@antelopejs/dms-frontend 0.3.8 → 0.3.9

package/dist/ports.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PORT_FALLBACK_RANGE = void 0;
+exports.MAX_TCP_PORT = exports.PORT_FALLBACK_RANGE = void 0;
 exports.reserveFreePort = reserveFreePort;
+exports.reservePort = reservePort;
 const node_net_1 = require("node:net");
+const cli_1 = require("@antelopejs/core/cli");
 exports.PORT_FALLBACK_RANGE = 20;
-const MAX_TCP_PORT = 65535;
+exports.MAX_TCP_PORT = 65535;
 function tryListen(port) {
     return new Promise((resolve) => {
         const server = (0, node_net_1.createServer)((socket) => socket.destroy());
@@ -14,17 +16,25 @@ function tryListen(port) {
     });
 }
 async function reserveFreePort(preferred, range = exports.PORT_FALLBACK_RANGE) {
-    const end = Math.min(preferred + range, MAX_TCP_PORT);
+    const end = Math.min(preferred + range, exports.MAX_TCP_PORT);
     for (let port = preferred; port <= end; port++) {
-        const server = await tryListen(port);
-        if (server) {
-            return {
-                port: server.address().port,
-                release: () => new Promise((resolve) => {
-                    server.close(() => resolve());
-                }),
-            };
-        }
+        const reserved = await reservePort(port);
+        if (reserved)
+            return reserved;
     }
-    throw new Error(`No free port found between ${preferred} and ${end}.`);
+    throw new cli_1.CliError({
+        title: `No free port found between ${preferred} and ${end}`,
+        fixes: ["Free one of these ports, or pass another one: -p <port>"],
+    });
+}
+async function reservePort(port) {
+    const server = await tryListen(port);
+    if (!server)
+        return undefined;
+    return {
+        port: server.address().port,
+        release: () => new Promise((resolve) => {
+            server.close(() => resolve());
+        }),
+    };
 }

package/dist/renderer-range.d.ts

@@ -1,3 +1,4 @@
+import { type MessageOptions } from "@antelopejs/core/cli";
 import { ResolvedLayer } from "./workspace";
 export interface RendererRelease {
     name: string;
@@ -5,6 +6,7 @@ export interface RendererRelease {
 }
 export interface RendererRangeCheckOptions {
     renderer?: RendererRelease;
-    warn?: (message: string) => void;
+    warn?: (text: string, options: MessageOptions) => void;
+    workspaceDir?: string;
 }
 export declare function assertLayersSupportRenderer(layers: ResolvedLayer[], options?: RendererRangeCheckOptions): void;

package/dist/renderer-range.js

@@ -4,18 +4,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertLayersSupportRenderer = assertLayersSupportRenderer;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const cli_1 = require("@antelopejs/core/cli");
 const semver_1 = __importDefault(require("semver"));
 const layers_1 = require("./layers");
+const output_1 = require("./output");
 const OWN_RELEASE = require("../package.json");
 const noticedModules = new Set();
+const NOTICED_MODULES_FILE = ".renderer-range-noticed";
+function readNoticedModules(workspaceDir) {
+    const file = workspaceDir && (0, node_path_1.join)(workspaceDir, NOTICED_MODULES_FILE);
+    if (!file || !(0, node_fs_1.existsSync)(file))
+        return new Set();
+    return new Set((0, node_fs_1.readFileSync)(file, "utf8").split("\n").filter(Boolean));
+}
+function saveNoticedModules(workspaceDir, modules) {
+    if (!workspaceDir)
+        return;
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, NOTICED_MODULES_FILE), [...modules].map((module) => `${module}\n`).join(""));
+}
 function moduleLabel(layer) {
     if (!layer.packageName)
         return layer.path;
     return `${layer.packageName} (${layer.path})`;
 }
+function shownModule(layer) {
+    const where = (0, output_1.showPath)(layer.sourcePath ?? layer.path);
+    return layer.packageName ? `${layer.packageName} (${where})` : where;
+}
 function declaredRange(layer, rendererName) {
     return {
         module: moduleLabel(layer),
+        shown: shownModule(layer),
         range: (0, layers_1.readLayerPackage)(layer.path)?.engines?.[rendererName],
     };
 }
