@raikuxq/alg-ds 1.1.7 → 1.2.2

package/lib/app/data-structures/LinkedList/AbstractLinkedList/AbstractLinkedList.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ValueOutOfRangeException_1 = require("../../../exceptions/ValueOutOfRangeException");
+var CollectionIsFullException_1 = require("../../../exceptions/CollectionIsFullException");
+var CollectionIsEmptyException_1 = require("../../../exceptions/CollectionIsEmptyException");
+var IndexOutOfBoundsException_1 = require("../../../exceptions/IndexOutOfBoundsException");
+var AbstractLinkedList = /** @class */ (function () {
+    /**
+     * Create empty instance
+     */
+    function AbstractLinkedList(capacity) {
+        this._capacity = AbstractLinkedList.calculateCapacity(capacity);
+        this._head = null;
+        this._tail = null;
+        this._length = 0;
+    }
+    /**
+     * Will calculate real capacity value
+     * @throws {ValueOutOfRangeException} when capacity is out of range
+     */
+    AbstractLinkedList.calculateCapacity = function (capacity) {
+        if (capacity === undefined) {
+            return Number.MAX_VALUE;
+        }
+        if (capacity <= 0) {
+            throw new ValueOutOfRangeException_1.default("Capacity must be larger than 0");
+        }
+        return capacity;
+    };
+    /**
+     * Will insert node between nodeLeft and nodeRight
+     * @throws {CollectionIsFullException} when list is full
+     */
+    AbstractLinkedList.prototype.insertNodeBetweenTwoNodes = function (targetNode, leftNode, rightNode) {
+        if (this.isFull()) {
+            throw new CollectionIsFullException_1.default("List is full, no more space available");
+        }
+        if (this._head === null) {
+            this._head = targetNode;
+        }
+        if (this._tail === null) {
+            this._tail = targetNode;
+        }
+        if (!leftNode) {
+            leftNode = this._tail;
+        }
+        if (!rightNode) {
+            rightNode = this._head;
+        }
+        this.insertNodeBetweenTwoNodesImpl(targetNode, leftNode, rightNode);
+        this._length++;
+    };
+    /**
+     * Will remove the node from its neighbors nodes links
+     * @throws {CollectionIsEmptyException} when list is empty
+     */
+    AbstractLinkedList.prototype.deleteNode = function (node) {
+        if (this.isEmpty()) {
+            throw new CollectionIsEmptyException_1.default("cannot delete because list is empty");
+        }
+        this.deleteNodeImpl(node);
+        this._length--;
+        if (this.isEmpty()) {
+            this.clear();
+        }
+        return node;
+    };
+    /**
+     * Will find node by its index
+     * @throws {CollectionIsEmptyException} when list is empty
+     * @throws {IndexOutOfBoundsException} when given index is out of range
+     */
+    AbstractLinkedList.prototype.getNodeByIndex = function (index) {
+        var isIndexNotInRange = index < 0 || index > this._length;
+        if (this.isEmpty()) {
+            throw new CollectionIsEmptyException_1.default("List is empty");
+        }
+        if (isIndexNotInRange) {
+            throw new IndexOutOfBoundsException_1.default("Index exceed list length");
+        }
+        var currentNode = this._tail;
+        var counter = 0;
+        while (currentNode && counter < index) {
+            currentNode = currentNode.next;
+            counter++;
+        }
+        return currentNode;
+    };
+    /**
+     * Push into start
+     * @throws {CollectionIsFullException} when there is no space available
+     */
+    AbstractLinkedList.prototype.unshift = function (value) {
+        var node = this.createNode(value);
+        this.insertNodeBetweenTwoNodes(node, this._head, this._tail);
+        this._tail = node;
+    };
+    /**
+     * Push into end
+     * @throws {CollectionIsFullException} when there is no space available
+     */
+    AbstractLinkedList.prototype.push = function (value) {
+        var node = this.createNode(value);
+        this.insertNodeBetweenTwoNodes(node, this._head, this._tail);
+        this._head = node;
+    };
+    /**
+     * Push from index
+     * @throws {IndexOutOfBoundsException} when given index is out of range
+     * @throws {CollectionIsFullException} when there is no space available
+     */
+    AbstractLinkedList.prototype.pushFromIndex = function (value, fromIndex) {
+        var isIndexNotInRange = fromIndex < 0 || fromIndex > this._length;
+        var shouldPushAsFirst = this.isEmpty() && fromIndex === 0;
+        if (isIndexNotInRange) {
+            throw new IndexOutOfBoundsException_1.default("index must be in range between 0 and list length");
+        }
+        if (shouldPushAsFirst) {
+            this.push(value);
+        }
+        else {
+            var node = this.createNode(value);
+            var nodeLeft = this.getNodeByIndex(fromIndex - 1);
+            var nodeRight = this.getNodeByIndex(fromIndex);
+            this.insertNodeBetweenTwoNodes(node, nodeLeft, nodeRight);
+        }
+    };
+    /**
+     * Delete node from list's end
+     * @throws {CollectionIsEmptyException} when list is empty
+     */
+    AbstractLinkedList.prototype.pop = function () {
+        var deletedNode = this.deleteNode(this._head);
+        this.popImpl();
+        return deletedNode.data;
+    };
+    /**
+     * Delete node from list's start and get its data
+     * @throws {CollectionIsEmptyException} when list is empty
+     */
+    AbstractLinkedList.prototype.shift = function () {
+        var deletedNode = this.deleteNode(this._tail);
+        this.shiftImpl();
+        return deletedNode.data;
+    };
+    /**
+     * Delete node from list by index from start
+     * @throws {CollectionIsEmptyException} when list is empty
+     */
+    AbstractLinkedList.prototype.deleteFromIndex = function (fromIndex) {
+        var nodeToDelete = this.getNodeByIndex(fromIndex);
+        var deletedNode = this.deleteNode(nodeToDelete);
+        return deletedNode.data;
+    };
+    /**
+     * List length
+     */
+    AbstractLinkedList.prototype.length = function () {
+        return this._length;
+    };
+    /**
+     * Is list empty
+     */
+    AbstractLinkedList.prototype.isEmpty = function () {
+        return this._length === 0 || this._head === null || this._tail === null;
+    };
+    /**
+     * Is list full
+     */
+    AbstractLinkedList.prototype.isFull = function () {
+        return this._length >= this._capacity;
+    };
+    /**
+     * Check if element exists in list
+     */
+    AbstractLinkedList.prototype.has = function (item) {
+        return this.getAsArray().includes(item);
+    };
+    /**
+     * Get head element data
+     * @throws {CollectionIsEmptyException} when head does not exist
+     */
+    AbstractLinkedList.prototype.peek = function () {
+        if (this.isEmpty() || !this._head) {
+            throw new CollectionIsEmptyException_1.default("head does not exist");
+        }
+        return this._head.data;
+    };
+    /**
+     * Get tail element data
+     * @throws {CollectionIsEmptyException} when tail does not exists
+     */
+    AbstractLinkedList.prototype.peekFromStart = function () {
+        if (this.isEmpty() || !this._tail) {
+            throw new CollectionIsEmptyException_1.default("tail does not exist");
+        }
+        return this._tail.data;
+    };
+    /**
+     * Get list element by index from start
+     * @throws {CollectionIsEmptyException} when list is empty
+     * @throws {IndexOutOfBoundsException} when given index is out of range
+     */
+    AbstractLinkedList.prototype.peekByIndex = function (index) {
+        var node = this.getNodeByIndex(index);
+        return node.data;
+    };
+    /**
+     * Remove all elements from list
+     */
+    AbstractLinkedList.prototype.clear = function () {
+        this._head = null;
+        this._tail = null;
+        this._length = 0;
+    };
+    /**
+     * Get elements as an array
+     */
+    AbstractLinkedList.prototype.getAsArray = function () {
+        var array = [];
+        var currentNode = this._tail;
+        var counter = 0;
+        while (currentNode && counter < this._length) {
+            if (currentNode)
+                array.push(currentNode.data);
+            currentNode = currentNode.next;
+            counter++;
+        }
+        return array;
+    };
+    /**
+     * Add elements to list from array
+     * @throws {CollectionIsFullException} when list is full
+     * */
+    AbstractLinkedList.prototype.pushFromArray = function (elements) {
+        var _this = this;
+        elements.forEach(function (element) {
+            if (_this.isFull()) {
+                throw new CollectionIsFullException_1.default("List is full, no more space available");
+            }
+            _this.push(element);
+        });
+    };
+    return AbstractLinkedList;
+}());
+exports.default = AbstractLinkedList;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{data-structures → app/data-structures}/LinkedList/AbstractLinkedList/AbstractLinkedNode.js

