@gtkx/cli 2.0.0-beta.3 → 2.0.0-beta.4

package/src/deploy/payload/stage.ts

@@ -1,4 +1,4 @@
-import { sortStringsBy } from "@gtkx/utils";
+import { sortStringsBy, warn } from "@gtkx/utils";
 import { existsSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { DeploySettings, DeployTargetName, NodeRuntime, NoticeSection, StagedFile } from "../types.js";
@@ -82,9 +82,48 @@ const stageMetadata = (settings: DeploySettings, root: string, metadata: StagedM
         : [writeInto(root, join(SHARE_MIME_PACKAGES, `${settings.applicationId}.xml`), metadata.mimePackage)]),
 ];
 
-const stageExtraFiles = (settings: DeploySettings, root: string): StagedFile[] =>
+const generatedMetadataKind = (
+    settings: DeploySettings,
+    metadata: StagedMetadata,
+    destination: string,
+): string | null => {
+    if (destination === join(SHARE_APPLICATIONS, `${settings.applicationId}.desktop`)) {
+        return "desktop entry";
+    }
+
+    if (destination === join(SHARE_METAINFO, `${settings.applicationId}.metainfo.xml`)) {
+        return "metainfo";
+    }
+
+    if (
+        metadata.mimePackage !== null &&
+        destination === join(SHARE_MIME_PACKAGES, `${settings.applicationId}.xml`)
+    ) {
+        return "MIME package";
+    }
+
+    return null;
+};
+
+const warnMetadataCollision = (
+    settings: DeploySettings,
+    metadata: StagedMetadata,
+    file: DeploySettings["extraFiles"][number],
+): void => {
+    const kind = generatedMetadataKind(settings, metadata, file.destination);
+
+    if (kind !== null) {
+        warn(
+            `extraFiles source "${file.source}" targeting "${file.destination}" is overridden by the ` +
+            `GTKX-generated ${kind}`,
+        );
+    }
+};
+
+const stageExtraFiles = (settings: DeploySettings, root: string, metadata: StagedMetadata): StagedFile[] =>
     settings.extraFiles.map((file) => {
         const source = resolve(settings.paths.root, file.source);
+        warnMetadataCollision(settings, metadata, file);
 
         return copyInto(root, file.destination, source, file.mode ?? executableModeFor(source));
     });
@@ -108,7 +147,7 @@ const stagePayload = ({ settings, node, metadata }: StageRequest): StagedFile[]
         ...stageNodeBinary(settings, root, node),
         ...stageRuntimeFiles(settings, root),
         ...stageCatalogs(settings, root),
-        ...stageExtraFiles(settings, root),
+        ...stageExtraFiles(settings, root, metadata),
         ...stageMetadata(settings, root, metadata),
         ...stageIcons(settings, root),
         ...stageSchemas(settings, root),

package/src/deploy/settings/extra-files.ts

@@ -1,5 +1,5 @@
 import { statSync } from "node:fs";
-import { resolve } from "node:path";
+import { normalize, resolve } from "node:path";
 import type { DeployConfig, DeployExtraFile } from "../types.js";
 
 type ExtraFiles = NonNullable<DeployConfig["extraFiles"]>;
@@ -22,13 +22,15 @@ const assertSourceFile = (root: string, file: DeployExtraFile): void => {
 };
 
 const resolveExtraFile = (destination: string, entry: ExtraFileEntry): DeployExtraFile => {
+    const normalizedDestination = normalize(destination);
+
     if (typeof entry === "string") {
-        return { destination, source: entry, mode: null };
+        return { destination: normalizedDestination, source: entry, mode: null };
     }
 
     const mode = entry.mode === undefined ? null : Number.parseInt(entry.mode, OCTAL_RADIX);
 
-    return { destination, source: entry.source, mode };
+    return { destination: normalizedDestination, source: entry.source, mode };
 };
 
 const resolveExtraFiles = (root: string, deploy: DeployConfig): DeployExtraFile[] => {

package/src/dev/supervisor.ts

@@ -1,7 +1,7 @@
 import { error, exitCodeForSignal, info, installGracefulShutdown } from "@gtkx/utils";
 import { fork as nodeFork } from "node:child_process";
-import { type FSWatcher, watch as watchFs } from "node:fs";
-import { basename, dirname } from "node:path";
+import { type FSWatcher, statSync, watch as watchFs } from "node:fs";
+import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DEV_CONFIG_ENV, DEV_ENTRY_ENV } from "./entry-env.js";
 
