👍 Add as.Readonly and as.Unreadonly

Author: lambdalisue

_annotation.ts

@@ -36,6 +36,13 @@ export type WithOptional<T = unknown> = {
   optional: Predicate<T>;
 };
 
+/**
+ * Annotation for readonly.
+ */
+export type WithReadonly<T = unknown> = {
+  readonly: Predicate<T>;
+};
+
 /**
  * Annotation for predObj.
  */

as/__snapshots__/readonly_test.ts.snap

@@ -0,0 +1,11 @@
+export const snapshot = {};
+
+snapshot[`asReadonly<T> > returns properly named function 1`] = `"asReadonly(isNumber)"`;
+
+snapshot[`asReadonly<T> > returns properly named function 2`] = `"asReadonly(isNumber)"`;
+
+snapshot[`asUnreadonly<T> > returns properly named function 1`] = `"isNumber"`;
+
+snapshot[`asUnreadonly<T> > returns properly named function 2`] = `"isNumber"`;
+
+snapshot[`asUnreadonly<T> > returns properly named function 3`] = `"isNumber"`;

as/mod.ts

@@ -1,6 +1,9 @@
 import { asOptional, asUnoptional } from "./optional.ts";
+import { asReadonly, asUnreadonly } from "./readonly.ts";
 
 export const as = {
   Optional: asOptional,
+  Readonly: asReadonly,
   Unoptional: asUnoptional,
+  Unreadonly: asUnreadonly,
 };

as/readonly.ts

@@ -0,0 +1,82 @@
+import { rewriteName } from "../_funcutil.ts";
+import type { Predicate } from "../type.ts";
+import {
+  annotate,
+  hasAnnotation,
+  unannotate,
+  type WithReadonly,
+} from "../_annotation.ts";
+
+/**
+ * Return an `Readonly` annotated type predicate function that returns `true` if the type of `x` is `T`.
+ *
+ * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
+ *
+ * ```ts
+ * import { as, is } from "@core/unknownutil";
+ *
+ * const isMyType = is.ObjectOf({
+ *   foo: as.Readonly(is.String),
+ * });
+ * const a: unknown = {};
+ * if (isMyType(a)) {
+ *   // a is narrowed to {readonly foo: string}
+ *   const _: {readonly foo: string} = a;
+ * }
+ * ```
+ */
+export function asReadonly<T>(
+  pred: Predicate<T>,
+): Predicate<T> & WithReadonly {
+  if (hasAnnotation(pred, "readonly")) {
+    return pred as Predicate<T> & WithReadonly;
+  }
+  return rewriteName(
+    annotate(
+      (x: unknown): x is T => pred(x),
+      "readonly",
+      pred,
+    ),
+    "asReadonly",
+    pred,
+  ) as Predicate<T> & WithReadonly;
+}
+
+/**
+ * Return an `Readonly` un-annotated type predicate function that returns `true` if the type of `x` is `T`.
+ *
+ * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
+ *
+ * ```ts
+ * import { as, is } from "@core/unknownutil";
+ *
+ * const isMyType = is.ObjectOf({
+ *   foo: as.Unreadonly(as.Readonly(is.String)),
+ * });
+ * const a: unknown = {foo: "a"};
+ * if (isMyType(a)) {
+ *   // a is narrowed to {foo: string}
+ *   const _: {foo: string} = a;
+ * }
+ * ```
+ */
+export function asUnreadonly<
+  P extends Predicate<unknown>,
+  T extends P extends Predicate<infer T> ? T : never,
+>(pred: P): Predicate<T> {
+  if (!hasAnnotation(pred, "readonly")) {
+    return pred as Predicate<T>;
+  }
+  return unannotate(pred, "readonly") as Predicate<T>;
+}
+
+/**
+ * Check if the given type predicate has readonly annotation.
+ */
+export function hasReadonly<
+  P extends Predicate<unknown>,
+>(
+  pred: P,
+): pred is P & WithReadonly {
+  return hasAnnotation(pred, "readonly");
+}

as/readonly_test.ts

@@ -0,0 +1,38 @@
+import { assertSnapshot } from "@std/testing/snapshot";
+import { assertType } from "@std/testing/types";
+import type { Equal } from "../_testutil.ts";
+import { is } from "../is/mod.ts";
+import { asReadonly, asUnreadonly } from "./readonly.ts";
+
+Deno.test("asReadonly<T>", async (t) => {
+  await t.step("returns properly named function", async (t) => {
+    await assertSnapshot(t, asReadonly(is.Number).name);
+    // Nesting does nothing
+    await assertSnapshot(t, asReadonly(asReadonly(is.Number)).name);
+  });
+  await t.step("returns proper type predicate", () => {
+    const a: unknown = undefined;
+    if (is.ObjectOf({ a: asReadonly(is.Number) })(a)) {
+      assertType<Equal<typeof a, { readonly a: number }>>(true);
+    }
+  });
+});
+
+Deno.test("asUnreadonly<T>", async (t) => {
+  await t.step("returns properly named function", async (t) => {
+    await assertSnapshot(t, asUnreadonly(asReadonly(is.Number)).name);
+    // Non optional does nothing
+    await assertSnapshot(t, asUnreadonly(is.Number).name);
+    // Nesting does nothing
+    await assertSnapshot(
+      t,
+      asUnreadonly(asUnreadonly(asReadonly(is.Number))).name,
+    );
+  });
+  await t.step("returns proper type predicate", () => {
+    const a: unknown = undefined;
+    if (is.ObjectOf({ a: asUnreadonly(asReadonly(is.Number)) })(a)) {
+      assertType<Equal<typeof a, { a: number }>>(true);
+    }
+  });
+});

is/object_of.ts

@@ -4,6 +4,7 @@ import {
   annotate,
   type WithOptional,
   type WithPredObj,
+  type WithReadonly,
 } from "../_annotation.ts";
 import type { Predicate } from "../type.ts";
 
@@ -58,14 +59,36 @@ export function isObjectOf<
 }
 
 type ObjectOf<T extends Record<PropertyKey, Predicate<unknown>>> = FlatType<
-  // Optional
+  // Readonly/Optional
   & {
-    [K in keyof T as T[K] extends WithOptional<unknown> ? K : never]?:
-      T[K] extends Predicate<infer U> ? U : never;
+    readonly [
+      K in keyof T as T[K] extends WithReadonly
+        ? T[K] extends WithOptional ? K : never
+        : never
+    ]?: T[K] extends Predicate<infer U> ? U : never;
   }
-  // Non optional
+  // Readonly/Non optional
   & {
-    [K in keyof T as T[K] extends WithOptional<unknown> ? never : K]:
-      T[K] extends Predicate<infer U> ? U : never;
+    readonly [
+      K in keyof T as T[K] extends WithReadonly
+        ? T[K] extends WithOptional ? never : K
+        : never
+    ]: T[K] extends Predicate<infer U> ? U : never;
+  }
+  // Non readonly/Optional
+  & {
+    [
+      K in keyof T as T[K] extends WithReadonly ? never
+        : T[K] extends WithOptional ? K
+        : never
+    ]?: T[K] extends Predicate<infer U> ? U : never;
+  }
+  // Non readonly/Non optional
+  & {
+    [
+      K in keyof T as T[K] extends WithReadonly ? never
+        : T[K] extends WithOptional ? never
+        : K
+    ]: T[K] extends Predicate<infer U> ? U : never;
   }
 >;