ts-data-forge 4.1.0 → 5.0.0

package/src/others/memoize-function.test.mts

@@ -1,17 +1,17 @@
 import { memoizeFunction } from './memoize-function.mjs';
 
-describe('memoizeFunction', () => {
+describe(memoizeFunction, () => {
   test('should cache results for the same arguments', () => {
     const mockFn = vi.fn((x: number) => x * 2);
     const memoized = memoizeFunction(mockFn, (x) => x);
 
     // First call
     expect(memoized(5)).toBe(10);
-    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledOnce();
 
     // Second call with same argument - should use cache
     expect(memoized(5)).toBe(10);
-    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledOnce();
 
     // Call with different argument
     expect(memoized(3)).toBe(6);
@@ -23,10 +23,10 @@ describe('memoizeFunction', () => {
     const memoized = memoizeFunction(mockFn, (a, b) => `${a},${b}`);
 
     expect(memoized(2, 3)).toBe(5);
-    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledOnce();
 
     expect(memoized(2, 3)).toBe(5);
-    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledOnce();
 
     expect(memoized(3, 2)).toBe(5);
     expect(mockFn).toHaveBeenCalledTimes(2);
@@ -38,12 +38,12 @@ describe('memoizeFunction', () => {
 
     // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
     expect(memoized(5)).toBeUndefined();
-    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledOnce();
 
     // Should use cache even for undefined
     // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
     expect(memoized(5)).toBeUndefined();
-    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledOnce();
   });
 
   test('should work with object arguments using primitive cache keys', () => {
@@ -56,11 +56,11 @@ describe('memoizeFunction', () => {
     const user3 = { id: 2, name: 'Charlie' };
 
     expect(memoized(user1)).toBe('Hello Alice');
-    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledOnce();
 
     // Same id, should use cache (even though name is different)
     expect(memoized(user2)).toBe('Hello Alice');
-    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledOnce();
 
     // Different id, should call function
     expect(memoized(user3)).toBe('Hello Charlie');
@@ -73,6 +73,7 @@ describe('memoizeFunction', () => {
       (x: string) => x.length,
       (x) => x.length,
     );
+
     expect(withNumber('hello')).toBe(5);
     expect(withNumber('world')).toBe(5); // Same length, uses cache
 
@@ -81,6 +82,7 @@ describe('memoizeFunction', () => {
       (x: number) => x * 2,
       (x) => x > 0,
     );
+
     expect(withBoolean(5)).toBe(10);
     expect(withBoolean(3)).toBe(10); // Both positive, uses cache
     expect(withBoolean(-2)).toBe(-4); // Negative, new cache entry
@@ -93,6 +95,7 @@ describe('memoizeFunction', () => {
       (s) => s,
     );
     const result1 = withSymbol(sym1);
+
     expect(withSymbol(sym1)).toBe(result1); // Same symbol, uses cache
     expect(withSymbol(sym2)).not.toBe(result1); // Different symbol
   });
@@ -102,10 +105,10 @@ describe('memoizeFunction', () => {
     const memoized = memoizeFunction(mockFn, (x) => x);
 
     expect(memoized(null)).toBe('default');
-    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledOnce();
 
     expect(memoized(null)).toBe('default');
-    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledOnce();
 
     expect(memoized(undefined)).toBe('default');
     expect(mockFn).toHaveBeenCalledTimes(2);
@@ -124,15 +127,15 @@ describe('memoizeFunction', () => {
     expect(memoized1(5)).toBe(10);
     expect(memoized2(5)).toBe(15);
 
-    expect(fn1).toHaveBeenCalledTimes(1);
-    expect(fn2).toHaveBeenCalledTimes(1);
+    expect(fn1).toHaveBeenCalledOnce();
+    expect(fn2).toHaveBeenCalledOnce();
 
     // Each has its own cache
     expect(memoized1(5)).toBe(10);
     expect(memoized2(5)).toBe(15);
 
-    expect(fn1).toHaveBeenCalledTimes(1);
-    expect(fn2).toHaveBeenCalledTimes(1);
+    expect(fn1).toHaveBeenCalledOnce();
+    expect(fn2).toHaveBeenCalledOnce();
   });
 
   test('should work with complex cache key generation', () => {
@@ -156,11 +159,11 @@ describe('memoizeFunction', () => {
     const args3 = { category: 'books', subcategory: 'fiction', id: 124 };
 
     expect(memoized(args1)).toBe('books/fiction/123');
-    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledOnce();
 
     // Same cache key, should use cache
     expect(memoized(args2)).toBe('books/fiction/123');
-    expect(mockFn).toHaveBeenCalledTimes(1);
+    expect(mockFn).toHaveBeenCalledOnce();
 
     // Different id, different cache key
     expect(memoized(args3)).toBe('books/fiction/124');

package/src/others/tuple.test.mts

@@ -1,10 +1,11 @@
 import { expectType } from '../expect-type.mjs';
 import { tp } from './tuple.mjs';
 
-describe('tp', () => {
+describe(tp, () => {
   test('test type', () => {
     const tuple = tp(1, 2, 3);
-    expect(tuple).toStrictEqual([1, 2, 3]);
+
+    assert.deepStrictEqual(tuple, [1, 2, 3]);
 
     expectType<typeof tuple, readonly [1, 2, 3]>('=');
   });

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

@@ -1,50 +1,58 @@
 import { unknownToString } from './unknown-to-string.mjs';
 
-describe('unknownToString', () => {
+describe(unknownToString, () => {
   test('string', () => {
     const result = unknownToString('aaaaa');
+
     expect(result).toBe('aaaaa');
     expect(JSON.stringify('aaaaa')).toBe('"aaaaa"');
   });
 
   test('number', () => {
     const result = unknownToString(1);
+
     expect(result).toBe('1');
     expect(JSON.stringify(1)).toBe('1');
   });
 
   test('boolean', () => {
     const result = unknownToString(true);
+
     expect(result).toBe('true');
     expect(JSON.stringify(true)).toBe('true');
   });
 
   test('symbol', () => {
     const result = unknownToString(Symbol('sym'));
+
     expect(result).toBe('Symbol(sym)');
     expect(JSON.stringify(Symbol('sym'))).toBeUndefined();
   });
 
   test('function', () => {
     const result = unknownToString(() => 0);
+
     expect(result).toBe('() => 0');
     expect(JSON.stringify(() => 0)).toBeUndefined();
   });
 
   test('undefined', () => {
     const result = unknownToString(undefined);
+
     expect(result).toBe('undefined');
     expect(JSON.stringify(undefined)).toBeUndefined();
   });
 
   test('null', () => {
     const result = unknownToString(null);
+
     expect(result).toBe('null');
     expect(JSON.stringify(null)).toBe('null');
   });
 
   test('object', () => {
     const result = unknownToString({ a: { b: 1 } });
+
     expect(result).toBe('{"a":{"b":1}}');
     expect(JSON.stringify({ a: { b: 1 } })).toBe('{"a":{"b":1}}');
   });
@@ -54,6 +62,7 @@ describe('unknownToString', () => {
       { a: { b: 1 } },
       { prettyPrintObject: true },
     );
+
     expect(result).toBe(
       [
         //
@@ -70,13 +79,16 @@ describe('unknownToString', () => {
     const mut_circular: { a: number; self?: unknown } = { a: 1 };
     mut_circular.self = mut_circular;
     const result = unknownToString(mut_circular);
+
     // Should return an error message string instead of throwing
-    expect(typeof result).toBe('string');
+    expectTypeOf(result).toBeString();
+
     expect(result).toMatch(/circular|serialize/iu);
   });
 
   test('BigInt value', () => {
     const result = unknownToString(123n);
+
     expect(result).toBe('123n');
   });
 
@@ -89,6 +101,7 @@ describe('unknownToString', () => {
     };
 
     const result = unknownToString(value);
+
     expect(result).toBe('[Circular or Non-serializable]');
   });
 });

package/src/promise/promise.test.mts

@@ -2,7 +2,7 @@ import { expectType } from '../expect-type.mjs';
 import { Result } from '../functional/index.mjs';
 import { createPromise } from './promise.mjs';
 
-describe('createPromise', () => {
+describe(createPromise, () => {
   test('resolves to Result.ok when executor resolves', async () => {
     const resultPromise = createPromise<number, Error>((resolve) => {
       resolve(42);
@@ -11,7 +11,9 @@ describe('createPromise', () => {
     expectType<typeof resultPromise, Promise<Result<number, Error>>>('=');
 
     const result = await resultPromise;
+
     expect(Result.isOk(result)).toBe(true);
+
     if (Result.isOk(result)) {
       expect(result.value).toBe(42);
     }
@@ -24,6 +26,7 @@ describe('createPromise', () => {
     });
 
     expect(Result.isErr(result)).toBe(true);
+
     if (Result.isErr(result)) {
       expect(result.value).toBe(rejection);
     }
@@ -35,8 +38,10 @@ describe('createPromise', () => {
     });
 
     expect(Result.isErr(result)).toBe(true);
+
     if (Result.isErr(result)) {
       expectType<typeof result.value, string>('=');
+
       expect(result.value).toBe('failure');
     }
   });