@ste_tisci/ecs 0.1.6 → 0.1.7

package/dist/index.cjs

@@ -0,0 +1,265 @@
+"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, {
+  ECS: () => ECS
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/SparseSet.ts
+function SparseSet() {
+  const sparse = [];
+  const dense = [];
+  let size = 0;
+  function has(eid) {
+    const ID = getIndex(eid);
+    const exist = ID !== void 0 && dense[ID] === eid;
+    const isWhitinBounds = ID >= 0 && ID < size;
+    return exist && isWhitinBounds;
+  }
+  function add(eid) {
+    if (has(eid)) throw new Error(`ID ${eid} already present in the set`);
+    sparse[eid] = size;
+    dense[size] = eid;
+    size++;
+  }
+  function remove(eid) {
+    if (!has(eid)) throw new Error(`Cannot remove ID ${eid} because does not exists`);
+    const ID = getIndex(eid);
+    const last = dense[size - 1];
+    dense[ID] = last;
+    sparse[last] = ID;
+    dense.pop();
+    size--;
+    delete sparse[eid];
+  }
+  function getIndex(eid) {
+    return sparse[eid];
+  }
+  function getDense() {
+    return dense;
+  }
+  function getSize() {
+    return size;
+  }
+  return { has, add, remove, getIndex, getDense, getSize };
+}
+
+// src/ComponentStore.ts
+var INITIAL_CAPACITY = 8;
+function grow(buffer, requiredIndex) {
+  let capacity = buffer.length;
+  while (capacity <= requiredIndex) capacity *= 2;
+  const grown = new Float32Array(capacity);
+  grown.set(buffer);
+  return grown;
+}
+function ComponentStore() {
+  const componentSet = SparseSet();
+  const componentData = {};
+  const isNumeric = {};
+  function add(eid, data) {
+    if (componentSet.has(eid)) throw new Error(`Entity ${eid} already has this component`);
+    const ID = componentSet.getSize();
+    componentSet.add(eid);
+    for (const key in data) {
+      const value = data[key];
+      if (!(key in componentData)) {
+        isNumeric[key] = typeof value === "number";
+        componentData[key] = isNumeric[key] ? new Float32Array(INITIAL_CAPACITY) : [];
+      }
+      if (isNumeric[key] && ID >= componentData[key].length) {
+        componentData[key] = grow(componentData[key], ID);
+      }
+      componentData[key][ID] = value;
+    }
+  }
+  function remove(eid) {
+    if (!componentSet.has(eid)) throw new Error(`Entity ${eid} does not have this component`);
+    const ID = componentSet.getIndex(eid);
+    const lastID = componentSet.getSize() - 1;
+    if (ID !== lastID) {
+      for (const key of Object.keys(componentData)) {
+        componentData[key][ID] = componentData[key][lastID];
+      }
+    }
+    componentSet.remove(eid);
+    for (const key in componentData) {
+      if (!isNumeric[key]) {
+        componentData[key].pop();
+      }
+    }
+  }
+  function getDense() {
+    return componentSet.getDense();
+  }
+  function getData() {
+    return componentData;
+  }
+  function getIndex(eid) {
+    return componentSet.getIndex(eid);
+  }
+  function getSize() {
+    return componentSet.getSize();
+  }
+  return { add, remove, getIndex, getDense, getData, getSize };
+}
+
+// src/EntityManager.ts
+function EntityManager(registry) {
+  let nextID = 0;
+  const recycledIDs = [];
+  const bitMasks = [];
+  function exists(eid) {
+    const isWithinBounds = eid >= 0 && eid < nextID;
+    const hasMask = bitMasks[eid] !== void 0;
+    return isWithinBounds && hasMask;
+  }
+  function hasComponent(eid, name) {
+    if (!exists(eid)) throw new Error(`Entity ${eid} does not exist`);
+    const cid = registry.getID(name);
+    return (bitMasks[eid] & 1n << BigInt(cid)) !== 0n;
+  }
+  function create() {
+    const ID = recycledIDs.length > 0 ? recycledIDs.pop() : nextID++;
+    bitMasks[ID] = 0n;
+    return ID;
+  }
+  function remove(eid) {
+    if (!exists(eid)) throw new Error(`Entity ${eid} does not exist`);
+    bitMasks[eid] = void 0;
+    recycledIDs.push(eid);
+  }
+  function addComponent(eid, name) {
+    if (!exists(eid)) throw new Error(`Entity ${eid} does not exists`);
+    if (hasComponent(eid, name)) throw new Error(`Entity ${eid} already has component ${name}`);
+    const cid = registry.getID(name);
+    bitMasks[eid] |= 1n << BigInt(cid);
+  }
+  function removeComponent(eid, name) {
+    if (!exists(eid)) throw new Error(`Entity ${eid} does not exists`);
+    if (!hasComponent(eid, name)) throw new Error(`Entity ${eid} does not have component ${name}`);
+    const cid = registry.getID(name);
+    bitMasks[eid] &= ~(1n << BigInt(cid));
+  }
+  function getMask(eid) {
+    if (!exists(eid)) throw new Error(`Entity ${eid} does not exist`);
+    return bitMasks[eid];
+  }
+  return { exists, hasComponent, create, remove, addComponent, removeComponent, getMask };
+}
+
+// src/utils/ComponentRegistry.ts
+function createComponentRegistry() {
+  const nameToID = /* @__PURE__ */ new Map();
+  const IDtoName = /* @__PURE__ */ new Map();
+  let nextID = 0;
+  function register(name) {
+    if (!nameToID.has(name)) {
+      const eid = nextID++;
+      nameToID.set(name, eid);
+      IDtoName.set(eid, name);
+    }
+  }
+  function getID(name) {
+    const eid = nameToID.get(name);
+    if (eid === void 0) throw new Error(`Component ${name} not registered`);
+    return eid;
+  }
+  function getName(cid) {
+    const name = IDtoName.get(cid);
+    if (!name) throw new Error(`Component ID ${cid} not registered`);
+    return name;
+  }
+  return { register, getID, getName };
+}
+
+// src/Ecs.ts
+function ECS() {
+  const ComponentRegistry = createComponentRegistry();
+  const Entities = EntityManager(ComponentRegistry);
+  const internalStores = {};
+  const components = {};
+  function defineComponents(...names) {
+    for (const name of names) {
+      if (name in internalStores) throw new Error(`Component ${String(name)} is already defined`);
+      ComponentRegistry.register(name);
+      internalStores[name] = ComponentStore();
+      components[name] = internalStores[name].getData();
+    }
+  }
+  function createEntity() {
+    return Entities.create();
+  }
+  function destroyEntity(eid) {
+    const entityMask = Entities.getMask(eid);
+    let cid = 0;
+    let tempMask = entityMask;
+    while (tempMask !== 0n) {
+      if ((tempMask & 1n) !== 0n) {
+        const name = ComponentRegistry.getName(cid);
+        internalStores[name].remove(eid);
+      }
+      tempMask >>= 1n;
+      cid++;
+    }
+    Entities.remove(eid);
+  }
+  function addComponent(eid, name, data) {
+    Entities.addComponent(eid, name);
+    internalStores[name].add(eid, data);
+  }
+  function removeComponent(eid, name) {
+    Entities.removeComponent(eid, name);
+    internalStores[name].remove(eid);
+  }
+  function* query(...componentName) {
+    if (componentName.length === 0) return;
+    let targetMask = 0n;
+    for (const name of componentName) {
+      targetMask |= 1n << BigInt(ComponentRegistry.getID(name));
+    }
+    let smallestStore = internalStores[componentName[0]];
+    let smallestSize = smallestStore.getSize();
+    for (let i = 1; i < componentName.length; i++) {
+      const store = internalStores[componentName[i]];
+      const size = store.getSize();
+      if (size < smallestSize) {
+        smallestStore = store;
+        smallestSize = size;
+      }
+    }
+    for (const eid of smallestStore.getDense()) {
+      if ((Entities.getMask(eid) & targetMask) !== targetMask) continue;
+      const result = {};
+      for (const name of componentName) {
+        const id = internalStores[name].getIndex(eid);
+        result[name] = { id };
+      }
+      yield result;
+    }
+  }
+  return { defineComponents, createEntity, destroyEntity, addComponent, removeComponent, query, components };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ECS
+});

