@codehz/ecs 0.7.2 → 0.7.4

package/src/__tests__/relations/wildcard.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, it } from "bun:test";
+import { component, relation } from "../../entity";
+import { World } from "../../world/world";
+
+describe("Wildcard relation edge cases", () => {
+  it("should handle empty wildcard matches", () => {
+    const world = new World();
+    const Likes = component<any>();
+    const entity = world.new();
+
+    // Query wildcard relation but entity has no relations
+    const results = world.get(entity, relation(Likes, "*"));
+    expect(results).toEqual([]);
+  });
+
+  it("should get wildcard relations with data", () => {
+    const world = new World();
+    const Follows = component<{ level: number }>();
+    const entity = world.new();
+    const target1 = world.new();
+    const target2 = world.new();
+
+    // Add relations with data
+    world.set(entity, relation(Follows, target1), { level: 1 });
+    world.set(entity, relation(Follows, target2), { level: 2 });
+    world.sync();
+
+    const results = world.get(entity, relation(Follows, "*"));
+    expect(results).toHaveLength(2);
+    expect(results.map((r: any) => r[0])).toContain(target1);
+    expect(results.map((r: any) => r[0])).toContain(target2);
+  });
+
+  it("should handle large number of wildcard relations", () => {
+    const world = new World();
+    const Likes = component<{ strength: number }>();
+    const entity = world.new();
+
+    // Create 100 relations
+    const targets = [];
+    for (let i = 0; i < 100; i++) {
+      const target = world.new();
+      targets.push(target);
+      world.set(entity, relation(Likes, target), { strength: i });
+    }
+
+    world.sync();
+
+    // Query all wildcard relations
+    const results = world.get(entity, relation(Likes, "*"));
+    expect(results).toHaveLength(100);
+
+    // Verify structure
+    for (const [target, data] of results) {
+      expect(targets).toContain(target as any);
+      expect(data.strength).toBeGreaterThanOrEqual(0);
+      expect(data.strength).toBeLessThan(100);
+    }
+  });
+
+  it("should remove wildcard relations correctly", () => {
+    const world = new World();
+    const Owns = component<{ quantity: number }>();
+    const entity = world.new();
+    const target1 = world.new();
+    const target2 = world.new();
+
+    world.set(entity, relation(Owns, target1), { quantity: 5 });
+    world.set(entity, relation(Owns, target2), { quantity: 3 });
+    world.sync();
+
+    expect(world.get(entity, relation(Owns, "*"))).toHaveLength(2);
+
+    // Remove all wildcard relations
+    world.remove(entity, relation(Owns, "*"));
+    world.sync();
+
+    const results = world.get(entity, relation(Owns, "*"));
+    expect(results).toEqual([]);
+
+    // Verify specific relations are also gone
+    expect(world.has(entity, relation(Owns, target1))).toBe(false);
+    expect(world.has(entity, relation(Owns, target2))).toBe(false);
+  });
+
+  it("should update wildcard relations", () => {
+    const world = new World();
+    const Knows = component<{ years: number }>();
+    const entity = world.new();
+    const target = world.new();
+
+    world.set(entity, relation(Knows, target), { years: 1 });
+    world.sync();
+
+    const initialResult = world.get(entity, relation(Knows, "*"));
+    expect(initialResult).toHaveLength(1);
+    expect(initialResult[0]![1]).toEqual({ years: 1 });
+
+    // Update the relation
+    world.set(entity, relation(Knows, target), { years: 5 });
+    world.sync();
+
+    const updatedResult = world.get(entity, relation(Knows, "*"));
+    expect(updatedResult).toHaveLength(1);
+    expect(updatedResult[0]![1]).toEqual({ years: 5 });
+  });
+
+  it("should handle dontFragment wildcard relations", () => {
+    const world = new World();
+    const Follows = component<{ data: number }>({ dontFragment: true });
+    const entity1 = world.new();
+    const entity2 = world.new();
+    const target1 = world.new();
+    const target2 = world.new();
+
+    // Add different wildcard relations to different entities
+    world.set(entity1, relation(Follows, target1), { data: 1 });
+    world.set(entity2, relation(Follows, target2), { data: 2 });
+    world.sync();
+
+    // Query both wildcards
+    const results1 = world.get(entity1, relation(Follows, "*"));
+    const results2 = world.get(entity2, relation(Follows, "*"));
+
+    expect(results1).toHaveLength(1);
+    expect(results2).toHaveLength(1);
+
+    // Both entities should be in the same archetype (dontFragment behavior)
+    const archetype1 = (world as any).entityToArchetype.get(entity1);
+    const archetype2 = (world as any).entityToArchetype.get(entity2);
+    expect(archetype1).toBe(archetype2);
+  });
+
+  it("should handle exclusive wildcard relations", () => {
+    const world = new World();
+    const ChildOf = component<{ priority: number }>({ exclusive: true });
+    const entity = world.new();
+    const parent1 = world.new();
+    const parent2 = world.new();
+
+    world.set(entity, relation(ChildOf, parent1), { priority: 1 });
+    world.sync();
+
+    const results1 = world.get(entity, relation(ChildOf, "*"));
+    expect(results1).toHaveLength(1);
+
+    // Set another parent - should replace the first due to exclusive
+    world.set(entity, relation(ChildOf, parent2), { priority: 2 });
+    world.sync();
+
+    const results2 = world.get(entity, relation(ChildOf, "*"));
+    expect(results2).toHaveLength(1);
+    expect(results2[0]![0]).toBe(parent2);
+  });
+
+  it("should mix specific and wildcard queries", () => {
+    const world = new World();
+    const Relates = component<{ value: number }>();
+    const entity = world.new();
+    const target1 = world.new();
+    const target2 = world.new();
+
+    world.set(entity, relation(Relates, target1), { value: 10 });
+    world.set(entity, relation(Relates, target2), { value: 20 });
+    world.sync();
+
+    // Get specific relation
+    expect(world.has(entity, relation(Relates, target1))).toBe(true);
+    expect(world.get(entity, relation(Relates, target1))).toEqual({ value: 10 });
+
+    // Get all via wildcard
+    const all = world.get(entity, relation(Relates, "*"));
+    expect(all).toHaveLength(2);
+
+    // Get specific relation again
+    expect(world.has(entity, relation(Relates, target2))).toBe(true);
+    expect(world.get(entity, relation(Relates, target2))).toEqual({ value: 20 });
+  });
+});

