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

package/src/internal/parent-process.ts

@@ -0,0 +1,110 @@
+import { readFileSync } from "node:fs";
+
+type ProcessIdentity = {
+    pid: number;
+    parentId: number;
+    processGroupId: number;
+    startTime: string;
+    state: string;
+};
+
+type ProcessGroupOwner = Pick<ProcessIdentity, "pid" | "startTime">;
+type ProcessGroupOwnerCapture = { isCaptured: true; owner: ProcessGroupOwner | undefined } |
+    { isCaptured: false; error: Error };
+
+const initialParentId = process.ppid;
+const STOPPED_PROCESS_STATES: Set<string> = new Set(["Z", "X", "x"]);
+
+const processIdentity = (pid: number): ProcessIdentity => {
+    const stat = readFileSync(`/proc/${String(pid)}/stat`, "utf8");
+    const fields = stat.slice(stat.lastIndexOf(") ") + 2).split(" ");
+    const state = fields[0];
+    const parentId = Number(fields[1]);
+    const processGroupId = Number(fields[2]);
+    const startTime = fields[19];
+
+    if (
+        state === undefined ||
+        startTime === undefined ||
+        !Number.isSafeInteger(parentId) ||
+        !Number.isSafeInteger(processGroupId)
+    ) {
+        throw new Error(`Failed to identify process ${String(pid)}`);
+    }
+
+    return { pid, parentId, processGroupId, startTime, state };
+};
+
+const ancestorFor = (process: ProcessIdentity, ancestorId: number): ProcessIdentity | undefined => {
+    let current = process;
+
+    while (current.parentId > 1) {
+        const parent = processIdentity(current.parentId);
+
+        if (parent.pid === ancestorId) {
+            return parent;
+        }
+
+        current = parent;
+    }
+
+    return undefined;
+};
+
+const processGroupOwner = (process: ProcessIdentity): ProcessGroupOwner => {
+    if (process.processGroupId !== process.pid || STOPPED_PROCESS_STATES.has(process.state)) {
+        throw new Error(`Failed to identify process group ${String(process.pid)}`);
+    }
+
+    return { pid: process.pid, startTime: process.startTime };
+};
+
+const processGroupOwnerFor = (process: ProcessIdentity): ProcessGroupOwner | undefined => {
+    if (process.processGroupId === process.pid) {
+        return undefined;
+    }
+
+    const groupLeader = processGroupOwner(processIdentity(process.processGroupId));
+    const owner = ancestorFor(process, groupLeader.pid);
+
+    if (owner !== undefined) {
+        return groupLeader;
+    }
+
+    const currentGroupLeader = processGroupOwner(processIdentity(groupLeader.pid));
+
+    if (currentGroupLeader.startTime !== groupLeader.startTime) {
+        throw new Error(`Failed to identify process group ${String(groupLeader.pid)}`);
+    }
+
+    return undefined;
+};
+
+const captureProcessGroupOwner = (): ProcessGroupOwnerCapture => {
+    try {
+        const initialProcess = processIdentity(process.pid);
+
+        if (initialProcess.parentId !== initialParentId) {
+            throw new Error("The process that launched GTKX exited during startup");
+        }
+
+        return { isCaptured: true, owner: processGroupOwnerFor(initialProcess) };
+    } catch (error) {
+        return {
+            isCaptured: false,
+            error: error instanceof Error ? error : new Error("Failed to identify the process that launched GTKX"),
+        };
+    }
+};
+
+const capturedProcessGroupOwner = captureProcessGroupOwner();
+
+const getInitialProcessGroupOwner = (): ProcessGroupOwner | undefined => {
+    if (!capturedProcessGroupOwner.isCaptured) {
+        throw capturedProcessGroupOwner.error;
+    }
+
+    return capturedProcessGroupOwner.owner;
+};
+
+export { getInitialProcessGroupOwner, initialParentId };

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/ensure-store.ts

@@ -3,11 +3,11 @@ import { ensureGenerated } from "../codegen/run-codegen.js";
 
 const TEST_MODE = "test";
 
