@gtkx/react 0.9.4 → 0.10.0

package/dist/nodes/notebook-page.js

@@ -0,0 +1,106 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { scheduleAfterCommit } from "../scheduler.js";
+import { NotebookPageTabNode } from "./notebook-page-tab.js";
+import { SlotNode } from "./slot.js";
+import { WidgetNode } from "./widget.js";
+export class NotebookPageNode extends SlotNode {
+    static priority = 1;
+    position;
+    tabNode;
+    static matches(type) {
+        return type === "Notebook.Page";
+    }
+    setNotebook(notebook) {
+        this.setParent(notebook);
+        this.updateTabNode();
+    }
+    setPosition(position) {
+        this.position = position;
+    }
+    getNotebook() {
+        if (!this.parent) {
+            throw new Error("Expected Notebook reference to be set on NotebookPageNode");
+        }
+        return this.parent;
+    }
+    updateTabNode() {
+        if (this.tabNode) {
+            this.tabNode.setPage(this.parent, this.child);
+        }
+    }
+    appendChild(child) {
+        if (child instanceof NotebookPageTabNode) {
+            this.tabNode = child;
+            scheduleAfterCommit(() => {
+                this.updateTabNode();
+            });
+            return;
+        }
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to 'Notebook.Page': expected Widget or Notebook.PageTab`);
+        }
+        const oldChild = this.child;
+        this.child = child.container;
+        scheduleAfterCommit(() => {
+            if (this.parent) {
+                this.onChildChange(oldChild);
+            }
+            this.updateTabNode();
+        });
+    }
+    removeChild(child) {
+        if (child instanceof NotebookPageTabNode) {
+            this.tabNode = undefined;
+            return;
+        }
+        // For content widget, use SlotNode's removeChild logic
+        super.removeChild();
+    }
+    unmount() {
+        this.tabNode = undefined;
+        super.unmount();
+    }
+    updateProps(oldProps, newProps) {
+        if (!oldProps || oldProps.label !== newProps.label) {
+            // Only update if using text label (no custom tab node)
+            if (this.child && this.parent && !this.tabNode?.child) {
+                const tabLabel = this.getNotebook().getTabLabel(this.child);
+                tabLabel.setLabel(newProps.label ?? "");
+            }
+        }
+    }
+    attachPage() {
+        const child = this.getChild();
+        const notebook = this.getNotebook();
+        // Use custom tab widget if provided, otherwise create a Label
+        let tabLabel;
+        if (this.tabNode?.child) {
+            tabLabel = this.tabNode.child;
+        }
+        else {
+            const label = new Gtk.Label();
+            label.setLabel(this.props.label ?? "");
+            tabLabel = label;
+        }
+        if (this.position !== undefined) {
+            notebook.insertPage(child, this.position, tabLabel);
+            return;
+        }
+        notebook.appendPage(child, tabLabel);
+    }
+    detachPage(childToDetach) {
+        const notebook = this.getNotebook();
+        const pageNum = notebook.pageNum(childToDetach);
+        notebook.removePage(pageNum);
+    }
+    onChildChange(oldChild) {
+        if (oldChild) {
+            this.detachPage(oldChild);
+        }
+        if (this.child) {
+            this.attachPage();
+        }
+    }
+}
+registerNodeClass(NotebookPageNode);

package/dist/nodes/notebook.d.ts

@@ -1,33 +1 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import type { ChildContainer, PageContainer } from "../containers.js";
-import type { Props } from "../factory.js";
-import { Node } from "../node.js";
-import { VirtualSlotNode } from "./virtual-slot.js";
-export declare class NotebookNode extends Node<Gtk.Notebook> implements PageContainer, ChildContainer {
-    static matches(type: string): boolean;
-    addPage(child: Gtk.Widget, label: string): void;
-    insertPageBefore(child: Gtk.Widget, label: string, beforeChild: Gtk.Widget): void;
-    removePage(child: Gtk.Widget): void;
-    updatePageLabel(child: Gtk.Widget, label: string): void;
-    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;
-};
-export declare class NotebookPageNode extends VirtualSlotNode<PageContainer, NotebookPageProps> {
-    static consumedPropNames: string[];
-    static matches(type: string): boolean;
-    protected isValidContainer(parent: Node): parent is Node & PageContainer;
-    protected extractSlotProps(props: Props): NotebookPageProps;
-    protected addToContainer(container: PageContainer, child: Gtk.Widget, props: NotebookPageProps): void;
-    protected insertBeforeInContainer(container: PageContainer, child: Gtk.Widget, props: NotebookPageProps, before: Gtk.Widget): void;
-    protected removeFromContainer(container: PageContainer, child: Gtk.Widget): void;
-    protected updateInContainer(container: PageContainer, child: Gtk.Widget, props: NotebookPageProps): void;
-    updateProps(oldProps: Props, newProps: Props): void;
-}
 export {};

package/dist/nodes/notebook.js

@@ -1,125 +1,32 @@
 import * as Gtk from "@gtkx/ffi/gtk";
-import { Node } from "../node.js";
-import { isPageContainer } from "../predicates.js";
-import { VirtualSlotNode } from "./virtual-slot.js";
-export class NotebookNode extends Node {
-    static matches(type) {
-        return type === "Notebook" || type === "Notebook.Root";
-    }
-    addPage(child, label) {
-        const tabLabel = new Gtk.Label();
-        tabLabel.setLabel(label);
-        this.widget.appendPage(child, tabLabel);
-    }
-    insertPageBefore(child, label, beforeChild) {
-        const beforePageNum = this.widget.pageNum(beforeChild);
-        const tabLabel = new Gtk.Label();
-        tabLabel.setLabel(label);
-        if (beforePageNum >= 0) {
-            this.widget.insertPage(child, beforePageNum, tabLabel);
-        }
-        else {
-            this.widget.appendPage(child, tabLabel);
-        }
-    }
-    removePage(child) {
-        const pageNum = this.widget.pageNum(child);
-        if (pageNum >= 0) {
-            this.widget.removePage(pageNum);
-        }
-    }
-    updatePageLabel(child, label) {
-        const tabLabel = new Gtk.Label();
-        tabLabel.setLabel(label);
-        this.widget.setTabLabel(child, tabLabel);
-    }
-    attachChild(child) {
-        this.widget.appendPage(child);
-    }
-    insertChildBefore(child, before) {
-        const beforePageNum = this.widget.pageNum(before);
-        if (beforePageNum >= 0) {
-            this.widget.insertPage(child, beforePageNum);
-        }
-        else {
-            this.widget.appendPage(child);
-        }
-    }
-    detachChild(child) {
-        this.removePage(child);
+import { registerNodeClass } from "../registry.js";
+import { isContainerType } 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 isContainerType(Gtk.Notebook, containerOrClass);
     }
     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;
+        if (!(child instanceof NotebookPageNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to 'Notebook': expected Notebook.Page`);
         }
