{"version":3,"file":"size-rollup-motion-value.js","sources":["../../motion-utils/dist/es/global-config.mjs","../../motion-utils/dist/es/subscription-manager.mjs","../../motion-utils/dist/es/array.mjs","../../motion-utils/dist/es/velocity-per-second.mjs","../lib/frameloop/order.js","../lib/frameloop/batcher.js","../lib/frameloop/render-step.js","../lib/frameloop/frame-data.js","../lib/frameloop/frame.js","../../motion-utils/dist/es/noop.mjs","../lib/frameloop/sync-time.js","../lib/value/index.js"],"sourcesContent":["const MotionGlobalConfig = {};\n\nexport { MotionGlobalConfig };\n//# sourceMappingURL=global-config.mjs.map\n","import { addUniqueItem, removeItem } from './array.mjs';\n\nclass SubscriptionManager {\n    constructor() {\n        this.subscriptions = [];\n    }\n    add(handler) {\n        addUniqueItem(this.subscriptions, handler);\n        return () => this.remove(handler);\n    }\n    remove(handler) {\n        removeItem(this.subscriptions, handler);\n    }\n    notify(a, b, c) {\n        const numSubscriptions = this.subscriptions.length;\n        if (!numSubscriptions)\n            return;\n        if (numSubscriptions === 1) {\n            /**\n             * If there's only a single handler we can just call it without invoking a loop.\n             */\n            this.subscriptions[0](a, b, c);\n        }\n        else {\n            for (let i = 0; i < numSubscriptions; i++) {\n                /**\n                 * Check whether the handler exists before firing as it's possible\n                 * the subscriptions were modified during this loop running.\n                 */\n                const handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    }\n    getSize() {\n        return this.subscriptions.length;\n    }\n    clear() {\n        this.subscriptions.length = 0;\n    }\n}\n\nexport { SubscriptionManager };\n//# sourceMappingURL=subscription-manager.mjs.map\n","function addUniqueItem(arr, item) {\n    if (arr.indexOf(item) === -1)\n        arr.push(item);\n}\nfunction removeItem(arr, item) {\n    const index = arr.indexOf(item);\n    if (index > -1)\n        arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem([...arr], fromIndex, toIndex) {\n    const startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n    if (startIndex >= 0 && startIndex < arr.length) {\n        const endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n        const [item] = arr.splice(fromIndex, 1);\n        arr.splice(endIndex, 0, item);\n    }\n    return arr;\n}\n\nexport { addUniqueItem, moveItem, removeItem };\n//# sourceMappingURL=array.mjs.map\n","/*\n  Convert velocity into velocity per second\n*/\n/*#__NO_SIDE_EFFECTS__*/\nconst velocityPerSecond = (velocity, frameDuration) => frameDuration ? velocity * (1000 / frameDuration) : 0;\n\nexport { velocityPerSecond };\n//# sourceMappingURL=velocity-per-second.mjs.map\n","export const stepsOrder = [\n    \"setup\", // Compute\n    \"read\", // Read\n    \"resolveKeyframes\", // Write/Read/Write/Read\n    \"preUpdate\", // Compute\n    \"update\", // Compute\n    \"preRender\", // Compute\n    \"render\", // Write\n    \"postRender\", // Compute\n];\n//# sourceMappingURL=order.js.map","import { MotionGlobalConfig } from \"motion-utils\";\nimport { stepsOrder } from \"./order\";\nimport { createRenderStep } from \"./render-step\";\nconst maxElapsed = 40;\nexport function createRenderBatcher(scheduleNextBatch, allowKeepAlive, state = {\n    delta: 0.0,\n    timestamp: 0.0,\n    isProcessing: false,\n}) {\n    let runNextFrame = false;\n    let useDefaultElapsed = true;\n    const flagRunNextFrame = () => (runNextFrame = true);\n    const steps = stepsOrder.reduce((acc, key) => {\n        acc[key] = createRenderStep(flagRunNextFrame);\n        return acc;\n    }, {});\n    const { setup, read, resolveKeyframes, preUpdate, update, preRender, render, postRender, } = steps;\n    const processBatch = () => {\n        const useManualTiming = MotionGlobalConfig.useManualTiming;\n        const timestamp = useManualTiming\n            ? state.timestamp\n            : performance.now();\n        runNextFrame = false;\n        if (!useManualTiming) {\n            state.delta = useDefaultElapsed\n                ? 1000 / 60\n                : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);\n        }\n        state.timestamp = timestamp;\n        state.isProcessing = true;\n        // Unrolled render loop for better per-frame performance\n        setup.process(state);\n        read.process(state);\n        resolveKeyframes.process(state);\n        preUpdate.process(state);\n        update.process(state);\n        preRender.process(state);\n        render.process(state);\n        postRender.process(state);\n        state.isProcessing = false;\n        if (runNextFrame && allowKeepAlive) {\n            useDefaultElapsed = false;\n            scheduleNextBatch(processBatch);\n        }\n    };\n    const wake = () => {\n        runNextFrame = true;\n        useDefaultElapsed = true;\n        if (!state.isProcessing) {\n            scheduleNextBatch(processBatch);\n        }\n    };\n    const schedule = stepsOrder.reduce((acc, key) => {\n        const step = steps[key];\n        acc[key] = (process, keepAlive = false, immediate = false) => {\n            if (!runNextFrame)\n                wake();\n            return step.schedule(process, keepAlive, immediate);\n        };\n        return acc;\n    }, {});\n    const cancel = (process) => {\n        for (let i = 0; i < stepsOrder.length; i++) {\n            steps[stepsOrder[i]].cancel(process);\n        }\n    };\n    return { schedule, cancel, state, steps };\n}\n//# sourceMappingURL=batcher.js.map","export function createRenderStep(runNextFrame) {\n    /**\n     * We create and reuse two queues, one to queue jobs for the current frame\n     * and one for the next. We reuse to avoid triggering GC after x frames.\n     */\n    let thisFrame = new Set();\n    let nextFrame = new Set();\n    /**\n     * Track whether we're currently processing jobs in this step. This way\n     * we can decide whether to schedule new jobs for this frame or next.\n     */\n    let isProcessing = false;\n    let flushNextFrame = false;\n    /**\n     * A set of processes which were marked keepAlive when scheduled.\n     * A keepAlive process is always also held by a frame queue until\n     * it's cancelled, so a Set has the same lifetime semantics as a\n     * WeakSet here while being considerably faster to query every frame.\n     */\n    const toKeepAlive = new Set();\n    let latestFrameData = {\n        delta: 0.0,\n        timestamp: 0.0,\n        isProcessing: false,\n    };\n    function triggerCallback(callback) {\n        if (toKeepAlive.has(callback)) {\n            nextFrame.add(callback);\n            runNextFrame();\n        }\n        callback(latestFrameData);\n    }\n    const step = {\n        /**\n         * Schedule a process to run on the next frame.\n         */\n        schedule: (callback, keepAlive = false, immediate = false) => {\n            const addToCurrentFrame = immediate && isProcessing;\n            const queue = addToCurrentFrame ? thisFrame : nextFrame;\n            if (keepAlive)\n                toKeepAlive.add(callback);\n            queue.add(callback);\n            return callback;\n        },\n        /**\n         * Cancel the provided callback from running on the next frame.\n         */\n        cancel: (callback) => {\n            nextFrame.delete(callback);\n            toKeepAlive.delete(callback);\n        },\n        /**\n         * Execute all schedule callbacks.\n         */\n        process: (frameData) => {\n            latestFrameData = frameData;\n            /**\n             * If we're already processing we've probably been triggered by a flushSync\n             * inside an existing process. Instead of executing, mark flushNextFrame\n             * as true and ensure we flush the following frame at the end of this one.\n             */\n            if (isProcessing) {\n                flushNextFrame = true;\n                return;\n            }\n            isProcessing = true;\n            // Swap this frame and the next to avoid GC\n            const prevFrame = thisFrame;\n            thisFrame = nextFrame;\n            nextFrame = prevFrame;\n            // Execute this frame\n            thisFrame.forEach(triggerCallback);\n            // Clear the frame so no callbacks remain. This is to avoid\n            // memory leaks should this render step not run for a while.\n            thisFrame.clear();\n            isProcessing = false;\n            if (flushNextFrame) {\n                flushNextFrame = false;\n                step.process(frameData);\n            }\n        },\n    };\n    return step;\n}\n//# sourceMappingURL=render-step.js.map","/**\n * The frameloop's state, kept apart from the frameloop itself so that\n * reading it doesn't bundle the scheduler.\n */\nexport const frameData = {\n    delta: 0.0,\n    timestamp: 0.0,\n    isProcessing: false,\n};\n//# sourceMappingURL=frame-data.js.map","import { noop } from \"motion-utils\";\nimport { createRenderBatcher } from \"./batcher\";\nimport { frameData } from \"./frame-data\";\nexport const { schedule: frame, cancel: cancelFrame, steps: frameSteps, } = /* @__PURE__ */ createRenderBatcher(typeof requestAnimationFrame !== \"undefined\" ? requestAnimationFrame : noop, true, frameData);\n//# sourceMappingURL=frame.js.map","/*#__NO_SIDE_EFFECTS__*/\nconst noop = (any) => any;\n\nexport { noop };\n//# sourceMappingURL=noop.mjs.map\n","import { MotionGlobalConfig } from \"motion-utils\";\nimport { frameData } from \"./frame-data\";\nlet now;\nfunction clearTime() {\n    now = undefined;\n}\n/**\n * An eventloop-synchronous alternative to performance.now().\n *\n * Ensures that time measurements remain consistent within a synchronous context.\n * Usually calling performance.now() twice within the same synchronous context\n * will return different values which isn't useful for animations when we're usually\n * trying to sync animations to the same frame.\n */\nexport const time = {\n    now: () => {\n        if (now === undefined) {\n            time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming\n                ? frameData.timestamp\n                : performance.now());\n        }\n        return now;\n    },\n    set: (newTime) => {\n        now = newTime;\n        queueMicrotask(clearTime);\n    },\n};\n//# sourceMappingURL=sync-time.js.map","import { SubscriptionManager, velocityPerSecond, warnOnce, } from \"motion-utils\";\nimport { frame } from \"../frameloop\";\nimport { time } from \"../frameloop/sync-time\";\n/**\n * Maximum time between the value of two frames, beyond which we\n * assume the velocity has since been 0.\n */\nconst MAX_VELOCITY_DELTA = 30;\nconst isFloat = (value) => {\n    return !isNaN(parseFloat(value));\n};\nexport const collectMotionValues = {\n    current: undefined,\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nexport class MotionValue {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     */\n    constructor(init, options = {}) {\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = null;\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        this.updateAndNotify = (v) => {\n            const currentTime = time.now();\n            /**\n             * If we're updating the value during another frame or eventloop\n             * than the previous frame, then the we set the previous frame value\n             * to current.\n             */\n            if (this.updatedAt !== currentTime) {\n                this.setPrevFrameValue();\n            }\n            this.prev = this.current;\n            this.setCurrent(v);\n            // Update update subscribers\n            if (this.current !== this.prev) {\n                this.notifyChange();\n                if (this.dependents) {\n                    for (const dependent of this.dependents) {\n                        dependent.dirty();\n                    }\n                }\n            }\n        };\n        this.hasAnimated = false;\n        this.setCurrent(init);\n        this.owner = options.owner;\n    }\n    setCurrent(current) {\n        this.current = current;\n        this.updatedAt = time.now();\n        if (this.canTrackVelocity === null && current !== undefined) {\n            this.canTrackVelocity = isFloat(this.current);\n        }\n    }\n    setPrevFrameValue(prevFrameValue = this.current) {\n        this.prevFrameValue = prevFrameValue;\n        this.prevUpdatedAt = this.updatedAt;\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.on(\"change\", updateOpacity)\n     *     const unsubscribeY = y.on(\"change\", updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @deprecated\n     */\n    onChange(subscription) {\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on(\"change\", callback).`);\n        }\n        return this.on(\"change\", subscription);\n    }\n    on(eventName, callback) {\n        var _a;\n        if (eventName === \"change\")\n            return this.onChangeSubscribe(callback);\n        return ((_a = this.events)[eventName] || (_a[eventName] = new SubscriptionManager())).add(callback);\n    }\n    onChangeSubscribe(callback) {\n        const { events } = this;\n        if (!events.change && !this.changeSubscriber) {\n            this.changeSubscriber = callback;\n        }\n        else {\n            if (!events.change) {\n                events.change = new SubscriptionManager();\n                events.change.add(this.changeSubscriber);\n                this.changeSubscriber = undefined;\n            }\n            events.change.add(callback);\n        }\n        return () => {\n            if (this.changeSubscriber === callback) {\n                this.changeSubscriber = undefined;\n            }\n            else {\n                events.change?.remove(callback);\n            }\n            this.stopIfUnobserved();\n        };\n    }\n    /**\n     * If we have no more change listeners by the start\n     * of the next frame, stop active animations.\n     */\n    stopIfUnobserved() {\n        frame.read(() => {\n            if (!this.changeSubscriber && !this.events.change?.getSize()) {\n                this.stop();\n            }\n        });\n    }\n    clearListeners() {\n        this.changeSubscriber = undefined;\n        for (const eventManagers in this.events) {\n            this.events[eventManagers].clear();\n        }\n    }\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     */\n    attach(passiveEffect, stopPassiveEffect) {\n        this.passiveEffect = passiveEffect;\n        this.stopPassiveEffect = stopPassiveEffect;\n    }\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    set(v) {\n        if (!this.passiveEffect) {\n            this.updateAndNotify(v);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    }\n    setWithVelocity(prev, current, delta) {\n        this.set(current);\n        this.prev = undefined;\n        this.prevFrameValue = prev;\n        this.prevUpdatedAt = this.updatedAt - delta;\n    }\n    /**\n     * Set the state of the `MotionValue`, stopping any active animations,\n     * effects, and resets velocity to `0`.\n     */\n    jump(v, endAnimation = true) {\n        this.updateAndNotify(v);\n        this.prev = v;\n        this.prevUpdatedAt = this.prevFrameValue = undefined;\n        endAnimation && this.stop();\n        if (this.stopPassiveEffect)\n            this.stopPassiveEffect();\n    }\n    dirty() {\n        this.notifyChange();\n    }\n    notifyChange() {\n        const { current, changeSubscriber } = this;\n        /**\n         * One or the other exists. Subscribing during the direct\n         * subscriber's call moves it into a new manager, which must not\n         * then be notified for the same change.\n         */\n        if (changeSubscriber) {\n            changeSubscriber(current);\n        }\n        else {\n            this.events.change?.notify(current);\n        }\n    }\n    addDependent(dependent) {\n        if (!this.dependents) {\n            this.dependents = new Set();\n        }\n        this.dependents.add(dependent);\n    }\n    removeDependent(dependent) {\n        if (this.dependents) {\n            this.dependents.delete(dependent);\n        }\n    }\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    get() {\n        if (collectMotionValues.current) {\n            collectMotionValues.current.push(this);\n        }\n        /**\n         * A value animating on the compositor isn't updated every frame,\n         * so read it from its animation.\n         */\n        const sampled = this.animation?.liveValue?.();\n        return sampled === undefined ? this.current : sampled;\n    }\n    /**\n     * The value as last set. Unlike get(), this doesn't read an animation\n     * running on the compositor, which renders the value itself.\n     */\n    getCurrent() {\n        return this.current;\n    }\n    /**\n     * @public\n     */\n    getPrevious() {\n        return this.prev;\n    }\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    getVelocity() {\n        const currentTime = time.now();\n        if (!this.canTrackVelocity ||\n            this.prevFrameValue === undefined ||\n            currentTime - this.updatedAt > MAX_VELOCITY_DELTA) {\n            return 0;\n        }\n        const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);\n        // Casts because of parseFloat's poor typing\n        return velocityPerSecond(parseFloat(this.current) -\n            parseFloat(this.prevFrameValue), delta);\n    }\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     */\n    start(startAnimation) {\n        this.stop();\n        return new Promise((resolve) => {\n            this.hasAnimated = true;\n            /**\n             * Complete synchronously via the callback rather than chaining a\n             * second promise per animation. Guard against animations that\n             * complete before startAnimation has returned.\n             */\n            let isComplete = false;\n            let animation;\n            // eslint-disable-next-line prefer-const -- read by the callback before assignment when completing synchronously\n            animation = startAnimation(() => {\n                isComplete = true;\n                this.events.animationComplete?.notify();\n                if (this.animation === animation)\n                    this.clearAnimation();\n                resolve();\n            });\n            if (!isComplete)\n                this.animation = animation;\n            this.events.animationStart?.notify();\n        });\n    }\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    stop() {\n        if (this.animation) {\n            this.animation.stop();\n            if (this.events.animationCancel) {\n                this.events.animationCancel.notify();\n            }\n        }\n        this.clearAnimation();\n    }\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    isAnimating() {\n        return !!this.animation;\n    }\n    clearAnimation() {\n        // Assign rather than delete to keep the object's shape stable\n        this.animation = undefined;\n    }\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    destroy() {\n        this.dependents?.clear();\n        this.events.destroy?.notify();\n        this.clearListeners();\n        this.stop();\n        if (this.stopPassiveEffect) {\n            this.stopPassiveEffect();\n        }\n    }\n}\nexport function motionValue(init, options) {\n    return new MotionValue(init, options);\n}\n//# sourceMappingURL=index.js.map"],"names":["MotionGlobalConfig","SubscriptionManager","constructor","this","subscriptions","add","handler","arr","item","indexOf","push","remove","index","splice","removeItem","notify","a","b","c","numSubscriptions","length","i","getSize","clear","stepsOrder","createRenderBatcher","scheduleNextBatch","allowKeepAlive","state","delta","timestamp","isProcessing","runNextFrame","useDefaultElapsed","flagRunNextFrame","steps","reduce","acc","key","thisFrame","Set","nextFrame","flushNextFrame","toKeepAlive","latestFrameData","triggerCallback","callback","has","step","schedule","keepAlive","immediate","queue","cancel","delete","process","frameData","prevFrame","forEach","createRenderStep","setup","read","resolveKeyframes","preUpdate","update","preRender","render","postRender","processBatch","useManualTiming","performance","now","Math","max","min","frame","requestAnimationFrame","any","clearTime","undefined","time","set","newTime","queueMicrotask","collectMotionValues","current","MotionValue","init","options","canTrackVelocity","events","updateAndNotify","v","currentTime","updatedAt","setPrevFrameValue","prev","setCurrent","notifyChange","dependents","dependent","dirty","hasAnimated","owner","value","isNaN","parseFloat","prevFrameValue","prevUpdatedAt","onChange","subscription","on","eventName","_a","onChangeSubscribe","change","changeSubscriber","stopIfUnobserved","stop","clearListeners","eventManagers","attach","passiveEffect","stopPassiveEffect","setWithVelocity","jump","endAnimation","addDependent","removeDependent","get","sampled","animation","liveValue","getCurrent","getPrevious","getVelocity","velocity","frameDuration","start","startAnimation","Promise","resolve","isComplete","animationComplete","clearAnimation","animationStart","animationCancel","isAnimating","destroy","motionValue"],"mappings":"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"}