@codehz/ecs 0.3.7 → 0.3.8

package/multi-map.d.ts

@@ -1,19 +0,0 @@
-declare class MultiMap<K, V> {
-    private map;
-    private _valueCount;
-    get valueCount(): number;
-    get keyCount(): number;
-    hasKey(key: K): boolean;
-    has(key: K, value?: V): boolean;
-    add(key: K, value: V): void;
-    remove(key: K, value: V): boolean;
-    deleteKey(key: K): boolean;
-    get(key: K): Set<V>;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-    entries(): IterableIterator<[K, V]>;
-    clear(): void;
-}
-export { MultiMap };
-export type { MultiMap as MultiMapType };

package/query-filter.d.ts

@@ -1,21 +0,0 @@
-import { Archetype } from "./archetype";
-import type { EntityId } from "./entity";
-/**
- * Filter options for queries
- */
-export interface QueryFilter {
-    negativeComponentTypes?: EntityId<any>[];
-}
-/**
- * Serialize a QueryFilter into a deterministic string suitable for cache keys.
- * Currently only serializes `negativeComponentTypes`.
- */
-export declare function serializeQueryFilter(filter?: QueryFilter): string;
-/**
- * Check if an archetype matches the given component types
- */
-export declare function matchesComponentTypes(archetype: Archetype, componentTypes: EntityId<any>[]): boolean;
-/**
- * Check if an archetype matches the filter conditions (only filtering logic)
- */
-export declare function matchesFilter(archetype: Archetype, filter: QueryFilter): boolean;

package/query.d.ts

@@ -1,80 +0,0 @@
-import { Archetype } from "./archetype";
-import type { EntityId } from "./entity";
-import { type QueryFilter } from "./query-filter";
-import type { ComponentTuple, ComponentType } from "./types";
-import type { World } from "./world";
-/**
- * Query class for efficient entity queries with cached archetypes
- */
-export declare class Query {
-    private world;
-    private componentTypes;
-    private filter;
-    private cachedArchetypes;
-    private isDisposed;
-    constructor(world: World<any[]>, componentTypes: EntityId<any>[], filter?: QueryFilter);
-    /**
-     * Get all entities matching the query
-     */
-    getEntities(): EntityId[];
-    /**
-     * Get entities with their component data
-     * @param componentTypes Array of component types to retrieve
-     * @returns Array of objects with entity and component data
-     */
-    getEntitiesWithComponents<const T extends readonly ComponentType<any>[]>(componentTypes: T): Array<{
-        entity: EntityId;
-        components: ComponentTuple<T>;
-    }>;
-    /**
-     * Iterate over entities with their component data
-     * @param componentTypes Array of component types to retrieve
-     * @param callback Function called for each entity with its components
-     */
-    forEach<const T extends readonly ComponentType<any>[]>(componentTypes: T, callback: (entity: EntityId, ...components: ComponentTuple<T>) => void): void;
-    /**
-     * Iterate over entities with their component data (generator)
-     * @param componentTypes Array of component types to retrieve
-     */
-    iterate<const T extends readonly ComponentType<any>[]>(componentTypes: T): IterableIterator<[EntityId, ...ComponentTuple<T>]>;
-    /**
-     * Get component data arrays for all matching entities
-     * @param componentType The component type to retrieve
-     * @returns Array of component data for all matching entities
-     */
-    getComponentData<T>(componentType: EntityId<T>): T[];
-    /**
-     * Update the cached archetypes
-     * Called when new archetypes are created
-     */
-    updateCache(): void;
-    /**
-     * Check if a new archetype matches this query and add to cache if it does
-     */
-    checkNewArchetype(archetype: Archetype): void;
-    /**
-     * Remove an archetype from the cached archetypes
-     */
-    removeArchetype(archetype: Archetype): void;
-    /**
-     * Dispose the query and disconnect from world
-     */
-    /**
-     * Request disposal of this query.
-     * This will decrement the world's reference count for the query.
-     * The query will only be fully disposed when the ref count reaches zero.
-     */
-    dispose(): void;
-    /**
-     * Internal full dispose called by World when refCount reaches zero.
-     */
-    _disposeInternal(): void;
-    /**
-     * Symbol.dispose implementation for automatic resource management
-     */
-    [Symbol.dispose](): void;
-    /**
-     * Check if the query has been disposed
-     */
-    get disposed(): boolean;
-}

