data-structure-typed 1.15.0 → 1.15.2

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

@@ -1,4 +1,5 @@
 export declare class DoublyLinkedListNode<T> {
+    constructor(nodeValue: T);
     protected _val: T;
     get val(): T;
     set val(v: T);
@@ -8,31 +9,30 @@ export declare class DoublyLinkedListNode<T> {
     protected _prev: DoublyLinkedListNode<T> | null;
     get prev(): DoublyLinkedListNode<T> | null;
     set prev(v: DoublyLinkedListNode<T> | null);
-    constructor(nodeValue: T);
 }
 export declare class DoublyLinkedList<T> {
+    constructor();
     protected _first: DoublyLinkedListNode<T> | null;
     get first(): DoublyLinkedListNode<T> | null;
+    protected set first(v: DoublyLinkedListNode<T> | null);
+    protected _last: DoublyLinkedListNode<T> | null;
+    get last(): DoublyLinkedListNode<T> | null;
+    protected set last(v: DoublyLinkedListNode<T> | null);
+    protected _size: number;
+    get size(): number;
+    protected set size(v: number);
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */
     getFirst(): DoublyLinkedListNode<T> | null;
-    protected set first(v: DoublyLinkedListNode<T> | null);
-    protected _last: DoublyLinkedListNode<T> | null;
-    get last(): DoublyLinkedListNode<T> | null;
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */
     getLast(): DoublyLinkedListNode<T> | null;
-    protected set last(v: DoublyLinkedListNode<T> | null);
-    protected _size: number;
-    get size(): number;
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */
     getSize(): number;
-    protected set size(v: number);
-    constructor();
     /**
      * 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

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -56,12 +56,6 @@ var DoublyLinkedList = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    DoublyLinkedList.prototype.getFirst = function () {
-        return this._first;
-    };
     Object.defineProperty(DoublyLinkedList.prototype, "last", {
         get: function () {
             return this._last;
@@ -72,12 +66,6 @@ var DoublyLinkedList = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    DoublyLinkedList.prototype.getLast = function () {
-        return this._last;
-    };
     Object.defineProperty(DoublyLinkedList.prototype, "size", {
         get: function () {
             return this._size;
@@ -88,6 +76,18 @@ var DoublyLinkedList = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    DoublyLinkedList.prototype.getFirst = function () {
+        return this._first;
+    };
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    DoublyLinkedList.prototype.getLast = function () {
+        return this._last;
+    };
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */

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

@@ -6,6 +6,7 @@
  * @license MIT License
  */
 export declare class SinglyLinkedListNode<NodeVal = any> {
+    constructor(val: NodeVal, prev?: SinglyLinkedListNode<NodeVal> | null, next?: SinglyLinkedListNode<NodeVal> | null, list?: SinglyLinkedList<NodeVal> | null);
     protected _val: NodeVal;
     get val(): NodeVal;
     set val(value: NodeVal);
@@ -18,7 +19,6 @@ export declare class SinglyLinkedListNode<NodeVal = any> {
     protected _list: SinglyLinkedList<NodeVal> | null;
     get list(): SinglyLinkedList<NodeVal> | null;
     set list(value: SinglyLinkedList<NodeVal> | null);
-    constructor(val: NodeVal, prev?: SinglyLinkedListNode<NodeVal> | null, next?: SinglyLinkedListNode<NodeVal> | null, list?: SinglyLinkedList<NodeVal> | null);
     get index(): number | undefined;
     /**
      * The `insertBefore` function inserts a new node with the given value before the current node in a singly linked list.
@@ -40,6 +40,12 @@ export declare class SinglyLinkedListNode<NodeVal = any> {
     remove(): SinglyLinkedListNode<NodeVal>;
 }
 export declare class SinglyLinkedList<NodeVal = any> {
+    /**
+     * The constructor initializes a linked list with the given arguments as nodes.
+     * @param {NodeVal[]} args - args is a rest parameter that allows the constructor to accept an arbitrary number of
+     * arguments of type NodeVal.
+     */
+    constructor(...args: NodeVal[]);
     protected _head: SinglyLinkedListNode<NodeVal> | null;
     get head(): SinglyLinkedListNode<NodeVal> | null;
     set head(value: SinglyLinkedListNode<NodeVal> | null);
@@ -49,12 +55,6 @@ export declare class SinglyLinkedList<NodeVal = any> {
     protected _size: number;
     get size(): number;
     set size(value: number);
-    /**
-     * The constructor initializes a linked list with the given arguments as nodes.
-     * @param {NodeVal[]} args - args is a rest parameter that allows the constructor to accept an arbitrary number of
-     * arguments of type NodeVal.
-     */
-    constructor(...args: NodeVal[]);
     /**
      * The `from` function in TypeScript creates a new SinglyLinkedList instance from an iterable object.
      * @param iterable - The `iterable` parameter is an object that can be iterated over, such as an array or a string. It

package/dist/data-structures/priority-queue/priority-queue.d.ts

@@ -7,19 +7,15 @@
  */
 import type { PriorityQueueComparator, PriorityQueueDFSOrderPattern, PriorityQueueOptions } from '../types';
 export declare class PriorityQueue<T = number> {
-    protected _nodes: T[];
-    get nodes(): T[];
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getNodes(): T[];
-    protected set nodes(value: T[]);
     /**
      * The constructor initializes a priority queue with the given options, including an array of nodes and a comparator
      * function.
      * @param options - The `options` parameter is an object that contains the following properties:
      */
     constructor(options: PriorityQueueOptions<T>);
+    protected _nodes: T[];
+    get nodes(): T[];
+    protected set nodes(value: T[]);
     get size(): number;
     /**
      * The `heapify` function creates a new PriorityQueue instance and fixes the heap property.
@@ -37,6 +33,10 @@ export declare class PriorityQueue<T = number> {
      * @returns the result of calling the `isValid()` method on a new instance of the `PriorityQueue` class.
      */
     static isPriorityQueueified<T>(options: Omit<PriorityQueueOptions<T>, 'isFix'>): boolean;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getNodes(): T[];
     /**
      * The "add" function adds a node to the heap and ensures that the heap property is maintained.
      * @param {T} node - The parameter "node" is of type T, which means it can be any data type. It represents the node

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

@@ -67,12 +67,6 @@ var PriorityQueue = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    PriorityQueue.prototype.getNodes = function () {
-        return this._nodes;
-    };
     Object.defineProperty(PriorityQueue.prototype, "size", {
         get: function () {
             return this.nodes.length;
@@ -102,6 +96,12 @@ var PriorityQueue = /** @class */ (function () {
     PriorityQueue.isPriorityQueueified = function (options) {
         return new PriorityQueue(__assign(__assign({}, options), { isFix: true })).isValid();
     };
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    PriorityQueue.prototype.getNodes = function () {
+        return this._nodes;
+    };
     /**
      * The "add" function adds a node to the heap and ensures that the heap property is maintained.
      * @param {T} node - The parameter "node" is of type T, which means it can be any data type. It represents the node

package/dist/data-structures/queue/deque.d.ts

@@ -9,6 +9,7 @@ import { DoublyLinkedList } from '../linked-list';
 export declare class Deque<T> extends DoublyLinkedList<T> {
 }
 export declare class ObjectDeque<T> {
+    constructor(capacity?: number);
     private _nodes;
     get nodes(): {
         [p: number]: T;
@@ -28,7 +29,6 @@ export declare class ObjectDeque<T> {
     private _size;
     get size(): number;
     protected set size(value: number);
-    constructor(capacity?: number);
     addFirst(value: T): void;
     addLast(value: T): void;
     pollFirst(): T | undefined;

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

@@ -1,55 +1,3 @@
-export type JSONSerializable = {
-    [key: string]: any;
-};
-export type JSONValue = string | number | boolean | undefined | JSONObject;
-export interface JSONObject {
-    [key: string]: JSONValue;
-}
-export type AnyFunction<A extends any[] = any[], R = any> = (...args: A) => R;
-export type Primitive = number | string | boolean | symbol | undefined | null | void | AnyFunction | Date;
-export type Cast<T, TComplex> = {
-    [M in keyof TComplex]: T;
-};
-export type DeepLeavesWrap<T, TComplex> = T extends string ? Cast<string, TComplex> : T extends number ? Cast<number, TComplex> : T extends boolean ? Cast<boolean, TComplex> : T extends undefined ? Cast<undefined, TComplex> : T extends null ? Cast<null, TComplex> : T extends void ? Cast<void, TComplex> : T extends symbol ? Cast<symbol, TComplex> : T extends AnyFunction ? Cast<AnyFunction, TComplex> : T extends Date ? Cast<Date, TComplex> : {
-    [K in keyof T]: T[K] extends (infer U)[] ? DeepLeavesWrap<U, TComplex>[] : DeepLeavesWrap<T[K], TComplex>;
-};
-export type TypeName<T> = T extends string ? 'string' : T extends number ? 'number' : T extends boolean ? 'boolean' : T extends undefined ? 'undefined' : T extends AnyFunction ? 'function' : 'object';
-export type JsonKeys<T> = keyof {
-    [P in keyof T]: number;
-};
-/**
- * A function that emits a side effect and does not return anything.
- */
-export type Procedure = (...args: any[]) => void;
-export type DebounceOptions = {
-    isImmediate?: boolean;
-    maxWait?: number;
-};
-export interface DebouncedFunction<F extends Procedure> {
-    cancel: () => void;
-    (this: ThisParameterType<F>, ...args: [...Parameters<F>]): void;
-}
-export type MonthKey = 'January' | 'February' | 'March' | 'April' | 'May' | 'June' | 'July' | 'August' | 'September' | 'October' | 'November' | 'December';
-export type Month = {
-    [key in MonthKey]: string;
-};
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-export declare class TreeNode<T> {
-    id: string;
-    name?: string | undefined;
-    value?: T | undefined;
-    children?: TreeNode<T>[] | undefined;
-    constructor(id: string, name?: string, value?: T, children?: TreeNode<T>[]);
-    addChildren(children: TreeNode<T> | TreeNode<T>[]): void;
-    getHeight(): number;
-}
-export type OrderType = 'InOrder' | 'PreOrder' | 'PostOrder';
-export type DeepProxy<T> = T extends (...args: any[]) => infer R ? (...args: [...Parameters<T>]) => DeepProxy<R> : T extends object ? {
-    [K in keyof T]: DeepProxy<T[K]>;
-} : T;
-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>;
 export type Thunk = () => ReturnType<ToThunkFn> & {
     __THUNK__: Symbol;

package/dist/utils/types/utils.js

@@ -1,54 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeNode = void 0;
-var arr = ['1', 2, 4, 5, 6];
-var a = 2;
-var TreeNode = /** @class */ (function () {
-    function TreeNode(id, name, value, children) {
-        this.id = id;
-        this.name = name || '';
-        this.value = value || undefined;
-        this.children = children || [];
-    }
-    // TODO get set
-    // get name (): string | undefined {
-    //     return this.name;
-    // }
-    //
-    // set name (name: string | undefined) {
-    //     this.name = name;
-    // }
-    TreeNode.prototype.addChildren = function (children) {
-        if (!this.children) {
-            this.children = [];
-        }
-        if (children instanceof TreeNode) {
-            this.children.push(children);
-        }
-        else {
-            this.children = this.children.concat(children);
-        }
-    };
-    TreeNode.prototype.getHeight = function () {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        var beginRoot = this;
-        var maxDepth = 1;
-        if (beginRoot) {
-            var bfs_1 = function (node, level) {
-                if (level > maxDepth) {
-                    maxDepth = level;
-                }
-                var children = node.children;
-                if (children) {
-                    for (var i = 0, len = children.length; i < len; i++) {
-                        bfs_1(children[i], level + 1);
-                    }
-                }
-            };
-            bfs_1(beginRoot, 1);
-        }
-        return maxDepth;
-    };
-    return TreeNode;
-}());
-exports.TreeNode = TreeNode;

package/dist/utils/utils.d.ts

@@ -1,101 +1,5 @@
-import type { AnyFunction, JSONObject, JSONSerializable } from './types';
-export declare function randomText(length: number): string;
 export declare const uuidV4: () => string;
-export declare class IncrementId {
-    private _id;
-    private readonly _prefix;
-    constructor(prefix?: string);
-    getId(): string;
-}
-export declare function incrementId(prefix?: string): () => string;
-export declare const getValue: <T, K extends keyof T>(obj: T, names: K[]) => T[K][];
-export declare const isObject: (object: string | JSONObject | boolean | AnyFunction | number) => boolean;
-export declare const looseEqual: (a: any, b: any) => boolean;
-export declare const strictEqual: (a: any, b: any) => boolean;
-export declare const strictObjectIsEqual: (a: any, b: any) => boolean;
-export declare const deepObjectStrictEqual: (object1: JSONSerializable, object2: JSONSerializable) => boolean;
-export declare function reverseColor(oldColor: string): string;
-export declare const isSameStructure: (objA: unknown, objB: unknown) => boolean;
-export declare const isLeafParent: (obj: JSONObject) => boolean;
-export declare const addDays: (date: Date, days: number) => Date;
-export declare class WaitManager {
-    private _time30;
-    private readonly _nXSpeed;
-    constructor(nXSpeed?: number);
-    private _time1;
-    get time1(): number;
-    private _time2;
-    get time2(): number;
-    private _time3;
-    get time3(): number;
-    private _time4;
-    get time4(): number;
-    private _time10;
-    get time10(): number;
-    private _time20;
-    get time20(): number;
-    get time50(): number;
-    private _time60;
-    get time60(): number;
-    private _cusTime;
-    get cusTime(): number;
-    set cusTime(v: number);
-}
-export declare const wait: (ms: number, resolveValue?: any) => Promise<unknown>;
-export declare function extractValue<Item>(data: {
-    key: string;
-    value: Item;
-}[]): Item[];
-export declare function keyValueToArray<Item>(data: {
-    [key: string]: Item;
-}): Item[];
-export declare function minuted(time: number): string;
-export declare function randomDate(start?: Date, end?: Date, specificProbabilityStart?: Date, specificProbability?: number): Date;
-export declare const capitalizeWords: (str: string) => string;
-export declare const capitalizeFirstLetter: (str: string) => string;
-export declare const comparerArray: <T>(otherArray: T[], limitKeys?: string[]) => (current: T) => boolean;
-export declare const onlyInA: <T>(a: T[], b: T[]) => T[];
-export declare const onlyInB: <T>(a: T[], b: T[]) => T[];
-export declare const diffAB: <T>(a: T[], b: T[]) => T[];
-export declare class StringUtil {
-    static toCamelCase(str: string): string;
-    static toSnakeCase(str: string): string;
-    static toPascalCase(str: string): string;
-    static toConstantCase(str: string): string;
-    static toKebabCase(str: string): string;
-    static toLowerCase(str: string): string;
-    static toTitleCase(str: string): string;
-    static toSentenceCase(str: string): string;
-    static toPathCase(str: string): string;
-    static toDotCase(str: string): string;
-}
-export type CaseType = 'camel' | 'snake' | 'pascal' | 'constant' | 'kebab' | 'lower' | 'title' | 'sentence' | 'path' | 'dot';
-export declare const deepKeysConvert: (obj: any, toType?: CaseType) => any;
-export declare const deepRemoveByKey: (obj: any, keysToBeRemoved: string[]) => any;
-export declare const deepRenameKeys: (obj: JSONSerializable, keysMap: {
-    [x: string]: string;
-}) => JSONSerializable;
-export declare const deepReplaceValues: (obj: JSONSerializable, keyReducerMap: {
-    [x: string]: (item: JSONSerializable) => any;
-}) => JSONSerializable;
-export declare const deepAdd: (obj: JSONSerializable, keyReducerMap: {
-    [x: string]: (item: JSONSerializable) => any;
-}, isItemRootParent?: boolean) => [] | JSONObject;
-export declare const bunnyConsole: {
-    log: (headerLog?: string, ...args: any[]) => void;
-    warn: (headerLog?: string, ...args: any[]) => void;
-    error: (headerLog?: string, ...args: any[]) => void;
-};
-export declare const timeStart: () => number;
-export declare const timeEnd: (startTime: number, headerLog?: string, consoleConditionFn?: ((timeSpent: number) => boolean) | undefined) => void;
 export declare const arrayRemove: <T>(array: T[], predicate: (item: T, index: number, array: T[]) => boolean) => T[];
-export declare function memo(): (target: Object, propertyKey: string, descriptor: PropertyDescriptor) => void;
-export declare function zip<T = number, T1 = number>(array1: T[], array2: T1[], options?: {
-    isToObj: boolean;
-}): [T, T1][] | {
-    x: T;
-    y: T1;
-}[];
 /**
  * data-structure-typed
  *
@@ -103,7 +7,7 @@ export declare function zip<T = number, T1 = number>(array1: T[], array2: T1[],
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from './types';
+import type { Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from './types';
 export declare const THUNK_SYMBOL: unique symbol;
 export declare const isThunk: (fnOrValue: any) => boolean;
 export declare const toThunk: (fn: ToThunkFn) => Thunk;