ecspresso 0.4.3 → 0.6.0

package/dist/asset-manager.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Asset management for ECSpresso ECS framework
+ */
+import type EventBus from './event-bus';
+import type { AssetStatus, AssetDefinition, AssetHandle, AssetsResource, AssetEvents, AssetConfigurator } from './asset-types';
+/**
+ * Manages asset loading and access for ECSpresso
+ */
+export default class AssetManager<AssetTypes extends Record<string, unknown> = Record<string, never>> {
+    private readonly assets;
+    private readonly groups;
+    private eventBus;
+    /**
+     * Set the event bus for asset events
+     * @internal
+     */
+    setEventBus(eventBus: EventBus<AssetEvents>): void;
+    /**
+     * Register an asset definition
+     */
+    register<K extends string, T>(key: K, definition: AssetDefinition<T>): void;
+    /**
+     * Load all assets marked as eager
+     */
+    loadEagerAssets(): Promise<void>;
+    /**
+     * Load a single asset by key
+     */
+    loadAsset<K extends keyof AssetTypes>(key: K): Promise<AssetTypes[K]>;
+    /**
+     * Load all assets in a group
+     */
+    loadAssetGroup(groupName: string): Promise<void>;
+    /**
+     * Get a loaded asset. Throws if not loaded.
+     */
+    get<K extends keyof AssetTypes>(key: K): AssetTypes[K];
+    /**
+     * Get a loaded asset or undefined
+     */
+    getOrUndefined<K extends keyof AssetTypes>(key: K): AssetTypes[K] | undefined;
+    /**
+     * Get a handle to an asset with status information
+     */
+    getHandle<K extends keyof AssetTypes>(key: K): AssetHandle<AssetTypes[K]>;
+    /**
+     * Get the status of an asset
+     */
+    getStatus<K extends keyof AssetTypes>(key: K): AssetStatus;
+    /**
+     * Check if an asset is loaded
+     */
+    isLoaded<K extends keyof AssetTypes>(key: K): boolean;
+    /**
+     * Check if all assets in a group are loaded
+     */
+    isGroupLoaded(groupName: string): boolean;
+    /**
+     * Get the loading progress of a group (0-1)
+     */
+    getGroupProgress(groupName: string): number;
+    /**
+     * Get detailed group progress
+     */
+    getGroupProgressDetails(groupName: string): {
+        loaded: number;
+        total: number;
+        progress: number;
+    };
+    /**
+     * Check group progress and emit events
+     */
+    private checkGroupProgress;
+    /**
+     * Create the $assets resource object
+     */
+    createResource(): AssetsResource<AssetTypes>;
+    /**
+     * Get all registered asset keys
+     */
+    getKeys(): Array<keyof AssetTypes>;
+    /**
+     * Get all group names
+     */
+    getGroupNames(): string[];
+    /**
+     * Get all asset keys in a group
+     */
+    getGroupKeys(groupName: string): Array<keyof AssetTypes>;
+}
+/**
+ * Implementation of AssetConfigurator for builder pattern
+ */
+export declare class AssetConfiguratorImpl<A extends Record<string, unknown>> implements AssetConfigurator<A> {
+    private readonly manager;
+    constructor(manager: AssetManager<A>);
+    add<K extends string, T>(key: K, loader: () => Promise<T>): AssetConfigurator<A & Record<K, T>>;
+    addWithConfig<K extends string, T>(key: K, definition: AssetDefinition<T>): AssetConfigurator<A & Record<K, T>>;
+    addGroup<G extends string, T extends Record<string, () => Promise<unknown>>>(groupName: G, assets: T): AssetConfigurator<A & {
+        [K in keyof T]: Awaited<ReturnType<T[K]>>;
+    }>;
+    /**
+     * Get the underlying manager
+     * @internal
+     */
+    getManager(): AssetManager<A>;
+}
+/**
+ * Create a new AssetConfigurator for builder pattern usage
+ */
+export declare function createAssetConfigurator<A extends Record<string, unknown> = Record<string, never>>(manager?: AssetManager<A>): AssetConfiguratorImpl<A>;

