data-structure-typed 1.46.1 → 1.46.3

package/src/types/helpers.ts

@@ -16,11 +16,11 @@ export const enum IterateDirection {
 }
 
 export interface IterableWithSize<T> extends Iterable<T> {
-  size: number;
+  size: number | ((...args: any[]) => number);
 }
 
 export interface IterableWithLength<T> extends Iterable<T> {
-  length: number;
+  length: number | ((...args: any[]) => number);
 }
 
 export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>

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

@@ -5,42 +5,42 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { TEN_THOUSAND } = magnitude;
+const { MILLION } = magnitude;
 
-suite.add(`${TEN_THOUSAND.toLocaleString()} set`, () => {
+suite.add(`${MILLION.toLocaleString()} set`, () => {
   const hm = new HashMap<number, number>();
 
-  for (let i = 0; i < TEN_THOUSAND; i++) {
+  for (let i = 0; i < MILLION; i++) {
     hm.set(i, i);
   }
 });
 if (isCompetitor) {
-  suite.add(`${TEN_THOUSAND.toLocaleString()} CPT set`, () => {
+  suite.add(`${MILLION.toLocaleString()} CPT set`, () => {
     const hm = new CHashMap<number, number>();
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
+    for (let i = 0; i < MILLION; i++) {
       hm.setElement(i, i);
     }
   });
 }
-suite.add(`${TEN_THOUSAND.toLocaleString()} set & get`, () => {
+suite.add(`${MILLION.toLocaleString()} set & get`, () => {
   const hm = new HashMap<number, number>();
 
-  for (let i = 0; i < TEN_THOUSAND; i++) {
+  for (let i = 0; i < MILLION; i++) {
     hm.set(i, i);
   }
-  for (let i = 0; i < TEN_THOUSAND; i++) {
+  for (let i = 0; i < MILLION; i++) {
     hm.get(i);
   }
 });
 if (isCompetitor) {
-  suite.add(`${TEN_THOUSAND.toLocaleString()} CPT set & get`, () => {
+  suite.add(`${MILLION.toLocaleString()} CPT set & get`, () => {
     const hm = new CHashMap<number, number>();
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
+    for (let i = 0; i < MILLION; i++) {
       hm.setElement(i, i);
     }
-    for (let i = 0; i < TEN_THOUSAND; i++) {
+    for (let i = 0; i < MILLION; i++) {
       hm.getElementByKey(i);
     }
   });

package/test/performance/reportor.ts

@@ -25,17 +25,20 @@ const reportDistPath = path.join(parentDirectory, 'benchmark');
 
 const testDir = path.join(__dirname, 'data-structures');
 const allFiles = fastGlob.sync(path.join(testDir, '**', '*.test.ts'));
-let testFiles: string[] = [];
+let testFiles: string[];
+
+let isIndividual = false;
 if (args.length > 0) {
   console.log(`arguments: ${args.join(' ')}`)
 
   testFiles = allFiles.filter(file =>
     args.every(word => file.includes(word))
   );
-
+  isIndividual = true;
   console.log(`${testFiles.map(file => coloredLabeled('Matched', file)).join(`
 `)}`);
 } else {
+  isIndividual = false;
   testFiles = allFiles;
 }
 
@@ -129,7 +132,7 @@ const composeReport = () => {
   html += `</div>
                     </body>
                   </html>`;
-  replaceMarkdownContent(
+  if (!isIndividual) replaceMarkdownContent(
     '[//]: # (No deletion!!! Start of Replace Section)', // Start tag
     '[//]: # (No deletion!!! End of Replace Section)', // end identifier
     htmlTables // New content to be inserted

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

@@ -172,15 +172,14 @@ describe('HashMap', () => {
     stdMap.forEach((value, key) => {
       if (index === 0) {
         expect(hashMap.first).toEqual([key, value]);
-        expect(hashMap.begin.current[0]).toEqual(key);
+        expect(hashMap.begin().next().value).toEqual([key, value]);
       } else if (index === hashMap.size - 1) {
         expect(hashMap.last).toEqual([key, value]);
-        expect(hashMap.reverseBegin.current[0]).toEqual(key);
+        expect(hashMap.reverseBegin().next().value).toEqual([key, value]);
       } else if (index <= 1000) {
         expect(hashMap.getAt(index)).toEqual([key, value]);
       }
       expect(hashMap.get(key)).toEqual(value);
-      expect(hashMap.getIterator(key).current[1]).toEqual(value);
       index++;
     });
   }
@@ -210,8 +209,8 @@ describe('HashMap', () => {
   test('should iterate correctly with reverse iterators', () => {
     hashMap.set('key1', 'value1');
     hashMap.set('key2', 'value2');
-    const iterator = hashMap.reverseBegin;
-    expect(iterator.next().current).toEqual(['key1', 'value1']);
+    const iterator = hashMap.reverseBegin();
+    expect(iterator.next().value).toEqual(['key2', 'value2']);
   });
 
   test('should return the last element', () => {

package/test/unit/data-structures/queue/deque.test.ts

@@ -419,4 +419,32 @@ describe('Deque', () => {
     expect(deque.indexOf(2)).toBe(1);
     expect(deque.indexOf(4)).toBe(-1);
   });
+
+
+  //Test begin method
+  describe('begin()', () => {
+    it('should return an iterator at the beginning of the deque', () => {
+      deque.push(1);
+      deque.push(2);
+      deque.push(3);
+
+      const iterator = deque.begin();
+
+      expect(iterator.next().value).toBe(1);
+    });
+  });
+
+  // Test the reverse Begin method
+  describe('reverseBegin()', () => {
+    it('should return a reverse iterator at the beginning of the deque', () => {
+      deque.push(1);
+      deque.push(2);
+      deque.push(3);
+
+      const iterator = deque.reverseBegin();
+
+      expect(iterator.next().value).toBe(3);
+    });
+  });
+
 });