Merge pull request #67 from lambdalisue/ref-record

💥 Rename `isRecord/isRecordOf/isRecordLike/isRecordLikeOf`

Author: lambdalisue

is/__snapshots__/factory_test.ts.snap

@@ -108,6 +108,14 @@ snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 2`] = `"
 
 snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 3`] = `"isReadonlyOf(isUniformTupleOf(3, (anonymous)))"`;
 
+snapshot[`isRecordObjectOf<T> > returns properly named function 1`] = `"isRecordObjectOf(isNumber, undefined)"`;
+
+snapshot[`isRecordObjectOf<T> > returns properly named function 2`] = `"isRecordObjectOf((anonymous), undefined)"`;
+
+snapshot[`isRecordObjectOf<T, K> > returns properly named function 1`] = `"isRecordObjectOf(isNumber, isString)"`;
+
+snapshot[`isRecordObjectOf<T, K> > returns properly named function 2`] = `"isRecordObjectOf((anonymous), isString)"`;
+
 snapshot[`isRecordOf<T> > returns properly named function 1`] = `"isRecordOf(isNumber, undefined)"`;
 
 snapshot[`isRecordOf<T> > returns properly named function 2`] = `"isRecordOf((anonymous), undefined)"`;

is/annotation_test.ts

@@ -16,7 +16,7 @@ import {
   isFunction,
   isNull,
   isNumber,
-  isRecord,
+  isRecordObject,
   isSet,
   isString,
   isSymbol,
@@ -121,8 +121,8 @@ Deno.test("isOptionalOf<T>", async (t) => {
       validExamples: ["set", "undefined"],
     });
   });
-  await t.step("with isRecord", async (t) => {
-    await testWithExamples(t, isOptionalOf(isRecord), {
+  await t.step("with isRecordObject", async (t) => {
+    await testWithExamples(t, isOptionalOf(isRecordObject), {
       validExamples: ["record", "undefined"],
     });
   });
@@ -208,10 +208,14 @@ Deno.test("isUnwrapOptionalOf<T>", async (t) => {
       validExamples: ["set"],
     });
   });
-  await t.step("with isRecord", async (t) => {
-    await testWithExamples(t, isUnwrapOptionalOf(isOptionalOf(isRecord)), {
-      validExamples: ["record"],
-    });
+  await t.step("with isRecordObject", async (t) => {
+    await testWithExamples(
+      t,
+      isUnwrapOptionalOf(isOptionalOf(isRecordObject)),
+      {
+        validExamples: ["record"],
+      },
+    );
   });
   await t.step("with isFunction", async (t) => {
     await testWithExamples(t, isUnwrapOptionalOf(isOptionalOf(isFunction)), {

is/core.ts

@@ -140,7 +140,7 @@ export function isSet(x: unknown): x is Set<unknown> {
 }
 
 /**
- * Return `true` if the type of `x` is `Record<PropertyKey, unknown>`.
+ * Return `true` if the type of `x` is an object instance that satisfies `Record<PropertyKey, unknown>`.
  *
  * Note that this function check if the `x` is an instance of `Object`.
  * Use `isRecordLike` instead if you want to check if the `x` satisfies the `Record<PropertyKey, unknown>` type.
@@ -149,39 +149,56 @@ export function isSet(x: unknown): x is Set<unknown> {
  * import { is } from "https://deno.land/x/unknownutil@$MODULE_VERSION/mod.ts";
  *
  * const a: unknown = {"a": 0, "b": 1};
- * if (is.Record(a)) {
+ * if (is.RecordObject(a)) {
  *   // a is narrowed to Record<PropertyKey, unknown>
  *   const _: Record<PropertyKey, unknown> = a;
  * }
+ *
+ * const b: unknown = new Set();
+ * if (is.RecordObject(b)) {
+ *   // b is not a raw object, so it is not narrowed
+ * }
  * ```
  */
