@adaas/a-utils 0.2.7 → 0.2.9

package/dist/node/lib/A-StateMachine/A-StateMachine.component.d.ts

@@ -0,0 +1,180 @@
+import { A_Component } from '@adaas/a-concept';
+import { A_StateMachineFeatures } from './A-StateMachine.constants.js';
+
+/**
+ * A_StateMachine is a powerful state machine implementation that allows you to define and manage
+ * complex state transitions with validation, hooks, and error handling.
+ *
+ * @template T - A record type defining the state transitions and their associated data types.
+ *               Each key represents a state name, and the value represents the data type for that state.
+ *
+ * @example
+ * ```typescript
+ * interface OrderStates {
+ *   pending: { orderId: string };
+ *   processing: { orderId: string; processedBy: string };
+ *   completed: { orderId: string; completedAt: Date };
+ *   cancelled: { orderId: string; reason: string };
+ * }
+ *
+ * class OrderStateMachine extends A_StateMachine<OrderStates> {
+ *   // Define custom transition logic
+ *   async pending_processing(scope: A_Scope) {
+ *     const operation = scope.resolve(A_StateMachineTransition)!;
+ *     const { orderId } = operation.props;
+ *     // Custom validation and business logic
+ *   }
+ * }
+ * ```
+ */
+declare class A_StateMachine<T extends Record<string, any> = Record<string, any>> extends A_Component {
+    /**
+     * Internal promise that tracks the initialization state of the state machine.
+     * Used to ensure the state machine is properly initialized before allowing transitions.
+     */
+    protected _initialized?: Promise<void>;
+    /**
+     * Gets a promise that resolves when the state machine is fully initialized and ready for transitions.
+     * This ensures that all initialization hooks have been executed before allowing state transitions.
+     *
+     * @returns Promise<void> that resolves when initialization is complete
+     *
+     * @example
+     * ```typescript
+     * const stateMachine = new MyStateMachine();
+     * await stateMachine.ready; // Wait for initialization
+     * await stateMachine.transition('idle', 'running');
+     * ```
+     */
+    get ready(): Promise<void>;
+    /**
+     * Initialization hook that runs when the state machine is first created.
+     * This method can be extended to add custom initialization logic.
+     *
+     * @param args - Variable arguments passed during initialization
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * class MyStateMachine extends A_StateMachine {
+     *   @A_Feature.Extend()
+     *   async [A_StateMachineFeatures.onInitialize]() {
+     *     // Custom initialization logic
+     *     console.log('State machine initialized');
+     *   }
+     * }
+     * ```
+     */
+    [A_StateMachineFeatures.onInitialize](...args: any[]): Promise<void>;
+    /**
+     * Hook that runs before any state transition occurs.
+     * Use this to add validation, logging, or preparation logic that should run for all transitions.
+     *
+     * @param args - Variable arguments, typically includes the transition scope
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * class MyStateMachine extends A_StateMachine {
+     *   @A_Feature.Extend()
+     *   async [A_StateMachineFeatures.onBeforeTransition](scope: A_Scope) {
+     *     const operation = scope.resolve(A_StateMachineTransition)!;
+     *     console.log(`Transitioning from ${operation.props.from} to ${operation.props.to}`);
+     *   }
+     * }
+     * ```
+     */
+    [A_StateMachineFeatures.onBeforeTransition](...args: any[]): Promise<void>;
+    /**
+     * Hook that runs after a successful state transition.
+     * Use this to add cleanup, logging, or post-transition logic that should run for all transitions.
+     *
+     * @param args - Variable arguments, typically includes the transition scope
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * class MyStateMachine extends A_StateMachine {
+     *   @A_Feature.Extend()
+     *   async [A_StateMachineFeatures.onAfterTransition](scope: A_Scope) {
+     *     const operation = scope.resolve(A_StateMachineTransition)!;
+     *     console.log(`Successfully transitioned to ${operation.props.to}`);
+     *   }
+     * }
+     * ```
+     */
+    [A_StateMachineFeatures.onAfterTransition](...args: any[]): Promise<void>;
+    /**
+     * Error handling hook that runs when a transition fails.
+     * Use this to add custom error handling, logging, or recovery logic.
+     *
+     * @param args - Variable arguments, typically includes the error scope
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * class MyStateMachine extends A_StateMachine {
+     *   @A_Feature.Extend()
+     *   async [A_StateMachineFeatures.onError](scope: A_Scope) {
+     *     const error = scope.resolve(A_StateMachineError);
+     *     console.error('Transition failed:', error?.message);
+     *   }
+     * }
+     * ```
+     */
+    [A_StateMachineFeatures.onError](...args: any[]): Promise<void>;
+    /**
+     * Executes a state transition from one state to another.
+     * This is the core method of the state machine that handles the complete transition lifecycle.
+     *
+     * @param from - The state to transition from (must be a key of T)
+     * @param to - The state to transition to (must be a key of T)
+     * @param props - Optional properties to pass to the transition context (should match T[keyof T])
+     * @returns Promise<void> that resolves when the transition is complete
+     *
+     * @throws {A_StateMachineError} When the transition fails for any reason
+     *
+     * @example
+     * ```typescript
+     * interface OrderStates {
+     *   pending: { orderId: string };
+     *   processing: { orderId: string; processedBy: string };
+     * }
+     *
+     * const orderMachine = new A_StateMachine<OrderStates>();
+     *
+     * // Transition with props
+     * await orderMachine.transition('pending', 'processing', {
+     *   orderId: '12345',
+     *   processedBy: 'user-456'
+     * });
+     * ```
+     *
+     * The transition process follows this lifecycle:
+     * 1. Wait for state machine initialization (ready)
+     * 2. Create transition name in camelCase format (e.g., "pending_processing")
+     * 3. Create operation context with transition data
+     * 4. Create isolated scope for the transition
+     * 5. Call onBeforeTransition hook
+     * 6. Execute the specific transition method (if defined)
+     * 7. Call onAfterTransition hook
+     * 8. Clean up scope and return result
+     *
+     * If any step fails, the onError hook is called and a wrapped error is thrown.
+     */
+    transition(
+    /**
+     * The state to transition from
+     */
+    from: keyof T, 
+    /**
+     * The state to transition to
+     */
+    to: keyof T, 
+    /**
+     * Optional properties to pass to the transition context
+     */
+    props?: T[keyof T]): Promise<void>;
+}
+
+export { A_StateMachine };