package/system-scheduler.d.ts

@@ -1,25 +0,0 @@
-import type { System } from "./system";
-/**
- * System Scheduler for managing system dependencies and execution order
- */
-export declare class SystemScheduler<UpdateParams extends any[] = []> {
-    private systems;
-    private systemDependencies;
-    private cachedExecutionOrder;
-    /**
-     * Add a system with optional dependencies
-     * @param system The system to add
-     * @param additionalDeps Additional dependencies for the system
-     */
-    addSystem(system: System<UpdateParams>, additionalDeps?: System<UpdateParams>[]): void;
-    /**
-     * Get the execution order of systems based on dependencies
-     * Uses topological sort
-     */
-    getExecutionOrder(): System<UpdateParams>[];
-    update(...params: UpdateParams): Promise<void[]> | void;
-    /**
-     * Clear all systems and dependencies
-     */
-    clear(): void;
-}

package/system.d.ts

@@ -1,13 +0,0 @@
-/**
- * Base System interface
- */
-export interface System<UpdateParams extends any[] = []> {
-    /**
-     * Update the system
-     */
-    update(...params: UpdateParams): void | Promise<void>;
-    /**
-     * Dependencies of this system (systems that must run before this one)
-     */
-    readonly dependencies?: readonly System<UpdateParams>[];
-}

package/types.d.ts

@@ -1,34 +0,0 @@
-import type { EntityId, WildcardRelationId } from "./entity";
-/**
- * Hook types for component lifecycle events
- */
-export interface LifecycleHook<T = unknown> {
-    /**
-     * Called when a component is added to an entity
-     */
-    on_init?: (entityId: EntityId, componentType: EntityId<T>, component: T) => void;
-    /**
-     * Called when a component is added to an entity
-     */
-    on_set?: (entityId: EntityId, componentType: EntityId<T>, component: T) => void;
-    /**
-     * Called when a component is deleted from an entity
-     */
-    on_remove?: (entityId: EntityId, componentType: EntityId<T>, component: T) => void;
-}
-export type ComponentType<T> = EntityId<T> | OptionalEntityId<T>;
-export type OptionalEntityId<T> = {
-    optional: EntityId<T>;
-};
-export declare function isOptionalEntityId<T>(type: ComponentType<T>): type is OptionalEntityId<T>;
-export type ComponentTypeToData<T> = T extends {
-    optional: infer U;
-} ? {
-    value: ComponentTypeToData<U>;
-} | undefined : T extends WildcardRelationId<infer U> ? [EntityId<unknown>, U][] : T extends EntityId<infer U> ? U : never;
-/**
- * Type helper for component tuples extracted from EntityId array
- */
-export type ComponentTuple<T extends readonly ComponentType<any>[]> = {
-    readonly [K in keyof T]: ComponentTypeToData<T[K]>;
-};

package/utils.d.ts

@@ -1,19 +0,0 @@
-/**
- * Utility functions for ECS library
- */
-/**
- * Get a value from cache or compute and cache it if not present
- * @param cache The cache map
- * @param key The cache key
- * @param compute Function to compute the value if not cached
- * @returns The cached or computed value
- */
-export declare function getOrComputeCache<K, V>(cache: Map<K, V>, key: K, compute: () => V): V;
-/**
- * Get a value from cache or create and cache it if not present, allowing side effects during creation
- * @param cache The cache map
- * @param key The cache key
- * @param create Function to create the value if not cached (can have side effects)
- * @returns The cached or created value
- */
-export declare function getOrCreateWithSideEffect<K, V>(cache: Map<K, V>, key: K, create: () => V): V;

package/world.d.ts

