@inglorious/utils 3.7.0 → 3.7.2

package/src/math/vectors.test.js

@@ -1,77 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import {
-  cross,
-  distance,
-  divide,
-  dot,
-  multiply,
-  power,
-  subtract,
-  sum,
-} from "./vectors.js"
-
-test("it should compute the cross product between two vectors (aka vectorProduct)", () => {
-  const vector1 = v(1, 2, 3)
-  const vector2 = v(4, 5, 6)
-  const expectedResult = v(-3, 6, -3)
-
-  expect(cross(vector1, vector2)).toStrictEqual(expectedResult)
-})
-
-test("it should compute the cross product of multiple vectors (aka vectorProduct)", () => {
-  const vectors = [v(1, 2, 3), v(4, 5, 6), v(7, 8, 9)]
-  const expectedResult = v(78, 6, -66)
-
-  expect(cross(...vectors)).toStrictEqual(expectedResult)
-})
-
-test("it should compute the distance between multiple vectors", () => {
-  const vectors = [v(0, 0, 0), v(4, 0, 3)]
-  const expectedResult = 5
-
-  expect(distance(...vectors)).toStrictEqual(expectedResult)
-})
-
-test("it should divide multiple vectors component-wise", () => {
-  const vectors = [v(80, 40, 20), v(2, 4, 5), v(2, 2, 2)]
-  const expectedResult = v(20, 5, 2)
-
-  expect(divide(...vectors)).toStrictEqual(expectedResult)
-})
-
-test("it should compute the dot product of multiple vectors (aka scalarProduct)", () => {
-  const vectors = [v(1, 2, 3), v(4, 5, 6), v(7, 8, 9)]
-  const expectedResult = 270
-
-  expect(dot(...vectors)).toStrictEqual(expectedResult)
-})
-
-test("it should multiply multiple vectors component-wise (Hadamard product)", () => {
-  const vectors = [v(1, 2, 3), v(4, 5, 6), v(2, 2, 2)]
-  const expectedResult = v(8, 20, 36)
-
-  expect(multiply(...vectors)).toStrictEqual(expectedResult)
-})
-
-test("it should raise a vector to the power of another vector", () => {
-  const vectors = [v(2, 3, 4), v(4, 3, 2)]
-  const expectedResult = v(16, 27, 16)
-
-  expect(power(...vectors)).toStrictEqual(expectedResult)
-})
-
-test("it should subtract multiple vectors", () => {
-  const vectors = [v(1, 2, 3), v(4, 5, 6), v(7, 8, 9)]
-  const expectedResult = v(-10, -11, -12)
-
-  expect(subtract(...vectors)).toStrictEqual(expectedResult)
-})
-
-test("it should sum multiple vectors (aka add)", () => {
-  const vectors = [v(1, 2, 3), v(4, 5, 6), v(7, 8, 9)]
-  const expectedResult = v(12, 15, 18)
-
-  expect(sum(...vectors)).toStrictEqual(expectedResult)
-})

package/src/physics/friction.test.js

@@ -1,43 +0,0 @@
-import { expect, test } from "vitest"
-
-import { zero } from "../math/vector.js"
-import { v } from "../v.js"
-import { applyFriction } from "./friction.js"
-
-test("it should apply friction to some velocity", () => {
-  const velocity = v(8, 0, 6)
-  const friction = 5
-  const expectedResult = v(4, 0, 3)
-
-  expect(applyFriction({ velocity, friction })).toStrictEqual(expectedResult)
-})
-
-test("it should stop movement when friction is equal to velocity", () => {
-  const velocity = v(8, 0, 6)
-  const friction = 5
-  const dt = 2
-
-  expect(applyFriction({ velocity, friction }, dt)).toStrictEqual(zero())
-})
-
-test("it should apply no friction on no velocity", () => {
-  const velocity = zero()
-  const friction = 5
-
-  expect(applyFriction({ velocity, friction })).toBe(velocity)
-})
-
-test("it should apply no friction if no friction is passed", () => {
-  const velocity = v(8, 0, 6)
-  const friction = 0
-
-  expect(applyFriction({ velocity, friction })).toStrictEqual(velocity)
-})
-
-test("it should apply no friction if no time passed", () => {
-  const velocity = v(8, 0, 6)
-  const friction = 5
-  const dt = 0
-
-  expect(applyFriction({ velocity, friction }, dt)).toStrictEqual(velocity)
-})

