bard-legends-framework 0.9.6 → 0.9.7

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

@@ -1,143 +1,220 @@
-"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(new helpers_lib_1.Vector(3, 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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(1, 1)), false);
-        (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(0, 0))).toBeFalsy();
-        (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(0, 1))).toBeFalsy();
-        (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(1, 0))).toBeFalsy();
-        (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(1, 1))).toBeFalsy();
-    });
-    (0, vitest_1.test)('should throw an error if area is outside of the grid', () => {
-        (0, vitest_1.expect)(() => grid.setArea(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(3, 3)), false)).toThrow();
-    });
-    (0, vitest_1.test)('should crop area outside of the grid 1', () => {
-        (0, vitest_1.expect)(grid.cropPartsOutsideOfTheGrid(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(-1, -1), new helpers_lib_1.Vector(3, 3))).toRect()).toStrictEqual({
-            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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(3, 3), new helpers_lib_1.Vector(4, 4))).toRect()).toStrictEqual({
-            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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(-1, -1), new helpers_lib_1.Vector(-1, -1))).toRect()).toStrictEqual({
-            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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(1, 1)))).toBeTruthy();
-        (0, vitest_1.expect)(grid.isAreaWithinBounds(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(3, 3)))).toBeFalsy();
-    });
-    (0, vitest_1.test)('should check if point is within bounds', () => {
-        (0, vitest_1.expect)(grid.isPointWithinBounds(new helpers_lib_1.Vector(0, 0))).toBeTruthy();
-        (0, vitest_1.expect)(grid.isPointWithinBounds(new helpers_lib_1.Vector(1, 1))).toBeTruthy();
-        (0, vitest_1.expect)(grid.isPointWithinBounds(new helpers_lib_1.Vector(3, 3))).toBeFalsy();
-    });
-    (0, vitest_1.test)('should set area within bounds', () => {
-        grid.safeSetArea(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(3, 3)), false);
-        (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(0, 0))).toBeFalsy();
-        (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(0, 1))).toBeFalsy();
-        (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(1, 0))).toBeFalsy();
-        (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(1, 1))).toBeFalsy();
-    });
-    (0, vitest_1.test)('should return neighbor positions only adjacent', () => {
-        (0, vitest_1.expect)(grid.getNeighborPositions(new helpers_lib_1.Vector(1, 1)).map(item => item.toVec2())).toStrictEqual([
-            { 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(new helpers_lib_1.Vector(1, 1), { includeDiagonals: true }).map(item => item.toVec2())).toStrictEqual([
-            { 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(new helpers_lib_1.Vector(2, 2)).map(item => item.toVec2())).toStrictEqual([
-            { 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(new helpers_lib_1.Vector(0, 0), { includeDiagonals: true }).map(item => item.toVec2())).toStrictEqual([
-            { x: 0, y: 1 },
-            { x: 1, y: 0 },
-            { x: 1, y: 1 }
-        ]);
-    });
-    (0, vitest_1.test)('should iterate over all values', () => {
-        grid.setArea(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(1, 0), new helpers_lib_1.Vector(1, 1)), false);
-        let values = [];
-        grid.forEach((value, position) => values.push({ value, position }));
-        (0, vitest_1.expect)(values.map(item => ({ value: item.value, position: item.position.toVec2() }))).toStrictEqual([
-            { 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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(1, 0), new helpers_lib_1.Vector(1, 1)), false);
-        let newGrid = grid.map((value, position) => (position.x + position.y) * (value ? 1 : -1));
-        (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(0, 0))).toBe(0);
-        (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(1, 0))).toBe(-1);
-        (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(2, 0))).toBe(2);
-        (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(0, 1))).toBe(1);
-        (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(1, 1))).toBe(-2);
-        (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(2, 1))).toBe(3);
-        (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(0, 2))).toBe(2);
-        (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(1, 2))).toBe(3);
-        (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(2, 2))).toBe(4);
-        (0, vitest_1.expect)(newGrid.size.toVec2()).toStrictEqual({ x: 3, y: 3 });
-    });
-    (0, vitest_1.test)('should find the neighbor direction from a vector', () => {
-        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0, 1)).toVec2()).toStrictEqual({ x: 0, y: 1 });
-        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(1, 0)).toVec2()).toStrictEqual({ x: 1, y: 0 });
-        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0, -1)).toVec2()).toStrictEqual({ x: 0, y: -1 });
-        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(-1, 0)).toVec2()).toStrictEqual({ x: -1, y: 0 });
-        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0.5, 2)).toVec2()).toStrictEqual({ x: 0, y: 1 });
-        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(2, -0.5)).toVec2()).toStrictEqual({ x: 1, y: -0 });
-        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0.5, -2)).toVec2()).toStrictEqual({ x: 0, y: -1 });
-        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(-2, -0.5)).toVec2()).toStrictEqual({ x: -1, y: -0 });
-        let middle = grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(1, 1));
-        (0, vitest_1.expect)(helpers_lib_1.Vector.isEqual(middle, new helpers_lib_1.Vector(0, 1)) || helpers_lib_1.Vector.isEqual(middle, new helpers_lib_1.Vector(1, 0))).toBeTruthy();
-    });
-    (0, vitest_1.test)('should find the neighbor direction with diagonals from a vector', () => {
-        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0, 1), { includeDiagonals: true }).toVec2()).toStrictEqual({ x: 0, y: 1 });
-        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(1, 1), { includeDiagonals: true }).toVec2()).toStrictEqual({ x: 1, y: 1 });
-        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(-1, -1), { includeDiagonals: true }).toVec2()).toStrictEqual({
-            x: -1,
-            y: -1
-        });
-        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(2, 1), { includeDiagonals: true }).toVec2()).toStrictEqual({ x: 1, y: 0 });
-    });
+  let grid;
+  (0, vitest_1.beforeEach)(() => {
+    grid = grid_1.Grid.createNew(new helpers_lib_1.Vector(3, 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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(1, 1)), false);
+    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(0, 0))).toBeFalsy();
+    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(0, 1))).toBeFalsy();
+    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(1, 0))).toBeFalsy();
+    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(1, 1))).toBeFalsy();
+  });
+  (0, vitest_1.test)('should throw an error if area is outside of the grid', () => {
+    (0, vitest_1.expect)(() =>
+      grid.setArea(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(3, 3)), false)
+    ).toThrow();
+  });
+  (0, vitest_1.test)('should crop area outside of the grid 1', () => {
+    (0, vitest_1.expect)(
+      grid
+        .cropPartsOutsideOfTheGrid(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(-1, -1), new helpers_lib_1.Vector(3, 3)))
+        .toRect()
+    ).toStrictEqual({
+      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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(3, 3), new helpers_lib_1.Vector(4, 4)))
+        .toRect()
+    ).toStrictEqual({
+      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(
+          new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(-1, -1), new helpers_lib_1.Vector(-1, -1))
+        )
+        .toRect()
+    ).toStrictEqual({
+      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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(1, 1)))
+    ).toBeTruthy();
+    (0, vitest_1.expect)(
+      grid.isAreaWithinBounds(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(3, 3)))
+    ).toBeFalsy();
+  });
+  (0, vitest_1.test)('should check if point is within bounds', () => {
+    (0, vitest_1.expect)(grid.isPointWithinBounds(new helpers_lib_1.Vector(0, 0))).toBeTruthy();
+    (0, vitest_1.expect)(grid.isPointWithinBounds(new helpers_lib_1.Vector(1, 1))).toBeTruthy();
+    (0, vitest_1.expect)(grid.isPointWithinBounds(new helpers_lib_1.Vector(3, 3))).toBeFalsy();
+  });
+  (0, vitest_1.test)('should set area within bounds', () => {
+    grid.safeSetArea(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(3, 3)), false);
+    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(0, 0))).toBeFalsy();
+    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(0, 1))).toBeFalsy();
+    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(1, 0))).toBeFalsy();
+    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(1, 1))).toBeFalsy();
+  });
+  (0, vitest_1.test)('should return neighbor positions only adjacent', () => {
+    (0, vitest_1.expect)(grid.getNeighborPositions(new helpers_lib_1.Vector(1, 1)).map(item => item.toVec2())).toStrictEqual([
+      { 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(new helpers_lib_1.Vector(1, 1), {
+          includeDiagonals: true
+        })
+        .map(item => item.toVec2())
+    ).toStrictEqual([
+      { 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(new helpers_lib_1.Vector(2, 2)).map(item => item.toVec2())).toStrictEqual([
+      { 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(new helpers_lib_1.Vector(0, 0), {
+          includeDiagonals: true
+        })
+        .map(item => item.toVec2())
+    ).toStrictEqual([
+      { x: 0, y: 1 },
+      { x: 1, y: 0 },
+      { x: 1, y: 1 }
+    ]);
+  });
+  (0, vitest_1.test)('should iterate over all values', () => {
+    grid.setArea(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(1, 0), new helpers_lib_1.Vector(1, 1)), false);
+    const values = [];
+    grid.forEach((value, position) => values.push({ value, position }));
+    (0, vitest_1.expect)(
+      values.map(item => ({
+        value: item.value,
+        position: item.position.toVec2()
+      }))
+    ).toStrictEqual([
+      { 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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(1, 0), new helpers_lib_1.Vector(1, 1)), false);
+    const newGrid = grid.map((value, position) => (position.x + position.y) * (value ? 1 : -1));
+    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(0, 0))).toBe(0);
+    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(1, 0))).toBe(-1);
+    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(2, 0))).toBe(2);
+    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(0, 1))).toBe(1);
+    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(1, 1))).toBe(-2);
+    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(2, 1))).toBe(3);
+    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(0, 2))).toBe(2);
+    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(1, 2))).toBe(3);
+    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(2, 2))).toBe(4);
+    (0, vitest_1.expect)(newGrid.size.toVec2()).toStrictEqual({ x: 3, y: 3 });
+  });
+  (0, vitest_1.test)('should find the neighbor direction from a vector', () => {
+    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0, 1)).toVec2()).toStrictEqual({
+      x: 0,
+      y: 1
+    });
+    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(1, 0)).toVec2()).toStrictEqual({
+      x: 1,
+      y: 0
+    });
+    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0, -1)).toVec2()).toStrictEqual({
+      x: 0,
+      y: -1
+    });
+    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(-1, 0)).toVec2()).toStrictEqual({
+      x: -1,
+      y: 0
+    });
+    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0.5, 2)).toVec2()).toStrictEqual({
+      x: 0,
+      y: 1
+    });
+    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(2, -0.5)).toVec2()).toStrictEqual({
+      x: 1,
+      y: -0
+    });
+    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0.5, -2)).toVec2()).toStrictEqual({
+      x: 0,
+      y: -1
+    });
+    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(-2, -0.5)).toVec2()).toStrictEqual({
+      x: -1,
+      y: -0
+    });
+    const middle = grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(1, 1));
+    (0, vitest_1.expect)(
+      helpers_lib_1.Vector.isEqual(middle, new helpers_lib_1.Vector(0, 1)) ||
+        helpers_lib_1.Vector.isEqual(middle, new helpers_lib_1.Vector(1, 0))
+    ).toBeTruthy();
+  });
+  (0, vitest_1.test)('should find the neighbor direction with diagonals from a vector', () => {
+    (0, vitest_1.expect)(
+      grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0, 1), {
+        includeDiagonals: true
+      }).toVec2()
+    ).toStrictEqual({ x: 0, y: 1 });
+    (0, vitest_1.expect)(
+      grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(1, 1), {
+        includeDiagonals: true
+      }).toVec2()
+    ).toStrictEqual({ x: 1, y: 1 });
+    (0, vitest_1.expect)(
+      grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(-1, -1), { includeDiagonals: true }).toVec2()
+    ).toStrictEqual({
+      x: -1,
+      y: -1
+    });
+    (0, vitest_1.expect)(
+      grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(2, 1), {
+        includeDiagonals: true
+      }).toVec2()
+    ).toStrictEqual({ x: 1, y: 0 });
+  });
 });
