@gtkx/react 0.15.0 → 0.16.0

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/positional-parent.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 { WidgetNode } from "../widget.js";
+type PositionalChildParentWidget = Gtk.Widget & {
+    remove(child: Gtk.Widget): void;
+};
+export declare abstract class PositionalParentNode<T extends PositionalChildParentWidget = PositionalChildParentWidget, P extends Props = Props> extends WidgetNode<T, P> {
+    protected abstract acceptedPositionalChildTypes: Set<string>;
+    protected abstract containerTypeName: string;
+    private isPositionalChild;
+    private formatExpectedTypes;
+    private assertValidChild;
+    appendChild(child: Node): void;
+    insertBefore(child: Node, before: Node): void;
+    removeChild(child: Node): void;
+}
+export {};

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

@@ -0,0 +1,48 @@
+import { SlotNode } from "../slot.js";
+import { WidgetNode } from "../widget.js";
+import { VirtualContainerNode } from "./virtual-container.js";
+export class PositionalParentNode extends WidgetNode {
+    isPositionalChild(child) {
+        return child instanceof VirtualContainerNode && this.acceptedPositionalChildTypes.has(child.typeName);
+    }
+    formatExpectedTypes() {
+        const types = Array.from(this.acceptedPositionalChildTypes)
+            .map((t) => `x.${t}`)
+            .join(", ");
+        return `${types}, or Widget`;
+    }
+    assertValidChild(child, operation) {
+        if (child instanceof SlotNode || child instanceof WidgetNode)
+            return;
+        const [verb, prep] = operation === "append"
+            ? ["append", "to"]
+            : operation === "insert"
+                ? ["insert", "into"]
+                : ["remove", "from"];
+        throw new Error(`Cannot ${verb} '${child.typeName}' ${prep} '${this.containerTypeName}': expected ${this.formatExpectedTypes()}`);
+    }
+    appendChild(child) {
+        if (this.isPositionalChild(child)) {
+            child.setParent(this.container);
+            return;
+        }
+        this.assertValidChild(child, "append");
+        super.appendChild(child);
+    }
+    insertBefore(child, before) {
+        if (this.isPositionalChild(child)) {
+            child.setParent(this.container);
+            return;
+        }
+        this.assertValidChild(child, "insert");
+        super.insertBefore(child, before);
+    }
+    removeChild(child) {
+        if (this.isPositionalChild(child)) {
+            child.unmount();
+            return;
+        }
+        this.assertValidChild(child, "remove");
+        super.removeChild(child);
+    }
+}

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

@@ -0,0 +1,17 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Node } from "../../node.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 {
+    protected parent: P | null;
+    setParent(newParent: P | null): void;
+    protected getParent(): P;
+    protected abstract attachChild(parent: P, widget: Gtk.Widget): 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,59 @@
+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;
+    }
+    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,54 @@
+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 (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,22 @@
 import { registerNodeClass } from "../registry.js";
-import { VirtualChildNode } from "./virtual-child.js";
-export class ActionRowChild extends VirtualChildNode {
+import { VirtualContainerNode } from "./abstract/virtual-container.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";
+    attachChild(parent, widget) {
+        parent.addPrefix(widget);
+    }
+}
+class ActionRowSuffixNode extends VirtualContainerNode {
+    static priority = 1;
+    static matches(type) {
+        return type === "ActionRowSuffix";
     }
     attachChild(parent, widget) {
-        if (this.getPositionLabel() === "prefix") {
-            parent.addPrefix(widget);
-        }
-        else {
-            parent.addSuffix(widget);
-        }
+        parent.addSuffix(widget);
     }
 }
-registerNodeClass(ActionRowChild);
+registerNodeClass(ActionRowPrefixNode);
+registerNodeClass(ActionRowSuffixNode);

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

@@ -1 +1,6 @@
-export {};
+import type * as Gtk from "@gtkx/ffi/gtk";
+export type PrefixSuffixWidget = Gtk.Widget & {
+    addPrefix(child: Gtk.Widget): void;
+    addSuffix(child: Gtk.Widget): void;
+    remove(child: Gtk.Widget): void;
+};

package/dist/nodes/action-row.js

@@ -1,46 +1,13 @@
 import { PREFIX_SUFFIX_INTERFACE_METHODS } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
-import { ActionRowChild } from "./action-row-child.js";
+import { PositionalParentNode } from "./abstract/positional-parent.js";
 import { matchesInterface } from "./internal/utils.js";
-import { SlotNode } from "./slot.js";
-import { WidgetNode } from "./widget.js";
-class ActionRowNode extends WidgetNode {
+class ActionRowNode extends PositionalParentNode {
     static priority = 0;
+    acceptedPositionalChildTypes = new Set(["ActionRowPrefix", "ActionRowSuffix"]);
+    containerTypeName = "ActionRow";
     static matches(_type, containerOrClass) {
         return matchesInterface(PREFIX_SUFFIX_INTERFACE_METHODS, containerOrClass);
     }
-    appendChild(child) {
-        if (child instanceof ActionRowChild) {
-            child.setParent(this.container);
-            return;
-        }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.appendChild(child);
-            return;
-        }
-        throw new Error(`Cannot append '${child.typeName}' to 'ActionRow': expected x.ActionRowPrefix, x.ActionRowSuffix, or Widget`);
-    }
-    insertBefore(child, before) {
-        if (child instanceof ActionRowChild) {
-            child.setParent(this.container);
-            return;
-        }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.insertBefore(child, before);
-            return;
-        }
-        throw new Error(`Cannot insert '${child.typeName}' into 'ActionRow': expected x.ActionRowPrefix, x.ActionRowSuffix, or Widget`);
-    }
-    removeChild(child) {
-        if (child instanceof ActionRowChild) {
-            child.unmount();
-            return;
-        }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.removeChild(child);
-            return;
-        }
-        throw new Error(`Cannot remove '${child.typeName}' from 'ActionRow': expected x.ActionRowPrefix, x.ActionRowSuffix, or Widget`);
-    }
 }
 registerNodeClass(ActionRowNode);

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.d.ts

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

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);

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

