@vadimcomanescu/nadicode-design-system 2.0.0

package/dist/chunk-EB5PYS7Q.js

@@ -0,0 +1,57 @@
+import { useIsInView } from './chunk-4O6L5YWT.js';
+import { m } from './chunk-PD2YEH3H.js';
+import { bezier } from './chunk-CRY67BIF.js';
+import { cn } from './chunk-QYZT24TS.js';
+import { useReducedMotion } from 'motion/react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+function HighlightText({
+  ref,
+  children,
+  className,
+  color = "var(--color-accent)",
+  duration = 0.6,
+  delay = 0,
+  inView = true,
+  inViewOnce = true,
+  inViewMargin = "0px",
+  ...props
+}) {
+  const prefersReduced = useReducedMotion();
+  const { ref: localRef, isInView } = useIsInView(
+    ref,
+    { inView, inViewOnce, inViewMargin }
+  );
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      ref: localRef,
+      className: cn("relative inline-block", className),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx(
+          m.span,
+          {
+            className: "absolute inset-0 -mx-1.5 rounded-sm",
+            style: {
+              backgroundColor: color,
+              opacity: 0.15,
+              transformOrigin: "left center"
+            },
+            initial: { scaleX: prefersReduced ? 1 : 0 },
+            animate: isInView ? { scaleX: 1 } : { scaleX: 0 },
+            transition: {
+              duration: prefersReduced ? 0 : duration,
+              delay,
+              ease: bezier["ease"]
+            },
+            "aria-hidden": "true"
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { className: "relative", children })
+      ]
+    }
+  );
+}
+
+export { HighlightText };

package/dist/chunk-ELKIUARM.js

