@doeixd/machine 0.0.23 → 1.0.2

package/dist/cjs/development/index.js

@@ -33,6 +33,7 @@ __export(src_exports, {
   bindTransitions: () => bindTransitions,
   branch: () => branch,
   call: () => call,
+  callWithContext: () => callWithContext,
   chain: () => chain,
   classCase: () => classCase,
   combine: () => combine,
@@ -42,6 +43,7 @@ __export(src_exports, {
   createActor: () => createActor,
   createAsyncMachine: () => createAsyncMachine,
   createContext: () => createContext,
+  createContextBoundMachine: () => createContextBoundMachine,
   createCustomMiddleware: () => createCustomMiddleware,
   createEnsemble: () => createEnsemble,
   createEnsembleFactory: () => createEnsembleFactory,
@@ -79,6 +81,7 @@ __export(src_exports, {
   inDevelopment: () => inDevelopment,
   invoke: () => invoke,
   isConditionalMiddleware: () => isConditionalMiddleware,
+  isContextBound: () => isContextBound,
   isMiddlewareContext: () => isMiddlewareContext,
   isMiddlewareError: () => isMiddlewareError,
   isMiddlewareFn: () => isMiddlewareFn,
@@ -131,6 +134,32 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/internal-transitions.ts
+var TRANSITIONS_SYMBOL = Symbol.for("__machine_transitions__");
+function attachTransitions(machine, transitions) {
+  Object.defineProperty(machine, TRANSITIONS_SYMBOL, {
+    value: transitions,
+    enumerable: false,
+    configurable: false
+  });
+  return machine;
+}
+function getStoredTransitions(machine) {
+  if (!machine || typeof machine !== "object") {
+    return void 0;
+  }
+  return machine[TRANSITIONS_SYMBOL];
+}
+function snapshotOwnTransitions(source) {
+  if (!source || typeof source !== "object") {
+    return {};
+  }
+  const entries = Object.entries(source).filter(
+    ([key, value]) => key !== "context" && typeof value === "function"
+  );
+  return Object.fromEntries(entries);
+}
+
 // src/generators.ts
 function run(flow, initial) {
   const generator = flow(initial);
@@ -261,8 +290,8 @@ function guard(condition, transition, options = {}) {
     const ctx = isMachine ? this.context : this;
     const conditionResult = condition(ctx, ...args);
     if (conditionResult) {
-      const contextForTransition = isMachine ? this.context : this;
-      return transition.apply(contextForTransition, args);
+      const machineForTransition = isMachine ? this : { context: this };
+      return transition.apply(machineForTransition, args);
     } else {
       if (onFail === "throw") {
         const message = errorMessage || "Guard condition failed";
@@ -302,8 +331,8 @@ function guardAsync(condition, transition, options = {}) {
     const ctx = isMachine ? this.context : this;
     const conditionResult = await Promise.resolve(condition(ctx, ...args));
     if (conditionResult) {
-      const contextForTransition = isMachine ? this.context : this;
-      return transition.apply(contextForTransition, args);
+      const machineForTransition = isMachine ? this : { context: this };
+      return transition.apply(machineForTransition, args);
     } else {
       if (onFail === "throw") {
         const message = errorMessage || "Guard condition failed";
@@ -384,7 +413,7 @@ function createRunner(initialMachine, onChange) {
         return void 0;
       }
       return (...args) => {
-        const nextState = transition.apply(currentMachine.context, args);
+        const nextState = transition.apply(currentMachine, args);
         const nextStateWithTransitions = Object.assign(
           { context: nextState.context },
           originalTransitions
@@ -427,7 +456,7 @@ function createEnsemble(store, factories, getDiscriminant) {
         );
       }
       return (...args) => {
-        return action2.apply(currentMachine.context, args);
+        return action2.apply(currentMachine, args);
       };
     }
   });
@@ -578,7 +607,7 @@ function createMutableMachine(sharedContext, factories, getDiscriminant) {
       const transition = currentMachine[prop];
       if (typeof transition === "function") {
         return (...args) => {
-          const nextContext = transition.apply(currentMachine.context, args);
+          const nextContext = transition.apply(currentMachine, 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;
@@ -700,14 +729,14 @@ function createParallelMachine(m1, m2) {
   for (const key in transitions1) {
     const transitionFn = transitions1[key];
     combinedTransitions[key] = (...args) => {
-      const nextM1 = transitionFn.apply(m1.context, args);
+      const nextM1 = transitionFn.apply(m1, args);
       return createParallelMachine(nextM1, m2);
     };
   }
   for (const key in transitions2) {
     const transitionFn = transitions2[key];
     combinedTransitions[key] = (...args) => {
-      const nextM2 = transitionFn.apply(m2.context, args);
+      const nextM2 = transitionFn.apply(m2, args);
       return createParallelMachine(m1, nextM2);
     };
   }
@@ -1178,7 +1207,7 @@ function withTimeTravel(machine, options = {}) {
     for (const entry of transitionsToReplay) {
       const transitionFn = replayedMachine[entry.transitionName];
       if (transitionFn) {
-        replayedMachine = transitionFn.apply(replayedMachine.context, entry.args);
+        replayedMachine = transitionFn.apply(replayedMachine, entry.args);
       }
     }
     return replayedMachine;
@@ -1696,8 +1725,8 @@ function createTransition(getTransitions, transformer) {
     return createMachine(nextContext, getTransitions());
   };
 }
-function call(fn, context, ...args) {
-  return fn.apply(context, args);
+function call(fn, machine, ...args) {
+  return fn.apply(machine, args);
 }
 function bindTransitions(machine) {
   return new Proxy(machine, {
@@ -1705,7 +1734,7 @@ function bindTransitions(machine) {
       const value = target[prop];
       if (typeof value === "function") {
         return function(...args) {
-          const result = value.apply(target.context, args);
+          const result = value.apply(target, args);
           if (result && typeof result === "object" && "context" in result) {
             return bindTransitions(result);
           }
@@ -1730,7 +1759,7 @@ var BoundMachine = class _BoundMachine {
         const value = this.wrappedMachine[prop];
         if (typeof value === "function") {
           return (...args) => {
-            const result = value.apply(this.wrappedMachine.context, args);
+            const result = value.apply(this.wrappedMachine, args);
             if (result && typeof result === "object" && "context" in result) {
               return new _BoundMachine(result);
             }
@@ -2006,7 +2035,7 @@ var _Actor = class _Actor {
       }
       let result;
       try {
-        result = fn.apply(this._state.context, event.args);
+        result = fn.apply(this._state, event.args);
       } catch (error) {
         console.error(`[Actor] Error in transition '${String(event.type)}':`, error);
         continue;
@@ -2084,62 +2113,73 @@ function fromObservable(observable) {
   return actor;
 }
 
+// src/context-bound.ts
+function createContextBoundMachine(initialContext, transformers) {
+  const savedTransformers = transformers;
+  const boundTransitions = Object.fromEntries(
+    Object.entries(transformers).map(([key, transformer]) => [
+      key,
+      function(...args) {
+        const contextOnly = { context: this.context };
+        const newContext = transformer.apply(contextOnly, args);
+        return createContextBoundMachine(newContext, savedTransformers);
+      }
+    ])
+  );
+  Object.values(boundTransitions).forEach((fn) => {
+    if (typeof fn === "function") {
+      Object.defineProperty(fn, "__contextBound", {
+        value: true,
+        enumerable: false
+      });
+    }
+  });
+  return attachTransitions(
+    Object.assign({ context: initialContext }, boundTransitions),
+    boundTransitions
+  );
+}
+function callWithContext(machine, transitionName, ...args) {
+  const fn = machine[transitionName];
+  const contextOnly = { context: machine.context };
+  return fn.apply(contextOnly, args);
+}
+function isContextBound(machine) {
+  const firstTransition = Object.values(machine).find(
+    (v) => typeof v === "function"
+  );
+  if (!firstTransition) return false;
+  return firstTransition.__contextBound === true;
+}
+
 // src/index.ts
 function createMachine(context, fnsOrFactory) {
   if (typeof fnsOrFactory === "function") {
     let transitions2;
     const transition = (newContext) => {
-      const machine2 = createMachine(newContext, transitions2);
-      const boundTransitions2 = Object.fromEntries(
-        Object.entries(transitions2).map(([key, fn]) => [
-          key,
-          fn.bind(newContext)
-        ])
-      );
-      return Object.assign(machine2, boundTransitions2);
+      return createMachine(newContext, transitions2);
     };
     transitions2 = fnsOrFactory(transition);
-    const boundTransitions = Object.fromEntries(
-      Object.entries(transitions2).map(([key, fn]) => [
-        key,
-        fn.bind(context)
-      ])
-    );
-    return Object.assign({ context }, boundTransitions);
+    return attachTransitions(Object.assign({ context }, transitions2), transitions2);
   }
-  const transitions = "context" in fnsOrFactory ? Object.fromEntries(
-    Object.entries(fnsOrFactory).filter(([key]) => key !== "context")
-  ) : fnsOrFactory;
+  const stored = getStoredTransitions(fnsOrFactory);
+  const transitions = stored != null ? stored : "context" in fnsOrFactory ? snapshotOwnTransitions(fnsOrFactory) : fnsOrFactory;
   const machine = Object.assign({ context }, transitions);
-  return machine;
+  return attachTransitions(machine, transitions);
 }
 function createAsyncMachine(context, fnsOrFactory) {
   if (typeof fnsOrFactory === "function") {
     let transitions2;
     const transition = (newContext) => {
-      const machine2 = createAsyncMachine(newContext, transitions2);
-      const boundTransitions2 = Object.fromEntries(
-        Object.entries(transitions2).map(([key, fn]) => [
-          key,
-          fn.bind(newContext)
-        ])
-      );
-      return Object.assign(machine2, boundTransitions2);
+      return createAsyncMachine(newContext, transitions2);
     };
     transitions2 = fnsOrFactory(transition);
-    const boundTransitions = Object.fromEntries(
-      Object.entries(transitions2).map(([key, fn]) => [
-        key,
-        fn.bind(context)
-      ])
-    );
-    return Object.assign({ context }, boundTransitions);
+    return attachTransitions(Object.assign({ context }, transitions2), transitions2);
   }
-  const transitions = "context" in fnsOrFactory ? Object.fromEntries(
-    Object.entries(fnsOrFactory).filter(([key]) => key !== "context")
-  ) : fnsOrFactory;
+  const stored = getStoredTransitions(fnsOrFactory);
+  const transitions = stored != null ? stored : "context" in fnsOrFactory ? snapshotOwnTransitions(fnsOrFactory) : fnsOrFactory;
   const machine = Object.assign({ context }, transitions);
-  return machine;
+  return attachTransitions(machine, transitions);
 }
 function createMachineFactory() {
   return (transformers) => {
@@ -2158,8 +2198,10 @@ function createMachineFactory() {
   };
 }
 function setContext(machine, newContextOrFn) {
-  const { context, ...transitions } = machine;
-  const newContext = typeof newContextOrFn === "function" ? newContextOrFn(context) : newContextOrFn;
+  var _a;
+  const currentContext = machine.context;
+  const transitions = (_a = getStoredTransitions(machine)) != null ? _a : snapshotOwnTransitions(machine);
+  const newContext = typeof newContextOrFn === "function" ? newContextOrFn(currentContext) : newContextOrFn;
   return createMachine(newContext, transitions);
 }
 function createContext(context) {
@@ -2218,7 +2260,7 @@ function runMachine(initial, onChange) {
     const controller = new AbortController();
     activeController = controller;
     try {
-      const nextStatePromise = fn.apply(current.context, [...event.args, { signal: controller.signal }]);
+      const nextStatePromise = fn.apply(current, [...event.args, { signal: controller.signal }]);
       const nextState = await nextStatePromise;
       if (controller.signal.aborted) {
         return current;
@@ -2258,7 +2300,6 @@ var MachineBase = class {
   }
 };
 function next(m, update) {
-  const { context, ...transitions } = m;
-  return createMachine(update(context), transitions);
+  return setContext(m, (ctx) => update(ctx));
 }
 //# sourceMappingURL=index.js.map