@inglorious/utils 3.6.3 → 3.7.1

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

@@ -1,242 +0,0 @@
-import { expect, test } from "vitest"
-
-import { mod } from "../math/numbers.js"
-import {
-  createBoard,
-  down,
-  downLeft,
-  downRight,
-  left,
-  right,
-  toString,
-  up,
-  upLeft,
-  upRight,
-} from "./board.js"
-
-test("it should create an empty board", () => {
-  const size = [4, 4]
-  const expectedResult = [
-    null,
-    null,
-    null,
-    null,
-    null,
-    null,
-    null,
-    null,
-    null,
-    null,
-    null,
-    null,
-    null,
-    null,
-    null,
-    null,
-  ]
-
-  expect(createBoard(size)).toStrictEqual(expectedResult)
-})
-
-test("it should create a checkerboard", () => {
-  const size = [4, 4]
-  const filler = (i, j) => (!mod(i + j, 2) ? 1 : 0)
-  const expectedResult = [1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
-
-  expect(createBoard(size, filler)).toStrictEqual(expectedResult)
-})
-
-test("it should return the coordinates of the cell downward", () => {
-  const size = [8, 8]
-  const coordinates = [3, 4]
-  const expectedResult = [4, 4]
-
-  expect(down(coordinates, size)).toStrictEqual(expectedResult)
-})
-
-test("it should throw going down if cell is downmost", () => {
-  const size = [8, 8]
-  const coordinates = [7, 4]
-
-  expect(() => down(coordinates, size)).toThrow()
-})
-
-test("it should return the coordinates of the cell down left", () => {
-  const size = [8, 8]
-  const coordinates = [3, 4]
-  const expectedResult = [4, 3]
-
-  expect(downLeft(coordinates, size)).toStrictEqual(expectedResult)
-})
-
-test("it should throw going down left if cell is downmost", () => {
-  const size = [8, 8]
-  const coordinates = [7, 4]
-
-  expect(() => downLeft(coordinates, size)).toThrow()
-})
-
-test("it should throw going down left if cell is downmost", () => {
-  const size = [8, 8]
-  const coordinates = [3, 0]
-
-  expect(() => downLeft(coordinates, size)).toThrow()
-})
-
-test("it should throw going down left if cell is on the angle", () => {
-  const size = [8, 8]
-  const coordinates = [7, 0]
-
-  expect(() => downLeft(coordinates, size)).toThrow()
-})
-
-test("it should return the coordinates of the cell down right", () => {
-  const size = [8, 8]
-  const coordinates = [3, 4]
-  const expectedResult = [4, 5]
-
-  expect(downRight(coordinates, size)).toStrictEqual(expectedResult)
-})
-
-test("it should throw going down right if cell is downmost", () => {
-  const size = [8, 8]
-  const coordinates = [7, 4]
-
-  expect(() => downRight(coordinates, size)).toThrow()
-})
-
-test("it should throw going down right if cell is downmost", () => {
-  const size = [8, 8]
-  const coordinates = [3, 7]
-
-  expect(() => downRight(coordinates, size)).toThrow()
-})
-
-test("it should throw going down right if cell is on the angle", () => {
-  const size = [8, 8]
-  const coordinates = [7, 7]
-
-  expect(() => downRight(coordinates, size)).toThrow()
-})
-
-test("it should return the coordinates of the cell to the left", () => {
-  const size = [8, 8]
-  const coordinates = [3, 4]
-  const expectedResult = [3, 3]
-
-  expect(left(coordinates, size)).toStrictEqual(expectedResult)
-})
-
-test("it should not return coordinates to the left if cell is leftmost", () => {
-  const size = [8, 8]
-  const coordinates = [3, 0]
-
-  expect(() => left(coordinates, size)).toThrow()
-})
-
-test("it should return the coordinates of the cell to the right", () => {
-  const size = [8, 8]
-  const coordinates = [3, 4]
-  const expectedResult = [3, 5]
-
-  expect(right(coordinates, size)).toStrictEqual(expectedResult)
-})
-
-test("it should not return coordinates to the right if cell is rightmost", () => {
-  const size = [8, 8]
-  const coordinates = [3, 7]
-
-  expect(() => right(coordinates, size)).toThrow()
-})
-
-test("it should return a string representation of the given board", () => {
-  const board = [1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
-
-  expect(toString(board, [4, 4])).toBe(`1 0 1 0
-0 1 0 1
-1 0 1 0
-0 1 0 1`)
-})
-
-test("it should return a custom string representation of the given board", () => {
-  const board = [1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
-  const cellToString = (cell) => cell.toFixed(1)
-
-  expect(toString(board, [4, 4], cellToString)).toBe(`1.0 0.0 1.0 0.0
-0.0 1.0 0.0 1.0
-1.0 0.0 1.0 0.0
-0.0 1.0 0.0 1.0`)
-})
-
-test("it should return the coordinates of the cell upward", () => {
-  const size = [8, 8]
-  const coordinates = [3, 4]
-  const expectedResult = [2, 4]
-
-  expect(up(coordinates, size)).toStrictEqual(expectedResult)
-})
-
-test("it should throw going upward if cell is topmost", () => {
-  const size = [8, 8]
-  const coordinates = [0, 4]
-
-  expect(() => up(coordinates, size)).toThrow()
-})
-
-test("it should return the coordinates of the cell up left", () => {
-  const size = [8, 8]
-  const coordinates = [3, 4]
-  const expectedResult = [2, 3]
-
-  expect(upLeft(coordinates, size)).toStrictEqual(expectedResult)
-})
-
-test("it should throw going up left if cell is upmost", () => {
-  const size = [8, 8]
-  const coordinates = [0, 4]
-
-  expect(() => upLeft(coordinates, size)).toThrow()
-})
-
-test("it should throw going up left if cell is leftmost", () => {
-  const size = [8, 8]
-  const coordinates = [3, 0]
-
-  expect(() => upLeft(coordinates, size)).toThrow()
-})
-
-test("it should throw going up left if cell is on the angle", () => {
-  const size = [8, 8]
-  const coordinates = [0, 0]
-
-  expect(() => upLeft(coordinates, size)).toThrow()
-})
-
-test("it should return the coordinates of the cell up right", () => {
-  const size = [8, 8]
-  const coordinates = [3, 4]
-  const expectedResult = [2, 5]
-
-  expect(upRight(coordinates, size)).toStrictEqual(expectedResult)
-})
-
-test("it should throw going up right if cell is upmost", () => {
-  const size = [8, 8]
-  const coordinates = [0, 4]
-
-  expect(() => upRight(coordinates, size)).toThrow()
-})
-
-test("it should throw going down right if cell is rightmost", () => {
-  const size = [8, 8]
-  const coordinates = [3, 7]
-
-  expect(() => upRight(coordinates, size)).toThrow()
-})
-
-test("it should throw going down right if cell is on the angle", () => {
-  const size = [8, 8]
-  const coordinates = [0, 7]
-
-  expect(() => upRight(coordinates, size)).toThrow()
-})

package/src/data-structures/heap.test.js

@@ -1,103 +0,0 @@
-import { expect, test } from "vitest"
-
-import { contains, heapify, pop, push, remove, root } from "./heap.js"
-
-test("it should check if a heap contains a value", () => {
-  const heap = [3, 2, 6, 1, 7, 4, 5]
-  const item = 1
-  const expectedResult = true
-
-  expect(contains(heap, item)).toBe(expectedResult)
-})
-
-test("it should check if a heap contains an object", () => {
-  const heap = [
-    { value: 3 },
-    { value: 2 },
-    { value: 6 },
-    { value: 1 },
-    { value: 7 },
-    { value: 4 },
-    { value: 5 },
-  ]
-  const item = heap[3]
-  const expectedResult = true
-
-  expect(contains(heap, item)).toBe(expectedResult)
-})
-
-test("it should not convert an array in existing heap form into a heap", () => {
-  const arr = [1, 2, 3, 4, 5, 6, 7]
-  const expectedResult = [1, 2, 3, 4, 5, 6, 7]
-
-  expect(heapify(arr)).toStrictEqual(expectedResult)
-})
-
-test("it should convert an array into a heap", () => {
-  const arr = [7, 6, 5, 4, 3, 2, 1]
-  const expectedResult = [1, 4, 2, 7, 5, 6, 3]
-
-  expect(heapify(arr)).toStrictEqual(expectedResult)
-})
-
-test("it should convert an array into a maxheap", () => {
-  const arr = [1, 2, 3, 4, 5, 6, 7]
-  const comparator = (a, b) => a - b
-  const expectedResult = [7, 4, 6, 1, 3, 2, 5]
-
-  expect(heapify(arr, comparator)).toStrictEqual(expectedResult)
-})
-
-test("it should find the minimum value in a min heap", () => {
-  const heap = [1, 4, 2, 7, 5, 6, 3]
-  const expectedResult = 1
-
-  expect(root(heap)).toBe(expectedResult)
-})
-
-test("it should push the first element of the heap", () => {
-  const heap = []
-  const value = 7
-  const expectedResult = [7]
-
-  expect(push(heap, value)).toStrictEqual(expectedResult)
-})
-
-test("it should push the biggest value at the end of the heap", () => {
-  const heap = [3, 13, 19, 33, 42, 23, 21]
-  const value = 50
-  const expectedResult = [3, 13, 19, 33, 42, 23, 21, 50]
-
-  expect(push(heap, value)).toStrictEqual(expectedResult)
-})
-
-test("it should push a value in the right spot of a heap", () => {
-  const heap = [3, 13, 19, 33, 42, 23, 21]
-  const value = 7
-  const expectedResult = [3, 7, 19, 13, 42, 23, 21, 33]
-
-  expect(push(heap, value)).toStrictEqual(expectedResult)
-})
-
-test("it should pop the lowest value from the end of the heap", () => {
-  const heap = [3, 13, 19, 33, 42, 23, 21]
-  const expectedResult = [13, 21, 19, 33, 42, 23]
-
-  expect(pop(heap)).toStrictEqual(expectedResult)
-})
-
-test("it should push the biggest value at the beginning of a maxheap", () => {
-  const heap = [3, 13, 19, 33, 42, 23, 21]
-  const comparator = (a, b) => a - b
-  const value = 50
-  const expectedResult = [50, 3, 19, 13, 42, 23, 21, 33]
-
-  expect(push(heap, value, comparator)).toStrictEqual(expectedResult)
-})
-
-test("it should remove the heap's root element", () => {
-  const heap = [3, 13, 19, 33, 42, 23, 21]
-  const expectedResult = [13, 21, 19, 33, 42, 23]
-
-  expect(remove(heap)).toStrictEqual(expectedResult)
-})

package/src/data-structures/object.test.js

@@ -1,335 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import {
-  clone,
-  deserialize,
-  filter,
-  find,
-  isObject,
-  map,
-  produce,
-  serialize,
-  toString,
-} from "./object.js"
-
-test("it should deep clone an object", () => {
-  const obj = {
-    primitive: 1,
-    array: [2, 3],
-    object: { a: 1, b: 2 },
-  }
-  const expectedResult = {
-    primitive: 1,
-    array: [2, 3],
-    object: { a: 1, b: 2 },
-  }
-
-  const result = clone(obj)
-
-  expect(result).toStrictEqual(expectedResult)
-  expect(result).not.toBe(expectedResult)
-  expect(result.primitive).toBe(expectedResult.primitive)
-  expect(result.array).not.toBe(expectedResult.array)
-  expect(result.object).not.toBe(expectedResult.object)
-})
-
-test("it should behave like Array.prototype.filter, but on an object", () => {
-  const obj = {
-    key1: "value1",
-    key2: "value2",
-    key3: "value3",
-  }
-  const callback = (key) => ["key2", "key3"].includes(key)
-  const expectedResult = {
-    key2: "value2",
-    key3: "value3",
-  }
-
-  expect(filter(obj, callback)).toStrictEqual(expectedResult)
-})
-
-test("it should behave like Array.prototype.find, but on an object", () => {
-  const obj = {
-    key1: "value1",
-    key2: "value2",
-    key3: "value3",
-  }
-  const callback = (key) => ["key2", "key3"].includes(key)
-  const expectedResult = {
-    key2: "value2",
-  }
-
-  expect(find(obj, callback)).toStrictEqual(expectedResult)
-})
-
-test("it correctly should check if a value is an object", () => {
-  expect(isObject(1)).toBe(false)
-  expect(isObject("a")).toBe(false)
-  expect(isObject([])).toBe(false)
-  expect(isObject(null)).toBe(false)
-  expect(isObject(new Date())).toBe(false)
-  expect(isObject({})).toBe(true)
-})
-
-test("it should behave like Array.prototype.map, but on an object", () => {
-  const obj = {
-    key1: "value1",
-    key2: "value2",
-    key3: "value3",
-  }
-  const callback = (key, value) => value.toUpperCase()
-  const expectedResult = {
-    key1: "VALUE1",
-    key2: "VALUE2",
-    key3: "VALUE3",
-  }
-
-  expect(map(obj, callback)).toStrictEqual(expectedResult)
-})
-
-test("it should produce a new state without mutating the original", () => {
-  const baseState = {
-    a: 1,
-    b: {
-      c: [2, 3],
-      d: { e: 4 },
-    },
-    f: 5,
-  }
-
-  const recipe = (draft) => {
-    draft.a = 10
-    draft.b.c.push(4)
-    draft.b.d.e = 40
-    draft.g = 6
-  }
-
-  const expectedState = {
-    a: 10,
-    b: {
-      c: [2, 3, 4],
-      d: { e: 40 },
-    },
-    f: 5,
-    g: 6,
-  }
-
-  const originalBaseState = deserialize(serialize(baseState))
-
-  const nextState = produce(baseState, recipe)
-
-  expect(nextState).toStrictEqual(expectedState)
-  expect(nextState).not.toBe(baseState)
-  expect(baseState).toStrictEqual(originalBaseState)
-})
-
-test("it should support currying to produce a new state", () => {
-  const baseState = {
-    a: 1,
-    b: {
-      c: [2, 3],
-      d: { e: 4 },
-    },
-    f: 5,
-  }
-  const originalStateCopy = clone(baseState)
-
-  const recipe = (draft) => {
-    draft.a = 10
-    draft.b.c.push(4)
-    draft.g = 6
-  }
-
-  const expectedState = {
-    a: 10,
-    b: {
-      c: [2, 3, 4],
-      d: { e: 4 },
-    },
-    f: 5,
-    g: 6,
-  }
-
-  const producer = produce(recipe)
-  const nextState = producer(baseState)
-
-  expect(nextState).toStrictEqual(expectedState)
-  expect(nextState).not.toBe(baseState)
-  expect(baseState).toStrictEqual(originalStateCopy)
-})
-
-test("it should pass extra arguments to the recipe", () => {
-  const baseState = { value: 1 }
-  const recipe = (draft, increment, multiplier) => {
-    draft.value = (draft.value + increment) * multiplier
-  }
-
-  // Test non-curried version
-  const nextStateUncurried = produce(baseState, recipe, 2, 3) // (1 + 2) * 3 = 9
-  expect(nextStateUncurried.value).toBe(9)
-
-  // Test curried version
-  const producer = produce(recipe)
-  const nextStateCurried = producer(baseState, 4, 5) // (1 + 4) * 5 = 25
-  expect(nextStateCurried.value).toBe(25)
-
-  expect(baseState.value).toBe(1)
-})
-
-test("it should return a string representation of a shallow object", () => {
-  const obj = {
-    key1: "value1",
-    key2: "value2",
-    key3: "value3",
-  }
-
-  expect(toString(obj)).toBe(`{
-  key1: "value1",
-  key2: "value2",
-  key3: "value3"
-}`)
-})
-
-test("it should return a string representation of a nested object", () => {
-  const obj = {
-    a: 1,
-    b: [7, 3],
-    c: { d: 4, h: 8 },
-    e: [{ f: 5, i: 9 }],
-    g: 6,
-  }
-
-  expect(toString(obj)).toBe(`{
-  a: 1,
-  b: [
-    7,
-    3
-  ],
-  c: {
-    d: 4,
-    h: 8
-  },
-  e: [
-    {
-      f: 5,
-      i: 9
-    }
-  ],
-  g: 6
-}`)
-})
-
-test("it should serialize a basic object with primitive values", () => {
-  const obj = { a: 1, b: "hello", c: true }
-  const expected = `{"a":1,"b":"hello","c":true}`
-
-  expect(serialize(obj)).toBe(expected)
-})
-
-test("it should serialize an object with nested objects", () => {
-  const obj = { a: 1, b: { c: "nested", d: { e: false } } }
-  const expected = `{"a":1,"b":{"c":"nested","d":{"e":false}}}`
-
-  expect(serialize(obj)).toBe(expected)
-})
-
-test("it should serialize an object containing a vector-like object", () => {
-  const obj = { position: v(1, 2, 3) }
-  const expected = `{"position":{"_type":"vector","coords":[1,2,3]}}`
-
-  expect(serialize(obj)).toBe(expected)
-})
-
-test("it should serialize an object with nested vector-like objects", () => {
-  const obj = {
-    entity: {
-      id: "player",
-      pos: v(10, 20),
-      vel: v(1, 0),
-      stats: { health: 100 },
-    },
-  }
-  const expected = `{"entity":{"id":"player","pos":{"_type":"vector","coords":[10,20]},"vel":{"_type":"vector","coords":[1,0]},"stats":{"health":100}}}`
-
-  expect(serialize(obj)).toBe(expected)
-})
-
-test("it should serialize an empty object", () => {
-  const obj = {}
-  const expected = `{}`
-
-  expect(serialize(obj)).toBe(expected)
-})
-
-test("it should serialize an object with null and undefined values (undefined should be omitted)", () => {
-  const obj = { a: null, b: undefined, c: 1 }
-  const expected = `{"a":null,"c":1}` // JSON.stringify omits undefined properties
-
-  expect(serialize(obj)).toBe(expected)
-})
-
-test("it should deserialize a basic object with primitive values", () => {
-  const serialized = `{"a":1,"b":"hello","c":true}`
-  const expected = { a: 1, b: "hello", c: true }
-
-  expect(deserialize(serialized)).toStrictEqual(expected)
-})
-
-test("it should deserialize an object with nested objects", () => {
-  const serialized = `{"a":1,"b":{"c":"nested","d":{"e":false}}}`
-  const expected = { a: 1, b: { c: "nested", d: { e: false } } }
-
-  expect(deserialize(serialized)).toStrictEqual(expected)
-})
-
-test("it should deserialize an object containing a vector representation", () => {
-  const serialized = `{"position":{"_type":"vector","coords":[1,2,3]}}`
-  const expected = { position: v(1, 2, 3) }
-
-  const result = deserialize(serialized)
-
-  expect(result).toStrictEqual(expected)
-  expect(result.position.__isVector__).toBe(true)
-})
-
-test("it should deserialize an object with nested vector representations", () => {
-  const serialized = `{"entity":{"id":"player","pos":{"_type":"vector","coords":[10,20]},"vel":{"_type":"vector","coords":[1,0]},"stats":{"health":100}}}`
-  const expected = {
-    entity: {
-      id: "player",
-      pos: v(10, 20),
-      vel: v(1, 0),
-      stats: { health: 100 },
-    },
-  }
-  const result = deserialize(serialized)
-
-  expect(result).toStrictEqual(expected)
-  expect(result.entity.pos.__isVector__).toBe(true)
-  expect(result.entity.vel.__isVector__).toBe(true)
-})
-
-test("it should deserialize an empty object", () => {
-  const serialized = `{}`
-  const expected = {}
-
-  expect(deserialize(serialized)).toStrictEqual(expected)
-})
-
-test("it should correctly round-trip a complex object through serialize and deserialize", () => {
-  const original = {
-    id: "game1",
-    player: { name: "Alice", score: 100, position: v(10, 20) },
-    enemies: [{ type: "goblin", pos: v(5, 5) }],
-    settings: { volume: 0.8, mute: false },
-  }
-  const jsonString = serialize(original)
-  const deserialized = deserialize(jsonString)
-
-  expect(deserialized).toStrictEqual(original)
-  expect(deserialized.player.position.__isVector__).toBe(true)
-  expect(deserialized.enemies[0].pos.__isVector__).toBe(true)
-  // Ensure that non-vector objects are still distinct references if they were originally
-  expect(deserialized.player).not.toBe(original.player)
-})