@inglorious/utils 3.6.3 → 3.7.1

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

@@ -1,196 +0,0 @@
-import { expect, test } from "vitest"
-
-import { isArray } from "./array.js"
-import { extend, extendWith, merge, mergeWith } from "./objects.js"
-
-test("it should extend an object with another, producing a new object as a result", () => {
-  const obj1 = {
-    primitiveKept: 1,
-    primitiveMerged: 2,
-    primitiveArrayKept: [1, 2],
-    primitiveArrayMerged: [3, 4],
-    primitiveObjectKept: { a: 1 },
-    primitiveObjectMerged: { b: 2, c: 3 },
-    nestedArrayKept: [{ a: 1 }],
-    nestedArrayMerged: [{ b: 2, c: 3 }],
-    nestedObjectKept: { a: { b: 2 } },
-    nestedObjectMerged: { c: { d: 4 } },
-  }
-  const obj2 = {
-    primitiveMerged: 3,
-    primitiveAdded: 4,
-    primitiveArrayMerged: [5],
-    primitiveArrayAdded: [6, 7],
-    primitiveObjectMerged: { c: 4 },
-    primitiveObjectAdded: { d: 4 },
-    nestedArrayMerged: [{ d: 4 }],
-    nestedArrayAdded: [{ e: 5 }],
-    nestedObjectMerged: { c: { e: 5 } },
-    nestedObjectAdded: { f: { g: 7 } },
-  }
-  const expectedResult = {
-    primitiveKept: 1,
-    primitiveMerged: 3,
-    primitiveAdded: 4,
-    primitiveArrayKept: [1, 2],
-    primitiveArrayMerged: [5],
-    primitiveArrayAdded: [6, 7],
-    primitiveObjectKept: { a: 1 },
-    primitiveObjectMerged: { b: 2, c: 4 },
-    primitiveObjectAdded: { d: 4 },
-    nestedArrayKept: [{ a: 1 }],
-    nestedArrayMerged: [{ d: 4 }],
-    nestedArrayAdded: [{ e: 5 }],
-    nestedObjectKept: { a: { b: 2 } },
-    nestedObjectMerged: { c: { d: 4, e: 5 } },
-    nestedObjectAdded: { f: { g: 7 } },
-  }
-
-  const result = extend(obj1, obj2)
-  expect(result).toStrictEqual(expectedResult)
-  expect(result).not.toBe(obj1)
-})
-
-test("it should deep merge an two objects, changing the first object in place", () => {
-  const obj1 = {
-    primitiveKept: 1,
-    primitiveMerged: 2,
-    primitiveArrayKept: [1, 2],
-    primitiveArrayMerged: [3, 4],
-    primitiveObjectKept: { a: 1 },
-    primitiveObjectMerged: { b: 2, c: 3 },
-    nestedArrayKept: [{ a: 1 }],
-    nestedArrayMerged: [{ b: 2, c: 3 }],
-    nestedObjectKept: { a: { b: 2 } },
-    nestedObjectMerged: { c: { d: 4 } },
-  }
-  const obj2 = {
-    primitiveMerged: 3,
-    primitiveAdded: 4,
-    primitiveArrayMerged: [5],
-    primitiveArrayAdded: [6, 7],
-    primitiveObjectMerged: { c: 4 },
-    primitiveObjectAdded: { d: 4 },
-    nestedArrayMerged: [{ d: 4 }],
-    nestedArrayAdded: [{ e: 5 }],
-    nestedObjectMerged: { c: { e: 5 } },
-    nestedObjectAdded: { f: { g: 7 } },
-  }
-  const expectedResult = {
-    primitiveKept: 1,
-    primitiveMerged: 3,
-    primitiveAdded: 4,
-    primitiveArrayKept: [1, 2],
-    primitiveArrayMerged: [5],
-    primitiveArrayAdded: [6, 7],
-    primitiveObjectKept: { a: 1 },
-    primitiveObjectMerged: { b: 2, c: 4 },
-    primitiveObjectAdded: { d: 4 },
-    nestedArrayKept: [{ a: 1 }],
-    nestedArrayMerged: [{ d: 4 }],
-    nestedArrayAdded: [{ e: 5 }],
-    nestedObjectKept: { a: { b: 2 } },
-    nestedObjectMerged: { c: { d: 4, e: 5 } },
-    nestedObjectAdded: { f: { g: 7 } },
-  }
-
-  const result = merge(obj1, obj2)
-  expect(result).toStrictEqual(expectedResult)
-  expect(result).toBe(obj1)
-})
-
-test("it should extend an object with a custom merger, producing a new object", () => {
-  const obj1 = {
-    primitiveArrayMerged: [3, 4],
-    nestedArrayMerged: [{ b: 2, c: 3 }],
-    nestedObjectMerged: { c: { d: 4 } },
-  }
-  const obj2 = {
-    primitiveArrayMerged: [5],
-    nestedArrayMerged: [{ d: 4 }],
-    nestedObjectMerged: { c: { e: 5 } },
-  }
-
-  const merger = (targetValue, sourceValue) => {
-    if (isArray(targetValue) && isArray(sourceValue)) {
-      return targetValue.concat(sourceValue)
-    }
-    return undefined // Use default logic for non-arrays
-  }
-
-  const expectedResult = {
-    primitiveArrayMerged: [3, 4, 5], // Concatenated
-    nestedArrayMerged: [{ b: 2, c: 3 }, { d: 4 }], // Concatenated
-    nestedObjectMerged: { c: { d: 4, e: 5 } }, // Default deep merge
-  }
-
-  const result = extendWith(merger, obj1, obj2)
-  expect(result).toStrictEqual(expectedResult)
-  expect(result).not.toBe(obj1)
-})
-
-test("it should merge an object with a custom merger, changing the first object in place", () => {
-  const obj1 = {
-    primitiveArrayMerged: [3, 4],
-    nestedArrayMerged: [{ b: 2, c: 3 }],
-    nestedObjectMerged: { c: { d: 4 } },
-  }
-  const obj2 = {
-    primitiveArrayMerged: [5],
-    nestedArrayMerged: [{ d: 4 }],
-    nestedObjectMerged: { c: { e: 5 } },
-  }
-
-  const merger = (targetValue, sourceValue) => {
-    if (isArray(targetValue) && isArray(sourceValue)) {
-      return targetValue.concat(sourceValue)
-    }
-    return undefined // Use default logic for non-arrays
-  }
-
-  const expectedResult = {
-    primitiveArrayMerged: [3, 4, 5], // Concatenated
-    nestedArrayMerged: [{ b: 2, c: 3 }, { d: 4 }], // Concatenated
-    nestedObjectMerged: { c: { d: 4, e: 5 } }, // Default deep merge
-  }
-
-  const result = mergeWith(merger, obj1, obj2)
-  expect(result).toStrictEqual(expectedResult)
-  expect(result).toBe(obj1)
-})
-
-test("extendWith without a merger should behave like extend", () => {
-  const obj1 = { a: 1, b: { c: 2 }, d: [3] }
-  const obj2 = { a: 10, b: { d: 20 }, d: [30] }
-
-  const expected = {
-    a: 10,
-    b: { c: 2, d: 20 },
-    d: [30],
-  }
-
-  const result = extendWith(undefined, obj1, obj2)
-  expect(result).toStrictEqual(expected)
-  expect(result).not.toBe(obj1)
-
-  const extendResult = extend(obj1, obj2)
-  expect(result).toStrictEqual(extendResult)
-})
-
-test("mergeWith without a merger should behave like merge", () => {
-  const obj1 = { a: 1, b: { c: 2 }, d: [3] }
-  const obj2 = { a: 10, b: { d: 20 }, d: [30] }
-
-  const expected = {
-    a: 10,
-    b: { c: 2, d: 20 },
-    d: [30],
-  }
-
-  const result = mergeWith(undefined, obj1, obj2)
-  expect(result).toStrictEqual(expected)
-  expect(result).toBe(obj1)
-
-  const mergeResult = merge({ a: 1, b: { c: 2 }, d: [3] }, obj2)
-  expect(result).toStrictEqual(mergeResult)
-})

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