package/dist/node/lib/A-StateMachine/A-StateMachine.component.js

@@ -0,0 +1,119 @@
+'use strict';
+
+var aConcept = require('@adaas/a-concept');
+var AStateMachine_error = require('./A-StateMachine.error');
+var AStateMachine_constants = require('./A-StateMachine.constants');
+var AStateMachineTransition_context = require('./A-StateMachineTransition.context');
+var aFrame = require('@adaas/a-frame');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var _a, _b, _c, _d;
+exports.A_StateMachine = class A_StateMachine extends aConcept.A_Component {
+  /**
+   * Gets a promise that resolves when the state machine is fully initialized and ready for transitions.
+   * This ensures that all initialization hooks have been executed before allowing state transitions.
+   * 
+   * @returns Promise<void> that resolves when initialization is complete
+   * 
+   * @example
+   * ```typescript
+   * const stateMachine = new MyStateMachine();
+   * await stateMachine.ready; // Wait for initialization
+   * await stateMachine.transition('idle', 'running');
+   * ```
+   */
+  get ready() {
+    if (!this._initialized) {
+      this._initialized = new Promise(
+        async (resolve, reject) => {
+          try {
+            await this.call(AStateMachine_constants.A_StateMachineFeatures.onInitialize);
+            resolve();
+          } catch (error) {
+            const wrappedError = new AStateMachine_error.A_StateMachineError({
+              title: AStateMachine_error.A_StateMachineError.InitializationError,
+              description: `An error occurred during state machine initialization.`,
+              originalError: error
+            });
+            reject(wrappedError);
+          }
+        }
+      );
+    }
+    return this._initialized;
+  }
+  async [_d = AStateMachine_constants.A_StateMachineFeatures.onInitialize](...args) {
+  }
+  async [_c = AStateMachine_constants.A_StateMachineFeatures.onBeforeTransition](...args) {
+  }
+  async [_b = AStateMachine_constants.A_StateMachineFeatures.onAfterTransition](...args) {
+  }
+  async [_a = AStateMachine_constants.A_StateMachineFeatures.onError](...args) {
+  }
+  async transition(from, to, props) {
+    await this.ready;
+    const transitionName = `${aConcept.A_FormatterHelper.toCamelCase(String(from))}_${aConcept.A_FormatterHelper.toCamelCase(String(to))}`;
+    const transition = new AStateMachineTransition_context.A_StateMachineTransition({
+      from: String(from),
+      to: String(to),
+      props
+    });
+    const scope = new aConcept.A_Scope({
+      name: `A-StateMachine-Transition-Scope-${transitionName}`,
+      fragments: [transition]
+    }).inherit(aConcept.A_Context.scope(this));
+    try {
+      await this.call(AStateMachine_constants.A_StateMachineFeatures.onBeforeTransition, scope);
+      await this.call(transitionName, scope);
+      await this.call(AStateMachine_constants.A_StateMachineFeatures.onAfterTransition, scope);
+      scope.destroy();
+      return transition.result;
+    } catch (error) {
+      const wrappedError = new AStateMachine_error.A_StateMachineError({
+        title: AStateMachine_error.A_StateMachineError.TransitionError,
+        description: `An error occurred while transitioning to "${transitionName}"`,
+        originalError: error
+      });
+      scope.register(wrappedError);
+      await this.call(AStateMachine_constants.A_StateMachineFeatures.onError, scope);
+      scope.destroy();
+      throw wrappedError;
+    }
+  }
+};
+__decorateClass([
+  aConcept.A_Feature.Extend()
+], exports.A_StateMachine.prototype, _d, 1);
+__decorateClass([
+  aConcept.A_Feature.Extend()
+], exports.A_StateMachine.prototype, _c, 1);
+__decorateClass([
+  aConcept.A_Feature.Extend()
+], exports.A_StateMachine.prototype, _b, 1);
+__decorateClass([
+  aConcept.A_Feature.Extend()
+], exports.A_StateMachine.prototype, _a, 1);
+__decorateClass([
+  aFrame.A_Frame.Method({
+    name: "transition",
+    description: "Executes a state transition from one state to another."
+  })
+], exports.A_StateMachine.prototype, "transition", 1);
+exports.A_StateMachine = __decorateClass([
+  aFrame.A_Frame.Namespace("A-Utils"),
+  aFrame.A_Frame.Component({
+    name: "A-StateMachine",
+    description: "A powerful state machine component for managing complex state transitions."
+  })
+], exports.A_StateMachine);
+//# sourceMappingURL=A-StateMachine.component.js.map
+//# sourceMappingURL=A-StateMachine.component.js.map

