@antelopejs/dms 0.8.0 → 0.8.1

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

@@ -173,25 +173,3 @@ describe("the load error a form shows", () => {
     }
   });
 });
-
-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;
@@ -104,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");
 
@@ -167,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/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/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)"',
-    );
-  });
 });

package/frontend-vue/tests/table-cell-wrap.test.ts

@@ -58,16 +58,4 @@ describe("Table grid cell layout theme", () => {
       expect(theme().rowCell({ cellWrap })).toContain("py-0");
     }
   });
-
-  it("reads each column's policy for its cell too", () => {
-    expect(tableSource).toMatch(
-      /uiTable\.rowCell\(\{[^}]*cellWrap: \(cell\.column\.columnDef as TableColumn<T>\)\s*\.cellWrap,?\s*\}\)/,
-    );
-  });
-
-  it("reads each column's policy inside the default slot fallback", () => {
-    expect(tableSource).toMatch(
-      /uiTable\.rowSpan\(\{\s*cellWrap: \(\s*cell\.column\.columnDef as TableColumn<T>\s*\)\.cellWrap[\s,]*\}\)/,
-    );
-  });
 });

package/frontend-vue/tests/table-density-menu.test.ts

@@ -11,19 +11,9 @@ import {
   type App,
 } from "vue";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import TableMenuDensity from "../layers/dms-ui/app/build/components/table/MenuDensity.vue";
 import TableMenuRoot from "../layers/dms-ui/app/build/components/table/MenuRoot.vue";
 
-const tableViewSource = readFileSync(
-  resolve(
-    __dirname,
-    "../layers/dms-ui/app/components/table-view/TableView.vue",
-  ),
-  "utf8",
-);
-
 describe("table density menu", () => {
   let app: App | undefined;
 
@@ -115,15 +105,4 @@ describe("table density menu", () => {
       "dms.table.density_title",
     );
   });
-
-  it("keeps the user's density with the table state, the module's as default", () => {
-    expect(tableViewSource).toMatch(
-      /defaultDensity = props\.density \?\? DEFAULT_DENSITY/,
-    );
-    expect(tableViewSource).toContain(
-      'tablePreferences.restore("density", density);',
-    );
-    expect(tableViewSource).toMatch(/\["density", density, defaultDensity\]/);
-    expect(tableViewSource).toContain('v-model:density="density"');
-  });
 });

package/frontend-vue/tests/table-live-hold.test.ts

@@ -6,8 +6,6 @@
  * pagination included), and Show reads the rows once without leaving the
  * pause.
  */
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import { createApp, defineComponent, h, nextTick, ref, type App } from "vue";
 import { refreshPageBlocks } from "../layers/dms-ui/app/utils/blockRefresh";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
@@ -43,13 +41,6 @@ const { useTableLiveHold } = await import(
 );
 
 const TOPIC = "api:requests";
-const tableViewSource = readFileSync(
-  resolve(
-    __dirname,
-    "../layers/dms-ui/app/components/table-view/TableView.vue",
-  ),
-  "utf8",
-);
 
 let apps: App[] = [];
 let live: PageLiveController;
@@ -203,23 +194,6 @@ it("reads on a user's refresh while held, and holds from then", async () => {
   });
 });
 
