@gtkx/cli 1.0.0-rc.3 → 1.0.0-rc.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/cli",
-  "version": "1.0.0-rc.3",
+  "version": "1.0.0-rc.4",
   "description": "Command-line tool and Vite plugin stack that scaffolds, develops, builds, and documents GTKX applications",
   "keywords": [
     "gtkx",
@@ -56,25 +56,25 @@
   "dependencies": {
     "@babel/core": "^8.0.1",
     "@babel/preset-typescript": "^8.0.1",
-    "@swc/core": "^1.15.46",
+    "@swc/core": "^1.15.47",
     "babel-plugin-react-compiler": "^1.0.0",
     "citty": "^0.2.2",
     "fast-xml-parser": "^5.10.1",
     "react-refresh": "^0.18.0",
-    "vite": "^8.1.5",
-    "@gtkx/config": "1.0.0-rc.3",
-    "@gtkx/mcp": "1.0.0-rc.3",
-    "@gtkx/codegen": "1.0.0-rc.3",
-    "@gtkx/runtime": "1.0.0-rc.3",
-    "@gtkx/utils": "1.0.0-rc.3",
-    "@gtkx/vitest": "1.0.0-rc.3",
-    "create-gtkx": "1.0.0-rc.3"
+    "vite": "^8.2.0",
+    "@gtkx/codegen": "1.0.0-rc.4",
+    "@gtkx/config": "1.0.0-rc.4",
+    "@gtkx/runtime": "1.0.0-rc.4",
+    "@gtkx/utils": "1.0.0-rc.4",
+    "@gtkx/mcp": "1.0.0-rc.4",
+    "@gtkx/vitest": "1.0.0-rc.4",
+    "create-gtkx": "1.0.0-rc.4"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",
     "@types/react-refresh": "^0.14.7",
     "vitest": "^4.1.10",
-    "@gtkx/testing": "1.0.0-rc.3"
+    "@gtkx/testing": "1.0.0-rc.4"
   },
   "peerDependencies": {
     "react": "^19"

package/src/codegen/freshness.ts

@@ -27,15 +27,12 @@ const namespaceBarrelPath = (giStoreDir: string, library: string): string => {
     return join(giStoreDir, namespace, "index.js");
 };
 
-const isStoreResolvable = (storeDir: string, packageName: string): boolean =>
-    existsSync(join(storeDir, "node_modules", "@gtkx", packageName, "package.json"));
+// The manifest is what makes the store resolvable as a package, and npm's prune of a generated store
+// removes the link while leaving the directory behind, so both have to be checked.
+const hasManifest = (storeDir: string): boolean => existsSync(join(storeDir, "package.json"));
 
 const isGiStoreStale = (store: CodegenStore, libraries: string[]): boolean => {
-    if (!existsSync(store.giLinkDir) || !existsSync(store.giStoreDir)) {
-        return true;
-    }
-
-    if (!isStoreResolvable(store.giStoreDir, "gi")) {
+    if (!existsSync(store.giLinkDir) || !hasManifest(store.giStoreDir)) {
         return true;
     }
 
@@ -47,7 +44,7 @@ const isReactStoreStale = (store: CodegenStore): boolean => {
         return false;
     }
 
-    if (!existsSync(store.jsxLinkDir) || !isStoreResolvable(store.jsxStoreDir, "jsx")) {
+    if (!existsSync(store.jsxLinkDir) || !hasManifest(store.jsxStoreDir)) {
         return true;
     }
 

package/src/codegen/run-codegen.ts

@@ -4,7 +4,7 @@ import {
     resolveElementComponents,
     resolveElementProps,
     resolveLazyElements,
-    resolveOmitProps,
+    resolveOmittedProps,
 } from "@gtkx/config/internal";
 import { info } from "@gtkx/utils";
 import { rmSync } from "node:fs";
@@ -17,7 +17,7 @@ import { type CodegenStore, resolveCodegenContext } from "./store-resolver.js";
 type RunCodegenOptions = {
     cwd?: string;
     mode?: string | undefined;
-    force?: boolean;
+    isForced?: boolean;
     inputs?: CodegenInputs;
     resolved?: LoadedConfig;
 };
@@ -28,7 +28,7 @@ type LoadedConfig = {
 };
 
 type RunCodegenResult = {
-    regenerated: boolean;
+    isRegenerated: boolean;
     namespaces: number;
     intrinsicElements: number;
     duration: number;
@@ -44,7 +44,7 @@ type CodegenOptionsInput = {
     elements: Config["elements"];
 };
 
-type PreparedCodegen = CodegenInputs & { force: boolean };
+type PreparedCodegen = CodegenInputs & { isForced: boolean };
 
 type RunOptionsInput = {
     root: string;
@@ -89,11 +89,11 @@ const codegenOptions = ({ store, libraries, girPath, elements }: CodegenOptionsI
     userComponents: resolveElementComponents(elements),
     userProps: resolveElementProps(elements),
     userLazyElements: resolveLazyElements(elements),
-    userOmitProps: resolveOmitProps(elements),
+    userOmittedProps: resolveOmittedProps(elements),
 });
 
 const disabledCodegenResult = (configFile: string): RunCodegenResult => ({
-    regenerated: false,
+    isRegenerated: false,
     namespaces: 0,
     intrinsicElements: 0,
     duration: 0,
@@ -118,9 +118,9 @@ const prepareCodegen = (options: RunCodegenOptions, cwd: string, config: Config)
         throw new Error(GIR_PATH_MISSING_MESSAGE);
     }
 
-    const isForce = options.force === true || isCodegenStale({ girPath, libraries, store });
+    const isForced = options.isForced === true || isCodegenStale({ girPath, libraries, store });
 
-    return { girPath, libraries, store, force: isForce };
+    return { girPath, libraries, store, isForced };
 };
 
 const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenResult> => {
@@ -133,9 +133,9 @@ const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenRe
         return disabledCodegenResult(configFile);
     }
 
-    const { girPath, libraries, store, force } = prepareCodegen(options, cwd, config);
+    const { girPath, libraries, store, isForced } = prepareCodegen(options, cwd, config);
 
-    if (options.force) {
+    if (options.isForced) {
         clearGeneratedStores(store);
     }
 
@@ -146,11 +146,11 @@ const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenRe
             girPath,
             elements: config.elements,
         }),
-        force,
+        isForced,
     });
 
     return {
-        regenerated: result.regenerated,
+        isRegenerated: result.isRegenerated,
         namespaces: result.namespaces,
         intrinsicElements: result.intrinsicElements,
         duration: result.duration,
@@ -182,8 +182,8 @@ const resolveInputsOrNull = (cwd: string, config: Config): CodegenInputs | null
     }
 };
 
-const maybeAnnounceStale = (announce: boolean | undefined, inputs: CodegenInputs | null): void => {
-    if (!announce) {
+const maybeAnnounceStale = (shouldAnnounce: boolean | undefined, inputs: CodegenInputs | null): void => {
+    if (!shouldAnnounce) {
         return;
     }
 
@@ -202,9 +202,9 @@ const getRunOptions = ({ root, mode, inputs, resolved }: RunOptionsInput): RunCo
 
 const ensureGenerated = async (
     cwd: string,
-    options: { announce?: boolean; mode?: string } = {},
+    options: { shouldAnnounce?: boolean; mode?: string } = {},
 ): Promise<boolean> => {
-    if (options.announce && process.env.GTKX_DISABLE_PREFLIGHT === "1") {
+    if (options.shouldAnnounce && process.env.GTKX_DISABLE_PREFLIGHT === "1") {
         return false;
     }
 
@@ -218,11 +218,11 @@ const ensureGenerated = async (
     }
 
     const inputs = resolveInputsOrNull(context.root, context.config);
-    maybeAnnounceStale(options.announce, inputs);
+    maybeAnnounceStale(options.shouldAnnounce, inputs);
     const resolved = { config: context.config, configFile: context.configFile };
     const result = await runCodegen(getRunOptions({ root: context.root, mode: options.mode, inputs, resolved }));
 
-    return result.regenerated;
+    return result.isRegenerated;
 };
 
 const resolveConfigWatch = async (

package/src/codegen/store-resolver.ts

@@ -1,3 +1,4 @@
+import { resolveStore } from "@gtkx/codegen";
 import { type Config, loadConfig } from "@gtkx/config";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -32,24 +33,6 @@ const readVersion = (packageJsonPath: string): string => {
     return parsed.version ?? "0.0.0";
 };
 
-const readSubexports = (packageDir: string): string[] => {
-    const parsed = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8")) as {
-        exports?: Record<string, unknown>;
-    };
-
-    return Object.keys(parsed.exports ?? {})
-        .filter((key) => key.startsWith("./") && key !== "./package.json")
-        .map((key) => key.slice(2));
-};
-
-/** Resolves the `@gtkx/react` subexport names for a project without requiring runtime/native to be installed. */
-const resolveReactSubexports = (dir: string): string[] => {
-    const require = createRequire(pathToFileURL(join(dir, "__gtkx_resolver__.js")).href);
-    const react = resolvePackage(require, dir, "@gtkx/react");
-
-    return react === null ? [] : readSubexports(react.dir);
-};
-
 const resolvePackage = (require: NodeJS.Require, dir: string, packageName: string): ResolvedPackage | null => {
     try {
         const real = realpathSync(require.resolve(`${packageName}/package.json`));
@@ -69,36 +52,27 @@ const resolvePackage = (require: NodeJS.Require, dir: string, packageName: strin
     }
 };
 
+const siblingStore = (giDir: string): string => join(dirname(giDir), "jsx");
+
 const resolveCodegenStore = (dir: string): CodegenStore => {
     const require = createRequire(pathToFileURL(join(dir, "__gtkx_resolver__.js")).href);
-    const runtime = resolvePackage(require, dir, "@gtkx/runtime");
-
-    if (runtime === null) {
-        throw new Error("Cannot resolve @gtkx/runtime from the project; is it installed?");
-    }
-
-    const native = resolvePackage(require, dir, "@gtkx/native");
 
-    if (native === null) {
+    if (resolvePackage(require, dir, "@gtkx/native") === null) {
         throw new Error("Cannot resolve @gtkx/native from the project; is it installed?");
     }
 
-    const react = resolvePackage(require, dir, "@gtkx/react");
-    const reactRuntime = resolvePackage(require, dir, "react");
-    const nodeModules = join(dir, "node_modules");
+    const store = resolveStore(dir);
+    const hasReactRuntime = resolvePackage(require, dir, "react") !== null;
 
     return {
-        giStoreDir: join(nodeModules, ".gtkx", "gi"),
-        giLinkDir: join(nodeModules, "@gtkx", "gi"),
-        jsxStoreDir: join(nodeModules, ".gtkx", "jsx"),
-        jsxLinkDir: join(nodeModules, "@gtkx", "jsx"),
-        runtimeVersion: runtime.version,
+        giStoreDir: store.gi.storeDir,
+        giLinkDir: store.gi.linkDir,
+        jsxStoreDir: store.jsx?.storeDir ?? siblingStore(store.gi.storeDir),
+        jsxLinkDir: store.jsx?.linkDir ?? siblingStore(store.gi.linkDir),
+        runtimeVersion: store.gi.version,
         react:
-            react !== null && reactRuntime !== null
-                ? {
-                        version: react.version,
-                        subexports: readSubexports(react.dir),
-                    }
+            hasReactRuntime && store.jsx !== null
+                ? { version: store.jsx.version, subexports: store.reactSubexports }
                 : null,
     };
 };
@@ -109,4 +83,4 @@ const resolveCodegenContext = async (cwd: string, mode?: string): Promise<Codege
     return { root: cwd, config, configFile };
 };
 
-export { resolveReactSubexports, resolveCodegenStore, resolveCodegenContext, type CodegenStore, type CodegenContext };
+export { resolveCodegenStore, resolveCodegenContext, type CodegenStore, type CodegenContext };

package/src/commands/build.ts

@@ -21,7 +21,7 @@ const build = defineCommand({
     async run({ args }) {
         const { cwd, entry } = resolveEntry(args);
         info(`Building ${entry}`);
-        await ensureGenerated(cwd, { announce: true, mode: BUILD_MODE });
+        await ensureGenerated(cwd, { shouldAnnounce: true, mode: BUILD_MODE });
 
         await buildApp({
             entry,

package/src/commands/codegen.ts

@@ -36,7 +36,7 @@ const codegen = defineCommand({
         }
 
         const startedAt = Date.now();
-        const result = await runCodegen({ cwd, force: true });
+        const result = await runCodegen({ cwd, isForced: true });
         syncSchemaEnv(cwd);
         const lines = formatCodegenResult(result, Date.now() - startedAt);
 

package/src/commands/dev.ts

@@ -15,7 +15,7 @@ const dev = defineCommand({
     },
     async run({ args }) {
         const { cwd, entry: entryPath } = resolveEntry(args);
-        await ensureGenerated(cwd, { announce: true, mode: DEV_MODE });
+        await ensureGenerated(cwd, { shouldAnnounce: true, mode: DEV_MODE });
         const watch: DevWatch | undefined = await resolveConfigWatch(cwd, DEV_MODE);
         await runDevSupervisor(entryPath, cwd, watch);
     },

package/src/commands/docs.ts

@@ -1,19 +1,19 @@
 import {
     type ElementProps,
-    mergeOmitProps,
+    mergeOmittedProps,
     type OmittedProps,
     readBuiltinElements,
     resolveGirPath,
     resolveLibraries,
-    writeDocs,
+    resolveStore,
 } from "@gtkx/codegen";
+import { writeDocs } from "@gtkx/codegen/internal";
 import { loadConfig } from "@gtkx/config";
-import { resolveOmitProps } from "@gtkx/config/internal";
+import { resolveOmittedProps } from "@gtkx/config/internal";
 import { info } from "@gtkx/utils";
 import { defineCommand } from "citty";
 import { existsSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { resolveReactSubexports } from "../codegen/store-resolver.js";
+import { resolve } from "node:path";
 import { cwdArg, resolveCwd } from "../internal/entry-arg.js";
 
 const docs = defineCommand({
@@ -66,17 +66,17 @@ const docs = defineCommand({
         const outDir = resolve(cwd, args.out);
         const builtin = await resolveDocsElements(cwd);
 
-        const { regenerated, namespaces } = writeDocs({
+        const { isRegenerated, namespaces } = writeDocs({
             libraries,
             girPath,
             outDir,
             basePath: args["base-path"],
             props: builtin.props,
-            omitProps: mergeOmitProps(builtin.omitProps, resolveOmitProps(config.elements)),
-            force: args.force,
+            omittedProps: mergeOmittedProps(builtin.omittedProps, resolveOmittedProps(config.elements)),
+            isForced: args.force,
         });
 
-        if (!regenerated) {
+        if (!isRegenerated) {
             info(`docs: pages in ${outDir} are up to date`);
 
             return;
@@ -91,16 +91,16 @@ const docs = defineCommand({
     },
 });
 
-const resolveDocsElements = async (cwd: string): Promise<{ props: ElementProps; omitProps: OmittedProps }> => {
-    const giStoreDir = join(cwd, "node_modules", ".gtkx", "gi");
+const resolveDocsElements = async (cwd: string): Promise<{ props: ElementProps; omittedProps: OmittedProps }> => {
+    const { gi, reactSubexports } = resolveStore(cwd);
 
-    if (!existsSync(giStoreDir)) {
-        return { props: {}, omitProps: {} };
+    if (!existsSync(gi.storeDir)) {
+        return { props: {}, omittedProps: {} };
     }
 
-    const { props, omitProps } = await readBuiltinElements(resolveReactSubexports(cwd), giStoreDir);
+    const { props, omittedProps } = await readBuiltinElements(reactSubexports, gi.storeDir);
 
-    return { props, omitProps };
+    return { props, omittedProps };
 };
 
 export { docs };

package/src/dev/supervisor.ts

@@ -28,8 +28,8 @@ type SupervisorState = {
     watchers: FSWatcher[];
     fork: ForkRunner;
     child: SupervisedChild | null;
-    shuttingDown: boolean;
-    restarting: boolean;
+    isShuttingDown: boolean;
+    isRestarting: boolean;
     capturedChildExit: number | undefined;
 };
 
@@ -72,11 +72,11 @@ const captureShutdownExit = (state: SupervisorState, code: number | null, signal
 const handleChildExit = (state: SupervisorState, code: number | null, signal: NodeJS.Signals | null): void => {
     state.child = null;
 
-    if (state.restarting) {
+    if (state.isRestarting) {
         return;
     }
 
-    if (state.shuttingDown) {
+    if (state.isShuttingDown) {
         captureShutdownExit(state, code, signal);
 
         return;
@@ -101,12 +101,12 @@ const launch = (state: SupervisorState): void => {
     });
 };
 
-const isRestartBlocked = (state: SupervisorState): boolean => state.restarting || state.shuttingDown;
+const isRestartBlocked = (state: SupervisorState): boolean => state.isRestarting || state.isShuttingDown;
 
 const relaunchAfterExit = (state: SupervisorState): void => {
-    state.restarting = false;
+    state.isRestarting = false;
 
-    if (state.shuttingDown) {
+    if (state.isShuttingDown) {
         return;
     }
 
@@ -121,20 +121,20 @@ const restart = async (state: SupervisorState): Promise<void> => {
         return;
     }
 
-    state.restarting = true;
+    state.isRestarting = true;
     info("gtkx.config.ts changed; regenerating bindings...");
 
     try {
         await watch.regenerate();
     } catch (error_) {
         error("Codegen failed; keeping the current dev runner. Fix the error and save again.", error_);
-        state.restarting = false;
+        state.isRestarting = false;
 
         return;
     }
 
-    if (state.shuttingDown) {
-        state.restarting = false;
+    if (state.isShuttingDown) {
+        state.isRestarting = false;
 
         return;
     }
@@ -142,7 +142,7 @@ const restart = async (state: SupervisorState): Promise<void> => {
     const current = state.child;
 
     if (current === null) {
-        state.restarting = false;
+        state.isRestarting = false;
         launch(state);
 
         return;
@@ -164,7 +164,7 @@ const scheduleRestart = (state: SupervisorState, timer: DebounceTimer): void =>
 };
 
 const isWatchedChange = (state: SupervisorState, names: Set<string>, filename: string | Buffer | null): boolean => {
-    if (filename === null || state.shuttingDown) {
+    if (filename === null || state.isShuttingDown) {
         return false;
     }
 
@@ -222,7 +222,7 @@ const closeWatchers = (state: SupervisorState): void => {
 
 const shutdownOnSignal = (state: SupervisorState, signal: NodeJS.Signals): Promise<void> =>
     new Promise<void>((resolve) => {
-        state.shuttingDown = true;
+        state.isShuttingDown = true;
         closeWatchers(state);
 
         if (!state.child) {
@@ -261,8 +261,8 @@ const runDevSupervisor = async (
         watchers: [],
         fork,
         child: null,
-        shuttingDown: false,
-        restarting: false,
+        isShuttingDown: false,
+        isRestarting: false,
         capturedChildExit: undefined,
     };
 

package/src/mcp/handlers.ts

@@ -37,7 +37,7 @@ const HANDLERS: Record<ServerInitiatedMethod, ValidatedHandler> = {
         return {
             tree: testing.prettyWidget(container, {
                 getId: (w) => registry.getOrCreateId(w),
-                highlight: false,
+                shouldHighlight: false,
                 ...((params.maxDepth !== undefined) && { maxDepth: params.maxDepth }),
             }),
         };

package/src/mcp/serialize-widget.ts

@@ -31,8 +31,8 @@ const serializeWidget = (
         role: testing.formatRole(widget.getAccessibleRole()),
         name: widget.getName() || null,
         text: testing.getWidgetNodeText(widget),
-        sensitive: widget.getSensitive(),
-        visible: widget.getVisible(),
+        isSensitive: widget.getSensitive(),
+        isVisible: widget.getVisible(),
         cssClasses: widget.getCssClasses(),
         children,
     };

package/src/refresh-runtime.ts

@@ -3,13 +3,6 @@ import "./refresh-globals.js";
 
 type ComponentType = (...args: unknown[]) => unknown;
 
-/**
- * Builds the per-module `$RefreshReg$` and `$RefreshSig$` hooks that React Refresh
- * transformed code expects, scoping every registered component to the given module.
- *
- * @param moduleId Identifier used to namespace registered component types so they are unique across modules.
- * @returns An object with `$RefreshReg$` and `$RefreshSig$` to install as module-local globals.
- */
 function createModuleRegistration(moduleId: string): {
     $RefreshReg$: (type: ComponentType, id: string) => void;
     $RefreshSig$: typeof RefreshRuntime.createSignatureFunctionForTransform;
@@ -22,13 +15,6 @@ function createModuleRegistration(moduleId: string): {
     };
 }
 
-/**
- * Determines whether a module can act as a React Refresh boundary, meaning every one of
- * its exports (ignoring `__esModule`) looks like a React component type.
- *
- * @param moduleExports The module's export object to inspect.
- * @returns `true` when the module qualifies as a refresh boundary, `false` otherwise.
- */
 const isComponentExport = (key: string, value: unknown): boolean =>
     key === "__esModule" || RefreshRuntime.isLikelyComponentType(value);
 
@@ -54,9 +40,6 @@ function isRefreshBoundary(moduleExports: Record<string, unknown>): boolean {
     return Object.keys(moduleExports).some((k) => k !== "__esModule");
 }
 
-/**
- * Applies all pending React Refresh updates, re-rendering components whose modules have changed.
- */
 function performRefresh(): void {
     RefreshRuntime.performReactRefresh();
 }

package/src/settings/schema.ts

@@ -11,7 +11,7 @@ import { renderEnvModule } from "./render.js";
 
 type SchemaEnvResult = {
     path: string;
-    written: boolean;
+    isWritten: boolean;
 };
 
 const SCHEMA_SUFFIX = ".gschema.xml";
@@ -155,7 +155,7 @@ const emitSchemaEnv = (rootDir: string, dataDir: string | null): SchemaEnvResult
     const path = schemaEnvPath(rootDir);
     const isWritten = didWriteChanges(path, content);
 
-    return { path, written: isWritten };
+    return { path, isWritten };
 };
 
 export {

package/src/vite-plugins/react-compiler.ts

@@ -1,4 +1,4 @@
-import type { ResolvedReactCompilerOptions } from "@gtkx/config";
+import type { ResolvedReactCompilerOptions } from "@gtkx/config/internal";
 import type { Plugin, ResolvedConfig, UserConfig } from "vite";
 import { transformAsync } from "@babel/core";
 import babelPresetTypescriptNs from "@babel/preset-typescript";

package/src/vitest-plugin.ts

@@ -3,11 +3,5 @@ import gtkxVitest from "@gtkx/vitest";
 import { gtkxVitePlugins } from "./vite-plugins/index.js";
 import { gtkxSettingsWorkerEnv } from "./vite-plugins/settings-worker-env.js";
 
-/**
- * Vite plugin factory that assembles the plugins needed to run GTKX apps under Vitest,
- * combining the shared GTKX Vite plugins with the `@gtkx/vitest` test integration.
- *
- * @returns The ordered array of Vite plugins to include in a Vitest configuration.
- */
 const gtkx = (): Plugin[] => [...gtkxVitePlugins(), gtkxSettingsWorkerEnv(), gtkxVitest()];
 export default gtkx;