👍 Add isReadonlyOf in annotation.ts

lambdalisue · lambdalisue · commit cef9f087370f · 2024-02-13T02:17:52.000+09:00
diff --git a/is/__snapshots__/annotation_test.ts.snap b/is/__snapshots__/annotation_test.ts.snap
@@ -3,3 +3,7 @@ export const snapshot = {};
 snapshot[`isOptionalOf<T> > returns properly named function 1`] = `"isOptionalOf(isNumber)"`;
 
 snapshot[`isOptionalOf<T> > returns properly named function 2`] = `"isOptionalOf(isNumber)"`;
+
+snapshot[`isReadonlyOf<T> > returns properly named function 1`] = `"isReadonlyOf(isNumber)"`;
+
+snapshot[`isReadonlyOf<T> > returns properly named function 2`] = `"isReadonlyOf(isReadonlyOf(isNumber))"`;
diff --git a/is/__snapshots__/factory_test.ts.snap b/is/__snapshots__/factory_test.ts.snap
@@ -1,18 +1,32 @@
 export const snapshot = {};
 
-snapshot[`isInstanceOf<T> > returns properly named function 1`] = `"isInstanceOf(Date)"`;
-
-snapshot[`isInstanceOf<T> > returns properly named function 2`] = `"isInstanceOf((anonymous))"`;
+snapshot[`isTupleOf<T, E> > returns properly named function 1`] = `
+"isTupleOf([
+  isNumber,
+  isString,
+  isBoolean
+], isArray)"
+`;
 
-snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 1`] = `"isReadonlyUniformTupleOf(3, isAny)"`;
+snapshot[`isTupleOf<T, E> > returns properly named function 2`] = `"isTupleOf([(anonymous)], isArrayOf(isString))"`;
 
-snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 2`] = `"isReadonlyUniformTupleOf(3, isNumber)"`;
+snapshot[`isTupleOf<T, E> > returns properly named function 3`] = `
+"isTupleOf([
+  isTupleOf([
+    isTupleOf([
+      isNumber,
+      isString,
+      isBoolean
+    ], isArray)
+  ], isArray)
+])"
+`;
 
-snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 3`] = `"isReadonlyUniformTupleOf(3, (anonymous))"`;
+snapshot[`isLiteralOneOf<T> > returns properly named function 1`] = `'isLiteralOneOf(["hello", "world"])'`;
 
-snapshot[`isMapOf<T, K> > returns properly named function 1`] = `"isMapOf(isNumber, isString)"`;
+snapshot[`isInstanceOf<T> > returns properly named function 1`] = `"isInstanceOf(Date)"`;
 
-snapshot[`isMapOf<T, K> > returns properly named function 2`] = `"isMapOf((anonymous), isString)"`;
+snapshot[`isInstanceOf<T> > returns properly named function 2`] = `"isInstanceOf((anonymous))"`;
 
 snapshot[`isReadonlyTupleOf<T, E> > returns properly named function 1`] = `
 "isReadonlyTupleOf([
@@ -36,31 +50,13 @@ snapshot[`isReadonlyTupleOf<T, E> > returns properly named function 3`] = `
 ], isArray)"
 `;
 
-snapshot[`isMapOf<T> > returns properly named function 1`] = `"isMapOf(isNumber, undefined)"`;
-
-snapshot[`isMapOf<T> > returns properly named function 2`] = `"isMapOf((anonymous), undefined)"`;
-
-snapshot[`isObjectOf<T> > returns properly named function 1`] = `
-"isObjectOf({
-  a: isNumber,
-  b: isString,
-  c: isBoolean
-})"
-`;
-
-snapshot[`isObjectOf<T> > returns properly named function 2`] = `"isObjectOf({a: a})"`;
+snapshot[`isSetOf<T> > returns properly named function 1`] = `"isSetOf(isNumber)"`;
 
-snapshot[`isObjectOf<T> > returns properly named function 3`] = `
-"isObjectOf({
-  a: isObjectOf({
-    b: isObjectOf({c: isBoolean})
-  })
-})"
-`;
+snapshot[`isSetOf<T> > returns properly named function 2`] = `"isSetOf((anonymous))"`;
 
