ts-data-forge 14.6.3 → 14.7.0

package/src/guard/is-record.test.mts

@@ -1,195 +0,0 @@
-import { type ReadonlyRecord, type UnknownRecord } from 'ts-type-forge';
-import { expectType } from '../expect-type.mjs';
-import { hasKey } from './has-key.mjs';
-import { isRecord } from './is-record.mjs';
-
-describe(isRecord, () => {
-  describe('plain objects are records', () => {
-    test('{ x: 1 } is a record', () => {
-      const unk: unknown = { x: 1 } as const;
-
-      if (isRecord(unk)) {
-        expectType<typeof unk, UnknownRecord>('=');
-      } else {
-        assert.fail();
-      }
-    });
-
-    test('{} is a record', () => {
-      const unk: unknown = {} as const;
-
-      assert.isTrue(isRecord(unk));
-    });
-
-    test('Object.create(null) is a record', () => {
-      const unk: unknown = Object.create(null);
-
-      assert.isTrue(isRecord(unk));
-    });
-  });
-
-  describe('arrays are not records', () => {
-    test('type-level: arrays are not assignable to UnknownRecord', () => {
-      // Arrays have a number index signature but no string index signature,
-      // so they are assignable to `ReadonlyRecord<number, unknown>` but not to
-      // `UnknownRecord` (= `ReadonlyRecord<string, unknown>`).
-      expectType<readonly number[], ReadonlyRecord<number, unknown>>('<=');
-
-      expectType<readonly number[], UnknownRecord>('!<=');
-
-      expectType<readonly string[], ReadonlyRecord<number, unknown>>('<=');
-
-      expectType<readonly string[], UnknownRecord>('!<=');
-
-      expectType<readonly [], UnknownRecord>('!<=');
-    });
-
-    test('[1, 2, 3] is not a record', () => {
-      const unk: unknown = [1, 2, 3] as const;
-
-      assert.isFalse(isRecord(unk));
-    });
-
-    test('["1", "2", "3"] is not a record', () => {
-      const unk: unknown = ['1', '2', '3'] as const;
-
-      assert.isFalse(isRecord(unk));
-    });
-
-    test('[] is not a record', () => {
-      const unk: unknown = [] as const;
-
-      assert.isFalse(isRecord(unk));
-    });
-  });
-
-  describe('other non-null objects are records', () => {
-    // These are not statically assignable to `UnknownRecord` either, but the
-    // guard intentionally admits them: every property read through
-    // `UnknownRecord` is typed `unknown`, so the narrowing is type-safe, and
-    // it keeps `isRecord(u) && hasKey(u, k)` usable for probing instances
-    // such as caught `Error` objects.
-    test('Date is a record', () => {
-      expectType<Date, UnknownRecord>('!<=');
-
-      const unk: unknown = new Date('2020-01-01');
-
-      assert.isTrue(isRecord(unk));
-    });
-
-    test('RegExp is a record', () => {
-      const unk: unknown = /test/u;
-
-      assert.isTrue(isRecord(unk));
-    });
-
-    test('Map is a record (but its entries are not own properties)', () => {
-      expectType<ReadonlyMap<string, number>, UnknownRecord>('!<=');
-
-      const unk: unknown = new Map([['a', 1]]);
-
-      if (isRecord(unk)) {
-        // Map entries are not own properties, so hasKey correctly rejects them.
-        assert.isFalse(hasKey(unk, 'a'));
-      } else {
-        assert.fail();
-      }
-    });
-
-    test('Set is a record', () => {
-      expectType<ReadonlySet<number>, UnknownRecord>('!<=');
-
-      const unk: unknown = new Set([1, 2, 3]);
-
-      assert.isTrue(isRecord(unk));
-    });
-
-    test('Error is a record and its own properties can be probed', () => {
-      const unk: unknown = Object.assign(new Error('failure'), {
-        code: 'ENOENT',
-      });
-
-      if (isRecord(unk) && hasKey(unk, 'code')) {
-        expectType<(typeof unk)['code'], unknown>('=');
-
-        assert.strictEqual(unk.code, 'ENOENT');
-      } else {
-        assert.fail();
-      }
-    });
-
-    test('class instance is a record', () => {
-      class Foo {
-        readonly x = 1;
-      }
-
-      const unk: unknown = new Foo();
-
-      assert.isTrue(isRecord(unk));
-    });
-  });
-
-  describe('functions are not records', () => {
-    test('arrow function is not a record', () => {
-      const unk: unknown = () => 0;
-
-      assert.isFalse(isRecord(unk));
-    });
-  });
-
-  describe('primitives are not records', () => {
-    test('null is not a record', () => {
-      const unk: unknown = null;
-
-      assert.isFalse(isRecord(unk));
-    });
-
-    test('undefined is not a record', () => {
-      const unk: unknown = undefined;
-
-      assert.isFalse(isRecord(unk));
-    });
-
-    test('3 is not a record', () => {
-      const unk: unknown = 3;
-
-      assert.isFalse(isRecord(unk));
-    });
-
-    test('"str" is not a record', () => {
-      const unk: unknown = 'str';
-
-      assert.isFalse(isRecord(unk));
-    });
-
-    test('true is not a record', () => {
-      const unk: unknown = true;
-
-      assert.isFalse(isRecord(unk));
-    });
-
-    test('symbol is not a record', () => {
-      const unk: unknown = Symbol('sym');
-
-      assert.isFalse(isRecord(unk));
-    });
-
-    test('bigint is not a record', () => {
-      const unk: unknown = 1n;
-
-      assert.isFalse(isRecord(unk));
-    });
-  });
-
-  test('combined with hasKey', () => {
-    const unk: unknown = { 'some-key': 42 } as const;
-
-    if (isRecord(unk) && hasKey(unk, 'some-key')) {
-      expectType<(typeof unk)['some-key'], unknown>('=');
-
-      assert.strictEqual(unk['some-key'], 42);
-    } else {
-      assert.fail();
-    }
-  });
-});

