@nulogy/components 16.1.0 → 17.0.0

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/animation-state.js

@@ -0,0 +1,224 @@
+import { animateVisualElement } from "../../animation/interfaces/visual-element.js";
+import { calcChildStagger } from "../../animation/utils/calc-child-stagger.js";
+import { getVariantContext } from "./get-variant-context.js";
+import { isAnimationControls } from "./is-animation-controls.js";
+import { isKeyframesTarget } from "./is-keyframes-target.js";
+import { isVariantLabel } from "./is-variant-label.js";
+import { resolveVariant } from "./resolve-dynamic-variants.js";
+import { shallowCompare } from "./shallow-compare.js";
+import { variantPriorityOrder } from "./variant-props.js";
+const reversePriorityOrder = [...variantPriorityOrder].reverse();
+const numAnimationTypes = variantPriorityOrder.length;
+function createAnimateFunction(visualElement) {
+  return (animations) => {
+    return Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));
+  };
+}
+function createAnimationState(visualElement) {
+  let animate = createAnimateFunction(visualElement);
+  let state = createState();
+  let isInitialRender = true;
+  let wasReset = false;
+  const buildResolvedTypeValues = (type) => (acc, definition) => {
+    const resolved = resolveVariant(visualElement, definition, type === "exit" ? visualElement.presenceContext?.custom : void 0);
+    if (resolved) {
+      const { transition, transitionEnd, ...target } = resolved;
+      acc = { ...acc, ...target, ...transitionEnd };
+    }
+    return acc;
+  };
+  function setAnimateFunction(makeAnimator) {
+    animate = makeAnimator(visualElement);
+  }
+  function animateChanges(changedActiveType) {
+    const { props } = visualElement;
+    const context = getVariantContext(visualElement.parent) || {};
+    const animations = [];
+    const removedKeys = /* @__PURE__ */ new Set();
+    let encounteredKeys = {};
+    let removedVariantIndex = Infinity;
+    for (let i = 0; i < numAnimationTypes; i++) {
+      const type = reversePriorityOrder[i];
+      const typeState = state[type];
+      const prop = props[type] !== void 0 ? props[type] : context[type];
+      const propIsVariant = isVariantLabel(prop);
+      const activeDelta = type === changedActiveType ? typeState.isActive : null;
+      if (activeDelta === false)
+        removedVariantIndex = i;
+      let isInherited = prop === context[type] && prop !== props[type] && propIsVariant;
+      if (isInherited && (isInitialRender || wasReset) && visualElement.manuallyAnimateOnMount) {
+        isInherited = false;
+      }
+      typeState.protectedKeys = { ...encounteredKeys };
+      if (
+        // If it isn't active and hasn't *just* been set as inactive
+        !typeState.isActive && activeDelta === null || // If we didn't and don't have any defined prop for this animation type
+        !prop && !typeState.prevProp || // Or if the prop doesn't define an animation
+        isAnimationControls(prop) || typeof prop === "boolean"
+      ) {
+        continue;
+      }
+      if (type === "exit" && typeState.isActive && activeDelta !== true) {
+        if (typeState.prevResolvedValues) {
+          encounteredKeys = {
+            ...encounteredKeys,
+            ...typeState.prevResolvedValues
+          };
+        }
+        continue;
+      }
+      const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);
+      let shouldAnimateType = variantDidChange || // If we're making this variant active, we want to always make it active
+      type === changedActiveType && typeState.isActive && !isInherited && propIsVariant || // If we removed a higher-priority variant (i is in reverse order)
+      i > removedVariantIndex && propIsVariant;
+      let handledRemovedValues = false;
+      const definitionList = Array.isArray(prop) ? prop : [prop];
+      let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});
+      if (activeDelta === false)
+        resolvedValues = {};
+      const { prevResolvedValues = {} } = typeState;
+      const allKeys = {
+        ...prevResolvedValues,
+        ...resolvedValues
+      };
+      const markToAnimate = (key) => {
+        shouldAnimateType = true;
+        if (removedKeys.has(key)) {
+          handledRemovedValues = true;
+          removedKeys.delete(key);
+        }
+        typeState.needsAnimating[key] = true;
+        const motionValue = visualElement.getValue(key);
+        if (motionValue)
+          motionValue.liveStyle = false;
+      };
+      for (const key in allKeys) {
+        const next = resolvedValues[key];
+        const prev = prevResolvedValues[key];
+        if (encounteredKeys.hasOwnProperty(key))
+          continue;
+        let valueHasChanged = false;
+        if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {
+          valueHasChanged = !shallowCompare(next, prev);
+        } else {
+          valueHasChanged = next !== prev;
+        }
+        if (valueHasChanged) {
+          if (next !== void 0 && next !== null) {
+            markToAnimate(key);
+          } else {
+            removedKeys.add(key);
+          }
+        } else if (next !== void 0 && removedKeys.has(key)) {
+          markToAnimate(key);
+        } else {
+          typeState.protectedKeys[key] = true;
+        }
+      }
+      typeState.prevProp = prop;
+      typeState.prevResolvedValues = resolvedValues;
+      if (typeState.isActive) {
+        encounteredKeys = { ...encounteredKeys, ...resolvedValues };
+      }
+      if ((isInitialRender || wasReset) && visualElement.blockInitialAnimation) {
+        shouldAnimateType = false;
+      }
+      const willAnimateViaParent = isInherited && variantDidChange;
+      const needsAnimating = !willAnimateViaParent || handledRemovedValues;
+      if (shouldAnimateType && needsAnimating) {
+        animations.push(...definitionList.map((animation) => {
+          const options = { type };
+          if (typeof animation === "string" && (isInitialRender || wasReset) && !willAnimateViaParent && visualElement.manuallyAnimateOnMount && visualElement.parent) {
+            const { parent } = visualElement;
+            const parentVariant = resolveVariant(parent, animation);
+            if (parent.enteringChildren && parentVariant) {
+              const { delayChildren } = parentVariant.transition || {};
+              options.delay = calcChildStagger(parent.enteringChildren, visualElement, delayChildren);
+            }
+          }
+          return {
+            animation,
+            options
+          };
+        }));
+      }
+    }
+    if (removedKeys.size) {
+      const fallbackAnimation = {};
+      if (typeof props.initial !== "boolean") {
+        const initialTransition = resolveVariant(visualElement, Array.isArray(props.initial) ? props.initial[0] : props.initial);
+        if (initialTransition && initialTransition.transition) {
+          fallbackAnimation.transition = initialTransition.transition;
+        }
+      }
+      removedKeys.forEach((key) => {
+        const fallbackTarget = visualElement.getBaseTarget(key);
+        const motionValue = visualElement.getValue(key);
+        if (motionValue)
+          motionValue.liveStyle = true;
+        fallbackAnimation[key] = fallbackTarget ?? null;
+      });
+      animations.push({ animation: fallbackAnimation });
+    }
+    let shouldAnimate = Boolean(animations.length);
+    if (isInitialRender && (props.initial === false || props.initial === props.animate) && !visualElement.manuallyAnimateOnMount) {
+      shouldAnimate = false;
+    }
+    isInitialRender = false;
+    wasReset = false;
+    return shouldAnimate ? animate(animations) : Promise.resolve();
+  }
+  function setActive(type, isActive) {
+    if (state[type].isActive === isActive)
+      return Promise.resolve();
+    visualElement.variantChildren?.forEach((child) => child.animationState?.setActive(type, isActive));
+    state[type].isActive = isActive;
+    const animations = animateChanges(type);
+    for (const key in state) {
+      state[key].protectedKeys = {};
+    }
+    return animations;
+  }
+  return {
+    animateChanges,
+    setActive,
+    setAnimateFunction,
+    getState: () => state,
+    reset: () => {
+      state = createState();
+      wasReset = true;
+    }
+  };
+}
+function checkVariantsDidChange(prev, next) {
+  if (typeof next === "string") {
+    return next !== prev;
+  } else if (Array.isArray(next)) {
+    return !shallowCompare(next, prev);
+  }
+  return false;
+}
+function createTypeState(isActive = false) {
+  return {
+    isActive,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function createState() {
+  return {
+    animate: createTypeState(true),
+    whileInView: createTypeState(),
+    whileHover: createTypeState(),
+    whileTap: createTypeState(),
+    whileDrag: createTypeState(),
+    whileFocus: createTypeState(),
+    exit: createTypeState()
+  };
+}
+export {
+  checkVariantsDidChange,
+  createAnimationState
+};
+//# sourceMappingURL=animation-state.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/animation-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-state.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/animation-state.mjs"],"sourcesContent":["import { animateVisualElement } from '../../animation/interfaces/visual-element.mjs';\nimport { calcChildStagger } from '../../animation/utils/calc-child-stagger.mjs';\nimport { getVariantContext } from './get-variant-context.mjs';\nimport { isAnimationControls } from './is-animation-controls.mjs';\nimport { isKeyframesTarget } from './is-keyframes-target.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { shallowCompare } from './shallow-compare.mjs';\nimport { variantPriorityOrder } from './variant-props.mjs';\n\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction createAnimateFunction(visualElement) {\n    return (animations) => {\n        return Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n    };\n}\nfunction createAnimationState(visualElement) {\n    let animate = createAnimateFunction(visualElement);\n    let state = createState();\n    let isInitialRender = true;\n    /**\n     * Track whether the animation state has been reset (e.g. via StrictMode\n     * double-invocation or Suspense unmount/remount). On the first\n     * animateChanges() call after a reset we need to behave like the initial\n     * render for variant-inheritance checks, even though isInitialRender is\n     * already false.\n     */\n    let wasReset = false;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    const buildResolvedTypeValues = (type) => (acc, definition) => {\n        const resolved = resolveVariant(visualElement, definition, type === \"exit\"\n            ? visualElement.presenceContext?.custom\n            : undefined);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\n    };\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(changedActiveType) {\n        const { props } = visualElement;\n        const context = getVariantContext(visualElement.parent) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        const animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        const removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        let encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        let removedVariantIndex = Infinity;\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined\n                ? props[type]\n                : context[type];\n            const propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            const activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            let isInherited = prop === context[type] &&\n                prop !== props[type] &&\n                propIsVariant;\n            if (isInherited &&\n                (isInitialRender || wasReset) &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = { ...encounteredKeys };\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                continue;\n            }\n            /**\n             * If exit is already active and wasn't just activated, skip\n             * re-processing to prevent interrupting running exit animations.\n             * Re-resolving exit with a changed custom value can start new\n             * value animations that stop the originals, leaving the exit\n             * animation promise unresolved and the component stuck in the DOM.\n             */\n            if (type === \"exit\" && typeState.isActive && activeDelta !== true) {\n                if (typeState.prevResolvedValues) {\n                    encounteredKeys = {\n                        ...encounteredKeys,\n                        ...typeState.prevResolvedValues,\n                    };\n                }\n                continue;\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            let handledRemovedValues = false;\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            const definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                if (removedKeys.has(key)) {\n                    handledRemovedValues = true;\n                    removedKeys.delete(key);\n                }\n                typeState.needsAnimating[key] = true;\n                const motionValue = visualElement.getValue(key);\n                if (motionValue)\n                    motionValue.liveStyle = false;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                let valueHasChanged = false;\n                if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                    valueHasChanged = !shallowCompare(next, prev);\n                }\n                else {\n                    valueHasChanged = next !== prev;\n                }\n                if (valueHasChanged) {\n                    if (next !== undefined && next !== null) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            if (typeState.isActive) {\n                encounteredKeys = { ...encounteredKeys, ...resolvedValues };\n            }\n            if ((isInitialRender || wasReset) &&\n                visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to skip this animation\n             * unless the inherited variants haven't changed on this render.\n             */\n            const willAnimateViaParent = isInherited && variantDidChange;\n            const needsAnimating = !willAnimateViaParent || handledRemovedValues;\n            if (shouldAnimateType && needsAnimating) {\n                animations.push(...definitionList.map((animation) => {\n                    const options = { type };\n                    /**\n                     * If we're performing the initial animation, but we're not\n                     * rendering at the same time as the variant-controlling parent,\n                     * we want to use the parent's transition to calculate the stagger.\n                     */\n                    if (typeof animation === \"string\" &&\n                        (isInitialRender || wasReset) &&\n                        !willAnimateViaParent &&\n                        visualElement.manuallyAnimateOnMount &&\n                        visualElement.parent) {\n                        const { parent } = visualElement;\n                        const parentVariant = resolveVariant(parent, animation);\n                        if (parent.enteringChildren && parentVariant) {\n                            const { delayChildren } = parentVariant.transition || {};\n                            options.delay = calcChildStagger(parent.enteringChildren, visualElement, delayChildren);\n                        }\n                    }\n                    return {\n                        animation: animation,\n                        options,\n                    };\n                }));\n            }\n        }\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            const fallbackAnimation = {};\n            /**\n             * If the initial prop contains a transition we can use that, otherwise\n             * allow the animation function to use the visual element's default.\n             */\n            if (typeof props.initial !== \"boolean\") {\n                const initialTransition = resolveVariant(visualElement, Array.isArray(props.initial)\n                    ? props.initial[0]\n                    : props.initial);\n                if (initialTransition && initialTransition.transition) {\n                    fallbackAnimation.transition = initialTransition.transition;\n                }\n            }\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                const motionValue = visualElement.getValue(key);\n                if (motionValue)\n                    motionValue.liveStyle = true;\n                // @ts-expect-error - @mattgperry to figure if we should do something here\n                fallbackAnimation[key] = fallbackTarget ?? null;\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            (props.initial === false || props.initial === props.animate) &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        wasReset = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive) {\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        visualElement.variantChildren?.forEach((child) => child.animationState?.setActive(type, isActive));\n        state[type].isActive = isActive;\n        const animations = animateChanges(type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n        reset: () => {\n            state = createState();\n            wasReset = true;\n        },\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState };\n//# sourceMappingURL=animation-state.mjs.map\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/get-variant-context.js

@@ -0,0 +1,27 @@
+import { isVariantLabel } from "./is-variant-label.js";
+import { variantProps } from "./variant-props.js";
+const numVariantProps = variantProps.length;
+function getVariantContext(visualElement) {
+  if (!visualElement)
+    return void 0;
+  if (!visualElement.isControllingVariants) {
+    const context2 = visualElement.parent ? getVariantContext(visualElement.parent) || {} : {};
+    if (visualElement.props.initial !== void 0) {
+      context2.initial = visualElement.props.initial;
+    }
+    return context2;
+  }
+  const context = {};
+  for (let i = 0; i < numVariantProps; i++) {
+    const name = variantProps[i];
+    const prop = visualElement.props[name];
+    if (isVariantLabel(prop) || prop === false) {
+      context[name] = prop;
+    }
+  }
+  return context;
+}
+export {
+  getVariantContext
+};
+//# sourceMappingURL=get-variant-context.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/get-variant-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-variant-context.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/get-variant-context.mjs"],"sourcesContent":["import { isVariantLabel } from './is-variant-label.mjs';\nimport { variantProps } from './variant-props.mjs';\n\nconst numVariantProps = variantProps.length;\n/**\n * Get variant context from a visual element's parent chain.\n * Uses `any` type for visualElement to avoid circular dependencies.\n */\nfunction getVariantContext(visualElement) {\n    if (!visualElement)\n        return undefined;\n    if (!visualElement.isControllingVariants) {\n        const context = visualElement.parent\n            ? getVariantContext(visualElement.parent) || {}\n            : {};\n        if (visualElement.props.initial !== undefined) {\n            context.initial = visualElement.props.initial;\n        }\n        return context;\n    }\n    const context = {};\n    for (let i = 0; i < numVariantProps; i++) {\n        const name = variantProps[i];\n        const prop = visualElement.props[name];\n        if (isVariantLabel(prop) || prop === false) {\n            context[name] = prop;\n        }\n    }\n    return context;\n}\n\nexport { getVariantContext };\n//# sourceMappingURL=get-variant-context.mjs.map\n"],"names":["context"],"mappings":";;AAGA,MAAM,kBAAkB,aAAa;AAKrC,SAAS,kBAAkB,eAAe;AACtC,MAAI,CAAC;AACD,WAAO;AACX,MAAI,CAAC,cAAc,uBAAuB;AACtC,UAAMA,WAAU,cAAc,SACxB,kBAAkB,cAAc,MAAM,KAAK,CAAA,IAC3C,CAAA;AACN,QAAI,cAAc,MAAM,YAAY,QAAW;AAC3C,MAAAA,SAAQ,UAAU,cAAc,MAAM;AAAA,IAC1C;AACA,WAAOA;AAAA,EACX;AACA,QAAM,UAAU,CAAA;AAChB,WAAS,IAAI,GAAG,IAAI,iBAAiB,KAAK;AACtC,UAAM,OAAO,aAAa,CAAC;AAC3B,UAAM,OAAO,cAAc,MAAM,IAAI;AACrC,QAAI,eAAe,IAAI,KAAK,SAAS,OAAO;AACxC,cAAQ,IAAI,IAAI;AAAA,IACpB;AAAA,EACJ;AACA,SAAO;AACX;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-animation-controls.js

@@ -0,0 +1,7 @@
+function isAnimationControls(v) {
+  return v !== null && typeof v === "object" && typeof v.start === "function";
+}
+export {
+  isAnimationControls
+};
+//# sourceMappingURL=is-animation-controls.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-animation-controls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-animation-controls.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-animation-controls.mjs"],"sourcesContent":["function isAnimationControls(v) {\n    return (v !== null &&\n        typeof v === \"object\" &&\n        typeof v.start === \"function\");\n}\n\nexport { isAnimationControls };\n//# sourceMappingURL=is-animation-controls.mjs.map\n"],"names":[],"mappings":"AAAA,SAAS,oBAAoB,GAAG;AAC5B,SAAQ,MAAM,QACV,OAAO,MAAM,YACb,OAAO,EAAE,UAAU;AAC3B;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-controlling-variants.js

@@ -0,0 +1,14 @@
+import { isAnimationControls } from "./is-animation-controls.js";
+import { isVariantLabel } from "./is-variant-label.js";
+import { variantProps } from "./variant-props.js";
+function isControllingVariants(props) {
+  return isAnimationControls(props.animate) || variantProps.some((name) => isVariantLabel(props[name]));
+}
+function isVariantNode(props) {
+  return Boolean(isControllingVariants(props) || props.variants);
+}
+export {
+  isControllingVariants,
+  isVariantNode
+};
+//# sourceMappingURL=is-controlling-variants.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-controlling-variants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-controlling-variants.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-controlling-variants.mjs"],"sourcesContent":["import { isAnimationControls } from './is-animation-controls.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { variantProps } from './variant-props.mjs';\n\nfunction isControllingVariants(props) {\n    return (isAnimationControls(props.animate) ||\n        variantProps.some((name) => isVariantLabel(props[name])));\n}\nfunction isVariantNode(props) {\n    return Boolean(isControllingVariants(props) || props.variants);\n}\n\nexport { isControllingVariants, isVariantNode };\n//# sourceMappingURL=is-controlling-variants.mjs.map\n"],"names":[],"mappings":";;;AAIA,SAAS,sBAAsB,OAAO;AAClC,SAAQ,oBAAoB,MAAM,OAAO,KACrC,aAAa,KAAK,CAAC,SAAS,eAAe,MAAM,IAAI,CAAC,CAAC;AAC/D;AACA,SAAS,cAAc,OAAO;AAC1B,SAAO,QAAQ,sBAAsB,KAAK,KAAK,MAAM,QAAQ;AACjE;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-forced-motion-value.js

@@ -0,0 +1,10 @@
+import { transformProps } from "./keys-transform.js";
+import { scaleCorrectors } from "../../projection/styles/scale-correction.js";
+function isForcedMotionValue(key, { layout, layoutId }) {
+  return transformProps.has(key) || key.startsWith("origin") || (layout || layoutId !== void 0) && (!!scaleCorrectors[key] || key === "opacity");
+}
+export {
+  isForcedMotionValue,
+  scaleCorrectors
+};
+//# sourceMappingURL=is-forced-motion-value.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-forced-motion-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-forced-motion-value.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-forced-motion-value.mjs"],"sourcesContent":["import { transformProps } from './keys-transform.mjs';\nimport { scaleCorrectors } from '../../projection/styles/scale-correction.mjs';\nexport { addScaleCorrector } from '../../projection/styles/scale-correction.mjs';\n\nfunction isForcedMotionValue(key, { layout, layoutId }) {\n    return (transformProps.has(key) ||\n        key.startsWith(\"origin\") ||\n        ((layout || layoutId !== undefined) &&\n            (!!scaleCorrectors[key] || key === \"opacity\")));\n}\n\nexport { isForcedMotionValue, scaleCorrectors };\n//# sourceMappingURL=is-forced-motion-value.mjs.map\n"],"names":[],"mappings":";;AAIA,SAAS,oBAAoB,KAAK,EAAE,QAAQ,SAAQ,GAAI;AACpD,SAAQ,eAAe,IAAI,GAAG,KAC1B,IAAI,WAAW,QAAQ,MACrB,UAAU,aAAa,YACpB,CAAC,CAAC,gBAAgB,GAAG,KAAK,QAAQ;AAC/C;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-keyframes-target.js

@@ -0,0 +1,7 @@
+const isKeyframesTarget = (v) => {
+  return Array.isArray(v);
+};
+export {
+  isKeyframesTarget
+};
+//# sourceMappingURL=is-keyframes-target.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-keyframes-target.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-keyframes-target.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-keyframes-target.mjs"],"sourcesContent":["const isKeyframesTarget = (v) => {\n    return Array.isArray(v);\n};\n\nexport { isKeyframesTarget };\n//# sourceMappingURL=is-keyframes-target.mjs.map\n"],"names":[],"mappings":"AAAK,MAAC,oBAAoB,CAAC,MAAM;AAC7B,SAAO,MAAM,QAAQ,CAAC;AAC1B;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-variant-label.js

@@ -0,0 +1,7 @@
+function isVariantLabel(v) {
+  return typeof v === "string" || Array.isArray(v);
+}
+export {
+  isVariantLabel
+};
+//# sourceMappingURL=is-variant-label.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-variant-label.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-variant-label.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/is-variant-label.mjs"],"sourcesContent":["/**\n * Decides if the supplied variable is variant label\n */\nfunction isVariantLabel(v) {\n    return typeof v === \"string\" || Array.isArray(v);\n}\n\nexport { isVariantLabel };\n//# sourceMappingURL=is-variant-label.mjs.map\n"],"names":[],"mappings":"AAGA,SAAS,eAAe,GAAG;AACvB,SAAO,OAAO,MAAM,YAAY,MAAM,QAAQ,CAAC;AACnD;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/keys-position.js

@@ -0,0 +1,14 @@
+import { transformPropOrder } from "./keys-transform.js";
+const positionalKeys = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  ...transformPropOrder
+]);
+export {
+  positionalKeys
+};
+//# sourceMappingURL=keys-position.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/keys-position.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys-position.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/keys-position.mjs"],"sourcesContent":["import { transformPropOrder } from './keys-transform.mjs';\n\nconst positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    ...transformPropOrder,\n]);\n\nexport { positionalKeys };\n//# sourceMappingURL=keys-position.mjs.map\n"],"names":[],"mappings":";AAEK,MAAC,iBAAiB,oBAAI,IAAI;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AACP,CAAC;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/keys-transform.js

