data-structure-typed 2.1.2 → 2.2.1

package/test/unit/data-structures/binary-tree/red-black-tree.test.ts

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, IBinaryTree, RedBlackTree, RedBlackTreeNode } from '../../../../src';
+import { IBinaryTree, RedBlackTree, RedBlackTreeNode } from '../../../../src';
 import { getRandomInt, getRandomIntArray, magnitude } from '../../../utils';
 import { OrderedMap } from 'js-sdsl';
 
@@ -641,14 +641,14 @@ describe('RedBlackTree 2', () => {
 
     it('The node obtained by get Node should match the node type', () => {
       const node3 = rbTree.getNode(3);
-      expect(node3).toBeInstanceOf(BinaryTreeNode);
-      expect(node3).toBeInstanceOf(BSTNode);
+      // expect(node3).toBeInstanceOf(BinaryTreeNode);
+      // expect(node3).toBeInstanceOf(BSTNode);
       expect(node3).toBeInstanceOf(RedBlackTreeNode);
     });
 
     it('forEach should iterate over all elements', () => {
       const mockCallback = jest.fn();
-      rbTree.forEach((key, value) => {
+      rbTree.forEach((value, key) => {
         mockCallback(key, value);
       });
 
@@ -659,7 +659,7 @@ describe('RedBlackTree 2', () => {
     });
 
     it('filter should return a new rbTree with filtered elements', () => {
-      const filteredTree = rbTree.filter(key => key > 1);
+      const filteredTree = rbTree.filter((_value, key) => key > 1);
       expect(filteredTree.size).toBe(2);
       expect([...filteredTree]).toEqual([
         [2, 'b'],
@@ -668,7 +668,7 @@ describe('RedBlackTree 2', () => {
     });
 
     it('map should return a new rbTree with modified elements', () => {
-      const rbTreeMapped = rbTree.map((key, value) => [(key * 2).toString(), value]);
+      const rbTreeMapped = rbTree.map((value, key) => [(key * 2).toString(), value]);
       expect(rbTreeMapped.size).toBe(3);
       expect([...rbTreeMapped]).toEqual([
         ['2', 'a'],

package/test/unit/data-structures/binary-tree/tree-counter.test.ts

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, IBinaryTree, RedBlackTreeNode, TreeCounter, TreeCounterNode } from '../../../../src';
+import { IBinaryTree, TreeCounter, TreeCounterNode } from '../../../../src';
 import { isDebugTest } from '../../../config';
 import { getRandomInt } from '../../../utils';
 
@@ -757,14 +757,15 @@ describe('TreeCounter iterative methods test', () => {
 
   it('The node obtained by get Node should match the node type', () => {
     const node3 = treeCounter.getNode(3);
-    expect(node3).toBeInstanceOf(BinaryTreeNode);
-    expect(node3).toBeInstanceOf(BSTNode);
-    expect(node3).toBeInstanceOf(RedBlackTreeNode);
+    // expect(node3).toBeInstanceOf(BinaryTreeNode);
+    // expect(node3).toBeInstanceOf(BSTNode);
+    // expect(node3).toBeInstanceOf(RedBlackTreeNode);
+    expect(node3).toBeInstanceOf(TreeCounterNode);
   });
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    treeCounter.forEach((key, value) => {
+    treeCounter.forEach((value, key) => {
       mockCallback(key, value);
     });
 
@@ -775,7 +776,7 @@ describe('TreeCounter iterative methods test', () => {
   });
 
   it('filter should return a new tree with filtered elements', () => {
-    const filteredTree = treeCounter.filter(key => key > 1);
+    const filteredTree = treeCounter.filter((_value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, 'b'],
@@ -784,7 +785,7 @@ describe('TreeCounter iterative methods test', () => {
   });
 
   it('map should return a new tree with modified elements', () => {
-    const treeCounterMapped = treeCounter.map((key, value) => [(key * 2).toString(), value]);
+    const treeCounterMapped = treeCounter.map((value, key) => [(key * 2).toString(), value]);
     expect(treeCounterMapped.size).toBe(3);
     expect([...treeCounterMapped]).toEqual([
       ['2', 'a'],

package/test/unit/data-structures/binary-tree/tree-multi-map.test.ts

@@ -1,6 +1,5 @@
-import { BinaryTreeNode, BSTNode, IBinaryTree, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
+import { IBinaryTree, Range, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
 import { getRandomInt } from '../../../utils';
-import { Range } from '../../../../src';
 import { isDebugTest } from '../../../config';
 import { costOfLiving } from './data/cost-of-living-by-country';
 
@@ -637,14 +636,14 @@ describe('TreeMultiMap 2', () => {
 
     it('The node obtained by get Node should match the node type', () => {
       const node3 = tmm.getNode(3);
-      expect(node3).toBeInstanceOf(BinaryTreeNode);
-      expect(node3).toBeInstanceOf(BSTNode);
+      // expect(node3).toBeInstanceOf(BinaryTreeNode);
+      // expect(node3).toBeInstanceOf(BSTNode);
       expect(node3).toBeInstanceOf(TreeMultiMapNode);
     });
 
     it('forEach should iterate over all elements', () => {
       const mockCallback = jest.fn();
-      tmm.forEach((key, value) => {
+      tmm.forEach((value, key) => {
         mockCallback(key, value);
       });
 
@@ -655,7 +654,7 @@ describe('TreeMultiMap 2', () => {
     });
 
     it('filter should return a new tmm with filtered elements', () => {
-      const filteredTree = tmm.filter(key => key > 1);
+      const filteredTree = tmm.filter((_value, key) => key > 1);
       expect(filteredTree.size).toBe(2);
       expect([...filteredTree]).toEqual([
         [2, ['b']],
@@ -664,7 +663,7 @@ describe('TreeMultiMap 2', () => {
     });
 
     it('map should return a new tmm with modified elements', () => {
-      const tmmMapped = tmm.map((key, value) => [(key * 2).toString(), value ? value : []]);
+      const tmmMapped = tmm.map((value, key) => [(key * 2).toString(), value ? value : []]);
       expect(tmmMapped.size).toBe(3);
       expect([...tmmMapped]).toEqual([
         ['2', ['a']],
@@ -1023,6 +1022,7 @@ function leftKey(tmm: TreeMultiMap<number, Product, Product>): number | undefine
   const v = tmm.getLeftMost();
   return v == null ? undefined : typeof v === 'object' ? v.key : v;
 }
+
 function rightKey(tmm: TreeMultiMap<number, Product, Product>): number | undefined {
   const v = tmm.getRightMost();
   return v == null ? undefined : typeof v === 'object' ? v.key : v;

package/test/unit/data-structures/graph/directed-graph.test.ts

@@ -680,12 +680,12 @@ describe('DirectedGraph iterative Methods', () => {
 
   it('forEach should apply a function to each vertex', () => {
     const result: VertexKey[] = [];
-    graph.forEach(key => key && result.push(key));
+    graph.forEach((_value, key) => key && result.push(key));
     expect(result).toEqual(vertexMap);
   });
 
   it('filter should return vertexMap that satisfy the condition', () => {
-    const filtered = graph.filterEntries(key => key === 'A' || key === 'B');
+    const filtered = graph.filterEntries((_value, key) => key === 'A' || key === 'B');
     expect(filtered).toEqual([
       ['A', undefined],
       ['B', undefined]
@@ -693,7 +693,7 @@ describe('DirectedGraph iterative Methods', () => {
   });
 
   it('map should apply a function to each vertex and return a new array', () => {
-    const mapped = graph.map(vertex => vertex + '_mapped');
+    const mapped = graph.map((_value, vertex) => vertex + '_mapped');
     expect(mapped).toEqual(vertexMap.map(key => key + '_mapped'));
   });
 

package/test/unit/data-structures/hash/hash-map.test.ts

@@ -328,7 +328,7 @@ describe('HashMap', () => {
     });
 
     it('some() returns true if any element matches the condition', () => {
-      expect(hashMap.some(key => key === 'key1')).toBe(true);
+      expect(hashMap.some((_value, key) => key === 'key1')).toBe(true);
     });
 
     it('forEach() should execute a function for each element', () => {
@@ -338,12 +338,12 @@ describe('HashMap', () => {
     });
 
     it('map() should transform each element', () => {
-      const newHashMap = hashMap.map((key, value) => value.toUpperCase());
+      const newHashMap = hashMap.map(value => value.toUpperCase());
       expect(newHashMap.get('key1')).toBe('VALUE1');
     });
 
     it('filter() should remove elements that do not match the condition', () => {
-      const filteredHashMap = hashMap.filter(key => key !== 'key1');
+      const filteredHashMap = hashMap.filter((_, key) => key !== 'key1');
       expect(filteredHashMap.has('key1')).toBe(false);
     });
 
@@ -361,28 +361,28 @@ describe('HashMap', () => {
     });
 
     it('should find', () => {
-      const found = hashMap.find((key, value) => value === 'value1');
+      const found = hashMap.find(value => value === 'value1');
       expect(found).toEqual(['key1', 'value1']);
       const notFound = hashMap.find(value => value === 'value6');
       expect(notFound).toEqual(undefined);
     });
 
     it('should every', () => {
-      const isEvery = hashMap.every((key, value) => value.substring(0, 5) === 'value');
+      const isEvery = hashMap.every(value => value.substring(0, 5) === 'value');
       expect(isEvery).toEqual(true);
-      const isEvery4 = hashMap.every((key, value) => value.substring(0, 4) === 'value');
+      const isEvery4 = hashMap.every(value => value.substring(0, 4) === 'value');
       expect(isEvery4).toEqual(false);
     });
 
     it('should some', () => {
-      const isSome = hashMap.some((key, value) => value.substring(5, 6) === '2');
+      const isSome = hashMap.some(value => value.substring(5, 6) === '2');
       expect(isSome).toEqual(true);
-      const isSome4 = hashMap.some((key, value) => value.substring(0, 5) === 'value');
+      const isSome4 = hashMap.some(value => value.substring(0, 5) === 'value');
       expect(isSome4).toEqual(true);
     });
 
     it('should forEach', () => {
-      hashMap.forEach((key, value, index) => expect(value.substring(5, 6)).toBe(String(index + 1)));
+      hashMap.forEach((value, key, index) => expect(value.substring(5, 6)).toBe(String(index + 1)));
     });
 
     it('should entries', () => {
@@ -817,7 +817,7 @@ describe('LinkedHashMap', () => {
     });
 
     it('some() returns true if any element matches the condition', () => {
-      expect(hashMap.some(key => key === 'key1')).toBe(true);
+      expect(hashMap.some((_value, key) => key === 'key1')).toBe(true);
     });
 
     it('forEach() should execute a function for each element', () => {
@@ -827,12 +827,12 @@ describe('LinkedHashMap', () => {
     });
 
     it('map() should transform each element', () => {
-      const newHashMap = hashMap.map((key, value) => [key, value.toUpperCase()]);
+      const newHashMap = hashMap.map((value, key) => [key, value.toUpperCase()]);
       expect(newHashMap.get('key1')).toBe('VALUE1');
     });
 
     it('filter() should remove elements that do not match the condition', () => {
-      const filteredHashMap = hashMap.filter(key => key !== 'key1');
+      const filteredHashMap = hashMap.filter((_v, key) => key !== 'key1');
       expect(filteredHashMap.has('key1')).toBe(false);
     });
 
@@ -893,7 +893,7 @@ describe('classic uses', () => {
     linkedHashMap.set(2, 'B');
     linkedHashMap.set(3, 'C');
 
-    const filteredMap = linkedHashMap.filter((key, value) => value !== 'B');
+    const filteredMap = linkedHashMap.filter(value => value !== 'B');
 
     const result = Array.from(filteredMap);
     expect(result).toEqual([
@@ -907,7 +907,7 @@ describe('classic uses', () => {
     linkedHashMap.set(1, 'A');
     linkedHashMap.set(2, 'B');
 
-    const mappedMap = linkedHashMap.map((key, value) => [value, key]);
+    const mappedMap = linkedHashMap.map((value, key) => [value, key]);
 
     const result = Array.from(mappedMap);
     expect(result).toEqual([

package/tsup.node.config.js

@@ -1,7 +1,7 @@
 import { defineConfig } from "tsup";
 
 export default defineConfig([
-  // ESM
+  // ESM (modern) - ES2022
   {
     entry: { index: "src/index.ts" },
     format: ["esm"],
@@ -12,13 +12,30 @@ export default defineConfig([
     keepNames: true,
     treeshake: true,
     clean: true,
+    target: "es2022",
+    outExtension() {
+      return { js: ".mjs" };
+    }
+  },
+
+  // ESM (legacy) - ES2018
+  {
+    entry: { index: "src/index.ts" },
+    format: ["esm"],
+    outDir: "dist/esm-legacy",
+    splitting: false,
+    sourcemap: true,
+    minify: false,
+    keepNames: true,
+    treeshake: true,
+    clean: false,
     target: "es2018",
     outExtension() {
-      return { js: ".mjs" }
-    },
+      return { js: ".mjs" };
+    }
   },
 
-  // CJS
+  // CJS (modern) - ES2022
   {
     entry: { index: "src/index.ts" },
     format: ["cjs"],
@@ -29,9 +46,26 @@ export default defineConfig([
     keepNames: true,
     treeshake: true,
     clean: false,
-    target: "es2018",
+    target: "es2022",
     outExtension() {
       return { js: ".cjs" };
-    },
+    }
   },
+
+  // CJS (legacy) - ES2018
+  {
+    entry: { index: "src/index.ts" },
+    format: ["cjs"],
+    outDir: "dist/cjs-legacy",
+    splitting: false,
+    sourcemap: true,
+    minify: false,
+    keepNames: true,
+    treeshake: true,
+    clean: false,
+    target: "es2018",
+    outExtension() {
+      return { js: ".cjs" };
+    }
+  }
 ]);