@@ -18,7 +18,8 @@ type ForkRunner = (modulePath: string, args: string[], env: NodeJS.ProcessEnv, c
 
 type DevWatch = {
     paths: string[];
-    regenerate: () => Promise<void>;
+    resolvePaths: () => string[];
+    regenerate: () => Promise<string[]>;
 };
 
 type SupervisorState = {
@@ -29,10 +30,12 @@ type SupervisorState = {
     args: string[];
     watch: DevWatch | undefined;
     watchers: FSWatcher[];
+    restartTimer: DebounceTimer;
     fork: ForkRunner;
     child: SupervisedChild | null;
     isShuttingDown: boolean;
     isRestarting: boolean;
+    isRestartPending: boolean;
     capturedChildExit: number | undefined;
 };
 
@@ -141,39 +144,87 @@ const launch = (state: SupervisorState): void => {
     });
 };
 
-const isRestartBlocked = (state: SupervisorState): boolean => state.isRestarting || state.isShuttingDown;
-
-const relaunchAfterExit = (state: SupervisorState): void => {
+const runPendingRestart = (state: SupervisorState): void => {
     state.isRestarting = false;
 
+    if (!state.isRestartPending || state.isShuttingDown) {
+        return;
+    }
+
+    state.isRestartPending = false;
+    void restart(state);
+};
+
+const relaunchAfterExit = (state: SupervisorState): void => {
     if (state.isShuttingDown) {
+        state.isRestarting = false;
+
         return;
     }
 
     info("Restarting dev runner...");
     launch(state);
+    runPendingRestart(state);
+};
+
+const isSupervisorShuttingDown = (state: SupervisorState): boolean => state.isShuttingDown;
+
+const reconcileConfigWatchers = (
+    state: SupervisorState,
+    paths: string[],
+    previous: ReadonlyMap<string, string | null>,
+): void => {
+    const didChange = didWatchPathsChange(previous, paths);
+
+    closeWatchers(state);
+
+    if (state.watch !== undefined) {
+        state.watch.paths = paths;
+    }
+
+    if (state.isShuttingDown) {
+        return;
+    }
+
+    installConfigWatchers(state);
+
+    if (didChange && !state.isRestartPending) {
+        scheduleRestart(state);
+    }
 };
 
 const restart = async (state: SupervisorState): Promise<void> => {
     const watch = state.watch;
 
-    if (watch === undefined || isRestartBlocked(state)) {
+    if (watch === undefined || state.isShuttingDown) {
+        return;
+    }
+
+    if (state.isRestarting) {
+        state.isRestartPending = true;
+
         return;
     }
 
     state.isRestarting = true;
-    info("gtkx.config.ts changed; regenerating bindings...");
+    info(`${basename(state.configFile)} changed; regenerating bindings...`);
+    closeWatchers(state);
+    watch.paths = watch.resolvePaths();
+    const previous = snapshotWatchPaths(watch.paths);
+    installConfigWatchers(state);
 
     try {
-        await watch.regenerate();
+        const paths = await watch.regenerate();
+        reconcileConfigWatchers(state, paths, previous);
     } catch (error_) {
+        reconcileConfigWatchers(state, watch.resolvePaths(), previous);
         error("Codegen failed; keeping the current dev runner. Fix the error and save again.", error_);
-        state.isRestarting = false;
+        runPendingRestart(state);
 
         return;
     }
 
-    if (state.isShuttingDown) {
+    if (isSupervisorShuttingDown(state)) {
         state.isRestarting = false;
 
         return;
@@ -182,8 +233,8 @@ const restart = async (state: SupervisorState): Promise<void> => {
     const current = state.child;
 
     if (current === null) {
-        state.isRestarting = false;
         launch(state);
+        runPendingRestart(state);
 
         return;
     }
@@ -195,12 +246,17 @@ const restart = async (state: SupervisorState): Promise<void> => {
     forwardSignal(current, "SIGTERM");
 };
 
-const scheduleRestart = (state: SupervisorState, timer: DebounceTimer): void => {
+const scheduleRestart = (state: SupervisorState): void => {
+    const timer = state.restartTimer;
+
     if (timer.handle !== null) {
         clearTimeout(timer.handle);
     }
 
-    timer.handle = setTimeout(() => void restart(state), CONFIG_DEBOUNCE_MS);
+    timer.handle = setTimeout(() => {
+        timer.handle = null;
+        void restart(state);
+    }, CONFIG_DEBOUNCE_MS);
 };
 
 const isWatchedChange = (state: SupervisorState, names: Set<string>, filename: string | Buffer | null): boolean => {
@@ -211,13 +267,76 @@ const isWatchedChange = (state: SupervisorState, names: Set<string>, filename: s
     return names.has(basename(filename.toString()));
 };
 
+const isDirectory = (path: string): boolean => {
+    try {
+        return statSync(path, { throwIfNoEntry: false })?.isDirectory() === true;
+    } catch {
+        return false;
+    }
+};
+
+const nearestWatchTarget = (path: string): { directory: string; name: string } => {
+    let directory = dirname(path);
+    let name = basename(path);
+
+    while (!isDirectory(directory)) {
+        const parent = dirname(directory);
+
+        if (parent === directory) {
+            break;
+        }
+
+        name = basename(directory);
+        directory = parent;
+    }
+
+    return { directory, name };
+};
+
+const watchTargets = (paths: string[]): Set<string> =>
+    new Set(paths.flatMap((path) => {
+        const { directory, name } = nearestWatchTarget(path);
+
+        return [path, join(directory, name)];
+    }));
+
+const watchPathState = (path: string): string | null => {
+    try {
+        const stat = statSync(path, { bigint: true, throwIfNoEntry: false });
+
+        return stat === undefined
+            ? null
+            : [stat.dev, stat.ino, stat.mode, stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
+    } catch {
+        return null;
+    }
+};
+
+const snapshotWatchPaths = (paths: string[]): Map<string, string | null> =>
+    new Map([...watchTargets(paths)].map((path) => [path, watchPathState(path)]));
+
+const didWatchPathsChange = (
+    previous: ReadonlyMap<string, string | null>,
+    paths: string[],
+): boolean => {
+    for (const path of watchTargets(paths)) {
+        const current = watchPathState(path);
+
+        if (previous.has(path) ? previous.get(path) !== current : current !== null) {
+            return true;
+        }
+    }
+
+    return false;
+};
+
 const groupWatchNamesByDirectory = (paths: string[]): Map<string, Set<string>> => {
     const namesByDirectory: Map<string, Set<string>> = new Map();
 
     for (const path of paths) {
-        const directory = dirname(path);
+        const { directory, name } = nearestWatchTarget(path);
         const names = namesByDirectory.get(directory) ?? new Set<string>();
-        names.add(basename(path));
+        names.add(name);
         namesByDirectory.set(directory, names);
     }
 
@@ -228,16 +347,21 @@ const watchConfigDirectory = (
     state: SupervisorState,
     directory: string,
     names: Set<string>,
-    timer: DebounceTimer,
 ): void => {
-    const watcher = watchFs(directory, (_event, filename) => {
-        if (isWatchedChange(state, names, filename)) {
-            scheduleRestart(state, timer);
-        }
-    });
+    try {
+        const watcher = watchFs(directory, (_event, filename) => {
+            if (isWatchedChange(state, names, filename)) {
+                scheduleRestart(state);
+            }
+        });
 
-    watcher.on("error", (): void => undefined);
-    state.watchers.push(watcher);
+        watcher.on("error", (cause) => {
+            error(`Configuration watch failed for ${directory}`, cause);
+        });
+        state.watchers.push(watcher);
+    } catch (error_) {
+        error(`Configuration watch failed for ${directory}`, error_);
+    }
 };
 
 const installConfigWatchers = (state: SupervisorState): void => {
@@ -247,10 +371,8 @@ const installConfigWatchers = (state: SupervisorState): void => {
         return;
     }
 
-    const timer: DebounceTimer = { handle: null };
-
     for (const [directory, names] of groupWatchNamesByDirectory(watch.paths)) {
-        watchConfigDirectory(state, directory, names, timer);
+        watchConfigDirectory(state, directory, names);
     }
 };
 
@@ -258,6 +380,8 @@ const closeWatchers = (state: SupervisorState): void => {
     for (const watcher of state.watchers) {
         watcher.close();
     }
+
+    state.watchers = [];
 };
 
 const shutdownOnSignal = (state: SupervisorState, signal: NodeJS.Signals): Promise<void> =>
@@ -265,6 +389,11 @@ const shutdownOnSignal = (state: SupervisorState, signal: NodeJS.Signals): Promi
         state.isShuttingDown = true;
         closeWatchers(state);
 
+        if (state.restartTimer.handle !== null) {
+            clearTimeout(state.restartTimer.handle);
+            state.restartTimer.handle = null;
+        }
+
         if (!state.child) {
             resolve();
 
@@ -298,10 +427,12 @@ const runDevSupervisor = async (options: DevSupervisorOptions): Promise<never> =
         args,
         watch,
         watchers: [],
+        restartTimer: { handle: null },
         fork,
         child: null,
         isShuttingDown: false,
         isRestarting: false,
+        isRestartPending: false,
         capturedChildExit: undefined,
     };
 

package/src/i18n/source-messages.ts

@@ -116,8 +116,24 @@ const STATIC_KEY_WRAPPER_TYPES: ReadonlySet<string> = new Set([
 
 class SourceExtractionError extends Error {}
 
-const sourceErrorMessage = (error: unknown): string =>
-    error instanceof Error ? error.message : String(error);
+const sourceErrorMessage = (error: unknown): string => {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+
+    if (
+        "code" in error &&
+        error.code === "BABEL_PARSE_ERROR"
+    ) {
+        const separator = error.message.indexOf(": ");
+
+        if (separator !== -1) {
+            return error.message.slice(separator + 2);
+        }
+    }
+
+    return error.message;
+};
 
 const projectSourcePath = (root: string, path: string): string => {
     const absolute = isAbsolute(path) ? resolve(path) : resolve(root, path);
@@ -1968,4 +1984,4 @@ const extractSourceCatalog = async (
     extractCatalogTemplate({ project, messages, shouldPreserveMetadataMessages });
 };
 
-export { extractSourceCatalog, extractSourceCatalogTo };
+export { extractSourceCatalog, extractSourceCatalogTo, SourceExtractionError };

package/src/internal/build-output.ts

@@ -53,27 +53,85 @@ const isReusableBuildDirectory = (path: string): boolean => {
     return stats.isDirectory() && (readdirSync(path).length === 0 || isGtkxBuildDirectory(path));
 };
 
-const buildOutputError = (root: string): Error =>
-    new Error(`Build output must be an empty directory or an earlier GTKX build below the project root ${root}`);
+const outputName = (root: string, path: string): string => relative(root, path) || ".";
 
-const hasGtkxBuildAncestor = (root: string, outDir: string): boolean => {
+const gtkxBuildAncestor = (root: string, outDir: string): string | null => {
     let ancestor = dirname(outDir);
 
     while (isPathInside(root, ancestor)) {
         if (isGtkxBuildDirectory(ancestor)) {
-            return true;
+            return ancestor;
         }
 
         ancestor = dirname(ancestor);
     }
 
-    return false;
+    return null;
+};
+
+const childDirectories = (parent: string): string[] =>
+    readdirSync(parent, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => join(parent, entry.name));
+
+const gtkxBuildDescendant = (root: string): string | null => {
+    const pending = childDirectories(root);
+
+    while (pending.length > 0) {
+        const path = pending.pop();
+
+        if (path === undefined) {
+            return null;
+        }
+
+        if (isGtkxBuildDirectory(path)) {
+            return path;
+        }
+
+        pending.push(...childDirectories(path));
+    }
+
+    return null;
 };
 
 const assertSafeBuildLocation = (root: string, outDir: string): void => {
-    if (!isPathInside(root, outDir) || hasSymlinkComponent(root, outDir) || hasGtkxBuildAncestor(root, outDir)) {
-        throw buildOutputError(root);
+    if (!isPathInside(root, outDir)) {
+        throw new Error(`Build output ${outDir} must be below the project root ${root}`);
     }
+
+    if (hasSymlinkComponent(root, outDir)) {
+        throw new Error(`Build output ${outputName(root, outDir)} passes through a symbolic link`);
+    }
+
+    const ancestor = gtkxBuildAncestor(root, outDir);
+
+    if (ancestor !== null) {
+        throw new Error(
+            `Build output ${outputName(root, outDir)} is nested inside the earlier GTKX build ` +
+            outputName(root, ancestor),
+        );
+    }
+};
+
+const nonReusableBuildOutputError = (root: string, outDir: string): Error => {
+    const stats = lstatSync(outDir, { throwIfNoEntry: false });
+
+    if (stats?.isDirectory() !== true) {
+        return new Error(`Build output ${outputName(root, outDir)} exists and is not a directory`);
+    }
+
+    const descendant = gtkxBuildDescendant(outDir);
+
+    if (descendant !== null) {
+        return new Error(
+            `Build output ${outputName(root, outDir)} contains the earlier GTKX build ` +
+            outputName(root, descendant),
+        );
+    }
+
+    return new Error(
+        `Build output ${outputName(root, outDir)} is nonempty and is not an earlier GTKX build`,
+    );
 };
 
 const resolveBuildOutDir = (root: string, configured?: string): string => {
@@ -83,7 +141,7 @@ const resolveBuildOutDir = (root: string, configured?: string): string => {
     assertSafeBuildLocation(root, outDir);
 
     if (!isReusableBuildDirectory(outDir)) {
-        throw buildOutputError(root);
+        throw nonReusableBuildOutputError(root, outDir);
     }
 
     return outDir;
@@ -94,7 +152,7 @@ const prepareBuildOutDir = (root: string, outDir: string): PreparedBuildOutDir =
     const prepared = prepareOutputDirectory(root, outDir, isReusableBuildDirectory);
 
     if (prepared.status === "unsafe") {
-        throw buildOutputError(root);
+        throw new Error(`Build output ${outputName(root, outDir)} became unsafe while preparing it`);
     }
 
     const transaction: OutputDirectoryTransaction = prepared.transaction;

package/src/internal/prepare-project.ts

@@ -3,21 +3,27 @@ import { type CodegenContext, resolveCodegenContext } from "../codegen/store-res
 import { resolveCwd, resolveEntry } from "./entry-arg.js";
 
 type ProjectArgs = { entry?: string; cwd?: string; config?: string };
-type PreparedProject = { cwd: string; entry: string; configFile: string };
+type PreparedProject = { cwd: string; entry: string; configFile: string; configDependencies: string[] };
 type ResolvedProject = PreparedProject & { context: CodegenContext };
 
 const resolveProject = async (args: ProjectArgs, mode: string): Promise<ResolvedProject> => {
     const cwd = resolveCwd(args);
     const context = await resolveCodegenContext(cwd, mode, args.config);
 
-    return { cwd, entry: resolveEntry(cwd, args.entry), configFile: context.configFile, context };
+    return {
+        cwd,
+        entry: resolveEntry(cwd, args.entry),
+        configFile: context.configFile,
+        configDependencies: context.configDependencies,
+        context,
+    };
 };
 
 const prepareProject = async (args: ProjectArgs, mode: string): Promise<PreparedProject> => {
     const { cwd, entry, context } = await resolveProject(args, mode);
     await ensureGeneratedIn(context, { shouldAnnounce: true, mode });
 
-    return { cwd, entry, configFile: context.configFile };
+    return { cwd, entry, configFile: context.configFile, configDependencies: context.configDependencies };
 };
 
 export { prepareProject, resolveProject };

package/src/vite-plugins/i18n.ts

@@ -12,7 +12,7 @@ import {
     resolveCatalogProject,
     synchronizeCatalogs,
 } from "../i18n/catalogs.js";
-import { extractSourceCatalog } from "../i18n/source-messages.js";
+import { extractSourceCatalog, SourceExtractionError } from "../i18n/source-messages.js";
 import { emitI18nTypes } from "../i18n/types.js";
 import { discoverSourceFiles, sourceLanguage } from "../internal/source-imports.js";
 import { stripQuery } from "./strip-query.js";
@@ -160,18 +160,35 @@ const isProjectSource = (state: I18nState, path: string): boolean => {
 const refreshProjectMessages = async (
     state: I18nState,
     shouldPreserveMetadataMessages: boolean,
+    shouldSynchronizeCatalogs = false,
 ): Promise<void> => {
     try {
-        await queueExtraction(state, shouldPreserveMetadataMessages, false);
+        await queueExtraction(state, shouldPreserveMetadataMessages, shouldSynchronizeCatalogs);
     } catch (error) {
         logger.error(error instanceof Error ? error.message : String(error));
     }
 };
 
+const recoverInitialSourceExtraction = async (
+    state: I18nState,
+    shouldPreserveMetadataMessages: boolean,
+): Promise<void> => {
+    try {
+        await queueExtraction(state, shouldPreserveMetadataMessages, true);
+    } catch (error) {
+        if (!(error instanceof SourceExtractionError)) {
+            throw error;
+        }
+
+        logger.error(error.message);
+    }
+};
+
 const gtkxI18n = (
     entryPath: string,
     loadConfig: ConfigLoader = createConfigLoader(),
     shouldPreserveMetadataMessages = true,
+    shouldRecoverExtractionErrors = false,
 ): Plugin => {
     const state: I18nState = {
         entryPath,
@@ -188,7 +205,9 @@ const gtkxI18n = (
 
         configResolved: (config) => applyResolvedConfig(state, config, loadConfig),
 
-        buildStart: () => queueExtraction(state, shouldPreserveMetadataMessages, true),
+        buildStart: () => shouldRecoverExtractionErrors
+            ? recoverInitialSourceExtraction(state, shouldPreserveMetadataMessages)
+            : queueExtraction(state, shouldPreserveMetadataMessages, true),
 
         hotUpdate(options) {
             if (!isProjectSource(state, options.file) || state.hotUpdateTimestamp === options.timestamp) {

package/src/vite-plugins/index.ts

@@ -30,7 +30,14 @@ const gtkxVitePlugins = (options: GtkxVitePluginOptions = {}): Plugin[] => {
 
     return [
         createConfigPlugin({ name: "gtkx:config", loadConfig }),
-        ...(entryPath === undefined ? [] : [gtkxI18n(entryPath, loadConfig, shouldPreserveI18nMetadata)]),
+        ...(entryPath === undefined
+            ? []
+            : [gtkxI18n(
+                    entryPath,
+                    loadConfig,
+                    shouldPreserveI18nMetadata,
+                    mode === "development",
+                )]),
         gtkxStoreLinks(),
         gtkxUndeclaredLibrary(loadConfig),
         gtkxSettings(buildManifest),