@antelopejs/dms 0.8.2 → 0.9.0

package/frontend-vue/layers/dms-ui/app/composables/useFileReadUrls.ts

@@ -1,105 +1,17 @@
-import { FORM_CONTENT_LANGUAGE_KEY } from "./form/types/content-language";
-
-interface FileMetadataUrlResponse {
-  url: string;
-  expiresAt?: number;
-}
-
-type CachedFileReadUrl = FileMetadataUrlResponse;
-
-const URL_REFRESH_LEAD_MS = 5000;
-const RETRY_DELAY_MS = 5000;
+import { useFileMetadata } from "../build/composables/files/useFileMetadata";
 
 /**
  * Resolves stored file resource keys to read URLs through
- * `/api/files/metadata`. Expiring URLs refresh while visible, and failed
- * lookups remain retryable instead of permanently hiding the file.
+ * `/api/files/metadata`. A key resolved during the setup (an immediate
+ * watcher) is read with the page, the server render included; expiring URLs
+ * refresh while visible, and failed lookups that may heal are retried
+ * instead of permanently hiding the file.
  */
 export function useFileReadUrls(storage?: string) {
-  const { $authFetch } = useAuthFetch();
-  const contentLanguage = inject(FORM_CONTENT_LANGUAGE_KEY, undefined);
-  const urls = ref<Map<string, CachedFileReadUrl>>(new Map());
-  const pendingKeys = new Set<string>();
-  const refreshTimers = new Map<string, ReturnType<typeof setTimeout>>();
-  let isDisposed = false;
-
-  function isFresh(metadata: CachedFileReadUrl): boolean {
-    return (
-      metadata.expiresAt === undefined ||
-      metadata.expiresAt - URL_REFRESH_LEAD_MS > Date.now()
-    );
-  }
-
-  function scheduleRefresh(key: string, expiresAt?: number): void {
-    if (isDisposed || import.meta.env.SSR) return;
-    const currentTimer = refreshTimers.get(key);
-    if (currentTimer) clearTimeout(currentTimer);
-    if (expiresAt === undefined) return;
-    const remaining = Math.max(expiresAt - Date.now(), 0);
-    const refreshLead = Math.min(URL_REFRESH_LEAD_MS, remaining / 2);
-    const delay = Math.max(remaining - refreshLead, 0);
-    refreshTimers.set(
-      key,
-      setTimeout(() => resolve(key, true), delay),
-    );
-  }
-
-  async function resolve(key: string, force = false): Promise<void> {
-    if (isDisposed) return;
-    const cached = urls.value.get(key);
-    if (!force && cached && isFresh(cached)) return;
-    if (pendingKeys.has(key)) return;
-
-    pendingKeys.add(key);
-    try {
-      const metadata = await $authFetch<FileMetadataUrlResponse>(
-        "/api/files/metadata",
-        {
-          query: { resourceKey: key, storage },
-          headers: contentLanguage
-            ? { [CONTENT_LANGUAGE_HEADER]: contentLanguage }
-            : undefined,
-        },
-      );
-      if (isDisposed) return;
-      urls.value.set(key, metadata);
-      scheduleRefresh(key, metadata.expiresAt);
-    } catch {
-      if (isDisposed) return;
-      if (cached?.expiresAt !== undefined && cached.expiresAt <= Date.now()) {
-        urls.value.delete(key);
-      } else if (cached?.expiresAt !== undefined) {
-        scheduleRefresh(key, cached.expiresAt);
-      }
-      if (
-        !import.meta.env.SSR &&
-        (!cached ||
-          (cached.expiresAt !== undefined && cached.expiresAt <= Date.now()))
-      ) {
-        refreshTimers.set(
-          key,
-          setTimeout(() => resolve(key, true), RETRY_DELAY_MS),
-        );
-      }
-    }
-    pendingKeys.delete(key);
-  }
-
-  function getUrl(key: string): string | undefined {
-    const metadata = urls.value.get(key);
-    if (
-      !metadata ||
-      (metadata.expiresAt !== undefined && metadata.expiresAt <= Date.now())
-    ) {
-      return undefined;
-    }
-    return metadata.url;
-  }
-
-  onScopeDispose(() => {
-    isDisposed = true;
-    refreshTimers.forEach(clearTimeout);
-  });
-
-  return { getUrl, resolve };
+  const files = useFileMetadata(storage);
+  return {
+    /** The URL to show `key` with, until it expires; undefined until read. */
+    getUrl: (key: string): string | undefined => files.metadata(key)?.url,
+    resolve: (key: string): Promise<void> => files.resolve(key),
+  };
 }

