@gtkx/react 0.17.2 → 0.18.0

package/dist/jsx.js

@@ -16,8 +16,8 @@ import { createElement } from "react";
  * </GtkHeaderBar>
  *
  * <GtkDropDown>
- *   <x.SimpleListItem id="opt1" value="Option 1" />
- *   <x.SimpleListItem id="opt2" value="Option 2" />
+ *   <x.ListItem id="opt1" value="Option 1" />
+ *   <x.ListItem id="opt2" value="Option 2" />
  * </GtkDropDown>
  * ```
  */
@@ -97,40 +97,26 @@ export const x = {
      */
     NotebookPageTab: "NotebookPageTab",
     /**
-     * Element type for items in a ListView or GridView.
+     * Element type for items in a GtkListView, GtkGridView, or GtkColumnView.
      *
-     * @example
-     * ```tsx
-     * <x.ListView renderItem={(item) => <GtkLabel label={item.name} />}>
-     *   <x.ListItem id="1" value={{ name: "Item 1" }} />
-     * </x.ListView>
-     * ```
-     */
-    ListItem: "ListItem",
-    /**
-     * Element type for items in a TreeListView.
+     * Items can be nested to create tree hierarchies inside a GtkListView.
      *
      * @example
      * ```tsx
-     * <x.TreeListView renderItem={(item) => <GtkLabel label={item.name} />}>
-     *   <x.TreeListItem id="parent" value={{ name: "Parent" }}>
-     *     <x.TreeListItem id="child" value={{ name: "Child" }} />
-     *   </x.TreeListItem>
-     * </x.TreeListView>
-     * ```
-     */
-    TreeListItem: "TreeListItem",
-    /**
-     * Element type for simple string-based list items.
+     * // Flat list
+     * <GtkListView renderItem={(item) => <GtkLabel label={item.name} />}>
+     *   <x.ListItem id="1" value={{ name: "Item 1" }} />
+     * </GtkListView>
      *
-     * @example
-     * ```tsx
-     * <GtkDropDown>
-     *   <x.SimpleListItem id="opt1" value="Option 1" />
-     * </GtkDropDown>
+     * // Tree list (nested items)
+     * <GtkListView renderItem={(item, row) => <GtkLabel label={item.name} />} autoexpand>
+     *   <x.ListItem id="parent" value={{ name: "Parent" }}>
+     *     <x.ListItem id="child" value={{ name: "Child" }} />
+     *   </x.ListItem>
+     * </GtkListView>
      * ```
      */
-    SimpleListItem: "SimpleListItem",
+    ListItem: "ListItem",
     /**
      * Component for defining columns in a ColumnView (table widget).
      *
@@ -150,124 +136,39 @@ export const x = {
         return createElement("ColumnViewColumn", props);
     },
     /**
-     * Virtualized list component with custom item rendering.
-     *
-     * @example
-     * ```tsx
-     * <x.ListView renderItem={(item) => <GtkLabel label={item?.name ?? ""} />}>
-     *   <x.ListItem id="1" value={{ name: "Apple" }} />
-     * </x.ListView>
-     * ```
-     */
-    ListView(props) {
-        return createElement("GtkListView", props);
-    },
-    /**
-     * Virtualized grid component with custom item rendering.
-     *
-     * @example
-     * ```tsx
-     * <x.GridView renderItem={(item) => <GtkImage iconName={item?.icon ?? ""} />}>
-     *   <x.ListItem id="1" value={{ icon: "folder" }} />
-     * </x.GridView>
-     * ```
-     */
-    GridView(props) {
-        return createElement("GtkGridView", props);
-    },
-    /**
-     * Tree list component with hierarchical data and expand/collapse support.
+     * Type-safe container slot for placing children via parent widget methods.
      *
-     * @example
-     * ```tsx
-     * <x.TreeListView renderItem={(item, row) => <GtkLabel label={item.name} />}>
-     *   <x.TreeListItem id="root" value={{ name: "Root" }}>
-     *     <x.TreeListItem id="child" value={{ name: "Child" }} />
-     *   </x.TreeListItem>
-     * </x.TreeListView>
-     * ```
-     */
-    TreeListView(props) {
-        return createElement("TreeListView", props);
-    },
-    /**
-     * Place child as a prefix (left side) of AdwActionRow, AdwEntryRow, or AdwExpanderRow.
+     * Unlike `x.Slot` (which uses property setters for single-child slots),
+     * `x.ContainerSlot` calls attachment methods that support multiple children
+     * (e.g., `addPrefix()`, `packStart()`, `addTopBar()`).
      *
-     * @example
-     * ```tsx
-     * <AdwActionRow title="Setting">
-     *   <x.ActionRowPrefix>
-     *     <GtkCheckButton />
-     *   </x.ActionRowPrefix>
-     * </AdwActionRow>
-     * ```
-     */
-    ActionRowPrefix: "ActionRowPrefix",
-    /**
-     * Place child as a suffix (right side) of AdwActionRow, AdwEntryRow, or AdwExpanderRow.
+     * The `for` prop provides TypeScript type narrowing for the `id` prop
+     * and is not used at runtime.
      *
      * @example
      * ```tsx