-        super.appendChild(child);
+        child.setNotebook(this.container);
     }
     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;
+        if (!(child instanceof NotebookPageNode) || !(before instanceof NotebookPageNode)) {
+            throw new Error(`Cannot insert '${child.typeName}' to 'Notebook': expected Notebook.Page`);
         }
-        super.insertBefore(child, before);
+        const beforePosition = this.container.pageNum(before.getChild());
+        child.setPosition(beforePosition);
+        child.setNotebook(this.container);
     }
     removeChild(child) {
-        if (child instanceof NotebookPageNode) {
-            const childWidget = child.getChildWidget();
-            if (childWidget) {
-                this.removePage(childWidget);
-            }
-            child.unmount();
-            child.parent = null;
-            return;
+        if (!(child instanceof NotebookPageNode)) {
+            throw new Error(`Cannot remove '${child.typeName}' from 'Notebook': expected Notebook.Page`);
         }
-        super.removeChild(child);
-    }
-}
-export class NotebookPageNode extends VirtualSlotNode {
-    static consumedPropNames = ["label"];
-    static matches(type) {
-        return type === "Notebook.Page";
-    }
-    isValidContainer(parent) {
-        return isPageContainer(parent);
-    }
-    extractSlotProps(props) {
-        return {
-            label: props.label ?? "",
-        };
-    }
-    addToContainer(container, child, props) {
-        container.addPage(child, props.label);
-    }
-    insertBeforeInContainer(container, child, props, before) {
-        container.insertPageBefore(child, props.label, before);
-    }
-    removeFromContainer(container, child) {
-        container.removePage(child);
-    }
-    updateInContainer(container, child, props) {
-        container.updatePageLabel(child, props.label);
-    }
-    updateProps(oldProps, newProps) {
-        this.updateSlotPropsIfChanged(oldProps, newProps, ["label"]);
-        super.updateProps(oldProps, newProps);
+        child.setPosition(undefined);
     }
 }