-snapshot[`isRecordOf<T> > returns properly named function 1`] = `"isRecordOf(isNumber, undefined)"`;
+snapshot[`isMapOf<T> > returns properly named function 1`] = `"isMapOf(isNumber, undefined)"`;
 
-snapshot[`isRecordOf<T> > returns properly named function 2`] = `"isRecordOf((anonymous), undefined)"`;
+snapshot[`isMapOf<T> > returns properly named function 2`] = `"isMapOf((anonymous), undefined)"`;
 
 snapshot[`isLiteralOf<T> > returns properly named function 1`] = `'isLiteralOf("hello")'`;
 
@@ -76,59 +72,11 @@ snapshot[`isLiteralOf<T> > returns properly named function 6`] = `"isLiteralOf(u
 
 snapshot[`isLiteralOf<T> > returns properly named function 7`] = `"isLiteralOf(Symbol(asdf))"`;
 
-snapshot[`isRecordOf<T, K> > returns properly named function 1`] = `"isRecordOf(isNumber, isString)"`;
-
-snapshot[`isRecordOf<T, K> > returns properly named function 2`] = `"isRecordOf((anonymous), isString)"`;
-
-snapshot[`isArrayOf<T> > returns properly named function 1`] = `"isArrayOf(isNumber)"`;
-
-snapshot[`isArrayOf<T> > returns properly named function 2`] = `"isArrayOf((anonymous))"`;
-
-snapshot[`isTupleOf<T> > returns properly named function 1`] = `
-"isTupleOf([
-  isNumber,
-  isString,
-  isBoolean
-])"
-`;
-
-snapshot[`isTupleOf<T> > returns properly named function 2`] = `"isTupleOf([(anonymous)])"`;
-
-snapshot[`isTupleOf<T> > returns properly named function 3`] = `
-"isTupleOf([
-  isTupleOf([
-    isTupleOf([
-      isNumber,
-      isString,
-      isBoolean
-    ])
-  ])
-])"
-`;
-
-snapshot[`isTupleOf<T, E> > returns properly named function 1`] = `
-"isTupleOf([
-  isNumber,
-  isString,
-  isBoolean
-], isArray)"
-`;
-
-snapshot[`isTupleOf<T, E> > returns properly named function 2`] = `"isTupleOf([(anonymous)], isArrayOf(isString))"`;
+snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 1`] = `"isReadonlyUniformTupleOf(3, isAny)"`;
 
-snapshot[`isTupleOf<T, E> > returns properly named function 3`] = `
-"isTupleOf([
-  isTupleOf([
-    isTupleOf([
-      isNumber,
-      isString,
-      isBoolean
-    ], isArray)
-  ], isArray)
-])"
-`;
+snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 2`] = `"isReadonlyUniformTupleOf(3, isNumber)"`;
 
-snapshot[`isLiteralOneOf<T> > returns properly named function 1`] = `'isLiteralOneOf(["hello", "world"])'`;
+snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 3`] = `"isReadonlyUniformTupleOf(3, (anonymous))"`;
 
 snapshot[`isStrictOf<T> > returns properly named function 1`] = `
 "isStrictOf(isObjectOf({
@@ -148,6 +96,16 @@ snapshot[`isStrictOf<T> > returns properly named function 3`] = `
 }))"
 `;
 
+snapshot[`isUniformTupleOf<T> > returns properly named function 1`] = `"isUniformTupleOf(3, isAny)"`;
+
+snapshot[`isUniformTupleOf<T> > returns properly named function 2`] = `"isUniformTupleOf(3, isNumber)"`;
+
+snapshot[`isUniformTupleOf<T> > returns properly named function 3`] = `"isUniformTupleOf(3, (anonymous))"`;
+
+snapshot[`isRecordOf<T> > returns properly named function 1`] = `"isRecordOf(isNumber, undefined)"`;
+
+snapshot[`isRecordOf<T> > returns properly named function 2`] = `"isRecordOf((anonymous), undefined)"`;
+
 snapshot[`isReadonlyTupleOf<T> > returns properly named function 1`] = `
 "isReadonlyTupleOf([
   isNumber,
@@ -170,12 +128,54 @@ snapshot[`isReadonlyTupleOf<T> > returns properly named function 3`] = `
 ])"
 `;
 
