@gtkx/react 0.17.2 → 0.18.0

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

@@ -1,4 +1,3 @@
-import { getNativeId } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
 import { createFiberRoot } from "../../fiber-root.js";
 import { reconciler } from "../../reconciler.js";
@@ -25,7 +24,7 @@ export class BaseItemRenderer {
     }
     getStore() {
         if (!this.store) {
-            throw new Error(`Expected ${this.getStoreTypeName()} to be set on ${this.constructor.name}`);
+            throw new Error(`Expected store to be set on ${this.constructor.name}`);
         }
         return this.store;
     }
@@ -34,7 +33,8 @@ export class BaseItemRenderer {
         this.fiberRoots.clear();
         this.tornDown.clear();
     }
-    onSetupComplete(_ptr) { }
+    onSetupComplete(_listItem) { }
+    onTeardown(_listItem) { }
     createBox() {
         const box = new Gtk.Box(Gtk.Orientation.HORIZONTAL);
         box.setValign(Gtk.Align.CENTER);
@@ -50,37 +50,34 @@ export class BaseItemRenderer {
     }
     initializeFactory() {
         this.signalStore.set(this, this.factory, "setup", (listItem) => {
-            const ptr = getNativeId(listItem.handle);
-            const container = this.onSetup(listItem, ptr);
+            const container = this.onSetup(listItem);
             const fiberRoot = createFiberRoot(container);
-            this.fiberRoots.set(ptr, fiberRoot);
-            const element = this.renderItem(ptr);
+            this.fiberRoots.set(listItem, fiberRoot);
+            const element = this.renderItem(listItem);
             reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {
-                if (this.tornDown.has(ptr))
+                if (this.tornDown.has(listItem))
                     return;
-                this.onSetupComplete(ptr);
+                this.onSetupComplete(listItem);
             });
         });
         this.signalStore.set(this, this.factory, "bind", (listItem) => {
-            const ptr = getNativeId(listItem.handle);
-            const fiberRoot = this.fiberRoots.get(ptr);
+            const fiberRoot = this.fiberRoots.get(listItem);
             if (!fiberRoot)
                 return;
-            this.onBind(listItem, ptr, fiberRoot);
+            this.onBind(listItem, fiberRoot);
         });
         this.signalStore.set(this, this.factory, "unbind", (listItem) => {
             this.onUnbind(listItem);
         });
         this.signalStore.set(this, this.factory, "teardown", (listItem) => {
-            const ptr = getNativeId(listItem.handle);
-            const fiberRoot = this.fiberRoots.get(ptr);
+            const fiberRoot = this.fiberRoots.get(listItem);
             if (fiberRoot) {
-                this.tornDown.add(ptr);
-                this.onTeardown(listItem, ptr);
+                this.tornDown.add(listItem);
+                this.onTeardown(listItem);
                 reconciler.getInstance().updateContainer(null, fiberRoot, null, () => { });
                 queueMicrotask(() => {
-                    this.fiberRoots.delete(ptr);
-                    this.tornDown.delete(ptr);
+                    this.fiberRoots.delete(listItem);
+                    this.tornDown.delete(listItem);
                 });
             }
         });

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

@@ -0,0 +1,17 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { ReactNode } from "react";
+import type Reconciler from "react-reconciler";
+import { BaseItemRenderer } from "./base-item-renderer.js";
+import type { ListStore } from "./list-store.js";
+export type GridRenderItemFn<T> = (item: T | null) => ReactNode;
+export declare class GridItemRenderer extends BaseItemRenderer<ListStore> {
+    private renderFn;
+    private boundItems;
+    setRenderFn(renderFn: GridRenderItemFn<unknown> | null): void;
+    rebindItem(id: string): void;
+    protected renderItem(_listItem: Gtk.ListItem): ReactNode;
+    private getItemFromListItem;
+    protected onSetup(listItem: Gtk.ListItem): Gtk.Widget;
+    protected onBind(listItem: Gtk.ListItem, fiberRoot: Reconciler.FiberRoot): void;
+    protected onUnbind(listItem: Gtk.ListItem): void;
+}

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

@@ -0,0 +1,59 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { reconciler } from "../../reconciler.js";
+import { BaseItemRenderer } from "./base-item-renderer.js";
+export class GridItemRenderer extends BaseItemRenderer {
+    renderFn = () => null;
+    boundItems = new Map();
+    setRenderFn(renderFn) {
+        this.renderFn = renderFn;
+    }
+    rebindItem(id) {
+        const listItem = this.boundItems.get(id);
+        if (!listItem)
+            return;
+        const fiberRoot = this.fiberRoots.get(listItem);
+        if (!fiberRoot)
+            return;
+        const item = this.getStore().getItem(id);
+        const element = this.renderFn?.(item);
+        reconciler.getInstance().updateContainer(element, fiberRoot, null, () => { });
+    }
+    renderItem(_listItem) {
+        return this.renderFn?.(null);
+    }
+    getItemFromListItem(listItem) {
+        const stringObject = listItem.getItem();
+        if (!(stringObject instanceof Gtk.StringObject))
+            return null;
+        return stringObject.getString();
+    }
+    onSetup(listItem) {
+        const box = this.createBox();
+        listItem.setChild(box);
+        return box;
+    }
+    onBind(listItem, fiberRoot) {
+        const id = this.getItemFromListItem(listItem);
+        if (id !== null) {
+            this.boundItems.set(id, listItem);
+        }
+        const item = id !== null ? this.getStore().getItem(id) : null;
+        const element = this.renderFn?.(item);
+        reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {
+            if (this.tornDown.has(listItem))
+                return;
+            if (this.estimatedItemHeight !== null)
+                return;
+            const currentFiberRoot = this.fiberRoots.get(listItem);
+            if (!currentFiberRoot)
+                return;
+            this.clearBoxSizeRequest(currentFiberRoot.containerInfo);
+        });
+    }
+    onUnbind(listItem) {
+        const id = this.getItemFromListItem(listItem);
+        if (id !== null) {
+            this.boundItems.delete(id);
+        }
+    }
+}

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

