@gtkx/react 0.12.0 → 0.13.0

package/dist/nodes/index.d.ts

@@ -2,13 +2,21 @@ import "./action-row-child.js";
 import "./action-row.js";
 import "./application.js";
 import "./autowrapped.js";
+import "./calendar-mark.js";
+import "./calendar.js";
 import "./column-view-column.js";
 import "./column-view.js";
+import "./expander-row-child.js";
+import "./expander-row.js";
 import "./fixed-child.js";
 import "./grid-child.js";
+import "./level-bar-offset.js";
+import "./level-bar.js";
 import "./list-item.js";
 import "./list-view.js";
 import "./menu.js";
+import "./navigation-page.js";
+import "./navigation-view.js";
 import "./notebook-page-tab.js";
 import "./notebook-page.js";
 import "./notebook.js";
@@ -16,11 +24,15 @@ import "./overlay-child.js";
 import "./pack-child.js";
 import "./pack.js";
 import "./popover-menu.js";
+import "./scale-mark.js";
+import "./scale.js";
 import "./simple-list-item.js";
 import "./simple-list-view.js";
 import "./slot.js";
 import "./stack-page.js";
 import "./stack.js";
+import "./toggle.js";
+import "./toggle-group.js";
 import "./toolbar-child.js";
 import "./tree-list-item.js";
 import "./tree-list-view.js";

package/dist/nodes/index.js

@@ -2,13 +2,21 @@ import "./action-row-child.js";
 import "./action-row.js";
 import "./application.js";
 import "./autowrapped.js";
+import "./calendar-mark.js";
+import "./calendar.js";
 import "./column-view-column.js";
 import "./column-view.js";
+import "./expander-row-child.js";
+import "./expander-row.js";
 import "./fixed-child.js";
 import "./grid-child.js";
+import "./level-bar-offset.js";
+import "./level-bar.js";
 import "./list-item.js";
 import "./list-view.js";
 import "./menu.js";
+import "./navigation-page.js";
+import "./navigation-view.js";
 import "./notebook-page-tab.js";
 import "./notebook-page.js";
 import "./notebook.js";
@@ -16,11 +24,15 @@ import "./overlay-child.js";
 import "./pack-child.js";
 import "./pack.js";
 import "./popover-menu.js";
+import "./scale-mark.js";
+import "./scale.js";
 import "./simple-list-item.js";
 import "./simple-list-view.js";
 import "./slot.js";
 import "./stack-page.js";
 import "./stack.js";
+import "./toggle.js";
+import "./toggle-group.js";
 import "./toolbar-child.js";
 import "./tree-list-item.js";
 import "./tree-list-view.js";

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

@@ -6,11 +6,14 @@ export declare class ListItemRenderer {
     private factory;
     private store?;
     private fiberRoots;
+    private tornDown;
     private renderFn?;
+    private estimatedItemHeight?;
     constructor();
     getFactory(): Gtk.SignalListItemFactory;
     setRenderFn(renderFn?: RenderItemFn<unknown>): void;
     setStore(store?: ListStore | null): void;
+    setEstimatedItemHeight(height?: number): void;
     private getStore;
     private initialize;
 }

package/dist/nodes/internal/list-item-renderer.js

