@statewalker/fsm 0.24.0 → 0.26.0

package/dist/index.d.ts

@@ -117,4 +117,9 @@ 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 };
+declare function newFsmProcess(config: FsmStateConfig, handler: (state: string, event: undefined | string) => void | Promise<void> | ((event: undefined | string) => void | Promise<void>) | Promise<(event: undefined | string) => void | Promise<void>>): [
+    dispatch: (event: string) => Promise<boolean>,
+    shutdown: () => Promise<void>
+];
+
+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, newFsmProcess, newProcess, preparePrinter, setPrinter, setProcessPrinter, setProcessTracer, setStateTracer };

package/dist/index.js

@@ -204,9 +204,9 @@ var FsmProcess = class extends FsmBaseClass {
       } finally {
         this.running = false;
       }
-      if (this.nextEvent !== void 0) {
-        await new Promise((r) => setImmediate(r));
-        return this.dispatch(this.nextEvent);
+      const nextEvent = this.nextEvent;
+      if (nextEvent !== void 0) {
+        return Promise.resolve().then(() => this.dispatch(nextEvent));
       }
     }
     return !(this.status & STATUS_FINISHED);
@@ -408,6 +408,31 @@ function getTransitionsFromDescriptor(descriptor, prevStateKey, index = {}) {
   }
   return result;
 }
+
+// src/newFsmProcess.ts
+function newFsmProcess(config, handler) {
+  let started = false;
+  let terminated = false;
+  const process = new FsmProcess(config);
+  process.onStateCreate((state) => {
+    started = true;
+    let cleanup;
+    state.onEnter(async () => {
+      cleanup = await handler(state.key, process.event);
+    });
+    state.onExit(async () => {
+      cleanup?.(process.event);
+    });
+  });
+  async function dispatch(event) {
+    return terminated || event !== void 0 ? process.dispatch(event) : false;
+  }
+  async function shutdown() {
+    await process.shutdown();
+    terminated = true;
+  }
+  return [dispatch, shutdown];
+}
 export {
   EVENT_ANY,
   EVENT_EMPTY,
@@ -430,6 +455,7 @@ export {
   getProcessPrinter,
   getStateTransitions,
   isStateTransitionEnabled,
+  newFsmProcess,
   newProcess,
   preparePrinter,
   setPrinter,

package/package.json

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

package/src/FsmProcess.ts

@@ -83,9 +83,9 @@ export class FsmProcess extends FsmBaseClass {
       } finally {
         this.running = false;
       }
-      if (this.nextEvent !== undefined) {
-        await new Promise((r) => setImmediate(r));
-        return this.dispatch(this.nextEvent);
+      const nextEvent = this.nextEvent;
+      if (nextEvent !== undefined) {
+        return Promise.resolve().then(() => this.dispatch(nextEvent));
       }
     }
     return !(this.status & STATUS_FINISHED);

package/src/index.ts

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

package/src/newFsmProcess.ts

@@ -0,0 +1,45 @@
+import { FsmProcess } from "./FsmProcess.js";
+import type { FsmStateConfig } from "./FsmStateConfig.js";
+import { isStateTransitionEnabled } from "./utils/transitions.js";
+
+export function newFsmProcess(
+  config: FsmStateConfig,
+  handler: (
+    state: string,
+    event: undefined | string,
+  ) =>
+    | void
+    | Promise<void>
+    | ((event: undefined | string) => void | Promise<void>)
+    | Promise<(event: undefined | string) => void | Promise<void>>,
+): [
+  dispatch: (event: string) => Promise<boolean>,
+  shutdown: () => Promise<void>,
+] {
+  let started = false;
+  let terminated = false;
+  const process = new FsmProcess(config);
+  process.onStateCreate((state) => {
+    started = true;
+    let cleanup: Awaited<ReturnType<typeof handler>> | undefined;
+    state.onEnter(async () => {
+      cleanup = await handler(state.key, process.event);
+    });
+    state.onExit(async () => {
+      cleanup?.(process.event);
+    });
+  });
+  async function dispatch(event: string): Promise<boolean> {
+    return terminated ||
+      (event !== undefined 
+        // && (!started || isStateTransitionEnabled(process, event))
+      )
+      ? process.dispatch(event)
+      : false;
+  }
+  async function shutdown(): Promise<void> {
+    await process.shutdown();
+    terminated = true;
+  }
+  return [dispatch, shutdown] as const;
+}

package/src/utils/newFsmStateHandler.ts

@@ -72,16 +72,12 @@ export type FsmStateModule<
     | ((...stack: FsmStateStore[]) => FsmStateContext)
     | (new (...stack: FsmStateStore[]) => FsmStateContext);
   // trigger?: (context: FsmStateContext) => AsyncGenerator<string>;
-  trigger?: (
-    context: FsmStateContext,
-    onEvent: (event: string) => void,
-  ) => void | (() => void);
+  trigger?: (context: FsmStateContext) => AsyncIterator<string>;
   handler?: (
     context: FsmStateContext,
   ) => void | (() => void) | Promise<void | (() => void)>;
 };
 
-
 export function newModuleContext<
   C = Record<string, unknown>,
   S = Record<string, unknown>,
@@ -103,8 +99,6 @@ 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/);
 }
 
@@ -127,6 +121,7 @@ export function newStateHandlers<
     FsmStateContext
   >(),
 ) {
+  const triggers = new Map<unknown, () => void>();
   return (state: FsmState) => {
     const stack: FsmStateStore[] = [];
     for (let s: FsmState | undefined = state.parent; !!s; s = s.parent) {
@@ -161,20 +156,35 @@ export function newStateHandlers<
         }
 
         // Initialize triggers
-        if (module.trigger) {
+        if (module.trigger && !triggers.has(module.trigger)) {
           const process = state.process;
-          // Set trigger
-          let notify = async (event: string) => {
-            if (event && isStateTransitionEnabled(process, event)) {
-              process.dispatch(event);
+          const iterator = module.trigger(stateContext);
+          let finalize: undefined | (() => void);
+          const end = new Promise<{ done: boolean; value?: string }>(
+            (r) => (finalize = () => r({ done: true })),
+          );
+          registrations.push(() => triggers.delete(module.trigger));
+          registrations.push(finalize);
+          registrations.push(() => iterator?.return?.(void 0));
+          (async () => {
+            try {
+              while (true) {
+                const { done, value: event } = await Promise.race([
+                  iterator.next(),
+                  end,
+                ]);
+                if (done) break;
+                if (event && isStateTransitionEnabled(process, event)) {
+                  process.dispatch(event);
+                }
+              }
+            } finally {
+              finalize?.();
             }
-          };
-          const cleanup = module.trigger(stateContext, notify);
-          registrations.push(() => {
-            notify = async () => {};
-            cleanup?.();
-          });
+          })();
         }
+
+        // Run actions associated with this event
         if (module.handler) {
           const cleanup = module.handler(stateContext);
           registrations.push(cleanup);