archetype-ecs 1.2.0 → 2.0.0

package/dist/tests/System.test.js

@@ -0,0 +1,630 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { createEntityManager } from '../src/EntityManager.js';
+import { createSystem, createSystems, System, OnAdded, OnRemoved } from '../src/System.js';
+import { component } from '../src/index.js';
+// ── Components (shared across all suites) ────────────────
+const Position = component('Position', 'f32', ['x', 'y']);
+const Velocity = component('Velocity', 'f32', ['vx', 'vy']);
+const Health = component('Health', 'f32', ['hp']);
+const Tag = component('Tag');
+// ── Functional API ───────────────────────────────────────
+describe('createSystem (functional)', () => {
+    let em;
+    beforeEach(() => {
+        em = createEntityManager();
+    });
+    it('onAdded fires callback after flush + run', () => {
+        const collected = [];
+        const sys = createSystem(em, (s) => {
+            s.onAdded(Health, (id) => collected.push(id));
+        });
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 100 });
+        em.flushHooks();
+        sys();
+        assert.deepEqual(collected, [e1]);
+        sys.dispose();
+    });
+    it('onAdded with multiple types only fires when entity has ALL types', () => {
+        const collected = [];
+        const sys = createSystem(em, (s) => {
+            s.onAdded(Health, Position, (id) => collected.push(id));
+        });
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 100 });
+        em.flushHooks();
+        sys();
+        assert.deepEqual(collected, []);
+        em.addComponent(e1, Position, { x: 0, y: 0 });
+        em.flushHooks();
+        sys();
+        assert.deepEqual(collected, [e1]);
+        sys.dispose();
+    });
+    it('onAdded deduplicates when multiple types trigger for same entity', () => {
+        const collected = [];
+        const sys = createSystem(em, (s) => {
+            s.onAdded(Health, Position, (id) => collected.push(id));
+        });
+        const e1 = em.createEntityWith(Health, { hp: 50 }, Position, { x: 0, y: 0 });
+        em.flushHooks();
+        sys();
+        assert.deepEqual(collected, [e1]);
+        sys.dispose();
+    });
+    it('onRemoved fires callback after flush + run', () => {
+        const collected = [];
+        const sys = createSystem(em, (s) => {
+            s.onRemoved(Health, (id) => collected.push(id));
+        });
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 50 });
+        em.flushHooks();
+        sys();
+        em.removeComponent(e1, Health);
+        em.flushHooks();
+        sys();
+        assert.deepEqual(collected, [e1]);
+        sys.dispose();
+    });
+    it('onRemoved with multiple types deduplicates', () => {
+        const collected = [];
+        const sys = createSystem(em, (s) => {
+            s.onRemoved(Health, Position, (id) => collected.push(id));
+        });
+        const e1 = em.createEntityWith(Health, { hp: 50 }, Position, { x: 0, y: 0 });
+        em.flushHooks();
+        sys();
+        em.removeComponent(e1, Health);
+        em.removeComponent(e1, Position);
+        em.flushHooks();
+        sys();
+        assert.deepEqual(collected, [e1]);
+        sys.dispose();
+    });
+    it('buffers cleared after sys() — no double processing', () => {
+        const collected = [];
+        const sys = createSystem(em, (s) => {
+            s.onAdded(Health, (id) => collected.push(id));
+        });
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 100 });
+        em.flushHooks();
+        sys();
+        assert.deepEqual(collected, [e1]);
+        collected.length = 0;
+        sys();
+        assert.deepEqual(collected, []);
+        sys.dispose();
+    });
+    it('dispose() unsubscribes hooks', () => {
+        const collected = [];
+        const sys = createSystem(em, (s) => {
+            s.onAdded(Health, (id) => collected.push(id));
+        });
+        sys.dispose();
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 100 });
+        em.flushHooks();
+        sys();
+        assert.deepEqual(collected, []);
+    });
+    it('forEach wraps em.forEach correctly (include + exclude)', () => {
+        const e1 = em.createEntity();
+        em.addComponent(e1, Position, { x: 1, y: 2 });
+        em.addComponent(e1, Velocity, { vx: 3, vy: 4 });
+        const e2 = em.createEntity();
+        em.addComponent(e2, Position, { x: 5, y: 6 });
+        em.addComponent(e2, Tag);
+        let count = 0;
+        const sys = createSystem(em, (s) => {
+            return () => {
+                s.forEach([Position], (view) => { count += view.count; }, [Tag]);
+            };
+        });
+        sys();
+        assert.equal(count, 1);
+        sys.dispose();
+    });
+    it('hooks-only system (no tick) works', () => {
+        const added = [];
+        const sys = createSystem(em, (s) => {
+            s.onAdded(Tag, (id) => added.push(id));
+        });
+        const e1 = em.createEntity();
+        em.addComponent(e1, Tag);
+        em.flushHooks();
+        sys();
+        assert.deepEqual(added, [e1]);
+        sys.dispose();
+    });
+    it('query-only system (no hooks) works', () => {
+        const e1 = em.createEntity();
+        em.addComponent(e1, Position, { x: 10, y: 20 });
+        em.addComponent(e1, Velocity, { vx: 1, vy: 2 });
+        let totalCount = 0;
+        const sys = createSystem(em, (s) => {
+            return () => {
+                s.forEach([Position, Velocity], (view) => { totalCount += view.count; });
+            };
+        });
+        sys();
+        assert.equal(totalCount, 1);
+        sys.dispose();
+    });
+});
+// ── Decorator-based class API ────────────────────────────
+describe('System (class + decorators)', () => {
+    let em;
+    beforeEach(() => {
+        em = createEntityManager();
+    });
+    it('@OnAdded fires decorated method after flush + run', () => {
+        const collected = [];
+        let TestSys = (() => {
+            let _classSuper = System;
+            let _instanceExtraInitializers = [];
+            let _handleAdd_decorators;
+            return class TestSys extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _handleAdd_decorators = [OnAdded(Health)];
+                    __esDecorate(this, null, _handleAdd_decorators, { kind: "method", name: "handleAdd", static: false, private: false, access: { has: obj => "handleAdd" in obj, get: obj => obj.handleAdd }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                handleAdd(id) { collected.push(id); }
+                constructor() {
+                    super(...arguments);
+                    __runInitializers(this, _instanceExtraInitializers);
+                }
+            };
+        })();
+        const sys = new TestSys(em);
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 100 });
+        em.flushHooks();
+        sys.run();
+        assert.deepEqual(collected, [e1]);
+        sys.dispose();
+    });
+    it('@OnAdded with multiple types only fires when entity has ALL types', () => {
+        const collected = [];
+        let TestSys = (() => {
+            let _classSuper = System;
+            let _instanceExtraInitializers = [];
+            let _handleAdd_decorators;
+            return class TestSys extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _handleAdd_decorators = [OnAdded(Health, Position)];
+                    __esDecorate(this, null, _handleAdd_decorators, { kind: "method", name: "handleAdd", static: false, private: false, access: { has: obj => "handleAdd" in obj, get: obj => obj.handleAdd }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                handleAdd(id) { collected.push(id); }
+                constructor() {
+                    super(...arguments);
+                    __runInitializers(this, _instanceExtraInitializers);
+                }
+            };
+        })();
+        const sys = new TestSys(em);
+        // Only Health — should NOT trigger
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 100 });
+        em.flushHooks();
+        sys.run();
+        assert.deepEqual(collected, []);
+        // Add Position — now matches
+        em.addComponent(e1, Position, { x: 0, y: 0 });
+        em.flushHooks();
+        sys.run();
+        assert.deepEqual(collected, [e1]);
+        sys.dispose();
+    });
+    it('@OnAdded deduplicates with createEntityWith', () => {
+        const collected = [];
+        let TestSys = (() => {
+            let _classSuper = System;
+            let _instanceExtraInitializers = [];
+            let _handleAdd_decorators;
+            return class TestSys extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _handleAdd_decorators = [OnAdded(Health, Position)];
+                    __esDecorate(this, null, _handleAdd_decorators, { kind: "method", name: "handleAdd", static: false, private: false, access: { has: obj => "handleAdd" in obj, get: obj => obj.handleAdd }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                handleAdd(id) { collected.push(id); }
+                constructor() {
+                    super(...arguments);
+                    __runInitializers(this, _instanceExtraInitializers);
+                }
+            };
+        })();
+        const sys = new TestSys(em);
+        const e1 = em.createEntityWith(Health, { hp: 50 }, Position, { x: 0, y: 0 });
+        em.flushHooks();
+        sys.run();
+        assert.deepEqual(collected, [e1]);
+        sys.dispose();
+    });
+    it('@OnRemoved fires decorated method after flush + run', () => {
+        const collected = [];
+        let TestSys = (() => {
+            let _classSuper = System;
+            let _instanceExtraInitializers = [];
+            let _handleRemove_decorators;
+            return class TestSys extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _handleRemove_decorators = [OnRemoved(Health)];
+                    __esDecorate(this, null, _handleRemove_decorators, { kind: "method", name: "handleRemove", static: false, private: false, access: { has: obj => "handleRemove" in obj, get: obj => obj.handleRemove }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                handleRemove(id) { collected.push(id); }
+                constructor() {
+                    super(...arguments);
+                    __runInitializers(this, _instanceExtraInitializers);
+                }
+            };
+        })();
+        const sys = new TestSys(em);
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 50 });
+        em.flushHooks();
+        sys.run();
+        em.removeComponent(e1, Health);
+        em.flushHooks();
+        sys.run();
+        assert.deepEqual(collected, [e1]);
+        sys.dispose();
+    });
+    it('@OnRemoved fires on destroyEntity for all component types', () => {
+        const removedHealth = [];
+        const removedPos = [];
+        let TestSys = (() => {
+            let _classSuper = System;
+            let _instanceExtraInitializers = [];
+            let _handleHealth_decorators;
+            let _handlePos_decorators;
+            return class TestSys extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _handleHealth_decorators = [OnRemoved(Health)];
+                    _handlePos_decorators = [OnRemoved(Position)];
+                    __esDecorate(this, null, _handleHealth_decorators, { kind: "method", name: "handleHealth", static: false, private: false, access: { has: obj => "handleHealth" in obj, get: obj => obj.handleHealth }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    __esDecorate(this, null, _handlePos_decorators, { kind: "method", name: "handlePos", static: false, private: false, access: { has: obj => "handlePos" in obj, get: obj => obj.handlePos }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                handleHealth(id) { removedHealth.push(id); }
+                handlePos(id) { removedPos.push(id); }
+                constructor() {
+                    super(...arguments);
+                    __runInitializers(this, _instanceExtraInitializers);
+                }
+            };
+        })();
+        const sys = new TestSys(em);
+        const e1 = em.createEntityWith(Health, { hp: 100 }, Position, { x: 0, y: 0 });
+        em.flushHooks();
+        sys.run();
+        em.destroyEntity(e1);
+        em.flushHooks();
+        sys.run();
+        assert.deepEqual(removedHealth, [e1]);
+        assert.deepEqual(removedPos, [e1]);
+        sys.dispose();
+    });
+    it('buffers cleared after run() — no double processing', () => {
+        const collected = [];
+        let TestSys = (() => {
+            let _classSuper = System;
+            let _instanceExtraInitializers = [];
+            let _handleAdd_decorators;
+            return class TestSys extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _handleAdd_decorators = [OnAdded(Health)];
+                    __esDecorate(this, null, _handleAdd_decorators, { kind: "method", name: "handleAdd", static: false, private: false, access: { has: obj => "handleAdd" in obj, get: obj => obj.handleAdd }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                handleAdd(id) { collected.push(id); }
+                constructor() {
+                    super(...arguments);
+                    __runInitializers(this, _instanceExtraInitializers);
+                }
+            };
+        })();
+        const sys = new TestSys(em);
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 100 });
+        em.flushHooks();
+        sys.run();
+        assert.deepEqual(collected, [e1]);
+        collected.length = 0;
+        sys.run();
+        assert.deepEqual(collected, []);
+        sys.dispose();
+    });
+    it('dispose() unsubscribes hooks', () => {
+        const collected = [];
+        let TestSys = (() => {
+            let _classSuper = System;
+            let _instanceExtraInitializers = [];
+            let _handleAdd_decorators;
+            return class TestSys extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _handleAdd_decorators = [OnAdded(Health)];
+                    __esDecorate(this, null, _handleAdd_decorators, { kind: "method", name: "handleAdd", static: false, private: false, access: { has: obj => "handleAdd" in obj, get: obj => obj.handleAdd }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                handleAdd(id) { collected.push(id); }
+                constructor() {
+                    super(...arguments);
+                    __runInitializers(this, _instanceExtraInitializers);
+                }
+            };
+        })();
+        const sys = new TestSys(em);
+        sys.dispose();
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 100 });
+        em.flushHooks();
+        sys.run();
+        assert.deepEqual(collected, []);
+    });
+    it('tick() is called after hook callbacks', () => {
+        const order = [];
+        let TestSys = (() => {
+            let _classSuper = System;
+            let _instanceExtraInitializers = [];
+            let _handleAdd_decorators;
+            return class TestSys extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _handleAdd_decorators = [OnAdded(Health)];
+                    __esDecorate(this, null, _handleAdd_decorators, { kind: "method", name: "handleAdd", static: false, private: false, access: { has: obj => "handleAdd" in obj, get: obj => obj.handleAdd }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                handleAdd(_id) { order.push('hook'); }
+                tick() { order.push('tick'); }
+                constructor() {
+                    super(...arguments);
+                    __runInitializers(this, _instanceExtraInitializers);
+                }
+            };
+        })();
+        const sys = new TestSys(em);
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 100 });
+        em.flushHooks();
+        sys.run();
+        assert.deepEqual(order, ['hook', 'tick']);
+        sys.dispose();
+    });
+    it('forEach available on System instance', () => {
+        const e1 = em.createEntity();
+        em.addComponent(e1, Position, { x: 1, y: 2 });
+        em.addComponent(e1, Velocity, { vx: 3, vy: 4 });
+        let count = 0;
+        class TestSys extends System {
+            tick() {
+                this.forEach([Position, Velocity], (view) => { count += view.count; });
+            }
+        }
+        const sys = new TestSys(em);
+        sys.run();
+        assert.equal(count, 1);
+        sys.dispose();
+    });
+    it('multiple decorated methods on same class', () => {
+        const added = [];
+        const removed = [];
+        let TestSys = (() => {
+            let _classSuper = System;
+            let _instanceExtraInitializers = [];
+            let _handleAdd_decorators;
+            let _handleRemove_decorators;
+            return class TestSys extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _handleAdd_decorators = [OnAdded(Health)];
+                    _handleRemove_decorators = [OnRemoved(Health)];
+                    __esDecorate(this, null, _handleAdd_decorators, { kind: "method", name: "handleAdd", static: false, private: false, access: { has: obj => "handleAdd" in obj, get: obj => obj.handleAdd }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    __esDecorate(this, null, _handleRemove_decorators, { kind: "method", name: "handleRemove", static: false, private: false, access: { has: obj => "handleRemove" in obj, get: obj => obj.handleRemove }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                handleAdd(id) { added.push(id); }
+                handleRemove(id) { removed.push(id); }
+                constructor() {
+                    super(...arguments);
+                    __runInitializers(this, _instanceExtraInitializers);
+                }
+            };
+        })();
+        const sys = new TestSys(em);
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 100 });
+        em.flushHooks();
+        sys.run();
+        assert.deepEqual(added, [e1]);
+        assert.deepEqual(removed, []);
+        em.removeComponent(e1, Health);
+        em.flushHooks();
+        sys.run();
+        assert.deepEqual(removed, [e1]);
+        sys.dispose();
+    });
+    it('multiple instances have independent buffers', () => {
+        const collectedA = [];
+        const collectedB = [];
+        let TestSys = (() => {
+            let _classSuper = System;
+            let _instanceExtraInitializers = [];
+            let _handleAdd_decorators;
+            return class TestSys extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _handleAdd_decorators = [OnAdded(Health)];
+                    __esDecorate(this, null, _handleAdd_decorators, { kind: "method", name: "handleAdd", static: false, private: false, access: { has: obj => "handleAdd" in obj, get: obj => obj.handleAdd }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                out = __runInitializers(this, _instanceExtraInitializers);
+                constructor(em, out) {
+                    super(em);
+                    this.out = out;
+                }
+                handleAdd(id) { this.out.push(id); }
+            };
+        })();
+        const sysA = new TestSys(em, collectedA);
+        const sysB = new TestSys(em, collectedB);
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 100 });
+        em.flushHooks();
+        sysA.run();
+        sysB.run();
+        assert.deepEqual(collectedA, [e1]);
+        assert.deepEqual(collectedB, [e1]);
+        sysA.dispose();
+        sysB.dispose();
+    });
+});
+// ── createSystems (activator) ────────────────────────────
+describe('createSystems', () => {
+    let em;
+    beforeEach(() => {
+        em = createEntityManager();
+    });
+    it('runs functional systems in order', () => {
+        const order = [];
+        function SysA() { return () => { order.push('A'); }; }
+        function SysB() { return () => { order.push('B'); }; }
+        const pipeline = createSystems(em, [SysA, SysB]);
+        pipeline();
+        assert.deepEqual(order, ['A', 'B']);
+        pipeline.dispose();
+    });
+    it('runs class-based systems in order', () => {
+        const order = [];
+        class SysA extends System {
+            tick() { order.push('A'); }
+        }
+        class SysB extends System {
+            tick() { order.push('B'); }
+        }
+        const pipeline = createSystems(em, [SysA, SysB]);
+        pipeline();
+        assert.deepEqual(order, ['A', 'B']);
+        pipeline.dispose();
+    });
+    it('mixes functional and class-based systems', () => {
+        const order = [];
+        function FuncSys() { return () => { order.push('func'); }; }
+        class ClassSys extends System {
+            tick() { order.push('class'); }
+        }
+        const pipeline = createSystems(em, [FuncSys, ClassSys]);
+        pipeline();
+        assert.deepEqual(order, ['func', 'class']);
+        pipeline.dispose();
+    });
+    it('dispose() disposes all systems', () => {
+        const collected = [];
+        let TestSys = (() => {
+            let _classSuper = System;
+            let _instanceExtraInitializers = [];
+            let _handleAdd_decorators;
+            return class TestSys extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _handleAdd_decorators = [OnAdded(Health)];
+                    __esDecorate(this, null, _handleAdd_decorators, { kind: "method", name: "handleAdd", static: false, private: false, access: { has: obj => "handleAdd" in obj, get: obj => obj.handleAdd }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                handleAdd(id) { collected.push(id); }
+                constructor() {
+                    super(...arguments);
+                    __runInitializers(this, _instanceExtraInitializers);
+                }
+            };
+        })();
+        const pipeline = createSystems(em, [TestSys]);
+        pipeline.dispose();
+        const e1 = em.createEntity();
+        em.addComponent(e1, Health, { hp: 100 });
+        em.flushHooks();
+        pipeline();
+        assert.deepEqual(collected, []);
+    });
+    it('class hooks fire through pipeline', () => {
+        const added = [];
+        let moved = 0;
+        let HookSys = (() => {
+            let _classSuper = System;
+            let _instanceExtraInitializers = [];
+            let _handleAdd_decorators;
+            return class HookSys extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _handleAdd_decorators = [OnAdded(Health)];
+                    __esDecorate(this, null, _handleAdd_decorators, { kind: "method", name: "handleAdd", static: false, private: false, access: { has: obj => "handleAdd" in obj, get: obj => obj.handleAdd }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                handleAdd(id) { added.push(id); }
+                constructor() {
+                    super(...arguments);
+                    __runInitializers(this, _instanceExtraInitializers);
+                }
+            };
+        })();
+        class TickSys extends System {
+            tick() {
+                this.forEach([Position, Velocity], (view) => { moved += view.count; });
+            }
+        }
+        const pipeline = createSystems(em, [HookSys, TickSys]);
+        const e1 = em.createEntityWith(Health, { hp: 100 }, Position, { x: 0, y: 0 }, Velocity, { vx: 1, vy: 1 });
+        em.flushHooks();
+        pipeline();
+        assert.deepEqual(added, [e1]);
+        assert.equal(moved, 1);
+        pipeline.dispose();
+    });
+});

package/dist/tests/types.d.ts

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