@antelopejs/dms-frontend 0.8.0 → 0.9.1

package/templates/vue/network-error.ts

@@ -18,7 +18,9 @@ const NETWORK_ERROR_KEY = "error.network";
 const DEFAULT_LOCALE = "en";
 // Shipped with the renderer, since no module is guaranteed to translate the
 // case; a module overrides them with `error.network.title` and
-// `error.network.description` in its own locale files.
+// `error.network.description` in its own locale files. `te()` reads the
+// visitor's locale alone, and the generated catalogs leave these keys out of
+// their English fill, so only that locale's own message replaces them.
 const NETWORK_ERROR_MESSAGES: Record<
   string,
   Record<"title" | "description", string>

package/templates/vue/package.json

@@ -25,7 +25,7 @@
     "@unhead/vue": "^2.0.14",
     "@vitejs/plugin-vue": "^6.0.6",
     "@vue/server-renderer": "^3.5.0",
-    "@vueuse/core": "^14.3.0",
+    "@vueuse/core": "14.4.0",
     "defu": "^6.1.4",
     "devalue": "^5.9.4",
     "ofetch": "^1.4.1",

package/templates/vue/patches/@vueuse__core@14.4.0.patch

@@ -0,0 +1,24 @@
+diff --git a/dist/index.js b/dist/index.js
+index 772a5e9..d433a57 100644
+--- a/dist/index.js
++++ b/dist/index.js
+@@ -2047,11 +2047,16 @@ function useColorMode(options = {}) {
+ 		let attributeToChange = null;
+ 		if (attribute === "class") {
+ 			const current = value.split(/\s/g);
++			// Patched by @antelopejs/dms-frontend until vueuse ships the fix: only
++			// the classes `el` lacks or still carries count as a change, so a mode
++			// already applied (by the server render, another instance or the
++			// mount re-run) skips the forced style recalculation below.
+ 			Object.values(modes).flatMap((i) => (i || "").split(/\s/g)).filter(Boolean).forEach((v) => {
+-				if (current.includes(v)) classesToAdd.add(v);
+-				else classesToRemove.add(v);
++				if (current.includes(v)) {
++					if (!el.classList.contains(v)) classesToAdd.add(v);
++				} else if (el.classList.contains(v)) classesToRemove.add(v);
+ 			});
+-		} else attributeToChange = {
++		} else if (el.getAttribute(attribute) !== value) attributeToChange = {
+ 			key: attribute,
+ 			value
+ 		};

package/templates/vue/pnpm-workspace.yaml

@@ -9,3 +9,8 @@ patchedDependencies:
   # Menu and breadcrumb links active on a sibling route (`/test` on `/test-a`):
   # nuxt/ui#6803, fixed by nuxt/ui#6809.
   "@nuxt/ui@4.10.0": patches/@nuxt__ui@4.10.0.patch
+  # useColorMode re-applies a color mode `<html>` already carries, forcing a
+  # full style recalculation on every call (6 on the dashboard home, 216 ms of
+  # main thread at 4x CPU): the guard of vueuse#4001 compares the modes with the
+  # requested value instead of the element. vueuse 15.0.0 still ships it.
+  "@vueuse/core@14.4.0": patches/@vueuse__core@14.4.0.patch

package/templates/vue/server/client-manifest.mjs

@@ -78,3 +78,15 @@ export function renderedModuleStyleTags(modules, template) {
     .map((file) => `<link rel="stylesheet" href="/${file}">`)
     .join("");
 }
+
+/**
+ * The link that preloads the built catalog of `locale`, the one the page was
+ * rendered with: the browser fetches it next to the entry rather than once the
+ * entry runs and asks for it, which would put a round trip before hydration.
+ * Nothing without a production build (Vite serves the sources in development).
+ */
+export function localeCatalogPreloadTag(locale) {
+  const manifest = productionClientManifest();
+  const file = locale && manifest?.[`locales.generated/${locale}.ts`]?.file;
+  return file ? `<link rel="modulepreload" crossorigin href="/${file}">` : "";
+}

package/templates/vue/server/in-place-render.mjs

@@ -0,0 +1,110 @@
+// A page that completes its query as it renders, rendered at that query in
+// the same request rather than answered with a redirect.
+//
+// Lives apart from server.mjs so the file stays under the size the linter
+// allows.
+
+import { ofetch } from "ofetch";
+
+/**
+ * How many times one request renders a page in place of a same-path redirect
+ * before it answers the redirect: a page that keeps changing its query.
+ */
+const IN_PLACE_RENDERS = 2;
+
+/**
+ * The key of a backend read a later render of the same request may reuse: a
+ * plain JSON `GET`, without hooks that would expect to see the response.
+ */
+function reusableReadKey(path, options, headers) {
+  const method = (options.method ?? "GET").toUpperCase();
+  if (method !== "GET" || options.body !== undefined) return undefined;
+  if (options.responseType && options.responseType !== "json") return undefined;
+  if (Object.keys(options).some((name) => /^on[A-Z]/.test(name)))
+    return undefined;
+  return JSON.stringify([
+    path,
+    options.query ?? options.params ?? null,
+    [...headers],
+  ]);
+}
+
+/**
+ * The backend reads of a request's server renders, sent with the request's
+ * `backendHeaders()` and the read's own. After `reuseCompletedReads()`, a later
+ * render of the same request is given a copy of each read a previous render
+ * completed instead of reading the backend again.
+ */
+export function serverReads(backendHeaders) {
+  const completed = new Map();
+  let reuse = false;
+  const read = (path, options = {}) => {
+    const headers = new Headers(backendHeaders());
+    new Headers(options.headers).forEach((value, name) => {
+      headers.set(name, value);
+    });
+    const key = reusableReadKey(path, options, headers);
+    if (reuse && key && completed.has(key))
+      return Promise.resolve(structuredClone(completed.get(key)));
+    const reading = ofetch(path, {
+      ...options,
+      baseURL: process.env.DMS_API_BASE_URL,
+      headers,
+    });
+    if (!key) return reading;
+    // A copy: the render that read it may still change the object it got. A
+    // body that cannot be copied is read again.
+    return reading.then((data) => {
+      try {
+        completed.set(key, structuredClone(data));
+      } catch {}
+      return data;
+    });
+  };
+  return Object.assign(read, {
+    reuseCompletedReads: () => {
+      reuse = true;
+    },
+  });
+}
+
+/**
+ * Whether a document request renders `location` in place of redirecting to
+ * it: a `GET` whose page only completes its query (`?workspace=`), on the
+ * same path. Any other redirect keeps its own response.
+ */
+function rendersInPlace(request, from, location) {
+  if (request.method !== "GET" || location.includes("#")) return false;
+  const current = new URL(from, "http://frontend.local");
+  const target = new URL(location, current);
+  return (
+    target.origin === current.origin && target.pathname === current.pathname
+  );
+}
+
+/**
+ * Renders a page document with `render(page)`. A page that completes its
+ * query as it renders (`router.replace` to the same path) is rendered again at
+ * that query, with the props `propsAt(props, url)` gives, reusing the reads
+ * the first render made (`fetch`), instead of being answered with a redirect
+ * the browser would follow with a whole new request. The page served then
+ * names the URL the document shows, which the browser puts in the address bar.
+ */
+export async function renderInPlace(request, page, fetch, render, propsAt) {
+  let rendered = await render(page);
+  let served = page;
+  for (
+    let pass = 0;
+    rendered.redirect &&
+    pass < IN_PLACE_RENDERS &&
+    rendersInPlace(request, served.url, rendered.redirect);
+    pass++
+  ) {
+    const url = new URL(rendered.redirect, "http://frontend.local");
+    const props = await propsAt(served.props, url);
+    served = { ...served, url: `${url.pathname}${url.search}`, props };
+    fetch.reuseCompletedReads();
+    rendered = await render(served);
+  }
+  return { rendered, served };
+}

package/templates/vue/server/page-props.mjs

@@ -100,6 +100,16 @@ async function loadPage(
   }
 }
 
