@bug-on/m3-expressive 1.2.5 → 1.2.7

package/dist/layout.mjs

@@ -1,7 +1,7 @@
 "use client";
 import { Slot } from '@radix-ui/react-slot';
 import { cva } from 'class-variance-authority';
-import { m, LazyMotion, domMax, useMotionValue, animate, useAnimationFrame, AnimatePresence, useReducedMotion } from 'motion/react';
+import { m, LazyMotion, domMax, useAnimationFrame, useMotionValue, animate, AnimatePresence, useReducedMotion } from 'motion/react';
 import * as React18 from 'react';
 import { createContext, useState, useCallback, useMemo, useEffect, useContext, createElement } from 'react';
 import { clsx } from 'clsx';
@@ -515,26 +515,46 @@ function generateWavyCircularPath(center, radius, amplitude, wavelength) {
     if (i === 0) d += `M ${xAt(t0).toFixed(2)} ${yAt(t0).toFixed(2)}`;
     d += ` C ${cp1x.toFixed(2)} ${cp1y.toFixed(2)}, ${cp2x.toFixed(2)} ${cp2y.toFixed(2)}, ${xAt(t1).toFixed(2)} ${yAt(t1).toFixed(2)}`;
   }
-  d += " Z";
-  return d;
+  return `${d} Z`;
 }
 function getSinePath(startX, endX, phase, wl, amp) {
   if (startX >= endX) return "";
-  let d = "";
-  const step = amp === 0 ? Math.max(10, endX - startX) : 1;
-  const yStart = Math.sin((startX + phase) / wl * 2 * Math.PI) * amp;
-  d += `M ${startX.toFixed(2)} ${yStart.toFixed(2)}`;
-  let nextX = Math.ceil(startX / step) * step;
-  if (nextX === startX) nextX += step;
-  while (nextX < endX) {
-    const y = Math.sin((nextX + phase) / wl * 2 * Math.PI) * amp;
-    d += ` L ${nextX.toFixed(2)} ${y.toFixed(2)}`;
-    nextX += step;
-  }
-  const yEnd = Math.sin((endX + phase) / wl * 2 * Math.PI) * amp;
-  d += ` L ${endX.toFixed(2)} ${yEnd.toFixed(2)}`;
+  if (amp <= 0.01) {
+    return `M ${startX.toFixed(2)} 0 L ${endX.toFixed(2)} 0`;
+  }
+  const safeWl = Math.max(1, wl);
+  const k = 2 * Math.PI / safeWl;
+  const phi = phase / safeWl * 2 * Math.PI;
+  const yAt = (x) => amp * Math.sin(k * x + phi);
+  const dyAt = (x) => amp * k * Math.cos(k * x + phi);
+  const step = safeWl / 4;
+  let d = `M ${startX.toFixed(2)} ${yAt(startX).toFixed(2)}`;
+  let currentX = startX;
+  while (currentX < endX) {
+    const nextX = Math.min(endX, currentX + step);
+    const dx = nextX - currentX;
+    const scale = dx / 3;
+    const y0 = yAt(currentX);
+    const dy0 = dyAt(currentX);
+    const y1 = yAt(nextX);
+    const dy1 = dyAt(nextX);
+    const cp1x = currentX + scale;
+    const cp1y = y0 + scale * dy0;
+    const cp2x = nextX - scale;
+    const cp2y = y1 - scale * dy1;
+    d += ` C ${cp1x.toFixed(2)} ${cp1y.toFixed(2)}, ${cp2x.toFixed(2)} ${cp2y.toFixed(2)}, ${nextX.toFixed(2)} ${y1.toFixed(2)}`;
+    currentX = nextX;
+  }
   return d;
 }
