@antelopejs/dms 0.7.20 → 0.8.0

package/frontend-vue/layers/dms-ui/app/build/composables/actions/useActionTargets.ts

@@ -25,10 +25,12 @@ import {
   type RowNavigation,
   type RowNavigationSource,
   rowNavigation,
+  type ShowRow,
 } from "./rowNavigation";
 import {
   clearWrittenRecord,
   isDeepLinkAction,
+  resolveDeepLinkedRow,
   writeRecordId,
   type WrittenRecord,
 } from "../table-view/utils/recordLink";
@@ -37,6 +39,7 @@ import {
   closeRowSidePanelOf,
   openRowSidePanel,
   rowSidePanelOwnerKey,
+  useRowSidePanelContent,
 } from "#dms-layout/app/build/composables/layout/rowSidePanel";
 import type { TableUrlScope } from "../table-view/utils/views";
 import { useActionConfirm } from "../confirm/useActionConfirm";
@@ -49,52 +52,47 @@ import {
   findServedQuickAction,
 } from "../../utils/dispatchQuickActionTarget";
 import {
-  hasUrlVariables,
+  namesPageValue,
   resolveLinkVariables,
   resolveTextVariables,
 } from "../../utils/urlVariables";
-import { interpolateLiteral } from "../../utils/literalText";
+import { currentPageUrlValues } from "../page/pageUrlValues";
 import { type DownloadFetch, saveDownload } from "../../utils/fileDownload";
+import { interpolateRowText } from "#dms-core/app/utils/url-interpolation";
 
 /** Runs a confirmed action from inside its dialog (see `onConfirm`). */
 type ConfirmedRun = NonNullable<ConfirmOptions["onConfirm"]>;
 
 /**
- * A link target's URL with the page's `{{params.X}}` / `{{query.X}}` filled
- * (a query pair without a value left out), then the row's `{field}`: a row
+ * A target's URL with the page's `{{params.X}}` / `{{query.X}}` filled (a
+ * query pair without a value left out), then the row's `{{row.field}}`: an
  * action keeps the page's context (`?website={{query.website}}`) as a page
- * header button does. Read when the link is followed, so it carries the URL
- * as it is then.
+ * header button does, whatever its type and wherever it sits. Read when the
+ * action runs, so it carries the URL as it is then.
  */
