@codehz/ecs 0.7.1 → 0.7.3

package/src/__tests__/core/bitset.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, it } from "bun:test";
+import { BitSet } from "../../utils/bit-set";
+
+describe("BitSet word boundary tests", () => {
+  it("should setRange across word boundaries", () => {
+    const bitset = new BitSet(100);
+
+    // Set range crossing 32-bit boundary (30-35)
+    bitset.setRange(30, 35);
+
+    // Check that all bits in range are set
+    for (let i = 30; i <= 35; i++) {
+      expect(bitset.has(i)).toBe(true);
+    }
+
+    // Check boundary bits
+    expect(bitset.has(29)).toBe(false);
+    expect(bitset.has(36)).toBe(false);
+  });
+
+  it("should handle setRange at word boundary exactly", () => {
+    const bitset = new BitSet(100);
+
+    // Set range [0..31] = first word
+    bitset.setRange(0, 31);
+
+    for (let i = 0; i <= 31; i++) {
+      expect(bitset.has(i)).toBe(true);
+    }
+    expect(bitset.has(32)).toBe(false);
+  });
+
+  it("should handle setRange spanning multiple words", () => {
+    const bitset = new BitSet(200);
+
+    // Set range [20..80] spanning parts of 3 words
+    bitset.setRange(20, 80);
+
+    for (let i = 20; i <= 80; i++) {
+      expect(bitset.has(i)).toBe(true);
+    }
+    expect(bitset.has(19)).toBe(false);
+    expect(bitset.has(81)).toBe(false);
+  });
+
+  it("should anyClearInRange work across word boundaries", () => {
+    const bitset = new BitSet(100);
+
+    // Set all bits
+    bitset.setRange(0, 99);
+
+    // All bits are set, so anyClearInRange should return false
+    expect(bitset.anyClearInRange(30, 35)).toBe(false);
+    expect(bitset.anyClearInRange(0, 99)).toBe(false);
+
+    // Clear some bits crossing boundary
+    bitset.clear(31);
+    bitset.clear(32);
+
+    expect(bitset.anyClearInRange(30, 35)).toBe(true);
+    expect(bitset.anyClearInRange(0, 30)).toBe(false);
+    expect(bitset.anyClearInRange(33, 99)).toBe(false);
+  });
+
+  it("should handle anyClearInRange with single word", () => {
+    const bitset = new BitSet(100);
+
+    bitset.setRange(10, 20);
+
+    // Range entirely in one word and all bits set
+    expect(bitset.anyClearInRange(10, 20)).toBe(false);
+
+    // Clear one bit in range
+    bitset.clear(15);
+    expect(bitset.anyClearInRange(10, 20)).toBe(true);
+
+    // Check range before and after
+    expect(bitset.anyClearInRange(0, 9)).toBe(true);
+    expect(bitset.anyClearInRange(21, 99)).toBe(true);
+  });
+
+  it("should handle large ranges", () => {
+    const bitset = new BitSet(1000);
+
+    // Set all bits
+    bitset.setRange(0, 999);
+
+    expect(bitset.anyClearInRange(0, 999)).toBe(false);
+
+    // Clear one bit in the middle
+    bitset.clear(500);
+    expect(bitset.anyClearInRange(0, 999)).toBe(true);
+    expect(bitset.anyClearInRange(0, 499)).toBe(false);
+    expect(bitset.anyClearInRange(501, 999)).toBe(false);
+  });
+
+  it("should handle range with no overlap", () => {
+    const bitset = new BitSet(100);
+
+    bitset.setRange(10, 20);
+
+    expect(bitset.anyClearInRange(0, 9)).toBe(true);
+    expect(bitset.anyClearInRange(21, 99)).toBe(true);
+  });
+
+  it("should iterate over set bits correctly", () => {
+    const bitset = new BitSet(100);
+
+    bitset.set(5);
+    bitset.set(35);
+    bitset.set(65);
+    bitset.set(99);
+
+    const setBits: number[] = [];
+    for (const bit of bitset) {
+      setBits.push(bit);
+    }
+
+    expect(setBits).toEqual([5, 35, 65, 99]);
+  });
+
+  it("should iterate over setRange result", () => {
+    const bitset = new BitSet(100);
+
+    bitset.setRange(10, 15);
+
+    const setBits: number[] = [];
+    for (const bit of bitset) {
+      setBits.push(bit);
+    }
+
+    expect(setBits).toEqual([10, 11, 12, 13, 14, 15]);
+  });
+
+  it("should handle reset correctly", () => {
+    const bitset = new BitSet(100);
+
+    bitset.setRange(0, 99);
+    bitset.reset();
+
+    expect(bitset.anyClearInRange(0, 99)).toBe(true);
+
+    const setBits: number[] = [];
+    for (const bit of bitset) {
+      setBits.push(bit);
+    }
+
+    expect(setBits).toHaveLength(0);
+  });
+
+  it("should handle edge case: setRange with reversed bounds", () => {
+    const bitset = new BitSet(100);
+
+    // setRange(hi, lo) where hi > lo should do nothing
+    bitset.setRange(50, 30);
+
+    for (let i = 0; i < 100; i++) {
+      expect(bitset.has(i)).toBe(false);
+    }
+  });
+
+  it("should handle single bit in range", () => {
+    const bitset = new BitSet(100);
+
+    bitset.setRange(25, 25);
+
+    expect(bitset.has(25)).toBe(true);
+    expect(bitset.has(24)).toBe(false);
+    expect(bitset.has(26)).toBe(false);
+  });
+});

