@gtkx/cli 1.0.0-rc.4 → 1.1.0

package/src/dev/failure-tracker.ts

@@ -0,0 +1,92 @@
+type FailureTracker = {
+    isDown: () => boolean;
+    hasReported: () => boolean;
+    fail: (cause?: unknown) => void;
+    report: (cause: unknown) => void;
+    settleUnmount: (decide: () => void) => void;
+};
+
+type FailureState = {
+    isDown: boolean;
+    hasReported: boolean;
+    isUnmounting: boolean;
+    announced: WeakSet<object>;
+    announce: (cause: unknown) => void;
+    isRefreshing: () => boolean;
+};
+
+const UNMOUNT_SETTLE_MS = 0;
+
+const wasAnnounced = (state: FailureState, cause: unknown): boolean => {
+    if (typeof cause !== "object" || cause === null) {
+        return false;
+    }
+
+    if (state.announced.has(cause)) {
+        return true;
+    }
+
+    state.announced.add(cause);
+
+    return false;
+};
+
+const recordCause = (state: FailureState, cause: unknown): void => {
+    state.hasReported = true;
+
+    if (!wasAnnounced(state, cause)) {
+        state.announce(cause);
+    }
+};
+
+const failState = (state: FailureState, cause: unknown): void => {
+    state.isDown = true;
+
+    if (cause !== undefined) {
+        recordCause(state, cause);
+    }
+};
+
+const reportState = (state: FailureState, cause: unknown): void => {
+    if (state.isUnmounting || state.isRefreshing()) {
+        state.isDown = true;
+    }
+
+    recordCause(state, cause);
+};
+
+const settleUnmountState = (state: FailureState, decide: () => void): void => {
+    state.isUnmounting = true;
+
+    setTimeout(() => {
+        state.isUnmounting = false;
+        decide();
+    }, UNMOUNT_SETTLE_MS);
+};
+
+const createFailureTracker = (announce: (cause: unknown) => void, isRefreshing: () => boolean): FailureTracker => {
+    const state: FailureState = {
+        isDown: false,
+        hasReported: false,
+        isUnmounting: false,
+        announced: new WeakSet(),
+        announce,
+        isRefreshing,
+    };
+
+    return {
+        isDown: () => state.isDown,
+        hasReported: () => state.hasReported,
+        fail: (cause) => {
+            failState(state, cause);
+        },
+        report: (cause) => {
+            reportState(state, cause);
+        },
+        settleUnmount: (decide) => {
+            settleUnmountState(state, decide);
+        },
+    };
+};
+
+export { createFailureTracker, type FailureTracker };

package/src/dev/missing-import.ts

@@ -0,0 +1,32 @@
+import { basename, dirname, extname } from "node:path";
+
+const LOAD_FAILURE_PATTERN = /Failed to load url (\S+)/;
+const INDEX_NAME = "index";
+const NAMELESS_URLS = new Set(["", ".", ".."]);
+
+const fileName = (path: string): string => basename(path, extname(path));
+
+const missingImportName = (cause: unknown): string | null => {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    const [, url] = LOAD_FAILURE_PATTERN.exec(message) ?? [];
+
+    if (url === undefined) {
+        return null;
+    }
+
+    const name = fileName(url);
+
+    return NAMELESS_URLS.has(name) ? null : name;
+};
+
+const isMissingImport = (createdPath: string, name: string): boolean => {
+    const created = fileName(createdPath);
+
+    if (created === name) {
+        return true;
+    }
+
+    return created === INDEX_NAME && basename(dirname(createdPath)) === name;
+};
+
+export { isMissingImport, missingImportName };

package/src/dev/runner-deps.ts

@@ -1,12 +1,19 @@
 import { loadConfig } from "@gtkx/config";
 import * as Gio from "@gtkx/gi/gio";
 import { quitApplication } from "@gtkx/runtime";
+import { type ApplicationInstance, getApplicationInstance } from "@gtkx/runtime/internal";
 import { info, installGracefulShutdown } from "@gtkx/utils";
+import { readFile } from "node:fs/promises";
 import { createServer } from "vite";
 import type { DevRunnerDeps } from "./runner.js";
 import { startMcpClient, stopMcpClient } from "../mcp/index.js";
