@antelopejs/dms 0.9.2 → 0.9.4

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

@@ -1,217 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { effectScope, nextTick, reactive } from "vue";
-import { combineSaveStates } from "../layers/dms-layout/app/composables/layout/useInstantSaveHeader";
-import {
-  INSTANT_SAVE_DEBOUNCE_MS,
-  INSTANT_SAVED_STATE_MS,
-  useInstantSave,
-} from "../layers/dms-ui/app/build/composables/instant-save/useInstantSave";
-
-interface Settings extends Record<string, unknown> {
-  name: string;
-  theme: string;
-  digest: boolean;
-}
-
-/** A server that answers when told to: each save waits for `settle`. */
-function deferredServer() {
-  const calls: Array<{
-    changes: Partial<Settings>;
-    resolve: () => void;
-    reject: (error: unknown) => void;
-  }> = [];
-  const save = vi.fn(
-    (changes: Partial<Settings>) =>
-      new Promise<void>((resolve, reject) => {
-        calls.push({ changes, resolve, reject });
-      }),
-  );
-  return { calls, save };
-}
-
-async function settle(): Promise<void> {
-  for (let tick = 0; tick < 4; tick++) await nextTick();
-  await Promise.resolve();
-}
-
-function setup(save: (changes: Partial<Settings>) => Promise<void>) {
-  const values = reactive<Settings>({
-    name: "Acme",
-    theme: "light",
-    digest: true,
-  });
-  const onError = vi.fn();
-  const scope = effectScope();
-  const instant = scope.run(() =>
-    useInstantSave<Settings>({
-      read: (key) => values[key],
-      write: (key, value) => {
-        (values as Record<string, unknown>)[key] = value;
-      },
-      save,
-      onError,
-    }),
-  )!;
-  return { values, instant, onError, scope };
-}
-
-beforeEach(() => vi.useFakeTimers());
-afterEach(() => vi.useRealTimers());
-
-describe("useInstantSave", () => {
-  it("saves a pick at once, alone, and shows saving then saved", async () => {
-    const server = deferredServer();
-    const { values, instant } = setup(server.save);
-
-    instant.change("theme", "dark");
-    expect(values.theme).toBe("dark");
-    expect(server.save).toHaveBeenCalledWith({ theme: "dark" });
-    expect(instant.states.theme).toBe("saving");
-
-    server.calls[0]!.resolve();
-    await settle();
-    expect(instant.states.theme).toBe("saved");
-
-    vi.advanceTimersByTime(INSTANT_SAVED_STATE_MS);
-    expect(instant.states.theme).toBe("idle");
-  });
-
-  it("waits for typing to pause before saving text, then sends the last value", async () => {
-    const server = deferredServer();
-    const { instant } = setup(server.save);
-
-    instant.change("name", "A", { debounce: true });
-    instant.change("name", "Ac", { debounce: true });
-    vi.advanceTimersByTime(INSTANT_SAVE_DEBOUNCE_MS - 1);
-    expect(server.save).not.toHaveBeenCalled();
-
-    vi.advanceTimersByTime(1);
-    expect(server.save).toHaveBeenCalledTimes(1);
-    expect(server.save).toHaveBeenCalledWith({ name: "Ac" });
-  });
-
-  it("puts the last confirmed value back when a save fails, then retries", async () => {
-    const server = deferredServer();
-    const { values, instant, onError } = setup(server.save);
-
-    instant.change("theme", "dark");
-    const refusal = new Error("refused");
-    server.calls[0]!.reject(refusal);
-    await settle();
-
-    expect(values.theme).toBe("light");
-    expect(instant.states.theme).toBe("error");
-    expect(instant.failed.value).toEqual({ theme: "dark" });
-    expect(onError).toHaveBeenCalledWith(refusal, { theme: "dark" });
-
-    instant.retry();
-    expect(values.theme).toBe("dark");
-    expect(server.save).toHaveBeenLastCalledWith({ theme: "dark" });
-    server.calls[1]!.resolve();
-    await settle();
-    expect(instant.failed.value).toBeNull();
-    expect(instant.states.theme).toBe("saved");
-  });
-
-  it("rolls back to what the server last confirmed, not what was shown first", async () => {
-    const server = deferredServer();
-    const { values, instant } = setup(server.save);
-
-    instant.change("theme", "dark");
-    server.calls[0]!.resolve();
-    await settle();
-    instant.change("theme", "blue");
-    server.calls[1]!.reject(new Error("refused"));
-    await settle();
-
-    expect(values.theme).toBe("dark");
-  });
-
-  it("sends a change made while a save of its key runs once that one ends", async () => {
-    const server = deferredServer();
-    const { values, instant } = setup(server.save);
-
-    instant.change("theme", "dark");
-    instant.change("theme", "blue");
-    expect(server.save).toHaveBeenCalledTimes(1);
-
-    server.calls[0]!.resolve();
-    await settle();
-    expect(server.save).toHaveBeenLastCalledWith({ theme: "blue" });
-    expect(values.theme).toBe("blue");
-  });
-
-  it("keeps a newer value on screen when an older save of its key fails", async () => {
-    const server = deferredServer();
-    const { values, instant } = setup(server.save);
-
-    instant.change("theme", "dark");
-    instant.change("theme", "blue");
-    server.calls[0]!.reject(new Error("refused"));
-    await settle();
-
-    expect(values.theme).toBe("blue");
-  });
-
-  it("saves several keys in one request", () => {
-    const server = deferredServer();
-    const { instant } = setup(server.save);
-
-    instant.changeMany({ theme: "dark", digest: false });
-    expect(server.save).toHaveBeenCalledWith({ theme: "dark", digest: false });
-    expect(instant.states.theme).toBe("saving");
-    expect(instant.states.digest).toBe("saving");
-  });
-
-  it("leaves a text still being typed out of a save of several keys", () => {
-    const server = deferredServer();
-    const { instant } = setup(server.save);
-
-    instant.change("name", "Acme Inc", { debounce: true });
-    instant.changeMany({ theme: "dark" });
-    expect(server.save).toHaveBeenCalledTimes(1);
-    expect(server.save).toHaveBeenCalledWith({ theme: "dark" });
-
-    vi.advanceTimersByTime(INSTANT_SAVE_DEBOUNCE_MS);
-    expect(server.save).toHaveBeenLastCalledWith({ name: "Acme Inc" });
-  });
-
-  it("queues a value the source already shows, from the confirmed one", async () => {
-    const server = deferredServer();
-    const { values, instant } = setup(server.save);
-    instant.confirm({ name: "Acme" });
-
-    values.name = "Typed";
-    instant.queue("name", "Typed");
-    server.calls[0]!.reject(new Error("refused"));
-    await settle();
-
-    expect(values.name).toBe("Acme");
-  });
-
-  it("sends a pending change at once when flushed", () => {
-    const server = deferredServer();
-    const { instant } = setup(server.save);
-
-    instant.change("name", "Acme Inc", { debounce: true });
-    void instant.flush();
-    expect(server.save).toHaveBeenCalledWith({ name: "Acme Inc" });
-  });
-
-  it("drops a pending change once cancelled", () => {
-    const server = deferredServer();
-    const { instant } = setup(server.save);
-
-    instant.change("name", "Acme Inc", { debounce: true });
-    instant.cancel("name");
-    vi.advanceTimersByTime(INSTANT_SAVE_DEBOUNCE_MS);
-    expect(server.save).not.toHaveBeenCalled();
-  });
-
-  it("reads one state for the page: saving, then error, then saved", () => {
-    expect(combineSaveStates(["saved", "error", "saving"])).toBe("saving");
-    expect(combineSaveStates(["saved", "error", "idle"])).toBe("error");
-    expect(combineSaveStates(["idle", "saved", undefined])).toBe("saved");
-    expect(combineSaveStates([])).toBe("idle");
-  });
-});

