{"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.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 () => 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) {\n    let runNextFrame = false;\n    let useDefaultElapsed = true;\n    const state = {\n        delta: 0.0,\n        timestamp: 0.0,\n        isProcessing: false,\n    };\n    const flagRunNextFrame = () => (runNextFrame = true);\n    const steps = stepsOrder.reduce((acc, key) => {\n        acc[key] = createRenderStep(flagRunNextFrame, allowKeepAlive ? key : undefined);\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","import { statsBuffer } from \"../stats/buffer\";\nexport function createRenderStep(runNextFrame, stepName) {\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     */\n    const toKeepAlive = new WeakSet();\n    let latestFrameData = {\n        delta: 0.0,\n        timestamp: 0.0,\n        isProcessing: false,\n    };\n    let numCalls = 0;\n    function triggerCallback(callback) {\n        if (toKeepAlive.has(callback)) {\n            step.schedule(callback);\n            runNextFrame();\n        }\n        numCalls++;\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            /**\n             * If we're recording stats then\n             */\n            if (stepName && statsBuffer.value) {\n                statsBuffer.value.frameloop[stepName].push(numCalls);\n            }\n            numCalls = 0;\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","import { noop } from \"motion-utils\";\nimport { createRenderBatcher } from \"./batcher\";\nexport const { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps, } = /* @__PURE__ */ createRenderBatcher(typeof requestAnimationFrame !== \"undefined\" ? requestAnimationFrame : noop, true);\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\";\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.events.change?.notify(this.current);\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        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        const unsubscribe = this.events[eventName].add(callback);\n        if (eventName === \"change\") {\n            return () => {\n                unsubscribe();\n                /**\n                 * If we have no more change listeners by the start\n                 * of the next frame, stop active animations.\n                 */\n                frame.read(() => {\n                    if (!this.events.change.getSize()) {\n                        this.stop();\n                    }\n                });\n            };\n        }\n        return unsubscribe;\n    }\n    clearListeners() {\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.events.change?.notify(this.current);\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        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            this.animation = startAnimation(resolve);\n            if (this.events.animationStart) {\n                this.events.animationStart.notify();\n            }\n        }).then(() => {\n            if (this.events.animationComplete) {\n                this.events.animationComplete.notify();\n            }\n            this.clearAnimation();\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        delete this.animation;\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","index","splice","removeItem","notify","a","b","c","numSubscriptions","length","i","getSize","clear","stepsOrder","createRenderBatcher","scheduleNextBatch","allowKeepAlive","runNextFrame","useDefaultElapsed","state","delta","timestamp","isProcessing","flagRunNextFrame","steps","reduce","acc","key","thisFrame","Set","nextFrame","flushNextFrame","toKeepAlive","WeakSet","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","change","dependents","dependent","dirty","hasAnimated","owner","value","isNaN","parseFloat","prevFrameValue","prevUpdatedAt","onChange","subscription","on","eventName","unsubscribe","stop","clearListeners","eventManagers","attach","passiveEffect","stopPassiveEffect","setWithVelocity","jump","endAnimation","addDependent","removeDependent","get","getPrevious","getVelocity","velocity","frameDuration","start","startAnimation","Promise","resolve","animation","animationStart","then","animationComplete","clearAnimation","animationCancel","isAnimating","destroy","motionValue"],"mappings":"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"}