@antelopejs/dms 0.9.1 → 0.9.3

package/frontend-vue/tests/builtin-emails.test.ts

@@ -1,162 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { type Component, createSSRApp, defineComponent, h } from "vue";
-import { renderToString } from "vue/server-renderer";
-import { createI18n } from "vue-i18n";
-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 type { DmsBrandingLogo } from "../layers/dms-core/shared/types/app-config";
-
-interface EmailModule {
-  default: Component;
-}
-
-const emailModules = import.meta.glob<EmailModule>(
-  "../layers/dms-layout/app/emails/*.vue",
-  { eager: true },
-);
-
-const PUBLIC_BASE = "https://admin.example.com";
-const PUBLIC_PNG_LOGO = "/images/logo.png";
-const SVG_LOGO = "/images/logo.svg";
-const EMAIL_LOGOS: Partial<DmsBrandingLogo> = {
-  default: { light: SVG_LOGO, dark: SVG_LOGO },
-  email: { light: "/branding/email.png", dark: "/branding/email-dark.png" },
-};
-const ELEMENTS: Record<string, string> = {
-  EHtml: "html",
-  EHead: "head",
-  EBody: "body",
-  EContainer: "div",
-  ESection: "section",
-  EHeading: "h1",
-  EText: "p",
-  EButton: "a",
-  EImg: "img",
-  EHr: "hr",
-  EPreview: "span",
-};
-
-function element(tag: string) {
-  return defineComponent({
-    inheritAttrs: false,
-    setup:
-      (_, { attrs, slots }) =>
-      () =>
-        h(tag, { src: attrs.src }, slots.default?.()),
-  });
-}
-
-/** A path stands for `branding.logo.default.light`. */
-function brandingLogo(logo: string | Partial<DmsBrandingLogo>) {
-  return typeof logo === "string" ? { default: { light: logo } } : logo;
-}
-
-function templateName(path: string): string {
-  return path.split("/").pop()?.replace(".vue", "") ?? path;
-}
-
-const EMAIL_PROPS = {
-  userName: "Ada",
-  newEmail: "ada@new.test",
-  expiresIn: "24 hours",
-  expiresInHours: 24,
-  partial: true,
-  failedSources: ["media"],
-};
-
-async function renderEmail(
-  component: Component,
-  logo: string | Partial<DmsBrandingLogo>,
-  locale = "en",
-): Promise<string> {
-  vi.stubGlobal("useDmsAppConfig", () => ({
-    branding: { logo: brandingLogo(logo) },
-  }));
-  vi.stubGlobal("useDmsRuntimeConfig", () => ({
-    public: { dms: { clientBaseUrl: PUBLIC_BASE } },
-  }));
-  const app = createSSRApp(component, EMAIL_PROPS);
-  app.use(
-    createI18n({
-      legacy: false,
-      locale,
-      fallbackLocale: "en",
-      messages: { en, fr },
-    }),
-  );
-  Object.entries(ELEMENTS).forEach(([name, tag]) =>
-    app.component(name, element(tag)),
-  );
-  const html = await renderToString(app);
-  vi.unstubAllGlobals();
-  return html;
-}
-
-const templates = Object.entries(emailModules).map(
-  ([path, module]) => [templateName(path), module.default] as const,
-);
-
-describe("built-in emails", () => {
-  it.each(templates)(
-    "%s leaves out a logo mail clients cannot load",
-    async (_name, component) => {
-      const html = await renderEmail(component, SVG_LOGO);
-      expect(html).not.toContain("<img");
-    },
-  );
-
-  it.each(templates)("%s draws a public PNG logo", async (_name, component) => {
-    const html = await renderEmail(component, PUBLIC_PNG_LOGO);
-    expect(html).toContain(`<img src="${PUBLIC_BASE}${PUBLIC_PNG_LOGO}"`);
-  });
-
-  it.each(templates)(
-    "%s draws the email logo, with its dark variant",
-    async (_name, component) => {
-      const html = await renderEmail(component, EMAIL_LOGOS);
-      expect(html).toContain(
-        `<source media="(prefers-color-scheme: dark)" srcset="${PUBLIC_BASE}/branding/email-dark.png">`,
-      );
-      expect(html).toContain(`<img src="${PUBLIC_BASE}/branding/email.png"`);
-    },
-  );
-
-  it.each(templates)("%s is written in French", async (_name, component) => {
-    const html = await renderEmail(component, PUBLIC_PNG_LOGO, "fr");
-    expect(html).toContain("Bonjour");
-    expect(html).not.toMatch(/Hello|If you/);
-  });
-
-  it("words the code lifetime in the recipient's language", async () => {
-    const [, component] = templates.find(
-      ([name]) => name === "EmailResetPassword",
-    )!;
-    expect(await renderEmail(component, PUBLIC_PNG_LOGO)).toContain(
-      "This code expires in 24 hours.",
-    );
-    expect(await renderEmail(component, PUBLIC_PNG_LOGO, "fr")).toContain(
-      "Ce code expire dans 24 heures.",
-    );
-  });
-
-  it("marks a partial export in French", async () => {
-    const [, component] = templates.find(
-      ([name]) => name === "EmailExportReady",
-    )!;
-    const html = await renderEmail(component, PUBLIC_PNG_LOGO, "fr");
-    expect(html).toContain("<strong>incomplet</strong>");
-    expect(html.replace(/<!--[^>]*-->/g, "")).toContain("— media.");
-  });
-
-  it("puts the two-factor disclaimer under the separator", async () => {
-    const [, component] = templates.find(
-      ([name]) => name === "EmailTwoFactor",
-    )!;
-    const html = await renderEmail(component, PUBLIC_PNG_LOGO);
-    const separator = html.indexOf("<hr>");
-    expect(separator).toBeGreaterThan(-1);
-    expect(html.indexOf("If you did not attempt to sign in")).toBeGreaterThan(
-      separator,
-    );
-  });
-});