@@ -1,15 +0,0 @@
-import { expect, test } from "vitest"
-
-import { ensureSet } from "./set.js"
-
-test("it should return the same array if the value is already an array", () => {
-  const set = new Set([1, "two", { three: 3 }])
-
-  expect(ensureSet(set)).toBe(set)
-})
-
-test("it should wrap the value in an array if it is not an array", () => {
-  const str = "hello"
-
-  expect(ensureSet(str)).toStrictEqual(new Set(["h", "e", "l", "o"]))
-})

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

@@ -1,33 +0,0 @@
-import { expect, test } from "vitest"
-
-import { bfs, dfs } from "./tree.js"
-
-test("it should perform Breadth-First Search on a tree", () => {
-  const tree = {
-    value: 1,
-    children: [
-      { value: 2, children: [{ value: 4 }, { value: 5 }] },
-      { value: 3, children: [{ value: 6 }, { value: 7 }] },
-    ],
-  }
-  const expectedResult = [1, 2, 3, 4, 5, 6, 7]
-
-  const result = bfs(tree)
-
-  expect(result).toStrictEqual(expectedResult)
-})
-
-test("it should perform Depth-First Search on a tree", () => {
-  const tree = {
-    value: 1,
-    children: [
-      { value: 2, children: [{ value: 3 }, { value: 4 }] },
-      { value: 5, children: [{ value: 6 }, { value: 7 }] },
-    ],
-  }
-  const expectedResult = [1, 2, 3, 4, 5, 6, 7]
-
-  const result = dfs(tree)
-
-  expect(result).toStrictEqual(expectedResult)
-})

