@shiftbloom-studio/circadian-ui 0.2.0

package/dist/index.cjs

@@ -0,0 +1,890 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/core/schedule.ts
+var defaultSchedule = {
+  dawn: { start: "05:30", end: "08:30" },
+  day: { start: "08:30", end: "17:30" },
+  dusk: { start: "17:30", end: "21:30" },
+  night: { start: "21:30", end: "05:30" }
+};
+var minutesInDay = 24 * 60;
+var parseTimeToMinutes = (value) => {
+  const [hours, minutes] = value.split(":").map(Number);
+  if (Number.isNaN(hours) || Number.isNaN(minutes)) {
+    throw new Error(`Invalid time format: ${value}`);
+  }
+  return (hours % 24 * 60 + minutes) % minutesInDay;
+};
+var normalizeSchedule = (schedule) => {
+  const merged = {
+    ...defaultSchedule,
+    ...schedule,
+    dawn: { ...defaultSchedule.dawn, ...schedule?.dawn },
+    day: { ...defaultSchedule.day, ...schedule?.day },
+    dusk: { ...defaultSchedule.dusk, ...schedule?.dusk },
+    night: { ...defaultSchedule.night, ...schedule?.night }
+  };
+  return {
+    dawn: {
+      start: parseTimeToMinutes(merged.dawn.start),
+      end: parseTimeToMinutes(merged.dawn.end)
+    },
+    day: {
+      start: parseTimeToMinutes(merged.day.start),
+      end: parseTimeToMinutes(merged.day.end)
+    },
+    dusk: {
+      start: parseTimeToMinutes(merged.dusk.start),
+      end: parseTimeToMinutes(merged.dusk.end)
+    },
+    night: {
+      start: parseTimeToMinutes(merged.night.start),
+      end: parseTimeToMinutes(merged.night.end)
+    }
+  };
+};
+var getMinutesFromDate = (date) => date.getHours() * 60 + date.getMinutes();
+var isWithinRange = (minutes, start, end) => {
+  if (start === end) {
+    return true;
+  }
+  if (start < end) {
+    return minutes >= start && minutes < end;
+  }
+  return minutes >= start || minutes < end;
+};
+var getPhaseFromTime = (date, schedule) => {
+  const minutes = getMinutesFromDate(date);
+  const normalized = normalizeSchedule(schedule);
+  const phases = ["dawn", "day", "dusk", "night"];
+  for (const phase of phases) {
+    const window2 = normalized[phase];
+    if (isWithinRange(minutes, window2.start, window2.end)) {
+      return phase;
+    }
+  }
+  return "night";
+};
+var computeNextTransition = (date, schedule) => {
+  const normalized = normalizeSchedule(schedule);
+  const currentPhase = getPhaseFromTime(date, schedule);
+  const minutes = getMinutesFromDate(date);
+  const endMinutes = normalized[currentPhase].end;
+  let delta = endMinutes - minutes;
+  if (delta <= 0) {
+    delta += minutesInDay;
+  }
+  return new Date(date.getTime() + delta * 60 * 1e3);
+};
+
+// src/core/sun.ts
+var minutesInDay2 = 24 * 60;
+var defaultSunSchedule = {
+  dawnOffsetMinutesBefore: 45,
+  dawnOffsetMinutesAfter: 45,
+  duskOffsetMinutesBefore: 45,
+  duskOffsetMinutesAfter: 45
+};
+var normalizeMinutes = (value) => (value % minutesInDay2 + minutesInDay2) % minutesInDay2;
+var deriveSunSchedule = (date, sunTimes, options) => {
+  const config = { ...defaultSunSchedule, ...options };
+  const sunriseMinutes = getMinutesFromDate(sunTimes.sunrise);
+  const sunsetMinutes = getMinutesFromDate(sunTimes.sunset);
+  const dawnStart = normalizeMinutes(sunriseMinutes - config.dawnOffsetMinutesBefore);
+  const dawnEnd = normalizeMinutes(sunriseMinutes + config.dawnOffsetMinutesAfter);
+  const duskStart = normalizeMinutes(sunsetMinutes - config.duskOffsetMinutesBefore);
+  const duskEnd = normalizeMinutes(sunsetMinutes + config.duskOffsetMinutesAfter);
+  return {
+    dawn: { start: dawnStart, end: dawnEnd },
+    day: { start: dawnEnd, end: duskStart },
+    dusk: { start: duskStart, end: duskEnd },
+    night: { start: duskEnd, end: dawnStart }
+  };
+};
+var getPhaseFromSunTimes = (date, sunTimes, options) => {
+  const schedule = deriveSunSchedule(date, sunTimes, options);
+  const minutes = getMinutesFromDate(date);
+  const phases = ["dawn", "day", "dusk", "night"];
+  for (const phase of phases) {
+    const window2 = schedule[phase];
+    const start = window2.start;
+    const end = window2.end;
+    if (start === end) {
+      return phase;
+    }
+    if (start < end && minutes >= start && minutes < end) {
+      return phase;
+    }
+    if (start > end && (minutes >= start || minutes < end)) {
+      return phase;
+    }
+  }
+  return "night";
+};
+var getScheduleFromProvider = (date, provider, options) => {
+  if (!provider) {
+    return null;
+  }
+  const sunTimes = provider(date);
+  if (!sunTimes) {
+    return null;
+  }
+  const schedule = deriveSunSchedule(date, sunTimes, options);
+  const toTimeString = (minutes) => {
+    const normalized = normalizeMinutes(minutes);
+    const hours = Math.floor(normalized / 60).toString().padStart(2, "0");
+    const mins = (normalized % 60).toString().padStart(2, "0");
+    return `${hours}:${mins}`;
+  };
+  return {
+    dawn: {
+      start: toTimeString(schedule.dawn.start),
+      end: toTimeString(schedule.dawn.end)
+    },
+    day: {
+      start: toTimeString(schedule.day.start),
+      end: toTimeString(schedule.day.end)
+    },
+    dusk: {
+      start: toTimeString(schedule.dusk.start),
+      end: toTimeString(schedule.dusk.end)
+    },
+    night: {
+      start: toTimeString(schedule.night.start),
+      end: toTimeString(schedule.night.end)
+    }
+  };
+};
+
+// src/core/tokens.ts
+var defaultTokens = {
+  dawn: {
+    bg: "27 60% 96%",
+    fg: "24 18% 18%",
+    muted: "27 40% 90%",
+    mutedFg: "24 14% 35%",
+    card: "0 0% 100%",
+    cardFg: "24 18% 18%",
+    border: "24 22% 84%",
+    ring: "20 65% 45%",
+    accent: "20 80% 92%",
+    accentFg: "20 40% 30%",
+    destructive: "0 74% 55%",
+    destructiveFg: "0 0% 100%"
+  },
+  day: {
+    bg: "0 0% 100%",
+    fg: "222 28% 14%",
+    muted: "210 20% 96%",
+    mutedFg: "215 16% 35%",
+    card: "0 0% 100%",
+    cardFg: "222 28% 14%",
+    border: "214 20% 90%",
+    ring: "220 65% 45%",
+    accent: "220 90% 95%",
+    accentFg: "220 45% 30%",
+    destructive: "0 72% 55%",
+    destructiveFg: "0 0% 100%"
+  },
+  dusk: {
+    bg: "240 24% 14%",
+    fg: "30 40% 95%",
+    muted: "245 20% 22%",
+    mutedFg: "30 20% 80%",
+    card: "240 22% 16%",
+    cardFg: "30 40% 95%",
+    border: "245 16% 30%",
+    ring: "32 70% 60%",
+    accent: "32 55% 25%",
+    accentFg: "32 70% 85%",
+    destructive: "0 70% 55%",
+    destructiveFg: "0 0% 100%"
+  },
+  night: {
+    bg: "230 22% 10%",
+    fg: "210 40% 96%",
+    muted: "230 18% 16%",
+    mutedFg: "210 20% 80%",
+    card: "230 20% 12%",
+    cardFg: "210 40% 96%",
+    border: "230 16% 24%",
+    ring: "210 80% 60%",
+    accent: "210 35% 20%",
+    accentFg: "210 50% 90%",
+    destructive: "0 65% 55%",
+    destructiveFg: "0 0% 100%"
+  }
+};
+var cssVarMap = {
+  bg: "--cui-bg",
+  fg: "--cui-fg",
+  muted: "--cui-muted",
+  mutedFg: "--cui-muted-fg",
+  card: "--cui-card",
+  cardFg: "--cui-card-fg",
+  border: "--cui-border",
+  ring: "--cui-ring",
+  accent: "--cui-accent",
+  accentFg: "--cui-accent-fg",
+  destructive: "--cui-destructive",
+  destructiveFg: "--cui-destructive-fg"
+};
+var resolveTokens = (phase, overrides) => {
+  return {
+    ...defaultTokens[phase],
+    ...overrides?.[phase]
+  };
+};
+var tokensToCssVars = (tokens) => {
+  const vars = {};
+  for (const [key, value] of Object.entries(tokens)) {
+    const cssVar = cssVarMap[key];
+    vars[cssVar] = value;
+  }
+  return vars;
+};
+var applyTokensToElement = (element, tokens) => {
+  const vars = tokensToCssVars(tokens);
+  for (const [key, value] of Object.entries(vars)) {
+    element.style.setProperty(key, value);
+  }
+};
+var applyColorSchemeBias = (tokens, prefers, bias) => {
+  if (prefers === "no-preference") {
+    return tokens;
+  }
+  const delta = prefers === "dark" ? bias.dark : bias.light;
+  const adjust = (value) => {
+    const [h, s, l] = value.split(" ");
+    const lightness = Math.max(0, Math.min(100, Number(l.replace("%", "")) + delta));
+    return `${h} ${s} ${lightness}%`;
+  };
+  return {
+    ...tokens,
+    bg: adjust(tokens.bg),
+    fg: adjust(tokens.fg),
+    muted: adjust(tokens.muted),
+    mutedFg: adjust(tokens.mutedFg),
+    card: adjust(tokens.card),
+    cardFg: adjust(tokens.cardFg),
+    border: adjust(tokens.border),
+    ring: adjust(tokens.ring),
+    accent: adjust(tokens.accent),
+    accentFg: adjust(tokens.accentFg),
+    destructive: adjust(tokens.destructive),
+    destructiveFg: adjust(tokens.destructiveFg)
+  };
+};
+
+// src/core/contrast.ts
+var clamp = (value, min = 0, max = 100) => Math.min(max, Math.max(min, value));
+var parseHsl = (value) => {
+  const [h, s, l] = value.split(" ");
+  return [Number(h), Number(s.replace("%", "")) / 100, Number(l.replace("%", "")) / 100];
+};
+var hslToRgb = (h, s, l) => {
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  if (h >= 0 && h < 60) {
+    r = c;
+    g = x;
+  } else if (h < 120) {
+    r = x;
+    g = c;
+  } else if (h < 180) {
+    g = c;
+    b = x;
+  } else if (h < 240) {
+    g = x;
+    b = c;
+  } else if (h < 300) {
+    r = x;
+    b = c;
+  } else {
+    r = c;
+    b = x;
+  }
+  return [r + m, g + m, b + m];
+};
+var relativeLuminance = (hsl) => {
+  const [h, s, l] = parseHsl(hsl);
+  const [r, g, b] = hslToRgb(h, s, l).map((channel) => {
+    const linear = channel <= 0.03928 ? channel / 12.92 : Math.pow((channel + 0.055) / 1.055, 2.4);
+    return linear;
+  });
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+};
+var contrastRatio = (foreground, background) => {
+  const lum1 = relativeLuminance(foreground);
+  const lum2 = relativeLuminance(background);
+  const lighter = Math.max(lum1, lum2);
+  const darker = Math.min(lum1, lum2);
+  return (lighter + 0.05) / (darker + 0.05);
+};
+var adjustLightness = (value, delta) => {
+  const [h, s, l] = value.split(" ");
+  const lightness = clamp(Number(l.replace("%", "")) + delta);
+  return `${h} ${s} ${lightness}%`;
+};
+var ensurePairContrast = (background, foreground, options) => {
+  let current = foreground;
+  if (contrastRatio(current, background) >= options.minimumRatio) {
+    return current;
+  }
+  const foregroundLum = relativeLuminance(foreground);
+  const backgroundLum = relativeLuminance(background);
+  const moveDarker = foregroundLum < backgroundLum;
+  const step = moveDarker ? -2 : 2;
+  for (let i = 0; i < options.maxIterations; i += 1) {
+    current = adjustLightness(current, step);
+    if (contrastRatio(current, background) >= options.minimumRatio) {
+      return current;
+    }
+  }
+  return current;
+};
+var ensureContrast = (tokens, options) => {
+  return {
+    ...tokens,
+    fg: ensurePairContrast(tokens.bg, tokens.fg, options),
+    mutedFg: ensurePairContrast(tokens.muted, tokens.mutedFg, options),
+    cardFg: ensurePairContrast(tokens.card, tokens.cardFg, options),
+    accentFg: ensurePairContrast(tokens.accent, tokens.accentFg, options),
+    destructiveFg: ensurePairContrast(tokens.destructive, tokens.destructiveFg, options)
+  };
+};
+
+// src/core/storage.ts
+var defaultStorageKey = "cui:preferences";
+var hasStorage = () => typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+var loadPersistedState = (key = defaultStorageKey) => {
+  if (!hasStorage()) {
+    return null;
+  }
+  try {
+    const raw = window.localStorage.getItem(key);
+    if (!raw) {
+      return null;
+    }
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var persistState = (state, key = defaultStorageKey) => {
+  if (!hasStorage()) {
+    return;
+  }
+  try {
+    window.localStorage.setItem(key, JSON.stringify(state));
+  } catch {
+  }
+};
+var clearPersistedState = (key = defaultStorageKey) => {
+  if (!hasStorage()) {
+    return;
+  }
+  try {
+    window.localStorage.removeItem(key);
+  } catch {
+  }
+};
+
+// src/core/systemPrefs.ts
+var getPreference = (query) => {
+  if (typeof window === "undefined" || !window.matchMedia) {
+    return null;
+  }
+  return window.matchMedia(query);
+};
+var getSystemPreferences = () => {
+  const colorScheme = getPreference("(prefers-color-scheme: dark)");
+  const lightScheme = getPreference("(prefers-color-scheme: light)");
+  const contrastMore = getPreference("(prefers-contrast: more)");
+  const contrastLess = getPreference("(prefers-contrast: less)");
+  const reduceMotion = getPreference("(prefers-reduced-motion: reduce)");
+  return {
+    prefersColorScheme: colorScheme?.matches ? "dark" : lightScheme?.matches ? "light" : "no-preference",
+    prefersContrast: contrastMore?.matches ? "more" : contrastLess?.matches ? "less" : "no-preference",
+    reducedMotion: Boolean(reduceMotion?.matches)
+  };
+};
+var subscribeSystemPreferences = (handler) => {
+  if (typeof window === "undefined" || !window.matchMedia) {
+    return () => void 0;
+  }
+  const notify = () => handler(getSystemPreferences());
+  const mediaQueries = [
+    "(prefers-color-scheme: dark)",
+    "(prefers-color-scheme: light)",
+    "(prefers-contrast: more)",
+    "(prefers-contrast: less)",
+    "(prefers-reduced-motion: reduce)"
+  ];
+  const listeners = mediaQueries.map((query) => {
+    const list = window.matchMedia(query);
+    const listener = () => notify();
+    if (list.addEventListener) {
+      list.addEventListener("change", listener);
+    } else {
+      list.addListener(listener);
+    }
+    return { list, listener };
+  });
+  return () => {
+    for (const { list, listener } of listeners) {
+      if (list.removeEventListener) {
+        list.removeEventListener("change", listener);
+      } else {
+        list.removeListener(listener);
+      }
+    }
+  };
+};
+
+// src/core/resolve.ts
+var defaultAccessibility = {
+  enforceContrast: true,
+  minimumRatio: 4.5,
+  largeTextRatio: 3,
+  preferPreserveHue: true,
+  maxIterations: 24
+};
+var defaultSystemOptions = {
+  respectColorScheme: true,
+  respectContrastPreference: true,
+  respectReducedMotion: true
+};
+var defaultColorSchemeBias = {
+  dark: -8,
+  light: 8
+};
+var defaultTransition = {
+  enabled: false,
+  durationMs: 200
+};
+var resolveMode = (userMode, system, config) => {
+  return userMode ?? config?.mode ?? "time";
+};
+var resolveAccessibility = (system, config) => {
+  const base = { ...defaultAccessibility, ...config?.accessibility };
+  if (config?.system?.respectContrastPreference !== false) {
+    if (system.prefersContrast === "more") {
+      base.minimumRatio = Math.max(base.minimumRatio, 7);
+    }
+    if (system.prefersContrast === "less") {
+      base.minimumRatio = Math.min(base.minimumRatio, 3);
+    }
+  }
+  return base;
+};
+
+// src/core/script.ts
+var serialize = (value) => JSON.stringify(value);
+var getMergedSchedule = (schedule) => ({
+  ...defaultSchedule,
+  ...schedule,
+  dawn: { ...defaultSchedule.dawn, ...schedule?.dawn },
+  day: { ...defaultSchedule.day, ...schedule?.day },
+  dusk: { ...defaultSchedule.dusk, ...schedule?.dusk },
+  night: { ...defaultSchedule.night, ...schedule?.night }
+});
+var getMode = (mode) => mode ?? "time";
+var createInlineScript = (config) => {
+  const schedule = getMergedSchedule(config?.schedule);
+  const storageKey = config?.storageKey ?? defaultStorageKey;
+  const persist = config?.persist !== false;
+  const tokens = {
+    dawn: tokensToCssVars({
+      ...defaultTokens.dawn,
+      ...config?.tokens?.dawn
+    }),
+    day: tokensToCssVars({
+      ...defaultTokens.day,
+      ...config?.tokens?.day
+    }),
+    dusk: tokensToCssVars({
+      ...defaultTokens.dusk,
+      ...config?.tokens?.dusk
+    }),
+    night: tokensToCssVars({
+      ...defaultTokens.night,
+      ...config?.tokens?.night
+    })
+  };
+  return `(() => {
+  try {
+    const schedule = ${serialize(schedule)};
+    const tokens = ${serialize(tokens)};
+    const storageKey = ${serialize(storageKey)};
+    const persist = ${serialize(persist)};
+    const fallbackMode = ${serialize(getMode(config?.mode))};
+    const now = new Date();
+    const minutes = now.getHours() * 60 + now.getMinutes();
+
+    const isWithin = (value, start, end) => {
+      if (start === end) return true;
+      if (start < end) return value >= start && value < end;
+      return value >= start || value < end;
+    };
+
+    const parse = (time) => {
+      const [h, m] = time.split(":").map(Number);
+      return ((h % 24) * 60 + m) % 1440;
+    };
+
+    const normalized = {
+      dawn: { start: parse(schedule.dawn.start), end: parse(schedule.dawn.end) },
+      day: { start: parse(schedule.day.start), end: parse(schedule.day.end) },
+      dusk: { start: parse(schedule.dusk.start), end: parse(schedule.dusk.end) },
+      night: { start: parse(schedule.night.start), end: parse(schedule.night.end) }
+    };
+
+    const order = ["dawn", "day", "dusk", "night"];
+    let phase = "night";
+    for (const key of order) {
+      const window = normalized[key];
+      if (isWithin(minutes, window.start, window.end)) {
+        phase = key;
+        break;
+      }
+    }
+
+    let mode = fallbackMode;
+    const persisted = persist && window.localStorage ? window.localStorage.getItem(storageKey) : null;
+    if (persisted) {
+      try {
+        const parsed = JSON.parse(persisted);
+        if (parsed.mode) mode = parsed.mode;
+        if (parsed.phase) phase = parsed.phase;
+      } catch {
+        // ignore
+      }
+    }
+
+    const root = document.documentElement;
+    root.setAttribute("data-cui-phase", phase);
+    const vars = tokens[phase] || tokens.night;
+    for (const key in vars) {
+      root.style.setProperty(key, vars[key]);
+    }
+  } catch {
+    // ignore
+  }
+})();`;
+};
+var resolveInitialPhase = (date, schedule) => {
+  const merged = getMergedSchedule(schedule);
+  const minutes = date.getHours() * 60 + date.getMinutes();
+  const isWithin = (value, start, end) => {
+    if (start === end) return true;
+    if (start < end) return value >= start && value < end;
+    return value >= start || value < end;
+  };
+  const parse = (time) => {
+    const [h, m] = time.split(":").map(Number);
+    return (h % 24 * 60 + m) % 1440;
+  };
+  const order = ["dawn", "day", "dusk", "night"];
+  for (const phase of order) {
+    const window2 = merged[phase];
+    if (isWithin(minutes, parse(window2.start), parse(window2.end))) {
+      return phase;
+    }
+  }
+  return "night";
+};
+var CircadianContext = react.createContext(null);
+var getRootElement = (target) => {
+  if (typeof document === "undefined") {
+    return {};
+  }
+  return target === "body" ? document.body : document.documentElement;
+};
+var getInitialSystemPreferences = () => {
+  if (typeof window === "undefined") {
+    return {
+      prefersColorScheme: "no-preference",
+      prefersContrast: "no-preference",
+      reducedMotion: false
+    };
+  }
+  return getSystemPreferences();
+};
+var computePhase = (date, mode, config, phaseOverride) => {
+  if (mode === "manual" && phaseOverride) {
+    return phaseOverride;
+  }
+  if (mode === "sun") {
+    const sunTimes = config.sunTimesProvider?.(date);
+    if (sunTimes) {
+      return getPhaseFromSunTimes(date, sunTimes, config.sunSchedule);
+    }
+  }
+  return getPhaseFromTime(date, config.schedule);
+};
+var computeNextChange = (date, mode, config) => {
+  if (mode === "manual") {
+    return null;
+  }
+  if (mode === "sun") {
+    const schedule = getScheduleFromProvider(date, config.sunTimesProvider, config.sunSchedule);
+    if (schedule) {
+      return computeNextTransition(date, schedule);
+    }
+  }
+  return computeNextTransition(date, config.schedule);
+};
+var CircadianProvider = ({ config = {}, children }) => {
+  const storageKey = config.storageKey;
+  const shouldPersist = config.persist !== false;
+  const [systemPrefs, setSystemPrefs] = react.useState(getInitialSystemPreferences);
+  const initialPersisted = typeof window !== "undefined" && shouldPersist ? loadPersistedState(storageKey) : null;
+  const [mode, setModeState] = react.useState(
+    initialPersisted?.mode ?? config.mode ?? "time"
+  );
+  const [phaseOverride, setPhaseOverrideState] = react.useState(
+    initialPersisted?.phase ?? null
+  );
+  const [phase, setPhase] = react.useState(
+    () => computePhase(/* @__PURE__ */ new Date(), mode, config, phaseOverride)
+  );
+  const [nextChangeAt, setNextChangeAt] = react.useState(
+    () => computeNextChange(/* @__PURE__ */ new Date(), mode, config)
+  );
+  const timerRef = react.useRef(null);
+  const accessibility = react.useMemo(
+    () => resolveAccessibility(systemPrefs, config),
+    [systemPrefs, config]
+  );
+  const transition = { ...defaultTransition, ...config.transition };
+  const systemOptions = { ...defaultSystemOptions, ...config.system };
+  const colorBias = { ...defaultColorSchemeBias, ...config.colorSchemeBias };
+  const tokens = react.useMemo(() => {
+    let resolved = resolveTokens(phase, config.tokens);
+    if (systemOptions.respectColorScheme) {
+      resolved = applyColorSchemeBias(resolved, systemPrefs.prefersColorScheme, colorBias);
+    }
+    if (accessibility.enforceContrast) {
+      resolved = ensureContrast(resolved, accessibility);
+    }
+    return resolved;
+  }, [
+    phase,
+    config.tokens,
+    systemPrefs.prefersColorScheme,
+    accessibility,
+    systemOptions.respectColorScheme,
+    colorBias
+  ]);
+  const updatePhase = react.useCallback(() => {
+    const now = /* @__PURE__ */ new Date();
+    const resolvedMode = resolveMode(mode, systemPrefs, config);
+    const nextPhase = computePhase(now, resolvedMode, config, phaseOverride);
+    setPhase(nextPhase);
+    setNextChangeAt(computeNextChange(now, resolvedMode, config));
+  }, [mode, systemPrefs, config, phaseOverride]);
+  react.useEffect(() => {
+    updatePhase();
+  }, [updatePhase]);
+  react.useEffect(() => {
+    if (mode === "manual") {
+      return;
+    }
+    if (timerRef.current) {
+      window.clearTimeout(timerRef.current);
+    }
+    if (!nextChangeAt) {
+      return;
+    }
+    const delay = Math.max(0, nextChangeAt.getTime() - Date.now() + 500);
+    timerRef.current = window.setTimeout(() => {
+      updatePhase();
+    }, delay);
+    return () => {
+      if (timerRef.current) {
+        window.clearTimeout(timerRef.current);
+      }
+    };
+  }, [mode, nextChangeAt, updatePhase]);
+  react.useEffect(() => {
+    const root = getRootElement(config.setAttributeOn);
+    if (!root || !root.style) {
+      return;
+    }
+    root.setAttribute("data-cui-phase", phase);
+    const allowMotion = !systemPrefs.reducedMotion || !systemOptions.respectReducedMotion;
+    if (transition.enabled && allowMotion) {
+      root.style.transition = `background-color ${transition.durationMs}ms ease, color ${transition.durationMs}ms ease`;
+    } else {
+      root.style.transition = "";
+    }
+    applyTokensToElement(root, tokens);
+  }, [
+    phase,
+    tokens,
+    transition,
+    systemPrefs.reducedMotion,
+    systemOptions.respectReducedMotion,
+    config.setAttributeOn
+  ]);
+  react.useEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    return subscribeSystemPreferences(setSystemPrefs);
+  }, []);
+  react.useEffect(() => {
+    if (!shouldPersist) {
+      return;
+    }
+    persistState(
+      {
+        mode,
+        phase: phaseOverride
+      },
+      storageKey
+    );
+  }, [mode, phaseOverride, shouldPersist, storageKey]);
+  const setMode = react.useCallback(
+    (nextMode) => {
+      setModeState(nextMode);
+      if (nextMode === "manual" && !phaseOverride) {
+        setPhaseOverrideState(phase);
+      }
+    },
+    [phase, phaseOverride]
+  );
+  const setPhaseOverride = react.useCallback((nextPhase) => {
+    setPhaseOverrideState(nextPhase);
+    setModeState("manual");
+  }, []);
+  const clearOverride = react.useCallback(() => {
+    setPhaseOverrideState(null);
+    setModeState("time");
+  }, []);
+  const contextValue = react.useMemo(
+    () => ({
+      phase,
+      mode,
+      tokens,
+      nextChangeAt,
+      setMode,
+      setPhaseOverride,
+      clearOverride,
+      isAuto: mode !== "manual"
+    }),
+    [phase, mode, tokens, nextChangeAt, setMode, setPhaseOverride, clearOverride]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(CircadianContext.Provider, { value: contextValue, children });
+};
+var useCircadianContext = () => {
+  const context = react.useContext(CircadianContext);
+  if (!context) {
+    throw new Error("useCircadian must be used within a CircadianProvider");
+  }
+  return context;
+};
+var useCircadian = () => useCircadianContext();
+var useCircadianTokens = () => {
+  const { tokens } = useCircadianContext();
+  const cssVars = react.useMemo(() => tokensToCssVars(tokens), [tokens]);
+  const applyToStyle = react.useMemo(
+    () => ({
+      style: Object.fromEntries(Object.entries(cssVars).map(([key, value]) => [key, value]))
+    }),
+    [cssVars]
+  );
+  return { tokens, cssVars, applyToStyle };
+};
+var CircadianScript = ({ config, nonce }) => {
+  const script = react.useMemo(() => createInlineScript(config), [config]);
+  return /* @__PURE__ */ jsxRuntime.jsx("script", { nonce, dangerouslySetInnerHTML: { __html: script } });
+};
+
+// src/tailwind/preset.ts
+var toColor = (cssVar) => `hsl(var(${cssVar}) / <alpha-value>)`;
+var circadianTailwindPreset = () => {
+  return {
+    theme: {
+      extend: {
+        colors: {
+          background: toColor(cssVarMap.bg),
+          foreground: toColor(cssVarMap.fg),
+          muted: toColor(cssVarMap.muted),
+          "muted-foreground": toColor(cssVarMap.mutedFg),
+          card: toColor(cssVarMap.card),
+          "card-foreground": toColor(cssVarMap.cardFg),
+          border: toColor(cssVarMap.border),
+          ring: toColor(cssVarMap.ring),
+          accent: toColor(cssVarMap.accent),
+          "accent-foreground": toColor(cssVarMap.accentFg),
+          destructive: toColor(cssVarMap.destructive),
+          "destructive-foreground": toColor(cssVarMap.destructiveFg)
+        }
+      }
+    }
+  };
+};
+
+// src/tailwind/plugin.ts
+var circadianPlugin = () => {
+  return ({ addBase }) => {
+    addBase({
+      ":root": tokensToCssVars(defaultTokens.day),
+      "[data-cui-phase='dawn']": tokensToCssVars(defaultTokens.dawn),
+      "[data-cui-phase='day']": tokensToCssVars(defaultTokens.day),
+      "[data-cui-phase='dusk']": tokensToCssVars(defaultTokens.dusk),
+      "[data-cui-phase='night']": tokensToCssVars(defaultTokens.night)
+    });
+  };
+};
+
+exports.CircadianProvider = CircadianProvider;
+exports.CircadianScript = CircadianScript;
+exports.applyColorSchemeBias = applyColorSchemeBias;
+exports.applyTokensToElement = applyTokensToElement;
+exports.circadianPlugin = circadianPlugin;
+exports.circadianTailwindPreset = circadianTailwindPreset;
+exports.clearPersistedState = clearPersistedState;
+exports.computeNextTransition = computeNextTransition;
+exports.contrastRatio = contrastRatio;
+exports.createInlineScript = createInlineScript;
+exports.cssVarMap = cssVarMap;
+exports.defaultAccessibility = defaultAccessibility;
+exports.defaultColorSchemeBias = defaultColorSchemeBias;
+exports.defaultSchedule = defaultSchedule;
+exports.defaultStorageKey = defaultStorageKey;
+exports.defaultSunSchedule = defaultSunSchedule;
+exports.defaultSystemOptions = defaultSystemOptions;
+exports.defaultTokens = defaultTokens;
+exports.defaultTransition = defaultTransition;
+exports.deriveSunSchedule = deriveSunSchedule;
+exports.ensureContrast = ensureContrast;
+exports.getMinutesFromDate = getMinutesFromDate;
+exports.getPhaseFromSunTimes = getPhaseFromSunTimes;
+exports.getPhaseFromTime = getPhaseFromTime;
+exports.getScheduleFromProvider = getScheduleFromProvider;
+exports.getSystemPreferences = getSystemPreferences;
+exports.loadPersistedState = loadPersistedState;
+exports.normalizeSchedule = normalizeSchedule;
+exports.parseTimeToMinutes = parseTimeToMinutes;
+exports.persistState = persistState;
+exports.resolveAccessibility = resolveAccessibility;
+exports.resolveInitialPhase = resolveInitialPhase;
+exports.resolveMode = resolveMode;
+exports.resolveTokens = resolveTokens;
+exports.subscribeSystemPreferences = subscribeSystemPreferences;
+exports.tokensToCssVars = tokensToCssVars;
+exports.useCircadian = useCircadian;
+exports.useCircadianContext = useCircadianContext;
+exports.useCircadianTokens = useCircadianTokens;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map