@gtkx/cli 1.6.0 → 2.0.0-beta.10

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@gtkx/cli",
-  "version": "1.6.0",
-  "description": "GTK app toolchain for React: scaffold, dev server, build, docs.",
+  "version": "2.0.0-beta.10",
+  "description": "Adwaita-first GNOME app toolchain for React and TypeScript.",
   "keywords": [
     "gtkx",
     "gtk",
     "gtk4",
+    "adwaita",
+    "gnome",
     "react",
     "typescript",
     "native",
@@ -33,10 +35,14 @@
     "./package.json": "./package.json",
     "./refresh-runtime": {
       "types": "./dist/refresh-runtime.d.ts",
+      "import": "./dist/refresh-runtime.js",
+      "require": null,
       "default": "./dist/refresh-runtime.js"
     },
     "./vitest-plugin": {
       "types": "./dist/vitest-plugin.d.ts",
+      "import": "./dist/vitest-plugin.js",
+      "require": null,
       "default": "./dist/vitest-plugin.js"
     }
   },
@@ -61,33 +67,38 @@
     }
   },
   "engines": {
-    "node": ">=24"
+    "node": ">=26.7.0"
   },
   "dependencies": {
     "@babel/core": "^8.0.1",
     "@babel/preset-typescript": "^8.0.1",
-    "@swc/core": "^1.16.1",
+    "@gtkx/codegen": "2.0.0-beta.10",
+    "@gtkx/config": "2.0.0-beta.10",
+    "@gtkx/mcp": "2.0.0-beta.10",
+    "@gtkx/native": "2.0.0-beta.10",
+    "@gtkx/runtime": "2.0.0-beta.10",
+    "@gtkx/utils": "2.0.0-beta.10",
+    "@gtkx/vitest": "2.0.0-beta.10",
+    "@swc/core": "^1.16.2",
     "babel-plugin-react-compiler": "^1.0.0",
     "citty": "^0.2.2",
-    "fast-xml-parser": "^5.11.0",
-    "i18next-cli": "1.71.3",
+    "confbox": "^0.3.1",
+    "create-gtkx": "2.0.0-beta.10",
+    "fast-xml-builder": "^1.3.1",
+    "fast-xml-parser": "^5.11.1",
+    "hosted-git-info": "^10.1.1",
+    "i18next-cli": "1.73.1",
+    "jiti": "^2.7.0",
     "react-refresh": "^0.18.0",
     "vite": "^8.2.2",
-    "yaml": "^2.9.0",
-    "@gtkx/codegen": "1.6.0",
-    "@gtkx/config": "1.6.0",
-    "@gtkx/runtime": "1.6.0",
-    "@gtkx/mcp": "1.6.0",
-    "@gtkx/utils": "1.6.0",
-    "create-gtkx": "1.6.0",
-    "@gtkx/vitest": "1.6.0"
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
+    "@gtkx/testing": "2.0.0-beta.10",
     "@types/babel__core": "^7.20.5",
+    "@types/hosted-git-info": "^3.0.5",
     "@types/react-refresh": "^0.14.7",
-    "vitest": "^4.1.11",
-    "@gtkx/animated": "1.6.0",
-    "@gtkx/testing": "1.6.0"
+    "vitest": "^5.0.0"
   },
   "peerDependencies": {
     "react": "^19"

package/src/builder.ts

@@ -1,6 +1,7 @@
-import { join, posix } from "node:path";
+import { loadConfig } from "@gtkx/config";
+import { join, posix, relative, resolve } from "node:path";
 import { type InlineConfig, mergeConfig, build as viteBuild } from "vite";
-import { createBuildManifestCollector } from "./internal/build-manifest.js";
+import { configDigest, createBuildManifestCollector } from "./internal/build-manifest.js";
 import { gtkxBuildManifest } from "./vite-plugins/build-manifest.js";
 import { BUNDLE_FILENAME, ESM_EXTENSION } from "./vite-plugins/esm-extension.js";
 import { gtkxVitePlugins } from "./vite-plugins/index.js";
@@ -10,6 +11,7 @@ import { gtkxWorker } from "./vite-plugins/worker.js";
 
 type BuildOptions = {
     entry: string;
+    configFile?: string | undefined;
     shouldPreserveI18nMetadata?: boolean | undefined;
     vite?: InlineConfig | undefined;
 };
@@ -27,23 +29,33 @@ const buildDefaults: InlineConfig = {
         minify: true,
         cssMinify: false,
     },
-    define: {
-        "process.env.NODE_ENV": JSON.stringify(BUILD_MODE),
-    },
 };
 
