@antelopejs/dms 0.9.2 → 0.9.4

package/frontend-vue/tests/table-view-display-registry.test.ts

@@ -1,59 +0,0 @@
-import { ref, type Ref } from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { registerTableViewDisplay } from "../layers/dms-ui/app/composables/table-view/useTableViewDisplays";
-import { storeTableViewDisplay } from "../layers/dms-ui/app/build/composables/table-view/displayRegistry";
-import type { TableViewDisplay } from "../layers/dms-ui/app/composables/table-view/types/display";
-
-const display = (id: string): TableViewDisplay => ({
-  id,
-  label: id,
-  icon: "i-ph-cards",
-});
-
-describe("table view display registry", () => {
-  let state: Ref<TableViewDisplay[]>;
-
-  beforeEach(() => {
-    state = ref([]);
-    vi.stubGlobal("useDmsState", () => state);
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it("registers a module display under <module>:<id>", () => {
-    registerTableViewDisplay(display("saas:plan-cards"));
-    expect(state.value.map((entry) => entry.id)).toEqual(["saas:plan-cards"]);
-  });
-
-  it.each(["table", "kanban", "cards", "grouped"])(
-    "refuses the reserved id %s",
-    (id) => {
-      expect(() => registerTableViewDisplay(display(id))).toThrow(
-        /is a built-in display/,
-      );
-    },
-  );
-
-  it("refuses an id without its module prefix", () => {
-    expect(() => registerTableViewDisplay(display("timeline"))).toThrow(
-      /must be named "<module>:<id>"/,
-    );
-  });
-
-  it("refuses to overwrite a display another registration claimed", () => {
-    registerTableViewDisplay(display("automation:timeline"));
-    expect(() =>
-      registerTableViewDisplay(display("automation:timeline")),
-    ).toThrow(/already registered/);
-  });
-
-  it("lets the DMS store its built-in displays", () => {
-    storeTableViewDisplay(display("cards"));
-    expect(() => registerTableViewDisplay(display("cards"))).toThrow(
-      /is a built-in display/,
-    );
-    expect(state.value.map((entry) => entry.id)).toEqual(["cards"]);
-  });
-});

package/frontend-vue/tests/table-view-escape-shortcut.test.ts

@@ -1,141 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import {
-  computed,
-  createApp,
-  defineComponent,
-  nextTick,
-  ref,
-  shallowRef,
-  type App,
-  type Ref,
-  type ShallowRef,
-} from "vue";
-import { useActiveElement } from "@vueuse/core";
-import type { RowSelectionState } from "@tanstack/vue-table";
-import { defineShortcuts } from "@nuxt/ui/runtime/composables/defineShortcuts.js";
-import {
-  TABLE_VIEW_SHORTCUTS_METADATA,
-  buildTableViewShortcuts,
-} from "../layers/dms-ui/app/composables/table-view/shortcuts";
-
-let app: App;
-let host: HTMLDivElement;
-let globalFilter: ShallowRef<string | undefined>;
-let rowSelect: Ref<RowSelectionState>;
-
-function mountTableShortcuts() {
-  const Harness = defineComponent({
-    setup() {
-      defineShortcuts(
-        buildTableViewShortcuts({
-          refresh: () => {},
-          tableProps: computed(() => ({})),
-          newRow: () => {},
-          globalFilter,
-          rowSelect,
-          data: ref(null),
-          activeElement: useActiveElement(),
-        }),
-      );
-      return () => null;
-    },
-  });
-  app = createApp(Harness);
-  app.mount(host);
-}
-
-function pressEscape(target: EventTarget = document.body): KeyboardEvent {
-  const event = new KeyboardEvent("keydown", {
-    key: "Escape",
-    code: "Escape",
-    bubbles: true,
-    cancelable: true,
-  });
-  target.dispatchEvent(event);
-  return event;
-}
-
-beforeEach(() => {
-  host = document.createElement("div");
-  document.body.appendChild(host);
-  globalFilter = shallowRef<string | undefined>(undefined);
-  rowSelect = ref<RowSelectionState>({});
-});
-
-afterEach(() => {
-  app.unmount();
-  document.body.innerHTML = "";
-});
-
-describe("TableView Escape shortcut", () => {
-  it("leaves Escape to overlays when there is nothing to clear", async () => {
-    mountTableShortcuts();
-    await nextTick();
-
-    expect(pressEscape().defaultPrevented).toBe(false);
-  });
-
-  it("closes the search when a global filter is set", async () => {
-    globalFilter.value = "acme";
-    mountTableShortcuts();
-    await nextTick();
-
-    expect(pressEscape().defaultPrevented).toBe(true);
-    expect(globalFilter.value).toBeUndefined();
-  });
-
-  it("clears the row selection when no search is open", async () => {
-    rowSelect.value = { a: true, b: true };
-    mountTableShortcuts();
-    await nextTick();
-
-    expect(pressEscape().defaultPrevented).toBe(true);
-    expect(rowSelect.value).toEqual({});
-  });
-
-  it("closes the search before touching the selection", async () => {
-    globalFilter.value = "";
-    rowSelect.value = { a: true };
-    mountTableShortcuts();
-    await nextTick();
-
-    pressEscape();
-    expect(globalFilter.value).toBeUndefined();
-    expect(rowSelect.value).toEqual({ a: true });
-  });
-
-  it("stops handling Escape once the filter is cleared", async () => {
-    globalFilter.value = "acme";
-    mountTableShortcuts();
-    await nextTick();
-
-    pressEscape();
-    await nextTick();
-    expect(pressEscape().defaultPrevented).toBe(false);
-  });
-
-  it("lets an open dialog take Escape even with a filter set", async () => {
-    globalFilter.value = "acme";
-    mountTableShortcuts();
-    const dialog = document.createElement("div");
-    dialog.setAttribute("role", "dialog");
-    const button = document.createElement("button");
-    dialog.appendChild(button);
-    document.body.appendChild(dialog);
-    button.focus();
-    await nextTick();
-
-    expect(pressEscape(button).defaultPrevented).toBe(false);
-    expect(globalFilter.value).toBe("acme");
-  });
-
-  it("describes when the shortcut applies in the help list", () => {
-    const escape = TABLE_VIEW_SHORTCUTS_METADATA.find((metadata) =>
-      metadata.key.includes("$keyboard.escape"),
-    );
-    expect(escape?.condition?.descriptionKey).toBe(
-      "$dms.shortcuts.tableview.escape.condition",
-    );
-  });
-});

package/frontend-vue/tests/table-view-expanded-band.test.ts

@@ -1,143 +0,0 @@
-// @vitest-environment jsdom
-import { createApp, defineComponent, h, type App } from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import ExpandedRowDetail from "../layers/dms-ui/app/build/components/table-view/ExpandedRowDetail.vue";
-import type {
-  TableViewColumn,
-  TableViewDisplayActions,
-  TableViewExpandableConfig,
-} from "../layers/dms-ui/app/composables/table-view/types";
-import type { ExpandedRowLoadState } from "../layers/dms-ui/app/build/composables/table-view/useExpandedRowDetails";
-
-vi.mock(
-  "../layers/dms-ui/app/components/key-value-list/KeyValueList.vue",
-  async () => {
-    const { defineComponent: define, h: render } = await import("vue");
-    return {
-      default: define({
-        props: { items: Array },
-        setup: (props) => () =>
-          render(
-            "dl",
-            (props.items as Array<{ label: string }>).map((item) =>
-              render("dt", item.label),
-            ),
-          ),
-      }),
-    };
-  },
-);
-
-const OrderLines = defineComponent({
-  props: { row: Object, rowId: String, refresh: Function, open: Function },
-  setup: (props) => () =>
-    h(
-      "button",
-      { "data-lines": props.rowId, onClick: () => props.refresh?.() },
-      String(props.row?.number),
-    ),
-});
-
-const refresh = vi.fn();
-
-const columns = [
-  { id: "carrier", accessorKey: "carrier", header: "Carrier" },
-] as unknown as TableViewColumn[];
-
-describe("TableView expanded row band", () => {
-  let app: App | undefined;
-
-  const mount = (
-    config: TableViewExpandableConfig,
-    loadState: ExpandedRowLoadState = "ready",
-    onRetry = () => {},
-  ) => {
-    app = createApp({
-      render: () =>
-        h(ExpandedRowDetail, {
-          rowProps: {
-            row: { number: "A-1", carrier: "UPS" },
-            rowId: "a1",
-            columns,
-            actions: {} as TableViewDisplayActions<Record<string, unknown>>,
-            open: () => {},
-            refresh,
-          },
-          config,
-          loadState,
-          onRetry,
-        }),
-    });
-    for (const name of ["USkeleton", "UIcon"]) {
-      app.component(name, defineComponent({ render: () => h("span") }));
-    }
-    app.component(
-      "UButton",
-      defineComponent({
-        props: { label: String },
-        setup: (props) => () => h("button", { "data-retry": "" }, props.label),
-      }),
-    );
-    const container = document.createElement("div");
-    app.mount(container);
-    return container;
-  };
-
-  beforeEach(() => {
-    vi.stubGlobal("useTranslation", () => ({
-      processI18n: (text: string) => text,
-    }));
-    vi.stubGlobal("useDataTypes", () => ({ getDataType: () => undefined }));
-    vi.stubGlobal("useI18n", () => ({
-      locale: { value: "en" },
-      t: (key: string) => key,
-    }));
-    vi.stubGlobal("resolveDmsComponent", (name: string) =>
-      name === "OrderLines" ? OrderLines : undefined,
-    );
-  });
-
-  afterEach(() => {
-    app?.unmount();
-    app = undefined;
-    vi.unstubAllGlobals();
-  });
-
-  it("hands the whole band to the component", () => {
-    const container = mount({
-      component: { componentName: "OrderLines" },
-      fields: [{ key: "carrier" }],
-    } as TableViewExpandableConfig);
-    expect(container.querySelector("[data-lines='a1']")?.textContent).toBe(
-      "A-1",
-    );
-    expect(container.querySelector("dl")).toBeNull();
-  });
-
-  it("hands the component the table's refresh", () => {
-    const container = mount({ component: { componentName: "OrderLines" } });
-    container.querySelector<HTMLButtonElement>("[data-lines]")!.click();
-    expect(refresh).toHaveBeenCalledOnce();
-  });
-
-  it("holds the band's place while its row loads, then says a failure, with a retry", () => {
-    const config = { component: { componentName: "OrderLines" } };
-    const loading = mount(config, "loading");
-    expect(loading.querySelector("[aria-busy='true']")).not.toBeNull();
-    expect(loading.querySelector("[data-lines]")).toBeNull();
-    app?.unmount();
-
-    const onRetry = vi.fn();
-    const failed = mount(config, "error", onRetry);
-    expect(failed.querySelector("[data-lines]")).toBeNull();
-    expect(failed.textContent).toContain("dms.table.load_error_title");
-    failed.querySelector<HTMLButtonElement>("[data-retry]")!.click();
-    expect(onRetry).toHaveBeenCalledOnce();
-  });
-
-  it("lists the fields without a component", () => {
-    const container = mount({ fields: [{ key: "carrier" }] });
-    expect(container.querySelector("[data-lines]")).toBeNull();
-    expect(container.querySelector("dt")?.textContent).toBe("Carrier");
-  });
-});

package/frontend-vue/tests/table-view-expanded-row-details.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { useExpandedRowDetails } from "../layers/dms-ui/app/build/composables/table-view/useExpandedRowDetails";
-import { buildExpandedRowProps } from "../layers/dms-ui/app/build/composables/table-view/utils/expandedRowProps";
-import type { TableViewDisplayActions } from "../layers/dms-ui/app/composables/table-view/types";
-
-interface Order {
-  _id: string;
-  number: string;
-  lines?: string[];
-}
-
-function deferred<T>() {
-  let resolve!: (value: T) => void;
-  let reject!: (error: unknown) => void;
-  const promise = new Promise<T>((done, fail) => {
-    resolve = done;
-    reject = fail;
-  });
-  return { promise, resolve, reject };
-}
-
-describe("lazyLoad expanded rows", () => {
-  it("reads an opened row once, until the listed rows reload", async () => {
-    const getRow = vi.fn(async (id: string) => ({ _id: id, number: "A-1" }));
-    const details = useExpandedRowDetails<Order>(getRow);
-
-    details.ensure(["a1"]);
-    expect(details.entryOf("a1")?.state).toBe("loading");
-    await vi.waitFor(() => expect(details.entryOf("a1")?.state).toBe("ready"));
-    details.ensure(["a1"]);
-    expect(getRow).toHaveBeenCalledOnce();
-
-    details.reset();
-    expect(details.entryOf("a1")).toBeUndefined();
-    details.ensure(["a1"]);
-    expect(getRow).toHaveBeenCalledTimes(2);
-  });
-
-  it("says a failed read failed, and reads it again on retry", async () => {
-    const getRow = vi
-      .fn<(id: string) => Promise<Order | undefined>>()
-      .mockRejectedValueOnce(new Error("network"))
-      .mockResolvedValueOnce({ _id: "a1", number: "A-1" });
-    const details = useExpandedRowDetails<Order>(getRow);
-
-    details.ensure(["a1"]);
-    await vi.waitFor(() => expect(details.entryOf("a1")?.state).toBe("error"));
-    await details.load("a1");
-    expect(details.entryOf("a1")).toEqual({
-      state: "ready",
-      row: { _id: "a1", number: "A-1" },
-    });
-  });
-
-  it("drops an answer that lands after the rows reloaded", async () => {
-    const answer = deferred<Order | undefined>();
-    const details = useExpandedRowDetails<Order>(() => answer.promise);
-
-    const loading = details.load("a1");
-    details.reset();
-    answer.resolve({ _id: "a1", number: "stale" });
-    await loading;
-    expect(details.entryOf("a1")).toBeUndefined();
-  });
-});
-
-describe("expanded row props", () => {
-  it("hands a band its row, actions, open and the table's refresh", () => {
-    const open = vi.fn();
-    const refresh = vi.fn();
-    const actions = { open } as unknown as TableViewDisplayActions<Order>;
-    const row = { _id: "a1", number: "A-1" };
-    const props = buildExpandedRowProps(row, {
-      columns: [],
-      labelKey: "number",
-      rowIdKey: "_id",
-      actions,
-      refresh,
-    });
-
-    expect(props).toMatchObject({ row, rowId: "a1", labelKey: "number" });
-    expect(props.actions).toBe(actions);
-    props.open();
-    expect(open).toHaveBeenCalledWith(row);
-    props.refresh();
-    expect(refresh).toHaveBeenCalledOnce();
-  });
-});

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

@@ -1,55 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  defaultExpandedRows,
-  keepListedRows,
-  nextExpandedRows,
-} from "../layers/dms-ui/app/build/composables/table-view/utils/expandedRows";
-
-const ROWS = ["a", "b", "c"];
-
-describe("TableView expandable rows", () => {
-  it("opens nothing, the first row or every row on arrival", () => {
-    expect(defaultExpandedRows(ROWS)).toEqual({});
-    expect(defaultExpandedRows(ROWS, "first")).toEqual({ a: true });
-    expect(defaultExpandedRows(ROWS, "all")).toEqual({
-      a: true,
-      b: true,
-      c: true,
-    });
-    expect(defaultExpandedRows([], "all")).toEqual({});
-  });
-
-  it("opens only the first row for 'all' in single mode", () => {
-    expect(defaultExpandedRows(ROWS, "all", true)).toEqual({ a: true });
-  });
-
-  it("keeps several rows open, and drops closed ones", () => {
-    expect(nextExpandedRows({ a: true }, { a: true, b: true }, ROWS)).toEqual({
-      a: true,
-      b: true,
-    });
-    expect(
-      nextExpandedRows({ a: true, b: true }, { a: false, b: true }, ROWS),
-    ).toEqual({ b: true });
-  });
-
-  it("turns TanStack's 'all rows' into the listed ids", () => {
-    expect(nextExpandedRows({}, true, ROWS)).toEqual({
-      a: true,
-      b: true,
-      c: true,
-    });
-  });
-
-  it("keeps only the row opened last in single mode", () => {
-    expect(
-      nextExpandedRows({ a: true }, { a: true, c: true }, ROWS, true),
-    ).toEqual({ c: true });
-    expect(nextExpandedRows({ a: true }, {}, ROWS, true)).toEqual({});
-    expect(nextExpandedRows({}, true, ROWS, true)).toEqual({ c: true });
-  });
-
-  it("forgets open rows that are no longer listed", () => {
-    expect(keepListedRows({ a: true, z: true }, ROWS)).toEqual({ a: true });
-  });
-});

package/frontend-vue/tests/table-view-form-texts.test.ts

@@ -1,124 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createI18n } from "vue-i18n";
-import {
-  formatRecordLabel,
-  resolveFormContainerTexts,
-  type FormContainerTextSource,
-} from "../layers/dms-ui/app/build/composables/table-view/utils/formTexts";
-import en from "../layers/dms-ui/i18n/locales/ui-en-GB.json";
-import fr from "../layers/dms-ui/i18n/locales/ui-fr-FR.json";
-
-const TASKS = {
-  en: {
-    caption: "Tasks",
-    edit_title: "Edit task",
-    edit_description: "Change its status or assignees.",
-  },
-  fr: { caption: "Tâches" },
-};
-
-function texts(source: FormContainerTextSource, locale: "en" | "fr" = "en") {
-  const i18n = createI18n({
-    legacy: false,
-    locale,
-    messages: {
-      en: { ...en, tasks: TASKS.en },
-      fr: { ...fr, tasks: TASKS.fr },
-    },
-  });
-  const t = (key: string, params?: Record<string, unknown>) =>
-    i18n.global.t(key, params ?? {});
-  const resolve = (text: string) =>
-    text.startsWith("$") ? t(text.slice(1)) : text;
-  return resolveFormContainerTexts(source, resolve, t);
-}
-
-describe("TableView form container texts", () => {
-  it("uses the formContainer page texts and follows the title with the row label", () => {
-    expect(
-      texts({
-        kind: "edit",
-        caption: "$tasks.caption",
-        pages: {
-          edit: {
-            displayName: "$tasks.edit_title",
-            description: "$tasks.edit_description",
-          },
-        },
-        recordLabel: "Write the docs",
-      }),
-    ).toEqual({
-      title: "Edit task · Write the docs",
-      description: "Change its status or assignees.",
-    });
-  });
-
-  it("falls back to entry texts naming the caption, never an item", () => {
-    const fallback = texts({ kind: "new", caption: "$tasks.caption" });
-    expect(fallback).toEqual({
-      title: "New entry",
-      description: "Added to Tasks once saved.",
-    });
-    expect(JSON.stringify(fallback)).not.toMatch(/item/i);
-  });
-
-  it("titles the details form from the pages' `details` entry", () => {
-    expect(
-      texts({
-        kind: "view",
-        pages: { details: { displayName: "Task details" } },
-        recordLabel: "Write the docs",
-      }).title,
-    ).toBe("Task details · Write the docs");
-  });
-
-  it("speaks French in the fallback too", () => {
-    expect(
-      texts({ kind: "view", caption: "$tasks.caption", recordLabel: 7 }, "fr"),
-    ).toEqual({
-      title: "Détails de l’entrée · 7",
-      description: "Une entrée de « Tâches », en lecture seule.",
-    });
-  });
-
-  it("keeps the generic description when the table has no caption", () => {
-    expect(texts({ kind: "edit" })).toEqual({
-      title: "Edit entry",
-      description: "Change its fields, then save.",
-    });
-  });
-
-  it("completes a partial override with the fallback", () => {
-    expect(
-      texts({
-        kind: "edit",
-        pages: { edit: { displayName: "Edit task" } },
-        caption: "Tasks",
-      }),
-    ).toEqual({
-      title: "Edit task",
-      description: "Changes are saved to Tasks.",
-    });
-  });
-});
-
-describe("formatRecordLabel", () => {
-  it("keeps a non-empty text or a number", () => {
-    expect(formatRecordLabel("  zz@example.com ")).toBe("zz@example.com");
-    expect(formatRecordLabel(42)).toBe("42");
-  });
-
-  it("reads a localized value in the reader's locale, else its first text", () => {
-    const name = { en: "Task 1", fr: "Tâche 1" };
-    expect(formatRecordLabel(name, "fr-FR")).toBe("Tâche 1");
-    expect(formatRecordLabel(name, "en")).toBe("Task 1");
-    expect(formatRecordLabel({ en: "Task 1" }, "fr-FR")).toBe("Task 1");
-  });
-
-  it("drops what cannot name a row", () => {
-    expect(formatRecordLabel("   ")).toBeUndefined();
-    expect(formatRecordLabel(null)).toBeUndefined();
-    expect(formatRecordLabel({ en: " " })).toBeUndefined();
-    expect(formatRecordLabel(["Task 1"])).toBeUndefined();
-  });
-});