@gtkx/codegen 0.21.0 → 1.0.0-rc.2

package/src/gir/qualified-name.ts

@@ -1,55 +0,0 @@
-import type { GirClass } from "./class.js";
-import type { GirRepository } from "./repository.js";
-
-/**
- * Splits a possibly cross-namespace GIR identifier (e.g. `"Gtk.Widget"`) into
- * its namespace and local name.
- *
- * Identifiers without a dot are resolved against `defaultNamespace`. This
- * mirrors the GIR convention where same-namespace references omit the
- * namespace prefix.
- *
- * @param qualified - The GIR identifier as it appears in `<type>` / `parent`
- * @param defaultNamespace - The namespace to assume when no prefix is present
- */
-export const splitQualifiedName = (
-    qualified: string,
-    defaultNamespace: string,
-): { readonly namespaceName: string; readonly typeName: string } => {
-    const dot = qualified.indexOf(".");
-    if (dot === -1) {
-        return { namespaceName: defaultNamespace, typeName: qualified };
-    }
-    return { namespaceName: qualified.slice(0, dot), typeName: qualified.slice(dot + 1) };
-};
-
-/**
- * A class or interface together with the namespace it was resolved through.
- */
-export type ResolvedQualifiedClass = {
-    readonly klass: GirClass;
-    readonly namespaceName: string;
-};
-
-/**
- * Resolves a possibly cross-namespace identifier to its `class` or `interface`
- * entry plus the namespace that declares it.
- *
- * Returns `undefined` when the identifier resolves to a different kind of GIR
- * entity (boxed, enum, …) or cannot be resolved at all.
- *
- * @param repository - The repository to query
- * @param qualified - The GIR identifier (e.g. `"Gtk.Widget"`)
- * @param defaultNamespace - Namespace to assume for unqualified identifiers
- */
-export const resolveQualifiedClass = (
-    repository: GirRepository,
-    qualified: string,
-    defaultNamespace: string,
-): ResolvedQualifiedClass | undefined => {
-    const { namespaceName, typeName } = splitQualifiedName(qualified, defaultNamespace);
-    const resolved = repository.resolveNamed(namespaceName, typeName);
-    if (resolved === undefined) return undefined;
-    if (resolved.kind !== "class" && resolved.kind !== "interface") return undefined;
-    return { klass: resolved.value, namespaceName: resolved.namespace.name };
-};

package/src/gir/qualify.ts

@@ -1,64 +0,0 @@
-import type { GirFunction } from "./function.js";
-import type { GirParameter } from "./parameter.js";
-import type { GirTypeRef } from "./type-ref.js";
-
-/**
- * Stamps a default namespace onto an unqualified `named` reference and
- * recurses into composite (`array`, `list`, `hashtable`) references.
- *
- * GIR omits the namespace when a reference points to a sibling in the same
- * file. When writers walk a class hierarchy across namespaces, the parent's
- * references must be qualified with the parent's namespace before they can be
- * resolved against the repository.
- *
- * Returns `undefined` for an `undefined` input so callers can pass through
- * void return types unchanged.
- *
- * @param ref - The reference to qualify, or `undefined`
- * @param defaultNamespace - The namespace to stamp on unqualified refs
- */
-export const qualifyTypeRef = (ref: GirTypeRef | undefined, defaultNamespace: string): GirTypeRef | undefined => {
-    if (ref === undefined) return undefined;
-    switch (ref.kind) {
-        case "named":
-            return { ...ref, namespaceName: ref.namespaceName ?? defaultNamespace };
-        case "array":
-            return { ...ref, element: qualifyTypeRef(ref.element, defaultNamespace) ?? ref.element };
-        case "list":
-            return { ...ref, element: qualifyTypeRef(ref.element, defaultNamespace) ?? ref.element };
-        case "hashtable":
-            return {
-                ...ref,
-                key: qualifyTypeRef(ref.key, defaultNamespace) ?? ref.key,
-                value: qualifyTypeRef(ref.value, defaultNamespace) ?? ref.value,
-            };
-        case "primitive":
-        case "callback":
-        case "varargs":
-            return ref;
-    }
-};
-
-const qualifyParameter = (parameter: GirParameter, defaultNamespace: string): GirParameter => ({
-    ...parameter,
-    type: qualifyTypeRef(parameter.type, defaultNamespace),
-});
-
-/**
- * Re-roots every type reference of a callable to `defaultNamespace`.
- *
- * Interface methods are flattened onto each implementing class, but their
- * GIR type references are unqualified relative to the interface's own
- * namespace. Stamping the interface namespace onto the instance parameter,
- * each regular parameter, and the return value lets the class writer resolve
- * and import those references as if the method had been authored on the class.
- *
- * @param fn - The callable whose references to qualify
- * @param defaultNamespace - The namespace the callable's references belong to
- */
-export const qualifyFunction = (fn: GirFunction, defaultNamespace: string): GirFunction => ({
-    ...fn,
-    instance: fn.instance === undefined ? undefined : qualifyParameter(fn.instance, defaultNamespace),
-    parameters: fn.parameters.map((parameter) => qualifyParameter(parameter, defaultNamespace)),
-    returnValue: { ...fn.returnValue, type: qualifyTypeRef(fn.returnValue.type, defaultNamespace) },
-});

