@gtkx/cli 2.0.0-beta.1 → 2.0.0-beta.10

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 };

package/src/codegen/freshness.ts

@@ -1,5 +1,6 @@
 import type { Config } from "@gtkx/config";
 import { resolveGirPath, resolveLibraries } from "@gtkx/codegen";
+import { resolveBoundLibraries } from "@gtkx/codegen/internal";
 import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { type CodegenStore, resolveCodegenStore } from "./store-resolver.js";
@@ -86,7 +87,10 @@ const hasStoreExports = (storeDir: string, required: string[], forbidden: string
 };
 
 const isGiStoreStale = (store: CodegenStore, libraries: string[]): boolean => {
-    const required = [PACKAGE_EXPORT, ...libraries.map((library) => namespaceExport(library))];
+    const required = [
+        PACKAGE_EXPORT,
+        ...resolveBoundLibraries(libraries).map((library) => namespaceExport(library)),
+    ];
 
     return !hasStoreExports(store.giStoreDir, required);
 };

package/src/codegen/reference.ts

@@ -38,6 +38,7 @@ const writeReference = async (options: WriteReferenceOptions): Promise<Reference
         basePath: REFERENCE_PATH,
         linkStyle: "file",
         props: builtin.props,
+        acceptedChildTypes: builtin.acceptedChildTypes,
         omittedProps: mergeOmittedProps(builtin.omittedProps, resolveOmittedProps(config.elements)),
         isForced: options.isForced === true,
     });