@gtkx/react 0.19.0 → 0.21.0

package/src/nodes/notebook-page.ts

@@ -81,6 +81,10 @@ export class NotebookPageNode extends VirtualNode<NotebookPageProps, WidgetNode<
     public override detachDeletedInstance(): void {
         const childWidget = this.findContentChild()?.container ?? null;
         if (childWidget && this.parent) {
+            const notebook = this.getParentWidget();
+            if (notebook.getNPages() <= 1) {
+                notebook.setShowTabs(false);
+            }
             this.detachPage(childWidget);
         }
         super.detachDeletedInstance();
@@ -157,11 +161,11 @@ export class NotebookPageNode extends VirtualNode<NotebookPageProps, WidgetNode<
         if (!page) return;
 
         if (this.props.tabExpand !== undefined) {
-            page.setTabExpand(this.props.tabExpand);
+            page.tabExpand = this.props.tabExpand;
         }
 
         if (this.props.tabFill !== undefined) {
-            page.setTabFill(this.props.tabFill);
+            page.tabFill = this.props.tabFill;
         }
     }
 

package/src/nodes/overlay-child.ts

@@ -1,6 +1,7 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { OverlayChildProps } from "../jsx.js";
 import type { Node } from "../node.js";
+import { isRemovable } from "./internal/predicates.js";
 import { hasChanged } from "./internal/props.js";
 import { VirtualNode } from "./virtual.js";
 import { WidgetNode } from "./widget.js";
@@ -32,6 +33,7 @@ export class OverlayChildNode extends VirtualNode<OverlayChildProps, WidgetNode<
         super.appendChild(child);
 
         if (this.parent) {
+            this.detachFromGtkParent(child);
             this.attachToParent(this.parent.container, child.container);
         }
     }
@@ -40,19 +42,12 @@ export class OverlayChildNode extends VirtualNode<OverlayChildProps, WidgetNode<
         super.insertBefore(child, before);
 
         if (this.parent) {
-            this.attachToParent(this.parent.container, child.container);
+            this.reinsertAllChildren();
         }
     }
 
     public override removeChild(child: WidgetNode): void {
-        if (this.parent) {
-            const widget = child.container;
-            const currentParent = widget.getParent();
-            if (currentParent && currentParent === this.parent.container) {
-                this.parent.container.removeOverlay(widget);
-            }
-        }
-
+        this.detachFromGtkParent(child);
         super.removeChild(child);
     }
 
@@ -98,6 +93,32 @@ export class OverlayChildNode extends VirtualNode<OverlayChildProps, WidgetNode<
         }
     }
 
