@antelopejs/dms 0.9.8 → 0.11.0

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/utils/linkedArrival.ts

@@ -0,0 +1,308 @@
+import { nextTick } from "vue";
+import {
+  hashText,
+  type TableField,
+} from "#dms-core/app/build/composables/user/tablePreferences";
+import type { QueryParamFilters } from "../../../../composables/table-view/types/config";
+import type { TablePreferences } from "../useTablePreferences";
+import { RECORD_URL_KEY } from "./recordLink";
+import { readTableUrlKey, type TableUrlScope, writeTableUrlKey } from "./views";
+
+/**
+ * The kept fields that decide which rows a table lists: a link that names
+ * part of that state replaces all of it, not only what it names.
+ */
+const LINKED_STATE_FIELDS: ReadonlySet<TableField> = new Set<TableField>([
+  "activeView",
+  "activeTab",
+  "columnFilters",
+  "sorting",
+  "pagination",
+  "paginationScope",
+]);
+
+/**
+ * The listing choices a user makes on a link's table (a view, a tab, a
+ * filter, a sort): the first one makes the state shown their own.
+ */
+const USER_CHOICE_FIELDS: ReadonlySet<TableField> = new Set<TableField>([
+  "activeView",
+  "activeTab",
+  "columnFilters",
+  "sorting",
+]);
+
+const VIEW_URL_KEY = "view";
+const TAB_URL_KEY = "tab";
+
+/**
+ * What `query` names as the table's view: an id, `""` for no view at all
+ * (`?view=`), or `undefined` when it names none.
+ */
+const namedView = (
+  query: Record<string, unknown>,
+  urlScope: TableUrlScope,
+): string | undefined => {
+  const reading = readTableUrlKey(query, urlScope, VIEW_URL_KEY);
+  return reading.isCleared ? "" : reading.value;
+};
+
+/** What the URL a table arrives on may name, and how it was reached. */
+export interface TableLinkArrival {
+  query: Record<string, unknown>;
+  urlScope: TableUrlScope;
+  queryParamFilters: QueryParamFilters | undefined;
+  /** The page was reached through a visit, not loaded or gone back to. */
+  isVisit: boolean;
+  /** The tab kept from the last visit. */
+  rememberedTab: string;
+  /** The URL filters the kept state was chosen under (`urlFilterScope`). */
+  keptLinkScope: string | undefined;
+  /** The link the table last showed, unclaimed by the user (`linkKeyScope`). */
+  shownLink: string | undefined;
+}
+
+const namesUrlFilter = (
+  query: Record<string, unknown>,
+  queryParamFilters: QueryParamFilters | undefined,
+  isNamed: (param: string) => boolean,
+): boolean =>
+  Object.keys(queryParamFilters ?? {}).some(
+    (param) => query[param] !== undefined && isNamed(param),
+  );
+
+/**
+ * The `queryParamFilters` values `query` carries, as one key, or `undefined`
+ * when it carries none: what a kept state chosen under them is tied to.
+ */
+export function urlFilterScope(
+  query: Record<string, unknown>,
+  queryParamFilters: QueryParamFilters | undefined,
+): string | undefined {
+  const values = Object.keys(queryParamFilters ?? {})
+    .filter((param) => query[param] !== undefined)
+    .sort()
+    .map((param) => [param, query[param]]);
+  return values.length > 0 ? hashText(JSON.stringify(values)) : undefined;
+}
+
+/**
+ * What `query` names for the table (its view, tab and row, and the filters
+ * declared in `queryParamFilters`), as one key, or `undefined` when it names
+ * none of them: a URL spelling a key short or prefixed reads the same.
+ */
+export function linkKeyScope(
+  query: Record<string, unknown>,
+  urlScope: TableUrlScope,
+  queryParamFilters: QueryParamFilters | undefined,
+): string | undefined {
+  const named = [
+    [VIEW_URL_KEY, namedView(query, urlScope)],
+    ...[TAB_URL_KEY, RECORD_URL_KEY].map((key) => [
+      key,
+      readTableUrlKey(query, urlScope, key).value,
+    ]),
+  ].filter(([, value]) => value !== undefined);
+  const filters = Object.keys(queryParamFilters ?? {})
+    .filter((param) => query[param] !== undefined)
+    .sort()
+    .map((param) => [`?${param}`, query[param]]);
+  const values = [...named, ...filters];
+  return values.length > 0 ? hashText(JSON.stringify(values)) : undefined;
+}
+
+/**
+ * Whether the table was reached through a link that names what it lists: a
+ * view, a record, a filter declared in `queryParamFilters`, or a tab. Reached
+ * through a visit (a link clicked, a notification), it always is, even when
+ * what it names is what the user left. Loaded in full (a reload) or gone back
+ * to, the URL may be the one the table wrote for the user's own choices: it
+ * is a link again when it is the link the table last showed, and when it
+ * names a view or a record, or a tab or URL filters other than the kept
+ * ones. A server render cannot tell a reload from a URL typed or opened in a
+ * new browser tab, so a full load naming only the kept tab reads as one.
+ */
+export function isLinkedArrival(arrival: TableLinkArrival): boolean {
+  const { query, urlScope, queryParamFilters } = arrival;
+  const linkScope = linkKeyScope(query, urlScope, queryParamFilters);
+  if (linkScope === undefined) return false;
+  if (arrival.isVisit || linkScope === arrival.shownLink) return true;
+  const names = (key: string) => !!readTableUrlKey(query, urlScope, key).value;
+  if (namedView(query, urlScope) !== undefined || names(RECORD_URL_KEY)) {
+    return true;
+  }
+  const filterScope = urlFilterScope(query, queryParamFilters);
+  if (filterScope !== undefined && filterScope !== arrival.keptLinkScope) {
+    return true;
+  }
+  const tab = readTableUrlKey(query, urlScope, TAB_URL_KEY).value;
+  return tab !== undefined && tab !== arrival.rememberedTab;
+}
+
+/**
+ * The table's preferences as a link arrival reads them: the listing state
+ * (`LINKED_STATE_FIELDS`) reads as its defaults, so the link applies over
+ * the table's own default state rather than over the last visit's. The
+ * kept state is only replaced once the user makes the state shown their own
+ * (`linkFollowingPreferences`).
+ */
+export function linkedArrivalPreferences(
+  preferences: TablePreferences,
+): TablePreferences {
+  return {
+    ...preferences,
+    get: (field, defaultValue) =>
+      LINKED_STATE_FIELDS.has(field)
+        ? defaultValue
+        : preferences.get(field, defaultValue),
+  };
+}
+
+/** A visit to the page the table is already shown on. */
+export interface TableLinkVisit {
+  query: Record<string, unknown>;
+  /**
+   * A link pushed on the page (one clicked, a notification): it is followed
+   * even when it names what the table shows.
+   */
+  isLinkClick: boolean;
+  /** The query of the visit the table was last reached through. */
+  previousQuery: Record<string, unknown>;
+  urlScope: TableUrlScope;
+  queryParamFilters: QueryParamFilters | undefined;
+  /** The view and the tab the table shows. */
+  activeView: string | undefined;
+  activeTab: string;
+  canOpenView: (id: string) => boolean;
+  canOpenTab: (id: string) => boolean;
+}
+
+/**
+ * Whether a visit that keeps the table mounted (a link to the page already
+ * shown, back and forward) is a link to follow as an arrival would. A link
+ * clicked on the page counts whenever it names a view or a tab the table can
+ * open, or a URL filter, even what the table already shows: the state around
+ * it may hide it. Otherwise (back and forward), the view and the tab are
+ * written or kept in place, so they count when they differ from what the
+ * table shows; a URL filter when it differs from the last visit. A row named
+ * (`?record=`) is opened on the table as it stands, its page included: it is
+ * no listing link, and a link naming one counts only for a view, a tab or a
+ * URL filter that changes what the table lists. A visit repeating what the
+ * table already reads (the one that mounted it) is not a link.
+ */
+export function isLinkedVisit(visit: TableLinkVisit): boolean {
+  const { query, previousQuery, urlScope, isLinkClick } = visit;
+  const read = (from: Record<string, unknown>, key: string) =>
+    readTableUrlKey(from, urlScope, key).value;
+  // A link clicked counts even when it names what is already there, unless
+  // it opens a row: the table it is opened on stays as it stands.
+  const isRowLink = read(query, RECORD_URL_KEY) !== undefined;
+  const isNew = (value: unknown, current: unknown) =>
+    (isLinkClick && !isRowLink) || value !== current;
+  const view = namedView(query, urlScope);
+  if (view === "" && isNew(undefined, visit.activeView)) return true;
+  if (view && isNew(view, visit.activeView) && visit.canOpenView(view)) {
+    return true;
+  }
+  const tab = read(query, TAB_URL_KEY);
+  if (tab && isNew(tab, visit.activeTab) && visit.canOpenTab(tab)) return true;
+  return namesUrlFilter(query, visit.queryParamFilters, (param) =>
+    isNew(query[param], previousQuery[param]),
+  );
+}
+
+/** A kept field of the listing state, with its value shown and default. */
+export type KeptListingField = [
+  field: TableField,
+  value: unknown,
+  defaultValue: unknown,
+];
+
+/** What `linkFollowingPreferences` reads the table's link state from. */
+export interface LinkFollowingOptions {
+  /** The table arrived on a link (`isLinkedArrival`). */
+  isLinkedArrival: boolean;
+  urlScope: TableUrlScope;
+  /** The URL filters the table lists under now (`urlFilterScope`). */
+  linkScope: () => string | undefined;
+  /** What the URL shown names for the table now (`linkKeyScope`). */
+  linkKeys: () => string | undefined;
+  /** The listing state shown, as it is kept (`LINKED_STATE_FIELDS`). */
+  listingState: () => KeptListingField[];
+}
+
+/** Preferences that leave a link's listing state unkept until it is the user's. */
+export interface LinkFollowingPreferences extends TablePreferences {
+  /**
+   * Runs `change`, which opens a link on the table already shown: as on a
+   * linked arrival, the state it sets is not kept.
+   */
+  followLink: (change: () => void) => Promise<void>;
+  /** Called once the table is mounted: what changes from then is the user's. */
+  settleArrival: () => Promise<void>;
+}
+
+/**
+ * Wraps the table's preferences so the listing state a link opens (on
+ * arrival or on the table already shown) does not overwrite the kept one,
+ * which stays for the next plain visit. The table keeps its state from
+ * watchers, which run on the next flush: what the link and the arrival set
+ * is settled a tick later. The user's first choice from there (a view, a
+ * tab, a filter, a sort) makes the state shown theirs: it is kept whole,
+ * with the URL filters it was chosen under, and the view the link named
+ * leaves the URL, which then reads as a plain visit on reload. Until then,
+ * the link shown is kept too (`shownLink`), so a reload shows it again.
+ */
+export function linkFollowingPreferences(
+  preferences: TablePreferences,
+  options: LinkFollowingOptions,
+): LinkFollowingPreferences {
+  let isShowingLink = options.isLinkedArrival;
+  let isSettled = false;
+
+  const keepLinkScope = () => {
+    preferences.set("linkScope", options.linkScope(), undefined);
+    preferences.set("shownLink", undefined, undefined);
+  };
+  const keepShownLink = () =>
+    preferences.set("shownLink", options.linkKeys(), undefined);
+
+  const takeOver = () => {
+    isShowingLink = false;
+    for (const [field, value, defaultValue] of options.listingState()) {
+      preferences.set(field, value, defaultValue);
+    }
+    keepLinkScope();
+    writeTableUrlKey(options.urlScope, VIEW_URL_KEY);
+  };
+
+  return {
+    ...preferences,
+    set: (field, value, defaultValue) => {
+      if (!LINKED_STATE_FIELDS.has(field)) {
+        preferences.set(field, value, defaultValue);
+      } else if (!isShowingLink) {
+        preferences.set(field, value, defaultValue);
+        keepLinkScope();
+      } else if (isSettled && USER_CHOICE_FIELDS.has(field)) {
+        takeOver();
+      }
+    },
+    followLink: async (change) => {
+      isShowingLink = true;
+      isSettled = false;
+      try {
+        change();
+        await nextTick();
+        keepShownLink();
+      } finally {
+        isSettled = true;
+      }
+    },
+    settleArrival: async () => {
+      await nextTick();
+      if (isShowingLink) keepShownLink();
+      isSettled = true;
+    },
+  };
+}

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/utils/locateRow.ts