package/dist/node/lib/A-StateMachine/A-StateMachine.component.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/A-StateMachine/A-StateMachine.component.ts"],"names":["A_StateMachine","A_Component","A_StateMachineFeatures","A_StateMachineError","A_FormatterHelper","A_StateMachineTransition","A_Scope","A_Context","A_Feature","A_Frame"],"mappings":"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","file":"A-StateMachine.component.js","sourcesContent":["import { A_Component, A_Context, A_Feature, A_FormatterHelper, A_Scope } from \"@adaas/a-concept\";\nimport { A_StateMachineError } from \"./A-StateMachine.error\";\nimport { A_StateMachineFeatures } from \"./A-StateMachine.constants\";\nimport { A_StateMachineTransition } from \"./A-StateMachineTransition.context\";\nimport { A_Frame } from \"@adaas/a-frame\";\n\n/**\n * A_StateMachine is a powerful state machine implementation that allows you to define and manage\n * complex state transitions with validation, hooks, and error handling.\n * \n * @template T - A record type defining the state transitions and their associated data types.\n *               Each key represents a state name, and the value represents the data type for that state.\n * \n * @example\n * ```typescript\n * interface OrderStates {\n *   pending: { orderId: string };\n *   processing: { orderId: string; processedBy: string };\n *   completed: { orderId: string; completedAt: Date };\n *   cancelled: { orderId: string; reason: string };\n * }\n * \n * class OrderStateMachine extends A_StateMachine<OrderStates> {\n *   // Define custom transition logic\n *   async pending_processing(scope: A_Scope) {\n *     const operation = scope.resolve(A_StateMachineTransition)!;\n *     const { orderId } = operation.props;\n *     // Custom validation and business logic\n *   }\n * }\n * ```\n */\n\n@A_Frame.Namespace('A-Utils')\n@A_Frame.Component({\n    name: 'A-StateMachine',\n    description: 'A powerful state machine component for managing complex state transitions.'\n})\nexport class A_StateMachine<\n    T extends Record<string, any> = Record<string, any>\n> extends A_Component {\n\n    /**\n     * Internal promise that tracks the initialization state of the state machine.\n     * Used to ensure the state machine is properly initialized before allowing transitions.\n     */\n    protected _initialized?: Promise<void>;\n\n    /**\n     * Gets a promise that resolves when the state machine is fully initialized and ready for transitions.\n     * This ensures that all initialization hooks have been executed before allowing state transitions.\n     * \n     * @returns Promise<void> that resolves when initialization is complete\n     * \n     * @example\n     * ```typescript\n     * const stateMachine = new MyStateMachine();\n     * await stateMachine.ready; // Wait for initialization\n     * await stateMachine.transition('idle', 'running');\n     * ```\n     */\n    get ready(): Promise<void> {\n        if (!this._initialized) {\n            this._initialized = new Promise<void>(\n                async (resolve, reject) => {\n                    try {\n                        await this.call(A_StateMachineFeatures.onInitialize);\n\n                        resolve();\n                    } catch (error) {\n                        const wrappedError = new A_StateMachineError({\n                            title: A_StateMachineError.InitializationError,\n                            description: `An error occurred during state machine initialization.`,\n                            originalError: error\n                        });\n\n                        reject(wrappedError);\n                    }\n                }\n            );\n        }\n\n        return this._initialized;\n    }\n\n\n\n    /**\n     * Initialization hook that runs when the state machine is first created.\n     * This method can be extended to add custom initialization logic.\n     * \n     * @param args - Variable arguments passed during initialization\n     * @returns Promise<void>\n     * \n     * @example\n     * ```typescript\n     * class MyStateMachine extends A_StateMachine {\n     *   @A_Feature.Extend()\n     *   async [A_StateMachineFeatures.onInitialize]() {\n     *     // Custom initialization logic\n     *     console.log('State machine initialized');\n     *   }\n     * }\n     * ```\n     */\n    @A_Feature.Extend()\n    async [A_StateMachineFeatures.onInitialize](...args: any[]): Promise<void> {\n        // Initialization logic can be added here\n    }\n\n    /**\n     * Hook that runs before any state transition occurs.\n     * Use this to add validation, logging, or preparation logic that should run for all transitions.\n     * \n     * @param args - Variable arguments, typically includes the transition scope\n     * @returns Promise<void>\n     * \n     * @example\n     * ```typescript\n     * class MyStateMachine extends A_StateMachine {\n     *   @A_Feature.Extend()\n     *   async [A_StateMachineFeatures.onBeforeTransition](scope: A_Scope) {\n     *     const operation = scope.resolve(A_StateMachineTransition)!;\n     *     console.log(`Transitioning from ${operation.props.from} to ${operation.props.to}`);\n     *   }\n     * }\n     * ```\n     */\n    @A_Feature.Extend()\n    async [A_StateMachineFeatures.onBeforeTransition](...args: any[]): Promise<void> {\n\n    }\n\n    /**\n     * Hook that runs after a successful state transition.\n     * Use this to add cleanup, logging, or post-transition logic that should run for all transitions.\n     * \n     * @param args - Variable arguments, typically includes the transition scope\n     * @returns Promise<void>\n     * \n     * @example\n     * ```typescript\n     * class MyStateMachine extends A_StateMachine {\n     *   @A_Feature.Extend()\n     *   async [A_StateMachineFeatures.onAfterTransition](scope: A_Scope) {\n     *     const operation = scope.resolve(A_StateMachineTransition)!;\n     *     console.log(`Successfully transitioned to ${operation.props.to}`);\n     *   }\n     * }\n     * ```\n     */\n    @A_Feature.Extend()\n    async [A_StateMachineFeatures.onAfterTransition](...args: any[]): Promise<void> {\n\n    }\n\n    /**\n     * Error handling hook that runs when a transition fails.\n     * Use this to add custom error handling, logging, or recovery logic.\n     * \n     * @param args - Variable arguments, typically includes the error scope\n     * @returns Promise<void>\n     * \n     * @example\n     * ```typescript\n     * class MyStateMachine extends A_StateMachine {\n     *   @A_Feature.Extend()\n     *   async [A_StateMachineFeatures.onError](scope: A_Scope) {\n     *     const error = scope.resolve(A_StateMachineError);\n     *     console.error('Transition failed:', error?.message);\n     *   }\n     * }\n     * ```\n     */\n    @A_Feature.Extend()\n    async [A_StateMachineFeatures.onError](...args: any[]): Promise<void> {\n        // Default error handling logic can be added here\n    }\n\n\n\n    /**\n     * Executes a state transition from one state to another.\n     * This is the core method of the state machine that handles the complete transition lifecycle.\n     * \n     * @param from - The state to transition from (must be a key of T)\n     * @param to - The state to transition to (must be a key of T)\n     * @param props - Optional properties to pass to the transition context (should match T[keyof T])\n     * @returns Promise<void> that resolves when the transition is complete\n     * \n     * @throws {A_StateMachineError} When the transition fails for any reason\n     * \n     * @example\n     * ```typescript\n     * interface OrderStates {\n     *   pending: { orderId: string };\n     *   processing: { orderId: string; processedBy: string };\n     * }\n     * \n     * const orderMachine = new A_StateMachine<OrderStates>();\n     * \n     * // Transition with props\n     * await orderMachine.transition('pending', 'processing', {\n     *   orderId: '12345',\n     *   processedBy: 'user-456'\n     * });\n     * ```\n     * \n     * The transition process follows this lifecycle:\n     * 1. Wait for state machine initialization (ready)\n     * 2. Create transition name in camelCase format (e.g., \"pending_processing\")\n     * 3. Create operation context with transition data\n     * 4. Create isolated scope for the transition\n     * 5. Call onBeforeTransition hook\n     * 6. Execute the specific transition method (if defined)\n     * 7. Call onAfterTransition hook\n     * 8. Clean up scope and return result\n     * \n     * If any step fails, the onError hook is called and a wrapped error is thrown.\n     */\n    @A_Frame.Method({\n        name: 'transition',\n        description: 'Executes a state transition from one state to another.'\n    })\n    async transition(\n        /**\n         * The state to transition from\n         */\n        from: keyof T,\n        /**\n         * The state to transition to\n         */\n        to: keyof T,\n        /**\n         * Optional properties to pass to the transition context\n         */\n        props?: T[keyof T]\n    ): Promise<void> {\n\n        await this.ready;\n\n        const transitionName = `${A_FormatterHelper.toCamelCase(String(from))}_${A_FormatterHelper.toCamelCase(String(to))}`;\n\n        const transition = new A_StateMachineTransition({\n            from: String(from),\n            to: String(to),\n            props\n        });\n\n        const scope = new A_Scope({\n            name: `A-StateMachine-Transition-Scope-${transitionName}`,\n            fragments: [transition]\n        })\n            .inherit(A_Context.scope(this));\n\n        try {\n\n            await this.call(A_StateMachineFeatures.onBeforeTransition, scope);\n\n            await this.call(transitionName, scope);\n\n            await this.call(A_StateMachineFeatures.onAfterTransition, scope);\n\n            scope.destroy();\n\n            return transition.result;\n\n        } catch (error) {\n            const wrappedError = new A_StateMachineError({\n                title: A_StateMachineError.TransitionError,\n                description: `An error occurred while transitioning to \"${transitionName}\"`,\n                originalError: error\n            });\n\n            scope.register(wrappedError);\n\n            await this.call(A_StateMachineFeatures.onError, scope);\n\n            scope.destroy();\n\n            throw wrappedError;\n        }\n    }\n}\n\n\n"]}

