@gtkx/react 0.8.0 → 0.9.1

package/dist/nodes/paged-stack.js

@@ -1,10 +1,11 @@
-import { Node } from "../node.js";
+import { Node as NodeClass } from "../node.js";
+import { StackPageNode } from "./stack.js";
 import { applyStackPageProps } from "./stack-page-props.js";
 /**
  * Abstract node for paged stack widgets (Gtk.Stack, Adw.ViewStack).
  * Handles visible child deferral and common page operations.
  */
-export class PagedStackNode extends Node {
+export class PagedStackNode extends NodeClass {
     static consumedPropNames = ["visibleChildName"];
     pendingVisibleChildName = null;
     applyPendingVisibleChild() {
@@ -45,6 +46,50 @@ export class PagedStackNode extends Node {
             this.pendingVisibleChildName = name;
         }
     }
+    appendChild(child) {
+        if (child instanceof StackPageNode) {
+            child.parent = this;
+            const childWidget = child.getChildWidget();
+            const props = child.getSlotProps();
+            if (childWidget) {
+                this.addStackPage(childWidget, props);
+                child.setParentContainer(this);
+            }
+            return;
+        }
+        super.appendChild(child);
+    }
+    insertBefore(child, before) {
+        if (child instanceof StackPageNode) {
+            child.parent = this;
+            const childWidget = child.getChildWidget();
+            const props = child.getSlotProps();
+            if (childWidget) {
+                const beforeWidget = child.getBeforeWidget(before);
+                if (beforeWidget) {
+                    this.insertStackPageBefore(childWidget, props, beforeWidget);
+                }
+                else {
+                    this.addStackPage(childWidget, props);
+                }
+                child.setParentContainer(this);
+            }
+            return;
+        }
+        super.insertBefore(child, before);
+    }
+    removeChild(child) {
+        if (child instanceof StackPageNode) {
+            const childWidget = child.getChildWidget();
+            if (childWidget) {
+                this.removeStackPage(childWidget);
+            }
+            child.unmount();
+            child.parent = null;
+            return;
+        }
+        super.removeChild(child);
+    }
     updateProps(oldProps, newProps) {
         if (newProps.visibleChildName !== undefined) {
             this.setVisibleChildOrDefer(newProps.visibleChildName);

package/dist/nodes/root.d.ts

@@ -2,7 +2,7 @@ import type * as Gtk from "@gtkx/ffi/gtk";
 import { Node } from "../node.js";
 export declare const ROOT_NODE_CONTAINER: unique symbol;
 export declare class RootNode extends Node<never> {
-    static matches(_type: string, existingWidget?: Gtk.Widget | typeof ROOT_NODE_CONTAINER): boolean;
+    static matches(_type: string, widget?: Gtk.Widget | typeof ROOT_NODE_CONTAINER): boolean;
     protected isVirtual(): boolean;
     constructor();
 }

package/dist/nodes/root.js

@@ -1,8 +1,8 @@
 import { Node } from "../node.js";
 export const ROOT_NODE_CONTAINER = Symbol.for("ROOT_NODE_CONTAINER");
 export class RootNode extends Node {
-    static matches(_type, existingWidget) {
-        return existingWidget === ROOT_NODE_CONTAINER;
+    static matches(_type, widget) {
+        return widget === ROOT_NODE_CONTAINER;
     }
     isVirtual() {
         return true;

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

@@ -1,7 +1,8 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import type { ItemContainer } from "../container-interfaces.js";
+import type { ItemContainer } 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";
 export type SelectableListState = {
     itemsById: Map<string, unknown>;
     itemOrder: string[];
@@ -18,7 +19,10 @@ export type SelectableListState = {
 type SelectableListWidget = Gtk.Widget & {
     setModel(model: Gtk.SelectionModel): void;
 };
-export declare abstract class SelectableListNode<T extends SelectableListWidget, S extends SelectableListState> extends Node<T, S> implements ItemContainer<unknown> {
+export declare abstract class SelectableListNode<T extends SelectableListWidget, S extends SelectableListState> extends NodeClass<T, S> implements ItemContainer<unknown> {
+    appendChild(child: Node): void;
+    insertBefore(child: Node, before: Node): void;
+    removeChild(child: Node): void;
     protected initializeSelectionState(props: Props): SelectableListState;
     protected applySelectionModel(): void;
     protected cleanupSelection(): void;

package/dist/nodes/selectable-list.js

@@ -1,15 +1,47 @@
-import { getInterface } from "@gtkx/ffi";
+import { getObject } 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 { scheduleFlush } from "../batch.js";
-import { Node } from "../node.js";
+import { Node as NodeClass } from "../node.js";
 import { getCallbackChange } from "../props.js";
-export class SelectableListNode extends Node {
+import { VirtualItemNode } from "./virtual-item.js";
+export class SelectableListNode extends NodeClass {
+    appendChild(child) {
+        if (child instanceof VirtualItemNode) {
+            child.parent = this;
+            child.addToContainer(this);
+            child.setParentContainer(this);
+            return;
+        }
+        super.appendChild(child);
+    }
+    insertBefore(child, before) {
+        if (child instanceof VirtualItemNode) {
+            child.parent = this;
+            if (before instanceof VirtualItemNode) {
+                child.insertBeforeInContainer(this, before.getId());
+            }
+            else {
+                child.addToContainer(this);
+            }
+            child.setParentContainer(this);
+            return;
+        }
+        super.insertBefore(child, before);
+    }
+    removeChild(child) {
+        if (child instanceof VirtualItemNode) {
+            child.unmount();
+            child.parent = null;
+            return;
+        }
+        super.removeChild(child);
+    }
     initializeSelectionState(props) {
         const selectionMode = props.selectionMode ?? Gtk.SelectionMode.SINGLE;
         const stringList = new Gtk.StringList([]);
-        const listModel = getInterface(stringList.id, Gio.ListModel);
+        const listModel = getObject(stringList.id, Gio.ListModel) ?? undefined;
         const selectionModel = selectionMode === Gtk.SelectionMode.MULTIPLE
             ? new Gtk.MultiSelection(listModel)
             : new Gtk.SingleSelection(listModel);
@@ -68,7 +100,7 @@ export class SelectableListNode extends Node {
         const currentSelection = this.getSelectedIds();
         const hadHandler = this.state.selectionHandlerId !== null;
         this.disconnectSelectionHandler();
-        const listModel = getInterface(this.state.stringList.id, Gio.ListModel);
+        const listModel = getObject(this.state.stringList.id, Gio.ListModel) ?? undefined;
         const newSelectionModel = newSelectionMode === Gtk.SelectionMode.MULTIPLE
             ? new Gtk.MultiSelection(listModel)
             : new Gtk.SingleSelection(listModel);

package/dist/nodes/slot.d.ts

@@ -4,11 +4,10 @@ export declare class SlotNode extends Node<never> {
     protected isVirtual(): boolean;
     private child;
     private slotName;
-    private parentNode;
     constructor(type: string);
     private updateParentSlot;
     appendChild(child: Node): void;
-    removeChild(_child: Node): void;
-    attachToParent(parent: Node): void;
-    detachFromParent(_parent: Node): void;
+    removeChild(child: Node): void;
+    mount(): void;
+    unmount(): void;
 }

package/dist/nodes/slot.js

@@ -14,7 +14,6 @@ export class SlotNode extends Node {
     }
     child = null;
     slotName;
-    parentNode = null;
     constructor(type) {
         super(type);
         const dotIndex = type.indexOf(".");
@@ -24,9 +23,9 @@ export class SlotNode extends Node {
         this.slotName = type.substring(dotIndex + 1);
     }
     updateParentSlot() {
-        if (!this.parentNode)
+        if (!this.parent)
             return;
-        const parentWidget = this.parentNode.getWidget();
+        const parentWidget = this.parent.getWidget();
         const childWidget = this.child?.getWidget();
         if (!parentWidget)
             return;
@@ -37,22 +36,24 @@ export class SlotNode extends Node {
         }
     }
     appendChild(child) {
+        child.parent = this;
         if (child.getWidget()) {
             this.child = child;
             this.updateParentSlot();
         }
     }
-    removeChild(_child) {
+    removeChild(child) {
+        child.unmount();
         this.child = null;
         this.updateParentSlot();
+        child.parent = null;
     }
-    attachToParent(parent) {
-        this.parentNode = parent;
+    mount() {
         this.updateParentSlot();
     }
-    detachFromParent(_parent) {
-        if (this.parentNode) {
-            const parentWidget = this.parentNode.getWidget();
+    unmount() {
+        if (this.parent) {
+            const parentWidget = this.parent.getWidget();
             if (parentWidget) {
                 const setterName = `set${this.slotName}`;
                 const setter = parentWidget[setterName];
@@ -61,6 +62,6 @@ export class SlotNode extends Node {
                 }
             }
         }
-        this.parentNode = null;
+        super.unmount();
     }
 }

package/dist/nodes/stack-page-props.d.ts

@@ -1,4 +1,4 @@
-import type { StackPageProps } from "../container-interfaces.js";
+import type { StackPageProps } from "../containers.js";
 export type StackPageLike = {
     setName(name: string): void;
     setTitle(title: string): void;

package/dist/nodes/stack.d.ts

@@ -1,5 +1,5 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
-import { type StackPageContainer, type StackPageProps } from "../container-interfaces.js";
+import type { StackPageContainer, StackPageProps } from "../containers.js";
 import type { Props } from "../factory.js";
 import type { Node } from "../node.js";
 import { PagedStackNode } from "./paged-stack.js";

package/dist/nodes/stack.js

@@ -1,4 +1,4 @@
-import { isStackPageContainer } from "../container-interfaces.js";
+import { isStackPageContainer } from "../predicates.js";
 import { PagedStackNode } from "./paged-stack.js";
 import { applyStackPageProps } from "./stack-page-props.js";
 import { VirtualSlotNode } from "./virtual-slot.js";
@@ -11,7 +11,7 @@ export class StackNode extends PagedStackNode {
         const { name, title } = props;
         let stackPage;
         if (title !== undefined) {
-            stackPage = this.widget.addTitled(child, title, name ?? null);
+            stackPage = this.widget.addTitled(child, title, name);
         }
         else if (name !== undefined) {
             stackPage = this.widget.addNamed(child, name);

package/dist/nodes/string-list-container.d.ts

@@ -1,20 +1,10 @@
 import * as Gio from "@gtkx/ffi/gio";
 import type * as Gtk from "@gtkx/ffi/gtk";
+import type { StringListContainer } from "../containers.js";
 import type { Props } from "../factory.js";
 import type { Node } from "../node.js";
 import { Node as NodeClass } from "../node.js";
 import { StringListStore } from "./string-list-store.js";
-export type StringListItem = {
-    id: string;
-    label: string;
-};
-type StringListContainer = {
-    addStringListItem(id: string, label: string): void;
-    insertStringListItemBefore(id: string, label: string, beforeId: string): void;
-    removeStringListItem(id: string): void;
-    updateStringListItem(oldId: string, newId: string, newLabel: string): void;
-};
-export declare const isStringListContainer: (node: Node) => node is Node & StringListContainer;
 type StringListContainerState = {
     store: StringListStore;
     onSelectionChanged?: (id: string) => void;
@@ -22,12 +12,15 @@ type StringListContainerState = {
     hasAppliedInitialSelection: boolean;
 };
 type StringListWidget = Gtk.Widget & {
-    setModel(model: Gio.ListModel | null): void;
+    setModel(model?: Gio.ListModel): void;
     getSelected(): number;
     setSelected(position: number): void;
 };
 export declare abstract class StringListContainerNode<T extends StringListWidget> extends NodeClass<T, StringListContainerState> implements StringListContainer {
     static consumedPropNames: string[];
+    appendChild(child: Node): void;
+    insertBefore(child: Node, before: Node): void;
+    removeChild(child: Node): void;
     initialize(props: Props): void;
     private connectSelectionHandler;
     addStringListItem(id: string, label: string): void;

package/dist/nodes/string-list-container.js

@@ -1,22 +1,50 @@
-import { getInterface } from "@gtkx/ffi";
+import { getObject } from "@gtkx/ffi";
 import * as Gio from "@gtkx/ffi/gio";
 import { Node as NodeClass } from "../node.js";
 import { getCallbackChange } from "../props.js";
+import { StringListItemNode } from "./string-list-item.js";
 import { StringListStore } from "./string-list-store.js";
-export const isStringListContainer = (node) => "addStringListItem" in node &&
-    "insertStringListItemBefore" in node &&
-    "removeStringListItem" in node &&
-    "updateStringListItem" in node;
 const SELECTION_SIGNAL = "notify::selected";
 export class StringListContainerNode extends NodeClass {
     static consumedPropNames = ["onSelectionChanged", "selectedId"];
+    appendChild(child) {
+        if (child instanceof StringListItemNode) {
+            child.parent = this;
+            child.addToContainer(this);
+            child.setParentContainer(this);
+            return;
+        }
+        super.appendChild(child);
+    }
+    insertBefore(child, before) {
+        if (child instanceof StringListItemNode) {
+            child.parent = this;
+            if (before instanceof StringListItemNode) {
+                child.insertBeforeInContainer(this, before.getId());
+            }
+            else {
+                child.addToContainer(this);
+            }
+            child.setParentContainer(this);
+            return;
+        }
+        super.insertBefore(child, before);
+    }
+    removeChild(child) {
+        if (child instanceof StringListItemNode) {
+            child.unmount();
+            child.parent = null;
+            return;
+        }
+        super.removeChild(child);
+    }
     initialize(props) {
         const store = new StringListStore();
         const onSelectionChanged = props.onSelectionChanged;
         const initialSelection = props.selectedId;
         this.state = { store, onSelectionChanged, initialSelection, hasAppliedInitialSelection: false };
         super.initialize(props);
-        this.widget.setModel(getInterface(store.getModel().id, Gio.ListModel));
+        this.widget.setModel(getObject(store.getModel().id, Gio.ListModel) ?? undefined);
     }
     connectSelectionHandler() {
         const handler = () => {

package/dist/nodes/string-list-item.d.ts

@@ -1,15 +1,19 @@
+import type { StringListContainer, StringListItem } from "../containers.js";
 import type { Props } from "../factory.js";
-import { Node } from "../node.js";
-import { type StringListItem } from "./string-list-container.js";
-export declare abstract class StringListItemNode extends Node<never> {
+import type { Node } from "../node.js";
+import { Node as NodeClass } from "../node.js";
+export declare abstract class StringListItemNode extends NodeClass<never> {
     static consumedPropNames: string[];
     protected isVirtual(): boolean;
     private id;
     private label;
+    private parentContainer;
     initialize(props: Props): void;
+    getId(): string;
     getStringListItem(): StringListItem;
-    attachToParent(parent: Node): void;
-    attachToParentBefore(parent: Node, before: Node): void;
-    detachFromParent(parent: Node): void;
+    setParentContainer(container: Node & StringListContainer): void;
+    addToContainer(container: StringListContainer): void;
+    insertBeforeInContainer(container: StringListContainer, beforeId: string): void;
+    unmount(): void;
     updateProps(oldProps: Props, newProps: Props): void;
 }

package/dist/nodes/string-list-item.js

@@ -1,37 +1,39 @@
-import { Node } from "../node.js";
-import { isStringListContainer } from "./string-list-container.js";
-export class StringListItemNode extends Node {
+import { Node as NodeClass } from "../node.js";
+import { isStringListContainer } from "../predicates.js";
+export class StringListItemNode extends NodeClass {
     static consumedPropNames = ["id", "label"];
     isVirtual() {
         return true;
     }
     id = "";
     label = "";
+    parentContainer = null;
     initialize(props) {
         this.id = props.id;
         this.label = props.label;
         super.initialize(props);
     }
+    getId() {
+        return this.id;
+    }
     getStringListItem() {
         return { id: this.id, label: this.label };
     }
-    attachToParent(parent) {
-        if (isStringListContainer(parent)) {
-            parent.addStringListItem(this.id, this.label);
-        }
+    setParentContainer(container) {
+        this.parentContainer = container;
     }
-    attachToParentBefore(parent, before) {
-        if (isStringListContainer(parent) && before instanceof StringListItemNode) {
-            parent.insertStringListItemBefore(this.id, this.label, before.id);
-        }
-        else {
-            this.attachToParent(parent);
-        }
+    addToContainer(container) {
+        container.addStringListItem(this.id, this.label);
+    }
+    insertBeforeInContainer(container, beforeId) {
+        container.insertStringListItemBefore(this.id, this.label, beforeId);
     }
-    detachFromParent(parent) {
-        if (isStringListContainer(parent)) {
-            parent.removeStringListItem(this.id);
+    unmount() {
+        if (this.parentContainer) {
+            this.parentContainer.removeStringListItem(this.id);
         }
+        this.parentContainer = null;
+        super.unmount();
     }
     updateProps(oldProps, newProps) {
         const oldId = oldProps.id;

package/dist/nodes/toggle-button.d.ts

@@ -16,9 +16,6 @@ export declare class ToggleButtonNode extends Node<Gtk.ToggleButton, ToggleButto
     static consumedPropNames: string[];
     static matches(type: string): boolean;
     initialize(props: Props): void;
-    attachToParent(parent: Node): void;
-    attachToParentBefore(parent: Node, before: Node): void;
-    detachFromParent(parent: Node): void;
     updateProps(_oldProps: Props, newProps: Props): void;
     protected connectSignal(widget: Gtk.Widget, eventName: string, handler: (...args: unknown[]) => unknown): void;
 }

package/dist/nodes/toggle-button.js

@@ -1,4 +1,3 @@
-import { isChildContainer } from "../container-interfaces.js";
 import { Node } from "../node.js";
 /**
  * Specialized node for GtkToggleButton that prevents signal feedback loops.
@@ -17,33 +16,6 @@ export class ToggleButtonNode extends Node {
         this.state = { lastPropsActive: undefined };
         super.initialize(props);
     }
-    attachToParent(parent) {
-        if (isChildContainer(parent)) {
-            parent.attachChild(this.widget);
-            return;
-        }
-        super.attachToParent(parent);
-    }
-    attachToParentBefore(parent, before) {
-        if (isChildContainer(parent)) {
-            const beforeWidget = before.getWidget();
-            if (beforeWidget) {
-                parent.insertChildBefore(this.widget, beforeWidget);
-            }
-            else {
-                parent.attachChild(this.widget);
-            }
-            return;
-        }
-        super.attachToParentBefore(parent, before);
-    }
-    detachFromParent(parent) {
-        if (isChildContainer(parent)) {
-            parent.detachChild(this.widget);
-            return;
-        }
-        super.detachFromParent(parent);
-    }
     updateProps(_oldProps, newProps) {
         const widget = this.getWidget();
         if (!widget) {

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

@@ -7,13 +7,12 @@ export declare class ToolbarViewSlotNode extends Node<never> {
     static matches(type: string): boolean;
     protected isVirtual(): boolean;
     private slotType;
-    private parentNode;
     private children;
     constructor(type: string);
     appendChild(child: Node): void;
     removeChild(child: Node): void;
-    attachToParent(parent: Node): void;
-    detachFromParent(_parent: Node): void;
+    mount(): void;
+    unmount(): void;
     private addBarToParent;
     private removeBarFromParent;
 }

package/dist/nodes/toolbar-view.js

@@ -14,7 +14,6 @@ export class ToolbarViewSlotNode extends Node {
         return true;
     }
     slotType;
-    parentNode = null;
     children = [];
     constructor(type) {
         super(type);
@@ -25,26 +24,28 @@ export class ToolbarViewSlotNode extends Node {
         this.slotType = slot;
     }
     appendChild(child) {
+        child.parent = this;
         const childWidget = child.getWidget();
         if (!childWidget)
             return;
         this.children.push(child);
-        if (this.parentNode) {
+        if (this.parent) {
             this.addBarToParent(childWidget);
         }
     }
     removeChild(child) {
+        child.unmount();
         const index = this.children.indexOf(child);
         if (index !== -1) {
             this.children.splice(index, 1);
         }
         const childWidget = child.getWidget();
-        if (this.parentNode && childWidget) {
+        if (this.parent && childWidget) {
             this.removeBarFromParent(childWidget);
         }
+        child.parent = null;
     }
-    attachToParent(parent) {
-        this.parentNode = parent;
+    mount() {
         for (const child of this.children) {
             const childWidget = child.getWidget();
             if (childWidget) {
@@ -52,17 +53,17 @@ export class ToolbarViewSlotNode extends Node {
             }
         }
     }
-    detachFromParent(_parent) {
+    unmount() {
         for (const child of this.children) {
             const childWidget = child.getWidget();
             if (childWidget) {
                 this.removeBarFromParent(childWidget);
             }
         }
-        this.parentNode = null;
+        super.unmount();
     }
     addBarToParent(childWidget) {
-        const parentWidget = this.parentNode?.getWidget();
+        const parentWidget = this.parent?.getWidget();
         if (!parentWidget)
             return;
         if (this.slotType === "Top") {
@@ -73,7 +74,7 @@ export class ToolbarViewSlotNode extends Node {
         }
     }
     removeBarFromParent(childWidget) {
-        const parentWidget = this.parentNode?.getWidget();
+        const parentWidget = this.parent?.getWidget();
         if (!parentWidget)
             return;
         parentWidget.remove(childWidget);

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

@@ -1,6 +1,6 @@
 import type * as Adw from "@gtkx/ffi/adw";
 import type * as Gtk from "@gtkx/ffi/gtk";
-import type { StackPageProps } from "../container-interfaces.js";
+import type { StackPageProps } from "../containers.js";
 import { PagedStackNode } from "./paged-stack.js";
 export declare class ViewStackNode extends PagedStackNode<Adw.ViewStack> {
     static matches(type: string): boolean;

package/dist/nodes/view-stack.js

@@ -8,10 +8,10 @@ export class ViewStackNode extends PagedStackNode {
         const { name, title, iconName } = props;
         let page;
         if (title !== undefined && iconName !== undefined) {
-            page = this.widget.addTitledWithIcon(child, title, iconName, name ?? null);
+            page = this.widget.addTitledWithIcon(child, title, iconName, name);
         }
         else if (title !== undefined) {
-            page = this.widget.addTitled(child, title, name ?? null);
+            page = this.widget.addTitled(child, title, name);
         }
         else if (name !== undefined) {
             page = this.widget.addNamed(child, name);

package/dist/nodes/virtual-item.d.ts

@@ -1,20 +1,24 @@
+import type { ItemContainer } 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";
 /**
  * Base class for virtual item nodes used in list-based containers.
  * Virtual nodes don't create GTK widgets directly but represent items
  * in list models (ListView, GridView, ColumnView).
  */
-export declare abstract class VirtualItemNode extends Node<never> {
+export declare abstract class VirtualItemNode extends NodeClass<never> {
     static consumedPropNames: string[];
     protected isVirtual(): boolean;
     private id;
     private item;
+    private parentContainer;
     initialize(props: Props): void;
     getId(): string;
     getItem(): unknown;
-    attachToParent(parent: Node): void;
-    attachToParentBefore(parent: Node, before: Node): void;
-    detachFromParent(parent: Node): void;
+    setParentContainer(container: Node & ItemContainer<unknown>): void;
+    addToContainer(container: ItemContainer<unknown>): void;
+    insertBeforeInContainer(container: ItemContainer<unknown>, beforeId: string): void;
+    unmount(): void;
     updateProps(oldProps: Props, newProps: Props): void;
 }