@@ -0,0 +1,25 @@
+const transformPropOrder = [
+  "transformPerspective",
+  "x",
+  "y",
+  "z",
+  "translateX",
+  "translateY",
+  "translateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "skew",
+  "skewX",
+  "skewY"
+];
+const transformProps = /* @__PURE__ */ (() => new Set(transformPropOrder))();
+export {
+  transformPropOrder,
+  transformProps
+};
+//# sourceMappingURL=keys-transform.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/keys-transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys-transform.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/keys-transform.mjs"],"sourcesContent":["/**\n * Generate a list of every possible transform key.\n */\nconst transformPropOrder = [\n    \"transformPerspective\",\n    \"x\",\n    \"y\",\n    \"z\",\n    \"translateX\",\n    \"translateY\",\n    \"translateZ\",\n    \"scale\",\n    \"scaleX\",\n    \"scaleY\",\n    \"rotate\",\n    \"rotateX\",\n    \"rotateY\",\n    \"rotateZ\",\n    \"skew\",\n    \"skewX\",\n    \"skewY\",\n];\n/**\n * A quick lookup for transform props.\n */\nconst transformProps = /*@__PURE__*/ (() => new Set(transformPropOrder))();\n\nexport { transformPropOrder, transformProps };\n//# sourceMappingURL=keys-transform.mjs.map\n"],"names":[],"mappings":"AAGK,MAAC,qBAAqB;AAAA,EACvB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ;AAIK,MAAC,iBAAgC,uBAAM,IAAI,IAAI,kBAAkB,GAAC;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/motion-values.js

