👍 Add isObjectOf<T>

Author: lambdalisue

is.ts

@@ -98,6 +98,58 @@ export function isRecordOf<T>(
     isRecord(x) && Object.values(x).every(pred);
 }
 
+type FlatType<T> = T extends RecordOf<unknown>
+  ? { [K in keyof T]: FlatType<T[K]> }
+  : T;
+
+export type ObjectOf<
+  T extends RecordOf<Predicate<unknown>>,
+> = FlatType<{ [K in keyof T]: T[K] extends Predicate<infer U> ? U : never }>;
+
+/**
+ * Return a type predicate function that returns `true` if the type of `x` is `ObjectOf<T>`.
+ * When `options.strict` is `true`, the number of keys of `x` must be equal to the number of keys of `predObj`.
+ * Otherwise, the number of keys of `x` must be greater than or equal to the number of keys of `predObj`.
+ *
+ * ```ts
+ * import is from "./is.ts";
+ *
+ * const predObj = {
+ *  a: is.Number,
+ *  b: is.String,
+ *  c: is.Boolean,
+ * };
+ * const a: unknown = { a: 0, b: "a", c: true };
+ * if (is.ObjectOf(predObj)(a)) {
+ *  // a is narrowed to { a: number, b: string, c: boolean }
+ *  const _: { a: number, b: string, c: boolean } = a;
+ * }
+ * ```
+ */
+export function isObjectOf<
+  T extends RecordOf<Predicate<unknown>>,
+>(
+  predObj: T,
+  options: { strict?: boolean } = {},
+): Predicate<ObjectOf<T>> {
+  return (x: unknown): x is ObjectOf<T> => {
+    if (!isRecord(x)) {
+      return false;
+    }
+    const preds = Object.entries<Predicate<unknown>>(predObj);
+    if (options.strict) {
+      if (Object.keys(x).length !== preds.length) {
+        return false;
+      }
+    } else {
+      if (Object.keys(x).length < preds.length) {
+        return false;
+      }
+    }
+    return preds.every(([k, p]) => p(x[k]));
+  };
+}
+
 /**
  * Return `true` if the type of `x` is `function`.
  */
@@ -135,6 +187,7 @@ export default {
   TupleOf: isTupleOf,
   Record: isRecord,
   RecordOf: isRecordOf,
+  ObjectOf: isObjectOf,
   Function: isFunction,
   Null: isNull,
   Undefined: isUndefined,

is_test.ts

@@ -10,6 +10,7 @@ import is, {
   isNull,
   isNullish,
   isNumber,
+  isObjectOf,
   isRecord,
   isRecordOf,
   isString,
@@ -26,6 +27,7 @@ Deno.test("is defines aliases of functions", () => {
   assertStrictEquals(is.TupleOf, isTupleOf);
   assertStrictEquals(is.Record, isRecord);
   assertStrictEquals(is.RecordOf, isRecordOf);
+  assertStrictEquals(is.ObjectOf, isObjectOf);
   assertStrictEquals(is.Function, isFunction);
   assertStrictEquals(is.Null, isNull);
   assertStrictEquals(is.Undefined, isUndefined);
@@ -165,6 +167,50 @@ Deno.test("isRecordOf<T>", async (t) => {
   });
 });
 
+Deno.test("isObjectOf<T>", async (t) => {
+  await t.step("returns true on T object", () => {
+    const predObj = {
+      a: isNumber,
+      b: isString,
+      c: isBoolean,
+    };
+    assertEquals(isObjectOf(predObj)({ a: 0, b: "a", c: true }), true);
+    assertEquals(
+      isObjectOf(predObj)({ a: 0, b: "a", c: true, d: "ignored" }),
+      true,
+    );
+  });
+  await t.step("returns false on non T object", () => {
+    const predObj = {
+      a: isNumber,
+      b: isString,
+      c: isBoolean,
+    };
+    assertEquals(isObjectOf(predObj)({ a: 0, b: "a", c: "" }), false);
+    assertEquals(isObjectOf(predObj)({ a: 0, b: "a" }), false);
+    assertEquals(
+      isObjectOf(predObj, { strict: true })({
+        a: 0,
+        b: "a",
+        c: true,
+        d: "invalid",
+      }),
+      false,
+    );
+  });
+  await t.step("returns proper type predicate", () => {
+    const predObj = {
+      a: isNumber,
+      b: isString,
+      c: isBoolean,
+    };
+    const a: unknown = { a: 0, b: "a", c: true };
+    if (isObjectOf(predObj)(a)) {
+      const _: { a: number; b: string; c: boolean } = a;
+    }
+  });
+});
+
 Deno.test("isFunction", async (t) => {
   await t.step("returns true on function", () => {
     assertEquals(isFunction(isFunction), true);