feat[isPickOf]: copy symbol properties from pred.predObj

Author: Milly

is/__snapshots__/pick_of_test.ts.snap

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

is/pick_of.ts

@@ -43,11 +43,15 @@ export function isPickOf<
 ):
   & Predicate<FlatType<Pick<T, K>>>
   & IsPredObj<P> {
-  const s = new Set(keys);
-  const predObj = Object.fromEntries(
-    Object.entries(pred.predObj).filter(([k]) => s.has(k as K)),
-  );
-  return isObjectOf(predObj) as
+  const omitKeys = new Set([
+    ...Object.keys(pred.predObj),
+    ...Object.getOwnPropertySymbols(pred.predObj),
+  ]).difference(new Set(keys));
+  const predObj = { ...pred.predObj };
+  for (const key of omitKeys) {
+    delete predObj[key];
+  }
+  return isObjectOf(predObj as Record<PropertyKey, Predicate<unknown>>) as
     & Predicate<FlatType<Pick<T, K>>>
     & IsPredObj<P>;
 }

is/pick_of_test.ts

@@ -51,4 +51,54 @@ Deno.test("isPickOf<T, K>", async (t) => {
       >(true);
     }
   });
+
+  await t.step("with symbol properties", async (t) => {
+    const b = Symbol("b");
+    const c = Symbol("c");
+    const pred = is.ObjectOf({
+      a: is.Number,
+      [b]: is.String,
+      [c]: is.Boolean,
+    });
+
+    await t.step("returns properly named predicate function", async (t) => {
+      await assertSnapshot(t, isPickOf(pred, ["a", c]).name);
+      await assertSnapshot(t, isPickOf(isPickOf(pred, ["a", c]), [c]).name);
+    });
+
+    await t.step("returns true on Pick<T, K> object", () => {
+      assertEquals(
+        isPickOf(pred, ["a", c])({ a: 0, [b]: undefined, [c]: true }),
+        true,
+      );
+      assertEquals(isPickOf(pred, ["a"])({ a: 0 }), true);
+    });
+
+    await t.step("returns false on non Pick<T, K> object", () => {
+      assertEquals(
+        isPickOf(pred, ["a", c])("a"),
+        false,
+        "Value is not an object",
+      );
+      assertEquals(
+        isPickOf(pred, ["a", c])({ a: 0, [b]: "a", [c]: "" }),
+        false,
+        "Object have a different type property",
+      );
+    });
+
+    await t.step("predicated type is correct", () => {
+      const a: unknown = { a: 0, [b]: "a", [c]: true };
+      if (isPickOf(pred, ["a", c])(a)) {
+        assertType<
+          Equal<typeof a, { a: number; [c]: boolean }>
+        >(true);
+      }
+      if (isPickOf(isPickOf(pred, ["a", c]), ["a"])(a)) {
+        assertType<
+          Equal<typeof a, { a: number }>
+        >(true);
+      }
+    });
+  });
 });