@statewalker/fsm 0.36.0 → 0.37.0

package/dist/index.d.ts

@@ -1,335 +0,0 @@
-type Handler<P extends unknown[] = unknown[], R = unknown> = (...args: P) => R;
-declare class FsmBaseClass {
-    handlers: Record<string, Handler[]>;
-    data: Record<string, unknown>;
-    constructor();
-    setData<T>(key: string, value: T): this;
-    getData<T>(key: string): T | undefined;
-    protected _addHandler<T>(type: string, handler: T, direct?: boolean): () => void;
-    protected _removeHandler<T>(type: string, handler: T): void;
-    _runHandlerParallel(type: string, ...args: unknown[]): Promise<void>;
-    _runHandler(type: string, ...args: unknown[]): Promise<void>;
-    _handleError(error: Error | unknown): Promise<void>;
-}
-
-declare const STATE_ANY = "*";
-declare const STATE_INITIAL = "";
-declare const STATE_FINAL = "";
-declare const EVENT_ANY = "*";
-declare const EVENT_EMPTY = "";
-type FsmStateKey = string;
-type FsmEventKey = string;
-type FsmStateConfig = {
-    key: FsmStateKey;
-    transitions?: [from: FsmStateKey, event: FsmEventKey, to: FsmStateKey][];
-    states?: FsmStateConfig[];
-} & Record<string, unknown>;
-
-declare class FsmStateDescriptor {
-    transitions: Record<string, Record<string, string>>;
-    states: Record<string, FsmStateDescriptor>;
-    static build(config: FsmStateConfig): FsmStateDescriptor;
-    getTargetStateKey(stateKey: string, eventKey: string): string;
-}
-
-type FsmStateDump = Record<string, unknown> & {
-    key: string;
-    data: Record<string, unknown>;
-};
-type FsmStateHandler = (state: FsmState, ...args: unknown[]) => void | Promise<void>;
-type FsmStateDumpHandler = (state: FsmState, dump: FsmStateDump) => void | Promise<void>;
-type FsmStateErrorHandler = (state: FsmState, error: unknown) => void | Promise<void>;
-declare class FsmState extends FsmBaseClass {
-    process: FsmProcess;
-    key: string;
-    parent?: FsmState;
-    descriptor?: FsmStateDescriptor;
-    constructor(process: FsmProcess, parent: FsmState | undefined, key: string, descriptor?: FsmStateDescriptor);
-    onEnter(handler: FsmStateHandler): () => void;
-    onExit(handler: FsmStateHandler): () => void;
-    onStateError(handler: FsmStateErrorHandler): () => void;
-    dump(handler: FsmStateDumpHandler): () => void;
-    restore(handler: FsmStateDumpHandler): () => void;
-    getData<T>(key: string, recursive?: boolean): T | undefined;
-    useData<T>(key: string): (((recursive?: boolean) => T | undefined) | ((value: T) => this))[];
-    _handleError(error: Error | unknown): Promise<void>;
-}
-
-declare const STATUS_NONE = 0;
-declare const STATUS_FIRST = 1;
-declare const STATUS_NEXT = 2;
-declare const STATUS_LEAF = 4;
-declare const STATUS_LAST = 8;
-declare const STATUS_FINISHED = 16;
-declare const STATUS_ENTER: number;
-declare const STATUS_EXIT: number;
-type FsmProcessHandler = (process: FsmProcess, ...args: unknown[]) => void | Promise<void>;
-type FsmProcessDump = Record<string, unknown> & {
-    status: number;
-    event?: string;
-    stack: FsmStateDump[];
-};
-type FsmProcessDumpHandler = (process: FsmProcess, dump: FsmProcessDump) => void | Promise<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): Promise<boolean>;
-    dump(...args: unknown[]): Promise<FsmProcessDump>;
-    restore(dump: FsmProcessDump, ...args: unknown[]): Promise<this>;
-    onStateCreate(handler: FsmStateHandler): () => void;
-    onStateError(handler: (state: FsmState, error: unknown) => void | Promise<void>): () => void;
-    _handleStateError(state: FsmState, error: Error | unknown): Promise<void>;
-    _newState(parent: FsmState | undefined, key: string, descriptor: FsmStateDescriptor | undefined): FsmState;
-    _getSubstate(parent: FsmState | undefined, prevStateKey: string | undefined): FsmState | undefined;
-    _newSubstate(parent: FsmState | undefined, toState: string): FsmState;
-    _update(): boolean;
-}
-
-type Module<C = unknown> = (context: C) => void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)> | Generator<string> | AsyncGenerator<string>;
-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>
-];
-
-/**
- * Key used to bind the dispatch function to the process context.
- * The dispatch function allows triggering state transitions by dispatching events.
- *
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * // Initialize the FSM process using `startFsmProcess`
- * const dispatch = context["fsm:dispatch"] as (event: string) => Promise<void>;
- * await dispatch("someEvent");
- */
-declare const KEY_DISPATCH: "fsm:dispatch";
-/**
- * Key used to bind the terminate function to the process context.
- * The terminate function is used to gracefully shut down the FSM process.
- * It returns a Promise that resolves when the process has been fully terminated.
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * // Initialize the FSM process using `startFsmProcess`
- * const terminate = context["fsm:terminate"] as () => Promise<void>;
- * await terminate();
- * ```
- */
-declare const KEY_TERMINATE: "fsm:terminate";
-/**
- * Key used to bind the current stack of active states to the process context.
- * This provides a snapshot of the states the FSM process has entered.
- * It is represented as an array of strings -- state keys.
- *
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * // Initialize the FSM process using `startFsmProcess`
- * const states = context["fsm:states"] as string[];
- * console.log("Current active states:", states);
- * ```
- */
-declare const KEY_STATES: "fsm:states";
-/**
- * Key used to bind the current event being processed to the process context.
- * This represents the event that triggered the current state transition.
- * It is represented as a string.
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * // Initialize the FSM process using `startFsmProcess`
- * const event = context["fsm:event"] as string;
- * console.log("Current event:", event);
- * ```
- */
-declare const KEY_EVENT: "fsm:event";
-/**
- * Key used to register a new FSM process configuration in the process context.
- * This key is associated with a function that allows adding new FSM configurations.
- * The function takes a process name and its configuration, and returns a cleanup function
- * to remove the registered configuration.
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * initProcessManager(context); // Initialize the process manager in the context
- * ...
- * type StateConfig = { key: string; transitions?: string[][]; states?: StateConfig[] };
- * const registerConfig = context["fsm:sys:registerConfig"] as (name: string, config: StateConfig) => () => void;
- * const unregister = registerConfig("myProcess", { key: "Main", transitions: [...] });
- * // To unregister the configuration later
- * unregister();
- * ```
- */
-declare const KEY_REGISTER_CONFIG: "fsm:sys:registerConfig";
-/**
- * Key used to register state and event handlers for FSM processes in the process context.
- * This key is associated with a function that allows adding handler modules for a specific process.
- * The function takes a process name and a variable number of handler modules, returning a cleanup function
- * to remove the registered handlers.
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * initProcessManager(context); // Initialize the process manager in the context
- * ...
- * const registerHandlers = context["fsm:sys:registerHandlers"] as (name: string, ...modules: unknown[]) => () => void;
- * const handlerModule1 = {
- *   Main: async (context) => { ... },
- *   SomeState: async (context) => { ... },
- * }
- * // Views layer can be defined in the same or separate modules
- * const handlerModule3 = {
- *  MainView: async (context) => { ... },
- *  SomeStateView: async (context) => { ... },
- * }
- * // A common handler function to call for all states
- * const handlerModule2 = (context) => { ... };
- * const unregister = registerHandlers(
- *  "myProcess",
- *  handlerModule1,
- *  handlerModule2,
- *  handlerModule3
- * );
- * // To unregister the handlers later
- * unregister();
- * ```
- */
-declare const KEY_REGISTER_HANDLERS: "fsm:sys:registerHandlers";
-/**
- * Key used to launch an FSM process in the process context.
- * This key is associated with a function that initiates the FSM process based on its name and context.
- * The function takes the process name and context, returning either nothing, a cleanup function,
- * or a Promise that resolves to either nothing or a cleanup function.
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * initProcessManager(context); // Initialize the process manager in the context
- * // Register process configurations and handlers as needed
- *
- * const launchProcess = context["fsm:sys:launch"] as (name: string, context: Record<string, unknown>) => () => Promise<void>;
- * const terminate = await launchProcess("myProcess", context);
- * // To terminate the process later
- * terminate?.();
- * ```
- */
-declare const KEY_LAUNCH_PROCESS: "fsm:sys:launch";
-
-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>;
-declare function toStageHandlers<C>(value: unknown, accept: (key: string, value: unknown) => boolean): StageHandler<C>[];
-
-type ProcessConfig = {
-    name: string;
-    config?: FsmStateConfig;
-} & ({
-    handler?: StageHandler;
-} | {
-    handlers?: StageHandler | (StageHandler | {
-        [state: string]: StageHandler | StageHandler[];
-    })[];
-} | {
-    default?: StageHandler | (StageHandler | {
-        [state: string]: StageHandler | StageHandler[];
-    })[];
-});
-declare function launcher(options: unknown): Promise<() => Promise<void>>;
-
-interface IProcessConfigManager {
-    getProcessConfig(processName: string): FsmStateConfig;
-    getHandlersLoader<C = unknown>(processName: string): (state: string, event: undefined | string) => StageHandler<C>[];
-    registerConfig(name: string, config: FsmStateConfig): () => void;
-    registerHandlers(name: string, ...modules: unknown[]): () => void;
-}
-declare class ProcessConfigManager implements IProcessConfigManager {
-    protected configs: Record<string, FsmStateConfig>;
-    protected handlers: Record<string, unknown[]>;
-    getProcessConfig(processName: string): FsmStateConfig;
-    getHandlersLoader<C = unknown>(processName: string): (state: string, event: undefined | string) => StageHandler<C>[];
-    registerConfig(name: string, config: FsmStateConfig): () => void;
-    registerHandlers(name: string, ...modules: unknown[]): () => void;
-}
-
-/**
- * Resolve module paths relative to a base URL.
- * This is useful for converting relative paths to absolute URLs.
- *
- * @param baseUrl - The base URL to resolve against.
- * @param refs - An array of module references (relative or absolute).
- * @returns An array of resolved absolute module URLs as strings.
- * @example
- * ```ts
- * const urls = resolveModulesUrls(
- *  'file:///home/user/project/', // base URL
- *  'https://example.com/js/my-module.js', // absolute URL
- *  './module1.js', // relative path
- *  '../module2.js' // relative path
- * );
- * console.log(urls);
- * // Output: [
- * //  'https://example.com/js/my-module.js',
- * //  'file:///home/user/project/module1.js',
- * //  'file:///home/user/module2.js'
- * // ] *
- * ```
- */
-declare function resolveModulesUrls(baseUrl: URL | string, ...refs: (URL | string)[]): string[];
-/**
- * Resolves module paths relative to a base URL.
- * This is useful for converting relative paths to absolute file system paths.
- * @param baseUrl - The base URL to resolve against
- * @param refs - An array of module references (relative or absolute)
- * @returns - An array of resolved absolute module paths as strings
- * @example
- * ```ts
- * const paths = resolveModulesPaths('file:///home/user/project/', './module1.js', '../module2.js');
- * console.log(paths);
- * // Output: [
- * //   '/home/user/project/module1.js',
- * //   '/home/user/module2.js'
- * // ]
- * ```
- */
-declare function resolveModulesPaths(baseUrl: URL | string, ...refs: (URL | string)[]): string[];
-
-declare function startNodeProcesses(modules?: string[]): Promise<void>;
-
-declare function startFsmProcess<C = unknown>(context: C, config: FsmStateConfig, load: (state: string, event: undefined | string) => StageHandler<C>[] | Promise<StageHandler<C>[]>, startEvent?: string): Promise<() => Promise<void>>;
-
-declare function startProcesses({ onExit, modules, init, }: {
-    onExit?: () => Promise<void> | void;
-    modules: unknown[];
-    init?: (context: Record<string, unknown>) => Promise<Record<string, unknown>> | Record<string, unknown>;
-}): Promise<() => Promise<void>>;
-
-type Printer = (...args: unknown[]) => void;
-type PrinterConfig = {
-    prefix?: string;
-    print?: (...args: unknown[]) => void;
-    lineNumbers?: boolean;
-};
-declare const KEY_PRINTER = "printer";
-declare function preparePrinter(process: FsmProcess, { prefix, print, lineNumbers }: PrinterConfig): Printer;
-declare function setPrinter(state: FsmState, config?: PrinterConfig): void;
-declare function setProcessPrinter(process: FsmProcess, config?: PrinterConfig): void;
-declare function getProcessPrinter(process: FsmProcess): Printer;
-declare function getPrinter(state: FsmState): Printer;
-
-declare function newProcess(config: FsmStateConfig, { prefix, print, lineNumbers, }: {
-    prefix?: string;
-    print?: (...args: any[]) => void;
-    lineNumbers?: boolean;
-}): FsmProcess;
-
-declare function setProcessTracer(process: FsmProcess, print?: Printer): () => void;
-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, type IProcessConfigManager, KEY_DISPATCH, KEY_EVENT, KEY_LAUNCH_PROCESS, KEY_PRINTER, KEY_REGISTER_CONFIG, KEY_REGISTER_HANDLERS, KEY_STATES, KEY_TERMINATE, type Module, type Printer, type PrinterConfig, type ProcessConfig, ProcessConfigManager, STATE_ANY, STATE_FINAL, STATE_INITIAL, STATUS_ENTER, STATUS_EXIT, STATUS_FINISHED, STATUS_FIRST, STATUS_LAST, STATUS_LEAF, STATUS_NEXT, STATUS_NONE, type StageHandler, startNodeProcesses as default, getPrinter, getProcessPrinter, getStateTransitions, isStateTransitionEnabled, launcher, newFsmProcess, newProcess, preparePrinter, resolveModulesPaths, resolveModulesUrls, setPrinter, setProcessPrinter, setProcessTracer, setStateTracer, startFsmProcess, startNodeProcesses, startProcesses, toStageHandlers };

