@antelopejs/dms-frontend 0.9.3 → 0.10.1

package/dist/internal/built-workspace.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readBuiltPrivateOptions = readBuiltPrivateOptions;
+exports.readBuiltModules = readBuiltModules;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("../config");
+const guards_1 = require("./guards");
+const manifest_decoder_1 = require("./manifest-decoder");
+const plain_object_1 = require("./plain-object");
+function isOptionsById(value) {
+    return (0, plain_object_1.isPlainObject)(value) && Object.values(value).every(manifest_decoder_1.isModuleOptions);
+}
+function readBuiltPrivateOptions(workspaceDir) {
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(workspaceDir, config_1.SERVER_OPTIONS_FILE), "utf8"));
+        const modules = (0, plain_object_1.isPlainObject)(parsed) ? parsed.modules : undefined;
+        return isOptionsById(modules) ? modules : {};
+    }
+    catch {
+        return {};
+    }
+}
+function readBuiltModules(workspaceDir) {
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(workspaceDir, "generated-frontend-modules.json"), "utf8"));
+        const modules = (0, plain_object_1.isPlainObject)(parsed) ? parsed.modules : undefined;
+        if (!Array.isArray(modules))
+            return [];
+        const listed = modules;
+        return listed.flatMap((module) => (0, plain_object_1.isPlainObject)(module) && (0, guards_1.isText)(module.id)
+            ? [
+                {
+                    name: (0, guards_1.isText)(module.name) ? module.name : module.id,
+                    version: (0, guards_1.isText)(module.version) ? module.version : undefined,
+                },
+            ]
+            : []);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/internal/ensure.d.ts

@@ -0,0 +1 @@
+export declare function ensure(condition: boolean, title: string, reason?: string): asserts condition;

package/dist/internal/ensure.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensure = ensure;
+const cli_1 = require("@antelopejs/core/cli");
+function ensure(condition, title, reason) {
+    if (!condition)
+        throw new cli_1.CliError({ title, reason });
+}

package/dist/internal/locale-catalogs.d.ts

@@ -1,6 +1,11 @@
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export declare function mergeLocaleMessages(source: Record<string, unknown>, existing: Record<string, unknown>): Record<string, unknown>;
+export type LocaleValue = string | number | boolean | null | LocaleValue[] | LocaleMessages;
+export interface LocaleMessages {
+    [key: string]: LocaleValue;
+}
+export declare function isLocaleValue(value: unknown): value is LocaleValue;
+export declare function isMessageGroup(value: LocaleValue): value is LocaleMessages;
+export declare function mergeLocaleMessages(source: LocaleMessages, existing: LocaleMessages): LocaleMessages;
 export declare const FALLBACK_LOCALE = "en";
 export declare const RENDERER_TRANSLATED_KEYS: string[];
-export declare function withoutMessage(messages: Record<string, unknown>, key: string): Record<string, unknown>;
+export declare function withoutMessage(messages: LocaleMessages, key: string): LocaleMessages;
 export declare function localeModuleSource(supportedLocales: string[]): string;

package/dist/internal/locale-catalogs.js

@@ -1,19 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RENDERER_TRANSLATED_KEYS = exports.FALLBACK_LOCALE = void 0;
-exports.isRecord = isRecord;
+exports.isLocaleValue = isLocaleValue;
+exports.isMessageGroup = isMessageGroup;
 exports.mergeLocaleMessages = mergeLocaleMessages;
 exports.withoutMessage = withoutMessage;
 exports.localeModuleSource = localeModuleSource;
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+const guards_1 = require("./guards");
+function isLocaleValue(value) {
+    if (value === null || (0, guards_1.isText)(value) || (0, guards_1.isNumber)(value) || (0, guards_1.isFlag)(value)) {
+        return true;
+    }
+    if (Array.isArray(value))
+        return value.every(isLocaleValue);
+    return (0, guards_1.isObjectLike)(value) && Object.values(value).every(isLocaleValue);
+}
+function isMessageGroup(value) {
+    return (0, guards_1.isObjectLike)(value) && !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)
+            isMessageGroup(sourceValue) && isMessageGroup(value)
                 ? mergeLocaleMessages(sourceValue, value)
                 : value;
     }
