data-structure-typed 0.9.16 → 1.3.0

package/dist/data-structures/hash/coordinate-set.js

@@ -1,39 +1,55 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoordinateSet = void 0;
-var CoordinateSet = /** @class */ (function (_super) {
-    __extends(CoordinateSet, _super);
-    function CoordinateSet(joint) {
-        var _this = _super.call(this) || this;
-        _this._joint = '_';
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+class CoordinateSet extends Set {
+    constructor(joint) {
+        super();
+        this._joint = '_';
         if (joint !== undefined)
-            _this._joint = joint;
-        return _this;
+            this._joint = joint;
     }
-    CoordinateSet.prototype.has = function (value) {
-        return _super.prototype.has.call(this, value.join(this._joint));
-    };
-    CoordinateSet.prototype.add = function (value) {
-        return _super.prototype.add.call(this, value.join(this._joint));
-    };
-    CoordinateSet.prototype.delete = function (value) {
-        return _super.prototype.delete.call(this, value.join(this._joint));
-    };
-    return CoordinateSet;
-}(Set));
+    get joint() {
+        return this._joint;
+    }
+    /**
+     * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
+     * joining its elements with a specified separator.
+     * @param {number[]} value - The parameter "value" is an array of numbers.
+     * @returns The overridden `has` method is returning the result of calling the `has` method of the superclass, passing
+     * in the joined value as an argument.
+     */
+    has(value) {
+        return super.has(value.join(this._joint));
+    }
+    /**
+     * The "add" function overrides the parent class's "add" function by joining the elements of the input array with a
+     * specified delimiter before calling the parent class's "add" function.
+     * @param {number[]} value - An array of numbers
+     * @returns The overridden `add` method is returning the result of calling the `add` method of the superclass
+     * (`super.add`) with the joined string representation of the `value` array (`value.join(this._joint)`).
+     */
+    add(value) {
+        return super.add(value.join(this._joint));
+    }
+    /**
+     * The function overrides the delete method and deletes an element from a Set by joining the elements of the input
+     * array with a specified joint and then calling the delete method of the parent class.
+     * @param {number[]} value - An array of numbers
+     * @returns The `delete` method is returning the result of calling the `delete` method of the superclass, with the
+     * `value` array joined together using the `_joint` property.
+     */
+    delete(value) {
+        return super.delete(value.join(this._joint));
+    }
+    _setJoint(v) {
+        this._joint = v;
+    }
+}
 exports.CoordinateSet = CoordinateSet;

package/dist/data-structures/hash/hash-table.d.ts

@@ -1 +1,2 @@
-export {};
+export declare class HashTable {
+}

package/dist/data-structures/hash/hash-table.js

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

package/dist/data-structures/hash/pair.d.ts

@@ -1 +1,2 @@
-export {};
+export declare class Pair {
+}

package/dist/data-structures/hash/pair.js

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

package/dist/data-structures/hash/tree-map.d.ts

@@ -1 +1,2 @@
-export {};
+export declare class TreeMap {
+}

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

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

package/dist/data-structures/hash/tree-set.d.ts

@@ -1 +1,2 @@
-export {};
+export declare class TreeSet {
+}

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

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

package/dist/data-structures/heap/heap.d.ts

@@ -1,66 +1,83 @@
-import { PriorityQueue } from '../priority-queue';
-import type { HeapItem, HeapOptions } from '../types';
 /**
- * @copyright 2021 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
  *
- * @abstract
- * @class Heap
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
-export declare abstract class Heap<T> {
-    protected abstract _pq: PriorityQueue<HeapItem<T>>;
-    protected _priorityCb: (element: T) => number;
+import { PriorityQueue } from '../priority-queue';
+import type { HeapOptions } from '../../types';
+export declare class HeapItem<T = number> {
     /**
-     * Creates a priority queue
-     * @public
-     * @params {object} [options]
+     * The constructor function initializes an instance of a class with a priority and a value.
+     * @param {number} priority - The `priority` parameter is a number that represents the priority of the value. It is
+     * optional and has a default value of `NaN`.
+     * @param {T | null} [val=null] - The `val` parameter is of type `T | null`, which means it can accept a value of type
+     * `T` or `null`.
+     */
+    constructor(priority?: number, val?: T | null);
+    private _priority;
+    get priority(): number;
+    set priority(value: number);
+    private _val;
+    get val(): T | null;
+    set val(value: T | null);
+}
+export declare abstract class Heap<T = number> {
+    /**
+     * The function is a constructor for a class that initializes a priority callback function based on the
+     * options provided.
+     * @param [options] - An optional object that contains configuration options for the Heap.
      */
     protected constructor(options?: HeapOptions<T>);
+    protected abstract _pq: PriorityQueue<HeapItem<T>>;
+    get pq(): PriorityQueue<HeapItem<T>>;
+    protected _priorityExtractor: (val: T) => number;
+    get priorityExtractor(): (val: T) => number;
     /**
-     * @public
-     * @returns {number}
+     * The function returns the size of a priority queue.
+     * @returns The size of the priority queue.
      */
     get size(): number;
     /**
-     * @public
-     * @returns {boolean}
+     * The function checks if a priority queue is empty.
+     * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
      */
     isEmpty(): boolean;
+    peek(isItem?: undefined): T | undefined;
+    peek(isItem: false): T | undefined;
+    peek(isItem: true): HeapItem<T> | null;
+    peekLast(isItem?: undefined): T | undefined;
+    peekLast(isItem: false): T | undefined;
+    peekLast(isItem: true): HeapItem<T> | null;
     /**
-     * Returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
-     */
-    peek(): HeapItem<T> | null;
-    /**
-     * Returns an element with lowest priority in the queue
-     * @public
-     * @returns {object}
-     */
-    peekLast(): HeapItem<T> | null;
-    /**
-     * Adds an element to the queue
-     * @public
-     * @param {any} element
-     * @param priority
+     * The `add` function adds an val to a priority queue with an optional priority value.
+     * @param {T} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
+     * type.
+     * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
+     * val being added to the heap. If the `val` parameter is a number, then the `priority` parameter is set to
+     * the value of `val`. If the `val` parameter is not a number, then the
+     * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    offer(element: T, priority?: number): Heap<T>;
-    /**
-     * Removes and returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
-     */
-    poll(): HeapItem<T> | null;
+    add(priority: number, val?: T): Heap<T>;
+    poll(isItem?: undefined): T | undefined;
+    poll(isItem: false): T | undefined;
+    poll(isItem: true): HeapItem<T> | null;
     /**
-     * Returns a sorted list of elements
-     * @public
-     * @returns {array}
+     * The function checks if a given node or value exists in the priority queue.
+     * @param {T | HeapItem<T>} node - The parameter `node` can be of type `T` or `HeapItem<T>`.
+     * @returns a boolean value.
      */
-    toArray(): HeapItem<T>[];
+    has(node: T | HeapItem<T>): boolean;
+    toArray(isItem?: undefined): (T | undefined)[];
+    toArray(isItem: false): (T | undefined)[];
+    toArray(isItem: true): (HeapItem<T> | null)[];
+    sort(isItem?: undefined): (T | undefined)[];
+    sort(isItem: false): (T | undefined)[];
+    sort(isItem: true): (HeapItem<T> | null)[];
     /**
-     * Clears the queue
-     * @public
+     * The clear function clears the priority queue.
      */
     clear(): void;
 }

