data-structure-typed 1.12.21 → 1.15.0

package/src/data-structures/graph/directed-graph.ts

@@ -40,17 +40,26 @@ export class DirectedEdge extends AbstractEdge {
     get src(): VertexId {
         return this._src;
     }
-
+    /**
+     * 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.
+     */
+    getSrc(): VertexId {
+        return this._src;
+    }
     set src(v: VertexId) {
         this._src = v;
     }
 
-
     private _dest: VertexId;
     get dest(): VertexId {
         return this._dest;
     }
-
+    /**
+     * 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.
+     */
+    getDest(): VertexId {
+        return this._dest;
+    }
     set dest(v: VertexId) {
         this._dest = v;
     }
@@ -101,7 +110,7 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
      * graph, and `false` if either the source or destination vertices of the edge are not present in the graph.
      */
     addEdge(edge: E): boolean {
-        if (!(this.containsVertex(edge.src) && this.containsVertex(edge.dest))) {
+        if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
             return false;
         }
 
@@ -401,7 +410,7 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
      * returns null.
      */
     getEndsOfEdge(edge: E): [V, V] | null {
-        if (!this.containsEdge(edge.src, edge.dest)) {
+        if (!this.hasEdge(edge.src, edge.dest)) {
             return null;
         }
         const v1 = this.getVertex(edge.src);

package/src/data-structures/graph/undirected-graph.ts

@@ -35,21 +35,38 @@ export class UndirectedEdge extends AbstractEdge {
     }
 
     private _vertices: [VertexId, VertexId];
-
-    public get vertices() {
+    get vertices() {
         return this._vertices;
     }
-
-    public set vertices(v: [VertexId, VertexId]) {
+    /**
+     * 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.
+     */
+    getVertices() {
+        return this._vertices;
+    }
+    set vertices(v: [VertexId, VertexId]) {
         this._vertices = v;
     }
 }
 
 export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
-    protected _edges: Map<V, E[]> = new Map();
+    protected _edges: Map<V, E[]>;
+    get edges(): Map<V, E[]> {
+        return this._edges;
+    }
+    /**
+     * 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.
+     */
+    getEdges(): Map<V, E[]> {
+        return this._edges;
+    }
+    protected set edges(v: Map<V, E[]>) {
+        this._edges = v;
+    }
 
     constructor() {
         super();
+        this._edges = new Map<V, E[]>();
     }
 
     /**
@@ -223,7 +240,7 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
      * `null`.
      */
     getEndsOfEdge(edge: E): [V, V] | null {
-        if (!this.containsEdge(edge.vertices[0], edge.vertices[1])) {
+        if (!this.hasEdge(edge.vertices[0], edge.vertices[1])) {
             return null;
         }
         const v1 = this.getVertex(edge.vertices[0]);

package/src/data-structures/hash/coordinate-map.ts

@@ -6,7 +6,19 @@
  * @license MIT License
  */
 export class CoordinateMap<V> extends Map<any, V> {
-    private readonly _joint: string = '_';
+    protected _joint: string = '_';
+    get joint(): string {
+        return this._joint;
+    }
+    /**
+     * 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 {
+        return this._joint;
+    }
+    protected set joint(v: string) {
+        this._joint = v;
+    }
 
     constructor(joint?: string) {
         super();

package/src/data-structures/hash/coordinate-set.ts

@@ -6,7 +6,19 @@
  * @license MIT License
  */
 export class CoordinateSet extends Set {
-    private readonly _joint: string = '_';
+    protected _joint: string = '_';
+    get joint(): string {
+        return this._joint;
+    }
+    /**
+     * 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 {
+        return this._joint;
+    }
+    protected set joint(v: string) {
+        this._joint = v;
+    }
 
     constructor(joint?: string) {
         super();

package/src/data-structures/heap/heap.ts

@@ -10,7 +10,32 @@ import type {HeapItem, HeapOptions} from '../types';
 
 export abstract class Heap<T> {
     protected abstract _pq: PriorityQueue<HeapItem<T>>;
+    get pq() {
+        return this._pq;
+    }
+    /**
+     * 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() {
+        return this._pq;
+    }
+    protected set pq(v: PriorityQueue<HeapItem<T>>) {
+        this._pq = v;
+    }
+
     protected _priorityCb: (element: T) => number;
+    get priorityCb() {
+        return this._priorityCb;
+    }
+    /**
+     * 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() {
+        return this._priorityCb;
+    }
+    protected set priorityCb(v: (element: T) => number) {
+        this._priorityCb = v;
+    }
 
     /**
      * The function is a constructor for a class that initializes a priority callback function based on the
@@ -36,6 +61,12 @@ export abstract class Heap<T> {
     get size(): number {
         return this._pq.size;
     }
+    /**
+     * 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 {
+        return this._pq.size;
+    }
 
     /**
      * The function checks if a priority queue is empty.

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -8,29 +8,86 @@
 import type {DoublyLinkedListGetBy} from '../types';
 
 export class DoublyLinkedListNode<T> {
-    val: T;
-    next: DoublyLinkedListNode<T> | null;
-    prev: DoublyLinkedListNode<T> | null;
+    protected _val: T;
+    get val(): T {
+        return this._val;
+    }
+    set val(v: T) {
+        this._val = v;
+    }
+
+    protected _next: DoublyLinkedListNode<T> | null;
+    get next(): DoublyLinkedListNode<T> | null {
+        return this._next;
+    }
+    set next(v: DoublyLinkedListNode<T> | null) {
+        this._next = v;
+    }
+
+    protected _prev: DoublyLinkedListNode<T> | null;
+    get prev(): DoublyLinkedListNode<T> | null {
+        return this._prev;
+    }
+    set prev(v: DoublyLinkedListNode<T> | null) {
+        this._prev = v;
+    }
 
     constructor(nodeValue: T) {
-        this.val = nodeValue;
-        this.next = null;
-        this.prev = null;
+        this._val = nodeValue;
+        this._next = null;
+        this._prev = null;
     }
 }
 
 export class DoublyLinkedList<T> {
-    private _first: DoublyLinkedListNode<T> | null = null;
-    private _last: DoublyLinkedListNode<T> | null = null;
-    private _size = 0;
+    protected _first: DoublyLinkedListNode<T> | null;
+    get first(): DoublyLinkedListNode<T> | null {
+        return this._first;
+    }
+    /**
+     * 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 {
+        return this._first;
+    }
+    protected set first(v: DoublyLinkedListNode<T> | null) {
+        this._first = v;
+    }
+
+    protected _last: DoublyLinkedListNode<T> | null;
+    get last(): DoublyLinkedListNode<T> | null {
+        return this._last;
+    }
+    /**
+     * 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 {
+        return this._last;
+    }
+    protected set last(v: DoublyLinkedListNode<T> | null) {
+        this._last = v;
+    }
+
+    protected _size: number;
     get size(): number {
         return this._size;
     }
-
-    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 {
+        return this._size;
+    }
+    protected set size(v: number) {
         this._size = v;
     }
 
+    constructor() {
+        this._first = null;
+        this._last = null;
+        this._size = 0;
+    }
+
     /**
      * 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