ecspresso 0.5.0 → 0.6.0

package/README.md

@@ -15,6 +15,9 @@ A type-safe, modular, and extensible Entity Component System (ECS) framework for
 - **Screen Management**: Game state/screen transitions with overlay support
 - **Entity Hierarchy**: Parent-child relationships with traversal and cascade deletion
 - **Query System**: Powerful entity filtering with helper type utilities
+- **Reactive Queries**: Enter/exit callbacks when entities match or unmatch queries
+- **System Groups**: Enable/disable groups of systems at runtime
+- **Component Lifecycle**: Callbacks for component add/remove with unsubscribe support
 
 ## Installation
 
@@ -212,6 +215,35 @@ world.addSystem('physics')
   .build();
 ```
 
+### System Groups
+
+Organize systems into groups that can be enabled/disabled at runtime:
+
+```typescript
+// Assign systems to groups
+world.addSystem('renderSprites')
+  .inGroup('rendering')
+  .addQuery('sprites', { with: ['position', 'sprite'] })
+  .setProcess((queries) => { /* ... */ })
+  .and()
+  .addSystem('renderParticles')
+  .inGroup('rendering')
+  .inGroup('effects')  // Systems can belong to multiple groups
+  .setProcess(() => { /* ... */ })
+  .build();
+
+// Disable/enable groups at runtime
+world.disableSystemGroup('rendering');  // All rendering systems skip
+world.enableSystemGroup('rendering');   // Resume rendering
+
+// Query group state
+world.isSystemGroupEnabled('rendering');  // true/false
+world.getSystemsInGroup('rendering');     // ['renderSprites', 'renderParticles']
+
+// If a system belongs to multiple groups, disabling ANY group skips the system
+world.disableSystemGroup('effects');  // renderParticles won't run
+```
+
 ## Advanced Features
 
 ### Bundles
@@ -316,7 +348,8 @@ Create resources lazily with factory functions:
 ```typescript
 interface Resources {
   config: { difficulty: string; soundEnabled: boolean };
-  assets: { textures: any[] };
+  database: Database;
+  cache: { db: Database };
 }
 
 const world = new ECSpresso<Components, {}, Resources>();
@@ -328,15 +361,87 @@ world.addResource('config', () => ({
 }));
 
 // Async factory
