@gtkx/cli 1.6.0 → 2.0.0-beta.10

package/src/codegen/freshness.ts

@@ -1,53 +1,106 @@
 import type { Config } from "@gtkx/config";
 import { resolveGirPath, resolveLibraries } from "@gtkx/codegen";
-import { resolveFuture } from "@gtkx/config/internal";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+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";
 
+type ExportTarget = string | { [condition: string]: ExportTarget };
+type StoreExports = Record<string, ExportTarget>;
+
 type CodegenInputs = {
     girPath: string[];
     libraries: string[];
     store: CodegenStore;
 };
 
-const REACT_GENERATED_MODULES: string[] = ["index.js", "metadata.js", join("gtk", "gtk.js")];
+const PACKAGE_EXPORT = "./package.json";
+const JSX_REQUIRED_EXPORTS = [PACKAGE_EXPORT, "./metadata", "./gtk", "./adw"];
 
 const resolveCodegenInputs = (cwd: string, config: Config): CodegenInputs => {
     const girPath = resolveGirPath(config.girPath);
-    const libraries = resolveLibraries(config.libraries, girPath, resolveFuture(config.future).isAdwaitaDefault);
+    const libraries = resolveLibraries(config.libraries);
     const store = resolveCodegenStore(cwd);
 
     return { girPath, libraries, store };
 };
 
