@gabrielrufino/cube 1.0.1

package/build/Algorithms/index.d.ts

@@ -0,0 +1,3 @@
+export default class Algorithms {
+    static decimalToBinary(n: number): string;
+}

package/build/Algorithms/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var __1 = require("..");
+var Algorithms = /** @class */ (function () {
+    function Algorithms() {
+    }
+    Algorithms.decimalToBinary = function (n) {
+        var _a;
+        var stack = new __1.Stack();
+        while (n > 0) {
+            var rem = Math.floor(n % 2);
+            stack.push(rem);
+            n = Math.floor(n / 2);
+        }
+        var binary = '';
+        while (!stack.isEmpty) {
+            // eslint-disable-next-line no-unsafe-optional-chaining
+            binary += (_a = stack.pop()) === null || _a === void 0 ? void 0 : _a.toString();
+        }
+        return binary;
+    };
+    return Algorithms;
+}());
+exports.default = Algorithms;

package/build/Array/IArray.d.ts

@@ -0,0 +1,9 @@
+interface IArray<T> {
+    insertInLastPosition(_element: T): T;
+    insertInFirstPosition(_element: T): T;
+    insertInPosition(_position: number, _element: T): T;
+    removeFromLastPosition(): T | undefined;
+    removeFromFirstPosition(): T | undefined;
+    removeFromPosition(_position: number): T | undefined;
+}
+export default IArray;

package/build/Array/IArray.js

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

package/build/Array/index.d.ts

@@ -0,0 +1,12 @@
+import DataStructure from '../DataStructure';
+import IArray from './IArray';
+export default class Array<T = number> extends DataStructure<T> implements IArray<T> {
+    constructor(...inputs: T[]);
+    insertInLastPosition(element: T): T;
+    insertInFirstPosition(element: T): T;
+    insertInPosition(position: number, element: T): T;
+    removeFromLastPosition(): T | undefined;
+    removeFromFirstPosition(): T | undefined;
+    removeFromPosition(position: number): T | undefined;
+    private [Symbol.toPrimitive];
+}

package/build/Array/index.js

@@ -0,0 +1,79 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var DataStructure_1 = __importDefault(require("../DataStructure"));
+var Array = /** @class */ (function (_super) {
+    __extends(Array, _super);
+    function Array() {
+        var inputs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            inputs[_i] = arguments[_i];
+        }
+        return _super.call(this, inputs) || this;
+    }
+    Array.prototype.insertInLastPosition = function (element) {
+        this._data[this.size] = element;
+        return element;
+    };
+    Array.prototype.insertInFirstPosition = function (element) {
+        for (var i = this.size; i > 0; i--) {
+            this._data[i] = this._data[i - 1];
+        }
+        this._data[0] = element;
+        return element;
+    };
+    Array.prototype.insertInPosition = function (position, element) {
+        this._data.splice(position, 0, element);
+        return element;
+    };
+    Array.prototype.removeFromLastPosition = function () {
+        var element = this._data[this.size - 1];
+        var array = new Array();
+        for (var i = 0; i < this.size - 1; i++) {
+            array.insertInLastPosition(this._data[i]);
+        }
+        this._data = array.data;
+        return element;
+    };
+    Array.prototype.removeFromFirstPosition = function () {
+        var element = this._data[0];
+        var array = new Array();
+        for (var i = 0; i < this.size - 1; i++) {
+            array.insertInLastPosition(this._data[i + 1]);
+        }
+        this._data = array.data;
+        return element;
+    };
+    Array.prototype.removeFromPosition = function (position) {
+        var element = this._data.splice(position, 1)[0];
+        return element;
+    };
+    Array.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return this.data.join(', ');
+        }
+        if (type === 'number') {
+            return this.size;
+        }
+        return null;
+    };
+    return Array;
+}(DataStructure_1.default));
+exports.default = Array;

package/build/BinarySearchTree/BinarySearchTreeNode.d.ts

@@ -0,0 +1,7 @@
+export default class BinarySearchTreeNode<T> {
+    value: T;
+    left: BinarySearchTreeNode<T> | null;
+    right: BinarySearchTreeNode<T> | null;
+    constructor(value: T);
+    [Symbol.toPrimitive](type: string): string | number | null;
+}

