@gtkx/codegen 0.21.0 → 1.0.0-rc.1

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

@@ -0,0 +1,161 @@
+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/jsx.ts

@@ -0,0 +1,294 @@
+import { sourceStringLiteral } from "@gtkx/utils";
+import type { GirClass } from "../../gir/class.js";
+import type { Library } from "../../gir/library.js";
+import type { GirNamespace } from "../../gir/namespace.js";
+import { renderJsDoc } from "../../writer/doc.js";
+import { renderBlock } from "../../writer/emit.js";
+import type { ImportsBuilder } from "../../writer/imports.js";
+import type { ElementPropTypegen } from "./element-prop-types.js";
+import {
+    collectInterfacePropsClasses,
+    type GlibNamedClass,
+    giNamespaceAlias,
+    glibNameOf,
+    type HasContainerProps,
+    interfaceHasPropsBody,
+    newlyImplementedInterfaces,
+    type ResolvedQualifiedInterface,
+} from "./intrinsic-elements.js";
+import { buildElementPropsEntries, buildInterfacePropsEntries } from "./props.js";
+
+type GenerateJsxOptions = {
+    excludeNames: Set<string>;
+    imports: ImportsBuilder;
+    typegen: ElementPropTypegen;
+    intrinsicElements: GlibNamedClass[];
+    intrinsicElementByGlibName: Map<string, GlibNamedClass>;
+};
+
+const ACCESSIBLE_INTERFACE_GLIB_NAME = "GtkAccessible";
+
+const ACCESSIBLE_PROPS_NAME = "AccessibleProps";
+
+const addGiNamespace = (imports: ImportsBuilder, namespaceName: string, alias: string): void => {
+    if (namespaceName === "") return;
+    imports.addNamespace(`@gtkx/gi/${namespaceName.toLowerCase()}`, alias, true);
+};
+
+const addReactBuiltin = (imports: ImportsBuilder, name: string): void => {
+    imports.addNamed("react", name, true);
+};
+
+const propLineName = (line: string): string | undefined => {
+    const declaration = line.slice(line.lastIndexOf("\n") + 1);
+    return declaration.split(/[?:]/, 1)[0]?.trim() || undefined;
+};
+
+const dedupePropLines = (lines: string[]): string[] => {
+    const seen = new Set<string>();
+    const result: string[] = [];
+    for (const line of lines) {
+        const name = propLineName(line);
+        if (name !== undefined && seen.has(name)) continue;
+        if (name !== undefined) seen.add(name);
+        result.push(line);
+    }
+    return result;
+};
+
+export const generateJsxSection = (
+    targetNamespace: GirNamespace,
+    library: Library,
+    options: GenerateJsxOptions,
+): { source: string; intrinsicCount: number } => {
+    const { excludeNames, imports, typegen, intrinsicElements, intrinsicElementByGlibName } = options;
+    const namespaceElements = intrinsicElements.filter((entry) => entry.namespace.name === targetNamespace.name);
+    const intrinsicElementConsts = namespaceElements.filter((entry) => !excludeNames.has(entry.glibName));
+    const constLines = intrinsicElementConsts.map(
+        (entry) => `export const ${entry.glibName} = ${sourceStringLiteral(entry.glibName)} as const;`,
+    );
+
+    const isIntrinsicElementAncestor = (candidate: GirClass): boolean => {
+        const candidateGlib = glibNameOf(candidate);
+        return candidateGlib !== undefined && intrinsicElementByGlibName.has(candidateGlib);
+    };
+    addReactBuiltin(imports, "ReactNode");
+    addReactBuiltin(imports, "Ref");
+
+    const interfaceResult = renderInterfacePropBlocks(library, targetNamespace.name, options);
+    let needsReactElement = interfaceResult.needsReactElement;
+    const propBlocks: string[] = [...interfaceResult.blocks];
+
+    const blockContext: RenderPropBlockContext = {
+        isIntrinsicElementAncestor,
+        intrinsicElementByGlibName,
+        targetNamespaceName: targetNamespace.name,
+        imports,
+        typegen,
+        hasContainerProps: interfaceResult.hasContainerProps,
+    };
+    for (const entry of namespaceElements) {
+        const { block, objectPropNames } = renderPropBlock(library, entry, blockContext);
+        if (objectPropNames.length > 0) needsReactElement = true;
+        propBlocks.push(block);
+    }
+    if (needsReactElement) addReactBuiltin(imports, "ReactElement");
+
+    const source = [
+        constLines.join("\n"),
+        "",
+        propBlocks.join("\n\n"),
+        "",
+        renderJsxAugmentation(namespaceElements),
+    ].join("\n");
+    return { source, intrinsicCount: intrinsicElementConsts.length };
+};
+
+type InterfaceBlockContext = {
+    library: Library;
+    targetNamespaceName: string;
+    imports: ImportsBuilder;
+    typegen: ElementPropTypegen;
+    hasContainerProps: HasContainerProps;
+};
+
+const renderInterfacePropBlocks = (
+    library: Library,
+    targetNamespaceName: string,
+    options: GenerateJsxOptions,
+): { blocks: string[]; needsReactElement: boolean; hasContainerProps: HasContainerProps } => {
+    const { imports, typegen, intrinsicElements } = options;
+    const hasContainerProps: HasContainerProps = (glibName) =>
+        glibName !== undefined && typegen.containerPropNamesFor(glibName).length > 0;
+    const context: InterfaceBlockContext = { library, targetNamespaceName, imports, typegen, hasContainerProps };
+    const blocks: string[] = [];
+    let needsReactElement = false;
+    for (const iface of collectInterfacePropsClasses(
+        library,
+        intrinsicElements,
+        targetNamespaceName,
+        hasContainerProps,
+    )) {
+        if (glibNameOf(iface.klass) === undefined) continue;
+        const { block, objectPropNames } = renderInterfacePropsBlock(iface, context);
+        if (objectPropNames.length > 0) needsReactElement = true;
+        blocks.push(block);
+    }
+    return { blocks, needsReactElement, hasContainerProps };
+};
+
+const registerCrossNsProps = (
+    imports: ImportsBuilder,
+    targetNamespaceName: string,
+    namespaceName: string,
+    propsName: string,
+): void => {
+    if (namespaceName === targetNamespaceName) return;
+    imports.addNamed(`@gtkx/jsx/${namespaceName.toLowerCase()}`, propsName, true);
+};
+
+const interfacePropsRef = (
+    iface: ResolvedQualifiedInterface,
+    targetNamespaceName: string,
+    imports: ImportsBuilder,
+): string | undefined => {
+    const glib = glibNameOf(iface.klass);
+    if (glib === undefined) return undefined;
+    registerCrossNsProps(imports, targetNamespaceName, iface.namespace.name, `${glib}Props`);
+    return `${glib}Props<Self>`;
+};
+
+const interfacePrerequisiteExtends = (iface: ResolvedQualifiedInterface, context: InterfaceBlockContext): string[] => {
+    const { library, targetNamespaceName, imports, hasContainerProps } = context;
+    const refs: string[] = [];
+    for (const prerequisiteName of iface.klass.prerequisites) {
+        const resolved = library.resolveType(iface.namespace.name, prerequisiteName);
+        if (resolved === undefined || resolved.kind !== "interface") continue;
+        if (!interfaceHasPropsBody(resolved.value, hasContainerProps)) continue;
+        const ref = interfacePropsRef(
+            { klass: resolved.value, namespace: resolved.namespace },
+            targetNamespaceName,
+            imports,
+        );
+        if (ref !== undefined) refs.push(ref);
+    }
+    return refs;
+};
+
+const renderInterfacePropsBlock = (
+    iface: ResolvedQualifiedInterface,
+    context: InterfaceBlockContext,
+): { block: string; objectPropNames: string[] } => {
+    const { library, imports, typegen } = context;
+    const glib = glibNameOf(iface.klass);
+    const {
+        propLines,
+        imports: propImports,
+        objectPropNames,
+    } = buildInterfacePropsEntries({
+        library,
+        iface: iface.klass,
+        namespace: iface.namespace,
+    });
+    for (const [namespace, alias] of propImports) addGiNamespace(imports, namespace, alias);
+    const containerPropNames = glib === undefined ? [] : typegen.containerPropNamesFor(glib);
+    const containerPropLines = containerPropNames.map((propName) => `${propName}?: ReactNode | null | undefined;`);
+    const ownerLines = dedupePropLines([...propLines, ...containerPropLines]);
+    const prerequisiteExtends = interfacePrerequisiteExtends(iface, context);
+    if (glib === ACCESSIBLE_INTERFACE_GLIB_NAME) {
+        imports.addNamed("@gtkx/react", ACCESSIBLE_PROPS_NAME, true);
+        prerequisiteExtends.push(ACCESSIBLE_PROPS_NAME);
+    }
+    const extendsClause = prerequisiteExtends.length === 0 ? "" : ` extends ${prerequisiteExtends.join(", ")}`;
+    addGiNamespace(imports, iface.namespace.name, giNamespaceAlias(iface.namespace.name));
+    const selfDefault = `${giNamespaceAlias(iface.namespace.name)}.${iface.klass.name}`;
+    const block = `${renderJsDoc(iface.klass.doc)}${renderBlock(
+        `export interface ${glib}Props<Self = ${selfDefault}>${extendsClause}`,
+        ownerLines.join("\n"),
+    )}`;
+    return { block, objectPropNames };
+};
+
+const renderJsxAugmentation = (namespaceElements: GlibNamedClass[]): string => {
+    const elementLines = namespaceElements.map((entry) => `${entry.glibName}: ${entry.glibName}Props;`).join("\n");
+    const intrinsicInterface = renderBlock("interface IntrinsicElements", elementLines);
+    const reactJsxNamespace = renderBlock("namespace React.JSX", intrinsicInterface);
+    return renderBlock("declare global", reactJsxNamespace);
+};
+
+type RenderPropBlockContext = {
+    isIntrinsicElementAncestor: (candidate: GirClass) => boolean;
+    intrinsicElementByGlibName: Map<string, GlibNamedClass>;
+    targetNamespaceName: string;
+    imports: ImportsBuilder;
+    typegen: ElementPropTypegen;
+    hasContainerProps: (glibName: string | undefined) => boolean;
+};
+
+const renderPropBlock = (
+    library: Library,
+    entry: GlibNamedClass,
+    context: RenderPropBlockContext,
+): { block: string; objectPropNames: string[] } => {
+    const containerPropNames = context.typegen.containerPropNamesFor(entry.glibName);
+    const { propLines, imports, objectPropNames } = buildElementPropsEntries({
+        library,
+        klass: entry.klass,
+        namespace: entry.namespace,
+        isIntrinsicElementAncestor: context.isIntrinsicElementAncestor,
+    });
+    for (const [namespace, alias] of imports) addGiNamespace(context.imports, namespace, alias);
+    addGiNamespace(context.imports, entry.namespace.name, giNamespaceAlias(entry.namespace.name));
+    const elementPropImports = new Map<string, string>();
+    const elementPropLines = context.typegen.classPropLines(
+        entry.glibName,
+        entry.klass,
+        entry.namespace,
+        elementPropImports,
+    );
+    for (const [namespace, alias] of elementPropImports) addGiNamespace(context.imports, namespace, alias);
+    const containerPropLines = containerPropNames.map((propName) => `${propName}?: ReactNode | null | undefined;`);
+    const ownerLines = dedupePropLines([
+        ...(context.typegen.acceptsChildren(entry.glibName) ? ["children?: ReactNode;"] : []),
+        "ref?: Ref<Self | null> | undefined;",
+        ...propLines,
+        ...containerPropLines,
+        ...elementPropLines,
+    ]);
+    const extendsList = resolveElementExtends(library, entry, context);
+    const extendsClause = extendsList.length === 0 ? "" : ` extends ${extendsList.join(", ")}`;
+    const selfDefault = `${giNamespaceAlias(entry.namespace.name)}.${entry.klass.name}`;
+    const block = `${renderJsDoc(entry.klass.doc)}${renderBlock(
+        `export interface ${entry.glibName}Props<Self = ${selfDefault}>${extendsClause}`,
+        ownerLines.join("\n"),
+    )}`;
+    return { block, objectPropNames };
+};
+
+const resolveElementExtends = (library: Library, entry: GlibNamedClass, context: RenderPropBlockContext): string[] => {
+    const extendsList: string[] = [];
+    const parentRef = resolveParentPropsRef(library, entry, context);
+    if (parentRef !== undefined) extendsList.push(parentRef);
+    for (const iface of newlyImplementedInterfaces(entry.klass, entry.namespace, library, context.hasContainerProps)) {
+        const ref = interfacePropsRef(iface, context.targetNamespaceName, context.imports);
+        if (ref !== undefined) extendsList.push(ref);
+    }
+    return extendsList;
+};
+
+const resolveParentPropsRef = (
+    library: Library,
+    entry: GlibNamedClass,
+    context: RenderPropBlockContext,
+): string | undefined => {
+    const parent = entry.klass.parent;
+    if (parent === undefined) return undefined;
+    const resolved = library.resolveType(entry.namespace.name, parent);
+    if (resolved === undefined) return undefined;
+    if (resolved.kind !== "class" && resolved.kind !== "interface") return undefined;
+    const parentGlib = glibNameOf(resolved.value);
+    if (parentGlib === undefined) return undefined;
+    if (!context.intrinsicElementByGlibName.has(parentGlib)) return undefined;
+    registerCrossNsProps(context.imports, context.targetNamespaceName, resolved.namespace.name, `${parentGlib}Props`);
+    return `${parentGlib}Props<Self>`;
+};

package/src/store/react/metadata.ts

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