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

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

@@ -1,204 +0,0 @@
-import type { Arg, Call, ContainerProp, ElementProp, ListProp, ValueProp } from "@gtkx/config";
-import { toCamelIdentifier } from "@gtkx/utils";
-import type { GirParameter } from "../../gir/parameter.js";
-import { PRIMITIVE_TS_TYPE } from "../../gir/primitives.js";
-import { BUILT_IN_ELEMENT_PROPS } from "./built-ins.js";
-import { findMethod, type GirIndex, hasMethod, hasProperty } from "./gir-index.js";
-
-const callMethodName = (call: Call): string => (typeof call === "string" ? call : call.method);
-
-const containerTypeNames = (parent: string, prop: ContainerProp): string[] => {
-    const names = [parent, prop.child];
-    if (prop.autowrap !== undefined) names.push(prop.autowrap);
-    return names;
-};
-
-const containerCalls = (prop: ContainerProp): Call[] => {
-    const calls = [prop.append, prop.remove, prop.insert, prop.reorder].filter(
-        (call): call is Call => call !== undefined,
-    );
-    if (typeof prop.adopt === "string") calls.push(prop.adopt);
-    return calls;
-};
-
-const knownTypes = (context: GirIndex, names: string[]): boolean => names.every((name) => context.index.has(name));
-
-const elementPropError = (path: string, message: string): Error => new Error(`gtkx.config.ts: \`${path}\` ${message}`);
-
-const validateTypeNames = (context: GirIndex, path: string, names: string[]): void => {
-    for (const name of names) {
-        if (!context.index.has(name)) {
-            throw elementPropError(path, `references "${name}", which is not a type in the generated libraries`);
-        }
-    }
-};
-
-const validateCalls = (context: GirIndex, path: string, host: string, calls: Call[]): void => {
-    for (const call of calls) {
-        const method = callMethodName(call);
-        if (!hasMethod(context, host, method)) {
-            throw elementPropError(path, `references method "${method}", which does not exist on ${host}`);
-        }
-    }
-};
-
-const validateMember = (context: GirIndex, path: string, host: string, name: string): void => {
-    if (!hasProperty(context, host, name)) {
-        throw elementPropError(path, `references "${name}", which is not a property of ${host}`);
-    }
-};
-
-const validateUserElementProp = (context: GirIndex, type: string, path: string, prop: ElementProp): void => {
-    switch (prop.kind) {
-        case "container":
-            validateTypeNames(context, path, containerTypeNames(type, prop));
-            validateCalls(context, path, type, containerCalls(prop));
-            return;
-        case "value":
-            validateTypeNames(context, path, [type]);
-            validateCalls(context, path, type, prop.after === undefined ? [prop.call] : [prop.call, prop.after]);
-            return;
-        case "controlled-text":
-            validateTypeNames(context, path, [type]);
-            validateMember(context, path, type, prop.prop);
-            return;
-        case "lazy":
-            validateTypeNames(context, path, [type]);
-            validateMember(context, path, type, prop.prop);
-            if (prop.lookup !== undefined) validateCalls(context, path, type, [prop.lookup]);
-            return;
-        case "list":
-            validateTypeNames(context, path, [type]);
-            validateCalls(context, path, type, listCalls(prop));
-            return;
-    }
-};
-
-const addCalls = (add: ListProp["add"]): Call[] => (Array.isArray(add) ? add : [add]);
-
-const listCalls = (prop: ListProp): Call[] => {
-    const calls = addCalls(prop.add);
-    if (prop.remove !== undefined) calls.push(prop.remove);
-    if (prop.clear !== undefined) calls.push(prop.clear);
-    return calls;
-};
-
-const NO_DEFAULT = Symbol("gtkx.no-default");
-
-const inferredDefault = (context: GirIndex, param: GirParameter): null | number | boolean | typeof NO_DEFAULT => {
-    if (param.nullable) return null;
-    const type = param.type === undefined ? undefined : context.library.typeOf(param.type);
-    if (type?.kind !== "primitive") return NO_DEFAULT;
-    switch (PRIMITIVE_TS_TYPE[type.category]) {
-        case "number":
-            return 0;
-        case "boolean":
-            return false;
-        default:
-            return NO_DEFAULT;
-    }
-};
-
-const argForParameter = (context: GirIndex, param: GirParameter): Arg => {
-    const field = toCamelIdentifier(param.name);
-    const or = inferredDefault(context, param);
-    return or === NO_DEFAULT ? { field } : { field, or };
-};
-
-const callArity = (context: GirIndex, type: string, call: Call): number | undefined =>
-    typeof call === "string" ? findMethod(context, type, call)?.params.length : undefined;
-
-const expandCall = (context: GirIndex, type: string, call: Call, scalar: boolean): Call => {
-    if (typeof call !== "string" || scalar) return call;
-    const method = findMethod(context, type, call);
-    if (method === undefined || method.params.length === 0) return call;
-    return { method: call, args: method.params.map((param) => argForParameter(context, param)) };
-};
-
-const expandListProp = (context: GirIndex, type: string, prop: ListProp): ListProp => {
-    const scalar = !Array.isArray(prop.add) && callArity(context, type, prop.add) === 1;
-    const add = Array.isArray(prop.add)
-        ? prop.add.map((call) => expandCall(context, type, call, false))
-        : expandCall(context, type, prop.add, scalar);
-    return {
-        ...prop,
-        add,
-        remove: prop.remove === undefined ? undefined : expandCall(context, type, prop.remove, scalar),
-    };
-};
-
-const expandValueProp = (context: GirIndex, type: string, prop: ValueProp): ValueProp => {
-    const arity = callArity(context, type, prop.call);
-    return { ...prop, call: expandCall(context, type, prop.call, arity === undefined || arity <= 1) };
-};
-
-const expandAppliedProps = (
-    context: GirIndex,
-    elementProps: Record<string, ElementProp[]>,
-): Record<string, ElementProp[]> => {
-    const result: Record<string, ElementProp[]> = {};
-    for (const [type, props] of Object.entries(elementProps)) {
-        result[type] = props.map((prop) => {
-            if (prop.kind === "list") return expandListProp(context, type, prop);
-            if (prop.kind === "value") return expandValueProp(context, type, prop);
-            return prop;
-        });
-    }
-    return result;
-};
-
-const validateUserElementProps = (context: GirIndex, elementProps: Record<string, ElementProp[]>): void => {
-    for (const [type, props] of Object.entries(elementProps)) {
-        props.forEach((prop, index) => {
-            validateUserElementProp(context, type, `elementProps.${type}[${index}]`, prop);
-        });
-    }
-};
-
-const elementPropKey = (prop: ElementProp): string =>
-    prop.kind === "container" ? `container:${prop.prop}:${prop.child}` : `applied:${prop.prop}`;
-
-const mergeElementProps = (layers: Record<string, ElementProp[]>[]): Record<string, ElementProp[]> => {
-    const byType = new Map<string, Map<string, ElementProp>>();
-    for (const layer of layers) {
-        for (const [type, props] of Object.entries(layer)) {
-            const merged = byType.get(type) ?? new Map<string, ElementProp>();
-            for (const prop of props) {
-                const key = elementPropKey(prop);
-                merged.delete(key);
-                merged.set(key, prop);
-            }
-            byType.set(type, merged);
-        }
-    }
-    const result: Record<string, ElementProp[]> = {};
-    for (const [type, merged] of byType) result[type] = [...merged.values()];
-    return result;
-};
-
-const filterKnownElementProps = (
-    context: GirIndex,
-    map: Record<string, ElementProp[]>,
-): Record<string, ElementProp[]> => {
-    const result: Record<string, ElementProp[]> = {};
-    for (const [type, props] of Object.entries(map)) {
-        if (!context.index.has(type)) continue;
-        const kept = props.filter(
-            (prop) => prop.kind !== "container" || knownTypes(context, containerTypeNames(type, prop)),
-        );
-        if (kept.length > 0) result[type] = kept;
-    }
-    return result;
-};
-
-export const assembleElementProps = (
-    context: GirIndex,
-    userElementProps: Record<string, ElementProp[]>,
-): Record<string, ElementProp[]> => {
-    validateUserElementProps(context, userElementProps);
-    const merged = mergeElementProps([
-        filterKnownElementProps(context, BUILT_IN_ELEMENT_PROPS),
-        filterKnownElementProps(context, userElementProps),
-    ]);
-    return expandAppliedProps(context, merged);
-};

