data-structure-typed 0.9.16 → 1.3.0

package/dist/interfaces/tree-multiset.d.ts

@@ -0,0 +1,7 @@
+import { TreeMultisetNode } from '../data-structures';
+import { IBSTNode } from './bst';
+import { IAVLTree } from './avl-tree';
+export interface ITreeMultisetNode<T, NEIGHBOR extends ITreeMultisetNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+}
+export interface ITreeMultiset<N extends TreeMultisetNode<N['val'], N>> extends IAVLTree<N> {
+}

package/dist/interfaces/tree-multiset.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/undirected-graph.d.ts

@@ -0,0 +1,5 @@
+import { VertexId } from '../types';
+import { IAbstractGraph } from './abstract-graph';
+export interface IUNDirectedGraph<V, E> extends IAbstractGraph<V, E> {
+    removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null;
+}

package/dist/interfaces/undirected-graph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,34 @@
+import { AbstractBinaryTreeNode } from '../../data-structures/binary-tree';
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
+export declare enum LoopType {
+    ITERATIVE = "ITERATIVE",
+    RECURSIVE = "RECURSIVE"
+}
+export declare enum FamilyPosition {
+    ROOT = "ROOT",
+    LEFT = "LEFT",
+    RIGHT = "RIGHT",
+    ROOT_LEFT = "ROOT_LEFT",
+    ROOT_RIGHT = "ROOT_RIGHT",
+    ISOLATED = "ISOLATED",
+    MAL_NODE = "MAL_NODE"
+}
+export type BinaryTreeNodePropertyName = 'id' | 'val';
+export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
+export type DFSOrderPattern = 'in' | 'pre' | 'post';
+export type BinaryTreeNodeId = number;
+export type BinaryTreeDeletedResult<N> = {
+    deleted: N | null | undefined;
+    needBalanced: N | null;
+};
+export type AbstractBinaryTreeNodeProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeId;
+export type AbstractBinaryTreeNodeProperties<N extends AbstractBinaryTreeNode<N['val'], N>> = AbstractBinaryTreeNodeProperty<N>[];
+export type AbstractBinaryTreeNodeNested<T> = AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AbstractBinaryTreeOptions = {
+    loopType?: LoopType;
+};

package/dist/types/data-structures/abstract-binary-tree.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FamilyPosition = exports.LoopType = void 0;
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
+var LoopType;
+(function (LoopType) {
+    LoopType["ITERATIVE"] = "ITERATIVE";
+    LoopType["RECURSIVE"] = "RECURSIVE";
+})(LoopType = exports.LoopType || (exports.LoopType = {}));
+/* This enumeration defines the position of a node within a family tree composed of three associated nodes, where 'root' represents the root node of the family tree, 'left' represents the left child node, and 'right' represents the right child node. */
+var FamilyPosition;
+(function (FamilyPosition) {
+    FamilyPosition["ROOT"] = "ROOT";
+    FamilyPosition["LEFT"] = "LEFT";
+    FamilyPosition["RIGHT"] = "RIGHT";
+    FamilyPosition["ROOT_LEFT"] = "ROOT_LEFT";
+    FamilyPosition["ROOT_RIGHT"] = "ROOT_RIGHT";
+    FamilyPosition["ISOLATED"] = "ISOLATED";
+    FamilyPosition["MAL_NODE"] = "MAL_NODE";
+})(FamilyPosition = exports.FamilyPosition || (exports.FamilyPosition = {}));

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

@@ -0,0 +1,11 @@
+export type VertexId = string | number;
+export type EdgeId = string;
+export type DijkstraResult<V> = {
+    distMap: Map<V, number>;
+    distPaths?: Map<V, V[]>;
+    preMap: Map<V, V | null>;
+    seen: Set<V>;
+    paths: V[][];
+    minDist: number;
+    minPath: V[];
+} | null;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+import { AVLTreeNode } from '../../data-structures/binary-tree';
+import { BSTOptions } from './bst';
+export type AVLTreeNodeNested<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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeOptions = BSTOptions & {};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+import { BinaryTreeNode } from '../../data-structures/binary-tree';
+import { AbstractBinaryTreeOptions } from './abstract-binary-tree';
+export type BinaryTreeNodeNested<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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BinaryTreeOptions = AbstractBinaryTreeOptions & {};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,13 @@
+import { BSTNode } from '../../data-structures/binary-tree';
+import type { BinaryTreeOptions } from './binary-tree';
+import { BinaryTreeNodeId } from './abstract-binary-tree';
+export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
+export type BSTNodeNested<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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BSTOptions = BinaryTreeOptions & {
+    comparator?: BSTComparator;
+};
+export declare enum CP {
+    lt = "lt",
+    eq = "eq",
+    gt = "gt"
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CP = void 0;
+var CP;
+(function (CP) {
+    CP["lt"] = "lt";
+    CP["eq"] = "eq";
+    CP["gt"] = "gt";
+})(CP = exports.CP || (exports.CP = {}));

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

@@ -0,0 +1,6 @@
+export type TopologicalStatus = 0 | 1 | 2;
+export declare enum TopologicalProperty {
+    VAL = "VAL",
+    NODE = "NODE",
+    ID = "ID"
+}

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

@@ -0,0 +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 || (exports.TopologicalProperty = {}));

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -4,10 +4,12 @@ export * from './avl-tree';
 export * from './segment-tree';
 export * from './tree-multiset';
 export * from './abstract-graph';