package/src/guard/key-is-in.test.mts

@@ -1,21 +0,0 @@
-import { type ReadonlyRecord } from 'ts-type-forge';
-import { keyIsIn } from './key-is-in.mjs';
-
-const f = <Key extends string, V, KeySub extends Key>(
-  key: Key,
-  obj: ReadonlyRecord<KeySub, V>,
-): V | undefined => (keyIsIn(key, obj) ? obj[key] : undefined);
-
-describe(keyIsIn, () => {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-  f('a' as 'a' | 'b' | 'c', { a: 0, b: 1 });
-
-  test('', () => {
-    assert.isTrue(
-      keyIsIn('a', {
-        a: 0,
-        b: 1,
-      }),
-    );
-  });
-});

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

@@ -1,295 +0,0 @@
-import dedent from 'dedent';
-import { unknownToString } from './unknown-to-string.mjs';
-
-describe(unknownToString, () => {
-  test('string', () => {
-    const value = 'aaaaa';
-
-    expect(unknownToString(value)).toBe('aaaaa');
-
-    expect(JSON.stringify(value)).toBe('"aaaaa"');
-  });
-
-  test('number', () => {
-    expect(unknownToString(1)).toBe('1');
-
-    expect(JSON.stringify(1)).toBe('1');
-  });
-
-  test('BigInt value', () => {
-    const value = 123n;
-
-    expect(unknownToString(value)).toBe('123n');
-
-    expect(() => JSON.stringify(value)).toThrow(
-      'Do not know how to serialize a BigInt',
-    );
-  });
-
-  test('boolean', () => {
-    expect(unknownToString(true)).toBe('true');
-
-    expect(JSON.stringify(true)).toBe('true');
-  });
-
-  test('undefined', () => {
-    expect(unknownToString(undefined)).toBe('undefined');
-
-    expect(JSON.stringify(undefined)).toBeUndefined();
-  });
-
-  test('null', () => {
-    expect(unknownToString(null)).toBe('null');
-
-    expect(JSON.stringify(null)).toBe('null');
-  });
-
-  test('symbol', () => {
-    const value = Symbol('sym');
-
-    expect(unknownToString(value)).toBe('Symbol(sym)');
-
-    expect(JSON.stringify(value)).toBeUndefined();
-  });
-
-  describe('function', () => {
-    test('() => 0', () => {
-      const fn = (): number => 0;
-
-      expect(unknownToString(fn)).toBe('() => 0');
-
-      expect(JSON.stringify(fn)).toBeUndefined();
-    });
-
-    test('(args) => ({ ret: args })', () => {
-      const fn = (args: unknown): unknown => ({ ret: args }) as const;
-
-      expect(unknownToString(fn)).toBe('(args) => ({ ret: args })');
-
-      expect(JSON.stringify(fn)).toBeUndefined();
-    });
-  });
-
-  describe('object', () => {
-    test('object', () => {
-      const obj = { a: { b: 1 } } as const;
-
-      expect(unknownToString(obj)).toBe('{"a":{"b":1}}');
-
-      expect(JSON.stringify(obj)).toBe('{"a":{"b":1}}');
-    });
-
-    test('object(prettyPrint=true)', () => {
-      const obj = { a: { b: 1 } } as const;
-
-      expect(unknownToString(obj, { prettyPrintObject: true })).toBe(
-        dedent`
-          {
-            "a": {
-              "b": 1
-            }
-          }
-        `,
-      );
-    });
-
-    describe('array', () => {
-      test('array of primitives', () => {
-        const arr = [1, 2, 3, 'test', true] as const;
-
-        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 }] as const;
-
-        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],
-        ] as const;
-
-        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] as const;
-
-        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', () => {
-    const mut_circular: { a: number; self?: unknown } = { a: 1 };
-
-    mut_circular.self = mut_circular;
-
-    // Should return an error message string instead of throwing
-    expectTypeOf(unknownToString(mut_circular)).toBeString();
-
-    expect(unknownToString(mut_circular)).toMatch(/circular|serialize/iu);
-  });
-
-  test('non-Error thrown during serialization returns fallback text', () => {
-    const value = {
-      toJSON: () => {
-        // eslint-disable-next-line @typescript-eslint/only-throw-error
-        throw 'custom failure';
-      },
-    } as const;
-
-    expect(unknownToString(value)).toBe('[Circular or Non-serializable]');
-  });
-});