data-structure-typed 1.40.0-rc → 1.41.0

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

@@ -1,2 +0,0 @@
-export class TreeMap {
-}

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

@@ -1,2 +0,0 @@
-export class TreeSet {
-}

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

@@ -1,83 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import { PriorityQueue } from '../priority-queue';
-import type { HeapOptions } from '../../types';
-export declare class HeapItem<V = any> {
-    /**
-     * 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 {V | null} [val=null] - The `val` parameter is of type `V | null`, which means it can accept a value of type
-     * `V` or `null`.
-     */
-    constructor(priority?: number, val?: V | null);
-    private _priority;
-    get priority(): number;
-    set priority(value: number);
-    private _val;
-    get val(): V | null;
-    set val(value: V | null);
-}
-export declare abstract class Heap<V = any> {
-    /**
-     * 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<V>);
-    protected abstract _pq: PriorityQueue<HeapItem<V>>;
-    get pq(): PriorityQueue<HeapItem<V>>;
-    protected _priorityExtractor: (val: V) => number;
-    get priorityExtractor(): (val: V) => number;
-    /**
-     * The function returns the size of a priority queue.
-     * @returns The size of the priority queue.
-     */
-    get size(): 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.
-     */
-    isEmpty(): boolean;
-    peek(isItem?: undefined): V | undefined;
-    peek(isItem: false): V | undefined;
-    peek(isItem: true): HeapItem<V> | null;
-    peekLast(isItem?: undefined): V | undefined;
-    peekLast(isItem: false): V | undefined;
-    peekLast(isItem: true): HeapItem<V> | null;
-    /**
-     * The `add` function adds an val to a priority queue with an optional priority value.
-     * @param {V} 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
-     */
-    add(priority: number, val?: V): Heap<V>;
-    poll(isItem?: undefined): V | undefined;
-    poll(isItem: false): V | undefined;
-    poll(isItem: true): HeapItem<V> | null;
-    /**
-     * The function checks if a given node or value exists in the priority queue.
-     * @param {V | HeapItem<V>} node - The parameter `node` can be of type `V` or `HeapItem<V>`.
-     * @returns a boolean value.
-     */
-    has(node: V | HeapItem<V>): boolean;
-    toArray(isItem?: undefined): (V | undefined)[];
-    toArray(isItem: false): (V | undefined)[];
-    toArray(isItem: true): (HeapItem<V> | null)[];
-    sort(isItem?: undefined): (V | undefined)[];
-    sort(isItem: false): (V | undefined)[];
-    sort(isItem: true): (HeapItem<V> | null)[];
-    /**
-     * The clear function clears the priority queue.
-     */
-    clear(): void;
-}

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

@@ -1,152 +0,0 @@
-export 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 {V | null} [val=null] - The `val` parameter is of type `V | null`, which means it can accept a value of type
-     * `V` 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;
-    }
-}
-export 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) {
-            const { priorityExtractor } = options;
-            if (priorityExtractor !== undefined && typeof priorityExtractor !== 'function') {
-                throw new Error('.constructor expects a valid priority function');
-            }
-            this._priorityExtractor = priorityExtractor || (el => +el);
-        }
-        else {
-            this._priorityExtractor = el => +el;
-        }
-    }
-    get pq() {
-        return this._pq;
-    }
-    get priorityExtractor() {
-        return this._priorityExtractor;
-    }
-    /**
-     * The function returns the size of a priority queue.
-     * @returns The size of the priority queue.
-     */
-    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;
-    }
-    /**
-     * The `peek` function returns the top item in the priority queue without removing it.
-     * @returns The `peek()` method is returning either a `HeapItem<V>` object or `null`.Returns an val with the highest priority in the queue
-     */
-    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;
-    }
-    /**
-     * The `peekLast` function returns the last item in the heap.
-     * @returns The method `peekLast()` returns either a `HeapItem<V>` object or `null`.Returns an val with the lowest priority in the queue
-     */
-    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;
-    }
-    /**
-     * The `add` function adds an val to a priority queue with an optional priority value.
-     * @param {V} 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
-     */
-    add(priority, val) {
-        val = val === undefined ? priority : val;
-        this._pq.add(new HeapItem(priority, val));
-        return this;
-    }
-    /**
-     * 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<V> object or null.
-     */
-    poll(isItem) {
-        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
-        const top = this._pq.poll();
-        if (!top) {
-            return null;
-        }
-        return isItem ? top : top.val;
-    }
-    /**
-     * The function checks if a given node or value exists in the priority queue.
-     * @param {V | HeapItem<V>} node - The parameter `node` can be of type `V` or `HeapItem<V>`.
-     * @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<V>` objects.
-     * @returns An array of HeapItem<V> 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);
-    }
-    /**
-     * 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<V>` objects or an array of the values (`V`) of those objects. If `isItem` is `true`, the
-     * sorted result will be an array of `HeapItem
-     * @returns an array of either `HeapItem<V>`, `null`, `V`, or `undefined` values.
-     */
-    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();
-    }
-}

