@inglorious/engine 0.2.0 → 0.4.0

package/src/utils/algorithms/path-finding.test.js

@@ -1,151 +0,0 @@
-import {
-  createBoard,
-  down,
-  downRight,
-  right,
-} from "@inglorious/utils/data-structures/board.js"
-import { expect, test } from "vitest"
-
-import { findPath } from "./path-finding.js"
-
-test("it should find the shortest path in a trivial example", () => {
-  const graph = {
-    nodes: {
-      A: [0, 0],
-      B: [2, 0],
-    },
-    arcs: [{ from: "A", to: "B", cost: 2 }],
-  }
-  const start = "A"
-  const end = "B"
-  const expectedResult = ["A", "B"]
-
-  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
-})
-
-test("it should find the shortest path between two nodes with default heuristic", () => {
-  const graph = {
-    nodes: {
-      A: [0, 0],
-      B: [2, 0],
-      C: [3, 2],
-      D: [4, 4],
-      E: [1, 1],
-      F: [2, 3],
-      G: [0, 4],
-    },
-    arcs: [
-      { from: "A", to: "B" },
-      { from: "B", to: "C" },
-      { from: "C", to: "D" },
-      { from: "A", to: "E" },
-      { from: "E", to: "F" },
-      { from: "F", to: "G" },
-      { from: "G", to: "D" },
-    ],
-  }
-  const start = "A"
-  const end = "D"
-  const expectedResult = ["A", "B", "C", "D"]
-
-  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
-})
-
-test("it should find the shortest path between two nodes with node costs", () => {
-  const graph = {
-    nodes: [
-      { id: "A", position: [0, 0], cost: 0 },
-      { id: "B", position: [2, 0], cost: 7 },
-      { id: "C", position: [3, 2], cost: 3 },
-      { id: "D", position: [4, 4], cost: 2 },
-      { id: "E", position: [1, 1], cost: 1.5 },
-      { id: "F", position: [2, 3], cost: 2 },
-      { id: "G", position: [0, 4], cost: 3 },
-    ],
-    arcs: [
-      { from: "A", to: "B" },
-      { from: "B", to: "C" },
-      { from: "C", to: "D" },
-      { from: "A", to: "E" },
-      { from: "E", to: "F" },
-      { from: "F", to: "G" },
-      { from: "G", to: "D" },
-    ],
-  }
-  const start = "A"
-  const end = "D"
-  const expectedResult = ["A", "E", "F", "G", "D"]
-
-  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
-})
-
-test("it should find the shortest path between two nodes with arc costs", () => {
-  const graph = {
-    nodes: {
-      A: [0, 0],
-      B: [2, 0],
-      C: [3, 2],
-      D: [4, 4],
-      E: [1, 1],
-      F: [2, 3],
-      G: [0, 4],
-    },
-    arcs: [
-      { from: "A", to: "B", cost: 7 },
-      { from: "B", to: "C", cost: 3 },
-      { from: "C", to: "D", cost: 2 },
-      { from: "A", to: "E", cost: 1.5 },
-      { from: "E", to: "F", cost: 2 },
-      { from: "F", to: "G", cost: 3 },
-      { from: "G", to: "D", cost: 4 },
-    ],
-  }
-  const start = "A"
-  const end = "D"
-  const expectedResult = ["A", "E", "F", "G", "D"]
-
-  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
-})
-
-test("it should find the best path in a board graph", () => {
-  const rows = 5
-  const columns = 5
-  const size = [rows, columns]
-  const filler = (i, j) => ({ id: `${i}${j}`, position: [i, j] })
-  const board = createBoard(size, filler)
-
-  const graph = {
-    nodes: board,
-    arcs: [],
-  }
-
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < columns; j++) {
-      const current = `${i}${j}`
-      if (i + 1 < rows) {
-        graph.arcs.push({
-          from: current,
-          to: down([i, j], size).join(""),
-        })
-      }
-      if (j + 1 < columns) {
-        graph.arcs.push({
-          from: current,
-          to: right([i, j], size).join(""),
-        })
-      }
-      if (i + 1 < rows && j + 1 < columns) {
-        graph.arcs.push({
-          from: current,
-          to: downRight([i, j], size).join(""),
-        })
-      }
-    }
-  }
-
-  const start = "00"
-  const end = "44"
-  const expectedResult = ["00", "11", "22", "33", "44"]
-
-  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
-})

package/src/utils/algorithms/types.d.ts

