"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/utils/motion-presets.ts
var motion_presets_exports = {};
__export(motion_presets_exports, {
  DISTANCES: () => DISTANCES,
  DURATIONS: () => DURATIONS,
  EASINGS: () => EASINGS,
  HOVER: () => HOVER,
  HOVER_TRANSITION: () => HOVER_TRANSITION,
  STAGGER: () => STAGGER,
  STAGGER_CONTAINERS: () => STAGGER_CONTAINERS,
  STAGGER_ITEMS: () => STAGGER_ITEMS,
  VARIANTS: () => VARIANTS,
  VIEWPORT: () => VIEWPORT,
  createSlideVariant: () => createSlideVariant,
  createTransition: () => createTransition,
  mergeVariants: () => mergeVariants
});
module.exports = __toCommonJS(motion_presets_exports);
var DURATIONS = {
  /** 0.15s - Micro-interactions, immediate feedback */
  instant: 0.15,
  /** 0.3s - Hover effects, tooltips, quick transitions */
  fast: 0.3,
  /** 0.5s - Standard page elements, cards, modals */
  normal: 0.5,
  /** 0.8s - Hero sections, emphasized content */
  slow: 0.8,
  /** 1.2s - Page transitions, complex sequences */
  slower: 1.2
};
var EASINGS = {
  /** Constant speed - use for continuous motion (spinners, scrolling) */
  linear: [0, 0, 1, 1],
  /** Fast start, slow end - use for entrances (fade in, slide in) */
  easeOut: [0, 0, 0.2, 1],
  /** Slow start, fast end - use for exits (fade out, slide out) */
  easeIn: [0.4, 0, 1, 1],
  /** Smooth both ends - use for movement (slide across, scale) */
  easeInOut: [0.4, 0, 0.2, 1],
  /** Natural bounce - use for interactive elements, emphasis */
  spring: { type: "spring", stiffness: 100, damping: 15 },
  /** Gentle bounce - use for cards, modals, subtle effects */
  softSpring: { type: "spring", stiffness: 80, damping: 15 },
  /** Bouncy - use for playful interactions, success states */
  bouncySpring: { type: "spring", stiffness: 120, damping: 12 }
};
var HOVER = {
  /** Standard lift: -6px up (most common) */
  lift: { y: -6 },
  /** Lift with scale: -6px up + 5% scale (buttons, cards) */
  liftWithScale: { y: -6, scale: 1.05 },
  /** Subtle lift: -4px up (small elements, icons) */
  subtle: { y: -4 },
  /** Dramatic lift: -8px up (hero elements, featured cards) */
  dramatic: { y: -8 }
};
var HOVER_TRANSITION = {
  duration: DURATIONS.fast,
  ease: EASINGS.easeOut
};
var DISTANCES = {
  /** 10px - Subtle movement, micro-interactions */
  sm: 10,
  /** 20px - Noticeable movement, standard slides */
  md: 20,
  /** 40px - Prominent movement, emphasized entrances */
  lg: 40,
  /** 60px - Dramatic movement, hero sections */
  xl: 60
};
var STAGGER = {
  /** 0.05s - Fast stagger (3-5 items) */
  fast: 0.05,
  /** 0.1s - Normal stagger (6-10 items) */
  normal: 0.1,
  /** 0.15s - Slow stagger (large sections) */
  slow: 0.15
};
var VIEWPORT = {
  /** Trigger once immediately when any part is visible */
  once: { once: true, amount: 0 },
  /** Trigger once when 30% is visible - good for cards */
  oncePartial: { once: true, amount: 0.3 },
  /** Trigger once when 50% is visible - good for large elements */
  onceHalf: { once: true, amount: 0.5 },
  /** Trigger every time element enters viewport - use sparingly */
  repeat: { once: false, amount: 0 }
};
var VARIANTS = {
  /** Simple fade in/out */
  fadeIn: {
    initial: { opacity: 0 },
    animate: { opacity: 1 },
    exit: { opacity: 0 }
  },
  /** Fade in with slide up from bottom */
  slideUp: {
    initial: { opacity: 0, y: DISTANCES.lg },
    animate: { opacity: 1, y: 0 },
    exit: { opacity: 0, y: -DISTANCES.lg }
  },
  /** Fade in with slide down from top */
  slideDown: {
    initial: { opacity: 0, y: -DISTANCES.lg },
    animate: { opacity: 1, y: 0 },
    exit: { opacity: 0, y: DISTANCES.lg }
  },
  /** Fade in with slide from left */
  slideLeft: {
    initial: { opacity: 0, x: DISTANCES.lg },
    animate: { opacity: 1, x: 0 },
    exit: { opacity: 0, x: -DISTANCES.lg }
  },
  /** Fade in with slide from right */
  slideRight: {
    initial: { opacity: 0, x: -DISTANCES.lg },
    animate: { opacity: 1, x: 0 },
    exit: { opacity: 0, x: DISTANCES.lg }
  },
  /** Subtle scale effect for cards/modals */
  scale: {
    initial: { opacity: 0, scale: 0.95 },
    animate: { opacity: 1, scale: 1 },
    exit: { opacity: 0, scale: 0.95 }
  },
  /** Dramatic scale up effect */
  scaleUp: {
    initial: { opacity: 0, scale: 0.8 },
    animate: { opacity: 1, scale: 1 },
    exit: { opacity: 0, scale: 1.1 }
  },
  /** Rotate in effect (for icons, decorative elements) */
  rotate: {
    initial: { opacity: 0, rotate: -90 },
    animate: { opacity: 1, rotate: 0 },
    exit: { opacity: 0, rotate: 90 }
  },
  /** Slide up with bounce (for emphasized content) */
  slideUpBounce: {
    initial: { opacity: 0, y: DISTANCES.lg },
    animate: { opacity: 1, y: 0 },
    exit: { opacity: 0, y: -DISTANCES.lg }
  },
  /** Card reveal with subtle scale and slide */
  cardReveal: {
    initial: { opacity: 0, y: DISTANCES.lg, scale: 0.95 },
    animate: { opacity: 1, y: 0, scale: 1 },
    exit: { opacity: 0, y: -DISTANCES.lg, scale: 0.95 }
  }
};
var STAGGER_CONTAINERS = {
  /** Fast stagger for small lists */
  fast: {
    hidden: { opacity: 0 },
    show: {
      opacity: 1,
      transition: {
        staggerChildren: STAGGER.fast
      }
    }
  },
  /** Normal stagger for medium lists */
  normal: {
    hidden: { opacity: 0 },
    show: {
      opacity: 1,
      transition: {
        staggerChildren: STAGGER.normal
      }
    }
  },
  /** Slow stagger for large sections */
  slow: {
    hidden: { opacity: 0 },
    show: {
      opacity: 1,
      transition: {
        staggerChildren: STAGGER.slow
      }
    }
  }
};
var STAGGER_ITEMS = {
  /** Fade up for staggered items */
  fadeUp: {
    hidden: { opacity: 0, y: DISTANCES.md },
    show: {
      opacity: 1,
      y: 0,
      transition: EASINGS.softSpring
    }
  },
  /** Fade in for staggered items */
  fade: {
    hidden: { opacity: 0 },
    show: {
      opacity: 1,
      transition: { duration: DURATIONS.normal }
    }
  },
  /** Scale in for staggered items */
  scale: {
    hidden: { opacity: 0, scale: 0.95 },
    show: {
      opacity: 1,
      scale: 1,
      transition: EASINGS.softSpring
    }
  }
};
function createTransition(duration = "normal", easing = "easeOut", delay = 0) {
  const easingValue = EASINGS[easing];
  if (typeof easingValue === "object" && "type" in easingValue) {
    return {
      ...easingValue,
      delay
    };
  }
  return {
    duration: DURATIONS[duration],
    ease: easingValue,
    delay
  };
}
function createSlideVariant(direction, distance = "lg") {
  const dist = DISTANCES[distance];
  const initial = {
    opacity: 0,
    ...direction === "up" && { y: dist },
    ...direction === "down" && { y: -dist },
    ...direction === "left" && { x: dist },
    ...direction === "right" && { x: -dist }
  };
  return {
    initial,
    animate: { opacity: 1, x: 0, y: 0 },
    exit: {
      opacity: 0,
      ...direction === "up" && { y: -dist },
      ...direction === "down" && { y: dist },
      ...direction === "left" && { x: -dist },
      ...direction === "right" && { x: dist }
    }
  };
}
function mergeVariants(...variants) {
  return variants.reduce(
    (acc, variant) => {
      return {
        initial: { ...acc.initial, ...variant.initial },
        animate: { ...acc.animate, ...variant.animate },
        exit: { ...acc.exit, ...variant.exit }
      };
    },
    {
      initial: {},
      animate: {},
      exit: {}
    }
  );
}
//# sourceMappingURL=motion-presets.js.map