-world.addResource('assets', async () => {
-  const textures = await loadTextures();
-  return { textures };
+world.addResource('database', async () => {
+  return await connectToDatabase();
 });
 
-// Initialize all resources
+// Factory with dependencies - initialized after dependencies are ready
+world.addResource('cache', {
+  dependsOn: ['database'],
+  factory: (ecs) => ({
+    db: ecs.getResource('database')
+  })
+});
+
+// Initialize all resources (respects dependency order)
 await world.initializeResources();
 ```
 
+**Dependency Features:**
+- Resources are initialized in topological order (dependencies first)
+- Circular dependencies throw a descriptive error at initialization time
+- Existing patterns (direct values, simple factories) work unchanged
+
+### Resource Builder
+
+Add resources fluently during ECSpresso construction using `withResource()`:
+
+```typescript
+const world = ECSpresso
+  .create<Components, Events, Resources>()
+  .withBundle(physicsBundle)
+  .withResource('config', { debug: true, maxEntities: 1000 })
+  .withResource('score', () => ({ value: 0 }))
+  .withResource('cache', {
+    dependsOn: ['database'],
+    factory: (ecs) => createCache(ecs.getResource('database'))
+  })
+  .build();
+```
+
+This chains naturally with `withBundle()`, `withAssets()`, and `withScreens()`.
+
+### Resource Disposal
+
+Resources can define cleanup logic with `onDispose` callbacks, useful for removing event listeners, closing connections, or releasing resources:
+
+```typescript
+// Factory with disposal callback
+world.addResource('keyboard', {
+  factory: () => {
+    const handler = (e: KeyboardEvent) => { /* ... */ };
+    window.addEventListener('keydown', handler);
+    return { handler };
+  },
+  onDispose: (resource) => {
+    window.removeEventListener('keydown', resource.handler);
+  }
+});
+
+// Or with the builder pattern
+const world = ECSpresso
+  .create<Components, Events, Resources>()
+  .withResource('database', {
+    factory: async () => await connectToDatabase(),
+    onDispose: async (db) => await db.close()
+  })
+  .build();
+
+// Dispose a single resource
+await world.disposeResource('keyboard');
+
+// Dispose all resources in reverse dependency order
+// (dependents are disposed before their dependencies)
+await world.disposeResources();
+```
+
+**Disposal Features:**
+- `onDispose` receives the resource value and the ECSpresso instance as context
+- `disposeResources()` disposes in reverse topological order (dependents first)
+- Only initialized resources have their `onDispose` called
+- Supports both sync and async disposal callbacks
+- `removeResource()` still exists for removal without disposal
+
 ### System Lifecycle
 
 Systems can have initialization and cleanup hooks:
@@ -446,6 +551,32 @@ world.getChildAt(root.id, 0);         // child.id
 world.getChildIndex(root.id, child2.id); // 1
 ```
 
+#### Parent-First Traversal
+
+Iterate the hierarchy with guaranteed parent-first order (useful for transform propagation):
+
+```typescript
+// Callback-based traversal
+world.forEachInHierarchy((entityId, parentId, depth) => {
+  // Parents are always visited before their children
+  console.log(`Entity ${entityId} at depth ${depth}, parent: ${parentId}`);
+});
+
+// Filter to specific subtrees
+world.forEachInHierarchy(
+  (entityId, parentId, depth) => {
+    // Only visits entities under root.id
+  },
+  { roots: [root.id] }
+);
+
+// Generator-based traversal (supports early termination)
+for (const { entityId, parentId, depth } of world.hierarchyIterator()) {
+  if (depth > 2) break; // Stop at depth 2
+  console.log(entityId);
+}
+```
+
 #### Cascade Deletion
 
 When removing entities, descendants are automatically removed by default:
@@ -771,19 +902,71 @@ world.withBundle(conflictingBundle); // TypeScript prevents this
 
 ## Component Callbacks
 
-React to component changes with callbacks:
+React to component changes with callbacks. Both methods return an unsubscribe function:
 
 ```typescript
-// Listen for component additions/removals
-world.entityManager.onComponentAdded('health', (value, entity) => {
+// Listen for component additions - returns unsubscribe function
+const unsubAdd = world.onComponentAdded('health', (value, entity) => {
   console.log(`Health added to entity ${entity.id}:`, value);
 });
 
-world.entityManager.onComponentRemoved('health', (oldValue, entity) => {
+// Listen for component removals
+const unsubRemove = world.onComponentRemoved('health', (oldValue, entity) => {
   console.log(`Health removed from entity ${entity.id}:`, oldValue);
 });
+
+// Unsubscribe when done
+unsubAdd();
+unsubRemove();
+
+// Also available on entityManager directly
+world.entityManager.onComponentAdded('position', (value, entity) => {
+  // ...
+});
 ```
 
+## Reactive Queries
+
+Get callbacks when entities enter or exit a query match. Unlike regular queries that you poll during `update()`, reactive queries push notifications when the entity's components change:
+
+```typescript
+// Add a reactive query with enter/exit callbacks
+world.addReactiveQuery('enemies', {
+  with: ['position', 'enemy'],
+  without: ['dead'],
+  onEnter: (entity) => {
+    // Called when entity starts matching the query
+    console.log(`Enemy ${entity.id} appeared at`, entity.components.position);
+    spawnHealthBar(entity.id);
+  },
+  onExit: (entityId) => {
+    // Called when entity stops matching (receives ID since entity may be removed)
+    console.log(`Enemy ${entityId} gone`);
+    removeHealthBar(entityId);
+  },
+});
+
+// Triggers: spawning matching entity, adding required component,
+//           removing excluded component
+const enemy = world.spawn({ position: { x: 0, y: 0 }, enemy: true }); // onEnter fires
+
+// Triggers: removing required component, adding excluded component,
+//           removing entity
+world.entityManager.addComponent(enemy.id, 'dead', true); // onExit fires
+
+// Existing matching entities trigger onEnter when query is added
+world.spawn({ position: { x: 10, y: 10 }, enemy: true });
+world.addReactiveQuery('positioned', {
+  with: ['position'],
+  onEnter: (entity) => { /* Called for all existing entities with position */ },
+});
+
+// Remove reactive query when no longer needed
+const removed = world.removeReactiveQuery('enemies'); // returns true if existed
+```
+
+**Note:** Component replacement (calling `addComponent` with a component that already exists) does NOT trigger enter/exit callbacks since the entity's query match status doesn't change.
+
 ## Error Handling
 
 ECSpresso provides clear, contextual error messages for common issues:

package/dist/bundle.d.ts

@@ -31,9 +31,12 @@ 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

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