package/src/core/new-fsm-process.ts

@@ -1,83 +0,0 @@
-import { isStateTransitionEnabled } from "../utils/transitions.ts";
-import { FsmProcess } from "./fsm-process.ts";
-import type { FsmStateConfig } from "./fsm-state-config.ts";
-
-export type Module<C = unknown> = (context: C) =>
-  | void
-  | (() => void | Promise<void>)
-  | Promise<void | (() => void | Promise<void>)>
-  // Event emitters / triggers
-  | Generator<string>
-  | AsyncGenerator<string>;
-
-export 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>,
-] {
-  let started = false;
-  let terminated = false;
-  const process = new FsmProcess(config);
-  async function dispatch(event: string): Promise<boolean> {
-    return terminated ||
-      (event !== undefined &&
-        (!started || isStateTransitionEnabled(process, event)))
-      ? process.dispatch(event)
-      : false;
-  }
-  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;
-              }
-              await dispatch(event);
-              if (terminated) {
-                break;
-              }
-            }
-          })();
-        } else if (typeof result === "function") {
-          state.onExit(result);
-        }
-      }
-    });
-  });
-  async function shutdown(): Promise<void> {
-    await process.shutdown();
-    terminated = true;
-  }
-  return [dispatch, shutdown] as const;
-
-  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"
-    );
-  }
-}