package/dist/asset-types.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Asset management types for ECSpresso ECS framework
+ */
+/**
+ * Status of an asset in the loading lifecycle
+ */
+export type AssetStatus = 'pending' | 'loading' | 'loaded' | 'failed';
+/**
+ * Definition for an asset including its loader and configuration
+ */
+export interface AssetDefinition<T> {
+    readonly loader: () => Promise<T>;
+    readonly eager?: boolean;
+    readonly group?: string;
+}
+/**
+ * Handle to an asset that provides status information and access methods
+ */
+export interface AssetHandle<T> {
+    readonly status: AssetStatus;
+    readonly isLoaded: boolean;
+    /**
+     * Get the asset value. Throws if asset is not loaded.
+     */
+    get(): T;
+    /**
+     * Get the asset value if loaded, undefined otherwise.
+     */
+    getOrUndefined(): T | undefined;
+}
+/**
+ * Resource interface for accessing assets in systems
+ * Exposed as $assets resource
+ */
+export interface AssetsResource<A extends Record<string, unknown>> {
+    /**
+     * Get the loading status of an asset
+     */
+    getStatus<K extends keyof A>(key: K): AssetStatus;
+    /**
+     * Check if an asset is loaded
+     */
+    isLoaded<K extends keyof A>(key: K): boolean;
+    /**
+     * Check if all assets in a group are loaded
+     */
+    isGroupLoaded(groupName: string): boolean;
+    /**
+     * Get the loading progress of a group (0-1)
+     */
+    getGroupProgress(groupName: string): number;
+    /**
+     * Get a loaded asset. Throws if not loaded.
+     */
+    get<K extends keyof A>(key: K): A[K];
+    /**
+     * Get a loaded asset or undefined if not loaded
+     */
+    getOrUndefined<K extends keyof A>(key: K): A[K] | undefined;
+    /**
+     * Get a handle to an asset with status information
+     */
+    getHandle<K extends keyof A>(key: K): AssetHandle<A[K]>;
+}
+/**
+ * Events emitted by the asset system
+ */
+export interface AssetEvents {
+    assetLoaded: {
+        key: string;
+    };
+    assetFailed: {
+        key: string;
+        error: Error;
+    };
+    assetGroupLoaded: {
+        group: string;
+    };
+    assetGroupProgress: {
+        group: string;
+        progress: number;
+        loaded: number;
+        total: number;
+    };
+}
+/**
+ * Configuration for asset definitions during builder setup
+ */
+export interface AssetConfigurator<A extends Record<string, unknown>> {
+    /**
+     * Add a single eager asset
+     */
+    add<K extends string, T>(key: K, loader: () => Promise<T>): AssetConfigurator<A & Record<K, T>>;
+    /**
+     * Add a single asset with full configuration
+     */
+    addWithConfig<K extends string, T>(key: K, definition: AssetDefinition<T>): AssetConfigurator<A & Record<K, T>>;
+    /**
+     * Add a group of assets that can be loaded together
+     */
+    addGroup<G extends string, T extends Record<string, () => Promise<unknown>>>(groupName: G, assets: T): AssetConfigurator<A & {
+        [K in keyof T]: Awaited<ReturnType<T[K]>>;
+    }>;
+}

package/dist/bundle.d.ts

@@ -1,12 +1,17 @@
 import { SystemBuilderWithBundle } from './system-builder';
 import type ECSpresso from './ecspresso';
+import type { AssetDefinition } from './asset-types';
+import type { ScreenDefinition } from './screen-types';
 /**
  * Bundle class that encapsulates a set of components, resources, events, and systems
  * that can be merged into a ECSpresso instance
  */