+export * from './map-graph';
+export * from './abstract-binary-tree';
+export * from './rb-tree';
 export * from './directed-graph';
 export * from './priority-queue';
 export * from './heap';
 export * from './singly-linked-list';
 export * from './doubly-linked-list';
 export * from './navigator';
-export * from './utils';

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

@@ -20,10 +20,12 @@ __exportStar(require("./avl-tree"), exports);
 __exportStar(require("./segment-tree"), exports);
 __exportStar(require("./tree-multiset"), exports);
 __exportStar(require("./abstract-graph"), exports);
+__exportStar(require("./map-graph"), exports);
+__exportStar(require("./abstract-binary-tree"), exports);
+__exportStar(require("./rb-tree"), exports);
 __exportStar(require("./directed-graph"), exports);
 __exportStar(require("./priority-queue"), exports);
 __exportStar(require("./heap"), exports);
 __exportStar(require("./singly-linked-list"), exports);
 __exportStar(require("./doubly-linked-list"), exports);
 __exportStar(require("./navigator"), exports);
-__exportStar(require("./utils"), exports);

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

@@ -0,0 +1 @@
+export type MapGraphCoordinate = [number, number];

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{data-structures/types → types/data-structures}/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/types/data-structures/navigator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{data-structures/types → types/data-structures}/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/types/data-structures/priority-queue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,8 @@
+import { BinaryTreeOptions } from './binary-tree';
+import { RBTreeNode } from '../../data-structures/binary-tree';
+export declare enum RBColor {
+    RED = "RED",
+    BLACK = "BLACK"
+}
+export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type RBTreeOptions = BinaryTreeOptions & {};

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RBColor = void 0;
+var RBColor;
+(function (RBColor) {
+    RBColor["RED"] = "RED";
+    RBColor["BLACK"] = "BLACK";
+})(RBColor = exports.RBColor || (exports.RBColor = {}));

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1 @@
+export {};

package/dist/types/data-structures/singly-linked-list.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+import { TreeMultisetNode } from '../../data-structures/binary-tree';
+import { AVLTreeOptions } from './avl-tree';
+export type TreeMultisetNodeNested<T> = TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type TreeMultisetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeById'> & {};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/helpers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/helpers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './data-structures';
+export * from './helpers';
+export * from './utils';

package/dist/types/index.js

@@ -0,0 +1,19 @@
+"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("./data-structures"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./utils"), exports);

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

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

package/dist/types/utils/index.js

@@ -0,0 +1,18 @@
+"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);
+__exportStar(require("./validate-type"), exports);

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

@@ -0,0 +1,7 @@
+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 SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/dist/types/utils/utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/utils/validate-type.d.ts

@@ -0,0 +1,19 @@
+export type KeyValueObject = {
+    [key: string]: any;
+};
+export type KeyValueObjectWithId = {
+    [key: string]: any;
+    id: string | number | symbol;
+};
+export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
+export type ObjectWithoutId = Omit<KeyValueObject, 'id'>;
+export type ObjectWithNonNumberId = {
+    [key: string]: any;
+    id: string | boolean | symbol | null | object | undefined;
+};
+export type ObjectWithNumberId = {
+    [key: string]: any;
+    id: number;
+};
+export type RestrictValById = NonNumberNonObjectButDefined | ObjectWithoutId | ObjectWithNonNumberId | ObjectWithNumberId;
+export type DummyAny = string | number | boolean | null | undefined | object | symbol | void | Function | never;

package/dist/types/utils/validate-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/utils.d.ts

@@ -1,105 +1,19 @@
-import { AnyFunction } from '../data-structures/types';
-export type JSONSerializable = {
-    [key: string]: any;
-};
-export type JSONValue = string | number | boolean | undefined | JSONObject;
-export interface JSONObject {
-    [key: string]: JSONValue;
-}
-export declare function randomText(length: number): string;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from '../types';
 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;
-}[];
+export declare const THUNK_SYMBOL: unique symbol;
+export declare const isThunk: (fnOrValue: any) => boolean;
+export declare const toThunk: (fn: ToThunkFn) => Thunk;
+export declare const trampoline: (fn: TrlFn) => ((...args: [...Parameters<TrlFn>]) => any) & {
+    cont: (...args: [...Parameters<TrlFn>]) => Thunk;
+};
+export declare const trampolineAsync: (fn: TrlAsyncFn) => ((...args: [...Parameters<TrlAsyncFn>]) => Promise<any>) & {
+    cont: (...args: [...Parameters<TrlAsyncFn>]) => Thunk;
+};