@gtkx/react 0.15.0 → 0.16.0

package/dist/nodes/widget.js

@@ -1,123 +1,81 @@
-import { batch, isObjectEqual, NativeObject } from "@gtkx/ffi";
-import * as Gdk from "@gtkx/ffi/gdk";
+import { getNativeObject, isObjectEqual } from "@gtkx/ffi";
+import { ObjectClass, ParamSpecString, Type, TypeInstance, typeClassRef, typeFromName, typeFundamental, typeNameFromInstance, } from "@gtkx/ffi/gobject";
 import * as Gtk from "@gtkx/ffi/gtk";
 import { CONSTRUCTOR_PROPS } from "../generated/internal.js";
 import { Node } from "../node.js";
 import { registerNodeClass } from "../registry.js";
-import { AdjustmentNode } from "./adjustment.js";
-import { EVENT_CONTROLLER_PROPS } from "./internal/constants.js";
-import { hasSingleContent, isAddable, isAdjustable, isAppendable, isEditable, isInsertable, isRemovable, isReorderable, isSingleChild, } from "./internal/predicates.js";
-import { signalStore } from "./internal/signal-store.js";
-import { filterProps, isContainerType, resolvePropMeta, resolveSignal } from "./internal/utils.js";
-import { ShortcutControllerNode } from "./shortcut-controller.js";
-import { SlotNode } from "./slot.js";
-const PROPS = ["children", "widthRequest", "heightRequest", "grabFocus"];
+import { getAttachmentStrategy, attachChild as performAttachment, detachChild as performDetachment, } from "./internal/child-attachment.js";
+import { isAttachable, isEditable, isInsertable, isRemovable, isReorderable, } from "./internal/predicates.js";
+import { filterProps, matchesAnyClass, propNameToSignalName, resolvePropMeta, resolveSignal, } from "./internal/utils.js";
+const EXCLUDED_PROPS = ["children", "widthRequest", "heightRequest", "grabFocus"];
+function findProperty(obj, key) {
+    if (!obj.handle)
+        return null;
+    const propertyName = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+    const typeInstance = getNativeObject(obj.handle, TypeInstance);
+    const typeName = typeNameFromInstance(typeInstance);
+    const gtype = typeFromName(typeName);
+    const typeClass = typeClassRef(gtype);
+    const objectClass = getNativeObject(typeClass.handle, ObjectClass);
+    return objectClass.findProperty(propertyName) ?? null;
+}
 export class WidgetNode extends Node {
     static priority = 3;
-    motionController;
-    clickController;
-    keyController;
-    scrollController;
-    dragSourceController;
-    dropTargetController;
-    gestureDragController;
-    adjustmentChild;
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.Widget, containerOrClass);
+        return matchesAnyClass([Gtk.Widget], containerOrClass);
     }