@@ -23,38 +44,49 @@ function releaseLine(version) {
     return semver_1.default.coerce(version)?.version ?? version;
 }
 function describeProblem(declaration, version) {
-    const { module, range } = declaration;
+    const { shown, range } = declaration;
     if (typeof range !== "string" || semver_1.default.validRange(range) === null)
-        return `${module} declares an unreadable range: ${JSON.stringify(range)}`;
+        return `${shown} declares an unreadable range: ${JSON.stringify(range)}`;
     if (semver_1.default.satisfies(releaseLine(version), range))
         return undefined;
-    return `${module} supports ${range}`;
+    return `${shown} supports ${range}`;
 }
-function noticeUndeclared(declarations, renderer, warn) {
-    const modules = declarations
+function noticeUndeclared(declarations, renderer, warn, workspaceDir) {
+    const remembered = readNoticedModules(workspaceDir);
+    const undeclared = declarations
         .filter(({ range }) => range === undefined)
-        .map(({ module }) => module)
-        .filter((module) => !noticedModules.has(module));
-    if (modules.length === 0)
+        .filter(({ module }) => !noticedModules.has(module) && !remembered.has(module));
+    if (undeclared.length === 0)
         return;
-    for (const module of modules)
+    for (const { module } of undeclared) {
         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}"].`);
+        remembered.add(module);
+    }
+    saveNoticedModules(workspaceDir, remembered);
+    const hint = (0, cli_1.getProcessUi)().symbols.levels.hint;
+    warn(`No supported ${renderer.name} range declared, so not checked against ${renderer.version}`, {
+        details: [
+            ...undeclared.map(({ shown }) => shown),
+            `${hint} Declare 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);
+    noticeUndeclared(declarations, renderer, options.warn ??
+        ((text, messageOptions) => (0, cli_1.getProcessUi)().message("warn", text, messageOptions)), options.workspaceDir);
     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}.`);
+    throw new cli_1.CliError({
+        title: `These frontend modules do not run on ${renderer.name} ${renderer.version}`,
+        details: problems,
+        fixes: [
+            `Install a ${renderer.name} release in their ranges, or upgrade the modules`,
+        ],
+    });
 }

package/dist/server-process.d.ts

@@ -0,0 +1,39 @@
+import { networkInterfaces } from "node:os";
+import { type CliProblem } from "@antelopejs/core/cli";
+import type { PathMapper } from "./child-output";
+import type { ReadyLine } from "./output";
+export interface ServerAddress {
+    address: string;
+    port: number;
+}
+interface ListenError {
+    code?: string;
+    message: string;
+    host: string;
+    port: number;
+}
+interface StartErrorLocation {
+    file: string;
+    line?: number;
+    column?: number;
+    lineText?: string;
+}
+export interface StartError {
+    message: string;
+    code?: string;
+    location?: StartErrorLocation;
+}
+export interface RunServerOptions {
+    name: string;
+    script: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    mapPath?: PathMapper;
+    onReady: (address: ServerAddress) => void;
+}
+export declare function describeStartError(error: StartError, mapPath?: PathMapper): CliProblem;
+export declare function describeListenError(error: ListenError): CliProblem;
+export declare function isGuestBridge(name: string, netDir?: string): boolean;
+export declare function readyLines(address: ServerAddress, settings: ReadyLine[], interfaces?: ReturnType<typeof networkInterfaces>, isGuestInterface?: (name: string) => boolean): ReadyLine[];
+export declare function runServer(options: RunServerOptions): Promise<number>;
+export {};

package/dist/server-process.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeStartError = describeStartError;
+exports.describeListenError = describeListenError;
+exports.isGuestBridge = isGuestBridge;
+exports.readyLines = readyLines;
+exports.runServer = runServer;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const cli_1 = require("@antelopejs/core/cli");
+const cancellation_1 = require("./cancellation");
+const workspace_setup_1 = require("./workspace-setup");
+const READY_MESSAGE = "dms:ready";
+const LISTEN_ERROR_MESSAGE = "dms:listen-error";
+const START_ERROR_MESSAGE = "dms:start-error";
+const DEV_COMMAND = "ajs dms dev";
+const MODULE_NOT_FOUND_CODES = ["ERR_MODULE_NOT_FOUND", "MODULE_NOT_FOUND"];
+const WILDCARD_ADDRESSES = new Set(["0.0.0.0", "::"]);
+const LOCAL_HOST = "localhost";
+const VIRTUAL_INTERFACE_NAME = /^(docker\d|br-|veth|virbr|cni|flannel|cali|cilium|weave|vxlan|kube-|podman|lxcbr|lxdbr|vboxnet|vmnet)/;
+const LINK_LOCAL_IPV4 = /^169\.254\./;
+const MAX_NETWORK_URLS = 3;
+const LINUX_NET_DIR = "/sys/class/net";
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function readReady(message) {
+    if (!isRecord(message) || message.type !== READY_MESSAGE)
+        return undefined;
+    const { address, port } = message;
+    if (typeof address !== "string" || typeof port !== "number")
+        return undefined;
+    return { address, port };
+}
+function readListenError(message) {
+    if (!isRecord(message) || message.type !== LISTEN_ERROR_MESSAGE)
+        return undefined;
+    return {
+        code: typeof message.code === "string" ? message.code : undefined,
+        message: String(message.message),
+        host: String(message.host),
+        port: Number(message.port),
+    };
+}
+function readStartError(message) {
+    if (!isRecord(message) || message.type !== START_ERROR_MESSAGE)
+        return undefined;
+    const { location } = message;
+    const isLocated = isRecord(location) && typeof location.file === "string";
+    return {
+        message: String(message.message),
+        code: typeof message.code === "string" ? message.code : undefined,
+        location: isLocated
+            ? {
+                file: String(location.file),
+                line: typeof location.line === "number" ? location.line : undefined,
+                column: typeof location.column === "number" ? location.column : undefined,
+                lineText: typeof location.lineText === "string"
+                    ? location.lineText
+                    : undefined,
+            }
+            : undefined,
+    };
+}
+function codeFrame(location) {
+    const { line, column, lineText } = location;
+    if (line === undefined || lineText === undefined)
+        return [];
+    const gutter = String(line);
+    const caret = `${" ".repeat(column ?? 0)}^`;
+    return [`${gutter} | ${lineText}`, `${" ".repeat(gutter.length)} | ${caret}`];
+}
+function describeStartError(error, mapPath = (path) => path) {
+    const { code, location } = error;
+    const message = mapPath(error.message);
+    if (code && MODULE_NOT_FOUND_CODES.includes(code)) {
+        return {
+            title: "Vite could not start in the dev server",
+            reason: message,
+            fixes: [`Reinstall the workspace dependencies: ${DEV_COMMAND} --force`],
+        };
+    }
+    if (!location) {
+        return {
+            title: "Vite could not start in the dev server",
+            reason: message,
+            fixes: [
+                `Look for the cause in Vite's output above, then run ${DEV_COMMAND} again`,
+            ],
+        };
+    }
+    const position = location.line === undefined
+        ? ""
+        : `:${location.line}:${location.column ?? 0}`;
+    return {
+        title: `Vite could not start: error in ${mapPath(location.file)}${position}`,
+        reason: message,
+        fixes: [`Fix the file and run ${DEV_COMMAND} again`],
+        details: codeFrame(location),
+    };
+}
+function describeListenError(error) {
+    const { code, host, port } = error;
+    if (code === "EADDRINUSE") {
+        return {
+            title: `Port ${port} is already in use`,
+            reason: `Another process is listening on ${host}:${port}.`,
+            fixes: ["Stop it, or pass another port: -p <port>"],
+        };
+    }
+    if (code === "EADDRNOTAVAIL") {
+        return {
+            title: `The server cannot listen on ${host}:${port}`,
+            reason: `${host} is not an address of this machine.`,
+            fixes: ["Set HOST to one of its addresses, or unset it"],
+        };
+    }
+    if (code === "EACCES") {
+        return {
+            title: `The server cannot listen on ${host}:${port}`,
+            reason: "Permission denied: ports below 1024 need elevated privileges.",
+            fixes: ["Pass a port above 1023: -p <port>"],
+        };
+    }
+    return {
+        title: `The server cannot listen on ${host}:${port}`,
+        reason: error.message,
+    };
+}
+function urlHost(address) {
+    if (WILDCARD_ADDRESSES.has(address))
+        return LOCAL_HOST;
+    return address.includes(":") ? `[${address}]` : address;
+}
+function localUrl({ address, port }) {
+    return `http://${urlHost(address)}:${port}/`;
+}
+function isGuestBridge(name, netDir = LINUX_NET_DIR) {
+    if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(netDir, name, "bridge")))
+        return false;
+    const ports = (0, node_fs_1.readdirSync)((0, node_path_1.join)(netDir, name, "brif"));
+    return !ports.some((port) => (0, node_fs_1.existsSync)((0, node_path_1.join)(netDir, port, "device")));
+}
+function isLinuxGuestBridge(name) {
+    try {
+        return process.platform === "linux" && isGuestBridge(name);
+    }
+    catch {
+        return false;
+    }
+}
+function networkUrls({ address, port }, interfaces = (0, node_os_1.networkInterfaces)(), isGuestInterface = isLinuxGuestBridge) {
+    if (!WILDCARD_ADDRESSES.has(address))
+        return [];
+    return Object.entries(interfaces)
+        .filter(([name]) => !VIRTUAL_INTERFACE_NAME.test(name))
+        .filter(([name]) => !isGuestInterface(name))
+        .flatMap(([, entries]) => entries ?? [])
+        .filter((entry) => entry.family === "IPv4" && !entry.internal)
+        .filter((entry) => !LINK_LOCAL_IPV4.test(entry.address))
+        .map((entry) => `http://${entry.address}:${port}/`);
+}
+function readyLines(address, settings, interfaces, isGuestInterface) {
+    const network = networkUrls(address, interfaces, isGuestInterface);
+    const hidden = network.length - MAX_NETWORK_URLS;
+    return [
+        { label: "Local", value: localUrl(address), isLink: true },
+        ...network.slice(0, MAX_NETWORK_URLS).map((value) => ({
+            label: "Network",
+            value,
+            isLink: true,
+        })),
+        ...(hidden > 0
+            ? [
+                {
+                    label: "Network",
+                    value: (0, cli_1.pluralize)(hidden, "more address", "more addresses"),
+                },
+            ]
+            : []),
+        ...settings,
+    ];
+}
+async function runServer(options) {
+    const { name, script, cwd, env, mapPath, onReady } = options;
+    let readyAt;
+    let listenError;
+    let startError;
+    try {
+        const code = await (0, workspace_setup_1.runCommand)(process.execPath, [script], {
+            cwd,
+            env,
+            shell: false,
+            stdio: ["inherit", "inherit", "inherit", "ipc"],
+        }, (child) => {
+            child.on("message", (message) => {
+                const ready = readReady(message);
+                if (ready && readyAt === undefined) {
+                    readyAt = Date.now();
+                    onReady(ready);
+                }
+                listenError ??= readListenError(message);
+                startError ??= readStartError(message);
+            });
+        });
+        if (listenError)
+            throw new cli_1.CliError(describeListenError(listenError));
+        if (startError)
+            throw new cli_1.CliError(describeStartError(startError, mapPath));
+        return code;
+    }
+    catch (error) {
+        if (!(error instanceof cancellation_1.CancelledError))
+            throw error;
+        const ran = readyAt === undefined
+            ? undefined
+            : `ran ${(0, cli_1.formatDuration)(Date.now() - readyAt)}`;
+        throw new cancellation_1.CancelledError(error.signal, `Stopped the ${name}`, ran);
+    }
+}

