@antelopejs/dms 0.9.1 → 0.9.3

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

@@ -1,222 +0,0 @@
-// @vitest-environment jsdom
-import {
-  computed,
-  createApp,
-  defineComponent,
-  h,
-  nextTick,
-  ref,
-  watch,
-  type App,
-  type VNode,
-} from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { useGroupedRows } from "../layers/dms-ui/app/build/composables/table-view/useGroupedRows";
-import {
-  dateGroupLabel,
-  groupedOptionsFor,
-  groupedSorting,
-  groupFilter,
-  isGroupableColumn,
-  NO_GROUP_KEY,
-  rowGroupKey,
-} from "../layers/dms-ui/app/build/composables/table-view/utils/groupedRows";
-import type { TableViewColumn } from "../layers/dms-ui/app/composables/table-view/types";
-
-const LABELS = {
-  today: "Today",
-  yesterday: "Yesterday",
-  weekOf: (date: string) => `Week of ${date}`,
-};
-const local = (day: number, hour: number) =>
-  new Date(2026, 8, day, hour, 30).toISOString();
-
-describe("grouped rows", () => {
-  it("files a row under its value, a relation under its id", () => {
-    expect(rowGroupKey("open", "value", "en-GB")).toBe("open");
-    expect(rowGroupKey(true, "value", "en-GB")).toBe("true");
-    expect(rowGroupKey({ _id: "r1", name: "Ops" }, "value", "en-GB")).toBe(
-      "r1",
-    );
-    expect(rowGroupKey(null, "value", "en-GB")).toBe(NO_GROUP_KEY);
-  });
-
-  it("files a date under its calendar day and week, in the reader's time zone", () => {
-    expect(rowGroupKey(local(29, 23), "day", "en-GB")).toBe("2026-09-29");
-    expect(rowGroupKey(local(29, 1), "day", "en-GB")).toBe("2026-09-29");
-    // Tuesday Sep 29: the week starts on Monday Sep 28 in en-GB.
-    expect(rowGroupKey(local(29, 9), "week", "en-GB")).toBe("2026-09-28");
-    expect(rowGroupKey(local(27, 9), "week", "en-GB")).toBe("2026-09-21");
-    expect(rowGroupKey(undefined, "day", "en-GB")).toBe(NO_GROUP_KEY);
-  });
-
-  it("names day and week groups", () => {
-    const now = new Date(2026, 8, 29, 10);
-    expect(dateGroupLabel("2026-09-29", "day", "en-GB", LABELS, now)).toBe(
-      "Today · 29 Sept",
-    );
-    expect(dateGroupLabel("2026-09-28", "day", "en-GB", LABELS, now)).toBe(
-      "Yesterday · 28 Sept",
-    );
-    expect(dateGroupLabel("2026-09-21", "week", "en-GB", LABELS, now)).toBe(
-      "Week of 21 Sept",
-    );
-  });
-
-  it("filters a group's rows for its count", () => {
-    expect(groupFilter("status", "open", "value")).toEqual({
-      accessorKey: "status",
-      mode: "is",
-      value: "open",
-    });
-    expect(groupFilter("createdAt", "2026-09-29", "day")).toEqual({
-      accessorKey: "createdAt",
-      mode: "is_between",
-      value: "2026-09-29,2026-09-29",
-    });
-    expect(groupFilter("createdAt", "2026-09-28", "week")).toEqual({
-      accessorKey: "createdAt",
-      mode: "is_between",
-      value: "2026-09-28,2026-10-04",
-    });
-    expect(groupFilter("status", NO_GROUP_KEY, "value")).toBe(undefined);
-  });
-
-  it("lists the rows sorted on the grouped column, in the user's direction on it", () => {
-    const byDay = { groupByField: "createdAt", by: "day" as const };
-    expect(groupedSorting([{ id: "title", desc: false }], byDay)).toEqual([
-      { id: "createdAt", desc: true },
-    ]);
-    expect(groupedSorting([{ id: "createdAt", desc: false }], byDay)).toEqual([
-      { id: "createdAt", desc: false },
-    ]);
-    expect(groupedSorting([], { groupByField: "status" })).toEqual([
-      { id: "status", desc: false },
-    ]);
-  });
-});
-
-describe("grouped group-by", () => {
-  const column = (accessorKey: string, typeId: string, options = {}) =>
-    ({
-      id: accessorKey,
-      accessorKey,
-      header: accessorKey,
-      listable: true,
-      type: { id: typeId, inputComponent: { options } },
-    }) as unknown as TableViewColumn;
-  const columns = [
-    column("status", "select", { items: [{ value: "open", label: "Open" }] }),
-    column("tags", "select", { multiple: true }),
-    column("done", "boolean"),
-    column("startedAt", "datetime"),
-    column("dueOn", "date"),
-    column("title", "string"),
-  ];
-
-  it("offers the columns holding a few known values, and the dates", () => {
-    expect(columns.filter(isGroupableColumn).map((c) => c.accessorKey)).toEqual(
-      ["status", "done", "startedAt", "dueOn"],
-    );
-  });
-
-  it("keeps the configured cut on the configured column", () => {
-    const grouped = { groupByField: "startedAt", by: "week" as const };
-    expect(groupedOptionsFor(grouped, "startedAt", columns)).toBe(grouped);
-  });
-
-  it("groups another date by the configured date cut, else by day", () => {
-    expect(
-      groupedOptionsFor(
-        { groupByField: "startedAt", by: "week", count: true },
-        "dueOn",
-        columns,
-      ),
-    ).toEqual({ groupByField: "dueOn", by: "week", count: true });
-    expect(
-      groupedOptionsFor({ groupByField: "status" }, "dueOn", columns),
-    ).toEqual({ groupByField: "dueOn", by: "day" });
-  });
-
-  it("groups any other column by its value", () => {
-    expect(
-      groupedOptionsFor(
-        { groupByField: "startedAt", by: "day", collapsible: true },
-        "status",
-        columns,
-      ),
-    ).toEqual({ groupByField: "status", by: "value", collapsible: true });
-  });
-});
-
-describe("useGroupedRows", () => {
-  let app: App | undefined;
-
-  beforeEach(() => {
-    vi.stubGlobal("computed", computed);
-    vi.stubGlobal("ref", ref);
-    vi.stubGlobal("watch", watch);
-    vi.stubGlobal("useI18n", () => ({
-      t: (key: string, params?: Record<string, string>) =>
-        params ? `${key}:${JSON.stringify(params)}` : key,
-      locale: ref("en-GB"),
-    }));
-    vi.stubGlobal("useDataTypes", () => ({ getDataType: () => undefined }));
-  });
-
-  afterEach(() => {
-    app?.unmount();
-    app = undefined;
-    vi.unstubAllGlobals();
-  });
-
-  it("counts the groups listed, with the rows' own filters, and heads them", async () => {
-    const asked: unknown[] = [];
-    const rows = ref([
-      { _id: "1", status: "open" },
-      { _id: "2", status: "open" },
-      { _id: "3", status: null },
-      { _id: "4", status: "closed" },
-    ]);
-    let grouped: ReturnType<typeof useGroupedRows> | undefined;
-    app = createApp(
-      defineComponent({
-        setup() {
-          grouped = useGroupedRows({
-            grouped: { groupByField: "status", count: true, collapsible: true },
-            isActive: computed(() => true),
-            columns: [
-              { id: "status", accessorKey: "status", header: "Status" },
-            ] as TableViewColumn[],
-            rows,
-            countQuery: (filter) => ({
-              search: "late",
-              [`filter_${filter.accessorKey}`]: `${filter.mode}:${filter.value}`,
-            }),
-            countBatch: async (queries) => {
-              asked.push(queries);
-              return { open: 12, closed: 4 };
-            },
-          });
-          return () => h("div");
-        },
-      }),
-    );
-    app.mount(document.createElement("div"));
-    await nextTick();
-    await nextTick();
-
-    expect(asked).toEqual([
-      [
-        { id: "open", query: { search: "late", filter_status: "is:open" } },
-        { id: "closed", query: { search: "late", filter_status: "is:closed" } },
-      ],
-    ]);
-    const grouping = grouped!.grouping.value!;
-    expect(grouping.collapsible).toBe(true);
-    expect(grouping.keyOf(rows.value[0]!)).toBe("open");
-    expect(grouping.countOf?.("open")).toBe(12);
-    const noValue = grouping.header(NO_GROUP_KEY, rows.value[2]!) as VNode;
-    expect(noValue.children).toBe("dms.table.grouped.none");
-  });
-});