@@ -1,28 +0,0 @@
-export type Conditions = unknown
-export type Outcome = string | boolean
-
-export interface DecisionTree {
-  test: (conditions: Conditions) => Outcome
-  [outcome: Outcome]: () => Outcome | DecisionTree
-}
-
-interface NodeMap {
-  [id: string]: [number, number] // [x, y]
-}
-
-interface Node {
-  id: string
-  position: [number, number] // [x, y]
-  cost?: number
-}
-
-interface Arc {
-  from: string
-  to: string
-  cost?: number
-}
-
-export interface Graph {
-  nodes: NodeMap | Node[]
-  arcs: Arc[]
-}

package/src/utils/data-structures/array.js

@@ -1,83 +0,0 @@
-/**
- * A default comparator function that compares two numbers.
- *
- * @param {number} a - The first number.
- * @param {number} b - The second number.
- * @returns {number} - A positive number if `a` is less than `b`, a negative number if `a` is greater than `b`, or 0 if they are equal.
- */
-const DEFAULT_COMPARATOR = (a, b) => b - a
-
-// Threshold constants for comparison results
-const LESS_THAN_ZERO = 0
-const GREATER_THAN_ZERO = 0
-
-/**
- * Checks if an array contains a specific item.
- *
- * @param {Array} arr - The array to search.
- * @param {*} item - The item to check for.
- * @returns {boolean} - `true` if the item is found, otherwise `false`.
- */
-export function contains(arr, item) {
-  return arr.includes(item)
-}
-
-/**
- * Finds the maximum item in an array based on a comparator function.
- *
- * @param {Array} arr - The array to search.
- * @param {Function} [comparator=DEFAULT_COMPARATOR] - The comparator function to determine the maximum item.
- * @returns {*} - The maximum item in the array.
- */
-export function max(arr, comparator = DEFAULT_COMPARATOR) {
-  return arr.reduce((acc, item) =>
-    comparator(item, acc) < LESS_THAN_ZERO ? item : acc,
-  )
-}
-
-/**
- * Finds the minimum item in an array based on a comparator function.
- *
- * @param {Array} arr - The array to search.
- * @param {Function} [comparator=DEFAULT_COMPARATOR] - The comparator function to determine the minimum item.
- * @returns {*} - The minimum item in the array.
- */
-export function min(arr, comparator = DEFAULT_COMPARATOR) {
-  return arr.reduce((acc, item) =>
-    comparator(item, acc) > GREATER_THAN_ZERO ? item : acc,
-  )
-}
-
-/**
- * Removes the smallest item from an array, based on a comparator function.
- *
- * @param {Array} arr - The array to remove the item from.
- * @param {Function} [comparator=DEFAULT_COMPARATOR] - The comparator function to determine the smallest item.
- * @returns {*} - A new array with the item removed.
- */
-export function pop(arr, comparator = DEFAULT_COMPARATOR) {
-  const item = min(arr, comparator)
-  return remove(arr, item)
-}
-
-/**
- * Adds an item to an array in an immutable way.
- *
- * @param {Array} arr - The array to add the item to.
- * @param {*} item - The item to add.
- * @returns {Array} - A new array with the item added.
- */
-export function push(arr, item) {
-  return [...arr, item]
-}
-
-/**
- * Removes a specific item from an array in an immutable way.
- *
- * @param {Array} arr - The array to remove the item from.
- * @param {*} item - The item to remove.
- * @returns {Array} - A new array with the item removed.
- */
-export function remove(arr, item) {
-  return arr.filter((el) => el !== item)
-}

package/src/utils/data-structures/array.test.js

