@statewalker/fsm 0.22.0 → 0.23.0

package/dist/chunk-CRID7TZR.js

@@ -0,0 +1,292 @@
+// src/FsmBaseClass.ts
+var FsmBaseClass = class {
+  constructor() {
+    this.handlers = {};
+    this.data = {};
+    bindMethods(this, "setData", "getData");
+  }
+  setData(key, value) {
+    this.data[key] = value;
+    return this;
+  }
+  getData(key) {
+    return this.data[key];
+  }
+  // ----------------------------------------------
+  // internal methods
+  _addHandler(type, handler, direct = true) {
+    const list = this.handlers[type] = this.handlers[type] || [];
+    direct ? list.push(handler) : list.unshift(handler);
+    return () => this._removeHandler(type, handler);
+  }
+  _removeHandler(type, handler) {
+    let list = this.handlers[type];
+    if (!list) return;
+    list = list.filter((h) => h !== handler);
+    if (list.length > 0) {
+      this.handlers[type] = list;
+    } else {
+      delete this.handlers[type];
+    }
+  }
+  async _runHandler(type, ...args) {
+    const list = this.handlers[type] || [];
+    const promises = list.map((handler) => handler(...args));
+    for (const promise of promises) {
+      try {
+        await promise;
+      } catch (error) {
+        await this._handleError(error);
+      }
+    }
+  }
+  async _handleError(error) {
+    console.error(error);
+  }
+};
+function bindMethods(obj, ...methods) {
+  const o = obj;
+  for (const methodName of methods) {
+    const method = o[methodName];
+    if (typeof method !== "function") continue;
+    o[methodName] = method.bind(o);
+  }
+  return obj;
+}
+
+// src/FsmState.ts
+var FsmState = class extends FsmBaseClass {
+  constructor(process, parent, key, descriptor) {
+    super();
+    this.process = process;
+    this.key = key;
+    this.parent = parent;
+    this.descriptor = descriptor;
+    bindMethods(
+      this,
+      "onEnter",
+      "onExit",
+      "dump",
+      "restore",
+      "useData",
+      "onStateError"
+    );
+  }
+  onEnter(handler) {
+    return this._addHandler("onEnter", handler, true);
+  }
+  onExit(handler) {
+    return this._addHandler("onExit", handler, false);
+  }
+  onStateError(handler) {
+    return this._addHandler("onStateError", handler);
+  }
+  dump(handler) {
+    return this._addHandler("dump", handler, true);
+  }
+  restore(handler) {
+    return this._addHandler("restore", handler, true);
+  }
+  getData(key, recursive = true) {
+    return this.data[key] ?? (recursive ? this.parent?.getData(key, recursive) : void 0);
+  }
+  useData(key) {
+    return [
+      (recursive = true) => this.getData(key, recursive),
+      (value) => this.setData(key, value)
+    ];
+  }
+  async _handleError(error) {
+    await this._runHandler("onStateError", this, error);
+    await this.process._handleStateError(this, error);
+  }
+};
+
+// src/FsmStateConfig.ts
+var STATE_ANY = "*";
+var STATE_INITIAL = "";
+var STATE_FINAL = "";
+var EVENT_ANY = "*";
+var EVENT_EMPTY = "";
+
+// src/FsmStateDescriptor.ts
+var FsmStateDescriptor = class _FsmStateDescriptor {
+  constructor() {
+    this.transitions = {};
+    this.states = {};
+  }
+  static build(config) {
+    const descriptor = new _FsmStateDescriptor();
+    for (const [from, event, to] of config.transitions || []) {
+      const index = descriptor.transitions[from] = descriptor.transitions[from] || {};
+      index[event] = to;
+    }
+    if (config.states) {
+      for (const substateConfig of config.states) {
+        descriptor.states[substateConfig.key] = this.build(substateConfig);
+      }
+    }
+    return descriptor;
+  }
+  getTargetStateKey(stateKey, eventKey) {
+    const pairs = [
+      [stateKey, eventKey],
+      [STATE_ANY, eventKey],
+      [stateKey, EVENT_ANY],
+      [STATE_ANY, EVENT_ANY]
+    ];
+    let targetKey;
+    for (let i = 0, len = pairs.length; targetKey === void 0 && i < len; i++) {
+      const [stateKey2, eventKey2] = pairs[i];
+      const stateTransitions = this.transitions[stateKey2];
+      if (!stateTransitions) continue;
+      targetKey = stateTransitions[eventKey2];
+    }
+    return targetKey !== void 0 ? targetKey : STATE_FINAL;
+  }
+};
+
+// src/FsmProcess.ts
+var STATUS_NONE = 0;
+var STATUS_FIRST = 1;
+var STATUS_NEXT = 2;
+var STATUS_LEAF = 4;
+var STATUS_LAST = 8;
+var STATUS_FINISHED = 16;
+var STATUS_ENTER = STATUS_FIRST | STATUS_NEXT;
+var STATUS_EXIT = STATUS_LEAF | STATUS_LAST;
+var FsmProcess = class extends FsmBaseClass {
+  constructor(config) {
+    super();
+    this.status = 0;
+    this.rootDescriptor = FsmStateDescriptor.build(config);
+    this.config = config;
+    bindMethods(this, "dispatch", "dump", "restore");
+  }
+  async shutdown(event) {
+    while (this.state) {
+      this.event = event;
+      this.status = STATUS_FINISHED;
+      await this.state?._runHandler("onExit", this.state);
+      this.state = this.state.parent;
+    }
+  }
+  async dispatch(event, mask = STATUS_LEAF) {
+    this.event = event;
+    while (true) {
+      if (this.status & STATUS_EXIT) {
+        await this.state?._runHandler("onExit", this.state);
+      }
+      if (!this._update()) return false;
+      if (this.status & STATUS_ENTER) {
+        await this.state?._runHandler("onEnter", this.state);
+      }
+      if (this.status & mask) return true;
+    }
+  }
+  async dump(...args) {
+    const dumpState = async (state) => {
+      const stateDump = {
+        key: state.key,
+        data: {}
+      };
+      await state._runHandler("dump", state, stateDump.data, ...args);
+      return stateDump;
+    };
+    const dumpStates = async (state, stack = []) => {
+      if (!state) return stack;
+      state.parent && await dumpStates(state.parent, stack);
+      stack.push(await dumpState(state));
+      return stack;
+    };
+    const dump = {
+      status: this.status,
+      event: this.event,
+      stack: await dumpStates(this.state)
+    };
+    return dump;
+  }
+  async restore(dump, ...args) {
+    this.status = dump.status || 0;
+    this.event = dump.event;
+    this.state = void 0;
+    for (let i = 0; i < dump.stack.length; i++) {
+      const stateDump = dump.stack[i];
+      this.state = this.state ? this._newSubstate(this.state, stateDump.key) : this._newState(void 0, stateDump.key, this.rootDescriptor);
+      await this.state._runHandler(
+        "restore",
+        this.state,
+        stateDump.data,
+        ...args
+      );
+    }
+    return this;
+  }
+  onStateCreate(handler) {
+    return this._addHandler("onStateCreate", handler, true);
+  }
+  onStateError(handler) {
+    return this._addHandler("onStateError", handler);
+  }
+  async _handleStateError(state, error) {
+    await this._runHandler("onStateError", state, error);
+    this._handleError(error);
+  }
+  _newState(parent, key, descriptor) {
+    const state = new FsmState(this, parent, key, descriptor);
+    this._runHandler("onStateCreate", state);
+    return state;
+  }
+  _getSubstate(parent, prevStateKey) {
+    if (!parent) return;
+    const toState = parent.descriptor?.getTargetStateKey(
+      prevStateKey || STATE_INITIAL,
+      this.event || EVENT_EMPTY
+    ) || STATE_FINAL;
+    if (!toState) return;
+    return this._newSubstate(parent, toState);
+  }
+  _newSubstate(parent, toState) {
+    let descriptor;
+    for (let state = parent; !descriptor && state; state = state.parent) {
+      descriptor = state.descriptor?.states[toState];
+    }
+    return this._newState(parent, toState, descriptor);
+  }
+  _update() {
+    if (this.status & STATUS_FINISHED) return false;
+    const nextState = this.status !== STATUS_NONE ? this.status & STATUS_ENTER ? this._getSubstate(this.state, STATE_INITIAL) : this._getSubstate(this.state?.parent, this.state?.key) : this._newState(void 0, this.config.key, this.rootDescriptor);
+    if (nextState !== void 0) {
+      this.state = nextState;
+      this.status = this.status & STATUS_EXIT ? STATUS_NEXT : STATUS_FIRST;
+    } else {
+      if (this.status & STATUS_EXIT) {
+        this.state = this.state?.parent;
+        this.status = STATUS_LAST;
+      } else {
+        this.status = STATUS_LEAF;
+      }
+      if (!this.state) this.status = STATUS_FINISHED;
+    }
+    return !(this.status & STATUS_FINISHED);
+  }
+};
+
+export {
+  FsmState,
+  STATE_ANY,
+  STATE_INITIAL,
+  STATE_FINAL,
+  EVENT_ANY,
+  EVENT_EMPTY,
+  FsmStateDescriptor,
+  STATUS_NONE,
+  STATUS_FIRST,
+  STATUS_NEXT,
+  STATUS_LEAF,
+  STATUS_LAST,
+  STATUS_FINISHED,
+  STATUS_ENTER,
+  STATUS_EXIT,
+  FsmProcess
+};

