@jsenv/navi 0.30.25 → 0.30.26

package/dist/jsenv_navi.js

@@ -3535,6 +3535,7 @@ const updateActions = ({
 
       const actionToRunPrivateProperties =
         getActionPrivateProperties(actionToPrerunOrRun);
+      actionToRunPrivateProperties.answeredAsync = false;
       let performRunResult;
       try {
         performRunResult = actionToRunPrivateProperties.performRun({
@@ -3559,6 +3560,7 @@ const updateActions = ({
       activationWeakSet.add(actionToPrerunOrRun);
 
       if (performRunResult && typeof performRunResult.then === "function") {
+        actionToRunPrivateProperties.answeredAsync = true;
         actionPromiseMap.set(actionToPrerunOrRun, performRunResult);
         allThenableArray.push(performRunResult);
         hasAsync = true;
@@ -3588,7 +3590,9 @@ const updateActions = ({
 
     // Execute promotions (prerun -> run requested)
     for (const actionToPromote of willPromoteSet) {
-      actionToPromote.isPrerunSignal.value = false;
+      writeActionState(() => {
+        actionToPromote.isPrerunSignal.value = false;
+      });
     }
   }
 
@@ -3597,13 +3601,21 @@ const updateActions = ({
   // that IS carrying it. `await action.run()` then means the same thing to
   // every caller: the second one waits for the first one's request and reads
   // the same data, instead of being handed `undefined` before the network has
-  // said anything. See the run() JSDoc.
+  // said anything. It answers in the tense of that run: the answer of a run
+  // that answered with a promise comes back as one, so `run().catch()` holds
+  // whatever state the instance is in. See the run() JSDoc.
   {
     for (const actionToJoin of willJoinSet) {
       const runningPromise = actionPromiseMap.get(actionToJoin);
       if (runningPromise) {
         hasAsync = true;
         resultArray.push({ type: "async", promise: runningPromise });
+      } else if (getActionPrivateProperties(actionToJoin).answeredAsync) {
+        hasAsync = true;
+        resultArray.push({
+          type: "async",
+          promise: Promise.resolve(actionToJoin.dataSignal.peek()),
+        });
       } else {
         resultArray.push({
           type: "sync",
@@ -3809,6 +3821,10 @@ const createAction = (callback, rootOptions = {}) => {
      * the one that asked first or the one that arrived while the request was
      * out. Use `rerun()` to force a fresh run ("refresh", "check now", any
      * explicit user intent to go back to the network).
+     *
+     * An asynchronous callback answers with a promise, joined or not:
+     * `ACTION.run().catch(…)` holds in every state. A synchronous one answers
+     * synchronously, and throws its failure.
      */
     const run = (options) => {
       action.debug(`${action}.run(${stringifyForDisplay(options)})`);
@@ -4267,7 +4283,9 @@ const createAction = (callback, rootOptions = {}) => {
             // another run's, or idle.
             return;
           }
-          runningStateSignal.value = ABORTED;
+          writeActionState(() => {
+            runningStateSignal.value = ABORTED;
+          });
           internalAbortController.abort(abortReason);
           actionAbortMap.delete(action);
           if (isPrerun && (globalAbortSignal.aborted || abortSignal.aborted)) {
@@ -4291,7 +4309,7 @@ const createAction = (callback, rootOptions = {}) => {
 
         actionAbortMap.set(action, abort);
 
-        batch(() => {
+        writeActionState(() => {
           if (valueSignal.peek() === undefined) {
             // An action saying nothing of its own may still have a value the
             // page kept from the previous document (see kept_values.js).
@@ -4370,7 +4388,7 @@ const createAction = (callback, rootOptions = {}) => {
            * before the UI attempts to render the now-missing resource.
            */
 
-          batch(() => {
+          writeActionState(() => {
             const value = resultToValue
               ? resultToValue(runResult, action)
               : runResult;
@@ -4399,7 +4417,9 @@ const createAction = (callback, rootOptions = {}) => {
               error === internalAbortSignal.reason) ||
             error.name === "AbortError";
           if (isAbort) {
-            runningStateSignal.value = ABORTED;
+            writeActionState(() => {
+              runningStateSignal.value = ABORTED;
+            });
             if (isPrerun && abortSignal.aborted) {
               prerunProtectionRegistry.unprotect(action);
             }
@@ -4410,7 +4430,7 @@ const createAction = (callback, rootOptions = {}) => {
           if (isPrerun) {
             markErrorAsPrerunFailure(error);
           }
-          batch(() => {
+          writeActionState(() => {
             errorSignal.value = error;
             runningStateSignal.value = FAILED;
             onError?.(error, { event, action, args });
@@ -4502,7 +4522,7 @@ const createAction = (callback, rootOptions = {}) => {
         }
 
         actionPromiseMap.delete(action);
-        batch(() => {
+        writeActionState(() => {
           if (!willRunOrPrerun) {
             errorSignal.value = undefined;
             valueSignal.value = valueInitial;
@@ -4520,6 +4540,9 @@ const createAction = (callback, rootOptions = {}) => {
         provisionalValue,
         inheritData,
         keepsAnswers: keptAnswerRegistry !== null,
+        // Whether the last run answered with a promise, written by
+        // updateActions: the tense a run joining this instance answers in.
+        answeredAsync: false,
 
         performRun,
         performReset,
@@ -5003,6 +5026,35 @@ const isPlainObject$2 = (obj) => {
   );
 };
 
+// Every state write of a run (start, end, failure, abort, reset), batched. At
+// the end of the batch preact runs the effects those writes woke up, anywhere
+// in the app, and rethrows the first one that threw: from there it would fail
+// this run, or leave it RUNNING, or stop the update half way. That throw is
+// the effect's, so it is reported on its own, as action_error_report.js
+// reports an error (thrown from a timer), and the action carries on. What
+// `write` throws (resultToValue, onComplete…) is the run's, and goes on.
+const writeActionState = (write) => {
+  let writeThrew = false;
+  let writeError;
+  try {
+    batch(() => {
+      try {
+        write();
+      } catch (e) {
+        writeThrew = true;
+        writeError = e;
+      }
+    });
+  } catch (effectError) {
+    setTimeout(() => {
+      throw effectError;
+    });
+  }
+  if (writeThrew) {
+    throw writeError;
+  }
+};
+
 /**
  * Reactively runs an action whenever the params derived from signals change.
  *