@statewalker/fsm 0.26.0 → 0.28.0

package/dist/index.d.ts

@@ -117,9 +117,13 @@ 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 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>>): [
+type Module<C = unknown> = (context: C) => void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)>;
+declare function newFsmProcess<C>(context: C, config: FsmStateConfig, load: (state: string, event: undefined | string) => undefined | Module<C> | Module<C>[] | Promise<undefined | Module<C> | Module<C>[]>): [
     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 };
+type ModuleOrTrigger<C = unknown> = (context: C) => void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)> | AsyncGenerator<string, void, unknown> | Generator<string, void, unknown>;
+declare function startFsmProcess<C>(context: C, config: FsmStateConfig, load: (state: string, event: undefined | string) => undefined | ModuleOrTrigger<C> | ModuleOrTrigger<C>[] | Promise<undefined | ModuleOrTrigger<C> | ModuleOrTrigger<C>[]>, startEvent?: string): () => 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 Module, type ModuleOrTrigger, 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, startFsmProcess };

package/dist/index.js

@@ -410,22 +410,24 @@ function getTransitionsFromDescriptor(descriptor, prevStateKey, index = {}) {
 }
 
 // src/newFsmProcess.ts
-function newFsmProcess(config, handler) {
+function newFsmProcess(context, config, load) {
   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);
+      const modules = await load(state.key, process.event) ?? [];
+      for (const module of Array.isArray(modules) ? modules : [modules]) {
+        const handler = await module(context);
+        if (typeof handler === "function") {
+          state.onExit(handler);
+        }
+      }
     });
   });
   async function dispatch(event) {
-    return terminated || event !== void 0 ? process.dispatch(event) : false;
+    return terminated || event !== void 0 && (!started || isStateTransitionEnabled(process, event)) ? process.dispatch(event) : false;
   }
   async function shutdown() {
     await process.shutdown();
@@ -433,6 +435,48 @@ function newFsmProcess(config, handler) {
   }
   return [dispatch, shutdown];
 }
+
+// src/startFsmProcess.ts
+function startFsmProcess(context, config, load, startEvent = "") {
+  let started = false;
+  let terminated = false;
+  const process = new FsmProcess(config);
+  process.onStateCreate((state) => {
+    started = true;
+    state.onEnter(async () => {
+      const ModuleOrTriggers = await load(state.key, process.event) ?? [];
+      for (const ModuleOrTrigger of Array.isArray(ModuleOrTriggers) ? ModuleOrTriggers : [ModuleOrTriggers]) {
+        const result = await ModuleOrTrigger?.(context);
+        if (isGenerator(result)) {
+          state.onExit(() => {
+            result.return?.(void 0);
+          });
+          (async () => {
+            for await (const event of result) {
+              if (terminated) {
+                break;
+              }
+              if (event !== void 0 && isStateTransitionEnabled(process, event)) {
+                await process.dispatch(event);
+              }
+            }
+          })();
+        } else if (typeof result === "function") {
+          state.onExit(result);
+        }
+      }
+    });
+  });
+  function isGenerator(value) {
+    return typeof value === "object" && value !== null && "next" in value && typeof value.next === "function";
+  }
+  async function shutdown() {
+    await process.shutdown();
+    terminated = true;
+  }
+  process.dispatch(startEvent);
+  return shutdown;
+}
 export {
   EVENT_ANY,
   EVENT_EMPTY,
@@ -461,5 +505,6 @@ export {
   setPrinter,
   setProcessPrinter,
   setProcessTracer,
-  setStateTracer
+  setStateTracer,
+  startFsmProcess
 };

package/package.json

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

package/src/index.ts

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

package/src/newFsmProcess.ts

@@ -2,16 +2,24 @@ import { FsmProcess } from "./FsmProcess.js";
 import type { FsmStateConfig } from "./FsmStateConfig.js";
 import { isStateTransitionEnabled } from "./utils/transitions.js";
 
-export function newFsmProcess(
+export type Module<C = unknown> = (
+  context: C,
+) =>
+  | void
+  | (() => void | Promise<void>)
+  | Promise<void | (() => void | Promise<void>)>;
+
+export function newFsmProcess<C>(
+  context: C,
   config: FsmStateConfig,
-  handler: (
+  load: (
     state: string,
     event: undefined | string,
   ) =>
-    | void
-    | Promise<void>
-    | ((event: undefined | string) => void | Promise<void>)
-    | Promise<(event: undefined | string) => void | Promise<void>>,
+    | undefined
+    | Module<C>
+    | Module<C>[]
+    | Promise<undefined | Module<C> | Module<C>[]>,
 ): [
   dispatch: (event: string) => Promise<boolean>,
   shutdown: () => Promise<void>,
@@ -21,19 +29,20 @@ export function newFsmProcess(
   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);
+      const modules = (await load(state.key, process.event)) ?? [];
+      for (const module of Array.isArray(modules) ? modules : [modules]) {
+        const handler = await module(context);
+        if (typeof handler === "function") {
+          state.onExit(handler);
+        }
+      }
     });
   });
   async function dispatch(event: string): Promise<boolean> {
     return terminated ||
-      (event !== undefined 
-        // && (!started || isStateTransitionEnabled(process, event))
-      )
+      (event !== undefined &&
+        (!started || isStateTransitionEnabled(process, event)))
       ? process.dispatch(event)
       : false;
   }

