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

Author: Milly

is/__snapshots__/omit_of_test.ts.snap

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

is/omit_of.ts

@@ -43,11 +43,11 @@ export function isOmitOf<
 ):
   & Predicate<FlatType<Omit<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 predObj = { ...pred.predObj };
+  for (const key of keys) {
+    delete predObj[key];
+  }
+  return isObjectOf(predObj as Record<PropertyKey, Predicate<unknown>>) as
     & Predicate<FlatType<Omit<T, K>>>
     & IsPredObj<P>;
 }

is/omit_of_test.ts

@@ -54,4 +54,57 @@ Deno.test("isOmitOf<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) => {
+      assertEquals(typeof isOmitOf(pred, [b]), "function");
+      await assertSnapshot(t, isOmitOf(pred, [b]).name);
+      await assertSnapshot(t, isOmitOf(isOmitOf(pred, [b]), [c]).name);
+    });
+
+    await t.step("returns true on Omit<T, K> object", () => {
+      assertEquals(
+        isOmitOf(pred, [b])({ a: 0, [b]: undefined, [c]: true }),
+        true,
+      );
+      assertEquals(isOmitOf(pred, [b, c])({ a: 0 }), true);
+    });
+
+    await t.step("returns false on non Omit<T, K> object", () => {
+      assertEquals(
+        isOmitOf(pred, [b])("a"),
+        false,
+        "Value is not an object",
+      );
+      assertEquals(
+        isOmitOf(pred, [b])({ a: 0, [b]: "a", [c]: "" }),
+        false,
+        "Object have a different type property",
+      );
+    });
+
+    await t.step("predicated type is correct", () => {
+      const x: unknown = { a: 0, [b]: "a", [c]: true };
+
+      if (isOmitOf(pred, [b])(x)) {
+        assertType<
+          Equal<typeof x, { a: number; [c]: boolean }>
+        >(true);
+      }
+
+      if (isOmitOf(isOmitOf(pred, [b]), [c])(x)) {
+        assertType<
+          Equal<typeof x, { a: number }>
+        >(true);
+      }
+    });
+  });
 });