package/dist/data-structures/heap/heap.js

@@ -1,119 +1,157 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Heap = void 0;
-/**
- * @copyright 2021 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
- *
- * @abstract
- * @class Heap
- */
-var Heap = /** @class */ (function () {
+exports.Heap = exports.HeapItem = void 0;
+class HeapItem {
     /**
-     * Creates a priority queue
-     * @public
-     * @params {object} [options]
+     * The constructor function initializes an instance of a class with a priority and a value.
+     * @param {number} priority - The `priority` parameter is a number that represents the priority of the value. It is
+     * optional and has a default value of `NaN`.
+     * @param {T | null} [val=null] - The `val` parameter is of type `T | null`, which means it can accept a value of type
+     * `T` or `null`.
      */
-    function Heap(options) {
+    constructor(priority = Number.MAX_SAFE_INTEGER, val = null) {
+        this._val = val;
+        this._priority = priority;
+    }
+    get priority() {
+        return this._priority;
+    }
+    set priority(value) {
+        this._priority = value;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(value) {
+        this._val = value;
+    }
+}
+exports.HeapItem = HeapItem;
+class Heap {
+    /**
+     * The function is a constructor for a class that initializes a priority callback function based on the
+     * options provided.
+     * @param [options] - An optional object that contains configuration options for the Heap.
+     */
+    constructor(options) {
         if (options) {
-            var priority = options.priority;
-            if (priority !== undefined && typeof priority !== 'function') {
+            const { priorityExtractor } = options;
+            if (priorityExtractor !== undefined && typeof priorityExtractor !== 'function') {
                 throw new Error('.constructor expects a valid priority function');
             }
-            this._priorityCb = priority || (function (el) { return +el; });
+            this._priorityExtractor = priorityExtractor || ((el) => +el);
         }
         else {
-            this._priorityCb = function (el) { return +el; };
+            this._priorityExtractor = (el) => +el;
         }
     }
-    Object.defineProperty(Heap.prototype, "size", {
-        /**
-         * @public
-         * @returns {number}
-         */
-        get: function () {
-            return this._pq.size;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    get pq() {
+        return this._pq;
+    }
+    get priorityExtractor() {
+        return this._priorityExtractor;
+    }
     /**
-     * @public
-     * @returns {boolean}
+     * The function returns the size of a priority queue.
+     * @returns The size of the priority queue.
      */
-    Heap.prototype.isEmpty = function () {
+    get size() {
+        return this._pq.size;
+    }
+    /**
+     * The function checks if a priority queue is empty.
+     * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
+     */
+    isEmpty() {
         return this._pq.size < 1;
-    };
+    }
     /**
-     * Returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
+     * The `peek` function returns the top item in the priority queue without removing it.
+     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an val with the highest priority in the queue
      */
-    Heap.prototype.peek = function () {
-        return this._pq.peek();
-    };
+    peek(isItem) {
+        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
+        const peeked = this._pq.peek();
+        return isItem ? peeked : peeked === null || peeked === void 0 ? void 0 : peeked.val;
+    }
     /**
-     * Returns an element with lowest priority in the queue
-     * @public
-     * @returns {object}
+     * The `peekLast` function returns the last item in the heap.
+     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an val with the lowest priority in the queue
      */
-    Heap.prototype.peekLast = function () {
-        return this._pq.leaf();
-    };
+    peekLast(isItem) {
+        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
+        const leafItem = this._pq.leaf();
+        return isItem ? leafItem : leafItem === null || leafItem === void 0 ? void 0 : leafItem.val;
+    }
     /**
-     * Adds an element to the queue
-     * @public
-     * @param {any} element
-     * @param priority
+     * The `add` function adds an val to a priority queue with an optional priority value.
+     * @param {T} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
+     * type.
+     * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
+     * val being added to the heap. If the `val` parameter is a number, then the `priority` parameter is set to
+     * the value of `val`. If the `val` parameter is not a number, then the
+     * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    Heap.prototype.offer = function (element, priority) {
-        if (typeof element === 'number') {
-            priority = element;
-        }
-        else {
-            if (priority === undefined) {
-                throw new Error('.offer expects a numeric priority');
-            }
-        }
-        if (priority && Number.isNaN(+priority)) {
-            throw new Error('.offer expects a numeric priority');
-        }
-        if (Number.isNaN(+priority) && Number.isNaN(this._priorityCb(element))) {
-            throw new Error('.offer expects a numeric priority '
-                + 'or a constructor callback that returns a number');
-        }
-        var _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(element);
-        this._pq.offer({ priority: _priority, element: element });
+    add(priority, val) {
+        val = (val === undefined) ? priority : val;
+        this._pq.add(new HeapItem(priority, val));
         return this;
-    };
+    }
     /**
-     * Removes and returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
+     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an val with the highest priority in the queue
+     * @returns either a HeapItem<T> object or null.
      */
-    Heap.prototype.poll = function () {
-        var top = this._pq.poll();
+    poll(isItem) {
+        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
+        const top = this._pq.poll();
         if (!top) {
             return null;
         }
-        return top;
-    };
+        return isItem ? top : top.val;
+    }
     /**
-     * Returns a sorted list of elements
-     * @public
-     * @returns {array}
+     * The function checks if a given node or value exists in the priority queue.
+     * @param {T | HeapItem<T>} node - The parameter `node` can be of type `T` or `HeapItem<T>`.
+     * @returns a boolean value.
      */
-    Heap.prototype.toArray = function () {
-        return this._pq.toArray();
-    };
+    has(node) {
+        if (node instanceof HeapItem) {
+            return this.pq.getNodes().includes(node);
+        }
+        else {
+            return this.pq.getNodes().findIndex(item => {
+                return item.val === node;
+            }) !== -1;
+        }
+    }
+    /**
+     * The `toArray` function returns an array of `HeapItem<T>` objects.
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of vals
+     */
+    toArray(isItem) {
+        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
+        const itemArray = this._pq.toArray();
+        return isItem ? itemArray : itemArray.map(item => item.val);
+    }
     /**
-     * Clears the queue
-     * @public
+     * The function sorts the elements in the priority queue and returns either the sorted items or their values depending
+     * on the value of the isItem parameter.
+     * @param {boolean} [isItem] - The `isItem` parameter is a boolean flag that indicates whether the sorted result should
+     * be an array of `HeapItem<T>` objects or an array of the values (`T`) of those objects. If `isItem` is `true`, the
+     * sorted result will be an array of `HeapItem
+     * @returns an array of either `HeapItem<T>`, `null`, `T`, or `undefined` values.
      */
-    Heap.prototype.clear = function () {
+    sort(isItem) {
+        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
+        const sorted = this._pq.sort();
+        return isItem ? sorted : sorted.map(item => item.val);
+    }
+    /**
+     * The clear function clears the priority queue.
+     */
+    clear() {
         this._pq.clear();
-    };
-    return Heap;
-}());
+    }
+}
 exports.Heap = Heap;

package/dist/data-structures/heap/max-heap.d.ts

@@ -1,15 +1,23 @@
 /**
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
-import { Heap } from './heap';
+import { Heap, HeapItem } from './heap';
 import { PriorityQueue } from '../priority-queue';
-import type { HeapItem, HeapOptions } from '../types';
+import type { HeapOptions } from '../../types';
 /**
  * @class MaxHeap
  * @extends Heap
  */
-export declare class MaxHeap<T> extends Heap<T> {
+export declare class MaxHeap<T = number> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
+    /**
+     * The constructor initializes a PriorityQueue with a custom comparator function.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
+     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     */
     constructor(options?: HeapOptions<T>);
 }

package/dist/data-structures/heap/max-heap.js

@@ -1,40 +1,30 @@
 "use strict";
 /**
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxHeap = void 0;
-var heap_1 = require("./heap");
-var priority_queue_1 = require("../priority-queue");
+const heap_1 = require("./heap");
+const priority_queue_1 = require("../priority-queue");
 /**
  * @class MaxHeap
  * @extends Heap
  */
-var MaxHeap = /** @class */ (function (_super) {
-    __extends(MaxHeap, _super);
-    function MaxHeap(options) {
-        var _this = _super.call(this, options) || this;
-        _this._pq = new priority_queue_1.PriorityQueue({
-            comparator: function (a, b) { return b.priority - a.priority; }
+class MaxHeap extends heap_1.Heap {
+    /**
+     * The constructor initializes a PriorityQueue with a custom comparator function.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
+     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     */
+    constructor(options) {
+        super(options);
+        this._pq = new priority_queue_1.PriorityQueue({
+            comparator: (a, b) => b.priority - a.priority
         });
-        return _this;
     }
-    return MaxHeap;
-}(heap_1.Heap));
+}
 exports.MaxHeap = MaxHeap;

package/dist/data-structures/heap/min-heap.d.ts

@@ -1,15 +1,24 @@
 /**
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
-import { Heap } from './heap';
+import { Heap, HeapItem } from './heap';
 import { PriorityQueue } from '../priority-queue';
-import type { HeapItem, HeapOptions } from '../types';
+import type { HeapOptions } from '../../types';
 /**
  * @class MinHeap
  * @extends Heap
  */
-export declare class MinHeap<T> extends Heap<T> {
+export declare class MinHeap<T = number> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
+    /**
+     * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem
+     * objects.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
+     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     */
     constructor(options?: HeapOptions<T>);
 }