@gtkx/react 0.15.0 → 0.16.0

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

@@ -1 +1,31 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../node.js";
+import type { Container, ContainerClass, Props } from "../types.js";
+import { TextBufferController } from "./internal/text-buffer-controller.js";
+import type { TextContentChild, TextContentParent } from "./text-content.js";
+import type { TextSegmentNode } from "./text-segment.js";
+import { WidgetNode } from "./widget.js";
+type TextViewProps = Props & {
+    enableUndo?: boolean;
+    onBufferChanged?: ((buffer: Gtk.TextBuffer) => void) | null;
+    onTextInserted?: ((buffer: Gtk.TextBuffer, offset: number, text: string) => void) | null;
+    onTextDeleted?: ((buffer: Gtk.TextBuffer, startOffset: number, endOffset: number) => void) | null;
+    onCanUndoChanged?: ((canUndo: boolean) => void) | null;
+    onCanRedoChanged?: ((canRedo: boolean) => void) | null;
+};
+export declare class TextViewNode extends WidgetNode<Gtk.TextView, TextViewProps> implements TextContentParent {
+    static priority: number;
+    protected bufferController: TextBufferController | null;
+    static matches(_type: string, containerOrClass?: Container | ContainerClass | null): boolean;
+    protected ensureBufferController(): TextBufferController;
+    protected createBufferController(): TextBufferController;
+    updateProps(oldProps: TextViewProps | null, newProps: TextViewProps): void;
+    protected applyOwnProps(oldProps: TextViewProps | null, newProps: TextViewProps): void;
+    appendChild(child: Node): void;
+    insertBefore(child: Node, before: Node): void;
+    removeChild(child: Node): void;
+    onChildInserted(child: TextContentChild): void;
+    onChildRemoved(child: TextContentChild): void;
+    onChildTextChanged(child: TextSegmentNode, oldLength: number, newLength: number): void;
+}
 export {};

package/dist/nodes/text-view.js

@@ -1,45 +1,73 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import * as GtkSource from "@gtkx/ffi/gtksource";
 import { registerNodeClass } from "../registry.js";
-import { isContainerType } from "./internal/utils.js";
-import { TextBufferNode } from "./text-buffer.js";
+import { TextBufferController } from "./internal/text-buffer-controller.js";
+import { filterProps, matchesAnyClass } from "./internal/utils.js";
 import { WidgetNode } from "./widget.js";
