deep-guards 1.3.0 → 1.4.0

package/src/compound.ts

@@ -1,197 +0,0 @@
-import { objectKeys } from "./helpers.js";
-
-import type { GuardSchemaOf, ObjectKey } from "./helpers.js";
-import type { Guard } from "./types.js";
-
-export function isOptional<T>(guard: Guard<T>): Guard<T | undefined> {
-  if (typeof guard !== "function") {
-    throw new TypeError(
-      `isOptional expects a guard parameter. Got instead: ${guard}`,
-    );
-  }
-
-  return (value): value is T | undefined => value === undefined || guard(value);
-}
-
-export function isNullable<T>(guard: Guard<T>): Guard<T | null | undefined> {
-  if (typeof guard !== "function") {
-    throw new TypeError(
-      `isNullable expects a guard parameter. Got instead: ${guard}`,
-    );
-  }
-
-  return (value: unknown): value is T | null | undefined =>
-    value == null || guard(value);
-}
-
-export function isNonNullable<T extends NonNullable<unknown>>(
-  value: T | null | undefined,
-): value is T {
-  return value != null;
-}
-
-export function isNot<const N>(guard: Guard<N>) {
-  if (typeof guard !== "function") {
-    throw new TypeError(
-      `isNot expects a guard parameter. Got instead: ${guard}`,
-    );
-  }
-
-  return <const T>(value: T | N): value is T => !guard(value);
-}
-
-export function isOneOf<
-  const T extends (string | number | boolean | symbol | null | undefined)[],
->(...values: T): Guard<T[number]> {
-  const valueSet = new Set(values);
-  return (value) => (valueSet.has as Guard<T[number]>)(value);
-}
-
-export function isUnionOf<T extends readonly unknown[]>(
-  ...guards: GuardSchemaOf<T>
-): Guard<T[number]> {
-  if (guards.every((guard) => typeof guard !== "function")) {
-    throw new TypeError(
-      `isUnionOf expects N guard parameters. Got instead: ${guards}`,
-    );
-  }
-
-  return (value): value is T => guards.some((guard) => guard(value));
-}
-
-type ArrayToIntersection<A extends readonly unknown[]> = A extends [
-  infer T,
-  ...infer R,
-]
-  ? T & ArrayToIntersection<R>
-  : unknown;
-
-export function isIntersectionOf<T extends readonly unknown[]>(
-  ...guards: GuardSchemaOf<T>
-): Guard<ArrayToIntersection<T>> {
-  if (guards.every((guard) => typeof guard !== "function")) {
-    throw new TypeError(
-      `isIntersectionOf expects N guard parameters. Got instead: ${guards}`,
-    );
-  }
-
-  return (value): value is ArrayToIntersection<T> =>
-    guards.every((guard) => guard(value));
-}
-
-export function isExact<const T>(expected: T): Guard<T> {
-  // Primitive checks
-  if (typeof expected !== "object" || expected === null) {
-    // NaN check
-    if (typeof expected === "number" && Number.isNaN(expected)) {
-      return (value): value is T =>
-        typeof value === "number" && Number.isNaN(value);
-    }
-    return (value): value is T => value === expected;
-  }
-
-  // Date checks
-  if (expected instanceof Date) {
-    return (value): value is T =>
-      value instanceof Date && expected.getTime() === value.getTime();
-  }
-
-  // RegExp checks
-  if (expected instanceof RegExp) {
-    return (value): value is T =>
-      value instanceof RegExp &&
-      expected.source === value.source &&
-      expected.flags === value.flags;
-  }
-
-  // Error checks
-  if (expected instanceof Error) {
-    return (value): value is T =>
-      value instanceof Error &&
-      expected.name === value.name &&
-      expected.message === value.message;
-  }
-
-  // Map checks
-  if (expected instanceof Map) {
-    const guards = Array.from(
-      expected
-        .entries()
-        .map(([k, v]) => [k, isExact(v)] as [string, Guard<unknown>]),
-    );
-
-    return (value): value is T =>
-      value instanceof Map &&
-      expected.size === value.size &&
-      guards.every(([k, guard]) => value.has(k) && guard(value.get(k)));
-  }
-
-  // Set checks
-  if (expected instanceof Set) {
-    const guards = new Map(
-      expected.values().map((v): [unknown, Guard<unknown>] => [v, isExact(v)]),
-    );
-
-    return (value): value is T =>
-      value instanceof Set &&
-      expected.size === value.size &&
-      value.values().every((v) => guards.get(v)?.(v));
-  }
-
-  // Typed Array checks
-  if (ArrayBuffer.isView(expected) && !(expected instanceof DataView)) {
-    const guards = Array.from(expected as unknown as ArrayLike<number>).map(
-      (v) => isExact(v),
-    );
-
-    return (value): value is T =>
-      ArrayBuffer.isView(value) &&
-      !(value instanceof DataView) &&
-      expected.constructor === value.constructor &&
-      (expected as unknown as ArrayLike<number>).length ===
-        (value as unknown as ArrayLike<number>).length &&
-      guards.every((guard, i) =>
-        guard((value as unknown as ArrayLike<number>)[i]),
-      );
-  }
-
-  // Array checks
-  if (Array.isArray(expected)) {
-    const guards = expected.map((v) => isExact(v));
-
-    return (value): value is T =>
-      Array.isArray(value) &&
-      expected.length === value.length &&
-      guards.every((guard, i) => guard(value[i]));
-  }
-
-  // Object checks
-  const guards = objectKeys(expected).map(
-    (k) => [k, isExact(expected[k])] as [ObjectKey, Guard<unknown>],
-  );
-
-  function objectEntriesChecks(value: object): value is T & object {
-    const valueKeys = new Set(objectKeys(value) as ObjectKey[]);
-    return (
-      guards.length === valueKeys.size &&
-      guards.every(
-        ([k, guard]) =>
-          valueKeys.has(k) && guard((value as Record<ObjectKey, unknown>)[k]),
-      )
-    );
-  }
-
-  return (value): value is T =>
-    typeof value === "object" &&
-    value != null &&
-    !Array.isArray(value) &&
-    objectKeys(value).length === guards.length &&
-    objectEntriesChecks(value);
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isInstance<C extends abstract new (...args: any) => unknown>(
-  cls: C,
-): Guard<InstanceType<C>> {
-  return (value): value is InstanceType<C> => value instanceof cls;
-}

package/src/errors.ts

@@ -1,17 +0,0 @@
-import type { Guard } from "./types.js";
-
-export class GuardError extends Error {
-  name = "GuardError";
-}
-
-export function guardOrThrow<T>(
-  value: unknown,
-  guard: Guard<T>,
-  hint?: string,
-): T {
-  if (guard(value)) {
-    return value;
-  } else {
-    throw new GuardError(hint ?? "Guard error");
-  }
-}

package/src/helpers.ts

@@ -1,22 +0,0 @@
-import type { Guard } from "./types.js";
-
-export type GuardSchemaOf<O extends object> = {
-  [K in keyof O]: Guard<O[K]>;
-};
-
-export type ObjectKey = string | number | symbol;
-
-export const objectKeys = <K extends ObjectKey>(obj: Record<K, unknown>): K[] =>
-  (Object.getOwnPropertyNames(obj) as K[]).concat(
-    Object.getOwnPropertySymbols(obj) as K[],
-  );
-
-export function omit<O extends NonNullable<unknown>>(
-  obj: O,
-  key: keyof O,
-): { [K in keyof O as K extends typeof key ? never : K]: O[K] } {
-  const omitted = { ...obj };
-  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-  delete omitted[key];
-  return omitted;
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from "./compound.js";
-export * from "./errors.js";
-export * from "./macros.js";
-export * from "./primitives.js";
-export * from "./structures.js";
-export * from "./types.js";

package/src/macros.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { isDiscriminatedObjectOf } from "./macros.ts";
-import { isString } from "./primitives.ts";
-import { isObjectOf } from "./structures.ts";
-
-describe("isDiscriminatedObjectOf", () => {
-  describe("no key override", () => {
-    const guard = isDiscriminatedObjectOf(
-      "foo",
-      isObjectOf({ bar: isString }, true),
-    );
-
-    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);
-    });
-  });
-
-  describe("overriding key", () => {
-    const guard = isDiscriminatedObjectOf(
-      "foo",
-      isObjectOf({ bar: isString }, true),
-      "test",
-    );
-
-    it("succeeds for an object of the value", () => {
-      expect(guard({ test: "foo", bar: "baz" })).toBe(true);
-    });
-
-    it("fails for any other value", () => {
-      expect(guard({ test: "foo" })).toBe(false);
-      expect(guard({ bar: "baz" })).toBe(false);
-      expect(guard(1)).toBe(false);
-    });
-  });
-});