package/dist/index.d.ts

@@ -6,7 +6,6 @@ declare class FsmBaseClass {
     getData<T>(key: string): T | undefined;
     _addHandler(type: string, handler: Function, direct?: boolean): () => void;
     _removeHandler(type: string, handler: Function): void;
-    _runHandlerSync(type: string, ...args: unknown[]): any[];
     _runHandler(type: string, ...args: unknown[]): Promise<void>;
     _handleError(error: Error | unknown): Promise<void>;
 }
@@ -22,7 +21,7 @@ type FsmStateConfig = {
     key: FsmStateKey;
     transitions?: [from: FsmStateKey, event: FsmEventKey, to: FsmStateKey][];
     states?: FsmStateConfig[];
-} & Record<string, any>;
+} & Record<string, unknown>;
 
 declare class FsmStateDescriptor {
     transitions: Record<string, Record<string, string>>;
@@ -31,14 +30,13 @@ declare class FsmStateDescriptor {
     getTargetStateKey(stateKey: string, eventKey: string): string;
 }
 
-type FsmStateDump = Record<string, any> & {
+type FsmStateDump = Record<string, unknown> & {
     key: string;
     data: Record<string, unknown>;
 };
 type FsmStateHandler = (state: FsmState, ...args: unknown[]) => void | Promise<void>;
-type FsmStateSyncHandler = (state: FsmState, ...args: unknown[]) => void;
 type FsmStateDumpHandler = (state: FsmState, dump: FsmStateDump) => void | Promise<void>;
-type FsmStateErrorHandler = (state: FsmState, error: any) => void | Promise<void>;
+type FsmStateErrorHandler = (state: FsmState, error: unknown) => void | Promise<void>;
 declare class FsmState extends FsmBaseClass {
     process: FsmProcess;
     key: string;
@@ -63,8 +61,8 @@ declare const STATUS_LAST = 8;
 declare const STATUS_FINISHED = 16;
 declare const STATUS_ENTER: number;
 declare const STATUS_EXIT: number;
-type FsmProcessHandler = (process: FsmProcess, ...args: any[]) => void | Promise<void>;
-type FsmProcessDump = Record<string, any> & {
+type FsmProcessHandler = (process: FsmProcess, ...args: unknown[]) => void | Promise<void>;
+type FsmProcessDump = Record<string, unknown> & {
     status: number;
     event?: string;
     stack: FsmStateDump[];
@@ -81,8 +79,8 @@ declare class FsmProcess extends FsmBaseClass {
     dispatch(event: string, mask?: number): Promise<boolean>;
     dump(...args: unknown[]): Promise<FsmProcessDump>;
     restore(dump: FsmProcessDump, ...args: unknown[]): Promise<this>;
-    onStateCreate(handler: FsmStateSyncHandler): () => void;
-    onStateError(handler: (state: FsmState, error: any) => void | Promise<void>): () => void;
+    onStateCreate(handler: FsmStateHandler): () => void;
+    onStateError(handler: (state: FsmState, error: unknown) => void | Promise<void>): () => void;
     _handleStateError(state: FsmState, error: Error | unknown): Promise<void>;
     _newState(parent: FsmState | undefined, key: string, descriptor: FsmStateDescriptor | undefined): FsmState;
     _getSubstate(parent: FsmState | undefined, prevStateKey: string | undefined): FsmState | undefined;
@@ -90,4 +88,4 @@ declare class FsmProcess extends FsmBaseClass {
     _update(): boolean;
 }
 
-export { EVENT_ANY, EVENT_EMPTY, type FsmEventKey, FsmProcess, type FsmProcessDump, type FsmProcessDumpHandler, type FsmProcessHandler, FsmState, type FsmStateConfig, FsmStateDescriptor, type FsmStateDump, type FsmStateDumpHandler, type FsmStateErrorHandler, type FsmStateHandler, type FsmStateKey, type FsmStateSyncHandler, STATE_ANY, STATE_FINAL, STATE_INITIAL, STATUS_ENTER, STATUS_EXIT, STATUS_FINISHED, STATUS_FIRST, STATUS_LAST, STATUS_LEAF, STATUS_NEXT, STATUS_NONE };
+export { EVENT_ANY, EVENT_EMPTY, type FsmEventKey, FsmProcess, type FsmProcessDump, type FsmProcessDumpHandler, type FsmProcessHandler, FsmState, type FsmStateConfig, FsmStateDescriptor, type FsmStateDump, type FsmStateDumpHandler, type FsmStateErrorHandler, type FsmStateHandler, type FsmStateKey, STATE_ANY, STATE_FINAL, STATE_INITIAL, STATUS_ENTER, STATUS_EXIT, STATUS_FINISHED, STATUS_FIRST, STATUS_LAST, STATUS_LEAF, STATUS_NEXT, STATUS_NONE };

package/dist/index.js

@@ -1,277 +1,21 @@
-// src/FsmBaseClass.ts
-var FsmBaseClass = class {
-  constructor() {
-    this.handlers = {};
-    this.data = {};
-    bindMethods(this, "setData", "getData");
-  }
-  setData(key, value) {
-    this.data[key] = value;
-    return this;
-  }
-  getData(key) {
-    return this.data[key];
-  }
-  // ----------------------------------------------
-  // internal methods
-  _addHandler(type, handler, direct = true) {
-    const list = this.handlers[type] = this.handlers[type] || [];
-    direct ? list.push(handler) : list.unshift(handler);
-    return () => this._removeHandler(type, handler);
-  }
-  _removeHandler(type, handler) {
-    let list = this.handlers[type];
-    if (!list) return;
-    list = list.filter((h) => h !== handler);
-    if (list.length > 0) {
-      this.handlers[type] = list;
-    } else {
-      delete this.handlers[type];
-    }
-  }
-  _runHandlerSync(type, ...args) {
-    const list = this.handlers[type] || [];
-    return list.map((handler) => handler(...args));
-  }
-  async _runHandler(type, ...args) {
-    const promises = this._runHandlerSync(type, ...args);
-    for (const promise of promises) {
-      try {
-        await promise;
-      } catch (error) {
-        await this._handleError(error);
-      }
-    }
-  }
-  async _handleError(error) {
-    console.error(error);
-  }
-};
-function bindMethods(obj, ...methods) {
-  const o = obj;
-  methods.forEach((methodName) => {
-    o[methodName] = o[methodName].bind(o);
-  });
-  return obj;
-}
-
-// src/FsmState.ts
-var FsmState = class extends FsmBaseClass {
-  constructor(process, parent, key, descriptor) {
-    super();
-    this.process = process;
-    this.key = key;
-    this.parent = parent;
-    this.descriptor = descriptor;
-    bindMethods(
-      this,
-      "onEnter",
-      "onExit",
-      "dump",
-      "restore",
-      "useData",
-      "onStateError"
-    );
-  }
-  onEnter(handler) {
-    return this._addHandler("onEnter", handler, true);
-  }
-  onExit(handler) {
-    return this._addHandler("onExit", handler, false);
-  }
-  onStateError(handler) {
-    return this._addHandler("onStateError", handler);
-  }
-  dump(handler) {
-    return this._addHandler("dump", handler, true);
-  }
-  restore(handler) {
-    return this._addHandler("restore", handler, true);
-  }
-  getData(key, recursive = true) {
-    return this.data[key] ?? (recursive ? this.parent?.getData(key, recursive) : void 0);
-  }
-  useData(key) {
-    return [
-      (recursive = true) => this.getData(key, recursive),
-      (value) => this.setData(key, value)
-    ];
-  }
-  async _handleError(error) {
-    await this._runHandler("onStateError", this, error);
-    await this.process._handleStateError(this, error);
-  }
-};
-
-// src/FsmStateConfig.ts
-var STATE_ANY = "*";
-var STATE_INITIAL = "";
-var STATE_FINAL = "";
-var EVENT_ANY = "*";
-var EVENT_EMPTY = "";
-
-// src/FsmStateDescriptor.ts
-var FsmStateDescriptor = class _FsmStateDescriptor {
-  constructor() {
-    this.transitions = {};
-    this.states = {};
-  }
-  static build(config) {
-    const descriptor = new _FsmStateDescriptor();
-    for (const [from, event, to] of config.transitions || []) {
-      const index = descriptor.transitions[from] = descriptor.transitions[from] || {};
-      index[event] = to;
-    }
-    if (config.states) {
-      for (const substateConfig of config.states) {
-        descriptor.states[substateConfig.key] = this.build(substateConfig);
-      }
-    }
-    return descriptor;
-  }
-  getTargetStateKey(stateKey, eventKey) {
-    const pairs = [
-      [stateKey, eventKey],
-      [STATE_ANY, eventKey],
-      [stateKey, EVENT_ANY],
-      [STATE_ANY, EVENT_ANY]
-    ];
-    let targetKey;
-    for (let i = 0, len = pairs.length; targetKey === void 0 && i < len; i++) {
-      const [stateKey2, eventKey2] = pairs[i];
-      const stateTransitions = this.transitions[stateKey2];
-      if (!stateTransitions) continue;
-      targetKey = stateTransitions[eventKey2];
-    }
-    return targetKey !== void 0 ? targetKey : STATE_FINAL;
-  }
-};
-
-// src/FsmProcess.ts
-var STATUS_NONE = 0;
-var STATUS_FIRST = 1;
-var STATUS_NEXT = 2;
-var STATUS_LEAF = 4;
-var STATUS_LAST = 8;
-var STATUS_FINISHED = 16;
-var STATUS_ENTER = STATUS_FIRST | STATUS_NEXT;
-var STATUS_EXIT = STATUS_LEAF | STATUS_LAST;
-var FsmProcess = class extends FsmBaseClass {
-  constructor(config) {
-    super();
-    this.status = 0;
-    this.rootDescriptor = FsmStateDescriptor.build(config);
-    this.config = config;
-    bindMethods(this, "dispatch", "dump", "restore");
-  }
-  async shutdown(event) {
-    while (this.state) {
-      this.event = event;
-      this.status = STATUS_FINISHED;
-      await this.state?._runHandler("onExit", this.state);
-      this.state = this.state.parent;
-    }
-  }
-  async dispatch(event, mask = STATUS_LEAF) {
-    this.event = event;
-    while (true) {
-      if (this.status & STATUS_EXIT) {
-        await this.state?._runHandler("onExit", this.state);
-      }
-      if (!this._update()) return false;
-      if (this.status & STATUS_ENTER) {
-        await this.state?._runHandler("onEnter", this.state);
-      }
-      if (this.status & mask) return true;
-    }
-  }
-  async dump(...args) {
-    const dumpState = async (state) => {
-      const stateDump = {
-        key: state.key,
-        data: {}
-      };
-      await state._runHandler("dump", state, stateDump.data, ...args);
-      return stateDump;
-    };
-    const dumpStates = async (state, stack = []) => {
-      if (!state) return stack;
-      state.parent && await dumpStates(state.parent, stack);
-      stack.push(await dumpState(state));
-      return stack;
-    };
-    const dump = {
-      status: this.status,
-      event: this.event,
-      stack: await dumpStates(this.state)
-    };
-    return dump;
-  }
-  async restore(dump, ...args) {
-    this.status = dump.status || 0;
-    this.event = dump.event;
-    this.state = void 0;
-    for (let i = 0; i < dump.stack.length; i++) {
-      const stateDump = dump.stack[i];
-      this.state = this.state ? this._newSubstate(this.state, stateDump.key) : this._newState(void 0, stateDump.key, this.rootDescriptor);
-      await this.state._runHandler(
-        "restore",
-        this.state,
-        stateDump.data,
-        ...args
-      );
-    }
-    return this;
-  }
-  onStateCreate(handler) {
-    return this._addHandler("onStateCreate", handler, true);
-  }
-  onStateError(handler) {
-    return this._addHandler("onStateError", handler);
-  }
-  async _handleStateError(state, error) {
-    await this._runHandler("onStateError", state, error);
-    this._handleError(error);
-  }
-  _newState(parent, key, descriptor) {
-    const state = new FsmState(this, parent, key, descriptor);
-    this._runHandlerSync("onStateCreate", state);
-    return state;
-  }
-  _getSubstate(parent, prevStateKey) {
-    if (!parent) return;
-    const toState = parent.descriptor?.getTargetStateKey(
-      prevStateKey || STATE_INITIAL,
-      this.event || EVENT_EMPTY
-    ) || STATE_FINAL;
-    if (!toState) return;
-    return this._newSubstate(parent, toState);
-  }
-  _newSubstate(parent, toState) {
-    let descriptor;
-    for (let state = parent; !descriptor && state; state = state.parent) {
-      descriptor = state.descriptor?.states[toState];
-    }
-    return this._newState(parent, toState, descriptor);
-  }
-  _update() {
-    if (this.status & STATUS_FINISHED) return false;
-    const nextState = this.status !== STATUS_NONE ? this.status & STATUS_ENTER ? this._getSubstate(this.state, STATE_INITIAL) : this._getSubstate(this.state?.parent, this.state?.key) : this._newState(void 0, this.config.key, this.rootDescriptor);
-    if (nextState !== void 0) {
-      this.state = nextState;
-      this.status = this.status & STATUS_EXIT ? STATUS_NEXT : STATUS_FIRST;
-    } else {
-      if (this.status & STATUS_EXIT) {
-        this.state = this.state?.parent;
-        this.status = STATUS_LAST;
-      } else {
-        this.status = STATUS_LEAF;
-      }
-      if (!this.state) this.status = STATUS_FINISHED;
-    }
-    return !(this.status & STATUS_FINISHED);
-  }
-};
+import {
+  EVENT_ANY,
+  EVENT_EMPTY,
+  FsmProcess,
+  FsmState,
+  FsmStateDescriptor,
+  STATE_ANY,
+  STATE_FINAL,
+  STATE_INITIAL,
+  STATUS_ENTER,
+  STATUS_EXIT,
+  STATUS_FINISHED,
+  STATUS_FIRST,
+  STATUS_LAST,
+  STATUS_LEAF,
+  STATUS_NEXT,
+  STATUS_NONE
+} from "./chunk-CRID7TZR.js";
 export {
   EVENT_ANY,
   EVENT_EMPTY,

package/dist/utils/index.d.ts

@@ -1,13 +1,13 @@
-import { FsmState, FsmStateHandler, FsmProcess } from '../index.js';
+import { FsmState, FsmStateHandler as FsmStateHandler$1, FsmProcess, FsmStateConfig } from '../index.js';
 
 declare const KEY_HANDLERS = "handlers";
 declare function callStateHandlers(state: FsmState): void;
-declare function addSubstateHandlers(state: FsmState, handlers: Record<string, FsmStateHandler>): void;
+declare function addSubstateHandlers(state: FsmState, handlers: Record<string, FsmStateHandler$1>): void;
 
-type Printer = (...args: any[]) => void;
+type Printer = (...args: unknown[]) => void;
 type PrinterConfig = {
     prefix?: string;
-    print?: (...args: any[]) => void;
+    print?: (...args: unknown[]) => void;
     lineNumbers?: boolean;
 };
 declare const KEY_PRINTER = "printer";
@@ -17,7 +17,26 @@ declare function setProcessPrinter(process: FsmProcess, config?: PrinterConfig):
 declare function getProcessPrinter(process: FsmProcess): Printer;
 declare function getPrinter(state: FsmState): Printer;
 
+declare function newProcess(config: FsmStateConfig, { prefix, print, lineNumbers, }: {
+    prefix?: string;
+    print?: (...args: any[]) => void;
+    lineNumbers?: boolean;
+}): FsmProcess;
+
 declare function setProcessTracer(process: FsmProcess, print?: Printer): () => void;
 declare function setStateTracer(state: FsmState, print?: Printer): void;
 
-export { KEY_HANDLERS, KEY_PRINTER, type Printer, type PrinterConfig, addSubstateHandlers, callStateHandlers, getPrinter, getProcessPrinter, preparePrinter, setPrinter, setProcessPrinter, setProcessTracer, setStateTracer };
+declare function isStateTransitionEnabled(process: FsmProcess, event: string): boolean;
+declare function getStateTransitions(state?: FsmState): [from: string, event: string, to: string][];
+
+declare function newModuleLoader<T>(baseUrl: string): (path: string) => Promise<T>;
+declare function newHandlerLoader(baseUrl: string, loader?: (path: string) => Promise<undefined | FsmStateHandler>): Promise<(state: FsmState) => Promise<FsmStateHandler[]>>;
+type FsmStateHandler<FsmStateContext extends Record<string, unknown> = Record<string, unknown>, FsmStateStore = Record<string, unknown>> = {
+    context?: (...stack: FsmStateStore[]) => FsmStateContext;
+    trigger?: (context: FsmStateContext, listener: (event: string) => void) => void | (() => void);
+    default?: (context: FsmStateContext) => void | (() => void);
+    handler?: (context: FsmStateContext) => void | (() => void);
+};
+declare function newStateHandlers<FsmStateContext extends Record<string, unknown> = Record<string, unknown>, FsmStateStore = Record<string, unknown>>(loader: (state: FsmState) => Promise<FsmStateHandler[]>, newContext?: (state: FsmState, ...stack: FsmStateStore[]) => FsmStateStore): (state: FsmState) => void;
+
+export { type FsmStateHandler, KEY_HANDLERS, KEY_PRINTER, type Printer, type PrinterConfig, addSubstateHandlers, callStateHandlers, getPrinter, getProcessPrinter, getStateTransitions, isStateTransitionEnabled, newHandlerLoader, newModuleLoader, newProcess, newStateHandlers, preparePrinter, setPrinter, setProcessPrinter, setProcessTracer, setStateTracer };

package/dist/utils/index.js

@@ -1,3 +1,7 @@
+import {
+  FsmProcess
+} from "../chunk-CRID7TZR.js";
+
 // src/utils/handlers.ts
 var KEY_HANDLERS = "handlers";
 function callStateHandlers(state) {
@@ -63,6 +67,156 @@ function setStateTracer(state, print) {
     printLine(`</${state.key}> <!-- event="${state.process.event}" -->`);
   });
 }
+
+// src/utils/process.ts
+function newProcess(config, {
+  prefix,
+  print,
+  lineNumbers = true
+}) {
+  let process = new FsmProcess(config);
+  setProcessPrinter(process, {
+    prefix,
+    print,
+    lineNumbers
+  });
+  setProcessTracer(process);
+  return process;
+}
+
+// src/utils/transitions.ts
+function isStateTransitionEnabled(process, event) {
+  const transitions = getStateTransitions(process.state);
+  let active = false;
+  for (const [from, ev, to] of transitions) {
+    if (ev === event) {
+      active = true;
+      break;
+    }
+  }
+  return active;
+}
+function getStateTransitions(state) {
+  const result = [];
+  let index = {};
+  if (state) {
+    let prevStateKey = state.key;
+    for (let parent = state?.parent; parent; parent = parent.parent) {
+      if (!parent.descriptor) continue;
+      result.push(
+        ...getTransitionsFromDescriptor(parent.descriptor, prevStateKey, index)
+      );
+      prevStateKey = parent.key;
+    }
+  }
+  return result.reverse();
+}
+function getTransitionsFromDescriptor(descriptor, prevStateKey, index = {}) {
+  const result = [];
+  const prevStateKeys = [prevStateKey, "*"];
+  for (const prevKey of prevStateKeys) {
+    const targets = descriptor.transitions[prevKey];
+    if (targets) {
+      for (const [event, target] of Object.entries(targets)) {
+        if (index[event]) continue;
+        if (target) {
+          index[event] = true;
+        }
+        result.push([prevStateKey, event, target]);
+      }
+    }
+  }
+  return result;
+}
+
+// src/utils/newFsmStateHandler.ts
+function newModuleLoader(baseUrl) {
+  const cache = {};
+  return async (path) => {
+    return cache[path] = cache[path] || (async () => {
+      const suffixes = ["/", "", ".js", "/index.js"];
+      for (const suffix of suffixes) {
+        const url = new URL(path + suffix, baseUrl).pathname;
+        try {
+          return await import(url);
+        } catch (error) {
+          continue;
+        }
+      }
+    })();
+  };
+}
+async function newHandlerLoader(baseUrl, loader = newModuleLoader(baseUrl)) {
+  return async (state) => {
+    const stack = [];
+    for (let s = state; s; s = s.parent) {
+      stack.unshift(s.key);
+    }
+    const handlers = [];
+    let topName;
+    while (stack.length > 0) {
+      const lastSegment = stack.pop();
+      if (!topName) {
+        topName = lastSegment;
+        if (topName === void 0) break;
+      }
+      const path = [...stack, topName].join("/");
+      const handler = await loader(path);
+      handler && handlers.push(handler);
+    }
+    return handlers;
+  };
+}
+function newStateHandlers(loader, newContext = (state) => ({
+  state: state.key,
+  event: state.process.event
+})) {
+  return (state) => {
+    const stack = [];
+    for (let s = state.parent; !!s; s = s.parent) {
+      const store2 = s.getData("context");
+      store2 && stack.push(store2);
+    }
+    const store = newContext(state, ...stack);
+    stack.unshift(store);
+    state.setData("context", store);
+    let registrations = [];
+    state.onExit(() => {
+      for (const registration of registrations) {
+        registration?.();
+      }
+    });
+    state.onEnter(async () => {
+      const modules = await loader(state);
+      if (!modules?.length) return;
+      for (const module of modules) {
+        const ctx = isClass(module.context) ? new module.context(...stack) : isFunction(module.context) ? module.context(...stack) || store : store;
+        const stateContext = ctx;
+        let notifyTrigger = (event) => {
+          if (event) {
+            state.process.dispatch(event);
+          }
+        };
+        const removeTrigger = module?.trigger?.(
+          stateContext,
+          (event) => notifyTrigger(event)
+        );
+        registrations.push(() => notifyTrigger = () => {
+        });
+        removeTrigger && registrations.push(removeTrigger);
+        const handler = module.default || module.handler;
+        registrations.push(handler?.(stateContext));
+      }
+      function isFunction(value) {
+        return typeof value === "function";
+      }
+      function isClass(value) {
+        if (!isFunction(value)) return false;
+        return value.prototype.constructor.toString().match(/^class/);
+      }
+    });
+  };
+}
 export {
   KEY_HANDLERS,
   KEY_PRINTER,
@@ -70,6 +224,12 @@ export {
   callStateHandlers,
   getPrinter,
   getProcessPrinter,
+  getStateTransitions,
+  isStateTransitionEnabled,
+  newHandlerLoader,
+  newModuleLoader,
+  newProcess,
+  newStateHandlers,
   preparePrinter,
   setPrinter,
   setProcessPrinter,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statewalker/fsm",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "HFSM Implementation",
   "keywords": [],
   "homepage": "https://github.com/statewalker/statewalker-fsm",
@@ -14,14 +14,23 @@
     "dist",
     "src"
   ],
+  "source": "./src/index.ts",
   "module": "./dist/index.js",
   "main": "./dist/index.js",
-  "jsdelivr": "./dist/index.js",
-  "unpkg": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js",
-    "./utils": "./dist/utils/index.js"
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./utils": {
+      "source": "./src/utils/index.ts",
+      "types": "./dist/utils/index.d.ts",
+      "import": "./dist/utils/index.js",
+      "default": "./dist/utils/index.js"
+    }
   },
   "devDependencies": {
     "@changesets/cli": "^2.27.7",
@@ -43,7 +52,8 @@
     "clean": "rm -rf dist",
     "lint": "eslint \"**/*.(js|ts)\"",
     "test": "vitest --run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "prepublish": "yarn dist"
   },
   "sideEffects": false,
   "publishConfig": {

package/src/FsmBaseClass.ts

@@ -30,12 +30,10 @@ export class FsmBaseClass {
       delete this.handlers[type];
     }
   }
-  _runHandlerSync(type: string, ...args: unknown[]) {
-    const list = this.handlers[type] || [];
-    return list.map((handler) => handler(...args));
-  }
+
   async _runHandler(type: string, ...args: unknown[]) {
-    const promises = this._runHandlerSync(type, ...args);
+    const list = this.handlers[type] || [];
+    const promises = list.map((handler) => handler(...args));
     for (const promise of promises) {
       try {
         await promise;
@@ -49,10 +47,12 @@ export class FsmBaseClass {
   }
 }
 
-export function bindMethods<T>(obj: T, ...methods: string[]) {
-  const o = obj as any;
-  methods.forEach((methodName) => {
-    o[methodName] = (o[methodName] as Function).bind(o);
-  });
+export function bindMethods<T>(obj: T, ...methods: (string | symbol)[]) {
+  const o = obj as Record<string | symbol, unknown>;
+  for (const methodName of methods) {
+    const method = o[methodName];
+    if (typeof method !== "function") continue;
+    o[methodName] = method.bind(o);
+  }
   return obj;
 }

package/src/FsmProcess.ts

@@ -1,5 +1,5 @@
 import { FsmBaseClass, bindMethods } from "./FsmBaseClass.ts";
-import { FsmState, FsmStateDump, FsmStateSyncHandler } from "./FsmState.ts";
+import { FsmState, FsmStateDump, FsmStateHandler } from "./FsmState.ts";
 import {
   EVENT_EMPTY,
   FsmStateConfig,
@@ -21,10 +21,10 @@ export const STATUS_EXIT = STATUS_LEAF | STATUS_LAST;
 
 export type FsmProcessHandler = (
   process: FsmProcess,
-  ...args: any[]
+  ...args: unknown[]
 ) => void | Promise<void>;
 
-export type FsmProcessDump = Record<string, any> & {
+export type FsmProcessDump = Record<string, unknown> & {
   status: number;
   event?: string;
   stack: FsmStateDump[];
@@ -32,7 +32,7 @@ export type FsmProcessDump = Record<string, any> & {
 
 export type FsmProcessDumpHandler = (
   process: FsmProcess,
-  dump: FsmProcessDump
+  dump: FsmProcessDump,
 ) => void | Promise<void>;
 
 export class FsmProcess extends FsmBaseClass {
@@ -83,7 +83,7 @@ export class FsmProcess extends FsmBaseClass {
     };
     const dumpStates = async (
       state: FsmState | undefined,
-      stack: FsmStateDump[] = []
+      stack: FsmStateDump[] = [],
     ) => {
       if (!state) return stack;
       state.parent && (await dumpStates(state.parent, stack));
@@ -111,17 +111,19 @@ export class FsmProcess extends FsmBaseClass {
         "restore",
         this.state,
         stateDump.data,
-        ...args
+        ...args,
       );
     }
     return this;
   }
 
-  onStateCreate(handler: FsmStateSyncHandler) {
+  onStateCreate(handler: FsmStateHandler) {
     return this._addHandler("onStateCreate", handler, true);
   }
 
-  onStateError(handler: (state: FsmState, error: any) => void | Promise<void>) {
+  onStateError(
+    handler: (state: FsmState, error: unknown) => void | Promise<void>,
+  ) {
     return this._addHandler("onStateError", handler);
   }
 
@@ -133,10 +135,10 @@ export class FsmProcess extends FsmBaseClass {
   _newState(
     parent: FsmState | undefined,
     key: string,
-    descriptor: FsmStateDescriptor | undefined
+    descriptor: FsmStateDescriptor | undefined,
   ) {
     const state = new FsmState(this, parent, key, descriptor);
-    this._runHandlerSync("onStateCreate", state);
+    this._runHandler("onStateCreate", state);
     return state;
   }
 
@@ -145,7 +147,7 @@ export class FsmProcess extends FsmBaseClass {
     const toState =
       parent.descriptor?.getTargetStateKey(
         prevStateKey || STATE_INITIAL,
-        this.event || EVENT_EMPTY
+        this.event || EVENT_EMPTY,
       ) || STATE_FINAL;
     if (!toState) return;
     return this._newSubstate(parent, toState);

package/src/FsmState.ts

@@ -2,7 +2,7 @@ import { FsmBaseClass, bindMethods } from "./FsmBaseClass.ts";
 import { FsmProcess } from "./FsmProcess.ts";
 import { FsmStateDescriptor } from "./FsmStateDescriptor.ts";
 
-export type FsmStateDump = Record<string, any> & {
+export type FsmStateDump = Record<string, unknown> & {
   key: string;
   data: Record<string, unknown>;
 };
@@ -11,8 +11,6 @@ export type FsmStateHandler = (
   ...args: unknown[]
 ) => void | Promise<void>;
 
-export type FsmStateSyncHandler = (state: FsmState, ...args: unknown[]) => void;
-
 export type FsmStateDumpHandler = (
   state: FsmState,
   dump: FsmStateDump
@@ -20,7 +18,7 @@ export type FsmStateDumpHandler = (
 
 export type FsmStateErrorHandler = (
   state: FsmState,
-  error: any
+  error: unknown
 ) => void | Promise<void>;
 
 export class FsmState extends FsmBaseClass {

package/src/FsmStateConfig.ts

@@ -10,4 +10,4 @@ export type FsmStateConfig = {
   key: FsmStateKey;
   transitions?: [from: FsmStateKey, event: FsmEventKey, to: FsmStateKey][];
   states?: FsmStateConfig[];
-} & Record<string, any>;
+} & Record<string, unknown>;

package/src/utils/index.ts

@@ -1,3 +1,6 @@
 export * from "./handlers.ts";
 export * from "./printer.ts";
+export * from "./process.ts";
 export * from "./tracer.ts";
+export * from "./transitions.ts";
+export * from "./newFsmStateHandler.ts";

package/src/utils/newFsmStateHandler.ts

@@ -0,0 +1,155 @@
+import { FsmState } from "../FsmState";
+
+export function newModuleLoader<T>(baseUrl: string) {
+  const cache: Record<string, Promise<T>> = {};
+  return async (path: string) => {
+    return (cache[path] =
+      cache[path] ||
+      (async () => {
+        const suffixes = ["/", "", ".js", "/index.js"];
+        for (const suffix of suffixes) {
+          const url = new URL(path + suffix, baseUrl).pathname;
+          try {
+            return (await import(url)) as T;
+          } catch (error) {
+            continue;
+          }
+        }
+      })());
+  };
+}
+
+export async function newHandlerLoader(
+  baseUrl: string,
+  loader: (
+    path: string,
+  ) => Promise<undefined | FsmStateHandler> = newModuleLoader(baseUrl),
+): Promise<(state: FsmState) => Promise<FsmStateHandler[]>> {
+  return async (state: FsmState) => {
+    const stack: string[] = [];
+    for (let s: FsmState | undefined = state; s; s = s.parent) {
+      stack.unshift(s.key);
+    }
+
+    const handlers: FsmStateHandler[] = [];
+    let topName: undefined | string;
+    while (stack.length > 0) {
+      const lastSegment = stack.pop();
+      if (!topName) {
+        topName = lastSegment;
+        if (topName === undefined) break;
+      }
+      const path = [...stack, topName].join("/");
+      const handler = await loader(path);
+      handler && handlers.push(handler);
+    }
+
+    return handlers;
+  };
+}
+
+/*
+* StateContext: 
+- Each context is a function or a class
+- It recieves the stack of state objects
+- The returned value is used to pass to the handler function
+* Trigger function
+- recieves the context instance
+- notifies about changes using the given callback
+* Handler
+- recieves the context
+- starts activities on call
+- optionally returns a cleanup function
+- could return a promise with optional cleanup function; the state is not 
+  activated until all handlers return the control
+*/
+export type FsmStateHandler<
+  FsmStateContext extends Record<string, unknown> = Record<string, unknown>,
+  FsmStateStore = Record<string, unknown>,
+> = {
+  context?: (...stack: FsmStateStore[]) => FsmStateContext;
+  trigger?: (
+    context: FsmStateContext,
+    listener: (event: string) => void,
+  ) => void | (() => void);
+  default?: (context: FsmStateContext) => void | (() => void);
+  handler?: (context: FsmStateContext) => void | (() => void);
+};
+
+export function newStateHandlers<
+  FsmStateContext extends Record<string, unknown> = Record<string, unknown>,
+  FsmStateStore = Record<string, unknown>,
+>(
+  loader: (state: FsmState) => Promise<FsmStateHandler[]>,
+  newContext: (state: FsmState, ...stack: FsmStateStore[]) => FsmStateStore = (
+    state,
+  ) =>
+    ({
+      state: state.key,
+      event: state.process.event,
+    }) as unknown as FsmStateStore,
+) {
+  return (state: FsmState) => {
+    const stack: FsmStateStore[] = [];
+    for (let s: FsmState | undefined = state.parent; !!s; s = s.parent) {
+      const store = s.getData<FsmStateStore>("context");
+      store && stack.push(store);
+    }
+    const store = newContext(state, ...stack);
+    stack.unshift(store);
+    state.setData("context", store);
+
+    // const process = state.process;
+    // let processContext = process.getData<FsmProcessContext>("context");
+    // if (!processContext) {
+    //   processContext = newContext(process);
+    //   process.setData("context", processContext);
+    // }
+    let registrations: (void | (() => void))[] = [];
+    state.onExit(() => {
+      for (const registration of registrations) {
+        registration?.();
+      }
+    });
+    state.onEnter(async () => {
+      const modules = await loader(state);
+      if (!modules?.length) return;
+      for (const module of modules) {
+        // Update state context
+        // TODO: use a stack of context objects
+        const ctx = isClass(module.context)
+          ? new module.context(...stack)
+          : isFunction(module.context)
+            ? module.context(...stack) || store
+            : store;
+        const stateContext = ctx as FsmStateContext;
+        // Set trigger
+        let notifyTrigger = (event: string) => {
+          if (event) {
+            // TODO: Check that the event is available in this state;
+            state.process.dispatch(event);
+          }
+        };
+        const removeTrigger = module?.trigger?.(stateContext, (event) =>
+          notifyTrigger(event),
+        );
+        registrations.push(() => (notifyTrigger = () => {}));
+        removeTrigger && registrations.push(removeTrigger);
+
+        const handler = module.default || module.handler;
+        registrations.push(handler?.(stateContext));
+      }
+      function isFunction<T extends Array<unknown>, R = unknown>(
+        value: unknown,
+      ): value is (...args: T) => R {
+        return typeof value === "function";
+      }
+      function isClass<T extends Array<unknown>, R = unknown>(
+        value: unknown,
+      ): value is new (...args: T) => R {
+        if (!isFunction(value)) return false;
+        return value.prototype.constructor.toString().match(/^class/);
+      }
+    });
+  };
+}

package/src/utils/printer.ts

@@ -1,9 +1,9 @@
 import type { FsmProcess } from "../FsmProcess.ts";
 import type { FsmState } from "../FsmState.ts";
-export type Printer = (...args: any[]) => void;
+export type Printer = (...args: unknown[]) => void;
 export type PrinterConfig = {
   prefix?: string;
-  print?: (...args: any[]) => void;
+  print?: (...args: unknown[]) => void;
   lineNumbers?: boolean;
 };
 
@@ -11,7 +11,7 @@ export const KEY_PRINTER = "printer";
 
 export function preparePrinter(
   process: FsmProcess,
-  { prefix = "", print = console.log, lineNumbers = false }: PrinterConfig
+  { prefix = "", print = console.log, lineNumbers = false }: PrinterConfig,
 ): Printer {
   let lineCounter = 0;
   const shift = () => {
@@ -22,7 +22,7 @@ export function preparePrinter(
     return prefix;
   };
   const getPrefix = lineNumbers ? () => `[${++lineCounter}]${shift()}` : shift;
-  const printer = (...args: string[]) => print(prefix, getPrefix(), ...args);
+  const printer = (...args: unknown[]) => print(prefix, getPrefix(), ...args);
   return printer;
 }
 
@@ -33,7 +33,7 @@ export function setPrinter(state: FsmState, config: PrinterConfig = {}) {
 
 export function setProcessPrinter(
   process: FsmProcess,
-  config: PrinterConfig = {}
+  config: PrinterConfig = {},
 ) {
   const printer = preparePrinter(process, config);
   process.setData(KEY_PRINTER, printer);

package/src/utils/process.ts

@@ -0,0 +1,26 @@
+import { FsmProcess } from "../FsmProcess.ts";
+import type { FsmStateConfig } from "../FsmStateConfig.ts";
+import { setProcessPrinter } from "./printer.ts";
+import { setProcessTracer } from "./tracer.ts";
+
+export function newProcess(
+  config: FsmStateConfig,
+  {
+    prefix,
+    print,
+    lineNumbers = true,
+  }: {
+    prefix?: string;
+    print?: (...args: any[]) => void;
+    lineNumbers?: boolean;
+  },
+): FsmProcess {
+  let process = new FsmProcess(config);
+  setProcessPrinter(process, {
+    prefix,
+    print,
+    lineNumbers,
+  });
+  setProcessTracer(process);
+  return process;
+}

package/src/utils/transitions.ts

@@ -0,0 +1,56 @@
+import { FsmProcess } from "../FsmProcess.ts";
+import type { FsmState } from "../FsmState.ts";
+import type { FsmStateDescriptor } from "../FsmStateDescriptor.ts";
+
+export function isStateTransitionEnabled(process: FsmProcess, event: string) {
+  const transitions = getStateTransitions(process.state);
+  let active = false;
+  for (const [from, ev, to] of transitions) {
+    if (ev === event) {
+      active = true;
+      break;
+    }
+  }
+  return active;
+}
+
+export function getStateTransitions(
+  state?: FsmState,
+): [from: string, event: string, to: string][] {
+  const result: [from: string, event: string, to: string][] = [];
+  let index = {};
+  if (state) {
+    let prevStateKey = state.key;
+    for (let parent = state?.parent; parent; parent = parent.parent) {
+      if (!parent.descriptor) continue;
+      result.push(
+        ...getTransitionsFromDescriptor(parent.descriptor, prevStateKey, index),
+      );
+      prevStateKey = parent.key;
+    }
+  }
+  return result.reverse();
+}
+
+function getTransitionsFromDescriptor(
+  descriptor: FsmStateDescriptor,
+  prevStateKey: string,
+  index: Record<string, boolean> = {},
+) {
+  const result: [from: string, event: string, to: string][] = [];
+  const prevStateKeys = [prevStateKey, "*"];
+  for (const prevKey of prevStateKeys) {
+    const targets: undefined | Record<string, string> =
+      descriptor.transitions[prevKey];
+    if (targets) {
+      for (const [event, target] of Object.entries(targets)) {
+        if (index[event]) continue;
+        if (target) {
+          index[event] = true;
+        }
+        result.push([prevStateKey, event, target]);
+      }
+    }
+  }
+  return result;
+}