@@ -23,12 +33,12 @@ exports.FALLBACK_LOCALE = "en";
 exports.RENDERER_TRANSLATED_KEYS = ["error.network"];
 function withoutMessage(messages, key) {
     const [head, ...rest] = key.split(".");
-    if (!(head in messages))
+    if (!Object.prototype.hasOwnProperty.call(messages, head))
         return messages;
     const { [head]: value, ...others } = messages;
     if (!rest.length)
         return others;
-    if (!isRecord(value))
+    if (!isMessageGroup(value))
         return messages;
     const remaining = withoutMessage(value, rest.join("."));
     return Object.keys(remaining).length

package/dist/internal/manifest-decoder.d.ts

@@ -0,0 +1,7 @@
+import type { FrontendModuleOptions, Manifest, ManifestModule } from "../workspace";
+export declare function isModuleOptions(value: unknown): value is FrontendModuleOptions;
+export declare function isManifestModule(value: unknown): value is ManifestModule;
+export declare function isManifest(value: unknown): value is Manifest;
+export declare function hasManifestVersion(value: unknown): value is {
+    version: number;
+};

package/dist/internal/manifest-decoder.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isModuleOptions = isModuleOptions;
+exports.isManifestModule = isManifestModule;
+exports.isManifest = isManifest;
+exports.hasManifestVersion = hasManifestVersion;
+const guards_1 = require("./guards");
+const plain_object_1 = require("./plain-object");
+function isList(value) {
+    return Array.isArray(value);
+}
+function isTextList(value) {
+    return isList(value) && value.every(guards_1.isText);
+}
+function isModuleValue(value) {
+    if (value === null || (0, guards_1.isText)(value) || (0, guards_1.isNumber)(value) || (0, guards_1.isFlag)(value))
+        return true;
+    return isList(value) ? value.every(isModuleValue) : isModuleOptions(value);
+}
+function isModuleOptions(value) {
+    return (0, plain_object_1.isPlainObject)(value) && Object.values(value).every(isModuleValue);
+}
+function isPublicEndpoint(value) {
+    return ((0, plain_object_1.isPlainObject)(value) &&
+        (0, guards_1.isText)(value.path) &&
+        (value.methods === undefined || isTextList(value.methods)) &&
+        (value.headers === undefined || isTextList(value.headers)));
+}
+function isBackendProxy(value) {
+    return ((0, plain_object_1.isPlainObject)(value) &&
+        (0, guards_1.isText)(value.path) &&
+        (value.auth === undefined ||
+            value.auth === "session" ||
+            value.auth === "none") &&
+        (value.maxBodyBytes === undefined || (0, guards_1.isNumber)(value.maxBodyBytes)));
+}
+function isRenderer(value) {
+    return (0, plain_object_1.isPlainObject)(value) && (0, guards_1.isText)(value.name) && (0, guards_1.isText)(value.version);
+}
+function hasOptionalFields(value) {
+    return ((0, plain_object_1.isPlainObject)(value) &&
+        (value.renderer === undefined || isRenderer(value.renderer)) &&
+        (value.path === undefined || (0, guards_1.isText)(value.path)) &&
+        (value.options === undefined || isModuleOptions(value.options)) &&
+        (value.privateOptions === undefined ||
+            isModuleOptions(value.privateOptions)) &&
+        (value.configKey === undefined || (0, guards_1.isText)(value.configKey)));
+}
+function hasOptionalLists(value) {
+    return ((0, plain_object_1.isPlainObject)(value) &&
+        (value.authEstablishEndpoints === undefined ||
+            isTextList(value.authEstablishEndpoints)) &&
+        (value.publicEndpoints === undefined ||
+            (isList(value.publicEndpoints) &&
+                value.publicEndpoints.every(isPublicEndpoint))) &&
+        (value.backendProxies === undefined ||
+            (isList(value.backendProxies) &&
+                value.backendProxies.every(isBackendProxy))));
+}
+function isManifestModule(value) {
+    return ((0, plain_object_1.isPlainObject)(value) &&
+        (0, guards_1.isText)(value.name) &&
+        (0, guards_1.isNumber)(value.priority) &&
+        hasOptionalFields(value) &&
+        hasOptionalLists(value));
+}
+function isOriginRewrite(value) {
+    return (0, plain_object_1.isPlainObject)(value) && (0, guards_1.isText)(value.from) && (0, guards_1.isText)(value.to);
+}
+function isManifest(value) {
+    return ((0, plain_object_1.isPlainObject)(value) &&
+        isList(value.modules) &&
+        value.modules.every(isManifestModule) &&
+        (value.settling === undefined || (0, guards_1.isFlag)(value.settling)) &&
+        (value.originRewrites === undefined ||
+            (isList(value.originRewrites) &&
+                value.originRewrites.every(isOriginRewrite))));
+}
+function hasManifestVersion(value) {
+    return (0, plain_object_1.isPlainObject)(value) && (0, guards_1.isNumber)(value.version);
+}

package/dist/internal/own-release.d.ts

@@ -0,0 +1,5 @@
+export interface OwnRelease {
+    name: string;
+    version: string;
+}
+export declare const ownRelease: OwnRelease;

package/dist/internal/own-release.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ownRelease = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const guards_1 = require("./guards");
+function isOwnRelease(value) {
+    return ((0, guards_1.isObjectLike)(value) &&
+        "name" in value &&
+        (0, guards_1.isText)(value.name) &&
+        "version" in value &&
+        (0, guards_1.isText)(value.version));
+}
+function readOwnRelease() {
+    const manifest = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "..", "..", "package.json"), "utf8"));
+    if (!isOwnRelease(manifest))
+        throw new Error("The package.json of dms-frontend has no name or version");
+    return manifest;
+}
+exports.ownRelease = readOwnRelease();