@@ -0,0 +1,106 @@
+import { get } from "@nuxt/ui/runtime/utils/index.js";
+import type { RowLocation } from "../../actions/rowNavigation";
+
+/** One window of the table's result, under its current query. */
+export interface LocatedWindow {
+  results: Data[];
+  total: number;
+}
+
+export interface RowLocatorOptions {
+  /**
+   * Reads the rows from `offset`, `limit` of them, under the table's current
+   * query; `limit: 0` reads every row (`wholeRead`). `null` while it cannot.
+   */
+  list: (offset: number, limit: number) => Promise<LocatedWindow | null>;
+  rowIdKey: string;
+  /**
+   * The table pages the rows itself (a source answering every row): one read
+   * holds them all.
+   */
+  isWholeRead?: () => boolean;
+}
+
+/** Rows read per window while looking for a row. */
+export const LOCATE_WINDOW = 200;
+/**
+ * How far into the result a row is looked for: past it, a deep link opens
+ * without a position rather than reading the table to its end.
+ */
+export const LOCATE_MAX_ROWS = 5_000;
+const HALF_WINDOW = Math.floor(LOCATE_WINDOW / 2);
+/** The row and one on each side. */
+const NEIGHBOURHOOD = 3;
+
+const idOf = (row: Data, rowIdKey: string): string =>
+  String(get(row, rowIdKey));
+
+/** The location of the row at `local` in `rows`, read from `offset`. */
+function locationIn(
+  window: LocatedWindow,
+  offset: number,
+  local: number,
+): RowLocation {
+  return {
+    index: offset + local,
+    total: Math.max(window.total, offset + local + 1),
+    prev: window.results[local - 1],
+    next: window.results[local + 1],
+  };
+}
+
+/**
+ * Finds a row among all the rows a table lists, by id, reading its result
+ * a window at a time: a deep link to a row past the page loaded, or a row
+ * live updates pushed out of it, gets its position and its neighbours in the
+ * table's current order. Each window overlaps the previous one by a row, so a
+ * row found has its neighbours with it; one at a window's edge has them read
+ * around it.
+ */
+export function rowLocator(options: RowLocatorOptions) {
+  const { list, rowIdKey } = options;
+  const find = (window: LocatedWindow, id: string) =>
+    window.results.findIndex((row) => idOf(row, rowIdKey) === id);
+
+  const withNeighbours = async (
+    location: RowLocation,
+  ): Promise<RowLocation> => {
+    const lacksPrev = !location.prev && location.index > 0;
+    const lacksNext = !location.next && location.index < location.total - 1;
+    if (!lacksPrev && !lacksNext) return location;
+    const offset = Math.max(0, location.index - 1);
+    const around = await list(offset, NEIGHBOURHOOD);
+    const local = around ? location.index - offset : -1;
+    if (!around || !around.results[local]) return location;
+    return { ...locationIn(around, offset, local), total: location.total };
+  };
+
+  return async (
+    id: string,
+    hint?: number,
+  ): Promise<RowLocation | undefined> => {
+    if (options.isWholeRead?.()) {
+      const all = await list(0, 0);
+      const local = all ? find(all, id) : -1;
+      return all && local >= 0 ? locationIn(all, 0, local) : undefined;
+    }
+    // The window around where the row last stood first, then the result
+    // from its start, until its end or the rows looked through run out.
+    const starts = hint === undefined ? [] : [Math.max(0, hint - HALF_WINDOW)];
+    let end = LOCATE_MAX_ROWS;
+    for (let start = 0; start < end; start += LOCATE_WINDOW) starts.push(start);
+    const read = new Set<number>();
+    for (const start of starts) {
+      if (read.has(start) || start >= end) continue;
+      read.add(start);
+      // One row before the window: its first row's previous.
+      const offset = Math.max(0, start - 1);
+      const window = await list(offset, LOCATE_WINDOW + (start > 0 ? 2 : 1));
+      if (!window) return undefined;
+      const local = find(window, id);
+      if (local >= 0) return withNeighbours(locationIn(window, offset, local));
+      end = Math.min(window.total, LOCATE_MAX_ROWS);
+    }
+    return undefined;
+  };
+}

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/utils/pageArrival.ts