-export default class Bundle<ComponentTypes extends Record<string, any> = {}, EventTypes extends Record<string, any> = {}, ResourceTypes extends Record<string, any> = {}> {
+export default class Bundle<ComponentTypes extends Record<string, any> = {}, EventTypes extends Record<string, any> = {}, ResourceTypes extends Record<string, any> = {}, AssetTypes extends Record<string, unknown> = {}, ScreenStates extends Record<string, ScreenDefinition<any, any>> = {}> {
     private _systems;
     private _resources;
+    private _assets;
+    private _assetGroups;
+    private _screens;
     private _id;
     constructor(id?: string);
     /**
@@ -26,9 +31,59 @@ export default class Bundle<ComponentTypes extends Record<string, any> = {}, Eve
     /**
      * Add a resource to this bundle
      * @param label The resource key
-     * @param resource The resource value or a factory function that returns the resource
+     * @param resource The resource value, a factory function, or a factory with dependencies
      */
-    addResource<K extends keyof ResourceTypes>(label: K, resource: ResourceTypes[K] | ((ecs: ECSpresso<ComponentTypes, EventTypes, ResourceTypes>) => ResourceTypes[K] | Promise<ResourceTypes[K]>)): this;
+    addResource<K extends keyof ResourceTypes>(label: K, resource: ResourceTypes[K] | ((ecs: ECSpresso<ComponentTypes, EventTypes, ResourceTypes>) => ResourceTypes[K] | Promise<ResourceTypes[K]>) | {
+        dependsOn: readonly string[];
+        factory: (ecs: ECSpresso<ComponentTypes, EventTypes, ResourceTypes>) => ResourceTypes[K] | Promise<ResourceTypes[K]>;
+    }): this;
+    /**
+     * Add an asset to this bundle
+     * @param key The asset key
+     * @param loader Function that loads and returns the asset
+     * @param options Optional asset configuration
+     */
+    addAsset<K extends string, T>(key: K, loader: () => Promise<T>, options?: {
+        eager?: boolean;
+        group?: string;
+    }): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes & Record<K, T>, ScreenStates>;
+    /**
+     * Add a group of assets to this bundle
+     * @param groupName The group name
+     * @param assets Object mapping asset keys to loader functions
+     */
+    addAssetGroup<G extends string, T extends Record<string, () => Promise<unknown>>>(groupName: G, assets: T): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes & {
+        [K in keyof T]: Awaited<ReturnType<T[K]>>;
+    }, ScreenStates>;
+    /**
+     * Add a screen to this bundle
+     * @param name The screen name
+     * @param definition The screen definition
+     */
+    addScreen<K extends string, Config extends Record<string, unknown>, State extends Record<string, unknown>>(name: K, definition: ScreenDefinition<Config, State>): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates & Record<K, ScreenDefinition<Config, State>>>;
+    /**
+     * Get all asset definitions in this bundle
+     */
+    getAssets(): Map<string, AssetDefinition<unknown>>;
+    /**
+     * Get all screen definitions in this bundle
+     */
+    getScreens(): Map<string, ScreenDefinition<any, any>>;
+    /**
+     * Internal method to set a resource
+     * @internal Used by mergeBundles
+     */
+    _setResource(key: string, value: unknown): void;
+    /**
+     * Internal method to set an asset definition
+     * @internal Used by mergeBundles
+     */
+    _setAsset(key: string, definition: AssetDefinition<unknown>): void;
+    /**
+     * Internal method to set a screen definition
+     * @internal Used by mergeBundles
+     */
+    _setScreen(name: string, definition: ScreenDefinition<any, any>): void;
     /**
      * Get all systems defined in this bundle
      * Returns built System objects instead of SystemBuilders
@@ -68,16 +123,20 @@ type Exactly<T, U> = T extends U ? U extends T ? true : false : false;
  * Simplified type constraint for bundle compatibility
  * Ensures that overlapping keys have exactly the same types
  */
-type CompatibleBundles<C1 extends Record<string, any>, C2 extends Record<string, any>, E1 extends Record<string, any>, E2 extends Record<string, any>, R1 extends Record<string, any>, R2 extends Record<string, any>> = {
+type CompatibleBundles<C1 extends Record<string, any>, C2 extends Record<string, any>, E1 extends Record<string, any>, E2 extends Record<string, any>, R1 extends Record<string, any>, R2 extends Record<string, any>, A1 extends Record<string, unknown> = {}, A2 extends Record<string, unknown> = {}, S1 extends Record<string, ScreenDefinition<any, any>> = {}, S2 extends Record<string, ScreenDefinition<any, any>> = {}> = {
     [K in keyof C1 & keyof C2]: Exactly<C1[K], C2[K]> extends true ? C1[K] : never;
 } & {
     [K in keyof E1 & keyof E2]: Exactly<E1[K], E2[K]> extends true ? E1[K] : never;
 } & {
     [K in keyof R1 & keyof R2]: Exactly<R1[K], R2[K]> extends true ? R1[K] : never;
+} & {
+    [K in keyof A1 & keyof A2]: Exactly<A1[K], A2[K]> extends true ? A1[K] : never;
+} & {
+    [K in keyof S1 & keyof S2]: Exactly<S1[K], S2[K]> extends true ? S1[K] : never;
 };
 /**
  * Function that merges multiple bundles into a single bundle
  */
-export declare function mergeBundles<C1 extends Record<string, any>, E1 extends Record<string, any>, R1 extends Record<string, any>, C2 extends Record<string, any>, E2 extends Record<string, any>, R2 extends Record<string, any>>(id: string, bundle1: Bundle<C1, E1, R1>, bundle2: Bundle<C2, E2, R2> & CompatibleBundles<C1, C2, E1, E2, R1, R2>): Bundle<C1 & C2, E1 & E2, R1 & R2>;
-export declare function mergeBundles<ComponentTypes extends Record<string, any>, EventTypes extends Record<string, any>, ResourceTypes extends Record<string, any>>(id: string, ...bundles: Array<Bundle<ComponentTypes, EventTypes, ResourceTypes>>): Bundle<ComponentTypes, EventTypes, ResourceTypes>;
+export declare function mergeBundles<C1 extends Record<string, any>, E1 extends Record<string, any>, R1 extends Record<string, any>, A1 extends Record<string, unknown>, S1 extends Record<string, ScreenDefinition<any, any>>, C2 extends Record<string, any>, E2 extends Record<string, any>, R2 extends Record<string, any>, A2 extends Record<string, unknown>, S2 extends Record<string, ScreenDefinition<any, any>>>(id: string, bundle1: Bundle<C1, E1, R1, A1, S1>, bundle2: Bundle<C2, E2, R2, A2, S2> & CompatibleBundles<C1, C2, E1, E2, R1, R2, A1, A2, S1, S2>): Bundle<C1 & C2, E1 & E2, R1 & R2, A1 & A2, S1 & S2>;
+export declare function mergeBundles<ComponentTypes extends Record<string, any>, EventTypes extends Record<string, any>, ResourceTypes extends Record<string, any>, AssetTypes extends Record<string, unknown>, ScreenStates extends Record<string, ScreenDefinition<any, any>>>(id: string, ...bundles: Array<Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>>): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>;
 export {};

package/dist/bundles/renderers/pixi.d.ts

@@ -0,0 +1,248 @@
+/**
+ * PixiJS Renderer Bundle for ECSpresso
+ *
+ * An opt-in PixiJS rendering bundle that automates scene graph wiring.
+ * Import from 'ecspresso/bundles/renderers/pixi'
+ */
+import type { Application, ApplicationOptions, Container, Sprite, Graphics } from 'pixi.js';
+import Bundle from '../../bundle';
+/**
+ * Local transform relative to parent (or world if no parent)
+ */
+export interface LocalTransform {
+    x: number;
+    y: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+}
+/**
+ * Computed world transform (accumulated from parent chain)
+ */
+export interface WorldTransform {
+    x: number;
+    y: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+}
+/**
+ * PixiJS Sprite component
+ */
+export interface PixiSprite {
+    sprite: Sprite;
+    anchor?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * PixiJS Graphics component
+ */
+export interface PixiGraphics {
+    graphics: Graphics;
+}
+/**
+ * PixiJS Container component
+ */
+export interface PixiContainer {
+    container: Container;
+}
+/**
+ * Visibility and alpha component
+ */
+export interface PixiVisible {
+    visible: boolean;
+    alpha?: number;
+}
+/**
+ * Aggregate component types for PixiJS bundle.
+ * Users should extend this interface with their own component types.
+ *
+ * @example
+ * ```typescript
+ * interface GameComponents extends PixiComponentTypes {
+ *   velocity: { x: number; y: number };
+ *   player: true;
+ * }
+ * ```
+ */
+export interface PixiComponentTypes {
+    localTransform: LocalTransform;
+    worldTransform: WorldTransform;
+    pixiSprite: PixiSprite;
+    pixiGraphics: PixiGraphics;
+    pixiContainer: PixiContainer;
+    pixiVisible: PixiVisible;
+}
+/**
+ * Events emitted by the PixiJS bundle
+ */
+export interface PixiEventTypes {
+    hierarchyChanged: {
+        entityId: number;
+        oldParent: number | null;
+        newParent: number | null;
+    };
+}
+/**
+ * Resources provided by the PixiJS bundle
+ */
+export interface PixiResourceTypes {
+    pixiApp: Application;
+    pixiRootContainer: Container;
+}
+/**
+ * Common options shared between both initialization modes
+ */
+interface PixiBundleCommonOptions {
+    /** Optional custom root container (defaults to app.stage) */
+    rootContainer?: Container;
+    /** System group name (default: 'pixi-renderer') */
+    systemGroup?: string;
+    /** Priority for transform propagation system (default: 1000) */
+    transformPriority?: number;
+    /** Priority for render sync system (default: 500) */
+    renderSyncPriority?: number;
+}
+/**
+ * Options when providing a pre-initialized PixiJS Application
+ */
+export interface PixiBundleAppOptions extends PixiBundleCommonOptions {
+    /** The PixiJS Application instance (already initialized) */
+    app: Application;
+    init?: never;
+    container?: never;
+}
+/**
+ * Options when letting the bundle create and manage the PixiJS Application
+ */
+export interface PixiBundleManagedOptions extends PixiBundleCommonOptions {
+    app?: never;
+    /** PixiJS ApplicationOptions - bundle will create and initialize the Application */
+    init: Partial<ApplicationOptions>;
+    /** Container element to append the canvas to, or CSS selector string */
+    container?: HTMLElement | string;
+}
+/**
+ * Configuration options for the PixiJS bundle.
+ *
+ * Supports two modes:
+ * 1. **Pre-initialized**: Pass an already-initialized Application via `app`
+ * 2. **Managed**: Pass `init` options and the bundle creates the Application during `ecs.initialize()`
+ *
+ * @example Pre-initialized mode (full control)
+ * ```typescript
+ * const app = new Application();
+ * await app.init({ resizeTo: window });
+ * const ecs = ECSpresso.create<...>()
+ *   .withBundle(createPixiBundle({ app }))
+ *   .build();
+ * ```
+ *
+ * @example Managed mode (convenience)
+ * ```typescript
+ * const ecs = ECSpresso.create<...>()
+ *   .withBundle(createPixiBundle({
+ *     init: { background: '#1099bb', resizeTo: window },
+ *     container: document.body,
+ *   }))
+ *   .build();
+ * await ecs.initialize(); // Application created here
+ * ```
+ */
+export type PixiBundleOptions = PixiBundleAppOptions | PixiBundleManagedOptions;
+/**
+ * Default local transform values
+ */
+export declare const DEFAULT_LOCAL_TRANSFORM: Readonly<LocalTransform>;
+/**
+ * Default world transform values
+ */
+export declare const DEFAULT_WORLD_TRANSFORM: Readonly<WorldTransform>;
+interface PositionOption {
+    x?: number;
+    y?: number;
+}
+interface TransformOptions {
+    rotation?: number;
+    scale?: number | {
+        x: number;
+        y: number;
+    };
+    visible?: boolean;
+    alpha?: number;
+}
+/**
+ * Create components for a sprite entity.
+ * Returns an object suitable for spreading into spawn().
+ *
+ * @example
+ * ```typescript
+ * const player = ecs.spawn({
+ *   ...createSpriteComponents(new Sprite(texture), { x: 100, y: 100 }),
+ *   velocity: { x: 0, y: 0 },
+ * });
+ * ```
+ */
+export declare function createSpriteComponents(sprite: Sprite, position?: PositionOption, options?: TransformOptions & {
+    anchor?: {
+        x: number;
+        y: number;
+    };
+}): Pick<PixiComponentTypes, 'pixiSprite' | 'localTransform' | 'worldTransform' | 'pixiVisible'>;
+/**
+ * Create components for a graphics entity.
+ * Returns an object suitable for spreading into spawn().
+ *
+ * @example
+ * ```typescript
+ * const rect = ecs.spawn({
+ *   ...createGraphicsComponents(graphics, { x: 50, y: 50 }),
+ * });
+ * ```
+ */
+export declare function createGraphicsComponents(graphics: Graphics, position?: PositionOption, options?: TransformOptions): Pick<PixiComponentTypes, 'pixiGraphics' | 'localTransform' | 'worldTransform' | 'pixiVisible'>;
+/**
+ * Create components for a container entity.
+ * Returns an object suitable for spreading into spawn().
+ *
+ * @example
+ * ```typescript
+ * const group = ecs.spawn({
+ *   ...createContainerComponents(new Container(), { x: 0, y: 0 }),
+ * });
+ * ```
+ */
+export declare function createContainerComponents(container: Container, position?: PositionOption, options?: TransformOptions): Pick<PixiComponentTypes, 'pixiContainer' | 'localTransform' | 'worldTransform' | 'pixiVisible'>;
+/**
+ * Create a PixiJS rendering bundle for ECSpresso.
+ *
+ * This bundle provides:
+ * - Transform propagation system (computes world transforms from hierarchy)
+ * - Render sync system (updates PixiJS objects from ECS components)
+ * - Scene graph management (mirrors ECS hierarchy in PixiJS scene graph)
+ *
+ * @example Pre-initialized mode
+ * ```typescript
+ * const app = new Application();
+ * await app.init({ resizeTo: window });
+ *
+ * const ecs = ECSpresso.create<GameComponents, {}, {}>()
+ *   .withBundle(createPixiBundle({ app }))
+ *   .build();
+ * ```
+ *
+ * @example Managed mode
+ * ```typescript
+ * const ecs = ECSpresso.create<GameComponents, {}, {}>()
+ *   .withBundle(createPixiBundle({
+ *     init: { background: '#1099bb', resizeTo: window },
+ *     container: document.body,
+ *   }))
+ *   .build();
+ * await ecs.initialize();
+ * ```
+ */
+export declare function createPixiBundle(options: PixiBundleOptions): Bundle<PixiComponentTypes, PixiEventTypes, PixiResourceTypes>;
+export {};

package/dist/bundles/renderers/pixi.js

@@ -0,0 +1,4 @@
+var O=Object.create;var{getPrototypeOf:I,defineProperty:j,getOwnPropertyNames:T}=Object;var f=Object.prototype.hasOwnProperty;var u=(H,J,K)=>{K=H!=null?O(I(H)):{};let F=J||!H||!H.__esModule?j(K,"default",{value:H,enumerable:!0}):K;for(let R of T(H))if(!f.call(F,R))j(F,R,{get:()=>H[R],enumerable:!0});return F};var b=((H)=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(H,{get:(J,K)=>(typeof require<"u"?require:J)[K]}):H)(function(H){if(typeof require<"u")return require.apply(this,arguments);throw Error('Dynamic require of "'+H+'" is not supported')});class k{_label;_ecspresso;_bundle;queries={};processFunction;detachFunction;initializeFunction;eventHandlers;_priority=0;_isRegistered=!1;_groups=[];_inScreens;_excludeScreens;_requiredAssets;constructor(H,J=null,K=null){this._label=H;this._ecspresso=J;this._bundle=K}get label(){return this._label}get bundle(){return this._bundle}get ecspresso(){return this._ecspresso}_autoRegister(){if(this._isRegistered||!this._ecspresso)return;let H=this._buildSystemObject();G(H,this._ecspresso),this._isRegistered=!0}_buildSystemObject(){return this._createSystemObject()}_createSystemObject(){let H={label:this._label,entityQueries:this.queries,priority:this._priority};if(this.processFunction)H.process=this.processFunction;if(this.detachFunction)H.onDetach=this.detachFunction;if(this.initializeFunction)H.onInitialize=this.initializeFunction;if(this.eventHandlers)H.eventHandlers=this.eventHandlers;if(this._groups.length>0)H.groups=[...this._groups];if(this._inScreens)H.inScreens=this._inScreens;if(this._excludeScreens)H.excludeScreens=this._excludeScreens;if(this._requiredAssets)H.requiredAssets=this._requiredAssets;return H}setPriority(H){return this._priority=H,this}inGroup(H){if(!this._groups.includes(H))this._groups.push(H);return this}inScreens(H){return this._inScreens=[...H],this}excludeScreens(H){return this._excludeScreens=[...H],this}requiresAssets(H){return this._requiredAssets=[...H],this}addQuery(H,J){let K=this;return K.queries={...this.queries,[H]:J},K}setProcess(H){return this.processFunction=H,this}registerAndContinue(){if(!this._ecspresso)throw Error(`Cannot register system '${this._label}': SystemBuilder is not attached to an ECSpresso instance. Use Bundle.addSystem() or ECSpresso.addSystem() instead.`);return this._autoRegister(),this._ecspresso}and(){if(this._ecspresso)return this._autoRegister(),this._ecspresso;if(this._bundle)return this._bundle;throw Error(`Cannot use and() on system '${this._label}': not attached to ECSpresso or Bundle.`)}setOnDetach(H){return this.detachFunction=H,this}setOnInitialize(H){return this.initializeFunction=H,this}setEventHandlers(H){return this.eventHandlers=H,this}build(H){let J=this._createSystemObject();if(this._ecspresso)G(J,this._ecspresso);if(H)G(J,H);return this}}function G(H,J){J._registerSystem(H)}function c(H,J){return new k(H,J)}function x(H,J){return new k(H,null,J)}function y(){return`bundle_${Date.now().toString(36)}_${Math.random().toString(36).substring(2,9)}`}class E{_systems=[];_resources=new Map;_assets=new Map;_assetGroups=new Map;_screens=new Map;_id;constructor(H){this._id=H||y()}get id(){return this._id}set id(H){this._id=H}addSystem(H){if(typeof H==="string"){let J=x(H,this);return this._systems.push(J),J}else return this._systems.push(H),H}addResource(H,J){return this._resources.set(H,J),this}addAsset(H,J,K){return this._assets.set(H,{loader:J,eager:K?.eager??!0,group:K?.group}),this}addAssetGroup(H,J){let K=new Map;for(let[F,R]of Object.entries(J))K.set(F,R),this._assets.set(F,{loader:R,eager:!1,group:H});return this._assetGroups.set(H,K),this}addScreen(H,J){return this._screens.set(H,J),this}getAssets(){return new Map(this._assets)}getScreens(){return new Map(this._screens)}_setResource(H,J){this._resources.set(H,J)}_setAsset(H,J){this._assets.set(H,J)}_setScreen(H,J){this._screens.set(H,J)}getSystems(){return this._systems.map((H)=>H.build())}registerSystemsWithEcspresso(H){for(let J of this._systems)J.build(H)}getResources(){return new Map(this._resources)}getResource(H){return this._resources.get(H)}getSystemBuilders(){return[...this._systems]}hasResource(H){return this._resources.has(H)}}function n(H,...J){if(J.length===0)return new E(H);let K=new E(H);for(let F of J){for(let R of F.getSystemBuilders())K.addSystem(R);for(let[R,Y]of F.getResources().entries())K._setResource(R,Y);for(let[R,Y]of F.getAssets().entries())K._setAsset(R,Y);for(let[R,Y]of F.getScreens().entries())K._setScreen(R,Y)}return K}async function m(H){let{Application:J}=await import("pixi.js"),K=new J;return await K.init(H),K}var t={x:0,y:0,rotation:0,scaleX:1,scaleY:1},o={x:0,y:0,rotation:0,scaleX:1,scaleY:1};function L(H,J){let K=J?.scale,F=typeof K==="number"?K:K?.x??1,R=typeof K==="number"?K:K?.y??1;return{x:H?.x??0,y:H?.y??0,rotation:J?.rotation??0,scaleX:F,scaleY:R}}function V(H,J){let K=J?.scale,F=typeof K==="number"?K:K?.x??1,R=typeof K==="number"?K:K?.y??1;return{x:H?.x??0,y:H?.y??0,rotation:J?.rotation??0,scaleX:F,scaleY:R}}function B(H){return{visible:H?.visible??!0,alpha:H?.alpha}}function e(H,J,K){return{pixiSprite:{sprite:H,anchor:K?.anchor},localTransform:L(J,K),worldTransform:V(J,K),pixiVisible:B(K)}}function HH(H,J,K){return{pixiGraphics:{graphics:H},localTransform:L(J,K),worldTransform:V(J,K),pixiVisible:B(K)}}function JH(H,J,K){return{pixiContainer:{container:H},localTransform:L(J,K),worldTransform:V(J,K),pixiVisible:B(K)}}function KH(H){let{rootContainer:J,systemGroup:K="pixi-renderer",transformPriority:F=1000,renderSyncPriority:R=500}=H,Y=new E("pixi-renderer");if("init"in H&&H.init!==void 0){let{init:_,container:Q}=H;Y.addResource("pixiApp",async()=>{let U=await m(_);if(Q){let D=typeof Q==="string"?document.querySelector(Q):Q;if(D)D.appendChild(U.canvas);else if(typeof Q==="string")console.warn(`PixiJS bundle: container selector "${Q}" not found`)}return U}),Y.addResource("pixiRootContainer",{dependsOn:["pixiApp"],factory:(U)=>J??U.getResource("pixiApp").stage})}else{let _=H.app;Y.addResource("pixiApp",_),Y.addResource("pixiRootContainer",J??_.stage)}let q=new Map;function W(_,Q){let U=q.get(_);if(U)return U;let D=Q.entityManager.getComponent(_,"pixiSprite");if(D)return q.set(_,D.sprite),D.sprite;let z=Q.entityManager.getComponent(_,"pixiGraphics");if(z)return q.set(_,z.graphics),z.graphics;let $=Q.entityManager.getComponent(_,"pixiContainer");if($)return q.set(_,$.container),$.container;return null}function A(_,Q,U){let D=U.getResource("pixiRootContainer"),z=U.getParent(_),M=(z!==null?W(z,U):null)??D;if(Q.parent!==M)M.addChild(Q)}function N(_){let Q=q.get(_);if(Q)Q.removeFromParent(),q.delete(_)}function g(_,Q){let U=q.get(_);if(!U)return;let D=Q.getResource("pixiRootContainer"),z=Q.getParent(_),M=(z!==null?W(z,Q):null)??D;if(U.parent!==M)U.removeFromParent(),M.addChild(U)}return Y.addSystem("pixi-transform-propagation").setPriority(F).inGroup(K).setProcess((_,Q,U)=>{U.forEachInHierarchy((z,$)=>{let M=U.entityManager.getComponent(z,"localTransform"),Z=U.entityManager.getComponent(z,"worldTransform");if(!M||!Z)return;if($===null)Z.x=M.x,Z.y=M.y,Z.rotation=M.rotation,Z.scaleX=M.scaleX,Z.scaleY=M.scaleY;else{let X=U.entityManager.getComponent($,"worldTransform");if(X){let P=M.x*X.scaleX,v=M.y*X.scaleY,S=Math.cos(X.rotation),C=Math.sin(X.rotation),w=P*S-v*C,h=P*C+v*S;Z.x=X.x+w,Z.y=X.y+h,Z.rotation=X.rotation+M.rotation,Z.scaleX=X.scaleX*M.scaleX,Z.scaleY=X.scaleY*M.scaleY}else Z.x=M.x,Z.y=M.y,Z.rotation=M.rotation,Z.scaleX=M.scaleX,Z.scaleY=M.scaleY}});let D=U.getEntitiesWithQuery(["localTransform","worldTransform"]);for(let z of D)if(U.getParent(z.id)===null&&U.getChildren(z.id).length===0){let{localTransform:M,worldTransform:Z}=z.components;Z.x=M.x,Z.y=M.y,Z.rotation=M.rotation,Z.scaleX=M.scaleX,Z.scaleY=M.scaleY}}).and(),Y.addSystem("pixi-render-sync").setPriority(R).inGroup(K).addQuery("sprites",{with:["pixiSprite","worldTransform"]}).addQuery("graphics",{with:["pixiGraphics","worldTransform"]}).addQuery("containers",{with:["pixiContainer","worldTransform"]}).setProcess((_,Q,U)=>{for(let D of _.sprites){let{pixiSprite:z,worldTransform:$}=D.components,{sprite:M,anchor:Z}=z;if(M.position.set($.x,$.y),M.rotation=$.rotation,M.scale.set($.scaleX,$.scaleY),Z)M.anchor.set(Z.x,Z.y);let X=U.entityManager.getComponent(D.id,"pixiVisible");if(X){if(M.visible=X.visible,X.alpha!==void 0)M.alpha=X.alpha}}for(let D of _.graphics){let{pixiGraphics:z,worldTransform:$}=D.components,{graphics:M}=z;M.position.set($.x,$.y),M.rotation=$.rotation,M.scale.set($.scaleX,$.scaleY);let Z=U.entityManager.getComponent(D.id,"pixiVisible");if(Z){if(M.visible=Z.visible,Z.alpha!==void 0)M.alpha=Z.alpha}}for(let D of _.containers){let{pixiContainer:z,worldTransform:$}=D.components,{container:M}=z;M.position.set($.x,$.y),M.rotation=$.rotation,M.scale.set($.scaleX,$.scaleY);let Z=U.entityManager.getComponent(D.id,"pixiVisible");if(Z){if(M.visible=Z.visible,Z.alpha!==void 0)M.alpha=Z.alpha}}}).and(),Y.addSystem("pixi-scene-graph-manager").setPriority(9999).inGroup(K).setOnInitialize((_)=>{_.addReactiveQuery("pixi-sprites",{with:["pixiSprite"],onEnter:(Q)=>{let U=Q.components.pixiSprite.sprite;q.set(Q.id,U),A(Q.id,U,_)},onExit:(Q)=>{N(Q)}}),_.addReactiveQuery("pixi-graphics",{with:["pixiGraphics"],onEnter:(Q)=>{let U=Q.components.pixiGraphics.graphics;q.set(Q.id,U),A(Q.id,U,_)},onExit:(Q)=>{N(Q)}}),_.addReactiveQuery("pixi-containers",{with:["pixiContainer"],onEnter:(Q)=>{let U=Q.components.pixiContainer.container;q.set(Q.id,U),A(Q.id,U,_)},onExit:(Q)=>{N(Q)}}),_.on("hierarchyChanged",({entityId:Q})=>{g(Q,_)})}).and(),Y}export{e as createSpriteComponents,KH as createPixiBundle,HH as createGraphicsComponents,JH as createContainerComponents,o as DEFAULT_WORLD_TRANSFORM,t as DEFAULT_LOCAL_TRANSFORM};
+
+//# debugId=3807489A54FF20AF64756E2164756E21
+//# sourceMappingURL=pixi.js.map