@react-chess-tools/react-chess-clock 1.0.1

package/dist/index.js

@@ -0,0 +1,969 @@
+// src/components/ChessClock/parts/Root.tsx
+import React from "react";
+
+// src/hooks/useChessClockContext.ts
+import { createContext, useContext } from "react";
+var ChessClockContext = createContext(
+  null
+);
+function useChessClockContext() {
+  const context = useContext(ChessClockContext);
+  if (!context) {
+    throw new Error(
+      "useChessClockContext must be used within a ChessClock.Root component. Make sure your component is wrapped with <ChessClock.Root>."
+    );
+  }
+  return context;
+}
+
+// src/hooks/useChessClock.ts
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState
+} from "react";
+
+// src/utils/timeControl.ts
+var TIME_CONTROL_REGEX = /^(\d+(?:\.\d+)?)(?:\+(\d+(?:\.\d+)?))?$/;
+var PERIOD_REGEX = /^(?:(?:(\d+)|sd|g)\/)?(\d+(?:\.\d+)?)(?:\+(\d+(?:\.\d+)?))?$/i;
+function parseTimeControlString(input) {
+  const match = input.match(TIME_CONTROL_REGEX);
+  if (!match) {
+    throw new Error(
+      `Invalid time control string: "${input}". Expected format: "5+3" (minutes + increment) or "10" (minutes only)`
+    );
+  }
+  const minutes = parseFloat(match[1]);
+  const increment = match[2] ? parseFloat(match[2]) : 0;
+  return {
+    baseTime: Math.round(minutes * 60),
+    increment: Math.round(increment)
+  };
+}
+function parsePeriod(periodStr) {
+  const trimmed = periodStr.trim();
+  const match = trimmed.match(PERIOD_REGEX);
+  if (!match) {
+    throw new Error(
+      `Invalid period format: "${trimmed}". Expected format: "40/90+30" or "sd/30+30"`
+    );
+  }
+  const [, movesStr, timeStr, incrementStr] = match;
+  const moves = movesStr ? parseInt(movesStr, 10) : void 0;
+  const minutes = parseFloat(timeStr);
+  const increment = incrementStr ? parseFloat(incrementStr) : 0;
+  return {
+    baseTime: Math.round(minutes * 60),
+    increment: increment > 0 ? Math.round(increment) : void 0,
+    moves
+  };
+}
+function parseMultiPeriodTimeControl(input) {
+  const parts = input.split(/\s*,\s*/);
+  return parts.map((part) => parsePeriod(part));
+}
+function normalizeTimeControl(input, timingMethod, clockStart) {
+  if (Array.isArray(input)) {
+    if (input.length === 0) {
+      throw new Error(
+        "Multi-period time control must have at least one period"
+      );
+    }
+    const periods = input.map((period) => ({
+      ...period,
+      baseTime: period.baseTime * 1e3,
+      increment: period.increment !== void 0 ? period.increment * 1e3 : void 0,
+      delay: period.delay !== void 0 ? period.delay * 1e3 : void 0
+    }));
+    const lastPeriod = periods[periods.length - 1];
+    if (lastPeriod.moves !== void 0) {
+      lastPeriod.moves = void 0;
+    }
+    const firstPeriod = periods[0];
+    return {
+      baseTime: firstPeriod.baseTime,
+      increment: firstPeriod.increment ?? 0,
+      delay: firstPeriod.delay ?? 0,
+      timingMethod,
+      clockStart,
+      periods
+    };
+  }
+  let parsed;
+  if (typeof input === "string") {
+    parsed = parseTimeControlString(input);
+  } else {
+    parsed = input;
+  }
+  return {
+    baseTime: parsed.baseTime * 1e3,
+    // Convert to milliseconds
+    increment: (parsed.increment ?? 0) * 1e3,
+    // Convert to milliseconds
+    delay: (parsed.delay ?? 0) * 1e3,
+    // Convert to milliseconds
+    timingMethod,
+    clockStart
+  };
+}
+function parseTimeControlConfig(config) {
+  const normalized = normalizeTimeControl(
+    config.time,
+    config.timingMethod ?? "fischer",
+    config.clockStart ?? "delayed"
+  );
+  return {
+    ...normalized,
+    whiteTimeOverride: config.whiteTime ? config.whiteTime * 1e3 : void 0,
+    blackTimeOverride: config.blackTime ? config.blackTime * 1e3 : void 0
+  };
+}
+function getInitialTimes(config) {
+  return {
+    white: config.whiteTimeOverride ?? config.baseTime,
+    black: config.blackTimeOverride ?? config.baseTime
+  };
+}
+
+// src/utils/formatTime.ts
+var AUTO_FORMAT_THRESHOLD = 20;
+function formatClockTime(milliseconds, format = "auto") {
+  const clampedMs = Math.max(0, milliseconds);
+  if (format === "auto") {
+    format = clampedMs < AUTO_FORMAT_THRESHOLD * 1e3 ? "ss.d" : "mm:ss";
+  }
+  const totalSeconds = Math.ceil(clampedMs / 1e3);
+  switch (format) {
+    case "ss.d": {
+      const secondsWithDecimal = clampedMs / 1e3;
+      return secondsWithDecimal.toFixed(1);
+    }
+    case "mm:ss": {
+      const totalMinutes = Math.floor(totalSeconds / 60);
+      const seconds = totalSeconds % 60;
+      if (totalMinutes >= 60) {
+        const hours = Math.floor(totalMinutes / 60);
+        const minutes = totalMinutes % 60;
+        return `${hours}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+      }
+      return `${totalMinutes}:${seconds.toString().padStart(2, "0")}`;
+    }
+    case "hh:mm:ss": {
+      const hours = Math.floor(totalSeconds / 3600);
+      const minutes = Math.floor(totalSeconds % 3600 / 60);
+      const seconds = totalSeconds % 60;
+      return `${hours}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+    }
+    default:
+      return String(totalSeconds);
+  }
+}
+
+// src/utils/timingMethods.ts
+function applyFischerIncrement(currentTime, increment) {
+  return currentTime + increment;
+}
+function applyBronsteinDelay(currentTime, timeSpent, delay) {
+  const addBack = Math.min(timeSpent, delay);
+  return currentTime + addBack;
+}
+function calculateSwitchAdjustment(timingMethod, currentTime, timeSpent, config) {
+  switch (timingMethod) {
+    case "fischer":
+      return applyFischerIncrement(currentTime, config.increment);
+    case "delay":
+      return currentTime;
+    case "bronstein":
+      return applyBronsteinDelay(currentTime, timeSpent, config.delay);
+    default:
+      return currentTime;
+  }
+}
+function getInitialActivePlayer(clockStart) {
+  return clockStart === "immediate" ? "white" : null;
+}
+function getInitialStatus(clockStart) {
+  if (clockStart === "immediate") return "running";
+  if (clockStart === "delayed") return "delayed";
+  return "idle";
+}
+
+// src/utils/calculateSwitchTime.ts
+function calculateSwitchTime(currentTime, timeSpent, config) {
+  let effectiveElapsed = timeSpent;
+  if (config.timingMethod === "delay") {
+    effectiveElapsed = Math.max(0, timeSpent - config.delay);
+  }
+  const newTime = Math.max(0, currentTime - effectiveElapsed);
+  return calculateSwitchAdjustment(
+    config.timingMethod,
+    newTime,
+    timeSpent,
+    config
+  );
+}
+
+// src/hooks/clockReducer.ts
+function maybeAdvancePeriod(times, periodState) {
+  let newTimes = times;
+  let newPeriodState = periodState;
+  ["white", "black"].forEach((player) => {
+    const playerPeriodIndex = newPeriodState.periodIndex[player];
+    if (playerPeriodIndex < 0 || playerPeriodIndex >= newPeriodState.periods.length) {
+      return;
+    }
+    const currentPeriod = newPeriodState.periods[playerPeriodIndex];
+    if (!(currentPeriod == null ? void 0 : currentPeriod.moves)) return;
+    const movesRequired = currentPeriod.moves;
+    const playerMoves = newPeriodState.periodMoves[player];
+    if (playerMoves >= movesRequired) {
+      const nextPeriodIndex = playerPeriodIndex + 1;
+      if (nextPeriodIndex >= newPeriodState.periods.length) {
+        return;
+      }
+      const nextPeriod = newPeriodState.periods[nextPeriodIndex];
+      if (!nextPeriod) return;
+      const addedTime = nextPeriod.baseTime;
+      newPeriodState = {
+        ...newPeriodState,
+        periodIndex: {
+          ...newPeriodState.periodIndex,
+          [player]: nextPeriodIndex
+        },
+        periodMoves: {
+          ...newPeriodState.periodMoves,
+          [player]: 0
+        }
+      };
+      newTimes = {
+        ...newTimes,
+        [player]: newTimes[player] + addedTime
+      };
+    }
+  });
+  return { times: newTimes, periodState: newPeriodState };
+}
+function clockReducer(state, action) {
+  var _a, _b, _c;
+  switch (action.type) {
+    case "START": {
+      if (state.status === "finished") return state;
+      if (state.status === "delayed") {
+        return state;
+      }
+      const now = ((_a = action.payload) == null ? void 0 : _a.now) ?? Date.now();
+      return {
+        ...state,
+        status: "running",
+        activePlayer: state.activePlayer ?? "white",
+        // Initialize move start time if not already set
+        moveStartTime: state.moveStartTime ?? now
+      };
+    }
+    case "PAUSE": {
+      if (state.status !== "running") return state;
+      const now = ((_b = action.payload) == null ? void 0 : _b.now) ?? Date.now();
+      const elapsedAtPause = state.moveStartTime !== null ? now - state.moveStartTime : 0;
+      return {
+        ...state,
+        status: "paused",
+        elapsedAtPause,
+        moveStartTime: null
+      };
+    }
+    case "RESUME": {
+      if (state.status !== "paused") return state;
+      const now = ((_c = action.payload) == null ? void 0 : _c.now) ?? Date.now();
+      return {
+        ...state,
+        status: "running",
+        moveStartTime: now - state.elapsedAtPause,
+        elapsedAtPause: 0
+      };
+    }
+    case "SWITCH": {
+      if (state.status === "finished") return state;
+      let newPeriodState = state.periodState;
+      const movedPlayer = state.activePlayer;
+      const now = action.payload.now ?? Date.now();
+      if (state.status === "delayed") {
+        const newCount = state.switchCount + 1;
+        const newPlayer2 = newCount % 2 === 1 ? "black" : "white";
+        const delayedMovePlayer = newCount % 2 === 1 ? "white" : "black";
+        if (state.periodState) {
+          newPeriodState = {
+            ...state.periodState,
+            periodMoves: {
+              ...state.periodState.periodMoves,
+              [delayedMovePlayer]: state.periodState.periodMoves[delayedMovePlayer] + 1
+            }
+          };
+        }
+        if (newPeriodState) {
+          const advanced = maybeAdvancePeriod(state.times, newPeriodState);
+          newPeriodState = advanced.periodState;
+        }
+        const newStateStatus = newCount >= 2 ? "running" : "delayed";
+        return {
+          ...state,
+          activePlayer: newPlayer2,
+          switchCount: newCount,
+          status: newStateStatus,
+          periodState: newPeriodState,
+          // Start timing when transitioning to running
+          moveStartTime: newStateStatus === "running" ? now : state.moveStartTime
+        };
+      }
+      if (movedPlayer === null) return state;
+      const { newTimes } = action.payload;
+      const newPlayer = movedPlayer === "white" ? "black" : "white";
+      if (state.periodState) {
+        newPeriodState = {
+          ...state.periodState,
+          periodMoves: {
+            ...state.periodState.periodMoves,
+            [movedPlayer]: state.periodState.periodMoves[movedPlayer] + 1
+          }
+        };
+      }
+      let resolvedTimes = newTimes ?? state.times;
+      if (newPeriodState) {
+        const advanced = maybeAdvancePeriod(resolvedTimes, newPeriodState);
+        resolvedTimes = advanced.times;
+        newPeriodState = advanced.periodState;
+      }
+      const newStatus = state.status === "idle" ? "running" : state.status;
+      return {
+        ...state,
+        activePlayer: newPlayer,
+        times: resolvedTimes,
+        switchCount: state.switchCount + 1,
+        periodState: newPeriodState,
+        status: newStatus,
+        // Reset timing for the new player
+        moveStartTime: newStatus === "running" ? now : null,
+        elapsedAtPause: 0
+      };
+    }
+    case "TIMEOUT": {
+      const { player } = action.payload;
+      return {
+        ...state,
+        status: "finished",
+        timeout: player,
+        times: { ...state.times, [player]: 0 }
+      };
+    }
+    case "RESET": {
+      const config = parseTimeControlConfig(action.payload);
+      const initialTimes = getInitialTimes(config);
+      const now = action.payload.now;
+      const periodState = config.periods ? {
+        periodIndex: { white: 0, black: 0 },
+        periodMoves: { white: 0, black: 0 },
+        periods: config.periods
+      } : void 0;
+      return createInitialClockState(
+        initialTimes,
+        getInitialStatus(config.clockStart),
+        getInitialActivePlayer(config.clockStart),
+        config,
+        periodState,
+        now
+      );
+    }
+    case "ADD_TIME": {
+      const { player, milliseconds } = action.payload;
+      const now = action.payload.now ?? Date.now();
+      const newTimes = {
+        ...state.times,
+        [player]: state.times[player] + milliseconds
+      };
+      const resetElapsed = state.status === "paused" && player === state.activePlayer;
+      return {
+        ...state,
+        times: newTimes,
+        moveStartTime: state.status === "running" ? now : null,
+        ...resetElapsed && { elapsedAtPause: 0 }
+      };
+    }
+    case "SET_TIME": {
+      const { player, milliseconds } = action.payload;
+      const now = action.payload.now ?? Date.now();
+      const newTimes = {
+        ...state.times,
+        [player]: Math.max(0, milliseconds)
+      };
+      const resetElapsed = state.status === "paused" && player === state.activePlayer;
+      return {
+        ...state,
+        times: newTimes,
+        moveStartTime: state.status === "running" ? now : null,
+        ...resetElapsed && { elapsedAtPause: 0 }
+      };
+    }
+    default:
+      return state;
+  }
+}
+function createInitialClockState(initialTimes, status, activePlayer, config, periodState, now) {
+  return {
+    times: initialTimes,
+    initialTimes,
+    status,
+    activePlayer,
+    timeout: null,
+    switchCount: 0,
+    periodState,
+    config,
+    // If starting immediately, initialize the move start time
+    moveStartTime: status === "running" ? now ?? Date.now() : null,
+    elapsedAtPause: 0
+  };
+}
+
+// src/hooks/useChessClock.ts
+var DISABLED_CLOCK_CONFIG = {
+  time: { baseTime: 0 }
+};
+function serializeTimeRelevantConfig(config) {
+  return JSON.stringify({
+    time: config.time,
+    timingMethod: config.timingMethod,
+    clockStart: config.clockStart,
+    whiteTime: config.whiteTime,
+    blackTime: config.blackTime
+  });
+}
+function calculateDisplayTime(baseTime, moveStartTime, elapsedAtPause, timingMethod, delay) {
+  if (moveStartTime === null) {
+    let effectiveElapsed2 = elapsedAtPause;
+    if (timingMethod === "delay") {
+      effectiveElapsed2 = Math.max(0, elapsedAtPause - delay);
+    }
+    return Math.max(0, baseTime - effectiveElapsed2);
+  }
+  const now = Date.now();
+  const rawElapsed = now - moveStartTime;
+  let effectiveElapsed = rawElapsed;
+  if (timingMethod === "delay") {
+    effectiveElapsed = Math.max(0, rawElapsed - delay);
+  }
+  return Math.max(0, baseTime - effectiveElapsed);
+}
+function useChessClock(options) {
+  const [state, dispatch] = useReducer(clockReducer, null, () => {
+    const initialConfig = parseTimeControlConfig(options);
+    const initialTimesValue = getInitialTimes(initialConfig);
+    const initialPeriodState = initialConfig.periods && initialConfig.periods.length > 1 ? {
+      periodIndex: { white: 0, black: 0 },
+      periodMoves: { white: 0, black: 0 },
+      periods: initialConfig.periods
+    } : void 0;
+    return createInitialClockState(
+      initialTimesValue,
+      getInitialStatus(initialConfig.clockStart),
+      getInitialActivePlayer(initialConfig.clockStart),
+      initialConfig,
+      initialPeriodState
+    );
+  });
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const configKey = serializeTimeRelevantConfig(options);
+  const prevConfigRef = useRef(configKey);
+  useEffect(() => {
+    if (prevConfigRef.current !== configKey) {
+      prevConfigRef.current = configKey;
+      dispatch({ type: "RESET", payload: { ...options, now: Date.now() } });
+    }
+  }, [configKey, options]);
+  const [tick, forceUpdate] = useState(0);
+  const displayTimes = state.activePlayer === null ? state.times : {
+    ...state.times,
+    [state.activePlayer]: calculateDisplayTime(
+      state.times[state.activePlayer],
+      state.moveStartTime,
+      state.elapsedAtPause,
+      state.config.timingMethod,
+      state.config.delay
+    )
+  };
+  const activePlayerTimedOut = state.status === "running" && state.activePlayer !== null && displayTimes[state.activePlayer] <= 0;
+  useEffect(() => {
+    if (state.status !== "running" || state.activePlayer === null) {
+      return;
+    }
+    const intervalId = setInterval(() => forceUpdate((c) => c + 1), 100);
+    return () => clearInterval(intervalId);
+  }, [state.status, state.activePlayer]);
+  useEffect(() => {
+    var _a, _b;
+    if (state.status === "running" && state.activePlayer !== null) {
+      (_b = (_a = optionsRef.current).onTimeUpdate) == null ? void 0 : _b.call(_a, displayTimes);
+    }
+  }, [tick]);
+  useEffect(() => {
+    var _a, _b;
+    if (activePlayerTimedOut && state.activePlayer !== null) {
+      dispatch({ type: "TIMEOUT", payload: { player: state.activePlayer } });
+      (_b = (_a = optionsRef.current).onTimeout) == null ? void 0 : _b.call(_a, state.activePlayer);
+    }
+  }, [activePlayerTimedOut, state.activePlayer]);
+  const previousActivePlayerRef = useRef(state.activePlayer);
+  useEffect(() => {
+    var _a, _b;
+    if (state.activePlayer !== previousActivePlayerRef.current && state.activePlayer !== null) {
+      (_b = (_a = optionsRef.current).onSwitch) == null ? void 0 : _b.call(_a, state.activePlayer);
+    }
+    previousActivePlayerRef.current = state.activePlayer;
+  }, [state.activePlayer]);
+  const info = useMemo(
+    () => ({
+      isRunning: state.status === "running",
+      isPaused: state.status === "paused",
+      isFinished: state.status === "finished",
+      isWhiteActive: state.activePlayer === "white",
+      isBlackActive: state.activePlayer === "black",
+      hasTimeout: state.timeout !== null,
+      // Time odds is based on initial configuration, not current remaining time
+      hasTimeOdds: state.initialTimes.white !== state.initialTimes.black
+    }),
+    [
+      state.status,
+      state.activePlayer,
+      state.timeout,
+      state.initialTimes.white,
+      state.initialTimes.black
+    ]
+  );
+  const start = useCallback(() => {
+    dispatch({ type: "START", payload: { now: Date.now() } });
+  }, []);
+  const pause = useCallback(() => {
+    dispatch({ type: "PAUSE", payload: { now: Date.now() } });
+  }, []);
+  const resume = useCallback(() => {
+    dispatch({ type: "RESUME", payload: { now: Date.now() } });
+  }, []);
+  const switchPlayer = useCallback(() => {
+    const currentState = stateRef.current;
+    const now = Date.now();
+    let newTimes;
+    if (currentState.status !== "delayed" && currentState.activePlayer && currentState.moveStartTime !== null) {
+      const timeSpent = now - currentState.moveStartTime;
+      const currentTime = currentState.times[currentState.activePlayer];
+      const newTime = calculateSwitchTime(
+        currentTime,
+        timeSpent,
+        currentState.config
+      );
+      newTimes = {
+        ...currentState.times,
+        [currentState.activePlayer]: newTime
+      };
+    }
+    dispatch({ type: "SWITCH", payload: { newTimes, now } });
+  }, []);
+  const reset = useCallback((newTimeControl) => {
+    const currentOptions = optionsRef.current;
+    const resetConfig = newTimeControl ? { ...currentOptions, time: newTimeControl } : currentOptions;
+    dispatch({ type: "RESET", payload: { ...resetConfig, now: Date.now() } });
+  }, []);
+  const addTime = useCallback((player, milliseconds) => {
+    dispatch({
+      type: "ADD_TIME",
+      payload: { player, milliseconds, now: Date.now() }
+    });
+  }, []);
+  const setTime = useCallback((player, milliseconds) => {
+    dispatch({
+      type: "SET_TIME",
+      payload: { player, milliseconds, now: Date.now() }
+    });
+  }, []);
+  const methods = useMemo(
+    () => ({
+      start,
+      pause,
+      resume,
+      switch: switchPlayer,
+      reset,
+      addTime,
+      setTime
+    }),
+    [start, pause, resume, switchPlayer, reset, addTime, setTime]
+  );
+  const periodInfo = useMemo(() => {
+    if (!state.periodState) {
+      return {
+        currentPeriodIndex: { white: 0, black: 0 },
+        totalPeriods: 1,
+        currentPeriod: {
+          white: {
+            baseTime: state.config.baseTime / 1e3,
+            increment: state.config.increment / 1e3,
+            delay: state.config.delay / 1e3
+          },
+          black: {
+            baseTime: state.config.baseTime / 1e3,
+            increment: state.config.increment / 1e3,
+            delay: state.config.delay / 1e3
+          }
+        },
+        periodMoves: { white: 0, black: 0 }
+      };
+    }
+    const periods = state.periodState.periods;
+    const getCurrentPeriod = (periodIndex) => {
+      const period = periodIndex >= 0 && periodIndex < periods.length ? periods[periodIndex] : periods[0];
+      return {
+        ...period,
+        baseTime: period.baseTime / 1e3,
+        increment: period.increment !== void 0 ? period.increment / 1e3 : void 0,
+        delay: period.delay !== void 0 ? period.delay / 1e3 : void 0
+      };
+    };
+    return {
+      currentPeriodIndex: state.periodState.periodIndex,
+      totalPeriods: periods.length,
+      currentPeriod: {
+        white: getCurrentPeriod(state.periodState.periodIndex.white),
+        black: getCurrentPeriod(state.periodState.periodIndex.black)
+      },
+      periodMoves: state.periodState.periodMoves
+    };
+  }, [state.periodState, state.config]);
+  return {
+    times: displayTimes,
+    initialTimes: state.initialTimes,
+    status: state.status,
+    activePlayer: state.activePlayer,
+    timeout: state.timeout,
+    timingMethod: state.config.timingMethod,
+    info,
+    ...periodInfo,
+    methods
+  };
+}
+function useOptionalChessClock(options) {
+  const result = useChessClock(options ?? DISABLED_CLOCK_CONFIG);
+  return options === void 0 ? null : result;
+}
+
+// src/components/ChessClock/parts/Root.tsx
+var Root = ({
+  timeControl,
+  children
+}) => {
+  const clockState = useChessClock(timeControl);
+  return /* @__PURE__ */ React.createElement(ChessClockContext.Provider, { value: clockState }, children);
+};
+Root.displayName = "ChessClock.Root";
+
+// src/components/ChessClock/parts/Display.tsx
+import React2 from "react";
+var Display = React2.forwardRef(
+  ({
+    color,
+    format = "auto",
+    formatTime: customFormatTime,
+    className,
+    style,
+    ...rest
+  }, ref) => {
+    const { times, activePlayer, status, timeout } = useChessClockContext();
+    const time = times[color];
+    const isActive = activePlayer === color;
+    const hasTimeout = timeout === color;
+    const isPaused = status === "paused";
+    const formattedTime = customFormatTime ? customFormatTime(time) : formatClockTime(time, format);
+    return /* @__PURE__ */ React2.createElement(
+      "div",
+      {
+        ref,
+        className,
+        style,
+        "data-clock-color": color,
+        "data-clock-active": isActive ? "true" : "false",
+        "data-clock-paused": isPaused ? "true" : "false",
+        "data-clock-timeout": hasTimeout ? "true" : "false",
+        "data-clock-status": status,
+        ...rest
+      },
+      formattedTime
+    );
+  }
+);
+Display.displayName = "ChessClock.Display";
+
+// src/components/ChessClock/parts/Switch.tsx
+import React3 from "react";
+import { Slot } from "@radix-ui/react-slot";
+var Switch = React3.forwardRef(
+  ({
+    asChild = false,
+    children,
+    onClick,
+    disabled,
+    className,
+    style,
+    type,
+    ...rest
+  }, ref) => {
+    const { methods, status } = useChessClockContext();
+    const isDisabled = disabled || status === "finished" || status === "idle";
+    const handleClick = React3.useCallback(
+      (e) => {
+        methods.switch();
+        onClick == null ? void 0 : onClick(e);
+      },
+      [methods, onClick]
+    );
+    return asChild ? /* @__PURE__ */ React3.createElement(
+      Slot,
+      {
+        ref,
+        onClick: handleClick,
+        className,
+        style,
+        ...{ ...rest, disabled: isDisabled }
+      },
+      children
+    ) : /* @__PURE__ */ React3.createElement(
+      "button",
+      {
+        ref,
+        type: type || "button",
+        className,
+        style,
+        onClick: handleClick,
+        disabled: isDisabled,
+        ...rest
+      },
+      children
+    );
+  }
+);
+Switch.displayName = "ChessClock.Switch";
+
+// src/components/ChessClock/parts/PlayPause.tsx
+import React4 from "react";
+import { Slot as Slot2 } from "@radix-ui/react-slot";
+var DEFAULT_CONTENT = {
+  start: "Start",
+  pause: "Pause",
+  resume: "Resume",
+  delayed: "Start",
+  finished: "Game Over"
+};
+var resolveContent = (isFinished, isDelayed, shouldShowStart, isPaused, isRunning, customContent) => {
+  if (isFinished) {
+    return customContent.finishedContent ?? DEFAULT_CONTENT.finished;
+  }
+  if (isDelayed) {
+    return customContent.delayedContent ?? DEFAULT_CONTENT.delayed;
+  }
+  if (shouldShowStart) {
+    return customContent.startContent ?? DEFAULT_CONTENT.start;
+  }
+  if (isPaused) {
+    return customContent.resumeContent ?? DEFAULT_CONTENT.resume;
+  }
+  if (isRunning) {
+    return customContent.pauseContent ?? DEFAULT_CONTENT.pause;
+  }
+  return DEFAULT_CONTENT.start;
+};
+var PlayPause = React4.forwardRef(
+  ({
+    asChild = false,
+    startContent,
+    pauseContent,
+    resumeContent,
+    delayedContent,
+    finishedContent,
+    children,
+    onClick,
+    disabled,
+    className,
+    style,
+    type,
+    ...rest
+  }, ref) => {
+    const { status, methods } = useChessClockContext();
+    const isIdle = status === "idle";
+    const isDelayed = status === "delayed";
+    const isPaused = status === "paused";
+    const isRunning = status === "running";
+    const isFinished = status === "finished";
+    const shouldShowStart = isIdle || isDelayed;
+    const isDisabled = disabled || isFinished || isDelayed;
+    const handleClick = React4.useCallback(
+      (e) => {
+        if (shouldShowStart) {
+          methods.start();
+        } else if (isPaused) {
+          methods.resume();
+        } else if (isRunning) {
+          methods.pause();
+        }
+        onClick == null ? void 0 : onClick(e);
+      },
+      [shouldShowStart, isPaused, isRunning, methods, onClick]
+    );
+    const content = children ?? resolveContent(
+      isFinished,
+      isDelayed,
+      shouldShowStart,
+      isPaused,
+      isRunning,
+      {
+        startContent,
+        pauseContent,
+        resumeContent,
+        delayedContent,
+        finishedContent
+      }
+    );
+    return asChild ? /* @__PURE__ */ React4.createElement(
+      Slot2,
+      {
+        ref,
+        onClick: handleClick,
+        className,
+        style,
+        ...{ ...rest, disabled: isDisabled }
+      },
+      content
+    ) : /* @__PURE__ */ React4.createElement(
+      "button",
+      {
+        ref,
+        type: type || "button",
+        className,
+        style,
+        onClick: handleClick,
+        disabled: isDisabled,
+        ...rest
+      },
+      content
+    );
+  }
+);
+PlayPause.displayName = "ChessClock.PlayPause";
+
+// src/components/ChessClock/parts/Reset.tsx
+import React5 from "react";
+import { Slot as Slot3 } from "@radix-ui/react-slot";
+var Reset = React5.forwardRef(
+  ({
+    asChild = false,
+    timeControl,
+    children,
+    onClick,
+    disabled,
+    className,
+    style,
+    type,
+    ...rest
+  }, ref) => {
+    const { methods, status } = useChessClockContext();
+    const isDisabled = disabled || status === "idle";
+    const handleClick = React5.useCallback(
+      (e) => {
+        methods.reset(timeControl);
+        onClick == null ? void 0 : onClick(e);
+      },
+      [methods, timeControl, onClick]
+    );
+    return asChild ? /* @__PURE__ */ React5.createElement(
+      Slot3,
+      {
+        ref,
+        onClick: handleClick,
+        className,
+        style,
+        ...{ ...rest, disabled: isDisabled }
+      },
+      children
+    ) : /* @__PURE__ */ React5.createElement(
+      "button",
+      {
+        ref,
+        type: type || "button",
+        className,
+        style,
+        onClick: handleClick,
+        disabled: isDisabled,
+        ...rest
+      },
+      children
+    );
+  }
+);
+Reset.displayName = "ChessClock.Reset";
+
+// src/components/ChessClock/index.ts
+var ChessClock = {
+  Root,
+  Display,
+  Switch,
+  PlayPause,
+  Reset
+};
+
+// src/utils/presets.ts
+var presets = {
+  // Bullet (< 3 minutes)
+  bullet1_0: { baseTime: 60, increment: 0 },
+  bullet1_1: { baseTime: 60, increment: 1 },
+  bullet2_1: { baseTime: 120, increment: 1 },
+  // Blitz (3-10 minutes)
+  blitz3_0: { baseTime: 180, increment: 0 },
+  blitz3_2: { baseTime: 180, increment: 2 },
+  blitz5_0: { baseTime: 300, increment: 0 },
+  blitz5_3: { baseTime: 300, increment: 3 },
+  // Rapid (10-60 minutes)
+  rapid10_0: { baseTime: 600, increment: 0 },
+  rapid10_5: { baseTime: 600, increment: 5 },
+  rapid15_10: { baseTime: 900, increment: 10 },
+  // Classical (≥ 60 minutes)
+  classical30_0: { baseTime: 1800, increment: 0 },
+  classical90_30: { baseTime: 5400, increment: 30 },
+  // Tournament (multi-period)
+  fideClassical: [
+    { baseTime: 5400, increment: 30, moves: 40 },
+    { baseTime: 1800, increment: 30, moves: 20 },
+    { baseTime: 900, increment: 30 }
+  ],
+  uscfClassical: [
+    { baseTime: 7200, moves: 40 },
+    { baseTime: 3600, moves: 20 },
+    { baseTime: 1800 }
+  ]
+};
+export {
+  ChessClock,
+  ChessClockContext,
+  Display,
+  PlayPause,
+  Reset,
+  Switch,
+  formatClockTime,
+  getInitialTimes,
+  normalizeTimeControl,
+  parseMultiPeriodTimeControl,
+  parseTimeControlConfig,
+  parseTimeControlString,
+  presets,
+  useChessClock,
+  useChessClockContext,
+  useOptionalChessClock
+};
+//# sourceMappingURL=index.js.map