bard-legends-framework 0.9.5 → 0.9.7

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

@@ -1,122 +1,133 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+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 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) {
-        let 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) {
-        let 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) {
-        let 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) {
-        let 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) {
-        let topLeft = this.movePositionInsideGrid(area.topLeft);
-        let bottomRight = this.movePositionInsideGrid(area.bottomRight);
-        return new helpers_lib_1.Rectangle(topLeft, bottomRight);
-    }
-    moveAreaInsideGrid(area) {
-        let topLeft = this.movePositionInsideGrid(area.topLeft);
-        let bottomRight = this.movePositionInsideGrid(area.bottomRight);
-        return new helpers_lib_1.Rectangle(topLeft, bottomRight);
-    }
-    movePositionInsideGrid(point) {
-        let x = Math.max(0, Math.min(this._size.x - 1, point.x));
-        let 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 }) {
-        let 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));
-    }
+  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
+//# sourceMappingURL=grid.js.map

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

@@ -1,140 +1,178 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const helpers_lib_1 = require("helpers-lib");
-const vitest_1 = require("vitest");
-const grid_1 = require("./grid");
+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);
-        let 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);
-        let 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 });
-        let 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 });
-    });
+  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
+//# sourceMappingURL=grid.spec.js.map