package/src/orchestrator/constants.ts

@@ -1,130 +0,0 @@
-/**
- * Key used to bind the dispatch function to the process context.
- * The dispatch function allows triggering state transitions by dispatching events.
- *
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * // Initialize the FSM process using `startFsmProcess`
- * const dispatch = context["fsm:dispatch"] as (event: string) => Promise<void>;
- * await dispatch("someEvent");
- */
-export const KEY_DISPATCH = "fsm:dispatch" as const;
-
-/**
- * Key used to bind the terminate function to the process context.
- * The terminate function is used to gracefully shut down the FSM process.
- * It returns a Promise that resolves when the process has been fully terminated.
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * // Initialize the FSM process using `startFsmProcess`
- * const terminate = context["fsm:terminate"] as () => Promise<void>;
- * await terminate();
- * ```
- */
-export const KEY_TERMINATE = "fsm:terminate" as const;
-
-/**
- * Key used to bind the current stack of active states to the process context.
- * This provides a snapshot of the states the FSM process has entered.
- * It is represented as an array of strings -- state keys.
- *
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * // Initialize the FSM process using `startFsmProcess`
- * const states = context["fsm:states"] as string[];
- * console.log("Current active states:", states);
- * ```
- */
-export const KEY_STATES = "fsm:states" as const;
-
-/**
- * Key used to bind the current event being processed to the process context.
- * This represents the event that triggered the current state transition.
- * It is represented as a string.
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * // Initialize the FSM process using `startFsmProcess`
- * const event = context["fsm:event"] as string;
- * console.log("Current event:", event);
- * ```
- */
-export const KEY_EVENT = "fsm:event" as const;
-
-//-------------------------------------------------
-
-// export const KEY_START_PROCESS = "fsm:sys:start" as const;
-/**
- * Key used to register a new FSM process configuration in the process context.
- * This key is associated with a function that allows adding new FSM configurations.
- * The function takes a process name and its configuration, and returns a cleanup function
- * to remove the registered configuration.
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * initProcessManager(context); // Initialize the process manager in the context
- * ...
- * type StateConfig = { key: string; transitions?: string[][]; states?: StateConfig[] };
- * const registerConfig = context["fsm:sys:registerConfig"] as (name: string, config: StateConfig) => () => void;
- * const unregister = registerConfig("myProcess", { key: "Main", transitions: [...] });
- * // To unregister the configuration later
- * unregister();
- * ```
- */
-export const KEY_REGISTER_CONFIG = "fsm:sys:registerConfig" as const;
-
-/**
- * Key used to register state and event handlers for FSM processes in the process context.
- * This key is associated with a function that allows adding handler modules for a specific process.
- * The function takes a process name and a variable number of handler modules, returning a cleanup function
- * to remove the registered handlers.
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * initProcessManager(context); // Initialize the process manager in the context
- * ...
- * const registerHandlers = context["fsm:sys:registerHandlers"] as (name: string, ...modules: unknown[]) => () => void;
- * const handlerModule1 = {
- *   Main: async (context) => { ... },
- *   SomeState: async (context) => { ... },
- * }
- * // Views layer can be defined in the same or separate modules
- * const handlerModule3 = {
- *  MainView: async (context) => { ... },
- *  SomeStateView: async (context) => { ... },
- * }
- * // A common handler function to call for all states
- * const handlerModule2 = (context) => { ... };
- * const unregister = registerHandlers(
- *  "myProcess",
- *  handlerModule1,
- *  handlerModule2,
- *  handlerModule3
- * );
- * // To unregister the handlers later
- * unregister();
- * ```
- */
-export const KEY_REGISTER_HANDLERS = "fsm:sys:registerHandlers" as const;
-
-/**
- * Key used to launch an FSM process in the process context.
- * This key is associated with a function that initiates the FSM process based on its name and context.
- * The function takes the process name and context, returning either nothing, a cleanup function,
- * or a Promise that resolves to either nothing or a cleanup function.
- * Example usage:
- * ```typescript
- * const context: Record<string, unknown> = {};
- * initProcessManager(context); // Initialize the process manager in the context
- * // Register process configurations and handlers as needed
- *
- * const launchProcess = context["fsm:sys:launch"] as (name: string, context: Record<string, unknown>) => () => Promise<void>;
- * const terminate = await launchProcess("myProcess", context);
- * // To terminate the process later
- * terminate?.();
- * ```
- */
-export const KEY_LAUNCH_PROCESS = "fsm:sys:launch" as const;

