@gtkx/codegen 0.21.0

package/src/react/compounds-meta.ts

@@ -0,0 +1,99 @@
+/**
+ * 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

@@ -0,0 +1,204 @@
+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));
+};

package/src/react/internal.ts

@@ -0,0 +1,91 @@
+import { quote, toCamelCase, toIdentifier } from "@gtkx/utils";
+import type { GirClass } from "../gir/class.js";
+import type { GirRepository } from "../gir/repository.js";
+import { implementedInterfaces, isReactNodeClass, iterateClassesWithGlibName, signalHandlerName } from "./widgets.js";
+
+/**
+ * Generates `internal.ts` source — the `SIGNALS` and `CONSTRUCT_ONLY_PROPS`
+ * tables consumed by the React metadata resolver.
+ *
+ * Walks every widget across every loaded namespace and emits one entry
+ * per GLib type name. Signals are mapped from kebab-case to `onCamelCase`;
+ * construct-only properties are surfaced as a `Set` for the runtime to
+ * consult on mount.
+ *
+ * @param repository - The loaded GIR repository
+ */
+export const generateInternal = (repository: GirRepository): string => {
+    const widgets = collectWidgets(repository);
+    const signalsEntries = widgets.map(
+        ({ glibName, signals }) => `    "${glibName}": ${renderSignalsObject(signals)},`,
+    );
+    const constructOnlyEntries = widgets
+        .filter(({ constructOnly }) => constructOnly.length > 0)
+        .map(({ glibName, constructOnly }) => `    "${glibName}": new Set([${constructOnly.map(quote).join(",")}]),`);
+
+    const namespaces = [...new Set(widgets.map((widget) => widget.namespace))].sort((a, b) => a.localeCompare(b));
+    const preamble = namespaces.map((name) => `import "@gtkx/gi/${name.toLowerCase()}";`).join("\n");
+
+    return `${[
+        preamble,
+        `export const SIGNALS: Readonly<Record<string, Readonly<Record<string, string>>>> = {\n${signalsEntries.join("\n")}\n};`,
+        `export const CONSTRUCT_ONLY_PROPS: Readonly<Record<string, ReadonlySet<string>>> = {\n${constructOnlyEntries.join("\n")}\n};`,
+    ].join("\n\n")}\n`;
+};
+
+type WidgetEntry = {
+    readonly glibName: string;
+    readonly namespace: string;
+    readonly signals: ReadonlyArray<readonly [string, string]>;
+    readonly constructOnly: readonly string[];
+};
+
+const collectWidgets = (repository: GirRepository): readonly WidgetEntry[] => {
+    const entries: WidgetEntry[] = [];
+    for (const { glibName, klass, namespace } of iterateClassesWithGlibName(repository)) {
+        if (!isReactNodeClass(klass, namespace, repository)) continue;
+        const sources = [klass, ...implementedInterfaces(klass, namespace, repository).map((entry) => entry.klass)];
+        entries.push({
+            glibName,
+            namespace: namespace.name,
+            signals: collectSignals(sources),
+            constructOnly: collectConstructOnly(sources),
+        });
+    }
+    return entries.sort((a, b) => a.glibName.localeCompare(b.glibName));
+};
+
+const collectSignals = (sources: readonly GirClass[]): ReadonlyArray<readonly [string, string]> => {
+    const seen = new Set<string>();
+    const signals: Array<readonly [string, string]> = [];
+    for (const source of sources) {
+        for (const signal of source.signals) {
+            const handlerName = signalHandlerName(signal.name);
+            if (seen.has(handlerName)) continue;
+            seen.add(handlerName);
+            signals.push([handlerName, signal.name] as const);
+        }
+    }
+    return signals;
+};
+
+const collectConstructOnly = (sources: readonly GirClass[]): readonly string[] => {
+    const seen = new Set<string>();
+    const names: string[] = [];
+    for (const source of sources) {
+        for (const property of source.properties) {
+            if (!property.constructOnly) continue;
+            const jsName = toIdentifier(toCamelCase(property.name));
+            if (seen.has(jsName)) continue;
+            seen.add(jsName);
+            names.push(jsName);
+        }
+    }
+    return names;
+};
+
+const renderSignalsObject = (entries: ReadonlyArray<readonly [string, string]>): string => {
+    if (entries.length === 0) return "{}";
+    const lines = entries.map(([key, value]) => `        ${quote(key)}: ${quote(value)}`);
+    return `{\n${lines.join(",\n")}\n    }`;
+};

