@ue-too/ecs 0.9.5 → 0.10.0

package/README.md

@@ -1,8 +1,364 @@
-# ecs
-This is an experimental implementation of the Entity Component System architecture.
+# @ue-too/ecs
 
-Following the tutorial from [Austin Morlan](https://austinmorlan.com/posts/entity_component_system/).
+High-performance Entity Component System (ECS) architecture for TypeScript.
 
-Please _**DO NOT**_ use this in production.
+[![npm version](https://img.shields.io/npm/v/@ue-too/ecs.svg)](https://www.npmjs.com/package/@ue-too/ecs)
+[![license](https://img.shields.io/npm/l/@ue-too/ecs.svg)](https://github.com/ue-too/ue-too/blob/main/LICENSE.txt)
 
-Detailed information would be added in the future.
+> **Experimental**: This package is an experimental implementation based on [Austin Morlan's ECS tutorial](https://austinmorlan.com/posts/entity_component_system/). Please **DO NOT** use this in production.
+
+## Overview
+
+`@ue-too/ecs` provides a lightweight Entity Component System implementation for TypeScript. ECS is an architectural pattern commonly used in game development that promotes composition over inheritance and enables high-performance iteration over game objects.
+
+### Key Features
+
+- **Efficient Storage**: Component arrays using sparse-set data structure for O(1) lookups
+- **Fast Iteration**: Dense packing enables cache-friendly iteration over components
+- **Type Safety**: Full TypeScript generics for component type safety
+- **Signature Matching**: Automatic system updates when entity component composition changes
+- **Entity Pooling**: Entity ID recycling for memory efficiency
+- **Minimal Overhead**: Lightweight architecture with predictable performance
+
+## Installation
+
+Using Bun:
+```bash
+bun add @ue-too/ecs
+```
+
+Using npm:
+```bash
+npm install @ue-too/ecs
+```
+
+## Quick Start
+
+Here's a simple example demonstrating the core ECS workflow:
+
+```typescript
+import { Coordinator } from '@ue-too/ecs';
+
+// 1. Define component types
+type Position = { x: number; y: number };
+type Velocity = { x: number; y: number };
+type Health = { current: number; max: number };
+
+// 2. Create coordinator
+const ecs = new Coordinator();
+
+// 3. Register components
+ecs.registerComponent<Position>('Position');
+ecs.registerComponent<Velocity>('Velocity');
+ecs.registerComponent<Health>('Health');
+
+// 4. Create entities and add components
+const player = ecs.createEntity();
+ecs.addComponentToEntity('Position', player, { x: 0, y: 0 });
+ecs.addComponentToEntity('Velocity', player, { x: 5, y: 0 });
+ecs.addComponentToEntity('Health', player, { current: 100, max: 100 });
+
+const enemy = ecs.createEntity();
+ecs.addComponentToEntity('Position', enemy, { x: 50, y: 50 });
+ecs.addComponentToEntity('Health', enemy, { current: 50, max: 50 });
+
+// 5. Query and update components
+const playerPos = ecs.getComponentFromEntity<Position>('Position', player);
+const playerVel = ecs.getComponentFromEntity<Velocity>('Velocity', player);
+
+if (playerPos && playerVel) {
+  playerPos.x += playerVel.x;
+  playerPos.y += playerVel.y;
+}
+
+// 6. Clean up
+ecs.destroyEntity(enemy);
+```
+
+## ECS Architecture
+
+The Entity Component System pattern separates data from logic:
+
+- **Entities**: Unique identifiers (numbers) representing game objects
+- **Components**: Plain data containers (no logic)
+- **Systems**: Functions that operate on entities with specific component combinations
+
+### Why ECS?
+
+Traditional object-oriented hierarchies can become complex and rigid. ECS promotes:
+
+- **Composition over inheritance**: Build entities by combining components
+- **Data locality**: Components are stored in dense arrays for better cache performance
+- **Flexibility**: Easy to add/remove behaviors by adding/removing components
+- **Parallelization**: Systems can operate independently on entity subsets
+
+## Core APIs
+
+### Coordinator
+
+The main ECS coordinator that manages all subsystems.
+
+```typescript
+const ecs = new Coordinator();
+```
+
+**Entity Management:**
+- `createEntity(): Entity` - Creates a new entity, returns entity ID
+- `destroyEntity(entity: Entity): void` - Destroys entity and removes all components
+
+**Component Management:**
+- `registerComponent<T>(name: string): void` - Registers a component type
+- `addComponentToEntity<T>(name: string, entity: Entity, component: T): void` - Adds component to entity
+- `removeComponentFromEntity<T>(name: string, entity: Entity): void` - Removes component from entity
+- `getComponentFromEntity<T>(name: string, entity: Entity): T | null` - Retrieves component data
+- `getComponentType(name: string): ComponentType | null` - Gets component type ID
+
+**System Management:**
+- `registerSystem(name: string, system: System): void` - Registers a system
+- `setSystemSignature(name: string, signature: ComponentSignature): void` - Sets which components a system requires
+
+### System Interface
+
+Systems maintain a set of entities that match their component signature:
+
+```typescript
+interface System {
+  entities: Set<Entity>;
+}
+```
+
+### Component Signature
+
+Bit flags indicating which components an entity has:
+
+```typescript
+type ComponentSignature = number;  // Bit field
+type ComponentType = number;       // Component type ID (0-31)
+type Entity = number;              // Entity ID
+```
+
+## Common Use Cases
+
+### Movement System
+
+Update positions based on velocities:
+
+```typescript
+import { Coordinator, System } from '@ue-too/ecs';
+
+const ecs = new Coordinator();
+
+// Register components
+ecs.registerComponent<Position>('Position');
+ecs.registerComponent<Velocity>('Velocity');
+
+// Create movement system
+const movementSystem: System = {
+  entities: new Set()
+};
+
+ecs.registerSystem('Movement', movementSystem);
+
+// Set signature: entities with Position AND Velocity
+const posType = ecs.getComponentType('Position')!;
+const velType = ecs.getComponentType('Velocity')!;
+const signature = (1 << posType) | (1 << velType);
+ecs.setSystemSignature('Movement', signature);
+
+// Update loop
+function update(deltaTime: number) {
+  movementSystem.entities.forEach(entity => {
+    const pos = ecs.getComponentFromEntity<Position>('Position', entity)!;
+    const vel = ecs.getComponentFromEntity<Velocity>('Velocity', entity)!;
+
+    pos.x += vel.x * deltaTime;
+    pos.y += vel.y * deltaTime;
+  });
+}
+
+// Game loop
+setInterval(() => update(0.016), 16); // ~60 FPS
+```
+
+### Damage System
+
+Process health and damage components:
+
+```typescript
+type Health = { current: number; max: number };
+type Damage = { amount: number; source: Entity };
+
+ecs.registerComponent<Health>('Health');
+ecs.registerComponent<Damage>('Damage');
+
+const damageSystem: System = { entities: new Set() };
+ecs.registerSystem('Damage', damageSystem);
+
+const healthType = ecs.getComponentType('Health')!;
+const damageType = ecs.getComponentType('Damage')!;
+const damageSignature = (1 << healthType) | (1 << damageType);
+ecs.setSystemSignature('Damage', damageSignature);
+
+function processDamage() {
+  damageSystem.entities.forEach(entity => {
+    const health = ecs.getComponentFromEntity<Health>('Health', entity)!;
+    const damage = ecs.getComponentFromEntity<Damage>('Damage', entity)!;
+
+    health.current -= damage.amount;
+
+    if (health.current <= 0) {
+      console.log(`Entity ${entity} destroyed`);
+      ecs.destroyEntity(entity);
+    } else {
+      // Remove damage component after processing
+      ecs.removeComponentFromEntity<Damage>('Damage', entity);
+    }
+  });
+}
+```
+
+### Rendering System
+
+Render entities with position and sprite components:
+
+```typescript
+type Sprite = { imageSrc: string; width: number; height: number };
+
+ecs.registerComponent<Sprite>('Sprite');
+
+const renderSystem: System = { entities: new Set() };
+ecs.registerSystem('Render', renderSystem);
+
+const spriteType = ecs.getComponentType('Sprite')!;
+const renderSignature = (1 << posType) | (1 << spriteType);
+ecs.setSystemSignature('Render', renderSignature);
+
+function render(ctx: CanvasRenderingContext2D) {
+  ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+  renderSystem.entities.forEach(entity => {
+    const pos = ecs.getComponentFromEntity<Position>('Position', entity)!;
+    const sprite = ecs.getComponentFromEntity<Sprite>('Sprite', entity)!;
+
+    // Draw sprite at position
+    const img = new Image();
+    img.src = sprite.imageSrc;
+    ctx.drawImage(img, pos.x, pos.y, sprite.width, sprite.height);
+  });
+}
+```
+
+### Component Signature Building
+
+Build complex component requirements:
+
+```typescript
+// Entities that have Position, Velocity, AND Sprite
+const movingRenderables =
+  (1 << ecs.getComponentType('Position')!) |
+  (1 << ecs.getComponentType('Velocity')!) |
+  (1 << ecs.getComponentType('Sprite')!);
+
+// Helper function for cleaner syntax
+function buildSignature(ecs: Coordinator, ...componentNames: string[]): number {
+  return componentNames.reduce((signature, name) => {
+    const type = ecs.getComponentType(name);
+    return type !== null ? signature | (1 << type) : signature;
+  }, 0);
+}
+
+// Usage
+const signature = buildSignature(ecs, 'Position', 'Velocity', 'Health');
+ecs.setSystemSignature('MySystem', signature);
+```
+
+## Configuration
+
+The package provides configuration constants:
+
+```typescript
+export const MAX_ENTITIES = 10000;    // Maximum simultaneous entities
+export const MAX_COMPONENTS = 32;      // Maximum component types (bit limit)
+```
+
+To customize, you can create your own EntityManager:
+
+```typescript
+import { EntityManager } from '@ue-too/ecs';
+
+const entityManager = new EntityManager(5000); // Custom max entities
+```
+
+## API Reference
+
+For complete API documentation with detailed type information, see the [TypeDoc-generated documentation](../../docs/ecs).
+
+## TypeScript Support
+
+This package is written in TypeScript with complete type definitions:
+
+```typescript
+// Component types are fully typed
+type Position = { x: number; y: number };
+ecs.registerComponent<Position>('Position');
+
+// Type-safe component retrieval
+const pos = ecs.getComponentFromEntity<Position>('Position', entity);
+if (pos) {
+  pos.x += 10; // TypeScript knows pos has x and y properties
+}
+
+// Generic component arrays
+import { ComponentArray } from '@ue-too/ecs';
+const positions = new ComponentArray<Position>(1000);
+```
+
+## Design Principles
+
+This ECS implementation follows these principles:
+
+- **Simplicity**: Minimal API surface for easy learning
+- **Performance**: Sparse-set data structure for O(1) operations
+- **Type Safety**: Leverage TypeScript's type system
+- **Flexibility**: Components are plain data objects
+- **Explicit**: No magic, predictable behavior
+
+## Performance Considerations
+
+- **Entity Creation**: O(1) - pops from available entity pool
+- **Component Lookup**: O(1) - sparse-set provides constant-time access
+- **Component Iteration**: O(n) - dense array iteration for cache efficiency
+- **Signature Matching**: O(m) where m is number of systems (typically small)
+
+**Performance Tips:**
+- Keep component data small and focused
+- Process components in batches (system-by-system) rather than entity-by-entity
+- Reuse entities when possible instead of create/destroy cycles
+- Limit number of component types (max 32 due to bit signature)
+
+## Limitations
+
+- **Max 32 component types**: Component signatures use 32-bit integers
+- **No component queries**: Must register systems with signatures upfront
+- **No hierarchical entities**: Flat entity structure only
+- **No built-in serialization**: Component data must be manually serialized
+
+## Related Packages
+
+- **[@ue-too/being](../being)**: State machine library for entity AI and behavior
+- **[@ue-too/math](../math)**: Vector and transformation utilities for component data
+- **[@ue-too/board](../board)**: Canvas rendering system that can integrate with ECS
+
+## Further Reading
+
+- [Austin Morlan's ECS Tutorial](https://austinmorlan.com/posts/entity_component_system/) - Original tutorial this implementation is based on
+- [ECS FAQ](https://github.com/SanderMertens/ecs-faq) - Comprehensive ECS concepts and patterns
+- [Data-Oriented Design](https://www.dataorienteddesign.com/dodbook/) - Principles behind ECS architecture
+
+## License
+
+MIT
+
+## Repository
+
+[https://github.com/ue-too/ue-too](https://github.com/ue-too/ue-too)

package/index.d.ts

@@ -1,9 +1,134 @@
-/** This is a direct port of the tutorial from https://austinmorlan.com/posts/entity_component_system/  with slight modifications */
+/**
+ * @packageDocumentation
+ * Entity Component System (ECS) implementation for TypeScript.
+ *
+ * @remarks
+ * The `@ue-too/ecs` package provides a high-performance Entity Component System architecture
+ * based on the tutorial from https://austinmorlan.com/posts/entity_component_system/
+ *
+ * ## ECS Architecture
+ *
+ * - **Entities**: Unique identifiers (numbers) representing game objects
+ * - **Components**: Data containers attached to entities
+ * - **Systems**: Logic that operates on entities with specific component combinations
+ * - **Signatures**: Bit flags indicating which components an entity has
+ *
+ * ## Key Features
+ *
+ * - **Efficient Storage**: Component arrays using sparse-set data structure
+ * - **Fast Iteration**: Dense packing for cache-friendly iteration
+ * - **Type-Safe**: TypeScript generics for component type safety
+ * - **Signature Matching**: Automatic system updates when entity signatures change
+ * - **Pooling**: Entity ID recycling for memory efficiency
+ *
+ * ## Core Classes
+ *
+ * - {@link Coordinator}: Main ECS coordinator managing all subsystems
+ * - {@link EntityManager}: Creates and destroys entities
+ * - {@link ComponentManager}: Registers components and manages component data
+ * - {@link SystemManager}: Registers systems and maintains entity sets
+ * - {@link ComponentArray}: Efficient sparse-set storage for component data
+ *
+ * @example
+ * Basic ECS usage
+ * ```typescript
+ * import { Coordinator } from '@ue-too/ecs';
+ *
+ * // Define component types
+ * type Position = { x: number; y: number };
+ * type Velocity = { x: number; y: number };
+ *
+ * // Create coordinator
+ * const coordinator = new Coordinator();
+ *
+ * // Register components
+ * coordinator.registerComponent<Position>('Position');
+ * coordinator.registerComponent<Velocity>('Velocity');
+ *
+ * // Create entity with components
+ * const entity = coordinator.createEntity();
+ * coordinator.addComponentToEntity('Position', entity, { x: 0, y: 0 });
+ * coordinator.addComponentToEntity('Velocity', entity, { x: 1, y: 1 });
+ *
+ * // Query components
+ * const pos = coordinator.getComponentFromEntity<Position>('Position', entity);
+ * console.log('Position:', pos);
+ * ```
+ *
+ * @example
+ * System registration
+ * ```typescript
+ * import { Coordinator, System } from '@ue-too/ecs';
+ *
+ * const coordinator = new Coordinator();
+ * coordinator.registerComponent<Position>('Position');
+ * coordinator.registerComponent<Velocity>('Velocity');
+ *
+ * // Create a movement system
+ * const movementSystem: System = {
+ *   entities: new Set()
+ * };
+ *
+ * coordinator.registerSystem('Movement', movementSystem);
+ *
+ * // Set signature (entities with Position AND Velocity)
+ * const posType = coordinator.getComponentType('Position')!;
+ * const velType = coordinator.getComponentType('Velocity')!;
+ * const signature = (1 << posType) | (1 << velType);
+ * coordinator.setSystemSignature('Movement', signature);
+ *
+ * // Update loop
+ * function update(deltaTime: number) {
+ *   movementSystem.entities.forEach(entity => {
+ *     const pos = coordinator.getComponentFromEntity<Position>('Position', entity)!;
+ *     const vel = coordinator.getComponentFromEntity<Velocity>('Velocity', entity)!;
+ *     pos.x += vel.x * deltaTime;
+ *     pos.y += vel.y * deltaTime;
+ *   });
+ * }
+ * ```
+ *
+ * @see {@link Coordinator} for the main ECS API
+ */
+/**
+ * Maximum number of entities that can exist simultaneously.
+ * @category Configuration
+ */
 export declare const MAX_ENTITIES = 10000;
+/**
+ * Maximum number of component types that can be registered.
+ * @category Configuration
+ */
 export declare const MAX_COMPONENTS = 32;
+/**
+ * Component signature type (bit field indicating which components an entity has).
+ * @category Types
+ */
 export type ComponentSignature = number;
+/**
+ * Component type identifier.
+ * @category Types
+ */
 export type ComponentType = number;
+/**
+ * Entity identifier (unique number).
+ * @category Types
+ */
 export type Entity = number;
+/**
+ * Manages entity lifecycle and signatures.
+ *
+ * @remarks
+ * The EntityManager handles:
+ * - Creating new entities (recycling IDs from a pool)
+ * - Destroying entities (returning IDs to the pool)
+ * - Storing and updating component signatures for each entity
+ *
+ * Entities are represented as simple numbers (IDs) and the manager maintains
+ * a signature (bit field) for each entity indicating which components it has.
+ *
+ * @category Managers
+ */
 export declare class EntityManager {
     private _availableEntities;
     private _signatures;
@@ -15,9 +140,32 @@ export declare class EntityManager {
     setSignature(entity: Entity, signature: ComponentSignature): void;
     getSignature(entity: Entity): ComponentSignature | null;
 }
+/**
+ * Internal interface for component array lifecycle hooks.
+ * @internal
+ */
 export interface CArray {
     entityDestroyed(entity: Entity): void;
 }
+/**
+ * Efficient sparse-set data structure for storing component data.
+ *
+ * @remarks
+ * ComponentArray uses a sparse-set implementation for O(1) insertion, deletion,
+ * and lookup while maintaining dense packing for cache-efficient iteration.
+ *
+ * The sparse-set consists of:
+ * - **Dense array**: Packed component data for iteration
+ * - **Sparse array**: Maps entity ID to dense array index
+ * - **Reverse array**: Maps dense array index back to entity ID
+ *
+ * This structure allows fast component access by entity ID and fast iteration
+ * over all components without gaps.
+ *
+ * @typeParam T - The component data type
+ *
+ * @category Data Structures
+ */
 export declare class ComponentArray<T> implements CArray {
     private denseArray;
     private sparse;
@@ -29,6 +177,21 @@ export declare class ComponentArray<T> implements CArray {
     removeData(entity: Entity): void;
     entityDestroyed(entity: Entity): void;
 }
+/**
+ * Manages component registration and component data storage.
+ *
+ * @remarks
+ * The ComponentManager handles:
+ * - Registering new component types and assigning unique type IDs
+ * - Creating ComponentArray storage for each component type
+ * - Adding, removing, and querying component data for entities
+ * - Cleaning up component data when entities are destroyed
+ *
+ * Each component type gets a unique ID (0-31) and its own ComponentArray
+ * for efficient storage and retrieval.
+ *
+ * @category Managers
+ */
 export declare class ComponentManager {
     private _componentNameToTypeMap;
     private _nextAvailableComponentType;
@@ -40,9 +203,58 @@ export declare class ComponentManager {
     entityDestroyed(entity: Entity): void;
     private _getComponentArray;
 }
+/**
+ * System interface for processing entities with specific component combinations.
+ *
+ * @remarks
+ * A System maintains a set of entities that match its component signature.
+ * The ECS automatically updates this set when entities are created, destroyed,
+ * or have their components modified.
+ *
+ * Systems contain only the logic for processing entities - the `entities` set
+ * is automatically managed by the SystemManager.
+ *
+ * @example
+ * ```typescript
+ * const movementSystem: System = {
+ *   entities: new Set()
+ * };
+ *
+ * // System logic (called in game loop)
+ * function updateMovement(deltaTime: number) {
+ *   movementSystem.entities.forEach(entity => {
+ *     const pos = ecs.getComponentFromEntity<Position>('Position', entity);
+ *     const vel = ecs.getComponentFromEntity<Velocity>('Velocity', entity);
+ *     if (pos && vel) {
+ *       pos.x += vel.x * deltaTime;
+ *       pos.y += vel.y * deltaTime;
+ *     }
+ *   });
+ * }
+ * ```
+ *
+ * @category Types
+ */
 export interface System {
     entities: Set<Entity>;
 }
+/**
+ * Manages system registration and entity-system matching.
+ *
+ * @remarks
+ * The SystemManager handles:
+ * - Registering systems with their component signature requirements
+ * - Maintaining the set of entities that match each system's signature
+ * - Automatically adding/removing entities from systems when signatures change
+ * - Cleaning up system entity sets when entities are destroyed
+ *
+ * When an entity's component signature changes (components added/removed),
+ * the SystemManager checks all registered systems and updates their entity sets.
+ * An entity is added to a system's set if its signature contains all components
+ * required by the system's signature.
+ *
+ * @category Managers
+ */
 export declare class SystemManager {
     private _systems;
     registerSystem(systemName: string, system: System): void;
@@ -50,6 +262,48 @@ export declare class SystemManager {
     entityDestroyed(entity: Entity): void;
     entitySignatureChanged(entity: Entity, signature: ComponentSignature): void;
 }
+/**
+ * Main ECS coordinator that manages entities, components, and systems.
+ *
+ * @remarks
+ * The Coordinator is the central API for working with the ECS. It provides a unified
+ * interface for:
+ * - Creating and destroying entities
+ * - Registering and managing components
+ * - Registering and configuring systems
+ * - Querying component data
+ *
+ * The Coordinator automatically keeps entity signatures up-to-date and notifies
+ * systems when entities match their component requirements.
+ *
+ * @example
+ * Complete ECS workflow
+ * ```typescript
+ * const ecs = new Coordinator();
+ *
+ * // Setup
+ * ecs.registerComponent<Position>('Position');
+ * ecs.registerComponent<Velocity>('Velocity');
+ *
+ * // Create entity
+ * const entity = ecs.createEntity();
+ * ecs.addComponentToEntity('Position', entity, { x: 0, y: 0 });
+ * ecs.addComponentToEntity('Velocity', entity, { x: 1, y: 0 });
+ *
+ * // Update
+ * const pos = ecs.getComponentFromEntity<Position>('Position', entity);
+ * const vel = ecs.getComponentFromEntity<Velocity>('Velocity', entity);
+ * if (pos && vel) {
+ *   pos.x += vel.x;
+ *   pos.y += vel.y;
+ * }
+ *
+ * // Cleanup
+ * ecs.destroyEntity(entity);
+ * ```
+ *
+ * @category Core
+ */
 export declare class Coordinator {
     private _entityManager;
     private _componentManager;

package/index.js

@@ -1,267 +1,3 @@
-// src/index.ts
-var MAX_ENTITIES = 1e4;
-var MAX_COMPONENTS = 32;
+var O=1e4,W=32;class G{_availableEntities=[];_signatures=[];_maxEntities;_livingEntityCount=0;constructor(b=1e4){this._maxEntities=b;for(let j=0;j<this._maxEntities;j++)this._availableEntities.push(j),this._signatures.push(0)}createEntity(){if(this._livingEntityCount>=this._maxEntities)throw Error("Max entities reached");let b=this._availableEntities.shift();if(b===void 0)throw Error("No available entities");return this._signatures[b]=0,this._livingEntityCount++,b}destroyEntity(b){if(b>=this._maxEntities||b<0)throw Error("Invalid entity out of range");this._signatures[b]=0,this._availableEntities.push(b),this._livingEntityCount--}setSignature(b,j){if(b>=this._maxEntities||b<0)throw Error("Invalid entity out of range");this._signatures[b]=j}getSignature(b){if(b>=this._maxEntities||b<0)return null;return this._signatures[b]}}class H{denseArray;sparse;reverse;_count;constructor(b){this._count=0,this.denseArray=Array(b),this.sparse=Array(b),this.reverse=Array(b)}insertData(b,j){if(this.getData(b)!==null)this.removeData(b);if(this.sparse.length<b)this.sparse=[...this.sparse,...Array(b-this.sparse.length).fill(null)];this.denseArray[this._count]=j,this.reverse[this._count]=b,this.sparse[b]=this._count,this._count++}getData(b){if(this.sparse.length<=b)return null;let j=this.sparse[b];if(j===void 0||j===null||j>=this._count)return null;if(this.reverse[j]!==b)return null;return this.denseArray[j]}removeData(b){let j=this.sparse[b];if(j===void 0||j===null||j>=this._count)return;let z=this.reverse[this._count-1];if(z===null)return;this.denseArray[j]=this.denseArray[this._count-1],this.reverse[j]=z,this.sparse[z]=j,this.sparse[b]=null,this._count--}entityDestroyed(b){this.removeData(b)}}class J{_componentNameToTypeMap=new Map;_nextAvailableComponentType=0;registerComponent(b){if(this._componentNameToTypeMap.has(b))console.warn(`Component ${b} already registered; registering with the given new type`);let j=this._nextAvailableComponentType;this._componentNameToTypeMap.set(b,{componentType:j,componentArray:new H(1e4)}),this._nextAvailableComponentType++}getComponentType(b){return this._componentNameToTypeMap.get(b)?.componentType??null}addComponentToEntity(b,j,z){let B=this._getComponentArray(b);if(B===null)return;B.insertData(j,z)}removeComponentFromEntity(b,j){let z=this._getComponentArray(b);if(z===null)return;z.removeData(j)}getComponentFromEntity(b,j){let z=this._getComponentArray(b);if(z===null)return null;return z.getData(j)}entityDestroyed(b){for(let j of this._componentNameToTypeMap.values())j.componentArray.entityDestroyed(b)}_getComponentArray(b){let j=this._componentNameToTypeMap.get(b);if(j===void 0)return console.warn(`Component ${b} not registered`),null;return j.componentArray}}class K{_systems=new Map;registerSystem(b,j){if(this._systems.has(b)){console.warn(`System ${b} already registered`);return}this._systems.set(b,{system:j,signature:0})}setSignature(b,j){if(!this._systems.has(b)){console.warn(`System ${b} not registered`);return}let z=this._systems.get(b);if(z===void 0){console.warn(`System ${b} not registered`);return}z.signature=j}entityDestroyed(b){for(let j of this._systems.values())j.system.entities.delete(b)}entitySignatureChanged(b,j){for(let z of this._systems.values()){let B=z.signature;if((B&j)===B)z.system.entities.add(b);else z.system.entities.delete(b)}}}class L{_entityManager;_componentManager;_systemManager;constructor(){this._entityManager=new G,this._componentManager=new J,this._systemManager=new K}createEntity(){return this._entityManager.createEntity()}destroyEntity(b){this._entityManager.destroyEntity(b),this._componentManager.entityDestroyed(b),this._systemManager.entityDestroyed(b)}registerComponent(b){this._componentManager.registerComponent(b)}addComponentToEntity(b,j,z){this._componentManager.addComponentToEntity(b,j,z);let B=this._entityManager.getSignature(j);if(B===null)B=0;let D=this._componentManager.getComponentType(b);if(D===null){console.warn(`Component ${b} not registered`);return}B|=1<<D,this._entityManager.setSignature(j,B),this._systemManager.entitySignatureChanged(j,B)}removeComponentFromEntity(b,j){this._componentManager.removeComponentFromEntity(b,j);let z=this._entityManager.getSignature(j);if(z===null)z=0;let B=this._componentManager.getComponentType(b);if(B===null)return;z&=~(1<<B),this._entityManager.setSignature(j,z),this._systemManager.entitySignatureChanged(j,z)}getComponentFromEntity(b,j){return this._componentManager.getComponentFromEntity(b,j)}getComponentType(b){return this._componentManager.getComponentType(b)??null}registerSystem(b,j){this._systemManager.registerSystem(b,j)}setSystemSignature(b,j){this._systemManager.setSignature(b,j)}}export{K as SystemManager,O as MAX_ENTITIES,W as MAX_COMPONENTS,G as EntityManager,L as Coordinator,J as ComponentManager,H as ComponentArray};
 
-class EntityManager {
-  _availableEntities = [];
-  _signatures = [];
-  _maxEntities;
-  _livingEntityCount = 0;
-  constructor(maxEntities = MAX_ENTITIES) {
-    this._maxEntities = maxEntities;
-    for (let i = 0;i < this._maxEntities; i++) {
-      this._availableEntities.push(i);
-      this._signatures.push(0);
-    }
-  }
-  createEntity() {
-    if (this._livingEntityCount >= this._maxEntities) {
-      throw new Error("Max entities reached");
-    }
-    const entity = this._availableEntities.shift();
-    if (entity === undefined) {
-      throw new Error("No available entities");
-    }
-    this._signatures[entity] = 0;
-    this._livingEntityCount++;
-    return entity;
-  }
-  destroyEntity(entity) {
-    if (entity >= this._maxEntities || entity < 0) {
-      throw new Error("Invalid entity out of range");
-    }
-    this._signatures[entity] = 0;
-    this._availableEntities.push(entity);
-    this._livingEntityCount--;
-  }
-  setSignature(entity, signature) {
-    if (entity >= this._maxEntities || entity < 0) {
-      throw new Error("Invalid entity out of range");
-    }
-    this._signatures[entity] = signature;
-  }
-  getSignature(entity) {
-    if (entity >= this._maxEntities || entity < 0) {
-      return null;
-    }
-    return this._signatures[entity];
-  }
-}
-
-class ComponentArray {
-  denseArray;
-  sparse;
-  reverse;
-  _count;
-  constructor(maxEntities) {
-    this._count = 0;
-    this.denseArray = new Array(maxEntities);
-    this.sparse = new Array(maxEntities);
-    this.reverse = new Array(maxEntities);
-  }
-  insertData(entity, data) {
-    if (this.getData(entity) !== null) {
-      this.removeData(entity);
-    }
-    if (this.sparse.length < entity) {
-      this.sparse = [...this.sparse, ...new Array(entity - this.sparse.length).fill(null)];
-    }
-    this.denseArray[this._count] = data;
-    this.reverse[this._count] = entity;
-    this.sparse[entity] = this._count;
-    this._count++;
-  }
-  getData(entity) {
-    if (this.sparse.length <= entity) {
-      return null;
-    }
-    const denseIndex = this.sparse[entity];
-    if (denseIndex === undefined || denseIndex === null || denseIndex >= this._count) {
-      return null;
-    }
-    if (this.reverse[denseIndex] !== entity) {
-      return null;
-    }
-    return this.denseArray[denseIndex];
-  }
-  removeData(entity) {
-    const denseIndex = this.sparse[entity];
-    if (denseIndex === undefined || denseIndex === null || denseIndex >= this._count) {
-      return;
-    }
-    const lastEntity = this.reverse[this._count - 1];
-    if (lastEntity === null) {
-      return;
-    }
-    this.denseArray[denseIndex] = this.denseArray[this._count - 1];
-    this.reverse[denseIndex] = lastEntity;
-    this.sparse[lastEntity] = denseIndex;
-    this.sparse[entity] = null;
-    this._count--;
-  }
-  entityDestroyed(entity) {
-    this.removeData(entity);
-  }
-}
-
-class ComponentManager {
-  _componentNameToTypeMap = new Map;
-  _nextAvailableComponentType = 0;
-  registerComponent(componentName) {
-    if (this._componentNameToTypeMap.has(componentName)) {
-      console.warn(`Component ${componentName} already registered; registering with the given new type`);
-    }
-    const componentType = this._nextAvailableComponentType;
-    this._componentNameToTypeMap.set(componentName, { componentType, componentArray: new ComponentArray(MAX_ENTITIES) });
-    this._nextAvailableComponentType++;
-  }
-  getComponentType(componentName) {
-    return this._componentNameToTypeMap.get(componentName)?.componentType ?? null;
-  }
-  addComponentToEntity(componentName, entity, component) {
-    const componentArray = this._getComponentArray(componentName);
-    if (componentArray === null) {
-      return;
-    }
-    componentArray.insertData(entity, component);
-  }
-  removeComponentFromEntity(componentName, entity) {
-    const componentArray = this._getComponentArray(componentName);
-    if (componentArray === null) {
-      return;
-    }
-    componentArray.removeData(entity);
-  }
-  getComponentFromEntity(componentName, entity) {
-    const componentArray = this._getComponentArray(componentName);
-    if (componentArray === null) {
-      return null;
-    }
-    return componentArray.getData(entity);
-  }
-  entityDestroyed(entity) {
-    for (const component of this._componentNameToTypeMap.values()) {
-      component.componentArray.entityDestroyed(entity);
-    }
-  }
-  _getComponentArray(componentName) {
-    const component = this._componentNameToTypeMap.get(componentName);
-    if (component === undefined) {
-      console.warn(`Component ${componentName} not registered`);
-      return null;
-    }
-    return component.componentArray;
-  }
-}
-
-class SystemManager {
-  _systems = new Map;
-  registerSystem(systemName, system) {
-    if (this._systems.has(systemName)) {
-      console.warn(`System ${systemName} already registered`);
-      return;
-    }
-    this._systems.set(systemName, { system, signature: 0 });
-  }
-  setSignature(systemName, signature) {
-    if (!this._systems.has(systemName)) {
-      console.warn(`System ${systemName} not registered`);
-      return;
-    }
-    const system = this._systems.get(systemName);
-    if (system === undefined) {
-      console.warn(`System ${systemName} not registered`);
-      return;
-    }
-    system.signature = signature;
-  }
-  entityDestroyed(entity) {
-    for (const system of this._systems.values()) {
-      system.system.entities.delete(entity);
-    }
-  }
-  entitySignatureChanged(entity, signature) {
-    for (const system of this._systems.values()) {
-      const systemSignature = system.signature;
-      if ((systemSignature & signature) === systemSignature) {
-        system.system.entities.add(entity);
-      } else {
-        system.system.entities.delete(entity);
-      }
-    }
-  }
-}
-
-class Coordinator {
-  _entityManager;
-  _componentManager;
-  _systemManager;
-  constructor() {
-    this._entityManager = new EntityManager;
-    this._componentManager = new ComponentManager;
-    this._systemManager = new SystemManager;
-  }
-  createEntity() {
-    return this._entityManager.createEntity();
-  }
-  destroyEntity(entity) {
-    this._entityManager.destroyEntity(entity);
-    this._componentManager.entityDestroyed(entity);
-    this._systemManager.entityDestroyed(entity);
-  }
-  registerComponent(componentName) {
-    this._componentManager.registerComponent(componentName);
-  }
-  addComponentToEntity(componentName, entity, component) {
-    this._componentManager.addComponentToEntity(componentName, entity, component);
-    let signature = this._entityManager.getSignature(entity);
-    if (signature === null) {
-      signature = 0;
-    }
-    const componentType = this._componentManager.getComponentType(componentName);
-    if (componentType === null) {
-      console.warn(`Component ${componentName} not registered`);
-      return;
-    }
-    signature |= 1 << componentType;
-    this._entityManager.setSignature(entity, signature);
-    this._systemManager.entitySignatureChanged(entity, signature);
-  }
-  removeComponentFromEntity(componentName, entity) {
-    this._componentManager.removeComponentFromEntity(componentName, entity);
-    let signature = this._entityManager.getSignature(entity);
-    if (signature === null) {
-      signature = 0;
-    }
-    const componentType = this._componentManager.getComponentType(componentName);
-    if (componentType === null) {
-      return;
-    }
-    signature &= ~(1 << componentType);
-    this._entityManager.setSignature(entity, signature);
-    this._systemManager.entitySignatureChanged(entity, signature);
-  }
-  getComponentFromEntity(componentName, entity) {
-    return this._componentManager.getComponentFromEntity(componentName, entity);
-  }
-  getComponentType(componentName) {
-    return this._componentManager.getComponentType(componentName) ?? null;
-  }
-  registerSystem(systemName, system) {
-    this._systemManager.registerSystem(systemName, system);
-  }
-  setSystemSignature(systemName, signature) {
-    this._systemManager.setSignature(systemName, signature);
-  }
-}
-export {
-  SystemManager,
-  MAX_ENTITIES,
-  MAX_COMPONENTS,
-  EntityManager,
-  Coordinator,
-  ComponentManager,
-  ComponentArray
-};
-
-//# debugId=840788BF2D72B20064756E2164756E21
+//# debugId=983008DE2E282BA464756E2164756E21

package/index.js.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../src/index.ts"],
   "sourcesContent": [
-    "/** This is a direct port of the tutorial from https://austinmorlan.com/posts/entity_component_system/  with slight modifications */\n\nexport const MAX_ENTITIES = 10000;\nexport const MAX_COMPONENTS = 32;\n\nexport type ComponentSignature = number;\nexport type ComponentType = number;\n\nexport type Entity = number;\n\n\nexport class EntityManager {\n\n    private _availableEntities: Entity[] = [];\n    private _signatures: ComponentSignature[] = [];\n    private _maxEntities: number;\n\n    private _livingEntityCount = 0;\n\n    constructor(maxEntities: number = MAX_ENTITIES) {\n        this._maxEntities = maxEntities;\n        for (let i = 0; i < this._maxEntities; i++) {\n            this._availableEntities.push(i);\n            this._signatures.push(0);\n        }\n    }\n\n    createEntity(): Entity {\n        if(this._livingEntityCount >= this._maxEntities) {\n            throw new Error('Max entities reached');\n        }\n        const entity = this._availableEntities.shift();\n        if(entity === undefined) {\n            throw new Error('No available entities');\n        }\n        this._signatures[entity] = 0;\n        this._livingEntityCount++;\n        return entity;\n    }\n\n    destroyEntity(entity: Entity): void {\n        if(entity >= this._maxEntities || entity < 0) {\n            throw new Error('Invalid entity out of range');\n        }\n        this._signatures[entity] = 0;\n        this._availableEntities.push(entity);\n        this._livingEntityCount--;\n    }\n\n    setSignature(entity: Entity, signature: ComponentSignature): void {\n        if(entity >= this._maxEntities || entity < 0) {\n            throw new Error('Invalid entity out of range');\n        }\n        this._signatures[entity] = signature;\n    }\n\n    getSignature(entity: Entity): ComponentSignature | null {\n        if(entity >= this._maxEntities || entity < 0) {\n            return null;\n        }\n        return this._signatures[entity];\n    }\n}\n\ntype Tuple<T, N extends number> = N extends N\n  ? number extends N\n    ? T[]\n    : _TupleOf<T, N, []>\n  : never;\n\ntype _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N\n  ? R\n  : _TupleOf<T, N, [...R, T]>;\n\n// Usage\n\nexport interface CArray {\n    entityDestroyed(entity: Entity): void;\n}\n\nexport class ComponentArray<T> implements CArray {\n\n    private denseArray: T[]; // packed array of data\n    private sparse: (Entity | null)[]; // maps entity to index in dense array\n    private reverse: (Entity | null)[]; // maps index in dense array to entity\n    private _count: number;\n\n    constructor(maxEntities: number) {\n        this._count = 0;\n        this.denseArray = new Array(maxEntities);\n        this.sparse = new Array(maxEntities);\n        this.reverse = new Array(maxEntities);\n    }\n\n    insertData(entity: Entity, data: T): void {\n        if(this.getData(entity) !== null) {\n            this.removeData(entity);\n        }\n        if(this.sparse.length < entity){\n            // resize the array for the new entity but normally this should not happen\n            this.sparse = [...this.sparse, ...new Array(entity - this.sparse.length).fill(null)];\n        }\n\n        this.denseArray[this._count] = data;\n        this.reverse[this._count] = entity;\n        this.sparse[entity] = this._count;\n        this._count++;\n    }\n\n    getData(entity: Entity): T | null {\n        if(this.sparse.length <= entity){\n            return null;\n        }\n\n        const denseIndex = this.sparse[entity];\n        if(denseIndex === undefined || denseIndex === null || denseIndex >= this._count){\n            return null;\n        }\n\n        if(this.reverse[denseIndex] !== entity) {\n            return null;\n        }\n\n        return this.denseArray[denseIndex];\n    }\n\n    removeData(entity: Entity): void {\n        const denseIndex = this.sparse[entity];\n        if(denseIndex === undefined || denseIndex === null || denseIndex >= this._count){\n            return;\n        }\n\n        const lastEntity = this.reverse[this._count - 1];\n\n        if(lastEntity === null) {\n            return;\n        }\n\n        this.denseArray[denseIndex] = this.denseArray[this._count - 1];\n        this.reverse[denseIndex] = lastEntity;\n        this.sparse[lastEntity] = denseIndex;\n        this.sparse[entity] = null;\n\n        this._count--;\n    }\n\n    entityDestroyed(entity: Entity): void {\n        this.removeData(entity);\n    }\n}\n\nexport class ComponentManager {\n\n    private _componentNameToTypeMap: Map<string, {componentType: ComponentType, componentArray: CArray}> = new Map();\n    private _nextAvailableComponentType: ComponentType = 0;\n    \n    registerComponent<T>(componentName: string){\n        if(this._componentNameToTypeMap.has(componentName)) {\n            console.warn(`Component ${componentName} already registered; registering with the given new type`);\n        }\n        const componentType = this._nextAvailableComponentType;\n        this._componentNameToTypeMap.set(componentName, {componentType, componentArray: new ComponentArray<T>(MAX_ENTITIES)});\n        this._nextAvailableComponentType++;\n    }\n\n    getComponentType(componentName: string): ComponentType | null {\n        return this._componentNameToTypeMap.get(componentName)?.componentType ?? null;\n    }\n\n    addComponentToEntity<T>(componentName: string, entity: Entity, component: T){\n        const componentArray = this._getComponentArray<T>(componentName);\n        if(componentArray === null) {\n            return;\n        }\n        componentArray.insertData(entity, component);\n    }\n\n    removeComponentFromEntity<T>(componentName: string, entity: Entity){\n        const componentArray = this._getComponentArray<T>(componentName);\n        if(componentArray === null) {\n            return;\n        }\n        componentArray.removeData(entity);\n    }\n\n    getComponentFromEntity<T>(componentName: string, entity: Entity): T | null {\n        const componentArray = this._getComponentArray<T>(componentName);\n        if(componentArray === null) {\n            return null;\n        }\n        return componentArray.getData(entity);\n    }\n\n    entityDestroyed(entity: Entity){\n        for(const component of this._componentNameToTypeMap.values()){\n            component.componentArray.entityDestroyed(entity);\n        }\n    }\n\n    private _getComponentArray<T>(componentName: string): ComponentArray<T> | null {\n        const component = this._componentNameToTypeMap.get(componentName);\n        if(component === undefined) {\n            console.warn(`Component ${componentName} not registered`);\n            return null;\n        }\n        return component.componentArray as ComponentArray<T>;\n    }\n\n}\n\nexport interface System {\n    entities: Set<Entity>;\n}\n\nexport class SystemManager {\n    private _systems: Map<string, {system: System, signature: ComponentSignature}> = new Map();\n\n    registerSystem(systemName: string, system: System){\n        if(this._systems.has(systemName)) {\n            console.warn(`System ${systemName} already registered`);\n            return;\n        }\n        this._systems.set(systemName, {system, signature: 0});\n    }\n\n    setSignature(systemName: string, signature: ComponentSignature){\n        if(!this._systems.has(systemName)) {\n            console.warn(`System ${systemName} not registered`);\n            return;\n        }\n        const system = this._systems.get(systemName);\n        if(system === undefined) {\n            console.warn(`System ${systemName} not registered`);\n            return;\n        }\n        system.signature = signature;\n    }\n\n    entityDestroyed(entity: Entity){\n        for(const system of this._systems.values()){\n            system.system.entities.delete(entity);\n        }\n    }\n\n    entitySignatureChanged(entity: Entity, signature: ComponentSignature){\n        for(const system of this._systems.values()){\n            const systemSignature = system.signature;\n            if((systemSignature & signature) === systemSignature){\n                system.system.entities.add(entity);\n            } else {\n                system.system.entities.delete(entity);\n            }\n        }\n    }\n}\n\nexport class Coordinator {\n    private _entityManager: EntityManager;\n    private _componentManager: ComponentManager;\n    private _systemManager: SystemManager;\n\n    constructor(){\n        this._entityManager = new EntityManager();\n        this._componentManager = new ComponentManager();\n        this._systemManager = new SystemManager();\n    }\n\n    createEntity(): Entity {\n        return this._entityManager.createEntity();\n    }\n\n    destroyEntity(entity: Entity): void {\n        this._entityManager.destroyEntity(entity);\n        this._componentManager.entityDestroyed(entity);\n        this._systemManager.entityDestroyed(entity);\n    }\n\n    registerComponent<T>(componentName: string): void {\n        this._componentManager.registerComponent<T>(componentName);\n    }\n\n    addComponentToEntity<T>(componentName: string, entity: Entity, component: T): void {\n        this._componentManager.addComponentToEntity<T>(componentName, entity, component);\n        let signature = this._entityManager.getSignature(entity);\n        if(signature === null) {\n            signature = 0;\n        }\n        const componentType = this._componentManager.getComponentType(componentName);\n        if(componentType === null) {\n            console.warn(`Component ${componentName} not registered`);\n            return;\n        }\n        signature |= 1 << componentType;\n        this._entityManager.setSignature(entity, signature);\n        this._systemManager.entitySignatureChanged(entity, signature);\n    }\n\n    removeComponentFromEntity<T>(componentName: string, entity: Entity): void {\n        this._componentManager.removeComponentFromEntity<T>(componentName, entity);\n        let signature = this._entityManager.getSignature(entity);\n        if(signature === null) {\n            signature = 0;\n        }\n        const componentType = this._componentManager.getComponentType(componentName);\n        if(componentType === null) {\n            return;\n        }\n        signature &= ~(1 << componentType);\n        this._entityManager.setSignature(entity, signature);\n        this._systemManager.entitySignatureChanged(entity, signature);\n    }\n\n    getComponentFromEntity<T>(componentName: string, entity: Entity): T | null {\n        return this._componentManager.getComponentFromEntity<T>(componentName, entity);\n    }\n\n    getComponentType(componentName: string): ComponentType | null {\n        return this._componentManager.getComponentType(componentName) ?? null;\n    }\n\n    registerSystem(systemName: string, system: System): void {\n        this._systemManager.registerSystem(systemName, system);\n    }\n\n    setSystemSignature(systemName: string, signature: ComponentSignature): void {\n        this._systemManager.setSignature(systemName, signature);\n    }\n}\n"
+    "/**\n * @packageDocumentation\n * Entity Component System (ECS) implementation for TypeScript.\n *\n * @remarks\n * The `@ue-too/ecs` package provides a high-performance Entity Component System architecture\n * based on the tutorial from https://austinmorlan.com/posts/entity_component_system/\n *\n * ## ECS Architecture\n *\n * - **Entities**: Unique identifiers (numbers) representing game objects\n * - **Components**: Data containers attached to entities\n * - **Systems**: Logic that operates on entities with specific component combinations\n * - **Signatures**: Bit flags indicating which components an entity has\n *\n * ## Key Features\n *\n * - **Efficient Storage**: Component arrays using sparse-set data structure\n * - **Fast Iteration**: Dense packing for cache-friendly iteration\n * - **Type-Safe**: TypeScript generics for component type safety\n * - **Signature Matching**: Automatic system updates when entity signatures change\n * - **Pooling**: Entity ID recycling for memory efficiency\n *\n * ## Core Classes\n *\n * - {@link Coordinator}: Main ECS coordinator managing all subsystems\n * - {@link EntityManager}: Creates and destroys entities\n * - {@link ComponentManager}: Registers components and manages component data\n * - {@link SystemManager}: Registers systems and maintains entity sets\n * - {@link ComponentArray}: Efficient sparse-set storage for component data\n *\n * @example\n * Basic ECS usage\n * ```typescript\n * import { Coordinator } from '@ue-too/ecs';\n *\n * // Define component types\n * type Position = { x: number; y: number };\n * type Velocity = { x: number; y: number };\n *\n * // Create coordinator\n * const coordinator = new Coordinator();\n *\n * // Register components\n * coordinator.registerComponent<Position>('Position');\n * coordinator.registerComponent<Velocity>('Velocity');\n *\n * // Create entity with components\n * const entity = coordinator.createEntity();\n * coordinator.addComponentToEntity('Position', entity, { x: 0, y: 0 });\n * coordinator.addComponentToEntity('Velocity', entity, { x: 1, y: 1 });\n *\n * // Query components\n * const pos = coordinator.getComponentFromEntity<Position>('Position', entity);\n * console.log('Position:', pos);\n * ```\n *\n * @example\n * System registration\n * ```typescript\n * import { Coordinator, System } from '@ue-too/ecs';\n *\n * const coordinator = new Coordinator();\n * coordinator.registerComponent<Position>('Position');\n * coordinator.registerComponent<Velocity>('Velocity');\n *\n * // Create a movement system\n * const movementSystem: System = {\n *   entities: new Set()\n * };\n *\n * coordinator.registerSystem('Movement', movementSystem);\n *\n * // Set signature (entities with Position AND Velocity)\n * const posType = coordinator.getComponentType('Position')!;\n * const velType = coordinator.getComponentType('Velocity')!;\n * const signature = (1 << posType) | (1 << velType);\n * coordinator.setSystemSignature('Movement', signature);\n *\n * // Update loop\n * function update(deltaTime: number) {\n *   movementSystem.entities.forEach(entity => {\n *     const pos = coordinator.getComponentFromEntity<Position>('Position', entity)!;\n *     const vel = coordinator.getComponentFromEntity<Velocity>('Velocity', entity)!;\n *     pos.x += vel.x * deltaTime;\n *     pos.y += vel.y * deltaTime;\n *   });\n * }\n * ```\n *\n * @see {@link Coordinator} for the main ECS API\n */\n\n/**\n * Maximum number of entities that can exist simultaneously.\n * @category Configuration\n */\nexport const MAX_ENTITIES = 10000;\n\n/**\n * Maximum number of component types that can be registered.\n * @category Configuration\n */\nexport const MAX_COMPONENTS = 32;\n\n/**\n * Component signature type (bit field indicating which components an entity has).\n * @category Types\n */\nexport type ComponentSignature = number;\n\n/**\n * Component type identifier.\n * @category Types\n */\nexport type ComponentType = number;\n\n/**\n * Entity identifier (unique number).\n * @category Types\n */\nexport type Entity = number;\n\n/**\n * Manages entity lifecycle and signatures.\n *\n * @remarks\n * The EntityManager handles:\n * - Creating new entities (recycling IDs from a pool)\n * - Destroying entities (returning IDs to the pool)\n * - Storing and updating component signatures for each entity\n *\n * Entities are represented as simple numbers (IDs) and the manager maintains\n * a signature (bit field) for each entity indicating which components it has.\n *\n * @category Managers\n */\nexport class EntityManager {\n\n    private _availableEntities: Entity[] = [];\n    private _signatures: ComponentSignature[] = [];\n    private _maxEntities: number;\n\n    private _livingEntityCount = 0;\n\n    constructor(maxEntities: number = MAX_ENTITIES) {\n        this._maxEntities = maxEntities;\n        for (let i = 0; i < this._maxEntities; i++) {\n            this._availableEntities.push(i);\n            this._signatures.push(0);\n        }\n    }\n\n    createEntity(): Entity {\n        if(this._livingEntityCount >= this._maxEntities) {\n            throw new Error('Max entities reached');\n        }\n        const entity = this._availableEntities.shift();\n        if(entity === undefined) {\n            throw new Error('No available entities');\n        }\n        this._signatures[entity] = 0;\n        this._livingEntityCount++;\n        return entity;\n    }\n\n    destroyEntity(entity: Entity): void {\n        if(entity >= this._maxEntities || entity < 0) {\n            throw new Error('Invalid entity out of range');\n        }\n        this._signatures[entity] = 0;\n        this._availableEntities.push(entity);\n        this._livingEntityCount--;\n    }\n\n    setSignature(entity: Entity, signature: ComponentSignature): void {\n        if(entity >= this._maxEntities || entity < 0) {\n            throw new Error('Invalid entity out of range');\n        }\n        this._signatures[entity] = signature;\n    }\n\n    getSignature(entity: Entity): ComponentSignature | null {\n        if(entity >= this._maxEntities || entity < 0) {\n            return null;\n        }\n        return this._signatures[entity];\n    }\n}\n\ntype Tuple<T, N extends number> = N extends N\n  ? number extends N\n    ? T[]\n    : _TupleOf<T, N, []>\n  : never;\n\ntype _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N\n  ? R\n  : _TupleOf<T, N, [...R, T]>;\n\n// Usage\n\n/**\n * Internal interface for component array lifecycle hooks.\n * @internal\n */\nexport interface CArray {\n    entityDestroyed(entity: Entity): void;\n}\n\n/**\n * Efficient sparse-set data structure for storing component data.\n *\n * @remarks\n * ComponentArray uses a sparse-set implementation for O(1) insertion, deletion,\n * and lookup while maintaining dense packing for cache-efficient iteration.\n *\n * The sparse-set consists of:\n * - **Dense array**: Packed component data for iteration\n * - **Sparse array**: Maps entity ID to dense array index\n * - **Reverse array**: Maps dense array index back to entity ID\n *\n * This structure allows fast component access by entity ID and fast iteration\n * over all components without gaps.\n *\n * @typeParam T - The component data type\n *\n * @category Data Structures\n */\nexport class ComponentArray<T> implements CArray {\n\n    private denseArray: T[]; // packed array of data\n    private sparse: (Entity | null)[]; // maps entity to index in dense array\n    private reverse: (Entity | null)[]; // maps index in dense array to entity\n    private _count: number;\n\n    constructor(maxEntities: number) {\n        this._count = 0;\n        this.denseArray = new Array(maxEntities);\n        this.sparse = new Array(maxEntities);\n        this.reverse = new Array(maxEntities);\n    }\n\n    insertData(entity: Entity, data: T): void {\n        if(this.getData(entity) !== null) {\n            this.removeData(entity);\n        }\n        if(this.sparse.length < entity){\n            // resize the array for the new entity but normally this should not happen\n            this.sparse = [...this.sparse, ...new Array(entity - this.sparse.length).fill(null)];\n        }\n\n        this.denseArray[this._count] = data;\n        this.reverse[this._count] = entity;\n        this.sparse[entity] = this._count;\n        this._count++;\n    }\n\n    getData(entity: Entity): T | null {\n        if(this.sparse.length <= entity){\n            return null;\n        }\n\n        const denseIndex = this.sparse[entity];\n        if(denseIndex === undefined || denseIndex === null || denseIndex >= this._count){\n            return null;\n        }\n\n        if(this.reverse[denseIndex] !== entity) {\n            return null;\n        }\n\n        return this.denseArray[denseIndex];\n    }\n\n    removeData(entity: Entity): void {\n        const denseIndex = this.sparse[entity];\n        if(denseIndex === undefined || denseIndex === null || denseIndex >= this._count){\n            return;\n        }\n\n        const lastEntity = this.reverse[this._count - 1];\n\n        if(lastEntity === null) {\n            return;\n        }\n\n        this.denseArray[denseIndex] = this.denseArray[this._count - 1];\n        this.reverse[denseIndex] = lastEntity;\n        this.sparse[lastEntity] = denseIndex;\n        this.sparse[entity] = null;\n\n        this._count--;\n    }\n\n    entityDestroyed(entity: Entity): void {\n        this.removeData(entity);\n    }\n}\n\n/**\n * Manages component registration and component data storage.\n *\n * @remarks\n * The ComponentManager handles:\n * - Registering new component types and assigning unique type IDs\n * - Creating ComponentArray storage for each component type\n * - Adding, removing, and querying component data for entities\n * - Cleaning up component data when entities are destroyed\n *\n * Each component type gets a unique ID (0-31) and its own ComponentArray\n * for efficient storage and retrieval.\n *\n * @category Managers\n */\nexport class ComponentManager {\n\n    private _componentNameToTypeMap: Map<string, {componentType: ComponentType, componentArray: CArray}> = new Map();\n    private _nextAvailableComponentType: ComponentType = 0;\n    \n    registerComponent<T>(componentName: string){\n        if(this._componentNameToTypeMap.has(componentName)) {\n            console.warn(`Component ${componentName} already registered; registering with the given new type`);\n        }\n        const componentType = this._nextAvailableComponentType;\n        this._componentNameToTypeMap.set(componentName, {componentType, componentArray: new ComponentArray<T>(MAX_ENTITIES)});\n        this._nextAvailableComponentType++;\n    }\n\n    getComponentType(componentName: string): ComponentType | null {\n        return this._componentNameToTypeMap.get(componentName)?.componentType ?? null;\n    }\n\n    addComponentToEntity<T>(componentName: string, entity: Entity, component: T){\n        const componentArray = this._getComponentArray<T>(componentName);\n        if(componentArray === null) {\n            return;\n        }\n        componentArray.insertData(entity, component);\n    }\n\n    removeComponentFromEntity<T>(componentName: string, entity: Entity){\n        const componentArray = this._getComponentArray<T>(componentName);\n        if(componentArray === null) {\n            return;\n        }\n        componentArray.removeData(entity);\n    }\n\n    getComponentFromEntity<T>(componentName: string, entity: Entity): T | null {\n        const componentArray = this._getComponentArray<T>(componentName);\n        if(componentArray === null) {\n            return null;\n        }\n        return componentArray.getData(entity);\n    }\n\n    entityDestroyed(entity: Entity){\n        for(const component of this._componentNameToTypeMap.values()){\n            component.componentArray.entityDestroyed(entity);\n        }\n    }\n\n    private _getComponentArray<T>(componentName: string): ComponentArray<T> | null {\n        const component = this._componentNameToTypeMap.get(componentName);\n        if(component === undefined) {\n            console.warn(`Component ${componentName} not registered`);\n            return null;\n        }\n        return component.componentArray as ComponentArray<T>;\n    }\n\n}\n\n/**\n * System interface for processing entities with specific component combinations.\n *\n * @remarks\n * A System maintains a set of entities that match its component signature.\n * The ECS automatically updates this set when entities are created, destroyed,\n * or have their components modified.\n *\n * Systems contain only the logic for processing entities - the `entities` set\n * is automatically managed by the SystemManager.\n *\n * @example\n * ```typescript\n * const movementSystem: System = {\n *   entities: new Set()\n * };\n *\n * // System logic (called in game loop)\n * function updateMovement(deltaTime: number) {\n *   movementSystem.entities.forEach(entity => {\n *     const pos = ecs.getComponentFromEntity<Position>('Position', entity);\n *     const vel = ecs.getComponentFromEntity<Velocity>('Velocity', entity);\n *     if (pos && vel) {\n *       pos.x += vel.x * deltaTime;\n *       pos.y += vel.y * deltaTime;\n *     }\n *   });\n * }\n * ```\n *\n * @category Types\n */\nexport interface System {\n    entities: Set<Entity>;\n}\n\n/**\n * Manages system registration and entity-system matching.\n *\n * @remarks\n * The SystemManager handles:\n * - Registering systems with their component signature requirements\n * - Maintaining the set of entities that match each system's signature\n * - Automatically adding/removing entities from systems when signatures change\n * - Cleaning up system entity sets when entities are destroyed\n *\n * When an entity's component signature changes (components added/removed),\n * the SystemManager checks all registered systems and updates their entity sets.\n * An entity is added to a system's set if its signature contains all components\n * required by the system's signature.\n *\n * @category Managers\n */\nexport class SystemManager {\n    private _systems: Map<string, {system: System, signature: ComponentSignature}> = new Map();\n\n    registerSystem(systemName: string, system: System){\n        if(this._systems.has(systemName)) {\n            console.warn(`System ${systemName} already registered`);\n            return;\n        }\n        this._systems.set(systemName, {system, signature: 0});\n    }\n\n    setSignature(systemName: string, signature: ComponentSignature){\n        if(!this._systems.has(systemName)) {\n            console.warn(`System ${systemName} not registered`);\n            return;\n        }\n        const system = this._systems.get(systemName);\n        if(system === undefined) {\n            console.warn(`System ${systemName} not registered`);\n            return;\n        }\n        system.signature = signature;\n    }\n\n    entityDestroyed(entity: Entity){\n        for(const system of this._systems.values()){\n            system.system.entities.delete(entity);\n        }\n    }\n\n    entitySignatureChanged(entity: Entity, signature: ComponentSignature){\n        for(const system of this._systems.values()){\n            const systemSignature = system.signature;\n            if((systemSignature & signature) === systemSignature){\n                system.system.entities.add(entity);\n            } else {\n                system.system.entities.delete(entity);\n            }\n        }\n    }\n}\n\n/**\n * Main ECS coordinator that manages entities, components, and systems.\n *\n * @remarks\n * The Coordinator is the central API for working with the ECS. It provides a unified\n * interface for:\n * - Creating and destroying entities\n * - Registering and managing components\n * - Registering and configuring systems\n * - Querying component data\n *\n * The Coordinator automatically keeps entity signatures up-to-date and notifies\n * systems when entities match their component requirements.\n *\n * @example\n * Complete ECS workflow\n * ```typescript\n * const ecs = new Coordinator();\n *\n * // Setup\n * ecs.registerComponent<Position>('Position');\n * ecs.registerComponent<Velocity>('Velocity');\n *\n * // Create entity\n * const entity = ecs.createEntity();\n * ecs.addComponentToEntity('Position', entity, { x: 0, y: 0 });\n * ecs.addComponentToEntity('Velocity', entity, { x: 1, y: 0 });\n *\n * // Update\n * const pos = ecs.getComponentFromEntity<Position>('Position', entity);\n * const vel = ecs.getComponentFromEntity<Velocity>('Velocity', entity);\n * if (pos && vel) {\n *   pos.x += vel.x;\n *   pos.y += vel.y;\n * }\n *\n * // Cleanup\n * ecs.destroyEntity(entity);\n * ```\n *\n * @category Core\n */\nexport class Coordinator {\n    private _entityManager: EntityManager;\n    private _componentManager: ComponentManager;\n    private _systemManager: SystemManager;\n\n    constructor(){\n        this._entityManager = new EntityManager();\n        this._componentManager = new ComponentManager();\n        this._systemManager = new SystemManager();\n    }\n\n    createEntity(): Entity {\n        return this._entityManager.createEntity();\n    }\n\n    destroyEntity(entity: Entity): void {\n        this._entityManager.destroyEntity(entity);\n        this._componentManager.entityDestroyed(entity);\n        this._systemManager.entityDestroyed(entity);\n    }\n\n    registerComponent<T>(componentName: string): void {\n        this._componentManager.registerComponent<T>(componentName);\n    }\n\n    addComponentToEntity<T>(componentName: string, entity: Entity, component: T): void {\n        this._componentManager.addComponentToEntity<T>(componentName, entity, component);\n        let signature = this._entityManager.getSignature(entity);\n        if(signature === null) {\n            signature = 0;\n        }\n        const componentType = this._componentManager.getComponentType(componentName);\n        if(componentType === null) {\n            console.warn(`Component ${componentName} not registered`);\n            return;\n        }\n        signature |= 1 << componentType;\n        this._entityManager.setSignature(entity, signature);\n        this._systemManager.entitySignatureChanged(entity, signature);\n    }\n\n    removeComponentFromEntity<T>(componentName: string, entity: Entity): void {\n        this._componentManager.removeComponentFromEntity<T>(componentName, entity);\n        let signature = this._entityManager.getSignature(entity);\n        if(signature === null) {\n            signature = 0;\n        }\n        const componentType = this._componentManager.getComponentType(componentName);\n        if(componentType === null) {\n            return;\n        }\n        signature &= ~(1 << componentType);\n        this._entityManager.setSignature(entity, signature);\n        this._systemManager.entitySignatureChanged(entity, signature);\n    }\n\n    getComponentFromEntity<T>(componentName: string, entity: Entity): T | null {\n        return this._componentManager.getComponentFromEntity<T>(componentName, entity);\n    }\n\n    getComponentType(componentName: string): ComponentType | null {\n        return this._componentManager.getComponentType(componentName) ?? null;\n    }\n\n    registerSystem(systemName: string, system: System): void {\n        this._systemManager.registerSystem(systemName, system);\n    }\n\n    setSystemSignature(systemName: string, signature: ComponentSignature): void {\n        this._systemManager.setSignature(systemName, signature);\n    }\n}\n"
   ],
-  "mappings": "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",
-  "debugId": "840788BF2D72B20064756E2164756E21",
+  "mappings": "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",
+  "debugId": "983008DE2E282BA464756E2164756E21",
   "names": []
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@ue-too/ecs",
   "author": "niuee",
   "type": "module",
-  "version": "0.9.5",
+  "version": "0.10.0",
   "description": "Entity Component System for uē-tôo",
   "license": "MIT",
   "repository": {