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

package/src/i18n/catalogs.ts

@@ -28,11 +28,17 @@ type CatalogProject = {
 };
 
 type PreparedCatalog = {
+    content: Buffer;
     isChanged: boolean;
     output: string;
     target: string;
 };
 
+type WrittenCatalog = {
+    content: Buffer;
+    path: string;
+};
+
 const PO_DIRNAME = "po";
 const LOCALE_DIRNAME = "locale";
 const LINGUAS_FILENAME = "LINGUAS";
@@ -165,16 +171,25 @@ const prepareCatalog = (
         initializeCatalog(catalog, template, output);
     }
 
+    const content = readFileSync(output);
+
     return {
-        isChanged: !isExisting || !readFileSync(output).equals(readFileSync(catalog.path)),
+        content,
+        isChanged: !isExisting || !content.equals(readFileSync(catalog.path)),
         output,
         target: catalog.path,
     };
 };
 
-const synchronizeCatalogs = (project: CatalogProject): void => {
+const replaceCatalog = (catalog: PreparedCatalog): WrittenCatalog => {
+    renameSync(catalog.output, catalog.target);
+
+    return { content: catalog.content, path: catalog.target };
+};
+
+const synchronizeCatalogs = (project: CatalogProject): WrittenCatalog[] => {
     if (project.catalogs.length === 0) {
-        return;
+        return [];
     }
 
     const template = join(project.poDir, `${project.domain}.pot`);
@@ -185,11 +200,7 @@ const synchronizeCatalogs = (project: CatalogProject): void => {
         const merged = project.catalogs.map((catalog, index) =>
             prepareCatalog(catalog, index, template, stagingDir));
 
-        for (const catalog of merged) {
-            if (catalog.isChanged) {
-                renameSync(catalog.output, catalog.target);
-            }
-        }
+        return merged.filter((catalog) => catalog.isChanged).map((catalog) => replaceCatalog(catalog));
     } finally {
         rmSync(stagingDir, { recursive: true, force: true });
     }
@@ -215,4 +226,5 @@ export {
     requiresCatalogInitialization,
     resolveCatalogProject,
     synchronizeCatalogs,
+    type WrittenCatalog,
 };

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

@@ -11,12 +11,23 @@ import {
     LOCALE_DIRNAME,
     resolveCatalogProject,
     synchronizeCatalogs,
+    type WrittenCatalog,
 } 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";
 
+type CatalogWriteListener = (catalogs: WrittenCatalog[]) => void;
+
+type I18nPluginOptions = {
+    entryPath: string;
+    loadConfig?: ConfigLoader | undefined;
+    onCatalogsWritten?: CatalogWriteListener | undefined;
+    shouldPreserveMetadataMessages?: boolean | undefined;
+    shouldRecoverExtractionErrors?: boolean | undefined;
+};
+
 type I18nState = {
     entryPath: string;
     i18nRoot: string;
@@ -24,6 +35,7 @@ type I18nState = {
     project: CatalogProject | null;
     extraction: Promise<void>;
     hotUpdateTimestamp: number | null;
+    onCatalogsWritten: CatalogWriteListener;
 };
 
 const BOOTSTRAP_SPECIFIER = "@gtkx/i18n/bootstrap";
@@ -110,7 +122,7 @@ const extractProjectMessages = async (
     await extractSourceCatalog(project, sourceFiles, shouldPreserveMetadataMessages);
 
     if (shouldSynchronizeCatalogs) {
-        synchronizeCatalogs(project);
+        state.onCatalogsWritten(synchronizeCatalogs(project));
     }
 
     await emitI18nTypes(project.root);
@@ -160,19 +172,37 @@ 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 gtkxI18n = (
-    entryPath: string,
-    loadConfig: ConfigLoader = createConfigLoader(),
+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,
+    loadConfig = createConfigLoader(),
+    onCatalogsWritten = (): void => undefined,
     shouldPreserveMetadataMessages = true,
-): Plugin => {
+    shouldRecoverExtractionErrors = false,
+}: I18nPluginOptions): Plugin => {
     const state: I18nState = {
         entryPath,
         extraction: Promise.resolve(),
@@ -180,6 +210,7 @@ const gtkxI18n = (
         i18nRoot: "",
         outDir: "",
         project: null,
+        onCatalogsWritten,
     };
 
     return {
@@ -188,7 +219,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) {
@@ -222,4 +255,4 @@ const gtkxI18n = (
     };
 };
 
-export { gtkxI18n };
+export { type CatalogWriteListener, gtkxI18n };

package/src/vite-plugins/index.ts

@@ -5,7 +5,7 @@ import type { BuildManifestCollector } from "../internal/build-manifest.js";
 import { gtkxAssetImports } from "./asset-imports.js";
 import { gtkxBuiltUrl } from "./built-url.js";
 import { gtkxCss } from "./css.js";
-import { gtkxI18n } from "./i18n.js";
+import { type CatalogWriteListener, gtkxI18n } from "./i18n.js";
 import { gtkxIcons } from "./icons.js";
 import { gtkxReactCompiler } from "./react-compiler.js";
 import { gtkxResources } from "./resources.js";
@@ -18,11 +18,19 @@ type GtkxVitePluginOptions = {
     configFile?: string | undefined;
     entryPath?: string | undefined;
     mode?: string | undefined;
+    onCatalogsWritten?: CatalogWriteListener | undefined;
     shouldPreserveI18nMetadata?: boolean | undefined;
 };
 
 const gtkxVitePlugins = (options: GtkxVitePluginOptions = {}): Plugin[] => {
-    const { buildManifest, configFile, entryPath, mode, shouldPreserveI18nMetadata = true } = options;
+    const {
+        buildManifest,
+        configFile,
+        entryPath,
+        mode,
+        onCatalogsWritten,
+        shouldPreserveI18nMetadata = true,
+    } = options;
     const loadConfig = createConfigLoader({
         ...(mode !== undefined && { mode }),
         ...(configFile !== undefined && { configFile }),
@@ -30,7 +38,15 @@ const gtkxVitePlugins = (options: GtkxVitePluginOptions = {}): Plugin[] => {
 
     return [
         createConfigPlugin({ name: "gtkx:config", loadConfig }),
-        ...(entryPath === undefined ? [] : [gtkxI18n(entryPath, loadConfig, shouldPreserveI18nMetadata)]),
+        ...(entryPath === undefined
+            ? []
+            : [gtkxI18n({
+                    entryPath,
+                    loadConfig,
+                    onCatalogsWritten,
+                    shouldPreserveMetadataMessages: shouldPreserveI18nMetadata,
+                    shouldRecoverExtractionErrors: mode === "development",
+                })]),
         gtkxStoreLinks(),
         gtkxUndeclaredLibrary(loadConfig),
         gtkxSettings(buildManifest),