@moontra/moonui 2.4.4 → 2.4.6

package/dist/index.js

@@ -10846,88 +10846,85 @@ var ScrollBar = t__namespace.forwardRef(({ className, orientation = "vertical",
   }
 ));
 ScrollBar.displayName = ScrollAreaScrollbar.displayName;
-var defaultVariants = {
-  up: {
-    hidden: { opacity: 0, y: 50 },
-    visible: { opacity: 1, y: 0 }
-  },
-  down: {
-    hidden: { opacity: 0, y: -50 },
-    visible: { opacity: 1, y: 0 }
-  },
-  left: {
-    hidden: { opacity: 0, x: 50 },
-    visible: { opacity: 1, x: 0 }
-  },
-  right: {
-    hidden: { opacity: 0, x: -50 },
-    visible: { opacity: 1, x: 0 }
-  },
-  fade: {
-    hidden: { opacity: 0 },
-    visible: { opacity: 1 }
-  },
-  scale: {
-    hidden: { opacity: 0, scale: 0.8 },
-    visible: { opacity: 1, scale: 1 }
-  },
-  blur: {
-    hidden: { opacity: 0, filter: "blur(10px)" },
-    visible: { opacity: 1, filter: "blur(0px)" }
-  }
+var createDefaultVariants = (direction, distance) => {
+  const baseVariants = {
+    up: {
+      hidden: { opacity: 0, y: distance },
+      visible: { opacity: 1, y: 0 }
+    },
+    down: {
+      hidden: { opacity: 0, y: -distance },
+      visible: { opacity: 1, y: 0 }
+    },
+    left: {
+      hidden: { opacity: 0, x: distance },
+      visible: { opacity: 1, x: 0 }
+    },
+    right: {
+      hidden: { opacity: 0, x: -distance },
+      visible: { opacity: 1, x: 0 }
+    },
+    fade: {
+      hidden: { opacity: 0 },
+      visible: { opacity: 1 }
+    },
+    scale: {
+      hidden: { opacity: 0, scale: 0.85 },
+      visible: { opacity: 1, scale: 1 }
+    },
+    blur: {
+      hidden: { opacity: 0, filter: "blur(10px)" },
+      visible: { opacity: 1, filter: "blur(0px)" }
+    }
+  };
+  return baseVariants[direction] || baseVariants.up;
+};
+var defaultTransition = {
+  duration: 0.5,
+  ease: [0.25, 0.46, 0.45, 0.94]
+  // Custom cubic-bezier for smooth motion
 };
 var ScrollReveal = t__namespace.forwardRef(
   ({
     children,
     direction = "up",
     delay = 0,
-    duration = 0.6,
+    duration = 0.5,
     distance = 50,
-    threshold = 0.1,
-    triggerOnce = true,
+    threshold = 0.3,
+    // Increased from 0.1 for better visibility
+    once = true,
+    triggerOnce,
+    // Backward compatibility
     stagger = 0,
     className,
     variants,
     animate: animate2 = true,
     style,
-    id
+    id,
+    viewport
   }, ref) => {
-    const controls = framerMotion.useAnimation();
-    const elementRef = t__namespace.useRef(null);
-    const isInView = framerMotion.useInView(elementRef, {
-      amount: threshold,
-      once: triggerOnce
-    });
-    const customVariants = t__namespace.useMemo(() => {
+    const shouldTriggerOnce = triggerOnce !== void 0 ? triggerOnce : once;
+    const animationVariants = t__namespace.useMemo(() => {
       if (variants)
         return variants;
-      const baseVariants = defaultVariants[direction] || defaultVariants.up;
-      return {
-        hidden: {
-          ...baseVariants.hidden,
-          ...direction === "up" && { y: distance },
-          ...direction === "down" && { y: -distance },
-          ...direction === "left" && { x: distance },
-          ...direction === "right" && { x: -distance }
-        },
-        visible: baseVariants.visible
-      };
+      return createDefaultVariants(direction, distance);
     }, [direction, distance, variants]);
-    t__namespace.useEffect(() => {
-      if (!animate2)
-        return;
-      if (isInView) {
-        controls.start("visible");
-      } else if (!triggerOnce) {
-        controls.start("hidden");
-      }
-    }, [isInView, controls, triggerOnce, animate2]);
-    t__namespace.useImperativeHandle(ref, () => elementRef.current);
+    const transition = t__namespace.useMemo(() => ({
+      ...defaultTransition,
+      duration,
+      delay: delay + stagger
+    }), [duration, delay, stagger]);
+    const viewportConfig = t__namespace.useMemo(() => ({
+      once: shouldTriggerOnce,
+      amount: threshold,
+      ...viewport
+    }), [shouldTriggerOnce, threshold, viewport]);
     if (!animate2) {
       return /* @__PURE__ */ jsxRuntime.jsx(
         "div",
         {
-          ref: elementRef,
+          ref,
           className,
           style,
           id,
@@ -10938,15 +10935,12 @@ var ScrollReveal = t__namespace.forwardRef(
     return /* @__PURE__ */ jsxRuntime.jsx(
       framerMotion.motion.div,
       {
-        ref: elementRef,
-        variants: customVariants,
+        ref,
         initial: "hidden",
-        animate: controls,
-        transition: {
-          duration,
-          delay: delay + stagger,
-          ease: "easeOut"
-        },
+        whileInView: "visible",
+        viewport: viewportConfig,
+        variants: animationVariants,
+        transition,
         className: cn(className),
         style,
         id,
@@ -10957,24 +10951,40 @@ var ScrollReveal = t__namespace.forwardRef(
 );
 ScrollReveal.displayName = "ScrollReveal";
 var ScrollRevealContainer = t__namespace.forwardRef(
-  ({ children, stagger = 0.1, className, style, id }, ref) => {
-    const containerRef = t__namespace.useRef(null);
-    const isInView = framerMotion.useInView(containerRef, { amount: 0.1, once: true });
-    t__namespace.useImperativeHandle(ref, () => containerRef.current);
+  ({
+    children,
+    stagger = 0.1,
+    className,
+    style,
+    id,
+    threshold = 0.3,
+    once = true,
+    triggerOnce,
+    viewport
+  }, ref) => {
+    const shouldTriggerOnce = triggerOnce !== void 0 ? triggerOnce : once;
+    const viewportConfig = t__namespace.useMemo(() => ({
+      once: shouldTriggerOnce,
+      amount: threshold,
+      ...viewport
+    }), [shouldTriggerOnce, threshold, viewport]);
+    const containerVariants = {
+      hidden: {},
+      visible: {
+        transition: {
+          staggerChildren: stagger,
+          delayChildren: 0
+        }
+      }
+    };
     return /* @__PURE__ */ jsxRuntime.jsx(
       framerMotion.motion.div,
       {
-        ref: containerRef,
+        ref,
         initial: "hidden",
-        animate: isInView ? "visible" : "hidden",
-        variants: {
-          hidden: {},
-          visible: {
-            transition: {
-              staggerChildren: stagger
-            }
-          }
-        },
+        whileInView: "visible",
+        viewport: viewportConfig,
+        variants: containerVariants,
         className: cn(className),
         style,
         id,
@@ -10988,37 +10998,28 @@ var ScrollRevealItem = t__namespace.forwardRef(
   ({
     children,
     direction = "up",
-    duration = 0.6,
+    duration = 0.5,
     distance = 50,
     className,
     variants,
     style,
     id
   }, ref) => {
-    const customVariants = t__namespace.useMemo(() => {
+    const animationVariants = t__namespace.useMemo(() => {
       if (variants)
         return variants;
-      const baseVariants = defaultVariants[direction] || defaultVariants.up;
-      return {
-        hidden: {
-          ...baseVariants.hidden,
-          ...direction === "up" && { y: distance },
-          ...direction === "down" && { y: -distance },
-          ...direction === "left" && { x: distance },
-          ...direction === "right" && { x: -distance }
-        },
-        visible: baseVariants.visible
-      };
+      return createDefaultVariants(direction, distance);
     }, [direction, distance, variants]);
+    const transition = t__namespace.useMemo(() => ({
+      ...defaultTransition,
+      duration
+    }), [duration]);
     return /* @__PURE__ */ jsxRuntime.jsx(
       framerMotion.motion.div,
       {
         ref,
-        variants: customVariants,
-        transition: {
-          duration,
-          ease: "easeOut"
-        },
+        variants: animationVariants,
+        transition,
         className: cn(className),
         style,
         id,