@gtkx/react 0.9.4 → 0.10.0

package/dist/codegen/jsx-generator.js

@@ -1,959 +0,0 @@
-import { formatDoc as formatDocBase, toCamelCase, toPascalCase } from "@gtkx/gir";
-import { format } from "prettier";
-const LIST_WIDGETS = new Set(["ListView", "GridView"]);
-const COLUMN_VIEW_WIDGET = "ColumnView";
-const DROPDOWN_WIDGETS = new Set(["DropDown"]);
-const GRID_WIDGETS = new Set(["Grid"]);
-const NOTEBOOK_WIDGET = "Notebook";
-const STACK_WIDGETS = new Set(["Stack", "ViewStack", "AdwViewStack"]);
-const POPOVER_MENU_WIDGET = "PopoverMenu";
-const TOOLBAR_VIEW_WIDGET = "ToolbarView";
-const INTERNALLY_PROVIDED_PARAMS = {
-    ApplicationWindow: new Set(["application"]),
-};
-const WIDGET_REFERENCE_PROPERTIES = new Set(["mnemonic-widget"]);
-const isPrimitive = (tsType) => {
-    const primitives = new Set(["boolean", "number", "string", "void", "unknown", "null", "undefined"]);
-    return primitives.has(tsType);
-};
-const toJsxPropertyTypeBase = (tsType, namespace) => {
-    let result = tsType;
-    if (result.startsWith("Ref<")) {
-        result = result.replace(/^Ref<(.+)>$/, "$1");
-    }
-    if (isPrimitive(result))
-        return result;
-    if (result.endsWith("[]")) {
-        const elementType = result.slice(0, -2);
-        if (isPrimitive(elementType))
-            return result;
-    }
-    if (result.includes(".") || result.includes("<") || result.includes("("))
-        return result;
-    return `${namespace}.${result}`;
-};
-const isListWidget = (widgetName) => LIST_WIDGETS.has(widgetName);
-const isColumnViewWidget = (widgetName) => widgetName === COLUMN_VIEW_WIDGET;
-const isDropDownWidget = (widgetName) => DROPDOWN_WIDGETS.has(widgetName);
-const isGridWidget = (widgetName) => GRID_WIDGETS.has(widgetName);
-const isNotebookWidget = (widgetName) => widgetName === NOTEBOOK_WIDGET;
-const isStackWidget = (widgetName) => STACK_WIDGETS.has(widgetName);
-const isPopoverMenuWidget = (widgetName) => widgetName === POPOVER_MENU_WIDGET;
-const isToolbarViewWidget = (widgetName) => widgetName === TOOLBAR_VIEW_WIDGET;
-const isWidgetSubclass = (typeName, classMap, visited = new Set()) => {
-    const className = typeName.includes(".") ? typeName.split(".")[1] : typeName;
-    if (!className || visited.has(className))
-        return false;
-    visited.add(className);
-    const cls = classMap.get(className);
-    if (!cls)
-        return false;
-    if (className === "Widget")
-        return true;
-    return cls.parent ? isWidgetSubclass(cls.parent, classMap, visited) : false;
-};
-export class JsxGenerator {
-    typeMapper;
-    typeRegistry;
-    classMap;
-    options;
-    interfaceMap = new Map();
-    usedNamespaces = new Set();
-    widgetPropertyNames = new Set();
-    widgetSignalNames = new Set();
-    currentNamespace = "";
-    widgetNamespaceMap = new Map();
-    constructor(typeMapper, typeRegistry, classMap, options = {}) {
-        this.typeMapper = typeMapper;
-        this.typeRegistry = typeRegistry;
-        this.classMap = classMap;
-        this.options = options;
-    }
-    formatDoc(doc, indent = "") {
-        return formatDocBase(doc, indent, {
-            namespace: this.currentNamespace,
-            escapeXmlTags: true,
-            linkStyle: "prefixed",
-        });
-    }
-    async generate(namespaces) {
-        for (const ns of namespaces) {
-            for (const iface of ns.interfaces) {
-                this.interfaceMap.set(iface.name, iface);
-                this.interfaceMap.set(`${ns.name}.${iface.name}`, iface);
-            }
-        }
-        this.usedNamespaces.clear();
-        this.widgetNamespaceMap.clear();
-        const allWidgets = [];
-        for (const ns of namespaces) {
-            const widgets = this.findWidgets(ns);
-            for (const widget of widgets) {
-                allWidgets.push({ widget, namespace: ns.name });
-                this.widgetNamespaceMap.set(widget.name, ns.name);
-                this.widgetNamespaceMap.set(`${ns.name}.${widget.name}`, ns.name);
-            }
-        }
-        const containerMetadata = this.buildContainerMetadata(allWidgets);
-        const widgetClass = this.classMap.get("Widget") ?? this.classMap.get("Gtk.Widget");
-        this.widgetPropertyNames = new Set(widgetClass?.properties.map((p) => toCamelCase(p.name)) ?? []);
-        this.widgetSignalNames = new Set(widgetClass?.signals.map((s) => toCamelCase(s.name)) ?? []);
-        const commonTypes = this.generateCommonTypes(widgetClass);
-        const widgetPropsInterfaces = this.generateWidgetPropsInterfaces(allWidgets, containerMetadata);
-        const exports = this.generateExports(allWidgets, containerMetadata);
-        const jsxNamespace = this.generateJsxNamespace(allWidgets, containerMetadata);
-        const imports = this.generateImports();
-        const jsxSections = [imports, commonTypes, widgetPropsInterfaces, exports, jsxNamespace, "export {};"];
-        const internalSections = [
-            this.generateInternalImports(),
-            this.generateConstructorArgsMetadata(allWidgets),
-            this.generatePropSettersMap(allWidgets),
-            this.generateSetterGetterMap(allWidgets),
-        ];
-        return {
-            jsx: await this.formatCode(jsxSections.join("\n")),
-            internal: await this.formatCode(internalSections.join("\n")),
-        };
-    }
-    generateImports() {
-        this.usedNamespaces.add("Gtk");
-        const namespaceImports = [...this.usedNamespaces]
-            .sort()
-            .map((ns) => `import type * as ${ns} from "@gtkx/ffi/${ns.toLowerCase()}";`);
-        return [
-            `import "react";`,
-            `import { createElement } from "react";`,
-            `import type { ReactNode, Ref } from "react";`,
-            ...namespaceImports,
-            `import type { ColumnViewColumnProps, ColumnViewRootProps, GridChildProps, ListItemProps, ListViewRenderProps, MenuItemProps, MenuRootProps, MenuSectionProps, MenuSubmenuProps, NotebookPageProps, SlotProps, StackPageProps, StackRootProps, StringListItemProps } from "../types.js";`,
-            "",
-        ].join("\n");
-    }
-    generateInternalImports() {
-        return "/** Internal metadata for the reconciler. Not part of the public API. */\n";
-    }
-    generateCommonTypes(widgetClass) {
-        this.currentNamespace = "Gtk";
-        this.typeMapper.setTypeRegistry(this.typeRegistry, "Gtk");
-        const widgetPropsContent = this.generateWidgetPropsContent(widgetClass);
-        return `
-export { ColumnViewColumnProps, ColumnViewRootProps, GridChildProps, ListItemProps, ListViewRenderProps, MenuItemProps, MenuRootProps, MenuSectionProps, MenuSubmenuProps, NotebookPageProps, SlotProps, StackPageProps, StackRootProps, StringListItemProps };
-
-${widgetPropsContent}
-`;
-    }
-    generateWidgetPropsContent(widgetClass) {
-        const lines = [];
-        const widgetDoc = widgetClass?.doc ? this.formatDoc(widgetClass.doc) : "";
-        if (widgetDoc) {
-            lines.push(widgetDoc.trimEnd());
-        }
-        lines.push("export interface WidgetProps {");
-        if (widgetClass) {
-            for (const prop of widgetClass.properties) {
-                const propName = toCamelCase(prop.name);
-                const tsType = this.toJsxPropertyType(this.typeMapper.mapType(prop.type).ts, "Gtk");
-                if (prop.doc) {
-                    lines.push(this.formatDoc(prop.doc, "\t").trimEnd());
-                }
-                lines.push(`\t${propName}?: ${tsType};`);
-            }
-            if (widgetClass.signals.length > 0) {
-                lines.push("");
-                for (const signal of widgetClass.signals) {
-                    if (signal.doc) {
-                        lines.push(this.formatDoc(signal.doc, "\t").trimEnd());
-                    }
-                    lines.push(`\t${this.generateSignalHandler(signal, "Widget")}`);
-                }
-            }
-        }
-        lines.push("");
-        lines.push("\tchildren?: ReactNode;");
-        lines.push("}");
-        return lines.join("\n");
-    }
-    buildContainerMetadata(widgets) {
-        const metadata = new Map();
-        for (const { widget, namespace } of widgets) {
-            const key = `${namespace}.${widget.name}`;
-            metadata.set(key, this.analyzeContainerCapabilities(widget));
-        }
-        return metadata;
-    }
-    findWidgets(namespace) {
-        const widgetCache = new Map();
-        const checkIsWidget = (className, ns) => {
-            const cacheKey = `${ns}.${className}`;
-            const cached = widgetCache.get(cacheKey);
-            if (cached !== undefined)
-                return cached;
-            widgetCache.set(cacheKey, false);
-            const cls = this.classMap.get(cacheKey) ?? this.classMap.get(className);
-            if (!cls)
-                return false;
-            if (cls.name === "Widget") {
-                widgetCache.set(cacheKey, true);
-                return true;
-            }
-            if (cls.parent) {
-                const parentNs = cls.parent.includes(".") ? cls.parent.split(".")[0] : ns;
-                const parentName = cls.parent.includes(".") ? cls.parent.split(".")[1] : cls.parent;
-                const result = checkIsWidget(parentName ?? "", parentNs ?? ns);
-                widgetCache.set(cacheKey, result);
-                return result;
-            }
-            return false;
-        };
-        const widgets = namespace.classes.filter((cls) => checkIsWidget(cls.name, namespace.name));
-        return widgets.sort((a, b) => {
-            if (a.name === "Widget")
-                return -1;
-            if (b.name === "Widget")
-                return 1;
-            if (a.name === "Window")
-                return -1;
-            if (b.name === "Window")
-                return 1;
-            return a.name.localeCompare(b.name);
-        });
-    }
-    analyzeContainerCapabilities(widget) {
-        const hasAppend = widget.methods.some((m) => m.name === "append");
-        const hasSetChild = widget.methods.some((m) => m.name === "set_child");
-        const namedChildSlots = widget.properties
-            .filter((prop) => {
-            if (!prop.writable)
-                return false;
-            if (WIDGET_REFERENCE_PROPERTIES.has(prop.name))
-                return false;
-            const typeName = prop.type.name;
-            return typeName === "Gtk.Widget" || typeName === "Widget" || isWidgetSubclass(typeName, this.classMap);
-        })
-            .map((prop) => ({
-            propertyName: prop.name,
-            slotName: toPascalCase(prop.name),
-        }));
-        if (isToolbarViewWidget(widget.name)) {
-            namedChildSlots.push({ propertyName: "top", slotName: "Top" });
-            namedChildSlots.push({ propertyName: "bottom", slotName: "Bottom" });
-        }
-        return {
-            supportsMultipleChildren: hasAppend,
-            supportsSingleChild: hasSetChild,
-            namedChildSlots,
-        };
-    }
-    generateWidgetPropsInterfaces(widgets, containerMetadata) {
-        const sections = [];
-        for (const { widget, namespace } of widgets) {
-            if (widget.name === "Widget")
-                continue;
-            const metadataKey = `${namespace}.${widget.name}`;
-            const metadata = containerMetadata.get(metadataKey);
-            if (!metadata)
-                throw new Error(`Missing container metadata for widget: ${metadataKey}`);
-            this.currentNamespace = namespace;
-            this.usedNamespaces.add(namespace);
-            this.typeMapper.setTypeRegistry(this.typeRegistry, namespace);
-            sections.push(this.generateWidgetProps(widget, metadata));
-        }
-        return sections.join("\n");
-    }
-    getWidgetExportName(widget) {
-        const baseName = toPascalCase(widget.name);
-        if (this.currentNamespace === "Gtk")
-            return baseName;
-        return `${this.currentNamespace}${baseName}`;
-    }
-    generateWidgetProps(widget, metadata) {
-        const widgetName = this.getWidgetExportName(widget);
-        const parentPropsName = this.getParentPropsName(widget);
-        const namedChildPropNames = new Set(metadata.namedChildSlots.map((s) => toCamelCase(s.propertyName)));
-        const lines = [];
-        lines.push(`/** Props for the {@link ${widgetName}} widget. */`);
-        lines.push(`export interface ${widgetName}Props extends ${parentPropsName} {`);
-        const requiredCtorParams = this.getRequiredConstructorParams(widget);
-        const seenProps = new Set();
-        const allProps = [...widget.properties];
-        for (const prop of widget.properties) {
-            seenProps.add(prop.name);
-        }
-        const seenSignals = new Set();
-        const allSignals = [...widget.signals];
-        for (const signal of widget.signals) {
-            seenSignals.add(signal.name);
-        }
-        const parentInterfaces = this.getAncestorInterfaces(widget);
-        for (const ifaceName of widget.implements) {
-            if (parentInterfaces.has(ifaceName))
-                continue;
-            const iface = this.interfaceMap.get(ifaceName);
-            if (iface) {
-                for (const prop of iface.properties) {
-                    if (!seenProps.has(prop.name)) {
-                        seenProps.add(prop.name);
-                        allProps.push(prop);
-                    }
-                }
-                for (const signal of iface.signals) {
-                    if (!seenSignals.has(signal.name)) {
-                        seenSignals.add(signal.name);
-                        allSignals.push(signal);
-                    }
-                }
-            }
-        }
-        const specificProps = allProps.filter((prop) => {
-            const propName = toCamelCase(prop.name);
-            return !this.widgetPropertyNames.has(propName) && !namedChildPropNames.has(propName);
-        });
-        const emittedProps = new Set();
-        for (const prop of specificProps) {
-            const propName = toCamelCase(prop.name);
-            emittedProps.add(prop.name);
-            const typeMapping = this.typeMapper.mapType(prop.type);
-            const tsType = this.toJsxPropertyType(typeMapping.ts, this.currentNamespace);
-            const isRequiredByConstructor = requiredCtorParams.has(prop.name);
-            const isRequired = isRequiredByConstructor;
-            if (prop.doc) {
-                lines.push(this.formatDoc(prop.doc, "\t").trimEnd());
-            }
-            lines.push(`\t${propName}${isRequired ? "" : "?"}: ${tsType};`);
-        }
-        for (const paramName of requiredCtorParams) {
-            if (emittedProps.has(paramName))
-                continue;
-            const propName = toCamelCase(paramName);
-            const inheritedProp = this.findInheritedProperty(widget, paramName);
-            if (inheritedProp) {
-                const typeMapping = this.typeMapper.mapType(inheritedProp.type);
-                const tsType = this.toJsxPropertyType(typeMapping.ts, this.currentNamespace);
-                lines.push(`\t${propName}: ${tsType};`);
-            }
-        }
-        const specificSignals = allSignals.filter((signal) => {
-            const signalName = toCamelCase(signal.name);
-            return !this.widgetSignalNames.has(signalName);
-        });
-        if (specificSignals.length > 0) {
-            lines.push("");
-            for (const signal of specificSignals) {
-                if (signal.doc) {
-                    lines.push(this.formatDoc(signal.doc, "\t").trimEnd());
-                }
-                lines.push(`\t${this.generateSignalHandler(signal, widget.name)}`);
-            }
-        }
-        if (isListWidget(widget.name) || isColumnViewWidget(widget.name)) {
-            lines.push("");
-            lines.push(`\t/** Array of selected item IDs */`);
-            lines.push(`\tselected?: string[];`);
-            lines.push(`\t/** Called when selection changes with array of selected item IDs */`);
-            lines.push(`\tonSelectionChanged?: (ids: string[]) => void;`);
-            lines.push(`\t/** Selection mode: SINGLE (default) or MULTIPLE */`);
-            lines.push(`\tselectionMode?: import("@gtkx/ffi/gtk").SelectionMode;`);
-        }
-        if (isListWidget(widget.name)) {
-            lines.push("");
-            lines.push(`\t/**`);
-            lines.push(`\t * Render function for list items.`);
-            lines.push(`\t * Called with null during setup (for loading state) and with the actual item during bind.`);
-            lines.push(`\t */`);
-            lines.push(`\trenderItem: (item: unknown) => import("react").ReactElement;`);
-        }
-        if (isDropDownWidget(widget.name)) {
-            lines.push("");
-            lines.push(`\t/** ID of the initially selected item */`);
-            lines.push(`\tselectedId?: string;`);
-            lines.push(`\t/** Called when selection changes with the selected item's ID */`);
-            lines.push(`\tonSelectionChanged?: (id: string) => void;`);
-        }
-        lines.push("");
-        const ffiTypeName = toPascalCase(widget.name);
-        lines.push(`\tref?: Ref<${this.currentNamespace}.${ffiTypeName}>;`);
-        lines.push(`}`);
-        return `${lines.join("\n")}\n`;
-    }
-    getParentPropsName(widget) {
-        if (widget.name === "Window")
-            return "WidgetProps";
-        if (widget.name === "ApplicationWindow")
-            return "WindowProps";
-        if (!widget.parent)
-            return "WidgetProps";
-        const parentNs = widget.parent.includes(".") ? widget.parent.split(".")[0] : this.currentNamespace;
-        const parentName = widget.parent.includes(".") ? widget.parent.split(".")[1] : widget.parent;
-        if (parentName === "Widget")
-            return "WidgetProps";
-        if (parentName === "Window")
-            return "WindowProps";
-        const baseName = toPascalCase(parentName ?? "");
-        if (parentNs === "Gtk") {
-            return `${baseName}Props`;
-        }
-        return `${parentNs}${baseName}Props`;
-    }
-    getRequiredConstructorParams(widget) {
-        const required = new Set();
-        const mainCtor = widget.constructors.find((c) => c.name === "new");
-        if (!mainCtor)
-            return required;
-        const internallyProvided = INTERNALLY_PROVIDED_PARAMS[widget.name] ?? new Set();
-        for (const param of mainCtor.parameters) {
-            if (!param.nullable && !param.optional) {
-                const normalizedName = param.name.replace(/_/g, "-");
-                if (!internallyProvided.has(normalizedName)) {
-                    required.add(normalizedName);
-                }
-            }
-        }
-        return required;
-    }
-    getConstructorParams(widget) {
-        const mainCtor = widget.constructors.find((c) => c.name === "new");
-        if (!mainCtor)
-            return [];
-        const params = mainCtor.parameters.map((param) => ({
-            name: toCamelCase(param.name),
-            hasDefault: param.nullable || param.optional || false,
-        }));
-        const required = params.filter((p) => !p.hasDefault);
-        const optional = params.filter((p) => p.hasDefault);
-        return [...required, ...optional];
-    }
-    generateConstructorArgsMetadata(widgets) {
-        const entries = [];
-        for (const { widget, namespace } of widgets) {
-            const params = this.getConstructorParams(widget);
-            if (params.length === 0)
-                continue;
-            this.currentNamespace = namespace;
-            const widgetName = this.getWidgetExportName(widget);
-            const paramStrs = params.map((p) => `{ name: "${p.name}", hasDefault: ${p.hasDefault} }`);
-            entries.push(`\t${widgetName}: [${paramStrs.join(", ")}]`);
-        }
-        if (entries.length === 0) {
-            return `export const CONSTRUCTOR_PARAMS: Record<string, { name: string; hasDefault: boolean }[]> = {};\n`;
-        }
-        return `export const CONSTRUCTOR_PARAMS: Record<string, { name: string; hasDefault: boolean }[]> = {\n${entries.join(",\n")},\n};\n`;
-    }
-    generatePropSettersMap(widgets) {
-        const widgetEntries = [];
-        for (const { widget, namespace } of widgets) {
-            this.currentNamespace = namespace;
-            const propSetterPairs = [];
-            const allProps = this.collectAllProperties(widget);
-            for (const prop of allProps) {
-                if (prop.setter) {
-                    const propName = toCamelCase(prop.name);
-                    const setterName = toCamelCase(prop.setter);
-                    propSetterPairs.push(`"${propName}": "${setterName}"`);
-                }
-            }
-            if (propSetterPairs.length > 0) {
-                const widgetName = this.getWidgetExportName(widget);
-                widgetEntries.push(`\t${widgetName}: { ${propSetterPairs.join(", ")} }`);
-            }
-        }
-        if (widgetEntries.length === 0) {
-            return `export const PROP_SETTERS: Record<string, Record<string, string>> = {};\n`;
-        }
-        return `export const PROP_SETTERS: Record<string, Record<string, string>> = {\n${widgetEntries.join(",\n")},\n};\n`;
-    }
-    generateSetterGetterMap(widgets) {
-        const widgetEntries = [];
-        for (const { widget, namespace } of widgets) {
-            this.currentNamespace = namespace;
-            const setterGetterPairs = [];
-            const allProps = this.collectAllProperties(widget);
-            const parentMethodNames = this.collectParentMethodNames(widget);
-            const widgetClassName = toPascalCase(widget.name);
-            for (const prop of allProps) {
-                if (prop.setter && prop.getter) {
-                    const setterName = toCamelCase(prop.setter);
-                    let getterName = toCamelCase(prop.getter);
-                    if (parentMethodNames.has(prop.getter)) {
-                        getterName = `${getterName}${widgetClassName}`;
-                    }
-                    setterGetterPairs.push(`"${setterName}": "${getterName}"`);
-                }
-            }
-            if (setterGetterPairs.length > 0) {
-                const widgetName = this.getWidgetExportName(widget);
-                widgetEntries.push(`\t${widgetName}: { ${setterGetterPairs.join(", ")} }`);
-            }
-        }
-        if (widgetEntries.length === 0) {
-            return `export const SETTER_GETTERS: Record<string, Record<string, string>> = {};\n`;
-        }
-        return `export const SETTER_GETTERS: Record<string, Record<string, string>> = {\n${widgetEntries.join(",\n")},\n};\n`;
-    }
-    collectParentMethodNames(widget) {
-        const names = new Set();
-        const visited = new Set();
-        let parentRef = widget.parent;
-        while (parentRef && !visited.has(parentRef)) {
-            visited.add(parentRef);
-            const current = this.classMap.get(parentRef) ??
-                this.classMap.get(`${this.currentNamespace}.${parentRef}`) ??
-                this.classMap.get(`Gtk.${parentRef}`);
-            if (!current)
-                break;
-            for (const method of current.methods) {
-                names.add(method.name);
-            }
-            for (const ifaceName of current.implements) {
-                const iface = this.interfaceMap.get(ifaceName);
-                if (iface) {
-                    for (const method of iface.methods) {
-                        names.add(method.name);
-                    }
-                }
-            }
-            parentRef = current.parent;
-        }
-        return names;
-    }
-    collectAllProperties(widget) {
-        const props = [];
-        const seen = new Set();
-        let current = widget;
-        while (current) {
-            for (const prop of current.properties) {
-                if (!seen.has(prop.name)) {
-                    seen.add(prop.name);
-                    props.push({ name: prop.name, setter: prop.setter, getter: prop.getter });
-                }
-            }
-            for (const ifaceName of current.implements) {
-                const iface = this.interfaceMap.get(ifaceName);
-                if (iface) {
-                    for (const prop of iface.properties) {
-                        if (!seen.has(prop.name)) {
-                            seen.add(prop.name);
-                            props.push({ name: prop.name, setter: prop.setter, getter: prop.getter });
-                        }
-                    }
-                }
-            }
-            if (current.parent) {
-                current =
-                    this.classMap.get(current.parent) ??
-                        this.classMap.get(`${this.currentNamespace}.${current.parent}`) ??
-                        this.classMap.get(`Gtk.${current.parent}`);
-            }
-            else {
-                current = undefined;
-            }
-        }
-        return props;
-    }
-    getAncestorInterfaces(widget) {
-        const interfaces = new Set();
-        let current = widget.parent ? this.classMap.get(widget.parent) : undefined;
-        while (current) {
-            for (const ifaceName of current.implements) {
-                interfaces.add(ifaceName);
-            }
-            current = current.parent ? this.classMap.get(current.parent) : undefined;
-        }
-        return interfaces;
-    }
-    findInheritedProperty(widget, propName) {
-        let current = widget.parent ? this.classMap.get(widget.parent) : undefined;
-        while (current) {
-            const prop = current.properties.find((p) => p.name === propName);
-            if (prop)
-                return prop;
-            for (const ifaceName of current.implements) {
-                const iface = this.interfaceMap.get(ifaceName);
-                if (iface) {
-                    const ifaceProp = iface.properties.find((p) => p.name === propName);
-                    if (ifaceProp)
-                        return ifaceProp;
-                }
-            }
-            current = current.parent ? this.classMap.get(current.parent) : undefined;
-        }
-        for (const ifaceName of widget.implements) {
-            const iface = this.interfaceMap.get(ifaceName);
-            if (iface) {
-                const ifaceProp = iface.properties.find((p) => p.name === propName);
-                if (ifaceProp)
-                    return ifaceProp;
-            }
-        }
-        return undefined;
-    }
-    generateSignalHandler(signal, widgetName) {
-        const signalName = toCamelCase(signal.name);
-        const handlerName = `on${signalName.charAt(0).toUpperCase()}${signalName.slice(1)}`;
-        const handlerType = this.buildSignalHandlerType(signal, widgetName);
-        return `${handlerName}?: ${handlerType};`;
-    }
-    getSignalParamFfiType(typeName) {
-        if (!typeName)
-            return undefined;
-        if (typeName.includes(".")) {
-            const [ns, className] = typeName.split(".", 2);
-            if (ns && className) {
-                const registered = this.typeRegistry.resolve(`${ns}.${className}`);
-                if (registered && (registered.kind === "class" || registered.kind === "interface")) {
-                    this.usedNamespaces.add(ns);
-                    return `${ns}.${registered.transformedName}`;
-                }
-            }
-            return undefined;
-        }
-        const registered = this.typeRegistry.resolveInNamespace(typeName, this.currentNamespace);
-        if (registered && (registered.kind === "class" || registered.kind === "interface")) {
-            this.usedNamespaces.add(registered.namespace);
-            if (registered.namespace === this.currentNamespace) {
-                return `${this.currentNamespace}.${registered.transformedName}`;
-            }
-            return `${registered.namespace}.${registered.transformedName}`;
-        }
-        return undefined;
-    }
-    addNamespacePrefix(tsType) {
-        const primitives = new Set(["boolean", "number", "string", "void", "unknown", "null", "undefined"]);
-        if (primitives.has(tsType))
-            return tsType;
-        if (tsType.endsWith("[]")) {
-            const elementType = tsType.slice(0, -2);
-            if (primitives.has(elementType))
-                return tsType;
-            if (elementType.includes(".") || elementType.includes("<") || elementType.includes("("))
-                return tsType;
-            return `${this.currentNamespace}.${elementType}[]`;
-        }
-        if (tsType.includes(".") || tsType.includes("<") || tsType.includes("("))
-            return tsType;
-        return `${this.currentNamespace}.${tsType}`;
-    }
-    toJsxPropertyType(tsType, namespace) {
-        const result = toJsxPropertyTypeBase(tsType, namespace);
-        if (result.includes(".") && !result.includes("<") && !result.includes("(")) {
-            const ns = result.split(".")[0];
-            if (ns) {
-                this.usedNamespaces.add(ns);
-            }
-        }
-        return result;
-    }
-    buildSignalHandlerType(signal, widgetName) {
-        const selfParam = `self: ${this.currentNamespace}.${toPascalCase(widgetName)}`;
-        const otherParams = signal.parameters
-            ?.map((p) => {
-            const ffiType = this.getSignalParamFfiType(p.type.name);
-            if (ffiType) {
-                return `${toCamelCase(p.name)}: ${ffiType}`;
-            }
-            const paramMapping = this.typeMapper.mapParameter(p);
-            const tsType = this.addNamespacePrefix(paramMapping.ts);
-            return `${toCamelCase(p.name)}: ${tsType}`;
-        })
-            .join(", ") ?? "";
-        const returnType = signal.returnType
-            ? this.addNamespacePrefix(this.typeMapper.mapType(signal.returnType).ts)
-            : "void";
-        const params = otherParams ? `${selfParam}, ${otherParams}` : selfParam;
-        return `(${params}) => ${returnType}`;
-    }
-    generateExports(widgets, containerMetadata) {
-        const lines = [];
-        for (const { widget, namespace } of widgets) {
-            this.currentNamespace = namespace;
-            const widgetName = this.getWidgetExportName(widget);
-            const metadataKey = `${namespace}.${widget.name}`;
-            const metadata = containerMetadata.get(metadataKey);
-            if (!metadata)
-                throw new Error(`Missing container metadata for widget: ${metadataKey}`);
-            const nonChildSlots = metadata.namedChildSlots.filter((slot) => slot.slotName !== "Child");
-            const hasMeaningfulSlots = nonChildSlots.length > 0 ||
-                isListWidget(widget.name) ||
-                isColumnViewWidget(widget.name) ||
-                isDropDownWidget(widget.name) ||
-                isGridWidget(widget.name) ||
-                isNotebookWidget(widget.name) ||
-                isStackWidget(widget.name) ||
-                isPopoverMenuWidget(widget.name);
-            const docComment = widget.doc ? this.formatDoc(widget.doc).trimEnd() : "";
-            if (hasMeaningfulSlots) {
-                if (isListWidget(widget.name) ||
-                    isColumnViewWidget(widget.name) ||
-                    isDropDownWidget(widget.name) ||
-                    isStackWidget(widget.name) ||
-                    isPopoverMenuWidget(widget.name)) {
-                    const wrapperComponents = this.generateGenericWrapperComponents(widgetName, metadata);
-                    const exportMembers = this.getWrapperExportMembers(widgetName, metadata);
-                    if (docComment) {
-                        lines.push(`${wrapperComponents}\n${docComment}\nexport const ${widgetName} = {\n\t${exportMembers.join(",\n\t")},\n};`);
-                    }
-                    else {
-                        lines.push(`${wrapperComponents}\nexport const ${widgetName} = {\n\t${exportMembers.join(",\n\t")},\n};`);
-                    }
-                }
-                else {
-                    const valueMembers = [
-                        `Root: "${widgetName}.Root" as const`,
-                        ...metadata.namedChildSlots.map((slot) => `${slot.slotName}: "${widgetName}.${slot.slotName}" as const`),
-                        ...(isGridWidget(widget.name) ? [`Child: "${widgetName}.Child" as const`] : []),
-                        ...(isNotebookWidget(widget.name) ? [`Page: "${widgetName}.Page" as const`] : []),
-                    ];
-                    if (docComment) {
-                        lines.push(`${docComment}\nexport const ${widgetName} = {\n\t${valueMembers.join(",\n\t")},\n};`);
-                    }
-                    else {
-                        lines.push(`export const ${widgetName} = {\n\t${valueMembers.join(",\n\t")},\n};`);
-                    }
-                }
-            }
-            else {
-                if (docComment) {
-                    lines.push(`${docComment}\nexport const ${widgetName} = "${widgetName}" as const;`);
-                }
-                else {
-                    lines.push(`export const ${widgetName} = "${widgetName}" as const;`);
-                }
-            }
-        }
-        lines.push(this.generateApplicationMenuComponents());
-        return `${lines.join("\n")}\n`;
-    }
-    generateApplicationMenuComponents() {
-        return `/**
- * Sets the application-wide menu bar.
- * The menu will appear in the window's title bar on supported platforms.
- * Use Menu.Item, Menu.Section, and Menu.Submenu as children.
- */
-export const ApplicationMenu = "ApplicationMenu" as const;
-
-function MenuItem(props: MenuItemProps): import("react").ReactElement {
-\treturn createElement("Menu.Item", props);
-}
-
-function MenuSection(props: MenuSectionProps): import("react").ReactElement {
-\treturn createElement("Menu.Section", props);
-}
-
-function MenuSubmenu(props: MenuSubmenuProps): import("react").ReactElement {
-\treturn createElement("Menu.Submenu", props);
-}
-
-/**
- * Declarative menu builder for use with PopoverMenu and ApplicationMenu.
- * Use Menu.Item for action items, Menu.Section for groups, Menu.Submenu for nested menus.
- */
-export const Menu = {
-\tItem: MenuItem,
-\tSection: MenuSection,
-\tSubmenu: MenuSubmenu,
-};
-`;
-    }
-    getWrapperExportMembers(widgetName, metadata) {
-        const name = toPascalCase(widgetName);
-        const members = [`Root: ${name}Root`];
-        if (isListWidget(widgetName)) {
-            members.push(`Item: ${name}Item`);
-        }
-        else if (isColumnViewWidget(widgetName)) {
-            members.push(`Column: ${name}Column`);
-            members.push(`Item: ${name}Item`);
-        }
-        else if (isDropDownWidget(widgetName)) {
-            members.push(`Item: ${name}Item`);
-        }
-        else if (isStackWidget(widgetName)) {
-            members.push(`Page: ${name}Page`);
-        }
-        else if (isPopoverMenuWidget(widgetName)) {
-            members.push(`Item: ${name}Item`);
-            members.push(`Section: ${name}Section`);
-            members.push(`Submenu: ${name}Submenu`);
-        }
-        for (const slot of metadata.namedChildSlots) {
-            members.push(`${slot.slotName}: ${name}${slot.slotName}`);
-        }
-        return members;
-    }
-    generateGenericWrapperComponents(widgetName, metadata) {
-        const name = toPascalCase(widgetName);
-        const lines = [];
-        if (isListWidget(widgetName)) {
-            lines.push(`/**`);
-            lines.push(` * Props for the ${name}.Root component with type-safe item rendering.`);
-            lines.push(` * @typeParam T - The type of items in the list.`);
-            lines.push(` */`);
-            lines.push(`interface ${name}RootProps<T> extends Omit<${name}Props, "renderItem"> {`);
-            lines.push(`\t/** Render function for list items. Called with null during setup (for loading state). */`);
-            lines.push(`\trenderItem: (item: T | null) => import("react").ReactElement;`);
-            lines.push(`}`);
-            lines.push(``);
-            lines.push(`function ${name}Root<T>(props: ${name}RootProps<T>): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("${name}.Root", props);`);
-            lines.push(`}`);
-            lines.push(``);
-            lines.push(`function ${name}Item<T>(props: ListItemProps<T>): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("${name}.Item", props);`);
-            lines.push(`}`);
-        }
-        else if (isColumnViewWidget(widgetName)) {
-            lines.push(`/**`);
-            lines.push(` * Props for the ${name}.Root component with column sorting UI indicators.`);
-            lines.push(` * @typeParam C - The union type of column IDs for type-safe sorting indicators.`);
-            lines.push(` */`);
-            lines.push(`interface ${name}RootPropsExtended<C extends string = string> extends ${name}Props, ColumnViewRootProps<C> {}`);
-            lines.push(``);
-            lines.push(`function ${name}Root<C extends string = string>(props: ${name}RootPropsExtended<C>): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("${name}.Root", props);`);
-            lines.push(`}`);
-            lines.push(``);
-            lines.push(`/**`);
-            lines.push(` * Props for ${name}.Column with type-safe cell rendering.`);
-            lines.push(` * @typeParam T - The type of items passed to the renderCell function.`);
-            lines.push(` */`);
-            lines.push(`interface ${name}GenericColumnProps<T> extends Omit<ColumnViewColumnProps, "renderCell"> {`);
-            lines.push(`\t/** Render function for column cells. Called with null during setup (for loading state). */`);
-            lines.push(`\trenderCell: (item: T | null) => import("react").ReactElement;`);
-            lines.push(`}`);
-            lines.push(``);
-            lines.push(`function ${name}Column<T>(props: ${name}GenericColumnProps<T>): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("${name}.Column", props);`);
-            lines.push(`}`);
-            lines.push(``);
-            lines.push(`function ${name}Item<T>(props: ListItemProps<T>): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("${name}.Item", props);`);
-            lines.push(`}`);
-        }
-        else if (isDropDownWidget(widgetName)) {
-            lines.push(`function ${name}Root(props: ${name}Props): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("${name}.Root", props);`);
-            lines.push(`}`);
-            lines.push(``);
-            lines.push(`function ${name}Item(props: StringListItemProps): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("${name}.Item", props);`);
-            lines.push(`}`);
-        }
-        else if (isStackWidget(widgetName)) {
-            lines.push(`function ${name}Root(props: StackRootProps & ${name}Props): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("${name}.Root", props);`);
-            lines.push(`}`);
-            lines.push(``);
-            lines.push(`function ${name}Page(props: StackPageProps): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("${name}.Page", props);`);
-            lines.push(`}`);
-        }
-        else if (isPopoverMenuWidget(widgetName)) {
-            lines.push(`function ${name}Root(props: MenuRootProps & ${name}Props): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("${name}.Root", props);`);
-            lines.push(`}`);
-            lines.push(``);
-            lines.push(`function ${name}Item(props: MenuItemProps): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("Menu.Item", props);`);
-            lines.push(`}`);
-            lines.push(``);
-            lines.push(`function ${name}Section(props: MenuSectionProps): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("Menu.Section", props);`);
-            lines.push(`}`);
-            lines.push(``);
-            lines.push(`function ${name}Submenu(props: MenuSubmenuProps): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("Menu.Submenu", props);`);
-            lines.push(`}`);
-        }
-        for (const slot of metadata.namedChildSlots) {
-            lines.push(``);
-            lines.push(`function ${name}${slot.slotName}(props: SlotProps): import("react").ReactElement {`);
-            lines.push(`\treturn createElement("${name}.${slot.slotName}", props);`);
-            lines.push(`}`);
-        }
-        return lines.join("\n");
-    }
-    generateJsxNamespace(widgets, containerMetadata) {
-        const elements = [];
-        for (const { widget, namespace } of widgets) {
-            if (widget.name === "Widget")
-                continue;
-            this.currentNamespace = namespace;
-            const widgetName = this.getWidgetExportName(widget);
-            const propsName = `${widgetName}Props`;
-            const metadataKey = `${namespace}.${widget.name}`;
-            const metadata = containerMetadata.get(metadataKey);
-            if (!metadata)
-                throw new Error(`Missing container metadata for widget: ${metadataKey}`);
-            const nonChildSlots = metadata.namedChildSlots.filter((slot) => slot.slotName !== "Child");
-            const hasMeaningfulSlots = nonChildSlots.length > 0 ||
-                isListWidget(widget.name) ||
-                isColumnViewWidget(widget.name) ||
-                isDropDownWidget(widget.name) ||
-                isGridWidget(widget.name) ||
-                isNotebookWidget(widget.name) ||
-                isStackWidget(widget.name) ||
-                isPopoverMenuWidget(widget.name);
-            if (hasMeaningfulSlots) {
-                elements.push(`"${widgetName}.Root": ${propsName};`);
-            }
-            else {
-                elements.push(`${widgetName}: ${propsName};`);
-            }
-            for (const slot of metadata.namedChildSlots) {
-                elements.push(`"${widgetName}.${slot.slotName}": SlotProps;`);
-            }
-            if (isListWidget(widget.name)) {
-                elements.push(`"${widgetName}.Item": ListItemProps;`);
-            }
-            if (isColumnViewWidget(widget.name)) {
-                elements.push(`"${widgetName}.Column": ColumnViewColumnProps;`);
-                elements.push(`"${widgetName}.Item": ListItemProps;`);
-            }
-            if (isDropDownWidget(widget.name)) {
-                elements.push(`"${widgetName}.Item": StringListItemProps;`);
-            }
-            if (isGridWidget(widget.name)) {
-                elements.push(`"${widgetName}.Child": GridChildProps;`);
-            }
-            if (isNotebookWidget(widget.name)) {
-                elements.push(`"${widgetName}.Page": NotebookPageProps;`);
-            }
-            if (isStackWidget(widget.name)) {
-                elements.push(`"${widgetName}.Page": StackPageProps;`);
-            }
-        }
-        this.addMenuIntrinsicElements(elements);
-        elements.push(`ApplicationMenu: MenuRootProps;`);
-        return `
-declare global {
-\tnamespace React {
-\t\tnamespace JSX {
-\t\t\tinterface IntrinsicElements {
-\t\t\t\t${elements.join("\n\t\t\t\t")}
-\t\t\t}
-\t\t}
-\t}
-}
-`;
-    }
-    addMenuIntrinsicElements(elements) {
-        elements.push(`"Menu.Item": MenuItemProps;`);
-        elements.push(`"Menu.Section": MenuSectionProps;`);
-        elements.push(`"Menu.Submenu": MenuSubmenuProps;`);
-    }
-    async formatCode(code) {
-        try {
-            return await format(code, {
-                parser: "typescript",
-                ...(this.options.prettierConfig &&
-                    typeof this.options.prettierConfig === "object" &&
-                    this.options.prettierConfig !== null
-                    ? this.options.prettierConfig
-                    : {}),
-            });
-        }
-        catch (error) {
-            console.warn("Failed to format code:", error);
-            return code;
-        }
-    }
-}