@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-IB7KHVFY.js

@@ -0,0 +1,821 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/ecs/index.ts
+var ecs_exports = {};
+__export(ecs_exports, {
+  ComponentRegistry: () => ComponentRegistry,
+  ComponentStore: () => ComponentStore,
+  EntityRegistry: () => EntityRegistry,
+  SystemScheduler: () => SystemScheduler,
+  World: () => World,
+  registerBuiltInComponents: () => registerBuiltInComponents
+});
+
+// src/ecs/ComponentRegistry.ts
+var ComponentRegistry = class {
+  schemas = /* @__PURE__ */ new Map();
+  /**
+   * Register a component type with its default data factory.
+   */
+  register(schema) {
+    this.schemas.set(schema.type, schema);
+  }
+  /**
+   * Get the schema for a component type.
+   */
+  getSchema(type) {
+    return this.schemas.get(type);
+  }
+  /**
+   * Create default data for a component type.
+   */
+  createDefault(type) {
+    const schema = this.schemas.get(type);
+    return schema ? schema.defaultData() : void 0;
+  }
+  /**
+   * Check if a component type is registered.
+   */
+  has(type) {
+    return this.schemas.has(type);
+  }
+  /**
+   * List all registered component types.
+   */
+  listTypes() {
+    return Array.from(this.schemas.keys());
+  }
+  /**
+   * Get count of registered types.
+   */
+  get count() {
+    return this.schemas.size;
+  }
+};
+function registerBuiltInComponents(registry) {
+  registry.register({
+    type: "transform",
+    defaultData: () => ({
+      position: [0, 0, 0],
+      rotation: { x: 0, y: 0, z: 0, w: 1 },
+      scale: { x: 1, y: 1, z: 1 }
+    }),
+    description: "Position, rotation, and scale in 3D space."
+  });
+  registry.register({
+    type: "renderable",
+    defaultData: () => ({ visible: true, meshType: "box", color: "#FFFFFF", opacity: 1 }),
+    description: "Visual rendering properties."
+  });
+  registry.register({
+    type: "collider",
+    defaultData: () => ({ type: "box", size: { x: 1, y: 1, z: 1 }, isTrigger: false }),
+    description: "Collision shape."
+  });
+  registry.register({
+    type: "rigidbody",
+    defaultData: () => ({
+      mass: 1,
+      velocity: { x: 0, y: 0, z: 0 },
+      useGravity: true,
+      isKinematic: false
+    }),
+    description: "Physics body properties."
+  });
+  registry.register({
+    type: "audio_source",
+    defaultData: () => ({ soundId: "", volume: 1, loop: false, spatialize: true }),
+    description: "Spatial audio source."
+  });
+  registry.register({
+    type: "ui_element",
+    defaultData: () => ({ type: "panel", interactive: false, text: "" }),
+    description: "UI element properties."
+  });
+}
+
+// src/ecs/ComponentStore.ts
+var ComponentStore = class {
+  pools = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Pool Management
+  // ---------------------------------------------------------------------------
+  registerPool(type) {
+    const pool = { type, data: /* @__PURE__ */ new Map() };
+    this.pools.set(type, pool);
+    return pool;
+  }
+  getPool(type) {
+    return this.pools.get(type);
+  }
+  hasPool(type) {
+    return this.pools.has(type);
+  }
+  getPoolTypes() {
+    return [...this.pools.keys()];
+  }
+  // ---------------------------------------------------------------------------
+  // Component Operations
+  // ---------------------------------------------------------------------------
+  add(type, entityId, data) {
+    let pool = this.pools.get(type);
+    if (!pool) {
+      pool = { type, data: /* @__PURE__ */ new Map() };
+      this.pools.set(type, pool);
+    }
+    if (pool.data.has(entityId)) return false;
+    pool.data.set(entityId, data);
+    return true;
+  }
+  remove(type, entityId) {
+    return this.pools.get(type)?.data.delete(entityId) ?? false;
+  }
+  get(type, entityId) {
+    return this.pools.get(type)?.data.get(entityId);
+  }
+  has(type, entityId) {
+    return this.pools.get(type)?.data.has(entityId) ?? false;
+  }
+  set(type, entityId, data) {
+    const pool = this.pools.get(type);
+    if (!pool) return false;
+    const existing = pool.data.get(entityId);
+    if (!existing) return false;
+    Object.assign(existing, data);
+    return true;
+  }
+  // ---------------------------------------------------------------------------
+  // Iteration
+  // ---------------------------------------------------------------------------
+  forEach(type, callback) {
+    const pool = this.pools.get(type);
+    if (!pool) return;
+    for (const [entityId, data] of pool.data) {
+      callback(entityId, data);
+    }
+  }
+  getEntitiesWithComponent(type) {
+    const pool = this.pools.get(type);
+    if (!pool) return [];
+    return [...pool.data.keys()];
+  }
+  getEntitiesWithAll(...types) {
+    if (types.length === 0) return [];
+    const first = this.pools.get(types[0]);
+    if (!first) return [];
+    const result = [];
+    for (const entityId of first.data.keys()) {
+      if (types.every((t) => this.has(t, entityId))) {
+        result.push(entityId);
+      }
+    }
+    return result;
+  }
+  // ---------------------------------------------------------------------------
+  // Bulk Operations
+  // ---------------------------------------------------------------------------
+  removeAllForEntity(entityId) {
+    let removed = 0;
+    for (const pool of this.pools.values()) {
+      if (pool.data.delete(entityId)) removed++;
+    }
+    return removed;
+  }
+  getComponentCount(type) {
+    return this.pools.get(type)?.data.size ?? 0;
+  }
+  getTotalComponentCount() {
+    let total = 0;
+    for (const pool of this.pools.values()) total += pool.data.size;
+    return total;
+  }
+  clear(type) {
+    if (type) {
+      this.pools.get(type)?.data.clear();
+    } else {
+      for (const pool of this.pools.values()) pool.data.clear();
+    }
+  }
+};
+
+// src/ecs/EntityRegistry.ts
+var EntityRegistry = class {
+  entities = /* @__PURE__ */ new Map();
+  nextId = 1;
+  recycledIds = [];
+  tagIndex = /* @__PURE__ */ new Map();
+  nameIndex = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Entity Lifecycle
+  // ---------------------------------------------------------------------------
+  create(name = "", tags = []) {
+    const id = this.recycledIds.length > 0 ? this.recycledIds.pop() : this.nextId++;
+    const tagSet = new Set(tags);
+    const entity = {
+      id,
+      name: name || `entity_${id}`,
+      active: true,
+      tags: tagSet,
+      components: /* @__PURE__ */ new Set(),
+      parent: null,
+      children: [],
+      createdAt: Date.now()
+    };
+    this.entities.set(id, entity);
+    if (entity.name) this.nameIndex.set(entity.name, id);
+    for (const tag of tags) {
+      if (!this.tagIndex.has(tag)) this.tagIndex.set(tag, /* @__PURE__ */ new Set());
+      this.tagIndex.get(tag).add(id);
+    }
+    return entity;
+  }
+  destroy(id) {
+    const entity = this.entities.get(id);
+    if (!entity) return false;
+    if (entity.parent !== null) {
+      const parent = this.entities.get(entity.parent);
+      if (parent) parent.children = parent.children.filter((c) => c !== id);
+    }
+    for (const childId of [...entity.children]) {
+      this.destroy(childId);
+    }
+    this.nameIndex.delete(entity.name);
+    for (const tag of entity.tags) {
+      this.tagIndex.get(tag)?.delete(id);
+    }
+    this.entities.delete(id);
+    this.recycledIds.push(id);
+    return true;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  get(id) {
+    return this.entities.get(id);
+  }
+  getByName(name) {
+    const id = this.nameIndex.get(name);
+    return id !== void 0 ? this.entities.get(id) : void 0;
+  }
+  getByTag(tag) {
+    const ids = this.tagIndex.get(tag);
+    if (!ids) return [];
+    return [...ids].map((id) => this.entities.get(id)).filter((e) => e && e.active);
+  }
+  getByComponents(...componentTypes) {
+    const result = [];
+    for (const entity of this.entities.values()) {
+      if (!entity.active) continue;
+      if (componentTypes.every((t) => entity.components.has(t))) {
+        result.push(entity);
+      }
+    }
+    return result;
+  }
+  getAll() {
+    return [...this.entities.values()];
+  }
+  getActiveCount() {
+    let count = 0;
+    for (const e of this.entities.values()) if (e.active) count++;
+    return count;
+  }
+  getTotalCount() {
+    return this.entities.size;
+  }
+  // ---------------------------------------------------------------------------
+  // Tags
+  // ---------------------------------------------------------------------------
+  addTag(id, tag) {
+    const entity = this.entities.get(id);
+    if (!entity) return false;
+    entity.tags.add(tag);
+    if (!this.tagIndex.has(tag)) this.tagIndex.set(tag, /* @__PURE__ */ new Set());
+    this.tagIndex.get(tag).add(id);
+    return true;
+  }
+  removeTag(id, tag) {
+    const entity = this.entities.get(id);
+    if (!entity) return false;
+    entity.tags.delete(tag);
+    this.tagIndex.get(tag)?.delete(id);
+    return true;
+  }
+  hasTag(id, tag) {
+    return this.entities.get(id)?.tags.has(tag) ?? false;
+  }
+  // ---------------------------------------------------------------------------
+  // Hierarchy
+  // ---------------------------------------------------------------------------
+  setParent(childId, parentId) {
+    const child = this.entities.get(childId);
+    const parent = this.entities.get(parentId);
+    if (!child || !parent) return false;
+    if (child.parent !== null) {
+      const oldParent = this.entities.get(child.parent);
+      if (oldParent) oldParent.children = oldParent.children.filter((c) => c !== childId);
+    }
+    child.parent = parentId;
+    parent.children.push(childId);
+    return true;
+  }
+  getChildren(id) {
+    const entity = this.entities.get(id);
+    if (!entity) return [];
+    return entity.children.map((cid) => this.entities.get(cid)).filter(Boolean);
+  }
+  // ---------------------------------------------------------------------------
+  // Component Registration (bookkeeping only — actual data in ComponentStore)
+  // ---------------------------------------------------------------------------
+  registerComponent(entityId, componentType) {
+    const entity = this.entities.get(entityId);
+    if (!entity) return false;
+    entity.components.add(componentType);
+    return true;
+  }
+  unregisterComponent(entityId, componentType) {
+    const entity = this.entities.get(entityId);
+    if (!entity) return false;
+    return entity.components.delete(componentType);
+  }
+  hasComponent(entityId, componentType) {
+    return this.entities.get(entityId)?.components.has(componentType) ?? false;
+  }
+  // ---------------------------------------------------------------------------
+  // Activation
+  // ---------------------------------------------------------------------------
+  setActive(id, active) {
+    const entity = this.entities.get(id);
+    if (entity) entity.active = active;
+  }
+};
+
+// src/ecs/SystemScheduler.ts
+var PHASE_ORDER = ["preUpdate", "fixedUpdate", "update", "postUpdate", "render"];
+var SystemScheduler = class {
+  systems = /* @__PURE__ */ new Map();
+  executionOrder = [];
+  dirty = true;
+  fixedTimeStep = 1 / 60;
+  fixedAccumulator = 0;
+  phaseStats = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // System Registration
+  // ---------------------------------------------------------------------------
+  register(name, execute, phase = "update", priority = 0, dependencies = [], group = "default") {
+    this.systems.set(name, {
+      name,
+      phase,
+      execute,
+      enabled: true,
+      priority,
+      dependencies,
+      group,
+      lastExecutionTime: 0,
+      executionCount: 0
+    });
+    this.dirty = true;
+  }
+  unregister(name) {
+    const result = this.systems.delete(name);
+    if (result) this.dirty = true;
+    return result;
+  }
+  enable(name) {
+    const sys = this.systems.get(name);
+    if (sys) sys.enabled = true;
+  }
+  disable(name) {
+    const sys = this.systems.get(name);
+    if (sys) sys.enabled = false;
+  }
+  isEnabled(name) {
+    return this.systems.get(name)?.enabled ?? false;
+  }
+  // ---------------------------------------------------------------------------
+  // Execution Order Resolution
+  // ---------------------------------------------------------------------------
+  resolveExecutionOrder() {
+    if (!this.dirty) return;
+    const sorted = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const visit = (name) => {
+      if (visited.has(name)) return;
+      if (visiting.has(name)) return;
+      visiting.add(name);
+      const sys = this.systems.get(name);
+      if (sys) {
+        for (const dep of sys.dependencies) {
+          visit(dep);
+        }
+      }
+      visiting.delete(name);
+      visited.add(name);
+      sorted.push(name);
+    };
+    const byPhase = /* @__PURE__ */ new Map();
+    for (const [name, sys] of this.systems) {
+      if (!byPhase.has(sys.phase)) byPhase.set(sys.phase, []);
+      byPhase.get(sys.phase).push(name);
+    }
+    for (const phase of PHASE_ORDER) {
+      const phaseSystems = byPhase.get(phase) ?? [];
+      phaseSystems.sort((a, b) => {
+        const sa = this.systems.get(a), sb = this.systems.get(b);
+        return sa.priority - sb.priority;
+      });
+      for (const name of phaseSystems) visit(name);
+    }
+    this.executionOrder = sorted;
+    this.dirty = false;
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    this.resolveExecutionOrder();
+    this.phaseStats.clear();
+    this.fixedAccumulator += dt;
+    for (const name of this.executionOrder) {
+      const sys = this.systems.get(name);
+      if (!sys || !sys.enabled) continue;
+      if (sys.phase === "fixedUpdate") {
+        while (this.fixedAccumulator >= this.fixedTimeStep) {
+          const start = performance.now();
+          sys.execute(this.fixedTimeStep);
+          sys.lastExecutionTime = performance.now() - start;
+          sys.executionCount++;
+          this.recordPhaseTime(sys.phase, sys.name, sys.lastExecutionTime);
+          this.fixedAccumulator -= this.fixedTimeStep;
+        }
+      } else {
+        const start = performance.now();
+        sys.execute(dt);
+        sys.lastExecutionTime = performance.now() - start;
+        sys.executionCount++;
+        this.recordPhaseTime(sys.phase, sys.name, sys.lastExecutionTime);
+      }
+    }
+  }
+  recordPhaseTime(phase, name, time) {
+    if (!this.phaseStats.has(phase)) {
+      this.phaseStats.set(phase, { phase, systemCount: 0, totalTime: 0, systems: [] });
+    }
+    const stats = this.phaseStats.get(phase);
+    stats.systemCount++;
+    stats.totalTime += time;
+    stats.systems.push({ name, time });
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getSystem(name) {
+    return this.systems.get(name);
+  }
+  getSystemCount() {
+    return this.systems.size;
+  }
+  get systemCount() {
+    return this.systems.size;
+  }
+  getExecutionOrder() {
+    this.resolveExecutionOrder();
+    return [...this.executionOrder];
+  }
+  getPhaseStats() {
+    return new Map(this.phaseStats);
+  }
+  getSystemsByPhase(phase) {
+    return [...this.systems.values()].filter((s) => s.phase === phase);
+  }
+  setFixedTimeStep(dt) {
+    this.fixedTimeStep = dt;
+  }
+  getFixedTimeStep() {
+    return this.fixedTimeStep;
+  }
+};
+
+// src/state/ReactiveState.ts
+function reactive(target, onMutation) {
+  return new Proxy(target, {
+    get(obj, key) {
+      const value = Reflect.get(obj, key);
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        return reactive(value, onMutation);
+      }
+      return value;
+    },
+    set(obj, key, value) {
+      const oldValue = Reflect.get(obj, key);
+      const result = Reflect.set(obj, key, value);
+      if (oldValue !== value && onMutation) {
+        onMutation(obj, key, value, oldValue);
+      }
+      return result;
+    }
+  });
+}
+
+// src/state/UndoManager.ts
+var UndoManager = class {
+  undoStack = [];
+  redoStack = [];
+  maxDurationMs = 5e3;
+  push(undoOp, redoOp) {
+    const now = Date.now();
+    this.undoStack.push({ undo: undoOp, redo: redoOp, timestamp: now });
+    this.redoStack = [];
+    this.prune(now);
+  }
+  prune(now) {
+    while (this.undoStack.length > 0 && now - this.undoStack[0].timestamp > this.maxDurationMs) {
+      this.undoStack.shift();
+    }
+  }
+  undo() {
+    const step = this.undoStack.pop();
+    if (!step) return null;
+    this.redoStack.push(step);
+    return step;
+  }
+  redo() {
+    const step = this.redoStack.pop();
+    if (!step) return null;
+    this.undoStack.push(step);
+    return step;
+  }
+  clear() {
+    this.undoStack = [];
+    this.redoStack = [];
+  }
+};
+
+// src/ecs/World.ts
+var World = class {
+  nextEntity = 1;
+  entities = /* @__PURE__ */ new Set();
+  components = /* @__PURE__ */ new Map();
+  tags = /* @__PURE__ */ new Map();
+  undoManager = new UndoManager();
+  isUndoing = false;
+  /**
+   * Create a new entity.
+   */
+  createEntity() {
+    const id = this.nextEntity++;
+    this.entities.add(id);
+    if (!this.isUndoing) {
+      this.undoManager.push(
+        { type: "destroy", entity: id, components: /* @__PURE__ */ new Map(), tags: /* @__PURE__ */ new Set() },
+        // UNDO: Destroy
+        { type: "create", entity: id }
+        // REDO: Create
+      );
+    }
+    return id;
+  }
+  /**
+   * Destroy an entity and all its components.
+   */
+  destroyEntity(entity) {
+    const componentsToSave = /* @__PURE__ */ new Map();
+    for (const [type, store] of this.components) {
+      if (store.has(entity)) {
+        componentsToSave.set(type, store.get(entity));
+      }
+    }
+    const tagsToSave = new Set(this.tags.get(entity) || []);
+    if (!this.isUndoing) {
+      this.undoManager.push(
+        { type: "restore", entity, components: componentsToSave, tags: tagsToSave },
+        // UNDO: Restore
+        { type: "destroy", entity, components: componentsToSave, tags: tagsToSave }
+        // REDO: Destroy
+      );
+    }
+    this.entities.delete(entity);
+    this.tags.delete(entity);
+    for (const store of this.components.values()) {
+      store.delete(entity);
+    }
+  }
+  /**
+   * Check if an entity exists.
+   */
+  hasEntity(entity) {
+    return this.entities.has(entity);
+  }
+  /**
+   * Get entity count.
+   */
+  get entityCount() {
+    return this.entities.size;
+  }
+  /**
+   * Add a component to an entity.
+   * The component data will be wrapped in a reactive proxy.
+   */
+  addComponent(entity, type, data) {
+    if (!this.entities.has(entity)) return;
+    if (!this.components.has(type)) this.components.set(type, /* @__PURE__ */ new Map());
+    const reactiveData = reactive(data, (target, key, value, oldValue) => {
+      if (!this.isUndoing) {
+        this.undoManager.push(
+          {
+            type: "updateComponent",
+            entity,
+            componentType: type,
+            key,
+            value: oldValue,
+            oldValue: void 0
+          },
+          // UNDO
+          { type: "updateComponent", entity, componentType: type, key, value, oldValue: void 0 }
+          // REDO
+        );
+      }
+    });
+    this.components.get(type).set(entity, reactiveData);
+    if (!this.isUndoing) {
+      this.undoManager.push(
+        { type: "removeComponent", entity, componentType: type, data: reactiveData },
+        // UNDO
+        { type: "addComponent", entity, componentType: type, data: reactiveData }
+        // REDO
+      );
+    }
+  }
+  /**
+   * Remove a component from an entity.
+   */
+  removeComponent(entity, type) {
+    const data = this.components.get(type)?.get(entity);
+    if (data && !this.isUndoing) {
+      this.undoManager.push(
+        { type: "addComponent", entity, componentType: type, data },
+        // UNDO
+        { type: "removeComponent", entity, componentType: type, data }
+        // REDO
+      );
+    }
+    this.components.get(type)?.delete(entity);
+  }
+  /**
+   * Get a component from an entity.
+   */
+  getComponent(entity, type) {
+    return this.components.get(type)?.get(entity);
+  }
+  /**
+   * Check if an entity has a component.
+   */
+  hasComponent(entity, type) {
+    return this.components.get(type)?.has(entity) || false;
+  }
+  /**
+   * Get all component types for an entity.
+   */
+  getComponentTypes(entity) {
+    const types = [];
+    for (const [type, store] of this.components) {
+      if (store.has(entity)) {
+        types.push(type);
+      }
+    }
+    return types;
+  }
+  /**
+   * Add a tag to an entity.
+   */
+  addTag(entity, tag) {
+    if (!this.tags.has(entity)) this.tags.set(entity, /* @__PURE__ */ new Set());
+    this.tags.get(entity).add(tag);
+  }
+  /**
+   * Check if an entity has a tag.
+   */
+  hasTag(entity, tag) {
+    return this.tags.get(entity)?.has(tag) || false;
+  }
+  /**
+   * Query all entities that have ALL of the specified component types.
+   */
+  query(...componentTypes) {
+    const results = [];
+    for (const entity of this.entities) {
+      let match = true;
+      for (const type of componentTypes) {
+        if (!this.hasComponent(entity, type)) {
+          match = false;
+          break;
+        }
+      }
+      if (match) results.push(entity);
+    }
+    return results;
+  }
+  /**
+   * Query entities by tag.
+   */
+  queryByTag(tag) {
+    const results = [];
+    for (const entity of this.entities) {
+      if (this.hasTag(entity, tag)) results.push(entity);
+    }
+    return results;
+  }
+  /**
+   * Get all entities.
+   */
+  getAllEntities() {
+    return Array.from(this.entities);
+  }
+  /**
+   * Undo the last operation.
+   */
+  undo() {
+    const step = this.undoManager.undo();
+    if (!step) return;
+    this.isUndoing = true;
+    try {
+      this.applyOp(step.undo);
+    } finally {
+      this.isUndoing = false;
+    }
+  }
+  /**
+   * Redo the last undone operation.
+   */
+  redo() {
+    const step = this.undoManager.redo();
+    if (!step) return;
+    this.isUndoing = true;
+    try {
+      this.applyOp(step.redo);
+    } finally {
+      this.isUndoing = false;
+    }
+  }
+  applyOp(op) {
+    switch (op.type) {
+      case "create":
+        if (!this.entities.has(op.entity)) {
+          this.entities.add(op.entity);
+          if (op.entity >= this.nextEntity) {
+            this.nextEntity = op.entity + 1;
+          }
+        }
+        break;
+      case "destroy":
+        this.destroyEntity(op.entity);
+        break;
+      case "addComponent":
+        this.addComponent(op.entity, op.componentType, op.data);
+        break;
+      case "removeComponent":
+        this.removeComponent(op.entity, op.componentType);
+        break;
+      case "updateComponent":
+        const store = this.components.get(op.componentType);
+        if (store && store.has(op.entity)) {
+          const comp = store.get(op.entity);
+          comp[op.key] = op.value;
+        }
+        break;
+      case "addTag":
+        this.addTag(op.entity, op.tag);
+        break;
+      case "removeTag":
+        if (this.tags.has(op.entity)) {
+          this.tags.get(op.entity).delete(op.tag);
+        }
+        break;
+      case "restore":
+        if (!this.entities.has(op.entity)) {
+          this.entities.add(op.entity);
+          if (op.entity >= this.nextEntity) {
+            this.nextEntity = op.entity + 1;
+          }
+        }
+        op.components.forEach((data, type) => {
+          this.addComponent(op.entity, type, data);
+        });
+        op.tags.forEach((tag) => this.addTag(op.entity, tag));
+        break;
+    }
+  }
+};
+
+export {
+  ComponentRegistry,
+  registerBuiltInComponents,
+  ComponentStore,
+  EntityRegistry,
+  SystemScheduler,
+  World,
+  ecs_exports
+};