package/src/macros.ts

@@ -1,30 +0,0 @@
-import { isExact } from "./compound.js";
-import { omit } from "./helpers.js";
-import { isObjectOf } from "./structures.js";
-
-import type { ObjectKey } from "./helpers.js";
-import type { Guard } from "./types.js";
-
-export function isDiscriminatedObjectOf<
-  const T extends string,
-  O extends object,
->(value: T, guard: Guard<O>): Guard<{ type: T } & O>;
-export function isDiscriminatedObjectOf<
-  const T extends string,
-  O extends object,
-  const K extends ObjectKey,
->(value: T, guard: Guard<O>, key: K): Guard<{ [S in K]: T } & O>;
-export function isDiscriminatedObjectOf<
-  const T extends string,
-  O extends object,
->(
-  value: T,
-  guard: Guard<O>,
-  key: ObjectKey = "type",
-): Guard<Record<ObjectKey, T> & O> {
-  const discriminatorGuard = isObjectOf({ [key]: isExact(value) }) as Guard<
-    Record<ObjectKey, T>
-  >;
-  return (value): value is Record<ObjectKey, T> & O =>
-    discriminatorGuard(value) && guard(omit(value, key));
-}

package/src/primitives.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  isBoolean,
-  isFunction,
-  isInteger,
-  isNull,
-  isNumber,
-  isString,
-  isUndefined,
-  isUnknown,
-} from "./primitives.ts";
-
-describe("isUnknown", () => {
-  it("succeeds for any value", () => {
-    expect(isUnknown("unknown")).toBe(true);
-  });
-});
-
-describe("isAnyFunction", () => {
-  it("succeeds for a function", () => {
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    expect(isFunction(() => {})).toBe(true);
-  });
-
-  it("fails for any other value", () => {
-    expect(isFunction(1)).toBe(false);
-  });
-});
-
-describe("isNull", () => {
-  it("succeeds for null", () => {
-    expect(isNull(null)).toBe(true);
-  });
-
-  it("fails for any other value", () => {
-    expect(isNull(undefined)).toBe(false);
-  });
-});
-
-describe("isUndefined", () => {
-  it("succeeds for undefined", () => {
-    expect(isUndefined(undefined)).toBe(true);
-  });
-
-  it("fails for any other value", () => {
-    expect(isUndefined(null)).toBe(false);
-  });
-});
-
-describe("isNumber", () => {
-  it("succeeds for a number", () => {
-    expect(isNumber(1.23)).toBe(true);
-  });
-
-  it("fails for any other type", () => {
-    expect(isNumber("foo")).toBe(false);
-  });
-});
-
-describe("isInteger", () => {
-  it("succeeds for an integer", () => {
-    expect(isInteger(1)).toBe(true);
-  });
-
-  it("fails for a non-integer", () => {
-    expect(isInteger(1.23)).toBe(false);
-  });
-
-  it("fails for any other type", () => {
-    expect(isInteger("foo")).toBe(false);
-  });
-});
-
-describe("isString", () => {
-  it("succeeds for a string", () => {
-    expect(isString("Foo bar")).toBe(true);
-  });
-
-  it("fails for other types", () => {
-    expect(isString(true)).toBe(false);
-  });
-});
-
-describe("isBoolean", () => {
-  it("succeeds for a boolean", () => {
-    expect(isBoolean(true)).toBe(true);
-    expect(isBoolean(false)).toBe(true);
-  });
-
-  it("fails for other types", () => {
-    expect(isBoolean("foo")).toBe(false);
-  });
-});