-//# sourceMappingURL=grid.test.js.map
+//# sourceMappingURL=grid.test.js.map

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

@@ -1,6 +1,6 @@
 import { Rectangle, Vector } from 'helpers-lib';
 export declare class PositionToGridPositionConverter {
-    static areaToGridArea(boundingBox: Rectangle, cellSize: number): Rectangle;
-    static positionToGridPosition(point: Vector, cellSize: number): Vector;
-    static gridPositionToPosition(gridPosition: Vector, cellSize: number): Vector;
+  static areaToGridArea(boundingBox: Rectangle, cellSize: number): Rectangle;
+  static positionToGridPosition(point: Vector, cellSize: number): Vector;
+  static gridPositionToPosition(gridPosition: Vector, cellSize: number): Vector;
 }

package/dist/utilities/libraries/data-structures/grid/position-to-grid-position-converter.js

@@ -1,17 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.PositionToGridPositionConverter = void 0;
-const helpers_lib_1 = require("helpers-lib");
+const helpers_lib_1 = require('helpers-lib');
 class PositionToGridPositionConverter {
-    static areaToGridArea(boundingBox, cellSize) {
-        return new helpers_lib_1.Rectangle(this.positionToGridPosition(boundingBox.topLeft, cellSize), this.positionToGridPosition(boundingBox.bottomRight, cellSize));
-    }
-    static positionToGridPosition(point, cellSize) {
-        return point.divideNumber(cellSize).floor();
-    }
-    static gridPositionToPosition(gridPosition, cellSize) {
-        return gridPosition.add(new helpers_lib_1.Vector(0.5, 0.5)).multiplyNumber(cellSize);
-    }
+  static areaToGridArea(boundingBox, cellSize) {
+    return new helpers_lib_1.Rectangle(
+      PositionToGridPositionConverter.positionToGridPosition(boundingBox.topLeft, cellSize),
+      PositionToGridPositionConverter.positionToGridPosition(boundingBox.bottomRight, cellSize)
+    );
+  }
+  static positionToGridPosition(point, cellSize) {
+    return point.divideNumber(cellSize).floor();
+  }
+  static gridPositionToPosition(gridPosition, cellSize) {
+    return gridPosition.add(new helpers_lib_1.Vector(0.5, 0.5)).multiplyNumber(cellSize);
+  }
 }
 exports.PositionToGridPositionConverter = PositionToGridPositionConverter;
