@ape.swap/bonds-sdk 5.1.0 → 5.1.1-test.0

package/dist/node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.js

@@ -0,0 +1,323 @@
+import '../../../../../motion-utils/dist/es/errors.js';
+import { noop } from '../../../../../motion-utils/dist/es/noop.js';
+import { millisecondsToSeconds, secondsToMilliseconds } from '../../../../../motion-utils/dist/es/time-conversion.js';
+import { isGenerator } from '../../../../../motion-dom/dist/es/animation/generators/utils/is-generator.js';
+import { attachTimeline } from '../../../../../motion-dom/dist/es/animation/waapi/utils/attach-timeline.js';
+import { isWaapiSupportedEasing } from '../../../../../motion-dom/dist/es/animation/waapi/utils/easing.js';
+import { supportsLinearEasing } from '../../../../../motion-dom/dist/es/utils/supports/linear-easing.js';
+import { anticipate } from '../../easing/anticipate.js';
+import { backInOut } from '../../easing/back.js';
+import { circInOut } from '../../easing/circ.js';
+import { DOMKeyframesResolver } from '../../render/dom/DOMKeyframesResolver.js';
+import { BaseAnimation } from './BaseAnimation.js';
+import { MainThreadAnimation } from './MainThreadAnimation.js';
+import { acceleratedValues } from './utils/accelerated-values.js';
+import { startWaapiAnimation } from './waapi/index.js';
+import { getFinalKeyframe } from './waapi/utils/get-final-keyframe.js';
+import { supportsWaapi } from './waapi/utils/supports-waapi.js';
+
+/**
+ * 10ms is chosen here as it strikes a balance between smooth
+ * results (more than one keyframe per frame at 60fps) and
+ * keyframe quantity.
+ */
+const sampleDelta = 10; //ms
+/**
+ * Implement a practical max duration for keyframe generation
+ * to prevent infinite loops
+ */
+const maxDuration = 20000;
+/**
+ * Check if an animation can run natively via WAAPI or requires pregenerated keyframes.
+ * WAAPI doesn't support spring or function easings so we run these as JS animation before
+ * handing off.
+ */
+function requiresPregeneratedKeyframes(options) {
+    return (isGenerator(options.type) ||
+        options.type === "spring" ||
+        !isWaapiSupportedEasing(options.ease));
+}
+function pregenerateKeyframes(keyframes, options) {
+    /**
+     * Create a main-thread animation to pregenerate keyframes.
+     * We sample this at regular intervals to generate keyframes that we then
+     * linearly interpolate between.
+     */
+    const sampleAnimation = new MainThreadAnimation({
+        ...options,
+        keyframes,
+        repeat: 0,
+        delay: 0,
+        isGenerator: true,
+    });
+    let state = { done: false, value: keyframes[0] };
+    const pregeneratedKeyframes = [];
+    /**
+     * Bail after 20 seconds of pre-generated keyframes as it's likely
+     * we're heading for an infinite loop.
+     */
+    let t = 0;
+    while (!state.done && t < maxDuration) {
+        state = sampleAnimation.sample(t);
+        pregeneratedKeyframes.push(state.value);
+        t += sampleDelta;
+    }
+    return {
+        times: undefined,
+        keyframes: pregeneratedKeyframes,
+        duration: t - sampleDelta,
+        ease: "linear",
+    };
+}
+const unsupportedEasingFunctions = {
+    anticipate,
+    backInOut,
+    circInOut,
+};
+function isUnsupportedEase(key) {
+    return key in unsupportedEasingFunctions;
+}
+class AcceleratedAnimation extends BaseAnimation {
+    constructor(options) {
+        super(options);
+        const { name, motionValue, element, keyframes } = this.options;
+        this.resolver = new DOMKeyframesResolver(keyframes, (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe), name, motionValue, element);
+        this.resolver.scheduleResolve();
+    }
+    initPlayback(keyframes, finalKeyframe) {
+        let { duration = 300, times, ease, type, motionValue, name, startTime, } = this.options;
+        /**
+         * If element has since been unmounted, return false to indicate
+         * the animation failed to initialised.
+         */
+        if (!motionValue.owner || !motionValue.owner.current) {
+            return false;
+        }
+        /**
+         * If the user has provided an easing function name that isn't supported
+         * by WAAPI (like "anticipate"), we need to provide the corressponding
+         * function. This will later get converted to a linear() easing function.
+         */
+        if (typeof ease === "string" &&
+            supportsLinearEasing() &&
+            isUnsupportedEase(ease)) {
+            ease = unsupportedEasingFunctions[ease];
+        }
+        /**
+         * If this animation needs pre-generated keyframes then generate.
+         */
+        if (requiresPregeneratedKeyframes(this.options)) {
+            const { onComplete, onUpdate, motionValue, element, ...options } = this.options;
+            const pregeneratedAnimation = pregenerateKeyframes(keyframes, options);
+            keyframes = pregeneratedAnimation.keyframes;
+            // If this is a very short animation, ensure we have
+            // at least two keyframes to animate between as older browsers
+            // can't animate between a single keyframe.
+            if (keyframes.length === 1) {
+                keyframes[1] = keyframes[0];
+            }
+            duration = pregeneratedAnimation.duration;
+            times = pregeneratedAnimation.times;
+            ease = pregeneratedAnimation.ease;
+            type = "keyframes";
+        }
+        const animation = startWaapiAnimation(motionValue.owner.current, name, keyframes, { ...this.options, duration, times, ease });
+        // Override the browser calculated startTime with one synchronised to other JS
+        // and WAAPI animations starting this event loop.
+        animation.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();
+        if (this.pendingTimeline) {
+            attachTimeline(animation, this.pendingTimeline);
+            this.pendingTimeline = undefined;
+        }
+        else {
+            /**
+             * Prefer the `onfinish` prop as it's more widely supported than
+             * the `finished` promise.
+             *
+             * Here, we synchronously set the provided MotionValue to the end
+             * keyframe. If we didn't, when the WAAPI animation is finished it would
+             * be removed from the element which would then revert to its old styles.
+             */
+            animation.onfinish = () => {
+                const { onComplete } = this.options;
+                motionValue.set(getFinalKeyframe(keyframes, this.options, finalKeyframe));
+                onComplete && onComplete();
+                this.cancel();
+                this.resolveFinishedPromise();
+            };
+        }
+        return {
+            animation,
+            duration,
+            times,
+            type,
+            ease,
+            keyframes: keyframes,
+        };
+    }
+    get duration() {
+        const { resolved } = this;
+        if (!resolved)
+            return 0;
+        const { duration } = resolved;
+        return millisecondsToSeconds(duration);
+    }
+    get time() {
+        const { resolved } = this;
+        if (!resolved)
+            return 0;
+        const { animation } = resolved;
+        return millisecondsToSeconds(animation.currentTime || 0);
+    }
+    set time(newTime) {
+        const { resolved } = this;
+        if (!resolved)
+            return;
+        const { animation } = resolved;
+        animation.currentTime = secondsToMilliseconds(newTime);
+    }
+    get speed() {
+        const { resolved } = this;
+        if (!resolved)
+            return 1;
+        const { animation } = resolved;
+        return animation.playbackRate;
+    }
+    set speed(newSpeed) {
+        const { resolved } = this;
+        if (!resolved)
+            return;
+        const { animation } = resolved;
+        animation.playbackRate = newSpeed;
+    }
+    get state() {
+        const { resolved } = this;
+        if (!resolved)
+            return "idle";
+        const { animation } = resolved;
+        return animation.playState;
+    }
+    get startTime() {
+        const { resolved } = this;
+        if (!resolved)
+            return null;
+        const { animation } = resolved;
+        // Coerce to number as TypeScript incorrectly types this
+        // as CSSNumberish
+        return animation.startTime;
+    }
+    /**
+     * Replace the default DocumentTimeline with another AnimationTimeline.
+     * Currently used for scroll animations.
+     */
+    attachTimeline(timeline) {
+        if (!this._resolved) {
+            this.pendingTimeline = timeline;
+        }
+        else {
+            const { resolved } = this;
+            if (!resolved)
+                return noop;
+            const { animation } = resolved;
+            attachTimeline(animation, timeline);
+        }
+        return noop;
+    }
+    play() {
+        if (this.isStopped)
+            return;
+        const { resolved } = this;
+        if (!resolved)
+            return;
+        const { animation } = resolved;
+        if (animation.playState === "finished") {
+            this.updateFinishedPromise();
+        }
+        animation.play();
+    }
+    pause() {
+        const { resolved } = this;
+        if (!resolved)
+            return;
+        const { animation } = resolved;
+        animation.pause();
+    }
+    stop() {
+        this.resolver.cancel();
+        this.isStopped = true;
+        if (this.state === "idle")
+            return;
+        this.resolveFinishedPromise();
+        this.updateFinishedPromise();
+        const { resolved } = this;
+        if (!resolved)
+            return;
+        const { animation, keyframes, duration, type, ease, times } = resolved;
+        if (animation.playState === "idle" ||
+            animation.playState === "finished") {
+            return;
+        }
+        /**
+         * WAAPI doesn't natively have any interruption capabilities.
+         *
+         * Rather than read commited styles back out of the DOM, we can
+         * create a renderless JS animation and sample it twice to calculate
+         * its current value, "previous" value, and therefore allow
+         * Motion to calculate velocity for any subsequent animation.
+         */
+        if (this.time) {
+            const { motionValue, onUpdate, onComplete, element, ...options } = this.options;
+            const sampleAnimation = new MainThreadAnimation({
+                ...options,
+                keyframes,
+                duration,
+                type,
+                ease,
+                times,
+                isGenerator: true,
+            });
+            const sampleTime = secondsToMilliseconds(this.time);
+            motionValue.setWithVelocity(sampleAnimation.sample(sampleTime - sampleDelta).value, sampleAnimation.sample(sampleTime).value, sampleDelta);
+        }
+        const { onStop } = this.options;
+        onStop && onStop();
+        this.cancel();
+    }
+    complete() {
+        const { resolved } = this;
+        if (!resolved)
+            return;
+        resolved.animation.finish();
+    }
+    cancel() {
+        const { resolved } = this;
+        if (!resolved)
+            return;
+        resolved.animation.cancel();
+    }
+    static supports(options) {
+        const { motionValue, name, repeatDelay, repeatType, damping, type } = options;
+        if (!motionValue ||
+            !motionValue.owner ||
+            !(motionValue.owner.current instanceof HTMLElement)) {
+            return false;
+        }
+        const { onUpdate, transformTemplate } = motionValue.owner.getProps();
+        return (supportsWaapi() &&
+            name &&
+            acceleratedValues.has(name) &&
+            /**
+             * If we're outputting values to onUpdate then we can't use WAAPI as there's
+             * no way to read the value from WAAPI every frame.
+             */
+            !onUpdate &&
+            !transformTemplate &&
+            !repeatDelay &&
+            repeatType !== "mirror" &&
+            damping !== 0 &&
+            type !== "inertia");
+    }
+}
+
+export { AcceleratedAnimation };
+//# sourceMappingURL=AcceleratedAnimation.js.map

