@antelopejs/dms-frontend 0.10.3 → 0.10.5

package/dist/config.js

@@ -74,6 +74,7 @@ exports.TEMPLATE_FILES = [
     ["sfc-global-types.mjs", "sfc-global-types.mjs"],
     ["icon-api.mjs", "icon-api.mjs"],
     ["icon-scan.mjs", "icon-scan.mjs"],
+    ["auto-imports.mjs", "auto-imports.mjs"],
     ["ui-kbd.mjs", "ui-kbd.mjs"],
     ["ui-lazy-icons.mjs", "ui-lazy-icons.mjs"],
     ["email-renderer.ts", "email-renderer.ts"],

package/dist/manifest.d.ts

@@ -8,7 +8,7 @@ export declare class ManifestUnauthorizedError extends CliError {
 export declare class BackendUnreachableError extends CliError {
     readonly url: string;
     readonly code?: string;
-    constructor(url: string, failure: unknown);
+    constructor(url: string, cause: unknown);
 }
 export declare function displayUrl(url: string | URL): string;
 export declare function backendEndpoint(backendUrl: string, path: string): URL;

package/dist/manifest.js

@@ -47,10 +47,10 @@ const UNREACHABLE_REASONS = new Map([
 ]);
 const UNKNOWN_HOST_CODES = ["ENOTFOUND", "EAI_AGAIN"];
 class BackendUnreachableError extends cli_1.CliError {
-    constructor(url, failure) {
-        const cause = (hasProperties(failure) ? failure.cause : undefined) ?? failure;
-        const code = hasProperties(cause) ? errorCode(cause) : undefined;
-        const message = () => cause instanceof Error ? cause.message : String(cause);
+    constructor(url, cause) {
+        const reason = (hasProperties(cause) ? cause.cause : undefined) ?? cause;
+        const code = hasProperties(reason) ? errorCode(reason) : undefined;
+        const message = () => reason instanceof Error ? reason.message : String(reason);
         const detail = code
             ? (UNREACHABLE_REASONS.get(code) ?? message())
             : `The request failed: ${message()}`;
@@ -61,7 +61,7 @@ class BackendUnreachableError extends cli_1.CliError {
             title: `Cannot reach the DMS backend at ${url}`,
             reason: `${code ? `${detail} (${code})` : detail}.`,
             fixes: [fix],
-        }, { cause: failure });
+        }, { cause });
         this.url = url;
         this.name = "BackendUnreachableError";
         this.code = code;

package/dist/output.d.ts

@@ -25,7 +25,7 @@ export type Failure = {
     kind: "thrown";
     text: string;
 };
-export declare function classifyFailure(thrown: unknown): Failure;
+export declare function classifyFailure(cause: unknown): Failure;
 export declare function failureDetails(failure: Failure, ui?: Ui): string[];
 export declare function endInterruptedTask(task: TaskHandle, error: CancelledError | undefined, stopped: string): void;
 export declare function reportStopped(stop: CancelledError, ui?: Ui): void;

package/dist/output.js

@@ -140,12 +140,12 @@ function formatAge(iso, now = Date.now()) {
 function cachedAge(fetchedAt) {
     return fetchedAt ? ` cached ${formatAge(fetchedAt)}` : "";
 }
-function classifyFailure(thrown) {
-    if (thrown instanceof cli_1.CliError)
-        return { kind: "cli", error: thrown };
-    if (thrown instanceof Error)
-        return { kind: "error", error: thrown };
-    return { kind: "thrown", text: String(thrown) };
+function classifyFailure(cause) {
+    if (cause instanceof cli_1.CliError)
+        return { kind: "cli", error: cause };
+    if (cause instanceof Error)
+        return { kind: "error", error: cause };
+    return { kind: "thrown", text: String(cause) };
 }
 function failureDetails(failure, ui = (0, cli_1.getProcessUi)()) {
     const { title, reason, fixes = [], details = [], } = failure.kind === "cli"

package/dist/verify-source-runner.js

@@ -62,6 +62,9 @@ async function checkServerModulesBundle(workspace) {
     (0, ensure_1.ensure)(Array.isArray(serverModules), "The server modules bundle exports none");
     return `${(0, cli_1.pluralize)(serverModules.length, "server module")}, ${(0, output_1.formatSize)(Buffer.byteLength(javascript))} JS`;
 }
+function isFunction(value) {
+    return typeof value === "function";
+}
 const EMAIL_CASES = [
     {
         name: "EmailAdminInvite",
@@ -141,7 +144,11 @@ async function checkEmailContracts(workspace) {
     const emailLocaleBytes = (0, node_fs_1.readdirSync)((0, node_path_1.join)(emailRoot, "locales")).reduce((total, file) => total + (0, node_fs_1.readFileSync)((0, node_path_1.join)(emailRoot, "locales", file)).byteLength, 0);
     const limit = (0, output_1.formatSize)(EMAIL_BUILD_SIZE_CEILING_BYTES);
     (0, ensure_1.ensure)(emailBuildSize <= EMAIL_BUILD_SIZE_CEILING_BYTES, `The e-mail bundle is ${(0, output_1.formatSize)(emailBuildSize)} of JavaScript`, `The limit is ${limit}.`);
-    const { renderEmail } = await Promise.resolve(`${(0, node_path_1.join)(emailRoot, "email-renderer.js")}`).then(s => __importStar(require(s)));
+    const emailRenderer = await Promise.resolve(`${(0, node_path_1.join)(emailRoot, "email-renderer.js")}`).then(s => __importStar(require(s)));
+    (0, ensure_1.ensure)((0, guards_1.isObjectLike)(emailRenderer) &&
+        "renderEmail" in emailRenderer &&
+        isFunction(emailRenderer.renderEmail), "The e-mail bundle exports no renderEmail function");
+    const { renderEmail } = emailRenderer;
     for (const emailCase of EMAIL_CASES) {
         const html = await renderEmail(emailCase.name, emailCase.props);
         (0, ensure_1.ensure)((0, guards_1.isText)(html) && html.startsWith("<!doctype html>"), `${emailCase.name} does not render a full HTML document`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms-frontend",
-  "version": "0.10.3",
+  "version": "0.10.5",
   "description": "Frontend-agnostic loader for AntelopeJS DMS, shipping the Vue 3 renderer (Vite, Inertia, SSR)",
   "keywords": [
     "antelope",
@@ -44,6 +44,10 @@
       "types": "./dist/common.d.ts",
       "default": "./dist/common.js"
     },
+    "./eslint-globals": {
+      "types": "./templates/eslint-globals.types.d.mts",
+      "default": "./templates/eslint-globals.mjs"
+    },
     "./dist/*.js": {
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
@@ -71,6 +75,7 @@
     "knip": "knip --dependencies",
     "knip:all": "knip",
     "docs:reference": "tsx scripts/docs-reference.ts",
+    "eslint-globals": "tsx scripts/eslint-globals.ts",
     "docs:reference:check": "tsx scripts/docs-reference.ts --check",
     "source-checks": "tsx scripts/source-checks.ts",
     "prepare": "if [ -e .git ] && command -v git >/dev/null 2>&1 && command -v lefthook >/dev/null 2>&1 && GIT_DIR=.git GIT_WORK_TREE=. git rev-parse --git-dir >/dev/null 2>&1; then GIT_DIR=.git GIT_WORK_TREE=. lefthook install; fi",
@@ -109,6 +114,7 @@
     "knip": "^6.34.0",
     "lefthook": "^2.2.2",
     "mongodb-memory-server": "^11.3.0",
+    "nuxt-ui-auto-imports": "npm:@nuxt/ui@4.10.0",
     "ofetch": "^1.5.1",
     "oxfmt": "^0.66.0",
     "oxlint": "1.81.0",

package/templates/eslint-globals.mjs

@@ -0,0 +1,133 @@
+/**
+ * ESLint flat-config globals for every name the DMS renderer auto-imports
+ * into a module's sources: Vue's preset, `frontend-module.ts` and Nuxt
+ * UI's composables. Written by `pnpm eslint-globals`.
+ */
+export default Object.freeze({
+  $fetch: "readonly",
+  Component: "readonly",
+  ComponentPublicInstance: "readonly",
+  ComputedRef: "readonly",
+  DirectiveBinding: "readonly",
+  DmsClientOnly: "readonly",
+  DmsLink: "readonly",
+  EffectScope: "readonly",
+  ExtractDefaultPropTypes: "readonly",
+  ExtractPropTypes: "readonly",
+  ExtractPublicPropTypes: "readonly",
+  InjectionKey: "readonly",
+  MaybeRef: "readonly",
+  MaybeRefOrGetter: "readonly",
+  PropType: "readonly",
+  Ref: "readonly",
+  ShallowRef: "readonly",
+  Slot: "readonly",
+  Slots: "readonly",
+  VNode: "readonly",
+  WritableComputedRef: "readonly",
+  abortDmsNavigation: "readonly",
+  clearDmsError: "readonly",
+  computed: "readonly",
+  createApp: "readonly",
+  createDmsError: "readonly",
+  customRef: "readonly",
+  defineAsyncComponent: "readonly",
+  defineComponent: "readonly",
+  defineDmsAppConfig: "readonly",
+  defineDmsMiddleware: "readonly",
+  defineDmsPageMeta: "readonly",
+  defineDmsPlugin: "readonly",
+  defineLocale: "readonly",
+  defineShortcuts: "readonly",
+  dmsRequestKey: "readonly",
+  effectScope: "readonly",
+  extendLocale: "readonly",
+  extractShortcuts: "readonly",
+  getCurrentInstance: "readonly",
+  getCurrentScope: "readonly",
+  getCurrentWatcher: "readonly",
+  h: "readonly",
+  inject: "readonly",
+  isDmsHydrating: "readonly",
+  isProxy: "readonly",
+  isReactive: "readonly",
+  isReadonly: "readonly",
+  isRef: "readonly",
+  isShallow: "readonly",
+  markRaw: "readonly",
+  navigateDms: "readonly",
+  nextTick: "readonly",
+  onActivated: "readonly",
+  onBeforeMount: "readonly",
+  onBeforeUnmount: "readonly",
+  onBeforeUpdate: "readonly",
+  onDeactivated: "readonly",
+  onErrorCaptured: "readonly",
+  onMounted: "readonly",
+  onRenderTracked: "readonly",
+  onRenderTriggered: "readonly",
+  onScopeDispose: "readonly",
+  onServerPrefetch: "readonly",
+  onUnmounted: "readonly",
+  onUpdated: "readonly",
+  onWatcherCleanup: "readonly",
+  preloadDmsComponents: "readonly",
+  provide: "readonly",
+  provideDmsKbdPlatform: "readonly",
+  reactive: "readonly",
+  readonly: "readonly",
+  ref: "readonly",
+  refreshDmsData: "readonly",
+  refreshDmsPageData: "readonly",
+  resolveComponent: "readonly",
+  setDmsAsyncDataScope: "readonly",
+  shallowReactive: "readonly",
+  shallowReadonly: "readonly",
+  shallowRef: "readonly",
+  showDmsError: "readonly",
+  toRaw: "readonly",
+  toRef: "readonly",
+  toRefs: "readonly",
+  toValue: "readonly",
+  triggerRef: "readonly",
+  unref: "readonly",
+  useAppConfig: "readonly",
+  useAttrs: "readonly",
+  useContentSearch: "readonly",
+  useCssModule: "readonly",
+  useCssVars: "readonly",
+  useDmsApp: "readonly",
+  useDmsAppConfig: "readonly",
+  useDmsAsyncData: "readonly",
+  useDmsCookie: "readonly",
+  useDmsData: "readonly",
+  useDmsError: "readonly",
+  useDmsFetch: "readonly",
+  useDmsPageLoading: "readonly",
+  useDmsPagedData: "readonly",
+  useDmsRoute: "readonly",
+  useDmsRouter: "readonly",
+  useDmsRuntimeConfig: "readonly",
+  useDmsState: "readonly",
+  useDmsUserSession: "readonly",
+  useFileUpload: "readonly",
+  useFormField: "readonly",
+  useHead: "readonly",
+  useI18n: "readonly",
+  useId: "readonly",
+  useKbd: "readonly",
+  useModel: "readonly",
+  useOverlay: "readonly",
+  useResizable: "readonly",
+  useScrollShadow: "readonly",
+  useScrollspy: "readonly",
+  useSeoMeta: "readonly",
+  useSlots: "readonly",
+  useTemplateRef: "readonly",
+  useToast: "readonly",
+  useTour: "readonly",
+  watch: "readonly",
+  watchEffect: "readonly",
+  watchPostEffect: "readonly",
+  watchSyncEffect: "readonly",
+});

package/templates/eslint-globals.types.d.mts

@@ -0,0 +1,6 @@
+/**
+ * ESLint flat-config globals for every name the DMS renderer auto-imports
+ * into a module's sources, for `languageOptions.globals`.
+ */
+declare const eslintGlobals: Readonly<Record<string, "readonly">>;
+export default eslintGlobals;

package/templates/vue/auto-imports.mjs

@@ -0,0 +1,54 @@
+/** The names `frontend-module.ts` gives every module's sources without an import. */
+const FRONTEND_MODULE_IMPORTS = [
+  "$fetch",
+  "abortDmsNavigation",
+  "clearDmsError",
+  "createDmsError",
+  "dmsRequestKey",
+  "defineDmsAppConfig",
+  "defineDmsPlugin",
+  "defineDmsMiddleware",
+  "defineDmsPageMeta",
+  "navigateDms",
+  "preloadDmsComponents",
+  "refreshDmsData",
+  "refreshDmsPageData",
+  "setDmsAsyncDataScope",
+  "showDmsError",
+  "useDmsAsyncData",
+  "useDmsData",
+  "useDmsCookie",
+  "useDmsFetch",
+  "useHead",
+  "useI18n",
+  "useDmsError",
+  "useDmsPagedData",
+  "useDmsPageLoading",
+  "isDmsHydrating",
+  "useDmsApp",
+  "useDmsRoute",
+  "useDmsRouter",
+  "useDmsRuntimeConfig",
+  "useSeoMeta",
+  "useDmsState",
+  "useDmsAppConfig",
+  "DmsClientOnly",
+  "DmsLink",
+  "useDmsUserSession",
+  "provideDmsKbdPlatform",
+];
+
+/**
+ * The `imports` of the workspace's auto-importer: Vue's preset and the names
+ * of `frontend-module.ts`. Nuxt UI adds its own composables to them.
+ *
+ * The auto-importer inlines `frontendModule` verbatim as the specifier of the
+ * import it prepends to each file, inside a single-quoted JavaScript string:
+ * pass a POSIX path, since a Windows backslash there reads as an escape.
+ *
+ * @param {string} frontendModule The import specifier of `frontend-module.ts`.
+ * @returns {["vue", Record<string, string[]>]}
+ */
+export function autoImportSources(frontendModule) {
+  return ["vue", { [frontendModule]: FRONTEND_MODULE_IMPORTS }];
+}

package/templates/vue/server/auth/session.mjs

@@ -4,6 +4,7 @@ import {
   createHash,
   randomBytes,
 } from "node:crypto";
+import { isBoolean, isNumber, isRecord, isString } from "../type-guards.mjs";
 
 export const SESSION_COOKIE = "dms_session";
 const REQUEST_SESSION = Symbol("dms-request-session");
@@ -66,12 +67,17 @@ function key() {
 }
 
 /**
+ * Seals `value` for the cookie `name` alone: the name is the AES-GCM
+ * additional authenticated data, so the value opens under no other cookie.
+ *
+ * @param {string} name The cookie's name in the jar
  * @param {unknown} value A session, or the value of a module's sealed cookie
  * @returns {string}
  */
-function encode(value) {
+function encode(name, value) {
   const iv = randomBytes(12);
   const cipher = createCipheriv("aes-256-gcm", key(), iv);
+  cipher.setAAD(Buffer.from(name));
   const encrypted = Buffer.concat([
     cipher.update(JSON.stringify(value)),
     cipher.final(),
@@ -82,11 +88,12 @@ function encode(value) {
 }
 
 /**
+ * @param {string} name The cookie's name in the jar
  * @param {string} value The cookie's value
- * @returns {any} What was sealed, as the JSON it was written from, `undefined`
- *   when it does not open
+ * @returns {unknown} What was sealed for `name`, as the JSON it was written
+ *   from, `undefined` when it does not open
  */
-function decode(value) {
+function decode(name, value) {
   try {
     const payload = Buffer.from(value, "base64url");
     const decipher = createDecipheriv(
@@ -95,6 +102,7 @@ function decode(value) {
       payload.subarray(0, 12),
     );
     decipher.setAuthTag(payload.subarray(12, 28));
+    decipher.setAAD(Buffer.from(name));
     return JSON.parse(
       Buffer.concat([
         decipher.update(payload.subarray(28)),
@@ -107,16 +115,21 @@ function decode(value) {
 }
 
 /**
- * @param {import("node:http").IncomingMessage} request
- * @param {string} name
- * @returns {string | undefined}
+ * @param {unknown} value
+ * @returns {value is Session} Whether `value` is what `writeSession` seals
  */
-function cookieValue(request, name) {
-  const scoped = scopedCookieName(name);
-  const cookies = request.headers.cookie?.split(";") ?? [];
-  return cookies
-    .map((part) => part.trim().split("="))
-    .find(([key]) => key === scoped)?.[1];
+function isSession(value) {
+  if (!isRecord(value) || !isBoolean(value.persistent)) return false;
+  const { user } = value;
+  return (
+    ["accessToken", "refreshToken", "accountId", "activeTenantId"].every(
+      (field) => !Object.hasOwn(value, field) || isString(value[field]),
+    ) &&
+    (!Object.hasOwn(value, "updatedAt") || isNumber(value.updatedAt)) &&
+    (!Object.hasOwn(value, "user") ||
+      (isRecord(user) &&
+        (!Object.hasOwn(user, "language") || isString(user.language))))
+  );
 }
 
 /**
@@ -158,6 +171,21 @@ function appendCookie(response, name, value, cookieAttributes) {
   );
 }
 
+/**
+ * @param {import("node:http").ServerResponse} response
+ * @param {string} name
+ * @param {unknown} value
+ * @param {string} cookieAttributes
+ */
+function appendSealedCookie(response, name, value, cookieAttributes) {
+  appendCookie(
+    response,
+    name,
+    encode(scopedCookieName(name), value),
+    cookieAttributes,
+  );
+}
+
 /**
  * @param {SessionRequest} request
  * @returns {Session | undefined} The session set for the request, else the one
@@ -165,9 +193,8 @@ function appendCookie(response, name, value, cookieAttributes) {
  */
 export function readSession(request) {
   if (REQUEST_SESSION in request) return request[REQUEST_SESSION];
-  const value = cookieValue(request, SESSION_COOKIE);
-  // oxlint-disable-next-line typescript/no-unsafe-return -- `decode` returns the JSON this server sealed under `SESSION_COOKIE`, untyped because `JSON.parse` is; the AES-GCM tag rejects any cookie it did not write.
-  return value ? decode(value) : undefined;
+  const sealed = readSealedCookie(request, SESSION_COOKIE);
+  return isSession(sealed) ? sealed : undefined;
 }
 
 /**
@@ -183,10 +210,10 @@ export function setRequestSession(request, session) {
  * @param {Session} session
  */
 export function writeSession(response, session) {
-  appendCookie(
+  appendSealedCookie(
     response,
     SESSION_COOKIE,
-    encode(session),
+    session,
     attributes(lifetime(session)),
   );
 }
@@ -203,8 +230,12 @@ export function clearSession(response) {
  *   `undefined` when there is none or it does not open
  */
 export function readSealedCookie(request, name) {
-  const value = cookieValue(request, name);
-  return value ? decode(value) : undefined;
+  const scoped = scopedCookieName(name);
+  const cookies = request.headers.cookie?.split(";") ?? [];
+  const value = cookies
+    .map((part) => part.trim().split("="))
+    .find(([key]) => key === scoped)?.[1];
+  return value ? decode(scoped, value) : undefined;
 }
 
 /**
@@ -215,7 +246,7 @@ export function readSealedCookie(request, name) {
  * @param {string} [path]
  */
 export function writeSealedCookie(response, name, value, maxAge, path = "/") {
-  appendCookie(response, name, encode(value), attributes(maxAge, path));
+  appendSealedCookie(response, name, value, attributes(maxAge, path));
 }
 
 /**

package/templates/vue/server/module-event.mjs

@@ -295,14 +295,14 @@ function isResponse(value) {
 }
 
 /**
- * @param {any} result What a handler answered: any value, of which only
+ * @param {unknown} result What a handler answered: any value, of which only
  *   `isResponse` looks
  * @returns {Response}
  */
 function asResponse(result) {
   if (isResponse(result))
-    // oxlint-disable-next-line typescript/no-unsafe-return -- `isResponse` also accepts a `Response` of another realm by its members (`status`, `headers.get`, `body`), so it cannot be a `value is Response` predicate without claiming members it does not check.
-    return result;
+    // SAFETY: `isResponse` accepts a `Response` of this realm or of another one (another copy of undici) by its `status`, `headers.get` and `body`; an answer that only mimics those members is read as a `Response` too, as it was before this assertion.
+    return /** @type {Response} */ (result);
   if (result === undefined || result === null)
     return new Response(null, { status: 204 });
   return Response.json(result);

package/templates/vue/server/module-server.mjs

@@ -222,16 +222,24 @@ function readPublicOptions() {
  */
 async function loadDeclarations(devServer) {
   if (devServer)
-    // oxlint-disable-next-line typescript/no-unsafe-return -- `ssrLoadModule` types every module `Record<string, any>`; the loader is the generated `server-modules.generated.ts`, which exports `serverModules`.
-    return (await devServer.ssrLoadModule(SOURCE_LOADER)).serverModules;
+    return declarationsOf(await devServer.ssrLoadModule(SOURCE_LOADER));
   if (!existsSync(fileURLToPath(BUILT_LOADER))) return [];
-  builtDeclarations ??= import(BUILT_LOADER.href).then(
-    // oxlint-disable-next-line typescript/no-unsafe-return -- the build of that same generated module is imported by a URL computed at run time, so it is untyped.
-    (loaded) => loaded.serverModules,
-  );
+  builtDeclarations ??= import(BUILT_LOADER.href).then(declarationsOf);
   return builtDeclarations;
 }
 
+/**
+ * @param {unknown} loader The generated `server-modules.generated.ts`, from
+ *   its source or its build
+ * @returns {ServerModuleDeclaration[]}
+ */
+function declarationsOf(loader) {
+  // SAFETY: `ssrLoadModule` types every module `Record<string, any>` and the build is imported by a URL computed at run time; both are the generated `server-modules.generated.ts`, which exports `serverModules`, the declarations of the modules with a dms.server.ts.
+  return /** @type {{ serverModules: ServerModuleDeclaration[] }} */ (
+    loader
+  ).serverModules;
+}
+
 /**
  * The declarations to serve. A module entry that fails to load in development
  * (a syntax error being typed) is reported once, and the last routes that

package/templates/vue/server/ssr-module.mjs

@@ -22,11 +22,12 @@ let productionSsrRenderer;
  * @returns {Promise<typeof import("../ssr-renderer.ts")>}
  */
 export async function ssrRenderer(devServer) {
-  /** @type {typeof import("../ssr-renderer.ts")} */
-  // oxlint-disable-next-line typescript/no-unsafe-assignment -- `ssrLoadModule` types every module `Record<string, any>` and the production import takes a URL computed at run time; both load this template's own `ssr-renderer.ts`, the type named above.
-  const renderer = devServer
-    ? await devServer.ssrLoadModule("/ssr-renderer.ts")
-    : await (productionSsrRenderer ??= import(BUILT_SSR_RENDERER_URL.href));
+  // SAFETY: both load this template's own `ssr-renderer.ts`, the development server from its source and the production import from its build; `ssrLoadModule` types every module `Record<string, any>` and the built URL is computed at run time.
+  const renderer = /** @type {typeof import("../ssr-renderer.ts")} */ (
+    devServer
+      ? await devServer.ssrLoadModule("/ssr-renderer.ts")
+      : await (productionSsrRenderer ??= import(BUILT_SSR_RENDERER_URL.href))
+  );
   await icons.provideIconCollections(renderer);
   return renderer;
 }

package/templates/vue/vite.config.ts

@@ -18,6 +18,7 @@ import { uiKbd } from "./ui-kbd.mjs";
 import { uiLazyIcons } from "./ui-lazy-icons.mjs";
 import { uiRequestState } from "./ui-request-state.mjs";
 import { autoImportDirectories, vitePlugins } from "./frontend-build-loader.ts";
+import { autoImportSources } from "./auto-imports.mjs";
 import { frontendBuilds } from "./frontend-builds.generated.ts";
 import { orderHeadForFirstPaint } from "./head-order.mjs";
 import { iconScanGlobs } from "./icon-scan.mjs";
@@ -218,56 +219,9 @@ export default defineConfig({
       autoImport: {
         dirs: importDirectories,
         dirsScanOptions: { types: true },
-        imports: [
-          "vue",
-          {
-            // This key is inlined verbatim as the module specifier of the
-            // import the auto-importer prepends to each file. A native Windows
-            // path would land inside a single-quoted JavaScript string with its
-            // backslashes intact, where `\U`, `\M` and `\f` are read as escape
-            // sequences: the specifier the bundler then resolves is a mangled
-            // path that cannot exist. Keep it POSIX.
-            [normalizePath(resolve(import.meta.dirname, "frontend-module.ts"))]:
-              [
-                "$fetch",
-                "abortDmsNavigation",
-                "clearDmsError",
-                "createDmsError",
-                "dmsRequestKey",
-                "defineDmsAppConfig",
-                "defineDmsPlugin",
-                "defineDmsMiddleware",
-                "defineDmsPageMeta",
-                "navigateDms",
-                "preloadDmsComponents",
-                "refreshDmsData",
-                "refreshDmsPageData",
-                "setDmsAsyncDataScope",
-                "showDmsError",
-                "useDmsAsyncData",
-                "useDmsData",
-                "useDmsCookie",
-                "useDmsFetch",
-                "useHead",
-                "useI18n",
-                "useDmsError",
-                "useDmsPagedData",
-                "useDmsPageLoading",
-                "isDmsHydrating",
-                "useDmsApp",
-                "useDmsRoute",
-                "useDmsRouter",
-                "useDmsRuntimeConfig",
-                "useSeoMeta",
-                "useDmsState",
-                "useDmsAppConfig",
-                "DmsClientOnly",
-                "DmsLink",
-                "useDmsUserSession",
-                "provideDmsKbdPlatform",
-              ],
-          },
-        ],
+        imports: autoImportSources(
+          normalizePath(resolve(import.meta.dirname, "frontend-module.ts")),
+        ),
         dts: "auto-imports.d.ts",
         vueTemplate: true,
       },