package/frontend-vue/tests/invites-edit-modal.test.ts

@@ -1,157 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { ref } from "vue";
-import { createI18n } from "vue-i18n";
-import { Color } from "../layers/dms-core/app/types/color";
-import { HttpMethod } from "../layers/dms-core/app/types/http";
-import { normalizeActionConfig } from "../layers/dms-core/app/utils/row-action-rule-evaluator";
-import { interpolateUrl } from "../layers/dms-core/app/utils/url-interpolation";
-import { useTranslation } from "../layers/dms-core/app/composables/translation/useTranslation";
-import { useEventedAction } from "../layers/dms-core/app/composables/useEventedAction";
-import core from "../layers/dms-core/i18n/locales/core-en-GB.json";
-import ui from "../layers/dms-ui/i18n/locales/ui-en-GB.json";
-import layout from "../layers/dms-layout/i18n/locales/layout-en-GB.json";
-
-vi.mock("../layers/dms-ui/app/components/form/Form.vue", () => ({
-  default: { name: "DmsForm" },
-}));
-
-type Messages = Record<string, unknown>;
-const merge = (target: Messages, source: Messages): Messages => {
-  for (const [key, value] of Object.entries(source)) {
-    const current = target[key];
-    target[key] =
-      current && typeof current === "object" && typeof value === "object"
-        ? merge({ ...(current as Messages) }, value as Messages)
-        : value;
-  }
-  return target;
-};
-
-const i18n = createI18n({
-  legacy: false,
-  locale: "en",
-  missingWarn: false,
-  fallbackWarn: false,
-  messages: { en: merge(merge(merge({}, core), ui), layout) as never },
-});
-const t = i18n.global.t as (...args: unknown[]) => string;
-
-const INVITE = { _id: "invite-1", email: "zz-invitee@example.com" };
-const INVITES_PAGE = "/settings/workspace/invites";
-
-const modal = { close: vi.fn() };
-const openModal = vi.fn(() => modal);
-const navigateDms = vi.fn();
-const refresh = vi.fn();
-
-/**
- * The row actions of the invitations table, configured as the server
- * serializes it: the edit form opens in a medium modal under the
- * "Edit invitation" texts, and no form page URL is handed down.
- */
-async function invitesRowActions() {
-  const { useTableRowActions } = await import(
-    "../layers/dms-ui/app/build/composables/table-view/useTableViewRowActions"
-  );
-  return useTableRowActions({
-    api: vi.fn() as never,
-    location: "/api/tables/admin-invites",
-    componentId: "table",
-    pageId: "settings.workspace.invites",
-    labelKey: "email",
-    formContainer: {
-      type: "modal",
-      size: "md",
-      pages: {
-        edit: {
-          displayName: "$page.settings.invites.form.edit_title",
-          description: "$page.settings.invites.form.edit_description",
-        },
-      },
-    } as never,
-    formComponents: {
-      edit: {
-        componentName: "DmsForm",
-        options: {
-          fields: [],
-          fetchUrl: "/api/tables/admin-invites/get?id={{params.id}}",
-          submitUrl: "/api/tables/admin-invites/edit?id={{params.id}}",
-        },
-      } as never,
-    },
-    refreshCallback: refresh,
-  });
-}
-
-beforeEach(() => {
-  const globals: Record<string, unknown> = {
-    ref,
-    Color,
-    HttpMethod,
-    normalizeActionConfig,
-    interpolateUrl,
-    useTranslation,
-    useEventedAction,
-    useI18n: () => ({ t, locale: ref("en") }),
-    useToast: () => ({ add: vi.fn() }),
-    useConfirm: () => ({ confirm: vi.fn() }),
-    useAuthFetch: () => ({ $authFetch: vi.fn() }),
-    useModal: () => ({ open: openModal }),
-    useDrawer: () => ({ open: vi.fn() }),
-    useDmsRoute: () => ({ query: {}, path: INVITES_PAGE }),
-    useExportJob: () => ({ runJob: vi.fn() }),
-    useComponentEvent: () => ({ sendComponentEvent: vi.fn() }),
-    navigateDms,
-    resolveDmsComponent: vi.fn(),
-  };
-  for (const [name, value] of Object.entries(globals)) {
-    vi.stubGlobal(name, value);
-  }
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.clearAllMocks();
-});
-
-describe("Invitations table: Edit invitation", () => {
-  it("opens the form in a modal over the list, not on a page", async () => {
-    const { editRow } = await invitesRowActions();
-    await editRow(INVITE);
-
-    expect(navigateDms).not.toHaveBeenCalled();
-    expect(openModal).toHaveBeenCalledTimes(1);
-    const [opened] = openModal.mock.calls[0] as unknown as [
-      {
-        title: string;
-        description: string;
-        size: string;
-        componentOptions: Record<string, unknown>;
-      },
-    ];
-    expect(opened.title).toBe("Edit invitation · zz-invitee@example.com");
-    expect(opened.description).toBe(
-      "The name, roles and language the invitee gets on accepting.",
-    );
-    expect(opened.size).toBe("md");
-    expect(opened.componentOptions.fetchUrl).toBe(
-      "/api/tables/admin-invites/get?id=invite-1",
-    );
-    expect(opened.componentOptions.submitUrl).toBe(
-      "/api/tables/admin-invites/edit?id=invite-1",
-    );
-  });
-
-  it("closes the modal and refreshes the list once saved", async () => {
-    const { editRow } = await invitesRowActions();
-    await editRow(INVITE);
-
-    const [opened] = openModal.mock.calls[0] as unknown as [
-      { componentOptions: { onSuccessCallback: () => void } },
-    ];
-    opened.componentOptions.onSuccessCallback();
-
-    expect(modal.close).toHaveBeenCalledTimes(1);
-    expect(refresh).toHaveBeenCalledTimes(1);
-  });
-});