package/dist/typecheck-output.d.ts

@@ -0,0 +1,13 @@
+import { type CliProblem } from "@antelopejs/core/cli";
+export interface TypeCheckError {
+    location: string;
+    code: string;
+    message: string[];
+    frame: string[];
+}
+export interface TypeCheckReport {
+    errors: TypeCheckError[];
+    count: number;
+}
+export declare function parseTypeCheckOutput(lines: string[]): TypeCheckReport;
+export declare function describeTypeCheckErrors(report: TypeCheckReport, rerun: string): CliProblem | undefined;

package/dist/typecheck-output.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTypeCheckOutput = parseTypeCheckOutput;
+exports.describeTypeCheckErrors = describeTypeCheckErrors;
+const cli_1 = require("@antelopejs/core/cli");
+const child_output_1 = require("./child-output");
+const ERROR_LINE = /^(.+?):(\d+):(\d+) - error (TS\d+): (.*)$/;
+const SUMMARY_LINE = /^Found (\d+) errors?\b/;
+const CONTINUATION_LINE = /^\s+\S/;
+const SHOWN_ERRORS = 5;
+const DETAIL_INDENT = "  ";
+function readError(header, body) {
+    const [, file, line, column, code, message] = header;
+    const firstBlank = body.findIndex((entry) => entry.trim() === "");
+    const chainEnd = firstBlank < 0 ? body.length : firstBlank;
+    const chain = body
+        .slice(0, chainEnd)
+        .filter((entry) => CONTINUATION_LINE.test(entry));
+    return {
+        location: `${file}:${line}:${column}`,
+        code,
+        message: [message, ...chain.map((entry) => entry.trim())],
+        frame: body
+            .slice(chainEnd)
+            .filter((entry) => entry.trim() !== "")
+            .map((entry) => entry.trimEnd()),
+    };
+}
+function parseTypeCheckOutput(lines) {
+    const errors = [];
+    let header;
+    let body = [];
+    let count;
+    const close = () => {
+        if (header)
+            errors.push(readError(header, body));
+        header = undefined;
+        body = [];
+    };
+    for (const line of lines) {
+        const error = ERROR_LINE.exec(line);
+        const summary = SUMMARY_LINE.exec(line);
+        if (error || summary)
+            close();
+        if (error)
+            header = error;
+        else if (summary)
+            count = Number(summary[1]);
+        else if (header)
+            body.push(line);
+    }
+    close();
+    return { errors, count: Math.max(count ?? 0, errors.length) };
+}
+function describeTypeCheckErrors(report, rerun) {
+    const { errors, count } = report;
+    const [first] = errors;
+    if (!first)
+        return undefined;
+    if (count === 1) {
+        const [reason, ...chain] = first.message;
+        return {
+            title: `${first.location}  ${first.code}`,
+            reason,
+            fixes: [`Fix the error and run ${rerun} again`],
+            details: [...chain, ...first.frame],
+        };
+    }
+    const shown = errors.slice(0, SHOWN_ERRORS);
+    const hidden = count - shown.length;
+    return {
+        title: (0, cli_1.pluralize)(count, "type error"),
+        fixes: [`Fix the errors and run ${rerun} again`],
+        details: [
+            ...shown.flatMap((error) => [
+                `${error.location}  ${error.code}`,
+                ...[...error.message, ...error.frame].map((line) => `${DETAIL_INDENT}${line}`),
+            ]),
+            ...(hidden > 0
+                ? [
+                    `${(0, cli_1.getProcessUi)().symbols.ellipsis} and ${(0, cli_1.pluralize)(hidden, "more error")}`,
+                    child_output_1.VERBOSE_OUTPUT_HINT,
+                ]
+                : []),
+        ],
+    };
+}

