archetype-ecs 1.2.0 → 2.0.0

package/dist/src/Profiler.d.ts

@@ -0,0 +1,12 @@
+export interface ProfilerEntry {
+    avg: number;
+}
+export interface Profiler {
+    readonly enabled: boolean;
+    setEnabled(value: boolean): void;
+    begin(): number;
+    end(name: string, t0: number): void;
+    record(name: string, ms: number): void;
+    getData(): Map<string, ProfilerEntry>;
+}
+export declare const profiler: Profiler;

package/dist/src/Profiler.js

@@ -0,0 +1,38 @@
+const EMA_ALPHA = 0.1;
+const data = new Map();
+let enabled = false;
+export const profiler = {
+    get enabled() { return enabled; },
+    setEnabled(value) {
+        enabled = value;
+        if (!value)
+            data.clear();
+    },
+    begin() {
+        return enabled ? performance.now() : 0;
+    },
+    end(name, t0) {
+        if (!enabled)
+            return;
+        const ms = performance.now() - t0;
+        const entry = data.get(name);
+        if (entry) {
+            entry.avg += (ms - entry.avg) * EMA_ALPHA;
+        }
+        else {
+            data.set(name, { avg: ms });
+        }
+    },
+    record(name, ms) {
+        if (!enabled)
+            return;
+        const entry = data.get(name);
+        if (entry) {
+            entry.avg += (ms - entry.avg) * EMA_ALPHA;
+        }
+        else {
+            data.set(name, { avg: ms });
+        }
+    },
+    getData() { return data; }
+};

package/dist/src/System.d.ts

@@ -0,0 +1,37 @@
+import type { ComponentDef } from './ComponentRegistry.js';
+import type { EntityId, EntityManager, ArchetypeView } from './EntityManager.js';
+export declare function OnAdded(...types: ComponentDef[]): (_method: Function, context: ClassMethodDecoratorContext) => void;
+export declare function OnRemoved(...types: ComponentDef[]): (_method: Function, context: ClassMethodDecoratorContext) => void;
+interface Hook {
+    buffer: Set<EntityId>;
+    handler: (id: EntityId) => void;
+}
+export declare class System {
+    em: EntityManager;
+    _unsubs: (() => void)[];
+    _hooks: Hook[];
+    constructor(em: EntityManager);
+    _registerHook(kind: 'add' | 'remove', types: ComponentDef[], handler: (id: EntityId) => void): void;
+    forEach(types: ComponentDef[], callback: (view: ArchetypeView) => void, exclude?: ComponentDef[]): void;
+    tick?(): void;
+    run(): void;
+    dispose(): void;
+}
+type HookCallback = (entityId: EntityId) => void;
+export interface SystemContext {
+    onAdded(...args: [...ComponentDef[], HookCallback]): void;
+    onRemoved(...args: [...ComponentDef[], HookCallback]): void;
+    forEach(types: ComponentDef[], callback: (view: ArchetypeView) => void, exclude?: ComponentDef[]): void;
+}
+export type FunctionalSystemConstructor = (sys: SystemContext) => (() => void) | void;
+export interface FunctionalSystem {
+    (): void;
+    dispose(): void;
+}
+export declare function createSystem(em: EntityManager, constructor: FunctionalSystemConstructor): FunctionalSystem;
+export interface Pipeline {
+    (): void;
+    dispose(): void;
+}
+export declare function createSystems(em: EntityManager, entries: (FunctionalSystemConstructor | (new (em: EntityManager) => System))[]): Pipeline;
+export {};

package/dist/src/System.js