package/src/physics/gravity.test.js

@@ -1,78 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import { applyGravity } from "./gravity.js"
-
-test("it should apply gravity based on input parameters", () => {
-  const params = {
-    maxJump: 10,
-    maxLeap: 10,
-    maxSpeed: 10,
-    vy: 10,
-    position: v(0, 10, 0),
-  }
-
-  expect(applyGravity(params)).toStrictEqual({
-    ay: -20,
-    vy: -10,
-    position: v(0, -10, 0),
-  })
-})
-
-test("it should compute no gravity when max jump height is not set", () => {
-  const params = {
-    maxLeap: 10,
-    maxSpeed: 10,
-    vy: 10,
-    position: v(0, 10, 0),
-  }
-
-  expect(applyGravity(params)).toStrictEqual({
-    ay: -0,
-    vy: 10,
-    position: v(0, 20, 0),
-  })
-})
-
-test("it should compute no gravity when max movement speed is not set", () => {
-  const params = {
-    maxJump: 10,
-    maxLeap: 10,
-    vy: 10,
-    position: v(0, 10, 0),
-  }
-
-  expect(applyGravity(params)).toStrictEqual({
-    ay: -0,
-    vy: 10,
-    position: v(0, 20, 0),
-  })
-})
-
-test("it should apply no gravity when no time has passed", () => {
-  const params = {
-    maxJump: 10,
-    maxLeap: 10,
-    maxSpeed: 10,
-    vy: 10,
-    position: v(0, 10, 0),
-  }
-  const dt = 0
-
-  expect(applyGravity(params, dt)).toStrictEqual({
-    ay: -20,
-    vy: 10,
-    position: v(0, 10, 0),
-  })
-})
-
-test("it should throw an error when max leap distance is not set", () => {
-  const params = {
-    maxJump: 10,
-    maxSpeed: 10,
-    vy: 10,
-    position: v(0, 10, 0),
-  }
-
-  expect(() => applyGravity(params)).toThrow()
-})

package/src/v.test.js

@@ -1,48 +0,0 @@
-import { expect, test } from "vitest"
-
-import { ensureV, v } from "./v"
-
-test("ensureV() should convert a numeric array into a vector", () => {
-  const array = [1, 2, 3]
-  const result = ensureV(array)
-  expect(result).toStrictEqual([1, 2, 3])
-  expect(result.__isVector__).toBe(true)
-})
-
-test("ensureV() should return an existing vector unchanged", () => {
-  const vector = v(4, 5, 6)
-  const result = ensureV(vector)
-  expect(result).toBe(vector)
-  expect(result.__isVector__).toBe(true)
-})
-
-test("ensureV() should not convert an array with non-finite numbers", () => {
-  const array = [1, Infinity, 3]
-  const result = ensureV(array)
-  expect(result).toBe(array)
-  expect(result.__isVector__).toBeUndefined()
-})
-
-test("ensureV() should not convert an array with non-numeric values", () => {
-  const array = [1, "a", 3]
-  const result = ensureV(array)
-  expect(result).toBe(array)
-  expect(result.__isVector__).toBeUndefined()
-})
-
-test("ensureV() should return non-array values unchanged", () => {
-  expect(ensureV(123)).toBe(123)
-  expect(ensureV("hello")).toBe("hello")
-  const obj = { a: 1 }
-  expect(ensureV(obj)).toBe(obj)
-})
-
-test("a vector created with the v() function is just a number array", () => {
-  const vector = v(1, 2, 3)
-  expect(vector).toStrictEqual([1, 2, 3])
-})
-
-test("a vector created with the v() function has a __isVector__ property", () => {
-  const vector = v(1, 2, 3)
-  expect(vector.__isVector__).toBe(true)
-})