package/lib/data-structures/heap/index.js

@@ -1,3 +0,0 @@
-export * from './max-heap';
-export * from './min-heap';
-export * from './heap';

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

@@ -1,23 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import { Heap, HeapItem } from './heap';
-import { PriorityQueue } from '../priority-queue';
-import type { HeapOptions } from '../../types';
-/**
- * @class MaxHeap
- * @extends Heap
- */
-export declare class MaxHeap<V = any> extends Heap<V> {
-    protected _pq: PriorityQueue<HeapItem<V>>;
-    /**
-     * 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<V>`, which is a generic type that represents the options for the heap.
-     */
-    constructor(options?: HeapOptions<V>);
-}

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

@@ -1,26 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import { Heap } from './heap';
-import { PriorityQueue } from '../priority-queue';
-/**
- * @class MaxHeap
- * @extends Heap
- */
-export class MaxHeap extends 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<V>`, which is a generic type that represents the options for the heap.
-     */
-    constructor(options) {
-        super(options);
-        this._pq = new PriorityQueue({
-            comparator: (a, b) => b.priority - a.priority
-        });
-    }
-}

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

@@ -1,24 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import { Heap, HeapItem } from './heap';
-import { PriorityQueue } from '../priority-queue';
-import type { HeapOptions } from '../../types';
-/**
- * @class MinHeap
- * @extends Heap
- */
-export declare class MinHeap<V = any> extends Heap<V> {
-    protected _pq: PriorityQueue<HeapItem<V>>;
-    /**
-     * 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<V>`, which is a generic type that represents the options for the heap.
-     */
-    constructor(options?: HeapOptions<V>);
-}

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