package/dist/node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcceleratedAnimation.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.mjs"],"sourcesContent":["import { supportsLinearEasing, attachTimeline, isGenerator, isWaapiSupportedEasing } from 'motion-dom';\nimport { millisecondsToSeconds, secondsToMilliseconds, noop } from 'motion-utils';\nimport { anticipate } from '../../easing/anticipate.mjs';\nimport { backInOut } from '../../easing/back.mjs';\nimport { circInOut } from '../../easing/circ.mjs';\nimport { DOMKeyframesResolver } from '../../render/dom/DOMKeyframesResolver.mjs';\nimport { BaseAnimation } from './BaseAnimation.mjs';\nimport { MainThreadAnimation } from './MainThreadAnimation.mjs';\nimport { acceleratedValues } from './utils/accelerated-values.mjs';\nimport { startWaapiAnimation } from './waapi/index.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\nimport { supportsWaapi } from './waapi/utils/supports-waapi.mjs';\n\n/**\n * 10ms is chosen here as it strikes a balance between smooth\n * results (more than one keyframe per frame at 60fps) and\n * keyframe quantity.\n */\nconst sampleDelta = 10; //ms\n/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxDuration = 20000;\n/**\n * Check if an animation can run natively via WAAPI or requires pregenerated keyframes.\n * WAAPI doesn't support spring or function easings so we run these as JS animation before\n * handing off.\n */\nfunction requiresPregeneratedKeyframes(options) {\n    return (isGenerator(options.type) ||\n        options.type === \"spring\" ||\n        !isWaapiSupportedEasing(options.ease));\n}\nfunction pregenerateKeyframes(keyframes, options) {\n    /**\n     * Create a main-thread animation to pregenerate keyframes.\n     * We sample this at regular intervals to generate keyframes that we then\n     * linearly interpolate between.\n     */\n    const sampleAnimation = new MainThreadAnimation({\n        ...options,\n        keyframes,\n        repeat: 0,\n        delay: 0,\n        isGenerator: true,\n    });\n    let state = { done: false, value: keyframes[0] };\n    const pregeneratedKeyframes = [];\n    /**\n     * Bail after 20 seconds of pre-generated keyframes as it's likely\n     * we're heading for an infinite loop.\n     */\n    let t = 0;\n    while (!state.done && t < maxDuration) {\n        state = sampleAnimation.sample(t);\n        pregeneratedKeyframes.push(state.value);\n        t += sampleDelta;\n    }\n    return {\n        times: undefined,\n        keyframes: pregeneratedKeyframes,\n        duration: t - sampleDelta,\n        ease: \"linear\",\n    };\n}\nconst unsupportedEasingFunctions = {\n    anticipate,\n    backInOut,\n    circInOut,\n};\nfunction isUnsupportedEase(key) {\n    return key in unsupportedEasingFunctions;\n}\nclass AcceleratedAnimation extends BaseAnimation {\n    constructor(options) {\n        super(options);\n        const { name, motionValue, element, keyframes } = this.options;\n        this.resolver = new DOMKeyframesResolver(keyframes, (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe), name, motionValue, element);\n        this.resolver.scheduleResolve();\n    }\n    initPlayback(keyframes, finalKeyframe) {\n        let { duration = 300, times, ease, type, motionValue, name, startTime, } = this.options;\n        /**\n         * If element has since been unmounted, return false to indicate\n         * the animation failed to initialised.\n         */\n        if (!motionValue.owner || !motionValue.owner.current) {\n            return false;\n        }\n        /**\n         * If the user has provided an easing function name that isn't supported\n         * by WAAPI (like \"anticipate\"), we need to provide the corressponding\n         * function. This will later get converted to a linear() easing function.\n         */\n        if (typeof ease === \"string\" &&\n            supportsLinearEasing() &&\n            isUnsupportedEase(ease)) {\n            ease = unsupportedEasingFunctions[ease];\n        }\n        /**\n         * If this animation needs pre-generated keyframes then generate.\n         */\n        if (requiresPregeneratedKeyframes(this.options)) {\n            const { onComplete, onUpdate, motionValue, element, ...options } = this.options;\n            const pregeneratedAnimation = pregenerateKeyframes(keyframes, options);\n            keyframes = pregeneratedAnimation.keyframes;\n            // If this is a very short animation, ensure we have\n            // at least two keyframes to animate between as older browsers\n            // can't animate between a single keyframe.\n            if (keyframes.length === 1) {\n                keyframes[1] = keyframes[0];\n            }\n            duration = pregeneratedAnimation.duration;\n            times = pregeneratedAnimation.times;\n            ease = pregeneratedAnimation.ease;\n            type = \"keyframes\";\n        }\n        const animation = startWaapiAnimation(motionValue.owner.current, name, keyframes, { ...this.options, duration, times, ease });\n        // Override the browser calculated startTime with one synchronised to other JS\n        // and WAAPI animations starting this event loop.\n        animation.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();\n        if (this.pendingTimeline) {\n            attachTimeline(animation, this.pendingTimeline);\n            this.pendingTimeline = undefined;\n        }\n        else {\n            /**\n             * Prefer the `onfinish` prop as it's more widely supported than\n             * the `finished` promise.\n             *\n             * Here, we synchronously set the provided MotionValue to the end\n             * keyframe. If we didn't, when the WAAPI animation is finished it would\n             * be removed from the element which would then revert to its old styles.\n             */\n            animation.onfinish = () => {\n                const { onComplete } = this.options;\n                motionValue.set(getFinalKeyframe(keyframes, this.options, finalKeyframe));\n                onComplete && onComplete();\n                this.cancel();\n                this.resolveFinishedPromise();\n            };\n        }\n        return {\n            animation,\n            duration,\n            times,\n            type,\n            ease,\n            keyframes: keyframes,\n        };\n    }\n    get duration() {\n        const { resolved } = this;\n        if (!resolved)\n            return 0;\n        const { duration } = resolved;\n        return millisecondsToSeconds(duration);\n    }\n    get time() {\n        const { resolved } = this;\n        if (!resolved)\n            return 0;\n        const { animation } = resolved;\n        return millisecondsToSeconds(animation.currentTime || 0);\n    }\n    set time(newTime) {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.currentTime = secondsToMilliseconds(newTime);\n    }\n    get speed() {\n        const { resolved } = this;\n        if (!resolved)\n            return 1;\n        const { animation } = resolved;\n        return animation.playbackRate;\n    }\n    set speed(newSpeed) {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.playbackRate = newSpeed;\n    }\n    get state() {\n        const { resolved } = this;\n        if (!resolved)\n            return \"idle\";\n        const { animation } = resolved;\n        return animation.playState;\n    }\n    get startTime() {\n        const { resolved } = this;\n        if (!resolved)\n            return null;\n        const { animation } = resolved;\n        // Coerce to number as TypeScript incorrectly types this\n        // as CSSNumberish\n        return animation.startTime;\n    }\n    /**\n     * Replace the default DocumentTimeline with another AnimationTimeline.\n     * Currently used for scroll animations.\n     */\n    attachTimeline(timeline) {\n        if (!this._resolved) {\n            this.pendingTimeline = timeline;\n        }\n        else {\n            const { resolved } = this;\n            if (!resolved)\n                return noop;\n            const { animation } = resolved;\n            attachTimeline(animation, timeline);\n        }\n        return noop;\n    }\n    play() {\n        if (this.isStopped)\n            return;\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        if (animation.playState === \"finished\") {\n            this.updateFinishedPromise();\n        }\n        animation.play();\n    }\n    pause() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.pause();\n    }\n    stop() {\n        this.resolver.cancel();\n        this.isStopped = true;\n        if (this.state === \"idle\")\n            return;\n        this.resolveFinishedPromise();\n        this.updateFinishedPromise();\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation, keyframes, duration, type, ease, times } = resolved;\n        if (animation.playState === \"idle\" ||\n            animation.playState === \"finished\") {\n            return;\n        }\n        /**\n         * WAAPI doesn't natively have any interruption capabilities.\n         *\n         * Rather than read commited styles back out of the DOM, we can\n         * create a renderless JS animation and sample it twice to calculate\n         * its current value, \"previous\" value, and therefore allow\n         * Motion to calculate velocity for any subsequent animation.\n         */\n        if (this.time) {\n            const { motionValue, onUpdate, onComplete, element, ...options } = this.options;\n            const sampleAnimation = new MainThreadAnimation({\n                ...options,\n                keyframes,\n                duration,\n                type,\n                ease,\n                times,\n                isGenerator: true,\n            });\n            const sampleTime = secondsToMilliseconds(this.time);\n            motionValue.setWithVelocity(sampleAnimation.sample(sampleTime - sampleDelta).value, sampleAnimation.sample(sampleTime).value, sampleDelta);\n        }\n        const { onStop } = this.options;\n        onStop && onStop();\n        this.cancel();\n    }\n    complete() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        resolved.animation.finish();\n    }\n    cancel() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        resolved.animation.cancel();\n    }\n    static supports(options) {\n        const { motionValue, name, repeatDelay, repeatType, damping, type } = options;\n        if (!motionValue ||\n            !motionValue.owner ||\n            !(motionValue.owner.current instanceof HTMLElement)) {\n            return false;\n        }\n        const { onUpdate, transformTemplate } = motionValue.owner.getProps();\n        return (supportsWaapi() &&\n            name &&\n            acceleratedValues.has(name) &&\n            /**\n             * If we're outputting values to onUpdate then we can't use WAAPI as there's\n             * no way to read the value from WAAPI every frame.\n             */\n            !onUpdate &&\n            !transformTemplate &&\n            !repeatDelay &&\n            repeatType !== \"mirror\" &&\n            damping !== 0 &&\n            type !== \"inertia\");\n    }\n}\n\nexport { AcceleratedAnimation };\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.js

@@ -0,0 +1,118 @@
+import { time } from '../../frameloop/sync-time.js';
+import { flushKeyframeResolvers } from '../../render/utils/KeyframesResolver.js';
+import { canAnimate } from './utils/can-animate.js';
+import { getFinalKeyframe } from './waapi/utils/get-final-keyframe.js';
+
+/**
+ * Maximum time allowed between an animation being created and it being
+ * resolved for us to use the latter as the start time.
+ *
+ * This is to ensure that while we prefer to "start" an animation as soon
+ * as it's triggered, we also want to avoid a visual jump if there's a big delay
+ * between these two moments.
+ */
+const MAX_RESOLVE_DELAY = 40;
+class BaseAnimation {
+    constructor({ autoplay = true, delay = 0, type = "keyframes", repeat = 0, repeatDelay = 0, repeatType = "loop", ...options }) {
+        // Track whether the animation has been stopped. Stopped animations won't restart.
+        this.isStopped = false;
+        this.hasAttemptedResolve = false;
+        this.createdAt = time.now();
+        this.options = {
+            autoplay,
+            delay,
+            type,
+            repeat,
+            repeatDelay,
+            repeatType,
+            ...options,
+        };
+        this.updateFinishedPromise();
+    }
+    /**
+     * This method uses the createdAt and resolvedAt to calculate the
+     * animation startTime. *Ideally*, we would use the createdAt time as t=0
+     * as the following frame would then be the first frame of the animation in
+     * progress, which would feel snappier.
+     *
+     * However, if there's a delay (main thread work) between the creation of
+     * the animation and the first commited frame, we prefer to use resolvedAt
+     * to avoid a sudden jump into the animation.
+     */
+    calcStartTime() {
+        if (!this.resolvedAt)
+            return this.createdAt;
+        return this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY
+            ? this.resolvedAt
+            : this.createdAt;
+    }
+    /**
+     * A getter for resolved data. If keyframes are not yet resolved, accessing
+     * this.resolved will synchronously flush all pending keyframe resolvers.
+     * This is a deoptimisation, but at its worst still batches read/writes.
+     */
+    get resolved() {
+        if (!this._resolved && !this.hasAttemptedResolve) {
+            flushKeyframeResolvers();
+        }
+        return this._resolved;
+    }
+    /**
+     * A method to be called when the keyframes resolver completes. This method
+     * will check if its possible to run the animation and, if not, skip it.
+     * Otherwise, it will call initPlayback on the implementing class.
+     */
+    onKeyframesResolved(keyframes, finalKeyframe) {
+        this.resolvedAt = time.now();
+        this.hasAttemptedResolve = true;
+        const { name, type, velocity, delay, onComplete, onUpdate, isGenerator, } = this.options;
+        /**
+         * If we can't animate this value with the resolved keyframes
+         * then we should complete it immediately.
+         */
+        if (!isGenerator && !canAnimate(keyframes, name, type, velocity)) {
+            // Finish immediately
+            if (!delay) {
+                onUpdate &&
+                    onUpdate(getFinalKeyframe(keyframes, this.options, finalKeyframe));
+                onComplete && onComplete();
+                this.resolveFinishedPromise();
+                return;
+            }
+            // Finish after a delay
+            else {
+                this.options.duration = 0;
+            }
+        }
+        const resolvedAnimation = this.initPlayback(keyframes, finalKeyframe);
+        if (resolvedAnimation === false)
+            return;
+        this._resolved = {
+            keyframes,
+            finalKeyframe,
+            ...resolvedAnimation,
+        };
+        this.onPostResolved();
+    }
+    onPostResolved() { }
+    /**
+     * Allows the returned animation to be awaited or promise-chained. Currently
+     * resolves when the animation finishes at all but in a future update could/should
+     * reject if its cancels.
+     */
+    then(resolve, reject) {
+        return this.currentFinishedPromise.then(resolve, reject);
+    }
+    flatten() {
+        this.options.type = "keyframes";
+        this.options.ease = "linear";
+    }
+    updateFinishedPromise() {
+        this.currentFinishedPromise = new Promise((resolve) => {
+            this.resolveFinishedPromise = resolve;
+        });
+    }
+}
+
+export { BaseAnimation };
+//# sourceMappingURL=BaseAnimation.js.map

package/dist/node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseAnimation.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.mjs"],"sourcesContent":["import { time } from '../../frameloop/sync-time.mjs';\nimport { flushKeyframeResolvers } from '../../render/utils/KeyframesResolver.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { canAnimate } from './utils/can-animate.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\n\n/**\n * Maximum time allowed between an animation being created and it being\n * resolved for us to use the latter as the start time.\n *\n * This is to ensure that while we prefer to \"start\" an animation as soon\n * as it's triggered, we also want to avoid a visual jump if there's a big delay\n * between these two moments.\n */\nconst MAX_RESOLVE_DELAY = 40;\nclass BaseAnimation {\n    constructor({ autoplay = true, delay = 0, type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType = \"loop\", ...options }) {\n        // Track whether the animation has been stopped. Stopped animations won't restart.\n        this.isStopped = false;\n        this.hasAttemptedResolve = false;\n        this.createdAt = time.now();\n        this.options = {\n            autoplay,\n            delay,\n            type,\n            repeat,\n            repeatDelay,\n            repeatType,\n            ...options,\n        };\n        this.updateFinishedPromise();\n    }\n    /**\n     * This method uses the createdAt and resolvedAt to calculate the\n     * animation startTime. *Ideally*, we would use the createdAt time as t=0\n     * as the following frame would then be the first frame of the animation in\n     * progress, which would feel snappier.\n     *\n     * However, if there's a delay (main thread work) between the creation of\n     * the animation and the first commited frame, we prefer to use resolvedAt\n     * to avoid a sudden jump into the animation.\n     */\n    calcStartTime() {\n        if (!this.resolvedAt)\n            return this.createdAt;\n        return this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY\n            ? this.resolvedAt\n            : this.createdAt;\n    }\n    /**\n     * A getter for resolved data. If keyframes are not yet resolved, accessing\n     * this.resolved will synchronously flush all pending keyframe resolvers.\n     * This is a deoptimisation, but at its worst still batches read/writes.\n     */\n    get resolved() {\n        if (!this._resolved && !this.hasAttemptedResolve) {\n            flushKeyframeResolvers();\n        }\n        return this._resolved;\n    }\n    /**\n     * A method to be called when the keyframes resolver completes. This method\n     * will check if its possible to run the animation and, if not, skip it.\n     * Otherwise, it will call initPlayback on the implementing class.\n     */\n    onKeyframesResolved(keyframes, finalKeyframe) {\n        this.resolvedAt = time.now();\n        this.hasAttemptedResolve = true;\n        const { name, type, velocity, delay, onComplete, onUpdate, isGenerator, } = this.options;\n        /**\n         * If we can't animate this value with the resolved keyframes\n         * then we should complete it immediately.\n         */\n        if (!isGenerator && !canAnimate(keyframes, name, type, velocity)) {\n            // Finish immediately\n            if (instantAnimationState.current || !delay) {\n                onUpdate &&\n                    onUpdate(getFinalKeyframe(keyframes, this.options, finalKeyframe));\n                onComplete && onComplete();\n                this.resolveFinishedPromise();\n                return;\n            }\n            // Finish after a delay\n            else {\n                this.options.duration = 0;\n            }\n        }\n        const resolvedAnimation = this.initPlayback(keyframes, finalKeyframe);\n        if (resolvedAnimation === false)\n            return;\n        this._resolved = {\n            keyframes,\n            finalKeyframe,\n            ...resolvedAnimation,\n        };\n        this.onPostResolved();\n    }\n    onPostResolved() { }\n    /**\n     * Allows the returned animation to be awaited or promise-chained. Currently\n     * resolves when the animation finishes at all but in a future update could/should\n     * reject if its cancels.\n     */\n    then(resolve, reject) {\n        return this.currentFinishedPromise.then(resolve, reject);\n    }\n    flatten() {\n        this.options.type = \"keyframes\";\n        this.options.ease = \"linear\";\n    }\n    updateFinishedPromise() {\n        this.currentFinishedPromise = new Promise((resolve) => {\n            this.resolveFinishedPromise = resolve;\n        });\n    }\n}\n\nexport { BaseAnimation };\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}