ecspresso 0.5.0 → 0.6.0

package/dist/reactive-query-manager.d.ts

@@ -0,0 +1,59 @@
+import type { Entity, FilteredEntity } from "./types";
+import type EntityManager from "./entity-manager";
+/**
+ * Definition for a reactive query with enter/exit callbacks
+ */
+export interface ReactiveQueryDefinition<ComponentTypes extends Record<string, any>, WithComponents extends keyof ComponentTypes = keyof ComponentTypes, WithoutComponents extends keyof ComponentTypes = never> {
+    /** Components the entity must have */
+    with: ReadonlyArray<WithComponents>;
+    /** Components the entity must not have */
+    without?: ReadonlyArray<WithoutComponents>;
+    /** Called when an entity starts matching the query */
+    onEnter?: (entity: FilteredEntity<ComponentTypes, WithComponents, WithoutComponents>) => void;
+    /** Called when an entity stops matching the query (receives just the ID since entity may be gone) */
+    onExit?: (entityId: number) => void;
+}
+/**
+ * Manages reactive queries that trigger callbacks when entities enter/exit query matches
+ */
+export default class ReactiveQueryManager<ComponentTypes extends Record<string, any>> {
+    private queries;
+    private entityManager;
+    constructor(entityManager: EntityManager<ComponentTypes>);
+    /**
+     * Add a reactive query
+     * @param name Unique name for the query
+     * @param definition Query definition with callbacks
+     */
+    addQuery<WithComponents extends keyof ComponentTypes, WithoutComponents extends keyof ComponentTypes = never>(name: string, definition: ReactiveQueryDefinition<ComponentTypes, WithComponents, WithoutComponents>): void;
+    /**
+     * Remove a reactive query
+     * @param name Name of the query to remove
+     * @returns true if the query existed and was removed
+     */
+    removeQuery(name: string): boolean;
+    /**
+     * Check if an entity matches a query definition
+     */
+    private entityMatchesQuery;
+    /**
+     * Called when a component is added to an entity
+     * Checks all queries for potential enter/exit events
+     */
+    onComponentAdded(entity: Entity<ComponentTypes>, _componentName: keyof ComponentTypes): void;
+    /**
+     * Called when a component is removed from an entity
+     * Checks all queries for potential enter/exit events
+     */
+    onComponentRemoved(entity: Entity<ComponentTypes>, _componentName: keyof ComponentTypes): void;
+    /**
+     * Called when an entity is removed
+     * Triggers onExit for all queries the entity was matching
+     */
+    onEntityRemoved(entityId: number): void;
+    /**
+     * Recheck an entity against all queries (used after batch component additions)
+     * Fires enter/exit callbacks as appropriate based on current state vs tracked state
+     */
+    recheckEntity(entity: Entity<ComponentTypes>): void;
+}

package/dist/resource-manager.d.ts

@@ -1,14 +1,24 @@
+/**
+ * Resource factory with declared dependencies and optional disposal callback
+ */
+interface ResourceFactoryWithDeps<T> {
+    dependsOn?: readonly string[];
+    factory: (context?: any) => T | Promise<T>;
+    onDispose?: (resource: T, context?: any) => void | Promise<void>;
+}
 export default class ResourceManager<ResourceTypes extends Record<string, any> = Record<string, any>> {
     private resources;
     private resourceFactories;
+    private resourceDependencies;
+    private resourceDisposers;
     private initializedResourceKeys;
     /**
      * Add a resource to the manager
      * @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
      * @returns The resource manager instance for chaining
      */
-    add<K extends keyof ResourceTypes>(label: K, resource: ResourceTypes[K] | ((context?: any) => ResourceTypes[K] | Promise<ResourceTypes[K]>)): this;
+    add<K extends keyof ResourceTypes>(label: K, resource: ResourceTypes[K] | ((context?: any) => ResourceTypes[K] | Promise<ResourceTypes[K]>) | ResourceFactoryWithDeps<ResourceTypes[K]>): this;
     /**
      * Improved detection of factory functions vs direct values/classes
      * @private
@@ -29,7 +39,7 @@ export default class ResourceManager<ResourceTypes extends Record<string, any> =
      */
     has<K extends keyof ResourceTypes>(label: K): boolean;
     /**
-     * Remove a resource
+     * Remove a resource (without calling onDispose)
      * @param label The resource key
      * @returns True if the resource was removed
      */
@@ -58,9 +68,31 @@ export default class ResourceManager<ResourceTypes extends Record<string, any> =
      */
     initializeResource<K extends keyof ResourceTypes>(label: K, context?: any): Promise<void>;
     /**
-     * Initialize specific resources or all resources that haven't been initialized yet
-     * @param keys Optional array of resource keys to initialize or optional context to pass to factory functions
+     * Initialize specific resources or all resources that haven't been initialized yet.
+     * Resources are initialized in topological order based on their dependencies.
+     * @param context Optional context to pass to factory functions (usually the ECSpresso instance)
+     * @param keys Optional array of resource keys to initialize
      * @returns Promise that resolves when the specified resources are initialized
      */
     initializeResources<K extends keyof ResourceTypes>(context?: any, ...keys: K[]): Promise<void>;
+    /**
+     * Get the dependencies of a resource
+     * @param label The resource key
+     * @returns Array of resource keys that this resource depends on
+     */
+    getDependencies<K extends keyof ResourceTypes>(label: K): readonly string[];
+    /**
+     * Dispose a single resource, calling its onDispose callback if it exists
+     * @param label The resource key to dispose
+     * @param context Optional context to pass to the onDispose callback
+     * @returns True if the resource existed and was disposed, false if it didn't exist
+     */
+    disposeResource<K extends keyof ResourceTypes>(label: K, context?: any): Promise<boolean>;
+    /**
+     * Dispose all initialized resources in reverse dependency order.
+     * Resources that depend on others are disposed first.
+     * @param context Optional context to pass to onDispose callbacks
+     */
+    disposeResources(context?: any): Promise<void>;
 }
