@jsenv/navi 0.29.437 → 0.29.438

package/dist/dev/jsenv_navi.js

@@ -2975,6 +2975,41 @@ const setActionPrivateProperties = (action, properties) => {
   actionPrivatePropertiesWeakMap.set(action, properties);
 };
 
+/*
+ * Where an action that declares no provisionalValue of its own finds one: the
+ * value the page kept from the previous document, for a route action that is
+ * not a resource read (see keepPageOnScreen in nav/page_kept.js). routeAction
+ * adds the source when it binds the action; a run asks for it at its start,
+ * like it asks provisionalValue (actions.js).
+ *
+ * A registry beside actions.js rather than an import of the kept reads: those
+ * know about stores and params keys, which import actions.js.
+ */
+
+const keptValueSourcesWeakMap = new WeakMap();
+const addKeptValueSource = (rootAction, source) => {
+  let sources = keptValueSourcesWeakMap.get(rootAction);
+  if (!sources) {
+    sources = [];
+    keptValueSourcesWeakMap.set(rootAction, sources);
+  }
+  sources.push(source);
+};
+const takeKeptValue = (action, params) => {
+  const rootAction = action.rootAction || action;
+  const sources = keptValueSourcesWeakMap.get(rootAction);
+  if (!sources) {
+    return undefined;
+  }
+  for (const source of sources) {
+    const value = source(params);
+    if (value !== undefined) {
+      return value;
+    }
+  }
+  return undefined;
+};
+
 /*
  * Actions: async callbacks wrapped in reactive state.
  *
@@ -4210,8 +4245,12 @@ const createAction = (callback, rootOptions = {}) => {
         actionAbortMap.set(action, abort);
 
         batch(() => {
-          if (provisionalValue && valueSignal.peek() === undefined) {
-            const provisional = provisionalValue(params, action);
+          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).
+            const provisional = provisionalValue
+              ? provisionalValue(params, action)
+              : takeKeptValue(action, params);
             if (provisional !== undefined) {
               valueSignal.value = provisional;
             }
@@ -26749,10 +26788,10 @@ const isOwnerReadBy = (childResource, childAction, ownerGetAction) => {
  * out again, after a reset say, it would write the previous document's rows
  * over a fresher answer.
  *
- * This module is the half the resources see: `resource()` and the range reader
- * take from it, and say which of their reads can be kept at all. Which reads
- * are on the page on screen, and what the slot is written into, is
- * page_kept.js.
+ * This module is the half the reads see: `resource()` and the range reader
+ * take from it and say which of their reads are kept as rows, routeAction takes
+ * from it for any other action (through action/kept_values.js). Which reads are
+ * on the page on screen, and what the slot is written into, is page_kept.js.
  */
 
 // key → what the read answered in the previous document, not handed out yet
@@ -26775,9 +26814,10 @@ const takeKeptRead = (key) => {
   return entry;
 };
 