package/src/__tests__/serialization/bounds.test.ts

@@ -0,0 +1,237 @@
+import { describe, expect, it } from "bun:test";
+import { component, type EntityId } from "../../entity";
+import { World } from "../../world/world";
+
+describe("Serialization edge cases", () => {
+  it("should serialize empty world", () => {
+    const world = new World();
+    const snapshot = world.serialize();
+
+    expect(snapshot.entities).toHaveLength(0);
+    expect(snapshot.version).toBeDefined();
+
+    const newWorld = new World(snapshot);
+    expect(newWorld.exists(-1 as unknown as ReturnType<typeof world.new>)).toBe(false);
+  });
+
+  it("should serialize and deserialize single entity", () => {
+    const world = new World();
+    const Position = component<{ x: number; y: number }>();
+    const entity = world.new();
+
+    world.set(entity, Position, { x: 10, y: 20 });
+    world.sync();
+
+    const snapshot = world.serialize();
+    const newWorld = new World(snapshot);
+
+    expect(newWorld.exists(entity)).toBe(true);
+    expect(newWorld.get(entity, Position)).toEqual({ x: 10, y: 20 });
+  });
+
+  it("should serialize world with many entities", () => {
+    const world = new World();
+    const Value = component<{ id: number }>();
+
+    const entities: EntityId[] = [];
+    // Create 100 entities
+    for (let i = 0; i < 100; i++) {
+      const entity = world.new();
+      entities.push(entity);
+      world.set(entity, Value, { id: i });
+    }
+    world.sync();
+
+    const snapshot = world.serialize();
+    const newWorld = new World(snapshot);
+
+    // Verify all entities exist
+    for (let i = 0; i < entities.length; i++) {
+      expect(newWorld.exists(entities[i]!)).toBe(true);
+      const data = newWorld.get(entities[i]!, Value);
+      expect(data.id).toBe(i);
+    }
+  });
+
+  it("should serialize multiple components per entity", () => {
+    const world = new World();
+    const Position = component<{ x: number; y: number }>();
+    const Velocity = component<{ dx: number; dy: number }>();
+    const Health = component<{ hp: number }>();
+
+    const entity = world.new();
+    world.set(entity, Position, { x: 1, y: 2 });
+    world.set(entity, Velocity, { dx: 3, dy: 4 });
+    world.set(entity, Health, { hp: 100 });
+    world.sync();
+
+    const snapshot = world.serialize();
+    const newWorld = new World(snapshot);
+
+    expect(newWorld.get(entity, Position)).toEqual({ x: 1, y: 2 });
+    expect(newWorld.get(entity, Velocity)).toEqual({ dx: 3, dy: 4 });
+    expect(newWorld.get(entity, Health)).toEqual({ hp: 100 });
+  });
+
+  it("should handle circular entity references in serialization", () => {
+    const world = new World();
+    const Ref = component<{ ref: EntityId }>();
+
+    const e1 = world.new();
+    const e2 = world.new();
+
+    world.set(e1, Ref, { ref: e2 });
+    world.set(e2, Ref, { ref: e1 });
+    world.sync();
+
+    const snapshot = world.serialize();
+    const newWorld = new World(snapshot);
+
+    expect(newWorld.exists(e1)).toBe(true);
+    expect(newWorld.exists(e2)).toBe(true);
+
+    // Verify circular references are preserved
+    const ref1 = newWorld.get(e1, Ref).ref;
+    const ref2 = newWorld.get(e2, Ref).ref;
+
+    // References should be maintained
+    expect(ref1).toBe(e2);
+    expect(ref2).toBe(e1);
+  });
+
+  it("should serialize with void components", () => {
+    const world = new World();
+    const Tag = component<void>();
+    const entity = world.new();
+
+    world.set(entity, Tag);
+    world.sync();
+
+    const snapshot = world.serialize();
+    const newWorld = new World(snapshot);
+
+    expect(newWorld.has(entity, Tag)).toBe(true);
+  });
+
+  it("should serialize with undefined component values", () => {
+    const world = new World();
+    const Optional = component<{ value: number } | undefined>();
+    const entity = world.new();
+
+    world.set(entity, Optional, undefined);
+    world.sync();
+
+    const snapshot = world.serialize();
+    const newWorld = new World(snapshot);
+
+    expect(newWorld.has(entity, Optional)).toBe(true);
+    expect(newWorld.get(entity, Optional)).toBeUndefined();
+  });
+
+  it("should round-trip serialization", () => {
+    const world1 = new World();
+    const Data = component<{ x: number; y: number }>();
+
+    const entities: EntityId[] = [];
+    for (let i = 0; i < 10; i++) {
+      const entity = world1.new();
+      entities.push(entity);
+      world1.set(entity, Data, { x: i, y: i * 2 });
+    }
+    world1.sync();
+
+    // First serialization
+    const snapshot1 = world1.serialize();
+    const world2 = new World(snapshot1);
+
+    // Second serialization
+    const snapshot2 = world2.serialize();
+
+    // Snapshots should be equivalent
+    expect(snapshot1.entities).toHaveLength(snapshot2.entities.length);
+    expect(snapshot1.version).toBe(snapshot2.version);
+
+    // Verify data is preserved
+    for (const entity of entities) {
+      expect(world2.get(entity, Data)).toBeDefined();
+    }
+  });
+
+  it("should preserve entity existence across serialization", () => {
+    const world = new World();
+    const Dummy = component<any>();
+
+    const entities: EntityId[] = [];
+    for (let i = 0; i < 50; i++) {
+      const entity = world.new();
+      entities.push(entity);
+      world.set(entity, Dummy, { num: i });
+    }
+    world.sync();
+
+    const snapshot = world.serialize();
+    const newWorld = new World(snapshot);
+
+    // All entities should exist in new world
+    for (const entity of entities) {
+      expect(newWorld.exists(entity)).toBe(true);
+    }
+  });
+
+  it("should handle mixed component types in serialization", () => {
+    const world = new World();
+    const String = component<string>();
+    const Number = component<number>();
+    const Boolean = component<boolean>();
+    const Object = component<{ nested: { value: number } }>();
+
+    const entity = world.new();
+    world.set(entity, String, "test");
+    world.set(entity, Number, 42);
+    world.set(entity, Boolean, true);
+    world.set(entity, Object, { nested: { value: 123 } });
+    world.sync();
+
+    const snapshot = world.serialize();
+    const newWorld = new World(snapshot);
+
+    expect(newWorld.get(entity, String)).toBe("test");
+    expect(newWorld.get(entity, Number)).toBe(42);
+    expect(newWorld.get(entity, Boolean)).toBe(true);
+    expect(newWorld.get(entity, Object)).toEqual({ nested: { value: 123 } });
+  });
+
+  it("should serialize entities with different archetypes", () => {
+    const world = new World();
+    const Position = component<{ x: number }>();
+    const Velocity = component<{ vx: number }>();
+
+    // Entity with both components
+    const e1 = world.new();
+    world.set(e1, Position, { x: 10 });
+    world.set(e1, Velocity, { vx: 5 });
+
+    // Entity with only Position
+    const e2 = world.new();
+    world.set(e2, Position, { x: 20 });
+
+    // Entity with only Velocity
+    const e3 = world.new();
+    world.set(e3, Velocity, { vx: 15 });
+
+    world.sync();
+
+    const snapshot = world.serialize();
+    const newWorld = new World(snapshot);
+
+    // Verify all entities and their components
+    expect(newWorld.get(e1, Position)).toEqual({ x: 10 });
+    expect(newWorld.get(e1, Velocity)).toEqual({ vx: 5 });
+
+    expect(newWorld.get(e2, Position)).toEqual({ x: 20 });
+    expect(newWorld.has(e2, Velocity)).toBe(false);
+
+    expect(newWorld.has(e3, Position)).toBe(false);
+    expect(newWorld.get(e3, Velocity)).toEqual({ vx: 15 });
+  });
+});

