@gtkx/codegen 0.21.0 → 1.0.0-rc.1

package/src/react/internal.ts

@@ -1,91 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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

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

package/src/react/props.ts

@@ -1,307 +0,0 @@
-import { toCamelCase, toIdentifier, toPascalCase } from "@gtkx/utils";
-import type { GirClass } from "../gir/class.js";
-import type { GirNamespace } from "../gir/namespace.js";
-import { type GirParameter, isInoutParameter, isOutParameter } from "../gir/parameter.js";
-import type { GirProperty } from "../gir/property.js";
-import { resolveQualifiedClass, splitQualifiedName } from "../gir/qualified-name.js";
-import { qualifyTypeRef } from "../gir/qualify.js";
-import type { GirRepository } from "../gir/repository.js";
-import type { GirSignal } from "../gir/signal.js";
-import type { GirTypeRef, NamedTypeRef } from "../gir/type-ref.js";
-import { renderBaseTypeFor, type TsTypeTarget } from "../writers/ts-type.js";
-import { isScalarRef } from "../writers/value.js";
-import { signalHandlerName } from "./widgets.js";
-
-/**
- * Rendered prop entries for a single widget's Props interface, together
- * with imports the writer must request to keep type references valid.
- */
-export type WidgetPropsEntries = {
-    /** Rendered prop lines, indented one level inside the interface body. */
-    readonly propLines: readonly string[];
-    /** Cross-namespace imports the writer must add to the surrounding module. */
-    readonly imports: ReadonlyMap<string, string>;
-};
-
-/**
- * Options for {@link buildWidgetPropsEntries}.
- */
-export type WidgetPropsOptions = {
-    /** The full GIR repository. */
-    readonly repository: GirRepository;
-    /** The widget class whose props bag is being built. */
-    readonly klass: GirClass;
-    /** Property names that should be widened to `ReactNode` slot children. */
-    readonly slotPropNames?: ReadonlySet<string>;
-    /** Returns `true` when `candidate` already has its own widget Props interface. */
-    readonly isWidgetAncestor?: (candidate: GirClass) => boolean;
-};
-
-type SignalRenderOptions = {
-    readonly repository: GirRepository;
-    readonly signal: GirSignal;
-    readonly imports: Map<string, string>;
-    readonly selfType: string;
-    readonly owningNamespace: string;
-};
-
-type ParentRef = { readonly klass: GirClass; readonly namespaceName: string };
-
-/**
- * Builds a typed prop bag for one widget intrinsic.
- *
- * Combines the widget's own properties + signal handlers with those declared
- * by its directly-implemented interfaces and by every non-widget ancestor up
- * to the first widget parent (whose props are inherited via `extends`).
- * Property types are written as TypeScript surface types resolved against the
- * loaded GIR repository.
- *
- * @param options - {@link WidgetPropsOptions}
- */
-export const buildWidgetPropsEntries = (options: WidgetPropsOptions): WidgetPropsEntries => {
-    const { repository, klass, slotPropNames = new Set<string>(), isWidgetAncestor = () => false } = options;
-    const imports = new Map<string, string>();
-    const propEntries: string[] = [];
-    const seen = new Set<string>();
-
-    const ownerName = klass.glibTypeName ?? klass.cType ?? klass.name;
-    const selfNamespace = currentNamespaceKey(repository, klass);
-    const selfTypeName = resolveSelfTypeName(klass, selfNamespace, imports);
-
-    const acceptProperty = (property: GirProperty, owningNamespace: string): void => {
-        const jsName = toIdentifier(toCamelCase(property.name));
-        if (seen.has(jsName)) return;
-        seen.add(jsName);
-        if (isPropOverridden(ownerName, jsName)) return;
-        if (slotPropNames.has(jsName)) {
-            propEntries.push(`${jsName}?: ReactNode | null;`);
-            return;
-        }
-        const qualified = qualifyTypeRef(property.type, owningNamespace);
-        const tsType = renderReactPropType(repository, qualified, true, imports);
-        propEntries.push(`${jsName}?: ${tsType} | null;`);
-    };
-
-    const acceptSignal = (signal: GirSignal, owningNamespace: string): void => {
-        const handlerName = signalHandlerName(signal.name);
-        if (seen.has(handlerName)) return;
-        seen.add(handlerName);
-        if (isSignalOverridden(ownerName, handlerName)) return;
-        const signature = renderSignalHandler({
-            repository,
-            signal,
-            imports,
-            selfType: selfTypeName,
-            owningNamespace,
-        });
-        propEntries.push(`${handlerName}?: ${signature};`);
-    };
-
-    visitClassAndAncestors({ repository, klass, selfNamespace, isWidgetAncestor }, acceptProperty, acceptSignal);
-
-    return { propLines: propEntries, imports };
-};
-
-const resolveSelfTypeName = (klass: GirClass, selfNamespace: string, imports: Map<string, string>): string => {
-    if (selfNamespace === "?") return toPascalCase(klass.name);
-    imports.set(selfNamespace, selfNamespace);
-    return `${selfNamespace}.${toPascalCase(klass.name)}`;
-};
-
-type WalkContext = {
-    readonly repository: GirRepository;
-    readonly klass: GirClass;
-    readonly selfNamespace: string;
-    readonly isWidgetAncestor: (candidate: GirClass) => boolean;
-};
-
-const visitClassAndAncestors = (
-    walk: WalkContext,
-    acceptProperty: (property: GirProperty, owningNamespace: string) => void,
-    acceptSignal: (signal: GirSignal, owningNamespace: string) => void,
-): void => {
-    const visit = (current: GirClass, owningNamespace: string): void => {
-        for (const property of current.properties) acceptProperty(property, owningNamespace);
-        for (const signal of current.signals) acceptSignal(signal, owningNamespace);
-        for (const implementsName of current.implements) {
-            const resolved = resolveInterface(walk.repository, current, implementsName);
-            if (resolved === undefined) continue;
-            for (const property of resolved.value.properties) acceptProperty(property, resolved.namespace.name);
-            for (const signal of resolved.value.signals) acceptSignal(signal, resolved.namespace.name);
-        }
-    };
-
-    visit(walk.klass, walk.selfNamespace);
-    const visited = new Set<string>([`${walk.selfNamespace}.${walk.klass.name}`]);
-    let parentRef = resolveParent(walk.repository, walk.klass, walk.selfNamespace);
-    while (parentRef !== undefined && !walk.isWidgetAncestor(parentRef.klass)) {
-        const key = `${parentRef.namespaceName}.${parentRef.klass.name}`;
-        if (visited.has(key)) break;
-        visited.add(key);
-        visit(parentRef.klass, parentRef.namespaceName);
-        parentRef = resolveParent(walk.repository, parentRef.klass, parentRef.namespaceName);
-    }
-};
-
-const resolveParent = (repository: GirRepository, klass: GirClass, defaultNamespace: string): ParentRef | undefined => {
-    if (klass.parent === undefined) return undefined;
-    return resolveQualifiedClass(repository, klass.parent, defaultNamespace);
-};
-
-const currentNamespaceKey = (repository: GirRepository, klass: GirClass): string => {
-    for (const namespace of repository.namespaces.values()) {
-        if (namespace.classes.includes(klass) || namespace.interfaces.includes(klass)) {
-            return namespace.name;
-        }
-    }
-    return "?";
-};
-
-const resolveInterface = (
-    repository: GirRepository,
-    declaringClass: GirClass,
-    implementsName: string,
-): { readonly namespace: GirNamespace; readonly value: GirClass } | undefined => {
-    const { namespaceName, typeName } = splitQualifiedName(
-        implementsName,
-        currentNamespaceKey(repository, declaringClass),
-    );
-    const resolved = repository.resolveNamed(namespaceName, typeName);
-    if (resolved === undefined) return undefined;
-    if (resolved.kind !== "interface") return undefined;
-    return { namespace: resolved.namespace, value: resolved.value };
-};
-
-/**
- * Per-widget prop names that the React package re-types in a hand-written
- * `declare module` augmentation. Skipping them in the generated bag
- * prevents TS2717 "subsequent property declarations must have the same
- * type" when the augmentation widens the GIR property to a declarative
- * React shape (e.g. an array of child-props instead of a raw GObject
- * model).
- *
- * Entries are matched against the widget's GLib type name (e.g.
- * `"AdwToggleGroup"`); values are the JS prop names to skip.
- */
-const PROP_OVERRIDES_BY_WIDGET: Readonly<Record<string, ReadonlySet<string>>> = {
-    AdwToggleGroup: new Set(["toggles"]),
-    AdwAlertDialog: new Set(["responses"]),
-    GtkColumnView: new Set(["columns"]),
-    GtkScale: new Set(["marks"]),
-};
-
-const isPropOverridden = (ownerName: string, propName: string): boolean => {
-    const overrides = PROP_OVERRIDES_BY_WIDGET[ownerName];
-    return overrides?.has(propName) ?? false;
-};
-
-/**
- * Per-widget signal-handler names whose generated emission is skipped so
- * a hand-written `declare module` augmentation can supply a refined
- * signature without triggering TS2717.
- */
-const SIGNAL_OVERRIDES_BY_WIDGET: Readonly<Record<string, ReadonlySet<string>>> = {
-    GtkRange: new Set(["onValueChanged"]),
-    GtkScale: new Set(["onValueChanged"]),
-    GtkScaleButton: new Set(["onValueChanged"]),
-    GtkSpinButton: new Set(["onValueChanged"]),
-    AdwSpinRow: new Set(["onValueChanged"]),
-    AdwSwitchRow: new Set(["onActivated"]),
-};
-
-const isSignalOverridden = (ownerName: string, handlerName: string): boolean => {
-    const overrides = SIGNAL_OVERRIDES_BY_WIDGET[ownerName];
-    return overrides?.has(handlerName) ?? false;
-};
-
-const renderSignalHandler = (options: SignalRenderOptions): string => {
-    const { repository, signal, imports, selfType, owningNamespace } = options;
-    const visible = signal.parameters.filter((parameter) => !parameter.isVarargs);
-    const params = visible
-        .filter((parameter) => !isOutParameter(parameter))
-        .map((parameter, index) => {
-            const name = parameter.name.length === 0 ? `arg${index + 1}` : toIdentifier(toCamelCase(parameter.name));
-            const qualified = qualifyTypeRef(parameter.type, owningNamespace);
-            const baseType = renderReactPropType(repository, qualified, false, imports);
-            return `${name}: ${baseType}`;
-        });
-    params.push(`self: ${selfType}`);
-    return `(${params.join(", ")}) => ${renderSignalReturnType(options, visible)}`;
-};
-
-/**
- * Computes a signal handler's return type.
- *
- * Pure out-parameters (`direction="out"`, not caller-allocated) are surfaced
- * through the return value as a tuple `[primary, ...outs]`, mirroring the
- * convention {@link renderMethodReturnType} produces for methods: a value return
- * with no outs stays scalar (with `| void` so handlers may opt out); a void
- * return with a single out unwraps to that out's type; otherwise the primary
- * (when present) leads a tuple of the out types.
- *
- * @param options - The signal render options
- * @param visible - The signal's non-varargs parameters
- */
-const renderSignalReturnType = (options: SignalRenderOptions, visible: readonly GirParameter[]): string => {
-    const { repository, signal, imports, owningNamespace } = options;
-    const qualifiedReturn = qualifyTypeRef(signal.returnValue.type, owningNamespace);
-    const baseReturn = renderReactPropType(repository, qualifiedReturn, signal.returnValue.nullable, imports);
-    const outTypes = visible
-        .filter(
-            (parameter) =>
-                isOutParameter(parameter) ||
-                (isInoutParameter(parameter) && isScalarRef(repository, owningNamespace, parameter.type)),
-        )
-        .map((parameter) =>
-            renderReactPropType(repository, qualifyTypeRef(parameter.type, owningNamespace), false, imports),
-        );
-    if (outTypes.length === 0) {
-        return baseReturn === "void" ? "void" : `${baseReturn} | void`;
-    }
-    if (baseReturn !== "void") {
-        return `[${baseReturn}, ${outTypes.join(", ")}]`;
-    }
-    const [single, ...rest] = outTypes;
-    if (rest.length === 0 && single !== undefined) return single;
-    return `[${outTypes.join(", ")}]`;
-};
-
-const reactTarget = (repository: GirRepository, imports: Map<string, string>): TsTypeTarget => ({
-    containerStyle: "record",
-    callbackType: "(...args: unknown[]) => unknown",
-    byteArrayAsNumber: false,
-    renderNamed: (ref) => namedTsType(repository, ref, imports),
-});
-
-const renderReactPropType = (
-    repository: GirRepository,
-    ref: GirTypeRef | undefined,
-    isNullable: boolean,
-    imports: Map<string, string>,
-): string => {
-    const base = renderBaseTypeFor(reactTarget(repository, imports), ref);
-    return isNullable ? `${base} | null` : base;
-};
-
-const namedTsType = (repository: GirRepository, ref: NamedTypeRef, imports: Map<string, string>): string => {
-    const namespaceName = ref.namespaceName;
-    if (namespaceName === undefined) {
-        return ref.typeName;
-    }
-    const resolved = repository.resolveNamed(namespaceName, ref.typeName);
-    if (resolved === undefined) {
-        imports.set(namespaceName, namespaceName);
-        return `${namespaceName}.${ref.typeName}`;
-    }
-    if (resolved.kind === "callback") return "(...args: unknown[]) => unknown";
-    if (resolved.kind === "alias") {
-        if (resolved.target === undefined) return "number";
-        return namedTsType(
-            repository,
-            { kind: "named", namespaceName: resolved.namespace.name, typeName: resolved.target, cType: undefined },
-            imports,
-        );
-    }
-    imports.set(namespaceName, namespaceName);
-    return `${namespaceName}.${ref.typeName}`;
-};