package/dist/node/lib/A-StateMachine/A-StateMachine.component.mjs

@@ -0,0 +1,110 @@
+import { __decorateClass } from '../../chunk-EQQGB2QZ.mjs';
+import { A_Component, A_FormatterHelper, A_Scope, A_Context, A_Feature } from '@adaas/a-concept';
+import { A_StateMachineError } from './A-StateMachine.error';
+import { A_StateMachineFeatures } from './A-StateMachine.constants';
+import { A_StateMachineTransition } from './A-StateMachineTransition.context';
+import { A_Frame } from '@adaas/a-frame';
+
+var _a, _b, _c, _d;
+let A_StateMachine = class extends A_Component {
+  /**
+   * Gets a promise that resolves when the state machine is fully initialized and ready for transitions.
+   * This ensures that all initialization hooks have been executed before allowing state transitions.
+   * 
+   * @returns Promise<void> that resolves when initialization is complete
+   * 
+   * @example
+   * ```typescript
+   * const stateMachine = new MyStateMachine();
+   * await stateMachine.ready; // Wait for initialization
+   * await stateMachine.transition('idle', 'running');
+   * ```
+   */
+  get ready() {
+    if (!this._initialized) {
+      this._initialized = new Promise(
+        async (resolve, reject) => {
+          try {
+            await this.call(A_StateMachineFeatures.onInitialize);
+            resolve();
+          } catch (error) {
+            const wrappedError = new A_StateMachineError({
+              title: A_StateMachineError.InitializationError,
+              description: `An error occurred during state machine initialization.`,
+              originalError: error
+            });
+            reject(wrappedError);
+          }
+        }
+      );
+    }
+    return this._initialized;
+  }
+  async [_d = A_StateMachineFeatures.onInitialize](...args) {
+  }
+  async [_c = A_StateMachineFeatures.onBeforeTransition](...args) {
+  }
+  async [_b = A_StateMachineFeatures.onAfterTransition](...args) {
+  }
+  async [_a = A_StateMachineFeatures.onError](...args) {
+  }
+  async transition(from, to, props) {
+    await this.ready;
+    const transitionName = `${A_FormatterHelper.toCamelCase(String(from))}_${A_FormatterHelper.toCamelCase(String(to))}`;
+    const transition = new A_StateMachineTransition({
+      from: String(from),
+      to: String(to),
+      props
+    });
+    const scope = new A_Scope({
+      name: `A-StateMachine-Transition-Scope-${transitionName}`,
+      fragments: [transition]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_StateMachineFeatures.onBeforeTransition, scope);
+      await this.call(transitionName, scope);
+      await this.call(A_StateMachineFeatures.onAfterTransition, scope);
+      scope.destroy();
+      return transition.result;
+    } catch (error) {
+      const wrappedError = new A_StateMachineError({
+        title: A_StateMachineError.TransitionError,
+        description: `An error occurred while transitioning to "${transitionName}"`,
+        originalError: error
+      });
+      scope.register(wrappedError);
+      await this.call(A_StateMachineFeatures.onError, scope);
+      scope.destroy();
+      throw wrappedError;
+    }
+  }
+};
+__decorateClass([
+  A_Feature.Extend()
+], A_StateMachine.prototype, _d, 1);
+__decorateClass([
+  A_Feature.Extend()
+], A_StateMachine.prototype, _c, 1);
+__decorateClass([
+  A_Feature.Extend()
+], A_StateMachine.prototype, _b, 1);
+__decorateClass([
+  A_Feature.Extend()
+], A_StateMachine.prototype, _a, 1);
+__decorateClass([
+  A_Frame.Method({
+    name: "transition",
+    description: "Executes a state transition from one state to another."
+  })
+], A_StateMachine.prototype, "transition", 1);
+A_StateMachine = __decorateClass([
+  A_Frame.Namespace("A-Utils"),
+  A_Frame.Component({
+    name: "A-StateMachine",
+    description: "A powerful state machine component for managing complex state transitions."
+  })
+], A_StateMachine);
+
+export { A_StateMachine };
+//# sourceMappingURL=A-StateMachine.component.mjs.map
+//# sourceMappingURL=A-StateMachine.component.mjs.map

