@gtkx/codegen 1.0.0-rc.1 → 1.0.0-rc.2

package/src/store/react/built-ins.ts

@@ -1,260 +0,0 @@
-import type { Call, ContainerProp, ElementProp } from "@gtkx/config";
-
-export type ElementComponent = { types: string[]; module: string; export: string };
-type ManyMethods = Pick<ContainerProp, "append" | "remove">;
-
-const container = (
-    prop: string,
-    child: string,
-    methods: Omit<ContainerProp, "kind" | "prop" | "child">,
-): ElementProp => ({
-    kind: "container",
-    prop,
-    child,
-    ...methods,
-});
-
-const nullSetter = (method: string): Call => ({ method, args: [{ literal: null }] });
-
-const singleChild = (): ElementProp =>
-    container("children", "GtkWidget", { append: "setChild", remove: nullSetter("setChild") });
-
-const singleContent = (): ElementProp =>
-    container("children", "GtkWidget", { append: "setContent", remove: nullSetter("setContent") });
-
-const boxChildren = (): ElementProp =>
-    container("children", "GtkWidget", {
-        append: "append",
-        remove: "remove",
-        insert: { method: "insertChildAfter", args: ["child", "sibling"] },
-        reorder: { method: "reorderChildAfter", args: ["child", "sibling"] },
-    });
-
-const indexedChildren = (append: string, reorder?: string): ElementProp =>
-    container("children", "GtkWidget", {
-        append,
-        remove: "remove",
-        insert: { method: "insert", args: ["child", "index"] },
-        ...(reorder !== undefined ? { reorder: { method: reorder, args: ["child", "index"] } } : {}),
-    });
-
-const addRemoveChildren = (): ElementProp => container("children", "GtkWidget", { append: "add", remove: "remove" });
-
-const prefixSuffixProps = (): ElementProp[] => [
-    container("prefix", "GtkWidget", { append: "addPrefix" }),
-    container("suffix", "GtkWidget", { append: "addSuffix" }),
-];
-
-const packProps = (): ElementProp[] => [
-    container("start", "GtkWidget", { append: "packStart" }),
-    container("end", "GtkWidget", { append: "packEnd" }),
-];
-
-const autowrapProp = (wrapper: string): ElementProp =>
-    container("children", "GtkWidget", {
-        append: "append",
-        remove: "remove",
-        insert: { method: "insert", args: ["child", "index"] },
-        autowrap: wrapper,
-    });
-
-const forEach = (types: string[], build: () => ElementProp[]): Record<string, ElementProp[]> =>
-    Object.fromEntries(types.map((type) => [type, build()]));
-
-export const BUILT_IN_ELEMENT_COMPONENTS: ElementComponent[] = [
-    { types: ["GtkApplication"], module: "@gtkx/react/internal", export: "createApplicationComponent" },
-    { types: ["GtkWindow"], module: "@gtkx/react/internal", export: "createWindowComponent" },
-    { types: ["AdwDialog"], module: "@gtkx/react/adw", export: "createDialogComponent" },
-];
-
-const CONTROLLER_METHODS = { append: "addController", remove: "removeController" } satisfies ManyMethods;
-const SHORTCUT_METHODS = { append: "addShortcut", remove: "removeShortcut" } satisfies ManyMethods;
-
-const ACTION_METHODS = {
-    append: "addAction",
-    remove: { method: "removeAction", args: [{ prop: "name" }] },
-} satisfies ManyMethods;
-
-const ACTION_GROUP_METHODS = {
-    append: { method: "insertActionGroup", args: [{ prop: "prefix" }, "child"] },
-    remove: { method: "insertActionGroup", args: [{ prop: "prefix" }, { literal: null }] },
-} satisfies ManyMethods;
-
-const SINGLE_CHILD_TYPES = [
-    "AdwBin",
-    "AdwBreakpointBin",
-    "AdwClamp",
-    "AdwClampScrollable",
-    "AdwDialog",
-    "AdwNavigationPage",
-    "AdwSplitButton",
-    "AdwStatusPage",
-    "AdwTabOverview",
-    "AdwToastOverlay",
-    "AdwToggle",
-    "GtkAspectFrame",
-    "GtkButton",
-    "GtkCheckButton",
-    "GtkComboBox",
-    "GtkDragIcon",
-    "GtkExpander",
-    "GtkFlowBoxChild",
-    "GtkFrame",
-    "GtkGraphicsOffload",
-    "GtkListBoxRow",
-    "GtkListHeader",
-    "GtkListItem",
-    "GtkMenuButton",
-    "GtkOverlay",
-    "GtkPopover",
-    "GtkPopoverBin",
-    "GtkRevealer",
-    "GtkScrolledWindow",
-    "GtkSearchBar",
-    "GtkTreeExpander",
-    "GtkViewport",
-    "GtkWindow",
-    "GtkWindowHandle",
-];
-
-const SINGLE_CONTENT_TYPES = [
-    "AdwApplicationWindow",
-    "AdwBottomSheet",
-    "AdwFlap",
-    "AdwNavigationSplitView",
-    "AdwOverlaySplitView",
-    "AdwWindow",
-];
-
-const BOX_TYPES = ["AdwLeaflet", "AdwWrapBox", "GtkBox"];
-
-const ADD_REMOVE_TYPES = [
-    "AdwNavigationView",
-    "AdwPreferencesDialog",
-    "AdwPreferencesGroup",
-    "AdwPreferencesWindow",
-    "AdwSqueezer",
-];
-
-const withBreakpoints = (props: Record<string, ElementProp[]>): Record<string, ElementProp[]> => {
-    for (const type of ["AdwApplicationWindow", "AdwWindow", "AdwDialog"]) {
-        props[type] = [...(props[type] ?? []), container("breakpoints", "AdwBreakpoint", { append: "addBreakpoint" })];
-    }
-    props.AdwBreakpointBin = [
-        ...(props.AdwBreakpointBin ?? []),
-        container("breakpoints", "AdwBreakpoint", { append: "addBreakpoint", remove: "removeBreakpoint" }),
-    ];
-    return props;
-};
-
-export const BUILT_IN_ELEMENT_PROPS: Record<string, ElementProp[]> = withBreakpoints({
-    ...forEach(SINGLE_CHILD_TYPES, () => [singleChild()]),
-    ...forEach(SINGLE_CONTENT_TYPES, () => [singleContent()]),
-    ...forEach(BOX_TYPES, () => [boxChildren()]),
-    ...forEach(ADD_REMOVE_TYPES, () => [addRemoveChildren()]),
-    GtkWidget: [
-        container("controllers", "GtkEventController", CONTROLLER_METHODS),
-        container("layoutManager", "GtkLayoutManager", {
-            append: "setLayoutManager",
-            remove: { method: "setLayoutManager", args: [{ literal: null }] },
-        }),
-        container("actionGroups", "GActionGroup", ACTION_GROUP_METHODS),
-    ],
-    GtkShortcutController: [container("shortcuts", "GtkShortcut", SHORTCUT_METHODS)],
-    GtkTextView: [
-        container("children", "GtkTextBuffer", {
-            append: "setBuffer",
-            remove: { method: "setBuffer", args: [{ literal: null }] },
-        }),
-        container("children", "GtkWidget", { remove: "remove" }),
-    ],
-    GActionMap: [container("actions", "GAction", ACTION_METHODS)],
-    GtkColumnView: [
-        container("children", "GtkColumnViewColumn", {
-            append: "appendColumn",
-            remove: "removeColumn",
-            insert: { method: "insertColumn", args: ["index", "child"] },
-        }),
-    ],
-    AdwShortcutsDialog: [container("children", "AdwShortcutsSection", { append: "add" })],
-    AdwShortcutsSection: [container("children", "AdwShortcutsItem", { append: "add" })],
-    AdwActionRow: prefixSuffixProps(),
-    AdwEntryRow: prefixSuffixProps(),
-    AdwExpanderRow: [
-        ...prefixSuffixProps(),
-        container("rows", "GtkWidget", { append: "addRow" }),
-        container("actions", "GtkWidget", { append: "addAction" }),
-    ],
-    AdwHeaderBar: packProps(),
-    GtkHeaderBar: packProps(),
-    GtkActionBar: packProps(),
-    AdwToolbarView: [
-        container("topBar", "GtkWidget", { append: "addTopBar" }),
-        container("bottomBar", "GtkWidget", { append: "addBottomBar" }),
-        singleContent(),
-    ],
-    AdwCarousel: [indexedChildren("append", "reorder")],
-    AdwPreferencesPage: [indexedChildren("add")],
-    AdwTabView: [
-        container("children", "GtkWidget", {
-            append: "append",
-            insert: { method: "insert", args: ["child", "index"] },
-            reorder: { method: "reorderPage", args: ["adopted", "index"] },
-            remove: { method: "closePage", args: ["adopted"] },
-            adopt: "getPage",
-        }),
-    ],
-    GtkListBox: [autowrapProp("GtkListBoxRow")],
-    GtkFlowBox: [autowrapProp("GtkFlowBoxChild")],
-    GtkStack: [
-        container("children", "GtkWidget", { append: "addChild", remove: "remove", adopt: true }),
-        { kind: "lazy", prop: "visibleChildName", lookup: "getChildByName" },
-    ],
-    AdwViewStack: [
-        container("children", "GtkWidget", { append: "add", remove: "remove", adopt: true }),
-        { kind: "lazy", prop: "visibleChildName", lookup: "getChildByName" },
-    ],
-    GtkNotebook: [
-        container("children", "GtkWidget", {
-            append: { method: "appendPage", args: ["child", { literal: null }] },
-            insert: { method: "insertPage", args: ["child", { literal: null }, "index"] },
-            reorder: { method: "reorderChild", args: ["child", "index"] },
-            remove: "detachTab",
-            adopt: "getPage",
-        }),
-    ],
-    AdwToggleGroup: [
-        container("children", "AdwToggle", { append: "add", remove: "remove" }),
-        { kind: "lazy", prop: "activeName", lookup: "getToggleByName" },
-        { kind: "lazy", prop: "active" },
-    ],
-    GtkDropTarget: [{ kind: "value", prop: "types", call: "setGtypes" }],
-    GtkDrawingArea: [{ kind: "value", prop: "drawFunc", call: "setDrawFunc", after: "queueDraw" }],
-    GtkDragSource: [{ kind: "value", prop: "icon", call: "setIcon" }],
-    GtkEditable: [{ kind: "controlled-text", prop: "text" }],
-    GtkScale: [{ kind: "list", prop: "marks", add: "addMark", clear: "clearMarks" }],
-    GtkCalendar: [{ kind: "list", prop: "markedDays", add: "markDay", clear: "clearMarks" }],
-    GtkLevelBar: [{ kind: "list", prop: "offsets", add: "addOffsetValue", remove: "removeOffsetValue" }],
-    GtkApplication: [
-        container("children", "GtkWindow", { append: "addWindow", remove: "removeWindow" }),
-        {
-            kind: "list",
-            prop: "actionAccels",
-            add: "setAccelsForAction",
-            remove: { method: "setAccelsForAction", args: [{ field: "detailedActionName" }, { literal: [] }] },
-        },
-    ],
-    GtkAboutDialog: [{ kind: "list", prop: "creditSections", add: "addCreditSection" }],
-    AdwAlertDialog: [
-        {
-            kind: "list",
-            prop: "responses",
-            add: [
-                "addResponse",
-                { method: "setResponseAppearance", args: [{ field: "id" }, { field: "appearance", or: 0 }] },
-                { method: "setResponseEnabled", args: [{ field: "id" }, { field: "enabled", or: true }] },
-            ],
-            remove: "removeResponse",
-        },
-    ],
-});

