@gtkx/react 0.17.2 → 0.18.0

package/dist/nodes/notebook-page-tab.js

@@ -1,42 +1,39 @@
-import { registerNodeClass } from "../registry.js";
-import { SlotNode } from "./slot.js";
-export class NotebookPageTabNode extends SlotNode {
-    static priority = 1;
-    notebook = null;
-    page = null;
-    static matches(type) {
-        return type === "NotebookPageTab";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export class NotebookPageTabNode extends VirtualNode {
+    isValidChild(child) {
+        return child instanceof WidgetNode;
     }
-    setPage(notebook, page) {
-        this.notebook = notebook;
-        this.page = page;
-        this.setParent(notebook);
-    }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
+    isValidParent(parent) {
+        return parent instanceof VirtualNode && parent.typeName === "NotebookPage";
     }
     getNotebook() {
-        if (!this.notebook) {
-            throw new Error("Expected Notebook reference to be set on NotebookPageTabNode");
-        }
-        return this.notebook;
+        return this.parent?.parent?.container ?? null;
     }
     getPage() {
-        if (!this.page) {
-            throw new Error("Expected page reference to be set on NotebookPageTabNode");
+        return this.parent?.findContentChild()?.container ?? null;
+    }
+    appendChild(child) {
+        super.appendChild(child);
+        if (this.parent) {
+            this.onChildChange();
         }
-        return this.page;
     }
-    onChildChange(_oldChild) {
-        if (!this.notebook || !this.page) {
-            return;
+    removeChild(child) {
+        super.removeChild(child);
+        if (this.parent) {
+            this.onChildChange();
         }
+    }
+    onChildChange() {
         const notebook = this.getNotebook();
         const page = this.getPage();
+        if (!notebook || !page) {
+            return;
+        }
         if (notebook.pageNum(page) === -1) {
             return;
         }
-        notebook.setTabLabel(page, this.child);
+        notebook.setTabLabel(page, this.children[0]?.container ?? null);
     }
 }
-registerNodeClass(NotebookPageTabNode);

package/dist/nodes/notebook-page.d.ts

@@ -1,25 +1,28 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import type { NotebookPageProps } from "../jsx.js";
 import type { Node } from "../node.js";
-import { SlotNode } from "./slot.js";
-type Props = Partial<NotebookPageProps>;
-export declare class NotebookPageNode extends SlotNode<Props> {
-    static priority: number;
-    position: number | null;
-    private tabNode;
-    static matches(type: string): boolean;
-    setParent(parent: Gtk.Widget | null): void;
+import { NotebookPageTabNode } from "./notebook-page-tab.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+type NotebookPageChild = WidgetNode | NotebookPageTabNode;
+export declare class NotebookPageNode extends VirtualNode<NotebookPageProps, WidgetNode<Gtk.Notebook>, NotebookPageChild> {
+    private position;
+    isValidChild(child: Node): boolean;
+    isValidParent(parent: Node): boolean;
+    findTabNode(): NotebookPageTabNode | undefined;
+    findContentChild(): WidgetNode | undefined;
+    setParent(parent: WidgetNode<Gtk.Notebook> | null): void;
+    appendChild(child: NotebookPageChild): void;
+    removeChild(child: NotebookPageChild): void;
+    commitUpdate(oldProps: NotebookPageProps | null, newProps: NotebookPageProps): void;
+    detachDeletedInstance(): void;
     setPosition(position: number | null): void;
-    private getNotebook;
-    private updateTabNode;
-    appendChild(child: Node): void;
-    removeChild(child: Node): void;
-    unmount(): void;
-    updateProps(oldProps: Props | null, newProps: Props): void;
-    protected applyOwnProps(oldProps: Props | null, newProps: Props): void;
+    getChildWidget(): Gtk.Widget;
+    private getParentWidget;
+    private applyOwnProps;
     private attachPage;
     private applyPageProps;
     private detachPage;
-    protected onChildChange(oldChild: Gtk.Widget | null): void;
+    private onChildChange;
 }
 export {};

package/dist/nodes/notebook-page.js

@@ -1,86 +1,104 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { registerNodeClass } from "../registry.js";
-import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
-import { hasChanged } from "./internal/utils.js";
+import { hasChanged } from "./internal/props.js";
 import { NotebookPageTabNode } from "./notebook-page-tab.js";
-import { SlotNode } from "./slot.js";
+import { VirtualNode } from "./virtual.js";
 import { WidgetNode } from "./widget.js";
-export class NotebookPageNode extends SlotNode {
-    static priority = 1;
+export class NotebookPageNode extends VirtualNode {
     position = null;
-    tabNode = null;
-    static matches(type) {
-        return type === "NotebookPage";
+    isValidChild(child) {
+        return child instanceof WidgetNode || child instanceof NotebookPageTabNode;
     }
-    setParent(parent) {
-        super.setParent(parent);
-        this.updateTabNode();
+    isValidParent(parent) {
+        return parent instanceof WidgetNode && parent.container instanceof Gtk.Notebook;
     }
-    setPosition(position) {
-        this.position = position;
+    findTabNode() {
+        return this.children.find((c) => c instanceof NotebookPageTabNode);
     }
-    getNotebook() {
-        if (!this.parent) {
-            throw new Error("Expected Notebook reference to be set on NotebookPageNode");
-        }
-        return this.parent;
+    findContentChild() {
+        return this.children.find((c) => c instanceof WidgetNode && !(c instanceof NotebookPageTabNode));
     }
-    updateTabNode() {
-        if (this.tabNode) {
-            this.tabNode.setPage(this.parent, this.child);
+    setParent(parent) {
+        if (!parent && this.parent) {
+            const childWidget = this.findContentChild()?.container ?? null;
+            if (childWidget) {
+                this.detachPage(childWidget);
+            }
+        }
+        super.setParent(parent);
+        if (parent && this.findContentChild()) {
+            this.onChildChange(null);
         }
     }
     appendChild(child) {
         if (child instanceof NotebookPageTabNode) {
-            this.tabNode = child;
-            scheduleAfterCommit(() => {
-                this.updateTabNode();
-            }, CommitPriority.NORMAL);
+            super.appendChild(child);
             return;
         }
-        if (!(child instanceof WidgetNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to 'x.NotebookPage': expected Widget or x.NotebookPageTab`);
+        const oldContent = this.findContentChild()?.container ?? null;
+        super.appendChild(child);
+        if (this.parent) {
+            this.onChildChange(oldContent);
         }
-        const oldChild = this.child;
-        this.child = child.container;
-        scheduleAfterCommit(() => {
-            if (this.parent) {
-                this.onChildChange(oldChild ?? null);
-            }
-            this.updateTabNode();
-        }, CommitPriority.NORMAL);
     }
     removeChild(child) {
         if (child instanceof NotebookPageTabNode) {
-            this.tabNode = null;
+            super.removeChild(child);
             return;
         }
+        const isContent = child === this.findContentChild();
+        const oldContent = isContent ? child.container : null;
         super.removeChild(child);
+        if (isContent && this.parent && oldContent) {
+            this.onChildChange(oldContent);
+        }
     }
-    unmount() {
-        this.tabNode = null;
-        super.unmount();
-    }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps, newProps);
         this.applyOwnProps(oldProps, newProps);
     }
+    detachDeletedInstance() {
+        const childWidget = this.findContentChild()?.container ?? null;
+        if (childWidget && this.parent) {
+            this.detachPage(childWidget);
+        }
+        super.detachDeletedInstance();
+    }
+    setPosition(position) {
+        this.position = position;
+    }
+    getChildWidget() {
+        const contentChild = this.findContentChild();
+        if (!contentChild) {
+            throw new Error("Expected content child widget to be set on NotebookPageNode");
+        }
+        return contentChild.container;
+    }
+    getParentWidget() {
+        if (!this.parent) {
+            throw new Error("Expected parent widget to be set on NotebookPageNode");
+        }
+        return this.parent.container;
+    }
     applyOwnProps(oldProps, newProps) {
-        if (hasChanged(oldProps, newProps, "label") && this.child && this.parent && !this.tabNode?.child) {
-            const tabLabel = this.getNotebook().getTabLabel(this.child);
+        const contentChild = this.findContentChild();
+        const childWidget = contentChild?.container ?? null;
+        const tabNode = this.findTabNode();
+        if (hasChanged(oldProps, newProps, "label") && childWidget && this.parent && !tabNode?.children[0]) {
+            const tabLabel = this.getParentWidget().getTabLabel(childWidget);
             tabLabel.setLabel(newProps.label ?? "");
         }
         const pagePropsChanged = hasChanged(oldProps, newProps, "tabExpand") || hasChanged(oldProps, newProps, "tabFill");
-        if (this.child && this.parent && pagePropsChanged) {
+        if (childWidget && this.parent && pagePropsChanged) {
             this.applyPageProps();
         }
     }
     attachPage() {
-        const child = this.getChild();
-        const notebook = this.getNotebook();
+        const child = this.getChildWidget();
+        const notebook = this.getParentWidget();
+        const tabNode = this.findTabNode();
         let tabLabel;
-        if (this.tabNode?.child) {
-            tabLabel = this.tabNode.child;
+        if (tabNode?.children[0]) {
+            tabLabel = tabNode.children[0].container;
         }
         else {
             const label = new Gtk.Label();
@@ -96,10 +114,10 @@ export class NotebookPageNode extends SlotNode {
         this.applyPageProps();
     }
     applyPageProps() {
-        const child = this.child;
+        const child = this.findContentChild()?.container ?? null;
         if (!child || !this.parent)
             return;
-        const notebook = this.getNotebook();
+        const notebook = this.getParentWidget();
         const page = notebook.getPage(child);
         if (!page)
             return;
@@ -111,17 +129,18 @@ export class NotebookPageNode extends SlotNode {
         }
     }
     detachPage(childToDetach) {
-        const notebook = this.getNotebook();
+        const notebook = this.getParentWidget();
         const pageNum = notebook.pageNum(childToDetach);
-        notebook.removePage(pageNum);
+        if (pageNum !== -1) {
+            notebook.removePage(pageNum);
+        }
     }
     onChildChange(oldChild) {
         if (oldChild) {
             this.detachPage(oldChild);
         }
-        if (this.child) {
+        if (this.findContentChild()) {
             this.attachPage();
         }
     }
 }
-registerNodeClass(NotebookPageNode);

package/dist/nodes/notebook.d.ts

@@ -1 +1,10 @@
-export {};
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../node.js";
+import type { Props } from "../types.js";
+import { NotebookPageNode } from "./notebook-page.js";
+import { WidgetNode } from "./widget.js";
+export declare class NotebookNode extends WidgetNode<Gtk.Notebook, Props, NotebookPageNode> {
+    isValidChild(child: Node): boolean;
+    insertBefore(child: NotebookPageNode, before: NotebookPageNode): void;
+    removeChild(child: NotebookPageNode): void;
+}

package/dist/nodes/notebook.js

@@ -1,32 +1,20 @@
-import { NOTEBOOK_CLASSES } from "../generated/internal.js";
-import { registerNodeClass } from "../registry.js";
-import { matchesAnyClass } from "./internal/utils.js";
 import { NotebookPageNode } from "./notebook-page.js";
 import { WidgetNode } from "./widget.js";
-class NotebookNode extends WidgetNode {
-    static priority = 1;
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass(NOTEBOOK_CLASSES, containerOrClass);
-    }
-    appendChild(child) {
-        if (!(child instanceof NotebookPageNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to 'Notebook': expected x.NotebookPage`);
-        }
-        child.setParent(this.container);
+export class NotebookNode extends WidgetNode {
+    isValidChild(child) {
+        return child instanceof NotebookPageNode;
     }
     insertBefore(child, before) {
-        if (!(child instanceof NotebookPageNode) || !(before instanceof NotebookPageNode)) {
-            throw new Error(`Cannot insert '${child.typeName}' into 'Notebook': expected x.NotebookPage`);
-        }
-        const beforePosition = this.container.pageNum(before.getChild());
+        const isMove = this.children.includes(child);
+        const beforePosition = this.container.pageNum(before.getChildWidget());
         child.setPosition(beforePosition);
-        child.setParent(this.container);
+        if (isMove) {
+            this.container.reorderChild(child.getChildWidget(), beforePosition);
+        }
+        super.insertBefore(child, before);
     }
     removeChild(child) {
-        if (!(child instanceof NotebookPageNode)) {
-            throw new Error(`Cannot remove '${child.typeName}' from 'Notebook': expected x.NotebookPage`);
-        }
         child.setPosition(null);
+        super.removeChild(child);
     }
 }
-registerNodeClass(NotebookNode);

package/dist/nodes/overlay-child.d.ts

@@ -1 +1,17 @@
-export {};
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { OverlayChildProps } from "../jsx.js";
+import type { Node } from "../node.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export declare class OverlayChildNode extends VirtualNode<OverlayChildProps, WidgetNode<Gtk.Overlay>, WidgetNode> {
+    isValidChild(child: Node): boolean;
+    isValidParent(parent: Node): boolean;
+    setParent(parent: WidgetNode<Gtk.Overlay> | null): void;
+    appendChild(child: WidgetNode): void;
+    insertBefore(child: WidgetNode, before: WidgetNode): void;
+    removeChild(child: WidgetNode): void;
+    commitUpdate(oldProps: OverlayChildProps | null, newProps: OverlayChildProps): void;
+    detachDeletedInstance(): void;
+    private attachToParent;
+    private detachAllChildren;
+}

package/dist/nodes/overlay-child.js

@@ -1,109 +1,87 @@
-import { getNativeId, isObjectEqual } from "@gtkx/ffi";
-import { registerNodeClass } from "../registry.js";
-import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
+import * as Gtk from "@gtkx/ffi/gtk";
+import { hasChanged } from "./internal/props.js";
 import { VirtualNode } from "./virtual.js";
 import { WidgetNode } from "./widget.js";
-class OverlayChildNode extends VirtualNode {
-    static priority = 1;
-    static matches(type) {
-        return type === "OverlayChild";
+export class OverlayChildNode extends VirtualNode {
+    isValidChild(child) {
+        return child instanceof WidgetNode;
     }
-    parent = null;
-    children = new Map();
-    canBeChildOf(parent) {
-        return parent instanceof WidgetNode;
+    isValidParent(parent) {
+        return parent instanceof WidgetNode && parent.container instanceof Gtk.Overlay;
     }
-    attachTo(parent) {
-        if (parent instanceof WidgetNode) {
-            this.parent = parent.container;
+    setParent(parent) {
+        if (!parent && this.parent) {
+            this.detachAllChildren(this.parent.container);
         }
-    }
-    detachFrom(_parent) { }
-    unmount() {
-        if (this.parent && this.children.size > 0) {
-            const parent = this.parent;
-            const children = [...this.children.values()];
-            this.children.clear();
-            for (const child of children) {
-                const currentParent = child.getParent();
-                if (currentParent && isObjectEqual(currentParent, parent)) {
-                    parent.removeOverlay(child);
-                }
+        super.setParent(parent);
+        if (parent) {
+            for (const child of this.children) {
+                this.attachToParent(parent.container, child.container);
             }
         }
-        this.parent = null;
-        super.unmount();
     }
     appendChild(child) {
-        if (!(child instanceof WidgetNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to '${this.typeName}': expected Widget`);
+        super.appendChild(child);
+        if (this.parent) {
+            this.attachToParent(this.parent.container, child.container);
         }
-        const widget = child.container;
-        this.children.set(getNativeId(widget.handle), widget);
-        scheduleAfterCommit(() => {
-            if (this.parent) {
-                this.attachChild(widget);
-            }
-        }, CommitPriority.NORMAL);
     }
-    insertBefore(child, _before) {
-        if (!(child instanceof WidgetNode)) {
-            throw new Error(`Cannot insert '${child.typeName}' into '${this.typeName}': expected Widget`);
+    insertBefore(child, before) {
+        super.insertBefore(child, before);
+        if (this.parent) {
+            this.attachToParent(this.parent.container, child.container);
         }
-        const widget = child.container;
-        this.children.set(getNativeId(widget.handle), widget);
-        scheduleAfterCommit(() => {
-            if (this.parent) {
-                this.attachChild(widget);
-            }
-        }, CommitPriority.NORMAL);
     }
     removeChild(child) {
-        if (!(child instanceof WidgetNode)) {
-            throw new Error(`Cannot remove '${child.typeName}' from '${this.typeName}': expected Widget`);
-        }
-        const widget = child.container;
-        const parent = this.parent;
-        this.children.delete(getNativeId(widget.handle));
-        scheduleAfterCommit(() => {
-            if (parent) {
-                const currentParent = widget.getParent();
-                if (currentParent && isObjectEqual(currentParent, parent)) {
-                    parent.removeOverlay(widget);
-                }
+        if (this.parent) {
+            const widget = child.container;
+            const currentParent = widget.getParent();
+            if (currentParent && currentParent === this.parent.container) {
+                this.parent.container.removeOverlay(widget);
             }
-        }, CommitPriority.HIGH);
+        }
+        super.removeChild(child);
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
+    commitUpdate(oldProps, newProps) {
+        super.commitUpdate(oldProps, newProps);
         if (!this.parent) {
             return;
         }
-        const measureChanged = oldProps?.measure !== newProps.measure;
-        const clipOverlayChanged = oldProps?.clipOverlay !== newProps.clipOverlay;
+        const measureChanged = hasChanged(oldProps, newProps, "measure");
+        const clipOverlayChanged = hasChanged(oldProps, newProps, "clipOverlay");
         if (measureChanged || clipOverlayChanged) {
-            const parent = this.parent;
-            for (const child of this.children.values()) {
+            const parent = this.parent.container;
+            for (const child of this.children) {
                 if (measureChanged) {
-                    parent.setMeasureOverlay(child, newProps.measure ?? false);
+                    parent.setMeasureOverlay(child.container, newProps.measure ?? false);
                 }
                 if (clipOverlayChanged) {
-                    parent.setClipOverlay(child, newProps.clipOverlay ?? false);
+                    parent.setClipOverlay(child.container, newProps.clipOverlay ?? false);
                 }
             }
         }
     }
-    attachChild(widget) {
-        if (!this.parent) {
-            return;
+    detachDeletedInstance() {
+        if (this.parent) {
+            this.detachAllChildren(this.parent.container);
         }
-        this.parent.addOverlay(widget);
+        super.detachDeletedInstance();
+    }
+    attachToParent(parent, child) {
+        parent.addOverlay(child);
         if (this.props.measure !== undefined) {
-            this.parent.setMeasureOverlay(widget, this.props.measure);
+            parent.setMeasureOverlay(child, this.props.measure);
         }
         if (this.props.clipOverlay !== undefined) {
-            this.parent.setClipOverlay(widget, this.props.clipOverlay);
+            parent.setClipOverlay(child, this.props.clipOverlay);
+        }
+    }
+    detachAllChildren(parent) {
+        for (const child of this.children) {
+            const currentParent = child.container.getParent();
+            if (currentParent && currentParent === parent) {
+                parent.removeOverlay(child.container);
+            }
         }
     }
 }
-registerNodeClass(OverlayChildNode);

package/dist/nodes/popover-menu.d.ts

@@ -1 +1,16 @@
+import type { Node } from "../node.js";
+import type { PopoverMenuWidget } from "../registry.js";
+import type { Container, Props } from "../types.js";
+import { MenuNode } from "./menu.js";
+import { SlotNode } from "./slot.js";
+import { WidgetNode } from "./widget.js";
+type PopoverMenuChild = MenuNode | SlotNode | WidgetNode;
+export declare class PopoverMenuNode extends WidgetNode<PopoverMenuWidget, Props, PopoverMenuChild> {
+    private menu;
+    isValidChild(child: Node): boolean;
+    constructor(typeName: string, props: Props, container: PopoverMenuWidget, rootContainer: Container);
+    appendChild(child: PopoverMenuChild): void;
+    insertBefore(child: PopoverMenuChild, before: PopoverMenuChild): void;
+    removeChild(child: PopoverMenuChild): void;
+}
 export {};

package/dist/nodes/popover-menu.js

@@ -1,24 +1,19 @@
 import * as Gio from "@gtkx/ffi/gio";
 import * as Gtk from "@gtkx/ffi/gtk";
-import { POPOVER_MENU_CLASSES } from "../generated/internal.js";
-import { registerNodeClass } from "../registry.js";
-import { matchesAnyClass } from "./internal/utils.js";
 import { MenuNode } from "./menu.js";
 import { MenuModel } from "./models/menu.js";
 import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
-const ACTION_PREFIX = "menu";
-class PopoverMenuNode extends WidgetNode {
-    static priority = 1;
+export class PopoverMenuNode extends WidgetNode {
     menu;
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass(POPOVER_MENU_CLASSES, containerOrClass);
+    isValidChild(child) {
+        return child instanceof MenuNode || child instanceof SlotNode || child instanceof WidgetNode;
     }
     constructor(typeName, props, container, rootContainer) {
         super(typeName, props, container, rootContainer);
         const application = rootContainer instanceof Gtk.Application ? rootContainer : undefined;
         const actionGroup = new Gio.SimpleActionGroup();
-        const prefix = application ? "app" : ACTION_PREFIX;
+        const prefix = application ? "app" : "menu";
         this.container.insertActionGroup(prefix, actionGroup);
         this.menu = new MenuModel("root", {}, rootContainer, actionGroup, application);
         this.container.setMenuModel(this.menu.getMenu());
@@ -28,33 +23,25 @@ class PopoverMenuNode extends WidgetNode {
             this.menu.appendChild(child);
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.appendChild(child);
-            return;
-        }
-        throw new Error(`Cannot append '${child.typeName}' to 'PopoverMenu': expected MenuItem or Widget`);
+        super.appendChild(child);
     }
     insertBefore(child, before) {
         if (child instanceof MenuNode) {
-            this.menu.insertBefore(child, before);
-            return;
-        }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.insertBefore(child, before);
+            if (before instanceof MenuNode) {
+                this.menu.insertBefore(child, before);
+            }
+            else {
+                this.menu.appendChild(child);
+            }
             return;
         }
-        throw new Error(`Cannot insert '${child.typeName}' into 'PopoverMenu': expected MenuItem or Widget`);
+        super.insertBefore(child, before);
     }
     removeChild(child) {
         if (child instanceof MenuNode) {
             this.menu.removeChild(child);
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.removeChild(child);
-            return;
-        }
-        throw new Error(`Cannot remove '${child.typeName}' from 'PopoverMenu': expected MenuItem or Widget`);
+        super.removeChild(child);
     }
 }
-registerNodeClass(PopoverMenuNode);

package/dist/nodes/scale.d.ts

@@ -1 +1,9 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { AdjustableProps, GtkScaleProps } from "../jsx.js";
+import { AdjustableNode } from "./adjustable.js";
+type ScaleProps = AdjustableProps & Pick<GtkScaleProps, "marks">;
+export declare class ScaleNode extends AdjustableNode<Gtk.Scale> {
+    private appliedMarks;
+    protected applyOwnProps(oldProps: ScaleProps | null, newProps: ScaleProps): void;
+}
 export {};