-    static createContainer(props, containerClass) {
+    static createContainer(props, containerClass, _rootContainer) {
         const WidgetClass = containerClass;
         const typeName = WidgetClass.glibTypeName;
         const args = (CONSTRUCTOR_PROPS[typeName] ?? []).map((name) => props[name]);
         return new WidgetClass(...args);
     }
     appendChild(child) {
-        if (child instanceof ShortcutControllerNode) {
-            child.setParent(this.container);
-            return;
-        }
-        if (child instanceof SlotNode) {
-            child.setParent(this.container);
-            return;
-        }
-        if (child instanceof AdjustmentNode) {
-            if (!isAdjustable(this.container)) {
-                throw new Error(`Cannot add Adjustment to '${this.typeName}': widget does not support adjustments`);
-            }
-            if (this.adjustmentChild) {
-                throw new Error(`${this.typeName} can only have one Adjustment child`);
-            }
-            this.adjustmentChild = child;
-            child.setWidget(this.container);
+        if (isAttachable(child) && child.canBeChildOf(this)) {
+            child.attachTo(this);
             return;
         }
         if (!(child instanceof WidgetNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to 'Widget': expected WidgetNode child`);
+            throw new Error(`Cannot append '${child.typeName}' to 'Widget': expected Widget`);
         }
         if (child.container instanceof Gtk.Window) {
             throw new Error(`Cannot append 'Window' to '${this.typeName}': windows must be top-level containers`);
         }
-        batch(() => this.attachChild(child));
+        this.attachChild(child);
     }
     removeChild(child) {
-        if (child instanceof ShortcutControllerNode) {
-            child.setParent(undefined);
-            return;
-        }
-        if (child instanceof SlotNode) {
-            return;
-        }
-        if (child instanceof AdjustmentNode) {
-            if (this.adjustmentChild === child) {
-                this.adjustmentChild = undefined;
-            }
+        if (isAttachable(child) && child.canBeChildOf(this)) {
+            child.detachFrom(this);
             return;
         }
         if (!(child instanceof WidgetNode)) {
-            throw new Error(`Cannot remove '${child.typeName}' from 'Widget': expected WidgetNode child`);
+            throw new Error(`Cannot remove '${child.typeName}' from 'Widget': expected Widget`);
         }
         if (child.container instanceof Gtk.Window) {
             throw new Error(`Cannot remove 'Window' from '${this.typeName}': windows must be top-level containers`);
         }
-        batch(() => this.detachChild(child));
+        this.detachChild(child);
     }
     insertBefore(child, before) {
-        if (child instanceof ShortcutControllerNode) {
-            child.setParent(this.container);
-            return;
-        }
-        if (child instanceof SlotNode) {
-            child.setParent(this.container);
-            return;
-        }
-        if (child instanceof AdjustmentNode) {
-            if (!isAdjustable(this.container)) {
-                throw new Error(`Cannot add Adjustment to '${this.typeName}': widget does not support adjustments`);
-            }
-            if (this.adjustmentChild) {
-                throw new Error(`${this.typeName} can only have one Adjustment child`);
-            }
-            this.adjustmentChild = child;
-            child.setWidget(this.container);
+        if (isAttachable(child) && child.canBeChildOf(this)) {
+            child.attachTo(this);
             return;
         }
         if (!(child instanceof WidgetNode) || !(before instanceof WidgetNode)) {
-            throw new Error(`Cannot insert '${child.typeName}' before '${before.typeName}': expected WidgetNode children`);
+            throw new Error(`Cannot insert '${child.typeName}' into '${this.typeName}': expected Widget`);
         }
         if (child.container instanceof Gtk.Window) {
             throw new Error(`Cannot insert 'Window' into '${this.typeName}': windows must be top-level containers`);
         }
-        batch(() => {
-            if (isReorderable(this.container)) {
-                this.insertBeforeReorderable(this.container, child, before);
-            }
-            else if (isInsertable(this.container)) {
-                this.insertBeforeInsertable(this.container, child, before);
-            }
-            else {
-                this.appendChild(child);
-            }
-        });
+        if (isReorderable(this.container)) {
+            this.insertBeforeReorderable(this.container, child, before);
+        }
+        else if (isInsertable(this.container)) {
+            this.insertBeforeInsertable(this.container, child, before);
+        }
+        else {
+            this.appendChild(child);
+        }
     }
     insertBeforeReorderable(container, child, before) {
         const previousSibling = this.findPreviousSibling(before);
@@ -137,11 +95,14 @@ export class WidgetNode extends Node {
         container.insert(child.container, position);
     }
     updateProps(oldProps, newProps) {
+        if (!this.container) {
+            throw new Error(`WidgetNode.updateProps: container is undefined for ${this.typeName}`);
+        }
         this.updateSizeRequest(oldProps, newProps);
         this.updateGrabFocus(oldProps, newProps);
         const propNames = new Set([
-            ...Object.keys(filterProps(oldProps ?? {}, PROPS)),
-            ...Object.keys(filterProps(newProps ?? {}, PROPS)),
+            ...Object.keys(filterProps(oldProps ?? {}, EXCLUDED_PROPS)),
+            ...Object.keys(filterProps(newProps ?? {}, EXCLUDED_PROPS)),
         ]);
         const pendingSignals = [];
         const pendingProperties = [];
@@ -150,40 +111,28 @@ export class WidgetNode extends Node {
             const newValue = newProps[name];
             if (oldValue === newValue)
                 continue;
-            if (EVENT_CONTROLLER_PROPS.has(name)) {
-                pendingSignals.push({ name, newValue });
-                continue;
-            }
-            if (name === "onNotify") {
-                pendingSignals.push({ name, newValue });
-                continue;
-            }
-            const signalName = this.propNameToSignalName(name);
+            const signalName = propNameToSignalName(name);
             if (resolveSignal(this.container, signalName)) {
                 pendingSignals.push({ name, newValue });
             }
             else if (newValue !== undefined) {
                 pendingProperties.push({ name, oldValue, newValue });
             }
+            else if (oldValue !== undefined) {
+                const defaultValue = this.getPropertyDefaultValue(name);
+                if (defaultValue !== undefined) {
+                    pendingProperties.push({ name, oldValue, newValue: defaultValue });
+                }
+            }
         }
         for (const { name, newValue } of pendingSignals) {
-            if (EVENT_CONTROLLER_PROPS.has(name)) {
-                this.updateEventControllerProp(name, newValue ?? null);
-            }
-            else if (name === "onNotify") {
-                this.updateNotifyHandler(newValue ?? null);
-            }
-            else {
-                const signalName = this.propNameToSignalName(name);
-                const handler = typeof newValue === "function" ? newValue : undefined;
-                signalStore.set(this, this.container, signalName, handler);
-            }
+            const signalName = propNameToSignalName(name);
+            const handler = typeof newValue === "function" ? newValue : undefined;
+            this.signalStore.set(this, this.container, signalName, handler);
         }
         for (const { name, oldValue, newValue } of pendingProperties) {
-            const isEditableText = name === "text" && isEditable(this.container);
-            if (isEditableText && oldValue !== undefined) {
-                const currentValue = this.getProperty(name);
-                if (oldValue !== currentValue) {
+            if (name === "text" && oldValue !== undefined && isEditable(this.container)) {
+                if (oldValue !== this.container.getText()) {
                     continue;
                 }
             }
@@ -206,157 +155,39 @@ export class WidgetNode extends Node {
             this.container.grabFocus();
         }
     }
-    updateEventControllerProp(propName, handlerOrValue) {
-        const wrappedHandler = typeof handlerOrValue === "function"
-            ? (_self, ...args) => handlerOrValue(...args)
-            : undefined;
-        switch (propName) {
-            case "onEnter":
-            case "onLeave":
-            case "onMotion": {
-                if (!this.motionController) {
-                    this.motionController = new Gtk.EventControllerMotion();
-                    this.container.addController(this.motionController);
-                }
-                const signalName = propName === "onEnter" ? "enter" : propName === "onLeave" ? "leave" : "motion";
-                signalStore.set(this, this.motionController, signalName, wrappedHandler);
-                break;
-            }
-            case "onPressed":
-            case "onReleased": {
-                if (!this.clickController) {
-                    this.clickController = new Gtk.GestureClick();
-                    this.container.addController(this.clickController);
-                }
-                const signalName = propName === "onPressed" ? "pressed" : "released";
-                signalStore.set(this, this.clickController, signalName, wrappedHandler);
-                break;
-            }
-            case "onKeyPressed":
-            case "onKeyReleased": {
-                if (!this.keyController) {
-                    this.keyController = new Gtk.EventControllerKey();
-                    this.container.addController(this.keyController);
-                }
-                const signalName = propName === "onKeyPressed" ? "key-pressed" : "key-released";
-                signalStore.set(this, this.keyController, signalName, wrappedHandler);
-                break;
-            }
-            case "onScroll": {
-                if (!this.scrollController) {
-                    this.scrollController = new Gtk.EventControllerScroll(Gtk.EventControllerScrollFlags.BOTH_AXES);
-                    this.container.addController(this.scrollController);
-                }
-                signalStore.set(this, this.scrollController, "scroll", wrappedHandler);
-                break;
-            }
-            case "onDragPrepare":
-            case "onDragBegin":
-            case "onDragEnd":
-            case "onDragCancel":
-            case "dragActions": {
-                const dragSource = this.ensureDragSource();
-                if (propName === "dragActions") {
-                    dragSource.setActions(handlerOrValue ?? Gdk.DragAction.COPY);
-                }
-                else {
-                    const signalName = propName === "onDragPrepare"
-                        ? "prepare"
-                        : propName === "onDragBegin"
-                            ? "drag-begin"
-                            : propName === "onDragEnd"
-                                ? "drag-end"
-                                : "drag-cancel";
-                    signalStore.set(this, dragSource, signalName, wrappedHandler);
-                }
-                break;
-            }
-            case "onDrop":
-            case "onDropEnter":
-            case "onDropLeave":
-            case "onDropMotion":
-            case "dropActions":
-            case "dropTypes": {
-                const dropTarget = this.ensureDropTarget();
-                if (propName === "dropActions") {
-                    dropTarget.setActions(handlerOrValue ?? Gdk.DragAction.COPY);
-                }
-                else if (propName === "dropTypes") {
-                    const types = handlerOrValue ?? [];
-                    dropTarget.setGtypes(types.length, types);
-                }
-                else {
-                    const signalName = propName === "onDrop"
-                        ? "drop"
-                        : propName === "onDropEnter"
-                            ? "enter"
-                            : propName === "onDropLeave"
-                                ? "leave"
-                                : "motion";
-                    signalStore.set(this, dropTarget, signalName, wrappedHandler);
-                }
-                break;
-            }
-            case "onGestureDragBegin":
-            case "onGestureDragUpdate":
-            case "onGestureDragEnd": {
-                const gestureDrag = this.ensureGestureDrag();
-                const signalName = propName === "onGestureDragBegin"
-                    ? "drag-begin"
-                    : propName === "onGestureDragUpdate"
-                        ? "drag-update"
-                        : "drag-end";
-                signalStore.set(this, gestureDrag, signalName, wrappedHandler);
-                break;
-            }
-        }
-    }
-    ensureDragSource() {
-        if (!this.dragSourceController) {
-            this.dragSourceController = new Gtk.DragSource();
-            this.dragSourceController.setActions(Gdk.DragAction.COPY);
-            this.container.addController(this.dragSourceController);
-        }
-        return this.dragSourceController;
-    }
-    ensureDropTarget() {
-        if (!this.dropTargetController) {
-            this.dropTargetController = new Gtk.DropTarget(0, Gdk.DragAction.COPY);
-            this.container.addController(this.dropTargetController);
-        }
-        return this.dropTargetController;
-    }
-    ensureGestureDrag() {
-        if (!this.gestureDragController) {
-            this.gestureDragController = new Gtk.GestureDrag();
-            this.container.addController(this.gestureDragController);
-        }
-        return this.gestureDragController;
-    }
-    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)
-            .replace(/([A-Z])/g, "-$1")
-            .toLowerCase()
-            .replace(/^-/, "");
-    }
-    getProperty(key) {
-        const propMeta = resolvePropMeta(this.container, key);
-        if (!propMeta)
+    getPropertyDefaultValue(key) {
+        if (!resolvePropMeta(this.container, key))
             return undefined;
-        const [getterName] = propMeta;
-        const getter = getterName ? this.container[getterName] : undefined;
-        if (getter && typeof getter === "function") {
-            return getter.call(this.container);
-        }
+        const pspec = findProperty(this.container, key);
+        if (!pspec)
+            return undefined;
+        const value = pspec.getDefaultValue();
+        const gtype = value.getType();
+        const fundamental = typeFundamental(gtype);
+        if (fundamental === Type.BOOLEAN)
+            return value.getBoolean();
+        if (fundamental === Type.INT)
+            return value.getInt();
+        if (fundamental === Type.UINT)
+            return value.getUint();
+        if (fundamental === Type.LONG)
+            return value.getLong();
+        if (fundamental === Type.ULONG)
+            return value.getUlong();
+        if (fundamental === Type.INT64)
+            return value.getInt64();
+        if (fundamental === Type.UINT64)
+            return value.getUint64();
+        if (fundamental === Type.FLOAT)
+            return value.getFloat();
+        if (fundamental === Type.DOUBLE)
+            return value.getDouble();
+        if (fundamental === Type.STRING)
+            return value.getString();
+        if (fundamental === Type.ENUM)
+            return value.getEnum();
+        if (fundamental === Type.FLAGS)
+            return value.getFlags();
         return undefined;
     }
     setProperty(key, value) {
@@ -365,21 +196,17 @@ export class WidgetNode extends Node {
             return;
         const [getterName, setterName] = propMeta;
         const setter = this.container[setterName];
-        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 &&
-                value instanceof NativeObject &&
-                isObjectEqual(currentValue, value)) {
-                return;
+        if (!setter || typeof setter !== "function")
+            return;
+        if (getterName && findProperty(this.container, key) instanceof ParamSpecString) {
+            const getter = this.container[getterName];
+            if (getter && typeof getter === "function") {
+                const currentValue = getter.call(this.container);
+                if (currentValue === value)
+                    return;
             }
         }
-        if (setter && typeof setter === "function") {
-            setter.call(this.container, value);
-        }
+        setter.call(this.container, value);
     }
     detachChildFromParent(child) {
         const currentParent = child.container.getParent();
@@ -388,37 +215,21 @@ export class WidgetNode extends Node {
         }
     }
     attachChild(child) {
-        if (isAppendable(this.container)) {
-            this.detachChildFromParent(child);
-            this.container.append(child.container);
+        const strategy = getAttachmentStrategy(this.container);
+        if (!strategy) {
+            throw new Error(`Cannot append '${child.typeName}' to '${this.container.constructor.name}': container does not support children`);
         }
-        else if (isAddable(this.container)) {
+        if (strategy.type === "appendable" || strategy.type === "addable") {
             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`);
         }
+        performAttachment(child.container, strategy);
     }
     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 {
+        const strategy = getAttachmentStrategy(this.container);
+        if (!strategy) {
             throw new Error(`Cannot remove '${child.typeName}' from '${this.container.constructor.name}': container does not support child removal`);
         }
+        performDetachment(child.container, strategy);
     }
     findPreviousSibling(before) {
         let beforeChild = this.container.getFirstChild();

package/dist/nodes/window.d.ts

@@ -2,22 +2,28 @@ import * as Gtk from "@gtkx/ffi/gtk";
 import type { Node } from "../node.js";
 import type { Container, ContainerClass, Props } from "../types.js";
 import { WidgetNode } from "./widget.js";
-type WindowProps = Props & {
+type CreditSection = {
+    name: string;
+    people: string[];
+};
+export type WindowProps = Props & {
     defaultWidth?: number;
     defaultHeight?: number;
     onClose?: () => void;
+    creditSections?: CreditSection[];
 };
 export declare class WindowNode extends WidgetNode<Gtk.Window, WindowProps> {
     static priority: number;
     private menu;
     static matches(_type: string, containerOrClass?: Container | ContainerClass | null): boolean;
-    static createContainer(props: Props, containerClass: typeof Gtk.Window, rootContainer?: Container): Gtk.Window;
-    constructor(typeName: string, props: WindowProps, container: Gtk.Window, rootContainer?: Container);
+    static createContainer(props: Props, containerClass: typeof Gtk.Window, rootContainer: Container | undefined): Gtk.Window;
+    constructor(typeName: string, props: WindowProps, container: Gtk.Window, rootContainer: Container);
     appendChild(child: Node): void;
     removeChild(child: Node): void;
     insertBefore(child: Node, before: Node): void;
     mount(): void;
     unmount(): void;
     updateProps(oldProps: WindowProps | null, newProps: WindowProps): void;
+    protected applyOwnProps(oldProps: WindowProps | null, newProps: WindowProps): void;
 }
 export {};

package/dist/nodes/window.js

@@ -1,25 +1,25 @@
 import * as Adw from "@gtkx/ffi/adw";
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
-import { signalStore } from "./internal/signal-store.js";
-import { filterProps, isContainerType } from "./internal/utils.js";
-import { Menu } from "./models/menu.js";
+import { DialogNode } from "./dialog.js";
+import { filterProps, hasChanged, matchesAnyClass } from "./internal/utils.js";
+import { MenuModel } from "./models/menu.js";
 import { WidgetNode } from "./widget.js";
-const PROPS = ["defaultWidth", "defaultHeight", "onClose"];
+const OWN_PROPS = ["defaultWidth", "defaultHeight", "onClose"];
 export class WindowNode extends WidgetNode {
     static priority = 1;
     menu;
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.Window, containerOrClass);
+        return matchesAnyClass([Gtk.Window], containerOrClass);
     }
     static createContainer(props, containerClass, rootContainer) {
         const WindowClass = containerClass;
-        if (isContainerType(Gtk.ApplicationWindow, WindowClass) ||
-            isContainerType(Adw.ApplicationWindow, WindowClass)) {
+        if (matchesAnyClass([Gtk.ApplicationWindow], WindowClass) ||
+            matchesAnyClass([Adw.ApplicationWindow], WindowClass)) {
             if (!(rootContainer instanceof Gtk.Application)) {
                 throw new Error("Expected ApplicationWindow to be created within Application");
             }
-            if (isContainerType(Adw.ApplicationWindow, WindowClass)) {
+            if (matchesAnyClass([Adw.ApplicationWindow], WindowClass)) {
                 return new Adw.ApplicationWindow(rootContainer);
             }
             return new Gtk.ApplicationWindow(rootContainer);
@@ -30,13 +30,22 @@ export class WindowNode extends WidgetNode {
         super(typeName, props, container, rootContainer);
         const application = rootContainer instanceof Gtk.Application ? rootContainer : undefined;
         const actionMap = container instanceof Gtk.ApplicationWindow ? container : undefined;
-        this.menu = new Menu("root", {}, actionMap, application);
+        this.menu = new MenuModel("root", {}, rootContainer, actionMap, application);
+        if (container instanceof Gtk.AboutDialog && props.creditSections) {
+            for (const section of props.creditSections) {
+                container.addCreditSection(section.name, section.people);
+            }
+        }
     }
     appendChild(child) {
         if (child.container instanceof Gtk.Window) {
             child.container.setTransientFor(this.container);
             return;
         }
+        if (child instanceof DialogNode) {
+            child.parent = this.container;
+            return;
+        }
         this.menu.appendChild(child);
         super.appendChild(child);
     }
@@ -45,6 +54,10 @@ export class WindowNode extends WidgetNode {
             child.container.setTransientFor(null);
             return;
         }
+        if (child instanceof DialogNode) {
+            child.parent = null;
+            return;
+        }
         this.menu.removeChild(child);
         super.removeChild(child);
     }
@@ -61,14 +74,16 @@ export class WindowNode extends WidgetNode {
         super.unmount();
     }
     updateProps(oldProps, newProps) {
-        if (!oldProps ||
-            oldProps.defaultWidth !== newProps.defaultWidth ||
-            oldProps.defaultHeight !== newProps.defaultHeight) {
+        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (hasChanged(oldProps, newProps, "defaultWidth") || hasChanged(oldProps, newProps, "defaultHeight")) {
             const width = newProps.defaultWidth ?? -1;
             const height = newProps.defaultHeight ?? -1;
             this.container.setDefaultSize(width, height);
         }
-        if (!oldProps || oldProps.onClose !== newProps.onClose) {
+        if (hasChanged(oldProps, newProps, "onClose")) {
             const userHandler = newProps.onClose;
             const wrappedHandler = userHandler
                 ? () => {
@@ -76,9 +91,8 @@ export class WindowNode extends WidgetNode {
                     return true;
                 }
                 : undefined;
-            signalStore.set(this, this.container, "close-request", wrappedHandler);
+            this.signalStore.set(this, this.container, "close-request", wrappedHandler);
         }
-        super.updateProps(filterProps(oldProps ?? {}, PROPS), filterProps(newProps, PROPS));
     }
 }
 registerNodeClass(WindowNode);

package/dist/registry.d.ts

@@ -1,7 +1,7 @@
 import type { Node } from "./node.js";
 import type { Container, Props } from "./types.js";
 type NodeClass<T = unknown, P = Props> = {
-    new (typeName: string, props: P, container: T, rootContainer?: Container): Node<T, P>;
+    new (typeName: string, props: P, container: T, rootContainer: Container): Node<T, P>;
 } & Omit<typeof Node, "prototype">;
 export declare const NODE_CLASSES: NodeClass[];
 export declare const registerNodeClass: <T, P>(nodeClass: NodeClass<T, P>) => void;