package/frontend-vue/tests/table-view-hidden-filters-page.test.ts

@@ -1,134 +0,0 @@
-import { computed, nextTick, readonly, ref, watch, type Ref } from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { LocationQuery } from "vue-router";
-import { useAccumulatedPages } from "../layers/dms-ui/app/build/composables/table-view/useAccumulatedPages";
-import { usePersistedPagination } from "../layers/dms-ui/app/build/composables/table-view/usePersistedPagination";
-import { usePreferences } from "../layers/dms-core/app/composables/user/usePreferences";
-import { useTablePreferences } from "../layers/dms-ui/app/build/composables/table-view/useTablePreferences";
-import { tablePreferenceId } from "../layers/dms-core/app/build/composables/user/tablePreferences";
-
-const PAGE_SIZE = 10;
-const THIRD_PAGE = 2;
-
-// What a table view derives from `queryParamFilters: { status: { field: "status" } }`.
-const hiddenFiltersOf = (query: () => LocationQuery) =>
-  computed(() =>
-    query().status === undefined
-      ? []
-      : [{ accessorKey: "status", mode: "is", value: query().status }],
-  );
-
-const COMPONENT_ID = "tasks";
-const PAGE_ID = "query-filters";
-
-// The `dms-preferences` cookie, surviving the remounts of a page.
-let cookie: Ref<string>;
-
-// What a table view does on mount: its page, read back from the cookie,
-// under the hidden filters the URL sets.
-const mountTable = (query: Ref<LocationQuery>) => {
-  const hiddenFilters = hiddenFiltersOf(() => query.value);
-  const pagination = usePersistedPagination({
-    preferences: useTablePreferences(COMPONENT_ID, PAGE_ID),
-    defaults: { pageIndex: 0, pageSize: PAGE_SIZE },
-    scope: () => [hiddenFilters.value, []],
-  });
-  return { hiddenFilters, pagination };
-};
-
-beforeEach(() => {
-  cookie = ref("");
-  vi.stubGlobal("useDmsCookie", () => cookie);
-  vi.stubGlobal("usePreferences", usePreferences);
-  vi.stubGlobal("ref", ref);
-  vi.stubGlobal("readonly", readonly);
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("watch", watch);
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-describe("a hidden filter changed by the URL", () => {
-  it("sends the pager back to page 1", () => {
-    const query = ref<LocationQuery>({ status: "pending" });
-    const { pagination } = mountTable(query);
-    pagination.value = { pageIndex: THIRD_PAGE, pageSize: PAGE_SIZE };
-
-    query.value = { status: "cancelled" };
-
-    expect(pagination.value).toEqual({ pageIndex: 0, pageSize: PAGE_SIZE });
-  });
-
-  it("keeps the page when another query parameter changes", () => {
-    const query = ref<LocationQuery>({ status: "pending" });
-    const { pagination } = mountTable(query);
-    pagination.value = { pageIndex: THIRD_PAGE, pageSize: PAGE_SIZE };
-
-    query.value = { status: "pending", record: "42" };
-
-    expect(pagination.value.pageIndex).toBe(THIRD_PAGE);
-  });
-
-  it("sends the pager back to page 1 when the filter goes away", () => {
-    const query = ref<LocationQuery>({ status: "pending" });
-    const { pagination } = mountTable(query);
-    pagination.value = { pageIndex: THIRD_PAGE, pageSize: PAGE_SIZE };
-
-    query.value = {};
-
-    expect(pagination.value.pageIndex).toBe(0);
-  });
-
-  it("starts at page 1 when a link remounts the page under another value", async () => {
-    const first = mountTable(ref<LocationQuery>({ status: "pending" }));
-    first.pagination.value = { pageIndex: THIRD_PAGE, pageSize: PAGE_SIZE };
-    await nextTick();
-
-    const other = mountTable(ref<LocationQuery>({ status: "completed" }));
-    expect(other.pagination.value).toEqual({
-      pageIndex: 0,
-      pageSize: PAGE_SIZE,
-    });
-  });
-
-  it("restores the page of a remount under the same value", async () => {
-    const first = mountTable(ref<LocationQuery>({ status: "pending" }));
-    first.pagination.value = { pageIndex: THIRD_PAGE, pageSize: PAGE_SIZE };
-    await nextTick();
-
-    const again = mountTable(ref<LocationQuery>({ status: "pending" }));
-    expect(again.pagination.value.pageIndex).toBe(THIRD_PAGE);
-  });
-
-  it("keeps a page stored without its hidden filters", () => {
-    usePreferences().setPreference(
-      `tables.${tablePreferenceId(COMPONENT_ID, PAGE_ID)}`,
-      { p: [PAGE_SIZE, THIRD_PAGE] },
-    );
-    const table = mountTable(ref<LocationQuery>({}));
-    expect(table.pagination.value.pageIndex).toBe(THIRD_PAGE);
-  });
-
-  it("starts a load-more list over from one page", async () => {
-    const query = ref<LocationQuery>({ status: "pending" });
-    const hiddenFilters = hiddenFiltersOf(() => query.value);
-    const pagination = ref({ pageIndex: 0, pageSize: PAGE_SIZE });
-    const pages = useAccumulatedPages({
-      mode: "loadMore",
-      pagination,
-      resetOn: [hiddenFilters],
-    });
-    pages.loadNextPage();
-    expect(pages.requestedPagination.value.pageSize).toBe(PAGE_SIZE * 2);
-
-    query.value = { status: "cancelled" };
-    await nextTick();
-
-    expect(pages.requestedPagination.value).toEqual({
-      pageIndex: 0,
-      pageSize: PAGE_SIZE,
-    });
-  });
-});

package/frontend-vue/tests/table-view-pagination-modes.test.ts

@@ -1,48 +0,0 @@
-import { computed, nextTick, ref, watch } from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { useAccumulatedPages } from "../layers/dms-ui/app/build/composables/table-view/useAccumulatedPages";
-
-beforeEach(() => {
-  vi.stubGlobal("ref", ref);
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("watch", watch);
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-describe("pages loaded by more", () => {
-  it("asks for every page loaded so far, and starts over when the list changes", async () => {
-    const pagination = ref({ pageIndex: 0, pageSize: 20 });
-    const search = ref("");
-    const pages = useAccumulatedPages({
-      mode: "infinite",
-      pagination,
-      resetOn: [search],
-    });
-    expect(pages.isAccumulating).toBe(true);
-    pages.loadNextPage();
-    pages.loadNextPage();
-    expect(pages.requestedPagination.value).toEqual({
-      pageIndex: 0,
-      pageSize: 60,
-    });
-    search.value = "deploy";
-    await nextTick();
-    expect(pages.requestedPagination.value.pageSize).toBe(20);
-  });
-
-  it("leaves a paged list's pagination alone", () => {
-    const pagination = ref({ pageIndex: 3, pageSize: 10 });
-    const pages = useAccumulatedPages({
-      mode: "pages",
-      pagination,
-      resetOn: [],
-    });
-    expect(pages.requestedPagination.value).toEqual({
-      pageIndex: 3,
-      pageSize: 10,
-    });
-  });
-});

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

@@ -1,128 +0,0 @@
-/**
- * `pinnedRows`: the rows a rule accepts lead the list whatever the sort — the
- * base language of a languages table stays on top whichever column the user
- * sorts on, and on the first page.
- */
-import { describe, expect, it, vi } from "vitest";
-import {
-  processSourceRows,
-  useTableRows,
-} from "../layers/dms-ui/app/build/composables/table-view/useTableRows";
-import { pinRows } from "../layers/dms-ui/app/build/composables/table-view/utils/pinnedRows";
-import type { TableViewColumn } from "../layers/dms-ui/app/composables/table-view/types";
-
-interface LanguageRow extends Record<string, unknown> {
-  _id: string;
-  name: string;
-  coverage: number;
-  isBase: boolean;
-}
-
-const LANGUAGES: LanguageRow[] = [
-  { _id: "de", name: "Deutsch", coverage: 40, isBase: false },
-  { _id: "en", name: "English", coverage: 100, isBase: true },
-  { _id: "fr", name: "Français", coverage: 90, isBase: false },
-  { _id: "es", name: "Español", coverage: 10, isBase: false },
-];
-
-const COLUMNS = [
-  { id: "name", accessorKey: "name" },
-  { id: "coverage", accessorKey: "coverage" },
-] as TableViewColumn[];
-
-const BASE = { field: "isBase", equals: true };
-
-type Api = Parameters<typeof useTableRows>[0]["api"];
-
-const ids = (rows: LanguageRow[]) => rows.map((row) => row._id);
-
-describe("pinRows", () => {
-  it("puts the rows the rule accepts first, each part in its order", () => {
-    expect(
-      ids(pinRows(LANGUAGES, { field: "coverage", in: [10, 100] })),
-    ).toEqual(["en", "es", "de", "fr"]);
-  });
-
-  it("leaves the rows as they are without a rule, or when none matches", () => {
-    expect(pinRows(LANGUAGES, undefined)).toBe(LANGUAGES);
-    expect(pinRows(LANGUAGES, { field: "_id", equals: "it" })).toBe(LANGUAGES);
-  });
-});
-
-describe("a source sorted in the browser", () => {
-  it("keeps the pinned row first in either direction", () => {
-    const ascending = processSourceRows(
-      LANGUAGES,
-      { sortKey: "coverage", sortDirection: "asc" },
-      {},
-      COLUMNS,
-      BASE,
-    );
-    const descending = processSourceRows(
-      LANGUAGES,
-      { sortKey: "name", sortDirection: "desc" },
-      {},
-      COLUMNS,
-      BASE,
-    );
-    expect(ids(ascending.results)).toEqual(["en", "es", "de", "fr"]);
-    expect(ids(descending.results)).toEqual(["en", "fr", "es", "de"]);
-  });
-
-  it("pins before the page is cut: the pinned row opens the first page", () => {
-    const query = { sortKey: "coverage", sortDirection: "asc", limit: 2 };
-    const first = processSourceRows(LANGUAGES, query, {}, COLUMNS, BASE);
-    const second = processSourceRows(
-      LANGUAGES,
-      { ...query, offset: 2 },
-      {},
-      COLUMNS,
-      BASE,
-    );
-    expect(ids(first.results)).toEqual(["en", "es"]);
-    expect(ids(second.results)).toEqual(["de", "fr"]);
-    expect(first.total).toBe(4);
-  });
-});
-
-describe("rows a route sorts", () => {
-  it("pins within the list a source route sorted itself", async () => {
-    const sortedByRoute = [...LANGUAGES].sort(
-      (a, b) => a.coverage - b.coverage,
-    );
-    const api = vi.fn(async () => ({ results: sortedByRoute, total: 4 }));
-    const rows = useTableRows<LanguageRow>({
-      api: api as unknown as Api,
-      location: "/api/languages",
-      source: { fetchUrl: "/api/languages", capabilities: { sort: true } },
-      columns: COLUMNS,
-      pinnedRows: () => BASE,
-    });
-    const page = await rows.list({ sortKey: "coverage", sortDirection: "asc" });
-    expect(ids(page!.results)).toEqual(["en", "es", "de", "fr"]);
-  });
-
-  it("pins within the page a controller answers, read on each request", async () => {
-    const api = vi.fn(async () => ({
-      results: LANGUAGES,
-      total: 40,
-      offset: 0,
-      limit: 4,
-    }));
-    let pinned: typeof BASE | undefined = BASE;
-    const rows = useTableRows<LanguageRow>({
-      api: api as unknown as Api,
-      location: "/api/languages",
-      columns: COLUMNS,
-      pinnedRows: () => pinned,
-    });
-    expect(ids((await rows.list({}))!.results)).toEqual([
-      "en",
-      "de",
-      "fr",
-      "es",
-    ]);
-    pinned = undefined;
-    expect(ids((await rows.list({}))!.results)).toEqual(ids(LANGUAGES));
-  });
-});