@statewalker/fsm 0.23.0 → 0.24.0

package/dist/index.d.ts

@@ -6,6 +6,7 @@ declare class FsmBaseClass {
     getData<T>(key: string): T | undefined;
     _addHandler(type: string, handler: Function, direct?: boolean): () => void;
     _removeHandler(type: string, handler: Function): void;
+    _runHandlerParallel(type: string, ...args: unknown[]): Promise<void>;
     _runHandler(type: string, ...args: unknown[]): Promise<void>;
     _handleError(error: Error | unknown): Promise<void>;
 }
@@ -71,12 +72,15 @@ type FsmProcessDumpHandler = (process: FsmProcess, dump: FsmProcessDump) => void
 declare class FsmProcess extends FsmBaseClass {
     state?: FsmState;
     event?: string;
+    nextEvent?: string;
+    running: boolean;
+    mask: number;
     status: number;
     config: FsmStateConfig;
     rootDescriptor: FsmStateDescriptor;
     constructor(config: FsmStateConfig);
     shutdown(event?: string): Promise<void>;
-    dispatch(event: string, mask?: number): Promise<boolean>;
+    dispatch(event: string): Promise<boolean>;
     dump(...args: unknown[]): Promise<FsmProcessDump>;
     restore(dump: FsmProcessDump, ...args: unknown[]): Promise<this>;
     onStateCreate(handler: FsmStateHandler): () => void;
@@ -88,4 +92,29 @@ 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, STATE_ANY, STATE_FINAL, STATE_INITIAL, STATUS_ENTER, STATUS_EXIT, STATUS_FINISHED, STATUS_FIRST, STATUS_LAST, STATUS_LEAF, STATUS_NEXT, STATUS_NONE };
+type Printer = (...args: unknown[]) => void;
+type PrinterConfig = {
+    prefix?: string;
+    print?: (...args: unknown[]) => void;
+    lineNumbers?: boolean;
+};
+declare const KEY_PRINTER = "printer";
+declare function preparePrinter(process: FsmProcess, { prefix, print, lineNumbers }: PrinterConfig): Printer;
+declare function setPrinter(state: FsmState, config?: PrinterConfig): void;
+declare function setProcessPrinter(process: FsmProcess, config?: PrinterConfig): void;
+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;
+
+declare function isStateTransitionEnabled(process: FsmProcess, event: string): boolean;
+declare function getStateTransitions(state?: FsmState): [from: string, event: string, to: string][];
+
+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, KEY_PRINTER, type Printer, type PrinterConfig, STATE_ANY, STATE_FINAL, STATE_INITIAL, STATUS_ENTER, STATUS_EXIT, STATUS_FINISHED, STATUS_FIRST, STATUS_LAST, STATUS_LEAF, STATUS_NEXT, STATUS_NONE, getPrinter, getProcessPrinter, getStateTransitions, isStateTransitionEnabled, newProcess, preparePrinter, setPrinter, setProcessPrinter, setProcessTracer, setStateTracer };

package/dist/index.js

