@gtkx/cli 2.0.0-beta.3 → 2.0.0-beta.4

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/run-codegen.ts

@@ -2,6 +2,7 @@ import { runCodegen as runCodegenCore } from "@gtkx/codegen";
 import { getShadowingStorePaths, sweepProjectStaging } from "@gtkx/codegen/internal";
 import { type Config, loadConfig } from "@gtkx/config";
 import {
+    configDependenciesFor,
     isAgentRulesEnabled,
     resolveElementComponents,
     resolveElementProps,
@@ -10,13 +11,14 @@ import {
 } from "@gtkx/config/internal";
 import { info } from "@gtkx/utils";
 import { existsSync, rmSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { join, relative, resolve } from "node:path";
 import { resolveCatalogProject, synchronizeCatalogs } from "../i18n/catalogs.js";
 import { extractSourceCatalog } from "../i18n/source-messages.js";
 import { clearI18nTypes, emitI18nTypes } from "../i18n/types.js";
 import { upsertAgentRules } from "../internal/agent-rules.js";
 import { discoverSourceFiles } from "../internal/source-imports.js";
 import { emitSchemaEnv } from "../settings/schema.js";
+import { resolveConfigDependencies } from "./config-dependencies.js";
 import { type CodegenInputs, isCodegenStale, resolveCodegenInputs } from "./freshness.js";
 import { type ReferenceResult, writeReference } from "./reference.js";
 import { type CodegenContext, type CodegenStore, resolveCodegenContext } from "./store-resolver.js";
@@ -260,13 +262,43 @@ const resolveConfigWatch = async (
     cwd: string,
     mode?: string,
     configFile?: string,
-): Promise<{ paths: string[]; regenerate: () => Promise<void> }> => {
-    const loaded = await loadConfig(cwd, { mode, configFile });
+    initialDependencies: string[] = [],
+): Promise<{ paths: string[]; resolvePaths: () => string[]; regenerate: () => Promise<string[]> }> => {
+    let selectedConfigFile: string;
+
+    if (configFile === undefined) {
+        const loaded = await loadConfig(cwd, { mode });
+        selectedConfigFile = loaded.configFile;
+    } else {
+        selectedConfigFile = resolve(cwd, configFile);
+    }
+
+    let knownDependencies = initialDependencies;
+    const selectedConfigName = relative(cwd, selectedConfigFile);
+    const resolvePaths = (): string[] => [
+        ...new Set(
+            [selectedConfigFile, ...knownDependencies]
+                .flatMap((path) => resolveConfigDependencies(path, selectedConfigName, cwd)),
+        ),
+    ];
 
     return {
-        paths: [resolve(loaded.root, loaded.configFile)],
+        paths: resolvePaths(),
+        resolvePaths,
         regenerate: async () => {
-            await runCodegen({ cwd: loaded.root, mode, configFile: loaded.configFile });
+            let loaded: Awaited<ReturnType<typeof loadConfig>>;
+
+            try {
+                loaded = await loadConfig(cwd, { mode, configFile: selectedConfigFile });
+            } catch (error) {
+                knownDependencies = [...new Set([...knownDependencies, ...configDependenciesFor(error)])];
+                throw error;
+            }
+
+            knownDependencies = configDependenciesFor(loaded);
+            await runCodegen({ cwd, mode, resolved: loaded });
+
+            return resolvePaths();
         },
     };
 };

package/src/codegen/store-resolver.ts

@@ -1,5 +1,6 @@
 import { resolveStore } from "@gtkx/codegen";
 import { type Config, loadConfig } from "@gtkx/config";
+import { configDependenciesFor } from "@gtkx/config/internal";
 import { existsSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
@@ -23,6 +24,7 @@ type CodegenContext = {
     root: string;
     config: Config;
     configFile: string;
+    configDependencies: string[];
 };
 
 const hasPackage = (require: NodeJS.Require, dir: string, packageName: string): boolean => {
@@ -64,9 +66,10 @@ const resolveCodegenStore = (dir: string): CodegenStore => {
 };
 
 const resolveCodegenContext = async (cwd: string, mode?: string, selectedConfig?: string): Promise<CodegenContext> => {
-    const { config, configFile } = await loadConfig(cwd, { mode, configFile: selectedConfig });
+    const loaded = await loadConfig(cwd, { mode, configFile: selectedConfig });
+    const { config, configFile } = loaded;
 
-    return { root: cwd, config, configFile };
+    return { root: cwd, config, configFile, configDependencies: configDependenciesFor(loaded) };
 };
 
 export { resolveCodegenStore, resolveCodegenContext, type CodegenContext, type CodegenStore };

package/src/commands/cleanup.ts

@@ -0,0 +1,36 @@
+import { info } from "@gtkx/utils";
+import { findStaleHeadlessDisplays, reapStaleHeadlessDisplays } from "@gtkx/vitest/headless";
+import { defineCommand } from "citty";
+import { cwdArg } from "../internal/entry-arg.js";
+
+const cleanup = defineCommand({
+    meta: {
+        name: "cleanup",
+        description: "Remove stale GTKX headless runtime directories",
+    },
+    args: {
+        "dry-run": {
+            type: "boolean",
+            description: "List stale headless runtime directories without removing them",
+        },
+        ...cwdArg,
+    },
+    run({ args }) {
+        const candidates = findStaleHeadlessDisplays();
+
+        for (const candidate of candidates) {
+            info(`cleanup: ${candidate.runtimeDir}`);
+        }
+
+        if (args["dry-run"] === true) {
+            info(`cleanup: found ${String(candidates.length)} stale headless runtime directories`);
+
+            return;
+        }
+
+        const removed = reapStaleHeadlessDisplays(candidates);
+        info(`cleanup: removed ${String(removed.length)} stale headless runtime directories`);
+    },
+});
+
+export { cleanup };

package/src/commands/dev.ts

@@ -1,4 +1,5 @@
 import { armParentDeath } from "@gtkx/native/internal";
+import { reapStaleHeadlessDisplays } from "@gtkx/vitest/headless";
 import { defineCommand } from "citty";
 import { resolveConfigWatch } from "../codegen/run-codegen.js";
 import { startHeadlessDevDisplay } from "../dev/headless.js";
@@ -28,6 +29,7 @@ const dev = defineCommand({
         },
     },
     async run({ args }) {
+        reapStaleHeadlessDisplays();
         const initialProcessGroupOwner = getInitialProcessGroupOwner();
 
         if (
@@ -44,8 +46,13 @@ const dev = defineCommand({
             throw new Error("--size requires --headless");
         }
 
-        const { cwd, entry: entryPath, configFile } = await prepareProject(args, DEV_MODE);
-        const watch: DevWatch | undefined = await resolveConfigWatch(cwd, DEV_MODE, configFile);
+        const { cwd, entry: entryPath, configFile, configDependencies } = await prepareProject(args, DEV_MODE);
+        const watch: DevWatch | undefined = await resolveConfigWatch(
+            cwd,
+            DEV_MODE,
+            configFile,
+            configDependencies,
+        );
         const { applicationArgs } = splitApplicationArgs(process.argv.slice(2));
         const stopHeadless = args.headless ? await startHeadlessDevDisplay(args.size) : undefined;
 

package/src/deploy/freedesktop/validate.ts

@@ -35,6 +35,7 @@ const REMEDY_FOR_RULE: Record<string, string> = {
     "metainfo-legacy-path": "this file is generated; report it as a gtkx bug",
     "summary-has-dot-suffix": "drop the trailing period from `deploy.summary`",
     "summary-too-long": "shorten `deploy.summary`",
+    "unknown-tag": "remove the unsupported `deploy.metainfoExtra` element or use a `<custom>` value",
     "url-homepage-missing": "set `deploy.homepage`, or `homepage` in package.json",
 };