@antelopejs/dms 0.9.1 → 0.9.3

package/frontend-vue/tests/regional-format.test.ts

@@ -1,134 +0,0 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  expectTypeOf,
-  it,
-  vi,
-} from "vitest";
-import { ref } from "vue";
-import { useRegionalFormat } from "../layers/dms-core/app/composables/user/useRegionalFormat";
-import {
-  regionalFormatLocale,
-  setRegionalPreferencesSource,
-} from "../layers/dms-core/app/utils/regional";
-
-// 23:30 UTC on 30 Sep: already 1 Oct in Brussels.
-const LATE_EVENING_UTC = new Date(Date.UTC(2026, 8, 30, 23, 30));
-const DAY_MONTH_YEAR: Intl.DateTimeFormatOptions = {
-  day: "numeric",
-  month: "long",
-  year: "numeric",
-};
-
-const locale = ref("fr-FR");
-
-beforeEach(() => {
-  locale.value = "fr-FR";
-  vi.stubGlobal("useI18n", () => ({
-    t: (key: string, params?: Record<string, unknown>) =>
-      `${key}:${JSON.stringify(params ?? {})}`,
-    locale,
-  }));
-  setRegionalPreferencesSource(() => ({ timeZone: "Europe/Brussels" }));
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  setRegionalPreferencesSource(() => ({}));
-});
-
-describe("useRegionalFormat", () => {
-  it("writes dates in the user's language and time zone", () => {
-    const { formatDate } = useRegionalFormat();
-    expect(formatDate(LATE_EVENING_UTC, DAY_MONTH_YEAR)).toBe("1 octobre 2026");
-  });
-
-  it("follows a language switch", () => {
-    const { formatDate } = useRegionalFormat();
-    locale.value = "en-GB";
-    expect(formatDate(LATE_EVENING_UTC, DAY_MONTH_YEAR)).toBe("1 October 2026");
-  });
-
-  it("applies the user's clock to its own formats", () => {
-    setRegionalPreferencesSource(() => ({
-      timeZone: "Europe/Brussels",
-      timeFormat: "h12",
-    }));
-    const { dateTimeFormat } = useRegionalFormat();
-    locale.value = "en-GB";
-    expect(
-      dateTimeFormat({ hour: "numeric", minute: "2-digit" }).format(
-        LATE_EVENING_UTC,
-      ),
-    ).toBe("1:30 am");
-  });
-
-  it("writes numbers in the user's language", () => {
-    const { formatNumber, formatPrice } = useRegionalFormat();
-    expect(formatNumber(1234.5)).toBe("1 234,5");
-    expect(formatPrice(12)).toBe("12,00 €");
-  });
-
-  it("translates relative dates with the application's messages", () => {
-    const { formatRelativeTime } = useRegionalFormat();
-    expect(formatRelativeTime(Date.now())).toBe("common.time.just_now:{}");
-  });
-
-  it("types a formatted number as a string", () => {
-    const { formatNumber, formatPercentage, formatPrice } = useRegionalFormat();
-    const written: string[] = [
-      formatNumber(1234.5),
-      formatPercentage(0.25),
-      formatPrice(12),
-    ];
-    expect(written).toEqual([
-      new Intl.NumberFormat("fr-FR").format(1234.5),
-      new Intl.NumberFormat("fr-FR", { style: "percent" }).format(0.25),
-      new Intl.NumberFormat("fr-FR", {
-        style: "currency",
-        currency: "EUR",
-      }).format(12),
-    ]);
-    expectTypeOf(formatNumber(1)).toEqualTypeOf<string>();
-    expectTypeOf(formatNumber("n/a" as unknown)).toEqualTypeOf<unknown>();
-    expect(formatNumber("n/a")).toBe("n/a");
-  });
-
-  it("names the locale of the DMS texts for the interface language", () => {
-    locale.value = "en";
-    const { formatLocale } = useRegionalFormat();
-    expect(formatLocale.value).toBe("en-GB");
-    locale.value = "fr";
-    expect(formatLocale.value).toBe("fr-FR");
-  });
-
-  it("writes in the locale of the DMS texts when asked", () => {
-    locale.value = "en";
-    const interfaceFormat = useRegionalFormat();
-    const textFormat = useRegionalFormat({ locale: "format" });
-    const clock: Intl.DateTimeFormatOptions = {
-      hour: "numeric",
-      minute: "2-digit",
-    };
-    expect(interfaceFormat.dateTimeFormat(clock).format(LATE_EVENING_UTC)).toBe(
-      "1:30 AM",
-    );
-    expect(textFormat.dateTimeFormat(clock).format(LATE_EVENING_UTC)).toBe(
-      "1:30",
-    );
-    expect(textFormat.formatDate(LATE_EVENING_UTC, DAY_MONTH_YEAR)).toBe(
-      "1 October 2026",
-    );
-  });
-});
-
-describe("regionalFormatLocale", () => {
-  it("reads a bare DMS language as the region its texts are written for", () => {
-    expect(regionalFormatLocale("en")).toBe("en-GB");
-    expect(regionalFormatLocale("fr")).toBe("fr-FR");
-    expect(regionalFormatLocale("en-US")).toBe("en-US");
-    expect(regionalFormatLocale("de")).toBe("de");
-  });
-});

