@statewalker/fsm 0.29.0 → 0.30.1

package/src/startFsmProcess copy 2.ts

@@ -1,74 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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 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) {
-              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;
-}

package/src/utils/newFsmStateHandler.ts

@@ -1,195 +0,0 @@
-import { FsmState } from "../FsmState";
-import { isStateTransitionEnabled } from "./transitions";
-
-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 | 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: FsmStateModule[] = [];
-    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 FsmStateModule<
-  FsmStateContext = Record<string, unknown>,
-  FsmStateStore = Record<string, unknown>,
-> = {
-  context?:
-    | ((...stack: FsmStateStore[]) => FsmStateContext)
-    | (new (...stack: FsmStateStore[]) => FsmStateContext);
-  // trigger?: (context: FsmStateContext) => AsyncGenerator<string>;
-  trigger?: (context: FsmStateContext) => AsyncIterator<string>;
-  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;
-  return value?.prototype?.constructor?.toString().match(/^class/);
-}
-
-export function newStateHandlers<
-  FsmStateContext = Record<string, unknown>,
-  FsmStateStore = Record<string, unknown>,
->(
-  loader: (
-    state: FsmState,
-  ) => Promise<FsmStateModule<FsmStateContext, FsmStateStore>[]>,
-  newContext: (state: FsmState, ...stack: FsmStateStore[]) => FsmStateStore = (
-    state,
-  ) =>
-    ({
-      state: state.key,
-      event: state.process.event,
-    }) as unknown as FsmStateStore,
-  contextCache: Map<unknown, FsmStateContext> = new Map<
-    unknown,
-    FsmStateContext
-  >(),
-) {
-  const triggers = new Map<unknown, () => void>();
-  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);
-
-    let registrations: (void | (() => void) | Promise<void | (() => void)>)[] =
-      [];
-    state.onExit(async () => {
-      for (const r of registrations) {
-        const registration = await r;
-        registration?.();
-      }
-    });
-    state.onEnter(async () => {
-      const modules = await loader(state);
-      if (!modules?.length) return;
-      for (const module of modules) {
-        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);
-          });
-        }
-
-        // Initialize triggers
-        if (module.trigger && !triggers.has(module.trigger)) {
-          const process = state.process;
-          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?.();
-            }
-          })();
-        }
-
-        // Run actions associated with this event
-        if (module.handler) {
-          const cleanup = module.handler(stateContext);
-          registrations.push(cleanup);
-        }
-      }
-    });
-  };
-}