@gtkx/react 0.15.0 → 0.17.1

package/dist/node.js

@@ -1,4 +1,4 @@
-import { signalStore } from "./nodes/internal/signal-store.js";
+import { getSignalStore } from "./nodes/internal/signal-store.js";
 export class Node {
     static priority = 0;
     static matches(_type, _containerOrClass) {
@@ -9,16 +9,27 @@ export class Node {
     }
     container;
     typeName;
-    constructor(typeName, _props = {}, container, _rootContainer) {
+    signalStore;
+    constructor(typeName, _props = {}, container, rootContainer) {
         this.typeName = typeName;
         this.container = container;
+        this.signalStore = getSignalStore(rootContainer);
     }
     appendChild(_child) { }
     removeChild(_child) { }
     insertBefore(_child, _before) { }
     updateProps(_oldProps, _newProps) { }
     mount() { }
+    commitProps(oldProps, newProps) {
+        this.signalStore.blockAll();
+        try {
+            this.updateProps(oldProps, newProps);
+        }
+        finally {
+            this.signalStore.unblockAll();
+        }
+    }
     unmount() {
-        signalStore.clear(this);
+        this.signalStore.clear(this);
     }
 }

package/dist/nodes/abstract/positional-child.d.ts

@@ -0,0 +1,9 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "../../types.js";
+import { VirtualSingleChildNode } from "./virtual-single-child.js";
+export declare abstract class PositionalChildNode<P extends Props = Props> extends VirtualSingleChildNode<P> {
+    protected abstract attachToParent(parent: Gtk.Widget, child: Gtk.Widget): void;
+    protected abstract detachFromParent(parent: Gtk.Widget, child: Gtk.Widget): void;
+    unmount(): void;
+    protected onChildChange(oldChild: Gtk.Widget | null): void;
+}

package/dist/nodes/abstract/positional-child.js

@@ -0,0 +1,29 @@
+import { isObjectEqual } from "@gtkx/ffi";
+import { VirtualSingleChildNode } from "./virtual-single-child.js";
+export class PositionalChildNode extends VirtualSingleChildNode {
+    unmount() {
+        if (this.parent && this.child) {
+            const parent = this.parent;
+            const oldChild = this.child;
+            this.child = null;
+            const parentOfOld = oldChild.getParent();
+            if (parentOfOld && isObjectEqual(parentOfOld, parent)) {
+                this.detachFromParent(parent, oldChild);
+            }
+        }
+        this.parent = null;
+        super.unmount();
+    }
+    onChildChange(oldChild) {
+        const parent = this.getParent();
+        if (oldChild) {
+            const parentOfOld = oldChild.getParent();
+            if (parentOfOld && isObjectEqual(parentOfOld, parent)) {
+                this.detachFromParent(parent, oldChild);
+            }
+        }
+        if (this.child) {
+            this.attachToParent(parent, this.child);
+        }
+    }
+}

package/dist/nodes/abstract/virtual-container.d.ts

@@ -0,0 +1,21 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../../node.js";
+import type { Attachable } from "../internal/predicates.js";
+import { VirtualNode } from "../virtual.js";
+type ChildParentWidget = Gtk.Widget & {
+    remove(child: Gtk.Widget): void;
+};
+export declare abstract class VirtualContainerNode<P extends ChildParentWidget = ChildParentWidget> extends VirtualNode implements Attachable {
+    protected parent: P | null;
+    setParent(newParent: P | null): void;
+    protected getParent(): P;
+    protected abstract attachChild(parent: P, widget: Gtk.Widget): void;
+    canBeChildOf(parent: Node): boolean;
+    attachTo(parent: Node): void;
+    detachFrom(_parent: Node): void;
+    unmount(): void;
+    appendChild(child: Node): void;
+    insertBefore(child: Node, _before: Node): void;
+    removeChild(child: Node): void;
+}
+export {};

package/dist/nodes/abstract/virtual-container.js

@@ -0,0 +1,68 @@
+import { isObjectEqual } from "@gtkx/ffi";
+import { CommitPriority, scheduleAfterCommit } from "../../scheduler.js";
+import { VirtualNode } from "../virtual.js";
+import { WidgetNode } from "../widget.js";
+export class VirtualContainerNode extends VirtualNode {
+    parent = null;
+    setParent(newParent) {
+        this.parent = newParent;
+    }
+    getParent() {
+        if (!this.parent) {
+            throw new Error(`Expected parent widget to be set on ${this.typeName}`);
+        }
+        return this.parent;
+    }
+    canBeChildOf(parent) {
+        return parent instanceof WidgetNode;
+    }
+    attachTo(parent) {
+        if (parent instanceof WidgetNode) {
+            this.setParent(parent.container);
+        }
+    }
+    detachFrom(_parent) { }
+    unmount() {
+        this.parent = null;
+        super.unmount();
+    }
+    appendChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to '${this.typeName}': expected Widget`);
+        }
+        const widget = child.container;
+        scheduleAfterCommit(() => {
+            const parent = this.parent;
+            if (parent) {
+                this.attachChild(parent, 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;
+        scheduleAfterCommit(() => {
+            const parent = this.parent;
+            if (parent) {
+                this.attachChild(parent, widget);
+            }
+        }, CommitPriority.NORMAL);
+    }
+    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;
+        scheduleAfterCommit(() => {
+            if (parent) {
+                const currentParent = widget.getParent();
+                if (currentParent && isObjectEqual(currentParent, parent)) {
+                    parent.remove(widget);
+                }
+            }
+        }, CommitPriority.HIGH);
+    }
+}

package/dist/nodes/abstract/virtual-single-child.d.ts

@@ -0,0 +1,18 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../../node.js";
+import type { Props } from "../../types.js";
+import type { Attachable } from "../internal/predicates.js";
+import { VirtualNode } from "../virtual.js";
+export declare abstract class VirtualSingleChildNode<P extends Props = Props> extends VirtualNode<P> implements Attachable {
+    protected parent: Gtk.Widget | null;
+    child: Gtk.Widget | null;
+    setParent(parent: Gtk.Widget | null): void;
+    protected getParent(): Gtk.Widget;
+    protected getTypedParent<T extends Gtk.Widget>(): T;
+    protected abstract onChildChange(oldChild: Gtk.Widget | null): void;
+    appendChild(child: Node): void;
+    removeChild(child: Node): void;
+    canBeChildOf(parent: Node): boolean;
+    attachTo(parent: Node): void;
+    detachFrom(_parent: Node): void;
+}

package/dist/nodes/abstract/virtual-single-child.js

@@ -0,0 +1,55 @@
+import { isObjectEqual } from "@gtkx/ffi";
+import { CommitPriority, scheduleAfterCommit } from "../../scheduler.js";
+import { VirtualNode } from "../virtual.js";
+import { WidgetNode } from "../widget.js";
+export class VirtualSingleChildNode extends VirtualNode {
+    parent = null;
+    child = null;
+    setParent(parent) {
+        this.parent = parent;
+    }
+    getParent() {
+        if (!this.parent) {
+            throw new Error(`Expected parent widget to be set on ${this.typeName}`);
+        }
+        return this.parent;
+    }
+    getTypedParent() {
+        return this.getParent();
+    }
+    appendChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to '${this.typeName}': expected Widget`);
+        }
+        const oldChild = this.child;
+        this.child = child.container;
+        scheduleAfterCommit(() => {
+            if (this.parent) {
+                this.onChildChange(oldChild);
+            }
+        }, CommitPriority.NORMAL);
+    }
+    removeChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot remove '${child.typeName}' from '${this.typeName}': expected Widget`);
+        }
+        const oldChild = this.child;
+        scheduleAfterCommit(() => {
+            if (isObjectEqual(oldChild, this.child)) {
+                this.child = null;
+            }
+            if (this.parent && oldChild) {
+                this.onChildChange(oldChild);
+            }
+        }, CommitPriority.HIGH);
+    }
+    canBeChildOf(parent) {
+        return parent instanceof WidgetNode;
+    }
+    attachTo(parent) {
+        if (parent instanceof WidgetNode) {
+            this.setParent(parent.container);
+        }
+    }
+    detachFrom(_parent) { }
+}

package/dist/nodes/action-row-child.d.ts

@@ -1,14 +1 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-import { VirtualChildNode } from "./virtual-child.js";
-type PrefixSuffixWidget = Gtk.Widget & {
-    addPrefix(child: Gtk.Widget): void;
-    addSuffix(child: Gtk.Widget): void;
-    remove(child: Gtk.Widget): void;
-};
-export declare class ActionRowChild extends VirtualChildNode<PrefixSuffixWidget> {
-    static priority: number;
-    static matches(type: string): boolean;
-    protected getPositionLabel(): string;
-    protected attachChild(parent: PrefixSuffixWidget, widget: Gtk.Widget): void;
-}
 export {};

package/dist/nodes/action-row-child.js

@@ -1,20 +1,30 @@
+import { PREFIX_SUFFIX_INTERFACE_METHODS } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
-import { VirtualChildNode } from "./virtual-child.js";
-export class ActionRowChild extends VirtualChildNode {
+import { VirtualContainerNode } from "./abstract/virtual-container.js";
+import { matchesInterface } from "./internal/utils.js";
+class ActionRowPrefixNode extends VirtualContainerNode {
     static priority = 1;
     static matches(type) {
-        return type === "ActionRowPrefix" || type === "ActionRowSuffix";
+        return type === "ActionRowPrefix";
     }
-    getPositionLabel() {
-        return this.typeName === "ActionRowPrefix" ? "prefix" : "suffix";
+    canBeChildOf(parent) {
+        return matchesInterface(PREFIX_SUFFIX_INTERFACE_METHODS, parent.container);
     }
     attachChild(parent, widget) {
-        if (this.getPositionLabel() === "prefix") {
-            parent.addPrefix(widget);
-        }
-        else {
-            parent.addSuffix(widget);
-        }
+        parent.addPrefix(widget);
     }
 }
-registerNodeClass(ActionRowChild);
+class ActionRowSuffixNode extends VirtualContainerNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "ActionRowSuffix";
+    }
+    canBeChildOf(parent) {
+        return matchesInterface(PREFIX_SUFFIX_INTERFACE_METHODS, parent.container);
+    }
+    attachChild(parent, widget) {
+        parent.addSuffix(widget);
+    }
+}
+registerNodeClass(ActionRowPrefixNode);
+registerNodeClass(ActionRowSuffixNode);

package/dist/nodes/adjustable.d.ts

@@ -0,0 +1,23 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import type { Container, ContainerClass, Props } from "../types.js";
+import type { AdjustableWidget } from "./internal/predicates.js";
+import { WidgetNode } from "./widget.js";
+type AdjustableProps = Props & {
+    value?: number;
+    lower?: number;
+    upper?: number;
+    stepIncrement?: number;
+    pageIncrement?: number;
+    pageSize?: number;
+    onValueChanged?: ((value: number, self: AdjustableWidget) => void) | null;
+};
+export declare class AdjustableNode<T extends AdjustableWidget = AdjustableWidget> extends WidgetNode<T, AdjustableProps> {
+    static priority: number;
+    private adjustment;
+    static matches(_type: string, containerOrClass?: Container | ContainerClass | null): boolean;
+    updateProps(oldProps: AdjustableProps | null, newProps: AdjustableProps): void;
+    protected ensureAdjustment(props: AdjustableProps): Gtk.Adjustment;
+    protected applyOwnProps(oldProps: AdjustableProps | null, newProps: AdjustableProps): void;
+    private updateValueChangedHandler;
+}
+export {};

package/dist/nodes/adjustable.js

@@ -0,0 +1,62 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+import { ADJUSTABLE_INTERFACE_METHODS } from "../generated/internal.js";
+import { registerNodeClass } from "../registry.js";
+import { filterProps, hasChanged, matchesInterface } from "./internal/utils.js";
+import { WidgetNode } from "./widget.js";
+const OWN_PROPS = ["value", "lower", "upper", "stepIncrement", "pageIncrement", "pageSize", "onValueChanged"];
+export class AdjustableNode extends WidgetNode {
+    static priority = 2;
+    adjustment = null;
+    static matches(_type, containerOrClass) {
+        return matchesInterface(ADJUSTABLE_INTERFACE_METHODS, containerOrClass);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
+    }
+    ensureAdjustment(props) {
+        if (!this.adjustment) {
+            this.adjustment = new Gtk.Adjustment(props.value ?? 0, props.lower ?? 0, props.upper ?? 100, props.stepIncrement ?? 1, props.pageIncrement ?? 10, props.pageSize ?? 0);
+            this.container.setAdjustment(this.adjustment);
+        }
+        return this.adjustment;
+    }
+    applyOwnProps(oldProps, newProps) {
+        const adjustment = this.ensureAdjustment(newProps);
+        if (hasChanged(oldProps, newProps, "onValueChanged")) {
+            this.updateValueChangedHandler(newProps);
+        }
+        if (!oldProps)
+            return;
+        if (hasChanged(oldProps, newProps, "lower")) {
+            adjustment.setLower(newProps.lower ?? 0);
+        }
+        if (hasChanged(oldProps, newProps, "upper")) {
+            adjustment.setUpper(newProps.upper ?? 100);
+        }
+        if (hasChanged(oldProps, newProps, "stepIncrement")) {
+            adjustment.setStepIncrement(newProps.stepIncrement ?? 1);
+        }
+        if (hasChanged(oldProps, newProps, "pageIncrement")) {
+            adjustment.setPageIncrement(newProps.pageIncrement ?? 10);
+        }
+        if (hasChanged(oldProps, newProps, "pageSize")) {
+            adjustment.setPageSize(newProps.pageSize ?? 0);
+        }
+        if (hasChanged(oldProps, newProps, "value") && newProps.value !== undefined) {
+            adjustment.setValue(newProps.value);
+        }
+    }
+    updateValueChangedHandler(props) {
+        if (!this.adjustment)
+            return;
+        const { onValueChanged } = props;
+        if (onValueChanged) {
+            this.signalStore.set(this, this.container, "value-changed", (self) => onValueChanged(self.getValue(), self));
+        }
+        else {
+            this.signalStore.set(this, this.container, "value-changed", null);
+        }
+    }
+}
+registerNodeClass(AdjustableNode);

package/dist/nodes/alert-dialog-response.js

@@ -0,0 +1,86 @@
+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";
+import { WidgetNode } from "./widget.js";
+class AlertDialogResponseNode extends VirtualNode {
+    static priority = 1;
+    dialog = null;
+    responseId = null;
+    static matches(type) {
+        return type === "AlertDialogResponse";
+    }
+    canBeChildOf(parent) {
+        return parent instanceof WidgetNode && parent.container instanceof Adw.AlertDialog;
+    }
+    attachTo(parent) {
+        if (!(parent instanceof WidgetNode) || !(parent.container instanceof Adw.AlertDialog)) {
+            return;
+        }
+        if (this.dialog)
+            return;
+        this.dialog = parent.container;
+        this.responseId = this.props.id;
+        const dialog = this.dialog;
+        const id = this.responseId;
+        const label = this.props.label;
+        scheduleAfterCommit(() => {
+            if (this.dialog) {
+                dialog.addResponse(id, label);
+                this.applyOptionalProps(null, this.props);
+            }
+        }, CommitPriority.NORMAL);
+    }
+    detachFrom(_parent) {
+        this.removeFromDialog();
+    }
+    removeFromDialog() {
+        if (!this.dialog || !this.responseId)
+            return;
+        const dialog = this.dialog;
+        const id = this.responseId;
+        this.dialog = null;
+        this.responseId = null;
+        scheduleAfterCommit(() => {
+            dialog.removeResponse(id);
+        }, CommitPriority.HIGH);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        if (!this.dialog || !this.responseId)
+            return;
+        if (hasChanged(oldProps, newProps, "id")) {
+            const oldId = this.responseId;
+            const newId = newProps.id;
+            const dialog = this.dialog;
+            const label = newProps.label;
+            this.responseId = newId;
+            scheduleAfterCommit(() => {
+                dialog.removeResponse(oldId);
+                dialog.addResponse(newId, label);
+                this.applyOptionalProps(null, newProps);
+            }, CommitPriority.NORMAL);
+            return;
+        }
+        if (hasChanged(oldProps, newProps, "label")) {
+            this.dialog.setResponseLabel(this.responseId, newProps.label);
+        }
+        this.applyOptionalProps(oldProps, newProps);
+    }
+    applyOptionalProps(oldProps, newProps) {
+        if (!this.dialog || !this.responseId)
+            return;
+        if (hasChanged(oldProps, newProps, "appearance") && newProps.appearance !== undefined) {
+            this.dialog.setResponseAppearance(this.responseId, newProps.appearance);
+        }
+        if (hasChanged(oldProps, newProps, "enabled") && newProps.enabled !== undefined) {
+            this.dialog.setResponseEnabled(this.responseId, newProps.enabled);
+        }
+    }
+    unmount() {
+        this.removeFromDialog();
+        super.unmount();
+    }
+}
+registerNodeClass(AlertDialogResponseNode);