package/dist/internal/plain-object.d.ts

@@ -0,0 +1 @@
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;

package/dist/internal/plain-object.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = isPlainObject;
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/internal/prepared-workspace.d.ts

@@ -0,0 +1,12 @@
+import type { ResolvedLayer } from "../workspace";
+export type RecordedLayer = Pick<ResolvedLayer, "path" | "name" | "sourcePath" | "packageName">;
+export type PreparedWorkspace = {
+    prepared: true;
+    layers: RecordedLayer[];
+} | {
+    prepared: false;
+    reason: string;
+};
+export declare function forgetPreparedLayers(workspaceDir: string): void;
+export declare function recordPreparedLayers(workspaceDir: string, layers: readonly ResolvedLayer[]): void;
+export declare function readPreparedWorkspace(workspaceDir: string): PreparedWorkspace;

package/dist/internal/prepared-workspace.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forgetPreparedLayers = forgetPreparedLayers;
+exports.recordPreparedLayers = recordPreparedLayers;
+exports.readPreparedWorkspace = readPreparedWorkspace;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("../config");
+const workspace_setup_1 = require("../workspace-setup");
+const guards_1 = require("./guards");
+const plain_object_1 = require("./plain-object");
+const PREPARED_LAYERS_FILE = ".dms-build-layers.json";
+const OPTIONAL_TEXT_KEYS = ["name", "sourcePath", "packageName"];
+function isRecordedLayer(value) {
+    return ((0, plain_object_1.isPlainObject)(value) &&
+        Object.prototype.hasOwnProperty.call(value, "path") &&
+        (0, guards_1.isText)(value.path) &&
+        OPTIONAL_TEXT_KEYS.every((key) => !Object.prototype.hasOwnProperty.call(value, key) || (0, guards_1.isText)(value[key])));
+}
+function readRecord(workspaceDir) {
+    let parsed;
+    try {
+        parsed = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(workspaceDir, PREPARED_LAYERS_FILE), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    if (!(0, plain_object_1.isPlainObject)(parsed) ||
+        !Object.prototype.hasOwnProperty.call(parsed, "installed"))
+        return undefined;
+    const { installed } = parsed;
+    if (!(0, guards_1.isFlag)(installed) ||
+        !Object.prototype.hasOwnProperty.call(parsed, "layers"))
+        return undefined;
+    const { layers } = parsed;
+    if (!Array.isArray(layers))
+        return undefined;
+    const listed = layers;
+    return listed.every(isRecordedLayer)
+        ? { installed, layers: listed }
+        : undefined;
+}
+function forgetPreparedLayers(workspaceDir) {
+    (0, node_fs_1.rmSync)((0, node_path_1.join)(workspaceDir, PREPARED_LAYERS_FILE), { force: true });
+}
+function recordPreparedLayers(workspaceDir, layers) {
+    const record = {
+        installed: !(0, workspace_setup_1.needsInstall)(workspaceDir, layers.map((layer) => layer.path), false),
+        layers: layers.map(({ path, name, sourcePath, packageName }) => ({
+            path,
+            name,
+            sourcePath,
+            packageName,
+        })),
+    };
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, PREPARED_LAYERS_FILE), `${JSON.stringify(record, null, 2)}\n`);
+}
+function readPreparedWorkspace(workspaceDir) {
+    const record = readRecord(workspaceDir);
+    if (!record)
+        return {
+            prepared: false,
+            reason: "No production setup finished in it.",
+        };
+    const installed = record.installed &&
+        (0, node_fs_1.existsSync)((0, node_path_1.join)(workspaceDir, config_1.DEPS_HASH_FILE)) &&
+        (0, node_fs_1.existsSync)((0, node_path_1.join)(workspaceDir, "node_modules"));
+    if (!installed)
+        return {
+            prepared: false,
+            reason: "Its dependencies are not installed, or changed since they were.",
+        };
+    return { prepared: true, layers: record.layers };
+}

