data-structure-typed 0.9.16 → 1.12.9

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

@@ -3,41 +3,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Queue = void 0;
 /**
  * @license MIT
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 var Queue = /** @class */ (function () {
     /**
-     * Creates a queue.
-     * @param {array} [elements]
+     * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
+     * @param {T[]} [elements] - The `elements` parameter is an optional array of elements of type `T`. If provided, it
+     * will be used to initialize the `_nodes` property of the class. If not provided, the `_nodes` property will be
+     * initialized as an empty array.
      */
     function Queue(elements) {
         this._nodes = elements || [];
         this._offset = 0;
     }
     /**
-     * Creates a queue from an existing array.
+     * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
      * @static
-     * @param {array} elements
-     * @return {Queue}
+     * @param {T[]} elements - The "elements" parameter is an array of elements of type T.
+     * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
+     * array.
      */
     Queue.fromArray = function (elements) {
         return new Queue(elements);
     };
     /**
-     * Adds an element at the back of the queue.
-     * @public
-     * @param {any} element
+     * The offer function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
+     * @param {T} element - The `element` parameter represents the element that you want to add to the queue.
+     * @returns The `offer` method is returning a `Queue<T>` object.
      */
     Queue.prototype.offer = function (element) {
         this._nodes.push(element);
         return this;
     };
     /**
-     * Dequeues the front element in the queue.
-     * @public
-     * @returns {any}
+     * The `poll` function removes and returns the first element in the queue, and adjusts the internal data structure if
+     * necessary to optimize performance.
+     * @returns The function `poll()` returns either the first element in the queue or `null` if the queue is empty.
      */
     Queue.prototype.poll = function () {
         if (this.size() === 0)
@@ -53,57 +56,52 @@ var Queue = /** @class */ (function () {
         return first;
     };
     /**
-     * Returns the front element of the queue.
-     * @public
-     * @returns {any}
+     * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+     * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
      */
     Queue.prototype.peek = function () {
         return this.size() > 0 ? this._nodes[this._offset] : null;
     };
     /**
-     * Returns the back element of the queue.
-     * @public
-     * @returns {any}
+     * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+     * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * array is empty, it returns `null`.
      */
     Queue.prototype.peekLast = function () {
         return this.size() > 0 ? this._nodes[this._nodes.length - 1] : null;
     };
     /**
-     * Returns the number of elements in the queue.
-     * @public
-     * @returns {number}
+     * The size function returns the number of elements in an array.
+     * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
      */
     Queue.prototype.size = function () {
         return this._nodes.length - this._offset;
     };
     /**
-     * Checks if the queue is empty.
-     * @public
-     * @returns {boolean}
+     * The function checks if a data structure is empty by comparing its size to zero.
+     * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
      */
     Queue.prototype.isEmpty = function () {
         return this.size() === 0;
     };
     /**
-     * Returns the remaining elements in the queue as an array.
-     * @public
-     * @returns {array}
+     * The toArray() function returns an array of elements from the current offset to the end of the _nodes array.
+     * @returns An array of type T is being returned.
      */
     Queue.prototype.toArray = function () {
         return this._nodes.slice(this._offset);
     };
     /**
-     * Clears the queue.
-     * @public
+     * The clear function resets the nodes array and offset to their initial values.
      */
     Queue.prototype.clear = function () {
         this._nodes = [];
         this._offset = 0;
     };
     /**
-     * Creates a shallow copy of the queue.
-     * @public
-     * @return {Queue}
+     * The `clone()` function returns a new Queue object with the same elements as the original Queue.
+     * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
     Queue.prototype.clone = function () {
         return new Queue(this._nodes.slice(this._offset));

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

@@ -1,68 +1,63 @@
 /**
  * @license MIT
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 export declare class Stack<T> {
     protected _elements: T[];
     /**
-     * Creates a stack.
-     * @param {array} [elements]
+     * The constructor initializes an array of elements, which can be provided as an optional parameter.
+     * @param {T[]} [elements] - The `elements` parameter is an optional parameter of type `T[]`, which represents an array
+     * of elements of type `T`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
+     * is provided and is an array, it is assigned to the `_elements
      */
     constructor(elements?: T[]);
     /**
-     * Creates a stack from an existing array
-     * @public
-     * @static
-     * @param {array} [elements]
-     * @return {Stack}
+     * The function "fromArray" creates a new Stack object from an array of elements.
+     * @param {T[]} elements - The `elements` parameter is an array of elements of type `T`.
+     * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
+     * array.
      */
     static fromArray<T>(elements: T[]): Stack<T>;
     /**
-     * Checks if the stack is empty.
-     * @public
-     * @returns {boolean}
+     * The function checks if an array is empty and returns a boolean value.
+     * @returns A boolean value indicating whether the `_elements` array is empty or not.
      */
     isEmpty(): boolean;
     /**
-     * Returns the number of elements in the stack.
-     * @public
-     * @returns {number}
+     * The size() function returns the number of elements in an array.
+     * @returns The size of the elements array.
      */
     size(): number;
     /**
-     * Returns the top element in the stack.
-     * @public
-     * @returns {object}
+     * The `peek` function returns the last element of an array, or null if the array is empty.
+     * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
      */
     peek(): T | null;
     /**
-     * Adds an element to the top of the stack.
-     * @public
-     * @param {object} element
+     * The push function adds an element to the stack and returns the updated stack.
+     * @param {T} element - The parameter "element" is of type T, which means it can be any data type.
+     * @returns The `push` method is returning the updated `Stack<T>` object.
      */
     push(element: T): Stack<T>;
     /**
-     * Removes and returns the top element in the stack.
-     * @public
-     * @returns {object}
+     * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
+     * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
+     * array is empty, it returns `null`.
      */
     pop(): T | null;
     /**
-     * Returns the remaining elements as an array.
-     * @public
-     * @returns {array}
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type T.
      */
     toArray(): T[];
     /**
-     * Clears all elements from the stack.
-     * @public
+     * The clear function clears the elements array.
      */
     clear(): void;
     /**
-     * Creates a shallow copy from the stack.
-     * @public
-     * @return {Stack}
+     * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
+     * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */
     clone(): Stack<T>;
 }

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

@@ -3,47 +3,45 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stack = void 0;
 /**
  * @license MIT
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 var Stack = /** @class */ (function () {
     /**
-     * Creates a stack.
-     * @param {array} [elements]
+     * The constructor initializes an array of elements, which can be provided as an optional parameter.
+     * @param {T[]} [elements] - The `elements` parameter is an optional parameter of type `T[]`, which represents an array
+     * of elements of type `T`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
+     * is provided and is an array, it is assigned to the `_elements
      */
     function Stack(elements) {
         this._elements = Array.isArray(elements) ? elements : [];
     }
     /**
-     * Creates a stack from an existing array
-     * @public
-     * @static
-     * @param {array} [elements]
-     * @return {Stack}
+     * The function "fromArray" creates a new Stack object from an array of elements.
+     * @param {T[]} elements - The `elements` parameter is an array of elements of type `T`.
+     * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
+     * array.
      */
     Stack.fromArray = function (elements) {
         return new Stack(elements);
     };
     /**
-     * Checks if the stack is empty.
-     * @public
-     * @returns {boolean}
+     * The function checks if an array is empty and returns a boolean value.
+     * @returns A boolean value indicating whether the `_elements` array is empty or not.
      */
     Stack.prototype.isEmpty = function () {
         return this._elements.length === 0;
     };
     /**
-     * Returns the number of elements in the stack.
-     * @public
-     * @returns {number}
+     * The size() function returns the number of elements in an array.
+     * @returns The size of the elements array.
      */
     Stack.prototype.size = function () {
         return this._elements.length;
     };
     /**
-     * Returns the top element in the stack.
-     * @public
-     * @returns {object}
+     * The `peek` function returns the last element of an array, or null if the array is empty.
+     * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
      */
     Stack.prototype.peek = function () {
         if (this.isEmpty())
@@ -51,18 +49,18 @@ var Stack = /** @class */ (function () {
         return this._elements[this._elements.length - 1];
     };
     /**
-     * Adds an element to the top of the stack.
-     * @public
-     * @param {object} element
+     * The push function adds an element to the stack and returns the updated stack.
+     * @param {T} element - The parameter "element" is of type T, which means it can be any data type.
+     * @returns The `push` method is returning the updated `Stack<T>` object.
      */
     Stack.prototype.push = function (element) {
         this._elements.push(element);
         return this;
     };
     /**
-     * Removes and returns the top element in the stack.
-     * @public
-     * @returns {object}
+     * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
+     * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
+     * array is empty, it returns `null`.
      */
     Stack.prototype.pop = function () {
         if (this.isEmpty())
@@ -70,24 +68,21 @@ var Stack = /** @class */ (function () {
         return this._elements.pop() || null;
     };
     /**
-     * Returns the remaining elements as an array.
-     * @public
-     * @returns {array}
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type T.
      */
     Stack.prototype.toArray = function () {
         return this._elements.slice();
     };
     /**
-     * Clears all elements from the stack.
-     * @public
+     * The clear function clears the elements array.
      */
     Stack.prototype.clear = function () {
         this._elements = [];
     };
     /**
-     * Creates a shallow copy from the stack.
-     * @public
-     * @return {Stack}
+     * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
+     * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */
     Stack.prototype.clone = function () {
         return new Stack(this._elements.slice());

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

@@ -1,3 +1,7 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 export declare class TrieNode {
     protected _value: string;
     constructor(v: string);
@@ -19,20 +23,36 @@ export declare class Trie {
     has(input: string): boolean;
     remove(word: string): boolean;
     /**
-     * Only can present as a prefix, not a word
-     * @param input
+     * The function checks if a given input string has an absolute prefix in a tree data structure.Only can present as a prefix, not a word
+     * @param {string} input - The input parameter is a string that represents the input value for the function.
+     * @returns a boolean value.
      */
     isAbsPrefix(input: string): boolean;
     /**
-     * Can present as a abs prefix or word
-     * @param input
+     * The function checks if a given input string is a prefix of any existing string in a tree structure.Can present as a abs prefix or word
+     * @param {string} input - The input parameter is a string that represents the prefix we want to check.
+     * @returns a boolean value.
      */
     isPrefix(input: string): boolean;
     /**
-     * Check if the input string is the common prefix of all the words
-     * @param input
+     * The function checks if the input string is a common prefix in a Trie data structure.Check if the input string is the common prefix of all the words
+     * @param {string} input - The input parameter is a string that represents the common prefix that we want to check for
+     * in the Trie data structure.
+     * @returns a boolean value indicating whether the input string is a common prefix in the Trie data structure.
      */
     isCommonPrefix(input: string): boolean;
+    /**
+     * The function `getLongestCommonPrefix` returns the longest common prefix among all the words stored in a Trie data
+     * structure.
+     * @returns The function `getLongestCommonPrefix` returns a string, which is the longest common prefix found in the
+     * Trie.
+     */
     getLongestCommonPrefix(): string;
+    /**
+     * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
+     * @param [prefix] - The `prefix` parameter is a string that represents the prefix that we want to search for in the
+     * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
+     * @returns an array of strings.
+     */
     getAll(prefix?: string): string[];
 }

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

@@ -12,6 +12,10 @@ var __values = (this && this.__values) || function(o) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trie = exports.TrieNode = void 0;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 var TrieNode = /** @class */ (function () {
     function TrieNode(v) {
         this._value = v;
@@ -159,8 +163,9 @@ var Trie = /** @class */ (function () {
     };
     // --- start additional methods ---
     /**
-     * Only can present as a prefix, not a word
-     * @param input
+     * The function checks if a given input string has an absolute prefix in a tree data structure.Only can present as a prefix, not a word
+     * @param {string} input - The input parameter is a string that represents the input value for the function.
+     * @returns a boolean value.
      */
     Trie.prototype.isAbsPrefix = function (input) {
         var e_4, _a;
@@ -184,8 +189,9 @@ var Trie = /** @class */ (function () {
         return !cur.isEnd;
     };
     /**
-     * Can present as a abs prefix or word
-     * @param input
+     * The function checks if a given input string is a prefix of any existing string in a tree structure.Can present as a abs prefix or word
+     * @param {string} input - The input parameter is a string that represents the prefix we want to check.
+     * @returns a boolean value.
      */
     Trie.prototype.isPrefix = function (input) {
         var e_5, _a;
@@ -209,8 +215,10 @@ var Trie = /** @class */ (function () {
         return true;
     };
     /**
-     * Check if the input string is the common prefix of all the words
-     * @param input
+     * The function checks if the input string is a common prefix in a Trie data structure.Check if the input string is the common prefix of all the words
+     * @param {string} input - The input parameter is a string that represents the common prefix that we want to check for
+     * in the Trie data structure.
+     * @returns a boolean value indicating whether the input string is a common prefix in the Trie data structure.
      */
     Trie.prototype.isCommonPrefix = function (input) {
         var commonPre = '';
@@ -228,7 +236,12 @@ var Trie = /** @class */ (function () {
         dfs(this._root);
         return commonPre === input;
     };
-    // Retrieve the longest common prefix of all the words
+    /**
+     * The function `getLongestCommonPrefix` returns the longest common prefix among all the words stored in a Trie data
+     * structure.
+     * @returns The function `getLongestCommonPrefix` returns a string, which is the longest common prefix found in the
+     * Trie.
+     */
     Trie.prototype.getLongestCommonPrefix = function () {
         var commonPre = '';
         var dfs = function (cur) {
@@ -243,6 +256,12 @@ var Trie = /** @class */ (function () {
         dfs(this._root);
         return commonPre;
     };
+    /**
+     * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
+     * @param [prefix] - The `prefix` parameter is a string that represents the prefix that we want to search for in the
+     * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
+     * @returns an array of strings.
+     */
     Trie.prototype.getAll = function (prefix) {
         var e_6, _a;
         if (prefix === void 0) { prefix = ''; }

package/dist/data-structures/types/avl-tree.d.ts

@@ -1,4 +1,4 @@
-import { AVLTreeNode } from "../binary-tree";
+import { AVLTreeNode } from '../binary-tree';
 export interface AVLTreeDeleted<T> {
     deleted: AVLTreeNode<T> | null;
     needBalanced: AVLTreeNode<T> | null;

package/dist/data-structures/types/binary-tree.d.ts

@@ -1,4 +1,4 @@
-import { BinaryTreeNode } from "../binary-tree";
+import { BinaryTreeNode } from '../binary-tree';
 export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
 export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
 export type DFSOrderPattern = 'in' | 'pre' | 'post';

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

@@ -10,4 +10,4 @@ export * from './heap';
 export * from './singly-linked-list';
 export * from './doubly-linked-list';
 export * from './navigator';
-export * from './utils';
+export * from '../../utils/types/utils';

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

@@ -26,4 +26,4 @@ __exportStar(require("./heap"), exports);
 __exportStar(require("./singly-linked-list"), exports);
 __exportStar(require("./doubly-linked-list"), exports);
 __exportStar(require("./navigator"), exports);
-__exportStar(require("./utils"), exports);
+__exportStar(require("../../utils/types/utils"), exports);

package/dist/data-structures/types/singly-linked-list.d.ts

@@ -1,5 +1 @@
-import { SinglyLinkedList } from "../linked-list";
-/** Type used for filter and find methods, returning a boolean */
-export type TTestFunction<NodeData> = (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean;
-/** Type used for map and forEach methods, returning anything */
-export type TMapFunction<NodeData> = (data: any, index: number, list: SinglyLinkedList<NodeData>) => any;
+export {};

package/dist/data-structures/types/tree-multiset.d.ts

@@ -1,4 +1,4 @@
-import { BSTNode } from "../binary-tree";
+import { BSTNode } from '../binary-tree';
 export type TreeMultiSetDeletedResult<T> = {
     deleted: BSTNode<T> | null;
     needBalanced: BSTNode<T> | null;

package/dist/{data-structures → utils}/trampoline.d.ts

@@ -1,16 +1,14 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+import { Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from './types';
 export declare const THUNK_SYMBOL: unique symbol;
 export declare const isThunk: (fnOrValue: any) => boolean;
-type ToThunkFn = () => ReturnType<TrlFn>;
-type Thunk = () => ReturnType<ToThunkFn> & {
-    __THUNK__: typeof THUNK_SYMBOL;
-};
 export declare const toThunk: (fn: ToThunkFn) => Thunk;
-type TrlFn = (...args: any[]) => any;
 export declare const trampoline: (fn: TrlFn) => ((...args: [...Parameters<TrlFn>]) => any) & {
     cont: (...args: [...Parameters<TrlFn>]) => Thunk;
 };
-type TrlAsyncFn = (...args: any[]) => any;
 export declare const trampolineAsync: (fn: TrlAsyncFn) => ((...args: [...Parameters<TrlAsyncFn>]) => Promise<any>) & {
     cont: (...args: [...Parameters<TrlAsyncFn>]) => Thunk;
 };
-export {};

package/dist/utils/types/index.d.ts

@@ -0,0 +1 @@
+export * from './utils';

package/dist/utils/types/index.js

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

package/dist/{data-structures → utils}/types/utils.d.ts

@@ -50,3 +50,11 @@ export type DeepProxy<T> = T extends (...args: any[]) => infer R ? (...args: [..
 export type DeepProxyOnChange = (target: any, property: string | symbol, value: any, receiver: any, descriptor: any, result: any) => void;
 export type DeepProxyOnGet = (target: any, property: string | symbol, value: any, receiver: any, descriptor: any, result: any) => void;
 export type CurryFunc<T> = T extends (...args: infer Args) => infer R ? Args extends [infer Arg, ...infer RestArgs] ? (arg: Arg) => CurryFunc<(...args: RestArgs) => R> : R : T;
+export type ToThunkFn = () => ReturnType<TrlFn>;
+declare const THUNK_SYMBOL: unique symbol;
+export type Thunk = () => ReturnType<ToThunkFn> & {
+    __THUNK__: typeof THUNK_SYMBOL;
+};
+export type TrlFn = (...args: any[]) => any;
+export type TrlAsyncFn = (...args: any[]) => any;
+export {};

package/dist/{data-structures → utils}/types/utils.js

@@ -52,3 +52,4 @@ var TreeNode = /** @class */ (function () {
     return TreeNode;
 }());
 exports.TreeNode = TreeNode;
+var THUNK_SYMBOL = Symbol('thunk');

package/dist/utils/utils.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunction } from '../data-structures/types';
+import { AnyFunction } from './types';
 export type JSONSerializable = {
     [key: string]: any;
 };

package/docs/.nojekyll

@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.