@antelopejs/dms 0.0.1

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

@@ -0,0 +1,156 @@
+import { createSSRApp, defineComponent, h, ref, type PropType } 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 Chart from "../layers/dms-ui/app/components/chart/Chart.vue";
+import KpiCard from "../layers/dms-ui/app/components/kpi/KpiCard.vue";
+import TopListCard from "../layers/dms-ui/app/components/top-list/TopListCard.vue";
+import type { ValuePrecision } from "../layers/dms-ui/app/composables/chart/types";
+
+const AMOUNT = 9.391;
+vi.mock("../layers/dms-ui/app/composables/chart/useChartFetch", () => ({
+  useChartFetch: () => ({
+    data: ref({
+      value: AMOUNT,
+      previousValue: AMOUNT,
+      series: [{ name: "Spend", data: [AMOUNT] }],
+      items: [{ id: "spend", title: "Spend", value: AMOUNT }],
+    }),
+    isLoading: ref(false),
+  }),
+}));
+
+interface ValueFormatter {
+  formatter: (value: number) => string;
+}
+interface FormattedAxis {
+  labels: ValueFormatter;
+}
+interface FormattedTooltip {
+  y: ValueFormatter;
+}
+interface ChartOptions {
+  yaxis: FormattedAxis;
+  tooltip: FormattedTooltip;
+}
+
+const PlotProbe = defineComponent({
+  props: {
+    options: { type: Object as PropType<ChartOptions>, required: true },
+  },
+  setup: (props) => () =>
+    h("output", [
+      h(
+        "span",
+        { class: "axis" },
+        props.options.yaxis.labels.formatter(AMOUNT),
+      ),
+      h(
+        "span",
+        { class: "tooltip" },
+        props.options.tooltip.y.formatter(AMOUNT),
+      ),
+    ]),
+});
+const Slot = defineComponent({
+  setup:
+    (_, { slots }) =>
+    () =>
+      h("div", slots.default?.()),
+});
+const Row = defineComponent({
+  props: ["formattedValue"],
+  setup: (props) => () => h("span", props.formattedValue),
+});
+
+function stubNuxt(locale: string) {
+  vi.stubGlobal("useI18n", () => ({
+    locale: ref(locale),
+    t: (key: string) => key,
+  }));
+  vi.stubGlobal("useTranslation", () => ({
+    processI18n: (text: string) => text,
+  }));
+  vi.stubGlobal("useComponentEvent", () => ({}));
+  vi.stubGlobal("useWatch", () => ({ state: ref({}) }));
+}
+
+const SLOT_COMPONENTS = [
+  "DmsCard",
+  "DmsClientOnly",
+  "UIcon",
+  "USkeleton",
+  "DmsTrendBadge",
+  "DmsSparkline",
+  "UBadge",
+];
+
+type CardProps = InstanceType<typeof ChartCard>["$props"];
+
+async function renderCards(
+  currencyCode: string,
+  locale: string,
+  valuePrecision?: ValuePrecision,
+) {
+  stubNuxt(locale);
+  const props: CardProps = {
+    title: "Spend",
+    componentId: "card",
+    pageId: "precision",
+    valueFormat: "currency",
+    currencyCode,
+    valuePrecision,
+  };
+  const app = createSSRApp({
+    render: () =>
+      h("main", [
+        h(ChartCard, props, () =>
+          h(Chart, { type: "line", componentId: "plot", pageId: "precision" }),
+        ),
+        h(KpiCard, props),
+        h(TopListCard, props),
+      ]),
+  });
+  for (const name of SLOT_COMPONENTS) app.component(name, Slot);
+  app.component("DmsApexChartHost", PlotProbe);
+  app.component("DmsTopListRow", Row);
+  return renderToString(app);
+}
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe("card → nested chart → Apex format propagation", () => {
+  it.each(["EUR", "JPY", "KWD"])(
+    "propagates native %s formatting to headline, comparison, axis, tooltip and list",
+    async (currency) => {
+      const expected = new Intl.NumberFormat("fr-FR", {
+        style: "currency",
+        currency,
+      }).format(AMOUNT);
+      const html = await renderCards(currency, "fr-FR", "native");
+      expect(html.split(expected)).toHaveLength(6);
+      expect(html).toContain(`class="axis">${expected}`);
+      expect(html).toContain(`class="tooltip">${expected}`);
+      const numeric = new Intl.NumberFormat("fr-FR", {
+        style: "currency",
+        currency,
+      })
+        .formatToParts(AMOUNT)
+        .filter((part) => part.type !== "currency")
+        .map((part) => part.value)
+        .join("")
+        .trim();
+      expect(html).toContain(`<span>${numeric}</span>`);
+    },
+  );
+
+  it("preserves defaults and honours explicit zero and three digits", async () => {
+    expect(await renderCards("EUR", "en-US")).toContain('class="axis">€9');
+    expect(await renderCards("EUR", "en-US", 0)).toContain(
+      'class="tooltip">€9',
+    );
+    expect(await renderCards("EUR", "en-US", 3)).toContain(
+      'class="tooltip">€9.391',
+    );
+  });
+});

