@jsenv/navi 0.29.497 → 0.29.499

package/dist/jsenv_navi.js

@@ -9871,15 +9871,16 @@ const [publishRouteRender, observeRouteRender] = createPubSub();
  *
  * A page whose height depends on something still loading is not there at the
  * moment it is put back, and a position beyond what has arrived is clamped.
- * What navi knows a first render left out, it waits for: a `<Box
- * mount="after-paint">` is built before the offset that shows it is written
- * (see mount_after_paint.jsx), and a reload or a return waits for the route
- * actions the page has nothing to draw for — its code among them — including
- * one whose `when` lets it ask after the position is written (see
- * stayForLateAsks). Anything else only the page knows, and it says so
- * (useHoldScrollRestoration). A wait can be long, so the reader reaching for
- * the page during it cancels the position: moved afterwards, they would lose
- * whatever they had started on.
+ * So it is written into what is there, as far as that goes, and written again
+ * once the page is whole (see putBackMeanwhile). What navi knows a first render
+ * left out, it waits for: a `<Box mount="after-paint">` is built before the
+ * offset that shows it is written (see mount_after_paint.jsx), and a reload or
+ * a return waits for the route actions the page has nothing to draw for — its
+ * code among them — including one whose `when` lets it ask after the position
+ * is written (see stayForLateAsks). Anything else only the page knows, and it
+ * says so (useHoldScrollRestoration). A wait can be long, so the reader
+ * reaching for the page during it cancels the position: moved afterwards, they
+ * would lose whatever they had started on.
  *
  * WHEN a page is arrived at is not decided here either. A document navigation
  * lands where its kind says (see via_history.js), and one scrollport can be
@@ -10038,6 +10039,7 @@ const putBack = (restoration) => {
   restoration.due = true;
   if (restorationHoldCount) {
     // The page is not whole yet: the last release puts it back.
+    putBackMeanwhile(restoration);
     return;
   }
   if (isDocumentHeld()) {
@@ -10084,6 +10086,22 @@ const isDocumentHeld = () => {
   return false;
 };
 
+// A position waiting for the page to be whole is written after the reader has
+// seen the page at its top, and seen as a jump — after the movement, when a
+// route transition photographs the page as soon as it renders, stand-ins and
+// all. So it is also written into what is there meanwhile, as far as that goes
+// (the browser clamps the rest), and again once the page is whole, when what
+// it stands on has grown or shrunk.
+const putBackMeanwhile = (restoration) => {
+  // Out of whatever commit or effect is asking: see scrollTo.
+  queueMicrotask(() => {
+    if (pendingRestoration !== restoration || isDocumentHeld()) {
+      return;
+    }
+    scrollTo(restoration.position);
+  });
+};
+
 // What a page holds instead: not the place, which stays the url's, but the
 // moment it is put back (see useHoldScrollRestoration). Counted: several parts
 // of one page can be waiting.
@@ -10111,11 +10129,11 @@ const holdScrollRestoration = () => {
 };
 
 /**
- * Holds back the scroll position a reload or a back/forward gives the page,
- * while the page is not whole yet: written into what the page shows meanwhile,
- * it is clamped to that height and lost. Put back after the commit in which
- * `held` turns false — unless the reader has reached for the page in the
- * meantime (a finger, a click, a wheel, a key), or gone elsewhere.
+ * Says the page is not whole yet to the scroll position a reload or a
+ * back/forward gives it: written into what the page shows meanwhile, it is
+ * clamped to that height. Put back again after the commit in which `held`
+ * turns false — unless the reader has reached for the page in the meantime (a
+ * finger, a click, a wheel, a key), or gone elsewhere.
  *
  * The page's route actions are waited for without this — its code, a read
  * with no answer yet, one whose `when` holds later. This is for
@@ -10227,6 +10245,7 @@ const putBackOnceAnswered = (restoration) => {
     });
     return;
   }
+  putBackMeanwhile(restoration);
   // A reader drawing its own wait subscribes in an effect, after the first
   // paint (see afterPaint): an answer that came before is drawn only then.
   let waitCount = 2;
@@ -10350,11 +10369,12 @@ const restoreScrollPosition = (url) => {
 };
 
 // A traversal back to `url`. The offset is written once the page returned to is
-// rendered and answered (see putBackOnceAnswered): written sooner, the document
-// still holds the page being left, or a stand-in for the one arriving, and
-// clamps it to that height. It is read at once all the same — a page left
-// taller than the one arriving is clamped by the render itself, and that clamp
-// is a scroll recorded under the url already returned to.
+// rendered (see whenPageRendered): written sooner, the document still holds the
+// page being left and clamps it to that height. Again once it has answered (see
+// putBackOnceAnswered), when it rendered stand-ins (see putBackMeanwhile). It
+// is read at once all the same — a page left taller than the one arriving is
+// clamped by the render itself, and that clamp is a scroll recorded under the
+// url already returned to.
 const restoreScrollPositionOnReturn = (url) => {
   pendingRestoration = null;
   const href = new URL(url, window.location.href).href;