data-structure-typed 1.38.0 → 1.38.2

package/{lib → dist/mjs}/data-structures/hash/hash-map.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashMap = void 0;
 /**
  * data-structure-typed
  *
@@ -5,43 +8,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export class HashMap {
-    get hashFn() {
-        return this._hashFn;
-    }
-    set hashFn(value) {
-        this._hashFn = value;
-    }
-    get table() {
-        return this._table;
-    }
-    set table(value) {
-        this._table = value;
-    }
-    get capacityMultiplier() {
-        return this._capacityMultiplier;
-    }
-    set capacityMultiplier(value) {
-        this._capacityMultiplier = value;
-    }
-    get loadFactor() {
-        return this._loadFactor;
-    }
-    set loadFactor(value) {
-        this._loadFactor = value;
-    }
-    get initialCapacity() {
-        return this._initialCapacity;
-    }
-    set initialCapacity(value) {
-        this._initialCapacity = value;
-    }
-    get size() {
-        return this._size;
-    }
-    set size(value) {
-        this._size = value;
-    }
+class HashMap {
     /**
      * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
      * multiplier, size, table array, and hash function.
@@ -71,30 +38,47 @@ export class HashMap {
                     return hash % this.table.length;
                 });
     }
-    _hash(key) {
-        return this._hashFn(key);
+    _initialCapacity;
+    get initialCapacity() {
+        return this._initialCapacity;
     }
-    /**
-     * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
-     * rehashing the key-value pairs from the old table into the new table.
-     * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
-     * the number of buckets that the new table should have.
-     */
-    resizeTable(newCapacity) {
-        const newTable = new Array(newCapacity);
-        for (const bucket of this._table) {
-            // Note that this is this._table
-            if (bucket) {
-                for (const [key, value] of bucket) {
-                    const newIndex = this._hash(key) % newCapacity;
-                    if (!newTable[newIndex]) {
-                        newTable[newIndex] = [];
-                    }
-                    newTable[newIndex].push([key, value]);
-                }
-            }
-        }
-        this._table = newTable; // Again, here is this._table
+    set initialCapacity(value) {
+        this._initialCapacity = value;
+    }
+    _loadFactor;
+    get loadFactor() {
+        return this._loadFactor;
+    }
+    set loadFactor(value) {
+        this._loadFactor = value;
+    }
+    _capacityMultiplier;
+    get capacityMultiplier() {
+        return this._capacityMultiplier;
+    }
+    set capacityMultiplier(value) {
+        this._capacityMultiplier = value;
+    }
+    _size;
+    get size() {
+        return this._size;
+    }
+    set size(value) {
+        this._size = value;
+    }
+    _table;
+    get table() {
+        return this._table;
+    }
+    set table(value) {
+        this._table = value;
+    }
+    _hashFn;
+    get hashFn() {
+        return this._hashFn;
+    }
+    set hashFn(value) {
+        this._hashFn = value;
     }
     set(key, value) {
         const loadFactor = this.size / this.table.length;
@@ -164,4 +148,30 @@ export class HashMap {
     isEmpty() {
         return this.size === 0;
     }
+    _hash(key) {
+        return this._hashFn(key);
+    }
+    /**
+     * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
+     * rehashing the key-value pairs from the old table into the new table.
+     * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
+     * the number of buckets that the new table should have.
+     */
+    resizeTable(newCapacity) {
+        const newTable = new Array(newCapacity);
+        for (const bucket of this._table) {
+            // Note that this is this._table
+            if (bucket) {
+                for (const [key, value] of bucket) {
+                    const newIndex = this._hash(key) % newCapacity;
+                    if (!newTable[newIndex]) {
+                        newTable[newIndex] = [];
+                    }
+                    newTable[newIndex].push([key, value]);
+                }
+            }
+        }
+        this._table = newTable; // Again, here is this._table
+    }
 }
+exports.HashMap = HashMap;

package/{lib → dist/mjs}/data-structures/hash/hash-table.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * data-structure-typed
  *
@@ -5,121 +6,52 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export class HashTableNode {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashTable = exports.HashTableNode = void 0;
+class HashTableNode {
+    key;
+    val;
+    next;
     constructor(key, val) {
         this.key = key;
         this.val = val;
         this.next = null;
     }
 }
-export class HashTable {
-    get hashFn() {
-        return this._hashFn;
-    }
-    set hashFn(value) {
-        this._hashFn = value;
-    }
-    get buckets() {
-        return this._buckets;
-    }
-    set buckets(value) {
-        this._buckets = value;
-    }
-    get capacity() {
-        return this._capacity;
-    }
-    set capacity(value) {
-        this._capacity = value;
-    }
+exports.HashTableNode = HashTableNode;
+class HashTable {
+    static DEFAULT_CAPACITY = 16;
+    static LOAD_FACTOR = 0.75;
     constructor(capacity = HashTable.DEFAULT_CAPACITY, hashFn) {
         this._hashFn = hashFn || this._defaultHashFn;
         this._capacity = Math.max(capacity, HashTable.DEFAULT_CAPACITY);
         this._size = 0;
         this._buckets = new Array(this._capacity).fill(null);
     }
-    /**
-     * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
-     * capacity of the data structure.
-     * @param {K} key - The `key` parameter is the input value that needs to be hashed. It can be of any type, but in this
-     * code snippet, it is checked whether the key is a string or an object. If it is a string, the `_murmurStringHashFn`
-     * function is used to
-     * @returns the hash value of the key modulo the capacity of the data structure.
-     */
-    _defaultHashFn(key) {
-        // Can be replaced with other hash functions as needed
-        const hashValue = typeof key === 'string' ? this._murmurStringHashFn(key) : this._objectHash(key);
-        return hashValue % this._capacity;
+    _capacity;
+    get capacity() {
+        return this._capacity;
     }
-    /**
-     * The `_multiplicativeStringHashFn` function calculates a hash value for a given string key using the multiplicative
-     * string hash function.
-     * @param {K} key - The `key` parameter is the input value for which we want to calculate the hash. It can be of any
-     * type, as it is generic (`K`). The function converts the `key` to a string using the `String()` function.
-     * @returns a number, which is the result of the multiplicative string hash function applied to the input key.
-     */
-    _multiplicativeStringHashFn(key) {
-        const keyString = String(key);
-        let hash = 0;
-        for (let i = 0; i < keyString.length; i++) {
-            const charCode = keyString.charCodeAt(i);
-            // Some constants for adjusting the hash function
-            const A = 0.618033988749895;
-            const M = 1 << 30; // 2^30
-            hash = (hash * A + charCode) % M;
-        }
-        return Math.abs(hash); // Take absolute value to ensure non-negative numbers
+    set capacity(value) {
+        this._capacity = value;
     }
-    /**
-     * The function `_murmurStringHashFn` calculates a hash value for a given string key using the MurmurHash algorithm.
-     * @param {K} key - The `key` parameter is the input value for which you want to calculate the hash. It can be of any
-     * type, but it will be converted to a string using the `String()` function before calculating the hash.
-     * @returns a number, which is the hash value calculated for the given key.
-     */
-    _murmurStringHashFn(key) {
-        const keyString = String(key);
-        const seed = 0;
-        let hash = seed;
-        for (let i = 0; i < keyString.length; i++) {
-            const char = keyString.charCodeAt(i);
-            hash = (hash ^ char) * 0x5bd1e995;
-            hash = (hash ^ (hash >>> 15)) * 0x27d4eb2d;
-            hash = hash ^ (hash >>> 15);
-        }
-        return Math.abs(hash);
+    _size;
+    get size() {
+        return this._size;
     }
-    /**
-     * The _hash function takes a key and returns a number.
-     * @param {K} key - The parameter "key" is of type K, which represents the type of the key that will be hashed.
-     * @returns The hash function is returning a number.
-     */
-    _hash(key) {
-        return this.hashFn(key);
+    _buckets;
+    get buckets() {
+        return this._buckets;
     }
-    /**
-     * The function calculates a hash value for a given string using the djb2 algorithm.
-     * @param {string} key - The `key` parameter in the `stringHash` function is a string value that represents the input for
-     * which we want to calculate the hash value.
-     * @returns a number, which is the hash value of the input string.
-     */
-    _stringHash(key) {
-        let hash = 0;
-        for (let i = 0; i < key.length; i++) {
-            hash = (hash * 31 + key.charCodeAt(i)) & 0xffffffff;
-        }
-        return hash;
+    set buckets(value) {
+        this._buckets = value;
     }
-    /**
-     * The function `_objectHash` takes a key and returns a hash value, using a custom hash function for objects.
-     * @param {K} key - The parameter "key" is of type "K", which means it can be any type. It could be a string, number,
-     * boolean, object, or any other type of value. The purpose of the objectHash function is to generate a hash value for
-     * the key, which can be used for
-     * @returns a number, which is the hash value of the key.
-     */
-    _objectHash(key) {
-        // If the key is an object, you can write a custom hash function
-        // For example, convert the object's properties to a string and use string hashing
-        // This is just an example; you should write a specific object hash function as needed
-        return this._stringHash(JSON.stringify(key));
+    _hashFn;
+    get hashFn() {
+        return this._hashFn;
+    }
+    set hashFn(value) {
+        this._hashFn = value;
     }
     /**
      * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
@@ -204,6 +136,90 @@ export class HashTable {
             currentNode = currentNode.next;
         }
     }
+    /**
+     * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
+     * capacity of the data structure.
+     * @param {K} key - The `key` parameter is the input value that needs to be hashed. It can be of any type, but in this
+     * code snippet, it is checked whether the key is a string or an object. If it is a string, the `_murmurStringHashFn`
+     * function is used to
+     * @returns the hash value of the key modulo the capacity of the data structure.
+     */
+    _defaultHashFn(key) {
+        // Can be replaced with other hash functions as needed
+        const hashValue = typeof key === 'string' ? this._murmurStringHashFn(key) : this._objectHash(key);
+        return hashValue % this._capacity;
+    }
+    /**
+     * The `_multiplicativeStringHashFn` function calculates a hash value for a given string key using the multiplicative
+     * string hash function.
+     * @param {K} key - The `key` parameter is the input value for which we want to calculate the hash. It can be of any
+     * type, as it is generic (`K`). The function converts the `key` to a string using the `String()` function.
+     * @returns a number, which is the result of the multiplicative string hash function applied to the input key.
+     */
+    _multiplicativeStringHashFn(key) {
+        const keyString = String(key);
+        let hash = 0;
+        for (let i = 0; i < keyString.length; i++) {
+            const charCode = keyString.charCodeAt(i);
+            // Some constants for adjusting the hash function
+            const A = 0.618033988749895;
+            const M = 1 << 30; // 2^30
+            hash = (hash * A + charCode) % M;
+        }
+        return Math.abs(hash); // Take absolute value to ensure non-negative numbers
+    }
+    /**
+     * The function `_murmurStringHashFn` calculates a hash value for a given string key using the MurmurHash algorithm.
+     * @param {K} key - The `key` parameter is the input value for which you want to calculate the hash. It can be of any
+     * type, but it will be converted to a string using the `String()` function before calculating the hash.
+     * @returns a number, which is the hash value calculated for the given key.
+     */
+    _murmurStringHashFn(key) {
+        const keyString = String(key);
+        const seed = 0;
+        let hash = seed;
+        for (let i = 0; i < keyString.length; i++) {
+            const char = keyString.charCodeAt(i);
+            hash = (hash ^ char) * 0x5bd1e995;
+            hash = (hash ^ (hash >>> 15)) * 0x27d4eb2d;
+            hash = hash ^ (hash >>> 15);
+        }
+        return Math.abs(hash);
+    }
+    /**
+     * The _hash function takes a key and returns a number.
+     * @param {K} key - The parameter "key" is of type K, which represents the type of the key that will be hashed.
+     * @returns The hash function is returning a number.
+     */
+    _hash(key) {
+        return this.hashFn(key);
+    }
+    /**
+     * The function calculates a hash value for a given string using the djb2 algorithm.
+     * @param {string} key - The `key` parameter in the `stringHash` function is a string value that represents the input for
+     * which we want to calculate the hash value.
+     * @returns a number, which is the hash value of the input string.
+     */
+    _stringHash(key) {
+        let hash = 0;
+        for (let i = 0; i < key.length; i++) {
+            hash = (hash * 31 + key.charCodeAt(i)) & 0xffffffff;
+        }
+        return hash;
+    }
+    /**
+     * The function `_objectHash` takes a key and returns a hash value, using a custom hash function for objects.
+     * @param {K} key - The parameter "key" is of type "K", which means it can be any type. It could be a string, number,
+     * boolean, object, or any other type of value. The purpose of the objectHash function is to generate a hash value for
+     * the key, which can be used for
+     * @returns a number, which is the hash value of the key.
+     */
+    _objectHash(key) {
+        // If the key is an object, you can write a custom hash function
+        // For example, convert the object's properties to a string and use string hashing
+        // This is just an example; you should write a specific object hash function as needed
+        return this._stringHash(JSON.stringify(key));
+    }
     /**
      * The `expand` function increases the capacity of a hash table by creating a new array of buckets with double the
      * capacity and rehashing all the existing key-value pairs into the new buckets.
@@ -232,9 +248,5 @@ export class HashTable {
         this._buckets = newBuckets;
         this._capacity = newCapacity;
     }
-    get size() {
-        return this._size;
-    }
 }
-HashTable.DEFAULT_CAPACITY = 16;
-HashTable.LOAD_FACTOR = 0.75;
+exports.HashTable = HashTable;

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

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hash-table"), exports);
+__exportStar(require("./coordinate-map"), exports);
+__exportStar(require("./coordinate-set"), exports);
+__exportStar(require("./tree-map"), exports);
+__exportStar(require("./tree-set"), exports);
+__exportStar(require("./hash-map"), exports);

package/dist/mjs/data-structures/hash/tree-map.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeMap = void 0;
+class TreeMap {
+}
+exports.TreeMap = TreeMap;

package/dist/mjs/data-structures/hash/tree-set.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeSet = void 0;
+class TreeSet {
+}
+exports.TreeSet = TreeSet;