package/src/react/slot-props.ts

@@ -1,57 +0,0 @@
-/**
- * Built-in widget-typed properties that should be exposed as JSX child
- * slots (typed as `ReactNode`) rather than as raw widget refs.
- *
- * The keys are JSX element names (i.e. GLib type names such as
- * `"AdwWindow"`, `"GtkHeaderBar"`); the values are the camelCase property
- * names that should be promoted. User-supplied `slotProps` from
- * `gtkx.config.ts` merge into this map.
- */
-const BUILT_IN_SLOT_PROPS: Readonly<Record<string, readonly string[]>> = Object.freeze({
-    GtkWindow: ["titlebar"],
-    AdwWindow: ["content"],
-    AdwApplicationWindow: ["content"],
-    AdwAlertDialog: ["extraChild"],
-    AdwBottomSheet: ["bottomBar", "content", "sheet"],
-    GtkCenterBox: ["centerWidget", "endWidget", "startWidget"],
-    GtkExpander: ["labelWidget"],
-    AdwFlap: ["content", "flap", "separator"],
-    GtkFrame: ["labelWidget"],
-    GtkHeaderBar: ["titleWidget"],
-    AdwHeaderBar: ["titleWidget"],
-    GtkMenuButton: ["popover"],
-    AdwMessageDialog: ["extraChild"],
-    AdwNavigationSplitView: ["content", "sidebar"],
-    AdwOverlaySplitView: ["content", "sidebar"],
-    GtkPaned: ["endChild", "startChild"],
-    AdwPreferencesGroup: ["headerSuffix"],
-    AdwPreferencesPage: ["banner"],
-    AdwSplitButton: ["popover"],
-    AdwTabBar: ["endActionWidget", "startActionWidget"],
-    AdwToolbarView: ["content"],
-});
-
-/**
- * Merges built-in slot props with the user-supplied `slotProps` map.
- *
- * Per JSX element name, the resulting list is the union of both sources
- * with duplicates removed and a stable alphabetical sort.
- *
- * @param userSlotProps - The user-provided `slotProps` map, or `undefined`
- */
-export const mergeSlotProps = (
-    userSlotProps: Readonly<Record<string, readonly string[]>> | undefined,
-): Readonly<Record<string, readonly string[]>> => {
-    const result: Record<string, string[]> = {};
-    for (const [key, values] of Object.entries(BUILT_IN_SLOT_PROPS)) {
-        result[key] = [...values];
-    }
-    if (userSlotProps !== undefined) {
-        for (const [key, values] of Object.entries(userSlotProps)) {
-            const merged = new Set<string>(result[key] ?? []);
-            for (const value of values) merged.add(value);
-            result[key] = [...merged].sort((a, b) => a.localeCompare(b));
-        }
-    }
-    return result;
-};