@gtkx/react 0.15.0 → 0.17.1

package/dist/nodes/overlay-child.js

@@ -1,49 +1,109 @@
-import { batch, isObjectEqual } from "@gtkx/ffi";
+import { getNativeId, isObjectEqual } from "@gtkx/ffi";
 import { registerNodeClass } from "../registry.js";
-import { SlotNode } from "./slot.js";
-class OverlayChildNode extends SlotNode {
+import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
+import { VirtualNode } from "./virtual.js";
+import { WidgetNode } from "./widget.js";
+class OverlayChildNode extends VirtualNode {
     static priority = 1;
     static matches(type) {
         return type === "OverlayChild";
     }
-    getOverlay() {
-        if (!this.parent) {
-            throw new Error("Expected parent widget to be set on OverlayChildNode");
+    parent = null;
+    children = new Map();
+    canBeChildOf(parent) {
+        return parent instanceof WidgetNode;
+    }
+    attachTo(parent) {
+        if (parent instanceof WidgetNode) {
+            this.parent = parent.container;
         }
-        return this.parent;
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
-        if (!this.parent || !this.child) {
-            return;
+    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);
+                }
+            }
         }
-        const overlay = this.getOverlay();
-        if (!oldProps || oldProps.measure !== newProps.measure) {
-            overlay.setMeasureOverlay(this.child, newProps.measure ?? false);
+        this.parent = null;
+        super.unmount();
+    }
+    appendChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to '${this.typeName}': expected Widget`);
         }
-        if (!oldProps || oldProps.clipOverlay !== newProps.clipOverlay) {
-            overlay.setClipOverlay(this.child, newProps.clipOverlay ?? false);
+        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`);
         }
+        const widget = child.container;
+        this.children.set(getNativeId(widget.handle), widget);
+        scheduleAfterCommit(() => {
+            if (this.parent) {
+                this.attachChild(widget);
+            }
+        }, CommitPriority.NORMAL);
     }
-    onChildChange(oldChild) {
-        const overlay = this.getOverlay();
-        batch(() => {
-            if (oldChild) {
-                const parent = oldChild.getParent();
-                if (parent && isObjectEqual(parent, overlay)) {
-                    overlay.removeOverlay(oldChild);
+    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.child) {
-                overlay.addOverlay(this.child);
-                if (this.props.measure !== undefined) {
-                    overlay.setMeasureOverlay(this.child, this.props.measure);
+        }, CommitPriority.HIGH);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        if (!this.parent) {
+            return;
+        }
+        const measureChanged = oldProps?.measure !== newProps.measure;
+        const clipOverlayChanged = oldProps?.clipOverlay !== newProps.clipOverlay;
+        if (measureChanged || clipOverlayChanged) {
+            const parent = this.parent;
+            for (const child of this.children.values()) {
+                if (measureChanged) {
+                    parent.setMeasureOverlay(child, newProps.measure ?? false);
                 }
-                if (this.props.clipOverlay !== undefined) {
-                    overlay.setClipOverlay(this.child, this.props.clipOverlay);
+                if (clipOverlayChanged) {
+                    parent.setClipOverlay(child, newProps.clipOverlay ?? false);
                 }
             }
-        });
+        }
+    }
+    attachChild(widget) {
+        if (!this.parent) {
+            return;
+        }
+        this.parent.addOverlay(widget);
+        if (this.props.measure !== undefined) {
+            this.parent.setMeasureOverlay(widget, this.props.measure);
+        }
+        if (this.props.clipOverlay !== undefined) {
+            this.parent.setClipOverlay(widget, this.props.clipOverlay);
+        }
     }
 }
 registerNodeClass(OverlayChildNode);

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

@@ -1,14 +1 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-import { VirtualChildNode } from "./virtual-child.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 VirtualChildNode<PackableWidget> {
-    static priority: number;
-    static matches(type: string): boolean;
-    protected getPositionLabel(): string;
-    protected attachChild(parent: PackableWidget, widget: Gtk.Widget): void;
-}
 export {};

package/dist/nodes/pack-child.js