+    private detachFromGtkParent(child: WidgetNode): void {
+        const currentParent = child.container.getParent();
+        if (currentParent !== null) {
+            if (currentParent instanceof Gtk.Overlay) {
+                currentParent.removeOverlay(child.container);
+            } else if (isRemovable(currentParent)) {
+                currentParent.remove(child.container);
+            } else {
+                child.container.unparent();
+            }
+        }
+    }
+
+    private reinsertAllChildren(): void {
+        if (!this.parent) return;
+        const parent = this.parent.container;
+
+        for (const child of this.children) {
+            this.detachFromGtkParent(child);
+        }
+
+        for (const child of this.children) {
+            this.attachToParent(parent, child.container);
+        }
+    }
+
     private detachAllChildren(parent: Gtk.Overlay): void {
         for (const child of this.children) {
             const currentParent = child.container.getParent();

package/src/nodes/spin-row.ts

@@ -0,0 +1,72 @@
+import type * as Adw from "@gtkx/ffi/adw";
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { AdjustableProps } from "../jsx.js";
+import { filterProps, hasChanged } from "./internal/props.js";
+import { WidgetNode } from "./widget.js";
+
+type SpinRowProps = AdjustableProps & {
+    onValueChanged?: ((value: number, self: Adw.SpinRow) => void) | null;
+};
+
+const OWN_PROPS = ["value", "lower", "upper", "stepIncrement", "pageIncrement", "pageSize", "onValueChanged"] as const;
+
+export class SpinRowNode extends WidgetNode<Adw.SpinRow, SpinRowProps> {
+    private adjustment: Gtk.Adjustment | null = null;
+
+    public override commitUpdate(oldProps: SpinRowProps | null, newProps: SpinRowProps): void {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
+    }
+
+    private ensureAdjustment(props: SpinRowProps): Gtk.Adjustment {
+        if (!this.adjustment) {
+            this.adjustment = new Gtk.Adjustment(
+                props.value ?? 0,
+                props.lower ?? 0,
+                props.upper ?? 100,
+                props.stepIncrement ?? 1,
+                props.pageIncrement ?? 10,
+                props.pageSize ?? 0,
+            );
+
+            this.container.setAdjustment(this.adjustment);
+        }
+
+        return this.adjustment;
+    }
+
+    private applyOwnProps(oldProps: SpinRowProps | null, newProps: SpinRowProps): void {
+        const adjustment = this.ensureAdjustment(newProps);
+
+        if (hasChanged(oldProps, newProps, "onValueChanged")) {
+            const { onValueChanged } = newProps;
+            this.signalStore.set(
+                this,
+                this.container,
+                "notify::value",
+                onValueChanged ? (self: Adw.SpinRow) => onValueChanged(self.getValue(), self) : undefined,
+            );
+        }
+
+        if (!oldProps) return;
+
+        if (hasChanged(oldProps, newProps, "lower")) {
+            adjustment.setLower(newProps.lower ?? 0);
+        }
+        if (hasChanged(oldProps, newProps, "upper")) {
+            adjustment.setUpper(newProps.upper ?? 100);
+        }
+        if (hasChanged(oldProps, newProps, "stepIncrement")) {
+            adjustment.setStepIncrement(newProps.stepIncrement ?? 1);
+        }
+        if (hasChanged(oldProps, newProps, "pageIncrement")) {
+            adjustment.setPageIncrement(newProps.pageIncrement ?? 10);
+        }
+        if (hasChanged(oldProps, newProps, "pageSize")) {
+            adjustment.setPageSize(newProps.pageSize ?? 0);
+        }
+        if (hasChanged(oldProps, newProps, "value") && newProps.value !== undefined) {
+            adjustment.setValue(newProps.value);
+        }
+    }
+}

package/src/nodes/switch-row.ts

@@ -0,0 +1,26 @@
+import type * as Adw from "@gtkx/ffi/adw";
+import { hasChanged } from "./internal/props.js";
+import { WidgetNode } from "./widget.js";
+
+type SwitchRowProps = {
+    onActiveChanged?: ((active: boolean, self: Adw.SwitchRow) => void) | null;
+};
+
+export class SwitchRowNode extends WidgetNode<Adw.SwitchRow, SwitchRowProps> {
+    public override commitUpdate(oldProps: SwitchRowProps | null, newProps: SwitchRowProps): void {
+        super.commitUpdate(oldProps, newProps);
+        this.applyOwnProps(oldProps, newProps);
+    }
+
+    private applyOwnProps(oldProps: SwitchRowProps | null, newProps: SwitchRowProps): void {
+        if (hasChanged(oldProps, newProps, "onActiveChanged")) {
+            const { onActiveChanged } = newProps;
+            this.signalStore.set(
+                this,
+                this.container,
+                "notify::active",
+                onActiveChanged ? (self: Adw.SwitchRow) => onActiveChanged(self.getActive(), self) : undefined,
+            );
+        }
+    }
+}

package/src/nodes/text-anchor.ts

@@ -1,6 +1,7 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { TextAnchorProps } from "../jsx.js";
 import type { Node } from "../node.js";
+import { isRemovable } from "./internal/predicates.js";
 import { TEXT_OBJECT_REPLACEMENT, type TextContentParent } from "./text-content.js";
 import { isTextContentParent } from "./text-segment.js";
 import { VirtualNode } from "./virtual.js";
@@ -66,6 +67,14 @@ export class TextAnchorNode extends VirtualNode<TextAnchorProps, Node & TextCont
         super.appendChild(child);
 
         if (this.textView && this.anchor && child.container) {
+            const currentParent = child.container.getParent();
+            if (currentParent !== null) {
+                if (isRemovable(currentParent)) {
+                    currentParent.remove(child.container);
+                } else {
+                    child.container.unparent();
+                }
+            }
             this.textView.addChildAtAnchor(child.container, this.anchor);
         }
     }

package/src/nodes/text-tag.ts

@@ -8,45 +8,45 @@ import { TextPaintableNode } from "./text-paintable.js";
 import { isTextContentParent, TextSegmentNode } from "./text-segment.js";
 import { VirtualNode } from "./virtual.js";
 
-const STYLE_PROPS: Partial<Record<keyof TextTagProps, keyof Gtk.TextTag>> = {
+const STYLE_PROPS: Partial<Record<keyof TextTagProps, keyof Gtk.TextTag | string>> = {
     background: "setBackground",
-    backgroundFullHeight: "setBackgroundFullHeight",
+    backgroundFullHeight: "backgroundFullHeight",
     foreground: "setForeground",
-    family: "setFamily",
-    font: "setFont",
-    sizePoints: "setSizePoints",
-    size: "setSize",
-    scale: "setScale",
-    weight: "setWeight",
-    style: "setStyle",
-    stretch: "setStretch",
-    variant: "setVariant",
-    strikethrough: "setStrikethrough",
-    underline: "setUnderline",
-    overline: "setOverline",
-    rise: "setRise",
-    letterSpacing: "setLetterSpacing",
-    lineHeight: "setLineHeight",
-    leftMargin: "setLeftMargin",
-    rightMargin: "setRightMargin",
-    indent: "setIndent",
-    pixelsAboveLines: "setPixelsAboveLines",
-    pixelsBelowLines: "setPixelsBelowLines",
-    pixelsInsideWrap: "setPixelsInsideWrap",
-    justification: "setJustification",
-    direction: "setDirection",
-    wrapMode: "setWrapMode",
-    editable: "setEditable",
-    invisible: "setInvisible",
-    allowBreaks: "setAllowBreaks",
-    insertHyphens: "setInsertHyphens",
-    fallback: "setFallback",
-    accumulativeMargin: "setAccumulativeMargin",
+    family: "family",
+    font: "font",
+    sizePoints: "sizePoints",
+    size: "size",
+    scale: "scale",
+    weight: "weight",
+    style: "style",
+    stretch: "stretch",
+    variant: "variant",
+    strikethrough: "strikethrough",
+    underline: "underline",
+    overline: "overline",
+    rise: "rise",
+    letterSpacing: "letterSpacing",
+    lineHeight: "lineHeight",
+    leftMargin: "leftMargin",
+    rightMargin: "rightMargin",
+    indent: "indent",
+    pixelsAboveLines: "pixelsAboveLines",
+    pixelsBelowLines: "pixelsBelowLines",
+    pixelsInsideWrap: "pixelsInsideWrap",
+    justification: "justification",
+    direction: "direction",
+    wrapMode: "wrapMode",
+    editable: "editable",
+    invisible: "invisible",
+    allowBreaks: "allowBreaks",
+    insertHyphens: "insertHyphens",
+    fallback: "fallback",
+    accumulativeMargin: "accumulativeMargin",
     paragraphBackground: "setParagraphBackground",
-    showSpaces: "setShowSpaces",
-    textTransform: "setTextTransform",
-    fontFeatures: "setFontFeatures",
-    language: "setLanguage",
+    showSpaces: "showSpaces",
+    textTransform: "textTransform",
+    fontFeatures: "fontFeatures",
+    language: "language",
 };
 
 type TextTagParent = Node & TextContentParent;
@@ -225,10 +225,15 @@ export class TextTagNode
         for (const prop of Object.keys(STYLE_PROPS) as (keyof TextTagProps)[]) {
             if (hasChanged(oldProps, newProps, prop)) {
                 const value = newProps[prop];
-                const method = STYLE_PROPS[prop];
-                if (value !== undefined && method) {
-                    const setter = this.tag[method] as (value: unknown) => void;
-                    setter.call(this.tag, value);
+                const target = STYLE_PROPS[prop];
+                if (value !== undefined && target) {
+                    const tag = this.tag as unknown as Record<string, unknown>;
+                    const member = tag[target];
+                    if (typeof member === "function") {
+                        (member as (v: unknown) => void).call(this.tag, value);
+                    } else {
+                        tag[target] = value;
+                    }
                 }
             }
         }

package/src/nodes/toggle-group.ts

@@ -1,19 +1,41 @@
-import type * as Adw from "@gtkx/ffi/adw";
-import type { AdwToggleGroupProps } from "../jsx.js";
+import * as Adw from "@gtkx/ffi/adw";
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { AdwToggleGroupProps, ToggleProps } from "../jsx.js";
+import type { Container, Props } from "../types.js";
+import { createContainerWithProperties } from "./internal/construct.js";
 import { filterProps, hasChanged } from "./internal/props.js";
 import { WidgetNode } from "./widget.js";
 
-const OWN_PROPS = ["onActiveChanged"] as const;
+const DEFERRED_PROPS = ["activeName", "active"] as const;
+const OWN_PROPS = ["onActiveChanged", "toggles", ...DEFERRED_PROPS] as const;
 
-type ToggleGroupProps = Pick<AdwToggleGroupProps, (typeof OWN_PROPS)[number]>;
+type OwnProps = Pick<AdwToggleGroupProps, (typeof OWN_PROPS)[number]>;
 
-export class ToggleGroupNode extends WidgetNode<Adw.ToggleGroup, ToggleGroupProps> {
-    public override commitUpdate(oldProps: ToggleGroupProps | null, newProps: ToggleGroupProps): void {
-        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
-        this.applyOwnProps(oldProps, newProps);
+export class ToggleGroupNode extends WidgetNode<Adw.ToggleGroup, OwnProps> {
+    private managedToggles: Adw.Toggle[] = [];
+
+    public static override createContainer(props: Props, containerClass: typeof Gtk.Widget): Container | null {
+        const { activeName: _, active: __, ...rest } = props;
+        return createContainerWithProperties(containerClass, rest);
     }
 
-    private applyOwnProps(oldProps: ToggleGroupProps | null, newProps: ToggleGroupProps): void {
+    public override commitUpdate(oldProps: OwnProps | null, newProps: OwnProps): void {
+        if (hasChanged(oldProps, newProps, "toggles")) {
+            this.syncToggles(newProps.toggles ?? []);
+        }
+
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+
+        if (hasChanged(oldProps, newProps, "activeName")) {
+            this.container.setActiveName(newProps.activeName ?? null);
+        }
+
+        if (hasChanged(oldProps, newProps, "active")) {
+            if (newProps.active != null) {
+                this.container.setActive(newProps.active);
+            }
+        }
+
         if (hasChanged(oldProps, newProps, "onActiveChanged")) {
             const callback = newProps.onActiveChanged;
             this.signalStore.set(
@@ -24,4 +46,36 @@ export class ToggleGroupNode extends WidgetNode<Adw.ToggleGroup, ToggleGroupProp
             );
         }
     }
+
+    public override detachDeletedInstance(): void {
+        this.clearToggles();
+        super.detachDeletedInstance();
+    }
+
+    private syncToggles(newToggles: ToggleProps[]): void {
+        this.clearToggles();
+
+        for (const toggleProps of newToggles) {
+            const toggle = new Adw.Toggle();
+            applyToggleProps(toggle, toggleProps);
+            this.container.add(toggle);
+            this.managedToggles.push(toggle);
+        }
+    }
+
+    private clearToggles(): void {
+        for (const toggle of this.managedToggles) {
+            this.container.remove(toggle);
+        }
+        this.managedToggles = [];
+    }
+}
+
+function applyToggleProps(toggle: Adw.Toggle, props: ToggleProps): void {
+    if (props.id != null) toggle.setName(props.id);
+    if (props.label != null) toggle.setLabel(props.label);
+    if (props.iconName != null) toggle.setIconName(props.iconName);
+    if (props.tooltip !== undefined) toggle.setTooltip(props.tooltip);
+    if (props.enabled !== undefined) toggle.setEnabled(props.enabled);
+    if (props.useUnderline !== undefined) toggle.setUseUnderline(props.useUnderline);
 }

package/src/nodes/widget.ts

@@ -11,12 +11,11 @@ import {
     typeNameFromInstance,
 } from "@gtkx/ffi/gobject";
 import * as Gtk from "@gtkx/ffi/gtk";
-import { CONSTRUCTOR_PROPS } from "../generated/internal.js";
 import { isConstructOnlyProp, resolvePropMeta, resolveSignal } from "../metadata.js";
 import { Node } from "../node.js";
 import type { Container, Props } from "../types.js";
 import { applyAccessibleProps, isAccessibleProp } from "./internal/accessible.js";
-import { createContainerWithConstructOnly } from "./internal/construct.js";
+import { createContainerWithProperties } from "./internal/construct.js";
 import {
     type InsertableWidget,
     isAddable,
@@ -56,15 +55,7 @@ export class WidgetNode<
         containerClass: typeof Gtk.Widget,
         _rootContainer?: Container,
     ): Container | null {
-        const WidgetClass = containerClass;
-        const typeName = WidgetClass.glibTypeName;
-        const args = (CONSTRUCTOR_PROPS[typeName] ?? []).map((name) => props[name]);
-
-        return createContainerWithConstructOnly(
-            WidgetClass,
-            props,
-            () => new WidgetClass(...(args as ConstructorParameters<typeof Gtk.Widget>)),
-        );
+        return createContainerWithProperties(containerClass, props);
     }
 
     public override isValidChild(_child: Node): boolean {
@@ -306,23 +297,16 @@ export class WidgetNode<
     }
 
     private setProperty(key: string, value: unknown): void {
-        const propMeta = resolvePropMeta(this.container, key);
-        if (!propMeta) return;
-
-        const [getterName, setterName] = propMeta;
-        const setter = this.container[setterName as keyof typeof this.container];
-        if (!setter || typeof setter !== "function") return;
+        const propName = resolvePropMeta(this.container, key);
+        if (!propName) return;
 
-        if (getterName && findProperty(this.container, key) instanceof ParamSpecString) {
-            const getter = this.container[getterName as keyof typeof this.container];
+        const target = this.container as Record<string, unknown>;
 
-            if (getter && typeof getter === "function") {
-                const currentValue = getter.call(this.container);
-                if (currentValue === value) return;
-            }
+        if (findProperty(this.container, key) instanceof ParamSpecString) {
+            if (target[propName] === value) return;
         }
 
-        setter.call(this.container, value);
+        target[propName] = value;
     }
 
     private insertBeforeReorderable(container: ReorderableWidget, child: WidgetNode, before: WidgetNode): void {
@@ -375,7 +359,11 @@ export class WidgetNode<
 
 function detachChildFromParent(child: WidgetNode): void {
     const currentParent = child.container.getParent();
-    if (currentParent !== null && isRemovable(currentParent)) {
-        currentParent.remove(child.container);
+    if (currentParent !== null) {
+        if (isRemovable(currentParent)) {
+            currentParent.remove(child.container);
+        } else {
+            child.container.unparent();
+        }
     }
 }

package/src/nodes/window.ts

@@ -107,6 +107,7 @@ export class WindowNode extends WidgetNode<Gtk.Window, WindowProps, WindowChild>
 
     public override removeChild(child: WindowChild): void {
         if (child instanceof WindowNode) {
+            child.container.setVisible(false);
             child.container.setTransientFor(null);
             super.removeChild(child);
             return;
@@ -152,9 +153,8 @@ export class WindowNode extends WidgetNode<Gtk.Window, WindowProps, WindowChild>
     }
 
     public override detachDeletedInstance(): void {
-        this.container.setVisible(false);
-        this.container.destroy();
         super.detachDeletedInstance();
+        this.container.destroy();
     }
 
     private applyOwnProps(oldProps: WindowProps | null, newProps: WindowProps): void {

package/src/registry.ts

@@ -5,26 +5,22 @@ import * as WebKit from "@gtkx/ffi/webkit";
 import type { Node } from "./node.js";
 import { AdjustableNode } from "./nodes/adjustable.js";
 
-import { AlertDialogResponseNode } from "./nodes/alert-dialog-response.js";
+import { AlertDialogNode } from "./nodes/alert-dialog.js";
 import { AnimationNode } from "./nodes/animation.js";
 import { ApplicationNode } from "./nodes/application.js";
 import { CalendarNode } from "./nodes/calendar.js";
 import { ColorDialogButtonNode } from "./nodes/color-dialog-button.js";
-import { ColumnViewNode } from "./nodes/column-view.js";
 import { ColumnViewColumnNode } from "./nodes/column-view-column.js";
 import { ContainerSlotNode } from "./nodes/container-slot.js";
 import { DialogNode } from "./nodes/dialog.js";
 import { DrawingAreaNode } from "./nodes/drawing-area.js";
-import { DropDownNode } from "./nodes/drop-down.js";
 import { EventControllerNode } from "./nodes/event-controller.js";
 import { FixedChildNode } from "./nodes/fixed-child.js";
 import { FontDialogButtonNode } from "./nodes/font-dialog-button.js";
 import { GridChildNode } from "./nodes/grid-child.js";
-import { GridViewNode } from "./nodes/grid-view.js";
 import { LevelBarNode } from "./nodes/level-bar.js";
-import { ListItemNode } from "./nodes/list-item.js";
-import { ListSectionNode } from "./nodes/list-section.js";
-import { ListViewNode } from "./nodes/list-view.js";
+import { ListNode } from "./nodes/list.js";
+import { ListItemNode } from "./nodes/list-item-node.js";
 import { MenuNode } from "./nodes/menu.js";
 import { NavigationPageNode } from "./nodes/navigation-page.js";
 import { NavigationViewNode } from "./nodes/navigation-view.js";
@@ -39,14 +35,15 @@ import { SearchBarNode } from "./nodes/search-bar.js";
 import { ShortcutNode } from "./nodes/shortcut.js";
 import { SlotNode } from "./nodes/slot.js";
 import { SourceViewNode } from "./nodes/source-view.js";
+import { SpinRowNode } from "./nodes/spin-row.js";
 import { StackNode } from "./nodes/stack.js";
 import { StackPageNode } from "./nodes/stack-page.js";
+import { SwitchRowNode } from "./nodes/switch-row.js";
 import { TextAnchorNode } from "./nodes/text-anchor.js";
 import { TextPaintableNode } from "./nodes/text-paintable.js";
 import { TextSegmentNode } from "./nodes/text-segment.js";
 import { TextTagNode } from "./nodes/text-tag.js";
 import { TextViewNode } from "./nodes/text-view.js";
-import { ToggleNode } from "./nodes/toggle.js";
 import { ToggleGroupNode } from "./nodes/toggle-group.js";
 import { WebViewNode } from "./nodes/web-view.js";
 import { WidgetNode } from "./nodes/widget.js";
@@ -58,14 +55,16 @@ export type AdjustableWidget = InstanceType<(typeof AdjustableWidgets)[number]>;
 export const StackWidgets = [Gtk.Stack, Adw.ViewStack] as const;
 export type StackWidget = InstanceType<(typeof StackWidgets)[number]>;
 
-export const DropDownWidgets = [Gtk.DropDown, Adw.ComboRow] as const;
-export type DropDownWidget = InstanceType<(typeof DropDownWidgets)[number]>;
-
 export const PopoverMenuWidgets = [Gtk.PopoverMenu, Gtk.PopoverMenuBar, Gtk.MenuButton] as const;
 export type PopoverMenuWidget = InstanceType<(typeof PopoverMenuWidgets)[number]>;
 
-// biome-ignore lint/suspicious/noExplicitAny: Registry entries require flexible typing for varied node constructors
-export type NodeClass = (new (...args: any[]) => Node) & { createContainer(...args: any[]): unknown };
+export type NodeClass = (new (
+    // biome-ignore lint/suspicious/noExplicitAny: Registry entries require flexible typing for varied node constructors
+    ...args: any[]
+) => Node) & {
+    // biome-ignore lint/suspicious/noExplicitAny: Registry entries require flexible typing for varied node constructors
+    createContainer(...args: any[]): unknown;
+};
 
 // biome-ignore lint/suspicious/noExplicitAny: Class keys require flexible typing for GTK class hierarchy matching
 type ClassKey = new (...args: any[]) => any;
@@ -74,19 +73,15 @@ type NodeRegistryEntry = [RegistryKey, NodeClass];
 
 export const NODE_REGISTRY: NodeRegistryEntry[] = [
     ["ContainerSlot", ContainerSlotNode],
-    ["AlertDialogResponse", AlertDialogResponseNode],
-    ["Animation", AnimationNode],
+    [["AdwTimedAnimation", "AdwSpringAnimation"], AnimationNode],
     ["ColumnViewColumn", ColumnViewColumnNode],
     ["FixedChild", FixedChildNode],
     ["GridChild", GridChildNode],
-    ["ListItem", ListItemNode],
-    ["ListSection", ListSectionNode],
     [["MenuItem", "MenuSection", "MenuSubmenu"], MenuNode],
     ["NavigationPage", NavigationPageNode],
     ["NotebookPage", NotebookPageNode],
     ["NotebookPageTab", NotebookPageTabNode],
     ["OverlayChild", OverlayChildNode],
-
     ["Shortcut", ShortcutNode],
     ["Slot", SlotNode],
     ["StackPage", StackPageNode],
@@ -94,15 +89,16 @@ export const NODE_REGISTRY: NodeRegistryEntry[] = [
     ["TextPaintable", TextPaintableNode],
     ["TextSegment", TextSegmentNode],
     ["TextTag", TextTagNode],
-    ["Toggle", ToggleNode],
     [Gtk.Application, ApplicationNode],
-
     [Gtk.EventController, EventControllerNode],
     [GtkSource.View, SourceViewNode],
     [Gtk.TextView, TextViewNode],
     [WebKit.WebView, WebViewNode],
+    [Adw.AlertDialog, AlertDialogNode],
     [Adw.Dialog, DialogNode],
     [Gtk.Window, WindowNode],
+    [Adw.SpinRow, SpinRowNode],
+    [Adw.SwitchRow, SwitchRowNode],
     [Gtk.Scale, ScaleNode],
     [Gtk.LevelBar, LevelBarNode],
     [Gtk.ScrolledWindow, ScrolledWindowNode],
@@ -115,11 +111,9 @@ export const NODE_REGISTRY: NodeRegistryEntry[] = [
     [Adw.ToggleGroup, ToggleGroupNode],
     [Gtk.Notebook, NotebookNode],
     [StackWidgets, StackNode],
-    [Gtk.ColumnView, ColumnViewNode],
-    [Gtk.ListView, ListViewNode],
-    [Gtk.GridView, GridViewNode],
-    [DropDownWidgets, DropDownNode],
+    [[Gtk.ListView, Gtk.ColumnView, Gtk.GridView, Gtk.DropDown, Adw.ComboRow], ListNode],
     [PopoverMenuWidgets, PopoverMenuNode],
     [AdjustableWidgets, AdjustableNode],
+    [[Gtk.ListItem, Gtk.ListHeader], ListItemNode],
     [Gtk.Widget, WidgetNode],
 ];

package/src/types.ts

@@ -1,7 +1,13 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
 
-export type Container = Gtk.Widget | Gtk.Application | Gtk.EventController;
+/** @internal */
+export type Container = Gtk.Widget | Gtk.Application | Gtk.EventController | Gtk.ListItem | Gtk.ListHeader;
 
 export type Props = Record<string, unknown>;
 
-export type ContainerClass = typeof Gtk.Widget | typeof Gtk.Application | typeof Gtk.EventController;
+export type ContainerClass =
+    | typeof Gtk.Widget
+    | typeof Gtk.Application
+    | typeof Gtk.EventController
+    | typeof Gtk.ListItem
+    | typeof Gtk.ListHeader;