-//# sourceMappingURL=position-to-grid-position-converter.js.map
+//# sourceMappingURL=position-to-grid-position-converter.js.map

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

@@ -1,23 +1,23 @@
 export declare class Queue<T> {
-    private start;
-    private end;
-    get isEmpty(): boolean;
-    constructor(firstNode?: T | undefined);
-    /**
-     * @param args The values to add to end of the queue
-     */
-    add(...args: T[]): void;
-    /**
-     * @returns The value of the first element in the queue
-     */
-    pop(): T | undefined;
-    /**
-     * @returns The value of the first element in the queue without removing it
-     */
-    peek(): T | undefined;
-    /**
-     * @param deepCopyItem An optional function that takes an item and returns a deep copy of it
-     * @returns The duplicated queue
-     */
-    duplicate(deepCopyItem?: (item: T) => T): Queue<T>;
+  private start;
+  private end;
+  get isEmpty(): boolean;
+  constructor(firstNode?: T | undefined);
+  /**
+   * @param args The values to add to end of the queue
+   */
+  add(...args: T[]): void;
+  /**
+   * @returns The value of the first element in the queue
+   */
+  pop(): T | undefined;
+  /**
+   * @returns The value of the first element in the queue without removing it
+   */
+  peek(): T | undefined;
+  /**
+   * @param deepCopyItem An optional function that takes an item and returns a deep copy of it
+   * @returns The duplicated queue
+   */
+  duplicate(deepCopyItem?: (item: T) => T): Queue<T>;
 }

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