package/src/functions/function.test.js

@@ -1,15 +0,0 @@
-import { expect, test } from "vitest"
-
-import { isFunction } from "./function.js"
-
-test("it should correctly identify a function", () => {
-  const func = () => {}
-
-  expect(isFunction(func)).toBe(true)
-})
-
-test("it should correctly identify a non-function", () => {
-  const str = "hello"
-
-  expect(isFunction(str)).toBe(false)
-})

package/src/functions/functions.test.js

@@ -1,51 +0,0 @@
-import { expect, test } from "vitest"
-
-import { compose, pipe } from "./functions.js"
-
-test("it should compose unary functions", () => {
-  const shout = (x) => x.toUpperCase()
-  const punctuate = (mark) => (x) => `${x}${mark}`
-  const html = (tag) => (x) => `<${tag}>${x}</${tag}>`
-
-  const fn = compose(html("p"), punctuate("!"), shout)
-  expect(fn("Hello world")).toBe("<p>HELLO WORLD!</p>")
-})
-
-test("it should compose functions with multiple initial arguments", () => {
-  const add = (a, b) => a + b
-  const square = (x) => x * x
-  const half = (x) => x / 2
-
-  const fn = compose(half, square, add) // half(square(add(2, 3)))
-  expect(fn(2, 3)).toBe(12.5)
-})
-
-test("it should return an identity-like function if compose is called with no arguments", () => {
-  const fn = compose()
-  expect(fn(42)).toBe(42)
-  expect(fn({ a: 1 })).toStrictEqual({ a: 1 })
-})
-
-test("it should pipe unary functions", () => {
-  const shout = (x) => x.toUpperCase()
-  const punctuate = (mark) => (x) => `${x}${mark}`
-  const html = (tag) => (x) => `<${tag}>${x}</${tag}>`
-
-  const fn = pipe(shout, punctuate("!"), html("p"))
-  expect(fn("Hello world")).toBe("<p>HELLO WORLD!</p>")
-})
-
-test("it should pipe functions with multiple initial arguments", () => {
-  const add = (a, b) => a + b
-  const square = (x) => x * x
-  const half = (x) => x / 2
-
-  const fn = pipe(add, square, half) // half(square(add(2, 3)))
-  expect(fn(2, 3)).toBe(12.5)
-})
-
-test("it should return an identity-like function if pipe is called with no arguments", () => {
-  const fn = pipe()
-  expect(fn(42)).toBe(42)
-  expect(fn({ a: 1 })).toStrictEqual({ a: 1 })
-})