package/build/BinarySearchTree/BinarySearchTreeNode.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var BinarySearchTreeNode = /** @class */ (function () {
+    function BinarySearchTreeNode(value) {
+        this.left = null;
+        this.right = null;
+        this.value = value;
+        this.left = null;
+        this.right = null;
+    }
+    BinarySearchTreeNode.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return "[".concat(this.left, "] <= (").concat(this.value, ") => [").concat(this.right, "]");
+        }
+        if (type === 'number') {
+            return 1 + (this.left ? 1 : 0) + (this.right ? 1 : 0);
+        }
+        return null;
+    };
+    return BinarySearchTreeNode;
+}());
+exports.default = BinarySearchTreeNode;

package/build/BinarySearchTree/IBinarySearchNodeOptions.d.ts

@@ -0,0 +1,5 @@
+interface IBinarySearchNodeOptions<T> {
+    inputs?: T[];
+    lessThanOrEqualTo?: (_value1: T, _value2: T) => boolean;
+}
+export default IBinarySearchNodeOptions;

package/build/BinarySearchTree/IBinarySearchNodeOptions.js

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

package/build/BinarySearchTree/IBinarySearchTree.d.ts

@@ -0,0 +1,14 @@
+import IBinarySearchTreeData from './IBinarySearchTreeData';
+interface IBinarySearchTree<T> {
+    get data(): IBinarySearchTreeData<T>;
+    get size(): number;
+    get min(): T | null;
+    get max(): T | null;
+    insert(_value: T): T;
+    walkInOrder(_callback: (_value: T) => any): void;
+    walkPreOrder(_callback: (_value: T) => any): void;
+    walkPostOrder(_callback: (_value: T) => any): void;
+    search(_value: T): boolean;
+    remove(_value: T): T | null;
+}
+export default IBinarySearchTree;

package/build/BinarySearchTree/IBinarySearchTree.js

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

package/build/BinarySearchTree/IBinarySearchTreeData.d.ts

@@ -0,0 +1,7 @@
+import BinarySearchTreeNode from './BinarySearchTreeNode';
+interface IBinarySearchTreeData<T> {
+    left: BinarySearchTreeNode<T> | null;
+    value: T | null;
+    right: BinarySearchTreeNode<T> | null;
+}
+export default IBinarySearchTreeData;

package/build/BinarySearchTree/IBinarySearchTreeData.js

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

package/build/BinarySearchTree/index.d.ts

@@ -0,0 +1,24 @@
+import IBinarySearchNodeOptions from './IBinarySearchNodeOptions';
+import IBinarySearchTree from './IBinarySearchTree';
+import IBinarySearchTreeData from './IBinarySearchTreeData';
+export default class BinarySearchTree<T = number> implements IBinarySearchTree<T> {
+    private _root;
+    private _size;
+    constructor({ inputs, lessThanOrEqualTo }?: IBinarySearchNodeOptions<T>);
+    get data(): IBinarySearchTreeData<T>;
+    get size(): number;
+    get min(): T | null;
+    get max(): T | null;
+    insert(value: T): T;
+    walkInOrder(callback: (_value: T) => any): void;
+    walkPreOrder(callback: (_value: T) => any): void;
+    walkPostOrder(callback: (_value: T) => any): void;
+    search(value: T): boolean;
+    remove(value: T): T | null;
+    private _lessThanOrEqualTo;
+    private _insertChild;
+    private _visitNodeInOrder;
+    private _visitNodePreOrder;
+    private _visitNodePostOrder;
+    private [Symbol.toPrimitive];
+}

package/build/BinarySearchTree/index.js

