@antelopejs/dms 0.7.21 → 0.8.1

package/frontend-vue/tests/form-enclosing-form.test.ts

@@ -5,8 +5,6 @@
  * leaves with its component, and focusing a field by id. A page opened on a
  * field's anchor focuses that field.
  */
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import { createApp, defineComponent, h } from "vue";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
@@ -120,22 +118,3 @@ describe("a field's anchor", () => {
     expect(linkedFieldId("#%E0%A4%A", FIELD_IDS)).toBe(undefined);
   });
 });
-
-describe("the Form", () => {
-  const formSource = readFileSync(
-    resolve(__dirname, "../layers/dms-ui/app/components/form/Form.vue"),
-    "utf8",
-  );
-
-  it("offers its fields the submit, its validators and the focus", () => {
-    expect(formSource).toMatch(
-      /provide\(FORM_HANDLE_KEY, \{\s*submit: async \(\) => \{\s*await form\.value\?\.submit\(\);\s*\},\s*registerValidator,\s*revealField,\s*\}\);/,
-    );
-  });
-
-  it("follows the anchor of a field once mounted, a page form only", () => {
-    expect(formSource).toMatch(
-      /if \(!inFormContainer && !container\) \{\s*const followFieldAnchor = \(\) => \{\s*const fieldId = linkedFieldId\(window\.location\.hash, allFieldIds\.value\);/,
-    );
-  });
-});

package/frontend-vue/tests/form-entry-order.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { orderFormEntries } from "../layers/dms-ui/app/build/composables/form/formEntryOrder";
+import type { FormFieldOrGroup } from "../layers/dms-ui/app/composables/form/types/field";
+
+const field = (id: string) => ({
+  id,
+  component: { componentName: "dms-input-text" },
+});
+
+const group = (id: string, order?: number) => ({
+  id,
+  order,
+  fields: [field(`${id}Member`)],
+});
+
+const ids = (entries: FormFieldOrGroup[]) => entries.map((entry) => entry.id);
+
+describe("orderFormEntries", () => {
+  it("moves the groups giving an order into their places, lowest first", () => {
+    const entries: FormFieldOrGroup[] = [
+      field("username"),
+      group("contact"),
+      field("bio"),
+      group("social", 2),
+      group("address", 1),
+    ];
+    expect(ids(orderFormEntries(entries))).toEqual([
+      "username",
+      "contact",
+      "bio",
+      "address",
+      "social",
+    ]);
+  });
+
+  it("keeps the declaration order of equal orders and of no order at all", () => {
+    const entries: FormFieldOrGroup[] = [
+      group("first", 1),
+      field("name"),
+      group("second", 1),
+      group("loose"),
+    ];
+    expect(ids(orderFormEntries(entries))).toEqual(ids(entries));
+  });
+});

package/frontend-vue/tests/form-footer-kind.test.ts

@@ -69,23 +69,28 @@ describe("saveBarState of an action form", () => {
     });
   });
 