package/src/math/circle.test.js

@@ -1,98 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import {
-  intersectsCircle,
-  intersectsPoint,
-  intersectsRectangle,
-} from "./circle.js"
-
-test("it should prove that a circle around a point intersects with it", () => {
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-  const point = v(1.5, 1.5, 0)
-
-  expect(intersectsPoint(circle, point)).toBe(true)
-})
-
-test("it should prove that two equal circles intersect", () => {
-  const circle1 = { position: v(1, 1, 0), radius: 1 }
-  const circle2 = { position: v(1, 1, 0), radius: 1 }
-
-  expect(intersectsCircle(circle1, circle2)).toBe(true)
-})
-
-test("it should prove that two circles shifted by a small x intersect", () => {
-  const circle1 = { position: v(1, 1, 0), radius: 1 }
-  const circle2 = { position: v(2, 1, 0), radius: 1 }
-
-  expect(intersectsCircle(circle1, circle2)).toBe(true)
-})
-
-test("it should prove that two touching circles intersect", () => {
-  const circle1 = { position: v(1, 1, 0), radius: 1 }
-  const circle2 = { position: v(3, 1, 0), radius: 1 }
-
-  expect(intersectsCircle(circle1, circle2)).toBe(true)
-})
-
-test("it should prove that two non-touching circles do not intersect", () => {
-  const circle1 = { position: v(1, 1, 0), radius: 1 }
-  const circle2 = { position: v(4, 1, 0), radius: 1 }
-
-  expect(intersectsCircle(circle1, circle2)).toBe(false)
-})
-
-test("it should prove that a circle inside of a rectangle intersects with it", () => {
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-  const rectangle = {
-    position: v(-1, -1, 0),
-    size: v(4, 4, 0),
-  }
-
-  expect(intersectsRectangle(circle, rectangle)).toBe(true)
-})
-
-test("it should prove that a circle touching the border of a rectangle intersects with it", () => {
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-  const rectangle = {
-    position: v(-1, 1, 0), // Rectangle's right edge is at x=0, touching the circle's left edge.
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(circle, rectangle)).toBe(true)
-})
-
-test("it should prove that a circle crossing a rectangle intersects with it", () => {
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-  const rectangle = {
-    position: v(0, 0, 0),
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(circle, rectangle)).toBe(true)
-})
-
-test("it should prove that a circle outside of a rectangle does not intersect with it", () => {
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-  const rectangle = {
-    position: v(-3, 0, 0),
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(circle, rectangle)).toBe(false)
-})

package/src/math/hitmask.test.js