@@ -0,0 +1,34 @@
+import { motionValue } from "../../value/index.js";
+import { isMotionValue } from "../../value/utils/is-motion-value.js";
+function updateMotionValuesFromProps(element, next, prev) {
+  for (const key in next) {
+    const nextValue = next[key];
+    const prevValue = prev[key];
+    if (isMotionValue(nextValue)) {
+      element.addValue(key, nextValue);
+    } else if (isMotionValue(prevValue)) {
+      element.addValue(key, motionValue(nextValue, { owner: element }));
+    } else if (prevValue !== nextValue) {
+      if (element.hasValue(key)) {
+        const existingValue = element.getValue(key);
+        if (existingValue.liveStyle === true) {
+          existingValue.jump(nextValue);
+        } else if (!existingValue.hasAnimated) {
+          existingValue.set(nextValue);
+        }
+      } else {
+        const latestValue = element.getStaticValue(key);
+        element.addValue(key, motionValue(latestValue !== void 0 ? latestValue : nextValue, { owner: element }));
+      }
+    }
+  }
+  for (const key in prev) {
+    if (next[key] === void 0)
+      element.removeValue(key);
+  }
+  return next;
+}
+export {
+  updateMotionValuesFromProps
+};
+//# sourceMappingURL=motion-values.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/motion-values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion-values.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/motion-values.mjs"],"sourcesContent":["import { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\n/**\n * Updates motion values from props changes.\n * Uses `any` type for element to avoid circular dependencies with VisualElement.\n */\nfunction updateMotionValuesFromProps(element, next, prev) {\n    for (const key in next) {\n        const nextValue = next[key];\n        const prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping from a motion value to a static value,\n             * create a new motion value from that\n             */\n            element.addValue(key, motionValue(nextValue, { owner: element }));\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                const existingValue = element.getValue(key);\n                if (existingValue.liveStyle === true) {\n                    existingValue.jump(nextValue);\n                }\n                else if (!existingValue.hasAnimated) {\n                    existingValue.set(nextValue);\n                }\n            }\n            else {\n                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n//# sourceMappingURL=motion-values.mjs.map\n"],"names":[],"mappings":";;AAOA,SAAS,4BAA4B,SAAS,MAAM,MAAM;AACtD,aAAW,OAAO,MAAM;AACpB,UAAM,YAAY,KAAK,GAAG;AAC1B,UAAM,YAAY,KAAK,GAAG;AAC1B,QAAI,cAAc,SAAS,GAAG;AAK1B,cAAQ,SAAS,KAAK,SAAS;AAAA,IACnC,WACS,cAAc,SAAS,GAAG;AAK/B,cAAQ,SAAS,KAAK,YAAY,WAAW,EAAE,OAAO,QAAO,CAAE,CAAC;AAAA,IACpE,WACS,cAAc,WAAW;AAM9B,UAAI,QAAQ,SAAS,GAAG,GAAG;AACvB,cAAM,gBAAgB,QAAQ,SAAS,GAAG;AAC1C,YAAI,cAAc,cAAc,MAAM;AAClC,wBAAc,KAAK,SAAS;AAAA,QAChC,WACS,CAAC,cAAc,aAAa;AACjC,wBAAc,IAAI,SAAS;AAAA,QAC/B;AAAA,MACJ,OACK;AACD,cAAM,cAAc,QAAQ,eAAe,GAAG;AAC9C,gBAAQ,SAAS,KAAK,YAAY,gBAAgB,SAAY,cAAc,WAAW,EAAE,OAAO,QAAO,CAAE,CAAC;AAAA,MAC9G;AAAA,IACJ;AAAA,EACJ;AAEA,aAAW,OAAO,MAAM;AACpB,QAAI,KAAK,GAAG,MAAM;AACd,cAAQ,YAAY,GAAG;AAAA,EAC/B;AACA,SAAO;AACX;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/reduced-motion/index.js