package/src/orchestrator/is-generator.ts

@@ -1,12 +0,0 @@
-export 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"
-  );
-}

package/src/orchestrator/process-config-manager.ts

@@ -1,70 +0,0 @@
-import type { FsmStateConfig } from "../core/fsm-state-config.ts";
-import { type StageHandler, toStageHandlers } from "./types.ts";
-
-export interface IProcessConfigManager {
-  getProcessConfig(processName: string): FsmStateConfig;
-  getHandlersLoader<C = unknown>(
-    processName: string,
-  ): (state: string, event: undefined | string) => StageHandler<C>[];
-  registerConfig(name: string, config: FsmStateConfig): () => void;
-  registerHandlers(name: string, ...modules: unknown[]): () => void;
-}
-
-export class ProcessConfigManager implements IProcessConfigManager {
-  protected configs: Record<string, FsmStateConfig> = {};
-  protected handlers: Record<string, unknown[]> = {};
-
-  getProcessConfig(processName: string): FsmStateConfig {
-    return this.configs[processName] ?? { key: "Main" };
-  }
-
-  getHandlersLoader<C = unknown>(
-    processName: string,
-  ): (state: string, event: undefined | string) => StageHandler<C>[] {
-    const config = this.getProcessConfig(processName);
-    return (stateKey: string) => {
-      const modulesKeys: string[] = [];
-      if (stateKey === config.key) {
-        modulesKeys.push("default");
-      }
-      modulesKeys.push(
-        stateKey,
-        `${stateKey}Controller`,
-        `${stateKey}StateController`,
-        `${stateKey}View`,
-        `${stateKey}StateView`,
-        `${stateKey}Trigger`,
-        `${stateKey}StateTrigger`,
-        `${stateKey}Test`,
-        `${stateKey}StateTest`,
-      );
-      const keysSet = new Set(modulesKeys);
-      const processHandlers = this.handlers[processName] ?? [];
-      const handlers = toStageHandlers(processHandlers, (key: string) =>
-        keysSet.has(key),
-      );
-      return handlers;
-    };
-  }
-
-  registerConfig(name: string, config: FsmStateConfig): () => void {
-    this.configs[name] = config;
-    return () => {
-      delete this.configs[name];
-    };
-  }
-
-  registerHandlers(name: string, ...modules: unknown[]): () => void {
-    let list: unknown[] = this.handlers[name];
-    if (!list) {
-      list = this.handlers[name] = [];
-    }
-    list.push(modules);
-    return () => {
-      list = list.filter((v) => v !== modules);
-      if (list.length === 0) {
-        delete this.handlers[name];
-      }
-    };
-  }
-}