package/dist/internal/text-list.d.ts

@@ -0,0 +1 @@
+export declare function isTextList(value: unknown): value is string[];

package/dist/internal/text-list.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTextList = isTextList;
+const guards_1 = require("./guards");
+function isTextList(value) {
+    if (!Array.isArray(value))
+        return false;
+    const items = value;
+    return items.every(guards_1.isText);
+}

package/dist/internal/vite-manifest.d.ts

@@ -0,0 +1,6 @@
+export interface ViteChunk {
+    file: string;
+    src?: string;
+    isEntry?: boolean;
+}
+export declare function parseViteManifest(content: string, label: string): ViteChunk[];

package/dist/internal/vite-manifest.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseViteManifest = parseViteManifest;
+const cli_1 = require("@antelopejs/core/cli");
+const guards_1 = require("./guards");
+const plain_object_1 = require("./plain-object");
+function isViteChunk(value) {
+    return ((0, plain_object_1.isPlainObject)(value) &&
+        (0, guards_1.isText)(value.file) &&
+        (value.src === undefined || (0, guards_1.isText)(value.src)) &&
+        (value.isEntry === undefined || (0, guards_1.isFlag)(value.isEntry)));
+}
+function parseViteManifest(content, label) {
+    const manifest = JSON.parse(content);
+    const chunks = (0, plain_object_1.isPlainObject)(manifest)
+        ? Object.values(manifest)
+        : [];
+    if (!(0, plain_object_1.isPlainObject)(manifest) || !chunks.every(isViteChunk))
+        throw new cli_1.CliError({
+            title: `The ${label} is not a Vite manifest`,
+            reason: "Every entry of it must name the chunk's file.",
+        });
+    return chunks;
+}

package/dist/layer-watch.js

