@streamplace/components 0.0.1 → 0.7.0

package/dist/lib/theme/theme.js

@@ -0,0 +1,248 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { PortalHost } from "@rn-primitives/portal";
+import { createContext, useContext, useMemo, useState, } from "react";
+import { Platform, useColorScheme } from "react-native";
+import { animations, borderRadius, colors, shadows, spacing, touchTargets, typography, } from "./tokens";
+import { GestureHandlerRootView } from "react-native-gesture-handler";
+// Create theme colors based on dark mode
+const createThemeColors = (isDark) => ({
+    background: isDark ? colors.gray[950] : colors.white,
+    foreground: isDark ? colors.gray[50] : colors.gray[950],
+    card: isDark ? colors.gray[900] : colors.white,
+    cardForeground: isDark ? colors.gray[50] : colors.gray[950],
+    popover: isDark ? colors.gray[900] : colors.white,
+    popoverForeground: isDark ? colors.gray[50] : colors.gray[950],
+    primary: Platform.OS === "ios" ? colors.ios.systemBlue : colors.primary[500],
+    primaryForeground: colors.white,
+    secondary: isDark ? colors.gray[800] : colors.gray[100],
+    secondaryForeground: isDark ? colors.gray[50] : colors.gray[900],
+    muted: isDark ? colors.gray[800] : colors.gray[100],
+    mutedForeground: isDark ? colors.gray[400] : colors.gray[500],
+    accent: isDark ? colors.gray[800] : colors.gray[100],
+    accentForeground: isDark ? colors.gray[50] : colors.gray[900],
+    destructive: Platform.OS === "ios" ? colors.ios.systemRed : colors.destructive[500],
+    destructiveForeground: colors.white,
+    success: Platform.OS === "ios" ? colors.ios.systemGreen : colors.success[500],
+    successForeground: colors.white,
+    warning: Platform.OS === "ios" ? colors.ios.systemOrange : colors.warning[500],
+    warningForeground: colors.white,
+    border: isDark ? colors.gray[500] + "30" : colors.gray[200] + "30",
+    input: isDark ? colors.gray[800] : colors.gray[200],
+    ring: Platform.OS === "ios" ? colors.ios.systemBlue : colors.primary[500],
+    text: isDark ? colors.gray[50] : colors.gray[950],
+    textMuted: isDark ? colors.gray[400] : colors.gray[500],
+    textDisabled: isDark ? colors.gray[600] : colors.gray[400],
+});
+// Create theme styles based on colors
+const createThemeStyles = (themeColors) => ({
+    shadow: {
+        sm: shadows.sm,
+        md: shadows.md,
+        lg: shadows.lg,
+        xl: shadows.xl,
+    },
+    button: {
+        primary: {
+            backgroundColor: themeColors.primary,
+            borderWidth: 0,
+            ...shadows.sm,
+        },
+        secondary: {
+            backgroundColor: themeColors.secondary,
+            borderWidth: 0,
+        },
+        outline: {
+            backgroundColor: "transparent",
+            borderWidth: 1,
+            borderColor: themeColors.border,
+        },
+        ghost: {
+            backgroundColor: "transparent",
+            borderWidth: 0,
+        },
+    },
+    text: {
+        primary: {
+            color: themeColors.text,
+        },
+        muted: {
+            color: themeColors.textMuted,
+        },
+        disabled: {
+            color: themeColors.textDisabled,
+        },
+    },
+    input: {
+        base: {
+            backgroundColor: themeColors.background,
+            borderWidth: 1,
+            borderColor: themeColors.border,
+            borderRadius: borderRadius.md,
+            paddingHorizontal: spacing[3],
+            paddingVertical: spacing[3],
+            minHeight: touchTargets.minimum,
+        },
+        focused: {
+            borderColor: themeColors.ring,
+            borderWidth: 2,
+        },
+        error: {
+            borderColor: themeColors.destructive,
+            borderWidth: 2,
+        },
+    },
+    card: {
+        base: {
+            backgroundColor: themeColors.card,
+            borderRadius: borderRadius.lg,
+            ...shadows.sm,
+        },
+    },
+});
+// Create theme icons based on colors
+const createThemeIcons = (themeColors) => ({
+    color: {
+        default: themeColors.text,
+        muted: themeColors.textMuted,
+        primary: themeColors.primary,
+        secondary: themeColors.secondary,
+        destructive: themeColors.destructive,
+        success: themeColors.success,
+        warning: themeColors.warning,
+    },
+    size: {
+        sm: 16,
+        md: 20,
+        lg: 24,
+        xl: 32,
+    },
+});
+// Create the theme context
+const ThemeContext = createContext(null);
+// Theme provider component
+export function ThemeProvider({ children, defaultTheme = "system", forcedTheme, }) {
+    const systemColorScheme = useColorScheme();
+    const [currentTheme, setCurrentTheme] = useState(defaultTheme);
+    // Determine if dark mode should be active
+    const isDark = useMemo(() => {
+        if (forcedTheme === "light")
+            return false;
+        if (forcedTheme === "dark")
+            return true;
+        if (currentTheme === "light")
+            return false;
+        if (currentTheme === "dark")
+            return true;
+        if (currentTheme === "system")
+            return systemColorScheme === "dark";
+        return systemColorScheme === "dark";
+    }, [forcedTheme, currentTheme, systemColorScheme]);
+    // Create theme based on dark mode
+    const theme = useMemo(() => {
+        const themeColors = createThemeColors(isDark);
+        return {
+            colors: themeColors,
+            spacing,
+            borderRadius,
+            typography,
+            shadows,
+            touchTargets,
+            animations,
+        };
+    }, [isDark]);
+    // Create utility styles
+    const styles = useMemo(() => {
+        return createThemeStyles(theme.colors);
+    }, [theme.colors]);
+    // Create icon utilities
+    const icons = useMemo(() => {
+        return createThemeIcons(theme.colors);
+    }, [theme.colors]);
+    // Theme controls
+    const setTheme = (newTheme) => {
+        if (!forcedTheme) {
+            setCurrentTheme(newTheme);
+        }
+    };
+    const toggleTheme = () => {
+        if (!forcedTheme) {
+            setCurrentTheme((prev) => {
+                if (prev === "light")
+                    return "dark";
+                if (prev === "dark")
+                    return "system";
+                return "light";
+            });
+        }
+    };
+    const value = useMemo(() => ({
+        theme,
+        styles,
+        icons,
+        isDark,
+        currentTheme: forcedTheme || currentTheme,
+        systemTheme: systemColorScheme || "light",
+        setTheme,
+        toggleTheme,
+    }), [
+        theme,
+        styles,
+        icons,
+        isDark,
+        forcedTheme,
+        currentTheme,
+        systemColorScheme,
+        setTheme,
+        toggleTheme,
+    ]);
+    return (_jsx(ThemeContext.Provider, { value: value, children: _jsxs(GestureHandlerRootView, { children: [children, _jsx(PortalHost, {})] }) }));
+}
+// Hook to use theme
+export function useTheme() {
+    const context = useContext(ThemeContext);
+    if (!context) {
+        throw new Error("useTheme must be used within a ThemeProvider");
+    }
+    return context;
+}
+// Hook to get current platform's typography
+export function usePlatformTypography() {
+    const { theme } = useTheme();
+    return useMemo(() => {
+        if (Platform.OS === "ios") {
+            return theme.typography.ios;
+        }
+        else if (Platform.OS === "android") {
+            return theme.typography.android;
+        }
+        return theme.typography.universal;
+    }, [theme.typography]);
+}
+// Utility function to create theme-aware styles
+export function createThemedStyles(styleCreator) {
+    return function useThemedStyles() {
+        const { theme, styles, icons } = useTheme();
+        return useMemo(() => styleCreator(theme, styles, icons), [theme, styles, icons]);
+    };
+}
+// Create light and dark theme instances for external use
+export const lightTheme = {
+    colors: createThemeColors(false),
+    spacing,
+    borderRadius,
+    typography,
+    shadows,
+    touchTargets,
+    animations,
+};
+export const darkTheme = {
+    colors: createThemeColors(true),
+    spacing,
+    borderRadius,
+    typography,
+    shadows,
+    touchTargets,
+    animations,
+};
+// Export individual theme utilities for convenience
+export { createThemeColors, createThemeIcons, createThemeStyles };

