{"version":3,"sources":["../src/index.ts","../src/decorators.ts","../src/component.ts","../src/mask.ts","../src/entity.ts","../src/system.ts","../src/aspect.ts","../src/query.ts","../src/world.ts"],"sourcesContent":["export { Component, RegisterComponent } from './component';\nexport { Entity, EntityBuilder } from './entity';\nexport type { IEntityBuilder } from './entity';\nexport type { Query } from './query';\nexport { System } from './system';\nexport { World } from './world';\nexport { Has, Without, Aspect } from './aspect';\nexport { parent, children, field, initializeAs } from './decorators';\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Component, ComponentConstructor, ComponentField } from './component';\nimport { Entity } from './entity';\n\n/**\n * Pending fields collected by member decorators, consumed by @RegisterComponent.\n * Safe because decorator evaluation is synchronous per class.\n */\nexport const pendingFields: ComponentField[] = [];\nexport const pendingInitializers: Array<{\n    initFrom: string;\n    field: string;\n}> = [];\n\n/**\n * Register field\n */\nexport function field(\n    _value: undefined,\n    context: ClassFieldDecoratorContext\n): void {\n    pendingFields.push({ fieldName: String(context.name) });\n}\n\nexport const validate = <T>(\n    validateFunction: (val: T) => boolean\n) => {\n    return function (\n        value: ClassAccessorDecoratorTarget<Component, T>,\n        context: ClassAccessorDecoratorContext<Component, T>\n    ): ClassAccessorDecoratorResult<Component, T> {\n        pendingFields.push({ fieldName: String(context.name) });\n        return {\n            set(this: Component, val: T) {\n                if (validateFunction(val)) {\n                    value.set.call(this, val);\n                } else {\n                    throw new Error('Component failed validation function.');\n                }\n            }\n        };\n    };\n};\n\n/**\n * Initialize field as another field on startup.\n * Useful for patterns where you have a field that derives from another.\n * (Example: A 'current' hp value might be initialized from a 'max' hp value.\n * @param initAsField\n */\nexport function initializeAs(initAsField: string) {\n    return function (_value: undefined, context: ClassFieldDecoratorContext) {\n        pendingInitializers.push({\n            initFrom: initAsField,\n            field: String(context.name)\n        });\n    };\n}\n\nexport function init<C>(\n    initValue: C\n): (\n    _value: undefined,\n    context: ClassFieldDecoratorContext\n) => (initialValue: C) => C {\n    return function (\n        _value: undefined,\n        context: ClassFieldDecoratorContext\n    ): (initialValue: C) => C {\n        pendingFields.push({\n            fieldName: String(context.name),\n            defaultValue: initValue\n        });\n        return () => initValue;\n    };\n}\n\nexport function children(\n    value: ClassAccessorDecoratorTarget<Component, Set<Entity>>,\n    context: ClassAccessorDecoratorContext<Component, Set<Entity>>\n): ClassAccessorDecoratorResult<Component, Set<Entity>> {\n    pendingFields.push({ fieldName: String(context.name) });\n\n    return {\n        set(this: Component, childrenVal: Set<Entity>) {\n            const addCleanupCallback = (entity: Entity) => {\n                entity.addCleanupCallback(() => {\n                    extendedSet.delete(entity);\n                });\n            };\n            class ExtendedSet extends Set<Entity> {\n                public add(val: Entity) {\n                    if (super.has(val)) {\n                        return this;\n                    }\n                    super.add(val);\n                    addCleanupCallback(val);\n                    return this;\n                }\n            }\n\n            const extendedSet = new ExtendedSet(childrenVal);\n            value.set.call(this, extendedSet as Set<Entity>);\n        }\n    };\n}\n\n/**\n * Mark entity property as parent\n * @param parentComponentClass Component which will get updated refs to any child entity\n * @param aggregatePropertyKey Property name of array which will contain all child refs\n * @returns Decorator\n */\nexport function parent<\n    V extends { new (): Component & Record<U, Set<Entity>> },\n    U extends string\n>(parentComponentClass: V, aggregatePropertyKey: U) {\n    return (\n        value: ClassAccessorDecoratorTarget<Component, Entity>,\n        context: ClassAccessorDecoratorContext<Component, Entity>\n    ): ClassAccessorDecoratorResult<Component, Entity> => {\n        const propertyKey = String(context.name);\n        pendingFields.push({ fieldName: propertyKey });\n\n        return {\n            set(this: Component, newParent: Entity) {\n                const thisEntity = this.getEntity();\n\n                // has old parent?\n                const currentParent = value.get.call(this);\n                if (currentParent) {\n                    if (currentParent.has(parentComponentClass)) {\n                        const oldParentAggregateProp =\n                            currentParent.get(parentComponentClass)[\n                                aggregatePropertyKey\n                            ];\n                        oldParentAggregateProp.delete(thisEntity);\n                        if (oldParentAggregateProp.size === 0) {\n                            currentParent.remove(parentComponentClass);\n                        }\n                    }\n                }\n\n                value.set.call(this, newParent);\n\n                // Adding entity reference to parent component class\n                if (!newParent.has(parentComponentClass)) {\n                    const childrenSet = new Set<Entity>();\n                    childrenSet.add(thisEntity);\n                    newParent.addComponent(parentComponentClass, {\n                        [aggregatePropertyKey]: childrenSet\n                    } as any);\n                } else {\n                    const childrenSet = newParent.get(parentComponentClass)[\n                        aggregatePropertyKey\n                    ] as Set<Entity> | undefined;\n\n                    if (!childrenSet) {\n                        const newChildrenSet = new Set<Entity>();\n                        newChildrenSet.add(thisEntity);\n\n                        (newParent.get(parentComponentClass)[\n                            aggregatePropertyKey\n                        ] as Set<Entity>) = newChildrenSet;\n                    } else {\n                        childrenSet.add(thisEntity);\n                    }\n                }\n\n                // cleans up this reference if component is removed\n                const componentClass = this\n                    .constructor as ComponentConstructor;\n                newParent.addCleanupCallback(() => {\n                    if (thisEntity.has(this)) {\n                        // entity property has been removed from component, we remove the component\n                        thisEntity.removeComponent(componentClass);\n                    }\n                });\n            }\n        };\n    };\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Entity } from './entity';\nimport { pendingFields, pendingInitializers } from './decorators';\n\nexport type ComponentId = number;\nexport type ComponentName = string;\nexport type ComponentField = {\n    fieldName: string;\n    defaultValue?: unknown;\n};\n\n/**\n * Component that can be attached to entities.\n */\nexport abstract class Component {\n    /**\n     * Bitflag id assigned to a component class at registration time.\n     * Keyed by the class reference itself, not by class name, so the ECS\n     * survives identifier mangling by minifiers and obfuscators.\n     */\n    static ComponentIdMap: Map<ComponentConstructor, ComponentId> = new Map();\n\n    static ComponentFieldMap: Map<\n        ComponentConstructor,\n        Map<string, ComponentField>\n    > = new Map();\n\n    static ComponentFieldInitializeMap: Map<\n        ComponentConstructor,\n        Map<string, Array<string>>\n    > = new Map();\n\n    static maxId = 0;\n\n    declare componentId: ComponentId;\n\n    private declare entity: Entity;\n\n    setValues(values: Record<string, any>): void {\n        const ctor = this.constructor as ComponentConstructor;\n        const fields = Component.ComponentFieldMap.get(ctor);\n        const initializers = Component.ComponentFieldInitializeMap.get(ctor);\n\n        if (!fields) {\n            return;\n        }\n\n        fields.forEach(({ fieldName }) => {\n            if (typeof values[fieldName] === 'undefined') {\n                throw new Error(\n                    `Value not provided for ${fieldName} on component ${this.constructor.name}.`\n                );\n            } else {\n                (this as any)[fieldName] = values[fieldName];\n\n                if (initializers && initializers.has(fieldName)) {\n                    initializers.get(fieldName)?.forEach((otherField) => {\n                        (this as any)[otherField] = values[fieldName];\n                    });\n                }\n            }\n        });\n    }\n    setEntity(entity: Entity): void {\n        this.entity = entity;\n    }\n\n    getEntity(): Entity {\n        if (!this.entity) {\n            throw new Error(\n                \"Component tried to fetch it's entity, but none was found\"\n            );\n        }\n        return this.entity;\n    }\n\n    onComponentRemoved() {\n        // no-op\n    }\n\n    toString(): string {\n        return `${this.constructor.name}`;\n    }\n}\n\ntype NonFunctionPropertyNames<T> = {\n    // eslint-disable-next-line @typescript-eslint/ban-types\n    [K in keyof T]: T[K] extends Function ? never : K;\n}[keyof T];\n\nexport type ComponentArgs<C> = {\n    [Property in Exclude<\n        NonFunctionPropertyNames<C>,\n        keyof Component\n    >]: C[Property];\n};\nexport type ComponentConstructor = { new (...args: any[]): Component };\n\nexport const registerComponentWithSpecificId = <T extends ComponentConstructor>(\n    constructor: T,\n    id: number\n) => {\n    registerComponent(constructor, id);\n};\n\nexport function RegisterComponent<T extends ComponentConstructor>(\n    value: T,\n    _context: ClassDecoratorContext\n): void {\n    Component.maxId++;\n    const newComponentId = Component.maxId;\n    registerComponent(value, newComponentId);\n\n    const fields = pendingFields.splice(0);\n    const fieldMap = Component.ComponentFieldMap.get(value);\n    if (fieldMap) {\n        for (const f of fields) {\n            fieldMap.set(f.fieldName, f);\n        }\n    }\n\n    const initializers = pendingInitializers.splice(0);\n    if (initializers.length > 0) {\n        let initMap = Component.ComponentFieldInitializeMap.get(value);\n        if (!initMap) {\n            initMap = new Map();\n            Component.ComponentFieldInitializeMap.set(value, initMap);\n        }\n        for (const init of initializers) {\n            if (!initMap.has(init.initFrom)) {\n                initMap.set(init.initFrom, []);\n            }\n            initMap.get(init.initFrom)?.push(init.field);\n        }\n    }\n}\n\nconst registerComponent = (\n    constructor: ComponentConstructor,\n    newComponentId: number\n) => {\n    constructor.prototype.componentId = newComponentId;\n    Component.ComponentIdMap.set(constructor, newComponentId);\n\n    if (!Component.ComponentFieldMap.has(constructor)) {\n        Component.ComponentFieldMap.set(constructor, new Map());\n    }\n};\n","import { Component } from './component';\n\nexport class Mask {\n    private _mask: Uint32Array;\n    private _enabled = false;\n\n    constructor(size = Component.maxId) {\n        // Uint32Array holds 32 bits for every unit of size, so we need the no. of components\n        // divided by 32 to mask all components\n        this._mask = new Uint32Array(Math.ceil(size / 32));\n    }\n\n    enable(): void {\n        this._enabled = true;\n    }\n\n    get enabled(): boolean {\n        return this._enabled;\n    }\n\n    get mask(): Uint32Array {\n        return this._mask;\n    }\n\n    get empty(): boolean {\n        return this._mask.every((m) => m === 0);\n    }\n\n    /**\n     * Checks another mask to see it is fulfilled by the flags in this mask\n     * @param otherMask Uint32Array to be compared with this mask\n     * @returns True if the provided mask is satisfied by this mask\n     */\n    public fulfills = (otherMask: Mask): boolean => {\n        if (otherMask.mask.length !== this._mask.length) {\n            throw new Error('Comparing masks of different sizes not allowed.');\n        }\n        return this._mask.every((m, index) =>\n            this.checkMask(m, otherMask.mask[index])\n        );\n    };\n\n    /**\n     * Checks another mask to see it contains all flags in this mask\n     * @param otherMask Uint32Array to be compared with this mask\n     * @returns True if the provided mask is satisfied by this mask\n     */\n    public fulfilledBy = (otherMask: Mask): boolean => {\n        if (otherMask.mask.length !== this._mask.length) {\n            throw new Error('Comparing masks of different sizes not allowed.');\n        }\n        return this._mask.every((m, index) =>\n            this.checkMask(otherMask.mask[index], m)\n        );\n    };\n\n    /**\n     * @param checkingMask The mask that needs to be met to fulfill the condition\n     * @param requiredMask The other mask that needs to match up with the first mask\n     * @returns Whether the masks match or not\n     */\n    private checkMask = (\n        checkingMask: number,\n        requiredMask: number\n    ): boolean => {\n        return (\n            (checkingMask & requiredMask) >>> 0 === requiredMask ||\n            checkingMask === requiredMask // second condition checking if they're both 0\n        );\n    };\n\n    /**\n     * Flips all bits in the mask to 1\n     */\n    flipAllToOne = () => {\n        this._mask.fill(~0 >>> 0);\n    };\n\n    /**\n     * Flip on a flag in this mask\n     * @param bitPosition The bit flag to flip, typically a componentId.\n     */\n    flipOn = (bitPosition: number) => {\n        this._mask[Math.floor(bitPosition / 32)] |=\n            (1 << bitPosition % 32) >>> 0;\n    };\n\n    /**\n     * Flip off a flag on this mask\n     * @param bitPosition The bit flag to flip, typically a componentId.\n     */\n    flipOff = (bitPosition: number) => {\n        this._mask[Math.floor(bitPosition / 32)] &= ~(\n            (1 << bitPosition % 32) >>>\n            0\n        );\n    };\n\n    toString(): string {\n        const decToBin = (dec: number) => {\n            return (dec >>> 0).toString(2);\n        };\n        let string = '|';\n        for (const mask of this.mask) {\n            const stringMask = decToBin(mask);\n            string += stringMask.padEnd(32, '0');\n            string += '|';\n        }\n        return string;\n    }\n\n    get maskString() {\n        return this.toString();\n    }\n}\n","/* eslint-disable @typescript-eslint/ban-types */\nimport {\n    Component,\n    ComponentArgs,\n    ComponentConstructor,\n    ComponentName\n} from './component';\nimport { Mask } from './mask';\nimport { Query, QueryId } from './query';\nimport { World } from './world';\n\nexport type EntityId = string;\n\nlet nextEntitySerial = 0;\nconst generateEntityId = (): EntityId => `e${nextEntitySerial++}`;\n\nexport type IfEquals<T, U, Y = unknown, N = never> = (<G>() => G extends T\n    ? 1\n    : 2) extends <G>() => G extends U ? 1 : 2\n    ? Y\n    : N;\nexport type KeysOfType<T, U> = {\n    [K in keyof T]: T[K] extends U ? K : never;\n}[keyof T];\nexport type RequiredKeys<T> = Exclude<\n    KeysOfType<T, Exclude<T[keyof T], undefined>>,\n    undefined\n>;\nexport type ExcludeOptionalProps<T> = Pick<T, RequiredKeys<T>>;\n\ntype RequiredFieldsOnly<T> = {\n    [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K];\n};\n\n/**\n * A base class from which all game entities derive, supports adding and removing {@link Component | Components}\n */\nexport class Entity {\n    public id: EntityId;\n    public name = 'unknown';\n    public alive = true;\n\n    private world: World;\n    private _componentMask: Mask;\n    private cleanupCallbacks: { (entity: Entity): void }[] = [];\n\n    private components: Map<ComponentConstructor, Component>;\n    private currentQueries = new Map<QueryId, Query>();\n\n    constructor(world: World, opts?: EntityOpts) {\n        this.id = opts?.id ?? generateEntityId();\n        this.name = opts?.name ?? 'unnamed';\n        this.components = new Map();\n        this.world = world;\n        this._componentMask = new Mask();\n    }\n\n    addComponent<T extends Component>(\n        component: { new (): T },\n        args?: ComponentArgs<T>\n    ): void {\n        this._addComponent(component, args);\n        this.world.updateRegistry(component, this);\n    }\n\n    /**\n     * Internal: add a component without notifying the world's query registry.\n     * Caller MUST follow up with World.refreshQueriesForEntity (or addComponent\n     * for a single component) so queries see the new state. Used by\n     * EntityBuilder.build to dedupe per-query work across many components.\n     */\n    _addComponent<T extends Component>(\n        component: { new (): T },\n        args?: ComponentArgs<T>\n    ): void {\n        const componentInstance = new component();\n        componentInstance.setEntity(this);\n        const fieldMap = Component.ComponentFieldMap.get(component);\n        if (fieldMap && fieldMap.size > 0 && args) {\n            componentInstance.setValues(args);\n        }\n\n        this.components.set(component, componentInstance);\n        this._componentMask.flipOn(componentInstance.componentId - 1);\n    }\n\n    /**\n     * Alias for {@link upsertComponent}\n     */\n    upsert<T extends Component>(\n        component: { new (): T },\n        args?: ComponentArgs<T>\n    ): void {\n        this.upsertComponent(component, args);\n    }\n\n    /**\n     * Add or update a given component\n     * @param component Component to update\n     * @param args Values to set on component\n     */\n    upsertComponent<T extends Component>(\n        component: { new (): T },\n        args?: ComponentArgs<T>\n    ): void {\n        if (!this.hasComponent(component)) {\n            this.addComponent(component, args);\n        } else {\n            this.components.get(component)?.setValues(args ?? {});\n        }\n    }\n\n    /**\n     * Alias for {@link getComponent}\n     */\n    get<T extends { new (...args: never): Component }>(\n        componentClass: T | Component\n    ): InstanceType<T> {\n        return this.getComponent(componentClass);\n    }\n\n    /**\n     * Gets a component from the entity by class\n     * @param componentClass Class of component to get\n     * @returns Component instance\n     */\n    getComponent<T extends { new (...args: never): Component }>(\n        componentClass: T | Component\n    ): InstanceType<T> {\n        const key =\n            componentClass instanceof Component\n                ? (componentClass.constructor as ComponentConstructor)\n                : (componentClass as unknown as ComponentConstructor);\n        return this.components.get(key) as InstanceType<T>;\n    }\n\n    /**\n     * @deprecated Class names may be mangled by minifiers/obfuscators.\n     * Iterate components directly or work with class references instead.\n     */\n    getComponentNames(): ComponentName[] {\n        return Array.from(this.components.keys()).map((c) => c.name);\n    }\n\n    get componentMask(): Mask {\n        return this._componentMask;\n    }\n\n    /**\n     * Alias for {@link hasComponent}\n     */\n    has<T extends { new (...args: never): Component }>(\n        componentClass: T | Component\n    ): boolean {\n        return this.hasComponent(componentClass);\n    }\n\n    /**\n     * Check if an entity has a component.\n     * @param componentClass Component class to check\n     * @returns boolean true/false depending on whether the component is on the entity\n     */\n    hasComponent<T extends { new (...args: never): Component }>(\n        componentClass: T | Component\n    ): boolean {\n        const key =\n            componentClass instanceof Component\n                ? (componentClass.constructor as ComponentConstructor)\n                : (componentClass as unknown as ComponentConstructor);\n        return this.components.has(key);\n    }\n\n    /**\n     * Alias for {@link removeComponent}\n     */\n    remove<T extends { new (...args: never): Component }>(\n        componentClass: T\n    ): boolean {\n        return this.removeComponent(componentClass);\n    }\n\n    /**\n     * Removes a component from entity by class. Returns true if the component\n     * was present and removed, false if the entity did not have it.\n     * @param componentClass Component class to remove\n     */\n    removeComponent<T extends { new (...args: never): Component }>(\n        componentClass: T\n    ): boolean {\n        const ctor = componentClass as unknown as ComponentConstructor;\n        if (!this.components.has(ctor)) {\n            return false;\n        }\n\n        const id = Component.ComponentIdMap.get(ctor);\n        if (id !== undefined) {\n            this._componentMask.flipOff(id - 1);\n        }\n\n        this.components.get(ctor)?.onComponentRemoved();\n        this.components.delete(ctor);\n\n        this.world.updateRegistry(ctor, this);\n        return true;\n    }\n\n    /**\n     * @deprecated Class names may be mangled by minifiers/obfuscators.\n     * Use {@link removeComponent} with a class reference instead.\n     */\n    removeComponentByName(componentName: ComponentName): boolean {\n        for (const ctor of this.components.keys()) {\n            if (ctor.name === componentName) {\n                return this.removeComponent(ctor);\n            }\n        }\n        return false;\n    }\n\n    /**\n     * Check whether this entity is the same as passed entity\n     */\n    equals(other: Entity): boolean {\n        return this.id === other.id;\n    }\n\n    registerQuery(query: Query): void {\n        this.currentQueries.set(query.id, query);\n    }\n\n    unregisterQuery(query: Query): void {\n        this.currentQueries.delete(query.id);\n    }\n\n    addCleanupCallback(callback: (entity: Entity) => void): void {\n        this.cleanupCallbacks.push(callback);\n    }\n\n    destroy(): void {\n        // use maintained list of registered systems and unregister entity\n        this.currentQueries.forEach((q) => {\n            q.unregisterEntity(this);\n        });\n\n        this.alive = false;\n\n        this.world.markDeadEntity(this);\n    }\n\n    purge(): void {\n        // Snapshot keys to avoid mutating during iteration.\n        const ctors = Array.from(this.components.keys());\n        ctors.forEach((ctor) => {\n            this.removeComponent(ctor);\n        });\n\n        this.cleanupCallbacks.forEach((cb) => {\n            cb(this);\n        });\n    }\n}\n\nexport interface IEntityBuilder {\n    build(): Entity;\n}\n\nexport type EntityOpts = {\n    id?: string;\n    name?: string;\n};\nexport class EntityBuilder implements IEntityBuilder {\n    private world: World;\n    private opts: EntityOpts | undefined;\n    private componentRecipes: Array<{\n        constructor: { new (): unknown };\n        args?: Record<any, unknown>;\n    }> = [];\n\n    static create(world: World, opts?: EntityOpts): EntityBuilder {\n        return new EntityBuilder(world, opts);\n    }\n\n    constructor(world: World, opts?: EntityOpts) {\n        this.world = world;\n        this.opts = opts;\n    }\n\n    with<T extends Component>(\n        componentConstructor: { new (): T },\n        args?: ComponentArgs<T>\n    ): EntityBuilder {\n        this.componentRecipes.push({\n            constructor: componentConstructor,\n            args: args\n        });\n        return this;\n    }\n\n    build(): Entity {\n        const entity = new Entity(this.world, this.opts);\n        this.componentRecipes.forEach(({ constructor, args }) => {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            entity._addComponent<any>(constructor, args);\n        });\n\n        this.world.mapEntity(entity);\n        this.world.refreshQueriesForEntity(\n            entity,\n            this.componentRecipes.map((r) => r.constructor as ComponentConstructor)\n        );\n        return entity;\n    }\n}\n","import { World } from './world';\nimport { v4 as uuidv4 } from 'uuid';\nimport { Aspect } from './aspect';\nimport { ComponentConstructor } from './component';\nimport { Query } from './query';\nimport { EntityBuilder } from '.';\nimport { EntityOpts } from './entity';\n\nexport type SystemId = string;\nexport abstract class System {\n    public order?: number;\n    public id: SystemId;\n    public declare world: World;\n    private _queries: Query[] = [];\n\n    constructor() {\n        this.id = uuidv4();\n    }\n\n    initialize() {\n        // optional abstract\n    }\n    abstract run(delta: number): void;\n\n    get queries() {\n        return this._queries;\n    }\n\n    protected query(aspects: Aspect[]): Query {\n        const query = new Query(aspects);\n        this._queries.push(query);\n        return query;\n    }\n\n    /**\n     * Convenience for `this.query(aspects).bindComponents(components)` —\n     * returns a Query whose forEachWith hands the listed components straight\n     * to the callback.\n     */\n    protected queryWith(\n        aspects: Aspect[],\n        components: ComponentConstructor[]\n    ): Query {\n        return this.query(aspects).bindComponents(components);\n    }\n\n    protected spawnEntity(opts?: EntityOpts) {\n        return EntityBuilder.create(this.world, opts);\n    }\n}\n","import { Component, ComponentConstructor } from './component';\n\nexport class Aspect {\n    public bitFlag: number;\n    public component: ComponentConstructor;\n\n    constructor(component: { new (...args: never): Component }) {\n        this.component = component as unknown as ComponentConstructor;\n        const id = Component.ComponentIdMap.get(this.component);\n        this.bitFlag = (id ?? 0) - 1;\n    }\n}\n\nexport class HasAspect extends Aspect {}\nexport class WithoutAspect extends Aspect {}\n\nexport const Has = <T extends { new (...args: never): Component }>(\n    component: T\n): Aspect => {\n    return new HasAspect(component);\n};\n\nexport const Without = <T extends { new (...args: never): Component }>(\n    component: T\n): Aspect => {\n    return new WithoutAspect(component);\n};\n","import { Aspect, HasAspect, WithoutAspect } from './aspect';\nimport { Component, ComponentConstructor } from './component';\nimport { Entity, EntityId } from './entity';\nimport { v4 as uuidv4 } from 'uuid';\nimport { Mask } from './mask';\n\nexport type QueryId = string;\n\ntype ChangeSet = {\n    added: Array<Entity>;\n    removed: Array<Entity>;\n};\n\nexport class Query {\n    public id: QueryId;\n\n    private _aspects: Aspect[] = [];\n\n    private declare _includeMask: Mask;\n    private declare _excludeMask: Mask;\n\n    /**\n     * Flat array of entities matched by this query. Deletions tombstone the\n     * slot (set to null) and `compact` repacks during flushQuery, so iteration\n     * order is stable insertion order and the array tolerates concurrent\n     * removals (e.g. an entity destroying itself mid-forEach).\n     */\n    private _entityList: Array<Entity | null> = [];\n    private _entityListIndex: Map<EntityId, number> = new Map();\n    private _holes = 0;\n\n    /**\n     * If non-null, parallel arrays of component instances kept in sync with\n     * _entityList so forEachWith can hand component refs to the callback\n     * without an entity.get() per iteration. _boundComponentArrays[k][i] is\n     * the instance of _boundComponents[k] on _entityList[i] (null when the\n     * slot is tombstoned).\n     */\n    private _boundComponents: ComponentConstructor[] | null = null;\n    private _boundComponentArrays: Array<Array<Component | null>> | null =\n        null;\n\n    /**\n     * Used by World.refreshQueriesForEntity to dedupe per-entity work without\n     * allocating a Set on every entity build. World stamps a fresh tick into\n     * this field; queries skip themselves when stamped.\n     */\n    public _visitedTick = -1;\n\n    private currentChangeSet: 0 | 1 = 0;\n    private changeSets: [ChangeSet, ChangeSet] = [\n        {\n            added: [],\n            removed: []\n        },\n        {\n            added: [],\n            removed: []\n        }\n    ];\n\n    constructor(aspects: Aspect[]) {\n        this._aspects = aspects;\n        this.initializeMasks();\n        this.id = uuidv4();\n    }\n\n    get nextChangeSetIndex(): 0 | 1 {\n        // 0 becomes 1, 1 becomes 0\n        return ((this.currentChangeSet + 1) % 2) as 0 | 1;\n    }\n\n    get added() {\n        return this.changeSets[this.currentChangeSet].added;\n    }\n\n    get removed() {\n        return this.changeSets[this.currentChangeSet].removed;\n    }\n\n    get nextAdded() {\n        return this.changeSets[this.nextChangeSetIndex].added;\n    }\n\n    get nextRemoved() {\n        return this.changeSets[this.nextChangeSetIndex].removed;\n    }\n\n    get current() {\n        if (this._holes === 0) return this._entityList.slice() as Entity[];\n        const out: Entity[] = [];\n        for (const e of this._entityList) if (e !== null) out.push(e);\n        return out;\n    }\n\n    get aspects() {\n        return this._aspects;\n    }\n\n    get includeMask(): Mask {\n        return this._includeMask;\n    }\n\n    get excludeMask(): Mask {\n        return this._excludeMask;\n    }\n\n    /**\n     * Snapshot of currently-matched entities as a Map. Built on demand from\n     * the internal flat list — held only for backward compat with consumers\n     * that want Map iteration; prefer `current` (Array) or `forEach` for hot\n     * paths.\n     */\n    get entities(): Map<EntityId, Entity> {\n        const map = new Map<EntityId, Entity>();\n        const list = this._entityList;\n        for (let i = 0; i < list.length; i++) {\n            const e = list[i];\n            if (e !== null) map.set(e.id, e);\n        }\n        return map;\n    }\n\n    initializeMasks(): void {\n        this._includeMask = new Mask();\n\n        this._excludeMask = new Mask();\n        this._excludeMask.flipAllToOne();\n\n        this.aspects.forEach((aspect) => {\n            switch (aspect.constructor) {\n                case HasAspect: {\n                    this._includeMask.flipOn(aspect.bitFlag);\n                    this._includeMask.enable();\n                    break;\n                }\n                case WithoutAspect: {\n                    this._excludeMask.flipOff(aspect.bitFlag);\n                    this._excludeMask.enable();\n                    break;\n                }\n            }\n        });\n\n        if (this._includeMask.empty) {\n            this._includeMask.flipAllToOne();\n        }\n    }\n\n    /**\n     * True for queries built only from Without aspects (no Has). The world\n     * needs to route entity changes to these queries via a separate path,\n     * because they don't appear in queryRegistry under any component.\n     */\n    get hasOnlyExclusiveAspects(): boolean {\n        return !this._includeMask.enabled && this._excludeMask.enabled;\n    }\n\n    checkIncludeMask = (entity: Entity): boolean =>\n        !this._includeMask.enabled ||\n        this._includeMask.fulfilledBy(entity.componentMask);\n\n    checkExcludeMask = (entity: Entity): boolean =>\n        !this._excludeMask.enabled ||\n        this._excludeMask.fulfills(entity.componentMask);\n\n    /**\n     * Check whether an entity is currently being tracked by this query\n     * @param entity Entity to check\n     * @returns whether the entity is in the query's entity list\n     */\n    hasEntity(entity: Entity): boolean {\n        return this._entityListIndex.has(entity.id);\n    }\n\n    /**\n     * Adds an entity to this query's entity track list\n     * @param entity Entity to add\n     */\n    registerEntity(entity: Entity): void {\n        this.nextAdded.push(entity);\n\n        if (!this.hasEntity(entity)) {\n            this._entityListIndex.set(entity.id, this._entityList.length);\n            this._entityList.push(entity);\n            if (this._boundComponentArrays !== null) {\n                const ctors = this._boundComponents!;\n                for (let k = 0; k < ctors.length; k++) {\n                    this._boundComponentArrays[k].push(\n                        entity.getComponent(ctors[k]) ?? null\n                    );\n                }\n            }\n            entity.registerQuery(this);\n        }\n    }\n\n    /**\n     * Remove an entity from this query's entity track list\n     * @param entity Entity to remove\n     */\n    unregisterEntity(entity: Entity): void {\n        this.nextRemoved.push(entity);\n        const idx = this._entityListIndex.get(entity.id);\n        if (idx !== undefined) {\n            this._entityList[idx] = null;\n            if (this._boundComponentArrays !== null) {\n                for (const arr of this._boundComponentArrays) {\n                    arr[idx] = null;\n                }\n            }\n            this._entityListIndex.delete(entity.id);\n            this._holes++;\n        }\n        entity.unregisterQuery(this);\n    }\n\n    shouldRegisterEntity(entity: Entity) {\n        const doesInclude = this.checkIncludeMask(entity);\n        const doesntExclude = this.checkExcludeMask(entity);\n        return doesInclude && doesntExclude;\n    }\n\n    updateRegistry = (entity: Entity) => {\n        const registerThisEntity = this.shouldRegisterEntity(entity);\n\n        if (this.hasEntity(entity) && !registerThisEntity) {\n            this.unregisterEntity(entity);\n        } else if (registerThisEntity) {\n            this.registerEntity(entity);\n        }\n    };\n\n    /**\n     * Iterate the entities currently matching this query. Re-reads list length\n     * each iteration so entities registered mid-forEach are visited (matching\n     * Map.forEach semantics); tombstoned slots from concurrent removals are\n     * skipped.\n     */\n    forEach(callbackfn: (entity: Entity) => void) {\n        const list = this._entityList;\n        for (let i = 0; i < list.length; i++) {\n            const e = list[i];\n            if (e !== null) callbackfn(e);\n        }\n    }\n\n    /**\n     * Repack _entityList (and any bound component arrays) in place so\n     * tombstoned slots don't accumulate. Called from flushQuery — at most once\n     * per world tick — keeping per-iteration null-check overhead bounded.\n     */\n    private compact() {\n        const list = this._entityList;\n        const bound = this._boundComponentArrays;\n        let write = 0;\n        for (let read = 0; read < list.length; read++) {\n            const e = list[read];\n            if (e === null) continue;\n            if (write !== read) {\n                list[write] = e;\n                this._entityListIndex.set(e.id, write);\n                if (bound !== null) {\n                    for (const arr of bound) arr[write] = arr[read];\n                }\n            }\n            write++;\n        }\n        list.length = write;\n        if (bound !== null) for (const arr of bound) arr.length = write;\n        this._holes = 0;\n    }\n\n    /**\n     * Bind a fixed list of components to this query so forEachWith can deliver\n     * them directly to the callback. Call once before the query starts being\n     * used; subsequent calls throw. Components don't have to overlap with the\n     * query's aspects — but the entities must actually have them, otherwise\n     * the callback receives null in that slot.\n     */\n    bindComponents(components: ComponentConstructor[]): this {\n        if (this._boundComponents !== null) {\n            throw new Error('Query already has bound components.');\n        }\n        this._boundComponents = components.slice();\n        this._boundComponentArrays = components.map(() => []);\n        // Backfill any entities already registered.\n        const list = this._entityList;\n        for (let i = 0; i < list.length; i++) {\n            const e = list[i];\n            for (let k = 0; k < components.length; k++) {\n                this._boundComponentArrays[k].push(\n                    e === null ? null : (e.getComponent(components[k]) ?? null)\n                );\n            }\n        }\n        return this;\n    }\n\n    /**\n     * Iterate, handing each entity its bound component instances directly —\n     * no entity.get() per element. Specialized fast paths for 1/2/3\n     * components cover the typical system-loop shapes; longer tuples fall\n     * through to a generic loop.\n     */\n    forEachWith(\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        callback: (entity: Entity, ...components: any[]) => void\n    ): void {\n        const list = this._entityList;\n        const bound = this._boundComponentArrays;\n        if (bound === null) {\n            throw new Error(\n                'forEachWith called before bindComponents — bind components first.'\n            );\n        }\n        switch (bound.length) {\n            case 1: {\n                const a0 = bound[0];\n                for (let i = 0; i < list.length; i++) {\n                    const e = list[i];\n                    if (e !== null) callback(e, a0[i]);\n                }\n                return;\n            }\n            case 2: {\n                const a0 = bound[0];\n                const a1 = bound[1];\n                for (let i = 0; i < list.length; i++) {\n                    const e = list[i];\n                    if (e !== null) callback(e, a0[i], a1[i]);\n                }\n                return;\n            }\n            case 3: {\n                const a0 = bound[0];\n                const a1 = bound[1];\n                const a2 = bound[2];\n                for (let i = 0; i < list.length; i++) {\n                    const e = list[i];\n                    if (e !== null) callback(e, a0[i], a1[i], a2[i]);\n                }\n                return;\n            }\n            default: {\n                for (let i = 0; i < list.length; i++) {\n                    const e = list[i];\n                    if (e === null) continue;\n                    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    const comps: any[] = new Array(bound.length);\n                    for (let k = 0; k < bound.length; k++) {\n                        comps[k] = bound[k][i];\n                    }\n                    callback(e, ...comps);\n                }\n            }\n        }\n    }\n\n    flushQuery = () => {\n        this.currentChangeSet = this.nextChangeSetIndex;\n        this.nextAdded.length = 0;\n        this.nextRemoved.length = 0;\n        if (this._holes > 0) this.compact();\n    };\n}\n","import { System } from './system';\nimport { Entity, EntityBuilder, EntityId, EntityOpts } from './entity';\nimport { Query } from './query';\nimport { ComponentConstructor } from './component';\n\nexport type SystemAndProps<T extends { new (...args: unknown[]): System }> = {\n    system: T;\n    props: ConstructorParameters<T>;\n};\n\nexport class World {\n    private systems: System[] = [];\n    private queryRegistry: Map<ComponentConstructor, Query[]> = new Map();\n    private allQueries: Array<Query> = [];\n    /**\n     * Queries that have only Without aspects don't appear in queryRegistry\n     * under any component, so we keep them in a flat list and check them\n     * on every entity-component change.\n     */\n    private exclusiveOnlyQueries: Array<Query> = [];\n    /**\n     * Monotonic tick stamped onto Query._visitedTick during\n     * refreshQueriesForEntity. Lets us dedupe per-entity work across multiple\n     * components without allocating a Set per build.\n     */\n    private _refreshTick = 0;\n    private entities: Map<EntityId, Entity> = new Map();\n    private deadEntities: Array<Entity> = [];\n    private entitiesToBePurged: Array<Entity> = [];\n    private initialized = false;\n\n    private onRunCallbacks: Array<(delta: number) => void> = [];\n\n    // eslint-disable-next-line @typescript-eslint/no-empty-function\n    private constructor() {}\n\n    static create(): World {\n        return new World();\n    }\n\n    destroy(): void {\n        this.systems = [];\n        this.queryRegistry.clear();\n        this.allQueries = [];\n        this.exclusiveOnlyQueries = [];\n        this.entities.clear();\n        this.deadEntities = [];\n        this.entitiesToBePurged = [];\n        this.initialized = false;\n    }\n\n    public getEntityById(id: EntityId) {\n        return this.entities.get(id);\n    }\n\n    /**\n     * Keeping track of which queries are interested in which components,\n     * in order to reduce the amount of iterations when updating entity lists\n     */\n    addToQueryRegistry(\n        key: ComponentConstructor,\n        query: Query,\n        registry: Map<ComponentConstructor, Query[]>\n    ): void {\n        if (!registry.has(key)) {\n            registry.set(key, [query]);\n        } else {\n            registry.get(key)?.push(query);\n        }\n    }\n\n    mapAspects(system: System): void {\n        system.queries.forEach((query: Query) => {\n            const aspects = query.aspects;\n            aspects.forEach((a) => {\n                this.addToQueryRegistry(\n                    a.component,\n                    query,\n                    this.queryRegistry\n                );\n            });\n            if (query.hasOnlyExclusiveAspects) {\n                this.exclusiveOnlyQueries.push(query);\n            }\n            this.allQueries.push(query);\n        });\n    }\n\n    addSystem<T extends { new (...args: any[]): System }>(\n        systemClass: T,\n        ...args: ConstructorParameters<T>\n    ) {\n        const systemInstance = new systemClass(...args);\n        systemInstance.world = this;\n        this.mapAspects(systemInstance);\n        this.systems.push(systemInstance);\n\n        return this;\n    }\n\n    /**\n     * Adds a callback that is called on each world.run\n     */\n    onRun = (cb: (delta: number) => void) => {\n        this.onRunCallbacks.push(cb);\n    };\n\n    /**\n     * Run all of the world's systems\n     * @param delta Optional, defaults to 1\n     */\n    run = (delta = 1): void => {\n        if (!this.initialized) {\n            this.systems.sort((a, b) => {\n                const orderA = a.order ?? 0;\n                const orderB = b.order ?? 0;\n                return orderA - orderB;\n            });\n            this.systems.forEach((system) => {\n                system.initialize();\n            });\n            this.initialized = true;\n        }\n\n        /**\n         * Flush every query so that they get fresh changesets to track\n         */\n        this.allQueries.forEach((query) => {\n            query.flushQuery();\n        });\n\n        /**\n         * Run each system\n         */\n        this.systems.forEach((system: System) => {\n            system.run(delta);\n        });\n\n        this.processGraveyard();\n\n        this.onRunCallbacks.forEach((cb) => cb(delta));\n    };\n\n    mapEntity(entity: Entity) {\n        if (this.entities.has(entity.id)) {\n            throw new Error(\n                `Entity with id \"${entity.id}\" already exists in the world.`\n            );\n        }\n        this.entities.set(entity.id, entity);\n    }\n\n    updateRegistry(component: ComponentConstructor, entity: Entity): void {\n        this.queryRegistry.get(component)?.forEach((query: Query) => {\n            query.updateRegistry(entity);\n        });\n        for (const q of this.exclusiveOnlyQueries) {\n            q.updateRegistry(entity);\n        }\n    }\n\n    /**\n     * Refresh every query that cares about any of the given components, exactly\n     * once per query. Used by EntityBuilder.build so that queries spanning\n     * multiple just-added components don't get re-checked per component.\n     */\n    refreshQueriesForEntity(\n        entity: Entity,\n        components: ComponentConstructor[]\n    ): void {\n        const tick = ++this._refreshTick;\n        for (const c of components) {\n            const queries = this.queryRegistry.get(c);\n            if (!queries) continue;\n            for (const q of queries) {\n                if (q._visitedTick === tick) continue;\n                q._visitedTick = tick;\n                q.updateRegistry(entity);\n            }\n        }\n        for (const q of this.exclusiveOnlyQueries) {\n            if (q._visitedTick === tick) continue;\n            q._visitedTick = tick;\n            q.updateRegistry(entity);\n        }\n    }\n\n    spawnEntity(opts?: EntityOpts): EntityBuilder {\n        return EntityBuilder.create(this, opts);\n    }\n\n    processGraveyard() {\n        this.entitiesToBePurged.forEach((entity) => {\n            entity.purge();\n            this.entities.delete(entity.id);\n        });\n        this.entitiesToBePurged = this.deadEntities.slice();\n        this.deadEntities.length = 0;\n    }\n\n    markDeadEntity(entity: Entity) {\n        this.deadEntities.push(entity);\n    }\n\n    /**\n     * Used for testing\n     */\n    getSystem<T extends { new (...args: never): System }>(\n        systemClass: T\n    ): InstanceType<T> {\n        return this.systems.find(\n            (s) => s instanceof systemClass\n        ) as InstanceType<T>;\n    }\n}\n"],"mappings":"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","names":["import_uuid","uuidv4","uuidv4"]}