bard-legends-framework 0.9.6 → 0.9.7

package/dist/utilities/libraries/binary-heap/binary-heap.d.ts

@@ -1,13 +1,13 @@
 export declare class BinaryHeap<T> {
-    private heap;
-    private map;
-    get size(): number;
-    private comparator;
-    private comparatorOrEqual;
-    constructor(type?: 'min' | 'max');
-    add(priority: number, item: T): void;
-    delete(item: T): boolean;
-    pop(): T | undefined;
-    private bubbleUp;
-    private bubbleDown;
+  private heap;
+  private map;
+  get size(): number;
+  private comparator;
+  private comparatorOrEqual;
+  constructor(type?: 'min' | 'max');
+  add(priority: number, item: T): void;
+  delete(item: T): boolean;
+  pop(): T | undefined;
+  private bubbleUp;
+  private bubbleDown;
 }

package/dist/utilities/libraries/binary-heap/binary-heap.js

@@ -1,94 +1,92 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.BinaryHeap = void 0;
 class BinaryHeapNode {
-    constructor(priority, item, index) {
-        this.priority = priority;
-        this.item = item;
-        this.index = index;
-    }
+  constructor(priority, item, index) {
+    this.priority = priority;
+    this.item = item;
+    this.index = index;
+  }
 }
 class BinaryHeap {
-    get size() {
-        return this.heap.length;
-    }
-    constructor(type = 'min') {
-        this.heap = [];
-        this.map = new Map(); // Map to keep track of items and their indices
-        this.comparator = (a, b) => a.priority < b.priority;
-        this.comparatorOrEqual = (a, b) => a.priority <= b.priority;
-        if (type === 'max') {
-            this.comparator = (a, b) => a.priority > b.priority;
-            this.comparatorOrEqual = (a, b) => a.priority >= b.priority;
-        }
+  get size() {
+    return this.heap.length;
+  }
+  constructor(type = 'min') {
+    this.heap = [];
+    this.map = new Map(); // Map to keep track of items and their indices
+    this.comparator = (a, b) => a.priority < b.priority;
+    this.comparatorOrEqual = (a, b) => a.priority <= b.priority;
+    if (type === 'max') {
+      this.comparator = (a, b) => a.priority > b.priority;
+      this.comparatorOrEqual = (a, b) => a.priority >= b.priority;
     }
-    add(priority, item) {
-        let node = new BinaryHeapNode(priority, item, this.heap.length);
-        this.heap.push(node);
-        this.map.set(item, node);
+  }
+  add(priority, item) {
+    const node = new BinaryHeapNode(priority, item, this.heap.length);
+    this.heap.push(node);
+    this.map.set(item, node);
+    this.bubbleUp(node.index);
+  }
+  delete(item) {
+    const node = this.map.get(item);
+    if (node) {
+      const lastNode = this.heap.pop();
+      if (this.heap.length > 0) {
+        this.heap[node.index] = lastNode;
+        lastNode.index = node.index; // Update the index of the last node
+        this.map.set(lastNode.item, lastNode); // Update the map
+        this.bubbleDown(node.index);
         this.bubbleUp(node.index);
+      }
+      this.map.delete(item); // Remove the item from the map
+      return true;
+    } else {
+      return false;
+    }
+  }
+  pop() {
+    if (this.heap.length > 0) {
+      const topNode = this.heap[0];
+      const lastNode = this.heap.pop();
+      if (this.heap.length > 0) {
+        this.heap[0] = lastNode;
+        lastNode.index = 0; // Update the index of the last node
+        this.map.set(lastNode.item, lastNode); // Update the map
+        this.bubbleDown(0);
+      }
+      this.map.delete(topNode.item); // Remove the popped item from the map
+      return topNode.item;
     }
-    delete(item) {
-        let node = this.map.get(item);
-        if (node) {
-            let lastNode = this.heap.pop();
-            if (this.heap.length > 0) {
-                this.heap[node.index] = lastNode;
-                lastNode.index = node.index; // Update the index of the last node
-                this.map.set(lastNode.item, lastNode); // Update the map
-                this.bubbleDown(node.index);
-                this.bubbleUp(node.index);
-            }
-            this.map.delete(item); // Remove the item from the map
-            return true;
-        }
-        else {
-            return false;
-        }
+  }
+  bubbleUp(index) {
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2);
+      if (this.comparatorOrEqual(this.heap[parentIndex], this.heap[index])) {
+        break;
+      }
+      [this.heap[parentIndex], this.heap[index]] = [this.heap[index], this.heap[parentIndex]];
+      this.heap[parentIndex].index = parentIndex;
+      this.heap[index].index = index;
+      index = parentIndex;
     }
-    pop() {
-        if (this.heap.length > 0) {
-            let topNode = this.heap[0];
-            let lastNode = this.heap.pop();
-            if (this.heap.length > 0) {
-                this.heap[0] = lastNode;
-                lastNode.index = 0; // Update the index of the last node
-                this.map.set(lastNode.item, lastNode); // Update the map
-                this.bubbleDown(0);
-            }
-            this.map.delete(topNode.item); // Remove the popped item from the map
-            return topNode.item;
-        }
+  }
+  bubbleDown(index) {
+    const leftChildIndex = 2 * index + 1;
+    const rightChildIndex = 2 * index + 2;
+    let currentIndex = index;
+    if (leftChildIndex < this.heap.length && this.comparator(this.heap[leftChildIndex], this.heap[currentIndex])) {
+      currentIndex = leftChildIndex;
     }
-    bubbleUp(index) {
-        while (index > 0) {
-            let parentIndex = Math.floor((index - 1) / 2);
-            if (this.comparatorOrEqual(this.heap[parentIndex], this.heap[index])) {
-                break;
-            }
-            [this.heap[parentIndex], this.heap[index]] = [this.heap[index], this.heap[parentIndex]];
-            this.heap[parentIndex].index = parentIndex;
-            this.heap[index].index = index;
-            index = parentIndex;
-        }
+    if (rightChildIndex < this.heap.length && this.comparator(this.heap[rightChildIndex], this.heap[currentIndex])) {
+      currentIndex = rightChildIndex;
     }
-    bubbleDown(index) {
-        let leftChildIndex = 2 * index + 1;
-        let rightChildIndex = 2 * index + 2;
-        let currentIndex = index;
-        if (leftChildIndex < this.heap.length && this.comparator(this.heap[leftChildIndex], this.heap[currentIndex])) {
-            currentIndex = leftChildIndex;
-        }
-        if (rightChildIndex < this.heap.length && this.comparator(this.heap[rightChildIndex], this.heap[currentIndex])) {
-            currentIndex = rightChildIndex;
-        }
-        if (currentIndex !== index) {
-            [this.heap[index], this.heap[currentIndex]] = [this.heap[currentIndex], this.heap[index]];
-            this.heap[index].index = index;
-            this.heap[currentIndex].index = currentIndex;
-            this.bubbleDown(currentIndex);
-        }
+    if (currentIndex !== index) {
+      [this.heap[index], this.heap[currentIndex]] = [this.heap[currentIndex], this.heap[index]];
+      this.heap[index].index = index;
+      this.heap[currentIndex].index = currentIndex;
+      this.bubbleDown(currentIndex);
     }
+  }
 }
 exports.BinaryHeap = BinaryHeap;
 /*
@@ -109,4 +107,4 @@ time complexity for the delete function  as well?
 Prompt:
 I want to get the lowest priority items, could you convert the max max binary heap to min binary heap?
 */
-//# sourceMappingURL=binary-heap.js.map
+//# sourceMappingURL=binary-heap.js.map

package/dist/utilities/libraries/data-structures/binary-heap/binary-heap.d.ts

@@ -1,13 +1,13 @@
 export declare class BinaryHeap<T> {
-    private heap;
-    private map;
-    get size(): number;
-    private comparator;
-    private comparatorOrEqual;
-    constructor(type?: 'min' | 'max');
-    add(priority: number, item: T): void;
-    delete(item: T): boolean;
-    pop(): T | undefined;
-    private bubbleUp;
-    private bubbleDown;
+  private heap;
+  private map;
+  get size(): number;
+  private comparator;
+  private comparatorOrEqual;
+  constructor(type?: 'min' | 'max');
+  add(priority: number, item: T): void;
+  delete(item: T): boolean;
+  pop(): T | undefined;
+  private bubbleUp;
+  private bubbleDown;
 }

package/dist/utilities/libraries/data-structures/binary-heap/binary-heap.js

@@ -1,94 +1,92 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.BinaryHeap = void 0;
 class BinaryHeapNode {
-    constructor(priority, item, index) {
-        this.priority = priority;
-        this.item = item;
-        this.index = index;
-    }
+  constructor(priority, item, index) {
+    this.priority = priority;
+    this.item = item;
+    this.index = index;
+  }
 }
 class BinaryHeap {
-    get size() {
-        return this.heap.length;
-    }
-    constructor(type = 'min') {
-        this.heap = [];
-        this.map = new Map();
-        this.comparator = (a, b) => a.priority < b.priority;
-        this.comparatorOrEqual = (a, b) => a.priority <= b.priority;
-        if (type === 'max') {
-            this.comparator = (a, b) => a.priority > b.priority;
-            this.comparatorOrEqual = (a, b) => a.priority >= b.priority;
-        }
+  get size() {
+    return this.heap.length;
+  }
+  constructor(type = 'min') {
+    this.heap = [];
+    this.map = new Map();
+    this.comparator = (a, b) => a.priority < b.priority;
+    this.comparatorOrEqual = (a, b) => a.priority <= b.priority;
+    if (type === 'max') {
+      this.comparator = (a, b) => a.priority > b.priority;
+      this.comparatorOrEqual = (a, b) => a.priority >= b.priority;
     }
-    add(priority, item) {
-        let node = new BinaryHeapNode(priority, item, this.heap.length);
-        this.heap.push(node);
-        this.map.set(item, node);
+  }
+  add(priority, item) {
+    const node = new BinaryHeapNode(priority, item, this.heap.length);
+    this.heap.push(node);
+    this.map.set(item, node);
+    this.bubbleUp(node.index);
+  }
+  delete(item) {
+    const node = this.map.get(item);
+    if (node) {
+      const lastNode = this.heap.pop();
+      if (this.heap.length > 0) {
+        this.heap[node.index] = lastNode;
+        lastNode.index = node.index;
+        this.map.set(lastNode.item, lastNode);
+        this.bubbleDown(node.index);
         this.bubbleUp(node.index);
+      }
+      this.map.delete(item);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  pop() {
+    if (this.heap.length > 0) {
+      const topNode = this.heap[0];
+      const lastNode = this.heap.pop();
+      if (this.heap.length > 0) {
+        this.heap[0] = lastNode;
+        lastNode.index = 0;
+        this.map.set(lastNode.item, lastNode);
+        this.bubbleDown(0);
+      }
+      this.map.delete(topNode.item);
+      return topNode.item;
     }
-    delete(item) {
-        let node = this.map.get(item);
-        if (node) {
-            let lastNode = this.heap.pop();
-            if (this.heap.length > 0) {
-                this.heap[node.index] = lastNode;
-                lastNode.index = node.index;
-                this.map.set(lastNode.item, lastNode);
-                this.bubbleDown(node.index);
-                this.bubbleUp(node.index);
-            }
-            this.map.delete(item);
-            return true;
-        }
-        else {
-            return false;
-        }
+  }
+  bubbleUp(index) {
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2);
+      if (this.comparatorOrEqual(this.heap[parentIndex], this.heap[index])) {
+        break;
+      }
+      [this.heap[parentIndex], this.heap[index]] = [this.heap[index], this.heap[parentIndex]];
+      this.heap[parentIndex].index = parentIndex;
+      this.heap[index].index = index;
+      index = parentIndex;
     }
-    pop() {
-        if (this.heap.length > 0) {
-            let topNode = this.heap[0];
-            let lastNode = this.heap.pop();
-            if (this.heap.length > 0) {
-                this.heap[0] = lastNode;
-                lastNode.index = 0;
-                this.map.set(lastNode.item, lastNode);
-                this.bubbleDown(0);
-            }
-            this.map.delete(topNode.item);
-            return topNode.item;
-        }
+  }
+  bubbleDown(index) {
+    const leftChildIndex = 2 * index + 1;
+    const rightChildIndex = 2 * index + 2;
+    let currentIndex = index;
+    if (leftChildIndex < this.heap.length && this.comparator(this.heap[leftChildIndex], this.heap[currentIndex])) {
+      currentIndex = leftChildIndex;
     }
-    bubbleUp(index) {
-        while (index > 0) {
-            let parentIndex = Math.floor((index - 1) / 2);
-            if (this.comparatorOrEqual(this.heap[parentIndex], this.heap[index])) {
-                break;
-            }
-            [this.heap[parentIndex], this.heap[index]] = [this.heap[index], this.heap[parentIndex]];
-            this.heap[parentIndex].index = parentIndex;
-            this.heap[index].index = index;
-            index = parentIndex;
-        }
+    if (rightChildIndex < this.heap.length && this.comparator(this.heap[rightChildIndex], this.heap[currentIndex])) {
+      currentIndex = rightChildIndex;
     }
-    bubbleDown(index) {
-        let leftChildIndex = 2 * index + 1;
-        let rightChildIndex = 2 * index + 2;
-        let currentIndex = index;
-        if (leftChildIndex < this.heap.length && this.comparator(this.heap[leftChildIndex], this.heap[currentIndex])) {
-            currentIndex = leftChildIndex;
-        }
-        if (rightChildIndex < this.heap.length && this.comparator(this.heap[rightChildIndex], this.heap[currentIndex])) {
-            currentIndex = rightChildIndex;
-        }
-        if (currentIndex !== index) {
-            [this.heap[index], this.heap[currentIndex]] = [this.heap[currentIndex], this.heap[index]];
-            this.heap[index].index = index;
-            this.heap[currentIndex].index = currentIndex;
-            this.bubbleDown(currentIndex);
-        }
+    if (currentIndex !== index) {
+      [this.heap[index], this.heap[currentIndex]] = [this.heap[currentIndex], this.heap[index]];
+      this.heap[index].index = index;
+      this.heap[currentIndex].index = currentIndex;
+      this.bubbleDown(currentIndex);
     }
+  }
 }
 exports.BinaryHeap = BinaryHeap;
 /*
@@ -109,4 +107,4 @@ time complexity for the delete function  as well?
 Prompt:
 I want to get the lowest priority items, could you convert the max max binary heap to min binary heap?
 */
-//# sourceMappingURL=binary-heap.js.map
+//# sourceMappingURL=binary-heap.js.map

package/dist/utilities/libraries/data-structures/grid/grid.d.ts

@@ -1,34 +1,38 @@
 import { Rectangle, Vector } from 'helpers-lib';
 export declare class Grid<T> {
-    static createByValues<T>(values: T[][]): Grid<T>;
-    static createNew<T>(size: Vector, defaultValue: T): Grid<T>;
-    static getNeighborDirections(options?: {
-        includeDiagonals: boolean;
-    }): Vector[];
-    static getDiagonalNeighborDirections(): Vector[];
-    static vectorToNeighborDirection(vector: Vector, options?: {
-        includeDiagonals: boolean;
-    }): Vector;
-    private _size;
-    private _grid;
-    get size(): Vector;
-    get width(): number;
-    get height(): number;
-    private constructor();
-    has(position: Vector): boolean;
-    get(position: Vector): T;
-    set(position: Vector, value: T): void;
-    safeSetArea(area: Rectangle, value: T): void;
-    setArea(area: Rectangle, value: T): void;
-    forEach(callback: (value: T, position: Vector) => void): void;
-    map<U>(callback: (value: T, position: Vector) => U): Grid<U>;
-    isAreaWithinBounds(area: Rectangle): boolean;
-    isPointWithinBounds(point: Vector): boolean;
-    cropPartsOutsideOfTheGrid(area: Rectangle): Rectangle;
-    moveAreaInsideGrid(area: Rectangle): Rectangle;
-    movePositionInsideGrid(point: Vector): Vector;
-    getNeighborPositions(position: Vector, options?: {
-        includeDiagonals: boolean;
-    }): Vector[];
-    getDiagonalNeighborPositions(position: Vector): Vector[];
+  static createByValues<T>(values: T[][]): Grid<T>;
+  static createNew<T>(size: Vector, defaultValue: T): Grid<T>;
+  static getNeighborDirections(options?: { includeDiagonals: boolean }): Vector[];
+  static getDiagonalNeighborDirections(): Vector[];
+  static vectorToNeighborDirection(
+    vector: Vector,
+    options?: {
+      includeDiagonals: boolean;
+    }
+  ): Vector;
+  private _size;
+  private _grid;
+  get size(): Vector;
+  get width(): number;
+  get height(): number;
+  private constructor();
+  has(position: Vector): boolean;
+  get(position: Vector): T;
+  set(position: Vector, value: T): void;
+  safeSetArea(area: Rectangle, value: T): void;
+  setArea(area: Rectangle, value: T): void;
+  forEach(callback: (value: T, position: Vector) => void): void;
+  map<U>(callback: (value: T, position: Vector) => U): Grid<U>;
+  isAreaWithinBounds(area: Rectangle): boolean;
+  isPointWithinBounds(point: Vector): boolean;
+  cropPartsOutsideOfTheGrid(area: Rectangle): Rectangle;
+  moveAreaInsideGrid(area: Rectangle): Rectangle;
+  movePositionInsideGrid(point: Vector): Vector;
+  getNeighborPositions(
+    position: Vector,
+    options?: {
+      includeDiagonals: boolean;
+    }
+  ): Vector[];
+  getDiagonalNeighborPositions(position: Vector): Vector[];
 }