data-structure-typed 1.12.21 → 1.15.0

package/dist/data-structures/graph/undirected-graph.js

@@ -99,6 +99,12 @@ var UndirectedEdge = /** @class */ (function (_super) {
         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.
+     */
+    UndirectedEdge.prototype.getVertices = function () {
+        return this._vertices;
+    };
     return UndirectedEdge;
 }(abstract_graph_1.AbstractEdge));
 exports.UndirectedEdge = UndirectedEdge;
@@ -109,6 +115,22 @@ var UndirectedGraph = /** @class */ (function (_super) {
         _this._edges = new Map();
         return _this;
     }
+    Object.defineProperty(UndirectedGraph.prototype, "edges", {
+        get: function () {
+            return this._edges;
+        },
+        set: function (v) {
+            this._edges = 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.
+     */
+    UndirectedGraph.prototype.getEdges = function () {
+        return this._edges;
+    };
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
      * @param {V | null | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID
@@ -293,7 +315,7 @@ var UndirectedGraph = /** @class */ (function (_super) {
      * `null`.
      */
     UndirectedGraph.prototype.getEndsOfEdge = function (edge) {
-        if (!this.containsEdge(edge.vertices[0], edge.vertices[1])) {
+        if (!this.hasEdge(edge.vertices[0], edge.vertices[1])) {
             return null;
         }
         var v1 = this.getVertex(edge.vertices[0]);

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

@@ -6,7 +6,13 @@
  * @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

@@ -32,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

@@ -6,7 +6,13 @@
  * @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

@@ -32,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

@@ -9,7 +9,19 @@ 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.
@@ -21,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.

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.

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

@@ -1,15 +1,38 @@
 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

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,6 +88,12 @@ 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