@alwatr/fsm 9.31.0 → 9.32.0

package/dist/main.js

@@ -1,5 +1,5 @@
-/* 📦 @alwatr/fsm v9.31.0 */
+/* 📦 @alwatr/fsm v9.32.0 */
 import{createPersistentStateSignal as U,createStateSignal as D}from"@alwatr/signal";import{createLogger as k}from"@alwatr/logger";import{createEventSignal as P}from"@alwatr/signal";class j{config_;stateSignal__;logger_;eventSignal__;stateSignal;activeActorCleanups__=new Set;constructor(q,z){this.config_=q;this.stateSignal__=z;this.logger_=k(`fsm:${this.config_.name}`),this.logger_.logMethodArgs?.("constructor",q),this.stateSignal=this.stateSignal__.asReadonly(),this.eventSignal__=P({name:`fsm-event-${this.config_.name}`}),this.eventSignal__.subscribe((J)=>this.processTransition__(J),{receivePrevious:!1}),this.start_()}dispatch=(q)=>{this.logger_.logMethodArgs?.("dispatch",{event:q}),this.eventSignal__.dispatch(q)};processTransition__(q){let z=this.stateSignal__.get();this.logger_.logMethodArgs?.("processTransition__",{state:z.name,event:q});let J=this.findTransition__(q,z.context);if(!J){this.logger_.incident?.("processTransition__","ignored_event","No valid transition found for event",{state:z.name,event:q});return}let X=J.target??z.name,K=J.target!==void 0;if(K)this.executeEffects__(q,z.context,this.config_.states[z.name]?.exit),this.cleanupActors__();let W=this.applyAssigners__(q,z.context,J.assigners),Q={name:X,context:W};if(this.stateSignal__.set(Q),K)this.executeEffects__(q,Q.context,this.config_.states[Q.name]?.entry),this.spawnActors__(q,Q.context,this.config_.states[Q.name]?.actors)}findTransition__(q,z){this.logger_.logMethod?.("findTransition__");let J=this.stateSignal__.get().name,K=this.config_.states[J]?.on?.[q.type];if(!K)return;let W=Array.isArray(K)?K:[K];for(let Q=0;Q<W.length;Q++){let Y=W[Q];if(!Y.guard)return Y;try{let Z=Y.guard({event:q,context:z});if(this.logger_.logStep?.("findTransition__","check_guard",{state:J,eventType:q.type,transitionIndex:Q,guard:Y.guard.name||"anonymous",result:Z}),Z)return Y}catch(Z){this.logger_.error("findTransition__","guard_failed",Z,{state:J,eventType:q.type,transitionIndex:Q,guard:Y.guard.name||"anonymous"})}}return}executeEffects__(q,z,J){if(!J){this.logger_.logMethodArgs?.("executeEffects__//skipped",{count:0});return}let X=Array.isArray(J)?J:[J];this.logger_.logMethodArgs?.("executeEffects__",{count:X.length});for(let K of X)try{let W=K({event:q,context:z});if(W instanceof Promise)W.catch((Q)=>{this.logger_.error("executeEffects__","effect_failed",Q,{effect:K.name||"anonymous",state:this.stateSignal__.get().name,event:q,context:z})})}catch(W){this.logger_.error("executeEffects__","effect_failed",W,{effect:K.name||"anonymous",state:this.stateSignal__.get().name,event:q,context:z})}}applyAssigners__(q,z,J){if(!J)return this.logger_.logMethodArgs?.("applyAssigners__//skipped",{count:0}),z;let X=Array.isArray(J)?J:[J];this.logger_.logMethodArgs?.("applyAssigners__",{count:X.length});try{let K=z;for(let W of X){let Q=W({event:q,context:K});if(this.logger_.logMethodFull?.(`event.${q.type}.action.${W.name||"anonymous"}`,{event:q,accContext:K},Q),Q!==void 0&&Q!==null)K=Q}return K}catch(K){return this.logger_.error("applyAssigners__","assigner_failed_atomic",K,{event:q,context:z}),z}}start_(){if(this.eventSignal__.isDestroyed)return;this.logger_.logMethod?.("start_");let q=this.stateSignal__.get(),z={type:"__init__"};this.executeEffects__(z,q.context,this.config_.states[q.name]?.entry),this.spawnActors__(z,q.context,this.config_.states[q.name]?.actors)}spawnActors__(q,z,J){if(!J){this.logger_.logMethodArgs?.("spawnActors__//skipped",{count:0});return}let X=Array.isArray(J)?J:[J];this.logger_.logMethodArgs?.("spawnActors__",{count:X.length});for(let K of X)try{let W=K({event:q,context:z,dispatch:this.dispatch});if(typeof W==="function")this.activeActorCleanups__.add(W)}catch(W){this.logger_.error("spawnActors__","actor_failed",W,{actor:K.name||"anonymous",state:this.stateSignal__.get().name,event:q,context:z})}}cleanupActors__(){this.logger_.logMethodArgs?.("cleanupActors__",{count:this.activeActorCleanups__.size});for(let q of this.activeActorCleanups__)try{q()}catch(z){this.logger_.error("cleanupActors__","cleanup_failed",z)}this.activeActorCleanups__.clear()}destroy(){this.logger_.logMethod?.("destroy"),this.cleanupActors__(),this.eventSignal__.destroy(),this.stateSignal__.destroy()}}function O(q){let z={name:q.initial,context:q.context},J=q.persistent?U({name:`fsm-state-${q.name}`,storageKey:q.persistent.storageKey??q.name,initialValue:z,schemaVersion:q.persistent.schemaVersion}):D({name:`fsm-state-${q.name}`,initialValue:z});return new j(q,J)}export{O as createFsmService,j as FsmService};
 
