deep-guards 1.0.1 → 1.0.3

package/src/structures.ts

@@ -1,83 +1,105 @@
-import { Guard, GuardSchemaOf } from "./types.js";
-
-type ObjectKey = string | number | symbol;
-
-function objectKeys<K extends ObjectKey>(obj: Record<K, unknown>): K[] {
-  return (Object.getOwnPropertyNames(obj) as K[]).concat(
-    Object.getOwnPropertySymbols(obj) as K[]
-  );
-}
-
-export const isAnyArray: Guard<unknown[]> = (value) => Array.isArray(value);
-
-export const isAnyRecord: Guard<Record<ObjectKey, unknown>> = (
-  value
-): value is Record<ObjectKey, unknown> =>
-  value != null && typeof value === "object" && !Array.isArray(value);
-
-export function isArrayOf<T>(guard: Guard<T>): Guard<T[]> {
-  if (typeof guard !== "function") {
-    throw new TypeError(
-      `isArrayOf expects a guard parameter. Got instead: ${guard}`
-    );
-  }
-
-  return (value): value is T[] => Array.isArray(value) && value.every(guard);
-}
-
-export function isRecordOf<K extends ObjectKey>(
-  keyGuard: Guard<K>
-): Guard<Record<K, unknown>>;
-export function isRecordOf<K extends ObjectKey, V>(
-  keyGuard: Guard<K>,
-  valueGuard: Guard<V>
-): Guard<Record<K, V>>;
-export function isRecordOf<K extends ObjectKey, V>(
-  keyGuard: Guard<K>,
-  valueGuard?: Guard<V>
-): Guard<Record<K, V>> {
-  if (typeof keyGuard !== "function") {
-    throw new TypeError(
-      `isRecordOf keyGuard expects a guard parameter. Got instead: ${keyGuard}`
-    );
-  } else if (valueGuard != null && typeof valueGuard !== "function") {
-    throw new TypeError(
-      `isRecordOf valueGuard expects an optional guard parameter. Got instead: ${valueGuard}`
-    );
-  }
-
-  return (value): value is Record<K, V> =>
-    value != null &&
-    typeof value === "object" &&
-    !Array.isArray(value) &&
-    objectKeys(value).every(
-      (key) => keyGuard(key) && (valueGuard?.(value[key]) ?? true)
-    );
-}
-
-export function isObjectOf<O extends object>(
-  schema: GuardSchemaOf<O>
-): O extends unknown[] ? never : Guard<O> {
-  const schemaKeys = objectKeys(schema);
-  const schemaUnknown = schema as unknown;
-  if (schemaKeys.length === 0) {
-    throw new Error("isObjectOf received an empty schema");
-  } else if (
-    schemaUnknown == null ||
-    typeof schemaUnknown !== "object" ||
-    Array.isArray(schemaUnknown) ||
-    schemaKeys.some((key) => typeof (schemaUnknown as O)[key] !== "function")
-  ) {
-    throw new TypeError(
-      `isObjectOf expects a guard schema. Got instead: ${schemaUnknown}`
-    );
-  }
-
-  return ((value): value is O =>
-    value != null &&
-    typeof value === "object" &&
-    !Array.isArray(value) &&
-    schemaKeys.every(
-      (key) => key in value && schema[key]((value as O)[key])
-    )) as O extends unknown[] ? never : Guard<O>;
-}
+import { Guard, GuardSchemaOf } from "./types";
+
+type ObjectKey = string | number | symbol;
+
+function objectKeys<K extends ObjectKey>(obj: Record<K, unknown>): K[] {
+  return (Object.getOwnPropertyNames(obj) as K[]).concat(
+    Object.getOwnPropertySymbols(obj) as K[]
+  );
+}
+
+export const isAnyArray: Guard<unknown[]> = (value) => Array.isArray(value);
+
+export const isAnyRecord: Guard<Record<ObjectKey, unknown>> = (
+  value
+): value is Record<ObjectKey, unknown> =>
+  value != null && typeof value === "object" && !Array.isArray(value);
+
+export function isArrayOf<T>(guard: Guard<T>): Guard<T[]> {
+  if (typeof guard !== "function") {
+    throw new TypeError(
+      `isArrayOf expects a guard parameter. Got instead: ${guard}`
+    );
+  }
+
+  return (value): value is T[] => Array.isArray(value) && value.every(guard);
+}
+
+export function isTupleOf<T extends readonly unknown[]>(
+  ...tupleGuards: GuardSchemaOf<T>
+): Guard<T> {
+  if (tupleGuards.some((guard) => typeof guard !== "function")) {
+    throw new TypeError(
+      `isTupleOf expects guard parameters. Got instead: ${JSON.stringify(
+        tupleGuards
+      )}`
+    );
+  }
+
+  return (value): value is T =>
+    Array.isArray(value) &&
+    value.length === tupleGuards.length &&
+    tupleGuards.every((guard, i) => guard(value[i]));
+}
+
+export function isRecordOf<K extends ObjectKey>(
+  keyGuard: Guard<K>
+): Guard<Record<K, unknown>>;
+export function isRecordOf<K extends ObjectKey, V>(
+  keyGuard: Guard<K>,
+  valueGuard: Guard<V>
+): Guard<Record<K, V>>;
+export function isRecordOf<K extends ObjectKey, V>(
+  keyGuard: Guard<K>,
+  valueGuard?: Guard<V>
+): Guard<Record<K, V>> {
+  if (typeof keyGuard !== "function") {
+    throw new TypeError(
+      `isRecordOf keyGuard expects a guard parameter. Got instead: ${keyGuard}`
+    );
+  } else if (valueGuard != null && typeof valueGuard !== "function") {
+    throw new TypeError(
+      `isRecordOf valueGuard expects an optional guard parameter. Got instead: ${valueGuard}`
+    );
+  }
+
+  return (value): value is Record<K, V> =>
+    value != null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    objectKeys(value).every(
+      (key) => keyGuard(key) && (valueGuard?.(value[key]) ?? true)
+    );
+}
+
+export function isObjectOf<O extends object>(
+  schema: GuardSchemaOf<O>
+): O extends unknown[] ? never : {} extends O ? never : Guard<O> {
+  if (schema == null || typeof schema !== "object") {
+    throw new TypeError(
+      `isObjectOf expects a guard schema object. Got instead: ${schema}`
+    );
+  }
+
+  const schemaKeys = objectKeys(schema);
+  if (
+    Array.isArray(schema) ||
+    schemaKeys.some((key) => typeof schema[key] !== "function")
+  ) {
+    throw new TypeError(
+      `isObjectOf expects a guard schema object. Got instead ${JSON.stringify(
+        schema
+      )}`
+    );
+  } else if (schemaKeys.length === 0) {
+    throw new Error("isObjectOf received an empty schema");
+  }
+
+  return ((value): value is O =>
+    value != null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    schemaKeys.every(
+      (key) => key in value && schema[key]((value as O)[key])
+    )) as O extends unknown[] ? never : {} extends O ? never : Guard<O>;
+}

