@funderforge/ecs 0.1.0

package/dist/component.js

@@ -0,0 +1,176 @@
+/**
+ * Abstract base class for components that can be attached to entities.
+ * Components provide functionality to entities and can respond to lifecycle events through virtual methods.
+ *
+ * Key features:
+ * - Belongs to exactly one entity
+ * - Method-based architecture with `onTick` and `onEnabledChanged` virtual methods
+ * - Enabled/disabled state that respects entity state
+ * - Automatic registration with the entity upon construction
+ *
+ * @example
+ * ```typescript
+ * class TransformComponent extends Component {
+ *   x = 0;
+ *   y = 0;
+ *
+ *   protected onTick(deltaTime: number): void {
+ *     // Update position based on deltaTime
+ *   }
+ * }
+ *
+ * const entity = new Entity({ id: 'player' });
+ * const transform = new TransformComponent(entity);
+ * ```
+ */
+export default class Component {
+    /** The entity this component belongs to. Set automatically during construction and cannot be changed. */
+    entity;
+    _enabledSelf;
+    /**
+     * Whether to add this component to the entity's type map for optimized lookups.
+     *
+     * - `false` (default): Component is NOT added to the type map. Lookups will fall back to iteration, which is slower
+     *   but avoids the overhead of maintaining the map for components that are rarely looked up by type.
+     * - `true`: Component is added to the type map, enabling fast O(1) lookups via `entity.getComponentByType()`.
+     *
+     * @default false
+     */
+    precacheTypeLookup;
+    /**
+     * Creates a new Component instance and attaches it to the specified entity.
+     * The component is automatically registered with the entity and cannot be moved to another entity.
+     *
+     * @param entity - The entity this component belongs to. Required and cannot be changed after construction.
+     * @param preset - Optional configuration object for the component.
+     * @param preset.enabledSelf - Whether the component is enabled by default. Defaults to `true`.
+     * @param preset.precacheTypeLookup - Whether to add this component to the entity's type map for optimized lookups.
+     *   Defaults to `false` (component is NOT added to map, uses slower iteration-based lookups). Set to `true` to add
+     *   the component to the map for fast O(1) lookups via `entity.getComponentByType()`.
+     *
+     * @example
+     * ```typescript
+     * class MyComponent extends Component {
+     *   constructor(entity: Entity) {
+     *     super(entity, { enabledSelf: true });
+     *   }
+     * }
+     *
+     * const entity = new Entity({ id: 'entity' });
+     * const component = new MyComponent(entity);
+     *
+     * // Component is NOT added to type map by default (slower lookups)
+     * const found = entity.getComponentByType(MyComponent);
+     *
+     * // Add to type map for components frequently looked up by type (fast lookups)
+     * const transform = new TransformComponent(entity, { precacheTypeLookup: true });
+     * const foundTransform = entity.getComponentByType(TransformComponent); // Fast O(1) lookup
+     * ```
+     */
+    constructor(entity, preset = {}) {
+        this._enabledSelf = preset.enabledSelf ?? true;
+        this.precacheTypeLookup = preset.precacheTypeLookup ?? false;
+        this.entity = entity;
+        // biome-ignore lint/suspicious/noExplicitAny: Override private guard
+        entity._components.push(this);
+        // Update component type map for optimized lookups
+        if (this.precacheTypeLookup) {
+            // biome-ignore lint/suspicious/noExplicitAny: Override private guard
+            const map = entity._componentMap;
+            const ctor = this.constructor;
+            // make sure the component is not already in the map
+            if (!map.has(ctor)) {
+                map.set(ctor, this);
+            }
+        }
+    }
+    /**
+     * Gets whether this component itself is enabled, independent of its entity's state.
+     * @returns `true` if this component is enabled, `false` otherwise.
+     */
+    get enabledSelf() {
+        return this._enabledSelf;
+    }
+    /**
+     * Sets whether this component itself is enabled. When the effective enabled state changes (considering both this value and the entity's enabled state),
+     * the `onEnabledChanged` method will be called.
+     * @param value - `true` to enable this component, `false` to disable it.
+     */
+    set enabledSelf(value) {
+        if (value === this._enabledSelf)
+            return;
+        const oldEnabled = this.enabled;
+        this._enabledSelf = value;
+        const enabled = this.enabled;
+        if (enabled !== oldEnabled) {
+            this.onEnabledChanged(enabled);
+        }
+    }
+    /**
+     * Virtual method called when the component is ticked during the entity update cycle.
+     * Override this method in derived classes to implement tick-based logic.
+     * @param deltaTime - The time elapsed since the last tick in milliseconds.
+     */
+    onTick(_deltaTime) { }
+    /**
+     * Virtual method called when the component's effective enabled state changes.
+     * Override this method in derived classes to respond to enabled state changes.
+     * @param newValue - The new effective enabled state of the component.
+     */
+    onEnabledChanged(_newValue) { }
+    /**
+     * Gets the effective enabled state of this component, considering both its own `enabledSelf` value and its entity's enabled state.
+     * @returns `true` only if both this component's `enabledSelf` is `true` and its entity's `enabled` is `true`.
+     */
+    get enabled() {
+        return this._enabledSelf && this.entity.enabled;
+    }
+    /**
+     * Destroys this component, removing it from its entity and marking it as "dead".
+     *
+     * After calling `destroy()`, the component is permanently removed from the entity's component list
+     * and its entity reference is cleared. The component should be considered "dead" and must not be
+     * accessed or used in any way after destruction.
+     *
+     * **CRITICAL**: After calling `destroy()`, you must:
+     * - Remove all references to this component from your code
+     * - Never access the component's properties or methods again
+     * - Never call any methods on the component
+     *
+     * Accessing a destroyed component will result in undefined behavior. In non-production builds,
+     * the component object is frozen to help detect misuse.
+     *
+     * @example
+     * ```typescript
+     * const component = new MyComponent(entity);
+     *
+     * // Use the component...
+     * component.doSomething();
+     *
+     * // Destroy the component when no longer needed
+     * component.destroy();
+     *
+     * // IMPORTANT: Remove all references and never access it again
+     * // component = null; // or let it go out of scope
+     * // DO NOT: component.doSomething(); // ❌ WRONG - component is dead
+     * ```
+     */
+    destroy() {
+        // biome-ignore lint/suspicious/noExplicitAny: override private guard
+        const entity = this.entity;
+        if (entity === undefined)
+            return;
+        const idx = entity._components.indexOf(this);
+        entity._components.splice(idx, 1);
+        const map = entity._componentMap;
+        if (map.get(this.constructor) === this) {
+            map.delete(this.constructor);
+        }
+        // biome-ignore lint/suspicious/noExplicitAny: override private guard
+        this.entity = undefined;
+        if (process.env.NODE_ENV !== "production") {
+            Object.freeze(this); // make future misuse obvious
+        }
+    }
+}
+//# sourceMappingURL=component.js.map

