@jsenv/navi 0.29.325 → 0.29.327

package/dist/dev/jsenv_navi.js

@@ -3235,6 +3235,15 @@ const resolveActionProxies = (actionSet) => {
 
 const NO_PARAMS = { __no_params__: true };
 const mergeActionParams = (currentParams, newParams) => {
+  if (newParams === null) {
+    // `null` is a question that cannot be asked: a callback destructuring its
+    // params throws on it. It is what a computed says when it has not got
+    // enough to ask with, and "nothing to ask" is said with `undefined`
+    // everywhere below (and by the run guards reading paramsSignal), so it
+    // becomes that here, at the one door params coming from a binding go
+    // through.
+    newParams = undefined;
+  }
   // The order of these two checks is load-bearing. Checking `undefined` first
   // looks symmetric — "no new params, keep whatever is there, NO_PARAMS
   // included" — and breaks routing: merge(NO_PARAMS, undefined) must yield
@@ -3492,7 +3501,10 @@ const createAction = (callback, rootOptions = {}) => {
      *
      * @param {any} newParamsOrSignal - params, or a signal holding them (the
      *   result then retargets itself as the signal changes), or an object whose
-     *   values may be signals.
+     *   values may be signals. A signal with nothing to ask yet — a question
+     *   computed from a form still missing a field — holds `undefined` or
+     *   `null`: the instance then has no params, which is what
+     *   `useAsyncData(action, { run: true })` reads to start nothing.
      * @param {object} [options]
      * @param {number} [options.debounce] - milliseconds the params must stay
      *   stable before the instance follows them. What it buys is a screen that
@@ -11276,9 +11288,11 @@ const swipeTypeOf = (axis, pulled) => {
  * copy is captured where it lands rather than where it was let go of.
  *
  * And the promise matters in both cases: the gesture holds its copy until the
- * answer settles. Returning the transition is what makes a landing continuous; a
- * `toss` that rejects brings the copy back, because the thing still exists and the
- * screen has to say so.
+ * answer settles. Returning the transition is what makes a landing continuous;
+ * rejecting brings the copy back over the original, because the thing still
+ * exists and the screen has to say so. That holds for every outcome that carries
+ * a copy — `land` and `reorder` as much as `toss` and `leave` — so a place can be
+ * asked about rather than taken: refuse, and the board is as it was.
  *
  * Starting a document transition is the application's call and not navi's: a
  * `view-transition-name` must be unique per document, so only the application can
@@ -17101,6 +17115,11 @@ const generateSignalId = () => {
  *   as the user moved. `"push"` is for a state whose values ARE places one came
  *   from (the photo one is looking at in a gallery). Whatever is said here, one
  *   write can say otherwise: `signal.set(value, { history })`.
+ *   Either way every write reaches the address, synchronously, and browsers
+ *   refuse an address written too often (Safari: 100 writes per 10 s, then a
+ *   SecurityError). A value one DRAGS is written at 60 Hz: keep it in the
+ *   gesture while the finger is down and write the state once, on release —
+ *   an address is not a recording of a gesture.
  * @param {boolean} [options.debug=false] - Enable debug logging for this signal's operations
  * @returns {import("@preact/signals").Signal} A signal that can be synchronized with a source signal and/or persisted in localStorage. The signal includes a `validity` property for validation state.
  *
@@ -27294,11 +27313,7 @@ const setupBrowserIntegrationViaHistory = ({
           [NAV_DEPTH_STATE_KEY]: getNavDepth(),
         },
       });
-      if (navigationType === "push") {
-        window.history.pushState(effectiveState, null, url);
-      } else {
-        window.history.replaceState(effectiveState, null, url);
-      }
+      writeHistoryEntry(navigationType, effectiveState, url);
       rememberEntryIsOfThisDocument();
       updateDocumentUrl(url);
       updateDocumentState(effectiveState);
@@ -27318,14 +27333,14 @@ const setupBrowserIntegrationViaHistory = ({
             [NAV_DEPTH_STATE_KEY]: getNavDepth(),
           },
         });
-        window.history.replaceState(state, null, url);
+        writeHistoryEntry("replace", state, url);
         rememberEntryIsOfThisDocument();
       } else if (redirected) {
         // The entry the browser is on names an address that only sends
         // elsewhere — a cold load on it, or a back into it. Written over where
         // it stands (the entry keeps its place in the stack, hence its state
         // and the depth in it): pressing back must not walk into it again.
-        window.history.replaceState(state, null, url);
+        writeHistoryEntry("replace", state, url);
         rememberEntryIsOfThisDocument();
       }
       updateDocumentUrl(url);
@@ -27578,7 +27593,7 @@ const setupBrowserIntegrationViaHistory = ({
       // The entry itself has to lose them too, not just the document state:
       // getDocumentState() reads the entry back, and every state write copies
       // what it finds there onto the next one.
-      window.history.replaceState(state, null, url);
+      writeHistoryEntry("replace", state, url);
     }
     handleRoutingTask(url, {
       reason: "routing initialization",
@@ -27605,6 +27620,57 @@ const setupBrowserIntegrationViaHistory = ({
 // replace onto the url already displayed. Never a traverse — the browser has
 // already moved window.location.href when a popstate is handled, so the
 // comparison would say "same" about every back and forward.
+// Browsers refuse an address written too often: WebKit throws a SecurityError
+// past 100 writes per 10 seconds, Chromium and Firefox drop the write. A state
+// bound to the url and written per frame gets there in under two seconds, and
+// a developer working in Chromium never sees it. Every write goes through here
+// so the rate is measured against the strictest budget before any browser
+// refuses, and so a refusal names its cause rather than `replaceState`.
+const HISTORY_WRITE_BUDGET = 100;
+const HISTORY_WRITE_WINDOW_MS = 10_000;
+const ADDRESS_WRITE_ADVICE = `An address is not a recording of a gesture: a value dragged per frame belongs to the gesture, and the state bound to the url is written once, on release.`;
+const writeHistoryEntry = (navigationType, state, url) => {
+  noteHistoryWrite(url);
+  try {
+    if (navigationType === "push") {
+      window.history.pushState(state, null, url);
+    } else {
+      window.history.replaceState(state, null, url);
+    }
+  } catch (e) {
+    if (e.name !== "SecurityError") {
+      throw e;
+    }
+    throw new Error(
+      `The browser refused to write the address ${url}: ${e.message}. ${ADDRESS_WRITE_ADVICE}`,
+      { cause: e },
+    );
+  }
+};
+const noteHistoryWrite = (() => {
+      const writeTimes = [];
+      let warned = false;
+      return (url) => {
+        if (warned) {
+          return;
+        }
+        const now = performance.now();
+        writeTimes.push(now);
+        while (writeTimes[0] < now - HISTORY_WRITE_WINDOW_MS) {
+          writeTimes.shift();
+        }
+        if (writeTimes.length < HISTORY_WRITE_BUDGET) {
+          return;
+        }
+        warned = true;
+        const seconds = ((now - writeTimes[0]) / 1000).toFixed(1);
+        console.warn(
+          `[navi] the address was written ${HISTORY_WRITE_BUDGET} times in ${seconds}s (last: ${url}). Safari refuses more than ${HISTORY_WRITE_BUDGET} writes per ${HISTORY_WRITE_WINDOW_MS / 1000}s with a SecurityError, and the state then runs ahead of the address. ${ADDRESS_WRITE_ADVICE}`,
+        );
+      };
+    })()
+  ;
+
 const isStateOnlyNavigation = (
   url,
   { navigationType },