@gtkx/react 0.14.0 → 0.15.0

package/dist/nodes/internal/signal-store.js

@@ -18,6 +18,7 @@ const LIFECYCLE_SIGNALS = new Set([
 class SignalStore {
     ownerHandlers = new Map();
     blockedHandlers = new Set();
+    isBlocking = false;
     getOwnerMap(owner) {
         let map = this.ownerHandlers.get(owner);
         if (!map) {
@@ -41,6 +42,10 @@ class SignalStore {
         const key = `${objectId}:${signal}`;
         const handlerId = obj.connect(signal, handler);
         this.getOwnerMap(owner).set(key, { obj, handlerId });
+        if (this.isBlocking && !LIFECYCLE_SIGNALS.has(signal)) {
+            GObject.signalHandlerBlock(obj, handlerId);
+            this.blockedHandlers.add(handlerId);
+        }
     }
     set(owner, obj, signal, handler) {
         this.disconnect(owner, obj, signal);
@@ -58,6 +63,7 @@ class SignalStore {
         }
     }
     blockAll() {
+        this.isBlocking = true;
         this.blockedHandlers.clear();
         for (const ownerMap of this.ownerHandlers.values()) {
             for (const [key, { obj, handlerId }] of ownerMap.entries()) {
@@ -70,6 +76,7 @@ class SignalStore {
         }
     }
     unblockAll() {
+        this.isBlocking = false;
         for (const ownerMap of this.ownerHandlers.values()) {
             for (const { obj, handlerId } of ownerMap.values()) {
                 if (this.blockedHandlers.has(handlerId)) {

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

@@ -18,6 +18,7 @@ export declare class TreeListItemRenderer {
     setStore(store?: TreeStore | null): void;
     setEstimatedItemHeight(height?: number): void;
     private getStore;
+    dispose(): void;
     private initialize;
     private processPendingBind;
     private renderBind;

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

@@ -35,6 +35,14 @@ export class TreeListItemRenderer {
         }
         return this.store;
     }
+    dispose() {
+        signalStore.clear(this);
+        this.fiberRoots.clear();
+        this.expanders.clear();
+        this.setupComplete.clear();
+        this.pendingBinds.clear();
+        this.tornDown.clear();
+    }
     initialize() {
         signalStore.set(this, this.factory, "setup", (_self, listItem) => {
             const ptr = getNativeId(listItem.handle);

package/dist/nodes/level-bar.js

@@ -3,7 +3,6 @@ import { registerNodeClass } from "../registry.js";
 import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
 import { isContainerType } from "./internal/utils.js";
 import { LevelBarOffsetNode } from "./level-bar-offset.js";
-import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
 class LevelBarNode extends WidgetNode {
     static priority = 1;
@@ -24,11 +23,7 @@ class LevelBarNode extends WidgetNode {
             });
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.appendChild(child);
-            return;
-        }
-        throw new Error(`Cannot append '${child.typeName}' to 'LevelBar': expected x.LevelBarOffset or Widget`);
+        super.appendChild(child);
     }
     insertBefore(child, before) {
         if (child instanceof LevelBarOffsetNode) {
@@ -43,11 +38,7 @@ class LevelBarNode extends WidgetNode {
             this.scheduleRebuildAllOffsets();
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.insertBefore(child, before);
-            return;
-        }
-        throw new Error(`Cannot insert '${child.typeName}' into 'LevelBar': expected x.LevelBarOffset or Widget`);
+        super.insertBefore(child, before);
     }
     removeChild(child) {
         if (child instanceof LevelBarOffsetNode) {
@@ -58,11 +49,7 @@ class LevelBarNode extends WidgetNode {
             this.scheduleRebuildAllOffsets(CommitPriority.HIGH);
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.removeChild(child);
-            return;
-        }
-        throw new Error(`Cannot remove '${child.typeName}' from 'LevelBar': expected x.LevelBarOffset or Widget`);
+        super.removeChild(child);
     }
     scheduleRebuildAllOffsets(priority = CommitPriority.NORMAL) {
         scheduleAfterCommit(() => {

package/dist/nodes/list-view.js

@@ -28,6 +28,10 @@ class ListViewNode extends WidgetNode {
         super.mount();
         this.container.setModel(this.list.getSelectionModel());
     }
+    unmount() {
+        this.itemRenderer.dispose();
+        super.unmount();
+    }
     appendChild(child) {
         if (!(child instanceof ListItemNode)) {
             throw new Error(`Cannot append '${child.typeName}' to 'ListView': expected x.ListItem`);
@@ -54,12 +58,12 @@ class ListViewNode extends WidgetNode {
             this.itemRenderer.setEstimatedItemHeight(newProps.estimatedItemHeight);
         }
         const previousModel = this.list.getSelectionModel();
-        this.list.updateProps(oldProps ? filterProps(oldProps, PROP_NAMES) : null, filterProps(newProps, PROP_NAMES));
+        this.list.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
         const currentModel = this.list.getSelectionModel();
         if (previousModel !== currentModel) {
             this.container.setModel(currentModel);
         }
-        super.updateProps(oldProps ? filterProps(oldProps, PROP_NAMES) : null, filterProps(newProps, PROP_NAMES));
+        super.updateProps(filterProps(oldProps ?? {}, PROP_NAMES), filterProps(newProps, PROP_NAMES));
     }
 }
 registerNodeClass(ListViewNode);

package/dist/nodes/navigation-page.js

@@ -1,3 +1,4 @@
+import { batch } from "@gtkx/ffi";
 import * as Adw from "@gtkx/ffi/adw";
 import { registerNodeClass } from "../registry.js";
 import { SlotNode } from "./slot.js";
@@ -12,36 +13,44 @@ export class NavigationPageNode extends SlotNode {
         if (!(child instanceof Adw.NavigationPage)) {
             return;
         }
-        if (newProps.id !== undefined && (!oldProps || oldProps.id !== newProps.id)) {
-            child.setTag(newProps.id);
+        if (!oldProps || oldProps.id !== newProps.id) {
+            if (newProps.id !== undefined) {
+                child.setTag(newProps.id);
+            }
         }
-        if (newProps.title !== undefined && (!oldProps || oldProps.title !== newProps.title)) {
-            child.setTitle(newProps.title);
+        if (!oldProps || oldProps.title !== newProps.title) {
+            if (newProps.title !== undefined) {
+                child.setTitle(newProps.title);
+            }
         }
-        if (newProps.canPop !== undefined && (!oldProps || oldProps.canPop !== newProps.canPop)) {
-            child.setCanPop(newProps.canPop);
+        if (!oldProps || oldProps.canPop !== newProps.canPop) {
+            if (newProps.canPop !== undefined) {
+                child.setCanPop(newProps.canPop);
+            }
         }
     }
     onChildChange(oldChild) {
-        const navigationView = this.getParent();
-        const title = this.props.title ?? "";
-        if (this.child) {
-            this.child = this.props.id
-                ? Adw.NavigationPage.newWithTag(this.child, title, this.props.id)
-                : new Adw.NavigationPage(this.child, title);
-            this.updateProps(null, this.props);
-        }
-        if (navigationView instanceof Adw.NavigationView) {
-            if (oldChild instanceof Adw.NavigationPage) {
-                navigationView.remove(oldChild);
-            }
+        batch(() => {
+            const navigationView = this.getParent();
+            const title = this.props.title ?? "";
             if (this.child) {
-                navigationView.add(this.child);
+                this.child = this.props.id
+                    ? Adw.NavigationPage.newWithTag(this.child, title, this.props.id)
+                    : new Adw.NavigationPage(this.child, title);
+                this.updateProps(null, this.props);
             }
-        }
-        else {
-            super.onChildChange(oldChild);
-        }
+            if (navigationView instanceof Adw.NavigationView) {
+                if (oldChild instanceof Adw.NavigationPage) {
+                    navigationView.remove(oldChild);
+                }
+                if (this.child) {
+                    navigationView.add(this.child);
+                }
+            }
+            else {
+                super.onChildChange(oldChild);
+            }
+        });
     }
 }
 registerNodeClass(NavigationPageNode);

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

@@ -8,6 +8,7 @@ export declare class NotebookPageTabNode extends SlotNode<Props> {
     private page?;
     static matches(type: string): boolean;
     setPage(notebook?: Gtk.Notebook, page?: Gtk.Widget): void;
+    updateProps(oldProps: Props | null, newProps: Props): void;
     private getNotebook;
     private getPage;
     protected onChildChange(_oldChild: Gtk.Widget | null): void;

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

@@ -1,3 +1,4 @@
+import { batch } from "@gtkx/ffi";
 import { registerNodeClass } from "../registry.js";
 import { SlotNode } from "./slot.js";
 export class NotebookPageTabNode extends SlotNode {
@@ -12,6 +13,9 @@ export class NotebookPageTabNode extends SlotNode {
         this.page = page;
         this.setParent(notebook);
     }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+    }
     getNotebook() {
         if (!this.notebook) {
             throw new Error("Expected Notebook reference to be set on NotebookPageTabNode");
@@ -25,15 +29,17 @@ export class NotebookPageTabNode extends SlotNode {
         return this.page;
     }
     onChildChange(_oldChild) {
-        if (!this.notebook || !this.page) {
-            return;
-        }
-        const notebook = this.getNotebook();
-        const page = this.getPage();
-        if (notebook.pageNum(page) === -1) {
-            return;
-        }
-        notebook.setTabLabel(page, this.child);
+        batch(() => {
+            if (!this.notebook || !this.page) {
+                return;
+            }
+            const notebook = this.getNotebook();
+            const page = this.getPage();
+            if (notebook.pageNum(page) === -1) {
+                return;
+            }
+            notebook.setTabLabel(page, this.child);
+        });
     }
 }
 registerNodeClass(NotebookPageTabNode);

package/dist/nodes/notebook-page.js

@@ -1,3 +1,4 @@
+import { batch } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
 import { scheduleAfterCommit } from "../scheduler.js";
@@ -93,12 +94,14 @@ export class NotebookPageNode extends SlotNode {
         notebook.removePage(pageNum);
     }
     onChildChange(oldChild) {
-        if (oldChild) {
-            this.detachPage(oldChild);
-        }
-        if (this.child) {
-            this.attachPage();
-        }
+        batch(() => {
+            if (oldChild) {
+                this.detachPage(oldChild);
+            }
+            if (this.child) {
+                this.attachPage();
+            }
+        });
     }
 }
 registerNodeClass(NotebookPageNode);

package/dist/nodes/scale.js

@@ -3,7 +3,6 @@ import { registerNodeClass } from "../registry.js";
 import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
 import { isContainerType } from "./internal/utils.js";
 import { ScaleMarkNode } from "./scale-mark.js";
-import { SlotNode } from "./slot.js";
 import { WidgetNode } from "./widget.js";
 class ScaleNode extends WidgetNode {
     static priority = 1;
@@ -18,11 +17,7 @@ class ScaleNode extends WidgetNode {
             scheduleAfterCommit(() => child.addMark());
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.appendChild(child);
-            return;
-        }
-        throw new Error(`Cannot append '${child.typeName}' to 'Scale': expected x.ScaleMark or Widget`);
+        super.appendChild(child);
     }
     insertBefore(child, before) {
         if (child instanceof ScaleMarkNode) {
@@ -37,11 +32,7 @@ class ScaleNode extends WidgetNode {
             this.scheduleRebuildAllMarks();
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.insertBefore(child, before);
-            return;
-        }
-        throw new Error(`Cannot insert '${child.typeName}' into 'Scale': expected x.ScaleMark or Widget`);
+        super.insertBefore(child, before);
     }
     removeChild(child) {
         if (child instanceof ScaleMarkNode) {
@@ -52,11 +43,7 @@ class ScaleNode extends WidgetNode {
             this.scheduleRebuildAllMarks(CommitPriority.HIGH);
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.removeChild(child);
-            return;
-        }
-        throw new Error(`Cannot remove '${child.typeName}' from 'Scale': expected x.ScaleMark or Widget`);
+        super.removeChild(child);
     }
     scheduleRebuildAllMarks(priority = CommitPriority.NORMAL) {
         scheduleAfterCommit(() => {

package/dist/nodes/scrolled-window.js

@@ -9,8 +9,9 @@ class ScrolledWindowNode extends WidgetNode {
         return isContainerType(Gtk.ScrolledWindow, containerOrClass);
     }
     updateProps(oldProps, newProps) {
-        if (oldProps?.hscrollbarPolicy !== newProps.hscrollbarPolicy ||
-            oldProps?.vscrollbarPolicy !== newProps.vscrollbarPolicy) {
+        if (!oldProps ||
+            oldProps.hscrollbarPolicy !== newProps.hscrollbarPolicy ||
+            oldProps.vscrollbarPolicy !== newProps.vscrollbarPolicy) {
             const hPolicy = newProps.hscrollbarPolicy ?? Gtk.PolicyType.AUTOMATIC;
             const vPolicy = newProps.vscrollbarPolicy ?? Gtk.PolicyType.AUTOMATIC;
             this.container.setPolicy(hPolicy, vPolicy);

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

@@ -0,0 +1,37 @@
+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;
+}

package/dist/nodes/shortcut-controller.js

@@ -0,0 +1,74 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { ShortcutNode } from "./shortcut.js";
+import { VirtualNode } from "./virtual.js";
+export class ShortcutControllerNode extends VirtualNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "ShortcutController";
+    }
+    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);
+        }
+    }
+    removeChild(child) {
+        if (!(child instanceof ShortcutNode))
+            return;
+        const index = this.shortcuts.indexOf(child);
+        if (index !== -1) {
+            this.shortcuts.splice(index, 1);
+            if (this.controller && child.shortcut) {
+                this.controller.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);
+        }
+    }
+}
+registerNodeClass(ShortcutControllerNode);

package/dist/nodes/shortcut.d.ts

@@ -0,0 +1,38 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "../types.js";
+import { VirtualNode } from "./virtual.js";
+/**
+ * Props for the Shortcut virtual element.
+ *
+ * Defines a keyboard shortcut. Must be a child of `x.ShortcutController`.
+ *
+ * @example
+ * ```tsx
+ * <x.ShortcutController>
+ *     <x.Shortcut trigger="<Control>s" onActivate={save} />
+ *     <x.Shortcut trigger={["F5", "<Control>r"]} onActivate={refresh} />
+ *     <x.Shortcut trigger="Escape" onActivate={cancel} disabled={!canCancel} />
+ * </x.ShortcutController>
+ * ```
+ */
+export interface ShortcutProps extends Props {
+    /** The trigger string(s) using GTK accelerator format (e.g., "\<Control\>s", "F1") */
+    trigger: string | string[];
+    /**
+     * Called when the shortcut is activated.
+     * Return false to indicate the shortcut was not handled; otherwise it is considered handled.
+     */
+    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?;
+    createShortcut(): void;
+    updateProps(oldProps: ShortcutProps | null, newProps: ShortcutProps): void;
+    unmount(): void;
+    private createTrigger;
+}

package/dist/nodes/shortcut.js

@@ -0,0 +1,46 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { registerNodeClass } from "../registry.js";
+import { VirtualNode } from "./virtual.js";
+export class ShortcutNode extends VirtualNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "Shortcut";
+    }
+    shortcut;
+    action;
+    createShortcut() {
+        const trigger = this.createTrigger();
+        this.action = new Gtk.CallbackAction(() => {
+            const result = this.props.onActivate();
+            return result !== false;
+        });
+        this.shortcut = new Gtk.Shortcut(trigger, this.action);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        if (this.shortcut && (oldProps?.trigger !== newProps.trigger || oldProps?.disabled !== newProps.disabled)) {
+            this.shortcut.setTrigger(this.createTrigger());
+        }
+    }
+    unmount() {
+        this.shortcut = undefined;
+        this.action = undefined;
+        super.unmount();
+    }
+    createTrigger() {
+        if (this.props.disabled) {
+            return Gtk.NeverTrigger.get();
+        }
+        const { trigger } = this.props;
+        const triggers = Array.isArray(trigger) ? trigger : [trigger];
+        if (triggers.length === 0) {
+            return Gtk.NeverTrigger.get();
+        }
+        let result = new Gtk.ShortcutTrigger(triggers[0]);
+        for (let i = 1; i < triggers.length; i++) {
+            result = new Gtk.AlternativeTrigger(result, new Gtk.ShortcutTrigger(triggers[i]));
+        }
+        return result;
+    }
+}
+registerNodeClass(ShortcutNode);

package/dist/nodes/source-buffer.d.ts

@@ -0,0 +1,73 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import * as GtkSource from "@gtkx/ffi/gtksource";
+import { VirtualNode } from "./virtual.js";
+/**
+ * Props for the SourceBuffer virtual element.
+ *
+ * Used to declaratively configure the text buffer for a GtkSourceView with syntax highlighting,
+ * bracket matching, and other source code editing features.
+ *
+ * @example
+ * ```tsx
+ * <GtkSourceView>
+ *     <x.SourceBuffer
+ *         text={sourceCode}
+ *         language="typescript"
+ *         styleScheme="Adwaita-dark"
+ *         highlightSyntax
+ *         highlightMatchingBrackets
+ *         onTextChanged={(text) => console.log("Code:", text)}
+ *     />
+ * </GtkSourceView>
+ * ```
+ */
+export type SourceBufferProps = {
+    /** Text content */
+    text?: string;
+    /** Whether to enable undo/redo */
+    enableUndo?: boolean;
+    /** Callback when the text content changes */
+    onTextChanged?: (text: string) => void;
+    /** Callback when can-undo state changes */
+    onCanUndoChanged?: (canUndo: boolean) => void;
+    /** Callback when can-redo state changes */
+    onCanRedoChanged?: (canRedo: boolean) => void;
+    /**
+     * Language for syntax highlighting.
+     * Can be a language ID string (e.g., "typescript", "python", "rust") or a GtkSource.Language object.
+     */
+    language?: string | GtkSource.Language;
+    /**
+     * Style scheme for syntax highlighting colors.
+     * Can be a scheme ID string (e.g., "Adwaita-dark", "classic") or a GtkSource.StyleScheme object.
+     */
+    styleScheme?: string | GtkSource.StyleScheme;
+    /** Whether to enable syntax highlighting. Defaults to true when language is set. */
+    highlightSyntax?: boolean;
+    /** Whether to highlight matching brackets when cursor is on a bracket. Defaults to true. */
+    highlightMatchingBrackets?: boolean;
+    /**
+     * Whether the buffer has an implicit trailing newline.
+     * When true (default), trailing newlines are handled automatically during file load/save.
+     */
+    implicitTrailingNewline?: boolean;
+    /** Callback when the cursor position changes */
+    onCursorMoved?: () => void;
+    /** Callback when syntax highlighting is updated for a region */
+    onHighlightUpdated?: (start: Gtk.TextIter, end: Gtk.TextIter) => void;
+};
+export declare class SourceBufferNode extends VirtualNode<SourceBufferProps> {
+    static priority: number;
+    private sourceView?;
+    private buffer?;
+    static matches(type: string): boolean;
+    setSourceView(sourceView: GtkSource.View): void;
+    private resolveLanguage;
+    private resolveStyleScheme;
+    private setupBuffer;
+    private applySourceProps;
+    private getBufferText;
+    private updateSignalHandlers;
+    updateProps(oldProps: SourceBufferProps | null, newProps: SourceBufferProps): void;
+    unmount(): void;
+}