-  it("shows nothing on a page while untouched", () => {
-    expect(action({}).isHidden).toBe(true);
+  it("shows its submit alone, ready, on a page while untouched", () => {
+    // A pre-filled form sends its defaults as they are.
+    expect(action({})).toEqual({
+      showsStatus: false,
+      showsSubmit: true,
+      isSubmitHeld: false,
+      isHidden: false,
+    });
   });
 
-  it("offers Cancel beside its held submit in a drawer or a modal", () => {
-    // The invite modal: empty, it still shows the way out and its "Invite".
+  it("offers Cancel beside its ready submit in a drawer or a modal", () => {
     expect(action({ cancellable: true })).toEqual({
       showsStatus: false,
       secondary: "cancel",
       showsSubmit: true,
-      isSubmitHeld: true,
+      isSubmitHeld: false,
       isHidden: false,
     });
   });
 
   it("shows its submit alone, ready, when nothing in it can be changed", () => {
-    const bar = action({ resettable: false });
+    const bar = action({ resettable: false, dirty: true });
     expect(bar.secondary).toBeUndefined();
     expect(bar).toMatchObject({
       showsSubmit: true,

package/frontend-vue/tests/form-load-error.test.ts

@@ -4,7 +4,9 @@ import { renderToString } from "vue/server-renderer";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import FormLoadError from "../layers/dms-ui/app/build/components/form/FormLoadError.vue";
 import {
+  type FormLoadFailure,
   type FormLoadSource,
+  missingRecordFailure,
   trackFormRecordLoad,
 } from "../layers/dms-ui/app/build/composables/form/formRecordLoad";
 
@@ -72,6 +74,32 @@ describe("a form's record load", () => {
   });
 });
 
+describe("a form about a record its address names none of", () => {
+  const FETCH_URL = "/api/tasks/get?id={{query.id}}";
+
+  it("reports the record missing while the id is not in the address", () => {
+    expect(
+      missingRecordFailure({ requiresRecord: true, fetchUrl: FETCH_URL }),
+    ).toBe("missing");
+  });
+
+  it("reports nothing once the address names the record", () => {
+    expect(
+      missingRecordFailure({
+        requiresRecord: true,
+        fetchUrl: FETCH_URL,
+        resolvedFetchUrl: "/api/tasks/get?id=1",
+      }),
+    ).toBe(null);
+  });
+
+  it("leaves a form that may open without a record to its defaults", () => {
+    // A create form seeded by `?duplicate=` when there is one.
+    expect(missingRecordFailure({ fetchUrl: FETCH_URL })).toBe(null);
+    expect(missingRecordFailure({ requiresRecord: true })).toBe(null);
+  });
+});
+
 describe("the load error a form shows", () => {
   const Slot = defineComponent({
     props: {
@@ -91,7 +119,7 @@ describe("the load error a form shows", () => {
         ]),
   });
 
-  async function render(failure: "forbidden" | "error"): Promise<string> {
+  async function render(failure: FormLoadFailure): Promise<string> {
     const app = createSSRApp({
       render: () => h(FormLoadError, { failure }),
     });
@@ -118,6 +146,13 @@ describe("the load error a form shows", () => {
     expect(html).toContain("dms.form.load_error.retry");
   });
 
+  it("says no entry is selected, with nothing to retry", async () => {
+    const html = await render("missing");
+    expect(html).toContain("dms.form.load_error.missing_title");
+    expect(html).toContain("dms.form.load_error.missing_description");
+    expect(html).not.toContain("dms.form.load_error.retry");
+  });
+
   it("has its texts in English and French", () => {
     for (const file of ["ui-en-GB.json", "ui-fr-FR.json"]) {
       const locale = JSON.parse(
@@ -131,30 +166,10 @@ describe("the load error a form shows", () => {
         "error_title",
         "forbidden_description",
         "forbidden_title",
+        "missing_description",
+        "missing_title",
         "retry",
       ]);
     }
   });
 });
-
-describe("a form whose record did not load", () => {
-  const formSource = readFileSync(
-    new URL("../layers/dms-ui/app/components/form/Form.vue", import.meta.url),
-    "utf8",
-  );
-
-  it("shows the load error instead of its fields", () => {
-    expect(formSource).toMatch(
-      /<div v-if="loadFailure"[^>]*>\s*<DmsFormLoadError[\s\S]*?<\/div>\s*<div v-else :class="surfaceClasses\.body">/,
-    );
-  });
-
-  it("cannot be saved: no save bar, and a submit is refused", () => {
-    expect(formSource).toMatch(
-      /<DmsSaveBar\s+v-if="canSave && !isInstant && !loadFailure"/,
-    );
-    expect(formSource).toMatch(
-      /function onSubmit\([^)]*\) \{\s*if \(loadFailure\.value \|\| !runValidators\(\)\) return;/,
-    );
-  });
-});

package/frontend-vue/tests/grid-responsive-columns.test.ts

@@ -1,7 +1,7 @@
-import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
 import {
   GRID_TRACKS_VAR,
+  gridCollapsedCellStyles,
   gridColumnsTemplate,
   gridResponsiveStyles,
   gridScopeId,
@@ -10,12 +10,6 @@ import {
 const GAP = "1rem";
 const MIN = "240px";
 
-const sourceOf = (file: string) =>
-  readFileSync(
-    new URL(`../layers/dms-ui/app/components/grid/${file}`, import.meta.url),
-    "utf8",
-  );
-
 // Guards the exact-fit case: at the width where the track floor is precisely
 // one Nth of the container, binary floats land a hair under the integer.
 const FIT_EPSILON = 1e-6;
@@ -87,6 +81,15 @@ describe("grid column template", () => {
     expect(gridColumnsTemplate(1, GAP, MIN)).toContain("(100% - 0 * 1rem)");
   });
 
+  it("reads a unitless gap or minimum as pixels, which calc() requires", () => {
+    const template = gridColumnsTemplate(2, "0", "160");
+    expect(template).toContain("(100% - 1 * 0px)");
+    expect(template).toContain("max(160px,");
+    expect(resolveColumnCount(template, 553, 0)).toBe(2);
+    const css = gridResponsiveStyles(gridScopeId("nested"), 2, "0", MIN);
+    expect(css).toContain(`calc(2 * ${MIN} + 1 * 0px)`);
+  });
+
   it("honours a caller-supplied minimum", () => {
     expect(gridColumnsTemplate(4, GAP, "120px")).toContain("120px");
     expect(
@@ -95,20 +98,6 @@ describe("grid column template", () => {
   });
 });
 
-describe("grid components", () => {
-  it("drive both the container and its rows from the shared template", () => {
-    for (const file of ["Grid.vue", "GridRow.vue"]) {
-      const source = sourceOf(file);
-      expect(source).toContain("gridColumnsTemplate(");
-      expect(source).not.toMatch(/repeat\(\$\{/);
-    }
-  });
-
-  it("keeps rows spanning the full grid width", () => {
-    expect(sourceOf("GridRow.vue")).toContain('gridColumn: "1 / -1"');
-  });
-});
-
 describe("grid responsive styles", () => {
   const scope = gridScopeId("grid-child-row1");
 
@@ -158,15 +147,34 @@ describe("grid responsive styles", () => {
   });
 });
 
-describe("grid components emit their rules as CSS", () => {
-  it("make the grid and its rows size containers with no measuring script", () => {
-    for (const file of ["Grid.vue", "GridRow.vue"]) {
-      const source = sourceOf(file);
-      expect(source).toContain('containerType: "inline-size"');
-      expect(source).toContain("gridResponsiveStyles(");
-      expect(source).toContain("<GridResponsiveStyle");
-      expect(source).not.toContain("ResizeObserver");
-      expect(source).not.toContain("data-dms-grid-reflowed");
-    }
+describe("grid collapsed cell styles", () => {
+  const scope = gridScopeId("grid-child-row2");
+  const cells = `[data-dms-grid="${scope}"] > `;
+
+  it("takes no track for a cell its block leaves empty, but keeps spacers", () => {
+    const [hide] = gridCollapsedCellStyles(scope, 2).split("\n");
+    expect(hide).toBe(`${cells}:empty:not(.dms-spacer) { display: none; }`);
+  });
+
+  it("widens the last filled cell over each run of trailing empty cells", () => {
+    const rules = gridCollapsedCellStyles(scope, 3).split("\n");
+    expect(rules).toHaveLength(3);
+    expect(rules[1]).toContain(
+      ":has(+ :empty:not(.dms-spacer) + style:last-child)",
+    );
+    expect(rules[1]).toContain(
+      `grid-column: span min(2, var(${GRID_TRACKS_VAR}, 2));`,
+    );
+    expect(rules[2]).toContain(
+      ":has(+ :empty:not(.dms-spacer) + :empty:not(.dms-spacer) + style:last-child)",
+    );
+    expect(rules[2]).toContain(
+      `grid-column: span min(3, var(${GRID_TRACKS_VAR}, 3));`,
+    );
+  });
+
+  it("gives a single-column row no rules", () => {
+    expect(gridCollapsedCellStyles(scope, 1)).toBe("");
+    expect(gridCollapsedCellStyles(scope, 0)).toBe("");
   });
 });

package/frontend-vue/tests/header-actions.test.ts

@@ -2,6 +2,7 @@
 import {
   computed,
   createApp,
+  createSSRApp,
   defineComponent,
   h,
   nextTick,
@@ -10,6 +11,7 @@ import {
   type App,
   type Ref,
 } from "vue";
+import { renderToString } from "vue/server-renderer";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import DashboardHeader from "../layers/dms-layout/app/build/components/layout/DashboardHeader.vue";
 import {
@@ -97,18 +99,44 @@ function installRuntime(): void {
   );
 }
 
-function mountHeader(): HTMLElement {
-  const host = document.createElement("div");
-  document.body.append(host);
-  app = createApp(DashboardHeader);
-  app.component("UButton", ButtonStub);
+function createHeaderApp(create: typeof createApp): App {
+  const header = create(DashboardHeader);
+  header.component("UButton", ButtonStub);
   ["UDashboardNavbar", "UTooltip", "UBreadcrumb", "UDropdownMenu"].forEach(
-    (name) => app?.component(name, SlotsStub),
+    (name) => header.component(name, SlotsStub),
   );
+  return header;
+}
+
+async function mountHeader(): Promise<HTMLElement> {
+  const host = document.createElement("div");
+  document.body.append(host);
+  app = createHeaderApp(createApp);
+  app.mount(host);
+  await nextTick();
+  return host;
+}
+
+/**
+ * Renders the header on the "server", runs what only the client runs (a
+ * `.client` plugin), then hydrates the server markup.
+ */
+async function hydrateHeader(runOnClient: () => void): Promise<HTMLElement> {
+  const host = document.createElement("div");
+  host.innerHTML = await renderToString(createHeaderApp(createSSRApp));
+  document.body.append(host);
+  runOnClient();
+  app = createHeaderApp(createSSRApp);
   app.mount(host);
   return host;
 }
 
+function hydrationWarnings(spies: ReturnType<typeof vi.spyOn>[]): string[] {
+  return spies
+    .flatMap((spy) => spy.mock.calls.map((call) => String(call[0])))
+    .filter((message) => message.includes("Hydration"));
+}
+
 function button(host: HTMLElement, label: string): HTMLButtonElement | null {
   return host.querySelector(`button[aria-label="${label}"]`);
 }
@@ -145,7 +173,7 @@ describe("header action buttons", () => {
       action("toggle", { onSelect: vi.fn(), isActive: () => isOn.value }),
     );
     registerHeaderAction(action("plain", { onSelect: vi.fn() }));
-    const host = mountHeader();
+    const host = await mountHeader();
     const toggle = button(host, "toggle");
     expect(toggle?.dataset.color).toBe(IDLE_COLOR);
     expect(toggle?.getAttribute("aria-pressed")).toBe("false");
@@ -160,7 +188,7 @@ describe("header action buttons", () => {
     registerHeaderAction(
       action("panel", { label: "$panel.toggle", sidePanelId: PANEL_ID }),
     );
-    const host = mountHeader();
+    const host = await mountHeader();
     const toggle = button(host, "t:panel.toggle");
     const { isOpen } = useSidePanel(PANEL_ID);
     toggle?.click();
@@ -182,10 +210,28 @@ describe("header action buttons", () => {
         isActive: () => true,
       }),
     );
-    const host = mountHeader();
+    const host = await mountHeader();
     const builder = button(host, "Edit");
     builder?.click();
     expect(onSelect).toHaveBeenCalledOnce();
     expect(builder?.dataset.color).toBe(ACTIVE_COLOR);
   });
 });
+
+describe("header action hydration", () => {
+  it("draws a client-only action once mounted, not over the server markup", async () => {
+    const spies = [
+      vi.spyOn(console, "warn").mockImplementation(() => undefined),
+      vi.spyOn(console, "error").mockImplementation(() => undefined),
+    ];
+    registerHeaderAction(action("panel", { sidePanelId: PANEL_ID }));
+    const host = await hydrateHeader(() =>
+      registerHeaderAction(action("client", { onSelect: vi.fn() })),
+    );
+    expect(hydrationWarnings(spies)).toEqual([]);
+    expect(button(host, "panel")).not.toBeNull();
+    await nextTick();
+    expect(button(host, "client")).not.toBeNull();
+    spies.forEach((spy) => spy.mockRestore());
+  });
+});

package/frontend-vue/tests/instant-save-badge.test.ts

@@ -51,13 +51,20 @@ afterEach(() => {
 });
 
 describe("DmsInstantSaveBadge", () => {
-  it("reads exactly 'Saved instantly' in en-GB, whatever the save state", async () => {
+  it("says what the save state is, in en-GB", async () => {
     const { default: InstantSaveBadge } = await import(
       "../layers/dms-ui/app/components/save-bar/InstantSaveBadge.vue"
     );
-    for (const state of [undefined, "idle", "saving", "saved"] as const) {
+    const labels = [
+      [undefined, "Saved instantly"],
+      ["idle", "Saved instantly"],
+      ["saving", "Saving"],
+      ["saved", "Saved instantly"],
+      ["error", "Not saved"],
+    ] as const;
+    for (const [state, label] of labels) {
       await mount({ render: () => h(InstantSaveBadge, { state }) });
-      expect(badge()?.textContent?.trim()).toBe("Saved instantly");
+      expect(badge()?.textContent?.trim()).toBe(label);
       expect(badge()?.dataset.state).toBe(state ?? "idle");
       expect(badge()?.title).toBeTruthy();
       app?.unmount();
@@ -82,7 +89,7 @@ describe("DmsInstantSaveBadge", () => {
     }
   });
 
-  it("uses one key, translated in French", async () => {
+  it("is translated in French", async () => {
     vi.stubGlobal("useI18n", () => ({ t: translator(uiFr) }));
     const { default: InstantSaveBadge } = await import(
       "../layers/dms-ui/app/components/save-bar/InstantSaveBadge.vue"

package/frontend-vue/tests/list-row-truncate.test.ts

@@ -0,0 +1,46 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createApp, h, nextTick, type App } from "vue";
+import ListRow from "../layers/dms-ui/app/components/list-row/ListRow.vue";
+
+const LONG_TITLE = "Safari on iPhone 15 with a very long device name";
+
+let app: App | undefined;
+let host: HTMLDivElement;
+
+async function mount(truncate: boolean) {
+  app = createApp({ render: () => h(ListRow, { title: LONG_TITLE, truncate }) });
+  app.mount(host);
+  await nextTick();
+}
+
+const titleText = () =>
+  [...host.querySelectorAll("span")].find(
+    (span) => span.textContent?.trim() === LONG_TITLE,
+  );
+
+beforeEach(() => {
+  vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
+  host = document.createElement("div");
+  document.body.append(host);
+});
+
+afterEach(() => {
+  app?.unmount();
+  app = undefined;
+  host.remove();
+  vi.unstubAllGlobals();
+});
+
+describe("DmsListRow truncate", () => {
+  it("puts the ellipsis on the title text, not on its flex container", async () => {
+    await mount(true);
+    expect(titleText()?.classList.contains("truncate")).toBe(true);
+    expect(titleText()?.parentElement?.title).toBe(LONG_TITLE);
+  });
+
+  it("leaves the title text alone without truncate", async () => {
+    await mount(false);
+    expect(titleText()?.classList.contains("truncate")).toBe(false);
+  });
+});

package/frontend-vue/tests/nuxt-ui-aria-labels.test.ts

@@ -1,5 +1,3 @@
-import { readFileSync, readdirSync, statSync } from "node:fs";
-import { join, relative } from "node:path";
 import { describe, expect, it } from "vitest";
 import coreEn from "../layers/dms-core/i18n/locales/core-en-GB.json";
 import coreFr from "../layers/dms-core/i18n/locales/core-fr-FR.json";
@@ -12,13 +10,6 @@ const LABELLED_TAGS = {
 } as const;
 const LOCALES = { "en-GB": coreEn, "fr-FR": coreFr };
 
-function walk(directory: string): string[] {
-  return readdirSync(directory).flatMap((name) => {
-    const path = join(directory, name);
-    return statSync(path).isDirectory() ? walk(path) : [path];
-  });
-}
-
 function lookup(messages: unknown, key: string): unknown {
   return key
     .split(".")
@@ -29,25 +20,7 @@ function lookup(messages: unknown, key: string): unknown {
 }
 
 describe("Nuxt UI hard-coded aria-labels", () => {
-  const sources = walk(join(process.cwd(), "layers"))
-    .filter((path) => path.endsWith(".vue"))
-    .map((path) => ({
-      path: relative(process.cwd(), path),
-      text: readFileSync(path, "utf8"),
-    }));
-
-  for (const [tag, key] of Object.entries(LABELLED_TAGS)) {
-    it(`binds a translated aria-label on every ${tag}`, () => {
-      const tagPattern = new RegExp(`<${tag}\\b[^>]*?>`, "gs");
-      const offenders = sources.flatMap(({ path, text }) =>
-        [...text.matchAll(tagPattern)]
-          .filter(([found]) => !found.includes(`:aria-label="t('${key}')"`))
-          .map(() => path),
-      );
-
-      expect(offenders).toEqual([]);
-    });
-
+  for (const key of Object.values(LABELLED_TAGS)) {
     it(`translates ${key} in every locale`, () => {
       for (const messages of Object.values(LOCALES)) {
         expect(lookup(messages, key)).toBeTypeOf("string");

package/frontend-vue/tests/period-live-pause.test.ts

@@ -5,8 +5,6 @@
  * so nothing refetches on the clock; a period the user picks still applies at
  * once, and resuming catches the skipped minutes up in one read.
  */
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import { createApp, defineComponent, h, ref } from "vue";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
 import { createPageLiveController } from "../layers/dms-ui/app/build/composables/live/pageLiveController";
@@ -107,14 +105,3 @@ it("holds the period while paused, but follows the user's pick", async () => {
   expect(requests).toHaveLength(3);
   expect(period.state.value.key).not.toBe(heldKey);
 });
-
-it("holds the selector's period on the page's pause", () => {
-  const source = readFileSync(
-    resolve(
-      __dirname,
-      "../layers/dms-ui/app/components/period/PeriodSelector.vue",
-    ),
-    "utf8",
-  );
-  expect(source).toContain("holdClock: () => isPagePaused.value,");
-});

package/frontend-vue/tests/period-max-days.test.ts

@@ -5,8 +5,6 @@
  * from the date fields or a long preset is cut to it.
  */
 import { CalendarDate } from "@internationalized/date";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import { createApp, defineComponent, h, nextTick, type App } from "vue";
 import { afterEach, describe, expect, it } from "vitest";
 import PeriodRangeCalendar from "../layers/dms-ui/app/build/components/period/PeriodRangeCalendar.vue";
@@ -114,15 +112,3 @@ describe("the range calendar with maxDays", () => {
     expect(day(host, "2026-09-30").hasAttribute("data-disabled")).toBe(false);
   });
 });
-
-it("hands maxDays to the calendar and cuts the date fields to it", () => {
-  const source = readFileSync(
-    resolve(
-      __dirname,
-      "../layers/dms-ui/app/components/period/PeriodSelector.vue",
-    ),
-    "utf8",
-  );
-  expect(source).toContain(':max-days="maxDays"');
-  expect(source).toContain("limitCalendarRange(range, props.maxDays, anchor)");
-});

package/frontend-vue/tests/roles-name-errors.test.ts

@@ -1,4 +1,5 @@
 // @vitest-environment jsdom
+import { interpolateUrl } from "../layers/dms-core/app/utils/url-interpolation";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
 import {
   type App,
@@ -203,9 +204,7 @@ beforeEach(() => {
   vi.stubGlobal("useToast", () => ({ add: addToast }));
   vi.stubGlobal("useConfirm", () => ({ confirm }));
   vi.stubGlobal("useAuthFetch", () => ({ $authFetch: authFetch }));
-  vi.stubGlobal("interpolateUrl", (url: string, data: Record<string, string>) =>
-    url.replace(/\{(\w+)\}/g, (_, key: string) => data[key] ?? ""),
-  );
+  vi.stubGlobal("interpolateUrl", interpolateUrl);
   vi.stubGlobal("useTranslation", () => ({
     processApiMessage: (message: string) => `t(${message})`,
   }));

package/frontend-vue/tests/row-side-panel.test.ts

@@ -828,16 +828,4 @@ describe("open row highlight", () => {
       "data-[open=true]:[&>td:first-child]:shadow-[inset_2px_0_0_0_var(--ui-primary)]",
     );
   });
-
-  it("marks the open row and wires both pointer events to the click mode", () => {
-    expect(tableSource).toContain(
-      ':data-open="isOpenRow(row.original) || undefined"',
-    );
-    expect(tableSource).toContain(
-      '@click="handleRowPointer($event, row.original)"',
-    );
-    expect(tableSource).toContain(
-      '@dblclick="handleRowPointer($event, row.original)"',
-    );
-  });
 });