👍 Improve performance of isObjectOf<T>

Before to this commit, the benchmark result was

  is.ObjectOf                   335.74 ns/iter   2,978,453.8 (307.15 ns … 694.14 ns) 337.23 ns 391.01 ns 694.14 ns
  is.ObjectOf (strict)          406.31 ns/iter   2,461,182.4  (386.4 ns … 453.27 ns) 413.72 ns 442.96 ns 453.27 ns
  is.ObjectOf (pre)             179.34 ns/iter   5,575,896.2   (167.5 ns … 196.1 ns) 185.86 ns 195.85 ns 195.88 ns
  is.ObjectOf (pre, strict)     205.37 ns/iter   4,869,263.2 (199.38 ns … 225.96 ns) 207.86 ns 224.33 ns 225.62 ns

And after this commit

  is.ObjectOf                   150.21 ns/iter   6,657,313.1 (144.75 ns … 161.07 ns) 152.62 ns 159.53 ns 160.82 ns
  is.ObjectOf (strict)          240.33 ns/iter   4,160,893.5 (233.04 ns … 276.14 ns) 241.96 ns 273.35 ns 273.55 ns
  is.ObjectOf (pre)              112.1 ns/iter   8,920,598.1 (108.72 ns … 124.09 ns) 112.92 ns 118.22 ns 122.38 ns
  is.ObjectOf (pre, strict)     137.05 ns/iter   7,296,588.7 (130.81 ns … 168.84 ns) 139.82 ns 151.59 ns 158.23 ns

Author: lambdalisue

is.ts

@@ -193,16 +193,35 @@ export function isObjectOf<
   predObj: T,
   options: { strict?: boolean } = {},
 ): Predicate<ObjectOf<T>> {
-  const preds = Object.entries(predObj);
-  const allKeys = new Set(preds.map(([key]) => key));
-  const requiredKeys = preds
-    .filter(([_, pred]) => !(pred as OptionalPredicate<unknown>).optional)
-    .map(([key]) => key);
-  const hasKeys = options.strict
-    ? (props: string[]) => props.every((p) => allKeys.has(p))
-    : (props: string[]) => requiredKeys.every((k) => props.includes(k));
-  return (x: unknown): x is ObjectOf<T> =>
-    isRecord(x) && hasKeys(Object.keys(x)) && preds.every(([k, p]) => p(x[k]));
+  return options.strict ? isObjectOfStrict(predObj) : isObjectOfLoose(predObj);
+}
+
+function isObjectOfLoose<
+  T extends RecordOf<Predicate<unknown>>,
+>(
+  predObj: T,
+): Predicate<ObjectOf<T>> {
+  return (x: unknown): x is ObjectOf<T> => {
+    if (!isRecord(x)) return false;
+    for (const k in predObj) {
+      if (!predObj[k](x[k])) return false;
+    }
+    return true;
+  };
+}
+
+function isObjectOfStrict<
+  T extends RecordOf<Predicate<unknown>>,
+>(
+  predObj: T,
+): Predicate<ObjectOf<T>> {
+  const keys = new Set(Object.keys(predObj));
+  const pred = isObjectOfLoose(predObj);
+  return (x: unknown): x is ObjectOf<T> => {
+    if (!pred(x)) return false;
+    const ks = Object.keys(x);
+    return ks.length <= keys.size && ks.every((k) => keys.has(k));
+  };
 }
 
 /**