@gtkx/react 0.10.5 → 0.11.1

package/dist/nodes/notebook.js

@@ -1,12 +1,12 @@
-import * as Gtk from "@gtkx/ffi/gtk";
+import { NOTEBOOK_CLASSES } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
-import { isContainerType } from "./internal/utils.js";
+import { matchesAnyClass } from "./internal/utils.js";
 import { NotebookPageNode } from "./notebook-page.js";
 import { WidgetNode } from "./widget.js";
 class NotebookNode extends WidgetNode {
     static priority = 1;
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.Notebook, containerOrClass);
+        return matchesAnyClass(NOTEBOOK_CLASSES, containerOrClass);
     }
     appendChild(child) {
         if (!(child instanceof NotebookPageNode)) {
@@ -26,7 +26,7 @@ class NotebookNode extends WidgetNode {
         if (!(child instanceof NotebookPageNode)) {
             throw new Error(`Cannot remove '${child.typeName}' from 'Notebook': expected Notebook.Page`);
         }
-        child.setPosition(undefined);
+        child.setPosition(null);
     }
 }
 registerNodeClass(NotebookNode);

package/dist/nodes/overlay-child.js

@@ -1,3 +1,4 @@
+import { isObjectEqual } from "@gtkx/ffi";
 import { registerNodeClass } from "../registry.js";
 import { SlotNode } from "./slot.js";
 class OverlayChildNode extends SlotNode {
@@ -15,7 +16,7 @@ class OverlayChildNode extends SlotNode {
         const overlay = this.getOverlay();
         if (oldChild) {
             const parent = oldChild.getParent();
-            if (parent?.equals(overlay)) {
+            if (parent && isObjectEqual(parent, overlay)) {
                 overlay.removeOverlay(oldChild);
             }
         }

package/dist/nodes/pack-child.js

@@ -1,3 +1,4 @@
+import { isObjectEqual } from "@gtkx/ffi";
 import { registerNodeClass } from "../registry.js";
 import { scheduleAfterCommit } from "../scheduler.js";
 import { VirtualNode } from "./virtual.js";
@@ -22,7 +23,7 @@ export class PackChild extends VirtualNode {
             scheduleAfterCommit(() => {
                 for (const widget of childrenToRemove) {
                     const currentParent = widget.getParent();
-                    if (currentParent?.equals(parent)) {
+                    if (currentParent && isObjectEqual(currentParent, parent)) {
                         parent.remove(widget);
                     }
                 }
@@ -65,7 +66,7 @@ export class PackChild extends VirtualNode {
         scheduleAfterCommit(() => {
             if (parent) {
                 const currentParent = widget.getParent();
-                if (currentParent?.equals(parent)) {
+                if (currentParent && isObjectEqual(currentParent, parent)) {
                     parent.remove(widget);
                 }
             }

package/dist/nodes/pack.js

@@ -1,16 +1,12 @@
-import * as Gtk from "@gtkx/ffi/gtk";
+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 { WidgetNode } from "./widget.js";
 class PackNode extends WidgetNode {
     static priority = 0;
     static matches(_type, containerOrClass) {
-        if (!containerOrClass ||
-            (typeof containerOrClass !== "function" && !(containerOrClass instanceof Gtk.Widget))) {
-            return false;
-        }
-        const protoOrInstance = typeof containerOrClass === "function" ? containerOrClass.prototype : containerOrClass;
-        return "packStart" in protoOrInstance && "packEnd" in protoOrInstance && "remove" in protoOrInstance;
+        return matchesInterface(PACK_INTERFACE_METHODS, containerOrClass);
     }
     appendChild(child) {
         if (child instanceof PackChild) {

package/dist/nodes/popover-menu.js

@@ -1,7 +1,8 @@
 import * as Gio from "@gtkx/ffi/gio";
 import * as Gtk from "@gtkx/ffi/gtk";
+import { POPOVER_MENU_CLASSES } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
-import { isContainerType } from "./internal/utils.js";
+import { matchesAnyClass } from "./internal/utils.js";
 import { MenuNode } from "./menu.js";
 import { Menu } from "./models/menu.js";
 import { SlotNode } from "./slot.js";
@@ -11,9 +12,7 @@ class PopoverMenuNode extends WidgetNode {
     static priority = 1;
     menu;
     static matches(_type, containerOrClass) {
-        return (isContainerType(Gtk.PopoverMenu, containerOrClass) ||
-            isContainerType(Gtk.PopoverMenuBar, containerOrClass) ||
-            isContainerType(Gtk.MenuButton, containerOrClass));
+        return matchesAnyClass(POPOVER_MENU_CLASSES, containerOrClass);
     }
     constructor(typeName, props, container, rootContainer) {
         super(typeName, props, container, rootContainer);

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

@@ -1,16 +1,15 @@
-import * as Adw from "@gtkx/ffi/adw";
-import * as Gtk from "@gtkx/ffi/gtk";
+import { DROP_DOWN_CLASSES } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
 import { signalStore } from "./internal/signal-store.js";
 import { SimpleListStore } from "./internal/simple-list-store.js";
-import { filterProps, isContainerType } from "./internal/utils.js";
+import { filterProps, matchesAnyClass } from "./internal/utils.js";
 import { SimpleListItemNode } from "./simple-list-item.js";
 import { WidgetNode } from "./widget.js";
 const PROP_NAMES = ["selectedId", "onSelectionChanged"];
 class SimpleListViewNode extends WidgetNode {
     static priority = -1;
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.DropDown, containerOrClass) || isContainerType(Adw.ComboRow, containerOrClass);
+        return matchesAnyClass(DROP_DOWN_CLASSES, containerOrClass);
     }
     store = new SimpleListStore();
     constructor(typeName, props, container, rootContainer) {
@@ -24,7 +23,7 @@ class SimpleListViewNode extends WidgetNode {
                 ? () => {
                     const selectedIndex = this.container.getSelected();
                     const id = this.store.getIdAtIndex(selectedIndex);
-                    if (id !== undefined) {
+                    if (id !== null) {
                         onSelectionChanged(id);
                     }
                 }
@@ -32,8 +31,8 @@ class SimpleListViewNode extends WidgetNode {
             signalStore.set(this, this.container, "notify::selected", handleSelectionChange);
         }
         if (!oldProps || oldProps.selectedId !== newProps.selectedId) {
-            const index = newProps.selectedId !== undefined ? this.store.getIndexById(newProps.selectedId) : undefined;
-            if (index !== undefined) {
+            const index = newProps.selectedId !== undefined ? this.store.getIndexById(newProps.selectedId) : null;
+            if (index !== null) {
                 this.container.setSelected(index);
             }
         }

package/dist/nodes/slot.d.ts

@@ -15,7 +15,7 @@ export declare class SlotNode<P extends SlotNodeProps = SlotNodeProps> extends V
     getChild(): Gtk.Widget;
     appendChild(child: Node): void;
     removeChild(): void;
-    protected onChildChange(oldChild: Gtk.Widget | undefined): void;
+    protected onChildChange(oldChild: Gtk.Widget | null): void;
     private isDescendantOf;
 }
 export {};

package/dist/nodes/slot.js

@@ -1,7 +1,8 @@
+import { isObjectEqual } from "@gtkx/ffi";
 import { toCamelCase } from "@gtkx/gir";
-import { PROPS } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
 import { scheduleAfterCommit } from "../scheduler.js";
+import { resolvePropMeta } from "./internal/utils.js";
 import { VirtualNode } from "./virtual.js";
 import { WidgetNode } from "./widget.js";
 export class SlotNode extends VirtualNode {
@@ -18,7 +19,7 @@ export class SlotNode extends VirtualNode {
         if (this.parent && this.child) {
             const oldChild = this.child;
             this.child = undefined;
-            this.onChildChange(oldChild);
+            this.onChildChange(oldChild ?? null);
         }
         this.parent = undefined;
         super.unmount();
@@ -50,7 +51,7 @@ export class SlotNode extends VirtualNode {
         this.child = child.container;
         scheduleAfterCommit(() => {
             if (this.parent) {
-                this.onChildChange(oldChild);
+                this.onChildChange(oldChild ?? null);
             }
         });
     }
@@ -61,17 +62,18 @@ export class SlotNode extends VirtualNode {
                 this.child = undefined;
             }
             if (this.parent) {
-                this.onChildChange(oldChild);
+                this.onChildChange(oldChild ?? null);
             }
         });
     }
     onChildChange(oldChild) {
         const parent = this.getParent();
         const parentType = parent.constructor.glibTypeName;
-        const [_, setterName] = PROPS[parentType]?.[this.getId()] ?? [];
-        if (!setterName) {
+        const propMeta = resolvePropMeta(parent, this.getId());
+        if (!propMeta) {
             throw new Error(`Unable to find property for Slot '${this.getId()}' on type '${parentType}'`);
         }
+        const [_, setterName] = propMeta;
         const setter = parent[setterName];
         if (typeof setter !== "function") {
             throw new Error(`Expected setter function for Slot '${this.getId()}' on type '${parentType}'`);
@@ -88,7 +90,7 @@ export class SlotNode extends VirtualNode {
     isDescendantOf(widget, ancestor) {
         let current = widget;
         while (current) {
-            if (current.equals(ancestor)) {
+            if (isObjectEqual(current, ancestor)) {
                 return true;
             }
             current = current.getParent();

package/dist/nodes/stack-page.js

@@ -1,3 +1,4 @@
+import { isObjectEqual } from "@gtkx/ffi";
 import * as Adw from "@gtkx/ffi/adw";
 import { registerNodeClass } from "../registry.js";
 import { SlotNode } from "./slot.js";
@@ -69,7 +70,7 @@ class StackPageNode extends SlotNode {
             return;
         }
         const currentParent = oldChild.getParent();
-        if (currentParent?.equals(parent)) {
+        if (currentParent && isObjectEqual(currentParent, parent)) {
             parent.remove(oldChild);
         }
     }

package/dist/nodes/stack.js

@@ -1,14 +1,13 @@
-import * as Adw from "@gtkx/ffi/adw";
-import * as Gtk from "@gtkx/ffi/gtk";
+import { STACK_CLASSES } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
 import { scheduleAfterCommit } from "../scheduler.js";
-import { filterProps, isContainerType } from "./internal/utils.js";
+import { filterProps, matchesAnyClass } from "./internal/utils.js";
 import { WidgetNode } from "./widget.js";
 const PROPS = ["visibleChildName"];
 class StackNode extends WidgetNode {
     static priority = 1;
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.Stack, containerOrClass) || isContainerType(Adw.ViewStack, containerOrClass);
+        return matchesAnyClass(STACK_CLASSES, containerOrClass);
     }
     updateProps(oldProps, newProps) {
         if (newProps.visibleChildName && this.container.getVisibleChildName() !== newProps.visibleChildName) {

package/dist/nodes/toolbar-child.js

@@ -1,3 +1,4 @@
+import { isObjectEqual } from "@gtkx/ffi";
 import { registerNodeClass } from "../registry.js";
 import { SlotNode } from "./slot.js";
 class ToolbarChildNode extends SlotNode {
@@ -18,7 +19,7 @@ class ToolbarChildNode extends SlotNode {
         const toolbar = this.getToolbar();
         if (oldChild) {
             const parent = oldChild.getParent();
-            if (parent?.equals(toolbar)) {
+            if (parent && isObjectEqual(parent, toolbar)) {
                 toolbar.remove(oldChild);
             }
         }

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

@@ -9,9 +9,9 @@ export declare class TreeListItemNode extends VirtualNode<Props> {
     private parentItemId?;
     private childNodes;
     static matches(type: string): boolean;
-    setStore(store?: TreeStore): void;
-    setParentItemId(parentId?: string): void;
-    getParentItemId(): string | undefined;
+    setStore(store?: TreeStore | null): void;
+    setParentItemId(parentId?: string | null): void;
+    getParentItemId(): string | null;
     appendChild(child: Node): void;
     insertBefore(child: Node, before: Node): void;
     removeChild(child: Node): void;

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

@@ -19,7 +19,7 @@ export class TreeListItemNode extends VirtualNode {
         this.parentItemId = parentId;
     }
     getParentItemId() {
-        return this.parentItemId;
+        return this.parentItemId ?? null;
     }
     appendChild(child) {
         if (!(child instanceof TreeListItemNode)) {
@@ -74,8 +74,8 @@ export class TreeListItemNode extends VirtualNode {
         if (this.store && child.props.id !== undefined) {
             this.store.removeItem(child.props.id, this.props.id);
         }
-        child.setStore(undefined);
-        child.setParentItemId(undefined);
+        child.setStore(null);
+        child.setParentItemId(null);
     }
     updateProps(oldProps, newProps) {
         super.updateProps(oldProps, newProps);

package/dist/nodes/widget.d.ts

@@ -7,14 +7,22 @@ export declare class WidgetNode<T extends Gtk.Widget = Gtk.Widget, P extends Pro
     private clickController?;
     private keyController?;
     private scrollController?;
-    static matches(_type: string, containerOrClass?: Container | ContainerClass): boolean;
-    static createContainer(props: Props, containerClass: typeof Gtk.Widget): Container | undefined;
+    static matches(_type: string, containerOrClass?: Container | ContainerClass | null): boolean;
+    static createContainer(props: Props, containerClass: typeof Gtk.Widget): Container | null;
     appendChild(child: Node): void;
     removeChild(child: Node): void;
     insertBefore(child: Node, before: Node): void;
+    private insertBeforeReorderable;
+    private insertBeforeInsertable;
     updateProps(oldProps: P | null, newProps: P): void;
     private updateEventControllerProp;
+    private updateNotifyHandler;
     private propNameToSignalName;
     private getProperty;
     private setProperty;
+    private detachChildFromParent;
+    private attachChild;
+    private detachChild;
+    private findPreviousSibling;
+    private findInsertPosition;
 }

package/dist/nodes/widget.js

@@ -1,23 +1,13 @@
-import { batch, NativeObject } from "@gtkx/ffi";
+import { batch, isObjectEqual, NativeObject } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
-import { CONSTRUCTOR_PROPS, PROPS, SIGNALS } from "../generated/internal.js";
+import { CONSTRUCTOR_PROPS } from "../generated/internal.js";
 import { Node } from "../node.js";
 import { registerNodeClass } from "../registry.js";
+import { EVENT_CONTROLLER_PROPS } from "./internal/constants.js";
 import { hasSingleContent, isAddable, isAppendable, isEditable, isInsertable, isRemovable, isReorderable, isSingleChild, } from "./internal/predicates.js";
 import { signalStore } from "./internal/signal-store.js";
-import { filterProps, isContainerType } from "./internal/utils.js";
+import { filterProps, isContainerType, resolvePropMeta, resolveSignal } from "./internal/utils.js";
 import { SlotNode } from "./slot.js";
-const EVENT_CONTROLLER_PROPS = new Set([
-    "onEnter",
-    "onLeave",
-    "onMotion",
-    "onPressed",
-    "onReleased",
-    "onKeyPressed",
-    "onKeyReleased",
-    "onScroll",
-    "onNotify",
-]);
 export class WidgetNode extends Node {
     static priority = 3;
     motionController;
@@ -44,31 +34,7 @@ export class WidgetNode extends Node {
         if (child.container instanceof Gtk.Window) {
             throw new Error(`Cannot append 'Window' to '${this.typeName}': windows must be top-level containers`);
         }
-        batch(() => {
-            if (isAppendable(this.container)) {
-                const currentParent = child.container.getParent();
-                if (currentParent !== null && isRemovable(currentParent)) {
-                    currentParent.remove(child.container);
-                }
-                this.container.append(child.container);
-            }
-            else if (isAddable(this.container)) {
-                const currentParent = child.container.getParent();
-                if (currentParent !== null && isRemovable(currentParent)) {
-                    currentParent.remove(child.container);
-                }
-                this.container.add(child.container);
-            }
-            else if (hasSingleContent(this.container)) {
-                this.container.setContent(child.container);
-            }
-            else if (isSingleChild(this.container)) {
-                this.container.setChild(child.container);
-            }
-            else {
-                throw new Error(`Cannot append '${child.typeName}' to '${this.container.constructor.name}': container does not support children`);
-            }
-        });
+        batch(() => this.attachChild(child));
     }
     removeChild(child) {
         if (child instanceof SlotNode) {
@@ -80,20 +46,7 @@ export class WidgetNode extends Node {
         if (child.container instanceof Gtk.Window) {
             throw new Error(`Cannot remove 'Window' from '${this.typeName}': windows must be top-level containers`);
         }
-        batch(() => {
-            if (isRemovable(this.container)) {
-                this.container.remove(child.container);
-            }
-            else if (hasSingleContent(this.container)) {
-                this.container.setContent(undefined);
-            }
-            else if (isSingleChild(this.container)) {
-                this.container.setChild(null);
-            }
-            else {
-                throw new Error(`Cannot remove '${child.typeName}' from '${this.container.constructor.name}': container does not support child removal`);
-            }
-        });
+        batch(() => this.detachChild(child));
     }
     insertBefore(child, before) {
         if (child instanceof SlotNode) {
@@ -108,71 +61,53 @@ export class WidgetNode extends Node {
         }
         batch(() => {
             if (isReorderable(this.container)) {
-                let beforeChild = this.container.getFirstChild();
-                while (beforeChild) {
-                    if (beforeChild.equals(before.container)) {
-                        break;
-                    }
-                    beforeChild = beforeChild.getNextSibling();
-                }
-                if (!beforeChild) {
-                    throw new Error(`Cannot insert '${child.typeName}': 'before' child not found in container`);
-                }
-                const previousSibling = beforeChild.getPrevSibling() ?? undefined;
-                const currentParent = child.container.getParent();
-                const isChildOfThisContainer = currentParent?.equals(this.container);
-                if (isChildOfThisContainer) {
-                    this.container.reorderChildAfter(child.container, previousSibling);
-                }
-                else {
-                    if (currentParent !== null && isRemovable(currentParent)) {
-                        currentParent.remove(child.container);
-                    }
-                    this.container.insertChildAfter(child.container, previousSibling);
-                }
+                this.insertBeforeReorderable(this.container, child, before);
             }
             else if (isInsertable(this.container)) {
-                const currentParent = child.container.getParent();
-                if (currentParent !== null && isRemovable(currentParent)) {
-                    currentParent.remove(child.container);
-                }
-                let position = 0;
-                let currentChild = this.container.getFirstChild();
-                while (currentChild) {
-                    if (currentChild.equals(before.container)) {
-                        break;
-                    }
-                    position++;
-                    currentChild = currentChild.getNextSibling();
-                }
-                if (!currentChild) {
-                    throw new Error(`Cannot insert '${child.typeName}': 'before' child not found in container`);
-                }
-                this.container.insert(child.container, position);
+                this.insertBeforeInsertable(this.container, child, before);
             }
             else {
                 this.appendChild(child);
             }
         });
     }
+    insertBeforeReorderable(container, child, before) {
+        const previousSibling = this.findPreviousSibling(before);
+        const currentParent = child.container.getParent();
+        const isChildOfThisContainer = currentParent && isObjectEqual(currentParent, container);
+        if (isChildOfThisContainer) {
+            container.reorderChildAfter(child.container, previousSibling);
+        }
+        else {
+            this.detachChildFromParent(child);
+            container.insertChildAfter(child.container, previousSibling);
+        }
+    }
+    insertBeforeInsertable(container, child, before) {
+        this.detachChildFromParent(child);
+        const position = this.findInsertPosition(before);
+        container.insert(child.container, position);
+    }
     updateProps(oldProps, newProps) {
         const propNames = new Set([
             ...Object.keys(filterProps(oldProps ?? {}, ["children"])),
             ...Object.keys(filterProps(newProps ?? {}, ["children"])),
         ]);
-        const WidgetClass = this.container.constructor;
-        const signals = SIGNALS[WidgetClass.glibTypeName] || new Set();
         for (const name of propNames) {
             const oldValue = oldProps?.[name];
             const newValue = newProps[name];
             if (oldValue === newValue)
                 continue;
             if (EVENT_CONTROLLER_PROPS.has(name)) {
-                this.updateEventControllerProp(name, newValue);
+                this.updateEventControllerProp(name, newValue ?? null);
+                continue;
+            }
+            if (name === "onNotify") {
+                this.updateNotifyHandler(newValue ?? null);
                 continue;
             }
             const signalName = this.propNameToSignalName(name);
-            if (signals.has(signalName)) {
+            if (resolveSignal(this.container, signalName)) {
                 const handler = typeof newValue === "function" ? newValue : undefined;
                 signalStore.set(this, this.container, signalName, handler);
             }
@@ -229,17 +164,16 @@ export class WidgetNode extends Node {
                 signalStore.set(this, this.scrollController, "scroll", handler);
                 break;
             }
-            case "onNotify": {
-                const wrappedHandler = handler
-                    ? (obj, pspec) => {
-                        handler(obj, pspec.getName());
-                    }
-                    : undefined;
-                signalStore.set(this, this.container, "notify", wrappedHandler);
-                break;
-            }
         }
     }
+    updateNotifyHandler(handler) {
+        const wrappedHandler = handler
+            ? (obj, pspec) => {
+                handler(obj, pspec.getName());
+            }
+            : undefined;
+        signalStore.set(this, this.container, "notify", wrappedHandler);
+    }
     propNameToSignalName(name) {
         return name
             .slice(2)
@@ -248,8 +182,10 @@ export class WidgetNode extends Node {
             .replace(/^-/, "");
     }
     getProperty(key) {
-        const WidgetClass = this.container.constructor;
-        const [getterName] = PROPS[WidgetClass.glibTypeName]?.[key] || [];
+        const propMeta = resolvePropMeta(this.container, key);
+        if (!propMeta)
+            return undefined;
+        const [getterName] = propMeta;
         const getter = getterName ? this.container[getterName] : undefined;
         if (getter && typeof getter === "function") {
             return getter.call(this.container);
@@ -257,16 +193,20 @@ export class WidgetNode extends Node {
         return undefined;
     }
     setProperty(key, value) {
-        const WidgetClass = this.container.constructor;
-        const [getterName, setterName] = PROPS[WidgetClass.glibTypeName]?.[key] || [];
+        const propMeta = resolvePropMeta(this.container, key);
+        if (!propMeta)
+            return;
+        const [getterName, setterName] = propMeta;
         const setter = this.container[setterName];
-        const getter = this.container[getterName];
+        const getter = getterName ? this.container[getterName] : undefined;
         if (getter && typeof getter === "function") {
             const currentValue = getter.call(this.container);
             if (currentValue === value) {
                 return;
             }
-            if (currentValue instanceof NativeObject && currentValue.equals(value)) {
+            if (currentValue instanceof NativeObject &&
+                value instanceof NativeObject &&
+                isObjectEqual(currentValue, value)) {
                 return;
             }
         }
@@ -274,5 +214,66 @@ export class WidgetNode extends Node {
             setter.call(this.container, value);
         }
     }
+    detachChildFromParent(child) {
+        const currentParent = child.container.getParent();
+        if (currentParent !== null && isRemovable(currentParent)) {
+            currentParent.remove(child.container);
+        }
+    }
+    attachChild(child) {
+        if (isAppendable(this.container)) {
+            this.detachChildFromParent(child);
+            this.container.append(child.container);
+        }
+        else if (isAddable(this.container)) {
+            this.detachChildFromParent(child);
+            this.container.add(child.container);
+        }
+        else if (hasSingleContent(this.container)) {
+            this.container.setContent(child.container);
+        }
+        else if (isSingleChild(this.container)) {
+            this.container.setChild(child.container);
+        }
+        else {
+            throw new Error(`Cannot append '${child.typeName}' to '${this.container.constructor.name}': container does not support children`);
+        }
+    }
+    detachChild(child) {
+        if (isRemovable(this.container)) {
+            this.container.remove(child.container);
+        }
+        else if (hasSingleContent(this.container)) {
+            this.container.setContent(null);
+        }
+        else if (isSingleChild(this.container)) {
+            this.container.setChild(null);
+        }
+        else {
+            throw new Error(`Cannot remove '${child.typeName}' from '${this.container.constructor.name}': container does not support child removal`);
+        }
+    }
+    findPreviousSibling(before) {
+        let beforeChild = this.container.getFirstChild();
+        while (beforeChild) {
+            if (isObjectEqual(beforeChild, before.container)) {
+                return beforeChild.getPrevSibling() ?? undefined;
+            }
+            beforeChild = beforeChild.getNextSibling();
+        }
+        throw new Error(`Cannot find 'before' child in container`);
+    }
+    findInsertPosition(before) {
+        let position = 0;
+        let currentChild = this.container.getFirstChild();
+        while (currentChild) {
+            if (isObjectEqual(currentChild, before.container)) {
+                return position;
+            }
+            position++;
+            currentChild = currentChild.getNextSibling();
+        }
+        throw new Error(`Cannot find 'before' child in container`);
+    }
 }
 registerNodeClass(WidgetNode);

package/dist/nodes/window.js

@@ -41,7 +41,7 @@ class WindowNode extends WidgetNode {
     }
     removeChild(child) {
         if (child.container instanceof Gtk.Window) {
-            child.container.setTransientFor(undefined);
+            child.container.setTransientFor(null);
             return;
         }
         this.menu.removeChild(child);