@codehz/ecs 0.7.2 → 0.7.3

package/src/__tests__/testing/entity-builder.test.ts

@@ -0,0 +1,84 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import { component, relation, type ComponentId } from "../../entity";
+import { EntityBuilder } from "../../testing/index";
+import { World } from "../../world/world";
+
+let PositionId: ComponentId<{ x: number; y: number }>;
+let VelocityId: ComponentId<{ x: number; y: number }>;
+let HealthId: ComponentId<{ current: number; max: number }>;
+let TagId: ComponentId<void>;
+let ParentId: ComponentId<{ offset: { x: number; y: number } }>;
+
+describe("EntityBuilder", () => {
+  beforeEach(() => {
+    PositionId = component<{ x: number; y: number }>();
+    VelocityId = component<{ x: number; y: number }>();
+    HealthId = component<{ current: number; max: number }>();
+    TagId = component<void>();
+    ParentId = component<{ offset: { x: number; y: number } }>();
+  });
+
+  it("should build entity with multiple components", () => {
+    const world = new World();
+    const entity = new EntityBuilder(world)
+      .with(PositionId, { x: 1, y: 2 })
+      .with(VelocityId, { x: 3, y: 4 })
+      .with(HealthId, { current: 100, max: 100 })
+      .build();
+    world.sync();
+
+    expect(world.has(entity, PositionId)).toBe(true);
+    expect(world.has(entity, VelocityId)).toBe(true);
+    expect(world.has(entity, HealthId)).toBe(true);
+  });
+
+  it("should support tag components", () => {
+    const world = new World();
+    const entity = new EntityBuilder(world).with(TagId).build();
+    world.sync();
+
+    expect(world.has(entity, TagId)).toBe(true);
+  });
+
+  it("should support relations", () => {
+    const world = new World();
+    const parent = new EntityBuilder(world).with(PositionId, { x: 0, y: 0 }).build();
+
+    const child = new EntityBuilder(world)
+      .with(PositionId, { x: 10, y: 10 })
+      .withRelation(ParentId, parent, { offset: { x: 5, y: 5 } })
+      .build();
+    world.sync();
+
+    const parentRelationId = relation(ParentId, parent);
+    expect(world.has(child, parentRelationId)).toBe(true);
+    expect(world.get(child, parentRelationId)).toEqual({ offset: { x: 5, y: 5 } });
+  });
+
+  it("should support relation tags", () => {
+    const ChildOfId = component<void>();
+    const world = new World();
+    const parent = world.new();
+    world.sync();
+
+    const child = new EntityBuilder(world).withRelation(ChildOfId, parent).build();
+    world.sync();
+
+    const relationId = relation(ChildOfId, parent);
+    expect(world.has(child, relationId)).toBe(true);
+  });
+
+  it("should support deferred build", () => {
+    const world = new World();
+    const e1 = new EntityBuilder(world).with(PositionId, { x: 1, y: 1 }).build();
+    const e2 = new EntityBuilder(world).with(PositionId, { x: 2, y: 2 }).build();
+
+    expect(world.has(e1, PositionId)).toBe(false);
+    expect(world.has(e2, PositionId)).toBe(false);
+
+    world.sync();
+
+    expect(world.has(e1, PositionId)).toBe(true);
+    expect(world.has(e2, PositionId)).toBe(true);
+  });
+});

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