-const gtkxEnsureStore = (): Plugin => ({
+const gtkxEnsureStore = (configFile?: string): Plugin => ({
     name: "gtkx:ensure-store",
 
     async config() {
-        await ensureGenerated(process.cwd(), { shouldAnnounce: true, mode: TEST_MODE });
+        await ensureGenerated(process.cwd(), { shouldAnnounce: true, mode: TEST_MODE, configFile });
     },
 });
 

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 { isPathWithin, toPosixPath } from "@gtkx/utils";
+import { isPathWithin, logger, toPosixPath } from "@gtkx/utils";
 import { existsSync, mkdirSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join, posix, relative, resolve } from "node:path";
@@ -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";
@@ -23,6 +23,7 @@ type I18nState = {
     outDir: string;
     project: CatalogProject | null;
     extraction: Promise<void>;
+    hotUpdateTimestamp: number | null;
 };
 
 const BOOTSTRAP_SPECIFIER = "@gtkx/i18n/bootstrap";
@@ -159,12 +160,27 @@ const isProjectSource = (state: I18nState, path: string): boolean => {
 const refreshProjectMessages = async (
     state: I18nState,
     shouldPreserveMetadataMessages: boolean,
-    reportError: (message: string) => void,
+    shouldSynchronizeCatalogs = false,
 ): Promise<void> => {
     try {
-        await queueExtraction(state, shouldPreserveMetadataMessages, false);
+        await queueExtraction(state, shouldPreserveMetadataMessages, shouldSynchronizeCatalogs);
     } catch (error) {
-        reportError(error instanceof Error ? error.message : String(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);
     }
 };
 
@@ -172,10 +188,12 @@ const gtkxI18n = (
     entryPath: string,
     loadConfig: ConfigLoader = createConfigLoader(),
     shouldPreserveMetadataMessages = true,
+    shouldRecoverExtractionErrors = false,
 ): Plugin => {
     const state: I18nState = {
         entryPath,
         extraction: Promise.resolve(),
+        hotUpdateTimestamp: null,
         i18nRoot: "",
         outDir: "",
         project: null,
@@ -187,20 +205,18 @@ 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)) {
+            if (!isProjectSource(state, options.file) || state.hotUpdateTimestamp === options.timestamp) {
                 return;
             }
 
-            return refreshProjectMessages(
-                state,
-                shouldPreserveMetadataMessages,
-                (message) => {
-                    options.server.config.logger.error(message);
-                },
-            );
+            state.hotUpdateTimestamp = options.timestamp;
+
+            return refreshProjectMessages(state, shouldPreserveMetadataMessages);
         },
 
         transform(code, id) {

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),

package/src/vite-plugins/native.ts

@@ -5,7 +5,6 @@ import { arch, platform } from "node:os";
 import { dirname, join } from "node:path";
 import { stripQuery } from "./strip-query.js";
 
-const EMITTED_BINDING_SPECIFIER = "./gtkx.node";
 const BINDING_FILENAME = "gtkx.node";
 
 function resolveBinaryPath(projectRequire: ReturnType<typeof createRequire>, currentArch: string): string {
@@ -97,10 +96,6 @@ function gtkxNative(root: string): Plugin {
             });
         },
 
-        resolveId(id) {
-            return id === EMITTED_BINDING_SPECIFIER ? { id, external: true } : null;
-        },
-
         transform(code, id) {
             return transformLoader(code, id, loaderPath(), bindingReferenceId);
         },

package/src/vite-plugins/settings-worker-env.ts

@@ -3,8 +3,8 @@ import type { Plugin } from "vitest/config";
 import { createConfigLoader } from "@gtkx/config/internal";
 import { prependSchemaDir, stageAndCompileProjectSchemas } from "../settings/schema.js";
 
-function gtkxSettingsWorkerEnv(): Plugin {
-    const loadConfig = createConfigLoader();
+function gtkxSettingsWorkerEnv(configFile?: string): Plugin {
+    const loadConfig = createConfigLoader({ configFile });
 
     return {
         name: "gtkx:settings-worker-env",

package/src/vitest-plugin.ts

@@ -1,5 +1,5 @@
 import type { Plugin } from "vite";
-import gtkxVitest from "@gtkx/vitest";
+import gtkxVitest, { type PluginOptions } from "@gtkx/vitest";
 import { gtkxEnsureStore } from "./vite-plugins/ensure-store.js";
 import { gtkxVitePlugins } from "./vite-plugins/index.js";
 import { gtkxSettingsWorkerEnv } from "./vite-plugins/settings-worker-env.js";
@@ -11,11 +11,11 @@ import { gtkxSettingsWorkerEnv } from "./vite-plugins/settings-worker-env.js";
  *
  * @returns The plugins to spread into a Vitest config.
  */
-const gtkx = (): Plugin[] => [
-    gtkxEnsureStore(),
-    ...gtkxVitePlugins(),
-    gtkxSettingsWorkerEnv(),
-    gtkxVitest(),
+const gtkx = (options: PluginOptions = {}): Plugin[] => [
+    gtkxEnsureStore(options.configFile),
+    ...gtkxVitePlugins({ configFile: options.configFile }),
+    gtkxSettingsWorkerEnv(options.configFile),
+    gtkxVitest(options),
 ];
 
 export default gtkx;