@@ -0,0 +1,34 @@
+/**
+ * How the page shown was reached: a full load of the document (a reload, a
+ * URL typed or opened in a new browser tab), an Inertia visit (a link, a
+ * redirect), or Back and Forward.
+ */
+export type PageArrivalKind = "load" | "visit" | "history";
+
+interface InertiaBeforeDetail {
+  visit: { prefetch?: boolean };
+}
+
+let arrivalKind: PageArrivalKind = "load";
+let isTracking = false;
+
+/**
+ * Starts following how each page is reached, once, when the app starts: a
+ * table mounted later must still see the visit that brought it. A server
+ * render never tracks, so it and the hydrating client both read a full load.
+ */
+export function trackPageArrivals(): void {
+  if (typeof document === "undefined" || isTracking) return;
+  isTracking = true;
+  // A prefetch (a link hovered) announces a visit that may never be made.
+  document.addEventListener("inertia:before", (event) => {
+    const { visit } = (event as CustomEvent<InertiaBeforeDetail>).detail;
+    if (!visit.prefetch) arrivalKind = "visit";
+  });
+  window.addEventListener("popstate", () => {
+    arrivalKind = "history";
+  });
+}
+
+/** How the page shown was reached (`trackPageArrivals`). */
+export const pageArrivalKind = (): PageArrivalKind => arrivalKind;

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/utils/pinnedRows.ts

