👍 Add isReadonlyOf

Author: lambdalisue

is/__snapshots__/readonly_of_test.ts.snap

@@ -0,0 +1,23 @@
+export const snapshot = {};
+
+snapshot[`isReadonlyOf<T> > returns properly named function 1`] = `
+"isObjectOf({
+  a: asReadonly(isNumber),
+  b: asReadonly(isUnionOf([
+    isString,
+    isUndefined
+  ])),
+  c: asReadonly(isBoolean)
+})"
+`;
+
+snapshot[`isReadonlyOf<T> > returns properly named function 2`] = `
+"isObjectOf({
+  a: asReadonly(isNumber),
+  b: asReadonly(isUnionOf([
+    isString,
+    isUndefined
+  ])),
+  c: asReadonly(isBoolean)
+})"
+`;

is/mod.ts

@@ -20,6 +20,7 @@ import { isParametersOf } from "./parameters_of.ts";
 import { isPartialOf } from "./partial_of.ts";
 import { isPickOf } from "./pick_of.ts";
 import { isPrimitive } from "./primitive.ts";
+import { isReadonlyOf } from "./readonly_of.ts";
 import { isRecord } from "./record.ts";
 import { isRecordObject } from "./record_object.ts";
 import { isRecordObjectOf } from "./record_object_of.ts";
@@ -60,6 +61,7 @@ export const is = {
   PartialOf: isPartialOf,
   PickOf: isPickOf,
   Primitive: isPrimitive,
+  ReadonlyOf: isReadonlyOf,
   Record: isRecord,
   RecordObject: isRecordObject,
   RecordObjectOf: isRecordObjectOf,

is/readonly_of.ts

@@ -0,0 +1,41 @@
+import type { FlatType } from "../_typeutil.ts";
+import type { WithPredObj } from "../_annotation.ts";
+import { asReadonly } from "../as/readonly.ts";
+import type { Predicate } from "../type.ts";
+import { isObjectOf } from "../is/object_of.ts";
+
+/**
+ * Return a type predicate function that returns `true` if the type of `x` is `Readonly<ObjectOf<T>>`.
+ *
+ * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
+ *
+ * ```typescript
+ * import { as, is } from "@core/unknownutil";
+ *
+ * const isMyType = is.ReadonlyOf(is.ObjectOf({
+ *   a: is.Number,
+ *   b: is.UnionOf([is.String, is.Undefined]),
+ *   c: as.Readonly(is.Boolean),
+ * }));
+ * const a: unknown = { a: 0, b: "b", c: true };
+ * if (isMyType(a)) {
+ *   // 'a' is narrowed to { readonly a: number; readonly b: string | undefined; readonly c: boolean }
+ *   const _: { readonly a: number; readonly b: string | undefined; readonly c: boolean } = a;
+ * }
+ * ```
+ */
+export function isReadonlyOf<
+  T extends Record<PropertyKey, unknown>,
+  P extends Record<PropertyKey, Predicate<unknown>>,
+>(
+  pred: Predicate<T> & WithPredObj<P>,
+):
+  & Predicate<FlatType<Readonly<T>>>
+  & WithPredObj<P> {
+  const predObj = Object.fromEntries(
+    Object.entries(pred.predObj).map(([k, v]) => [k, asReadonly(v)]),
+  ) as Record<PropertyKey, Predicate<unknown>>;
+  return isObjectOf(predObj) as
+    & Predicate<FlatType<Readonly<T>>>
+    & WithPredObj<P>;
+}

is/readonly_of_test.ts

@@ -0,0 +1,49 @@
+import { assertEquals } from "@std/assert";
+import { assertSnapshot } from "@std/testing/snapshot";
+import { assertType } from "@std/testing/types";
+import type { Equal } from "../_testutil.ts";
+import { as } from "../as/mod.ts";
+import { is } from "../is/mod.ts";
+import { isReadonlyOf } from "./readonly_of.ts";
+
+Deno.test("isReadonlyOf<T>", async (t) => {
+  const pred = is.ObjectOf({
+    a: is.Number,
+    b: is.UnionOf([is.String, is.Undefined]),
+    c: as.Readonly(is.Boolean),
+  });
+  await t.step("returns properly named function", async (t) => {
+    await assertSnapshot(t, isReadonlyOf(pred).name);
+    // Nestable (no effect)
+    await assertSnapshot(t, isReadonlyOf(isReadonlyOf(pred)).name);
+  });
+  await t.step("returns proper type predicate", () => {
+    const a: unknown = { a: 0, b: "a", c: true };
+    if (isReadonlyOf(pred)(a)) {
+      assertType<
+        Equal<
+          typeof a,
+          Readonly<{ a: number; b: string | undefined; c: boolean }>
+        >
+      >(true);
+    }
+  });
+  await t.step("returns true on Readonly<T> object", () => {
+    assertEquals(
+      isReadonlyOf(pred)({ a: 0, b: "b", c: true } as const),
+      true,
+    );
+    assertEquals(
+      isReadonlyOf(pred)({ a: 0, b: "b", c: true }),
+      true,
+    );
+  });
+  await t.step("returns false on non Readonly<T> object", () => {
+    assertEquals(isReadonlyOf(pred)("a"), false, "Value is not an object");
+    assertEquals(
+      isReadonlyOf(pred)({ a: 0, b: "a", c: "" }),
+      false,
+      "Object have a different type property",
+    );
+  });
+});