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

package/src/store/react/intrinsic-elements.ts

@@ -1,161 +0,0 @@
-import { sortStringsBy, toCamelIdentifier, upperFirst } from "@gtkx/utils";
-import { ancestorChain } from "../../gir/ancestry.js";
-import type { GirClass } from "../../gir/class.js";
-import type { Library } from "../../gir/library.js";
-import type { GirNamespace } from "../../gir/namespace.js";
-
-export const signalHandlerName = (signalName: string): string => `on${upperFirst(toCamelIdentifier(signalName))}`;
-
-export type GlibNamedClass = {
-    glibName: string;
-    klass: GirClass;
-    namespace: GirNamespace;
-};
-
-export function* iterateClassesWithGlibName(library: Library): IterableIterator<GlibNamedClass> {
-    for (const namespace of library.namespaces.values()) {
-        for (const klass of namespace.classes) {
-            const glibName = glibNameOf(klass);
-            if (glibName === undefined) continue;
-            yield { glibName, klass, namespace };
-        }
-    }
-}
-
-export type ResolvedQualifiedInterface = { klass: GirClass; namespace: GirNamespace };
-
-export const implementedInterfaces = (
-    klass: GirClass,
-    namespace: GirNamespace,
-    library: Library,
-): ResolvedQualifiedInterface[] => {
-    const result: ResolvedQualifiedInterface[] = [];
-    const visited = new Set<string>();
-    const visit = (names: string[], fromNamespace: GirNamespace): void => {
-        for (const name of names) {
-            const resolved = library.resolveType(fromNamespace.name, name);
-            if (resolved === undefined || resolved.kind !== "interface") continue;
-            const key = `${resolved.namespace.name}.${resolved.value.name}`;
-            if (visited.has(key)) continue;
-            visited.add(key);
-            result.push({ klass: resolved.value, namespace: resolved.namespace });
-            visit(resolved.value.prerequisites, resolved.namespace);
-        }
-    };
-    visit(klass.implements, namespace);
-    return result;
-};
-
-export const glibNameOf = (klass: GirClass): string | undefined => klass.glibTypeName ?? klass.cType;
-
-export const giNamespaceAlias = (namespaceName: string): string => `${namespaceName}$`;
-
-export type HasContainerProps = (glibName: string | undefined) => boolean;
-
-const noContainerProps: HasContainerProps = () => false;
-
-export const interfaceHasPropsBody = (
-    klass: GirClass,
-    hasContainerProps: HasContainerProps = noContainerProps,
-): boolean => klass.properties.length > 0 || klass.signals.length > 0 || hasContainerProps(glibNameOf(klass));
-
-const qualifiedInterfaceKey = (iface: ResolvedQualifiedInterface): string =>
-    `${iface.namespace.name}.${iface.klass.name}`;
-
-const parentImplementedInterfaceKeys = (klass: GirClass, namespace: GirNamespace, library: Library): Set<string> => {
-    const keys = new Set<string>();
-    if (klass.parent === undefined) return keys;
-    const resolvedParent = library.resolveType(namespace.name, klass.parent);
-    if (resolvedParent === undefined || resolvedParent.kind !== "class") return keys;
-    for (const iface of implementedInterfaces(resolvedParent.value, resolvedParent.namespace, library)) {
-        keys.add(qualifiedInterfaceKey(iface));
-    }
-    return keys;
-};
-
-export const newlyImplementedInterfaces = (
-    klass: GirClass,
-    namespace: GirNamespace,
-    library: Library,
-    hasContainerProps: HasContainerProps = noContainerProps,
-): ResolvedQualifiedInterface[] => {
-    const inherited = parentImplementedInterfaceKeys(klass, namespace, library);
-    const own = implementedInterfaces(klass, namespace, library).filter(
-        (iface) =>
-            interfaceHasPropsBody(iface.klass, hasContainerProps) && !inherited.has(qualifiedInterfaceKey(iface)),
-    );
-    return sortStringsBy(own, qualifiedInterfaceKey);
-};
-
-export const collectInterfacePropsClasses = (
-    library: Library,
-    intrinsicElements: GlibNamedClass[],
-    targetNamespaceName: string,
-    hasContainerProps: HasContainerProps = noContainerProps,
-): ResolvedQualifiedInterface[] => {
-    const seen = new Set<string>();
-    const result: ResolvedQualifiedInterface[] = [];
-    for (const intrinsicElement of intrinsicElements) {
-        for (const iface of implementedInterfaces(intrinsicElement.klass, intrinsicElement.namespace, library)) {
-            const key = qualifiedInterfaceKey(iface);
-            if (seen.has(key)) continue;
-            seen.add(key);
-            if (!interfaceHasPropsBody(iface.klass, hasContainerProps)) continue;
-            if (iface.namespace.name !== targetNamespaceName) continue;
-            result.push(iface);
-        }
-    }
-    return sortStringsBy(result, qualifiedInterfaceKey);
-};
-
-export const ancestorGlibNames = (klass: GirClass, namespace: GirNamespace, library: Library): string[] => {
-    const names: string[] = [];
-    for (const { klass: ancestor } of ancestorChain(library, klass, namespace.name)) {
-        const glibName = glibNameOf(ancestor);
-        if (glibName !== undefined) names.push(glibName);
-    }
-    return names;
-};
-
-const someAncestor = (
-    klass: GirClass,
-    namespace: GirNamespace,
-    library: Library,
-    predicate: (klass: GirClass, glibName: string) => boolean,
-): boolean => {
-    for (const { klass: ancestor } of ancestorChain(library, klass, namespace.name)) {
-        const glibName = glibNameOf(ancestor) ?? "";
-        if (predicate(ancestor, glibName)) return true;
-    }
-    return false;
-};
-
-const descendsFrom = (
-    klass: GirClass,
-    namespace: GirNamespace,
-    library: Library,
-    matches: (glibName: string) => boolean,
-): boolean => someAncestor(klass, namespace, library, (_klass, glibName) => matches(glibName));
-
-export const classExposesMethod = (
-    klass: GirClass,
-    namespace: GirNamespace,
-    library: Library,
-    methodName: string,
-): boolean => someAncestor(klass, namespace, library, (current) => current.methods.some((m) => m.name === methodName));
-
-export const isIntrinsicElementClass = (klass: GirClass, namespace: GirNamespace, library: Library): boolean =>
-    descendsFrom(klass, namespace, library, (glibName) => glibName === "GObject");
-
-export const collectIntrinsicElementClasses = (library: Library): GlibNamedClass[] => {
-    const seen = new Set<string>();
-    const entries: GlibNamedClass[] = [];
-    for (const candidate of iterateClassesWithGlibName(library)) {
-        const { glibName, klass, namespace } = candidate;
-        if (!isIntrinsicElementClass(klass, namespace, library)) continue;
-        if (seen.has(glibName)) continue;
-        seen.add(glibName);
-        entries.push(candidate);
-    }
-    return sortStringsBy(entries, (entry) => entry.glibName);
-};

