@jsenv/navi 0.29.127 → 0.29.129

package/dist/jsenv_navi.js

@@ -3000,8 +3000,9 @@ naviI18n.addAll({
  * read by the action layer rather than by every callback.
  *
  * Under a policy (a truthy reason):
- * - a resource GET answers with the row its store holds for its params and
- *   asks nothing (resource_graph.js, applyNetworkPolicy); a completed read
+ * - a resource GET answers with the row its store holds for it — named by its
+ *   params, or the one it last completed with — and asks nothing
+ *   (resource_graph.js, applyNetworkPolicy); a completed read
  *   asked to rerun stays completed (actions.js, handleActionRequest);
  *   anything else settles with an OfflineError carrying the reason;
  * - a control bound to a write — or inside a form bound to one — is read-only
@@ -4037,6 +4038,7 @@ const createAction = (callback, rootOptions = {}) => {
           event,
           signal: internalAbortSignal,
           isPrerun,
+          action,
         });
         const returnValue = sideEffect(...args);
         if (typeof returnValue === "function") {
@@ -14792,7 +14794,7 @@ const debug$3 = (...args) => {
  *
  * @param {string} name - resource name, used in action names and error messages
  * @param {Object} restCallbacks - `{ idKey, uniqueKeys, rerunOn, dependencies, GET, GET_MANY, GET_RANGE, POST, POST_MANY, PUT, PUT_MANY, PATCH, PATCH_MANY, DELETE, DELETE_MANY }`
- * @param {string} [restCallbacks.idKey] - primary key property, defaults to `"id"` (or the first `uniqueKeys` entry)
+ * @param {string} [restCallbacks.idKey] - primary key property, defaults to `"id"`
  * @param {string[]} [restCallbacks.uniqueKeys] - alternate keys the store can find an item by (e.g. `"username"`); a callback may return a different `id` to rename the item's primary key
  * @see docs/resource.md — relationships, callback return contracts, decision table
  *
@@ -14808,7 +14810,7 @@ const resource = (
   name,
   {
     // configuration options
-    idKey,
+    idKey = "id",
     uniqueKeys = [],
     rerunOn,
     dependencies,
@@ -14827,9 +14829,6 @@ const resource = (
   } = {},
 ) => {
   const declarationSite = getDeclarationSite();
-  if (idKey === undefined) {
-    idKey = uniqueKeys.length === 0 ? "id" : uniqueKeys[0];
-  }
   const setupCallbackSet = new Set();
   const addItemSetup = (callback) => {
     setupCallbackSet.add(callback);
@@ -14877,10 +14876,12 @@ const resource = (
     store,
     declarationSite,
   });
-  // The row a GET's params designate, when the store already holds it: the
-  // value under idKey may be the id or any unique key (a route opening a user
-  // by id or by slug names both `id`), and a unique key may be given under its
-  // own name. Answers a GET under a network policy (see applyNetworkPolicy).
+  // The row a GET designates, when the store already holds it — by its params:
+  // the value under idKey may be the id or any unique key (a route opening a
+  // user by id or by slug names both `id`), and a unique key may be given under
+  // its own name; or, when the params name no row (a GET without params, or
+  // whose params carry no key), the row the action last completed with.
+  // Answers a GET under a network policy (see applyNetworkPolicy).
   const selectByAnyKey = (value) => {
     const item = store.select(value);
     if (item) {
@@ -14894,31 +14895,42 @@ const resource = (
     }
     return null;
   };
-  const findItemInStore = (params) => {
-    return untracked(() => {
-      if (primitiveCanBeId(params)) {
-        return selectByAnyKey(params);
-      }
-      if (!isProps(params)) {
-        return null;
+  const findItemByParams = (params) => {
+    if (primitiveCanBeId(params)) {
+      return selectByAnyKey(params);
+    }
+    if (!isProps(params)) {
+      return null;
+    }
+    const idParam = params[idKey];
+    if (idParam !== undefined) {
+      const item = selectByAnyKey(idParam);
+      if (item) {
+        return item;
       }
-      const idParam = params[idKey];
-      if (idParam !== undefined) {
-        const item = selectByAnyKey(idParam);
+    }
+    for (const uniqueKey of uniqueKeys) {
+      const uniqueKeyParam = params[uniqueKey];
+      if (uniqueKeyParam !== undefined) {
+        const item = store.select(uniqueKey, uniqueKeyParam);
         if (item) {
           return item;
         }
       }
-      for (const uniqueKey of uniqueKeys) {
-        const uniqueKeyParam = params[uniqueKey];
-        if (uniqueKeyParam !== undefined) {
-          const item = store.select(uniqueKey, uniqueKeyParam);
-          if (item) {
-            return item;
-          }
-        }
+    }
+    return null;
+  };
+  const findItemInStore = (params, action) => {
+    return untracked(() => {
+      const itemByParams = findItemByParams(params);
+      if (itemByParams) {
+        return itemByParams;
       }
-      return null;
+      const lastItemId = getLastGetItemId(action);
+      if (lastItemId === undefined) {
+        return null;
+      }
+      return store.select(lastItemId) || null;
     });
   };
   return createResource(name, {
@@ -15970,6 +15982,9 @@ const createRestActionFactoryForRoot = (
         // lifecycle rules can detect whether sub-resources were embedded.
         if (verb === "GET") {
           recordGetResultProperties(action, Object.keys(result));
+          const itemId = applyResultToValue(result);
+          lastGetItemIdWeakMap.set(action, itemId);
+          return itemId;
         }
         return applyResultToValue(result);
       },
@@ -16017,12 +16032,12 @@ const createRestActionFactoryForRoot = (
 };
 
 // Under a network policy no callback is called (see network_policy.js). A GET
-// of a root resource answers with the row the store holds for its params —
-// handing the item back is an upsert without effect, so the action completes
-// with what it had and nothing is asked. A relationship GET has no row of its
-// own to answer with, and a write has nothing to answer: both settle with an
-// OfflineError carrying the policy's reason. A completed GET asked to rerun
-// never gets here (actions.js holds it).
+// of a root resource answers with the row the store holds for it (see
+// findItemInStore) — handing the item back is an upsert without effect, so the
+// action completes with what it had and nothing is asked. A relationship GET
+// has no row of its own to answer with, and a write has nothing to answer:
+// both settle with an OfflineError carrying the policy's reason. A completed
+// GET asked to rerun never gets here (actions.js holds it).
 const applyNetworkPolicy = (
   restCallback,
   { verb, isMany, findItemInStore },
@@ -16033,7 +16048,7 @@ const applyNetworkPolicy = (
       return restCallback(params, context);
     }
     if (verb === "GET" && !isMany && findItemInStore) {
-      const item = findItemInStore(params);
+      const item = findItemInStore(params, context.action);
       if (item) {
         return item;
       }
@@ -16042,6 +16057,14 @@ const applyNetworkPolicy = (
   };
 };
 
+// WeakMap<action, itemId> — the row each GET action last completed with. A
+// reset clears the action's value; this survives it, so a GET run again after
+// a reset can still be answered from the store under a network policy.
+const lastGetItemIdWeakMap = new WeakMap();
+const getLastGetItemId = (action) => {
+  return lastGetItemIdWeakMap.get(action);
+};
+
 // Captures the "file:line:column" of the user code that invoked the public
 // function (resource(), .one(), .many(), withParams, …), so invalid-result
 // errors can point at where the callbacks were declared, not at this file.
@@ -17610,6 +17633,7 @@ const LAYOUT_PROPS = {
   flexWrap: applyToCssPropWhenTruthy("flexWrap", "wrap", "nowrap"),
   grid: () => {},
   gridTemplateColumns: PASS_THROUGH,
+  gridTemplateRows: PASS_THROUGH,
   display: PASS_THROUGH, // in case people write "display: none" (even if hidden prop is recommended)
   row: () => {},
   column: () => {},
@@ -73451,6 +73475,7 @@ const TimeWheel = ({
  *   size?: string,
  *   startLabel?: import("ignore:preact").ComponentChildren,
  *   endLabel?: import("ignore:preact").ComponentChildren,
+ *   labelPosition?: "before" | "above",
  *   timeProps?: object,
  *   [key: string]: any,
  * }>}
@@ -73459,6 +73484,13 @@ const TimeWheel = ({
  * @param {import("ignore:preact").ComponentChildren} [startLabel] What is written
  *   before the first time ("De"), and `endLabel` between the two ("à"). Say
  *   `null` for neither.
+ * @param {"before"|"above"} [labelPosition="before"] Where each label stands.
+ *   Before its wheels, the span reads as one sentence ("De 9h00 à 18h00").
+ *   Above them, each bound is a column — "Début" over its wheels, "Fin" over
+ *   the other — two answers side by side, whose wheels land at the same place
+ *   whatever the width of the words. Labels that are nouns rather than
+ *   prepositions belong there; the group is still a row, and takes `flexWrap`
+ *   for screens too narrow to hold both columns.
  * @param {number} [minuteStep=1] How many minutes apart the values on both
  *   minute wheels are.
  * @param {{min?: number, max?: number}|number[]} [hours] Which hours both
@@ -73487,6 +73519,7 @@ const TimeRangeWheel = ({
   size,
   startLabel = naviI18n("time_range.from"),
   endLabel = naviI18n("time_range.to"),
+  labelPosition = "before",
   timeProps,
   startTimeProps,
   endTimeProps,
@@ -73554,53 +73587,61 @@ const TimeRangeWheel = ({
     ...rest,
     children: jsxs(AnsweredContext.Provider, {
       value: answeredRef,
-      children: [startLabel === null ? null : jsx(Text, {
-        size: size,
-        className: "navi_time_range_label",
-        children: startLabel
-      }), jsx(TimeWheel, {
-        id: startId,
-        ref: startRef,
-        name: "start",
-        minuteStep: minuteStep,
-        hours: hours,
-        loop: loop,
-        size: size,
-        placeholder: placeholder ? placeholder.start : undefined
-        // e.detail.value is the settled WHEEL's own value (an hour, a
-        // minute) — half a time. What the pair compares is this bound's
-        // whole time, read off the element the listener sits on.
-        ,
+      children: [jsx(TimeBound, {
+        labelPosition: labelPosition,
+        label: startLabel === null ? null : jsx(Text, {
+          size: size,
+          className: "navi_time_range_label",
+          children: startLabel
+        }),
+        children: jsx(TimeWheel, {
+          id: startId,
+          ref: startRef,
+          name: "start",
+          minuteStep: minuteStep,
+          hours: hours,
+          loop: loop,
+          size: size,
+          placeholder: placeholder ? placeholder.start : undefined
+          // e.detail.value is the settled WHEEL's own value (an hour, a
+          // minute) — half a time. What the pair compares is this bound's
+          // whole time, read off the element the listener sits on.
+          ,
 
-        onnavi_wheel_settle: e => {
-          keepBoundsApart("start", getUIStateFromElement(e.currentTarget), e);
-        },
-        ...timeProps,
-        ...startTimeProps
-      }), endLabel === null ? null : jsx(Text, {
-        size: size,
-        className: "navi_time_range_label",
-        children: endLabel
-      }), jsx(TimeWheel, {
-        ref: endRef,
-        name: "end",
-        minuteStep: minuteStep,
-        hours: hours,
-        loop: loop,
-        size: size,
-        placeholder: placeholder ? placeholder.end : undefined,
-        onnavi_wheel_settle: e => {
-          keepBoundsApart("end", getUIStateFromElement(e.currentTarget), e);
-        }
-        // Which time it comes after, and how much room there must be between
-        // the two: said on the LATER of the two, so the answer is given where
-        // the time one would have to move is (see time_range_constraint.js).
-        ,
+          onnavi_wheel_settle: e => {
+            keepBoundsApart("start", getUIStateFromElement(e.currentTarget), e);
+          },
+          ...timeProps,
+          ...startTimeProps
+        })
+      }), jsx(TimeBound, {
+        labelPosition: labelPosition,
+        label: endLabel === null ? null : jsx(Text, {
+          size: size,
+          className: "navi_time_range_label",
+          children: endLabel
+        }),
+        children: jsx(TimeWheel, {
+          ref: endRef,
+          name: "end",
+          minuteStep: minuteStep,
+          hours: hours,
+          loop: loop,
+          size: size,
+          placeholder: placeholder ? placeholder.end : undefined,
+          onnavi_wheel_settle: e => {
+            keepBoundsApart("end", getUIStateFromElement(e.currentTarget), e);
+          }
+          // Which time it comes after, and how much room there must be between
+          // the two: said on the LATER of the two, so the answer is given where
+          // the time one would have to move is (see time_range_constraint.js).
+          ,
 
-        "data-time-after": startId,
-        "data-time-min-duration": minDuration,
-        ...timeProps,
-        ...endTimeProps
+          "data-time-after": startId,
+          "data-time-min-duration": minDuration,
+          ...timeProps,
+          ...endTimeProps
+        })
       })]
     })
   });
@@ -73719,6 +73760,27 @@ const resolveHourList = hours => {
 };
 const padTwo = value => String(value).padStart(2, "0");
 
+// A label and its wheels. Side by side, they are two items of the group's own
+// row. One above the other, they are one item: the two bounds then stand at
+// the same height and their wheels line up whatever the width of the words.
+const TimeBound = ({
+  labelPosition,
+  label,
+  children
+}) => {
+  if (labelPosition === "above") {
+    return jsxs(Box, {
+      flex: "y",
+      alignX: "center",
+      spacing: "xs",
+      children: [label, children]
+    });
+  }
+  return jsxs(Fragment$1, {
+    children: [label, children]
+  });
+};
+
 // The two times as one span, { start, end } — the shape a pair carries.
 const aggregateSpan = childUIStateControllers => {
   const span = {};