+/**
+ * The props of the same page at another query of its path (`url`): the page
+ * is read again, since its layout reads the query, and the rest is kept,
+ * the site layout included.
+ */
+export async function propsForQuery(props, url, backend, auth) {
+  const { page } = await loadPage(url, false, backend, auth.signInPath);
+  return { ...props, page };
+}
+
 /**
  * The props of the page a request visits, with the once props to declare.
  *

package/templates/vue/server/proxy-transfers.mjs

@@ -1,14 +1,18 @@
 // Large transfers through the proxy, a file upload above all. The request
 // body is streamed to the backend, never buffered, and held to the
 // `maxBodyBytes` of the proxy it reached: a declared Content-Length over the
-// limit is refused before a byte is read, a chunked body is cut off as soon as
-// it goes over.
+// limit is refused before a byte is passed on, a chunked body is cut off as
+// soon as it goes over.
 
 const PAYLOAD_TOO_LARGE = 413;
 const TOO_LARGE_BODY = JSON.stringify({ message: "Payload Too Large" });
-// Reading on after the refusal would take the whole body the limit exists to
-// refuse, so the request stream is left as it is and the connection closed.
+// The refused body is never passed on: the iteration stops where it went
+// over, and the request stream stays open for the lingering close below.
 const BODY_ITERATION = { destroyOnReturn: false };
+// How long a refused body is read and dropped before the connection closes
+// anyway: long enough for a client to finish sending what was in flight,
+// short enough to bound what a refused client can make the server read.
+const LINGER_MS = 5_000;
 
 const BODILESS_METHODS = new Set(["GET", "HEAD"]);
 const REQUEST_TIMEOUT_MS = 60 * 60 * 1000;
@@ -54,13 +58,35 @@ function isBodyTooLarge(error) {
   );
 }
 
-/** Answers 413 and closes the connection, the rest of the body unread. */
-function refuseTooLargeBody(response) {
+/**
+ * Answers 413 and closes the connection once the client stopped sending.
+ *
+ * Closing a socket with unread bytes makes the kernel reset the connection,
+ * and a client stack that drops what it had not read yet when the reset
+ * arrives (macOS, BSD, Windows) reports a network error instead of the 413,
+ * the browser's upload failing without a reason. The rest of the body is read
+ * and dropped instead (RFC 9112, section 9.6, "tear-down"), for `LINGER_MS`
+ * at most; the response ends with it and the connection then closes cleanly.
+ */
+function refuseTooLargeBody(request, response) {
   response.writeHead(PAYLOAD_TOO_LARGE, {
     "content-type": "application/json",
     connection: "close",
   });
-  response.end(TOO_LARGE_BODY);
+  response.write(TOO_LARGE_BODY);
+  if (request.complete) return response.end();
+  const close = () => {
+    clearTimeout(timer);
+    response.end();
+  };
+  const timer = setTimeout(() => {
+    response.end();
+    request.socket.destroy();
+  }, LINGER_MS);
+  timer.unref();
+  request.once("end", close);
+  request.once("error", close);
+  request.resume();
 }
 
 /**
@@ -74,11 +100,11 @@ function refuseTooLargeBody(response) {
  */
 export async function sendWithinLimit(request, response, maxBodyBytes, send) {
   if (declaresTooLargeBody(request, maxBodyBytes))
-    return refuseTooLargeBody(response);
+    return refuseTooLargeBody(request, response);
   try {
     return await send(requestBody(request, maxBodyBytes));
   } catch (error) {
     if (!isBodyTooLarge(error)) throw error;
-    return refuseTooLargeBody(response);
+    return refuseTooLargeBody(request, response);
   }
 }

package/templates/vue/server.mjs

@@ -2,7 +2,6 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { createServer, maxHeaderSize } from "node:http";
 import { extname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { ofetch } from "ofetch";
 import {
   CLIENT_HEADERS,
   relayedHeaders,
@@ -26,7 +25,10 @@ import {
 } from "./server/cli-report.mjs";
 import { publicBuildFile } from "./server/built-files.mjs";
 import { serveStaticFile } from "./server/static-files.mjs";
-import { productionHtmlTemplate } from "./server/client-manifest.mjs";
+import {
+  localeCatalogPreloadTag,
+  productionHtmlTemplate,
+} from "./server/client-manifest.mjs";
 import { writeContent } from "./server/content.mjs";
 import {
   captureViteErrors,
@@ -50,7 +52,8 @@ import {
 } from "./server/module-server.mjs";
 import { HOMEPAGE } from "./server/homepage.mjs";
 import { publicOptionsScript } from "./server/public-options.mjs";
-import { loadPageProps } from "./server/page-props.mjs";
+import { renderInPlace, serverReads } from "./server/in-place-render.mjs";
+import { loadPageProps, propsForQuery } from "./server/page-props.mjs";
 import { htmlTag } from "./server/html-tag.mjs";
 import { listenHost } from "./server/listen-host.mjs";
 import * as icons from "./server/icons.mjs";
@@ -149,17 +152,7 @@ function backendHeaders(request, access = { anonymous: false, headers: [] }) {
 }
 
 function serverComponentFetch(request) {
-  return (path, options = {}) => {
-    const headers = new Headers(backendHeaders(request));
-    new Headers(options.headers).forEach((value, name) => {
-      headers.set(name, value);
-    });
-    return ofetch(path, {
-      ...options,
-      baseURL: process.env.DMS_API_BASE_URL,
-      headers,
-    });
-  };
+  return serverReads(() => backendHeaders(request));
 }
 
 async function backendJson(path, request) {
@@ -177,18 +170,18 @@ async function currentAuth() {
   return (await loadServerModules(await developmentServer())).serverAuth;
 }
 
+function pageBackend(request) {
+  return {
+    fetchJson: (path) => backendJson(path, request),
+    isFrontendPage: async (pathname) =>
+      (await ssrRenderer(await developmentServer())).isDmsFrontendPage(
+        pathname,
+      ),
+  };
+}
+
 function pageProps(request, auth) {
-  return loadPageProps(
-    request,
-    {
-      fetchJson: (path) => backendJson(path, request),
-      isFrontendPage: async (pathname) =>
-        (await ssrRenderer(await developmentServer())).isDmsFrontendPage(
-          pathname,
-        ),
-    },
-    auth,
-  );
+  return loadPageProps(request, pageBackend(request), auth);
 }
 
 function redirectToHomepage(request, response, pathname) {
@@ -320,6 +313,7 @@ export async function renderHtml(
     return { html: "", status: 200, redirect: rendered.redirect };
   const headEnd =
     (await documentStyleTags(devServer, rendered.modules, template)) +
+    (devServer ? "" : localeCatalogPreloadTag(rendered.catalogLocale)) +
     publicOptionsScript();
   const html = template
     .replace("<title>Antelope DMS</title>", () =>
@@ -338,13 +332,28 @@ export async function renderHtml(
   return { html, status: rendered.error?.statusCode ?? 200 };
 }
 
-function renderRequestHtml(page, request, rule = {}) {
-  const fetch = serverComponentFetch(request);
+function renderRequestHtml(page, request, rule = {}, reads) {
+  const fetch = reads ?? serverComponentFetch(request);
   return renderHtml(page, request.url, fetch, request.headers.cookie, {
     ssr: rule.ssr,
   });
 }
 
+/**
+ * Renders a page document, at the query the page completes as it renders:
+ * see `renderInPlace`.
+ */
+function renderDocument(page, request, rule, auth) {
+  const fetch = serverComponentFetch(request);
+  return renderInPlace(
+    request,
+    page,
+    fetch,
+    (served) => renderRequestHtml(served, request, rule, fetch),
+    (props, url) => propsForQuery(props, url, pageBackend(request), auth),
+  );
+}
+
 async function writeBackendError(error, request, response) {
   const auth = await currentAuth();
   const status = Number.isInteger(error?.status) ? error.status : 502;
@@ -477,16 +486,17 @@ export async function handleRequest(request, response) {
       JSON.stringify(page),
     );
   }
-  const rendered = await renderRequestHtml(page, request, rule);
+  const { rendered, served } = await renderDocument(page, request, rule, auth);
   if (rendered.redirect) {
     redirectFrontendVisit(request, response, rendered.redirect);
     return;
   }
+  const location = served === page ? {} : { "content-location": served.url };
   return writeContent(
     request,
     response,
     rendered.status,
-    { ...htmlHeaders(), ...headersFor(rendered.status) },
+    { ...htmlHeaders(), ...headersFor(rendered.status), ...location },
     rendered.html,
   );
 }

package/templates/vue/sfc-global-types.mjs

@@ -0,0 +1,119 @@
+// Vue's SFC compiler turns `defineProps<Props>()` into runtime prop types, and
+// it reads a type from the component's own imports only. A type a module
+// auto-imports (its declared `app/types`, `app/composables`…, and Vue's own
+// `Ref`, `Component`…) is visible to TypeScript through auto-imports.d.ts but
+// not to the compiler, which drops it from the prop without a word:
+// `boolean | RowActionConfig` became `{ type: Boolean }` in a production build.
+//
+// The compiler does read ambient declarations from `script.globalTypeFiles`,
+// but not the `export type { … } from` re-exports auto-imports.d.ts is made
+// of. This writes those types as ambient aliases it can follow, from the same
+// directories and through the same scanner as the auto-imports, before Vite
+// compiles anything, and rewrites them when a dev server sees a module's
+// declared directories change.
+
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+
+// The very unimport the auto-import plugin scans with, so both read the
+// directories the same way. Imported by URL, not by path: on Windows,
+// `import()` reads `C:\...` as a URL whose scheme is `c:` and refuses it.
+const unimportUrl = pathToFileURL(
+  createRequire(
+    createRequire(import.meta.url).resolve("unplugin-auto-import/package.json"),
+  ).resolve("unimport"),
+);
+const { builtinPresets, resolvePreset, scanDirExports } = await import(
+  unimportUrl.href
+);
+
+const HEADER =
+  "// Generated by @antelopejs/dms-frontend from the auto-imported types, for\n" +
+  "// Vue's SFC compiler (script.globalTypeFiles). Not read by TypeScript.\n";
+
+const withoutExtension = (path) => path.replace(/\.[cm]?[jt]sx?$/, "");
+
+/**
+ * The ambient aliases of the auto-imported types: one per name, in the order
+ * the auto-import plugin reads them (Vue's preset, then the scanned
+ * directories), the last one winning, as unimport's own deduplication keeps
+ * the last of two imports of the same name. A module that exports its own
+ * `Component` thus shadows Vue's, for the compiler as for TypeScript.
+ *
+ * @param {(string | { glob: string, types?: boolean })[]} dirs the auto-import
+ *   directories, as handed to the auto-import plugin
+ * @param {string} cwd the workspace
+ */
+export async function sfcGlobalTypes(dirs, cwd) {
+  const vue = await resolvePreset(builtinPresets.vue);
+  const scanned = await scanDirExports(dirs, { cwd, types: true });
+  const aliases = new Map();
+  for (const entry of [...vue, ...scanned]) {
+    if (!entry.type) continue;
+    const name = entry.as ?? entry.name;
+    const source = JSON.stringify(withoutExtension(entry.from));
+    aliases.set(
+      name,
+      `declare type ${name} = import(${source}).${entry.name};`,
+    );
+  }
+  return `${HEADER}${[...aliases.values()].join("\n")}\n`;
+}
+
+function writeIfChanged(file, content) {
+  let current;
+  try {
+    current = readFileSync(file, "utf8");
+  } catch {
+    current = undefined;
+  }
+  if (current === content) return false;
+  // Through a temporary file: a build starting meanwhile reads the previous
+  // declarations or the new ones, never a half-written file the compiler
+  // would then keep in its cache.
+  const temporary = `${file}.${process.pid}.tmp`;
+  writeFileSync(temporary, content);
+  renameSync(temporary, file);
+  return true;
+}
+
+/** Writes the declarations once, before Vite's config is returned. */
+export async function writeSfcGlobalTypes(dirs, cwd, file) {
+  writeIfChanged(file, await sfcGlobalTypes(dirs, cwd));
+}
+
+/**
+ * Keeps the declarations in step on a dev server: a type file added, renamed
+ * or removed rewrites them, and the Vue plugin reloads the components whose
+ * props read the file.
+ */
+export function sfcGlobalTypesWatcher(dirs, cwd, file) {
+  return {
+    name: "dms-sfc-global-types",
+    apply: "serve",
+    configureServer(server) {
+      let pending;
+      const refresh = (path) => {
+        if (!/\.[cm]?[jt]sx?$/.test(path) || path === file) return;
+        clearTimeout(pending);
+        pending = setTimeout(() => {
+          // The file is under the workspace, which Vite watches: rewriting it
+          // is the change the Vue plugin reloads the dependent components on.
+          // A failed scan or write keeps the previous declarations: it must
+          // not end the dev server.
+          sfcGlobalTypes(dirs, cwd)
+            .then((content) => writeIfChanged(file, content))
+            .catch((error) =>
+              server.config.logger.warn(
+                `Could not update ${file}, the types Vue's SFC compiler ` +
+                  `reads: ${error instanceof Error ? error.message : error}`,
+              ),
+            );
+        }, 100);
+      };
+      for (const event of ["add", "change", "unlink"])
+        server.watcher.on(event, refresh);
+    },
+  };
+}

package/templates/vue/ssr-renderer.ts

@@ -63,6 +63,11 @@ export interface DmsSsrResult {
   modules: string[];
   error?: DmsErrorData;
   redirect?: string;
+  /**
+   * The locale of the catalog the page was rendered with: the server preloads
+   * that catalog's file, which the browser loads before it hydrates.
+   */
+  catalogLocale?: string;
 }
 
 export interface DmsSsrHead {
@@ -189,6 +194,7 @@ async function renderDmsPageWithRuntime(
     let icons = new Set<string>();
     let iconSymbols = new Map<string, string>();
     let payload: DmsPayload = { data: {}, errors: {}, state: {} };
+    let catalogLocale: (() => string | undefined) | undefined;
     const inertiaResult = await createInertiaApp({
       page,
       // Read as the HTML is complete: data a run settles afterwards was never
@@ -214,6 +220,7 @@ async function renderDmsPageWithRuntime(
           runtime,
           serverFetch,
         });
+        catalogLocale = configured.catalogLocale;
         return app;
       },
     });
@@ -256,6 +263,7 @@ async function renderDmsPageWithRuntime(
       },
       overlays: ssrContext.teleports?.["#dms-overlays"] ?? "",
       modules: [...(ssrContext.modules ?? [])],
+      catalogLocale: catalogLocale?.(),
     };
   } finally {
     // Only once the head and the async data are serialized: both still read

package/templates/vue/ui-kbd.mjs

@@ -0,0 +1,45 @@
+// Nuxt UI prints the `meta`, `ctrl` and `alt` of a key hint (`UKbd`, the
+// `kbds` of its menus) from a map every hint shares, blank until the first
+// hint mounts: a hint hydrating after that, in an async component, printed
+// "⌘" or "Ctrl" over the server's blank, a hydration mismatch on every
+// platform. Its `useKbd` is routed to the DMS runtime's `useDmsKbd`, which
+// keeps each hint on the server's value until it mounts and lets the
+// application give the platform to the server render
+// (`provideDmsKbdPlatform`). The build fails if Nuxt UI changes the form
+// rewritten here, rather than letting the mismatch come back unnoticed.
+
+/** Nuxt UI's key hint composable. */
+const USE_KBD = /\/@nuxt\/ui\/dist\/runtime\/composables\/useKbd\.js$/;
+/** Its export as Nuxt UI 4 writes it: one composable shared by every hint. */
+const SHARED_EXPORT =
+  /export const useKbd = \/\* @__PURE__ \*\/ createSharedComposable\(_useKbd\);/;
+const ROUTED_EXPORT =
+  'import { useDmsKbd } from "#dms/frontend-module";\n' +
+  "const useSharedKbd = /* @__PURE__ */ createSharedComposable(_useKbd);\n" +
+  "export const useKbd = () => useDmsKbd(useSharedKbd, kbdKeysMap);";
+
+/**
+ * The rewrite, as a Vite plugin.
+ *
+ * @param isNuxtUiFile `(id) => boolean`, whether a module is Nuxt UI's
+ */
+export function uiKbd(isNuxtUiFile) {
+  return {
+    name: "dms-ui-kbd",
+    enforce: "pre",
+    transform(code, id) {
+      const path = id.replaceAll("\\", "/").split("?")[0];
+      if (!isNuxtUiFile(id) || !USE_KBD.test(path)) return null;
+      if (
+        !SHARED_EXPORT.test(code) ||
+        !code.includes("export const kbdKeysMap")
+      )
+        this.error(
+          `${id} defines useKbd in a form the DMS does not rewrite: its key ` +
+            "hints would not hydrate cleanly. Update ui-kbd.mjs for this " +
+            "Nuxt UI release.",
+        );
+      return { code: code.replace(SHARED_EXPORT, ROUTED_EXPORT), map: null };
+    },
+  };
+}