-import { setTestingModuleLoader } from "../mcp/testing-loader.js";
-import { isRefreshBoundary, performRefresh } from "../refresh-runtime.js";
+import {
+    mergeTestingModule,
+    setTestingModuleLoader,
+    type TestingInternalModule,
+    type TestingPublicModule,
+} from "../mcp/testing-loader.js";
+import { isRefreshBoundary, performRefresh, staleExportName } from "../refresh-runtime.js";
 import { gtkxFastRefresh } from "../vite-plugins/fast-refresh/swc-refresh.js";
 import { gtkxVitePlugins } from "../vite-plugins/index.js";
 import { gtkxReactDomPrebundle } from "../vite-plugins/react-dom-prebundle.js";
@@ -16,11 +23,17 @@ const APPLICATION_POLL_INTERVAL_MS = 50;
 
 const currentApplicationId = (): string | null => Gio.Application.getDefault()?.applicationId ?? null;
 
-const waitForApplicationId = async (timeoutMs: number): Promise<string | null> => {
+const currentApplicationInstance = (): ApplicationInstance => {
+    const application = Gio.Application.getDefault();
+
+    return application === null ? "unregistered" : getApplicationInstance(application);
+};
+
+const waitForApplicationId = async (timeoutMs: number, shouldKeepWaiting: () => boolean): Promise<string | null> => {
     const deadline = Date.now() + timeoutMs;
     let applicationId = currentApplicationId();
 
-    while (applicationId === null && Date.now() < deadline) {
+    while (applicationId === null && Date.now() < deadline && shouldKeepWaiting()) {
         await new Promise((resolve) => setTimeout(resolve, APPLICATION_POLL_INTERVAL_MS));
         applicationId = currentApplicationId();
     }
@@ -28,6 +41,8 @@ const waitForApplicationId = async (timeoutMs: number): Promise<string | null> =
     return applicationId;
 };
 
+const readFileRevision = (path: string): Promise<string> => readFile(path, "utf8");
+
 const defaultDevRunnerDeps = (): DevRunnerDeps => ({
     createServer,
     waitForApplicationId,
@@ -37,7 +52,14 @@ const defaultDevRunnerDeps = (): DevRunnerDeps => ({
         return loaded.config.applicationId;
     },
     startMcpClient: (applicationId, loadAppModule) => {
-        setTestingModuleLoader(() => loadAppModule("@gtkx/testing") as Promise<typeof import("@gtkx/testing")>);
+        setTestingModuleLoader(async () => {
+            const [publicApi, internals] = await Promise.all([
+                loadAppModule("@gtkx/testing") as Promise<TestingPublicModule>,
+                loadAppModule("@gtkx/testing/internal") as Promise<TestingInternalModule>,
+            ]);
+
+            return mergeTestingModule(publicApi, internals);
+        });
 
         return startMcpClient(applicationId);
     },
@@ -45,6 +67,11 @@ const defaultDevRunnerDeps = (): DevRunnerDeps => ({
     watchApplicationShutdown: (onShutdown) => {
         Gio.Application.getDefault()?.on("shutdown", onShutdown);
     },
+    watchUncaughtErrors: (onUncaughtError) => {
+        process.on("uncaughtException", onUncaughtError);
+        process.on("unhandledRejection", onUncaughtError);
+    },
+    getApplicationInstance: currentApplicationInstance,
     installShutdownHandlers: (onSignal) => {
         installGracefulShutdown({ onSignal });
     },
@@ -57,6 +84,8 @@ const defaultDevRunnerDeps = (): DevRunnerDeps => ({
     },
     performRefresh,
     isRefreshBoundary,
+    staleExportName,
+    readFileRevision,
     plugins: () => [...gtkxVitePlugins(DEV_MODE), ...gtkxFastRefresh(), gtkxReactDomPrebundle()],
     log: info,
     exit: (code: number): never => process.exit(code),

package/src/dev/runner-main.ts

@@ -1,12 +1,11 @@
 import { error } from "@gtkx/utils";
 import { resolve } from "node:path";
 import { resolveDataDir } from "../internal/data-dir.js";
+import { DEV_ENTRY_ENV } from "./entry-env.js";
 import { prepareDevIconDir } from "./icon-dir.js";
 import { createDevRunner } from "./runner.js";
 import { prepareDevSchemaDir } from "./schema-dir.js";
 
-const ENTRY_ARG_INDEX = 2;
-
 const main = async (): Promise<void> => {
     if (process.channel) {
         process.once("disconnect", () => {
@@ -15,10 +14,10 @@ const main = async (): Promise<void> => {
     }
 
     const cwd = process.cwd();
-    const entryArg = process.argv[ENTRY_ARG_INDEX];
+    const entryArg = process.env[DEV_ENTRY_ENV];
 
     if (!entryArg) {
-        error("Missing entry argument");
+        error(`Missing ${DEV_ENTRY_ENV}`);
         process.exit(1);
     }