aifsmjs 0.2.1 → 0.3.1

package/dist/pbt/index.d.cts

@@ -1,5 +1,5 @@
 import * as fc from 'fast-check';
-import { i as Runtime, M as MachineDef, I as Implementations } from '../types-BLwKAHnW.cjs';
+import { i as Runtime, M as MachineDef, I as Implementations } from '../types-CGKk6Rur.cjs';
 
 /**
  * Pure-model representation of an FSM run, used by `fc.commands`.

package/dist/pbt/index.d.ts

@@ -1,5 +1,5 @@
 import * as fc from 'fast-check';
-import { i as Runtime, M as MachineDef, I as Implementations } from '../types-BLwKAHnW.js';
+import { i as Runtime, M as MachineDef, I as Implementations } from '../types-CGKk6Rur.js';
 
 /**
  * Pure-model representation of an FSM run, used by `fc.commands`.

package/dist/pbt/index.js

@@ -248,6 +248,18 @@ var RuntimeDisposedError = class extends Error {
     this.name = "RuntimeDisposedError";
   }
 };
+var SubMachineError = class extends Error {
+  parentState;
+  phase;
+  cause;
+  constructor(parentState, phase, cause) {
+    super(`aifsmjs: sub-machine ${phase} failed at parent state "${parentState}"`, { cause });
+    this.name = "SubMachineError";
+    this.parentState = parentState;
+    this.phase = phase;
+    this.cause = cause;
+  }
+};
 var RESET_EVENT = Object.freeze({ type: RESET_EVENT_TYPE });
 function composeMiddleware(middleware) {
   return (ctx, finalNext) => {
@@ -272,6 +284,8 @@ function createRuntime(def, impl, opts = {}) {
   const shouldDispatch = opts.dispatchEffects !== false;
   const controller = new AbortController();
   let disposed = false;
+  let childRuntime;
+  let childAbortCleanup;
   const eventListeners = {
     transition: /* @__PURE__ */ new Set(),
     error: /* @__PURE__ */ new Set(),
