@gtkx/react 0.17.2 → 0.18.0

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 { DialogNode } from "./dialog.js";
-import { filterProps, hasChanged, matchesAnyClass } from "./internal/utils.js";
+import { AnimationNode } from "./animation.js";
+import { filterProps, hasChanged } from "./internal/props.js";
+import { MenuNode } from "./menu.js";
 import { MenuModel } from "./models/menu.js";
+import { NavigationPageNode } from "./navigation-page.js";
+import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
-const OWN_PROPS = ["defaultWidth", "defaultHeight", "onClose"];
+// biome-ignore lint/suspicious/noExplicitAny: Required for matching GTK class constructors with varying signatures
+const isOrExtendsClass = (target, cls) => target === cls || Object.prototype.isPrototypeOf.call(cls, target);
+const OWN_PROPS = ["onClose"];
 export class WindowNode extends WidgetNode {
-    static priority = 1;
     menu;
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass([Gtk.Window], containerOrClass);
-    }
     static createContainer(props, containerClass, rootContainer) {
         const WindowClass = containerClass;
-        if (matchesAnyClass([Gtk.ApplicationWindow], WindowClass) ||
-            matchesAnyClass([Adw.ApplicationWindow], WindowClass)) {
+        if (isOrExtendsClass(WindowClass, Gtk.ApplicationWindow) ||
+            isOrExtendsClass(WindowClass, Adw.ApplicationWindow)) {
             if (!(rootContainer instanceof Gtk.Application)) {
                 throw new Error("Expected ApplicationWindow to be created within Application");
             }
-            if (matchesAnyClass([Adw.ApplicationWindow], WindowClass)) {
+            if (isOrExtendsClass(WindowClass, Adw.ApplicationWindow)) {
                 return new Adw.ApplicationWindow(rootContainer);
             }
             return new Gtk.ApplicationWindow(rootContainer);
@@ -37,52 +37,72 @@ export class WindowNode extends WidgetNode {
             }
         }
     }
+    shouldAttachToParent() {
+        return false;
+    }
+    isValidChild(child) {
+        return (child instanceof WidgetNode ||
+            child instanceof MenuNode ||
+            child instanceof SlotNode ||
+            child instanceof AnimationNode ||
+            child instanceof NavigationPageNode);
+    }
     appendChild(child) {
-        if (child.container instanceof Gtk.Window) {
+        if (child instanceof WindowNode) {
             child.container.setTransientFor(this.container);
+            super.appendChild(child);
             return;
         }
-        if (child instanceof DialogNode) {
-            child.parent = this.container;
+        if (child instanceof MenuNode) {
+            this.menu.appendChild(child);
             return;
         }
-        this.menu.appendChild(child);
         super.appendChild(child);
     }
     removeChild(child) {
-        if (child.container instanceof Gtk.Window) {
+        if (child instanceof WindowNode) {
             child.container.setTransientFor(null);
+            super.removeChild(child);
             return;
         }
-        if (child instanceof DialogNode) {
-            child.parent = null;
+        if (child instanceof MenuNode) {
+            this.menu.removeChild(child);
             return;
         }
-        this.menu.removeChild(child);
         super.removeChild(child);
     }
     insertBefore(child, before) {
-        this.menu.insertBefore(child, before);
-        this.appendChild(child);
+        if (child instanceof MenuNode) {
+            if (before instanceof MenuNode) {
+                this.menu.insertBefore(child, before);
+            }
+            else {
+                this.menu.appendChild(child);
+            }
+            return;
+        }
+        if (child instanceof WindowNode) {
+            child.container.setTransientFor(this.container);
+        }
+        super.insertBefore(child, before);
+    }
+    finalizeInitialChildren(props) {
+        this.commitUpdate(null, props);
+        return true;
+    }
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
     }
-    mount() {
+    commitMount() {
         this.container.present();
-        super.mount();
     }
-    unmount() {
+    detachDeletedInstance() {
+        this.container.setVisible(false);
         this.container.destroy();
-        super.unmount();
-    }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
-        this.applyOwnProps(oldProps, newProps);
+        super.detachDeletedInstance();
     }
     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 (hasChanged(oldProps, newProps, "onClose")) {
             const userHandler = newProps.onClose;
             const wrappedHandler = userHandler
@@ -95,4 +115,3 @@ export class WindowNode extends WidgetNode {
         }
     }
 }
-registerNodeClass(WindowNode);

package/dist/registry.d.ts

@@ -1,8 +1,19 @@
+import * as Adw from "@gtkx/ffi/adw";
+import * as Gtk from "@gtkx/ffi/gtk";
 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>;
-} & Omit<typeof Node, "prototype">;
-export declare const NODE_CLASSES: NodeClass[];
-export declare const registerNodeClass: <T, P>(nodeClass: NodeClass<T, P>) => void;
+export declare const AdjustableWidgets: readonly [typeof Gtk.SpinButton, typeof Gtk.ScaleButton, typeof Gtk.Range];
+export type AdjustableWidget = InstanceType<(typeof AdjustableWidgets)[number]>;
+export declare const StackWidgets: readonly [typeof Gtk.Stack, typeof Adw.ViewStack];
+export type StackWidget = InstanceType<(typeof StackWidgets)[number]>;
+export declare const DropDownWidgets: readonly [typeof Gtk.DropDown, typeof Adw.ComboRow];
+export type DropDownWidget = InstanceType<(typeof DropDownWidgets)[number]>;
+export declare const PopoverMenuWidgets: readonly [typeof Gtk.PopoverMenu, typeof Gtk.PopoverMenuBar, typeof Gtk.MenuButton];
+export type PopoverMenuWidget = InstanceType<(typeof PopoverMenuWidgets)[number]>;
+export type NodeClass = (new (...args: any[]) => Node) & {
+    createContainer(...args: any[]): unknown;
+};
+type ClassKey = new (...args: any[]) => any;
+type RegistryKey = string | ClassKey | readonly (string | ClassKey)[];
+type NodeRegistryEntry = [RegistryKey, NodeClass];
+export declare const NODE_REGISTRY: NodeRegistryEntry[];
 export {};

package/dist/registry.js

@@ -1,5 +1,104 @@
-export const NODE_CLASSES = [];
-export const registerNodeClass = (nodeClass) => {
-    NODE_CLASSES.push(nodeClass);
-    NODE_CLASSES.sort((a, b) => a.priority - b.priority);
-};
+import * as Adw from "@gtkx/ffi/adw";
+import * as Gtk from "@gtkx/ffi/gtk";
+import * as GtkSource from "@gtkx/ffi/gtksource";
+import * as WebKit from "@gtkx/ffi/webkit";
+import { AdjustableNode } from "./nodes/adjustable.js";
+import { AlertDialogResponseNode } from "./nodes/alert-dialog-response.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 { ListViewNode } from "./nodes/list-view.js";
+import { MenuNode } from "./nodes/menu.js";
+import { NavigationPageNode } from "./nodes/navigation-page.js";
+import { NavigationViewNode } from "./nodes/navigation-view.js";
+import { NotebookNode } from "./nodes/notebook.js";
+import { NotebookPageNode } from "./nodes/notebook-page.js";
+import { NotebookPageTabNode } from "./nodes/notebook-page-tab.js";
+import { OverlayChildNode } from "./nodes/overlay-child.js";
+import { PopoverMenuNode } from "./nodes/popover-menu.js";
+import { ScaleNode } from "./nodes/scale.js";
+import { ScrolledWindowNode } from "./nodes/scrolled-window.js";
+import { SearchBarNode } from "./nodes/search-bar.js";
+import { ShortcutNode } from "./nodes/shortcut.js";
+import { ShortcutControllerNode } from "./nodes/shortcut-controller.js";
+import { SlotNode } from "./nodes/slot.js";
+import { SourceViewNode } from "./nodes/source-view.js";
+import { StackNode } from "./nodes/stack.js";
+import { StackPageNode } from "./nodes/stack-page.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";
+import { WindowNode } from "./nodes/window.js";
+export const AdjustableWidgets = [Gtk.SpinButton, Gtk.ScaleButton, Gtk.Range];
+export const StackWidgets = [Gtk.Stack, Adw.ViewStack];
+export const DropDownWidgets = [Gtk.DropDown, Adw.ComboRow];
+export const PopoverMenuWidgets = [Gtk.PopoverMenu, Gtk.PopoverMenuBar, Gtk.MenuButton];
+export const NODE_REGISTRY = [
+    ["ContainerSlot", ContainerSlotNode],
+    ["AlertDialogResponse", AlertDialogResponseNode],
+    ["Animation", AnimationNode],
+    ["ColumnViewColumn", ColumnViewColumnNode],
+    ["FixedChild", FixedChildNode],
+    ["GridChild", GridChildNode],
+    ["ListItem", ListItemNode],
+    [["MenuItem", "MenuSection", "MenuSubmenu"], MenuNode],
+    ["NavigationPage", NavigationPageNode],
+    ["NotebookPage", NotebookPageNode],
+    ["NotebookPageTab", NotebookPageTabNode],
+    ["OverlayChild", OverlayChildNode],
+    ["Shortcut", ShortcutNode],
+    ["Slot", SlotNode],
+    ["StackPage", StackPageNode],
+    ["TextAnchor", TextAnchorNode],
+    ["TextPaintable", TextPaintableNode],
+    ["TextSegment", TextSegmentNode],
+    ["TextTag", TextTagNode],
+    ["Toggle", ToggleNode],
+    [Gtk.Application, ApplicationNode],
+    [Gtk.ShortcutController, ShortcutControllerNode],
+    [Gtk.EventController, EventControllerNode],
+    [GtkSource.View, SourceViewNode],
+    [Gtk.TextView, TextViewNode],
+    [WebKit.WebView, WebViewNode],
+    [Adw.Dialog, DialogNode],
+    [Gtk.Window, WindowNode],
+    [Gtk.Scale, ScaleNode],
+    [Gtk.LevelBar, LevelBarNode],
+    [Gtk.ScrolledWindow, ScrolledWindowNode],
+    [Gtk.Calendar, CalendarNode],
+    [Gtk.ColorDialogButton, ColorDialogButtonNode],
+    [Gtk.FontDialogButton, FontDialogButtonNode],
+    [Gtk.DrawingArea, DrawingAreaNode],
+    [Gtk.SearchBar, SearchBarNode],
+    [Adw.NavigationView, NavigationViewNode],
+    [Adw.ToggleGroup, ToggleGroupNode],
+    [Gtk.Notebook, NotebookNode],
+    [StackWidgets, StackNode],
+    [Gtk.ColumnView, ColumnViewNode],
+    [Gtk.ListView, ListViewNode],
+    [Gtk.GridView, GridViewNode],
+    [DropDownWidgets, DropDownNode],
+    [PopoverMenuWidgets, PopoverMenuNode],
+    [AdjustableWidgets, AdjustableNode],
+    [Gtk.Widget, WidgetNode],
+];

package/dist/render.d.ts

@@ -35,15 +35,6 @@ export declare const ApplicationContext: React.Context<Gtk.Application | null>;
  * @see {@link ApplicationContext} for the underlying context
  */
 export declare const useApplication: () => Gtk.Application;
-/**
- * Returns the current GTK Application instance.
- *
- * Returns null if no application has been rendered yet.
- * Used by tools that need access to the running application.
- *
- * @returns The current GTK Application or null
- */
-export declare const getApplication: () => Gtk.Application | null;
 /**
  * Sets the hot reloading state.
  *
@@ -122,4 +113,4 @@ export declare const update: (element: ReactNode) => Promise<void>;
  *
  * @see {@link render} for starting the application
  */
-export declare const quit: () => boolean;
+export declare const quit: () => void;

package/dist/render.js

@@ -47,17 +47,6 @@ export const useApplication = () => {
 let container = null;
 let app = null;
 let isHotReloading = false;
-/**
- * Returns the current GTK Application instance.
- *
- * Returns null if no application has been rendered yet.
- * Used by tools that need access to the running application.
- *
- * @returns The current GTK Application or null
- */
-export const getApplication = () => {
-    return app;
-};
 /**
  * Sets the hot reloading state.
  *
@@ -159,12 +148,11 @@ export const update = (element) => {
  */
 export const quit = () => {
     if (isHotReloading) {
-        return true;
+        return;
     }
     reconciler.getInstance().updateContainer(null, container, null, () => {
         setTimeout(() => {
             stop();
         }, 0);
     });
-    return true;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/react",
-  "version": "0.17.2",
+  "version": "0.18.0",
   "description": "Build GTK4 desktop applications with React and TypeScript",
   "keywords": [
     "gtkx",
@@ -13,13 +13,13 @@
     "gui",
     "native"
   ],
-  "homepage": "https://eugeniodepalo.github.io/gtkx",
+  "homepage": "https://gtkx.dev",
   "bugs": {
-    "url": "https://github.com/eugeniodepalo/gtkx/issues"
+    "url": "https://github.com/gtkx-org/gtkx/issues"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/eugeniodepalo/gtkx.git",
+    "url": "https://github.com/gtkx-org/gtkx.git",
     "directory": "packages/react"
   },
   "license": "MPL-2.0",
@@ -37,8 +37,8 @@
   ],
   "dependencies": {
     "react-reconciler": "^0.33.0",
-    "@gtkx/ffi": "0.17.2",
-    "@gtkx/gir": "0.17.2"
+    "@gtkx/ffi": "0.18.0",
+    "@gtkx/gir": "0.18.0"
   },
   "devDependencies": {
     "@types/react-reconciler": "^0.33.0"

package/dist/animation/css-builder.d.ts

@@ -1,3 +0,0 @@
-import type { AnimatableProperties } from "./types.js";
-export declare const interpolate: (from: AnimatableProperties, to: AnimatableProperties, progress: number) => AnimatableProperties;
-export declare const buildCss: (className: string, props: AnimatableProperties) => string;

package/dist/animation/css-builder.js

@@ -1,53 +0,0 @@
-const getDefaultValue = (property) => {
-    switch (property) {
-        case "opacity":
-        case "scale":
-        case "scaleX":
-        case "scaleY":
-            return 1;
-        default:
-            return 0;
-    }
-};
-export const interpolate = (from, to, progress) => {
-    const result = {};
-    const allKeys = new Set([...Object.keys(from), ...Object.keys(to)]);
-    for (const key of allKeys) {
-        const fromVal = from[key] ?? getDefaultValue(key);
-        const toVal = to[key] ?? getDefaultValue(key);
-        result[key] = fromVal + (toVal - fromVal) * progress;
-    }
-    return result;
-};
-export const buildCss = (className, props) => {
-    const parts = [];
-    const transforms = [];
-    if (props.opacity !== undefined) {
-        parts.push(`opacity: ${props.opacity}`);
-    }
-    if (props.translateX !== undefined || props.translateY !== undefined) {
-        transforms.push(`translate(${props.translateX ?? 0}px, ${props.translateY ?? 0}px)`);
-    }
-    if (props.scale !== undefined) {
-        transforms.push(`scale(${props.scale})`);
-    }
-    else if (props.scaleX !== undefined || props.scaleY !== undefined) {
-        transforms.push(`scale(${props.scaleX ?? 1}, ${props.scaleY ?? 1})`);
-    }
-    if (props.rotate !== undefined) {
-        transforms.push(`rotate(${props.rotate}deg)`);
-    }
-    if (props.skewX !== undefined) {
-        transforms.push(`skewX(${props.skewX}deg)`);
-    }
-    if (props.skewY !== undefined) {
-        transforms.push(`skewY(${props.skewY}deg)`);
-    }
-    if (transforms.length > 0) {
-        parts.push(`transform: ${transforms.join(" ")}`);
-    }
-    if (parts.length === 0) {
-        return "";
-    }
-    return `.${className} { ${parts.join("; ")}; }`;
-};

package/dist/animation/types.d.ts

@@ -1,120 +0,0 @@
-import type { Easing } from "@gtkx/ffi/adw";
-import type { ReactNode } from "react";
-/**
- * The type of animation to use.
- *
- * - `"timed"`: Duration-based animation with easing curves (uses {@link Adw.TimedAnimation})
- * - `"spring"`: Physics-based spring animation (uses {@link Adw.SpringAnimation})
- */
-export type AnimationMode = "timed" | "spring";
-/**
- * A numeric value that can be animated.
- */
-export type AnimatableValue = number;
-/**
- * CSS properties that can be animated on a widget.
- *
- * All transforms are applied via GTK CSS and rendered through the widget's style context.
- */
-export type AnimatableProperties = {
-    /** Opacity from 0 (fully transparent) to 1 (fully opaque) */
-    opacity?: AnimatableValue;
-    /** Horizontal translation in pixels (positive moves right) */
-    translateX?: AnimatableValue;
-    /** Vertical translation in pixels (positive moves down) */
-    translateY?: AnimatableValue;
-    /** Uniform scale factor (1 = original size, 2 = double size) */
-    scale?: AnimatableValue;
-    /** Horizontal scale factor */
-    scaleX?: AnimatableValue;
-    /** Vertical scale factor */
-    scaleY?: AnimatableValue;
-    /** Rotation angle in degrees (positive rotates clockwise) */
-    rotate?: AnimatableValue;
-    /** Horizontal skew angle in degrees */
-    skewX?: AnimatableValue;
-    /** Vertical skew angle in degrees */
-    skewY?: AnimatableValue;
-};
-/**
- * Transition configuration for timed (duration-based) animations.
- *
- * @see {@link https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/class.TimedAnimation.html Adw.TimedAnimation}
- */
-export type TimedTransition = {
-    /** Animation duration in milliseconds (default: 300) */
-    duration?: number;
-    /** Easing function for the animation curve (default: EASE_OUT_CUBIC) */
-    easing?: Easing;
-    /** Delay before starting the animation in milliseconds */
-    delay?: number;
-    /** Number of times to repeat the animation (0 = no repeat, -1 = infinite) */
-    repeat?: number;
-    /** Whether to play the animation in reverse */
-    reverse?: boolean;
-    /** Whether to alternate direction on each repeat */
-    alternate?: boolean;
-};
-/**
- * Transition configuration for spring (physics-based) animations.
- *
- * Spring animations simulate a mass attached to a spring, providing natural-feeling motion.
- * The animation settles when the spring reaches equilibrium.
- *
- * @see {@link https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/class.SpringAnimation.html Adw.SpringAnimation}
- */
-export type SpringTransition = {
-    /** Damping ratio controlling oscillation decay (default: 1, critically damped) */
-    damping?: number;
-    /** Spring stiffness in N/m affecting animation speed (default: 100) */
-    stiffness?: number;
-    /** Virtual mass in kg affecting momentum (default: 1) */
-    mass?: number;
-    /** Initial velocity to apply at animation start */
-    initialVelocity?: number;
-    /** Whether to clamp the animation value to prevent overshooting */
-    clamp?: boolean;
-    /** Delay before starting the animation in milliseconds */
-    delay?: number;
-};
-/**
- * Props for the Animation component.
- *
- * Provides a declarative API for animating widget properties using either
- * timed (duration-based) or spring (physics-based) animations.
- *
- * @typeParam M - The animation mode, either `"timed"` or `"spring"`
- *
- * @example
- * ```tsx
- * <x.Animation
- *   mode="spring"
- *   initial={{ opacity: 0, translateY: -20 }}
- *   animate={{ opacity: 1, translateY: 0 }}
- *   exit={{ opacity: 0, translateY: 20 }}
- *   animateOnMount
- * >
- *   <GtkLabel label="Animated content" />
- * </x.Animation>
- * ```
- */
-export type AnimationProps<M extends AnimationMode = AnimationMode> = {
-    /** Animation type: `"timed"` for duration-based or `"spring"` for physics-based */
-    mode: M;
-    /** Initial property values before animation starts, or `false` to skip initial state */
-    initial?: AnimatableProperties | false;
-    /** Target property values to animate towards */
-    animate?: AnimatableProperties;
-    /** Property values to animate to when the component unmounts */
-    exit?: AnimatableProperties;
-    /** Transition configuration (type depends on mode) */
-    transition?: M extends "timed" ? TimedTransition : SpringTransition;
-    /** Whether to animate from `initial` to `animate` when first mounted (default: false) */
-    animateOnMount?: boolean;
-    /** Callback fired when an animation begins */
-    onAnimationStart?: () => void;
-    /** Callback fired when an animation completes */
-    onAnimationComplete?: () => void;
-    /** The child widget to animate (must be a single GTK widget) */
-    children?: ReactNode;
-};

package/dist/animation/types.js

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

package/dist/nodes/abstract/positional-child.d.ts

@@ -1,9 +0,0 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-import type { Props } from "../../types.js";
-import { VirtualSingleChildNode } from "./virtual-single-child.js";
-export declare abstract class PositionalChildNode<P extends Props = Props> extends VirtualSingleChildNode<P> {
-    protected abstract attachToParent(parent: Gtk.Widget, child: Gtk.Widget): void;
-    protected abstract detachFromParent(parent: Gtk.Widget, child: Gtk.Widget): void;
-    unmount(): void;
-    protected onChildChange(oldChild: Gtk.Widget | null): void;
-}

package/dist/nodes/abstract/positional-child.js

@@ -1,29 +0,0 @@
-import { isObjectEqual } from "@gtkx/ffi";
-import { VirtualSingleChildNode } from "./virtual-single-child.js";
-export class PositionalChildNode extends VirtualSingleChildNode {
-    unmount() {
-        if (this.parent && this.child) {
-            const parent = this.parent;
-            const oldChild = this.child;
-            this.child = null;
-            const parentOfOld = oldChild.getParent();
-            if (parentOfOld && isObjectEqual(parentOfOld, parent)) {
-                this.detachFromParent(parent, oldChild);
-            }
-        }
-        this.parent = null;
-        super.unmount();
-    }
-    onChildChange(oldChild) {
-        const parent = this.getParent();
-        if (oldChild) {
-            const parentOfOld = oldChild.getParent();
-            if (parentOfOld && isObjectEqual(parentOfOld, parent)) {
-                this.detachFromParent(parent, oldChild);
-            }
-        }
-        if (this.child) {
-            this.attachToParent(parent, this.child);
-        }
-    }
-}

package/dist/nodes/abstract/virtual-container.d.ts

@@ -1,21 +0,0 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-import type { Node } from "../../node.js";
-import type { Attachable } from "../internal/predicates.js";
-import { VirtualNode } from "../virtual.js";
-type ChildParentWidget = Gtk.Widget & {
-    remove(child: Gtk.Widget): void;
-};
-export declare abstract class VirtualContainerNode<P extends ChildParentWidget = ChildParentWidget> extends VirtualNode implements Attachable {
-    protected parent: P | null;
-    setParent(newParent: P | null): void;
-    protected getParent(): P;
-    protected abstract attachChild(parent: P, widget: Gtk.Widget): void;
-    canBeChildOf(parent: Node): boolean;
-    attachTo(parent: Node): void;
-    detachFrom(_parent: Node): void;
-    unmount(): void;
-    appendChild(child: Node): void;
-    insertBefore(child: Node, _before: Node): void;
-    removeChild(child: Node): void;
-}
-export {};