-snapshot[`isSetOf<T> > returns properly named function 1`] = `"isSetOf(isNumber)"`;
+snapshot[`isRecordOf<T, K> > returns properly named function 1`] = `"isRecordOf(isNumber, isString)"`;
 
-snapshot[`isSetOf<T> > returns properly named function 2`] = `"isSetOf((anonymous))"`;
+snapshot[`isRecordOf<T, K> > returns properly named function 2`] = `"isRecordOf((anonymous), isString)"`;
 
-snapshot[`isUniformTupleOf<T> > returns properly named function 1`] = `"isUniformTupleOf(3, isAny)"`;
+snapshot[`isTupleOf<T> > returns properly named function 1`] = `
+"isTupleOf([
+  isNumber,
+  isString,
+  isBoolean
+])"
+`;
 
-snapshot[`isUniformTupleOf<T> > returns properly named function 2`] = `"isUniformTupleOf(3, isNumber)"`;
+snapshot[`isTupleOf<T> > returns properly named function 2`] = `"isTupleOf([(anonymous)])"`;
 
-snapshot[`isUniformTupleOf<T> > returns properly named function 3`] = `"isUniformTupleOf(3, (anonymous))"`;
+snapshot[`isTupleOf<T> > returns properly named function 3`] = `
+"isTupleOf([
+  isTupleOf([
+    isTupleOf([
+      isNumber,
+      isString,
+      isBoolean
+    ])
+  ])
+])"
+`;
+
+snapshot[`isMapOf<T, K> > returns properly named function 1`] = `"isMapOf(isNumber, isString)"`;
+
+snapshot[`isMapOf<T, K> > returns properly named function 2`] = `"isMapOf((anonymous), isString)"`;
+
+snapshot[`isArrayOf<T> > returns properly named function 1`] = `"isArrayOf(isNumber)"`;
+
+snapshot[`isArrayOf<T> > returns properly named function 2`] = `"isArrayOf((anonymous))"`;
+
+snapshot[`isObjectOf<T> > returns properly named function 1`] = `
+"isObjectOf({
+  a: isNumber,
+  b: isString,
+  c: isBoolean
+})"
+`;
+
+snapshot[`isObjectOf<T> > returns properly named function 2`] = `"isObjectOf({a: a})"`;
+
+snapshot[`isObjectOf<T> > returns properly named function 3`] = `
+"isObjectOf({
+  a: isObjectOf({
+    b: isObjectOf({c: isBoolean})
+  })
+})"
+`;
diff --git a/is/__snapshots__/utility_test.ts.snap b/is/__snapshots__/utility_test.ts.snap
@@ -1,5 +1,13 @@
 export const snapshot = {};
 
+snapshot[`isUnionOf<T> > returns properly named function 1`] = `
+"isUnionOf([
+  isNumber,
+  isString,
+  isBoolean
+])"
+`;
+
 snapshot[`isPartialOf<T> > returns properly named function 1`] = `
 "isObjectOf({
   a: isOptionalOf(isNumber),
@@ -23,28 +31,20 @@ snapshot[`isIntersectionOf<T> > returns properly named function 1`] = `
 })"
 `;
 
-snapshot[`isUnionOf<T> > returns properly named function 1`] = `
-"isUnionOf([
-  isNumber,
-  isString,
-  isBoolean
-])"
-`;
-
-snapshot[`isOmitOf<T, K> > returns properly named function 1`] = `
+snapshot[`isPickOf<T, K> > returns properly named function 1`] = `
 "isObjectOf({
   a: isNumber,
   c: isBoolean
 })"
 `;
 
-snapshot[`isOmitOf<T, K> > returns properly named function 2`] = `"isObjectOf({a: isNumber})"`;
+snapshot[`isPickOf<T, K> > returns properly named function 2`] = `"isObjectOf({a: isNumber})"`;
 