@@ -7,7 +7,9 @@ export class ListItemRenderer {
     factory;
     store;
     fiberRoots = new Map();
+    tornDown = new Set();
     renderFn = () => null;
+    estimatedItemHeight;
     constructor() {
         this.factory = new Gtk.SignalListItemFactory();
         this.initialize();
@@ -21,6 +23,9 @@ export class ListItemRenderer {
     setStore(store) {
         this.store = store;
     }
+    setEstimatedItemHeight(height) {
+        this.estimatedItemHeight = height;
+    }
     getStore() {
         if (!this.store) {
             throw new Error("Expected list store to be set on ListItemRenderer");
@@ -31,6 +36,9 @@ export class ListItemRenderer {
         signalStore.set(this, this.factory, "setup", (_self, listItem) => {
             const ptr = getNativeId(listItem.handle);
             const box = new Gtk.Box(Gtk.Orientation.VERTICAL, 0);
+            if (this.estimatedItemHeight !== undefined) {
+                box.setSizeRequest(-1, this.estimatedItemHeight);
+            }
             listItem.setChild(box);
             const fiberRoot = createFiberRoot(box);
             this.fiberRoots.set(ptr, fiberRoot);
@@ -47,21 +55,29 @@ export class ListItemRenderer {
                 return;
             const item = this.getStore().getItem(stringObject.getString());
             const element = this.renderFn?.(item);
-            reconciler.getInstance().updateContainer(element, fiberRoot, null, () => { });
-        });
-        signalStore.set(this, this.factory, "unbind", (_self, listItem) => {
-            const ptr = getNativeId(listItem.handle);
-            const fiberRoot = this.fiberRoots.get(ptr);
-            if (!fiberRoot)
-                return;
-            reconciler.getInstance().updateContainer(null, fiberRoot, null, () => { });
+            reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {
+                if (this.tornDown.has(ptr))
+                    return;
+                const currentFiberRoot = this.fiberRoots.get(ptr);
+                if (!currentFiberRoot)
+                    return;
+                const box = currentFiberRoot.containerInfo;
+                if (box instanceof Gtk.Box) {
+                    box.setSizeRequest(-1, -1);
+                }
+            });
         });
+        signalStore.set(this, this.factory, "unbind", () => { });
         signalStore.set(this, this.factory, "teardown", (_self, listItem) => {
             const ptr = getNativeId(listItem.handle);
             const fiberRoot = this.fiberRoots.get(ptr);
             if (fiberRoot) {
+                this.tornDown.add(ptr);
                 reconciler.getInstance().updateContainer(null, fiberRoot, null, () => { });
-                queueMicrotask(() => this.fiberRoots.delete(ptr));
+                queueMicrotask(() => {
+                    this.fiberRoots.delete(ptr);
+                    this.tornDown.delete(ptr);
+                });
             }
         });
     }

package/dist/nodes/internal/list-store.js

@@ -1,5 +1,5 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { scheduleAfterCommit } from "../../scheduler.js";
+import { CommitPriority, scheduleAfterCommit } from "../../scheduler.js";
 export class ListStore {
     items = new Map();
     model = new Gtk.StringList();
@@ -57,7 +57,7 @@ export class ListStore {
             return;
         }
         this.shouldSync = true;
-        scheduleAfterCommit(() => this.sync());
+        scheduleAfterCommit(() => this.sync(), CommitPriority.LOW);
     }
     sync() {
         this.shouldSync = false;

package/dist/nodes/internal/tree-list-item-renderer.d.ts

@@ -6,11 +6,19 @@ export declare class TreeListItemRenderer {
     private factory;
     private store?;
     private fiberRoots;
+    private expanders;
+    private setupComplete;
+    private pendingBinds;
+    private tornDown;
     private renderFn?;
+    private estimatedItemHeight?;
     constructor();
     getFactory(): Gtk.SignalListItemFactory;
     setRenderFn(renderFn?: TreeRenderItemFn<unknown>): void;
     setStore(store?: TreeStore | null): void;
+    setEstimatedItemHeight(height?: number): void;
     private getStore;
     private initialize;
+    private processPendingBind;
+    private renderBind;
 }

package/dist/nodes/internal/tree-list-item-renderer.js

@@ -7,7 +7,12 @@ export class TreeListItemRenderer {
     factory;
     store;
     fiberRoots = new Map();
+    expanders = new Map();
+    setupComplete = new Set();
+    pendingBinds = new Map();
+    tornDown = new Set();
     renderFn = () => null;
+    estimatedItemHeight;
     constructor() {
         this.factory = new Gtk.SignalListItemFactory();
         this.initialize();
@@ -21,6 +26,9 @@ export class TreeListItemRenderer {
     setStore(store) {
         this.store = store;
     }
+    setEstimatedItemHeight(height) {
+        this.estimatedItemHeight = height;
+    }
     getStore() {
         if (!this.store) {
             throw new Error("Expected tree store to be set on TreeListItemRenderer");
@@ -32,61 +40,97 @@ export class TreeListItemRenderer {
             const ptr = getNativeId(listItem.handle);
             const expander = new Gtk.TreeExpander();
             const box = new Gtk.Box(Gtk.Orientation.VERTICAL, 0);
+            if (this.estimatedItemHeight !== undefined) {
+                box.setSizeRequest(-1, this.estimatedItemHeight);
+            }
             expander.setChild(box);
             listItem.setChild(expander);
             const fiberRoot = createFiberRoot(box);
             this.fiberRoots.set(ptr, fiberRoot);
+            this.expanders.set(ptr, expander);
             const element = this.renderFn?.(null, null);
-            reconciler.getInstance().updateContainer(element, fiberRoot, null, () => { });
+            reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {
+                if (this.tornDown.has(ptr))
+                    return;
+                this.setupComplete.add(ptr);
+                this.processPendingBind(ptr);
+            });
         });
         signalStore.set(this, this.factory, "bind", (_self, listItem) => {
             const ptr = getNativeId(listItem.handle);
             const fiberRoot = this.fiberRoots.get(ptr);
-            if (!fiberRoot)
+            const expander = this.expanders.get(ptr);
+            if (!fiberRoot || !expander)
                 return;
             const treeListRow = listItem.getItem();
             if (!(treeListRow instanceof Gtk.TreeListRow))
                 return;
-            const expander = listItem.getChild();
-            if (!(expander instanceof Gtk.TreeExpander))
-                return;
             expander.setListRow(treeListRow);
             const stringObject = treeListRow.getItem();
             if (!(stringObject instanceof Gtk.StringObject))
                 return;
             const id = stringObject.getString();
-            const itemData = this.getStore().getItem(id);
-            if (itemData) {
-                if (itemData.indentForDepth !== undefined) {
-                    expander.setIndentForDepth(itemData.indentForDepth);
-                }
-                if (itemData.indentForIcon !== undefined) {
-                    expander.setIndentForIcon(itemData.indentForIcon);
-                }
-                if (itemData.hideExpander !== undefined) {
-                    expander.setHideExpander(itemData.hideExpander);
-                }
+            if (!this.setupComplete.has(ptr)) {
+                this.pendingBinds.set(ptr, { treeListRow, expander, id });
+                return;
             }
-            const element = this.renderFn?.(itemData?.value ?? null, treeListRow);
-            reconciler.getInstance().updateContainer(element, fiberRoot, null, () => { });
+            this.renderBind(ptr, expander, treeListRow, id);
         });
         signalStore.set(this, this.factory, "unbind", (_self, listItem) => {
-            const ptr = getNativeId(listItem.handle);
-            const fiberRoot = this.fiberRoots.get(ptr);
-            if (!fiberRoot)
-                return;
             const expander = listItem.getChild();
             if (expander instanceof Gtk.TreeExpander) {
                 expander.setListRow(null);
             }
-            reconciler.getInstance().updateContainer(null, fiberRoot, null, () => { });
         });
         signalStore.set(this, this.factory, "teardown", (_self, listItem) => {
             const ptr = getNativeId(listItem.handle);
             const fiberRoot = this.fiberRoots.get(ptr);
             if (fiberRoot) {
+                this.tornDown.add(ptr);
                 reconciler.getInstance().updateContainer(null, fiberRoot, null, () => { });
-                queueMicrotask(() => this.fiberRoots.delete(ptr));
+                queueMicrotask(() => {
+                    this.fiberRoots.delete(ptr);
+                    this.expanders.delete(ptr);
+                    this.setupComplete.delete(ptr);
+                    this.pendingBinds.delete(ptr);
+                    this.tornDown.delete(ptr);
+                });
+            }
+        });
+    }
+    processPendingBind(ptr) {
+        const pending = this.pendingBinds.get(ptr);
+        if (!pending)
+            return;
+        this.pendingBinds.delete(ptr);
+        this.renderBind(ptr, pending.expander, pending.treeListRow, pending.id);
+    }
+    renderBind(ptr, expander, treeListRow, id) {
+        const fiberRoot = this.fiberRoots.get(ptr);
+        if (!fiberRoot)
+            return;
+        const itemData = this.getStore().getItem(id);
+        if (itemData) {
+            if (itemData.indentForDepth !== undefined) {
+                expander.setIndentForDepth(itemData.indentForDepth);
+            }
+            if (itemData.indentForIcon !== undefined) {
+                expander.setIndentForIcon(itemData.indentForIcon);
+            }
+            if (itemData.hideExpander !== undefined) {
+                expander.setHideExpander(itemData.hideExpander);
+            }
+        }
+        const element = this.renderFn?.(itemData?.value ?? null, treeListRow);
+        reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {
+            if (this.tornDown.has(ptr))
+                return;
+            const currentExpander = this.expanders.get(ptr);
+            if (!currentExpander)
+                return;
+            const box = currentExpander.getChild();
+            if (box instanceof Gtk.Box) {
+                box.setSizeRequest(-1, -1);
             }
         });
     }

package/dist/nodes/internal/tree-store.js

@@ -1,6 +1,6 @@
 import { batch } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
-import { scheduleAfterCommit } from "../../scheduler.js";
+import { CommitPriority, scheduleAfterCommit } from "../../scheduler.js";
 export class TreeStore {
     items = new Map();
     rootIds = [];
@@ -126,7 +126,7 @@ export class TreeStore {
             return;
         }
         this.shouldSync = true;
-        scheduleAfterCommit(() => this.sync());
+        scheduleAfterCommit(() => this.sync(), CommitPriority.LOW);
     }
     sync() {
         this.shouldSync = false;
@@ -135,10 +135,9 @@ export class TreeStore {
             this.rootModel.splice(0, oldRootLength, this.newRootIds.length > 0 ? this.newRootIds : undefined);
             this.rootIds = [...this.newRootIds];
             for (const [parentId, newChildIds] of this.newChildren) {
-                const oldChildIds = this.children.get(parentId) ?? [];
                 const model = this.childModels.get(parentId);
                 if (model) {
-                    const oldLength = oldChildIds.length;
+                    const oldLength = model.getNItems();
                     model.splice(0, oldLength, newChildIds.length > 0 ? newChildIds : undefined);
                 }
             }

package/dist/nodes/level-bar-offset.d.ts

@@ -0,0 +1,13 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { LevelBarOffsetProps } from "../jsx.js";
+import { VirtualNode } from "./virtual.js";
+export declare class LevelBarOffsetNode extends VirtualNode<LevelBarOffsetProps> {
+    static priority: number;
+    private levelBar?;
+    private onRebuild?;
+    static matches(type: string): boolean;
+    setLevelBar(levelBar: Gtk.LevelBar, onRebuild: () => void): void;
+    addOffset(): string | undefined;
+    updateProps(oldProps: LevelBarOffsetProps | null, newProps: LevelBarOffsetProps): void;
+    unmount(): void;
+}

package/dist/nodes/level-bar-offset.js

@@ -0,0 +1,35 @@
+import { registerNodeClass } from "../registry.js";
+import { VirtualNode } from "./virtual.js";
+export class LevelBarOffsetNode extends VirtualNode {
+    static priority = 1;
+    levelBar;
+    onRebuild;
+    static matches(type) {
+        return type === "LevelBarOffset";
+    }
+    setLevelBar(levelBar, onRebuild) {
+        this.levelBar = levelBar;
+        this.onRebuild = onRebuild;
+    }
+    addOffset() {
+        if (!this.levelBar)
+            return undefined;
+        this.levelBar.addOffsetValue(this.props.id, this.props.value);
+        return this.props.id;
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        if (oldProps && this.levelBar) {
+            const changed = oldProps.id !== newProps.id || oldProps.value !== newProps.value;
+            if (changed) {
+                this.onRebuild?.();
+            }
+        }
+    }
+    unmount() {
+        this.levelBar = undefined;
+        this.onRebuild = undefined;
+        super.unmount();
+    }
+}
+registerNodeClass(LevelBarOffsetNode);

package/dist/nodes/level-bar.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/nodes/level-bar.js

@@ -0,0 +1,82 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
+import { isContainerType } from "./internal/utils.js";
+import { LevelBarOffsetNode } from "./level-bar-offset.js";
+import { SlotNode } from "./slot.js";
+import { WidgetNode } from "./widget.js";
+class LevelBarNode extends WidgetNode {
+    static priority = 1;
+    offsetChildren = [];
+    appliedOffsetIds = new Set();
+    static matches(_type, containerOrClass) {
+        return isContainerType(Gtk.LevelBar, containerOrClass);
+    }
+    appendChild(child) {
+        if (child instanceof LevelBarOffsetNode) {
+            child.setLevelBar(this.container, () => this.scheduleRebuildAllOffsets());
+            this.offsetChildren.push(child);
+            scheduleAfterCommit(() => {
+                const id = child.addOffset();
+                if (id) {
+                    this.appliedOffsetIds.add(id);
+                }
+            });
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.appendChild(child);
+            return;
+        }
+        throw new Error(`Cannot append '${child.typeName}' to 'LevelBar': expected x.LevelBarOffset or Widget`);
+    }
+    insertBefore(child, before) {
+        if (child instanceof LevelBarOffsetNode) {
+            child.setLevelBar(this.container, () => this.scheduleRebuildAllOffsets());
+            const beforeIndex = this.offsetChildren.indexOf(before);
+            if (beforeIndex >= 0) {
+                this.offsetChildren.splice(beforeIndex, 0, child);
+            }
+            else {
+                this.offsetChildren.push(child);
+            }
+            this.scheduleRebuildAllOffsets();
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.insertBefore(child, before);
+            return;
+        }
+        throw new Error(`Cannot insert '${child.typeName}' into 'LevelBar': expected x.LevelBarOffset or Widget`);
+    }
+    removeChild(child) {
+        if (child instanceof LevelBarOffsetNode) {
+            const index = this.offsetChildren.indexOf(child);
+            if (index >= 0) {
+                this.offsetChildren.splice(index, 1);
+            }
+            this.scheduleRebuildAllOffsets(CommitPriority.HIGH);
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.removeChild(child);
+            return;
+        }
+        throw new Error(`Cannot remove '${child.typeName}' from 'LevelBar': expected x.LevelBarOffset or Widget`);
+    }
+    scheduleRebuildAllOffsets(priority = CommitPriority.NORMAL) {
+        scheduleAfterCommit(() => {
+            for (const id of this.appliedOffsetIds) {
+                this.container.removeOffsetValue(id);
+            }
+            this.appliedOffsetIds.clear();
+            for (const offset of this.offsetChildren) {
+                const id = offset.addOffset();
+                if (id) {
+                    this.appliedOffsetIds.add(id);
+                }
+            }
+        }, priority);
+    }
+}
+registerNodeClass(LevelBarNode);

package/dist/nodes/list-view.js

@@ -5,7 +5,7 @@ import { filterProps, matchesAnyClass } from "./internal/utils.js";
 import { ListItemNode } from "./list-item.js";
 import { List } from "./models/list.js";
 import { WidgetNode } from "./widget.js";
-const PROP_NAMES = ["renderItem"];
+const PROP_NAMES = ["renderItem", "estimatedItemHeight"];
 class ListViewNode extends WidgetNode {
     static priority = 1;
     itemRenderer;
@@ -15,7 +15,11 @@ class ListViewNode extends WidgetNode {
     }
     constructor(typeName, props, container, rootContainer) {
         super(typeName, props, container, rootContainer);
-        this.list = new List();
+        this.list = new List({
+            selectionMode: props.selectionMode,
+            selected: props.selected,
+            onSelectionChanged: props.onSelectionChanged,
+        });
         this.itemRenderer = new ListItemRenderer();
         this.itemRenderer.setStore(this.list.getStore());
         this.container.setFactory(this.itemRenderer.getFactory());
@@ -26,19 +30,19 @@ class ListViewNode extends WidgetNode {
     }
     appendChild(child) {
         if (!(child instanceof ListItemNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to 'ListView': expected ListItem`);
+            throw new Error(`Cannot append '${child.typeName}' to 'ListView': expected x.ListItem`);
         }
         this.list.appendChild(child);
     }
     insertBefore(child, before) {
         if (!(child instanceof ListItemNode) || !(before instanceof ListItemNode)) {
-            throw new Error(`Cannot insert '${child.typeName}' to 'ListView': expected ListItem`);
+            throw new Error(`Cannot insert '${child.typeName}' into 'ListView': expected x.ListItem`);
         }
         this.list.insertBefore(child, before);
     }
     removeChild(child) {
         if (!(child instanceof ListItemNode)) {
-            throw new Error(`Cannot remove '${child.typeName}' from 'ListView': expected ListItem`);
+            throw new Error(`Cannot remove '${child.typeName}' from 'ListView': expected x.ListItem`);
         }
         this.list.removeChild(child);
     }
@@ -46,8 +50,11 @@ class ListViewNode extends WidgetNode {
         if (!oldProps || oldProps.renderItem !== newProps.renderItem) {
             this.itemRenderer.setRenderFn(newProps.renderItem);
         }
-        this.list.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
-        super.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
+        if (!oldProps || oldProps.estimatedItemHeight !== newProps.estimatedItemHeight) {
+            this.itemRenderer.setEstimatedItemHeight(newProps.estimatedItemHeight);
+        }
+        this.list.updateProps(oldProps ? filterProps(oldProps, PROP_NAMES) : null, filterProps(newProps, PROP_NAMES));
+        super.updateProps(oldProps ? filterProps(oldProps, PROP_NAMES) : null, filterProps(newProps, PROP_NAMES));
     }
 }
 registerNodeClass(ListViewNode);

package/dist/nodes/menu.js

@@ -4,16 +4,16 @@ import { Menu } from "./models/menu.js";
 export class MenuNode extends Menu {
     static priority = 1;
     static matches(type) {
-        return type === "Menu.Item" || type === "Menu.Section" || type === "Menu.Submenu";
+        return type === "MenuItem" || type === "MenuSection" || type === "MenuSubmenu";
     }
     static getType(typeName) {
-        if (typeName === "Menu.Item") {
+        if (typeName === "MenuItem") {
             return "item";
         }
-        else if (typeName === "Menu.Section") {
+        else if (typeName === "MenuSection") {
             return "section";
         }
-        else if (typeName === "Menu.Submenu") {
+        else if (typeName === "MenuSubmenu") {
             return "submenu";
         }
         throw new Error(`Unable to find menu type '${typeName}'`);

package/dist/nodes/models/list.d.ts

@@ -11,7 +11,8 @@ export declare class List extends VirtualNode<ListProps> {
     private store;
     private selectionModel;
     private handleSelectionChange?;
-    constructor(selectionMode?: Gtk.SelectionMode);
+    constructor(props?: ListProps);
+    private initSelectionHandler;
     getStore(): ListStore;
     getSelectionModel(): Gtk.SingleSelection | Gtk.MultiSelection;
     appendChild(child: Node): void;

package/dist/nodes/models/list.js

@@ -7,11 +7,22 @@ export class List extends VirtualNode {
     store;
     selectionModel;
     handleSelectionChange;
-    constructor(selectionMode) {
+    constructor(props = {}) {
         super("", {}, undefined);
         this.store = new ListStore();
-        this.selectionModel = this.createSelectionModel(selectionMode);
+        this.selectionModel = this.createSelectionModel(props.selectionMode);
         this.selectionModel.setModel(this.store.getModel());
+        this.initSelectionHandler(props.onSelectionChanged);
+    }
+    initSelectionHandler(onSelectionChanged) {
+        if (!onSelectionChanged) {
+            signalStore.set(this, this.selectionModel, "selection-changed", null);
+            return;
+        }
+        this.handleSelectionChange = () => {
+            onSelectionChanged(this.getSelection());
+        };
+        signalStore.set(this, this.selectionModel, "selection-changed", this.handleSelectionChange);
     }
     getStore() {
         return this.store;
@@ -42,20 +53,18 @@ export class List extends VirtualNode {
     }
     updateProps(oldProps, newProps) {
         super.updateProps(oldProps, newProps);
-        if (!oldProps || oldProps.selectionMode !== newProps.selectionMode) {
+        if (oldProps && oldProps.selectionMode !== newProps.selectionMode) {
             signalStore.set(this, this.selectionModel, "selection-changed", null);
             this.selectionModel = this.createSelectionModel(newProps.selectionMode);
+            this.selectionModel.setModel(this.store.getModel());
+            this.initSelectionHandler(newProps.onSelectionChanged);
+            this.setSelection(newProps.selected);
+            return;
         }
-        if (!oldProps ||
-            oldProps.onSelectionChanged !== newProps.onSelectionChanged ||
-            oldProps.selectionMode !== newProps.selectionMode) {
-            const onSelectionChanged = newProps.onSelectionChanged;
-            this.handleSelectionChange = () => {
-                onSelectionChanged?.(this.getSelection());
-            };
-            signalStore.set(this, this.selectionModel, "selection-changed", newProps.onSelectionChanged ? this.handleSelectionChange : null);
+        if (!oldProps || oldProps.onSelectionChanged !== newProps.onSelectionChanged) {
+            this.initSelectionHandler(newProps.onSelectionChanged);
         }
-        if (!oldProps || oldProps.selected !== newProps.selected || oldProps.selectionMode !== newProps.selectionMode) {
+        if (!oldProps || oldProps.selected !== newProps.selected) {
             this.setSelection(newProps.selected);
         }
     }

package/dist/nodes/models/menu.d.ts

@@ -29,6 +29,7 @@ export declare class Menu extends VirtualNode<MenuProps> {
     createAction(): void;
     private removeAction;
     private getPosition;
+    private findPositionIn;
     private setParent;
     getMenu(): Gio.Menu;
     private getAction;