package/src/gir/repository.ts

@@ -1,149 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import type { GirBoxed } from "./boxed.js";
-import type { GirCallback } from "./callback.js";
-import type { GirClass } from "./class.js";
-import type { GirEnum } from "./enum.js";
-import { type GirNamespace, namespaceFromRepository } from "./namespace.js";
-import { parseGirFile } from "./parse.js";
-import type { GirTypeRef } from "./type-ref.js";
-
-/**
- * Resolved entity that a {@link GirRepository.resolveNamed} call returns.
- *
- * Wraps the matching entity along with the namespace it lives in, so
- * writers can pull the namespace identifier or shared library name without
- * a second lookup.
- */
-export type ResolvedNamed =
-    | { readonly kind: "class"; readonly namespace: GirNamespace; readonly value: GirClass }
-    | { readonly kind: "interface"; readonly namespace: GirNamespace; readonly value: GirClass }
-    | { readonly kind: "boxed"; readonly namespace: GirNamespace; readonly value: GirBoxed }
-    | { readonly kind: "enum"; readonly namespace: GirNamespace; readonly value: GirEnum }
-    | { readonly kind: "callback"; readonly namespace: GirNamespace; readonly value: GirCallback }
-    | {
-          readonly kind: "alias";
-          readonly namespace: GirNamespace;
-          readonly target: string | undefined;
-          readonly targetRef: GirTypeRef | undefined;
-      };
-
-/**
- * In-memory database of every loaded GIR namespace, indexed by name.
- *
- * Construct via {@link loadGirRepository}; the public API after that is the
- * `namespaces` map and {@link resolveNamed} for cross-namespace lookups.
- */
-export class GirRepository {
-    /** Namespaces keyed by their unqualified name (e.g. `"Gtk"`, `"GLib"`). */
-    public readonly namespaces: ReadonlyMap<string, GirNamespace>;
-    /** Absolute paths of every `.gir` file loaded, for staleness fingerprinting. */
-    public readonly girFiles: readonly string[];
-    private readonly entityIndex: Map<string, ResolvedNamed>;
-
-    /**
-     * Constructs a repository from the supplied namespace map.
-     *
-     * Callers should prefer {@link loadGirRepository} which discovers and
-     * parses files for you.
-     *
-     * @param namespaces - Namespaces keyed by unqualified name
-     * @param girFiles - Absolute paths of the `.gir` files the namespaces came from
-     */
-    constructor(namespaces: ReadonlyMap<string, GirNamespace>, girFiles: readonly string[] = []) {
-        this.namespaces = namespaces;
-        this.girFiles = girFiles;
-        this.entityIndex = new Map();
-        for (const namespace of namespaces.values()) {
-            indexNamespace(this.entityIndex, namespace);
-        }
-    }
-
-    /**
-     * Looks up a type by `(namespace, name)`. Aliases are followed one step
-     * to their target. Returns `undefined` when neither the namespace nor a
-     * matching entity exists.
-     *
-     * @param namespaceName - Namespace to look in (e.g. `"GLib"`)
-     * @param typeName - Local type name within the namespace (e.g. `"Variant"`)
-     */
-    resolveNamed(namespaceName: string, typeName: string): ResolvedNamed | undefined {
-        const key = entityKey(namespaceName, typeName);
-        const direct = this.entityIndex.get(key);
-        if (direct !== undefined) return direct;
-        return undefined;
-    }
-}
-
-const entityKey = (namespaceName: string, typeName: string): string => `${namespaceName}.${typeName}`;
-
-const indexNamespace = (index: Map<string, ResolvedNamed>, namespace: GirNamespace): void => {
-    for (const value of namespace.classes) {
-        index.set(entityKey(namespace.name, value.name), { kind: "class", namespace, value });
-    }
-    for (const value of namespace.interfaces) {
-        index.set(entityKey(namespace.name, value.name), { kind: "interface", namespace, value });
-    }
-    for (const value of namespace.boxeds) {
-        index.set(entityKey(namespace.name, value.name), { kind: "boxed", namespace, value });
-    }
-    for (const value of namespace.enums) {
-        index.set(entityKey(namespace.name, value.name), { kind: "enum", namespace, value });
-    }
-    for (const value of namespace.callbacks) {
-        index.set(entityKey(namespace.name, value.name), { kind: "callback", namespace, value });
-    }
-    for (const alias of namespace.aliases) {
-        const target = alias.target?.kind === "named" ? alias.target.typeName : undefined;
-        index.set(entityKey(namespace.name, alias.name), {
-            kind: "alias",
-            namespace,
-            target,
-            targetRef: alias.target,
-        });
-    }
-};
-
-/**
- * Discovers and parses every GIR file needed to satisfy `libraries` and
- * their transitive `<include>` dependencies.
- *
- * @param libraries - Resolved `Name-Version` namespace identifiers
- * @param girPath - Ordered list of directories to search for `.gir` files
- * @returns A populated {@link GirRepository}
- * @throws If any required GIR file cannot be located on `girPath`
- */
-export const loadGirRepository = (libraries: readonly string[], girPath: readonly string[]): GirRepository => {
-    const namespaces = new Map<string, GirNamespace>();
-    const girFiles: string[] = [];
-    const queue: string[] = [...libraries];
-    while (queue.length > 0) {
-        const identifier = queue.shift();
-        if (identifier === undefined) continue;
-        const namespaceName = identifier.split("-")[0] ?? identifier;
-        if (namespaces.has(namespaceName)) continue;
-        const path = locateGirFile(identifier, girPath);
-        girFiles.push(path);
-        const root = parseGirFile(path);
-        const repository = root.repository;
-        if (typeof repository !== "object" || repository === null) {
-            throw new Error(`GIR file at ${path} has no <repository> root`);
-        }
-        const namespace = namespaceFromRepository(repository as Record<string, unknown>);
-        namespaces.set(namespace.name, namespace);
-        for (const include of namespace.includes) {
-            queue.push(`${include.name}-${include.version}`);
-        }
-    }
-    return new GirRepository(namespaces, girFiles);
-};
-
-const locateGirFile = (identifier: string, girPath: readonly string[]): string => {
-    const filename = `${identifier}.gir`;
-    for (const directory of girPath) {
-        const candidate = join(directory, filename);
-        if (existsSync(candidate)) return candidate;
-    }
-    const tried = girPath.map((directory) => join(directory, filename)).join(", ");
-    throw new Error(`GIR file ${filename} not found on girPath. Tried: ${tried}`);
-};