@@ -0,0 +1,150 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import { component, type ComponentId } from "../../entity";
+import { Snapshot, WorldFixture, type WorldSnapshot } from "../../testing/index";
+
+let PositionId: ComponentId<{ x: number; y: number }>;
+let VelocityId: ComponentId<{ x: number; y: number }>;
+
+describe("Snapshot", () => {
+  beforeEach(() => {
+    PositionId = component<{ x: number; y: number }>();
+    VelocityId = component<{ x: number; y: number }>();
+  });
+
+  it("should capture entity state", () => {
+    const fixture = new WorldFixture();
+    const entity = fixture.spawn().with(PositionId, { x: 10, y: 20 }).with(VelocityId, { x: 1, y: 2 }).build();
+    fixture.sync();
+    const snapshot = Snapshot.capture(fixture.world, [entity], [PositionId, VelocityId]);
+
+    expect(snapshot.entities).toHaveLength(1);
+    expect(snapshot.entities[0]!.entity).toBe(entity);
+    expect(snapshot.entities[0]!.components.get(PositionId)).toEqual({ x: 10, y: 20 });
+    expect(snapshot.entities[0]!.components.get(VelocityId)).toEqual({ x: 1, y: 2 });
+  });
+
+  it("should capture multiple entities", () => {
+    const fixture = new WorldFixture();
+    const e1 = fixture.spawn().with(PositionId, { x: 1, y: 1 }).build();
+    const e2 = fixture.spawn().with(PositionId, { x: 2, y: 2 }).build();
+    fixture.sync();
+
+    const snapshot = Snapshot.capture(fixture.world, [e1, e2], [PositionId]);
+
+    expect(snapshot.entities).toHaveLength(2);
+  });
+
+  it("should skip non-existent entities", () => {
+    const fixture = new WorldFixture();
+    const entity = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+    fixture.world.delete(entity);
+    fixture.sync();
+
+    const snapshot = Snapshot.capture(fixture.world, [entity], [PositionId]);
+
+    expect(snapshot.entities).toHaveLength(0);
+  });
+
+  it("should detect added entities in diff", () => {
+    const before: WorldSnapshot = { entities: [] };
+    const fixture = new WorldFixture();
+    const entity = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+    fixture.sync();
+    const after = Snapshot.capture(fixture.world, [entity], [PositionId]);
+
+    const diff = Snapshot.compare(before, after);
+
+    expect(diff.addedEntities).toContain(entity);
+    expect(diff.removedEntities).toHaveLength(0);
+  });
+
+  it("should detect removed entities in diff", () => {
+    const fixture = new WorldFixture();
+    const entity = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+    fixture.sync();
+    const before = Snapshot.capture(fixture.world, [entity], [PositionId]);
+
+    fixture.world.delete(entity);
+    fixture.sync();
+
+    const after = Snapshot.capture(fixture.world, [entity], [PositionId]);
+    const diff = Snapshot.compare(before, after);
+
+    expect(diff.removedEntities).toContain(entity);
+    expect(diff.addedEntities).toHaveLength(0);
+  });
+
+  it("should detect component changes in diff", () => {
+    const fixture = new WorldFixture();
+    const entity = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+    fixture.sync();
+    const before = Snapshot.capture(fixture.world, [entity], [PositionId]);
+
+    fixture.world.set(entity, PositionId, { x: 100, y: 200 });
+    fixture.sync();
+
+    const after = Snapshot.capture(fixture.world, [entity], [PositionId]);
+    const diff = Snapshot.compare(before, after);
+
+    expect(diff.componentChanges).toHaveLength(1);
+    expect(diff.componentChanges[0]!.changeType).toBe("modified");
+    expect(diff.componentChanges[0]!.before).toEqual({ x: 0, y: 0 });
+    expect(diff.componentChanges[0]!.after).toEqual({ x: 100, y: 200 });
+  });
+
+  it("should detect added components in diff", () => {
+    const fixture = new WorldFixture();
+    const entity = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+    fixture.sync();
+    const before = Snapshot.capture(fixture.world, [entity], [PositionId, VelocityId]);
+
+    fixture.world.set(entity, VelocityId, { x: 1, y: 1 });
+    fixture.sync();
+
+    const after = Snapshot.capture(fixture.world, [entity], [PositionId, VelocityId]);
+    const diff = Snapshot.compare(before, after);
+
+    const velocityChange = diff.componentChanges.find((c) => c.componentId === VelocityId);
+    expect(velocityChange).toBeDefined();
+    expect(velocityChange!.changeType).toBe("added");
+  });
+
+  it("should detect removed components in diff", () => {
+    const fixture = new WorldFixture();
+    const entity = fixture.spawn().with(PositionId, { x: 0, y: 0 }).with(VelocityId, { x: 1, y: 1 }).build();
+    fixture.sync();
+    const before = Snapshot.capture(fixture.world, [entity], [PositionId, VelocityId]);
+
+    fixture.world.remove(entity, VelocityId);
+    fixture.sync();
+
+    const after = Snapshot.capture(fixture.world, [entity], [PositionId, VelocityId]);
+    const diff = Snapshot.compare(before, after);
+
+    const velocityChange = diff.componentChanges.find((c) => c.componentId === VelocityId);
+    expect(velocityChange).toBeDefined();
+    expect(velocityChange!.changeType).toBe("removed");
+  });
+
+  it("should check snapshot equality", () => {
+    const fixture = new WorldFixture();
+    const entity = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+    fixture.sync();
+    const snapshot1 = Snapshot.capture(fixture.world, [entity], [PositionId]);
+    const snapshot2 = Snapshot.capture(fixture.world, [entity], [PositionId]);
+
+    expect(Snapshot.equals(snapshot1, snapshot2)).toBe(true);
+  });
+
+  it("should isolate snapshots from mutations", () => {
+    const fixture = new WorldFixture();
+    const entity = fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+    fixture.sync();
+    const snapshot = Snapshot.capture(fixture.world, [entity], [PositionId]);
+
+    fixture.world.set(entity, PositionId, { x: 999, y: 999 });
+    fixture.sync();
+
+    expect(snapshot.entities[0]!.components.get(PositionId)).toEqual({ x: 0, y: 0 });
+  });
+});