@@ -24,11 +24,11 @@ function createSyncFailures(src, reporter) {
     const failed = new Set();
     const show = (rel) => reporter.show((0, node_path_1.join)(src, rel));
     return {
-        fail(rel, err) {
+        fail(rel, errorLines) {
             failed.add(rel);
             reporter.warn(`${show(rel)} not copied to the workspace`, {
                 details: [
-                    ...reporter.describe(err),
+                    ...errorLines,
                     "The dev server keeps its previous version until the next save.",
                 ],
             });
@@ -73,7 +73,7 @@ function createLayerSync(src, dest, reporter, onStaged) {
             failures.applied(rel);
         }
         catch (err) {
-            failures.fail(rel, err);
+            failures.fail(rel, reporter.describe((0, output_1.classifyFailure)(err)));
         }
     };
     const remove = (rel, recursive) => {
@@ -86,7 +86,7 @@ function createLayerSync(src, dest, reporter, onStaged) {
             failures.applied(rel);
         }
         catch (err) {
-            failures.fail(rel, err);
+            failures.fail(rel, reporter.describe((0, output_1.classifyFailure)(err)));
         }
     };
     const stage = (p, add, cancel) => {
@@ -113,7 +113,7 @@ function createLayerSync(src, dest, reporter, onStaged) {
                     failures.applied(rel);
                 }
                 catch (err) {
-                    failures.fail(rel, err);
+                    failures.fail(rel, reporter.describe((0, output_1.classifyFailure)(err)));
                 }
             }
         },
@@ -127,22 +127,6 @@ 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 locale_files_1.InvalidLocaleFileError) {
-        const file = reporter.show(err.path);
-        return {
-            text: `${file} is not a valid locale file`,
-            options: { details: [...err.reason.split("\n"), kept] },
-            fixed: [`${file} fixed`, `${output.name} regenerated`].join((0, cli_1.getProcessUi)().symbols.separator),
-        };
-    }
-    return {
-        text: `${capitalize(output.name)} not regenerated`,
-        options: { details: [...reporter.describe(err), kept] },
-        fixed: `${capitalize(output.name)} regenerated`,
-    };
-}
 function describeLayerDirectories(paths, reporter) {
     const layers = [...new Set(paths)].filter((path) => !paths.some((other) => other.startsWith(`${path}${node_path_1.sep}`)));
     const shown = layers.map((path) => reporter.show(path));
@@ -183,7 +167,24 @@ function createDerivedOutputRefresher(workspaceDir, layers, reporter) {
             return isChanged;
         }
         catch (err) {
-            fail(output, describeOutputFailure(output, err, reporter));
+            const kept = `The dev server keeps the previous ${output.name} until the file is fixed.`;
+            if (err instanceof locale_files_1.InvalidLocaleFileError) {
+                const file = reporter.show(err.path);
+                fail(output, {
+                    text: `${file} is not a valid locale file`,
+                    options: { details: [err.reason, ...err.details, kept] },
+                    fixed: [`${file} fixed`, `${output.name} regenerated`].join((0, cli_1.getProcessUi)().symbols.separator),
+                });
+            }
+            else {
+                fail(output, {
+                    text: `${capitalize(output.name)} not regenerated`,
+                    options: {
+                        details: [...reporter.describe((0, output_1.classifyFailure)(err)), kept],
+                    },
+                    fixed: `${capitalize(output.name)} regenerated`,
+                });
+            }
             return false;
         }
     };