@@ -1,27 +1,420 @@
-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";
+// 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 _runHandlerParallel(type, ...args) {
+    const list = this.handlers[type] || [];
+    await Promise.all(
+      list.map(async (handler) => {
+        try {
+          await handler(...args);
+        } catch (error) {
+          this._handleError(error);
+        }
+      })
+    );
+  }
+  async _runHandler(type, ...args) {
+    const list = this.handlers[type] || [];
+    for (const handler of list) {
+      try {
+        await handler(...args);
+      } 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.running = false;
+    this.mask = STATUS_LEAF;
+    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) {
+    this.nextEvent = event;
+    if (!this.running && !(this.status & STATUS_FINISHED)) {
+      this.running = true;
+      try {
+        this.event = this.nextEvent;
+        this.nextEvent = void 0;
+        while (true) {
+          if (this.status & STATUS_EXIT) {
+            await this.state?._runHandler("onExit", this.state);
+          }
+          if (!this._update()) break;
+          if (this.status & STATUS_ENTER) {
+            await this.state?._runHandler("onEnter", this.state);
+          }
+          if (this.status & this.mask) break;
+        }
+      } finally {
+        this.running = false;
+      }
+      if (this.nextEvent !== void 0) {
+        await new Promise((r) => setImmediate(r));
+        return this.dispatch(this.nextEvent);
+      }
+    }
+    return !(this.status & STATUS_FINISHED);
+  }
+  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._runHandlerParallel("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);
+  }
+};
+
+// src/utils/printer.ts
+var KEY_PRINTER = "printer";
+function preparePrinter(process, { prefix = "", print = console.log, lineNumbers = false }) {
+  let lineCounter = 0;
+  const shift = () => {
+    let prefix2 = "";
+    for (let s = process.state?.parent; !!s; s = s.parent) {
+      prefix2 += "  ";
+    }
+    return prefix2;
+  };
+  const getPrefix = lineNumbers ? () => `[${++lineCounter}]${shift()}` : shift;
+  const printer = (...args) => print(prefix, getPrefix(), ...args);
+  return printer;
+}
+function setPrinter(state, config = {}) {
+  const printer = preparePrinter(state.process, config);
+  state.setData(KEY_PRINTER, printer);
+}
+function setProcessPrinter(process, config = {}) {
+  const printer = preparePrinter(process, config);
+  process.setData(KEY_PRINTER, printer);
+}
+function getProcessPrinter(process) {
+  return process.getData(KEY_PRINTER) || console.log;
+}
+function getPrinter(state) {
+  return state.getData(KEY_PRINTER, true) || getProcessPrinter(state.process);
+}
+
+// src/utils/tracer.ts
+function setProcessTracer(process, print) {
+  return process.onStateCreate((state) => {
+    setStateTracer(state, print);
+  });
+}
+function setStateTracer(state, print) {
+  state.onEnter(() => {
+    const printLine = print || getPrinter(state);
+    printLine(`<${state?.key} event="${state.process.event}">`);
+  });
+  state.onExit(async () => {
+    await Promise.resolve().then(async () => {
+      const printLine = print || getPrinter(state);
+      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;
+}
 export {
   EVENT_ANY,
   EVENT_EMPTY,
   FsmProcess,
   FsmState,
   FsmStateDescriptor,
+  KEY_PRINTER,
   STATE_ANY,
   STATE_FINAL,
   STATE_INITIAL,
@@ -32,5 +425,15 @@ export {
   STATUS_LAST,
   STATUS_LEAF,
   STATUS_NEXT,
-  STATUS_NONE
+  STATUS_NONE,
+  getPrinter,
+  getProcessPrinter,
+  getStateTransitions,
+  isStateTransitionEnabled,
+  newProcess,
+  preparePrinter,
+  setPrinter,
+  setProcessPrinter,
+  setProcessTracer,
+  setStateTracer
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statewalker/fsm",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "HFSM Implementation",
   "keywords": [],
   "homepage": "https://github.com/statewalker/statewalker-fsm",
@@ -24,12 +24,6 @@
       "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": {

package/src/FsmBaseClass.ts

@@ -31,17 +31,30 @@ export class FsmBaseClass {
     }
   }
 
+  async _runHandlerParallel(type: string, ...args: unknown[]) {
+    const list = this.handlers[type] || [];
+    await Promise.all(
+      list.map(async (handler) => {
+        try {
+          await handler(...args);
+        } catch (error) {
+          this._handleError(error);
+        }
+      }),
+    );
+  }
+
   async _runHandler(type: string, ...args: unknown[]) {
     const list = this.handlers[type] || [];
-    const promises = list.map((handler) => handler(...args));
-    for (const promise of promises) {
+    for (const handler of list) {
       try {
-        await promise;
+        await handler(...args);
       } catch (error) {
         await this._handleError(error);
       }
     }
   }
+
   async _handleError(error: Error | unknown) {
     console.error(error);
   }

package/src/FsmProcess.ts

@@ -38,6 +38,9 @@ export type FsmProcessDumpHandler = (
 export class FsmProcess extends FsmBaseClass {
   state?: FsmState;
   event?: string;
+  nextEvent?: string;
+  running: boolean = false;
+  mask: number = STATUS_LEAF;
   status: number = 0;
   config: FsmStateConfig;
   rootDescriptor: FsmStateDescriptor;
@@ -58,18 +61,34 @@ export class FsmProcess extends FsmBaseClass {
     }
   }
 
-  async dispatch(event: string, mask: number = STATUS_LEAF) {
-    this.event = event;
-    while (true) {
-      if (this.status & STATUS_EXIT) {
-        await this.state?._runHandler("onExit", this.state);
+  async dispatch(event: string): Promise<boolean> {
+    this.nextEvent = event;
+    if (!this.running && !(this.status & STATUS_FINISHED)) {
+      this.running = true;
+      try {
+        this.event = this.nextEvent;
+        this.nextEvent = undefined;
+        while (true) {
+          // ---
+          if (this.status & STATUS_EXIT) {
+            await this.state?._runHandler("onExit", this.state);
+          }
+          if (!this._update()) break;
+          if (this.status & STATUS_ENTER) {
+            await this.state?._runHandler("onEnter", this.state);
+          }
+          if (this.status & this.mask) break;
+          // ---
+        }
+      } finally {
+        this.running = false;
       }
-      if (!this._update()) return false;
-      if (this.status & STATUS_ENTER) {
-        await this.state?._runHandler("onEnter", this.state);
+      if (this.nextEvent !== undefined) {
+        await new Promise((r) => setImmediate(r));
+        return this.dispatch(this.nextEvent);
       }
-      if (this.status & mask) return true;
     }
+    return !(this.status & STATUS_FINISHED);
   }
 
   async dump(...args: unknown[]): Promise<FsmProcessDump> {
@@ -138,7 +157,7 @@ export class FsmProcess extends FsmBaseClass {
     descriptor: FsmStateDescriptor | undefined,
   ) {
     const state = new FsmState(this, parent, key, descriptor);
-    this._runHandler("onStateCreate", state);
+    this._runHandlerParallel("onStateCreate", state);
     return state;
   }
 

package/src/index.ts

@@ -2,3 +2,4 @@ export * from "./FsmProcess.ts";
 export * from "./FsmState.ts";
 export * from "./FsmStateConfig.ts";
 export * from "./FsmStateDescriptor.ts";
+export * from "./utils/index.ts";

package/src/utils/index.ts

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