@@ -1,75 +1,72 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.Queue = void 0;
 class DoublyLinkedListNode {
-    constructor(value) {
-        this.value = value;
-    }
+  constructor(value) {
+    this.value = value;
+  }
 }
 class Queue {
-    get isEmpty() {
-        return this.start === undefined;
-    }
-    constructor(firstNode) {
-        if (firstNode) {
-            let firstNodeInstance = new DoublyLinkedListNode(firstNode);
-            this.start = firstNodeInstance;
-            this.end = firstNodeInstance;
-        }
-    }
-    /**
-     * @param args The values to add to end of the queue
-     */
-    add(...args) {
-        args.forEach(value => {
-            let newNode = new DoublyLinkedListNode(value);
-            if (this.start) {
-                newNode.previous = this.end;
-                this.end.next = newNode;
-                this.end = newNode;
-            }
-            else {
-                this.start = newNode;
-                this.end = newNode;
-            }
-        });
-    }
-    /**
-     * @returns The value of the first element in the queue
-     */
-    pop() {
-        if (this.start) {
-            let value = this.start.value;
-            this.start = this.start.next;
-            if (this.start) {
-                this.start.previous = undefined;
-            }
-            else {
-                this.end = undefined;
-            }
-            return value;
-        }
+  get isEmpty() {
+    return this.start === undefined;
+  }
+  constructor(firstNode) {
+    if (firstNode) {
+      const firstNodeInstance = new DoublyLinkedListNode(firstNode);
+      this.start = firstNodeInstance;
+      this.end = firstNodeInstance;
     }
-    /**
-     * @returns The value of the first element in the queue without removing it
-     */
-    peek() {
-        return this.start?.value;
+  }
+  /**
+   * @param args The values to add to end of the queue
+   */
+  add(...args) {
+    args.forEach(value => {
+      const newNode = new DoublyLinkedListNode(value);
+      if (this.start) {
+        newNode.previous = this.end;
+        this.end.next = newNode;
+        this.end = newNode;
+      } else {
+        this.start = newNode;
+        this.end = newNode;
+      }
+    });
+  }
+  /**
+   * @returns The value of the first element in the queue
+   */
+  pop() {
+    if (this.start) {
+      const value = this.start.value;
+      this.start = this.start.next;
+      if (this.start) {
+        this.start.previous = undefined;
+      } else {
+        this.end = undefined;
+      }
+      return value;
     }
-    /**
-     * @param deepCopyItem An optional function that takes an item and returns a deep copy of it
-     * @returns The duplicated queue
-     */
-    duplicate(deepCopyItem) {
-        let newQueue = new Queue();
-        let current = this.start;
-        while (current) {
-            let value = deepCopyItem ? deepCopyItem(current.value) : current.value;
-            newQueue.add(value);
-            current = current.next;
-        }
-        return newQueue;
+  }
+  /**
+   * @returns The value of the first element in the queue without removing it
+   */
+  peek() {
+    return this.start?.value;
+  }
+  /**
+   * @param deepCopyItem An optional function that takes an item and returns a deep copy of it
+   * @returns The duplicated queue
+   */
+  duplicate(deepCopyItem) {
+    const newQueue = new Queue();
+    let current = this.start;
+    while (current) {
+      const value = deepCopyItem ? deepCopyItem(current.value) : current.value;
+      newQueue.add(value);
+      current = current.next;
     }
+    return newQueue;
+  }
 }
 exports.Queue = Queue;
-//# sourceMappingURL=queue.js.map
+//# sourceMappingURL=queue.js.map