@@ -38,4 +38,4 @@ var AbstractLinkedNode = /** @class */ (function () {
     return AbstractLinkedNode;
 }());
 exports.default = AbstractLinkedNode;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJzdHJhY3RMaW5rZWROb2RlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RhdGEtc3RydWN0dXJlcy9MaW5rZWRMaXN0L0Fic3RyYWN0TGlua2VkTGlzdC9BYnN0cmFjdExpbmtlZE5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQTtJQUlFOztPQUVHO0lBQ0gsNEJBQXNCLElBQU8sRUFBRSxJQUF5QztRQUF6QyxxQkFBQSxFQUFBLFdBQXlDO1FBQ3RFLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDO1FBQ2xCLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDO0lBQ3BCLENBQUM7SUFLRCxzQkFBVyxvQ0FBSTtRQUhmOztXQUVHO2FBQ0g7WUFDRSxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUM7UUFDcEIsQ0FBQzs7O09BQUE7SUFLRCxzQkFBVyxvQ0FBSTtRQUhmOztXQUVHO2FBQ0g7WUFDRSxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUM7UUFDcEIsQ0FBQztRQUVEOztXQUVHO2FBQ0gsVUFBZ0IsS0FBbUM7WUFDakQsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDckIsQ0FBQzs7O09BUEE7SUFRSCx5QkFBQztBQUFELENBQUMsQUFoQ0QsSUFnQ0MifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJzdHJhY3RMaW5rZWROb2RlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9kYXRhLXN0cnVjdHVyZXMvTGlua2VkTGlzdC9BYnN0cmFjdExpbmtlZExpc3QvQWJzdHJhY3RMaW5rZWROb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUE7SUFJRTs7T0FFRztJQUNILDRCQUFzQixJQUFPLEVBQUUsSUFBeUM7UUFBekMscUJBQUEsRUFBQSxXQUF5QztRQUN0RSxJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQztRQUNsQixJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQztJQUNwQixDQUFDO0lBS0Qsc0JBQVcsb0NBQUk7UUFIZjs7V0FFRzthQUNIO1lBQ0UsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO1FBQ3BCLENBQUM7OztPQUFBO0lBS0Qsc0JBQVcsb0NBQUk7UUFIZjs7V0FFRzthQUNIO1lBQ0UsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO1FBQ3BCLENBQUM7UUFFRDs7V0FFRzthQUNILFVBQWdCLEtBQW1DO1lBQ2pELElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLENBQUM7OztPQVBBO0lBUUgseUJBQUM7QUFBRCxDQUFDLEFBaENELElBZ0NDIn0=

