@gaozh1024/rn-kit 0.2.0-beta.0

package/dist/index.mjs

@@ -0,0 +1,4504 @@
+// src/utils/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/utils/color.ts
+function hexToRgb(hex) {
+  const clean = hex.replace("#", "");
+  const bigint = parseInt(clean, 16);
+  return {
+    r: bigint >> 16 & 255,
+    g: bigint >> 8 & 255,
+    b: bigint & 255
+  };
+}
+function rgbToHex(rgb) {
+  return "#" + [rgb.r, rgb.g, rgb.b].map((x) => x.toString(16).padStart(2, "0")).join("");
+}
+function adjustBrightness(rgb, factor) {
+  const adjust = (c) => Math.max(0, Math.min(255, c + (factor > 0 ? (255 - c) * factor : c * factor)));
+  return { r: adjust(rgb.r), g: adjust(rgb.g), b: adjust(rgb.b) };
+}
+function generateColorPalette(baseHex) {
+  const rgb = hexToRgb(baseHex);
+  const factors = {
+    0: 0.95,
+    50: 0.9,
+    100: 0.75,
+    200: 0.5,
+    300: 0.3,
+    400: 0.1,
+    500: 0,
+    600: -0.1,
+    700: -0.25,
+    800: -0.4,
+    900: -0.55,
+    950: -0.7
+  };
+  const result = {};
+  for (const [level, factor] of Object.entries(factors)) {
+    result[parseInt(level)] = rgbToHex(adjustBrightness(rgb, factor));
+  }
+  return result;
+}
+
+// src/utils/platform.ts
+function isDevelopment() {
+  return process.env.NODE_ENV === "development";
+}
+
+// src/utils/date/index.ts
+function formatDate(date, format = "yyyy-MM-dd") {
+  const d = new Date(date);
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return format.replace("yyyy", String(year)).replace("MM", month).replace("dd", day);
+}
+function formatRelativeTime(date) {
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - new Date(date).getTime();
+  const minutes = Math.floor(diff / 6e4);
+  const hours = Math.floor(diff / 36e5);
+  const days = Math.floor(diff / 864e5);
+  if (minutes < 1) return "\u521A\u521A";
+  if (minutes < 60) return `${minutes}\u5206\u949F\u524D`;
+  if (hours < 24) return `${hours}\u5C0F\u65F6\u524D`;
+  if (days < 30) return `${days}\u5929\u524D`;
+  return formatDate(date);
+}
+
+// src/utils/string/index.ts
+function truncate(str, length, suffix = "...") {
+  if (str.length <= length) return str;
+  return str.slice(0, length - suffix.length) + suffix;
+}
+function slugify(str) {
+  return str.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-");
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/utils/number/index.ts
+function formatNumber(num) {
+  return num.toLocaleString("zh-CN");
+}
+function formatCurrency(num, currency = "\xA5") {
+  return `${currency}${formatNumber(num)}`;
+}
+function formatPercent(num, decimals = 2) {
+  return `${(num * 100).toFixed(decimals)}%`;
+}
+function clamp(num, min, max) {
+  return Math.min(Math.max(num, min), max);
+}
+
+// src/utils/object/index.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+      result[key] = deepMerge(result[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) result[key] = obj[key];
+  }
+  return result;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) delete result[key];
+  return result;
+}
+
+// src/utils/validation/index.ts
+function getValidationErrors(error) {
+  const errors = {};
+  for (const issue of error.issues) {
+    const path = issue.path.join(".");
+    errors[path] = issue.message;
+  }
+  return errors;
+}
+function isValidEmail(email) {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}
+function isValidPhone(phone) {
+  return /^1[3-9]\d{9}$/.test(phone);
+}
+
+// src/theme/create-theme.ts
+var defaultSpacing = {
+  0: 0,
+  1: 4,
+  2: 8,
+  3: 12,
+  4: 16,
+  5: 20,
+  6: 24,
+  8: 32,
+  10: 40,
+  12: 48
+};
+var defaultBorderRadius = {
+  none: 0,
+  sm: 2,
+  md: 6,
+  lg: 8,
+  xl: 12,
+  "2xl": 16,
+  "3xl": 24,
+  full: 9999
+};
+var defaultColors = {
+  background: "#ffffff",
+  card: "#ffffff",
+  text: "#1f2937",
+  border: "#e5e7eb",
+  error: "#ef4444",
+  success: "#22c55e",
+  warning: "#f59e0b",
+  info: "#3b82f6"
+};
+function resolveColor(token) {
+  return typeof token === "string" ? generateColorPalette(token) : token;
+}
+function createTheme(config) {
+  const colors = {};
+  for (const [name, value] of Object.entries(defaultColors)) {
+    colors[name] = resolveColor(value);
+  }
+  for (const [name, token] of Object.entries(config.colors)) {
+    colors[name] = resolveColor(token);
+  }
+  return {
+    colors,
+    spacing: config.spacing ?? defaultSpacing,
+    borderRadius: config.borderRadius ?? defaultBorderRadius
+  };
+}
+
+// src/theme/provider.tsx
+import { createContext, useContext, useState, useMemo } from "react";
+import { jsx } from "nativewind/jsx-runtime";
+var ThemeContext = createContext(null);
+var fallbackTheme = createTheme({
+  colors: {
+    primary: "#f38b32",
+    secondary: "#3b82f6",
+    background: "#ffffff",
+    card: "#ffffff",
+    text: "#1f2937",
+    border: "#e5e7eb",
+    error: "#ef4444",
+    success: "#22c55e",
+    warning: "#f59e0b",
+    info: "#3b82f6"
+  }
+});
+function ThemeProvider({
+  children,
+  light,
+  dark,
+  defaultDark = false,
+  isDark: controlledIsDark,
+  onThemeChange
+}) {
+  const [internalIsDark, setInternalIsDark] = useState(defaultDark);
+  const isDark = controlledIsDark ?? internalIsDark;
+  const theme = useMemo(() => {
+    const config = isDark && dark ? dark : light;
+    return createTheme(config);
+  }, [isDark, light, dark]);
+  const toggleTheme = () => {
+    const nextIsDark = !isDark;
+    if (controlledIsDark === void 0) {
+      setInternalIsDark(nextIsDark);
+    }
+    onThemeChange?.(nextIsDark);
+  };
+  return /* @__PURE__ */ jsx(ThemeContext.Provider, { value: { theme, isDark, toggleTheme }, children });
+}
+function useTheme() {
+  const context = useContext(ThemeContext);
+  if (!context) throw new Error("useTheme must be used within ThemeProvider");
+  return context;
+}
+function useOptionalTheme() {
+  const context = useContext(ThemeContext);
+  return context || {
+    theme: fallbackTheme,
+    isDark: false,
+    toggleTheme: () => {
+    }
+  };
+}
+
+// src/theme/tokens.ts
+import { useMemo as useMemo2 } from "react";
+function getThemeColors(theme, isDark) {
+  return {
+    primary: theme.colors.primary?.[500] || "#f38b32",
+    primarySurface: isDark ? theme.colors.primary?.[900] || "#7c2d12" : theme.colors.primary?.[50] || "#fff7ed",
+    background: theme.colors.background?.[500] || (isDark ? "#0a0a0a" : "#ffffff"),
+    card: theme.colors.card?.[500] || (isDark ? "#1f2937" : "#ffffff"),
+    cardElevated: (isDark ? theme.colors.card?.[800] || theme.colors.card?.[700] : theme.colors.card?.[500]) || (isDark ? "#1f2937" : "#ffffff"),
+    text: theme.colors.text?.[500] || (isDark ? "#ffffff" : "#1f2937"),
+    textSecondary: isDark ? "#d1d5db" : "#374151",
+    textMuted: isDark ? "#9ca3af" : "#6b7280",
+    textInverse: "#ffffff",
+    border: isDark ? theme.colors.border?.[600] || theme.colors.border?.[500] || "#4b5563" : theme.colors.border?.[500] || "#d1d5db",
+    divider: isDark ? theme.colors.border?.[700] || theme.colors.border?.[500] || "#374151" : theme.colors.border?.[500] || "#e5e7eb",
+    iconMuted: isDark ? "#9ca3af" : "#6b7280"
+  };
+}
+function useThemeColors() {
+  const { theme, isDark } = useOptionalTheme();
+  return useMemo2(() => getThemeColors(theme, isDark), [theme, isDark]);
+}
+
+// src/core/index.ts
+import { z } from "zod";
+import { useQuery, useMutation } from "@tanstack/react-query";
+
+// src/core/error/types.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["VALIDATION"] = "VALIDATION";
+  ErrorCode2["NETWORK"] = "NETWORK";
+  ErrorCode2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  ErrorCode2["FORBIDDEN"] = "FORBIDDEN";
+  ErrorCode2["SERVER"] = "SERVER";
+  ErrorCode2["BUSINESS"] = "BUSINESS";
+  ErrorCode2["UNKNOWN"] = "UNKNOWN";
+  return ErrorCode2;
+})(ErrorCode || {});
+
+// src/core/error/helpers.ts
+function mapHttpStatus(status) {
+  if (status === 401) return "UNAUTHORIZED" /* UNAUTHORIZED */;
+  if (status === 403) return "FORBIDDEN" /* FORBIDDEN */;
+  if (status >= 400 && status < 500) return "VALIDATION" /* VALIDATION */;
+  if (status >= 500) return "SERVER" /* SERVER */;
+  return "UNKNOWN" /* UNKNOWN */;
+}
+function enhanceError(error) {
+  return {
+    ...error,
+    get isValidation() {
+      return error.code === "VALIDATION" /* VALIDATION */;
+    },
+    get isNetwork() {
+      return error.code === "NETWORK" /* NETWORK */;
+    },
+    get isAuth() {
+      return error.code === "UNAUTHORIZED" /* UNAUTHORIZED */ || error.code === "FORBIDDEN" /* FORBIDDEN */;
+    },
+    get isRetryable() {
+      return error.retryable ?? error.code === "NETWORK" /* NETWORK */;
+    }
+  };
+}
+
+// src/core/hooks/useAsyncState.ts
+import { useState as useState2, useCallback } from "react";
+function useAsyncState() {
+  const [data, setData] = useState2(null);
+  const [error, setError] = useState2(null);
+  const [loading, setLoading] = useState2(false);
+  const execute = useCallback(async (promise) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await promise;
+      setData(result);
+      return result;
+    } catch (err) {
+      const appError = {
+        code: err.code || "UNKNOWN",
+        message: err.message || "Unknown error",
+        ...err
+      };
+      const enhanced = enhanceError(appError);
+      setError(enhanced);
+      throw enhanced;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const reset = useCallback(() => {
+    setData(null);
+    setError(null);
+    setLoading(false);
+  }, []);
+  return { data, error, loading, execute, reset };
+}
+
+// src/core/api/create-api.ts
+import { ZodError } from "zod";
+function parseZodError(error) {
+  const first = error.errors[0];
+  return {
+    code: "VALIDATION" /* VALIDATION */,
+    message: first?.message || "Validation failed",
+    field: first?.path.join(".")
+  };
+}
+function isAppError(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && "message" in error && typeof error.message === "string";
+}
+function parseNetworkError(error) {
+  return {
+    code: "NETWORK" /* NETWORK */,
+    message: error instanceof Error ? error.message : "Network request failed",
+    retryable: true,
+    original: error
+  };
+}
+function parseHttpError(response, data) {
+  const fallbackMessage = response.statusText || `Request failed with status ${response.status}`;
+  const message = typeof data === "object" && data !== null && "message" in data && typeof data.message === "string" ? data.message : fallbackMessage;
+  return {
+    code: mapHttpStatus(response.status),
+    message,
+    statusCode: response.status,
+    retryable: response.status >= 500,
+    original: data
+  };
+}
+function parseUnknownError(error) {
+  if (error instanceof ZodError) {
+    return parseZodError(error);
+  }
+  if (isAppError(error)) {
+    return error;
+  }
+  return {
+    code: "UNKNOWN" /* UNKNOWN */,
+    message: error instanceof Error ? error.message : "Unknown error",
+    original: error
+  };
+}
+async function notifyError(error, context, endpoint, config) {
+  const enhanced = enhanceError(error);
+  await endpoint.onError?.(enhanced, context);
+  await config.onError?.(enhanced, context);
+  return enhanced;
+}
+function createAPI(config) {
+  const endpoints = {};
+  const fetcher = config.fetcher ?? fetch;
+  for (const [name, ep] of Object.entries(config.endpoints)) {
+    endpoints[name] = async (input) => {
+      const context = {
+        endpointName: name,
+        path: ep.path,
+        method: ep.method,
+        input
+      };
+      if (ep.input) {
+        const result = ep.input.safeParse(input);
+        if (!result.success) {
+          throw await notifyError(parseZodError(result.error), context, ep, config);
+        }
+      }
+      const url = config.baseURL + ep.path;
+      let response;
+      try {
+        response = await fetcher(url, { method: ep.method });
+      } catch (error) {
+        throw await notifyError(parseNetworkError(error), context, ep, config);
+      }
+      context.response = response;
+      let data = void 0;
+      const contentType = response.headers.get("content-type") || "";
+      const canParseJson = contentType.includes("application/json");
+      if (canParseJson) {
+        try {
+          data = await response.json();
+        } catch {
+          data = void 0;
+        }
+      }
+      context.responseData = data;
+      if (!response.ok) {
+        throw await notifyError(parseHttpError(response, data), context, ep, config);
+      }
+      const businessError = ep.parseBusinessError?.(data, response) ?? config.parseBusinessError?.(data, response);
+      if (businessError) {
+        throw await notifyError(businessError, context, ep, config);
+      }
+      try {
+        if (ep.output) {
+          return ep.output.parse(data);
+        }
+      } catch (error) {
+        throw await notifyError(parseUnknownError(error), context, ep, config);
+      }
+      return data;
+    };
+  }
+  return endpoints;
+}
+
+// src/core/storage/memory-storage.ts
+var MemoryStorage = class {
+  constructor() {
+    /** 内部存储的 Map 实例 */
+    this.memory = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 存储键值对
+   * @param key - 存储键名
+   * @param value - 要存储的字符串值
+   * @returns 解析为 void 的 Promise
+   */
+  async setItem(key, value) {
+    this.memory.set(key, value);
+  }
+  /**
+   * 根据键名获取值
+   * @param key - 存储键名
+   * @returns 存储的字符串值，如果不存在则返回 null
+   */
+  async getItem(key) {
+    return this.memory.get(key) ?? null;
+  }
+  /**
+   * 删除指定键名的存储项
+   * @param key - 要删除的键名
+   * @returns 解析为 void 的 Promise
+   */
+  async removeItem(key) {
+    this.memory.delete(key);
+  }
+};
+var storage = new MemoryStorage();
+
+// src/core/hooks/useRequest.ts
+import { useState as useState3, useCallback as useCallback2, useRef, useEffect } from "react";
+function useRequest(service, options = {}) {
+  const {
+    manual = false,
+    deps = [],
+    defaultParams,
+    onSuccess,
+    onError,
+    onFinally,
+    retryCount = 0,
+    retryDelay = 1e3
+  } = options;
+  const [data, setData] = useState3(void 0);
+  const [loading, setLoading] = useState3(!manual);
+  const [error, setError] = useState3(void 0);
+  const serviceRef = useRef(service);
+  const paramsRef = useRef(defaultParams);
+  const retryCountRef = useRef(0);
+  const canceledRef = useRef(false);
+  serviceRef.current = service;
+  const run = useCallback2(
+    async (...params) => {
+      paramsRef.current = params;
+      setLoading(true);
+      setError(void 0);
+      try {
+        const result = await serviceRef.current(...params);
+        if (!canceledRef.current) {
+          setData(result);
+          retryCountRef.current = 0;
+          onSuccess?.(result, params);
+        }
+        return result;
+      } catch (err) {
+        if (!canceledRef.current) {
+          const error2 = err instanceof Error ? err : new Error(String(err));
+          setError(error2);
+          onError?.(error2, params);
+          if (retryCountRef.current < retryCount) {
+            retryCountRef.current++;
+            setTimeout(() => {
+              if (!canceledRef.current) {
+                run(...params);
+              }
+            }, retryDelay * retryCountRef.current);
+          }
+        }
+        throw err;
+      } finally {
+        if (!canceledRef.current) {
+          setLoading(false);
+          onFinally?.(params);
+        }
+      }
+    },
+    [onSuccess, onError, onFinally, retryCount, retryDelay]
+  );
+  const refresh = useCallback2(() => {
+    if (paramsRef.current) {
+      return run(...paramsRef.current);
+    }
+    throw new Error("No params to refresh");
+  }, [run]);
+  const cancel = useCallback2(() => {
+    canceledRef.current = true;
+  }, []);
+  const mutate = useCallback2((newData) => {
+    setData((prev) => {
+      if (typeof newData === "function") {
+        return newData(prev);
+      }
+      return newData;
+    });
+  }, []);
+  useEffect(() => {
+    if (!manual) {
+      run(...defaultParams || []);
+    }
+    return () => {
+      canceledRef.current = true;
+    };
+  }, deps);
+  return {
+    data,
+    loading,
+    error,
+    run,
+    refresh,
+    cancel,
+    mutate
+  };
+}
+
+// src/core/hooks/usePagination.ts
+import { useState as useState4, useCallback as useCallback3, useRef as useRef2 } from "react";
+function usePagination(service, options = {}) {
+  const { defaultCurrent = 1, defaultPageSize = 10 } = options;
+  const [data, setData] = useState4([]);
+  const [current, setCurrent] = useState4(defaultCurrent);
+  const [pageSize] = useState4(defaultPageSize);
+  const [total, setTotal] = useState4(0);
+  const [loading, setLoading] = useState4(false);
+  const [refreshing, setRefreshing] = useState4(false);
+  const [loadingMore, setLoadingMore] = useState4(false);
+  const [error, setError] = useState4(null);
+  const serviceRef = useRef2(service);
+  serviceRef.current = service;
+  const hasMore = data.length < total;
+  const fetch2 = useCallback3(async (params, isRefresh = false) => {
+    try {
+      const result = await serviceRef.current(params);
+      const items = result.data ?? result.list ?? [];
+      if (isRefresh) {
+        setData(items);
+      } else {
+        setData((prev) => [...prev, ...items]);
+      }
+      setTotal(result.total);
+      setError(null);
+      return result;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      throw err;
+    }
+  }, []);
+  const refresh = useCallback3(async () => {
+    setRefreshing(true);
+    try {
+      await fetch2({ current: 1, pageSize }, true);
+      setCurrent(1);
+    } finally {
+      setRefreshing(false);
+    }
+  }, [fetch2, pageSize]);
+  const loadMore = useCallback3(async () => {
+    if (loadingMore || !hasMore) return;
+    setLoadingMore(true);
+    try {
+      const nextPage = current + 1;
+      await fetch2({ current: nextPage, pageSize }, false);
+      setCurrent(nextPage);
+    } finally {
+      setLoadingMore(false);
+    }
+  }, [fetch2, current, pageSize, loadingMore, hasMore]);
+  const changePage = useCallback3(
+    async (page) => {
+      setLoading(true);
+      try {
+        await fetch2({ current: page, pageSize }, true);
+        setCurrent(page);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [fetch2, pageSize]
+  );
+  return {
+    data,
+    current,
+    pageSize,
+    total,
+    hasMore,
+    loading,
+    refreshing,
+    loadingMore,
+    error,
+    refresh,
+    loadMore,
+    changePage
+  };
+}
+
+// src/core/hooks/usePrevious.ts
+import { useRef as useRef3, useEffect as useEffect2 } from "react";
+function usePrevious(value) {
+  const ref = useRef3(void 0);
+  useEffect2(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+
+// src/core/hooks/useSetState.ts
+import { useState as useState5, useCallback as useCallback4 } from "react";
+function useSetState(initialState) {
+  const [state, setState] = useState5(initialState);
+  const setMergeState = useCallback4((patch) => {
+    setState((prev) => ({
+      ...prev,
+      ...typeof patch === "function" ? patch(prev) : patch
+    }));
+  }, []);
+  const resetState = useCallback4(() => {
+    setState(initialState);
+  }, [initialState]);
+  return [state, setMergeState, resetState];
+}
+
+// src/core/hooks/useMemoizedFn.ts
+import { useRef as useRef4, useCallback as useCallback5 } from "react";
+function useMemoizedFn(fn) {
+  const fnRef = useRef4(fn);
+  fnRef.current = fn;
+  const memoizedFn = useCallback5(
+    ((...args) => {
+      return fnRef.current(...args);
+    }),
+    []
+  );
+  return memoizedFn;
+}
+
+// src/core/hooks/useUpdateEffect.ts
+import { useEffect as useEffect3, useRef as useRef5 } from "react";
+function useUpdateEffect(effect, deps) {
+  const isFirstRender = useRef5(true);
+  useEffect3(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      return;
+    }
+    return effect();
+  }, deps);
+}
+
+// src/core/hooks/useStorage.ts
+import { useState as useState6, useEffect as useEffect4, useCallback as useCallback6 } from "react";
+function useStorage(key, defaultValue) {
+  const [value, setValue] = useState6(defaultValue);
+  const [, setIsLoaded] = useState6(false);
+  useEffect4(() => {
+    const loadValue = async () => {
+      try {
+        const stored = await storage.getItem(key);
+        if (stored !== null) {
+          setValue(JSON.parse(stored));
+        }
+      } catch (error) {
+        console.warn(`Failed to load storage key "${key}":`, error);
+      } finally {
+        setIsLoaded(true);
+      }
+    };
+    loadValue();
+  }, [key]);
+  const setStoredValue = useCallback6(
+    async (newValue) => {
+      try {
+        const valueToStore = newValue instanceof Function ? newValue(value) : newValue;
+        setValue(valueToStore);
+        await storage.setItem(key, JSON.stringify(valueToStore));
+      } catch (error) {
+        console.warn(`Failed to save storage key "${key}":`, error);
+      }
+    },
+    [key, value]
+  );
+  const removeValue = useCallback6(async () => {
+    try {
+      setValue(defaultValue);
+      await storage.removeItem(key);
+    } catch (error) {
+      console.warn(`Failed to remove storage key "${key}":`, error);
+    }
+  }, [key, defaultValue]);
+  return [value, setStoredValue, removeValue];
+}
+
+// src/core/hooks/useRefresh.ts
+import { useState as useState7, useCallback as useCallback7 } from "react";
+function useRefresh(fetcher) {
+  const [data, setData] = useState7(void 0);
+  const [refreshing, setRefreshing] = useState7(false);
+  const [error, setError] = useState7(void 0);
+  const refresh = useCallback7(async () => {
+    setRefreshing(true);
+    setError(void 0);
+    try {
+      const result = await fetcher();
+      setData(result);
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      setError(errorObj);
+    } finally {
+      setRefreshing(false);
+    }
+  }, [fetcher]);
+  return {
+    data,
+    refreshing,
+    error,
+    refresh
+  };
+}
+
+// src/core/hooks/useInfinite.ts
+import { useState as useState8, useCallback as useCallback8 } from "react";
+function useInfinite(fetcher, options = {}) {
+  const { defaultPage = 1, pageSize = 10 } = options;
+  const [data, setData] = useState8([]);
+  const [page, setPage] = useState8(defaultPage);
+  const [loading, setLoading] = useState8(false);
+  const [loadingMore, setLoadingMore] = useState8(false);
+  const [hasMore, setHasMore] = useState8(true);
+  const [error, setError] = useState8(void 0);
+  const fetchData = useCallback8(
+    async (targetPage, isLoadMore) => {
+      if (isLoadMore) {
+        setLoadingMore(true);
+      } else {
+        setLoading(true);
+      }
+      setError(void 0);
+      try {
+        const result = await fetcher({ page: targetPage, pageSize });
+        const items = result.data ?? result.list ?? [];
+        if (isLoadMore) {
+          setData((prev) => [...prev, ...items]);
+        } else {
+          setData(items);
+        }
+        setHasMore(result.hasMore);
+        setPage(targetPage);
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+      } finally {
+        setLoading(false);
+        setLoadingMore(false);
+      }
+    },
+    [fetcher, pageSize]
+  );
+  const load = useCallback8(async () => {
+    await fetchData(defaultPage, false);
+  }, [fetchData, defaultPage]);
+  const loadMore = useCallback8(async () => {
+    if (loadingMore || !hasMore) return;
+    await fetchData(page + 1, true);
+  }, [fetchData, page, loadingMore, hasMore]);
+  const refresh = useCallback8(async () => {
+    await fetchData(defaultPage, false);
+  }, [fetchData, defaultPage]);
+  const reset = useCallback8(() => {
+    setData([]);
+    setPage(defaultPage);
+    setLoading(false);
+    setLoadingMore(false);
+    setHasMore(true);
+    setError(void 0);
+  }, [defaultPage]);
+  return {
+    data,
+    page,
+    loading,
+    loadingMore,
+    hasMore,
+    error,
+    load,
+    loadMore,
+    refresh,
+    reset
+  };
+}
+
+// src/ui/primitives/AppView.tsx
+import { View } from "react-native";
+
+// src/ui/utils/theme-color.ts
+var grayPalette = {
+  50: "#f9fafb",
+  100: "#f3f4f6",
+  200: "#e5e7eb",
+  300: "#d1d5db",
+  400: "#9ca3af",
+  500: "#6b7280",
+  600: "#4b5563",
+  700: "#374151",
+  800: "#1f2937",
+  900: "#111827",
+  950: "#030712"
+};
+var staticPalettes = {
+  gray: grayPalette,
+  white: { 500: "#ffffff" },
+  black: { 500: "#000000" }
+};
+function resolvePaletteColor(name, shade, theme) {
+  const palette = theme.colors[name] ?? staticPalettes[name];
+  if (!palette) return void 0;
+  return palette[shade] ?? palette[500] ?? palette["500"];
+}
+function resolveNamedColor(color, theme, isDark) {
+  if (!color) return void 0;
+  switch (color) {
+    case "text":
+    case "foreground":
+    case "default":
+      return theme.colors.text?.[500] ?? (isDark ? "#ffffff" : "#1f2937");
+    case "muted":
+    case "text-muted":
+    case "secondary-text":
+      return isDark ? "#9ca3af" : "#6b7280";
+    case "inverse":
+    case "on-primary":
+      return "#ffffff";
+    case "background":
+    case "screen":
+    case "page":
+      return theme.colors.background?.[500] ?? (isDark ? "#0a0a0a" : "#ffffff");
+    case "card":
+    case "surface":
+      return theme.colors.card?.[500] ?? (isDark ? "#1f2937" : "#ffffff");
+    case "border":
+      return theme.colors.border?.[500] ?? (isDark ? "#404040" : "#e5e5e5");
+    case "danger":
+      return theme.colors.error?.[500] ?? "#ef4444";
+    case "success":
+    case "warning":
+    case "error":
+    case "info":
+    case "primary":
+    case "secondary":
+      return theme.colors[color]?.[500];
+    case "transparent":
+      return "transparent";
+  }
+  if (color.startsWith("#") || color.startsWith("rgb(") || color.startsWith("rgba(")) {
+    return color;
+  }
+  if (theme.colors[color]?.[500]) {
+    return theme.colors[color][500];
+  }
+  if (color.includes("-")) {
+    const [name, shade] = color.split("-");
+    if (name === "danger") {
+      return theme.colors.error?.[shade] ?? theme.colors.error?.[500] ?? "#ef4444";
+    }
+    return resolvePaletteColor(name, shade, theme);
+  }
+  return void 0;
+}
+function resolveSurfaceColor(surface, theme, isDark) {
+  switch (surface) {
+    case "background":
+      return theme.colors.background?.[500] ?? (isDark ? "#0a0a0a" : "#ffffff");
+    case "card":
+      return theme.colors.card?.[500] ?? (isDark ? "#1f2937" : "#ffffff");
+    case "muted":
+      return isDark ? "#111827" : "#f3f4f6";
+    default:
+      return void 0;
+  }
+}
+function resolveTextTone(tone, theme, isDark) {
+  switch (tone) {
+    case "default":
+      return theme.colors.text?.[500] ?? (isDark ? "#ffffff" : "#1f2937");
+    case "muted":
+      return isDark ? "#9ca3af" : "#6b7280";
+    case "inverse":
+      return "#ffffff";
+    case "primary":
+    case "secondary":
+    case "success":
+    case "warning":
+    case "error":
+      return resolveNamedColor(tone, theme, isDark);
+    default:
+      return void 0;
+  }
+}
+
+// src/ui/primitives/AppView.tsx
+import { jsx as jsx2 } from "nativewind/jsx-runtime";
+function AppView({
+  flex,
+  row,
+  center,
+  between,
+  items,
+  justify,
+  p,
+  px,
+  py,
+  gap,
+  bg,
+  surface,
+  rounded,
+  className,
+  children,
+  style,
+  ...props
+}) {
+  const { theme, isDark } = useOptionalTheme();
+  const resolvedBgColor = resolveSurfaceColor(surface, theme, isDark) ?? resolveNamedColor(bg, theme, isDark);
+  const shouldUseClassBg = !!bg && !resolvedBgColor;
+  return /* @__PURE__ */ jsx2(
+    View,
+    {
+      className: cn(
+        flex === true && "flex-1",
+        typeof flex === "number" && `flex-${flex}`,
+        row ? "flex-row" : "flex-col",
+        center && "items-center justify-center",
+        between && "justify-between",
+        items && `items-${items}`,
+        justify && `justify-${justify}`,
+        p !== void 0 && `p-${p}`,
+        px !== void 0 && `px-${px}`,
+        py !== void 0 && `py-${py}`,
+        gap !== void 0 && `gap-${gap}`,
+        shouldUseClassBg && `bg-${bg}`,
+        rounded && `rounded-${rounded}`,
+        className
+      ),
+      style: [resolvedBgColor ? { backgroundColor: resolvedBgColor } : void 0, style],
+      ...props,
+      children
+    }
+  );
+}
+
+// src/ui/primitives/AppScrollView.tsx
+import { ScrollView } from "react-native";
+import { jsx as jsx3 } from "nativewind/jsx-runtime";
+function AppScrollView({
+  flex,
+  bg,
+  p,
+  px,
+  py,
+  gap,
+  surface,
+  rounded,
+  className,
+  children,
+  style,
+  ...props
+}) {
+  const { theme, isDark } = useOptionalTheme();
+  const resolvedBgColor = resolveSurfaceColor(surface, theme, isDark) ?? resolveNamedColor(bg, theme, isDark);
+  const shouldUseClassBg = !!bg && !resolvedBgColor;
+  return /* @__PURE__ */ jsx3(
+    ScrollView,
+    {
+      className: cn(
+        flex && "flex-1",
+        shouldUseClassBg && `bg-${bg}`,
+        p !== void 0 && `p-${p}`,
+        px !== void 0 && `px-${px}`,
+        py !== void 0 && `py-${py}`,
+        gap !== void 0 && `gap-${gap}`,
+        rounded && `rounded-${rounded}`,
+        className
+      ),
+      style: [resolvedBgColor ? { backgroundColor: resolvedBgColor } : void 0, style],
+      ...props,
+      children
+    }
+  );
+}
+
+// src/ui/primitives/AppText.tsx
+import { Text } from "react-native";
+import { jsx as jsx4 } from "nativewind/jsx-runtime";
+function AppText({
+  size = "md",
+  weight = "normal",
+  color,
+  tone,
+  className,
+  children,
+  style,
+  ...props
+}) {
+  const { theme, isDark } = useOptionalTheme();
+  const sizeMap3 = {
+    xs: "text-xs",
+    sm: "text-sm",
+    md: "text-base",
+    lg: "text-lg",
+    xl: "text-xl",
+    "2xl": "text-2xl",
+    "3xl": "text-3xl"
+  };
+  const weightMap = {
+    normal: "font-normal",
+    medium: "font-medium",
+    semibold: "font-semibold",
+    bold: "font-bold"
+  };
+  const resolvedColor = resolveTextTone(tone, theme, isDark) ?? resolveNamedColor(color, theme, isDark);
+  const shouldUseClassColor = !!color && !resolvedColor;
+  return /* @__PURE__ */ jsx4(
+    Text,
+    {
+      className: cn(sizeMap3[size], weightMap[weight], shouldUseClassColor && `text-${color}`, className),
+      style: [resolvedColor ? { color: resolvedColor } : void 0, style],
+      ...props,
+      children
+    }
+  );
+}
+
+// src/ui/primitives/AppPressable.tsx
+import * as React2 from "react";
+import { Pressable } from "react-native";
+import { jsx as jsx5 } from "nativewind/jsx-runtime";
+function AppPressable({
+  className,
+  pressedClassName,
+  children,
+  ...props
+}) {
+  const [isPressed, setIsPressed] = React2.useState(false);
+  return /* @__PURE__ */ jsx5(
+    Pressable,
+    {
+      className: cn(className, isPressed && pressedClassName),
+      onPressIn: (e) => {
+        setIsPressed(true);
+        props.onPressIn?.(e);
+      },
+      onPressOut: (e) => {
+        setIsPressed(false);
+        props.onPressOut?.(e);
+      },
+      ...props,
+      children
+    }
+  );
+}
+
+// src/ui/layout/Row.tsx
+import { jsx as jsx6 } from "nativewind/jsx-runtime";
+var justifyMap = {
+  start: "justify-start",
+  center: "justify-center",
+  end: "justify-end",
+  between: "justify-between",
+  around: "justify-around"
+};
+var itemsMap = {
+  start: "items-start",
+  center: "items-center",
+  end: "items-end",
+  stretch: "items-stretch"
+};
+function Row({ justify = "start", items = "center", className, ...props }) {
+  return /* @__PURE__ */ jsx6(AppView, { row: true, className: cn(justifyMap[justify], itemsMap[items], className), ...props });
+}
+
+// src/ui/layout/Col.tsx
+import { jsx as jsx7 } from "nativewind/jsx-runtime";
+var justifyMap2 = {
+  start: "justify-start",
+  center: "justify-center",
+  end: "justify-end",
+  between: "justify-between",
+  around: "justify-around"
+};
+var itemsMap2 = {
+  start: "items-start",
+  center: "items-center",
+  end: "items-end",
+  stretch: "items-stretch"
+};
+function Col({ justify = "start", items = "stretch", className, ...props }) {
+  return /* @__PURE__ */ jsx7(AppView, { className: cn(justifyMap2[justify], itemsMap2[items], className), ...props });
+}
+
+// src/ui/layout/Center.tsx
+import { jsx as jsx8 } from "nativewind/jsx-runtime";
+function Center({ flex = true, ...props }) {
+  return /* @__PURE__ */ jsx8(AppView, { center: true, flex, ...props });
+}
+
+// src/ui/layout/SafeScreen.tsx
+import { View as View2, StyleSheet } from "react-native";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+import { jsx as jsx9 } from "nativewind/jsx-runtime";
+function SafeScreen({
+  top = true,
+  bottom = true,
+  left = false,
+  right = false,
+  bg,
+  flex = true,
+  className,
+  children,
+  style,
+  ...props
+}) {
+  const insets = useSafeAreaInsets();
+  const { theme, isDark } = useOptionalTheme();
+  const resolvedBgColor = resolveNamedColor(bg, theme, isDark);
+  const shouldUseClassBg = !!bg && !resolvedBgColor;
+  return /* @__PURE__ */ jsx9(
+    View2,
+    {
+      className: cn(flex && "flex-1", shouldUseClassBg && `bg-${bg}`, className),
+      style: [
+        flex && styles.flex,
+        resolvedBgColor ? { backgroundColor: resolvedBgColor } : void 0,
+        {
+          paddingTop: top ? insets.top : 0,
+          paddingBottom: bottom ? insets.bottom : 0,
+          paddingLeft: left ? insets.left : 0,
+          paddingRight: right ? insets.right : 0
+        },
+        style
+      ],
+      ...props,
+      children
+    }
+  );
+}
+var styles = StyleSheet.create({
+  flex: {
+    flex: 1
+  }
+});
+function Page({
+  children,
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx9(SafeScreen, { flex: true, bg: "background", ...props, className, children });
+}
+function SafeBottom({
+  children,
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx9(SafeScreen, { bottom: true, left: true, right: true, flex: false, ...props, className, children });
+}
+
+// src/ui/actions/AppButton.tsx
+import { ActivityIndicator } from "react-native";
+import { jsx as jsx10 } from "nativewind/jsx-runtime";
+function AppButton({
+  variant = "solid",
+  size = "md",
+  color = "primary",
+  loading,
+  disabled,
+  onPress,
+  children,
+  className
+}) {
+  const { theme, isDark } = useOptionalTheme();
+  const isDisabled = disabled || loading;
+  const sizeClasses = { sm: "px-3 py-2", md: "px-4 py-3", lg: "px-6 py-4" };
+  const buttonColors = {
+    primary: theme.colors.primary?.[500] || "#f38b32",
+    secondary: theme.colors.secondary?.[500] || "#3b82f6",
+    danger: theme.colors.error?.[500] || "#ef4444"
+  };
+  const ghostTextColor = isDark ? "#ffffff" : theme.colors.text?.[500] || "#1f2937";
+  const ghostBackgroundColor = isDark ? "rgba(255,255,255,0.04)" : "transparent";
+  const loadingColor = variant === "solid" ? "white" : buttonColors[color];
+  const textColor = variant === "solid" ? "#ffffff" : variant === "ghost" ? ghostTextColor : buttonColors[color];
+  const buttonStyle = variant === "solid" ? { backgroundColor: buttonColors[color] } : variant === "outline" ? { borderWidth: 0.5, borderColor: buttonColors[color], backgroundColor: "transparent" } : { backgroundColor: ghostBackgroundColor };
+  return /* @__PURE__ */ jsx10(
+    AppPressable,
+    {
+      onPress,
+      disabled: isDisabled,
+      className: cn(
+        "flex-row items-center justify-center rounded-lg",
+        sizeClasses[size],
+        isDisabled && "opacity-50",
+        className
+      ),
+      style: buttonStyle,
+      children: loading ? /* @__PURE__ */ jsx10(ActivityIndicator, { size: "small", color: loadingColor }) : /* @__PURE__ */ jsx10(AppText, { weight: "semibold", style: { color: textColor }, children })
+    }
+  );
+}
+
+// src/ui/feedback/Toast.tsx
+import { jsx as jsx11 } from "nativewind/jsx-runtime";
+var typeStyles = {
+  success: "bg-green-500",
+  error: "bg-red-500",
+  warning: "bg-yellow-500",
+  info: "bg-blue-500"
+};
+function Toast({ message, type = "info", visible = true }) {
+  if (!visible) return null;
+  return /* @__PURE__ */ jsx11(AppView, { className: cn("px-4 py-3 rounded-lg", typeStyles[type]), children: /* @__PURE__ */ jsx11(AppText, { color: "white", children: message }) });
+}
+
+// src/ui/feedback/Alert.tsx
+import { useCallback as useCallback9 } from "react";
+import { Modal, TouchableOpacity, StyleSheet as StyleSheet2 } from "react-native";
+import { jsx as jsx12, jsxs } from "nativewind/jsx-runtime";
+function Alert({ visible, title, message, buttons, onClose }) {
+  const { theme, isDark } = useTheme();
+  const modalBgColor = isDark ? "#1f2937" : "#ffffff";
+  const textColor = isDark ? "#ffffff" : "#1f2937";
+  const messageColor = isDark ? "#9ca3af" : "#6b7280";
+  const borderColor = isDark ? "#374151" : "#e5e7eb";
+  const cancelButtonBg = isDark ? "#374151" : "#f3f4f6";
+  const cancelButtonText = isDark ? "#ffffff" : "#374151";
+  const destructiveColor = theme.colors.error?.[500] || "#ef4444";
+  const handleButtonPress = useCallback9(
+    (button) => (e) => {
+      e.stopPropagation();
+      button.onPress?.();
+      onClose?.();
+    },
+    [onClose]
+  );
+  const getButtonStyle = (button) => {
+    if (button.style === "destructive") {
+      return {
+        backgroundColor: "transparent",
+        borderWidth: 0.5,
+        borderColor: destructiveColor
+      };
+    }
+    if (button.style === "cancel") {
+      return {
+        backgroundColor: cancelButtonBg,
+        borderWidth: 0.5,
+        borderColor: isDark ? "#4b5563" : "#d1d5db"
+      };
+    }
+    return {
+      backgroundColor: theme.colors.primary?.[500] || "#f38b32",
+      borderWidth: 0
+    };
+  };
+  const getButtonTextColor = (button) => {
+    if (button.style === "destructive") {
+      return destructiveColor;
+    }
+    if (button.style === "cancel") {
+      return cancelButtonText;
+    }
+    return "#ffffff";
+  };
+  return /* @__PURE__ */ jsx12(
+    Modal,
+    {
+      visible,
+      transparent: true,
+      animationType: "fade",
+      onRequestClose: onClose,
+      statusBarTranslucent: true,
+      children: /* @__PURE__ */ jsx12(AppView, { className: "flex-1", style: { backgroundColor: "rgba(0,0,0,0.5)" }, center: true, children: /* @__PURE__ */ jsxs(
+        AppView,
+        {
+          className: "rounded-xl mx-8 min-w-[280px]",
+          style: { backgroundColor: modalBgColor },
+          children: [
+            /* @__PURE__ */ jsxs(AppView, { className: "px-6 py-5", children: [
+              /* @__PURE__ */ jsx12(
+                AppText,
+                {
+                  size: "lg",
+                  weight: "semibold",
+                  className: "text-center mb-2",
+                  style: { color: textColor },
+                  children: title
+                }
+              ),
+              message && /* @__PURE__ */ jsx12(AppText, { size: "sm", style: { color: messageColor }, className: "text-center leading-5", children: message })
+            ] }),
+            /* @__PURE__ */ jsx12(AppView, { className: "border-t", style: { borderTopColor: borderColor }, children: buttons.length === 1 ? (
+              // 单个按钮
+              /* @__PURE__ */ jsx12(
+                TouchableOpacity,
+                {
+                  onPress: handleButtonPress(buttons[0]),
+                  className: "py-3 rounded-b-xl",
+                  style: [styles2.singleButton, getButtonStyle(buttons[0])],
+                  children: /* @__PURE__ */ jsx12(
+                    AppText,
+                    {
+                      weight: "medium",
+                      className: "text-center",
+                      style: { color: getButtonTextColor(buttons[0]) },
+                      children: buttons[0].text
+                    }
+                  )
+                }
+              )
+            ) : buttons.length === 2 ? (
+              // 两个按钮横向排列
+              /* @__PURE__ */ jsx12(AppView, { row: true, style: styles2.twoButtonContainer, children: buttons.map((button, index) => /* @__PURE__ */ jsx12(
+                TouchableOpacity,
+                {
+                  onPress: handleButtonPress(button),
+                  className: cn(
+                    "py-3 flex-1",
+                    index === 0 && "rounded-bl-xl",
+                    index === 1 && "rounded-br-xl"
+                  ),
+                  style: [
+                    styles2.twoButton,
+                    index > 0 && { borderLeftColor: borderColor },
+                    getButtonStyle(button)
+                  ],
+                  children: /* @__PURE__ */ jsx12(
+                    AppText,
+                    {
+                      weight: "medium",
+                      className: "text-center",
+                      style: { color: getButtonTextColor(button) },
+                      children: button.text
+                    }
+                  )
+                },
+                index
+              )) })
+            ) : (
+              // 多个按钮纵向排列
+              /* @__PURE__ */ jsx12(AppView, { className: "gap-2 pb-4 px-4", children: buttons.map((button, index) => /* @__PURE__ */ jsx12(
+                TouchableOpacity,
+                {
+                  onPress: handleButtonPress(button),
+                  className: "py-3 rounded-lg",
+                  style: getButtonStyle(button),
+                  children: /* @__PURE__ */ jsx12(
+                    AppText,
+                    {
+                      weight: "medium",
+                      className: "text-center",
+                      style: { color: getButtonTextColor(button) },
+                      children: button.text
+                    }
+                  )
+                },
+                index
+              )) })
+            ) })
+          ]
+        }
+      ) })
+    }
+  );
+}
+var styles2 = StyleSheet2.create({
+  singleButton: {
+    borderBottomLeftRadius: 12,
+    borderBottomRightRadius: 12
+  },
+  twoButtonContainer: {
+    borderBottomLeftRadius: 12,
+    borderBottomRightRadius: 12
+  },
+  twoButton: {
+    borderLeftWidth: 0.5
+  }
+});
+
+// src/ui/feedback/Loading.tsx
+import { ActivityIndicator as ActivityIndicator2 } from "react-native";
+import { jsx as jsx13, jsxs as jsxs2 } from "nativewind/jsx-runtime";
+function Loading({
+  text,
+  color,
+  overlay = false,
+  visible = true,
+  testID
+}) {
+  if (!visible) return null;
+  const content = /* @__PURE__ */ jsxs2(AppView, { center: true, gap: 3, testID, children: [
+    /* @__PURE__ */ jsx13(ActivityIndicator2, { size: "large", color }),
+    text && /* @__PURE__ */ jsx13(AppText, { style: color ? { color } : void 0, children: text })
+  ] });
+  if (overlay) {
+    return /* @__PURE__ */ jsx13(AppView, { center: true, flex: true, className: "absolute inset-0 bg-black/30", testID, children: content });
+  }
+  return content;
+}
+
+// src/ui/display/Progress.tsx
+import { jsx as jsx14 } from "nativewind/jsx-runtime";
+var sizeMap = { xs: "h-1", sm: "h-1.5", md: "h-2", lg: "h-3", xl: "h-4" };
+var colorMap = {
+  primary: "bg-primary-500",
+  secondary: "bg-secondary-500",
+  success: "bg-success-500",
+  warning: "bg-warning-500",
+  error: "bg-error-500"
+};
+function Progress({
+  value,
+  max = 100,
+  size = "md",
+  color = "primary",
+  testID,
+  className,
+  barClassName
+}) {
+  const { theme, isDark } = useTheme();
+  const percentage = Math.min(Math.max(value / max * 100, 0), 100);
+  const trackBgColor = isDark ? theme.colors.border?.[700] || "#374151" : "#e5e7eb";
+  return /* @__PURE__ */ jsx14(
+    AppView,
+    {
+      className: cn("w-full rounded-full", sizeMap[size], className),
+      style: { backgroundColor: trackBgColor },
+      testID,
+      children: /* @__PURE__ */ jsx14(
+        AppView,
+        {
+          className: cn("rounded-full", sizeMap[size], colorMap[color], barClassName),
+          style: { width: `${percentage}%` }
+        }
+      )
+    }
+  );
+}
+
+// src/ui/display/Card.tsx
+import { View as View3 } from "react-native";
+import { jsx as jsx15 } from "nativewind/jsx-runtime";
+function Card({
+  children,
+  className,
+  style,
+  noShadow = false,
+  noBorder = false,
+  noRadius = false,
+  ...props
+}) {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ jsx15(
+    View3,
+    {
+      className: cn(
+        !noRadius && "rounded-lg",
+        !noShadow && "shadow-sm",
+        "overflow-hidden",
+        className
+      ),
+      style: [
+        {
+          backgroundColor: colors.card,
+          ...noBorder ? {} : { borderWidth: 0.5, borderColor: colors.divider }
+        },
+        style
+      ],
+      ...props,
+      children
+    }
+  );
+}
+
+// src/ui/display/Icon.tsx
+import MaterialIcons from "react-native-vector-icons/MaterialIcons";
+import { jsx as jsx16 } from "nativewind/jsx-runtime";
+var sizeMap2 = {
+  xs: 16,
+  sm: 20,
+  md: 24,
+  lg: 32,
+  xl: 48
+};
+function resolveSize(size = "md") {
+  if (typeof size === "number") return size;
+  return sizeMap2[size] || 24;
+}
+function Icon({ name, size = "md", color = "gray-600", style, onPress, testID }) {
+  const { theme, isDark } = useOptionalTheme();
+  const resolvedSize = resolveSize(size);
+  const resolvedColor = resolveNamedColor(color, theme, isDark) ?? color;
+  if (onPress) {
+    return /* @__PURE__ */ jsx16(AppPressable, { onPress, testID, children: /* @__PURE__ */ jsx16(MaterialIcons, { name, size: resolvedSize, color: resolvedColor, style }) });
+  }
+  return /* @__PURE__ */ jsx16(
+    MaterialIcons,
+    {
+      name,
+      size: resolvedSize,
+      color: resolvedColor,
+      style,
+      testID
+    }
+  );
+}
+var NavigationIcons = {
+  home: "home",
+  explore: "explore",
+  profile: "person",
+  settings: "settings",
+  back: "arrow-back",
+  forward: "arrow-forward",
+  close: "close",
+  menu: "menu",
+  more: "more-vert"
+};
+var ActionIcons = {
+  add: "add",
+  edit: "edit",
+  delete: "delete",
+  search: "search",
+  share: "share",
+  favorite: "favorite",
+  favoriteBorder: "favorite-border",
+  check: "check",
+  checkCircle: "check-circle",
+  close: "close",
+  closeCircle: "cancel",
+  copy: "content-copy",
+  download: "download",
+  upload: "upload"
+};
+var StatusIcons = {
+  info: "info",
+  success: "check-circle",
+  warning: "warning",
+  error: "error",
+  help: "help",
+  loading: "refresh"
+};
+var FileIcons = {
+  file: "insert-drive-file",
+  image: "image",
+  video: "videocam",
+  audio: "audiotrack",
+  folder: "folder",
+  folderOpen: "folder-open"
+};
+
+// src/ui/display/AppImage.tsx
+import { useState as useState10, useCallback as useCallback10 } from "react";
+import {
+  Image,
+  ActivityIndicator as ActivityIndicator3,
+  View as View4
+} from "react-native";
+import { jsx as jsx17, jsxs as jsxs3 } from "nativewind/jsx-runtime";
+var radiusMap = {
+  none: 0,
+  sm: 2,
+  md: 6,
+  lg: 8,
+  xl: 12,
+  "2xl": 16,
+  full: 9999
+};
+function resolveRadius(radius) {
+  if (typeof radius === "number") return radius;
+  return radiusMap[radius || "none"];
+}
+function SkeletonItem() {
+  return /* @__PURE__ */ jsx17(AppView, { flex: true, className: "bg-gray-200 animate-pulse" });
+}
+function AppImage({
+  source,
+  width = "100%",
+  height = "auto",
+  borderRadius = "none",
+  placeholder,
+  errorPlaceholder,
+  loadingIndicator = false,
+  showError = false,
+  resizeMode = "cover",
+  onLoad,
+  onError,
+  onPress,
+  onLongPress,
+  className,
+  style
+}) {
+  const [isLoading, setIsLoading] = useState10(true);
+  const [hasError, setHasError] = useState10(false);
+  const { theme } = useTheme();
+  const resolvedRadius = resolveRadius(borderRadius);
+  const handleLoad = useCallback10(() => {
+    setIsLoading(false);
+    onLoad?.();
+  }, [onLoad]);
+  const handleError = useCallback10(
+    (error) => {
+      setIsLoading(false);
+      setHasError(true);
+      onError?.(error);
+    },
+    [onError]
+  );
+  const imageStyle = [
+    {
+      width: "100%",
+      height: "100%",
+      borderRadius: resolvedRadius
+    },
+    style
+  ];
+  const renderLoading = () => {
+    if (!isLoading) return null;
+    if (placeholder) {
+      return /* @__PURE__ */ jsx17(
+        Image,
+        {
+          source: placeholder,
+          style: {
+            position: "absolute",
+            width: "100%",
+            height: "100%",
+            borderRadius: resolvedRadius
+          },
+          resizeMode
+        }
+      );
+    }
+    if (loadingIndicator) {
+      if (typeof loadingIndicator === "boolean") {
+        return /* @__PURE__ */ jsx17(
+          AppView,
+          {
+            center: true,
+            className: "absolute inset-0 bg-gray-100",
+            style: { borderRadius: resolvedRadius },
+            children: /* @__PURE__ */ jsx17(ActivityIndicator3, { color: theme.colors.primary?.[500] })
+          }
+        );
+      }
+      return /* @__PURE__ */ jsx17(AppView, { center: true, className: "absolute inset-0", style: { borderRadius: resolvedRadius }, children: loadingIndicator });
+    }
+    return /* @__PURE__ */ jsx17(SkeletonItem, {});
+  };
+  const renderError = () => {
+    if (!hasError) return null;
+    if (errorPlaceholder) {
+      return /* @__PURE__ */ jsx17(
+        Image,
+        {
+          source: errorPlaceholder,
+          style: {
+            position: "absolute",
+            width: "100%",
+            height: "100%",
+            borderRadius: resolvedRadius
+          },
+          resizeMode
+        }
+      );
+    }
+    if (showError) {
+      return /* @__PURE__ */ jsx17(
+        AppView,
+        {
+          center: true,
+          className: "absolute inset-0 bg-gray-100",
+          style: { borderRadius: resolvedRadius },
+          children: /* @__PURE__ */ jsx17(Icon, { name: "error", size: "lg", color: "error-500" })
+        }
+      );
+    }
+    return null;
+  };
+  const isNumberWidth = typeof width === "number";
+  const isNumberHeight = typeof height === "number";
+  const content = /* @__PURE__ */ jsxs3(
+    View4,
+    {
+      className: cn("overflow-hidden", className),
+      style: {
+        width: isNumberWidth ? width : "100%",
+        height: isNumberHeight ? height : void 0,
+        aspectRatio: typeof height === "string" && height.startsWith("aspect-") ? Number(height.replace("aspect-", "").split("/")[0]) / Number(height.replace("aspect-", "").split("/")[1] || 1) : void 0,
+        borderRadius: resolvedRadius
+      },
+      children: [
+        renderLoading(),
+        /* @__PURE__ */ jsx17(
+          Image,
+          {
+            source,
+            style: imageStyle,
+            resizeMode,
+            onLoad: handleLoad,
+            onError: handleError
+          }
+        ),
+        renderError()
+      ]
+    }
+  );
+  if (onPress || onLongPress) {
+    return /* @__PURE__ */ jsx17(AppPressable, { onPress, onLongPress, children: content });
+  }
+  return content;
+}
+
+// src/ui/display/AppList.tsx
+import { useState as useState11, useCallback as useCallback11, useMemo as useMemo3 } from "react";
+import {
+  FlatList,
+  RefreshControl,
+  ActivityIndicator as ActivityIndicator4,
+  StyleSheet as StyleSheet3
+} from "react-native";
+import { Fragment, jsx as jsx18, jsxs as jsxs4 } from "nativewind/jsx-runtime";
+function SkeletonItem2({ render }) {
+  const colors = useThemeColors();
+  if (render) {
+    return render();
+  }
+  return /* @__PURE__ */ jsx18(AppView, { p: 4, gap: 3, testID: "skeleton", children: /* @__PURE__ */ jsxs4(AppView, { row: true, gap: 3, children: [
+    /* @__PURE__ */ jsx18(AppView, { className: "w-16 h-16 rounded-lg", style: { backgroundColor: colors.divider } }),
+    /* @__PURE__ */ jsxs4(AppView, { flex: true, gap: 2, children: [
+      /* @__PURE__ */ jsx18(AppView, { className: "h-4 w-3/4 rounded", style: { backgroundColor: colors.divider } }),
+      /* @__PURE__ */ jsx18(AppView, { className: "h-3 w-1/2 rounded", style: { backgroundColor: colors.divider } })
+    ] })
+  ] }) });
+}
+function EmptyState({
+  title,
+  description,
+  icon
+}) {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ jsxs4(Center, { py: 20, children: [
+    /* @__PURE__ */ jsx18(Icon, { name: icon || "inbox", size: 64, color: colors.textMuted }),
+    /* @__PURE__ */ jsx18(AppText, { size: "lg", weight: "medium", className: "mt-4", style: { color: colors.text }, children: title || "\u6682\u65E0\u6570\u636E" }),
+    description && /* @__PURE__ */ jsx18(AppText, { size: "sm", className: "mt-2", style: { color: colors.textMuted }, children: description })
+  ] });
+}
+function ErrorState({ error, onRetry }) {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ jsxs4(Center, { py: 20, children: [
+    /* @__PURE__ */ jsx18(Icon, { name: "error-outline", size: 64, color: "error-300" }),
+    /* @__PURE__ */ jsx18(AppText, { size: "lg", weight: "medium", color: "error-500", className: "mt-4", children: "\u52A0\u8F7D\u5931\u8D25" }),
+    /* @__PURE__ */ jsx18(AppText, { size: "sm", style: { color: colors.textMuted }, className: "mt-2 text-center px-8", children: error.message || "\u8BF7\u68C0\u67E5\u7F51\u7EDC\u540E\u91CD\u8BD5" }),
+    onRetry && /* @__PURE__ */ jsx18(
+      AppPressable,
+      {
+        onPress: onRetry,
+        className: "mt-6 px-4 py-2 rounded-lg",
+        style: [
+          styles3.retryButton,
+          { backgroundColor: colors.cardElevated, borderColor: colors.border }
+        ],
+        children: /* @__PURE__ */ jsx18(AppText, { style: { color: colors.textSecondary }, className: "text-center", children: "\u91CD\u65B0\u52A0\u8F7D" })
+      }
+    )
+  ] });
+}
+function LoadMoreFooter({ loading }) {
+  if (!loading) return null;
+  return /* @__PURE__ */ jsx18(Center, { py: 4, children: /* @__PURE__ */ jsx18(ActivityIndicator4, { size: "small" }) });
+}
+function Divider({ style }) {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ jsx18(
+    AppView,
+    {
+      className: "h-px",
+      style: [{ marginVertical: 0 }, { backgroundColor: colors.divider }, style]
+    }
+  );
+}
+function AppList({
+  data,
+  renderItem,
+  keyExtractor,
+  loading = false,
+  refreshing = false,
+  onRefresh,
+  hasMore = false,
+  onEndReached,
+  onEndReachedThreshold = 0.5,
+  error,
+  onRetry,
+  emptyTitle,
+  emptyDescription,
+  emptyIcon,
+  EmptyComponent,
+  divider = false,
+  dividerStyle,
+  skeletonCount = 6,
+  skeletonRender,
+  ListHeaderComponent,
+  ListFooterComponent,
+  contentContainerStyle,
+  style,
+  numColumns,
+  columnWrapperStyle,
+  horizontal,
+  showsVerticalScrollIndicator,
+  showsHorizontalScrollIndicator
+}) {
+  const { theme } = useTheme();
+  const [isLoadingMore, setIsLoadingMore] = useState11(false);
+  const handleEndReached = useCallback11(async () => {
+    if (isLoadingMore || !hasMore || !onEndReached) return;
+    setIsLoadingMore(true);
+    try {
+      await onEndReached();
+    } finally {
+      setIsLoadingMore(false);
+    }
+  }, [isLoadingMore, hasMore, onEndReached]);
+  const defaultKeyExtractor = useCallback11(
+    (item, index) => {
+      if (keyExtractor) return keyExtractor(item, index);
+      return `item-${index}`;
+    },
+    [keyExtractor]
+  );
+  const wrappedRenderItem = useCallback11(
+    (info) => {
+      return /* @__PURE__ */ jsxs4(Fragment, { children: [
+        divider && info.index > 0 && /* @__PURE__ */ jsx18(Divider, { style: dividerStyle }),
+        renderItem(info)
+      ] });
+    },
+    [renderItem, divider, dividerStyle]
+  );
+  const skeletonData = useMemo3(
+    () => new Array(skeletonCount).fill(null).map((_, i) => ({ _skeletonId: i })),
+    [skeletonCount]
+  );
+  const skeletonRenderItem = useCallback11(
+    () => /* @__PURE__ */ jsx18(SkeletonItem2, { render: skeletonRender }),
+    [skeletonRender]
+  );
+  if (loading && data.length === 0) {
+    return /* @__PURE__ */ jsx18(
+      FlatList,
+      {
+        data: skeletonData,
+        renderItem: skeletonRenderItem,
+        keyExtractor: (_, index) => `skeleton-${index}`,
+        contentContainerStyle,
+        style,
+        showsVerticalScrollIndicator,
+        showsHorizontalScrollIndicator
+      }
+    );
+  }
+  if (error && data.length === 0) {
+    return /* @__PURE__ */ jsx18(Center, { style, children: /* @__PURE__ */ jsx18(ErrorState, { error, onRetry }) });
+  }
+  const ListEmptyComponent = useMemo3(() => {
+    if (EmptyComponent) return /* @__PURE__ */ jsx18(EmptyComponent, {});
+    return /* @__PURE__ */ jsx18(EmptyState, { title: emptyTitle, description: emptyDescription, icon: emptyIcon });
+  }, [EmptyComponent, emptyTitle, emptyDescription, emptyIcon]);
+  const FooterComponent = useMemo3(() => {
+    return /* @__PURE__ */ jsxs4(Fragment, { children: [
+      /* @__PURE__ */ jsx18(LoadMoreFooter, { loading: isLoadingMore }),
+      ListFooterComponent
+    ] });
+  }, [isLoadingMore, ListFooterComponent]);
+  return /* @__PURE__ */ jsx18(
+    FlatList,
+    {
+      data,
+      renderItem: wrappedRenderItem,
+      keyExtractor: defaultKeyExtractor,
+      refreshControl: onRefresh ? /* @__PURE__ */ jsx18(
+        RefreshControl,
+        {
+          refreshing,
+          onRefresh,
+          tintColor: theme.colors.primary?.[500],
+          colors: [theme.colors.primary?.[500]]
+        }
+      ) : void 0,
+      onEndReached: onEndReached ? handleEndReached : void 0,
+      onEndReachedThreshold,
+      ListEmptyComponent,
+      ListHeaderComponent,
+      ListFooterComponent: FooterComponent,
+      contentContainerStyle,
+      style,
+      numColumns,
+      columnWrapperStyle,
+      horizontal,
+      showsVerticalScrollIndicator,
+      showsHorizontalScrollIndicator,
+      removeClippedSubviews: true,
+      maxToRenderPerBatch: 10,
+      windowSize: 10,
+      initialNumToRender: 10
+    }
+  );
+}
+var styles3 = StyleSheet3.create({
+  retryButton: {
+    borderWidth: 0.5
+  }
+});
+
+// src/ui/form/AppInput.tsx
+import { forwardRef, useState as useState12 } from "react";
+import { TextInput, View as View5, StyleSheet as StyleSheet4 } from "react-native";
+import { jsx as jsx19, jsxs as jsxs5 } from "nativewind/jsx-runtime";
+var AppInput = forwardRef(
+  ({ label, error, disabled = false, leftIcon, rightIcon, className, style, ...props }, ref) => {
+    const colors = useThemeColors();
+    const [isFocused, setIsFocused] = useState12(false);
+    const errorColor = "#ef4444";
+    const getBorderColor = () => {
+      if (error) return errorColor;
+      if (isFocused) return colors.primary;
+      return colors.border;
+    };
+    return /* @__PURE__ */ jsxs5(AppView, { className: cn("flex-col gap-1", className), children: [
+      label && /* @__PURE__ */ jsx19(AppText, { size: "sm", weight: "medium", style: { color: colors.textSecondary }, children: label }),
+      /* @__PURE__ */ jsxs5(
+        AppView,
+        {
+          row: true,
+          items: "center",
+          className: "rounded-lg px-3",
+          style: [
+            styles4.inputContainer,
+            {
+              backgroundColor: colors.card,
+              borderColor: getBorderColor(),
+              opacity: disabled ? 0.6 : 1
+            }
+          ],
+          children: [
+            leftIcon && /* @__PURE__ */ jsx19(View5, { style: styles4.icon, children: leftIcon }),
+            /* @__PURE__ */ jsx19(
+              TextInput,
+              {
+                ref,
+                className: "flex-1 py-3 text-base",
+                style: [styles4.input, { color: colors.text }, style],
+                placeholderTextColor: colors.textMuted,
+                editable: !disabled,
+                onFocus: (e) => {
+                  setIsFocused(true);
+                  props.onFocus?.(e);
+                },
+                onBlur: (e) => {
+                  setIsFocused(false);
+                  props.onBlur?.(e);
+                },
+                ...props
+              }
+            ),
+            rightIcon && /* @__PURE__ */ jsx19(View5, { style: styles4.icon, children: rightIcon })
+          ]
+        }
+      ),
+      error && /* @__PURE__ */ jsx19(AppText, { size: "xs", style: { color: errorColor }, children: error })
+    ] });
+  }
+);
+AppInput.displayName = "AppInput";
+var styles4 = StyleSheet4.create({
+  inputContainer: {
+    borderWidth: 0.5,
+    minHeight: 48
+  },
+  input: {
+    padding: 0,
+    margin: 0
+  },
+  icon: {
+    marginHorizontal: 4
+  }
+});
+
+// src/ui/form/Checkbox.tsx
+import { useState as useState13 } from "react";
+import { TouchableOpacity as TouchableOpacity2, StyleSheet as StyleSheet5 } from "react-native";
+import { jsx as jsx20, jsxs as jsxs6 } from "nativewind/jsx-runtime";
+function Checkbox({
+  checked,
+  defaultChecked,
+  onChange,
+  disabled = false,
+  children,
+  className,
+  testID
+}) {
+  const colors = useThemeColors();
+  const [internalChecked, setInternalChecked] = useState13(defaultChecked || false);
+  const isChecked = checked !== void 0 ? checked : internalChecked;
+  const toggle = () => {
+    if (disabled) return;
+    const newChecked = !isChecked;
+    if (checked === void 0) {
+      setInternalChecked(newChecked);
+    }
+    onChange?.(newChecked);
+  };
+  const disabledOpacity = 0.4;
+  return /* @__PURE__ */ jsxs6(
+    TouchableOpacity2,
+    {
+      onPress: toggle,
+      disabled,
+      className: cn("flex-row items-center gap-2", className),
+      style: disabled ? { opacity: disabledOpacity } : void 0,
+      testID,
+      activeOpacity: 0.7,
+      children: [
+        /* @__PURE__ */ jsx20(
+          AppView,
+          {
+            className: cn(
+              "w-5 h-5 rounded items-center justify-center",
+              isChecked ? "bg-primary-500" : "bg-white border"
+            ),
+            style: [
+              styles5.checkbox,
+              {
+                backgroundColor: isChecked ? colors.primary : colors.cardElevated,
+                borderColor: isChecked ? colors.primary : colors.border
+              }
+            ],
+            children: isChecked && /* @__PURE__ */ jsx20(AppView, { testID: `${testID}-icon`, children: /* @__PURE__ */ jsx20(Icon, { name: "check", size: "sm", color: "white" }) })
+          }
+        ),
+        children && /* @__PURE__ */ jsx20(AppText, { size: "sm", style: { color: colors.text }, children })
+      ]
+    }
+  );
+}
+var styles5 = StyleSheet5.create({
+  checkbox: {
+    borderWidth: 0.5
+  }
+});
+
+// src/ui/form/CheckboxGroup.tsx
+import { jsx as jsx21 } from "nativewind/jsx-runtime";
+function CheckboxGroup({
+  value = [],
+  onChange,
+  options = [],
+  direction = "column",
+  disabled = false
+}) {
+  const handleChange = (optionValue, checked) => {
+    if (!onChange) return;
+    if (checked) {
+      onChange([...value, optionValue]);
+    } else {
+      onChange(value.filter((v) => v !== optionValue));
+    }
+  };
+  return /* @__PURE__ */ jsx21(AppView, { row: direction === "row", flex: direction === "row", gap: 4, children: options.map((option) => /* @__PURE__ */ jsx21(
+    Checkbox,
+    {
+      checked: value.includes(option.value),
+      onChange: (checked) => handleChange(option.value, checked),
+      disabled: disabled || option.disabled,
+      children: option.label
+    },
+    option.value
+  )) });
+}
+
+// src/ui/form/Radio.tsx
+import { useState as useState14 } from "react";
+import { TouchableOpacity as TouchableOpacity3, StyleSheet as StyleSheet6 } from "react-native";
+import { jsx as jsx22, jsxs as jsxs7 } from "nativewind/jsx-runtime";
+function Radio({
+  checked,
+  defaultChecked,
+  onChange,
+  disabled = false,
+  children,
+  className,
+  testID
+}) {
+  const colors = useThemeColors();
+  const [internalChecked, setInternalChecked] = useState14(defaultChecked || false);
+  const isChecked = checked !== void 0 ? checked : internalChecked;
+  const toggle = () => {
+    if (disabled) return;
+    const newChecked = !isChecked;
+    if (checked === void 0) {
+      setInternalChecked(newChecked);
+    }
+    onChange?.(newChecked);
+  };
+  const disabledOpacity = 0.4;
+  return /* @__PURE__ */ jsxs7(
+    TouchableOpacity3,
+    {
+      onPress: toggle,
+      disabled,
+      className: cn("flex-row items-center gap-2", className),
+      style: disabled ? { opacity: disabledOpacity } : void 0,
+      testID,
+      activeOpacity: 0.7,
+      children: [
+        /* @__PURE__ */ jsx22(
+          AppView,
+          {
+            className: cn("w-5 h-5 rounded-full items-center justify-center", isChecked && "border-2"),
+            style: [
+              styles6.radio,
+              {
+                backgroundColor: colors.card,
+                borderColor: isChecked ? colors.primary : colors.border,
+                borderWidth: isChecked ? 0.5 : 0.5
+              }
+            ],
+            children: isChecked && /* @__PURE__ */ jsx22(
+              AppView,
+              {
+                className: "rounded-full",
+                style: [styles6.inner, { backgroundColor: colors.primary }]
+              }
+            )
+          }
+        ),
+        children && /* @__PURE__ */ jsx22(AppText, { size: "sm", style: { color: colors.text }, children })
+      ]
+    }
+  );
+}
+var styles6 = StyleSheet6.create({
+  radio: {
+    borderWidth: 0.5
+  },
+  inner: {
+    width: 10,
+    height: 10
+  }
+});
+
+// src/ui/form/RadioGroup.tsx
+import { jsx as jsx23 } from "nativewind/jsx-runtime";
+function RadioGroup({
+  value,
+  onChange,
+  options = [],
+  direction = "column",
+  disabled = false
+}) {
+  return /* @__PURE__ */ jsx23(AppView, { row: direction === "row", flex: direction === "row", gap: 4, children: options.map((option) => /* @__PURE__ */ jsx23(
+    Radio,
+    {
+      checked: value === option.value,
+      onChange: () => onChange?.(option.value),
+      disabled: disabled || option.disabled,
+      children: option.label
+    },
+    option.value
+  )) });
+}
+
+// src/ui/form/Switch.tsx
+import { useState as useState15 } from "react";
+import { TouchableOpacity as TouchableOpacity4, StyleSheet as StyleSheet7 } from "react-native";
+import { jsx as jsx24 } from "nativewind/jsx-runtime";
+function Switch({
+  checked,
+  defaultChecked,
+  onChange,
+  disabled = false,
+  size = "md",
+  className,
+  testID,
+  style
+}) {
+  const colors = useThemeColors();
+  const [internalChecked, setInternalChecked] = useState15(defaultChecked || false);
+  const isChecked = checked !== void 0 ? checked : internalChecked;
+  const toggle = () => {
+    if (disabled) return;
+    const newChecked = !isChecked;
+    if (checked === void 0) {
+      setInternalChecked(newChecked);
+    }
+    onChange?.(newChecked);
+  };
+  const uncheckedTrackColor = colors.divider;
+  const checkedTrackColor = colors.primary;
+  const disabledOpacity = 0.4;
+  const sizes = {
+    sm: { width: 36, height: 20, thumb: 16, padding: 2 },
+    md: { width: 48, height: 26, thumb: 22, padding: 2 },
+    lg: { width: 60, height: 32, thumb: 28, padding: 2 }
+  };
+  const config = sizes[size];
+  const thumbPosition = isChecked ? config.width - config.thumb - config.padding : config.padding;
+  return /* @__PURE__ */ jsx24(
+    TouchableOpacity4,
+    {
+      onPress: toggle,
+      disabled,
+      className: cn(className),
+      testID,
+      activeOpacity: disabled ? 1 : 0.8,
+      children: /* @__PURE__ */ jsx24(
+        AppView,
+        {
+          className: "rounded-full",
+          style: [
+            styles7.track,
+            {
+              width: config.width,
+              height: config.height,
+              backgroundColor: isChecked ? checkedTrackColor : uncheckedTrackColor,
+              opacity: disabled ? disabledOpacity : 1
+            },
+            style
+          ],
+          children: /* @__PURE__ */ jsx24(
+            AppView,
+            {
+              className: "rounded-full",
+              style: [
+                styles7.thumb,
+                {
+                  width: config.thumb,
+                  height: config.thumb,
+                  backgroundColor: colors.textInverse,
+                  transform: [{ translateX: thumbPosition }],
+                  shadowColor: "#000000",
+                  shadowOffset: { width: 0, height: 1 },
+                  shadowOpacity: 0.25,
+                  shadowRadius: 1
+                }
+              ]
+            }
+          )
+        }
+      )
+    }
+  );
+}
+var styles7 = StyleSheet7.create({
+  track: {
+    justifyContent: "center",
+    padding: 2
+  },
+  thumb: {
+    elevation: 2,
+    shadowColor: "#000000",
+    shadowOffset: { width: 0, height: 1 },
+    shadowOpacity: 0.2,
+    shadowRadius: 1
+  }
+});
+
+// src/ui/form/Slider.tsx
+import { useState as useState16, useCallback as useCallback12, useRef as useRef6 } from "react";
+import {
+  View as View6,
+  PanResponder,
+  StyleSheet as StyleSheet8
+} from "react-native";
+
+// src/ui/form/useFormTheme.ts
+import { useMemo as useMemo4 } from "react";
+function useFormThemeColors() {
+  const { isDark } = useOptionalTheme();
+  const colors = useThemeColors();
+  return useMemo4(
+    () => ({
+      primary: colors.primary,
+      primarySurface: colors.primarySurface,
+      surface: colors.cardElevated,
+      surfaceMuted: isDark ? colors.divider : "#f3f4f6",
+      headerSurface: isDark ? "#111827" : "#f3f4f6",
+      text: colors.text,
+      textSecondary: colors.textSecondary,
+      textMuted: colors.textMuted,
+      textInverse: colors.textInverse,
+      border: colors.border,
+      divider: colors.divider,
+      icon: colors.textMuted,
+      overlay: "rgba(0,0,0,0.5)"
+    }),
+    [colors, isDark]
+  );
+}
+
+// src/ui/form/Slider.tsx
+import { jsx as jsx25, jsxs as jsxs8 } from "nativewind/jsx-runtime";
+function Slider({
+  value,
+  defaultValue = 0,
+  min = 0,
+  max = 100,
+  step = 1,
+  disabled = false,
+  showTooltip = false,
+  onChange,
+  onChangeEnd,
+  className
+}) {
+  const colors = useFormThemeColors();
+  const [internalValue, setInternalValue] = useState16(defaultValue);
+  const [trackWidth, setTrackWidth] = useState16(0);
+  const [isDragging, setIsDragging] = useState16(false);
+  const currentValue = value !== void 0 ? value : internalValue;
+  const disabledOpacity = 0.4;
+  const progress = (currentValue - min) / (max - min) * 100;
+  const getValueFromPosition = useCallback12(
+    (position) => {
+      const percentage = Math.max(0, Math.min(1, position / trackWidth));
+      const rawValue = min + percentage * (max - min);
+      const steppedValue = Math.round(rawValue / step) * step;
+      return Math.min(max, Math.max(min, steppedValue));
+    },
+    [trackWidth, min, max, step]
+  );
+  const setValue = useCallback12(
+    (newValue) => {
+      const clampedValue = Math.min(max, Math.max(min, newValue));
+      if (value === void 0) {
+        setInternalValue(clampedValue);
+      }
+      onChange?.(clampedValue);
+    },
+    [value, min, max, onChange]
+  );
+  const panResponder = useRef6(
+    PanResponder.create({
+      onStartShouldSetPanResponder: () => !disabled,
+      onMoveShouldSetPanResponder: () => !disabled,
+      onPanResponderGrant: () => {
+        setIsDragging(true);
+      },
+      onPanResponderMove: (_, gestureState) => {
+        const position = progress / 100 * trackWidth + gestureState.dx;
+        const newValue = getValueFromPosition(position);
+        setValue(newValue);
+      },
+      onPanResponderRelease: (_, gestureState) => {
+        const position = progress / 100 * trackWidth + gestureState.dx;
+        const newValue = getValueFromPosition(position);
+        setValue(newValue);
+        setIsDragging(false);
+        onChangeEnd?.(newValue);
+      }
+    })
+  ).current;
+  const handleTrackPress = useCallback12(
+    (event) => {
+      if (disabled) return;
+      const { locationX } = event.nativeEvent;
+      const newValue = getValueFromPosition(locationX);
+      setValue(newValue);
+      onChangeEnd?.(newValue);
+    },
+    [disabled, getValueFromPosition, setValue, onChangeEnd]
+  );
+  const onLayout = useCallback12((event) => {
+    setTrackWidth(event.nativeEvent.layout.width);
+  }, []);
+  return /* @__PURE__ */ jsxs8(AppView, { className: cn("py-2", className), children: [
+    showTooltip && isDragging && /* @__PURE__ */ jsxs8(
+      AppView,
+      {
+        className: "absolute rounded px-2 py-1 -top-8",
+        style: [
+          styles8.tooltip,
+          {
+            backgroundColor: colors.surfaceMuted,
+            left: `${progress}%`,
+            transform: [{ translateX: -16 }]
+          }
+        ],
+        children: [
+          /* @__PURE__ */ jsx25(AppText, { size: "xs", style: { color: colors.text }, children: Math.round(currentValue) }),
+          /* @__PURE__ */ jsx25(
+            AppView,
+            {
+              style: [
+                styles8.tooltipArrow,
+                {
+                  borderTopColor: colors.surfaceMuted
+                }
+              ]
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs8(
+      View6,
+      {
+        onLayout,
+        className: "rounded-full",
+        style: [
+          styles8.track,
+          { backgroundColor: colors.divider, opacity: disabled ? disabledOpacity : 1 }
+        ],
+        onTouchEnd: handleTrackPress,
+        children: [
+          /* @__PURE__ */ jsx25(
+            AppView,
+            {
+              className: "rounded-full",
+              style: [
+                styles8.filledTrack,
+                {
+                  backgroundColor: colors.primary,
+                  width: `${progress}%`
+                }
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx25(
+            AppView,
+            {
+              className: "absolute rounded-full items-center justify-center",
+              style: [
+                styles8.thumb,
+                {
+                  backgroundColor: colors.textInverse,
+                  left: `${progress}%`,
+                  transform: [{ translateX: -12 }],
+                  shadowColor: "#000000",
+                  shadowOffset: { width: 0, height: 2 },
+                  shadowOpacity: 0.25,
+                  shadowRadius: 2
+                }
+              ],
+              ...panResponder.panHandlers,
+              children: /* @__PURE__ */ jsx25(
+                AppView,
+                {
+                  className: "rounded-full",
+                  style: [
+                    styles8.thumbDot,
+                    {
+                      backgroundColor: colors.primary
+                    }
+                  ]
+                }
+              )
+            }
+          )
+        ]
+      }
+    )
+  ] });
+}
+var styles8 = StyleSheet8.create({
+  track: {
+    height: 6,
+    width: "100%"
+  },
+  filledTrack: {
+    height: 6
+  },
+  thumb: {
+    width: 24,
+    height: 24,
+    top: -9,
+    elevation: 3,
+    shadowColor: "#000000",
+    shadowOffset: { width: 0, height: 2 },
+    shadowOpacity: 0.2,
+    shadowRadius: 2
+  },
+  thumbDot: {
+    width: 8,
+    height: 8
+  },
+  tooltip: {
+    minWidth: 32,
+    alignItems: "center",
+    elevation: 4
+  },
+  tooltipArrow: {
+    position: "absolute",
+    bottom: -4,
+    width: 0,
+    height: 0,
+    borderLeftWidth: 4,
+    borderRightWidth: 4,
+    borderTopWidth: 4,
+    borderLeftColor: "transparent",
+    borderRightColor: "transparent"
+  }
+});
+
+// src/ui/form/Select.tsx
+import { useState as useState17, useCallback as useCallback13, useMemo as useMemo5 } from "react";
+import {
+  Modal as Modal2,
+  View as View7,
+  TouchableOpacity as TouchableOpacity5,
+  FlatList as FlatList2,
+  TextInput as TextInput2,
+  StyleSheet as StyleSheet9
+} from "react-native";
+import { Fragment as Fragment2, jsx as jsx26, jsxs as jsxs9 } from "nativewind/jsx-runtime";
+function Select({
+  value,
+  onChange,
+  options,
+  placeholder = "\u8BF7\u9009\u62E9",
+  multiple = false,
+  searchable = false,
+  onSearch,
+  disabled = false,
+  clearable = true,
+  className
+}) {
+  const colors = useFormThemeColors();
+  const [visible, setVisible] = useState17(false);
+  const [searchKeyword, setSearchKeyword] = useState17("");
+  const selectedValues = useMemo5(() => {
+    if (multiple) {
+      return Array.isArray(value) ? value : [];
+    }
+    return value ? [value] : [];
+  }, [value, multiple]);
+  const displayText = useMemo5(() => {
+    if (selectedValues.length === 0) return placeholder;
+    const selectedLabels = options.filter((opt) => selectedValues.includes(opt.value)).map((opt) => opt.label);
+    return selectedLabels.join(", ") || placeholder;
+  }, [selectedValues, options, placeholder]);
+  const filteredOptions = useMemo5(() => {
+    if (!searchable || !searchKeyword) return options;
+    return options.filter((opt) => opt.label.toLowerCase().includes(searchKeyword.toLowerCase()));
+  }, [options, searchable, searchKeyword]);
+  const handleSelect = useCallback13(
+    (optionValue) => {
+      if (multiple) {
+        const currentValues = Array.isArray(value) ? value : [];
+        const newValues = currentValues.includes(optionValue) ? currentValues.filter((v) => v !== optionValue) : [...currentValues, optionValue];
+        onChange?.(newValues);
+      } else {
+        onChange?.(optionValue);
+        setVisible(false);
+      }
+    },
+    [multiple, value, onChange]
+  );
+  const handleClear = useCallback13(
+    (e) => {
+      e.stopPropagation();
+      onChange?.(multiple ? [] : "");
+    },
+    [multiple, onChange]
+  );
+  const handleSearch = useCallback13(
+    (text) => {
+      setSearchKeyword(text);
+      onSearch?.(text);
+    },
+    [onSearch]
+  );
+  const renderOption = useCallback13(
+    ({ item }) => {
+      const isSelected = selectedValues.includes(item.value);
+      return /* @__PURE__ */ jsxs9(
+        AppPressable,
+        {
+          className: cn(
+            "flex-row items-center justify-between px-4 py-3",
+            isSelected && "bg-primary-50"
+          ),
+          style: [
+            styles9.optionItem,
+            { borderBottomColor: colors.divider },
+            isSelected && { backgroundColor: colors.primarySurface }
+          ],
+          onPress: () => handleSelect(item.value),
+          children: [
+            /* @__PURE__ */ jsx26(AppText, { style: { color: isSelected ? colors.primary : colors.text }, children: item.label }),
+            isSelected && /* @__PURE__ */ jsx26(Icon, { name: "check", size: "sm", color: "primary-500" })
+          ]
+        }
+      );
+    },
+    [selectedValues, handleSelect, colors]
+  );
+  return /* @__PURE__ */ jsxs9(Fragment2, { children: [
+    /* @__PURE__ */ jsxs9(
+      AppPressable,
+      {
+        className: cn(
+          "flex-row items-center justify-between px-4 py-3 rounded-lg",
+          disabled ? "opacity-60" : "",
+          className
+        ),
+        style: [styles9.trigger, { backgroundColor: colors.surface, borderColor: colors.border }],
+        disabled,
+        onPress: () => setVisible(true),
+        children: [
+          /* @__PURE__ */ jsx26(
+            AppText,
+            {
+              className: "flex-1",
+              style: { color: selectedValues.length === 0 ? colors.textMuted : colors.text },
+              numberOfLines: 1,
+              children: displayText
+            }
+          ),
+          /* @__PURE__ */ jsxs9(View7, { className: "flex-row items-center", children: [
+            clearable && selectedValues.length > 0 && !disabled && /* @__PURE__ */ jsx26(TouchableOpacity5, { onPress: handleClear, className: "mr-2 p-1", children: /* @__PURE__ */ jsx26(Icon, { name: "close", size: "sm", color: colors.icon }) }),
+            /* @__PURE__ */ jsx26(Icon, { name: "keyboard-arrow-down", size: "md", color: colors.icon })
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx26(
+      Modal2,
+      {
+        visible,
+        transparent: true,
+        animationType: "slide",
+        onRequestClose: () => setVisible(false),
+        children: /* @__PURE__ */ jsx26(AppView, { className: "flex-1", style: { backgroundColor: colors.overlay }, justify: "end", children: /* @__PURE__ */ jsxs9(
+          AppView,
+          {
+            className: "rounded-t-2xl max-h-[70%]",
+            style: { backgroundColor: colors.surface },
+            children: [
+              /* @__PURE__ */ jsxs9(
+                AppView,
+                {
+                  row: true,
+                  between: true,
+                  items: "center",
+                  className: "px-4 py-3",
+                  style: [styles9.header, { borderBottomColor: colors.divider }],
+                  children: [
+                    /* @__PURE__ */ jsx26(AppText, { className: "text-lg font-semibold", style: { color: colors.text }, children: multiple ? "\u9009\u62E9\u9009\u9879" : "\u8BF7\u9009\u62E9" }),
+                    /* @__PURE__ */ jsx26(TouchableOpacity5, { onPress: () => setVisible(false), children: /* @__PURE__ */ jsx26(Icon, { name: "close", size: "md", color: colors.icon }) })
+                  ]
+                }
+              ),
+              searchable && /* @__PURE__ */ jsx26(
+                AppView,
+                {
+                  className: "px-4 py-3",
+                  style: [styles9.searchBox, { borderBottomColor: colors.divider }],
+                  children: /* @__PURE__ */ jsxs9(
+                    AppView,
+                    {
+                      row: true,
+                      items: "center",
+                      className: "px-3 py-2 rounded-lg",
+                      style: { backgroundColor: colors.surfaceMuted },
+                      children: [
+                        /* @__PURE__ */ jsx26(View7, { style: { marginRight: 8 }, children: /* @__PURE__ */ jsx26(Icon, { name: "search", size: "sm", color: colors.icon }) }),
+                        /* @__PURE__ */ jsx26(
+                          TextInput2,
+                          {
+                            className: "flex-1 text-base",
+                            style: { color: colors.text },
+                            placeholder: "\u641C\u7D22...",
+                            placeholderTextColor: colors.textMuted,
+                            value: searchKeyword,
+                            onChangeText: handleSearch,
+                            autoFocus: true
+                          }
+                        ),
+                        searchKeyword.length > 0 && /* @__PURE__ */ jsx26(TouchableOpacity5, { onPress: () => setSearchKeyword(""), children: /* @__PURE__ */ jsx26(Icon, { name: "close", size: "sm", color: colors.icon }) })
+                      ]
+                    }
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsx26(
+                FlatList2,
+                {
+                  data: filteredOptions,
+                  keyExtractor: (item) => item.value,
+                  renderItem: renderOption,
+                  ListEmptyComponent: /* @__PURE__ */ jsx26(AppView, { center: true, className: "py-8", children: /* @__PURE__ */ jsx26(AppText, { style: { color: colors.textMuted }, children: "\u6682\u65E0\u9009\u9879" }) })
+                }
+              ),
+              multiple && /* @__PURE__ */ jsxs9(
+                AppView,
+                {
+                  row: true,
+                  between: true,
+                  items: "center",
+                  className: "px-4 py-3",
+                  style: [styles9.footer, { borderTopColor: colors.divider }],
+                  children: [
+                    /* @__PURE__ */ jsxs9(AppText, { style: { color: colors.textMuted }, children: [
+                      "\u5DF2\u9009\u62E9 ",
+                      selectedValues.length,
+                      " \u9879"
+                    ] }),
+                    /* @__PURE__ */ jsx26(
+                      TouchableOpacity5,
+                      {
+                        className: "px-4 py-2 rounded-lg",
+                        style: { backgroundColor: colors.primary },
+                        onPress: () => setVisible(false),
+                        children: /* @__PURE__ */ jsx26(AppText, { className: "font-medium", style: { color: colors.textInverse }, children: "\u786E\u5B9A" })
+                      }
+                    )
+                  ]
+                }
+              )
+            ]
+          }
+        ) })
+      }
+    )
+  ] });
+}
+var styles9 = StyleSheet9.create({
+  trigger: {
+    borderWidth: 0.5
+  },
+  header: {
+    borderBottomWidth: 0.5
+  },
+  searchBox: {
+    borderBottomWidth: 0.5
+  },
+  optionItem: {
+    borderBottomWidth: 0.5
+  },
+  footer: {
+    borderTopWidth: 0.5
+  }
+});
+
+// src/ui/form/DatePicker.tsx
+import { useState as useState18, useCallback as useCallback14, useMemo as useMemo6 } from "react";
+import { Modal as Modal3, TouchableOpacity as TouchableOpacity6, StyleSheet as StyleSheet10 } from "react-native";
+import { Fragment as Fragment3, jsx as jsx27, jsxs as jsxs10 } from "nativewind/jsx-runtime";
+function PickerColumn({
+  title,
+  values,
+  selectedValue,
+  onSelect,
+  isDisabled,
+  formatLabel = (value) => String(value),
+  showDivider = false,
+  colors
+}) {
+  return /* @__PURE__ */ jsxs10(
+    AppView,
+    {
+      flex: true,
+      style: [
+        showDivider && styles10.column,
+        showDivider ? { borderRightColor: colors.divider } : void 0
+      ],
+      children: [
+        /* @__PURE__ */ jsx27(AppView, { center: true, className: "py-2", style: { backgroundColor: colors.headerSurface }, children: /* @__PURE__ */ jsx27(AppText, { className: "text-sm font-medium", style: { color: colors.textMuted }, children: title }) }),
+        /* @__PURE__ */ jsx27(AppView, { className: "flex-1", children: values.map((value) => {
+          const selected = selectedValue === value;
+          const disabled = isDisabled(value);
+          return /* @__PURE__ */ jsx27(
+            TouchableOpacity6,
+            {
+              className: cn("py-2 items-center", selected && "bg-primary-50"),
+              style: selected ? { backgroundColor: colors.primarySurface } : void 0,
+              disabled,
+              onPress: () => onSelect(value),
+              children: /* @__PURE__ */ jsx27(
+                AppText,
+                {
+                  className: cn(selected ? "font-semibold" : void 0, disabled && "opacity-30"),
+                  style: {
+                    color: selected ? colors.primary : colors.textSecondary
+                  },
+                  children: formatLabel(value)
+                }
+              )
+            },
+            value
+          );
+        }) })
+      ]
+    }
+  );
+}
+function DatePicker({
+  value,
+  onChange,
+  placeholder = "\u8BF7\u9009\u62E9\u65E5\u671F",
+  disabled = false,
+  format = "yyyy-MM-dd",
+  minDate,
+  maxDate,
+  className
+}) {
+  const colors = useFormThemeColors();
+  const [visible, setVisible] = useState18(false);
+  const [tempDate, setTempDate] = useState18(value || /* @__PURE__ */ new Date());
+  const displayText = useMemo6(() => {
+    return value ? formatDate(value, format) : placeholder;
+  }, [value, format, placeholder]);
+  const handleConfirm = useCallback14(() => {
+    onChange?.(tempDate);
+    setVisible(false);
+  }, [tempDate, onChange]);
+  const years = useMemo6(() => {
+    const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+    const arr = [];
+    for (let i = currentYear - 50; i <= currentYear + 50; i++) {
+      arr.push(i);
+    }
+    return arr;
+  }, []);
+  const months = useMemo6(() => {
+    return Array.from({ length: 12 }, (_, i) => i + 1);
+  }, []);
+  const days = useMemo6(() => {
+    const year = tempDate.getFullYear();
+    const month = tempDate.getMonth();
+    const daysInMonth = new Date(year, month + 1, 0).getDate();
+    return Array.from({ length: daysInMonth }, (_, i) => i + 1);
+  }, [tempDate]);
+  const isDateDisabled = useCallback14(
+    (year, month, day) => {
+      const date = new Date(year, month - 1, day);
+      if (minDate && date < minDate) return true;
+      if (maxDate && date > maxDate) return true;
+      return false;
+    },
+    [minDate, maxDate]
+  );
+  const updateTempDate = useCallback14(
+    (year, month, day) => {
+      const newDate = new Date(tempDate);
+      if (year !== void 0) newDate.setFullYear(year);
+      if (month !== void 0) newDate.setMonth(month - 1);
+      if (day !== void 0) newDate.setDate(day);
+      setTempDate(newDate);
+    },
+    [tempDate]
+  );
+  return /* @__PURE__ */ jsxs10(Fragment3, { children: [
+    /* @__PURE__ */ jsxs10(
+      AppPressable,
+      {
+        className: cn(
+          "flex-row items-center justify-between px-4 py-3 rounded-lg",
+          disabled ? "opacity-60" : "",
+          className
+        ),
+        style: [styles10.trigger, { backgroundColor: colors.surface, borderColor: colors.border }],
+        disabled,
+        onPress: () => {
+          setTempDate(value || /* @__PURE__ */ new Date());
+          setVisible(true);
+        },
+        children: [
+          /* @__PURE__ */ jsx27(
+            AppText,
+            {
+              className: "flex-1",
+              style: { color: value ? colors.text : colors.textMuted },
+              numberOfLines: 1,
+              children: displayText
+            }
+          ),
+          /* @__PURE__ */ jsx27(Icon, { name: "calendar-today", size: "md", color: colors.icon })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx27(
+      Modal3,
+      {
+        visible,
+        transparent: true,
+        animationType: "slide",
+        onRequestClose: () => setVisible(false),
+        children: /* @__PURE__ */ jsx27(AppView, { className: "flex-1", style: { backgroundColor: colors.overlay }, justify: "end", children: /* @__PURE__ */ jsxs10(AppView, { className: "rounded-t-2xl", style: { backgroundColor: colors.surface }, children: [
+          /* @__PURE__ */ jsxs10(
+            AppView,
+            {
+              row: true,
+              between: true,
+              items: "center",
+              className: "px-4 py-3",
+              style: [styles10.header, { borderBottomColor: colors.divider }],
+              children: [
+                /* @__PURE__ */ jsx27(TouchableOpacity6, { onPress: () => setVisible(false), children: /* @__PURE__ */ jsx27(AppText, { style: { color: colors.textMuted }, children: "\u53D6\u6D88" }) }),
+                /* @__PURE__ */ jsx27(AppText, { className: "text-lg font-semibold", style: { color: colors.text }, children: "\u9009\u62E9\u65E5\u671F" }),
+                /* @__PURE__ */ jsx27(TouchableOpacity6, { onPress: handleConfirm, children: /* @__PURE__ */ jsx27(AppText, { style: { color: colors.primary }, className: "font-medium", children: "\u786E\u5B9A" }) })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx27(AppView, { center: true, className: "py-4", style: { backgroundColor: colors.headerSurface }, children: /* @__PURE__ */ jsx27(AppText, { className: "text-2xl font-semibold", style: { color: colors.text }, children: formatDate(tempDate, "yyyy\u5E74MM\u6708dd\u65E5") }) }),
+          /* @__PURE__ */ jsxs10(AppView, { row: true, className: "h-48", children: [
+            /* @__PURE__ */ jsx27(
+              PickerColumn,
+              {
+                title: "\u5E74",
+                values: years,
+                selectedValue: tempDate.getFullYear(),
+                onSelect: (year) => updateTempDate(year),
+                isDisabled: (year) => isDateDisabled(year, tempDate.getMonth() + 1, tempDate.getDate()),
+                colors,
+                showDivider: true
+              }
+            ),
+            /* @__PURE__ */ jsx27(
+              PickerColumn,
+              {
+                title: "\u6708",
+                values: months,
+                selectedValue: tempDate.getMonth() + 1,
+                onSelect: (month) => updateTempDate(void 0, month),
+                isDisabled: (month) => isDateDisabled(tempDate.getFullYear(), month, tempDate.getDate()),
+                formatLabel: (month) => `${month}\u6708`,
+                colors,
+                showDivider: true
+              }
+            ),
+            /* @__PURE__ */ jsx27(
+              PickerColumn,
+              {
+                title: "\u65E5",
+                values: days,
+                selectedValue: tempDate.getDate(),
+                onSelect: (day) => updateTempDate(void 0, void 0, day),
+                isDisabled: (day) => isDateDisabled(tempDate.getFullYear(), tempDate.getMonth() + 1, day),
+                colors
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs10(
+            AppView,
+            {
+              row: true,
+              className: "px-4 py-3 gap-2",
+              style: [styles10.footer, { borderTopColor: colors.divider }],
+              children: [
+                /* @__PURE__ */ jsx27(
+                  TouchableOpacity6,
+                  {
+                    className: "flex-1 py-2 items-center rounded-lg",
+                    style: { backgroundColor: colors.surfaceMuted },
+                    onPress: () => setTempDate(/* @__PURE__ */ new Date()),
+                    children: /* @__PURE__ */ jsx27(AppText, { style: { color: colors.text }, children: "\u4ECA\u5929" })
+                  }
+                ),
+                minDate && /* @__PURE__ */ jsx27(
+                  TouchableOpacity6,
+                  {
+                    className: "flex-1 py-2 items-center rounded-lg",
+                    style: { backgroundColor: colors.surfaceMuted },
+                    onPress: () => setTempDate(minDate),
+                    children: /* @__PURE__ */ jsx27(AppText, { style: { color: colors.text }, children: "\u6700\u65E9" })
+                  }
+                ),
+                maxDate && /* @__PURE__ */ jsx27(
+                  TouchableOpacity6,
+                  {
+                    className: "flex-1 py-2 items-center rounded-lg",
+                    style: { backgroundColor: colors.surfaceMuted },
+                    onPress: () => setTempDate(maxDate),
+                    children: /* @__PURE__ */ jsx27(AppText, { style: { color: colors.text }, children: "\u6700\u665A" })
+                  }
+                )
+              ]
+            }
+          )
+        ] }) })
+      }
+    )
+  ] });
+}
+var styles10 = StyleSheet10.create({
+  trigger: {
+    borderWidth: 0.5
+  },
+  header: {
+    borderBottomWidth: 0.5
+  },
+  column: {
+    borderRightWidth: 0.5
+  },
+  footer: {
+    borderTopWidth: 0.5
+  }
+});
+
+// src/ui/form/FormItem.tsx
+import { jsx as jsx28, jsxs as jsxs11 } from "nativewind/jsx-runtime";
+function FormItem({
+  name: _name,
+  label,
+  error,
+  help,
+  required,
+  children,
+  className,
+  labelClassName
+}) {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ jsxs11(AppView, { className: cn("mb-4", className), children: [
+    label && /* @__PURE__ */ jsxs11(AppView, { row: true, items: "center", gap: 1, className: cn("mb-2", labelClassName), children: [
+      /* @__PURE__ */ jsx28(AppText, { size: "sm", weight: "medium", style: { color: colors.textSecondary }, children: label }),
+      required && /* @__PURE__ */ jsx28(AppText, { color: "error-500", children: "*" })
+    ] }),
+    children,
+    error && /* @__PURE__ */ jsx28(AppText, { size: "sm", color: "error-500", className: "mt-1", children: error }),
+    help && !error && /* @__PURE__ */ jsx28(AppText, { size: "sm", className: "mt-1", style: { color: colors.textMuted }, children: help })
+  ] });
+}
+
+// src/ui/form/useForm.ts
+import { useState as useState19, useCallback as useCallback15, useMemo as useMemo7 } from "react";
+function useForm({
+  schema,
+  defaultValues
+}) {
+  const [values, setValues] = useState19(defaultValues);
+  const [errors, setErrors] = useState19({});
+  const [isSubmitting, setIsSubmitting] = useState19(false);
+  const isDirty = useMemo7(() => {
+    return JSON.stringify(values) !== JSON.stringify(defaultValues);
+  }, [values, defaultValues]);
+  const isValid = useMemo7(() => {
+    return Object.keys(errors).length === 0;
+  }, [errors]);
+  const setValue = useCallback15((name, value) => {
+    setValues((prev) => ({ ...prev, [name]: value }));
+    setErrors((prev) => {
+      const next = { ...prev };
+      delete next[name];
+      return next;
+    });
+  }, []);
+  const getValue = useCallback15(
+    (name) => {
+      return values[name];
+    },
+    [values]
+  );
+  const validateField = useCallback15(
+    async (name) => {
+      try {
+        const shape = schema.shape;
+        if (shape && shape[name]) {
+          await shape[name].parseAsync(values[name]);
+          setErrors((prev) => {
+            const next = { ...prev };
+            delete next[name];
+            return next;
+          });
+          return true;
+        }
+        return true;
+      } catch (error) {
+        setErrors((prev) => ({
+          ...prev,
+          [name]: error.errors?.[0]?.message || "\u9A8C\u8BC1\u5931\u8D25"
+        }));
+        return false;
+      }
+    },
+    [schema, values]
+  );
+  const validate = useCallback15(async () => {
+    try {
+      await schema.parseAsync(values);
+      setErrors({});
+      return true;
+    } catch (error) {
+      const formErrors = {};
+      error.errors?.forEach((err) => {
+        const path = err.path.join(".");
+        formErrors[path] = err.message;
+      });
+      setErrors(formErrors);
+      return false;
+    }
+  }, [schema, values]);
+  const reset = useCallback15(() => {
+    setValues(defaultValues);
+    setErrors({});
+    setIsSubmitting(false);
+  }, [defaultValues]);
+  const handleSubmit = useCallback15(
+    async (onSubmit) => {
+      const valid = await validate();
+      if (!valid) return;
+      setIsSubmitting(true);
+      try {
+        await onSubmit?.(values);
+      } finally {
+        setIsSubmitting(false);
+      }
+    },
+    [validate, values]
+  );
+  return {
+    values,
+    errors,
+    isValid,
+    isDirty,
+    isSubmitting,
+    setValue,
+    getValue,
+    validate,
+    validateField,
+    reset,
+    handleSubmit
+  };
+}
+
+// src/ui/hooks/useToggle.ts
+import { useCallback as useCallback16, useState as useState20 } from "react";
+function useToggle(defaultValue = false) {
+  const [value, setValue] = useState20(defaultValue);
+  const toggle = useCallback16(() => {
+    setValue((v) => !v);
+  }, []);
+  const set = useCallback16((newValue) => {
+    setValue(newValue);
+  }, []);
+  const setTrue = useCallback16(() => {
+    setValue(true);
+  }, []);
+  const setFalse = useCallback16(() => {
+    setValue(false);
+  }, []);
+  return [value, { toggle, set, setTrue, setFalse }];
+}
+
+// src/ui/hooks/useDebounce.ts
+import { useEffect as useEffect5, useState as useState21 } from "react";
+function useDebounce(value, delay = 500) {
+  const [debouncedValue, setDebouncedValue] = useState21(value);
+  useEffect5(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+
+// src/ui/hooks/useThrottle.ts
+import { useEffect as useEffect6, useRef as useRef7, useState as useState22 } from "react";
+function useThrottle(value, delay = 200) {
+  const [throttledValue, setThrottledValue] = useState22(value);
+  const lastUpdatedRef = useRef7(Date.now());
+  useEffect6(() => {
+    const now = Date.now();
+    const timeElapsed = now - lastUpdatedRef.current;
+    if (timeElapsed >= delay) {
+      lastUpdatedRef.current = now;
+      setThrottledValue(value);
+      return void 0;
+    } else {
+      const timer = setTimeout(() => {
+        lastUpdatedRef.current = Date.now();
+        setThrottledValue(value);
+      }, delay - timeElapsed);
+      return () => {
+        clearTimeout(timer);
+      };
+    }
+  }, [value, delay]);
+  return throttledValue;
+}
+
+// src/ui/hooks/useKeyboard.ts
+import { useEffect as useEffect7, useState as useState23, useCallback as useCallback17 } from "react";
+import { Keyboard, Platform } from "react-native";
+function useKeyboard() {
+  const [visible, setVisible] = useState23(false);
+  const [height, setHeight] = useState23(0);
+  useEffect7(() => {
+    const handleKeyboardWillShow = (event) => {
+      setVisible(true);
+      setHeight(event.endCoordinates.height);
+    };
+    const handleKeyboardDidShow = (event) => {
+      setVisible(true);
+      setHeight(event.endCoordinates.height);
+    };
+    const handleKeyboardWillHide = () => {
+      setVisible(false);
+      setHeight(0);
+    };
+    const handleKeyboardDidHide = () => {
+      setVisible(false);
+      setHeight(0);
+    };
+    const willShowSub = Keyboard.addListener(
+      Platform.OS === "ios" ? "keyboardWillShow" : "keyboardDidShow",
+      Platform.OS === "ios" ? handleKeyboardWillShow : handleKeyboardDidShow
+    );
+    const willHideSub = Keyboard.addListener(
+      Platform.OS === "ios" ? "keyboardWillHide" : "keyboardDidHide",
+      Platform.OS === "ios" ? handleKeyboardWillHide : handleKeyboardDidHide
+    );
+    return () => {
+      willShowSub.remove();
+      willHideSub.remove();
+    };
+  }, []);
+  const dismiss = useCallback17(() => {
+    Keyboard.dismiss();
+  }, []);
+  return { visible, height, dismiss };
+}
+
+// src/ui/hooks/useDimensions.ts
+import { useEffect as useEffect8, useState as useState24 } from "react";
+import { Dimensions } from "react-native";
+function useDimensions() {
+  const [dimensions, setDimensions] = useState24(() => {
+    const window = Dimensions.get("window");
+    return {
+      width: window.width,
+      height: window.height,
+      scale: window.scale,
+      fontScale: window.fontScale
+    };
+  });
+  useEffect8(() => {
+    const handleChange = ({ window }) => {
+      setDimensions({
+        width: window.width,
+        height: window.height,
+        scale: window.scale,
+        fontScale: window.fontScale
+      });
+    };
+    const subscription = Dimensions.addEventListener("change", handleChange);
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+  return dimensions;
+}
+
+// src/ui/hooks/useOrientation.ts
+import { useEffect as useEffect9, useState as useState25 } from "react";
+import { Dimensions as Dimensions2 } from "react-native";
+function useOrientation() {
+  const getOrientation = () => {
+    const { width, height } = Dimensions2.get("window");
+    return width > height ? "landscape" : "portrait";
+  };
+  const [orientation, setOrientation] = useState25(getOrientation);
+  useEffect9(() => {
+    const handleChange = ({ window }) => {
+      const newOrientation = window.width > window.height ? "landscape" : "portrait";
+      setOrientation(newOrientation);
+    };
+    const subscription = Dimensions2.addEventListener("change", handleChange);
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+  return {
+    orientation,
+    isPortrait: orientation === "portrait",
+    isLandscape: orientation === "landscape"
+  };
+}
+
+// src/navigation/provider.tsx
+import React5 from "react";
+import {
+  NavigationContainer
+} from "@react-navigation/native";
+
+// src/navigation/utils/navigation-theme.ts
+function createNavigationTheme(pantherTheme, isDark) {
+  const { primary, background, card, text, divider } = getThemeColors(pantherTheme, isDark);
+  return {
+    dark: isDark,
+    colors: {
+      primary,
+      background,
+      card,
+      text,
+      border: divider,
+      notification: pantherTheme.colors.error?.[500] || "#ef4444"
+    },
+    fonts: {
+      regular: { fontFamily: "System", fontWeight: "400" },
+      medium: { fontFamily: "System", fontWeight: "500" },
+      bold: { fontFamily: "System", fontWeight: "700" },
+      heavy: { fontFamily: "System", fontWeight: "900" }
+    }
+  };
+}
+
+// src/navigation/provider.tsx
+import { jsx as jsx29 } from "nativewind/jsx-runtime";
+function NavigationProvider({
+  children,
+  linking,
+  fallback,
+  onReady,
+  onStateChange,
+  onUnhandledAction,
+  theme: customTheme
+}) {
+  const { theme, isDark } = useTheme();
+  const navigationTheme = React5.useMemo(
+    () => customTheme || createNavigationTheme(theme, isDark),
+    [customTheme, theme, isDark]
+  );
+  return /* @__PURE__ */ jsx29(
+    NavigationContainer,
+    {
+      theme: navigationTheme,
+      linking,
+      fallback,
+      onReady,
+      onStateChange,
+      onUnhandledAction,
+      children
+    }
+  );
+}
+
+// src/navigation/vendor/stack.ts
+import { createStackNavigator, TransitionPresets } from "@react-navigation/stack";
+
+// src/navigation/navigators/StackNavigator.tsx
+import { jsx as jsx30 } from "nativewind/jsx-runtime";
+var NativeStack = createStackNavigator();
+var defaultScreenOptions = {
+  headerShown: false,
+  ...TransitionPresets.SlideFromRightIOS
+};
+function StackNavigator({ initialRouteName, screenOptions, children }) {
+  return /* @__PURE__ */ jsx30(
+    NativeStack.Navigator,
+    {
+      initialRouteName,
+      screenOptions: { ...defaultScreenOptions, ...screenOptions },
+      children
+    }
+  );
+}
+StackNavigator.Screen = NativeStack.Screen;
+StackNavigator.Group = NativeStack.Group;
+function createStackScreens(routes) {
+  return routes.map((route) => /* @__PURE__ */ jsx30(
+    StackNavigator.Screen,
+    {
+      name: route.name,
+      component: route.component,
+      options: route.options,
+      initialParams: route.initialParams
+    },
+    route.name
+  ));
+}
+
+// src/navigation/navigators/TabNavigator.tsx
+import React6 from "react";
+import { createBottomTabNavigator } from "@react-navigation/bottom-tabs";
+
+// src/navigation/components/BottomTabBar.tsx
+import { View as View8, TouchableOpacity as TouchableOpacity7, StyleSheet as StyleSheet11 } from "react-native";
+import { useSafeAreaInsets as useSafeAreaInsets2 } from "react-native-safe-area-context";
+import { jsx as jsx31, jsxs as jsxs12 } from "nativewind/jsx-runtime";
+var DEFAULT_TAB_BAR_HEIGHT = 65;
+function BottomTabBar({
+  state,
+  descriptors,
+  navigation,
+  showLabel = true,
+  activeTintColor,
+  inactiveTintColor,
+  height = DEFAULT_TAB_BAR_HEIGHT,
+  activeBackgroundColor,
+  inactiveBackgroundColor,
+  iconStyle,
+  labelStyle,
+  style
+}) {
+  const colors = useThemeColors();
+  const insets = useSafeAreaInsets2();
+  const activeColor = activeTintColor || colors.primary;
+  const inactiveColor = inactiveTintColor || colors.textMuted;
+  const backgroundColor = style?.backgroundColor || colors.card;
+  const borderTopColor = colors.divider;
+  return /* @__PURE__ */ jsx31(
+    View8,
+    {
+      style: [
+        styles11.container,
+        { borderTopColor },
+        { backgroundColor, height: height + insets.bottom, paddingBottom: insets.bottom },
+        style
+      ],
+      children: state.routes.map((route, index) => {
+        const { options } = descriptors[route.key];
+        const isFocused = state.index === index;
+        const onPress = () => {
+          const event = navigation.emit({
+            type: "tabPress",
+            target: route.key,
+            canPreventDefault: true
+          });
+          if (!isFocused && !event.defaultPrevented) {
+            navigation.navigate(route.name);
+          }
+        };
+        const onLongPress = () => {
+          navigation.emit({
+            type: "tabLongPress",
+            target: route.key
+          });
+        };
+        const label = options.tabBarLabel !== void 0 ? options.tabBarLabel : options.title !== void 0 ? options.title : route.name;
+        const iconName = options.tabBarIcon ? options.tabBarIcon({
+          focused: isFocused,
+          color: isFocused ? activeColor : inactiveColor,
+          size: 24
+        }) : null;
+        const badge = options.tabBarBadge;
+        return /* @__PURE__ */ jsxs12(
+          TouchableOpacity7,
+          {
+            accessibilityRole: "button",
+            accessibilityState: isFocused ? { selected: true } : {},
+            accessibilityLabel: options.tabBarAccessibilityLabel,
+            testID: options.tabBarTestID,
+            onPress,
+            onLongPress,
+            style: [
+              styles11.tab,
+              {
+                backgroundColor: isFocused ? activeBackgroundColor : inactiveBackgroundColor
+              }
+            ],
+            children: [
+              /* @__PURE__ */ jsxs12(View8, { style: [styles11.iconContainer, iconStyle], children: [
+                iconName,
+                badge != null && /* @__PURE__ */ jsx31(View8, { style: [styles11.badge, { backgroundColor: activeColor }], children: /* @__PURE__ */ jsx31(AppText, { style: styles11.badgeText, children: typeof badge === "number" && badge > 99 ? "99+" : badge }) })
+              ] }),
+              showLabel && /* @__PURE__ */ jsx31(
+                AppText,
+                {
+                  style: [
+                    styles11.label,
+                    { color: isFocused ? activeColor : inactiveColor },
+                    labelStyle
+                  ],
+                  numberOfLines: 1,
+                  children: label
+                }
+              )
+            ]
+          },
+          route.key
+        );
+      })
+    }
+  );
+}
+var styles11 = StyleSheet11.create({
+  container: {
+    flexDirection: "row",
+    borderTopWidth: 0.5,
+    elevation: 8,
+    shadowColor: "#000",
+    shadowOffset: { width: 0, height: -2 },
+    shadowOpacity: 0.1,
+    shadowRadius: 3
+  },
+  tab: {
+    flex: 1,
+    alignItems: "center",
+    justifyContent: "center",
+    paddingVertical: 6
+  },
+  iconContainer: {
+    position: "relative",
+    marginBottom: 2
+  },
+  badge: {
+    position: "absolute",
+    top: -6,
+    right: -10,
+    minWidth: 18,
+    height: 18,
+    borderRadius: 9,
+    justifyContent: "center",
+    alignItems: "center",
+    paddingHorizontal: 4
+  },
+  badgeText: {
+    color: "#fff",
+    fontSize: 10,
+    fontWeight: "bold"
+  },
+  label: {
+    fontSize: 12,
+    marginTop: 2
+  }
+});
+
+// src/navigation/navigators/TabNavigator.tsx
+import { jsx as jsx32 } from "nativewind/jsx-runtime";
+var NativeTab = createBottomTabNavigator();
+var defaultScreenOptions2 = {
+  headerShown: false,
+  tabBarShowLabel: true
+};
+function TabNavigator({
+  initialRouteName,
+  tabBarOptions,
+  tabBar,
+  screenOptions,
+  children
+}) {
+  const mergedScreenOptions = React6.useMemo(() => {
+    const options = { ...defaultScreenOptions2, ...screenOptions };
+    if (tabBarOptions) {
+      if (tabBarOptions.showLabel !== void 0) {
+        options.tabBarShowLabel = tabBarOptions.showLabel;
+      }
+      if (tabBarOptions.activeTintColor) {
+        options.tabBarActiveTintColor = tabBarOptions.activeTintColor;
+      }
+      if (tabBarOptions.inactiveTintColor) {
+        options.tabBarInactiveTintColor = tabBarOptions.inactiveTintColor;
+      }
+      if (tabBarOptions.activeBackgroundColor) {
+        options.tabBarActiveBackgroundColor = tabBarOptions.activeBackgroundColor;
+      }
+      if (tabBarOptions.inactiveBackgroundColor) {
+        options.tabBarInactiveBackgroundColor = tabBarOptions.inactiveBackgroundColor;
+      }
+      if (tabBarOptions.hideOnKeyboard !== void 0) {
+        options.tabBarHideOnKeyboard = tabBarOptions.hideOnKeyboard;
+      }
+      if (tabBarOptions.labelPosition) {
+        options.tabBarLabelPosition = tabBarOptions.labelPosition;
+      }
+      if (tabBarOptions.labelStyle) {
+        options.tabBarLabelStyle = tabBarOptions.labelStyle;
+      }
+      if (tabBarOptions.style) {
+        options.tabBarStyle = tabBarOptions.style;
+      }
+    }
+    return options;
+  }, [tabBarOptions, screenOptions]);
+  const resolvedTabBar = React6.useMemo(() => {
+    if (tabBar) return tabBar;
+    return (props) => /* @__PURE__ */ jsx32(
+      BottomTabBar,
+      {
+        ...props,
+        showLabel: tabBarOptions?.showLabel,
+        activeTintColor: tabBarOptions?.activeTintColor,
+        inactiveTintColor: tabBarOptions?.inactiveTintColor,
+        activeBackgroundColor: tabBarOptions?.activeBackgroundColor,
+        inactiveBackgroundColor: tabBarOptions?.inactiveBackgroundColor,
+        iconStyle: tabBarOptions?.iconStyle,
+        labelStyle: tabBarOptions?.labelStyle,
+        style: tabBarOptions?.style,
+        height: tabBarOptions?.height
+      }
+    );
+  }, [
+    tabBar,
+    tabBarOptions?.showLabel,
+    tabBarOptions?.activeTintColor,
+    tabBarOptions?.inactiveTintColor,
+    tabBarOptions?.activeBackgroundColor,
+    tabBarOptions?.inactiveBackgroundColor,
+    tabBarOptions?.iconStyle,
+    tabBarOptions?.labelStyle,
+    tabBarOptions?.style,
+    tabBarOptions?.height
+  ]);
+  return /* @__PURE__ */ jsx32(
+    NativeTab.Navigator,
+    {
+      initialRouteName,
+      screenOptions: mergedScreenOptions,
+      tabBar: resolvedTabBar,
+      children
+    }
+  );
+}
+TabNavigator.Screen = NativeTab.Screen;
+function createTabScreens(routes) {
+  return routes.map((route) => /* @__PURE__ */ jsx32(
+    TabNavigator.Screen,
+    {
+      name: route.name,
+      component: route.component,
+      options: route.options,
+      initialParams: route.initialParams
+    },
+    route.name
+  ));
+}
+
+// src/navigation/navigators/DrawerNavigator.tsx
+import React7 from "react";
+import { createDrawerNavigator } from "@react-navigation/drawer";
+import { jsx as jsx33 } from "nativewind/jsx-runtime";
+var NativeDrawer = createDrawerNavigator();
+function DrawerNavigator({
+  initialRouteName,
+  screenOptions,
+  drawerContent,
+  drawerOptions,
+  children
+}) {
+  const { theme, isDark } = useTheme();
+  const navigationTheme = createNavigationTheme(theme, isDark);
+  const mergedScreenOptions = React7.useMemo(() => {
+    return {
+      headerShown: false,
+      drawerStyle: {
+        backgroundColor: navigationTheme.colors.card,
+        width: drawerOptions?.drawerWidth || 280
+      },
+      drawerActiveTintColor: theme.colors.primary?.[500] || "#f38b32",
+      drawerInactiveTintColor: navigationTheme.colors.text,
+      drawerLabelStyle: {
+        fontSize: 16
+      },
+      drawerType: drawerOptions?.drawerType,
+      overlayColor: drawerOptions?.overlayColor,
+      edgeWidth: drawerOptions?.edgeWidth,
+      minSwipeDistance: drawerOptions?.minSwipeDistance,
+      ...screenOptions
+    };
+  }, [screenOptions, drawerOptions, navigationTheme, theme]);
+  return /* @__PURE__ */ jsx33(
+    NativeDrawer.Navigator,
+    {
+      initialRouteName,
+      screenOptions: mergedScreenOptions,
+      drawerContent,
+      children
+    }
+  );
+}
+DrawerNavigator.Screen = NativeDrawer.Screen;
+function createDrawerScreens(routes) {
+  return routes.map((route) => /* @__PURE__ */ jsx33(
+    DrawerNavigator.Screen,
+    {
+      name: route.name,
+      component: route.component,
+      options: route.options,
+      initialParams: route.initialParams
+    },
+    route.name
+  ));
+}
+
+// src/navigation/components/AppHeader.tsx
+import { StyleSheet as StyleSheet12 } from "react-native";
+import { useSafeAreaInsets as useSafeAreaInsets3 } from "react-native-safe-area-context";
+import { jsx as jsx34, jsxs as jsxs13 } from "nativewind/jsx-runtime";
+function AppHeader({
+  title,
+  subtitle,
+  leftIcon = "chevron-left",
+  onLeftPress,
+  rightIcons = [],
+  transparent = false,
+  safeArea = true,
+  style
+}) {
+  const colors = useThemeColors();
+  const insets = useSafeAreaInsets3();
+  const backgroundColor = transparent ? "transparent" : colors.card;
+  return /* @__PURE__ */ jsx34(
+    AppView,
+    {
+      style: [
+        {
+          backgroundColor,
+          paddingTop: safeArea ? insets.top : 0
+        },
+        style
+      ],
+      children: /* @__PURE__ */ jsxs13(AppView, { row: true, items: "center", px: 4, style: styles12.container, children: [
+        /* @__PURE__ */ jsx34(AppView, { style: [styles12.sideContainer, styles12.leftContainer], children: leftIcon && /* @__PURE__ */ jsx34(AppPressable, { onPress: onLeftPress, style: styles12.iconButton, children: /* @__PURE__ */ jsx34(Icon, { name: leftIcon, size: 24, color: colors.text }) }) }),
+        /* @__PURE__ */ jsxs13(AppView, { style: styles12.centerContainer, children: [
+          title && /* @__PURE__ */ jsx34(
+            AppText,
+            {
+              size: "lg",
+              weight: "semibold",
+              style: [styles12.title, { color: colors.text }],
+              numberOfLines: 1,
+              children: title
+            }
+          ),
+          subtitle && /* @__PURE__ */ jsx34(
+            AppText,
+            {
+              size: "xs",
+              style: [styles12.subtitle, { color: colors.textMuted }],
+              numberOfLines: 1,
+              children: subtitle
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx34(AppView, { row: true, items: "center", style: [styles12.sideContainer, styles12.rightContainer], children: rightIcons.map((icon, index) => /* @__PURE__ */ jsx34(AppPressable, { onPress: icon.onPress, style: styles12.iconButton, children: /* @__PURE__ */ jsxs13(AppView, { children: [
+          /* @__PURE__ */ jsx34(Icon, { name: icon.icon, size: 24, color: colors.text }),
+          icon.badge ? /* @__PURE__ */ jsx34(AppView, { style: styles12.badge, children: /* @__PURE__ */ jsx34(AppText, { size: "xs", color: "white", style: styles12.badgeText, children: icon.badge > 99 ? "99+" : icon.badge }) }) : null
+        ] }) }, index)) })
+      ] })
+    }
+  );
+}
+var styles12 = StyleSheet12.create({
+  container: {
+    height: 44
+    // iOS 标准导航栏高度
+  },
+  sideContainer: {
+    width: 70,
+    // 固定宽度，确保标题居中
+    flexDirection: "row",
+    alignItems: "center"
+  },
+  leftContainer: {
+    justifyContent: "flex-start"
+  },
+  rightContainer: {
+    justifyContent: "flex-end"
+  },
+  centerContainer: {
+    flex: 1,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  title: {
+    textAlign: "center"
+  },
+  subtitle: {
+    textAlign: "center",
+    marginTop: 2
+  },
+  iconButton: {
+    padding: 8
+  },
+  badge: {
+    position: "absolute",
+    top: -4,
+    right: -4,
+    minWidth: 16,
+    height: 16,
+    borderRadius: 8,
+    backgroundColor: "#ef4444",
+    alignItems: "center",
+    justifyContent: "center",
+    paddingHorizontal: 4
+  },
+  badgeText: {
+    fontSize: 10,
+    fontWeight: "bold"
+  }
+});
+
+// src/navigation/components/DrawerContent.tsx
+import { View as View9, TouchableOpacity as TouchableOpacity8, StyleSheet as StyleSheet13 } from "react-native";
+import { DrawerContentScrollView } from "@react-navigation/drawer";
+import { jsx as jsx35, jsxs as jsxs14 } from "nativewind/jsx-runtime";
+function DrawerContent({
+  state,
+  descriptors,
+  navigation,
+  header,
+  footer,
+  items,
+  activeBackgroundColor,
+  activeTintColor,
+  inactiveTintColor
+}) {
+  const { theme, isDark } = useTheme();
+  const colors = useThemeColors();
+  const activeBgColor = activeBackgroundColor || (isDark ? colors.primarySurface : theme.colors.primary?.[50] || "#fff7ed");
+  const activeColor = activeTintColor || colors.primary;
+  const inactiveColor = inactiveTintColor || (isDark ? "#d1d5db" : "#4b5563");
+  const backgroundColor = colors.card;
+  const dividerColor = colors.divider;
+  const drawerItems = items || state.routes.map((route) => {
+    const descriptor = descriptors[route.key];
+    const options = descriptor.options;
+    return {
+      name: route.name,
+      label: options.drawerLabel || options.title || route.name,
+      icon: options.drawerIcon?.({ size: 24, color: inactiveColor })?.props?.name,
+      badge: options.tabBarBadge
+    };
+  });
+  return /* @__PURE__ */ jsxs14(DrawerContentScrollView, { style: [styles13.container, { backgroundColor }], children: [
+    header && /* @__PURE__ */ jsx35(View9, { style: [styles13.header, { borderBottomColor: dividerColor }], children: header }),
+    /* @__PURE__ */ jsx35(AppView, { className: "py-2", children: drawerItems.map((item) => {
+      const isFocused = state.routes[state.index].name === item.name;
+      const onPress = () => {
+        navigation.navigate(item.name);
+      };
+      return /* @__PURE__ */ jsxs14(
+        TouchableOpacity8,
+        {
+          onPress,
+          style: [styles13.item, isFocused && { backgroundColor: activeBgColor }],
+          children: [
+            item.icon && /* @__PURE__ */ jsx35(View9, { style: styles13.iconContainer, children: /* @__PURE__ */ jsx35(
+              Icon,
+              {
+                name: item.icon,
+                size: "md",
+                color: isFocused ? activeColor : inactiveColor
+              }
+            ) }),
+            /* @__PURE__ */ jsx35(
+              AppText,
+              {
+                style: [
+                  styles13.label,
+                  { color: isFocused ? activeColor : inactiveColor },
+                  isFocused && styles13.activeLabel
+                ],
+                numberOfLines: 1,
+                children: item.label
+              }
+            ),
+            item.badge != null && /* @__PURE__ */ jsx35(View9, { style: [styles13.badge, { backgroundColor: activeColor }], children: /* @__PURE__ */ jsx35(AppText, { style: styles13.badgeText, children: typeof item.badge === "number" && item.badge > 99 ? "99+" : item.badge }) })
+          ]
+        },
+        item.name
+      );
+    }) }),
+    footer && /* @__PURE__ */ jsx35(View9, { style: [styles13.footer, { borderTopColor: dividerColor }], children: footer })
+  ] });
+}
+var styles13 = StyleSheet13.create({
+  container: {
+    flex: 1
+  },
+  header: {
+    padding: 16,
+    borderBottomWidth: 0.5
+  },
+  item: {
+    flexDirection: "row",
+    alignItems: "center",
+    paddingHorizontal: 16,
+    paddingVertical: 12,
+    marginHorizontal: 8,
+    marginVertical: 2,
+    borderRadius: 8
+  },
+  iconContainer: {
+    width: 32,
+    alignItems: "center",
+    marginRight: 8
+  },
+  label: {
+    flex: 1,
+    fontSize: 16
+  },
+  activeLabel: {
+    fontWeight: "600"
+  },
+  badge: {
+    minWidth: 20,
+    height: 20,
+    borderRadius: 10,
+    justifyContent: "center",
+    alignItems: "center",
+    paddingHorizontal: 6
+  },
+  badgeText: {
+    color: "#fff",
+    fontSize: 12,
+    fontWeight: "bold"
+  },
+  footer: {
+    marginTop: "auto",
+    padding: 16,
+    borderTopWidth: 0.5
+  }
+});
+
+// src/navigation/hooks/useNavigation.ts
+import { useEffect as useEffect10 } from "react";
+import { useNavigation as useRNNavigation } from "@react-navigation/native";
+function useNavigation() {
+  return useRNNavigation();
+}
+function useStackNavigation() {
+  return useRNNavigation();
+}
+function useTabNavigation() {
+  return useRNNavigation();
+}
+function useDrawerNavigation() {
+  return useRNNavigation();
+}
+function useBackHandler(handler) {
+  const navigation = useRNNavigation();
+  useEffect10(() => {
+    const unsubscribe = navigation.addListener("beforeRemove", (e) => {
+      if (!handler()) {
+        e.preventDefault();
+      }
+    });
+    return unsubscribe;
+  }, [navigation, handler]);
+}
+
+// src/navigation/hooks/useRoute.ts
+import { useRoute as useRNRoute } from "@react-navigation/native";
+function useRoute() {
+  return useRNRoute();
+}
+
+// src/navigation/hooks/useNavigationState.ts
+import {
+  useNavigationState as useRNNavigationState,
+  useIsFocused,
+  useFocusEffect,
+  useScrollToTop
+} from "@react-navigation/native";
+function useNavigationState(selector) {
+  return useRNNavigationState(selector);
+}
+
+// src/navigation/index.ts
+import {
+  NavigationContainer as NavigationContainer2
+} from "@react-navigation/native";
+
+// src/overlay/AppProvider.tsx
+import { SafeAreaProvider } from "react-native-safe-area-context";
+
+// src/overlay/AppStatusBar.tsx
+import { StatusBar } from "react-native";
+import { jsx as jsx36 } from "nativewind/jsx-runtime";
+function AppStatusBar({
+  barStyle = "auto",
+  backgroundColor,
+  translucent = false,
+  ...props
+}) {
+  const { theme, isDark } = useTheme();
+  const resolvedBarStyle = barStyle === "auto" ? isDark ? "light-content" : "dark-content" : barStyle;
+  const resolvedBackgroundColor = backgroundColor ?? (translucent ? "transparent" : theme.colors.background?.[500] || "#ffffff");
+  return /* @__PURE__ */ jsx36(
+    StatusBar,
+    {
+      barStyle: resolvedBarStyle,
+      backgroundColor: resolvedBackgroundColor,
+      translucent,
+      ...props
+    }
+  );
+}
+
+// src/overlay/loading/provider.tsx
+import { useState as useState26, useCallback as useCallback18 } from "react";
+
+// src/overlay/loading/context.ts
+import { createContext as createContext2, useContext as useContext2 } from "react";
+var LoadingContext = createContext2(null);
+function useLoadingContext() {
+  const ctx = useContext2(LoadingContext);
+  if (!ctx) throw new Error("useLoading must be used within OverlayProvider");
+  return ctx;
+}
+
+// src/overlay/loading/component.tsx
+import { View as View10, Modal as Modal4, ActivityIndicator as ActivityIndicator5, StyleSheet as StyleSheet14 } from "react-native";
+import { jsx as jsx37, jsxs as jsxs15 } from "nativewind/jsx-runtime";
+function LoadingModal({ visible, text }) {
+  return /* @__PURE__ */ jsx37(Modal4, { transparent: true, visible, animationType: "fade", children: /* @__PURE__ */ jsx37(View10, { style: styles14.overlay, children: /* @__PURE__ */ jsxs15(View10, { style: [styles14.loadingBox, { backgroundColor: "rgba(0,0,0,0.8)" }], children: [
+    /* @__PURE__ */ jsx37(ActivityIndicator5, { size: "large", color: "#fff" }),
+    text && /* @__PURE__ */ jsx37(AppText, { className: "text-white mt-3 text-sm", children: text })
+  ] }) }) });
+}
+var styles14 = StyleSheet14.create({
+  overlay: {
+    flex: 1,
+    backgroundColor: "rgba(0,0,0,0.5)",
+    justifyContent: "center",
+    alignItems: "center"
+  },
+  loadingBox: {
+    padding: 24,
+    borderRadius: 12,
+    alignItems: "center",
+    minWidth: 120
+  }
+});
+
+// src/overlay/loading/provider.tsx
+import { jsx as jsx38, jsxs as jsxs16 } from "nativewind/jsx-runtime";
+function LoadingProvider({ children }) {
+  const [state, setState] = useState26({ visible: false });
+  const show = useCallback18((text) => {
+    setState({ visible: true, text });
+  }, []);
+  const hide = useCallback18(() => {
+    setState({ visible: false });
+  }, []);
+  return /* @__PURE__ */ jsxs16(LoadingContext.Provider, { value: { show, hide }, children: [
+    children,
+    /* @__PURE__ */ jsx38(LoadingModal, { ...state })
+  ] });
+}
+
+// src/overlay/toast/provider.tsx
+import { useState as useState27, useCallback as useCallback19, useRef as useRef9 } from "react";
+import { View as View11, StyleSheet as StyleSheet15 } from "react-native";
+
+// src/overlay/toast/context.ts
+import { createContext as createContext3, useContext as useContext3 } from "react";
+var ToastContext = createContext3(null);
+function useToastContext() {
+  const ctx = useContext3(ToastContext);
+  if (!ctx) throw new Error("useToast must be used within OverlayProvider");
+  return ctx;
+}
+
+// src/overlay/toast/component.tsx
+import { useRef as useRef8, useEffect as useEffect11 } from "react";
+import { Animated } from "react-native";
+import { jsx as jsx39 } from "nativewind/jsx-runtime";
+function ToastItemView({ message, type, onHide }) {
+  const fadeAnim = useRef8(new Animated.Value(0)).current;
+  useEffect11(() => {
+    Animated.sequence([
+      Animated.timing(fadeAnim, { toValue: 1, duration: 200, useNativeDriver: true }),
+      Animated.delay(2500),
+      Animated.timing(fadeAnim, { toValue: 0, duration: 200, useNativeDriver: true })
+    ]).start(onHide);
+  }, []);
+  const bgColors = {
+    success: "bg-success-500",
+    error: "bg-error-500",
+    warning: "bg-warning-500",
+    info: "bg-primary-500"
+  };
+  return /* @__PURE__ */ jsx39(
+    Animated.View,
+    {
+      style: {
+        opacity: fadeAnim,
+        transform: [
+          {
+            translateY: fadeAnim.interpolate({
+              inputRange: [0, 1],
+              outputRange: [-20, 0]
+            })
+          }
+        ]
+      },
+      children: /* @__PURE__ */ jsx39(AppView, { className: `${bgColors[type]} px-4 py-3 rounded-lg mb-2 mx-4 shadow-lg`, children: /* @__PURE__ */ jsx39(AppText, { className: "text-white text-center", children: message }) })
+    }
+  );
+}
+
+// src/overlay/toast/provider.tsx
+import { jsx as jsx40, jsxs as jsxs17 } from "nativewind/jsx-runtime";
+function ToastProvider({ children }) {
+  const [toasts, setToasts] = useState27([]);
+  const timersRef = useRef9(/* @__PURE__ */ new Map());
+  const remove = useCallback19((id) => {
+    setToasts((prev) => prev.filter((t) => t.id !== id));
+    const timer = timersRef.current.get(id);
+    if (timer) {
+      clearTimeout(timer);
+      timersRef.current.delete(id);
+    }
+  }, []);
+  const show = useCallback19(
+    (message, type = "info", duration = 3e3) => {
+      const id = Math.random().toString(36).substring(7);
+      const toast = { id, message, type, duration };
+      setToasts((prev) => [...prev, toast]);
+      const timer = setTimeout(() => remove(id), duration);
+      timersRef.current.set(id, timer);
+    },
+    [remove]
+  );
+  const success = useCallback19(
+    (message, duration) => show(message, "success", duration),
+    [show]
+  );
+  const error = useCallback19(
+    (message, duration) => show(message, "error", duration),
+    [show]
+  );
+  const info = useCallback19(
+    (message, duration) => show(message, "info", duration),
+    [show]
+  );
+  const warning = useCallback19(
+    (message, duration) => show(message, "warning", duration),
+    [show]
+  );
+  return /* @__PURE__ */ jsxs17(ToastContext.Provider, { value: { show, success, error, info, warning }, children: [
+    children,
+    /* @__PURE__ */ jsx40(View11, { style: styles15.toastContainer, pointerEvents: "none", children: toasts.map((toast) => /* @__PURE__ */ jsx40(ToastItemView, { ...toast, onHide: () => remove(toast.id) }, toast.id)) })
+  ] });
+}
+var styles15 = StyleSheet15.create({
+  toastContainer: {
+    position: "absolute",
+    top: 60,
+    left: 0,
+    right: 0,
+    zIndex: 9999
+  }
+});
+
+// src/overlay/alert/provider.tsx
+import { useState as useState28, useCallback as useCallback20 } from "react";
+
+// src/overlay/alert/context.ts
+import { createContext as createContext4, useContext as useContext4 } from "react";
+var AlertContext = createContext4(null);
+function useAlertContext() {
+  const ctx = useContext4(AlertContext);
+  if (!ctx) throw new Error("useAlert must be used within OverlayProvider");
+  return ctx;
+}
+
+// src/overlay/alert/component.tsx
+import { View as View12, Modal as Modal5, StyleSheet as StyleSheet16 } from "react-native";
+import { jsx as jsx41, jsxs as jsxs18 } from "nativewind/jsx-runtime";
+function AlertModal({
+  visible,
+  title,
+  message,
+  confirmText,
+  cancelText,
+  showCancel,
+  onConfirm,
+  onCancel
+}) {
+  if (!visible) return null;
+  return /* @__PURE__ */ jsx41(Modal5, { transparent: true, visible: true, animationType: "fade", children: /* @__PURE__ */ jsx41(View12, { style: styles16.overlay, children: /* @__PURE__ */ jsxs18(View12, { style: styles16.alertBox, children: [
+    title && /* @__PURE__ */ jsx41(AppText, { className: "text-lg font-semibold text-center mb-2", children: title }),
+    message && /* @__PURE__ */ jsx41(AppText, { className: "text-gray-600 text-center mb-4", children: message }),
+    /* @__PURE__ */ jsxs18(AppView, { row: true, gap: 3, className: "mt-2", children: [
+      showCancel && /* @__PURE__ */ jsx41(AppPressable, { onPress: onCancel, className: "flex-1 py-3 bg-gray-100 rounded-lg", children: /* @__PURE__ */ jsx41(AppText, { className: "text-center text-gray-700", children: cancelText || "\u53D6\u6D88" }) }),
+      /* @__PURE__ */ jsx41(AppPressable, { onPress: onConfirm, className: "flex-1 py-3 bg-primary-500 rounded-lg", children: /* @__PURE__ */ jsx41(AppText, { className: "text-center text-white", children: confirmText || "\u786E\u5B9A" }) })
+    ] })
+  ] }) }) });
+}
+var styles16 = StyleSheet16.create({
+  overlay: {
+    flex: 1,
+    backgroundColor: "rgba(0,0,0,0.5)",
+    justifyContent: "center",
+    alignItems: "center"
+  },
+  alertBox: {
+    backgroundColor: "white",
+    borderRadius: 12,
+    padding: 24,
+    margin: 32,
+    minWidth: 280,
+    shadowColor: "#000",
+    shadowOffset: { width: 0, height: 2 },
+    shadowOpacity: 0.25,
+    shadowRadius: 4,
+    elevation: 5
+  }
+});
+
+// src/overlay/alert/provider.tsx
+import { jsx as jsx42, jsxs as jsxs19 } from "nativewind/jsx-runtime";
+function AlertProvider({ children }) {
+  const [alert, setAlert] = useState28(null);
+  const showAlert = useCallback20((options) => {
+    setAlert({ ...options, visible: true });
+  }, []);
+  const confirm = useCallback20(
+    (options) => {
+      showAlert({ ...options, showCancel: true });
+    },
+    [showAlert]
+  );
+  const hide = useCallback20(() => {
+    setAlert(null);
+  }, []);
+  const handleConfirm = useCallback20(() => {
+    alert?.onConfirm?.();
+    hide();
+  }, [alert, hide]);
+  const handleCancel = useCallback20(() => {
+    alert?.onCancel?.();
+    hide();
+  }, [alert, hide]);
+  return /* @__PURE__ */ jsxs19(AlertContext.Provider, { value: { alert: showAlert, confirm }, children: [
+    children,
+    /* @__PURE__ */ jsx42(
+      AlertModal,
+      {
+        visible: alert?.visible ?? false,
+        title: alert?.title,
+        message: alert?.message,
+        confirmText: alert?.confirmText,
+        cancelText: alert?.cancelText,
+        showCancel: alert?.showCancel,
+        onConfirm: handleConfirm,
+        onCancel: handleCancel
+      }
+    )
+  ] });
+}
+
+// src/overlay/provider.tsx
+import { jsx as jsx43 } from "nativewind/jsx-runtime";
+function OverlayProvider({ children }) {
+  return /* @__PURE__ */ jsx43(LoadingProvider, { children: /* @__PURE__ */ jsx43(ToastProvider, { children: /* @__PURE__ */ jsx43(AlertProvider, { children }) }) });
+}
+
+// src/overlay/AppProvider.tsx
+import { Fragment as Fragment4, jsx as jsx44, jsxs as jsxs20 } from "nativewind/jsx-runtime";
+var defaultLightTheme = {
+  colors: {
+    primary: "#f38b32",
+    secondary: "#3b82f6",
+    success: "#22c55e",
+    warning: "#f59e0b",
+    error: "#ef4444",
+    info: "#3b82f6"
+  }
+};
+var defaultDarkTheme = {
+  colors: {
+    primary: "#f38b32",
+    secondary: "#60a5fa",
+    success: "#4ade80",
+    warning: "#fbbf24",
+    error: "#f87171",
+    info: "#60a5fa"
+  }
+};
+function AppProvider({
+  children,
+  enableNavigation = true,
+  enableOverlay = true,
+  enableTheme = true,
+  enableStatusBar = true,
+  enableSafeArea = true,
+  lightTheme = defaultLightTheme,
+  darkTheme = defaultDarkTheme,
+  defaultDark = false,
+  isDark,
+  statusBarProps,
+  ...navigationProps
+}) {
+  let content = children;
+  if (enableOverlay) {
+    content = /* @__PURE__ */ jsx44(OverlayProvider, { children: content });
+  }
+  if (enableNavigation) {
+    content = /* @__PURE__ */ jsx44(NavigationProvider, { ...navigationProps, children: content });
+  }
+  if (enableTheme) {
+    content = /* @__PURE__ */ jsx44(ThemeProvider, { light: lightTheme, dark: darkTheme, defaultDark, isDark, children: /* @__PURE__ */ jsxs20(Fragment4, { children: [
+      enableStatusBar && /* @__PURE__ */ jsx44(AppStatusBar, { testID: "status-bar", ...statusBarProps }),
+      content
+    ] }) });
+  }
+  if (enableSafeArea) {
+    content = /* @__PURE__ */ jsx44(SafeAreaProvider, { children: content });
+  }
+  return /* @__PURE__ */ jsx44(Fragment4, { children: content });
+}
+
+// src/overlay/loading/hooks.ts
+function useLoading() {
+  return useLoadingContext();
+}
+
+// src/overlay/toast/hooks.ts
+function useToast() {
+  return useToastContext();
+}
+
+// src/overlay/alert/hooks.ts
+function useAlert() {
+  return useAlertContext();
+}
+
+// src/index.ts
+import { SafeAreaProvider as SafeAreaProvider2 } from "react-native-safe-area-context";
+export {
+  ActionIcons,
+  Alert,
+  AppButton,
+  AppHeader,
+  AppImage,
+  AppInput,
+  AppList,
+  AppPressable,
+  AppProvider,
+  AppScrollView,
+  AppStatusBar,
+  AppText,
+  AppView,
+  BottomTabBar,
+  Card,
+  Center,
+  Checkbox,
+  CheckboxGroup,
+  Col,
+  DatePicker,
+  DrawerContent,
+  DrawerNavigator,
+  ErrorCode,
+  FileIcons,
+  FormItem,
+  Icon,
+  Loading,
+  MemoryStorage,
+  NavigationContainer2 as NavigationContainer,
+  NavigationIcons,
+  NavigationProvider,
+  OverlayProvider,
+  Page,
+  Progress,
+  Radio,
+  RadioGroup,
+  Row,
+  SafeAreaProvider2 as SafeAreaProvider,
+  SafeBottom,
+  SafeScreen,
+  Select,
+  Slider,
+  StackNavigator,
+  StatusIcons,
+  Switch,
+  TabNavigator,
+  ThemeProvider,
+  Toast,
+  adjustBrightness,
+  capitalize,
+  clamp,
+  clsx,
+  cn,
+  createAPI,
+  createDrawerScreens,
+  createNavigationTheme,
+  createStackScreens,
+  createTabScreens,
+  createTheme,
+  deepMerge,
+  enhanceError,
+  formatCurrency,
+  formatDate,
+  formatNumber,
+  formatPercent,
+  formatRelativeTime,
+  generateColorPalette,
+  getThemeColors,
+  getValidationErrors,
+  hexToRgb,
+  isDevelopment,
+  isValidEmail,
+  isValidPhone,
+  mapHttpStatus,
+  omit,
+  pick,
+  rgbToHex,
+  slugify,
+  storage,
+  truncate,
+  twMerge,
+  useAlert,
+  useAsyncState,
+  useBackHandler,
+  useDebounce,
+  useDimensions,
+  useDrawerNavigation,
+  useFocusEffect,
+  useForm,
+  useInfinite,
+  useIsFocused,
+  useKeyboard,
+  useLoading,
+  useMemoizedFn,
+  useMutation,
+  useNavigation,
+  useNavigationState,
+  useOrientation,
+  usePagination,
+  usePrevious,
+  useQuery,
+  useRefresh,
+  useRequest,
+  useRoute,
+  useScrollToTop,
+  useSetState,
+  useStackNavigation,
+  useStorage,
+  useTabNavigation,
+  useTheme,
+  useThemeColors,
+  useThrottle,
+  useToast,
+  useToggle,
+  useUpdateEffect,
+  z
+};
+//# sourceMappingURL=index.mjs.map