-     * <AdwActionRow title="Setting">
-     *   <x.ActionRowSuffix>
-     *     <GtkButton iconName="go-next-symbolic" />
-     *   </x.ActionRowSuffix>
-     * </AdwActionRow>
-     * ```
-     */
-    ActionRowSuffix: "ActionRowSuffix",
-    /**
-     * Place child at the start (left in LTR) of HeaderBar or ActionBar.
+     * <AdwToolbarView>
+     *   <x.ContainerSlot for={AdwToolbarView} id="addTopBar">
+     *     <AdwHeaderBar />
+     *   </x.ContainerSlot>
+     * </AdwToolbarView>
      *
-     * @example
-     * ```tsx
      * <GtkHeaderBar>
-     *   <x.PackStart>
+     *   <x.ContainerSlot for={GtkHeaderBar} id="packStart">
      *     <GtkButton label="Back" />
-     *   </x.PackStart>
+     *   </x.ContainerSlot>
      * </GtkHeaderBar>
-     * ```
-     */
-    PackStart: "PackStart",
-    /**
-     * Place child at the end (right in LTR) of HeaderBar or ActionBar.
-     *
-     * @example
-     * ```tsx
-     * <GtkHeaderBar>
-     *   <x.PackEnd>
-     *     <GtkMenuButton />
-     *   </x.PackEnd>
-     * </GtkHeaderBar>
-     * ```
-     */
-    PackEnd: "PackEnd",
-    /**
-     * Place toolbar at the top of AdwToolbarView.
      *
-     * @example
-     * ```tsx
-     * <AdwToolbarView>
-     *   <x.ToolbarTop>
-     *     <AdwHeaderBar />
-     *   </x.ToolbarTop>
-     * </AdwToolbarView>
-     * ```
-     */
-    ToolbarTop: "ToolbarTop",
-    /**
-     * Place toolbar at the bottom of AdwToolbarView.
-     *
-     * @example
-     * ```tsx
-     * <AdwToolbarView>
-     *   <x.ToolbarBottom>
-     *     <GtkActionBar />
-     *   </x.ToolbarBottom>
-     * </AdwToolbarView>
+     * <AdwActionRow title="Setting">
+     *   <x.ContainerSlot for={AdwActionRow} id="addPrefix">
+     *     <GtkCheckButton />
+     *   </x.ContainerSlot>
+     * </AdwActionRow>
      * ```
      */
-    ToolbarBottom: "ToolbarBottom",
+    ContainerSlot(props) {
+        return createElement("ContainerSlot", { id: props.id }, props.children);
+    },
     /**
      * Element type for overlay children positioned above the main content.
      *
@@ -391,33 +292,6 @@ export const x = {
      * ```
      */
     AlertDialogResponse: "AlertDialogResponse",
-    /**
-     * Nested rows container for AdwExpanderRow.
-     *
-     * @example
-     * ```tsx
-     * <AdwExpanderRow title="Settings">
-     *   <ExpanderRow.Row>
-     *     <AdwActionRow title="Option 1" />
-     *     <AdwActionRow title="Option 2" />
-     *   </ExpanderRow.Row>
-     * </AdwExpanderRow>
-     * ```
-     */
-    ExpanderRowRow: "ExpanderRowRow",
-    /**
-     * Action widget container for AdwExpanderRow header.
-     *
-     * @example
-     * ```tsx
-     * <AdwExpanderRow title="Group">
-     *   <ExpanderRow.Action>
-     *     <GtkButton iconName="emblem-system-symbolic" />
-     *   </ExpanderRow.Action>
-     * </AdwExpanderRow>
-     * ```
-     */
-    ExpanderRowAction: "ExpanderRowAction",
     /**
      * Type-safe page component for AdwNavigationView or AdwNavigationSplitView.
      *
@@ -446,22 +320,6 @@ export const x = {
      * ```
      */
     NavigationPage: "NavigationPage",