package/lib/{data-structures → app/data-structures}/LinkedList/DoubleLinkedList/DoubleLinkedList.d.ts

@@ -43,6 +43,8 @@ export default class DoubleLinkedList<T> extends AbstractLinkedList<T> implement
     reverse(): void;
     /**
      * List iterator
+     * @throws {CollectionIsEmptyException} when list is empty
+     * @throws {IndexOutOfBoundsException} when given index is out of range
      */
     iterator(fromIndex?: number): IBiDirectIterator<T>;
 }

package/lib/{data-structures → app/data-structures}/LinkedList/DoubleLinkedList/DoubleLinkedList.js

@@ -95,6 +95,8 @@ var DoubleLinkedList = /** @class */ (function (_super) {
     };
     /**
      * List iterator
+     * @throws {CollectionIsEmptyException} when list is empty
+     * @throws {IndexOutOfBoundsException} when given index is out of range
      */
     DoubleLinkedList.prototype.iterator = function (fromIndex) {
         if (fromIndex === void 0) { fromIndex = 0; }
@@ -122,7 +124,7 @@ var DoubleLinkedList = /** @class */ (function (_super) {
             },
             /**
              * @inheritDoc
-             * @throws when next element does not exist
+             * @throws {IsNotFoundException} when next element does not exist
              */
             next: function () {
                 if (!iterator.hasNext()) {
@@ -133,7 +135,7 @@ var DoubleLinkedList = /** @class */ (function (_super) {
             },
             /**
              * @inheritDoc
-             * @throws when prev element does not exists
+             * @throws {IsNotFoundException} when prev element does not exists
              */
             prev: function () {
                 if (!iterator.hasPrev()) {
@@ -148,4 +150,4 @@ var DoubleLinkedList = /** @class */ (function (_super) {
     return DoubleLinkedList;
 }(AbstractLinkedList_1.default));
 exports.default = DoubleLinkedList;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{data-structures → app/data-structures}/LinkedList/DoubleLinkedList/DoubleLinkedNode.js

@@ -62,4 +62,4 @@ var DoubleLinkedNode = /** @class */ (function (_super) {
     return DoubleLinkedNode;
 }(AbstractLinkedNode_1.default));
 exports.default = DoubleLinkedNode;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRG91YmxlTGlua2VkTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRhLXN0cnVjdHVyZXMvTGlua2VkTGlzdC9Eb3VibGVMaW5rZWRMaXN0L0RvdWJsZUxpbmtlZE5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsK0VBQTBFO0FBRTFFO0lBQWlELG9DQUFxQjtJQUlwRTs7T0FFRztJQUNILDBCQUNFLElBQU8sRUFDUCxJQUF1QyxFQUN2QyxJQUF1QztRQUR2QyxxQkFBQSxFQUFBLFdBQXVDO1FBQ3ZDLHFCQUFBLEVBQUEsV0FBdUM7UUFIekMsWUFLRSxrQkFBTSxJQUFJLENBQUMsU0FHWjtRQUZDLEtBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDO1FBQ2xCLEtBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDOztJQUNwQixDQUFDO0lBS0Qsc0JBQVcsa0NBQUk7UUFJZjs7V0FFRzthQUNIO1lBQ0UsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO1FBQ3BCLENBQUM7UUFaRDs7V0FFRzthQUNILFVBQWdCLEtBQWlDO1lBQy9DLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLENBQUM7OztPQUFBO0lBWUQsc0JBQVcsa0NBQUk7UUFJZjs7V0FFRzthQUNIO1lBQ0UsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO1FBQ3BCLENBQUM7UUFaRDs7V0FFRzthQUNILFVBQWdCLEtBQWlDO1lBQy9DLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLENBQUM7OztPQUFBO0lBUUgsdUJBQUM7QUFBRCxDQUFDLEFBNUNELENBQWlELDRCQUFrQixHQTRDbEUifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRG91YmxlTGlua2VkTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvZGF0YS1zdHJ1Y3R1cmVzL0xpbmtlZExpc3QvRG91YmxlTGlua2VkTGlzdC9Eb3VibGVMaW5rZWROb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtFQUEwRTtBQUUxRTtJQUFpRCxvQ0FBcUI7SUFJcEU7O09BRUc7SUFDSCwwQkFDRSxJQUFPLEVBQ1AsSUFBdUMsRUFDdkMsSUFBdUM7UUFEdkMscUJBQUEsRUFBQSxXQUF1QztRQUN2QyxxQkFBQSxFQUFBLFdBQXVDO1FBSHpDLFlBS0Usa0JBQU0sSUFBSSxDQUFDLFNBR1o7UUFGQyxLQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQztRQUNsQixLQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQzs7SUFDcEIsQ0FBQztJQUtELHNCQUFXLGtDQUFJO1FBSWY7O1dBRUc7YUFDSDtZQUNFLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztRQUNwQixDQUFDO1FBWkQ7O1dBRUc7YUFDSCxVQUFnQixLQUFpQztZQUMvQyxJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNyQixDQUFDOzs7T0FBQTtJQVlELHNCQUFXLGtDQUFJO1FBSWY7O1dBRUc7YUFDSDtZQUNFLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztRQUNwQixDQUFDO1FBWkQ7O1dBRUc7YUFDSCxVQUFnQixLQUFpQztZQUMvQyxJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNyQixDQUFDOzs7T0FBQTtJQVFILHVCQUFDO0FBQUQsQ0FBQyxBQTVDRCxDQUFpRCw0QkFBa0IsR0E0Q2xFIn0=

package/lib/{data-structures → app/data-structures}/LinkedList/SingleLinkedList/SingleLinkedList.d.ts

@@ -47,6 +47,8 @@ export default class SingleLinkedList<T> extends AbstractLinkedList<T> implement
     reverse(): void;
     /**
      * List iterator
+     * @throws {CollectionIsEmptyException} when list is empty
+     * @throws {IndexOutOfBoundsException} when given index is out of range
      */
     iterator(fromIndex?: number): IIterator<T>;
 }

package/lib/{data-structures → app/data-structures}/LinkedList/SingleLinkedList/SingleLinkedList.js

@@ -100,6 +100,8 @@ var SingleLinkedList = /** @class */ (function (_super) {
     };
     /**
      * List iterator
+     * @throws {CollectionIsEmptyException} when list is empty
+     * @throws {IndexOutOfBoundsException} when given index is out of range
      */
     SingleLinkedList.prototype.iterator = function (fromIndex) {
         if (fromIndex === void 0) { fromIndex = 0; }
@@ -120,7 +122,7 @@ var SingleLinkedList = /** @class */ (function (_super) {
             },
             /**
              * @inheritDoc
-             * @throws when next element does not exist
+             * @throws {IsNotFoundException} when next element does not exist
              */
             next: function () {
                 if (!iterator.hasNext()) {
@@ -135,4 +137,4 @@ var SingleLinkedList = /** @class */ (function (_super) {
     return SingleLinkedList;
 }(AbstractLinkedList_1.default));
 exports.default = SingleLinkedList;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{data-structures → app/data-structures}/LinkedList/SingleLinkedList/SingleLinkedNode.js

@@ -26,4 +26,4 @@ var SingleLinkedNode = /** @class */ (function (_super) {
     return SingleLinkedNode;
 }(AbstractLinkedNode_1.default));
 exports.default = SingleLinkedNode;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2luZ2xlTGlua2VkTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRhLXN0cnVjdHVyZXMvTGlua2VkTGlzdC9TaW5nbGVMaW5rZWRMaXN0L1NpbmdsZUxpbmtlZE5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsK0VBQTBFO0FBRTFFO0lBQWlELG9DQUFxQjtJQUNwRTs7T0FFRztJQUNILDBCQUFtQixJQUFPLEVBQUUsSUFBdUM7UUFBdkMscUJBQUEsRUFBQSxXQUF1QztlQUNqRSxrQkFBTSxJQUFJLEVBQUUsSUFBSSxDQUFDO0lBQ25CLENBQUM7SUFDSCx1QkFBQztBQUFELENBQUMsQUFQRCxDQUFpRCw0QkFBa0IsR0FPbEUifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2luZ2xlTGlua2VkTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvZGF0YS1zdHJ1Y3R1cmVzL0xpbmtlZExpc3QvU2luZ2xlTGlua2VkTGlzdC9TaW5nbGVMaW5rZWROb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtFQUEwRTtBQUUxRTtJQUFpRCxvQ0FBcUI7SUFDcEU7O09BRUc7SUFDSCwwQkFBbUIsSUFBTyxFQUFFLElBQXVDO1FBQXZDLHFCQUFBLEVBQUEsV0FBdUM7ZUFDakUsa0JBQU0sSUFBSSxFQUFFLElBQUksQ0FBQztJQUNuQixDQUFDO0lBQ0gsdUJBQUM7QUFBRCxDQUFDLEFBUEQsQ0FBaUQsNEJBQWtCLEdBT2xFIn0=

package/lib/app/data-structures/LinkedList/_helpers/createLinkedList.d.ts

@@ -0,0 +1,3 @@
+import { EnumLinkedListType } from "../../../types/EnumLinkedListType";
+import ILinkedList from "../../../types/ILinkedList";
+export declare const createLinkedList: <T>(type: EnumLinkedListType, capacity?: number | undefined) => ILinkedList<T>;

package/lib/app/data-structures/LinkedList/_helpers/createLinkedList.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLinkedList = void 0;
+var EnumLinkedListType_1 = require("../../../types/EnumLinkedListType");
+var DoubleLinkedList_1 = require("../DoubleLinkedList/DoubleLinkedList");
+var SingleLinkedList_1 = require("../SingleLinkedList/SingleLinkedList");
+exports.createLinkedList = function (type, capacity) {
+    var linkedList;
+    switch (type) {
+        case EnumLinkedListType_1.EnumLinkedListType.DOUBLE:
+            linkedList = new DoubleLinkedList_1.default(capacity);
+            break;
+        case EnumLinkedListType_1.EnumLinkedListType.SINGLE:
+            linkedList = new SingleLinkedList_1.default(capacity);
+            break;
+    }
+    return linkedList;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlTGlua2VkTGlzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvZGF0YS1zdHJ1Y3R1cmVzL0xpbmtlZExpc3QvX2hlbHBlcnMvY3JlYXRlTGlua2VkTGlzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx3RUFBdUU7QUFDdkUseUVBQW9FO0FBQ3BFLHlFQUFvRTtBQUd2RCxRQUFBLGdCQUFnQixHQUFHLFVBQzlCLElBQXdCLEVBQ3hCLFFBQWlCO0lBRWpCLElBQUksVUFBMEIsQ0FBQztJQUUvQixRQUFRLElBQUksRUFBRTtRQUNaLEtBQUssdUNBQWtCLENBQUMsTUFBTTtZQUM1QixVQUFVLEdBQUcsSUFBSSwwQkFBZ0IsQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUM1QyxNQUFNO1FBQ1IsS0FBSyx1Q0FBa0IsQ0FBQyxNQUFNO1lBQzVCLFVBQVUsR0FBRyxJQUFJLDBCQUFnQixDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQzVDLE1BQU07S0FDVDtJQUVELE9BQU8sVUFBVSxDQUFDO0FBQ3BCLENBQUMsQ0FBQyJ9

package/lib/{data-structures → app/data-structures}/LoopedArray/LoopedArray.d.ts

@@ -10,6 +10,7 @@ export default class LoopedArray<T> implements IArrayFacade<T> {
     private _array;
     /**
      * Create empty instance
+     * @throws {ValueOutOfRangeException} when given capacity is not valid
      */
     constructor(capacity: number);
     /**
@@ -22,10 +23,12 @@ export default class LoopedArray<T> implements IArrayFacade<T> {
     unshift(value: T): void;
     /**
      * Delete node from array's end
+     * @throws {CollectionIsEmptyException} when array is empty
      */
     pop(): T;
     /**
      * Delete node from array's start
+     * @throws {CollectionIsEmptyException} when array is empty
      */
     shift(): T;
     /**

package/lib/app/data-structures/LoopedArray/LoopedArray.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ValueOutOfRangeException_1 = require("../../exceptions/ValueOutOfRangeException");
+var CollectionIsEmptyException_1 = require("../../exceptions/CollectionIsEmptyException");
+/**
+ * Linear data structure
+ * Facade above array
+ * After reaching full array new pushed elements will be overwritten over old elements
+ */
+var LoopedArray = /** @class */ (function () {
+    /**
+     * Create empty instance
+     * @throws {ValueOutOfRangeException} when given capacity is not valid
+     */
+    function LoopedArray(capacity) {
+        this._realLength = 0;
+        if (capacity <= 0) {
+            throw new ValueOutOfRangeException_1.default("Capacity must be larger than 0");
+        }
+        this._capacity = capacity;
+        this._array = new Array(0);
+    }
+    /**
+     * Push into end
+     */
+    LoopedArray.prototype.push = function (value) {
+        if (this._realLength % this._capacity === 0) {
+            this._array = new Array(0);
+        }
+        this._realLength++;
+        if (!this.isFull()) {
+            this._array.push(value);
+        }
+        else {
+            var indexToPush = (this._realLength % this._capacity) - 1;
+            this._array.splice(indexToPush, 1, value);
+        }
+    };
+    /**
+     * Push into start
+     */
+    LoopedArray.prototype.unshift = function (value) {
+        if (this._realLength % this._capacity === 0) {
+            this._array = new Array(0);
+        }
+        this._realLength++;
+        if (!this.isFull()) {
+            this._array.unshift(value);
+        }
+        else {
+            this._array.splice(this._capacity - 1);
+            this._array.unshift(value);
+        }
+    };
+    /**
+     * Delete node from array's end
+     * @throws {CollectionIsEmptyException} when array is empty
+     */
+    LoopedArray.prototype.pop = function () {
+        if (this.isEmpty()) {
+            throw new CollectionIsEmptyException_1.default("cannot delete because array is empty");
+        }
+        this._realLength--;
+        var deletedItem = this._array.pop();
+        return deletedItem;
+    };
+    /**
+     * Delete node from array's start
+     * @throws {CollectionIsEmptyException} when array is empty
+     */
+    LoopedArray.prototype.shift = function () {
+        if (this.isEmpty()) {
+            throw new CollectionIsEmptyException_1.default("cannot delete because array is empty");
+        }
+        this._realLength--;
+        var deletedItem = this._array.shift();
+        return deletedItem;
+    };
+    /**
+     * Get head element data
+     */
+    LoopedArray.prototype.peek = function () {
+        return this._array[this._array.length - 1];
+    };
+    /**
+     * Get tail element data
+     */
+    LoopedArray.prototype.peekFromStart = function () {
+        return this._array[0];
+    };
+    /**
+     * Get array element by index from start
+     */
+    LoopedArray.prototype.peekByIndex = function (index) {
+        return this._array[index];
+    };
+    /**
+     * Push from index
+     */
+    LoopedArray.prototype.pushFromIndex = function (value, fromIndex) {
+        this._array[fromIndex] = value;
+    };
+    /**
+     * Get elements as array
+     */
+    LoopedArray.prototype.getAsArray = function () {
+        return this._array;
+    };
+    /**
+     * Check if element exists in array
+     */
+    LoopedArray.prototype.has = function (item) {
+        return this._array.includes(item);
+    };
+    /**
+     * Is array empty
+     */
+    LoopedArray.prototype.isEmpty = function () {
+        return this._array.length === 0;
+    };
+    /**
+     * Is array full
+     */
+    LoopedArray.prototype.isFull = function () {
+        return this._array.length >= this._capacity;
+    };
+    /**
+     * List length
+     */
+    LoopedArray.prototype.length = function () {
+        return this._array.length;
+    };
+    /**
+     * Remove all elements from array
+     */
+    LoopedArray.prototype.clear = function () {
+        this._array = new Array(0);
+    };
+    /**
+     * Delete node from array by index from start
+     */
+    LoopedArray.prototype.deleteFromIndex = function (fromIndex) {
+        var deletedElement = this._array[fromIndex];
+        delete this._array[fromIndex];
+        return deletedElement;
+    };
+    /**
+     * Add elements to array from array
+     * */
+    LoopedArray.prototype.pushFromArray = function (elements) {
+        var _this = this;
+        elements.forEach(function (element) {
+            _this.push(element);
+        });
+    };
+    /**
+     * Reverse array nodes links and swap head with tail
+     */
+    LoopedArray.prototype.reverse = function () {
+        this._array = this._array.reverse();
+    };
+    return LoopedArray;
+}());
+exports.default = LoopedArray;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{data-structures → app/data-structures}/Queue/Queue.d.ts

@@ -10,17 +10,17 @@ export default class Queue<T> implements ILinearStorage<T> {
     constructor(capacity?: number);
     /**
      * Get first element in queue (without deleting)
-     * @throws when list is empty
+     * @throws {CollectionIsEmptyException} when list is empty
      */
     peek(): T;
     /**
      * Add element to queue
-     * @throws when list is full
+     * @throws {CollectionIsFullException} when list is full
      */
     push(item: T): void;
     /**
      * Delete first element in queue
-     * @throws when list is empty
+     * @throws {CollectionIsEmptyException} when list is empty
      */
     pop(): T;
     /**