@gtkx/react 0.8.0 → 0.9.0

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";

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;
@@ -28,6 +18,9 @@ type StringListWidget = Gtk.Widget & {
 };
 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

@@ -2,14 +2,42 @@ import { getInterface } 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;

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/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;
 }

package/dist/nodes/virtual-item.js

@@ -1,20 +1,18 @@
-import { isItemContainer } from "../container-interfaces.js";
-import { Node } from "../node.js";
-const hasGetId = (node) => {
-    return typeof node.getId === "function";
-};
+import { Node as NodeClass } from "../node.js";
+import { isItemContainer } from "../predicates.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 class VirtualItemNode extends Node {
+export class VirtualItemNode extends NodeClass {
     static consumedPropNames = ["id", "item"];
     isVirtual() {
         return true;
     }
     id = "";
     item;
+    parentContainer = null;
     initialize(props) {
         this.id = props.id;
         this.item = props.item;
@@ -26,23 +24,21 @@ export class VirtualItemNode extends Node {
     getItem() {
         return this.item;
     }
-    attachToParent(parent) {
-        if (isItemContainer(parent)) {
-            parent.addItem(this.id, this.item);
-        }
+    setParentContainer(container) {
+        this.parentContainer = container;
     }
-    attachToParentBefore(parent, before) {
-        if (isItemContainer(parent) && hasGetId(before)) {
-            parent.insertItemBefore(this.id, this.item, before.getId());
-        }
-        else {
-            this.attachToParent(parent);
-        }
+    addToContainer(container) {
+        container.addItem(this.id, this.item);
+    }
+    insertBeforeInContainer(container, beforeId) {
+        container.insertItemBefore(this.id, this.item, beforeId);
     }
-    detachFromParent(parent) {
-        if (isItemContainer(parent)) {
-            parent.removeItem(this.id);
+    unmount() {
+        if (this.parentContainer) {
+            this.parentContainer.removeItem(this.id);
         }
+        this.parentContainer = null;
+        super.unmount();
     }
     updateProps(oldProps, newProps) {
         const newId = newProps.id;

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

@@ -16,10 +16,10 @@ export declare abstract class VirtualSlotNode<TContainer, TProps> extends Node<n
     protected abstract extractSlotProps(props: Props): TProps;
     initialize(props: Props): void;
     getChildWidget(): Gtk.Widget | null;
+    getSlotProps(): TProps;
+    setParentContainer(container: Node & TContainer): void;
+    getBeforeWidget(before: Node): Gtk.Widget | null;
     appendChild(child: Node): void;
-    attachToParent(parent: Node): void;
-    attachToParentBefore(parent: Node, before: Node): void;
-    protected getBeforeWidget(before: Node): Gtk.Widget | null;
-    detachFromParent(parent: Node): void;
+    unmount(): void;
     protected updateSlotPropsIfChanged(oldProps: Props, newProps: Props, propKeys: string[]): boolean;
 }

package/dist/nodes/virtual-slot.js

@@ -22,29 +22,11 @@ export class VirtualSlotNode extends Node {
     getChildWidget() {
         return this.childWidget;
     }
-    appendChild(child) {
-        const childWidget = child.getWidget();
-        if (childWidget) {
-            this.childWidget = childWidget;
-        }
+    getSlotProps() {
+        return this.slotProps;
     }
-    attachToParent(parent) {
-        if (this.isValidContainer(parent) && this.childWidget) {
-            this.parentContainer = parent;
-            this.addToContainer(parent, this.childWidget, this.slotProps);
-        }
-    }
-    attachToParentBefore(parent, before) {
-        if (this.isValidContainer(parent) && this.childWidget) {
-            this.parentContainer = parent;
-            const beforeWidget = this.getBeforeWidget(before);
-            if (beforeWidget) {
-                this.insertBeforeInContainer(parent, this.childWidget, this.slotProps, beforeWidget);
-            }
-            else {
-                this.addToContainer(parent, this.childWidget, this.slotProps);
-            }
-        }
+    setParentContainer(container) {
+        this.parentContainer = container;
     }
     getBeforeWidget(before) {
         if (before instanceof VirtualSlotNode) {
@@ -52,12 +34,16 @@ export class VirtualSlotNode extends Node {
         }
         return before.getWidget() ?? null;
     }
-    detachFromParent(parent) {
-        if (this.isValidContainer(parent) && this.childWidget) {
-            this.removeFromContainer(parent, this.childWidget);
-            this.parentContainer = null;
+    appendChild(child) {
+        const childWidget = child.getWidget();
+        if (childWidget) {
+            this.childWidget = childWidget;
         }
     }
+    unmount() {
+        this.parentContainer = null;
+        super.unmount();
+    }
     updateSlotPropsIfChanged(oldProps, newProps, propKeys) {
         const changed = propKeys.some((key) => oldProps[key] !== newProps[key]);
         if (changed) {

package/dist/nodes/window.d.ts

@@ -4,8 +4,9 @@ import { Node } from "../node.js";
 export declare class WindowNode extends Node<Gtk.Window> {
     static consumedPropNames: string[];
     static matches(type: string): boolean;
+    protected isStandalone(): boolean;
     protected createWidget(type: string, _props: Props): Gtk.Window;
-    detachFromParent(_parent: Node): void;
     mount(): void;
+    unmount(): void;
     updateProps(oldProps: Props, newProps: Props): void;
 }

package/dist/nodes/window.js

@@ -8,6 +8,9 @@ export class WindowNode extends Node {
     static matches(type) {
         return WINDOW_TYPES.has(normalizeWidgetType(type));
     }
+    isStandalone() {
+        return true;
+    }
     createWidget(type, _props) {
         const widgetType = normalizeWidgetType(type);
         if (widgetType === "ApplicationWindow") {
@@ -21,12 +24,13 @@ export class WindowNode extends Node {
         }
         return new Gtk.Window();
     }
-    detachFromParent(_parent) {
-        this.widget.destroy();
-    }
     mount() {
         this.widget.present();
     }
+    unmount() {
+        this.widget.destroy();
+        super.unmount();
+    }
     updateProps(oldProps, newProps) {
         const widthChanged = oldProps.defaultWidth !== newProps.defaultWidth;
         const heightChanged = oldProps.defaultHeight !== newProps.defaultHeight;

package/dist/predicates.d.ts

@@ -1,4 +1,6 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
+import type { ChildContainer, GridContainer, ItemContainer, PackContainer, PageContainer, StackPageContainer, StringListContainer } from "./containers.js";
+import type { Node } from "./node.js";
 interface Appendable extends Gtk.Widget {
     append(child: unknown): void;
 }
@@ -11,28 +13,17 @@ interface SingleChild extends Gtk.Widget {
 interface Removable extends Gtk.Widget {
     remove(child: unknown): void;
 }
-/**
- * Type guard that checks if a GTK widget supports appending children via an append method.
- */
 export declare const isAppendable: (widget: Gtk.Widget) => widget is Appendable;
-/**
- * Type guard that checks if a GTK widget supports adding children via an add method.
- */
 export declare const isAddable: (widget: Gtk.Widget) => widget is Addable;
-/**
- * Type guard that checks if a GTK widget supports a single child via setChild method.
- */
 export declare const isSingleChild: (widget: Gtk.Widget) => widget is SingleChild;
-/**
- * Type guard that checks if a GTK widget supports removing children via a remove method.
- */
 export declare const isRemovable: (widget: Gtk.Widget) => widget is Removable;
-/**
- * Type guard that checks if a GTK widget is a FlowBoxChild.
- */
 export declare const isFlowBoxChild: (widget: Gtk.Widget) => widget is Gtk.FlowBoxChild;
-/**
- * Type guard that checks if a GTK widget is a ListBoxRow.
- */
 export declare const isListBoxRow: (widget: Gtk.Widget) => widget is Gtk.ListBoxRow;
+export declare const isChildContainer: (node: Node) => node is Node & ChildContainer;
+export declare const isPageContainer: (node: Node) => node is Node & PageContainer;
+export declare const isStackPageContainer: (node: Node) => node is Node & StackPageContainer;
+export declare const isGridContainer: (node: Node) => node is Node & GridContainer;
+export declare const isItemContainer: (node: Node) => node is Node & ItemContainer<unknown>;
+export declare const isPackContainer: (node: Node) => node is Node & PackContainer;
+export declare const isStringListContainer: (node: Node) => node is Node & StringListContainer;
 export {};