-class TextViewNode extends WidgetNode {
+const OWN_PROPS = [
+    "enableUndo",
+    "onBufferChanged",
+    "onTextInserted",
+    "onTextDeleted",
+    "onCanUndoChanged",
+    "onCanRedoChanged",
+];
+export class TextViewNode extends WidgetNode {
     static priority = 1;
-    bufferChild;
+    bufferController = null;
     static matches(_type, containerOrClass) {
-        if (isContainerType(GtkSource.View, containerOrClass))
+        if (matchesAnyClass([GtkSource.View], containerOrClass))
             return false;
-        return isContainerType(Gtk.TextView, containerOrClass);
+        return matchesAnyClass([Gtk.TextView], containerOrClass);
+    }
+    ensureBufferController() {
+        if (!this.bufferController) {
+            this.bufferController = this.createBufferController();
+        }
+        return this.bufferController;
+    }
+    createBufferController() {
+        return new TextBufferController(this, this.container, () => new Gtk.TextBuffer());
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
+        this.ensureBufferController().applyOwnProps(oldProps, newProps);
     }
     appendChild(child) {
-        if (this.tryAttachTextBuffer(child))
+        const controller = this.ensureBufferController();
+        if (controller.isTextContentChild(child)) {
+            controller.appendChild(child);
             return;
+        }
         super.appendChild(child);
     }
     insertBefore(child, before) {
-        if (this.tryAttachTextBuffer(child))
+        const controller = this.ensureBufferController();
+        if (controller.isTextContentChild(child)) {
+            controller.insertBefore(child, before);
             return;
+        }
         super.insertBefore(child, before);
     }
     removeChild(child) {
-        if (child instanceof TextBufferNode) {
-            if (this.bufferChild === child) {
-                this.bufferChild = undefined;
-            }
+        const controller = this.ensureBufferController();
+        if (controller.isTextContentChild(child)) {
+            controller.removeChild(child);
             return;
         }
         super.removeChild(child);
     }
-    tryAttachTextBuffer(child) {
-        if (!(child instanceof TextBufferNode))
-            return false;
-        if (this.bufferChild) {
-            throw new Error("TextView can only have one TextBuffer child");
-        }
-        this.bufferChild = child;
-        child.setTextView(this.container);
-        return true;
+    onChildInserted(child) {
+        this.ensureBufferController().onChildInserted(child);
+    }
+    onChildRemoved(child) {
+        this.ensureBufferController().onChildRemoved(child);
+    }
+    onChildTextChanged(child, oldLength, newLength) {
+        this.ensureBufferController().onChildTextChanged(child, oldLength, newLength);
     }
 }
 registerNodeClass(TextViewNode);

package/dist/nodes/toggle-group.js

@@ -1,48 +1,40 @@
 import * as Adw from "@gtkx/ffi/adw";
 import { registerNodeClass } from "../registry.js";
-import { isContainerType } from "./internal/utils.js";
-import { SlotNode } from "./slot.js";
-import { ToggleNode } from "./toggle.js";
+import { filterProps, hasChanged, matchesAnyClass } from "./internal/utils.js";
 import { WidgetNode } from "./widget.js";
+const OWN_PROPS = ["onActiveChanged"];
 class ToggleGroupNode extends WidgetNode {
     static priority = 1;
+    notifyHandler = null;
     static matches(_type, containerOrClass) {
-        return isContainerType(Adw.ToggleGroup, containerOrClass);
+        return matchesAnyClass([Adw.ToggleGroup], containerOrClass);
     }
-    appendChild(child) {
-        if (child instanceof ToggleNode) {
-            child.setToggleGroup(this.container);
-            child.addToGroup();
-            return;
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        if (hasChanged(oldProps, newProps, "onActiveChanged")) {
+            this.setupNotifyHandler(newProps.onActiveChanged);
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.appendChild(child);
-            return;
-        }
-        throw new Error(`Cannot append '${child.typeName}' to 'ToggleGroup': expected x.Toggle or Widget`);
     }
-    insertBefore(child, before) {
-        if (child instanceof ToggleNode) {
-            child.setToggleGroup(this.container);
-            child.addToGroup();
-            return;
+    setupNotifyHandler(callback) {
+        if (this.notifyHandler) {
+            this.signalStore.set(this, this.container, "notify", undefined);
+            this.notifyHandler = null;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.insertBefore(child, before);
-            return;
+        if (callback) {
+            this.notifyHandler = (pspec, _toggleGroup) => {
+                if (pspec.getName() === "active") {
+                    callback(this.container.getActive(), this.container.getActiveName());
+                }
+            };
+            this.signalStore.set(this, this.container, "notify", this.notifyHandler);
         }
-        throw new Error(`Cannot insert '${child.typeName}' into 'ToggleGroup': expected x.Toggle or Widget`);
     }
-    removeChild(child) {
-        if (child instanceof ToggleNode) {
-            child.removeFromGroup();
-            return;
-        }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.removeChild(child);
-            return;
+    unmount() {
+        if (this.notifyHandler) {
+            this.signalStore.set(this, this.container, "notify", undefined);
+            this.notifyHandler = null;
         }
-        throw new Error(`Cannot remove '${child.typeName}' from 'ToggleGroup': expected x.Toggle or Widget`);
+        super.unmount();
     }
 }
 registerNodeClass(ToggleGroupNode);

package/dist/nodes/toggle.d.ts

@@ -1,15 +1 @@
-import * as Adw from "@gtkx/ffi/adw";
-import type { ToggleProps } from "../jsx.js";
-import { VirtualNode } from "./virtual.js";
-export declare class ToggleNode extends VirtualNode<ToggleProps> {
-    static priority: number;
-    private toggleGroup?;
-    private toggle?;
-    static matches(type: string): boolean;
-    setToggleGroup(toggleGroup: Adw.ToggleGroup): void;
-    addToGroup(): void;
-    removeFromGroup(): void;
-    updateProps(oldProps: ToggleProps | null, newProps: ToggleProps): void;
-    unmount(): void;
-    private applyProps;
-}
+export {};

package/dist/nodes/toggle.js

@@ -1,70 +1,78 @@
 import * as Adw from "@gtkx/ffi/adw";
 import { registerNodeClass } from "../registry.js";
 import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
+import { hasChanged } from "./internal/utils.js";
 import { VirtualNode } from "./virtual.js";
-export class ToggleNode extends VirtualNode {
+import { WidgetNode } from "./widget.js";
+class ToggleNode extends VirtualNode {
     static priority = 1;
-    toggleGroup;
-    toggle;
+    toggleGroup = null;
+    toggle = null;
     static matches(type) {
         return type === "Toggle";
     }
-    setToggleGroup(toggleGroup) {
-        this.toggleGroup = toggleGroup;
+    canBeChildOf(parent) {
+        return parent instanceof WidgetNode && parent.container instanceof Adw.ToggleGroup;
     }
-    addToGroup() {
-        if (!this.toggleGroup || this.toggle)
+    attachTo(parent) {
+        if (!(parent instanceof WidgetNode) || !(parent.container instanceof Adw.ToggleGroup)) {
             return;
+        }
+        if (this.toggle)
+            return;
+        this.toggleGroup = parent.container;
         const toggleGroup = this.toggleGroup;
         this.toggle = new Adw.Toggle();
         scheduleAfterCommit(() => {
-            if (this.toggle) {
-                this.applyProps(this.props);
-                toggleGroup.add(this.toggle);
+            const toggle = this.toggle;
+            if (toggle) {
+                this.applyOwnProps(null, this.props);
+                toggleGroup.add(toggle);
             }
-        });
+        }, CommitPriority.NORMAL);
+    }
+    detachFrom(_parent) {
+        this.removeFromGroup();
     }
     removeFromGroup() {
         if (!this.toggleGroup || !this.toggle)
             return;
         const toggleGroup = this.toggleGroup;
         const toggle = this.toggle;
-        this.toggle = undefined;
+        this.toggle = null;
         scheduleAfterCommit(() => {
             toggleGroup.remove(toggle);
         }, CommitPriority.HIGH);
     }
     updateProps(oldProps, newProps) {
         super.updateProps(oldProps, newProps);
-        if (oldProps && this.toggle) {
-            this.applyProps(newProps);
-        }
+        this.applyOwnProps(oldProps, newProps);
     }
-    unmount() {
-        this.removeFromGroup();
-        super.unmount();
-    }
-    applyProps(props) {
+    applyOwnProps(oldProps, newProps) {
         if (!this.toggle)
             return;
-        if (props.id !== undefined && props.id !== this.toggle.getName()) {
-            this.toggle.setName(props.id);
+        if (hasChanged(oldProps, newProps, "id") && newProps.id !== undefined) {
+            this.toggle.setName(newProps.id);
         }
-        if (props.label !== undefined && props.label !== this.toggle.getLabel()) {
-            this.toggle.setLabel(props.label);
+        if (hasChanged(oldProps, newProps, "label") && newProps.label !== undefined) {
+            this.toggle.setLabel(newProps.label);
         }
-        if (props.iconName !== undefined && props.iconName !== this.toggle.getIconName()) {
-            this.toggle.setIconName(props.iconName);
+        if (hasChanged(oldProps, newProps, "iconName") && newProps.iconName !== undefined) {
+            this.toggle.setIconName(newProps.iconName);
         }
-        if (props.tooltip !== undefined && props.tooltip !== this.toggle.getTooltip()) {
-            this.toggle.setTooltip(props.tooltip);
+        if (hasChanged(oldProps, newProps, "tooltip") && newProps.tooltip !== undefined) {
+            this.toggle.setTooltip(newProps.tooltip);
         }
-        if (props.enabled !== undefined && props.enabled !== this.toggle.getEnabled()) {
-            this.toggle.setEnabled(props.enabled);
+        if (hasChanged(oldProps, newProps, "enabled") && newProps.enabled !== undefined) {
+            this.toggle.setEnabled(newProps.enabled);
         }
-        if (props.useUnderline !== undefined && props.useUnderline !== this.toggle.getUseUnderline()) {
-            this.toggle.setUseUnderline(props.useUnderline);
+        if (hasChanged(oldProps, newProps, "useUnderline") && newProps.useUnderline !== undefined) {
+            this.toggle.setUseUnderline(newProps.useUnderline);
         }
     }
+    unmount() {
+        this.removeFromGroup();
+        super.unmount();
+    }
 }
 registerNodeClass(ToggleNode);

package/dist/nodes/toolbar-child.js

@@ -1,4 +1,4 @@
-import { batch, isObjectEqual } from "@gtkx/ffi";
+import { isObjectEqual } from "@gtkx/ffi";
 import { registerNodeClass } from "../registry.js";
 import { SlotNode } from "./slot.js";
 class ToolbarChildNode extends SlotNode {
@@ -17,23 +17,21 @@ class ToolbarChildNode extends SlotNode {
     }
     onChildChange(oldChild) {
         const toolbar = this.getToolbar();
-        batch(() => {
-            if (oldChild) {
-                const parent = oldChild.getParent();
-                if (parent && isObjectEqual(parent, toolbar)) {
-                    toolbar.remove(oldChild);
-                }
+        if (oldChild) {
+            const parent = oldChild.getParent();
+            if (parent && isObjectEqual(parent, toolbar)) {
+                toolbar.remove(oldChild);
             }
-            if (this.child) {
-                const position = this.getPosition();
-                if (position === "top") {
-                    toolbar.addTopBar(this.child);
-                }
-                else {
-                    toolbar.addBottomBar(this.child);
-                }
+        }
+        if (this.child) {
+            const position = this.getPosition();
+            if (position === "top") {
+                toolbar.addTopBar(this.child);
+            }
+            else {
+                toolbar.addBottomBar(this.child);
             }
-        });
+        }
     }
 }
 registerNodeClass(ToolbarChildNode);

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

@@ -1,16 +1,18 @@
 import type { TreeListItemProps } from "../jsx.js";
 import type { Node } from "../node.js";
-import type { TreeStore } from "./internal/tree-store.js";
+import type { TreeItemData, TreeStore } from "./internal/tree-store.js";
 import { VirtualNode } from "./virtual.js";
 type Props = Partial<TreeListItemProps>;
+export declare const createTreeItemData: (props: Props) => TreeItemData;
 export declare class TreeListItemNode extends VirtualNode<Props> {
     static priority: number;
-    private store?;
-    private parentItemId?;
+    private store;
+    private parentItemId;
     private childNodes;
     static matches(type: string): boolean;
-    setStore(store?: TreeStore | null): void;
-    setParentItemId(parentId?: string | null): void;
+    setStore(store: TreeStore | null): void;
+    getChildNodes(): readonly TreeListItemNode[];
+    setParentItemId(parentId: string | null): void;
     getParentItemId(): string | null;
     appendChild(child: Node): void;
     insertBefore(child: Node, before: Node): void;

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

@@ -1,10 +1,15 @@
 import { registerNodeClass } from "../registry.js";
-import { scheduleAfterCommit } from "../scheduler.js";
 import { VirtualNode } from "./virtual.js";
+export const createTreeItemData = (props) => ({
+    value: props.value,
+    indentForDepth: props.indentForDepth,
+    indentForIcon: props.indentForIcon,
+    hideExpander: props.hideExpander,
+});
 export class TreeListItemNode extends VirtualNode {
     static priority = 1;
-    store;
-    parentItemId;
+    store = null;
+    parentItemId = null;
     childNodes = [];
     static matches(type) {
         return type === "TreeListItem";
@@ -15,36 +20,32 @@ export class TreeListItemNode extends VirtualNode {
             child.setStore(store);
         }
     }
+    getChildNodes() {
+        return this.childNodes;
+    }
     setParentItemId(parentId) {
         this.parentItemId = parentId;
     }
     getParentItemId() {
-        return this.parentItemId ?? null;
+        return this.parentItemId;
     }
     appendChild(child) {
         if (!(child instanceof TreeListItemNode)) {
             return;
         }
         child.setStore(this.store);
-        child.setParentItemId(this.props.id);
+        child.setParentItemId(this.props.id ?? null);
         this.childNodes.push(child);
-        scheduleAfterCommit(() => {
-            if (this.store && child.props.id !== undefined) {
-                this.store.addItem(child.props.id, {
-                    value: child.props.value,
-                    indentForDepth: child.props.indentForDepth,
-                    indentForIcon: child.props.indentForIcon,
-                    hideExpander: child.props.hideExpander,
-                }, this.props.id);
-            }
-        });
+        if (this.store && child.props.id !== undefined) {
+            this.store.addItem(child.props.id, createTreeItemData(child.props), this.props.id);
+        }
     }
     insertBefore(child, before) {
         if (!(child instanceof TreeListItemNode) || !(before instanceof TreeListItemNode)) {
             return;
         }
         child.setStore(this.store);
-        child.setParentItemId(this.props.id);
+        child.setParentItemId(this.props.id ?? null);
         const beforeIndex = this.childNodes.indexOf(before);
         if (beforeIndex === -1) {
             this.childNodes.push(child);
@@ -52,16 +53,9 @@ export class TreeListItemNode extends VirtualNode {
         else {
             this.childNodes.splice(beforeIndex, 0, child);
         }
-        scheduleAfterCommit(() => {
-            if (this.store && child.props.id !== undefined && before.props.id !== undefined) {
-                this.store.insertItemBefore(child.props.id, before.props.id, {
-                    value: child.props.value,
-                    indentForDepth: child.props.indentForDepth,
-                    indentForIcon: child.props.indentForIcon,
-                    hideExpander: child.props.hideExpander,
-                }, this.props.id);
-            }
-        });
+        if (this.store && child.props.id !== undefined && before.props.id !== undefined) {
+            this.store.insertItemBefore(child.props.id, before.props.id, createTreeItemData(child.props), this.props.id);
+        }
     }
     removeChild(child) {
         if (!(child instanceof TreeListItemNode)) {
@@ -82,20 +76,14 @@ export class TreeListItemNode extends VirtualNode {
         if (!this.store) {
             return;
         }
-        if (!oldProps ||
+        const propsChanged = !oldProps ||
             oldProps.id !== newProps.id ||
             oldProps.value !== newProps.value ||
             oldProps.indentForDepth !== newProps.indentForDepth ||
             oldProps.indentForIcon !== newProps.indentForIcon ||
-            oldProps.hideExpander !== newProps.hideExpander) {
-            if (newProps.id !== undefined) {
-                this.store.updateItem(newProps.id, {
-                    value: newProps.value,
-                    indentForDepth: newProps.indentForDepth,
-                    indentForIcon: newProps.indentForIcon,
-                    hideExpander: newProps.hideExpander,
-                });
-            }
+            oldProps.hideExpander !== newProps.hideExpander;
+        if (propsChanged && newProps.id !== undefined) {
+            this.store.updateItem(newProps.id, createTreeItemData(newProps));
         }
     }
 }

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

@@ -25,9 +25,10 @@ class TreeListViewNode extends WidgetNode {
             selectionMode: props.selectionMode,
             selected: props.selected,
             onSelectionChanged: props.onSelectionChanged,
-        });
-        this.itemRenderer = new TreeListItemRenderer();
+        }, rootContainer);
+        this.itemRenderer = new TreeListItemRenderer(this.signalStore);
         this.itemRenderer.setStore(this.treeList.getStore());
+        this.treeList.getStore().setOnItemUpdated((id) => this.itemRenderer.rebindItem(id));
         this.container.setFactory(this.itemRenderer.getFactory());
     }
     mount() {
@@ -58,18 +59,18 @@ class TreeListViewNode extends WidgetNode {
     }
     updateProps(oldProps, newProps) {
         if (!oldProps || oldProps.renderItem !== newProps.renderItem) {
-            this.itemRenderer.setRenderFn(newProps.renderItem);
+            this.itemRenderer.setRenderFn(newProps.renderItem ?? null);
         }
         if (!oldProps || oldProps.estimatedItemHeight !== newProps.estimatedItemHeight) {
-            this.itemRenderer.setEstimatedItemHeight(newProps.estimatedItemHeight);
+            this.itemRenderer.setEstimatedItemHeight(newProps.estimatedItemHeight ?? null);
         }
         const previousModel = this.treeList.getSelectionModel();
-        this.treeList.updateProps(filterProps(oldProps ?? {}, RENDERER_PROP_NAMES), filterProps(newProps, RENDERER_PROP_NAMES));
+        this.treeList.updateProps(oldProps ? filterProps(oldProps, RENDERER_PROP_NAMES) : null, filterProps(newProps, RENDERER_PROP_NAMES));
         const currentModel = this.treeList.getSelectionModel();
         if (previousModel !== currentModel) {
             this.container.setModel(currentModel);
         }
-        super.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
+        super.updateProps(oldProps ? filterProps(oldProps, PROP_NAMES) : null, filterProps(newProps, PROP_NAMES));
     }
 }
 registerNodeClass(TreeListViewNode);

package/dist/nodes/virtual.d.ts

@@ -5,7 +5,7 @@ export declare class VirtualNode<P = Props> extends Node<undefined, P> {
     static matches(_type: string): boolean;
     static createContainer(): void;
     props: P;
-    constructor(typeName: string, props: P | undefined, container: undefined, rootContainer?: Container);
+    constructor(typeName: string, props: P | undefined, container: undefined, rootContainer: Container);
     appendChild(_child: Node): void;
     removeChild(_child: Node): void;
     insertBefore(_child: Node, _before: Node): void;

package/dist/nodes/widget.d.ts

@@ -3,16 +3,8 @@ import { Node } from "../node.js";
 import type { Container, ContainerClass, Props } from "../types.js";
 export declare class WidgetNode<T extends Gtk.Widget = Gtk.Widget, P extends Props = Props> extends Node<T, P> {
     static priority: number;
-    private motionController?;
-    private clickController?;
-    private keyController?;
-    private scrollController?;
-    private dragSourceController?;
-    private dropTargetController?;
-    private gestureDragController?;
-    private adjustmentChild?;
     static matches(_type: string, containerOrClass?: Container | ContainerClass | null): boolean;
-    static createContainer(props: Props, containerClass: typeof Gtk.Widget): Container | null;
+    static createContainer(props: Props, containerClass: typeof Gtk.Widget, _rootContainer?: Container): Container | null;
     appendChild(child: Node): void;
     removeChild(child: Node): void;
     insertBefore(child: Node, before: Node): void;
@@ -21,13 +13,7 @@ export declare class WidgetNode<T extends Gtk.Widget = Gtk.Widget, P extends Pro
     updateProps(oldProps: P | null, newProps: P): void;
     private updateSizeRequest;
     private updateGrabFocus;
-    private updateEventControllerProp;
-    private ensureDragSource;
-    private ensureDropTarget;
-    private ensureGestureDrag;
-    private updateNotifyHandler;
-    private propNameToSignalName;
-    private getProperty;
+    private getPropertyDefaultValue;
     private setProperty;
     private detachChildFromParent;
     private attachChild;