@statewalker/fsm 0.23.0 → 0.24.0

package/src/utils/newFsmStateHandler.ts

@@ -1,4 +1,5 @@
 import { FsmState } from "../FsmState";
+import { isStateTransitionEnabled } from "./transitions";
 
 export function newModuleLoader<T>(baseUrl: string) {
   const cache: Record<string, Promise<T>> = {};
@@ -23,15 +24,15 @@ export async function newHandlerLoader(
   baseUrl: string,
   loader: (
     path: string,
-  ) => Promise<undefined | FsmStateHandler> = newModuleLoader(baseUrl),
-): Promise<(state: FsmState) => Promise<FsmStateHandler[]>> {
+  ) => Promise<undefined | FsmStateModule> = newModuleLoader(baseUrl),
+): Promise<(state: FsmState) => Promise<FsmStateModule[]>> {
   return async (state: FsmState) => {
     const stack: string[] = [];
     for (let s: FsmState | undefined = state; s; s = s.parent) {
       stack.unshift(s.key);
     }
 
-    const handlers: FsmStateHandler[] = [];
+    const handlers: FsmStateModule[] = [];
     let topName: undefined | string;
     while (stack.length > 0) {
       const lastSegment = stack.pop();
@@ -63,24 +64,57 @@ export async function newHandlerLoader(
 - 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>,
+export type FsmStateModule<
+  FsmStateContext = Record<string, unknown>,
   FsmStateStore = Record<string, unknown>,
 > = {
-  context?: (...stack: FsmStateStore[]) => FsmStateContext;
+  context?:
+    | ((...stack: FsmStateStore[]) => FsmStateContext)
+    | (new (...stack: FsmStateStore[]) => FsmStateContext);
+  // trigger?: (context: FsmStateContext) => AsyncGenerator<string>;
   trigger?: (
     context: FsmStateContext,
-    listener: (event: string) => void,
+    onEvent: (event: string) => void,
   ) => void | (() => void);
-  default?: (context: FsmStateContext) => void | (() => void);
-  handler?: (context: FsmStateContext) => void | (() => void);
+  handler?: (
+    context: FsmStateContext,
+  ) => void | (() => void) | Promise<void | (() => void)>;
 };
 
+
+export function newModuleContext<
+  C = Record<string, unknown>,
+  S = Record<string, unknown>,
+>(module: FsmStateModule<C, S>, ...stack: S[]): C {
+  if (isClass<S[], C>(module.context)) {
+    return new module.context(...stack) as unknown as C;
+  } else if (isFunction<S[], C>(module.context)) {
+    return module.context(...stack);
+  } else {
+    return stack[0] as unknown as C;
+  }
+}
+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;
+  // console.log('============')
+  // console.log('???', value, value?.prototype, value?.prototype?.constructor);
+  return value?.prototype?.constructor?.toString().match(/^class/);
+}
+
 export function newStateHandlers<
-  FsmStateContext extends Record<string, unknown> = Record<string, unknown>,
+  FsmStateContext = Record<string, unknown>,
   FsmStateStore = Record<string, unknown>,
 >(
-  loader: (state: FsmState) => Promise<FsmStateHandler[]>,
+  loader: (
+    state: FsmState,
+  ) => Promise<FsmStateModule<FsmStateContext, FsmStateStore>[]>,
   newContext: (state: FsmState, ...stack: FsmStateStore[]) => FsmStateStore = (
     state,
   ) =>
@@ -88,6 +122,10 @@ export function newStateHandlers<
       state: state.key,
       event: state.process.event,
     }) as unknown as FsmStateStore,
+  contextCache: Map<unknown, FsmStateContext> = new Map<
+    unknown,
+    FsmStateContext
+  >(),
 ) {
   return (state: FsmState) => {
     const stack: FsmStateStore[] = [];
@@ -99,15 +137,11 @@ export function newStateHandlers<
     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) {
+    let registrations: (void | (() => void) | Promise<void | (() => void)>)[] =
+      [];
+    state.onExit(async () => {
+      for (const r of registrations) {
+        const registration = await r;
         registration?.();
       }
     });
@@ -115,40 +149,36 @@ export function newStateHandlers<
       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 contextKey: unknown = module.context;
+        // Create state context or get it from the local cache
+        let stateContext = contextCache.get(contextKey);
+        if (!stateContext) {
+          stateContext = newModuleContext(module, ...stack);
+          contextCache.set(contextKey, stateContext);
+          registrations.push(() => {
+            contextCache.delete(contextKey);
+          });
+        }
 
-        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/);
+        // Initialize triggers
+        if (module.trigger) {
+          const process = state.process;
+          // Set trigger
+          let notify = async (event: string) => {
+            if (event && isStateTransitionEnabled(process, event)) {
+              process.dispatch(event);
+            }
+          };
+          const cleanup = module.trigger(stateContext, notify);
+          registrations.push(() => {
+            notify = async () => {};
+            cleanup?.();
+          });
+        }
+        if (module.handler) {
+          const cleanup = module.handler(stateContext);
+          registrations.push(cleanup);
+        }
       }
     });
   };

package/src/utils/tracer.ts

@@ -13,8 +13,10 @@ export function setStateTracer(state: FsmState, print?: Printer) {
     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}" -->`);
+  state.onExit(async () => {
+    await Promise.resolve().then(async () => {
+      const printLine = print || getPrinter(state);
+      printLine(`</${state.key}> <!-- event="${state.process.event}" -->`);
+    });
   });
 }

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 };