+registerNodeClass(NotebookNode);

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

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

package/dist/nodes/overlay-child.js

@@ -0,0 +1,30 @@
+import { registerNodeClass } from "../registry.js";
+import { SlotNode } from "./slot.js";
+class OverlayChildNode extends SlotNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "OverlayChild";
+    }
+    getOverlay() {
+        if (!this.parent) {
+            throw new Error("Expected parent widget to be set on OverlayChildNode");
+        }
+        return this.parent;
+    }
+    onChildChange(oldChild) {
+        const overlay = this.getOverlay();
+        if (oldChild) {
+            overlay.removeOverlay(oldChild);
+        }
+        if (this.child) {
+            overlay.addOverlay(this.child);
+            if (this.props.measure !== undefined) {
+                overlay.setMeasureOverlay(this.child, this.props.measure);
+            }
+            if (this.props.clipOverlay !== undefined) {
+                overlay.setClipOverlay(this.child, this.props.clipOverlay);
+            }
+        }
+    }
+}
+registerNodeClass(OverlayChildNode);

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

@@ -0,0 +1,21 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../node.js";
+import { VirtualNode } from "./virtual.js";
+type PackableWidget = Gtk.Widget & {
+    packStart(child: Gtk.Widget): void;
+    packEnd(child: Gtk.Widget): void;
+    remove(child: Gtk.Widget): void;
+};
+export declare class PackChild extends VirtualNode {
+    static priority: number;
+    static matches(type: string): boolean;
+    private parent?;
+    private children;
+    private getPosition;
+    setParent(newParent?: PackableWidget): void;
+    unmount(): void;
+    appendChild(child: Node): void;
+    insertBefore(child: Node): void;
+    removeChild(child: Node): void;
+}
+export {};

package/dist/nodes/pack-child.js

@@ -0,0 +1,68 @@
+import { registerNodeClass } from "../registry.js";
+import { scheduleAfterCommit } from "../scheduler.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+export class PackChild extends VirtualNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "Pack.Start" || type === "Pack.End";
+    }
+    parent;
+    children = [];
+    getPosition() {
+        return this.typeName === "Pack.Start" ? "start" : "end";
+    }
+    setParent(newParent) {
+        this.parent = newParent;
+    }
+    unmount() {
+        const parent = this.parent;
+        const childrenToRemove = [...this.children];
+        if (parent && childrenToRemove.length > 0) {
+            scheduleAfterCommit(() => {
+                for (const widget of childrenToRemove) {
+                    parent.remove(widget);
+                }
+            });
+        }
+        this.children = [];
+        this.parent = undefined;
+        super.unmount();
+    }
+    appendChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to '${this.typeName}': expected Widget`);
+        }
+        const widget = child.container;
+        this.children.push(widget);
+        scheduleAfterCommit(() => {
+            if (this.parent) {
+                if (this.getPosition() === "start") {
+                    this.parent.packStart(widget);
+                }
+                else {
+                    this.parent.packEnd(widget);
+                }
+            }
+        });
+    }
+    insertBefore(child) {
+        this.appendChild(child);
+    }
+    removeChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot remove '${child.typeName}' from '${this.typeName}': expected Widget`);
+        }
+        const widget = child.container;
+        const index = this.children.indexOf(widget);
+        if (index !== -1) {
+            this.children.splice(index, 1);
+        }
+        scheduleAfterCommit(() => {
+            if (this.parent) {
+                this.parent.remove(widget);
+            }
+        });
+    }
+}
+registerNodeClass(PackChild);