-    /**
-     * Declarative keyboard shortcut controller.
-     *
-     * Attach keyboard shortcuts to a widget. Must contain `x.Shortcut` children.
-     *
-     * @example
-     * ```tsx
-     * <GtkBox>
-     *   <GtkShortcutController scope={Gtk.ShortcutScope.GLOBAL}>
-     *     <x.Shortcut trigger="<Control>f" onActivate={() => setSearchMode(s => !s)} />
-     *     <x.Shortcut trigger="<Control>q" onActivate={quit} />
-     *   </GtkShortcutController>
-     * </GtkBox>
-     * ```
-     */
-    ShortcutController: "GtkShortcutController",
     /**
      * A keyboard shortcut definition.
      *
@@ -483,9 +341,9 @@ export const x = {
      * @example
      * ```tsx
      * <x.Animation
-     *   mode="spring"
      *   initial={{ opacity: 0, scale: 0.9 }}
      *   animate={{ opacity: 1, scale: 1 }}
+     *   transition={{ mode: "spring", damping: 0.8, stiffness: 200 }}
      *   animateOnMount
      * >
      *   <GtkButton label="Animated Button" />

package/dist/metadata.d.ts

@@ -0,0 +1,3 @@
+import type { Container } from "./types.js";
+export declare const resolvePropMeta: (instance: Container, key: string) => [string | null, string] | null;
+export declare const resolveSignal: (instance: Container, propName: string) => string | null;

package/dist/metadata.js

@@ -0,0 +1,26 @@
+import { PROPS, SIGNALS } from "./generated/internal.js";
+const walkPrototypeChain = (instance, lookup) => {
+    // biome-ignore lint/complexity/noBannedTypes: Walking prototype chain requires Function type
+    let current = instance.constructor;
+    while (current) {
+        const typeName = current.glibTypeName;
+        if (typeName) {
+            const result = lookup(typeName);
+            if (result !== null) {
+                return result;
+            }
+        }
+        const prototype = Object.getPrototypeOf(current.prototype);
+        current = prototype?.constructor ?? null;
+        if (current === Object || current === Function) {
+            break;
+        }
+    }
+    return null;
+};
+export const resolvePropMeta = (instance, key) => walkPrototypeChain(instance, (typeName) => PROPS[typeName]?.[key] ?? null);
+export const resolveSignal = (instance, propName) => {
+    if (propName === "onNotify")
+        return "notify";
+    return walkPrototypeChain(instance, (typeName) => SIGNALS[typeName]?.[propName] ?? null);
+};

package/dist/node.d.ts

@@ -1,18 +1,26 @@
 import { type SignalStore } from "./nodes/internal/signal-store.js";
 import type { Container, ContainerClass, Props } from "./types.js";
-export declare class Node<T = unknown, P = Props> {
-    static priority: number;
-    static matches(_type: string, _containerOrClass?: Container | ContainerClass | null): boolean;
+export declare class Node<TContainer = any, TProps = any, TParent extends Node = any, TChild extends Node = any> {
     static createContainer(_props: Props, _containerClass: ContainerClass, _rootContainer?: Container): unknown;
-    container: T;
+    container: TContainer;
+    props: TProps;
     typeName: string;
     signalStore: SignalStore;
-    constructor(typeName: string, _props: P | undefined, container: T, rootContainer: Container);
-    appendChild(_child: Node): void;
-    removeChild(_child: Node): void;
-    insertBefore(_child: Node, _before: Node): void;
-    updateProps(_oldProps: P | null, _newProps: P): void;
-    mount(): void;
-    commitProps(oldProps: P | null, newProps: P): void;
-    unmount(): void;
+    rootContainer: Container;
+    parent: TParent | null;
+    children: TChild[];
+    private childIndices;
+    constructor(typeName: string, props: TProps, container: TContainer, rootContainer: Container);
+    isValidChild(_child: Node): boolean;
+    isValidParent(_parent: Node): boolean;
+    setParent(parent: TParent | null): void;
+    appendInitialChild(child: TChild): void;
+    appendChild(child: TChild): void;
+    removeChild(child: TChild): void;
+    insertBefore(child: TChild, before: TChild): void;
+    private rebuildChildIndices;
+    finalizeInitialChildren(props: TProps): boolean;
+    commitUpdate(_oldProps: TProps | null, newProps: TProps): void;
+    commitMount(): void;
+    detachDeletedInstance(): void;
 }

package/dist/node.js

@@ -1,35 +1,90 @@
 import { getSignalStore } from "./nodes/internal/signal-store.js";
+// biome-ignore lint/suspicious/noExplicitAny: Self-referential type bounds require any
 export class Node {
-    static priority = 0;
-    static matches(_type, _containerOrClass) {
-        return false;
-    }
     static createContainer(_props, _containerClass, _rootContainer) {
         throw new Error("Cannot create container: unsupported node type");
     }
     container;
+    props;
     typeName;
     signalStore;
-    constructor(typeName, _props = {}, container, rootContainer) {
+    rootContainer;
+    parent = null;
+    children = [];
+    childIndices = new Map();
+    constructor(typeName, props, container, rootContainer) {
         this.typeName = typeName;
+        this.props = props;
         this.container = container;
+        this.rootContainer = rootContainer;
         this.signalStore = getSignalStore(rootContainer);
     }
-    appendChild(_child) { }
-    removeChild(_child) { }
-    insertBefore(_child, _before) { }
-    updateProps(_oldProps, _newProps) { }
-    mount() { }
-    commitProps(oldProps, newProps) {
-        this.signalStore.blockAll();
-        try {
-            this.updateProps(oldProps, newProps);
+    isValidChild(_child) {
+        return false;
+    }
+    isValidParent(_parent) {
+        return true;
+    }
+    setParent(parent) {
+        if (parent !== null && !this.isValidParent(parent)) {
+            throw new Error(`Cannot add '${this.typeName}' to '${parent.typeName}'`);
+        }
+        this.parent = parent;
+    }
+    appendInitialChild(child) {
+        this.appendChild(child);
+    }
+    appendChild(child) {
+        if (!this.isValidChild(child)) {
+            throw new Error(`Cannot append '${child.typeName}' to '${this.typeName}'`);
+        }
+        this.childIndices.set(child, this.children.length);
+        this.children.push(child);
+        child.setParent(this);
+    }
+    removeChild(child) {
+        const index = this.childIndices.get(child);
+        if (index !== undefined) {
+            child.setParent(null);
+            this.children.splice(index, 1);
+            this.childIndices.delete(child);
+            this.rebuildChildIndices(index);
+        }
+    }
+    insertBefore(child, before) {
+        const beforeIndex = this.childIndices.get(before);
+        if (beforeIndex === undefined) {
+            throw new Error(`Cannot find 'before' child '${before.typeName}' in '${this.typeName}'`);
         }
-        finally {
-            this.signalStore.unblockAll();
+        const existingIndex = this.childIndices.get(child);
+        if (existingIndex !== undefined) {
+            this.children.splice(existingIndex, 1);
+            const adjustedIndex = existingIndex < beforeIndex ? beforeIndex - 1 : beforeIndex;
+            this.children.splice(adjustedIndex, 0, child);
+            this.rebuildChildIndices(Math.min(existingIndex, adjustedIndex));
+            return;
         }
+        if (!this.isValidChild(child)) {
+            throw new Error(`Cannot insert '${child.typeName}' into '${this.typeName}'`);
+        }
+        this.children.splice(beforeIndex, 0, child);
+        this.rebuildChildIndices(beforeIndex);
+        child.setParent(this);
+    }
+    rebuildChildIndices(fromIndex) {
+        for (let i = fromIndex; i < this.children.length; i++) {
+            this.childIndices.set(this.children[i], i);
+        }
+    }
+    finalizeInitialChildren(props) {
+        this.commitUpdate(null, props);
+        return false;
+    }
+    commitUpdate(_oldProps, newProps) {
+        this.props = newProps;
     }
-    unmount() {
+    commitMount() { }
+    detachDeletedInstance() {
         this.signalStore.clear(this);
     }
 }

package/dist/nodes/adjustable.d.ts

@@ -1,23 +1,10 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import type { Container, ContainerClass, Props } from "../types.js";
-import type { AdjustableWidget } from "./internal/predicates.js";
+import type { AdjustableProps } from "../jsx.js";
+import type { AdjustableWidget } from "../registry.js";
 import { WidgetNode } from "./widget.js";
-type AdjustableProps = Props & {
-    value?: number;
-    lower?: number;
-    upper?: number;
-    stepIncrement?: number;
-    pageIncrement?: number;
-    pageSize?: number;
-    onValueChanged?: ((value: number, self: AdjustableWidget) => void) | null;
-};
 export declare class AdjustableNode<T extends AdjustableWidget = AdjustableWidget> extends WidgetNode<T, AdjustableProps> {
-    static priority: number;
     private adjustment;
-    static matches(_type: string, containerOrClass?: Container | ContainerClass | null): boolean;
-    updateProps(oldProps: AdjustableProps | null, newProps: AdjustableProps): void;
+    commitUpdate(oldProps: AdjustableProps | null, newProps: AdjustableProps): void;
     protected ensureAdjustment(props: AdjustableProps): Gtk.Adjustment;
     protected applyOwnProps(oldProps: AdjustableProps | null, newProps: AdjustableProps): void;
-    private updateValueChangedHandler;
 }
-export {};

package/dist/nodes/adjustable.js

@@ -1,17 +1,11 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { ADJUSTABLE_INTERFACE_METHODS } from "../generated/internal.js";
-import { registerNodeClass } from "../registry.js";
-import { filterProps, hasChanged, matchesInterface } from "./internal/utils.js";
+import { filterProps, hasChanged } from "./internal/props.js";
 import { WidgetNode } from "./widget.js";
 const OWN_PROPS = ["value", "lower", "upper", "stepIncrement", "pageIncrement", "pageSize", "onValueChanged"];
 export class AdjustableNode extends WidgetNode {
-    static priority = 2;
     adjustment = null;
-    static matches(_type, containerOrClass) {
-        return matchesInterface(ADJUSTABLE_INTERFACE_METHODS, containerOrClass);
-    }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
         this.applyOwnProps(oldProps, newProps);
     }
     ensureAdjustment(props) {
@@ -24,7 +18,8 @@ export class AdjustableNode extends WidgetNode {
     applyOwnProps(oldProps, newProps) {
         const adjustment = this.ensureAdjustment(newProps);
         if (hasChanged(oldProps, newProps, "onValueChanged")) {
-            this.updateValueChangedHandler(newProps);
+            const { onValueChanged } = newProps;
+            this.signalStore.set(this, this.container, "value-changed", onValueChanged ? (self) => onValueChanged(self.getValue(), self) : undefined);
         }
         if (!oldProps)
             return;
@@ -47,16 +42,4 @@ export class AdjustableNode extends WidgetNode {
             adjustment.setValue(newProps.value);
         }
     }
-    updateValueChangedHandler(props) {
-        if (!this.adjustment)
-            return;
-        const { onValueChanged } = props;
-        if (onValueChanged) {
-            this.signalStore.set(this, this.container, "value-changed", (self) => onValueChanged(self.getValue(), self));
-        }
-        else {
-            this.signalStore.set(this, this.container, "value-changed", null);
-        }
-    }
 }
-registerNodeClass(AdjustableNode);

package/dist/nodes/alert-dialog-response.d.ts

@@ -1 +1,14 @@
-export {};
+import * as Adw from "@gtkx/ffi/adw";
+import type { AlertDialogResponseProps } from "../jsx.js";
+import type { Node } from "../node.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export declare class AlertDialogResponseNode extends VirtualNode<AlertDialogResponseProps, WidgetNode<Adw.AlertDialog>> {
+    private responseId;
+    isValidParent(parent: Node): boolean;
+    setParent(parent: WidgetNode<Adw.AlertDialog> | null): void;
+    commitUpdate(oldProps: AlertDialogResponseProps | null, newProps: AlertDialogResponseProps): void;
+    detachDeletedInstance(): void;
+    private removeFromDialog;
+    private applyOwnProps;
+}

package/dist/nodes/alert-dialog-response.js

@@ -1,86 +1,60 @@
 import * as Adw from "@gtkx/ffi/adw";
-import { registerNodeClass } from "../registry.js";
-import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
-import { hasChanged } from "./internal/utils.js";
+import { hasChanged } from "./internal/props.js";
 import { VirtualNode } from "./virtual.js";
 import { WidgetNode } from "./widget.js";
-class AlertDialogResponseNode extends VirtualNode {
-    static priority = 1;
-    dialog = null;
+export class AlertDialogResponseNode extends VirtualNode {
     responseId = null;
-    static matches(type) {
-        return type === "AlertDialogResponse";
-    }
-    canBeChildOf(parent) {
+    isValidParent(parent) {
         return parent instanceof WidgetNode && parent.container instanceof Adw.AlertDialog;
     }
-    attachTo(parent) {
-        if (!(parent instanceof WidgetNode) || !(parent.container instanceof Adw.AlertDialog)) {
-            return;
+    setParent(parent) {
+        if (!parent && this.parent) {
+            this.removeFromDialog();
+        }
+        super.setParent(parent);
+        if (parent && !this.responseId) {
+            this.responseId = this.props.id;
+            parent.container.addResponse(this.responseId, this.props.label);
+            this.applyOwnProps(null, this.props);
         }
-        if (this.dialog)
-            return;
-        this.dialog = parent.container;
-        this.responseId = this.props.id;
-        const dialog = this.dialog;
-        const id = this.responseId;
-        const label = this.props.label;
-        scheduleAfterCommit(() => {
-            if (this.dialog) {
-                dialog.addResponse(id, label);
-                this.applyOptionalProps(null, this.props);
-            }
-        }, CommitPriority.NORMAL);
-    }
-    detachFrom(_parent) {
-        this.removeFromDialog();
-    }
-    removeFromDialog() {
-        if (!this.dialog || !this.responseId)
-            return;
-        const dialog = this.dialog;
-        const id = this.responseId;
-        this.dialog = null;
-        this.responseId = null;
-        scheduleAfterCommit(() => {
-            dialog.removeResponse(id);
-        }, CommitPriority.HIGH);
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
-        if (!this.dialog || !this.responseId)
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps, newProps);
+        if (!this.parent || !this.responseId)
             return;
         if (hasChanged(oldProps, newProps, "id")) {
             const oldId = this.responseId;
             const newId = newProps.id;
-            const dialog = this.dialog;
             const label = newProps.label;
+            this.parent.container.removeResponse(oldId);
             this.responseId = newId;
-            scheduleAfterCommit(() => {
-                dialog.removeResponse(oldId);
-                dialog.addResponse(newId, label);
-                this.applyOptionalProps(null, newProps);
-            }, CommitPriority.NORMAL);
+            this.parent.container.addResponse(newId, label);
+            this.applyOwnProps(null, newProps);
             return;
         }
         if (hasChanged(oldProps, newProps, "label")) {
-            this.dialog.setResponseLabel(this.responseId, newProps.label);
+            this.parent.container.setResponseLabel(this.responseId, newProps.label);
         }
-        this.applyOptionalProps(oldProps, newProps);
+        this.applyOwnProps(oldProps, newProps);
+    }
+    detachDeletedInstance() {
+        this.removeFromDialog();
+        super.detachDeletedInstance();
     }
-    applyOptionalProps(oldProps, newProps) {
-        if (!this.dialog || !this.responseId)
+    removeFromDialog() {
+        if (!this.parent || !this.responseId)
             return;
-        if (hasChanged(oldProps, newProps, "appearance") && newProps.appearance !== undefined) {
-            this.dialog.setResponseAppearance(this.responseId, newProps.appearance);
+        this.parent.container.removeResponse(this.responseId);
+        this.responseId = null;
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (!this.parent || !this.responseId)
+            return;
+        if (hasChanged(oldProps, newProps, "appearance")) {
+            this.parent.container.setResponseAppearance(this.responseId, newProps.appearance ?? Adw.ResponseAppearance.DEFAULT);
         }
-        if (hasChanged(oldProps, newProps, "enabled") && newProps.enabled !== undefined) {
-            this.dialog.setResponseEnabled(this.responseId, newProps.enabled);
+        if (hasChanged(oldProps, newProps, "enabled")) {
+            this.parent.container.setResponseEnabled(this.responseId, newProps.enabled ?? true);
         }
     }
-    unmount() {
-        this.removeFromDialog();
-        super.unmount();
-    }
 }
-registerNodeClass(AlertDialogResponseNode);