@windrun-huaiin/third-ui 14.2.0 → 14.3.1

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/gestures/press.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var eventInfo = require('../events/event-info.js');
+var Feature = require('../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/Feature.js');
+var index = require('../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/gestures/press/index.js');
+var frame = require('../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/frame.js');
+
+function handlePressEvent(node, event, lifecycle) {
+    const { props } = node;
+    if (node.current instanceof HTMLButtonElement && node.current.disabled) {
+        return;
+    }
+    if (node.animationState && props.whileTap) {
+        node.animationState.setActive("whileTap", lifecycle === "Start");
+    }
+    const eventName = ("onTap" + (lifecycle === "End" ? "" : lifecycle));
+    const callback = props[eventName];
+    if (callback) {
+        frame.frame.postRender(() => callback(event, eventInfo.extractEventInfo(event)));
+    }
+}
+class PressGesture extends Feature.Feature {
+    mount() {
+        const { current } = this.node;
+        if (!current)
+            return;
+        const { globalTapTarget, propagate } = this.node.props;
+        this.unmount = index.press(current, (_element, startEvent) => {
+            handlePressEvent(this.node, startEvent, "Start");
+            return (endEvent, { success }) => handlePressEvent(this.node, endEvent, success ? "End" : "Cancel");
+        }, {
+            useGlobalTarget: globalTapTarget,
+            stopPropagation: propagate?.tap === false,
+        });
+    }
+    unmount() { }
+}
+
+exports.PressGesture = PressGesture;

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/gestures/press.mjs

@@ -0,0 +1,37 @@
+import { extractEventInfo } from '../events/event-info.mjs';
+import { Feature } from '../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/Feature.mjs';
+import { press } from '../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/gestures/press/index.mjs';
+import { frame } from '../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/frame.mjs';
+
+function handlePressEvent(node, event, lifecycle) {
+    const { props } = node;
+    if (node.current instanceof HTMLButtonElement && node.current.disabled) {
+        return;
+    }
+    if (node.animationState && props.whileTap) {
+        node.animationState.setActive("whileTap", lifecycle === "Start");
+    }
+    const eventName = ("onTap" + (lifecycle === "End" ? "" : lifecycle));
+    const callback = props[eventName];
+    if (callback) {
+        frame.postRender(() => callback(event, extractEventInfo(event)));
+    }
+}
+class PressGesture extends Feature {
+    mount() {
+        const { current } = this.node;
+        if (!current)
+            return;
+        const { globalTapTarget, propagate } = this.node.props;
+        this.unmount = press(current, (_element, startEvent) => {
+            handlePressEvent(this.node, startEvent, "Start");
+            return (endEvent, { success }) => handlePressEvent(this.node, endEvent, success ? "End" : "Cancel");
+        }, {
+            useGlobalTarget: globalTapTarget,
+            stopPropagation: propagate?.tap === false,
+        });
+    }
+    unmount() { }
+}
+
+export { PressGesture };

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/animation/exit.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var Feature = require('../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/Feature.js');
+var resolveDynamicVariants = require('../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/utils/resolve-dynamic-variants.js');
+
+let id = 0;
+class ExitAnimationFeature extends Feature.Feature {
+    constructor() {
+        super(...arguments);
+        this.id = id++;
+        this.isExitComplete = false;
+    }
+    update() {
+        if (!this.node.presenceContext)
+            return;
+        const { isPresent, onExitComplete } = this.node.presenceContext;
+        const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};
+        if (!this.node.animationState || isPresent === prevIsPresent) {
+            return;
+        }
+        if (isPresent && prevIsPresent === false) {
+            /**
+             * When re-entering, if the exit animation already completed
+             * (element is at rest), reset to initial values so the enter
+             * animation replays from the correct position.
+             */
+            if (this.isExitComplete) {
+                const { initial, custom } = this.node.getProps();
+                if (typeof initial === "string") {
+                    const resolved = resolveDynamicVariants.resolveVariant(this.node, initial, custom);
+                    if (resolved) {
+                        const { transition, transitionEnd, ...target } = resolved;
+                        for (const key in target) {
+                            this.node
+                                .getValue(key)
+                                ?.jump(target[key]);
+                        }
+                    }
+                }
+                this.node.animationState.reset();
+                this.node.animationState.animateChanges();
+            }
+            else {
+                this.node.animationState.setActive("exit", false);
+            }
+            this.isExitComplete = false;
+            return;
+        }
+        const exitAnimation = this.node.animationState.setActive("exit", !isPresent);
+        if (onExitComplete && !isPresent) {
+            exitAnimation.then(() => {
+                this.isExitComplete = true;
+                onExitComplete(this.id);
+            });
+        }
+    }
+    mount() {
+        const { register, onExitComplete } = this.node.presenceContext || {};
+        if (onExitComplete) {
+            onExitComplete(this.id);
+        }
+        if (register) {
+            this.unmount = register(this.id);
+        }
+    }
+    unmount() { }
+}
+
+exports.ExitAnimationFeature = ExitAnimationFeature;

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/animation/exit.mjs

