@woosh/meep-engine 2.165.6 → 2.165.7

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

@@ -1,41 +1,228 @@
-import {EntityComponentDataset} from "./EntityComponentDataset";
-
-interface Type<T> extends Function {
-    new(...args: any[]): T;
-}
-
-export default class Entity {
-    public id: number;
-
-    add<T>(component: T): Entity
-
-    removeComponent<T>(componentType: Type<T>): T | null
-
-    removeAllComponents(): void
-
-    getComponent<T>(componentType: Type<T>): T | null
-
-    getComponentSafe<T>(componentType: Type<T>): T
-
-    hasComponent<T>(componentType: Type<T>): boolean
-
-    build(dataset: EntityComponentDataset): number
-
-    destroy(): boolean
-
-    public readonly isBuilt: boolean
-
-    sendEvent(eventName: string, event?: any): void
-
-    addEventListener(eventName: string, listener: (data?: any) => void, context?: any): Entity
-
-    removeEventListener(eventName: string, listener: (data?: any) => void, context?: any): Entity
-
-    static readFromDataset(entity: number, dataset: EntityComponentDataset): Entity
-
-    getFlag(flag: number): boolean
-
-    setFlag(flag: number, value: number): void
-
-    readonly isEntity:boolean
-}
+/**
+ * Representation of an entity, helps build entities and keep track of them without having to access {@link EntityComponentDataset} directly
+ *
+ *
+ * @example
+ * const entity = new Entity();
+ *
+ * // Add components to the entity.
+ * entity.add(new Position(10, 20));
+ * entity.add(new Velocity(1, 2));
+ *
+ * // Get a component (would return null if the entity doesn't have it).
+ * const position = entity.getComponent(Position); // { x:10, y:20 }
+ *
+ * // Remove a component.
+ * entity.removeComponent(Velocity);
+ *
+ * // To actually use the entity in a game, you need to build it using an EntityComponentDataset.
+ * const dataset = new EntityComponentDataset(); // You would typically have one already
+ *
+ * entity.build(dataset); // add entity with the components to the scene
+ *
+ * // ... Once entity is no longer needed, we destroy it
+ * entity.destroy();
+ *
+ * @see {@link EntityComponentDataset}
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class Entity {
+    /**
+     * Extract data about an entity and its components from a dataset.
+     * Note that this behaves the same way as if you first created the {@link Entity} and then called {@link build} on it, just the other way around.
+     *
+     * @example
+     *  const ecd:EntityComponentDataset = ...;
+     *  const entity_id = 7;
+     *  const entity:Entity = Entity.readFromDataset(entity_id, ecd);
+     *
+     * @param {number} entity
+     * @param {EntityComponentDataset} dataset
+     * @returns {Entity}
+     */
+    static readFromDataset(entity: number, dataset: EntityComponentDataset): Entity;
+    /**
+     * Reference to the entity in a dataset. Do not modify directly.
+     * Only valid when the entity is built, check with {@link isBuilt}.
+     * @readonly
+     * @type {EntityReference}
+     */
+    readonly reference: EntityReference;
+    /**
+     * ID of the entity. Shortcut to {@link reference.id}
+     * @returns {number}
+     */
+    get id(): number;
+    /**
+     * Entity's generation tag. Shortcut to {@link reference.generation}
+     * @returns {number}
+     */
+    get generation(): number;
+    /**
+     * Components associated with the entity. Do not modify directly
+     * @readonly
+     * @type {Array}
+     */
+    readonly components: any[];
+    /**
+     * Dataset in which this entity exists, if built. If not built - null.
+     * Do not modify directly.
+     * @type {EntityComponentDataset}
+     * @see {@link build}
+     * @see {@link destroy}
+     */
+    dataset: EntityComponentDataset;
+    /**
+     * Do not modify directly unless you understand the consequences of doing so.
+     * @type {EntityFlags|number}
+     */
+    flags: EntityFlags | number;
+    /**
+     * Arbitrary user data, add anything you want here.
+     * @readonly
+     * @type {Object}
+     */
+    readonly properties: any;
+    /**
+     * @readonly
+     */
+    readonly on: {
+        /**
+         * Fired when {@link build} is called
+         */
+        built: Signal;
+    };
+    /**
+     *
+     * @param {number|EntityFlags} value
+     */
+    setFlag(value: number | EntityFlags): void;
+    /**
+     *
+     * @param {number|EntityFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag: number | EntityFlags): boolean;
+    /**
+     *
+     * @param {number|EntityFlags} flag
+     */
+    clearFlag(flag: number | EntityFlags): void;
+    /**
+     * True is the entity is currently attached to a dataset. When this is `true`, {@link dataset} property will be set as well.
+     * @readonly
+     * @returns {boolean}
+     * @see {@link build}
+     * @see {@link destroy}
+     *
+     */
+    readonly get isBuilt(): boolean;
+    /**
+     * Remove all components from the entity
+     */
+    removeAllComponents(): void;
+    /**
+     * Number of attached components
+     * @return {number}
+     */
+    get count(): number;
+    /**
+     * Note that this is live-edit, if the {@link Entity} is built - component will be added to the dataset as well.
+     *
+     * @template T class of the component
+     * @param {T} component_instance
+     * @returns {Entity}
+     */
+    add<T>(component_instance: T): Entity;
+    /**
+     * Check if a component of a given type is present on this entity.
+     * @template T
+     * @param {T} klass type of the component
+     * @returns {boolean}
+     */
+    hasComponent<T_1>(klass: T_1): boolean;
+    /**
+     * @template T
+     * @param {Class<T>} klass type of the component
+     * @returns {T|null} component of specified class
+     */
+    getComponent<T_2>(klass: Class<T_2>): T_2;
+    /**
+     * Similar to {@link #getComponent}, instead of returning null - throws an exception
+     * @template T
+     * @param {Class<T>} klass
+     * @returns {T}
+     */
+    getComponentSafe<T_3>(klass: Class<T_3>): T_3;
+    /**
+     * Note that this is live-edit, if the {@link Entity} is built - component will be removed from the dataset as well.
+     * @param {function} klass
+     * @returns {*|null}
+     */
+    removeComponent(klass: Function): any | null;
+    /**
+     *
+     * @param {string} eventName
+     * @param {*} [event]
+     */
+    sendEvent(eventName: string, event?: any): void;
+    /**
+     *
+     * @param {string} eventName
+     */
+    promiseEvent(eventName: string): Promise<any>;
+    /**
+     *
+     * @param {string} eventName
+     * @param {function} listener
+     * @param {*} [context]
+     * @returns {Entity}
+     */
+    addEventListener(eventName: string, listener: Function, context?: any): Entity;
+    /**
+     *
+     * @param {string} eventName
+     * @param {function} listener
+     * @param {*} [context]
+     * @returns {Entity}
+     */
+    removeEventListener(eventName: string, listener: Function, context?: any): Entity;
+    /**
+     * Removes built entity from the {@link EntityManager}.
+     * Note that the destroyed {@link Entity} can be later re-built.
+     * @returns {boolean} true if entity was destroyed, false if entity was not built
+     * @see {@link build}
+     * @see {@link isBuilt}
+     */
+    destroy(): boolean;
+    /**
+     * Builds entity in the given dataset.
+     *
+     * @example
+     *  const ecd:EntityComponentDataset = ...;
+     *  const entity:Entity = new Entity();
+     *  entity.add(new Position(10, 20));
+     *  entity.add(new Velocity(1, 2));
+     *  const entity_id = entity.build(ecd);
+     *
+     * @returns {number} entity ID
+     * @param {EntityComponentDataset} dataset
+     * @see {@link destroy}
+     * @see {@link isBuilt}
+     *
+     */
+    build(dataset: EntityComponentDataset): number;
+    /**
+     * Useful for a faster alternative to `instanceof` checks
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isEntity: boolean;
+    #private;
+}
+export default Entity;
+import { EntityReference } from "./EntityReference.js";
+import { EntityFlags } from "./EntityFlags.js";
+import Signal from "../../core/events/signal/Signal.js";
+//# sourceMappingURL=Entity.d.ts.map

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

@@ -1,17 +1,43 @@
-import Entity from "./Entity";
-
-interface Type<T> extends Function {
-    new(...args: any[]): T;
-}
-
-export class EntityBlueprint {
-    static from(components: any[]): EntityBlueprint
-
-    add<T>(component: T): void
-
-    addJSON<T>(klass: Type<T>, json: any): void
-
-    clear(): void
-
-    build(seed?: object): Entity
-}
+/**
+ * Template for instantiating entities
+ * @class
+ */
+export class EntityBlueprint {
+    /**
+     *
+     * @param {Array} components
+     * @returns {EntityBlueprint}
+     */
+    static from(components?: any[]): EntityBlueprint;
+    /**
+     * @param {Object} json
+     * @param {ModuleRegistry} registry
+     */
+    static fromJSON(json: any, registry: ModuleRegistry): EntityBlueprint;
+    /**
+     *
+     * @param {Object} component
+     */
+    add(component: any): void;
+    clear(): void;
+    /**
+     * @template T
+     * @param {Class<T>} klass
+     * @param {Object} json
+     */
+    addJSON<T>(klass: Class<T>, json: any): void;
+    /**
+     *
+     * @param {Object} json
+     * @param {ModuleRegistry} registry
+     */
+    fromJSON(json: any, registry: ModuleRegistry): void;
+    /**
+     * @param {object} [templateSeed]
+     * @return {Entity}
+     */
+    build(templateSeed?: object): Entity;
+    #private;
+}
+import Entity from "./Entity.js";
+//# sourceMappingURL=EntityBlueprint.d.ts.map