data-structure-typed 0.8.6

package/dist/utils.js

@@ -0,0 +1,569 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zip = exports.memo = exports.arrayRemove = exports.timeEnd = exports.timeStart = exports.bunnyConsole = exports.deepAdd = exports.deepReplaceValues = exports.deepRenameKeys = exports.deepRemoveByKey = exports.deepKeysConvert = exports.StringUtil = exports.diffAB = exports.onlyInB = exports.onlyInA = exports.comparerArray = exports.capitalizeFirstLetter = exports.capitalizeWords = exports.randomDate = exports.minuted = exports.keyValueToArray = exports.extractValue = exports.NomicsAPIError = exports.BunnyAPIError = exports.AuthAPIError = exports.wait = exports.WaitManager = exports.addDays = exports.isLeafParent = exports.isSameStructure = exports.reverseColor = exports.isTypeEqual = exports.deepObjectStrictEqual = exports.strictObjectIsEqual = exports.strictEqual = exports.looseEqual = exports.isObject = exports.getValue = exports.incrementId = exports.IncrementId = exports.uuidV4 = exports.randomText = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+function randomText(length) {
+    let result = '';
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+exports.randomText = randomText;
+const uuidV4 = function () {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+};
+exports.uuidV4 = uuidV4;
+class IncrementId {
+    constructor(prefix) {
+        this._prefix = prefix ? prefix : '';
+        this._id = this._prefix + '0';
+    }
+    getId() {
+        const { _id, _prefix } = this;
+        if (!_id) {
+            this._id = _prefix + '0';
+        }
+        else {
+            const idNumStr = _id.substr(_prefix.length, _id.length - _prefix.length);
+            const newIdNum = parseInt(idNumStr, 10) + 1;
+            this._id = _prefix + newIdNum.toString();
+        }
+        return this._id;
+    }
+}
+exports.IncrementId = IncrementId;
+function incrementId(prefix) {
+    const _prefix = prefix ? prefix : '';
+    let _id = _prefix + '0';
+    return function id() {
+        const idNumStr = _id.substr(_prefix.length, _id.length - _prefix.length);
+        const newIdNum = parseInt(idNumStr, 10) + 1;
+        _id = _prefix + newIdNum.toString();
+        return _id;
+    };
+}
+exports.incrementId = incrementId;
+const getValue = (obj, names) => {
+    return names.map(i => obj[i]);
+};
+exports.getValue = getValue;
+const isObject = (object) => {
+    return object != null && typeof object === 'object';
+};
+exports.isObject = isObject;
+const looseEqual = (a, b) => {
+    return a == b;
+};
+exports.looseEqual = looseEqual;
+const strictEqual = (a, b) => {
+    return a === b;
+};
+exports.strictEqual = strictEqual;
+const strictObjectIsEqual = (a, b) => {
+    return Object.is(a, b);
+};
+exports.strictObjectIsEqual = strictObjectIsEqual;
+const deepObjectStrictEqual = (object1, object2) => {
+    const keys1 = Object.keys(object1);
+    const keys2 = Object.keys(object2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        const val1 = object1[key];
+        const val2 = object2[key];
+        const areObjects = (0, exports.isObject)(val1) && (0, exports.isObject)(val2);
+        if (areObjects && !(0, exports.deepObjectStrictEqual)(val1, val2) ||
+            !areObjects && val1 !== val2) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.deepObjectStrictEqual = deepObjectStrictEqual;
+const isTypeEqual = (obj) => {
+    const m = obj;
+};
+exports.isTypeEqual = isTypeEqual;
+function reverseColor(oldColor) {
+    const oldColorTemp = '0x' + oldColor.replace(/#/g, '');
+    const str = '000000' + (0xFFFFFF - Number(oldColorTemp)).toString(16);
+    return '#' + str.substring(str.length - 6, str.length);
+}
+exports.reverseColor = reverseColor;
+const isSameStructure = (objA, objB) => {
+    const objATraversable = objA;
+    const objBTraversable = objB;
+    const objAKeys = Object.keys(objATraversable);
+    const objBKeys = Object.keys(objBTraversable);
+    let isSame = true;
+    if (objAKeys.length !== objBKeys.length) {
+        return isSame = false;
+    }
+    else {
+        objAKeys.forEach((i) => {
+            if (!objBKeys.includes(i)) {
+                return isSame = false;
+            }
+        });
+        return isSame;
+    }
+};
+exports.isSameStructure = isSameStructure;
+const isLeafParent = (obj) => {
+    let isLeaf = true;
+    Object.values(obj).forEach(value => {
+        if (typeof value === 'object' && value instanceof Array) {
+            value.forEach(item => {
+                if (typeof item === 'object') {
+                    return false;
+                }
+            });
+            return isLeaf = true;
+        }
+        if (!['string', 'boolean', 'number', 'undefined', 'function'].includes(typeof value) && (value !== null)) {
+            return isLeaf = false;
+        }
+    });
+    return isLeaf;
+};
+exports.isLeafParent = isLeafParent;
+const addDays = (date, days) => {
+    date.setDate(date.getDate() + days);
+    return date;
+};
+exports.addDays = addDays;
+class WaitManager {
+    get time1() {
+        return this._time1 / this._nXSpeed;
+    }
+    get time2() {
+        return this._time2 / this._nXSpeed;
+    }
+    get time3() {
+        return this._time3 / this._nXSpeed;
+    }
+    get time4() {
+        return this._time4 / this._nXSpeed;
+    }
+    get time10() {
+        return this._time10 / this._nXSpeed;
+    }
+    get time20() {
+        return this._time20 / this._nXSpeed;
+    }
+    get time50() {
+        return this._time30 / this._nXSpeed;
+    }
+    get time60() {
+        return this._time60 / this._nXSpeed;
+    }
+    get cusTime() {
+        return this._cusTime / this._nXSpeed;
+    }
+    set cusTime(v) {
+        this._cusTime = v;
+    }
+    constructor(nXSpeed) {
+        this._time1 = 1000;
+        this._time2 = 2000;
+        this._time3 = 3000;
+        this._time4 = 4000;
+        this._time10 = 10000;
+        this._time20 = 20000;
+        this._time30 = 20000;
+        this._time60 = 60000;
+        this._cusTime = 1000;
+        this._nXSpeed = 1;
+        if (nXSpeed === undefined)
+            nXSpeed = 1;
+        this._nXSpeed = nXSpeed;
+    }
+}
+exports.WaitManager = WaitManager;
+const wait = (ms, resolveValue) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => {
+            const finalResolveValue = resolveValue || true;
+            resolve(finalResolveValue);
+        }, ms);
+    });
+});
+exports.wait = wait;
+class AuthAPIError extends Error {
+    constructor(serverErrorMessage, serverErrorCode, serverErrorStack) {
+        super(serverErrorMessage);
+        if (serverErrorStack) {
+            this.serverErrorStack = serverErrorStack;
+        }
+        if (serverErrorCode) {
+            this.serverErrorCode = serverErrorCode;
+        }
+        this.name = new.target.name;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, new.target);
+        }
+        if (typeof Object.setPrototypeOf === 'function') {
+            Object.setPrototypeOf(this, new.target.prototype);
+        }
+        else {
+            this.__proto__ = new.target.prototype;
+        }
+    }
+}
+exports.AuthAPIError = AuthAPIError;
+class BunnyAPIError extends Error {
+    constructor(serverErrorMessage, serverErrorCode, serverErrorStack) {
+        super(serverErrorMessage);
+        if (serverErrorStack) {
+            this.serverErrorStack = serverErrorStack;
+        }
+        if (serverErrorCode) {
+            this.serverErrorCode = serverErrorCode;
+        }
+        this.name = new.target.name;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, new.target);
+        }
+        if (typeof Object.setPrototypeOf === 'function') {
+            Object.setPrototypeOf(this, new.target.prototype);
+        }
+        else {
+            this.__proto__ = new.target.prototype;
+        }
+    }
+}
+exports.BunnyAPIError = BunnyAPIError;
+class NomicsAPIError extends Error {
+    constructor(serverErrorMessage, serverErrorCode, serverErrorStack) {
+        super(serverErrorMessage);
+        if (serverErrorStack) {
+            this.serverErrorStack = serverErrorStack;
+        }
+        if (serverErrorCode) {
+            this.serverErrorCode = serverErrorCode;
+        }
+        this.name = new.target.name;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, new.target);
+        }
+        if (typeof Object.setPrototypeOf === 'function') {
+            Object.setPrototypeOf(this, new.target.prototype);
+        }
+        else {
+            this.__proto__ = new.target.prototype;
+        }
+    }
+}
+exports.NomicsAPIError = NomicsAPIError;
+function extractValue(data) {
+    let result = [];
+    if (data && data.length > 0) {
+        result = data.map(item => item.value);
+    }
+    return result;
+}
+exports.extractValue = extractValue;
+function keyValueToArray(data) {
+    const itemArray = [];
+    const keys = Object.keys(data);
+    for (const i of keys) {
+        itemArray.push(Object.assign(Object.assign({}, data[i]), { _id: i }));
+    }
+    return itemArray;
+}
+exports.keyValueToArray = keyValueToArray;
+function minuted(time) {
+    const minutes = Math.floor(time / 60000).toString();
+    const seconds = Math.floor((time % 60000) / 1000).toString().padStart(2, '0');
+    return `${minutes}:${seconds}`;
+}
+exports.minuted = minuted;
+function randomDate(start, end, specificProbabilityStart, specificProbability) {
+    if (!start)
+        start = new Date('1970-1-1');
+    if (!end)
+        end = new Date();
+    if (specificProbabilityStart) {
+        if (!specificProbability)
+            specificProbability = 0.5;
+        if (Math.random() <= specificProbability) {
+            return new Date(specificProbabilityStart.getTime() + Math.random() * (end.getTime() - specificProbabilityStart.getTime()));
+        }
+    }
+    return new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
+}
+exports.randomDate = randomDate;
+const capitalizeWords = (str) => {
+    return str.replace(/(?:^|\s)\S/g, (a) => a.toUpperCase());
+};
+exports.capitalizeWords = capitalizeWords;
+const capitalizeFirstLetter = (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+};
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+const comparerArray = (otherArray, limitKeys) => {
+    return function (current) {
+        return otherArray.filter(function (other) {
+            if (!limitKeys) {
+                return lodash_1.default.isEqual(current, other);
+            }
+            else {
+                // TODO
+            }
+        }).length == 0;
+    };
+};
+exports.comparerArray = comparerArray;
+const onlyInA = (a, b) => {
+    return a.filter((0, exports.comparerArray)(b));
+};
+exports.onlyInA = onlyInA;
+const onlyInB = (a, b) => {
+    return b.filter((0, exports.comparerArray)(a));
+};
+exports.onlyInB = onlyInB;
+const diffAB = (a, b) => {
+    return (0, exports.onlyInA)(a, b).concat((0, exports.onlyInB)(a, b));
+};
+exports.diffAB = diffAB;
+class StringUtil {
+    // camelCase
+    static toCamelCase(str) {
+        return lodash_1.default.camelCase(str);
+    }
+    // snake_case
+    static toSnakeCase(str) {
+        return lodash_1.default.snakeCase(str);
+    }
+    // PascalCase
+    static toPascalCase(str) {
+        return lodash_1.default.startCase(lodash_1.default.camelCase(str)).replace(/ /g, '');
+    }
+    // CONSTANT_CASE
+    static toConstantCase(str) {
+        return lodash_1.default.upperCase(str).replace(/ /g, '_');
+    }
+    // kebab-case
+    static toKebabCase(str) {
+        return lodash_1.default.kebabCase(str);
+    }
+    // lowercase
+    static toLowerCase(str) {
+        return lodash_1.default.lowerCase(str).replace(/ /g, '');
+    }
+    // Title Case
+    static toTitleCase(str) {
+        return lodash_1.default.startCase(lodash_1.default.camelCase(str));
+    }
+    // Sentence case
+    static toSentenceCase(str) {
+        return lodash_1.default.upperFirst(lodash_1.default.lowerCase(str));
+    }
+    // path/case
+    static toPathCase(str) {
+        return lodash_1.default.lowerCase(str).replace(/ /g, '/');
+    }
+    // dot.case
+    static toDotCase(str) {
+        return lodash_1.default.lowerCase(str).replace(/ /g, '.');
+    }
+}
+exports.StringUtil = StringUtil;
+const deepKeysConvert = (obj, toType) => {
+    const _toType = toType || 'snake';
+    if (Array.isArray(obj)) {
+        return obj.map(v => (0, exports.deepKeysConvert)(v, _toType));
+    }
+    else if (obj !== null && obj.constructor === Object) {
+        return Object.keys(obj).reduce((result, key) => {
+            let newKey = '';
+            switch (_toType) {
+                case 'camel':
+                    newKey = StringUtil.toCamelCase(key);
+                    break;
+                case 'snake':
+                    newKey = StringUtil.toSnakeCase(key);
+                    break;
+                case 'pascal':
+                    newKey = StringUtil.toPascalCase(key);
+                    break;
+                case 'constant':
+                    newKey = StringUtil.toConstantCase(key);
+                    break;
+                case 'kebab':
+                    newKey = StringUtil.toKebabCase(key);
+                    break;
+                case 'lower':
+                    newKey = StringUtil.toLowerCase(key);
+                    break;
+                case 'title':
+                    newKey = StringUtil.toTitleCase(key);
+                    break;
+                case 'sentence':
+                    newKey = StringUtil.toSentenceCase(key);
+                    break;
+                case 'path':
+                    newKey = StringUtil.toPathCase(key);
+                    break;
+                case 'dot':
+                    newKey = StringUtil.toDotCase(key);
+                    break;
+                default:
+                    newKey = StringUtil.toDotCase(key);
+                    break;
+            }
+            return Object.assign(Object.assign({}, result), { [newKey]: (0, exports.deepKeysConvert)(obj[key], _toType) });
+        }, {});
+    }
+    return obj;
+};
+exports.deepKeysConvert = deepKeysConvert;
+const deepRemoveByKey = (obj, keysToBeRemoved) => {
+    const result = lodash_1.default.transform(obj, function (result, value, key) {
+        if (lodash_1.default.isObject(value)) {
+            value = (0, exports.deepRemoveByKey)(value, keysToBeRemoved);
+        }
+        if (!keysToBeRemoved.includes(key)) {
+            lodash_1.default.isArray(obj) ? result.push(value) : result[key] = value;
+        }
+    });
+    return result;
+};
+exports.deepRemoveByKey = deepRemoveByKey;
+const deepRenameKeys = (obj, keysMap) => {
+    return lodash_1.default.transform(obj, function (result, value, key) {
+        const currentKey = keysMap[key] || key;
+        result[currentKey] = lodash_1.default.isObject(value) ? (0, exports.deepRenameKeys)(value, keysMap) : value;
+    });
+};
+exports.deepRenameKeys = deepRenameKeys;
+const deepReplaceValues = (obj, keyReducerMap) => {
+    const newObject = lodash_1.default.clone(obj);
+    lodash_1.default.each(obj, (val, key) => {
+        for (const item in keyReducerMap) {
+            if (key === item) {
+                newObject[key] = keyReducerMap[item](newObject);
+            }
+            else if (typeof (val) === 'object' || val instanceof Array) {
+                newObject[key] = (0, exports.deepReplaceValues)(val, keyReducerMap);
+            }
+        }
+    });
+    return newObject;
+};
+exports.deepReplaceValues = deepReplaceValues;
+// function getCallStackSize() {
+//     let count = 0, fn = arguments.callee;
+//     while ( (fn = fn.caller) ) {
+//         count++;
+//     }
+//     return count;
+// }
+// TODO determine depth and pass root node as a param through callback
+const deepAdd = (obj, keyReducerMap, isItemRootParent) => {
+    const newObject = lodash_1.default.clone(obj);
+    if (lodash_1.default.isObject(newObject) && !lodash_1.default.isArray(newObject)) {
+        for (const item in keyReducerMap) {
+            newObject[item] = keyReducerMap[item](newObject);
+        }
+    }
+    lodash_1.default.each(obj, (val, key) => {
+        if (lodash_1.default.isObject(val)) {
+            for (const item in keyReducerMap) {
+                // @ts-ignore
+                newObject[key] = (0, exports.deepAdd)(val, keyReducerMap, isItemRootParent);
+            }
+        }
+    });
+    return newObject;
+};
+exports.deepAdd = deepAdd;
+const styleString = (color) => `color: ${color}; font-weight: bold`;
+const styleHeader = (header) => `%c[${header}]`;
+exports.bunnyConsole = {
+    log: (headerLog = 'bunny', ...args) => {
+        return console.log(styleHeader(headerLog), styleString('black'), ...args);
+    },
+    warn: (headerLog = 'bunny', ...args) => {
+        return console.warn(styleHeader(headerLog), styleString('orange'), ...args);
+    },
+    error: (headerLog = 'bunny', ...args) => {
+        return console.error(styleHeader(headerLog), styleString('red'), ...args);
+    }
+};
+const timeStart = () => {
+    return performance ? performance.now() : new Date().getTime();
+};
+exports.timeStart = timeStart;
+const timeEnd = (startTime, headerLog, consoleConditionFn) => {
+    const timeSpent = (performance ? performance.now() : new Date().getTime()) - startTime;
+    const isPassCondition = consoleConditionFn ? consoleConditionFn(timeSpent) : true;
+    if (isPassCondition) {
+        exports.bunnyConsole.log(headerLog ? headerLog : 'time spent', timeSpent.toFixed(2));
+    }
+};
+exports.timeEnd = timeEnd;
+const arrayRemove = function (array, predicate) {
+    let i = -1, len = array ? array.length : 0;
+    const result = [];
+    while (++i < len) {
+        const value = array[i];
+        if (predicate(value, i, array)) {
+            result.push(value);
+            Array.prototype.splice.call(array, i--, 1);
+            len--;
+        }
+    }
+    return result;
+};
+exports.arrayRemove = arrayRemove;
+function memo() {
+    const cache = {};
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const cacheKey = `__cacheKey__${args.toString()}`;
+            // eslint-disable-next-line no-prototype-builtins
+            if (!cache.hasOwnProperty(cacheKey)) {
+                cache[cacheKey] = originalMethod.apply(this, args);
+            }
+            return cache[cacheKey];
+        };
+    };
+}
+exports.memo = memo;
+function zip(array1, array2, options) {
+    const zipped = [];
+    const zippedObjCoords = [];
+    const { isToObj } = options ? options : { isToObj: false };
+    for (let i = 0; i < array1.length; i++) {
+        if (isToObj) {
+            zippedObjCoords.push({ x: array1[i], y: array2[i] });
+        }
+        else {
+            zipped.push([array1[i], array2[i]]);
+        }
+    }
+    return isToObj ? zippedObjCoords : zipped;
+}
+exports.zip = zip;

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "data-structure-typed",
+  "version": "0.8.6",
+  "description": "Hash (CoordinateSet, CoordinateMap) Heap (MaxHeap, MinHeap) Binary Tree (AVL Tree, Binary Indexed Tree, Binary Search Tree, Segment Tree, Tree Multiset) Graph (Directed Graph, Undirected Graph) Linked List (Singly Linked List, Doubly Linked List) Matrix Priority Queue (Max Priority Queue, Min Priority Queue) Queue (Queue, Dequeue) Stack Trie",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zrwusa/data-structure-typed.git"
+  },
+  "keywords": [
+    "Hash",
+    "CoordinateSet",
+    "CoordinateMap",
+    "Heap",
+    "MaxHeap",
+    "MinHeap",
+    "Binary",
+    "Tree",
+    "AVL",
+    "Tree",
+    "Binary",
+    "Indexed",
+    "Tree",
+    "Binary",
+    "Search",
+    "Tree",
+    "Segment",
+    "Tree",
+    "Tree",
+    "Multiset",
+    "Graph",
+    "Directed",
+    "Graph",
+    "Undirected",
+    "Graph",
+    "Linked",
+    "List",
+    "Singly",
+    "Linked",
+    "List",
+    "Doubly",
+    "Linked",
+    "List",
+    "Matrix",
+    "Priority",
+    "Queue",
+    "Max",
+    "Priority",
+    "Queue",
+    "Min",
+    "Priority",
+    "Queue",
+    "Queue",
+    "Queue",
+    "Dequeue",
+    "Stack",
+    "Trie"
+  ],
+  "author": "Tyler Zeng",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/zrwusa/data-structure-ts/issues"
+  },
+  "homepage": "https://github.com/zrwusa/data-structure-ts#readme",
+  "devDependencies": {
+    "@types/lodash": "^4.14.178",
+    "typescript": "^4.6.2"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21"
+  }
+}

package/src/data-structures/binary-tree/aa-tree.ts

@@ -0,0 +1,3 @@
+export class AaTree {
+
+}