@jael-ecs/core 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jonathan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,493 @@
+<div align="center">
+
+# Jael (Just Another ECS Library)
+
+[![npm version](https://badge.fury.io/js/%40jael%2Fcore.svg)](https://badge.fury.io/js/%40jael%2Fcore)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.9+-blue.svg)](https://www.typescriptlang.org/)
+
+_A modern, performant, and user-friendly Entity Component System library written in TypeScript_
+
+</div>
+
+## Table of contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Architecture](#architecture)
+- [Api Reference](#-api-reference)
+  - [World](#world)
+  - [Entity](#entity)
+  - [System](#system)
+  - [Query](#query)
+  - [SparseSet](#sparseset)
+  - [Time](#time)
+  - [EventRegistry](#event-registry)
+- [Best Practices](#best-practices)
+- [Advanced Usage](#advanced-usage)
+- [Contributing](#contributing)
+- [Acknowledgments](#acknowledgments)
+
+## Features
+
+- **User Friendly API** - Clean, fluent api that's easy to learn
+- **High Performance** - Optimized SparseSet implementation for fast entity lookups
+- **Minimal Bundle size** - Compact bundle size without dependencies.
+
+## Installation
+
+```bash
+npm install @jael/core
+```
+
+## Quick Start
+
+```typescript
+import { World, System } from "@jael/core";
+
+// Create your world
+const world = new World();
+
+// Define components
+interface Position {
+  x: number;
+  y: number;
+}
+
+interface Velocity {
+  dx: number;
+  dy: number;
+}
+
+// Create entities
+const player = world.create();
+world.addComponent(player, "position", { x: 0, y: 0 });
+world.addComponent(player, "velocity", { dx: 1, dy: 1 });
+
+const enemy = world.create();
+world.addComponent(enemy, "position", { x: 10, y: 10 });
+world.addComponent(enemy, "velocity", { dx: -1, dy: 0 });
+
+// Create a system
+const movementSystem: System = {
+  priority: 0,
+  update(dt) {
+    const query = world.include("position", "velocity");
+
+    for (const entity of query.entities) {
+      const position = entity.get<Position>("position");
+      const velocity = entity.get<Velocity>("velocity");
+
+      position.x += velocity.dx * (dt || 0.016);
+      position.y += velocity.dy * (dt || 0.016);
+    }
+  },
+};
+
+// Add system to world
+world.addSystem(movementSystem);
+
+// Game loop
+function gameLoop(dt: number) {
+  world.update(dt);
+}
+```
+
+## Architecture
+
+Jael follows the classic Entity Component System pattern:
+
+- **Entities**: Unique identifiers (just IDs) - no data attached
+- **Components**: Pure data containers (no logic)
+- **Systems**: Process entities with specific component combinations
+
+## API Reference
+
+### World
+
+The central hub that manages entities, components, and systems.
+
+#### Entity Management
+
+```typescript
+// Create a new entity
+const entity = world.create();
+
+// Destroy an entity
+world.destroy(entity);
+
+// Check if entity exists
+const exists = world.exist(entity);
+```
+
+#### Component Management
+
+```typescript
+// Add component
+world.addComponent(entity, "position", { x: 0, y: 0 });
+
+// Remove component
+world.removeComponent(entity, "position");
+
+// Get component
+const position = entity.get<Position>("position");
+
+// Check if entity has component
+const hasPosition = entity.has("position");
+```
+
+#### System Management
+
+```typescript
+// Add system
+world.addSystem(yourSystem);
+
+// Remove system
+world.removeSystem(yourSystem);
+```
+
+#### Events
+
+```typescript
+// Listen to world events
+world.on("entityCreated", ({ entity }) => {
+  console.log("Entity created:", entity);
+});
+
+world.on("entityDestroyed", ({ entity }) => {
+  console.log("Entity destroyed:", entity);
+});
+
+world.on("componentAdded", ({ entity, component }) => {
+  console.log(`Component ${component} added to entity`);
+});
+
+world.on("componentRemoved", ({ entity, component }) => {
+  console.log(`Component ${component} removed from entity`);
+});
+
+world.on("updated", () => {
+  console.log("World updated");
+});
+```
+
+### Entity
+
+Base entity class for intuitive component management
+
+```typescript
+// Create entity
+const entity = world.create();
+
+// Add component
+entity.add("position", { x: 0, y: 0 });
+
+// Remove component
+entity.remove("position");
+
+// Check if component exist
+const posExist = entity.has("position");
+
+// Get curren value of the component
+const compSchema = entity.get("position");
+```
+
+### System
+
+Systems contain the game logic that processes entities with specific components.
+
+```typescript
+interface System {
+  priority: number; // Execution order (lower = earlier)
+  exit?(): void; // Cleanup when removed
+  update(dt?: number): void; // Main update logic
+}
+```
+
+#### Example System
+
+```typescript
+const renderSystem: System = {
+  priority: 100, // Render after all other systems
+
+  update(dt) {
+    const renderableQuery = world.include("position", "sprite");
+
+    for (const entity of renderableQuery.entities) {
+      const position = entity.get<Position>("position");
+      const sprite = entity.get<Sprite>("sprite");
+
+      // Render entity
+      drawSprite(sprite, position.x, position.y);
+    }
+  },
+
+  exit() {
+    console.log("Render system cleanup");
+  },
+};
+```
+
+### Query
+
+Queries provide efficient, cached access to entities matching specific component patterns.
+
+```typescript
+interface QueryConfig {
+  include: string[]; // Required components
+  exclude: string[]; // Components to exclude
+}
+```
+
+#### Creating Queries
+
+```typescript
+// Simple include query
+const movingEntities = world.include("position", "velocity");
+
+// Simple exclude query
+const nonStatic = world.exclude("static");
+
+// Complex query
+const complex = world.query({
+  include: ["position", "velocity", "health"],
+  exclude: ["dead", "paused"],
+});
+
+// Can be use with builder pattern creating a hash for every include/exclude
+const complexQuery2 = world.include("position", "health").exclude("static");
+```
+
+#### Accessing Results
+
+```typescript
+// Iterate through entities
+for (const entity of query.entities) {
+  // Process entity
+}
+
+// Get the first value of the query
+const first = query.entities.first();
+
+// Check query size
+const count = query.entities.size();
+
+// Check if query has any entities
+const isEmpty = query.entities.size() === 0;
+```
+
+### SparseSet
+
+High-performance data structure used internally for entity and component storage.
+
+```typescript
+const sparseSet = new SparseSet<Entity>();
+
+// Add items
+sparseSet.add(entity1);
+sparseSet.add(entity2);
+
+// Remove items
+sparseSet.remove(entity1);
+
+// Check existence
+const exists = sparseSet.has(entity2);
+
+// Iterate
+for (const entity of sparseSet) {
+  // Process entity
+}
+
+// Get size
+const size = sparseSet.size;
+
+// Clear all
+sparseSet.clear();
+```
+
+### Time
+
+Utility singleton class for managing time and delta time calculations.
+
+```typescript
+import { Time } from "@jael/core";
+
+Time.start();
+
+// Access time properties
+const dt = Time.delta; // Delta time
+const elapsed = Time.elapsed; // Total elapsed time
+
+// Events
+time.on("update", () => {
+  console.log(`Frame: ${dt}ms, Total: ${total}ms`);
+});
+```
+
+### Event Registry
+
+Base class providing event emission and listening capabilities.
+
+```typescript
+interface WorldEvents {
+  entityCreated: { entity: Entity };
+  entityDestroyed: { entity: Entity };
+  componentAdded: { entity: Entity; component: string };
+  componentRemoved: { entity: Entity; component: string };
+  updated: void;
+}
+
+// Listen to events
+world.on("entityCreated", (data) => {
+  // Handle event
+});
+
+// Emit events (handled internally by World)
+world.emit("entityCreated", { entity: someEntity });
+
+// Remove listeners
+world.off("entityCreated", handler);
+
+// Romeve all listeners of a type
+world.clearEvent('type')
+
+// Remove all listeners
+world.clearAllEvents();
+```
+
+## Best Practices
+
+### 1. Component Design
+
+```typescript
+// ✅ Good: Simple data containers
+interface Position {
+  x: number;
+  y: number;
+}
+
+interface Health {
+  current: number;
+  max: number;
+}
+
+// ❌ Avoid: Methods in components
+interface BadComponent {
+  x: number;
+  move(): void; // Put this in a system!
+}
+```
+
+### 2. System Organization
+
+```typescript
+// Organize systems by functionality and priority
+const INPUT_PRIORITY = 0;
+const PHYSICS_PRIORITY = 50;
+const LOGIC_PRIORITY = 100;
+const RENDER_PRIORITY = 200;
+
+const inputSystem = { priority: INPUT_PRIORITY /* ... */ };
+const physicsSystem = { priority: PHYSICS_PRIORITY /* ... */ };
+const renderSystem = { priority: RENDER_PRIORITY /* ... */ };
+```
+
+### 3. Query Optimization
+
+```typescript
+// ✅ Good: Cache queries when possible
+class MovementSystem implements System {
+  private movementQuery: Query;
+  priority: number = 1
+
+  constructor(private world: World) {
+    this.movementQuery = world.include('position', 'velocity');
+  }
+
+  update(dt?: number) {
+    for (const entity of this.movementQuery.entities) {
+      // Process movement
+    }
+  }
+}
+
+// ✅ Also good: Use world.include/exclude for simple cases
+update(dt?: number) {
+  const entities = this.world.include('position', 'velocity');
+  // ...
+}
+```
+
+### 4. Memory Management
+
+```typescript
+// Remember to clean up when removing entities
+world.destroy(entity); // Automatically removes all components
+
+// Clean up systems if they have resources
+system.exit?.(); // Called automatically when removed from world
+```
+
+## Advanced Usage
+
+### Custom Events
+
+```typescript
+// Extend world with custom events
+interface CustomWorldEvents extends WorldEvents {
+  playerScored: { points: number };
+  gameOver: void;
+}
+
+const world = new World() as any as EventRegistry<CustomWorldEvents>;
+
+// Emit custom events
+world.emit("playerScored", { points: 100 });
+
+// Listen to custom events
+world.on("playerScored", ({ points }) => {
+  updateScore(points);
+});
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+### Development Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/cammyb1/jael.git
+cd jael
+
+# Install dependencies
+npm install
+
+# Start development
+npm run dev
+
+# Build
+npm run build
+```
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/) - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Inspiration from ECS frameworks like [ECSY](https://github.com/ecsyjs/ecsy) and [Bevy](https://github.com/bevyengine/bevy)
+- TypeScript for providing excellent type safety and developer experience
+
+---
+
+<div align="center">
+
+[⭐ Star this repo if it helped you!](https://github.com/cammyb1/jael)
+
+[☕ You can buy me a coffee :)](https://buymeacoffee.com/jonathanva5)
+
+**Built with ❤️ by [cammyb1](https://github.com/cammyb1)**
+
+</div>

package/dist/ComponentManager.d.ts

@@ -0,0 +1,23 @@
+import { Entity } from './EntityManager';
+import { default as EventRegistry } from './EventRegistry';
+import { default as World } from './World';
+export type ComponentSchema = Record<string, any>;
+export interface ComponentManagerEvents {
+    add: {
+        entity: Entity;
+        component: keyof ComponentSchema;
+    };
+    remove: {
+        entity: Entity;
+        component: keyof ComponentSchema;
+    };
+}
+export declare class ComponentManager extends EventRegistry<ComponentManagerEvents> {
+    componentSet: Map<number, ComponentSchema>;
+    world: World;
+    constructor(world: World);
+    addComponent<K extends keyof ComponentSchema>(entity: Entity, key: K, value: ComponentSchema[K]): void;
+    getComponent<K extends keyof ComponentSchema>(entity: Entity, key: K): ComponentSchema[K] | undefined;
+    hasComponent<K extends keyof ComponentSchema>(entity: Entity, key: K): boolean;
+    removeComponent<K extends keyof ComponentSchema>(entity: Entity, key: K): void;
+}

package/dist/EntityManager.d.ts

@@ -0,0 +1,47 @@
+import { default as EventRegistry } from './EventRegistry';
+import { SparseSet } from './SparseSet';
+import { default as World } from './World';
+declare class Entity {
+    readonly id: number;
+    private _world;
+    constructor(world: World, id: number);
+    /**
+     * Add component to current entity.
+     * @param compType Component name
+     * @param compValue Component value
+     */
+    add(compType: string, compValue: any): void;
+    /**
+     * Remove component of current entity.
+     * @param compType Component name
+     */
+    remove(compType: string): void;
+    /**
+     * Check if current entity has a component.
+     * @param compType Component name
+     * @returns boolean
+     */
+    has(compKey: string): boolean;
+    /**
+     * Get passed component schema of current entity.
+     * @param compType Component name
+     * @returns Return component schema with T(any as default) as type
+     */
+    get<T = any>(compType: string): T;
+}
+export declare class EntityManager extends EventRegistry<EntityManagerEvents> {
+    entityMap: SparseSet<Entity>;
+    nextId: number;
+    _world: World;
+    constructor(world: World);
+    get entities(): SparseSet<Entity>;
+    create(): Entity;
+    exist(entity: Entity): boolean;
+    size(): number;
+    destroy(entity: Entity): Entity;
+}
+export interface EntityManagerEvents {
+    create: Entity;
+    destroy: Entity;
+}
+export { type Entity };

package/dist/EventRegistry.d.ts

@@ -0,0 +1,11 @@
+export type Event<E> = (e: E[keyof E]) => void;
+export default class EventRegistry<E extends Record<string, any> = {}> {
+    private _listeners;
+    on(type: keyof E, callback: Event<E>): void;
+    off(type: keyof E, callback: Event<E>): void;
+    once(type: keyof E, callback: Event<E>): void;
+    clearEvent(type: keyof E): void;
+    clearAllEvents(): void;
+    contains(type: keyof E, callback: Event<E>): boolean;
+    emit(type: keyof E, data: E[keyof E]): void;
+}

package/dist/Query.d.ts

@@ -0,0 +1,20 @@
+import { Entity } from './EntityManager';
+import { SparseSet } from './SparseSet';
+import { default as World } from './World';
+export interface QueryConfig {
+    include: string[];
+    exclude: string[];
+}
+export declare class Query {
+    config: QueryConfig;
+    entityMap: SparseSet<Entity>;
+    world: World;
+    constructor(config: QueryConfig, world: World);
+    hasComponents(entity: Entity): boolean;
+    get entities(): SparseSet<Entity>;
+    include(...comps: string[]): Query;
+    exclude(...comps: string[]): Query;
+    private _checkExistingEntities;
+    checkEntities(): void;
+    static getHash(config: QueryConfig): number;
+}

package/dist/SparseSet.d.ts

@@ -0,0 +1,19 @@
+export declare class SparseSet<V> {
+    denseValues: V[];
+    sparse: Map<V, number>;
+    [Symbol.iterator](): {
+        next: () => {
+            value: V;
+            done: boolean;
+        };
+    };
+    get values(): V[];
+    first(): V;
+    add(item: V): void;
+    indexOf(item: V): number;
+    remove(item: V): void;
+    forEach(predicate: (item: V) => void): void;
+    size(): number;
+    clear(): void;
+    has(item: V): boolean;
+}

package/dist/SystemManager.d.ts

@@ -0,0 +1,12 @@
+export interface System {
+    priority: number;
+    exit?(): void;
+    update(dt?: number): void;
+}
+export declare class SystemManager {
+    systemList: System[];
+    addSystem(system: System): void;
+    reorder(): void;
+    has(system: System): boolean;
+    removeSystem(system: System): void;
+}

package/dist/Time.d.ts

@@ -0,0 +1,18 @@
+import { default as EventRegistry } from './EventRegistry';
+export interface TimeEvents {
+    update: void;
+}
+declare class TimeSingleton extends EventRegistry<TimeEvents> {
+    private _startTime;
+    private _oldTime;
+    private _requestId;
+    running: boolean;
+    delta: number;
+    elapsed: number;
+    constructor();
+    private _loop;
+    start(): void;
+    stop(): void;
+}
+export declare let Time: TimeSingleton;
+export {};

package/dist/World.d.ts

@@ -0,0 +1,43 @@
+import { ComponentManager, ComponentSchema } from './ComponentManager';
+import { EntityManager, Entity } from './EntityManager';
+import { default as EventRegistry } from './EventRegistry';
+import { Query, QueryConfig } from './Query';
+import { SparseSet } from './SparseSet';
+import { SystemManager, System } from './SystemManager';
+export interface WorldEvents {
+    entityCreated: {
+        entity: Entity;
+    };
+    entityDestroyed: {
+        entity: Entity;
+    };
+    componentAdded: {
+        entity: Entity;
+        component: keyof ComponentSchema;
+    };
+    componentRemoved: {
+        entity: Entity;
+        component: keyof ComponentSchema;
+    };
+    updated: void;
+}
+export default class World extends EventRegistry<WorldEvents> {
+    entityManager: EntityManager;
+    componentManager: ComponentManager;
+    systemManager: SystemManager;
+    queries: Map<number, Query>;
+    constructor();
+    get entities(): SparseSet<Entity>;
+    query(config: QueryConfig): Query;
+    private _updateQueries;
+    exist(entity: Entity): boolean;
+    include(...comps: string[]): Query;
+    exclude(...comps: string[]): Query;
+    create(): Entity;
+    destroy(entity: Entity): void;
+    addSystem(sys: System): void;
+    removeSystem(sys: System): void;
+    addComponent(entity: Entity, compKey: string, compValue: any): void;
+    removeComponent(entity: Entity, compKey: string): void;
+    update(): void;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { default as EventRegistry } from './EventRegistry';
+import { System, SystemManager } from './SystemManager';
+import { Entity, EntityManager, EntityManagerEvents } from './EntityManager';
+import { ComponentSchema, ComponentManager, ComponentManagerEvents } from './ComponentManager';
+import { Query, QueryConfig } from './Query';
+import { SparseSet } from './SparseSet';
+import { Time, TimeEvents } from './Time';
+import { default as World, WorldEvents } from './World';
+export { type System, type Entity, type EntityManagerEvents, type ComponentManagerEvents, type ComponentSchema, type QueryConfig, type TimeEvents, type WorldEvents, Query, World, Time, SparseSet, EventRegistry, SystemManager, EntityManager, ComponentManager, };

package/dist/jael-build.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class h{_listeners=new Map;on(e,t){if(this.contains(e,t))return;const s=this._listeners.get(e);s?s.add(t):this._listeners.set(e,new Set([t]))}off(e,t){if(!this.contains(e,t))return;const s=this._listeners.get(e);s&&s.delete(t)}once(e,t){const s=(i=>{t(i),this.off(e,s)});this.on(e,s)}clearEvent(e){this._listeners.get(e)&&this._listeners.get(e)?.clear()}clearAllEvents(){this._listeners.forEach(e=>e.clear()),this._listeners.clear()}contains(e,t){return this._listeners.get(e)?this._listeners.get(e).has(t):!1}emit(e,t){this._listeners.get(e)&&this._listeners.get(e)?.forEach(s=>{s(t)})}}class u{systemList=[];addSystem(e){this.systemList.push(e),this.reorder()}reorder(){this.systemList.sort((e,t)=>e.priority-t.priority)}has(e){return this.systemList.indexOf(e)>0}removeSystem(e){if(!this.has(e))return;const t=this.systemList.indexOf(e);t>=0&&(this.systemList.splice(t,1),e.exit?.(),this.reorder())}}class d{denseValues=[];sparse=new Map;[Symbol.iterator](){let e=this.values.length;const t={value:void 0,done:!1};return{next:()=>(t.value=this.values[--e],t.done=e<0,t)}}get values(){return this.denseValues}first(){return this.denseValues[0]}add(e){this.has(e)||(this.denseValues.push(e),this.sparse.set(e,this.denseValues.length-1))}indexOf(e){return this.sparse.get(e)?this.sparse.get(e):-1}remove(e){if(!this.has(e))return;const t=this.sparse.get(e);this.sparse.delete(e);const s=this.denseValues[this.denseValues.length-1];s!==e&&(this.denseValues[t]=s,this.sparse.set(s,t)),this.denseValues.pop()}forEach(e){for(let t of this)e(t)}size(){return this.denseValues.length}clear(){for(let e of this)this.remove(e)}has(e){return this.sparse.has(e)}}class m{id;_world;constructor(e,t){this.id=t,this._world=e}add(e,t){this._world.addComponent(this,e,t)}remove(e){this._world.removeComponent(this,e)}has(e){return this._world.componentManager.hasComponent(this,e)}get(e){return this._world.componentManager.getComponent(this,e)}}class c extends h{entityMap=new d;nextId=0;_world;constructor(e){super(),this._world=e}get entities(){return this.entityMap}create(){const e=this.nextId++,t=new m(this._world,e);return this.entities.add(t),this.emit("create",t),t}exist(e){return this.entities.has(e)}size(){return this.entities.size()}destroy(e){return this.entities.remove(e),this.emit("destroy",e),e}}class l extends h{componentSet=new Map;world;constructor(e){super(),this.world=e,this.world.on("entityDestroyed",t=>{t&&t.entity&&this.componentSet.get(t.entity.id)&&this.componentSet.delete(t.entity.id)})}addComponent(e,t,s){const i=this.componentSet.get(e.id);i?i[t]=s:this.componentSet.set(e.id,{[t]:s}),this.emit("add",{entity:e,component:t})}getComponent(e,t){return this.hasComponent(e,t)?this.componentSet.get(e.id)[t]:void 0}hasComponent(e,t){const s=this.componentSet.get(e.id);return s?t in s:!1}removeComponent(e,t){if(!this.componentSet.get(e.id))return;const s=this.componentSet.get(e.id);s&&s[t]!==void 0&&(delete s[t],Object.keys(s).length===0&&this.componentSet.delete(e.id),this.emit("remove",{entity:e,component:t}))}}class a{config;entityMap;world;constructor(e,t){this.config=e,this.world=t,this.entityMap=new d}hasComponents(e){return this.config.include?.every(t=>e.has(t))&&this.config.exclude?.every(t=>!e.has(t))}get entities(){return this.entityMap}include(...e){return this.world.include(...e)}exclude(...e){return this.world.exclude(...e)}_checkExistingEntities(){for(let e of this.entities)this.world.exist(e)||this.entityMap.remove(e)}checkEntities(){for(let e of this.world.entities)e&&this.hasComponents(e)&&this.entityMap.add(e);this._checkExistingEntities()}static getHash(e){const t=e.include?.map(n=>n.trim()).filter(n=>n).join("_"),s=e.exclude?.map(n=>n.trim()).filter(n=>n).join("_"),i="in_"+t+"_out_"+s;let o=0;for(const n of i)o=(o<<5)-o+n.charCodeAt(0),o|=0;return o}}class p extends h{_startTime=0;_oldTime=0;_requestId=0;running=!1;delta=0;elapsed=0;constructor(){super()}_loop(){let e=0;if(this.running){const t=performance.now();e=(t-this._oldTime)/1e3,this._oldTime=t,this.elapsed+=e}this.delta=e,this.emit("update"),this._requestId=requestAnimationFrame(this._loop.bind(this))}start(){this._startTime=performance.now(),this._oldTime=this._startTime,this.elapsed=0,this.delta=0,this.running=!0,this._loop()}stop(){this.running=!1,cancelAnimationFrame(this._requestId),this._requestId=0}}let g=new p;class f extends h{entityManager;componentManager;systemManager;queries;constructor(){super(),this.entityManager=new c(this),this.componentManager=new l(this),this.systemManager=new u,this.entityManager.on("create",e=>{e&&this.emit("entityCreated",{entity:e}),this._updateQueries()}),this.entityManager.on("destroy",e=>{e&&this.emit("entityDestroyed",{entity:e}),this._updateQueries()}),this.componentManager.on("add",e=>{this.emit("componentAdded",{entity:e.entity,component:e.component}),this._updateQueries()}),this.componentManager.on("remove",e=>{this.emit("componentRemoved",{entity:e.entity,component:e.component}),this._updateQueries()}),this.queries=new Map}get entities(){return this.entityManager.entities}query(e){const t=a.getHash(e);let i=this.queries.get(t);return i||(i=new a(e,this),this.queries.set(t,i),this._updateQueries()),i}_updateQueries(){this.queries.forEach(e=>e.checkEntities())}exist(e){return this.entityManager.exist(e)}include(...e){return this.query({include:e,exclude:[]})}exclude(...e){return this.query({include:[],exclude:e})}create(){return this.entityManager.create()}destroy(e){this.entityManager.destroy(e)}addSystem(e){this.systemManager.addSystem(e)}removeSystem(e){this.systemManager.removeSystem(e)}addComponent(e,t,s){this.componentManager.addComponent(e,t,s)}removeComponent(e,t){this.componentManager.removeComponent(e,t)}update(){this.systemManager.systemList.forEach(e=>{e.update()}),this.emit("updated")}}exports.ComponentManager=l;exports.EntityManager=c;exports.EventRegistry=h;exports.Query=a;exports.SparseSet=d;exports.SystemManager=u;exports.Time=g;exports.World=f;

package/dist/jael-build.js

@@ -0,0 +1,332 @@
+class h {
+  _listeners = /* @__PURE__ */ new Map();
+  on(e, t) {
+    if (this.contains(e, t))
+      return;
+    const s = this._listeners.get(e);
+    s ? s.add(t) : this._listeners.set(e, /* @__PURE__ */ new Set([t]));
+  }
+  off(e, t) {
+    if (!this.contains(e, t))
+      return;
+    const s = this._listeners.get(e);
+    s && s.delete(t);
+  }
+  once(e, t) {
+    const s = ((i) => {
+      t(i), this.off(e, s);
+    });
+    this.on(e, s);
+  }
+  clearEvent(e) {
+    this._listeners.get(e) && this._listeners.get(e)?.clear();
+  }
+  clearAllEvents() {
+    this._listeners.forEach((e) => e.clear()), this._listeners.clear();
+  }
+  contains(e, t) {
+    return this._listeners.get(e) ? this._listeners.get(e).has(t) : !1;
+  }
+  emit(e, t) {
+    this._listeners.get(e) && this._listeners.get(e)?.forEach((s) => {
+      s(t);
+    });
+  }
+}
+class u {
+  systemList = [];
+  addSystem(e) {
+    this.systemList.push(e), this.reorder();
+  }
+  reorder() {
+    this.systemList.sort((e, t) => e.priority - t.priority);
+  }
+  has(e) {
+    return this.systemList.indexOf(e) > 0;
+  }
+  removeSystem(e) {
+    if (!this.has(e)) return;
+    const t = this.systemList.indexOf(e);
+    t >= 0 && (this.systemList.splice(t, 1), e.exit?.(), this.reorder());
+  }
+}
+class d {
+  denseValues = [];
+  sparse = /* @__PURE__ */ new Map();
+  [Symbol.iterator]() {
+    let e = this.values.length;
+    const t = {
+      value: void 0,
+      done: !1
+    };
+    return {
+      next: () => (t.value = this.values[--e], t.done = e < 0, t)
+    };
+  }
+  get values() {
+    return this.denseValues;
+  }
+  first() {
+    return this.denseValues[0];
+  }
+  add(e) {
+    this.has(e) || (this.denseValues.push(e), this.sparse.set(e, this.denseValues.length - 1));
+  }
+  indexOf(e) {
+    return this.sparse.get(e) ? this.sparse.get(e) : -1;
+  }
+  remove(e) {
+    if (!this.has(e)) return;
+    const t = this.sparse.get(e);
+    this.sparse.delete(e);
+    const s = this.denseValues[this.denseValues.length - 1];
+    s !== e && (this.denseValues[t] = s, this.sparse.set(s, t)), this.denseValues.pop();
+  }
+  forEach(e) {
+    for (let t of this)
+      e(t);
+  }
+  size() {
+    return this.denseValues.length;
+  }
+  clear() {
+    for (let e of this)
+      this.remove(e);
+  }
+  has(e) {
+    return this.sparse.has(e);
+  }
+}
+class c {
+  id;
+  _world;
+  constructor(e, t) {
+    this.id = t, this._world = e;
+  }
+  /**
+   * Add component to current entity.
+   * @param compType Component name
+   * @param compValue Component value
+   */
+  add(e, t) {
+    this._world.addComponent(this, e, t);
+  }
+  /**
+   * Remove component of current entity.
+   * @param compType Component name
+   */
+  remove(e) {
+    this._world.removeComponent(this, e);
+  }
+  /**
+   * Check if current entity has a component.
+   * @param compType Component name
+   * @returns boolean
+   */
+  has(e) {
+    return this._world.componentManager.hasComponent(this, e);
+  }
+  /**
+   * Get passed component schema of current entity.
+   * @param compType Component name
+   * @returns Return component schema with T(any as default) as type
+   */
+  get(e) {
+    return this._world.componentManager.getComponent(this, e);
+  }
+}
+class l extends h {
+  entityMap = new d();
+  nextId = 0;
+  _world;
+  constructor(e) {
+    super(), this._world = e;
+  }
+  get entities() {
+    return this.entityMap;
+  }
+  create() {
+    const e = this.nextId++, t = new c(this._world, e);
+    return this.entities.add(t), this.emit("create", t), t;
+  }
+  exist(e) {
+    return this.entities.has(e);
+  }
+  size() {
+    return this.entities.size();
+  }
+  destroy(e) {
+    return this.entities.remove(e), this.emit("destroy", e), e;
+  }
+}
+class m extends h {
+  componentSet = /* @__PURE__ */ new Map();
+  world;
+  constructor(e) {
+    super(), this.world = e, this.world.on("entityDestroyed", (t) => {
+      t && t.entity && this.componentSet.get(t.entity.id) && this.componentSet.delete(t.entity.id);
+    });
+  }
+  addComponent(e, t, s) {
+    const i = this.componentSet.get(
+      e.id
+    );
+    i ? i[t] = s : this.componentSet.set(e.id, { [t]: s }), this.emit("add", { entity: e, component: t });
+  }
+  getComponent(e, t) {
+    return this.hasComponent(e, t) ? this.componentSet.get(e.id)[t] : void 0;
+  }
+  hasComponent(e, t) {
+    const s = this.componentSet.get(e.id);
+    return s ? t in s : !1;
+  }
+  removeComponent(e, t) {
+    if (!this.componentSet.get(e.id)) return;
+    const s = this.componentSet.get(e.id);
+    s && s[t] !== void 0 && (delete s[t], Object.keys(s).length === 0 && this.componentSet.delete(e.id), this.emit("remove", { entity: e, component: t }));
+  }
+}
+class a {
+  config;
+  entityMap;
+  world;
+  constructor(e, t) {
+    this.config = e, this.world = t, this.entityMap = new d();
+  }
+  hasComponents(e) {
+    return this.config.include?.every((t) => e.has(t)) && this.config.exclude?.every((t) => !e.has(t));
+  }
+  get entities() {
+    return this.entityMap;
+  }
+  include(...e) {
+    return this.world.include(...e);
+  }
+  exclude(...e) {
+    return this.world.exclude(...e);
+  }
+  _checkExistingEntities() {
+    for (let e of this.entities)
+      this.world.exist(e) || this.entityMap.remove(e);
+  }
+  checkEntities() {
+    for (let e of this.world.entities)
+      e && this.hasComponents(e) && this.entityMap.add(e);
+    this._checkExistingEntities();
+  }
+  static getHash(e) {
+    const t = e.include?.map((n) => n.trim()).filter((n) => n).join("_"), s = e.exclude?.map((n) => n.trim()).filter((n) => n).join("_"), i = "in_" + t + "_out_" + s;
+    let o = 0;
+    for (const n of i)
+      o = (o << 5) - o + n.charCodeAt(0), o |= 0;
+    return o;
+  }
+}
+class p extends h {
+  _startTime = 0;
+  _oldTime = 0;
+  _requestId = 0;
+  running = !1;
+  delta = 0;
+  elapsed = 0;
+  constructor() {
+    super();
+  }
+  _loop() {
+    let e = 0;
+    if (this.running) {
+      const t = performance.now();
+      e = (t - this._oldTime) / 1e3, this._oldTime = t, this.elapsed += e;
+    }
+    this.delta = e, this.emit("update"), this._requestId = requestAnimationFrame(this._loop.bind(this));
+  }
+  start() {
+    this._startTime = performance.now(), this._oldTime = this._startTime, this.elapsed = 0, this.delta = 0, this.running = !0, this._loop();
+  }
+  stop() {
+    this.running = !1, cancelAnimationFrame(this._requestId), this._requestId = 0;
+  }
+}
+let g = new p();
+class f extends h {
+  entityManager;
+  componentManager;
+  systemManager;
+  queries;
+  constructor() {
+    super(), this.entityManager = new l(this), this.componentManager = new m(this), this.systemManager = new u(), this.entityManager.on("create", (e) => {
+      e && this.emit("entityCreated", { entity: e }), this._updateQueries();
+    }), this.entityManager.on("destroy", (e) => {
+      e && this.emit("entityDestroyed", { entity: e }), this._updateQueries();
+    }), this.componentManager.on(
+      "add",
+      (e) => {
+        this.emit("componentAdded", {
+          entity: e.entity,
+          component: e.component
+        }), this._updateQueries();
+      }
+    ), this.componentManager.on(
+      "remove",
+      (e) => {
+        this.emit("componentRemoved", {
+          entity: e.entity,
+          component: e.component
+        }), this._updateQueries();
+      }
+    ), this.queries = /* @__PURE__ */ new Map();
+  }
+  get entities() {
+    return this.entityManager.entities;
+  }
+  query(e) {
+    const t = a.getHash(e);
+    let i = this.queries.get(t);
+    return i || (i = new a(e, this), this.queries.set(t, i), this._updateQueries()), i;
+  }
+  _updateQueries() {
+    this.queries.forEach((e) => e.checkEntities());
+  }
+  exist(e) {
+    return this.entityManager.exist(e);
+  }
+  include(...e) {
+    return this.query({ include: e, exclude: [] });
+  }
+  exclude(...e) {
+    return this.query({ include: [], exclude: e });
+  }
+  create() {
+    return this.entityManager.create();
+  }
+  destroy(e) {
+    this.entityManager.destroy(e);
+  }
+  addSystem(e) {
+    this.systemManager.addSystem(e);
+  }
+  removeSystem(e) {
+    this.systemManager.removeSystem(e);
+  }
+  addComponent(e, t, s) {
+    this.componentManager.addComponent(e, t, s);
+  }
+  removeComponent(e, t) {
+    this.componentManager.removeComponent(e, t);
+  }
+  update() {
+    this.systemManager.systemList.forEach((e) => {
+      e.update();
+    }), this.emit("updated");
+  }
+}
+export {
+  m as ComponentManager,
+  l as EntityManager,
+  h as EventRegistry,
+  a as Query,
+  d as SparseSet,
+  u as SystemManager,
+  g as Time,
+  f as World
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@jael-ecs/core",
+  "version": "1.0.0",
+  "description": "Entity Component System library with typescript",
+  "keywords": [
+    "ecs",
+    "ts"
+  ],
+  "homepage": "https://github.com/cammyb1/jael#readme",
+  "bugs": {
+    "url": "https://github.com/cammyb1/jael/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cammyb1/jael.git"
+  },
+  "main": "./dist/jael-build.cjs",
+  "module": "./dist/jael-build.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "author": "cammyb1",
+  "type": "module",
+  "files": [
+    "dist/**",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "typescript": "~5.9.3",
+    "unplugin-dts": "^1.0.0-beta.6",
+    "vite": "^7.2.4"
+  }
+}