data-structure-typed 0.8.18 → 1.12.9

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

@@ -1,21 +1,64 @@
 "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;
-class CoordinateSet extends Set {
-    constructor(joint) {
-        super();
-        this._joint = '_';
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+var CoordinateSet = /** @class */ (function (_super) {
+    __extends(CoordinateSet, _super);
+    function CoordinateSet(joint) {
+        var _this = _super.call(this) || this;
+        _this._joint = '_';
         if (joint !== undefined)
-            this._joint = joint;
+            _this._joint = joint;
+        return _this;
     }
-    has(value) {
-        return super.has(value.join(this._joint));
-    }
-    add(value) {
-        return super.add(value.join(this._joint));
-    }
-    delete(value) {
-        return super.delete(value.join(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.
+     */
+    CoordinateSet.prototype.has = function (value) {
+        return _super.prototype.has.call(this, 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)`).
+     */
+    CoordinateSet.prototype.add = function (value) {
+        return _super.prototype.add.call(this, 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.
+     */
+    CoordinateSet.prototype.delete = function (value) {
+        return _super.prototype.delete.call(this, value.join(this._joint));
+    };
+    return CoordinateSet;
+}(Set));
 exports.CoordinateSet = CoordinateSet;

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

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

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

@@ -15,3 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./hash-table"), exports);
+__exportStar(require("./coordinate-map"), exports);
+__exportStar(require("./coordinate-set"), exports);
+__exportStar(require("./pair"), exports);
+__exportStar(require("./tree-map"), exports);
+__exportStar(require("./tree-set"), exports);

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

@@ -1,72 +1,61 @@
-import { PriorityQueue } from '../priority-queue';
-export interface HeapOptions<T> {
-    priority?: (element: T) => number;
-}
-export interface HeapItem<T> {
-    priority: number;
-    element: T | null;
-}
 /**
- * @copyright 2021 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
- *
- * @abstract
- * @class Heap
  */
+import { PriorityQueue } from '../priority-queue';
+import type { HeapItem, HeapOptions } from '../types';
 export declare abstract class Heap<T> {
     protected abstract _pq: PriorityQueue<HeapItem<T>>;
     protected _priorityCb: (element: T) => number;
     /**
-     * Creates a priority queue
-     * @public
-     * @params {object} [options]
+     * 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>);
     /**
-     * @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;
     /**
-     * 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 element with the highest priority in the queue
      */
     peek(): HeapItem<T> | null;
     /**
-     * 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 element with the lowest priority in the queue
      */
     peekLast(): HeapItem<T> | null;
     /**
-     * Adds an element to the queue
-     * @public
-     * @param {any} element
-     * @param priority
+     * The `offer` function adds an element to a priority queue with an optional priority value.
+     * @param {T} element - The `element` 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
+     * element being offered to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
+     * the value of `element`. If the `element` parameter is not a number, then the
+     * @returns The `offer` 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}
+     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an element with the highest priority in the queue
+     * @returns either a HeapItem<T> object or null.
      */
     poll(): HeapItem<T> | null;
     /**
-     * Returns a sorted list of elements
-     * @public
-     * @returns {array}
+     * The `toArray` function returns an array of `HeapItem<T>` objects.
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of elements
      */
     toArray(): HeapItem<T>[];
     /**
-     * Clears the queue
-     * @public
+     * The clear function clears the priority queue.
      */
     clear(): void;
 }

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

@@ -1,69 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Heap = void 0;
-/**
- * @copyright 2021 Pablo Rios <zrwusa@gmail.com>
- * @license MIT
- *
- * @abstract
- * @class Heap
- */
-class Heap {
+var Heap = /** @class */ (function () {
     /**
-     * Creates a priority queue
-     * @public
-     * @params {object} [options]
+     * 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) {
+    function Heap(options) {
         if (options) {
-            const { priority } = options;
+            var priority = options.priority;
             if (priority !== undefined && typeof priority !== 'function') {
                 throw new Error('.constructor expects a valid priority function');
             }
-            this._priorityCb = priority || ((el) => +el);
+            this._priorityCb = priority || (function (el) { return +el; });
         }
         else {
-            this._priorityCb = (el) => +el;
+            this._priorityCb = function (el) { return +el; };
         }
     }
+    Object.defineProperty(Heap.prototype, "size", {
+        /**
+         * The function returns the size of a priority queue.
+         * @returns The size of the priority queue.
+         */
+        get: function () {
+            return this._pq.size;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
-     * @public
-     * @returns {number}
+     * 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.
      */
-    get size() {
-        return this._pq.size;
-    }
-    /**
-     * @public
-     * @returns {boolean}
-     */
-    isEmpty() {
+    Heap.prototype.isEmpty = function () {
         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 element with the highest priority in the queue
      */
-    peek() {
+    Heap.prototype.peek = function () {
         return this._pq.peek();
-    }
+    };
     /**
-     * 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 element with the lowest priority in the queue
      */
-    peekLast() {
+    Heap.prototype.peekLast = function () {
         return this._pq.leaf();
-    }
+    };
     /**
-     * Adds an element to the queue
-     * @public
-     * @param {any} element
-     * @param priority
+     * The `offer` function adds an element to a priority queue with an optional priority value.
+     * @param {T} element - The `element` 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
+     * element being offered to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
+     * the value of `element`. If the `element` parameter is not a number, then the
+     * @returns The `offer` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    offer(element, priority) {
+    Heap.prototype.offer = function (element, priority) {
         if (typeof element === 'number') {
             priority = element;
         }
@@ -79,36 +77,34 @@ class Heap {
             throw new Error('.offer expects a numeric priority '
                 + 'or a constructor callback that returns a number');
         }
-        const _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(element);
-        this._pq.offer({ priority: _priority, element });
+        var _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(element);
+        this._pq.offer({ priority: _priority, element: element });
         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 element with the highest priority in the queue
+     * @returns either a HeapItem<T> object or null.
      */
-    poll() {
-        const top = this._pq.poll();
+    Heap.prototype.poll = function () {
+        var top = this._pq.poll();
         if (!top) {
             return null;
         }
         return top;
-    }
+    };
     /**
-     * Returns a sorted list of elements
-     * @public
-     * @returns {array}
+     * The `toArray` function returns an array of `HeapItem<T>` objects.
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of elements
      */
-    toArray() {
+    Heap.prototype.toArray = function () {
         return this._pq.toArray();
-    }
+    };
     /**
-     * Clears the queue
-     * @public
+     * The clear function clears the priority queue.
      */
-    clear() {
+    Heap.prototype.clear = function () {
         this._pq.clear();
-    }
-}
+    };
+    return Heap;
+}());
 exports.Heap = Heap;

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

@@ -1,14 +1,20 @@
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
-import { Heap, HeapItem, HeapOptions } from './heap';
+import { Heap } from './heap';
 import { PriorityQueue } from '../priority-queue';
+import type { HeapItem, HeapOptions } from '../types';
 /**
  * @class MaxHeap
  * @extends Heap
  */
 export declare class MaxHeap<T> 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,22 +1,45 @@
 "use strict";
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
+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;
-const heap_1 = require("./heap");
-const priority_queue_1 = require("../priority-queue");
+var heap_1 = require("./heap");
+var priority_queue_1 = require("../priority-queue");
 /**
  * @class MaxHeap
  * @extends Heap
  */
-class MaxHeap extends heap_1.Heap {
-    constructor(options) {
-        super(options);
-        this._pq = new priority_queue_1.PriorityQueue({
-            comparator: (a, b) => b.priority - a.priority
+var MaxHeap = /** @class */ (function (_super) {
+    __extends(MaxHeap, _super);
+    /**
+     * 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.
+     */
+    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; }
         });
+        return _this;
     }
-}
+    return MaxHeap;
+}(heap_1.Heap));
 exports.MaxHeap = MaxHeap;

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

@@ -1,14 +1,21 @@
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
-import { Heap, HeapItem, HeapOptions } from './heap';
+import { Heap } from './heap';
 import { PriorityQueue } from '../priority-queue';
+import type { HeapItem, HeapOptions } from '../types';
 /**
  * @class MinHeap
  * @extends Heap
  */
 export declare class MinHeap<T> 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>);
 }

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

@@ -1,22 +1,46 @@
 "use strict";
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
+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.MinHeap = void 0;
-const heap_1 = require("./heap");
-const priority_queue_1 = require("../priority-queue");
+var heap_1 = require("./heap");
+var priority_queue_1 = require("../priority-queue");
 /**
  * @class MinHeap
  * @extends Heap
  */
-class MinHeap extends heap_1.Heap {
-    constructor(options) {
-        super(options);
-        this._pq = new priority_queue_1.PriorityQueue({
-            comparator: (a, b) => a.priority - b.priority
+var MinHeap = /** @class */ (function (_super) {
+    __extends(MinHeap, _super);
+    /**
+     * 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.
+     */
+    function MinHeap(options) {
+        var _this = _super.call(this, options) || this;
+        _this._pq = new priority_queue_1.PriorityQueue({
+            comparator: function (a, b) { return a.priority - b.priority; }
         });
+        return _this;
     }
-}
+    return MinHeap;
+}(heap_1.Heap));
 exports.MinHeap = MinHeap;

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -4,7 +4,6 @@ export declare class DoublyLinkedListNode<T> {
     prev: DoublyLinkedListNode<T> | null;
     constructor(nodeValue: T);
 }
-export type DoublyLinkedListGetBy = 'node' | 'val';
 export declare class DoublyLinkedList<T> {
     private _first;
     private _last;
@@ -12,13 +11,17 @@ export declare class DoublyLinkedList<T> {
     get size(): number;
     set size(v: number);
     /**
-     * Adds a node at the beginning of the linked list
-     * @param val Value to be stored at the beginning of the linked list
+     * The function adds a new node with a given value to the beginning of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of
+     * the doubly linked list.
+     * @returns A boolean value is being returned.
      */
     offerFirst(val: T): boolean;
     /**
-     * Adds a node to the end of the linked list
-     * @param val Value to be stored in the Doubly linked list node
+     * The function adds a new node with a given value to the end of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the end of the
+     * doubly linked list.
+     * @returns a boolean value, which is always true.
      */
     offerLast(val: T): boolean;
     peekFirst(): T | null;
@@ -52,8 +55,12 @@ export declare class DoublyLinkedList<T> {
      */
     insert(index: number, val: T): boolean;
     /**
-     * Removes a node at the specified index and returns its value.
-     * @param index Index at which the node has to be removed.
+     * The `remove` function removes an element at a specified index from a data structure, updating the links between
+     * nodes accordingly.
+     * @param {number} index - The index parameter represents the position of the element to be removed in the data
+     * structure. It is of type number.
+     * @returns The `remove` method returns the value of the removed element (`T`) if the removal is successful, or `null`
+     * if the index is out of bounds.
      */
     remove(index: number): T | null;
 }