@shalomormsby/ui 0.0.5

package/dist/hooks.mjs

@@ -0,0 +1,696 @@
+"use client";
+
+// src/lib/store/theme.ts
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+var useThemeStore = create()(
+  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/hooks/useTheme.ts
+function useTheme() {
+  return useThemeStore();
+}
+
+// src/hooks/useMotionPreference.ts
+import { useEffect } from "react";
+
+// src/lib/store/customizer.ts
+import { create as create2 } from "zustand";
+import { persist as persist2 } from "zustand/middleware";
+import { computeDerivedTokens } from "@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 = create2()(
+  persist2(
+    (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 = 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 = 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 = 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 = computeDerivedTokens("--color-primary", colors.primary, mode);
+        let secondary = colors.secondary;
+        let secondaryForeground = secondary ? getOptimalForeground(secondary) : void 0;
+        if (secondary) {
+          const secondaryDerived = computeDerivedTokens("--color-secondary", secondary, mode);
+          derivedTokens = { ...derivedTokens, ...secondaryDerived };
+        }
+        let accent = colors.accent;
+        let accentForeground = accent ? getOptimalForeground(accent) : void 0;
+        if (accent) {
+          const accentDerived = 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/hooks/useMotionPreference.ts
+function useMotionPreference() {
+  const { motion, prefersReducedMotion, setPrefersReducedMotion } = useCustomizer();
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mediaQuery = window.matchMedia("(prefers-reduced-motion: reduce)");
+    setPrefersReducedMotion(mediaQuery.matches);
+    const handleChange = (e) => {
+      setPrefersReducedMotion(e.matches);
+    };
+    mediaQuery.addEventListener("change", handleChange);
+    return () => mediaQuery.removeEventListener("change", handleChange);
+  }, [setPrefersReducedMotion]);
+  return {
+    scale: motion,
+    shouldAnimate: motion > 0 && !prefersReducedMotion,
+    prefersReducedMotion
+  };
+}
+
+// src/hooks/useForm.ts
+import { useState, useCallback } from "react";
+
+// src/lib/validation.ts
+function validateField(value, rules) {
+  if (rules.required) {
+    const isEmpty = value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+    if (isEmpty) {
+      return typeof rules.required === "string" ? rules.required : "This field is required";
+    }
+  }
+  if (!value && !rules.required) {
+    return void 0;
+  }
+  if (rules.minLength && value.length < rules.minLength.value) {
+    return rules.minLength.message;
+  }
+  if (rules.maxLength && value.length > rules.maxLength.value) {
+    return rules.maxLength.message;
+  }
+  if (rules.pattern && !rules.pattern.value.test(value)) {
+    return rules.pattern.message;
+  }
+  if (rules.custom) {
+    for (const rule of rules.custom) {
+      if (!rule.validate(value)) {
+        return rule.message;
+      }
+    }
+  }
+  return void 0;
+}
+function validateForm(values, validations) {
+  const errors = {};
+  for (const [field, rules] of Object.entries(validations)) {
+    const error = validateField(values[field], rules);
+    if (error) {
+      errors[field] = error;
+    }
+  }
+  return errors;
+}
+
+// src/hooks/useForm.ts
+function useForm({
+  initialValues,
+  validations = {},
+  onSubmit,
+  validateOn = "onBlur"
+}) {
+  const [values, setValues] = useState(initialValues);
+  const [errors, setErrors] = useState({});
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [isDirty, setIsDirty] = useState(false);
+  const setValue = useCallback((name, value) => {
+    setValues((prev) => ({ ...prev, [name]: value }));
+    setIsDirty(true);
+  }, []);
+  const setError = useCallback((name, error) => {
+    setErrors((prev) => ({ ...prev, [name]: error }));
+  }, []);
+  const validateFieldByName = useCallback(
+    (name) => {
+      const fieldRules = validations[name];
+      if (!fieldRules) return;
+      const error = validateField(values[name], fieldRules);
+      setError(name, error);
+      return !error;
+    },
+    [values, validations, setError]
+  );
+  const handleChange = useCallback(
+    (e) => {
+      const { name, value, type } = e.target;
+      const fieldValue = type === "checkbox" ? e.target.checked : value;
+      setValue(name, fieldValue);
+      if (validateOn === "onChange") {
+        validateFieldByName(name);
+      }
+    },
+    [setValue, validateOn, validateFieldByName]
+  );
+  const handleBlur = useCallback(
+    (e) => {
+      const { name } = e.target;
+      if (validateOn === "onBlur") {
+        validateFieldByName(name);
+      }
+    },
+    [validateOn, validateFieldByName]
+  );
+  const validate = useCallback(() => {
+    const formErrors = validateForm(values, validations);
+    setErrors(formErrors);
+    return Object.keys(formErrors).length === 0;
+  }, [values, validations]);
+  const handleSubmit = useCallback(
+    async (e) => {
+      e?.preventDefault();
+      const isValid = validate();
+      if (!isValid) return;
+      if (onSubmit) {
+        setIsSubmitting(true);
+        try {
+          await onSubmit(values);
+        } finally {
+          setIsSubmitting(false);
+        }
+      }
+    },
+    [validate, onSubmit, values]
+  );
+  const reset = useCallback(() => {
+    setValues(initialValues);
+    setErrors({});
+    setIsDirty(false);
+    setIsSubmitting(false);
+  }, [initialValues]);
+  const getFieldProps = useCallback(
+    (name) => ({
+      name,
+      value: values[name] ?? "",
+      onChange: handleChange,
+      onBlur: handleBlur,
+      error: !!errors[name]
+    }),
+    [values, errors, handleChange, handleBlur]
+  );
+  return {
+    values,
+    errors,
+    isSubmitting,
+    isDirty,
+    setValue,
+    setError,
+    handleChange,
+    handleBlur,
+    handleSubmit,
+    reset,
+    validate,
+    getFieldProps
+  };
+}
+export {
+  useForm,
+  useMotionPreference,
+  useTheme
+};
+//# sourceMappingURL=hooks.mjs.map