@gtkx/react 0.14.0 → 0.16.0

package/dist/nodes/internal/text-buffer-controller.d.ts

@@ -0,0 +1,43 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../../node.js";
+import type { TextContentChild, TextContentParent } from "../text-content.js";
+import { TextSegmentNode } from "../text-segment.js";
+type BufferCallbackProps = {
+    onBufferChanged?: ((buffer: Gtk.TextBuffer) => void) | null;
+    onTextInserted?: ((buffer: Gtk.TextBuffer, offset: number, text: string) => void) | null;
+    onTextDeleted?: ((buffer: Gtk.TextBuffer, startOffset: number, endOffset: number) => void) | null;
+    onCanUndoChanged?: ((canUndo: boolean) => void) | null;
+    onCanRedoChanged?: ((canRedo: boolean) => void) | null;
+};
+type BufferProps = {
+    enableUndo?: boolean;
+} & BufferCallbackProps;
+export declare class TextBufferController<TBuffer extends Gtk.TextBuffer = Gtk.TextBuffer> {
+    private readonly owner;
+    private readonly container;
+    private readonly createBuffer;
+    private buffer;
+    private textChildren;
+    constructor(owner: Node & TextContentParent, container: Gtk.TextView, createBuffer: () => TBuffer);
+    getBuffer(): TBuffer | null;
+    hasTextChildren(): boolean;
+    ensureBuffer(): TBuffer;
+    applyOwnProps(oldProps: BufferProps | null, newProps: BufferProps): void;
+    private updateSignalHandlers;
+    isTextContentChild(child: Node): child is TextContentChild;
+    appendChild(child: TextContentChild): void;
+    insertBefore(child: TextContentChild, before: TextContentChild): void;
+    removeChild(child: TextContentChild): void;
+    private setChildParent;
+    private getTotalLength;
+    private insertTextAtOffset;
+    private deleteTextAtRange;
+    private updateChildOffsets;
+    private reapplyAllTagsRecursive;
+    private reapplyTagsFromOffset;
+    private findDirectChildContaining;
+    onChildInserted(child: TextContentChild): void;
+    onChildRemoved(child: TextContentChild): void;
+    onChildTextChanged(child: TextSegmentNode, oldLength: number, _newLength: number): void;
+}
+export {};

package/dist/nodes/internal/text-buffer-controller.js

