@antelopejs/dms 0.9.1 → 0.9.3

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

@@ -1,61 +0,0 @@
-import { readFileSync } from "node:fs";
-import { describe, expect, it } from "vitest";
-import { tv } from "tailwind-variants";
-import { EYEBROW_CLASS } from "../layers/dms-ui/app/build/utils/eyebrow";
-import { REORDER_HANDLE_CLASS } from "../layers/dms-ui/app/build/composables/table-view/useReorderHandles";
-
-const tableSource = readFileSync(
-  new URL(
-    "../layers/dms-ui/app/build/components/table/Table.vue",
-    import.meta.url,
-  ),
-  "utf8",
-);
-const themeSource = tableSource.slice(
-  tableSource.indexOf("const PANEL_MATCH_BG"),
-  tableSource.indexOf("// Grid-like default"),
-);
-const theme = new Function(
-  "tv",
-  "EYEBROW_CLASS",
-  "REORDER_HANDLE_CLASS",
-  `${themeSource}; return theme;`,
-)(tv, EYEBROW_CLASS, REORDER_HANDLE_CLASS);
-
-describe("Table grid cell layout theme", () => {
-  it.each([undefined, false])("preserves the default for %s", (cellWrap) => {
-    expect(theme().rowSpan({ cellWrap })).toBe("line-clamp-1 text-ellipsis");
-  });
-
-  it("removes the clamp and inherited nowrap only for opted-in cells", () => {
-    const classes = theme().rowSpan({ cellWrap: true });
-    expect(classes).toContain("line-clamp-none");
-    expect(classes).toContain("whitespace-normal");
-    expect(classes).toContain("[overflow-wrap:anywhere]");
-    expect(classes).not.toContain("line-clamp-1");
-    expect(theme().rowSpan()).toBe("line-clamp-1 text-ellipsis");
-  });
-
-  it("preserves pinned cell and table layout classes", () => {
-    expect(theme({ cellWrap: true }).table()).toBe(theme().table());
-    const pinned = theme().rowCell({ pinned: "left" }).split(" ");
-    const wrapped = theme()
-      .rowCell({ pinned: "left", cellWrap: true })
-      .split(" ");
-    expect(wrapped.filter((name: string) => !pinned.includes(name))).toEqual([
-      "py-2.5",
-    ]);
-    expect(pinned.filter((name: string) => !wrapped.includes(name))).toEqual([
-      "py-0",
-    ]);
-  });
-
-  it("pads only a wrapped cell, so its lines clear the row's hairlines", () => {
-    expect(theme().rowCell({ cellWrap: true })).toContain("py-2.5");
-    expect(theme().rowCell({ cellWrap: true })).toContain("h-11");
-    expect(theme().rowCell({ cellWrap: true })).not.toContain("py-0");
-    for (const cellWrap of [undefined, false]) {
-      expect(theme().rowCell({ cellWrap })).toContain("py-0");
-    }
-  });
-});

package/frontend-vue/tests/table-clear-filters.test.ts

