@woosh/meep-engine 2.165.6 → 2.165.7

package/src/engine/ecs/EntityComponentDataset.d.ts

@@ -1,60 +1,580 @@
-import Signal from "../../core/events/signal/Signal";
-
-interface Type<T> extends Function {
-    new(...args: any[]): T;
-}
-
-export class EntityComponentDataset implements Iterable<number> {
-    readonly onEntityCreated: Signal<number>
-    readonly onEntityRemoved: Signal<number>
-
-    hasComponent<T>(entity: number, component: Type<T>): boolean
-
-    getComponent<T>(entity: number, component: Type<T>): T | undefined
-
-    getComponentSafe<T>(entity: number, component: Type<T>): T
-
-    getComponentByIndex<T>(entity: number, componentIndex: number): T | undefined
-
-    addComponentToEntity<T>(entityIndex: number, componentInstance: T): void
-
-    removeComponentFromEntity<T>(entityIndex: number, klass: Type<T>): void
-
-    setComponentTypeMap(types: any[]): void
-
-    getComponentTypeMap(): (Type<any> & { typeName?: string })[]
-
-    getComponentClassByName<T>(name: string): Type<T> | null
-
-    getAnyComponent<T>(type: Type<T>): { entity: number, component: T | null }
-
-    computeComponentTypeIndex<T>(type: Type<T>): number
-
-    registerComponentType<T>(componentType: Type<T>): boolean
-
-    registerManyComponentTypes(componentTypes: Type<any>[]): boolean
-
-    createEntity(): number
-
-    createEntitySpecific(entityId: number): void
-
-    removeEntity(entityIndex: number): boolean
-
-    removeEntities(entityIndices: number[]): void
-
-    entityExists(entityIndex: number): boolean
-
-    traverseEntities(classes: any[], visitor: (...params: any) => boolean, thisArg?: any): void
-
-    traverseComponents<T>(klass: Type<T>, visitor: (component: T, entity: number) => boolean, thisArg?: any): void
-
-    addEntityEventListener<T>(entity: number, eventName: string, listener: (event: T, entity: number) => any, thisArg?: any): void
-
-    removeEntityEventListener<T>(entity: number, eventName: string, listener: (event: T, entity: number) => any, thisArg?: any): boolean
-
-    sendEvent<T>(entity: number, name: string, event?: T): void
-
-    isEmpty(): boolean
-
-    getEntityGeneration(entity: number): number
-}
+/**
+ * Represents a storage for entities and their associated components.
+ * Entities are just integer IDs and components are stored in a virtual table, where each component type has a separate column and each entity is a row in that table.
+ * It is valid for entities to have no components or to have every possible component.
+ * The entity IDs are compacted, meaning that when an entity is removed - its ID can later be reused.
+ * Typically, you would use {@link Entity} helper class instead of working directly with the dataset as it offers a higher-level API.
+ *
+ * Designed to handle millions of objects at the same time.
+ * @implements {Iterable<number>} iterate over the entity IDs
+ * @example
+ *   const ecd = new EntityComponentDataset();
+ *
+ *   const entityId = ecd.createEntity(); // create an entity
+ *
+ *   ecd.addComponentToEntity(entityId, myComponentInstance); // add a component to your entity
+ *
+ *   // ... once no longer needed, destroy the entity
+ *   ecd.removeEntity(entityId);
+ *
+ * @see https://en.wikipedia.org/wiki/Entity_component_system
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class EntityComponentDataset implements Iterable<number> {
+    /**
+     * Set a bit at index of an entity if index is used, unset otherwise
+     * @private
+     * @type {BitSet}
+     */
+    private entityOccupancy;
+    /**
+     * For each entity ID records generation when entity was created
+     * Values are invalid for unused entity IDs
+     * @private
+     * @type {Uint32Array}
+     */
+    private entityGeneration;
+    /**
+     * Bit table, if a bit is set - that means component is present.
+     * The format is
+     *      entity_0: [component_0, component_1, ... component_n]
+     *      entity_1: [component_0, component_1, ... component_n]
+     *       ...
+     *      entity_n: [component_0, component_1, ... component_n]
+     * @private
+     * @type {BitSet}
+     */
+    private componentOccupancy;
+    /**
+     * Do not modify directly.
+     * Use {@link setComponentTypeMap} instead.
+     * @private
+     * @type {Class[]}
+     */
+    private componentTypeMap;
+    /**
+     * Fast index lookup from a component class
+     * @type {Map<Class, number>}
+     * @private
+     */
+    private __type_to_index_map;
+    /**
+     * How many component types exist for this collection. This is the same as componentMap.length
+     * @private
+     * @type {number}
+     */
+    private componentTypeCount;
+    /**
+     * 2d array of following structure: components[component_index][entity_index].
+     * @private
+     * @type {Object[][]}
+     */
+    private components;
+    /**
+     * Current number of entities
+     * @private
+     * @type {number}
+     */
+    private entityCount;
+    /**
+     * A counter that is incremented every time an entity is created
+     * Generation is used to provide an entity with a unique identity
+     * Entity IDs are re-used, but generation is always increasing
+     * Two entities with the same ID but different generation represent two distinct entities, one with "younger" generation (larger number) is the more recently created one
+     * @private
+     * @type {number}
+     */
+    private generation;
+    /**
+     * @readonly
+     * @type {Signal<number>}
+     */
+    readonly onEntityCreated: any;
+    /**
+     * @readonly
+     * @type {Signal<number>}
+     */
+    readonly onEntityRemoved: any;
+    /**
+     *
+     * @type {Array<Object<SignalHandler[]>>}
+     * @private
+     */
+    private __entityEventListeners;
+    /**
+     *
+     * @type {SignalHandler[][]}
+     * @private
+     */
+    private __entityAnyEventListeners;
+    /**
+     * @private
+     * @type {Array<Array<EntityObserver>>}
+     */
+    private observers;
+    /**
+     * returns a promise of a component instance based on a given type
+     * @template T, R
+     * @param {int} entity
+     * @param {T} component_type
+     * @returns {Promise<R>}
+     */
+    promiseComponent<T, R>(entity: int, component_type: T): Promise<R>;
+    /**
+     *
+     * @param {EntityObserver} observer
+     * @param {boolean} [immediate=false] whenever pre-existing matches should be processed
+     * @returns {boolean}
+     */
+    addObserver(observer: EntityObserver, immediate?: boolean): boolean;
+    /**
+     *
+     * @param {EntityObserver} observer
+     * @param {boolean} [immediate=false] if flag set, matches will be broken after observer is removed
+     * @returns {boolean}
+     */
+    removeObserver(observer: EntityObserver, immediate?: boolean): boolean;
+    /**
+     *
+     * @returns {number}
+     */
+    getEntityCount(): number;
+    /**
+     *
+     * @returns {number}
+     */
+    getComponentTypeCount(): number;
+    /**
+     * Convenience method for retrieving a collection of components for a given entity
+     * @param {number} entity ID of the entity
+     * @param {[]} component_classes Classes of components to extract
+     * @returns {Array}
+     */
+    getComponents(entity: number, component_classes: []): any[];
+    /**
+     *
+     * @param {[]} output
+     * @param {number} output_offset
+     * @param {number} entity_id
+     * @returns {number} how many components were written to the output
+     * @see getAllComponents
+     */
+    readEntityComponents(output: [], output_offset: number, entity_id: number): number;
+    /**
+     * Get all components associated with a given entity.
+     * Note that this method allocates. If performance is important - prefer alternatives.
+     * Prefer to use {@link readEntityComponents} for performance reasons.
+     * @param {number} entity_id
+     * @returns {[]} all components attached to the entity, array is not compacted
+     * @see readEntityComponents
+     */
+    getAllComponents(entity_id: number): [];
+    /**
+     * Modify dataset component mapping. Algorithm will attempt to mutate dataset even if entities exist, however, it will not remove component classes for which instances exist in the dataset.
+     * @param {Class[]} map collection of component classes
+     * @returns {void}
+     * @throws Error when attempting to remove component classes with live instances
+     */
+    setComponentTypeMap(map: Class[]): void;
+    /**
+     *
+     * @param {Class[]} types
+     * @returns {boolean} true if all types are present, false otherwise
+     */
+    areComponentTypesRegistered(types: Class[]): boolean;
+    /**
+     * Does this dataset have a given component registered?
+     * Use {@link registerComponentType}/{@link unregisterComponentType} to alter registered set
+     * @param {Class|Function} type
+     * @return {boolean}
+     */
+    isComponentTypeRegistered(type: Class | Function): boolean;
+    /**
+     *
+     * @returns {Class[]}
+     */
+    getComponentTypeMap(): Class[];
+    /**
+     *
+     * @param {Class[]} types
+     * @returns {boolean} false if no new classes were added, true if at least one new class was added
+     */
+    registerManyComponentTypes(types: Class[]): boolean;
+    /**
+     * Attempt to add a component class to dataset registry
+     * @param {Class|Function} type
+     * @returns {boolean} true if component successfully added, false if component is already registered
+     */
+    registerComponentType(type: Class | Function): boolean;
+    /**
+     * Attempt to remove a component class from the registry
+     * @param {Class} type
+     * @returns {boolean} true iff component is removed, false if it was not registered
+     */
+    unregisterComponentType(type: Class): boolean;
+    /**
+     *
+     * @param {number} min_size
+     * @returns {void}
+     */
+    enlargeGenerationTable(min_size: number): void;
+    /**
+     * Produces generation ID for a given entity
+     * NOTE: this method doesn't check for entity's existence, make sure to check that separately if needed
+     * @param {number} entity_id
+     * @returns {number}
+     */
+    getEntityGeneration(entity_id: number): number;
+    /**
+     * @private
+     * @param {number} entity_id
+     * @returns {void}
+     */
+    private createEntityUnsafe;
+    /**
+     *
+     * @returns {number} entityIndex
+     */
+    createEntity(): number;
+    /**
+     *
+     * @param {number} entity_id
+     * @throws {Error} if entity index is already in use
+     * @returns {void}
+     */
+    createEntitySpecific(entity_id: number): void;
+    /**
+     *
+     * @param {number} entityIndex
+     * @returns {boolean}
+     */
+    entityExists(entityIndex: number): boolean;
+    /**
+     *
+     * @param {number} componentIndex
+     * @returns {boolean}
+     */
+    componentIndexExists(componentIndex: number): boolean;
+    /**
+     * Remove entity from the dataset, effectively destroying it from the world
+     * @param {number} entity_id
+     * @returns {boolean} true if entity was removed, false if it doesn't exist
+     */
+    removeEntity(entity_id: number): boolean;
+    /**
+     * Convenience method for removal of multiple entities
+     * Works the same as {@link removeEntity} but for multiple elements
+     * @param {number[]} entity_ids
+     * @returns {void}
+     */
+    removeEntities(entity_ids: number[]): void;
+    /**
+     *
+     * @param {number} entity_id
+     * @param {Class} klass
+     * @returns {void}
+     */
+    removeComponentFromEntity(entity_id: number, klass: Class): void;
+    /**
+     *
+     * @param {number} entity_id
+     * @param {number} component_index
+     * @returns {void}
+     */
+    removeComponentFromEntityByIndex(entity_id: number, component_index: number): void;
+    /**
+     * This method doesn't perform any checks, make sure you understand what you are doing when using it
+     * @private
+     * @param {number} entity_id
+     * @param {number} component_index
+     * @param {number} component_occupancy_index
+     * @returns {void}
+     */
+    private removeComponentFromEntityByIndex_Unchecked;
+    /**
+     * Internally every component class is mapped to an index, this method is used to retrieve such mapping.
+     * @param {Function|Class} klass
+     * @returns {number} integer index, -1 if not found
+     */
+    computeComponentTypeIndex(klass: Function | Class): number;
+    /**
+     * @template T
+     * @param {T} klass
+     * @returns {number}
+     */
+    computeComponentCount<T_1>(klass: T_1): number;
+    /**
+     * Retrieves any instance of a given component.
+     * If no component instances exist - component will be `null` and entity will be `-1`.
+     * Useful for singleton components such as a camera or an audio listener.
+     * @template T
+     * @param {Class<T>} component_type
+     * @returns {{entity:number, component:T}}
+     */
+    getAnyComponent<T_2>(component_type: Class<T_2>): {
+        entity: number;
+        component: T_2;
+    };
+    /**
+     *
+     * Associate a component with a particular entity.
+     * NOTE: An entity can have *AT MOST* one component of a given type.
+     * @template C
+     * @param {number} entity_id
+     * @param {C} component_instance
+     * @returns {void}
+     */
+    addComponentToEntity<C>(entity_id: number, component_instance: C): void;
+    /**
+     * If in doubt, prefer to use {@link addComponentToEntity} instead.
+     * @template C
+     * @param {number} entity_id
+     * @param {number} component_index ordered index of the entity type, matching order in {@link getComponentTypeMap}
+     * @param {C} component_instance
+     * @returns {void}
+     */
+    addComponentToEntityByIndex<C_1>(entity_id: number, component_index: number, component_instance: C_1): void;
+    /**
+     * @template C
+     * @param {number} entity_id
+     * @param {number} component_index
+     * @returns {C|undefined}
+     */
+    getComponentByIndex<C_2>(entity_id: number, component_index: number): C_2;
+    /**
+     * Whether a given entity has a component of the specified class attached
+     * @template C
+     * @param {number} entity_id
+     * @param {Class<C>} klass
+     * @returns {boolean}
+     */
+    hasComponent<C_3>(entity_id: number, klass: Class<C_3>): boolean;
+    /**
+     * @template T
+     * @param {number} entity_id
+     * @param {Class<T>} klass
+     * @returns {T|undefined}
+     */
+    getComponent<T_3>(entity_id: number, klass: Class<T_3>): T_3;
+    /**
+     * Always returns non-null value, if the component is not found - an error is thrown instead
+     * @template C
+     * @param {number} entity_id
+     * @param {Class<C>} klass
+     * @returns {C}
+     * @throws {Error} when component not found
+     */
+    getComponentSafe<C_4>(entity_id: number, klass: Class<C_4>): C_4;
+    /**
+     * same as getComponent when component exists, if component is not associated with the entity, callback will be invoked once when it is added.
+     * @param {Number} entity_id
+     * @param {Class} component_class
+     * @param {function} callback
+     * @param {*} [thisArg]
+     * @returns {void}
+     */
+    getComponentAsync(entity_id: number, component_class: Class, callback: Function, thisArg?: any): void;
+    /**
+     * Performs traversal on a subset of entities which have specified components.
+     * @example
+     *  ecd.traverseEntities(
+     *      [Transform, Renderable, Tag], // Component classes to match
+     *      (transform, renderable, tag, entity ) => {  // actual component instances along with entity ID
+     *          // do something
+     *      }
+     *  );
+     * @param {Array} classes
+     * @param {function(...args):boolean} visitor Visitor can return optional "false" to terminate traversal earlier
+     * @param {object} [thisArg] specifies context object on which callbacks are to be called, optional
+     * @returns {void}
+     */
+    traverseEntities(classes: any[], visitor: (...args: any[][]) => boolean, thisArg?: object): void;
+    /**
+     * Performs traversal on a subset of entities which have only the specified components and no others
+     * @example traverseEntitiesExact([Transform,Renderable,Tag],function(transform, renderable, tag, entity){ ... }, this);
+     * @param {Array.<class>} classes
+     * @param {Function} visitor
+     * @param {Object} [thisArg] specifies context object on which callbacks are to be called, optional
+     * @returns {void}
+     */
+    traverseEntitiesExact(classes: any, visitor: Function, thisArg?: any): void;
+    /**
+     * Traverse all entities with a given component class instance.
+     * @example
+     *  ecd.traverseComponents(Name, n => n.value = `${n.value} the Great`); // turn every name X to "X the Great", like "John" -> "John the Great"
+     *
+     * @template T
+     * @param {Class<T>} klass
+     * @param {function(instance:T, entity:number)} visitor
+     * @param {*} [thisArg=undefined] optional `this` argument for the visitor callback
+     * @returns {void}
+     */
+    traverseComponents<T_4>(klass: Class<T_4>, visitor: any, thisArg?: any): void;
+    /**
+     *
+     * @param {number} component_index
+     * @param {function} visitor
+     * @param {*} [thisArg]
+     * @returns {void}
+     */
+    traverseComponentsByIndex(component_index: number, visitor: Function, thisArg?: any): void;
+    /**
+     * Alternative to {@link __traverseComponentsByIndex_via_property} as of 2020, appears to be significantly slower on Chrome with larger datasets
+     * @private
+     * @param {number} component_index
+     * @param {function} visitor
+     * @param {*} [thisArg]
+     * @returns {void}
+     */
+    private __traverseComponentsByIndex_via_bitset;
+    /**
+     * @private
+     * @param {number} component_index
+     * @param {function} visitor
+     * @param {*} [thisArg]
+     * @returns {void}
+     */
+    private __traverseComponentsByIndex_via_property;
+    /**
+     * @private
+     * @param {number} entity_id
+     * @param {number} component_index
+     * @returns {void}
+     */
+    private processObservers_ComponentAdded;
+    /**
+     * @private
+     * @param {number} entity_id
+     * @param {number} component_index
+     * @returns {void}
+     */
+    private processObservers_ComponentRemoved;
+    /**
+     * Captures all events for a given entity
+     * @param {number} entity
+     * @param {function} listener
+     * @param {*} [thisArg]
+     * @returns {void}
+     *
+     * @see removeEntityAnyEventListener
+     * @see addEntityEventListener
+     */
+    addEntityAnyEventListener(entity: number, listener: Function, thisArg?: any): void;
+    /**
+     * Removed listener attached via {@link #addEntityAnyEventListener}
+     * @param {number} entity
+     * @param {function} listener
+     * @param {*} [thisArg]
+     * @returns {boolean}
+     *
+     * @see addEntityAnyEventListener
+     * @see removeEntityEventListener
+     */
+    removeEntityAnyEventListener(entity: number, listener: Function, thisArg?: any): boolean;
+    /**
+     * Registers an event listener to a specific entity and event type, specified by event_name string.
+     * @param {number} entity
+     * @param {string} event_name
+     * @param {function()} listener
+     * @param {*} [thisArg]
+     * @returns {void}
+     *
+     * @see sendEvent
+     * @see removeEntityEventListener
+     */
+    addEntityEventListener(entity: number, event_name: string, listener: () => any, thisArg?: any): void;
+    /**
+     * Remove existing event listener associated with a specific entity. Does nothing if listener isn't registered.
+     * @param {number} entity
+     * @param {string} event_name
+     * @param {function} listener
+     * @param {*} [thisArg]
+     * @returns {boolean}
+     *
+     * @see addEntityEventListener
+     * @see sendEvent
+     */
+    removeEntityEventListener(entity: number, event_name: string, listener: Function, thisArg?: any): boolean;
+    /**
+     * Notifies every component of specified entity with given event
+     * @param {number} entity
+     * @param {string} name event name
+     * @param {Object} [event=undefined]
+     * @returns {void}
+     * @see addEntityEventListener
+     */
+    sendEvent(entity: number, name: string, event?: any): void;
+    /**
+     *
+     * @param {number} entity_id
+     * @returns {boolean}
+     */
+    entityHasComponents(entity_id: number): boolean;
+    /**
+     * Remove all entities, triggers all relevant removal events for each entity/component
+     * @returns {void}
+     * @see dropData
+     */
+    clear(): void;
+    /**
+     * Drops all data, bypassing standard workflow, no events are dispatched. Data is simply ejected.
+     * This method is very efficient but is intended to be used only when associated data is not needed as it may produce unintended consequences if the data is re-used
+     * @returns {void}
+     * @see clear
+     */
+    dropData(): void;
+    /**
+     * @template T
+     * @param {string} class_name
+     * @returns {null|function|Class<T>}
+     */
+    getComponentClassByName<T_5>(class_name: string): null | Function | Class<T_5>;
+    /**
+     * Copy entities from a supplied input dataset. Only components present in the mask are copied
+     * @param {Array} component_classes
+     * @param {EntityComponentDataset} source
+     * @returns {void}
+     */
+    maskedCopy(source: EntityComponentDataset, component_classes: any[]): void;
+    /**
+     * Main utility of this method is to facilitate serialization.
+     * @param {Array} component_classes
+     * @param {function(componentIndex:number,components:Array, componentCount:number)} visitor
+     * @returns {void}
+     */
+    traverseEntitiesCompactedFiltered(component_classes: any[], visitor: any): void;
+    /**
+     * Tells if dataset has any entities
+     * @returns {boolean}
+     */
+    isEmpty(): boolean;
+    /**
+     * Note that {@link EntityComponentDataset} also implements `Iterable<number>`
+     * @param {function(entityIndex:number)} visitor
+     * @param {*} [thisArg]
+     * @returns {void}
+     */
+    traverseEntityIndices(visitor: any, thisArg?: any): void;
+    /**
+     * Useful for fast type checks that doesn't require an import
+     * `x.isEntityComponentDataset === true` vs `x instanceof EntityComponentDataset`
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isEntityComponentDataset: boolean;
+    /**
+     * @deprecated use [Symbol.iterator] directly instead
+     */
+    createEntityIterator: () => Generator<number>;
+    /**
+     * @deprecated use {@link removeEntityAnyEventListener} directly instead
+     */
+    removeAnyEventListener: (entity: number, listener: Function, thisArg?: any) => boolean;
+    /**
+     * Iterate over all entities
+     * @return {Generator<number>}
+     */
+    [Symbol.iterator](): Generator<number>;
+}
+//# sourceMappingURL=EntityComponentDataset.d.ts.map

package/src/engine/ecs/EntityComponentDataset.d.ts.map

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