@gtkx/react 0.16.0 → 0.17.2

package/dist/nodes/shortcut-controller.js

@@ -1,42 +1,18 @@
-import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
-import { hasChanged } from "./internal/utils.js";
+import { EventControllerNode } from "./event-controller.js";
 import { ShortcutNode } from "./shortcut.js";
-import { VirtualNode } from "./virtual.js";
-import { WidgetNode } from "./widget.js";
-class ShortcutControllerNode extends VirtualNode {
+class ShortcutControllerNode extends EventControllerNode {
     static priority = 0;
     static matches(type) {
         return type === "GtkShortcutController";
     }
-    controller = null;
-    parentWidget = null;
     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 = null;
-        }
-    }
     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))
@@ -44,46 +20,15 @@ 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);
-        this.applyOwnProps(oldProps, newProps);
-    }
-    applyOwnProps(oldProps, newProps) {
-        if (hasChanged(oldProps, newProps, "scope")) {
-            this.applyScope();
-        }
-    }
-    unmount() {
-        this.setParent(null);
-        super.unmount();
-    }
-    canBeChildOf(parent) {
-        return parent instanceof WidgetNode;
-    }
-    attachTo(parent) {
-        if (parent instanceof WidgetNode) {
-            this.setParent(parent.container);
-        }
-    }
-    detachFrom(_parent) {
-        this.setParent(null);
-    }
-    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/slot.js

