data-structure-typed 1.17.4 → 1.18.5

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

@@ -15,7 +15,6 @@ export declare class PriorityQueue<T = number> {
     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.
@@ -112,6 +111,7 @@ export declare class PriorityQueue<T = number> {
      * @returns an array of type `(T | null)[]`.
      */
     DFS(dfsMode: PriorityQueueDFSOrderPattern): (T | null)[];
+    protected _setNodes(value: T[]): void;
     protected readonly _comparator: PriorityQueueComparator<T>;
     /**
      * The function compares two numbers using a custom comparator function.

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

@@ -61,9 +61,6 @@ var PriorityQueue = /** @class */ (function () {
         get: function () {
             return this._nodes;
         },
-        set: function (value) {
-            this._nodes = value;
-        },
         enumerable: false,
         configurable: true
     });
@@ -167,7 +164,7 @@ var PriorityQueue = /** @class */ (function () {
      * The clear function clears the nodes array.
      */
     PriorityQueue.prototype.clear = function () {
-        this.nodes = [];
+        this._setNodes([]);
     };
     /**
      * The toArray function returns an array containing all the elements in the nodes property.
@@ -256,6 +253,9 @@ var PriorityQueue = /** @class */ (function () {
         this._isValidIndex(0) && traverse(0);
         return visitedNode;
     };
+    PriorityQueue.prototype._setNodes = function (value) {
+        this._nodes = value;
+    };
     /**
      * The function compares two numbers using a custom comparator function.
      * @param {number} a - The parameter "a" is a number that represents the index of a node in an array.

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

@@ -8,15 +8,12 @@
 import { DoublyLinkedList } from '../linked-list';
 export declare class Deque<T> extends DoublyLinkedList<T> {
 }
-export declare class ObjectDeque<T> {
+export declare class ObjectDeque<T = number> {
     constructor(capacity?: number);
     private _nodes;
     get nodes(): {
         [p: number]: T;
     };
-    protected set nodes(value: {
-        [p: number]: T;
-    });
     private _capacity;
     get capacity(): number;
     set capacity(value: number);
@@ -28,7 +25,6 @@ export declare class ObjectDeque<T> {
     set last(value: number);
     private _size;
     get size(): number;
-    protected set size(value: number);
     addFirst(value: T): void;
     addLast(value: T): void;
     pollFirst(): T | undefined;
@@ -37,6 +33,10 @@ export declare class ObjectDeque<T> {
     peekLast(): T | undefined;
     get(index: number): NonNullable<T> | null;
     isEmpty(): boolean;
+    protected _seNodes(value: {
+        [p: number]: T;
+    }): void;
+    protected _setSize(value: number): void;
 }
 export declare class ArrayDeque<T> {
     protected _nodes: T[];

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

@@ -51,9 +51,6 @@ var ObjectDeque = /** @class */ (function () {
         get: function () {
             return this._nodes;
         },
-        set: function (value) {
-            this._nodes = value;
-        },
         enumerable: false,
         configurable: true
     });
@@ -91,9 +88,6 @@ var ObjectDeque = /** @class */ (function () {
         get: function () {
             return this._size;
         },
-        set: function (value) {
-            this._size = value;
-        },
         enumerable: false,
         configurable: true
     });
@@ -153,6 +147,12 @@ var ObjectDeque = /** @class */ (function () {
     ObjectDeque.prototype.isEmpty = function () {
         return this._size <= 0;
     };
+    ObjectDeque.prototype._seNodes = function (value) {
+        this._nodes = value;
+    };
+    ObjectDeque.prototype._setSize = function (value) {
+        this._size = value;
+    };
     return ObjectDeque;
 }());
 exports.ObjectDeque = ObjectDeque;

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

@@ -3,7 +3,7 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-export declare class Queue<T> {
+export declare class Queue<T = number> {
     protected _nodes: T[];
     protected _offset: number;
     /**

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

@@ -3,7 +3,7 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-export declare class Stack<T> {
+export declare class Stack<T = number> {
     protected _elements: T[];
     /**
      * The constructor initializes an array of elements, which can be provided as an optional parameter.

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

@@ -1,9 +1,17 @@
 export declare class TreeNode<T = number> {
-    id: string;
-    name?: string | undefined;
-    value?: T | undefined;
-    children?: TreeNode<T>[] | undefined;
     constructor(id: string, name?: string, value?: T, children?: TreeNode<T>[]);
+    private _id;
+    get id(): string;
+    set id(value: string);
+    private _name?;
+    get name(): string | undefined;
+    set name(value: string | undefined);
+    private _value?;
+    get value(): T | undefined;
+    set value(value: T | undefined);
+    private _children?;
+    get children(): TreeNode<T>[] | undefined;
+    set children(value: TreeNode<T>[] | undefined);
     addChildren(children: TreeNode<T> | TreeNode<T>[]): void;
     getHeight(): number;
 }

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

@@ -3,19 +3,51 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeNode = void 0;
 var TreeNode = /** @class */ (function () {
     function TreeNode(id, name, value, children) {
-        this.id = id;
-        this.name = name || '';
-        this.value = value || undefined;
-        this.children = 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;
-    // }
+    Object.defineProperty(TreeNode.prototype, "id", {
+        get: function () {
+            return this._id;
+        },
+        set: function (value) {
+            this._id = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TreeNode.prototype, "name", {
+        get: function () {
+            return this._name;
+        },
+        set: function (value) {
+            this._name = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TreeNode.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        set: function (value) {
+            this._value = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TreeNode.prototype, "children", {
+        get: function () {
+            return this._children;
+        },
+        set: function (value) {
+            this._children = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
     TreeNode.prototype.addChildren = function (children) {
         if (!this.children) {
             this.children = [];

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

@@ -6,16 +6,16 @@
  * @license MIT License
  */
 export declare class TrieNode {
-    protected _value: string;
     constructor(v: string);
+    private _val;
+    get val(): string;
+    set val(v: string);
     protected _children: Map<string, TrieNode>;
     get children(): Map<string, TrieNode>;
     set children(v: Map<string, TrieNode>);
     protected _isEnd: boolean;
     get isEnd(): boolean;
     set isEnd(v: boolean);
-    get val(): string;
-    set val(v: string);
 }
 export declare class Trie {
     constructor(words?: string[]);

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

@@ -21,36 +21,36 @@ exports.Trie = exports.TrieNode = void 0;
  */
 var TrieNode = /** @class */ (function () {
     function TrieNode(v) {
-        this._value = v;
+        this._val = v;
         this._isEnd = false;
         this._children = new Map();
     }
-    Object.defineProperty(TrieNode.prototype, "children", {
+    Object.defineProperty(TrieNode.prototype, "val", {
         get: function () {
-            return this._children;
+            return this._val;
         },
         set: function (v) {
-            this._children = v;
+            this._val = v;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(TrieNode.prototype, "isEnd", {
+    Object.defineProperty(TrieNode.prototype, "children", {
         get: function () {
-            return this._isEnd;
+            return this._children;
         },
         set: function (v) {
-            this._isEnd = v;
+            this._children = v;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(TrieNode.prototype, "val", {
+    Object.defineProperty(TrieNode.prototype, "isEnd", {
         get: function () {
-            return this._value;
+            return this._isEnd;
         },
         set: function (v) {
-            this._value = v;
+            this._isEnd = v;
         },
         enumerable: false,
         configurable: true

package/dist/data-structures/types/abstract-graph.d.ts

@@ -1,4 +1,5 @@
 export type VertexId = string | number;
+export type EdgeId = string;
 export type DijkstraResult<V> = {
     distMap: Map<V, number>;
     preMap: Map<V, V | null>;
@@ -7,23 +8,3 @@ export type DijkstraResult<V> = {
     minDist: number;
     minPath: V[];
 } | null;
-export interface IGraph<V, E> {
-    hasVertex(vertexOrId: V | VertexId): boolean;
-    getVertex(vertexOrId: VertexId | V): V | null;
-    getVertexId(vertexOrId: V | VertexId): VertexId;
-    vertexSet(): Map<VertexId, V>;
-    addVertex(v: V): boolean;
-    removeVertex(vertexOrId: V | VertexId): boolean;
-    removeAllVertices(vertices: V[] | VertexId[]): boolean;
-    degreeOf(vertexOrId: V | VertexId): number;
-    edgesOf(vertexOrId: V | VertexId): E[];
-    hasEdge(src: V | VertexId, dest: V | VertexId): boolean;
-    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-    edgeSet(): E[];
-    addEdge(edge: E): boolean;
-    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-    removeEdge(edge: E): E | null;
-    setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
-    getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
-    getNeighbors(vertexOrId: V | VertexId): V[];
-}

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

@@ -1,5 +1,6 @@
 import { AVLTreeNode } from '../binary-tree';
-export interface AVLTreeDeleted<T> {
-    deleted: AVLTreeNode<T> | null;
-    needBalanced: AVLTreeNode<T> | null;
-}
+export type AVLTreeDeleted<N> = {
+    deleted: N | null;
+    needBalanced: N | null;
+};
+export type RecursiveAVLTreeNode<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;

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

@@ -3,9 +3,10 @@ export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
 export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
 export type DFSOrderPattern = 'in' | 'pre' | 'post';
 export type BinaryTreeNodeId = number;
-export type BinaryTreeDeleted<T> = {
-    deleted: BinaryTreeNode<T> | null | undefined;
-    needBalanced: BinaryTreeNode<T> | null;
+export type BinaryTreeDeleted<N> = {
+    deleted: N | null | undefined;
+    needBalanced: N | null;
 };
-export type ResultByProperty<T> = T | BinaryTreeNode<T> | number | BinaryTreeNodeId;
-export type ResultsByProperty<T> = ResultByProperty<T>[];
+export type ResultByProperty<N extends BinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeId;
+export type ResultsByProperty<N extends BinaryTreeNode<N['val'], N>> = ResultByProperty<N>[];
+export type RecursiveBinaryTreeNode<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;

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

@@ -1,7 +1,8 @@
 import { BSTNode } from '../binary-tree';
 import type { BinaryTreeNodeId } from './binary-tree';
 export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
-export type BSTDeletedResult<T> = {
-    deleted: BSTNode<T> | null;
-    needBalanced: BSTNode<T> | null;
+export type BSTDeletedResult<N extends BSTNode<N['val'], N>> = {
+    deleted: N | null;
+    needBalanced: N | null;
 };
+export type RecursiveBSTNode<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;

package/dist/data-structures/types/directed-graph.d.ts

@@ -1,10 +1,6 @@
-import { VertexId } from './abstract-graph';
-export interface IDirectedGraph<V, E> {
-    incomingEdgesOf(vertex: V): E[];
-    outgoingEdgesOf(vertex: V): E[];
-    inDegreeOf(vertexOrId: V | VertexId): number;
-    outDegreeOf(vertexOrId: V | VertexId): number;
-    getEdgeSrc(e: E): V | null;
-    getEdgeDest(e: E): V | null;
-}
 export type TopologicalStatus = 0 | 1 | 2;
+export declare enum TopologicalProperty {
+    VAL = "VAL",
+    NODE = "NODE",
+    ID = "ID"
+}

package/dist/data-structures/types/directed-graph.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologicalProperty = void 0;
+var TopologicalProperty;
+(function (TopologicalProperty) {
+    TopologicalProperty["VAL"] = "VAL";
+    TopologicalProperty["NODE"] = "NODE";
+    TopologicalProperty["ID"] = "ID";
+})(TopologicalProperty || (exports.TopologicalProperty = TopologicalProperty = {}));

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

@@ -1 +1 @@
-export type DoublyLinkedListGetBy = 'node' | 'val';
+export {};

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

@@ -1,3 +1,3 @@
-export interface HeapOptions<T> {
+export type HeapOptions<T> = {
     priority?: (element: T) => number;
-}
+};

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

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

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

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

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

@@ -2,7 +2,7 @@ export type Direction = 'up' | 'right' | 'down' | 'left';
 export type Turning = {
     [key in Direction]: Direction;
 };
-export interface NavigatorParams<T> {
+export type NavigatorParams<T> = {
     matrix: T[][];
     turning: Turning;
     onMove: (cur: [number, number]) => void;
@@ -11,4 +11,4 @@ export interface NavigatorParams<T> {
         charDir: Direction;
         VISITED: T;
     };
-}
+};

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

@@ -1,7 +1,7 @@
 export type PriorityQueueComparator<T> = (a: T, b: T) => number;
-export interface PriorityQueueOptions<T> {
+export type PriorityQueueOptions<T> = {
     nodes?: T[];
     isFix?: boolean;
     comparator: PriorityQueueComparator<T>;
-}
+};
 export type PriorityQueueDFSOrderPattern = 'pre' | 'in' | 'post';

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

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