@@ -0,0 +1,287 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { TextAnchorNode } from "../text-anchor.js";
+import { TextPaintableNode } from "../text-paintable.js";
+import { TextSegmentNode } from "../text-segment.js";
+import { TextTagNode } from "../text-tag.js";
+import { hasChanged } from "./utils.js";
+export class TextBufferController {
+    owner;
+    container;
+    createBuffer;
+    buffer = null;
+    textChildren = [];
+    constructor(owner, container, createBuffer) {
+        this.owner = owner;
+        this.container = container;
+        this.createBuffer = createBuffer;
+    }
+    getBuffer() {
+        return this.buffer;
+    }
+    hasTextChildren() {
+        return this.textChildren.length > 0;
+    }
+    ensureBuffer() {
+        if (!this.buffer) {
+            this.buffer = this.createBuffer();
+            this.container.setBuffer(this.buffer);
+        }
+        return this.buffer;
+    }
+    applyOwnProps(oldProps, newProps) {
+        const hasBufferProps = newProps.enableUndo !== undefined ||
+            newProps.onBufferChanged !== undefined ||
+            newProps.onTextInserted !== undefined ||
+            newProps.onTextDeleted !== undefined ||
+            newProps.onCanUndoChanged !== undefined ||
+            newProps.onCanRedoChanged !== undefined;
+        if (!hasBufferProps && this.textChildren.length === 0) {
+            return;
+        }
+        const buffer = this.ensureBuffer();
+        if (hasChanged(oldProps, newProps, "enableUndo") && newProps.enableUndo !== undefined) {
+            buffer.setEnableUndo(newProps.enableUndo);
+        }
+        const signalHandlersChanged = hasChanged(oldProps, newProps, "onBufferChanged") ||
+            hasChanged(oldProps, newProps, "onTextInserted") ||
+            hasChanged(oldProps, newProps, "onTextDeleted") ||
+            hasChanged(oldProps, newProps, "onCanUndoChanged") ||
+            hasChanged(oldProps, newProps, "onCanRedoChanged");
+        if (signalHandlersChanged) {
+            this.updateSignalHandlers(newProps);
+        }
+    }
+    updateSignalHandlers(callbacks) {
+        if (!this.buffer)
+            return;
+        const buffer = this.buffer;
+        const { onBufferChanged, onTextInserted, onTextDeleted, onCanUndoChanged, onCanRedoChanged } = callbacks;
+        this.owner.signalStore.set(this.owner, buffer, "changed", onBufferChanged ? () => onBufferChanged(buffer) : null);
+        this.owner.signalStore.set(this.owner, buffer, "insert-text", onTextInserted
+            ? (location, text, _len) => onTextInserted(buffer, location.getOffset(), text)
+            : null);
+        this.owner.signalStore.set(this.owner, buffer, "delete-range", onTextDeleted
+            ? (start, end) => onTextDeleted(buffer, start.getOffset(), end.getOffset())
+            : null);
+        this.owner.signalStore.set(this.owner, buffer, "notify::can-undo", onCanUndoChanged ? () => onCanUndoChanged(buffer.getCanUndo()) : null);
+        this.owner.signalStore.set(this.owner, buffer, "notify::can-redo", onCanRedoChanged ? () => onCanRedoChanged(buffer.getCanRedo()) : null);
+    }
+    isTextContentChild(child) {
+        return (child instanceof TextSegmentNode ||
+            child instanceof TextTagNode ||
+            child instanceof TextAnchorNode ||
+            child instanceof TextPaintableNode);
+    }
+    appendChild(child) {
+        const buffer = this.ensureBuffer();
+        const wasMoved = this.textChildren.indexOf(child) !== -1;
+        if (wasMoved) {
+            const existingIndex = this.textChildren.indexOf(child);
+            const oldOffset = child.bufferOffset;
+            const oldLength = child.getLength();
+            this.textChildren.splice(existingIndex, 1);
+            if (oldLength > 0) {
+                this.deleteTextAtRange(oldOffset, oldOffset + oldLength);
+            }
+            this.updateChildOffsets(existingIndex);
+        }
+        const offset = this.getTotalLength();
+        this.textChildren.push(child);
+        child.bufferOffset = offset;
+        this.setChildParent(child);
+        if (child instanceof TextSegmentNode) {
+            this.insertTextAtOffset(child.getText(), offset);
+        }
+        else if (child instanceof TextTagNode) {
+            const text = child.getText();
+            this.insertTextAtOffset(text, offset);
+            if (!child.hasBuffer()) {
+                child.setBuffer(buffer);
+            }
+        }
+        else if (child instanceof TextAnchorNode) {
+            child.setTextViewAndBuffer(this.container, buffer);
+        }
+        else if (child instanceof TextPaintableNode) {
+            child.setTextViewAndBuffer(this.container, buffer);
+        }
+        if (wasMoved) {
+            this.updateChildOffsets(0);
+            this.reapplyTagsFromOffset(0);
+        }
+    }
+    insertBefore(child, before) {
+        const buffer = this.ensureBuffer();
+        const existingIndex = this.textChildren.indexOf(child);
+        if (existingIndex !== -1) {
+            const oldOffset = child.bufferOffset;
+            const oldLength = child.getLength();
+            this.textChildren.splice(existingIndex, 1);
+            if (oldLength > 0) {
+                this.deleteTextAtRange(oldOffset, oldOffset + oldLength);
+            }
+            this.updateChildOffsets(existingIndex);
+        }
+        const beforeIndex = this.textChildren.indexOf(before);
+        const insertIndex = beforeIndex !== -1 ? beforeIndex : this.textChildren.length;
+        let offset = 0;
+        for (let i = 0; i < insertIndex; i++) {
+            const c = this.textChildren[i];
+            if (c)
+                offset += c.getLength();
+        }
+        this.textChildren.splice(insertIndex, 0, child);
+        child.bufferOffset = offset;
+        this.setChildParent(child);
+        if (child instanceof TextSegmentNode) {
+            this.insertTextAtOffset(child.getText(), offset);
+        }
+        else if (child instanceof TextTagNode) {
+            const text = child.getText();
+            this.insertTextAtOffset(text, offset);
+            if (!child.hasBuffer()) {
+                child.setBuffer(buffer);
+            }
+        }
+        else if (child instanceof TextAnchorNode) {
+            child.setTextViewAndBuffer(this.container, buffer);
+        }
+        else if (child instanceof TextPaintableNode) {
+            child.setTextViewAndBuffer(this.container, buffer);
+        }
+        this.updateChildOffsets(0);
+        this.reapplyTagsFromOffset(0);
+    }
+    removeChild(child) {
+        const index = this.textChildren.indexOf(child);
+        if (index === -1)
+            return;
+        const offset = child.bufferOffset;
+        const length = child.getLength();
+        this.textChildren.splice(index, 1);
+        if (this.buffer && length > 0) {
+            this.deleteTextAtRange(offset, offset + length);
+        }
+        this.updateChildOffsets(index);
+        this.reapplyTagsFromOffset(offset);
+    }
+    setChildParent(child) {
+        if (child instanceof TextSegmentNode || child instanceof TextTagNode) {
+            child.setParent(this.owner);
+        }
+    }
+    getTotalLength() {
+        let length = 0;
+        for (const child of this.textChildren) {
+            length += child.getLength();
+        }
+        return length;
+    }
+    insertTextAtOffset(text, offset) {
+        const buffer = this.buffer;
+        if (!buffer || text.length === 0)
+            return;
+        const iter = new Gtk.TextIter();
+        buffer.getIterAtOffset(iter, offset);
+        buffer.insert(iter, text, text.length);
+    }
+    deleteTextAtRange(start, end) {
+        const buffer = this.buffer;
+        if (!buffer || start >= end)
+            return;
+        const startIter = new Gtk.TextIter();
+        const endIter = new Gtk.TextIter();
+        buffer.getIterAtOffset(startIter, start);
+        buffer.getIterAtOffset(endIter, end);
+        buffer.delete(startIter, endIter);
+    }
+    updateChildOffsets(startIndex) {
+        let offset = 0;
+        for (let i = 0; i < startIndex; i++) {
+            const child = this.textChildren[i];
+            if (child)
+                offset += child.getLength();
+        }
+        for (let i = startIndex; i < this.textChildren.length; i++) {
+            const child = this.textChildren[i];
+            if (child) {
+                child.bufferOffset = offset;
+                offset += child.getLength();
+            }
+        }
+    }
+    reapplyAllTagsRecursive(children) {
+        for (const child of children) {
+            if (child instanceof TextTagNode) {
+                child.reapplyTag();
+                this.reapplyAllTagsRecursive(child.getChildren());
+            }
+        }
+    }
+    reapplyTagsFromOffset(fromOffset) {
+        for (const child of this.textChildren) {
+            if (child instanceof TextTagNode) {
+                if (child.bufferOffset >= fromOffset) {
+                    child.reapplyTag();
+                    this.reapplyAllTagsRecursive(child.getChildren());
+                }
+                else if (child.bufferOffset + child.getLength() > fromOffset) {
+                    child.reapplyTag();
+                    this.reapplyAllTagsRecursive(child.getChildren());
+                }
+            }
+        }
+    }
+    findDirectChildContaining(offset) {
+        for (let i = 0; i < this.textChildren.length; i++) {
+            const child = this.textChildren[i];
+            if (child) {
+                const start = child.bufferOffset;
+                const end = start + child.getLength();
+                if (offset >= start && offset <= end) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+    onChildInserted(child) {
+        if (!this.buffer)
+            return;
+        const text = child.getText();
+        if (text.length > 0) {
+            this.insertTextAtOffset(text, child.bufferOffset);
+        }
+        const containingIndex = this.findDirectChildContaining(child.bufferOffset);
+        if (containingIndex !== -1) {
+            this.updateChildOffsets(containingIndex + 1);
+        }
+        this.reapplyTagsFromOffset(child.bufferOffset);
+    }
+    onChildRemoved(child) {
+        if (!this.buffer)
+            return;
+        const offset = child.bufferOffset;
+        const length = child.getLength();
+        if (length > 0) {
+            this.deleteTextAtRange(offset, offset + length);
+        }
+        const containingIndex = this.findDirectChildContaining(offset);
+        if (containingIndex !== -1) {
+            this.updateChildOffsets(containingIndex + 1);
+        }
+        this.reapplyTagsFromOffset(offset);
+    }
+    onChildTextChanged(child, oldLength, _newLength) {
+        if (!this.buffer)
+            return;
+        const offset = child.bufferOffset;
+        this.deleteTextAtRange(offset, offset + oldLength);
+        this.insertTextAtOffset(child.getText(), offset);
+        const containingIndex = this.findDirectChildContaining(offset);
+        if (containingIndex !== -1) {
+            this.updateChildOffsets(containingIndex + 1);
+        }
+        this.reapplyTagsFromOffset(offset);
+    }
+}

package/dist/nodes/internal/text-tag-styles.d.ts

@@ -0,0 +1,43 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type * as Pango from "@gtkx/ffi/pango";
+export type TagStyleProps = {
+    background?: string;
+    backgroundFullHeight?: boolean;
+    foreground?: string;
+    family?: string;
+    font?: string;
+    sizePoints?: number;
+    size?: number;
+    scale?: number;
+    weight?: Pango.Weight | number;
+    style?: Pango.Style;
+    stretch?: Pango.Stretch;
+    variant?: Pango.Variant;
+    strikethrough?: boolean;
+    underline?: Pango.Underline;
+    overline?: Pango.Overline;
+    rise?: number;
+    letterSpacing?: number;
+    lineHeight?: number;
+    leftMargin?: number;
+    rightMargin?: number;
+    indent?: number;
+    pixelsAboveLines?: number;
+    pixelsBelowLines?: number;
+    pixelsInsideWrap?: number;
+    justification?: Gtk.Justification;
+    direction?: Gtk.TextDirection;
+    wrapMode?: Gtk.WrapMode;
+    editable?: boolean;
+    invisible?: boolean;
+    allowBreaks?: boolean;
+    insertHyphens?: boolean;
+    fallback?: boolean;
+    accumulativeMargin?: boolean;
+    paragraphBackground?: string;
+    showSpaces?: Pango.ShowFlags;
+    textTransform?: Pango.TextTransform;
+    fontFeatures?: string;
+    language?: string;
+};
+export declare function applyStyleChanges(tag: Gtk.TextTag, oldProps: TagStyleProps | null, newProps: TagStyleProps): void;

package/dist/nodes/internal/text-tag-styles.js

@@ -0,0 +1,52 @@
+import { hasChanged } from "./utils.js";
+const STYLE_PROPS = {
+    background: "setBackground",
+    backgroundFullHeight: "setBackgroundFullHeight",
+    foreground: "setForeground",
+    family: "setFamily",
+    font: "setFont",
+    sizePoints: "setSizePoints",
+    size: "setSize",
+    scale: "setScale",
+    weight: "setWeight",
+    style: "setStyle",
+    stretch: "setStretch",
+    variant: "setVariant",
+    strikethrough: "setStrikethrough",
+    underline: "setUnderline",
+    overline: "setOverline",
+    rise: "setRise",
+    letterSpacing: "setLetterSpacing",
+    lineHeight: "setLineHeight",
+    leftMargin: "setLeftMargin",
+    rightMargin: "setRightMargin",
+    indent: "setIndent",
+    pixelsAboveLines: "setPixelsAboveLines",
+    pixelsBelowLines: "setPixelsBelowLines",
+    pixelsInsideWrap: "setPixelsInsideWrap",
+    justification: "setJustification",
+    direction: "setDirection",
+    wrapMode: "setWrapMode",
+    editable: "setEditable",
+    invisible: "setInvisible",
+    allowBreaks: "setAllowBreaks",
+    insertHyphens: "setInsertHyphens",
+    fallback: "setFallback",
+    accumulativeMargin: "setAccumulativeMargin",
+    paragraphBackground: "setParagraphBackground",
+    showSpaces: "setShowSpaces",
+    textTransform: "setTextTransform",
+    fontFeatures: "setFontFeatures",
+    language: "setLanguage",
+};
+export function applyStyleChanges(tag, oldProps, newProps) {
+    for (const prop of Object.keys(STYLE_PROPS)) {
+        if (hasChanged(oldProps, newProps, prop)) {
+            const value = newProps[prop];
+            if (value !== undefined) {
+                const setter = tag[STYLE_PROPS[prop]];
+                setter.call(tag, value);
+            }
+        }
+    }
+}

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

@@ -1,24 +1,26 @@
 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 { TreeStore } from "./tree-store.js";
 export type TreeRenderItemFn<T> = (item: T | null, row: Gtk.TreeListRow | null) => ReactNode;
-export declare class TreeListItemRenderer {
-    private factory;
-    private store?;
-    private fiberRoots;
+export declare class TreeListItemRenderer extends BaseItemRenderer<TreeStore> {
     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 renderFn;
+    private boundItems;
+    setRenderFn(renderFn: TreeRenderItemFn<unknown> | null): void;
+    rebindItem(id: string): void;
+    protected getStoreTypeName(): string;
+    dispose(): void;
+    protected renderItem(_ptr: number): ReactNode;
+    protected getItemFromListItem(listItem: Gtk.ListItem): unknown;
+    protected onSetup(listItem: Gtk.ListItem, ptr: number): Gtk.Widget;
+    protected onSetupComplete(ptr: number): void;
+    protected onBind(listItem: Gtk.ListItem, ptr: number, fiberRoot: Reconciler.FiberRoot): void;
+    protected onUnbind(listItem: Gtk.ListItem): void;
+    protected onTeardown(_listItem: Gtk.ListItem, ptr: number): void;
     private processPendingBind;
     private renderBind;
 }

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

@@ -1,114 +1,109 @@
-import { getNativeId } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
-import { createFiberRoot } from "../../fiber-root.js";
 import { reconciler } from "../../reconciler.js";
-import { signalStore } from "./signal-store.js";
-export class TreeListItemRenderer {
-    factory;
-    store;
-    fiberRoots = new Map();
+import { BaseItemRenderer } from "./base-item-renderer.js";
+export class TreeListItemRenderer extends BaseItemRenderer {
     expanders = new Map();
     setupComplete = new Set();
     pendingBinds = new Map();
-    tornDown = new Set();
     renderFn = () => null;
-    estimatedItemHeight;
-    constructor() {
-        this.factory = new Gtk.SignalListItemFactory();
-        this.initialize();
-    }
-    getFactory() {
-        return this.factory;
-    }
+    boundItems = new Map();
     setRenderFn(renderFn) {
         this.renderFn = renderFn;
     }
-    setStore(store) {
-        this.store = store;
+    rebindItem(id) {
+        const binding = this.boundItems.get(id);
+        if (!binding)
+            return;
+        const fiberRoot = this.fiberRoots.get(binding.ptr);
+        if (!fiberRoot)
+            return;
+        const expander = this.expanders.get(binding.ptr);
+        if (!expander)
+            return;
+        this.renderBind(binding.ptr, expander, binding.treeListRow, id, fiberRoot);
+    }
+    getStoreTypeName() {
+        return "tree store";
+    }
+    dispose() {
+        super.dispose();
+        this.expanders.clear();
+        this.setupComplete.clear();
+        this.pendingBinds.clear();
+        this.boundItems.clear();
+    }
+    renderItem(_ptr) {
+        return this.renderFn?.(null, null);
     }
-    setEstimatedItemHeight(height) {
-        this.estimatedItemHeight = height;
+    getItemFromListItem(listItem) {
+        const treeListRow = listItem.getItem();
+        if (!(treeListRow instanceof Gtk.TreeListRow))
+            return null;
+        const stringObject = treeListRow.getItem();
+        if (!(stringObject instanceof Gtk.StringObject))
+            return null;
+        return this.getStore().getItem(stringObject.getString());
     }
-    getStore() {
-        if (!this.store) {
-            throw new Error("Expected tree store to be set on TreeListItemRenderer");
+    onSetup(listItem, ptr) {
+        const expander = new Gtk.TreeExpander();
+        const box = this.createBox();
+        expander.setChild(box);
+        listItem.setChild(expander);
+        this.expanders.set(ptr, expander);
+        return box;
+    }
+    onSetupComplete(ptr) {
+        this.setupComplete.add(ptr);
+        this.processPendingBind(ptr);
+    }
+    onBind(listItem, ptr, fiberRoot) {
+        const expander = this.expanders.get(ptr);
+        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, { ptr, treeListRow });
+        if (!this.setupComplete.has(ptr)) {
+            this.pendingBinds.set(ptr, { treeListRow, expander, id });
+            return;
         }
-        return this.store;
+        this.renderBind(ptr, expander, treeListRow, id, fiberRoot);
     }
-    initialize() {
-        signalStore.set(this, this.factory, "setup", (_self, listItem) => {
-            const ptr = getNativeId(listItem.handle);
-            const expander = new Gtk.TreeExpander();
-            const box = new Gtk.Box(Gtk.Orientation.VERTICAL);
-            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, () => {
-                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);
-            const expander = this.expanders.get(ptr);
-            if (!fiberRoot || !expander)
-                return;
+    onUnbind(listItem) {
+        const expander = listItem.getChild();
+        if (expander instanceof Gtk.TreeExpander) {
+            expander.setListRow(null);
             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();
-            if (!this.setupComplete.has(ptr)) {
-                this.pendingBinds.set(ptr, { treeListRow, expander, id });
-                return;
-            }
-            this.renderBind(ptr, expander, treeListRow, id);
-        });
-        signalStore.set(this, this.factory, "unbind", (_self, listItem) => {
-            const expander = listItem.getChild();
-            if (expander instanceof Gtk.TreeExpander) {
-                expander.setListRow(null);
+            if (treeListRow instanceof Gtk.TreeListRow) {
+                const stringObject = treeListRow.getItem();
+                if (stringObject instanceof Gtk.StringObject) {
+                    this.boundItems.delete(stringObject.getString());
+                }
             }
-        });
-        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);
-                    this.expanders.delete(ptr);
-                    this.setupComplete.delete(ptr);
-                    this.pendingBinds.delete(ptr);
-                    this.tornDown.delete(ptr);
-                });
-            }
-        });
+        }
+    }
+    onTeardown(_listItem, ptr) {
+        this.expanders.delete(ptr);
+        this.setupComplete.delete(ptr);
+        this.pendingBinds.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;
+        if (fiberRoot) {
+            this.renderBind(ptr, pending.expander, pending.treeListRow, pending.id, fiberRoot);
+        }
+    }
+    renderBind(ptr, expander, treeListRow, id, fiberRoot) {
         const itemData = this.getStore().getItem(id);
         if (itemData) {
             if (itemData.indentForDepth !== undefined) {
@@ -125,12 +120,14 @@ export class TreeListItemRenderer {
         reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {
             if (this.tornDown.has(ptr))
                 return;
+            if (this.estimatedItemHeight !== null)
+                return;
             const currentExpander = this.expanders.get(ptr);
             if (!currentExpander)
                 return;
             const box = currentExpander.getChild();
-            if (box instanceof Gtk.Box) {
-                box.setSizeRequest(-1, -1);
+            if (box) {
+                this.clearBoxSizeRequest(box);
             }
         });
     }