package/tests/compound.test.ts

@@ -1,136 +1,152 @@
-import {
-  isExact,
-  isNot,
-  isNullable,
-  isNonNullable,
-  isOneOf,
-  isOptional,
-  isUnionOf,
-} from "../src/compound";
-import { isNumber, isString } from "../src/primitives";
-
-describe("isOptional", () => {
-  const guard = isOptional(isString);
-
-  it("succeeds for the expected type or undefined", () => {
-    expect(guard("foo")).toBe(true);
-    expect(guard(undefined)).toBe(true);
-  });
-
-  it("fails for any other value", () => {
-    expect(guard(null)).toBe(false);
-  });
-});
-
-describe("isNullable", () => {
-  const guard = isNullable(isString);
-
-  it("succeeds for the expected type, null, or undefined", () => {
-    expect(guard("foo")).toBe(true);
-    expect(guard(null)).toBe(true);
-    expect(guard(undefined)).toBe(true);
-  });
-
-  it("fails any other value", () => {
-    expect(guard(1)).toBe(false);
-  });
-});
-
-describe("isNonNullable", () => {
-  const guard = isNonNullable;
-
-  it("succeeds for the expected type, null, or undefined", () => {
-    expect(guard("foo")).toBe(true);
-    expect(guard(1)).toBe(true);
-  });
-
-  it("fails any other value", () => {
-    expect(guard(null)).toBe(false);
-    expect(guard(undefined)).toBe(false);
-  });
-});
-
-describe("isNot", () => {
-  const guard = isNot(isString);
-
-  it("succeeds for any other value", () => {
-    expect(guard(1)).toBe(true);
-  });
-
-  it("fails for the isNot type", () => {
-    expect(guard("foo")).toBe(false);
-  });
-});
-
-describe("isOneOf", () => {
-  const guard = isOneOf(1, "foo", true);
-
-  it("succeeds for all of the values", () => {
-    expect(guard(1)).toBe(true);
-    expect(guard("foo")).toBe(true);
-    expect(guard(true)).toBe(true);
-  });
-
-  expect(guard(2)).toBe(false);
-  it("fails any other value", () => {
-    expect(guard(null)).toBe(false);
-    expect(guard("bar")).toBe(false);
-    expect(guard(false)).toBe(false);
-  });
-});
-
-describe("isUnionOf", () => {
-  const guard = isUnionOf(isString, isNumber);
-  it("succeeds for the union types", () => {
-    expect(guard(1)).toBe(true);
-    expect(guard("foo")).toBe(true);
-  });
-
-  it("fails for any other type", () => {
-    expect(guard(true)).toBe(false);
-    expect(guard(null)).toBe(false);
-  });
-});
-
-describe("isExact", () => {
-  describe("deep", () => {
-    const guard = isExact(
-      { foo: "bar", hello: ["world", { key: "test" }] },
-      true
-    );
-
-    it("succeeds for the exact value", () => {
-      expect(guard({ foo: "bar", hello: ["world", { key: "test" }] })).toBe(
-        true
-      );
-    });
-
-    it("fails for any other value", () => {
-      expect(guard({ foo: "baz", hello: ["world", { key: "test" }] })).toBe(
-        false
-      );
-      expect(guard({ foo: "bar", hello: ["world", { key: "tester" }] })).toBe(
-        false
-      );
-      expect(guard(1)).toBe(false);
-    });
-  });
-
-  describe("shallow", () => {
-    const guard = isExact("foo", false);
-
-    it("succeeds for the exact value", () => {
-      expect(guard("foo")).toBe(true);
-    });
-
-    it("fails for deep equality", () => {
-      const guard = isExact(["foo", "bar", "baz", 1, 2, 3], false);
-      expect(guard(["foo", "bar", "baz", 1, 2, 3])).toBe(false);
-    });
-
-    it("fails for any other value", () => {
-      expect(guard("bar")).toBe(false);
-      expect(guard(1)).toBe(false);
-    });
-  });
-});
+import {
+  isExact,
+  isIntersectionOf,
+  isNonNullable,
+  isNot,
+  isNullable,
+  isNumber,
+  isOneOf,
+  isOptional,
+  isString,
+  isUnionOf,
+} from "../src";
+
+describe("isOptional", () => {
+  const guard = isOptional(isString);
+
+  it("succeeds for the expected type or undefined", () => {
+    expect(guard("foo")).toBe(true);
+    expect(guard(undefined)).toBe(true);
+  });
+
+  it("fails for any other value", () => {
+    expect(guard(null)).toBe(false);
+  });
+});
+
+describe("isNullable", () => {
+  const guard = isNullable(isString);
+
+  it("succeeds for the expected type, null, or undefined", () => {
+    expect(guard("foo")).toBe(true);
+    expect(guard(null)).toBe(true);
+    expect(guard(undefined)).toBe(true);
+  });
+
+  it("fails any other value", () => {
+    expect(guard(1)).toBe(false);
+  });
+});
+
+describe("isNonNullable", () => {
+  it("succeeds for the expected type, null, or undefined", () => {
+    expect(isNonNullable("foo")).toBe(true);
+    expect(isNonNullable(1)).toBe(true);
+  });
+
+  it("fails any other value", () => {
+    expect(isNonNullable(null)).toBe(false);
+    expect(isNonNullable(undefined)).toBe(false);
+  });
+});
+
+describe("isNot", () => {
+  const guard = isNot(isString);
+
+  it("succeeds for any other value", () => {
+    expect(guard(1)).toBe(true);
+  });
+
+  it("fails for the isNot type", () => {
+    expect(guard("foo")).toBe(false);
+  });
+});
+
+describe("isOneOf", () => {
+  const guard = isOneOf(1, "foo", true);
+
+  it("succeeds for all of the values", () => {
+    expect(guard(1)).toBe(true);
+    expect(guard("foo")).toBe(true);
+    expect(guard(true)).toBe(true);
+  });
+
+  expect(guard(2)).toBe(false);
+  it("fails any other value", () => {
+    expect(guard(null)).toBe(false);
+    expect(guard("bar")).toBe(false);
+    expect(guard(false)).toBe(false);
+  });
+});
+
+describe("isUnionOf", () => {
+  const guard = isUnionOf(isString, isNumber);
+  it("succeeds for the union types", () => {
+    expect(guard(1)).toBe(true);
+    expect(guard("foo")).toBe(true);
+  });
+
+  it("fails for any other type", () => {
+    expect(guard(true)).toBe(false);
+    expect(guard(null)).toBe(false);
+  });
+});
+
+describe("isIntersectionOf", () => {
+  const guard = isIntersectionOf(
+    isOneOf("foo", "bar", "baz"),
+    isExact("foo", false)
+  );
+
+  it("succeeds for the intersection", () => {
+    expect(guard("foo")).toBe(true);
+  });
+
+  it("fails for any other type", () => {
+    expect(guard("bar")).toBe(false);
+    expect(guard(1)).toBe(false);
+  });
+});
+
+describe("isExact", () => {
+  describe("deep", () => {
+    const guard = isExact(
+      { foo: "bar", hello: ["world", { key: "test" }] },
+      true
+    );
+
+    it("succeeds for the exact value", () => {
+      expect(guard({ foo: "bar", hello: ["world", { key: "test" }] })).toBe(
+        true
+      );
+    });
+
+    it("fails for any other value", () => {
+      expect(guard({ foo: "baz", hello: ["world", { key: "test" }] })).toBe(
+        false
+      );
+      expect(guard({ foo: "bar", hello: ["world", { key: "tester" }] })).toBe(
+        false
+      );
+      expect(guard(1)).toBe(false);
+    });
+  });
+
+  describe("shallow", () => {
+    const guard = isExact("foo", false);
+
+    it("succeeds for the exact value", () => {
+      expect(guard("foo")).toBe(true);
+    });
+
+    it("fails for deep equality", () => {
+      const guard = isExact(["foo", "bar", "baz", 1, 2, 3], false);
+      expect(guard(["foo", "bar", "baz", 1, 2, 3])).toBe(false);
+    });
+
+    it("fails for any other value", () => {
+      expect(guard("bar")).toBe(false);
+      expect(guard(1)).toBe(false);
+    });
+  });
+});

package/tests/macros.test.ts

@@ -0,0 +1,15 @@
+import { isDiscriminatedObjectOf, isObjectOf, isString } from "../src";
+
+describe("isDiscriminatedObjectOf", () => {
+  const guard = isDiscriminatedObjectOf("foo", isObjectOf({ bar: isString }));
+
+  it("succeeds for an object of the value", () => {
+    expect(guard({ type: "foo", bar: "baz" })).toBe(true);
+  });
+
+  it("fails for any other value", () => {
+    expect(guard({ type: "foo" })).toBe(false);
+    expect(guard({ bar: "baz" })).toBe(false);
+    expect(guard(1)).toBe(false);
+  });
+});