@draug/engine 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -0,0 +1,946 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Clock: () => Clock,
+  Commands: () => Commands,
+  Component: () => Component,
+  ComponentAlreadyRegisteredError: () => ComponentAlreadyRegisteredError,
+  ComponentStorage: () => ComponentStorage,
+  ComponentsManager: () => ComponentsManager,
+  EntitiesManager: () => EntitiesManager,
+  EntityMaskNotFoundError: () => EntityMaskNotFoundError,
+  EntityRef: () => EntityRef,
+  ErrMissingPluginMetadata: () => ErrMissingPluginMetadata,
+  ErrMissingSystemMetadata: () => ErrMissingSystemMetadata,
+  ErrNotAPlugin: () => ErrNotAPlugin,
+  ErrNotASystem: () => ErrNotASystem,
+  ErrPluginNotInit: () => ErrPluginNotInit,
+  ErrUnknownPlugin: () => ErrUnknownPlugin,
+  EventBuffer: () => EventBuffer,
+  EventBus: () => EventBus,
+  GameLoop: () => GameLoop,
+  Plugin: () => Plugin,
+  PluginBase: () => PluginBase,
+  PluginError: () => PluginError,
+  PluginsManager: () => PluginsManager,
+  ResourcesManager: () => ResourcesManager,
+  Runtime: () => Runtime,
+  SingletonStorage: () => SingletonStorage,
+  System: () => System,
+  SystemBase: () => SystemBase,
+  SystemError: () => SystemError,
+  SystemsManager: () => SystemsManager,
+  UnregisteredComponentStorageError: () => UnregisteredComponentStorageError,
+  World: () => World3,
+  createEventKey: () => createEventKey,
+  entry: () => entry,
+  getPluginMetadata: () => getPluginMetadata,
+  getSystemMetadata: () => getSystemMetadata,
+  isPlugin: () => isPlugin,
+  isSystem: () => isSystem
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ecs/system.ts
+var import_dag = require("@draug/core/graph/dag");
+var SystemError = class extends Error {
+  constructor(target) {
+    super(`[System Error] (System "${target.name}".`);
+  }
+};
+var ErrNotASystem = class extends Error {
+  constructor(target) {
+    super(`Provided class "${target.name}" is not a System! Extend your class from SystemBase.`);
+  }
+};
+var ErrMissingSystemMetadata = class extends SystemError {
+  constructor(target) {
+    super(target);
+    this.message = `${this.message}: Missing system metadata! Define system class with @System decorator.`;
+  }
+};
+var SystemMetadataSymbol = /* @__PURE__ */ Symbol("system");
+function System(props) {
+  return (target) => {
+    const systemTarget = target;
+    if ("__proto__" in systemTarget && systemTarget.__proto__ !== SystemBase) {
+      throw new ErrNotASystem(target);
+    }
+    const query = { ...props.query };
+    const requiredComponents = new Set(props.requiredComponents);
+    const computeAfter = new Set(props.computeAfter);
+    const metadata = { query, requiredComponents, computeAfter };
+    systemTarget[SystemMetadataSymbol] = metadata;
+  };
+}
+function getSystemMetadata(system) {
+  if (hasMetadata(system)) {
+    return system[SystemMetadataSymbol];
+  }
+  throw new ErrMissingSystemMetadata(system);
+}
+function hasMetadata(ctor) {
+  return SystemMetadataSymbol in ctor;
+}
+function isSystem(ctor) {
+  return hasMetadata(ctor);
+}
+var SystemBase = class {
+};
+var SystemsManager = class {
+  constructor(world) {
+    this.world = world;
+  }
+  world;
+  systems_ = /* @__PURE__ */ new Map();
+  executionOrder_ = [];
+  requiredComponents_ = /* @__PURE__ */ new Set();
+  dirty_ = true;
+  getRequiredComponents() {
+    return Array.from(this.requiredComponents_);
+  }
+  register(sys) {
+    const ctor = sys.constructor;
+    if (this.systems_.has(ctor)) throw new Error("Duplicate system");
+    const { query, requiredComponents } = getSystemMetadata(ctor);
+    this.systems_.set(ctor, sys);
+    const q = query;
+    for (const c of q.include ?? [])
+      this.requiredComponents_.add(c);
+    for (const c of q.exclude ?? [])
+      this.requiredComponents_.add(c);
+    for (const c of q.anyOf ?? [])
+      this.requiredComponents_.add(c);
+    for (const c of requiredComponents)
+      this.requiredComponents_.add(c);
+  }
+  build() {
+    this.buildSystemsArray();
+    for (const sys of this.systems_.values())
+      sys.onInit?.(this.world);
+  }
+  rebuild() {
+    this.build();
+  }
+  get(ctor) {
+    const s = this.systems_.get(ctor);
+    if (!s)
+      throw new Error("System not registered");
+    return s;
+  }
+  update(dt) {
+    if (this.dirty_)
+      this.rebuild();
+    this.world.events.swapAll();
+    for (const s of this.executionOrder_) {
+      const { query } = getSystemMetadata(s.constructor);
+      const entities = this.world.query(query);
+      s.compute({ entities, world: this.world, dt });
+    }
+  }
+  buildSystemsArray() {
+    const map = /* @__PURE__ */ new Map();
+    for (const [ctor, system] of this.systems_.entries()) {
+      map.set(ctor, new import_dag.DAGNode(system));
+    }
+    for (const ctor of this.systems_.keys()) {
+      const currentNode = map.get(ctor);
+      const { computeAfter } = getSystemMetadata(ctor);
+      for (const depCtor of computeAfter ?? []) {
+        const depNode = map.get(depCtor);
+        if (!depNode) {
+          throw new Error(`Dependency ${depCtor.name} not registered`);
+        }
+        depNode.vertices.push(currentNode);
+      }
+    }
+    this.executionOrder_ = (0, import_dag.topologicalSort)(map.values()).map((x) => x.data);
+  }
+};
+
+// src/ecs/entity.ts
+var UnregisteredComponentStorageError = class extends Error {
+  constructor(component) {
+    super(`Cannot get storage for component ${component.name}. Seems like it's not registered in world.`);
+  }
+};
+var EntityMaskNotFoundError = class extends Error {
+  constructor(id2) {
+    super(`Cannot find bitmask for entity [${id2}]. Seems like it's not registered in the EntityManager.`);
+  }
+};
+var EntitiesManager = class {
+  id_ = 0;
+  nextId() {
+    return ++this.id_;
+  }
+  create() {
+    return this.nextId();
+  }
+};
+var EntityRef = class {
+  constructor(world, id2) {
+    this.world = world;
+    this.id = id2;
+  }
+  world;
+  id;
+  with(...components) {
+    return components.map((c) => {
+      const s = this.world.components.getStorage(c);
+      return s.tryGet(this.id);
+    });
+  }
+};
+
+// src/ecs/constant.ts
+var ECS_DEFAULTS = {
+  MAX_ENTITY_COUNT: Math.pow(2, 16)
+};
+
+// src/ecs/events-buffer.ts
+var EventBuffer = class {
+  readBuf = [];
+  writeBuf = [];
+  write(event) {
+    this.writeBuf.push(event);
+  }
+  /**
+   * Advances the buffer to the next frame.
+   *
+   * Performs a double-buffer flip:
+   * - Promotes all events written during the previous frame (`writeBuf`)
+   *   to be readable in the current frame (`readBuf`).
+   * - Reuses the previous `readBuf` as the new `writeBuf` and clears it
+   *   to collect events for the next frame.
+   *
+   * After calling this method:
+   * - `get()` will return a stable snapshot of events produced in the previous frame.
+   * - `add()` will write into an empty buffer for the current frame.
+   *
+   * Guarantees:
+   * - No events written during the current frame are visible until the next `swap()`.
+   * - Readers observe a consistent, immutable snapshot within a frame.
+   *
+   * Expected to be called exactly once per frame, before system execution.
+  */
+  swap() {
+    const tmp = this.readBuf;
+    this.readBuf = this.writeBuf;
+    this.writeBuf = tmp;
+    this.writeBuf.length = 0;
+  }
+  read() {
+    return this.readBuf;
+  }
+  size() {
+    return this.readBuf.length;
+  }
+};
+function createEventKey(description) {
+  return Symbol(description);
+}
+var EventBus = class {
+  storage = /* @__PURE__ */ new Map();
+  swapAll() {
+    this.storage.forEach((s) => s.swap());
+  }
+  getBuffer(key) {
+    let buf = this.storage.get(key);
+    if (!buf) {
+      buf = new EventBuffer();
+      this.storage.set(key, buf);
+    }
+    return buf;
+  }
+};
+
+// src/ecs/components/component-storage.ts
+var import_pool = require("@draug/core/memory/pool");
+var import_bitmap_index = require("bitmap-index");
+var import_ts_sparse_set = require("ts-sparse-set");
+var ComponentStorage = class {
+  bits_;
+  set_;
+  pool_;
+  id_ = 0;
+  cls;
+  constructor(cap = ECS_DEFAULTS.MAX_ENTITY_COUNT, factory, cls) {
+    this.set_ = new import_ts_sparse_set.SparseSet(cap);
+    this.bits_ = new import_bitmap_index.Bitmap(cap);
+    this.pool_ = new import_pool.ObjectPool(factory, cap);
+    this.cls = cls;
+  }
+  bitmap() {
+    return this.bits_;
+  }
+  get id() {
+    return this.id_;
+  }
+  _internalSetId(id2) {
+    return this.id_ = id2;
+  }
+  add(id2, initFn) {
+    const obj = this.pool_.acquire();
+    initFn?.(obj);
+    const value = this.set_.add(id2, obj);
+    this.bits_.set(id2);
+    return value;
+  }
+  remove(id2) {
+    const obj = this.set_.get(id2);
+    if (!obj) return;
+    this.bits_.remove(id2);
+    this.pool_.release(obj);
+    this.set_.remove(id2);
+  }
+  get(id2) {
+    return this.set_.get(id2);
+  }
+  tryGet(id2) {
+    const x = this.set_.get(id2);
+    if (!x)
+      throw new Error(`[ComponentStorage "${this.cls.name}"]: Requesting non-existing item with ID ${id2}.`);
+    return x;
+  }
+  writeComponentsToBuf(ids, out) {
+    let len = 0;
+    for (const id2 of ids) {
+      const obj = this.set_.get(id2);
+      if (obj !== null) out[len++] = obj;
+    }
+    return len;
+  }
+  has(id2) {
+    return this.bits_.contains(id2);
+  }
+  entityIds() {
+    return Array.from(this.bits_);
+  }
+  size() {
+    return this.bits_.count();
+  }
+  forEach(cb) {
+    this.bits_.range((x) => cb(x));
+  }
+};
+
+// src/ecs/components/singleton-storage.ts
+var SingletonStorage = class {
+  constructor(factory) {
+    this.factory = factory;
+  }
+  factory;
+  value = null;
+  entityId = null;
+  bitmap() {
+    throw new Error("Singletone component cannot has a bitmap!");
+  }
+  add(id2, initFn) {
+    if (this.value !== null)
+      throw new Error("Singleton already initiated");
+    this.entityId = id2;
+    this.value = this.factory();
+    initFn?.(this.value);
+    return this.value;
+  }
+  remove(id2) {
+    if (!this.validateId(id2))
+      return;
+    this.value = null;
+    this.entityId = null;
+  }
+  get(id2) {
+    if (!this.validateId(id2))
+      return null;
+    return this.value;
+  }
+  tryGet(id2) {
+    if (!this.validateId(id2))
+      throw new Error("[SingletoneStorage]: ID missmatch.");
+    return this.value;
+  }
+  has(id2) {
+    return this.validateId(id2);
+  }
+  size() {
+    return this.value !== null ? 1 : 0;
+  }
+  forEach(cb) {
+    if (this.entityId !== null)
+      cb(this.entityId);
+  }
+  validateId(id2) {
+    return this.entityId !== null && id2 === this.entityId;
+  }
+};
+
+// src/ecs/components/manager.ts
+var ComponentAlreadyRegisteredError = class extends Error {
+  constructor(component) {
+    super(`Component ${component.name} already registered!`);
+  }
+};
+var ComponentsManager = class {
+  constructor(maxEntityCount = ECS_DEFAULTS.MAX_ENTITY_COUNT) {
+    this.maxEntityCount = maxEntityCount;
+  }
+  maxEntityCount;
+  storages_ = /* @__PURE__ */ new Map();
+  currId_ = 0;
+  nextId() {
+    return ++this.currId_;
+  }
+  register(component, opts) {
+    if (this.storages_.has(component))
+      return this.storages_.get(component);
+    let store;
+    switch (opts?.storageType) {
+      case 2 /* SINGLETON_STORAGE */:
+        store = this.createSingletonStore(opts);
+        break;
+      case 1 /* COMPONENT_STORAGE */:
+        store = this.createComponentStore(component, opts);
+        break;
+      default:
+        store = this.createComponentStore(component, opts);
+        break;
+    }
+    this.storages_.set(component, store);
+    return store;
+  }
+  createComponentStore(component, opts) {
+    const factory = opts?.factory ?? ((...args) => new component(...args));
+    const store = new ComponentStorage(this.maxEntityCount, factory, component);
+    store._internalSetId(this.nextId());
+    return store;
+  }
+  createSingletonStore(opts) {
+    if (!opts?.factory) {
+      throw new Error("For singletone storage provide factory is required!");
+    }
+    return new SingletonStorage(opts.factory);
+  }
+  getStorage(component) {
+    const store = this.storages_.get(component);
+    if (store === void 0)
+      throw new UnregisteredComponentStorageError(component);
+    return store;
+  }
+  getComponentId(ctor) {
+    return getComponentId(ctor);
+  }
+};
+
+// src/ecs/components/utils.ts
+var registry = /* @__PURE__ */ new Map();
+var id = 0;
+function Component() {
+  return (target) => {
+    if (registry.has(target)) return;
+    registry.set(target, ++id);
+  };
+}
+function getComponentId(ctor) {
+  const id2 = registry.get(ctor);
+  if (id2 === void 0) {
+    throw new Error(`Component not registered: ${ctor.name}`);
+  }
+  return id2;
+}
+
+// src/ecs/resources/resources.ts
+var ResourcesManager = class {
+  items_ = /* @__PURE__ */ new Map();
+  insert(type, value) {
+    this.items_.set(type, value);
+    return value;
+  }
+  get(type) {
+    const value = this.items_.get(type);
+    if (!value)
+      throw new Error(`Resource of class ${type.name} does not exist!`);
+    return value;
+  }
+  getOrInsert(type, factory) {
+    let value = this.items_.get(type) ?? null;
+    if (value === null) {
+      value = factory();
+      this.items_.set(type, value);
+    }
+    return value;
+  }
+  remove(type) {
+    this.items_.delete(type);
+  }
+};
+
+// src/ecs/command.ts
+function entry(component, init = () => {
+}) {
+  return [component, init];
+}
+var Commands = class {
+  constructor(world) {
+    this.world = world;
+  }
+  world;
+  commandsQueue_ = [];
+  add(cmd) {
+    this.commandsQueue_.push(cmd);
+  }
+  flush(world) {
+    for (const cmd of this.commandsQueue_)
+      cmd(world);
+    this.commandsQueue_.length = 0;
+  }
+  createEntity(...entries) {
+    const id2 = this.world.entities.create();
+    const cmd = (world) => {
+      for (const [cls, initFn] of entries) {
+        world.addComponent(id2, cls, initFn);
+      }
+    };
+    this.add(cmd);
+    return id2;
+  }
+};
+
+// src/ecs/query.ts
+var import_bitmap_index2 = require("bitmap-index");
+var QueryManager = class {
+  constructor(world) {
+    this.world = world;
+  }
+  world;
+  cache = /* @__PURE__ */ new Map();
+  get(params) {
+    const key = this.getKey(params);
+    let entry2 = this.cache.get(key);
+    if (!entry2) {
+      entry2 = {
+        params,
+        bitmap: this.compute(params),
+        dirty: false,
+        deps: this.collectDeps(params)
+      };
+      this.cache.set(key, entry2);
+    }
+    if (entry2.dirty) {
+      entry2.bitmap = this.compute(entry2.params);
+      entry2.dirty = false;
+    }
+    let targetBitmap = entry2.bitmap;
+    if (params.excludeEntitiesIds?.length) {
+      targetBitmap = entry2.bitmap.clone();
+      const excludeBm = new import_bitmap_index2.Bitmap();
+      for (const id2 of params.excludeEntitiesIds) {
+        excludeBm.set(id2);
+      }
+      targetBitmap.andNot(excludeBm);
+    }
+    if (params.filter) {
+      const result = [];
+      targetBitmap.range((id2) => {
+        if (params.filter(id2)) result.push(id2);
+      });
+      return result;
+    }
+    return this.extractIds(targetBitmap);
+  }
+  invalidate(component) {
+    for (const entry2 of this.cache.values()) {
+      if (entry2.deps.has(component)) {
+        entry2.dirty = true;
+      }
+    }
+  }
+  getKey(q) {
+    return [
+      this.ids(q.include),
+      this.ids(q.exclude),
+      this.ids(q.anyOf)
+    ].join("|");
+  }
+  ids(arr) {
+    if (!arr || arr.length === 0) return "";
+    return arr.map((c) => this.world.components.getComponentId(c)).sort((a, b) => a - b).join(",");
+  }
+  collectDeps(q) {
+    const set = /* @__PURE__ */ new Set();
+    q.include?.forEach((c) => set.add(c));
+    q.exclude?.forEach((c) => set.add(c));
+    q.anyOf?.forEach((c) => set.add(c));
+    return set;
+  }
+  compute(params) {
+    let result = this.combineBitmaps(params.include, "and");
+    const any = this.combineBitmaps(params.anyOf, "or");
+    if (any) {
+      result = result ? result.and(any) : any;
+    }
+    if (!result) {
+      return new import_bitmap_index2.Bitmap();
+    }
+    this.applyExclusions(result, params.exclude);
+    return result;
+  }
+  combineBitmaps(components, op) {
+    if (!components?.length) return null;
+    let result = null;
+    let hasAtLeastOneValid = false;
+    for (const c of components) {
+      const bm = this.world.components.getStorage(c)?.bitmap();
+      if (!bm) {
+        if (op === "and") {
+          return new import_bitmap_index2.Bitmap();
+        }
+        continue;
+      }
+      hasAtLeastOneValid = true;
+      if (!result) {
+        result = bm.clone();
+      } else {
+        op === "and" ? result.and(bm) : result.or(bm);
+      }
+    }
+    if (op === "or" && !hasAtLeastOneValid) {
+      return new import_bitmap_index2.Bitmap();
+    }
+    return result;
+  }
+  applyExclusions(target, excludeComponents) {
+    if (excludeComponents?.length) {
+      for (const c of excludeComponents) {
+        const bm = this.world.components.getStorage(c)?.bitmap();
+        if (bm) target.andNot(bm);
+      }
+    }
+  }
+  extractIds(bitmap) {
+    const result = [];
+    bitmap.range((id2) => {
+      result.push(id2);
+    });
+    return result;
+  }
+};
+
+// src/plugin/plugin.ts
+var import_dag2 = require("@draug/core/graph/dag");
+var PluginMetadataSymbol = /* @__PURE__ */ Symbol("plugin");
+function Plugin(metadata) {
+  return (target) => {
+    if ("__proto__" in target && target.__proto__ !== PluginBase)
+      throw new ErrNotAPlugin(target);
+    target[PluginMetadataSymbol] = metadata;
+  };
+}
+function getPluginMetadata(plugin) {
+  if (hasMetadata2(plugin)) {
+    return plugin[PluginMetadataSymbol];
+  }
+  throw new ErrMissingPluginMetadata(plugin);
+}
+function hasMetadata2(ctor) {
+  return PluginMetadataSymbol in ctor;
+}
+function isPlugin(ctor) {
+  return hasMetadata2(ctor);
+}
+var PluginBase = class {
+  onPluginLoad;
+  onPluginUnload;
+  onAfterWorldInit;
+};
+var PluginError = class extends Error {
+  constructor(pluginId) {
+    super(`Plugin error! Plugin [${pluginId}]`);
+  }
+};
+var ErrNotAPlugin = class extends Error {
+  constructor(target) {
+    super(`Provided class ${target.name} is not a Plugin! Every plugin must extends of PluginBase class.`);
+  }
+};
+var ErrMissingPluginMetadata = class extends Error {
+  constructor(plugin) {
+    super(`Provided class ${plugin.name}: Missing plugin metadata! Define plugin class with @Plugin decorator.`);
+  }
+};
+var ErrUnknownPlugin = class extends PluginError {
+  constructor(pluginId) {
+    super(pluginId);
+    this.message = `${super.message}: Plugin not found in manager.`;
+  }
+};
+var ErrPluginNotInit = class extends PluginError {
+  constructor(pluginId) {
+    super(pluginId);
+    this.message = `${super.message}: Plugin not initiated yet. You must use PluginsManager.build() before getting instance.`;
+  }
+};
+var ErrMissingPluginDependency = class extends PluginError {
+  constructor(pluginId, missingDepId) {
+    super(pluginId);
+    this.message = `${super.message}: Missing required dependency [${missingDepId}]. Install it first.`;
+  }
+};
+var ErrDAGCycleDetectedPlugin = class extends Error {
+  constructor() {
+    super(`Cycle detected in plugin dependencies!`);
+  }
+};
+var PluginsManager = class {
+  plugins_ = /* @__PURE__ */ new Map();
+  isInitiated_ = false;
+  install(plugin, ...constructorProps) {
+    if (!isPlugin(plugin))
+      throw new ErrMissingPluginMetadata(plugin);
+    const metadata = getPluginMetadata(plugin);
+    if (this.plugins_.has(metadata.id))
+      return;
+    const entry2 = {
+      ctor: plugin,
+      ctorParams: constructorProps,
+      metadata
+    };
+    this.plugins_.set(metadata.id, entry2);
+  }
+  build() {
+    const nodes = /* @__PURE__ */ new Map();
+    for (const id2 of this.plugins_.keys()) {
+      nodes.set(id2, new import_dag2.DAGNode(id2));
+    }
+    for (const [id2, entry2] of this.plugins_) {
+      const node = nodes.get(id2);
+      const depPlugins = entry2.metadata.dependencies?.plugins ?? [];
+      for (const dep of depPlugins) {
+        const depNode = nodes.get(dep.id);
+        if (!depNode) {
+          throw new ErrMissingPluginDependency(id2, dep.id);
+        }
+        node.vertices.push(depNode);
+      }
+    }
+    let sortedNodes;
+    try {
+      sortedNodes = (0, import_dag2.topologicalSort)(nodes.values());
+    } catch (e) {
+      if (e instanceof import_dag2.ErrDAGCycleDetected) {
+        throw new ErrDAGCycleDetectedPlugin();
+      }
+      throw e;
+    }
+    for (const node of sortedNodes) {
+      const entry2 = this.plugins_.get(node.data);
+      const { ctor, ctorParams } = entry2;
+      entry2.instance = new ctor(...ctorParams);
+    }
+    this.isInitiated_ = true;
+  }
+  getPluginMetadata(pluginOrId) {
+    const id2 = this.resolveId(pluginOrId);
+    const entry2 = this.plugins_.get(id2);
+    if (!entry2) throw new ErrUnknownPlugin(id2);
+    return entry2.metadata;
+  }
+  getPluginInstance(pluginOrId) {
+    if (!this.isInitiated_) {
+      throw new Error("Plugin instance is not initiated yet. Use PluginManager.build() before use plugins.");
+    }
+    const id2 = this.resolveId(pluginOrId);
+    const entry2 = this.plugins_.get(id2);
+    if (!entry2) throw new ErrUnknownPlugin(id2);
+    if (!entry2.instance) throw new ErrPluginNotInit(id2);
+    return entry2.instance;
+  }
+  resolveId(pluginOrId) {
+    if (typeof pluginOrId === "string") {
+      return pluginOrId;
+    }
+    if (!isPlugin(pluginOrId)) {
+      throw new ErrMissingPluginMetadata(pluginOrId);
+    }
+    return getPluginMetadata(pluginOrId).id;
+  }
+};
+
+// src/ecs/world.ts
+var World3 = class {
+  entities = new EntitiesManager();
+  components = new ComponentsManager();
+  systems = new SystemsManager(this);
+  events = new EventBus();
+  resources = new ResourcesManager();
+  commands = new Commands(this);
+  queries = new QueryManager(this);
+  plugins = new PluginsManager();
+  entityRefs_ = /* @__PURE__ */ new Map();
+  constructor(maxEntityCount = ECS_DEFAULTS.MAX_ENTITY_COUNT) {
+    this.components = new ComponentsManager(maxEntityCount);
+  }
+  getEntityRef(id2) {
+    let ref = this.entityRefs_.get(id2);
+    if (!ref) {
+      ref = new EntityRef(this, id2);
+      this.entityRefs_.set(id2, ref);
+    }
+    return ref;
+  }
+  query(params) {
+    return this.queries.get(params);
+  }
+  removeComponent(entity, component) {
+    const id2 = typeof entity === "number" ? entity : entity.id;
+    const storage = this.components.getStorage(component);
+    storage.remove(id2);
+    this.queries.invalidate(component);
+  }
+  addComponent(entity, component, initFn) {
+    const storage = this.components.getStorage(component);
+    let id2;
+    if (typeof entity === "number") {
+      id2 = entity;
+    } else {
+      id2 = entity.id;
+    }
+    const c = storage.add(id2, (o) => {
+      if (initFn) {
+        initFn(o);
+      }
+      return o;
+    });
+    this.queries.invalidate(component);
+    return c;
+  }
+  update(dt) {
+    this.systems.update(dt);
+    this.commands.flush(this);
+  }
+  build() {
+    this.plugins.build();
+  }
+};
+
+// src/runtime/clock.ts
+var Clock = class {
+  constructor(timeSource_) {
+    this.timeSource_ = timeSource_;
+    this.lastTimeMs_ = timeSource_.now();
+  }
+  timeSource_;
+  lastTimeMs_;
+  elapsedTime_ = 0;
+  dt_ = 0;
+  get dt() {
+    return this.dt_;
+  }
+  get ellapsedTime() {
+    return this.elapsedTime_;
+  }
+  tick() {
+    const now = this.timeSource_.now();
+    const dt = now - this.lastTimeMs_;
+    this.dt_ = dt;
+    this.elapsedTime_ += dt;
+    this.lastTimeMs_ = now;
+  }
+};
+
+// src/runtime/game-loop.ts
+var GameLoop = class {
+  constructor(clock, stepFn) {
+    this.clock = clock;
+    this.stepFn = stepFn;
+  }
+  clock;
+  stepFn;
+  running = false;
+  start(platformLoop) {
+    this.running = true;
+    const loop = () => {
+      if (!this.running) return;
+      this.clock.tick();
+      this.stepFn(this.clock.dt);
+      platformLoop(loop);
+    };
+    platformLoop(loop);
+  }
+  stop() {
+    this.running = false;
+  }
+};
+
+// src/runtime/runtime.ts
+var Runtime = class {
+  constructor(world, assets) {
+    this.world = world;
+    this.assets = assets;
+  }
+  world;
+  assets;
+  update(dt) {
+    this.world.update(dt);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Clock,
+  Commands,
+  Component,
+  ComponentAlreadyRegisteredError,
+  ComponentStorage,
+  ComponentsManager,
+  EntitiesManager,
+  EntityMaskNotFoundError,
+  EntityRef,
+  ErrMissingPluginMetadata,
+  ErrMissingSystemMetadata,
+  ErrNotAPlugin,
+  ErrNotASystem,
+  ErrPluginNotInit,
+  ErrUnknownPlugin,
+  EventBuffer,
+  EventBus,
+  GameLoop,
+  Plugin,
+  PluginBase,
+  PluginError,
+  PluginsManager,
+  ResourcesManager,
+  Runtime,
+  SingletonStorage,
+  System,
+  SystemBase,
+  SystemError,
+  SystemsManager,
+  UnregisteredComponentStorageError,
+  World,
+  createEventKey,
+  entry,
+  getPluginMetadata,
+  getSystemMetadata,
+  isPlugin,
+  isSystem
+});
+//# sourceMappingURL=index.cjs.map