-snapshot[`isPickOf<T, K> > returns properly named function 1`] = `
+snapshot[`isOmitOf<T, K> > returns properly named function 1`] = `
 "isObjectOf({
   a: isNumber,
   c: isBoolean
 })"
 `;
 
-snapshot[`isPickOf<T, K> > returns properly named function 2`] = `"isObjectOf({a: isNumber})"`;
+snapshot[`isOmitOf<T, K> > returns properly named function 2`] = `"isObjectOf({a: isNumber})"`;
diff --git a/is/annotation.ts b/is/annotation.ts
@@ -59,7 +59,56 @@ type IsOptionalOfMetadata = {
   args: Parameters<typeof isOptionalOf>;
 };
 
+/**
+ * Return `true` if the type of predicate function `x` is annotated as `Readonly`
+ */
+export function isReadonly<P extends Predicate<unknown>>(
+  x: P,
+): x is P & WithMetadata<IsReadonlyOfMetadata> {
+  const m = getMetadata(x);
+  if (m == null) return false;
+  return (m as PredicateFactoryMetadata).name === "isReadonlyOf";
+}
+
+/**
+ * Return an `Readonly` annotated type predicate function that returns `true` if the type of `x` is `T`.
+ *
+ * Note that this function does nothing but annotate the predicate function as `Readonly`.
+ *
+ * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
+ *
+ * ```ts
+ * import { is } from "https://deno.land/x/unknownutil@$MODULE_VERSION/mod.ts";
+ *
+ * const isMyType = is.ReadonlyOf(is.TupleOf([is.String, is.Number]));
+ * const a: unknown = ["a", 1];
+ * if (isMyType(a)) {
+ *   // a is narrowed to readonly [string, number]
+ *   const _: readonly [string, number] = a;
+ * }
+ * ```
+ */
+export function isReadonlyOf<T>(
+  pred: Predicate<T>,
+):
+  & Predicate<Readonly<T>>
+  & WithMetadata<IsReadonlyOfMetadata> {
+  return setPredicateFactoryMetadata(
+    (x: unknown): x is Readonly<T> => pred(x),
+    { name: "isReadonlyOf", args: [pred] },
+  ) as
+    & Predicate<Readonly<T>>
+    & WithMetadata<IsReadonlyOfMetadata>;
+}
+
+type IsReadonlyOfMetadata = {
+  name: "isReadonlyOf";
+  args: Parameters<typeof isReadonlyOf>;
+};
+
 export default {
   Optional: isOptional,
   OptionalOf: isOptionalOf,
+  Readonly: isReadonly,
+  ReadonlyOf: isReadonlyOf,
 };
diff --git a/is/annotation_test.ts b/is/annotation_test.ts
@@ -23,7 +23,8 @@ import {
   isSyncFunction,
   isUndefined,
 } from "./core.ts";
-import is, { isOptionalOf } from "./annotation.ts";
+import { isObjectOf, isTupleOf, isUniformTupleOf } from "./factory.ts";
+import is, { isOptionalOf, isReadonlyOf } from "./annotation.ts";
 
 const examples = {
   string: ["", "Hello world"],
@@ -152,6 +153,33 @@ Deno.test("isOptionalOf<T>", async (t) => {
   });
 });
 
+Deno.test("isReadonlyOf<T>", async (t) => {
+  await t.step("returns properly named function", async (t) => {
+    await assertSnapshot(t, isReadonlyOf(isNumber).name);
+    // Nesting does nothing
+    await assertSnapshot(t, isReadonlyOf(isReadonlyOf(isNumber)).name);
+  });
+  await t.step("returns proper type predicate", () => {
+    const a: unknown = undefined;
+    if (isReadonlyOf(isNumber)(a)) {
+      assertType<Equal<typeof a, Readonly<number>>>(true);
+    }
+    if (isReadonlyOf(isTupleOf([isString, isNumber, isBoolean]))(a)) {
+      assertType<Equal<typeof a, Readonly<[string, number, boolean]>>>(true);
+    }
+    if (isReadonlyOf(isUniformTupleOf(3, isString))(a)) {
+      assertType<Equal<typeof a, Readonly<[string, string, string]>>>(true);
+    }
+    if (
+      isReadonlyOf(isObjectOf({ a: isString, b: isNumber, c: isBoolean }))(a)
+    ) {
+      assertType<
+        Equal<typeof a, Readonly<{ a: string; b: number; c: boolean }>>
+      >(true);
+    }
+  });
+});
+
 Deno.test("is", async (t) => {
   const mod = await import("./annotation.ts");
   const casesOfAliasAndIsFunction = Object.entries(mod)