@@ -0,0 +1,21 @@
+import { hasReducedMotionListener, prefersReducedMotion } from "./state.js";
+const isBrowser = typeof window !== "undefined";
+function initPrefersReducedMotion() {
+  hasReducedMotionListener.current = true;
+  if (!isBrowser)
+    return;
+  if (window.matchMedia) {
+    const motionMediaQuery = window.matchMedia("(prefers-reduced-motion)");
+    const setReducedMotionPreferences = () => prefersReducedMotion.current = motionMediaQuery.matches;
+    motionMediaQuery.addEventListener("change", setReducedMotionPreferences);
+    setReducedMotionPreferences();
+  } else {
+    prefersReducedMotion.current = false;
+  }
+}
+export {
+  hasReducedMotionListener,
+  initPrefersReducedMotion,
+  prefersReducedMotion
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/reduced-motion/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/reduced-motion/index.mjs"],"sourcesContent":["import { hasReducedMotionListener, prefersReducedMotion } from './state.mjs';\n\nconst isBrowser = typeof window !== \"undefined\";\nfunction initPrefersReducedMotion() {\n    hasReducedMotionListener.current = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        const motionMediaQuery = window.matchMedia(\"(prefers-reduced-motion)\");\n        const setReducedMotionPreferences = () => (prefersReducedMotion.current = motionMediaQuery.matches);\n        motionMediaQuery.addEventListener(\"change\", setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n\nexport { hasReducedMotionListener, initPrefersReducedMotion, prefersReducedMotion };\n//# sourceMappingURL=index.mjs.map\n"],"names":[],"mappings":";AAEA,MAAM,YAAY,OAAO,WAAW;AACpC,SAAS,2BAA2B;AAChC,2BAAyB,UAAU;AACnC,MAAI,CAAC;AACD;AACJ,MAAI,OAAO,YAAY;AACnB,UAAM,mBAAmB,OAAO,WAAW,0BAA0B;AACrE,UAAM,8BAA8B,MAAO,qBAAqB,UAAU,iBAAiB;AAC3F,qBAAiB,iBAAiB,UAAU,2BAA2B;AACvE,gCAA2B;AAAA,EAC/B,OACK;AACD,yBAAqB,UAAU;AAAA,EACnC;AACJ;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/reduced-motion/state.js