package/frontend-vue/tests/key-value-list-copy.test.ts

@@ -1,117 +0,0 @@
-// @vitest-environment jsdom
-/**
- * A KeyValueList row with `copy` draws a copy button next to its value, from
- * static items as from the items a `fetchUrl` answers; `copyValue` copies
- * another text than the one shown.
- */
-import { createApp, defineComponent, h, reactive, ref } from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { useRealDataEngine } from "./fixtures/dataEngine";
-import { createI18n } from "vue-i18n";
-
-const i18n = createI18n({
-  legacy: false,
-  locale: "en",
-  missingWarn: false,
-  fallbackWarn: false,
-  messages: { en: { dms: { button: { copy: "Copy", copied: "Copied" } } } },
-});
-
-const copied: string[] = [];
-
-// jsdom has no clipboard: the button's copy lands in `copied` instead.
-vi.mock("@vueuse/core", async (importOriginal) => ({
-  ...(await importOriginal<typeof import("@vueuse/core")>()),
-  useClipboard: () => ({
-    copy: async (text: string) => {
-      copied.push(text);
-    },
-    copied: ref(false),
-  }),
-}));
-
-let fetchedItems: unknown[] = [];
-
-vi.stubGlobal("useAuthFetch", () => ({
-  $authFetch: async () => ({ items: fetchedItems }),
-}));
-vi.stubGlobal("useDmsRoute", () => reactive({ query: {} }));
-
-vi.mock("../layers/dms-core/app/composables/watch/useWatch", () => ({
-  useWatch: () => ({ state: ref({}) }),
-}));
-vi.mock(
-  "../layers/dms-core/app/composables/components/useComponentEvent",
-  () => ({ useComponentEvent: () => ({}) }),
-);
-
-const KeyValueListBlock = (
-  await import("../layers/dms-ui/app/components/blocks/KeyValueListBlock.vue")
-).default;
-
-const SETTLE_MS = 50;
-const settle = () => new Promise((resolve) => setTimeout(resolve, SETTLE_MS));
-const mounted: Array<{ unmount: () => void }> = [];
-
-function render(props: Record<string, unknown>): HTMLElement {
-  const root = document.createElement("div");
-  const app = createApp(KeyValueListBlock, { card: false, ...props });
-  app.component("UIcon", defineComponent({ render: () => h("i") }));
-  app.component("USkeleton", defineComponent({ render: () => h("span") }));
-  app.mount(root);
-  mounted.push(app);
-  return root;
-}
-
-function copyButtons(root: HTMLElement): HTMLButtonElement[] {
-  return [...root.querySelectorAll<HTMLButtonElement>("button[title]")];
-}
-
-beforeEach(() => useRealDataEngine());
-
-beforeEach(() => {
-  fetchedItems = [];
-  copied.splice(0);
-  vi.stubGlobal("useI18n", () => ({
-    t: i18n.global.t,
-    locale: i18n.global.locale,
-  }));
-});
-
-afterEach(() => {
-  mounted.splice(0).forEach((app) => app.unmount());
-});
-
-describe("KeyValueList copy button", () => {
-  it("copies the shown value of a row that asks for it, and only those", async () => {
-    const root = render({
-      items: [
-        { label: "Endpoint", value: "https://api.example.com", copy: true },
-        { label: "Plan", value: "Business" },
-        { label: "Token", value: null, copy: true },
-      ],
-    });
-
-    const buttons = copyButtons(root);
-    expect(buttons).toHaveLength(1);
-    buttons[0]!.click();
-    await settle();
-    expect(copied).toEqual(["https://api.example.com"]);
-  });
-
-  it("copies copyValue rather than the shown text, from fetched items", async () => {
-    fetchedItems = [
-      {
-        label: "Thumbnail",
-        value: "thumb.webp",
-        copyValue: "https://cdn.example.com/media/42/thumb.webp",
-      },
-    ];
-    const root = render({ fetchUrl: "/api/media/42/urls" });
-    await settle();
-
-    copyButtons(root)[0]!.click();
-    await settle();
-    expect(copied).toEqual(["https://cdn.example.com/media/42/thumb.webp"]);
-  });
-});