package/{src/types/IEcs.d.ts → dist/index.d.cts}

@@ -1,12 +1,43 @@
-import type { QueryResult, StoreDataMap } from './index.js';
+/**
+ * Represents component data in Structure of Arrays (SoA) format.
+ * Each property of the component is stored in a separate array,
+ * enabling cache-efficient iteration and SIMD operations.
+ * Numeric properties are backed by a Float32Array for a compact, homogeneous
+ * memory layout; non-numeric properties fall back to a plain JS array.
+ * @template T - The component data type
+ * @example
+ * // For Position component: { x: number, y: number }
+ * // ComponentDataArrays would be: { x: Float32Array, y: Float32Array }
+ */
+type ComponentDataArrays<T> = {
+  [K in keyof T]: T[K] extends number ? Float32Array : T[K][];
+};
 
+/**
+ * Maps component names to their data arrays for direct access.
+ * Used to expose component data to the user without store methods.
+ * @template T - Record type defining all component types
+ */
+type StoreDataMap<T> = {
+  [K in keyof T]: ComponentDataArrays<T[K]>;
+};
+
+/**
+ * Type helper for the query result.
+ * Creates an object with an entry for each requested component, holding its store index.
+ * @template C - Array of the component names requested in the query.
+ */
+type QueryResult<C extends readonly PropertyKey[]> = {
+  [K in C[number]]: { id: number };
+};
+
 /**
  * Interface for the main ECS registry.
  * Provides high-level API for entity-component management,
  * coordinating between EntityManager and ComponentStores.
  * @template T - Record type defining all component types in the ECS
  */