package/frontend-vue/tests/regional-preferences.test.ts

@@ -1,209 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  formatDate,
-  formatDateTime,
-  formatRelativeTime,
-} from "../layers/dms-core/app/utils/formatter";
-import {
-  readRegionalPreferences,
-  regionalDayKey,
-  regionalDayNumber,
-  regionalWeekStart,
-  setRegionalPreferencesSource,
-  withRegionalOptions,
-} from "../layers/dms-core/app/utils/regional";
-import {
-  buildTimeZoneOptions,
-  timeZoneLabel,
-  timeZoneOffset,
-} from "../layers/dms-layout/app/build/components/pages/settings/region/timeZones";
-import { groupNotificationsByDay } from "../layers/dms-layout/app/build/components/pages/settings/notification/notificationDisplay";
-import type { UserNotification } from "../layers/dms-layout/app/composables/notification/useNotifications";
-
-// 23:30 UTC on 30 Sep: already 1 Oct in Brussels, still 30 Sep in New York.
-const LATE_EVENING_UTC = new Date(Date.UTC(2026, 8, 30, 23, 30));
-
-afterEach(() => {
-  setRegionalPreferencesSource(() => ({}));
-});
-
-describe("readRegionalPreferences", () => {
-  it("keeps the values this runtime can apply", () => {
-    expect(
-      readRegionalPreferences({
-        timeZone: "Europe/Brussels",
-        weekStart: 0,
-        timeFormat: "h12",
-        dateFormat: "numeric",
-      }),
-    ).toEqual({
-      timeZone: "Europe/Brussels",
-      weekStart: 0,
-      timeFormat: "h12",
-      dateFormat: "numeric",
-    });
-  });
-
-  it("drops unknown zones and values as automatic", () => {
-    expect(
-      readRegionalPreferences({
-        timeZone: "Mars/Olympus",
-        weekStart: 3,
-        timeFormat: "h24",
-        dateFormat: null,
-      }),
-    ).toEqual({
-      timeZone: undefined,
-      weekStart: undefined,
-      timeFormat: undefined,
-      dateFormat: undefined,
-    });
-    expect(readRegionalPreferences(null)).toEqual({});
-  });
-});
-
-describe("withRegionalOptions", () => {
-  it("adds the zone and the clock, never over what the caller states", () => {
-    const preferences = {
-      timeZone: "Asia/Tokyo",
-      timeFormat: "h12" as const,
-    };
-    expect(withRegionalOptions({ hour: "2-digit" }, {}, preferences)).toEqual({
-      hour: "2-digit",
-      timeZone: "Asia/Tokyo",
-      hourCycle: "h12",
-    });
-    expect(
-      withRegionalOptions(
-        { hour: "2-digit", hour12: false, timeZone: "UTC" },
-        {},
-        preferences,
-      ),
-    ).toEqual({ hour: "2-digit", hour12: false, timeZone: "UTC" });
-  });
-
-  it("leaves the clock alone on a date without time", () => {
-    expect(
-      withRegionalOptions({ day: "numeric" }, {}, { timeFormat: "h12" }),
-    ).toEqual({ day: "numeric" });
-  });
-
-  it("keeps the browser zone for calendar days", () => {
-    expect(
-      withRegionalOptions(
-        { day: "numeric" },
-        { keepLocalZone: true },
-        { timeZone: "Asia/Tokyo" },
-      ),
-    ).toEqual({ day: "numeric" });
-  });
-
-  it("rewrites full dates to the chosen date format only", () => {
-    const numeric = { dateFormat: "numeric" as const };
-    expect(
-      withRegionalOptions(
-        { day: "2-digit", month: "long", year: "numeric" },
-        {},
-        numeric,
-      ),
-    ).toEqual({ day: "2-digit", month: "2-digit", year: "numeric" });
-    expect(
-      withRegionalOptions(
-        { dateStyle: "medium", timeStyle: "short" },
-        {},
-        numeric,
-      ),
-    ).toEqual({
-      day: "2-digit",
-      month: "2-digit",
-      year: "numeric",
-      hour: "2-digit",
-      minute: "2-digit",
-    });
-    // "Sep 27" has no year: not a full date.
-    expect(
-      withRegionalOptions({ day: "numeric", month: "short" }, {}, numeric),
-    ).toEqual({ day: "numeric", month: "short" });
-    expect(
-      withRegionalOptions(
-        { day: "2-digit", month: "2-digit", year: "numeric" },
-        {},
-        { dateFormat: "text" },
-      ),
-    ).toEqual({ day: "2-digit", month: "short", year: "numeric" });
-  });
-});
-
-describe("shared formatters follow the user's preferences", () => {
-  it("writes dates and times in the chosen zone and clock", () => {
-    setRegionalPreferencesSource(() => ({
-      timeZone: "Europe/Brussels",
-      timeFormat: "h12",
-      dateFormat: "numeric",
-    }));
-    expect(formatDate(LATE_EVENING_UTC, "en-GB")).toBe("01/10/2026");
-    expect(
-      formatDateTime(LATE_EVENING_UTC, "en-GB", { second: undefined }),
-    ).toMatch(/01\/10\/2026.*1:30.*am/i);
-
-    setRegionalPreferencesSource(() => ({ timeZone: "America/New_York" }));
-    expect(formatDate(LATE_EVENING_UTC, "en-GB")).toBe("30 September 2026");
-  });
-
-  it("counts days in the chosen zone", () => {
-    const brussels = { timeZone: "Europe/Brussels" };
-    const newYork = { timeZone: "America/New_York" };
-    expect(
-      regionalDayNumber(LATE_EVENING_UTC, brussels) -
-        regionalDayNumber(LATE_EVENING_UTC, newYork),
-    ).toBe(1);
-    setRegionalPreferencesSource(() => brussels);
-    expect(regionalDayKey(LATE_EVENING_UTC)).toBe("2026-10-01");
-  });
-
-  it("names yesterday in the chosen zone", () => {
-    setRegionalPreferencesSource(() => ({ timeFormat: "h23" }));
-    const t = (key: string, params?: Record<string, unknown>) =>
-      `${key}:${JSON.stringify(params ?? {})}`;
-    const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
-    expect(formatRelativeTime(twoDaysAgo, t, "fr-FR")).toContain(
-      "common.time.on_date",
-    );
-  });
-
-  it("files notifications under the reader's day", () => {
-    setRegionalPreferencesSource(() => ({ timeZone: "Europe/Brussels" }));
-    const now = new Date(Date.UTC(2026, 9, 1, 8));
-    const groups = groupNotificationsByDay(
-      [{ createdAt: LATE_EVENING_UTC.toISOString() } as UserNotification],
-      now,
-    );
-    expect(groups.map((group) => group.key)).toEqual(["today"]);
-  });
-
-  it("starts the week on the chosen day, else the locale's", () => {
-    expect(regionalWeekStart("en", { weekStart: 0 })).toBe(0);
-    expect(regionalWeekStart("fr", {})).toBe(1);
-  });
-});
-
-describe("time zone picker entries", () => {
-  it("labels and sorts zones by offset", () => {
-    const at = new Date(Date.UTC(2026, 0, 15));
-    expect(timeZoneLabel("America/Argentina/Buenos_Aires")).toBe(
-      "America / Argentina / Buenos Aires",
-    );
-    expect(timeZoneOffset("UTC", at)).toBe("UTC+00:00");
-    expect(timeZoneOffset("Asia/Kolkata", at)).toBe("UTC+05:30");
-    const options = buildTimeZoneOptions(
-      ["Asia/Tokyo", "UTC", "America/New_York"],
-      at,
-      ["UTC", ""],
-    );
-    expect(options.map((option) => option.value)).toEqual([
-      "America/New_York",
-      "UTC",
-      "Asia/Tokyo",
-    ]);
-  });
-});