@@ -1,20 +1,30 @@
+import { PACK_INTERFACE_METHODS } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
-import { VirtualChildNode } from "./virtual-child.js";
-export class PackChild extends VirtualChildNode {
+import { VirtualContainerNode } from "./abstract/virtual-container.js";
+import { matchesInterface } from "./internal/utils.js";
+class PackStartNode extends VirtualContainerNode {
     static priority = 1;
     static matches(type) {
-        return type === "PackStart" || type === "PackEnd";
+        return type === "PackStart";
     }
-    getPositionLabel() {
-        return this.typeName === "PackStart" ? "start" : "end";
+    canBeChildOf(parent) {
+        return matchesInterface(PACK_INTERFACE_METHODS, parent.container);
     }
     attachChild(parent, widget) {
-        if (this.getPositionLabel() === "start") {
-            parent.packStart(widget);
-        }
-        else {
-            parent.packEnd(widget);
-        }
+        parent.packStart(widget);
     }
 }
-registerNodeClass(PackChild);
+class PackEndNode extends VirtualContainerNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "PackEnd";
+    }
+    canBeChildOf(parent) {
+        return matchesInterface(PACK_INTERFACE_METHODS, parent.container);
+    }
+    attachChild(parent, widget) {
+        parent.packEnd(widget);
+    }
+}
+registerNodeClass(PackStartNode);
+registerNodeClass(PackEndNode);

package/dist/nodes/popover-menu.js

@@ -4,7 +4,7 @@ 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 { Menu } from "./models/menu.js";
+import { MenuModel } from "./models/menu.js";
 import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
 const ACTION_PREFIX = "menu";
