@vworlds/vecs 1.0.0 → 1.0.1

package/tests/bitset.test.ts

@@ -1,127 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Bitset, BitPtr } from "../src/util/bitset.js";
-
-describe("Bitset", () => {
-  it("starts empty", () => {
-    const b = new Bitset();
-    expect(b.has(0)).toBe(false);
-    expect(b.has(31)).toBe(false);
-    expect(b.has(64)).toBe(false);
-    expect(b.indices()).toEqual([]);
-  });
-
-  it("adds and checks single bits", () => {
-    const b = new Bitset();
-    b.add(3);
-    b.add(33);
-    b.add(100);
-    expect(b.has(3)).toBe(true);
-    expect(b.has(33)).toBe(true);
-    expect(b.has(100)).toBe(true);
-    expect(b.has(2)).toBe(false);
-    expect(b.has(34)).toBe(false);
-  });
-
-  it("returns indices in ascending order", () => {
-    const b = new Bitset();
-    b.add(100);
-    b.add(0);
-    b.add(31);
-    b.add(32);
-    expect(b.indices()).toEqual([0, 31, 32, 100]);
-  });
-
-  it("delete clears a bit", () => {
-    const b = new Bitset();
-    b.add(0);
-    b.add(64);
-    expect(b.has(64)).toBe(true);
-    b.delete(64);
-    expect(b.has(64)).toBe(false);
-    expect(b.has(0)).toBe(true);
-  });
-
-  it("delete trims trailing zero words", () => {
-    const b = new Bitset();
-    b.add(0);
-    b.add(32);
-    b.add(64);
-    expect(b["bits"].length).toBe(3);
-    b.delete(64);
-    expect(b["bits"].length).toBe(2);
-    b.delete(32);
-    expect(b["bits"].length).toBe(1);
-    b.delete(0);
-    expect(b["bits"].length).toBe(0);
-  });
-
-  it("delete on absent word is a no-op", () => {
-    const b = new Bitset();
-    b.delete(50); // never been added — array is empty
-    expect(b.has(50)).toBe(false);
-  });
-
-  it("equal compares bit-by-bit", () => {
-    const a = new Bitset();
-    const b = new Bitset();
-    a.add(1);
-    a.add(33);
-    b.add(33);
-    b.add(1);
-    expect(a.equal(b)).toBe(true);
-    b.add(2);
-    expect(a.equal(b)).toBe(false);
-  });
-
-  it("hasBitset checks subset relation", () => {
-    const a = new Bitset();
-    const b = new Bitset();
-    a.add(1);
-    a.add(2);
-    a.add(33);
-    b.add(1);
-    b.add(33);
-    expect(a.hasBitset(b)).toBe(true);
-    expect(b.hasBitset(a)).toBe(false);
-  });
-
-  it("hasBitset returns false when other has bits in higher words than this", () => {
-    const a = new Bitset();
-    const b = new Bitset();
-    a.add(0);
-    b.add(0);
-    b.add(64);
-    expect(a.hasBitset(b)).toBe(false);
-  });
-
-  it("forEach yields each set bit exactly once", () => {
-    const b = new Bitset();
-    [0, 1, 32, 33, 100].forEach((n) => b.add(n));
-    const seen: number[] = [];
-    b.forEach((n) => seen.push(n));
-    expect(seen).toEqual([0, 1, 32, 33, 100]);
-  });
-
-  it("BitPtr fast path matches add/has results", () => {
-    const b = new Bitset();
-    const ptr = new BitPtr(45);
-    b.addBit(ptr);
-    expect(b.hasBit(ptr)).toBe(true);
-    expect(b.has(45)).toBe(true);
-  });
-
-  it("BitPtr.equals identifies same bit position", () => {
-    expect(new BitPtr(7).equals(new BitPtr(7))).toBe(true);
-    expect(new BitPtr(7).equals(new BitPtr(8))).toBe(false);
-  });
-
-  it("addIndexBitmask and setIndexBitmask manipulate raw words", () => {
-    const b = new Bitset();
-    b.addIndexBitmask(0, 0b1010);
-    expect(b.has(1)).toBe(true);
-    expect(b.has(3)).toBe(true);
-    b.setIndexBitmask(0, 0b0001);
-    expect(b.has(1)).toBe(false);
-    expect(b.has(0)).toBe(true);
-  });
-});