package/src/__tests__/core/changeset.test.ts

@@ -0,0 +1,254 @@
+import { describe, expect, it } from "bun:test";
+import { ComponentChangeset } from "../../commands/changeset";
+import { component } from "../../entity";
+
+describe("ComponentChangeset", () => {
+  const PositionId = component<{ x: number; y: number }>();
+  const VelocityId = component<{ x: number; y: number }>();
+  const HealthId = component<number>();
+
+  describe("Basic Operations", () => {
+    it("should start with no changes", () => {
+      const changeset = new ComponentChangeset();
+      expect(changeset.hasChanges()).toBe(false);
+      expect(changeset.adds.size).toBe(0);
+      expect(changeset.removes.size).toBe(0);
+    });
+
+    it("should add components", () => {
+      const changeset = new ComponentChangeset();
+      changeset.set(PositionId, { x: 10, y: 20 });
+
+      expect(changeset.hasChanges()).toBe(true);
+      expect(changeset.adds.get(PositionId)).toEqual({ x: 10, y: 20 });
+      expect(changeset.removes.size).toBe(0);
+    });
+
+    it("should remove components", () => {
+      const changeset = new ComponentChangeset();
+      changeset.delete(PositionId);
+
+      expect(changeset.hasChanges()).toBe(true);
+      expect(changeset.adds.size).toBe(0);
+      expect(changeset.removes.has(PositionId)).toBe(true);
+    });
+
+    it("should clear all changes", () => {
+      const changeset = new ComponentChangeset();
+      changeset.set(PositionId, { x: 10, y: 20 });
+      changeset.delete(VelocityId);
+
+      expect(changeset.hasChanges()).toBe(true);
+
+      changeset.clear();
+
+      expect(changeset.hasChanges()).toBe(false);
+      expect(changeset.adds.size).toBe(0);
+      expect(changeset.removes.size).toBe(0);
+    });
+  });
+
+  describe("Conflict Resolution", () => {
+    it("should remove from removes when adding a component that was going to be removed", () => {
+      const changeset = new ComponentChangeset();
+      changeset.delete(PositionId);
+      changeset.set(PositionId, { x: 10, y: 20 });
+
+      expect(changeset.adds.get(PositionId)).toEqual({ x: 10, y: 20 });
+      expect(changeset.removes.has(PositionId)).toBe(false);
+    });
+
+    it("should remove from adds when removing a component that was going to be added", () => {
+      const changeset = new ComponentChangeset();
+      changeset.set(PositionId, { x: 10, y: 20 });
+      changeset.delete(PositionId);
+
+      expect(changeset.adds.has(PositionId)).toBe(false);
+      expect(changeset.removes.has(PositionId)).toBe(true);
+    });
+  });
+
+  describe("Apply Changes", () => {
+    it("should apply additions to existing components", () => {
+      const changeset = new ComponentChangeset();
+      changeset.set(PositionId, { x: 10, y: 20 });
+      changeset.set(VelocityId, { x: 1, y: 2 });
+
+      const existing = new Map();
+      existing.set(HealthId, 100);
+
+      const result = changeset.applyTo(existing);
+
+      expect(result.get(PositionId)).toEqual({ x: 10, y: 20 });
+      expect(result.get(VelocityId)).toEqual({ x: 1, y: 2 });
+      expect(result.get(HealthId)).toBe(100);
+    });
+
+    it("should apply removals to existing components", () => {
+      const changeset = new ComponentChangeset();
+      changeset.delete(PositionId);
+
+      const existing = new Map();
+      existing.set(PositionId, { x: 10, y: 20 });
+      existing.set(VelocityId, { x: 1, y: 2 });
+
+      const result = changeset.applyTo(existing);
+
+      expect(result.has(PositionId)).toBe(false);
+      expect(result.get(VelocityId)).toEqual({ x: 1, y: 2 });
+    });
+
+    it("should apply both additions and removals", () => {
+      const changeset = new ComponentChangeset();
+      changeset.set(PositionId, { x: 50, y: 60 });
+      changeset.delete(VelocityId);
+
+      const existing = new Map();
+      existing.set(PositionId, { x: 10, y: 20 });
+      existing.set(VelocityId, { x: 1, y: 2 });
+      existing.set(HealthId, 100);
+
+      const result = changeset.applyTo(existing);
+
+      expect(result.get(PositionId)).toEqual({ x: 50, y: 60 }); // Updated
+      expect(result.has(VelocityId)).toBe(false); // Removed
+      expect(result.get(HealthId)).toBe(100); // Unchanged
+    });
+
+    it("should get final component types correctly", () => {
+      const changeset = new ComponentChangeset();
+      changeset.set(PositionId, { x: 10, y: 20 });
+      changeset.delete(VelocityId);
+
+      const existing = new Map();
+      existing.set(VelocityId, { x: 1, y: 2 });
+      existing.set(HealthId, 100);
+
+      const finalTypes = changeset.applyTo(existing);
+
+      expect([...finalTypes.keys()]).toEqual([HealthId, PositionId]);
+    });
+  });
+
+  describe("Direct Access", () => {
+    it("should return direct references to internal maps for performance", () => {
+      const changeset = new ComponentChangeset();
+      changeset.set(PositionId, { x: 10, y: 20 });
+
+      const adds = changeset.adds;
+      const removes = changeset.removes;
+
+      // Since this is internal API, direct modification is allowed
+      adds.clear();
+      removes.add(VelocityId);
+
+      expect(changeset.adds.size).toBe(0);
+      expect(changeset.removes.size).toBe(1);
+    });
+  });
+
+  describe("Merge Changesets", () => {
+    it("should merge additions into an empty changeset", () => {
+      const changeset1 = new ComponentChangeset();
+      const changeset2 = new ComponentChangeset();
+      changeset2.set(PositionId, { x: 10, y: 20 });
+      changeset2.set(VelocityId, { x: 1, y: 2 });
+
+      changeset1.merge(changeset2);
+
+      expect(changeset1.adds.get(PositionId)).toEqual({ x: 10, y: 20 });
+      expect(changeset1.adds.get(VelocityId)).toEqual({ x: 1, y: 2 });
+      expect(changeset1.removes.size).toBe(0);
+      expect(changeset1.hasChanges()).toBe(true);
+    });
+
+    it("should merge removals into an empty changeset", () => {
+      const changeset1 = new ComponentChangeset();
+      const changeset2 = new ComponentChangeset();
+      changeset2.delete(PositionId);
+      changeset2.delete(VelocityId);
+
+      changeset1.merge(changeset2);
+
+      expect(changeset1.removes.has(PositionId)).toBe(true);
+      expect(changeset1.removes.has(VelocityId)).toBe(true);
+      expect(changeset1.adds.size).toBe(0);
+      expect(changeset1.hasChanges()).toBe(true);
+    });
+
+    it("should merge additions and removals together", () => {
+      const changeset1 = new ComponentChangeset();
+      const changeset2 = new ComponentChangeset();
+      changeset2.set(PositionId, { x: 10, y: 20 });
+      changeset2.delete(VelocityId);
+
+      changeset1.merge(changeset2);
+
+      expect(changeset1.adds.get(PositionId)).toEqual({ x: 10, y: 20 });
+      expect(changeset1.removes.has(VelocityId)).toBe(true);
+      expect(changeset1.hasChanges()).toBe(true);
+    });
+
+    it("should override removal with addition when merging", () => {
+      const changeset1 = new ComponentChangeset();
+      changeset1.delete(PositionId); // Initially removing
+
+      const changeset2 = new ComponentChangeset();
+      changeset2.set(PositionId, { x: 10, y: 20 }); // Adding the same component
+
+      changeset1.merge(changeset2);
+
+      expect(changeset1.adds.get(PositionId)).toEqual({ x: 10, y: 20 });
+      expect(changeset1.removes.has(PositionId)).toBe(false);
+    });
+
+    it("should override addition with removal when merging", () => {
+      const changeset1 = new ComponentChangeset();
+      changeset1.set(PositionId, { x: 5, y: 5 }); // Initially adding
+
+      const changeset2 = new ComponentChangeset();
+      changeset2.delete(PositionId); // Removing the same component
+
+      changeset1.merge(changeset2);
+
+      expect(changeset1.adds.has(PositionId)).toBe(false);
+      expect(changeset1.removes.has(PositionId)).toBe(true);
+    });
+
+    it("should merge multiple changesets sequentially", () => {
+      const changeset1 = new ComponentChangeset();
+      changeset1.set(PositionId, { x: 10, y: 20 });
+
+      const changeset2 = new ComponentChangeset();
+      changeset2.delete(PositionId);
+      changeset2.set(VelocityId, { x: 1, y: 2 });
+
+      const changeset3 = new ComponentChangeset();
+      changeset3.delete(VelocityId);
+      changeset3.set(HealthId, 100);
+
+      changeset1.merge(changeset2);
+      changeset1.merge(changeset3);
+
+      expect(changeset1.adds.has(PositionId)).toBe(false); // Removed by changeset2
+      expect(changeset1.removes.has(PositionId)).toBe(true);
+      expect(changeset1.adds.has(VelocityId)).toBe(false); // Removed by changeset3
+      expect(changeset1.removes.has(VelocityId)).toBe(true);
+      expect(changeset1.adds.get(HealthId)).toBe(100);
+      expect(changeset1.hasChanges()).toBe(true);
+    });
+
+    it("should handle merging empty changeset", () => {
+      const changeset1 = new ComponentChangeset();
+      changeset1.set(PositionId, { x: 10, y: 20 });
+
+      const changeset2 = new ComponentChangeset(); // Empty
+
+      changeset1.merge(changeset2);
+
+      expect(changeset1.adds.get(PositionId)).toEqual({ x: 10, y: 20 });
+      expect(changeset1.removes.size).toBe(0);
+      expect(changeset1.hasChanges()).toBe(true);
+    });
+  });
+});

