@doeixd/machine 0.0.4 → 0.0.6

package/dist/cjs/development/index.js

@@ -20,15 +20,34 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  META_KEY: () => META_KEY,
   MachineBase: () => MachineBase,
+  MultiMachineBase: () => MultiMachineBase,
+  RUNTIME_META: () => RUNTIME_META,
+  action: () => action,
   createAsyncMachine: () => createAsyncMachine,
+  createEnsemble: () => createEnsemble,
   createFlow: () => createFlow,
   createMachine: () => createMachine,
   createMachineBuilder: () => createMachineBuilder,
   createMachineFactory: () => createMachineFactory,
+  createMultiMachine: () => createMultiMachine,
+  createMutableMachine: () => createMutableMachine,
+  createRunner: () => createRunner,
+  describe: () => describe,
   extendTransitions: () => extendTransitions,
+  extractFromInstance: () => extractFromInstance,
+  extractFunctionMetadata: () => extractFunctionMetadata,
+  extractMachine: () => extractMachine,
+  extractMachines: () => extractMachines,
+  extractStateNode: () => extractStateNode,
+  generateChart: () => generateChart,
+  generateStatechart: () => generateStatechart,
+  guarded: () => guarded,
   hasState: () => hasState,
+  invoke: () => invoke,
   matchMachine: () => matchMachine,
+  metadata: () => metadata,
   next: () => next,
   overrideTransitions: () => overrideTransitions,
   run: () => run,
@@ -36,9 +55,12 @@ __export(src_exports, {
   runMachine: () => runMachine,
   runSequence: () => runSequence,
   runWithDebug: () => runWithDebug,
+  runWithEnsemble: () => runWithEnsemble,
+  runWithRunner: () => runWithRunner,
   setContext: () => setContext,
   step: () => step,
   stepAsync: () => stepAsync,
+  transitionTo: () => transitionTo,
   yieldMachine: () => yieldMachine
 });
 module.exports = __toCommonJS(src_exports);
@@ -106,6 +128,675 @@ async function* stepAsync(m) {
   return received;
 }
 