+var GLOBAL_ROTATION_DURATION = 6e3;
+var GLOBAL_ROTATION_TARGET = 1080;
+var ADDITIONAL_ROTATION_CYCLE = 1500;
+var ADDITIONAL_ROTATION_STEP = 90;
+var ADDITIONAL_ROTATION_EASE_DURATION = 500;
+var DEFAULT_MIN_PROGRESS = 0.1;
+var DEFAULT_MAX_PROGRESS = 0.8;
+var PROGRESS_CYCLE_DURATION = 1500;
 var CircularProgress = React18.forwardRef(
   (_a, ref) => {
     var _b = _a, {
@@ -548,6 +568,10 @@ var CircularProgress = React18.forwardRef(
       crawlerSpeed = 1,
       color,
       trackColor,
+      showTrack = "auto",
+      minProgress = DEFAULT_MIN_PROGRESS,
+      maxProgress = DEFAULT_MAX_PROGRESS,
+      amplitudeRange,
       className,
       "aria-label": ariaLabel
     } = _b, restProps = __objRest(_b, [
@@ -561,6 +585,10 @@ var CircularProgress = React18.forwardRef(
       "crawlerSpeed",
       "color",
       "trackColor",
+      "showTrack",
+      "minProgress",
+      "maxProgress",
+      "amplitudeRange",
       "className",
       "aria-label"
     ]);
@@ -571,6 +599,7 @@ var CircularProgress = React18.forwardRef(
     const activeColor = color || "var(--md-sys-color-indicator-active)";
     const bgTrackColor = trackColor || "var(--md-sys-color-indicator-track)";
     const isWavy = shape === "wavy";
+    const shouldShowIndeterminateTrack = showTrack === "auto" ? isWavy : showTrack;
     const BASELINE_SIZE = 48;
     const scaleFactor = size / BASELINE_SIZE;
     const effectiveAmplitude = React18.useMemo(
@@ -581,6 +610,10 @@ var CircularProgress = React18.forwardRef(
       () => wavelength != null ? wavelength : 15 * scaleFactor,
       [wavelength, scaleFactor]
     );
+    const resolvedAmplitudeRange = React18.useMemo(
+      () => amplitudeRange != null ? amplitudeRange : [0, effectiveAmplitude],
+      [amplitudeRange, effectiveAmplitude]
+    );
     const wavyActivePath = React18.useMemo(
       () => isWavy ? generateWavyCircularPath(
         center,
@@ -600,6 +633,145 @@ var CircularProgress = React18.forwardRef(
     const trackLength = isDeterminate ? Math.max(1e-3, 1 - activeAngularFraction - 2 * gapForTrack) : 1;
     const ActiveCircleElem = m.circle;
     const ActivePathElem = m.path;
+    const indeterminateSvgRef = React18.useRef(null);
+    const indeterminateTrackRef = React18.useRef(null);
+    const indeterminateActiveRef = React18.useRef(null);
+    const indeterminateWavyTrackPathRef = React18.useRef(null);
+    const indeterminateWavyActivePathRef = React18.useRef(null);
+    const cachedPathLengthRef = React18.useRef(0);
+    React18.useLayoutEffect(() => {
+      if (!isWavy || !wavyActivePath) {
+        cachedPathLengthRef.current = circumference;
+        return;
+      }
+      const el = indeterminateActiveRef.current;
+      if (el && "getTotalLength" in el) {
+        try {
+          const len = el.getTotalLength();
+          if (len > 0) {
+            cachedPathLengthRef.current = len;
+            return;
+          }
+        } catch (e) {
+        }
+      }
+      cachedPathLengthRef.current = circumference;
+    }, [isWavy, circumference, wavyActivePath]);
+    useAnimationFrame((time) => {
+      if (isDeterminate) return;
+      const safeCrawlerSpeed = Math.max(0.1, crawlerSpeed);
+      const scaledTime = time * safeCrawlerSpeed;
+      const globalCycle = scaledTime % GLOBAL_ROTATION_DURATION;
+      const globalAngle = globalCycle / GLOBAL_ROTATION_DURATION * GLOBAL_ROTATION_TARGET;
+      const additionalFullCycles = Math.floor(
+        scaledTime / ADDITIONAL_ROTATION_CYCLE
+      );
+      const additionalCycleTime = scaledTime % ADDITIONAL_ROTATION_CYCLE;
+      const additionalEaseT = Math.min(
+        1,
+        additionalCycleTime / ADDITIONAL_ROTATION_EASE_DURATION
+      );
+      const additionalAngle = (additionalFullCycles + easeInOutCubic(additionalEaseT)) * ADDITIONAL_ROTATION_STEP;
+      const totalRotation = globalAngle + additionalAngle;
+      if (indeterminateSvgRef.current) {
+        indeterminateSvgRef.current.style.transform = `rotate(${totalRotation - 90}deg)`;
+      }
+      const progressFullCycle = PROGRESS_CYCLE_DURATION * 2;
+      const progressCycleTime = scaledTime % progressFullCycle;
+      let progress;
+      if (progressCycleTime < PROGRESS_CYCLE_DURATION) {
+        const t = progressCycleTime / PROGRESS_CYCLE_DURATION;
+        progress = minProgress + (maxProgress - minProgress) * easeInOutCubic(t);
+      } else {
+        const t = (progressCycleTime - PROGRESS_CYCLE_DURATION) / PROGRESS_CYCLE_DURATION;
+        progress = maxProgress - (maxProgress - minProgress) * easeInOutCubic(t);
+      }
+      if (isWavy) {
+        const amplitudeT = (progress - minProgress) / (maxProgress - minProgress);
+        const currentAmplitude = resolvedAmplitudeRange[0] + (resolvedAmplitudeRange[1] - resolvedAmplitudeRange[0]) * amplitudeT;
+        const dynamicPath = generateWavyCircularPath(
+          center,
+          radius,
+          currentAmplitude,
+          effectiveWavelength
+        );
+        if (indeterminateWavyActivePathRef.current) {
+          indeterminateWavyActivePathRef.current.setAttribute("d", dynamicPath);
+        }
+        if (indeterminateWavyTrackPathRef.current) {
+          indeterminateWavyTrackPathRef.current.setAttribute("d", dynamicPath);
+        }
+        const pathEl = indeterminateWavyActivePathRef.current;
+        let totalLen = cachedPathLengthRef.current || circumference;
+        if (pathEl) {
+          try {
+            const len = pathEl.getTotalLength();
+            if (len > 0) totalLen = len;
+          } catch (e) {
+          }
+        }
+        const gapFrac = (gapSize + trackHeight) / totalLen;
+        const activeLen = totalLen * progress;
+        const activeOff = 0;
+        if (indeterminateWavyActivePathRef.current) {
+          indeterminateWavyActivePathRef.current.setAttribute(
+            "stroke-dasharray",
+            `${activeLen} ${totalLen}`
+          );
+          indeterminateWavyActivePathRef.current.setAttribute(
+            "stroke-dashoffset",
+            `${activeOff}`
+          );
+        }
+        if (shouldShowIndeterminateTrack && indeterminateWavyTrackPathRef.current) {
+          const trackStartFrac = progress + gapFrac;
+          const trackLen = Math.max(
+            1e-3,
+            totalLen * (1 - progress - 2 * gapFrac)
+          );
+          const trackOff = -totalLen * trackStartFrac;
+          indeterminateWavyTrackPathRef.current.setAttribute(
+            "stroke-dasharray",
+            `${trackLen} ${totalLen}`
+          );
+          indeterminateWavyTrackPathRef.current.setAttribute(
+            "stroke-dashoffset",
+            `${trackOff}`
+          );
+        }
+      } else {
+        const totalLen = circumference;
+        const activeLen = totalLen * progress;
+        const activeOff = 0;
+        if (indeterminateActiveRef.current) {
+          indeterminateActiveRef.current.setAttribute(
+            "stroke-dasharray",
+            `${activeLen} ${totalLen}`
+          );
+          indeterminateActiveRef.current.setAttribute(
+            "stroke-dashoffset",
+            `${activeOff}`
+          );
+        }
+        if (shouldShowIndeterminateTrack && indeterminateTrackRef.current) {
+          const gapFrac = (gapSize + trackHeight) / totalLen;
+          const trackStartFrac = progress + gapFrac;
+          const trackLen = Math.max(
+            1e-3,
+            totalLen * (1 - progress - 2 * gapFrac)
+          );
+          const trackOff = -totalLen * trackStartFrac;
+          indeterminateTrackRef.current.setAttribute(
+            "stroke-dasharray",
+            `${trackLen} ${totalLen}`
+          );
+          indeterminateTrackRef.current.setAttribute(
+            "stroke-dashoffset",
+            `${trackOff}`
+          );
+        }
+      }
+    });
     return /* @__PURE__ */ jsx(
       "div",
       __spreadProps(__spreadValues({
@@ -676,9 +848,10 @@ var CircularProgress = React18.forwardRef(
               ]
             }
           ),
-          !isDeterminate && /* @__PURE__ */ jsxs(
-            m.svg,
+          !isDeterminate && /* @__PURE__ */ jsx(
+            "svg",
             {
+              ref: indeterminateSvgRef,
               width: size,
               height: size,
               viewBox: `0 0 ${size} ${size}`,
@@ -687,90 +860,60 @@ var CircularProgress = React18.forwardRef(
                 position: "absolute",
                 inset: 0,
                 overflow: "visible",
-                rotate: "-90deg",
-                transformOrigin: "center"
+                transformOrigin: "center",
+                transform: "rotate(-90deg)"
               },
-              animate: { rotate: ["-90deg", "270deg"] },
-              transition: {
-                rotate: {
-                  duration: 2 / Math.max(0.1, crawlerSpeed),
-                  repeat: Number.POSITIVE_INFINITY,
-                  ease: "linear"
-                }
-              },
-              children: [
-                /* @__PURE__ */ jsx(
-                  m.circle,
+              children: isWavy ? /* @__PURE__ */ jsxs(Fragment, { children: [
+                shouldShowIndeterminateTrack && /* @__PURE__ */ jsx(
+                  "path",
                   {
-                    cx: center,
-                    cy: center,
-                    r: radius,
+                    ref: indeterminateWavyTrackPathRef,
+                    d: wavyActivePath != null ? wavyActivePath : "",
                     fill: "none",
                     stroke: bgTrackColor,
                     strokeWidth: trackHeight,
-                    strokeLinecap: "round",
-                    style: { originX: "50%", originY: "50%" },
-                    animate: {
-                      pathLength: [
-                        Math.max(1e-3, 1 - 0.1 - 2 * gapForTrack),
-                        Math.max(1e-3, 1 - 0.75 - 2 * gapForTrack),
-                        Math.max(1e-3, 1 - 0.1 - 2 * gapForTrack)
-                      ],
-                      rotate: [
-                        `${(0.1 + gapForTrack) * 360}deg`,
-                        `${(1 + gapForTrack) * 360}deg`,
-                        `${(1.1 + gapForTrack) * 360}deg`
-                      ]
-                    },
-                    transition: {
-                      duration: 2 / Math.max(0.1, crawlerSpeed),
-                      repeat: Number.POSITIVE_INFINITY,
-                      ease: [0.4, 0, 0.2, 1]
-                    }
+                    strokeLinecap: "round"
                   }
                 ),
-                isWavy ? /* @__PURE__ */ jsx(
-                  ActivePathElem,
+                /* @__PURE__ */ jsx(
+                  "path",
                   {
+                    ref: indeterminateWavyActivePathRef,
                     d: wavyActivePath != null ? wavyActivePath : "",
                     fill: "none",
                     stroke: activeColor,
                     strokeWidth: trackHeight,
-                    strokeLinecap: "round",
-                    style: { originX: "50%", originY: "50%" },
-                    animate: {
-                      pathLength: [0.1, 0.75, 0.1],
-                      rotate: ["0deg", "90deg", "360deg"]
-                    },
-                    transition: {
-                      duration: 2 / Math.max(0.1, crawlerSpeed),
-                      repeat: Number.POSITIVE_INFINITY,
-                      ease: [0.4, 0, 0.2, 1]
-                    }
+                    strokeLinecap: "round"
                   }
-                ) : /* @__PURE__ */ jsx(
-                  ActiveCircleElem,
+                )
+              ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+                shouldShowIndeterminateTrack && /* @__PURE__ */ jsx(
+                  "circle",
+                  {
+                    ref: indeterminateTrackRef,
+                    cx: center,
+                    cy: center,
+                    r: radius,
+                    fill: "none",
+                    stroke: bgTrackColor,
+                    strokeWidth: trackHeight,
+                    strokeLinecap: "round"
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  "circle",
                   {
+                    ref: indeterminateActiveRef,
                     cx: center,
                     cy: center,
                     r: radius,
                     fill: "none",
                     stroke: activeColor,
                     strokeWidth: trackHeight,
-                    strokeLinecap: "round",
-                    style: { originX: "50%", originY: "50%" },
-                    animate: {
-                      pathLength: [0.1, 0.75, 0.1],
-                      rotate: ["0deg", "90deg", "360deg"]
-                    },
-                    transition: {
-                      duration: 2 / Math.max(0.1, crawlerSpeed),
-                      repeat: Number.POSITIVE_INFINITY,
-                      ease: [0.4, 0, 0.2, 1]
-                    }
+                    strokeLinecap: "round"
                   }
                 )
-              ]
+              ] })
             }
           )
         ] })
@@ -934,6 +1077,12 @@ var WavyLinearTrack = React18.memo(function WavyLinearTrack2({
         duration: 0.5
       });
       animate(fractionMV, fraction, { duration: 0.4, ease: [0.2, 0, 0, 1] });
+    } else {
+      animate(amplitudeMV, amplitude, {
+        type: "spring",
+        bounce: 0,
+        duration: 0.5
+      });
     }
   }, [
     clampedValue,
@@ -947,10 +1096,10 @@ var WavyLinearTrack = React18.memo(function WavyLinearTrack2({
     1,
     isDeterminate ? wavelength : indeterminateWavelength
   );
-  const trackAmp = trackShape === "wavy" ? amplitude : 0;
   useAnimationFrame((time) => {
     if (width === 0) return;
     const currentAmp = amplitudeMV.get();
+    const trackAmp = trackShape === "wavy" ? amplitude : 0;
     const phase = time / 1e3 * waveSpeed * activeWavelength;
     const capWidth = trackHeight / 2;
     let activePathD = "";
@@ -970,7 +1119,7 @@ var WavyLinearTrack = React18.memo(function WavyLinearTrack2({
           currentAmp
         );
       } else if (fraction === 0) {
-        activePathD = `M ${capWidth} 0 L ${capWidth + 0.01} 0`;
+        activePathD = "";
       }
       const trackStart = adjHead + totalGap;
       if (trackStart < width - capWidth) {
@@ -1002,20 +1151,20 @@ var WavyLinearTrack = React18.memo(function WavyLinearTrack2({
         activeLines.push({ tail: l1T, head: l1H });
         activeLines.push({ tail: l2T, head: l2H });
       }
-      const segments = activeLines.map((line) => {
-        const barTail = line.tail * width;
-        const barHead = line.head * width;
+      const activeSegments = activeLines.map((line) => {
+        const rawTail = line.tail * width;
+        const rawHead = line.head * width;
         const adjTail = Math.max(
           capWidth,
-          Math.min(width - capWidth, barTail)
+          Math.min(width - capWidth, rawTail)
         );
         const adjHead = Math.max(
           capWidth,
-          Math.min(width - capWidth, barHead)
+          Math.min(width - capWidth, rawHead)
         );
         return { adjTail, adjHead };
       }).filter((seg) => seg.adjHead - seg.adjTail > 0.1);
-      activePathD = segments.map(
+      activePathD = activeSegments.map(
         (seg) => getSinePath(
           seg.adjTail,
           seg.adjHead,
@@ -1024,13 +1173,24 @@ var WavyLinearTrack = React18.memo(function WavyLinearTrack2({
           currentAmp
         )
       ).join(" ");
+      const validActiveLines = activeLines.filter(
+        (line) => line.head > line.tail && line.head * width > 0 && line.tail * width < width
+      ).sort((a, b) => a.tail - b.tail);
       let currentTrackX = capWidth;
-      for (const seg of segments) {
-        const trackEnd = seg.adjTail - totalGap;
+      for (const line of validActiveLines) {
+        const blockStart = line.tail * width - totalGap;
+        const blockEnd = line.head * width + totalGap;
+        const trackEnd = Math.min(width - capWidth, blockStart);
         if (trackEnd > currentTrackX) {
-          trackD += `${getSinePath(currentTrackX, trackEnd, phase, activeWavelength, trackAmp)} `;
+          trackD += `${getSinePath(
+            currentTrackX,
+            trackEnd,
+            phase,
+            activeWavelength,
+            trackAmp
+          )} `;
         }
-        currentTrackX = Math.max(currentTrackX, seg.adjHead + totalGap);
+        currentTrackX = Math.max(currentTrackX, blockEnd);
       }
       if (currentTrackX < width - capWidth) {
         trackD += getSinePath(
@@ -1043,15 +1203,15 @@ var WavyLinearTrack = React18.memo(function WavyLinearTrack2({
       }
     }
     if (activePathRef.current)
-      activePathRef.current.setAttribute("d", activePathD);
+      activePathRef.current.setAttribute("d", activePathD || "");
     if (trackPathRef.current)
-      trackPathRef.current.setAttribute("d", trackD.trim());
+      trackPathRef.current.setAttribute("d", trackD.trim() || "");
   });
   return /* @__PURE__ */ jsx(
     "div",
     {
       ref: containerRef,
-      className: "relative w-full overflow-hidden",
+      className: "relative w-full",
       style: { height: svgHeight },
       children: width > 0 && /* @__PURE__ */ jsxs(
         "svg",
@@ -1105,7 +1265,7 @@ var LinearProgress = React18.forwardRef(
       waveSpeed = 1,
       crawlerSpeed = 1,
       determinateAnimation = "md3",
-      indeterminateAnimation = "continuous",
+      indeterminateAnimation = "md3",
       gapSize = 4,
       showStopIndicator = "auto",
       color,
@@ -1142,15 +1302,15 @@ var LinearProgress = React18.forwardRef(
         setIsRtl(dir === "rtl");
       }
     }, []);
-    const isWavy = shape === "wavy";
     const resolvedTrackShape = trackShape != null ? trackShape : shape;
+    const isWavy = shape === "wavy" || resolvedTrackShape === "wavy";
     const effectiveAmplitude = React18.useMemo(() => amplitude != null ? amplitude : 3, [amplitude]);
     const svgHeight = React18.useMemo(
       () => isWavy ? trackHeight + effectiveAmplitude * 2 : trackHeight,
       [isWavy, trackHeight, effectiveAmplitude]
     );
     const shouldShowStop = React18.useMemo(
-      () => isDeterminate && resolvedTrackShape === "flat" && (showStopIndicator === true || showStopIndicator === "auto" && isDeterminate),
+      () => isDeterminate && resolvedTrackShape === "flat" && showStopIndicator !== false,
       [isDeterminate, resolvedTrackShape, showStopIndicator]
     );
     const stopSize = React18.useMemo(
@@ -1160,6 +1320,8 @@ var LinearProgress = React18.forwardRef(
     const stopOffset = (trackHeight - stopSize) / 2;
     const activeColor = color || "var(--md-sys-color-indicator-active)";
     const bgTrackColor = trackColor || "var(--md-sys-color-indicator-track)";
+    const useWavyTrack = isWavy || !isDeterminate;
+    const trackAmp = isWavy ? effectiveAmplitude : 0;
     return /* @__PURE__ */ jsx(LazyMotion, { features: domMax, strict: true, children: /* @__PURE__ */ jsxs(
       "div",
       __spreadProps(__spreadValues({
@@ -1176,12 +1338,12 @@ var LinearProgress = React18.forwardRef(
         style: { height: svgHeight }
       }, restProps), {
         children: [
-          isWavy ? /* @__PURE__ */ jsx(
+          useWavyTrack ? /* @__PURE__ */ jsx(
             WavyLinearTrack,
             {
               trackHeight,
               svgHeight,
-              amplitude: effectiveAmplitude,
+              amplitude: trackAmp,
               wavelength,
               indeterminateWavelength,
               activeColor,