@statewalker/fsm 0.23.0 → 0.23.1

package/dist/index.d.ts

@@ -88,4 +88,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,391 @@
-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 _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);
+  }
+};
+
+// 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(() => {
+    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 +396,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.23.1",
   "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/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";

package/dist/chunk-CRID7TZR.js

@@ -1,292 +0,0 @@
-// 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/utils/index.d.ts

@@ -1,42 +0,0 @@
-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$1>): void;
-
-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][];
-
-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,238 +0,0 @@
-import {
-  FsmProcess
-} from "../chunk-CRID7TZR.js";
-
-// src/utils/handlers.ts
-var KEY_HANDLERS = "handlers";
-function callStateHandlers(state) {
-  const key = state.key;
-  for (let parent = state.parent; !!parent; parent = parent?.parent) {
-    const handlers = parent.getData(KEY_HANDLERS)?.[key];
-    handlers?.forEach((handler) => handler(state));
-  }
-}
-function addSubstateHandlers(state, handlers) {
-  const oldIndex = state.getData(KEY_HANDLERS);
-  const index = oldIndex ? { ...oldIndex } : {};
-  for (const [key, handler] of Object.entries(handlers)) {
-    const list = index[key] = index[key] || [];
-    list.push(handler);
-  }
-  state.setData(KEY_HANDLERS, index);
-}
-
-// 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(() => {
-    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;
-}
-
-// 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,
-  addSubstateHandlers,
-  callStateHandlers,
-  getPrinter,
-  getProcessPrinter,
-  getStateTransitions,
-  isStateTransitionEnabled,
-  newHandlerLoader,
-  newModuleLoader,
-  newProcess,
-  newStateHandlers,
-  preparePrinter,
-  setPrinter,
-  setProcessPrinter,
-  setProcessTracer,
-  setStateTracer
-};