package/src/startFsmProcess copy 2.ts

@@ -0,0 +1,74 @@
+import type { FsmStateConfig } from "./FsmStateConfig.js";
+import { type Module, newFsmProcess } from "./newFsmProcess.js";
+
+export type ModuleOrTrigger<C = unknown> =
+  | Module<C>
+  | AsyncGenerator<string, void, unknown>
+  | Generator<string, void, unknown>;
+export function startFsmProcess<C>(
+  context: C,
+  config: FsmStateConfig,
+  load: (
+    state: string,
+    event: undefined | string,
+  ) =>
+    | undefined
+    | ModuleOrTrigger<C>
+    | ModuleOrTrigger<C>[]
+    | Promise<undefined | ModuleOrTrigger<C> | ModuleOrTrigger<C>[]>,
+  startEvent = "",
+) {
+  function validateModule(
+    module: ModuleOrTrigger<C> | undefined,
+  ): Module<C> | undefined {
+    if (module === undefined) {
+      return undefined;
+    }
+    if (isGeneratorFunction<string, [C]>(module)) {
+      const generator = module as (context: C) => AsyncGenerator<string>;
+      return async (context: C) => {
+        const iterator = generator(context);
+        console.warn('INIT', module, iterator);
+        (async () => {
+          for await (const event of iterator) {
+            await dispatch(event);
+          }
+        })();
+        return () => {
+          console.warn('DONE', module, iterator);
+          iterator.return?.(void 0);
+        };
+      };
+    }
+    return module as Module<C>;
+  }
+
+  const [dispatch, terminate] = newFsmProcess(
+    context,
+    config,
+    async (state, event) => {
+      const modules = (await load(state, event)) ?? [];
+      const modulesList = Array.isArray(modules) ? modules : [modules];
+      return modulesList
+        .map(validateModule)
+        .flat()
+        .filter(Boolean) as Module<C>[];
+    },
+  );
+  dispatch(startEvent);
+  return terminate;
+}
+
+const AsyncGeneratorFunction = async function* () {}.constructor;
+const GeneratorFunction = function* () {}.constructor;
+
+function isGeneratorFunction<T, P extends unknown[] = []>(
+  value: unknown,
+): value is
+  | ((...args: P) => AsyncGenerator<T>)
+  | ((...args: P) => Generator<T>) {
+  return (
+    value instanceof AsyncGeneratorFunction ||
+    value instanceof GeneratorFunction
+  );
+}

package/src/startFsmProcess copy.ts