package/src/orchestrator/resolve-module-refs.ts

@@ -1,52 +0,0 @@
-/**
- * Resolve module paths relative to a base URL.
- * This is useful for converting relative paths to absolute URLs.
- *
- * @param baseUrl - The base URL to resolve against.
- * @param refs - An array of module references (relative or absolute).
- * @returns An array of resolved absolute module URLs as strings.
- * @example
- * ```ts
- * const urls = resolveModulesUrls(
- *  'file:///home/user/project/', // base URL
- *  'https://example.com/js/my-module.js', // absolute URL
- *  './module1.js', // relative path
- *  '../module2.js' // relative path
- * );
- * console.log(urls);
- * // Output: [
- * //  'https://example.com/js/my-module.js',
- * //  'file:///home/user/project/module1.js',
- * //  'file:///home/user/module2.js'
- * // ] *
- * ```
- */
-export function resolveModulesUrls(
-  baseUrl: URL | string,
-  ...refs: (URL | string)[]
-): string[] {
-  return refs.map((ref) => new URL(ref, baseUrl).href);
-}
-
-/**
- * Resolves module paths relative to a base URL.
- * This is useful for converting relative paths to absolute file system paths.
- * @param baseUrl - The base URL to resolve against
- * @param refs - An array of module references (relative or absolute)
- * @returns - An array of resolved absolute module paths as strings
- * @example
- * ```ts
- * const paths = resolveModulesPaths('file:///home/user/project/', './module1.js', '../module2.js');
- * console.log(paths);
- * // Output: [
- * //   '/home/user/project/module1.js',
- * //   '/home/user/module2.js'
- * // ]
- * ```
- */
-export function resolveModulesPaths(
-  baseUrl: URL | string,
-  ...refs: (URL | string)[]
-): string[] {
-  return refs.map((ref) => new URL(ref, baseUrl).pathname);
-}