data-structure-typed 0.8.6

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

@@ -0,0 +1,69 @@
+/**
+ * @license MIT
+ * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ *
+ * @class
+ */
+export declare class Stack<T> {
+    protected _elements: T[];
+    /**
+     * Creates a stack.
+     * @param {array} [elements]
+     */
+    constructor(elements?: T[]);
+    /**
+     * Checks if the stack is empty.
+     * @public
+     * @returns {boolean}
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns the number of elements in the stack.
+     * @public
+     * @returns {number}
+     */
+    size(): number;
+    /**
+     * Returns the top element in the stack.
+     * @public
+     * @returns {object}
+     */
+    peek(): T | null;
+    /**
+     * Adds an element to the top of the stack.
+     * @public
+     * @param {object} element
+     */
+    push(element: T): Stack<T>;
+    /**
+     * Removes and returns the top element in the stack.
+     * @public
+     * @returns {object}
+     */
+    pop(): T | null;
+    /**
+     * Returns the remaining elements as an array.
+     * @public
+     * @returns {array}
+     */
+    toArray(): T[];
+    /**
+     * Clears all elements from the stack.
+     * @public
+     */
+    clear(): void;
+    /**
+     * Creates a shallow copy from the stack.
+     * @public
+     * @return {Stack}
+     */
+    clone(): Stack<T>;
+    /**
+     * Creates a stack from an existing array
+     * @public
+     * @static
+     * @param {array} [elements]
+     * @return {Stack}
+     */
+    static fromArray<T>(elements: T[]): Stack<T>;
+}

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

@@ -0,0 +1,25 @@
+export type ArgumentTypes<T extends (...args: any[]) => any> = T extends (...args: infer A) => any ? A : never;
+export declare const THUNK_SYMBOL: unique symbol;
+export interface Thunk<T> extends Function {
+    __THUNK__: typeof THUNK_SYMBOL;
+    (): T;
+}
+export type ThunkOrValue<T> = T | Thunk<T>;
+export type UnwrapThunkDeep<T> = {
+    0: T extends Thunk<infer U> ? UnwrapThunkDeep<U> : T;
+}[T extends ThunkOrValue<T> ? 0 : never];
+export declare const isThunk: <T>(value: any) => value is Thunk<T>;
+export declare const toThunk: <R>(fn: () => R) => Thunk<R>;
+export type UnwrapPromise<T> = T extends Promise<infer U> ? Exclude<U, Promise<T>> : T;
+export type Unbox<T> = UnwrapThunkDeep<UnwrapPromise<T>>;
+export type Cont<A extends any[], R> = (...args: A) => Thunk<Unbox<R>>;
+export interface Trampoline<F extends ((...args: any[]) => any)> {
+    (...args: ArgumentTypes<F>): Unbox<ReturnType<F>>;
+    cont: Cont<ArgumentTypes<F>, ReturnType<F>>;
+}
+export interface TrampolineAsync<F extends ((...args: any[]) => any)> {
+    (...args: ArgumentTypes<F>): Promise<Unbox<ReturnType<F>>>;
+    cont: Cont<ArgumentTypes<F>, ReturnType<F>>;
+}
+export declare const trampoline: <F extends (...args: any[]) => any>(fn: F) => Trampoline<F>;
+export declare const trampolineAsync: <F extends (...args: any[]) => any>(fn: F) => TrampolineAsync<F>;

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

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

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

@@ -0,0 +1,28 @@
+export declare class TrieNode {
+    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);
+}
+export declare class Trie {
+    protected _root: TrieNode;
+    get root(): TrieNode;
+    set root(v: TrieNode);
+    constructor();
+    put(input: string): boolean;
+    has(input: string): boolean;
+    remove(word: string): boolean;
+    /**
+     * Only can present as a prefix, not a word
+     * @param input
+     */
+    isAbsPrefix(input: string): boolean;
+    /**
+     * Can present as a prefix or word
+     * @param input
+     */
+    isPrefix(input: string): boolean;
+    getAll(prefix?: string): string[];
+}

package/dist/types/index.d.ts

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

package/dist/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/types/types/index.d.ts

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

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

@@ -0,0 +1,46 @@
+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 JSONSerializable = {
+    [key: string]: any;
+};
+export type JSONValue = string | number | boolean | undefined | JSONObject;
+export interface JSONObject {
+    [key: string]: JSONValue;
+}
+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> {
+    (this: ThisParameterType<F>, ...args: Parameters<F>): void;
+    cancel: () => 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';

package/dist/types/utils.d.ts

@@ -0,0 +1,122 @@
+import { AnyFunction } from './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;
+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 const isTypeEqual: <T>(obj: unknown) => void;
+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 _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;
+    private _time30;
+    get time50(): number;
+    private _time60;
+    get time60(): number;
+    private _cusTime;
+    get cusTime(): number;
+    set cusTime(v: number);
+    private readonly _nXSpeed;
+    constructor(nXSpeed?: number);
+}
+export declare const wait: (ms: number, resolveValue?: any) => Promise<unknown>;
+export declare class AuthAPIError extends Error {
+    protected serverErrorStack: string | undefined;
+    protected serverErrorCode: string | undefined;
+    constructor(serverErrorMessage: string, serverErrorCode?: string, serverErrorStack?: string);
+}
+export declare class BunnyAPIError extends Error {
+    protected serverErrorStack: string | undefined;
+    protected serverErrorCode: string | undefined;
+    constructor(serverErrorMessage: string, serverErrorCode?: string, serverErrorStack?: string);
+}
+export declare class NomicsAPIError extends Error {
+    protected serverErrorStack: string | undefined;
+    protected serverErrorCode: string | undefined;
+    constructor(serverErrorMessage: string, serverErrorCode?: string, serverErrorStack?: string);
+}
+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;
+}
+type ToCase = 'camel' | 'snake' | 'pascal' | 'constant' | 'kebab' | 'lower' | 'title' | 'sentence' | 'path' | 'dot';
+export declare const deepKeysConvert: (obj: any, toType?: ToCase) => 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 {};

package/dist/types/utils.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeNode = void 0;
+const arr = ['1', 2, 4, 5, 6];
+const a = 2;
+class TreeNode {
+    constructor(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;
+    // }
+    addChildren(children) {
+        if (!this.children) {
+            this.children = [];
+        }
+        if (children instanceof Array) {
+            this.children = this.children.concat(children);
+        }
+        else {
+            this.children.push(children);
+        }
+    }
+    getHeight() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const beginRoot = this;
+        let maxDepth = 1;
+        if (beginRoot) {
+            const bfs = (node, level) => {
+                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;
+    }
+}
+exports.TreeNode = TreeNode;