data-structure-typed 1.19.3 → 1.19.4

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Heap = exports.HeapItem = void 0;
-var HeapItem = /** @class */ (function () {
+class HeapItem {
     /**
      * The constructor function initializes an instance of a class with a priority and a value.
      * @param {number} priority - The `priority` parameter is a number that represents the priority of the value. It is
@@ -9,99 +9,76 @@ var HeapItem = /** @class */ (function () {
      * @param {T | null} [val=null] - The `val` parameter is of type `T | null`, which means it can accept a value of type
      * `T` or `null`.
      */
-    function HeapItem(priority, val) {
-        if (priority === void 0) { priority = NaN; }
-        if (val === void 0) { val = null; }
+    constructor(priority = NaN, val = null) {
         this._val = val;
         this._priority = priority;
     }
-    Object.defineProperty(HeapItem.prototype, "priority", {
-        get: function () {
-            return this._priority;
-        },
-        set: function (value) {
-            this._priority = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(HeapItem.prototype, "val", {
-        get: function () {
-            return this._val;
-        },
-        set: function (value) {
-            this._val = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return HeapItem;
-}());
+    get priority() {
+        return this._priority;
+    }
+    set priority(value) {
+        this._priority = value;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(value) {
+        this._val = value;
+    }
+}
 exports.HeapItem = HeapItem;
-var Heap = /** @class */ (function () {
+class Heap {
     /**
      * The function is a constructor for a class that initializes a priority callback function based on the
      * options provided.
      * @param [options] - An optional object that contains configuration options for the Heap.
      */
-    function Heap(options) {
+    constructor(options) {
         if (options) {
-            var priorityExtractor = options.priorityExtractor;
+            const { priorityExtractor } = options;
             if (priorityExtractor !== undefined && typeof priorityExtractor !== 'function') {
                 throw new Error('.constructor expects a valid priority function');
             }
-            this._priorityExtractor = priorityExtractor || (function (el) { return +el; });
+            this._priorityExtractor = priorityExtractor || ((el) => +el);
         }
         else {
-            this._priorityExtractor = function (el) { return +el; };
+            this._priorityExtractor = (el) => +el;
         }
     }
-    Object.defineProperty(Heap.prototype, "pq", {
-        get: function () {
-            return this._pq;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Heap.prototype, "priorityExtractor", {
-        get: function () {
-            return this._priorityExtractor;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Heap.prototype, "size", {
-        /**
-         * The function returns the size of a priority queue.
-         * @returns The size of the priority queue.
-         */
-        get: function () {
-            return this._pq.size;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    get pq() {
+        return this._pq;
+    }
+    get priorityExtractor() {
+        return this._priorityExtractor;
+    }
+    /**
+     * The function returns the size of a priority queue.
+     * @returns The size of the priority queue.
+     */
+    get size() {
+        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.
      */
-    Heap.prototype.isEmpty = function () {
+    isEmpty() {
         return this._pq.size < 1;
-    };
+    }
     /**
      * The `peek` function returns the top item in the priority queue without removing it.
      * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an val with the highest priority in the queue
      */
-    Heap.prototype.peek = function () {
+    peek() {
         return this._pq.peek();
-    };
+    }
     /**
      * The `peekLast` function returns the last item in the heap.
      * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an val with the lowest priority in the queue
      */
-    Heap.prototype.peekLast = function () {
+    peekLast() {
         return this._pq.leaf();
-    };
+    }
     /**
      * The `add` function adds an val to a priority queue with an optional priority value.
      * @param {T} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
@@ -112,7 +89,7 @@ var Heap = /** @class */ (function () {
      * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    Heap.prototype.add = function (val, priority) {
+    add(val, priority) {
         if (typeof val === 'number') {
             priority = val;
         }
@@ -128,49 +105,48 @@ var Heap = /** @class */ (function () {
             throw new Error('.add expects a numeric priority '
                 + 'or a constructor callback that returns a number');
         }
-        var _priority = !Number.isNaN(+priority) ? priority : this._priorityExtractor(val);
+        const _priority = !Number.isNaN(+priority) ? priority : this._priorityExtractor(val);
         this._pq.add(new HeapItem(_priority, val));
         return this;
-    };
+    }
     /**
      * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an val with the highest priority in the queue
      * @returns either a HeapItem<T> object or null.
      */
-    Heap.prototype.poll = function () {
-        var top = this._pq.poll();
+    poll() {
+        const top = this._pq.poll();
         if (!top) {
             return null;
         }
         return top;
-    };
+    }
     /**
      * The function checks if a given node or value exists in the priority queue.
      * @param {T | HeapItem<T>} node - The parameter `node` can be of type `T` or `HeapItem<T>`.
      * @returns a boolean value.
      */
-    Heap.prototype.has = function (node) {
+    has(node) {
         if (node instanceof HeapItem) {
             return this.pq.getNodes().includes(node);
         }
         else {
-            return this.pq.getNodes().findIndex(function (item) {
+            return this.pq.getNodes().findIndex(item => {
                 return item.val === node;
             }) !== -1;
         }
-    };
+    }
     /**
      * The `toArray` function returns an array of `HeapItem<T>` objects.
      * @returns An array of HeapItem<T> objects.Returns a sorted list of vals
      */
-    Heap.prototype.toArray = function () {
+    toArray() {
         return this._pq.toArray();
-    };
+    }
     /**
      * The clear function clears the priority queue.
      */
-    Heap.prototype.clear = function () {
+    clear() {
         this._pq.clear();
-    };
-    return Heap;
-}());
+    }
+}
 exports.Heap = Heap;

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

@@ -6,43 +6,25 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-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.MaxHeap = void 0;
-var heap_1 = require("./heap");
-var priority_queue_1 = require("../priority-queue");
+const heap_1 = require("./heap");
+const priority_queue_1 = require("../priority-queue");
 /**
  * @class MaxHeap
  * @extends Heap
  */
-var MaxHeap = /** @class */ (function (_super) {
-    __extends(MaxHeap, _super);
+class MaxHeap extends heap_1.Heap {
     /**
      * The constructor initializes a PriorityQueue with a custom comparator function.
      * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
      * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
      */
-    function MaxHeap(options) {
-        var _this = _super.call(this, options) || this;
-        _this._pq = new priority_queue_1.PriorityQueue({
-            comparator: function (a, b) { return b.priority - a.priority; }
+    constructor(options) {
+        super(options);
+        this._pq = new priority_queue_1.PriorityQueue({
+            comparator: (a, b) => b.priority - a.priority
         });
-        return _this;
     }
-    return MaxHeap;
-}(heap_1.Heap));
+}
 exports.MaxHeap = MaxHeap;

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

@@ -6,44 +6,26 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-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.MinHeap = void 0;
-var heap_1 = require("./heap");
-var priority_queue_1 = require("../priority-queue");
+const heap_1 = require("./heap");
+const priority_queue_1 = require("../priority-queue");
 /**
  * @class MinHeap
  * @extends Heap
  */
-var MinHeap = /** @class */ (function (_super) {
-    __extends(MinHeap, _super);
+class MinHeap extends heap_1.Heap {
     /**
      * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem
      * objects.
      * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
      * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
      */
-    function MinHeap(options) {
-        var _this = _super.call(this, options) || this;
-        _this._pq = new priority_queue_1.PriorityQueue({
-            comparator: function (a, b) { return a.priority - b.priority; }
+    constructor(options) {
+        super(options);
+        this._pq = new priority_queue_1.PriorityQueue({
+            comparator: (a, b) => a.priority - b.priority
         });
-        return _this;
     }
-    return MinHeap;
-}(heap_1.Heap));
+}
 exports.MinHeap = MinHeap;