@@ -1,221 +0,0 @@
-import { Archetype } from "./archetype";
-import { ComponentChangeset } from "./changeset";
-import { type Command } from "./command-buffer";
-import type { EntityId, WildcardRelationId } from "./entity";
-import { Query } from "./query";
-import { type QueryFilter } from "./query-filter";
-import type { System } from "./system";
-import type { ComponentTuple, LifecycleHook } from "./types";
-/**
- * World class for ECS architecture
- * Manages entities, components, and systems
- */
-export declare class World<UpdateParams extends any[] = []> {
-    /** Manages allocation and deallocation of entity IDs */
-    private entityIdManager;
-    /** Array of all archetypes in the world */
-    private archetypes;
-    /** Maps archetype signatures (component type signatures) to archetype instances */
-    private archetypeBySignature;
-    /** Maps entity IDs to their current archetype */
-    private entityToArchetype;
-    /** Maps component types to arrays of archetypes that contain them */
-    private archetypesByComponent;
-    /** Tracks which entities reference each entity as a component type */
-    private entityReferences;
-    /** Array of all active queries for archetype change notifications */
-    private queries;
-    /** Cache for queries keyed by component types and filter signatures */
-    private queryCache;
-    /** Schedules and executes systems in dependency order */
-    private systemScheduler;
-    /** Buffers structural changes for deferred execution */
-    private commandBuffer;
-    /** Stores lifecycle hooks for component and relation events */
-    private hooks;
-    /** Set of component IDs marked as exclusive relations */
-    private exclusiveComponents;
-    /** Set of component IDs that will cascade delete when the relation target is deleted */
-    private cascadeDeleteComponents;
-    /**
-     * Create a new World.
-     * If an optional snapshot object is provided (previously produced by `world.serialize()`),
-     * the world will be restored from that snapshot. The snapshot may contain non-JSON values.
-     */
-    constructor(snapshot?: SerializedWorld);
-    /**
-     * Generate a signature string for component types array
-     * @returns A string signature for the component types
-     */
-    private createArchetypeSignature;
-    /**
-     * Create a new entity
-     * @returns The ID of the newly created entity
-     */
-    new(): EntityId;
-    /**
-     * Destroy an entity and remove all its components (immediate execution)
-     */
-    private destroyEntityImmediate;
-    /**
-     * Check if an entity exists
-     */
-    exists(entityId: EntityId): boolean;
-    /**
-     * Add a component to an entity (deferred)
-     */
-    set(entityId: EntityId, componentType: EntityId<void>): void;
-    set<T>(entityId: EntityId, componentType: EntityId<T>, component: NoInfer<T>): void;
-    /**
-     * Remove a component from an entity (deferred)
-     */
-    remove<T>(entityId: EntityId, componentType: EntityId<T>): void;
-    /**
-     * Destroy an entity and remove all its components (deferred)
-     */
-    delete(entityId: EntityId): void;
-    /**
-     * Check if an entity has a specific component
-     */
-    has<T>(entityId: EntityId, componentType: EntityId<T>): boolean;
-    /**
-     * Get component data for a specific entity and wildcard relation type
-     * Returns an array of all matching relation instances
-     * @param entityId The entity
-     * @param componentType The wildcard relation type
-     * @returns Array of [targetEntityId, componentData] pairs for all matching relations
-     */
-    get<T>(entityId: EntityId, componentType: WildcardRelationId<T>): [EntityId<unknown>, T][];
-    /**
-     * Get component data for a specific entity and component type
-     * @param entityId The entity
-     * @param componentType The component type
-     * @returns The component data
-     */
-    get<T>(entityId: EntityId, componentType: EntityId<T>): T;
-    /**
-     * Register a system with optional dependencies
-     */
-    registerSystem(system: System<UpdateParams>, additionalDeps?: System<UpdateParams>[]): void;
-    /**
-     * Register a lifecycle hook for component or wildcard relation events
-     */
-    hook<T>(componentType: EntityId<T>, hook: LifecycleHook<T>): void;
-    /**
-     * Unregister a lifecycle hook for component or wildcard relation events
-     */
-    unhook<T>(componentType: EntityId<T>, hook: LifecycleHook<T>): void;
-    /**
-     * Mark a component as exclusive relation
-     * For exclusive relations, an entity can have at most one relation per base component
-     */
-    setExclusive(componentId: EntityId): void;
-    /**
-     * Mark a component as cascade-delete relation
-     * For cascade relations, when the relation target entity is deleted,
-     * the referencing entity will also be deleted (cascade).
-     * Only applicable to entity-relation components
-     */
-    setCascadeDelete(componentId: EntityId): void;
-    /**
-     * Update the world (run all systems in dependency order)
-     * This function is synchronous when all systems are synchronous,
-     * and asynchronous (returns a Promise) when any system is asynchronous.
-     */
-    update(...params: UpdateParams): Promise<void> | void;
-    /**
-     * Execute all deferred commands immediately without running systems
-     */
-    sync(): void;
-    /**
-     * Create a cached query for efficient entity lookups
-     * @returns A Query object for the specified component types and filter
-     */
-    createQuery(componentTypes: EntityId<any>[], filter?: QueryFilter): Query;
-    /**
-     * @internal Register a query for archetype update notifications
-     */
-    _registerQuery(query: Query): void;
-    /**
-     * @internal Unregister a query
-     */
-    _unregisterQuery(query: Query): void;
-    /**
-     * Release a query reference obtained from createQuery.
-     * Decrements the refCount and fully disposes the query when it reaches zero.
-     */
-    releaseQuery(query: Query): void;
-    /**
-     * @internal Get archetypes that match specific component types (for internal use by queries)
-     */
-    getMatchingArchetypes(componentTypes: EntityId<any>[]): Archetype[];
-    /**
-     * Query entities with specific components
-     * @returns Array of entity IDs that have all the specified components
-     */
-    query(componentTypes: EntityId<any>[]): EntityId[];
-    query<const T extends readonly EntityId<any>[]>(componentTypes: T, includeComponents: true): Array<{
-        entity: EntityId;
-        components: ComponentTuple<T>;
-    }>;
-    /**
-     * @internal Execute commands for a single entity (for internal use by CommandBuffer)
-     * @returns ComponentChangeset describing the changes made
-     */
-    executeEntityCommands(entityId: EntityId, commands: Command[]): ComponentChangeset;
-    /**
-     * Get or create an archetype for the given component types
-     * @returns The archetype for the given component types
-     */
-    private ensureArchetype;
-    /**
-     * Add a component reference to the reverse index when an entity is used as a component type
-     * @param sourceEntityId The entity that has the component
-     * @param componentType The component type (which may be an entity ID used as component type)
-     * @param targetEntityId The entity being used as component type
-     */
-    private trackEntityReference;
-    /**
-     * Remove a component reference from the reverse index
-     * @param sourceEntityId The entity that has the component
-     * @param componentType The component type
-     * @param targetEntityId The entity being used as component type
-     */
-    private untrackEntityReference;
-    /**
-     * Get all component references where a target entity is used as a component type
-     * @param targetEntityId The target entity
-     * @returns A MultiMap of sourceEntityId to componentTypes that reference the target entity
-     */
-    private getEntityReferences;
-    /**
-     * Remove an empty archetype from all internal data structures
-     */
-    private cleanupEmptyArchetype;
-    /**
-     * Execute component lifecycle hooks for added and removed components
-     */
-    private triggerLifecycleHooks;
-    /**
-     * Convert the world into a plain snapshot object.
-     * This returns an in-memory structure and does not perform JSON stringification.
-     * Component values are stored as-is (they may be non-JSON-serializable).
-     */
-    serialize(): SerializedWorld;
-}
-export type SerializedWorld = {
-    version: number;
-    entityManager: any;
-    entities: SerializedEntity[];
-};
-export type SerializedEntity = {
-    id: number;
-    components: SerializedComponent[];
-};
-export type SerializedComponent = {
-    type: number | string | {
-        component: string;
-        target: number | string;
-    };
-    value: any;
-};