@gtkx/react 0.12.1 → 0.13.1

package/dist/nodes/action-row-child.d.ts

@@ -1,21 +1,14 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
-import type { Node } from "../node.js";
-import { VirtualNode } from "./virtual.js";
+import { VirtualChildNode } from "./virtual-child.js";
 type PrefixSuffixWidget = Gtk.Widget & {
     addPrefix(child: Gtk.Widget): void;
     addSuffix(child: Gtk.Widget): void;
     remove(child: Gtk.Widget): void;
 };
-export declare class ActionRowChild extends VirtualNode {
+export declare class ActionRowChild extends VirtualChildNode<PrefixSuffixWidget> {
     static priority: number;
     static matches(type: string): boolean;
-    private parent?;
-    private children;
-    private getPosition;
-    setParent(newParent?: PrefixSuffixWidget): void;
-    appendChild(child: Node): void;
-    insertBefore(child: Node): void;
-    removeChild(child: Node): void;
-    unmount(): void;
+    protected getPositionLabel(): string;
+    protected attachChild(parent: PrefixSuffixWidget, widget: Gtk.Widget): void;
 }
 export {};

package/dist/nodes/action-row-child.js

@@ -1,76 +1,20 @@
-import { isObjectEqual } from "@gtkx/ffi";
 import { registerNodeClass } from "../registry.js";
-import { scheduleAfterCommit } from "../scheduler.js";
-import { VirtualNode } from "./virtual.js";
-import { WidgetNode } from "./widget.js";
-export class ActionRowChild extends VirtualNode {
+import { VirtualChildNode } from "./virtual-child.js";
+export class ActionRowChild extends VirtualChildNode {
     static priority = 1;
     static matches(type) {
-        return type === "ActionRow.Prefix" || type === "ActionRow.Suffix";
+        return type === "ActionRowPrefix" || type === "ActionRowSuffix";
     }
-    parent;
-    children = [];
-    getPosition() {
-        return this.typeName === "ActionRow.Prefix" ? "prefix" : "suffix";
+    getPositionLabel() {
+        return this.typeName === "ActionRowPrefix" ? "prefix" : "suffix";
     }
-    setParent(newParent) {
-        this.parent = newParent;
-    }
-    appendChild(child) {
-        if (!(child instanceof WidgetNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to '${this.typeName}': expected Widget`);
-        }
-        const widget = child.container;
-        this.children.push(widget);
-        scheduleAfterCommit(() => {
-            if (this.parent) {
-                if (this.getPosition() === "prefix") {
-                    this.parent.addPrefix(widget);
-                }
-                else {
-                    this.parent.addSuffix(widget);
-                }
-            }
-        });
-    }
-    insertBefore(child) {
-        this.appendChild(child);
-    }
-    removeChild(child) {
-        if (!(child instanceof WidgetNode)) {
-            throw new Error(`Cannot remove '${child.typeName}' from '${this.typeName}': expected Widget`);
-        }
-        const widget = child.container;
-        const parent = this.parent;
-        const index = this.children.indexOf(widget);
-        if (index !== -1) {
-            this.children.splice(index, 1);
+    attachChild(parent, widget) {
+        if (this.getPositionLabel() === "prefix") {
+            parent.addPrefix(widget);
         }
-        scheduleAfterCommit(() => {
-            if (parent) {
-                const currentParent = widget.getParent();
-                if (currentParent && isObjectEqual(currentParent, parent)) {
-                    parent.remove(widget);
-                }
-            }
-        });
-    }
-    unmount() {
-        const parent = this.parent;
-        const childrenToRemove = [...this.children];
-        if (parent && childrenToRemove.length > 0) {
-            scheduleAfterCommit(() => {
-                for (const widget of childrenToRemove) {
-                    const currentParent = widget.getParent();
-                    if (currentParent && isObjectEqual(currentParent, parent)) {
-                        parent.remove(widget);
-                    }
-                }
-            });
+        else {
+            parent.addSuffix(widget);
         }
-        this.children = [];
-        this.parent = undefined;
-        super.unmount();
     }
 }
 registerNodeClass(ActionRowChild);

package/dist/nodes/action-row.js

@@ -2,6 +2,7 @@ import { PREFIX_SUFFIX_INTERFACE_METHODS } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
 import { ActionRowChild } from "./action-row-child.js";
 import { matchesInterface } from "./internal/utils.js";
+import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
 class ActionRowNode extends WidgetNode {
     static priority = 0;
@@ -13,17 +14,33 @@ class ActionRowNode extends WidgetNode {
             child.setParent(this.container);
             return;
         }
-        super.appendChild(child);
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.appendChild(child);
+            return;
+        }
+        throw new Error(`Cannot append '${child.typeName}' to 'ActionRow': expected x.ActionRowPrefix, x.ActionRowSuffix, or Widget`);
     }
-    insertBefore(child) {
-        this.appendChild(child);
+    insertBefore(child, before) {
+        if (child instanceof ActionRowChild) {
+            child.setParent(this.container);
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.insertBefore(child, before);
+            return;
+        }
+        throw new Error(`Cannot insert '${child.typeName}' into 'ActionRow': expected x.ActionRowPrefix, x.ActionRowSuffix, or Widget`);
     }
     removeChild(child) {
         if (child instanceof ActionRowChild) {
             child.unmount();
             return;
         }
-        super.removeChild(child);
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.removeChild(child);
+            return;
+        }
+        throw new Error(`Cannot remove '${child.typeName}' from 'ActionRow': expected x.ActionRowPrefix, x.ActionRowSuffix, or Widget`);
     }
 }
 registerNodeClass(ActionRowNode);

package/dist/nodes/application.js

@@ -1,9 +1,11 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import { Node } from "../node.js";
 import { registerNodeClass } from "../registry.js";
+import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
 import { isContainerType } from "./internal/utils.js";
 import { MenuNode } from "./menu.js";
 import { Menu } from "./models/menu.js";
+import { WindowNode } from "./window.js";
 class ApplicationNode extends Node {
     static priority = 0;
     menu;
@@ -19,20 +21,37 @@ class ApplicationNode extends Node {
         if (child instanceof MenuNode) {
             this.menu.appendChild(child);
             this.container.setMenubar(this.menu.getMenu());
+            return;
         }
+        if (child instanceof WindowNode) {
+            return;
+        }
+        throw new Error(`Cannot append '${child.typeName}' to 'Application': expected Window or MenuItem`);
     }
     insertBefore(child, before) {
         if (child instanceof MenuNode) {
             this.menu.insertBefore(child, before);
+            return;
+        }
+        if (child instanceof WindowNode) {
+            return;
         }
+        throw new Error(`Cannot insert '${child.typeName}' into 'Application': expected Window or MenuItem`);
     }
     removeChild(child) {
         if (child instanceof MenuNode) {
             this.menu.removeChild(child);
-            if (this.menu.getMenu().getNItems() === 0) {
-                this.container.setMenubar(null);
-            }
+            scheduleAfterCommit(() => {
+                if (this.menu.getMenu().getNItems() === 0) {
+                    this.container.setMenubar(null);
+                }
+            }, CommitPriority.LOW);
+            return;
+        }
+        if (child instanceof WindowNode) {
+            return;
         }
+        throw new Error(`Cannot remove '${child.typeName}' from 'Application': expected Window or MenuItem`);
     }
 }
 registerNodeClass(ApplicationNode);

package/dist/nodes/autowrapped.js

@@ -4,6 +4,7 @@ import { AUTOWRAP_CLASSES } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
 import { isRemovable, isSingleChild } from "./internal/predicates.js";
 import { matchesAnyClass } from "./internal/utils.js";
+import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
 const isAutowrappedChild = (obj) => {
     return obj instanceof Gtk.ListBoxRow || obj instanceof Gtk.FlowBoxChild;
@@ -14,10 +15,13 @@ class AutowrappedNode extends WidgetNode {
         return matchesAnyClass(AUTOWRAP_CLASSES, containerOrClass);
     }
     appendChild(child) {
-        if (!(child instanceof WidgetNode)) {
+        if (child instanceof SlotNode) {
             super.appendChild(child);
             return;
         }
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to 'ListBox/FlowBox': expected Widget`);
+        }
         batch(() => {
             if (isAutowrappedChild(child.container)) {
                 const currentParent = child.container.getParent();
@@ -32,10 +36,13 @@ class AutowrappedNode extends WidgetNode {
         });
     }
     removeChild(child) {
-        if (!(child instanceof WidgetNode)) {
+        if (child instanceof SlotNode) {
             super.removeChild(child);
             return;
         }
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot remove '${child.typeName}' from 'ListBox/FlowBox': expected Widget`);
+        }
         batch(() => {
             if (!isAutowrappedChild(child.container)) {
                 const wrapper = child.container.getParent();
@@ -49,10 +56,13 @@ class AutowrappedNode extends WidgetNode {
         });
     }
     insertBefore(child, before) {
-        if (!(child instanceof WidgetNode) || !(before instanceof WidgetNode)) {
+        if (child instanceof SlotNode) {
             super.insertBefore(child, before);
             return;
         }
+        if (!(child instanceof WidgetNode) || !(before instanceof WidgetNode)) {
+            throw new Error(`Cannot insert '${child.typeName}' before '${before.typeName}' in 'ListBox/FlowBox': expected Widget`);
+        }
         batch(() => {
             const currentParent = child.container.getParent();
             if (currentParent !== null) {

package/dist/nodes/calendar-mark.d.ts

@@ -0,0 +1,15 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import { VirtualNode } from "./virtual.js";
+export type CalendarMarkProps = {
+    day: number;
+};
+export declare class CalendarMarkNode extends VirtualNode<CalendarMarkProps> {
+    static priority: number;
+    private calendar?;
+    private onRebuild?;
+    static matches(type: string): boolean;
+    setCalendar(calendar: Gtk.Calendar, onRebuild: () => void): void;
+    addMark(): void;
+    updateProps(oldProps: CalendarMarkProps | null, newProps: CalendarMarkProps): void;
+    unmount(): void;
+}

package/dist/nodes/calendar-mark.js

@@ -0,0 +1,29 @@
+import { registerNodeClass } from "../registry.js";
+import { VirtualNode } from "./virtual.js";
+export class CalendarMarkNode extends VirtualNode {
+    static priority = 1;
+    calendar;
+    onRebuild;
+    static matches(type) {
+        return type === "CalendarMark";
+    }
+    setCalendar(calendar, onRebuild) {
+        this.calendar = calendar;
+        this.onRebuild = onRebuild;
+    }
+    addMark() {
+        this.calendar?.markDay(this.props.day);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        if (oldProps && this.calendar && oldProps.day !== newProps.day) {
+            this.onRebuild?.();
+        }
+    }
+    unmount() {
+        this.calendar = undefined;
+        this.onRebuild = undefined;
+        super.unmount();
+    }
+}
+registerNodeClass(CalendarMarkNode);

package/dist/nodes/calendar.d.ts

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

package/dist/nodes/calendar.js

@@ -0,0 +1,70 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
+import { CalendarMarkNode } from "./calendar-mark.js";
+import { isContainerType } from "./internal/utils.js";
+import { SlotNode } from "./slot.js";
+import { WidgetNode } from "./widget.js";
+class CalendarNode extends WidgetNode {
+    static priority = 1;
+    markChildren = [];
+    static matches(_type, containerOrClass) {
+        return isContainerType(Gtk.Calendar, containerOrClass);
+    }
+    appendChild(child) {
+        if (child instanceof CalendarMarkNode) {
+            child.setCalendar(this.container, () => this.scheduleRebuildAllMarks());
+            this.markChildren.push(child);
+            scheduleAfterCommit(() => child.addMark());
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.appendChild(child);
+            return;
+        }
+        throw new Error(`Cannot append '${child.typeName}' to 'Calendar': expected x.CalendarMark or Widget`);
+    }
+    insertBefore(child, before) {
+        if (child instanceof CalendarMarkNode) {
+            child.setCalendar(this.container, () => this.scheduleRebuildAllMarks());
+            const beforeIndex = this.markChildren.indexOf(before);
+            if (beforeIndex >= 0) {
+                this.markChildren.splice(beforeIndex, 0, child);
+            }
+            else {
+                this.markChildren.push(child);
+            }
+            this.scheduleRebuildAllMarks();
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.insertBefore(child, before);
+            return;
+        }
+        throw new Error(`Cannot insert '${child.typeName}' into 'Calendar': expected x.CalendarMark or Widget`);
+    }
+    removeChild(child) {
+        if (child instanceof CalendarMarkNode) {
+            const index = this.markChildren.indexOf(child);
+            if (index >= 0) {
+                this.markChildren.splice(index, 1);
+            }
+            this.scheduleRebuildAllMarks(CommitPriority.HIGH);
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.removeChild(child);
+            return;
+        }
+        throw new Error(`Cannot remove '${child.typeName}' from 'Calendar': expected x.CalendarMark or Widget`);
+    }
+    scheduleRebuildAllMarks(priority = CommitPriority.NORMAL) {
+        scheduleAfterCommit(() => {
+            this.container.clearMarks();
+            for (const mark of this.markChildren) {
+                mark.addMark();
+            }
+        }, priority);
+    }
+}
+registerNodeClass(CalendarNode);

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

@@ -11,6 +11,7 @@ export declare class ColumnViewColumnNode extends VirtualNode<Props> {
     private itemRenderer;
     constructor(typeName: string, props: Props, container: undefined, rootContainer?: Container);
     setStore(model?: ListStore): void;
+    setEstimatedRowHeight(height?: number): void;
     updateProps(oldProps: Props | null, newProps: Props): void;
 }
 export {};

package/dist/nodes/column-view-column.js

@@ -18,6 +18,9 @@ export class ColumnViewColumnNode extends VirtualNode {
     setStore(model) {
         this.itemRenderer.setStore(model);
     }
+    setEstimatedRowHeight(height) {
+        this.itemRenderer.setEstimatedItemHeight(height);
+    }
     updateProps(oldProps, newProps) {
         if (!oldProps || oldProps.renderCell !== newProps.renderCell) {
             if (newProps.renderCell) {
@@ -49,6 +52,7 @@ export class ColumnViewColumnNode extends VirtualNode {
                 this.column.setSorter(null);
             }
         }
+        super.updateProps(oldProps, newProps);
     }
 }
 registerNodeClass(ColumnViewColumnNode);

package/dist/nodes/column-view.js

@@ -7,17 +7,23 @@ 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 = ["sortColumn", "sortOrder", "onSortChange"];
+const PROP_NAMES = ["sortColumn", "sortOrder", "onSortChange", "estimatedRowHeight"];
 class ColumnViewNode extends WidgetNode {
     static priority = 1;
     handleSortChange;
     list;
+    columnNodes = new Set();
+    estimatedRowHeight;
     static matches(_type, containerOrClass) {
         return matchesAnyClass(COLUMN_VIEW_CLASSES, containerOrClass);
     }
     constructor(typeName, props, container, rootContainer) {
         super(typeName, props, container, rootContainer);
-        this.list = new List(props.selectionMode);
+        this.list = new List({
+            selectionMode: props.selectionMode,
+            selected: props.selected,
+            onSelectionChanged: props.onSelectionChanged,
+        });
     }
     mount() {
         super.mount();
@@ -29,7 +35,7 @@ class ColumnViewNode extends WidgetNode {
             return;
         }
         if (!(child instanceof ColumnViewColumnNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to 'ColumnView': expected ColumnViewColumn`);
+            throw new Error(`Cannot append '${child.typeName}' to 'ColumnView': expected x.ColumnViewColumn or x.ListItem`);
         }
         const existingColumn = this.findColumnInView(child.column);
         if (existingColumn) {
@@ -37,6 +43,8 @@ class ColumnViewNode extends WidgetNode {
         }
         this.container.appendColumn(child.column);
         child.setStore(this.list.getStore());
+        child.setEstimatedRowHeight(this.estimatedRowHeight);
+        this.columnNodes.add(child);
     }
     insertBefore(child, before) {
         if (child instanceof ListItemNode) {
@@ -44,7 +52,7 @@ class ColumnViewNode extends WidgetNode {
             return;
         }
         if (!(child instanceof ColumnViewColumnNode)) {
-            throw new Error(`Cannot insert '${child.typeName}' to 'ColumnView': expected ColumnViewColumn`);
+            throw new Error(`Cannot insert '${child.typeName}' into 'ColumnView': expected x.ColumnViewColumn or x.ListItem`);
         }
         const existingColumn = this.findColumnInView(child.column);
         if (existingColumn) {
@@ -58,6 +66,8 @@ class ColumnViewNode extends WidgetNode {
             this.container.appendColumn(child.column);
         }
         child.setStore(this.list.getStore());
+        child.setEstimatedRowHeight(this.estimatedRowHeight);
+        this.columnNodes.add(child);
     }
     removeChild(child) {
         if (child instanceof ListItemNode) {
@@ -65,13 +75,14 @@ class ColumnViewNode extends WidgetNode {
             return;
         }
         if (!(child instanceof ColumnViewColumnNode)) {
-            throw new Error(`Cannot remove '${child.typeName}' from 'ColumnView': expected ColumnViewColumn`);
+            throw new Error(`Cannot remove '${child.typeName}' from 'ColumnView': expected x.ColumnViewColumn or x.ListItem`);
         }
         const existingColumn = this.findColumnInView(child.column);
         if (existingColumn) {
             this.container.removeColumn(existingColumn);
         }
         child.setStore(undefined);
+        this.columnNodes.delete(child);
     }
     updateProps(oldProps, newProps) {
         if (!oldProps || oldProps.onSortChange !== newProps.onSortChange) {
@@ -94,8 +105,14 @@ class ColumnViewNode extends WidgetNode {
                 this.container.sortByColumn(sortOrder, this.getColumn(sortColumn));
             }
         }
-        this.list.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
-        super.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
+        if (!oldProps || oldProps.estimatedRowHeight !== newProps.estimatedRowHeight) {
+            this.estimatedRowHeight = newProps.estimatedRowHeight;
+            for (const column of this.columnNodes) {
+                column.setEstimatedRowHeight(this.estimatedRowHeight);
+            }
+        }
+        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));
     }
     getColumn(columnId) {
         const columns = this.container.getColumns();

package/dist/nodes/expander-row-child.d.ts

@@ -0,0 +1,15 @@
+import type * as Adw from "@gtkx/ffi/adw";
+import type * as Gtk from "@gtkx/ffi/gtk";
+import { VirtualChildNode } from "./virtual-child.js";
+type ExpanderRowWidget = Adw.ExpanderRow & {
+    addRow(child: Gtk.Widget): void;
+    addAction(widget: Gtk.Widget): void;
+    remove(child: Gtk.Widget): void;
+};
+export declare class ExpanderRowChild extends VirtualChildNode<ExpanderRowWidget> {
+    static priority: number;
+    static matches(type: string): boolean;
+    protected getPositionLabel(): string;
+    protected attachChild(parent: ExpanderRowWidget, widget: Gtk.Widget): void;
+}
+export {};

package/dist/nodes/expander-row-child.js

@@ -0,0 +1,20 @@
+import { registerNodeClass } from "../registry.js";
+import { VirtualChildNode } from "./virtual-child.js";
+export class ExpanderRowChild extends VirtualChildNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "ExpanderRowRow" || type === "ExpanderRowAction";
+    }
+    getPositionLabel() {
+        return this.typeName === "ExpanderRowRow" ? "row" : "action";
+    }
+    attachChild(parent, widget) {
+        if (this.getPositionLabel() === "row") {
+            parent.addRow(widget);
+        }
+        else {
+            parent.addAction(widget);
+        }
+    }
+}
+registerNodeClass(ExpanderRowChild);

package/dist/nodes/expander-row.d.ts

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

package/dist/nodes/expander-row.js

@@ -0,0 +1,54 @@
+import * as Adw from "@gtkx/ffi/adw";
+import { registerNodeClass } from "../registry.js";
+import { ActionRowChild } from "./action-row-child.js";
+import { ExpanderRowChild } from "./expander-row-child.js";
+import { isContainerType } from "./internal/utils.js";
+import { SlotNode } from "./slot.js";
+import { WidgetNode } from "./widget.js";
+class ExpanderRowNode extends WidgetNode {
+    static priority = -1;
+    static matches(_type, containerOrClass) {
+        return isContainerType(Adw.ExpanderRow, containerOrClass);
+    }
+    appendChild(child) {
+        if (child instanceof ExpanderRowChild) {
+            child.setParent(this.container);
+            return;
+        }
+        if (child instanceof ActionRowChild) {
+            child.setParent(this.container);
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.appendChild(child);
+            return;
+        }
+        throw new Error(`Cannot append '${child.typeName}' to 'ExpanderRow': expected x.ExpanderRowRow, x.ExpanderRowAction, x.ActionRowPrefix, x.ActionRowSuffix, or Widget`);
+    }
+    insertBefore(child, before) {
+        if (child instanceof ExpanderRowChild) {
+            child.setParent(this.container);
+            return;
+        }
+        if (child instanceof ActionRowChild) {
+            child.setParent(this.container);
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.insertBefore(child, before);
+            return;
+        }
+        throw new Error(`Cannot insert '${child.typeName}' into 'ExpanderRow': expected x.ExpanderRowRow, x.ExpanderRowAction, x.ActionRowPrefix, x.ActionRowSuffix, or Widget`);
+    }
+    removeChild(child) {
+        if (child instanceof ExpanderRowChild || child instanceof ActionRowChild) {
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.removeChild(child);
+            return;
+        }
+        throw new Error(`Cannot remove '${child.typeName}' from 'ExpanderRow': expected x.ExpanderRowRow, x.ExpanderRowAction, x.ActionRowPrefix, x.ActionRowSuffix, or Widget`);
+    }
+}
+registerNodeClass(ExpanderRowNode);

package/dist/nodes/fixed-child.js

@@ -37,15 +37,17 @@ class FixedChildNode extends SlotNode {
     }
     onChildChange(oldChild) {
         const fixed = this.getFixed();
-        if (oldChild) {
-            const parent = oldChild.getParent();
-            if (parent && isObjectEqual(parent, fixed)) {
-                fixed.remove(oldChild);
+        batch(() => {
+            if (oldChild) {
+                const parent = oldChild.getParent();
+                if (parent && isObjectEqual(parent, fixed)) {
+                    fixed.remove(oldChild);
+                }
             }
-        }
-        if (this.child) {
-            this.positionChild();
-        }
+            if (this.child) {
+                this.positionChild();
+            }
+        });
     }
 }
 registerNodeClass(FixedChildNode);

package/dist/nodes/grid-child.js

@@ -46,15 +46,17 @@ class GridChildNode extends SlotNode {
     }
     onChildChange(oldChild) {
         const grid = this.getGrid();
-        if (oldChild) {
-            const parent = oldChild.getParent();
-            if (parent && isObjectEqual(parent, grid)) {
-                grid.remove(oldChild);
+        batch(() => {
+            if (oldChild) {
+                const parent = oldChild.getParent();
+                if (parent && isObjectEqual(parent, grid)) {
+                    grid.remove(oldChild);
+                }
             }
-        }
-        if (this.child) {
-            this.attachChild();
-        }
+            if (this.child) {
+                this.attachChild();
+            }
+        });
     }
 }
 registerNodeClass(GridChildNode);