package/src/store/react/metadata.ts

@@ -1,197 +0,0 @@
-import type { ElementProp } from "@gtkx/config";
-import { sortStringsBy, sourceStringLiteral, toCamelIdentifier } from "@gtkx/utils";
-import { inputParameters } from "../../analysis/param-structure.js";
-import type { GirClass } from "../../gir/class.js";
-import type { GirEnum } from "../../gir/enum.js";
-import type { Library } from "../../gir/library.js";
-import type { PrimitiveCategory } from "../../gir/primitives.js";
-import { type GirProperty, isConstructableProperty } from "../../gir/property.js";
-import type { TypeId } from "../../gir/type-id.js";
-import {
-    implementedInterfaces,
-    isIntrinsicElementClass,
-    iterateClassesWithGlibName,
-    signalHandlerName,
-} from "./intrinsic-elements.js";
-
-export const generateMetadata = (library: Library, elementProps: Record<string, ElementProp[]>): string => {
-    const intrinsicElements = collectIntrinsicElements(library);
-    const signalsEntries = intrinsicElements.map(
-        ({ glibName, signals }) => `    "${glibName}": ${renderSignalsObject(signals)},`,
-    );
-    const constructOnlyEntries = intrinsicElements
-        .filter(({ constructOnly }) => constructOnly.length > 0)
-        .map(({ glibName, constructOnly }) => `    "${glibName}": ${renderStringSet(constructOnly)},`);
-    const constructableEntries = intrinsicElements
-        .filter(({ constructable }) => constructable.length > 0)
-        .map(({ glibName, constructable }) => `    "${glibName}": ${renderStringSet(constructable)},`);
-    const defaultsEntries = intrinsicElements
-        .filter(({ defaults }) => defaults.length > 0)
-        .map(({ glibName, defaults }) => `    "${glibName}": ${renderDefaultsObject(defaults)},`);
-
-    return `${[
-        `export const SIGNALS: Record<string, Record<string, string>> = {\n${signalsEntries.join("\n")}\n};`,
-        `export const CONSTRUCT_ONLY_PROPS: Record<string, Set<string>> = {\n${constructOnlyEntries.join("\n")}\n};`,
-        `export const CONSTRUCT_PROPS: Record<string, Set<string>> = {\n${constructableEntries.join("\n")}\n};`,
-        `export const DEFAULT_PROPS: Record<string, Record<string, unknown>> = {\n${defaultsEntries.join("\n")}\n};`,
-        `export const ELEMENT_PROPS: Record<string, Array<import("@gtkx/react").ElementProp>> = ${JSON.stringify(elementProps, null, 4)};`,
-    ].join("\n\n")}\n`;
-};
-
-type IntrinsicElementEntry = {
-    glibName: string;
-    signals: [string, string][];
-    constructOnly: string[];
-    constructable: string[];
-    defaults: [string, string][];
-};
-
-const collectIntrinsicElements = (library: Library): IntrinsicElementEntry[] => {
-    const entries: IntrinsicElementEntry[] = [];
-    for (const { glibName, klass, namespace } of iterateClassesWithGlibName(library)) {
-        if (!isIntrinsicElementClass(klass, namespace, library)) continue;
-        const sources: GirClass[] = [
-            klass,
-            ...implementedInterfaces(klass, namespace, library).map((entry) => entry.klass),
-        ];
-        entries.push({
-            glibName,
-            signals: collectSignals(sources),
-            constructOnly: collectConstructOnly(sources),
-            constructable: collectConstructable(sources),
-            defaults: collectDefaultProps(library, sources),
-        });
-    }
-    return sortStringsBy(entries, (entry) => entry.glibName);
-};
-
-const collectSignals = (sources: GirClass[]): [string, string][] => {
-    const seen = new Set<string>();
-    const signals: [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 collectPropNames = (sources: GirClass[], keep: (property: GirProperty) => boolean): string[] => {
-    const seen = new Set<string>();
-    const names: string[] = [];
-    for (const source of sources) {
-        for (const property of source.properties) {
-            if (!keep(property)) continue;
-            const jsName = toCamelIdentifier(property.name);
-            if (seen.has(jsName)) continue;
-            seen.add(jsName);
-            names.push(jsName);
-        }
-    }
-    return names;
-};
-
-const collectConstructOnly = (sources: GirClass[]): string[] =>
-    collectPropNames(sources, (property) => property.constructOnly && property.introspectable);
-
-const collectConstructable = (sources: GirClass[]): string[] => collectPropNames(sources, isConstructableProperty);
-
-const renderObjectLiteral = (entries: [string, string][], renderValue: (value: string) => string): string => {
-    if (entries.length === 0) return "{}";
-    const lines = entries.map(([key, value]) => `        ${sourceStringLiteral(key)}: ${renderValue(value)}`);
-    return `{\n${lines.join(",\n")}\n    }`;
-};
-
-const renderStringSet = (names: string[]): string => `new Set([${names.map(sourceStringLiteral).join(",")}])`;
-
-const renderSignalsObject = (entries: [string, string][]): string => renderObjectLiteral(entries, sourceStringLiteral);
-
-const collectDefaultProps = (library: Library, sources: GirClass[]): [string, string][] => {
-    const seen = new Set<string>();
-    const defaults: [string, string][] = [];
-    for (const klass of sources) {
-        for (const property of klass.properties) {
-            const settable = (property.writable || property.construct) && !property.constructOnly;
-            if (!settable || !property.introspectable) continue;
-            const jsName = toCamelIdentifier(property.name);
-            if (seen.has(jsName)) continue;
-            seen.add(jsName);
-            const literal = renderDefaultLiteral(library, klass, property);
-            if (literal === undefined) continue;
-            defaults.push([jsName, literal] as const);
-        }
-    }
-    return defaults;
-};
-
-const setterRejectsNull = (library: Library, klass: GirClass, property: GirProperty): boolean => {
-    if (property.setter === undefined) return false;
-    const setter = klass.methods.find((method) => method.name === property.setter);
-    if (setter === undefined) return false;
-    const [value] = inputParameters(library, setter);
-    return value !== undefined && !value.parameter.nullable && !value.parameter.optional;
-};
-
-const renderDefaultLiteral = (library: Library, klass: GirClass, property: GirProperty): string | undefined => {
-    if (property.defaultValue === "NULL" && setterRejectsNull(library, klass, property)) return undefined;
-    return resolveDefaultLiteral(library, property.type, property.defaultValue);
-};
-
-const resolveDefaultLiteral = (
-    library: Library,
-    ref: TypeId | undefined,
-    raw: string | undefined,
-): string | undefined => {
-    if (raw === undefined) return undefined;
-    if (raw === "NULL") return "null";
-    if (ref === undefined) return undefined;
-    const resolved = library.typeOf(ref);
-    if (resolved === undefined) return undefined;
-    if (resolved.kind === "primitive") return primitiveDefaultLiteral(resolved.category, raw);
-    if (resolved.kind === "enum") return enumDefaultLiteral(resolved.value, raw);
-    if (resolved.kind === "alias") return resolveDefaultLiteral(library, resolved.value.target, raw);
-    return undefined;
-};
-
-const INTEGER_PATTERN = /^-?\d+$/;
-
-const primitiveDefaultLiteral = (category: PrimitiveCategory, raw: string): string | undefined => {
-    switch (category) {
-        case "boolean":
-            if (raw === "TRUE") return "true";
-            if (raw === "FALSE") return "false";
-            return undefined;
-        case "int8":
-        case "int16":
-        case "int32":
-        case "uint8":
-        case "uint16":
-        case "uint32":
-        case "int64":
-        case "uint64":
-        case "unichar":
-            return INTEGER_PATTERN.test(raw.trim()) ? raw.trim() : undefined;
-        case "float32":
-        case "float64": {
-            const value = Number.parseFloat(raw);
-            return Number.isFinite(value) ? String(value) : undefined;
-        }
-        case "string":
-            return sourceStringLiteral(raw);
-        default:
-            return undefined;
-    }
-};
-
-const enumDefaultLiteral = (enumType: GirEnum, raw: string): string | undefined => {
-    const trimmed = raw.trim();
-    if (INTEGER_PATTERN.test(trimmed)) return trimmed;
-    const member = enumType.members.find((entry) => entry.cIdentifier === trimmed || entry.name === trimmed);
-    return member?.value;
-};
-
-const renderDefaultsObject = (entries: [string, string][]): string =>
-    renderObjectLiteral(entries, (literal) => literal);

package/src/store/react/pipeline.ts

@@ -1,90 +0,0 @@
-import type { ElementProp } from "@gtkx/config";
-import { sortStringsBy } from "@gtkx/utils";
-import type { Library } from "../../gir/library.js";
-import { type GirNamespace, namespaceDirectory } from "../../gir/namespace.js";
-import { ImportsBuilder } from "../../writer/imports.js";
-import { generateElementComponentsSection } from "./element-components.js";
-import { createElementPropTypegen, type ElementPropTypegen } from "./element-prop-types.js";
-import { assembleElementProps } from "./element-props.js";
-import { buildGirIndex } from "./gir-index.js";
-import { collectIntrinsicElementClasses, type GlibNamedClass } from "./intrinsic-elements.js";
-import { generateJsxSection } from "./jsx.js";
-import { generateMetadata } from "./metadata.js";
-
-export type JsxNamespaceFile = {
-    directory: string;
-    source: string;
-};
-
-type JsxFiles = {
-    namespaces: JsxNamespaceFile[];
-    metadata: string;
-    intrinsicElementCount: number;
-};
-
-export const generateJsxFiles = (library: Library, userElementProps?: Record<string, ElementProp[]>): JsxFiles => {
-    const intrinsicElements = collectIntrinsicElementClasses(library);
-    const intrinsicElementByGlibName = new Map(intrinsicElements.map((entry) => [entry.glibName, entry]));
-    const namespacesWithIntrinsicElements = new Map<string, GirNamespace>();
-    for (const entry of intrinsicElements) {
-        namespacesWithIntrinsicElements.set(entry.namespace.name, entry.namespace);
-    }
-
-    const girIndex = buildGirIndex(library);
-    const elementProps = assembleElementProps(girIndex, userElementProps ?? {});
-    const typegen = createElementPropTypegen(girIndex, elementProps);
-
-    const namespaces: JsxNamespaceFile[] = [];
-    let intrinsicElementCount = 0;
-    for (const namespace of sortStringsBy(namespacesWithIntrinsicElements.values(), (entry) => entry.name)) {
-        const { source, count } = generateJsxNamespace(namespace, library, {
-            typegen,
-            intrinsicElements,
-            intrinsicElementByGlibName,
-        });
-        namespaces.push({ directory: namespaceDirectory(namespace), source });
-        intrinsicElementCount += count;
-    }
-
-    const metadata = generateMetadata(library, elementProps);
-
-    return { namespaces, metadata, intrinsicElementCount };
-};
-
-type JsxNamespaceContext = {
-    typegen: ElementPropTypegen;
-    intrinsicElements: GlibNamedClass[];
-    intrinsicElementByGlibName: Map<string, GlibNamedClass>;
-};
-
-const generateJsxNamespace = (
-    targetNamespace: GirNamespace,
-    library: Library,
-    context: JsxNamespaceContext,
-): { source: string; count: number } => {
-    const { typegen, intrinsicElements, intrinsicElementByGlibName } = context;
-    const targetDirectory = namespaceDirectory(targetNamespace);
-    const imports = new ImportsBuilder();
-    imports.addSideEffect(`@gtkx/gi/${targetDirectory}`);
-
-    const elementComponents = generateElementComponentsSection(targetNamespace, library, {
-        imports,
-        typegen,
-        intrinsicElements,
-        intrinsicElementByGlibName,
-    });
-    const excludeNames = new Set<string>(elementComponents.exportedNames);
-    const { source: jsxSection, intrinsicCount } = generateJsxSection(targetNamespace, library, {
-        excludeNames,
-        imports,
-        typegen,
-        intrinsicElements,
-        intrinsicElementByGlibName,
-    });
-
-    const body = [imports.toSource().trimEnd(), "", jsxSection];
-    if (elementComponents.source.length > 0) body.push("", elementComponents.source);
-
-    const count = elementComponents.exportedNames.size + intrinsicCount;
-    return { source: `${body.join("\n")}\n`, count };
-};

package/src/store/react/props.ts

@@ -1,197 +0,0 @@
-import { toCamelIdentifier, upperFirst } from "@gtkx/utils";
-import { forEachAncestor } from "../../analysis/inheritance.js";
-import { renderHandlerParameters, renderHandlerResultType } from "../../analysis/param-structure.js";
-import { renderBaseTypeFor, type TsTypeTarget } from "../../analysis/ts-type.js";
-import type { GirClass } from "../../gir/class.js";
-import type { Library } from "../../gir/library.js";
-import type { GirNamespace } from "../../gir/namespace.js";
-import type { GirSignal } from "../../gir/parameter.js";
-import { type GirProperty, isConstructableProperty } from "../../gir/property.js";
-import type { TypeId } from "../../gir/type-id.js";
-import { renderJsDoc } from "../../writer/doc.js";
-import {
-    classExposesMethod,
-    giNamespaceAlias,
-    isIntrinsicElementClass,
-    signalHandlerName,
-} from "./intrinsic-elements.js";
-
-type IntrinsicElementPropsEntries = {
-    propLines: string[];
-    imports: Map<string, string>;
-    objectPropNames: string[];
-};
-
-type IntrinsicElementPropsOptions = {
-    library: Library;
-    klass: GirClass;
-    namespace: GirNamespace;
-    isIntrinsicElementAncestor?: (candidate: GirClass) => boolean;
-};
-
-type PropTypeRenderContext = {
-    library: Library;
-    imports: Map<string, string>;
-};
-
-type SignalRenderOptions = {
-    types: PropTypeRenderContext;
-    signal: GirSignal;
-    selfType: string;
-};
-
-type PropEntryCollector = {
-    propLines: string[];
-    imports: Map<string, string>;
-    objectPropNames: string[];
-    acceptProperty: (property: GirProperty) => void;
-    acceptSignal: (signal: GirSignal) => void;
-};
-
-const createPropEntryCollector = (owner: PropOwner): PropEntryCollector => {
-    const { library } = owner;
-    const imports = new Map<string, string>();
-    const types: PropTypeRenderContext = { library, imports };
-    const propLines: string[] = [];
-    const objectPropNames: string[] = [];
-    const seen = new Set<string>();
-
-    const acceptProperty = (property: GirProperty): void => {
-        if (!property.introspectable) return;
-        const jsName = toCamelIdentifier(property.name);
-        if (seen.has(jsName)) return;
-        seen.add(jsName);
-        const tsType = renderReactPropType(types, property.type, false);
-        const doc = renderJsDoc(property.doc);
-        if (isObjectProp(owner, property, jsName)) {
-            propLines.push(`${doc}${jsName}?: ${tsType} | ReactElement | null | undefined;`);
-            objectPropNames.push(jsName);
-            return;
-        }
-        const settable = isConstructableProperty(property);
-        if (settable) propLines.push(`${doc}${jsName}?: ${tsType} | null | undefined;`);
-        propLines.push(
-            `${settable ? "" : doc}onNotify${upperFirst(jsName)}?: ((value: ${tsType} | null, self: Self) => void) | null | undefined;`,
-        );
-    };
-
-    const acceptSignal = (signal: GirSignal): void => {
-        const handlerName = signalHandlerName(signal.name);
-        if (seen.has(handlerName)) return;
-        seen.add(handlerName);
-        const signature = renderSignalHandler({ types, signal, selfType: "Self" });
-        propLines.push(`${renderJsDoc(signal.doc)}${handlerName}?: (${signature}) | undefined;`);
-    };
-
-    return { propLines, imports, objectPropNames, acceptProperty, acceptSignal };
-};
-
-export const buildElementPropsEntries = (options: IntrinsicElementPropsOptions): IntrinsicElementPropsEntries => {
-    const { library, klass, namespace, isIntrinsicElementAncestor = () => false } = options;
-    const collector = createPropEntryCollector({ library, klass, namespace });
-    walkIntrinsicElementMembers({
-        library,
-        klass,
-        namespace,
-        isIntrinsicElementAncestor,
-        acceptProperty: collector.acceptProperty,
-        acceptSignal: collector.acceptSignal,
-    });
-    return { propLines: collector.propLines, imports: collector.imports, objectPropNames: collector.objectPropNames };
-};
-
-type InterfacePropsOptions = {
-    library: Library;
-    iface: GirClass;
-    namespace: GirNamespace;
-};
-
-export const buildInterfacePropsEntries = (options: InterfacePropsOptions): IntrinsicElementPropsEntries => {
-    const { library, iface, namespace } = options;
-    const collector = createPropEntryCollector({ library, klass: iface, namespace });
-    for (const property of iface.properties) collector.acceptProperty(property);
-    for (const signal of iface.signals) collector.acceptSignal(signal);
-    return { propLines: collector.propLines, imports: collector.imports, objectPropNames: collector.objectPropNames };
-};
-
-type IntrinsicElementMemberWalk = {
-    library: Library;
-    klass: GirClass;
-    namespace: GirNamespace;
-    isIntrinsicElementAncestor: (candidate: GirClass) => boolean;
-    acceptProperty: (property: GirProperty) => void;
-    acceptSignal: (signal: GirSignal) => void;
-};
-
-const walkIntrinsicElementMembers = (walk: IntrinsicElementMemberWalk): void => {
-    const { library, klass, namespace, isIntrinsicElementAncestor, acceptProperty, acceptSignal } = walk;
-    const visitMembers = (memberClass: GirClass): void => {
-        for (const property of memberClass.properties) acceptProperty(property);
-        for (const signal of memberClass.signals) acceptSignal(signal);
-    };
-    const ancestry = { library, namespace };
-    visitMembers(klass);
-    forEachAncestor(ancestry, klass, (ancestor) => visitMembers(ancestor.klass), isIntrinsicElementAncestor);
-};
-
-const resolvesToGObjectClass = (library: Library, ref: TypeId | undefined): boolean => {
-    if (ref === undefined) return false;
-    const resolved = library.typeOf(ref);
-    if (resolved?.kind !== "class") return false;
-    return isIntrinsicElementClass(resolved.value, resolved.namespace, library);
-};
-
-type PropOwner = {
-    library: Library;
-    klass: GirClass;
-    namespace: GirNamespace;
-};
-
-export const isObjectProp = (owner: PropOwner, property: GirProperty, jsName: string): boolean => {
-    if (!property.writable || property.constructOnly) return false;
-    if (!resolvesToGObjectClass(owner.library, property.type)) return false;
-    if (jsName === "child" && classExposesMethod(owner.klass, owner.namespace, owner.library, "set_child")) {
-        return false;
-    }
-    return true;
-};
-
-const renderSignalHandler = (options: SignalRenderOptions): string => {
-    const { types, signal, selfType } = options;
-    const params = [
-        ...renderHandlerParameters(signal.parameters, (ref, nullable) => renderReactPropType(types, ref, nullable)),
-        `self: ${selfType}`,
-    ];
-    const result = renderHandlerResultType({
-        library: types.library,
-        signal,
-        renderType: (ref, nullable) => renderReactPropType(types, ref, nullable),
-        includeCallerAllocated: false,
-        optOut: true,
-    });
-    return `(${params.join(", ")}) => ${result}`;
-};
-
-export const reactTarget = (context: PropTypeRenderContext): TsTypeTarget => ({
-    containerStyle: "record",
-    callbackType: "((...args: unknown[]) => unknown)",
-    byteArrayAsNumber: false,
-    renderNamed: (resolved, name) => {
-        if (resolved?.kind === "alias") {
-            return resolved.value.target === undefined
-                ? "number"
-                : renderBaseTypeFor(context.library, reactTarget(context), resolved.value.target);
-        }
-        context.imports.set(name.namespaceName, giNamespaceAlias(name.namespaceName));
-        return `${giNamespaceAlias(name.namespaceName)}.${name.typeName}`;
-    },
-    renderGtype: () => {
-        context.imports.set("GObject", giNamespaceAlias("GObject"));
-        return `${giNamespaceAlias("GObject")}.Type`;
-    },
-});
-
-const renderReactPropType = (context: PropTypeRenderContext, ref: TypeId | undefined, isNullable: boolean): string => {
-    const base = renderBaseTypeFor(context.library, reactTarget(context), ref);
-    return isNullable ? `${base} | null` : base;
-};