package/src/__tests__/core/multi-map.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, test } from "bun:test";
+import { MultiMap } from "../../utils/multi-map";
+
+describe("MultiMap", () => {
+  test("add and get values", () => {
+    const mm = new MultiMap<string, number>();
+    mm.add("a", 1);
+    mm.add("a", 2);
+    mm.add("b", 3);
+
+    expect(mm.keyCount).toBe(2);
+    expect(mm.valueCount).toBe(3);
+
+    const aValues = mm.get("a");
+    expect(Array.from(aValues).sort()).toEqual([1, 2]);
+    expect(Array.from(mm.get("c"))).toEqual([]);
+  });
+
+  test("remove value and deleteKey behavior", () => {
+    const mm = new MultiMap<string, string>();
+    mm.add("x", "one");
+    mm.add("x", "two");
+    mm.add("y", "three");
+
+    expect(mm.valueCount).toBe(3);
+
+    const removed = mm.remove("x", "one");
+    expect(removed).toBe(true);
+    expect(mm.valueCount).toBe(2);
+    expect(mm.has("x", "one")).toBe(false);
+
+    // remove remaining value for x -> key removed
+    expect(mm.remove("x", "two")).toBe(true);
+    expect(mm.hasKey("x")).toBe(false);
+    expect(mm.keyCount).toBe(1);
+    expect(mm.valueCount).toBe(1);
+
+    // delete whole key y
+    expect(mm.deleteKey("y")).toBe(true);
+    expect(mm.keyCount).toBe(0);
+    expect(mm.valueCount).toBe(0);
+  });
+
+  test("keys, values and entries iteration", () => {
+    const mm = new MultiMap<number, string>();
+    mm.add(1, "a");
+    mm.add(1, "b");
+    mm.add(2, "c");
+
+    const keys = Array.from(mm.keys()).sort((a, b) => a - b);
+    expect(keys).toEqual([1, 2]);
+
+    const values = Array.from(mm.values()).sort();
+    expect(values).toEqual(["a", "b", "c"]);
+
+    const entries = Array.from(mm.entries());
+    // entries should be pairs of key and a Set copy
+    expect(entries.length).toBe(3);
+    const entryMap = new Map(entries);
+    expect(entryMap.get(1)!).toEqual("b");
+  });
+
+  test("clear resets state", () => {
+    const mm = new MultiMap<string, number>();
+    mm.add("k", 1);
+    mm.add("k", 2);
+    expect(mm.keyCount).toBe(1);
+    expect(mm.valueCount).toBe(2);
+    mm.clear();
+    expect(mm.keyCount).toBe(0);
+    expect(mm.valueCount).toBe(0);
+    expect(Array.from(mm.keys()).length).toBe(0);
+  });
+});

