deque-typed 1.19.3

package/dist/deque.d.ts

@@ -0,0 +1,120 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import { DoublyLinkedList } from 'data-structure-typed';
+export declare class Deque<T> extends DoublyLinkedList<T> {
+}
+export declare class ObjectDeque<T = number> {
+    constructor(capacity?: number);
+    private _nodes;
+    get nodes(): {
+        [p: number]: T;
+    };
+    private _capacity;
+    get capacity(): number;
+    set capacity(value: number);
+    private _first;
+    get first(): number;
+    set first(value: number);
+    private _last;
+    get last(): number;
+    set last(value: number);
+    private _size;
+    get size(): number;
+    addFirst(value: T): void;
+    addLast(value: T): void;
+    pollFirst(): T | undefined;
+    peekFirst(): T | undefined;
+    pollLast(): T | undefined;
+    peekLast(): T | undefined;
+    get(index: number): NonNullable<T> | null;
+    isEmpty(): boolean;
+    protected _seNodes(value: {
+        [p: number]: T;
+    }): void;
+    protected _setSize(value: number): void;
+}
+export declare class ArrayDeque<T> {
+    protected _nodes: T[];
+    get size(): number;
+    /**
+     * The function "addLast" adds a value to the end of an array.
+     * @param {T} value - The value parameter represents the value that you want to add to the end of the array.
+     * @returns The return value is the new length of the array after the value has been added.
+     */
+    addLast(value: T): number;
+    /**
+     * The function "pollLast" returns and removes the last element from an array, or returns null if the array is empty.
+     * @returns The method `pollLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     */
+    pollLast(): T | null;
+    /**
+     * The `pollFirst` function removes and returns the first element from an array, or returns null if the array is empty.
+     * @returns The `pollFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
+     * empty.
+     */
+    pollFirst(): T | null;
+    /**
+     * The function "addFirst" adds a value to the beginning of an array.
+     * @param {T} value - The value parameter represents the value that you want to add to the beginning of the array.
+     * @returns The return value of the `addFirst` function is the new length of the array `_nodes` after adding the
+     * `value` at the beginning.
+     */
+    addFirst(value: T): number;
+    /**
+     * The `peekFirst` function returns the first element of an array or null if the array is empty.
+     * @returns The function `peekFirst()` is returning the first element (`T`) of the `_nodes` array. If the array is
+     * empty, it will return `null`.
+     */
+    peekFirst(): T | null;
+    /**
+     * The `peekLast` function returns the last element of an array or null if the array is empty.
+     * @returns The method `peekLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     */
+    peekLast(): T | null;
+    /**
+     * The get function returns the element at the specified index in an array, or null if the index is out of bounds.
+     * @param {number} index - The index parameter is a number that represents the position of the element you want to
+     * retrieve from the array.
+     * @returns The method is returning the element at the specified index in the `_nodes` array. If the element exists, it
+     * will be returned. If the element does not exist (i.e., the index is out of bounds), `null` will be returned.
+     */
+    get(index: number): T | null;
+    /**
+     * The set function assigns a value to a specific index in an array.
+     * @param {number} index - The index parameter is a number that represents the position of the element in the array
+     * that you want to set a new value for.
+     * @param {T} value - The value parameter represents the new value that you want to set at the specified index in the
+     * _nodes array.
+     * @returns The value that is being set at the specified index in the `_nodes` array.
+     */
+    set(index: number, value: T): T;
+    /**
+     * The insert function adds a value at a specified index in an array.
+     * @param {number} index - The index parameter specifies the position at which the value should be inserted in the
+     * array. It is a number that represents the index of the array where the value should be inserted. The index starts
+     * from 0, so the first element of the array has an index of 0, the second element has
+     * @param {T} value - The value parameter represents the value that you want to insert into the array at the specified
+     * index.
+     * @returns The splice method returns an array containing the removed elements, if any. In this case, since no elements
+     * are being removed, an empty array will be returned.
+     */
+    insert(index: number, value: T): T[];
+    /**
+     * The remove function removes an element from an array at a specified index.
+     * @param {number} index - The index parameter specifies the position of the element to be removed from the array. It
+     * is a number that represents the index of the element to be removed.
+     * @returns The method is returning an array containing the removed element.
+     */
+    remove(index: number): T[];
+    /**
+     * The function checks if an array called "_nodes" is empty.
+     * @returns The method `isEmpty()` is returning a boolean value. It returns `true` if the length of the `_nodes` array
+     * is 0, indicating that the array is empty. Otherwise, it returns `false`.
+     */
+    isEmpty(): boolean;
+}