@@ -0,0 +1,67 @@
+import { Feature } from '../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/Feature.mjs';
+import { resolveVariant } from '../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/utils/resolve-dynamic-variants.mjs';
+
+let id = 0;
+class ExitAnimationFeature extends Feature {
+    constructor() {
+        super(...arguments);
+        this.id = id++;
+        this.isExitComplete = false;
+    }
+    update() {
+        if (!this.node.presenceContext)
+            return;
+        const { isPresent, onExitComplete } = this.node.presenceContext;
+        const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};
+        if (!this.node.animationState || isPresent === prevIsPresent) {
+            return;
+        }
+        if (isPresent && prevIsPresent === false) {
+            /**
+             * When re-entering, if the exit animation already completed
+             * (element is at rest), reset to initial values so the enter
+             * animation replays from the correct position.
+             */
+            if (this.isExitComplete) {
+                const { initial, custom } = this.node.getProps();
+                if (typeof initial === "string") {
+                    const resolved = resolveVariant(this.node, initial, custom);
+                    if (resolved) {
+                        const { transition, transitionEnd, ...target } = resolved;
+                        for (const key in target) {
+                            this.node
+                                .getValue(key)
+                                ?.jump(target[key]);
+                        }
+                    }
+                }
+                this.node.animationState.reset();
+                this.node.animationState.animateChanges();
+            }
+            else {
+                this.node.animationState.setActive("exit", false);
+            }
+            this.isExitComplete = false;
+            return;
+        }
+        const exitAnimation = this.node.animationState.setActive("exit", !isPresent);
+        if (onExitComplete && !isPresent) {
+            exitAnimation.then(() => {
+                this.isExitComplete = true;
+                onExitComplete(this.id);
+            });
+        }
+    }
+    mount() {
+        const { register, onExitComplete } = this.node.presenceContext || {};
+        if (onExitComplete) {
+            onExitComplete(this.id);
+        }
+        if (register) {
+            this.unmount = register(this.id);
+        }
+    }
+    unmount() { }
+}
+
+export { ExitAnimationFeature };

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/animation/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var Feature = require('../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/Feature.js');
+var animationState = require('../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/utils/animation-state.js');
+var isAnimationControls = require('../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/utils/is-animation-controls.js');
+
+class AnimationFeature extends Feature.Feature {
+    /**
+     * We dynamically generate the AnimationState manager as it contains a reference
+     * to the underlying animation library. We only want to load that if we load this,
+     * so people can optionally code split it out using the `m` component.
+     */
+    constructor(node) {
+        super(node);
+        node.animationState || (node.animationState = animationState.createAnimationState(node));
+    }
+    updateAnimationControlsSubscription() {
+        const { animate } = this.node.getProps();
+        if (isAnimationControls.isAnimationControls(animate)) {
+            this.unmountControls = animate.subscribe(this.node);
+        }
+    }
+    /**
+     * Subscribe any provided AnimationControls to the component's VisualElement
+     */
+    mount() {
+        this.updateAnimationControlsSubscription();
+    }
+    update() {
+        const { animate } = this.node.getProps();
+        const { animate: prevAnimate } = this.node.prevProps || {};
+        if (animate !== prevAnimate) {
+            this.updateAnimationControlsSubscription();
+        }
+    }
+    unmount() {
+        this.node.animationState.reset();
+        this.unmountControls?.();
+    }
+}
+
+exports.AnimationFeature = AnimationFeature;

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/animation/index.mjs