package/frontend-vue/tests/key-value-rows.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  keyValueObject,
-  keyValueProblem,
-  keyValueRows,
-} from "../layers/dms-ui/app/build/composables/form/keyValueRows";
-
-describe("key-value rows", () => {
-  it("reads an object as rows, and back", () => {
-    const value = { Accept: "*/*", "X-Trace": "on" };
-    const rows = keyValueRows(value, false);
-    expect(rows).toEqual([
-      { key: "Accept", value: "*/*" },
-      { key: "X-Trace", value: "on" },
-    ]);
-    expect(keyValueObject(rows, false)).toEqual(value);
-  });
-
-  it("reads and writes { value, enabled } when toggleable", () => {
-    const value = { retries: { value: 3, enabled: false } };
-    const rows = keyValueRows(value, true);
-    expect(rows).toEqual([{ key: "retries", value: 3, enabled: false }]);
-    expect(keyValueObject(rows, true)).toEqual(value);
-    expect(keyValueObject([{ key: "new" }], true)).toEqual({
-      new: { value: null, enabled: true },
-    });
-  });
-
-  it("drops the rows nobody filled, and trims the names", () => {
-    expect(keyValueObject([{}, { key: " a ", value: "1" }], false)).toEqual({
-      a: "1",
-    });
-  });
-
-  it("says when a value has no name, or a name comes twice", () => {
-    expect(keyValueProblem([{ key: "", value: "x" }])).toBe(
-      "$dms.field_errors.key_missing",
-    );
-    expect(
-      keyValueProblem([
-        { key: "a", value: "1" },
-        { key: "a ", value: "2" },
-      ]),
-    ).toBe("$dms.field_errors.key_duplicate");
-    expect(keyValueProblem([{}, { key: "a", value: "1" }])).toBeUndefined();
-  });
-
-  it("reads nothing as no rows", () => {
-    expect(keyValueRows(null, false)).toEqual([]);
-    expect(keyValueRows(undefined, true)).toEqual([]);
-  });
-});

