ts-data-forge 6.5.0 → 6.7.0

package/src/object/object.test.mts

@@ -181,3 +181,294 @@ describe('fromEntries', () => {
     assert.deepStrictEqual(result, { name: 'Alice' });
   });
 });
+
+describe('merge', () => {
+  test('should merge two objects, later overriding earlier', () => {
+    const a = { a: 0, b: 0 } as const;
+
+    const b = { b: 1, c: 0 } as const;
+
+    const result = Obj.merge(a, b);
+
+    expectType<typeof result, Readonly<{ a: 0; b: 1; c: 0 }>>('=');
+
+    assert.deepStrictEqual(result, { a: 0, b: 1, c: 0 });
+  });
+
+  test('should merge three objects', () => {
+    const a = { x: 1, y: 2 } as const;
+
+    const b = { y: 3, z: 4 } as const;
+
+    const c = { z: 5, w: 6 } as const;
+
+    const result = Obj.merge(a, b, c);
+
+    expectType<typeof result, Readonly<{ x: 1; y: 3; z: 5; w: 6 }>>('=');
+
+    assert.deepStrictEqual(result, { x: 1, y: 3, z: 5, w: 6 });
+  });
+
+  test('should return empty object when called with no arguments', () => {
+    const result = Obj.merge();
+
+    expectType<typeof result, {}>('=');
+
+    assert.deepStrictEqual(result, {});
+  });
+
+  test('should return the same shape for a single argument', () => {
+    const a = { a: 1, b: 2 } as const;
+
+    const result = Obj.merge(a);
+
+    expectType<typeof result, Readonly<{ a: 1; b: 2 }>>('=');
+
+    assert.deepStrictEqual(result, { a: 1, b: 2 });
+  });
+
+  test('type: later key completely overrides earlier key type', () => {
+    const a = { key: 'hello' } as const;
+
+    const b = { key: 42 } as const;
+
+    const result = Obj.merge(a, b);
+
+    expectType<typeof result, Readonly<{ key: 42 }>>('=');
+
+    assert.deepStrictEqual(result, { key: 42 });
+  });
+
+  test('type: MergeAll with four objects', () => {
+    const a = { a: 1, b: 2 } as const;
+
+    const b = { b: 3, c: 4 } as const;
+
+    const c = { c: 5, d: 6 } as const;
+
+    const d = { d: 7, e: 8 } as const;
+
+    const result = Obj.merge(a, b, c, d);
+
+    expectType<typeof result, Readonly<{ a: 1; b: 3; c: 5; d: 7; e: 8 }>>('=');
+
+    assert.deepStrictEqual(result, { a: 1, b: 3, c: 5, d: 7, e: 8 });
+  });
+
+  test('type: MergeAll with same key multiple times', () => {
+    const a = { x: 'first' } as const;
+
+    const b = { x: 'second' } as const;
+
+    const c = { x: 'third' } as const;
+
+    const result = Obj.merge(a, b, c);
+
+    expectType<typeof result, Readonly<{ x: 'third' }>>('=');
+
+    assert.deepStrictEqual(result, { x: 'third' });
+  });
+
+  test('type: MergeAll with disjoint keys', () => {
+    const a = { a: 1 } as const;
+
+    const b = { b: 2 } as const;
+
+    const c = { c: 3 } as const;
+
+    const result = Obj.merge(a, b, c);
+
+    expectType<typeof result, Readonly<{ a: 1; b: 2; c: 3 }>>('=');
+
+    assert.deepStrictEqual(result, { a: 1, b: 2, c: 3 });
+  });
+
+  test('type: MergeAll with complex nested types', () => {
+    const a = { value: { nested: 1 } } as const;
+
+    const b = { value: { nested: 2, extra: 'text' } } as const;
+
+    const result = Obj.merge(a, b);
+
+    expectType<
+      typeof result,
+      DeepReadonly<{ value: { nested: 2; extra: 'text' } }>
+    >('=');
+
+    assert.deepStrictEqual(result, { value: { nested: 2, extra: 'text' } });
+  });
+
+  test('type: MergeAll with mixed value types', () => {
+    const a = { x: 1, y: 'string' } as const;
+
+    const b = { y: 2, z: true } as const;
+
+    const c = { z: false, w: undefined } as const;
+
+    const result = Obj.merge(a, b, c);
+
+    expectType<typeof result, Readonly<{ x: 1; y: 2; z: false; w: undefined }>>(
+      '=',
+    );
+
+    assert.deepStrictEqual(result, { x: 1, y: 2, z: false, w: undefined });
+  });
+
+  test('type: MergeAll with mixed value types with optional properties', () => {
+    const a: Readonly<{ x: number; y?: string }> = {
+      x: 1,
+      y: 'string',
+    } as const;
+
+    const b: Readonly<{ y?: number; z?: boolean }> = { y: 2, z: true } as const;
+
+    const c: Readonly<{ z?: boolean; w?: undefined }> = {
+      z: false,
+      w: undefined,
+    } as const;
+
+    const result = Obj.merge(a, b, c);
+
+    expectType<
+      typeof result,
+      Readonly<{ x: number; y?: string | number; z?: boolean; w?: undefined }>
+    >('=');
+
+    assert.deepStrictEqual(result, { x: 1, y: 2, z: false, w: undefined });
+  });
+
+  test('type: MergeAll empty array produces empty object', () => {
+    const result = Obj.merge();
+
+    expectType<typeof result, {}>('=');
+
+    assert.deepStrictEqual(result, {});
+  });
+
+  test('type: MergeAll with arrays as values', () => {
+    const a = { items: [1, 2] } as const;
+
+    const b = { items: [3, 4, 5] } as const;
+
+    const result = Obj.merge(a, b);
+
+    expectType<typeof result, Readonly<{ items: readonly [3, 4, 5] }>>('=');
+
+    assert.deepStrictEqual(result, { items: [3, 4, 5] });
+  });
+
+  test('type: MergeAll preserves literal types', () => {
+    const a = { status: 'pending', count: 0 } as const;
+
+    const b = { status: 'completed' } as const;
+
+    const result = Obj.merge(a, b);
+
+    expectType<typeof result, Readonly<{ status: 'completed'; count: 0 }>>('=');
+
+    assert.deepStrictEqual(result, { status: 'completed', count: 0 });
+  });
+
+  test('type: MergeAll with UnknownRecord[] produces UnknownRecord', () => {
+    const records: readonly UnknownRecord[] = [
+      { a: 1, b: 2 },
+      { b: 3, c: 4 },
+      { c: 5, d: 6 },
+    ] as const;
+
+    const result = Obj.merge(...records);
+
+    expectType<typeof result, UnknownRecord>('=');
+
+    assert.deepStrictEqual(result, { a: 1, b: 3, c: 5, d: 6 });
+  });
+
+  test('type: MergeAll with specific typed array', () => {
+    type MyRecord = Readonly<{ x: number; y: string }>;
+
+    const records: readonly MyRecord[] = [
+      { x: 1, y: 'a' },
+      { x: 2, y: 'b' },
+      { x: 3, y: 'c' },
+    ] as const;
+
+    const result = Obj.merge(...records);
+
+    expectType<typeof result, MyRecord>('=');
+
+    assert.deepStrictEqual(result, { x: 3, y: 'c' });
+  });
+
+  test('type: MergeAll with fixed length typed array', () => {
+    type MyRecord = Readonly<{ x: number; y: string }>;
+
+    const records: ArrayOfLength<3, MyRecord> = [
+      { x: 1, y: 'a' },
+      { x: 2, y: 'b' },
+      { x: 3, y: 'c' },
+    ] as const;
+
+    const result = Obj.merge(...records);
+
+    expectType<typeof result, MyRecord>('=');
+
+    assert.deepStrictEqual(result, { x: 3, y: 'c' });
+  });
+
+  test('type: MergeAll with array and optional properties', () => {
+    type RecordWithOptional = Readonly<{ x: number; y?: string }>;
+
+    const records: readonly RecordWithOptional[] = [
+      { x: 1, y: 'a' },
+      { x: 2 },
+    ] as const;
+
+    const result = Obj.merge(...records);
+
+    expectType<typeof result, RecordWithOptional>('=');
+
+    assert.deepStrictEqual(result, { x: 2, y: 'a' });
+  });
+
+  test('type: MergeAll with fixed length typed array and optional properties', () => {
+    type RecordWithOptional = Readonly<{ x: number; y?: string }>;
+
+    const records: ArrayOfLength<2, RecordWithOptional> = [
+      { x: 1, y: 'a' },
+      { x: 2 },
+    ] as const;
+
+    const result = Obj.merge(...records);
+
+    expectType<typeof result, RecordWithOptional>('=');
+
+    assert.deepStrictEqual(result, { x: 2, y: 'a' });
+  });
+
+  test('type: MergeAll with empty dynamic array', () => {
+    const records: readonly UnknownRecord[] = [] as const;
+
+    const result = Obj.merge(...records);
+
+    expectType<typeof result, UnknownRecord>('=');
+
+    assert.deepStrictEqual(result, {});
+  });
+
+  test('type: MergeAll with union type array', () => {
+    type RecordA = Readonly<{ a: number; b: string }>;
+
+    type RecordB = Readonly<{ c: boolean; d: number }>;
+
+    const records: readonly (RecordA | RecordB)[] = [
+      { a: 1, b: 'text' },
+      { c: true, d: 42 },
+    ] as const;
+
+    const result = Obj.merge(...records);
+
+    expectType<typeof result, RecordA | RecordB>('=');
+
+    assert.deepStrictEqual(result, { a: 1, b: 'text', c: true, d: 42 });
+  });
+});