package/src/__tests__/entity/component-registry.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "bun:test";
+import { ComponentIdAllocator } from "../../entity/manager";
+import { COMPONENT_ID_MAX, createComponentId } from "../../entity/types";
+
+describe("ComponentIdAllocator", () => {
+  it("should allocate component IDs sequentially", () => {
+    const allocator = new ComponentIdAllocator();
+
+    const id1 = allocator.allocate();
+    const id2 = allocator.allocate();
+    const id3 = allocator.allocate();
+
+    expect(id1).toBe(createComponentId(1));
+    expect(id2).toBe(createComponentId(2));
+    expect(id3).toBe(createComponentId(3));
+  });
+
+  it("should throw when exceeding COMPONENT_ID_MAX", () => {
+    const allocator = new ComponentIdAllocator();
+
+    // Allocate up to the limit
+    for (let i = 1; i <= COMPONENT_ID_MAX; i++) {
+      allocator.allocate();
+    }
+
+    // The next allocation should throw
+    expect(() => allocator.allocate()).toThrow(/out of component IDs|overflow/i);
+  });
+
+  it("should check availability correctly", () => {
+    const allocator = new ComponentIdAllocator();
+
+    expect(allocator.hasAvailableIds()).toBe(true);
+
+    // Allocate up to the limit
+    for (let i = 1; i <= COMPONENT_ID_MAX; i++) {
+      allocator.allocate();
+    }
+
+    expect(allocator.hasAvailableIds()).toBe(false);
+  });
+
+  it("should track next ID correctly", () => {
+    const allocator = new ComponentIdAllocator();
+
+    expect(allocator.getNextId()).toBe(1);
+
+    allocator.allocate();
+    expect(allocator.getNextId()).toBe(2);
+
+    allocator.allocate();
+    expect(allocator.getNextId()).toBe(3);
+  });
+
+  it("should allocate exactly COMPONENT_ID_MAX IDs", () => {
+    const allocator = new ComponentIdAllocator();
+
+    for (let i = 1; i <= COMPONENT_ID_MAX; i++) {
+      const id = allocator.allocate();
+      expect(id).toBe(createComponentId(i));
+    }
+
+    // Should be exhausted now
+    expect(allocator.hasAvailableIds()).toBe(false);
+  });
+});