@toankhontech/arctimer-core 0.0.0

package/dist/index.js

@@ -0,0 +1,773 @@
+import { createContext, useReducer, useState, useRef, useMemo, useCallback, useEffect, useContext } from 'react';
+
+// src/useCountdown.ts
+
+// src/engine/timerMachine.ts
+function createInitialState(duration, initialRemainingTime) {
+  const elapsed = initialRemainingTime !== void 0 ? duration - initialRemainingTime : 0;
+  return {
+    status: "idle",
+    duration,
+    elapsed: Math.max(0, Math.min(elapsed, duration)),
+    startedAt: null,
+    pausedAt: null
+  };
+}
+function timerReducer(state, event) {
+  switch (event.type) {
+    case "PLAY": {
+      if (state.status === "playing") return state;
+      const now = performance.now();
+      if (state.status === "completed") {
+        return {
+          ...state,
+          status: "playing",
+          elapsed: 0,
+          startedAt: now,
+          pausedAt: null
+        };
+      }
+      return {
+        ...state,
+        status: "playing",
+        startedAt: now - state.elapsed * 1e3,
+        pausedAt: null
+      };
+    }
+    case "PAUSE": {
+      if (state.status !== "playing") return state;
+      return {
+        ...state,
+        status: "paused",
+        pausedAt: performance.now()
+      };
+    }
+    case "COMPLETE": {
+      if (state.status !== "playing") return state;
+      return {
+        ...state,
+        status: "completed",
+        elapsed: state.duration,
+        startedAt: null,
+        pausedAt: null
+      };
+    }
+    case "RESET": {
+      const newDuration = event.duration ?? state.duration;
+      return createInitialState(newDuration);
+    }
+    default:
+      return state;
+  }
+}
+
+// src/engine/rafLoop.ts
+var subscribers = /* @__PURE__ */ new Map();
+var rafId = null;
+var isRunning = false;
+function tick(timestamp) {
+  subscribers.forEach((cb) => {
+    try {
+      cb(timestamp);
+    } catch (_e) {
+    }
+  });
+  if (subscribers.size > 0) {
+    rafId = requestAnimationFrame(tick);
+  } else {
+    isRunning = false;
+    rafId = null;
+  }
+}
+function startLoop() {
+  if (isRunning) return;
+  isRunning = true;
+  rafId = requestAnimationFrame(tick);
+}
+function stopLoop() {
+  if (rafId !== null) {
+    cancelAnimationFrame(rafId);
+    rafId = null;
+  }
+  isRunning = false;
+}
+function subscribe(id, callback) {
+  subscribers.set(id, callback);
+  if (subscribers.size === 1) {
+    startLoop();
+  }
+  return () => {
+    subscribers.delete(id);
+    if (subscribers.size === 0) {
+      stopLoop();
+    }
+  };
+}
+function _resetForTesting() {
+  subscribers.clear();
+  stopLoop();
+}
+
+// src/engine/colorInterpolation.ts
+function hexToRgb(hex) {
+  const cleaned = hex.replace("#", "");
+  const fullHex = cleaned.length === 3 ? cleaned.split("").map((c) => c + c).join("") : cleaned;
+  const num = parseInt(fullHex, 16);
+  return [num >> 16 & 255, num >> 8 & 255, num & 255];
+}
+function rgbToHex(r, g, b) {
+  const toHex = (n) => Math.round(Math.max(0, Math.min(255, n))).toString(16).padStart(2, "0");
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function interpolateColor(color1, color2, factor) {
+  const clampedFactor = Math.max(0, Math.min(1, factor));
+  const [r1, g1, b1] = hexToRgb(color1);
+  const [r2, g2, b2] = hexToRgb(color2);
+  return rgbToHex(
+    r1 + (r2 - r1) * clampedFactor,
+    g1 + (g2 - g1) * clampedFactor,
+    b1 + (b2 - b1) * clampedFactor
+  );
+}
+function getStrokeColor(colors, colorsTime, remainingTime, duration) {
+  const defaultColor = "#3498DB";
+  if (!colors) return defaultColor;
+  if (typeof colors === "string") return colors;
+  if (colors.length === 0) return defaultColor;
+  if (colors.length === 1) return colors[0];
+  const times = colorsTime ?? colors.map((_, i) => duration - duration / (colors.length - 1) * i);
+  for (let i = 0; i < times.length - 1; i++) {
+    const currentTime = times[i];
+    const nextTime = times[i + 1];
+    if (remainingTime <= currentTime && remainingTime >= nextTime) {
+      const range = currentTime - nextTime;
+      if (range === 0) return colors[i];
+      const factor = (currentTime - remainingTime) / range;
+      return interpolateColor(colors[i], colors[i + 1], factor);
+    }
+  }
+  if (remainingTime >= times[0]) return colors[0];
+  return colors[colors.length - 1];
+}
+
+// src/svg/pathCalculation.ts
+function getCirclePath(size, strokeWidth, rotation = "clockwise") {
+  const halfSize = size / 2;
+  const radius = halfSize - strokeWidth / 2;
+  const isClockwise = rotation === "clockwise";
+  const sweepFlag = isClockwise ? 1 : 0;
+  return [
+    `M ${halfSize},${strokeWidth / 2}`,
+    `A ${radius},${radius} 0 1,${sweepFlag} ${halfSize},${size - strokeWidth / 2}`,
+    `A ${radius},${radius} 0 1,${sweepFlag} ${halfSize},${strokeWidth / 2}`
+  ].join(" ");
+}
+function getPathLength(size, strokeWidth) {
+  const radius = (size - strokeWidth) / 2;
+  return 2 * Math.PI * radius;
+}
+function getStrokeDashoffset(pathLength, progress) {
+  const clampedProgress = Math.max(0, Math.min(1, progress));
+  return pathLength * (1 - clampedProgress);
+}
+
+// src/animation/spring.ts
+function springStep(state, stiffness, damping, mass, dt) {
+  function acceleration(pos, vel) {
+    return (-stiffness * (pos - 1) - damping * vel) / mass;
+  }
+  const k1v = acceleration(state.position, state.velocity);
+  const k1x = state.velocity;
+  const k2v = acceleration(
+    state.position + k1x * dt * 0.5,
+    state.velocity + k1v * dt * 0.5
+  );
+  const k2x = state.velocity + k1v * dt * 0.5;
+  const k3v = acceleration(
+    state.position + k2x * dt * 0.5,
+    state.velocity + k2v * dt * 0.5
+  );
+  const k3x = state.velocity + k2v * dt * 0.5;
+  const k4v = acceleration(
+    state.position + k3x * dt,
+    state.velocity + k3v * dt
+  );
+  const k4x = state.velocity + k3v * dt;
+  const newPosition = state.position + dt / 6 * (k1x + 2 * k2x + 2 * k3x + k4x);
+  const newVelocity = state.velocity + dt / 6 * (k1v + 2 * k2v + 2 * k3v + k4v);
+  return { position: newPosition, velocity: newVelocity };
+}
+function createSpringEasing(config) {
+  const tension = config.tension ?? 170;
+  const friction = config.friction ?? 26;
+  const mass = config.mass ?? 1;
+  const samples = [];
+  const sampleCount = 1e3;
+  const dt = 1e-3;
+  let state = { position: 0, velocity: 0 };
+  let totalTime = 0;
+  const threshold = 1e-4;
+  for (let i = 0; i < 1e4; i++) {
+    state = springStep(state, tension, friction, mass, dt);
+    totalTime += dt;
+    if (Math.abs(state.position - 1) < threshold && Math.abs(state.velocity) < threshold) {
+      break;
+    }
+  }
+  const settleDuration = totalTime;
+  state = { position: 0, velocity: 0 };
+  for (let i = 0; i <= sampleCount; i++) {
+    const targetTime = i / sampleCount * settleDuration;
+    while (totalTime < targetTime) {
+      state = springStep(state, tension, friction, mass, dt);
+      totalTime += dt;
+    }
+    samples.push(state.position);
+    if (i === 0) {
+      totalTime = 0;
+      state = { position: 0, velocity: 0 };
+    }
+  }
+  const properSamples = [];
+  state = { position: 0, velocity: 0 };
+  for (let i = 0; i <= sampleCount; i++) {
+    const stepsPerSample = Math.ceil(settleDuration / dt / sampleCount);
+    for (let j = 0; j < stepsPerSample; j++) {
+      state = springStep(state, tension, friction, mass, dt);
+    }
+    properSamples.push(Math.max(0, Math.min(state.position, 1.5)));
+  }
+  return (t) => {
+    if (t <= 0) return 0;
+    if (t >= 1) return 1;
+    const index = t * sampleCount;
+    const lower = Math.floor(index);
+    const upper = Math.min(Math.ceil(index), sampleCount);
+    const fraction = index - lower;
+    const lowerVal = properSamples[lower] ?? 0;
+    const upperVal = properSamples[upper] ?? 1;
+    return lowerVal + (upperVal - lowerVal) * fraction;
+  };
+}
+
+// src/animation/easings.ts
+var easings = {
+  linear: (t) => t,
+  easeIn: (t) => t * t,
+  easeOut: (t) => t * (2 - t),
+  easeInOut: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+  easeInCubic: (t) => t * t * t,
+  easeOutCubic: (t) => {
+    const t1 = t - 1;
+    return t1 * t1 * t1 + 1;
+  },
+  easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1
+};
+function resolveEasing(easing) {
+  if (!easing) return easings.linear;
+  if (typeof easing === "function") return easing;
+  if (typeof easing === "string") {
+    return easings[easing] ?? easings.linear;
+  }
+  if (typeof easing === "object" && easing.type === "spring") {
+    return createSpringEasing(easing);
+  }
+  return easings.linear;
+}
+function getEasingNames() {
+  return Object.keys(easings);
+}
+
+// src/animation/effects.ts
+function computeBounce(remainingTime, prevRemainingTime, bounceAt, bounceOnComplete, isComplete, elapsedSinceBounce) {
+  const bounceDuration = 300;
+  const shouldBounce = bounceOnComplete && isComplete || bounceAt.some(
+    (threshold) => prevRemainingTime > threshold && remainingTime <= threshold
+  );
+  if (!shouldBounce && elapsedSinceBounce > bounceDuration) {
+    return { scale: 1, active: false };
+  }
+  if (shouldBounce || elapsedSinceBounce <= bounceDuration) {
+    const progress = Math.min(elapsedSinceBounce / bounceDuration, 1);
+    const bounceScale = 1 + 0.1 * Math.sin(progress * Math.PI);
+    return { scale: bounceScale, active: progress < 1 };
+  }
+  return { scale: 1, active: false };
+}
+function computePulse(elapsedTime, config) {
+  if (!config) {
+    return { scale: 1, opacity: 1 };
+  }
+  const { interval, scale = 1.05, opacity = 1 } = config;
+  if (interval <= 0) {
+    return { scale: 1, opacity: 1 };
+  }
+  const cycleProgress = elapsedTime % interval / interval;
+  const sinValue = Math.sin(cycleProgress * 2 * Math.PI);
+  const normalized = (sinValue + 1) / 2;
+  const currentScale = 1 + (scale - 1) * normalized;
+  const minOpacity = Math.max(0, 2 * opacity - 1);
+  const currentOpacity = minOpacity + (1 - minOpacity) * normalized;
+  return {
+    scale: currentScale,
+    opacity: currentOpacity
+  };
+}
+
+// src/useCountdown.ts
+var idCounter = 0;
+function generateId() {
+  return `arc-timer-${++idCounter}`;
+}
+function useCountdown(props) {
+  const {
+    duration,
+    isPlaying = false,
+    colors,
+    colorsTime,
+    size = 180,
+    strokeWidth = 12,
+    rotation = "clockwise",
+    isCountUp = false,
+    initialRemainingTime,
+    updateInterval = 1,
+    easing,
+    bounceOnComplete = false,
+    bounceAt = [],
+    pulse,
+    onComplete,
+    onUpdate,
+    onAnimationFrame
+  } = props;
+  const [state, dispatch] = useReducer(
+    timerReducer,
+    { duration, initialRemainingTime },
+    ({ duration: d, initialRemainingTime: irt }) => createInitialState(d, irt)
+  );
+  const [displayTime, setDisplayTime] = useState(() => {
+    if (initialRemainingTime !== void 0) {
+      return isCountUp ? duration - initialRemainingTime : initialRemainingTime;
+    }
+    return isCountUp ? 0 : duration;
+  });
+  const [smoothProgress, setSmoothProgress] = useState(0);
+  const [animationScale, setAnimationScale] = useState(1);
+  const [animationOpacity, setAnimationOpacity] = useState(1);
+  const idRef = useRef(generateId());
+  const prevDisplayTimeRef = useRef(displayTime);
+  const onCompleteRef = useRef(onComplete);
+  const onUpdateRef = useRef(onUpdate);
+  const onAnimationFrameRef = useRef(onAnimationFrame);
+  const repeatTimeoutRef = useRef(null);
+  const bounceStartRef = useRef(null);
+  const prevRemainingForBounceRef = useRef(displayTime);
+  const easingFn = useMemo(() => resolveEasing(easing), [easing]);
+  onCompleteRef.current = onComplete;
+  onUpdateRef.current = onUpdate;
+  onAnimationFrameRef.current = onAnimationFrame;
+  const play = useCallback(() => {
+    dispatch({ type: "PLAY" });
+  }, []);
+  const pause = useCallback(() => {
+    dispatch({ type: "PAUSE" });
+  }, []);
+  const reset = useCallback(
+    (newDuration) => {
+      dispatch({ type: "RESET", duration: newDuration });
+      const dur = newDuration ?? duration;
+      setDisplayTime(isCountUp ? 0 : dur);
+      setSmoothProgress(0);
+      setAnimationScale(1);
+      setAnimationOpacity(1);
+      bounceStartRef.current = null;
+    },
+    [duration, isCountUp]
+  );
+  useEffect(() => {
+    if (isPlaying) {
+      if (state.status !== "playing") {
+        dispatch({ type: "PLAY" });
+      }
+    } else {
+      if (state.status === "playing") {
+        dispatch({ type: "PAUSE" });
+      }
+    }
+  }, [isPlaying, state.status]);
+  useEffect(() => {
+    if (duration !== state.duration) {
+      dispatch({ type: "RESET", duration });
+    }
+  }, [duration, state.duration]);
+  useEffect(() => {
+    if (state.status !== "playing" || state.startedAt === null) return;
+    const startedAt = state.startedAt;
+    let lastUpdateTime = 0;
+    const unsubscribe = subscribe(idRef.current, (timestamp) => {
+      const elapsedMs = timestamp - startedAt;
+      const elapsedSeconds = elapsedMs / 1e3;
+      const clampedElapsed = Math.min(elapsedSeconds, duration);
+      const linearProgress = duration > 0 ? clampedElapsed / duration : 1;
+      const easedProgress = easingFn(linearProgress);
+      setSmoothProgress(easedProgress);
+      onAnimationFrameRef.current?.(easedProgress);
+      const rawRemainingTime = Math.max(
+        0,
+        duration - duration * easedProgress
+      );
+      const remainingTimeInt = Math.ceil(rawRemainingTime);
+      const hasBounceConfig = bounceOnComplete || bounceAt && bounceAt.length > 0;
+      if (hasBounceConfig) {
+        const prevRemaining = prevRemainingForBounceRef.current;
+        const shouldStartBounce = bounceOnComplete && rawRemainingTime <= 0 && prevRemaining > 0 || bounceAt.some(
+          (t) => prevRemaining > t && remainingTimeInt <= t
+        );
+        if (shouldStartBounce) {
+          bounceStartRef.current = timestamp;
+        }
+        if (bounceStartRef.current !== null) {
+          const bounceElapsed = timestamp - bounceStartRef.current;
+          const result = computeBounce(
+            remainingTimeInt,
+            prevRemaining,
+            bounceAt,
+            bounceOnComplete,
+            rawRemainingTime <= 0,
+            bounceElapsed
+          );
+          setAnimationScale(result.scale);
+          if (!result.active) {
+            bounceStartRef.current = null;
+          }
+        }
+        prevRemainingForBounceRef.current = remainingTimeInt;
+      }
+      if (pulse) {
+        const pulseResult = computePulse(clampedElapsed, pulse);
+        setAnimationScale(
+          (prev) => bounceStartRef.current !== null ? prev : pulseResult.scale
+        );
+        setAnimationOpacity(pulseResult.opacity);
+      }
+      const shouldUpdate = updateInterval === 0 || timestamp - lastUpdateTime >= updateInterval * 1e3;
+      if (shouldUpdate) {
+        lastUpdateTime = timestamp;
+        const newDisplayTime = isCountUp ? Math.floor(clampedElapsed) : remainingTimeInt;
+        setDisplayTime((prev) => {
+          if (prev !== newDisplayTime) {
+            return newDisplayTime;
+          }
+          return prev;
+        });
+      }
+      if (clampedElapsed >= duration) {
+        dispatch({ type: "COMPLETE" });
+      }
+    });
+    return unsubscribe;
+  }, [
+    state.status,
+    state.startedAt,
+    duration,
+    updateInterval,
+    isCountUp,
+    easingFn,
+    bounceOnComplete,
+    bounceAt,
+    pulse
+  ]);
+  useEffect(() => {
+    if (state.status !== "completed") return;
+    const result = onCompleteRef.current?.(state.duration);
+    if (result?.shouldRepeat) {
+      const delay = (result.delay ?? 0) * 1e3;
+      repeatTimeoutRef.current = setTimeout(() => {
+        if (result.newInitialRemainingTime !== void 0) {
+          dispatch({ type: "RESET" });
+          setDisplayTime(
+            isCountUp ? duration - result.newInitialRemainingTime : result.newInitialRemainingTime
+          );
+        } else {
+          dispatch({ type: "RESET" });
+          setDisplayTime(isCountUp ? 0 : duration);
+        }
+        setSmoothProgress(0);
+        dispatch({ type: "PLAY" });
+      }, delay);
+    }
+    return () => {
+      if (repeatTimeoutRef.current) {
+        clearTimeout(repeatTimeoutRef.current);
+      }
+    };
+  }, [state.status, state.duration, duration, isCountUp]);
+  useEffect(() => {
+    if (prevDisplayTimeRef.current !== displayTime) {
+      prevDisplayTimeRef.current = displayTime;
+      const rt = isCountUp ? duration - displayTime : displayTime;
+      onUpdateRef.current?.(rt);
+    }
+  }, [displayTime, duration, isCountUp]);
+  const path = useMemo(
+    () => getCirclePath(size, strokeWidth, rotation),
+    [size, strokeWidth, rotation]
+  );
+  const pathLength = useMemo(
+    () => getPathLength(size, strokeWidth),
+    [size, strokeWidth]
+  );
+  const elapsedTime = isCountUp ? displayTime : duration - displayTime;
+  const remainingTime = isCountUp ? duration - displayTime : displayTime;
+  const isComplete = state.status === "completed";
+  const arcProgress = isCountUp ? smoothProgress : 1 - smoothProgress;
+  const strokeDashoffset = getStrokeDashoffset(pathLength, arcProgress);
+  const color = getStrokeColor(colors, colorsTime, remainingTime, duration);
+  const progress = smoothProgress;
+  return {
+    path,
+    pathLength,
+    stroke: color,
+    strokeDashoffset,
+    remainingTime,
+    elapsedTime,
+    progress,
+    color,
+    size,
+    strokeWidth,
+    isComplete,
+    isPlaying: state.status === "playing",
+    animationScale,
+    animationOpacity,
+    _play: play,
+    _pause: pause,
+    _reset: reset,
+    _getState: () => ({
+      remainingTime,
+      elapsedTime,
+      isPlaying: state.status === "playing",
+      progress,
+      isComplete
+    })
+  };
+}
+var TimerGroupContext = createContext(
+  null
+);
+function useTimerGroupContext() {
+  return useContext(TimerGroupContext);
+}
+function useTimerGroup(options) {
+  const {
+    mode = "sequential",
+    staggerDelay: _staggerDelay = 0,
+    isPlaying = false,
+    timerCount,
+    onGroupComplete,
+    onTimerComplete
+  } = options;
+  const [activeIndex, setActiveIndex] = useState(0);
+  const [groupState, setGroupState] = useState("idle");
+  const [completedTimers, setCompletedTimers] = useState(
+    () => /* @__PURE__ */ new Set()
+  );
+  const [timerStates, setTimerStates] = useState(
+    () => Array.from({ length: timerCount }, () => ({
+      isPlaying: false,
+      isComplete: false
+    }))
+  );
+  const onGroupCompleteRef = useRef(onGroupComplete);
+  const onTimerCompleteRef = useRef(onTimerComplete);
+  onGroupCompleteRef.current = onGroupComplete;
+  onTimerCompleteRef.current = onTimerComplete;
+  useEffect(() => {
+    if (isPlaying) {
+      setGroupState("playing");
+    } else if (groupState === "playing") {
+      setGroupState("paused");
+    }
+  }, [isPlaying, groupState]);
+  useEffect(() => {
+    if (groupState !== "playing") {
+      setTimerStates(
+        (prev) => prev.map((t) => ({ ...t, isPlaying: false }))
+      );
+      return;
+    }
+    setTimerStates(
+      (prev) => prev.map((t, i) => {
+        if (completedTimers.has(i)) {
+          return { ...t, isPlaying: false, isComplete: true };
+        }
+        switch (mode) {
+          case "sequential":
+            return { ...t, isPlaying: i === activeIndex };
+          case "parallel":
+            return { ...t, isPlaying: true };
+          case "staggered":
+            return { ...t, isPlaying: true };
+          default:
+            return t;
+        }
+      })
+    );
+  }, [groupState, mode, activeIndex, completedTimers, timerCount]);
+  const handleTimerComplete = useCallback(
+    (index) => {
+      onTimerCompleteRef.current?.(index);
+      setCompletedTimers((prev) => {
+        const next = new Set(prev);
+        next.add(index);
+        if (next.size >= timerCount) {
+          setGroupState("completed");
+          onGroupCompleteRef.current?.();
+        }
+        return next;
+      });
+      if (mode === "sequential") {
+        setActiveIndex((prev) => Math.min(prev + 1, timerCount - 1));
+      }
+    },
+    [mode, timerCount]
+  );
+  const playAll = useCallback(() => {
+    setGroupState("playing");
+  }, []);
+  const pauseAll = useCallback(() => {
+    setGroupState("paused");
+  }, []);
+  const resetAll = useCallback(() => {
+    setActiveIndex(0);
+    setGroupState("idle");
+    setCompletedTimers(/* @__PURE__ */ new Set());
+    setTimerStates(
+      Array.from({ length: timerCount }, () => ({
+        isPlaying: false,
+        isComplete: false
+      }))
+    );
+  }, [timerCount]);
+  return {
+    timers: timerStates,
+    activeIndex,
+    playAll,
+    pauseAll,
+    resetAll,
+    groupState,
+    _handleTimerComplete: handleTimerComplete
+  };
+}
+
+// src/accessibility/ariaLabels.ts
+function generateAriaLabel(remainingTime, isCountUp) {
+  const minutes = Math.floor(remainingTime / 60);
+  const seconds = remainingTime % 60;
+  const timeStr = minutes > 0 ? `${minutes} minute${minutes !== 1 ? "s" : ""} and ${seconds} second${seconds !== 1 ? "s" : ""}` : `${seconds} second${seconds !== 1 ? "s" : ""}`;
+  return isCountUp ? `${timeStr} elapsed` : `${timeStr} remaining`;
+}
+function resolveAriaLabel(ariaLabel, info, isCountUp) {
+  if (typeof ariaLabel === "function") {
+    return ariaLabel(info);
+  }
+  if (typeof ariaLabel === "string") {
+    return ariaLabel;
+  }
+  return generateAriaLabel(info.remainingTime, isCountUp);
+}
+var DEFAULT_THRESHOLDS_PERCENT = [50, 25, 10];
+var DEFAULT_THRESHOLDS_SECONDS = [5];
+function getAnnouncementText(remainingTime, isCountUp) {
+  if (remainingTime <= 0) {
+    return isCountUp ? "Timer complete" : "Time is up";
+  }
+  const minutes = Math.floor(remainingTime / 60);
+  const seconds = remainingTime % 60;
+  if (minutes > 0) {
+    return isCountUp ? `${minutes} minutes and ${seconds} seconds elapsed` : `${minutes} minutes and ${seconds} seconds remaining`;
+  }
+  return isCountUp ? `${seconds} seconds elapsed` : `${seconds} seconds remaining`;
+}
+function shouldAnnounce(remainingTime, prevRemainingTime, duration, announceInterval) {
+  if (remainingTime === prevRemainingTime) return false;
+  if (remainingTime <= 0 && prevRemainingTime > 0) return true;
+  if (announceInterval > 0) {
+    const prevBucket = Math.floor(prevRemainingTime / announceInterval);
+    const currentBucket = Math.floor(remainingTime / announceInterval);
+    if (prevBucket !== currentBucket) return true;
+  }
+  for (const percent of DEFAULT_THRESHOLDS_PERCENT) {
+    const threshold = Math.floor(duration * (percent / 100));
+    if (prevRemainingTime > threshold && remainingTime <= threshold) {
+      return true;
+    }
+  }
+  for (const threshold of DEFAULT_THRESHOLDS_SECONDS) {
+    if (prevRemainingTime > threshold && remainingTime <= threshold) {
+      return true;
+    }
+  }
+  return false;
+}
+function useAnnouncer(remainingTime, duration, announceInterval, isCountUp) {
+  const prevTimeRef = useRef(remainingTime);
+  const announcementRef = useRef("");
+  useEffect(() => {
+    if (shouldAnnounce(
+      remainingTime,
+      prevTimeRef.current,
+      duration,
+      announceInterval
+    )) {
+      announcementRef.current = getAnnouncementText(
+        remainingTime,
+        isCountUp
+      );
+    }
+    prevTimeRef.current = remainingTime;
+  }, [remainingTime, duration, announceInterval, isCountUp]);
+  return {
+    announcement: announcementRef.current,
+    announcerProps: {
+      role: "status",
+      "aria-live": "polite",
+      "aria-atomic": true,
+      style: {
+        position: "absolute",
+        width: 1,
+        height: 1,
+        padding: 0,
+        margin: -1,
+        overflow: "hidden",
+        clip: "rect(0, 0, 0, 0)",
+        whiteSpace: "nowrap",
+        borderWidth: 0
+      }
+    }
+  };
+}
+var QUERY = "(prefers-reduced-motion: reduce)";
+function getInitialState() {
+  if (typeof window === "undefined") return false;
+  if (typeof window.matchMedia !== "function") return false;
+  return window.matchMedia(QUERY).matches;
+}
+function useReducedMotion() {
+  const [prefersReducedMotion, setPrefersReducedMotion] = useState(getInitialState);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    if (typeof window.matchMedia !== "function") return;
+    const mediaQuery = window.matchMedia(QUERY);
+    const handler = (event) => {
+      setPrefersReducedMotion(event.matches);
+    };
+    mediaQuery.addEventListener("change", handler);
+    return () => {
+      mediaQuery.removeEventListener("change", handler);
+    };
+  }, []);
+  return prefersReducedMotion;
+}
+
+export { TimerGroupContext, _resetForTesting, computeBounce, computePulse, createInitialState, createSpringEasing, easings, generateAriaLabel, getAnnouncementText, getCirclePath, getEasingNames, getPathLength, getStrokeColor, getStrokeDashoffset, hexToRgb, interpolateColor, resolveAriaLabel, resolveEasing, rgbToHex, shouldAnnounce, subscribe, timerReducer, useAnnouncer, useCountdown, useReducedMotion, useTimerGroup, useTimerGroupContext };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map