👍 isIntersectionOf allows anything other than isObjectOf

Fixes #68

Author: Milly

__snapshots__/is_test.ts.snap

@@ -229,6 +229,17 @@ snapshot[`isIntersectionOf<T> > returns properly named function 1`] = `
 })"
 `;
 
+snapshot[`isIntersectionOf<T> > returns properly named function 2`] = `
+"isString"
+`;
+
+snapshot[`isIntersectionOf<T> > returns properly named function 3`] = `
+"isIntersectionOf([
+  isFunction,
+  isObjectOf({b: isString})
+])"
+`;
+
 snapshot[`isRequiredOf<T> > returns properly named function 1`] = `
 "isObjectOf({
   a: isNumber,

_typeutil.ts

@@ -2,9 +2,9 @@ export type FlatType<T> = T extends Record<PropertyKey, unknown>
   ? { [K in keyof T]: FlatType<T[K]> }
   : T;
 
-export type UnionToIntersection<U> =
-  (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void)
-    ? I
-    : never;
+export type TupleToIntersection<T> = T extends readonly [] ? never
+  : T extends readonly [infer U] ? U
+  : T extends readonly [infer U, ...infer R] ? U & TupleToIntersection<R>
+  : never;
 
 export type Writable<T> = { -readonly [P in keyof T]: T[P] };

is.ts

@@ -1,4 +1,4 @@
-import type { FlatType, UnionToIntersection, Writable } from "./_typeutil.ts";
+import type { FlatType, TupleToIntersection, Writable } from "./_typeutil.ts";
 import {
   type GetMetadata,
   getMetadata,
@@ -1430,17 +1430,51 @@ export function isIntersectionOf<
   ],
 >(
   preds: T,
-): Predicate<IntersectionOf<T>> & WithMetadata<IsObjectOfMetadata> {
+): Predicate<IntersectionOf<T>> & WithMetadata<IsObjectOfMetadata>;
+export function isIntersectionOf<
+  T extends readonly [Predicate<unknown>],
+>(
+  preds: T,
+): T[0];
+export function isIntersectionOf<
+  T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]],
+>(
+  preds: T,
+): Predicate<IntersectionOf<T>> & WithMetadata<IsIntersectionOfMetadata>;
+export function isIntersectionOf<
+  T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]],
+>(
+  preds: T,
+):
+  | Predicate<unknown>
+  | Predicate<IntersectionOf<T>>
+    & WithMetadata<IsObjectOfMetadata | IsIntersectionOfMetadata> {
   const predObj = {};
-  preds.forEach((pred) => {
-    Object.assign(predObj, getPredicateFactoryMetadata(pred).args[0]);
+  const restPreds = preds.filter((pred) => {
+    const meta = getMetadata(pred);
+    if ((meta as IsObjectOfMetadata)?.name !== "isObjectOf") {
+      return true;
+    }
+    Object.assign(predObj, (meta as IsObjectOfMetadata).args[0]);
   });
-  return isObjectOf(predObj) as
-    & Predicate<IntersectionOf<T>>
-    & WithMetadata<IsObjectOfMetadata>;
+  if (restPreds.length < preds.length) {
+    restPreds.push(isObjectOf(predObj));
+  }
+  if (restPreds.length === 1) {
+    return restPreds[0];
+  }
+  return setPredicateFactoryMetadata(
+    (x: unknown): x is IntersectionOf<T> => restPreds.every((pred) => pred(x)),
+    { name: "isIntersectionOf", args: [preds] },
+  );
 }
 
-type IntersectionOf<T> = UnionToIntersection<UnionOf<T>>;
+type IntersectionOf<T> = TupleToIntersection<TupleOf<T>>;
+
+type IsIntersectionOfMetadata = {
+  name: "isIntersectionOf";
+  args: Parameters<typeof isIntersectionOf>;
+};
 
 /**
  * Return a type predicate function that returns `true` if the type of `x` is `Required<ObjectOf<T>>`.
@@ -1628,7 +1662,7 @@ export function isAllOf<
   return isIntersectionOf(preds);
 }
 
-type AllOf<T> = UnionToIntersection<OneOf<T>>;
+type AllOf<T> = IntersectionOf<T>;
 
 export const is = {
   AllOf: isAllOf,

is_test.ts

@@ -1477,24 +1477,62 @@ Deno.test("isIntersectionOf<T>", async (t) => {
         isObjectOf({ a: isNumber }),
         isObjectOf({ b: isString }),
       ]).name,
+      "Should return `isObjectOf`, if all predicates that",
+    );
+    await assertSnapshot(
+      t,
+      isIntersectionOf([
+        isString,
+      ]).name,
+      "Should return as is, if there is only one predicate",
+    );
+    await assertSnapshot(
+      t,
+      isIntersectionOf([
+        isFunction,
+        isObjectOf({ b: isString }),
+      ]).name,
     );
   });
   await t.step("returns proper type predicate", () => {
-    const preds = [
+    const objPreds = [
       isObjectOf({ a: isNumber }),
       isObjectOf({ b: isString }),
     ] as const;
+    const funcPreds = [
+      isFunction,
+      isObjectOf({ b: isString }),
+    ] as const;
     const a: unknown = { a: 0, b: "a" };
-    if (isIntersectionOf(preds)(a)) {
+    if (isIntersectionOf(objPreds)(a)) {
       assertType<Equal<typeof a, { a: number } & { b: string }>>(true);
     }
+    if (isIntersectionOf([isString])(a)) {
+      assertType<Equal<typeof a, string>>(true);
+    }
+    if (isIntersectionOf(funcPreds)(a)) {
+      assertType<
+        Equal<
+          typeof a,
+          & ((...args: unknown[]) => unknown)
+          & { b: string }
+        >
+      >(true);
+    }
   });
   await t.step("returns true on all of T", () => {
-    const preds = [
+    const objPreds = [
       isObjectOf({ a: isNumber }),
       isObjectOf({ b: isString }),
     ] as const;
-    assertEquals(isIntersectionOf(preds)({ a: 0, b: "a" }), true);
+    const funcPreds = [
+      isFunction,
+      isObjectOf({ b: isString }),
+    ] as const;
+    const f = Object.assign(() => void 0, { b: "a" });
+    assertEquals(isIntersectionOf(objPreds)({ a: 0, b: "a" }), true);
+    assertEquals(isIntersectionOf([isString])("a"), true);
+    assertEquals(isIntersectionOf(funcPreds)(f), true);
   });
   await t.step("returns false on non of T", async (t) => {
     const preds = [
@@ -1515,6 +1553,25 @@ Deno.test("isIntersectionOf<T>", async (t) => {
       excludeExamples: ["record"],
     });
   });
+  await t.step("returns false on non of T with any predicates", async (t) => {
+    const preds = [
+      isFunction,
+      isObjectOf({ b: isString }),
+    ] as const;
+    assertEquals(
+      isIntersectionOf(preds)({ b: "a" }),
+      false,
+      "Not a function object",
+    );
+    assertEquals(
+      isIntersectionOf(preds)(() => void 0),
+      false,
+      "Some properties does not exists in Function object",
+    );
+    await testWithExamples(t, isIntersectionOf(preds), {
+      excludeExamples: ["record"],
+    });
+  });
 });
 
 Deno.test("isRequiredOf<T>", async (t) => {