@gtkx/react 0.7.0 → 0.9.0

package/dist/nodes/header-bar.d.ts

@@ -1,23 +1,10 @@
 import type * as Adw from "@gtkx/ffi/adw";
 import type * as Gtk from "@gtkx/ffi/gtk";
-import { type PackContainer } from "../container-interfaces.js";
+import type { PackContainer } from "../containers.js";
 import type { Props } from "../factory.js";
 import { Node } from "../node.js";
 import { VirtualSlotNode } from "./virtual-slot.js";
 type HeaderBarWidget = Gtk.HeaderBar | Adw.HeaderBar | Gtk.ActionBar;
-export declare class PackContainerNode<T extends HeaderBarWidget> extends Node<T> implements PackContainer {
-    packStart(child: Gtk.Widget): void;
-    packEnd(child: Gtk.Widget): void;
-    removeFromPack(child: Gtk.Widget): void;
-    appendChild(child: Node): void;
-    removeChild(child: Node): void;
-}
-export declare class AdwHeaderBarNode extends PackContainerNode<Adw.HeaderBar> {
-    static matches(type: string): boolean;
-}
-export declare class HeaderBarNode extends PackContainerNode<Gtk.HeaderBar> {
-    static matches(type: string): boolean;
-}
 type PackPosition = "start" | "end";
 type PackSlotProps = {
     position: PackPosition;
@@ -39,4 +26,18 @@ export declare class PackEndNode extends PackSlotNode {
     protected readonly position: PackPosition;
     static matches(type: string): boolean;
 }
+export declare class PackContainerNode<T extends HeaderBarWidget> extends Node<T> implements PackContainer {
+    packStart(child: Gtk.Widget): void;
+    packEnd(child: Gtk.Widget): void;
+    removeFromPack(child: Gtk.Widget): void;
+    appendChild(child: Node): void;
+    insertBefore(child: Node, before: Node): void;
+    removeChild(child: Node): void;
+}
+export declare class AdwHeaderBarNode extends PackContainerNode<Adw.HeaderBar> {
+    static matches(type: string): boolean;
+}
+export declare class HeaderBarNode extends PackContainerNode<Gtk.HeaderBar> {
+    static matches(type: string): boolean;
+}
 export {};

package/dist/nodes/header-bar.js

@@ -1,41 +1,6 @@
-import { isPackContainer } from "../container-interfaces.js";
 import { Node } from "../node.js";
+import { isPackContainer } from "../predicates.js";
 import { VirtualSlotNode } from "./virtual-slot.js";
-export class PackContainerNode extends Node {
-    packStart(child) {
-        this.widget.packStart(child);
-    }
-    packEnd(child) {
-        this.widget.packEnd(child);
-    }
-    removeFromPack(child) {
-        this.widget.remove(child);
-    }
-    appendChild(child) {
-        const childWidget = child.getWidget();
-        if (!childWidget) {
-            child.attachToParent(this);
-            return;
-        }
-        this.packStart(childWidget);
-    }
-    removeChild(child) {
-        const childWidget = child.getWidget();
-        if (childWidget) {
-            this.removeFromPack(childWidget);
-        }
-    }
-}
-export class AdwHeaderBarNode extends PackContainerNode {
-    static matches(type) {
-        return type === "AdwHeaderBar" || type === "AdwHeaderBar.Root";
-    }
-}
-export class HeaderBarNode extends PackContainerNode {
-    static matches(type) {
-        return type === "HeaderBar" || type === "HeaderBar.Root";
-    }
-}
 class PackSlotNode extends VirtualSlotNode {
     isValidContainer(parent) {
         return isPackContainer(parent);
@@ -71,3 +36,81 @@ export class PackEndNode extends PackSlotNode {
         return type === "HeaderBar.End" || type === "AdwHeaderBar.End" || type === "ActionBar.End";
     }
 }
+export class PackContainerNode extends Node {
+    packStart(child) {
+        this.widget.packStart(child);
+    }
+    packEnd(child) {
+        this.widget.packEnd(child);
+    }
+    removeFromPack(child) {
+        this.widget.remove(child);
+    }
+    appendChild(child) {
+        if (child instanceof PackSlotNode) {
+            child.parent = this;
+            const childWidget = child.getChildWidget();
+            const props = child.getSlotProps();
+            if (childWidget) {
+                if (props.position === "start") {
+                    this.packStart(childWidget);
+                }
+                else {
+                    this.packEnd(childWidget);
+                }
+                child.setParentContainer(this);
+            }
+            return;
+        }
+        child.parent = this;
+        const childWidget = child.getWidget();
+        if (childWidget) {
+            this.packStart(childWidget);
+        }
+    }
+    insertBefore(child, before) {
+        if (child instanceof PackSlotNode) {
+            child.parent = this;
+            const childWidget = child.getChildWidget();
+            const props = child.getSlotProps();
+            if (childWidget) {
+                if (props.position === "start") {
+                    this.packStart(childWidget);
+                }
+                else {
+                    this.packEnd(childWidget);
+                }
+                child.setParentContainer(this);
+            }
+            return;
+        }
+        super.insertBefore(child, before);
+    }
+    removeChild(child) {
+        if (child instanceof PackSlotNode) {
+            const childWidget = child.getChildWidget();
+            if (childWidget) {
+                this.removeFromPack(childWidget);
+            }
+            child.unmount();
+            child.parent = null;
+            return;
+        }
+        child.unmount();
+        const childWidget = child.getWidget();
+        if (childWidget) {
+            this.removeFromPack(childWidget);
+        }
+        child.parent = null;
+    }
+}
+export class AdwHeaderBarNode extends PackContainerNode {
+    static matches(type) {
+        return type === "AdwHeaderBar" || type === "AdwHeaderBar.Root";
+    }
+}
+export class HeaderBarNode extends PackContainerNode {
+    static matches(type) {
+        return type === "HeaderBar" || type === "HeaderBar.Root";
+    }
+}

package/dist/nodes/indexed-child-container.d.ts

@@ -1,5 +1,5 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
-import type { ChildContainer } from "../container-interfaces.js";
+import type { ChildContainer } from "../containers.js";
 import { Node } from "../node.js";
 type IndexedWidget = Gtk.Widget & {
     append(child: Gtk.Widget): void;

package/dist/nodes/list-box.d.ts

@@ -3,4 +3,8 @@ import { IndexedChildContainerNode } from "./indexed-child-container.js";
 export declare class ListBoxNode extends IndexedChildContainerNode<Gtk.ListBox> {
     static matches(type: string): boolean;
     protected getInsertionIndex(before: Gtk.Widget): number;
+    private unparentFromRow;
+    attachChild(child: Gtk.Widget): void;
+    insertChildBefore(child: Gtk.Widget, before: Gtk.Widget): void;
+    detachChild(child: Gtk.Widget): void;
 }

package/dist/nodes/list-box.js

@@ -1,3 +1,4 @@
+import { beginBatch, endBatch } from "@gtkx/ffi";
 import { isListBoxRow } from "../predicates.js";
 import { IndexedChildContainerNode } from "./indexed-child-container.js";
 export class ListBoxNode extends IndexedChildContainerNode {
@@ -5,9 +6,43 @@ export class ListBoxNode extends IndexedChildContainerNode {
         return type === "ListBox";
     }
     getInsertionIndex(before) {
-        if (isListBoxRow(before)) {
-            return before.getIndex();
+        const beforeParent = before.getParent();
+        if (beforeParent && isListBoxRow(beforeParent)) {
+            return beforeParent.getIndex();
         }
         return -1;
     }
+    unparentFromRow(child) {
+        const parent = child.getParent();
+        if (parent && isListBoxRow(parent)) {
+            beginBatch();
+            parent.setChild(null);
+            this.widget.remove(parent);
+            endBatch();
+        }
+    }
+    attachChild(child) {
+        this.unparentFromRow(child);
+        this.widget.append(child);
+    }
+    insertChildBefore(child, before) {
+        this.unparentFromRow(child);
+        const index = this.getInsertionIndex(before);
+        if (index >= 0) {
+            this.widget.insert(child, index);
+        }
+        else {
+            this.widget.append(child);
+        }
+    }
+    detachChild(child) {
+        if (isListBoxRow(child)) {
+            beginBatch();
+            child.setChild(null);
+            this.widget.remove(child);
+            endBatch();
+            return;
+        }
+        this.unparentFromRow(child);
+    }
 }

package/dist/nodes/list-view.d.ts

@@ -1,6 +1,5 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { Props } from "../factory.js";
-import type { Node } from "../node.js";
 import type { RenderItemFn } from "../types.js";
 import { type ListItemFactoryHandlers, type ListItemInfo } from "./list-item-factory.js";
 import { SelectableListNode, type SelectableListState } from "./selectable-list.js";
@@ -15,7 +14,7 @@ export declare class ListViewNode extends SelectableListNode<Gtk.ListView | Gtk.
     static consumedPropNames: string[];
     static matches(type: string): boolean;
     initialize(props: Props): void;
-    detachFromParent(parent: Node): void;
+    unmount(): void;
     updateProps(oldProps: Props, newProps: Props): void;
 }
 export declare class ListItemNode extends VirtualItemNode {

package/dist/nodes/list-view.js

@@ -26,10 +26,10 @@ export class ListViewNode extends SelectableListNode {
         this.applySelectionModel();
         this.widget.setFactory(this.state.factory);
     }
-    detachFromParent(parent) {
+    unmount() {
         this.state.factoryHandlers?.disconnect();
         this.cleanupSelection();
-        super.detachFromParent(parent);
+        super.unmount();
     }
     updateProps(oldProps, newProps) {
         if (oldProps.renderItem !== newProps.renderItem) {

package/dist/nodes/menu.d.ts

@@ -1,7 +1,8 @@
 import * as Gio from "@gtkx/ffi/gio";
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { Props } from "../factory.js";
-import { Node } from "../node.js";
+import type { Node } from "../node.js";
+import { Node as NodeClass } from "../node.js";
 type MenuEntry = {
     type: "item" | "section" | "submenu";
     label?: string;
@@ -13,13 +14,24 @@ interface MenuContainer {
     addMenuEntry(entry: MenuEntry): void;
     removeMenuEntry(entry: MenuEntry): void;
 }
-declare abstract class MenuContainerNode<T extends Gtk.Widget | undefined> extends Node<T> implements MenuContainer {
+interface MenuEntryNode {
+    parent: Node | null;
+    getMenuEntry(): MenuEntry;
+    setParentContainer(container: Node & MenuContainer): void;
+    onAttach(): void;
+    onDetach(): void;
+    unmount(): void;
+}
+declare abstract class MenuContainerNode<T extends Gtk.Widget | undefined> extends NodeClass<T> implements MenuContainer {
     protected menu: Gio.Menu;
     protected entries: MenuEntry[];
     private rebuildScheduled;
     getMenu(): Gio.Menu;
     addMenuEntry(entry: MenuEntry): void;
     removeMenuEntry(entry: MenuEntry): void;
+    appendChild(child: Node): void;
+    insertBefore(child: Node, before: Node): void;
+    removeChild(child: Node): void;
     private scheduleRebuild;
     protected rebuildMenu(): void;
     protected onMenuRebuilt(): void;
@@ -43,12 +55,11 @@ export declare class PopoverMenuBarNode extends MenuWidgetNode<Gtk.PopoverMenuBa
 export declare class ApplicationMenuNode extends MenuContainerNode<never> {
     static matches(type: string): boolean;
     protected isVirtual(): boolean;
-    detachFromParent(_parent: Node): void;
-    attachToParent(parent: Node): void;
     mount(): void;
+    unmount(): void;
     protected onMenuRebuilt(): void;
 }
-export declare class MenuItemNode extends Node<never> {
+export declare class MenuItemNode extends NodeClass<never> implements MenuEntryNode {
     static consumedPropNames: string[];
     static matches(type: string): boolean;
     protected isVirtual(): boolean;
@@ -58,10 +69,13 @@ export declare class MenuItemNode extends Node<never> {
     private signalHandlerId;
     private onActivateCallback;
     private currentAccels;
-    private isAttached;
+    private parentContainer;
     initialize(props: Props): void;
-    attachToParent(parent: Node): void;
-    detachFromParent(parent: Node): void;
+    getMenuEntry(): MenuEntry;
+    setParentContainer(container: Node & MenuContainer): void;
+    onAttach(): void;
+    onDetach(): void;
+    unmount(): void;
     private isFieldInitializationIncomplete;
     updateProps(oldProps: Props, newProps: Props): void;
     private invokeCurrentCallback;
@@ -69,7 +83,7 @@ export declare class MenuItemNode extends Node<never> {
     private cleanupAction;
     private updateAccels;
 }
-declare class MenuContainerItemNode extends MenuContainerNode<never> {
+declare class MenuContainerItemNode extends MenuContainerNode<never> implements MenuEntryNode {
     static consumedPropNames: string[];
     protected entryType: "section" | "submenu";
     protected matchType: string;
@@ -77,8 +91,10 @@ declare class MenuContainerItemNode extends MenuContainerNode<never> {
     protected isVirtual(): boolean;
     private entry;
     initialize(props: Props): void;
-    attachToParent(parent: Node): void;
-    detachFromParent(parent: Node): void;
+    getMenuEntry(): MenuEntry;
+    setParentContainer(_container: Node & MenuContainer): void;
+    onAttach(): void;
+    onDetach(): void;
     updateProps(oldProps: Props, newProps: Props): void;
 }
 export declare class MenuSectionNode extends MenuContainerItemNode {

package/dist/nodes/menu.js

@@ -2,12 +2,12 @@ import { getCurrentApp, getInterface } from "@gtkx/ffi";
 import * as Gio from "@gtkx/ffi/gio";
 import * as GObject from "@gtkx/ffi/gobject";
 import * as Gtk from "@gtkx/ffi/gtk";
-import { Node } from "../node.js";
+import { Node as NodeClass } from "../node.js";
 import { RootNode } from "./root.js";
 let actionCounter = 0;
 const generateActionName = () => `gtkx_menu_action_${actionCounter++}`;
-const isMenuContainer = (node) => "getMenu" in node && "addMenuEntry" in node && "removeMenuEntry" in node;
-class MenuContainerNode extends Node {
+const isMenuEntryNode = (node) => "getMenuEntry" in node && "setParentContainer" in node;
+class MenuContainerNode extends NodeClass {
     menu = new Gio.Menu();
     entries = [];
     rebuildScheduled = false;
@@ -25,6 +25,35 @@ class MenuContainerNode extends Node {
             this.scheduleRebuild();
         }
     }
+    appendChild(child) {
+        if (isMenuEntryNode(child)) {
+            child.parent = this;
+            child.onAttach();
+            this.addMenuEntry(child.getMenuEntry());
+            child.setParentContainer(this);
+            return;
+        }
+        super.appendChild(child);
+    }
+    insertBefore(child, before) {
+        if (isMenuEntryNode(child)) {
+            child.parent = this;
+            child.onAttach();
+            this.addMenuEntry(child.getMenuEntry());
+            child.setParentContainer(this);
+            return;
+        }
+        super.insertBefore(child, before);
+    }
+    removeChild(child) {
+        if (isMenuEntryNode(child)) {
+            this.removeMenuEntry(child.getMenuEntry());
+            child.unmount();
+            child.parent = null;
+            return;
+        }
+        super.removeChild(child);
+    }
     scheduleRebuild() {
         if (this.rebuildScheduled)
             return;
@@ -83,22 +112,21 @@ export class ApplicationMenuNode extends MenuContainerNode {
     isVirtual() {
         return true;
     }
-    detachFromParent(_parent) {
-        getCurrentApp().setMenubar(null);
-    }
-    attachToParent(parent) {
-        if (!(parent instanceof RootNode)) {
+    mount() {
+        if (!(this.parent instanceof RootNode)) {
             throw new Error("ApplicationMenu must be a direct child of a fragment at the root level");
         }
-    }
-    mount() {
         getCurrentApp().setMenubar(this.menu);
     }
+    unmount() {
+        getCurrentApp().setMenubar(null);
+        super.unmount();
+    }
     onMenuRebuilt() {
         getCurrentApp().setMenubar(this.menu);
     }
 }
-export class MenuItemNode extends Node {
+export class MenuItemNode extends NodeClass {
     static consumedPropNames = ["label", "onActivate", "accels"];
     static matches(type) {
         return type === "Menu.Item";
@@ -112,26 +140,29 @@ export class MenuItemNode extends Node {
     signalHandlerId = null;
     onActivateCallback;
     currentAccels;
-    isAttached = false;
+    parentContainer = null;
     initialize(props) {
         this.onActivateCallback = props.onActivate;
         this.currentAccels = props.accels;
         this.entry.label = props.label;
         super.initialize(props);
     }
-    attachToParent(parent) {
-        if (!isMenuContainer(parent))
-            return;
-        this.isAttached = true;
+    getMenuEntry() {
+        return this.entry;
+    }
+    setParentContainer(container) {
+        this.parentContainer = container;
+    }
+    onAttach() {
         this.setupAction();
-        parent.addMenuEntry(this.entry);
     }
-    detachFromParent(parent) {
-        if (!isMenuContainer(parent))
-            return;
-        parent.removeMenuEntry(this.entry);
+    onDetach() {
+        this.cleanupAction();
+    }
+    unmount() {
         this.cleanupAction();
-        this.isAttached = false;
+        this.parentContainer = null;
+        super.unmount();
     }
     isFieldInitializationIncomplete() {
         return !this.entry;
@@ -149,7 +180,7 @@ export class MenuItemNode extends Node {
         if (labelChanged) {
             this.entry.label = newProps.label;
         }
-        if (this.isAttached && callbackPresenceChanged) {
+        if (this.parentContainer && callbackPresenceChanged) {
             this.cleanupAction();
             this.setupAction();
         }
@@ -219,16 +250,12 @@ class MenuContainerItemNode extends MenuContainerNode {
         this.entry.label = props.label;
         super.initialize(props);
     }
-    attachToParent(parent) {
-        if (!isMenuContainer(parent))
-            return;
-        parent.addMenuEntry(this.entry);
-    }
-    detachFromParent(parent) {
-        if (!isMenuContainer(parent))
-            return;
-        parent.removeMenuEntry(this.entry);
+    getMenuEntry() {
+        return this.entry;
     }
+    setParentContainer(_container) { }
+    onAttach() { }
+    onDetach() { }
     updateProps(oldProps, newProps) {
         if (oldProps.label !== newProps.label && this.entry) {
             this.entry.label = newProps.label;

package/dist/nodes/notebook.d.ts

@@ -1,5 +1,5 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { type ChildContainer, type PageContainer } from "../container-interfaces.js";
+import type { ChildContainer, PageContainer } from "../containers.js";
 import type { Props } from "../factory.js";
 import { Node } from "../node.js";
 import { VirtualSlotNode } from "./virtual-slot.js";
@@ -12,6 +12,9 @@ export declare class NotebookNode extends Node<Gtk.Notebook> implements PageCont
     attachChild(child: Gtk.Widget): void;
     insertChildBefore(child: Gtk.Widget, before: Gtk.Widget): void;
     detachChild(child: Gtk.Widget): void;
+    appendChild(child: Node): void;
+    insertBefore(child: Node, before: Node): void;
+    removeChild(child: Node): void;
 }
 type NotebookPageProps = {
     label: string;

package/dist/nodes/notebook.js

@@ -1,6 +1,6 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { isPageContainer } from "../container-interfaces.js";
 import { Node } from "../node.js";
+import { isPageContainer } from "../predicates.js";
 import { VirtualSlotNode } from "./virtual-slot.js";
 export class NotebookNode extends Node {
     static matches(type) {
@@ -48,6 +48,50 @@ export class NotebookNode extends Node {
     detachChild(child) {
         this.removePage(child);
     }
+    appendChild(child) {
+        if (child instanceof NotebookPageNode) {
+            child.parent = this;
+            const childWidget = child.getChildWidget();
+            const props = child.getSlotProps();
+            if (childWidget) {
+                this.addPage(childWidget, props.label);
+                child.setParentContainer(this);
+            }
+            return;
+        }
+        super.appendChild(child);
+    }
+    insertBefore(child, before) {
+        if (child instanceof NotebookPageNode) {
+            child.parent = this;
+            const childWidget = child.getChildWidget();
+            const props = child.getSlotProps();
+            if (childWidget) {
+                const beforeWidget = child.getBeforeWidget(before);
+                if (beforeWidget) {
+                    this.insertPageBefore(childWidget, props.label, beforeWidget);
+                }
+                else {
+                    this.addPage(childWidget, props.label);
+                }
+                child.setParentContainer(this);
+            }
+            return;
+        }
+        super.insertBefore(child, before);
+    }
+    removeChild(child) {
+        if (child instanceof NotebookPageNode) {
+            const childWidget = child.getChildWidget();
+            if (childWidget) {
+                this.removePage(childWidget);
+            }
+            child.unmount();
+            child.parent = null;
+            return;
+        }
+        super.removeChild(child);
+    }
 }
 export class NotebookPageNode extends VirtualSlotNode {
     static consumedPropNames = ["label"];

package/dist/nodes/overlay.d.ts

@@ -1,5 +1,5 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
-import type { ChildContainer } from "../container-interfaces.js";
+import type { ChildContainer } from "../containers.js";
 import { Node } from "../node.js";
 export declare class OverlayNode extends Node<Gtk.Overlay> implements ChildContainer {
     static matches(type: string): boolean;

package/dist/nodes/paged-stack.d.ts

@@ -1,7 +1,8 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
-import type { ChildContainer, StackPageContainer, StackPageProps } from "../container-interfaces.js";
+import type { ChildContainer, StackPageContainer, StackPageProps } from "../containers.js";
 import type { Props } from "../factory.js";
-import { Node } from "../node.js";
+import type { Node } from "../node.js";
+import { Node as NodeClass } from "../node.js";
 import { type StackPageLike } from "./stack-page-props.js";
 type StackWidget = Gtk.Widget & {
     getChildByName(name: string): Gtk.Widget | null;
@@ -13,7 +14,7 @@ type StackWidget = Gtk.Widget & {
  * Abstract node for paged stack widgets (Gtk.Stack, Adw.ViewStack).
  * Handles visible child deferral and common page operations.
  */
-export declare abstract class PagedStackNode<T extends StackWidget> extends Node<T> implements StackPageContainer, ChildContainer {
+export declare abstract class PagedStackNode<T extends StackWidget> extends NodeClass<T> implements StackPageContainer, ChildContainer {
     static consumedPropNames: string[];
     private pendingVisibleChildName;
     /**
@@ -34,6 +35,9 @@ export declare abstract class PagedStackNode<T extends StackWidget> extends Node
     insertChildBefore(child: Gtk.Widget, _before: Gtk.Widget): void;
     detachChild(child: Gtk.Widget): void;
     private setVisibleChildOrDefer;
+    appendChild(child: Node): void;
+    insertBefore(child: Node, before: Node): void;
+    removeChild(child: Node): void;
     updateProps(oldProps: Props, newProps: Props): void;
 }
 export {};