package/dist/node/lib/A-StateMachine/A-StateMachine.component.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/A-StateMachine/A-StateMachine.component.ts"],"names":[],"mappings":"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","file":"A-StateMachine.component.mjs","sourcesContent":["import { A_Component, A_Context, A_Feature, A_FormatterHelper, A_Scope } from \"@adaas/a-concept\";\nimport { A_StateMachineError } from \"./A-StateMachine.error\";\nimport { A_StateMachineFeatures } from \"./A-StateMachine.constants\";\nimport { A_StateMachineTransition } from \"./A-StateMachineTransition.context\";\nimport { A_Frame } from \"@adaas/a-frame\";\n\n/**\n * A_StateMachine is a powerful state machine implementation that allows you to define and manage\n * complex state transitions with validation, hooks, and error handling.\n * \n * @template T - A record type defining the state transitions and their associated data types.\n *               Each key represents a state name, and the value represents the data type for that state.\n * \n * @example\n * ```typescript\n * interface OrderStates {\n *   pending: { orderId: string };\n *   processing: { orderId: string; processedBy: string };\n *   completed: { orderId: string; completedAt: Date };\n *   cancelled: { orderId: string; reason: string };\n * }\n * \n * class OrderStateMachine extends A_StateMachine<OrderStates> {\n *   // Define custom transition logic\n *   async pending_processing(scope: A_Scope) {\n *     const operation = scope.resolve(A_StateMachineTransition)!;\n *     const { orderId } = operation.props;\n *     // Custom validation and business logic\n *   }\n * }\n * ```\n */\n\n@A_Frame.Namespace('A-Utils')\n@A_Frame.Component({\n    name: 'A-StateMachine',\n    description: 'A powerful state machine component for managing complex state transitions.'\n})\nexport class A_StateMachine<\n    T extends Record<string, any> = Record<string, any>\n> extends A_Component {\n\n    /**\n     * Internal promise that tracks the initialization state of the state machine.\n     * Used to ensure the state machine is properly initialized before allowing transitions.\n     */\n    protected _initialized?: Promise<void>;\n\n    /**\n     * Gets a promise that resolves when the state machine is fully initialized and ready for transitions.\n     * This ensures that all initialization hooks have been executed before allowing state transitions.\n     * \n     * @returns Promise<void> that resolves when initialization is complete\n     * \n     * @example\n     * ```typescript\n     * const stateMachine = new MyStateMachine();\n     * await stateMachine.ready; // Wait for initialization\n     * await stateMachine.transition('idle', 'running');\n     * ```\n     */\n    get ready(): Promise<void> {\n        if (!this._initialized) {\n            this._initialized = new Promise<void>(\n                async (resolve, reject) => {\n                    try {\n                        await this.call(A_StateMachineFeatures.onInitialize);\n\n                        resolve();\n                    } catch (error) {\n                        const wrappedError = new A_StateMachineError({\n                            title: A_StateMachineError.InitializationError,\n                            description: `An error occurred during state machine initialization.`,\n                            originalError: error\n                        });\n\n                        reject(wrappedError);\n                    }\n                }\n            );\n        }\n\n        return this._initialized;\n    }\n\n\n\n    /**\n     * Initialization hook that runs when the state machine is first created.\n     * This method can be extended to add custom initialization logic.\n     * \n     * @param args - Variable arguments passed during initialization\n     * @returns Promise<void>\n     * \n     * @example\n     * ```typescript\n     * class MyStateMachine extends A_StateMachine {\n     *   @A_Feature.Extend()\n     *   async [A_StateMachineFeatures.onInitialize]() {\n     *     // Custom initialization logic\n     *     console.log('State machine initialized');\n     *   }\n     * }\n     * ```\n     */\n    @A_Feature.Extend()\n    async [A_StateMachineFeatures.onInitialize](...args: any[]): Promise<void> {\n        // Initialization logic can be added here\n    }\n\n    /**\n     * Hook that runs before any state transition occurs.\n     * Use this to add validation, logging, or preparation logic that should run for all transitions.\n     * \n     * @param args - Variable arguments, typically includes the transition scope\n     * @returns Promise<void>\n     * \n     * @example\n     * ```typescript\n     * class MyStateMachine extends A_StateMachine {\n     *   @A_Feature.Extend()\n     *   async [A_StateMachineFeatures.onBeforeTransition](scope: A_Scope) {\n     *     const operation = scope.resolve(A_StateMachineTransition)!;\n     *     console.log(`Transitioning from ${operation.props.from} to ${operation.props.to}`);\n     *   }\n     * }\n     * ```\n     */\n    @A_Feature.Extend()\n    async [A_StateMachineFeatures.onBeforeTransition](...args: any[]): Promise<void> {\n\n    }\n\n    /**\n     * Hook that runs after a successful state transition.\n     * Use this to add cleanup, logging, or post-transition logic that should run for all transitions.\n     * \n     * @param args - Variable arguments, typically includes the transition scope\n     * @returns Promise<void>\n     * \n     * @example\n     * ```typescript\n     * class MyStateMachine extends A_StateMachine {\n     *   @A_Feature.Extend()\n     *   async [A_StateMachineFeatures.onAfterTransition](scope: A_Scope) {\n     *     const operation = scope.resolve(A_StateMachineTransition)!;\n     *     console.log(`Successfully transitioned to ${operation.props.to}`);\n     *   }\n     * }\n     * ```\n     */\n    @A_Feature.Extend()\n    async [A_StateMachineFeatures.onAfterTransition](...args: any[]): Promise<void> {\n\n    }\n\n    /**\n     * Error handling hook that runs when a transition fails.\n     * Use this to add custom error handling, logging, or recovery logic.\n     * \n     * @param args - Variable arguments, typically includes the error scope\n     * @returns Promise<void>\n     * \n     * @example\n     * ```typescript\n     * class MyStateMachine extends A_StateMachine {\n     *   @A_Feature.Extend()\n     *   async [A_StateMachineFeatures.onError](scope: A_Scope) {\n     *     const error = scope.resolve(A_StateMachineError);\n     *     console.error('Transition failed:', error?.message);\n     *   }\n     * }\n     * ```\n     */\n    @A_Feature.Extend()\n    async [A_StateMachineFeatures.onError](...args: any[]): Promise<void> {\n        // Default error handling logic can be added here\n    }\n\n\n\n    /**\n     * Executes a state transition from one state to another.\n     * This is the core method of the state machine that handles the complete transition lifecycle.\n     * \n     * @param from - The state to transition from (must be a key of T)\n     * @param to - The state to transition to (must be a key of T)\n     * @param props - Optional properties to pass to the transition context (should match T[keyof T])\n     * @returns Promise<void> that resolves when the transition is complete\n     * \n     * @throws {A_StateMachineError} When the transition fails for any reason\n     * \n     * @example\n     * ```typescript\n     * interface OrderStates {\n     *   pending: { orderId: string };\n     *   processing: { orderId: string; processedBy: string };\n     * }\n     * \n     * const orderMachine = new A_StateMachine<OrderStates>();\n     * \n     * // Transition with props\n     * await orderMachine.transition('pending', 'processing', {\n     *   orderId: '12345',\n     *   processedBy: 'user-456'\n     * });\n     * ```\n     * \n     * The transition process follows this lifecycle:\n     * 1. Wait for state machine initialization (ready)\n     * 2. Create transition name in camelCase format (e.g., \"pending_processing\")\n     * 3. Create operation context with transition data\n     * 4. Create isolated scope for the transition\n     * 5. Call onBeforeTransition hook\n     * 6. Execute the specific transition method (if defined)\n     * 7. Call onAfterTransition hook\n     * 8. Clean up scope and return result\n     * \n     * If any step fails, the onError hook is called and a wrapped error is thrown.\n     */\n    @A_Frame.Method({\n        name: 'transition',\n        description: 'Executes a state transition from one state to another.'\n    })\n    async transition(\n        /**\n         * The state to transition from\n         */\n        from: keyof T,\n        /**\n         * The state to transition to\n         */\n        to: keyof T,\n        /**\n         * Optional properties to pass to the transition context\n         */\n        props?: T[keyof T]\n    ): Promise<void> {\n\n        await this.ready;\n\n        const transitionName = `${A_FormatterHelper.toCamelCase(String(from))}_${A_FormatterHelper.toCamelCase(String(to))}`;\n\n        const transition = new A_StateMachineTransition({\n            from: String(from),\n            to: String(to),\n            props\n        });\n\n        const scope = new A_Scope({\n            name: `A-StateMachine-Transition-Scope-${transitionName}`,\n            fragments: [transition]\n        })\n            .inherit(A_Context.scope(this));\n\n        try {\n\n            await this.call(A_StateMachineFeatures.onBeforeTransition, scope);\n\n            await this.call(transitionName, scope);\n\n            await this.call(A_StateMachineFeatures.onAfterTransition, scope);\n\n            scope.destroy();\n\n            return transition.result;\n\n        } catch (error) {\n            const wrappedError = new A_StateMachineError({\n                title: A_StateMachineError.TransitionError,\n                description: `An error occurred while transitioning to \"${transitionName}\"`,\n                originalError: error\n            });\n\n            scope.register(wrappedError);\n\n            await this.call(A_StateMachineFeatures.onError, scope);\n\n            scope.destroy();\n\n            throw wrappedError;\n        }\n    }\n}\n\n\n"]}

