@doeixd/machine 0.0.8 → 0.0.10

package/dist/cjs/development/index.js

@@ -20,6 +20,7 @@ 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,
   META_KEY: () => META_KEY,
   MachineBase: () => MachineBase,
@@ -61,6 +62,7 @@ __export(src_exports, {
   generateChart: () => generateChart,
   generateStatechart: () => generateStatechart,
   guard: () => guard,
+  guardAsync: () => guardAsync,
   guarded: () => guarded,
   hasState: () => hasState,
   inDevelopment: () => inDevelopment,
@@ -90,6 +92,7 @@ __export(src_exports, {
   when: () => when,
   whenContext: () => whenContext,
   whenGuard: () => whenGuard,
+  whenGuardAsync: () => whenGuardAsync,
   withAnalytics: () => withAnalytics,
   withDebugging: () => withDebugging,
   withErrorReporting: () => withErrorReporting,
@@ -228,6 +231,47 @@ function action(action2, transition) {
   return transition;
 }
 function guard(condition, transition, options = {}) {
+  const { onFail = "throw", errorMessage, description } = options;
+  const fullOptions = { ...options, onFail, errorMessage, description };
+  const guardedTransition = function(...args) {
+    const isMachine = typeof this === "object" && "context" in this;
+    const ctx = isMachine ? this.context : this;
+    const conditionResult = condition(ctx, ...args);
+    if (conditionResult) {
+      const contextForTransition = isMachine ? this.context : this;
+      return transition.apply(contextForTransition, args);
+    } else {
+      if (onFail === "throw") {
+        const message = errorMessage || "Guard condition failed";
+        throw new Error(message);
+      } else if (onFail === "ignore") {
+        if (isMachine) {
+          return this;
+        } else {
+          throw new Error('Cannot use "ignore" mode with context-only binding. Use full machine binding or provide fallback.');
+        }
+      } else if (typeof onFail === "function") {
+        if (isMachine) {
+          return onFail.apply(this, args);
+        } else {
+          throw new Error("Cannot use function fallback with context-only binding. Use full machine binding.");
+        }
+      } else {
+        return onFail;
+      }
+    }
+  };
+  Object.defineProperty(guardedTransition, "__guard", { value: true, enumerable: false });
+  Object.defineProperty(guardedTransition, "condition", { value: condition, enumerable: false });
+  Object.defineProperty(guardedTransition, "transition", { value: transition, enumerable: false });
+  Object.defineProperty(guardedTransition, "options", { value: fullOptions, enumerable: false });
+  attachRuntimeMeta(guardedTransition, {
+    description: description || "Synchronous guarded transition",
+    guards: [{ name: "runtime_guard", description: description || "Synchronous condition check" }]
+  });
+  return guardedTransition;
+}
+function guardAsync(condition, transition, options = {}) {
   const { onFail = "throw", errorMessage, description } = options;
   const fullOptions = { ...options, onFail, errorMessage, description };
   const guardedTransition = async function(...args) {
@@ -283,6 +327,21 @@ function whenGuard(condition) {
     }
   };
 }
+function whenGuardAsync(condition) {
+  return {
+    /**
+     * Define the transition to execute when the condition passes.
+     * Returns a guarded transition that can optionally have an else clause.
+     */
+    do(transition) {
+      const guarded2 = guardAsync(condition, transition);
+      guarded2.else = function(fallback) {
+        return guardAsync(condition, transition, { onFail: fallback });
+      };
+      return guarded2;
+    }
+  };
+}
 function metadata(_meta, value) {
   return value;
 }
@@ -416,6 +475,36 @@ function extractFromCallExpression(call2, verbose = false) {
         }
       }
       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;
   }
@@ -657,6 +746,37 @@ function generateChart() {
     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();
 }