@gtkx/react 0.17.2 → 0.18.0

package/dist/nodes/event-controller.d.ts

@@ -1,22 +1,13 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import { Node } from "../node.js";
-import type { Container, Props } from "../types.js";
-import type { Attachable } from "./internal/predicates.js";
-export declare class EventControllerNode<T extends Gtk.EventController = Gtk.EventController> extends Node<T, Props> implements Attachable {
-    static priority: number;
-    static matches(type: string): boolean;
+import type { Props } from "../types.js";
+import { WidgetNode } from "./widget.js";
+export declare class EventControllerNode<T extends Gtk.EventController = Gtk.EventController, TChild extends Node = any> extends Node<T, Props, WidgetNode, TChild> {
     static createContainer(props: Props, containerClass: typeof Gtk.EventController): Gtk.EventController;
-    props: Props;
-    protected parentWidget: Gtk.Widget | null;
-    constructor(typeName: string, props: Props, container: T, rootContainer: Container);
-    canBeChildOf(parent: Node): boolean;
-    appendChild(_child: Node): void;
-    removeChild(_child: Node): void;
-    insertBefore(_child: Node, _before: Node): void;
-    attachTo(parent: Node): void;
-    detachFrom(_parent: Node): void;
-    updateProps(oldProps: Props | null, newProps: Props): void;
-    unmount(): void;
-    private applyProps;
+    isValidParent(parent: Node): boolean;
+    setParent(parent: WidgetNode | null): void;
+    commitUpdate(oldProps: Props | null, newProps: Props): void;
+    detachDeletedInstance(): void;
+    private applyOwnProps;
     private setProperty;
 }

package/dist/nodes/event-controller.js

@@ -1,64 +1,43 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { CONTROLLER_CLASSES, CONTROLLER_CONSTRUCTOR_PROPS } from "../generated/internal.js";
+import { CONSTRUCTOR_PROPS } from "../generated/internal.js";
+import { resolvePropMeta, resolveSignal } from "../metadata.js";
 import { Node } from "../node.js";
-import { registerNodeClass } from "../registry.js";
-import { propNameToSignalName, resolvePropMeta, resolveSignal } from "./internal/utils.js";
 import { WidgetNode } from "./widget.js";
 const G_TYPE_INVALID = 0;
 export class EventControllerNode extends Node {
-    static priority = 1;
-    static matches(type) {
-        return type in CONTROLLER_CLASSES;
-    }
     static createContainer(props, containerClass) {
         const typeName = containerClass.glibTypeName;
         if (typeName === "GtkDropTarget") {
             const actions = props.actions ?? 0;
             return new Gtk.DropTarget(G_TYPE_INVALID, actions);
         }
-        const args = (CONTROLLER_CONSTRUCTOR_PROPS[typeName] ?? []).map((name) => props[name]);
+        const args = (CONSTRUCTOR_PROPS[typeName] ?? []).map((name) => props[name]);
         // biome-ignore lint/suspicious/noExplicitAny: Dynamic constructor invocation
         return new containerClass(...args);
     }
-    props;
-    parentWidget = null;
-    constructor(typeName, props, container, rootContainer) {
-        super(typeName, props, container, rootContainer);
-        this.props = props;
-    }
-    canBeChildOf(parent) {
+    isValidParent(parent) {
         return parent instanceof WidgetNode;
     }
-    appendChild(_child) { }
-    removeChild(_child) { }
-    insertBefore(_child, _before) { }
-    attachTo(parent) {
-        if (parent instanceof WidgetNode) {
-            this.parentWidget = parent.container;
-            parent.container.addController(this.container);
+    setParent(parent) {
+        if (!parent && this.parent) {
+            this.parent.container.removeController(this.container);
         }
-    }
-    detachFrom(_parent) {
-        if (this.parentWidget) {
-            this.parentWidget.removeController(this.container);
+        super.setParent(parent);
+        if (parent) {
+            parent.container.addController(this.container);
         }
-        this.parentWidget = null;
     }
-    updateProps(oldProps, newProps) {
-        this.props = newProps;
-        this.applyProps(oldProps, newProps);
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps, newProps);
+        this.applyOwnProps(oldProps, newProps);
     }
-    unmount() {
-        if (this.parentWidget) {
-            this.parentWidget.removeController(this.container);
+    detachDeletedInstance() {
+        if (this.parent && this.container.getWidget() === this.parent.container) {
+            this.parent.container.removeController(this.container);
         }
-        this.parentWidget = null;
-        super.unmount();
+        super.detachDeletedInstance();
     }
-    applyProps(oldProps, newProps) {
-        if (!this.container) {
-            throw new Error(`EventControllerNode.applyProps: container is undefined for ${this.typeName}`);
-        }
+    applyOwnProps(oldProps, newProps) {
         const propNames = new Set([...Object.keys(oldProps ?? {}), ...Object.keys(newProps ?? {})]);
         for (const name of propNames) {
             if (name === "children")
@@ -67,8 +46,8 @@ export class EventControllerNode extends Node {
             const newValue = newProps[name];
             if (oldValue === newValue)
                 continue;
-            const signalName = propNameToSignalName(name);
-            if (resolveSignal(this.container, signalName)) {
+            const signalName = resolveSignal(this.container, name);
+            if (signalName) {
                 const handler = typeof newValue === "function" ? newValue : undefined;
                 this.signalStore.set(this, this.container, signalName, handler, { blockable: false });
             }
@@ -93,4 +72,3 @@ export class EventControllerNode extends Node {
         }
     }
 }
-registerNodeClass(EventControllerNode);

package/dist/nodes/fixed-child.d.ts

@@ -1 +1,18 @@
-export {};
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { FixedChildProps } from "../jsx.js";
+import type { Node } from "../node.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export declare class FixedChildNode extends VirtualNode<FixedChildProps, WidgetNode<Gtk.Fixed>, WidgetNode> {
+    isValidChild(child: Node): boolean;
+    isValidParent(parent: Node): boolean;
+    setParent(parent: WidgetNode<Gtk.Fixed> | null): void;
+    appendChild(child: WidgetNode): void;
+    removeChild(child: WidgetNode): void;
+    commitUpdate(oldProps: FixedChildProps | null, newProps: FixedChildProps): void;
+    detachDeletedInstance(): void;
+    private attachToParent;
+    private detachFromParent;
+    private repositionChild;
+    private applyTransform;
+}

package/dist/nodes/fixed-child.js

@@ -1,36 +1,40 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { registerNodeClass } from "../registry.js";
-import { PositionalChildNode } from "./abstract/positional-child.js";
-import { hasChanged } from "./internal/utils.js";
-class FixedChildNode extends PositionalChildNode {
-    static priority = 1;
-    static matches(type) {
-        return type === "FixedChild";
+import { hasChanged } from "./internal/props.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export class FixedChildNode extends VirtualNode {
+    isValidChild(child) {
+        return child instanceof WidgetNode;
     }
-    canBeChildOf(parent) {
-        return parent.container instanceof Gtk.Fixed;
+    isValidParent(parent) {
+        return parent instanceof WidgetNode && parent.container instanceof Gtk.Fixed;
     }
-    onChildChange(oldChild) {
-        super.onChildChange(oldChild);
-        if (this.child) {
+    setParent(parent) {
+        if (!parent && this.parent && this.children[0]) {
+            this.detachFromParent(this.parent.container, this.children[0].container);
+        }
+        super.setParent(parent);
+        if (parent && this.children[0]) {
+            this.attachToParent(parent.container, this.children[0].container);
             this.applyTransform();
         }
     }
-    attachToParent(parent, child) {
-        const fixed = parent;
-        const x = this.props.x ?? 0;
-        const y = this.props.y ?? 0;
-        fixed.put(child, x, y);
-    }
-    detachFromParent(parent, child) {
-        parent.remove(child);
+    appendChild(child) {
+        super.appendChild(child);
+        if (this.parent) {
+            this.attachToParent(this.parent.container, child.container);
+            this.applyTransform();
+        }
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
-        this.applyOwnProps(oldProps, newProps);
+    removeChild(child) {
+        if (this.parent) {
+            this.detachFromParent(this.parent.container, child.container);
+        }
+        super.removeChild(child);
     }
-    applyOwnProps(oldProps, newProps) {
-        if (!this.parent || !this.child) {
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps, newProps);
+        if (!this.parent || !this.children[0]) {
             return;
         }
         const positionChanged = hasChanged(oldProps, newProps, "x") || hasChanged(oldProps, newProps, "y");
@@ -41,29 +45,41 @@ class FixedChildNode extends PositionalChildNode {
             this.applyTransform();
         }
     }
+    detachDeletedInstance() {
+        if (this.parent && this.children[0]) {
+            this.detachFromParent(this.parent.container, this.children[0].container);
+        }
+        super.detachDeletedInstance();
+    }
+    attachToParent(parent, child) {
+        const x = this.props.x ?? 0;
+        const y = this.props.y ?? 0;
+        parent.put(child, x, y);
+    }
+    detachFromParent(parent, child) {
+        const childParent = child.getParent();
+        if (childParent && childParent === parent) {
+            parent.remove(child);
+        }
+    }
     repositionChild() {
-        const fixed = this.getTypedParent();
-        const child = this.child;
-        if (!child) {
+        if (!this.parent || !this.children[0])
             return;
-        }
         const x = this.props.x ?? 0;
         const y = this.props.y ?? 0;
-        fixed.remove(child);
-        fixed.put(child, x, y);
+        this.parent.container.remove(this.children[0].container);
+        this.parent.container.put(this.children[0].container, x, y);
         this.applyTransform();
     }
     applyTransform() {
-        if (!this.child || !this.props.transform) {
+        if (!this.parent || !this.children[0] || !this.props.transform) {
             return;
         }
-        const fixed = this.getTypedParent();
-        const layoutManager = fixed.getLayoutManager();
+        const layoutManager = this.parent.container.getLayoutManager();
         if (!layoutManager) {
             return;
         }
-        const layoutChild = layoutManager.getLayoutChild(this.child);
+        const layoutChild = layoutManager.getLayoutChild(this.children[0].container);
         layoutChild.setTransform(this.props.transform);
     }
 }
-registerNodeClass(FixedChildNode);

package/dist/nodes/font-dialog-button.d.ts

@@ -1 +1,14 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { GtkFontDialogButtonProps } from "../jsx.js";
+import type { Container } from "../types.js";
+import { WidgetNode } from "./widget.js";
+declare const OWN_PROPS: readonly ["fontDesc", "onFontDescChanged", "title", "modal", "language", "useFont", "useSize", "level"];
+type FontDialogButtonProps = Pick<GtkFontDialogButtonProps, (typeof OWN_PROPS)[number]>;
+export declare class FontDialogButtonNode extends WidgetNode<Gtk.FontDialogButton, FontDialogButtonProps> {
+    private dialog;
+    static createContainer(_props: FontDialogButtonProps, containerClass: typeof Gtk.Widget): Container | null;
+    constructor(typeName: string, props: FontDialogButtonProps, container: Gtk.FontDialogButton, rootContainer: Container);
+    commitUpdate(oldProps: FontDialogButtonProps | null, newProps: FontDialogButtonProps): void;
+    private applyOwnProps;
+}
 export {};

package/dist/nodes/font-dialog-button.js

@@ -1,6 +1,5 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { registerNodeClass } from "../registry.js";
-import { filterProps, hasChanged, matchesAnyClass } from "./internal/utils.js";
+import { filterProps, hasChanged } from "./internal/props.js";
 import { WidgetNode } from "./widget.js";
 const OWN_PROPS = [
     "fontDesc",
@@ -12,33 +11,28 @@ const OWN_PROPS = [
     "useSize",
     "level",
 ];
-class FontDialogButtonNode extends WidgetNode {
-    static priority = 1;
+export class FontDialogButtonNode extends WidgetNode {
     dialog;
-    notifyHandler = null;
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass([Gtk.FontDialogButton], containerOrClass);
-    }
     static createContainer(_props, containerClass) {
         const dialog = new Gtk.FontDialog();
         const button = new containerClass(dialog);
         return button;
     }
-    constructor(type, props, container, rootContainer) {
-        super(type, props, container, rootContainer);
+    constructor(typeName, props, container, rootContainer) {
+        super(typeName, props, container, rootContainer);
         const dialog = container.getDialog();
         if (!dialog) {
             throw new Error("FontDialogButton must have a dialog");
         }
         this.dialog = dialog;
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
         this.applyOwnProps(oldProps, newProps);
     }
     applyOwnProps(oldProps, newProps) {
-        if (hasChanged(oldProps, newProps, "title") && newProps.title !== undefined) {
-            this.dialog.setTitle(newProps.title);
+        if (hasChanged(oldProps, newProps, "title")) {
+            this.dialog.setTitle(newProps.title ?? "");
         }
         if (hasChanged(oldProps, newProps, "modal")) {
             this.dialog.setModal(newProps.modal ?? true);
@@ -59,32 +53,15 @@ class FontDialogButtonNode extends WidgetNode {
             this.container.setFontDesc(newProps.fontDesc);
         }
         if (hasChanged(oldProps, newProps, "onFontDescChanged")) {
-            this.setupNotifyHandler(newProps.onFontDescChanged);
-        }
-    }
-    setupNotifyHandler(callback) {
-        if (this.notifyHandler) {
-            this.signalStore.set(this, this.container, "notify", undefined);
-            this.notifyHandler = null;
-        }
-        if (callback) {
-            this.notifyHandler = (_button, pspec) => {
-                if (pspec.getName() === "font-desc") {
+            const callback = newProps.onFontDescChanged;
+            this.signalStore.set(this, this.container, "notify::font-desc", callback
+                ? () => {
                     const fontDesc = this.container.getFontDesc();
                     if (fontDesc) {
                         callback(fontDesc);
                     }
                 }
-            };
-            this.signalStore.set(this, this.container, "notify", this.notifyHandler);
-        }
-    }
-    unmount() {
-        if (this.notifyHandler) {
-            this.signalStore.set(this, this.container, "notify", undefined);
-            this.notifyHandler = null;
+                : undefined);
         }
-        super.unmount();
     }
 }
-registerNodeClass(FontDialogButtonNode);

package/dist/nodes/grid-child.d.ts

@@ -1 +1,17 @@
-export {};
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { GridChildProps } from "../jsx.js";
+import type { Node } from "../node.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export declare class GridChildNode extends VirtualNode<GridChildProps, WidgetNode<Gtk.Grid>, WidgetNode> {
+    isValidChild(child: Node): boolean;
+    isValidParent(parent: Node): boolean;
+    setParent(parent: WidgetNode<Gtk.Grid> | null): void;
+    appendChild(child: WidgetNode): void;
+    removeChild(child: WidgetNode): void;
+    commitUpdate(oldProps: GridChildProps | null, newProps: GridChildProps): void;
+    detachDeletedInstance(): void;
+    private attachToParent;
+    private detachFromParent;
+    private reattachChild;
+}

package/dist/nodes/grid-child.js

@@ -1,60 +1,80 @@
-import { isObjectEqual } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
-import { registerNodeClass } from "../registry.js";
-import { PositionalChildNode } from "./abstract/positional-child.js";
-import { hasChanged } from "./internal/utils.js";
-class GridChildNode extends PositionalChildNode {
-    static priority = 1;
-    static matches(type) {
-        return type === "GridChild";
+import { hasChanged } from "./internal/props.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export class GridChildNode extends VirtualNode {
+    isValidChild(child) {
+        return child instanceof WidgetNode;
     }
-    canBeChildOf(parent) {
-        return parent.container instanceof Gtk.Grid;
+    isValidParent(parent) {
+        return parent instanceof WidgetNode && parent.container instanceof Gtk.Grid;
     }
-    attachToParent(parent, child) {
-        const grid = parent;
-        const column = this.props.column ?? 0;
-        const row = this.props.row ?? 0;
-        const columnSpan = this.props.columnSpan ?? 1;
-        const rowSpan = this.props.rowSpan ?? 1;
-        const existingChild = grid.getChildAt(column, row);
-        if (existingChild && !isObjectEqual(existingChild, child)) {
-            grid.remove(existingChild);
+    setParent(parent) {
+        if (!parent && this.parent && this.children[0]) {
+            this.detachFromParent(this.parent.container, this.children[0].container);
+        }
+        super.setParent(parent);
+        if (parent && this.children[0]) {
+            this.attachToParent(parent.container, this.children[0].container);
         }
-        grid.attach(child, column, row, columnSpan, rowSpan);
     }
-    detachFromParent(parent, child) {
-        parent.remove(child);
+    appendChild(child) {
+        super.appendChild(child);
+        if (this.parent) {
+            this.attachToParent(this.parent.container, child.container);
+        }
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
-        this.applyOwnProps(oldProps, newProps);
+    removeChild(child) {
+        if (this.parent) {
+            this.detachFromParent(this.parent.container, child.container);
+        }
+        super.removeChild(child);
     }
-    applyOwnProps(oldProps, newProps) {
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps, newProps);
         const positionChanged = hasChanged(oldProps, newProps, "column") ||
             hasChanged(oldProps, newProps, "row") ||
             hasChanged(oldProps, newProps, "columnSpan") ||
             hasChanged(oldProps, newProps, "rowSpan");
-        if (positionChanged && this.parent && this.child) {
+        if (positionChanged && this.parent && this.children[0]) {
             this.reattachChild();
         }
     }
+    detachDeletedInstance() {
+        if (this.parent && this.children[0]) {
+            this.detachFromParent(this.parent.container, this.children[0].container);
+        }
+        super.detachDeletedInstance();
+    }
+    attachToParent(parent, child) {
+        const column = this.props.column ?? 0;
+        const row = this.props.row ?? 0;
+        const columnSpan = this.props.columnSpan ?? 1;
+        const rowSpan = this.props.rowSpan ?? 1;
+        const existingChild = parent.getChildAt(column, row);
+        if (existingChild && existingChild !== child) {
+            parent.remove(existingChild);
+        }
+        parent.attach(child, column, row, columnSpan, rowSpan);
+    }
+    detachFromParent(parent, child) {
+        const childParent = child.getParent();
+        if (childParent && childParent === parent) {
+            parent.remove(child);
+        }
+    }
     reattachChild() {
-        const grid = this.getTypedParent();
-        const child = this.child;
-        if (!child) {
+        if (!this.parent || !this.children[0])
             return;
-        }
         const column = this.props.column ?? 0;
         const row = this.props.row ?? 0;
         const columnSpan = this.props.columnSpan ?? 1;
         const rowSpan = this.props.rowSpan ?? 1;
-        const existingChild = grid.getChildAt(column, row);
-        if (existingChild && !isObjectEqual(existingChild, child)) {
-            grid.remove(existingChild);
+        const existingChild = this.parent.container.getChildAt(column, row);
+        if (existingChild && existingChild !== this.children[0].container) {
+            this.parent.container.remove(existingChild);
         }
-        grid.remove(child);
-        grid.attach(child, column, row, columnSpan, rowSpan);
+        this.parent.container.remove(this.children[0].container);
+        this.parent.container.attach(this.children[0].container, column, row, columnSpan, rowSpan);
     }
 }
-registerNodeClass(GridChildNode);

package/dist/nodes/grid-view.d.ts

@@ -0,0 +1,24 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { GtkGridViewProps } from "../jsx.js";
+import type { Node } from "../node.js";
+import type { Container } from "../types.js";
+import { ListItemNode } from "./list-item.js";
+import { type GridModelProps } from "./models/grid.js";
+import { WidgetNode } from "./widget.js";
+declare const OWN_PROPS: readonly ["renderItem", "estimatedItemHeight"];
+type GridViewProps = Pick<GtkGridViewProps, (typeof OWN_PROPS)[number]> & GridModelProps;
+export declare class GridViewNode extends WidgetNode<Gtk.GridView, GridViewProps, ListItemNode> {
+    private itemRenderer;
+    private grid;
+    constructor(typeName: string, props: GridViewProps, container: Gtk.GridView, rootContainer: Container);
+    isValidChild(child: Node): boolean;
+    appendChild(child: ListItemNode): void;
+    insertBefore(child: ListItemNode, before: ListItemNode): void;
+    removeChild(child: ListItemNode): void;
+    finalizeInitialChildren(props: GridViewProps): boolean;
+    commitUpdate(oldProps: GridViewProps | null, newProps: GridViewProps): void;
+    commitMount(): void;
+    detachDeletedInstance(): void;
+    private applyOwnProps;
+}
+export {};

package/dist/nodes/grid-view.js

@@ -0,0 +1,73 @@
+import { GridItemRenderer } from "./internal/grid-item-renderer.js";
+import { filterProps, hasChanged } from "./internal/props.js";
+import { ListItemNode } from "./list-item.js";
+import { GridModel } from "./models/grid.js";
+import { WidgetNode } from "./widget.js";
+const OWN_PROPS = ["renderItem", "estimatedItemHeight"];
+export class GridViewNode extends WidgetNode {
+    itemRenderer;
+    grid;
+    constructor(typeName, props, container, rootContainer) {
+        super(typeName, props, container, rootContainer);
+        this.grid = new GridModel({ owner: this, signalStore: this.signalStore }, {
+            selectionMode: props.selectionMode,
+            selected: props.selected,
+            onSelectionChanged: props.onSelectionChanged,
+        });
+        this.itemRenderer = new GridItemRenderer(this.signalStore);
+        this.itemRenderer.setStore(this.grid.getStore());
+        this.grid.getStore().setOnItemUpdated((id) => this.itemRenderer.rebindItem(id));
+        this.container.setFactory(this.itemRenderer.getFactory());
+    }
+    isValidChild(child) {
+        if (!(child instanceof ListItemNode))
+            return false;
+        if (child.getChildNodes().length > 0) {
+            throw new Error("GtkGridView does not support nested ListItems. Use GtkListView for tree lists.");
+        }
+        return true;
+    }
+    appendChild(child) {
+        super.appendChild(child);
+        this.grid.appendChild(child);
+    }
+    insertBefore(child, before) {
+        super.insertBefore(child, before);
+        this.grid.insertBefore(child, before);
+    }
+    removeChild(child) {
+        this.grid.removeChild(child);
+        super.removeChild(child);
+    }
+    finalizeInitialChildren(props) {
+        super.finalizeInitialChildren(props);
+        return true;
+    }
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
+    }
+    commitMount() {
+        super.commitMount();
+        this.grid.flushBatch();
+        this.container.setModel(this.grid.getSelectionModel());
+    }
+    detachDeletedInstance() {
+        this.itemRenderer.dispose();
+        super.detachDeletedInstance();
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (hasChanged(oldProps, newProps, "renderItem")) {
+            this.itemRenderer.setRenderFn(newProps.renderItem ?? null);
+        }
+        if (hasChanged(oldProps, newProps, "estimatedItemHeight")) {
+            this.itemRenderer.setEstimatedItemHeight(newProps.estimatedItemHeight ?? null);
+        }
+        const previousModel = this.grid.getSelectionModel();
+        this.grid.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        const currentModel = this.grid.getSelectionModel();
+        if (previousModel !== currentModel) {
+            this.container.setModel(currentModel);
+        }
+    }
+}

package/dist/nodes/internal/base-item-renderer.d.ts

@@ -4,25 +4,23 @@ import type Reconciler from "react-reconciler";
 import type { SignalStore } from "./signal-store.js";
 export declare abstract class BaseItemRenderer<TStore = unknown> {
     protected factory: Gtk.SignalListItemFactory;
-    protected fiberRoots: Map<number, any>;
-    protected tornDown: Set<number>;
+    protected fiberRoots: Map<Gtk.ListItem, any>;
+    protected tornDown: Set<Gtk.ListItem>;
     protected estimatedItemHeight: number | null;
     private store;
     protected signalStore: SignalStore;
-    protected abstract getStoreTypeName(): string;
     constructor(signalStore: SignalStore);
     getFactory(): Gtk.SignalListItemFactory;
     setEstimatedItemHeight(height: number | null): void;
     setStore(store: TStore | null): void;
     protected getStore(): TStore;
     dispose(): void;
-    protected abstract renderItem(ptr: number): ReactNode;
-    protected abstract getItemFromListItem(listItem: Gtk.ListItem): unknown;
-    protected abstract onSetup(listItem: Gtk.ListItem, ptr: number): Gtk.Widget;
-    protected abstract onBind(listItem: Gtk.ListItem, ptr: number, fiberRoot: Reconciler.FiberRoot): void;
+    protected abstract renderItem(listItem: Gtk.ListItem): ReactNode;
+    protected abstract onSetup(listItem: Gtk.ListItem): Gtk.Widget;
+    protected abstract onBind(listItem: Gtk.ListItem, fiberRoot: Reconciler.FiberRoot): void;
     protected abstract onUnbind(listItem: Gtk.ListItem): void;
-    protected abstract onTeardown(listItem: Gtk.ListItem, ptr: number): void;
-    protected onSetupComplete(_ptr: number): void;
+    protected onSetupComplete(_listItem: Gtk.ListItem): void;
+    protected onTeardown(_listItem: Gtk.ListItem): void;
     protected createBox(): Gtk.Box;
     protected clearBoxSizeRequest(box: Gtk.Widget): void;
     private initializeFactory;