package/src/store/react/element-components.ts

@@ -1,138 +0,0 @@
-import { sourceStringLiteral } from "@gtkx/utils";
-import type { Library } from "../../gir/library.js";
-import type { GirNamespace } from "../../gir/namespace.js";
-import { renderJsDoc } from "../../writer/doc.js";
-import type { ImportsBuilder } from "../../writer/imports.js";
-import { BUILT_IN_ELEMENT_COMPONENTS, type ElementComponent } from "./built-ins.js";
-import type { ElementPropTypegen, LazyElementSpec } from "./element-prop-types.js";
-import { ancestorGlibNames, type GlibNamedClass } from "./intrinsic-elements.js";
-
-type TextNodeElement = {
-    flatName: string;
-    kind: string;
-    propsType: string;
-    parent: string;
-};
-
-const TEXT_NODE_ELEMENTS: TextNodeElement[] = [
-    { flatName: "GtkTextAnchor", kind: "text-anchor", propsType: "TextAnchorProps", parent: "GtkTextView" },
-    { flatName: "GtkTextPaintable", kind: "text-paintable", propsType: "TextPaintableProps", parent: "GtkTextView" },
-];
-
-type ExportCollector = {
-    imports: ImportsBuilder;
-    exportedNames: Set<string>;
-    exportLines: string[];
-};
-
-export const generateElementComponentsSection = (
-    targetNamespace: GirNamespace,
-    library: Library,
-    options: {
-        imports: ImportsBuilder;
-        typegen: ElementPropTypegen;
-        intrinsicElements: GlibNamedClass[];
-        intrinsicElementByGlibName: Map<string, GlibNamedClass>;
-    },
-): { source: string; exportedNames: Set<string> } => {
-    const collector: ExportCollector = { imports: options.imports, exportedNames: new Set(), exportLines: [] };
-
-    const inTargetNamespace = (parentGlibName: string): boolean =>
-        options.intrinsicElementByGlibName.get(parentGlibName)?.namespace.name === targetNamespace.name;
-
-    const lazyElements = options.typegen.lazyElementExports(targetNamespace.name);
-    const textNodes = TEXT_NODE_ELEMENTS.filter((node) => inTargetNamespace(node.parent));
-    const virtualNames = new Set([
-        ...lazyElements.map((entry) => entry.element),
-        ...textNodes.map((node) => node.flatName),
-    ]);
-
-    collectCandidateExports(collector, {
-        targetNamespace,
-        library,
-        virtualNames,
-        intrinsicElements: options.intrinsicElements,
-    });
-    collectLazyElementExports(collector, lazyElements);
-    collectTextNodeExports(collector, textNodes);
-
-    if (textNodes.length > 0) {
-        collector.imports.addNamed("@gtkx/react/internal", "WRAPPER_NODE_ELEMENT", false);
-    }
-    const source = collector.exportLines.join("\n\n");
-    return { source, exportedNames: collector.exportedNames };
-};
-
-type CandidateExportOptions = {
-    targetNamespace: GirNamespace;
-    library: Library;
-    virtualNames: Set<string>;
-    intrinsicElements: GlibNamedClass[];
-};
-
-const collectCandidateExports = (
-    collector: ExportCollector,
-    { targetNamespace, library, virtualNames, intrinsicElements }: CandidateExportOptions,
-): void => {
-    for (const candidate of intrinsicElements) {
-        if (candidate.namespace.name !== targetNamespace.name) continue;
-        if (virtualNames.has(candidate.glibName)) continue;
-        const line = renderCandidateExport(candidate, library, collector.imports);
-        if (line === null) continue;
-        collector.exportLines.push(line);
-        collector.exportedNames.add(candidate.glibName);
-    }
-};
-
-const collectLazyElementExports = (collector: ExportCollector, lazyElements: LazyElementSpec[]): void => {
-    for (const spec of lazyElements) {
-        collector.imports.addNamed("@gtkx/react/internal", "createLazyElementComponent", false);
-        collector.imports.addNamed("react", "ReactNode", true);
-        collector.exportLines.push(renderLazyElementExport(spec));
-        collector.exportedNames.add(spec.element);
-    }
-};
-
-const collectTextNodeExports = (collector: ExportCollector, textNodes: TextNodeElement[]): void => {
-    for (const node of textNodes) {
-        collector.imports.addNamed("@gtkx/react", node.propsType, true);
-        collector.imports.addNamed("react", "ReactNode", true);
-        collector.exportLines.push(renderTextNodeExport(node));
-        collector.exportedNames.add(node.flatName);
-    }
-};
-
-const renderLazyElementExport = (spec: LazyElementSpec): string => {
-    const factory = `createLazyElementComponent<${spec.typeName}>()`;
-    const component = `export const ${spec.element}: (props: ${spec.typeName}) => ReactNode = ${factory};`;
-    return `${spec.typeSource}\n\n${component}`;
-};
-
-const renderTextNodeExport = (node: TextNodeElement): string =>
-    `export const ${node.flatName} = (props: ${node.propsType}): ReactNode => (\n    <WRAPPER_NODE_ELEMENT kind=${sourceStringLiteral(node.kind)} {...props} />\n);`;
-
-const renderCandidateExport = (candidate: GlibNamedClass, library: Library, imports: ImportsBuilder): string | null => {
-    const { glibName, klass, namespace } = candidate;
-    const ancestry = new Set(ancestorGlibNames(klass, namespace, library));
-    const wrapper = resolveElementComponent(ancestry);
-    imports.addNamed("@gtkx/react/internal", "createElementComponent", false);
-    imports.addNamed("react", "ReactNode", true);
-    if (wrapper !== undefined) imports.addNamed(wrapper.module, wrapper.export, false);
-    return `${renderJsDoc(klass.doc)}${renderElementComponentExport(glibName, wrapper)}`;
-};
-
-const resolveElementComponent = (types: Set<string>): ElementComponent | undefined => {
-    for (const entry of BUILT_IN_ELEMENT_COMPONENTS) {
-        if (entry.types.some((type) => types.has(type))) return entry;
-    }
-    return undefined;
-};
-
-const renderElementComponentExport = (glibName: string, wrapper: ElementComponent | undefined): string => {
-    const propsType = `${glibName}Props`;
-    if (wrapper === undefined) {
-        return `export const ${glibName}: (props: ${propsType}) => ReactNode = createElementComponent(${sourceStringLiteral(glibName)});`;
-    }
-    const annotation = `(props: ${propsType}) => ReactNode`;
-    return `export const ${glibName}: ${annotation} = ${wrapper.export}(createElementComponent(${sourceStringLiteral(glibName)}));`;
-};