@@ -10,7 +10,7 @@ export class SlotNode extends VirtualSingleChildNode {
     }
     cachedSetter = null;
     setParent(parent) {
-        if (this.parent !== parent) {
+        if (!isObjectEqual(this.parent, parent)) {
             this.cachedSetter = null;
         }
         super.setParent(parent);

package/dist/nodes/text-paintable.d.ts

@@ -1,7 +1,13 @@
 import type * as Gdk from "@gtkx/ffi/gdk";
 import * as Gtk from "@gtkx/ffi/gtk";
 import { VirtualNode } from "./virtual.js";
+/**
+ * Props for the TextPaintable virtual element.
+ *
+ * Used to embed inline images or icons within text content in a GtkTextView.
+ */
 export type TextPaintableProps = {
+    /** The paintable (image, icon, etc.) to embed inline with the text */
     paintable: Gdk.Paintable;
 };
 export declare class TextPaintableNode extends VirtualNode<TextPaintableProps> {

package/dist/nodes/toggle-group.js

@@ -21,7 +21,7 @@ class ToggleGroupNode extends WidgetNode {
             this.notifyHandler = null;
         }
         if (callback) {
-            this.notifyHandler = (pspec, _toggleGroup) => {
+            this.notifyHandler = (pspec) => {
                 if (pspec.getName() === "active") {
                     callback(this.container.getActive(), this.container.getActiveName());
                 }

package/dist/nodes/toolbar-child.js

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

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

@@ -1,3 +1,4 @@
+import { isObjectEqual } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
 import { TreeListItemRenderer } from "./internal/tree-list-item-renderer.js";
@@ -67,7 +68,7 @@ class TreeListViewNode extends WidgetNode {
         const previousModel = this.treeList.getSelectionModel();
         this.treeList.updateProps(oldProps ? filterProps(oldProps, RENDERER_PROP_NAMES) : null, filterProps(newProps, RENDERER_PROP_NAMES));
         const currentModel = this.treeList.getSelectionModel();
-        if (previousModel !== currentModel) {
+        if (!isObjectEqual(previousModel, currentModel)) {
             this.container.setModel(currentModel);
         }
         super.updateProps(oldProps ? filterProps(oldProps, PROP_NAMES) : null, filterProps(newProps, PROP_NAMES));

package/dist/nodes/web-view.d.ts

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

package/dist/nodes/web-view.js

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

package/dist/render.js

@@ -107,7 +107,7 @@ export const render = (element, appId, flags) => {
         getSignalStore(application).forceUnblockAll();
         const formattedError = formatBoundaryError(error);
         console.error(formattedError.toString());
-    }, () => { }, () => { }, null);
+    }, () => { }, () => { });
     instance.updateContainer(_jsx(ApplicationContext.Provider, { value: application, children: element }), container, null, () => { });
 };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/react",
-  "version": "0.16.0",
+  "version": "0.17.2",
   "description": "Build GTK4 desktop applications with React and TypeScript",
   "keywords": [
     "gtkx",
@@ -37,11 +37,11 @@
   ],
   "dependencies": {
     "react-reconciler": "^0.33.0",
-    "@gtkx/ffi": "0.16.0",
-    "@gtkx/gir": "0.16.0"
+    "@gtkx/ffi": "0.17.2",
+    "@gtkx/gir": "0.17.2"
   },
   "devDependencies": {
-    "@types/react-reconciler": "^0.32.3"
+    "@types/react-reconciler": "^0.33.0"
   },
   "peerDependencies": {
     "react": "^19"

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

@@ -1,18 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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/action-row.d.ts

@@ -1,6 +0,0 @@
-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,13 +0,0 @@
-import { PREFIX_SUFFIX_INTERFACE_METHODS } from "../generated/internal.js";
-import { registerNodeClass } from "../registry.js";
-import { PositionalParentNode } from "./abstract/positional-parent.js";
-import { matchesInterface } from "./internal/utils.js";
-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);
-    }
-}
-registerNodeClass(ActionRowNode);

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

@@ -1,17 +0,0 @@
-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

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

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

@@ -1,15 +0,0 @@
-import * as Adw from "@gtkx/ffi/adw";
-import type * as Gtk from "@gtkx/ffi/gtk";
-export type TimedTransition = {
-    type?: "timed";
-    duration?: number;
-    easing?: Adw.Easing;
-};
-export type SpringTransition = {
-    type: "spring";
-    stiffness?: number;
-    damping?: number;
-    mass?: number;
-};
-export type Transition = TimedTransition | SpringTransition;
-export declare function createAnimation(widget: Gtk.Widget, from: number, to: number, transition: Transition, onValue: (value: number) => void): Adw.Animation;

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

@@ -1,25 +0,0 @@
-import * as Adw from "@gtkx/ffi/adw";
-const DEFAULT_TIMED_DURATION = 250;
-const DEFAULT_SPRING_STIFFNESS = 100;
-const DEFAULT_SPRING_DAMPING = 10;
-const DEFAULT_SPRING_MASS = 1;
-function convertToDampingRatio(stiffness, damping, mass) {
-    const criticalDamping = 2 * Math.sqrt(stiffness * mass);
-    return damping / criticalDamping;
-}
-export function createAnimation(widget, from, to, transition, onValue) {
-    const target = new Adw.CallbackAnimationTarget(onValue);
-    if (transition.type === "spring") {
-        const stiffness = transition.stiffness ?? DEFAULT_SPRING_STIFFNESS;
-        const damping = transition.damping ?? DEFAULT_SPRING_DAMPING;
-        const mass = transition.mass ?? DEFAULT_SPRING_MASS;
-        const dampingRatio = convertToDampingRatio(stiffness, damping, mass);
-        const springParams = new Adw.SpringParams(dampingRatio, mass, stiffness);
-        return new Adw.SpringAnimation(widget, from, to, springParams, target);
-    }
-    const duration = transition.duration ?? DEFAULT_TIMED_DURATION;
-    const easing = transition.easing ?? Adw.Easing.EASE_OUT_CUBIC;
-    const animation = new Adw.TimedAnimation(widget, from, to, duration, target);
-    animation.setEasing(easing);
-    return animation;
-}

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

@@ -1,9 +0,0 @@
-import { type AnimatableProperties } from "./animation-controller.js";
-import type { Transition } from "./animation-factory.js";
-export type AnimationProps = {
-    initial?: AnimatableProperties;
-    animate?: AnimatableProperties;
-    transition?: Transition;
-    onAnimationComplete?: () => void;
-    children?: React.ReactNode;
-};

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

@@ -1,126 +0,0 @@
-import { registerNodeClass } from "../../registry.js";
-import { CommitPriority, scheduleAfterCommit } from "../../scheduler.js";
-import { VirtualSingleChildNode } from "../abstract/virtual-single-child.js";
-import { attachChild, detachChild, getAttachmentStrategy } from "../internal/child-attachment.js";
-import { isRemovable } from "../internal/predicates.js";
-import { WidgetNode } from "../widget.js";
-import { AnimationController } from "./animation-controller.js";
-class AnimationNode extends VirtualSingleChildNode {
-    static priority = 2;
-    controller = new AnimationController();
-    hasAppliedInitial = false;
-    hasStartedAnimation = false;
-    static matches(type) {
-        return type === "Animation";
-    }
-    appendChild(child) {
-        if (!(child instanceof WidgetNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to 'x.Animation': 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 'x.Animation': expected Widget`);
-        }
-        const oldChild = this.child;
-        scheduleAfterCommit(() => {
-            if (oldChild === this.child) {
-                this.child = null;
-                this.controller.setWidget(null);
-            }
-            if (this.parent && oldChild) {
-                this.onChildChange(oldChild);
-            }
-        }, CommitPriority.HIGH);
-    }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
-        const animateChanged = !shallowObjectEqual(oldProps?.animate, newProps.animate);
-        if (animateChanged) {
-            this.hasStartedAnimation = false;
-        }
-        if (this.child) {
-            this.controller.setWidget(this.child);
-            if (!this.hasAppliedInitial && newProps.initial) {
-                this.controller.applyImmediate(newProps.initial);
-                this.hasAppliedInitial = true;
-            }
-            if (!this.hasStartedAnimation && newProps.animate) {
-                this.hasStartedAnimation = true;
-                this.startAnimation();
-            }
-        }
-    }
-    unmount() {
-        if (this.parent && this.child) {
-            const strategy = getAttachmentStrategy(this.parent);
-            if (strategy) {
-                detachChild(this.child, strategy);
-            }
-        }
-        this.controller.dispose();
-        this.hasAppliedInitial = false;
-        this.child = null;
-        super.unmount();
-    }
-    onChildChange(oldChild) {
-        if (!this.parent)
-            return;
-        const strategy = getAttachmentStrategy(this.parent);
-        if (!strategy)
-            return;
-        if (oldChild && !this.child) {
-            detachChild(oldChild, strategy);
-        }
-        else if (oldChild && this.child && oldChild !== this.child) {
-            if (isRemovable(this.parent)) {
-                this.parent.remove(oldChild);
-            }
-            attachChild(this.child, strategy);
-        }
-        else if (!oldChild && this.child) {
-            attachChild(this.child, strategy);
-        }
-        if (!this.child)
-            return;
-        this.controller.setWidget(this.child);
-        if (!this.hasAppliedInitial && this.props.initial) {
-            this.controller.applyImmediate(this.props.initial);
-            this.hasAppliedInitial = true;
-        }
-        if (!this.hasStartedAnimation && this.props.animate) {
-            this.hasStartedAnimation = true;
-            this.startAnimation();
-        }
-    }
-    startAnimation() {
-        const from = this.props.initial ?? {};
-        const to = this.props.animate ?? {};
-        const transition = this.props.transition ?? {};
-        const onComplete = this.props.onAnimationComplete;
-        this.controller.animate(from, to, transition, onComplete);
-    }
-}
-function shallowObjectEqual(a, b) {
-    if (a === b)
-        return true;
-    if (!a || !b)
-        return false;
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length)
-        return false;
-    for (const key of keysA) {
-        if (a[key] !== b[key])
-            return false;
-    }
-    return true;
-}
-registerNodeClass(AnimationNode);