-// The root actions whose answer is rows of a store, written and read back the
-// same way: a resource's GET and GET_MANY. Anything else a route runs (a page's
-// code, a computation) has nothing a later document could draw.
+// The root actions whose answer is rows of a store: a resource's GET and
+// GET_MANY. They are kept as rows, since their value (ids) names rows a new
+// document's store does not hold. Any other route action is kept by its value
+// (see page_kept.js).
 const keepableReadWeakSet = new WeakSet();
 const markKeepableRead = (rootAction) => {
   keepableReadWeakSet.add(rootAction);
@@ -39211,6 +39251,15 @@ const writeCover = (edge, element, size) => {
 // Every route action, with whether it asks something of the address at the
 // moment: its route matches and its params getter returns something.
 const routeActionEntriesSignal = signal([]);
+// What a route action is called in the page kept for the next document (see
+// keepPageOnScreen): its place among the route actions declared, which the
+// next document of the same build declares in the same order. A resource read
+// has a name of its own and is kept by it; an action made from a callback is
+// most often "anonymous", and several of them read the same page.
+const keptNameWeakMap = new WeakMap();
+const getRouteActionKeptName = (routeAction) => {
+  return keptNameWeakMap.get(routeAction);
+};
 let activeRouteActionsPrevious = new Set();
 /**
  * The route actions asking something for the page on screen: their route
@@ -39295,7 +39344,16 @@ const routeAction = (
     }
     return params;
   };
+  const rootAction = rootActionOf(action);
+  const keptName = `route_action#${routeActionEntriesSignal.peek().length} ${rootAction.name}`;
+  if (!isKeepableRead(rootAction)) {
+    // Before the effect below: it may run the action at once.
+    addKeptValueSource(rootAction, (params) =>
+      takeKeptRead(getKeptReadKey(keptName, params)),
+    );
+  }
   const actionBoundToRoute = actionRunEffect(action, readParamsAsked, options);
+  keptNameWeakMap.set(actionBoundToRoute, keptName);
   routeActionEntriesSignal.value = [
     ...routeActionEntriesSignal.peek(),
     {
@@ -39386,6 +39444,13 @@ const anyMatchingRouteSignal = (routes) => {
   return anyMatchingSignal;
 };
 
+const rootActionOf = (action) => {
+  if (action.isProxy) {
+    return rootActionOf(getActionPrivateProperties(action).currentAction);
+  }
+  return action.rootAction || action;
+};
+
 const haveSameMembers = (setA, setB) => {
   if (setA.size !== setB.size) {
     return false;
@@ -39413,6 +39478,15 @@ const haveSameMembers = (setA, setB) => {
  * (shownRangeReadersSignal). A search typed on the page is neither, and is not
  * kept.
  *
+ * What a read is made of on the way out depends on what it holds. A resource
+ * read holds ids, which name rows a new document's store does not have: its
+ * rows are written, and re-enter the store. Any other route action holds its
+ * value, written as it is when JSON brings it back as it was — a page's code
+ * (a function), a Date built by the callback, a Map, are not, and are left
+ * out. Such an action is recognized in the next document by its place among
+ * the route actions declared (see getRouteActionKeptName), not by a name the
+ * app would have to give every action made from a callback.
+ *
  * A read is written once it has answered in this document. Before that it
  * keeps what the previous document kept for it, never what it shows meanwhile:
  * an answer handed over from other params (a list standing in for the next
@@ -39439,17 +39513,19 @@ let stopKeepingCurrent = null;
  * draws it again while its reads go out, rather than skeletons.
  *
  * What the page reads is what navi runs for it: the route actions asking
- * something for it (see `activeRouteActionsSignal`) whose action is a resource
- * `GET` or `GET_MANY`, and the `GET_RANGE` compositions the `<List.Items>` on
- * screen read, around the window they draw. A navigation replaces the slot with
- * the next page's reads, and the page left is dropped. In the next document,
- * the first run of the same read with the same params draws the kept answer as
- * its provisional value: `data` set while `loading` is `true`, the answer
- * replacing it. Under a network policy answering reads from the store, the
- * kept answer answers the read. The copy follows the store: a `PUT` on a row
- * rewrites it.
- *
- * Call it before the routes start: the first runs are the ones that look.
+ * something for it (see `activeRouteActionsSignal`), and the `GET_RANGE`
+ * compositions the `<List.Items>` on screen read, around the window they draw.
+ * A resource read keeps its rows; any other route action keeps its value when
+ * JSON brings it back as it was. A navigation replaces the slot with the next
+ * page's reads, and the page left is dropped. In the next document, the first
+ * run of the same read with the same params draws the kept answer as its
+ * provisional value: `data` set while `loading` is `true`, the answer replacing
+ * it. Under a network policy answering reads from the store, a resource read
+ * completes with it. The copy follows the store: a `PUT` on a row rewrites it.
+ *
+ * Call it before the routes start: the first runs are the ones that look. And
+ * declare the route actions where the app starts: one that is not a resource
+ * read is recognized by its place among them.
  *
  * @param {object} options
  * @param {import("@preact/signals").Signal} options.signal - where the slot is
@@ -39572,7 +39648,7 @@ const keepPageOnScreen = ({
   });
 
   const actionReadWeakMap = new WeakMap();
-  const actionReadOf = (action) => {
+  const actionReadOf = (action, keptName, readEntryOf) => {
     let read = actionReadWeakMap.get(action);
     if (read) {
       return read;
@@ -39586,16 +39662,10 @@ const keepPageOnScreen = ({
         answeredActionWeakSet.add(action);
       }
       return {
-        key: getKeptReadKey(action.name, action.params),
+        key: getKeptReadKey(keptName, action.params),
         answered: answeredActionWeakSet.has(action),
         landed,
-        readEntry: () => {
-          const data = action.dataSignal.value;
-          if (data === undefined || data === null) {
-            return undefined;
-          }
-          return serializeData(data);
-        },
+        readEntry: () => readEntryOf(action),
       };
     };
     actionReadWeakMap.set(action, read);
@@ -39634,10 +39704,20 @@ const keepPageOnScreen = ({
       // eslint-disable-next-line no-unused-expressions
       routeAction.callSource;
       const action = getActionPrivateProperties(routeAction).currentAction;
-      if (action.params === NO_PARAMS || !isKeepableRead(action)) {
+      if (action.params === NO_PARAMS) {
         continue;
       }
-      reads.push(actionReadOf(action));
+      if (isKeepableRead(action)) {
+        reads.push(actionReadOf(action, action.name, readRows));
+      } else {
+        reads.push(
+          actionReadOf(
+            action,
+            getRouteActionKeptName(routeAction),
+            readPlainValue,
+          ),
+        );
+      }
     }
     for (const reader of shownRangeReadersSignal.value.keys()) {
       reads.push(rangeReadOf(reader));
@@ -39723,6 +39803,57 @@ const keepPageOnScreen = ({
   return stop;
 };
 
+const readRows = (action) => {
+  const data = action.dataSignal.value;
+  if (data === undefined || data === null) {
+    return undefined;
+  }
+  return serializeData(data);
+};
+const readPlainValue = (action) => {
+  const value = action.valueSignal.value;
+  if (value === undefined || !isPlainData(value, new Set())) {
+    return undefined;
+  }
+  return value;
+};
+// What JSON writes and reads back as it was. `undefined` inside is accepted:
+// JSON drops the key, which reads the same.
+const isPlainData = (value, ancestorSet) => {
+  if (value === null || value === undefined) {
+    return true;
+  }
+  const type = typeof value;
+  if (type === "string" || type === "boolean") {
+    return true;
+  }
+  if (type === "number") {
+    return Number.isFinite(value);
+  }
+  if (type !== "object") {
+    return false;
+  }
+  if (ancestorSet.has(value)) {
+    return false;
+  }
+  const isArray = Array.isArray(value);
+  if (!isArray) {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) {
+      return false;
+    }
+  }
+  ancestorSet.add(value);
+  const entries = isArray ? value : Object.values(value);
+  for (const entry of entries) {
+    if (!isPlainData(entry, ancestorSet)) {
+      return false;
+    }
+  }
+  ancestorSet.delete(value);
+  return true;
+};
+
 /**
  * A popup that is the anchor, brought to the front.
  *