@@ -20,7 +20,7 @@ class PopoverMenuNode extends WidgetNode {
         const actionGroup = new Gio.SimpleActionGroup();
         const prefix = application ? "app" : ACTION_PREFIX;
         this.container.insertActionGroup(prefix, actionGroup);
-        this.menu = new Menu("root", {}, actionGroup, application);
+        this.menu = new MenuModel("root", {}, rootContainer, actionGroup, application);
         this.container.setMenuModel(this.menu.getMenu());
     }
     appendChild(child) {

package/dist/nodes/scale.js

@@ -1,57 +1,27 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
-import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
-import { isContainerType } from "./internal/utils.js";
-import { ScaleMarkNode } from "./scale-mark.js";
-import { WidgetNode } from "./widget.js";
-class ScaleNode extends WidgetNode {
+import { AdjustableNode } from "./adjustable.js";
+import { matchesAnyClass, shallowArrayEqual } from "./internal/utils.js";
+class ScaleNode extends AdjustableNode {
     static priority = 1;
-    markChildren = [];
+    appliedMarks = [];
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.Scale, containerOrClass);
+        return matchesAnyClass([Gtk.Scale], containerOrClass);
     }
-    appendChild(child) {
-        if (child instanceof ScaleMarkNode) {
-            child.setScale(this.container, () => this.scheduleRebuildAllMarks());
-            this.markChildren.push(child);
-            scheduleAfterCommit(() => child.addMark());
-            return;
-        }
-        super.appendChild(child);
+    applyOwnProps(oldProps, newProps) {
+        super.applyOwnProps(oldProps, newProps);
+        this.applyMarks(newProps);
     }
-    insertBefore(child, before) {
-        if (child instanceof ScaleMarkNode) {
-            child.setScale(this.container, () => this.scheduleRebuildAllMarks());
-            const beforeIndex = this.markChildren.indexOf(before);
-            if (beforeIndex >= 0) {
-                this.markChildren.splice(beforeIndex, 0, child);
-            }
-            else {
-                this.markChildren.push(child);
-            }
-            this.scheduleRebuildAllMarks();
+    applyMarks(newProps) {
+        const newMarks = newProps.marks ?? [];
+        if (shallowArrayEqual(this.appliedMarks, newMarks)) {
             return;
         }
-        super.insertBefore(child, before);
-    }
-    removeChild(child) {
-        if (child instanceof ScaleMarkNode) {
-            const index = this.markChildren.indexOf(child);
-            if (index >= 0) {
-                this.markChildren.splice(index, 1);
-            }
-            this.scheduleRebuildAllMarks(CommitPriority.HIGH);
-            return;
+        this.container.clearMarks();
+        for (const mark of newMarks) {
+            this.container.addMark(mark.value, mark.position ?? Gtk.PositionType.BOTTOM, mark.label);
         }
-        super.removeChild(child);
-    }
-    scheduleRebuildAllMarks(priority = CommitPriority.NORMAL) {
-        scheduleAfterCommit(() => {
-            this.container.clearMarks();
-            for (const mark of this.markChildren) {
-                mark.addMark();
-            }
-        }, priority);
+        this.appliedMarks = [...newMarks];
     }
 }
 registerNodeClass(ScaleNode);

package/dist/nodes/scrolled-window.js

@@ -1,22 +1,23 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
-import { filterProps, isContainerType } from "./internal/utils.js";
+import { filterProps, hasChanged, matchesAnyClass } from "./internal/utils.js";
 import { WidgetNode } from "./widget.js";
 const PROPS = ["hscrollbarPolicy", "vscrollbarPolicy"];
 class ScrolledWindowNode extends WidgetNode {
     static priority = 2;
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.ScrolledWindow, containerOrClass);
+        return matchesAnyClass([Gtk.ScrolledWindow], containerOrClass);
     }
     updateProps(oldProps, newProps) {
-        if (!oldProps ||
-            oldProps.hscrollbarPolicy !== newProps.hscrollbarPolicy ||
-            oldProps.vscrollbarPolicy !== newProps.vscrollbarPolicy) {
+        super.updateProps(oldProps ? filterProps(oldProps, PROPS) : null, filterProps(newProps, PROPS));
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (hasChanged(oldProps, newProps, "hscrollbarPolicy") || hasChanged(oldProps, newProps, "vscrollbarPolicy")) {
             const hPolicy = newProps.hscrollbarPolicy ?? Gtk.PolicyType.AUTOMATIC;
             const vPolicy = newProps.vscrollbarPolicy ?? Gtk.PolicyType.AUTOMATIC;
             this.container.setPolicy(hPolicy, vPolicy);
         }
-        super.updateProps(filterProps(oldProps ?? {}, PROPS), filterProps(newProps, PROPS));
     }
 }
 registerNodeClass(ScrolledWindowNode);

package/dist/nodes/search-bar.d.ts

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

package/dist/nodes/search-bar.js

@@ -0,0 +1,40 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { filterProps, hasChanged, matchesAnyClass } from "./internal/utils.js";
+import { WidgetNode } from "./widget.js";
+const OWN_PROPS = ["onSearchModeChanged"];
+class SearchBarNode extends WidgetNode {
+    static priority = 1;
+    notifyHandler = null;
+    static matches(_type, containerOrClass) {
+        return matchesAnyClass([Gtk.SearchBar], containerOrClass);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        if (hasChanged(oldProps, newProps, "onSearchModeChanged")) {
+            this.setupNotifyHandler(newProps.onSearchModeChanged);
+        }
+    }
+    setupNotifyHandler(callback) {
+        if (this.notifyHandler) {
+            this.signalStore.set(this, this.container, "notify", undefined);
+            this.notifyHandler = null;
+        }
+        if (callback) {
+            this.notifyHandler = (_searchBar, pspec) => {
+                if (pspec.getName() === "search-mode-enabled") {
+                    callback(this.container.getSearchMode());
+                }
+            };
+            this.signalStore.set(this, this.container, "notify", this.notifyHandler);
+        }
+    }
+    unmount() {
+        if (this.notifyHandler) {
+            this.signalStore.set(this, this.container, "notify", undefined);
+            this.notifyHandler = null;
+        }
+        super.unmount();
+    }
+}
+registerNodeClass(SearchBarNode);

package/dist/nodes/shortcut-controller.d.ts

@@ -1,37 +1 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import type { Node } from "../node.js";
-import type { Props } from "../types.js";
-import { VirtualNode } from "./virtual.js";
-/**
- * Props for the ShortcutController virtual element.
- *
- * Attaches keyboard shortcuts to a widget. Must contain `x.Shortcut` children.
- *
- * @example
- * ```tsx
- * <GtkBox>
- *     <x.ShortcutController scope={Gtk.ShortcutScope.GLOBAL}>
- *         <x.Shortcut trigger="<Control>f" onActivate={toggleSearch} />
- *         <x.Shortcut trigger="<Control>q" onActivate={quit} />
- *     </x.ShortcutController>
- * </GtkBox>
- * ```
- */
-export interface ShortcutControllerProps extends Props {
-    /** The scope for shortcuts (LOCAL, MANAGED, or GLOBAL) */
-    scope?: Gtk.ShortcutScope;
-}
-export declare class ShortcutControllerNode extends VirtualNode<ShortcutControllerProps> {
-    static priority: number;
-    static matches(type: string): boolean;
-    private controller?;
-    private parentWidget?;
-    private shortcuts;
-    setParent(widget?: Gtk.Widget): void;
-    appendChild(child: Node): void;
-    removeChild(child: Node): void;
-    updateProps(oldProps: ShortcutControllerProps | null, newProps: ShortcutControllerProps): void;
-    unmount(): void;
-    private applyScope;
-    private addShortcutToController;
-}
+export {};

package/dist/nodes/shortcut-controller.js

@@ -1,40 +1,18 @@
-import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
+import { EventControllerNode } from "./event-controller.js";
 import { ShortcutNode } from "./shortcut.js";
-import { VirtualNode } from "./virtual.js";
-export class ShortcutControllerNode extends VirtualNode {
-    static priority = 1;
+class ShortcutControllerNode extends EventControllerNode {
+    static priority = 0;
     static matches(type) {
-        return type === "ShortcutController";
+        return type === "GtkShortcutController";
     }
-    controller;
-    parentWidget;
     shortcuts = [];
-    setParent(widget) {
-        if (this.parentWidget && this.controller) {
-            this.parentWidget.removeController(this.controller);
-        }
-        this.parentWidget = widget;
-        if (widget) {
-            this.controller = new Gtk.ShortcutController();
-            this.applyScope();
-            widget.addController(this.controller);
-            for (const shortcut of this.shortcuts) {
-                this.addShortcutToController(shortcut);
-            }
-        }
-        else {
-            this.controller = undefined;
-        }
-    }
     appendChild(child) {
         if (!(child instanceof ShortcutNode)) {
             throw new Error(`ShortcutController only accepts Shortcut children, got '${child.typeName}'`);
         }
         this.shortcuts.push(child);
-        if (this.controller) {
-            this.addShortcutToController(child);
-        }
+        this.addShortcutToController(child);
     }
     removeChild(child) {
         if (!(child instanceof ShortcutNode))
@@ -42,32 +20,15 @@ export class ShortcutControllerNode extends VirtualNode {
         const index = this.shortcuts.indexOf(child);
         if (index !== -1) {
             this.shortcuts.splice(index, 1);
-            if (this.controller && child.shortcut) {
-                this.controller.removeShortcut(child.shortcut);
+            if (child.shortcut) {
+                this.container.removeShortcut(child.shortcut);
             }
         }
     }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
-        if (!oldProps || oldProps.scope !== newProps.scope) {
-            this.applyScope();
-        }
-    }
-    unmount() {
-        this.setParent(undefined);
-        super.unmount();
-    }
-    applyScope() {
-        if (!this.controller)
-            return;
-        this.controller.setScope(this.props.scope ?? Gtk.ShortcutScope.LOCAL);
-    }
     addShortcutToController(node) {
-        if (!this.controller)
-            return;
         node.createShortcut();
         if (node.shortcut) {
-            this.controller.addShortcut(node.shortcut);
+            this.container.addShortcut(node.shortcut);
         }
     }
 }

package/dist/nodes/shortcut.d.ts

@@ -15,7 +15,7 @@ import { VirtualNode } from "./virtual.js";
  * </x.ShortcutController>
  * ```
  */
-export interface ShortcutProps extends Props {
+export type ShortcutProps = Props & {
     /** The trigger string(s) using GTK accelerator format (e.g., "\<Control\>s", "F1") */
     trigger: string | string[];
     /**
@@ -25,14 +25,15 @@ export interface ShortcutProps extends Props {
     onActivate: () => boolean | void;
     /** Whether the shortcut is disabled */
     disabled?: boolean;
-}
+};
 export declare class ShortcutNode extends VirtualNode<ShortcutProps> {
     static priority: number;
     static matches(type: string): boolean;
-    shortcut?: Gtk.Shortcut;
-    private action?;
+    shortcut: Gtk.Shortcut | null;
+    private action;
     createShortcut(): void;
     updateProps(oldProps: ShortcutProps | null, newProps: ShortcutProps): void;
+    protected applyOwnProps(oldProps: ShortcutProps | null, newProps: ShortcutProps): void;
     unmount(): void;
     private createTrigger;
 }

package/dist/nodes/shortcut.js

@@ -1,13 +1,14 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
+import { hasChanged } from "./internal/utils.js";
 import { VirtualNode } from "./virtual.js";
 export class ShortcutNode extends VirtualNode {
     static priority = 1;
     static matches(type) {
         return type === "Shortcut";
     }
-    shortcut;
-    action;
+    shortcut = null;
+    action = null;
     createShortcut() {
         const trigger = this.createTrigger();
         this.action = new Gtk.CallbackAction(() => {
@@ -18,13 +19,18 @@ export class ShortcutNode extends VirtualNode {
     }
     updateProps(oldProps, newProps) {
         super.updateProps(oldProps, newProps);
-        if (this.shortcut && (oldProps?.trigger !== newProps.trigger || oldProps?.disabled !== newProps.disabled)) {
+        this.applyOwnProps(oldProps, newProps);
+    }
+    applyOwnProps(oldProps, newProps) {
+        if (!this.shortcut)
+            return;
+        if (hasChanged(oldProps, newProps, "trigger") || hasChanged(oldProps, newProps, "disabled")) {
             this.shortcut.setTrigger(this.createTrigger());
         }
     }
     unmount() {
-        this.shortcut = undefined;
-        this.action = undefined;
+        this.shortcut = null;
+        this.action = null;
         super.unmount();
     }
     createTrigger() {

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

@@ -1,6 +1,5 @@
 import { DROP_DOWN_CLASSES } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
-import { signalStore } from "./internal/signal-store.js";
 import { SimpleListStore } from "./internal/simple-list-store.js";
 import { filterProps, matchesAnyClass } from "./internal/utils.js";
 import { SimpleListItemNode } from "./simple-list-item.js";
@@ -28,7 +27,7 @@ class SimpleListViewNode extends WidgetNode {
                     }
                 }
                 : undefined;
-            signalStore.set(this, this.container, "notify::selected", handleSelectionChange);
+            this.signalStore.set(this, this.container, "notify::selected", handleSelectionChange);
         }
         if (!oldProps || oldProps.selectedId !== newProps.selectedId) {
             const index = newProps.selectedId !== undefined ? this.store.getIndexById(newProps.selectedId) : null;
@@ -36,7 +35,7 @@ class SimpleListViewNode extends WidgetNode {
                 this.container.setSelected(index);
             }
         }
-        super.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
+        super.updateProps(oldProps ? filterProps(oldProps, PROP_NAMES) : null, filterProps(newProps, PROP_NAMES));
     }
     appendChild(child) {
         if (!(child instanceof SimpleListItemNode)) {

package/dist/nodes/slot.d.ts

@@ -1,21 +1,18 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
 import type { SlotProps } from "../jsx.js";
-import type { Node } from "../node.js";
 import type { Props } from "../types.js";
-import { VirtualNode } from "./virtual.js";
+import { VirtualSingleChildNode } from "./abstract/virtual-single-child.js";
 type SlotNodeProps = Omit<SlotProps, "children">;
-export declare class SlotNode<P extends Props = SlotNodeProps> extends VirtualNode<P> {
+export declare class SlotNode<P extends Props = SlotNodeProps> extends VirtualSingleChildNode<P> {
     static priority: number;
     static matches(type: string): boolean;
-    parent?: Gtk.Widget;
-    child?: Gtk.Widget;
-    setParent(parent?: Gtk.Widget): void;
+    private cachedSetter;
+    setParent(parent: Gtk.Widget | null): void;
     unmount(): void;
+    getChild(): Gtk.Widget;
     protected getId(): string;
     protected getParent(): Gtk.Widget;
-    getChild(): Gtk.Widget;
-    appendChild(child: Node): void;
-    removeChild(): void;
+    protected ensureChildSetter(): (child: Gtk.Widget | null) => void;
     protected onChildChange(oldChild: Gtk.Widget | null): void;
     private isDescendantOf;
 }