package/dist/update-check.d.ts

@@ -1,3 +1,4 @@
+import { type Ui } from "@antelopejs/core/cli";
 export declare const UPDATE_CHECK_PACKAGE = "@antelopejs/dms-frontend";
 export declare const UPDATE_CHECK_INTERVAL_MS: number;
 export declare const UPDATE_CHECK_RETRY_INTERVAL_MS: number;
@@ -7,13 +8,24 @@ export interface UpdateCheckOptions {
     currentVersion: string;
     argv?: readonly string[];
     env?: NodeJS.ProcessEnv;
+    isTerminal?: boolean;
     now?: () => number;
     cacheFile?: string;
     fetchLatestVersion?: (packageName: string) => Promise<string | undefined>;
-    write?: (message: string) => void;
+    ui?: Ui;
+    write?: (line: string) => void;
+}
+export interface UpdateNoticeOptions {
+    isFollowed?: boolean;
+}
+export interface UpdateCheck {
+    readonly completion: Promise<void>;
+    report(options?: UpdateNoticeOptions): Promise<void>;
 }
 export declare function stripUpdateCheckFlag(argv: readonly string[]): string[];
 export declare function isUpdateCheckEnabled(argv: readonly string[], env: NodeJS.ProcessEnv): boolean;
 export declare function updateCheckCacheFile(): string;
 export declare function fetchLatestVersionFromRegistry(packageName: string, registryUrl?: string, timeoutMs?: number): Promise<string | undefined>;
-export declare function checkForUpdate(options: UpdateCheckOptions): Promise<void>;
+export declare function startUpdateCheck(options: UpdateCheckOptions): UpdateCheck | undefined;
+export declare function startProcessUpdateCheck(options: UpdateCheckOptions): void;
+export declare function reportAvailableUpdate(options?: UpdateNoticeOptions): Promise<void>;