+export {};

package/dist/system-builder.d.ts

@@ -15,6 +15,7 @@ export declare class SystemBuilder<ComponentTypes extends Record<string, any> =
     private eventHandlers?;
     private _priority;
     private _isRegistered;
+    private _groups;
     private _inScreens?;
     private _excludeScreens?;
     private _requiredAssets?;
@@ -51,6 +52,13 @@ export declare class SystemBuilder<ComponentTypes extends Record<string, any> =
      * @returns This SystemBuilder instance for method chaining
      */
     setPriority(priority: number): this;
+    /**
+     * Add this system to a group. Systems can belong to multiple groups.
+     * When any group a system belongs to is disabled, the system will be skipped.
+     * @param groupName The name of the group to add the system to
+     * @returns This SystemBuilder instance for method chaining
+     */
+    inGroup(groupName: string): this;
     /**
      * Restrict this system to only run in specified screens.
      * System will be skipped during update() when the current screen

package/dist/types.d.ts

@@ -23,6 +23,24 @@ export interface HierarchyChangedEvent {
     /** The new parent, or null if entity was orphaned */
     newParent: number | null;
 }
+/**
+ * Options for hierarchy traversal methods
+ */
+export interface HierarchyIteratorOptions {
+    /** Specific root entities to start traversal from. If not provided, all root entities are used. */
+    roots?: readonly number[];
+}
+/**
+ * Entry yielded during hierarchy traversal
+ */
+export interface HierarchyEntry {
+    /** The entity being visited */
+    entityId: number;
+    /** The parent entity ID, or null for root entities */
+    parentId: number | null;
+    /** Depth in the hierarchy (0 for roots) */
+    depth: number;
+}
 export interface EventHandler<T> {
     callback: (data: T) => void;
     once: boolean;
@@ -107,6 +125,10 @@ export interface System<ComponentTypes extends Record<string, any> = {}, WithCom
      * When systems have the same priority, they execute in registration order
      */
     priority?: number;
+    /**
+     * Groups this system belongs to. If any group is disabled, the system will be skipped.
+     */
+    groups?: string[];
     /**
      * Screens where this system should run. If specified, system only runs
      * when current screen is in this list.

package/package.json

@@ -1,11 +1,25 @@
 {
 	"name": "ecspresso",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"main": "dist/index.js",
 	"module": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"description": "A minimal Entity-Component-System library for typescript and javascript.",
 	"sideEffects": false,
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./bundles/renderers/pixi": {
+			"import": "./dist/bundles/renderers/pixi.js",
+			"types": "./dist/bundles/renderers/pixi.d.ts"
+		},
+		"./bundles/utils/timers": {
+			"import": "./dist/bundles/utils/timers.js",
+			"types": "./dist/bundles/utils/timers.d.ts"
+		}
+	},
 	"publishConfig": {
 		"registry": "https://npm.pkg.github.com/"
 	},
@@ -30,7 +44,13 @@
 		"three": "^0.180.0"
 	},
 	"peerDependencies": {
-		"typescript": "^5.9.2"
+		"typescript": "^5.9.2",
+		"pixi.js": "^8.0.0"
+	},
+	"peerDependenciesMeta": {
+		"pixi.js": {
+			"optional": true
+		}
 	},
 	"files": [
 		"dist"
@@ -38,7 +58,7 @@
 	"scripts": {
 		"build:clean": "rm -rf dist",
 		"build:ts": "bun tsc -p tsconfig.build.json",
-		"build:js": "bun build --target=browser --sourcemap=linked --minify --outdir=dist src/index.ts",
+		"build:js": "bun build --target=browser --sourcemap=linked --minify --external=pixi.js --outdir=dist src/index.ts src/bundles/renderers/pixi.ts src/bundles/utils/timers.ts",
 		"build": "bun build:clean && bun build:ts && bun build:js",
 		"check:types": "bun tsc --noEmit --skipLibCheck",
 		"check": "bun run check:types && bun test",