@awesome-ecs/abstract 0.20.0 → 0.20.2

package/dist/pipeline-BGsQiSer.d.ts

@@ -0,0 +1,161 @@
+import { P as PerformanceTimeEntry } from './performance-timer-BVyl0SRs.js';
+
+/**
+ * Represents the result of a pipeline operation.
+ * It can provide performance metrics collected from self or inner middleware & pipeline calls.
+ */
+type PipelineResult = {
+    /**
+     * Performance metrics collected from the current pipeline operation.
+     * This field is optional and can be `undefined` if no performance metrics were collected.
+     */
+    readonly performance?: PerformanceTimeEntry;
+    /**
+     * An array of results from inner middleware & pipeline calls.
+     * This field is optional and can be `undefined` if there were no inner calls.
+     */
+    readonly inner?: PipelineResult[];
+};
+
+/**
+ * Represents the result that can be returned from a middleware function.
+ * It can either be void (indicating no result) or a PipelineResult instance.
+ *
+ * @remarks
+ * MiddlewareResult is used to provide Pipeline Results from inner pipeline calls.
+ * This is useful when a middleware function needs to return a result from an inner pipeline call.
+ **/
+type MiddlewareResult = void | PipelineResult;
+
+/**
+ * The PipelineStatus enum represents the different states a pipeline can be in.
+ *
+ * @remarks
+ * This enum is used to track the current status of the pipeline.
+ */
+declare enum PipelineStatus {
+    /**
+     * The pipeline is currently idle and not processing any tasks.
+     */
+    idle = "idle",
+    /**
+     * The pipeline is currently processing tasks.
+     */
+    ongoing = "ongoing",
+    /**
+     * The pipeline has completed all tasks successfully.
+     */
+    completed = "completed",
+    /**
+     * The pipeline has been halted due to an error or middleware intervention.
+     */
+    halted = "halted"
+}
+
+/**
+ * The Pipeline Context allows exposing state to the Pipeline's middlewares.
+ */
+interface IPipelineContext {
+    /**
+     * The runtime state of the pipeline.
+     */
+    readonly runtime: PipelineRuntime;
+}
+/**
+ * The Pipeline Runtime exposes runtime status controls for Middlewares, as part of the PipelineContext.
+ * It allows controlling the pipeline's execution flow.
+ */
+type PipelineRuntime = {
+    /**
+     * A flag indicating whether the pipeline should stop executing.
+     * If true, the pipeline execution will be stopped.
+     */
+    shouldStop: boolean;
+    /**
+     * The current status of the pipeline.
+     * It can be undefined if the status is not set.
+     */
+    status?: PipelineStatus;
+};
+
+/**
+ * A middleware, the building block of a Pipeline. Middlewares will provide a unit-of-work implementation
+ * dealing with potential state changes over the input Context, or running cleanup logic over the input Context.
+ *
+ * @template TContext The type of the context that the middleware will operate on.
+ * @template TResult The type of the result that the middleware will return.
+ */
+interface IMiddleware<TContext extends IPipelineContext, TResult = MiddlewareResult> {
+    /**
+     * An optional name for the middleware.
+     */
+    readonly name?: string;
+    /**
+     * This optional function gets called before executing the middleware. It acts as a boolean gateway whether enough conditions are
+     * being met so this middleware's action should run.
+     *
+     * @param context The Context to determine whether the run condition is satisfied.
+     * @returns A boolean indicating whether the middleware should run.
+     */
+    shouldRun?(context: TContext): boolean;
+    /**
+     * The function gets called as part of the pipeline, based on the registration order.
+     *
+     * @param context The Context can be read or updated. The Context holds all the state necessary for the execution of the middleware.
+     * @returns The result of the middleware's action.
+     */
+    action(context: TContext): TResult;
+    /**
+     * This optional function gets called when the cleanup of the Pipeline is necessary, based on reverse order of Middleware registration.
+     *
+     * @param context Part of the Context should be cleaned, and any allocated resources in the Action, should be disposed.
+     * @returns The result of the middleware's cleanup.
+     */
+    cleanup?(context: TContext): TResult;
+}
+
+/**
+ * An interface representing a middleware container and dispatcher.
+ * It allows registering and executing middleware functions in a pipeline.
+ *
+ * @template TContext - The type of the context object that will be passed to each middleware function.
+ * @template TResult - The type of the result that each middleware function will return.
+ *                     Defaults to {@link MiddlewareResult}.
+ */
+interface IPipeline<TContext extends IPipelineContext, TResult = MiddlewareResult> {
+    /**
+     * Represents the name of the pipeline.
+     * This property is optional and can be used for debugging purposes.
+     */
+    readonly name?: string;
+    /**
+     * Represents the number of middleware functions registered in the pipeline.
+     * This property is optional.
+     */
+    readonly length?: number;
+    /**
+     * Register middleware for this pipeline.
+     *
+     * @param middleware - The middleware function to be added to the pipeline.
+     * @returns This instance of the pipeline, allowing for method chaining.
+     */
+    use(middleware: IMiddleware<TContext, TResult>): this;
+    /**
+     * Execute the Dispatch phase on the chain of middleware, with the given Context.
+     * The Dispatch phase is responsible for invoking the middleware functions in the pipeline.
+     *
+     * @param context - The context object that will be passed to each middleware function.
+     * @returns A {@link PipelineResult} object representing the result of the pipeline execution.
+     */
+    dispatch(context: TContext): PipelineResult;
+    /**
+     * Execute the Cleanup phase on the chain of middleware, with the given Context.
+     * The Cleanup phase is responsible for performing any necessary cleanup operations after the pipeline execution.
+     *
+     * @param context - The context object that will be passed to each middleware function.
+     * @returns A {@link PipelineResult} object representing the result of the cleanup execution.
+     */
+    cleanup(context: TContext): PipelineResult;
+}
+
+export { type IPipelineContext as I, type MiddlewareResult as M, type PipelineResult as P, type IPipeline as a, type IMiddleware as b, type PipelineRuntime as c, PipelineStatus as d };