package/src/gir/signal.ts

@@ -1,36 +0,0 @@
-import { type GirParameter, type GirReturnValue, parameterFromNode, returnValueFromNode } from "./parameter.js";
-import { attr, attrBool, childOf, childrenOf, type RawNode } from "./parse.js";
-
-/** Emission stage (`<glib:signal when="…">`). */
-type SignalWhen = "first" | "last" | "cleanup";
-
-/** A GObject `<glib:signal>` declaration. */
-export type GirSignal = {
-    /** GIR signal name, kebab-case (e.g. `"activate-link"`). */
-    readonly name: string;
-    readonly parameters: readonly GirParameter[];
-    readonly returnValue: GirReturnValue;
-    readonly when: SignalWhen;
-    readonly detailed: boolean;
-    readonly action: boolean;
-    readonly noRecurse: boolean;
-    readonly noHooks: boolean;
-};
-
-/**
- * Builds a {@link GirSignal} from a `<glib:signal>` element.
- */
-export const signalFromNode = (node: RawNode): GirSignal => {
-    const parametersNode = childOf(node, "parameters");
-    const parameterNodes = childrenOf(parametersNode, "parameter");
-    return {
-        name: attr(node, "name") ?? "",
-        parameters: parameterNodes.map((parameter) => parameterFromNode(parameter, false)),
-        returnValue: returnValueFromNode(childOf(node, "return-value")),
-        when: (attr(node, "when") ?? "last") as SignalWhen,
-        detailed: attrBool(node, "detailed"),
-        action: attrBool(node, "action"),
-        noRecurse: attrBool(node, "no-recurse"),
-        noHooks: attrBool(node, "no-hooks"),
-    };
-};

