deep-guards 1.0.1 → 1.0.3

package/tests/primitives.test.ts

@@ -1,91 +1,91 @@
-import {
-  isBoolean,
-  isFunction,
-  isInteger,
-  isNull,
-  isNumber,
-  isString,
-  isUndefined,
-  isUnknown,
-} from "../src/primitives";
-
-describe("isUnknown", () => {
-  it("succeeds for any value", () => {
-    expect(isUnknown("unknown")).toBe(true);
-  });
-});
-
-describe("isAnyFunction", () => {
-  it("succeeds for a 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);
-  });
-});
+import {
+  isBoolean,
+  isFunction,
+  isInteger,
+  isNull,
+  isNumber,
+  isString,
+  isUndefined,
+  isUnknown,
+} from "../src";
+
+describe("isUnknown", () => {
+  it("succeeds for any value", () => {
+    expect(isUnknown("unknown")).toBe(true);
+  });
+});
+
+describe("isAnyFunction", () => {
+  it("succeeds for a 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/tests/structures.test.ts

@@ -1,110 +1,128 @@
-import { isNumber, isString, isSymbol } from "../src/primitives";
-import {
-  isAnyArray,
-  isAnyRecord,
-  isArrayOf,
-  isObjectOf,
-  isRecordOf,
-} from "../src/structures";
-
-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("isObjectOf", () => {
-  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("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);
-    });
-  });
-});
+import {
+  isAnyArray,
+  isAnyRecord,
+  isArrayOf,
+  isBoolean,
+  isNumber,
+  isObjectOf,
+  isRecordOf,
+  isString,
+  isSymbol,
+  isTupleOf,
+} from "../src";
+
+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", () => {
+  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("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);
+    });
+  });
+});