package/src/store/react/gir-index.ts

@@ -1,85 +0,0 @@
-import { toCamelIdentifier } from "@gtkx/utils";
-import { inputParameters } from "../../analysis/param-structure.js";
-import { ancestorChain } from "../../gir/ancestry.js";
-import type { GirClass } from "../../gir/class.js";
-import type { GirFunction } from "../../gir/function.js";
-import type { Library } from "../../gir/library.js";
-import type { GirNamespace } from "../../gir/namespace.js";
-import type { GirParameter } from "../../gir/parameter.js";
-import { glibNameOf, implementedInterfaces } from "./intrinsic-elements.js";
-
-export type GirTypeEntry = {
-    klass: GirClass;
-    namespace: GirNamespace;
-    isInterface: boolean;
-};
-
-export type GirIndex = {
-    library: Library;
-    index: Map<string, GirTypeEntry>;
-};
-
-export const buildGirIndex = (library: Library): GirIndex => {
-    const index = new Map<string, GirTypeEntry>();
-    for (const namespace of library.namespaces.values()) {
-        for (const klass of namespace.classes) {
-            const glibName = glibNameOf(klass);
-            if (glibName !== undefined && !index.has(glibName)) {
-                index.set(glibName, { klass, namespace, isInterface: false });
-            }
-        }
-        for (const klass of namespace.interfaces) {
-            const glibName = glibNameOf(klass);
-            if (glibName !== undefined && !index.has(glibName)) {
-                index.set(glibName, { klass, namespace, isInterface: true });
-            }
-        }
-    }
-    return { library, index };
-};
-
-export const chainOf = (context: GirIndex, entry: GirTypeEntry): GirClass[] => {
-    if (entry.isInterface) return [entry.klass];
-    const chain: GirClass[] = [];
-    for (const { klass } of ancestorChain(context.library, entry.klass, entry.namespace.name)) chain.push(klass);
-    for (const iface of implementedInterfaces(entry.klass, entry.namespace, context.library)) chain.push(iface.klass);
-    return chain;
-};
-
-type ResolvedMethod = {
-    fn: GirFunction;
-    params: GirParameter[];
-};
-
-export const findMethod = (context: GirIndex, typeName: string, camelName: string): ResolvedMethod | undefined => {
-    const entry = context.index.get(typeName);
-    if (entry === undefined) return undefined;
-    for (const klass of chainOf(context, entry)) {
-        const fn = klass.methods.find(
-            (method) =>
-                method.introspectable &&
-                method.shadowedBy === undefined &&
-                toCamelIdentifier(method.name) === camelName,
-        );
-        if (fn !== undefined) {
-            return { fn, params: inputParameters(context.library, fn).map((input) => input.parameter) };
-        }
-    }
-    return undefined;
-};
-
-const chainSome = (context: GirIndex, typeName: string, predicate: (klass: GirClass) => boolean): boolean => {
-    const entry = context.index.get(typeName);
-    if (entry === undefined) return false;
-    return chainOf(context, entry).some(predicate);
-};
-
-export const hasMethod = (context: GirIndex, typeName: string, camelName: string): boolean =>
-    chainSome(context, typeName, (klass) =>
-        klass.methods.some((method) => method.introspectable && toCamelIdentifier(method.name) === camelName),
-    );
-
-export const hasProperty = (context: GirIndex, typeName: string, camelName: string): boolean =>
-    chainSome(context, typeName, (klass) =>
-        klass.properties.some((property) => toCamelIdentifier(property.name) === camelName),
-    );

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);