data-structure-typed 0.8.18 → 1.3.0

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

@@ -1,7 +1,37 @@
-export declare class CoordinateSet extends Set {
-    private readonly _joint;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export declare class CoordinateSet extends Set<any> {
     constructor(joint?: string);
+    protected _joint: string;
+    get joint(): string;
+    /**
+     * 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: number[]): boolean;
+    /**
+     * 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: number[]): this;
+    /**
+     * 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: number[]): boolean;
+    protected _setJoint(v: string): void;
 }

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

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoordinateSet = void 0;
+/**
+ * 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();
@@ -8,14 +15,41 @@ class CoordinateSet extends Set {
         if (joint !== undefined)
             this._joint = joint;
     }
+    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/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/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,72 +1,83 @@
-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>
- * @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> {
+    /**
+     * 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> {
     /**
-     * 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>);
+    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,111 +1,154 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Heap = void 0;
-/**
- * @copyright 2021 Pablo Rios <zrwusa@gmail.com>
- * @license MIT
- *
- * @abstract
- * @class Heap
- */
+exports.Heap = exports.HeapItem = void 0;
+class HeapItem {
+    /**
+     * 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.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 {
     /**
-     * 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) {
         if (options) {
-            const { priority } = options;
-            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 || ((el) => +el);
+            this._priorityExtractor = priorityExtractor || ((el) => +el);
         }
         else {
-            this._priorityCb = (el) => +el;
+            this._priorityExtractor = (el) => +el;
         }
     }
+    get pq() {
+        return this._pq;
+    }
+    get priorityExtractor() {
+        return this._priorityExtractor;
+    }
     /**
-     * @public
-     * @returns {number}
+     * The function returns the size of a priority queue.
+     * @returns The size of the priority queue.
      */
     get size() {
         return this._pq.size;
     }
     /**
-     * @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() {
         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
      */
-    peek() {
-        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
      */
-    peekLast() {
-        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
      */
-    offer(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');
-        }
-        const _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(element);
-        this._pq.offer({ priority: _priority, 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.
      */
-    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;
+    }
+    /**
+     * 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.
+     */
+    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);
     }
     /**
-     * Returns a sorted list of elements
-     * @public
-     * @returns {array}
+     * 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.
      */
-    toArray() {
-        return this._pq.toArray();
+    sort(isItem) {
+        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
+        const sorted = this._pq.sort();
+        return isItem ? sorted : sorted.map(item => item.val);
     }
     /**
-     * Clears the queue
-     * @public
+     * The clear function clears the priority queue.
      */
     clear() {
         this._pq.clear();

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

@@ -1,14 +1,23 @@
 /**
- * @copyright 2020 Pablo Rios <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, HeapItem, HeapOptions } from './heap';
+import { Heap, HeapItem } from './heap';
 import { PriorityQueue } from '../priority-queue';
+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,7 +1,10 @@
 "use strict";
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxHeap = void 0;
@@ -12,6 +15,11 @@ const priority_queue_1 = require("../priority-queue");
  * @extends Heap
  */
 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({

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

@@ -1,14 +1,24 @@
 /**
- * @copyright 2020 Pablo Rios <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, HeapItem, HeapOptions } from './heap';
+import { Heap, HeapItem } from './heap';
 import { PriorityQueue } from '../priority-queue';
+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>);
 }

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

@@ -1,7 +1,10 @@
 "use strict";
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinHeap = void 0;
@@ -12,6 +15,12 @@ const priority_queue_1 = require("../priority-queue");
  * @extends Heap
  */
 class MinHeap extends heap_1.Heap {
+    /**
+     * 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) {
         super(options);
         this._pq = new priority_queue_1.PriorityQueue({

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

@@ -4,6 +4,7 @@ export * from './stack';
 export * from './queue';
 export * from './graph';
 export * from './binary-tree';
+export * from './tree';
 export * from './heap';
 export * from './priority-queue';
 export * from './matrix';

package/dist/data-structures/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./stack"), exports);
 __exportStar(require("./queue"), exports);
 __exportStar(require("./graph"), exports);
 __exportStar(require("./binary-tree"), exports);
+__exportStar(require("./tree"), exports);
 __exportStar(require("./heap"), exports);
 __exportStar(require("./priority-queue"), exports);
 __exportStar(require("./matrix"), exports);