package/frontend-vue/tests/button-disabled-theme.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { twMerge } from "tailwind-merge";
-import appConfig from "../layers/dms-layout/app/app.config";
-
-// Nuxt UI 4's own button base, which the app config is merged over.
-const NUXT_UI_BUTTON_BASE =
-  "rounded-md font-medium inline-flex items-center disabled:cursor-not-allowed aria-disabled:cursor-not-allowed disabled:opacity-75 aria-disabled:opacity-75";
-
-describe("button theme", () => {
-  const merged = twMerge(NUXT_UI_BUTTON_BASE, appConfig.ui.button.slots.base);
-
-  it("fades disabled buttons past Nuxt UI's default", () => {
-    expect(merged).toContain("disabled:opacity-50");
-    expect(merged).toContain("aria-disabled:opacity-50");
-    expect(merged).not.toContain("opacity-75");
-  });
-
-  it("cancels the press effect on a disabled button", () => {
-    expect(merged).toContain("disabled:active:scale-100");
-  });
-});

package/frontend-vue/tests/cascader.test.ts

@@ -1,216 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  buildCascaderPathLabels,
-  buildCascaderTree,
-  cascaderValuePath,
-  findCascaderNode,
-  flattenCascaderTree,
-  formatCascaderPath,
-  isCascaderNodeSelectable,
-  resolveCascaderKeyMapping,
-  searchCascaderTree,
-  type CascaderKeyMapping,
-} from "../layers/dms-ui/app/utils/cascader";
-
-const keyMapping: CascaderKeyMapping = {
-  label: "name",
-  value: "_id",
-  parent: "parent_id",
-  disabled: "inactive",
-};
-
-interface CategoryRow extends Record<string, unknown> {
-  _id: string;
-  name: string;
-  parent_id: string | null;
-  inactive?: boolean;
-}
-
-const categories: CategoryRow[] = [
-  { _id: "electronics", name: "Electronics", parent_id: null },
-  { _id: "audio", name: "Audio", parent_id: "electronics" },
-  { _id: "headphones", name: "Headphones", parent_id: "audio" },
-  { _id: "speakers", name: "Speakers", parent_id: "audio" },
-  { _id: "video", name: "Video", parent_id: "electronics", inactive: true },
-  { _id: "tv", name: "TV", parent_id: "video" },
-  { _id: "garden", name: "Garden", parent_id: null },
-];
-
-describe("buildCascaderTree", () => {
-  it("rebuilds the tree from a flat list", () => {
-    const roots = buildCascaderTree(categories, keyMapping);
-
-    expect(roots.map((node) => node.value)).toEqual(["electronics", "garden"]);
-    const audio = findCascaderNode(roots, "audio");
-    expect(audio?.children.map((node) => node.value)).toEqual([
-      "headphones",
-      "speakers",
-    ]);
-    expect(audio?.depth).toBe(2);
-    expect(audio?.pathLabels).toEqual(["Electronics", "Audio"]);
-  });
-
-  it("treats rows with a missing parent as roots", () => {
-    const roots = buildCascaderTree(
-      [
-        { _id: "a", name: "A", parent_id: null },
-        { _id: "orphan", name: "Orphan", parent_id: "missing" },
-      ],
-      keyMapping,
-    );
-
-    expect(roots.map((node) => node.value)).toEqual(["a", "orphan"]);
-  });
-
-  it("drops rows trapped in a parent cycle", () => {
-    const roots = buildCascaderTree(
-      [
-        { _id: "a", name: "A", parent_id: "b" },
-        { _id: "b", name: "B", parent_id: "a" },
-        { _id: "root", name: "Root", parent_id: null },
-      ],
-      keyMapping,
-    );
-
-    expect(flattenCascaderTree(roots).map((node) => node.value)).toEqual([
-      "root",
-    ]);
-  });
-
-  it("disables the entire subtree of a disabled node", () => {
-    const roots = buildCascaderTree(categories, keyMapping);
-
-    expect(findCascaderNode(roots, "video")?.disabled).toBe(true);
-    expect(findCascaderNode(roots, "tv")?.disabled).toBe(true);
-    expect(findCascaderNode(roots, "audio")?.disabled).toBe(false);
-  });
-
-  it("prunes nodes deeper than maxDepth", () => {
-    const roots = buildCascaderTree(categories, keyMapping, { maxDepth: 2 });
-
-    const depths = flattenCascaderTree(roots).map((node) => node.depth);
-    expect(Math.max(...depths)).toBe(2);
-    expect(findCascaderNode(roots, "headphones")).toBeUndefined();
-    expect(findCascaderNode(roots, "audio")?.children).toEqual([]);
-  });
-});
-
-describe("searchCascaderTree", () => {
-  it("matches on the full path, case-insensitively", () => {
-    const roots = buildCascaderTree(categories, keyMapping);
-
-    const matches = searchCascaderTree(roots, "electronics / audio");
-    expect(matches.map((node) => node.value)).toEqual([
-      "audio",
-      "headphones",
-      "speakers",
-    ]);
-  });
-
-  it("finds a node by its own label", () => {
-    const roots = buildCascaderTree(categories, keyMapping);
-
-    const matches = searchCascaderTree(roots, "HeadPhones");
-    expect(matches.map((node) => formatCascaderPath(node))).toEqual([
-      "Electronics / Audio / Headphones",
-    ]);
-  });
-
-  it("returns nothing for a blank query", () => {
-    const roots = buildCascaderTree(categories, keyMapping);
-
-    expect(searchCascaderTree(roots, "  ")).toEqual([]);
-  });
-
-  it("keeps disabled nodes in the results", () => {
-    const roots = buildCascaderTree(categories, keyMapping);
-
-    const matches = searchCascaderTree(roots, "tv");
-    expect(matches.map((node) => node.value)).toEqual(["tv"]);
-    expect(matches[0]?.disabled).toBe(true);
-  });
-});
-
-describe("isCascaderNodeSelectable", () => {
-  const roots = buildCascaderTree(categories, keyMapping);
-
-  it("rejects disabled nodes", () => {
-    expect(isCascaderNodeSelectable(findCascaderNode(roots, "video")!)).toBe(
-      false,
-    );
-  });
-
-  it("allows intermediate nodes unless leafOnly is set", () => {
-    const audio = findCascaderNode(roots, "audio")!;
-    expect(isCascaderNodeSelectable(audio)).toBe(true);
-    expect(isCascaderNodeSelectable(audio, { leafOnly: true })).toBe(false);
-    expect(
-      isCascaderNodeSelectable(findCascaderNode(roots, "headphones")!, {
-        leafOnly: true,
-      }),
-    ).toBe(true);
-  });
-
-  it("rejects nodes deeper than maxDepth", () => {
-    const headphones = findCascaderNode(roots, "headphones")!;
-    expect(isCascaderNodeSelectable(headphones, { maxDepth: 2 })).toBe(false);
-    expect(isCascaderNodeSelectable(headphones, { maxDepth: 3 })).toBe(true);
-  });
-});
-
-describe("buildCascaderPathLabels", () => {
-  it("resolves the full label path from the flat list", () => {
-    expect(
-      buildCascaderPathLabels(categories, keyMapping, "headphones"),
-    ).toEqual(["Electronics", "Audio", "Headphones"]);
-  });
-
-  it("returns an empty array for an unknown value", () => {
-    expect(buildCascaderPathLabels(categories, keyMapping, "nope")).toEqual([]);
-  });
-
-  it("stops at a parent cycle without looping", () => {
-    const rows = [
-      { _id: "a", name: "A", parent_id: "b" },
-      { _id: "b", name: "B", parent_id: "a" },
-    ];
-    expect(buildCascaderPathLabels(rows, keyMapping, "a")).toEqual(["B", "A"]);
-  });
-});
-
-describe("cascaderValuePath", () => {
-  it("resolves a picked id, or a picked row, to its path", () => {
-    expect(cascaderValuePath("speakers", keyMapping, categories)).toEqual([
-      "Electronics",
-      "Audio",
-      "Speakers",
-    ]);
-    expect(
-      cascaderValuePath({ _id: "tv", name: "TV" }, keyMapping, categories),
-    ).toEqual(["Electronics", "Video", "TV"]);
-  });
-
-  it("shows a picked row's own label, or its id, until the rows are there", () => {
-    expect(cascaderValuePath({ _id: "tv", name: "TV" }, keyMapping)).toEqual([
-      "TV",
-    ]);
-    expect(cascaderValuePath("tv", keyMapping)).toEqual(["tv"]);
-    expect(cascaderValuePath("nope", keyMapping, categories)).toEqual(["nope"]);
-  });
-
-  it("has no path for nothing picked", () => {
-    expect(cascaderValuePath(null, keyMapping, categories)).toEqual([]);
-    expect(cascaderValuePath({ name: "Loose" }, keyMapping)).toEqual(["Loose"]);
-  });
-});
-
-describe("resolveCascaderKeyMapping", () => {
-  it("falls back to default keys", () => {
-    expect(resolveCascaderKeyMapping()).toEqual({
-      label: "label",
-      value: "value",
-      parent: "parent",
-    });
-    expect(resolveCascaderKeyMapping({ label: "name" }).label).toBe("name");
-  });
-});