package/frontend-vue/tests/relation-badges.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildRelationBadges } from "../layers/dms-ui/app/build/composables/data-types/relationBadges";
-
-describe("buildRelationBadges", () => {
-  it("reads each resolved related row through the label key", () => {
-    expect(
-      buildRelationBadges([{ name: "Admin" }, { name: "Billing" }], "name"),
-    ).to.deep.equal({ visible: ["Admin", "Billing"], hidden: [] });
-  });
-
-  it("folds the labels past the limit into the hidden list", () => {
-    const roles = ["A", "B", "C", "D", "E"].map((name) => ({ name }));
-    expect(buildRelationBadges(roles, "name", 3)).to.deep.equal({
-      visible: ["A", "B", "C"],
-      hidden: ["D", "E"],
-    });
-  });
-
-  it("shows a raw id when the relation was not resolved", () => {
-    expect(buildRelationBadges(["role-1"], "name").visible).to.deep.equal([
-      "role-1",
-    ]);
-  });
-
-  it("drops items without a label and renders nothing for no value", () => {
-    expect(buildRelationBadges([{ other: "x" }, null], "name")).to.deep.equal({
-      visible: [],
-      hidden: [],
-    });
-    expect(buildRelationBadges([], "name").visible).to.deep.equal([]);
-  });
-});