@@ -1,374 +0,0 @@
-// @vitest-environment jsdom
-import {
-  computed,
-  createApp,
-  defineComponent,
-  h,
-  nextTick,
-  provide,
-  ref,
-  shallowRef,
-  type App,
-  type Ref,
-} from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { PaginationState } from "@tanstack/vue-table";
-import type { TableFilter } from "../layers/dms-ui/app/build/components/table/Table.vue";
-import {
-  clearTableColumnFilters,
-  clearTableFilters,
-  clearTableFiltersLabelKey,
-  clearTableSearch,
-  clearableTableFilters,
-  isTableNarrowed,
-  resetColumnFilters,
-  type TableNarrowingState,
-} from "../layers/dms-ui/app/build/composables/table/utils/clearTableFilters";
-import TableEmpty from "../layers/dms-ui/app/build/components/table/Empty.vue";
-import { useTableViewEmptyState } from "../layers/dms-ui/app/composables/table-view/useTableViewEmptyState";
-import type { TableViewEmptyStatesConfig } from "../layers/dms-ui/app/composables/table-view/types";
-
-const pinnedStatus = (value: unknown): TableFilter => ({
-  accessorKey: "status",
-  mode: "is",
-  value,
-  pinned: true,
-  initialValue: "open",
-});
-const dueDate: TableFilter = {
-  accessorKey: "dueDate",
-  mode: "before",
-  value: "2026-01-01",
-  pinned: false,
-};
-
-interface Harness extends TableNarrowingState {
-  columnFilters: Ref<TableFilter[]>;
-  globalFilter: Ref<string | undefined>;
-  pagination: Ref<PaginationState>;
-}
-
-// What a quick filter writes: the column's own filter.
-const quickPriority = (value: string): TableFilter => ({
-  accessorKey: "priority",
-  mode: "is",
-  value,
-  pinned: false,
-});
-
-const createState = (
-  overrides: Partial<{
-    columnFilters: TableFilter[];
-    globalFilter: string;
-    pageIndex: number;
-  }> = {},
-): Harness => ({
-  columnFilters: ref(overrides.columnFilters ?? []),
-  globalFilter: ref(overrides.globalFilter ?? ""),
-  pagination: ref({ pageIndex: overrides.pageIndex ?? 0, pageSize: 25 }),
-});
-
-describe("clearTableFilters", () => {
-  it("clears the chips, the search and the quick filters, back to page 1", () => {
-    const state = createState({
-      columnFilters: [pinnedStatus("done"), dueDate, quickPriority("high")],
-      globalFilter: "dfgdf",
-      pageIndex: 3,
-    });
-
-    clearTableFilters(state);
-
-    // The default filter goes back to its value, the added chip is dropped.
-    expect(state.columnFilters.value).toEqual([pinnedStatus("open")]);
-    expect(state.globalFilter.value).toBe("");
-    expect(state.pagination.value).toEqual({ pageIndex: 0, pageSize: 25 });
-  });
-
-  it("keeps the page size", () => {
-    const state = createState({ globalFilter: "x", pageIndex: 2 });
-    state.pagination.value = { pageIndex: 2, pageSize: 50 };
-    clearTableFilters(state);
-    expect(state.pagination.value).toEqual({ pageIndex: 0, pageSize: 50 });
-  });
-
-  it("drops the added chips and resets the default ones", () => {
-    expect(resetColumnFilters([dueDate, pinnedStatus("done")])).toEqual([
-      pinnedStatus("open"),
-    ]);
-  });
-
-  it("names what a clear would change", () => {
-    expect(clearableTableFilters(createState())).toEqual({
-      filters: false,
-      search: false,
-    });
-    // A default filter at its own value is nothing to clear.
-    expect(
-      clearableTableFilters(
-        createState({ columnFilters: [pinnedStatus("open")] }),
-      ),
-    ).toEqual({ filters: false, search: false });
-    expect(clearableTableFilters(createState({ globalFilter: "abc" }))).toEqual(
-      { filters: false, search: true },
-    );
-    expect(
-      clearableTableFilters(
-        createState({ columnFilters: [quickPriority("high")] }),
-      ),
-    ).toEqual({ filters: true, search: false });
-    expect(
-      clearableTableFilters(
-        createState({ columnFilters: [dueDate], globalFilter: "abc" }),
-      ),
-    ).toEqual({ filters: true, search: true });
-  });
-
-  it("picks the label of what it clears", () => {
-    expect(clearTableFiltersLabelKey({ filters: true, search: false })).toBe(
-      "dms.table.clear_filters",
-    );
-    expect(clearTableFiltersLabelKey({ filters: false, search: true })).toBe(
-      "dms.table.clear_search",
-    );
-    expect(clearTableFiltersLabelKey({ filters: true, search: true })).toBe(
-      "dms.table.clear_filters_and_search",
-    );
-  });
-
-  it("tells when the rows are narrowed", () => {
-    expect(isTableNarrowed(createState())).toBe(false);
-    // An empty chip narrows nothing.
-    expect(
-      isTableNarrowed(
-        createState({ columnFilters: [{ ...dueDate, value: undefined }] }),
-      ),
-    ).toBe(false);
-    expect(isTableNarrowed(createState({ globalFilter: "a" }))).toBe(true);
-    expect(isTableNarrowed(createState({ columnFilters: [dueDate] }))).toBe(
-      true,
-    );
-    expect(
-      isTableNarrowed(createState({ columnFilters: [quickPriority("low")] })),
-    ).toBe(true);
-  });
-
-  it("counts the hidden filters of the page URL as filters", () => {
-    const state = { ...createState(), hiddenFiltersApply: ref(true) };
-    expect(isTableNarrowed(state)).toBe(true);
-    // Nothing the user could clear: no clear action is offered.
-    expect(clearableTableFilters(state)).toEqual({
-      filters: false,
-      search: false,
-    });
-    state.hiddenFiltersApply.value = false;
-    expect(isTableNarrowed(state)).toBe(false);
-  });
-
-  it("ignores a search the active display does not apply", () => {
-    const state = {
-      ...createState({ globalFilter: "a" }),
-      searchApplies: ref(false),
-    };
-    expect(isTableNarrowed(state)).toBe(false);
-    expect(clearableTableFilters(state)).toEqual({
-      filters: false,
-      search: false,
-    });
-  });
-});
-
-describe("clearing the search or the filters alone", () => {
-  it("empties the search, the chips kept, back to page 1", () => {
-    const state = createState({
-      columnFilters: [dueDate],
-      globalFilter: "late",
-      pageIndex: 2,
-    });
-    clearTableSearch(state);
-    expect(state.globalFilter.value).toBe("");
-    expect(state.columnFilters.value).toEqual([dueDate]);
-    expect(state.pagination.value.pageIndex).toBe(0);
-  });
-
-  it("clears the chips, the search kept, back to page 1", () => {
-    const state = createState({
-      columnFilters: [pinnedStatus("closed"), dueDate],
-      globalFilter: "late",
-      pageIndex: 2,
-    });
-    clearTableColumnFilters(state);
-    expect(state.globalFilter.value).toBe("late");
-    expect(state.columnFilters.value).toEqual([pinnedStatus("open")]);
-    expect(state.pagination.value.pageIndex).toBe(0);
-  });
-});
-
-describe("table empty state", () => {
-  let app: App | undefined;
-
-  const mountEmpty = (
-    state: Harness,
-    emptyStates?: TableViewEmptyStatesConfig,
-  ) => {
-    const sharedData = shallowRef({
-      resetFilters: () => clearTableFilters(state),
-      clearSearch: () => clearTableSearch(state),
-      clearFilters: () => clearTableColumnFilters(state),
-      globalFilterState: state.globalFilter,
-      emptyStates,
-      clearableFilters: computed(() => clearableTableFilters(state)),
-      isFiltered: computed(() => isTableNarrowed(state)),
-      showArchivedState: ref(false),
-      emits: vi.fn(),
-    });
-    const Host = defineComponent({
-      setup() {
-        provide("tableSharedData", sharedData);
-        return () => h(TableEmpty);
-      },
-    });
-    app = createApp(Host);
-    app.component(
-      "UButton",
-      defineComponent({
-        props: { label: String, onClick: Function },
-        setup: (props) => () =>
-          h("button", { onClick: props.onClick }, props.label),
-      }),
-    );
-    app.component("UIcon", defineComponent({ setup: () => () => h("i") }));
-    const container = document.createElement("div");
-    app.mount(container);
-    return container;
-  };
-
-  beforeEach(() => {
-    vi.stubGlobal("computed", computed);
-    vi.stubGlobal("useTranslation", () => ({
-      processI18n: (text: string) => text,
-    }));
-    vi.stubGlobal("useI18n", () => ({
-      t: (key: string) => key,
-      te: () => false,
-    }));
-  });
-
-  afterEach(() => {
-    app?.unmount();
-    app = undefined;
-    vi.unstubAllGlobals();
-  });
-
-  it("clears the filters and the search from the no-results state", async () => {
-    const state = createState({
-      columnFilters: [dueDate],
-      globalFilter: "dfgdf",
-      pageIndex: 1,
-    });
-    const container = mountEmpty(state);
-
-    expect(container.textContent).toContain("dms.table.no_results_title");
-    const button = container.querySelector("button")!;
-    expect(button.textContent).toBe("dms.table.clear_filters_and_search");
-
-    button.click();
-    await nextTick();
-
-    expect(state.globalFilter.value).toBe("");
-    expect(state.columnFilters.value).toEqual([]);
-    expect(state.pagination.value.pageIndex).toBe(0);
-    // Nothing narrows the rows any more: the plain empty state is back.
-    expect(container.textContent).toContain("dms.table.empty_title");
-    expect(container.querySelector("button")).toBeNull();
-  });
-
-  it("offers to clear a search alone", async () => {
-    const state = createState({ globalFilter: "dfgdf" });
-    const container = mountEmpty(state);
-
-    const button = container.querySelector("button")!;
-    expect(button.textContent).toBe("dms.table.clear_search");
-    button.click();
-    await nextTick();
-    expect(state.globalFilter.value).toBe("");
-  });
-
-  it("says no row matches, not that there are none yet, under hidden filters", () => {
-    const container = mountEmpty({
-      ...createState(),
-      hiddenFiltersApply: ref(true),
-    });
-    expect(container.textContent).toContain("dms.table.no_results_title");
-    expect(container.textContent).not.toContain("dms.table.empty_title");
-    expect(container.querySelector("button")).toBeNull();
-  });
-
-  it("hands a custom state a clear for the search and one for the filters", async () => {
-    const received: Record<string, unknown>[] = [];
-    vi.stubGlobal("resolveDmsComponent", () =>
-      defineComponent({
-        props: {
-          state: String,
-          clearSearch: Function,
-          clearFilters: Function,
-        },
-        setup: (props) => () => {
-          received.push({ ...props });
-          return h("p", "custom");
-        },
-      }),
-    );
-    const state = createState({
-      columnFilters: [dueDate],
-      globalFilter: "late",
-    });
-    mountEmpty(state, {
-      filtered: { title: "", component: { componentName: "LogsEmpty" } },
-    });
-    const props = received.at(-1)!;
-    expect(props.state).toBe("filtered");
-    (props.clearSearch as () => void)();
-    await nextTick();
-    expect(state.globalFilter.value).toBe("");
-    expect(state.columnFilters.value).toEqual([dueDate]);
-    expect(received.at(-1)!.clearSearch).toBeUndefined();
-    (received.at(-1)!.clearFilters as () => void)();
-    expect(state.columnFilters.value).toEqual([]);
-  });
-
-  it("lets a component inside the table clear through useTableViewEmptyState", async () => {
-    const state = createState({
-      columnFilters: [dueDate],
-      globalFilter: "late",
-    });
-    let controls: ReturnType<typeof useTableViewEmptyState> | undefined;
-    vi.stubGlobal("resolveDmsComponent", () =>
-      defineComponent({
-        setup: () => {
-          controls = useTableViewEmptyState();
-          return () => h("p");
-        },
-      }),
-    );
-    mountEmpty(state, {
-      filtered: { title: "", component: { componentName: "LogsEmpty" } },
-    });
-    expect(controls!.search.value).toBe("late");
-    expect(controls!.isFiltered.value).toBe(true);
-    expect(controls!.canClearSearch.value).toBe(true);
-    expect(controls!.canClearFilters.value).toBe(true);
-    controls!.clearFilters();
-    expect(controls!.canClearFilters.value).toBe(false);
-    expect(state.globalFilter.value).toBe("late");
-    controls!.clearSearch();
-    expect(controls!.isFiltered.value).toBe(false);
-  });
-
-  it("offers no clear action when only default filters narrow the rows", () => {
-    const container = mountEmpty(
-      createState({ columnFilters: [pinnedStatus("open")] }),
-    );
-    expect(container.textContent).toContain("dms.table.no_results_title");
-    expect(container.querySelector("button")).toBeNull();
-  });
-});

