@unchainedshop/utils 3.1.1 → 3.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/utils",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "main": "lib/utils-index.js",
   "types": "lib/utils-index.d.ts",
   "type": "module",
@@ -9,8 +9,8 @@
     "build": "tsc -b",
     "prepublishOnly": "npm run clean && npm run build",
     "watch": "tsc -w",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles --forceExit",
-    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --detectOpenHandles --forceExit"
+    "test": "tsx --test",
+    "test:watch": "tsx --test --watch"
   },
   "repository": {
     "type": "git",
@@ -33,7 +33,6 @@
   },
   "devDependencies": {
     "@types/node": "^22.13.4",
-    "jest": "^29.7.0",
     "typescript": "^5.7.3"
   }
 }

package/src/calculation.test.ts

@@ -1,3 +1,6 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+
 import {
   applyRate,
   roundToNext,
@@ -8,63 +11,63 @@ import {
 
 describe('roundToNext', () => {
   it('rounds to the next multiple of precision correctly when the value is positive', () => {
-    expect(roundToNext(5, 2)).toBe(6);
-    expect(roundToNext(10, 5)).toBe(10);
-    expect(roundToNext(13, 5)).toBe(15);
+    assert.strictEqual(roundToNext(5, 2), 6);
+    assert.strictEqual(roundToNext(10, 5), 10);
+    assert.strictEqual(roundToNext(13, 5), 15);
   });
 
   it('rounds to the next multiple of precision correctly when the value is negative', () => {
-    expect(roundToNext(-5, 2)).toBe(-4);
-    expect(roundToNext(-10, 5)).toBe(-10);
-    expect(roundToNext(-13, 5)).toBe(-10);
+    assert.strictEqual(roundToNext(-5, 2), -4);
+    assert.strictEqual(roundToNext(-10, 5), -10);
+    assert.strictEqual(roundToNext(-13, 5), -10);
   });
 
   it('returns 0 when the value is 0', () => {
-    expect(roundToNext(0, 5)).toBe(0);
+    assert.strictEqual(roundToNext(0, 5), 0);
   });
 
   it('returns the same value when the precision is 1', () => {
-    expect(roundToNext(5, 1)).toBe(5);
+    assert.strictEqual(roundToNext(5, 1), 5);
   });
 });
 
 describe('resolveAmountAndTax', () => {
   it('ratio is 0 and taxDivisor is 0', () => {
     const result = resolveAmountAndTax({ ratio: 0, taxDivisor: 0 }, 100);
-    expect(result).toEqual([0, 0]);
+    assert.deepStrictEqual(result, [0, 0]);
   });
 
   it('ratio is not 0 and taxDivisor is 0', () => {
     const result = resolveAmountAndTax({ ratio: 0.5, taxDivisor: 0 }, 100);
-    expect(result).toEqual([50, 0]);
+    assert.deepStrictEqual(result, [50, 0]);
   });
 
   it('ratio is 0 and taxDivisor is not 0', () => {
     const result = resolveAmountAndTax({ ratio: 0, taxDivisor: 2 }, 100);
-    expect(result).toEqual([0, 0]);
+    assert.deepStrictEqual(result, [0, 0]);
   });
 
   it('ratio and taxDivisor are not 0', () => {
     const result = resolveAmountAndTax({ ratio: 0.5, taxDivisor: 2 }, 100);
-    expect(result).toEqual([50, 25]);
+    assert.deepStrictEqual(result, [50, 25]);
   });
 
   it('ratio and taxDivisor are not finite number', () => {
     const result = resolveAmountAndTax({ ratio: Number.NaN, taxDivisor: Number.NaN }, 100);
-    expect(result).toEqual([0, 0]);
+    assert.deepStrictEqual(result, [0, 0]);
   });
 });
 
-describe('resolveAmountAndTax', () => {
+describe('applyDiscountToMultipleShares', () => {
   it('shares are empty', () => {
     const result = applyDiscountToMultipleShares([], 100);
-    expect(result).toEqual([0, 0]);
+    assert.deepStrictEqual(result, [0, 0]);
   });
 
   it('shares have one share', () => {
     const shares = [{ ratio: 0.5, taxDivisor: 2 }];
     const result = applyDiscountToMultipleShares(shares, 100);
-    expect(result).toEqual([50, 25]);
+    assert.deepStrictEqual(result, [50, 25]);
   });
 
   it('shares have multiple shares', () => {
@@ -73,7 +76,7 @@ describe('resolveAmountAndTax', () => {
       { ratio: 0.2, taxDivisor: 1.5 },
     ];
     const result = applyDiscountToMultipleShares(shares, 100);
-    expect(result).toEqual([70, 31.666666666666664]);
+    assert.deepStrictEqual(result, [70, 31.666666666666664]);
   });
 });
 
@@ -83,7 +86,7 @@ describe('applyRate', () => {
       rate: 0.1,
     };
     const amount = 100;
-    expect(applyRate(configuration, amount)).toBe(10);
+    assert.strictEqual(applyRate(configuration, amount), 10);
   });
 
   it('applies the fixed rate correctly when a fixed rate is provided', () => {
@@ -91,7 +94,7 @@ describe('applyRate', () => {
       fixedRate: 50,
     };
     const amount = 100;
-    expect(applyRate(configuration, amount)).toBe(50);
+    assert.strictEqual(applyRate(configuration, amount), 50);
   });
 
   it('applies the fixed rate correctly when a fixed rate is provided and the amount is less than fixed rate', () => {
@@ -99,7 +102,7 @@ describe('applyRate', () => {
       fixedRate: 150,
     };
     const amount = 100;
-    expect(applyRate(configuration, amount)).toBe(100);
+    assert.strictEqual(applyRate(configuration, amount), 100);
   });
 
   it('applies the rate correctly when rate is less than or equal to 0', () => {
@@ -107,44 +110,7 @@ describe('applyRate', () => {
       rate: -0.1,
     };
     const amount = 100;
-    expect(applyRate(configuration, amount)).toBe(-10);
-  });
-  it('applies the rate correctly when only rate is provided and amount is negative', () => {
-    const configuration = {
-      rate: 0.1,
-    };
-    const amount = -100;
-    expect(applyRate(configuration, amount)).toBe(-10);
-  });
-
-  it('applies the rate correctly when only rate is provided and amount is negative', () => {
-    const configuration = {
-      rate: 0.1,
-    };
-    const amount = -100;
-    expect(applyRate(configuration, amount)).toBe(-10);
-  });
-
-  it('applies the rate correctly when only rate is provided and amount is negative', () => {
-    const configuration = {
-      rate: 0.1,
-    };
-    const amount = -100;
-    expect(applyRate(configuration, amount)).toBe(-10);
-  });
-
-  it('applies the rate correctly when only rate is provided and amount is negative', () => {
-    const configuration = {
-      rate: 0.1,
-    };
-    const amount = -100;
-    expect(applyRate(configuration, amount)).toBe(-10);
-  });
-
-  it('returns 0 when rate and fixed rate are not provided', () => {
-    const configuration = {};
-    const amount = 100;
-    expect(applyRate(configuration, amount)).toBe(0);
+    assert.strictEqual(applyRate(configuration, amount), -10);
   });
 
   it('applies the rate correctly when only rate is provided and amount is negative', () => {
@@ -152,13 +118,13 @@ describe('applyRate', () => {
       rate: 0.1,
     };
     const amount = -100;
-    expect(applyRate(configuration, amount)).toBe(-10);
+    assert.strictEqual(applyRate(configuration, amount), -10);
   });
 
   it('returns 0 when rate and fixed rate are not provided', () => {
     const configuration = {};
     const amount = 100;
-    expect(applyRate(configuration, amount)).toBe(0);
+    assert.strictEqual(applyRate(configuration, amount), 0);
   });
 });
 
@@ -168,7 +134,7 @@ describe('calculateAmountToSplit', () => {
       rate: 0.1,
     };
     const amount = 1000;
-    expect(calculateAmountToSplit(configuration, amount)).toBe(100);
+    assert.strictEqual(calculateAmountToSplit(configuration, amount), 100);
   });
 
   it('calculates the correct amount to split when using a fixed rate', () => {
@@ -176,7 +142,7 @@ describe('calculateAmountToSplit', () => {
       fixedRate: 50,
     };
     const amount = 1000;
-    expect(calculateAmountToSplit(configuration, amount)).toBe(50);
+    assert.strictEqual(calculateAmountToSplit(configuration, amount), 50);
   });
 
   it('returns 0 when the amount is less than or equal to 0', () => {
@@ -184,7 +150,7 @@ describe('calculateAmountToSplit', () => {
       rate: 0.1,
     };
     const amount = 0;
-    expect(calculateAmountToSplit(configuration, amount)).toBe(0);
+    assert.strictEqual(calculateAmountToSplit(configuration, amount), 0);
   });
 
   it('returns 0 when amount is negative', () => {
@@ -192,7 +158,7 @@ describe('calculateAmountToSplit', () => {
       rate: 0.1,
     };
     const amount = -1000;
-    expect(calculateAmountToSplit(configuration, amount)).toBe(0);
+    assert.strictEqual(calculateAmountToSplit(configuration, amount), 0);
   });
 
   it('returns 0 when configuration rate is negative', () => {
@@ -200,6 +166,6 @@ describe('calculateAmountToSplit', () => {
       rate: -0.1,
     };
     const amount = 1000;
-    expect(calculateAmountToSplit(configuration, amount)).toBe(0);
+    assert.strictEqual(calculateAmountToSplit(configuration, amount), 0);
   });
 });

package/src/director/base-director.test.ts

@@ -1,24 +1,26 @@
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert';
 import { BaseDirector } from './BaseDirector.js';
 
 const adapter1 = {
   key: 'adapter1',
   label: 'Adapter 1',
   version: '1',
-  log: import.meta.jest.fn(),
+  log: () => ({}),
 };
 
 const adapter2 = {
   key: 'adapter2',
   label: 'Adapter 2',
   version: '2',
-  log: import.meta.jest.fn(),
+  log: () => ({}),
 };
 
 const adapter3 = {
   key: 'adapter3',
   label: 'Adapter 3',
   version: '3',
-  log: import.meta.jest.fn(),
+  log: () => ({}),
 };
 
 describe('BaseDirector', () => {
@@ -34,21 +36,16 @@ describe('BaseDirector', () => {
   describe('registerAdapter', () => {
     it('should add the adapter to the director', () => {
       director.registerAdapter(adapter1);
-      expect(director.getAdapter(adapter1.key)).toBe(adapter1);
-    });
-
-    xit('should generate a log message when an adapter is registered', () => {
-      const spy = import.meta.jest.spyOn(console, 'log');
-      expect(spy).toHaveBeenCalledWith('TestDirector -> Registered  adapter1 1.0.0 (Adapter 1)');
+      assert.strictEqual(director.getAdapter(adapter1.key), adapter1);
     });
 
     it('should allow multiple adapters to be registered', () => {
-      expect(director.getAdapter(adapter1.key)).toBe(adapter1);
-      expect(director.getAdapter(adapter2.key)).toBe(adapter2);
+      assert.strictEqual(director.getAdapter(adapter1.key), adapter1);
+      assert.strictEqual(director.getAdapter(adapter2.key), adapter2);
     });
 
     it('should register an adapter and add it to the internal map', () => {
-      expect(director.getAdapter(adapter1.key)).toEqual(adapter1);
+      assert.deepStrictEqual(director.getAdapter(adapter1.key), adapter1);
     });
 
     it('should use the adapterKeyField specified in the options to store the adapter in the internal map', () => {
@@ -56,7 +53,7 @@ describe('BaseDirector', () => {
         adapterKeyField: 'label',
       });
       director.registerAdapter(adapter1);
-      expect(director.getAdapter(adapter1.label)).toEqual(adapter1);
+      assert.deepStrictEqual(director.getAdapter(adapter1.label), adapter1);
     });
 
     it('should return the correct Adapter object', () => {
@@ -65,46 +62,43 @@ describe('BaseDirector', () => {
       director = BaseDirector(directorName, { adapterKeyField });
       director.registerAdapter(adapter1);
 
-      expect(director.getAdapter(adapter1.key)).toEqual(adapter1);
+      assert.deepStrictEqual(director.getAdapter(adapter1.key), adapter1);
     });
 
     it('should return undefined if the Adapter does not exist', () => {
       const directorName = 'TestDirector';
       const adapterKeyField = 'key';
       director = BaseDirector(directorName, { adapterKeyField });
-      expect(director.getAdapter(adapter1.key)).toBeUndefined();
+      assert.strictEqual(director.getAdapter(adapter1.key), undefined);
     });
   });
 
   describe('getAdapter', () => {
     it('should return the correct Adapter object for a given key', () => {
-      // Expect that calling getAdapter with the key 'foo' returns the fooAdapter
-      expect(director.getAdapter(adapter1.key)).toBe(adapter1);
+      assert.strictEqual(director.getAdapter(adapter1.key), adapter1);
     });
 
     it('should return undefined if no Adapter is registered with the given key', () => {
-      // Expect that calling getAdapter with a key that has not been registered returns undefined
-      expect(director.getAdapter('invalid-key')).toBeUndefined();
+      assert.strictEqual(director.getAdapter('invalid-key'), undefined);
     });
 
     it('should return the correct Adapter object when the keyField is set to a property other than "key"', () => {
-      // Create a director with the keyField option set to 'label'
       director = BaseDirector('TestDirector', { adapterKeyField: 'label' });
       director.registerAdapter(adapter1);
-      expect(director.getAdapter(adapter1.label)).toBe(adapter1);
+      assert.strictEqual(director.getAdapter(adapter1.label), adapter1);
     });
   });
 
   describe('getAdapters', () => {
     it('should return an array of registered Adapter objects', () => {
-      expect(director.getAdapters()).toEqual([adapter1, adapter3, adapter2]);
+      assert.deepStrictEqual(director.getAdapters(), [adapter1, adapter3, adapter2]);
     });
 
     it('should return an empty array if no Adapter objects have been registered', () => {
       const directorName = 'TestDirector';
       const adapterKeyField = 'key';
       const baseDirector = BaseDirector(directorName, { adapterKeyField });
-      expect(baseDirector.getAdapters()).toEqual([]);
+      assert.deepStrictEqual(baseDirector.getAdapters(), []);
     });
 
     it('should return an array of registered Adapter objects sorted by the adapterSortKey provided', () => {
@@ -112,7 +106,7 @@ describe('BaseDirector', () => {
       director.registerAdapter(adapter1);
       director.registerAdapter(adapter3);
       director.registerAdapter(adapter2);
-      expect(director.getAdapters()).toEqual([adapter1, adapter2, adapter3]);
+      assert.deepStrictEqual(director.getAdapters(), [adapter1, adapter2, adapter3]);
     });
   });
 });

package/src/utils-index.test.ts

@@ -1,19 +1,21 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
 import { resolveBestCountry, resolveBestSupported, slugify, systemLocale } from './utils-index.js';
 import generateHashId from './generate-random-hash.js';
 
 describe('Utils', () => {
   it('Locale', () => {
-    expect(systemLocale).toBeDefined();
-    expect(resolveBestCountry).toBeInstanceOf(Function);
-    expect(resolveBestSupported).toBeInstanceOf(Function);
+    assert.ok(systemLocale);
+    assert.equal(typeof resolveBestCountry, 'function');
+    assert.equal(typeof resolveBestSupported, 'function');
   });
 
   describe('generateHashId', () => {
-    it('should create a random hash ', () => {
+    it('should create a random hash', () => {
       const result = generateHashId();
 
-      expect(typeof result).toBe('string');
-      expect(result).toMatch(/^[A-Z0-9]+$/);
+      assert.equal(typeof result, 'string');
+      assert.match(result, /^[A-Z0-9]+$/);
     });
   });
 
@@ -24,7 +26,7 @@ describe('Utils', () => {
 
       const result = slugify(text);
 
-      expect(result).toEqual(expected);
+      assert.equal(result, expected);
     });
 
     it('with a string containing special characters', () => {
@@ -33,7 +35,7 @@ describe('Utils', () => {
 
       const result = slugify(text);
 
-      expect(result).toEqual(expected);
+      assert.equal(result, expected);
     });
 
     it('with a string containing multiple spaces', () => {
@@ -42,7 +44,7 @@ describe('Utils', () => {
 
       const result = slugify(text);
 
-      expect(result).toEqual(expected);
+      assert.equal(result, expected);
     });
 
     it('with a string containing only special characters (leave underscore)', () => {
@@ -51,7 +53,7 @@ describe('Utils', () => {
 
       const result = slugify(text);
 
-      expect(result).toEqual(expected);
+      assert.equal(result, expected);
     });
   });
 });

package/jest.config.js

@@ -1,17 +0,0 @@
-/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
-export default {
-  preset: 'ts-jest/presets/default-esm', // or other ESM presets
-  testEnvironment: 'node',
-  extensionsToTreatAsEsm: ['.ts'],
-  transform: {
-    '^.+\\.tsx?$': [
-      'ts-jest',
-      {
-        useESM: true,
-      },
-    ],
-  },
-  moduleNameMapper: {
-    '^(\\.{1,2}/.*)\\.js$': '$1',
-  },
-};