@gtkx/react 0.19.0 → 0.21.0

package/src/nodes/column-view-column.ts

@@ -1,19 +1,34 @@
+import { getNativeId } from "@gtkx/ffi";
 import * as Gio from "@gtkx/ffi/gio";
+import type * as GObject from "@gtkx/ffi/gobject";
 import * as Gtk from "@gtkx/ffi/gtk";
-import type { ColumnViewColumnProps } from "../jsx.js";
+import type { ColumnViewColumnProps, ListItem } from "../jsx.js";
 import type { Node } from "../node.js";
 import type { Container } from "../types.js";
-import { GridItemRenderer } from "./internal/grid-item-renderer.js";
-import { ListItemRenderer } from "./internal/list-item-renderer.js";
-import type { ListStore } from "./internal/list-store.js";
+import type { BoundItem } from "./internal/bound-item.js";
 import { hasChanged } from "./internal/props.js";
-import type { TreeStore } from "./internal/tree-store.js";
 import { MenuNode } from "./menu.js";
 import { MenuModel } from "./models/menu.js";
 import { VirtualNode } from "./virtual.js";
 import { WidgetNode } from "./widget.js";
 
-export class ColumnViewColumnNode extends VirtualNode<ColumnViewColumnProps, WidgetNode<Gtk.ColumnView>, MenuNode> {
+const UNBOUND_POSITION = -1;
+
+export class ColumnViewColumnNode extends VirtualNode<ColumnViewColumnProps, WidgetNode, MenuNode> {
+    private column: Gtk.ColumnViewColumn | null = null;
+    private columnFactory: Gtk.SignalListItemFactory | null = null;
+    private containers = new Map<Gtk.ListItem, number>();
+    private containerKeys = new Map<Gtk.ListItem, string>();
+    private menu: MenuModel;
+    private actionGroup: Gio.SimpleActionGroup;
+
+    constructor(typeName: string, props: ColumnViewColumnProps, container: undefined, rootContainer: Container) {
+        super(typeName, props, container, rootContainer);
+        this.actionGroup = new Gio.SimpleActionGroup();
+        this.menu = new MenuModel("root", {}, rootContainer, this.actionGroup);
+        this.menu.setActionMap(this.actionGroup, props.id);
+    }
+
     public override isValidChild(child: Node): boolean {
         return child instanceof MenuNode;
     }
@@ -21,172 +36,154 @@ export class ColumnViewColumnNode extends VirtualNode<ColumnViewColumnProps, Wid
     public override isValidParent(parent: Node): boolean {
         return parent instanceof WidgetNode && parent.container instanceof Gtk.ColumnView;
     }
-    private column: Gtk.ColumnViewColumn;
-    private treeRenderer: ListItemRenderer | null;
-    private flatRenderer: GridItemRenderer | null = null;
-    private menu: MenuModel | null = null;
-    private actionGroup: Gio.SimpleActionGroup | null = null;
-    private columnView: Gtk.ColumnView | null = null;
 
-    constructor(typeName: string, props: ColumnViewColumnProps, container: undefined, rootContainer: Container) {
-        super(typeName, props, container, rootContainer);
-        this.treeRenderer = new ListItemRenderer(this.signalStore);
-        this.column = new Gtk.ColumnViewColumn();
-        this.column.setFactory(this.treeRenderer.getFactory());
+    public override finalizeInitialChildren(props: ColumnViewColumnProps): boolean {
+        this.setupFactory();
+        this.setupColumn(props);
+        this.updateHeaderMenu();
+        return false;
+    }
+
+    public override commitUpdate(oldProps: ColumnViewColumnProps | null, newProps: ColumnViewColumnProps): void {
+        super.commitUpdate(oldProps, newProps);
+        if (oldProps === null) return;
+        this.applyColumnProps(oldProps, newProps);
     }
 
     public override appendChild(child: MenuNode): void {
-        this.initMenu();
-        this.menu?.appendChild(child);
+        this.menu.appendChild(child);
+        this.updateHeaderMenu();
     }
 
     public override insertBefore(child: MenuNode, before: MenuNode): void {
-        this.initMenu();
-        if (before instanceof MenuNode) {
-            this.menu?.insertBefore(child, before);
-        } else {
-            this.menu?.appendChild(child);
-        }
+        this.menu.insertBefore(child, before);
+        this.updateHeaderMenu();
     }
 
     public override removeChild(child: MenuNode): void {
-        this.menu?.removeChild(child);
-
-        if (this.menu && this.menu.getMenu().getNItems() === 0) {
-            this.cleanupMenu();
-        }
-    }
-
-    public override commitUpdate(oldProps: ColumnViewColumnProps | null, newProps: ColumnViewColumnProps): void {
-        super.commitUpdate(oldProps, newProps);
-        this.applyOwnProps(oldProps, newProps);
+        this.menu.removeChild(child);
+        this.updateHeaderMenu();
     }
 
     public override detachDeletedInstance(): void {
-        this.cleanupMenu();
-        this.treeRenderer?.dispose();
-        this.flatRenderer?.dispose();
         super.detachDeletedInstance();
     }
 
     public getColumn(): Gtk.ColumnViewColumn {
+        if (!this.column) throw new Error("ColumnViewColumn not initialized");
         return this.column;
     }
 
-    public rebindItem(id: string): void {
-        this.treeRenderer?.rebindItem(id);
-        this.flatRenderer?.rebindItem(id);
-    }
-
-    public setStore(model: TreeStore | null): void {
-        this.treeRenderer?.setStore(model);
-    }
-
-    public setFlatStore(store: ListStore): void {
-        if (this.treeRenderer) {
-            this.treeRenderer.dispose();
-            this.treeRenderer = null;
-        }
-        if (!this.flatRenderer) {
-            this.flatRenderer = new GridItemRenderer(this.signalStore);
-            this.flatRenderer.setRenderFn(this.props.renderCell);
-            this.column.setFactory(this.flatRenderer.getFactory());
-        }
-        this.flatRenderer.setStore(store);
-    }
+    public collectBoundItems(flatItems: ListItem[]): BoundItem[] {
+        const { renderCell } = this.props;
+        if (!renderCell) return [];
 
-    public setEstimatedRowHeight(height: number | null): void {
-        this.treeRenderer?.setEstimatedItemHeight(height);
-        this.flatRenderer?.setEstimatedItemHeight(height);
-    }
+        const items: BoundItem[] = [];
 
-    public attachToColumnView(columnView: Gtk.ColumnView): void {
-        this.columnView = columnView;
+        for (const [container, position] of this.containers) {
+            if (position === UNBOUND_POSITION) continue;
 
-        if (this.actionGroup) {
-            this.columnView.insertActionGroup(this.props.id, this.actionGroup);
-        }
-    }
+            const key = this.containerKeys.get(container);
+            if (!key) continue;
 
-    public detachFromColumnView(): void {
-        if (this.columnView && this.actionGroup) {
-            this.columnView.insertActionGroup(this.props.id, null);
+            const item = flatItems[position];
+            if (!item) continue;
+            const content = renderCell(item.value);
+            items.push([content, container, key]);
         }
 
-        this.columnView = null;
+        return items;
     }
 
-    private initMenu(): void {
-        if (this.menu) return;
-
-        this.actionGroup = new Gio.SimpleActionGroup();
-        this.menu = new MenuModel("root", {}, this.rootContainer);
-        this.menu.setActionMap(this.actionGroup, this.props.id);
-        this.column.setHeaderMenu(this.menu.getMenu());
+    public installActionGroup(widget: Gtk.Widget): void {
+        widget.insertActionGroup(this.props.id, this.actionGroup);
+    }
 
-        if (this.columnView) {
-            this.columnView.insertActionGroup(this.props.id, this.actionGroup);
-        }
+    public uninstallActionGroup(widget: Gtk.Widget): void {
+        widget.insertActionGroup(this.props.id, null);
     }
 
-    private cleanupMenu(): void {
-        if (!this.menu) return;
+    private setupFactory(): void {
+        this.columnFactory = new Gtk.SignalListItemFactory();
 
-        this.column.setHeaderMenu(null);
+        this.columnFactory.connect("setup", (_self: GObject.Object, obj: GObject.Object) => {
+            const listItem = obj as unknown as Gtk.ListItem;
+            const key = String(getNativeId(listItem.handle));
+            const placeholder = new Gtk.Box();
+            const { width, height } = this.getParentEstimatedItemSize();
+            placeholder.setSizeRequest(width, height);
+            listItem.setChild(placeholder);
+            this.containers.set(listItem, UNBOUND_POSITION);
+            this.containerKeys.set(listItem, key);
+        });
 
-        if (this.columnView && this.actionGroup) {
-            this.columnView.insertActionGroup(this.props.id, null);
-        }
+        this.columnFactory.connect("bind", (_self: GObject.Object, obj: GObject.Object) => {
+            const listItem = obj as unknown as Gtk.ListItem;
+            this.containers.set(listItem, listItem.getPosition());
+            this.scheduleParentUpdate();
+        });
 
-        this.menu = null;
-        this.actionGroup = null;
+        this.columnFactory.connect("unbind", (_self: GObject.Object, obj: GObject.Object) => {
+            const listItem = obj as unknown as Gtk.ListItem;
+            this.containers.set(listItem, UNBOUND_POSITION);
+            this.scheduleParentUpdate();
+        });
+
+        this.columnFactory.connect("teardown", (_self: GObject.Object, obj: GObject.Object) => {
+            const listItem = obj as unknown as Gtk.ListItem;
+            this.containers.delete(listItem);
+            this.containerKeys.delete(listItem);
+            listItem.setChild(null);
+        });
     }
 
-    private applyOwnProps(oldProps: ColumnViewColumnProps | null, newProps: ColumnViewColumnProps): void {
-        if (hasChanged(oldProps, newProps, "renderCell")) {
-            this.treeRenderer?.setRenderFn(newProps.renderCell);
-            this.flatRenderer?.setRenderFn(newProps.renderCell);
-        }
+    private setupColumn(props: ColumnViewColumnProps): void {
+        this.column = new Gtk.ColumnViewColumn(props.title, this.columnFactory);
+        this.column.setId(props.id);
 
-        if (hasChanged(oldProps, newProps, "title")) {
-            this.column.setTitle(newProps.title);
-        }
-
-        if (hasChanged(oldProps, newProps, "expand")) {
-            this.column.setExpand(newProps.expand ?? false);
-        }
+        if (props.expand !== undefined) this.column.setExpand(props.expand);
+        if (props.resizable !== undefined) this.column.setResizable(props.resizable);
+        if (props.fixedWidth !== undefined) this.column.setFixedWidth(props.fixedWidth);
+        if (props.visible !== undefined) this.column.setVisible(props.visible);
+        if (props.sortable) this.column.setSorter(new Gtk.CustomSorter());
+    }
 
-        if (hasChanged(oldProps, newProps, "resizable")) {
-            this.column.setResizable(newProps.resizable ?? false);
-        }
+    private applyColumnProps(oldProps: ColumnViewColumnProps, newProps: ColumnViewColumnProps): void {
+        if (!this.column) return;
 
-        if (hasChanged(oldProps, newProps, "fixedWidth")) {
-            this.column.setFixedWidth(newProps.fixedWidth ?? -1);
+        if (hasChanged(oldProps, newProps, "title")) this.column.setTitle(newProps.title);
+        if (hasChanged(oldProps, newProps, "expand")) this.column.setExpand(newProps.expand ?? false);
+        if (hasChanged(oldProps, newProps, "resizable")) this.column.setResizable(newProps.resizable ?? false);
+        if (hasChanged(oldProps, newProps, "fixedWidth")) this.column.setFixedWidth(newProps.fixedWidth ?? -1);
+        if (hasChanged(oldProps, newProps, "visible")) this.column.setVisible(newProps.visible ?? true);
+        if (hasChanged(oldProps, newProps, "sortable")) {
+            this.column.setSorter(newProps.sortable ? new Gtk.CustomSorter() : null);
         }
+        if (hasChanged(oldProps, newProps, "renderCell")) this.scheduleParentUpdate();
+    }
 
-        if (hasChanged(oldProps, newProps, "id")) {
-            if (this.columnView && this.actionGroup && oldProps?.id) {
-                this.columnView.insertActionGroup(oldProps.id, null);
-                this.columnView.insertActionGroup(newProps.id, this.actionGroup);
-            }
-
-            this.column.setId(newProps.id);
-
-            if (oldProps && this.menu && this.actionGroup) {
-                this.menu.setActionMap(this.actionGroup, newProps.id);
-            }
-        }
+    private updateHeaderMenu(): void {
+        if (!this.column) return;
+        const menu = this.menu.getMenu();
+        this.column.setHeaderMenu(menu.getNItems() > 0 ? menu : null);
+    }
 
-        if (hasChanged(oldProps, newProps, "visible")) {
-            this.column.setVisible(newProps.visible ?? true);
+    private getParentEstimatedItemSize(): { width: number; height: number } {
+        if (this.parent && "getEstimatedItemSize" in this.parent) {
+            return (
+                this.parent as { getEstimatedItemSize(): { width: number; height: number } }
+            ).getEstimatedItemSize();
         }
+        return { width: -1, height: -1 };
+    }
 
-        if (hasChanged(oldProps, newProps, "sortable")) {
-            if (newProps.sortable) {
-                this.column.setSorter(new Gtk.StringSorter());
-            } else {
-                this.column.setSorter(null);
-            }
+    private scheduleParentUpdate(): void {
+        if (
+            this.parent &&
+            "scheduleBoundItemsUpdate" in this.parent &&
+            typeof this.parent.scheduleBoundItemsUpdate === "function"
+        ) {
+            (this.parent as { scheduleBoundItemsUpdate(): void }).scheduleBoundItemsUpdate();
         }
     }
 }

package/src/nodes/container-slot.ts

@@ -16,7 +16,7 @@ export class ContainerSlotNode extends VirtualNode<ContainerSlotProps, WidgetNod
 
     public override setParent(parent: WidgetNode | null): void {
         if (!parent && this.parent) {
-            this.detachAllChildren(this.parent.container);
+            this.detachAllFromGtkParent();
         }
 
         super.setParent(parent);
@@ -32,6 +32,7 @@ export class ContainerSlotNode extends VirtualNode<ContainerSlotProps, WidgetNod
         super.appendChild(child);
 
         if (this.parent) {
+            this.detachFromGtkParent(child);
             this.attachToParent(this.parent.container, child.container);
         }
     }
@@ -40,25 +41,18 @@ export class ContainerSlotNode extends VirtualNode<ContainerSlotProps, WidgetNod
         super.insertBefore(child, before);
 
         if (this.parent) {
-            this.attachToParent(this.parent.container, child.container);
+            this.reinsertAllChildren();
         }
     }
 
     public override removeChild(child: WidgetNode): void {
-        if (this.parent && isRemovable(this.parent.container)) {
-            const widget = child.container;
-            const currentParent = widget.getParent();
-            if (currentParent && currentParent === this.parent.container) {
-                this.parent.container.remove(widget);
-            }
-        }
-
+        this.detachFromGtkParent(child);
         super.removeChild(child);
     }
 
     public override detachDeletedInstance(): void {
         if (this.parent) {
-            this.detachAllChildren(this.parent.container);
+            this.detachAllFromGtkParent();
         }
         super.detachDeletedInstance();
     }
@@ -74,14 +68,33 @@ export class ContainerSlotNode extends VirtualNode<ContainerSlotProps, WidgetNod
         (method as (child: Gtk.Widget) => void).call(parent, child);
     }
 
-    private detachAllChildren(parent: Gtk.Widget): void {
-        if (!isRemovable(parent)) return;
+    private detachFromGtkParent(child: WidgetNode): void {
+        const currentParent = child.container.getParent();
+        if (currentParent !== null) {
+            if (isRemovable(currentParent)) {
+                currentParent.remove(child.container);
+            } else {
+                child.container.unparent();
+            }
+        }
+    }
+
+    private reinsertAllChildren(): void {
+        if (!this.parent) return;
+        const parent = this.parent.container;
 
         for (const child of this.children) {
-            const currentParent = child.container.getParent();
-            if (currentParent && currentParent === parent) {
-                parent.remove(child.container);
-            }
+            this.detachFromGtkParent(child);
+        }
+
+        for (const child of this.children) {
+            this.attachToParent(parent, child.container);
+        }
+    }
+
+    private detachAllFromGtkParent(): void {
+        for (const child of this.children) {
+            this.detachFromGtkParent(child);
         }
     }
 }

package/src/nodes/drawing-area.ts

@@ -7,40 +7,16 @@ import { filterProps, hasChanged } from "./internal/props.js";
 import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
 
-const OWN_PROPS = ["onDraw"] as const;
+const OWN_PROPS = ["render"] as const;
 
 type DrawFunc = (cr: import("@gtkx/ffi/cairo").Context, width: number, height: number, self: Gtk.DrawingArea) => void;
 type DrawingAreaProps = Pick<GtkDrawingAreaProps, (typeof OWN_PROPS)[number]>;
 
-type PendingDrawFuncEntry = { container: Gtk.DrawingArea; fn: DrawFunc };
-
-const pendingDrawFuncs: PendingDrawFuncEntry[] = [];
-
-function wrapDrawFunc(
-    fn: DrawFunc,
-): (self: Gtk.DrawingArea, cr: import("@gtkx/ffi/cairo").Context, width: number, height: number) => void {
-    return (self, cr, width, height) => fn(cr, width, height, self);
-}
-
-function ensurePendingBatch(): PendingDrawFuncEntry[] {
-    if (pendingDrawFuncs.length === 0) {
-        queueMicrotask(flushPendingDrawFuncs);
-    }
-
-    return pendingDrawFuncs;
-}
-
-function flushPendingDrawFuncs(): void {
-    const batch = pendingDrawFuncs.splice(0);
-
-    for (const { container, fn } of batch) {
-        container.setDrawFunc(wrapDrawFunc(fn));
-    }
-}
-
 type DrawingAreaChild = EventControllerNode | SlotNode | ContainerSlotNode;
 
 export class DrawingAreaNode extends WidgetNode<Gtk.DrawingArea, DrawingAreaProps, DrawingAreaChild> {
+    private currentDrawFunc: DrawFunc | null = null;
+
     public override isValidChild(child: Node): boolean {
         return child instanceof EventControllerNode || child instanceof SlotNode || child instanceof ContainerSlotNode;
     }
@@ -50,12 +26,27 @@ export class DrawingAreaNode extends WidgetNode<Gtk.DrawingArea, DrawingAreaProp
         this.applyOwnProps(oldProps, newProps);
     }
 
+    public override detachDeletedInstance(): void {
+        this.currentDrawFunc = null;
+        this.container.setDrawFunc(undefined);
+        super.detachDeletedInstance();
+    }
+
     private applyOwnProps(oldProps: DrawingAreaProps | null, newProps: DrawingAreaProps): void {
-        if (hasChanged(oldProps, newProps, "onDraw")) {
-            if (this.container.getAllocatedWidth() > 0) {
-                this.container.setDrawFunc(newProps.onDraw ? wrapDrawFunc(newProps.onDraw) : null);
-            } else if (newProps.onDraw) {
-                ensurePendingBatch().push({ container: this.container, fn: newProps.onDraw });
+        if (hasChanged(oldProps, newProps, "render")) {
+            const hadDraw = !!oldProps?.render;
+            const hasDraw = !!newProps.render;
+
+            this.currentDrawFunc = newProps.render ?? null;
+
+            if (hasDraw && !hadDraw) {
+                this.container.setDrawFunc((self, cr, width, height) => {
+                    this.currentDrawFunc?.(cr, width, height, self);
+                });
+            } else if (!hasDraw && hadDraw) {
+                this.container.setDrawFunc(undefined);
+            } else if (hasDraw) {
+                this.container.queueDraw();
             }
         }
     }

package/src/nodes/event-controller.ts

@@ -1,9 +1,8 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { CONSTRUCTOR_PROPS } from "../generated/internal.js";
 import { isConstructOnlyProp, resolvePropMeta, resolveSignal } from "../metadata.js";
 import { Node } from "../node.js";
 import type { Props } from "../types.js";
-import { createContainerWithConstructOnly } from "./internal/construct.js";
+import { createContainerWithProperties } from "./internal/construct.js";
 import type { SignalHandler } from "./internal/signal-store.js";
 import { WidgetNode } from "./widget.js";
 
@@ -18,19 +17,12 @@ export class EventControllerNode<
         props: Props,
         containerClass: typeof Gtk.EventController,
     ): Gtk.EventController {
-        const typeName = containerClass.glibTypeName;
-
-        if (typeName === "GtkDropTarget") {
+        if (containerClass.glibTypeName === "GtkDropTarget") {
             const actions = (props.actions as number | undefined) ?? 0;
             return new Gtk.DropTarget(G_TYPE_INVALID, actions);
         }
 
-        const args = (CONSTRUCTOR_PROPS[typeName] ?? []).map((name) => props[name]);
-
-        return createContainerWithConstructOnly(containerClass, props, () => {
-            // biome-ignore lint/suspicious/noExplicitAny: Dynamic constructor invocation
-            return new (containerClass as any)(...args);
-        }) as Gtk.EventController;
+        return createContainerWithProperties(containerClass, props) as Gtk.EventController;
     }
 
     public override isValidChild(child: Node): boolean {
@@ -95,14 +87,10 @@ export class EventControllerNode<
             return;
         }
 
-        const propMeta = resolvePropMeta(this.container, name);
+        const propName = resolvePropMeta(this.container, name);
 
-        if (propMeta) {
-            const [, setterName] = propMeta;
-            const setterFn = (this.container as unknown as Record<string, (v: unknown) => void>)[setterName];
-            if (typeof setterFn === "function") {
-                setterFn.call(this.container, value);
-            }
+        if (propName) {
+            (this.container as unknown as Record<string, unknown>)[propName] = value;
         }
     }
 }

package/src/nodes/fixed-child.ts

@@ -3,6 +3,7 @@ import * as Gsk from "@gtkx/ffi/gsk";
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { FixedChildProps } from "../jsx.js";
 import type { Node } from "../node.js";
+import { isRemovable } from "./internal/predicates.js";
 import { hasChanged } from "./internal/props.js";
 import { VirtualNode } from "./virtual.js";
 import { WidgetNode } from "./widget.js";
@@ -33,6 +34,7 @@ export class FixedChildNode extends VirtualNode<FixedChildProps, WidgetNode<Gtk.
         super.appendChild(child);
 
         if (this.parent) {
+            this.detachFromGtkParent(child.container);
             this.attachToParent(this.parent.container, child.container);
             this.applyLayoutTransform();
         }
@@ -82,6 +84,17 @@ export class FixedChildNode extends VirtualNode<FixedChildProps, WidgetNode<Gtk.
         }
     }
 
+    private detachFromGtkParent(child: Gtk.Widget): void {
+        const currentParent = child.getParent();
+        if (currentParent !== null) {
+            if (isRemovable(currentParent)) {
+                currentParent.remove(child);
+            } else {
+                child.unparent();
+            }
+        }
+    }
+
     private applyLayoutTransform(): void {
         if (!this.parent || !this.children[0]) return;
 

package/src/nodes/grid-child.ts

@@ -1,6 +1,7 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { GridChildProps } from "../jsx.js";
 import type { Node } from "../node.js";
+import { isRemovable } from "./internal/predicates.js";
 import { hasChanged } from "./internal/props.js";
 import { VirtualNode } from "./virtual.js";
 import { WidgetNode } from "./widget.js";
@@ -30,6 +31,7 @@ export class GridChildNode extends VirtualNode<GridChildProps, WidgetNode<Gtk.Gr
         super.appendChild(child);
 
         if (this.parent) {
+            this.detachFromGtkParent(child.container);
             this.attachToParent(this.parent.container, child.container);
         }
     }
@@ -84,6 +86,17 @@ export class GridChildNode extends VirtualNode<GridChildProps, WidgetNode<Gtk.Gr
         }
     }
 
+    private detachFromGtkParent(child: Gtk.Widget): void {
+        const currentParent = child.getParent();
+        if (currentParent !== null) {
+            if (isRemovable(currentParent)) {
+                currentParent.remove(child);
+            } else {
+                child.unparent();
+            }
+        }
+    }
+
     private reattachChild(): void {
         if (!this.parent || !this.children[0]) return;
 

package/src/nodes/internal/accessible.ts

@@ -29,7 +29,6 @@ const fromString: CreateValue = (val) => Value.newFromString(val as string);
 const fromBoolean: CreateValue = (val) => Value.newFromBoolean(val as boolean);
 const fromInt: CreateValue = (val) => Value.newFromInt(val as number);
 const fromDouble: CreateValue = (val) => Value.newFromDouble(val as number);
-
 const fromObject: CreateValue = (val) => Value.newFromObject((val as GObject.Object) ?? null);
 
 const fromRefList: CreateValue = (val) => {

package/src/nodes/internal/bound-item.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from "react";
+import type { Container } from "../../types.js";
+
+export type BoundItem = [ReactNode, Container, string];