motion-v 0.3.0 → 0.3.1-beta.1

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/easing/steps.mjs

@@ -0,0 +1,12 @@
+import { clamp } from "../utils/clamp.mjs";
+function steps(numSteps, direction = "end") {
+  return (progress) => {
+    progress = direction === "end" ? Math.min(progress, 0.999) : Math.max(progress, 1e-3);
+    const expanded = progress * numSteps;
+    const rounded = direction === "end" ? Math.floor(expanded) : Math.ceil(expanded);
+    return clamp(0, 1, rounded / numSteps);
+  };
+}
+export {
+  steps
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/easing/utils/create-generator-easing.mjs

@@ -0,0 +1,14 @@
+import { calcGeneratorDuration, maxGeneratorDuration } from "../../animation/generators/utils/calc-duration.mjs";
+import { millisecondsToSeconds } from "../../utils/time-conversion.mjs";
+function createGeneratorEasing(options, scale = 100, createGenerator) {
+  const generator = createGenerator({ ...options, keyframes: [0, scale] });
+  const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
+  return {
+    type: "keyframes",
+    ease: (progress) => generator.next(duration * progress).value / scale,
+    duration: millisecondsToSeconds(duration)
+  };
+}
+export {
+  createGeneratorEasing
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/easing/utils/get-easing-for-segment.mjs

@@ -0,0 +1,8 @@
+import { wrap } from "../../utils/wrap.mjs";
+import { isEasingArray } from "./is-easing-array.mjs";
+function getEasingForSegment(easing, i) {
+  return isEasingArray(easing) ? easing[wrap(0, easing.length, i)] : easing;
+}
+export {
+  getEasingForSegment
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/easing/utils/is-bezier-definition.mjs

@@ -0,0 +1,4 @@
+const isBezierDefinition = (easing) => Array.isArray(easing) && typeof easing[0] === "number";
+export {
+  isBezierDefinition
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/easing/utils/is-easing-array.mjs

@@ -0,0 +1,6 @@
+const isEasingArray = (ease) => {
+  return Array.isArray(ease) && typeof ease[0] !== "number";
+};
+export {
+  isEasingArray
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/easing/utils/map.mjs

@@ -0,0 +1,35 @@
+import { invariant } from "../../utils/errors.mjs";
+import { cubicBezier } from "../cubic-bezier.mjs";
+import { noop } from "../../utils/noop.mjs";
+import { easeIn, easeInOut, easeOut } from "../ease.mjs";
+import { circIn, circInOut, circOut } from "../circ.mjs";
+import { backIn, backInOut, backOut } from "../back.mjs";
+import { anticipate } from "../anticipate.mjs";
+import { isBezierDefinition } from "./is-bezier-definition.mjs";
+const easingLookup = {
+  linear: noop,
+  easeIn,
+  easeInOut,
+  easeOut,
+  circIn,
+  circInOut,
+  circOut,
+  backIn,
+  backInOut,
+  backOut,
+  anticipate
+};
+const easingDefinitionToFunction = (definition) => {
+  if (isBezierDefinition(definition)) {
+    invariant(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`);
+    const [x1, y1, x2, y2] = definition;
+    return cubicBezier(x1, y1, x2, y2);
+  } else if (typeof definition === "string") {
+    invariant(easingLookup[definition] !== void 0, `Invalid easing type '${definition}'`);
+    return easingLookup[definition];
+  }
+  return definition;
+};
+export {
+  easingDefinitionToFunction
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/frameloop/batcher.mjs

@@ -0,0 +1,75 @@
+import { createRenderStep } from "./render-step.mjs";
+const stepsOrder = [
+  "read",
+  // Read
+  "resolveKeyframes",
+  // Write/Read/Write/Read
+  "update",
+  // Compute
+  "preRender",
+  // Compute
+  "render",
+  // Write
+  "postRender"
+  // Compute
+];
+const maxElapsed = 40;
+function createRenderBatcher(scheduleNextBatch, allowKeepAlive) {
+  let runNextFrame = false;
+  let useDefaultElapsed = true;
+  const state = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: false
+  };
+  const flagRunNextFrame = () => runNextFrame = true;
+  const steps = stepsOrder.reduce((acc, key) => {
+    acc[key] = createRenderStep(flagRunNextFrame);
+    return acc;
+  }, {});
+  const { read, resolveKeyframes, update, preRender, render, postRender } = steps;
+  const processBatch = () => {
+    const timestamp = performance.now();
+    runNextFrame = false;
+    state.delta = useDefaultElapsed ? 1e3 / 60 : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);
+    state.timestamp = timestamp;
+    state.isProcessing = true;
+    read.process(state);
+    resolveKeyframes.process(state);
+    update.process(state);
+    preRender.process(state);
+    render.process(state);
+    postRender.process(state);
+    state.isProcessing = false;
+    if (runNextFrame && allowKeepAlive) {
+      useDefaultElapsed = false;
+      scheduleNextBatch(processBatch);
+    }
+  };
+  const wake = () => {
+    runNextFrame = true;
+    useDefaultElapsed = true;
+    if (!state.isProcessing) {
+      scheduleNextBatch(processBatch);
+    }
+  };
+  const schedule = stepsOrder.reduce((acc, key) => {
+    const step = steps[key];
+    acc[key] = (process, keepAlive = false, immediate = false) => {
+      if (!runNextFrame)
+        wake();
+      return step.schedule(process, keepAlive, immediate);
+    };
+    return acc;
+  }, {});
+  const cancel = (process) => {
+    for (let i = 0; i < stepsOrder.length; i++) {
+      steps[stepsOrder[i]].cancel(process);
+    }
+  };
+  return { schedule, cancel, state, steps };
+}
+export {
+  createRenderBatcher,
+  stepsOrder
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/frameloop/frame.mjs

@@ -0,0 +1,9 @@
+import { noop } from "../utils/noop.mjs";
+import { createRenderBatcher } from "./batcher.mjs";
+const { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps } = createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop, true);
+export {
+  cancelFrame,
+  frame,
+  frameData,
+  frameSteps
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/frameloop/index-legacy.mjs

@@ -0,0 +1,11 @@
+import { stepsOrder } from "./batcher.mjs";
+import { frame, cancelFrame } from "./frame.mjs";
+const sync = frame;
+const cancelSync = stepsOrder.reduce((acc, key) => {
+  acc[key] = (process) => cancelFrame(process);
+  return acc;
+}, {});
+export {
+  cancelSync,
+  sync
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/frameloop/render-step.mjs

@@ -0,0 +1,63 @@
+function createRenderStep(runNextFrame) {
+  let thisFrame = /* @__PURE__ */ new Set();
+  let nextFrame = /* @__PURE__ */ new Set();
+  let isProcessing = false;
+  let flushNextFrame = false;
+  const toKeepAlive = /* @__PURE__ */ new WeakSet();
+  let latestFrameData = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: false
+  };
+  function triggerCallback(callback) {
+    if (toKeepAlive.has(callback)) {
+      step.schedule(callback);
+      runNextFrame();
+    }
+    callback(latestFrameData);
+  }
+  const step = {
+    /**
+     * Schedule a process to run on the next frame.
+     */
+    schedule: (callback, keepAlive = false, immediate = false) => {
+      const addToCurrentFrame = immediate && isProcessing;
+      const queue = addToCurrentFrame ? thisFrame : nextFrame;
+      if (keepAlive)
+        toKeepAlive.add(callback);
+      if (!queue.has(callback))
+        queue.add(callback);
+      return callback;
+    },
+    /**
+     * Cancel the provided callback from running on the next frame.
+     */
+    cancel: (callback) => {
+      nextFrame.delete(callback);
+      toKeepAlive.delete(callback);
+    },
+    /**
+     * Execute all schedule callbacks.
+     */
+    process: (frameData) => {
+      latestFrameData = frameData;
+      if (isProcessing) {
+        flushNextFrame = true;
+        return;
+      }
+      isProcessing = true;
+      [thisFrame, nextFrame] = [nextFrame, thisFrame];
+      nextFrame.clear();
+      thisFrame.forEach(triggerCallback);
+      isProcessing = false;
+      if (flushNextFrame) {
+        flushNextFrame = false;
+        step.process(frameData);
+      }
+    }
+  };
+  return step;
+}
+export {
+  createRenderStep
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/frameloop/sync-time.mjs

@@ -0,0 +1,21 @@
+import { MotionGlobalConfig } from "../utils/GlobalConfig.mjs";
+import { frameData } from "./frame.mjs";
+let now;
+function clearTime() {
+  now = void 0;
+}
+const time = {
+  now: () => {
+    if (now === void 0) {
+      time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming ? frameData.timestamp : performance.now());
+    }
+    return now;
+  },
+  set: (newTime) => {
+    now = newTime;
+    queueMicrotask(clearTime);
+  }
+};
+export {
+  time
+};

package/dist/es/{node_modules/.pnpm/framer-motion@11.11.11/node_modules → external/.pnpm/framer-motion@11.11.11/external}/framer-motion/dist/es/motion/features/definitions.mjs

@@ -1,4 +1,4 @@
-const n = {
+const featureProps = {
   animation: [
     "animate",
     "variants",
@@ -17,11 +17,13 @@ const n = {
   pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
   inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
   layout: ["layout", "layoutId"]
-}, t = {};
-for (const e in n)
-  t[e] = {
-    isEnabled: (o) => n[e].some((a) => !!o[a])
+};
+const featureDefinitions = {};
+for (const key in featureProps) {
+  featureDefinitions[key] = {
+    isEnabled: (props) => featureProps[key].some((name) => !!props[name])
   };
+}
 export {
-  t as featureDefinitions
+  featureDefinitions
 };

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs

@@ -0,0 +1,8 @@
+import { scaleCorrectors } from "../../projection/styles/scale-correction.mjs";
+import { transformProps } from "../../render/html/utils/transform.mjs";
+function isForcedMotionValue(key, { layout, layoutId }) {
+  return transformProps.has(key) || key.startsWith("origin") || (layout || layoutId !== void 0) && (!!scaleCorrectors[key] || key === "opacity");
+}
+export {
+  isForcedMotionValue
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/geometry/conversion.mjs

@@ -0,0 +1,22 @@
+function convertBoundingBoxToBox({ top, left, right, bottom }) {
+  return {
+    x: { min: left, max: right },
+    y: { min: top, max: bottom }
+  };
+}
+function transformBoxPoints(point, transformPoint) {
+  if (!transformPoint)
+    return point;
+  const topLeft = transformPoint({ x: point.left, y: point.top });
+  const bottomRight = transformPoint({ x: point.right, y: point.bottom });
+  return {
+    top: topLeft.y,
+    left: topLeft.x,
+    bottom: bottomRight.y,
+    right: bottomRight.x
+  };
+}
+export {
+  convertBoundingBoxToBox,
+  transformBoxPoints
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/geometry/models.mjs

@@ -0,0 +1,9 @@
+const createAxis = () => ({ min: 0, max: 0 });
+const createBox = () => ({
+  x: createAxis(),
+  y: createAxis()
+});
+export {
+  createAxis,
+  createBox
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/styles/scale-correction.mjs

@@ -0,0 +1,4 @@
+const scaleCorrectors = {};
+export {
+  scaleCorrectors
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/utils/measure.mjs

@@ -0,0 +1,7 @@
+import { convertBoundingBoxToBox, transformBoxPoints } from "../geometry/conversion.mjs";
+function measureViewportBox(instance, transformPoint) {
+  return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));
+}
+export {
+  measureViewportBox
+};