-const build = async (options: BuildOptions): Promise<string> => {
-    const { entry, shouldPreserveI18nMetadata = true, vite: viteConfig } = options;
-    const root = viteConfig?.root ?? process.cwd();
-    const assetsDir = viteConfig?.build?.assetsDir ?? DEFAULT_ASSETS_DIR;
+const forcedConfig = async (options: BuildOptions, root: string, assetsDir: string): Promise<InlineConfig> => {
+    const { entry, shouldPreserveI18nMetadata = true } = options;
     const buildManifest = createBuildManifestCollector();
+    const loadedConfig = await loadConfig(root, { mode: BUILD_MODE, configFile: options.configFile });
+    const buildConfigIdentity = {
+        configFile: posix.normalize(relative(root, loadedConfig.configFile).replaceAll("\\", "/")),
+        configDigest: configDigest(loadedConfig.config),
+    };
 
-    const forced: InlineConfig = {
+    return {
+        mode: BUILD_MODE,
+        define: {
+            "process.env.NODE_ENV": JSON.stringify(BUILD_MODE),
+        },
         plugins: [
-            ...gtkxVitePlugins(BUILD_MODE, entry, buildManifest, shouldPreserveI18nMetadata),
+            ...gtkxVitePlugins({
+                mode: BUILD_MODE,
+                entryPath: entry,
+                buildManifest,
+                shouldPreserveI18nMetadata,
+                configFile: options.configFile,
+            }),
             gtkxWorker(),
             gtkxNative(root),
-            gtkxBuildManifest(root, buildManifest),
+            gtkxBuildManifest(root, buildManifest, buildConfigIdentity),
             gtkxSelfContained(),
         ],
         build: {
@@ -58,11 +70,32 @@ const build = async (options: BuildOptions): Promise<string> => {
             },
         },
     };
+};
 
+const buildProduction = async (options: BuildOptions): Promise<string> => {
+    const viteConfig = options.vite;
+    const root = resolve(viteConfig?.root ?? process.cwd());
+    const assetsDir = viteConfig?.build?.assetsDir ?? DEFAULT_ASSETS_DIR;
+    const forced = await forcedConfig(options, root, assetsDir);
     const merged: InlineConfig = mergeConfig(mergeConfig(buildDefaults, viteConfig ?? {}), forced);
     await viteBuild({ ...merged, ssr: { ...merged.ssr, noExternal: true } });
 
     return join(merged.build?.outDir ?? DEFAULT_OUT_DIR, ENTRY_FILE_NAMES);
 };
 
+const build = async (options: BuildOptions): Promise<string> => {
+    const callerNodeEnv = process.env.NODE_ENV;
+    process.env.NODE_ENV = BUILD_MODE;
+
+    try {
+        return await buildProduction(options);
+    } finally {
+        if (callerNodeEnv === undefined) {
+            delete process.env.NODE_ENV;
+        } else {
+            process.env.NODE_ENV = callerNodeEnv;
+        }
+    }
+};
+
 export { build };

package/src/cli.ts

@@ -1,7 +1,15 @@
+import { assertSupportedNodeVersion } from "@gtkx/config/internal";
 import { defineCommand, runMain } from "citty";
 import packageManifest from "../package.json" with { type: "json" };
 import { splitApplicationArgs } from "./internal/application-args.js";
-import { withErrorBoundary } from "./internal/errors.js";
+import { printError, withErrorBoundary } from "./internal/errors.js";
+import "./internal/parent-process.js";
+
+try {
+    assertSupportedNodeVersion();
+} catch (error) {
+    printError(error);
+}
 
 const version = packageManifest.version;
 const { cliArgs } = splitApplicationArgs(process.argv.slice(2));
@@ -10,7 +18,7 @@ const main = defineCommand({
     meta: {
         name: "gtkx",
         version,
-        description: "CLI for GTKX: create and develop GTK4 React applications",
+        description: "CLI for GTKX: create and develop Adwaita-first GNOME applications",
     },
     subCommands: {
         dev: async () => {
@@ -48,6 +56,11 @@ const main = defineCommand({
 
             return withErrorBoundary(scaffoldCommand);
         },
+        cleanup: async () => {
+            const { cleanup } = await import("./commands/cleanup.js");
+
+            return withErrorBoundary(cleanup);
+        },
     },
 });
 

package/src/codegen/config-dependencies.ts

@@ -0,0 +1,470 @@
+import { parseSync, traverse, types } from "@babel/core";
+import { parseJSON, parseJSON5, parseJSONC, parseTOML, parseYAML } from "confbox";
+import { createJiti, type Jiti } from "jiti";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const MODULE_EXTENSIONS: ReadonlySet<string> = new Set([
+    ".cjs",
+    ".cts",
+    ".js",
+    ".mjs",
+    ".mts",
+    ".ts",
+]);
+const RESOLVABLE_EXTENSIONS = [
+    ".js",
+    ".ts",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts",
+    ".json",
+    ".jsonc",
+    ".json5",
+    ".yaml",
+    ".yml",
+    ".toml",
+];
+const JAVASCRIPT_FALLBACKS: Readonly<Record<string, string[]>> = {
+    ".cjs": [".cts"],
+    ".js": [".ts"],
+    ".jsx": [".tsx"],
+    ".mjs": [".mts"],
+};
+const DATA_PARSERS: Readonly<Record<string, (source: string) => unknown>> = {
+    ".json": parseJSON,
+    ".json5": parseJSON5,
+    ".jsonc": parseJSONC,
+    ".toml": parseTOML,
+    ".yaml": parseYAML,
+    ".yml": parseYAML,
+};
+
+type PackageImports = { file: string; imports: Record<string, unknown>; root: string };
+type ModuleSources = { all: string[]; extended: string[] };
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+    typeof value === "object" && value !== null && !Array.isArray(value);
+
+const parserPlugins = (path: string): ("decorators" | "jsx" | "typescript")[] => {
+    const extension = extname(path).toLowerCase();
+
+    return [
+        "decorators",
+        ...([".cts", ".mts", ".ts"].includes(extension) ? ["typescript" as const] : []),
+    ];
+};
+
+function expressionSources(value: types.Expression): string[] {
+    if (types.isStringLiteral(value)) {
+        return [value.value];
+    }
+
+    if (types.isArrayExpression(value)) {
+        return value.elements.flatMap((element) =>
+            types.isExpression(element) ? expressionSources(element) : []);
+    }
+
+    return types.isObjectExpression(value)
+        ? value.properties.flatMap((property) => sourcePropertySources(property))
+        : [];
+}
+
+const isNamedProperty = (property: types.ObjectProperty, name: string): boolean =>
+    (types.isIdentifier(property.key) && property.key.name === name) ||
+    (types.isStringLiteral(property.key) && property.key.value === name);
+
+function sourcePropertySources(
+    property: types.ObjectMethod | types.ObjectProperty | types.SpreadElement,
+): string[] {
+    return types.isObjectProperty(property) &&
+        isNamedProperty(property, "source") &&
+        types.isExpression(property.value)
+        ? expressionSources(property.value)
+        : [];
+}
+
+const extendsSources = (value: types.Expression): string[] => expressionSources(value);
+
+const isExtendsProperty = (property: types.ObjectProperty): boolean =>
+    isNamedProperty(property, "extends");
+
+type ParsedModule = NonNullable<ReturnType<typeof parseSync>>;
+
+const parseModule = (path: string): ParsedModule | undefined => {
+    try {
+        return parseSync(readFileSync(path, "utf8"), {
+            ast: true,
+            babelrc: false,
+            configFile: false,
+            filename: path,
+            parserOpts: { allowReturnOutsideFunction: true, plugins: parserPlugins(path) },
+            sourceType: "unambiguous",
+        }) ?? undefined;
+    } catch {
+        return undefined;
+    }
+};
+
+const addSource = (sources: Set<string>, source: types.StringLiteral | null | undefined): void => {
+    if (source !== null && source !== undefined) {
+        sources.add(source.value);
+    }
+};
+
+const requireSource = (call: types.CallExpression): types.StringLiteral | undefined =>
+    types.isIdentifier(call.callee, { name: "require" }) && types.isStringLiteral(call.arguments[0])
+        ? call.arguments[0]
+        : undefined;
+
+const importEqualsSource = (declaration: types.TSImportEqualsDeclaration): types.StringLiteral | undefined => {
+    const { moduleReference } = declaration;
+
+    return types.isTSExternalModuleReference(moduleReference) ? moduleReference.expression : undefined;
+};
+
+const propertySources = (property: types.ObjectProperty): string[] =>
+    isExtendsProperty(property) && types.isExpression(property.value)
+        ? extendsSources(property.value)
+        : [];
+
+const collectModuleSources = (ast: ParsedModule): ModuleSources => {
+    const sources: Set<string> = new Set();
+    const extended: Set<string> = new Set();
+
+    traverse(ast, {
+        CallExpression: (nodePath) => {
+            addSource(sources, requireSource(nodePath.node));
+        },
+        ExportAllDeclaration: (nodePath) => {
+            addSource(sources, nodePath.node.source);
+        },
+        ExportNamedDeclaration: (nodePath) => {
+            addSource(sources, nodePath.node.source);
+        },
+        ImportDeclaration: (nodePath) => {
+            addSource(sources, nodePath.node.source);
+        },
+        ImportExpression: (nodePath) => {
+            const { source } = nodePath.node;
+            addSource(sources, types.isStringLiteral(source) ? source : undefined);
+        },
+        ObjectProperty: (nodePath) => {
+            for (const source of propertySources(nodePath.node)) {
+                sources.add(source);
+                extended.add(source);
+            }
+        },
+        TSImportEqualsDeclaration: (nodePath) => {
+            addSource(sources, importEqualsSource(nodePath.node));
+        },
+    });
+
+    return { all: [...sources], extended: [...extended] };
+};
+
+const moduleSources = (path: string): ModuleSources => {
+    const ast = parseModule(path);
+
+    return ast === undefined ? { all: [], extended: [] } : collectModuleSources(ast);
+};
+
+function parsedExtendsSources(value: unknown): string[] {
+    if (typeof value === "string") {
+        return [value];
+    }
+
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => parsedExtendsSources(item));
+    }
+
+    return objectExtendsSources(value);
+}
+
+const objectExtendsSources = (value: unknown): string[] => {
+    if (typeof value !== "object" || value === null) {
+        return [];
+    }
+
+    return "source" in value ? parsedExtendsSources(value.source) : [];
+};
+
+const configExtendsSources = (value: unknown): string[] => {
+    if (typeof value !== "object" || value === null) {
+        return [];
+    }
+
+    return "extends" in value ? parsedExtendsSources(value.extends) : [];
+};
+
+const dataSources = (path: string): string[] => {
+    const parser = DATA_PARSERS[extname(path).toLowerCase()];
+
+    if (parser === undefined) {
+        return [];
+    }
+
+    try {
+        return configExtendsSources(parser(readFileSync(path, "utf8")));
+    } catch {
+        return [];
+    }
+};
+
+const extensionCandidates = (path: string): string[] => {
+    const extension = extname(path).toLowerCase();
+
+    if (extension.length === 0) {
+        return RESOLVABLE_EXTENSIONS.map((candidate) => `${path}${candidate}`);
+    }
+
+    const stem = path.slice(0, -extension.length);
+
+    return (JAVASCRIPT_FALLBACKS[extension] ?? []).map((candidate) => `${stem}${candidate}`);
+};
+
+const targetCandidates = (target: string, configName: string): string[] => {
+    const extension = extname(target);
+
+    if (extension.length > 0) {
+        return [target, ...extensionCandidates(target)];
+    }
+
+    return [
+        target,
+        ...extensionCandidates(target),
+        join(target, configName),
+        ...RESOLVABLE_EXTENSIONS.map((candidate) => join(target, `index${candidate}`)),
+    ];
+};
+
+const localSourceTarget = (source: string, importer: string): string | undefined => {
+    const clean = source.split(/[?#]/u, 1)[0] ?? "";
+
+    if (clean.startsWith("file:")) {
+        return fileURLToPath(clean);
+    }
+
+    if (!isAbsolute(clean) && !clean.startsWith(".")) {
+        return undefined;
+    }
+
+    return resolve(dirname(importer), clean);
+};
+
+const unresolvedCandidates = (source: string, importer: string, configName: string): string[] => {
+    const target = localSourceTarget(source, importer);
+
+    if (target === undefined) {
+        return [];
+    }
+
+    return targetCandidates(target, configName);
+};
+
+const nearestPackageFile = (importer: string): string | undefined => {
+    let directory = dirname(importer);
+    let previous = "";
+
+    while (directory !== previous) {
+        const candidate = join(directory, "package.json");
+
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+
+        previous = directory;
+        directory = dirname(directory);
+    }
+
+    return undefined;
+};
+
+const readPackageImports = (importer: string): PackageImports | undefined => {
+    const file = nearestPackageFile(importer);
+
+    if (file === undefined) {
+        return undefined;
+    }
+
+    try {
+        const manifest = parseJSON(readFileSync(file, "utf8"));
+
+        return isRecord(manifest) && isRecord(manifest.imports)
+            ? { file, imports: manifest.imports, root: dirname(file) }
+            : undefined;
+    } catch {
+        return undefined;
+    }
+};
+
+function stringTargets(value: unknown): string[] {
+    if (typeof value === "string") {
+        return [value];
+    }
+
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => stringTargets(item));
+    }
+
+    return isRecord(value)
+        ? Object.values(value).flatMap((item) => stringTargets(item))
+        : [];
+}
+
+const importPatternMatch = (pattern: string, source: string): string | undefined => {
+    if (pattern === source) {
+        return "";
+    }
+
+    const wildcard = pattern.indexOf("*");
+
+    if (wildcard === -1) {
+        return undefined;
+    }
+
+    const prefix = pattern.slice(0, wildcard);
+    const suffix = pattern.slice(wildcard + 1);
+
+    return source.startsWith(prefix) && source.endsWith(suffix)
+        ? source.slice(prefix.length, source.length - suffix.length)
+        : undefined;
+};
+
+const packageImportTargets = (source: string, imports: Record<string, unknown>): string[] =>
+    Object.entries(imports).flatMap(([pattern, value]) => {
+        const match = importPatternMatch(pattern, source);
+
+        return match === undefined
+            ? []
+            : stringTargets(value).map((target) => target.split("*").join(match));
+    });
+
+const packageImportDependencies = (source: string, importer: string, configName: string): string[] => {
+    if (!source.startsWith("#")) {
+        return [];
+    }
+
+    const packageImports = readPackageImports(importer);
+
+    if (packageImports === undefined) {
+        return [];
+    }
+
+    const targets = packageImportTargets(source, packageImports.imports)
+        .filter((target) => target.startsWith("."))
+        .flatMap((target) => targetCandidates(resolve(packageImports.root, target), configName));
+
+    return [packageImports.file, ...targets];
+};
+
+const normalizedResolvedPath = (path: string): string =>
+    path.startsWith("file:") ? fileURLToPath(path) : path;
+
+const resolvedSourcePath = (source: string, importer: string, jiti: Jiti): string | undefined => {
+    try {
+        const path = jiti.esmResolve(source, {
+            parentURL: pathToFileURL(importer).href,
+            try: true,
+        });
+
+        return path === undefined ? undefined : normalizedResolvedPath(path);
+    } catch {
+        return undefined;
+    }
+};
+
+const sourceDependencies = (
+    source: string,
+    importer: string,
+    configName: string,
+    jiti: Jiti,
+): string[] => {
+    const dependency = resolvedSourcePath(source, importer, jiti);
+    const packageDependencies = packageImportDependencies(source, importer, configName);
+
+    return dependency === undefined
+        ? [...unresolvedCandidates(source, importer, configName), ...packageDependencies]
+        : [dependency, ...packageDependencies];
+};
+
+const configLayerDirectory = (path: string, configName: string, configRoot: string): string => {
+    const segments = configName.split(/[\\/]/u).filter((segment) => segment.length > 0);
+    let directory = resolve(path);
+    let remaining = segments.length;
+
+    while (remaining > 0) {
+        directory = dirname(directory);
+        remaining -= 1;
+    }
+
+    return resolve(directory, ...segments) === resolve(path) ? directory : resolve(configRoot);
+};
+
+const c12SourceDependencies = (
+    source: string,
+    importer: string,
+    configName: string,
+    configRoot: string,
+): string[] => {
+    const clean = source.split(/[?#]/u, 1)[0] ?? "";
+
+    if (clean === "." || (!isAbsolute(clean) && !clean.startsWith("."))) {
+        return [];
+    }
+
+    const cwd = configLayerDirectory(importer, configName, configRoot);
+    const extension = extname(clean);
+    const target = (extension.length === 0 || extension === basename(clean))
+        ? resolve(cwd, clean, configName)
+        : resolve(cwd, clean);
+
+    return targetCandidates(target, configName);
+};
+
+const directDependencies = (path: string, configName: string, configRoot: string): string[] => {
+    const module = MODULE_EXTENSIONS.has(extname(path).toLowerCase()) ? moduleSources(path) : undefined;
+    const sources = module?.all ?? dataSources(path);
+    const extended = module?.extended ?? sources;
+    const jiti = createJiti(path, {
+        extensions: RESOLVABLE_EXTENSIONS,
+        fsCache: false,
+        moduleCache: false,
+    });
+
+    return [
+        ...sources.flatMap((source) => sourceDependencies(source, path, configName, jiti)),
+        ...extended.flatMap((source) => c12SourceDependencies(source, path, configName, configRoot)),
+    ]
+        .filter((dependency) => !dependency.includes(`${sep}node_modules${sep}`));
+};
+
+const resolveConfigDependencies = (
+    configFile: string,
+    configName = basename(configFile),
+    configRoot = dirname(configFile),
+): string[] => {
+    const dependencies: Set<string> = new Set();
+    const pending = [resolve(configFile)];
+
+    while (pending.length > 0) {
+        const path = pending.pop();
+
+        if (path === undefined) {
+            break;
+        }
+
+        if (dependencies.has(path)) {
+            continue;
+        }
+
+        dependencies.add(path);
+        pending.push(...directDependencies(path, configName, configRoot));
+    }
+
+    return [...dependencies];
+};
+
+export { resolveConfigDependencies };