package/frontend-vue/tests/command-palette-search-text.test.ts

@@ -0,0 +1,118 @@
+import { highlight } from "@nuxt/ui/utils/search";
+import { describe, expect, it } from "vitest";
+import { resolveOptionalI18nKey } from "../layers/dms-core/app/composables/translation/useTranslation";
+import {
+  COMMAND_PALETTE_SEARCH_TEXT_KEY,
+  hideSearchTextMatches,
+} from "../layers/dms-layout/app/composables/useCommandPaletteSources";
+
+const MESSAGES: Record<string, string> = {
+  "settings.billing.description": "Manage your plan and invoices",
+};
+
+function translate(key: string): string {
+  return MESSAGES[key] ?? key;
+}
+
+function item(matchedKeys: string[]) {
+  return {
+    label: "Billing",
+    suffix: "Settings",
+    matches: matchedKeys.map((key) => ({ key, value: "match" })),
+  };
+}
+
+// Recorded from Fuse while searching "shareable" against a page whose title
+// does not contain the term, so the contract test below runs on the shape the
+// palette really produces. `highlight` renders the first match whose key is not
+// the palette's `labelKey` (`label` by default) as the item suffix.
+const SEARCH_TEXT_MATCH = {
+  key: COMMAND_PALETTE_SEARCH_TEXT_KEY,
+  value: "Tabs with URL persistence for shareable links",
+  indices: [[30, 38]] as [number, number][],
+};
+const PALETTE_LABEL_KEY = "label";
+
+describe("resolveOptionalI18nKey", () => {
+  it("translates a prefixed key", () => {
+    expect(
+      resolveOptionalI18nKey(translate, "$settings.billing.description"),
+    ).to.equal("Manage your plan and invoices");
+  });
+
+  it("returns a plain string verbatim", () => {
+    expect(resolveOptionalI18nKey(translate, "Manage invoices")).to.equal(
+      "Manage invoices",
+    );
+  });
+
+  it("returns undefined for an untranslated key", () => {
+    expect(
+      resolveOptionalI18nKey(translate, "$settings.billing.missing"),
+    ).to.equal(undefined);
+  });
+
+  it("returns undefined when there is nothing to resolve", () => {
+    expect(resolveOptionalI18nKey(translate, undefined)).to.equal(undefined);
+    expect(resolveOptionalI18nKey(translate, "")).to.equal(undefined);
+  });
+});
+
+describe("hideSearchTextMatches", () => {
+  it("drops search text matches so they cannot render as a suffix", () => {
+    const group = hideSearchTextMatches({ id: "navigation" });
+    const [filtered] = group.postFilter!("plan", [
+      item([COMMAND_PALETTE_SEARCH_TEXT_KEY]),
+    ]);
+
+    expect(filtered!.matches).to.deep.equal([]);
+  });
+
+  it("keeps matches on rendered keys", () => {
+    const group = hideSearchTextMatches({ id: "navigation" });
+    const [filtered] = group.postFilter!("settings", [
+      item(["suffix", COMMAND_PALETTE_SEARCH_TEXT_KEY]),
+    ]);
+
+    expect(filtered!.matches).to.deep.equal([
+      { key: "suffix", value: "match" },
+    ]);
+  });
+
+  it("keeps the hidden text out of the suffix Nuxt UI renders", () => {
+    const matched = {
+      label: "Persistent Tabs",
+      suffix: "Pages › Layout › Tabs",
+    };
+    const leaked = highlight(
+      { ...matched, matches: [SEARCH_TEXT_MATCH] },
+      "shareable",
+      undefined,
+      [PALETTE_LABEL_KEY],
+    );
+    expect(leaked).to.contain("<mark>shareable</mark>");
+
+    const [guarded] = hideSearchTextMatches({ id: "navigation" }).postFilter!(
+      "shareable",
+      [{ ...matched, matches: [SEARCH_TEXT_MATCH] }],
+    );
+
+    expect(
+      highlight(guarded!, "shareable", undefined, [PALETTE_LABEL_KEY]),
+    ).to.equal(undefined);
+  });
+
+  it("runs after the group's own filter", () => {
+    const group = hideSearchTextMatches({
+      id: "navigation",
+      postFilter: (_searchTerm, items) => items.slice(1),
+    });
+    const filtered = group.postFilter!("plan", [
+      item(["label"]),
+      item([COMMAND_PALETTE_SEARCH_TEXT_KEY]),
+    ]);
+
+    expect(filtered).to.have.length(1);
+    expect(filtered[0]!.matches).to.deep.equal([]);
+  });
+});