+// src/primitives.ts
+var META_KEY = Symbol("MachineMeta");
+var RUNTIME_META = Symbol("__machine_runtime_meta__");
+function attachRuntimeMeta(fn, metadata2) {
+  const existing = fn[RUNTIME_META] || {};
+  const merged = { ...existing, ...metadata2 };
+  if (metadata2.guards && existing.guards) {
+    merged.guards = [...metadata2.guards, ...existing.guards];
+  } else if (metadata2.guards) {
+    merged.guards = [...metadata2.guards];
+  }
+  if (metadata2.actions && existing.actions) {
+    merged.actions = [...metadata2.actions, ...existing.actions];
+  } else if (metadata2.actions) {
+    merged.actions = [...metadata2.actions];
+  }
+  Object.defineProperty(fn, RUNTIME_META, {
+    value: merged,
+    enumerable: false,
+    writable: false,
+    configurable: true
+    // CRITICAL: Must be configurable for re-definition
+  });
+}
+function transitionTo(_target, implementation) {
+  attachRuntimeMeta(implementation, {
+    target: _target.name || _target.toString()
+  });
+  return implementation;
+}
+function describe(_text, transition) {
+  attachRuntimeMeta(transition, {
+    description: _text
+  });
+  return transition;
+}
+function guarded(guard, transition) {
+  attachRuntimeMeta(transition, {
+    guards: [guard]
+  });
+  return transition;
+}
+function invoke(service, implementation) {
+  attachRuntimeMeta(implementation, {
+    invoke: {
+      src: service.src,
+      onDone: service.onDone.name || service.onDone.toString(),
+      onError: service.onError.name || service.onError.toString(),
+      description: service.description
+    }
+  });
+  return implementation;
+}
+function action(action2, transition) {
+  attachRuntimeMeta(transition, {
+    actions: [action2]
+  });
+  return transition;
+}
+function metadata(_meta, value) {
+  return value;
+}
+
+// src/extract.ts
+var import_ts_morph = require("ts-morph");
+function resolveClassName(node) {
+  if (import_ts_morph.Node.isIdentifier(node)) {
+    return node.getText();
+  }
+  if (import_ts_morph.Node.isTypeOfExpression(node)) {
+    return node.getExpression().getText();
+  }
+  return "unknown";
+}
+function parseObjectLiteral(obj) {
+  if (!import_ts_morph.Node.isObjectLiteralExpression(obj)) {
+    return {};
+  }
+  const result = {};
+  for (const prop of obj.getProperties()) {
+    if (import_ts_morph.Node.isPropertyAssignment(prop)) {
+      const name = prop.getName();
+      const init = prop.getInitializer();
+      if (init) {
+        if (import_ts_morph.Node.isStringLiteral(init)) {
+          result[name] = init.getLiteralValue();
+        } else if (import_ts_morph.Node.isNumericLiteral(init)) {
+          result[name] = init.getLiteralValue();
+        } else if (init.getText() === "true" || init.getText() === "false") {
+          result[name] = init.getText() === "true";
+        } else if (import_ts_morph.Node.isIdentifier(init)) {
+          result[name] = init.getText();
+        } else if (import_ts_morph.Node.isObjectLiteralExpression(init)) {
+          result[name] = parseObjectLiteral(init);
+        } else if (import_ts_morph.Node.isArrayLiteralExpression(init)) {
+          result[name] = init.getElements().map((el) => {
+            if (import_ts_morph.Node.isObjectLiteralExpression(el)) {
+              return parseObjectLiteral(el);
+            }
+            return el.getText();
+          });
+        }
+      }
+    }
+  }
+  return result;
+}
+function parseInvokeService(obj) {
+  if (!import_ts_morph.Node.isObjectLiteralExpression(obj)) {
+    return {};
+  }
+  const service = {};
+  for (const prop of obj.getProperties()) {
+    if (import_ts_morph.Node.isPropertyAssignment(prop)) {
+      const name = prop.getName();
+      const init = prop.getInitializer();
+      if (!init) continue;
+      if (name === "onDone" || name === "onError") {
+        service[name] = resolveClassName(init);
+      } else if (import_ts_morph.Node.isStringLiteral(init)) {
+        service[name] = init.getLiteralValue();
+      } else if (import_ts_morph.Node.isIdentifier(init)) {
+        service[name] = init.getText();
+      }
+    }
+  }
+  return service;
+}
+function extractFromCallExpression(call, verbose = false) {
+  if (!import_ts_morph.Node.isCallExpression(call)) {
+    return null;
+  }
+  const expression = call.getExpression();
+  const fnName = import_ts_morph.Node.isIdentifier(expression) ? expression.getText() : null;
+  if (!fnName) {
+    return null;
+  }
+  const metadata2 = {};
+  const args = call.getArguments();
+  switch (fnName) {
+    case "transitionTo":
+      if (args[0]) {
+        metadata2.target = resolveClassName(args[0]);
+      }
+      break;
+    case "describe":
+      if (args[0] && import_ts_morph.Node.isStringLiteral(args[0])) {
+        metadata2.description = args[0].getLiteralValue();
+      }
+      if (args[1] && import_ts_morph.Node.isCallExpression(args[1])) {
+        const nested = extractFromCallExpression(args[1], verbose);
+        if (nested) {
+          Object.assign(metadata2, nested);
+        }
+      }
+      break;
+    case "guarded":
+      if (args[0]) {
+        const guard = parseObjectLiteral(args[0]);
+        if (Object.keys(guard).length > 0) {
+          metadata2.guards = [guard];
+        }
+      }
+      if (args[1] && import_ts_morph.Node.isCallExpression(args[1])) {
+        const nested = extractFromCallExpression(args[1], verbose);
+        if (nested) {
+          Object.assign(metadata2, nested);
+        }
+      }
+      break;
+    case "invoke":
+      if (args[0]) {
+        const service = parseInvokeService(args[0]);
+        if (Object.keys(service).length > 0) {
+          metadata2.invoke = service;
+        }
+      }
+      break;
+    case "action":
+      if (args[0]) {
+        const actionMeta = parseObjectLiteral(args[0]);
+        if (Object.keys(actionMeta).length > 0) {
+          metadata2.actions = [actionMeta];
+        }
+      }
+      if (args[1] && import_ts_morph.Node.isCallExpression(args[1])) {
+        const nested = extractFromCallExpression(args[1], verbose);
+        if (nested) {
+          Object.assign(metadata2, nested);
+        }
+      }
+      break;
+    default:
+      return null;
+  }
+  return Object.keys(metadata2).length > 0 ? metadata2 : null;
+}
+function extractMetaFromMember(member, verbose = false) {
+  if (!import_ts_morph.Node.isPropertyDeclaration(member)) {
+    if (verbose) console.error(`      ⚠️ Not a property declaration`);
+    return null;
+  }
+  const initializer = member.getInitializer();
+  if (!initializer) {
+    if (verbose) console.error(`      ⚠️ No initializer`);
+    return null;
+  }
+  if (!import_ts_morph.Node.isCallExpression(initializer)) {
+    if (verbose) console.error(`      ⚠️ Initializer is not a call expression`);
+    return null;
+  }
+  const metadata2 = extractFromCallExpression(initializer, verbose);
+  if (metadata2 && verbose) {
+    console.error(`      ✅ Extracted metadata:`, JSON.stringify(metadata2, null, 2));
+  }
+  return metadata2;
+}
+function analyzeStateNode(classSymbol, verbose = false) {
+  const chartNode = { on: {} };
+  const classDeclaration = classSymbol.getDeclarations()[0];
+  if (!classDeclaration || !import_ts_morph.Node.isClassDeclaration(classDeclaration)) {
+    if (verbose) {
+      console.error(`⚠️ Warning: Could not get class declaration for ${classSymbol.getName()}`);
+    }
+    return chartNode;
+  }
+  const className = classSymbol.getName();
+  if (verbose) {
+    console.error(`  Analyzing state: ${className}`);
+  }
+  for (const member of classDeclaration.getInstanceMembers()) {
+    const memberName = member.getName();
+    if (verbose) {
+      console.error(`    Checking member: ${memberName}`);
+    }
+    const meta = extractMetaFromMember(member, verbose);
+    if (!meta) continue;
+    if (verbose) {
+      console.error(`    Found transition: ${memberName}`);
+    }
+    const { invoke: invoke2, actions, guards, ...onEntry } = meta;
+    if (invoke2) {
+      if (!chartNode.invoke) chartNode.invoke = [];
+      chartNode.invoke.push({
+        src: invoke2.src,
+        onDone: { target: invoke2.onDone },
+        onError: { target: invoke2.onError },
+        description: invoke2.description
+      });
+      if (verbose) {
+        console.error(`      → Invoke: ${invoke2.src}`);
+      }
+    }
+    if (onEntry.target) {
+      const transition = { target: onEntry.target };
+      if (onEntry.description) {
+        transition.description = onEntry.description;
+      }
+      if (guards) {
+        transition.cond = guards.map((g) => g.name).join(" && ");
+        if (verbose) {
+          console.error(`      → Guard: ${transition.cond}`);
+        }
+      }
+      if (actions && actions.length > 0) {
+        transition.actions = actions.map((a) => a.name);
+        if (verbose) {
+          console.error(`      → Actions: ${transition.actions.join(", ")}`);
+        }
+      }
+      chartNode.on[memberName] = transition;
+      if (verbose) {
+        console.error(`      → Target: ${onEntry.target}`);
+      }
+    }
+  }
+  return chartNode;
+}
+function extractMachine(config, project, verbose = false) {
+  if (verbose) {
+    console.error(`
+🔍 Analyzing machine: ${config.id}`);
+    console.error(`  Source: ${config.input}`);
+  }
+  const sourceFile = project.getSourceFile(config.input);
+  if (!sourceFile) {
+    throw new Error(`Source file not found: ${config.input}`);
+  }
+  const fullChart = {
+    id: config.id,
+    initial: config.initialState,
+    states: {}
+  };
+  if (config.description) {
+    fullChart.description = config.description;
+  }
+  for (const className of config.classes) {
+    const classDeclaration = sourceFile.getClass(className);
+    if (!classDeclaration) {
+      console.warn(`⚠️ Warning: Class '${className}' not found in '${config.input}'. Skipping.`);
+      continue;
+    }
+    const classSymbol = classDeclaration.getSymbolOrThrow();
+    const stateNode = analyzeStateNode(classSymbol, verbose);
+    fullChart.states[className] = stateNode;
+  }
+  if (verbose) {
+    console.error(`  ✅ Extracted ${config.classes.length} states`);
+  }
+  return fullChart;
+}
+function extractMachines(config) {
+  var _a;
+  const verbose = (_a = config.verbose) != null ? _a : false;
+  if (verbose) {
+    console.error(`
+📊 Starting statechart extraction`);
+    console.error(`  Machines to extract: ${config.machines.length}`);
+  }
+  const project = new import_ts_morph.Project();
+  project.addSourceFilesAtPaths("src/**/*.ts");
+  project.addSourceFilesAtPaths("examples/**/*.ts");
+  const results = [];
+  for (const machineConfig of config.machines) {
+    try {
+      const chart = extractMachine(machineConfig, project, verbose);
+      results.push(chart);
+    } catch (error) {
+      console.error(`❌ Error extracting machine '${machineConfig.id}':`, error);
+      if (!verbose) {
+        console.error(`   Run with --verbose for more details`);
+      }
+    }
+  }
+  if (verbose) {
+    console.error(`
+✅ Extraction complete: ${results.length}/${config.machines.length} machines extracted`);
+  }
+  return results;
+}
+function generateChart() {
+  const config = {
+    input: "examples/authMachine.ts",
+    classes: [
+      "LoggedOutMachine",
+      "LoggingInMachine",
+      "LoggedInMachine",
+      "SessionExpiredMachine",
+      "ErrorMachine"
+    ],
+    id: "auth",
+    initialState: "LoggedOutMachine",
+    description: "Authentication state machine"
+  };
+  console.error("🔍 Using legacy generateChart function");
+  console.error("⚠️ Consider using extractMachines() with a config file instead\n");
+  const project = new import_ts_morph.Project();
+  project.addSourceFilesAtPaths("src/**/*.ts");
+  project.addSourceFilesAtPaths("examples/**/*.ts");
+  try {
+    const chart = extractMachine(config, project, true);
+    console.log(JSON.stringify(chart, null, 2));
+  } catch (error) {
+    console.error(`❌ Error:`, error);
+    process.exit(1);
+  }
+}
+if (require.main === module) {
+  generateChart();
+}
+
+// src/runtime-extract.ts
+function extractFunctionMetadata(fn) {
+  if (typeof fn !== "function") {
+    return null;
+  }
+  const meta = fn[RUNTIME_META];
+  return meta || null;
+}
+function extractStateNode(stateInstance) {
+  const stateNode = { on: {} };
+  const invoke2 = [];
+  for (const key in stateInstance) {
+    const value = stateInstance[key];
+    if (typeof value !== "function") {
+      continue;
+    }
+    const meta = extractFunctionMetadata(value);
+    if (!meta) {
+      continue;
+    }
+    if (meta.invoke) {
+      invoke2.push({
+        src: meta.invoke.src,
+        onDone: { target: meta.invoke.onDone },
+        onError: { target: meta.invoke.onError },
+        description: meta.invoke.description
+      });
+    }
+    if (meta.target) {
+      const transition = { target: meta.target };
+      if (meta.description) {
+        transition.description = meta.description;
+      }
+      if (meta.guards && meta.guards.length > 0) {
+        transition.cond = meta.guards.map((g) => g.name).join(" && ");
+      }
+      if (meta.actions && meta.actions.length > 0) {
+        transition.actions = meta.actions.map((a) => a.name);
+      }
+      stateNode.on[key] = transition;
+    }
+  }
+  if (invoke2.length > 0) {
+    stateNode.invoke = invoke2;
+  }
+  return stateNode;
+}
+function generateStatechart(states, config) {
+  const chart = {
+    id: config.id,
+    initial: config.initial,
+    states: {}
+  };
+  if (config.description) {
+    chart.description = config.description;
+  }
+  for (const [stateName, stateInstance] of Object.entries(states)) {
+    chart.states[stateName] = extractStateNode(stateInstance);
+  }
+  return chart;
+}
+function extractFromInstance(machineInstance, config) {
+  const stateName = config.stateName || machineInstance.constructor.name || "State";
+  return {
+    id: config.id,
+    initial: stateName,
+    states: {
+      [stateName]: extractStateNode(machineInstance)
+    }
+  };
+}
+
+// src/multi.ts
+function createRunner(initialMachine, onChange) {
+  let currentMachine = initialMachine;
+  const setState = (newState) => {
+    currentMachine = newState;
+    onChange == null ? void 0 : onChange(newState);
+  };
+  const { context: _initialContext, ...originalTransitions } = initialMachine;
+  const actions = new Proxy({}, {
+    get(_target, prop) {
+      const transition = currentMachine[prop];
+      if (typeof transition !== "function") {
+        return void 0;
+      }
+      return (...args) => {
+        const nextState = transition.apply(currentMachine.context, args);
+        const nextStateWithTransitions = Object.assign(
+          { context: nextState.context },
+          originalTransitions
+        );
+        setState(nextStateWithTransitions);
+        return nextStateWithTransitions;
+      };
+    }
+  });
+  return {
+    get state() {
+      return currentMachine;
+    },
+    get context() {
+      return currentMachine.context;
+    },
+    actions,
+    setState
+  };
+}
+function createEnsemble(store, factories, getDiscriminant) {
+  const getCurrentMachine = () => {
+    const context = store.getContext();
+    const currentStateName = getDiscriminant(context);
+    const factory = factories[currentStateName];
+    if (!factory) {
+      throw new Error(
+        `[Ensemble] Invalid state: No factory found for state "${String(currentStateName)}".`
+      );
+    }
+    return factory(context);
+  };
+  const actions = new Proxy({}, {
+    get(_target, prop) {
+      const currentMachine = getCurrentMachine();
+      const action2 = currentMachine[prop];
+      if (typeof action2 !== "function") {
+        throw new Error(
+          `[Ensemble] Transition "${prop}" is not valid in the current state.`
+        );
+      }
+      return (...args) => {
+        return action2.apply(currentMachine.context, args);
+      };
+    }
+  });
+  return {
+    get context() {
+      return store.getContext();
+    },
+    get state() {
+      return getCurrentMachine();
+    },
+    actions
+  };
+}
+function runWithRunner(flow, initialMachine) {
+  const runner = createRunner(initialMachine);
+  const generator = flow(runner);
+  let result = generator.next();
+  while (!result.done) {
+    result = generator.next();
+  }
+  return result.value;
+}
+function runWithEnsemble(flow, ensemble) {
+  const generator = flow(ensemble);
+  let result = generator.next();
+  while (!result.done) {
+    result = generator.next();
+  }
+  return result.value;
+}
+var MultiMachineBase = class {
+  /**
+   * @param store - The StateStore that will manage this machine's context.
+   */
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Read-only access to the current context from the external store.
+   * This getter always returns the latest context from the store.
+   *
+   * @protected
+   *
+   * @example
+   * const currentStatus = this.context.status;
+   * const currentData = this.context.data;
+   */
+  get context() {
+    return this.store.getContext();
+  }
+  /**
+   * Update the shared context in the external store.
+   * Call this method in your transition methods to update the state.
+   *
+   * @protected
+   * @param newContext - The new context object. Should typically be a shallow
+   *   copy with only the properties you're changing, merged with the current
+   *   context using spread operators.
+   *
+   * @example
+   * // In a transition method:
+   * this.setContext({ ...this.context, status: 'loading' });
+   *
+   * @example
+   * // Updating nested properties:
+   * this.setContext({
+   *   ...this.context,
+   *   user: { ...this.context.user, name: 'Alice' }
+   * });
+   */
+  setContext(newContext) {
+    this.store.setContext(newContext);
+  }
+};
+function createMultiMachine(MachineClass, store) {
+  const instance = new MachineClass(store);
+  return new Proxy({}, {
+    get(_target, prop) {
+      const context = store.getContext();
+      if (prop in context) {
+        return context[prop];
+      }
+      const method = instance[prop];
+      if (typeof method === "function") {
+        return (...args) => {
+          return method.apply(instance, args);
+        };
+      }
+      return void 0;
+    },
+    set(_target, prop, value) {
+      const context = store.getContext();
+      if (prop in context) {
+        const newContext = { ...context, [prop]: value };
+        store.setContext(newContext);
+        return true;
+      }
+      return false;
+    },
+    has(_target, prop) {
+      const context = store.getContext();
+      return prop in context || typeof instance[prop] === "function";
+    },
+    ownKeys(_target) {
+      const context = store.getContext();
+      const contextKeys = Object.keys(context);
+      const methodKeys = Object.getOwnPropertyNames(
+        Object.getPrototypeOf(instance)
+      ).filter((key) => key !== "constructor" && typeof instance[key] === "function");
+      return Array.from(/* @__PURE__ */ new Set([...contextKeys, ...methodKeys]));
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const context = store.getContext();
+      if (prop in context || typeof instance[prop] === "function") {
+        return {
+          value: void 0,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        };
+      }
+      return void 0;
+    }
+  });
+}
+function createMutableMachine(sharedContext, factories, getDiscriminant) {
+  const getCurrentMachine = () => {
+    const currentStateName = getDiscriminant(sharedContext);
+    const factory = factories[currentStateName];
+    if (!factory) {
+      throw new Error(
+        `[MutableMachine] Invalid state: No factory for state "${String(currentStateName)}".`
+      );
+    }
+    return factory(sharedContext);
+  };
+  return new Proxy(sharedContext, {
+    get(target, prop, _receiver) {
+      if (prop in target) {
+        return target[prop];
+      }
+      const currentMachine = getCurrentMachine();
+      const transition = currentMachine[prop];
+      if (typeof transition === "function") {
+        return (...args) => {
+          const nextContext = transition.apply(currentMachine.context, args);
+          if (typeof nextContext !== "object" || nextContext === null) {
+            console.warn(`[MutableMachine] Transition "${String(prop)}" did not return a valid context object. State may be inconsistent.`);
+            return;
+          }
+          Object.keys(target).forEach((key) => delete target[key]);
+          Object.assign(target, nextContext);
+        };
+      }
+      return void 0;
+    },
+    set(target, prop, value, _receiver) {
+      target[prop] = value;
+      return true;
+    },
+    has(target, prop) {
+      const currentMachine = getCurrentMachine();
+      return prop in target || typeof currentMachine[prop] === "function";
+    }
+  });
+}
+
 // src/index.ts
 function createMachine(context, fns) {
   return Object.assign({ context }, fns);