package/frontend-vue/tests/table-column-visibility.test.ts

@@ -1,20 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildInitialColumnVisibility } from "../layers/dms-ui/app/build/composables/table-view/utils/columnVisibility";
-
-describe("buildInitialColumnVisibility", () => {
-  it("hides the columns declared isVisible: false", () => {
-    expect(
-      buildInitialColumnVisibility([
-        { id: "number" },
-        { id: "amount", isVisible: true },
-        { id: "stripeId", isVisible: false },
-      ]),
-    ).toEqual({ number: true, amount: true, stripeId: false });
-  });
-
-  it("keeps every column visible when none opts out", () => {
-    expect(buildInitialColumnVisibility([{ id: "name" }])).toEqual({
-      name: true,
-    });
-  });
-});

package/frontend-vue/tests/table-data-ssr.test.ts

@@ -1,195 +0,0 @@
-// @vitest-environment jsdom
-/**
- * A table view's list, tab counters and footer figures, through the runtime's
- * real async data: a server render requests them in parallel and renders
- * them, the browser hydrates with them without asking again and without a
- * mismatch, and a client navigation does not wait for them.
- */
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import {
-  computed,
-  createSSRApp,
-  defineComponent,
-  h,
-  nextTick,
-  type App,
-} from "vue";
-import { renderToString } from "vue/server-renderer";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { DmsFrontendRuntime } from "#dms/frontend-module";
-import type { TableViewColumn } from "../layers/dms-ui/app/composables/table-view/types";
-
-const engine = await import("#dms/frontend-module");
-vi.stubGlobal("computed", computed);
-vi.stubGlobal("useDmsAsyncData", engine.useDmsAsyncData);
-vi.stubGlobal("useI18n", () => ({ locale: { value: "en" } }));
-vi.stubGlobal("useTranslation", () => ({
-  processI18n: (text: string) => text,
-}));
-vi.stubGlobal("useDataTypes", () => ({ getDataType: () => undefined }));
-
-const LOCATION = "/api/orders";
-const COLUMNS = [
-  { id: "total", accessorKey: "total" },
-] as unknown as TableViewColumn[];
-const DELAY_MS = 20;
-
-interface Request {
-  url: string;
-  startedAt: number;
-}
-
-const requests: Request[] = [];
-let inFlight = 0;
-let mostInFlight = 0;
-
-async function answer<T>(url: string, value: T): Promise<T> {
-  requests.push({ url, startedAt: performance.now() });
-  inFlight += 1;
-  mostInFlight = Math.max(mostInFlight, inFlight);
-  await new Promise((done) => setTimeout(done, DELAY_MS));
-  inFlight -= 1;
-  return value;
-}
-
-const api = (async (url: string) =>
-  url.endsWith("/count/batch")
-    ? answer(url, { all: 2, open: 1 })
-    : answer(url, { results: [{ _id: "a", total: 3 }], total: 1 })) as never;
-vi.stubGlobal("useAuthFetch", () => ({
-  $authFetch: (url: string) => answer(url, { sum: 42 }),
-}));
-
-const { useApiData } = await import(
-  "../layers/dms-core/app/composables/auth/useApiData"
-);
-vi.stubGlobal("useApiData", useApiData);
-
-const { useTableRows } = await import(
-  "../layers/dms-ui/app/build/composables/table-view/useTableRows"
-);
-const { useTableCountsData, useTableListData } = await import(
-  "../layers/dms-ui/app/build/composables/table-view/useTableListData"
-);
-const { useTableFooter } = await import(
-  "../layers/dms-ui/app/build/composables/table-view/useTableFooter"
-);
-
-const Table = defineComponent({
-  setup() {
-    const rows = useTableRows({ api, location: LOCATION, columns: COLUMNS });
-    const keys = { componentId: "orders", pageId: "sales", rows };
-    const archiveQuery = computed(() => ({}));
-    // As TableView: none of the three is awaited.
-    const list = useTableListData({
-      ...keys,
-      query: computed(() => ({ offset: 0, limit: 10 })),
-      archiveQuery,
-      isSelfManaged: computed(() => false),
-    });
-    const counts = useTableCountsData({
-      ...keys,
-      queries: computed(() => [
-        { id: "all", query: {} },
-        { id: "open", query: { filter_status: "is:open" } },
-      ]),
-      archiveQuery,
-    });
-    const { footer } = useTableFooter({
-      footer: {
-        summary: [{ id: "sum", op: "sum", field: "total", label: "Sum" }],
-      },
-      columns: COLUMNS,
-      location: LOCATION,
-      query: computed(() => ({})),
-      dataKey: "table-view-orders-sales",
-    } as never);
-    return () =>
-      h("p", [
-        `rows:${list.data.value?.total ?? "-"}`,
-        ` counts:${counts.data.value ? counts.data.value.all : "-"}`,
-        ` sum:${footer.value?.summaries[0]?.value ?? "-"}`,
-      ]);
-  },
-});
-
-let runtime: DmsFrontendRuntime;
-const mounted: App[] = [];
-
-beforeEach(() => {
-  requests.length = 0;
-  inFlight = 0;
-  mostInFlight = 0;
-});
-
-afterEach(() => {
-  mounted.splice(0).forEach((app) => app.unmount());
-});
-
-async function serverRender(): Promise<{ html: string; payload: unknown }> {
-  runtime = engine.createDmsFrontendRuntime(undefined, {}, true);
-  const app = createSSRApp(Table);
-  engine.provideDmsFrontendRuntime(app, runtime);
-  const html = await renderToString(app);
-  return { html, payload: engine.serializeDmsPayload(runtime) };
-}
-
-describe("a table view's data in a server render", () => {
-  it("requests the list, the counters and the footer in parallel and renders them", async () => {
-    const { html } = await serverRender();
-
-    expect(html).toBe("<p>rows:1 counts:2 sum:42</p>");
-    expect(requests.map(({ url }) => url).sort()).toEqual([
-      `${LOCATION}/count/batch`,
-      `${LOCATION}/list`,
-      `${LOCATION}/summary`,
-    ]);
-    expect(mostInFlight).toBe(3);
-  });
-
-  it("hands the browser the rendered data: no request, no mismatch", async () => {
-    const { html, payload } = await serverRender();
-    requests.length = 0;
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const error = vi.spyOn(console, "error").mockImplementation(() => {});
-
-    const browser = engine.createDmsFrontendRuntime(undefined, {});
-    engine.restoreDmsPayload(
-      browser,
-      structuredClone(payload) as Parameters<
-        typeof engine.restoreDmsPayload
-      >[1],
-    );
-    const container = document.createElement("div");
-    container.innerHTML = html;
-    const app = createSSRApp(Table);
-    engine.provideDmsFrontendRuntime(app, browser);
-    app.mount(container);
-    mounted.push(app);
-    await nextTick();
-    await new Promise((done) => setTimeout(done, DELAY_MS * 2));
-
-    const mismatches = [...warn.mock.calls, ...error.mock.calls].filter(
-      (call) => /hydration/i.test(String(call[0])),
-    );
-    warn.mockRestore();
-    error.mockRestore();
-    expect(mismatches).toEqual([]);
-    expect(requests).toEqual([]);
-    expect(container.textContent).toBe("rows:1 counts:2 sum:42");
-  });
-
-  it("is not awaited by TableView, so the three start together", () => {
-    const tableView = readFileSync(
-      resolve(
-        __dirname,
-        "../layers/dms-ui/app/components/table-view/TableView.vue",
-      ),
-      "utf8",
-    );
-    expect(tableView).not.toMatch(
-      /await\s+(useTableListData|useTableCountsData|useTableFooter)\b/,
-    );
-  });
-});