@@ -0,0 +1,7 @@
+const prefersReducedMotion = { current: null };
+const hasReducedMotionListener = { current: false };
+export {
+  hasReducedMotionListener,
+  prefersReducedMotion
+};
+//# sourceMappingURL=state.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/reduced-motion/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/reduced-motion/state.mjs"],"sourcesContent":["// Does this device prefer reduced motion? Returns `null` server-side.\nconst prefersReducedMotion = { current: null };\nconst hasReducedMotionListener = { current: false };\n\nexport { hasReducedMotionListener, prefersReducedMotion };\n//# sourceMappingURL=state.mjs.map\n"],"names":[],"mappings":"AACK,MAAC,uBAAuB,EAAE,SAAS,KAAI;AACvC,MAAC,2BAA2B,EAAE,SAAS,MAAK;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/resolve-dynamic-variants.js

@@ -0,0 +1,9 @@
+import { resolveVariantFromProps } from "./resolve-variants.js";
+function resolveVariant(visualElement, definition, custom) {
+  const props = visualElement.getProps();
+  return resolveVariantFromProps(props, definition, custom !== void 0 ? custom : props.custom, visualElement);
+}
+export {
+  resolveVariant
+};
+//# sourceMappingURL=resolve-dynamic-variants.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/resolve-dynamic-variants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-dynamic-variants.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/resolve-dynamic-variants.mjs"],"sourcesContent":["import { resolveVariantFromProps } from './resolve-variants.mjs';\n\nfunction resolveVariant(visualElement, definition, custom) {\n    const props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== undefined ? custom : props.custom, visualElement);\n}\n\nexport { resolveVariant };\n//# sourceMappingURL=resolve-dynamic-variants.mjs.map\n"],"names":[],"mappings":";AAEA,SAAS,eAAe,eAAe,YAAY,QAAQ;AACvD,QAAM,QAAQ,cAAc,SAAQ;AACpC,SAAO,wBAAwB,OAAO,YAAY,WAAW,SAAY,SAAS,MAAM,QAAQ,aAAa;AACjH;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/resolve-variants.js

