@statewalker/fsm 0.22.1 → 0.23.1

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,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, type FsmStateSyncHandler, 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

@@ -29,12 +29,9 @@ var FsmBaseClass = class {
       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);
+    const list = this.handlers[type] || [];
+    const promises = list.map((handler) => handler(...args));
     for (const promise of promises) {
       try {
         await promise;
@@ -49,9 +46,11 @@ var FsmBaseClass = class {
 };
 function bindMethods(obj, ...methods) {
   const o = obj;
-  methods.forEach((methodName) => {
-    o[methodName] = o[methodName].bind(o);
-  });
+  for (const methodName of methods) {
+    const method = o[methodName];
+    if (typeof method !== "function") continue;
+    o[methodName] = method.bind(o);
+  }
   return obj;
 }
 
@@ -235,7 +234,7 @@ var FsmProcess = class extends FsmBaseClass {
   }
   _newState(parent, key, descriptor) {
     const state = new FsmState(this, parent, key, descriptor);
-    this._runHandlerSync("onStateCreate", state);
+    this._runHandler("onStateCreate", state);
     return state;
   }
   _getSubstate(parent, prevStateKey) {
@@ -272,12 +271,121 @@ var FsmProcess = class extends FsmBaseClass {
     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,
@@ -288,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.22.1",
+  "version": "0.23.1",
   "description": "HFSM Implementation",
   "keywords": [],
   "homepage": "https://github.com/statewalker/statewalker-fsm",
@@ -14,14 +14,17 @@
     "dist",
     "src"
   ],
+  "source": "./src/index.ts",
   "module": "./dist/index.js",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js",
-    "./utils": "./dist/utils/index.js",
-    "./*.ts": "./src/*.ts",
-    "./utils/*.ts": "./src/utils/*.ts"
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "devDependencies": {
     "@changesets/cli": "^2.27.7",
@@ -43,7 +46,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/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,3 +1,4 @@
-export * from "./handlers.ts";
 export * from "./printer.ts";
+export * from "./process.ts";
 export * from "./tracer.ts";
+export * from "./transitions.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;
+}

package/dist/utils/index.d.ts

@@ -1,23 +0,0 @@
-import { FsmState, FsmStateHandler, FsmProcess } from '../index.js';
-
-declare const KEY_HANDLERS = "handlers";
-declare function callStateHandlers(state: FsmState): void;
-declare function addSubstateHandlers(state: FsmState, handlers: Record<string, FsmStateHandler>): void;
-
-type Printer = (...args: any[]) => void;
-type PrinterConfig = {
-    prefix?: string;
-    print?: (...args: any[]) => 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 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 };

package/dist/utils/index.js

@@ -1,78 +0,0 @@
-// 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}" -->`);
-  });
-}
-export {
-  KEY_HANDLERS,
-  KEY_PRINTER,
-  addSubstateHandlers,
-  callStateHandlers,
-  getPrinter,
-  getProcessPrinter,
-  preparePrinter,
-  setPrinter,
-  setProcessPrinter,
-  setProcessTracer,
-  setStateTracer
-};