@shalomormsby/ui 0.0.5

package/dist/providers.js

@@ -0,0 +1,736 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/providers.ts
+var providers_exports = {};
+__export(providers_exports, {
+  ThemeProvider: () => ThemeProvider
+});
+module.exports = __toCommonJS(providers_exports);
+
+// src/providers/ThemeProvider.tsx
+var import_react = require("react");
+
+// src/lib/store/theme.ts
+var import_zustand = require("zustand");
+var import_middleware = require("zustand/middleware");
+var useThemeStore = (0, import_zustand.create)()(
+  (0, import_middleware.persist)(
+    (set, get) => ({
+      // Defaults
+      theme: "volt",
+      mode: "dark",
+      // Actions
+      setTheme: (theme) => set({ theme }),
+      setMode: (mode) => set({ mode }),
+      toggleMode: () => set((state) => ({ mode: state.mode === "light" ? "dark" : "light" })),
+      // Computed
+      get themeConfig() {
+        const state = get();
+        return { name: state.theme, mode: state.mode };
+      }
+    }),
+    {
+      name: "ecosystem-theme",
+      // Only persist theme and mode
+      partialize: (state) => ({
+        theme: state.theme,
+        mode: state.mode
+      })
+    }
+  )
+);
+
+// src/lib/store/customizer.ts
+var import_zustand2 = require("zustand");
+var import_middleware2 = require("zustand/middleware");
+var import_tokens = require("@sage/tokens");
+
+// src/lib/colors.ts
+var colorTokens = {
+  // Background colors
+  background: "var(--color-background)",
+  backgroundSecondary: "var(--color-background-secondary)",
+  backgroundTertiary: "var(--color-background-tertiary)",
+  surface: "var(--color-surface)",
+  // Foreground/Text colors
+  foreground: "var(--color-foreground)",
+  foregroundSecondary: "var(--color-foreground-secondary)",
+  foregroundTertiary: "var(--color-foreground-tertiary)",
+  textPrimary: "var(--color-text-primary)",
+  textSecondary: "var(--color-text-secondary)",
+  textMuted: "var(--color-text-muted)",
+  // Brand colors
+  primary: "var(--color-primary)",
+  primaryForeground: "var(--color-primary-foreground)",
+  secondary: "var(--color-secondary)",
+  secondaryForeground: "var(--color-secondary-foreground)",
+  accent: "var(--color-accent)",
+  accentForeground: "var(--color-accent-foreground)",
+  // Semantic colors
+  success: "var(--color-success)",
+  successForeground: "var(--color-success-foreground)",
+  warning: "var(--color-warning)",
+  warningForeground: "var(--color-warning-foreground)",
+  error: "var(--color-error)",
+  errorForeground: "var(--color-error-foreground)",
+  info: "var(--color-info)",
+  infoForeground: "var(--color-info-foreground)",
+  // Borders
+  border: "var(--color-border)",
+  borderSubtle: "var(--color-border-subtle)",
+  // Interactive states
+  hover: "var(--color-hover)",
+  active: "var(--color-active)",
+  focus: "var(--color-focus)",
+  // Links
+  link: "var(--color-link)",
+  linkHover: "var(--color-link-hover)",
+  linkHoverForeground: "var(--color-link-hover-foreground)"
+};
+var semanticColors = {
+  /**
+   * Status colors for indicating states
+   */
+  status: {
+    success: {
+      bg: colorTokens.success,
+      fg: colorTokens.successForeground
+    },
+    warning: {
+      bg: colorTokens.warning,
+      fg: colorTokens.warningForeground
+    },
+    error: {
+      bg: colorTokens.error,
+      fg: colorTokens.errorForeground
+    },
+    info: {
+      bg: colorTokens.info,
+      fg: colorTokens.infoForeground
+    }
+  },
+  /**
+   * Brand colors for primary UI elements
+   */
+  brand: {
+    primary: {
+      bg: colorTokens.primary,
+      fg: colorTokens.primaryForeground
+    },
+    secondary: {
+      bg: colorTokens.secondary,
+      fg: colorTokens.secondaryForeground
+    },
+    accent: {
+      bg: colorTokens.accent,
+      fg: colorTokens.accentForeground
+    }
+  },
+  /**
+   * Interactive state colors
+   */
+  interactive: {
+    default: {
+      bg: colorTokens.background,
+      fg: colorTokens.foreground
+    },
+    hover: {
+      bg: colorTokens.hover,
+      fg: colorTokens.foreground
+    },
+    active: {
+      bg: colorTokens.active,
+      fg: colorTokens.foreground
+    },
+    focus: {
+      border: colorTokens.focus
+    }
+  }
+};
+function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16)
+  } : null;
+}
+function getLuminance(r, g, b) {
+  const [rs, gs, bs] = [r, g, b].map((c) => {
+    const srgb = c / 255;
+    return srgb <= 0.03928 ? srgb / 12.92 : Math.pow((srgb + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
+}
+function getContrastRatio(hex1, hex2) {
+  const rgb1 = hexToRgb(hex1);
+  const rgb2 = hexToRgb(hex2);
+  if (!rgb1 || !rgb2) return 0;
+  const lum1 = getLuminance(rgb1.r, rgb1.g, rgb1.b);
+  const lum2 = getLuminance(rgb2.r, rgb2.g, rgb2.b);
+  const lighter = Math.max(lum1, lum2);
+  const darker = Math.min(lum1, lum2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function hexToHSL(hex) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return { h: 0, s: 0, l: 0 };
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let h = 0, s = 0, l = (max + min) / 2;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+        break;
+      case g:
+        h = ((b - r) / d + 2) / 6;
+        break;
+      case b:
+        h = ((r - g) / d + 4) / 6;
+        break;
+    }
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToHex(h, s, l) {
+  h = h / 360;
+  s = s / 100;
+  l = l / 100;
+  let r, g, b;
+  if (s === 0) {
+    r = g = b = l;
+  } else {
+    const hue2rgb = (p2, q2, t) => {
+      if (t < 0) t += 1;
+      if (t > 1) t -= 1;
+      if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+      if (t < 1 / 2) return q2;
+      if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+      return p2;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  const toHex = (x) => {
+    const hex = Math.round(x * 255).toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  };
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function getOptimalForeground(bgHex, whiteHex = "#ffffff", blackHex = "#000000") {
+  const whiteRatio = getContrastRatio(bgHex, whiteHex);
+  const blackRatio = getContrastRatio(bgHex, blackHex);
+  return whiteRatio > blackRatio ? whiteHex : blackHex;
+}
+function generateColorScale(baseHex) {
+  const hsl = hexToHSL(baseHex);
+  return {
+    50: hslToHex(hsl.h, Math.max(hsl.s - 10, 20), 95),
+    100: hslToHex(hsl.h, Math.max(hsl.s - 5, 30), 90),
+    200: hslToHex(hsl.h, hsl.s, 80),
+    300: hslToHex(hsl.h, hsl.s, 70),
+    400: hslToHex(hsl.h, hsl.s, 60),
+    500: baseHex,
+    // Base color
+    600: hslToHex(hsl.h, Math.min(hsl.s + 5, 100), 45),
+    700: hslToHex(hsl.h, Math.min(hsl.s + 10, 100), 35),
+    800: hslToHex(hsl.h, Math.min(hsl.s + 15, 100), 25),
+    900: hslToHex(hsl.h, Math.min(hsl.s + 20, 100), 15)
+  };
+}
+
+// src/lib/store/customizer.ts
+var useCustomizer = (0, import_zustand2.create)()(
+  (0, import_middleware2.persist)(
+    (set, get) => ({
+      motion: 5,
+      prefersReducedMotion: false,
+      customizationMode: "simple",
+      customColors: {},
+      savedPalettes: [],
+      customFontThemes: {},
+      savedFontThemes: [],
+      setMotion: (level) => set({ motion: level }),
+      setPrefersReducedMotion: (value) => set({ prefersReducedMotion: value }),
+      setCustomizationMode: (mode) => set({ customizationMode: mode }),
+      setCustomPrimaryColor: (theme, mode, hexColor) => {
+        const state = get();
+        const currentPalette = state.customColors[theme]?.[mode];
+        const scale = generateColorScale(hexColor);
+        const primaryForeground = getOptimalForeground(hexColor);
+        const derivedTokens = (0, import_tokens.computeDerivedTokens)("--color-primary", hexColor, mode);
+        const isSimple = state.customizationMode === "simple";
+        const palette = {
+          primary: hexColor,
+          primaryForeground,
+          secondary: isSimple ? void 0 : currentPalette?.secondary,
+          secondaryForeground: isSimple ? void 0 : currentPalette?.secondaryForeground,
+          accent: isSimple ? void 0 : currentPalette?.accent,
+          accentForeground: isSimple ? void 0 : currentPalette?.accentForeground,
+          scale,
+          derivedTokens
+        };
+        set((state2) => ({
+          customColors: {
+            ...state2.customColors,
+            [theme]: {
+              ...state2.customColors[theme],
+              [mode]: palette
+            }
+          }
+        }));
+      },
+      setCustomSecondaryColor: (theme, mode, hexColor) => {
+        const state = get();
+        const currentPalette = state.customColors[theme]?.[mode];
+        if (!currentPalette) return;
+        const secondaryForeground = getOptimalForeground(hexColor);
+        const derivedTokens = (0, import_tokens.computeDerivedTokens)("--color-secondary", hexColor, mode);
+        set((state2) => ({
+          customColors: {
+            ...state2.customColors,
+            [theme]: {
+              ...state2.customColors[theme],
+              [mode]: {
+                ...currentPalette,
+                secondary: hexColor,
+                secondaryForeground,
+                derivedTokens: {
+                  ...currentPalette.derivedTokens,
+                  ...derivedTokens
+                }
+              }
+            }
+          }
+        }));
+      },
+      setCustomAccentColor: (theme, mode, hexColor) => {
+        const state = get();
+        const currentPalette = state.customColors[theme]?.[mode];
+        if (!currentPalette) return;
+        const accentForeground = getOptimalForeground(hexColor);
+        const derivedTokens = (0, import_tokens.computeDerivedTokens)("--color-accent", hexColor, mode);
+        set((state2) => ({
+          customColors: {
+            ...state2.customColors,
+            [theme]: {
+              ...state2.customColors[theme],
+              [mode]: {
+                ...currentPalette,
+                accent: hexColor,
+                accentForeground,
+                derivedTokens: {
+                  ...currentPalette.derivedTokens,
+                  ...derivedTokens
+                }
+              }
+            }
+          }
+        }));
+      },
+      applyColorPalette: (theme, mode, colors) => {
+        const scale = generateColorScale(colors.primary);
+        const primaryForeground = getOptimalForeground(colors.primary);
+        let derivedTokens = (0, import_tokens.computeDerivedTokens)("--color-primary", colors.primary, mode);
+        let secondary = colors.secondary;
+        let secondaryForeground = secondary ? getOptimalForeground(secondary) : void 0;
+        if (secondary) {
+          const secondaryDerived = (0, import_tokens.computeDerivedTokens)("--color-secondary", secondary, mode);
+          derivedTokens = { ...derivedTokens, ...secondaryDerived };
+        }
+        let accent = colors.accent;
+        let accentForeground = accent ? getOptimalForeground(accent) : void 0;
+        if (accent) {
+          const accentDerived = (0, import_tokens.computeDerivedTokens)("--color-accent", accent, mode);
+          derivedTokens = { ...derivedTokens, ...accentDerived };
+        }
+        const palette = {
+          name: colors.name,
+          description: colors.description,
+          primary: colors.primary,
+          primaryForeground,
+          secondary,
+          secondaryForeground,
+          accent,
+          accentForeground,
+          scale,
+          derivedTokens
+        };
+        set((state) => ({
+          customColors: {
+            ...state.customColors,
+            [theme]: {
+              ...state.customColors[theme],
+              [mode]: palette
+            }
+          }
+        }));
+      },
+      resetCustomColors: (theme, mode) => {
+        if (mode) {
+          set((state) => ({
+            customColors: {
+              ...state.customColors,
+              [theme]: {
+                ...state.customColors[theme],
+                [mode]: void 0
+              }
+            }
+          }));
+        } else {
+          set((state) => {
+            const { [theme]: _, ...rest } = state.customColors;
+            return { customColors: rest };
+          });
+        }
+      },
+      getActiveColorPalette: (theme, mode) => {
+        return get().customColors[theme]?.[mode] || null;
+      },
+      // Saved palette management
+      savePalette: (paletteData) => {
+        const id = `custom-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const newPalette = {
+          ...paletteData,
+          id,
+          category: "custom",
+          createdAt: Date.now()
+        };
+        set((state) => ({
+          savedPalettes: [...state.savedPalettes, newPalette]
+        }));
+      },
+      updatePalette: (id, updates) => {
+        set((state) => ({
+          savedPalettes: state.savedPalettes.map(
+            (p) => p.id === id ? { ...p, ...updates } : p
+          )
+        }));
+      },
+      renamePalette: (id, newName) => {
+        set((state) => ({
+          savedPalettes: state.savedPalettes.map(
+            (p) => p.id === id ? { ...p, name: newName } : p
+          )
+        }));
+      },
+      deletePalette: (id) => {
+        set((state) => ({
+          savedPalettes: state.savedPalettes.filter((p) => p.id !== id)
+        }));
+      },
+      reorderPalettes: (palettes) => {
+        set({ savedPalettes: palettes });
+      },
+      getSavedPalettes: () => {
+        return get().savedPalettes;
+      },
+      // Font theme management
+      applyFontTheme: (theme, mode, fontTheme) => {
+        set((state) => ({
+          customFontThemes: {
+            ...state.customFontThemes,
+            [theme]: {
+              ...state.customFontThemes[theme],
+              [mode]: fontTheme
+            }
+          }
+        }));
+      },
+      resetCustomFonts: (theme, mode) => {
+        if (mode) {
+          set((state) => ({
+            customFontThemes: {
+              ...state.customFontThemes,
+              [theme]: {
+                ...state.customFontThemes[theme],
+                [mode]: void 0
+              }
+            }
+          }));
+        } else {
+          set((state) => {
+            const { [theme]: _, ...rest } = state.customFontThemes;
+            return { customFontThemes: rest };
+          });
+        }
+      },
+      getActiveFontTheme: (theme, mode) => {
+        return get().customFontThemes[theme]?.[mode] || null;
+      },
+      // Saved font theme management
+      saveFontTheme: (fontThemeData) => {
+        const id = `font-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const newFontTheme = {
+          ...fontThemeData,
+          id,
+          category: "custom",
+          createdAt: Date.now(),
+          isCustom: true
+        };
+        set((state) => ({
+          savedFontThemes: [...state.savedFontThemes, newFontTheme]
+        }));
+      },
+      updateFontTheme: (id, updates) => {
+        set((state) => ({
+          savedFontThemes: state.savedFontThemes.map(
+            (ft) => ft.id === id ? { ...ft, ...updates } : ft
+          )
+        }));
+      },
+      renameFontTheme: (id, newName) => {
+        set((state) => ({
+          savedFontThemes: state.savedFontThemes.map(
+            (ft) => ft.id === id ? { ...ft, name: newName } : ft
+          )
+        }));
+      },
+      deleteFontTheme: (id) => {
+        set((state) => ({
+          savedFontThemes: state.savedFontThemes.filter((ft) => ft.id !== id)
+        }));
+      },
+      reorderFontThemes: (fontThemes) => {
+        set({ savedFontThemes: fontThemes });
+      },
+      getSavedFontThemes: () => {
+        return get().savedFontThemes;
+      }
+    }),
+    {
+      name: "ecosystem-customizer",
+      version: 4,
+      partialize: (state) => ({
+        motion: state.motion,
+        prefersReducedMotion: state.prefersReducedMotion,
+        customizationMode: state.customizationMode,
+        customColors: state.customColors,
+        savedPalettes: state.savedPalettes,
+        customFontThemes: state.customFontThemes,
+        savedFontThemes: state.savedFontThemes
+      })
+    }
+  )
+);
+
+// src/providers/ThemeProvider.tsx
+var import_tokens2 = require("@sage/tokens");
+var import_jsx_runtime = require("react/jsx-runtime");
+var themeTokens = {
+  studio: import_tokens2.studioTokens,
+  sage: import_tokens2.sageTokens,
+  volt: import_tokens2.voltTokens
+};
+var fontFamilies = {
+  studio: {
+    heading: "var(--font-studio-heading)",
+    body: "var(--font-studio-body)",
+    mono: "var(--font-mono)"
+  },
+  sage: {
+    sans: "var(--font-sage-body)",
+    serif: "var(--font-sage-heading)",
+    mono: "var(--font-mono)"
+  },
+  volt: {
+    sans: "var(--font-volt-heading)",
+    mono: "var(--font-mono)"
+  }
+};
+function getThemeVars(theme, mode) {
+  const tokens = themeTokens[theme];
+  const colors = tokens[mode]?.colors;
+  const effects = tokens[mode]?.effects;
+  const fonts = fontFamilies[theme];
+  return {
+    // Colors - Base
+    "--color-background": colors?.background || "#ffffff",
+    "--color-background-secondary": colors?.backgroundSecondary || colors?.background || "#fafafa",
+    "--color-background-tertiary": colors?.backgroundTertiary || colors?.backgroundSecondary || colors?.background || "#f5f5f5",
+    "--color-foreground": colors?.foreground || "#0a0a0a",
+    "--color-primary": colors?.primary || "#0a0a0a",
+    "--color-primary-foreground": colors?.primaryForeground || "#ffffff",
+    "--color-secondary": colors?.secondary || "#f5f5f5",
+    "--color-secondary-foreground": colors?.secondaryForeground || "#0a0a0a",
+    "--color-accent": colors?.accent || colors?.primary || "#0070f3",
+    "--color-accent-foreground": colors?.accentForeground || "#ffffff",
+    "--color-success": colors?.success || "#00a86b",
+    "--color-success-foreground": colors?.successForeground || "#ffffff",
+    "--color-warning": colors?.warning || "#f59e0b",
+    "--color-warning-foreground": colors?.warningForeground || "#ffffff",
+    "--color-error": colors?.error || "#ef4444",
+    "--color-error-foreground": colors?.errorForeground || "#ffffff",
+    "--color-info": colors?.info || colors?.accent || "#0070f3",
+    "--color-info-foreground": colors?.infoForeground || "#ffffff",
+    "--color-glass": colors?.glass || "rgba(255, 255, 255, 0.7)",
+    "--color-glass-border": colors?.glassBorder || "rgba(0, 0, 0, 0.1)",
+    // Semantic color aliases (matching README examples)
+    "--color-text-primary": colors?.foreground || "#0a0a0a",
+    "--color-text-secondary": colors?.foregroundSecondary || "#525252",
+    "--color-text-muted": colors?.foregroundTertiary || "#a3a3a3",
+    "--color-surface": colors?.backgroundSecondary || colors?.background || "#fafafa",
+    "--color-border": colors?.border || colors?.glassBorder || "rgba(0, 0, 0, 0.1)",
+    "--color-focus": colors?.accent || colors?.primary || "#0070f3",
+    // Links and focus rings (can be overridden by derived tokens)
+    "--color-link": colors?.link || colors?.primary || "#0a0a0a",
+    "--color-ring": colors?.ring || colors?.primary || "#0a0a0a",
+    // Interactive states
+    "--color-hover": colors?.hover || colors?.backgroundSecondary || "#fafafa",
+    "--color-active": colors?.active || colors?.backgroundTertiary || "#f0f0f0",
+    "--color-link-hover": colors?.linkHover || colors?.primary || "#0a0a0a",
+    "--color-link-hover-foreground": colors?.linkHoverForeground || colors?.background || "#ffffff",
+    // Effects - Blur
+    "--effect-blur-sm": effects?.blur?.sm || "blur(4px)",
+    "--effect-blur-md": effects?.blur?.md || "blur(8px)",
+    "--effect-blur-lg": effects?.blur?.lg || "blur(16px)",
+    "--effect-blur-xl": effects?.blur?.xl || effects?.blur?.lg || "blur(24px)",
+    // Effects - Shadow
+    "--effect-shadow-sm": effects?.shadow?.sm || "0 1px 2px 0 rgba(0, 0, 0, 0.05)",
+    "--effect-shadow-md": effects?.shadow?.md || effects?.shadow?.sm || "0 4px 6px -1px rgba(0, 0, 0, 0.1)",
+    "--effect-shadow-lg": effects?.shadow?.lg || effects?.shadow?.md || effects?.shadow?.sm || "0 10px 15px -3px rgba(0, 0, 0, 0.1)",
+    // Typography - Font Families
+    "--font-heading": fonts?.heading || (theme === "sage" && fonts?.serif ? fonts.serif : fonts?.sans) || "var(--font-studio-heading)",
+    "--font-body": fonts?.body || fonts?.sans || "var(--font-studio-body)",
+    "--font-mono": fonts?.mono || "var(--font-studio-mono)",
+    // Motion - These are accessed programmatically via tokens
+    // but we can set defaults for CSS animations
+    "--ease-default": tokens?.motion?.ease?.default || "cubic-bezier(0.4, 0, 0.2, 1)",
+    "--ease-spring": tokens?.motion?.ease?.spring || tokens?.motion?.ease?.default || "cubic-bezier(0.16, 1, 0.3, 1)",
+    // Syntax Highlighting - Based on VS Code Dark+ theme
+    "--syntax-comment": mode === "light" ? import_tokens2.syntaxColors.light.comment : import_tokens2.syntaxColors.dark.comment,
+    "--syntax-keyword": mode === "light" ? import_tokens2.syntaxColors.light.keyword : import_tokens2.syntaxColors.dark.keyword,
+    "--syntax-function": mode === "light" ? import_tokens2.syntaxColors.light.function : import_tokens2.syntaxColors.dark.function,
+    "--syntax-string": mode === "light" ? import_tokens2.syntaxColors.light.string : import_tokens2.syntaxColors.dark.string,
+    "--syntax-number": mode === "light" ? import_tokens2.syntaxColors.light.number : import_tokens2.syntaxColors.dark.number,
+    "--syntax-boolean": mode === "light" ? import_tokens2.syntaxColors.light.boolean : import_tokens2.syntaxColors.dark.boolean,
+    "--syntax-operator": mode === "light" ? import_tokens2.syntaxColors.light.operator : import_tokens2.syntaxColors.dark.operator,
+    "--syntax-property": mode === "light" ? import_tokens2.syntaxColors.light.property : import_tokens2.syntaxColors.dark.property,
+    "--syntax-className": mode === "light" ? import_tokens2.syntaxColors.light.className : import_tokens2.syntaxColors.dark.className,
+    "--syntax-tag": mode === "light" ? import_tokens2.syntaxColors.light.tag : import_tokens2.syntaxColors.dark.tag,
+    "--syntax-attribute": mode === "light" ? import_tokens2.syntaxColors.light.attribute : import_tokens2.syntaxColors.dark.attribute,
+    "--syntax-variable": mode === "light" ? import_tokens2.syntaxColors.light.variable : import_tokens2.syntaxColors.dark.variable,
+    "--syntax-punctuation": mode === "light" ? import_tokens2.syntaxColors.light.punctuation : import_tokens2.syntaxColors.dark.punctuation,
+    "--syntax-plain": mode === "light" ? import_tokens2.syntaxColors.light.plain : import_tokens2.syntaxColors.dark.plain,
+    // Code Block Backgrounds and Borders - Accessible contrast (WCAG AA 4.5:1)
+    "--code-block-bg": mode === "light" ? import_tokens2.codeColors.light.blockBackground : import_tokens2.codeColors.dark.blockBackground,
+    "--code-inline-bg": mode === "light" ? import_tokens2.codeColors.light.inlineBackground : import_tokens2.codeColors.dark.inlineBackground,
+    "--code-border": mode === "light" ? import_tokens2.codeColors.light.border : import_tokens2.codeColors.dark.border
+  };
+}
+function mergeCustomColorTokens(baseTokens, customPalette) {
+  return {
+    ...baseTokens,
+    // Override primary color
+    "--color-primary": customPalette.primary,
+    "--color-primary-foreground": customPalette.primaryForeground,
+    // Apply color scale (for utilities like bg-primary/50)
+    "--color-primary-50": customPalette.scale[50],
+    "--color-primary-100": customPalette.scale[100],
+    "--color-primary-200": customPalette.scale[200],
+    "--color-primary-300": customPalette.scale[300],
+    "--color-primary-400": customPalette.scale[400],
+    "--color-primary-500": customPalette.scale[500],
+    "--color-primary-600": customPalette.scale[600],
+    "--color-primary-700": customPalette.scale[700],
+    "--color-primary-800": customPalette.scale[800],
+    "--color-primary-900": customPalette.scale[900],
+    // Override secondary color if provided (advanced mode)
+    ...customPalette.secondary && {
+      "--color-secondary": customPalette.secondary,
+      "--color-secondary-foreground": customPalette.secondaryForeground || baseTokens["--color-secondary-foreground"]
+    },
+    // Override accent color if provided (advanced mode)
+    ...customPalette.accent && {
+      "--color-accent": customPalette.accent,
+      "--color-accent-foreground": customPalette.accentForeground || baseTokens["--color-accent-foreground"]
+    },
+    // Apply ALL derived tokens from dependency graph
+    // This automatically updates:
+    // - Links (--color-link, --color-link-hover)
+    // - Focus rings (--color-ring)
+    // - Charts (--chart-1, --chart-2, --chart-3, --chart-4, --chart-5)
+    // - Buttons, badges, and any other dependent tokens
+    ...customPalette.derivedTokens
+  };
+}
+function ThemeProvider({ children }) {
+  const { theme, mode } = useThemeStore();
+  const customPalette = useCustomizer((state) => state.customColors?.[theme]?.[mode]);
+  const [isTransitioning, setIsTransitioning] = (0, import_react.useState)(false);
+  const [mounted, setMounted] = (0, import_react.useState)(false);
+  (0, import_react.useEffect)(() => {
+    setMounted(true);
+  }, []);
+  (0, import_react.useEffect)(() => {
+    if (!mounted) return;
+    setIsTransitioning(true);
+    const root = document.documentElement;
+    const baseTokens = getThemeVars(theme, mode);
+    console.log("[ThemeProvider] Update:", {
+      theme,
+      mode,
+      hasCustomPalette: !!customPalette,
+      customPrimary: customPalette?.primary,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const finalTokens = customPalette ? mergeCustomColorTokens(baseTokens, customPalette) : baseTokens;
+    root.classList.add("theme-transitioning");
+    Object.entries(finalTokens).forEach(([key, value]) => {
+      root.style.setProperty(key, value);
+    });
+    root.setAttribute("data-theme", theme);
+    root.setAttribute("data-mode", mode);
+    root.setAttribute("data-custom-colors", customPalette ? "active" : "default");
+    if (mode === "dark") {
+      root.classList.add("dark");
+    } else {
+      root.classList.remove("dark");
+    }
+    const timeout = setTimeout(() => {
+      root.classList.remove("theme-transitioning");
+      setIsTransitioning(false);
+    }, 400);
+    return () => clearTimeout(timeout);
+  }, [theme, mode, mounted, customPalette]);
+  if (!mounted) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ThemeProvider
+});
+//# sourceMappingURL=providers.js.map