-//# debugId=E06E90A5ADCE4D7164756E2164756E21
+//# debugId=BC19972D6D3E964E64756E2164756E21
 //# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -6,6 +6,6 @@
     "import type {SingleOrArray} from '@alwatr/type-helper';\nimport {createLogger, type AlwatrLogger} from '@alwatr/logger';\nimport {\n  createEventSignal,\n  type StateSignal,\n  type PersistentStateSignal,\n  EventSignal,\n  type IReadonlySignal,\n} from '@alwatr/signal';\n\nimport type {StateMachineConfig, MachineState, MachineEvent, Transition, Effect, Assigner, Actor} from './type.js';\n\n/**\n * A generic, encapsulated service that creates, runs, and manages a finite state machine.\n * It handles signal creation, logic connection, and lifecycle management, providing a clean,\n * reactive API for interacting with the FSM.\n *\n * @template TState The union type of all possible state names.\n * @template TEvent The union type of all possible events.\n * @template TContext The type of the machine's context (extended state).\n */\nexport class FsmService<\n  TState extends string,\n  TEvent extends MachineEvent,\n  TContext extends Record<string, unknown> = Record<string, never>,\n> {\n  protected readonly logger_: AlwatrLogger;\n\n  /** The private event signal for sending events to the FSM. */\n  private readonly eventSignal__: EventSignal<TEvent>;\n\n  /** The public, read-only state signal. Subscribe to react to state changes. */\n  public readonly stateSignal: IReadonlySignal<MachineState<TState, TContext>>;\n\n  /** The set of cleanup functions for currently active state actors. */\n  private readonly activeActorCleanups__ = new Set<() => void>();\n\n  constructor(\n    protected readonly config_: StateMachineConfig<TState, TEvent, TContext>,\n    private readonly stateSignal__:\n      | StateSignal<MachineState<TState, TContext>>\n      | PersistentStateSignal<MachineState<TState, TContext>>,\n  ) {\n    this.logger_ = createLogger(`fsm:${this.config_.name}`);\n    this.logger_.logMethodArgs?.('constructor', config_);\n\n    this.stateSignal = this.stateSignal__.asReadonly();\n    this.eventSignal__ = createEventSignal<TEvent>({\n      name: `fsm-event-${this.config_.name}`,\n    });\n    this.eventSignal__.subscribe((event) => this.processTransition__(event), {receivePrevious: false});\n\n    // Execute initial state entry effects and actors.\n    this.start_();\n  }\n\n  /**\n   * Dispatches an event to the FSM mailbox.\n   *\n   * @param event The event to process.\n   */\n  public readonly dispatch = (event: TEvent): void => {\n    this.logger_.logMethodArgs?.('dispatch', {event});\n    this.eventSignal__.dispatch(event);\n  };\n\n  /**\n   * The core FSM logic that processes a single event and transitions the machine to a new state.\n   * This process is atomic and follows the Run-to-Completion (RTC) model.\n   *\n   * @param event The event to process.\n   */\n  private processTransition__(event: TEvent): void {\n    const currentState = this.stateSignal__.get();\n    this.logger_.logMethodArgs?.('processTransition__', {state: currentState.name, event});\n\n    const transition = this.findTransition__(event, currentState.context);\n\n    if (!transition) {\n      this.logger_.incident?.('processTransition__', 'ignored_event', 'No valid transition found for event', {\n        state: currentState.name,\n        event,\n      });\n      return; // Event ignored, no transition occurs.\n    }\n\n    const targetStateName = transition.target ?? currentState.name;\n    const isExternalTransition = transition.target !== undefined;\n\n    // 1. Execute exit effects and cleanup actors of the current state if it's an external transition.\n    if (isExternalTransition) {\n      this.executeEffects__(event, currentState.context, this.config_.states[currentState.name]?.exit);\n      this.cleanupActors__();\n    }\n\n    // 2. Apply assigners to compute the next context. This is a pure function.\n    const nextContext = this.applyAssigners__(event, currentState.context, transition.assigners);\n\n    // 3. Create the final next state object.\n    const nextState: MachineState<TState, TContext> = {\n      name: targetStateName,\n      context: nextContext,\n    };\n\n    // 4. Set the new state, notifying all subscribers.\n    this.stateSignal__.set(nextState);\n\n    // 5. Execute entry effects and spawn actors of the new state if it's an external transition.\n    if (isExternalTransition) {\n      this.executeEffects__(event, nextState.context, this.config_.states[nextState.name]?.entry);\n      this.spawnActors__(event, nextState.context, this.config_.states[nextState.name]?.actors);\n    }\n  }\n\n  /**\n   * Finds the first valid transition for the given event and context by evaluating guards.\n   *\n   * @param event The triggering event.\n   * @param context The current machine context.\n   * @returns The first matching transition or `undefined` if none are found.\n   */\n  private findTransition__(\n    event: TEvent,\n    context: Readonly<TContext>,\n  ): Transition<TState, TEvent, TContext> | undefined {\n    this.logger_.logMethod?.('findTransition__');\n\n    const currentStateName = this.stateSignal__.get().name;\n    const currentStateConfig = this.config_.states[currentStateName];\n    const transitions = currentStateConfig?.on?.[event.type as TEvent['type']] as\n      | SingleOrArray<Transition<TState, TEvent, TContext>>\n      | undefined;\n\n    if (!transitions) return undefined;\n\n    const transitionsArray = Array.isArray(transitions) ? transitions : [transitions];\n\n    for (let index = 0; index < transitionsArray.length; index++) {\n      const transition = transitionsArray[index];\n      if (!transition.guard) return transition;\n      try {\n        const guardMet = transition.guard({event, context});\n        this.logger_.logStep?.('findTransition__', 'check_guard', {\n          state: currentStateName,\n          eventType: event.type,\n          transitionIndex: index,\n          guard: transition.guard.name || 'anonymous',\n          result: guardMet,\n        });\n        if (guardMet) return transition;\n      } catch (error) {\n        this.logger_.error('findTransition__', 'guard_failed', error, {\n          state: currentStateName,\n          eventType: event.type,\n          transitionIndex: index,\n          guard: transition.guard.name || 'anonymous',\n        });\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Sequentially executes a list of effects (side-effects).\n   * Errors are caught and logged without stopping the FSM.\n   *\n   * @param event The event that triggered these effects.\n   * @param context The context at the time of execution.\n   * @param effects A single effect or an array of effects.\n   */\n  private executeEffects__(\n    event: TEvent,\n    context: Readonly<TContext>,\n    effects?: SingleOrArray<Effect<TEvent, TContext>>,\n  ): void {\n    if (!effects) {\n      this.logger_.logMethodArgs?.('executeEffects__//skipped', {count: 0});\n      return;\n    }\n    const effectsArray = Array.isArray(effects) ? effects : [effects];\n\n    this.logger_.logMethodArgs?.('executeEffects__', {count: effectsArray.length});\n\n    for (const effect of effectsArray) {\n      try {\n        const result = effect({event, context});\n        if (result instanceof Promise) {\n          result.catch((error) => {\n            this.logger_.error('executeEffects__', 'effect_failed', error, {\n              effect: effect.name || 'anonymous',\n              state: this.stateSignal__.get().name,\n              event,\n              context,\n            });\n          });\n        }\n      } catch (error) {\n        this.logger_.error('executeEffects__', 'effect_failed', error, {\n          effect: effect.name || 'anonymous',\n          state: this.stateSignal__.get().name,\n          event,\n          context,\n        });\n      }\n    }\n  }\n\n  /**\n   * Applies all assigner functions to the context to produce a new, updated context.\n   * This process is atomic (all-or-nothing). If any assigner fails, the original\n   * context is returned, and all updates are discarded.\n   *\n   * @param event The event that triggered the transition.\n   * @param context The current context.\n   * @param assigners A single assigner or an array of assigners.\n   * @returns The new, updated context, or the original context if any assigner fails.\n   */\n  private applyAssigners__(\n    event: TEvent,\n    context: TContext,\n    assigners?: SingleOrArray<Assigner<TEvent, TContext>>,\n  ): TContext {\n    if (!assigners) {\n      this.logger_.logMethodArgs?.('applyAssigners__//skipped', {count: 0});\n      return context;\n    }\n\n    const assignersArray = Array.isArray(assigners) ? assigners : [assigners];\n\n    this.logger_.logMethodArgs?.('applyAssigners__', {count: assignersArray.length});\n\n    try {\n      let accContext = context;\n      for (const assigner of assignersArray) {\n        const nextContext = assigner({event, context: accContext});\n        this.logger_.logMethodFull?.(\n          `event.${event.type}.action.${assigner.name || 'anonymous'}`,\n          {event, accContext},\n          nextContext,\n        );\n        if (nextContext !== undefined && nextContext !== null) {\n          accContext = nextContext;\n        }\n      }\n      return accContext;\n    } catch (error) {\n      this.logger_.error('applyAssigners__', 'assigner_failed_atomic', error, {\n        event,\n        context, // Log the original context for debugging.\n      });\n      // On ANY failure, discard all changes and return the original context.\n      return context;\n    }\n  }\n\n  /**\n   * Starts the FSM by executing the entry effects and spawning the actors\n   * of the initial/current state.\n   */\n  protected start_(): void {\n    if (this.eventSignal__.isDestroyed) return;\n    this.logger_.logMethod?.('start_');\n    const currentState = this.stateSignal__.get();\n    const initEvent = {type: '__init__'} as unknown as TEvent;\n    this.executeEffects__(initEvent, currentState.context, this.config_.states[currentState.name]?.entry);\n    this.spawnActors__(initEvent, currentState.context, this.config_.states[currentState.name]?.actors);\n  }\n\n  /**\n   * Spawns all configured actors for the entered state.\n   */\n  private spawnActors__(\n    event: TEvent,\n    context: Readonly<TContext>,\n    actors?: SingleOrArray<Actor<TEvent, TContext>>,\n  ): void {\n    if (!actors) {\n      this.logger_.logMethodArgs?.('spawnActors__//skipped', {count: 0});\n      return;\n    }\n    const actorsArray = Array.isArray(actors) ? actors : [actors];\n\n    this.logger_.logMethodArgs?.('spawnActors__', {count: actorsArray.length});\n\n    for (const actor of actorsArray) {\n      try {\n        const cleanup = actor({\n          event,\n          context,\n          dispatch: this.dispatch,\n        });\n        if (typeof cleanup === 'function') {\n          this.activeActorCleanups__.add(cleanup);\n        }\n      } catch (error) {\n        this.logger_.error('spawnActors__', 'actor_failed', error, {\n          actor: actor.name || 'anonymous',\n          state: this.stateSignal__.get().name,\n          event,\n          context,\n        });\n      }\n    }\n  }\n\n  /**\n   * Cleans up (destroys) all currently active state actors.\n   */\n  private cleanupActors__(): void {\n    this.logger_.logMethodArgs?.('cleanupActors__', {count: this.activeActorCleanups__.size});\n    for (const cleanup of this.activeActorCleanups__) {\n      try {\n        cleanup();\n      } catch (error) {\n        this.logger_.error('cleanupActors__', 'cleanup_failed', error);\n      }\n    }\n    this.activeActorCleanups__.clear();\n  }\n\n  /**\n   * Destroys the service, cleaning up all internal signals and subscriptions\n   * to prevent memory leaks.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n    this.cleanupActors__();\n    this.eventSignal__.destroy();\n    this.stateSignal__.destroy();\n  }\n}\n"
   ],
   "mappings": "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",
-  "debugId": "E06E90A5ADCE4D7164756E2164756E21",
+  "debugId": "BC19972D6D3E964E64756E2164756E21",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alwatr/fsm",
-  "version": "9.31.0",
+  "version": "9.32.0",
   "description": "A tiny, type-safe, declarative, and reactive finite state machine (FSM) library for modern TypeScript applications, built on top of Alwatr Signals.",
   "license": "MPL-2.0",
   "author": "S. Ali Mihandoost <ali.mihandoost@gmail.com> (https://ali.mihandoost.com)",
@@ -22,7 +22,7 @@
   "sideEffects": false,
   "dependencies": {
     "@alwatr/logger": "9.31.0",
-    "@alwatr/signal": "9.31.0"
+    "@alwatr/signal": "9.32.0"
   },
   "devDependencies": {
     "@alwatr/nano-build": "9.25.0",
@@ -65,5 +65,5 @@
     "state",
     "typescript"
   ],
-  "gitHead": "a2bdb86945c56f8b99b6dd0f8ec714df70dfa3e5"
+  "gitHead": "ac7ea45eecea81a216886612f1cd7dbc4b0dc106"
 }