package/src/__tests__/testing/assertions.test.ts

@@ -0,0 +1,224 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import { component, type ComponentId } from "../../entity";
+import { AssertionError, Assertions, WorldFixture } from "../../testing/index";
+
+let PositionId: ComponentId<{ x: number; y: number }>;
+let VelocityId: ComponentId<{ x: number; y: number }>;
+let ParentId: ComponentId<{ offset: { x: number; y: number } }>;
+
+describe("Assertions", () => {
+  beforeEach(() => {
+    PositionId = component<{ x: number; y: number }>();
+    VelocityId = component<{ x: number; y: number }>();
+    ParentId = component<{ offset: { x: number; y: number } }>();
+  });
+
+  describe("hasComponent / lacksComponent", () => {
+    it("should return true when entity has component", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+      fixture.sync();
+      expect(Assertions.hasComponent(fixture.world, entity, PositionId)).toBe(true);
+      expect(Assertions.lacksComponent(fixture.world, entity, PositionId)).toBe(false);
+    });
+
+    it("should return false when entity lacks component", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+      fixture.sync();
+      expect(Assertions.hasComponent(fixture.world, entity, VelocityId)).toBe(false);
+      expect(Assertions.lacksComponent(fixture.world, entity, VelocityId)).toBe(true);
+    });
+
+    it("should handle non-existent entities", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().build();
+      fixture.world.delete(entity);
+      fixture.sync();
+
+      expect(Assertions.hasComponent(fixture.world, entity, PositionId)).toBe(false);
+      expect(Assertions.lacksComponent(fixture.world, entity, PositionId)).toBe(true);
+    });
+  });
+
+  describe("getComponent", () => {
+    it("should return component value", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().with(PositionId, { x: 42, y: 84 }).build();
+      fixture.sync();
+      expect(Assertions.getComponent(fixture.world, entity, PositionId)).toEqual({ x: 42, y: 84 });
+    });
+
+    it("should return undefined for missing component", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().build();
+      fixture.sync();
+      expect(Assertions.getComponent(fixture.world, entity, PositionId)).toBeUndefined();
+    });
+  });
+
+  describe("entityExists", () => {
+    it("should return true for existing entity", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().build();
+      fixture.sync();
+      expect(Assertions.entityExists(fixture.world, entity)).toBe(true);
+    });
+
+    it("should return false for deleted entity", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().build();
+      fixture.world.delete(entity);
+      fixture.sync();
+
+      expect(Assertions.entityExists(fixture.world, entity)).toBe(false);
+    });
+  });
+
+  describe("query assertions", () => {
+    it("should check query contains entities", () => {
+      const fixture = new WorldFixture();
+      const e1 = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+      const e2 = fixture.spawn().with(PositionId, { x: 1, y: 1 }).build();
+      const e3 = fixture.spawn().with(VelocityId, { x: 0, y: 0 }).build();
+      fixture.sync();
+
+      const query = fixture.createQuery([PositionId]);
+
+      expect(Assertions.queryContains(query, e1)).toBe(true);
+      expect(Assertions.queryContains(query, e1, e2)).toBe(true);
+      expect(Assertions.queryContains(query, e3)).toBe(false);
+    });
+
+    it("should check query contains exactly", () => {
+      const fixture = new WorldFixture();
+      const e1 = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+      const e2 = fixture.spawn().with(PositionId, { x: 1, y: 1 }).build();
+      fixture.sync();
+
+      const query = fixture.createQuery([PositionId]);
+
+      expect(Assertions.queryContainsExactly(query, e1, e2)).toBe(true);
+      expect(Assertions.queryContainsExactly(query, e1)).toBe(false);
+    });
+
+    it("should count query entities", () => {
+      const fixture = new WorldFixture();
+      fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+      fixture.sync();
+      fixture.spawn().with(PositionId, { x: 1, y: 1 }).build();
+      fixture.sync();
+
+      const query = fixture.createQuery([PositionId]);
+
+      expect(Assertions.queryCount(query)).toBe(2);
+    });
+  });
+
+  describe("throwing assertions", () => {
+    it("assertHasComponent should throw for missing component", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().build();
+
+      expect(() => Assertions.assertHasComponent(fixture.world, entity, PositionId)).toThrow(AssertionError);
+    });
+
+    it("assertHasComponent should not throw for existing component", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+      fixture.sync();
+      expect(() => Assertions.assertHasComponent(fixture.world, entity, PositionId)).not.toThrow();
+    });
+
+    it("assertLacksComponent should throw for existing component", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+      fixture.sync();
+      expect(() => Assertions.assertLacksComponent(fixture.world, entity, PositionId)).toThrow(AssertionError);
+    });
+
+    it("assertComponentEquals should throw for mismatched value", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().with(PositionId, { x: 1, y: 2 }).build();
+      fixture.sync();
+      expect(() => Assertions.assertComponentEquals(fixture.world, entity, PositionId, { x: 99, y: 99 })).toThrow(
+        AssertionError,
+      );
+    });
+
+    it("assertComponentEquals should not throw for matching value", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().with(PositionId, { x: 1, y: 2 }).build();
+      fixture.sync();
+      expect(() => Assertions.assertComponentEquals(fixture.world, entity, PositionId, { x: 1, y: 2 })).not.toThrow();
+    });
+
+    it("assertEntityExists should throw for non-existent entity", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().build();
+      fixture.world.delete(entity);
+      fixture.sync();
+
+      expect(() => Assertions.assertEntityExists(fixture.world, entity)).toThrow(AssertionError);
+    });
+
+    it("assertEntityNotExists should throw for existing entity", () => {
+      const fixture = new WorldFixture();
+      const entity = fixture.spawn().build();
+
+      expect(() => Assertions.assertEntityNotExists(fixture.world, entity)).toThrow(AssertionError);
+    });
+
+    it("assertQueryContains should throw when entity missing", () => {
+      const fixture = new WorldFixture();
+      const e1 = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+      const e2 = fixture.spawn().with(VelocityId, { x: 0, y: 0 }).build();
+      fixture.sync();
+
+      const query = fixture.createQuery([PositionId]);
+
+      expect(() => Assertions.assertQueryContains(query, e2)).toThrow(AssertionError);
+      expect(() => Assertions.assertQueryContains(query, e1)).not.toThrow();
+    });
+
+    it("assertQueryNotContains should throw when entity present", () => {
+      const fixture = new WorldFixture();
+      const e1 = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+      fixture.sync();
+
+      const query = fixture.createQuery([PositionId]);
+
+      expect(() => Assertions.assertQueryNotContains(query, e1)).toThrow(AssertionError);
+    });
+  });
+
+  describe("relation assertions", () => {
+    it("should check hasRelation", () => {
+      const fixture = new WorldFixture();
+      const parent = fixture.spawn().build();
+      const child = fixture
+        .spawn()
+        .withRelation(ParentId, parent, { offset: { x: 0, y: 0 } })
+        .build();
+      fixture.sync();
+
+      expect(Assertions.hasRelation(fixture.world, child, ParentId, parent)).toBe(true);
+      expect(Assertions.hasRelation(fixture.world, parent, ParentId, child)).toBe(false);
+    });
+
+    it("should get relations via wildcard", () => {
+      const fixture = new WorldFixture();
+      const target1 = fixture.spawn().build();
+      const target2 = fixture.spawn().build();
+      const entity = fixture
+        .spawn()
+        .withRelation(ParentId, target1, { offset: { x: 1, y: 1 } })
+        .withRelation(ParentId, target2, { offset: { x: 2, y: 2 } })
+        .build();
+      fixture.sync();
+
+      const relations = Assertions.getRelations(fixture.world, entity, ParentId);
+      expect(relations).toHaveLength(2);
+    });
+  });
+});