ts-data-forge 6.1.1 → 6.2.0

package/dist/others/unknown-to-string.d.mts

@@ -14,6 +14,11 @@
  * - Functions: converted to their string representation
  * - null: returns "null" (not "null" from JSON)
  * - undefined: returns "undefined"
+ * - Date: converted to ISO string
+ * - RegExp: converted to regex literal string
+ * - Map: converted to Map representation with entries
+ * - Set: converted to Set representation with values
+ * - Error: returns error message
  * - Objects: JSON stringified (with optional pretty printing)
  *
  * @param value - The unknown value to convert to string

package/dist/others/unknown-to-string.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-to-string.d.mts","sourceRoot":"","sources":["../../src/others/unknown-to-string.mts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,OAAO,EACd,UAAU,OAAO,CAAC,QAAQ,CAAC;IAAE,iBAAiB,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,KAC1D,MAmCF,CAAC"}
+{"version":3,"file":"unknown-to-string.d.mts","sourceRoot":"","sources":["../../src/others/unknown-to-string.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,OAAO,EACd,UAAU,OAAO,CAAC,QAAQ,CAAC;IAAE,iBAAiB,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,KAC1D,MAuEF,CAAC"}

package/dist/others/unknown-to-string.mjs

@@ -1,5 +1,4 @@
-import { isError } from '@sindresorhus/is';
-import { isNonNullish } from '../guard/is-type.mjs';
+import { isDate, isRegExp, isError, isMap, isSet } from '@sindresorhus/is';
 
 /**
  * Converts an unknown value to its string representation in a type-safe manner.
@@ -17,6 +16,11 @@ import { isNonNullish } from '../guard/is-type.mjs';
  * - Functions: converted to their string representation
  * - null: returns "null" (not "null" from JSON)
  * - undefined: returns "undefined"
+ * - Date: converted to ISO string
+ * - RegExp: converted to regex literal string
+ * - Map: converted to Map representation with entries
+ * - Set: converted to Set representation with values
+ * - Error: returns error message
  * - Objects: JSON stringified (with optional pretty printing)
  *
  * @param value - The unknown value to convert to string
@@ -41,23 +45,51 @@ const unknownToString = (value, options) => {
         case 'symbol':
         case 'function':
             return value.toString();
-        case 'object':
-            if (!isNonNullish(value)) {
+        case 'undefined':
+            return 'undefined';
+        case 'object': {
+            if (value === null) {
                 return 'null';
             }
             try {
-                const stringified = options?.prettyPrintObject === true
+                // Special handling for Date
+                if (isDate(value)) {
+                    return value.toISOString();
+                }
+                // Special handling for RegExp
+                if (isRegExp(value)) {
+                    return value.toString();
+                }
+                if (isError(value)) {
+                    return value.message;
+                }
+                const prettyPrintObject = options?.prettyPrintObject === true;
+                // Special handling for Map
+                if (isMap(value)) {
+                    const entries = Array.from(value.entries());
+                    const entriesStr = prettyPrintObject
+                        ? JSON.stringify(entries, undefined, 2)
+                        : JSON.stringify(entries);
+                    return `Map(${entriesStr})`;
+                }
+                // Special handling for Set
+                if (isSet(value)) {
+                    const values = Array.from(value.values());
+                    const valuesStr = prettyPrintObject
+                        ? JSON.stringify(values, undefined, 2)
+                        : JSON.stringify(values);
+                    return `Set(${valuesStr})`;
+                }
+                return prettyPrintObject
                     ? JSON.stringify(value, undefined, 2)
                     : JSON.stringify(value);
-                return stringified;
             }
             catch (error) {
                 return isError(error)
                     ? error.message
                     : '[Circular or Non-serializable]';
             }
-        case 'undefined':
-            return 'undefined';
+        }
     }
 };
 

package/dist/others/unknown-to-string.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-to-string.mjs","sources":["../../src/others/unknown-to-string.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;MACU,eAAe,GAAG,CAC7B,KAAc,EACd,OAA2D,KACjD;IACV,QAAQ,OAAO,KAAK;AAClB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,KAAK;AAEd,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,GAAG,KAAK,CAAC,QAAQ,EAAE,GAAG;AAE/B,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,SAAS;AACd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,UAAU;AACb,YAAA,OAAO,KAAK,CAAC,QAAQ,EAAE;AAEzB,QAAA,KAAK,QAAQ;AACX,YAAA,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE;AACxB,gBAAA,OAAO,MAAM;YACf;AAEA,YAAA,IAAI;AACF,gBAAA,MAAM,WAAW,GACf,OAAO,EAAE,iBAAiB,KAAK;sBAC3B,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;AACpC,sBAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;AAE3B,gBAAA,OAAO,WAAW;YACpB;YAAE,OAAO,KAAK,EAAE;gBACd,OAAO,OAAO,CAAC,KAAK;sBAChB,KAAK,CAAC;sBACN,gCAAgC;YACtC;AAEF,QAAA,KAAK,WAAW;AACd,YAAA,OAAO,WAAW;;AAExB;;;;"}
+{"version":3,"file":"unknown-to-string.mjs","sources":["../../src/others/unknown-to-string.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;MACU,eAAe,GAAG,CAC7B,KAAc,EACd,OAA2D,KACjD;IACV,QAAQ,OAAO,KAAK;AAClB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,KAAK;AAEd,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,GAAG,KAAK,CAAC,QAAQ,EAAE,GAAG;AAE/B,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,SAAS;AACd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,UAAU;AACb,YAAA,OAAO,KAAK,CAAC,QAAQ,EAAE;AAEzB,QAAA,KAAK,WAAW;AACd,YAAA,OAAO,WAAW;QAEpB,KAAK,QAAQ,EAAE;AACb,YAAA,IAAI,KAAK,KAAK,IAAI,EAAE;AAClB,gBAAA,OAAO,MAAM;YACf;AAEA,YAAA,IAAI;;AAEF,gBAAA,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE;AACjB,oBAAA,OAAO,KAAK,CAAC,WAAW,EAAE;gBAC5B;;AAGA,gBAAA,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE;AACnB,oBAAA,OAAO,KAAK,CAAC,QAAQ,EAAE;gBACzB;AAEA,gBAAA,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE;oBAClB,OAAO,KAAK,CAAC,OAAO;gBACtB;AAEA,gBAAA,MAAM,iBAAiB,GAAG,OAAO,EAAE,iBAAiB,KAAK,IAAI;;AAG7D,gBAAA,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE;oBAChB,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;oBAE3C,MAAM,UAAU,GAAG;0BACf,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC;AACtC,0BAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;oBAE3B,OAAO,CAAA,IAAA,EAAO,UAAU,CAAA,CAAA,CAAG;gBAC7B;;AAGA,gBAAA,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE;oBAChB,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;oBAEzC,MAAM,SAAS,GAAG;0BACd,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC;AACrC,0BAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;oBAE1B,OAAO,CAAA,IAAA,EAAO,SAAS,CAAA,CAAA,CAAG;gBAC5B;AAEA,gBAAA,OAAO;sBACH,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;AACpC,sBAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;YAC3B;YAAE,OAAO,KAAK,EAAE;gBACd,OAAO,OAAO,CAAC,KAAK;sBAChB,KAAK,CAAC;sBACN,gCAAgC;YACtC;QACF;;AAEJ;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "6.1.1",
+  "version": "6.2.0",
   "private": false,
   "keywords": [
     "typescript",
@@ -100,10 +100,11 @@
     "@vitest/ui": "4.0.16",
     "conventional-changelog-conventionalcommits": "9.1.0",
     "cspell": "9.4.0",
+    "dedent": "^1.7.1",
     "eslint": "9.39.2",
-    "eslint-config-typed": "4.1.0",
+    "eslint-config-typed": "4.3.0",
     "github-settings-as-code": "1.0.6",
-    "immer": "11.0.1",
+    "immer": "11.1.0",
     "jiti": "2.6.1",
     "markdownlint": "0.40.0",
     "markdownlint-cli2": "0.20.0",
@@ -112,9 +113,9 @@
     "prettier": "3.7.4",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "2.5.20",
-    "rollup": "4.53.5",
+    "rollup": "4.54.0",
     "semantic-release": "25.0.2",
-    "ts-repo-utils": "7.9.5",
+    "ts-repo-utils": "8.0.0",
     "tslib": "2.8.1",
     "tsx": "4.21.0",
     "typedoc": "0.28.15",

package/src/others/unknown-to-string.mts

@@ -1,5 +1,4 @@
-import { isError } from '@sindresorhus/is';
-import { isNonNullish } from '../guard/index.mjs';
+import { isDate, isError, isMap, isRegExp, isSet } from '@sindresorhus/is';
 
 /**
  * Converts an unknown value to its string representation in a type-safe manner.
@@ -17,6 +16,11 @@ import { isNonNullish } from '../guard/index.mjs';
  * - Functions: converted to their string representation
  * - null: returns "null" (not "null" from JSON)
  * - undefined: returns "undefined"
+ * - Date: converted to ISO string
+ * - RegExp: converted to regex literal string
+ * - Map: converted to Map representation with entries
+ * - Set: converted to Set representation with values
+ * - Error: returns error message
  * - Objects: JSON stringified (with optional pretty printing)
  *
  * @param value - The unknown value to convert to string
@@ -47,25 +51,61 @@ export const unknownToString = (
     case 'function':
       return value.toString();
 
-    case 'object':
-      if (!isNonNullish(value)) {
+    case 'undefined':
+      return 'undefined';
+
+    case 'object': {
+      if (value === null) {
         return 'null';
       }
 
       try {
-        const stringified =
-          options?.prettyPrintObject === true
-            ? JSON.stringify(value, undefined, 2)
-            : JSON.stringify(value);
+        // Special handling for Date
+        if (isDate(value)) {
+          return value.toISOString();
+        }
+
+        // Special handling for RegExp
+        if (isRegExp(value)) {
+          return value.toString();
+        }
+
+        if (isError(value)) {
+          return value.message;
+        }
+
+        const prettyPrintObject = options?.prettyPrintObject === true;
+
+        // Special handling for Map
+        if (isMap(value)) {
+          const entries = Array.from(value.entries());
+
+          const entriesStr = prettyPrintObject
+            ? JSON.stringify(entries, undefined, 2)
+            : JSON.stringify(entries);
 
-        return stringified;
+          return `Map(${entriesStr})`;
+        }
+
+        // Special handling for Set
+        if (isSet(value)) {
+          const values = Array.from(value.values());
+
+          const valuesStr = prettyPrintObject
+            ? JSON.stringify(values, undefined, 2)
+            : JSON.stringify(values);
+
+          return `Set(${valuesStr})`;
+        }
+
+        return prettyPrintObject
+          ? JSON.stringify(value, undefined, 2)
+          : JSON.stringify(value);
       } catch (error) {
         return isError(error)
           ? error.message
           : '[Circular or Non-serializable]';
       }
-
-    case 'undefined':
-      return 'undefined';
+    }
   }
 };

package/src/others/unknown-to-string.test.mts

@@ -1,86 +1,274 @@
+import dedent from 'dedent';
 import { unknownToString } from './unknown-to-string.mjs';
 
 describe(unknownToString, () => {
   test('string', () => {
-    const result = unknownToString('aaaaa');
+    const value = 'aaaaa';
 
-    expect(result).toBe('aaaaa');
+    expect(unknownToString(value)).toBe('aaaaa');
 
-    expect(JSON.stringify('aaaaa')).toBe('"aaaaa"');
+    expect(JSON.stringify(value)).toBe('"aaaaa"');
   });
 
   test('number', () => {
-    const result = unknownToString(1);
-
-    expect(result).toBe('1');
+    expect(unknownToString(1)).toBe('1');
 
     expect(JSON.stringify(1)).toBe('1');
   });
 
-  test('boolean', () => {
-    const result = unknownToString(true);
+  test('BigInt value', () => {
+    const value = 123n;
 
-    expect(result).toBe('true');
+    expect(unknownToString(value)).toBe('123n');
 
-    expect(JSON.stringify(true)).toBe('true');
+    expect(() => JSON.stringify(value)).toThrowError(
+      'Do not know how to serialize a BigInt',
+    );
   });
 
-  test('symbol', () => {
-    const result = unknownToString(Symbol('sym'));
-
-    expect(result).toBe('Symbol(sym)');
+  test('boolean', () => {
+    expect(unknownToString(true)).toBe('true');
 
-    expect(JSON.stringify(Symbol('sym'))).toBeUndefined();
+    expect(JSON.stringify(true)).toBe('true');
   });
 
-  test('function', () => {
-    const result = unknownToString(() => 0);
+  test('undefined', () => {
+    expect(unknownToString(undefined)).toBe('undefined');
 
-    expect(result).toBe('() => 0');
+    expect(JSON.stringify(undefined)).toBeUndefined();
+  });
 
-    expect(JSON.stringify(() => 0)).toBeUndefined();
+  test('null', () => {
+    expect(unknownToString(null)).toBe('null');
+
+    expect(JSON.stringify(null)).toBe('null');
   });
 
-  test('undefined', () => {
-    const result = unknownToString(undefined);
+  test('symbol', () => {
+    const value = Symbol('sym');
 
-    expect(result).toBe('undefined');
+    expect(unknownToString(value)).toBe('Symbol(sym)');
 
-    expect(JSON.stringify(undefined)).toBeUndefined();
+    expect(JSON.stringify(value)).toBeUndefined();
   });
 
-  test('null', () => {
-    const result = unknownToString(null);
+  describe('function', () => {
+    test('() => 0', () => {
+      const fn = (): number => 0;
 
-    expect(result).toBe('null');
+      expect(unknownToString(fn)).toBe('() => 0');
 
-    expect(JSON.stringify(null)).toBe('null');
-  });
+      expect(JSON.stringify(fn)).toBeUndefined();
+    });
 
-  test('object', () => {
-    const result = unknownToString({ a: { b: 1 } });
+    test('(args) => ({ ret: args })', () => {
+      const fn = (args: unknown): unknown => ({ ret: args });
 
-    expect(result).toBe('{"a":{"b":1}}');
+      expect(unknownToString(fn)).toBe('(args) => ({ ret: args })');
 
-    expect(JSON.stringify({ a: { b: 1 } })).toBe('{"a":{"b":1}}');
+      expect(JSON.stringify(fn)).toBeUndefined();
+    });
   });
 
-  test('object(prettyPrint=true)', () => {
-    const result = unknownToString(
-      { a: { b: 1 } },
-      { prettyPrintObject: true },
-    );
+  describe('object', () => {
+    test('object', () => {
+      const obj = { a: { b: 1 } };
+
+      expect(unknownToString(obj)).toBe('{"a":{"b":1}}');
 
-    expect(result).toBe(
-      [
-        //
-        `{`,
-        `  "a": {`,
-        `    "b": 1`,
-        `  }`,
-        `}`,
-      ].join('\n'),
-    );
+      expect(JSON.stringify(obj)).toBe('{"a":{"b":1}}');
+    });
+
+    test('object(prettyPrint=true)', () => {
+      const obj = { a: { b: 1 } };
+
+      expect(unknownToString(obj, { prettyPrintObject: true })).toBe(
+        dedent`
+          {
+            "a": {
+              "b": 1
+            }
+          }
+        `,
+      );
+    });
+
+    describe('array', () => {
+      test('array of primitives', () => {
+        const arr = [1, 2, 3, 'test', true];
+
+        expect(unknownToString(arr)).toBe('[1,2,3,"test",true]');
+
+        expect(JSON.stringify(arr)).toBe('[1,2,3,"test",true]');
+      });
+
+      test('array of objects', () => {
+        const arr = [{ a: 1 }, { b: 2 }];
+
+        expect(unknownToString(arr)).toBe('[{"a":1},{"b":2}]');
+
+        expect(JSON.stringify(arr)).toBe('[{"a":1},{"b":2}]');
+      });
+
+      test('empty array', () => {
+        expect(unknownToString([])).toBe('[]');
+
+        expect(JSON.stringify([])).toBe('[]');
+      });
+
+      test('nested array', () => {
+        const nestedArray = [
+          [1, 2],
+          [3, 4],
+        ];
+
+        expect(unknownToString(nestedArray)).toBe('[[1,2],[3,4]]');
+
+        expect(JSON.stringify(nestedArray)).toBe('[[1,2],[3,4]]');
+      });
+
+      test('array with prettyPrint', () => {
+        const arr = [1, { a: 2 }, 3];
+
+        expect(
+          unknownToString(arr, {
+            prettyPrintObject: true,
+          }),
+        ).toBe(
+          dedent`
+            [
+              1,
+              {
+                "a": 2
+              },
+              3
+            ]
+          `,
+        );
+      });
+    });
+
+    describe('special objects', () => {
+      test('Date object returns ISO string', () => {
+        const date = new Date('2024-01-15T10:30:00.000Z');
+
+        expect(unknownToString(date)).toBe('2024-01-15T10:30:00.000Z');
+      });
+
+      test('RegExp returns regex literal', () => {
+        const regex = /test/giu;
+
+        expect(unknownToString(regex)).toBe('/test/giu');
+      });
+
+      test('RegExp without flags', () => {
+        // eslint-disable-next-line require-unicode-regexp
+        const regex = /hello/;
+
+        expect(unknownToString(regex)).toBe('/hello/');
+      });
+
+      test('Map with entries', () => {
+        const map = new Map<number | string, boolean | number | string>([
+          ['key1', 'value1'],
+          ['key2', 42],
+          [3, true],
+        ]);
+
+        expect(unknownToString(map)).toBe(
+          'Map([["key1","value1"],["key2",42],[3,true]])',
+        );
+      });
+
+      test('empty Map', () => {
+        const map = new Map();
+
+        expect(unknownToString(map)).toBe('Map([])');
+      });
+
+      test('Map with prettyPrint', () => {
+        const map = new Map([
+          ['a', 1],
+          ['b', 2],
+        ]);
+
+        expect(unknownToString(map, { prettyPrintObject: true })).toBe(
+          dedent`
+            Map([
+              [
+                "a",
+                1
+              ],
+              [
+                "b",
+                2
+              ]
+            ])
+          `,
+        );
+      });
+
+      test('Set with values', () => {
+        const set = new Set([1, 2, 3, 'test', true]);
+
+        expect(unknownToString(set)).toBe('Set([1,2,3,"test",true])');
+      });
+
+      test('empty Set', () => {
+        const set = new Set();
+
+        expect(unknownToString(set)).toBe('Set([])');
+      });
+
+      test('Set with prettyPrint', () => {
+        const set = new Set([1, { a: 2 }, 3]);
+
+        expect(unknownToString(set, { prettyPrintObject: true })).toBe(
+          dedent`
+            Set([
+              1,
+              {
+                "a": 2
+              },
+              3
+            ])
+          `,
+        );
+      });
+
+      test('nested Map and Set', () => {
+        const map = new Map([['set', new Set([1, 2])]]);
+
+        const result = unknownToString(map);
+
+        // Set is converted to object notation in JSON.stringify
+        expect(result).toMatch(/Map\(\[\["set",/u);
+      });
+
+      test('Error object returns message', () => {
+        const err = new Error('Something went wrong');
+
+        expect(unknownToString(err)).toBe('Something went wrong');
+
+        expect(JSON.stringify(err)).toBe('{}');
+      });
+
+      test('Error object with empty message', () => {
+        // eslint-disable-next-line unicorn/error-message
+        const err = new Error('');
+
+        expect(unknownToString(err)).toBe('');
+
+        expect(JSON.stringify(err)).toBe('{}');
+      });
+
+      test('TypeError object with empty message', () => {
+        // eslint-disable-next-line unicorn/error-message
+        const err = new TypeError('');
+
+        expect(unknownToString(err)).toBe('');
+      });
+    });
   });
 
   test('circular reference returns error message', () => {
@@ -88,18 +276,10 @@ describe(unknownToString, () => {
 
     mut_circular.self = mut_circular;
 
-    const result = unknownToString(mut_circular);
-
     // Should return an error message string instead of throwing
-    expectTypeOf(result).toBeString();
+    expectTypeOf(unknownToString(mut_circular)).toBeString();
 
-    expect(result).toMatch(/circular|serialize/iu);
-  });
-
-  test('BigInt value', () => {
-    const result = unknownToString(123n);
-
-    expect(result).toBe('123n');
+    expect(unknownToString(mut_circular)).toMatch(/circular|serialize/iu);
   });
 
   test('non-Error thrown during serialization returns fallback text', () => {
@@ -110,8 +290,6 @@ describe(unknownToString, () => {
       },
     };
 
-    const result = unknownToString(value);
-
-    expect(result).toBe('[Circular or Non-serializable]');
+    expect(unknownToString(value)).toBe('[Circular or Non-serializable]');
   });
 });