data-structure-typed 0.8.18 → 0.9.16

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

@@ -3,37 +3,46 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Queue = void 0;
 /**
  * @license MIT
- * @copyright 2020 Pablo
- *
+ * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-class Queue {
+var Queue = /** @class */ (function () {
     /**
      * Creates a queue.
      * @param {array} [elements]
      */
-    constructor(elements) {
+    function Queue(elements) {
         this._nodes = elements || [];
         this._offset = 0;
     }
+    /**
+     * Creates a queue from an existing array.
+     * @public
+     * @static
+     * @param {array} elements
+     * @return {Queue}
+     */
+    Queue.fromArray = function (elements) {
+        return new Queue(elements);
+    };
     /**
      * Adds an element at the back of the queue.
      * @public
      * @param {any} element
      */
-    offer(element) {
+    Queue.prototype.offer = function (element) {
         this._nodes.push(element);
         return this;
-    }
+    };
     /**
      * Dequeues the front element in the queue.
      * @public
      * @returns {any}
      */
-    poll() {
+    Queue.prototype.poll = function () {
         if (this.size() === 0)
             return null;
-        const first = this.peek();
+        var first = this.peek();
         this._offset += 1;
         if (this._offset * 2 < this._nodes.length)
             return first;
@@ -42,72 +51,63 @@ class Queue {
         this._nodes = this._nodes.slice(this._offset);
         this._offset = 0;
         return first;
-    }
+    };
     /**
      * Returns the front element of the queue.
      * @public
      * @returns {any}
      */
-    peek() {
+    Queue.prototype.peek = function () {
         return this.size() > 0 ? this._nodes[this._offset] : null;
-    }
+    };
     /**
      * Returns the back element of the queue.
      * @public
      * @returns {any}
      */
-    peekLast() {
+    Queue.prototype.peekLast = function () {
         return this.size() > 0 ? this._nodes[this._nodes.length - 1] : null;
-    }
+    };
     /**
      * Returns the number of elements in the queue.
      * @public
      * @returns {number}
      */
-    size() {
+    Queue.prototype.size = function () {
         return this._nodes.length - this._offset;
-    }
+    };
     /**
      * Checks if the queue is empty.
      * @public
      * @returns {boolean}
      */
-    isEmpty() {
+    Queue.prototype.isEmpty = function () {
         return this.size() === 0;
-    }
+    };
     /**
      * Returns the remaining elements in the queue as an array.
      * @public
      * @returns {array}
      */
-    toArray() {
+    Queue.prototype.toArray = function () {
         return this._nodes.slice(this._offset);
-    }
+    };
     /**
      * Clears the queue.
      * @public
      */
-    clear() {
+    Queue.prototype.clear = function () {
         this._nodes = [];
         this._offset = 0;
-    }
+    };
     /**
      * Creates a shallow copy of the queue.
      * @public
      * @return {Queue}
      */
-    clone() {
+    Queue.prototype.clone = function () {
         return new Queue(this._nodes.slice(this._offset));
-    }
-    /**
-     * Creates a queue from an existing array.
-     * @public
-     * @static
-     * @param {array} elements
-     * @return {Queue}
-     */
-    static fromArray(elements) {
-        return new Queue(elements);
-    }
-}
+    };
+    return Queue;
+}());
 exports.Queue = Queue;

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

@@ -1,7 +1,6 @@
 /**
  * @license MIT
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
- *
+ * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 export declare class Stack<T> {
@@ -11,6 +10,14 @@ export declare class Stack<T> {
      * @param {array} [elements]
      */
     constructor(elements?: T[]);
+    /**
+     * Creates a stack from an existing array
+     * @public
+     * @static
+     * @param {array} [elements]
+     * @return {Stack}
+     */
+    static fromArray<T>(elements: T[]): Stack<T>;
     /**
      * Checks if the stack is empty.
      * @public
@@ -58,12 +65,4 @@ export declare class Stack<T> {
      * @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/data-structures/stack/stack.js

@@ -3,95 +3,95 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stack = void 0;
 /**
  * @license MIT
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
- *
+ * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-class Stack {
+var Stack = /** @class */ (function () {
     /**
      * Creates a stack.
      * @param {array} [elements]
      */
-    constructor(elements) {
+    function Stack(elements) {
         this._elements = Array.isArray(elements) ? elements : [];
     }
+    /**
+     * Creates a stack from an existing array
+     * @public
+     * @static
+     * @param {array} [elements]
+     * @return {Stack}
+     */
+    Stack.fromArray = function (elements) {
+        return new Stack(elements);
+    };
     /**
      * Checks if the stack is empty.
      * @public
      * @returns {boolean}
      */
-    isEmpty() {
+    Stack.prototype.isEmpty = function () {
         return this._elements.length === 0;
-    }
+    };
     /**
      * Returns the number of elements in the stack.
      * @public
      * @returns {number}
      */
-    size() {
+    Stack.prototype.size = function () {
         return this._elements.length;
-    }
+    };
     /**
      * Returns the top element in the stack.
      * @public
      * @returns {object}
      */
-    peek() {
+    Stack.prototype.peek = function () {
         if (this.isEmpty())
             return null;
         return this._elements[this._elements.length - 1];
-    }
+    };
     /**
      * Adds an element to the top of the stack.
      * @public
      * @param {object} element
      */
-    push(element) {
+    Stack.prototype.push = function (element) {
         this._elements.push(element);
         return this;
-    }
+    };
     /**
      * Removes and returns the top element in the stack.
      * @public
      * @returns {object}
      */
-    pop() {
+    Stack.prototype.pop = function () {
         if (this.isEmpty())
             return null;
         return this._elements.pop() || null;
-    }
+    };
     /**
      * Returns the remaining elements as an array.
      * @public
      * @returns {array}
      */
-    toArray() {
+    Stack.prototype.toArray = function () {
         return this._elements.slice();
-    }
+    };
     /**
      * Clears all elements from the stack.
      * @public
      */
-    clear() {
+    Stack.prototype.clear = function () {
         this._elements = [];
-    }
+    };
     /**
      * Creates a shallow copy from the stack.
      * @public
      * @return {Stack}
      */
-    clone() {
+    Stack.prototype.clone = function () {
         return new Stack(this._elements.slice());
-    }
-    /**
-     * Creates a stack from an existing array
-     * @public
-     * @static
-     * @param {array} [elements]
-     * @return {Stack}
-     */
-    static fromArray(elements) {
-        return new Stack(elements);
-    }
-}
+    };
+    return Stack;
+}());
 exports.Stack = Stack;

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

@@ -1,25 +1,16 @@
-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 {
+export declare const isThunk: (fnOrValue: any) => boolean;
+type ToThunkFn = () => ReturnType<TrlFn>;
+type Thunk = () => ReturnType<ToThunkFn> & {
     __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>;
+};
+export declare const toThunk: (fn: ToThunkFn) => Thunk;
+type TrlFn = (...args: any[]) => any;
+export declare const trampoline: (fn: TrlFn) => ((...args: [...Parameters<TrlFn>]) => any) & {
+    cont: (...args: [...Parameters<TrlFn>]) => Thunk;
+};
+type TrlAsyncFn = (...args: any[]) => any;
+export declare const trampolineAsync: (fn: TrlAsyncFn) => ((...args: [...Parameters<TrlAsyncFn>]) => Promise<any>) & {
+    cont: (...args: [...Parameters<TrlAsyncFn>]) => Thunk;
+};
+export {};

package/dist/data-structures/trampoline.js

@@ -8,45 +8,123 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = void 0;
 exports.THUNK_SYMBOL = Symbol('thunk');
-const isThunk = (value) => {
-    return typeof value === 'function' && value.__THUNK__ === exports.THUNK_SYMBOL;
+var isThunk = function (fnOrValue) {
+    return typeof fnOrValue === 'function' && fnOrValue.__THUNK__ === exports.THUNK_SYMBOL;
 };
 exports.isThunk = isThunk;
-const toThunk = (fn) => {
-    const thunk = () => fn();
+var toThunk = function (fn) {
+    var thunk = function () { return fn(); };
     thunk.__THUNK__ = exports.THUNK_SYMBOL;
     return thunk;
 };
 exports.toThunk = toThunk;
-const trampoline = (fn) => {
-    const cont = (...args) => (0, exports.toThunk)(() => fn(...args));
-    return Object.assign((...args) => {
-        let result = fn(...args);
-        while ((0, exports.isThunk)(result)) {
+var trampoline = function (fn) {
+    var cont = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return (0, exports.toThunk)(function () { return fn.apply(void 0, __spreadArray([], __read(args), false)); });
+    };
+    return Object.assign(function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var result = fn.apply(void 0, __spreadArray([], __read(args), false));
+        while ((0, exports.isThunk)(result) && typeof result === 'function') {
             result = result();
         }
         return result;
-    }, { cont });
+    }, { cont: cont });
 };
 exports.trampoline = trampoline;
-const trampolineAsync = (fn) => {
-    const cont = (...args) => (0, exports.toThunk)(() => fn(...args));
-    return Object.assign((...args) => __awaiter(void 0, void 0, void 0, function* () {
-        let result = yield fn(...args);
-        while ((0, exports.isThunk)(result)) {
-            result = yield result();
+var trampolineAsync = function (fn) {
+    var cont = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
         }
-        return result;
-    }), { cont });
+        return (0, exports.toThunk)(function () { return fn.apply(void 0, __spreadArray([], __read(args), false)); });
+    };
+    return Object.assign(function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return __awaiter(void 0, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fn.apply(void 0, __spreadArray([], __read(args), false))];
+                    case 1:
+                        result = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (!((0, exports.isThunk)(result) && typeof result === 'function')) return [3 /*break*/, 4];
+                        return [4 /*yield*/, result()];
+                    case 3:
+                        result = _a.sent();
+                        return [3 /*break*/, 2];
+                    case 4: return [2 /*return*/, result];
+                }
+            });
+        });
+    }, { cont: cont });
 };
 exports.trampolineAsync = trampolineAsync;
-const factorial = (0, exports.trampoline)((n, acc = 1) => {
-    return n
-        // Note: calling factorial.cont instead of factorial directly
-        ? factorial.cont(n - 1, acc * n)
-        : acc;
-});
-// factorial(32768)

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

@@ -1,17 +1,21 @@
 export declare class TrieNode {
+    protected _value: string;
+    constructor(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[]);
     protected _root: TrieNode;
     get root(): TrieNode;
     set root(v: TrieNode);
-    constructor();
-    put(input: string): boolean;
+    put(word: string): boolean;
     has(input: string): boolean;
     remove(word: string): boolean;
     /**
@@ -20,9 +24,15 @@ export declare class Trie {
      */
     isAbsPrefix(input: string): boolean;
     /**
-     * Can present as a prefix or word
+     * Can present as a abs prefix or word
      * @param input
      */
     isPrefix(input: string): boolean;
+    /**
+     * Check if the input string is the common prefix of all the words
+     * @param input
+     */
+    isCommonPrefix(input: string): boolean;
+    getLongestCommonPrefix(): string;
     getAll(prefix?: string): string[];
 }