@@ -2,18 +2,23 @@ import * as Gtk from "@gtkx/ffi/gtk";
 import type { ReactNode } from "react";
 import type Reconciler from "react-reconciler";
 import { BaseItemRenderer } from "./base-item-renderer.js";
-import type { ListStore } from "./list-store.js";
-export type RenderItemFn<T> = (item: T | null) => ReactNode;
-export declare class ListItemRenderer extends BaseItemRenderer<ListStore> {
+import type { TreeStore } from "./tree-store.js";
+export type RenderItemFn<T> = (item: T | null, row: Gtk.TreeListRow | null) => ReactNode;
+export declare class ListItemRenderer extends BaseItemRenderer<TreeStore> {
+    private expanders;
+    private setupComplete;
+    private pendingBinds;
     private renderFn;
     private boundItems;
     setRenderFn(renderFn: RenderItemFn<unknown> | null): void;
     rebindItem(id: string): void;
-    protected getStoreTypeName(): string;
-    protected renderItem(_ptr: number): ReactNode;
-    protected getItemFromListItem(listItem: Gtk.ListItem): string | null;
-    protected onSetup(listItem: Gtk.ListItem, _ptr: number): Gtk.Widget;
-    protected onBind(listItem: Gtk.ListItem, ptr: number, fiberRoot: Reconciler.FiberRoot): void;
+    dispose(): void;
+    protected renderItem(_listItem: Gtk.ListItem): ReactNode;
+    protected onSetup(listItem: Gtk.ListItem): Gtk.Widget;
+    protected onSetupComplete(listItem: Gtk.ListItem): void;
+    protected onBind(listItem: Gtk.ListItem, fiberRoot: Reconciler.FiberRoot): void;
     protected onUnbind(listItem: Gtk.ListItem): void;
-    protected onTeardown(_listItem: Gtk.ListItem, _ptr: number): void;
+    protected onTeardown(listItem: Gtk.ListItem): void;
+    private processPendingBind;
+    private renderBind;
 }

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

@@ -2,62 +2,123 @@ import * as Gtk from "@gtkx/ffi/gtk";
 import { reconciler } from "../../reconciler.js";
 import { BaseItemRenderer } from "./base-item-renderer.js";
 export class ListItemRenderer extends BaseItemRenderer {
+    expanders = new Map();
+    setupComplete = new Set();
+    pendingBinds = new Map();
     renderFn = () => null;
     boundItems = new Map();
     setRenderFn(renderFn) {
         this.renderFn = renderFn;
     }
     rebindItem(id) {
-        const ptr = this.boundItems.get(id);
-        if (ptr === undefined)
+        const binding = this.boundItems.get(id);
+        if (!binding)
             return;
-        const fiberRoot = this.fiberRoots.get(ptr);
+        const fiberRoot = this.fiberRoots.get(binding.listItem);
         if (!fiberRoot)
             return;
-        const item = this.getStore().getItem(id);
-        const element = this.renderFn?.(item);
-        reconciler.getInstance().updateContainer(element, fiberRoot, null, () => { });
-    }
-    getStoreTypeName() {
-        return "list store";
+        const expander = this.expanders.get(binding.listItem);
+        if (!expander)
+            return;
+        this.renderBind(binding.listItem, expander, binding.treeListRow, id, fiberRoot);
     }
-    renderItem(_ptr) {
-        return this.renderFn?.(null);
+    dispose() {
+        super.dispose();
+        this.expanders.clear();
+        this.setupComplete.clear();
+        this.pendingBinds.clear();
+        this.boundItems.clear();
     }
-    getItemFromListItem(listItem) {
-        const stringObject = listItem.getItem();
-        if (!(stringObject instanceof Gtk.StringObject))
-            return null;
-        return stringObject.getString();
+    renderItem(_listItem) {
+        return this.renderFn?.(null, null);
     }
-    onSetup(listItem, _ptr) {
+    onSetup(listItem) {
+        const expander = new Gtk.TreeExpander();
         const box = this.createBox();
-        listItem.setChild(box);
+        expander.setChild(box);
+        listItem.setChild(expander);
+        this.expanders.set(listItem, expander);
         return box;
     }
-    onBind(listItem, ptr, fiberRoot) {
-        const id = this.getItemFromListItem(listItem);
-        if (id !== null) {
-            this.boundItems.set(id, ptr);
+    onSetupComplete(listItem) {
+        this.setupComplete.add(listItem);
+        this.processPendingBind(listItem);
+    }
+    onBind(listItem, fiberRoot) {
+        const expander = this.expanders.get(listItem);
+        if (!expander)
+            return;
+        const treeListRow = listItem.getItem();
+        if (!(treeListRow instanceof Gtk.TreeListRow))
+            return;
+        expander.setListRow(treeListRow);
+        const stringObject = treeListRow.getItem();
+        if (!(stringObject instanceof Gtk.StringObject))
+            return;
+        const id = stringObject.getString();
+        this.boundItems.set(id, { listItem, treeListRow });
+        if (!this.setupComplete.has(listItem)) {
+            this.pendingBinds.set(listItem, { treeListRow, expander, id });
+            return;
+        }
+        this.renderBind(listItem, expander, treeListRow, id, fiberRoot);
+    }
+    onUnbind(listItem) {
+        const expander = listItem.getChild();
+        if (expander instanceof Gtk.TreeExpander) {
+            expander.setListRow(null);
+            const treeListRow = listItem.getItem();
+            if (treeListRow instanceof Gtk.TreeListRow) {
+                const stringObject = treeListRow.getItem();
+                if (stringObject instanceof Gtk.StringObject) {
+                    this.boundItems.delete(stringObject.getString());
+                }
+            }
+        }
+    }
+    onTeardown(listItem) {
+        this.expanders.delete(listItem);
+        this.setupComplete.delete(listItem);
+        this.pendingBinds.delete(listItem);
+    }
+    processPendingBind(listItem) {
+        const pending = this.pendingBinds.get(listItem);
+        if (!pending)
+            return;
+        this.pendingBinds.delete(listItem);
+        const fiberRoot = this.fiberRoots.get(listItem);
+        if (fiberRoot) {
+            this.renderBind(listItem, pending.expander, pending.treeListRow, pending.id, fiberRoot);
         }
-        const item = id !== null ? this.getStore().getItem(id) : null;
-        const element = this.renderFn?.(item);
+    }
+    renderBind(listItem, expander, treeListRow, id, fiberRoot) {
+        const itemData = this.getStore().getItem(id);
+        if (itemData) {
+            expander.setIndentForDepth(itemData.indentForDepth ?? true);
+            expander.setHideExpander(itemData.hideExpander ?? false);
+            if (itemData.indentForIcon !== undefined) {
+                expander.setIndentForIcon(itemData.indentForIcon);
+            }
+            else {
+                expander.setIndentForIcon(treeListRow.isExpandable());
+            }
+        }
+        else {
+            expander.setIndentForIcon(treeListRow.isExpandable());
+        }
+        const element = this.renderFn?.(itemData?.value ?? null, treeListRow);
         reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {
-            if (this.tornDown.has(ptr))
+            if (this.tornDown.has(listItem))
                 return;
             if (this.estimatedItemHeight !== null)
                 return;
-            const currentFiberRoot = this.fiberRoots.get(ptr);
-            if (!currentFiberRoot)
+            const currentExpander = this.expanders.get(listItem);
+            if (!currentExpander)
                 return;
-            this.clearBoxSizeRequest(currentFiberRoot.containerInfo);
+            const box = currentExpander.getChild();
+            if (box) {
+                this.clearBoxSizeRequest(box);
+            }
         });
     }
-    onUnbind(listItem) {
-        const id = this.getItemFromListItem(listItem);
-        if (id !== null) {
-            this.boundItems.delete(id);
-        }
-    }
-    onTeardown(_listItem, _ptr) { }
 }

package/dist/nodes/internal/list-store.d.ts

@@ -3,13 +3,18 @@ export type ItemUpdatedCallback = (id: string) => void;
 export declare class ListStore {
     private model;
     private ids;
+    private idToIndex;
     private items;
     private onItemUpdated;
+    private pendingBatch;
     setOnItemUpdated(callback: ItemUpdatedCallback | null): void;
+    beginBatch(): void;
+    flushBatch(): void;
     addItem(id: string, item: unknown): void;
     removeItem(id: string): void;
     insertItemBefore(id: string, beforeId: string, item: unknown): void;
     updateItem(id: string, item: unknown): void;
     getItem(id: string): unknown;
     getModel(): Gtk.StringList;
+    private rebuildIndices;
 }

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

@@ -2,43 +2,68 @@ import * as Gtk from "@gtkx/ffi/gtk";
 export class ListStore {
     model = new Gtk.StringList();
     ids = [];
+    idToIndex = new Map();
     items = new Map();
     onItemUpdated = null;
+    pendingBatch = null;
     setOnItemUpdated(callback) {
         this.onItemUpdated = callback;
     }
+    beginBatch() {
+        this.pendingBatch = [];
+    }
+    flushBatch() {
+        const batch = this.pendingBatch;
+        this.pendingBatch = null;
+        if (batch && batch.length > 0) {
+            this.model.splice(0, 0, batch);
+        }
+    }
     addItem(id, item) {
         this.items.set(id, item);
-        const existingIndex = this.ids.indexOf(id);
-        if (existingIndex >= 0) {
+        const existingIndex = this.idToIndex.get(id);
+        if (existingIndex !== undefined) {
             this.model.remove(existingIndex);
             this.ids.splice(existingIndex, 1);
+            this.rebuildIndices(existingIndex);
         }
+        this.idToIndex.set(id, this.ids.length);
         this.ids.push(id);
-        this.model.append(id);
+        if (this.pendingBatch) {
+            this.pendingBatch.push(id);
+        }
+        else {
+            this.model.append(id);
+        }
     }
     removeItem(id) {
-        const index = this.ids.indexOf(id);
-        if (index < 0)
+        const index = this.idToIndex.get(id);
+        if (index === undefined)
             return;
         this.model.remove(index);
         this.ids.splice(index, 1);
+        this.idToIndex.delete(id);
+        this.rebuildIndices(index);
         this.items.delete(id);
     }
     insertItemBefore(id, beforeId, item) {
         this.items.set(id, item);
-        const existingIndex = this.ids.indexOf(id);
-        if (existingIndex >= 0) {
+        const existingIndex = this.idToIndex.get(id);
+        if (existingIndex !== undefined) {
             this.model.remove(existingIndex);
             this.ids.splice(existingIndex, 1);
+            this.idToIndex.delete(id);
+            this.rebuildIndices(existingIndex);
         }
-        const beforeIndex = this.ids.indexOf(beforeId);
-        if (beforeIndex < 0) {
+        const beforeIndex = this.idToIndex.get(beforeId);
+        if (beforeIndex === undefined) {
+            this.idToIndex.set(id, this.ids.length);
             this.ids.push(id);
             this.model.append(id);
         }
         else {
             this.ids.splice(beforeIndex, 0, id);
+            this.rebuildIndices(beforeIndex);
             this.model.splice(beforeIndex, 0, [id]);
         }
     }
@@ -57,4 +82,9 @@ export class ListStore {
     getModel() {
         return this.model;
     }
+    rebuildIndices(fromIndex) {
+        for (let i = fromIndex; i < this.ids.length; i++) {
+            this.idToIndex.set(this.ids[i], i);
+        }
+    }
 }

package/dist/nodes/internal/predicates.d.ts

@@ -4,17 +4,8 @@
  * These predicates check for specific APIs that widgets may or may not expose.
  * GTK widgets don't have a consistent interface - different widgets support
  * different child management APIs - so runtime checking is necessary.
- *
- * Predicate evaluation order matters in WidgetNode.appendChild/removeChild:
- * 1. isReorderable (Box, etc.) - reorderChildAfter/insertChildAfter
- * 2. isInsertable (ListBox, etc.) - insert
- * 3. isAppendable (most containers) - append
- * 4. isAddable (some legacy widgets) - add
- * 5. isContentWidget (ActionBar, etc.) - setContent
- * 6. isSingleChild (Bin subclasses) - setChild
  */
 import * as Gtk from "@gtkx/ffi/gtk";
-import type { Node } from "../../node.js";
 type AppendableWidget = Gtk.Widget & {
     append: (child: Gtk.Widget) => void;
 };
@@ -43,9 +34,9 @@ type EditableWidget = Gtk.Widget & {
     setPosition: (position: number) => void;
     getText: () => string;
 };
-export type AdjustableWidget = Gtk.Widget & {
-    setAdjustment: (adjustment: Gtk.Adjustment) => void;
-    getValue: () => number;
+type BufferedWidget = Gtk.Widget & {
+    getBuffer: () => Gtk.TextBuffer;
+    setBuffer: (buffer?: Gtk.TextBuffer | null) => void;
 };
 export declare const isAppendable: (obj: unknown) => obj is AppendableWidget;
 export declare const isAddable: (obj: unknown) => obj is AddableWidget;
@@ -55,11 +46,5 @@ export declare const isRemovable: (obj: unknown) => obj is RemovableWidget;
 export declare const isReorderable: (obj: unknown) => obj is ReorderableWidget;
 export declare const isInsertable: (obj: unknown) => obj is InsertableWidget;
 export declare const isEditable: (obj: unknown) => obj is EditableWidget;
-export declare const isBufferedType: (type: string) => boolean;
-export type Attachable = {
-    canBeChildOf(parent: Node): boolean;
-    attachTo(parent: Node): void;
-    detachFrom(parent: Node): void;
-};
-export declare function isAttachable(node: Node): node is Node & Attachable;
+export declare const isBuffered: (obj: unknown) => obj is BufferedWidget;
 export {};

package/dist/nodes/internal/predicates.js

@@ -4,17 +4,8 @@
  * These predicates check for specific APIs that widgets may or may not expose.
  * GTK widgets don't have a consistent interface - different widgets support
  * different child management APIs - so runtime checking is necessary.
- *
- * Predicate evaluation order matters in WidgetNode.appendChild/removeChild:
- * 1. isReorderable (Box, etc.) - reorderChildAfter/insertChildAfter
- * 2. isInsertable (ListBox, etc.) - insert
- * 3. isAppendable (most containers) - append
- * 4. isAddable (some legacy widgets) - add
- * 5. isContentWidget (ActionBar, etc.) - setContent
- * 6. isSingleChild (Bin subclasses) - setChild
  */
 import * as Gtk from "@gtkx/ffi/gtk";
-import { resolveContainerClass } from "../../factory.js";
 export const isAppendable = (obj) => obj instanceof Gtk.Widget && "append" in obj && typeof obj.append === "function";
 export const isAddable = (obj) => obj instanceof Gtk.Widget && "add" in obj && typeof obj.add === "function";
 export const isContentWidget = (obj) => obj instanceof Gtk.Widget && "setContent" in obj && typeof obj.setContent === "function";
@@ -37,18 +28,8 @@ export const isEditable = (obj) => obj instanceof Gtk.Widget &&
     typeof obj.setPosition === "function" &&
     "getText" in obj &&
     typeof obj.getText === "function";
-const isBuffered = (obj) => obj instanceof Gtk.Widget &&
+export const isBuffered = (obj) => obj instanceof Gtk.Widget &&
     "getBuffer" in obj &&
     typeof obj.getBuffer === "function" &&
     "setBuffer" in obj &&
     typeof obj.setBuffer === "function";
-export const isBufferedType = (type) => {
-    const containerClass = resolveContainerClass(type);
-    return containerClass !== null && isBuffered(containerClass.prototype);
-};
-export function isAttachable(node) {
-    const candidate = node;
-    return (typeof candidate.canBeChildOf === "function" &&
-        typeof candidate.attachTo === "function" &&
-        typeof candidate.detachFrom === "function");
-}

package/dist/nodes/internal/props.d.ts

@@ -0,0 +1,5 @@
+import type { Props } from "../../types.js";
+export declare const filterProps: <T extends Props>(props: T, excludeKeys: readonly string[]) => T;
+export declare const hasChanged: <T>(oldProps: T | null, newProps: T, key: keyof T) => boolean;
+export declare const shallowArrayEqual: <T extends Record<string, unknown>>(a: T[], b: T[]) => boolean;
+export declare const primitiveArrayEqual: <T extends string | number | boolean>(a: T[] | null | undefined, b: T[] | null | undefined) => boolean;

package/dist/nodes/internal/props.js

@@ -0,0 +1,42 @@
+export const filterProps = (props, excludeKeys) => {
+    const result = {};
+    for (const key of Object.keys(props)) {
+        if (!excludeKeys.includes(key)) {
+            result[key] = props[key];
+        }
+    }
+    return result;
+};
+export const hasChanged = (oldProps, newProps, key) => !oldProps || oldProps[key] !== newProps[key];
+export const shallowArrayEqual = (a, b) => {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        const itemA = a[i];
+        const itemB = b[i];
+        if (!itemA || !itemB)
+            return false;
+        const keysA = Object.keys(itemA);
+        const keysB = Object.keys(itemB);
+        if (keysA.length !== keysB.length)
+            return false;
+        for (const key of keysA) {
+            if (itemA[key] !== itemB[key])
+                return false;
+        }
+    }
+    return true;
+};
+export const primitiveArrayEqual = (a, b) => {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+};

package/dist/nodes/internal/{selection-model.d.ts → selection-model-controller.d.ts}

@@ -1,21 +1,16 @@
 import type * as Gio from "@gtkx/ffi/gio";
 import * as Gtk from "@gtkx/ffi/gtk";
+import type { GtkListViewProps } from "../../jsx.js";
 import type { SignalStore } from "./signal-store.js";
 type SelectionModel = Gtk.NoSelection | Gtk.SingleSelection | Gtk.MultiSelection;
-export type SelectionModelConfig = {
+export type SelectionModelConfig = Pick<GtkListViewProps, "selectionMode" | "selected" | "onSelectionChanged"> & {
     owner: object;
     signalStore: SignalStore;
-    selectionMode?: Gtk.SelectionMode;
-    selected?: string[];
-    onSelectionChanged?: (ids: string[]) => void;
 };
-export declare class SelectionModelManager {
+export declare class SelectionModelController {
     private owner;
     private signalStore;
     private selectionModel;
-    private handleSelectionChange;
-    private pendingSelection;
-    private selectionAction;
     private getSelection;
     private resolveSelectionIndices;
     private getItemCount;
@@ -24,7 +19,7 @@ export declare class SelectionModelManager {
     update(oldProps: SelectionModelConfig | null, newProps: SelectionModelConfig, model: Gio.ListModel): SelectionModel;
     private initSelectionHandler;
     private createSelectionModel;
+    reapplySelection(ids?: string[] | null): void;
     private setSelection;
-    private applySelection;
 }
 export {};

package/dist/nodes/internal/{selection-model.js → selection-model-controller.js}

@@ -1,13 +1,8 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { CommitPriority } from "../../scheduler.js";
-import { DeferredAction } from "./deferred-action.js";
-export class SelectionModelManager {
+export class SelectionModelController {
     owner;
     signalStore;
     selectionModel;
-    handleSelectionChange = null;
-    pendingSelection = null;
-    selectionAction;
     getSelection;
     resolveSelectionIndices;
     getItemCount;
@@ -19,7 +14,6 @@ export class SelectionModelManager {
         this.getSelection = getSelection;
         this.resolveSelectionIndices = resolveSelectionIndices;
         this.getItemCount = getItemCount;
-        this.selectionAction = new DeferredAction(() => this.applySelection(), CommitPriority.LOW);
         this.initSelectionHandler(config.onSelectionChanged);
         this.setSelection(config.selected);
     }
@@ -48,10 +42,10 @@ export class SelectionModelManager {
             this.signalStore.set(this.owner, this.selectionModel, "selection-changed", null);
             return;
         }
-        this.handleSelectionChange = () => {
+        const handler = () => {
             onSelectionChanged(this.getSelection());
         };
-        this.signalStore.set(this.owner, this.selectionModel, "selection-changed", this.handleSelectionChange);
+        this.signalStore.set(this.owner, this.selectionModel, "selection-changed", handler);
     }
     createSelectionModel(mode, model) {
         const selectionMode = mode ?? Gtk.SelectionMode.SINGLE;
@@ -66,14 +60,11 @@ export class SelectionModelManager {
         selectionModel.setCanUnselect(selectionMode !== Gtk.SelectionMode.BROWSE);
         return selectionModel;
     }
-    setSelection(ids) {
-        this.pendingSelection = ids ?? null;
-        this.selectionAction.schedule();
+    reapplySelection(ids) {
+        this.setSelection(ids);
     }
-    applySelection() {
-        const ids = this.pendingSelection;
+    setSelection(ids) {
         const nItems = this.getItemCount();
-        this.pendingSelection = null;
         const selected = ids ? this.resolveSelectionIndices(ids) : new Gtk.Bitset();
         const mask = Gtk.Bitset.newRange(0, nItems);
         if (this.selectionModel instanceof Gtk.SingleSelection) {