data-structure-typed 1.15.0 → 1.15.2

package/src/data-structures/hash/coordinate-set.ts

@@ -6,24 +6,27 @@
  * @license MIT License
  */
 export class CoordinateSet extends Set {
+    constructor(joint?: string) {
+        super();
+        if (joint !== undefined) this._joint = joint;
+    }
+
     protected _joint: string = '_';
+
     get joint(): string {
         return this._joint;
     }
+
+    protected set joint(v: string) {
+        this._joint = v;
+    }
+
     /**
      * 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.
      */
     getJoint(): string {
         return this._joint;
     }
-    protected set joint(v: string) {
-        this._joint = v;
-    }
-
-    constructor(joint?: string) {
-        super();
-        if (joint !== undefined) this._joint = joint;
-    }
 
     /**
      * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after

package/src/data-structures/heap/heap.ts

@@ -9,34 +9,6 @@ import {PriorityQueue} from '../priority-queue';
 import type {HeapItem, HeapOptions} from '../types';
 
 export abstract class Heap<T> {
-    protected abstract _pq: PriorityQueue<HeapItem<T>>;
-    get pq() {
-        return this._pq;
-    }
-    /**
-     * 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.
-     */
-    getPq() {
-        return this._pq;
-    }
-    protected set pq(v: PriorityQueue<HeapItem<T>>) {
-        this._pq = v;
-    }
-
-    protected _priorityCb: (element: T) => number;
-    get priorityCb() {
-        return this._priorityCb;
-    }
-    /**
-     * 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.
-     */
-    getPriorityCb() {
-        return this._priorityCb;
-    }
-    protected set priorityCb(v: (element: T) => number) {
-        this._priorityCb = v;
-    }
-
     /**
      * The function is a constructor for a class that initializes a priority callback function based on the
      * options provided.
@@ -54,6 +26,25 @@ export abstract class Heap<T> {
         }
     }
 
+    protected abstract _pq: PriorityQueue<HeapItem<T>>;
+
+    get pq() {
+        return this._pq;
+    }
+
+    protected set pq(v: PriorityQueue<HeapItem<T>>) {
+        this._pq = v;
+    }
+
+    protected _priorityCb: (element: T) => number;
+    get priorityCb() {
+        return this._priorityCb;
+    }
+
+    protected set priorityCb(v: (element: T) => number) {
+        this._priorityCb = v;
+    }
+
     /**
      * The function returns the size of a priority queue.
      * @returns The size of the priority queue.
@@ -61,6 +52,21 @@ export abstract class Heap<T> {
     get size(): number {
         return this._pq.size;
     }
+
+    /**
+     * 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.
+     */
+    getPq() {
+        return this._pq;
+    }
+
+    /**
+     * 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.
+     */
+    getPriorityCb() {
+        return this._priorityCb;
+    }
+
     /**
      * 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/src/data-structures/linked-list/doubly-linked-list.ts

@@ -8,48 +8,56 @@
 import type {DoublyLinkedListGetBy} from '../types';
 
 export class DoublyLinkedListNode<T> {
+    constructor(nodeValue: T) {
+        this._val = nodeValue;
+        this._next = null;
+        this._prev = null;
+    }
+
     protected _val: T;
+
     get val(): T {
         return this._val;
     }
+
     set val(v: T) {
         this._val = v;
     }
 
     protected _next: DoublyLinkedListNode<T> | null;
+
     get next(): DoublyLinkedListNode<T> | null {
         return this._next;
     }
+
     set next(v: DoublyLinkedListNode<T> | null) {
         this._next = v;
     }
 
     protected _prev: DoublyLinkedListNode<T> | null;
+
     get prev(): DoublyLinkedListNode<T> | null {
         return this._prev;
     }
+
     set prev(v: DoublyLinkedListNode<T> | null) {
         this._prev = v;
     }
-
-    constructor(nodeValue: T) {
-        this._val = nodeValue;
-        this._next = null;
-        this._prev = null;
-    }
 }
 
 export class DoublyLinkedList<T> {
+    constructor() {
+        this._first = null;
+        this._last = null;
+        this._size = 0;
+    }
+
     protected _first: DoublyLinkedListNode<T> | null;
+
     get first(): DoublyLinkedListNode<T> | null {
         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.
-     */
-    getFirst(): DoublyLinkedListNode<T> | null {
-        return this._first;
-    }
+
     protected set first(v: DoublyLinkedListNode<T> | null) {
         this._first = v;
     }
@@ -58,34 +66,40 @@ export class DoublyLinkedList<T> {
     get last(): DoublyLinkedListNode<T> | null {
         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.
-     */
-    getLast(): DoublyLinkedListNode<T> | null {
-        return this._last;
-    }
+
     protected set last(v: DoublyLinkedListNode<T> | null) {
         this._last = v;
     }
 
     protected _size: number;
+
     get size(): number {
         return this._size;
     }
+
+    protected set size(v: number) {
+        this._size = v;
+    }
+
     /**
      * 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 {
-        return this._size;
+    getFirst(): DoublyLinkedListNode<T> | null {
+        return this._first;
     }
-    protected set size(v: number) {
-        this._size = v;
+
+    /**
+     * 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 {
+        return this._last;
     }
 
-    constructor() {
-        this._first = null;
-        this._last = null;
-        this._size = 0;
+    /**
+     * 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 {
+        return this._size;
     }
 
     /**

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -10,7 +10,15 @@
 /* The SinglyLinkedListNode class represents a node in a singly linked list and provides methods for inserting, removing,
 and accessing nodes. */
 export class SinglyLinkedListNode<NodeVal = any> {
+    constructor(val: NodeVal, prev?: SinglyLinkedListNode<NodeVal> | null, next?: SinglyLinkedListNode<NodeVal> | null, list?: SinglyLinkedList<NodeVal> | null) {
+        this._val = val;
+        this._prev = prev || null;
+        this._next = next || null;
+        this._list = list || null;
+    }
+
     protected _val: NodeVal;
+
     get val(): NodeVal {
         return this._val;
     }
@@ -20,6 +28,7 @@ export class SinglyLinkedListNode<NodeVal = any> {
     }
 
     protected _prev: SinglyLinkedListNode<NodeVal> | null;
+
     get prev(): SinglyLinkedListNode<NodeVal> | null {
         return this._prev;
     }
@@ -29,6 +38,7 @@ export class SinglyLinkedListNode<NodeVal = any> {
     }
 
     protected _next: SinglyLinkedListNode<NodeVal> | null
+
     get next(): SinglyLinkedListNode<NodeVal> | null {
         return this._next;
     }
@@ -38,6 +48,7 @@ export class SinglyLinkedListNode<NodeVal = any> {
     }
 
     protected _list: SinglyLinkedList<NodeVal> | null
+
     get list(): SinglyLinkedList<NodeVal> | null {
         return this._list;
     }
@@ -46,13 +57,6 @@ export class SinglyLinkedListNode<NodeVal = any> {
         this._list = value;
     }
 
-    constructor(val: NodeVal, prev?: SinglyLinkedListNode<NodeVal> | null, next?: SinglyLinkedListNode<NodeVal> | null, list?: SinglyLinkedList<NodeVal> | null) {
-        this._val = val;
-        this._prev = prev || null;
-        this._next = next || null;
-        this._list = list || null;
-    }
-
     get index() {
         if (!this.list) {
             return undefined;
@@ -97,46 +101,51 @@ export class SinglyLinkedListNode<NodeVal = any> {
 
 export 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[]) {
+        this._head = null;
+        this._tail = null;
+        this._size = 0;
+
+        for (let i = 0; i < arguments.length; i++) {
+            this.append(args[i]);
+        }
+    }
+
     protected _head: SinglyLinkedListNode<NodeVal> | null;
+
     get head(): SinglyLinkedListNode<NodeVal> | null {
         return this._head;
     }
+
     set head(value: SinglyLinkedListNode<NodeVal> | null) {
         this._head = value;
     }
 
-
     protected _tail: SinglyLinkedListNode<NodeVal> | null;
+
     get tail(): SinglyLinkedListNode<NodeVal> | null {
         return this._tail;
     }
+
     set tail(value: SinglyLinkedListNode<NodeVal> | null) {
         this._tail = value;
     }
 
     protected _size: number;
+
     get size(): number {
         return this._size;
     }
+
     set size(value: number) {
         this._size = value;
     }
 
-    /**
-     * 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[]) {
-        this._head = null;
-        this._tail = null;
-        this._size = 0;
-
-        for (let i = 0; i < arguments.length; i++) {
-            this.append(args[i]);
-        }
-    }
-
     /**
      * 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/src/data-structures/priority-queue/priority-queue.ts

@@ -9,20 +9,6 @@ import type {PriorityQueueComparator, PriorityQueueDFSOrderPattern, PriorityQueu
 
 export class PriorityQueue<T = number> {
 
-    protected _nodes: T[] = [];
-    get nodes(): T[] {
-        return this._nodes;
-    }
-    /**
-     * 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[] {
-        return this._nodes;
-    }
-    protected set nodes(value: T[]) {
-        this._nodes = value;
-    }
-    
     /**
      * The constructor initializes a priority queue with the given options, including an array of nodes and a comparator
      * function.
@@ -39,6 +25,16 @@ export class PriorityQueue<T = number> {
         }
     }
 
+    protected _nodes: T[] = [];
+
+    get nodes(): T[] {
+        return this._nodes;
+    }
+
+    protected set nodes(value: T[]) {
+        this._nodes = value;
+    }
+
     get size(): number {
         return this.nodes.length;
     }
@@ -67,6 +63,13 @@ export class PriorityQueue<T = number> {
         return new PriorityQueue({...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.
+     */
+    getNodes(): T[] {
+        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/src/data-structures/queue/deque.ts

@@ -17,50 +17,60 @@ export class Deque<T> extends DoublyLinkedList<T> {
 // O(n) time complexity of adding at the beginning and the end
 // todo tested slowest one
 export class ObjectDeque<T> {
+    constructor(capacity?: number) {
+        if (capacity !== undefined) this._capacity = capacity;
+    }
+
     private _nodes: { [key: number]: T } = {};
+
     get nodes(): { [p: number]: T } {
         return this._nodes;
     }
+
     protected set nodes(value: { [p: number]: T }) {
         this._nodes = value;
     }
 
     private _capacity = Number.MAX_SAFE_INTEGER;
+
     get capacity(): number {
         return this._capacity;
     }
+
     set capacity(value: number) {
         this._capacity = value;
     }
 
     private _first: number = -1;
+
     get first(): number {
         return this._first;
     }
+
     set first(value: number) {
         this._first = value;
     }
 
     private _last: number = -1;
+
     get last(): number {
         return this._last;
     }
+
     set last(value: number) {
         this._last = value;
     }
 
     private _size: number = 0;
+
     get size(): number {
         return this._size;
     }
+
     protected set size(value: number) {
         this._size = value;
     }
 
-    constructor(capacity?: number) {
-        if (capacity !== undefined) this._capacity = capacity;
-    }
-
     addFirst(value: T) {
         if (this._size === 0) {
             const mid = Math.floor(this._capacity / 2);

package/src/utils/types/utils.ts

@@ -1,178 +1,4 @@
-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>;
-                                        }
-
-
-type Json = null | string | number | boolean | Json [] | { [name: string]: Json }
-
-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
-}
-
-const arr = ['1', 2, 4, 5, 6] as const;
-type Range = typeof arr[number];
-const a: Range = 2;
-
-
-/**
- * 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 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>[]) {
-        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;
-    // }
-
-    addChildren(children: TreeNode<T> | TreeNode<T> []) {
-        if (!this.children) {
-            this.children = [];
-        }
-        if (children instanceof TreeNode) {
-            this.children.push(children);
-        } else {
-            this.children = this.children.concat(children);
-        }
-    }
-
-    getHeight() {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const beginRoot = this;
-        let maxDepth = 1;
-        if (beginRoot) {
-            const bfs = (node: TreeNode<T>, level: number) => {
-                if (level > maxDepth) {
-                    maxDepth = level;
-                }
-                const {children} = node;
-                if (children) {
-                    for (let i = 0, len = children.length; i < len; i++) {
-                        bfs(children[i], level + 1);
-                    }
-                }
-            };
-            bfs(beginRoot, 1);
-        }
-        return maxDepth;
-    }
-
-}
-
-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 };
 export type TrlFn = (...args: any[]) => any;
-export type TrlAsyncFn = (...args: any[]) => any;
-
+export type TrlAsyncFn = (...args: any[]) => any;