package/dist/node/lib/A-StateMachine/A-StateMachine.constants.d.mts

@@ -0,0 +1,20 @@
+declare enum A_StateMachineFeatures {
+    /**
+     * Allows to extend error handling logic and behavior
+     */
+    onError = "_A_StateMachine_onError",
+    /**
+     * Allows to extend initialization logic and behavior
+     */
+    onInitialize = "_A_StateMachine_onInitialize",
+    /**
+     * Allows to extend transition validation logic and behavior
+     */
+    onBeforeTransition = "_A_StateMachine_onBeforeTransition",
+    /**
+     * Allows to extend post-transition logic and behavior
+     */
+    onAfterTransition = "_A_StateMachine_onAfterTransition"
+}
+
+export { A_StateMachineFeatures };

package/dist/node/lib/A-StateMachine/A-StateMachine.constants.d.ts

@@ -0,0 +1,20 @@
+declare enum A_StateMachineFeatures {
+    /**
+     * Allows to extend error handling logic and behavior
+     */
+    onError = "_A_StateMachine_onError",
+    /**
+     * Allows to extend initialization logic and behavior
+     */
+    onInitialize = "_A_StateMachine_onInitialize",
+    /**
+     * Allows to extend transition validation logic and behavior
+     */
+    onBeforeTransition = "_A_StateMachine_onBeforeTransition",
+    /**
+     * Allows to extend post-transition logic and behavior
+     */
+    onAfterTransition = "_A_StateMachine_onAfterTransition"
+}
+
+export { A_StateMachineFeatures };