package/tests/component.test.ts

@@ -1,104 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { World, Component } from "../src/index.js";
-import { makeWorldWithFlushPhase } from "./_helpers.js";
-
-class Health extends Component {
-  hp = 10;
-}
-
-describe("Component", () => {
-  it("type is shorthand for meta.type", () => {
-    const w = new World();
-    w.registerComponent(Health, 42);
-    const e = w.createEntity();
-    const h = e.add(Health);
-    expect(h.type).toBe(42);
-    expect(h.type).toBe(h.meta.type);
-  });
-
-  it("bitPtr is shorthand for meta.bitPtr", () => {
-    const w = new World();
-    w.registerComponent(Health);
-    const h = w.createEntity().add(Health);
-    expect(h.bitPtr).toBe(h.meta.bitPtr);
-  });
-
-  it("toString returns the component name", () => {
-    const w = new World();
-    w.registerComponent(Health, "HP");
-    const h = w.createEntity().add(Health);
-    expect(h.toString()).toBe("HP");
-  });
-
-  it("modified() queues an onSet hook delivery", () => {
-    const env = makeWorldWithFlushPhase();
-    env.w.registerComponent(Health);
-    const onSet = vi.fn();
-    env.w.hook(Health).onSet(onSet);
-    env.start();
-    const h = env.w.createEntity().add(Health, false);
-    h.modified();
-    env.tick();
-    expect(onSet).toHaveBeenCalledWith(h);
-  });
-
-  it("modified() is coalesced — onSet fires once even if called twice", () => {
-    const env = makeWorldWithFlushPhase();
-    env.w.registerComponent(Health);
-    const onSet = vi.fn();
-    env.w.hook(Health).onSet(onSet);
-    env.start();
-    const h = env.w.createEntity().add(Health, false);
-    h.modified();
-    h.modified();
-    h.modified();
-    env.tick();
-    expect(onSet).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("Hook", () => {
-  it("onAdd fires when a component is first attached", () => {
-    const env = makeWorldWithFlushPhase();
-    env.w.registerComponent(Health);
-    const onAdd = vi.fn();
-    env.w.hook(Health).onAdd(onAdd);
-    env.start();
-    const h = env.w.createEntity().add(Health);
-    expect(onAdd).toHaveBeenCalledWith(h);
-  });
-
-  it("onRemove fires when a component is removed", () => {
-    const env = makeWorldWithFlushPhase();
-    env.w.registerComponent(Health);
-    const onRemove = vi.fn();
-    env.w.hook(Health).onRemove(onRemove);
-    env.start();
-    const e = env.w.createEntity();
-    const h = e.add(Health);
-    e.remove(Health);
-    expect(onRemove).toHaveBeenCalledWith(h);
-  });
-
-  it("onRemove fires when the entity is destroyed", () => {
-    const env = makeWorldWithFlushPhase();
-    env.w.registerComponent(Health);
-    const onRemove = vi.fn();
-    env.w.hook(Health).onRemove(onRemove);
-    env.start();
-    const e = env.w.createEntity();
-    e.add(Health);
-    e.destroy();
-    expect(onRemove).toHaveBeenCalledTimes(1);
-  });
-
-  it("hooks are chainable on the same Hook object", () => {
-    const w = new World();
-    w.registerComponent(Health);
-    const a = vi.fn();
-    const b = vi.fn();
-    const c = vi.fn();
-    const result = w.hook(Health).onAdd(a).onRemove(b).onSet(c);
-    expect(result).toBe(w.hook(Health));
-  });
-});

package/tests/entity.test.ts

@@ -1,179 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { World, Component } from "../src/index.js";
-import { makeWorldWithFlushPhase } from "./_helpers.js";
-
-class Position extends Component {
-  x = 0;
-  y = 0;
-}
-class Velocity extends Component {
-  vx = 0;
-}
-
-describe("Entity — components", () => {
-  it("add returns a typed instance bound to the entity", () => {
-    const w = new World();
-    w.registerComponent(Position);
-    const e = w.createEntity();
-    const pos = e.add(Position);
-    expect(pos).toBeInstanceOf(Position);
-    expect(pos.entity).toBe(e);
-    expect(pos.x).toBe(0);
-  });
-
-  it("add is idempotent — same instance is returned on repeat", () => {
-    const w = new World();
-    w.registerComponent(Position);
-    const e = w.createEntity();
-    const a = e.add(Position);
-    const b = e.add(Position);
-    expect(a).toBe(b);
-  });
-
-  it("add(typeId) works with numeric type ids", () => {
-    const w = new World();
-    w.registerComponent(Position, 5);
-    const e = w.createEntity();
-    const pos = e.add(5);
-    expect(pos).toBeInstanceOf(Position);
-  });
-
-  it("get returns the component or undefined", () => {
-    const w = new World();
-    w.registerComponent(Position);
-    const e = w.createEntity();
-    expect(e.get(Position)).toBeUndefined();
-    const pos = e.add(Position);
-    expect(e.get(Position)).toBe(pos);
-  });
-
-  it("remove detaches a component", () => {
-    const w = new World();
-    w.registerComponent(Position);
-    const e = w.createEntity();
-    e.add(Position);
-    e.remove(Position);
-    expect(e.get(Position)).toBeUndefined();
-  });
-
-  it("get(Class, true) recovers a component removed in this frame", () => {
-    const w = new World();
-    w.registerComponent(Position);
-    const e = w.createEntity();
-    const pos = e.add(Position);
-    e.remove(Position);
-    expect(e.get(Position)).toBeUndefined();
-    expect(e.get(Position, true)).toBe(pos);
-  });
-
-  it("componentBitmask reflects added/removed components", () => {
-    const w = new World();
-    w.registerComponent(Position);
-    w.registerComponent(Velocity);
-    const e = w.createEntity();
-    e.add(Position);
-    e.add(Velocity);
-    expect(e.componentBitmask.has(w.getComponentType(Position))).toBe(true);
-    expect(e.componentBitmask.has(w.getComponentType(Velocity))).toBe(true);
-    e.remove(Position);
-    expect(e.componentBitmask.has(w.getComponentType(Position))).toBe(false);
-  });
-
-  it("empty reflects whether any components remain", () => {
-    const w = new World();
-    w.registerComponent(Position);
-    const e = w.createEntity();
-    expect(e.empty).toBe(true);
-    e.add(Position);
-    expect(e.empty).toBe(false);
-    e.remove(Position);
-    expect(e.empty).toBe(true);
-  });
-
-  it("forEachComponent visits every attached component", () => {
-    const w = new World();
-    w.registerComponent(Position);
-    w.registerComponent(Velocity);
-    const e = w.createEntity();
-    e.add(Position);
-    e.add(Velocity);
-    const seen: string[] = [];
-    e.forEachComponent((c) => seen.push(c.toString()));
-    expect(seen.sort()).toEqual(["Position", "Velocity"]);
-  });
-
-  it("toString returns Entity{eid}", () => {
-    const w = new World();
-    const e = w.createEntity();
-    expect(e.toString()).toBe(`Entity${e.eid}`);
-  });
-});
-
-describe("Entity — lifecycle and hierarchy", () => {
-  it("destroy emits the 'destroy' event", () => {
-    const env = makeWorldWithFlushPhase();
-    env.start();
-    const e = env.w.createEntity();
-    const cb = vi.fn();
-    e.events.on("destroy", cb);
-    e.destroy();
-    env.tick();
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-
-  it("destroy removes the entity from the world map", () => {
-    const env = makeWorldWithFlushPhase();
-    env.start();
-    const e = env.w.createEntity();
-    e.destroy();
-    expect(env.w.entity(e.eid)).toBeUndefined();
-  });
-
-  it("destroy recursively destroys children", () => {
-    const env = makeWorldWithFlushPhase();
-    env.start();
-    const parent = env.w.createEntity();
-    const child = env.w.createEntity();
-    child.parent = parent;
-    parent.children.add(child);
-
-    const childDestroyed = vi.fn();
-    child.events.on("destroy", childDestroyed);
-    parent.destroy();
-    env.tick();
-    expect(childDestroyed).toHaveBeenCalled();
-    expect(env.w.entity(child.eid)).toBeUndefined();
-    expect(env.w.entity(parent.eid)).toBeUndefined();
-  });
-
-  it("destroy unlinks from parent and triggers parent's archetype update", () => {
-    const env = makeWorldWithFlushPhase();
-    env.start();
-    const parent = env.w.createEntity();
-    const child = env.w.createEntity();
-    child.parent = parent;
-    parent.children.add(child);
-
-    child.destroy();
-    env.tick();
-    expect(parent.children.has(child)).toBe(false);
-    expect(child.parent).toBeUndefined();
-    expect(env.w.entity(parent.eid)).toBe(parent);
-  });
-
-  it("children set is created lazily", () => {
-    const w = new World();
-    const e = w.createEntity();
-    expect(e["_children"]).toBeUndefined();
-    const c = e.children;
-    expect(c).toBeInstanceOf(Set);
-    expect(e.children).toBe(c); // memoized
-  });
-
-  it("properties is a free-form map", () => {
-    const w = new World();
-    const e = w.createEntity();
-    e.properties.set("kind", "bullet");
-    expect(e.properties.get("kind")).toBe("bullet");
-  });
-});

package/tests/events.test.ts

@@ -1,48 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { Events } from "../src/util/events.js";
-
-type Map = {
-  hello(name: string): void;
-  count(n: number): void;
-};
-
-describe("Events", () => {
-  it("calls listeners with their typed args", () => {
-    const e = new Events<Map>();
-    const greet = vi.fn();
-    e.on("hello", greet);
-    e.emit("hello", "world");
-    expect(greet).toHaveBeenCalledWith("world");
-  });
-
-  it("once fires only on the first emit", () => {
-    const e = new Events<Map>();
-    const cb = vi.fn();
-    e.once("count", cb);
-    e.emit("count", 1);
-    e.emit("count", 2);
-    expect(cb).toHaveBeenCalledTimes(1);
-    expect(cb).toHaveBeenCalledWith(1);
-  });
-
-  it("off / removeListener detaches a single listener", () => {
-    const e = new Events<Map>();
-    const cb = vi.fn();
-    e.on("hello", cb);
-    e.off("hello", cb);
-    e.emit("hello", "x");
-    expect(cb).not.toHaveBeenCalled();
-  });
-
-  it("removeAllListeners detaches every handler", () => {
-    const e = new Events<Map>();
-    const a = vi.fn();
-    const b = vi.fn();
-    e.on("hello", a);
-    e.on("hello", b);
-    e.removeAllListeners("hello");
-    e.emit("hello", "x");
-    expect(a).not.toHaveBeenCalled();
-    expect(b).not.toHaveBeenCalled();
-  });
-});

package/tests/ordered_set.test.ts

@@ -1,153 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { OrderedSet } from "../src/util/ordered_set.js";
-
-const numCmp = (a: number, b: number) => a - b;
-const strCmp = (a: string, b: string) => a.localeCompare(b);
-
-describe("OrderedSet", () => {
-  it("starts empty", () => {
-    const s = new OrderedSet<number>(numCmp);
-    expect(s.size).toBe(0);
-    expect(s.has(1)).toBe(false);
-  });
-
-  it("add/has round trip", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(3);
-    expect(s.has(3)).toBe(true);
-    expect(s.size).toBe(1);
-  });
-
-  it("add is idempotent", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(5).add(5).add(5);
-    expect(s.size).toBe(1);
-  });
-
-  it("add returns this for chaining", () => {
-    const s = new OrderedSet<number>(numCmp);
-    expect(s.add(1).add(2)).toBe(s);
-  });
-
-  it("maintains sorted order", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(30).add(10).add(20).add(5);
-    expect([...s]).toEqual([5, 10, 20, 30]);
-  });
-
-  it("delete removes existing element and returns true", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(1).add(2).add(3);
-    expect(s.delete(2)).toBe(true);
-    expect(s.has(2)).toBe(false);
-    expect(s.size).toBe(2);
-    expect([...s]).toEqual([1, 3]);
-  });
-
-  it("delete on missing element returns false", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(1);
-    expect(s.delete(99)).toBe(false);
-    expect(s.size).toBe(1);
-  });
-
-  it("clear empties the set", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(1).add(2).add(3);
-    s.clear();
-    expect(s.size).toBe(0);
-    expect(s.has(1)).toBe(false);
-  });
-
-  it("forEach visits values in sorted order", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(3).add(1).add(2);
-    const seen: number[] = [];
-    s.forEach((v) => seen.push(v));
-    expect(seen).toEqual([1, 2, 3]);
-  });
-
-  it("forEach passes value, value, set", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(42);
-    s.forEach((v, v2, set) => {
-      expect(v).toBe(42);
-      expect(v2).toBe(42);
-      expect(set).toBe(s);
-    });
-  });
-
-  it("forEach respects thisArg", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(1);
-    const ctx = { called: false };
-    s.forEach(function (this: typeof ctx) {
-      this.called = true;
-    }, ctx);
-    expect(ctx.called).toBe(true);
-  });
-
-  it("[Symbol.iterator] yields values in sorted order", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(9).add(3).add(6);
-    expect([...s]).toEqual([3, 6, 9]);
-  });
-
-  it("values() yields sorted values", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(2).add(1).add(3);
-    expect([...s.values()]).toEqual([1, 2, 3]);
-  });
-
-  it("keys() yields sorted values (same as values)", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(2).add(1).add(3);
-    expect([...s.keys()]).toEqual([1, 2, 3]);
-  });
-
-  it("entries() yields [value, value] pairs in sorted order", () => {
-    const s = new OrderedSet<number>(numCmp);
-    s.add(2).add(1);
-    expect([...s.entries()]).toEqual([
-      [1, 1],
-      [2, 2],
-    ]);
-  });
-
-  it("works with string comparator", () => {
-    const s = new OrderedSet<string>(strCmp);
-    s.add("banana").add("apple").add("cherry");
-    expect([...s]).toEqual(["apple", "banana", "cherry"]);
-  });
-
-  it("works with object comparator", () => {
-    type Item = { priority: number; name: string };
-    const s = new OrderedSet<Item>((a, b) => a.priority - b.priority);
-    s.add({ priority: 3, name: "c" });
-    s.add({ priority: 1, name: "a" });
-    s.add({ priority: 2, name: "b" });
-    const names = [...s].map((x) => x.name);
-    expect(names).toEqual(["a", "b", "c"]);
-  });
-
-  it("binary search handles first and last element", () => {
-    const s = new OrderedSet<number>(numCmp);
-    for (let i = 1; i <= 10; i++) s.add(i);
-    expect(s.has(1)).toBe(true);
-    expect(s.has(10)).toBe(true);
-    expect(s.delete(1)).toBe(true);
-    expect(s.delete(10)).toBe(true);
-    expect([...s]).toEqual([2, 3, 4, 5, 6, 7, 8, 9]);
-  });
-
-  it("Symbol.toStringTag is 'OrderedSet'", () => {
-    const s = new OrderedSet<number>(numCmp);
-    expect(s[Symbol.toStringTag]).toBe("OrderedSet");
-  });
-
-  it("is assignable to Set<T>", () => {
-    const s: Set<number> = new OrderedSet<number>(numCmp);
-    s.add(1).add(2);
-    expect(s.size).toBe(2);
-  });
-});

package/tests/setup.ts

@@ -1,6 +0,0 @@
-import { beforeEach, vi } from "vitest";
-
-// Silence the registration / phase logs the world emits at construction time.
-beforeEach(() => {
-  vi.spyOn(console, "log").mockImplementation(() => {});
-});