@@ -287,14 +301,7 @@ function createRuntime(def, impl, opts = {}) {
   }
   function runMiddleware(prev, event, effects, changed) {
     if (!middlewareChain) return;
-    const mwCtx = deepFreeze({
-      prev,
-      next: snapshot,
-      event,
-      effects,
-      changed
-    });
-    middlewareChain(mwCtx, () => {
+    middlewareChain(deepFreeze({ prev, next: snapshot, event, effects, changed }), () => {
     });
   }
   function dispatchEffects(effects, context, event) {
@@ -305,52 +312,128 @@ function createRuntime(def, impl, opts = {}) {
       const r = handler(eff, { context, event, signal: controller.signal });
       if (r instanceof Promise) {
         r.catch((err) => {
-          const payload = { error: err, event };
-          emit("error", payload);
+          emit("error", { error: err, event });
         });
       }
     }
   }
+  function wireChildAbort(child) {
+    if (controller.signal.aborted) {
+      try {
+        child.dispose();
+      } catch {
+      }
+      return () => {
+      };
+    }
+    const onAbort = () => {
+      try {
+        child.dispose();
+      } catch {
+      }
+    };
+    controller.signal.addEventListener("abort", onAbort, { once: true });
+    return () => controller.signal.removeEventListener("abort", onAbort);
+  }
+  function findChosenIsExternal(value, event, context) {
+    const state = def.states[value];
+    if (!state?.on) return false;
+    const candidates = state.on[event.type];
+    if (!candidates) return false;
+    const list = Array.isArray(candidates) ? candidates : [candidates];
+    for (const t of list) {
+      if (!t.guard || evalGuard(t.guard, context, event, impl, value)) {
+        return t.target !== void 0;
+      }
+    }
+    return false;
+  }
+  function applySubLifecycle(prevValue, nextValue) {
+    const prevStateDef = def.states[prevValue];
+    const nextStateDef = def.states[nextValue];
+    if (prevStateDef?.sub !== void 0 && childRuntime !== void 0) {
+      const child = childRuntime;
+      childRuntime = void 0;
+      childAbortCleanup?.();
+      childAbortCleanup = void 0;
+      try {
+        child.dispose();
+      } catch (cause) {
+        throw new SubMachineError(prevValue, "dispose", cause);
+      }
+    }
+    if (nextStateDef?.sub !== void 0) {
+      let newChild;
+      try {
+        newChild = createRuntime(nextStateDef.sub, nextStateDef.subImpl ?? {});
+      } catch (cause) {
+        throw new SubMachineError(nextValue, "init", cause);
+      }
+      childRuntime = newChild;
+      childAbortCleanup = wireChildAbort(newChild);
+    }
+  }
   function send(event) {
     if (disposed) throw new RuntimeDisposedError();
     const prev = snapshot;
     const result = step(def, prev, event, impl);
+    const isExternal = result.changed && (prev.value !== result.snapshot.value || findChosenIsExternal(prev.value, event, prev.context));
+    if (result.changed && isExternal) applySubLifecycle(prev.value, result.snapshot.value);
     snapshot = result.snapshot;
     const committed = result.snapshot;
     runMiddleware(prev, event, result.effects, result.changed);
-    if (shouldDispatch) {
-      dispatchEffects(result.effects, committed.context, event);
-    }
+    if (shouldDispatch) dispatchEffects(result.effects, committed.context, event);
     if (result.changed) {
       notify(committed);
-      const payload = {
+      emit("transition", {
         prev,
         next: committed,
         event,
         effects: result.effects,
         changed: true
-      };
-      emit("transition", payload);
+      });
     }
     return snapshot;
   }
   function reset(event) {
     if (disposed) throw new RuntimeDisposedError();
     const prev = snapshot;
-    snapshot = initialSnapshot(def);
-    const changed = prev.value !== snapshot.value;
+    const nextSnap = initialSnapshot(def);
+    const changed = prev.value !== nextSnap.value;
+    if (childRuntime) {
+      const child = childRuntime;
+      childRuntime = void 0;
+      childAbortCleanup?.();
+      childAbortCleanup = void 0;
+      try {
+        child.dispose();
+      } catch (cause) {
+        throw new SubMachineError(prev.value, "dispose", cause);
+      }
+    }
+    const initStateDef = def.states[nextSnap.value];
+    if (initStateDef?.sub) {
+      let newChild;
+      try {
+        newChild = createRuntime(initStateDef.sub, initStateDef.subImpl ?? {});
+      } catch (cause) {
+        throw new SubMachineError(nextSnap.value, "init", cause);
+      }
+      childRuntime = newChild;
+      childAbortCleanup = wireChildAbort(newChild);
+    }
+    snapshot = nextSnap;
     const triggerEvent = event ?? RESET_EVENT;
     runMiddleware(prev, triggerEvent, [], changed);
     if (changed) {
       notify();
-      const payload = {
+      emit("transition", {
         prev,
         next: snapshot,
         event: triggerEvent,
         effects: [],
         changed: true
-      };
-      emit("transition", payload);
+      });
     }
     return snapshot;
   }
@@ -371,36 +454,43 @@ function createRuntime(def, impl, opts = {}) {
     if (disposed || options?.signal?.aborted) return () => {
     };
     const target = eventListeners[type];
+    let detachAbort;
+    const cleanup = () => {
+      target.delete(wrapped);
+      if (detachAbort) {
+        detachAbort();
+        externalAbortCleanups.delete(detachAbort);
+      }
+    };
     let wrapped = listener;
     if (options?.once) {
       wrapped = (payload) => {
-        target.delete(wrapped);
+        cleanup();
         listener(payload);
       };
     }
     target.add(wrapped);
-    let detachAbort;
     const signal = options?.signal;
     if (signal) {
-      const onAbort = () => {
-        target.delete(wrapped);
-        if (detachAbort) externalAbortCleanups.delete(detachAbort);
-      };
+      const onAbort = () => cleanup();
       signal.addEventListener("abort", onAbort, { once: true });
       detachAbort = () => signal.removeEventListener("abort", onAbort);
       externalAbortCleanups.add(detachAbort);
     }
-    return () => {
-      target.delete(wrapped);
-      if (detachAbort) {
-        detachAbort();
-        externalAbortCleanups.delete(detachAbort);
-      }
-    };
+    return cleanup;
   }
   function dispose() {
     if (disposed) return;
     disposed = true;
+    if (childRuntime) {
+      childAbortCleanup?.();
+      childAbortCleanup = void 0;
+      try {
+        childRuntime.dispose();
+      } catch {
+      }
+      childRuntime = void 0;
+    }
     controller.abort();
     listeners.clear();
     emit("dispose", void 0);
@@ -408,7 +498,7 @@ function createRuntime(def, impl, opts = {}) {
     for (const cleanup of externalAbortCleanups) cleanup();
     externalAbortCleanups.clear();
   }
-  return {
+  const runtime = {
     getSnapshot: () => snapshot,
     snapshot: () => snapshot,
     send,
@@ -427,8 +517,22 @@ function createRuntime(def, impl, opts = {}) {
       };
       listeners.add(listener);
       return () => listeners.delete(listener);
-    }
+    },
+    subRuntime: () => childRuntime,
+    onTransition: (handler, options) => on("transition", handler, options)
   };
+  const bootStateDef = def.states[snapshot.value];
+  if (bootStateDef?.sub) {
+    let newChild;
+    try {
+      newChild = createRuntime(bootStateDef.sub, bootStateDef.subImpl ?? {});
+    } catch (cause) {
+      throw new SubMachineError(snapshot.value, "init", cause);
+    }
+    childRuntime = newChild;
+    childAbortCleanup = wireChildAbort(newChild);
+  }
+  return runtime;
 }
 
 // src/fsm/definition.ts