package/src/__tests__/testing/world-fixture.test.ts

@@ -0,0 +1,73 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import { component, type ComponentId } from "../../entity";
+import { WorldFixture } from "../../testing/index";
+import { World } from "../../world/world";
+
+let PositionId: ComponentId<{ x: number; y: number }>;
+
+describe("WorldFixture", () => {
+  beforeEach(() => {
+    PositionId = component<{ x: number; y: number }>();
+  });
+
+  it("should create a world instance", () => {
+    const fixture = new WorldFixture();
+    expect(fixture.world).toBeInstanceOf(World);
+  });
+
+  it("should spawn entities with fluent API", () => {
+    const fixture = new WorldFixture();
+    const entity = fixture.spawn().with(PositionId, { x: 10, y: 20 }).build();
+    fixture.sync();
+
+    expect(fixture.world.exists(entity)).toBe(true);
+    expect(fixture.world.has(entity, PositionId)).toBe(true);
+    expect(fixture.world.get(entity, PositionId)).toEqual({ x: 10, y: 20 });
+  });
+
+  it("should spawn multiple entities", () => {
+    const fixture = new WorldFixture();
+    const entities = fixture.spawnMany(3, (builder, index) =>
+      builder.with(PositionId, { x: index * 10, y: index * 20 }),
+    );
+    fixture.sync();
+
+    expect(entities).toHaveLength(3);
+    expect(fixture.world.get(entities[0]!, PositionId)).toEqual({ x: 0, y: 0 });
+    expect(fixture.world.get(entities[1]!, PositionId)).toEqual({ x: 10, y: 20 });
+    expect(fixture.world.get(entities[2]!, PositionId)).toEqual({ x: 20, y: 40 });
+  });
+
+  it("should reset to fresh world", () => {
+    const fixture = new WorldFixture();
+    const entity = fixture.spawn().with(PositionId, { x: 10, y: 20 }).build();
+    const oldWorld = fixture.world;
+
+    fixture.reset();
+
+    expect(fixture.world).not.toBe(oldWorld);
+    expect(fixture.world.exists(entity)).toBe(false);
+  });
+
+  it("should track and dispose queries on reset", () => {
+    const fixture = new WorldFixture();
+    fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+    fixture.sync();
+
+    const query = fixture.createQuery([PositionId]);
+    expect(query.getEntities()).toHaveLength(1);
+
+    fixture.reset();
+    expect(query.disposed).toBe(true);
+  });
+
+  it("should support Symbol.dispose", () => {
+    const fixture = new WorldFixture();
+    fixture.spawn().with(PositionId, { x: 0, y: 0 }).build();
+    fixture.sync();
+    const query = fixture.createQuery([PositionId]);
+
+    fixture[Symbol.dispose]();
+    expect(query.disposed).toBe(true);
+  });
+});

