@gfazioli/mantine-clock 2.1.17 → 3.1.0

package/dist/cjs/Clock.cjs

@@ -2,27 +2,21 @@
 'use strict';
 
 var dayjs = require('dayjs');
-var timezonePlugin = require('dayjs/plugin/timezone');
+var timezone = require('dayjs/plugin/timezone');
 var utc = require('dayjs/plugin/utc');
 var React = require('react');
 var core = require('@mantine/core');
+var hooks = require('@mantine/hooks');
+var clockUtils = require('./clock-utils.cjs');
+var ClockDigital = require('./ClockDigital.cjs');
+var ClockFaceStatic = require('./ClockFaceStatic.cjs');
+var geometry = require('./geometry.cjs');
+var RealClock = require('./RealClock.cjs');
 var Clock_module = require('./Clock.module.css.cjs');
 
 dayjs.extend(utc);
-dayjs.extend(timezonePlugin);
-const defaultProps = {
-  size: 400,
-  hourHandSize: 0.017,
-  minuteHandSize: 0.011,
-  secondHandSize: 6e-3,
-  hourHandLength: 0.4,
-  minuteHandLength: 0.57,
-  secondHandLength: 0.68,
-  secondHandOpacity: 1,
-  minuteHandOpacity: 1,
-  hourHandOpacity: 1,
-  running: true
-};
+dayjs.extend(timezone);
+const defaultProps = clockUtils.defaultClockProps;
 const defaultClockSizes = {
   xs: 100,
   sm: 200,
@@ -30,464 +24,41 @@ const defaultClockSizes = {
   lg: 480,
   xl: 512
 };
-const varsResolver = core.createVarsResolver(
-  (theme, {
-    size,
-    color,
-    hourTicksColor,
-    hourTicksOpacity,
-    minuteTicksColor,
-    minuteTicksOpacity,
-    primaryNumbersColor,
-    primaryNumbersOpacity,
-    secondaryNumbersColor,
-    secondaryNumbersOpacity,
-    secondHandColor,
-    minuteHandColor,
-    hourHandColor,
-    secondsArcColor,
-    minutesArcColor,
-    hoursArcColor
-  }) => {
-    const sizeValue = size || "md";
-    const clockSize = typeof sizeValue === "string" && sizeValue in defaultClockSizes ? defaultClockSizes[sizeValue] : sizeValue;
-    const effectiveSize = Math.round(core.px(core.getSize(clockSize, "clock-size")));
-    return {
-      root: {
-        "--clock-size": `${effectiveSize}px`,
-        "--clock-color": core.parseThemeColor({
-          color: color || "",
-          theme
-        }).value,
-        "--clock-hour-ticks-color": core.parseThemeColor({
-          color: hourTicksColor || "",
-          theme
-        }).value,
-        "--clock-hour-ticks-opacity": (Math.round((hourTicksOpacity || 1) * 100) / 100).toString(),
-        "--clock-minute-ticks-color": core.parseThemeColor({
-          color: minuteTicksColor || "",
-          theme
-        }).value,
-        "--clock-minute-ticks-opacity": (Math.round((minuteTicksOpacity || 1) * 100) / 100).toString(),
-        "--clock-primary-numbers-color": core.parseThemeColor({
-          color: primaryNumbersColor || "",
-          theme
-        }).value,
-        "--clock-primary-numbers-opacity": (Math.round((primaryNumbersOpacity || 1) * 100) / 100).toString(),
-        "--clock-secondary-numbers-color": core.parseThemeColor({
-          color: secondaryNumbersColor || "",
-          theme
-        }).value,
-        "--clock-secondary-numbers-opacity": (Math.round((secondaryNumbersOpacity || 1) * 100) / 100).toString(),
-        "--clock-second-hand-color": core.parseThemeColor({
-          color: secondHandColor || "",
-          theme
-        }).value,
-        "--clock-minute-hand-color": core.parseThemeColor({
-          color: minuteHandColor || "",
-          theme
-        }).value,
-        "--clock-hour-hand-color": core.parseThemeColor({
-          color: hourHandColor || "",
-          theme
-        }).value,
-        "--clock-seconds-arc-color": core.parseThemeColor({
-          color: secondsArcColor || secondHandColor || "",
-          theme
-        }).value,
-        "--clock-minutes-arc-color": core.parseThemeColor({
-          color: minutesArcColor || minuteHandColor || "",
-          theme
-        }).value,
-        "--clock-hours-arc-color": core.parseThemeColor({
-          color: hoursArcColor || hourHandColor || "",
-          theme
-        }).value
-      }
-    };
-  }
-);
-const parseTimeValue = (value) => {
-  if (!value) {
-    return null;
-  }
-  if (value instanceof Date) {
-    return value;
-  }
-  if (dayjs.isDayjs(value)) {
-    return value.toDate();
-  }
-  if (typeof value === "string") {
-    const timeRegex = /^(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?$/;
-    const match = value.match(timeRegex);
-    if (match) {
-      const hours = parseInt(match[1], 10);
-      const minutes = parseInt(match[2], 10);
-      const seconds = parseInt(match[3] || "0", 10);
-      const date = /* @__PURE__ */ new Date();
-      date.setHours(hours, minutes, seconds, 0);
-      return date;
-    }
-    const parsed = new Date(value);
-    if (!isNaN(parsed.getTime())) {
-      return parsed;
-    }
-  }
-  return null;
-};
-const RealClock = (props) => {
-  const {
-    time,
-    timezone: timezone2,
-    getStyles,
-    effectiveSize,
-    hourHandSize,
-    minuteHandSize,
-    secondHandSize,
-    hourHandLength,
-    minuteHandLength,
-    secondHandLength,
-    secondHandBehavior,
-    secondHandOpacity,
-    minuteHandOpacity,
-    hourHandOpacity,
-    hourTicksOpacity,
-    minuteTicksOpacity,
-    primaryNumbersOpacity,
-    secondaryNumbersOpacity,
-    hourNumbersDistance = 0.75,
-    // Default distance for hour numbers
-    primaryNumbersProps,
-    secondaryNumbersProps,
-    withSecondsArc,
-    secondsArcFrom,
-    secondsArcDirection = "clockwise",
-    withMinutesArc,
-    minutesArcFrom,
-    minutesArcDirection = "clockwise",
-    withHoursArc,
-    hoursArcFrom,
-    hoursArcDirection = "clockwise",
-    secondsArcOpacity,
-    minutesArcOpacity,
-    hoursArcOpacity
-  } = props;
-  const timezoneTime = timezone2 && timezone2 !== "" ? dayjs(time).tz(timezone2) : dayjs(time);
-  const hours = timezoneTime.hour() % 12;
-  const minutes = timezoneTime.minute();
-  const seconds = timezoneTime.second();
-  const milliseconds = timezoneTime.millisecond();
-  const hourAngle = hours * 30 + minutes * 0.5;
-  const minuteAngle = minutes * 6;
-  let secondAngle = 0;
-  switch (secondHandBehavior) {
-    case "tick":
-      secondAngle = seconds * 6;
-      break;
-    case "tick-half":
-      secondAngle = (seconds + Math.floor(milliseconds / 500) * 0.5) * 6;
-      break;
-    case "tick-high-freq":
-      secondAngle = (seconds + Math.floor(milliseconds / 125) * 0.125) * 6;
-      break;
-    case "smooth":
-    default:
-      secondAngle = (seconds + milliseconds / 1e3) * 6;
-      break;
-  }
-  const size = effectiveSize;
-  const clockRadius = Math.round(size / 2);
-  const numberRadius = Math.round(clockRadius * hourNumbersDistance);
-  const calculatedHourHandLength = Math.round(
-    clockRadius * (hourHandLength ?? defaultProps.hourHandLength)
-  );
-  const calculatedMinuteHandLength = Math.round(
-    clockRadius * (minuteHandLength ?? defaultProps.minuteHandLength)
-  );
-  const calculatedSecondHandLength = Math.round(
-    clockRadius * (secondHandLength ?? defaultProps.secondHandLength)
-  );
-  const centerSize = Math.round(size * 0.034);
-  const tickOffset = Math.round(size * 0.028);
-  const toClockAngle = (deg) => (deg % 360 + 360) % 360;
-  const secAngleFromDate = (d) => {
-    if (!d) {
-      return 0;
+const varsResolver = core.createVarsResolver((theme, props) => {
+  const c = (color) => core.parseThemeColor({ color, theme }).value;
+  return {
+    root: {
+      "--clock-size": void 0,
+      "--clock-color": c(props.color || ""),
+      "--clock-hour-ticks-color": c(props.hourTicksColor || ""),
+      "--clock-hour-ticks-opacity": clockUtils.round2(props.hourTicksOpacity ?? 1).toString(),
+      "--clock-minute-ticks-color": c(props.minuteTicksColor || ""),
+      "--clock-minute-ticks-opacity": clockUtils.round2(props.minuteTicksOpacity ?? 1).toString(),
+      "--clock-primary-numbers-color": c(props.primaryNumbersColor || ""),
+      "--clock-primary-numbers-opacity": clockUtils.round2(props.primaryNumbersOpacity ?? 1).toString(),
+      "--clock-secondary-numbers-color": c(props.secondaryNumbersColor || ""),
+      "--clock-secondary-numbers-opacity": clockUtils.round2(props.secondaryNumbersOpacity ?? 1).toString(),
+      "--clock-second-hand-color": c(props.secondHandColor || ""),
+      "--clock-minute-hand-color": c(props.minuteHandColor || ""),
+      "--clock-hour-hand-color": c(props.hourHandColor || ""),
+      "--clock-seconds-arc-color": c(props.secondsArcColor || props.secondHandColor || ""),
+      "--clock-minutes-arc-color": c(props.minutesArcColor || props.minuteHandColor || ""),
+      "--clock-hours-arc-color": c(props.hoursArcColor || props.hourHandColor || "")
     }
-    const dt = timezone2 && timezone2 !== "" ? dayjs(d).tz(timezone2) : dayjs(d);
-    const s = dt.second();
-    const ms = dt.millisecond();
-    return toClockAngle((s + ms / 1e3) * 6);
   };
-  const minAngleFromDate = (d) => {
-    if (!d) {
-      return 0;
-    }
-    const dt = timezone2 && timezone2 !== "" ? dayjs(d).tz(timezone2) : dayjs(d);
-    const m = dt.minute();
-    return toClockAngle(m * 6);
-  };
-  const hourAngleFromDate = (d) => {
-    if (!d) {
-      return 0;
-    }
-    const dt = timezone2 && timezone2 !== "" ? dayjs(d).tz(timezone2) : dayjs(d);
-    const h = dt.hour() % 12;
-    const m = dt.minute();
-    return toClockAngle(h * 30 + m * 0.5);
-  };
-  const describeSector = (cx, cy, r, startDeg, endDeg, direction) => {
-    const start = toClockAngle(startDeg);
-    const end = toClockAngle(endDeg);
-    let delta = 0;
-    if (direction === "clockwise") {
-      delta = end - start;
-      if (delta < 0) {
-        delta += 360;
-      }
-    } else {
-      delta = start - end;
-      if (delta < 0) {
-        delta += 360;
-      }
-    }
-    const largeArc = delta >= 180 ? 1 : 0;
-    const sweep = direction === "clockwise" ? 1 : 0;
-    const aStart = start * Math.PI / 180;
-    const aEnd = end * Math.PI / 180;
-    const x1 = cx + r * Math.sin(aStart);
-    const y1 = cy - r * Math.cos(aStart);
-    const x2 = cx + r * Math.sin(aEnd);
-    const y2 = cy - r * Math.cos(aEnd);
-    const fmt = (n) => Number.isFinite(n) ? n.toFixed(3) : "0";
-    return `M ${fmt(cx)} ${fmt(cy)} L ${fmt(x1)} ${fmt(y1)} A ${fmt(r)} ${fmt(r)} 0 ${largeArc} ${sweep} ${fmt(x2)} ${fmt(y2)} Z`;
-  };
-  const showSecArc = withSecondsArc === true && (secondsArcOpacity ?? 1) !== 0;
-  const showMinArc = withMinutesArc === true && (minutesArcOpacity ?? 1) !== 0;
-  const showHrArc = withHoursArc === true && (hoursArcOpacity ?? 1) !== 0;
-  return /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("clockContainer") }, /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("glassWrapper") }, /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("clockFace") }, (showSecArc || showMinArc || showHrArc) && /* @__PURE__ */ React.createElement(
-    "svg",
-    {
-      ...getStyles("arcsLayer", { style: { width: size, height: size } }),
-      viewBox: `0 0 ${size} ${size}`
-    },
-    showHrArc && /* @__PURE__ */ React.createElement(
-      "path",
-      {
-        d: describeSector(
-          clockRadius,
-          clockRadius,
-          calculatedHourHandLength,
-          hourAngleFromDate(parseTimeValue(hoursArcFrom) ?? null),
-          hourAngle,
-          hoursArcDirection
-        ),
-        fill: "var(--clock-hours-arc-color-resolved)",
-        fillOpacity: Math.round((hoursArcOpacity ?? 1) * 100) / 100
-      }
-    ),
-    showMinArc && /* @__PURE__ */ React.createElement(
-      "path",
-      {
-        d: describeSector(
-          clockRadius,
-          clockRadius,
-          calculatedMinuteHandLength,
-          minAngleFromDate(parseTimeValue(minutesArcFrom) ?? null),
-          minuteAngle,
-          minutesArcDirection
-        ),
-        fill: "var(--clock-minutes-arc-color-resolved)",
-        fillOpacity: Math.round((minutesArcOpacity ?? 1) * 100) / 100
-      }
-    ),
-    showSecArc && /* @__PURE__ */ React.createElement(
-      "path",
-      {
-        d: describeSector(
-          clockRadius,
-          clockRadius,
-          calculatedSecondHandLength,
-          secAngleFromDate(parseTimeValue(secondsArcFrom) ?? null),
-          secondAngle,
-          secondsArcDirection
-        ),
-        fill: "var(--clock-seconds-arc-color-resolved)",
-        fillOpacity: Math.round((secondsArcOpacity ?? 1) * 100) / 100
-      }
-    )
-  ), /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("hourMarks") }, hourTicksOpacity !== 0 && Array.from({ length: 12 }, (_, i) => /* @__PURE__ */ React.createElement(
-    core.Box,
-    {
-      key: `hour-tick-${i}`,
-      ...getStyles("hourTick", {
-        style: {
-          top: tickOffset,
-          left: "50%",
-          transformOrigin: `50% ${clockRadius - tickOffset}px`,
-          transform: `translateX(-50%) rotate(${i * 30}deg)`
-        }
-      })
-    }
-  )), minuteTicksOpacity !== 0 && Array.from({ length: 60 }, (_, i) => {
-    if (i % 5 === 0) {
-      return null;
-    }
-    return /* @__PURE__ */ React.createElement(
-      core.Box,
-      {
-        key: `minute-tick-${i}`,
-        ...getStyles("minuteTick", {
-          style: {
-            top: tickOffset,
-            left: "50%",
-            transformOrigin: `50% ${clockRadius - tickOffset}px`,
-            transform: `translateX(-50%) rotate(${i * 6}deg)`
-          }
-        })
-      }
-    );
-  }), primaryNumbersOpacity !== 0 && [12, 3, 6, 9].map((num) => {
-    const i = num === 12 ? 0 : num;
-    const angle = (i * 30 - 90) * (Math.PI / 180);
-    const x = Math.round(clockRadius + Math.cos(angle) * numberRadius);
-    const y = Math.round(clockRadius + Math.sin(angle) * numberRadius);
-    return /* @__PURE__ */ React.createElement(
-      core.Text,
-      {
-        key: `primary-number-${num}`,
-        ...primaryNumbersProps,
-        ...getStyles("primaryNumber", {
-          className: getStyles("number").className,
-          style: {
-            left: x,
-            top: y
-          }
-        })
-      },
-      num
-    );
-  }), secondaryNumbersOpacity !== 0 && [1, 2, 4, 5, 7, 8, 10, 11].map((num) => {
-    const i = num;
-    const angle = (i * 30 - 90) * (Math.PI / 180);
-    const x = Math.round(clockRadius + Math.cos(angle) * numberRadius);
-    const y = Math.round(clockRadius + Math.sin(angle) * numberRadius);
-    return /* @__PURE__ */ React.createElement(
-      core.Text,
-      {
-        key: `secondary-number-${num}`,
-        ...secondaryNumbersProps,
-        ...getStyles("secondaryNumber", {
-          className: getStyles("number").className,
-          style: {
-            left: x,
-            top: y
-          }
-        })
-      },
-      num
-    );
-  })), (hourHandOpacity ?? defaultProps.hourHandOpacity) !== 0 && /* @__PURE__ */ React.createElement(
-    core.Box,
-    {
-      ...getStyles("hand", {
-        className: getStyles("hourHand").className,
-        style: {
-          width: Math.round(size * (hourHandSize ?? defaultProps.hourHandSize) * 100) / 100,
-          height: calculatedHourHandLength,
-          opacity: Math.round((hourHandOpacity ?? defaultProps.hourHandOpacity) * 100) / 100,
-          bottom: clockRadius,
-          left: clockRadius,
-          marginLeft: Math.round(-(size * (hourHandSize ?? defaultProps.hourHandSize)) / 2 * 100) / 100,
-          borderRadius: `${Math.round(size * (hourHandSize ?? defaultProps.hourHandSize) * 100) / 100}px`,
-          transform: `rotate(${Math.round(hourAngle * 100) / 100}deg)`
-        }
-      })
-    }
-  ), (minuteHandOpacity ?? defaultProps.minuteHandOpacity) !== 0 && /* @__PURE__ */ React.createElement(
-    core.Box,
-    {
-      ...getStyles("hand", {
-        className: getStyles("minuteHand").className,
-        style: {
-          width: Math.round(size * (minuteHandSize ?? defaultProps.minuteHandSize) * 100) / 100,
-          height: calculatedMinuteHandLength,
-          opacity: Math.round((minuteHandOpacity ?? defaultProps.minuteHandOpacity) * 100) / 100,
-          bottom: clockRadius,
-          left: clockRadius,
-          marginLeft: Math.round(
-            -(size * (minuteHandSize ?? defaultProps.minuteHandSize)) / 2 * 100
-          ) / 100,
-          borderRadius: `${Math.round(size * (minuteHandSize ?? defaultProps.minuteHandSize) * 100) / 100}px`,
-          transform: `rotate(${Math.round(minuteAngle * 100) / 100}deg)`
-        }
-      })
-    }
-  ), (secondHandOpacity ?? defaultProps.secondHandOpacity) !== 0 && /* @__PURE__ */ React.createElement(
-    core.Box,
-    {
-      ...getStyles("secondHandContainer", {
-        style: {
-          width: Math.round(size * (secondHandSize ?? defaultProps.secondHandSize) * 100) / 100,
-          height: calculatedSecondHandLength,
-          top: clockRadius - calculatedSecondHandLength,
-          left: clockRadius,
-          marginLeft: Math.round(
-            -(size * (secondHandSize ?? defaultProps.secondHandSize)) / 2 * 100
-          ) / 100,
-          transformOrigin: `${Math.round(size * (secondHandSize ?? defaultProps.secondHandSize) / 2 * 100) / 100}px ${calculatedSecondHandLength}px`,
-          transform: `rotate(${Math.round(secondAngle * 100) / 100}deg)`
-        }
-      })
-    },
-    /* @__PURE__ */ React.createElement(
-      core.Box,
-      {
-        ...getStyles("secondHand", {
-          style: {
-            width: Math.round(size * (secondHandSize ?? defaultProps.secondHandSize) * 100) / 100,
-            height: calculatedSecondHandLength,
-            opacity: Math.round((secondHandOpacity ?? defaultProps.secondHandOpacity) * 100) / 100
-          }
-        })
-      }
-    ),
-    /* @__PURE__ */ React.createElement(
-      core.Box,
-      {
-        ...getStyles("secondHandCounterweight", {
-          style: {
-            width: Math.round(size * 6e-3 * 3 * 100) / 100,
-            opacity: Math.round((secondHandOpacity ?? defaultProps.secondHandOpacity) * 100) / 100,
-            left: Math.round(
-              size * (secondHandSize ?? defaultProps.secondHandSize) / 2 - size * 6e-3 * 3 / 2
-            )
-          }
-        })
-      }
-    )
-  ), /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("centerBlur") }), /* @__PURE__ */ React.createElement(
-    core.Box,
-    {
-      ...getStyles("centerDot", {
-        style: {
-          width: centerSize,
-          height: centerSize,
-          opacity: Math.round((secondHandOpacity ?? defaultProps.secondHandOpacity) * 100) / 100,
-          top: Math.round(clockRadius - centerSize / 2),
-          left: Math.round(clockRadius - centerSize / 2)
-        }
-      })
-    }
-  ))));
-};
+});
 const Clock = core.factory((_props, ref) => {
   const props = core.useProps("Clock", defaultProps, _props);
   const [time, setTime] = React.useState(/* @__PURE__ */ new Date());
   const [hasMounted, setHasMounted] = React.useState(false);
   const intervalRef = React.useRef(null);
+  const rafRef = React.useRef(null);
   const startTimeRef = React.useRef(null);
   const realStartTimeRef = React.useRef(null);
+  const onTimeChange = hooks.useCallbackRef(_props.onTimeChange);
+  const containerRef = React.useRef(null);
+  const [measuredSize, setMeasuredSize] = React.useState(null);
+  const mergedRef = hooks.useMergedRef(ref, containerRef);
   const {
     // Clock-specific props that should not be passed to DOM
     size,
@@ -513,14 +84,13 @@ const Clock = core.factory((_props, ref) => {
     hourHandOpacity,
     hourHandSize,
     hourHandLength,
-    hourTicksOpacity: _hourTicksOpacity,
-    minuteTicksOpacity: _minuteTicksOpacity,
     hourNumbersDistance,
     primaryNumbersProps,
     secondaryNumbersProps,
     timezone: timezone2,
     running,
     value,
+    ariaLabel,
     withSecondsArc,
     secondsArcFrom,
     secondsArcDirection,
@@ -536,6 +106,17 @@ const Clock = core.factory((_props, ref) => {
     hoursArcDirection,
     hoursArcColor,
     hoursArcOpacity,
+    sectors,
+    faceContent,
+    animateOnMount,
+    animateOnMountDuration,
+    shape,
+    aspectRatio,
+    borderRadius,
+    onTimeChange: _onTimeChange,
+    renderHourHand,
+    renderMinuteHand,
+    renderSecondHand,
     // Styles API props
     classNames,
     style,
@@ -557,19 +138,48 @@ const Clock = core.factory((_props, ref) => {
     vars,
     varsResolver
   });
-  const effectiveSize = Math.round(
+  const resolvedSize = core.useMatches(
+    typeof size === "object" && size !== null && !Array.isArray(size) ? size : { base: size ?? defaultProps.size }
+  );
+  const isAutoSize = resolvedSize === "auto";
+  const effectiveSize = isAutoSize ? measuredSize ?? 400 : Math.round(
     core.px(
       core.getSize(
-        typeof size === "string" && size in defaultClockSizes ? defaultClockSizes[size] : size || defaultProps.size,
+        typeof resolvedSize === "string" && resolvedSize in defaultClockSizes ? defaultClockSizes[resolvedSize] : resolvedSize || defaultProps.size,
         "clock-size"
       )
     )
   );
+  const geometry$1 = React.useMemo(
+    () => geometry.createGeometry(effectiveSize, shape, { aspectRatio, borderRadius }),
+    [effectiveSize, shape, aspectRatio, borderRadius]
+  );
   React.useEffect(() => {
     setHasMounted(true);
   }, []);
+  React.useEffect(() => {
+    if (!isAutoSize || !hasMounted) {
+      return;
+    }
+    const element = containerRef.current;
+    if (!element || typeof ResizeObserver === "undefined") {
+      return;
+    }
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (entry) {
+        const { width, height } = entry.contentRect;
+        const newSize = Math.round(Math.min(width, height));
+        if (newSize > 0) {
+          setMeasuredSize(newSize);
+        }
+      }
+    });
+    observer.observe(element);
+    return () => observer.disconnect();
+  }, [isAutoSize, hasMounted]);
   const getEffectiveTime = () => {
-    const parsedValue = parseTimeValue(value);
+    const parsedValue = clockUtils.parseTimeValue(value);
     if (!running) {
       if (parsedValue) {
         return parsedValue;
@@ -588,10 +198,14 @@ const Clock = core.factory((_props, ref) => {
       clearInterval(intervalRef.current);
       intervalRef.current = null;
     }
+    if (rafRef.current !== null) {
+      cancelAnimationFrame(rafRef.current);
+      rafRef.current = null;
+    }
     if (!running) {
       return;
     }
-    const parsedValue = parseTimeValue(value);
+    const parsedValue = clockUtils.parseTimeValue(value);
     if (parsedValue) {
       startTimeRef.current = parsedValue;
       realStartTimeRef.current = /* @__PURE__ */ new Date();
@@ -599,122 +213,185 @@ const Clock = core.factory((_props, ref) => {
       startTimeRef.current = null;
       realStartTimeRef.current = null;
     }
-    let interval = 1e3;
-    switch (secondHandBehavior) {
-      case "smooth":
-        interval = 16;
-        break;
-      case "tick-half":
-        interval = 500;
-        break;
-      case "tick-high-freq":
-        interval = 125;
-        break;
-      case "tick":
-      default:
-        interval = 1e3;
-        break;
-    }
+    const fireOnTimeChange = (now) => {
+      const tz = timezone2 && timezone2 !== "" ? dayjs(now).tz(timezone2) : dayjs(now);
+      onTimeChange({
+        hours: tz.hour(),
+        minutes: tz.minute(),
+        seconds: tz.second(),
+        milliseconds: tz.millisecond()
+      });
+    };
     const updateTime = () => {
-      setTime(/* @__PURE__ */ new Date());
+      const now = /* @__PURE__ */ new Date();
+      setTime(now);
+      fireOnTimeChange(now);
     };
     updateTime();
-    intervalRef.current = setInterval(updateTime, interval);
+    if (secondHandBehavior === "smooth") {
+      const animate = () => {
+        const now = /* @__PURE__ */ new Date();
+        setTime(now);
+        fireOnTimeChange(now);
+        rafRef.current = requestAnimationFrame(animate);
+      };
+      animate();
+    } else {
+      let interval = 1e3;
+      switch (secondHandBehavior) {
+        case "tick-half":
+          interval = 500;
+          break;
+        case "tick-high-freq":
+          interval = 125;
+          break;
+        case "tick":
+        default:
+          interval = 1e3;
+          break;
+      }
+      intervalRef.current = setInterval(updateTime, interval);
+    }
     return () => {
       if (intervalRef.current) {
         clearInterval(intervalRef.current);
       }
+      if (rafRef.current !== null) {
+        cancelAnimationFrame(rafRef.current);
+      }
     };
-  }, [running, value, secondHandBehavior, secondHandOpacity]);
+  }, [running, value, secondHandBehavior, timezone2]);
   if (!hasMounted) {
-    return /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("root"), ref, ...others }, /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("clockContainer") }, /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("glassWrapper") }, /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("clockFace") }, /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("hourMarks") }, (hourTicksOpacity || 1) !== 0 && Array.from({ length: 12 }, (_, i) => /* @__PURE__ */ React.createElement(
+    return /* @__PURE__ */ React.createElement(
       core.Box,
       {
-        key: `hour-tick-${i}`,
-        ...getStyles("hourTick", {
+        ...getStyles("root", {
           style: {
-            top: Math.round(effectiveSize * 0.028),
-            left: "50%",
-            transformOrigin: `50% ${Math.round(effectiveSize / 2) - Math.round(effectiveSize * 0.028)}px`,
-            transform: `translateX(-50%) rotate(${i * 30}deg)`
+            ...{ "--clock-size": `${effectiveSize}px` },
+            ...isAutoSize ? { width: "100%", height: "100%" } : { width: geometry$1.width, height: geometry$1.height }
           }
-        })
-      }
-    )), (minuteTicksOpacity || 1) !== 0 && Array.from({ length: 60 }, (_, i) => {
-      if (i % 5 === 0) {
-        return null;
-      }
-      return /* @__PURE__ */ React.createElement(
+        }),
+        ref: mergedRef,
+        role: "img",
+        "aria-label": ariaLabel || "Clock",
+        ...others
+      },
+      /* @__PURE__ */ React.createElement(
         core.Box,
         {
-          key: `minute-tick-${i}`,
-          ...getStyles("minuteTick", {
+          ...getStyles("clockContainer", {
             style: {
-              top: Math.round(effectiveSize * 0.028),
-              left: "50%",
-              transformOrigin: `50% ${Math.round(effectiveSize / 2) - Math.round(effectiveSize * 0.028)}px`,
-              transform: `translateX(-50%) rotate(${i * 6}deg)`
-            }
-          })
-        }
-      );
-    }), (primaryNumbersOpacity || 1) !== 0 && [12, 3, 6, 9].map((num) => {
-      const i = num === 12 ? 0 : num;
-      const angle = (i * 30 - 90) * (Math.PI / 180);
-      const clockRadius = Math.round(effectiveSize / 2);
-      const numberRadius = Math.round(clockRadius * (hourNumbersDistance || 0.75));
-      const x = Math.round(clockRadius + Math.cos(angle) * numberRadius);
-      const y = Math.round(clockRadius + Math.sin(angle) * numberRadius);
-      return /* @__PURE__ */ React.createElement(
-        core.Text,
-        {
-          key: `primary-number-${num}`,
-          ...primaryNumbersProps,
-          ...getStyles("primaryNumber", {
-            className: getStyles("number").className,
-            style: {
-              left: x,
-              top: y
+              width: geometry$1.width,
+              height: geometry$1.height
             }
           })
         },
-        num
-      );
-    }), (secondaryNumbersOpacity || 1) !== 0 && [1, 2, 4, 5, 7, 8, 10, 11].map((num) => {
-      const i = num;
-      const angle = (i * 30 - 90) * (Math.PI / 180);
-      const clockRadius = Math.round(effectiveSize / 2);
-      const numberRadius = Math.round(clockRadius * (hourNumbersDistance || 0.75));
-      const x = Math.round(clockRadius + Math.cos(angle) * numberRadius);
-      const y = Math.round(clockRadius + Math.sin(angle) * numberRadius);
-      return /* @__PURE__ */ React.createElement(
-        core.Text,
-        {
-          key: `secondary-number-${num}`,
-          ...secondaryNumbersProps,
-          ...getStyles("secondaryNumber", {
-            className: getStyles("number").className,
-            style: {
-              left: x,
-              top: y
-            }
-          })
-        },
-        num
-      );
-    }))))));
+        /* @__PURE__ */ React.createElement(
+          core.Box,
+          {
+            ...getStyles("glassWrapper", {
+              style: { width: geometry$1.width, height: geometry$1.height }
+            })
+          },
+          /* @__PURE__ */ React.createElement(
+            core.Box,
+            {
+              ...getStyles("clockFace", {
+                style: {
+                  width: geometry$1.width,
+                  height: geometry$1.height,
+                  borderRadius: geometry$1.borderRadius(),
+                  clipPath: geometry$1.clipPath()
+                }
+              })
+            },
+            faceContent && /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("faceContent") }, faceContent),
+            /* @__PURE__ */ React.createElement(
+              ClockFaceStatic.ClockFaceStatic,
+              {
+                getStyles,
+                effectiveSize,
+                geometry: geometry$1,
+                hourTicksOpacity,
+                minuteTicksOpacity,
+                primaryNumbersOpacity,
+                secondaryNumbersOpacity,
+                hourNumbersDistance,
+                primaryNumbersProps,
+                secondaryNumbersProps
+              }
+            )
+          )
+        )
+      )
+    );
   }
   const effectiveTime = getEffectiveTime();