package/frontend-vue/tests/keyboard-platform.test.ts

@@ -1,87 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  DEFAULT_KEYBOARD_PLATFORM,
-  detectKeyboardPlatform,
-  formatKeyboardShortcut,
-  keyboardKeyLabel,
-} from "../layers/dms-ui/app/composables/global/keyboardPlatform";
-import { PAGE_SEARCH_HINT_KEYS } from "../layers/dms-ui/app/build/composables/global/searchShortcuts";
-
-const MAC_UA =
-  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36";
-const WINDOWS_UA =
-  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36";
-const IPHONE_UA =
-  "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1";
-
-describe("detectKeyboardPlatform", () => {
-  it.each([
-    ["client hint macOS", { userAgentData: { platform: "macOS" } }, "mac"],
-    [
-      "client hint Windows",
-      { userAgentData: { platform: "Windows" } },
-      "other",
-    ],
-    ["client hint Linux", { userAgentData: { platform: "Linux" } }, "other"],
-    ["platform MacIntel", { platform: "MacIntel" }, "mac"],
-    ["platform iPhone", { platform: "iPhone" }, "mac"],
-    ["platform iPad", { platform: "iPad" }, "mac"],
-    ["platform Win32", { platform: "Win32" }, "other"],
-    ["platform Linux x86_64", { platform: "Linux x86_64" }, "other"],
-    ["mac user agent only", { userAgent: MAC_UA }, "mac"],
-    ["iPhone user agent only", { userAgent: IPHONE_UA }, "mac"],
-    ["windows user agent only", { userAgent: WINDOWS_UA }, "other"],
-  ] as const)("reads %s", (_case, navigator, expected) => {
-    expect(detectKeyboardPlatform(navigator)).toBe(expected);
-  });
-
-  it("prefers the client hint over the legacy platform", () => {
-    expect(
-      detectKeyboardPlatform({
-        userAgentData: { platform: "Windows" },
-        platform: "MacIntel",
-      }),
-    ).toBe("other");
-  });
-
-  it("falls back to the server default without a navigator", () => {
-    expect(detectKeyboardPlatform(undefined)).toBe(DEFAULT_KEYBOARD_PLATFORM);
-    expect(DEFAULT_KEYBOARD_PLATFORM).toBe("other");
-  });
-});
-
-describe("keyboard labels", () => {
-  it("prints meta as ⌘ on macOS and Ctrl elsewhere", () => {
-    expect(keyboardKeyLabel("meta", "mac")).toBe("⌘");
-    expect(keyboardKeyLabel("meta", "other")).toBe("Ctrl");
-  });
-
-  it("prints the other modifiers per platform", () => {
-    expect(keyboardKeyLabel("shift", "mac")).toBe("⇧");
-    expect(keyboardKeyLabel("alt", "mac")).toBe("⌥");
-    expect(keyboardKeyLabel("alt", "other")).toBe("Alt");
-  });
-
-  it("uppercases letters and keeps unknown key names", () => {
-    expect(keyboardKeyLabel("k", "mac")).toBe("K");
-    expect(keyboardKeyLabel("/", "other")).toBe("/");
-    expect(keyboardKeyLabel("letter_placeholder", "other")).toBe(
-      "letter_placeholder",
-    );
-  });
-
-  it("runs a mac combination together and spaces a PC one", () => {
-    expect(formatKeyboardShortcut(["meta", "k"], "mac")).toBe("⌘K");
-    expect(formatKeyboardShortcut(["meta", "k"], "other")).toBe("Ctrl K");
-    expect(formatKeyboardShortcut(["meta", "v"], "other")).toBe("Ctrl V");
-  });
-
-  it("prints the page search hint as ⌘ / or Ctrl /", () => {
-    expect(
-      PAGE_SEARCH_HINT_KEYS.map((k) => keyboardKeyLabel(k, "mac")),
-    ).toEqual(["⌘", "/"]);
-    expect(
-      PAGE_SEARCH_HINT_KEYS.map((k) => keyboardKeyLabel(k, "other")),
-    ).toEqual(["Ctrl", "/"]);
-  });
-});