@@ -0,0 +1,40 @@
+import { Feature } from '../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/Feature.mjs';
+import { createAnimationState } from '../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/utils/animation-state.mjs';
+import { isAnimationControls } from '../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/utils/is-animation-controls.mjs';
+
+class AnimationFeature extends Feature {
+    /**
+     * We dynamically generate the AnimationState manager as it contains a reference
+     * to the underlying animation library. We only want to load that if we load this,
+     * so people can optionally code split it out using the `m` component.
+     */
+    constructor(node) {
+        super(node);
+        node.animationState || (node.animationState = createAnimationState(node));
+    }
+    updateAnimationControlsSubscription() {
+        const { animate } = this.node.getProps();
+        if (isAnimationControls(animate)) {
+            this.unmountControls = animate.subscribe(this.node);
+        }
+    }
+    /**
+     * Subscribe any provided AnimationControls to the component's VisualElement
+     */
+    mount() {
+        this.updateAnimationControlsSubscription();
+    }
+    update() {
+        const { animate } = this.node.getProps();
+        const { animate: prevAnimate } = this.node.prevProps || {};
+        if (animate !== prevAnimate) {
+            this.updateAnimationControlsSubscription();
+        }
+    }
+    unmount() {
+        this.node.animationState.reset();
+        this.unmountControls?.();
+    }
+}
+
+export { AnimationFeature };

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/animations.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var index = require('./animation/index.js');
+var exit = require('./animation/exit.js');
+
+const animations = {
+    animation: {
+        Feature: index.AnimationFeature,
+    },
+    exit: {
+        Feature: exit.ExitAnimationFeature,
+    },
+};
+
+exports.animations = animations;

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/animations.mjs

@@ -0,0 +1,13 @@
+import { AnimationFeature } from './animation/index.mjs';
+import { ExitAnimationFeature } from './animation/exit.mjs';
+
+const animations = {
+    animation: {
+        Feature: AnimationFeature,
+    },
+    exit: {
+        Feature: ExitAnimationFeature,
+    },
+};
+
+export { animations };

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/definitions.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var VisualElement = require('../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/VisualElement.js');
+
+const featureProps = {
+    animation: [
+        "animate",
+        "variants",
+        "whileHover",
+        "whileTap",
+        "exit",
+        "whileInView",
+        "whileFocus",
+        "whileDrag",
+    ],
+    exit: ["exit"],
+    drag: ["drag", "dragControls"],
+    focus: ["whileFocus"],
+    hover: ["whileHover", "onHoverStart", "onHoverEnd"],
+    tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
+    pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
+    inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
+    layout: ["layout", "layoutId"],
+};
+let isInitialized = false;
+/**
+ * Initialize feature definitions with isEnabled checks.
+ * This must be called before any motion components are rendered.
+ */
+function initFeatureDefinitions() {
+    if (isInitialized)
+        return;
+    const initialFeatureDefinitions = {};
+    for (const key in featureProps) {
+        initialFeatureDefinitions[key] = {
+            isEnabled: (props) => featureProps[key].some((name) => !!props[name]),
+        };
+    }
+    VisualElement.setFeatureDefinitions(initialFeatureDefinitions);
+    isInitialized = true;
+}
+/**
+ * Get the current feature definitions, initializing if needed.
+ */
+function getInitializedFeatureDefinitions() {
+    initFeatureDefinitions();
+    return VisualElement.getFeatureDefinitions();
+}
+
+exports.getInitializedFeatureDefinitions = getInitializedFeatureDefinitions;
+exports.initFeatureDefinitions = initFeatureDefinitions;

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/definitions.mjs

