@gtkx/react 0.12.0 → 0.13.0

package/dist/nodes/pack.js

@@ -2,6 +2,7 @@ import { PACK_INTERFACE_METHODS } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
 import { matchesInterface } from "./internal/utils.js";
 import { PackChild } from "./pack-child.js";
+import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
 class PackNode extends WidgetNode {
     static priority = 0;
@@ -13,17 +14,33 @@ class PackNode 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 'Pack': expected x.PackStart, x.PackEnd, or Widget`);
     }
-    insertBefore(child) {
-        this.appendChild(child);
+    insertBefore(child, before) {
+        if (child instanceof PackChild) {
+            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 'Pack': expected x.PackStart, x.PackEnd, or Widget`);
     }
     removeChild(child) {
         if (child instanceof PackChild) {
             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 'Pack': expected x.PackStart, x.PackEnd, or Widget`);
     }
 }
 registerNodeClass(PackNode);

package/dist/nodes/popover-menu.js

@@ -24,34 +24,37 @@ class PopoverMenuNode extends WidgetNode {
         this.container.setMenuModel(this.menu.getMenu());
     }
     appendChild(child) {
+        if (child instanceof MenuNode) {
+            this.menu.appendChild(child);
+            return;
+        }
         if (child instanceof SlotNode || child instanceof WidgetNode) {
             super.appendChild(child);
             return;
         }
-        if (!(child instanceof MenuNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to 'PopoverMenu': expected MenuItem`);
-        }
-        this.menu.appendChild(child);
+        throw new Error(`Cannot append '${child.typeName}' to 'PopoverMenu': expected MenuItem or Widget`);
     }
     insertBefore(child, before) {
+        if (child instanceof MenuNode) {
+            this.menu.insertBefore(child, before);
+            return;
+        }
         if (child instanceof SlotNode || child instanceof WidgetNode) {
             super.insertBefore(child, before);
             return;
         }
-        if (!(child instanceof MenuNode)) {
-            throw new Error(`Cannot insert '${child.typeName}' to 'PopoverMenu': expected MenuItem`);
-        }
-        this.menu.insertBefore(child, before);
+        throw new Error(`Cannot insert '${child.typeName}' into 'PopoverMenu': expected MenuItem or Widget`);
     }
     removeChild(child) {
+        if (child instanceof MenuNode) {
+            this.menu.removeChild(child);
+            return;
+        }
         if (child instanceof SlotNode || child instanceof WidgetNode) {
             super.removeChild(child);
             return;
         }
-        if (!(child instanceof MenuNode)) {
-            throw new Error(`Cannot remove '${child.typeName}' from 'PopoverMenu': expected MenuItem`);
-        }
-        this.menu.removeChild(child);
+        throw new Error(`Cannot remove '${child.typeName}' from 'PopoverMenu': expected MenuItem or Widget`);
     }
 }
 registerNodeClass(PopoverMenuNode);

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

@@ -0,0 +1,17 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { VirtualNode } from "./virtual.js";
+export type ScaleMarkProps = {
+    value: number;
+    position?: Gtk.PositionType;
+    label?: string | null;
+};
+export declare class ScaleMarkNode extends VirtualNode<ScaleMarkProps> {
+    static priority: number;
+    private scale?;
+    private onRebuild?;
+    static matches(type: string): boolean;
+    setScale(scale: Gtk.Scale, onRebuild: () => void): void;
+    addMark(): void;
+    updateProps(oldProps: ScaleMarkProps | null, newProps: ScaleMarkProps): void;
+    unmount(): void;
+}

package/dist/nodes/scale-mark.js

@@ -0,0 +1,38 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { VirtualNode } from "./virtual.js";
+export class ScaleMarkNode extends VirtualNode {
+    static priority = 1;
+    scale;
+    onRebuild;
+    static matches(type) {
+        return type === "ScaleMark";
+    }
+    setScale(scale, onRebuild) {
+        this.scale = scale;
+        this.onRebuild = onRebuild;
+    }
+    addMark() {
+        if (!this.scale)
+            return;
+        const { value, position, label } = this.props;
+        this.scale.addMark(value, position ?? Gtk.PositionType.BOTTOM, label);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        if (oldProps && this.scale) {
+            const changed = oldProps.value !== newProps.value ||
+                oldProps.position !== newProps.position ||
+                oldProps.label !== newProps.label;
+            if (changed) {
+                this.onRebuild?.();
+            }
+        }
+    }
+    unmount() {
+        this.scale = undefined;
+        this.onRebuild = undefined;
+        super.unmount();
+    }
+}
+registerNodeClass(ScaleMarkNode);

