@doeixd/machine 0.0.17 → 0.0.19

package/dist/cjs/development/index.js

@@ -20,7 +20,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  ADVANCED_CONFIG_EXAMPLES: () => ADVANCED_CONFIG_EXAMPLES,
   BoundMachine: () => BoundMachine,
   CANCEL: () => CANCEL,
   META_KEY: () => META_KEY,
@@ -32,11 +31,13 @@ __export(src_exports, {
   branch: () => branch,
   call: () => call,
   chain: () => chain,
+  classCase: () => classCase,
   combine: () => combine,
   combineFactories: () => combineFactories,
   compose: () => compose,
   composeTyped: () => composeTyped,
   createAsyncMachine: () => createAsyncMachine,
+  createContext: () => createContext,
   createCustomMiddleware: () => createCustomMiddleware,
   createEnsemble: () => createEnsemble,
   createEnsembleFactory: () => createEnsembleFactory,
@@ -47,6 +48,7 @@ __export(src_exports, {
   createMachine: () => createMachine,
   createMachineBuilder: () => createMachineBuilder,
   createMachineFactory: () => createMachineFactory,
+  createMatcher: () => createMatcher,
   createMiddleware: () => createMiddleware,
   createMiddlewareFactory: () => createMiddlewareFactory,
   createMiddlewareRegistry: () => createMiddlewareRegistry,
@@ -58,12 +60,12 @@ __export(src_exports, {
   createTransition: () => createTransition,
   createTransitionExtender: () => createTransitionExtender,
   createTransitionFactory: () => createTransitionFactory,
+  customCase: () => customCase,
   delegateToChild: () => delegateToChild,
   describe: () => describe,
+  discriminantCase: () => discriminantCase,
   extendTransitions: () => extendTransitions,
-  extractMachine: () => extractMachine,
-  extractMachines: () => extractMachines,
-  generateChart: () => generateChart,
+  forContext: () => forContext,
   guard: () => guard,
   guardAsync: () => guardAsync,
   guarded: () => guarded,
@@ -706,441 +708,6 @@ function createParallelMachine(m1, m2) {
   };
 }
 
-// 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(call2, verbose = false) {
-  if (!import_ts_morph.Node.isCallExpression(call2)) {
-    return null;
-  }
-  const expression = call2.getExpression();
-  const fnName = import_ts_morph.Node.isIdentifier(expression) ? expression.getText() : null;
-  if (!fnName) {
-    return null;
-  }
-  const metadata2 = {};
-  const args = call2.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 guard2 = parseObjectLiteral(args[0]);
-        if (Object.keys(guard2).length > 0) {
-          metadata2.guards = [guard2];
-        }
-      }
-      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;
-    case "guard":
-      if (args[2]) {
-        const options = parseObjectLiteral(args[2]);
-        if (options.description) {
-          metadata2.description = options.description;
-        }
-      }
-      metadata2.guards = [{ name: "runtime_guard", description: metadata2.description || "Synchronous condition check" }];
-      if (args[1] && import_ts_morph.Node.isCallExpression(args[1])) {
-        const nested = extractFromCallExpression(args[1], verbose);
-        if (nested) {
-          Object.assign(metadata2, nested);
-        }
-      }
-      break;
-    case "guardAsync":
-      if (args[2]) {
-        const options = parseObjectLiteral(args[2]);
-        if (options.description) {
-          metadata2.description = options.description;
-        }
-      }
-      metadata2.guards = [{ name: "runtime_guard_async", description: metadata2.description || "Asynchronous condition check" }];
-      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 analyzeStateNodeWithNesting(className, classSymbol, sourceFile, childConfig, verbose = false) {
-  const stateNode = analyzeStateNode(classSymbol, verbose);
-  if (childConfig) {
-    if (verbose) {
-      console.error(`  👪 Analyzing children for state: ${className}`);
-    }
-    stateNode.initial = childConfig.initialState;
-    stateNode.states = {};
-    for (const childClassName of childConfig.classes) {
-      const childClassDeclaration = sourceFile.getClass(childClassName);
-      if (childClassDeclaration) {
-        const childSymbol = childClassDeclaration.getSymbolOrThrow();
-        stateNode.states[childClassName] = analyzeStateNode(childSymbol, verbose);
-      } else {
-        console.warn(`⚠️ Warning: Child class '${childClassName}' not found.`);
-      }
-    }
-  }
-  return stateNode;
-}
-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}`);
-  }
-  if (config.parallel) {
-    if (verbose) {
-      console.error(`  ⏹️ Parallel machine detected. Analyzing regions.`);
-    }
-    const parallelChart = {
-      id: config.id,
-      type: "parallel",
-      states: {}
-    };
-    if (config.description) {
-      parallelChart.description = config.description;
-    }
-    for (const region of config.parallel.regions) {
-      if (verbose) {
-        console.error(`    📍 Analyzing region: ${region.name}`);
-      }
-      const regionStates = {};
-      for (const className of region.classes) {
-        const classDeclaration = sourceFile.getClass(className);
-        if (classDeclaration) {
-          const classSymbol = classDeclaration.getSymbolOrThrow();
-          regionStates[className] = analyzeStateNode(classSymbol, verbose);
-        } else {
-          console.warn(`⚠️ Warning: Class '${className}' not found for region '${region.name}'.`);
-        }
-      }
-      parallelChart.states[region.name] = {
-        initial: region.initialState,
-        states: regionStates
-      };
-    }
-    if (verbose) {
-      console.error(`  ✅ Extracted ${config.parallel.regions.length} parallel regions`);
-    }
-    return parallelChart;
-  }
-  if (!config.initialState || !config.classes) {
-    throw new Error(`Machine config for '${config.id}' must have either 'parallel' or 'initialState'/'classes'.`);
-  }
-  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 hasChildren = className === config.initialState && config.children;
-    const stateNode = analyzeStateNodeWithNesting(
-      className,
-      classSymbol,
-      sourceFile,
-      hasChildren ? config.children : void 0,
-      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);
-  }
-}
-var ADVANCED_CONFIG_EXAMPLES = {
-  hierarchical: {
-    input: "examples/dashboardMachine.ts",
-    id: "dashboard",
-    classes: ["DashboardMachine", "LoggedOutMachine"],
-    initialState: "DashboardMachine",
-    children: {
-      contextProperty: "child",
-      initialState: "ViewingChildMachine",
-      classes: ["ViewingChildMachine", "EditingChildMachine"]
-    }
-  },
-  parallel: {
-    input: "examples/editorMachine.ts",
-    id: "editor",
-    parallel: {
-      regions: [
-        {
-          name: "fontWeight",
-          initialState: "NormalWeight",
-          classes: ["NormalWeight", "BoldWeight"]
-        },
-        {
-          name: "textDecoration",
-          initialState: "NoDecoration",
-          classes: ["NoDecoration", "UnderlineState"]
-        }
-      ]
-    }
-  }
-};
-if (require.main === module) {
-  generateChart();
-}
-
 // src/middleware/core.ts
 var CANCEL = Symbol("CANCEL");
 function createMiddleware(machine, hooks, options = {}) {
@@ -2114,6 +1681,132 @@ function state(context, transitions) {
   return createFunctionalMachine(context);
 }
 
+// src/matcher.ts
+function createMatcher(...cases) {
+  const nameToCase = /* @__PURE__ */ new Map();
+  for (const [name, _, predicate] of cases) {
+    if (nameToCase.has(name)) {
+      throw new Error(`Duplicate matcher case name: "${name}"`);
+    }
+    nameToCase.set(name, { predicate });
+  }
+  const isProxy = new Proxy({}, {
+    get(_target, prop) {
+      return function isGuard(machine) {
+        const caseConfig = nameToCase.get(prop);
+        if (!caseConfig) {
+          const available = Array.from(nameToCase.keys()).join(", ");
+          throw new Error(
+            `Unknown matcher case: "${prop}". Available cases: ${available}`
+          );
+        }
+        return caseConfig.predicate(machine);
+      };
+    }
+  });
+  const caseProxy = new Proxy({}, {
+    get(_target, prop) {
+      return function createCaseHandler(handler) {
+        if (!nameToCase.has(prop)) {
+          const available = Array.from(nameToCase.keys()).join(", ");
+          throw new Error(
+            `Unknown matcher case: "${prop}". Available cases: ${available}`
+          );
+        }
+        return {
+          __brand: "CaseHandler",
+          __name: prop,
+          __machine: void 0,
+          __return: void 0,
+          handler
+        };
+      };
+    }
+  });
+  const exhaustive = { __exhaustive: true };
+  function when2(machine) {
+    return {
+      is(...handlers) {
+        if (handlers.length === 0) {
+          throw new Error("Pattern match requires at least one handler and exhaustiveness marker");
+        }
+        const lastHandler = handlers[handlers.length - 1];
+        if (!lastHandler || typeof lastHandler !== "object" || !("__exhaustive" in lastHandler)) {
+          throw new Error(
+            "Pattern match must end with match.exhaustive for compile-time exhaustiveness checking"
+          );
+        }
+        const actualHandlers = handlers.slice(0, -1);
+        for (const caseHandler of actualHandlers) {
+          const caseName = caseHandler.__name;
+          const caseConfig = nameToCase.get(caseName);
+          if (!caseConfig) {
+            throw new Error(`Internal error: Unknown matcher case in handler: ${caseName}`);
+          }
+          if (caseConfig.predicate(machine)) {
+            return caseHandler.handler(machine);
+          }
+        }
+        const handledCases = actualHandlers.map((h) => h.__name).join(", ");
+        const allCases = Array.from(nameToCase.keys()).join(", ");
+        throw new Error(
+          `Non-exhaustive pattern match at runtime: no handler matched the machine.
+Handled cases: [${handledCases}]
+All cases: [${allCases}]
+This may occur if predicates don't cover all runtime possibilities.`
+        );
+      }
+    };
+  }
+  function simpleMatcher(machine) {
+    for (const [name, _, predicate] of cases) {
+      if (predicate(machine)) {
+        return name;
+      }
+    }
+    return null;
+  }
+  return Object.assign(simpleMatcher, {
+    is: isProxy,
+    when: when2,
+    case: caseProxy,
+    exhaustive
+  });
+}
+function classCase(name, machineClass) {
+  return [
+    name,
+    void 0,
+    // Type-only, not used at runtime
+    (m) => m instanceof machineClass
+  ];
+}
+function discriminantCase(name, key, value) {
+  return [
+    name,
+    void 0,
+    // Type-only, not used at runtime
+    (m) => hasState(m, key, value)
+  ];
+}
+function customCase(name, predicate) {
+  return [name, void 0, predicate];
+}
+function forContext() {
+  return {
+    /**
+     * Creates a discriminated union case with full type inference.
+     */
+    case(name, key, value) {
+      return [
+        name,
+        void 0,
+        (m) => hasState(m, key, value)
+      ];
+    }
+  };
+}
+
 // src/index.ts
 function createMachine(context, fnsOrFactory) {
   if (typeof fnsOrFactory === "function") {
@@ -2192,6 +1885,9 @@ function setContext(machine, newContextOrFn) {
   const newContext = typeof newContextOrFn === "function" ? newContextOrFn(context) : newContextOrFn;
   return createMachine(newContext, transitions);
 }
+function createContext(context) {
+  return { context };
+}
 function overrideTransitions(machine, overrides) {
   const { context, ...originalTransitions } = machine;
   const newTransitions = { ...originalTransitions, ...overrides };