package/dist/pipeline-DunwPUPZ.d.cts

@@ -0,0 +1,161 @@
+import { P as PerformanceTimeEntry } from './performance-timer-BVyl0SRs.cjs';
+
+/**
+ * Represents the result of a pipeline operation.
+ * It can provide performance metrics collected from self or inner middleware & pipeline calls.
+ */
+type PipelineResult = {
+    /**
+     * Performance metrics collected from the current pipeline operation.
+     * This field is optional and can be `undefined` if no performance metrics were collected.
+     */
+    readonly performance?: PerformanceTimeEntry;
+    /**
+     * An array of results from inner middleware & pipeline calls.
+     * This field is optional and can be `undefined` if there were no inner calls.
+     */
+    readonly inner?: PipelineResult[];
+};
+
+/**
+ * Represents the result that can be returned from a middleware function.
+ * It can either be void (indicating no result) or a PipelineResult instance.
+ *
+ * @remarks
+ * MiddlewareResult is used to provide Pipeline Results from inner pipeline calls.
+ * This is useful when a middleware function needs to return a result from an inner pipeline call.
+ **/
+type MiddlewareResult = void | PipelineResult;
+
+/**
+ * The PipelineStatus enum represents the different states a pipeline can be in.
+ *
+ * @remarks
+ * This enum is used to track the current status of the pipeline.
+ */
+declare enum PipelineStatus {
+    /**
+     * The pipeline is currently idle and not processing any tasks.
+     */
+    idle = "idle",
+    /**
+     * The pipeline is currently processing tasks.
+     */
+    ongoing = "ongoing",
+    /**
+     * The pipeline has completed all tasks successfully.
+     */
+    completed = "completed",
+    /**
+     * The pipeline has been halted due to an error or middleware intervention.
+     */
+    halted = "halted"
+}
+
+/**
+ * The Pipeline Context allows exposing state to the Pipeline's middlewares.
+ */
+interface IPipelineContext {
+    /**
+     * The runtime state of the pipeline.
+     */
+    readonly runtime: PipelineRuntime;
+}
+/**
+ * The Pipeline Runtime exposes runtime status controls for Middlewares, as part of the PipelineContext.
+ * It allows controlling the pipeline's execution flow.
+ */
+type PipelineRuntime = {
+    /**
+     * A flag indicating whether the pipeline should stop executing.
+     * If true, the pipeline execution will be stopped.
+     */
+    shouldStop: boolean;
+    /**
+     * The current status of the pipeline.
+     * It can be undefined if the status is not set.
+     */
+    status?: PipelineStatus;
+};
+
+/**
+ * A middleware, the building block of a Pipeline. Middlewares will provide a unit-of-work implementation
+ * dealing with potential state changes over the input Context, or running cleanup logic over the input Context.
+ *
+ * @template TContext The type of the context that the middleware will operate on.
+ * @template TResult The type of the result that the middleware will return.
+ */
+interface IMiddleware<TContext extends IPipelineContext, TResult = MiddlewareResult> {
+    /**
+     * An optional name for the middleware.
+     */
+    readonly name?: string;
+    /**
+     * This optional function gets called before executing the middleware. It acts as a boolean gateway whether enough conditions are
+     * being met so this middleware's action should run.
+     *
+     * @param context The Context to determine whether the run condition is satisfied.
+     * @returns A boolean indicating whether the middleware should run.
+     */
+    shouldRun?(context: TContext): boolean;
+    /**
+     * The function gets called as part of the pipeline, based on the registration order.
+     *
+     * @param context The Context can be read or updated. The Context holds all the state necessary for the execution of the middleware.
+     * @returns The result of the middleware's action.
+     */
+    action(context: TContext): TResult;
+    /**
+     * This optional function gets called when the cleanup of the Pipeline is necessary, based on reverse order of Middleware registration.
+     *
+     * @param context Part of the Context should be cleaned, and any allocated resources in the Action, should be disposed.
+     * @returns The result of the middleware's cleanup.
+     */
+    cleanup?(context: TContext): TResult;
+}
+
+/**
+ * An interface representing a middleware container and dispatcher.
+ * It allows registering and executing middleware functions in a pipeline.
+ *
+ * @template TContext - The type of the context object that will be passed to each middleware function.
+ * @template TResult - The type of the result that each middleware function will return.
+ *                     Defaults to {@link MiddlewareResult}.
+ */
+interface IPipeline<TContext extends IPipelineContext, TResult = MiddlewareResult> {
+    /**
+     * Represents the name of the pipeline.
+     * This property is optional and can be used for debugging purposes.
+     */
+    readonly name?: string;
+    /**
+     * Represents the number of middleware functions registered in the pipeline.
+     * This property is optional.
+     */
+    readonly length?: number;
+    /**
+     * Register middleware for this pipeline.
+     *
+     * @param middleware - The middleware function to be added to the pipeline.
+     * @returns This instance of the pipeline, allowing for method chaining.
+     */
+    use(middleware: IMiddleware<TContext, TResult>): this;
+    /**
+     * Execute the Dispatch phase on the chain of middleware, with the given Context.
+     * The Dispatch phase is responsible for invoking the middleware functions in the pipeline.
+     *
+     * @param context - The context object that will be passed to each middleware function.
+     * @returns A {@link PipelineResult} object representing the result of the pipeline execution.
+     */
+    dispatch(context: TContext): PipelineResult;
+    /**
+     * Execute the Cleanup phase on the chain of middleware, with the given Context.
+     * The Cleanup phase is responsible for performing any necessary cleanup operations after the pipeline execution.
+     *
+     * @param context - The context object that will be passed to each middleware function.
+     * @returns A {@link PipelineResult} object representing the result of the cleanup execution.
+     */
+    cleanup(context: TContext): PipelineResult;
+}
+
+export { type IPipelineContext as I, type MiddlewareResult as M, type PipelineResult as P, type IPipeline as a, type IMiddleware as b, type PipelineRuntime as c, PipelineStatus as d };

