@antelopejs/dms 0.9.2 → 0.9.4

package/frontend-vue/tests/notification-popover-errors.test.ts

@@ -1,320 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import {
-  computed,
-  createApp,
-  defineComponent,
-  h,
-  nextTick,
-  onMounted,
-  onUnmounted,
-  ref,
-  watch,
-  type App,
-  type Ref,
-} from "vue";
-import NotificationPopover from "../layers/dms-layout/app/build/components/notification/NotificationPopover.vue";
-
-const HTTP_FORBIDDEN = 403;
-const UNREAD_COUNT = 4;
-const NOTIFICATIONS_PAGE = "settings.user.notifications";
-
-interface NotificationsStub {
-  unreadCount: Ref<number>;
-  unreadTone: Ref<string | undefined>;
-  areCountsLoaded: Ref<boolean>;
-  notifications: Ref<unknown[]>;
-  fetchBellCounts: ReturnType<typeof vi.fn>;
-  fetchNotifications: ReturnType<typeof vi.fn>;
-  markAsRead: ReturnType<typeof vi.fn>;
-}
-
-const UNREAD_NOTIFICATION = {
-  _id: "n1",
-  userId: "u1",
-  icon: "i-ph-bell",
-  title: "Hello",
-  description: "World",
-  params: null,
-  linkTo: null,
-  isRead: false,
-  categoryId: "system",
-  subjectId: "general",
-  createdAt: "2026-10-02T10:00:00.000Z",
-  updatedAt: "2026-10-02T10:00:00.000Z",
-};
-
-let app: App;
-let host: HTMLDivElement;
-let errorHandler: ReturnType<typeof vi.fn>;
-let notifications: NotificationsStub;
-let state: Map<string, Ref<unknown>>;
-
-function forbidden(): Promise<never> {
-  return Promise.reject(
-    Object.assign(new Error("tenant.suspended"), {
-      response: { status: HTTP_FORBIDDEN },
-    }),
-  );
-}
-
-const Popover = defineComponent({
-  props: { open: { type: Boolean, default: false } },
-  emits: ["update:open"],
-  setup:
-    (props, { emit, slots }) =>
-    () =>
-      h("div", [
-        h(
-          "div",
-          { "data-trigger": "", onClick: () => emit("update:open", true) },
-          slots.default?.(),
-        ),
-        h("button", {
-          "data-close": "",
-          onClick: () => emit("update:open", false),
-        }),
-        props.open ? slots.content?.() : null,
-      ]),
-});
-
-const Card = defineComponent({
-  setup:
-    (_, { slots }) =>
-    () =>
-      h("div", { "data-card": "" }, slots.default?.()),
-});
-
-const Passthrough = defineComponent({
-  setup:
-    (_, { slots }) =>
-    () =>
-      h("div", slots.default?.()),
-});
-
-function installRuntime(): void {
-  Object.entries({
-    ref,
-    computed,
-    watch,
-    nextTick,
-    onMounted,
-    onUnmounted,
-  }).forEach(([key, value]) => vi.stubGlobal(key, value));
-  vi.stubGlobal("useDmsState", (key: string, init: () => unknown) => {
-    if (!state.has(key)) state.set(key, ref(init()));
-    return state.get(key);
-  });
-  vi.stubGlobal("useI18n", () => ({ t: (key: string) => key, locale: "en" }));
-  vi.stubGlobal("useDmsUserSession", () => ({ loggedIn: ref(true) }));
-  vi.stubGlobal("useTranslation", () => ({
-    processI18n: (value: string) => value,
-  }));
-  vi.stubGlobal("useNotifications", () => ({
-    ...notifications,
-    hasMore: ref(false),
-  }));
-  vi.stubGlobal("useInfiniteScroll", () => ({
-    isLoadingMore: ref(false),
-    setupObserver: vi.fn(),
-    disconnectObserver: vi.fn(),
-  }));
-  vi.stubGlobal("NotificationEvents", { NOTIFICATION_RECEIVED: "received" });
-  vi.stubGlobal("FormEvents", { SUBMIT_SUCCESS: "submit-success" });
-  vi.stubGlobal("navigateDms", vi.fn());
-}
-
-async function mountPopover(): Promise<void> {
-  app = createApp(NotificationPopover);
-  app.config.errorHandler = errorHandler;
-  app.config.globalProperties.$t = (key: string) => key;
-  app.component("UPopover", Popover);
-  app.component("UButton", Passthrough);
-  app.component("USeparator", Passthrough);
-  app.component("UIcon", Passthrough);
-  app.component("UCard", Card);
-  app.mount(host);
-  await vi.waitFor(() =>
-    expect(notifications.fetchBellCounts).toHaveBeenCalled(),
-  );
-  await nextTick();
-}
-
-async function openPopover(): Promise<void> {
-  host.querySelector<HTMLElement>("[data-trigger]")!.click();
-  await vi.waitFor(() =>
-    expect(notifications.fetchNotifications).toHaveBeenCalled(),
-  );
-  await nextTick();
-}
-
-async function closePopover(): Promise<void> {
-  host.querySelector<HTMLElement>("[data-close]")!.click();
-  await nextTick();
-  await nextTick();
-}
-
-function badge(): HTMLElement | null {
-  return host.querySelector("[data-bell-badge]");
-}
-
-function badgeText(): string {
-  return badge()?.textContent?.trim() ?? "";
-}
-
-/** The badge the bell keeps on the Notifications entry of the navigation. */
-function menuBadge(): unknown {
-  const badges = state.get("dms-nav-badges")?.value as
-    | Record<string, unknown>
-    | undefined;
-  return badges?.[NOTIFICATIONS_PAGE];
-}
-
-beforeEach(() => {
-  errorHandler = vi.fn();
-  state = new Map();
-  notifications = {
-    unreadCount: ref(0),
-    unreadTone: ref(undefined),
-    // Not read with the page (signed in since the app started): the bell
-    // reads them once mounted.
-    areCountsLoaded: ref(false),
-    notifications: ref([]),
-    fetchBellCounts: vi.fn(),
-    fetchNotifications: vi.fn(),
-    markAsRead: vi.fn(),
-  };
-  vi.spyOn(console, "warn").mockImplementation(() => {});
-  installRuntime();
-  host = document.createElement("div");
-});
-
-afterEach(() => {
-  app?.unmount();
-  vi.unstubAllGlobals();
-  vi.restoreAllMocks();
-});
-
-it("badges every unread notification, in the tone of the most important", async () => {
-  notifications.fetchBellCounts.mockImplementation(async () => {
-    notifications.unreadCount.value = UNREAD_COUNT;
-    notifications.unreadTone.value = "error";
-  });
-  await mountPopover();
-  expect(badgeText()).toBe(String(UNREAD_COUNT));
-  expect(badge()!.className).toContain("bg-(--ui-color-error-500) text-white");
-});
-
-it("shows the same count and tone as the Notifications entry", async () => {
-  notifications.fetchBellCounts.mockImplementation(async () => {
-    notifications.unreadCount.value = UNREAD_COUNT;
-    notifications.unreadTone.value = "warning";
-  });
-  await mountPopover();
-  expect(menuBadge()).toEqual({ label: String(UNREAD_COUNT), tone: "warning" });
-  expect(badge()!.className).toContain("bg-(--ui-color-warning-400)");
-
-  // A new unread error turns both red.
-  notifications.unreadCount.value = UNREAD_COUNT + 1;
-  notifications.unreadTone.value = "error";
-  await nextTick();
-  expect(badgeText()).toBe(String(UNREAD_COUNT + 1));
-  expect(badge()!.className).toContain("bg-(--ui-color-error-500)");
-  expect(menuBadge()).toEqual({
-    label: String(UNREAD_COUNT + 1),
-    tone: "error",
-  });
-});
-
-it("draws an untoned count in the accent, and hides the badge at zero", async () => {
-  notifications.fetchBellCounts.mockImplementation(async () => {
-    notifications.unreadCount.value = 1;
-    notifications.unreadTone.value = "primary";
-  });
-  await mountPopover();
-  expect(badge()!.className).toContain("bg-(--dms-accent-fill)");
-
-  notifications.unreadCount.value = 0;
-  notifications.unreadTone.value = undefined;
-  await nextTick();
-  expect(badge()).toBeNull();
-  expect(menuBadge()).toEqual({ label: "" });
-});
-
-it("hides the badge instead of failing the page when the count is refused", async () => {
-  notifications.unreadCount.value = UNREAD_COUNT;
-  notifications.unreadTone.value = "error";
-  notifications.fetchBellCounts.mockImplementation(forbidden);
-  await mountPopover();
-  await vi.waitFor(() => expect(console.warn).toHaveBeenCalled());
-  expect(errorHandler).not.toHaveBeenCalled();
-  expect(notifications.unreadCount.value).toBe(0);
-  expect(notifications.unreadTone.value).toBeUndefined();
-  expect(badgeText()).toBe("");
-});
-
-it("keeps the count when opened and closed: opening marks nothing", async () => {
-  const sendBeacon = vi.fn();
-  vi.stubGlobal("navigator", { sendBeacon });
-  notifications.unreadCount.value = UNREAD_COUNT;
-  notifications.unreadTone.value = "warning";
-  notifications.notifications.value = [UNREAD_NOTIFICATION];
-  await mountPopover();
-
-  await openPopover();
-  expect(badgeText()).toBe(String(UNREAD_COUNT));
-  expect(host.querySelector(".bg-primary")).not.toBeNull();
-
-  await closePopover();
-  window.dispatchEvent(new Event("beforeunload"));
-  expect(notifications.markAsRead).not.toHaveBeenCalled();
-  expect(sendBeacon).not.toHaveBeenCalled();
-  expect(notifications.unreadCount.value).toBe(UNREAD_COUNT);
-  expect(badgeText()).toBe(String(UNREAD_COUNT));
-});
-
-it("marks a notification read when it is clicked", async () => {
-  notifications.notifications.value = [UNREAD_NOTIFICATION];
-  await mountPopover();
-  await openPopover();
-  host.querySelector<HTMLElement>("[data-card]")!.click();
-  await vi.waitFor(() =>
-    expect(notifications.markAsRead).toHaveBeenCalledWith("n1"),
-  );
-});
-
-it("does not mark an already read notification again", async () => {
-  notifications.notifications.value = [
-    { ...UNREAD_NOTIFICATION, isRead: true },
-  ];
-  await mountPopover();
-  await openPopover();
-  host.querySelector<HTMLElement>("[data-card]")!.click();
-  await nextTick();
-  expect(notifications.markAsRead).not.toHaveBeenCalled();
-});
-
-it("keeps the page alive when the notification list is refused on open", async () => {
-  notifications.fetchNotifications.mockImplementation(forbidden);
-  await mountPopover();
-  await openPopover();
-  await vi.waitFor(() => expect(console.warn).toHaveBeenCalled());
-  expect(errorHandler).not.toHaveBeenCalled();
-  expect(host.textContent).toContain("notification.dropdown.no_notifications");
-});
-
-it("does not read the counts again when the page brought them", async () => {
-  notifications.areCountsLoaded.value = true;
-  notifications.unreadCount.value = 2;
-  app = createApp(NotificationPopover);
-  app.config.globalProperties.$t = (key: string) => key;
-  for (const name of ["UButton", "USeparator", "UIcon"])
-    app.component(name, Passthrough);
-  app.component("UPopover", Popover);
-  app.component("UCard", Card);
-  app.mount(host);
-  await nextTick();
-  await new Promise((done) => setTimeout(done, 0));
-  expect(notifications.fetchBellCounts).not.toHaveBeenCalled();
-  expect(host.textContent).toContain("2");
-});