@@ -0,0 +1,48 @@
+import { getFeatureDefinitions, setFeatureDefinitions } from '../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/VisualElement.mjs';
+
+const featureProps = {
+    animation: [
+        "animate",
+        "variants",
+        "whileHover",
+        "whileTap",
+        "exit",
+        "whileInView",
+        "whileFocus",
+        "whileDrag",
+    ],
+    exit: ["exit"],
+    drag: ["drag", "dragControls"],
+    focus: ["whileFocus"],
+    hover: ["whileHover", "onHoverStart", "onHoverEnd"],
+    tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
+    pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
+    inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
+    layout: ["layout", "layoutId"],
+};
+let isInitialized = false;
+/**
+ * Initialize feature definitions with isEnabled checks.
+ * This must be called before any motion components are rendered.
+ */
+function initFeatureDefinitions() {
+    if (isInitialized)
+        return;
+    const initialFeatureDefinitions = {};
+    for (const key in featureProps) {
+        initialFeatureDefinitions[key] = {
+            isEnabled: (props) => featureProps[key].some((name) => !!props[name]),
+        };
+    }
+    setFeatureDefinitions(initialFeatureDefinitions);
+    isInitialized = true;
+}
+/**
+ * Get the current feature definitions, initializing if needed.
+ */
+function getInitializedFeatureDefinitions() {
+    initFeatureDefinitions();
+    return getFeatureDefinitions();
+}
+
+export { getInitializedFeatureDefinitions, initFeatureDefinitions };

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/drag.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var index = require('../../gestures/drag/index.js');
+var index$1 = require('../../gestures/pan/index.js');
+var MeasureLayout = require('./layout/MeasureLayout.js');
+var HTMLProjectionNode = require('../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/node/HTMLProjectionNode.js');
+
+const drag = {
+    pan: {
+        Feature: index$1.PanGesture,
+    },
+    drag: {
+        Feature: index.DragGesture,
+        ProjectionNode: HTMLProjectionNode.HTMLProjectionNode,
+        MeasureLayout: MeasureLayout.MeasureLayout,
+    },
+};
+
+exports.drag = drag;

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/drag.mjs

@@ -0,0 +1,17 @@
+import { DragGesture } from '../../gestures/drag/index.mjs';
+import { PanGesture } from '../../gestures/pan/index.mjs';
+import { MeasureLayout } from './layout/MeasureLayout.mjs';
+import { HTMLProjectionNode } from '../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/node/HTMLProjectionNode.mjs';
+
+const drag = {
+    pan: {
+        Feature: PanGesture,
+    },
+    drag: {
+        Feature: DragGesture,
+        ProjectionNode: HTMLProjectionNode,
+        MeasureLayout,
+    },
+};
+
+export { drag };

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/gestures.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var hover = require('../../gestures/hover.js');
+var focus = require('../../gestures/focus.js');
+var press = require('../../gestures/press.js');
+var index = require('./viewport/index.js');
+
+const gestureAnimations = {
+    inView: {
+        Feature: index.InViewFeature,
+    },
+    tap: {
+        Feature: press.PressGesture,
+    },
+    focus: {
+        Feature: focus.FocusGesture,
+    },
+    hover: {
+        Feature: hover.HoverGesture,
+    },
+};
+
+exports.gestureAnimations = gestureAnimations;

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/gestures.mjs

@@ -0,0 +1,21 @@
+import { HoverGesture } from '../../gestures/hover.mjs';
+import { FocusGesture } from '../../gestures/focus.mjs';
+import { PressGesture } from '../../gestures/press.mjs';
+import { InViewFeature } from './viewport/index.mjs';
+
+const gestureAnimations = {
+    inView: {
+        Feature: InViewFeature,
+    },
+    tap: {
+        Feature: PressGesture,
+    },
+    focus: {
+        Feature: FocusGesture,
+    },
+    hover: {
+        Feature: HoverGesture,
+    },
+};
+
+export { gestureAnimations };

package/dist/node_modules/.pnpm/framer-motion@12.38.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.js