@@ -0,0 +1,199 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var BinarySearchTreeNode_1 = __importDefault(require("./BinarySearchTreeNode"));
+var BinarySearchTree = /** @class */ (function () {
+    function BinarySearchTree(_a) {
+        var _b = _a === void 0 ? { inputs: [] } : _a, _c = _b.inputs, inputs = _c === void 0 ? [] : _c, lessThanOrEqualTo = _b.lessThanOrEqualTo;
+        this._root = null;
+        this._size = 0;
+        if (lessThanOrEqualTo) {
+            this._lessThanOrEqualTo = lessThanOrEqualTo;
+        }
+        for (var _i = 0, inputs_1 = inputs; _i < inputs_1.length; _i++) {
+            var value = inputs_1[_i];
+            this.insert(value);
+        }
+        this._size = inputs.length;
+    }
+    Object.defineProperty(BinarySearchTree.prototype, "data", {
+        get: function () {
+            return this._root || {
+                left: null,
+                value: null,
+                right: null,
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinarySearchTree.prototype, "size", {
+        get: function () {
+            return this._size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinarySearchTree.prototype, "min", {
+        get: function () {
+            var current = this._root;
+            while (current && current.left) {
+                current = current.left;
+            }
+            return (current === null || current === void 0 ? void 0 : current.value) || null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinarySearchTree.prototype, "max", {
+        get: function () {
+            var current = this._root;
+            while (current && current.right) {
+                current = current.right;
+            }
+            return (current === null || current === void 0 ? void 0 : current.value) || null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BinarySearchTree.prototype.insert = function (value) {
+        var node = new BinarySearchTreeNode_1.default(value);
+        if (this._root) {
+            this._insertChild(this._root, node);
+        }
+        else {
+            this._root = node;
+        }
+        this._size += 1;
+        return value;
+    };
+    BinarySearchTree.prototype.walkInOrder = function (callback) {
+        this._visitNodeInOrder(this._root, callback);
+    };
+    BinarySearchTree.prototype.walkPreOrder = function (callback) {
+        this._visitNodePreOrder(this._root, callback);
+    };
+    BinarySearchTree.prototype.walkPostOrder = function (callback) {
+        this._visitNodePostOrder(this._root, callback);
+    };
+    BinarySearchTree.prototype.search = function (value) {
+        var current = this._root;
+        while (current && current.value !== value) {
+            if (this._lessThanOrEqualTo(value, current.value)) {
+                current = current.left;
+            }
+            else {
+                current = current.right;
+            }
+        }
+        return Boolean(current);
+    };
+    BinarySearchTree.prototype.remove = function (value) {
+        var current = this._root;
+        var path = [];
+        while (current && current.value !== value) {
+            if (this._lessThanOrEqualTo(value, current.value)) {
+                current = current.left;
+                path.push('left');
+            }
+            else {
+                current = current.right;
+                path.push('right');
+            }
+        }
+        var found = __assign({}, current);
+        var parent = path
+            .slice(0, path.length - 1)
+            .reduce(function (accumulator, current) { return accumulator && accumulator[current]; }, this._root);
+        var child = path[path.length - 1];
+        if ((current === null || current === void 0 ? void 0 : current.left) && (current === null || current === void 0 ? void 0 : current.right) && parent) {
+            var head = current.right;
+            while (head.left) {
+                head = head.left;
+            }
+            this.remove(head.value);
+            current.value = head.value;
+        }
+        else if ((current === null || current === void 0 ? void 0 : current.left) && parent) {
+            parent[child] = current.left;
+            this._size -= 1;
+        }
+        else if ((current === null || current === void 0 ? void 0 : current.right) && parent) {
+            parent[child] = current.right;
+            this._size -= 1;
+        }
+        else if (parent) {
+            parent[child] = null;
+            this._size -= 1;
+        }
+        return found.value || null;
+    };
+    BinarySearchTree.prototype._lessThanOrEqualTo = function (value1, value2) {
+        if (value1 <= value2) {
+            return true;
+        }
+        return false;
+    };
+    BinarySearchTree.prototype._insertChild = function (father, child) {
+        if (this._lessThanOrEqualTo(child.value, father.value)) {
+            if (father.left) {
+                this._insertChild(father.left, child);
+            }
+            else {
+                father.left = child;
+            }
+            return;
+        }
+        if (father.right) {
+            this._insertChild(father.right, child);
+        }
+        else {
+            father.right = child;
+        }
+    };
+    BinarySearchTree.prototype._visitNodeInOrder = function (node, callback) {
+        if (node) {
+            this._visitNodeInOrder(node.left, callback);
+            callback(node.value);
+            this._visitNodeInOrder(node.right, callback);
+        }
+    };
+    BinarySearchTree.prototype._visitNodePreOrder = function (node, callback) {
+        if (node) {
+            callback(node.value);
+            this._visitNodePreOrder(node.left, callback);
+            this._visitNodePreOrder(node.right, callback);
+        }
+    };
+    BinarySearchTree.prototype._visitNodePostOrder = function (node, callback) {
+        if (node) {
+            this._visitNodePostOrder(node.left, callback);
+            this._visitNodePostOrder(node.right, callback);
+            callback(node.value);
+        }
+    };
+    BinarySearchTree.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return "".concat(this._root);
+        }
+        if (type === 'number') {
+            return this.size;
+        }
+        return null;
+    };
+    return BinarySearchTree;
+}());
+exports.default = BinarySearchTree;

package/build/DataStructure/index.d.ts

@@ -0,0 +1,6 @@
+export default abstract class DataStructure<T> {
+    protected _data: T[];
+    constructor(inputs: T[]);
+    get data(): T[];
+    get size(): number;
+}

package/build/DataStructure/index.js

@@ -0,0 +1,32 @@
+"use strict";
+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 });
+var DataStructure = /** @class */ (function () {
+    function DataStructure(inputs) {
+        this._data = __spreadArray([], inputs, true);
+    }
+    Object.defineProperty(DataStructure.prototype, "data", {
+        get: function () {
+            return __spreadArray([], this._data, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataStructure.prototype, "size", {
+        get: function () {
+            return this._data.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return DataStructure;
+}());
+exports.default = DataStructure;

package/build/Deck/IDeck.d.ts

@@ -0,0 +1,9 @@
+interface IDeck<T> {
+    addFront(_element: T): T;
+    addBack(_element: T): T;
+    removeFront(): T | undefined;
+    removeBack(): T | undefined;
+    peekFront(): T | undefined;
+    peekBack(): T | undefined;
+}
+export default IDeck;

package/build/Deck/IDeck.js

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

package/build/Deck/index.d.ts

@@ -0,0 +1,12 @@
+import DataStructure from '../DataStructure';
+import IDeck from './IDeck';
+export default class Deck<T = number> extends DataStructure<T> implements IDeck<T> {
+    constructor(...inputs: T[]);
+    addFront(element: T): T;
+    addBack(element: T): T;
+    removeFront(): T | undefined;
+    removeBack(): T | undefined;
+    peekFront(): T | undefined;
+    peekBack(): T | undefined;
+    private [Symbol.toPrimitive];
+}

package/build/Deck/index.js

@@ -0,0 +1,76 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var DataStructure_1 = __importDefault(require("../DataStructure"));
+var Deck = /** @class */ (function (_super) {
+    __extends(Deck, _super);
+    function Deck() {
+        var inputs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            inputs[_i] = arguments[_i];
+        }
+        return _super.call(this, inputs) || this;
+    }
+    Deck.prototype.addFront = function (element) {
+        this._data = __spreadArray([element], this.data, true);
+        return element;
+    };
+    Deck.prototype.addBack = function (element) {
+        this._data = __spreadArray(__spreadArray([], this.data, true), [element], false);
+        return element;
+    };
+    Deck.prototype.removeFront = function () {
+        var _a = this.data, element = _a[0], rest = _a.slice(1);
+        this._data = rest;
+        return element;
+    };
+    Deck.prototype.removeBack = function () {
+        var element = this._data.pop();
+        return element;
+    };
+    Deck.prototype.peekFront = function () {
+        var element = this.data[0];
+        return element;
+    };
+    Deck.prototype.peekBack = function () {
+        var element = this.data[this.size - 1];
+        return element;
+    };
+    Deck.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return "[Front] ".concat(this.data.join(', '), " [Back]");
+        }
+        if (type === 'number') {
+            return this.size;
+        }
+        return null;
+    };
+    return Deck;
+}(DataStructure_1.default));
+exports.default = Deck;

package/build/Dictionary/IDictionary.d.ts

@@ -0,0 +1,16 @@
+import IDictionaryData from './IDictionaryData';
+interface IDictionary<T> {
+    get data(): IDictionaryData<T>;
+    get size(): number;
+    get isEmpty(): boolean;
+    get keys(): string[];
+    get values(): T[];
+    get pairs(): [string, T][];
+    set(_key: string, _value: T): [string, T];
+    remove(_key: string): [string, T] | null;
+    hasKey(_key: string): boolean;
+    get(_key: string): T | null;
+    clear(): IDictionaryData<T>;
+    forEach(_func: (_key: string, _value: T) => any): void;
+}
+export default IDictionary;

package/build/Dictionary/IDictionary.js

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

package/build/Dictionary/IDictionaryData.d.ts

@@ -0,0 +1,4 @@
+interface IDictionaryData<T> {
+    [key: string]: T;
+}
+export default IDictionaryData;

package/build/Dictionary/IDictionaryData.js

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

package/build/Dictionary/index.d.ts

@@ -0,0 +1,21 @@
+import IDictionary from './IDictionary';
+import IDictionaryData from './IDictionaryData';
+export default class Dictionary<T = number> implements IDictionary<T> {
+    private _data;
+    constructor(inputs?: {
+        [key: string]: T;
+    });
+    get data(): IDictionaryData<T>;
+    get size(): number;
+    get isEmpty(): boolean;
+    get keys(): string[];
+    get values(): T[];
+    get pairs(): [string, T][];
+    set(key: string, value: T): [string, T];
+    remove(key: string): [string, T] | null;
+    hasKey(key: string): boolean;
+    get(key: string): T | null;
+    clear(): IDictionaryData<T>;
+    forEach(func: (_key: string, _value: T) => any): void;
+    private [Symbol.toPrimitive];
+}