@@ -0,0 +1,17 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import { type Transition } from "./animation-factory.js";
+import { type AnimatableProperty } from "./property-mapper.js";
+export type AnimatableProperties = Partial<Record<AnimatableProperty, number>>;
+export declare class AnimationController {
+    private widget;
+    private activeAnimations;
+    private pendingCompletions;
+    private onComplete;
+    setWidget(widget: Gtk.Widget | null): void;
+    applyImmediate(properties: AnimatableProperties): void;
+    animate(from: AnimatableProperties, to: AnimatableProperties, transition: Transition, onComplete?: () => void): void;
+    private startPropertyAnimation;
+    private onAnimationDone;
+    skipAll(): void;
+    dispose(): void;
+}

package/dist/nodes/animation/animation-controller.js

@@ -0,0 +1,107 @@
+import * as Adw from "@gtkx/ffi/adw";
+import { createAnimation } from "./animation-factory.js";
+import { getPropertyAccessor, isAnimatableProperty, isTransformProperty, } from "./property-mapper.js";
+import { registerWidget, unregisterWidget } from "./widget-registry.js";
+const DEFAULT_SPRING = { type: "spring", stiffness: 100, damping: 10 };
+const DEFAULT_TIMED = { type: "timed", duration: 250, easing: Adw.Easing.EASE_OUT_CUBIC };
+function getDefaultTransition(property) {
+    return isTransformProperty(property) ? DEFAULT_SPRING : DEFAULT_TIMED;
+}
+function isEmptyTransition(transition) {
+    return transition.type === undefined && !("duration" in transition) && !("stiffness" in transition);
+}
+export class AnimationController {
+    widget = null;
+    activeAnimations = new Map();
+    pendingCompletions = new Set();
+    onComplete = null;
+    setWidget(widget) {
+        if (this.widget === widget)
+            return;
+        if (this.widget) {
+            this.skipAll();
+            unregisterWidget(this.widget);
+        }
+        this.widget = widget;
+        if (widget) {
+            registerWidget(widget);
+        }
+    }
+    applyImmediate(properties) {
+        if (!this.widget)
+            return;
+        for (const [key, value] of Object.entries(properties)) {
+            if (value === undefined || !isAnimatableProperty(key))
+                continue;
+            const accessor = getPropertyAccessor(key);
+            accessor.set(this.widget, value);
+        }
+    }
+    animate(from, to, transition, onComplete) {
+        if (!this.widget)
+            return;
+        this.skipAll();
+        this.onComplete = onComplete ?? null;
+        this.pendingCompletions.clear();
+        const useDefaultTransitions = isEmptyTransition(transition);
+        const propertiesToAnimate = new Set([...Object.keys(from), ...Object.keys(to)]);
+        for (const key of propertiesToAnimate) {
+            if (!isAnimatableProperty(key))
+                continue;
+            const fromValue = from[key];
+            const toValue = to[key];
+            if (fromValue === undefined && toValue === undefined)
+                continue;
+            const accessor = getPropertyAccessor(key);
+            const currentValue = fromValue ?? accessor.get(this.widget);
+            const targetValue = toValue ?? accessor.get(this.widget);
+            if (currentValue === targetValue)
+                continue;
+            const effectiveTransition = useDefaultTransitions ? getDefaultTransition(key) : transition;
+            this.pendingCompletions.add(key);
+            this.startPropertyAnimation(key, currentValue, targetValue, effectiveTransition);
+        }
+        if (this.pendingCompletions.size === 0 && this.onComplete) {
+            this.onComplete();
+            this.onComplete = null;
+        }
+    }
+    startPropertyAnimation(property, from, to, transition) {
+        if (!this.widget)
+            return;
+        const accessor = getPropertyAccessor(property);
+        const widget = this.widget;
+        const animation = createAnimation(widget, from, to, transition, (value) => {
+            accessor.set(widget, value);
+        });
+        const connectionId = animation.connect("done", () => {
+            this.onAnimationDone(property);
+        });
+        this.activeAnimations.set(property, { animation, connectionId });
+        animation.play();
+    }
+    onAnimationDone(property) {
+        this.activeAnimations.delete(property);
+        this.pendingCompletions.delete(property);
+        if (this.pendingCompletions.size === 0 && this.onComplete) {
+            const callback = this.onComplete;
+            this.onComplete = null;
+            callback();
+        }
+    }
+    skipAll() {
+        this.onComplete = null;
+        this.pendingCompletions.clear();
+        for (const { animation } of this.activeAnimations.values()) {
+            animation.skip();
+        }
+        this.activeAnimations.clear();
+    }
+    dispose() {
+        this.skipAll();
+        if (this.widget) {
+            unregisterWidget(this.widget);
+        }
+        this.widget = null;
+    }
+}