@@ -0,0 +1,32 @@
+import { useAnimatedIcon } from './chunk-ASKFAYYR.js';
+import { cn } from './chunk-QYZT24TS.js';
+import { useAnimation, motion } from 'motion/react';
+import { jsx } from 'react/jsx-runtime';
+
+var PATH_VARIANTS = {
+  normal: { pathLength: 1, opacity: 1 },
+  animate: {
+    pathLength: [0, 1],
+    opacity: [0, 1],
+    transition: { duration: 0.6, ease: "linear", opacity: { duration: 0.1 } }
+  }
+};
+function StarIcon({
+  onMouseEnter,
+  onMouseLeave,
+  className,
+  size = 28,
+  ref,
+  ...props
+}) {
+  const controls = useAnimation();
+  const { handleMouseEnter, handleMouseLeave } = useAnimatedIcon(ref, {
+    onMouseEnter,
+    onMouseLeave,
+    animate: () => controls.start("animate"),
+    reset: () => controls.start("normal")
+  });
+  return /* @__PURE__ */ jsx("div", { className: cn(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, ...props, children: /* @__PURE__ */ jsx("svg", { fill: "none", height: size, stroke: "currentColor", strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: "2", viewBox: "0 0 24 24", width: size, xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ jsx(motion.path, { animate: controls, d: "M11.525 2.295a.53.53 0 0 1 .95 0l2.31 4.679a2.123 2.123 0 0 0 1.595 1.16l5.166.756a.53.53 0 0 1 .294.904l-3.736 3.638a2.123 2.123 0 0 0-.611 1.878l.882 5.14a.53.53 0 0 1-.771.56l-4.618-2.428a2.122 2.122 0 0 0-1.973 0L6.396 21.01a.53.53 0 0 1-.77-.56l.881-5.139a2.122 2.122 0 0 0-.611-1.879L2.16 9.795a.53.53 0 0 1 .294-.906l5.165-.755a2.122 2.122 0 0 0 1.597-1.16z", initial: "normal", variants: PATH_VARIANTS }) }) });
+}
+
+export { StarIcon };

package/dist/chunk-EV2V5RWT.js

@@ -0,0 +1,432 @@
+import { useMotionConfig, m, motionSpring } from './chunk-PD2YEH3H.js';
+import { cn } from './chunk-QYZT24TS.js';
+import * as React from 'react';
+import { useMotionValue, useSpring, useTransform } from 'motion/react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+var TRACK_HEIGHT = 52;
+var TRACK_RADIUS = 12;
+var HANDLE_SIZE = 18;
+var HANDLE_MIN_LEFT = 10;
+var DWELL_MS = 800;
+var HASH_COUNT = 8;
+var RUBBER_BAND_DEADZONE = 10;
+var RUBBER_BAND_FACTOR = 0.15;
+var SPRING_SNAP = { stiffness: 400, damping: 30, mass: 0.8 };
+var SPRING_RUBBER = { stiffness: 300, damping: 25, mass: 0.5 };
+function clampNum(v, lo, hi) {
+  return Math.min(Math.max(v, lo), hi);
+}
+function quantize(v, step, min, max) {
+  const steps = Math.round((v - min) / step);
+  return clampNum(min + steps * step, min, max);
+}
+function snapToDecile(ratio) {
+  return Math.round(ratio * 10) / 10;
+}
+function defaultFormat(value, min, max) {
+  const range = max - min;
+  if (range <= 1) {
+    return value.toFixed(2);
+  }
+  if (Number.isInteger(value)) {
+    return String(value);
+  }
+  return value.toFixed(1);
+}
+function FillBar({
+  fillSpring,
+  radius
+}) {
+  const width = useTransform(
+    fillSpring,
+    (v) => `${clampNum(v * 100, 0, 100)}%`
+  );
+  return /* @__PURE__ */ jsx(
+    m.div,
+    {
+      className: "absolute top-0 left-0 h-full",
+      style: {
+        width,
+        borderRadius: radius,
+        background: "rgb(var(--color-slider-fill))"
+      }
+    }
+  );
+}
+function Slider({
+  label,
+  value: controlledValue,
+  defaultValue = 0.5,
+  min = 0,
+  max = 1,
+  step = 0.01,
+  onChange,
+  onChangeEnd,
+  disabled = false,
+  formatValue,
+  className,
+  showHashMarks = true,
+  snapToDeciles = true,
+  rubberBand = true,
+  ref
+}) {
+  const motionConfig = useMotionConfig();
+  const isControlled = controlledValue !== void 0;
+  const [internalValue, setInternalValue] = React.useState(defaultValue);
+  const currentValue = isControlled ? controlledValue : internalValue;
+  const trackRef = React.useRef(null);
+  const isDragging = React.useRef(false);
+  const isClick = React.useRef(true);
+  const pointerStartX = React.useRef(0);
+  const dwellTimer = React.useRef(null);
+  const [isHovered, setIsHovered] = React.useState(false);
+  const [isActive, setIsActive] = React.useState(false);
+  const [isEditing, setIsEditing] = React.useState(false);
+  const [editText, setEditText] = React.useState("");
+  const inputRef = React.useRef(null);
+  const ratio = max === min ? 0 : (currentValue - min) / (max - min);
+  const fillMotion = useMotionValue(ratio);
+  const fillSpring = useSpring(fillMotion, SPRING_SNAP);
+  const rubberBandX = useMotionValue(0);
+  const rubberBandSpring = useSpring(rubberBandX, SPRING_RUBBER);
+  const rubberBandScale = useTransform(
+    rubberBandSpring,
+    [-40, 0, 40],
+    [1.02, 1, 1.02]
+  );
+  React.useEffect(() => {
+    if (!isDragging.current) {
+      fillMotion.set(ratio);
+    }
+  }, [ratio, fillMotion]);
+  const setValue = React.useCallback(
+    (newValue) => {
+      const quantized = quantize(newValue, step, min, max);
+      if (!isControlled) {
+        setInternalValue(quantized);
+      }
+      onChange?.(quantized);
+    },
+    [step, min, max, isControlled, onChange]
+  );
+  const getValueFromPointer = React.useCallback(
+    (clientX) => {
+      const track = trackRef.current;
+      if (!track) return { value: min, ratio: 0, overflow: 0 };
+      const rect = track.getBoundingClientRect();
+      const rawRatio = (clientX - rect.left) / rect.width;
+      const overflow = rawRatio < 0 ? rawRatio * rect.width : rawRatio > 1 ? (rawRatio - 1) * rect.width : 0;
+      const clamped = clampNum(rawRatio, 0, 1);
+      const rawValue = min + clamped * (max - min);
+      return { value: rawValue, ratio: clamped, overflow };
+    },
+    [min, max]
+  );
+  const handlePointerDown = React.useCallback(
+    (e) => {
+      if (disabled) return;
+      e.preventDefault();
+      const target = e.currentTarget;
+      target.setPointerCapture(e.pointerId);
+      isDragging.current = false;
+      isClick.current = true;
+      pointerStartX.current = e.clientX;
+      const { value: newValue, ratio: rawRatio } = getValueFromPointer(e.clientX);
+      dwellTimer.current = setTimeout(() => {
+        if (isClick.current) {
+          setIsEditing(true);
+          setEditText(
+            formatValue ? formatValue(currentValue) : defaultFormat(currentValue, min, max)
+          );
+        }
+      }, DWELL_MS);
+      setIsActive(true);
+      if (snapToDeciles) {
+        const snappedRatio = snapToDecile(rawRatio);
+        const snappedValue = min + snappedRatio * (max - min);
+        fillMotion.set(snappedRatio);
+        setValue(snappedValue);
+      } else {
+        fillMotion.set((newValue - min) / (max - min));
+        setValue(newValue);
+      }
+    },
+    [
+      disabled,
+      getValueFromPointer,
+      setValue,
+      snapToDeciles,
+      min,
+      max,
+      fillMotion,
+      formatValue,
+      currentValue
+    ]
+  );
+  const handlePointerMove = React.useCallback(
+    (e) => {
+      if (!isActive || disabled) return;
+      const dx = Math.abs(e.clientX - pointerStartX.current);
+      if (dx > 3) {
+        isDragging.current = true;
+        isClick.current = false;
+        if (dwellTimer.current) {
+          clearTimeout(dwellTimer.current);
+          dwellTimer.current = null;
+        }
+      }
+      if (isDragging.current) {
+        const { value: newValue, ratio: newRatio, overflow } = getValueFromPointer(e.clientX);
+        if (rubberBand && Math.abs(overflow) > RUBBER_BAND_DEADZONE) {
+          const sign = overflow > 0 ? 1 : -1;
+          const excess = Math.abs(overflow) - RUBBER_BAND_DEADZONE;
+          const damped = Math.log1p(excess * RUBBER_BAND_FACTOR) * 20;
+          rubberBandX.set(sign * damped);
+        } else {
+          rubberBandX.set(0);
+        }
+        fillMotion.set(newRatio);
+        setValue(newValue);
+      }
+    },
+    [
+      isActive,
+      disabled,
+      getValueFromPointer,
+      rubberBand,
+      rubberBandX,
+      fillMotion,
+      setValue
+    ]
+  );
+  const handlePointerUp = React.useCallback(
+    (e) => {
+      if (disabled) return;
+      e.currentTarget.releasePointerCapture(e.pointerId);
+      if (dwellTimer.current) {
+        clearTimeout(dwellTimer.current);
+        dwellTimer.current = null;
+      }
+      rubberBandX.set(0);
+      if (isClick.current && snapToDeciles) {
+        const { ratio: rawRatio } = getValueFromPointer(e.clientX);
+        const snappedRatio = snapToDecile(rawRatio);
+        const snappedValue = min + snappedRatio * (max - min);
+        const quantized = quantize(snappedValue, step, min, max);
+        fillMotion.set(snappedRatio);
+        setValue(quantized);
+        onChangeEnd?.(quantized);
+      } else {
+        onChangeEnd?.(currentValue);
+      }
+      isDragging.current = false;
+      isClick.current = true;
+      setIsActive(false);
+    },
+    [
+      disabled,
+      rubberBandX,
+      snapToDeciles,
+      getValueFromPointer,
+      min,
+      max,
+      step,
+      fillMotion,
+      setValue,
+      onChangeEnd,
+      currentValue
+    ]
+  );
+  const handleKeyDown = React.useCallback(
+    (e) => {
+      if (disabled) return;
+      let newValue = currentValue;
+      switch (e.key) {
+        case "ArrowRight":
+        case "ArrowUp":
+          e.preventDefault();
+          newValue = clampNum(currentValue + step, min, max);
+          break;
+        case "ArrowLeft":
+        case "ArrowDown":
+          e.preventDefault();
+          newValue = clampNum(currentValue - step, min, max);
+          break;
+        case "Home":
+          e.preventDefault();
+          newValue = min;
+          break;
+        case "End":
+          e.preventDefault();
+          newValue = max;
+          break;
+        default:
+          return;
+      }
+      fillMotion.set((newValue - min) / (max - min));
+      setValue(newValue);
+      onChangeEnd?.(newValue);
+    },
+    [disabled, currentValue, step, min, max, fillMotion, setValue, onChangeEnd]
+  );
+  const commitEdit = React.useCallback(() => {
+    setIsEditing(false);
+    const parsed = parseFloat(editText);
+    if (!isNaN(parsed)) {
+      const clamped = clampNum(parsed, min, max);
+      const quantized = quantize(clamped, step, min, max);
+      fillMotion.set((quantized - min) / (max - min));
+      setValue(quantized);
+      onChangeEnd?.(quantized);
+    }
+  }, [editText, min, max, step, fillMotion, setValue, onChangeEnd]);
+  const handleEditKeyDown = React.useCallback(
+    (e) => {
+      if (e.key === "Enter") {
+        commitEdit();
+      } else if (e.key === "Escape") {
+        setIsEditing(false);
+      }
+    },
+    [commitEdit]
+  );
+  React.useEffect(() => {
+    if (isEditing && inputRef.current) {
+      inputRef.current.focus();
+      inputRef.current.select();
+    }
+  }, [isEditing]);
+  const handleLeftExpr = `clamp(${HANDLE_MIN_LEFT}px, calc(${ratio * 100}% - ${HANDLE_SIZE / 2}px), calc(100% - ${HANDLE_SIZE + 4}px))`;
+  const handleCenterPercent = ratio * 100;
+  const labelDodge = handleCenterPercent < 25;
+  const valueDodge = handleCenterPercent > 75;
+  const formattedValue = formatValue ? formatValue(currentValue) : defaultFormat(currentValue, min, max);
+  const interacting = isHovered || isActive;
+  return /* @__PURE__ */ jsx(
+    m.div,
+    {
+      ref,
+      role: "slider",
+      "aria-valuemin": min,
+      "aria-valuemax": max,
+      "aria-valuenow": currentValue,
+      "aria-label": label,
+      "aria-disabled": disabled || void 0,
+      tabIndex: disabled ? -1 : 0,
+      className: cn(
+        "relative w-full select-none touch-none outline-none focus-visible:ring-2 focus-visible:ring-focus-ring",
+        "rounded-xl bg-muted overflow-hidden",
+        "transition-[filter] duration-200",
+        "focus-visible:ring-1 focus-visible:ring-accent",
+        disabled && "opacity-50 pointer-events-none",
+        className
+      ),
+      style: { height: TRACK_HEIGHT },
+      animate: {
+        filter: interacting ? "brightness(1.08)" : "brightness(1)"
+      },
+      transition: { ...motionSpring.snappy, ...motionConfig },
+      onPointerDown: handlePointerDown,
+      onPointerMove: handlePointerMove,
+      onPointerUp: handlePointerUp,
+      onPointerEnter: () => !disabled && setIsHovered(true),
+      onPointerLeave: () => setIsHovered(false),
+      onKeyDown: handleKeyDown,
+      children: /* @__PURE__ */ jsxs(
+        m.div,
+        {
+          ref: trackRef,
+          className: "absolute inset-0",
+          style: { scaleX: rubberBandScale, transformOrigin: "center" },
+          children: [
+            /* @__PURE__ */ jsx(FillBar, { fillSpring, radius: TRACK_RADIUS }),
+            !!showHashMarks && /* @__PURE__ */ jsx(
+              m.div,
+              {
+                className: "absolute inset-0 pointer-events-none",
+                style: {
+                  maskImage: "linear-gradient(to right, transparent, black 5%, black 95%, transparent)",
+                  WebkitMaskImage: "linear-gradient(to right, transparent, black 5%, black 95%, transparent)"
+                },
+                animate: { opacity: interacting ? 1 : 0 },
+                transition: { ...motionSpring.snappy, ...motionConfig },
+                children: Array.from({ length: HASH_COUNT }, (_, i) => {
+                  const pos = (i + 1) / (HASH_COUNT + 1) * 100;
+                  return /* @__PURE__ */ jsx(
+                    "div",
+                    {
+                      className: "absolute top-1/2 -translate-y-1/2 w-px h-2 bg-text-primary/[0.08]",
+                      style: { left: `${pos}%` }
+                    },
+                    i
+                  );
+                })
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              m.div,
+              {
+                className: "absolute top-1/2 pointer-events-none",
+                style: {
+                  width: HANDLE_SIZE,
+                  height: HANDLE_SIZE,
+                  borderRadius: HANDLE_SIZE / 2,
+                  y: "-50%",
+                  left: handleLeftExpr,
+                  backgroundColor: "rgb(var(--color-slider-handle))",
+                  boxShadow: "0 1px 3px rgb(var(--color-overlay) / 0.3)"
+                },
+                animate: {
+                  opacity: interacting ? 1 : 0,
+                  scaleX: interacting ? 1 : 0.25
+                },
+                transition: { ...motionSpring.snappy, ...motionConfig }
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              m.span,
+              {
+                className: "absolute left-5 top-1/2 -translate-y-1/2 text-text-secondary text-base pointer-events-none select-none",
+                animate: {
+                  opacity: interacting && labelDodge ? 0.3 : 1,
+                  scale: interacting && labelDodge ? 0.92 : 1
+                },
+                transition: { ...motionSpring.gentle, ...motionConfig },
+                children: label
+              }
+            ),
+            !isEditing && /* @__PURE__ */ jsx(
+              m.span,
+              {
+                className: "absolute right-5 top-1/2 -translate-y-1/2 font-mono text-text-primary text-base pointer-events-none select-none",
+                animate: {
+                  opacity: interacting && valueDodge ? 0.3 : 1,
+                  scale: interacting && valueDodge ? 0.92 : 1
+                },
+                transition: { ...motionSpring.gentle, ...motionConfig },
+                children: formattedValue
+              }
+            ),
+            isEditing && /* @__PURE__ */ jsx(
+              "input",
+              {
+                ref: inputRef,
+                type: "text",
+                className: "absolute right-5 top-1/2 -translate-y-1/2 font-mono text-text-primary text-base bg-transparent border-none outline-none focus-visible:ring-2 focus-visible:ring-focus-ring w-20 text-right",
+                value: editText,
+                onChange: (e) => setEditText(e.target.value),
+                onBlur: commitEdit,
+                onKeyDown: handleEditKeyDown,
+                onClick: (e) => e.stopPropagation(),
+                onPointerDown: (e) => e.stopPropagation()
+              }
+            )
+          ]
+        }
+      )
+    }
+  );
+}
+
+export { Slider };

package/dist/chunk-EYWOKTOY.js

@@ -0,0 +1,58 @@
+import { cn } from './chunk-QYZT24TS.js';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import { jsx } from 'react/jsx-runtime';
+
+var Tabs = TabsPrimitive.Root;
+function TabsList({
+  className,
+  ref,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    TabsPrimitive.List,
+    {
+      ref,
+      className: cn(
+        "inline-flex h-10 items-center justify-center rounded-md glass-tab-bar p-1.5 text-text-secondary",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function TabsTrigger({
+  className,
+  ref,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    TabsPrimitive.Trigger,
+    {
+      ref,
+      className: cn(
+        "inline-flex items-center justify-center whitespace-nowrap rounded-sm px-4 py-1.5 text-sm font-medium transition-colors duration-200 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-accent focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:glass-tab-active data-[state=active]:text-text-primary hover:bg-surface/30 hover:text-text-primary",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function TabsContent({
+  className,
+  ref,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    TabsPrimitive.Content,
+    {
+      ref,
+      className: cn(
+        "mt-2 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-accent focus-visible:ring-offset-2",
+        className
+      ),
+      ...props
+    }
+  );
+}
+
+export { Tabs, TabsContent, TabsList, TabsTrigger };

package/dist/chunk-F3T2U7YL.js

@@ -0,0 +1,79 @@
+import { useIsInView } from './chunk-4O6L5YWT.js';
+import * as React from 'react';
+import { useReducedMotion, useMotionValue, useSpring } from 'motion/react';
+import { jsx } from 'react/jsx-runtime';
+
+var DEFAULT_COUNTING_TRANSITION = { stiffness: 90, damping: 50 };
+function CountingNumber({
+  ref,
+  number,
+  fromNumber = 0,
+  padStart = false,
+  inView = false,
+  inViewMargin = "0px",
+  inViewOnce = true,
+  decimalSeparator = ".",
+  transition = DEFAULT_COUNTING_TRANSITION,
+  decimalPlaces = 0,
+  delay = 0,
+  initiallyStable = false,
+  ...props
+}) {
+  const prefersReduced = useReducedMotion();
+  const { ref: localRef, isInView } = useIsInView(
+    ref,
+    {
+      inView,
+      inViewOnce,
+      inViewMargin
+    }
+  );
+  const numberStr = number.toString();
+  const decimals = typeof decimalPlaces === "number" ? decimalPlaces : numberStr.includes(".") ? numberStr.split(".")[1]?.length ?? 0 : 0;
+  const motionVal = useMotionValue(initiallyStable ? number : fromNumber);
+  const springVal = useSpring(motionVal, transition);
+  React.useEffect(() => {
+    if (prefersReduced) {
+      motionVal.set(number);
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      if (isInView) motionVal.set(number);
+    }, delay);
+    return () => clearTimeout(timeoutId);
+  }, [prefersReduced, isInView, number, motionVal, delay]);
+  React.useEffect(() => {
+    const unsubscribe = springVal.on("change", (latest) => {
+      if (localRef.current) {
+        let formatted = decimals > 0 ? latest.toFixed(decimals) : Math.round(latest).toString();
+        if (decimals > 0) {
+          formatted = formatted.replace(".", decimalSeparator);
+        }
+        if (padStart) {
+          const finalIntLength2 = Math.floor(Math.abs(number)).toString().length;
+          const [intPart, fracPart] = formatted.split(decimalSeparator);
+          const paddedInt = intPart?.padStart(finalIntLength2, "0") ?? "";
+          formatted = fracPart ? `${paddedInt}${decimalSeparator}${fracPart}` : paddedInt;
+        }
+        localRef.current.textContent = formatted;
+      }
+    });
+    return () => unsubscribe();
+  }, [springVal, decimals, padStart, number, decimalSeparator, localRef]);
+  const finalIntLength = Math.floor(Math.abs(number)).toString().length;
+  const formatValue = (val) => {
+    let out = decimals > 0 ? val.toFixed(decimals) : Math.round(val).toString();
+    if (decimals > 0) out = out.replace(".", decimalSeparator);
+    if (padStart) {
+      const [intPart, fracPart] = out.split(decimalSeparator);
+      const paddedInt = (intPart ?? "").padStart(finalIntLength, "0");
+      out = fracPart ? `${paddedInt}${decimalSeparator}${fracPart}` : paddedInt;
+    }
+    return out;
+  };
+  const zeroText = padStart ? "0".padStart(finalIntLength, "0") + (decimals > 0 ? decimalSeparator + "0".repeat(decimals) : "") : "0" + (decimals > 0 ? decimalSeparator + "0".repeat(decimals) : "");
+  const initialText = initiallyStable ? formatValue(number) : zeroText;
+  return /* @__PURE__ */ jsx("span", { ref: localRef, "data-slot": "counting-number", ...props, children: initialText });
+}
+
+export { CountingNumber };

package/dist/chunk-FLF5AMNO.js

@@ -0,0 +1,28 @@
+import { useAnimatedIcon } from './chunk-ASKFAYYR.js';
+import { cn } from './chunk-QYZT24TS.js';
+import { useAnimation, motion } from 'motion/react';
+import { jsx } from 'react/jsx-runtime';
+
+var PATH_VARIANTS = {
+  normal: { opacity: 1, pathLength: 1, transition: { duration: 0.6, opacity: { duration: 0.1 } } },
+  animate: { opacity: [0, 1], pathLength: [0, 1], transition: { duration: 0.6, opacity: { duration: 0.1 } } }
+};
+function ZapIcon({
+  onMouseEnter,
+  onMouseLeave,
+  className,
+  size = 28,
+  ref,
+  ...props
+}) {
+  const controls = useAnimation();
+  const { handleMouseEnter, handleMouseLeave } = useAnimatedIcon(ref, {
+    onMouseEnter,
+    onMouseLeave,
+    animate: () => controls.start("animate"),
+    reset: () => controls.start("normal")
+  });
+  return /* @__PURE__ */ jsx("div", { className: cn(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, ...props, children: /* @__PURE__ */ jsx("svg", { fill: "none", height: size, stroke: "currentColor", strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: "2", viewBox: "0 0 24 24", width: size, xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ jsx(motion.path, { animate: controls, d: "M4 14a1 1 0 0 1-.78-1.63l9.9-10.2a.5.5 0 0 1 .86.46l-1.92 6.02A1 1 0 0 0 13 10h7a1 1 0 0 1 .78 1.63l-9.9 10.2a.5.5 0 0 1-.86-.46l1.92-6.02A1 1 0 0 0 11 14z", variants: PATH_VARIANTS }) }) });
+}
+
+export { ZapIcon };