-const namespaceBarrelPath = (giStoreDir: string, library: string): string => {
+const namespaceExport = (library: string): string => {
     const separator = library.indexOf("-");
     const namespace = (separator === -1 ? library : library.slice(0, separator)).toLowerCase();
 
-    return join(giStoreDir, namespace, "index.js");
+    return `./${namespace}`;
 };
 
-const hasManifest = (storeDir: string): boolean => existsSync(join(storeDir, "package.json"));
+const targetFiles = (target: ExportTarget): string[] =>
+    typeof target === "string" ? [target] : Object.values(target).flatMap((nested) => targetFiles(nested));
 
-const isGiStoreStale = (store: CodegenStore, libraries: string[]): boolean => {
-    if (!hasManifest(store.giStoreDir)) {
-        return true;
+const indexExtension = (target: string): string | undefined => {
+    if (target.endsWith("/index.d.ts")) {
+        return ".d.ts";
     }
 
-    return libraries.some((library) => !existsSync(namespaceBarrelPath(store.giStoreDir, library)));
+    return target.endsWith("/index.js") ? ".js" : undefined;
 };
 
-const isReactStoreStale = (store: CodegenStore): boolean => {
-    if (store.react === null) {
+const implementationFile = (target: string): string | undefined => {
+    const extension = indexExtension(target);
+
+    if (extension === undefined) {
+        return undefined;
+    }
+
+    const directory = dirname(target);
+
+    return join(directory, `${basename(directory)}${extension}`);
+};
+
+const generatedFiles = (exports: StoreExports): string[] =>
+    Object.values(exports)
+        .flatMap((target) => targetFiles(target))
+        .flatMap((target) => {
+            const implementation = implementationFile(target);
+
+            return implementation === undefined ? [target] : [target, implementation];
+        });
+
+const hasStoreExports = (storeDir: string, required: string[], forbidden: string[] = []): boolean => {
+    const manifestPath = join(storeDir, "package.json");
+
+    if (!existsSync(manifestPath)) {
         return false;
     }
 
-    if (!hasManifest(store.jsxStoreDir)) {
-        return true;
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as {
+        exports?: StoreExports;
+    };
+    const exports = manifest.exports;
+
+    if (exports === undefined || required.some((key) => !Object.hasOwn(exports, key)) ||
+        forbidden.some((key) => Object.hasOwn(exports, key))) {
+        return false;
+    }
+
+    const files = generatedFiles(exports);
+
+    return files.length > 0 && files.every((file) => existsSync(join(storeDir, file)));
+};
+
+const isGiStoreStale = (store: CodegenStore, libraries: string[]): boolean => {
+    const required = [
+        PACKAGE_EXPORT,
+        ...resolveBoundLibraries(libraries).map((library) => namespaceExport(library)),
+    ];
+
+    return !hasStoreExports(store.giStoreDir, required);
+};
+
+const isReactStoreStale = (store: CodegenStore): boolean => {
+    if (store.react === null) {
+        return false;
     }
 
-    return REACT_GENERATED_MODULES.some((module) => !existsSync(join(store.jsxStoreDir, module)));
+    return !hasStoreExports(store.jsxStoreDir, JSX_REQUIRED_EXPORTS, ["."]);
 };
 
 const isCodegenStale = (inputs: CodegenInputs): boolean => {

package/src/codegen/reference.ts

@@ -22,8 +22,6 @@ type ReferenceResult = {
 const REFERENCE_PATH = ".gtkx/reference";
 const SKIPPED: ReferenceResult = { isRegenerated: false, elements: 0, namespaces: 0 };
 
-const resolveReferenceDir = (root: string): string => join(root, ".gtkx", "reference");
-
 const writeReference = async (options: WriteReferenceOptions): Promise<ReferenceResult> => {
     const { root, config, girPath, libraries } = options;
 
@@ -36,17 +34,13 @@ const writeReference = async (options: WriteReferenceOptions): Promise<Reference
     const { isRegenerated, namespaces } = writeDocs({
         libraries,
         girPath,
-        outDir: resolveReferenceDir(root),
+        outDir: join(root, REFERENCE_PATH),
         basePath: REFERENCE_PATH,
         linkStyle: "file",
         props: builtin.props,
+        acceptedChildTypes: builtin.acceptedChildTypes,
         omittedProps: mergeOmittedProps(builtin.omittedProps, resolveOmittedProps(config.elements)),
         isForced: options.isForced === true,
-        isByteArrayTyped: config.future?.v2ByteArrays === true,
-        isValueUnwrapped: config.future?.v2ValueReturns === true,
-        isFinishTrimmed: config.future?.v2FinishResults === true,
-        isInoutInPlace: config.future?.v2InoutReturns === true,
-        isTreeShaken: config.future?.v2TreeShaking === true,
     });
 
     return {

package/src/codegen/report.ts

@@ -3,27 +3,11 @@ import { REFERENCE_PATH } from "./reference.js";
 
 const PREFIX = "codegen: ";
 
-const contextDetails = (result: RunCodegenResult): string[] => {
-    const details: string[] = [];
-
-    if (result.configFile) {
-        details.push(`config=${result.configFile}`);
-    }
-
-    if (result.libraries) {
-        details.push(`libraries=${result.libraries.join(", ")}`);
-    }
-
-    if (result.girPath) {
-        details.push(`girPath=${result.girPath.join(":")}`);
-    }
-
-    if (result.future && result.future.length > 0) {
-        details.push(`future=${result.future.join(", ")}`);
-    }
-
-    return details;
-};
+const contextDetails = (result: RunCodegenResult): string[] => [
+    `config=${result.configFile}`,
+    `libraries=${result.libraries.join(", ")}`,
+    `girPath=${result.girPath.join(":")}`,
+];
 
 const referenceDetails = (result: RunCodegenResult): string[] => {
     if (result.reference?.isRegenerated !== true) {

package/src/codegen/run-codegen.ts

@@ -1,31 +1,24 @@
 import { runCodegen as runCodegenCore } from "@gtkx/codegen";
-import {
-    getShadowingStorePaths,
-    LIBRARIES_WILDCARD,
-    redundantLibraries,
-    sweepProjectStaging,
-} from "@gtkx/codegen/internal";
+import { getShadowingStorePaths, sweepProjectStaging } from "@gtkx/codegen/internal";
 import { type Config, loadConfig } from "@gtkx/config";
 import {
+    configDependenciesFor,
     isAgentRulesEnabled,
-    type ResolvedFuture,
     resolveElementComponents,
     resolveElementProps,
-    resolveFuture,
     resolveLazyElements,
     resolveOmittedProps,
-    unknownFutureKeys,
 } from "@gtkx/config/internal";
-import { info, warn } from "@gtkx/utils";
+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 { emitI18nTypes } from "../i18n/types.js";
+import { clearI18nTypes, emitI18nTypes } from "../i18n/types.js";
 import { upsertAgentRules } from "../internal/agent-rules.js";
-import { resolveDataDir } from "../internal/data-dir.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";
@@ -33,6 +26,7 @@ import { type CodegenContext, type CodegenStore, resolveCodegenContext } from ".
 type RunCodegenOptions = {
     cwd?: string;
     mode?: string | undefined;
+    configFile?: string | undefined;
     isForced?: boolean;
     inputs?: CodegenInputs;
     resolved?: LoadedConfig;
@@ -48,12 +42,10 @@ type RunCodegenResult = {
     isRegenerated: boolean;
     namespaces: number;
     intrinsicElements: number;
-    notices: string[];
     duration: number;
-    girPath?: string[] | undefined;
-    configFile?: string | undefined;
-    libraries?: string[] | undefined;
-    future?: string[] | undefined;
+    girPath: string[];
+    configFile: string;
+    libraries: string[];
     reference?: ReferenceResult | undefined;
 };
 
@@ -62,7 +54,6 @@ type CodegenOptionsInput = {
     libraries: string[];
     girPath: string[];
     elements: Config["elements"];
-    future: ResolvedFuture;
 };
 
 type PreparedCodegen = CodegenInputs & { isForced: boolean };
@@ -70,17 +61,10 @@ type PreparedCodegen = CodegenInputs & { isForced: boolean };
 type EnsureGeneratedOptions = {
     shouldAnnounce?: boolean;
     mode?: string;
+    configFile?: string | undefined;
     shouldPreserveI18nMetadata?: boolean | undefined;
 };
 
-type RunOptionsInput = {
-    root: string;
-    mode: string | undefined;
-    inputs: CodegenInputs | null;
-    resolved: LoadedConfig;
-    shouldPreserveI18nMetadata: boolean | undefined;
-};
-
 const GIR_PATH_MISSING_MESSAGE =
     "No GIR search paths available. Install gobject-introspection " +
     "(Linux: `sudo dnf install gobject-introspection-devel` or `sudo apt install libgirepository1.0-dev`), " +
@@ -97,18 +81,14 @@ const removeShadowingStores = (cwd: string): void => {
     removeStores(getShadowingStorePaths(cwd));
 };
 
-const codegenOptions = ({ store, libraries, girPath, elements, future }: CodegenOptionsInput) => ({
+const codegenOptions = ({ store, libraries, girPath, elements }: CodegenOptionsInput) => ({
     libraries,
     girPath,
-    isByteArrayTyped: future.isByteArrayTyped,
-    isValueUnwrapped: future.isValueUnwrapped,
-    isFinishTrimmed: future.isFinishTrimmed,
-    isInoutInPlace: future.isInoutInPlace,
-    isTreeShaken: future.isTreeShaken,
     gi: {
         storeDir: store.giStoreDir,
         linkDir: store.giLinkDir,
         version: store.runtimeVersion,
+        owner: store.owner,
     },
     jsx:
         store.react === null
@@ -117,94 +97,24 @@ const codegenOptions = ({ store, libraries, girPath, elements, future }: Codegen
                     storeDir: store.jsxStoreDir,
                     linkDir: store.jsxLinkDir,
                     version: store.react.version,
+                    owner: store.owner,
                 },
-    reactSubexports: store.react?.subexports ?? [],
     userComponents: resolveElementComponents(elements),
     userProps: resolveElementProps(elements),
     userLazyElements: resolveLazyElements(elements),
     userOmittedProps: resolveOmittedProps(elements),
 });
 
-const enabledFutureFlags = (config: Config): string[] => {
-    const unknown: Set<string> = new Set(unknownFutureKeys(config.future));
-
-    return Object.entries(config.future ?? {})
-        .filter(([name, value]) => value === true && !unknown.has(name))
-        .map(([name]) => name);
-};
-
-const disabledCodegenResult = (configFile: string, notices: string[]): RunCodegenResult => ({
+const disabledCodegenResult = (configFile: string): RunCodegenResult => ({
     isRegenerated: false,
     namespaces: 0,
     intrinsicElements: 0,
-    notices,
     duration: 0,
     girPath: [],
     configFile,
     libraries: [],
 });
 
-const warnNotices = (notices: string[]): void => {
-    for (const notice of notices) {
-        warn(notice);
-    }
-};
-
-const unknownFutureNotice = (keys: string[]): string[] => {
-    if (keys.length === 0) {
-        return [];
-    }
-
-    return [
-        `gtkx.config.ts: \`future\` has no ${keys.join(", ")} flag, so the key is ignored. Check it against ` +
-        "the flags the configuration guide lists.",
-    ];
-};
-
-const redundantLibraryNotice = (entries: string[]): string[] => {
-    if (entries.length === 0) {
-        return [];
-    }
-
-    return [
-        `gtkx.config.ts: \`future.v2DefaultLibraries\` binds ${entries.join(", ")} on its own, so naming them ` +
-        "in `libraries` changes nothing. Drop them; naming them becomes a configuration error in GTKX 2.0.",
-    ];
-};
-
-const wildcardLibrariesNotice = (libraries: Config["libraries"]): string[] => {
-    if (libraries !== LIBRARIES_WILDCARD) {
-        return [];
-    }
-
-    return [
-        'gtkx.config.ts: `libraries: "*"` binds whatever the build host happens to have installed, so the ' +
-        "store changes with the machine. Instead, list the libraries the project needs; the wildcard is " +
-        "removed in GTKX 2.0.",
-    ];
-};
-
-const configNotices = (config: Config, future: ResolvedFuture): string[] => [
-    ...unknownFutureNotice(unknownFutureKeys(config.future)),
-    ...wildcardLibrariesNotice(config.libraries),
-    ...redundantLibraryNotice(redundantLibraries(config.libraries, future.isAdwaitaDefault)),
-];
-
-const regeneratedStorePaths = (store: CodegenStore): string[] => {
-    if (store.react === null) {
-        return [store.giStoreDir, store.giLinkDir];
-    }
-
-    return [store.giStoreDir, store.giLinkDir, store.jsxStoreDir, store.jsxLinkDir];
-};
-
-const clearGeneratedStores = (store: CodegenStore): void => {
-    removeStores(regeneratedStorePaths(store));
-};
-
-const resolveLoadedConfig = async (options: RunCodegenOptions, cwd: string): Promise<LoadedConfig> =>
-    options.resolved ?? (await loadConfig(cwd, { mode: options.mode }));
-
 const prepareCodegen = (options: RunCodegenOptions, cwd: string, config: Config): PreparedCodegen => {
     const { girPath, libraries, store } = options.inputs ?? resolveCodegenInputs(cwd, config);
 
@@ -219,55 +129,44 @@ const prepareCodegen = (options: RunCodegenOptions, cwd: string, config: Config)
 
 const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenResult> => {
     const cwd = options.cwd ?? process.cwd();
-    const { config, configFile } = await resolveLoadedConfig(options, cwd);
-    const future = resolveFuture(config.future);
-    const configured = configNotices(config, future);
-    warnNotices(configured);
+    const { config, configFile } = options.resolved ?? (await loadConfig(cwd, {
+        mode: options.mode,
+        configFile: options.configFile,
+    }));
     await syncI18n(cwd, config.applicationId, options.shouldPreserveI18nMetadata);
-    syncSchemaEnv(cwd, future.isResourceImported);
+    emitSchemaEnv(cwd);
 
     if (config.codegen === false) {
         removeShadowingStores(cwd);
 
-        return disabledCodegenResult(configFile, configured);
+        return disabledCodegenResult(configFile);
     }
 
     const { girPath, libraries, store, isForced } = prepareCodegen(options, cwd, config);
 
-    if (options.isForced) {
-        clearGeneratedStores(store);
-    }
-
     const result = await runCodegenCore({
-        ...codegenOptions({ store, libraries, girPath, elements: config.elements, future }),
+        ...codegenOptions({ store, libraries, girPath, elements: config.elements }),
         isForced,
     });
 
-    warnNotices(result.notices);
-    const notices = [...configured, ...result.notices];
     const reference = await writeReference({ root: cwd, config, girPath, libraries, isForced });
-    syncAgentRules(cwd, config);
+
+    if (isAgentRulesEnabled(config)) {
+        upsertAgentRules(cwd);
+    }
 
     return {
         isRegenerated: result.isRegenerated,
         namespaces: result.namespaces,
         intrinsicElements: result.intrinsicElements,
-        notices,
         duration: result.duration,
         girPath,
         configFile,
         libraries,
-        future: enabledFutureFlags(config),
         reference,
     };
 };
 
-const syncAgentRules = (root: string, config: Config): void => {
-    if (isAgentRulesEnabled(config)) {
-        upsertAgentRules(root);
-    }
-};
-
 const syncI18n = async (
     root: string,
     applicationId: string,
@@ -276,21 +175,21 @@ const syncI18n = async (
     const project = resolveCatalogProject(root, applicationId);
 
     if (project === null) {
-        emitI18nTypes(root, [], false);
+        clearI18nTypes(root);
 
         return;
     }
 
     const srcDir = join(root, "src");
     const sourceFiles = discoverSourceFiles(existsSync(srcDir) ? srcDir : root);
-    const catalog = await extractSourceCatalog(project, sourceFiles, shouldPreserveMetadataMessages);
+    await extractSourceCatalog(project, sourceFiles, shouldPreserveMetadataMessages);
     synchronizeCatalogs(project);
-    emitI18nTypes(root, catalog.messages);
+    await emitI18nTypes(root);
 };
 
-const isCodegenDisabled = async (cwd: string, mode?: string): Promise<boolean> => {
+const isCodegenDisabled = async (cwd: string, mode?: string, configFile?: string): Promise<boolean> => {
     try {
-        const { config } = await loadConfig(cwd, { mode });
+        const { config } = await loadConfig(cwd, { mode, configFile });
 
         return config.codegen === false;
     } catch {
@@ -298,11 +197,6 @@ const isCodegenDisabled = async (cwd: string, mode?: string): Promise<boolean> =
     }
 };
 
-const syncSchemaEnv = (cwd: string, isV2ResourceImports = false): void => {
-    const dataDir = isV2ResourceImports ? null : resolveDataDir(cwd);
-    emitSchemaEnv(cwd, dataDir, isV2ResourceImports);
-};
-
 const resolveInputsOrNull = (cwd: string, config: Config): CodegenInputs | null => {
     try {
         return resolveCodegenInputs(cwd, config);
@@ -321,20 +215,6 @@ const maybeAnnounceStale = (shouldAnnounce: boolean | undefined, inputs: Codegen
     }
 };
 
-const getRunOptions = ({
-    root,
-    mode,
-    inputs,
-    resolved,
-    shouldPreserveI18nMetadata,
-}: RunOptionsInput): RunCodegenOptions => {
-    if (inputs === null) {
-        return { cwd: root, mode, resolved, shouldPreserveI18nMetadata };
-    }
-
-    return { cwd: root, mode, inputs, resolved, shouldPreserveI18nMetadata };
-};
-
 const isPreflightSkipped = (options: EnsureGeneratedOptions): boolean =>
     options.shouldAnnounce === true && process.env.GTKX_DISABLE_PREFLIGHT === "1";
 
@@ -355,13 +235,13 @@ const generate = async (context: CodegenContext, options: EnsureGeneratedOptions
     maybeAnnounceStale(options.shouldAnnounce, inputs);
     const resolved = { config: context.config, configFile: context.configFile };
 
-    const result = await runCodegen(getRunOptions({
-        root: context.root,
+    const result = await runCodegen({
+        cwd: context.root,
         mode: options.mode,
-        inputs,
         resolved,
         shouldPreserveI18nMetadata: options.shouldPreserveI18nMetadata,
-    }));
+        ...(inputs !== null && { inputs }),
+    });
 
     return result.isRegenerated;
 };
@@ -374,18 +254,51 @@ const ensureGeneratedIn = async (
 
 /* eslint-disable-next-line unicorn/consistent-boolean-name -- the boolean reports whether codegen ran */
 const ensureGenerated = async (cwd: string, options: EnsureGeneratedOptions = {}): Promise<boolean> =>
-    isPreflightSkipped(options) ? false : generate(await resolveCodegenContext(cwd, options.mode), options);
+    isPreflightSkipped(options)
+        ? false
+        : generate(await resolveCodegenContext(cwd, options.mode, options.configFile), options);
 
 const resolveConfigWatch = async (
     cwd: string,
     mode?: string,
-): Promise<{ paths: string[]; regenerate: () => Promise<void> }> => {
-    const { configFile, root } = await loadConfig(cwd, { mode });
+    configFile?: string,
+    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(root, configFile)],
+        paths: resolvePaths(),
+        resolvePaths,
         regenerate: async () => {
-            await runCodegen({ cwd: root, mode });
+            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();
         },
     };
 };