data-structure-typed 1.46.2 → 1.46.4

package/dist/mjs/data-structures/queue/deque.js

@@ -5,87 +5,13 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { calcMinUnitsRequired, rangeCheck, throwRangeError } from "../../utils";
+import { calcMinUnitsRequired, rangeCheck } from "../../utils";
 /**
  * Deque can provide random access with O(1) time complexity
  * Deque is usually more compact and efficient in memory usage because it does not require additional space to store pointers.
  * Deque may experience performance jitter, but DoublyLinkedList will not
  * Deque is implemented using a dynamic array. Inserting or deleting beyond both ends of the array may require moving elements or reallocating space.
  */
-export class DequeIterator {
-    iterateDirection;
-    index;
-    deque;
-    /**
-     * The constructor initializes the index, iterate direction, and prev/next functions for a
-     * DequeIterator object.
-     * @param {number} index - The index parameter represents the current index position of the iterator
-     * within the deque. It is a number that indicates the position of the element that the iterator is
-     * currently pointing to.
-     * @param deque - The `deque` parameter is an instance of the `Deque` class. It represents a
-     * double-ended queue data structure, which allows elements to be added or removed from both ends.
-     * @param iterateDirection - The `iterateDirection` parameter is an optional parameter that specifies
-     * the direction in which the iterator should iterate over the elements of the `deque`. It has a
-     * default value of `IterateDirection.DEFAULT`.
-     * @returns The constructor is not returning anything. It is used to initialize the properties of the
-     * object being created.
-     */
-    constructor(index, deque, iterateDirection = 0 /* IterateDirection.DEFAULT */) {
-        this.index = index;
-        this.iterateDirection = iterateDirection;
-        if (this.iterateDirection === 0 /* IterateDirection.DEFAULT */) {
-            this.prev = function () {
-                if (this.index === 0) {
-                    throwRangeError();
-                }
-                this.index -= 1;
-                return this;
-            };
-            this.next = function () {
-                if (this.index === this.deque.size) {
-                    throwRangeError();
-                }
-                this.index += 1;
-                return this;
-            };
-        }
-        else {
-            this.prev = function () {
-                if (this.index === this.deque.size - 1) {
-                    throwRangeError();
-                }
-                this.index += 1;
-                return this;
-            };
-            this.next = function () {
-                if (this.index === -1) {
-                    throwRangeError();
-                }
-                this.index -= 1;
-                return this;
-            };
-        }
-        this.deque = deque;
-    }
-    get current() {
-        return this.deque.getAt(this.index);
-    }
-    set current(newElement) {
-        this.deque.setAt(this.index, newElement);
-    }
-    isAccessible() {
-        return this.index !== this.deque.size;
-    }
-    prev() {
-        return this;
-    }
-    next() {
-        return this;
-    }
-    clone() {
-        return new DequeIterator(this.index, this.deque, this.iterateDirection);
-    }
-}
 export class Deque {
     _bucketFirst = 0;
     _firstInBucket = 0;
@@ -220,35 +146,25 @@ export class Deque {
         this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
     }
     /**
-     * The `begin()` function returns a new iterator for a deque starting from the first element.
-     * @returns A new instance of the DequeIterator class is being returned.
-     */
-    begin() {
-        return new DequeIterator(0, this);
-    }
-    /**
-     * The `end()` function returns a new `DequeIterator` object with the size and reference to the
-     * current deque.
-     * @returns A new instance of the DequeIterator class is being returned.
+     * The below function is a generator that yields elements from a collection one by one.
      */
-    end() {
-        return new DequeIterator(this.size, this);
-    }
-    /**
-     * The reverseBegin function returns a new DequeIterator object that starts at the last element of
-     * the deque and iterates in reverse direction.
-     * @returns A new instance of the DequeIterator class is being returned.
-     */
-    reverseBegin() {
-        return new DequeIterator(this.size - 1, this, 1 /* IterateDirection.REVERSE */);
+    *begin() {
+        let index = 0;
+        while (index < this.size) {
+            yield this.getAt(index);
+            index++;
+        }
     }
     /**
-     * The reverseEnd() function returns a new DequeIterator object that iterates over the elements of a
-     * Deque in reverse order.
-     * @returns A new instance of the DequeIterator class is being returned.
+     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
+     * the last element.
      */
-    reverseEnd() {
-        return new DequeIterator(-1, this, 1 /* IterateDirection.REVERSE */);
+    *reverseBegin() {
+        let index = this.size - 1;
+        while (index >= 0) {
+            yield this.getAt(index);
+            index--;
+        }
     }
     /**
      * Time Complexity - Amortized O(1) (possible reallocation)
@@ -555,46 +471,6 @@ export class Deque {
         this.cut(index - 1);
         return this.size;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function deletes an element from a deque using an iterator and returns the next iterator.
-     * @param iter - The parameter `iter` is of type `DequeIterator<E>`. It represents an iterator object
-     * that is used to iterate over elements in a deque (double-ended queue).
-     * @returns the updated iterator after deleting an element from the deque.
-     */
-    deleteByIterator(iter) {
-        const index = iter.index;
-        this.deleteAt(index);
-        iter = iter.next();
-        return iter;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function `findIterator` searches for an element in a deque and returns an iterator pointing to
-     * the element if found, otherwise it returns an iterator pointing to the end of the deque.
-     * @param {E} element - The `element` parameter is the element that you want to find in the deque.
-     * @returns The method `findIterator(element: E)` returns a `DequeIterator<E>` object.
-     */
-    findIterator(element) {
-        for (let i = 0; i < this.size; ++i) {
-            if (this.getAt(i) === element) {
-                return new DequeIterator(i, this);
-            }
-        }
-        return this.end();
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

package/dist/mjs/types/data-structures/hash/hash-map.d.ts

@@ -4,3 +4,8 @@ export type HashMapLinkedNode<K, V> = {
     next: HashMapLinkedNode<K, V>;
     prev: HashMapLinkedNode<K, V>;
 };
+export type HashMapOptions<K, V> = {
+    elements: Iterable<[K, V]>;
+    hashFn: (key: K) => string;
+    objHashFn: (key: K) => WeakKey;
+};

package/dist/mjs/types/data-structures/hash/index.d.ts

@@ -1,7 +1,3 @@
-export * from './coordinate-map';
-export * from './coordinate-set';
 export * from './hash-map';
 export * from './hash-table';
-export * from './tree-map';
-export * from './tree-set';
 export type HashFunction<K> = (key: K) => number;

package/dist/mjs/types/data-structures/hash/index.js

@@ -1,6 +1,2 @@
-export * from './coordinate-map';
-export * from './coordinate-set';
 export * from './hash-map';
 export * from './hash-table';
-export * from './tree-map';
-export * from './tree-set';

package/dist/mjs/utils/utils.d.ts

@@ -20,5 +20,5 @@ export declare const trampolineAsync: (fn: TrlAsyncFn) => ((...args: [...Paramet
 export declare const getMSB: (value: number) => number;
 export declare const rangeCheck: (index: number, min: number, max: number, message?: string) => void;
 export declare const throwRangeError: (message?: string) => void;
-export declare const isObjOrFunc: (input: unknown) => input is Record<string, unknown> | ((...args: any[]) => any);
+export declare const isWeakKey: (input: unknown) => input is WeakKey;
 export declare const calcMinUnitsRequired: (totalQuantity: number, unitSize: number) => number;

package/dist/mjs/utils/utils.js

@@ -59,7 +59,7 @@ export const rangeCheck = (index, min, max, message = 'Index out of bounds.') =>
 export const throwRangeError = (message = 'The value is off-limits.') => {
     throw new RangeError(message);
 };
-export const isObjOrFunc = (input) => {
+export const isWeakKey = (input) => {
     const inputType = typeof input;
     return (inputType === 'object' && input !== null) || inputType === 'function';
 };