@@ -27,3 +27,20 @@ export function pinRows<T extends Record<string, unknown>>(
   );
   return pinned.length === 0 ? rows : [...pinned, ...rest];
 }
+
+/**
+ * `rows` as a table reading `span` of them at a time shows them: the pinned
+ * rows lead each read, not the whole list. `rows` starts at a read's first.
+ */
+export function pinRowsBySpan<T extends Record<string, unknown>>(
+  rows: T[],
+  span: number,
+  pinnedRows: RowActionRule | undefined,
+): T[] {
+  if (!pinnedRows || span <= 0) return pinRows(rows, pinnedRows);
+  const spans: T[][] = [];
+  for (let start = 0; start < rows.length; start += span) {
+    spans.push(pinRows(rows.slice(start, start + span), pinnedRows));
+  }
+  return spans.flat();
+}

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/utils/quickFilters.ts

@@ -1,6 +1,14 @@
 import type { TableViewColumn } from "../../../../composables/table-view/types/column";
 import type { TableViewQuickFilterMode } from "../../../../composables/table-view/types/config";
 import type { TableFilter } from "../../../components/table/Table.vue";
+import type {
+  DataType,
+  DataTypeSelectSource,
+} from "#dms-core/app/composables/data-types/useDataType";
+import {
+  relationRowLabel,
+  relationRowValue,
+} from "../../data-types/relationRows";
 
 /** A value a quick filter offers. */
 export interface QuickFilterItem {
@@ -20,22 +28,13 @@ export interface ResolvedQuickFilter {
   pending?: boolean;
 }
 
-/** Where a relation quick filter reads its values from. */
-export interface QuickFilterRelationSource {
-  url: string;
-  labelKey: string;
-  valueKey: string;
-}
-
 interface ColumnInputOptions {
   items?: Array<{ value: unknown; label: string }>;
+  /** A tags column's suggested tags: the values it offers. */
+  suggestions?: string[];
   multiple?: boolean;
-  searchUrl?: string;
-  keyMapping?: { label?: string; value?: string };
 }
 
-const DEFAULT_LABEL_KEY = "name";
-const DEFAULT_VALUE_KEY = "_id";
 const ARRAY_MODE: TableViewQuickFilterMode = "array_contains_string";
 const SCALAR_MODE: TableViewQuickFilterMode = "is";
 
@@ -44,26 +43,30 @@ const inputOptions = (column: TableViewColumn | undefined) =>
 
 /**
  * The compare mode a quick filter applies: the declared one, else "contains"
- * for a multiple select or relation (the row holds a list) and equality
- * otherwise.
+ * when the row holds a list -- a multiple select or relation, or a type that
+ * filters on "contains" by default (tags) -- and equality otherwise.
  */
 export function quickFilterMode(
   column: TableViewColumn | undefined,
   declared?: TableViewQuickFilterMode,
 ): TableViewQuickFilterMode {
   if (declared) return declared;
-  return inputOptions(column).multiple ? ARRAY_MODE : SCALAR_MODE;
+  const holdsList =
+    inputOptions(column).multiple ||
+    column?.type?.defaultCompareMode === ARRAY_MODE;
+  return holdsList ? ARRAY_MODE : SCALAR_MODE;
 }
 
 /**
- * The values a select or boolean column offers, known from its declaration;
- * `undefined` for a column whose values must be fetched (a relation).
+ * The values a select, boolean or tags column offers (a select's items, a
+ * tags column's `suggestions`), known from its declaration; `undefined` for a
+ * column that declares none (a relation's are fetched).
  */
 export function staticQuickFilterItems(
   column: TableViewColumn | undefined,
   translate: (key: string) => string,
 ): QuickFilterItem[] | undefined {
-  if (!column) return [];
+  if (!column) return undefined;
   const typeId = column.type?.id;
   if (typeId === "boolean" || typeId === "status") {
     return [
@@ -74,41 +77,45 @@ export function staticQuickFilterItems(
       },
     ];
   }
-  const items = inputOptions(column).items;
+  const { items, suggestions } = inputOptions(column);
   if (items) {
     return items.map((item) => ({
       value: String(item.value),
       label: translate(item.label),
     }));
   }
-  return relationQuickFilterSource(column) ? undefined : [];
+  if (suggestions) {
+    return suggestions.map((tag) => ({ value: tag, label: tag }));
+  }
+  return undefined;
 }
 
-/** The `select` endpoint a relation column picks its rows from. */
+/**
+ * Where a relation column's values are read: the `select` route its data
+ * type's {@link DataType.selectSource} names, as for its picker and its
+ * filter chips.
+ */
 export function relationQuickFilterSource(
   column: TableViewColumn | undefined,
-): QuickFilterRelationSource | undefined {
-  const options = inputOptions(column);
-  if (!options.searchUrl) return undefined;
-  return {
-    url: options.searchUrl,
-    labelKey: options.keyMapping?.label ?? DEFAULT_LABEL_KEY,
-    valueKey: options.keyMapping?.value ?? DEFAULT_VALUE_KEY,
-  };
+  getDataType: (id: string) => DataType | undefined,
+): DataTypeSelectSource | undefined {
+  const typeId = column?.type?.id;
+  if (!typeId) return undefined;
+  return getDataType(typeId)?.selectSource?.(inputOptions(column));
 }
 
-/** Rows of a relation's `select` endpoint as quick filter values. */
+/** Rows of a relation's `select` route as quick filter values. */
 export function relationQuickFilterItems(
   rows: Array<Record<string, unknown>>,
-  source: QuickFilterRelationSource,
+  source: DataTypeSelectSource,
 ): QuickFilterItem[] {
   return rows.flatMap((row) => {
-    const value = row[source.valueKey];
+    const value = relationRowValue(source, row);
     if (value === undefined || value === null) return [];
     return [
       {
         value: String(value),
-        label: String(row[source.labelKey] ?? value),
+        label: String(relationRowLabel(source, row) ?? value),
       },
     ];
   });
@@ -118,7 +125,8 @@ export function relationQuickFilterItems(
 const isQuickFilterOf =
   (quickFilter: Pick<ResolvedQuickFilter, "field" | "mode">) =>
   (filter: TableFilter): boolean =>
-    filter.accessorKey === quickFilter.field && filter.mode === quickFilter.mode;
+    filter.accessorKey === quickFilter.field &&
+    filter.mode === quickFilter.mode;
 
 /**
  * The value a quick filter shows as picked: the one its column's filter holds

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/utils/recordLink.ts

@@ -39,12 +39,28 @@ export function writeRecordId(
 
 /**
  * Whether an action keeps the row it opens in the URL: a side panel does
- * unless its target or the action sets `deepLink: false`, a drawer or a modal
- * only with the action's `deepLink: true`.
+ * unless its target or the action sets `deepLink: false`, a drawer only with
+ * its target's or the action's `deepLink: true`, a modal only with the
+ * action's.
  */
 export function isDeepLinkAction(action: CustomRowAction): boolean {
-  if (action.target.type !== "sidePanel") return !!action.deepLink;
-  return (action.deepLink ?? action.target.deepLink) !== false;
+  const { target } = action;
+  if (target.type === "sidePanel") {
+    return (action.deepLink ?? target.deepLink) !== false;
+  }
+  if (target.type === "drawer") return !!(action.deepLink ?? target.deepLink);
+  return !!action.deepLink;
+}
+
+/**
+ * Whether the action's container draws its own "no longer available" state
+ * on a row that is gone: a side panel always, a drawer once its target words
+ * it (`notFound`).
+ */
+export function hasMissingRowState(action: CustomRowAction): boolean {
+  const { target } = action;
+  if (target.type === "sidePanel") return true;
+  return target.type === "drawer" && !!target.notFound;
 }
 
 /** The row a table wrote in the URL, and the page it wrote it on. */
@@ -114,8 +130,9 @@ export async function resolveDeepLinkedRow<T>(
 
 /**
  * What a table does with the row a deep link resolved to: open it, let a side
- * panel show its own "no longer available" state, tell the user the link led
- * nowhere (a drawer or a modal has no such state, and a table with no route to
+ * panel (or a drawer wording it) show its own "no longer available" state,
+ * tell the user the link led nowhere (any other container has no such state,
+ * and a table with no route to
  * read one row finds nothing either), or tell them the row could not be read
  * (a refusal, the network) without claiming it is gone.
  */
@@ -131,7 +148,6 @@ export function deepLinkOutcome(
 ): DeepLinkOutcome {
   if (found.row) return "open";
   if (found.isFailed) return "notifyFailed";
-  if (found.isMissing && action.target.type === "sidePanel")
-    return "missingPanel";
+  if (found.isMissing && hasMissingRowState(action)) return "missingPanel";
   return "notify";
 }