package/frontend-vue/tests/category-nav-cards.test.ts

@@ -1,105 +0,0 @@
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import { computed, ref } from "vue";
-import { useCategoryNavCards } from "../layers/dms-layout/app/build/composables/navigation/useCategoryNavCards";
-import type { NavBadge } from "../layers/dms-ui/app/build/composables/navigation/useNavBadges";
-
-const badges = ref<Record<string, NavBadge>>({});
-vi.mock(
-  "../layers/dms-core/app/build/composables/auth/usePermissionPreview",
-  () => ({
-    usePermissionPreview: () => ({}),
-  }),
-);
-
-const node = (fullId: string, extra: Record<string, unknown> = {}) => ({
-  fullId,
-  displayName: `$${fullId}`,
-  fullSlug: `/${fullId.replaceAll(".", "/")}`,
-  layoutUrl: `/${fullId}/pagelayout`,
-  children: {},
-  childrenOrders: [],
-  ...extra,
-});
-
-const tree = ref({
-  ...node(""),
-  children: {
-    settings: {
-      ...node("settings"),
-      layoutUrl: undefined,
-      children: {
-        user: {
-          ...node("settings.user"),
-          layoutUrl: undefined,
-          children: {
-            profile: node("settings.user.profile", { icon: "i-ph-user" }),
-            security: node("settings.user.security", { badge: "1" }),
-            notifications: node("settings.user.notifications", {
-              badge: "4",
-              badgeTone: "warning",
-            }),
-            locked: node("settings.user.locked", { hasAccess: false }),
-          },
-          childrenOrders: ["profile", "security", "notifications", "locked"],
-        },
-      },
-      childrenOrders: ["user"],
-    },
-  },
-  childrenOrders: ["settings"],
-});
-
-beforeEach(() => {
-  badges.value = {};
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
-  vi.stubGlobal("useSiteLayout", () => ({ siteLayoutTree: tree }));
-  vi.stubGlobal("useDmsState", () => badges);
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-it("makes a card of each page the viewer can open, in menu order", () => {
-  const { cards } = useCategoryNavCards(() => "settings.user");
-  expect(cards.value.map((card) => card.id)).toEqual([
-    "settings.user.profile",
-    "settings.user.security",
-    "settings.user.notifications",
-  ]);
-  expect(cards.value[0]).toMatchObject({
-    title: "$settings.user.profile",
-    icon: "i-ph-user",
-    to: "/settings/user/profile",
-    badge: undefined,
-  });
-});
-
-it("shows the navigation badge, a fresher count first", () => {
-  badges.value = {
-    "settings.user.notifications": { label: "" },
-    "settings.user.security": { label: "2", tone: "error" },
-  };
-  const { cards } = useCategoryNavCards(() => "settings.user");
-  expect(cards.value.map((card) => card.badge)).toEqual([
-    undefined,
-    "2",
-    undefined,
-  ]);
-  expect(cards.value[1]?.badgeTone).toBe("error");
-});
-
-it("draws the served badge in the tone the server gave it", () => {
-  const { cards } = useCategoryNavCards(() => "settings.user");
-  expect(cards.value[2]).toMatchObject({ badge: "4", badgeTone: "warning" });
-  expect(cards.value[1]).toMatchObject({ badge: "1", badgeTone: undefined });
-  // The badge is the card's corner pill, not the live state line under the
-  // description that a fetched card closes on.
-  expect(cards.value[2]).not.toHaveProperty("state");
-});
-
-it("lists nothing for a category the site layout does not hold", () => {
-  const { cards } = useCategoryNavCards(() => "settings.unknown");
-  expect(cards.value).toEqual([]);
-});

package/frontend-vue/tests/chart-absent-value.test.ts

@@ -1,78 +0,0 @@
-import { createSSRApp, defineComponent, h, ref } from "vue";
-import { renderToString } from "vue/server-renderer";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import ChartCard from "../layers/dms-ui/app/components/chart/ChartCard.vue";
-import KpiCard from "../layers/dms-ui/app/components/kpi/KpiCard.vue";
-import { ABSENT_VALUE_TEXT } from "../layers/dms-ui/app/composables/chart/formatValue";
-
-// A period the query measured nothing in: the response carries its series and no
-// figure at all, which is what the contract answers rather than a zero.
-vi.mock("../layers/dms-ui/app/composables/chart/useChartFetch", () => ({
-  useChartFetch: () => ({
-    data: ref({ series: [{ name: "Revenue", data: [] }] }),
-    isLoading: ref(false),
-  }),
-}));
-
-const Slot = defineComponent({
-  setup:
-    (_, { slots }) =>
-    () =>
-      h("div", slots.default?.()),
-});
-
-const SLOT_COMPONENTS = [
-  "DmsCard",
-  "DmsClientOnly",
-  "UIcon",
-  "USkeleton",
-  "DmsTrendBadge",
-  "DmsSparkline",
-  "UBadge",
-];
-
-function stubNuxt() {
-  vi.stubGlobal("useI18n", () => ({
-    locale: ref("en-US"),
-    t: (key: string) => key,
-  }));
-  vi.stubGlobal("useTranslation", () => ({
-    processI18n: (text: string) => text,
-  }));
-  vi.stubGlobal("useComponentEvent", () => ({}));
-  vi.stubGlobal("useWatch", () => ({ state: ref({}) }));
-}
-
-type CardProps = InstanceType<typeof ChartCard>["$props"];
-
-async function renderCards() {
-  stubNuxt();
-  const props: CardProps = {
-    title: "Revenue",
-    componentId: "card",
-    pageId: "absent",
-    valueFormat: "currency",
-  };
-  const app = createSSRApp({
-    render: () => h("main", [h(ChartCard, props), h(KpiCard, props)]),
-  });
-  for (const name of SLOT_COMPONENTS) app.component(name, Slot);
-  return renderToString(app);
-}
-
-afterEach(() => vi.unstubAllGlobals());
-
-describe("a card whose query measured nothing", () => {
-  it("shows an absence where the figure goes, on both cards", async () => {
-    const html = await renderCards();
-    expect(html.split(ABSENT_VALUE_TEXT)).toHaveLength(3);
-  });
-
-  it("prints no zero, and no unit for a quantity there is none of", async () => {
-    const html = await renderCards();
-    expect(html, "a zero reads exactly like a measured figure").not.toContain(
-      "<span>0</span>",
-    );
-    expect(html).not.toContain("€");
-  });
-});