@statewalker/fsm 0.36.0 → 0.37.0

package/src/orchestrator/start-node-processes.ts

@@ -1,19 +0,0 @@
-import { resolveModulesPaths } from "./resolve-module-refs.ts";
-import { startProcesses } from "./start-processes.ts";
-export async function startNodeProcesses(modules?: string[]): Promise<void> {
-  try {
-    if (!modules) {
-      modules = process.argv.slice(2);
-    }
-    const terminate = await startProcesses({
-      modules: resolveModulesPaths(`file://${process.cwd()}/`, ...modules),
-      onExit: () => process.exit(0),
-    });
-    process.on("SIGINT", terminate);
-    process.on("SIGTERM", terminate);
-    process.stdin.resume();
-  } catch (err) {
-    console.error("Fatal error:", err);
-    process.exit(1);
-  }
-}

package/src/orchestrator/start-processes.ts

@@ -1,32 +0,0 @@
-import { launcher } from "./launcher.ts";
-
-export async function startProcesses({
-  onExit,
-  modules,
-  init,
-}: {
-  onExit?: () => Promise<void> | void;
-  modules: unknown[];
-  init?: (
-    context: Record<string, unknown>,
-  ) => Promise<Record<string, unknown>> | Record<string, unknown>;
-}) {
-  const modulesList: unknown[] = [];
-  for (const module of modules) {
-    modulesList.push(
-      typeof module === "string" || module instanceof URL
-        ? await import(String(module))
-        : module,
-    );
-  }
-  return await launcher({
-    init,
-    processes: [
-      ...modulesList,
-      // This function is called on exit at the end of the process chain
-      function Exit() {
-        return onExit;
-      },
-    ],
-  });
-}

package/src/orchestrator/types.ts

@@ -1,34 +0,0 @@
-export type StageHandler<C = Record<string, unknown>> = (
-  context: C,
-) =>
-  | void
-  | (() => void | Promise<void>)
-  | Promise<void | (() => void | Promise<void>)>
-  | AsyncGenerator<string, void, unknown>
-  | Generator<string, void, unknown>;
-
-export function toStageHandlers<C>(
-  value: unknown,
-  accept: (key: string, value: unknown) => boolean,
-): StageHandler<C>[] {
-  return visit(value);
-
-  function visit(val: unknown): StageHandler<C>[] {
-    if (!val) {
-      return [];
-    }
-    if (typeof val === "function") {
-      return [val] as StageHandler<C>[];
-    }
-    if (typeof val !== "object") {
-      return [];
-    }
-    if (Array.isArray(val)) {
-      return val.flatMap(visit);
-    }
-    const modulesIndex = val as Record<string, unknown>;
-    return Object.entries(modulesIndex).flatMap(([key, value]) => {
-      return accept(key, value) ? visit(value) : [];
-    });
-  }
-}

package/src/utils/handlers.ts

@@ -1,35 +0,0 @@
-import type { FsmState, FsmStateHandler } from "../core/fsm-state.ts";
-
-export const KEY_HANDLERS = "handlers";
-
-export function callStateHandlers(state: FsmState) {
-  const key = state.key;
-  for (
-    let parent: FsmState | undefined = state.parent;
-    parent;
-    parent = parent?.parent
-  ) {
-    const handlers =
-      parent.getData<Record<string, FsmStateHandler[]>>(KEY_HANDLERS)?.[key];
-    handlers?.forEach((handler) => {
-      handler(state);
-    });
-  }
-}
-
-export function addSubstateHandlers(
-  state: FsmState,
-  handlers: Record<string, FsmStateHandler>,
-) {
-  const oldIndex =
-    state.getData<Record<string, FsmStateHandler[]>>(KEY_HANDLERS);
-  const index = oldIndex ? { ...oldIndex } : {};
-  for (const [key, handler] of Object.entries(handlers)) {
-    let list = index[key];
-    if (!list) {
-      list = index[key] = [];
-    }
-    list.push(handler);
-  }
-  state.setData(KEY_HANDLERS, index);
-}

package/src/utils/process.ts

@@ -1,26 +0,0 @@
-import { FsmProcess } from "../core/fsm-process.ts";
-import type { FsmStateConfig } from "../core/fsm-state-config.ts";
-import { setProcessPrinter } from "./printer.ts";
-import { setProcessTracer } from "./tracer.ts";
-
-export function newProcess(
-  config: FsmStateConfig,
-  {
-    prefix,
-    print,
-    lineNumbers = true,
-  }: {
-    prefix?: string;
-    print?: (...args: any[]) => void;
-    lineNumbers?: boolean;
-  },
-): FsmProcess {
-  const process = new FsmProcess(config);
-  setProcessPrinter(process, {
-    prefix,
-    print,
-    lineNumbers,
-  });
-  setProcessTracer(process);
-  return process;
-}

package/src/utils/transitions.ts

@@ -1,56 +0,0 @@
-import type { FsmProcess } from "../core/fsm-process.ts";
-import type { FsmState } from "../core/fsm-state.ts";
-import type { FsmStateDescriptor } from "../core/fsm-state-descriptor.ts";
-
-export function isStateTransitionEnabled(process: FsmProcess, event: string) {
-  const transitions = getStateTransitions(process.state);
-  let active = false;
-  for (const [from, ev, to] of transitions) {
-    if (ev === event) {
-      active = true;
-      break;
-    }
-  }
-  return active;
-}
-
-export function getStateTransitions(
-  state?: FsmState,
-): [from: string, event: string, to: string][] {
-  const result: [from: string, event: string, to: string][] = [];
-  const index = {};
-  if (state) {
-    let prevStateKey = state.key;
-    for (let parent = state?.parent; parent; parent = parent.parent) {
-      if (!parent.descriptor) continue;
-      result.push(
-        ...getTransitionsFromDescriptor(parent.descriptor, prevStateKey, index),
-      );
-      prevStateKey = parent.key;
-    }
-  }
-  return result.reverse();
-}
-
-function getTransitionsFromDescriptor(
-  descriptor: FsmStateDescriptor,
-  prevStateKey: string,
-  index: Record<string, boolean> = {},
-) {
-  const result: [from: string, event: string, to: string][] = [];
-  const prevStateKeys = [prevStateKey, "*"];
-  for (const prevKey of prevStateKeys) {
-    const targets: undefined | Record<string, string> =
-      descriptor.transitions[prevKey];
-    if (targets) {
-      for (const [event, target] of Object.entries(targets)) {
-        if (index[event]) continue;
-        if (target) {
-          index[event] = true;
-        }
-        result.push([prevStateKey, event, target]);
-      }
-    }
-  }
-  return result;
-}