package/src/jsx-store.ts

@@ -1,53 +0,0 @@
-import { type StoreOptions, writeStore } from "./store-fs.js";
-
-/**
- * Options for assembling the injected `@gtkx/react-jsx` unit.
- */
-export type JsxStoreOptions = StoreOptions & {
-    /** Absolute path to the gi store, for the unit's own `node_modules/@gtkx/gi`. */
-    readonly giStoreDir: string;
-    /** Real (symlink-resolved) directory of the installed `react` runtime. */
-    readonly realReactRuntimeDir: string;
-    /** Real (symlink-resolved) directory of the installed `@gtkx/react`. */
-    readonly realReactPackageDir: string;
-};
-
-const stem = (relativePath: string): string => relativePath.replace(/\.(tsx|ts)$/, "");
-
-/**
- * Assembles the self-contained injected `@gtkx/react-jsx` unit: the generated
- * `jsx`/`internal`/`compounds` modules plus a `package.json` and the unit's own
- * `node_modules` symlinks to `@gtkx/gi` and `react`.
- *
- * @param options - Resolved store/link/dependency paths
- * @param files - React pipeline output keyed by source filename
- */
-export const writeJsxStore = (options: JsxStoreOptions, files: ReadonlyMap<string, string>): void => {
-    writeStore({
-        storeDir: options.storeDir,
-        linkDir: options.linkDir,
-        files: [...files].map(([relativePath, source]) => ({
-            stem: stem(relativePath),
-            fileName: relativePath,
-            source,
-        })),
-        manifest: {
-            name: "@gtkx/react-jsx",
-            type: "module",
-            version: options.version,
-            sideEffects: ["./internal.js"],
-            exports: {
-                "./package.json": "./package.json",
-                ".": { types: "./jsx.d.ts", default: "./jsx.js" },
-                "./jsx": { types: "./jsx.d.ts", default: "./jsx.js" },
-                "./compounds": { types: "./compounds.d.ts", default: "./compounds.js" },
-                "./internal": { types: "./internal.d.ts", default: "./internal.js" },
-            },
-        },
-        symlinks: [
-            { segments: ["node_modules", "@gtkx", "gi"], target: options.giStoreDir },
-            { segments: ["node_modules", "@gtkx", "react"], target: options.realReactPackageDir },
-            { segments: ["node_modules", "react"], target: options.realReactRuntimeDir },
-        ],
-    });
-};

package/src/react/compounds-meta.ts