package/src/__tests__/world/component-hooks.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, it } from "bun:test";
+import { component, type EntityId } from "../../entity";
+import { World } from "../../world/world";
+
+describe("World - Single Component Hooks", () => {
+  type Position = { x: number; y: number };
+
+  const positionComponent = component<Position>();
+
+  it("should trigger component initialized hooks", () => {
+    const world = new World();
+    const entity = world.new();
+    const position: Position = { x: 10, y: 20 };
+
+    let hookCalled = false;
+    let hookEntityId: EntityId | undefined;
+
+    let hookComponent: Position | undefined;
+
+    world.set(entity, positionComponent, position);
+    world.sync();
+
+    world.hook([positionComponent], {
+      on_init: (entityId, component) => {
+        hookCalled = true;
+        hookEntityId = entityId;
+        hookComponent = component;
+      },
+    });
+
+    expect(hookCalled).toBe(true);
+    expect(hookEntityId).toBe(entity);
+    expect(hookComponent).toEqual(position);
+  });
+
+  it("should trigger component added hooks", () => {
+    const world = new World();
+    const entity = world.new();
+    const position: Position = { x: 10, y: 20 };
+
+    let hookCalled = false;
+    let hookEntityId: EntityId | undefined;
+    let hookComponent: Position | undefined;
+
+    world.hook([positionComponent], {
+      on_set: (entityId, component) => {
+        hookCalled = true;
+        hookEntityId = entityId;
+        hookComponent = component;
+      },
+    });
+
+    world.set(entity, positionComponent, position);
+    world.sync();
+
+    expect(hookCalled).toBe(true);
+    expect(hookEntityId).toBe(entity);
+    expect(hookComponent).toEqual(position);
+  });
+
+  it("should trigger component removed hooks", () => {
+    const world = new World();
+    const entity = world.new();
+    const position: Position = { x: 10, y: 20 };
+
+    world.set(entity, positionComponent, position);
+    world.sync();
+
+    let hookCalled = false;
+    let hookEntityId: EntityId | undefined;
+    let hookComponent: Position | undefined;
+
+    world.hook([positionComponent], {
+      on_remove: (entityId, component) => {
+        hookCalled = true;
+        hookEntityId = entityId;
+        hookComponent = component;
+      },
+    });
+
+    world.remove(entity, positionComponent);
+    world.sync();
+
+    expect(hookCalled).toBe(true);
+    expect(hookEntityId).toBe(entity);
+    expect(hookComponent).toEqual(position);
+  });
+
+  it("should handle multiple hooks for the same component type", () => {
+    const world = new World();
+    const entity = world.new();
+    const position: Position = { x: 10, y: 20 };
+
+    let hook1Called = false;
+    let hook2Called = false;
+
+    world.hook([positionComponent], {
+      on_set: () => {
+        hook1Called = true;
+      },
+    });
+
+    world.hook([positionComponent], {
+      on_set: () => {
+        hook2Called = true;
+      },
+    });
+
+    world.set(entity, positionComponent, position);
+    world.sync();
+
+    expect(hook1Called).toBe(true);
+    expect(hook2Called).toBe(true);
+  });
+
+  it("should support hooks with both onAdded and onRemoved", () => {
+    const world = new World();
+    const entity = world.new();
+    const position: Position = { x: 10, y: 20 };
+
+    let addedCalled = false;
+    let removedCalled = false;
+
+    world.hook([positionComponent], {
+      on_set: () => {
+        addedCalled = true;
+      },
+      on_remove: () => {
+        removedCalled = true;
+      },
+    });
+
+    world.set(entity, positionComponent, position);
+    world.sync();
+
+    expect(addedCalled).toBe(true);
+    expect(removedCalled).toBe(false);
+
+    world.remove(entity, positionComponent);
+    world.sync();
+
+    expect(removedCalled).toBe(true);
+  });
+
+  it("should support hooks with only onAdded", () => {
+    const world = new World();
+    const entity = world.new();
+    const position: Position = { x: 10, y: 20 };
+
+    let addedCalled = false;
+
+    world.hook([positionComponent], {
+      on_set: () => {
+        addedCalled = true;
+      },
+    });
+
+    world.set(entity, positionComponent, position);
+    world.sync();
+
+    expect(addedCalled).toBe(true);
+  });
+
+  it("should support hooks with only onRemoved", () => {
+    const world = new World();
+    const entity = world.new();
+    const position: Position = { x: 10, y: 20 };
+
+    world.set(entity, positionComponent, position);
+    world.sync();
+
+    let removedCalled = false;
+
+    world.hook([positionComponent], {
+      on_remove: () => {
+        removedCalled = true;
+      },
+    });
+
+    world.remove(entity, positionComponent);
+    world.sync();
+
+    expect(removedCalled).toBe(true);
+  });
+});