package/src/others/cast-readonly.test.mts

@@ -64,6 +64,7 @@ describe(castDeepReadonly, () => {
   });
 
   test('should preserve runtime value for complex structures', () => {
+    // transformer-ignore-next-line convert-to-readonly
     const complex = {
       users: [{ id: 1, profile: { name: 'Alice' } }],
       settings: { theme: 'dark', options: { debug: true } },
@@ -82,6 +83,7 @@ describe(castDeepReadonly, () => {
   });
 
   test('should work with arrays of objects', () => {
+    // transformer-ignore-next-line convert-to-readonly
     const data = [
       { id: 1, meta: { active: true } },
       { id: 2, meta: { active: false } },

package/src/others/fast-deep-equal.test.mts

@@ -17,7 +17,7 @@ class MyMap<K, V> extends Map<K, V> {}
 
 class MySet<T> extends Set<T> {}
 
-const emptyObj = {};
+const emptyObj = {} as const;
 
 type TestCase = Readonly<{
   name: string;
@@ -367,8 +367,9 @@ describe(fastDeepEqual, () => {
   describe('Maps', () => {
     const createMap = <K, V>(
       obj: ReadonlyRecord<string, V>,
+      // transformer-ignore-next-line convert-to-readonly
       MapClass: new () => Map<K, V> = Map,
-    ): Map<K, V> => {
+    ): ReadonlyMap<K, V> => {
       const mut_m = new MapClass();
 
       for (const key in obj) {
@@ -498,8 +499,9 @@ describe(fastDeepEqual, () => {
   describe('Sets', () => {
     const createSet = <T,>(
       arr: readonly T[],
+      // transformer-ignore-next-line convert-to-readonly
       SetClass: new () => Set<T> = Set,
-    ): Set<T> => {
+    ): ReadonlySet<T> => {
       const mut_s = new SetClass();
 
       for (const value of arr) {
@@ -739,7 +741,7 @@ describe(fastDeepEqual, () => {
             React.createElement('h1', { key: 'h1' }, 'Title'),
             React.createElement('h2', { key: 'h2' }, 'Subtitle'),
           ],
-        };
+        } as const;
 
         if (child.shouldComponentUpdate(sameProps)) {
           child.render();
@@ -755,7 +757,7 @@ describe(fastDeepEqual, () => {
             React.createElement('h1', { key: 'h1' }, 'New Title'),
             React.createElement('h2', { key: 'h2' }, 'Subtitle'),
           ],
-        };
+        } as const;
 
         if (child.shouldComponentUpdate(differentProps)) {
           child.render();