package/dist/lib/theme/tokens.js

@@ -0,0 +1,383 @@
+/**
+ * Design tokens for React Native components
+ * Inspired by shadcn/ui but adapted for React Native styling
+ */
+export const colors = {
+    // Primary colors
+    primary: {
+        50: "#eff6ff",
+        100: "#dbeafe",
+        200: "#bfdbfe",
+        300: "#93c5fd",
+        400: "#60a5fa",
+        500: "#3b82f6",
+        600: "#2563eb",
+        700: "#1d4ed8",
+        800: "#1e40af",
+        900: "#1e3a8a",
+        950: "#172554",
+    },
+    // Grayscale
+    gray: {
+        50: "#fafafa",
+        100: "#f5f5f5",
+        200: "#e5e5e5",
+        300: "#d4d4d4",
+        400: "#a3a3a3",
+        500: "#737373",
+        600: "#525252",
+        700: "#404040",
+        800: "#262626",
+        900: "#171717",
+        950: "#0d0d0d",
+    },
+    // Semantic colors
+    destructive: {
+        50: "#fef2f2",
+        100: "#fee2e2",
+        200: "#fecaca",
+        300: "#fca5a5",
+        400: "#f87171",
+        500: "#ef4444",
+        600: "#dc2626",
+        700: "#b91c1c",
+        800: "#991b1b",
+        900: "#7f1d1d",
+        950: "#450a0a",
+    },
+    success: {
+        50: "#f0fdf4",
+        100: "#dcfce7",
+        200: "#bbf7d0",
+        300: "#86efac",
+        400: "#4ade80",
+        500: "#22c55e",
+        600: "#16a34a",
+        700: "#15803d",
+        800: "#166534",
+        900: "#14532d",
+        950: "#052e16",
+    },
+    warning: {
+        50: "#fffbeb",
+        100: "#fef3c7",
+        200: "#fde68a",
+        300: "#fcd34d",
+        400: "#fbbf24",
+        500: "#f59e0b",
+        600: "#d97706",
+        700: "#b45309",
+        800: "#92400e",
+        900: "#78350f",
+        950: "#451a03",
+    },
+    // iOS system colors (adaptive)
+    ios: {
+        systemBlue: "#007AFF",
+        systemGreen: "#34C759",
+        systemRed: "#FF3B30",
+        systemOrange: "#FF9500",
+        systemYellow: "#FFCC00",
+        systemPurple: "#AF52DE",
+        systemPink: "#FF2D92",
+        systemTeal: "#5AC8FA",
+        systemIndigo: "#5856D6",
+        systemGray: "#8E8E93",
+        systemGray2: "#AEAEB2",
+        systemGray3: "#C7C7CC",
+        systemGray4: "#D1D1D6",
+        systemGray5: "#E5E5EA",
+        systemGray6: "#F2F2F7",
+    },
+    // Android Material colors
+    android: {
+        primary: "#6200EE",
+        primaryVariant: "#3700B3",
+        secondary: "#03DAC6",
+        secondaryVariant: "#018786",
+        background: "#FFFFFF",
+        surface: "#FFFFFF",
+        error: "#B00020",
+        onPrimary: "#FFFFFF",
+        onSecondary: "#000000",
+        onBackground: "#000000",
+        onSurface: "#000000",
+        onError: "#FFFFFF",
+    },
+    // Transparent colors
+    transparent: "transparent",
+    black: "#000000",
+    white: "#FFFFFF",
+};
+export const spacing = {
+    0: 0,
+    1: 4,
+    2: 8,
+    3: 12,
+    4: 16,
+    5: 20,
+    6: 24,
+    7: 28,
+    8: 32,
+    9: 36,
+    10: 40,
+    11: 44,
+    12: 48,
+    14: 56,
+    16: 64,
+    20: 80,
+    24: 96,
+    28: 112,
+    32: 128,
+    36: 144,
+    40: 160,
+    44: 176,
+    48: 192,
+    52: 208,
+    56: 224,
+    60: 240,
+    64: 256,
+    72: 288,
+    80: 320,
+    96: 384,
+    auto: "auto",
+};
+export const borderRadius = {
+    none: 0,
+    sm: 4,
+    md: 8,
+    lg: 12,
+    xl: 16,
+    "2xl": 20,
+    "3xl": 24,
+    full: 999,
+};
+export const typography = {
+    // iOS system font sizes
+    ios: {
+        largeTitle: {
+            fontSize: 34,
+            lineHeight: 41,
+            fontWeight: "700",
+        },
+        title1: {
+            fontSize: 28,
+            lineHeight: 34,
+            fontWeight: "700",
+        },
+        title2: {
+            fontSize: 22,
+            lineHeight: 28,
+            fontWeight: "700",
+        },
+        title3: {
+            fontSize: 20,
+            lineHeight: 25,
+            fontWeight: "600",
+        },
+        headline: {
+            fontSize: 17,
+            lineHeight: 22,
+            fontWeight: "600",
+        },
+        body: {
+            fontSize: 17,
+            lineHeight: 22,
+            fontWeight: "400",
+        },
+        callout: {
+            fontSize: 16,
+            lineHeight: 21,
+            fontWeight: "400",
+        },
+        subhead: {
+            fontSize: 15,
+            lineHeight: 20,
+            fontWeight: "400",
+        },
+        footnote: {
+            fontSize: 13,
+            lineHeight: 18,
+            fontWeight: "400",
+        },
+        caption1: {
+            fontSize: 12,
+            lineHeight: 16,
+            fontWeight: "400",
+        },
+        caption2: {
+            fontSize: 11,
+            lineHeight: 13,
+            fontWeight: "400",
+        },
+    },
+    // Android Material typography
+    android: {
+        headline1: {
+            fontSize: 96,
+            lineHeight: 112,
+            fontWeight: "300",
+        },
+        headline2: {
+            fontSize: 60,
+            lineHeight: 72,
+            fontWeight: "300",
+        },
+        headline3: {
+            fontSize: 48,
+            lineHeight: 56,
+            fontWeight: "400",
+        },
+        headline4: {
+            fontSize: 34,
+            lineHeight: 42,
+            fontWeight: "400",
+        },
+        headline5: {
+            fontSize: 24,
+            lineHeight: 32,
+            fontWeight: "400",
+        },
+        headline6: {
+            fontSize: 20,
+            lineHeight: 28,
+            fontWeight: "500",
+        },
+        subtitle1: {
+            fontSize: 16,
+            lineHeight: 24,
+            fontWeight: "400",
+        },
+        subtitle2: {
+            fontSize: 14,
+            lineHeight: 22,
+            fontWeight: "500",
+        },
+        body1: {
+            fontSize: 16,
+            lineHeight: 24,
+            fontWeight: "400",
+        },
+        body2: {
+            fontSize: 14,
+            lineHeight: 20,
+            fontWeight: "400",
+        },
+        button: {
+            fontSize: 14,
+            lineHeight: 16,
+            fontWeight: "500",
+        },
+        caption: {
+            fontSize: 12,
+            lineHeight: 16,
+            fontWeight: "400",
+        },
+        overline: {
+            fontSize: 10,
+            lineHeight: 16,
+            fontWeight: "400",
+        },
+    },
+    // Universal typography scale
+    universal: {
+        xs: {
+            fontSize: 12,
+            lineHeight: 16,
+            fontWeight: "400",
+        },
+        sm: {
+            fontSize: 14,
+            lineHeight: 20,
+            fontWeight: "400",
+        },
+        base: {
+            fontSize: 16,
+            lineHeight: 24,
+            fontWeight: "400",
+        },
+        lg: {
+            fontSize: 18,
+            lineHeight: 28,
+            fontWeight: "400",
+        },
+        xl: {
+            fontSize: 20,
+            lineHeight: 28,
+            fontWeight: "500",
+        },
+        "2xl": {
+            fontSize: 24,
+            lineHeight: 32,
+            fontWeight: "600",
+        },
+        "3xl": {
+            fontSize: 30,
+            lineHeight: 36,
+            fontWeight: "700",
+        },
+        "4xl": {
+            fontSize: 36,
+            lineHeight: 40,
+            fontWeight: "700",
+        },
+    },
+};
+export const shadows = {
+    none: {
+        shadowColor: "transparent",
+        shadowOffset: { width: 0, height: 0 },
+        shadowOpacity: 0,
+        shadowRadius: 0,
+        elevation: 0,
+    },
+    sm: {
+        shadowColor: colors.black,
+        shadowOffset: { width: 0, height: 1 },
+        shadowOpacity: 0.05,
+        shadowRadius: 2,
+        elevation: 2,
+    },
+    md: {
+        shadowColor: colors.black,
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.1,
+        shadowRadius: 4,
+        elevation: 4,
+    },
+    lg: {
+        shadowColor: colors.black,
+        shadowOffset: { width: 0, height: 4 },
+        shadowOpacity: 0.15,
+        shadowRadius: 8,
+        elevation: 8,
+    },
+    xl: {
+        shadowColor: colors.black,
+        shadowOffset: { width: 0, height: 8 },
+        shadowOpacity: 0.2,
+        shadowRadius: 16,
+        elevation: 16,
+    },
+};
+// Touch targets (iOS Human Interface Guidelines)
+export const touchTargets = {
+    minimum: 44, // Minimum touch target size
+    comfortable: 48, // Comfortable touch target size
+    large: 56, // Large touch target size
+};
+// Animation durations
+export const animations = {
+    fast: 150,
+    normal: 200,
+    slow: 300,
+    slower: 500,
+};
+// Breakpoints for responsive design
+export const breakpoints = {
+    sm: 640,
+    md: 768,
+    lg: 1024,
+    xl: 1280,
+    "2xl": 1536,
+};

