@antelopejs/dms 0.7.9 → 0.7.11

package/frontend-vue/layers/dms-ui/app/build/components/table/Table.vue

@@ -113,6 +113,8 @@ export interface TableRowActionOptions {
   copyLink?: boolean | RowActionConfig;
   hasSelection?: boolean;
   custom?: CustomRowAction[];
+  /** Name of a row's ⋯ menu button, its `{field}` braces filled from the row. */
+  menuLabel?: string;
 }
 
 export interface NavItem {
@@ -149,6 +151,8 @@ export interface TableProps<T> {
   caption?: string;
 
   rowIdKey?: string;
+  /** Field naming a row: the default name of its ⋯ menu button. */
+  labelKey?: string;
   rowActions?: TableRowActionOptions;
   /**
    * What runs a row's click action: a double-click (the default) or a single
@@ -203,6 +207,8 @@ export interface TableProps<T> {
   chrome?: ResolvedTableChrome;
   /** Placeholder of the search field. */
   searchPlaceholder?: string;
+  /** Key opening the search (`defineShortcuts` notation); `shift_f` else. */
+  searchShortcut?: string;
   /**
    * One-click dropdown filters of the toolbar, writing the column filters
    * (the `columnFilters` model).
@@ -342,6 +348,10 @@ export interface TableSharedData<T> {
    * included) and the toolbar search — and goes back to the first page.
    */
   resetFilters: () => void;
+  /** Empties the toolbar search alone (the toolbar folds it). */
+  clearSearch: () => void;
+  /** Clears the filter chips alone, the search kept. */
+  clearFilters: () => void;
   /** What `resetFilters` would clear (nothing: no clear action to offer). */
   clearableFilters: ComputedRef<ClearableTableFilters>;
   /** A search, a filter chip or a hidden filter narrows the rows. */
@@ -409,7 +419,9 @@ import TableTabs from "./Tabs.vue";
 import { createTableViewDeleteShortcut } from "../../../composables/table-view/shortcuts/tableViewDelete";
 import { FULL_TABLE_CHROME } from "../../composables/table-view/utils/chrome";
 import {
+  clearTableColumnFilters,
   clearTableFilters,
+  clearTableSearch,
   clearableTableFilters,
   isTableNarrowed,
   type TableNarrowingState,
@@ -444,11 +456,14 @@ const ROW_SELECTED_BG = "data-[selected=true]:bg-primary/10";
 const ROW_SELECTED_CELL_BG =
   "group-data-[selected=true]:bg-[color-mix(in_srgb,var(--ui-primary)_10%,var(--dms-surface-card))]";
 
-// The row a side panel has open: the hover tint, held, and an accent rule on
-// its leading edge.
+// The row a side panel has open: the accent tint of a selected row and a 2px
+// accent bar on its leading edge, the "current item" of the design system
+// (a list row, a settings role). The bar is drawn by the first cell: a
+// table row's own box shadow is not painted under its cells' backgrounds.
 const ROW_OPEN_BG =
-  "data-[open=true]:bg-elevated data-[open=true]:shadow-[inset_2px_0_0_0_var(--ui-primary)]";
-const ROW_OPEN_CELL_BG = "group-data-[open=true]:bg-elevated";
+  "data-[open=true]:bg-primary/10 data-[open=true]:[&>td:first-child]:shadow-[inset_2px_0_0_0_var(--ui-primary)]";
+const ROW_OPEN_CELL_BG =
+  "group-data-[open=true]:bg-[color-mix(in_srgb,var(--ui-primary)_10%,var(--dms-surface-card))]";
 
 // An expanded row keeps the hover tint and hands its bottom rule to the detail
 // band below it.
@@ -1079,6 +1094,13 @@ const resetFilters = () => {
   clearTableFilters(narrowingState);
   void filtersCleared.trigger();
 };
+// Clearing the search folds the toolbar's field, as a full clear does; the
+// filters alone leave it as it is.
+const clearSearch = () => {
+  clearTableSearch(narrowingState);
+  void filtersCleared.trigger();
+};
+const clearFilters = () => clearTableColumnFilters(narrowingState);
 const clearableFilters = computed(() => clearableTableFilters(narrowingState));
 const isFiltered = computed(() => isTableNarrowed(narrowingState));
 
@@ -1162,6 +1184,8 @@ watchEffect(() => {
     hasCustomColumns,
     deleteFilter,
     resetFilters,
+    clearSearch,
+    clearFilters,
     clearableFilters,
     isFiltered,
     onFiltersCleared: filtersCleared.on,
@@ -1305,6 +1329,7 @@ defineShortcuts({
           :on-custom-button="onCustomButton"
           :chrome="resolvedChrome"
           :search-placeholder="searchPlaceholder"
+          :search-shortcut="searchShortcut"
           :quick-filters="quickFilters"
           :class="{
             'ms-auto': !resolvedChrome.caption && !tabsInline,

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

@@ -91,8 +91,13 @@ interface SidePanelTargetRun extends TargetRunExtras {
   title: string;
   containerId: string;
   rowData?: Data;
+  /** Id of a row the link names but the route answered 404 for. */
+  missingId?: string;
 }
 
+const NOT_FOUND_TITLE_KEY = "side_panel.not_found.title";
+const NOT_FOUND_DESCRIPTION_KEY = "side_panel.not_found.description";
+
 /** A drawer or modal to open, and on what. */
 interface ComponentTargetRun extends TargetRunExtras {
   target: ActionTarget & { type: "modal" | "drawer" };
@@ -246,21 +251,39 @@ export function useActionTargets(config: ActionTargetsConfig) {
     return id === undefined || id === null ? undefined : String(id);
   };
 
-  // A deep-linked action keeps the row it has open in the URL; `undefined`
-  // removes it, but only the row this run wrote, on the page it wrote it:
-  // closing as the user navigates leaves the next page's `?record=` alone.
-  const rowRecorder = (deepLink?: boolean) => {
+  // A deep-linked action keeps the row it has open in the URL, by id;
+  // `undefined` removes it, but only the row this run wrote, on the page it
+  // wrote it: closing as the user navigates leaves the next page's
+  // `?record=` alone.
+  const recordRecorder = (deepLink?: boolean) => {
     let written: WrittenRecord | undefined;
-    return (row?: Data): void => {
+    return (id?: string): void => {
       if (!deepLink || !config.recordScope || !config.rowNavigation) return;
-      if (!row) {
+      if (!id) {
         clearWrittenRecord(written);
         written = undefined;
         return;
       }
-      written = writeRecordId(config.recordScope, rowIdOf(row));
+      written = writeRecordId(config.recordScope, id);
     };
   };
+  const rowRecorder = (deepLink?: boolean) => {
+    const recordId = recordRecorder(deepLink);
+    return (row?: Data): void => recordId(rowIdOf(row));
+  };
+
+  // The header names the open row when the target words it from its fields.
+  const rowTitleOf = (target: SidePanelTarget, row?: Data) =>
+    row && target.rowTitle
+      ? resolveConfirmText(target.rowTitle, row, t as ConfirmTranslate)
+      : undefined;
+
+  const notFoundOf = (target: SidePanelTarget) => ({
+    title: processI18n(target.notFound?.title || `$${NOT_FOUND_TITLE_KEY}`),
+    description: processI18n(
+      target.notFound?.description || `$${NOT_FOUND_DESCRIPTION_KEY}`,
+    ),
+  });
 
   const ownerKey = rowSidePanelOwnerKey(config.pageId, config.componentId);
 
@@ -274,36 +297,40 @@ export function useActionTargets(config: ActionTargetsConfig) {
     const componentName = run.target.component?.componentName;
     if (!componentName) return;
     const session = Symbol(componentName);
-    const component = resolveTargetComponent(componentName);
-    const recordRow = rowRecorder(run.deepLink && !run.selection);
-    const componentOptions = {
-      ...run.target.component?.options,
-      pageId: config.pageId,
-      componentId: config.componentId,
-      containerId: run.containerId,
-      selection: run.selection,
-      onSuccessCallback: () => {
-        closeRowSidePanel(session);
-        config.refreshCallback?.();
+    const recordId = recordRecorder(run.deepLink && !run.selection);
+    const panel = {
+      session,
+      ownerKey,
+      title: run.title,
+      positionLabel: run.target.positionLabel,
+      component: resolveTargetComponent(componentName),
+      componentOptions: {
+        ...run.target.component?.options,
+        pageId: config.pageId,
+        componentId: config.componentId,
+        containerId: run.containerId,
+        selection: run.selection,
+        onSuccessCallback: () => {
+          closeRowSidePanel(session);
+          config.refreshCallback?.();
+        },
       },
+      onClose: () => recordId(undefined),
     };
     const showRow = (row?: Data) => {
       openRowSidePanel({
-        session,
-        ownerKey,
-        title: run.title,
-        positionLabel: run.target.positionLabel,
-        component,
-        componentOptions,
+        ...panel,
+        rowTitle: rowTitleOf(run.target, row),
         row,
         rowKey: rowIdOf(row),
         source: row ? config.rowNavigation : undefined,
         showRow,
-        onClose: () => recordRow(undefined),
       });
-      recordRow(row);
+      recordId(rowIdOf(row));
     };
-    showRow(run.rowData);
+    if (!run.missingId) return showRow(run.rowData);
+    openRowSidePanel({ ...panel, notFound: notFoundOf(run.target), showRow });
+    recordId(run.missingId);
   };
 
   // A container opened on a listed row steps through the rows shown (its
@@ -543,5 +570,26 @@ export function useActionTargets(config: ActionTargetsConfig) {
     );
   };
 
-  return { handleCustomButton, handleCustomRowAction, handleBulkCustomAction };
+  /**
+   * Opens a side panel action on a row its link names but its route answered
+   * 404 for: the panel says the row is gone, and closing it removes the link.
+   * Another target opens nothing: no row, no drawer.
+   */
+  const handleMissingRow = (action: CustomRowAction, id: string) => {
+    if (action.target.type !== "sidePanel") return;
+    handleSidePanelTarget({
+      target: action.target,
+      title: processI18n(action.target.title || action.label),
+      containerId: `${config.pageId}-${config.componentId}-${action.target.type}`,
+      deepLink: isDeepLinkAction(action),
+      missingId: id,
+    });
+  };
+
+  return {
+    handleCustomButton,
+    handleCustomRowAction,
+    handleBulkCustomAction,
+    handleMissingRow,
+  };
 }

package/frontend-vue/layers/dms-ui/app/build/composables/blocks/useBlockItems.ts

@@ -3,10 +3,16 @@ import { useChartFetch } from "../../../composables/chart/useChartFetch";
 import { useComponentEvent } from "../../../../../dms-core/app/composables/components/useComponentEvent";
 import { useWatch } from "../../../../../dms-core/app/composables/watch/useWatch";
 import type { WatchAction } from "../../../../../dms-core/app/types/watch";
+import {
+  type FetchNotFound,
+  readFetchNotFound,
+} from "../../utils/fetchNotFound";
 
 /** What a list block's `fetchUrl` answers with. */
 export interface BlockItemsResponse<T> {
   items?: T[];
+  /** How many items the source holds in all (an ActivityFeed's head count). */
+  count?: number;
 }
 
 export interface UseBlockItemsOptions<T> {
@@ -31,10 +37,17 @@ export interface UseBlockItemsOptions<T> {
 
 export interface UseBlockItemsReturn<T> {
   items: ComputedRef<T[]>;
+  /** The `count` the source answered with, if it answered one. */
+  count: ComputedRef<number | undefined>;
   /** First load of a fetched list: nothing to show yet. */
   isPending: ComputedRef<boolean>;
   /** The first load failed; a refetch failure keeps the last items. */
   hasError: ComputedRef<boolean>;
+  /**
+   * The source answered 404: what the block lists does not exist (its last
+   * items are dropped). `null` otherwise. Never also `hasError`.
+   */
+  notFound: ComputedRef<FetchNotFound | null>;
   refresh: () => Promise<void>;
 }
 
@@ -71,12 +84,23 @@ export function useBlockItems<T>(
   const items = computed<T[]>(() =>
     isFetched ? (data.value?.items ?? []) : (options.items() ?? []),
   );
+  const count = computed<number | undefined>(() =>
+    typeof data.value?.count === "number" ? data.value.count : undefined,
+  );
   const isPending = computed(
     () => isFetched && isLoading.value && data.value === null,
   );
+  const notFound = computed(() =>
+    isFetched && !isLoading.value ? readFetchNotFound(error.value) : null,
+  );
   const hasError = computed(
-    () => isFetched && !isLoading.value && data.value === null && !!error.value,
+    () =>
+      isFetched &&
+      !isLoading.value &&
+      data.value === null &&
+      !!error.value &&
+      !notFound.value,
   );
 
-  return { items, isPending, hasError, refresh };
+  return { items, count, isPending, hasError, notFound, refresh };
 }

package/frontend-vue/layers/dms-ui/app/build/composables/blocks/useGuard.ts

@@ -0,0 +1,115 @@
+import { computed, type ComputedRef } from "vue";
+import { useChartFetch } from "../../../composables/chart/useChartFetch";
+import {
+  type FetchNotFound,
+  readFetchNotFound,
+} from "../../utils/fetchNotFound";
+import type { BlockAction } from "../../components/blocks/BlockActions.vue";
+import type {
+  EmptyStateSize,
+  EmptyStateVariant,
+} from "../../../components/empty-state/EmptyState.vue";
+import type { Tone } from "../../../types/tone";
+
+/** The empty state a guard shows in place of its children (interface-dms `GuardFallback`). */
+export interface GuardFallback {
+  title?: string;
+  description?: string;
+  variant?: EmptyStateVariant;
+  icon?: string;
+  tone?: Tone;
+  hatched?: boolean;
+  size?: EmptyStateSize;
+  actions?: BlockAction[];
+  code?: { content: string; language?: string; copy?: boolean };
+  card?: boolean;
+}
+
+/** What a guard checks its route for (interface-dms `GuardCondition`). */
+export type GuardCondition = "empty" | "notFound";
+
+/** The route a guard reads and what it checks it for (interface-dms `GuardOptions`). */
+export interface GuardSource {
+  fetchUrl?: string;
+  fetchUrlMethod?: string;
+  periodScope?: string;
+  realtimeTopic?: string | string[];
+  when?: GuardCondition;
+  /** Dot path of the value `empty` checks; the whole answer without it. */
+  field?: string;
+}
+
+/** What the route answers: any value, maybe with an `emptyState` laid over the fallback. */
+export interface GuardResponse {
+  emptyState?: GuardFallback;
+  [field: string]: unknown;
+}
+
+/** Which condition held: the fallback to show, before its defaults. */
+export interface GuardState {
+  condition: GuardCondition;
+  /** The answer's `emptyState`, when the route sent one. */
+  override?: GuardFallback;
+  /** What the 404 said, for `notFound`: its message sets the default texts. */
+  notFound?: FetchNotFound;
+}
+
+const FIELD_PATH_SEPARATOR = ".";
+
+/** The value at a dot path of an answer, `undefined` where the path stops. */
+export function readFieldPath(source: unknown, path: string): unknown {
+  return path.split(FIELD_PATH_SEPARATOR).reduce<unknown>((value, key) => {
+    if (value === null || typeof value !== "object") return undefined;
+    return (value as Record<string, unknown>)[key];
+  }, source);
+}
+
+/** Absent, `null`, `false`, `0`, `""` or an empty list: nothing to show. */
+export function isEmptyValue(value: unknown): boolean {
+  if (Array.isArray(value)) return value.length === 0;
+  return !value;
+}
+
+function answerOverride(answer: unknown): GuardFallback | undefined {
+  if (!answer || typeof answer !== "object" || Array.isArray(answer)) {
+    return undefined;
+  }
+  const { emptyState } = answer as GuardResponse;
+  return emptyState && typeof emptyState === "object" ? emptyState : undefined;
+}
+
+/**
+ * The condition that holds, or `null` while the children show: while the
+ * route loads, after any failure other than the condition, and whenever the
+ * value is set. The route is read like a block's `fetchUrl` (URL tokens,
+ * period scope, realtime topics, page refresh); nothing is requested while
+ * a token has no value.
+ */
+export function useGuard(
+  options: () => GuardSource,
+  routeParams: () => Record<string, string> | undefined,
+): ComputedRef<GuardState | null> {
+  const initial = options();
+  const { data, error } = useChartFetch<unknown>({
+    fetchUrl: initial.fetchUrl,
+    fetchUrlMethod: initial.fetchUrlMethod,
+    periodScope: initial.periodScope,
+    realtimeTopic: initial.realtimeTopic,
+    routeParams,
+  });
+
+  return computed(() => {
+    const { when = "empty", field } = options();
+    const failure = error.value;
+    if (when === "notFound") {
+      const notFound = readFetchNotFound(failure);
+      if (!notFound) return null;
+      return { condition: when, override: notFound.emptyState, notFound };
+    }
+    const answer = data.value;
+    if (failure || answer === null || answer === undefined) return null;
+    const value = field ? readFieldPath(answer, field) : answer;
+    if (!isEmptyValue(value)) return null;
+    return { condition: when, override: answerOverride(answer) };
+  });
+}

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

@@ -68,7 +68,7 @@ const isTechnical = (text: string) =>
  * as it came. Undefined when it is not user-facing (an untranslated key, JSON,
  * a stack trace…), for the caller to fall back on a generic message.
  */
-const userFacingText = (
+export const userFacingText = (
   text: string | undefined,
   translate: I18nTranslate,
 ): string | undefined => {

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

@@ -1,6 +1,14 @@
-import type { ConfirmDialog } from "#dms-core/app/types/confirm-dialog";
+import type {
+  ConfirmDialog,
+  ConfirmDialogSecondaryAction,
+  ConfirmDialogSecondaryTarget,
+} from "#dms-core/app/types/confirm-dialog";
+import { interpolateUrl } from "#dms-core/app/utils/url-interpolation";
 import { readTranslationKey } from "#dms-core/app/composables/translation/useTranslation";
-import type { ConfirmOptions } from "../../../composables/confirm/types";
+import type {
+  ConfirmOptions,
+  ConfirmSecondaryAction,
+} from "../../../composables/confirm/types";
 import { processFieldI18n } from "../../utils/fieldOptionsI18n";
 import { interpolateLiteral } from "../../utils/literalText";
 
@@ -28,21 +36,68 @@ export function resolveConfirmText(
     : t(key, params);
 }
 
+/** Runs a dialog's secondary target, its URL already filled in. */
+export type SecondaryTargetRun = (
+  target: ConfirmDialogSecondaryTarget,
+) => Promise<void> | void;
+
+/**
+ * A dialog's secondary target with its URL (and file name) filled in with
+ * the same parameters as its texts.
+ */
+function resolveSecondaryTarget(
+  target: ConfirmDialogSecondaryTarget,
+  params: Record<string, unknown>,
+): ConfirmDialogSecondaryTarget {
+  const url = interpolateUrl(target.url, params);
+  if (target.type !== "download" || target.filename === undefined) {
+    return { ...target, url };
+  }
+  return {
+    ...target,
+    url,
+    filename: interpolateLiteral(target.filename, params),
+  };
+}
+
+function resolveSecondaryAction(
+  action: ConfirmDialogSecondaryAction | undefined,
+  params: Record<string, unknown>,
+  t: ConfirmTranslate,
+  runTarget: SecondaryTargetRun | undefined,
+): ConfirmSecondaryAction | undefined {
+  if (!action || !runTarget) return undefined;
+  const target = resolveSecondaryTarget(action.target, params);
+  return {
+    label: resolveConfirmText(action.label, params, t),
+    icon: action.icon,
+    run: () => runTarget(target),
+  };
+}
+
 /**
  * A confirmation dialog with its texts resolved, ready for `useConfirm()`:
  * interpolated with the row's fields (`row`) and the dialog's own `params`.
+ * Its secondary action is drawn only when given `runTarget` to run it with.
  */
 export function resolveConfirmDialog(
   dialog: ConfirmDialog,
   row: Record<string, unknown> | undefined,
   t: ConfirmTranslate,
+  runTarget?: SecondaryTargetRun,
 ): ConfirmOptions {
   const params = { ...row, ...dialog.params };
   const text = (value: string | undefined) =>
     value === undefined ? undefined : resolveConfirmText(value, params, t);
-  const { params: _params, ...rest } = dialog;
+  const { params: _params, secondaryAction, ...rest } = dialog;
   return {
     ...rest,
+    secondaryAction: resolveSecondaryAction(
+      secondaryAction,
+      params,
+      t,
+      runTarget,
+    ),
     title: text(dialog.title) ?? "",
     description: text(dialog.description),
     confirmLabel: text(dialog.confirmLabel),

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

@@ -0,0 +1,86 @@
+import type {
+  ConfirmDialogDownloadTarget,
+  ConfirmDialogLinkTarget,
+  ConfirmDialogSecondaryTarget,
+} from "#dms-core/app/types/confirm-dialog";
+import { downloadFile } from "#dms-core/app/utils/downloadFile";
+import type { SecondaryTargetRun } from "./confirmDialogTexts";
+
+/** The response a download reads: its body and its headers. */
+export interface DownloadResponse {
+  _data?: Blob;
+  headers: Headers;
+}
+
+/** Fetches a download with the user's session (`$authFetch.raw`). */
+export type DownloadFetch = (
+  url: string,
+  options: { responseType: "blob" },
+) => Promise<DownloadResponse>;
+
+const DISPOSITION_NAME = /filename\*?=(?:UTF-8'')?"?([^";]+)"?/i;
+const FALLBACK_FILENAME = "download";
+
+// A malformed escape is kept as written rather than failing the download.
+function decodeName(name: string): string {
+  try {
+    return decodeURIComponent(name);
+  } catch {
+    return name;
+  }
+}
+
+/**
+ * The name a download is saved under: the declared one, else the server's
+ * `Content-Disposition` one, else the URL's last path segment.
+ */
+export function downloadFilename(
+  target: ConfirmDialogDownloadTarget,
+  disposition: string | null,
+): string {
+  if (target.filename) return target.filename;
+  const served = disposition ? DISPOSITION_NAME.exec(disposition)?.[1] : "";
+  if (served) return decodeName(served.trim());
+  const path = target.url.split(/[?#]/)[0] ?? "";
+  return decodeName(path.split("/").pop() || FALLBACK_FILENAME);
+}
+
+function openLink(target: ConfirmDialogLinkTarget): void {
+  if (typeof window === "undefined" || !target.url) return;
+  if (target.newTab) {
+    window.open(target.url, "_blank", "noopener,noreferrer");
+    return;
+  }
+  window.location.href = target.url;
+}
+
+async function saveDownload(
+  target: ConfirmDialogDownloadTarget,
+  fetchRaw: DownloadFetch,
+): Promise<void> {
+  if (!target.url) return;
+  const response = await fetchRaw(target.url, { responseType: "blob" });
+  const blob = response._data ?? new Blob([]);
+  const objectUrl = URL.createObjectURL(blob);
+  try {
+    downloadFile(
+      objectUrl,
+      downloadFilename(target, response.headers.get("content-disposition")),
+    );
+  } finally {
+    URL.revokeObjectURL(objectUrl);
+  }
+}
+
+/**
+ * Runs the target of a confirmation's secondary action, the dialog left
+ * open: a link opens, a download is fetched with `fetchRaw` and saved.
+ */
+export function secondaryTargetRunner(
+  fetchRaw: DownloadFetch,
+): SecondaryTargetRun {
+  return (target: ConfirmDialogSecondaryTarget) =>
+    target.type === "download"
+      ? saveDownload(target, fetchRaw)
+      : openLink(target);
+}

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

@@ -13,6 +13,7 @@ import {
   type ConfirmTranslate,
   resolveConfirmDialog,
 } from "./confirmDialogTexts";
+import { type DownloadFetch, secondaryTargetRunner } from "./secondaryTarget";
 
 /** What an action asks its confirmation with. */
 export interface ActionConfirmRequest {
@@ -44,6 +45,9 @@ export function useActionConfirm() {
   const { $authFetch } = useAuthFetch();
   const { t } = useI18n();
   const toast = useToast();
+  const runSecondaryTarget = secondaryTargetRunner(
+    $authFetch.raw as unknown as DownloadFetch,
+  );
 
   const loadDialog = async (
     declared: ActionConfirm,
@@ -81,6 +85,7 @@ export function useActionConfirm() {
       dialog,
       request.row,
       t as ConfirmTranslate,
+      runSecondaryTarget,
     );
     const isConfirmed = await confirm({
       ...request.fallback,

package/frontend-vue/layers/dms-ui/app/build/composables/live/currentPageLive.ts

@@ -48,6 +48,11 @@ export interface LiveGate {
   catchUp(): void;
   /** Records a read the caller makes itself (see LiveSubscription). */
   acknowledge(): void;
+  /**
+   * Holds the block alone while the page stays live (see LiveSubscription).
+   * Does nothing on a page without `live`.
+   */
+  setHeld(isHeld: boolean): void;
 }
 
 interface BoundSubscription {
@@ -103,5 +108,6 @@ export function useLiveGate(refresh: () => void): LiveGate {
       else refresh();
     },
     acknowledge: () => resolve()?.acknowledge(),
+    setHeld: (isHeld) => resolve()?.setHeld(isHeld),
   };
 }