package/dist/nodes/scale.d.ts

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

package/dist/nodes/scale.js

@@ -0,0 +1,70 @@
+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 { ScaleMarkNode } from "./scale-mark.js";
+import { SlotNode } from "./slot.js";
+import { WidgetNode } from "./widget.js";
+class ScaleNode extends WidgetNode {
+    static priority = 1;
+    markChildren = [];
+    static matches(_type, containerOrClass) {
+        return isContainerType(Gtk.Scale, containerOrClass);
+    }
+    appendChild(child) {
+        if (child instanceof ScaleMarkNode) {
+            child.setScale(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 'Scale': expected x.ScaleMark or Widget`);
+    }
+    insertBefore(child, before) {
+        if (child instanceof ScaleMarkNode) {
+            child.setScale(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 'Scale': expected x.ScaleMark or Widget`);
+    }
+    removeChild(child) {
+        if (child instanceof ScaleMarkNode) {
+            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 'Scale': expected x.ScaleMark or Widget`);
+    }
+    scheduleRebuildAllMarks(priority = CommitPriority.NORMAL) {
+        scheduleAfterCommit(() => {
+            this.container.clearMarks();
+            for (const mark of this.markChildren) {
+                mark.addMark();
+            }
+        }, priority);
+    }
+}
+registerNodeClass(ScaleNode);

package/dist/nodes/simple-list-view.js

@@ -40,7 +40,7 @@ class SimpleListViewNode extends WidgetNode {
     }
     appendChild(child) {
         if (!(child instanceof SimpleListItemNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to 'SimpleListView': expected SimpleListItem`);
+            throw new Error(`Cannot append '${child.typeName}' to 'DropDown': expected x.SimpleListItem`);
         }
         const { id, value } = child.props;
         if (!id || value === undefined) {
@@ -51,7 +51,7 @@ class SimpleListViewNode extends WidgetNode {
     }
     insertBefore(child, before) {
         if (!(child instanceof SimpleListItemNode) || !(before instanceof SimpleListItemNode)) {
-            throw new Error(`Cannot insert '${child.typeName}' to 'SimpleListView': expected SimpleListItem`);
+            throw new Error(`Cannot insert '${child.typeName}' into 'DropDown': expected x.SimpleListItem`);
         }
         const { id, value } = child.props;
         const beforeId = before.props.id;
@@ -63,7 +63,7 @@ class SimpleListViewNode extends WidgetNode {
     }
     removeChild(child) {
         if (!(child instanceof SimpleListItemNode)) {
-            throw new Error(`Cannot remove '${child.typeName}' from 'SimpleListView': expected SimpleListItem`);
+            throw new Error(`Cannot remove '${child.typeName}' from 'DropDown': expected x.SimpleListItem`);
         }
         const { id } = child.props;
         if (!id) {

package/dist/nodes/slot.d.ts

@@ -1,9 +1,10 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
 import type { SlotProps } from "../jsx.js";
 import type { Node } from "../node.js";
+import type { Props } from "../types.js";
 import { VirtualNode } from "./virtual.js";
 type SlotNodeProps = Omit<SlotProps, "children">;
-export declare class SlotNode<P extends SlotNodeProps = SlotNodeProps> extends VirtualNode<P> {
+export declare class SlotNode<P extends Props = SlotNodeProps> extends VirtualNode<P> {
     static priority: number;
     static matches(type: string): boolean;
     parent?: Gtk.Widget;

package/dist/nodes/slot.js

@@ -1,7 +1,7 @@
 import { isObjectEqual } from "@gtkx/ffi";
 import { toCamelCase } from "@gtkx/gir";
 import { registerNodeClass } from "../registry.js";
-import { scheduleAfterCommit } from "../scheduler.js";
+import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
 import { resolvePropMeta } from "./internal/utils.js";
 import { VirtualNode } from "./virtual.js";
 import { WidgetNode } from "./widget.js";
@@ -64,7 +64,7 @@ export class SlotNode extends VirtualNode {
             if (this.parent) {
                 this.onChildChange(oldChild ?? null);
             }
-        });
+        }, CommitPriority.HIGH);
     }
     onChildChange(oldChild) {
         const parent = this.getParent();

package/dist/nodes/stack-page.js

@@ -38,13 +38,13 @@ class StackPageNode extends SlotNode {
         let page;
         if (parent instanceof Adw.ViewStack) {
             if (this.props.title && this.props.iconName) {
-                page = parent.addTitledWithIcon(child, this.props.title, this.props.iconName, this.props.name);
+                page = parent.addTitledWithIcon(child, this.props.title, this.props.iconName, this.props.id);
             }
             else if (this.props.title) {
-                page = parent.addTitled(child, this.props.title, this.props.name);
+                page = parent.addTitled(child, this.props.title, this.props.id);
             }
-            else if (this.props.name) {
-                page = parent.addNamed(child, this.props.name);
+            else if (this.props.id) {
+                page = parent.addNamed(child, this.props.id);
             }
             else {
                 page = parent.add(child);
@@ -52,10 +52,10 @@ class StackPageNode extends SlotNode {
         }
         else {
             if (this.props.title) {
-                page = parent.addTitled(child, this.props.title, this.props.name);
+                page = parent.addTitled(child, this.props.title, this.props.id);
             }
-            else if (this.props.name) {
-                page = parent.addNamed(child, this.props.name);
+            else if (this.props.id) {
+                page = parent.addNamed(child, this.props.id);
             }
             else {
                 page = parent.addChild(child);

package/dist/nodes/stack.js

@@ -3,18 +3,18 @@ import { registerNodeClass } from "../registry.js";
 import { scheduleAfterCommit } from "../scheduler.js";
 import { filterProps, matchesAnyClass } from "./internal/utils.js";
 import { WidgetNode } from "./widget.js";
-const PROPS = ["visibleChildName"];
+const PROPS = ["page"];
 class StackNode extends WidgetNode {
     static priority = 1;
     static matches(_type, containerOrClass) {
         return matchesAnyClass(STACK_CLASSES, containerOrClass);
     }
     updateProps(oldProps, newProps) {
-        if (newProps.visibleChildName && this.container.getVisibleChildName() !== newProps.visibleChildName) {
-            const visibleChildName = newProps.visibleChildName;
+        if (newProps.page && this.container.getVisibleChildName() !== newProps.page) {
+            const page = newProps.page;
             scheduleAfterCommit(() => {
-                if (this.container.getChildByName(visibleChildName)) {
-                    this.container.setVisibleChildName(visibleChildName);
+                if (this.container.getChildByName(page)) {
+                    this.container.setVisibleChildName(page);
                 }
             });
         }

package/dist/nodes/toggle-group.d.ts

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

package/dist/nodes/toggle-group.js

@@ -0,0 +1,48 @@
+import * as Adw from "@gtkx/ffi/adw";
+import { registerNodeClass } from "../registry.js";
+import { isContainerType } from "./internal/utils.js";
+import { SlotNode } from "./slot.js";
+import { ToggleNode } from "./toggle.js";
+import { WidgetNode } from "./widget.js";
+class ToggleGroupNode extends WidgetNode {
+    static priority = 1;
+    static matches(_type, containerOrClass) {
+        return isContainerType(Adw.ToggleGroup, containerOrClass);
+    }
+    appendChild(child) {
+        if (child instanceof ToggleNode) {
+            child.setToggleGroup(this.container);
+            child.addToGroup();
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.appendChild(child);
+            return;
+        }
+        throw new Error(`Cannot append '${child.typeName}' to 'ToggleGroup': expected x.Toggle or Widget`);
+    }
+    insertBefore(child, before) {
+        if (child instanceof ToggleNode) {
+            child.setToggleGroup(this.container);
+            child.addToGroup();
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.insertBefore(child, before);
+            return;
+        }
+        throw new Error(`Cannot insert '${child.typeName}' into 'ToggleGroup': expected x.Toggle or Widget`);
+    }
+    removeChild(child) {
+        if (child instanceof ToggleNode) {
+            child.removeFromGroup();
+            return;
+        }
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.removeChild(child);
+            return;
+        }
+        throw new Error(`Cannot remove '${child.typeName}' from 'ToggleGroup': expected x.Toggle or Widget`);
+    }
+}
+registerNodeClass(ToggleGroupNode);

package/dist/nodes/toggle.d.ts

@@ -0,0 +1,15 @@
+import * as Adw from "@gtkx/ffi/adw";
+import type { ToggleProps } from "../jsx.js";
+import { VirtualNode } from "./virtual.js";
+export declare class ToggleNode extends VirtualNode<ToggleProps> {
+    static priority: number;
+    private toggleGroup?;
+    private toggle?;
+    static matches(type: string): boolean;
+    setToggleGroup(toggleGroup: Adw.ToggleGroup): void;
+    addToGroup(): void;
+    removeFromGroup(): void;
+    updateProps(oldProps: ToggleProps | null, newProps: ToggleProps): void;
+    unmount(): void;
+    private applyProps;
+}

package/dist/nodes/toggle.js

@@ -0,0 +1,70 @@
+import * as Adw from "@gtkx/ffi/adw";
+import { registerNodeClass } from "../registry.js";
+import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
+import { VirtualNode } from "./virtual.js";
+export class ToggleNode extends VirtualNode {
+    static priority = 1;
+    toggleGroup;
+    toggle;
+    static matches(type) {
+        return type === "Toggle";
+    }
+    setToggleGroup(toggleGroup) {
+        this.toggleGroup = toggleGroup;
+    }
+    addToGroup() {
+        if (!this.toggleGroup || this.toggle)
+            return;
+        const toggleGroup = this.toggleGroup;
+        this.toggle = new Adw.Toggle();
+        scheduleAfterCommit(() => {
+            if (this.toggle) {
+                this.applyProps(this.props);
+                toggleGroup.add(this.toggle);
+            }
+        });
+    }
+    removeFromGroup() {
+        if (!this.toggleGroup || !this.toggle)
+            return;
+        const toggleGroup = this.toggleGroup;
+        const toggle = this.toggle;
+        this.toggle = undefined;
+        scheduleAfterCommit(() => {
+            toggleGroup.remove(toggle);
+        }, CommitPriority.HIGH);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        if (oldProps && this.toggle) {
+            this.applyProps(newProps);
+        }
+    }
+    unmount() {
+        this.removeFromGroup();
+        super.unmount();
+    }
+    applyProps(props) {
+        if (!this.toggle)
+            return;
+        if (props.id !== undefined && props.id !== this.toggle.getName()) {
+            this.toggle.setName(props.id);
+        }
+        if (props.label !== undefined && props.label !== this.toggle.getLabel()) {
+            this.toggle.setLabel(props.label);
+        }
+        if (props.iconName !== undefined && props.iconName !== this.toggle.getIconName()) {
+            this.toggle.setIconName(props.iconName);
+        }
+        if (props.tooltip !== undefined && props.tooltip !== this.toggle.getTooltip()) {
+            this.toggle.setTooltip(props.tooltip);
+        }
+        if (props.enabled !== undefined && props.enabled !== this.toggle.getEnabled()) {
+            this.toggle.setEnabled(props.enabled);
+        }
+        if (props.useUnderline !== undefined && props.useUnderline !== this.toggle.getUseUnderline()) {
+            this.toggle.setUseUnderline(props.useUnderline);
+        }
+    }
+}
+registerNodeClass(ToggleNode);

package/dist/nodes/toolbar-child.js

@@ -1,10 +1,10 @@
-import { isObjectEqual } from "@gtkx/ffi";
+import { batch, isObjectEqual } from "@gtkx/ffi";
 import { registerNodeClass } from "../registry.js";
 import { SlotNode } from "./slot.js";
 class ToolbarChildNode extends SlotNode {
     static priority = 1;
     static matches(type) {
-        return type === "Toolbar.Top" || type === "Toolbar.Bottom";
+        return type === "ToolbarTop" || type === "ToolbarBottom";
     }
     getToolbar() {
         if (!this.parent) {
@@ -13,25 +13,27 @@ class ToolbarChildNode extends SlotNode {
         return this.parent;
     }
     getPosition() {
-        return this.typeName === "Toolbar.Top" ? "top" : "bottom";
+        return this.typeName === "ToolbarTop" ? "top" : "bottom";
     }
     onChildChange(oldChild) {
         const toolbar = this.getToolbar();
-        if (oldChild) {
-            const parent = oldChild.getParent();
-            if (parent && isObjectEqual(parent, toolbar)) {
-                toolbar.remove(oldChild);
+        batch(() => {
+            if (oldChild) {
+                const parent = oldChild.getParent();
+                if (parent && isObjectEqual(parent, toolbar)) {
+                    toolbar.remove(oldChild);
+                }
             }
-        }
-        if (this.child) {
-            const position = this.getPosition();
-            if (position === "top") {
-                toolbar.addTopBar(this.child);
-            }
-            else {
-                toolbar.addBottomBar(this.child);
+            if (this.child) {
+                const position = this.getPosition();
+                if (position === "top") {
+                    toolbar.addTopBar(this.child);
+                }
+                else {
+                    toolbar.addBottomBar(this.child);
+                }
             }
-        }
+        });
     }
 }
 registerNodeClass(ToolbarChildNode);

package/dist/nodes/tree-list-view.js

@@ -5,7 +5,8 @@ import { filterProps } from "./internal/utils.js";
 import { TreeList } from "./models/tree-list.js";
 import { TreeListItemNode } from "./tree-list-item.js";
 import { WidgetNode } from "./widget.js";
-const PROP_NAMES = ["renderItem", "autoexpand", "selectionMode", "selected", "onSelectionChanged"];
+const RENDERER_PROP_NAMES = ["renderItem", "estimatedItemHeight"];
+const PROP_NAMES = [...RENDERER_PROP_NAMES, "autoexpand", "selectionMode", "selected", "onSelectionChanged"];
 class TreeListViewNode extends WidgetNode {
     static priority = 1;
     itemRenderer;
@@ -19,7 +20,12 @@ class TreeListViewNode extends WidgetNode {
     constructor(typeName, props, container, rootContainer) {
         const listView = container ?? new Gtk.ListView();
         super(typeName, props, listView, rootContainer);
-        this.treeList = new TreeList(props.autoexpand, props.selectionMode);
+        this.treeList = new TreeList({
+            autoexpand: props.autoexpand,
+            selectionMode: props.selectionMode,
+            selected: props.selected,
+            onSelectionChanged: props.onSelectionChanged,
+        });
         this.itemRenderer = new TreeListItemRenderer();
         this.itemRenderer.setStore(this.treeList.getStore());
         this.container.setFactory(this.itemRenderer.getFactory());
@@ -30,19 +36,19 @@ class TreeListViewNode extends WidgetNode {
     }
     appendChild(child) {
         if (!(child instanceof TreeListItemNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to 'TreeListView': expected TreeListItem`);
+            throw new Error(`Cannot append '${child.typeName}' to 'TreeListView': expected x.TreeListItem`);
         }
         this.treeList.appendChild(child);
     }
     insertBefore(child, before) {
         if (!(child instanceof TreeListItemNode) || !(before instanceof TreeListItemNode)) {
-            throw new Error(`Cannot insert '${child.typeName}' to 'TreeListView': expected TreeListItem`);
+            throw new Error(`Cannot insert '${child.typeName}' into 'TreeListView': expected x.TreeListItem`);
         }
         this.treeList.insertBefore(child, before);
     }
     removeChild(child) {
         if (!(child instanceof TreeListItemNode)) {
-            throw new Error(`Cannot remove '${child.typeName}' from 'TreeListView': expected TreeListItem`);
+            throw new Error(`Cannot remove '${child.typeName}' from 'TreeListView': expected x.TreeListItem`);
         }
         this.treeList.removeChild(child);
     }
@@ -50,8 +56,11 @@ class TreeListViewNode extends WidgetNode {
         if (!oldProps || oldProps.renderItem !== newProps.renderItem) {
             this.itemRenderer.setRenderFn(newProps.renderItem);
         }
-        this.treeList.updateProps(filterProps(oldProps ?? {}, ["renderItem"]), filterProps(newProps, ["renderItem"]));
-        super.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
+        if (!oldProps || oldProps.estimatedItemHeight !== newProps.estimatedItemHeight) {
+            this.itemRenderer.setEstimatedItemHeight(newProps.estimatedItemHeight);
+        }
+        this.treeList.updateProps(oldProps ? filterProps(oldProps, RENDERER_PROP_NAMES) : null, filterProps(newProps, RENDERER_PROP_NAMES));
+        super.updateProps(oldProps ? filterProps(oldProps, PROP_NAMES) : null, filterProps(newProps, PROP_NAMES));
     }
 }
 registerNodeClass(TreeListViewNode);

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

@@ -0,0 +1,18 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../node.js";
+import { VirtualNode } from "./virtual.js";
+type ChildParentWidget = Gtk.Widget & {
+    remove(child: Gtk.Widget): void;
+};
+export declare abstract class VirtualChildNode<P extends ChildParentWidget = ChildParentWidget> extends VirtualNode {
+    protected parent?: P;
+    protected children: Gtk.Widget[];
+    setParent(newParent?: P): void;
+    protected abstract getPositionLabel(): string;
+    protected abstract attachChild(parent: P, widget: Gtk.Widget): void;
+    unmount(): void;
+    appendChild(child: Node): void;
+    insertBefore(child: Node): void;
+    removeChild(child: Node): void;
+}
+export {};