package/src/store/react/element-prop-types.ts

@@ -1,280 +0,0 @@
-import type { AppliedProp, Call, ContainerProp, ElementProp } from "@gtkx/config";
-import { toCamelIdentifier } from "@gtkx/utils";
-import { renderBaseTypeFor } from "../../analysis/ts-type.js";
-import type { GirClass } from "../../gir/class.js";
-import type { GirNamespace } from "../../gir/namespace.js";
-import type { GirParameter } from "../../gir/parameter.js";
-import { chainOf, findMethod, type GirIndex, type GirTypeEntry, hasProperty } from "./gir-index.js";
-import { glibNameOf } from "./intrinsic-elements.js";
-import { reactTarget } from "./props.js";
-
-type TypeImports = Map<string, string>;
-
-type PropContribution = {
-    child: string;
-    prop: string;
-    param: GirParameter;
-};
-
-export type LazyElementSpec = {
-    element: string;
-    typeName: string;
-    typeSource: string;
-};
-
-export type ElementPropTypegen = {
-    classPropLines: (glibName: string, klass: GirClass, namespace: GirNamespace, imports: TypeImports) => string[];
-    lazyElementExports: (namespaceName: string) => LazyElementSpec[];
-    containerPropNamesFor: (glibName: string) => string[];
-    acceptsChildren: (glibName: string) => boolean;
-};
-
-const forEachContainer = (
-    elementProps: Record<string, ElementProp[]>,
-    visit: (type: string, prop: ContainerProp) => void,
-): void => {
-    for (const [type, props] of Object.entries(elementProps)) {
-        for (const prop of props) {
-            if (prop.kind === "container") visit(type, prop);
-        }
-    }
-};
-
-const renderParamType = (context: GirIndex, imports: TypeImports, param: GirParameter | undefined): string => {
-    if (param === undefined) return "unknown";
-    const base = renderBaseTypeFor(context.library, reactTarget({ library: context.library, imports }), param.type);
-    return param.nullable || param.optional ? `${base} | null` : base;
-};
-
-const optionalLine = (prop: string, type: string): string => {
-    const withNull = type.endsWith(" | null") ? type : `${type} | null`;
-    return `${prop}?: ${withNull} | undefined;`;
-};
-
-type FieldLine = { field: string; text: string };
-
-const callFieldLines = (context: GirIndex, imports: TypeImports, type: string, call: Call): FieldLine[] => {
-    if (typeof call === "string") return [];
-    const method = findMethod(context, type, call.method);
-    const lines: FieldLine[] = [];
-    call.args.forEach((arg, positionIndex) => {
-        if (typeof arg !== "object" || !("field" in arg)) return;
-        const param = method?.params[positionIndex];
-        const optional = "or" in arg || param?.nullable === true || param?.optional === true;
-        lines.push({
-            field: arg.field,
-            text: `${arg.field}${optional ? "?" : ""}: ${renderParamType(context, imports, param)};`,
-        });
-    });
-    return lines;
-};
-
-const mergedFieldsType = (lines: FieldLine[]): string => {
-    const seen = new Set<string>();
-    const texts: string[] = [];
-    for (const line of lines) {
-        if (seen.has(line.field)) continue;
-        seen.add(line.field);
-        texts.push(line.text);
-    }
-    return `{ ${texts.join(" ")} }`;
-};
-
-const callFieldsType = (context: GirIndex, imports: TypeImports, type: string, call: Call | Call[]): string => {
-    if (Array.isArray(call))
-        return mergedFieldsType(call.flatMap((entry) => callFieldLines(context, imports, type, entry)));
-    if (typeof call === "string") {
-        const method = findMethod(context, type, call);
-        return renderParamType(context, imports, method?.params[0]);
-    }
-    const lines = callFieldLines(context, imports, type, call);
-    if (lines.length > 0) return mergedFieldsType(lines);
-    const method = findMethod(context, type, call.method);
-    return renderParamType(context, imports, method?.params[0]);
-};
-
-const appliedPropLine = (context: GirIndex, imports: TypeImports, type: string, prop: AppliedProp): string | null => {
-    if (hasProperty(context, type, prop.prop)) return null;
-    if (prop.kind === "value") return optionalLine(prop.prop, callFieldsType(context, imports, type, prop.call));
-    if (prop.kind === "list") return optionalLine(prop.prop, `${callFieldsType(context, imports, type, prop.add)}[]`);
-    return null;
-};
-
-const collectCallContributions = (
-    context: GirIndex,
-    contributions: PropContribution[],
-    container: { parent: string; child: string },
-    call: Exclude<ContainerProp["append"], string | undefined>,
-): void => {
-    const method = findMethod(context, container.parent, call.method);
-    call.args.forEach((arg, positionIndex) => {
-        if (typeof arg !== "object" || !("prop" in arg)) return;
-        const param = method?.params[positionIndex];
-        if (param === undefined) return;
-        if (hasProperty(context, container.child, arg.prop)) return;
-        if (contributions.some((entry) => entry.child === container.child && entry.prop === arg.prop)) return;
-        contributions.push({ child: container.child, prop: arg.prop, param });
-    });
-};
-
-const collectPropContributions = (
-    context: GirIndex,
-    elementProps: Record<string, ElementProp[]>,
-): PropContribution[] => {
-    const contributions: PropContribution[] = [];
-    forEachContainer(elementProps, (parent, cp) => {
-        for (const call of [cp.append, cp.remove, cp.insert, cp.reorder]) {
-            if (call === undefined || typeof call === "string") continue;
-            collectCallContributions(context, contributions, { parent, child: cp.child }, call);
-        }
-    });
-    return contributions;
-};
-
-const directTypeNames = (context: GirIndex, klass: GirClass, namespace: GirNamespace): Set<string> => {
-    const names = new Set<string>();
-    const glibName = glibNameOf(klass);
-    if (glibName !== undefined) names.add(glibName);
-    for (const name of klass.implements) {
-        const resolved = context.library.resolveType(namespace.name, name);
-        if (resolved === undefined || resolved.kind !== "interface") continue;
-        const ifaceGlib = glibNameOf(resolved.value);
-        if (ifaceGlib !== undefined) names.add(ifaceGlib);
-    }
-    return names;
-};
-
-const constructOnlyNames = (context: GirIndex, entry: GirTypeEntry): string[] => {
-    const names: string[] = [];
-    for (const klass of chainOf(context, entry)) {
-        for (const property of klass.properties) {
-            if (property.constructOnly) names.push(toCamelIdentifier(property.name));
-        }
-    }
-    return names;
-};
-
-const methodReturnGlib = (context: GirIndex, typeName: string, methodCamel: string): string | undefined => {
-    const method = findMethod(context, typeName, methodCamel);
-    const ref = method?.fn.returnValue.type;
-    if (ref === undefined) return undefined;
-    const resolved = context.library.typeOf(ref);
-    if (resolved === undefined || resolved.kind !== "class") return undefined;
-    return glibNameOf(resolved.value);
-};
-
-const resolveAdoptElement = (context: GirIndex, parent: string, cp: ContainerProp): string | undefined => {
-    if (cp.adopt === undefined) return undefined;
-    const source = typeof cp.adopt === "string" ? cp.adopt : cp.append;
-    if (source === undefined) return undefined;
-    const method = typeof source === "string" ? source : source.method;
-    return methodReturnGlib(context, parent, method);
-};
-
-const lazyElementExportOf = (context: GirIndex, element: string): LazyElementSpec => {
-    const typeName = `${element}ElementProps`;
-    const elementClass = context.index.get(element);
-    if (elementClass === undefined) {
-        return { element, typeName, typeSource: `export type ${typeName} = { children?: ReactNode };` };
-    }
-    const baseName = glibNameOf(elementClass.klass) ?? element;
-    const omitted = constructOnlyNames(context, elementClass);
-    const omitUnion = omitted.map((name) => JSON.stringify(name)).join(" | ");
-    const base = omitted.length === 0 ? `${baseName}Props` : `Omit<${baseName}Props, ${omitUnion}>`;
-    return { element, typeName, typeSource: `export type ${typeName} = ${base};` };
-};
-
-const collectLazyElementSpecs = (
-    context: GirIndex,
-    elementProps: Record<string, ElementProp[]>,
-): Map<string, LazyElementSpec[]> => {
-    const specs = new Map<string, LazyElementSpec[]>();
-    forEachContainer(elementProps, (parent, cp) => {
-        const parentEntry = context.index.get(parent);
-        if (parentEntry === undefined) return;
-        const element = resolveAdoptElement(context, parent, cp);
-        if (element === undefined) return;
-        const spec = lazyElementExportOf(context, element);
-        const list = specs.get(parentEntry.namespace.name) ?? [];
-        if (!list.some((existing) => existing.element === spec.element)) list.push(spec);
-        specs.set(parentEntry.namespace.name, list);
-    });
-    return specs;
-};
-
-const collectContainerPropNames = (elementProps: Record<string, ElementProp[]>): Map<string, string[]> => {
-    const containerPropNamesByParent = new Map<string, string[]>();
-    forEachContainer(elementProps, (parent, cp) => {
-        if (cp.prop === "children") return;
-        const names = containerPropNamesByParent.get(parent) ?? [];
-        if (!names.includes(cp.prop)) names.push(cp.prop);
-        containerPropNamesByParent.set(parent, names);
-    });
-    return containerPropNamesByParent;
-};
-
-const TEXT_CONTAINERS = ["GtkLabel", "GtkTextBuffer", "GtkTextTag", "GtkTextView"];
-
-export const createElementPropTypegen = (
-    context: GirIndex,
-    elementProps: Record<string, ElementProp[]>,
-): ElementPropTypegen => {
-    const appliedByType = new Map<string, AppliedProp[]>();
-    for (const [type, props] of Object.entries(elementProps)) {
-        for (const prop of props) {
-            if (prop.kind === "container") continue;
-            const list = appliedByType.get(type) ?? [];
-            list.push(prop);
-            appliedByType.set(type, list);
-        }
-    }
-
-    const propContributions = collectPropContributions(context, elementProps);
-    const lazyElementSpecs = collectLazyElementSpecs(context, elementProps);
-    const containerPropNamesByParent = collectContainerPropNames(elementProps);
-
-    const childrenContainers = new Set<string>(TEXT_CONTAINERS);
-    forEachContainer(elementProps, (parent, cp) => {
-        if (cp.prop === "children") childrenContainers.add(parent);
-        const element = resolveAdoptElement(context, parent, cp);
-        if (element !== undefined) childrenContainers.add(element);
-    });
-
-    const acceptsChildren = (glibName: string): boolean => {
-        if (childrenContainers.has(glibName)) return true;
-        const entry = context.index.get(glibName);
-        if (entry === undefined) return false;
-        const chain = chainOf(context, entry);
-        if (chain.some((klass) => glibNameOf(klass) === "GtkWidget")) return true;
-        return chain.some((klass) => {
-            const name = glibNameOf(klass);
-            return name !== undefined && childrenContainers.has(name);
-        });
-    };
-
-    const classPropLines = (
-        glibName: string,
-        klass: GirClass,
-        namespace: GirNamespace,
-        imports: TypeImports,
-    ): string[] => {
-        const lines: string[] = [];
-        for (const prop of appliedByType.get(glibName) ?? []) {
-            const line = appliedPropLine(context, imports, glibName, prop);
-            if (line !== null) lines.push(line);
-        }
-        const direct = directTypeNames(context, klass, namespace);
-        for (const contribution of propContributions) {
-            if (!direct.has(contribution.child)) continue;
-            lines.push(optionalLine(contribution.prop, renderParamType(context, imports, contribution.param)));
-        }
-        return lines;
-    };
-
-    return {
-        classPropLines,
-        lazyElementExports: (namespaceName) => lazyElementSpecs.get(namespaceName) ?? [],
-        containerPropNamesFor: (glibName) => containerPropNamesByParent.get(glibName) ?? [],
-        acceptsChildren,
-    };
-};