🐛 Fix invalid type narrowed by isOneOf

Close #49

Because of this bug fix, `isOneOf` and `isAllOf` now requires a readonly
array of predicates.
Thus users may face some type errors when updating this module. In that
case, just add `as const` to the array of predicates.

Author: lambdalisue

is.ts

@@ -958,7 +958,9 @@ export function isLiteralOneOf<T extends readonly Primitive[]>(
   );
 }
 
-export type OneOf<T> = T extends Predicate<infer U>[] ? U : never;
+export type OneOf<T> = T extends readonly [Predicate<infer U>, ...infer R]
+  ? U | OneOf<R>
+  : never;
 
 /**
  * Return a type predicate function that returns `true` if the type of `x` is `OneOf<T>`.
@@ -975,8 +977,25 @@ export type OneOf<T> = T extends Predicate<infer U>[] ? U : never;
  *   const _: number | string | boolean = a;
  * }
  * ```
+ *
+ * Depending on the version of TypeScript and how values are provided, it may be necessary to add `as const` to the array
+ * used as `preds`. If a type error occurs, try adding `as const` as follows:
+ *
+ * ```ts
+ * import { is } from "https://deno.land/x/unknownutil@$MODULE_VERSION/mod.ts";
+ *
+ * const preds = [is.Number, is.String, is.Boolean] as const;
+ * const isMyType = is.OneOf(preds);
+ * const a: unknown = 0;
+ * if (isMyType(a)) {
+ *   // a is narrowed to number | string | boolean
+ *   const _: number | string | boolean = a;
+ * }
+ * ```
  */
-export function isOneOf<T extends readonly Predicate<unknown>[]>(
+export function isOneOf<
+  T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]],
+>(
   preds: T,
 ): Predicate<OneOf<T>> {
   return Object.defineProperties(
@@ -1009,12 +1028,32 @@ export type AllOf<T> = UnionToIntersection<OneOf<T>>;
  * ]);
  * const a: unknown = { a: 0, b: "a" };
  * if (isMyType(a)) {
- *   // a is narrowed to { a: number; b: string }
- *   const _: { a: number; b: string } = a;
+ *   // a is narrowed to { a: number } & { b: string }
+ *   const _: { a: number } & { b: string } = a;
+ * }
+ * ```
+ *
+ * Depending on the version of TypeScript and how values are provided, it may be necessary to add `as const` to the array
+ * used as `preds`. If a type error occurs, try adding `as const` as follows:
+ *
+ * ```ts
+ * import { is } from "https://deno.land/x/unknownutil@$MODULE_VERSION/mod.ts";
+ *
+ * const preds = [
+ *   is.ObjectOf({ a: is.Number }),
+ *   is.ObjectOf({ b: is.String }),
+ * ] as const
+ * const isMyType = is.AllOf(preds);
+ * const a: unknown = { a: 0, b: "a" };
+ * if (isMyType(a)) {
+ *   // a is narrowed to { a: number } & { b: string }
+ *   const _: { a: number } & { b: string } = a;
  * }
  * ```
  */
-export function isAllOf<T extends readonly Predicate<unknown>[]>(
+export function isAllOf<
+  T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]],
+>(
   preds: T,
 ): Predicate<AllOf<T>> {
   return Object.defineProperties(

is_test.ts

@@ -934,7 +934,7 @@ Deno.test("isOneOf<T>", async (t) => {
     await assertSnapshot(t, isOneOf([isNumber, isString, isBoolean]).name);
   });
   await t.step("returns proper type predicate", () => {
-    const preds = [isNumber, isString, isBoolean];
+    const preds = [isNumber, isString, isBoolean] as const;
     const a: unknown = [0, "a", true];
     if (isOneOf(preds)(a)) {
       assertType<Equal<typeof a, number | string | boolean>>(true);
@@ -945,20 +945,20 @@ Deno.test("isOneOf<T>", async (t) => {
     const isBar = isObjectOf({ foo: isString, bar: isNumber });
     type Foo = PredicateType<typeof isFoo>;
     type Bar = PredicateType<typeof isBar>;
-    const preds = [isFoo, isBar];
+    const preds = [isFoo, isBar] as const;
     const a: unknown = [0, "a", true];
     if (isOneOf(preds)(a)) {
       assertType<Equal<typeof a, Foo | Bar>>(true);
     }
   });
   await t.step("returns true on one of T", () => {
-    const preds = [isNumber, isString, isBoolean];
+    const preds = [isNumber, isString, isBoolean] as const;
     assertEquals(isOneOf(preds)(0), true);
     assertEquals(isOneOf(preds)("a"), true);
     assertEquals(isOneOf(preds)(true), true);
   });
   await t.step("returns false on non of T", async (t) => {
-    const preds = [isNumber, isString, isBoolean];
+    const preds = [isNumber, isString, isBoolean] as const;
     await testWithExamples(t, isOneOf(preds), {
       excludeExamples: ["number", "string", "boolean"],
     });
@@ -979,7 +979,7 @@ Deno.test("isAllOf<T>", async (t) => {
     const preds = [
       is.ObjectOf({ a: is.Number }),
       is.ObjectOf({ b: is.String }),
-    ];
+    ] as const;
     const a: unknown = { a: 0, b: "a" };
     if (isAllOf(preds)(a)) {
       assertType<Equal<typeof a, { a: number } & { b: string }>>(true);
@@ -989,14 +989,14 @@ Deno.test("isAllOf<T>", async (t) => {
     const preds = [
       is.ObjectOf({ a: is.Number }),
       is.ObjectOf({ b: is.String }),
-    ];
+    ] as const;
     assertEquals(isAllOf(preds)({ a: 0, b: "a" }), true);
   });
   await t.step("returns false on non of T", async (t) => {
     const preds = [
       is.ObjectOf({ a: is.Number }),
       is.ObjectOf({ b: is.String }),
-    ];
+    ] as const;
     assertEquals(
       isAllOf(preds)({ a: 0, b: 0 }),
       false,