package/dist/nodes/pack.d.ts

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

package/dist/nodes/pack.js

@@ -0,0 +1,33 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { PackChild } from "./pack-child.js";
+import { WidgetNode } from "./widget.js";
+class PackNode extends WidgetNode {
+    static priority = 0;
+    static matches(_type, containerOrClass) {
+        if (!containerOrClass ||
+            (typeof containerOrClass !== "function" && !(containerOrClass instanceof Gtk.Widget))) {
+            return false;
+        }
+        const protoOrInstance = typeof containerOrClass === "function" ? containerOrClass.prototype : containerOrClass;
+        return "packStart" in protoOrInstance && "packEnd" in protoOrInstance && "remove" in protoOrInstance;
+    }
+    appendChild(child) {
+        if (child instanceof PackChild) {
+            child.setParent(this.container);
+            return;
+        }
+        super.appendChild(child);
+    }
+    insertBefore(child) {
+        this.appendChild(child);
+    }
+    removeChild(child) {
+        if (child instanceof PackChild) {
+            child.unmount();
+            return;
+        }
+        super.removeChild(child);
+    }
+}
+registerNodeClass(PackNode);

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

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

package/dist/nodes/popover-menu.js

@@ -0,0 +1,58 @@
+import * as Gio from "@gtkx/ffi/gio";
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { isContainerType } from "./internal/utils.js";
+import { MenuNode } from "./menu.js";
+import { Menu } 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;
+    menu;
+    static matches(_type, containerOrClass) {
+        return (isContainerType(Gtk.PopoverMenu, containerOrClass) ||
+            isContainerType(Gtk.PopoverMenuBar, containerOrClass) ||
+            isContainerType(Gtk.MenuButton, containerOrClass));
+    }
+    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;
+        this.container.insertActionGroup(prefix, actionGroup);
+        this.menu = new Menu("root", {}, actionGroup, application);
+        this.container.setMenuModel(this.menu.getMenu());
+    }
+    appendChild(child) {
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.appendChild(child);
+            return;
+        }
+        if (!(child instanceof MenuNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to 'PopoverMenu': expected MenuItem`);
+        }
+        this.menu.appendChild(child);
+    }
+    insertBefore(child, before) {
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.insertBefore(child, before);
+            return;
+        }
+        if (!(child instanceof MenuNode)) {
+            throw new Error(`Cannot insert '${child.typeName}' to 'PopoverMenu': expected MenuItem`);
+        }
+        this.menu.insertBefore(child, before);
+    }
+    removeChild(child) {
+        if (child instanceof SlotNode || child instanceof WidgetNode) {
+            super.removeChild(child);
+            return;
+        }
+        if (!(child instanceof MenuNode)) {
+            throw new Error(`Cannot remove '${child.typeName}' from 'PopoverMenu': expected MenuItem`);
+        }
+        this.menu.removeChild(child);
+    }
+}
+registerNodeClass(PopoverMenuNode);

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

@@ -0,0 +1,9 @@
+import type { StringListItemProps } from "../jsx.js";
+import type { SimpleListStore } from "./internal/simple-list-store.js";
+import { ListItemNode } from "./list-item.js";
+type Props = Partial<StringListItemProps>;
+export declare class SimpleListItemNode extends ListItemNode<SimpleListStore, Props> {
+    static priority: number;
+    static matches(type: string): boolean;
+}
+export {};

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

@@ -0,0 +1,9 @@
+import { registerNodeClass } from "../registry.js";
+import { ListItemNode } from "./list-item.js";
+export class SimpleListItemNode extends ListItemNode {
+    static priority = -1;
+    static matches(type) {
+        return type === "SimpleListItem";
+    }
+}
+registerNodeClass(SimpleListItemNode);

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

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

package/dist/nodes/simple-list-view.js

@@ -0,0 +1,75 @@
+import * as Adw from "@gtkx/ffi/adw";
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { SimpleListStore } from "./internal/simple-list-store.js";
+import { filterProps, isContainerType } from "./internal/utils.js";
+import { SimpleListItemNode } from "./simple-list-item.js";
+import { WidgetNode } from "./widget.js";
+const PROP_NAMES = ["selectedId", "onSelectionChanged"];
+class SimpleListViewNode extends WidgetNode {
+    static priority = -1;
+    static matches(_type, containerOrClass) {
+        return isContainerType(Gtk.DropDown, containerOrClass) || isContainerType(Adw.ComboRow, containerOrClass);
+    }
+    store = new SimpleListStore();
+    constructor(typeName, props, container, rootContainer) {
+        super(typeName, props, container, rootContainer);
+        this.container.setModel(this.store.getModel());
+    }
+    updateProps(oldProps, newProps) {
+        if (!oldProps || oldProps.onSelectionChanged !== newProps.onSelectionChanged) {
+            const onSelectionChanged = newProps.onSelectionChanged;
+            const handleSelectionChange = onSelectionChanged
+                ? () => {
+                    const selectedIndex = this.container.getSelected();
+                    const id = this.store.getIdAtIndex(selectedIndex);
+                    if (id !== undefined) {
+                        onSelectionChanged(id);
+                    }
+                }
+                : undefined;
+            this.signalStore.set(this.container, "notify::selected", handleSelectionChange);
+        }
+        if (!oldProps || oldProps.selectedId !== newProps.selectedId) {
+            const index = newProps.selectedId !== undefined ? this.store.getIndexById(newProps.selectedId) : undefined;
+            if (index !== undefined) {
+                this.container.setSelected(index);
+            }
+        }
+        super.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
+    }
+    appendChild(child) {
+        if (!(child instanceof SimpleListItemNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to 'SimpleListView': expected SimpleListItem`);
+        }
+        const { id, value } = child.props;
+        if (!id || value === undefined) {
+            throw new Error("Expected 'id' and 'value' props to be present on SimpleListItem");
+        }
+        child.setStore(this.store);
+        this.store.addItem(id, value);
+    }
+    insertBefore(child, before) {
+        if (!(child instanceof SimpleListItemNode) || !(before instanceof SimpleListItemNode)) {
+            throw new Error(`Cannot insert '${child.typeName}' to 'SimpleListView': expected SimpleListItem`);
+        }
+        const { id, value } = child.props;
+        const beforeId = before.props.id;
+        if (!id || value === undefined || !beforeId) {
+            throw new Error("Expected 'id' and 'value' props to be present on SimpleListItem");
+        }
+        child.setStore(this.store);
+        this.store.insertItemBefore(id, beforeId, value);
+    }
+    removeChild(child) {
+        if (!(child instanceof SimpleListItemNode)) {
+            throw new Error(`Cannot remove '${child.typeName}' from 'SimpleListView': expected SimpleListItem`);
+        }
+        const { id } = child.props;
+        if (!id) {
+            throw new Error("Expected 'id' prop to be present on SimpleListItem");
+        }
+        this.store.removeItem(id);
+    }
+}
+registerNodeClass(SimpleListViewNode);

package/dist/nodes/slot.d.ts

@@ -1,13 +1,21 @@
-import { Node } from "../node.js";
-export declare class SlotNode extends Node<never> {
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { SlotProps } from "../jsx.js";
+import type { Node } from "../node.js";
+import { VirtualNode } from "./virtual.js";
+type SlotNodeProps = Omit<SlotProps, "children">;
+export declare class SlotNode<P extends SlotNodeProps = SlotNodeProps> extends VirtualNode<P> {
+    static priority: number;
     static matches(type: string): boolean;
-    protected isVirtual(): boolean;
-    private child;
-    private slotName;
-    constructor(type: string);
-    private updateParentSlot;
-    appendChild(child: Node): void;
-    removeChild(child: Node): void;
-    mount(): void;
+    parent?: Gtk.Widget;
+    child?: Gtk.Widget;
+    setParent(parent?: Gtk.Widget): void;
     unmount(): void;
+    protected getId(): string;
+    protected getParent(): Gtk.Widget;
+    getChild(): Gtk.Widget;
+    appendChild(child: Node): void;
+    removeChild(): void;
+    protected onChildChange(oldChild: Gtk.Widget | undefined): void;
+    private isDescendantOf;
 }
+export {};