package/frontend-vue/tests/dev-reload.test.ts

@@ -0,0 +1,252 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  createDevReloadCoordinator,
+  type DevReloadDeps,
+} from "../layers/dms-layout/app/composables/useDevReload";
+
+/**
+ * The dev-reload coordinator is the single mechanism behind both the SSE
+ * `reload` handler and the `useDmsDevReload().awaitRoute` module frontends
+ * call. These tests drive the real implementation with fake dependencies and a
+ * virtual clock: `delay` never waits, it just moves `now` forward, so a
+ * timeout is reached in as many iterations as the real one would take.
+ */
+
+interface Harness {
+  deps: DevReloadDeps;
+  /** Routes the backend serves right now. */
+  backend: Set<string>;
+  /** Routes the committed site layout serves right now. */
+  committed: Set<string>;
+  probes: number;
+  reloadingLog: boolean[];
+  commits: number;
+  derivedFor: string[];
+  clearedFor: string[];
+  /** Virtual milliseconds burnt by the coordinator's own waiting. */
+  elapsed: () => number;
+}
+
+function createHarness(
+  overrides: Partial<DevReloadDeps> & {
+    /** Probes the backend answers with "route absent" before serving it. */
+    probesBeforeServed?: number;
+  } = {},
+): Harness {
+  const { probesBeforeServed = 0, ...depOverrides } = overrides;
+  let time = 0;
+  const harness: Harness = {
+    deps: undefined as unknown as DevReloadDeps,
+    backend: new Set<string>(),
+    committed: new Set<string>(),
+    probes: 0,
+    reloadingLog: [],
+    commits: 0,
+    derivedFor: [],
+    clearedFor: [],
+    elapsed: () => time,
+  };
+
+  harness.deps = {
+    isDev: true,
+    currentPath: () => "/current",
+    isRouteKnown: (path) => harness.committed.has(path),
+    probeAndCommitRoute: (path) => {
+      harness.probes += 1;
+      if (harness.probes <= probesBeforeServed || !harness.backend.has(path)) {
+        return Promise.resolve(false);
+      }
+      harness.committed = new Set(harness.backend);
+      return Promise.resolve(true);
+    },
+    commitLayout: () => {
+      harness.commits += 1;
+      harness.committed = new Set(harness.backend);
+      return Promise.resolve();
+    },
+    refreshDerived: (path) => {
+      harness.derivedFor.push(path);
+      return Promise.resolve();
+    },
+    clearTransient404: (path) => {
+      harness.clearedFor.push(path);
+    },
+    setReloading: (value) => {
+      harness.reloadingLog.push(value);
+    },
+    now: () => time,
+    delay: async (ms) => {
+      time += ms;
+      await Promise.resolve();
+    },
+    ...depOverrides,
+  };
+
+  return harness;
+}
+
+describe("dev reload coordinator", () => {
+  let harness: Harness;
+
+  beforeEach(() => {
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+    vi.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  describe("awaitRoute", () => {
+    it("answers from the committed layout without probing the backend", async () => {
+      harness = createHarness();
+      harness.committed.add("/pages/a");
+      const coordinator = createDevReloadCoordinator(harness.deps);
+
+      await expect(coordinator.awaitRoute("/pages/a")).resolves.toBe(true);
+      // Nothing to wait for: no fetch, and no reload flag raised for a
+      // no-op — the reload must stay invisible.
+      expect(harness.probes).toBe(0);
+      expect(harness.reloadingLog).toEqual([]);
+    });
+
+    it("holds until the re-registering backend serves the route", async () => {
+      harness = createHarness({ probesBeforeServed: 3 });
+      harness.backend.add("/pages/new");
+      const coordinator = createDevReloadCoordinator(harness.deps);
+
+      await expect(coordinator.awaitRoute("/pages/new")).resolves.toBe(true);
+      expect(harness.probes).toBe(4);
+      expect(harness.committed.has("/pages/new")).toBe(true);
+      // The layout is committed by the probe itself, so the route the caller
+      // asked for is the one that got validated.
+      expect(harness.commits).toBe(0);
+    });
+
+    it("resolves false when the route never comes back", async () => {
+      harness = createHarness();
+      const coordinator = createDevReloadCoordinator(harness.deps);
+
+      await expect(coordinator.awaitRoute("/pages/gone")).resolves.toBe(false);
+      // Timing out still commits whatever the backend has now, so a genuinely
+      // deleted page reaches the renderer and 404s there.
+      expect(harness.commits).toBe(1);
+      expect(harness.clearedFor).toEqual([]);
+    });
+
+    it("honours a caller-supplied timeout", async () => {
+      harness = createHarness();
+      const coordinator = createDevReloadCoordinator(harness.deps);
+
+      await expect(
+        coordinator.awaitRoute("/pages/gone", { timeoutMs: 600 }),
+      ).resolves.toBe(false);
+      expect(harness.elapsed()).toBeLessThan(1000);
+    });
+
+    it("joins an in-flight refresh instead of racing a second fetch loop", async () => {
+      harness = createHarness({ probesBeforeServed: 4 });
+      harness.backend.add("/current");
+      const coordinator = createDevReloadCoordinator(harness.deps);
+
+      const refresh = coordinator.requestRefresh("/current");
+      const waited = coordinator.awaitRoute("/current");
+
+      await expect(waited).resolves.toBe(true);
+      await refresh;
+      // One loop, not two: the probe count is the one the SSE refresh needed.
+      expect(harness.probes).toBe(5);
+    });
+
+    it("clears the transient 404 once the route is committed", async () => {
+      harness = createHarness({ probesBeforeServed: 1 });
+      harness.backend.add("/current");
+      const coordinator = createDevReloadCoordinator(harness.deps);
+
+      await coordinator.awaitRoute("/current");
+      expect(harness.clearedFor).toEqual(["/current"]);
+    });
+  });
+
+  describe("awaitRoute outside dev", () => {
+    it("never probes and only reads the committed layout", async () => {
+      harness = createHarness({ isDev: false });
+      harness.backend.add("/pages/a");
+      const coordinator = createDevReloadCoordinator(harness.deps);
+
+      await expect(coordinator.awaitRoute("/pages/a")).resolves.toBe(false);
+      expect(harness.probes).toBe(0);
+      expect(harness.commits).toBe(0);
+      expect(harness.reloadingLog).toEqual([]);
+    });
+
+    it("resolves true when a refresh driven elsewhere commits the route", async () => {
+      harness = createHarness({ isDev: false });
+      const coordinator = createDevReloadCoordinator(harness.deps);
+      let reads = 0;
+      harness.deps.isRouteKnown = (path) => {
+        reads += 1;
+        return reads > 3 && path === "/pages/a";
+      };
+
+      await expect(coordinator.awaitRoute("/pages/a")).resolves.toBe(true);
+    });
+
+    it("caps the wait well short of the dev timeout", async () => {
+      harness = createHarness({ isDev: false });
+      const coordinator = createDevReloadCoordinator(harness.deps);
+
+      await expect(
+        coordinator.awaitRoute("/pages/a", { timeoutMs: 60000 }),
+      ).resolves.toBe(false);
+      expect(harness.elapsed()).toBeLessThan(3000);
+    });
+  });
+
+  describe("requestRefresh", () => {
+    it("coalesces a burst into a single trailing re-run on the current route", async () => {
+      harness = createHarness();
+      harness.backend.add("/pages/a");
+      harness.backend.add("/current");
+      const coordinator = createDevReloadCoordinator(harness.deps);
+
+      const first = coordinator.requestRefresh("/pages/a");
+      const second = coordinator.requestRefresh("/pages/a");
+      expect(second).toBe(first);
+      coordinator.requestRefresh("/pages/a");
+
+      await coordinator.settled();
+      // Two passes for three events, and the trailing one re-reads the route
+      // the user is on rather than the stale path captured at burst time.
+      expect(harness.derivedFor).toEqual(["/pages/a", "/current"]);
+    });
+
+    it("keeps the reload flag raised across the trailing re-run", async () => {
+      harness = createHarness();
+      harness.backend.add("/current");
+      const coordinator = createDevReloadCoordinator(harness.deps);
+
+      const first = coordinator.requestRefresh("/current");
+      coordinator.requestRefresh("/current");
+      await first;
+      await coordinator.settled();
+
+      // Never lowered between the two passes: a flicker there would let the
+      // renderer raise the 404 the reload is about to fix.
+      expect(harness.reloadingLog).toEqual([true, true, false]);
+    });
+
+    it("lowers the reload flag when a pass throws", async () => {
+      harness = createHarness({
+        commitLayout: () => Promise.reject(new Error("backend down")),
+      });
+      const coordinator = createDevReloadCoordinator(harness.deps);
+
+      await expect(coordinator.requestRefresh("/pages/a")).resolves.toBe(false);
+      expect(harness.reloadingLog).toEqual([true, false]);
+    });
+
+    it("settles immediately when nothing is in flight", async () => {
+      harness = createHarness();
+      const coordinator = createDevReloadCoordinator(harness.deps);
+
+      await expect(coordinator.settled()).resolves.toBeUndefined();
+    });
+  });
+});

package/frontend-vue/tests/file-constraints.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import {
+  checkFileConstraints,
+  type FileFieldConstraints,
+  matchMimetype,
+} from "../layers/dms-ui/app/utils/fileConstraints";
+
+function fakeFile(type: string, size: number): File {
+  return { type, size, name: "sample" } as File;
+}
+
+describe("matchMimetype", () => {
+  it("matches an exact mimetype", () => {
+    expect(matchMimetype("image/png", "image/png")).to.equal(true);
+  });
+
+  it("matches a trailing wildcard pattern", () => {
+    expect(matchMimetype("image/png", "image/*")).to.equal(true);
+  });
+
+  it("rejects a mimetype outside a wildcard pattern", () => {
+    expect(matchMimetype("application/pdf", "image/*")).to.equal(false);
+  });
+
+  it("rejects a different exact mimetype", () => {
+    expect(matchMimetype("image/png", "image/jpeg")).to.equal(false);
+  });
+});
+
+describe("checkFileConstraints", () => {
+  it("accepts any file when no constraints are configured", () => {
+    expect(
+      checkFileConstraints(fakeFile("application/x-foo", 10_000)),
+    ).to.equal(null);
+  });
+
+  it("accepts a file within size and mimetype constraints", () => {
+    const constraints: FileFieldConstraints = {
+      maxSize: 1024,
+      allowedMimetypes: ["image/*"],
+    };
+    expect(
+      checkFileConstraints(fakeFile("image/png", 512), constraints),
+    ).to.equal(null);
+  });
+
+  it("reports a size violation before a mimetype violation", () => {
+    const constraints: FileFieldConstraints = {
+      maxSize: 1024,
+      allowedMimetypes: ["image/*"],
+    };
+    expect(
+      checkFileConstraints(fakeFile("application/pdf", 4096), constraints),
+    ).to.equal("size");
+  });
+
+  it("reports a mimetype violation", () => {
+    const constraints: FileFieldConstraints = {
+      allowedMimetypes: ["image/png", "image/jpeg"],
+    };
+    expect(
+      checkFileConstraints(fakeFile("application/pdf", 512), constraints),
+    ).to.equal("mimetype");
+  });
+
+  it("accepts everything when allowedMimetypes is empty", () => {
+    const constraints: FileFieldConstraints = { allowedMimetypes: [] };
+    expect(
+      checkFileConstraints(fakeFile("application/pdf", 512), constraints),
+    ).to.equal(null);
+  });
+});