-function linkTargetUrl(url: string, rowData?: Data): string {
-  const withPageValues = hasUrlVariables(url)
+function targetUrl(url: string, rowData?: Data): string {
+  const withPageValues = namesPageValue(url)
     ? resolveLinkVariables(url, currentPageUrlValues())
     : url;
   return rowData ? interpolateUrl(withPageValues, rowData) : withPageValues;
 }
 
 /**
- * A download target's file name with the page's tokens filled as they are
- * (a name, not a URL: nothing is encoded), then the row's `{field}`. A token
- * the page has no value for leaves no name: the server's one is used.
+ * A download target's file name with the row's `{{row.field}}` and the
+ * page's tokens filled as they are (a name, not a URL: nothing is encoded). A
+ * token without a value leaves no name: the server's one is used.
  */
 function downloadTargetFilename(
   filename: string | undefined,
   rowData?: Data,
 ): string | undefined {
   if (!filename) return undefined;
-  const withPageValues = resolveTextVariables(filename, currentPageUrlValues());
-  if (!withPageValues || !rowData) return withPageValues;
-  return interpolateLiteral(withPageValues, rowData);
+  const withRow = rowData ? interpolateRowText(filename, rowData) : filename;
+  return resolveTextVariables(withRow, currentPageUrlValues());
 }
 
-function currentPageUrlValues() {
-  const route = useDmsRoute();
-  return {
-    routeParams: useSiteLayout().findMatchingRoute(route.path)?.params,
-    routeQuery: route.query as Record<string, unknown>,
-  };
-}
+// The id an export job's start answered, in its `statusUrl` / `downloadUrl`.
+const JOB_ID_TOKEN = /\{\{\s*job\.id\s*\}\}/g;
 
 /** Where the buttons run: the requests they send, what they refresh. */
 export interface ActionTargetsConfig {
@@ -116,7 +114,7 @@ export interface ActionTargetsConfig {
    */
   onRecordShown?: (id?: string) => void;
   /**
-   * The field a row's id is read from (`_id` by default): it fills `{id}` in
+   * The field a row's id is read from (`_id` by default): it fills `{{row.id}}` in
    * the `from` URL of a row action's confirmation, as on a built-in action.
    */
   rowIdKey?: string;
@@ -145,6 +143,18 @@ interface SidePanelTargetRun extends TargetRunExtras {
   missingId?: string;
 }
 
+/**
+ * `show`, run only while the row side panel still shows `session`: a row read
+ * after the panel closed, or moved to another run, leaves it alone.
+ */
+function whileShown<V>(session: symbol, show: (value: V) => void) {
+  return (value: V): void => {
+    if (useRowSidePanelContent().value?.session === session) show(value);
+  };
+}
+
+const NO_ROW_ROUTE = async (): Promise<undefined> => undefined;
+
 const NOT_FOUND_TITLE_KEY = "side_panel.not_found.title";
 const NOT_FOUND_DESCRIPTION_KEY = "side_panel.not_found.description";
 
@@ -260,7 +270,10 @@ export function useActionTargets(config: ActionTargetsConfig) {
     const statusUrlTemplate = target.statusUrl;
     const downloadUrlTemplate = target.downloadUrl;
     const interpolate = (template: string, ticket: ExportJobTicket): string =>
-      interpolateUrl(template, { ...(rowData ?? {}), jobId: ticket.jobId });
+      targetUrl(
+        template.replace(JOB_ID_TOKEN, encodeURIComponent(ticket.jobId)),
+        rowData,
+      );
     await runExportJob({
       startUrl: url,
       startMethod: target.method ?? "POST",
@@ -284,7 +297,7 @@ export function useActionTargets(config: ActionTargetsConfig) {
     try {
       await saveDownload(
         {
-          url: linkTargetUrl(target.url, rowData),
+          url: targetUrl(target.url, rowData),
           filename: downloadTargetFilename(target.filename, rowData),
         },
         fetchRaw,
@@ -339,6 +352,31 @@ export function useActionTargets(config: ActionTargetsConfig) {
       config.onRecordShown?.(id);
     };
   };
+  // `showRow` given an id: the listed row, else the one the table's route
+  // reads. A row its route answered 404 for goes to `showMissing` when the
+  // container has a state for it; any other row not found rejects. Only the
+  // latest call applies: a read that resolves after a later call is dropped.
+  const rowShower = (
+    show: (row: Data) => void,
+    showMissing?: (id: string) => void,
+  ): ShowRow => {
+    let latest = 0;
+    return async (rowOrId) => {
+      const call = ++latest;
+      if (typeof rowOrId !== "string") return show(rowOrId);
+      const source = config.rowNavigation;
+      const found = await resolveDeepLinkedRow(rowOrId, {
+        listed: source?.rows(),
+        idOf: rowIdOf,
+        getRow: source?.getRow ?? NO_ROW_ROUTE,
+      });
+      if (call !== latest) return;
+      if (found.row) return show(found.row);
+      if (found.isMissing && showMissing) return showMissing(rowOrId);
+      throw new Error(`The row "${rowOrId}" could not be read`);
+    };
+  };
+
   const rowRecorder = (deepLink?: boolean) => {
     const recordId = recordRecorder(deepLink);
     return (row?: Data): void => recordId(rowIdOf(row));
@@ -382,6 +420,10 @@ export function useActionTargets(config: ActionTargetsConfig) {
         componentId: config.componentId,
         containerId: run.containerId,
         selection: run.selection,
+        showRow: rowShower(
+          whileShown(session, showRow),
+          whileShown(session, showMissing),
+        ),
         onSuccessCallback: () => {
           closeRowSidePanel(session);
           config.refreshCallback?.();
@@ -389,7 +431,7 @@ export function useActionTargets(config: ActionTargetsConfig) {
       },
       onClose: () => recordId(undefined),
     };
-    const showRow = (row?: Data) => {
+    function showRow(row?: Data) {
       openRowSidePanel({
         ...panel,
         rowTitle: rowTitleOf(run.target, row),
@@ -399,10 +441,13 @@ export function useActionTargets(config: ActionTargetsConfig) {
         showRow,
       });
       recordId(rowIdOf(row));
-    };
-    if (!run.missingId) return showRow(run.rowData);
-    openRowSidePanel({ ...panel, notFound: notFoundOf(run.target), showRow });
-    recordId(run.missingId);
+    }
+    function showMissing(id: string) {
+      openRowSidePanel({ ...panel, notFound: notFoundOf(run.target), showRow });
+      recordId(id);
+    }
+    if (run.missingId) return showMissing(run.missingId);
+    showRow(run.rowData);
   };
 
   // A container opened on a listed row steps through the rows shown (its
@@ -415,6 +460,12 @@ export function useActionTargets(config: ActionTargetsConfig) {
     const source = config.rowNavigation;
     let instance: ContainerInstance | undefined;
     let navigation: RowNavigation | undefined;
+    // Set once the container closes: a row read that resolves later neither
+    // writes `?record=` back nor patches the closed container.
+    let closed = false;
+    const showRowById = rowShower((row) => {
+      if (!closed) showRow(row);
+    });
     const optionsFor = (row?: Data) => {
       navigation =
         row && source ? rowNavigation(source, row, showRow) : undefined;
@@ -425,6 +476,7 @@ export function useActionTargets(config: ActionTargetsConfig) {
         containerId: run.containerId,
         rowData: row,
         navigation,
+        showRow: showRowById,
         selection: run.selection,
         onSuccessCallback: () => {
           instance?.close();
@@ -436,14 +488,16 @@ export function useActionTargets(config: ActionTargetsConfig) {
     function showRow(row: Data) {
       instance?.patch({
         componentOptions: optionsFor(row),
-        componentKey: String(get(row, source!.rowIdKey)),
+        componentKey: rowIdOf(row),
       });
       recordRow(row);
     }
     instance = openContainer(run, component, optionsFor(run.rowData));
     recordRow(run.rowData);
-    const stopSteps = navigation ? listenRowSteps(() => navigation) : undefined;
+    // `showRow` may move an unlisted row's container onto a listed one.
+    const stopSteps = source ? listenRowSteps(() => navigation) : undefined;
     const settle = () => {
+      closed = true;
       stopSteps?.();
       recordRow(undefined);
     };
@@ -482,11 +536,11 @@ export function useActionTargets(config: ActionTargetsConfig) {
   const targetHandlers: Record<string, TargetHandler> = {
     page: (target, _label, rowData) => {
       const pageTarget = target as ActionTarget & { type: "page" };
-      navigateDms(linkTargetUrl(pageTarget.url, rowData));
+      navigateDms(targetUrl(pageTarget.url, rowData));
     },
     external: (target, _label, rowData) => {
       const externalTarget = target as ActionTarget & { type: "external" };
-      const url = linkTargetUrl(externalTarget.url, rowData);
+      const url = targetUrl(externalTarget.url, rowData);
       if (typeof window === "undefined" || !url) return;
       if (externalTarget.newTab) {
         window.open(url, "_blank", "noopener,noreferrer");
@@ -496,16 +550,12 @@ export function useActionTargets(config: ActionTargetsConfig) {
     },
     api: async (target, label, rowData) => {
       const apiTarget = target as ActionTarget & { type: "api" };
-      const url = rowData
-        ? interpolateUrl(apiTarget.url, rowData)
-        : apiTarget.url;
+      const url = targetUrl(apiTarget.url, rowData);
       await handleApiTarget(apiTarget, url, label, rowData);
     },
     exportJob: async (target, _label, rowData) => {
       const jobTarget = target as ActionTarget & { type: "exportJob" };
-      const url = rowData
-        ? interpolateUrl(jobTarget.url, rowData)
-        : jobTarget.url;
+      const url = targetUrl(jobTarget.url, rowData);
       await handleExportJobTarget(jobTarget, url, rowData);
     },
     download: (target, label, rowData) =>
@@ -525,9 +575,6 @@ export function useActionTargets(config: ActionTargetsConfig) {
     sidePanel: sidePanelHandler,
   };
 
-  const targetUrl = (url: string, rowData?: Data): string =>
-    rowData ? interpolateUrl(url, rowData) : url;
-
   // A target making a request runs it from inside its confirmation, which
   // shows a refusal (under its field when it names one) and stays open; any
   // other runs once confirmed.
@@ -548,7 +595,7 @@ export function useActionTargets(config: ActionTargetsConfig) {
     },
   };
 
-  // `{id}` of a confirmation's `from` URL, when the row carries an id.
+  // `{{row.id}}` of a confirmation's `from` URL, when the row carries an id.
   const rowUrlParams = (rowData?: Data) => {
     const id = rowData
       ? get(rowData, config.rowIdKey ?? DEFAULT_ROW_ID_KEY)

package/frontend-vue/layers/dms-ui/app/build/composables/chart/apexTheme.ts

@@ -18,9 +18,19 @@ const DATA_LABEL_FONT_SIZE = "11px";
 const DATA_LABEL_FONT_WEIGHT = 600;
 const TOOLTIP_DATETIME_FORMAT = "dd MMM yyyy";
 const HOVER_MARKER_SIZE = 5;
+/** Grows a visible point on hover instead of setting a size below its own. */
+const HOVER_POINT_SIZE_OFFSET = 2;
+/** A scatter is nothing but its points, so it draws them without `pointSize`. */
+const DEFAULT_POINT_SIZE = 6;
+const POINT_MARKER_TYPES: ChartType[] = ["scatter"];
+/** Half a data label's box and a gap: lifts the label off the point it names. */
+const POINT_LABEL_CLEARANCE = 11;
+const HALF = 2;
 const HEAD_MARKER_SIZE = 5;
 const SOLID_GRID = 0;
 const HEAD_MARKER_TYPES: ChartType[] = ["line", "area"];
+/** A radar draws its own polygon grid; the cartesian one would cross the card. */
+const OWN_GRID_TYPES: ChartType[] = ["radar"];
 
 /** Theme colors every section of an Apex config reads once per build. */
 export interface ApexThemeColors {
@@ -83,7 +93,10 @@ export function buildGrid(
   theme: ApexThemeColors,
 ): Record<string, unknown> {
   return {
-    show: !isCircular && (input.showGrid ?? true),
+    show:
+      !isCircular &&
+      !OWN_GRID_TYPES.includes(input.type) &&
+      (input.showGrid ?? true),
     borderColor: theme.border,
     strokeDashArray: SOLID_GRID,
     padding: GRID_PADDING,
@@ -140,6 +153,13 @@ export function buildMarkers(
   colors: string[],
   theme: ApexThemeColors,
 ): Record<string, unknown> {
+  if (POINT_MARKER_TYPES.includes(input.type)) {
+    return {
+      size: pointSize(input),
+      strokeWidth: 0,
+      hover: { sizeOffset: HOVER_POINT_SIZE_OFFSET },
+    };
+  }
   const showsHead = HEAD_MARKER_TYPES.includes(input.type) && !input.stacked;
   return {
     size: 0,
@@ -151,18 +171,55 @@ export function buildMarkers(
   };
 }
 
-/** Value labels in mono, without Apex's default drop shadow. */
+function pointSize(input: UseApexChartInput): number {
+  return input.pointSize ?? DEFAULT_POINT_SIZE;
+}
+
+/**
+ * How far a data label moves up: Apex centres it on its point, which hides a
+ * scatter's point under its own label.
+ */
+export function dataLabelOffset(input: UseApexChartInput): number {
+  if (!POINT_MARKER_TYPES.includes(input.type)) return 0;
+  return -(pointSize(input) / HALF + POINT_LABEL_CLEARANCE);
+}
+
+/** Where Apex is drawing a data label. */
+interface DataLabelContext {
+  seriesIndex: number;
+  dataPointIndex: number;
+  w: { config: { series: ChartSeries[] } };
+}
+
+/** A point's own `label` when it has one, else the value Apex would print. */
+function pointLabel(value: unknown, context: DataLabelContext): unknown {
+  const point =
+    context.w.config.series[context.seriesIndex]?.data[context.dataPointIndex];
+  if (typeof point !== "object" || point === null || !("label" in point)) {
+    return value;
+  }
+  return point.label || value;
+}
+
+/**
+ * Value labels in mono, without Apex's default drop shadow. A circular chart
+ * keeps Apex's own percent formatter: its series hold bare numbers.
+ */
 export function buildDataLabels(
   enabled: boolean,
   theme: ApexThemeColors,
+  isCircular = false,
+  offsetY = 0,
 ): Record<string, unknown> {
   return {
     enabled,
+    offsetY,
     dropShadow: { enabled: false },
     style: {
       fontSize: DATA_LABEL_FONT_SIZE,
       fontFamily: theme.monoFont,
       fontWeight: DATA_LABEL_FONT_WEIGHT,
     },
+    ...(isCircular ? {} : { formatter: pointLabel }),
   };
 }

package/frontend-vue/layers/dms-ui/app/build/composables/confirm/confirmDialogTexts.ts

@@ -3,7 +3,10 @@ import type {
   ConfirmDialogSecondaryAction,
   ConfirmDialogSecondaryTarget,
 } from "#dms-core/app/types/confirm-dialog";
-import { interpolateUrl } from "#dms-core/app/utils/url-interpolation";
+import {
+  interpolateRowText,
+  interpolateUrl,
+} from "#dms-core/app/utils/url-interpolation";
 import { readTranslationKey } from "#dms-core/app/composables/translation/useTranslation";
 import type {
   ConfirmOptions,
@@ -11,6 +14,12 @@ import type {
 } from "../../../composables/confirm/types";
 import { processFieldI18n } from "../../utils/fieldOptionsI18n";
 import { interpolateLiteral } from "../../utils/literalText";
+import {
+  namesPageValue,
+  resolveLinkVariables,
+  resolveTextVariables,
+} from "../../utils/urlVariables";
+import { currentPageUrlValues } from "../page/pageUrlValues";
 
 /** `t` as vue-i18n gives it: named parameters, then the plural count. */
 export type ConfirmTranslate = (
@@ -41,22 +50,36 @@ export type SecondaryTargetRun = (
   target: ConfirmDialogSecondaryTarget,
 ) => Promise<void> | void;
 
+// The page's `{{params.X}}` / `{{query.X}}` come first, as on an action's own
+// target; the route is only read for a text holding such a token.
+function withPageLink(url: string): string {
+  return namesPageValue(url)
+    ? resolveLinkVariables(url, currentPageUrlValues())
+    : url;
+}
+
+function withPageText(text: string): string | undefined {
+  return namesPageValue(text)
+    ? resolveTextVariables(text, currentPageUrlValues())
+    : text;
+}
+
 /**
  * A dialog's secondary target with its URL (and file name) filled in with
- * the same parameters as its texts.
+ * the page's values and, as `{{row.X}}`, the same parameters as its texts.
  */
 function resolveSecondaryTarget(
   target: ConfirmDialogSecondaryTarget,
   params: Record<string, unknown>,
 ): ConfirmDialogSecondaryTarget {
-  const url = interpolateUrl(target.url, params);
+  const url = interpolateUrl(withPageLink(target.url), params);
   if (target.type !== "download" || target.filename === undefined) {
     return { ...target, url };
   }
   return {
     ...target,
     url,
-    filename: interpolateLiteral(target.filename, params),
+    filename: withPageText(interpolateRowText(target.filename, params)),
   };
 }
 

package/frontend-vue/layers/dms-ui/app/build/composables/confirm/useActionConfirm.ts

@@ -15,12 +15,17 @@ import {
 } from "./confirmDialogTexts";
 import type { DownloadFetch } from "../../utils/fileDownload";
 import { secondaryTargetRunner } from "./secondaryTarget";
+import {
+  namesPageValue,
+  resolveLinkVariables,
+} from "../../utils/urlVariables";
+import { currentPageUrlValues } from "../page/pageUrlValues";
 
 /** What an action asks its confirmation with. */
 export interface ActionConfirmRequest {
   /** The row the action targets: its fields fill the texts and `from` URL. */
   row?: Record<string, unknown>;
-  /** Fill-ins of a `from` URL besides the row's fields (`{id}`). */
+  /** Fill-ins of a `from` URL besides the row's fields (`{{row.id}}`). */
   urlParams?: Record<string, unknown>;
   /**
    * The look of the action, where the dialog leaves it out (an archive's
@@ -55,7 +60,10 @@ export function useActionConfirm() {
     request: ActionConfirmRequest,
   ): Promise<ConfirmDialog | undefined> => {
     if (!isConfirmFrom(declared)) return declared;
-    const url = interpolateUrl(declared.from, {
+    const from = namesPageValue(declared.from)
+      ? resolveLinkVariables(declared.from, currentPageUrlValues())
+      : declared.from;
+    const url = interpolateUrl(from, {
       ...request.row,
       ...request.urlParams,
     });

package/frontend-vue/layers/dms-ui/app/build/composables/data-types/registerDefaults.ts

@@ -322,13 +322,8 @@ function renderRelation(value: unknown, options: unknown) {
 }
 
 function renderCascaderRelation(value: unknown, options: unknown) {
-  const { t } = useI18n();
   const opts = options as CascaderRelationOptions | undefined;
 
-  if (opts?.multiple && Array.isArray(value)) {
-    return t("dms.form.cascader.selected_count", { count: value.length });
-  }
-
   if (!value) return value;
 
   return h(CascaderPath, {

package/frontend-vue/layers/dms-ui/app/build/composables/form/formEntryOrder.ts

@@ -0,0 +1,23 @@
+import type { FormFieldOrGroup } from "../../../composables/form/types/field";
+import { isFieldGroup } from "../../../composables/form/types/field";
+
+function entryOrder(entry: FormFieldOrGroup): number | undefined {
+  return isFieldGroup(entry) ? entry.order : undefined;
+}
+
+/**
+ * A form's entries with its groups' `order` applied: the groups giving one
+ * trade the places they were declared at, sorted on it (equal orders keep
+ * their declaration order); every other entry keeps its place.
+ */
+export function orderFormEntries<T extends FormFieldOrGroup>(
+  entries: readonly T[],
+): T[] {
+  const ordered = entries
+    .filter((entry) => entryOrder(entry) !== undefined)
+    .sort((left, right) => entryOrder(left)! - entryOrder(right)!);
+  let next = 0;
+  return entries.map((entry) =>
+    entryOrder(entry) === undefined ? entry : ordered[next++]!,
+  );
+}

package/frontend-vue/layers/dms-ui/app/build/composables/form/formFooter.ts

@@ -6,10 +6,10 @@
  *   it has somewhere to go back to, then "Unsaved changes" with Discard and
  *   Save.
  * - `action`: a form that does something each time (send a notification,
- *   invite someone, run a job). Reset and the form's own submit label once a
- *   value changed; untouched — pre-filled or not —, no buttons on a page, and
- *   Cancel beside a held submit in a drawer or a modal. It empties after a
- *   successful submit.
+ *   invite someone, run a job). Its own submit label, always ready: what it
+ *   holds untouched, its defaults included, is a payload too. Beside it,
+ *   Reset once a value changed, Cancel before that in a drawer or a modal.
+ *   It empties after a successful submit.
  */
 export type FormKind = "record" | "action";
 
@@ -83,21 +83,25 @@ function recordSaveBar(context: SaveBarContext): SaveBarState {
 }
 
 /**
- * An action form's bar: Reset and its submit once a value changed. Before
- * that, a form in a drawer or a modal offers Cancel beside its held submit —
- * the modal's only way out and the proof it sends something —, a page form
- * nothing; a form nothing in which can be changed, its submit alone.
+ * An action form's bar: its submit, never held, so a pre-filled form sends as
+ * it is. Beside it, Reset once a value changed; before that, Cancel in a
+ * drawer or a modal, its only way out. A form nothing in which can be changed
+ * has nothing to reset.
  */
 function actionSaveBar(context: SaveBarContext): SaveBarState {
-  const bar = { showsStatus: false, showsSubmit: true, isHidden: false };
-  if (!context.resettable) return { ...bar, isSubmitHeld: false };
-  if (context.dirty) {
-    return { ...bar, secondary: "discard", isSubmitHeld: false };
+  const bar: SaveBarState = {
+    showsStatus: false,
+    showsSubmit: true,
+    isSubmitHeld: false,
+    isHidden: false,
+  };
+  if (context.dirty && context.resettable) {
+    return { ...bar, secondary: "discard" };
   }
-  if (!context.cancellable) {
-    return { ...HIDDEN_BAR, showsStatus: false };
+  if (!context.dirty && context.cancellable) {
+    return { ...bar, secondary: "cancel" };
   }
-  return { ...bar, secondary: "cancel", isSubmitHeld: true };
+  return bar;
 }
 
 const SAVE_BARS: Record<FormKind, (context: SaveBarContext) => SaveBarState> = {

package/frontend-vue/layers/dms-ui/app/build/composables/form/formRecordLoad.ts

@@ -5,9 +5,33 @@ import { HTTP_FORBIDDEN } from "#dms-core/app/utils/http-status";
 /**
  * Why a form could not load the record it edits: `forbidden` when the server
  * refused the caller the read (a role that may edit rows but not view them),
- * `error` for anything else (a network failure, a server error, a row gone).
+ * `missing` when its address lacks the record's id (a page reached without
+ * its `?id=`), `error` for anything else (a network failure, a server error,
+ * a row gone).
  */
-export type FormLoadFailure = "forbidden" | "error";
+export type FormLoadFailure = "forbidden" | "missing" | "error";
+
+/** What a form knows of the record it is about, as far as `missing` goes. */
+export interface FormRecordAddress {
+  requiresRecord?: boolean;
+  fetchUrl?: string;
+  /** `fetchUrl` with its route values filled; unset while one is missing. */
+  resolvedFetchUrl?: string;
+}
+
+/**
+ * `missing` for a form about one record whose address names no record yet:
+ * its fields would only hold their defaults, which read as a record.
+ */
+export function missingRecordFailure(
+  address: FormRecordAddress,
+): FormLoadFailure | null {
+  const isMissing =
+    !!address.requiresRecord &&
+    !!address.fetchUrl &&
+    !address.resolvedFetchUrl;
+  return isMissing ? "missing" : null;
+}
 
 /** The cached load of a form's record (`useDmsAsyncData`), as far as it is read. */
 export interface FormLoadSource<T> {

package/frontend-vue/layers/dms-ui/app/build/composables/page/pageUrlValues.ts

@@ -0,0 +1,41 @@
+import {
+  namesPageValue,
+  type ReplaceUrlVariablesContext,
+  resolveLinkVariables,
+  resolveUrlVariables,
+} from "../../utils/urlVariables";
+
+/**
+ * The values of the page being shown that a `{{params.X}}` / `{{query.X}}`
+ * token names: the route parameters of the DMS page matching the URL, and its
+ * query. Read when called, so it follows the URL as it changes.
+ */
+export function currentPageUrlValues(): ReplaceUrlVariablesContext {
+  const route = useDmsRoute();
+  return {
+    routeParams: useSiteLayout().findMatchingRoute(route.path)?.params,
+    routeQuery: route.query as Record<string, unknown>,
+  };
+}
+
+/**
+ * A link declared on a block (`to`) with the page's tokens filled, as a page
+ * header button's: a query pair the page has no value for is left out. The
+ * route is only read for a link holding a token.
+ */
+export function pageLink(to: string): string;
+export function pageLink(to: string | undefined): string | undefined;
+export function pageLink(to: string | undefined): string | undefined {
+  if (!to || !namesPageValue(to)) return to;
+  return resolveLinkVariables(to, currentPageUrlValues());
+}
+
+/**
+ * A route a field or block requests (`searchUrl`, `rotateUrl`, …) with the
+ * page's tokens filled, or `undefined` while one has no value, as a block's
+ * `fetchUrl`.
+ */
+export function pageRequestUrl(url: string | undefined): string | undefined {
+  if (!url || !namesPageValue(url)) return url;
+  return resolveUrlVariables(url, currentPageUrlValues());
+}