data-structure-typed 1.12.11 → 1.15.0

package/dist/data-structures/hash/coordinate-map.d.ts

@@ -1,9 +1,18 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 export declare class CoordinateMap<V> extends Map<any, V> {
-    private readonly _joint;
+    protected _joint: string;
+    get joint(): string;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getJoint(): string;
+    protected set joint(v: string);
     constructor(joint?: string);
     /**
      * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the

package/dist/data-structures/hash/coordinate-map.js

@@ -17,8 +17,11 @@ var __extends = (this && this.__extends) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoordinateMap = void 0;
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var CoordinateMap = /** @class */ (function (_super) {
     __extends(CoordinateMap, _super);
@@ -29,6 +32,22 @@ var CoordinateMap = /** @class */ (function (_super) {
             _this._joint = joint;
         return _this;
     }
+    Object.defineProperty(CoordinateMap.prototype, "joint", {
+        get: function () {
+            return this._joint;
+        },
+        set: function (v) {
+            this._joint = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    CoordinateMap.prototype.getJoint = function () {
+        return this._joint;
+    };
     /**
      * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
      * key array with a specified delimiter.

package/dist/data-structures/hash/coordinate-set.d.ts

@@ -1,9 +1,18 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 export declare class CoordinateSet extends Set {
-    private readonly _joint;
+    protected _joint: string;
+    get joint(): string;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getJoint(): string;
+    protected set joint(v: string);
     constructor(joint?: string);
     /**
      * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after

package/dist/data-structures/hash/coordinate-set.js

@@ -17,8 +17,11 @@ var __extends = (this && this.__extends) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoordinateSet = void 0;
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var CoordinateSet = /** @class */ (function (_super) {
     __extends(CoordinateSet, _super);
@@ -29,6 +32,22 @@ var CoordinateSet = /** @class */ (function (_super) {
             _this._joint = joint;
         return _this;
     }
+    Object.defineProperty(CoordinateSet.prototype, "joint", {
+        get: function () {
+            return this._joint;
+        },
+        set: function (v) {
+            this._joint = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    CoordinateSet.prototype.getJoint = function () {
+        return this._joint;
+    };
     /**
      * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
      * joining its elements with a specified separator.

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

@@ -1,12 +1,27 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import { PriorityQueue } from '../priority-queue';
 import type { HeapItem, HeapOptions } from '../types';
 export declare abstract class Heap<T> {
     protected abstract _pq: PriorityQueue<HeapItem<T>>;
+    get pq(): PriorityQueue<HeapItem<T>>;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getPq(): PriorityQueue<HeapItem<T>>;
+    protected set pq(v: PriorityQueue<HeapItem<T>>);
     protected _priorityCb: (element: T) => number;
+    get priorityCb(): (element: T) => number;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getPriorityCb(): (element: T) => number;
+    protected set priorityCb(v: (element: T) => number);
     /**
      * The function is a constructor for a class that initializes a priority callback function based on the
      * options provided.
@@ -18,6 +33,10 @@ export declare abstract class Heap<T> {
      * @returns The size of the priority queue.
      */
     get size(): number;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getSize(): number;
     /**
      * The function checks if a priority queue is empty.
      * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
@@ -34,16 +53,16 @@ export declare abstract class Heap<T> {
      */
     peekLast(): HeapItem<T> | null;
     /**
-     * The `offer` function adds an element to a priority queue with an optional priority value.
+     * The `add` function adds an element to a priority queue with an optional priority value.
      * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
      * type.
      * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
-     * element being offered to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
+     * element being added to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
      * the value of `element`. If the `element` parameter is not a number, then the
-     * @returns The `offer` method returns the instance of the `Heap` class.
+     * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    offer(element: T, priority?: number): Heap<T>;
+    add(element: T, priority?: number): Heap<T>;
     /**
      * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an element with the highest priority in the queue
      * @returns either a HeapItem<T> object or null.

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

@@ -19,6 +19,38 @@ var Heap = /** @class */ (function () {
             this._priorityCb = function (el) { return +el; };
         }
     }
+    Object.defineProperty(Heap.prototype, "pq", {
+        get: function () {
+            return this._pq;
+        },
+        set: function (v) {
+            this._pq = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    Heap.prototype.getPq = function () {
+        return this._pq;
+    };
+    Object.defineProperty(Heap.prototype, "priorityCb", {
+        get: function () {
+            return this._priorityCb;
+        },
+        set: function (v) {
+            this._priorityCb = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    Heap.prototype.getPriorityCb = function () {
+        return this._priorityCb;
+    };
     Object.defineProperty(Heap.prototype, "size", {
         /**
          * The function returns the size of a priority queue.
@@ -30,6 +62,12 @@ var Heap = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    Heap.prototype.getSize = function () {
+        return this._pq.size;
+    };
     /**
      * The function checks if a priority queue is empty.
      * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
@@ -52,33 +90,33 @@ var Heap = /** @class */ (function () {
         return this._pq.leaf();
     };
     /**
-     * The `offer` function adds an element to a priority queue with an optional priority value.
+     * The `add` function adds an element to a priority queue with an optional priority value.
      * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
      * type.
      * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
-     * element being offered to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
+     * element being added to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
      * the value of `element`. If the `element` parameter is not a number, then the
-     * @returns The `offer` method returns the instance of the `Heap` class.
+     * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    Heap.prototype.offer = function (element, priority) {
+    Heap.prototype.add = function (element, priority) {
         if (typeof element === 'number') {
             priority = element;
         }
         else {
             if (priority === undefined) {
-                throw new Error('.offer expects a numeric priority');
+                throw new Error('.add expects a numeric priority');
             }
         }
         if (priority && Number.isNaN(+priority)) {
-            throw new Error('.offer expects a numeric priority');
+            throw new Error('.add expects a numeric priority');
         }
         if (Number.isNaN(+priority) && Number.isNaN(this._priorityCb(element))) {
-            throw new Error('.offer expects a numeric priority '
+            throw new Error('.add expects a numeric priority '
                 + 'or a constructor callback that returns a number');
         }
         var _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(element);
-        this._pq.offer({ priority: _priority, element: element });
+        this._pq.add({ priority: _priority, element: element });
         return this;
     };
     /**

package/dist/data-structures/heap/max-heap.d.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import { Heap } from './heap';
 import { PriorityQueue } from '../priority-queue';

package/dist/data-structures/heap/max-heap.js

@@ -1,7 +1,10 @@
 "use strict";
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var __extends = (this && this.__extends) || (function () {
     var extendStatics = function (d, b) {

package/dist/data-structures/heap/min-heap.d.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import { Heap } from './heap';
 import { PriorityQueue } from '../priority-queue';

package/dist/data-structures/heap/min-heap.js

@@ -1,7 +1,10 @@
 "use strict";
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var __extends = (this && this.__extends) || (function () {
     var extendStatics = function (d, b) {

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

@@ -8,3 +8,4 @@ export * from './heap';
 export * from './priority-queue';
 export * from './matrix';
 export * from './trie';
+export * from './types';

package/dist/data-structures/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./heap"), exports);
 __exportStar(require("./priority-queue"), exports);
 __exportStar(require("./matrix"), exports);
 __exportStar(require("./trie"), exports);
+__exportStar(require("./types"), exports);

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -1,29 +1,52 @@
 export declare class DoublyLinkedListNode<T> {
-    val: T;
-    next: DoublyLinkedListNode<T> | null;
-    prev: DoublyLinkedListNode<T> | null;
+    protected _val: T;
+    get val(): T;
+    set val(v: T);
+    protected _next: DoublyLinkedListNode<T> | null;
+    get next(): DoublyLinkedListNode<T> | null;
+    set next(v: DoublyLinkedListNode<T> | null);
+    protected _prev: DoublyLinkedListNode<T> | null;
+    get prev(): DoublyLinkedListNode<T> | null;
+    set prev(v: DoublyLinkedListNode<T> | null);
     constructor(nodeValue: T);
 }
 export declare class DoublyLinkedList<T> {
-    private _first;
-    private _last;
-    private _size;
+    protected _first: DoublyLinkedListNode<T> | null;
+    get first(): DoublyLinkedListNode<T> | null;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getFirst(): DoublyLinkedListNode<T> | null;
+    protected set first(v: DoublyLinkedListNode<T> | null);
+    protected _last: DoublyLinkedListNode<T> | null;
+    get last(): DoublyLinkedListNode<T> | null;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getLast(): DoublyLinkedListNode<T> | null;
+    protected set last(v: DoublyLinkedListNode<T> | null);
+    protected _size: number;
     get size(): number;
-    set size(v: number);
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getSize(): number;
+    protected set size(v: number);
+    constructor();
     /**
      * The function adds a new node with a given value to the beginning of a doubly linked list.
      * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of
      * the doubly linked list.
      * @returns A boolean value is being returned.
      */
-    offerFirst(val: T): boolean;
+    addFirst(val: T): boolean;
     /**
      * The function adds a new node with a given value to the end of a doubly linked list.
      * @param {T} val - The `val` parameter represents the value of the element that you want to add to the end of the
      * doubly linked list.
      * @returns a boolean value, which is always true.
      */
-    offerLast(val: T): boolean;
+    addLast(val: T): boolean;
     peekFirst(): T | null;
     peekFirst(by: 'val'): T | null;
     peekFirst(by: 'node'): DoublyLinkedListNode<T> | null;

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -3,10 +3,40 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoublyLinkedList = exports.DoublyLinkedListNode = void 0;
 var DoublyLinkedListNode = /** @class */ (function () {
     function DoublyLinkedListNode(nodeValue) {
-        this.val = nodeValue;
-        this.next = null;
-        this.prev = null;
+        this._val = nodeValue;
+        this._next = null;
+        this._prev = null;
     }
+    Object.defineProperty(DoublyLinkedListNode.prototype, "val", {
+        get: function () {
+            return this._val;
+        },
+        set: function (v) {
+            this._val = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DoublyLinkedListNode.prototype, "next", {
+        get: function () {
+            return this._next;
+        },
+        set: function (v) {
+            this._next = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DoublyLinkedListNode.prototype, "prev", {
+        get: function () {
+            return this._prev;
+        },
+        set: function (v) {
+            this._prev = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
     return DoublyLinkedListNode;
 }());
 exports.DoublyLinkedListNode = DoublyLinkedListNode;
@@ -15,8 +45,39 @@ var DoublyLinkedList = /** @class */ (function () {
         this._first = null;
         this._last = null;
         this._size = 0;
-        // --- end extra methods ---
     }
+    Object.defineProperty(DoublyLinkedList.prototype, "first", {
+        get: function () {
+            return this._first;
+        },
+        set: function (v) {
+            this._first = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    DoublyLinkedList.prototype.getFirst = function () {
+        return this._first;
+    };
+    Object.defineProperty(DoublyLinkedList.prototype, "last", {
+        get: function () {
+            return this._last;
+        },
+        set: function (v) {
+            this._last = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    DoublyLinkedList.prototype.getLast = function () {
+        return this._last;
+    };
     Object.defineProperty(DoublyLinkedList.prototype, "size", {
         get: function () {
             return this._size;
@@ -27,13 +88,19 @@ var DoublyLinkedList = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    DoublyLinkedList.prototype.getSize = function () {
+        return this._size;
+    };
     /**
      * The function adds a new node with a given value to the beginning of a doubly linked list.
      * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of
      * the doubly linked list.
      * @returns A boolean value is being returned.
      */
-    DoublyLinkedList.prototype.offerFirst = function (val) {
+    DoublyLinkedList.prototype.addFirst = function (val) {
         var newNode = new DoublyLinkedListNode(val);
         if (this._size === 0) {
             this._first = newNode;
@@ -54,7 +121,7 @@ var DoublyLinkedList = /** @class */ (function () {
      * doubly linked list.
      * @returns a boolean value, which is always true.
      */
-    DoublyLinkedList.prototype.offerLast = function (val) {
+    DoublyLinkedList.prototype.addLast = function (val) {
         var newNode = new DoublyLinkedListNode(val);
         if (this._size === 0) {
             this._first = newNode;
@@ -247,9 +314,9 @@ var DoublyLinkedList = /** @class */ (function () {
         if (index < 0 || index > this._size)
             return false;
         if (index === 0)
-            return !!this.offerFirst(val);
+            return !!this.addFirst(val);
         if (index === this._size)
-            return !!this.offerLast(val);
+            return !!this.addLast(val);
         var newNode = new DoublyLinkedListNode(val);
         var prevNode = this.get(index - 1, 'node');
         var nextNode = prevNode === null || prevNode === void 0 ? void 0 : prevNode.next;