@@ -1,173 +0,0 @@
-import { expect, test } from "vitest"
-
-import { contains, max, min, pop, push, remove } from "./array.js"
-
-test("it should check if an array contains a value", () => {
-  const arr = [3, 2, 6, 1, 7, 4, 5]
-  const item = 1
-  const expectedResult = true
-
-  expect(contains(arr, item)).toBe(expectedResult)
-})
-
-test("it should check if an array contains an object", () => {
-  const arr = [
-    { value: 3 },
-    { value: 2 },
-    { value: 6 },
-    { value: 1 },
-    { value: 7 },
-    { value: 4 },
-    { value: 5 },
-  ]
-  const item = arr[3]
-  const expectedResult = true
-
-  expect(contains(arr, item)).toBe(expectedResult)
-})
-
-test("it should find the maximum value of an array", () => {
-  const arr = [3, 2, 6, 1, 7, 4, 5]
-  const expectedResult = 7
-
-  expect(max(arr)).toBe(expectedResult)
-})
-
-test("it should find the maximum value in an array of objects", () => {
-  const arr = [
-    { value: 3 },
-    { value: 2 },
-    { value: 6 },
-    { value: 1 },
-    { value: 7 },
-    { value: 4 },
-    { value: 5 },
-  ]
-  const comparator = (a, b) => b.value - a.value
-  const expectedResult = { value: 7 }
-
-  expect(max(arr, comparator)).toStrictEqual(expectedResult)
-})
-
-test("it should find the minimum value of an array", () => {
-  const arr = [3, 2, 6, 1, 7, 4, 5]
-  const expectedResult = 1
-
-  expect(min(arr)).toBe(expectedResult)
-})
-
-test("it should find the minimum value in an array of objects", () => {
-  const arr = [
-    { value: 3 },
-    { value: 2 },
-    { value: 6 },
-    { value: 1 },
-    { value: 7 },
-    { value: 4 },
-    { value: 5 },
-  ]
-  const comparator = (a, b) => b.value - a.value
-  const expectedResult = { value: 1 }
-
-  expect(min(arr, comparator)).toStrictEqual(expectedResult)
-})
-
-test("it should remove the minimum value from an array", () => {
-  const arr = [3, 2, 6, 1, 7, 4, 5]
-  const expectedResult = [3, 2, 6, 7, 4, 5]
-
-  expect(pop(arr)).toStrictEqual(expectedResult)
-})
-
-test("it should remove the minimum object from an array", () => {
-  const arr = [
-    { value: 3 },
-    { value: 2 },
-    { value: 6 },
-    { value: 1 },
-    { value: 7 },
-    { value: 4 },
-    { value: 5 },
-  ]
-  const comparator = (a, b) => b.value - a.value
-  const expectedResult = [
-    { value: 3 },
-    { value: 2 },
-    { value: 6 },
-    { value: 7 },
-    { value: 4 },
-    { value: 5 },
-  ]
-
-  expect(pop(arr, comparator)).toStrictEqual(expectedResult)
-})
-
-test("it should remove the maximum value from an array", () => {
-  const arr = [3, 2, 6, 1, 7, 4, 5]
-  const comparator = (a, b) => a - b
-  const expectedResult = [3, 2, 6, 1, 4, 5]
-
-  expect(pop(arr, comparator)).toStrictEqual(expectedResult)
-})
-
-test("it should remove the maximum object from an array", () => {
-  const arr = [
-    { value: 3 },
-    { value: 2 },
-    { value: 6 },
-    { value: 1 },
-    { value: 7 },
-    { value: 4 },
-    { value: 5 },
-  ]
-  const comparator = (a, b) => a.value - b.value
-  const expectedResult = [
-    { value: 3 },
-    { value: 2 },
-    { value: 6 },
-    { value: 1 },
-    { value: 4 },
-    { value: 5 },
-  ]
-
-  expect(pop(arr, comparator)).toStrictEqual(expectedResult)
-})
-
-test("it should add a value at the end of the array", () => {
-  const arr = [3, 2, 6, 1, 7, 4]
-  const item = 5
-  const expectedResult = [3, 2, 6, 1, 7, 4, 5]
-
-  expect(push(arr, item)).toStrictEqual(expectedResult)
-})
-
-test("it should remove a primitive value from an array", () => {
-  const arr = [3, 2, 6, 1, 7, 4, 5]
-  const item = 1
-  const expectedResult = [3, 2, 6, 7, 4, 5]
-
-  expect(remove(arr, item)).toStrictEqual(expectedResult)
-})
-
-test("it should remove an object from an array", () => {
-  const arr = [
-    { value: 3 },
-    { value: 2 },
-    { value: 6 },
-    { value: 1 },
-    { value: 7 },
-    { value: 4 },
-    { value: 5 },
-  ]
-  const item = arr[3]
-  const expectedResult = [
-    { value: 3 },
-    { value: 2 },
-    { value: 6 },
-    { value: 7 },
-    { value: 4 },
-    { value: 5 },
-  ]
-
-  expect(remove(arr, item)).toStrictEqual(expectedResult)
-})

package/src/utils/data-structures/board.js