package/dist/deque.js

@@ -0,0 +1,277 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayDeque = exports.ObjectDeque = exports.Deque = void 0;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+var data_structure_typed_1 = require("data-structure-typed");
+// O(n) time complexity of obtaining the value
+// O(1) time complexity of adding at the beginning and the end
+var Deque = /** @class */ (function (_super) {
+    __extends(Deque, _super);
+    function Deque() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return Deque;
+}(data_structure_typed_1.DoublyLinkedList));
+exports.Deque = Deque;
+// O(1) time complexity of obtaining the value
+// O(n) time complexity of adding at the beginning and the end
+// todo tested slowest one
+var ObjectDeque = /** @class */ (function () {
+    function ObjectDeque(capacity) {
+        this._nodes = {};
+        this._capacity = Number.MAX_SAFE_INTEGER;
+        this._first = -1;
+        this._last = -1;
+        this._size = 0;
+        if (capacity !== undefined)
+            this._capacity = capacity;
+    }
+    Object.defineProperty(ObjectDeque.prototype, "nodes", {
+        get: function () {
+            return this._nodes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ObjectDeque.prototype, "capacity", {
+        get: function () {
+            return this._capacity;
+        },
+        set: function (value) {
+            this._capacity = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ObjectDeque.prototype, "first", {
+        get: function () {
+            return this._first;
+        },
+        set: function (value) {
+            this._first = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ObjectDeque.prototype, "last", {
+        get: function () {
+            return this._last;
+        },
+        set: function (value) {
+            this._last = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ObjectDeque.prototype, "size", {
+        get: function () {
+            return this._size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ObjectDeque.prototype.addFirst = function (value) {
+        if (this._size === 0) {
+            var mid = Math.floor(this._capacity / 2);
+            this._first = mid;
+            this._last = mid;
+        }
+        else {
+            this._first--;
+        }
+        this._nodes[this._first] = value;
+        this._size++;
+    };
+    ObjectDeque.prototype.addLast = function (value) {
+        if (this._size === 0) {
+            var mid = Math.floor(this._capacity / 2);
+            this._first = mid;
+            this._last = mid;
+        }
+        else {
+            this._last++;
+        }
+        this._nodes[this._last] = value;
+        this._size++;
+    };
+    ObjectDeque.prototype.pollFirst = function () {
+        if (!this._size)
+            return;
+        var value = this.peekFirst();
+        delete this._nodes[this._first];
+        this._first++;
+        this._size--;
+        return value;
+    };
+    ObjectDeque.prototype.peekFirst = function () {
+        if (this._size)
+            return this._nodes[this._first];
+    };
+    ObjectDeque.prototype.pollLast = function () {
+        if (!this._size)
+            return;
+        var value = this.peekLast();
+        delete this._nodes[this._last];
+        this._last--;
+        this._size--;
+        return value;
+    };
+    ObjectDeque.prototype.peekLast = function () {
+        if (this._size)
+            return this._nodes[this._last];
+    };
+    ObjectDeque.prototype.get = function (index) {
+        return this._nodes[this._first + index] || null;
+    };
+    ObjectDeque.prototype.isEmpty = function () {
+        return this._size <= 0;
+    };
+    ObjectDeque.prototype._seNodes = function (value) {
+        this._nodes = value;
+    };
+    ObjectDeque.prototype._setSize = function (value) {
+        this._size = value;
+    };
+    return ObjectDeque;
+}());
+exports.ObjectDeque = ObjectDeque;
+// O(1) time complexity of obtaining the value
+// O(n) time complexity of adding at the beginning and the end
+var ArrayDeque = /** @class */ (function () {
+    function ArrayDeque() {
+        this._nodes = [];
+    }
+    Object.defineProperty(ArrayDeque.prototype, "size", {
+        get: function () {
+            return this._nodes.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * The function "addLast" adds a value to the end of an array.
+     * @param {T} value - The value parameter represents the value that you want to add to the end of the array.
+     * @returns The return value is the new length of the array after the value has been added.
+     */
+    ArrayDeque.prototype.addLast = function (value) {
+        return this._nodes.push(value);
+    };
+    /**
+     * The function "pollLast" returns and removes the last element from an array, or returns null if the array is empty.
+     * @returns The method `pollLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     */
+    ArrayDeque.prototype.pollLast = function () {
+        var _a;
+        return (_a = this._nodes.pop()) !== null && _a !== void 0 ? _a : null;
+    };
+    /**
+     * The `pollFirst` function removes and returns the first element from an array, or returns null if the array is empty.
+     * @returns The `pollFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
+     * empty.
+     */
+    ArrayDeque.prototype.pollFirst = function () {
+        var _a;
+        return (_a = this._nodes.shift()) !== null && _a !== void 0 ? _a : null;
+    };
+    /**
+     * The function "addFirst" adds a value to the beginning of an array.
+     * @param {T} value - The value parameter represents the value that you want to add to the beginning of the array.
+     * @returns The return value of the `addFirst` function is the new length of the array `_nodes` after adding the
+     * `value` at the beginning.
+     */
+    ArrayDeque.prototype.addFirst = function (value) {
+        return this._nodes.unshift(value);
+    };
+    /**
+     * The `peekFirst` function returns the first element of an array or null if the array is empty.
+     * @returns The function `peekFirst()` is returning the first element (`T`) of the `_nodes` array. If the array is
+     * empty, it will return `null`.
+     */
+    ArrayDeque.prototype.peekFirst = function () {
+        var _a;
+        return (_a = this._nodes[0]) !== null && _a !== void 0 ? _a : null;
+    };
+    /**
+     * The `peekLast` function returns the last element of an array or null if the array is empty.
+     * @returns The method `peekLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     */
+    ArrayDeque.prototype.peekLast = function () {
+        var _a;
+        return (_a = this._nodes[this._nodes.length - 1]) !== null && _a !== void 0 ? _a : null;
+    };
+    /**
+     * The get function returns the element at the specified index in an array, or null if the index is out of bounds.
+     * @param {number} index - The index parameter is a number that represents the position of the element you want to
+     * retrieve from the array.
+     * @returns The method is returning the element at the specified index in the `_nodes` array. If the element exists, it
+     * will be returned. If the element does not exist (i.e., the index is out of bounds), `null` will be returned.
+     */
+    ArrayDeque.prototype.get = function (index) {
+        var _a;
+        return (_a = this._nodes[index]) !== null && _a !== void 0 ? _a : null;
+    };
+    /**
+     * The set function assigns a value to a specific index in an array.
+     * @param {number} index - The index parameter is a number that represents the position of the element in the array
+     * that you want to set a new value for.
+     * @param {T} value - The value parameter represents the new value that you want to set at the specified index in the
+     * _nodes array.
+     * @returns The value that is being set at the specified index in the `_nodes` array.
+     */
+    ArrayDeque.prototype.set = function (index, value) {
+        return this._nodes[index] = value;
+    };
+    /**
+     * The insert function adds a value at a specified index in an array.
+     * @param {number} index - The index parameter specifies the position at which the value should be inserted in the
+     * array. It is a number that represents the index of the array where the value should be inserted. The index starts
+     * from 0, so the first element of the array has an index of 0, the second element has
+     * @param {T} value - The value parameter represents the value that you want to insert into the array at the specified
+     * index.
+     * @returns The splice method returns an array containing the removed elements, if any. In this case, since no elements
+     * are being removed, an empty array will be returned.
+     */
+    ArrayDeque.prototype.insert = function (index, value) {
+        return this._nodes.splice(index, 0, value);
+    };
+    /**
+     * The remove function removes an element from an array at a specified index.
+     * @param {number} index - The index parameter specifies the position of the element to be removed from the array. It
+     * is a number that represents the index of the element to be removed.
+     * @returns The method is returning an array containing the removed element.
+     */
+    ArrayDeque.prototype.remove = function (index) {
+        return this._nodes.splice(index, 1);
+    };
+    /**
+     * The function checks if an array called "_nodes" is empty.
+     * @returns The method `isEmpty()` is returning a boolean value. It returns `true` if the length of the `_nodes` array
+     * is 0, indicating that the array is empty. Otherwise, it returns `false`.
+     */
+    ArrayDeque.prototype.isEmpty = function () {
+        return this._nodes.length === 0;
+    };
+    return ArrayDeque;
+}());
+exports.ArrayDeque = ArrayDeque;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './deque';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./deque"), exports);

package/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testMatch: ['<rootDir>/tests/**/*.test.ts'],
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "deque-typed",
+  "version": "1.19.3",
+  "description": "Deque. Javascript & Typescript Data Structure.",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "rm -rf dist && npx tsc",
+    "test": "jest",
+    "build:docs": "typedoc --out docs ./src",
+    "deps:check": "dependency-cruiser src",
+    "build:publish": "npm run build && npm run build:docs && npm publish"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zrwusa/data-structure-typed"
+  },
+  "keywords": [
+    "Deque",
+    "Javascript Data Structure",
+    "Typescript Data Structure",
+    "Double-ended queue",
+    "Deque",
+    "Queue",
+    "Stack",
+    "Data structure",
+    "Insertion",
+    "Deletion",
+    "Front",
+    "Back",
+    "FIFO",
+    "LIFO",
+    "Dynamic resizing",
+    "Random access",
+    "Circular buffer",
+    "Linked list",
+    "Array-based",
+    "Efficient operations",
+    "Push",
+    "Pop",
+    "Enqueue",
+    "Dequeue",
+    "Peek",
+    "Priority queue",
+    "Concurrency",
+    "Multithreading"
+  ],
+  "author": "Tyler Zeng zrwusa@gmail.com",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/zrwusa/data-structure-typed/issues"
+  },
+  "homepage": "https://github.com/zrwusa/data-structure-typed#readme",
+  "types": "dist/index.d.ts",
+  "devDependencies": {
+    "@types/jest": "^29.5.3",
+    "@types/node": "^20.4.9",
+    "dependency-cruiser": "^13.1.2",
+    "jest": "^29.6.2",
+    "ts-jest": "^29.1.1",
+    "typedoc": "^0.24.8",
+    "typescript": "^4.9.5"
+  },
+  "dependencies": {
+    "data-structure-typed": "^1.19.3",
+    "zod": "^3.22.2"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "./dist",
+    "module": "commonjs",
+    "target": "es5",
+    "lib": [
+      "esnext",
+    ],
+    "strict": true,
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "declarationDir": "./dist",
+    "skipLibCheck": true,
+    "downlevelIteration": true,
+    "experimentalDecorators": true,
+    //    "allowJs": true,
+    //    "allowSyntheticDefaultImports": true,
+    //    "forceConsistentCasingInFileNames": true,
+    //    "noFallthroughCasesInSwitch": true,
+    //    "resolveJsonModule": true,
+    //    "isolatedModules": true,
+    //    "noEmit": true,
+    "typeRoots": [
+      "node_modules/@types"
+    ]
+  },
+
+  "include": [
+    "src",
+  ],
+  "exclude": [
+//    "node_modules/data-structure-typed",
+    "node_modules",
+    "dist"
+  ]
+}