@antelopejs/dms-frontend 0.8.0 → 0.9.1

package/dist/commands/build-action.js

@@ -10,6 +10,7 @@ const child_output_1 = require("../child-output");
 const common_1 = require("../common");
 const output_1 = require("../output");
 const vite_output_1 = require("../vite-output");
+const entry_weight_1 = require("../entry-weight");
 const workspace_task_1 = require("./workspace-task");
 exports.DEFAULT_WORKSPACE_DIR = ".dms-frontend";
 function productionWorkspace(options) {
@@ -107,6 +108,7 @@ async function runBuild(options) {
     }
 }
 async function buildProduction(options, startedAt) {
+    (0, entry_weight_1.entryWeightThreshold)(process.env);
     const ui = (0, cli_1.getProcessUi)();
     const workspace = productionWorkspace(options);
     (0, output_1.writeHeader)("build", [options.project, options.env]);
@@ -136,6 +138,7 @@ async function buildProduction(options, startedAt) {
     for (const step of exports.BUILD_STEPS)
         await runBuildStep(step, context);
     (0, vite_output_1.reportViteWarnings)(context.warnings, isVerbose, ui);
+    (0, entry_weight_1.reportEntryWeight)(ui, workspaceDir, process.env);
     (0, output_1.writeBlankLine)();
     ui.summary({
         headline: "Built the production frontend",

package/dist/commands/dev-action.d.ts

@@ -4,5 +4,7 @@ export interface DevOptions {
     force?: boolean;
     offline?: boolean;
     bootstrapSecret?: string;
+    project?: string;
+    env?: string;
 }
 export declare function runDev(options: DevOptions): Promise<void>;

package/dist/commands/dev-action.js

@@ -14,6 +14,7 @@ const manifest_1 = require("../manifest");
 const module_set_1 = require("../module-set");
 const project_modules_1 = require("../project-modules");
 const workspace_task_1 = require("./workspace-task");
+const BASE_ENVIRONMENT = "default";
 function clientHost() {
     const host = process.env.HOST?.trim();
     if (!host || host === "0.0.0.0" || host === "::" || host === "[::]") {
@@ -41,6 +42,10 @@ async function runDev(options) {
     const offline = (0, common_1.flagOrEnv)(options.offline, "DMS_OFFLINE");
     const sessionSecret = (0, common_1.resolveSessionSecret)("dev");
     const { backendUrl, workspaceKey, projectDir } = resolveBackend(options);
+    const project = {
+        projectDir: options.project ?? projectDir ?? process.cwd(),
+        environment: options.env ?? BASE_ENVIRONMENT,
+    };
     const bootstrapSecret = (0, common_1.resolveBootstrapSecret)(options.bootstrapSecret, backendUrl);
     const ui = (0, cli_1.getProcessUi)();
     (0, output_1.writeHeader)("dev", [backendUrl, "development"]);
@@ -58,6 +63,7 @@ async function runDev(options) {
         clientUrl,
         workspaceKey,
         bootstrapSecret,
+        project,
     });
     if (port !== requestedPort) {
         ui.message("warn", `Port ${requestedPort} is busy, using ${port}`);
@@ -103,16 +109,17 @@ async function runDev(options) {
             clientUrl,
             workspaceKey,
             bootstrapSecret: session.bootstrapSecret,
+            project,
         });
     }
 }
-function servedModules(setup) {
+function backendModuleSet(setup) {
     return (0, manifest_1.readCachedManifest)(setup.workspaceDir)?.manifest.modules ?? [];
 }
 function reportServed(session, setup) {
-    return (0, module_set_1.reportFrontendReady)(session.backendUrl, servedModules(setup).map((module) => ({
-        name: module.name,
-        version: module.path ? (0, project_modules_1.readShippingVersion)(module.path) : undefined,
+    return (0, module_set_1.reportFrontendReady)(session.backendUrl, setup.layers.map((layer) => ({
+        name: layer.name ?? layer.path,
+        version: (0, project_modules_1.readShippingVersion)(layer.path),
     })), session.bootstrapSecret);
 }
 async function serveWorkspace(session, setup) {
@@ -126,7 +133,7 @@ async function serveWorkspace(session, setup) {
                 session.bootstrapSecret = session.refreshBootstrapSecret();
                 return session.bootstrapSecret;
             },
-            fingerprint: (0, module_set_1.moduleSetFingerprint)(servedModules(setup)),
+            fingerprint: (0, module_set_1.moduleSetFingerprint)(backendModuleSet(setup)),
             onChange: () => restart.abort(),
             onUnchanged: () => void reportServed(session, setup),
         });

package/dist/commands/dev.js

@@ -50,8 +50,10 @@ const DEV_EXAMPLES = [
 function cmdDev() {
     const command = new commander_1.Command("dev")
         .summary("Run the dev server against a local backend, with hot reload")
-        .description("Run the dev server with hot reload. It reads the frontend modules in place, from the backend's own directories, so the backend runs on this machine.")
+        .description("Run the dev server with hot reload. It reads the frontend modules from the AntelopeJS project as build does, each module's frontendModule called with dev: true, and serves them in place from their sources. The backend, on this machine, gives the secrets it holds and says when the module store changes its modules.")
         .addOption(config_1.Options.backendUrl("Backend URL; when omitted, discovered from the enclosing antelope project's .antelope/dev.json"))
+        .addOption(new commander_1.Option("--project <dir>", "The AntelopeJS project the modules are read from (default: the discovered backend's, else the current directory)"))
+        .addOption(new commander_1.Option("-e, --env <environment>", "The AntelopeJS environment the backend runs, as ajs project dev -e (default: the base configuration)").env("ANTELOPEJS_LAUNCH_ENV"))
         .addOption(config_1.Options.port)
         .addOption(config_1.Options.force("Reinstall the workspace dependencies"))
         .addOption(config_1.Options.offline("Reuse the last cached manifest instead of fetching it"))

package/dist/commands/start-action.js

@@ -61,11 +61,40 @@ function publicOptionsById(modules) {
         ];
     }));
 }
+function builtModules(workspaceDir) {
+    try {
+        const { modules } = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(workspaceDir, "generated-frontend-modules.json"), "utf8"));
+        return (modules ?? []).map((module) => ({
+            name: module.name ?? module.id,
+            version: module.version,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function reportModuleSetDrift(built, modules) {
+    const builtNames = new Set(built.map(({ name }) => name));
+    const currentNames = new Set(modules.map(({ layer }) => layer.name ?? layer.path));
+    const added = [...currentNames].filter((name) => !builtNames.has(name));
+    const removed = [...builtNames].filter((name) => !currentNames.has(name));
+    if (added.length === 0 && removed.length === 0)
+        return;
+    const ui = (0, cli_1.getProcessUi)();
+    ui.message("warn", "The project's modules differ from the ones the build serves: rebuild to apply them", {
+        details: [
+            ...(added.length > 0
+                ? [`Not in the build: ${added.sort().join(", ")}`]
+                : []),
+            ...(removed.length > 0
+                ? [`Built, no longer in the project: ${removed.sort().join(", ")}`]
+                : []),
+            `${ui.symbols.levels.hint} Build again with the deployment's variables: ajs dms build`,
+        ],
+    });
+}
 async function reportServedModules(backendUrl, modules) {
-    const isTaken = await (0, module_set_1.reportFrontendReadyOnceAnswered)(backendUrl, modules.map(({ layer, version }) => ({
-        name: layer.name ?? layer.path,
-        version,
-    })), process.env.DMS_BOOTSTRAP_SECRET);
+    const isTaken = await (0, module_set_1.reportFrontendReadyOnceAnswered)(backendUrl, modules, process.env.DMS_BOOTSTRAP_SECRET);
     const ui = (0, cli_1.getProcessUi)();
     if (isTaken) {
         ui.message("info", `[DMS] Reported ${modules.length} modules to the backend (dms-frontend ${module_set_1.OWN_RELEASE.version})`);
@@ -116,6 +145,8 @@ async function runStart(options) {
         projectDir: options.project,
         environment: options.env,
     });
+    const built = builtModules(workspaceDir);
+    reportModuleSetDrift(built, modules);
     const secrets = (0, common_1.resolveManifestSecrets)({ published: {}, conflicts: [] });
     (0, common_1.reportManifestSecrets)(secrets, (count) => `Set ${count === 1 ? "it" : "them"} in the server's environment, with the value${count === 1 ? "" : "s"} the backend uses`);
     reportUnfilledPrivateValues(workspaceDir);
@@ -148,7 +179,7 @@ async function runStart(options) {
                 ]),
                 footer: "Ctrl+C to stop",
             });
-            void reportServedModules(backendUrl, modules);
+            void reportServedModules(backendUrl, built);
             void (0, update_check_1.reportAvailableUpdate)({ isFollowed: true });
         },
     });

package/dist/common.d.ts

@@ -8,6 +8,7 @@ export * from "./manifest-secrets";
 export * from "./layer-watch";
 export * from "./materialize";
 export * from "./derived-outputs";
+export * from "./locale-files";
 export * from "./app-configs";
 export * from "./renderer-range";
 export * from "./workspace";

package/dist/common.js

@@ -24,6 +24,7 @@ __exportStar(require("./manifest-secrets"), exports);
 __exportStar(require("./layer-watch"), exports);
 __exportStar(require("./materialize"), exports);
 __exportStar(require("./derived-outputs"), exports);
+__exportStar(require("./locale-files"), exports);
 __exportStar(require("./app-configs"), exports);
 __exportStar(require("./renderer-range"), exports);
 __exportStar(require("./workspace"), exports);

package/dist/config.js

@@ -63,11 +63,14 @@ exports.TEMPLATE_FILES = [
     ["compress-assets.mjs", "compress-assets.mjs"],
     ["head-order.mjs", "head-order.mjs"],
     ["client-chunking.mjs", "client-chunking.mjs"],
+    ["entry-weight.mjs", "entry-weight.mjs"],
     ["client-server-guard.mjs", "client-server-guard.mjs"],
     ["ui-inertia-page.mjs", "ui-inertia-page.mjs"],
     ["ui-request-state.mjs", "ui-request-state.mjs"],
+    ["sfc-global-types.mjs", "sfc-global-types.mjs"],
     ["icon-api.mjs", "icon-api.mjs"],
     ["icon-scan.mjs", "icon-scan.mjs"],
+    ["ui-kbd.mjs", "ui-kbd.mjs"],
     ["email-renderer.ts", "email-renderer.ts"],
     ["email-runtime.ts", "email-runtime.ts"],
     ["email-locales.ts", "email-locales.ts"],

package/dist/derived-outputs.d.ts

@@ -3,6 +3,7 @@ export interface FrontendModuleRegistryEntry {
     id: string;
     name?: string;
     packageName?: string;
+    version?: string;
     root: string;
     priority: number;
     entry?: string;
@@ -14,11 +15,6 @@ export interface FrontendModuleRegistry {
     modules: FrontendModuleRegistryEntry[];
 }
 export declare function createFrontendModuleRegistry(workspaceDir: string, layers: ResolvedLayer[]): FrontendModuleRegistry;
-export declare class InvalidLocaleFileError extends Error {
-    readonly path: string;
-    readonly reason: string;
-    constructor(path: string, reason: string);
-}
 export declare function affectsLocaleMessages(relativePath: string): boolean;
 export declare function writeLocaleMessages(workspaceDir: string, registry: FrontendModuleRegistry): boolean;
 export interface DerivedOutput {

package/dist/derived-outputs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DERIVED_OUTPUTS = exports.InvalidLocaleFileError = void 0;
+exports.DERIVED_OUTPUTS = void 0;
 exports.createFrontendModuleRegistry = createFrontendModuleRegistry;
 exports.affectsLocaleMessages = affectsLocaleMessages;
 exports.writeLocaleMessages = writeLocaleMessages;
@@ -8,9 +8,11 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const config_1 = require("./config");
 const app_configs_1 = require("./app-configs");
+const locale_files_1 = require("./locale-files");
 const asset_roots_1 = require("./asset-roots");
 const layer_aliases_1 = require("./layer-aliases");
 const layers_1 = require("./layers");
+const project_modules_1 = require("./project-modules");
 const fs_sync_1 = require("./fs-sync");
 const GENERATED_MODULE_ID = /^[A-Za-z0-9_-]+$/;
 function validateFrontendModuleRegistry(registry, workspaceDir) {
@@ -42,6 +44,7 @@ function createFrontendModuleRegistry(workspaceDir, layers) {
             id: (0, layers_1.getLayerSafeName)(layer),
             name: layer.name ?? layer.packageName,
             packageName: layer.packageName,
+            version: (0, project_modules_1.readShippingVersion)(layer.sourcePath ?? layer.path),
             root: (0, layers_1.getLayerWorkspacePath)(workspaceDir, layer),
             priority: layer.priority ?? 0,
             entry: (0, node_fs_1.existsSync)(sourceEntry) ? config_1.FRONTEND_MODULE_ENTRY : undefined,
@@ -148,24 +151,6 @@ function mergeLocaleMessages(source, existing) {
     return merged;
 }
 const LOCALE_DIRECTORY = "i18n/locales";
-class InvalidLocaleFileError extends Error {
-    constructor(path, reason) {
-        super(`Invalid locale file ${path}: ${reason}`);
-        this.path = path;
-        this.reason = reason;
-        this.name = "InvalidLocaleFileError";
-    }
-}
-exports.InvalidLocaleFileError = InvalidLocaleFileError;
-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 InvalidLocaleFileError(path, reason);
-    }
-}
 function readLocaleMessages(assets, registry) {
     const roots = new Map(registry.modules.map((module) => [module.id, module.root]));
     const messages = {};
@@ -174,7 +159,7 @@ function readLocaleMessages(assets, registry) {
         const root = roots.get(asset.moduleId);
         if (!locale || !root)
             continue;
-        const value = readLocaleFile((0, node_path_1.join)(root, asset.relativePath));
+        const value = (0, locale_files_1.readLocaleFile)((0, node_path_1.join)(root, asset.relativePath));
         messages[locale] = mergeLocaleMessages(value, messages[locale] ?? {});
     }
     return messages;
@@ -182,13 +167,28 @@ function readLocaleMessages(assets, registry) {
 function affectsLocaleMessages(relativePath) {
     return (0, asset_roots_1.affectsAssetDirectory)(LOCALE_DIRECTORY, relativePath);
 }
+const FALLBACK_LOCALE = "en";
+const RENDERER_TRANSLATED_KEYS = ["error.network"];
+function withoutMessage(messages, key) {
+    const [head, ...rest] = key.split(".");
+    if (!(head in messages))
+        return messages;
+    const { [head]: value, ...others } = messages;
+    if (!rest.length)
+        return others;
+    if (!isRecord(value))
+        return messages;
+    const remaining = withoutMessage(value, rest.join("."));
+    return Object.keys(remaining).length
+        ? { ...others, [head]: remaining }
+        : others;
+}
 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>;
+    const loaders = supportedLocales.map((locale) => `  ${JSON.stringify(locale)}: () => import(${JSON.stringify(`./locales.generated/${locale}`)}),`);
+    const fallback = supportedLocales.includes(FALLBACK_LOCALE)
+        ? FALLBACK_LOCALE
+        : supportedLocales[0];
+    return `type LocaleMessages = Record<string, unknown>;
 type LocaleLoader = () => Promise<{ default: LocaleMessages }>;
 interface LocaleMessagesTarget {
   setLocaleMessage(locale: string, messages: LocaleMessages): void;
@@ -200,13 +200,13 @@ interface LocaleState {
 }
 
 export const supportedLocales = ${JSON.stringify(supportedLocales)};
+const fallbackLocale: string | undefined = ${JSON.stringify(fallback)};
 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 },
+  messages: {},
   targets: new Set(),
   version: 0,
 };
@@ -216,11 +216,20 @@ async function readLocaleMessages(locale: string): Promise<LocaleMessages> {
   return (await localeLoaders[locale]()).default;
 }
 
-export async function loadLocaleMessages(locale: string): Promise<LocaleMessages> {
+/**
+ * The catalog that serves \`locale\`: its own when the application has one,
+ * else the fallback locale's.
+ */
+export function catalogLocale(locale: string): string | undefined {
   const normalized = locale.slice(0, 2);
-  if (!localeLoaders[normalized]) return localeMessages.en;
-  localeMessages[normalized] ??= await readLocaleMessages(normalized);
-  return localeMessages[normalized];
+  return normalized in localeLoaders ? normalized : fallbackLocale;
+}
+
+export async function loadLocaleMessages(locale: string): Promise<LocaleMessages> {
+  const catalog = catalogLocale(locale);
+  if (!catalog) return {};
+  localeMessages[catalog] ??= await readLocaleMessages(catalog);
+  return localeMessages[catalog];
 }
 
 /** Development only: applies every regenerated catalog to \`target\`. */
@@ -262,10 +271,14 @@ function writeLocaleMessages(workspaceDir, registry) {
         changed = (0, fs_sync_1.applyContent)(content, path) || changed;
     };
     (0, node_fs_1.mkdirSync)(outputDir, { recursive: true });
+    const fallback = RENDERER_TRANSLATED_KEYS.reduce(withoutMessage, messages[FALLBACK_LOCALE] ?? {});
     for (const [locale, value] of Object.entries(messages)) {
         const catalog = JSON.stringify(value);
+        const complete = locale === FALLBACK_LOCALE
+            ? catalog
+            : JSON.stringify(mergeLocaleMessages(fallback, value));
         apply(catalog, (0, node_path_1.join)(outputDir, `${locale}.json`));
-        apply(`const messages = ${catalog};\nexport default messages;\n`, (0, node_path_1.join)(outputDir, `${locale}.ts`));
+        apply(`const messages = ${complete};\nexport default messages;\n`, (0, node_path_1.join)(outputDir, `${locale}.ts`));
         outputs.add(`${locale}.json`).add(`${locale}.ts`);
     }
     const supportedLocales = Object.keys(messages);

package/dist/dev-modules.d.ts

@@ -0,0 +1,5 @@
+import type { ProjectFrontendModule, ProjectModulesOptions } from "./project-modules";
+import type { Manifest, ResolvedLayer } from "./workspace";
+export declare function readProjectModulesFresh(options: ProjectModulesOptions): Promise<ProjectFrontendModule[]>;
+export declare function warnModuleDrift(layers: readonly ResolvedLayer[], manifest: Manifest): void;
+export declare function withBackendValues(modules: readonly ProjectFrontendModule[], manifest: Manifest): ResolvedLayer[];

package/dist/dev-modules.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readProjectModulesFresh = readProjectModulesFresh;
+exports.warnModuleDrift = warnModuleDrift;
+exports.withBackendValues = withBackendValues;
+const node_child_process_1 = require("node:child_process");
+const cli_1 = require("@antelopejs/core/cli");
+const private_values_1 = require("./private-values");
+function readProjectModulesFresh(options) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.fork)(require.resolve("./project-modules-child"), [], {
+            stdio: ["ignore", "inherit", "inherit", "ipc"],
+        });
+        let reply;
+        child.once("message", (message) => {
+            reply = message;
+        });
+        child.once("error", reject);
+        child.once("exit", (code, signal) => {
+            if (!reply) {
+                reject(new Error(`Reading the project's modules stopped (${signal ?? `exit code ${code}`})`));
+                return;
+            }
+            const ui = (0, cli_1.getProcessUi)();
+            for (const message of reply.messages)
+                ui.message(...message);
+            if ("modules" in reply)
+                resolve(reply.modules);
+            else if ("problem" in reply)
+                reject(new cli_1.CliError(reply.problem));
+            else
+                reject(new Error(reply.failure));
+        });
+        child.send(options);
+    });
+}
+const URL_BOUNDARY = "(?=[/?#]|$)";
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function rewriteOrigins(options, rewrites) {
+    if (rewrites.length === 0)
+        return options;
+    const replacements = new Map(rewrites.map(({ from, to }) => [from, to]));
+    const alternation = [...replacements.keys()]
+        .sort((left, right) => right.length - left.length)
+        .map(escapeRegExp)
+        .join("|");
+    const pattern = new RegExp(`(?:${alternation})${URL_BOUNDARY}`, "g");
+    const rewrite = (value) => {
+        if (typeof value === "string")
+            return value.replace(pattern, (match) => replacements.get(match) ?? match);
+        if (Array.isArray(value))
+            return value.map(rewrite);
+        if (value !== null && typeof value === "object")
+            return rewriteObject(value);
+        return value;
+    };
+    const rewriteObject = (value) => Object.fromEntries(Object.entries(value).map(([key, item]) => [key, rewrite(item)]));
+    return rewriteObject(options);
+}
+function warnModuleDrift(layers, manifest) {
+    const served = new Set(layers.map((layer) => layer.name ?? ""));
+    const registered = new Set(manifest.modules.map((module) => module.name));
+    const ui = (0, cli_1.getProcessUi)();
+    for (const name of served) {
+        if (!registered.has(name))
+            ui.message("warn", `${name} is served from the project, but the backend does not register it`, {
+                detail: "Its frontendModule returns a registration the running backend did not add: check the module's configuration and startup",
+            });
+    }
+    for (const name of registered) {
+        if (!served.has(name))
+            ui.message("warn", `${name} is registered by the backend, but not in the project: its pages are left out`, {
+                detail: `A build leaves it out too. Declare its frontendModule (dmsFrontend in its package.json), or add the module to antelope.config.ts`,
+            });
+    }
+}
+function withBackendValues(modules, manifest) {
+    const registered = new Map(manifest.modules.map((module) => [module.name, module]));
+    return modules.map(({ layer }) => ({
+        ...layer,
+        options: layer.options &&
+            rewriteOrigins(layer.options, manifest.originRewrites ?? []),
+        privateOptions: layer.privateOptions &&
+            (0, private_values_1.filledOptions)(layer.privateOptions, registered.get(layer.name ?? "")?.privateOptions),
+    }));
+}

package/dist/entry-weight.d.ts

@@ -0,0 +1,24 @@
+export declare const ENTRY_WEIGHT_VARIABLE = "DMS_ENTRY_WEIGHT_WARNING";
+export declare const DEFAULT_ENTRY_WEIGHT_WARNING_KB = 50;
+export interface EntryShare {
+    owner: string;
+    bytes: number;
+    brotli: number;
+}
+export interface EntryWeight {
+    bytes: number;
+    brotli: number;
+    shares: EntryShare[];
+}
+export declare function readEntryWeight(workspaceDir: string): EntryWeight | undefined;
+export declare function entryWeightThreshold(env: NodeJS.ProcessEnv): number;
+export declare function heavyEntryModules(weight: EntryWeight, threshold: number): EntryShare[];
+export declare function describeEntryShares(weight: EntryWeight): string[];
+interface ReportUi {
+    message(level: "info" | "warn", text: string, options?: {
+        detail?: string;
+        details?: string[];
+    }): void;
+}
+export declare function reportEntryWeight(ui: ReportUi, workspaceDir: string, env: NodeJS.ProcessEnv): void;
+export {};

package/dist/entry-weight.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ENTRY_WEIGHT_WARNING_KB = exports.ENTRY_WEIGHT_VARIABLE = void 0;
+exports.readEntryWeight = readEntryWeight;
+exports.entryWeightThreshold = entryWeightThreshold;
+exports.heavyEntryModules = heavyEntryModules;
+exports.describeEntryShares = describeEntryShares;
+exports.reportEntryWeight = reportEntryWeight;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_zlib_1 = require("node:zlib");
+const cli_1 = require("@antelopejs/core/cli");
+const output_1 = require("./output");
+exports.ENTRY_WEIGHT_VARIABLE = "DMS_ENTRY_WEIGHT_WARNING";
+exports.DEFAULT_ENTRY_WEIGHT_WARNING_KB = 50;
+const ENTRY_WEIGHT_FILE = (0, node_path_1.join)("dist", "client", ".vite", "entry-weight.json");
+const SHARED_OWNER = "shared";
+const TRANSLATIONS_OWNER = "translations";
+const NON_MODULE_OWNERS = new Set([SHARED_OWNER, TRANSLATIONS_OWNER]);
+const BYTES_PER_KB = 1024;
+function brotliSize(file) {
+    const compressed = `${file}.br`;
+    if ((0, node_fs_1.existsSync)(compressed))
+        return (0, node_fs_1.statSync)(compressed).size;
+    return (0, node_zlib_1.brotliCompressSync)((0, node_fs_1.readFileSync)(file), {
+        params: { [node_zlib_1.constants.BROTLI_PARAM_QUALITY]: node_zlib_1.constants.BROTLI_MAX_QUALITY },
+    }).length;
+}
+function readEntryWeight(workspaceDir) {
+    const path = (0, node_path_1.join)(workspaceDir, ENTRY_WEIGHT_FILE);
+    if (!(0, node_fs_1.existsSync)(path))
+        return undefined;
+    const recorded = JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+    const brotli = recorded.files.reduce((sum, file) => sum + brotliSize((0, node_path_1.join)(workspaceDir, "dist", "client", file)), 0);
+    const ratio = recorded.bytes ? brotli / recorded.bytes : 0;
+    const shares = Object.entries(recorded.owners)
+        .map(([owner, bytes]) => ({
+        owner,
+        bytes,
+        brotli: Math.round(bytes * ratio),
+    }))
+        .sort((left, right) => right.bytes - left.bytes);
+    return { bytes: recorded.bytes, brotli, shares };
+}
+function entryWeightThreshold(env) {
+    const value = env[exports.ENTRY_WEIGHT_VARIABLE]?.trim();
+    if (!value)
+        return exports.DEFAULT_ENTRY_WEIGHT_WARNING_KB * BYTES_PER_KB;
+    const kilobytes = Number(value);
+    if (!Number.isFinite(kilobytes) || kilobytes < 0)
+        throw new cli_1.CliError({
+            title: `${exports.ENTRY_WEIGHT_VARIABLE} is not a size`,
+            reason: `It is ${JSON.stringify(value)}; it takes a number of KB of Brotli.`,
+            fixes: [
+                `Set ${exports.ENTRY_WEIGHT_VARIABLE}=${exports.DEFAULT_ENTRY_WEIGHT_WARNING_KB}, or 0 to turn the warning off`,
+            ],
+        });
+    return kilobytes * BYTES_PER_KB;
+}
+function heavyEntryModules(weight, threshold) {
+    if (threshold <= 0)
+        return [];
+    return weight.shares.filter((share) => !NON_MODULE_OWNERS.has(share.owner) && share.brotli > threshold);
+}
+function describeEntryShares(weight) {
+    return weight.shares.map((share) => `${share.owner}  ${(0, output_1.formatSize)(share.brotli)} (${(0, output_1.formatSize)(share.bytes)})`);
+}
+function reportEntryWeight(ui, workspaceDir, env) {
+    const threshold = entryWeightThreshold(env);
+    const weight = readEntryWeight(workspaceDir);
+    if (!weight)
+        return;
+    ui.message("info", `Client entry ${(0, output_1.formatSize)(weight.brotli)} Brotli (${(0, output_1.formatSize)(weight.bytes)}), loaded first by every page`, { details: describeEntryShares(weight) });
+    const heavy = heavyEntryModules(weight, threshold);
+    heavy.forEach((share, index) => {
+        const isLast = index === heavy.length - 1;
+        ui.message("warn", `${share.owner} adds ${(0, output_1.formatSize)(share.brotli)} Brotli to the client entry`, {
+            details: isLast
+                ? [
+                    "What a module's dms.frontend.ts and its plugins import is loaded by every page: render a component they only show on some pages by its registered name or with defineAsyncComponent",
+                    `The threshold is ${(0, output_1.formatSize)(threshold)} (${exports.ENTRY_WEIGHT_VARIABLE}, in KB; 0 turns the warning off)`,
+                ]
+                : [],
+        });
+    });
+}

package/dist/help.js

@@ -17,9 +17,13 @@ exports.ENVIRONMENT_VARIABLES = [
     ["DMS_WORKSPACE_DIR", "Same as build and start --workspace"],
     [
         "ANTELOPEJS_LAUNCH_ENV",
-        "AntelopeJS environment build and start evaluate the project in, same as -e",
+        "AntelopeJS environment dev, build and start evaluate the project in, same as -e",
     ],
     ["DMS_PREPARE_STRICT", "Same as prepare --strict, read like DMS_OFFLINE"],
+    [
+        "DMS_ENTRY_WEIGHT_WARNING",
+        "KB of Brotli a module may add to the client entry before build warns (default: 50; 0: never)",
+    ],
     ["PORT", "Same as -p"],
     [
         "HOST",

package/dist/layer-watch.js

@@ -12,6 +12,7 @@ const child_output_1 = require("./child-output");
 const config_1 = require("./config");
 const layers_1 = require("./layers");
 const derived_outputs_1 = require("./derived-outputs");
+const locale_files_1 = require("./locale-files");
 const output_1 = require("./output");
 const fs_sync_1 = require("./fs-sync");
 const WATCH_DEBOUNCE_MS = 80;
@@ -128,11 +129,11 @@ function createLayerSync(src, dest, reporter, onStaged) {
 }
 function describeOutputFailure(output, err, reporter) {
     const kept = `The dev server keeps the previous ${output.name} until the file is fixed.`;
-    if (err instanceof derived_outputs_1.InvalidLocaleFileError) {
+    if (err instanceof locale_files_1.InvalidLocaleFileError) {
         const file = reporter.show(err.path);
         return {
             text: `${file} is not a valid locale file`,
-            options: { details: [err.reason, kept] },
+            options: { details: [...err.reason.split("\n"), kept] },
             fixed: [`${file} fixed`, `${output.name} regenerated`].join((0, cli_1.getProcessUi)().symbols.separator),
         };
     }

package/dist/layers.d.ts

@@ -11,6 +11,7 @@ export interface LayerPackage {
     name?: unknown;
     engines?: Record<string, unknown>;
     dmsFrontend?: unknown;
+    antelopeJs?: unknown;
 }
 export declare function readLayerPackage(layerPath: string): LayerPackage | undefined;
 export declare function buildLayersFromPaths(modules: ServedWithPath[]): ResolvedLayer[];

package/dist/locale-files.d.ts

@@ -0,0 +1,6 @@
+export declare class InvalidLocaleFileError extends Error {
+    readonly path: string;
+    readonly reason: string;
+    constructor(path: string, reason: string);
+}
+export declare function readLocaleFile(path: string): Record<string, unknown>;