@@ -0,0 +1,139 @@
+// ── Decorators (TC39 Stage 3) ────────────────────────────
+export function OnAdded(...types) {
+    return function (_method, context) {
+        context.addInitializer(function () {
+            const self = this;
+            self._registerHook('add', types, self[context.name].bind(self));
+        });
+    };
+}
+export function OnRemoved(...types) {
+    return function (_method, context) {
+        context.addInitializer(function () {
+            const self = this;
+            self._registerHook('remove', types, self[context.name].bind(self));
+        });
+    };
+}
+export class System {
+    em;
+    _unsubs = [];
+    _hooks = [];
+    constructor(em) {
+        this.em = em;
+    }
+    _registerHook(kind, types, handler) {
+        const buffer = new Set();
+        if (kind === 'add') {
+            for (const comp of types) {
+                const unsub = this.em.onAdd(comp, (id) => {
+                    for (let i = 0; i < types.length; i++) {
+                        if (!this.em.hasComponent(id, types[i]))
+                            return;
+                    }
+                    buffer.add(id);
+                });
+                this._unsubs.push(unsub);
+            }
+        }
+        else {
+            for (const comp of types) {
+                const unsub = this.em.onRemove(comp, (id) => buffer.add(id));
+                this._unsubs.push(unsub);
+            }
+        }
+        this._hooks.push({ buffer, handler });
+    }
+    forEach(types, callback, exclude) {
+        this.em.forEach(types, callback, exclude);
+    }
+    run() {
+        for (const hook of this._hooks) {
+            for (const id of hook.buffer)
+                hook.handler(id);
+            hook.buffer.clear();
+        }
+        if (this.tick)
+            this.tick();
+    }
+    dispose() {
+        for (const unsub of this._unsubs)
+            unsub();
+        this._unsubs.length = 0;
+        this._hooks.length = 0;
+    }
+}
+export function createSystem(em, constructor) {
+    const hooks = [];
+    const sys = {
+        onAdded(...args) {
+            const callback = args[args.length - 1];
+            const types = args.slice(0, -1);
+            const buffer = new Set();
+            const unsubs = [];
+            for (const comp of types) {
+                const unsub = em.onAdd(comp, (id) => {
+                    for (let i = 0; i < types.length; i++) {
+                        if (!em.hasComponent(id, types[i]))
+                            return;
+                    }
+                    buffer.add(id);
+                });
+                unsubs.push(unsub);
+            }
+            hooks.push({ unsubs, buffer, callback });
+        },
+        onRemoved(...args) {
+            const callback = args[args.length - 1];
+            const types = args.slice(0, -1);
+            const buffer = new Set();
+            const unsubs = [];
+            for (const comp of types) {
+                const unsub = em.onRemove(comp, (id) => {
+                    buffer.add(id);
+                });
+                unsubs.push(unsub);
+            }
+            hooks.push({ unsubs, buffer, callback });
+        },
+        forEach(types, callback, exclude) {
+            em.forEach(types, callback, exclude);
+        },
+    };
+    const tick = constructor(sys);
+    function system() {
+        for (const hook of hooks) {
+            for (const id of hook.buffer)
+                hook.callback(id);
+            hook.buffer.clear();
+        }
+        if (tick)
+            tick();
+    }
+    system.dispose = function () {
+        for (const hook of hooks) {
+            for (const unsub of hook.unsubs)
+                unsub();
+        }
+        hooks.length = 0;
+    };
+    return system;
+}
+export function createSystems(em, entries) {
+    const systems = entries.map(Entry => {
+        if (Entry.prototype instanceof System) {
+            return new Entry(em);
+        }
+        const sys = createSystem(em, Entry);
+        return { run: sys, dispose: sys.dispose };
+    });
+    function pipeline() {
+        for (let i = 0; i < systems.length; i++)
+            systems[i].run();
+    }
+    pipeline.dispose = function () {
+        for (let i = 0; i < systems.length; i++)
+            systems[i].dispose();
+    };
+    return pipeline;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+export { createEntityManager } from './EntityManager.js';
+export type { EntityId, FieldRef, ArchetypeView, EntityManager, SerializedData } from './EntityManager.js';
+export { createSystem, createSystems, System, OnAdded, OnRemoved } from './System.js';
+export type { SystemContext, FunctionalSystemConstructor, FunctionalSystem, Pipeline } from './System.js';
+export { profiler } from './Profiler.js';
+export type { Profiler, ProfilerEntry } from './Profiler.js';
+export { TYPED, componentSchemas, parseTypeSpec } from './ComponentRegistry.js';
+export type { ComponentDef, TypeSpec } from './ComponentRegistry.js';
+import { type ComponentDef } from './ComponentRegistry.js';
+export declare function component(name: string, typeOrSchema?: string | Record<string, string>, fields?: string[]): ComponentDef;

package/dist/src/index.js

@@ -0,0 +1,29 @@
+export { createEntityManager } from './EntityManager.js';
+export { createSystem, createSystems, System, OnAdded, OnRemoved } from './System.js';
+export { profiler } from './Profiler.js';
+export { TYPED, componentSchemas, parseTypeSpec } from './ComponentRegistry.js';
+import { parseTypeSpec, componentSchemas } from './ComponentRegistry.js';
+export function component(name, typeOrSchema, fields) {
+    const sym = Symbol(name);
+    const comp = { _sym: sym, _name: name };
+    let schema;
+    if (typeof typeOrSchema === 'string' && Array.isArray(fields)) {
+        const spec = parseTypeSpec(typeOrSchema);
+        schema = {};
+        for (const f of fields) {
+            schema[f] = spec;
+            comp[f] = { _sym: sym, _field: f };
+        }
+    }
+    else if (typeOrSchema && typeof typeOrSchema === 'object') {
+        schema = {};
+        for (const [field, type] of Object.entries(typeOrSchema)) {
+            schema[field] = parseTypeSpec(type);
+            comp[field] = { _sym: sym, _field: field };
+        }
+    }
+    if (schema) {
+        componentSchemas.set(sym, schema);
+    }
+    return comp;
+}

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

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