package/dist/component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.js","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,OAAO,OAAgB,SAAS;IACtC,yGAAyG;IAChG,MAAM,CAAU;IACjB,YAAY,CAAU;IAE9B;;;;;;;;OAQG;IACM,kBAAkB,CAAU;IAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,YACC,MAAc,EACd,SAAkE,EAAE;QAEpE,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,WAAW,IAAI,IAAI,CAAC;QAC/C,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,IAAI,KAAK,CAAC;QAC7D,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,qEAAqE;QACpE,MAAc,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvC,kDAAkD;QAClD,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC7B,qEAAqE;YACrE,MAAM,GAAG,GAAI,MAAc,CAAC,aAAa,CAAC;YAC1C,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC;YAE9B,oDAAoD;YACpD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACpB,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YACrB,CAAC;QACF,CAAC;IACF,CAAC;IAED;;;OAGG;IACH,IAAI,WAAW;QACd,OAAO,IAAI,CAAC,YAAY,CAAC;IAC1B,CAAC;IAED;;;;OAIG;IACH,IAAI,WAAW,CAAC,KAAc;QAC7B,IAAI,KAAK,KAAK,IAAI,CAAC,YAAY;YAAE,OAAO;QACxC,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC;QAChC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,IAAI,OAAO,KAAK,UAAU,EAAE,CAAC;YAC5B,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAChC,CAAC;IACF,CAAC;IAED;;;;OAIG;IACO,MAAM,CAAC,UAAkB,IAAS,CAAC;IAE7C;;;;OAIG;IACO,gBAAgB,CAAC,SAAkB,IAAS,CAAC;IAEvD;;;OAGG;IACH,IAAI,OAAO;QACV,OAAO,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;IACjD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,OAAO;QACN,qEAAqE;QACrE,MAAM,MAAM,GAAQ,IAAI,CAAC,MAAM,CAAC;QAChC,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO;QAEjC,MAAM,GAAG,GAAG,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7C,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QAElC,MAAM,GAAG,GAAG,MAAM,CAAC,aAAa,CAAC;QACjC,IAAI,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,IAAI,EAAE,CAAC;YACxC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC9B,CAAC;QAED,qEAAqE;QACpE,IAAY,CAAC,MAAM,GAAG,SAAS,CAAC;QAEjC,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,EAAE,CAAC;YAC3C,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,6BAA6B;QACnD,CAAC;IACF,CAAC;CACD"}