-it("wires the table view's rows, row events and banner to the hold", () => {
-  expect(tableViewSource).toMatch(
-    /liveHold\?: boolean \| TableViewLiveHoldOptions;/,
-  );
-  expect(tableViewSource).toContain(
-    "isRowOpen: () => openRowId.value !== undefined,",
-  );
-  expect(tableViewSource).toContain('ref="tableRoot"');
-  expect(tableViewSource).toContain("heldQuery: liveHold.heldQuery,");
-  expect(tableViewSource).toContain("refreshCallback: refreshByUser,");
-  expect(tableViewSource).toContain('@refresh="refreshByUser"');
-  expect(tableViewSource).toContain("gateRowEvent(payload.type, ids, event);");
-  expect(tableViewSource).toMatch(
-    /<LiveHoldBanner[\s\S]*@show="liveHold.showNew"/,
-  );
-});
-
 it("holds the table alone while a row is open, the page staying live", async () => {
   const isRowOpen = ref(false);
   const { refresh, hold } = mountTable({
@@ -338,19 +312,6 @@ it("holds for no search nor sort the options leave off", async () => {
   expect(hold.reason.value).toBe(null);
 });
 
-it("tells the hold about the table's search and sort, and the banner why", () => {
-  expect(tableViewSource).toContain(
-    "isSearching: () => !!effectiveGlobalFilter.value,",
-  );
-  expect(tableViewSource).toContain(
-    "isSorted: () => !isSameSorting(effectiveSorting.value, defaultSortState),",
-  );
-  expect(tableViewSource).toMatch(
-    /v-if="liveHold\.newCount\.value > 0 \|\| liveHold\.reason\.value"/,
-  );
-  expect(tableViewSource).toContain(':reason="liveHold.reason.value"');
-});
-
 it("hands the strip the paused page's breakdown and the table's missedLabel", async () => {
   const isRowOpen = ref(false);
   const { hold } = mountTable({
@@ -377,8 +338,3 @@ it("hands the strip the paused page's breakdown and the table's missedLabel", as
   await nextTick();
   expect(hold.missedDetail.value).toBe(null);
 });
-
-it("passes the strip its wording and breakdown", () => {
-  expect(tableViewSource).toContain(':missed-label="liveHold.missedLabel"');
-  expect(tableViewSource).toContain(':detail="liveHold.missedDetail.value"');
-});

package/frontend-vue/tests/table-row-hover.test.ts

@@ -95,16 +95,6 @@ describe("row hover affordance", () => {
     });
     expect(pinned).toContain("group-data-[presence=true]:bg-elevated");
   });
-
-  it("feeds the same condition to the row, its pinned cells and the rail", () => {
-    expect(tableSource).toMatch(
-      /uiTable\.row\(\{\s*loading,\s*rowClickable: isRowClickable\(row\.original\),/,
-    );
-    expect(tableSource).toMatch(
-      /uiTable\.rowCell\(\{[^}]*rowClickable: isRowClickable\(row\.original\),/,
-    );
-    expect(tableSource).toContain("presenceRailBackground(row.original)");
-  });
 });
 
 describe("resolveRowClickAction", () => {

package/frontend-vue/tests/table-scroll-area.test.ts

@@ -34,12 +34,4 @@ describe("Table scroll area", () => {
     expect(theme().headCell()).not.toContain("sticky");
     expect(theme().tableRoot()).not.toContain("overflow-y-auto");
   });
-
-  it("opens the scroll area from `maxHeight` alone", () => {
-    expect(tableSource).not.toContain("stickyHeader");
-    expect(tableSource).toMatch(
-      /hasScrollArea = computed\(\(\) => !!props\.maxHeight\)/,
-    );
-    expect(tableSource).toMatch(/maxHeight: props\.maxHeight,/);
-  });
 });

package/frontend-vue/tests/table-view-card-props.test.ts

@@ -1,8 +1,6 @@
 // @vitest-environment jsdom
 import { computed, createApp, defineComponent, h, ref, type App } from "vue";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import CardsDisplay from "../layers/dms-ui/app/build/components/table-view/CardsDisplay.vue";
 import {
   buildCardProps,
@@ -21,14 +19,6 @@ vi.mock("../layers/dms-ui/app/build/components/table/Empty.vue", () => ({
   default: { render: () => null },
 }));
 
-const kanbanBoardSource = readFileSync(
-  resolve(
-    __dirname,
-    "../layers/dms-ui/app/components/table-view/KanbanBoard.vue",
-  ),
-  "utf8",
-);
-
 const rows = [
   { _id: "t1", name: "Write the docs" },
   { _id: "t2", name: "Ship it" },
@@ -79,13 +69,6 @@ describe("table view card props", () => {
     expect(opened).toEqual([rows[0]]);
     expect(buildCardProps(rows[1]!, context).selected).toBe(true);
   });
-
-  it("gives a kanban card the same props, plus its column's value", () => {
-    expect(kanbanBoardSource).toMatch(
-      /buildCardProps\(item, props\.cardContext\)/,
-    );
-    expect(kanbanBoardSource).toMatch(/groupValue,\n\s*\}\);/);
-  });
 });
 
 describe("cards display with a custom card", () => {

package/frontend-vue/tests/table-view-cards-reorder.test.ts

@@ -11,8 +11,6 @@ import {
   type PropType,
 } from "vue";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import CardsDisplay from "../layers/dms-ui/app/build/components/table-view/CardsDisplay.vue";
 import { useTableReorder } from "../layers/dms-ui/app/build/composables/table-view/useTableReorder";
 import { moveRow } from "../layers/dms-ui/app/build/composables/table-view/utils/reorder";
@@ -31,14 +29,6 @@ vi.mock("../layers/dms-ui/app/build/components/table/Empty.vue", () => ({
 type Row = { _id: string; name: string };
 type Api = Parameters<typeof useTableReorder>[0]["api"];
 
-const tableViewSource = readFileSync(
-  resolve(
-    __dirname,
-    "../layers/dms-ui/app/components/table-view/TableView.vue",
-  ),
-  "utf8",
-);
-
 const TaskCard = defineComponent({
   props: {
     rowId: String,
@@ -223,12 +213,6 @@ describe("the cards display of a hand-ordered table", () => {
 });
 
 describe("which displays move rows", () => {
-  it("offers moving on the grid and the cards, never on the board or the groups", () => {
-    expect(tableViewSource).toMatch(
-      /ORDERED_DISPLAY_IDS = new Set\(\[TABLE_DISPLAY_ID, CARDS_DISPLAY_ID\]\)/,
-    );
-    expect(tableViewSource).toMatch(/reorder: reorderState\.value,/);
-  });
 
   it("draws no handle on a display that does not draw the rows in their order", () => {
     vi.stubGlobal("computed", computed);

package/frontend-vue/tests/table-view-grouped.test.ts

@@ -1,6 +1,4 @@
 // @vitest-environment jsdom
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import {
   computed,
   createApp,
@@ -25,25 +23,6 @@ import {
 } from "../layers/dms-ui/app/build/composables/table-view/utils/groupedRows";
 import type { TableViewColumn } from "../layers/dms-ui/app/composables/table-view/types";
 
-const tableSource = readFileSync(
-  resolve(__dirname, "../layers/dms-ui/app/build/components/table/Table.vue"),
-  "utf8",
-);
-const menuViewModeSource = readFileSync(
-  resolve(
-    __dirname,
-    "../layers/dms-ui/app/build/components/table/MenuViewMode.vue",
-  ),
-  "utf8",
-);
-const tableViewSource = readFileSync(
-  resolve(
-    __dirname,
-    "../layers/dms-ui/app/components/table-view/TableView.vue",
-  ),
-  "utf8",
-);
-
 const LABELS = {
   today: "Today",
   yesterday: "Yesterday",
@@ -117,40 +96,6 @@ describe("grouped rows", () => {
   });
 });
 
-describe("grouped display wiring", () => {
-  it("draws a header row before each group of the page", () => {
-    expect(tableSource).toMatch(
-      /v-for="\{ kind, id, row, key, header \} in bodyEntries"/,
-    );
-    // Drawn by the entry, not by reading the prop when the header renders:
-    // leaving the grouped display then cannot leave it undefined.
-    expect(tableSource).toContain('<component :is="header" />');
-    expect(tableSource).not.toContain("grouping!.header");
-    expect(tableSource).toContain(':class="uiTable.groupCell()"');
-    expect(tableSource).toMatch(/if \(key !== currentKey\) \{/);
-  });
-
-  it("sorts the list on the grouped column while the grouped display shows", () => {
-    expect(tableViewSource).toMatch(
-      /isGroupedDisplay\.value && activeGroupedOptions\.value\s*\?\s*groupedSorting\(picked, activeGroupedOptions\.value\)/,
-    );
-    expect(tableViewSource).toContain(':grouping="grouping"');
-  });
-
-  it("lets the user pick the grouped column from the options menu, as on the kanban", () => {
-    expect(tableViewSource).toContain(
-      'v-model:grouped-group-by="groupedGroupBy"',
-    );
-    expect(tableViewSource).toContain(
-      ':grouped-group-by-options="groupedGroupByOptions"',
-    );
-    expect(tableViewSource).toMatch(/grouped: activeGroupedOptions,/);
-    expect(menuViewModeSource).toMatch(
-      /\[GROUPED_DISPLAY_ID\]: \(shared\) => \(\{\s*options: shared\.groupedGroupByOptions,/,
-    );
-  });
-});
-
 describe("grouped group-by", () => {
   const column = (accessorKey: string, typeId: string, options = {}) =>
     ({

package/frontend-vue/tests/table-view-pinned-rows.test.ts

@@ -3,8 +3,6 @@
  * base language of a languages table stays on top whichever column the user
  * sorts on, and on the first page.
  */
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import { describe, expect, it, vi } from "vitest";
 import {
   processSourceRows,
@@ -128,16 +126,3 @@ describe("rows a route sorts", () => {
     expect(ids((await rows.list({}))!.results)).toEqual(ids(LANGUAGES));
   });
 });
-
-it("hands the table view's pinnedRows to its rows, except while grouped", () => {
-  const source = readFileSync(
-    resolve(
-      __dirname,
-      "../layers/dms-ui/app/components/table-view/TableView.vue",
-    ),
-    "utf8",
-  );
-  expect(source).toMatch(
-    /pinnedRows: \(\) => \(isGroupedDisplay\.value \? undefined : props\.pinnedRows\)/,
-  );
-});

package/frontend-vue/tests/table-view-record-link.test.ts

@@ -5,8 +5,6 @@
  * closed meanwhile: the table removes the key in place, so the route still
  * holds the same value and only the visit tells the link was followed again.
  */
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import { createApp, defineComponent, h, nextTick, reactive } from "vue";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { CustomRowAction } from "../layers/dms-ui/app/types/row-action";
@@ -190,18 +188,3 @@ describe("the URL a closed drawer leaves", () => {
     });
   });
 });
-
-it("wires the record link and the filter chips into the table view", () => {
-  const source = readFileSync(
-    resolve(
-      __dirname,
-      "../layers/dms-ui/app/components/table-view/TableView.vue",
-    ),
-    "utf8",
-  );
-  expect(source).toContain("useTableRecordLink<T>({");
-  expect(source).toContain("onRecordShown: (id) => recordLink?.shown(id),");
-  expect(source).toContain(
-    "withoutQueryParam(currentQuery(route.query), param)",
-  );
-});

package/frontend-vue/tests/table-view-refresh.test.ts

@@ -5,8 +5,6 @@
  * asks its blocks to refresh (refreshPageBlocks). The re-read goes through the
  * same refresh as the toolbar's button, which keeps the rows on screen.
  */
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import { createApp, defineComponent, h } from "vue";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
 import type { RealtimeTopicHandler } from "../layers/dms-core/app/composables/realtime/useUserRealtime";
@@ -24,14 +22,6 @@ const { useRefreshTriggers } = await import(
   "../layers/dms-ui/app/build/composables/blocks/useRefreshTriggers"
 );
 
-const tableViewSource = readFileSync(
-  resolve(
-    __dirname,
-    "../layers/dms-ui/app/components/table-view/TableView.vue",
-  ),
-  "utf8",
-);
-
 const UPLOADS_TOPIC = "media:uploads";
 const mounted: Array<{ unmount: () => void }> = [];
 
@@ -75,10 +65,3 @@ it("refreshes on each event of any of its topics, not on a snapshot", () => {
   topicHandlers.get(UPLOADS_TOPIC)?.({ entries: [] } as never);
   expect(block.onRefresh).toHaveBeenCalledTimes(2);
 });
-
-it("wires the table view's realtimeTopic and page refresh to its refresh", () => {
-  expect(tableViewSource).toMatch(/realtimeTopic\?: string \| string\[\];/);
-  expect(tableViewSource).toMatch(
-    /const liveGate = useRefreshTriggers\(\s*props\.realtimeTopic,\s*\(\) => void refreshAll\(\),\s*\);/,
-  );
-});

package/frontend-vue/tests/table-view-url-tab.test.ts

@@ -6,8 +6,6 @@
  * remounting the page. A tab the user opens is written back to the URL in
  * place, under the same key.
  */
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import { createApp, defineComponent, h, nextTick, reactive, ref } from "vue";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
@@ -183,15 +181,3 @@ describe("the tab the user opens", () => {
     expect(activeTabId.value).toBe("all");
   });
 });
-
-it("wires the URL tab into the table view", () => {
-  const source = readFileSync(
-    resolve(
-      __dirname,
-      "../layers/dms-ui/app/components/table-view/TableView.vue",
-    ),
-    "utf8",
-  );
-  expect(source).toContain("readTableUrlTab(route.query, urlScope)");
-  expect(source).toContain("useTableUrlTab({");
-});