package/frontend-vue/tests/notification-preferences-groups.test.ts

@@ -1,268 +0,0 @@
-// @vitest-environment jsdom
-import {
-  computed,
-  createApp,
-  defineComponent,
-  h,
-  nextTick,
-  onMounted,
-  ref,
-  type App,
-  type Component,
-} from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import NotificationPreferencesForm from "../layers/dms-layout/app/build/components/pages/settings/notification/NotificationPreferencesForm.vue";
-import { NOTIFICATION_GROUP_STORAGE_PREFIX } from "../layers/dms-layout/app/build/composables/notification/useNotificationGroupsOpen";
-
-const preferences = vi.hoisted(() => ({
-  toggleCategory: vi.fn(),
-  toggleSubject: vi.fn(),
-}));
-
-vi.mock(
-  "../layers/dms-layout/app/build/composables/notification/useNotificationPreferences",
-  async () => {
-    const vue = await import("vue");
-    const system = { id: "system", labelKey: "System", icon: "i-ph-gear" };
-    const security = {
-      id: "security",
-      labelKey: "Security",
-      icon: "i-ph-shield",
-    };
-    const subjects = {
-      system: [
-        { id: "general", category: system, labelKey: "General" },
-        { id: "account", category: system, labelKey: "Account" },
-      ],
-      security: [
-        { id: "alerts", category: security, labelKey: "Security alerts" },
-      ],
-    } as Record<string, { id: string; labelKey: string }[]>;
-    return {
-      useNotificationPreferences: () => ({
-        ...preferences,
-        categories: vue.ref([system, security]),
-        subjectsOf: (id: string) => subjects[id] ?? [],
-        failedChanges: vue.ref(undefined),
-        saveState: vue.ref("idle"),
-        isLoading: vue.ref(false),
-        loadFailed: vue.ref(false),
-        isEnabled: () => true,
-        rowState: () => "idle",
-        toggleableSubjectsOf: (category: { id: string }) =>
-          subjects[category.id] ?? [],
-        retry: vi.fn(),
-        load: vi.fn(),
-      }),
-    };
-  },
-);
-
-vi.mock(
-  "../layers/dms-layout/app/composables/layout/useInstantSaveHeader",
-  () => ({
-    useInstantSaveHeader: vi.fn(),
-  }),
-);
-
-vi.mock("#dms-ui/app/build/components/skeleton/RowSkeleton.vue", async () => {
-  const vue = await import("vue");
-  return { default: vue.defineComponent({ render: () => vue.h("span") }) };
-});
-
-let app: App | undefined;
-
-function mount(component: Component) {
-  app = createApp(defineComponent({ setup: () => () => h(component) }));
-  const passThrough = defineComponent({
-    setup:
-      (_props, { slots }) =>
-      () =>
-        h("div", [slots.default?.(), slots.footer?.()]),
-  });
-  for (const [name, stub] of Object.entries({
-    DmsSection: passThrough,
-    DmsEmptyState: passThrough,
-    DmsIconWell: defineComponent({ render: () => h("span") }),
-    UBadge: defineComponent({ render: () => h("span") }),
-    UIcon: defineComponent({ render: () => h("span") }),
-    // Attributes (aria-*) fall through to the native button.
-    UButton: defineComponent({
-      props: { label: String, icon: String },
-      emits: ["click"],
-      setup:
-        (props, { emit }) =>
-        () =>
-          h(
-            "button",
-            {
-              type: "button",
-              "data-icon": props.icon,
-              onClick: () => emit("click"),
-            },
-            props.label,
-          ),
-    }),
-    USwitch: defineComponent({
-      props: { modelValue: Boolean, disabled: Boolean },
-      emits: ["update:modelValue"],
-      setup:
-        (props, { emit }) =>
-        () =>
-          h("button", {
-            type: "button",
-            role: "switch",
-            "aria-checked": String(props.modelValue),
-            onClick: () => emit("update:modelValue", !props.modelValue),
-          }),
-    }),
-    // Shows its content while open, as Reka's collapsible does.
-    UCollapsible: defineComponent({
-      props: { open: Boolean },
-      setup:
-        (props, { slots }) =>
-        () =>
-          h("div", props.open ? slots.content?.() : []),
-    }),
-  })) {
-    app.component(name, stub);
-  }
-  const container = document.createElement("div");
-  document.body.append(container);
-  app.mount(container);
-  return container;
-}
-
-const chevronOf = (container: HTMLElement, categoryId: string) =>
-  container.querySelector<HTMLButtonElement>(
-    `button[aria-controls="notification-category-subjects-${categoryId}"]`,
-  )!;
-
-const subjectNames = (container: HTMLElement) =>
-  [...container.querySelectorAll('[role="rowgroup"] [role="rowheader"]')].map(
-    (cell) => cell.textContent?.trim(),
-  );
-
-const rowOf = (container: HTMLElement, categoryId: string) =>
-  chevronOf(container, categoryId).closest<HTMLElement>('[role="row"]')!;
-
-beforeEach(() => {
-  localStorage.clear();
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("ref", ref);
-  vi.stubGlobal("onMounted", onMounted);
-  vi.stubGlobal("useI18n", () => ({
-    t: (key: string, params?: Record<string, unknown>) =>
-      params?.name ? `${key}:${String(params.name)}` : key,
-  }));
-});
-
-afterEach(() => {
-  app?.unmount();
-  app = undefined;
-  document.body.innerHTML = "";
-  vi.unstubAllGlobals();
-  vi.clearAllMocks();
-});
-
-describe("notification preferences groups", () => {
-  it("starts every group folded, with its count on the group row", () => {
-    const container = mount(NotificationPreferencesForm as Component);
-
-    expect(subjectNames(container)).toEqual([]);
-    const chevron = chevronOf(container, "system");
-    expect(chevron.getAttribute("aria-expanded")).toBe("false");
-    expect(chevron.getAttribute("aria-label")).toBe(
-      "page.settings.notifications.category_expand:System",
-    );
-    expect(chevron.dataset.icon).toBe("i-ph-caret-right");
-    expect(rowOf(container, "system").textContent).toContain(
-      "page.settings.notifications.category_count",
-    );
-  });
-
-  it("unfolds and folds a group's subjects from its chevron", async () => {
-    const container = mount(NotificationPreferencesForm as Component);
-    const chevron = chevronOf(container, "system");
-
-    chevron.click();
-    await nextTick();
-    expect(chevron.getAttribute("aria-expanded")).toBe("true");
-    expect(chevron.dataset.icon).toBe("i-ph-caret-down");
-    expect(chevron.getAttribute("aria-label")).toBe(
-      "page.settings.notifications.category_collapse:System",
-    );
-    expect(subjectNames(container)).toEqual(["General", "Account"]);
-    expect(
-      container.querySelector("#notification-category-subjects-system"),
-    ).not.toBeNull();
-
-    chevron.click();
-    await nextTick();
-    expect(subjectNames(container)).toEqual([]);
-  });
-
-  it("unfolds a group from its title area too", async () => {
-    const container = mount(NotificationPreferencesForm as Component);
-
-    rowOf(container, "security")
-      .querySelector<HTMLElement>("[data-category-title]")!
-      .click();
-    await nextTick();
-    expect(subjectNames(container)).toEqual(["Security alerts"]);
-  });
-
-  it("keeps the master switch working on a folded group without unfolding it", async () => {
-    const container = mount(NotificationPreferencesForm as Component);
-
-    rowOf(container, "system")
-      .querySelector<HTMLButtonElement>('[role="switch"]')!
-      .click();
-    await nextTick();
-
-    expect(preferences.toggleCategory).toHaveBeenCalledWith(
-      expect.objectContaining({ id: "system" }),
-      false,
-    );
-    expect(chevronOf(container, "system").getAttribute("aria-expanded")).toBe(
-      "false",
-    );
-    expect(subjectNames(container)).toEqual([]);
-  });
-
-  it("remembers the open groups in the browser", async () => {
-    const first = mount(NotificationPreferencesForm as Component);
-    chevronOf(first, "security").click();
-    await nextTick();
-    expect(
-      localStorage.getItem(`${NOTIFICATION_GROUP_STORAGE_PREFIX}security`),
-    ).toBe("open");
-    app?.unmount();
-    document.body.innerHTML = "";
-
-    const second = mount(NotificationPreferencesForm as Component);
-    expect(chevronOf(second, "security").getAttribute("aria-expanded")).toBe(
-      "true",
-    );
-    expect(chevronOf(second, "system").getAttribute("aria-expanded")).toBe(
-      "false",
-    );
-    expect(subjectNames(second)).toEqual(["Security alerts"]);
-  });
-
-  it("folds every group when the browser storage is unavailable", async () => {
-    vi.spyOn(Storage.prototype, "getItem").mockImplementation(() => {
-      throw new Error("blocked");
-    });
-    vi.spyOn(Storage.prototype, "setItem").mockImplementation(() => {
-      throw new Error("blocked");
-    });
-    const container = mount(NotificationPreferencesForm as Component);
-    expect(subjectNames(container)).toEqual([]);
-
-    chevronOf(container, "system").click();
-    await nextTick();
-    expect(subjectNames(container)).toEqual(["General", "Account"]);
-    vi.restoreAllMocks();
-  });
-});

