@gtkx/cli 2.0.0-beta.1 → 2.0.0-beta.2

package/src/internal/prepare-project.ts

@@ -2,22 +2,22 @@ import { ensureGeneratedIn } from "../codegen/run-codegen.js";
 import { type CodegenContext, resolveCodegenContext } from "../codegen/store-resolver.js";
 import { resolveCwd, resolveEntry } from "./entry-arg.js";
 
-type ProjectArgs = { entry?: string; cwd?: string };
-type PreparedProject = { cwd: string; entry: string };
+type ProjectArgs = { entry?: string; cwd?: string; config?: string };
+type PreparedProject = { cwd: string; entry: string; configFile: 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);
+    const context = await resolveCodegenContext(cwd, mode, args.config);
 
-    return { cwd, entry: resolveEntry(cwd, args.entry), context };
+    return { cwd, entry: resolveEntry(cwd, args.entry), configFile: context.configFile, 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 };
+    return { cwd, entry, configFile: context.configFile };
 };
 
 export { prepareProject, resolveProject };

package/src/internal/source-imports.ts

@@ -33,7 +33,7 @@ const discoverSourceFiles = (dir: string): string[] =>
     sortStringsBy(
         globSync("**/{*,.*}", {
             cwd: dir,
-            exclude: ["**/{build,coverage,dist,node_modules,out-tsc}/**"],
+            exclude: ["**/{build,coverage,dist,node_modules,out-tsc}/**", "**/.gtkx-output-*/**"],
             withFileTypes: true,
         })
             .filter((entry) => entry.isFile())

package/src/mcp/client.ts

@@ -1,10 +1,10 @@
 import * as Gio from "@gtkx/gi/gio";
 import * as Gtk from "@gtkx/gi/gtk";
 import {
-    DEFAULT_SOCKET_PATH,
     isConnectionClosedError,
     type JSONRPCRequest,
     ProtocolConnection,
+    resolveMcpSocketPath,
     type Result,
 } from "@gtkx/mcp/internal";
 import { error, errorMessage, info, normalizeError } from "@gtkx/utils";
@@ -65,7 +65,7 @@ class McpClient {
     private registry = new WidgetRegistry();
 
     constructor(options: McpClientOptions) {
-        this.socketPath = options.socketPath ?? DEFAULT_SOCKET_PATH;
+        this.socketPath = resolveMcpSocketPath(options.socketPath);
         this.applicationId = options.applicationId;
     }
 

package/src/vite-plugins/build-manifest.ts

@@ -21,6 +21,11 @@ type ManifestState = {
     outDir: string;
 };
 
+type BuildConfigIdentity = {
+    configFile: string;
+    configDigest: string;
+};
+
 const PACKAGE_MANIFEST_FILENAME = "package.json";
 const DEFAULT_OUT_DIR = "dist";
 const JSON_INDENT = 4;
@@ -73,7 +78,7 @@ const packagesFor = (outDir: string, ids: string[]): RecordedPackage[] => {
 
 const renderManifest = (manifest: BuildManifest): string => `${JSON.stringify(manifest, null, JSON_INDENT)}\n`;
 
-function gtkxBuildManifest(root: string, collector: BuildManifestCollector): Plugin {
+function gtkxBuildManifest(root: string, collector: BuildManifestCollector, identity: BuildConfigIdentity): Plugin {
     const state: ManifestState = { outDir: join(root, DEFAULT_OUT_DIR) };
 
     return {
@@ -90,6 +95,7 @@ function gtkxBuildManifest(root: string, collector: BuildManifestCollector): Plu
             const manifest: BuildManifest = {
                 generator: BUILD_MANIFEST_GENERATOR,
                 formatVersion: BUILD_MANIFEST_FORMAT_VERSION,
+                ...identity,
                 schemas: collector.schemas,
                 packages: packagesFor(state.outDir, ids),
             };

package/src/vite-plugins/i18n.ts

@@ -1,7 +1,7 @@
 import type { ConfigLoader } from "@gtkx/config";
 import type { Plugin, ResolvedConfig } from "vite";
 import { createConfigLoader } from "@gtkx/config/internal";
-import { toPosixPath } from "@gtkx/utils";
+import { isPathWithin, toPosixPath } from "@gtkx/utils";
 import { existsSync, mkdirSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join, posix, relative, resolve } from "node:path";
@@ -13,7 +13,8 @@ import {
     synchronizeCatalogs,
 } from "../i18n/catalogs.js";
 import { extractSourceCatalog } from "../i18n/source-messages.js";
-import { discoverSourceFiles } from "../internal/source-imports.js";
+import { emitI18nTypes } from "../i18n/types.js";
+import { discoverSourceFiles, sourceLanguage } from "../internal/source-imports.js";
 import { stripQuery } from "./strip-query.js";
 
 type I18nState = {
@@ -21,6 +22,7 @@ type I18nState = {
     i18nRoot: string;
     outDir: string;
     project: CatalogProject | null;
+    extraction: Promise<void>;
 };
 
 const BOOTSTRAP_SPECIFIER = "@gtkx/i18n/bootstrap";
@@ -94,6 +96,7 @@ const buildCatalogs = (state: I18nState): void => {
 const extractProjectMessages = async (
     state: I18nState,
     shouldPreserveMetadataMessages: boolean,
+    shouldSynchronizeCatalogs: boolean,
 ): Promise<void> => {
     const project = state.project;
 
@@ -104,7 +107,65 @@ const extractProjectMessages = async (
     const srcDir = join(project.root, "src");
     const sourceFiles = discoverSourceFiles(existsSync(srcDir) ? srcDir : project.root);
     await extractSourceCatalog(project, sourceFiles, shouldPreserveMetadataMessages);
-    synchronizeCatalogs(project);
+
+    if (shouldSynchronizeCatalogs) {
+        synchronizeCatalogs(project);
+    }
+
+    await emitI18nTypes(project.root);
+};
+
+const settleExtraction = async (pending: Promise<void>): Promise<void> => {
+    try {
+        await pending;
+    } catch {
+        return;
+    }
+};
+
+const queueExtraction = (
+    state: I18nState,
+    shouldPreserveMetadataMessages: boolean,
+    shouldSynchronizeCatalogs: boolean,
+): Promise<void> => {
+    const prior = state.extraction;
+    const pending = (async (): Promise<void> => {
+        await settleExtraction(prior);
+        await extractProjectMessages(
+            state,
+            shouldPreserveMetadataMessages,
+            shouldSynchronizeCatalogs,
+        );
+    })();
+
+    state.extraction = pending;
+
+    return pending;
+};
+
+const isProjectSource = (state: I18nState, path: string): boolean => {
+    const project = state.project;
+
+    if (project === null || sourceLanguage(path) === undefined) {
+        return false;
+    }
+
+    const srcDir = join(project.root, "src");
+    const sourceRoot = existsSync(srcDir) ? srcDir : project.root;
+
+    return isPathWithin(sourceRoot, path);
+};
+
+const refreshProjectMessages = async (
+    state: I18nState,
+    shouldPreserveMetadataMessages: boolean,
+    reportError: (message: string) => void,
+): Promise<void> => {
+    try {
+        await queueExtraction(state, shouldPreserveMetadataMessages, false);
+    } catch (error) {
+        reportError(error instanceof Error ? error.message : String(error));
+    }
 };
 
 const gtkxI18n = (
@@ -112,7 +173,13 @@ const gtkxI18n = (
     loadConfig: ConfigLoader = createConfigLoader(),
     shouldPreserveMetadataMessages = true,
 ): Plugin => {
-    const state: I18nState = { entryPath, i18nRoot: "", outDir: "", project: null };
+    const state: I18nState = {
+        entryPath,
+        extraction: Promise.resolve(),
+        i18nRoot: "",
+        outDir: "",
+        project: null,
+    };
 
     return {
         name: "gtkx:i18n",
@@ -120,7 +187,21 @@ const gtkxI18n = (
 
         configResolved: (config) => applyResolvedConfig(state, config, loadConfig),
 
-        buildStart: () => extractProjectMessages(state, shouldPreserveMetadataMessages),
+        buildStart: () => queueExtraction(state, shouldPreserveMetadataMessages, true),
+
+        hotUpdate(options) {
+            if (!isProjectSource(state, options.file)) {
+                return;
+            }
+
+            return refreshProjectMessages(
+                state,
+                shouldPreserveMetadataMessages,
+                (message) => {
+                    options.server.config.logger.error(message);
+                },
+            );
+        },
 
         transform(code, id) {
             if (isI18nLocaleModule(state, id)) {

package/src/vite-plugins/index.ts

@@ -13,13 +13,20 @@ import { gtkxSettings } from "./settings.js";
 import { gtkxStoreLinks } from "./store-links.js";
 import { gtkxUndeclaredLibrary } from "./undeclared-library.js";
 
-const gtkxVitePlugins = (
-    mode?: string,
-    entryPath?: string,
-    buildManifest?: BuildManifestCollector,
-    shouldPreserveI18nMetadata = true,
-): Plugin[] => {
-    const loadConfig = createConfigLoader(mode === undefined ? {} : { mode });
+type GtkxVitePluginOptions = {
+    buildManifest?: BuildManifestCollector | undefined;
+    configFile?: string | undefined;
+    entryPath?: string | undefined;
+    mode?: string | undefined;
+    shouldPreserveI18nMetadata?: boolean | undefined;
+};
+
+const gtkxVitePlugins = (options: GtkxVitePluginOptions = {}): Plugin[] => {
+    const { buildManifest, configFile, entryPath, mode, shouldPreserveI18nMetadata = true } = options;
+    const loadConfig = createConfigLoader({
+        ...(mode !== undefined && { mode }),
+        ...(configFile !== undefined && { configFile }),
+    });
 
     return [
         createConfigPlugin({ name: "gtkx:config", loadConfig }),