package/frontend-vue/tests/relation-value.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { sameRelationValue } from "../layers/dms-ui/app/build/composables/data-types/relationValue";
-
-const ANN = { _id: "u-1", name: "Ann", avatar: "ann.png" };
-const BOB = { _id: "u-2", name: "Bob" };
-const SINGLE = { keyMapping: { label: "name", value: "_id" } };
-const MULTIPLE = { ...SINGLE, multiple: true };
-
-describe("sameRelationValue", () => {
-  it("matches the row the server joined with the id the picker holds", () => {
-    expect(sameRelationValue(ANN, "u-1", SINGLE)).toBe(true);
-    expect(sameRelationValue("u-1", ANN, SINGLE)).toBe(true);
-  });
-
-  it("tells another row apart", () => {
-    expect(sameRelationValue(ANN, "u-2", SINGLE)).toBe(false);
-  });
-
-  it("reads the id under the field's value key", () => {
-    const bySlug = { keyMapping: { value: "slug" } };
-    expect(sameRelationValue({ slug: "ann" }, "ann", bySlug)).toBe(true);
-    expect(sameRelationValue({ slug: "ann", _id: "u-1" }, "u-1", bySlug)).toBe(
-      false,
-    );
-  });
-
-  it("compares the picks of a multiple relation as a set", () => {
-    expect(sameRelationValue([ANN, BOB], ["u-2", "u-1"], MULTIPLE)).toBe(true);
-    expect(sameRelationValue([ANN, BOB], ["u-1"], MULTIPLE)).toBe(false);
-    expect(sameRelationValue([ANN], ["u-1", "u-1"], MULTIPLE)).toBe(false);
-  });
-
-  it("holds every empty value the same, and none the same as a pick", () => {
-    expect(sameRelationValue(null, undefined, SINGLE)).toBe(true);
-    expect(sameRelationValue([], undefined, MULTIPLE)).toBe(true);
-    expect(sameRelationValue(null, "u-1", SINGLE)).toBe(false);
-    expect(sameRelationValue([], [ANN], MULTIPLE)).toBe(false);
-  });
-});

package/frontend-vue/tests/resolve-dms-component.test.ts

@@ -1,47 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const engine = vi.hoisted(() => ({
-  resolveDmsComponent: vi.fn(),
-}));
-
-vi.mock("#dms/frontend-module", () => engine);
-
-const SecurityStatus = { name: "SecurityStatus" };
-
-describe("resolveDmsComponent", () => {
-  beforeEach(() => {
-    engine.resolveDmsComponent.mockImplementation((name: string) =>
-      name === "DmsSecurityStatus" ? SecurityStatus : undefined,
-    );
-  });
-
-  afterEach(() => {
-    engine.resolveDmsComponent.mockReset();
-  });
-
-  async function load() {
-    return import("../layers/dms-ui/app/composables/resolveDmsComponent");
-  }
-
-  it("resolves a component through the engine by its full name", async () => {
-    const { resolveDmsComponent } = await load();
-
-    expect(resolveDmsComponent("DmsSecurityStatus")).toBe(SecurityStatus);
-    expect(engine.resolveDmsComponent).toHaveBeenCalledWith(
-      "DmsSecurityStatus",
-    );
-  });
-
-  it("resolves nothing for a name the engine does not know", async () => {
-    const { resolveDmsComponent } = await load();
-
-    expect(resolveDmsComponent("SecurityStatus")).toBeUndefined();
-  });
-
-  it("resolves nothing without a name", async () => {
-    const { resolveDmsComponent } = await load();
-
-    expect(resolveDmsComponent(undefined)).toBeUndefined();
-    expect(engine.resolveDmsComponent).not.toHaveBeenCalled();
-  });
-});