package/dist/node/lib/A-StateMachine/A-StateMachine.constants.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var A_StateMachineFeatures = /* @__PURE__ */ ((A_StateMachineFeatures2) => {
+  A_StateMachineFeatures2["onError"] = "_A_StateMachine_onError";
+  A_StateMachineFeatures2["onInitialize"] = "_A_StateMachine_onInitialize";
+  A_StateMachineFeatures2["onBeforeTransition"] = "_A_StateMachine_onBeforeTransition";
+  A_StateMachineFeatures2["onAfterTransition"] = "_A_StateMachine_onAfterTransition";
+  return A_StateMachineFeatures2;
+})(A_StateMachineFeatures || {});
+
+exports.A_StateMachineFeatures = A_StateMachineFeatures;
+//# sourceMappingURL=A-StateMachine.constants.js.map
+//# sourceMappingURL=A-StateMachine.constants.js.map

package/dist/node/lib/A-StateMachine/A-StateMachine.constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/A-StateMachine/A-StateMachine.constants.ts"],"names":["A_StateMachineFeatures"],"mappings":";;AAAO,IAAK,sBAAA,qBAAAA,uBAAAA,KAAL;AAIH,EAAAA,wBAAA,SAAA,CAAA,GAAU,yBAAA;AAIV,EAAAA,wBAAA,cAAA,CAAA,GAAe,8BAAA;AAIf,EAAAA,wBAAA,oBAAA,CAAA,GAAqB,oCAAA;AAIrB,EAAAA,wBAAA,mBAAA,CAAA,GAAoB,mCAAA;AAhBZ,EAAA,OAAAA,uBAAAA;AAAA,CAAA,EAAA,sBAAA,IAAA,EAAA","file":"A-StateMachine.constants.js","sourcesContent":["export enum A_StateMachineFeatures {\n    /**\n     * Allows to extend error handling logic and behavior\n     */\n    onError = '_A_StateMachine_onError',\n    /**\n     * Allows to extend initialization logic and behavior\n     */\n    onInitialize = '_A_StateMachine_onInitialize',\n    /**\n     * Allows to extend transition validation logic and behavior\n     */\n    onBeforeTransition = '_A_StateMachine_onBeforeTransition',\n    /**\n     * Allows to extend post-transition logic and behavior\n     */\n    onAfterTransition = '_A_StateMachine_onAfterTransition',\n}"]}

package/dist/node/lib/A-StateMachine/A-StateMachine.constants.mjs

@@ -0,0 +1,13 @@
+import '../../chunk-EQQGB2QZ.mjs';
+
+var A_StateMachineFeatures = /* @__PURE__ */ ((A_StateMachineFeatures2) => {
+  A_StateMachineFeatures2["onError"] = "_A_StateMachine_onError";
+  A_StateMachineFeatures2["onInitialize"] = "_A_StateMachine_onInitialize";
+  A_StateMachineFeatures2["onBeforeTransition"] = "_A_StateMachine_onBeforeTransition";
+  A_StateMachineFeatures2["onAfterTransition"] = "_A_StateMachine_onAfterTransition";
+  return A_StateMachineFeatures2;
+})(A_StateMachineFeatures || {});
+
+export { A_StateMachineFeatures };
+//# sourceMappingURL=A-StateMachine.constants.mjs.map
+//# sourceMappingURL=A-StateMachine.constants.mjs.map

package/dist/node/lib/A-StateMachine/A-StateMachine.constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/A-StateMachine/A-StateMachine.constants.ts"],"names":["A_StateMachineFeatures"],"mappings":";;AAAO,IAAK,sBAAA,qBAAAA,uBAAAA,KAAL;AAIH,EAAAA,wBAAA,SAAA,CAAA,GAAU,yBAAA;AAIV,EAAAA,wBAAA,cAAA,CAAA,GAAe,8BAAA;AAIf,EAAAA,wBAAA,oBAAA,CAAA,GAAqB,oCAAA;AAIrB,EAAAA,wBAAA,mBAAA,CAAA,GAAoB,mCAAA;AAhBZ,EAAA,OAAAA,uBAAAA;AAAA,CAAA,EAAA,sBAAA,IAAA,EAAA","file":"A-StateMachine.constants.mjs","sourcesContent":["export enum A_StateMachineFeatures {\n    /**\n     * Allows to extend error handling logic and behavior\n     */\n    onError = '_A_StateMachine_onError',\n    /**\n     * Allows to extend initialization logic and behavior\n     */\n    onInitialize = '_A_StateMachine_onInitialize',\n    /**\n     * Allows to extend transition validation logic and behavior\n     */\n    onBeforeTransition = '_A_StateMachine_onBeforeTransition',\n    /**\n     * Allows to extend post-transition logic and behavior\n     */\n    onAfterTransition = '_A_StateMachine_onAfterTransition',\n}"]}