@@ -1,156 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import { findCollisions } from "./hitmask.js"
-
-/**
- * Given a rectangle located at (x=1.5, y=0, z=2.5) with a size of (1, 1, 1),
- * which is touching a wall tile, this test proves a collision is detected.
- *
- * Tilemap layout:
- * ⬛️🟩🟩⬛️
- * ⬛️⬛️⬛️⬛️
- * ⬛️⬛️⬛️⬛️
- *
- * Rectangle position (X,Z): R at (1.5, 2.5)
- *
- * Expected outcome: true
- */
-test("it should prove that a rectangle touching a wall intersects with it", () => {
-  const hitmask = {
-    position: v(2, 0, 1.5),
-    tileSize: [1, 1],
-    columns: 4,
-    // The top row (indices 0, 1, 2, 3) now has the walls.
-    heights: [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: v(1.5, 0, 2.5),
-    size: v(1, 1, 1),
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(true)
-})
-
-/**
- * Given the same scenario as the previous test, but all coordinates
- * are shifted by a constant value, this test proves the outcome remains
- * unchanged, ensuring the collision detection is relative.
- *
- * Tilemap layout:
- * ⬛️🟩🟩⬛️
- * ⬛️⬛️⬛️⬛️
- * ⬛️⬛️⬛️⬛️
- *
- * Rectangle position (X,Z): R at (11.5, 12.5)
- *
- * Expected outcome: true
- */
-test("it should prove that shifting operands does not change the outcome", () => {
-  const SHIFT = 10
-  const hitmask = {
-    position: [2 + SHIFT, 0, 1.5 + SHIFT],
-    tileSize: [1, 1],
-    columns: 4,
-    // The top row (indices 0, 1, 2, 3) now has the walls.
-    heights: [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: v(11.5, 0, 12.5),
-    size: v(1, 1, 1),
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(true)
-})
-
-/**
- * Given a rectangle located at (x=0.5, y=0, z=0.5) with a size of (1, 1, 1),
- * which is not touching any walls, this test proves no collision is detected.
- *
- * Tilemap layout:
- * ⬛️🟩🟩⬛️
- * ⬛️⬛️⬛️⬛️
- * ⬛️⬛️⬛️⬛️
- *
- * Rectangle position (X,Z): R at (0.5, 0.5)
- *
- * Expected outcome: false
- */
-test("it should prove that a rectangle not touching a wall does not intersect with it", () => {
-  const hitmask = {
-    position: v(2, 0, 1.5),
-    tileSize: [1, 1],
-    columns: 4,
-    // The top row (indices 0, 1, 2, 3) now has the walls.
-    heights: [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: v(0.5, 0, 0.5),
-    size: v(1, 1, 1),
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(false)
-})
-
-/**
- * Given a rectangle located above the tile, this test proves no
- * collision is detected even when the X and Z positions overlap.
- *
- * Tilemap layout:
- * ⬛️🟩🟩⬛️
- * ⬛️⬛️⬛️⬛️
- * ⬛️⬛️⬛️⬛️
- *
- * Rectangle position: R at (x=1.5, y=1.6, z=2.5)
- *
- * Expected outcome: false
- */
-test("it should prove that a rectangle above the tile of a hitmask does not intersect with it", () => {
-  const hitmask = {
-    position: v(2, 0, 1.5),
-    tileSize: [1, 1],
-    columns: 4,
-    // The top row (indices 0, 1, 2, 3) now has the walls.
-    heights: [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: v(1.5, 1.6, 2.5),
-    size: v(1, 1, 1),
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(false)
-})
-
-/**
- * Given a rectangle located outside of the tilemap, this test proves
- * no collision is detected.
- *
- * Tilemap layout:
- * ⬛️🟩🟩⬛️
- * ⬛️⬛️⬛️⬛️
- * ⬛️⬛️⬛️⬛️
- *
- * Rectangle position: R at (x=5.5, y=0.5, z=1.5)
- *
- * Expected outcome: false
- */
-test("it should prove that a rectangle outside of a hitmask does not intersect with it", () => {
-  const hitmask = {
-    position: v(2, 0, 1.5),
-    tileSize: [1, 1],
-    columns: 4,
-    // The top row (indices 0, 1, 2, 3) now has the walls.
-    heights: [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: v(5.5, 0.5, 1.5),
-    size: v(1, 1, 1),
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(false)
-})

package/src/math/line.test.js

@@ -1,50 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import { distanceFromPoint, intersectsCircle } from "./line.js"
-
-test("it should compute the distance between a line and a point", () => {
-  const line = v(-4, 3, 0)
-  const point = v(5, 0, 0)
-  const expectedResult = 4
-
-  expect(distanceFromPoint(line, point)).toBe(expectedResult)
-})
-
-test("it should not compute the distance between a line and a point", () => {
-  const line = v(-1, 1, 0)
-  const point = v(2, 0, 2)
-  const expectedResult = 0
-
-  expect(distanceFromPoint(line, point)).toBe(expectedResult)
-})
-
-test("it should prove that a line that crosses a circle intersects with it", () => {
-  const line = v(-2, 2, 0)
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(line, circle)).toBe(true)
-})
-
-test("it should prove that a line tangent to a circle intersects with it", () => {
-  const line = v(-2, 0, 0)
-  const circle = {
-    position: v(1, 0, 1),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(line, circle)).toBe(true)
-})
-
-test("it should prove that a line that does not cross a circle does not intersect with it", () => {
-  const line = v(1, 1, 0)
-  const circle = {
-    position: v(1, 0, 1),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(line, circle)).toBe(false)
-})