-export interface IECS<T> {
+interface IECS<T> {
   /**
    * Initializes the ECS with component definitions.
    * Registers all components and creates their corresponding stores.
@@ -61,4 +92,8 @@ export interface IECS<T> {
   query: <C extends (keyof T)[]>(...componentName: C) => Generator<QueryResult<C>>;
 
   components: StoreDataMap<T>;
-}
+}
+
+declare function ECS<T extends Record<string, Record<string, any>>>(): IECS<T>;
+
+export { ECS };

package/dist/index.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Represents component data in Structure of Arrays (SoA) format.
+ * Each property of the component is stored in a separate array,
+ * enabling cache-efficient iteration and SIMD operations.
+ * Numeric properties are backed by a Float32Array for a compact, homogeneous
+ * memory layout; non-numeric properties fall back to a plain JS array.
+ * @template T - The component data type
+ * @example
+ * // For Position component: { x: number, y: number }
+ * // ComponentDataArrays would be: { x: Float32Array, y: Float32Array }
+ */
+type ComponentDataArrays<T> = {
+  [K in keyof T]: T[K] extends number ? Float32Array : T[K][];
+};
+
+/**
+ * Maps component names to their data arrays for direct access.
+ * Used to expose component data to the user without store methods.
+ * @template T - Record type defining all component types
+ */
+type StoreDataMap<T> = {
+  [K in keyof T]: ComponentDataArrays<T[K]>;
+};
+
+/**
+ * Type helper for the query result.
+ * Creates an object with an entry for each requested component, holding its store index.
+ * @template C - Array of the component names requested in the query.
+ */
+type QueryResult<C extends readonly PropertyKey[]> = {
+  [K in C[number]]: { id: number };
+};
+
+/**
+ * Interface for the main ECS registry.
+ * Provides high-level API for entity-component management,
+ * coordinating between EntityManager and ComponentStores.
+ * @template T - Record type defining all component types in the ECS
+ */
+interface IECS<T> {
+  /**
+   * Initializes the ECS with component definitions.
+   * Registers all components and creates their corresponding stores.
+   * Must be called before any other operations.
+   * @param names -component names
+   * @throws Error if a component name is already defined
+   */
+  defineComponents<K extends readonly (keyof T)[]>(...names: K): void;
+
+  /**
+   * Creates a new entity in the ECS.
+   * @returns The ID of the newly created entity
+   */
+  createEntity: () => number;
+
+  /**
+   * Completely removes an entity and all its components from the ECS.
+   * Cleans up all component data and entity records.
+   * @param eid - The entity ID to destroy
+   */
+  destroyEntity: (eid: number) => void;
+
+  /**
+   * Adds a component to an entity with the provided data.
+   * Updates both the entity's bitmask and the component store.
+   * @template K - The component name type (key of T)
+   * @param eid - The entity ID
+   * @param name - The component name
+   * @param data - The component data to store
+   */
+  addComponent: <K extends keyof T>(eid: number, name: K, data: T[K]) => void;
+
+  /**
+   * Removes a component from an entity.
+   * Updates both the entity's bitmask and the component store.
+   * @template K - The component name type (key of T)
+   * @param eid - The entity ID
+   * @param name - The component name
+   */
+  removeComponent: <K extends keyof T>(eid: number, name: K) => void;
+
+  /**
+   * Retrieves all entities that contain the specified set of components.
+   * Performs a filtered search across component stores and yields each matching entity.
+   * The returned generator allows efficient iteration without allocating large arrays.
+   *
+   * @template C - Array of component names to query for
+   * @param components - List of component names that the entity must include
+   * @returns A generator that yields an object for each matching entity,
+   *          containing the entity ID and the related component data
+   */
+  query: <C extends (keyof T)[]>(...componentName: C) => Generator<QueryResult<C>>;
+
+  components: StoreDataMap<T>;
+}
+
+declare function ECS<T extends Record<string, Record<string, any>>>(): IECS<T>;
+
+export { ECS };

package/dist/index.js

@@ -0,0 +1,238 @@
+// src/utils/SparseSet.ts
+function SparseSet() {
+  const sparse = [];
+  const dense = [];
+  let size = 0;
+  function has(eid) {
+    const ID = getIndex(eid);
+    const exist = ID !== void 0 && dense[ID] === eid;
+    const isWhitinBounds = ID >= 0 && ID < size;
+    return exist && isWhitinBounds;
+  }
+  function add(eid) {
+    if (has(eid)) throw new Error(`ID ${eid} already present in the set`);
+    sparse[eid] = size;
+    dense[size] = eid;
+    size++;
+  }
+  function remove(eid) {
+    if (!has(eid)) throw new Error(`Cannot remove ID ${eid} because does not exists`);
+    const ID = getIndex(eid);
+    const last = dense[size - 1];
+    dense[ID] = last;
+    sparse[last] = ID;
+    dense.pop();
+    size--;
+    delete sparse[eid];
+  }
+  function getIndex(eid) {
+    return sparse[eid];
+  }
+  function getDense() {
+    return dense;
+  }
+  function getSize() {
+    return size;
+  }
+  return { has, add, remove, getIndex, getDense, getSize };
+}
+
+// src/ComponentStore.ts
+var INITIAL_CAPACITY = 8;
+function grow(buffer, requiredIndex) {
+  let capacity = buffer.length;
+  while (capacity <= requiredIndex) capacity *= 2;
+  const grown = new Float32Array(capacity);
+  grown.set(buffer);
+  return grown;
+}
+function ComponentStore() {
+  const componentSet = SparseSet();
+  const componentData = {};
+  const isNumeric = {};
+  function add(eid, data) {
+    if (componentSet.has(eid)) throw new Error(`Entity ${eid} already has this component`);
+    const ID = componentSet.getSize();
+    componentSet.add(eid);
+    for (const key in data) {
+      const value = data[key];
+      if (!(key in componentData)) {
+        isNumeric[key] = typeof value === "number";
+        componentData[key] = isNumeric[key] ? new Float32Array(INITIAL_CAPACITY) : [];
+      }
+      if (isNumeric[key] && ID >= componentData[key].length) {
+        componentData[key] = grow(componentData[key], ID);
+      }
+      componentData[key][ID] = value;
+    }
+  }
+  function remove(eid) {
+    if (!componentSet.has(eid)) throw new Error(`Entity ${eid} does not have this component`);
+    const ID = componentSet.getIndex(eid);
+    const lastID = componentSet.getSize() - 1;
+    if (ID !== lastID) {
+      for (const key of Object.keys(componentData)) {
+        componentData[key][ID] = componentData[key][lastID];
+      }
+    }
+    componentSet.remove(eid);
+    for (const key in componentData) {
+      if (!isNumeric[key]) {
+        componentData[key].pop();
+      }
+    }
+  }
+  function getDense() {
+    return componentSet.getDense();
+  }
+  function getData() {
+    return componentData;
+  }
+  function getIndex(eid) {
+    return componentSet.getIndex(eid);
+  }
+  function getSize() {
+    return componentSet.getSize();
+  }
+  return { add, remove, getIndex, getDense, getData, getSize };
+}
+
+// src/EntityManager.ts
+function EntityManager(registry) {
+  let nextID = 0;
+  const recycledIDs = [];
+  const bitMasks = [];
+  function exists(eid) {
+    const isWithinBounds = eid >= 0 && eid < nextID;
+    const hasMask = bitMasks[eid] !== void 0;
+    return isWithinBounds && hasMask;
+  }
+  function hasComponent(eid, name) {
+    if (!exists(eid)) throw new Error(`Entity ${eid} does not exist`);
+    const cid = registry.getID(name);
+    return (bitMasks[eid] & 1n << BigInt(cid)) !== 0n;
+  }
+  function create() {
+    const ID = recycledIDs.length > 0 ? recycledIDs.pop() : nextID++;
+    bitMasks[ID] = 0n;
+    return ID;
+  }
+  function remove(eid) {
+    if (!exists(eid)) throw new Error(`Entity ${eid} does not exist`);
+    bitMasks[eid] = void 0;
+    recycledIDs.push(eid);
+  }
+  function addComponent(eid, name) {
+    if (!exists(eid)) throw new Error(`Entity ${eid} does not exists`);
+    if (hasComponent(eid, name)) throw new Error(`Entity ${eid} already has component ${name}`);
+    const cid = registry.getID(name);
+    bitMasks[eid] |= 1n << BigInt(cid);
+  }
+  function removeComponent(eid, name) {
+    if (!exists(eid)) throw new Error(`Entity ${eid} does not exists`);
+    if (!hasComponent(eid, name)) throw new Error(`Entity ${eid} does not have component ${name}`);
+    const cid = registry.getID(name);
+    bitMasks[eid] &= ~(1n << BigInt(cid));
+  }
+  function getMask(eid) {
+    if (!exists(eid)) throw new Error(`Entity ${eid} does not exist`);
+    return bitMasks[eid];
+  }
+  return { exists, hasComponent, create, remove, addComponent, removeComponent, getMask };
+}
+
+// src/utils/ComponentRegistry.ts
+function createComponentRegistry() {
+  const nameToID = /* @__PURE__ */ new Map();
+  const IDtoName = /* @__PURE__ */ new Map();
+  let nextID = 0;
+  function register(name) {
+    if (!nameToID.has(name)) {
+      const eid = nextID++;
+      nameToID.set(name, eid);
+      IDtoName.set(eid, name);
+    }
+  }
+  function getID(name) {
+    const eid = nameToID.get(name);
+    if (eid === void 0) throw new Error(`Component ${name} not registered`);
+    return eid;
+  }
+  function getName(cid) {
+    const name = IDtoName.get(cid);
+    if (!name) throw new Error(`Component ID ${cid} not registered`);
+    return name;
+  }
+  return { register, getID, getName };
+}
+
+// src/Ecs.ts
+function ECS() {
+  const ComponentRegistry = createComponentRegistry();
+  const Entities = EntityManager(ComponentRegistry);
+  const internalStores = {};
+  const components = {};
+  function defineComponents(...names) {
+    for (const name of names) {
+      if (name in internalStores) throw new Error(`Component ${String(name)} is already defined`);
+      ComponentRegistry.register(name);
+      internalStores[name] = ComponentStore();
+      components[name] = internalStores[name].getData();
+    }
+  }
+  function createEntity() {
+    return Entities.create();
+  }
+  function destroyEntity(eid) {
+    const entityMask = Entities.getMask(eid);
+    let cid = 0;
+    let tempMask = entityMask;
+    while (tempMask !== 0n) {
+      if ((tempMask & 1n) !== 0n) {
+        const name = ComponentRegistry.getName(cid);
+        internalStores[name].remove(eid);
+      }
+      tempMask >>= 1n;
+      cid++;
+    }
+    Entities.remove(eid);
+  }
+  function addComponent(eid, name, data) {
+    Entities.addComponent(eid, name);
+    internalStores[name].add(eid, data);
+  }
+  function removeComponent(eid, name) {
+    Entities.removeComponent(eid, name);
+    internalStores[name].remove(eid);
+  }
+  function* query(...componentName) {
+    if (componentName.length === 0) return;
+    let targetMask = 0n;
+    for (const name of componentName) {
+      targetMask |= 1n << BigInt(ComponentRegistry.getID(name));
+    }
+    let smallestStore = internalStores[componentName[0]];
+    let smallestSize = smallestStore.getSize();
+    for (let i = 1; i < componentName.length; i++) {
+      const store = internalStores[componentName[i]];
+      const size = store.getSize();
+      if (size < smallestSize) {
+        smallestStore = store;
+        smallestSize = size;
+      }
+    }
+    for (const eid of smallestStore.getDense()) {
+      if ((Entities.getMask(eid) & targetMask) !== targetMask) continue;
+      const result = {};
+      for (const name of componentName) {
+        const id = internalStores[name].getIndex(eid);
+        result[name] = { id };
+      }
+      yield result;
+    }
+  }
+  return { defineComponents, createEntity, destroyEntity, addComponent, removeComponent, query, components };
+}
+export {
+  ECS
+};

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@ste_tisci/ecs",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "A minimalistic game engine with zero dependencies based on the Entity Component System (ECS) architecture implemented in TypeScript",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "tsup"
+    "build": "tsup",
+    "prepublishOnly": "npm run build"
   },
   "keywords": [],
   "author": "",

package/.prettierrc

@@ -1,12 +0,0 @@
-{
-  "singleQuote": true,
-  "printWidth": 150,
-  "proseWrap": "always",
-  "tabWidth": 2,
-  "useTabs": false,
-  "trailingComma": "all",
-  "bracketSpacing": true,
-  "arrowParens": "avoid",
-  "singleAttributePerLine": false,
-  "semi": true
-}

package/src/ComponentStore.ts

@@ -1,96 +0,0 @@
-import type { IComponentStore } from './types/IComponentStore.js';
-import type { ComponentDataArrays } from './types/index.js';
-import { SparseSet } from './utils/SparseSet.js';
-
-const INITIAL_CAPACITY = 8;
-
-// Float32Array has a fixed length, so numeric fields grow by doubling capacity
-// (like a dynamic array reallocation) instead of relying on push/pop.
-function grow(buffer: Float32Array, requiredIndex: number): Float32Array {
-  let capacity = buffer.length;
-  while (capacity <= requiredIndex) capacity *= 2;
-
-  const grown = new Float32Array(capacity);
-  grown.set(buffer);
-  return grown;
-}
-
-// Internally every field is either a Float32Array (numeric) or a plain array (anything else).
-// The precise, per-field ComponentDataArrays<T> type is only applied at the public getData() boundary.
-type FieldStore = Float32Array | unknown[];
-
-export function ComponentStore<T extends Record<string, any>>(): IComponentStore<T> {
-  const componentSet = SparseSet();
-  const componentData: Record<string, FieldStore> = {};
-
-  // Tracks which fields are numeric (Float32Array-backed) vs plain arrays, keyed by field name
-  const isNumeric: Record<string, boolean> = {};
-
-  function add(eid: number, data: T): void {
-    if (componentSet.has(eid)) throw new Error(`Entity ${eid} already has this component`);
-
-    // Use the current size (next index) to maintain data coherence with the dense array
-    const ID = componentSet.getSize();
-
-    componentSet.add(eid);
-
-    // Store each property of the component into its corresponding array
-    for (const key in data) {
-      const value = data[key];
-
-      if (!(key in componentData)) {
-        isNumeric[key] = typeof value === 'number';
-        componentData[key] = isNumeric[key] ? new Float32Array(INITIAL_CAPACITY) : [];
-      }
-
-      if (isNumeric[key] && ID >= componentData[key].length) {
-        componentData[key] = grow(componentData[key] as Float32Array, ID);
-      }
-
-      (componentData[key] as unknown[])[ID] = value;
-    }
-  }
-
-  function remove(eid: number): void {
-    if (!componentSet.has(eid)) throw new Error(`Entity ${eid} does not have this component`);
-
-    const ID = componentSet.getIndex(eid);
-    const lastID = componentSet.getSize() - 1;
-
-    // Swap the component data only if is not the last one inserted
-    if (ID !== lastID) {
-      for (const key of Object.keys(componentData)) {
-        (componentData[key] as unknown[])[ID] = componentData[key][lastID];
-      }
-    }
-
-    componentSet.remove(eid);
-
-    // Plain arrays are trimmed to release references and stay in sync with the dense array.
-    // Float32Array slots beyond the current size are simply unused (unreachable via query/getIndex),
-    // so there's nothing to release and the capacity is kept as-is.
-    for (const key in componentData) {
-      if (!isNumeric[key]) {
-        (componentData[key] as unknown[]).pop();
-      }
-    }
-  }
-
-  function getDense(): number[] {
-    return componentSet.getDense();
-  }
-
-  function getData(): ComponentDataArrays<T> {
-    return componentData as ComponentDataArrays<T>;
-  }
-
-  function getIndex(eid: number): number {
-    return componentSet.getIndex(eid);
-  }
-
-  function getSize(): number {
-    return componentSet.getSize();
-  }
-
-  return { add, remove, getIndex, getDense, getData, getSize };
-}

package/src/Ecs.ts

@@ -1,98 +0,0 @@
-import type { QueryResult, StoreDataMap, StoreMap } from './types/index.js';
-import type { IECS } from './types/IEcs.js';
-import { ComponentStore } from './ComponentStore.js';
-import { EntityManager } from './EntityManager.js';
-import { createComponentRegistry } from './utils/ComponentRegistry.js';
-
-export function ECS<T extends Record<string, Record<string, any>>>(): IECS<T> {
-  const ComponentRegistry = createComponentRegistry<keyof T & string>();
-  const Entities = EntityManager(ComponentRegistry);
-  const internalStores = {} as StoreMap<T>;
-  const components = {} as StoreDataMap<T>;
-
-  // Initialize the structure of the components used
-  function defineComponents<K extends readonly (keyof T)[]>(...names: K): void {
-    for (const name of names) {
-      if (name in internalStores) throw new Error(`Component ${String(name)} is already defined`);
-
-      ComponentRegistry.register(name as string);
-      internalStores[name] = ComponentStore<T[typeof name]>();
-      components[name] = internalStores[name].getData();
-    }
-  }
-
-  function createEntity(): number {
-    return Entities.create();
-  }
-
-  function destroyEntity(eid: number): void {
-    const entityMask = Entities.getMask(eid);
-
-    let cid = 0;
-    let tempMask = entityMask;
-
-    // Bit operation on the entity mask to track the corresponding components and remove them
-    while (tempMask !== 0n) {
-      if ((tempMask & 1n) !== 0n) {
-        const name = ComponentRegistry.getName(cid);
-        internalStores[name].remove(eid);
-      }
-
-      tempMask >>= 1n;
-      cid++;
-    }
-
-    Entities.remove(eid);
-  }
-
-  function addComponent<K extends keyof T>(eid: number, name: K, data: T[K]): void {
-    Entities.addComponent(eid, name as keyof T & string);
-    internalStores[name].add(eid, data);
-  }
-
-  function removeComponent<K extends keyof T>(eid: number, name: K): void {
-    Entities.removeComponent(eid, name as keyof T & string);
-    internalStores[name].remove(eid);
-  }
-
-  // Generator function to retrive the indexes of the entity components searched
-  function* query<C extends (keyof T)[]>(...componentName: C): Generator<QueryResult<C>> {
-    if (componentName.length === 0) return;
-
-    // Validate that every requested component is registered before touching internalStores,
-    // so an unknown name throws a clear error instead of a raw "undefined" access below.
-    let targetMask = 0n;
-    for (const name of componentName) {
-      targetMask |= 1n << BigInt(ComponentRegistry.getID(name as keyof T & string));
-    }
-
-    let smallestStore = internalStores[componentName[0]];
-    let smallestSize = smallestStore.getSize();
-
-    for (let i = 1; i < componentName.length; i++) {
-      const store = internalStores[componentName[i]];
-      const size = store.getSize();
-
-      if (size < smallestSize) {
-        smallestStore = store;
-        smallestSize = size;
-      }
-    }
-
-    for (const eid of smallestStore.getDense()) {
-      if ((Entities.getMask(eid) & targetMask) !== targetMask) continue;
-
-      const result = {} as any;
-
-      for (const name of componentName) {
-        const id = internalStores[name].getIndex(eid);
-
-        result[name] = { id };
-      }
-
-      yield result as QueryResult<C>;
-    }
-  }
-
-  return { defineComponents, createEntity, destroyEntity, addComponent, removeComponent, query, components };
-}

package/src/EntityManager.ts

@@ -1,60 +0,0 @@
-import type { IComponentRegistry } from './types/IComponentRegistry.js';
-import type { IEntityManager } from './types/IEntityManager.js';
-
-export function EntityManager<K extends string>(registry: IComponentRegistry<K>): IEntityManager<K> {
-  let nextID: number = 0;
-  const recycledIDs: number[] = [];
-  const bitMasks: bigint[] = [];
-
-  function exists(eid: number): boolean {
-    const isWithinBounds = eid >= 0 && eid < nextID;
-    const hasMask = bitMasks[eid] !== undefined;
-
-    return isWithinBounds && hasMask;
-  }
-
-  function hasComponent(eid: number, name: K): boolean {
-    if (!exists(eid)) throw new Error(`Entity ${eid} does not exist`);
-
-    const cid = registry.getID(name);
-    return (bitMasks[eid] & (1n << BigInt(cid))) !== 0n;
-  }
-
-  function create(): number {
-    const ID = recycledIDs.length > 0 ? recycledIDs.pop()! : nextID++;
-    bitMasks[ID] = 0n;
-
-    return ID;
-  }
-
-  function remove(eid: number): void {
-    if (!exists(eid)) throw new Error(`Entity ${eid} does not exist`);
-
-    bitMasks[eid] = undefined as any;
-    recycledIDs.push(eid);
-  }
-
-  function addComponent(eid: number, name: K): void {
-    if (!exists(eid)) throw new Error(`Entity ${eid} does not exists`);
-    if (hasComponent(eid, name)) throw new Error(`Entity ${eid} already has component ${name}`);
-
-    const cid = registry.getID(name);
-    bitMasks[eid] |= 1n << BigInt(cid);
-  }
-
-  function removeComponent(eid: number, name: K): void {
-    if (!exists(eid)) throw new Error(`Entity ${eid} does not exists`);
-    if (!hasComponent(eid, name)) throw new Error(`Entity ${eid} does not have component ${name}`);
-
-    const cid = registry.getID(name);
-    bitMasks[eid] &= ~(1n << BigInt(cid));
-  }
-
-  function getMask(eid: number): bigint {
-    if (!exists(eid)) throw new Error(`Entity ${eid} does not exist`);
-
-    return bitMasks[eid];
-  }
-
-  return { exists, hasComponent, create, remove, addComponent, removeComponent, getMask };
-}

package/src/index.ts

@@ -1 +0,0 @@
-export { ECS } from './Ecs.js';

package/src/types/IComponentRegistry.d.ts

@@ -1,29 +0,0 @@
-/**
- * Interface for managing component registration and ID mapping.
- * Provides a centralized registry that maps component names to unique IDs
- * and vice versa, used for efficient bitmask operations in the ECS.
- */
-export interface IComponentRegistry<K extends string> {
-  /**
-   * Registers a new component by name.
-   * Assigns a unique incremental ID to the component if not already registered.
-   * @param name - The name of the component to register
-   */
-  register: (name: K) => void;
-
-  /**
-   * Retrieves the unique ID associated with a component name.
-   * @param name - The name of the component
-   * @returns The unique ID assigned to the component
-   * @throws Error if the component is not registered
-   */
-  getID: (name: K) => number;
-
-  /**
-   * Retrieves the component name associated with a given ID.
-   * @param cid - The unique ID of the component
-   * @returns The name of the component
-   * @throws Error if the ID is not registered
-   */
-  getName: (cid: number) => K;
-}

package/src/types/IComponentStore.d.ts

@@ -1,53 +0,0 @@
-import type { ComponentDataArrays } from './index.js';
-
-/**
- * Interface for storing and managing component data using Structure of Arrays (SoA) pattern.
- * Each component type has its own store that maintains entity-component associations
- * and stores component data in separate arrays per property for cache efficiency.
- * @template T - The component data type (object with properties)
- */
-export interface IComponentStore<T> {
-  /**
-   * Adds a component to an entity with the provided data.
-   * Stores each property of the component in separate arrays for efficient iteration.
-   * @param eid - The entity ID to add the component to
-   * @param data - The component data to store
-   * @throws Error if the entity already has this component
-   */
-  add: (eid: number, data: T) => void;
-
-  /**
-   * Removes a component from an entity.
-   * Uses swap-and-pop technique to maintain dense arrays.
-   * @param eid - The entity ID to remove the component from
-   * @throws Error if the entity doesn't have this component
-   */
-  remove: (eid: number) => void;
-
-  /**
-   * Gets the index of an entity's component data in the dense arrays.
-   * @param eid - The entity ID
-   * @returns The index in the data arrays where this entity's component data is stored
-   */
-  getIndex: (eid: number) => number;
-
-  /**
-   * Returns the dense array of entity IDs that have this component.
-   * Useful for efficient iteration over all entities with this component.
-   * @returns Array of entity IDs
-   */
-  getDense: () => number[];
-
-  /**
-   * Returns the component data arrays organized by property.
-   * Each property of the component type has its own array.
-   * @returns Object mapping property names to their value arrays
-   */
-  getData: () => ComponentDataArrays<T>;
-
-  /**
-   * Returns the number of entities that have this component.
-   * @returns The count of entities with this component
-   */
-  getSize: () => number;
-}

package/src/types/IEntityManager.d.ts

@@ -1,65 +0,0 @@
-/**
- * Interface for managing entities and their component associations.
- * Uses bitmasks to efficiently track which components each entity has,
- * enabling fast component checks and queries.
- */
-export interface IEntityManager<K extends string> {
-  /**
-   * Checks if an entity exists in the system.
-   * @param eid - The entity ID to check
-   * @returns True if the entity exists, false otherwise
-   */
-  exists: (eid: number) => boolean;
-
-  /**
-   * Checks if an entity has a specific component.
-   * Uses bitwise operations on the entity's bitmask for fast lookups.
-   * @param eid - The entity ID
-   * @param name - The component name
-   * @returns True if the entity has the component, false otherwise
-   */
-  hasComponent: (eid: number, name: K) => boolean;
-
-  /**
-   * Creates a new entity.
-   * Recycles entity IDs when possible, otherwise assigns a new incremental ID.
-   * @returns The ID of the newly created entity
-   */
-  create: () => number;
-
-  /**
-   * Removes an entity from the system.
-   * Marks the entity ID for recycling.
-   * @param eid - The entity ID to remove
-   * @throws Error if the entity doesn't exist
-   */
-  remove: (eid: number) => void;
-
-  /**
-   * Adds a component flag to an entity's bitmask.
-   * Updates the entity's bitmask to indicate it has the specified component.
-   * @param eid - The entity ID
-   * @param name - The component name
-   * @throws Error if the entity doesn't exist or already has the component
-   */
-  addComponent: (eid: number, name: K) => void;
-
-  /**
-   * Removes a component flag from an entity's bitmask.
-   * Updates the entity's bitmask to indicate it no longer has the specified component.
-   * @param eid - The entity ID
-   * @param name - The component name
-   * @throws Error if the entity doesn't exist
-   */
-  removeComponent: (eid: number, name: K) => void;
-
-  /**
-   * Retrieves the complete bitmask for an entity.
-   * The bitmask represents all components the entity has,
-   * with each bit corresponding to a component ID.
-   * @param eid - The entity ID
-   * @returns The entity's component bitmask
-   * @throws Error if the entity doesn't exist
-   */
-  getMask: (eid: number) => bigint;
-}

package/src/types/ISparseSet.d.ts

@@ -1,49 +0,0 @@
-/**
- * Interface used for fast entity lookups, insertion and removal.
- *
- * Maintain two parallel arrays:
- *
- * - sparse: a direct lookup table that maps an entity ID (eid) to its index in the dense array.
- * - dense: a compact array that stores all active entity IDs contiguously.
- */
-export interface ISparseSet {
-  /**
-   * Check if an entity ID exists in the set
-   * @param eid The entity ID to check
-   * @returns True if the entity ID exists, false otherwise
-   */
-  has: (eid: number) => boolean;
-
-  /**
-   * Add the entity ID to the set
-   * @param eid The entity ID to add
-   * @thows Error if the entity ID is already been added
-   */
-  add: (eid: number) => void;
-
-  /**
-   * Remove an Entity ID from the set
-   * @param eid The entity ID to remove
-   * @throws Error if the ID does not exists in the set
-   */
-  remove: (eid: number) => void;
-
-  /**
-   * Retrive the index of the entity ID in the set
-   * @param eid The entity ID
-   * @returns The index corresponding to an entity ID in the set
-   */
-  getIndex: (eid: number) => number;
-
-  /**
-   * Retrive the full dense array that contain all the entity IDs of the set
-   * @returns an Array with all the current entity IDs
-   */
-  getDense: () => number[];
-
-  /**
-   * Retrive the size representing the number of active entities in the set.
-   * @returns The current size of the Dense array
-   */
-  getSize: () => number;
-}

package/src/types/index.d.ts

@@ -1,43 +0,0 @@
-import type { IComponentStore } from './IComponentStore.js';
-
-/**
- * Represents component data in Structure of Arrays (SoA) format.
- * Each property of the component is stored in a separate array,
- * enabling cache-efficient iteration and SIMD operations.
- * Numeric properties are backed by a Float32Array for a compact, homogeneous
- * memory layout; non-numeric properties fall back to a plain JS array.
- * @template T - The component data type
- * @example
- * // For Position component: { x: number, y: number }
- * // ComponentDataArrays would be: { x: Float32Array, y: Float32Array }
- */
-export type ComponentDataArrays<T> = {
-  [K in keyof T]: T[K] extends number ? Float32Array : T[K][];
-};
-
-/**
- * Maps component names to their corresponding ComponentStore instances.
- * Used internally by CreateWorld to manage all component stores.
- * @template T - Record type defining all component types
- */
-export type StoreMap<T> = {
-  [K in keyof T]: IComponentStore<T[K]>;
-};
-
-/**
- * Maps component names to their data arrays for direct access.
- * Used to expose component data to the user without store methods.
- * @template T - Record type defining all component types
- */
-export type StoreDataMap<T> = {
-  [K in keyof T]: ComponentDataArrays<T[K]>;
-};
-
-/**
- * Type helper for the query result.
- * Creates an object with an entry for each requested component, holding its store index.
- * @template C - Array of the component names requested in the query.
- */
-export type QueryResult<C extends readonly PropertyKey[]> = {
-  [K in C[number]]: { id: number };
-};

package/src/utils/ComponentRegistry.ts

@@ -1,32 +0,0 @@
-import type { IComponentRegistry } from '../types/IComponentRegistry.js';
-
-export function createComponentRegistry<K extends string>(): IComponentRegistry<K> {
-  const nameToID = new Map<K, number>();
-  const IDtoName = new Map<number, K>();
-  let nextID: number = 0;
-
-  function register(name: K): void {
-    if (!nameToID.has(name)) {
-      const eid = nextID++;
-
-      nameToID.set(name, eid);
-      IDtoName.set(eid, name);
-    }
-  }
-
-  function getID(name: K): number {
-    const eid = nameToID.get(name);
-    if (eid === undefined) throw new Error(`Component ${name} not registered`);
-
-    return eid;
-  }
-
-  function getName(cid: number): K {
-    const name = IDtoName.get(cid);
-    if (!name) throw new Error(`Component ID ${cid} not registered`);
-
-    return name;
-  }
-
-  return { register, getID, getName };
-}

package/src/utils/SparseSet.ts

@@ -1,54 +0,0 @@
-import type { ISparseSet } from '../types/ISparseSet.js';
-
-export function SparseSet(): ISparseSet {
-  const sparse: number[] = [];
-  const dense: number[] = [];
-  let size = 0;
-
-  function has(eid: number): boolean {
-    const ID = getIndex(eid);
-
-    const exist = ID !== undefined && dense[ID] === eid;
-    const isWhitinBounds = ID >= 0 && ID < size;
-
-    return exist && isWhitinBounds;
-  }
-
-  function add(eid: number): void {
-    if (has(eid)) throw new Error(`ID ${eid} already present in the set`);
-
-    sparse[eid] = size;
-    dense[size] = eid;
-    size++;
-  }
-
-  function remove(eid: number): void {
-    if (!has(eid)) throw new Error(`Cannot remove ID ${eid} because does not exists`);
-
-    const ID = getIndex(eid);
-    const last = dense[size - 1];
-
-    // Swap with the last element inserted
-    dense[ID] = last;
-    sparse[last] = ID;
-
-    // Remove the element
-    dense.pop();
-    size--;
-    delete sparse[eid];
-  }
-
-  function getIndex(eid: number): number {
-    return sparse[eid];
-  }
-
-  function getDense(): number[] {
-    return dense;
-  }
-
-  function getSize(): number {
-    return size;
-  }
-
-  return { has, add, remove, getIndex, getDense, getSize };
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2024",
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "outDir": "dist",
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "strict": true,
-    "sourceMap": true,
-    "rootDir": "src",
-    "moduleResolution": "nodenext",
-    "module": "node20"
-  },
-  "exclude": ["node_modules/"],
-  "include": ["src"]
-}

package/tsup.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  format: ['cjs', 'esm'],
-  entry: ['./src/index.ts'],
-  dts: true,
-  shims: true,
-  skipNodeModulesBundle: true,
-  clean: true,
-});