@antelopejs/dms-frontend 0.3.2 → 0.3.4

package/dist/materialize.js

@@ -4,16 +4,13 @@ exports.getPackageRoot = getPackageRoot;
 exports.copyStaticTemplates = copyStaticTemplates;
 exports.writeWorkspacePackageJson = writeWorkspacePackageJson;
 exports.materializeLayers = materializeLayers;
-exports.createFrontendModuleRegistry = createFrontendModuleRegistry;
 exports.collectAuthEstablishEndpoints = collectAuthEstablishEndpoints;
 exports.writeFrontendModuleRegistry = writeFrontendModuleRegistry;
-exports.affectsLocaleMessages = affectsLocaleMessages;
-exports.writeLocaleMessages = writeLocaleMessages;
 exports.writeDmsMainCss = writeDmsMainCss;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const config_1 = require("./config");
-const layer_aliases_1 = require("./layer-aliases");
+const derived_outputs_1 = require("./derived-outputs");
 const layers_1 = require("./layers");
 const fs_sync_1 = require("./fs-sync");
 function getPackageRoot() {
@@ -77,40 +74,6 @@ function sanitizeLayerPackage(pkgPath) {
         return;
     (0, fs_sync_1.applyContent)((0, fs_sync_1.sanitizedPackageContent)((0, node_fs_1.readFileSync)(pkgPath, "utf-8")), pkgPath);
 }
-const GENERATED_MODULE_ID = /^[A-Za-z0-9_-]+$/;
-function validateFrontendModuleRegistry(registry, workspaceDir) {
-    const ids = new Set();
-    const moduleRoot = `${(0, node_path_1.resolve)(workspaceDir, config_1.LAYERS_SUBDIR)}${node_path_1.sep}`;
-    for (const module of registry.modules) {
-        if (!GENERATED_MODULE_ID.test(module.id) || ids.has(module.id))
-            throw new Error(`Invalid or duplicate frontend module id: ${module.id}`);
-        if (!Number.isFinite(module.priority))
-            throw new Error(`Invalid frontend module priority: ${module.id}`);
-        if (module.entry !== undefined && module.entry !== config_1.FRONTEND_MODULE_ENTRY)
-            throw new Error(`Invalid frontend module entry: ${module.id}`);
-        if (!(0, node_path_1.resolve)(module.root).startsWith(moduleRoot))
-            throw new Error(`Frontend module root escapes the workspace: ${module.id}`);
-        ids.add(module.id);
-    }
-}
-function createFrontendModuleRegistry(workspaceDir, layers) {
-    const modules = layers.map((layer) => {
-        const sourceEntry = (0, node_path_1.join)(layer.path, config_1.FRONTEND_MODULE_ENTRY);
-        const options = layer.options ?? {};
-        return {
-            id: (0, layers_1.getLayerSafeName)(layer),
-            packageName: layer.packageName,
-            root: (0, layers_1.getLayerWorkspacePath)(workspaceDir, layer),
-            priority: layer.priority ?? 0,
-            entry: (0, node_fs_1.existsSync)(sourceEntry) ? config_1.FRONTEND_MODULE_ENTRY : undefined,
-            options: layer.configKey ? { [layer.configKey]: options } : options,
-        };
-    });
-    modules.sort((left, right) => right.priority - left.priority || left.id.localeCompare(right.id));
-    const registry = { modules };
-    validateFrontendModuleRegistry(registry, workspaceDir);
-    return registry;
-}
 const BACKEND_API_PATH = /^\/api\/[A-Za-z0-9][A-Za-z0-9._~-]*(?:\/[A-Za-z0-9][A-Za-z0-9._~-]*)*$/;
 function collectAuthEstablishEndpoints(layers) {
     const endpoints = new Set();
@@ -132,214 +95,10 @@ function writeAuthEstablishEndpoints(workspaceDir, layers) {
     (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, config_1.AUTH_ESTABLISH_FILE), `${JSON.stringify({ endpoints }, null, 2)}\n`);
 }
 function writeFrontendModuleRegistry(workspaceDir, layers) {
-    const registry = createFrontendModuleRegistry(workspaceDir, layers);
-    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "generated-frontend-modules.json"), `${JSON.stringify(registry, null, 2)}\n`);
+    const registry = (0, derived_outputs_1.createFrontendModuleRegistry)(workspaceDir, layers);
     writeAuthEstablishEndpoints(workspaceDir, layers);