package/frontend-vue/layers/dms-ui/app/utils/blockRefresh.ts

@@ -11,6 +11,15 @@ export const BLOCK_REFRESH_EVENT = "DmsComponent.Block.Refresh";
  */
 export const LIVE_BLOCK_REFRESH_EVENT = "DmsComponent.Block.LiveRefresh";
 
+/**
+ * The detail of a `refreshPageBlocks()` event: a listener whose refresh
+ * takes time hands its promise to `waitUntil`, and the call resolves once
+ * every one settled.
+ */
+export interface PageBlocksRefreshDetail {
+  waitUntil(work: Promise<unknown>): void;
+}
+
 /** The watch functions every block can name (see interface-dms). */
 export const BlockFunctions = {
   REFRESH_PAGE: "DmsComponent.Block.RefreshPage",
@@ -23,10 +32,30 @@ export const BlockFunctions = {
  * through `BlockFunctions.REFRESH_PAGE` once it saved. A user action always
  * refreshes: on a page declared with `live` it reads even while paused, and
  * the blocks it reads no longer count what they had missed.
+ *
+ * @returns Resolves once the page's data refresh (its `useApiData` reads)
+ *   is done, failed reads included: they keep their `error`
  */
-export function refreshPageBlocks(): void {
-  if (typeof window === "undefined") return;
-  window.dispatchEvent(new CustomEvent(BLOCK_REFRESH_EVENT));
+export function refreshPageBlocks(): Promise<void> {
+  if (typeof window === "undefined") return Promise.resolve();
+  const pending: Array<Promise<unknown>> = [];
+  const detail: PageBlocksRefreshDetail = {
+    waitUntil: (work) => void pending.push(work),
+  };
+  window.dispatchEvent(new CustomEvent(BLOCK_REFRESH_EVENT, { detail }));
+  return Promise.allSettled(pending).then(() => undefined);
+}
+
+/**
+ * Has `refreshPageBlocks()` wait for `work` too, when `event` is one of its
+ * events.
+ */
+export function waitForPageBlocksRefresh(
+  event: Event,
+  work: Promise<unknown>,
+): void {
+  const detail = (event as CustomEvent<PageBlocksRefreshDetail | null>).detail;
+  detail?.waitUntil(work);
 }
 
 /**

package/frontend-vue/package.json

@@ -11,7 +11,7 @@
   "license": "Apache-2.0",
   "packageManager": "pnpm@10.6.5",
   "engines": {
-    "@antelopejs/dms-frontend": ">=0.5.2 <0.6.0"
+    "@antelopejs/dms-frontend": ">=0.6.0 <0.7.0"
   },
   "scripts": {
     "typecheck": "ajs dms verify-source --layer \"$PWD\" --local-package @antelopejs/dms=.. --local-package @antelopejs/interface-dms=../../interface-dms",
@@ -74,7 +74,7 @@
   },
   "devDependencies": {
     "@antelopejs/core": ">=1.13.4 <2",
-    "@antelopejs/dms-frontend": ">=0.5.6 <0.6.0",
+    "@antelopejs/dms-frontend": ">=0.6.0 <0.7.0",
     "@eslint/js": "^8.57.0",
     "@inertiajs/vue3": "^3.7.0",
     "@nuxt/ui": "4.10.0",

package/frontend-vue/pnpm-lock.yaml

@@ -160,8 +160,8 @@ importers:
         specifier: '>=1.13.4 <2'
         version: 1.13.5
       '@antelopejs/dms-frontend':
-        specifier: '>=0.5.6 <0.6.0'
-        version: 0.5.6(@antelopejs/core@1.13.5)
+        specifier: '>=0.6.0 <0.7.0'
+        version: 0.6.0(@antelopejs/core@1.13.5)
       '@eslint/js':
         specifier: ^8.57.0
         version: 8.57.0
@@ -237,8 +237,8 @@ packages:
     engines: {node: '>=20.19'}
     hasBin: true
 
-  '@antelopejs/dms-frontend@0.5.6':
-    resolution: {integrity: sha512-bO7kacKMF1rVsIjS208rhPUoIxRYss6ZuQCdQ1Kpq5D3pG0qSvF2pNsi+WecvxTOKM8d6AQAoLl5facu5tyHFQ==}
+  '@antelopejs/dms-frontend@0.6.0':
+    resolution: {integrity: sha512-1514XxAK7qPRdOrGDd4/lJ8Xo9Fq9nMUY+7HZe1isRTbuwkJoFiUUHsssICm5hWeTWtuTEtLe+Pwe6wHokYSaA==}
     engines: {node: '>=20.12.0'}
     hasBin: true
     peerDependencies:
@@ -4208,7 +4208,7 @@ snapshots:
       semver: 7.8.5
       typescript: 5.9.3
 
-  '@antelopejs/dms-frontend@0.5.6(@antelopejs/core@1.13.5)':
+  '@antelopejs/dms-frontend@0.6.0(@antelopejs/core@1.13.5)':
     dependencies:
       '@antelopejs/core': 1.13.5
       chokidar: 4.0.3

package/frontend-vue/server/private-options.ts

@@ -0,0 +1,27 @@
+import type { DmsServerEvent } from "#dms/server";
+
+/**
+ * A secret of the DMS's private options, as the frontend server hands them
+ * to its routes. The manifest's value wins; the environment variable of the
+ * same secret is the fallback, read only when the manifest holds none. A
+ * frontend built without the bootstrap credential gets no private options at
+ * all, so the environment variable alone configures it there.
+ *
+ * @param event The route's event
+ * @param section The private options' section (`htmlRender`, `oauth`)
+ * @param key The secret's key in it
+ * @param variable The environment variable that configures it
+ */
+export function privateSecret(
+  event: DmsServerEvent,
+  section: string,
+  key: string,
+  variable: string,
+): string | undefined {
+  const options = event.module.privateOptions[section] as
+    | Record<string, unknown>
+    | undefined;
+  const value = options?.[key];
+  if (typeof value === "string" && value) return value;
+  return process.env[variable] || undefined;
+}

package/frontend-vue/tests/async-data-scope.test.ts

@@ -0,0 +1,121 @@
+// @vitest-environment jsdom
+/**
+ * Every key of the async data lives in the scope of the session's account and
+ * workspace: the browser finds what the server transferred under the same
+ * scope, and a switch of account or workspace drops the previous session's
+ * data instead of showing it under the new one.
+ */
+import {
+  type App,
+  createApp,
+  createSSRApp,
+  defineComponent,
+  h,
+  nextTick,
+  Suspense,
+} from "vue";
+import { renderToString } from "vue/server-renderer";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { DmsFrontendRuntime } from "#dms/frontend-module";
+import { asyncDataScopeOf } from "../layers/dms-core/app/build/utils/asyncDataScope";
+
+const engine = await import("#dms/frontend-module");
+const { default: asyncDataScopePlugin } = await import(
+  "../layers/dms-core/app/plugins/async-data-scope"
+);
+
+const ACCOUNT_A = { accountId: "account-a", activeTenantId: "tenant-1" };
+const ACCOUNT_B = { accountId: "account-b", activeTenantId: "tenant-1" };
+
+const handler = vi.fn(async () => "orders of account A");
+
+const Page = defineComponent({
+  async setup() {
+    const { data } = await engine.useDmsAsyncData("orders", handler);
+    return () => h("p", data.value ?? "none");
+  },
+});
+
+const Root = defineComponent({
+  setup: () => () => h(Suspense, null, { default: () => h(Page) }),
+});
+
+const mounted: App[] = [];
+
+function start(app: App, runtime: DmsFrontendRuntime, session: object) {
+  engine.provideDmsFrontendRuntime(app, runtime);
+  app.runWithContext(() => {
+    engine.useDmsState("dms-session", () => null).value = session;
+    void asyncDataScopePlugin({} as never);
+  });
+}
+
+async function settle(): Promise<void> {
+  await nextTick();
+  await new Promise((done) => setTimeout(done, 0));
+}
+
+beforeEach(async () => {
+  handler.mockClear();
+  await engine.setupFrontendModules([]);
+});
+
+afterEach(() => {
+  mounted.splice(0).forEach((app) => app.unmount());
+});
+
+describe("the async data scope", () => {
+  it("is a digest of the account and the workspace, none when signed out", () => {
+    const scope = asyncDataScopeOf(ACCOUNT_A);
+    expect(scope).toMatch(/^[0-9a-z]+$/);
+    expect(scope).not.toContain("account-a");
+    expect(asyncDataScopeOf({ ...ACCOUNT_A })).toBe(scope);
+    expect(asyncDataScopeOf(ACCOUNT_B)).not.toBe(scope);
+    expect(
+      asyncDataScopeOf({ ...ACCOUNT_A, activeTenantId: "tenant-2" }),
+    ).not.toBe(scope);
+    expect(asyncDataScopeOf(null)).toBeUndefined();
+    expect(asyncDataScopeOf({})).toBeUndefined();
+  });
+
+  it("hands the server's data to the browser under the same session", async () => {
+    const server = engine.createDmsFrontendRuntime(undefined, {}, true);
+    const serverApp = createSSRApp(Root);
+    start(serverApp, server, ACCOUNT_A);
+    expect(await renderToString(serverApp)).toBe("<p>orders of account A</p>");
+    const payload = structuredClone(engine.serializeDmsPayload(server));
+    expect(JSON.stringify(payload)).not.toContain("account-a");
+
+    handler.mockClear();
+    const browser = engine.createDmsFrontendRuntime(undefined, {});
+    const browserApp = createApp(Root);
+    start(browserApp, browser, ACCOUNT_A);
+    engine.restoreDmsPayload(browser, payload);
+    const host = document.createElement("div");
+    browserApp.mount(host);
+    mounted.push(browserApp);
+    await settle();
+
+    expect(handler).not.toHaveBeenCalled();
+    expect(host.textContent).toBe("orders of account A");
+  });
+
+  it("drops the previous account's data once the session switches", async () => {
+    const browser = engine.createDmsFrontendRuntime(undefined, {});
+    const browserApp = createApp(Root);
+    start(browserApp, browser, ACCOUNT_A);
+    const host = document.createElement("div");
+    browserApp.mount(host);
+    mounted.push(browserApp);
+    await settle();
+    expect(host.textContent).toBe("orders of account A");
+
+    browserApp.runWithContext(() => {
+      engine.useDmsState("dms-session", () => null).value = ACCOUNT_B;
+    });
+    await settle();
+
+    expect(browser.asyncData.size).toBe(0);
+    expect(host.textContent).toBe("none");
+  });
+});

package/frontend-vue/tests/auth-middleware-error.test.ts

@@ -8,14 +8,14 @@ const navigateDms = vi.fn();
 beforeEach(() => {
   vi.resetModules();
   vi.stubGlobal("defineDmsMiddleware", (handler: Middleware) => handler);
-  vi.stubGlobal("useError", () => pageError);
-  vi.stubGlobal("abortNavigation", () => false);
+  vi.stubGlobal("useDmsError", () => pageError);
+  vi.stubGlobal("abortDmsNavigation", () => false);
   vi.stubGlobal("navigateDms", navigateDms);
   vi.stubGlobal("useSiteLayout", () => ({
     siteLayout: { value: {} },
     findMatchingRoute: () => ({ metadata: {} }),
   }));
-  vi.stubGlobal("useUserSession", () => ({ loggedIn: { value: false } }));
+  vi.stubGlobal("useDmsUserSession", () => ({ loggedIn: { value: false } }));
 });
 
 afterEach(() => {

package/frontend-vue/tests/banner-block-fetch.test.ts

@@ -7,6 +7,7 @@
  */
 import { createApp, defineComponent, h, reactive, ref } from "vue";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import { refreshPageBlocks } from "../layers/dms-ui/app/utils/blockRefresh";
 
 const requests: string[] = [];
@@ -93,6 +94,8 @@ function mountBanner(props: Record<string, unknown>) {
   };
 }
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   requests.length = 0;
   pressed.length = 0;

package/frontend-vue/tests/block-fetch-options-forwarding.test.ts

@@ -6,6 +6,7 @@
 import { type Component, createSSRApp, defineComponent, h, ref } from "vue";
 import { renderToString } from "vue/server-renderer";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import type { UseChartFetchOptions } from "../layers/dms-ui/app/composables/chart/useChartFetch";
 
 const fetchOptions: Array<UseChartFetchOptions<unknown>> = [];
@@ -78,6 +79,8 @@ async function render(block: Component): Promise<void> {
   await renderToString(app);
 }
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   fetchOptions.length = 0;
   vi.stubGlobal("useI18n", () => ({ locale: ref("en-GB"), t: String }));

package/frontend-vue/tests/block-items-period-realtime.test.ts

@@ -7,6 +7,7 @@
  */
 import { createApp, defineComponent, h, nextTick, reactive, ref } from "vue";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import type { RealtimeTopicHandler } from "../layers/dms-core/app/composables/realtime/useUserRealtime";
 
 const requests: string[] = [];
@@ -106,6 +107,8 @@ function mountRealtimeBlock(probe: ItemsProbe) {
   mounted.push(app);
 }
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   requests.length = 0;
   revision = 1;

package/frontend-vue/tests/block-not-found.test.ts

@@ -16,6 +16,7 @@ import {
   ref,
 } from "vue";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import { readFetchNotFound } from "../layers/dms-ui/app/build/utils/fetchNotFound";
 
 interface FetchFailure extends Error {
@@ -92,6 +93,8 @@ function mount(component: Component): HTMLElement {
   return host;
 }
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   answers.clear();
   route.query = { workspace: "web" };
@@ -157,12 +160,23 @@ describe("useChartFetch on a 404", () => {
     );
   });
 
-  it("keeps them on any other failure", async () => {
+  it("keeps them when a read of the same request fails otherwise", async () => {
     const state = mountFetch();
     await settle();
-    await switchWorkspace("down");
+    answers.set("/api/kpis?workspace=web", failure(500));
+    await state.refresh?.();
+    await settle();
     expect(state.data?.value).toEqual({ items: [{ label: "web" }] });
   });
+
+  it("never shows a record's values for another request that failed", async () => {
+    // They belong to another workspace: the card shows its failure instead.
+    const state = mountFetch();
+    await settle();
+    await switchWorkspace("down");
+    expect(state.data?.value).toBeNull();
+    expect(state.error?.value).toBeTruthy();
+  });
 });
 
 describe("useBlockItems on a 404", () => {

package/frontend-vue/tests/block-page-refresh.test.ts

@@ -7,6 +7,7 @@
  */
 import { createApp, defineComponent, h, ref } from "vue";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import {
   BlockFunctions,
   refreshPageBlocks,
@@ -64,6 +65,8 @@ function mountBlock(fetchUrl: string) {
 
 const apps: Array<() => void> = [];
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   requests.length = 0;
   answer = 1;

package/frontend-vue/tests/block-route-params.test.ts

@@ -15,6 +15,7 @@ import {
   ref,
 } from "vue";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import {
   replaceUrlVariables,
   resolveTextVariables,
@@ -59,6 +60,8 @@ function mount(component: Component) {
   mounted.push(app);
 }
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   requests.length = 0;
   route.query = {};

package/frontend-vue/tests/branding-defaults.test.ts

@@ -0,0 +1,34 @@
+import { defu } from "defu";
+import { describe, expect, it } from "vitest";
+import appConfig from "../layers/dms-layout/app/app.config";
+
+const ANTELOPE_ICON = "/images/antelope-logo/icon.svg";
+
+describe("branding defaults", () => {
+  it("hold the palettes and logos the layout ships", () => {
+    expect(appConfig.branding.defaults).toEqual({
+      colors: appConfig.ui.colors,
+      logo: appConfig.branding.logo,
+    });
+    expect(appConfig.branding.defaults.colors.primary).toBe("dms");
+    expect(appConfig.branding.logo.favicon).toEqual({
+      light: ANTELOPE_ICON,
+      dark: ANTELOPE_ICON,
+    });
+  });
+
+  it("survive a live edit of the merged palette and logos", () => {
+    // A clone keeps any object shared between the two places, like the
+    // loader's merge keeps the objects no layer overrides.
+    const merged = defu(
+      { branding: { footer: { githubStar: false } } },
+      structuredClone(appConfig),
+    );
+
+    merged.ui.colors.primary = "violet";
+    merged.branding.logo.favicon!.light = "/branding/icon.png";
+
+    expect(merged.branding.defaults.colors.primary).toBe("dms");
+    expect(merged.branding.defaults.logo.favicon?.light).toBe(ANTELOPE_ICON);
+  });
+});

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

@@ -4,6 +4,7 @@ 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;
@@ -17,6 +18,10 @@ const emailModules = import.meta.glob<EmailModule>(
 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",
@@ -41,6 +46,11 @@ function element(tag: string) {
   });
 }
 
+/** 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;
 }
@@ -56,11 +66,11 @@ const EMAIL_PROPS = {
 
 async function renderEmail(
   component: Component,
-  logo: string,
+  logo: string | Partial<DmsBrandingLogo>,
   locale = "en",
 ): Promise<string> {
   vi.stubGlobal("useDmsAppConfig", () => ({
-    branding: { logo: { default: { light: logo } } },
+    branding: { logo: brandingLogo(logo) },
   }));
   vi.stubGlobal("useDmsRuntimeConfig", () => ({
     public: { dms: { clientBaseUrl: PUBLIC_BASE } },
@@ -100,6 +110,17 @@ describe("built-in emails", () => {
     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");

package/frontend-vue/tests/chart-live-pause.test.ts

@@ -4,7 +4,8 @@
  * refresh, and reads once when the page resumes.
  */
 import { createApp, defineComponent, h, ref } from "vue";
-import { afterEach, expect, it, vi } from "vitest";
+import { beforeEach, afterEach, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import {
   refreshLivePageBlocks,
   refreshPageBlocks,
@@ -39,6 +40,8 @@ afterEach(() => {
   window.localStorage.clear();
 });
 
+beforeEach(() => useRealDataEngine());
+
 it("requests nothing while paused and reads once on resume", async () => {
   const live = createPageLiveController("api.overview", {});
   setCurrentPageLive(live);

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

@@ -1,6 +1,7 @@
 import { createSSRApp, defineComponent, h, ref, type PropType } from "vue";
 import { renderToString } from "vue/server-renderer";
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, afterEach, describe, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 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";
@@ -119,6 +120,8 @@ async function renderCards(
 
 afterEach(() => vi.unstubAllGlobals());
 
+beforeEach(() => useRealDataEngine());
+
 describe("card → nested chart → Apex format propagation", () => {
   it.each(["EUR", "JPY", "KWD"])(
     "propagates native %s formatting to headline, comparison, axis, tooltip and list",

package/frontend-vue/tests/composed-text-blocks.test.ts

@@ -13,6 +13,7 @@ import {
   type Component,
 } from "vue";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import { createI18n } from "vue-i18n";
 import { setRegionalPreferencesSource } from "../layers/dms-core/app/utils/regional";
 
@@ -118,6 +119,8 @@ const seats = (value: number) => ({
   params: { count: { type: "count", value } },
 });
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   i18n.global.locale.value = "en";
   fetchedItems = [];