package/src/react/jsx.ts

@@ -0,0 +1,155 @@
+import { quote } from "@gtkx/utils";
+import type { GirClass } from "../gir/class.js";
+import { splitQualifiedName } from "../gir/qualified-name.js";
+import type { GirRepository } from "../gir/repository.js";
+import { containerSlotsFor } from "./compounds-meta.js";
+import { buildWidgetPropsEntries } from "./props.js";
+import { isReactNodeClass, iterateClassesWithGlibName, type WidgetCandidate } from "./widgets.js";
+
+/**
+ * Generates `jsx.ts` source — one `export const Name = "Name"` per JSX
+ * intrinsic element (every GtkWidget descendant plus event controllers
+ * and layout managers) that is NOT exported as a slot-widget compound,
+ * plus an `export type NameProps` permissive prop bag per intrinsic and
+ * a `WidgetSlotNames` index of every widget's allowed slot names.
+ *
+ * Compounds.ts owns its widgets' runtime exports. To prevent ambiguous
+ * re-exports when consumers wildcard both `compounds.js` and `jsx.js`,
+ * widgets covered by `excludeNames` are skipped here and the consumer
+ * sees a single function-typed export from compounds instead of the
+ * string-literal constant. Prop types are still emitted for every
+ * widget — they live in the type namespace and never clash with
+ * compounds.
+ *
+ * @param repository - The loaded GIR repository
+ * @param excludeNames - Widgets already exported by `compounds.ts`
+ * @param slotPropMap - Per-widget slot prop name overrides
+ */
+export const generateJsx = (
+    repository: GirRepository,
+    excludeNames: ReadonlySet<string> = new Set(),
+    slotPropMap: Readonly<Record<string, readonly string[]>> = {},
+): string => {
+    const widgets = collectWidgets(repository);
+    const intrinsicWidgets = widgets.filter((entry) => !excludeNames.has(entry.glibName));
+    const constLines = intrinsicWidgets.map(
+        (entry) => `export const ${entry.glibName} = ${quote(entry.glibName)} as const;`,
+    );
+
+    const widgetByGlibName = new Map(widgets.map((entry) => [entry.glibName, entry]));
+    const isWidgetAncestor = (candidate: GirClass): boolean => {
+        const candidateGlib = candidate.glibTypeName ?? candidate.cType;
+        return candidateGlib !== undefined && widgetByGlibName.has(candidateGlib);
+    };
+    const namespaceImports = new Map<string, string>();
+    const propBlocks: string[] = ["export interface WidgetProps {\n    name?: string;\n}"];
+    for (const entry of widgets) {
+        const block = renderPropBlock(repository, entry, {
+            slotPropMap,
+            isWidgetAncestor,
+            widgetByGlibName,
+            namespaceImports,
+        });
+        propBlocks.push(block);
+    }
+
+    const importLines = renderImportLines(namespaceImports);
+    const slotEntries = widgets.map((entry) => `    readonly ${quote(entry.glibName)}: string`);
+    const slotNamesLine = `export type WidgetSlotNames = {\n${slotEntries.join(";\n")};\n};`;
+    const intrinsicEntries = widgets.map((entry) => `        ${entry.glibName}: ${entry.glibName}Props;`);
+    const jsxAugmentation = [
+        "declare global {",
+        "    namespace React.JSX {",
+        "        interface IntrinsicElements {",
+        ...intrinsicEntries,
+        "        }",
+        "    }",
+        "}",
+    ].join("\n");
+    const body = [
+        importLines.join("\n"),
+        "",
+        constLines.join("\n"),
+        "",
+        propBlocks.join("\n\n"),
+        "",
+        slotNamesLine,
+        "",
+        jsxAugmentation,
+    ].join("\n");
+    return `${body}\n`;
+};
+
+type RenderPropBlockContext = {
+    readonly slotPropMap: Readonly<Record<string, readonly string[]>>;
+    readonly isWidgetAncestor: (candidate: GirClass) => boolean;
+    readonly widgetByGlibName: ReadonlyMap<string, WidgetCandidate>;
+    readonly namespaceImports: Map<string, string>;
+};
+
+const renderPropBlock = (
+    repository: GirRepository,
+    entry: WidgetCandidate,
+    context: RenderPropBlockContext,
+): string => {
+    const slotPropNames = new Set(context.slotPropMap[entry.glibName] ?? []);
+    const { propLines, imports } = buildWidgetPropsEntries({
+        repository,
+        klass: entry.klass,
+        slotPropNames,
+        isWidgetAncestor: context.isWidgetAncestor,
+    });
+    for (const [namespace, alias] of imports) context.namespaceImports.set(namespace, alias);
+    context.namespaceImports.set(entry.namespace.name, entry.namespace.name);
+    const widgetTypeRef = `${entry.namespace.name}.${entry.klass.name} | null`;
+    const ownerLines = [
+        "    children?: ReactNode;",
+        `    ref?: Ref<${widgetTypeRef}>;`,
+        ...propLines.map((line) => `    ${line}`),
+        ...containerSlotsFor(entry.glibName).map((method) => `    ${method}?: ReactNode | null;`),
+    ];
+    const parentExtends = resolveParentPropsExtension(repository, entry, context.widgetByGlibName);
+    return `export interface ${entry.glibName}Props extends ${parentExtends} {\n${ownerLines.join("\n")}\n}`;
+};
+
+const renderImportLines = (namespaceImports: ReadonlyMap<string, string>): readonly string[] => {
+    const lines = ['import type { ReactNode, Ref } from "react";'];
+    for (const [namespaceName, alias] of namespaceImports) {
+        if (namespaceName === "") continue;
+        const directory = namespaceName.toLowerCase();
+        lines.push(`import type * as ${alias} from "${ffiImportPath(directory)}";`);
+    }
+    return lines;
+};
+
+const collectWidgets = (repository: GirRepository): readonly WidgetCandidate[] => {
+    const entries: WidgetCandidate[] = [];
+    const seen = new Set<string>();
+    for (const candidate of iterateClassesWithGlibName(repository)) {
+        const { glibName, klass, namespace } = candidate;
+        if (!isReactNodeClass(klass, namespace, repository)) continue;
+        if (seen.has(glibName)) continue;
+        seen.add(glibName);
+        entries.push(candidate);
+    }
+    return entries.sort((a, b) => a.glibName.localeCompare(b.glibName));
+};
+
+const ffiImportPath = (directory: string): string => `@gtkx/gi/${directory}`;
+
+const resolveParentPropsExtension = (
+    repository: GirRepository,
+    entry: WidgetCandidate,
+    widgetByGlibName: ReadonlyMap<string, WidgetCandidate>,
+): string => {
+    const parent = entry.klass.parent;
+    if (parent === undefined) return "WidgetProps";
+    const { namespaceName, typeName } = splitQualifiedName(parent, entry.namespace.name);
+    const resolved = repository.resolveNamed(namespaceName, typeName);
+    if (resolved === undefined) return "WidgetProps";
+    if (resolved.kind !== "class" && resolved.kind !== "interface") return "WidgetProps";
+    const parentGlib = resolved.value.glibTypeName ?? resolved.value.cType;
+    if (parentGlib === undefined) return "WidgetProps";
+    if (!widgetByGlibName.has(parentGlib)) return "WidgetProps";
+    return `${parentGlib}Props`;
+};