package/dist/lib/utils.js

@@ -0,0 +1,94 @@
+import { StyleSheet } from "react-native";
+/**
+ * Merges React Native styles similar to how cn() merges CSS classes
+ * Handles arrays, objects, and falsy values
+ */
+export function mergeStyles(...styles) {
+    const validStyles = styles.filter(Boolean).flat();
+    return StyleSheet.flatten(validStyles) || {};
+}
+/**
+ * Creates a style merger function that includes base styles
+ * Useful for component variants
+ */
+export function createStyleMerger(baseStyle) {
+    return (...styles) => {
+        return mergeStyles(baseStyle, ...styles);
+    };
+}
+/**
+ * Conditionally applies styles based on boolean conditions
+ */
+export function conditionalStyle(condition, trueStyle, falseStyle) {
+    return condition ? trueStyle : falseStyle;
+}
+/**
+ * Creates responsive values based on screen dimensions
+ */
+export function responsiveValue(values, screenWidth) {
+    if (screenWidth >= 1280 && values.xl !== undefined)
+        return values.xl;
+    if (screenWidth >= 1024 && values.lg !== undefined)
+        return values.lg;
+    if (screenWidth >= 768 && values.md !== undefined)
+        return values.md;
+    if (screenWidth >= 640 && values.sm !== undefined)
+        return values.sm;
+    return values.default;
+}
+/**
+ * Creates platform-specific styles
+ */
+export function platformStyle(styles) {
+    const Platform = require("react-native").Platform;
+    if (Platform.OS === "ios" && styles.ios)
+        return styles.ios;
+    if (Platform.OS === "android" && styles.android)
+        return styles.android;
+    if (Platform.OS === "web" && styles.web)
+        return styles.web;
+    return styles.default || {};
+}
+/**
+ * Converts hex color to rgba
+ */
+export function hexToRgba(hex, alpha = 1) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    if (!result)
+        return hex;
+    const r = parseInt(result[1], 16);
+    const g = parseInt(result[2], 16);
+    const b = parseInt(result[3], 16);
+    return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}
+/**
+ * Creates a debounced function for performance
+ */
+export function debounce(func, delay) {
+    let timeoutId;
+    return (...args) => {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => func(...args), delay);
+    };
+}
+/**
+ * Creates a throttled function for performance
+ */
+export function throttle(func, delay) {
+    let lastCall = 0;
+    return (...args) => {
+        const now = Date.now();
+        if (now - lastCall >= delay) {
+            lastCall = now;
+            func(...args);
+        }
+    };
+}
+/**
+ * Type-safe component prop forwarding
+ */
+export function forwardProps(props, omit) {
+    const result = { ...props };
+    omit.forEach((key) => delete result[key]);
+    return result;
+}