@@ -198,7 +199,7 @@ function createDerivedOutputRefresher(workspaceDir, layers, reporter) {
                 text: "Derived files not regenerated",
                 options: {
                     details: [
-                        ...reporter.describe(err),
+                        ...reporter.describe((0, output_1.classifyFailure)(err)),
                         "The dev server keeps the previous ones until the module is fixed.",
                     ],
                 },
@@ -278,7 +279,7 @@ function startLayerWatchers(workspaceDir, layers, ui = (0, cli_1.getProcessUi)()
             if (!isQuiet)
                 write((0, output_1.formatTimedMessage)("success", text, {}, ui));
         },
-        describe: (error) => (0, output_1.failureDetails)(error, ui).map((line) => mapPath(line)),
+        describe: (failure) => (0, output_1.failureDetails)(failure, ui).map((line) => mapPath(line)),
         show: (path) => {
             const mapped = mapPath(path);
             return mapped === path ? (0, output_1.showPath)(path) : mapped;

package/dist/layers.d.ts

@@ -9,7 +9,7 @@ interface PathlessManifestSource {
 export declare function assertLayerPathsServed(modules: ManifestModule[], backendUrl: string, { bootstrapSecret, cache }?: PathlessManifestSource): asserts modules is ServedWithPath[];
 export interface LayerPackage {
     name?: unknown;
-    engines?: Record<string, unknown>;
+    engines?: unknown;
     dmsFrontend?: unknown;
     antelopeJs?: unknown;
 }

package/dist/layers.js

@@ -12,6 +12,7 @@ const manifest_1 = require("./manifest");
 const config_1 = require("./config");
 const output_1 = require("./output");
 const guards_1 = require("./internal/guards");
+const plain_object_1 = require("./internal/plain-object");
 const BUILD_FIX = "A remote or production backend never sends them: build the frontend from the project instead, with `ajs dms build`";
 function assertLayerPathsServed(modules, backendUrl, { bootstrapSecret, cache } = {}) {
     const pathless = modules.filter((mod) => !mod.path);
@@ -56,7 +57,8 @@ function readLayerPackage(layerPath) {
     if (!(0, node_fs_1.existsSync)(pkgPath))
         return undefined;
     try {
-        return JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf-8"));
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf-8"));
+        return (0, plain_object_1.isPlainObject)(parsed) ? parsed : undefined;
     }
     catch {
         return undefined;

package/dist/locale-files.d.ts

@@ -1,6 +1,9 @@
-export declare class InvalidLocaleFileError extends Error {
+import { CliError } from "@antelopejs/core/cli";
+import { type LocaleMessages } from "./internal/locale-catalogs";
+export declare class InvalidLocaleFileError extends CliError {
     readonly path: string;
     readonly reason: string;
-    constructor(path: string, reason: string);
+    readonly details: readonly string[];
+    constructor(path: string, reason: string, details?: readonly string[]);
 }
-export declare function readLocaleFile(path: string): Record<string, unknown>;
+export declare function readLocaleFile(path: string): LocaleMessages;

package/dist/locale-files.js

@@ -3,17 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidLocaleFileError = void 0;
 exports.readLocaleFile = readLocaleFile;
 const node_fs_1 = require("node:fs");
+const cli_1 = require("@antelopejs/core/cli");
 const message_compiler_1 = require("@intlify/message-compiler");
 const guards_1 = require("./internal/guards");
-class InvalidLocaleFileError extends Error {
-    constructor(path, reason) {
-        super(`Invalid locale file ${path}: ${reason}`);
+const locale_catalogs_1 = require("./internal/locale-catalogs");
+class InvalidLocaleFileError extends cli_1.CliError {
+    constructor(path, reason, details = []) {
+        super({
+            title: `Invalid locale file ${path}: ${reason}`,
+            details: [...details],
+        });
         this.path = path;
         this.reason = reason;
+        this.details = details;
         this.name = "InvalidLocaleFileError";
     }
 }
 exports.InvalidLocaleFileError = InvalidLocaleFileError;
+const LINE_BREAKS = /\r?\n/g;
 const LITERAL_ESCAPES = {
     "@": "{'@'}",
     "{": "{'{'}",
@@ -66,15 +73,14 @@ function readLocaleFile(path) {
     }
     catch (error) {
         const reason = error instanceof Error ? error.message : String(error);
-        throw new InvalidLocaleFileError(path, reason);
+        throw new InvalidLocaleFileError(path, reason.replace(LINE_BREAKS, "\\n"));
+    }
+    if (!(0, locale_catalogs_1.isLocaleValue)(value) || !(0, locale_catalogs_1.isMessageGroup)(value)) {
+        throw new InvalidLocaleFileError(path, "a locale file must hold a JSON object of messages");
     }
     const problems = messageProblems(value, "");
     if (problems.length) {
-        const reason = [
-            `${problems.length} message(s) vue-i18n cannot compile:`,
-            ...problems.map(describeProblem),
-        ].join("\n");
-        throw new InvalidLocaleFileError(path, reason);
+        throw new InvalidLocaleFileError(path, `${problems.length} message(s) vue-i18n cannot compile:`, problems.map(describeProblem));
     }
     return value;
 }

package/dist/manifest.d.ts

@@ -16,7 +16,7 @@ export declare function fetchFromBackend(backendUrl: string, url: URL, bootstrap
 export declare class ManifestRefusedError extends CliError {
     constructor(problem: string | CliProblem);
 }
-export declare function describeManifestVersion(version: unknown): CliProblem;
+export declare function describeManifestVersion(version: number | undefined): CliProblem;
 export declare class BackendResponseError extends CliError {
     readonly status: number;
     constructor(subject: string, url: string | URL, response: Pick<Response, "status" | "statusText">);