archetype-ecs 1.2.0 → 1.3.2

package/dist/tests/types.js

@@ -0,0 +1,129 @@
+// Compile-time type tests — run with: npx tsc --noEmit
+// These tests validate TS types flow correctly through the API.
+// No runtime execution needed; if this file compiles, the types are correct.
+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 { createEntityManager, createSystem, createSystems, component, System, OnAdded, OnRemoved } from '../src/index.js';
+// --- component() creates ComponentDef ---
+const Position = component('Position', 'f32', ['x', 'y']);
+const Velocity = component('Velocity', { vx: 'f32', vy: 'f32' });
+const Tag = component('Tag');
+const Name = component('Name', { name: 'string', title: 'string' });
+const Label = component('Label', 'string', ['text', 'color']);
+// component() returns ComponentDef
+const _assertComp = Position;
+const _assertTag = Tag;
+// --- EntityManager typed methods ---
+const em = createEntityManager();
+const id = em.createEntity();
+// addComponent: accepts data
+em.addComponent(id, Position, { x: 1, y: 2 });
+em.addComponent(id, Velocity, { vx: 0, vy: 0 });
+em.addComponent(id, Name, { name: 'Hero', title: 'Sir' });
+// getComponent: returns data or undefined
+const pos = em.getComponent(id, Position);
+// get/set: field descriptor access
+const px = em.get(id, Position.x);
+em.set(id, Position.x, 10);
+// forEach + field: accepts FieldRef
+em.forEach([Position, Velocity], (arch) => {
+    const count = arch.count;
+    const ids = arch.entityIds;
+    const arrX = arch.field(Position.x);
+});
+// createEntityWith: alternating type, data
+em.createEntityWith(Position, { x: 0, y: 0 }, Velocity, { vx: 1, vy: 1 });
+// --- createSystem returns FunctionalSystem ---
+const sys = createSystem(em, (s) => {
+    // onAdded with 1 type
+    s.onAdded(Position, (entityId) => { });
+    // onAdded with 2 types
+    s.onAdded(Position, Velocity, (entityId) => { });
+    // onRemoved with 1 type
+    s.onRemoved(Position, (entityId) => { });
+    // onRemoved with 2 types
+    s.onRemoved(Position, Velocity, (entityId) => { });
+    return () => {
+        s.forEach([Position, Velocity], (view) => {
+            const count = view.count;
+        });
+        s.forEach([Position], (_view) => { }, [Velocity]);
+    };
+});
+sys();
+sys.dispose();
+// --- FunctionalSystemConstructor type ---
+const ctor = (s) => {
+    s.onAdded(Position, (_id) => { });
+};
+// --- createSystems returns Pipeline ---
+const pipeline = createSystems(em, [ctor]);
+pipeline();
+pipeline.dispose();
+// --- Class-based System ---
+let TestSystem = (() => {
+    let _classSuper = System;
+    let _instanceExtraInitializers = [];
+    let _handleAdd_decorators;
+    let _handleRemove_decorators;
+    return class TestSystem extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _handleAdd_decorators = [OnAdded(Position)];
+            _handleRemove_decorators = [OnRemoved(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);
+            __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) { }
+        handleRemove(id) { }
+        tick() {
+            this.forEach([Position], (view) => {
+                const count = view.count;
+            });
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+    };
+})();
+const testSys = new TestSystem(em);
+testSys.run();
+testSys.dispose();
+// --- createSystems accepts mixed entries ---
+const mixedPipeline = createSystems(em, [ctor, TestSystem]);
+mixedPipeline();
+mixedPipeline.dispose();

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "archetype-ecs",
-  "version": "1.2.0",
+  "version": "1.3.2",
   "description": "Lightweight archetype-based Entity Component System",
   "type": "module",
-  "main": "src/index.js",
-  "module": "src/index.js",
-  "types": "src/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.d.ts",
-      "default": "./src/index.js"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
   "scripts": {
-    "test": "node --test tests/ && npx tsc --noEmit",
+    "build": "tsc",
+    "test": "tsc && tsc -p tsconfig.test.json && node --test dist-test/tests/EntityManager.test.js dist-test/tests/System.test.js",
     "bench": "node --expose-gc bench/multi-ecs-bench.js"
   },
   "keywords": [
@@ -26,9 +26,11 @@
   ],
   "license": "MIT",
   "devDependencies": {
+    "@types/node": "^25.2.3",
     "bitecs": "^0.4.0",
     "harmony-ecs": "^0.0.12",
     "miniplex": "^2.0.0",
+    "typescript": "^5.9.3",
     "wolf-ecs": "^2.0.0"
   }
 }

package/src/ComponentRegistry.ts

@@ -0,0 +1,49 @@
+export const TYPED: unique symbol = Symbol('typed');
+
+type TypedArrayConstructor =
+  | typeof Float32Array | typeof Float64Array
+  | typeof Int8Array | typeof Int16Array | typeof Int32Array
+  | typeof Uint8Array | typeof Uint16Array | typeof Uint32Array
+  | typeof Array;
+
+export const TYPE_MAP: Record<string, TypedArrayConstructor> = {
+  'f32': Float32Array,
+  'f64': Float64Array,
+  'i8': Int8Array,
+  'i16': Int16Array,
+  'i32': Int32Array,
+  'u8': Uint8Array,
+  'u16': Uint16Array,
+  'u32': Uint32Array,
+  'string': Array,
+};
+
+export type TypeSpec = TypedArrayConstructor | [TypedArrayConstructor, number];
+
+export function parseTypeSpec(typeStr: string): TypeSpec {
+  const match = typeStr.match(/^(\w+)\[(\d+)\]$/);
+  if (match) {
+    const Ctor = TYPE_MAP[match[1]];
+    if (!Ctor) throw new Error(`Unknown base type "${match[1]}"`);
+    return [Ctor, parseInt(match[2])];
+  }
+  const Ctor = TYPE_MAP[typeStr];
+  if (!Ctor) throw new Error(`Unknown type "${typeStr}"`);
+  return Ctor;
+}
+
+export const componentSchemas = new Map<symbol, Record<string, TypeSpec>>();
+
+export interface FieldRef {
+  readonly _sym: symbol;
+  readonly _field: string;
+}
+
+export type ComponentDef<F extends string = never> = {
+  readonly _sym: symbol;
+  readonly _name: string;
+} & { readonly [K in F]: FieldRef };
+
+export function toSym(type: ComponentDef | symbol): symbol {
+  return (type as ComponentDef)._sym || (type as symbol);
+}