package/dist/pipelines/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/pipelines/index.ts","../../src/pipelines/pipeline-status.ts"],"sourcesContent":["export * from './middleware';\nexport * from './middleware-result';\nexport * from './middleware-runner';\n\nexport * from './pipeline-context';\nexport * from './pipeline-result';\nexport * from './pipeline-runner';\nexport * from './pipeline-status';\nexport * from './pipeline';\n","/**\n * The PipelineStatus tracks the current status of the pipeline.\n */\nexport enum PipelineStatus {\n  idle = 'idle',\n  ongoing = 'ongoing',\n  completed = 'completed',\n  halted = 'halted',\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACGO,IAAK,iBAAL,kBAAKA,oBAAL;AACL,EAAAA,gBAAA,UAAO;AACP,EAAAA,gBAAA,aAAU;AACV,EAAAA,gBAAA,eAAY;AACZ,EAAAA,gBAAA,YAAS;AAJC,SAAAA;AAAA,GAAA;","names":["PipelineStatus"]}
+{"version":3,"sources":["../../src/pipelines/index.ts","../../src/pipelines/pipeline-status.ts"],"sourcesContent":["export * from './middleware-result';\nexport * from './middleware-runner';\nexport * from './middleware';\nexport * from './pipeline-context';\nexport * from './pipeline-result';\nexport * from './pipeline-runner';\nexport * from './pipeline-status';\nexport * from './pipeline';\n","/**\n * The PipelineStatus enum represents the different states a pipeline can be in.\n *\n * @remarks\n * This enum is used to track the current status of the pipeline.\n */\nexport enum PipelineStatus {\n  /**\n   * The pipeline is currently idle and not processing any tasks.\n   */\n  idle = 'idle',\n\n  /**\n   * The pipeline is currently processing tasks.\n   */\n  ongoing = 'ongoing',\n\n  /**\n   * The pipeline has completed all tasks successfully.\n   */\n  completed = 'completed',\n\n  /**\n   * The pipeline has been halted due to an error or middleware intervention.\n   */\n  halted = 'halted'\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACMO,IAAK,iBAAL,kBAAKA,oBAAL;AAIL,EAAAA,gBAAA,UAAO;AAKP,EAAAA,gBAAA,aAAU;AAKV,EAAAA,gBAAA,eAAY;AAKZ,EAAAA,gBAAA,YAAS;AAnBC,SAAAA;AAAA,GAAA;","names":["PipelineStatus"]}

package/dist/pipelines/index.d.cts

@@ -1,22 +1,28 @@
-import { I as IPipelineContext, b as IMiddleware, M as MiddlewareResult, P as PipelineResult } from '../pipeline-BowCAITe.cjs';
-export { a as IPipeline, c as PipelineRuntime, d as PipelineStatus } from '../pipeline-BowCAITe.cjs';
-import '../performance-timer-XvdCbcAE.cjs';
+import { I as IPipelineContext, b as IMiddleware, M as MiddlewareResult, P as PipelineResult } from '../pipeline-DunwPUPZ.cjs';
+export { a as IPipeline, c as PipelineRuntime, d as PipelineStatus } from '../pipeline-DunwPUPZ.cjs';
+import '../performance-timer-BVyl0SRs.cjs';
 
 /**
- * The `Middleware Runner` allows for custom logic when running an {@link IMiddleware} method.
+ * The `IMiddlewareRunner` interface allows for custom logic when running an {@link IMiddleware} method.
  * It's useful for implementing different `Decorators` to compose extensible runtime logic.
+ *
+ * @template TContext The type of the context that will be passed to the middleware methods.
  */
 interface IMiddlewareRunner<TContext extends IPipelineContext> {
     /**
-     * The {@link dispatch} method will decide how to run the {@link IMiddleware.action} method on the provided {@link IMiddleware} instance.
+     * The `dispatch` method decides how to run the {@link IMiddleware.action} method on the provided {@link IMiddleware} instance.
+     *
      * @param context The {@link IPipelineContext} passed to the Middleware's {@link IMiddleware.action} method.
      * @param middleware The {@link IMiddleware} to call the {@link IMiddleware.action} method on.
+     * @returns A {@link MiddlewareResult} indicating the outcome of the middleware's action.
      */
     dispatch(context: TContext, middleware: IMiddleware<TContext>): MiddlewareResult;
     /**
-     * The {@link cleanup} method will decide how to run the {@link IMiddleware.cleanup} method on the provided {@link IMiddleware} instance.
+     * The `cleanup` method decides how to run the {@link IMiddleware.cleanup} method on the provided {@link IMiddleware} instance.
+     *
      * @param context The {@link IPipelineContext} passed to the Middleware's {@link IMiddleware.cleanup} method.
      * @param middleware The {@link IMiddleware} to call the {@link IMiddleware.cleanup} method on.
+     * @returns A {@link MiddlewareResult} indicating the outcome of the middleware's cleanup.
      */
     cleanup(context: TContext, middleware: IMiddleware<TContext>): MiddlewareResult;
 }
@@ -28,15 +34,21 @@ interface IMiddlewareRunner<TContext extends IPipelineContext> {
 interface IPipelineRunner<TContext extends IPipelineContext> {
     /**
      * The {@link dispatch} method will decide how to run the {@link IMiddleware.action} method on the provided {@link IMiddleware} instances, starting with the provided {@link startIndex} (optional).
-     * @param context The {@link IPipelineContext} passed to the Middleware's {@link IMiddleware.action} method.
-     * @param middleware The {@link IMiddleware} Array to call the {@link IMiddleware.action} methods on.
-     * @param startIndex (optional) the Start Index to run in the Middleware Array.
+     *
+     * @param context - The {@link IPipelineContext} passed to the Middleware's {@link IMiddleware.action} method.
+     * @param middleware - The {@link IMiddleware} Array to call the {@link IMiddleware.action} methods on.
+     * @param startIndex - (optional) the Start Index to run in the Middleware Array.
+     *
+     * @returns A {@link PipelineResult} indicating the success or failure of the operation.
      */
     dispatch(context: TContext, middleware: IMiddleware<TContext>[], startIndex?: number): PipelineResult;
     /**
      * The {@link cleanup} method will decide how to run the {@link IMiddleware.cleanup} method on the provided {@link IMiddleware} instances.
-     * @param context The {@link IPipelineContext} passed to the Middleware's {@link IMiddleware.cleanup} method.
-     * @param middleware The {@link IMiddleware} Array to call the {@link IMiddleware.cleanup} methods on.
+     *
+     * @param context - The {@link IPipelineContext} passed to the Middleware's {@link IMiddleware.cleanup} method.
+     * @param middleware - The {@link IMiddleware} Array to call the {@link IMiddleware.cleanup} methods on.
+     *
+     * @returns A {@link PipelineResult} indicating the success or failure of the operation.
      */
     cleanup(context: TContext, middleware: IMiddleware<TContext>[]): PipelineResult;
 }

package/dist/pipelines/index.d.ts

@@ -1,22 +1,28 @@
-import { I as IPipelineContext, b as IMiddleware, M as MiddlewareResult, P as PipelineResult } from '../pipeline-D43CXxWG.js';
-export { a as IPipeline, c as PipelineRuntime, d as PipelineStatus } from '../pipeline-D43CXxWG.js';
-import '../performance-timer-XvdCbcAE.js';
+import { I as IPipelineContext, b as IMiddleware, M as MiddlewareResult, P as PipelineResult } from '../pipeline-BGsQiSer.js';
+export { a as IPipeline, c as PipelineRuntime, d as PipelineStatus } from '../pipeline-BGsQiSer.js';
+import '../performance-timer-BVyl0SRs.js';
 
 /**
- * The `Middleware Runner` allows for custom logic when running an {@link IMiddleware} method.
+ * The `IMiddlewareRunner` interface allows for custom logic when running an {@link IMiddleware} method.
  * It's useful for implementing different `Decorators` to compose extensible runtime logic.
+ *
+ * @template TContext The type of the context that will be passed to the middleware methods.
  */
 interface IMiddlewareRunner<TContext extends IPipelineContext> {
     /**
-     * The {@link dispatch} method will decide how to run the {@link IMiddleware.action} method on the provided {@link IMiddleware} instance.
+     * The `dispatch` method decides how to run the {@link IMiddleware.action} method on the provided {@link IMiddleware} instance.
+     *
      * @param context The {@link IPipelineContext} passed to the Middleware's {@link IMiddleware.action} method.
      * @param middleware The {@link IMiddleware} to call the {@link IMiddleware.action} method on.
+     * @returns A {@link MiddlewareResult} indicating the outcome of the middleware's action.
      */
     dispatch(context: TContext, middleware: IMiddleware<TContext>): MiddlewareResult;
     /**
-     * The {@link cleanup} method will decide how to run the {@link IMiddleware.cleanup} method on the provided {@link IMiddleware} instance.
+     * The `cleanup` method decides how to run the {@link IMiddleware.cleanup} method on the provided {@link IMiddleware} instance.
+     *
      * @param context The {@link IPipelineContext} passed to the Middleware's {@link IMiddleware.cleanup} method.
      * @param middleware The {@link IMiddleware} to call the {@link IMiddleware.cleanup} method on.
+     * @returns A {@link MiddlewareResult} indicating the outcome of the middleware's cleanup.
      */
     cleanup(context: TContext, middleware: IMiddleware<TContext>): MiddlewareResult;
 }
@@ -28,15 +34,21 @@ interface IMiddlewareRunner<TContext extends IPipelineContext> {
 interface IPipelineRunner<TContext extends IPipelineContext> {
     /**
      * The {@link dispatch} method will decide how to run the {@link IMiddleware.action} method on the provided {@link IMiddleware} instances, starting with the provided {@link startIndex} (optional).
-     * @param context The {@link IPipelineContext} passed to the Middleware's {@link IMiddleware.action} method.
-     * @param middleware The {@link IMiddleware} Array to call the {@link IMiddleware.action} methods on.
-     * @param startIndex (optional) the Start Index to run in the Middleware Array.
+     *
+     * @param context - The {@link IPipelineContext} passed to the Middleware's {@link IMiddleware.action} method.
+     * @param middleware - The {@link IMiddleware} Array to call the {@link IMiddleware.action} methods on.
+     * @param startIndex - (optional) the Start Index to run in the Middleware Array.
+     *
+     * @returns A {@link PipelineResult} indicating the success or failure of the operation.
      */
     dispatch(context: TContext, middleware: IMiddleware<TContext>[], startIndex?: number): PipelineResult;
     /**
      * The {@link cleanup} method will decide how to run the {@link IMiddleware.cleanup} method on the provided {@link IMiddleware} instances.
-     * @param context The {@link IPipelineContext} passed to the Middleware's {@link IMiddleware.cleanup} method.
-     * @param middleware The {@link IMiddleware} Array to call the {@link IMiddleware.cleanup} methods on.
+     *
+     * @param context - The {@link IPipelineContext} passed to the Middleware's {@link IMiddleware.cleanup} method.
+     * @param middleware - The {@link IMiddleware} Array to call the {@link IMiddleware.cleanup} methods on.
+     *
+     * @returns A {@link PipelineResult} indicating the success or failure of the operation.
      */
     cleanup(context: TContext, middleware: IMiddleware<TContext>[]): PipelineResult;
 }

package/dist/pipelines/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/pipelines/pipeline-status.ts"],"sourcesContent":["/**\n * The PipelineStatus tracks the current status of the pipeline.\n */\nexport enum PipelineStatus {\n  idle = 'idle',\n  ongoing = 'ongoing',\n  completed = 'completed',\n  halted = 'halted',\n}\n"],"mappings":";AAGO,IAAK,iBAAL,kBAAKA,oBAAL;AACL,EAAAA,gBAAA,UAAO;AACP,EAAAA,gBAAA,aAAU;AACV,EAAAA,gBAAA,eAAY;AACZ,EAAAA,gBAAA,YAAS;AAJC,SAAAA;AAAA,GAAA;","names":["PipelineStatus"]}
+{"version":3,"sources":["../../src/pipelines/pipeline-status.ts"],"sourcesContent":["/**\n * The PipelineStatus enum represents the different states a pipeline can be in.\n *\n * @remarks\n * This enum is used to track the current status of the pipeline.\n */\nexport enum PipelineStatus {\n  /**\n   * The pipeline is currently idle and not processing any tasks.\n   */\n  idle = 'idle',\n\n  /**\n   * The pipeline is currently processing tasks.\n   */\n  ongoing = 'ongoing',\n\n  /**\n   * The pipeline has completed all tasks successfully.\n   */\n  completed = 'completed',\n\n  /**\n   * The pipeline has been halted due to an error or middleware intervention.\n   */\n  halted = 'halted'\n}\n"],"mappings":";AAMO,IAAK,iBAAL,kBAAKA,oBAAL;AAIL,EAAAA,gBAAA,UAAO;AAKP,EAAAA,gBAAA,aAAU;AAKV,EAAAA,gBAAA,eAAY;AAKZ,EAAAA,gBAAA,YAAS;AAnBC,SAAAA;AAAA,GAAA;","names":["PipelineStatus"]}

package/dist/systems/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/systems/index.ts","../../src/systems/module/system-type.ts"],"sourcesContent":["export * from './pipeline/system-context-entity';\nexport * from './pipeline/system-context-events';\nexport * from './pipeline/system-context-proxies';\nexport * from './pipeline/system-context-repository';\nexport * from './pipeline/system-context-scheduler';\nexport * from './pipeline/system-context-snapshot';\nexport * from './runtime/systems-runtime-context';\nexport * from './runtime/systems-runtime-middleware';\nexport * from './pipeline/system-middleware';\nexport * from './pipeline/system-context';\nexport * from './module/system-type';\nexport * from './module/systems-module';\nexport * from './module/systems-module-repository';\nexport * from './runtime/systems-runtime';\n","/**\n * The built-in ECS pipeline types. They can be extended to introduce more types, and the System Runtime Pipeline should\n * add Middleware to handle the newly added types.\n */\nexport enum SystemType {\n  initialize = 'initialize',\n  update = 'update',\n  render = 'render',\n  sync = 'sync',\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACIO,IAAK,aAAL,kBAAKA,gBAAL;AACL,EAAAA,YAAA,gBAAa;AACb,EAAAA,YAAA,YAAS;AACT,EAAAA,YAAA,YAAS;AACT,EAAAA,YAAA,UAAO;AAJG,SAAAA;AAAA,GAAA;","names":["SystemType"]}
+{"version":3,"sources":["../../src/systems/index.ts","../../src/systems/module/system-type.ts"],"sourcesContent":["export * from './pipeline/system-context-entity';\nexport * from './pipeline/system-context-events';\nexport * from './pipeline/system-context-proxies';\nexport * from './pipeline/system-context-repository';\nexport * from './pipeline/system-context-scheduler';\nexport * from './pipeline/system-context-snapshot';\nexport * from './runtime/systems-runtime-context';\nexport * from './runtime/systems-runtime-middleware';\nexport * from './pipeline/system-middleware';\nexport * from './pipeline/system-context';\nexport * from './module/system-type';\nexport * from './module/systems-module';\nexport * from './module/systems-module-repository';\nexport * from './runtime/systems-runtime';\n","/**\n * Enum representing the built-in System pipeline types.\n * These types can be extended to introduce more types, and the System Runtime Pipeline should\n * add Middleware to handle the newly added types.\n */\nexport enum SystemType {\n  /**\n   * The initialization phase of the Module pipeline.\n   * This phase is typically used for setting up initial state and resources.\n   */\n  initialize = 'initialize',\n\n  /**\n   * The update phase of the Module pipeline.\n   * This phase is responsible for updating the game logic and state of entities.\n   */\n  update = 'update',\n\n  /**\n   * The render phase of the Module pipeline.\n   * This phase is used for rendering the game to the screen.\n   */\n  render = 'render',\n\n  /**\n   * The synchronization phase of the Module pipeline.\n   * This phase is used for synchronizing game state with external systems or other components.\n   */\n  sync = 'sync'\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACKO,IAAK,aAAL,kBAAKA,gBAAL;AAKL,EAAAA,YAAA,gBAAa;AAMb,EAAAA,YAAA,YAAS;AAMT,EAAAA,YAAA,YAAS;AAMT,EAAAA,YAAA,UAAO;AAvBG,SAAAA;AAAA,GAAA;","names":["SystemType"]}

package/dist/systems/index.d.cts

@@ -1,21 +1,27 @@
-import { I as ISystemsRuntimeContext, a as ISystemContext, S as SystemType } from '../systems-runtime-context-C-PeYs1I.cjs';
-export { b as ISystemContextEntity, c as ISystemContextEvents, d as ISystemContextProxies, e as ISystemContextRepository, f as ISystemContextScheduler, g as ISystemContextSnapshot } from '../systems-runtime-context-C-PeYs1I.cjs';
-import { c as IEntity, E as EntityTypeUid } from '../index-DK2CXVZ8.cjs';
-import { b as IMiddleware, P as PipelineResult } from '../pipeline-BowCAITe.cjs';
-import { f as IEntityUpdate } from '../entity-repository-DmfcUSrX.cjs';
-import { I as Immutable } from '../types-BNwBqRWY.cjs';
+import { I as ISystemsRuntimeContext, a as ISystemContext, S as SystemType } from '../systems-runtime-context-DhtHMczN.cjs';
+export { b as ISystemContextEntity, c as ISystemContextEvents, d as ISystemContextProxies, e as ISystemContextRepository, f as ISystemContextScheduler, g as ISystemContextSnapshot } from '../systems-runtime-context-DhtHMczN.cjs';
+import { c as IEntity, E as EntityTypeUid } from '../index-CnlpX7ys.cjs';
+import { b as IMiddleware, P as PipelineResult } from '../pipeline-DunwPUPZ.cjs';
+import { f as IEntityUpdate } from '../entity-repository-DJ1xbvaN.cjs';
+import { I as Immutable } from '../types-cZ-1lGPD.cjs';
 import '../utils/index.cjs';
-import '../performance-timer-XvdCbcAE.cjs';
+import '../performance-timer-BVyl0SRs.cjs';
 
 /**
- * The ISystemsRuntimeMiddleware represents the building blocks of executing SystemsModule's registered Pipelines.
+ * The `ISystemsRuntimeMiddleware` represents the building blocks of executing SystemsModule's registered Pipelines.
  * It receives the current State in the Context, and can decide which SystemPipelines to execute.
+ *
+ * @typeParam TEntity - The type of entity that the middleware operates on.
+ * @extends {IMiddleware<ISystemsRuntimeContext<TEntity>>} - Extends the base `IMiddleware` interface, which is used for defining middleware functions.
  */
 type ISystemsRuntimeMiddleware<TEntity extends IEntity> = IMiddleware<ISystemsRuntimeContext<TEntity>>;
 
 /**
- * The SystemMiddleware is the basic System implementation that can be registered as a Middleware in a SystemPipeline.
- * It provides a SystemPipelineContext to it's exposed methods.
+ * The `ISystemMiddleware` is a basic System implementation that can be registered as a Middleware in a SystemPipeline.
+ * It provides a `SystemPipelineContext` to its exposed methods.
+ *
+ * @template TEntity - The type of entity that this middleware operates on.
+ * @extends {IMiddleware<ISystemContext<TEntity>>} - Extends the base `IMiddleware` interface, which requires a `SystemPipelineContext` to be provided.
  */
 type ISystemMiddleware<TEntity extends IEntity> = IMiddleware<ISystemContext<TEntity>>;
 
@@ -25,36 +31,69 @@ type ISystemMiddleware<TEntity extends IEntity> = IMiddleware<ISystemContext<TEn
  */
 interface ISystemsModule<TEntity extends IEntity> {
     /**
-     * @param type The SystemPipelineType to append the provided SystemMiddlewares to.
-     * @param systems The SystemMiddlewares will be registered in the provided SystemPipelineType in the same order as the provided array.
+     * Registers SystemMiddlewares to the specified SystemPipelineType.
+     *
+     * @param type - The SystemPipelineType to append the provided SystemMiddlewares to.
+     * @param systems - The SystemMiddlewares to be registered in the provided SystemPipelineType in the same order as the provided array.
      * The SystemMiddlewares will be appended to existing Pipelines to allow easy extension of existing behaviors.
      */
-    registerSystems(type: SystemType, systems: ISystemMiddleware<TEntity>[]): void;
+    registerSystems?(type: SystemType, systems: ISystemMiddleware<TEntity>[]): void;
     /**
-     * Trigger all registered SystemPipelines, to apply the changes from the provided EntityUpdate to an Entity instance.
-     * @param update The EntityUpdate containing the desired changes to be applied on an Entity instance.
+     * Triggers all registered SystemPipelines to apply the changes from the provided EntityUpdate to an Entity instance.
+     *
+     * @param update - The EntityUpdate containing the desired changes to be applied on an Entity instance.
+     * @returns A PipelineResult indicating the success or failure of the triggered SystemPipelines.
      */
     triggerSystems(update: IEntityUpdate): PipelineResult;
 }
 
+/**
+ * Interface for managing systems modules.
+ *
+ * @template TEntity - The type of entity that the systems module operates on.
+ */
 interface ISystemsModuleRepository {
+    /**
+     * The number of systems modules in the repository.
+     */
     readonly size: number;
+    /**
+     * Retrieves a systems module for a specific entity type.
+     *
+     * @param type - The unique identifier of the entity type.
+     * @returns The systems module for the specified entity type.
+     */
     get<TEntity extends IEntity>(type: EntityTypeUid): ISystemsModule<TEntity>;
+    /**
+     * Adds or updates a systems module for a specific entity type.
+     *
+     * @param type - The unique identifier of the entity type.
+     * @param module - The systems module to add or update.
+     */
     set(type: EntityTypeUid, module: ISystemsModule<IEntity>): void;
+    /**
+     * Retrieves a read-only map of all systems modules in the repository.
+     *
+     * @returns A read-only map of entity type unique identifiers to systems modules.
+     */
     list(): ReadonlyMap<EntityTypeUid, Immutable<ISystemsModule<IEntity>>>;
 }
 
 /**
  * The System Runtime allows running a loop of Ticks.
  *
- * Each RunTick can process one or more Entity Updates, from the EntityQueue.
- * We can have multiple implementations of a SystemRuntime, based on the use-case.
+ * Each `runTick` method can process one or more Entity Updates.
+ *
+ * We can have multiple implementations of a `SystemsRuntime`, based on the use-case.
  * A different implementation can be chosen at runtime, based for example on performance.
  */
 interface ISystemsRuntime {
     /**
-     * The method should trigger the SystemsModule logic for the provided IEntityUpdate.
-     * If no EntityUpdate is given, the SystemRuntime implementation can choose to dequeue one from the IEntityUpdateQueue.
+     * The method should trigger the SystemsModule logic for the provided `IEntityUpdate`.
+     * If no EntityUpdate is given, the `SystemRuntime` implementation can choose to dequeue one from the `IEntityUpdateQueue`.
+     *
+     * @param update - An optional `IEntityUpdate` to process. If not provided, the method will dequeue one from the `IEntityUpdateQueue`.
+     * @returns A `PipelineResult` representing the outcome of the SystemsModule logic execution.
      */
     runTick(update?: IEntityUpdate): PipelineResult;
 }