-export function isRecord(
+export function isRecordObject(
   x: unknown,
 ): x is Record<PropertyKey, unknown> {
   return x != null && typeof x === "object" && x.constructor === Object;
 }
 
 /**
- * Return `true` if the type of `x` is like `Record<PropertyKey, unknown>`.
+ * Return `true` if the type of `x` satisfies `Record<PropertyKey, unknown>`.
  *
  * Note that this function returns `true` for ambiguous instances like `Set`, `Map`, `Date`, `Promise`, etc.
  *
  * ```ts
  * import { is } from "https://deno.land/x/unknownutil@$MODULE_VERSION/mod.ts";
  *
  * const a: unknown = {"a": 0, "b": 1};
- * if (is.RecordLike(a)) {
+ * if (is.Record(a)) {
  *   // a is narrowed to Record<PropertyKey, unknown>
  *   const _: Record<PropertyKey, unknown> = a;
  * }
  *
- * const b: unknown = new Date();
- * if (is.RecordLike(b)) {
- *   // a is narrowed to Record<PropertyKey, unknown>
+ * const b: unknown = new Set();
+ * if (is.Record(b)) {
+ *   // b is narrowed to Record<PropertyKey, unknown>
  *   const _: Record<PropertyKey, unknown> = b;
  * }
  * ```
  */
+export function isRecord(
+  x: unknown,
+): x is Record<PropertyKey, unknown> {
+  return x != null && !Array.isArray(x) && typeof x === "object";
+}
+
+/**
+ * Return `true` if the type of `x` is like `Record<PropertyKey, unknown>`.
+ *
+ * @deprecated Use `is.Record` instead.
+ * ```
+ */
 export function isRecordLike(
   x: unknown,
 ): x is Record<PropertyKey, unknown> {
@@ -376,6 +393,7 @@ export default {
   Primitive: isPrimitive,
   Record: isRecord,
   RecordLike: isRecordLike,
+  RecordObject: isRecordObject,
   Set: isSet,
   String: isString,
   Symbol: isSymbol,

is/core_test.ts

@@ -18,6 +18,7 @@ import is, {
   isPrimitive,
   isRecord,
   isRecordLike,
+  isRecordObject,
   isSet,
   isString,
   isSymbol,
@@ -142,9 +143,15 @@ Deno.test("isSet", async (t) => {
   await testWithExamples(t, isSet, { validExamples: ["set"] });
 });
 
+Deno.test("isRecordObject", async (t) => {
+  await testWithExamples(t, isRecordObject, {
+    validExamples: ["record"],
+  });
+});
+
 Deno.test("isRecord", async (t) => {
   await testWithExamples(t, isRecord, {
-    validExamples: ["record"],
+    validExamples: ["record", "date", "promise", "set", "map"],
   });
 });
 

is/factory.ts

@@ -6,7 +6,7 @@ import {
   isArray,
   isMap,
   isRecord,
-  isRecordLike,
+  isRecordObject,
   isSet,
   type Primitive,
 } from "./core.ts";
@@ -368,17 +368,17 @@ export function isReadonlyUniformTupleOf<T, N extends number>(
 }
 
 /**
- * Return a type predicate function that returns `true` if the type of `x` is `Record<K, T>`.
+ * Return a type predicate function that returns `true` if the type of `x` is an Object instance that satisfies `Record<K, T>`.
  *
  * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
  *
  * Note that this function check if the `x` is an instance of `Object`.
- * Use `isRecordLikeOf` instead if you want to check if the `x` satisfies the `Record<K, T>` type.
+ * Use `isRecordOf` instead if you want to check if the `x` satisfies the `Record<K, T>` type.
  *
  * ```ts
  * import { is } from "https://deno.land/x/unknownutil@$MODULE_VERSION/mod.ts";
  *
- * const isMyType = is.RecordOf(is.Number);
+ * const isMyType = is.RecordObjectOf(is.Number);
  * const a: unknown = {"a": 0, "b": 1};
  * if (isMyType(a)) {
  *   // a is narrowed to Record<PropertyKey, number>
@@ -391,45 +391,45 @@ export function isReadonlyUniformTupleOf<T, N extends number>(
  * ```ts
  * import { is } from "https://deno.land/x/unknownutil@$MODULE_VERSION/mod.ts";
  *
- * const isMyType = is.RecordOf(is.Number, is.String);
+ * const isMyType = is.RecordObjectOf(is.Number, is.String);
  * const a: unknown = {"a": 0, "b": 1};
  * if (isMyType(a)) {
  *   // a is narrowed to Record<string, number>
  *   const _: Record<string, number> = a;
  * }
  * ```
  */
-export function isRecordOf<T, K extends PropertyKey = PropertyKey>(
+export function isRecordObjectOf<T, K extends PropertyKey = PropertyKey>(
   pred: Predicate<T>,
   predKey?: Predicate<K>,
-): Predicate<Record<K, T>> & WithMetadata<IsRecordOfMetadata> {
+): Predicate<Record<K, T>> & WithMetadata<IsRecordObjectOfMetadata> {
   return setPredicateFactoryMetadata(
     (x: unknown): x is Record<K, T> => {
-      if (!isRecord(x)) return false;
+      if (!isRecordObject(x)) return false;
       for (const k in x) {
         if (!pred(x[k])) return false;
         if (predKey && !predKey(k)) return false;
       }
       return true;
     },
-    { name: "isRecordOf", args: [pred, predKey] },
+    { name: "isRecordObjectOf", args: [pred, predKey] },
   );
 }
 
-type IsRecordOfMetadata = {
-  name: "isRecordOf";
-  args: Parameters<typeof isRecordOf>;
+type IsRecordObjectOfMetadata = {
+  name: "isRecordObjectOf";
+  args: Parameters<typeof isRecordObjectOf>;
 };
 
 /**
- * Return a type predicate function that returns `true` if the type of `x` is like `Record<K, T>`.
+ * Return a type predicate function that returns `true` if the type of `x` satisfies `Record<K, T>`.
  *
  * 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.RecordLikeOf(is.Number);
+ * const isMyType = is.RecordOf(is.Number);
  * const a: unknown = {"a": 0, "b": 1};
  * if (isMyType(a)) {
  *   // a is narrowed to Record<PropertyKey, number>
@@ -450,23 +450,43 @@ type IsRecordOfMetadata = {
  * }
  * ```
  */
-export function isRecordLikeOf<T, K extends PropertyKey = PropertyKey>(
+export function isRecordOf<T, K extends PropertyKey = PropertyKey>(
   pred: Predicate<T>,
   predKey?: Predicate<K>,
-): Predicate<Record<K, T>> & WithMetadata<IsRecordLikeOfMetadata> {
+): Predicate<Record<K, T>> & WithMetadata<IsRecordOfMetadata> {
   return setPredicateFactoryMetadata(
     (x: unknown): x is Record<K, T> => {
-      if (!isRecordLike(x)) return false;
+      if (!isRecord(x)) return false;
       for (const k in x) {
         if (!pred(x[k])) return false;
         if (predKey && !predKey(k)) return false;
       }
       return true;
     },
-    { name: "isRecordLikeOf", args: [pred, predKey] },
+    { name: "isRecordOf", args: [pred, predKey] },
   );
 }
 
+type IsRecordOfMetadata = {
+  name: "isRecordOf";
+  args: Parameters<typeof isRecordOf>;
+};
+
+/**
+ * Return a type predicate function that returns `true` if the type of `x` satisfies `Record<K, T>`.
+ *
+ * @deprecated Use `is.RecordOf()` instead
+ */
+export function isRecordLikeOf<T, K extends PropertyKey = PropertyKey>(
+  pred: Predicate<T>,
+  predKey?: Predicate<K>,
+): Predicate<Record<K, T>> & WithMetadata<IsRecordLikeOfMetadata> {
+  return setPredicateFactoryMetadata(isRecordOf(pred, predKey), {
+    name: "isRecordLikeOf",
+    args: [pred, predKey],
+  });
+}
+
 type IsRecordLikeOfMetadata = {
   name: "isRecordLikeOf";
   args: Parameters<typeof isRecordLikeOf>;
@@ -747,6 +767,7 @@ export default {
   ReadonlyTupleOf: isReadonlyTupleOf,
   ReadonlyUniformTupleOf: isReadonlyUniformTupleOf,
   RecordLikeOf: isRecordLikeOf,
+  RecordObjectOf: isRecordObjectOf,
   RecordOf: isRecordOf,
   SetOf: isSetOf,
   StrictOf: isStrictOf,