package/dist/entity.d.ts

@@ -0,0 +1,222 @@
+import type Component from "./component";
+/**
+ * Represents an entity in a hierarchical tree structure that can contain child entities and components.
+ * Entities form the backbone of the component framework, allowing you to build flexible hierarchies
+ * where each entity can have multiple components attached to it.
+ *
+ * Key features:
+ * - Hierarchical parent-child relationships
+ * - Cascading enabled/disabled state management with caching
+ * - Component attachment and management
+ * - Efficient traversal of entities and components
+ * - Method-based architecture through component virtual methods
+ *
+ * @example
+ * ```typescript
+ * const root = new Entity({ id: 'root' });
+ * const child = new Entity({ id: 'child', parent: root });
+ * root.addChild(child);
+ * ```
+ */
+export default class Entity {
+    private _children;
+    private _parent;
+    private _enabledSelf;
+    private _enabledCache;
+    /** Unique identifier for this entity. Can be a string or number. If not provided in constructor, an auto-incrementing number is assigned. */
+    readonly id: string | number;
+    private static _idCounter;
+    private readonly _components;
+    private readonly _componentMap;
+    /**
+     * Creates a new Entity instance.
+     * @param preset - Optional configuration object for the entity.
+     * @param preset.id - Optional unique identifier. If not provided, an auto-incrementing number is assigned.
+     * @param preset.enabledSelf - Whether the entity is enabled by default. Defaults to `true`.
+     * @param preset.parent - Optional parent entity. If provided, this entity will be added as a child of the parent.
+     *
+     * @example
+     * ```typescript
+     * // Create a root entity with a custom ID
+     * const root = new Entity({ id: 'scene' });
+     *
+     * // Create a child entity with a parent
+     * const child = new Entity({ id: 'player', parent: root, enabledSelf: true });
+     *
+     * // Create an entity that will be auto-assigned an ID
+     * const entity = new Entity();
+     * ```
+     */
+    constructor(preset?: {
+        id?: string;
+        enabledSelf?: boolean;
+        parent?: Entity;
+    });
+    /**
+     * Gets whether this entity itself is enabled, independent of its parent's state.
+     * @returns `true` if this entity is enabled, `false` otherwise.
+     */
+    get enabledSelf(): boolean;
+    /**
+     * Sets whether this entity itself is enabled. When set to `false`, this entity and all its descendants become disabled.
+     * Invalidates the enabled cache for this entity and all descendants, and calls `onEnabledChanged` on affected components.
+     * @param value - `true` to enable this entity, `false` to disable it.
+     */
+    set enabledSelf(value: boolean);
+    /**
+     * Gets the effective enabled state of this entity, considering both its own `enabledSelf` value and all parent entities' enabled states.
+     * The result is cached for performance and automatically invalidated when necessary.
+     * @returns `true` only if this entity's `enabledSelf` is `true` and all parent entities (up to the root) have `enabledSelf` set to `true`.
+     */
+    get enabled(): boolean;
+    /**
+     * Invalidates the enabled cache for this entity and all its descendants.
+     * This is called when enabledSelf changes or when parent changes.
+     * Uses an iterative approach with a stack to avoid potential stack overflow for deep trees.
+     */
+    private _invalidateEnabledCache;
+    /**
+     * Adds a child entity to this entity. If the child already has a parent, it will be removed from its previous parent first.
+     * @param child - The entity to add as a child.
+     */
+    addChild(child: Entity): void;
+    /**
+     * Removes a child entity by its index in the children array. The removed child's parent will be set to `null`.
+     * @param index - The index of the child to remove.
+     */
+    removeChildByIndex(index: number): void;
+    /**
+     * Removes a child entity. The removed child's parent will be set to `null`.
+     * @param child - The child entity to remove.
+     */
+    removeChild(child: Entity): void;
+    /**
+     * Gets the number of direct child entities.
+     * @returns The number of children.
+     */
+    childrenLength(): number;
+    /**
+     * Gets a child entity by its index in the children array.
+     * @template T - The type of entity to return. Defaults to `Entity`.
+     * @param index - The index of the child to retrieve.
+     * @returns The child entity at the specified index, or `undefined` if the index is out of bounds.
+     */
+    childByIdx<T extends Entity = Entity>(index: number): T;
+    /**
+     * Finds the first child entity that matches the given predicate.
+     * @template T - The type of entity to return. Defaults to `Entity`.
+     * @param predicate - A function that returns `true` for the child to find.
+     * @returns The first matching child entity, or `undefined` if no match is found.
+     */
+    getChild<T extends Entity = Entity>(predicate: (child: Entity) => boolean): T;
+    /**
+     * Gets the index of a child entity in the children array.
+     * @param child - The child entity to find the index of.
+     * @returns The index of the child, or `-1` if not found.
+     */
+    indexOfChild(child: Entity): number;
+    /**
+     * Gets all child entities that match the given filter function.
+     * @template T - The type of entity to return. Defaults to `Entity`.
+     * @param filter - A function that returns `true` for children to include.
+     * @returns An array of matching child entities.
+     */
+    getChildren<T extends Entity = Entity>(filter: (child: Entity) => boolean): T[];
+    /**
+     * Traverses the children of this entity and all its descendants using a depth-first approach.
+     * @template T - The type of entity to yield. Defaults to `Entity`.
+     * @param predicate - Optional predicate to filter the children. If provided and returns `true`, the child will be yielded and its descendants will be traversed. If omitted, all children are traversed.
+     * @returns A generator that yields entities in the traversal order.
+     */
+    traverseChildren<T extends Entity = Entity>(predicate?: (child: Entity) => boolean): Generator<T>;
+    /**
+     * Traverses the components of this entity and all its descendants using a pre-order depth-first approach.
+     * Only traverses enabled entities. Components are yielded before their entity's children.
+     * @template T - The type of component to yield. Defaults to `Component`.
+     * @param predicate - Optional predicate to filter the components. If provided and returns `true`, the component will be yielded. If omitted, all components are traversed.
+     * @returns A generator that yields components in the traversal order.
+     */
+    traverseComponents<T extends Component = Component>(predicate?: (component: Component) => boolean): Generator<T>;
+    /**
+     * Sets or clears the parent entity. If setting a new parent, this entity will be removed from its previous parent and added to the new one.
+     * Invalidates the enabled cache when the parent changes.
+     * @param parent - The new parent entity, or `null` to remove the parent.
+     */
+    setParent(parent: Entity | null): void;
+    /**
+     * Gets the parent entity in the hierarchy.
+     * @returns The parent entity, or `null` if this entity has no parent (i.e., it's a root entity).
+     */
+    get parent(): Entity | null;
+    /**
+     * Gets the depth level of this entity in the hierarchy. Root entities have a level of 0.
+     * @returns The number of ancestors (parent entities) in the hierarchy chain.
+     */
+    hierarchyLevel(): number;
+    /**
+     * Gets the number of components attached to this entity.
+     * @returns The number of components.
+     */
+    componentsLength(): number;
+    /**
+     * Gets a component by its index in the components array.
+     * @template T - The type of component to return. Defaults to `Component`.
+     * @param index - The index of the component to retrieve.
+     * @returns The component at the specified index, or `undefined` if the index is out of bounds.
+     */
+    componentByIdx<T extends Component = Component>(index: number): T;
+    /**
+     * Finds the first component that matches the given predicate.
+     * @template T - The type of component to return. Defaults to `Component`.
+     * @param predicate - A function that returns `true` for the component to find.
+     * @returns The first matching component, or `undefined` if no match is found.
+     */
+    getComponent<T extends Component = Component>(predicate: (component: Component) => boolean): T;
+    /**
+     * Finds the first component of the specified type. Uses an optimized type map for fast lookups when available.
+     *
+     * **Performance Note:** Components are only added to the internal type map for optimized lookups when they are
+     * created with `precacheTypeLookup: true`. If a component is created with `precacheTypeLookup: false` (the default),
+     * it will not be in the type map and the lookup will fall back to iterating through all components, which is slower
+     * but avoids the overhead of maintaining the map for components that are rarely looked up by type.
+     *
+     * @template T - The type of component to return.
+     * @param type - The constructor function of the component type to find.
+     * @returns The first matching component of the specified type, or `undefined` if not found.
+     *
+     * @example
+     * ```typescript
+     * class TransformComponent extends Component {}
+     * const entity = new Entity();
+     * // Component is NOT added to type map by default (precacheTypeLookup defaults to false)
+     * const transform = new TransformComponent(entity);
+     * const found = entity.getComponentByType(TransformComponent); // Slower, iterates through components
+     *
+     * // Component is added to type map for fast lookups (precacheTypeLookup: true)
+     * const render = new RenderComponent(entity, { precacheTypeLookup: true });
+     * const foundRender = entity.getComponentByType(RenderComponent); // Fast O(1) lookup
+     * ```
+     */
+    getComponentByType<T extends Component>(type: new (...args: any[]) => T): T | undefined;
+    /**
+     * Gets all components that match the given filter function.
+     * @template T - The type of component to return. Defaults to `Component`.
+     * @param filter - A function that returns `true` for components to include.
+     * @returns An array of matching components.
+     */
+    getComponents<T extends Component = Component>(filter: (component: Component) => boolean): T[];
+    /**
+     * Gets the index of a component in the components array.
+     * @param component - The component to find the index of.
+     * @returns The index of the component, or `-1` if not found.
+     */
+    indexOfComponent(component: Component): number;
+    /**
+     * Ticks this entity and all its descendants, calling `onTick` on all enabled components.
+     * This should ONLY be called from the root of an Entity tree. Will traverse the full depth of the tree.
+     * Disabled entity subtrees and disabled components are skipped during traversal.
+     * @param deltaTime - The time elapsed since the last tick in milliseconds.
+     */
+    protected _tick(deltaTime: number): void;
+}
+//# sourceMappingURL=entity.d.ts.map

package/dist/entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../src/entity.ts"],"names":[],"mappings":"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"}