feat[isStrictOf]: discover symbol properties in pred.predObj

Author: Milly

is/__snapshots__/strict_of_test.ts.snap

@@ -17,3 +17,19 @@ snapshot[`isStrictOf<T> > returns properly named predicate function 3`] = `
   }))
 }))"
 `;
+
+snapshot[`isStrictOf<T> > with symbol properties > returns properly named predicate function 1`] = `
+"isStrictOf(isObjectOf({
+  a: isNumber,
+  Symbol(b): isString,
+  Symbol(c): isBoolean
+}))"
+`;
+
+snapshot[`isStrictOf<T> > with symbol properties > returns properly named predicate function 2`] = `
+"isStrictOf(isObjectOf({
+  a: isStrictOf(isObjectOf({
+    Symbol(b): isStrictOf(isObjectOf({Symbol(c): isBoolean}))
+  }))
+}))"
+`;

is/strict_of.ts

@@ -40,15 +40,18 @@ export function isStrictOf<
 ):
   & Predicate<T>
   & IsPredObj<P> {
-  const s = new Set(Object.keys(pred.predObj));
+  const s = new Set(getKeys(pred.predObj));
   return rewriteName(
     (x: unknown): x is T => {
       if (!pred(x)) return false;
-      // deno-lint-ignore no-explicit-any
-      const ks = Object.keys(x as any);
-      return ks.length <= s.size && ks.every((k) => s.has(k));
+      const ks = new Set(getKeys(x));
+      return ks.difference(s).size === 0;
     },
     "isStrictOf",
     pred,
   ) as Predicate<T> & IsPredObj<P>;
 }
+
+function getKeys(o: Record<PropertyKey, unknown>) {
+  return [...Object.keys(o), ...Object.getOwnPropertySymbols(o)];
+}

is/strict_of_test.ts

@@ -155,4 +155,112 @@ Deno.test("isStrictOf<T>", async (t) => {
       }
     });
   });
+
+  await t.step("with symbol properties", async (t) => {
+    const b = Symbol("b");
+    const c = Symbol("c");
+    const predObj = {
+      a: is.Number,
+      [b]: is.UnionOf([is.String, is.Undefined]),
+      [c]: as.Optional(is.Boolean),
+    };
+    await t.step("returns properly named predicate function", async (t) => {
+      await assertSnapshot(
+        t,
+        isStrictOf(
+          is.ObjectOf({ a: is.Number, [b]: is.String, [c]: is.Boolean }),
+        )
+          .name,
+      );
+      await assertSnapshot(
+        t,
+        isStrictOf(
+          is.ObjectOf({
+            a: isStrictOf(
+              is.ObjectOf({
+                [b]: isStrictOf(is.ObjectOf({ [c]: is.Boolean })),
+              }),
+            ),
+          }),
+        ).name,
+      );
+    });
+
+    await t.step("returns true on T object", () => {
+      assertEquals(
+        isStrictOf(is.ObjectOf(predObj))({ a: 0, [b]: "a", [c]: true }),
+        true,
+      );
+      assertEquals(
+        isStrictOf(is.ObjectOf(predObj))({ a: 0, [b]: "a" }),
+        true,
+        "Object does not have an optional property",
+      );
+      assertEquals(
+        isStrictOf(is.ObjectOf(predObj))({ a: 0, [b]: "a", [c]: undefined }),
+        true,
+        "Object has `undefined` as value of optional property",
+      );
+    });
+
+    await t.step("returns false on non T object", () => {
+      assertEquals(
+        isStrictOf(is.ObjectOf(predObj))({ a: 0, [b]: "a", [c]: "" }),
+        false,
+        "Object have a different type property",
+      );
+      assertEquals(
+        isStrictOf(is.ObjectOf(predObj))({ a: 0, [b]: "a", [c]: null }),
+        false,
+        "Object has `null` as value of optional property",
+      );
+      assertEquals(
+        isStrictOf(is.ObjectOf(predObj))({
+          a: 0,
+          [b]: "a",
+          [c]: true,
+          d: "invalid",
+        }),
+        false,
+        "Object have an unknown property",
+      );
+      assertEquals(
+        isStrictOf(is.ObjectOf(predObj))({
+          a: 0,
+          [b]: "a",
+          [c]: true,
+          [Symbol("d")]: "invalid",
+        }),
+        false,
+        "Object have an unknown symbol property",
+      );
+      assertEquals(
+        isStrictOf(is.ObjectOf(predObj))({
+          a: 0,
+          [b]: "a",
+          d: "invalid",
+        }),
+        false,
+        "Object have the same number of properties but an unknown property exists",
+      );
+      assertEquals(
+        isStrictOf(is.ObjectOf(predObj))({
+          a: 0,
+          [b]: "a",
+          [Symbol("d")]: "invalid",
+        }),
+        false,
+        "Object have the same number of properties but an unknown symbol property exists",
+      );
+    });
+
+    await t.step("predicated type is correct", () => {
+      const a: unknown = { a: 0, [b]: "a" };
+      if (isStrictOf(is.ObjectOf(predObj))(a)) {
+        assertType<
+          Equal<typeof a, { a: number; [b]: string | undefined; [c]?: boolean }>
+        >(true);
+      }
+    });
+  });
 });