bard-legends-framework 0.12.0 → 1.0.0-rc0

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

@@ -1,110 +0,0 @@
-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;
-  }
-}
-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;
-    }
-  }
-  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;
-    }
-  }
-  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;
-    }
-  }
-  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;
-    }
-    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);
-    }
-  }
-}
-exports.BinaryHeap = BinaryHeap;
-/*
-Prompt:
-Could you implement a "mutable priority queue" in typescript?
-abstract class MutablePriorityQueue<T> {
-  abstract add(priority: number, item: T): void;
-  abstract delete(priority: number, item: T): boolean;
-  abstract pop(): Node | undefined;
-  abstract size(): number;
-}
-Each function should maximum have "O(log(n))" time complexity.
-
-Promt:
-The delete function is running in O(n) time complexity. Could you change your implementation to achieve O(log(n))
-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

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

@@ -1,13 +0,0 @@
-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;
-}

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

@@ -1,110 +0,0 @@
-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;
-  }
-}
-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;
-    }
-  }
-  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;
-    }
-  }
-  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;
-    }
-  }
-  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;
-    }
-    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);
-    }
-  }
-}
-exports.BinaryHeap = BinaryHeap;
-/*
-Prompt:
-Could you implement a "mutable priority queue" in typescript?
-abstract class MutablePriorityQueue<T> {
-  abstract add(priority: number, item: T): void;
-  abstract delete(priority: number, item: T): boolean;
-  abstract pop(): Node | undefined;
-  abstract size(): number;
-}
-Each function should maximum have "O(log(n))" time complexity.
-
-Promt:
-The delete function is running in O(n) time complexity. Could you change your implementation to achieve O(log(n))
-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

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

@@ -1,38 +0,0 @@
-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[];
-}

package/dist/utilities/libraries/data-structures/grid/grid.js

@@ -1,133 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.Grid = void 0;
-const helpers_lib_1 = require('helpers-lib');
-const NEIGHBORS = [
-  new helpers_lib_1.Vector(-1, 0),
-  new helpers_lib_1.Vector(0, -1),
-  new helpers_lib_1.Vector(0, 1),
-  new helpers_lib_1.Vector(1, 0)
-];
-const DIAGONALS = [
-  new helpers_lib_1.Vector(-1, -1),
-  new helpers_lib_1.Vector(-1, 1),
-  new helpers_lib_1.Vector(1, -1),
-  new helpers_lib_1.Vector(1, 1)
-];
-const NEIGHBORS_INCLUDING_DIAGONALS = [...NEIGHBORS, ...DIAGONALS];
-class Grid {
-  static createByValues(values) {
-    const width = values[0].length;
-    values.forEach(row => {
-      if (row.length !== width) {
-        throw new Error(`Grid: All rows must have the same length. Expected: ${width}, got: ${row.length}`);
-      }
-    });
-    return new Grid(values);
-  }
-  static createNew(size, defaultValue) {
-    const values = Array(Math.floor(size.y))
-      .fill(undefined)
-      .map(() => Array(Math.floor(size.x)).fill(defaultValue));
-    return new Grid(values);
-  }
-  static getNeighborDirections(options) {
-    return options?.includeDiagonals ? NEIGHBORS_INCLUDING_DIAGONALS : NEIGHBORS;
-  }
-  static getDiagonalNeighborDirections() {
-    return DIAGONALS;
-  }
-  static vectorToNeighborDirection(vector, options) {
-    const roundedVector = vector.normalize().round();
-    if (!options?.includeDiagonals && roundedVector.x !== 0 && roundedVector.y !== 0) {
-      if (helpers_lib_1.Random.chance(0.5)) {
-        return new helpers_lib_1.Vector(0, roundedVector.y);
-      } else {
-        return new helpers_lib_1.Vector(roundedVector.x, 0);
-      }
-    } else {
-      return new helpers_lib_1.Vector(roundedVector.x, roundedVector.y);
-    }
-  }
-  get size() {
-    return this._size;
-  }
-  get width() {
-    return this._size.x;
-  }
-  get height() {
-    return this._size.y;
-  }
-  constructor(values) {
-    this._size = new helpers_lib_1.Vector(values[0].length, values.length);
-    this._grid = values;
-  }
-  has(position) {
-    return this.isPointWithinBounds(position) && this.get(position) !== undefined;
-  }
-  get(position) {
-    return this._grid[position.y][position.x];
-  }
-  set(position, value) {
-    if (!this.isPointWithinBounds(position)) {
-      throw new Error(`Grid: Point is outside of the grid: point: "${position}", grid-size: "${this._size}"`);
-    }
-    this._grid[position.y][position.x] = value;
-  }
-  safeSetArea(area, value) {
-    area = this.cropPartsOutsideOfTheGrid(area);
-    this.setArea(area, value);
-  }
-  setArea(area, value) {
-    if (!this.isAreaWithinBounds(area)) {
-      throw new Error(
-        `Grid: Area is outside of the grid: area: "${JSON.stringify(area)}", grid-size: "${JSON.stringify(this._size)}"`
-      );
-    }
-    for (let y = area.topLeft.y; y <= area.bottomRight.y && y < this._grid.length; y++) {
-      for (let x = area.topLeft.x; x <= area.bottomRight.x && x < this._grid[y].length; x++) {
-        this._grid[y][x] = value;
-      }
-    }
-  }
-  forEach(callback) {
-    this._grid.forEach((row, y) => row.forEach((value, x) => callback(value, new helpers_lib_1.Vector(x, y))));
-  }
-  map(callback) {
-    const newValues = this._grid.map((row, y) => row.map((value, x) => callback(value, new helpers_lib_1.Vector(x, y))));
-    return new Grid(newValues);
-  }
-  isAreaWithinBounds(area) {
-    return this.isPointWithinBounds(area.topLeft) && this.isPointWithinBounds(area.bottomRight);
-  }
-  isPointWithinBounds(point) {
-    return point.x >= 0 && point.y >= 0 && point.x < this._size.x && point.y < this._size.y;
-  }
-  cropPartsOutsideOfTheGrid(area) {
-    const topLeft = this.movePositionInsideGrid(area.topLeft);
-    const bottomRight = this.movePositionInsideGrid(area.bottomRight);
-    return new helpers_lib_1.Rectangle(topLeft, bottomRight);
-  }
-  moveAreaInsideGrid(area) {
-    const topLeft = this.movePositionInsideGrid(area.topLeft);
-    const bottomRight = this.movePositionInsideGrid(area.bottomRight);
-    return new helpers_lib_1.Rectangle(topLeft, bottomRight);
-  }
-  movePositionInsideGrid(point) {
-    const x = Math.max(0, Math.min(this._size.x - 1, point.x));
-    const y = Math.max(0, Math.min(this._size.y - 1, point.y));
-    return new helpers_lib_1.Vector(x, y);
-  }
-  getNeighborPositions(position, options = { includeDiagonals: false }) {
-    const neighbors = options.includeDiagonals ? NEIGHBORS_INCLUDING_DIAGONALS : NEIGHBORS;
-    return neighbors
-      .map(neighborDirection => new helpers_lib_1.Vector(position.x + neighborDirection.x, position.y + neighborDirection.y))
-      .filter(neighborPosition => this.isPointWithinBounds(neighborPosition));
-  }
-  getDiagonalNeighborPositions(position) {
-    return DIAGONALS.map(
-      neighborDirection => new helpers_lib_1.Vector(position.x + neighborDirection.x, position.y + neighborDirection.y)
-    ).filter(neighborPosition => this.isPointWithinBounds(neighborPosition));
-  }
-}
-exports.Grid = Grid;
-//# sourceMappingURL=grid.js.map

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

@@ -1 +0,0 @@
-export {};

package/dist/utilities/libraries/data-structures/grid/grid.spec.js

@@ -1,178 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-const helpers_lib_1 = require('helpers-lib');
-const vitest_1 = require('vitest');
-const grid_1 = require('./grid');
-(0, vitest_1.describe)('Grid', () => {
-  let grid;
-  (0, vitest_1.beforeEach)(() => {
-    grid = grid_1.Grid.createNew({ x: 3, y: 3 }, true);
-  });
-  (0, vitest_1.test)('should be defined', () => {
-    (0, vitest_1.expect)(grid).toBeDefined();
-  });
-  (0, vitest_1.test)('should set and get values', () => {
-    grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } }, false);
-    (0, vitest_1.expect)(grid.get({ x: 0, y: 0 })).toBeFalsy();
-    (0, vitest_1.expect)(grid.get({ x: 0, y: 1 })).toBeFalsy();
-    (0, vitest_1.expect)(grid.get({ x: 1, y: 0 })).toBeFalsy();
-    (0, vitest_1.expect)(grid.get({ x: 1, y: 1 })).toBeFalsy();
-  });
-  (0, vitest_1.test)('should throw an error if area is outside of the grid', () => {
-    (0, vitest_1.expect)(() => grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 3, y: 3 } }, false)).toThrow();
-  });
-  (0, vitest_1.test)('should crop area outside of the grid 1', () => {
-    (0, vitest_1.expect)(
-      grid.cropPartsOutsideOfTheGrid({
-        topLeft: { x: -1, y: -1 },
-        bottomRight: { x: 3, y: 3 }
-      })
-    ).toEqual({
-      topLeft: { x: 0, y: 0 },
-      bottomRight: { x: 2, y: 2 }
-    });
-  });
-  (0, vitest_1.test)('should crop area outside of the grid 2', () => {
-    (0, vitest_1.expect)(
-      grid.cropPartsOutsideOfTheGrid({
-        topLeft: { x: 3, y: 3 },
-        bottomRight: { x: 4, y: 4 }
-      })
-    ).toEqual({
-      topLeft: { x: 2, y: 2 },
-      bottomRight: { x: 2, y: 2 }
-    });
-  });
-  (0, vitest_1.test)('should crop area outside of the grid 2', () => {
-    (0, vitest_1.expect)(
-      grid.cropPartsOutsideOfTheGrid({
-        topLeft: { x: -1, y: -1 },
-        bottomRight: { x: -1, y: -1 }
-      })
-    ).toEqual({
-      topLeft: { x: 0, y: 0 },
-      bottomRight: { x: 0, y: 0 }
-    });
-  });
-  (0, vitest_1.test)('should check if area is within bounds', () => {
-    (0, vitest_1.expect)(
-      grid.isAreaWithinBounds({
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 1, y: 1 }
-      })
-    ).toBeTruthy();
-    (0, vitest_1.expect)(
-      grid.isAreaWithinBounds({
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 3, y: 3 }
-      })
-    ).toBeFalsy();
-  });
-  (0, vitest_1.test)('should check if point is within bounds', () => {
-    (0, vitest_1.expect)(grid.isPointWithinBounds({ x: 0, y: 0 })).toBeTruthy();
-    (0, vitest_1.expect)(grid.isPointWithinBounds({ x: 1, y: 1 })).toBeTruthy();
-    (0, vitest_1.expect)(grid.isPointWithinBounds({ x: 3, y: 3 })).toBeFalsy();
-  });
-  (0, vitest_1.test)('should set area within bounds', () => {
-    grid.safeSetArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 3, y: 3 } }, false);
-    (0, vitest_1.expect)(grid.get({ x: 0, y: 0 })).toBeFalsy();
-    (0, vitest_1.expect)(grid.get({ x: 0, y: 1 })).toBeFalsy();
-    (0, vitest_1.expect)(grid.get({ x: 1, y: 0 })).toBeFalsy();
-    (0, vitest_1.expect)(grid.get({ x: 1, y: 1 })).toBeFalsy();
-  });
-  (0, vitest_1.test)('should return neighbor positions only adjacent', () => {
-    (0, vitest_1.expect)(grid.getNeighborPositions({ x: 1, y: 1 })).toEqual([
-      { x: 0, y: 1 },
-      { x: 1, y: 0 },
-      { x: 1, y: 2 },
-      { x: 2, y: 1 }
-    ]);
-  });
-  (0, vitest_1.test)('should return neighbor positions with diagonals', () => {
-    (0, vitest_1.expect)(grid.getNeighborPositions({ x: 1, y: 1 }, { includeDiagonals: true })).toEqual([
-      { x: 0, y: 1 },
-      { x: 1, y: 0 },
-      { x: 1, y: 2 },
-      { x: 2, y: 1 },
-      { x: 0, y: 0 },
-      { x: 0, y: 2 },
-      { x: 2, y: 0 },
-      { x: 2, y: 2 }
-    ]);
-  });
-  (0, vitest_1.test)('should return neighbor positions only adjacent at the edge', () => {
-    (0, vitest_1.expect)(grid.getNeighborPositions({ x: 2, y: 2 })).toEqual([
-      { x: 1, y: 2 },
-      { x: 2, y: 1 }
-    ]);
-  });
-  (0, vitest_1.test)('should return neighbor positions at the edge with diagonals', () => {
-    (0, vitest_1.expect)(grid.getNeighborPositions({ x: 0, y: 0 }, { includeDiagonals: true })).toEqual([
-      { x: 0, y: 1 },
-      { x: 1, y: 0 },
-      { x: 1, y: 1 }
-    ]);
-  });
-  (0, vitest_1.test)('should iterate over all values', () => {
-    grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 1, y: 1 } }, false);
-    const values = [];
-    grid.forEach((value, position) => values.push({ value, position }));
-    (0, vitest_1.expect)(values).toEqual([
-      { value: true, position: { x: 0, y: 0 } },
-      { value: false, position: { x: 1, y: 0 } },
-      { value: true, position: { x: 2, y: 0 } },
-      { value: true, position: { x: 0, y: 1 } },
-      { value: false, position: { x: 1, y: 1 } },
-      { value: true, position: { x: 2, y: 1 } },
-      { value: true, position: { x: 0, y: 2 } },
-      { value: true, position: { x: 1, y: 2 } },
-      { value: true, position: { x: 2, y: 2 } }
-    ]);
-  });
-  (0, vitest_1.test)('should map over all values', () => {
-    grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 1, y: 1 } }, false);
-    const newGrid = grid.map((value, position) => (position.x + position.y) * (value ? 1 : -1));
-    (0, vitest_1.expect)(newGrid.get({ x: 0, y: 0 })).toBe(0);
-    (0, vitest_1.expect)(newGrid.get({ x: 1, y: 0 })).toBe(-1);
-    (0, vitest_1.expect)(newGrid.get({ x: 2, y: 0 })).toBe(2);
-    (0, vitest_1.expect)(newGrid.get({ x: 0, y: 1 })).toBe(1);
-    (0, vitest_1.expect)(newGrid.get({ x: 1, y: 1 })).toBe(-2);
-    (0, vitest_1.expect)(newGrid.get({ x: 2, y: 1 })).toBe(3);
-    (0, vitest_1.expect)(newGrid.get({ x: 0, y: 2 })).toBe(2);
-    (0, vitest_1.expect)(newGrid.get({ x: 1, y: 2 })).toBe(3);
-    (0, vitest_1.expect)(newGrid.get({ x: 2, y: 2 })).toBe(4);
-    (0, vitest_1.expect)(newGrid.size).toEqual({ x: 3, y: 3 });
-  });
-  (0, vitest_1.test)('should find the neighbor direction from a vector', () => {
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 0, y: 1 })).toEqual({ x: 0, y: 1 });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 1, y: 0 })).toEqual({ x: 1, y: 0 });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 0, y: -1 })).toEqual({ x: 0, y: -1 });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: -1, y: 0 })).toEqual({ x: -1, y: 0 });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 0.5, y: 2 })).toEqual({ x: 0, y: 1 });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 2, y: -0.5 })).toEqual({ x: 1, y: 0 });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 0.5, y: -2 })).toEqual({ x: 0, y: -1 });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: -2, y: -0.5 })).toEqual({ x: -1, y: 0 });
-    const middle = grid_1.Grid.vectorToNeighborDirection({ x: 1, y: 1 });
-    (0, vitest_1.expect)(
-      helpers_lib_1.Vector.isEqual(middle, { x: 0, y: 1 }) || helpers_lib_1.Vector.isEqual(middle, { x: 1, y: 0 })
-    ).toBeTruthy();
-  });
-  (0, vitest_1.test)('should find the neighbor direction with diagonals from a vector', () => {
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 0, y: 1 }, { includeDiagonals: true })).toEqual({
-      x: 0,
-      y: 1
-    });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 1, y: 1 }, { includeDiagonals: true })).toEqual({
-      x: 1,
-      y: 1
-    });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: -1, y: -1 }, { includeDiagonals: true })).toEqual({
-      x: -1,
-      y: -1
-    });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 2, y: 1 }, { includeDiagonals: true })).toEqual({
-      x: 1,
-      y: 0
-    });
-  });
-});
-//# sourceMappingURL=grid.spec.js.map

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

@@ -1 +0,0 @@
-export {};