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

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";
@@ -23,7 +24,7 @@ type ResolvedPackage = { dir: string; version: string };
 type CodegenContext = {
     root: string;
     config: Config;
-    configFile: string | undefined;
+    configFile: string;
 };
 
 const readVersion = (packageJsonPath: string): string => {
@@ -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,48 +52,35 @@ 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,
     };
 };
 
-const resolveCodegenContext = async (cwd: string, mode?: string): Promise<CodegenContext | null> => {
+const resolveCodegenContext = async (cwd: string, mode?: string): Promise<CodegenContext> => {
     const { config, configFile } = await loadConfig(cwd, { mode });
 
-    if (configFile === undefined) {
-        return null;
-    }
-
     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,10 +1,19 @@
-import { type ElementProps, readBuiltinElements, resolveGirPath, resolveLibraries, writeDocs } from "@gtkx/codegen";
+import {
+    type ElementProps,
+    mergeOmittedProps,
+    type OmittedProps,
+    readBuiltinElements,
+    resolveGirPath,
+    resolveLibraries,
+    resolveStore,
+} from "@gtkx/codegen";
+import { writeDocs } from "@gtkx/codegen/internal";
 import { loadConfig } from "@gtkx/config";
+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({
@@ -55,17 +64,19 @@ const docs = defineCommand({
         const libraries = resolveLibraries(config.libraries, girPath);
         const startedAt = Date.now();
         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: await resolveDocsProps(cwd),
-            force: args.force,
+            props: builtin.props,
+            omittedProps: mergeOmittedProps(builtin.omittedProps, resolveOmittedProps(config.elements)),
+            isForced: args.force,
         });
 
-        if (!regenerated) {
+        if (!isRegenerated) {
             info(`docs: pages in ${outDir} are up to date`);
 
             return;
@@ -80,16 +91,16 @@ const docs = defineCommand({
     },
 });
 
-const resolveDocsProps = async (cwd: string): Promise<ElementProps> => {
-    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 {};
+    if (!existsSync(gi.storeDir)) {
+        return { props: {}, omittedProps: {} };
     }
 
-    const { props } = await readBuiltinElements(resolveReactSubexports(cwd), giStoreDir);
+    const { props, omittedProps } = await readBuiltinElements(reactSubexports, gi.storeDir);
 
-    return props;
+    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/index.ts

@@ -13,7 +13,7 @@ const gtkxVitePlugins = (mode?: string): Plugin[] => {
 
     return [
         createConfigPlugin({ name: "gtkx:config", loadConfig }),
-        gtkxUndeclaredLibrary(mode),
+        gtkxUndeclaredLibrary(loadConfig),
         gtkxSettings(),
         gtkxIcons(),
         gtkxResources(loadConfig),

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";
@@ -61,7 +61,7 @@ function gtkxReactCompiler(loadConfig: ConfigLoader = createConfigLoader()): Plu
         enforce: "pre",
 
         async config(config: UserConfig) {
-            const resolved = await loadConfig(config.root ?? process.cwd());
+            const resolved = await loadConfig.resolve(config.root ?? process.cwd());
             state.options = resolved.reactCompiler;
         },
 

package/src/vite-plugins/resources.ts

@@ -253,7 +253,7 @@ const refreshDevRegistration = async (state: PluginState): Promise<void> => {
 };
 
 const resolveResourceConfig = async (state: PluginState, config: UserConfig, loadConfig: ConfigLoader) => {
-    const { applicationId } = await loadConfig(config.root ?? process.cwd());
+    const { applicationId } = await loadConfig.resolve(config.root ?? process.cwd());
     state.prefix = deriveResourcePrefix(applicationId);
 
     return {

package/src/vite-plugins/undeclared-library.ts

@@ -1,10 +1,11 @@
+import type { ConfigLoader } from "@gtkx/config/internal";
 import type { Plugin, UserConfig } from "vite";
 import { discoverGirNamespaces, resolveGirPath } from "@gtkx/codegen";
-import { loadConfig } from "@gtkx/config";
+import { createConfigLoader } from "@gtkx/config/internal";
 
 type PluginState = {
     root: string;
-    mode: string | undefined;
+    loadConfig: ConfigLoader;
     girPath: string[] | null;
 };
 
@@ -12,7 +13,7 @@ const GENERATED_MODULE_PATTERN = /^@gtkx\/(?:gi|jsx)\/([a-z0-9]+)$/;
 
 const girSearchPaths = async (state: PluginState): Promise<string[]> => {
     if (state.girPath === null) {
-        const { config } = await loadConfig(state.root, { mode: state.mode });
+        const { config } = await state.loadConfig.load(state.root);
         state.girPath = resolveGirPath(config.girPath);
     }
 
@@ -42,10 +43,10 @@ const undeclaredLibraryError = (source: string, namespace: string, girPath: stri
     );
 };
 
-function gtkxUndeclaredLibrary(mode?: string): Plugin {
+function gtkxUndeclaredLibrary(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
     const state: PluginState = {
         root: "",
-        mode,
+        loadConfig,
         girPath: null,
     };
 

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;