@gabrielrufino/cube 1.0.1

package/build/Graph/index.js

@@ -0,0 +1,187 @@
+"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 __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 GraphNodeNotFoundError_1 = __importDefault(require("./GraphNodeNotFoundError"));
+var GraphSearchNodeStates_1 = __importDefault(require("./GraphSearchNodeStates"));
+var Dictionary_1 = __importDefault(require("../Dictionary"));
+var Queue_1 = __importDefault(require("../Queue"));
+var Set_1 = __importDefault(require("../Set"));
+var Graph = /** @class */ (function () {
+    function Graph(_a) {
+        var _b = _a === void 0 ? { inputs: {}, isDirected: false } : _a, _c = _b.inputs, inputs = _c === void 0 ? {} : _c, _d = _b.isDirected, isDirected = _d === void 0 ? false : _d;
+        this._isDirected = isDirected;
+        this._data = new Dictionary_1.default();
+        var nodes = Object.keys(inputs);
+        for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+            var node = nodes_1[_i];
+            this.insert(node);
+        }
+        for (var _e = 0, nodes_2 = nodes; _e < nodes_2.length; _e++) {
+            var node = nodes_2[_e];
+            for (var _f = 0, _g = inputs[node]; _f < _g.length; _f++) {
+                var value = _g[_f];
+                this.connect(node, value);
+            }
+        }
+    }
+    Object.defineProperty(Graph.prototype, "isDirected", {
+        get: function () {
+            return this._isDirected;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Graph.prototype, "data", {
+        get: function () {
+            return Object.entries(this._data.data)
+                .reduce(function (accumulator, _a) {
+                var _b;
+                var key = _a[0], value = _a[1];
+                return (__assign(__assign({}, accumulator), (_b = {}, _b[key] = value.data, _b)));
+            }, {});
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Graph.prototype, "size", {
+        get: function () {
+            return this._data.size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Graph.prototype, "nodes", {
+        get: function () {
+            return __spreadArray([], this._data.keys, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Graph.prototype, "edges", {
+        get: function () {
+            if (this.isDirected) {
+                return Object.entries(this.data)
+                    .flatMap(function (_a) {
+                    var node = _a[0], links = _a[1];
+                    return links.map(function (link) { return [node, link]; });
+                });
+            }
+            return Object.entries(this.data)
+                .reduce(function (accumulator, _a) {
+                var node = _a[0], links = _a[1];
+                var edges = links
+                    .map(function (link) { return [node, link]; })
+                    .filter(function (edge) { return !accumulator.find(function (item) { return item.includes(edge[0]) && item.includes(edge[1]); }); });
+                return __spreadArray(__spreadArray([], accumulator, true), edges, true);
+            }, []);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Graph.prototype.insert = function (node) {
+        if (this._data.hasKey(node)) {
+            return null;
+        }
+        this._data.set(node, new Set_1.default());
+        return node;
+    };
+    Graph.prototype.connect = function (node1, node2) {
+        var _a, _b;
+        if (!this._data.hasKey(node1)) {
+            throw new GraphNodeNotFoundError_1.default(node1);
+        }
+        if (!this._data.hasKey(node2)) {
+            throw new GraphNodeNotFoundError_1.default(node2);
+        }
+        (_a = this._data.get(node1)) === null || _a === void 0 ? void 0 : _a.add(node2);
+        if (!this._isDirected) {
+            (_b = this._data.get(node2)) === null || _b === void 0 ? void 0 : _b.add(node1);
+        }
+        return [node1, node2];
+    };
+    Graph.prototype.breadthFirstSearch = function (startNode, callback) {
+        var _a;
+        if (!this._data.hasKey(startNode)) {
+            throw new GraphNodeNotFoundError_1.default(startNode);
+        }
+        var nodes = this.nodes;
+        var states = nodes.reduce(function (accumulator, node) {
+            var _a;
+            return (__assign(__assign({}, accumulator), (_a = {}, _a[node] = GraphSearchNodeStates_1.default.UNEXPLORED, _a)));
+        }, {});
+        var queue = new Queue_1.default();
+        queue.enqueue(startNode);
+        while (!queue.isEmpty) {
+            var current = queue.dequeue() || '';
+            if (current) {
+                states[current] = GraphSearchNodeStates_1.default.DISCOVERED;
+                var neighbors = ((_a = this._data.get(current)) === null || _a === void 0 ? void 0 : _a.data) || [];
+                var unexploredNeighbors = neighbors.filter(function (neighbor) { return states[neighbor] === GraphSearchNodeStates_1.default.UNEXPLORED; });
+                for (var _i = 0, unexploredNeighbors_1 = unexploredNeighbors; _i < unexploredNeighbors_1.length; _i++) {
+                    var neighbor = unexploredNeighbors_1[_i];
+                    states[neighbor] = GraphSearchNodeStates_1.default.DISCOVERED;
+                    queue.enqueue(neighbor);
+                }
+            }
+            states[current] = GraphSearchNodeStates_1.default.EXPLORED;
+            callback(current);
+        }
+    };
+    Graph.prototype.getDistancesFrom = function (node) {
+        var _a;
+        if (!this._data.hasKey(node)) {
+            throw new GraphNodeNotFoundError_1.default(node);
+        }
+        var nodes = this.nodes;
+        var states = nodes.reduce(function (accumulator, node) {
+            var _a;
+            return (__assign(__assign({}, accumulator), (_a = {}, _a[node] = GraphSearchNodeStates_1.default.UNEXPLORED, _a)));
+        }, {});
+        var distances = nodes.reduce(function (accumulator, node) {
+            var _a;
+            return (__assign(__assign({}, accumulator), (_a = {}, _a[node] = 0, _a)));
+        }, {});
+        var queue = new Queue_1.default();
+        queue.enqueue(node);
+        while (!queue.isEmpty) {
+            var current = queue.dequeue() || '';
+            if (current) {
+                states[current] = GraphSearchNodeStates_1.default.DISCOVERED;
+                var neighbors = ((_a = this._data.get(current)) === null || _a === void 0 ? void 0 : _a.data) || [];
+                var unexploredNeighbors = neighbors.filter(function (neighbor) { return states[neighbor] === GraphSearchNodeStates_1.default.UNEXPLORED; });
+                for (var _i = 0, unexploredNeighbors_2 = unexploredNeighbors; _i < unexploredNeighbors_2.length; _i++) {
+                    var neighbor = unexploredNeighbors_2[_i];
+                    states[neighbor] = GraphSearchNodeStates_1.default.DISCOVERED;
+                    distances[neighbor] = distances[current] + 1;
+                    queue.enqueue(neighbor);
+                }
+            }
+            states[current] = GraphSearchNodeStates_1.default.EXPLORED;
+        }
+        return distances;
+    };
+    return Graph;
+}());
+exports.default = Graph;

package/build/HashTable/IHashTable.d.ts

@@ -0,0 +1,9 @@
+import IHashTableData from './IHashTableData';
+interface IHashTable<T> {
+    get data(): IHashTableData<T>;
+    get size(): number;
+    put(_key: string, _value: T): T;
+    get(_key: string): T | null;
+    remove(_key: string): T | null;
+}
+export default IHashTable;

package/build/HashTable/IHashTable.js

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

package/build/HashTable/IHashTableData.d.ts

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

package/build/HashTable/IHashTableData.js

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

package/build/HashTable/IHashTableInputs.d.ts

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

package/build/HashTable/IHashTableInputs.js

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

package/build/HashTable/IHashTableOptions.d.ts

@@ -0,0 +1,4 @@
+interface IHashTableOptions {
+    maxSize?: number;
+}
+export default IHashTableOptions;

package/build/HashTable/IHashTableOptions.js

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

package/build/HashTable/index.d.ts

@@ -0,0 +1,16 @@
+import IHashTable from './IHashTable';
+import IHashTableData from './IHashTableData';
+import IHashTableInputs from './IHashTableInputs';
+import IHashTableOptions from './IHashTableOptions';
+export default class HashTable<T = number> implements IHashTable<T> {
+    private _maxSize;
+    private _data;
+    constructor(inputs?: IHashTableInputs<T>, { maxSize }?: IHashTableOptions);
+    get data(): IHashTableData<T>;
+    get size(): number;
+    put(key: string, value: T): T;
+    get(key: string): T | null;
+    remove(key: string): T | null;
+    private _hashCode;
+    private [Symbol.toPrimitive];
+}

package/build/HashTable/index.js

@@ -0,0 +1,83 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var HashTable = /** @class */ (function () {
+    function HashTable(inputs, _a) {
+        if (inputs === void 0) { inputs = {}; }
+        var _b = _a === void 0 ? { maxSize: 100 } : _a, _c = _b.maxSize, maxSize = _c === void 0 ? 100 : _c;
+        this._maxSize = maxSize;
+        this._data = new Array(this._maxSize);
+        for (var _i = 0, _d = Object.entries(inputs); _i < _d.length; _i++) {
+            var _e = _d[_i], key = _e[0], value = _e[1];
+            this.put(key, value);
+        }
+    }
+    Object.defineProperty(HashTable.prototype, "data", {
+        get: function () {
+            return this._data
+                .map(function (value, index) { return ({ index: index, value: value }); })
+                .reduce(function (accumulator, current) {
+                var _a;
+                return (__assign(__assign({}, accumulator), (_a = {}, _a[current.index] = current.value, _a)));
+            }, {});
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(HashTable.prototype, "size", {
+        get: function () {
+            return Reflect.ownKeys(this.data).length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HashTable.prototype.put = function (key, value) {
+        var position = this._hashCode(key);
+        this._data[position] = value;
+        return value;
+    };
+    HashTable.prototype.get = function (key) {
+        var position = this._hashCode(key);
+        return this.data[position] || null;
+    };
+    HashTable.prototype.remove = function (key) {
+        var value = this.get(key);
+        if (value) {
+            var position = this._hashCode(key);
+            Reflect.deleteProperty(this._data, position);
+            return value;
+        }
+        return null;
+    };
+    HashTable.prototype._hashCode = function (key) {
+        var code = key
+            .split('')
+            .map(function (character) { return character.charCodeAt(0); })
+            .reduce(function (previous, current) { return previous + current; }, 0);
+        return code % this._maxSize;
+    };
+    HashTable.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return "[ ".concat(Object.entries(this.data).map(function (_a) {
+                var key = _a[0], value = _a[1];
+                return "".concat(key, " => ").concat(value);
+            }).join(', '), " ]");
+        }
+        if (type === 'number') {
+            return this.size;
+        }
+        return null;
+    };
+    return HashTable;
+}());
+exports.default = HashTable;

package/build/HashTableLinearProbing/HashTableLinearProbingElement.d.ts

@@ -0,0 +1,6 @@
+export default class HashTableLinearProbingElement<T> {
+    key: string;
+    value: T;
+    constructor(key: string, value: T);
+    [Symbol.toPrimitive](type: 'string' | 'number'): string | number | null;
+}

package/build/HashTableLinearProbing/HashTableLinearProbingElement.js

@@ -0,0 +1,19 @@
+"use strict";
+/* eslint-disable no-unused-vars */
+/* eslint-disable no-useless-constructor */
+Object.defineProperty(exports, "__esModule", { value: true });
+var HashTableLinearProbingElement = /** @class */ (function () {
+    function HashTableLinearProbingElement(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+    HashTableLinearProbingElement.prototype[Symbol.toPrimitive] = function (type) {
+        var options = {
+            string: "{ ".concat(this.key, " => ").concat(this.value, " }"),
+            number: 2,
+        };
+        return options[type] || null;
+    };
+    return HashTableLinearProbingElement;
+}());
+exports.default = HashTableLinearProbingElement;

package/build/HashTableLinearProbing/IHashTableLinearProbing.d.ts

@@ -0,0 +1,9 @@
+import IHashTableLinearProbingData from './IHashTableLinearProbingData';
+interface IHashTableLinearProbing<T> {
+    get data(): IHashTableLinearProbingData<T>;
+    get size(): number;
+    put(_key: string, _value: T): T | null;
+    get(_key: string): T | null;
+    remove(_key: string): T | null;
+}
+export default IHashTableLinearProbing;

package/build/HashTableLinearProbing/IHashTableLinearProbing.js

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

package/build/HashTableLinearProbing/IHashTableLinearProbingData.d.ts

@@ -0,0 +1,5 @@
+import HashTableLinearProbingElement from './HashTableLinearProbingElement';
+interface IHashTableLinearProbingData<T> {
+    [index: number]: HashTableLinearProbingElement<T>;
+}
+export default IHashTableLinearProbingData;

package/build/HashTableLinearProbing/IHashTableLinearProbingData.js

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

package/build/HashTableLinearProbing/IHashTableLinearProbingInputs.d.ts

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

package/build/HashTableLinearProbing/IHashTableLinearProbingInputs.js

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

package/build/HashTableLinearProbing/IHashTableLinearProbingOptions.d.ts

@@ -0,0 +1,4 @@
+interface IHashTableLinearProbingOptions {
+    maxSize: number;
+}
+export default IHashTableLinearProbingOptions;

package/build/HashTableLinearProbing/IHashTableLinearProbingOptions.js

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

package/build/HashTableLinearProbing/index.d.ts

@@ -0,0 +1,20 @@
+import HashTableLinearProbingElement from './HashTableLinearProbingElement';
+import IHashTableLinearProbing from './IHashTableLinearProbing';
+import IHashTableLinearProbingInputs from './IHashTableLinearProbingInputs';
+import IHashTableLinearProbingOptions from './IHashTableLinearProbingOptions';
+export default class HashTableLinearProbing<T = number> implements IHashTableLinearProbing<T> {
+    private _maxSize;
+    private _data;
+    constructor(inputs?: IHashTableLinearProbingInputs<T>, { maxSize }?: IHashTableLinearProbingOptions);
+    get data(): {
+        [index: number]: HashTableLinearProbingElement<T>;
+    };
+    get size(): number;
+    put(key: string, value: T): T | null;
+    get(key: string): T | null;
+    remove(key: string): T | null;
+    private _hashCode;
+    private _nextPositionOf;
+    private _previousPositionOf;
+    private [Symbol.toPrimitive];
+}

package/build/HashTableLinearProbing/index.js

@@ -0,0 +1,120 @@
+"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 HashTableLinearProbingElement_1 = __importDefault(require("./HashTableLinearProbingElement"));
+var HashTableLinearProbing = /** @class */ (function () {
+    function HashTableLinearProbing(inputs, _a) {
+        if (inputs === void 0) { inputs = {}; }
+        var _b = _a === void 0 ? { maxSize: 100 } : _a, _c = _b.maxSize, maxSize = _c === void 0 ? 100 : _c;
+        this._maxSize = 0;
+        this._data = [];
+        this._maxSize = maxSize;
+        for (var _i = 0, _d = Object.entries(inputs); _i < _d.length; _i++) {
+            var _e = _d[_i], key = _e[0], value = _e[1];
+            this.put(key, value);
+        }
+    }
+    Object.defineProperty(HashTableLinearProbing.prototype, "data", {
+        get: function () {
+            return this._data
+                .map(function (value, index) { return ({ index: index, value: value }); })
+                .reduce(function (accumulator, current) {
+                var _a;
+                return (__assign(__assign({}, accumulator), (_a = {}, _a[current.index] = current.value, _a)));
+            }, {});
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(HashTableLinearProbing.prototype, "size", {
+        get: function () {
+            return Reflect.ownKeys(this.data).length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HashTableLinearProbing.prototype.put = function (key, value) {
+        if (this.size === this._maxSize) {
+            return null;
+        }
+        var element = new HashTableLinearProbingElement_1.default(key, value);
+        var position = this._hashCode(key);
+        if (this._data[position]) {
+            do {
+                position = this._nextPositionOf(position);
+            } while (this._data[position]);
+        }
+        this._data[position] = element;
+        return value;
+    };
+    HashTableLinearProbing.prototype.get = function (key) {
+        var _a;
+        var position = this._hashCode(key);
+        var i = position;
+        do {
+            if (((_a = this._data[i]) === null || _a === void 0 ? void 0 : _a.key) === key) {
+                return this._data[i].value;
+            }
+            i = this._nextPositionOf(i);
+        } while (this._data[i] && i !== position);
+        return null;
+    };
+    HashTableLinearProbing.prototype.remove = function (key) {
+        if (this.get(key)) {
+            var position = this._hashCode(key);
+            while (this._data[position].key !== key) {
+                position = this._nextPositionOf(position);
+            }
+            var value = this._data[position].value;
+            Reflect.deleteProperty(this._data, position);
+            var i = void 0;
+            for (i = position; this._data[this._nextPositionOf(i)]
+                && this._hashCode(this._data[this._nextPositionOf(i)].key) === this._hashCode(key)
+                && this._nextPositionOf(i) !== position; i = this._nextPositionOf(i)) {
+                this._data[i] = this._data[this._nextPositionOf(i)];
+            }
+            if (i !== position) {
+                Reflect.deleteProperty(this._data, i);
+            }
+            return value;
+        }
+        return null;
+    };
+    HashTableLinearProbing.prototype._hashCode = function (key) {
+        var code = key
+            .split('')
+            .map(function (character) { return character.charCodeAt(0); })
+            .reduce(function (previous, current) { return previous + current; }, 0);
+        return code % this._maxSize;
+    };
+    HashTableLinearProbing.prototype._nextPositionOf = function (position) {
+        return (position + 1) % this._maxSize;
+    };
+    HashTableLinearProbing.prototype._previousPositionOf = function (position) {
+        return (position + this.size - 1) % this._maxSize;
+    };
+    HashTableLinearProbing.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return "[ ".concat(Object.values(this.data).join(', '), " ]");
+        }
+        if (type === 'number') {
+            return this.size;
+        }
+        return null;
+    };
+    return HashTableLinearProbing;
+}());
+exports.default = HashTableLinearProbing;

package/build/HashTableSeparateChaining/HashTableSeparateChainingElement.d.ts

@@ -0,0 +1,6 @@
+export default class HashTableSeparateChainingElement<T> {
+    key: string;
+    value: T;
+    constructor(key: string, value: T);
+    private [Symbol.toPrimitive];
+}

package/build/HashTableSeparateChaining/HashTableSeparateChainingElement.js

@@ -0,0 +1,21 @@
+"use strict";
+/* eslint-disable no-useless-constructor */
+/* eslint-disable no-unused-vars */
+Object.defineProperty(exports, "__esModule", { value: true });
+var HashTableSeparateChainingElement = /** @class */ (function () {
+    function HashTableSeparateChainingElement(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+    HashTableSeparateChainingElement.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return "{ ".concat(this.key, " => ").concat(this.value, "}");
+        }
+        if (type === 'number') {
+            return 2;
+        }
+        return null;
+    };
+    return HashTableSeparateChainingElement;
+}());
+exports.default = HashTableSeparateChainingElement;

package/build/HashTableSeparateChaining/IHashTableSeparateChaining.d.ts

@@ -0,0 +1,10 @@
+import HashTableSeparateChainingElement from './HashTableSeparateChainingElement';
+import IHashTableSeparateChainingData from './IHashTableSeparateChainingData';
+interface IHashTableSeparateChaining<T> {
+    get data(): IHashTableSeparateChainingData<T>;
+    get size(): number;
+    put(_key: string, _value: T): T;
+    get(_key: string): HashTableSeparateChainingElement<T> | null;
+    remove(_key: string): HashTableSeparateChainingElement<T> | null;
+}
+export default IHashTableSeparateChaining;

package/build/HashTableSeparateChaining/IHashTableSeparateChaining.js

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

package/build/HashTableSeparateChaining/IHashTableSeparateChainingData.d.ts

@@ -0,0 +1,5 @@
+import LinkedList from '../LinkedList';
+interface IHashTableSeparateChainingData<T> {
+    [key: number]: LinkedList<T>;
+}
+export default IHashTableSeparateChainingData;

package/build/HashTableSeparateChaining/IHashTableSeparateChainingData.js

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

package/build/HashTableSeparateChaining/IHashTableSeparateChainingInputs.d.ts

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

package/build/HashTableSeparateChaining/IHashTableSeparateChainingInputs.js

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

package/build/HashTableSeparateChaining/IHashTableSeparateChainingOptions.d.ts

@@ -0,0 +1,4 @@
+interface IHashTableSeparateChainingOptions {
+    maxSize: number;
+}
+export default IHashTableSeparateChainingOptions;

package/build/HashTableSeparateChaining/IHashTableSeparateChainingOptions.js

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

package/build/HashTableSeparateChaining/index.d.ts

@@ -0,0 +1,19 @@
+import HashTableSeparateChainingElement from './HashTableSeparateChainingElement';
+import IHashTableSeparateChaining from './IHashTableSeparateChaining';
+import IHashTableSeparateChainingData from './IHashTableSeparateChainingData';
+import IHashTableSeparateChainingInputs from './IHashTableSeparateChainingInputs';
+export default class HashTableSeparateChaining<T = number> implements IHashTableSeparateChaining<T> {
+    private _maxSize;
+    private _data;
+    constructor(inputs?: IHashTableSeparateChainingInputs<T>, { maxSize }?: {
+        maxSize: number;
+    });
+    get data(): IHashTableSeparateChainingData<T>;
+    get size(): number;
+    put(key: string, value: T): T;
+    get(key: string): HashTableSeparateChainingElement<T> | null;
+    remove(key: string): HashTableSeparateChainingElement<T> | null;
+    private _getLinkedListByKey;
+    private _hashCode;
+    private [Symbol.toPrimitive];
+}