archetype-ecs 1.4.2 → 1.5.0

package/tests/EntityManager.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { createEntityManager, type EntityManager } from '../src/EntityManager.js';
-import { component } from '../src/index.js';
+import { component, type ComponentDef } from '../src/index.js';
 
 describe('EntityManager', () => {
   let em: EntityManager;
@@ -140,7 +140,7 @@ describe('EntityManager', () => {
       [Velocity._sym, 'Velocity'],
       [Health._sym, 'Health']
     ]);
-    const nameToSymbol: Record<string, any> = { Position, Velocity, Health };
+    const nameToSymbol: Record<string, ComponentDef> = { Position, Velocity, Health };
 
     it('round-trips entities and components', () => {
       const a = em.createEntity();
@@ -195,27 +195,27 @@ describe('EntityManager', () => {
 
       const result = em.serialize(metaSymbolToName, [], [], { serializers });
       assert.deepEqual(result.components['Meta'][a], { x: 1, y: 2 });
-      assert.equal((result.components['Meta'][a] as any).secret, undefined);
+      assert.equal((result.components['Meta'][a] as Record<string, unknown>).secret, undefined);
     });
 
     it('custom deserializers are used when provided', () => {
       const Meta = component('Meta2', { x: 'f32', y: 'f32' });
       const metaSymbolToName = new Map([...symbolToName, [Meta._sym, 'Meta2']]);
-      const metaNameToSymbol: Record<string, any> = { ...nameToSymbol, Meta2: Meta };
+      const metaNameToSymbol: Record<string, ComponentDef> = { ...nameToSymbol, Meta2: Meta };
 
       const a = em.createEntity();
       em.addComponent(a, Meta, { x: 1, y: 2 });
 
       const data = em.serialize(metaSymbolToName);
 
-      const deserializers = new Map<string, (data: any) => any>([
-        ['Meta2', (compData: any) => ({ ...compData, restored: true })]
+      const deserializers = new Map<string, (data: unknown) => unknown>([
+        ['Meta2', (compData) => ({ ...(compData as Record<string, unknown>), restored: true })]
       ]);
 
       em.deserialize(data, metaNameToSymbol, { deserializers });
-      const result = em.getComponent(a, Meta);
-      assert.ok(Math.abs(result.x - 1) < 0.01);
-      assert.ok(Math.abs(result.y - 2) < 0.01);
+      const result = em.getComponent(a, Meta)!;
+      assert.ok(Math.abs(result.x as number - 1) < 0.01);
+      assert.ok(Math.abs(result.y as number - 2) < 0.01);
     });
 
     it('deserialize clears previous state', () => {
@@ -239,9 +239,9 @@ describe('Typed Components (SoA)', () => {
     const Pos = component('Pos', 'f32', ['x', 'y']);
     const id = em.createEntity();
     em.addComponent(id, Pos, { x: 1.5, y: 2.5 });
-    const result = em.getComponent(id, Pos);
-    assert.ok(Math.abs(result.x - 1.5) < 0.001);
-    assert.ok(Math.abs(result.y - 2.5) < 0.001);
+    const result = em.getComponent(id, Pos)!;
+    assert.ok(Math.abs(result.x as number - 1.5) < 0.001);
+    assert.ok(Math.abs(result.y as number - 2.5) < 0.001);
   });
 
   it('growth past initial capacity (>64 entities)', () => {
@@ -253,9 +253,9 @@ describe('Typed Components (SoA)', () => {
       ids.push(id);
     }
     for (let i = 0; i < 100; i++) {
-      const result = em.getComponent(ids[i], Pos);
-      assert.ok(Math.abs(result.x - i) < 0.001);
-      assert.ok(Math.abs(result.y - i * 2) < 0.001);
+      const result = em.getComponent(ids[i], Pos)!;
+      assert.ok(Math.abs(result.x as number - i) < 0.001);
+      assert.ok(Math.abs(result.y as number - i * 2) < 0.001);
     }
   });
 
@@ -270,10 +270,10 @@ describe('Typed Components (SoA)', () => {
 
     em.destroyEntity(a);
 
-    const resultB = em.getComponent(b, Pos);
-    assert.ok(Math.abs(resultB.x - 3) < 0.001);
-    const resultC = em.getComponent(c, Pos);
-    assert.ok(Math.abs(resultC.x - 5) < 0.001);
+    const resultB = em.getComponent(b, Pos)!;
+    assert.ok(Math.abs(resultB.x as number - 3) < 0.001);
+    const resultC = em.getComponent(c, Pos)!;
+    assert.ok(Math.abs(resultC.x as number - 5) < 0.001);
   });
 
   it('typed + tag on same entity', () => {
@@ -283,8 +283,8 @@ describe('Typed Components (SoA)', () => {
     em.addComponent(id, Pos, { x: 10, y: 20 });
     em.addComponent(id, Tag, {});
 
-    const pos = em.getComponent(id, Pos);
-    assert.ok(Math.abs(pos.x - 10) < 0.001);
+    const pos = em.getComponent(id, Pos)!;
+    assert.ok(Math.abs(pos.x as number - 10) < 0.001);
     assert.equal(em.getComponent(id, Tag), undefined);
     assert.equal(em.hasComponent(id, Tag), true);
   });
@@ -300,10 +300,10 @@ describe('Typed Components (SoA)', () => {
     }
 
     em.forEach([Pos, Vel], (arch) => {
-      const px = arch.field(Pos.x);
-      const py = arch.field(Pos.y);
-      const vx = arch.field(Vel.vx);
-      const vy = arch.field(Vel.vy);
+      const px = arch.field(Pos.x) as Float32Array;
+      const py = arch.field(Pos.y) as Float32Array;
+      const vx = arch.field(Vel.vx) as Float32Array;
+      const vy = arch.field(Vel.vy) as Float32Array;
       for (let i = 0; i < arch.count; i++) {
         px[i] += vx[i];
         py[i] += vy[i];
@@ -312,16 +312,16 @@ describe('Typed Components (SoA)', () => {
 
     const ids = em.query([Pos, Vel]);
     for (const id of ids) {
-      const pos = em.getComponent(id, Pos);
-      assert.ok(pos.x >= 1);
-      assert.ok(Math.abs(pos.y - 2) < 0.001);
+      const pos = em.getComponent(id, Pos)!;
+      assert.ok((pos.x as number) >= 1);
+      assert.ok(Math.abs(pos.y as number - 2) < 0.001);
     }
   });
 
   it('serialize/deserialize round-trip with typed components', () => {
     const Pos = component('PosSer', 'f32', ['x', 'y']);
     const symbolToName = new Map([[Pos._sym, 'PosSer']]);
-    const nameToSymbol: Record<string, any> = { PosSer: Pos };
+    const nameToSymbol: Record<string, ComponentDef> = { PosSer: Pos };
 
     const a = em.createEntity();
     em.addComponent(a, Pos, { x: 1.5, y: 2.5 });
@@ -331,10 +331,10 @@ describe('Typed Components (SoA)', () => {
     const data = em.serialize(symbolToName);
     em.deserialize(data, nameToSymbol);
 
-    const posA = em.getComponent(a, Pos);
-    assert.ok(Math.abs(posA.x - 1.5) < 0.01);
-    const posB = em.getComponent(b, Pos);
-    assert.ok(Math.abs(posB.x - 3.5) < 0.01);
+    const posA = em.getComponent(a, Pos)!;
+    assert.ok(Math.abs(posA.x as number - 1.5) < 0.01);
+    const posB = em.getComponent(b, Pos)!;
+    assert.ok(Math.abs(posB.x as number - 3.5) < 0.01);
   });
 
   it('archetype migration with typed components', () => {
@@ -345,12 +345,12 @@ describe('Typed Components (SoA)', () => {
     em.addComponent(id, Pos, { x: 5, y: 10 });
     em.addComponent(id, Vel, { vx: 1, vy: 2 });
 
-    const pos = em.getComponent(id, Pos);
-    assert.ok(Math.abs(pos.x - 5) < 0.001);
+    const pos = em.getComponent(id, Pos)!;
+    assert.ok(Math.abs(pos.x as number - 5) < 0.001);
 
     em.removeComponent(id, Vel);
-    const pos2 = em.getComponent(id, Pos);
-    assert.ok(Math.abs(pos2.x - 5) < 0.001);
+    const pos2 = em.getComponent(id, Pos)!;
+    assert.ok(Math.abs(pos2.x as number - 5) < 0.001);
     assert.equal(em.hasComponent(id, Vel), false);
   });
 
@@ -359,17 +359,17 @@ describe('Typed Components (SoA)', () => {
     const id = em.createEntity();
     em.addComponent(id, Pos, { x: 1, y: 2 });
     em.addComponent(id, Pos, { x: 99, y: 88 });
-    const result = em.getComponent(id, Pos);
-    assert.ok(Math.abs(result.x - 99) < 0.001);
+    const result = em.getComponent(id, Pos)!;
+    assert.ok(Math.abs(result.x as number - 99) < 0.001);
   });
 
   it('get/set for zero-allocation field access', () => {
     const Pos = component('PosGS', 'f32', ['x', 'y']);
     const id = em.createEntity();
     em.addComponent(id, Pos, { x: 3.5, y: 7.5 });
-    assert.ok(Math.abs(em.get(id, Pos.x) - 3.5) < 0.001);
+    assert.ok(Math.abs(em.get(id, Pos.x)! as number - 3.5) < 0.001);
     em.set(id, Pos.x, 42);
-    assert.ok(Math.abs(em.get(id, Pos.x) - 42) < 0.001);
+    assert.ok(Math.abs(em.get(id, Pos.x)! as number - 42) < 0.001);
   });
 
   it('get returns undefined for missing entity/component', () => {
@@ -447,7 +447,7 @@ describe('Typed Components (SoA)', () => {
     em.addComponent(id, Item, { name: 'Sword', weight: 3.5 });
 
     assert.equal(em.get(id, Item.name), 'Sword');
-    assert.ok(Math.abs(em.get(id, Item.weight) - 3.5) < 0.01);
+    assert.ok(Math.abs(em.get(id, Item.weight)! as number - 3.5) < 0.01);
   });
 
   it('string component forEach field access', () => {
@@ -470,7 +470,6 @@ describe('Deferred Structural Changes during forEach', () => {
   let em: EntityManager;
   const Pos = component('DPos', 'f32', ['x', 'y']);
   const Vel = component('DVel', 'f32', ['vx', 'vy']);
-  const Tag = component('DTag');
 
   beforeEach(() => {
     em = createEntityManager();
@@ -489,23 +488,13 @@ describe('Deferred Structural Changes during forEach', () => {
       const ids = arch.entityIds;
       for (let i = 0; i < arch.count; i++) {
         visited.push(ids[i]);
-        // Remove first entity during iteration — should be deferred
-        if (ids[i] === a) {
-          em.removeComponent(a, Pos);
-        }
+        if (ids[i] === a) em.removeComponent(a, Pos);
       }
     });
 
-    // All 3 should have been visited (removal was deferred)
     assert.equal(visited.length, 3);
-    assert.ok(visited.includes(a));
-    assert.ok(visited.includes(b));
-    assert.ok(visited.includes(c));
-
-    // After forEach, the removal should have been applied
     assert.equal(em.hasComponent(a, Pos), false);
     assert.equal(em.hasComponent(b, Pos), true);
-    assert.equal(em.hasComponent(c, Pos), true);
   });
 
   it('addComponent (migration) during forEach is deferred', () => {
@@ -517,21 +506,13 @@ describe('Deferred Structural Changes during forEach', () => {
     em.forEach([Pos], (arch) => {
       const ids = arch.entityIds;
       for (let i = 0; i < arch.count; i++) {
-        // Add a new component to entity a — causes migration, should be deferred
-        if (ids[i] === a) {
-          em.addComponent(a, Vel, { vx: 10, vy: 20 });
-        }
+        if (ids[i] === a) em.addComponent(a, Vel, { vx: 10, vy: 20 });
       }
     });
 
-    // After forEach, migration should have been applied
     assert.equal(em.hasComponent(a, Vel), true);
-    const vel = em.getComponent(a, Vel);
-    assert.ok(Math.abs(vel.vx - 10) < 0.001);
-    assert.ok(Math.abs(vel.vy - 20) < 0.001);
-    // Original data preserved after migration
-    const pos = em.getComponent(a, Pos);
-    assert.ok(Math.abs(pos.x - 1) < 0.001);
+    const vel = em.getComponent(a, Vel)!;
+    assert.ok(Math.abs((vel.vx as number) - 10) < 0.001);
   });
 
   it('addComponent overwrite during forEach is immediate (no migration)', () => {
@@ -539,10 +520,8 @@ describe('Deferred Structural Changes during forEach', () => {
     em.addComponent(a, Pos, { x: 1, y: 2 });
 
     em.forEach([Pos], (arch) => {
-      const px = arch.field(Pos.x);
-      // Overwrite via addComponent — same archetype, should be immediate
+      const px = arch.field(Pos.x) as Float32Array;
       em.addComponent(a, Pos, { x: 99, y: 88 });
-      // The array should reflect the change immediately
       assert.ok(Math.abs(px[0] - 99) < 0.001);
     });
   });
@@ -560,16 +539,13 @@ describe('Deferred Structural Changes during forEach', () => {
       const ids = arch.entityIds;
       for (let i = 0; i < arch.count; i++) {
         visited.push(ids[i]);
-        if (ids[i] === b) {
-          em.destroyEntity(b);
-        }
+        if (ids[i] === b) em.destroyEntity(b);
       }
     });
 
     assert.equal(visited.length, 3);
-    // After forEach, entity b should be destroyed
     assert.equal(em.hasComponent(b, Pos), false);
-    assert.deepEqual(em.getAllEntities().includes(b), false);
+    assert.equal(em.getAllEntities().includes(b), false);
   });
 
   it('multiple deferred operations are applied in order', () => {
@@ -577,15 +553,12 @@ describe('Deferred Structural Changes during forEach', () => {
     em.addComponent(a, Pos, { x: 1, y: 0 });
 
     em.forEach([Pos], () => {
-      // Remove Pos then add Vel — both deferred, applied in order
       em.removeComponent(a, Pos);
       em.addComponent(a, Vel, { vx: 5, vy: 6 });
     });
 
     assert.equal(em.hasComponent(a, Pos), false);
     assert.equal(em.hasComponent(a, Vel), true);
-    const vel = em.getComponent(a, Vel);
-    assert.ok(Math.abs(vel.vx - 5) < 0.001);
   });
 
   it('nested forEach properly defers until outermost forEach completes', () => {
@@ -594,19 +567,13 @@ describe('Deferred Structural Changes during forEach', () => {
     em.addComponent(a, Pos, { x: 1, y: 0 });
     em.addComponent(b, Vel, { vx: 2, vy: 0 });
 
-    let innerComplete = false;
     em.forEach([Pos], () => {
       em.forEach([Vel], () => {
         em.removeComponent(b, Vel);
-        innerComplete = true;
       });
-      // After inner forEach, structural change is still deferred
-      // (outermost forEach is still running)
-      assert.equal(innerComplete, true);
-      assert.equal(em.hasComponent(b, Vel), true); // live state — still deferred
+      assert.equal(em.hasComponent(b, Vel), true); // still deferred
     });
 
-    // Now outermost forEach is done — deferred ops should be flushed
     assert.equal(em.hasComponent(b, Vel), false);
   });
 
@@ -616,8 +583,7 @@ describe('Deferred Structural Changes during forEach', () => {
 
     em.forEach([Pos], (arch) => {
       em.set(a, Pos.x, 42);
-      // Should be immediately visible
-      const px = arch.field(Pos.x);
+      const px = arch.field(Pos.x) as Float32Array;
       assert.ok(Math.abs(px[0] - 42) < 0.001);
     });
   });
@@ -637,7 +603,6 @@ describe('Deferred Structural Changes during forEach', () => {
       em.addComponent(a, Vel, { vx: 1, vy: 2 });
     });
 
-    // Deferred ops were applied, hooks should be pending
     em.flushHooks();
     assert.deepEqual(removed, [a]);
     assert.deepEqual(added, [a]);

package/tests/System.test.ts

@@ -177,6 +177,46 @@ describe('createSystem (functional)', () => {
     sys.dispose();
   });
 
+  it('onRemoved handler can read removed component data via get()', () => {
+    const hpValues: number[] = [];
+    const sys = createSystem(em, (s) => {
+      s.onRemoved(Health, (id: EntityId) => {
+        hpValues.push(em.get(id, Health.hp) as number);
+      });
+    });
+
+    const e1 = em.createEntityWith(Health, { hp: 77 });
+    em.flushHooks();
+    sys();
+
+    em.removeComponent(e1, Health);
+    em.flushHooks();
+    sys();
+
+    assert.ok(Math.abs(hpValues[0] - 77) < 0.001);
+    sys.dispose();
+  });
+
+  it('onRemoved handler can read data of destroyed entity', () => {
+    const hpValues: number[] = [];
+    const sys = createSystem(em, (s) => {
+      s.onRemoved(Health, (id: EntityId) => {
+        hpValues.push(em.get(id, Health.hp) as number);
+      });
+    });
+
+    const e1 = em.createEntityWith(Health, { hp: 55 });
+    em.flushHooks();
+    sys();
+
+    em.destroyEntity(e1);
+    em.flushHooks();
+    sys();
+
+    assert.ok(Math.abs(hpValues[0] - 55) < 0.001);
+    sys.dispose();
+  });
+
   it('query-only system (no hooks) works', () => {
     const e1 = em.createEntity();
     em.addComponent(e1, Position, { x: 10, y: 20 });
@@ -420,6 +460,97 @@ describe('System (class + decorators)', () => {
     sys.dispose();
   });
 
+  it('@OnRemoved handler can read removed component data via get()', () => {
+    const hpValues: number[] = [];
+
+    class TestSys extends System {
+      @OnRemoved(Health)
+      handleRemove(id: EntityId) {
+        hpValues.push(this.em.get(id, Health.hp) as number);
+      }
+    }
+
+    const sys = new TestSys(em);
+    const e1 = em.createEntityWith(Health, { hp: 42 });
+    em.flushHooks();
+    sys.run();
+
+    em.removeComponent(e1, Health);
+    em.flushHooks();
+    sys.run();
+
+    assert.ok(Math.abs(hpValues[0] - 42) < 0.001);
+    sys.dispose();
+  });
+
+  it('@OnRemoved handler can read data of destroyed entity via get()', () => {
+    const hpValues: number[] = [];
+
+    class TestSys extends System {
+      @OnRemoved(Health)
+      handleRemove(id: EntityId) {
+        hpValues.push(this.em.get(id, Health.hp) as number);
+      }
+    }
+
+    const sys = new TestSys(em);
+    const e1 = em.createEntityWith(Health, { hp: 99 });
+    em.flushHooks();
+    sys.run();
+
+    em.destroyEntity(e1);
+    em.flushHooks();
+    sys.run();
+
+    assert.ok(Math.abs(hpValues[0] - 99) < 0.001);
+    sys.dispose();
+  });
+
+  it('@OnRemoved handler can read data via getComponent()', () => {
+    const results: Record<string, number | string | number[]>[] = [];
+
+    class TestSys extends System {
+      @OnRemoved(Position)
+      handleRemove(id: EntityId) {
+        const comp = this.em.getComponent(id, Position);
+        if (comp) results.push(comp);
+      }
+    }
+
+    const sys = new TestSys(em);
+    const e1 = em.createEntityWith(Position, { x: 10, y: 20 });
+    em.flushHooks();
+    sys.run();
+
+    em.removeComponent(e1, Position);
+    em.flushHooks();
+    sys.run();
+
+    assert.ok(Math.abs(results[0].x as number - 10) < 0.001);
+    assert.ok(Math.abs(results[0].y as number - 20) < 0.001);
+    sys.dispose();
+  });
+
+  it('removed data is cleared after commitRemovals (via run())', () => {
+    class TestSys extends System {
+      @OnRemoved(Health)
+      handleRemove(_id: EntityId) {}
+    }
+
+    const sys = new TestSys(em);
+    const e1 = em.createEntityWith(Health, { hp: 42 });
+    em.flushHooks();
+    sys.run();
+
+    em.removeComponent(e1, Health);
+    em.flushHooks();
+    sys.run(); // calls commitRemovals internally
+
+    // After run(), removed data should be cleared
+    assert.equal(em.get(e1, Health.hp), undefined);
+    sys.dispose();
+  });
+
   it('multiple instances have independent buffers', () => {
     const collectedA: EntityId[] = [];
     const collectedB: EntityId[] = [];
@@ -514,6 +645,59 @@ describe('createSystems', () => {
     assert.deepEqual(collected, []);
   });
 
+  it('@OnRemoved in pipeline can access removed data', () => {
+    const hpValues: number[] = [];
+
+    class DeathSys extends System {
+      @OnRemoved(Health)
+      handleRemove(id: EntityId) {
+        hpValues.push(this.em.get(id, Health.hp) as number);
+      }
+    }
+
+    const pipeline = createSystems(em, [DeathSys]);
+    const e1 = em.createEntityWith(Health, { hp: 77 });
+    em.flushHooks();
+    pipeline();
+
+    em.removeComponent(e1, Health);
+    em.flushHooks();
+    pipeline();
+
+    assert.ok(Math.abs(hpValues[0] - 77) < 0.001);
+    // Data should be cleared after pipeline (commitRemovals)
+    assert.equal(em.get(e1, Health.hp), undefined);
+    pipeline.dispose();
+  });
+
+  it('multiple systems in pipeline all see removed data', () => {
+    const hpA: number[] = [];
+    const hpB: number[] = [];
+
+    class SysA extends System {
+      @OnRemoved(Health)
+      handle(id: EntityId) { hpA.push(this.em.get(id, Health.hp) as number); }
+    }
+
+    class SysB extends System {
+      @OnRemoved(Health)
+      handle(id: EntityId) { hpB.push(this.em.get(id, Health.hp) as number); }
+    }
+
+    const pipeline = createSystems(em, [SysA, SysB]);
+    const e1 = em.createEntityWith(Health, { hp: 33 });
+    em.flushHooks();
+    pipeline();
+
+    em.destroyEntity(e1);
+    em.flushHooks();
+    pipeline();
+
+    assert.ok(Math.abs(hpA[0] - 33) < 0.001);
+    assert.ok(Math.abs(hpB[0] - 33) < 0.001);
+    pipeline.dispose();
+  });
+
   it('class hooks fire through pipeline', () => {
     const added: EntityId[] = [];
     let moved = 0;

package/tests/types.ts

@@ -33,7 +33,7 @@ em.addComponent(id, Name, { name: 'Hero', title: 'Sir' });
 const pos = em.getComponent(id, Position);
 
 // get/set: field descriptor access
-const px: any = em.get(id, Position.x);
+const px = em.get(id, Position.x);
 em.set(id, Position.x, 10);
 
 // forEach + field: accepts FieldRef

package/tsconfig.json

@@ -6,8 +6,8 @@
     "moduleResolution": "NodeNext",
     "declaration": true,
     "outDir": "dist",
-    "rootDir": ".",
+    "rootDir": "src",
     "skipLibCheck": true
   },
-  "include": ["src/**/*.ts", "tests/**/*.ts"]
+  "include": ["src/**/*.ts"]
 }

package/tsconfig.test.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": false,
+    "outDir": "dist-test",
+    "rootDir": ".",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
+}

package/dist/tests/EntityManager.test.d.ts

@@ -1 +0,0 @@
-export {};