@draug/engine 1.0.21 → 1.0.23

package/dist/system-jRDSVzc9.d.cts

@@ -0,0 +1,382 @@
+import { Bitmap } from 'bitmap-index';
+
+type ClassType<T> = new (...args: any[]) => T;
+type ComponentType<T extends object = object> = ClassType<T>;
+
+declare enum LogLevel {
+    Debug = 0,
+    Info = 1,
+    Warn = 2,
+    Error = 3
+}
+type LogMessage = () => string;
+interface Logger {
+    debug(message: LogMessage): void;
+    info(message: LogMessage): void;
+    warn(message: LogMessage): void;
+    error(message: LogMessage): void;
+}
+
+declare class ComponentStorage<T extends object> {
+    private bits_;
+    private data_;
+    private entityIds_;
+    private indexMap_;
+    private pool_;
+    private id_;
+    private size_;
+    private cls;
+    constructor(cap: number | undefined, factory: () => T, cls: ClassType<T>);
+    bitmap(): Bitmap;
+    get id(): number;
+    _internalSetId(id: number): number;
+    add(id: number, initFn?: (obj: T) => T): T;
+    remove(id: number): void;
+    get(id: number): T | null;
+    tryGet(id: number): T;
+    writeComponentsToBuf(ids: ReadonlyArray<number>, out: T[]): number;
+    has(id: number): boolean;
+    size(): number;
+    forEach(cb: (id: number) => void): void;
+}
+
+type RegisterComponentStorageOptions<T extends object> = {
+    factory?: () => T;
+};
+type RegisterComponentOptions<T extends object> = RegisterComponentStorageOptions<T>;
+declare class ComponentAlreadyRegisteredError extends Error {
+    constructor(component: ComponentType);
+}
+declare class ComponentsManager {
+    private readonly logger;
+    private maxEntityCount;
+    private readonly storages_;
+    private currId_;
+    private nextId;
+    constructor(logger: Logger, maxEntityCount?: number);
+    register<T extends object>(component: ComponentType<T>, opts?: RegisterComponentOptions<T>): ComponentStorage<T>;
+    private createComponentStore;
+    getStorage<T extends object>(component: ComponentType<T>): ComponentStorage<T>;
+    getComponentId(ctor: ComponentType): number;
+}
+
+type EntityID = number;
+declare class UnregisteredComponentStorageError extends Error {
+    constructor(component: ComponentType);
+}
+declare class EntityMaskNotFoundError extends Error {
+    constructor(id: EntityID);
+}
+declare class EntitiesManager {
+    private readonly logger;
+    private id_;
+    constructor(logger: Logger);
+    private nextId;
+    create(): EntityID;
+}
+declare class EntityRef {
+    private world;
+    id: EntityID;
+    constructor(world: World, id: EntityID);
+    with<T extends ComponentType[], Result extends {
+        [K in keyof T]: InstanceType<T[K]>;
+    }>(...components: T): Result;
+}
+
+declare class EventBuffer<T extends unknown> {
+    private readBuf;
+    private writeBuf;
+    write(event: T): void;
+    /**
+     * Advances the buffer to the next frame.
+     *
+     * Performs a double-buffer flip:
+     * - Promotes all events written during the previous frame (`writeBuf`)
+     *   to be readable in the current frame (`readBuf`).
+     * - Reuses the previous `readBuf` as the new `writeBuf` and clears it
+     *   to collect events for the next frame.
+     *
+     * After calling this method:
+     * - `get()` will return a stable snapshot of events produced in the previous frame.
+     * - `add()` will write into an empty buffer for the current frame.
+     *
+     * Guarantees:
+     * - No events written during the current frame are visible until the next `swap()`.
+     * - Readers observe a consistent, immutable snapshot within a frame.
+     *
+     * Expected to be called exactly once per frame, before system execution.
+    */
+    swap(): void;
+    read(): ReadonlyArray<T>;
+    size(): number;
+}
+type EventKey<T> = symbol & {
+    __type?: T;
+};
+declare function createEventKey<T>(description?: string): EventKey<T>;
+declare class EventBus {
+    private storage;
+    swapAll(): void;
+    getBuffer<T>(key: EventKey<T>): EventBuffer<T>;
+}
+
+type ResourceMetadata = {
+    name: string;
+};
+type ResourceParams = {
+    name: string;
+};
+declare function Resource(params: ResourceParams): ClassDecorator;
+declare function getResourceMetadata(resource: Function): ResourceMetadata;
+declare class ResourcesManager {
+    private readonly logger;
+    private readonly items_;
+    constructor(logger: Logger);
+    insert<T extends object>(type: ClassType<T>, value: T): T;
+    get<T extends object>(type: ClassType<T>): T;
+    getOrInsert<T extends object>(type: ClassType<T>, factory: () => T): T;
+    remove<T>(type: ClassType<T>): void;
+}
+
+type WorldCommand = (world: World) => void;
+type ComponentInitFn<C extends ComponentType> = (component: InstanceType<C>) => void;
+type CreateEntityComponentEntry<T extends ComponentType = ComponentType> = T extends unknown ? [T, ComponentInitFn<T>] : never;
+declare function entry<T extends ComponentType>(component: T, init?: ComponentInitFn<T>): CreateEntityComponentEntry;
+declare class Commands {
+    private readonly world;
+    private readonly logger;
+    private readonly commandsQueue_;
+    constructor(world: World, logger: Logger);
+    add(cmd: WorldCommand): void;
+    flush(world: World): void;
+    createEntity(...entries: CreateEntityComponentEntry[]): number;
+}
+
+type QueryParameters = {
+    include?: ComponentType[];
+    exclude?: ComponentType[];
+    anyOf?: ComponentType[];
+    excludeEntitiesIds?: number[];
+    filter?: (id: number) => boolean;
+};
+declare class QueryManager {
+    private readonly world;
+    private cache;
+    constructor(world: World);
+    get(params: QueryParameters): EntityID[];
+    invalidate(component: ComponentType): void;
+    private getKey;
+    private ids;
+    private collectDeps;
+    private compute;
+    private combineBitmaps;
+    private applyExclusions;
+    private extractIds;
+}
+
+type PluginID = string;
+type PluginConstructor = ClassType<PluginBase>;
+type PluginDependencies = {
+    components?: ComponentType[];
+    resources?: ClassType<any>[];
+    systems?: ClassType<SystemBase>[];
+    plugins?: Array<{
+        plugin: PluginConstructor;
+        version?: string;
+    }>;
+};
+interface PluginMetadata {
+    id?: PluginID;
+    version: string;
+    name: string;
+    dependencies?: PluginDependencies;
+}
+declare function Plugin(metadata: PluginMetadata): ClassDecorator;
+declare function getPluginMetadata(plugin: PluginConstructor): PluginMetadata;
+declare function isPlugin(ctor: Function): boolean;
+declare abstract class PluginBase {
+    onPluginLoad?: () => void;
+    onPluginUnload?: (world: World) => void;
+    onAfterWorldInit?: (world: World) => void;
+}
+declare class PluginError extends Error {
+    constructor(pluginId: PluginConstructor);
+}
+declare class ErrNotAPlugin extends Error {
+    constructor(target: Function);
+}
+declare class ErrMissingPluginMetadata extends Error {
+    constructor(plugin: PluginConstructor);
+}
+declare class ErrUnknownPlugin extends PluginError {
+    constructor(pluginId: PluginConstructor);
+}
+declare class ErrPluginNotInit extends PluginError {
+    constructor(pluginId: PluginConstructor);
+}
+declare class PluginsManager {
+    private readonly logger;
+    private plugins_;
+    private isInitiated_;
+    constructor(logger: Logger);
+    install<T extends PluginConstructor>(plugin: T, ...constructorProps: ConstructorParameters<T>): void;
+    build(): void;
+    /**
+     * @internal
+     */
+    __internal__onAfterWorldInit(world: World): void;
+    getPluginMetadata(plugin: PluginConstructor): PluginMetadata;
+    getPluginInstance<T extends PluginBase>(plugin: ClassType<T>): T;
+}
+
+interface TimeSource {
+    now(): number;
+}
+declare class Clock {
+    private readonly timeSource_;
+    private lastTimeMs_;
+    private ellapsedTime_;
+    private delta_;
+    private readonly time_;
+    constructor(timeSource_: TimeSource);
+    get deltaMs(): number;
+    get ellapsedTime(): number;
+    tick(): void;
+    getTime(): Readonly<Time>;
+}
+type Time = {
+    delta: number;
+    elapsed: number;
+};
+
+type WorldConstructor = {
+    maxEntityCount?: number;
+    logger: Logger;
+};
+declare class World {
+    readonly entities: EntitiesManager;
+    readonly components: ComponentsManager;
+    readonly systems: SystemsManager;
+    readonly events: EventBus;
+    readonly resources: ResourcesManager;
+    readonly commands: Commands;
+    readonly queries: QueryManager;
+    readonly plugins: PluginsManager;
+    private readonly logger;
+    private entityRefs_;
+    private updatesCount_;
+    get updatesCount(): number;
+    constructor(params: WorldConstructor);
+    getEntityRef(id: number): EntityRef;
+    query(params: QueryParameters): number[];
+    removeComponent<T extends object>(ref: EntityRef, component: ComponentType<T>): void;
+    removeComponent<T extends object>(entity: EntityID, component: ComponentType<T>): void;
+    addComponent<T extends object>(id: EntityID, component: ClassType<T>, initFn?: (obj: T) => void): T;
+    addComponent<T extends object>(id: EntityRef, component: ClassType<T>, initFn?: (obj: T) => void): T;
+    update(clock: Clock): void;
+    build(): void;
+}
+
+declare class SystemError extends Error {
+    constructor(target: Function);
+}
+declare class ErrNotASystem extends Error {
+    constructor(target: Function);
+}
+declare class ErrMissingSystemMetadata extends SystemError {
+    constructor(target: SystemCtor);
+}
+declare enum SystemPhase {
+    PRE = 0,
+    MAIN = 1,
+    POST = 2
+}
+type SystemMetadata = {
+    /**
+     * ECS query definition used to select entities for this system execution.
+     *
+     * Determines the iteration set passed to {@link SystemBase.compute}.
+     * The ECS runtime resolves entities based on this query each update.
+     */
+    query: Readonly<QueryParameters>;
+    /**
+     * Explicit list of component types required by the system but not necessarily
+     * part of the iteration query.
+     *
+     * Used for:
+     * - ensuring component storages are initialized in the world
+     * - safe access via `world.components.getStorage`
+     * - dependencies that should not affect entity selection
+     *
+     * This does NOT influence entity iteration; only runtime validation/setup.
+     */
+    requiredComponents: Set<ComponentType>;
+    /**
+     * Systems that must run before this one. Pass constructor arguments
+     * `super(OtherSystemCtor, ...)` to add edges; each listed system is scheduled earlier than
+     * this instance. Used when {@link SystemsManager.build} computes a topological execution order.
+     */
+    computeAfter?: Set<SystemCtor>;
+    phase?: SystemPhase;
+    name: string;
+};
+type SystemDecoratorProps = {
+    query: SystemMetadata['query'];
+    requiredComponents?: ComponentType[];
+    computeAfter?: SystemCtor[];
+    phase?: SystemPhase;
+    name: SystemMetadata['name'];
+};
+declare function System(props: SystemDecoratorProps): ClassDecorator;
+declare function getSystemMetadata(system: SystemCtor): SystemMetadata;
+declare function isSystem(ctor: Function): boolean;
+type SystemCtor<T extends SystemBase = SystemBase> = ClassType<T>;
+/**
+ * Arguments passed to {@link SystemBase.compute} on each {@link SystemsManager.update} call.
+ */
+type SystemComputeContext = {
+    /** Entity IDs from the query for this {@link SystemBase.compute} invocation. */
+    readonly entities: number[];
+    /** ECS world instance. */
+    readonly world: World;
+    /** Delta time (seconds or your engine's convention) since the previous update. */
+    readonly time: Time;
+    /** Logger instance for debugging and diagnostics. */
+    readonly logger: Logger;
+};
+type SystemInitContext = {
+    world: World;
+    logger: Logger;
+};
+/**
+ * Base class for ECS systems executed by {@link SystemsManager}.
+ *
+ * Subclasses declare which components they iterate over (`queryComponents`), which component
+ * types must exist in the world for registration (`requiredComponents`), and optional ordering
+ * relative to other systems (`computeAfter` / `super(OtherSystem)`).
+ */
+declare abstract class SystemBase {
+    /**
+     * Logic for one systems pass: run for all entities in {@link SystemComputeContext.entities}.
+     */
+    abstract compute(ctx: SystemComputeContext): void;
+    onInit?(ctx: SystemInitContext): void;
+}
+declare class SystemsManager {
+    private readonly world;
+    private readonly logger;
+    private systems_;
+    private executionOrder_;
+    private requiredComponents_;
+    private dirty_;
+    constructor(world: World, logger: Logger);
+    getRequiredComponents(): Set<ComponentType>;
+    register<T extends SystemBase>(sys: T): void;
+    build(): void;
+    private rebuild;
+    get<T extends SystemBase>(ctor: SystemCtor<T>): T;
+    update(time: Time): void;
+    private buildSystemsArray;
+}
+
+export { PluginsManager as A, type ResourceMetadata as B, Clock as C, ResourcesManager as D, EntitiesManager as E, SystemBase as F, type SystemComputeContext as G, SystemError as H, type SystemInitContext as I, SystemPhase as J, SystemsManager as K, type Logger as L, type WorldCommand as M, createEventKey as N, entry as O, Plugin as P, getPluginMetadata as Q, Resource as R, System as S, type TimeSource as T, UnregisteredComponentStorageError as U, getResourceMetadata as V, World as W, getSystemMetadata as X, isPlugin as Y, isSystem as Z, type ClassType as a, Commands as b, ComponentAlreadyRegisteredError as c, type ComponentInitFn as d, ComponentStorage as e, type ComponentType as f, ComponentsManager as g, type CreateEntityComponentEntry as h, type EntityID as i, EntityMaskNotFoundError as j, EntityRef as k, ErrMissingPluginMetadata as l, ErrMissingSystemMetadata as m, ErrNotAPlugin as n, ErrNotASystem as o, ErrPluginNotInit as p, ErrUnknownPlugin as q, EventBuffer as r, EventBus as s, LogLevel as t, type LogMessage as u, PluginBase as v, type PluginDependencies as w, PluginError as x, type PluginID as y, type PluginMetadata as z };