@@ -0,0 +1,139 @@
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var usePresence = require('../../../components/AnimatePresence/use-presence.js');
+var LayoutGroupContext = require('../../../context/LayoutGroupContext.js');
+var SwitchLayoutGroupContext = require('../../../context/SwitchLayoutGroupContext.js');
+var state = require('../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/node/state.js');
+var frame = require('../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/frame.js');
+var microtask = require('../../../../../../../../motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/microtask.js');
+
+/**
+ * Track whether we've taken any snapshots yet. If not,
+ * we can safely skip notification of didUpdate.
+ *
+ * Difficult to capture in a test but to prevent flickering
+ * we must set this to true either on update or unmount.
+ * Running `next-env/layout-id` in Safari will show this behaviour if broken.
+ */
+let hasTakenAnySnapshot = false;
+class MeasureLayoutWithContext extends React.Component {
+    /**
+     * This only mounts projection nodes for components that
+     * need measuring, we might want to do it for all components
+     * in order to incorporate transforms
+     */
+    componentDidMount() {
+        const { visualElement, layoutGroup, switchLayoutGroup, layoutId } = this.props;
+        const { projection } = visualElement;
+        if (projection) {
+            if (layoutGroup.group)
+                layoutGroup.group.add(projection);
+            if (switchLayoutGroup && switchLayoutGroup.register && layoutId) {
+                switchLayoutGroup.register(projection);
+            }
+            if (hasTakenAnySnapshot) {
+                projection.root.didUpdate();
+            }
+            projection.addEventListener("animationComplete", () => {
+                this.safeToRemove();
+            });
+            projection.setOptions({
+                ...projection.options,
+                layoutDependency: this.props.layoutDependency,
+                onExitComplete: () => this.safeToRemove(),
+            });
+        }
+        state.globalProjectionState.hasEverUpdated = true;
+    }
+    getSnapshotBeforeUpdate(prevProps) {
+        const { layoutDependency, visualElement, drag, isPresent } = this.props;
+        const { projection } = visualElement;
+        if (!projection)
+            return null;
+        /**
+         * TODO: We use this data in relegate to determine whether to
+         * promote a previous element. There's no guarantee its presence data
+         * will have updated by this point - if a bug like this arises it will
+         * have to be that we markForRelegation and then find a new lead some other way,
+         * perhaps in didUpdate
+         */
+        projection.isPresent = isPresent;
+        if (prevProps.layoutDependency !== layoutDependency) {
+            projection.setOptions({
+                ...projection.options,
+                layoutDependency,
+            });
+        }
+        hasTakenAnySnapshot = true;
+        if (drag ||
+            prevProps.layoutDependency !== layoutDependency ||
+            layoutDependency === undefined ||
+            prevProps.isPresent !== isPresent) {
+            projection.willUpdate();
+        }
+        else {
+            this.safeToRemove();
+        }
+        if (prevProps.isPresent !== isPresent) {
+            if (isPresent) {
+                projection.promote();
+            }
+            else if (!projection.relegate()) {
+                /**
+                 * If there's another stack member taking over from this one,
+                 * it's in charge of the exit animation and therefore should
+                 * be in charge of the safe to remove. Otherwise we call it here.
+                 */
+                frame.frame.postRender(() => {
+                    const stack = projection.getStack();
+                    if (!stack || !stack.members.length) {
+                        this.safeToRemove();
+                    }
+                });
+            }
+        }
+        return null;
+    }
+    componentDidUpdate() {
+        const { visualElement, layoutAnchor } = this.props;
+        const { projection } = visualElement;
+        if (projection) {
+            projection.options.layoutAnchor = layoutAnchor;
+            projection.root.didUpdate();
+            microtask.microtask.postRender(() => {
+                if (!projection.currentAnimation && projection.isLead()) {
+                    this.safeToRemove();
+                }
+            });
+        }
+    }
+    componentWillUnmount() {
+        const { visualElement, layoutGroup, switchLayoutGroup: promoteContext, } = this.props;
+        const { projection } = visualElement;
+        hasTakenAnySnapshot = true;
+        if (projection) {
+            projection.scheduleCheckAfterUnmount();
+            if (layoutGroup && layoutGroup.group)
+                layoutGroup.group.remove(projection);
+            if (promoteContext && promoteContext.deregister)
+                promoteContext.deregister(projection);
+        }
+    }
+    safeToRemove() {
+        const { safeToRemove } = this.props;
+        safeToRemove && safeToRemove();
+    }
+    render() {
+        return null;
+    }
+}
+function MeasureLayout(props) {
+    const [isPresent, safeToRemove] = usePresence.usePresence();
+    const layoutGroup = React.useContext(LayoutGroupContext.LayoutGroupContext);
+    return (jsxRuntime.jsx(MeasureLayoutWithContext, { ...props, layoutGroup: layoutGroup, switchLayoutGroup: React.useContext(SwitchLayoutGroupContext.SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove }));
+}
+
+exports.MeasureLayout = MeasureLayout;