package/frontend-vue/tests/response-warning-toast.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  readResponseWarning,
-  resolveResponseToast,
-} from "../layers/dms-ui/app/build/utils/responseWarning";
-import en from "../layers/dms-layout/i18n/locales/layout-en-GB.json";
-import fr from "../layers/dms-layout/i18n/locales/layout-fr-FR.json";
-import uiEn from "../layers/dms-ui/i18n/locales/ui-en-GB.json";
-import uiFr from "../layers/dms-ui/i18n/locales/ui-fr-FR.json";
-
-const INVITE_EMAIL_FAILED = "$page.settings.members.invite.email_failed";
-const SUCCESS = { color: "success", title: "Invitation sent successfully" };
-
-const translation = {
-  processI18n: (key: string) => `i18n:${key}`,
-  processApiMessage: (message: unknown) => `api:${String(message)}`,
-};
-
-describe("response warning toast", () => {
-  it("tells the warning instead of the success when the response carries one", () => {
-    expect(
-      resolveResponseToast(
-        { redirectPath: "/invites", warning: INVITE_EMAIL_FAILED },
-        SUCCESS,
-        translation,
-      ),
-    ).toEqual({
-      color: "warning",
-      title: "i18n:$dms.form.warning_title",
-      description: `api:${INVITE_EMAIL_FAILED}`,
-    });
-  });
-
-  it("keeps the success toast for a plain success", () => {
-    expect(
-      resolveResponseToast({ emailDelivery: "sent" }, SUCCESS, translation),
-    ).toBe(SUCCESS);
-    expect(resolveResponseToast(undefined, SUCCESS, translation)).toBe(SUCCESS);
-    expect(resolveResponseToast("", SUCCESS, translation)).toBe(SUCCESS);
-  });
-
-  it("ignores a warning that is not a message", () => {
-    expect(readResponseWarning({ warning: "" })).toBeUndefined();
-    expect(readResponseWarning({ warning: 42 })).toBeUndefined();
-  });
-
-  it("has the invitation warnings in every shipped locale", () => {
-    for (const locale of [en, fr]) {
-      const settings = locale.page.settings;
-      expect(settings.members.invite.email_failed).toBeTruthy();
-      expect(settings.invites.action.resend_email_failed).toBeTruthy();
-    }
-    for (const locale of [uiEn, uiFr]) {
-      expect(locale.dms.form.warning_title).toBeTruthy();
-    }
-  });
-});

package/frontend-vue/tests/revealed-backup-codes.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { nextTick, ref } from "vue";
-import { useRevealedBackupCodes } from "../layers/dms-layout/app/build/composables/settings/security/useRevealedBackupCodes";
-
-const ALICE = "user-alice";
-const BOB = "user-bob";
-const ALICE_CODES = ["11111111", "22222222"];
-
-async function revealForAlice() {
-  const userId = ref<string | undefined>(ALICE);
-  const revealed = useRevealedBackupCodes(userId);
-  revealed.reveal(ALICE_CODES, true);
-  revealed.isOpen.value = true;
-  await nextTick();
-  return { userId, ...revealed };
-}
-
-describe("useRevealedBackupCodes", () => {
-  it("shows a freshly issued set to the account it was issued for", async () => {
-    const { codes, isRegenerated } = await revealForAlice();
-    expect(codes.value).toEqual(ALICE_CODES);
-    expect(isRegenerated.value).toBe(true);
-  });
-
-  // Switching accounts in the same tab does not reload the page: the next
-  // account could open the dialog and read, or "save", the previous codes.
-  it("never shows them to another account of the same tab", async () => {
-    const { userId, codes, isOpen } = await revealForAlice();
-    userId.value = BOB;
-    expect(codes.value).toEqual([]);
-    await nextTick();
-    expect(isOpen.value).toBe(false);
-    userId.value = ALICE;
-    expect(codes.value).toEqual([]);
-  });
-
-  it("forgets them on sign-out", async () => {
-    const { userId, codes } = await revealForAlice();
-    userId.value = undefined;
-    await nextTick();
-    userId.value = ALICE;
-    expect(codes.value).toEqual([]);
-  });
-
-  it("forgets them once their dialog closes", async () => {
-    const { codes, isOpen, isRegenerated } = await revealForAlice();
-    isOpen.value = false;
-    await nextTick();
-    expect(codes.value).toEqual([]);
-    expect(isRegenerated.value).toBe(false);
-  });
-
-  it("keeps nothing without a signed-in account", () => {
-    const { codes, reveal } = useRevealedBackupCodes(ref(undefined));
-    reveal(ALICE_CODES);
-    expect(codes.value).toEqual([]);
-  });
-});