@@ -1,99 +0,0 @@
-/**
- * Container-slot mapping for compound widgets — JSX element name to the
- * camelCase GTK method names that append a child onto the widget.
- *
- * Each method name doubles as a `ReactNode` prop on the compound and as the
- * `<ContainerSlot id="…">` identifier the reconciler dispatches to. For
- * example `packStart` on `AdwHeaderBar` maps to `adw_header_bar_pack_start(…)`;
- * `<AdwHeaderBar packStart={…} />` packs the value at the start.
- *
- * Unlike setter slots ({@link BUILT_IN_SLOT_PROPS}), a container slot accepts
- * multiple children and appends rather than replaces.
- *
- * The list is small and stable; defining it in code keeps the lookup
- * fast and avoids one more GIR-introspection pass.
- */
-const CONTAINER_SLOTS: Readonly<Record<string, readonly string[]>> = Object.freeze({
-    AdwActionRow: ["addPrefix", "addSuffix"],
-    AdwEntryRow: ["addPrefix", "addSuffix"],
-    AdwExpanderRow: ["addPrefix", "addSuffix", "addRow", "addAction"],
-    AdwHeaderBar: ["packStart", "packEnd"],
-    AdwToolbarView: ["addTopBar", "addBottomBar"],
-    GtkActionBar: ["packStart", "packEnd"],
-    GtkHeaderBar: ["packStart", "packEnd"],
-});
-
-/**
- * Returns the container-slot method names for a JSX element name, or an
- * empty array if no container slots exist.
- *
- * @param jsxName - The JSX element name (PascalCase / GLib type name)
- */
-export const containerSlotsFor = (jsxName: string): readonly string[] => CONTAINER_SLOTS[jsxName] ?? [];
-
-/**
- * Virtual-child subcomponent mapping — JSX element name to the map of
- * subcomponent property → virtual JSX intrinsic name it routes through.
- *
- * For example `GtkConstraintLayout.Constraint` renders the
- * `<Constraint>` virtual intrinsic so the reconciler can attach a
- * GtkConstraint to the layout. Unlike container slots, virtual
- * subcomponents render an existing intrinsic element rather than
- * invoking a setter on the parent widget.
- */
-const VIRTUAL_SUBCOMPONENTS: Readonly<
-    Record<string, ReadonlyArray<{ readonly child: string; readonly intrinsic: string }>>
-> = Object.freeze({
-    GtkShortcutController: [{ child: "Shortcut", intrinsic: "Shortcut" }],
-    GtkConstraintLayout: [
-        { child: "Constraint", intrinsic: "Constraint" },
-        { child: "Guide", intrinsic: "ConstraintGuide" },
-        { child: "Widget", intrinsic: "ConstraintLayoutWidget" },
-        { child: "Vfl", intrinsic: "ConstraintVfl" },
-    ],
-    GtkStack: [{ child: "Page", intrinsic: "StackPage" }],
-    AdwViewStack: [{ child: "Page", intrinsic: "StackPage" }],
-    GtkNotebook: [
-        { child: "Page", intrinsic: "NotebookPage" },
-        { child: "PageTab", intrinsic: "NotebookPageTab" },
-    ],
-    GtkGrid: [{ child: "Child", intrinsic: "GridChild" }],
-    GtkFixed: [{ child: "Child", intrinsic: "FixedChild" }],
-    GtkOverlay: [{ child: "Child", intrinsic: "OverlayChild" }],
-    GtkColumnView: [{ child: "Column", intrinsic: "ColumnViewColumn" }],
-    GtkTextView: [
-        { child: "Tag", intrinsic: "TextTag" },
-        { child: "Anchor", intrinsic: "TextAnchor" },
-        { child: "Paintable", intrinsic: "TextPaintable" },
-    ],
-    GtkSourceView: [
-        { child: "Tag", intrinsic: "TextTag" },
-        { child: "Anchor", intrinsic: "TextAnchor" },
-        { child: "Paintable", intrinsic: "TextPaintable" },
-    ],
-    GtkMenuButton: [
-        { child: "MenuItem", intrinsic: "MenuItem" },
-        { child: "MenuSection", intrinsic: "MenuSection" },
-        { child: "MenuSubmenu", intrinsic: "MenuSubmenu" },
-    ],
-    GtkPopoverMenu: [
-        { child: "Item", intrinsic: "MenuItem" },
-        { child: "Section", intrinsic: "MenuSection" },
-        { child: "Submenu", intrinsic: "MenuSubmenu" },
-    ],
-    GtkPopoverMenuBar: [
-        { child: "Item", intrinsic: "MenuItem" },
-        { child: "Section", intrinsic: "MenuSection" },
-        { child: "Submenu", intrinsic: "MenuSubmenu" },
-    ],
-});
-
-/**
- * Returns the virtual-subcomponent record for a JSX element name, or an
- * empty array if no virtual subcomponents exist.
- *
- * @param jsxName - The JSX element name (PascalCase / GLib type name)
- */
-export const virtualSubcomponentsFor = (
-    jsxName: string,
-): ReadonlyArray<{ readonly child: string; readonly intrinsic: string }> => VIRTUAL_SUBCOMPONENTS[jsxName] ?? [];

package/src/react/compounds.ts