@@ -1,159 +0,0 @@
-/**
- * Default filler function for board cells.
- * @returns {null} Default value for a cell.
- */
-const DEFAULT_FILLER = () => null
-
-/**
- * Default function to convert a cell to a string.
- * @param {*} cell - The cell value.
- * @returns {string} String representation of the cell.
- */
-const DEFAULT_CELL_TO_STRING = (cell) => `${cell}`
-
-const FIRST_ROW = 0
-const FIRST_COLUMN = 0
-const LAST_ROW_OFFSET = 1
-const LAST_COLUMN_OFFSET = 1
-const MOVE_DOWN = 1
-const MOVE_LEFT = -1
-const MOVE_RIGHT = 1
-const MOVE_UP = -1
-
-/**
- * Calculates the index in a one-dimensional array for given row and column.
- * @param {number} row - The row index.
- * @param {number} column - The column index.
- * @param {number} columns - The total number of columns.
- * @returns {number} The calculated index.
- */
-function getIndex(row, column, columns) {
-  return row * columns + column
-}
-
-/**
- * Creates a 1D board with the specified dimensions and fills it using the provided filler function.
- * @param {[number, number]} dimensions - Array containing the number of rows and columns.
- * @param {Function} [filler=DEFAULT_FILLER] - Function to fill each cell of the board.
- * @returns {any[]} The created board.
- */
-export function createBoard([rows, columns], filler = DEFAULT_FILLER) {
-  return new Array(rows * columns).fill(null).map((_, index) => {
-    const row = Math.floor(index / columns)
-    const column = index % columns
-    return filler(row, column)
-  })
-}
-
-/**
- * Moves the given coordinates one step down.
- * @param {[number, number]} coords - The current coordinates [row, column].
- * @param {[number]} size - Array containing the number of rows.
- * @returns {[number, number]} The new coordinates after moving down.
- * @throws {Error} If the movement goes out of bounds.
- */
-export function down([i, j], [rows]) {
-  if (i === rows - LAST_ROW_OFFSET) {
-    throw new Error()
-  }
-  return [i + MOVE_DOWN, j]
-}
-
-/**
- * Moves the given coordinates one step down and one step left.
- * @param {[number, number]} coords - The current coordinates [row, column].
- * @param {[number, number]} size - Array containing the number of rows and columns.
- * @returns {[number, number]} The new coordinates after moving down-left.
- */
-export function downLeft(coords, size) {
-  return down(left(coords, size), size)
-}
-
-/**
- * Moves the given coordinates one step down and one step right.
- * @param {[number, number]} coords - The current coordinates [row, column].
- * @param {[number, number]} size - Array containing the number of rows and columns.
- * @returns {[number, number]} The new coordinates after moving down-right.
- */
-export function downRight(coords, size) {
-  return down(right(coords, size), size)
-}
-
-/**
- * Moves the given coordinates one step left.
- * @param {[number, number]} coords - The current coordinates [row, column].
- * @returns {[number, number]} The new coordinates after moving left.
- * @throws {Error} If the movement goes out of bounds.
- */
-export function left([i, j]) {
-  if (j === FIRST_COLUMN) {
-    throw new Error()
-  }
-  return [i, j + MOVE_LEFT]
-}
-
-/**
- * Moves the given coordinates one step right.
- * @param {[number, number]} coords - The current coordinates [row, column].
- * @param {[number, number]} size - Array containing the number of rows and columns.
- * @returns {[number, number]} The new coordinates after moving right.
- * @throws {Error} If the movement goes out of bounds.
- */
-export function right([i, j], [, columns]) {
-  if (j === columns - LAST_COLUMN_OFFSET) {
-    throw new Error()
-  }
-  return [i, j + MOVE_RIGHT]
-}
-
-/**
- * Converts the board to a string representation.
- * @param {any[]} board - The 1D board to convert.
- * @param {[number, number]} dimensions - Array containing the number of rows and columns.
- * @param {Function} [cellToString=DEFAULT_CELL_TO_STRING] - Function to convert each cell to a string.
- * @returns {string} The string representation of the board.
- */
-export function toString(
-  board,
-  [rows, columns],
-  cellToString = DEFAULT_CELL_TO_STRING,
-) {
-  return Array.from({ length: rows }, (_, i) =>
-    Array.from({ length: columns }, (_, j) =>
-      cellToString(board[getIndex(i, j, columns)], i, j),
-    ).join(" "),
-  ).join("\n")
-}
-
-/**
- * Moves the given coordinates one step up.
- * @param {[number, number]} coords - The current coordinates [row, column].
- * @returns {[number, number]} The new coordinates after moving up.
- * @throws {Error} If the movement goes out of bounds.
- */
-export function up([i, j]) {
-  if (i === FIRST_ROW) {
-    throw new Error()
-  }
-  return [i + MOVE_UP, j]
-}
-
-/**
- * Moves the given coordinates one step up and one step left.
- * @param {[number, number]} coords - The current coordinates [row, column].
- * @param {[number, number]} size - Array containing the number of rows and columns.
- * @returns {[number, number]} The new coordinates after moving up-left.
- */
-export function upLeft(coords, size) {
-  return up(left(coords, size), size)
-}
-
-/**
- * Moves the given coordinates one step up and one step right.
- * @param {[number, number]} coords - The current coordinates [row, column].
- * @param {[number, number]} size - Array containing the number of rows and columns.
- * @returns {[number, number]} The new coordinates after moving up-right.
- */
-export function upRight(coords, size) {
-  return up(right(coords, size), size)
-}