-    writeFrontendTypePaths(workspaceDir, registry);
-    writeFrontendModuleLoader(workspaceDir, registry);
-    writeLocaleMessages(workspaceDir, registry);
-    writeShortcutExports(workspaceDir, registry);
-    writePublicAssets(workspaceDir, registry);
-}
-function writeFrontendTypePaths(workspaceDir, registry) {
-    const paths = {
-        "#dms/frontend-module": ["./frontend-module.ts"],
-        "@frontend/*": ["./frontend-modules/*"],
-        ...(0, layer_aliases_1.frontendLayerTypePaths)([...registry.modules].reverse().map((module) => module.root), { relativeTo: workspaceDir }),
-    };
-    const config = { compilerOptions: { paths } };
-    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "frontend-paths.generated.json"), `${JSON.stringify(config, null, 2)}\n`);
-}
-function writeFrontendModuleLoader(workspaceDir, registry) {
-    const modules = registry.modules.filter((module) => module.entry);
-    const imports = modules
-        .map((module, index) => `import module${index} from "@frontend/${module.id}/${module.entry}";`)
-        .join("\n");
-    const registrations = modules
-        .map((module, index) => `{ module: module${index}, options: { public: ${JSON.stringify(module.options)} } }`)
-        .join(", ");
-    const content = `${imports}\n\nimport type { DmsFrontendModuleRegistration } from "./frontend-module";\n\nexport const frontendModules: DmsFrontendModuleRegistration[] = [${registrations}];\n`;
-    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "frontend-modules.generated.ts"), content);
-}
-function moduleAssetRoots(moduleRoot) {
-    const layersRoot = (0, node_path_1.join)(moduleRoot, "layers");
-    if (!(0, node_fs_1.existsSync)(layersRoot)) {
-        return [{ absolutePath: moduleRoot, relativePrefix: "" }];
-    }
-    return (0, node_fs_1.readdirSync)(layersRoot).map((name) => ({
-        absolutePath: (0, node_path_1.join)(layersRoot, name),
-        relativePrefix: `layers/${name}/`,
-    }));
-}
-function writePublicAssets(workspaceDir, registry) {
-    const destination = (0, node_path_1.join)(workspaceDir, "public");
-    (0, node_fs_1.rmSync)(destination, { force: true, recursive: true });
-    for (const module of [...registry.modules].reverse()) {
-        for (const root of moduleAssetRoots(module.root)) {
-            const source = (0, node_path_1.join)(root.absolutePath, "public");
-            if ((0, node_fs_1.existsSync)(source)) {
-                (0, node_fs_1.cpSync)(source, destination, { force: true, recursive: true });
-            }
-        }
-    }
-}
-function discoverAssets(registry, directory, extensions) {
-    return registry.modules.flatMap((module) => {
-        return moduleAssetRoots(module.root).flatMap((assetRoot) => {
-            const root = (0, node_path_1.join)(assetRoot.absolutePath, directory);
-            return (0, fs_sync_1.collectFiles)(root)
-                .filter((file) => extensions.some((extension) => file.endsWith(extension)))
-                .sort()
-                .map((relativePath) => ({
-                moduleId: module.id,
-                relativePath: `${assetRoot.relativePrefix}${(0, fs_sync_1.toPosixPath)((0, node_path_1.join)(directory, relativePath))}`,
-            }));
-        });
-    });
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function mergeLocaleMessages(source, existing) {
-    const merged = { ...source };
-    for (const [key, value] of Object.entries(existing)) {
-        const sourceValue = merged[key];
-        merged[key] =
-            isRecord(sourceValue) && isRecord(value)
-                ? mergeLocaleMessages(sourceValue, value)
-                : value;
-    }
-    return merged;
-}
-const LOCALE_DIRECTORY = "i18n/locales";
-function readLocaleFile(path) {
-    try {
-        return JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        throw new Error(`Invalid locale file ${path}: ${reason}`);
-    }
-}
-function readLocaleMessages(assets, registry) {
-    const roots = new Map(registry.modules.map((module) => [module.id, module.root]));
-    const messages = {};
-    for (const asset of assets) {
-        const locale = asset.relativePath.match(/(?:^|[/-])([a-z]{2})-[A-Z]{2}\.json$/)?.[1];
-        const root = roots.get(asset.moduleId);
-        if (!locale || !root)
-            continue;
-        const value = readLocaleFile((0, node_path_1.join)(root, asset.relativePath));
-        messages[locale] = mergeLocaleMessages(value, messages[locale] ?? {});
-    }
-    return messages;
-}
-function affectsLocaleMessages(relativePath) {
-    const segments = (0, fs_sync_1.toPosixPath)(relativePath).split("/");
-    if (segments[0] === "layers" && segments.length <= 2)
-        return true;
-    const withinRoot = segments[0] === "layers" ? segments.slice(2) : segments;
-    return LOCALE_DIRECTORY.split("/").every((segment, index) => index >= withinRoot.length || withinRoot[index] === segment);
-}
-function localeModuleSource(supportedLocales) {
-    const loaders = supportedLocales
-        .filter((locale) => locale !== "en")
-        .map((locale) => `  ${JSON.stringify(locale)}: () => import(${JSON.stringify(`./locales.generated/${locale}`)}),`);
-    return `import defaultMessages from "./locales.generated/en";
-
-type LocaleMessages = Record<string, unknown>;
-type LocaleLoader = () => Promise<{ default: LocaleMessages }>;
-interface LocaleMessagesTarget {
-  setLocaleMessage(locale: string, messages: LocaleMessages): void;
-}
-interface LocaleState {
-  messages: Record<string, LocaleMessages>;
-  targets: Set<LocaleMessagesTarget>;
-  version: number;
-}
-
-export const supportedLocales = ${JSON.stringify(supportedLocales)};
-const localeLoaders: Record<string, LocaleLoader> = {
-  "en": async () => ({ default: defaultMessages }),
-${loaders.join("\n")}
-};
-const shared: LocaleState | undefined = import.meta.hot?.data.state;
-const state: LocaleState = shared ?? {
-  messages: { en: defaultMessages },
-  targets: new Set(),
-  version: 0,
-};
-export const localeMessages = state.messages;
-
-async function readLocaleMessages(locale: string): Promise<LocaleMessages> {
-  return (await localeLoaders[locale]()).default;
-}
-
-export async function loadLocaleMessages(locale: string): Promise<LocaleMessages> {
-  const normalized = locale.slice(0, 2);
-  if (!localeLoaders[normalized]) return localeMessages.en;
-  localeMessages[normalized] ??= await readLocaleMessages(normalized);
-  return localeMessages[normalized];
-}
-
-/** Development only: applies every regenerated catalog to \`target\`. */
-export function syncLocaleMessages(target: LocaleMessagesTarget): void {
-  if (import.meta.hot) state.targets.add(target);
-}
-
-async function refreshLocaleMessages(): Promise<void> {
-  const version = ++state.version;
-  const locales = Object.keys(localeMessages).filter(
-    (locale) => locale in localeLoaders,
-  );
-  const catalogs = await Promise.all(locales.map(readLocaleMessages));
-  if (version !== state.version) return;
-  locales.forEach((locale, index) => {
-    localeMessages[locale] = catalogs[index];
-    for (const target of state.targets)
-      target.setLocaleMessage(locale, catalogs[index]);
-  });
-}
-
-if (import.meta.hot) {
-  import.meta.hot.data.state = state;
-  if (shared) void refreshLocaleMessages();
-  import.meta.hot.accept((next) => {
-    if (next?.supportedLocales.join() !== supportedLocales.join())
-      import.meta.hot?.invalidate("the list of locales changed");
-  });
-}
-`;
-}
-function writeLocaleMessages(workspaceDir, registry) {
-    const locales = discoverAssets(registry, LOCALE_DIRECTORY, [".json"]);
-    const messages = readLocaleMessages(locales, registry);
-    const outputDir = (0, node_path_1.join)(workspaceDir, "locales.generated");
-    const outputs = new Set();
-    (0, node_fs_1.mkdirSync)(outputDir, { recursive: true });
-    for (const [locale, value] of Object.entries(messages)) {
-        const catalog = JSON.stringify(value);
-        (0, fs_sync_1.applyContent)(catalog, (0, node_path_1.join)(outputDir, `${locale}.json`));
-        (0, fs_sync_1.applyContent)(`const messages = ${catalog};\nexport default messages;\n`, (0, node_path_1.join)(outputDir, `${locale}.ts`));
-        outputs.add(`${locale}.json`).add(`${locale}.ts`);
-    }
-    const supportedLocales = Object.keys(messages);
-    (0, fs_sync_1.applyContent)(JSON.stringify(supportedLocales), (0, node_path_1.join)(workspaceDir, "email-locales.generated.json"));
-    (0, fs_sync_1.applyContent)(localeModuleSource(supportedLocales), (0, node_path_1.join)(workspaceDir, "locales.generated.ts"));
-    for (const name of (0, node_fs_1.readdirSync)(outputDir)) {
-        if (!outputs.has(name))
-            (0, node_fs_1.rmSync)((0, node_path_1.join)(outputDir, name), { recursive: true, force: true });
-    }
-}
-function writeShortcutExports(workspaceDir, registry) {
-    const registries = discoverAssets(registry, "app/config", [
-        "shortcuts-registry.ts",
-        "shortcuts-registry.js",
-    ]);
-    const imports = registries.map((asset, index) => `import registry${index} from "@frontend/${asset.moduleId}/${asset.relativePath}";`);
-    const spreads = registries.map((_, index) => `...registry${index}`);
-    const content = `${imports.join("\n")}\nconst aggregatedShortcuts = [${spreads.join(", ")}];\nexport { aggregatedShortcuts };\nexport default aggregatedShortcuts;\n`;
-    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "shortcuts-aggregated.generated.ts"), content);
+    for (const output of derived_outputs_1.DERIVED_OUTPUTS)
+        output.write(workspaceDir, registry);
 }
 function writeDmsMainCss(workspaceDir, layers) {
     const sources = layers

package/dist/renderer-range.d.ts

@@ -0,0 +1,10 @@
+import { ResolvedLayer } from "./workspace";
+export interface RendererRelease {
+    name: string;
+    version: string;
+}
+export interface RendererRangeCheckOptions {
+    renderer?: RendererRelease;
+    warn?: (message: string) => void;
+}
+export declare function assertLayersSupportRenderer(layers: ResolvedLayer[], options?: RendererRangeCheckOptions): void;

package/dist/renderer-range.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertLayersSupportRenderer = assertLayersSupportRenderer;
+const semver_1 = __importDefault(require("semver"));
+const layers_1 = require("./layers");
+const OWN_RELEASE = require("../package.json");
+const noticedModules = new Set();
+function declaredRange(layer, rendererName) {
+    return {
+        module: layer.packageName ?? layer.path,
+        range: (0, layers_1.readLayerPackage)(layer.path)?.engines?.[rendererName],
+    };
+}
+function releaseLine(version) {
+    return semver_1.default.coerce(version)?.version ?? version;
+}
+function describeProblem(declaration, version) {
+    const { module, range } = declaration;
+    if (typeof range !== "string" || semver_1.default.validRange(range) === null)
+        return `${module} declares an unreadable range: ${JSON.stringify(range)}`;
+    if (semver_1.default.satisfies(releaseLine(version), range))
+        return undefined;
+    return `${module} supports ${range}`;
+}
+function noticeUndeclared(declarations, renderer, warn) {
+    const modules = declarations
+        .filter(({ range }) => range === undefined)
+        .map(({ module }) => module)
+        .filter((module) => !noticedModules.has(module));
+    if (modules.length === 0)
+        return;
+    for (const module of modules)
+        noticedModules.add(module);
+    warn(`⚠ No supported ${renderer.name} range declared, so not checked against ` +
+        `${renderer.version}: ${modules.join(", ")}. A frontend module declares ` +
+        `one in its package.json, under engines["${renderer.name}"].`);
+}
+function assertLayersSupportRenderer(layers, options = {}) {
+    const renderer = options.renderer ?? OWN_RELEASE;
+    const declarations = layers.map((layer) => declaredRange(layer, renderer.name));
+    noticeUndeclared(declarations, renderer, options.warn ?? console.warn);
+    const problems = declarations
+        .filter(({ range }) => range !== undefined)
+        .map((declaration) => describeProblem(declaration, renderer.version))
+        .filter((problem) => problem !== undefined);
+    if (problems.length === 0)
+        return;
+    throw new Error(`These frontend modules do not run on ${renderer.name} ${renderer.version}:\n` +
+        problems.map((problem) => `  - ${problem}`).join("\n") +
+        `\nInstall a ${renderer.name} release their ranges allow, or upgrade those ` +
+        `modules to releases that support ${renderer.version}.`);
+}

package/dist/verify-source-runner.js

@@ -74,6 +74,7 @@ const layers = roots.map((root) => ({
     packageName: JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(root, "package.json"), "utf8"))
         .name,
 }));