@@ -0,0 +1,26 @@
+function getValueState(visualElement) {
+  const state = [{}, {}];
+  visualElement?.values.forEach((value, key) => {
+    state[0][key] = value.get();
+    state[1][key] = value.getVelocity();
+  });
+  return state;
+}
+function resolveVariantFromProps(props, definition, custom, visualElement) {
+  if (typeof definition === "function") {
+    const [current, velocity] = getValueState(visualElement);
+    definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
+  }
+  if (typeof definition === "string") {
+    definition = props.variants && props.variants[definition];
+  }
+  if (typeof definition === "function") {
+    const [current, velocity] = getValueState(visualElement);
+    definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
+  }
+  return definition;
+}
+export {
+  resolveVariantFromProps
+};
+//# sourceMappingURL=resolve-variants.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/resolve-variants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-variants.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/resolve-variants.mjs"],"sourcesContent":["function getValueState(visualElement) {\n    const state = [{}, {}];\n    visualElement?.values.forEach((value, key) => {\n        state[0][key] = value.get();\n        state[1][key] = value.getVelocity();\n    });\n    return state;\n}\nfunction resolveVariantFromProps(props, definition, custom, visualElement) {\n    /**\n     * If the variant definition is a function, resolve.\n     */\n    if (typeof definition === \"function\") {\n        const [current, velocity] = getValueState(visualElement);\n        definition = definition(custom !== undefined ? custom : props.custom, current, velocity);\n    }\n    /**\n     * If the variant definition is a variant label, or\n     * the function returned a variant label, resolve.\n     */\n    if (typeof definition === \"string\") {\n        definition = props.variants && props.variants[definition];\n    }\n    /**\n     * At this point we've resolved both functions and variant labels,\n     * but the resolved variant label might itself have been a function.\n     * If so, resolve. This can only have returned a valid target object.\n     */\n    if (typeof definition === \"function\") {\n        const [current, velocity] = getValueState(visualElement);\n        definition = definition(custom !== undefined ? custom : props.custom, current, velocity);\n    }\n    return definition;\n}\n\nexport { resolveVariantFromProps };\n//# sourceMappingURL=resolve-variants.mjs.map\n"],"names":[],"mappings":"AAAA,SAAS,cAAc,eAAe;AAClC,QAAM,QAAQ,CAAC,CAAA,GAAI,EAAE;AACrB,iBAAe,OAAO,QAAQ,CAAC,OAAO,QAAQ;AAC1C,UAAM,CAAC,EAAE,GAAG,IAAI,MAAM,IAAG;AACzB,UAAM,CAAC,EAAE,GAAG,IAAI,MAAM,YAAW;AAAA,EACrC,CAAC;AACD,SAAO;AACX;AACA,SAAS,wBAAwB,OAAO,YAAY,QAAQ,eAAe;AAIvE,MAAI,OAAO,eAAe,YAAY;AAClC,UAAM,CAAC,SAAS,QAAQ,IAAI,cAAc,aAAa;AACvD,iBAAa,WAAW,WAAW,SAAY,SAAS,MAAM,QAAQ,SAAS,QAAQ;AAAA,EAC3F;AAKA,MAAI,OAAO,eAAe,UAAU;AAChC,iBAAa,MAAM,YAAY,MAAM,SAAS,UAAU;AAAA,EAC5D;AAMA,MAAI,OAAO,eAAe,YAAY;AAClC,UAAM,CAAC,SAAS,QAAQ,IAAI,cAAc,aAAa;AACvD,iBAAa,WAAW,WAAW,SAAY,SAAS,MAAM,QAAQ,SAAS,QAAQ;AAAA,EAC3F;AACA,SAAO;AACX;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/setters.js

