@statewalker/fsm 0.23.1 → 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;

package/dist/index.js

@@ -29,12 +29,23 @@ var FsmBaseClass = class {
       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] || [];
-    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);
       }
@@ -158,6 +169,8 @@ 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;
@@ -171,18 +184,32 @@ var FsmProcess = class extends FsmBaseClass {
       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);
+  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._update()) return false;
-      if (this.status & STATUS_ENTER) {
-        await this.state?._runHandler("onEnter", this.state);
+      if (this.nextEvent !== void 0) {
+        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) {
     const dumpState = async (state) => {
@@ -234,7 +261,7 @@ var FsmProcess = class extends FsmBaseClass {
   }
   _newState(parent, key, descriptor) {
     const state = new FsmState(this, parent, key, descriptor);
-    this._runHandler("onStateCreate", state);
+    this._runHandlerParallel("onStateCreate", state);
     return state;
   }
   _getSubstate(parent, prevStateKey) {
@@ -313,9 +340,11 @@ function setStateTracer(state, print) {
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statewalker/fsm",
-  "version": "0.23.1",
+  "version": "0.24.0",
   "description": "HFSM Implementation",
   "keywords": [],
   "homepage": "https://github.com/statewalker/statewalker-fsm",

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/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}" -->`);
+    });
   });
 }