package/dist/node/lib/A-StateMachine/A-StateMachine.error.d.mts

@@ -0,0 +1,8 @@
+import { A_Error } from '@adaas/a-concept';
+
+declare class A_StateMachineError extends A_Error {
+    static readonly InitializationError = "A-StateMachine Initialization Error";
+    static readonly TransitionError = "A-StateMachine Transition Error";
+}
+
+export { A_StateMachineError };

package/dist/node/lib/A-StateMachine/A-StateMachine.error.d.ts

@@ -0,0 +1,8 @@
+import { A_Error } from '@adaas/a-concept';
+
+declare class A_StateMachineError extends A_Error {
+    static readonly InitializationError = "A-StateMachine Initialization Error";
+    static readonly TransitionError = "A-StateMachine Transition Error";
+}
+
+export { A_StateMachineError };

package/dist/node/lib/A-StateMachine/A-StateMachine.error.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var aConcept = require('@adaas/a-concept');
+
+class A_StateMachineError extends aConcept.A_Error {
+}
+A_StateMachineError.InitializationError = "A-StateMachine Initialization Error";
+A_StateMachineError.TransitionError = "A-StateMachine Transition Error";
+
+exports.A_StateMachineError = A_StateMachineError;
+//# sourceMappingURL=A-StateMachine.error.js.map
+//# sourceMappingURL=A-StateMachine.error.js.map

package/dist/node/lib/A-StateMachine/A-StateMachine.error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/A-StateMachine/A-StateMachine.error.ts"],"names":["A_Error"],"mappings":";;;;AAGO,MAAM,4BAA4BA,gBAAA,CAAQ;AAMjD;AANa,mBAAA,CAEO,mBAAA,GAAsB,qCAAA;AAF7B,mBAAA,CAIO,eAAA,GAAkB,iCAAA","file":"A-StateMachine.error.js","sourcesContent":["import { A_Error } from \"@adaas/a-concept\";\n\n\nexport class A_StateMachineError extends A_Error {\n\n    static readonly InitializationError = 'A-StateMachine Initialization Error';\n\n    static readonly TransitionError = 'A-StateMachine Transition Error';\n    \n}"]}

package/dist/node/lib/A-StateMachine/A-StateMachine.error.mjs

@@ -0,0 +1,11 @@
+import '../../chunk-EQQGB2QZ.mjs';
+import { A_Error } from '@adaas/a-concept';
+
+class A_StateMachineError extends A_Error {
+}
+A_StateMachineError.InitializationError = "A-StateMachine Initialization Error";
+A_StateMachineError.TransitionError = "A-StateMachine Transition Error";
+
+export { A_StateMachineError };
+//# sourceMappingURL=A-StateMachine.error.mjs.map
+//# sourceMappingURL=A-StateMachine.error.mjs.map

package/dist/node/lib/A-StateMachine/A-StateMachine.error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/A-StateMachine/A-StateMachine.error.ts"],"names":[],"mappings":";;;AAGO,MAAM,4BAA4B,OAAA,CAAQ;AAMjD;AANa,mBAAA,CAEO,mBAAA,GAAsB,qCAAA;AAF7B,mBAAA,CAIO,eAAA,GAAkB,iCAAA","file":"A-StateMachine.error.mjs","sourcesContent":["import { A_Error } from \"@adaas/a-concept\";\n\n\nexport class A_StateMachineError extends A_Error {\n\n    static readonly InitializationError = 'A-StateMachine Initialization Error';\n\n    static readonly TransitionError = 'A-StateMachine Transition Error';\n    \n}"]}

package/dist/node/lib/A-StateMachine/A-StateMachine.types.d.mts

@@ -0,0 +1,14 @@
+import { A_Operation_Storage } from '../A-Operation/A-Operation.types.mjs';
+import '@adaas/a-concept';
+
+type A_StateMachineTransitionParams<T = any> = {
+    from: string;
+    to: string;
+    props?: T;
+};
+type A_StateMachineTransitionStorage<_ResultType extends any = any, _ParamsType extends any = any> = {
+    from: string;
+    to: string;
+} & A_Operation_Storage<_ResultType, A_StateMachineTransitionParams<_ParamsType>>;
+
+export type { A_StateMachineTransitionParams, A_StateMachineTransitionStorage };

package/dist/node/lib/A-StateMachine/A-StateMachine.types.d.ts

@@ -0,0 +1,14 @@
+import { A_Operation_Storage } from '../A-Operation/A-Operation.types.js';
+import '@adaas/a-concept';
+
+type A_StateMachineTransitionParams<T = any> = {
+    from: string;
+    to: string;
+    props?: T;
+};
+type A_StateMachineTransitionStorage<_ResultType extends any = any, _ParamsType extends any = any> = {
+    from: string;
+    to: string;
+} & A_Operation_Storage<_ResultType, A_StateMachineTransitionParams<_ParamsType>>;
+
+export type { A_StateMachineTransitionParams, A_StateMachineTransitionStorage };

package/dist/node/lib/A-StateMachine/A-StateMachine.types.js

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=A-StateMachine.types.js.map
+//# sourceMappingURL=A-StateMachine.types.js.map

package/dist/node/lib/A-StateMachine/A-StateMachine.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"A-StateMachine.types.js"}

package/dist/node/lib/A-StateMachine/A-StateMachine.types.mjs

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=A-StateMachine.types.mjs.map
+//# sourceMappingURL=A-StateMachine.types.mjs.map