@@ -0,0 +1,26 @@
+import { motionValue } from "../../value/index.js";
+import { resolveVariant } from "./resolve-dynamic-variants.js";
+import { isKeyframesTarget } from "./is-keyframes-target.js";
+function setMotionValue(visualElement, key, value) {
+  if (visualElement.hasValue(key)) {
+    visualElement.getValue(key).set(value);
+  } else {
+    visualElement.addValue(key, motionValue(value));
+  }
+}
+function resolveFinalValueInKeyframes(v) {
+  return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;
+}
+function setTarget(visualElement, definition) {
+  const resolved = resolveVariant(visualElement, definition);
+  let { transitionEnd = {}, transition = {}, ...target } = resolved || {};
+  target = { ...target, ...transitionEnd };
+  for (const key in target) {
+    const value = resolveFinalValueInKeyframes(target[key]);
+    setMotionValue(visualElement, key, value);
+  }
+}
+export {
+  setTarget
+};
+//# sourceMappingURL=setters.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/setters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setters.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/setters.mjs"],"sourcesContent":["import { motionValue } from '../../value/index.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { isKeyframesTarget } from './is-keyframes-target.mjs';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n    if (visualElement.hasValue(key)) {\n        visualElement.getValue(key).set(value);\n    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction resolveFinalValueInKeyframes(v) {\n    // TODO maybe throw if v.length - 1 is placeholder token?\n    return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n}\nfunction setTarget(visualElement, definition) {\n    const resolved = resolveVariant(visualElement, definition);\n    let { transitionEnd = {}, transition = {}, ...target } = resolved || {};\n    target = { ...target, ...transitionEnd };\n    for (const key in target) {\n        const value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\n\nexport { setTarget };\n//# sourceMappingURL=setters.mjs.map\n"],"names":[],"mappings":";;;AAQA,SAAS,eAAe,eAAe,KAAK,OAAO;AAC/C,MAAI,cAAc,SAAS,GAAG,GAAG;AAC7B,kBAAc,SAAS,GAAG,EAAE,IAAI,KAAK;AAAA,EACzC,OACK;AACD,kBAAc,SAAS,KAAK,YAAY,KAAK,CAAC;AAAA,EAClD;AACJ;AACA,SAAS,6BAA6B,GAAG;AAErC,SAAO,kBAAkB,CAAC,IAAI,EAAE,EAAE,SAAS,CAAC,KAAK,IAAI;AACzD;AACA,SAAS,UAAU,eAAe,YAAY;AAC1C,QAAM,WAAW,eAAe,eAAe,UAAU;AACzD,MAAI,EAAE,gBAAgB,CAAA,GAAI,aAAa,CAAA,GAAI,GAAG,OAAM,IAAK,YAAY,CAAA;AACrE,WAAS,EAAE,GAAG,QAAQ,GAAG,cAAa;AACtC,aAAW,OAAO,QAAQ;AACtB,UAAM,QAAQ,6BAA6B,OAAO,GAAG,CAAC;AACtD,mBAAe,eAAe,KAAK,KAAK;AAAA,EAC5C;AACJ;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/render/utils/shallow-compare.js

@@ -0,0 +1,16 @@
+function shallowCompare(next, prev) {
+  if (!Array.isArray(prev))
+    return false;
+  const prevLength = prev.length;
+  if (prevLength !== next.length)
+    return false;
+  for (let i = 0; i < prevLength; i++) {
+    if (prev[i] !== next[i])
+      return false;
+  }
+  return true;
+}
+export {
+  shallowCompare
+};
+//# sourceMappingURL=shallow-compare.js.map