@@ -0,0 +1,77 @@
+import { FsmProcess } from "./FsmProcess.js";
+import type { FsmStateConfig } from "./FsmStateConfig.js";
+import { isStateTransitionEnabled } from "./utils/transitions.js";
+
+export type Module<C = unknown> = (
+  context: C,
+) =>
+  | void
+  | (() => void | Promise<void>)
+  | Promise<void | (() => void | Promise<void>)>
+  | AsyncGenerator<string, void, unknown>
+  | Generator<string, void, unknown>;
+
+export function startFsmProcess<C>(
+  context: C,
+  config: FsmStateConfig,
+  load: (
+    state: string,
+    event: undefined | string,
+  ) =>
+    | undefined
+    | Module<C>
+    | Module<C>[]
+    | Promise<undefined | Module<C> | Module<C>[]>,
+  startEvent = ""
+): () => Promise<void> {
+  let started = false;
+  let terminated = false;
+  const process = new FsmProcess(config);
+  process.onStateCreate((state) => {
+    started = true;
+    state.onEnter(async () => {
+      const modules = (await load(state.key, process.event)) ?? [];
+      for (const module of Array.isArray(modules) ? modules : [modules]) {
+        const result = await module(context);
+        if (isGenerator(result)) {
+          state.onExit(() => {
+            result.return?.(void 0);
+          });
+          (async () => {
+            for await (const event of result) {
+              await dispatch(event);
+            }
+          })();
+        } else if (typeof result === "function") {
+          state.onExit(result);
+        }
+      }
+    });
+  });
+
+  function isGenerator(
+    value: unknown,
+  ): value is
+    | Generator<string, void, unknown>
+    | AsyncGenerator<string, void, unknown> {
+    return (
+      typeof value === "object" &&
+      value !== null &&
+      "next" in value &&
+      typeof (value as Generator<string, void, unknown>).next === "function"
+    );
+  }
+  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;
+  }
+  dispatch(startEvent);
+  return shutdown;
+}

package/src/startFsmProcess.ts

@@ -0,0 +1,78 @@
+import { FsmProcess } from "./FsmProcess.js";
+import type { FsmStateConfig } from "./FsmStateConfig.js";
+import { isStateTransitionEnabled } from "./utils/transitions.js";
+
+export type ModuleOrTrigger<C = unknown> = (
+  context: C,
+) =>
+  | void
+  | (() => void | Promise<void>)
+  | Promise<void | (() => void | Promise<void>)>
+  | AsyncGenerator<string, void, unknown>
+  | Generator<string, void, unknown>;
+
+export function startFsmProcess<C>(
+  context: C,
+  config: FsmStateConfig,
+  load: (
+    state: string,
+    event: undefined | string,
+  ) =>
+    | undefined
+    | ModuleOrTrigger<C>
+    | ModuleOrTrigger<C>[]
+    | Promise<undefined | ModuleOrTrigger<C> | ModuleOrTrigger<C>[]>,
+  startEvent = "",
+): () => Promise<void> {
+  let started = false;
+  let terminated = false;
+  const process = new FsmProcess(config);
+  process.onStateCreate((state) => {
+    started = true;
+    state.onEnter(async () => {
+      const ModuleOrTriggers = (await load(state.key, process.event)) ?? [];
+      for (const ModuleOrTrigger of Array.isArray(ModuleOrTriggers) ? ModuleOrTriggers : [ModuleOrTriggers]) {
+        const result = await ModuleOrTrigger?.(context);
+        if (isGenerator(result)) {
+          state.onExit(() => {
+            result.return?.(void 0);
+          });
+          (async () => {
+            for await (const event of result) {
+              if (terminated) {
+                break;
+              }
+              if (
+                event !== undefined &&
+                isStateTransitionEnabled(process, event)
+              ) {
+                await process.dispatch(event);
+              }
+            }
+          })();
+        } else if (typeof result === "function") {
+          state.onExit(result);
+        }
+      }
+    });
+  });
+
+  function isGenerator(
+    value: unknown,
+  ): value is
+    | Generator<string, void, unknown>
+    | AsyncGenerator<string, void, unknown> {
+    return (
+      typeof value === "object" &&
+      value !== null &&
+      "next" in value &&
+      typeof (value as Generator<string, void, unknown>).next === "function"
+    );
+  }
+  async function shutdown(): Promise<void> {
+    await process.shutdown();
+    terminated = true;
+  } 
+  process.dispatch(startEvent);
+  return shutdown;
+}