package/frontend-vue/tests/notification-tone-contract.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveNotificationTone as resolveOnServer } from "../../src/utils/notification-tones";
-import {
-  resolveNotificationTone as resolveInInbox,
-  unreadToneWith,
-} from "../layers/dms-layout/app/build/components/pages/settings/notification/notificationDisplay";
-import type {
-  NotificationTone,
-  UserNotification,
-} from "../layers/dms-layout/app/composables/notification/useNotifications";
-
-// The server weighs the unread badge (the bell, the Notifications entry) with
-// the tone the inbox draws each notification in: the two never disagree.
-
-const STORED_TONES: Array<NotificationTone | null> = [
-  null,
-  "neutral",
-  "primary",
-  "success",
-  "warning",
-  "error",
-];
-
-const row = (
-  tone: NotificationTone | null,
-  isRead: boolean,
-): UserNotification => ({
-  _id: "n1",
-  userId: "u1",
-  icon: "i-ph-bell",
-  title: "",
-  description: "",
-  params: null,
-  linkTo: null,
-  isRead,
-  categoryId: "system",
-  tone,
-  createdAt: "2026-10-09T10:00:00.000Z",
-  updatedAt: "2026-10-09T10:00:00.000Z",
-});
-
-it("resolves every stored tone, read or not, as the server does", () => {
-  for (const tone of STORED_TONES) {
-    for (const isRead of [false, true]) {
-      expect(resolveInInbox(row(tone, isRead)), `${tone}/${isRead}`).toBe(
-        resolveOnServer(tone, isRead),
-      );
-    }
-  }
-});
-
-it("draws an untoned unread notification in primary", () => {
-  expect(resolveInInbox(row(null, false))).toBe("primary");
-});
-
-describe("the unread badge's tone when a notification arrives", () => {
-  it("takes the stronger of the current tone and the new notification's", () => {
-    expect(unreadToneWith("warning", row("error", false))).toBe("error");
-    expect(unreadToneWith("error", row("success", false))).toBe("error");
-    expect(unreadToneWith("success", row(null, false))).toBe("primary");
-  });
-
-  it("takes the new notification's tone when nothing was unread", () => {
-    expect(unreadToneWith(undefined, row("warning", false))).toBe("warning");
-  });
-
-  it("keeps the current tone for a notification that arrives read", () => {
-    expect(unreadToneWith("success", row("error", true))).toBe("success");
-  });
-});

package/frontend-vue/tests/nuxt-ui-aria-labels.test.ts

@@ -1,31 +0,0 @@
-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";
-
-// Nuxt UI hard-codes these labels in English, and its locales do not carry
-// them: each use has to bind its own, translated.
-const LABELLED_TAGS = {
-  UBreadcrumb: "dms.a11y.breadcrumb",
-  USkeleton: "dms.a11y.loading",
-} as const;
-const LOCALES = { "en-GB": coreEn, "fr-FR": coreFr };
-
-function lookup(messages: unknown, key: string): unknown {
-  return key
-    .split(".")
-    .reduce<unknown>(
-      (node, part) => (node as Record<string, unknown> | undefined)?.[part],
-      messages,
-    );
-}
-
-describe("Nuxt UI hard-coded aria-labels", () => {
-  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");
-      }
-      expect(lookup(coreFr, key)).not.toBe(lookup(coreEn, key));
-    });
-  }
-});