package/src/primitives.ts

@@ -1,25 +0,0 @@
-import type { Guard } from "./types.js";
-
-export const isUnknown: Guard<unknown> = (_value): _value is unknown => true;
-
-export const isNull: Guard<null> = (value) => value === null;
-
-export const isUndefined: Guard<undefined> = (value) => value === undefined;
-
-export const isNumber: Guard<number> = (value) => typeof value === "number";
-
-export const isInteger: Guard<number> = (value): value is number =>
-  Number.isInteger(value);
-
-export const isString: Guard<string> = (value) => typeof value === "string";
-
-export const isSymbol: Guard<symbol> = (value) => typeof value === "symbol";
-
-export const isBoolean: Guard<boolean> = (value) =>
-  value === true || value === false;
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isFunction: Guard<(...args: any[]) => unknown> = (
-  value,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-): value is (...args: any[]) => unknown => typeof value === "function";

package/src/structures.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { isBoolean, isNumber, isString, isSymbol } from "./primitives.ts";
-import {
-  isAnyArray,
-  isAnyRecord,
-  isArrayOf,
-  isObjectOf,
-  isRecordOf,
-  isTupleOf,
-} from "./structures.ts";
-
-describe("isAnyArray", () => {
-  it("succeeds for an array", () => {
-    expect(isAnyArray([])).toBe(true);
-    expect(isAnyArray(["foo", 1, true, null])).toBe(true);
-  });
-
-  it("fails for any other value", () => {
-    expect(isAnyArray({})).toBe(false);
-    expect(isAnyArray(1)).toBe(false);
-  });
-});
-
-describe("isAnyRecord", () => {
-  it("succeeds for a record", () => {
-    expect(isAnyRecord({})).toBe(true);
-    expect(isAnyRecord({ foo: "bar", baz: 1 })).toBe(true);
-  });
-
-  it("fails for any other value", () => {
-    expect(isAnyRecord([])).toBe(false);
-    expect(isAnyRecord(1)).toBe(false);
-  });
-});
-
-describe("isArrayOf", () => {
-  const guard = isArrayOf(isString);
-
-  it("succeeds for an array of the value", () => {
-    expect(guard([])).toBe(true);
-    expect(guard(["foo", "bar", "baz"])).toBe(true);
-  });
-
-  it("fails for any other value", () => {
-    expect(guard([1, 2, 3])).toBe(false);
-    expect(guard(["foo", "bar", null])).toBe(false);
-    expect(guard(1)).toBe(false);
-  });
-});
-
-describe("isTupleOf", () => {
-  const guard = isTupleOf(isNumber, isString, isBoolean);
-
-  it("succeeds for an array of the value", () => {
-    expect(guard([1, "foo", true])).toBe(true);
-  });
-
-  it("fails for any other value", () => {
-    expect(guard([1, "foo", true, null])).toBe(false);
-    expect(guard([1, "foo"])).toBe(false);
-    expect(guard(1)).toBe(false);
-  });
-});
-
-describe("isObjectOf", () => {
-  describe("leaky", () => {
-    const barSymbol = Symbol("bar");
-    const guard = isObjectOf({
-      foo: isString,
-      [barSymbol]: isNumber,
-      baz: isObjectOf({
-        qux: isSymbol,
-      }),
-    });
-
-    it("succeeds for an object of the value", () => {
-      expect(
-        guard({
-          foo: "hello",
-          [barSymbol]: 1,
-          baz: { qux: Symbol("world!") },
-          quux: "this should not be checked",
-        }),
-      ).toBe(true);
-    });
-
-    it("fails for any other value", () => {
-      expect(
-        guard({
-          foo: "hello",
-          [barSymbol]: "FAIL",
-          baz: { qux: Symbol("world!") },
-        }),
-      ).toBe(false);
-      expect(guard(1)).toBe(false);
-    });
-  });
-
-  describe("exact keys", () => {
-    const barSymbol = Symbol("bar");
-    const guard = isObjectOf(
-      {
-        foo: isString,
-        [barSymbol]: isNumber,
-        baz: isObjectOf({
-          qux: isSymbol,
-        }),
-      },
-      true,
-    );
-
-    it("succeeds for an object of the value", () => {
-      expect(
-        guard({
-          foo: "hello",
-          [barSymbol]: 1,
-          baz: { qux: Symbol("world!") },
-        }),
-      ).toBe(true);
-    });
-
-    it("fails for any other value", () => {
-      expect(
-        guard({
-          foo: "hello",
-          [barSymbol]: 1,
-          baz: { qux: Symbol("world!") },
-          quux: "this should be checked",
-        }),
-      ).toBe(false);
-      expect(
-        guard({
-          foo: "hello",
-          [barSymbol]: "FAIL",
-          baz: { qux: Symbol("world!") },
-        }),
-      ).toBe(false);
-      expect(guard(1)).toBe(false);
-    });
-  });
-});
-
-describe("isRecordOf", () => {
-  describe("with valueGuard", () => {
-    const guard = isRecordOf(isString, isNumber);
-
-    it("succeeds for a record of the key/value types", () => {
-      expect(guard({})).toBe(true);
-      expect(guard({ foo: 1, bar: 2 })).toBe(true);
-    });
-
-    it("fails for any other value", () => {
-      expect(guard({ foo: "bar", baz: 1 })).toBe(false);
-      expect(guard(1)).toBe(false);
-    });
-  });
-
-  describe("without valueGuard", () => {
-    const guard = isRecordOf(isString);
-
-    it("succeeds for a record with the key type", () => {
-      expect(guard({})).toBe(true);
-      expect(guard({ foo: 1, bar: "baz" })).toBe(true);
-    });
-
-    it("fails for any other value", () => {
-      expect(guard({ 1: "foo", [Symbol("bar")]: 1 })).toBe(false);
-      expect(guard(1)).toBe(false);
-    });
-  });
-});