@gtkx/react 0.15.0 → 0.17.1

package/dist/nodes/toolbar-child.js

@@ -1,39 +1,30 @@
-import { batch, isObjectEqual } from "@gtkx/ffi";
 import { registerNodeClass } from "../registry.js";
-import { SlotNode } from "./slot.js";
-class ToolbarChildNode extends SlotNode {
+import { VirtualContainerNode } from "./abstract/virtual-container.js";
+import { matchesInterface } from "./internal/utils.js";
+const TOOLBAR_INTERFACE_METHODS = ["addTopBar", "addBottomBar", "remove"];
+class ToolbarTopNode extends VirtualContainerNode {
     static priority = 1;
     static matches(type) {
-        return type === "ToolbarTop" || type === "ToolbarBottom";
+        return type === "ToolbarTop";
     }
-    getToolbar() {
-        if (!this.parent) {
-            throw new Error("Expected ToolbarView reference to be set on ToolbarChildNode");
-        }
-        return this.parent;
+    canBeChildOf(parent) {
+        return matchesInterface(TOOLBAR_INTERFACE_METHODS, parent.container);
     }
-    getPosition() {
-        return this.typeName === "ToolbarTop" ? "top" : "bottom";
+    attachChild(parent, widget) {
+        parent.addTopBar(widget);
     }
-    onChildChange(oldChild) {
-        const toolbar = this.getToolbar();
-        batch(() => {
-            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);
-                }
-            }
-        });
+}
+class ToolbarBottomNode extends VirtualContainerNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "ToolbarBottom";
+    }
+    canBeChildOf(parent) {
+        return matchesInterface(TOOLBAR_INTERFACE_METHODS, parent.container);
+    }
+    attachChild(parent, widget) {
+        parent.addBottomBar(widget);
     }
 }
-registerNodeClass(ToolbarChildNode);
+registerNodeClass(ToolbarTopNode);
+registerNodeClass(ToolbarBottomNode);

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

@@ -1,3 +1,4 @@
+import { isObjectEqual } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
 import { TreeListItemRenderer } from "./internal/tree-list-item-renderer.js";
@@ -25,9 +26,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 +60,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) {
+        if (!isObjectEqual(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/web-view.d.ts

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

package/dist/nodes/web-view.js

@@ -0,0 +1,29 @@
+import * as WebKit from "@gtkx/ffi/webkit";
+import { registerNodeClass } from "../registry.js";
+import { filterProps, hasChanged, matchesAnyClass, propNameToSignalName, resolveSignal } from "./internal/utils.js";
+import { WidgetNode } from "./widget.js";
+const NON_BLOCKABLE_SIGNALS = ["load-changed"];
+class WebViewNode extends WidgetNode {
+    static priority = 1;
+    static matches(_type, containerOrClass) {
+        return matchesAnyClass([WebKit.WebView], containerOrClass);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps ? filterProps(oldProps, NON_BLOCKABLE_SIGNALS) : null, filterProps(newProps, NON_BLOCKABLE_SIGNALS));
+        this.applyNonBlockableSignals(oldProps, newProps);
+    }
+    applyNonBlockableSignals(oldProps, newProps) {
+        for (const propName of NON_BLOCKABLE_SIGNALS) {
+            const camelCaseName = `on${propName.charAt(0).toUpperCase()}${propName.slice(1).replace(/-([a-z])/g, (_, c) => c.toUpperCase())}`;
+            if (hasChanged(oldProps, newProps, camelCaseName)) {
+                const signalName = propNameToSignalName(camelCaseName);
+                if (resolveSignal(this.container, signalName)) {
+                    const newValue = newProps[camelCaseName];
+                    const handler = typeof newValue === "function" ? newValue : undefined;
+                    this.signalStore.set(this, this.container, signalName, handler, { blockable: false });
+                }
+            }
+        }
+    }
+}
+registerNodeClass(WebViewNode);

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;