@@ -1,204 +0,0 @@
-import { quote } from "@gtkx/utils";
-import { indent } from "../dsl/emit.js";
-import type { GirRepository } from "../gir/repository.js";
-import { containerSlotsFor, virtualSubcomponentsFor } from "./compounds-meta.js";
-import { mergeSlotProps } from "./slot-props.js";
-import { ancestorGlibNames, isWidgetClass, iterateClassesWithGlibName, type WidgetCandidate } from "./widgets.js";
-
-type CompoundAccumulator = {
-    readonly elementNames: Set<string>;
-    readonly compoundPropTypes: Set<string>;
-    readonly virtualPropTypes: Set<string>;
-};
-
-/**
- * Generates `compounds.tsx` source — one statically-compiled React
- * component per widget that has slot props, container-slot props, or
- * virtual-child sub-components.
- *
- * Each component is plain JSX: it destructures its slot and container-slot
- * props, forwards the rest to the host intrinsic, and wraps each non-null
- * slot value in a `<Slot>` (setter) or `<ContainerSlot>` (append) element.
- * Virtual-child sub-components (e.g. `GtkStack.Page`) are attached with
- * `Object.assign` under an explicit intersection type so isolated
- * declaration emit succeeds.
- *
- * A host intrinsic is referenced through a module-local
- * `${Name}Element = "Name"` const so the JSX tag does not collide with the
- * exported component of the same name. Widgets with no slots, container
- * slots, or virtual children remain bare string-constant intrinsics in
- * `jsx.ts`.
- *
- * @param repository - The loaded GIR repository
- * @param userSlotProps - User-supplied slot-prop overrides
- */
-export const generateCompounds = (
-    repository: GirRepository,
-    userSlotProps: Readonly<Record<string, readonly string[]>> | undefined,
-): { readonly source: string; readonly exportedNames: ReadonlySet<string> } => {
-    const slotPropMap = mergeSlotProps(userSlotProps);
-    const exportedNames = new Set<string>();
-    const exportLines: string[] = [];
-    const accumulator: CompoundAccumulator = {
-        elementNames: new Set<string>(),
-        compoundPropTypes: new Set<string>(),
-        virtualPropTypes: new Set<string>(),
-    };
-
-    for (const { glibName, klass, namespace } of collectCompoundCandidates(repository)) {
-        const slots = resolveInheritedSlots(slotPropMap, klass, namespace, repository);
-        const containers = containerSlotsFor(glibName);
-        const virtuals = virtualSubcomponentsFor(glibName);
-        if (slots.length === 0 && containers.length === 0 && virtuals.length === 0) continue;
-
-        exportLines.push(renderCompound({ glibName, slots, containers, virtuals }, accumulator));
-        exportedNames.add(glibName);
-    }
-
-    const sections = [
-        renderImportLines(accumulator).join("\n"),
-        renderElementConsts(accumulator),
-        exportLines.join("\n\n"),
-    ];
-    const source = `${sections.filter((section) => section.length > 0).join("\n\n")}\n`;
-    return { source, exportedNames };
-};
-
-type CompoundShape = {
-    readonly glibName: string;
-    readonly slots: readonly string[];
-    readonly containers: readonly string[];
-    readonly virtuals: ReadonlyArray<{ readonly child: string; readonly intrinsic: string }>;
-};
-
-const renderCompound = (shape: CompoundShape, accumulator: CompoundAccumulator): string => {
-    const { glibName, slots, containers, virtuals } = shape;
-    const propsType = `${glibName}Props`;
-    accumulator.compoundPropTypes.add(propsType);
-    accumulator.elementNames.add(glibName);
-    if (slots.length > 0) accumulator.elementNames.add("Slot");
-    if (containers.length > 0) accumulator.elementNames.add("ContainerSlot");
-
-    const component = renderComponentFunction(glibName, propsType, slots, containers);
-    if (virtuals.length === 0) {
-        return `export const ${glibName} = ${component};`;
-    }
-
-    const subcomponents = virtuals.map((virtual) => renderVirtualSubcomponent(virtual, accumulator));
-    const fields = subcomponents.map((sub) => `    ${sub.field};`).join("\n");
-    const impls = subcomponents.map((sub) => indent(`${sub.impl},`, 1)).join("\n");
-    return [
-        `export const ${glibName}: ((props: ${propsType}) => ReactNode) & {`,
-        fields,
-        `} = Object.assign(`,
-        `${indent(component, 1)},`,
-        "    {",
-        impls,
-        "    },",
-        ");",
-    ].join("\n");
-};
-
-const renderComponentFunction = (
-    glibName: string,
-    propsType: string,
-    slots: readonly string[],
-    containers: readonly string[],
-): string => {
-    const host = `${glibName}Element`;
-    if (slots.length === 0 && containers.length === 0) {
-        return [
-            `(props: ${propsType}): ReactNode => {`,
-            "    const { children, ...rest } = props;",
-            `    return <${host} {...rest}>{children}</${host}>;`,
-            "}",
-        ].join("\n");
-    }
-
-    const destructured = [...slots, ...containers, "children"].join(", ");
-    const slotChildren = [
-        ...slots.map((slot) => renderSlotChild("SlotElement", slot)),
-        ...containers.map((container) => renderSlotChild("ContainerSlotElement", container)),
-    ];
-    return [
-        `(props: ${propsType}): ReactNode => {`,
-        `    const { ${destructured}, ...rest } = props;`,
-        "    return (",
-        `        <${host} {...rest}>`,
-        "            {children}",
-        ...slotChildren.map((child) => `            ${child}`),
-        `        </${host}>`,
-        "    );",
-        "}",
-    ].join("\n");
-};
-
-const renderSlotChild = (elementConst: string, slot: string): string =>
-    `{${slot} != null && <${elementConst} id=${quote(slot)}>{${slot}}</${elementConst}>}`;
-
-const renderVirtualSubcomponent = (
-    virtual: { readonly child: string; readonly intrinsic: string },
-    accumulator: CompoundAccumulator,
-): { readonly field: string; readonly impl: string } => {
-    const { child, intrinsic } = virtual;
-    const propsType = `${intrinsic}Props`;
-    accumulator.virtualPropTypes.add(propsType);
-    accumulator.elementNames.add(intrinsic);
-    return {
-        field: `${child}: (props: ${propsType}) => ReactNode`,
-        impl: `${child}: (props: ${propsType}): ReactNode => <${intrinsic}Element {...props} />`,
-    };
-};
-
-const renderElementConsts = (accumulator: CompoundAccumulator): string =>
-    [...accumulator.elementNames]
-        .sort((a, b) => a.localeCompare(b))
-        .map((name) => `const ${name}Element = ${quote(name)} as const;`)
-        .join("\n");
-
-const renderImportLines = (accumulator: CompoundAccumulator): readonly string[] => {
-    const lines = ['import type { ReactNode } from "react";'];
-    const compoundPropTypes = [...accumulator.compoundPropTypes].sort((a, b) => a.localeCompare(b));
-    if (compoundPropTypes.length > 0) {
-        lines.push(`import type { ${compoundPropTypes.join(", ")} } from "./jsx.js";`);
-    }
-    const virtualPropTypes = [...accumulator.virtualPropTypes].sort((a, b) => a.localeCompare(b));
-    if (virtualPropTypes.length > 0) {
-        lines.push(`import type { ${virtualPropTypes.join(", ")} } from "@gtkx/react";`);
-    }
-    return lines;
-};
-
-const resolveInheritedSlots = (
-    slotPropMap: Readonly<Record<string, readonly string[]>>,
-    klass: WidgetCandidate["klass"],
-    namespace: WidgetCandidate["namespace"],
-    repository: GirRepository,
-): readonly string[] => {
-    const seen = new Set<string>();
-    const slots: string[] = [];
-    for (const glibName of ancestorGlibNames(klass, namespace, repository)) {
-        for (const slot of slotPropMap[glibName] ?? []) {
-            if (seen.has(slot)) continue;
-            seen.add(slot);
-            slots.push(slot);
-        }
-    }
-    return slots;
-};
-
-const collectCompoundCandidates = (repository: GirRepository): readonly WidgetCandidate[] => {
-    const seen = new Set<string>();
-    const candidates: WidgetCandidate[] = [];
-    for (const candidate of iterateClassesWithGlibName(repository)) {
-        const { glibName, klass, namespace } = candidate;
-        const isWidget = isWidgetClass(klass, namespace, repository);
-        const hasContainerSlot = containerSlotsFor(glibName).length > 0;
-        const hasVirtualChild = virtualSubcomponentsFor(glibName).length > 0;
-        if (!isWidget && !hasContainerSlot && !hasVirtualChild) continue;
-        if (seen.has(glibName)) continue;
-        seen.add(glibName);
-        candidates.push(candidate);
-    }
-    return candidates.sort((a, b) => a.glibName.localeCompare(b.glibName));
-};