-  return /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("root"), ref, ...others }, /* @__PURE__ */ React.createElement(
-    RealClock,
+  const timezoneTime = timezone2 && timezone2 !== "" ? dayjs(effectiveTime).tz(timezone2) : dayjs(effectiveTime);
+  const computedAriaLabel = ariaLabel || `Clock showing ${String(timezoneTime.hour()).padStart(2, "0")}:${String(timezoneTime.minute()).padStart(2, "0")}:${String(timezoneTime.second()).padStart(2, "0")}`;
+  return /* @__PURE__ */ React.createElement(
+    core.Box,
     {
-      time: effectiveTime,
-      getStyles,
-      effectiveSize,
-      ...props
-    }
-  ));
+      ...getStyles("root", {
+        style: {
+          ...{ "--clock-size": `${effectiveSize}px` },
+          ...isAutoSize ? { width: "100%", height: "100%" } : { width: geometry$1.width, height: geometry$1.height }
+        }
+      }),
+      ref: mergedRef,
+      role: "img",
+      "aria-label": computedAriaLabel,
+      ...others
+    },
+    /* @__PURE__ */ React.createElement(
+      RealClock.RealClock,
+      {
+        time: effectiveTime,
+        getStyles,
+        effectiveSize,
+        geometry: geometry$1,
+        timezone: timezone2,
+        hourHandSize,
+        minuteHandSize,
+        secondHandSize,
+        hourHandLength,
+        minuteHandLength,
+        secondHandLength,
+        secondHandBehavior,
+        secondHandOpacity,
+        minuteHandOpacity,
+        hourHandOpacity,
+        hourTicksOpacity,
+        minuteTicksOpacity,
+        primaryNumbersOpacity,
+        secondaryNumbersOpacity,
+        hourNumbersDistance,
+        primaryNumbersProps,
+        secondaryNumbersProps,
+        withSecondsArc,
+        secondsArcFrom,
+        secondsArcDirection,
+        secondsArcOpacity,
+        withMinutesArc,
+        minutesArcFrom,
+        minutesArcDirection,
+        minutesArcOpacity,
+        withHoursArc,
+        hoursArcFrom,
+        hoursArcDirection,
+        hoursArcOpacity,
+        sectors,
+        faceContent,
+        animateOnMount,
+        animateOnMountDuration,
+        renderHourHand,
+        renderMinuteHand,
+        renderSecondHand
+      }
+    )
+  );
 });
+Clock.Digital = ClockDigital.ClockDigital;
 Clock.classes = Clock_module;
 Clock.displayName = "Clock";