@@ -1,27 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import { Heap } from './heap';
-import { PriorityQueue } from '../priority-queue';
-/**
- * @class MinHeap
- * @extends Heap
- */
-export class MinHeap extends 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<V>`, which is a generic type that represents the options for the heap.
-     */
-    constructor(options) {
-        super(options);
-        this._pq = new PriorityQueue({
-            comparator: (a, b) => a.priority - b.priority
-        });
-    }
-}

package/lib/data-structures/index.js

@@ -1,11 +0,0 @@
-export * from './hash';
-export * from './linked-list';
-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';
-export * from './trie';

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

@@ -1,234 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export declare class DoublyLinkedListNode<E = any> {
-    /**
-     * The constructor function initializes the value, next, and previous properties of an object.
-     * @param {E} val - The "val" parameter is the value that will be stored in the node. It can be of any data type, as it
-     * is defined as a generic type "E".
-     */
-    constructor(val: E);
-    private _val;
-    get val(): E;
-    set val(value: E);
-    private _next;
-    get next(): DoublyLinkedListNode<E> | null;
-    set next(value: DoublyLinkedListNode<E> | null);
-    private _prev;
-    get prev(): DoublyLinkedListNode<E> | null;
-    set prev(value: DoublyLinkedListNode<E> | null);
-}
-export declare class DoublyLinkedList<E = any> {
-    /**
-     * The constructor initializes the linked list with an empty head, tail, and length.
-     */
-    constructor();
-    private _head;
-    get head(): DoublyLinkedListNode<E> | null;
-    set head(value: DoublyLinkedListNode<E> | null);
-    private _tail;
-    get tail(): DoublyLinkedListNode<E> | null;
-    set tail(value: DoublyLinkedListNode<E> | null);
-    private _length;
-    get length(): number;
-    /**
-     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
-     * given array.
-     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-     * @returns The `fromArray` function returns a DoublyLinkedList object.
-     */
-    static fromArray<E>(data: E[]): DoublyLinkedList<E>;
-    /**
-     * The push function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} val - The value to be added to the linked list.
-     */
-    push(val: E): void;
-    /**
-     * The addLast function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} val - The value to be added to the linked list.
-     */
-    addLast(val: E): void;
-    /**
-     * The `pop()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the
-     * list is empty, it returns null.
-     */
-    pop(): E | undefined;
-    /**
-     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the
-     * list is empty, it returns null.
-     */
-    pollLast(): E | undefined;
-    /**
-     * The `shift()` function removes and returns the value of the first node in a doubly linked list.
-     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-     * list.
-     */
-    shift(): E | undefined;
-    /**
-     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
-     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-     * list.
-     */
-    pollFirst(): E | undefined;
-    /**
-     * The unshift function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} val - The `val` parameter represents the value of the new node that will be added to the beginning of the
-     * doubly linked list.
-     */
-    unshift(val: E): void;
-    /**
-     * The addFirst function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} val - The `val` parameter represents the value of the new node that will be added to the beginning of the
-     * doubly linked list.
-     */
-    addFirst(val: E): void;
-    /**
-     * The `peekFirst` function returns the first node in a doubly linked list, or null if the list is empty.
-     * @returns The method `peekFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
-     */
-    peekFirst(): E | undefined;
-    /**
-     * The `peekLast` function returns the last node in a doubly linked list, or null if the list is empty.
-     * @returns The method `peekLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
-     */
-    peekLast(): E | undefined;
-    get size(): number;
-    /**
-     * The `getAt` function returns the value at a specified index in a linked list, or null if the index is out of bounds.
-     * @param {number} index - The index parameter is a number that represents the position of the element we want to
-     * retrieve from the list.
-     * @returns The method is returning the value at the specified index in the linked list. If the index is out of bounds
-     * or the linked list is empty, it will return null.
-     */
-    getAt(index: number): E | undefined;
-    /**
-     * The function `getNodeAt` returns the node at a given index in a doubly linked list, or null if the index is out of
-     * range.
-     * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
-     * retrieve from the doubly linked list. It indicates the zero-based index of the node we want to access.
-     * @returns The method `getNodeAt(index: number)` returns a `DoublyLinkedListNode<E>` object if the index is within the
-     * valid range of the linked list, otherwise it returns `null`.
-     */
-    getNodeAt(index: number): DoublyLinkedListNode<E> | null;
-    /**
-     * The function `findNodeByValue` searches for a node with a specific value in a doubly linked list and returns the
-     * node if found, otherwise it returns null.
-     * @param {E} val - The `val` parameter is the value that we want to search for in the doubly linked list.
-     * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `val`
-     * is found in the linked list. If no such node is found, it returns `null`.
-     */
-    findNode(val: E): DoublyLinkedListNode<E> | null;
-    /**
-     * The `insert` function inserts a value at a specified index in a doubly linked list.
-     * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
-     * DoublyLinkedList. It is of type number.
-     * @param {E} val - The `val` parameter represents the value that you want to insert into the Doubly Linked List at the
-     * specified index.
-     * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
-     * if the index is out of bounds.
-     */
-    insertAt(index: number, val: E): boolean;
-    /**
-     * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
-     * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
-     * data structure. It is of type number.
-     * @returns The method `deleteAt` returns the value of the node that was deleted, or `null` if the index is out of
-     * bounds.
-     */
-    deleteAt(index: number): E | undefined;
-    delete(valOrNode: E): boolean;
-    delete(valOrNode: DoublyLinkedListNode<E>): boolean;
-    /**
-     * The `toArray` function converts a linked list into an array.
-     * @returns The `toArray()` method is returning an array of type `E[]`.
-     */
-    toArray(): E[];
-    /**
-     * The function checks if a variable has a length greater than zero and returns a boolean value.
-     * @returns A boolean value is being returned.
-     */
-    isEmpty(): boolean;
-    /**
-     * The `clear` function resets the linked list by setting the head, tail, and length to null and 0 respectively.
-     */
-    clear(): void;
-    /**
-     * The `find` function iterates through a linked list and returns the first element that satisfies a given condition.
-     * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
-     * function is used to determine whether a particular value in the linked list satisfies a certain condition.
-     * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
-     * the callback function. If no element satisfies the condition, it returns `null`.
-     */
-    find(callback: (val: E) => boolean): E | null;
-    /**
-     * The function returns the index of the first occurrence of a given value in a linked list.
-     * @param {E} val - The parameter `val` is of type `E`, which means it can be any data type. It represents the value
-     * that we are searching for in the linked list.
-     * @returns The method `indexOf` returns the index of the first occurrence of the specified value `val` in the linked
-     * list. If the value is not found, it returns -1.
-     */
-    indexOf(val: E): number;
-    /**
-     * The `findLast` function iterates through a linked list from the last node to the first node and returns the last
-     * value that satisfies the given callback function, or null if no value satisfies the callback.
-     * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
-     * function is used to determine whether a given value satisfies a certain condition.
-     * @returns The method `findLast` returns the last value in the linked list that satisfies the condition specified by
-     * the callback function. If no value satisfies the condition, it returns `null`.
-     */
-    findLast(callback: (val: E) => boolean): E | null;
-    /**
-     * The `toArrayReverse` function converts a doubly linked list into an array in reverse order.
-     * @returns The `toArrayReverse()` function returns an array of type `E[]`.
-     */
-    toArrayReverse(): E[];
-    /**
-     * The `reverse` function reverses the order of the elements in a doubly linked list.
-     */
-    reverse(): void;
-    /**
-     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
-     * @param callback - The callback parameter is a function that takes two arguments: val and index. The val argument
-     * represents the value of the current node in the linked list, and the index argument represents the index of the
-     * current node in the linked list.
-     */
-    forEach(callback: (val: E, index: number) => void): void;
-    /**
-     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
-     * DoublyLinkedList with the transformed values.
-     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
-     * the original DoublyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
-     * DoublyLinkedList).
-     * @returns The `map` function is returning a new instance of `DoublyLinkedList<U>` that contains the mapped values.
-     */
-    map<U>(callback: (val: E) => U): DoublyLinkedList<U>;
-    /**
-     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList containing only the
-     * elements that satisfy the given callback function.
-     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
-     * It is used to determine whether a value should be included in the filtered list or not.
-     * @returns The filtered list, which is an instance of the DoublyLinkedList class.
-     */
-    filter(callback: (val: E) => boolean): DoublyLinkedList<E>;
-    /**
-     * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
-     * single value.
-     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `val`. It is
-     * used to perform a specific operation on each element of the linked list.
-     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
-     * point for the reduction operation.
-     * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
-     * elements in the linked list.
-     */
-    reduce<U>(callback: (accumulator: U, val: E) => U, initialValue: U): U;
-    insertAfter(existingValueOrNode: E, newValue: E): boolean;
-    insertAfter(existingValueOrNode: DoublyLinkedListNode<E>, newValue: E): boolean;
-    insertBefore(existingValueOrNode: E, newValue: E): boolean;
-    insertBefore(existingValueOrNode: DoublyLinkedListNode<E>, newValue: E): boolean;
-}