+(0, common_1.assertLayersSupportRenderer)(layers);
 (0, common_1.materializeLayers)(workspace, layers);
 const registry = (0, common_1.createFrontendModuleRegistry)(workspace, layers);
 registry.modules.forEach((module) => {

package/dist/workspace-setup.js

@@ -14,6 +14,7 @@ const node_path_1 = require("node:path");
 const layers_1 = require("./layers");
 const manifest_1 = require("./manifest");
 const manifest_secrets_1 = require("./manifest-secrets");
+const renderer_range_1 = require("./renderer-range");
 const materialize_1 = require("./materialize");
 const workspace_1 = require("./workspace");
 const config_1 = require("./config");
@@ -168,6 +169,7 @@ async function setupWorkspace(opts) {
         }
         layers = await (0, layers_1.buildLayersFromCache)(manifest.modules, cacheDir);
     }
+    (0, renderer_range_1.assertLayersSupportRenderer)(layers);
     (0, materialize_1.copyStaticTemplates)(workspaceDir);
     (0, materialize_1.writeWorkspacePackageJson)(workspaceDir, layers);
     (0, materialize_1.materializeLayers)(workspaceDir, layers);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms-frontend",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Frontend-agnostic loader for AntelopeJS DMS, shipping the Vue 3 renderer (Vite, Inertia, SSR)",
   "keywords": [
     "antelope",
@@ -59,7 +59,7 @@
     "test": "node --import tsx --test tests/*.test.ts tests/*.test.mts",
     "test:real-source": "pnpm run build && node dist/verify-source-runner.js",
     "format": "oxfmt .",
-    "lint": "oxlint && oxfmt --check .",
+    "lint": "oxlint && oxfmt --check . && antelopejs-check-interface-ranges",
     "typecheck": "tsc --noEmit",
     "lint:fix": "oxlint --fix --max-warnings=1000000 && oxfmt .",
     "knip": "knip --dependencies",
@@ -76,7 +76,7 @@
     "unzipper": "^0.12.3"
   },
   "devDependencies": {
-    "@antelopejs/tooling-configs": ">=0.0.6 <1.0.0",
+    "@antelopejs/tooling-configs": ">=0.0.7 <1.0.0",
     "@inertiajs/vue3": "^3.7.1",
     "@types/figlet": "^1.7.0",
     "@types/node": "^24.8.1",

package/templates/vue/app-runtime.ts

@@ -2,6 +2,7 @@ import UApp from "@nuxt/ui/components/App.vue";
 import UIcon from "@nuxt/ui/runtime/vue/components/Icon.vue";
 import { useToast } from "@nuxt/ui/composables/useToast";
 import { useAppConfig } from "@nuxt/ui/runtime/vue/composables/useAppConfig";
+import { en as uiEn, fr as uiFr } from "@nuxt/ui/locale";
 import ui from "@nuxt/ui/vue-plugin";
 import { useHead } from "@unhead/vue";
 import type { VueHeadClient } from "@unhead/vue/types";
@@ -80,6 +81,19 @@ const SSR_ASYNC_DATA_ID = "dms-ssr-async-data";
 export const SSR_ASYNC_COMPONENTS_ID = "dms-ssr-async-components";
 const DEFAULT_LOCALE = "en";
 
+/**
+ * Nuxt UI ships its own strings (placeholders, empty states, aria labels).
+ * Only the locales the DMS translates are imported: the full catalog would
+ * weigh on every bundle. A locale missing here falls back to English.
+ */
+const UI_LOCALES = { en: uiEn, fr: uiFr };
+
+type UiLocale = (typeof UI_LOCALES)[keyof typeof UI_LOCALES];
+
+function uiLocale(locale: string): UiLocale {
+  return UI_LOCALES[locale as keyof typeof UI_LOCALES] ?? UI_LOCALES.en;
+}
+
 function pageLocale(props: DmsPageProps): string {
   const language = props.user?.language;
   if (typeof language !== "string") return DEFAULT_LOCALE;
@@ -164,6 +178,7 @@ const DmsPersistentLayout = defineComponent({
         error,
         content,
         overlays.value,
+        i18n.locale.value,
       );
     };
   },
@@ -198,6 +213,7 @@ function renderDmsPersistentLayout(
   error: DmsPageProps["error"],
   children: VNode[] | undefined,
   overlays: string[],
+  locale: string,
 ) {
   const layout = error ? undefined : getDmsLayout(props);
   const content = layout
@@ -205,7 +221,7 @@ function renderDmsPersistentLayout(
     : children;
   return h(
     UApp,
-    { portal: "#dms-overlays" },
+    { portal: "#dms-overlays", locale: uiLocale(locale) },
     {
       default: () => [
         ...overlays.map((name) =>