package/src/react/pipeline.ts

@@ -0,0 +1,29 @@
+import type { GirRepository } from "../gir/repository.js";
+import { generateCompounds } from "./compounds.js";
+import { generateInternal } from "./internal.js";
+import { generateJsx } from "./jsx.js";
+import { mergeSlotProps } from "./slot-props.js";
+
+/**
+ * Produces the three React generated files (`jsx.ts`, `internal.ts`,
+ * `compounds.tsx`) plus a summary widget count for the runner result.
+ *
+ * @param repository - The loaded GIR repository
+ * @param userSlotProps - Slot-prop overrides from `gtkx.config.ts`
+ */
+export const generateReactFiles = (
+    repository: GirRepository,
+    userSlotProps: Readonly<Record<string, readonly string[]>> | undefined,
+): { readonly files: Map<string, string>; readonly widgetCount: number } => {
+    const slotPropMap = mergeSlotProps(userSlotProps);
+    const compounds = generateCompounds(repository, userSlotProps);
+    const jsx = generateJsx(repository, compounds.exportedNames, slotPropMap);
+    const internal = generateInternal(repository);
+    const files = new Map<string, string>([
+        ["jsx.ts", jsx],
+        ["internal.ts", internal],
+        ["compounds.tsx", compounds.source],
+    ]);
+    const widgetCount = jsx.split("\n").filter((line) => line.startsWith("export const ")).length;
+    return { files, widgetCount };
+};