@gaozh1024/rn-kit 0.2.0-beta.0

package/dist/index.js

@@ -0,0 +1,4627 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActionIcons: () => ActionIcons,
+  Alert: () => Alert,
+  AppButton: () => AppButton,
+  AppHeader: () => AppHeader,
+  AppImage: () => AppImage,
+  AppInput: () => AppInput,
+  AppList: () => AppList,
+  AppPressable: () => AppPressable,
+  AppProvider: () => AppProvider,
+  AppScrollView: () => AppScrollView,
+  AppStatusBar: () => AppStatusBar,
+  AppText: () => AppText,
+  AppView: () => AppView,
+  BottomTabBar: () => BottomTabBar,
+  Card: () => Card,
+  Center: () => Center,
+  Checkbox: () => Checkbox,
+  CheckboxGroup: () => CheckboxGroup,
+  Col: () => Col,
+  DatePicker: () => DatePicker,
+  DrawerContent: () => DrawerContent,
+  DrawerNavigator: () => DrawerNavigator,
+  ErrorCode: () => ErrorCode,
+  FileIcons: () => FileIcons,
+  FormItem: () => FormItem,
+  Icon: () => Icon,
+  Loading: () => Loading,
+  MemoryStorage: () => MemoryStorage,
+  NavigationContainer: () => import_native5.NavigationContainer,
+  NavigationIcons: () => NavigationIcons,
+  NavigationProvider: () => NavigationProvider,
+  OverlayProvider: () => OverlayProvider,
+  Page: () => Page,
+  Progress: () => Progress,
+  Radio: () => Radio,
+  RadioGroup: () => RadioGroup,
+  Row: () => Row,
+  SafeAreaProvider: () => import_react_native_safe_area_context5.SafeAreaProvider,
+  SafeBottom: () => SafeBottom,
+  SafeScreen: () => SafeScreen,
+  Select: () => Select,
+  Slider: () => Slider,
+  StackNavigator: () => StackNavigator,
+  StatusIcons: () => StatusIcons,
+  Switch: () => Switch,
+  TabNavigator: () => TabNavigator,
+  ThemeProvider: () => ThemeProvider,
+  Toast: () => Toast,
+  adjustBrightness: () => adjustBrightness,
+  capitalize: () => capitalize,
+  clamp: () => clamp,
+  clsx: () => import_clsx.clsx,
+  cn: () => cn,
+  createAPI: () => createAPI,
+  createDrawerScreens: () => createDrawerScreens,
+  createNavigationTheme: () => createNavigationTheme,
+  createStackScreens: () => createStackScreens,
+  createTabScreens: () => createTabScreens,
+  createTheme: () => createTheme,
+  deepMerge: () => deepMerge,
+  enhanceError: () => enhanceError,
+  formatCurrency: () => formatCurrency,
+  formatDate: () => formatDate,
+  formatNumber: () => formatNumber,
+  formatPercent: () => formatPercent,
+  formatRelativeTime: () => formatRelativeTime,
+  generateColorPalette: () => generateColorPalette,
+  getThemeColors: () => getThemeColors,
+  getValidationErrors: () => getValidationErrors,
+  hexToRgb: () => hexToRgb,
+  isDevelopment: () => isDevelopment,
+  isValidEmail: () => isValidEmail,
+  isValidPhone: () => isValidPhone,
+  mapHttpStatus: () => mapHttpStatus,
+  omit: () => omit,
+  pick: () => pick,
+  rgbToHex: () => rgbToHex,
+  slugify: () => slugify,
+  storage: () => storage,
+  truncate: () => truncate,
+  twMerge: () => import_tailwind_merge.twMerge,
+  useAlert: () => useAlert,
+  useAsyncState: () => useAsyncState,
+  useBackHandler: () => useBackHandler,
+  useDebounce: () => useDebounce,
+  useDimensions: () => useDimensions,
+  useDrawerNavigation: () => useDrawerNavigation,
+  useFocusEffect: () => import_native4.useFocusEffect,
+  useForm: () => useForm,
+  useInfinite: () => useInfinite,
+  useIsFocused: () => import_native4.useIsFocused,
+  useKeyboard: () => useKeyboard,
+  useLoading: () => useLoading,
+  useMemoizedFn: () => useMemoizedFn,
+  useMutation: () => import_react_query.useMutation,
+  useNavigation: () => useNavigation,
+  useNavigationState: () => useNavigationState,
+  useOrientation: () => useOrientation,
+  usePagination: () => usePagination,
+  usePrevious: () => usePrevious,
+  useQuery: () => import_react_query.useQuery,
+  useRefresh: () => useRefresh,
+  useRequest: () => useRequest,
+  useRoute: () => useRoute,
+  useScrollToTop: () => import_native4.useScrollToTop,
+  useSetState: () => useSetState,
+  useStackNavigation: () => useStackNavigation,
+  useStorage: () => useStorage,
+  useTabNavigation: () => useTabNavigation,
+  useTheme: () => useTheme,
+  useThemeColors: () => useThemeColors,
+  useThrottle: () => useThrottle,
+  useToast: () => useToast,
+  useToggle: () => useToggle,
+  useUpdateEffect: () => useUpdateEffect,
+  z: () => import_zod2.z
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/cn.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
+function cn(...inputs) {
+  return (0, import_tailwind_merge.twMerge)((0, import_clsx.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
+var import_react = require("react");
+var import_jsx_runtime = require("nativewind/jsx-runtime");
+var ThemeContext = (0, import_react.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] = (0, import_react.useState)(defaultDark);
+  const isDark = controlledIsDark ?? internalIsDark;
+  const theme = (0, import_react.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__ */ (0, import_jsx_runtime.jsx)(ThemeContext.Provider, { value: { theme, isDark, toggleTheme }, children });
+}
+function useTheme() {
+  const context = (0, import_react.useContext)(ThemeContext);
+  if (!context) throw new Error("useTheme must be used within ThemeProvider");
+  return context;
+}
+function useOptionalTheme() {
+  const context = (0, import_react.useContext)(ThemeContext);
+  return context || {
+    theme: fallbackTheme,
+    isDark: false,
+    toggleTheme: () => {
+    }
+  };
+}
+
+// src/theme/tokens.ts
+var import_react2 = require("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 (0, import_react2.useMemo)(() => getThemeColors(theme, isDark), [theme, isDark]);
+}
+
+// src/core/index.ts
+var import_zod2 = require("zod");
+var import_react_query = require("@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
+var import_react3 = require("react");
+function useAsyncState() {
+  const [data, setData] = (0, import_react3.useState)(null);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const [loading, setLoading] = (0, import_react3.useState)(false);
+  const execute = (0, import_react3.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 = (0, import_react3.useCallback)(() => {
+    setData(null);
+    setError(null);
+    setLoading(false);
+  }, []);
+  return { data, error, loading, execute, reset };
+}
+
+// src/core/api/create-api.ts
+var import_zod = require("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 import_zod.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
+var import_react4 = require("react");
+function useRequest(service, options = {}) {
+  const {
+    manual = false,
+    deps = [],
+    defaultParams,
+    onSuccess,
+    onError,
+    onFinally,
+    retryCount = 0,
+    retryDelay = 1e3
+  } = options;
+  const [data, setData] = (0, import_react4.useState)(void 0);
+  const [loading, setLoading] = (0, import_react4.useState)(!manual);
+  const [error, setError] = (0, import_react4.useState)(void 0);
+  const serviceRef = (0, import_react4.useRef)(service);
+  const paramsRef = (0, import_react4.useRef)(defaultParams);
+  const retryCountRef = (0, import_react4.useRef)(0);
+  const canceledRef = (0, import_react4.useRef)(false);
+  serviceRef.current = service;
+  const run = (0, import_react4.useCallback)(
+    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 = (0, import_react4.useCallback)(() => {
+    if (paramsRef.current) {
+      return run(...paramsRef.current);
+    }
+    throw new Error("No params to refresh");
+  }, [run]);
+  const cancel = (0, import_react4.useCallback)(() => {
+    canceledRef.current = true;
+  }, []);
+  const mutate = (0, import_react4.useCallback)((newData) => {
+    setData((prev) => {
+      if (typeof newData === "function") {
+        return newData(prev);
+      }
+      return newData;
+    });
+  }, []);
+  (0, import_react4.useEffect)(() => {
+    if (!manual) {
+      run(...defaultParams || []);
+    }
+    return () => {
+      canceledRef.current = true;
+    };
+  }, deps);
+  return {
+    data,
+    loading,
+    error,
+    run,
+    refresh,
+    cancel,
+    mutate
+  };
+}
+
+// src/core/hooks/usePagination.ts
+var import_react5 = require("react");
+function usePagination(service, options = {}) {
+  const { defaultCurrent = 1, defaultPageSize = 10 } = options;
+  const [data, setData] = (0, import_react5.useState)([]);
+  const [current, setCurrent] = (0, import_react5.useState)(defaultCurrent);
+  const [pageSize] = (0, import_react5.useState)(defaultPageSize);
+  const [total, setTotal] = (0, import_react5.useState)(0);
+  const [loading, setLoading] = (0, import_react5.useState)(false);
+  const [refreshing, setRefreshing] = (0, import_react5.useState)(false);
+  const [loadingMore, setLoadingMore] = (0, import_react5.useState)(false);
+  const [error, setError] = (0, import_react5.useState)(null);
+  const serviceRef = (0, import_react5.useRef)(service);
+  serviceRef.current = service;
+  const hasMore = data.length < total;
+  const fetch2 = (0, import_react5.useCallback)(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 = (0, import_react5.useCallback)(async () => {
+    setRefreshing(true);
+    try {
+      await fetch2({ current: 1, pageSize }, true);
+      setCurrent(1);
+    } finally {
+      setRefreshing(false);
+    }
+  }, [fetch2, pageSize]);
+  const loadMore = (0, import_react5.useCallback)(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 = (0, import_react5.useCallback)(
+    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
+var import_react6 = require("react");
+function usePrevious(value) {
+  const ref = (0, import_react6.useRef)(void 0);
+  (0, import_react6.useEffect)(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+
+// src/core/hooks/useSetState.ts
+var import_react7 = require("react");
+function useSetState(initialState) {
+  const [state, setState] = (0, import_react7.useState)(initialState);
+  const setMergeState = (0, import_react7.useCallback)((patch) => {
+    setState((prev) => ({
+      ...prev,
+      ...typeof patch === "function" ? patch(prev) : patch
+    }));
+  }, []);
+  const resetState = (0, import_react7.useCallback)(() => {
+    setState(initialState);
+  }, [initialState]);
+  return [state, setMergeState, resetState];
+}
+
+// src/core/hooks/useMemoizedFn.ts
+var import_react8 = require("react");
+function useMemoizedFn(fn) {
+  const fnRef = (0, import_react8.useRef)(fn);
+  fnRef.current = fn;
+  const memoizedFn = (0, import_react8.useCallback)(
+    ((...args) => {
+      return fnRef.current(...args);
+    }),
+    []
+  );
+  return memoizedFn;
+}
+
+// src/core/hooks/useUpdateEffect.ts
+var import_react9 = require("react");
+function useUpdateEffect(effect, deps) {
+  const isFirstRender = (0, import_react9.useRef)(true);
+  (0, import_react9.useEffect)(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      return;
+    }
+    return effect();
+  }, deps);
+}
+
+// src/core/hooks/useStorage.ts
+var import_react10 = require("react");
+function useStorage(key, defaultValue) {
+  const [value, setValue] = (0, import_react10.useState)(defaultValue);
+  const [, setIsLoaded] = (0, import_react10.useState)(false);
+  (0, import_react10.useEffect)(() => {
+    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 = (0, import_react10.useCallback)(
+    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 = (0, import_react10.useCallback)(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
+var import_react11 = require("react");
+function useRefresh(fetcher) {
+  const [data, setData] = (0, import_react11.useState)(void 0);
+  const [refreshing, setRefreshing] = (0, import_react11.useState)(false);
+  const [error, setError] = (0, import_react11.useState)(void 0);
+  const refresh = (0, import_react11.useCallback)(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
+var import_react12 = require("react");
+function useInfinite(fetcher, options = {}) {
+  const { defaultPage = 1, pageSize = 10 } = options;
+  const [data, setData] = (0, import_react12.useState)([]);
+  const [page, setPage] = (0, import_react12.useState)(defaultPage);
+  const [loading, setLoading] = (0, import_react12.useState)(false);
+  const [loadingMore, setLoadingMore] = (0, import_react12.useState)(false);
+  const [hasMore, setHasMore] = (0, import_react12.useState)(true);
+  const [error, setError] = (0, import_react12.useState)(void 0);
+  const fetchData = (0, import_react12.useCallback)(
+    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 = (0, import_react12.useCallback)(async () => {
+    await fetchData(defaultPage, false);
+  }, [fetchData, defaultPage]);
+  const loadMore = (0, import_react12.useCallback)(async () => {
+    if (loadingMore || !hasMore) return;
+    await fetchData(page + 1, true);
+  }, [fetchData, page, loadingMore, hasMore]);
+  const refresh = (0, import_react12.useCallback)(async () => {
+    await fetchData(defaultPage, false);
+  }, [fetchData, defaultPage]);
+  const reset = (0, import_react12.useCallback)(() => {
+    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
+var import_react_native = require("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
+var import_jsx_runtime2 = require("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__ */ (0, import_jsx_runtime2.jsx)(
+    import_react_native.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
+var import_react_native2 = require("react-native");
+var import_jsx_runtime3 = require("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__ */ (0, import_jsx_runtime3.jsx)(
+    import_react_native2.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
+var import_react_native3 = require("react-native");
+var import_jsx_runtime4 = require("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__ */ (0, import_jsx_runtime4.jsx)(
+    import_react_native3.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
+var React2 = __toESM(require("react"));
+var import_react_native4 = require("react-native");
+var import_jsx_runtime5 = require("nativewind/jsx-runtime");
+function AppPressable({
+  className,
+  pressedClassName,
+  children,
+  ...props
+}) {
+  const [isPressed, setIsPressed] = React2.useState(false);
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+    import_react_native4.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
+var import_jsx_runtime6 = require("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__ */ (0, import_jsx_runtime6.jsx)(AppView, { row: true, className: cn(justifyMap[justify], itemsMap[items], className), ...props });
+}
+
+// src/ui/layout/Col.tsx
+var import_jsx_runtime7 = require("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__ */ (0, import_jsx_runtime7.jsx)(AppView, { className: cn(justifyMap2[justify], itemsMap2[items], className), ...props });
+}
+
+// src/ui/layout/Center.tsx
+var import_jsx_runtime8 = require("nativewind/jsx-runtime");
+function Center({ flex = true, ...props }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(AppView, { center: true, flex, ...props });
+}
+
+// src/ui/layout/SafeScreen.tsx
+var import_react_native5 = require("react-native");
+var import_react_native_safe_area_context = require("react-native-safe-area-context");
+var import_jsx_runtime9 = require("nativewind/jsx-runtime");
+function SafeScreen({
+  top = true,
+  bottom = true,
+  left = false,
+  right = false,
+  bg,
+  flex = true,
+  className,
+  children,
+  style,
+  ...props
+}) {
+  const insets = (0, import_react_native_safe_area_context.useSafeAreaInsets)();
+  const { theme, isDark } = useOptionalTheme();
+  const resolvedBgColor = resolveNamedColor(bg, theme, isDark);
+  const shouldUseClassBg = !!bg && !resolvedBgColor;
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+    import_react_native5.View,
+    {
+      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 = import_react_native5.StyleSheet.create({
+  flex: {
+    flex: 1
+  }
+});
+function Page({
+  children,
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(SafeScreen, { flex: true, bg: "background", ...props, className, children });
+}
+function SafeBottom({
+  children,
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(SafeScreen, { bottom: true, left: true, right: true, flex: false, ...props, className, children });
+}
+
+// src/ui/actions/AppButton.tsx
+var import_react_native6 = require("react-native");
+var import_jsx_runtime10 = require("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__ */ (0, import_jsx_runtime10.jsx)(
+    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__ */ (0, import_jsx_runtime10.jsx)(import_react_native6.ActivityIndicator, { size: "small", color: loadingColor }) : /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(AppText, { weight: "semibold", style: { color: textColor }, children })
+    }
+  );
+}
+
+// src/ui/feedback/Toast.tsx
+var import_jsx_runtime11 = require("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__ */ (0, import_jsx_runtime11.jsx)(AppView, { className: cn("px-4 py-3 rounded-lg", typeStyles[type]), children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(AppText, { color: "white", children: message }) });
+}
+
+// src/ui/feedback/Alert.tsx
+var import_react13 = require("react");
+var import_react_native7 = require("react-native");
+var import_jsx_runtime12 = require("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 = (0, import_react13.useCallback)(
+    (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__ */ (0, import_jsx_runtime12.jsx)(
+    import_react_native7.Modal,
+    {
+      visible,
+      transparent: true,
+      animationType: "fade",
+      onRequestClose: onClose,
+      statusBarTranslucent: true,
+      children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(AppView, { className: "flex-1", style: { backgroundColor: "rgba(0,0,0,0.5)" }, center: true, children: /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
+        AppView,
+        {
+          className: "rounded-xl mx-8 min-w-[280px]",
+          style: { backgroundColor: modalBgColor },
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(AppView, { className: "px-6 py-5", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+                AppText,
+                {
+                  size: "lg",
+                  weight: "semibold",
+                  className: "text-center mb-2",
+                  style: { color: textColor },
+                  children: title
+                }
+              ),
+              message && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(AppText, { size: "sm", style: { color: messageColor }, className: "text-center leading-5", children: message })
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(AppView, { className: "border-t", style: { borderTopColor: borderColor }, children: buttons.length === 1 ? (
+              // 单个按钮
+              /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+                import_react_native7.TouchableOpacity,
+                {
+                  onPress: handleButtonPress(buttons[0]),
+                  className: "py-3 rounded-b-xl",
+                  style: [styles2.singleButton, getButtonStyle(buttons[0])],
+                  children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+                    AppText,
+                    {
+                      weight: "medium",
+                      className: "text-center",
+                      style: { color: getButtonTextColor(buttons[0]) },
+                      children: buttons[0].text
+                    }
+                  )
+                }
+              )
+            ) : buttons.length === 2 ? (
+              // 两个按钮横向排列
+              /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(AppView, { row: true, style: styles2.twoButtonContainer, children: buttons.map((button, index) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+                import_react_native7.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__ */ (0, import_jsx_runtime12.jsx)(
+                    AppText,
+                    {
+                      weight: "medium",
+                      className: "text-center",
+                      style: { color: getButtonTextColor(button) },
+                      children: button.text
+                    }
+                  )
+                },
+                index
+              )) })
+            ) : (
+              // 多个按钮纵向排列
+              /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(AppView, { className: "gap-2 pb-4 px-4", children: buttons.map((button, index) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+                import_react_native7.TouchableOpacity,
+                {
+                  onPress: handleButtonPress(button),
+                  className: "py-3 rounded-lg",
+                  style: getButtonStyle(button),
+                  children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+                    AppText,
+                    {
+                      weight: "medium",
+                      className: "text-center",
+                      style: { color: getButtonTextColor(button) },
+                      children: button.text
+                    }
+                  )
+                },
+                index
+              )) })
+            ) })
+          ]
+        }
+      ) })
+    }
+  );
+}
+var styles2 = import_react_native7.StyleSheet.create({
+  singleButton: {
+    borderBottomLeftRadius: 12,
+    borderBottomRightRadius: 12
+  },
+  twoButtonContainer: {
+    borderBottomLeftRadius: 12,
+    borderBottomRightRadius: 12
+  },
+  twoButton: {
+    borderLeftWidth: 0.5
+  }
+});
+
+// src/ui/feedback/Loading.tsx
+var import_react_native8 = require("react-native");
+var import_jsx_runtime13 = require("nativewind/jsx-runtime");
+function Loading({
+  text,
+  color,
+  overlay = false,
+  visible = true,
+  testID
+}) {
+  if (!visible) return null;
+  const content = /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(AppView, { center: true, gap: 3, testID, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_react_native8.ActivityIndicator, { size: "large", color }),
+    text && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(AppText, { style: color ? { color } : void 0, children: text })
+  ] });
+  if (overlay) {
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(AppView, { center: true, flex: true, className: "absolute inset-0 bg-black/30", testID, children: content });
+  }
+  return content;
+}
+
+// src/ui/display/Progress.tsx
+var import_jsx_runtime14 = require("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__ */ (0, import_jsx_runtime14.jsx)(
+    AppView,
+    {
+      className: cn("w-full rounded-full", sizeMap[size], className),
+      style: { backgroundColor: trackBgColor },
+      testID,
+      children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+        AppView,
+        {
+          className: cn("rounded-full", sizeMap[size], colorMap[color], barClassName),
+          style: { width: `${percentage}%` }
+        }
+      )
+    }
+  );
+}
+
+// src/ui/display/Card.tsx
+var import_react_native9 = require("react-native");
+var import_jsx_runtime15 = require("nativewind/jsx-runtime");
+function Card({
+  children,
+  className,
+  style,
+  noShadow = false,
+  noBorder = false,
+  noRadius = false,
+  ...props
+}) {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+    import_react_native9.View,
+    {
+      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
+var import_MaterialIcons = __toESM(require("react-native-vector-icons/MaterialIcons"));
+var import_jsx_runtime16 = require("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__ */ (0, import_jsx_runtime16.jsx)(AppPressable, { onPress, testID, children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_MaterialIcons.default, { name, size: resolvedSize, color: resolvedColor, style }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+    import_MaterialIcons.default,
+    {
+      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
+var import_react14 = require("react");
+var import_react_native10 = require("react-native");
+var import_jsx_runtime17 = require("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__ */ (0, import_jsx_runtime17.jsx)(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] = (0, import_react14.useState)(true);
+  const [hasError, setHasError] = (0, import_react14.useState)(false);
+  const { theme } = useTheme();
+  const resolvedRadius = resolveRadius(borderRadius);
+  const handleLoad = (0, import_react14.useCallback)(() => {
+    setIsLoading(false);
+    onLoad?.();
+  }, [onLoad]);
+  const handleError = (0, import_react14.useCallback)(
+    (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__ */ (0, import_jsx_runtime17.jsx)(
+        import_react_native10.Image,
+        {
+          source: placeholder,
+          style: {
+            position: "absolute",
+            width: "100%",
+            height: "100%",
+            borderRadius: resolvedRadius
+          },
+          resizeMode
+        }
+      );
+    }
+    if (loadingIndicator) {
+      if (typeof loadingIndicator === "boolean") {
+        return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+          AppView,
+          {
+            center: true,
+            className: "absolute inset-0 bg-gray-100",
+            style: { borderRadius: resolvedRadius },
+            children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_react_native10.ActivityIndicator, { color: theme.colors.primary?.[500] })
+          }
+        );
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(AppView, { center: true, className: "absolute inset-0", style: { borderRadius: resolvedRadius }, children: loadingIndicator });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(SkeletonItem, {});
+  };
+  const renderError = () => {
+    if (!hasError) return null;
+    if (errorPlaceholder) {
+      return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        import_react_native10.Image,
+        {
+          source: errorPlaceholder,
+          style: {
+            position: "absolute",
+            width: "100%",
+            height: "100%",
+            borderRadius: resolvedRadius
+          },
+          resizeMode
+        }
+      );
+    }
+    if (showError) {
+      return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        AppView,
+        {
+          center: true,
+          className: "absolute inset-0 bg-gray-100",
+          style: { borderRadius: resolvedRadius },
+          children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Icon, { name: "error", size: "lg", color: "error-500" })
+        }
+      );
+    }
+    return null;
+  };
+  const isNumberWidth = typeof width === "number";
+  const isNumberHeight = typeof height === "number";
+  const content = /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(
+    import_react_native10.View,
+    {
+      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__ */ (0, import_jsx_runtime17.jsx)(
+          import_react_native10.Image,
+          {
+            source,
+            style: imageStyle,
+            resizeMode,
+            onLoad: handleLoad,
+            onError: handleError
+          }
+        ),
+        renderError()
+      ]
+    }
+  );
+  if (onPress || onLongPress) {
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(AppPressable, { onPress, onLongPress, children: content });
+  }
+  return content;
+}
+
+// src/ui/display/AppList.tsx
+var import_react15 = require("react");
+var import_react_native11 = require("react-native");
+var import_jsx_runtime18 = require("nativewind/jsx-runtime");
+function SkeletonItem2({ render }) {
+  const colors = useThemeColors();
+  if (render) {
+    return render();
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(AppView, { p: 4, gap: 3, testID: "skeleton", children: /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(AppView, { row: true, gap: 3, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(AppView, { className: "w-16 h-16 rounded-lg", style: { backgroundColor: colors.divider } }),
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(AppView, { flex: true, gap: 2, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(AppView, { className: "h-4 w-3/4 rounded", style: { backgroundColor: colors.divider } }),
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(AppView, { className: "h-3 w-1/2 rounded", style: { backgroundColor: colors.divider } })
+    ] })
+  ] }) });
+}
+function EmptyState({
+  title,
+  description,
+  icon
+}) {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(Center, { py: 20, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(Icon, { name: icon || "inbox", size: 64, color: colors.textMuted }),
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(AppText, { size: "lg", weight: "medium", className: "mt-4", style: { color: colors.text }, children: title || "\u6682\u65E0\u6570\u636E" }),
+    description && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(AppText, { size: "sm", className: "mt-2", style: { color: colors.textMuted }, children: description })
+  ] });
+}
+function ErrorState({ error, onRetry }) {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(Center, { py: 20, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(Icon, { name: "error-outline", size: 64, color: "error-300" }),
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(AppText, { size: "lg", weight: "medium", color: "error-500", className: "mt-4", children: "\u52A0\u8F7D\u5931\u8D25" }),
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(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__ */ (0, import_jsx_runtime18.jsx)(
+      AppPressable,
+      {
+        onPress: onRetry,
+        className: "mt-6 px-4 py-2 rounded-lg",
+        style: [
+          styles3.retryButton,
+          { backgroundColor: colors.cardElevated, borderColor: colors.border }
+        ],
+        children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(AppText, { style: { color: colors.textSecondary }, className: "text-center", children: "\u91CD\u65B0\u52A0\u8F7D" })
+      }
+    )
+  ] });
+}
+function LoadMoreFooter({ loading }) {
+  if (!loading) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(Center, { py: 4, children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_react_native11.ActivityIndicator, { size: "small" }) });
+}
+function Divider({ style }) {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+    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] = (0, import_react15.useState)(false);
+  const handleEndReached = (0, import_react15.useCallback)(async () => {
+    if (isLoadingMore || !hasMore || !onEndReached) return;
+    setIsLoadingMore(true);
+    try {
+      await onEndReached();
+    } finally {
+      setIsLoadingMore(false);
+    }
+  }, [isLoadingMore, hasMore, onEndReached]);
+  const defaultKeyExtractor = (0, import_react15.useCallback)(
+    (item, index) => {
+      if (keyExtractor) return keyExtractor(item, index);
+      return `item-${index}`;
+    },
+    [keyExtractor]
+  );
+  const wrappedRenderItem = (0, import_react15.useCallback)(
+    (info) => {
+      return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(import_jsx_runtime18.Fragment, { children: [
+        divider && info.index > 0 && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(Divider, { style: dividerStyle }),
+        renderItem(info)
+      ] });
+    },
+    [renderItem, divider, dividerStyle]
+  );
+  const skeletonData = (0, import_react15.useMemo)(
+    () => new Array(skeletonCount).fill(null).map((_, i) => ({ _skeletonId: i })),
+    [skeletonCount]
+  );
+  const skeletonRenderItem = (0, import_react15.useCallback)(
+    () => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(SkeletonItem2, { render: skeletonRender }),
+    [skeletonRender]
+  );
+  if (loading && data.length === 0) {
+    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+      import_react_native11.FlatList,
+      {
+        data: skeletonData,
+        renderItem: skeletonRenderItem,
+        keyExtractor: (_, index) => `skeleton-${index}`,
+        contentContainerStyle,
+        style,
+        showsVerticalScrollIndicator,
+        showsHorizontalScrollIndicator
+      }
+    );
+  }
+  if (error && data.length === 0) {
+    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(Center, { style, children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(ErrorState, { error, onRetry }) });
+  }
+  const ListEmptyComponent = (0, import_react15.useMemo)(() => {
+    if (EmptyComponent) return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(EmptyComponent, {});
+    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(EmptyState, { title: emptyTitle, description: emptyDescription, icon: emptyIcon });
+  }, [EmptyComponent, emptyTitle, emptyDescription, emptyIcon]);
+  const FooterComponent = (0, import_react15.useMemo)(() => {
+    return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(import_jsx_runtime18.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(LoadMoreFooter, { loading: isLoadingMore }),
+      ListFooterComponent
+    ] });
+  }, [isLoadingMore, ListFooterComponent]);
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+    import_react_native11.FlatList,
+    {
+      data,
+      renderItem: wrappedRenderItem,
+      keyExtractor: defaultKeyExtractor,
+      refreshControl: onRefresh ? /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+        import_react_native11.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 = import_react_native11.StyleSheet.create({
+  retryButton: {
+    borderWidth: 0.5
+  }
+});
+
+// src/ui/form/AppInput.tsx
+var import_react16 = require("react");
+var import_react_native12 = require("react-native");
+var import_jsx_runtime19 = require("nativewind/jsx-runtime");
+var AppInput = (0, import_react16.forwardRef)(
+  ({ label, error, disabled = false, leftIcon, rightIcon, className, style, ...props }, ref) => {
+    const colors = useThemeColors();
+    const [isFocused, setIsFocused] = (0, import_react16.useState)(false);
+    const errorColor = "#ef4444";
+    const getBorderColor = () => {
+      if (error) return errorColor;
+      if (isFocused) return colors.primary;
+      return colors.border;
+    };
+    return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(AppView, { className: cn("flex-col gap-1", className), children: [
+      label && /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(AppText, { size: "sm", weight: "medium", style: { color: colors.textSecondary }, children: label }),
+      /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(
+        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__ */ (0, import_jsx_runtime19.jsx)(import_react_native12.View, { style: styles4.icon, children: leftIcon }),
+            /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+              import_react_native12.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__ */ (0, import_jsx_runtime19.jsx)(import_react_native12.View, { style: styles4.icon, children: rightIcon })
+          ]
+        }
+      ),
+      error && /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(AppText, { size: "xs", style: { color: errorColor }, children: error })
+    ] });
+  }
+);
+AppInput.displayName = "AppInput";
+var styles4 = import_react_native12.StyleSheet.create({
+  inputContainer: {
+    borderWidth: 0.5,
+    minHeight: 48
+  },
+  input: {
+    padding: 0,
+    margin: 0
+  },
+  icon: {
+    marginHorizontal: 4
+  }
+});
+
+// src/ui/form/Checkbox.tsx
+var import_react17 = require("react");
+var import_react_native13 = require("react-native");
+var import_jsx_runtime20 = require("nativewind/jsx-runtime");
+function Checkbox({
+  checked,
+  defaultChecked,
+  onChange,
+  disabled = false,
+  children,
+  className,
+  testID
+}) {
+  const colors = useThemeColors();
+  const [internalChecked, setInternalChecked] = (0, import_react17.useState)(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__ */ (0, import_jsx_runtime20.jsxs)(
+    import_react_native13.TouchableOpacity,
+    {
+      onPress: toggle,
+      disabled,
+      className: cn("flex-row items-center gap-2", className),
+      style: disabled ? { opacity: disabledOpacity } : void 0,
+      testID,
+      activeOpacity: 0.7,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+          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__ */ (0, import_jsx_runtime20.jsx)(AppView, { testID: `${testID}-icon`, children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Icon, { name: "check", size: "sm", color: "white" }) })
+          }
+        ),
+        children && /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(AppText, { size: "sm", style: { color: colors.text }, children })
+      ]
+    }
+  );
+}
+var styles5 = import_react_native13.StyleSheet.create({
+  checkbox: {
+    borderWidth: 0.5
+  }
+});
+
+// src/ui/form/CheckboxGroup.tsx
+var import_jsx_runtime21 = require("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__ */ (0, import_jsx_runtime21.jsx)(AppView, { row: direction === "row", flex: direction === "row", gap: 4, children: options.map((option) => /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+    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
+var import_react18 = require("react");
+var import_react_native14 = require("react-native");
+var import_jsx_runtime22 = require("nativewind/jsx-runtime");
+function Radio({
+  checked,
+  defaultChecked,
+  onChange,
+  disabled = false,
+  children,
+  className,
+  testID
+}) {
+  const colors = useThemeColors();
+  const [internalChecked, setInternalChecked] = (0, import_react18.useState)(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__ */ (0, import_jsx_runtime22.jsxs)(
+    import_react_native14.TouchableOpacity,
+    {
+      onPress: toggle,
+      disabled,
+      className: cn("flex-row items-center gap-2", className),
+      style: disabled ? { opacity: disabledOpacity } : void 0,
+      testID,
+      activeOpacity: 0.7,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+          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__ */ (0, import_jsx_runtime22.jsx)(
+              AppView,
+              {
+                className: "rounded-full",
+                style: [styles6.inner, { backgroundColor: colors.primary }]
+              }
+            )
+          }
+        ),
+        children && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(AppText, { size: "sm", style: { color: colors.text }, children })
+      ]
+    }
+  );
+}
+var styles6 = import_react_native14.StyleSheet.create({
+  radio: {
+    borderWidth: 0.5
+  },
+  inner: {
+    width: 10,
+    height: 10
+  }
+});
+
+// src/ui/form/RadioGroup.tsx
+var import_jsx_runtime23 = require("nativewind/jsx-runtime");
+function RadioGroup({
+  value,
+  onChange,
+  options = [],
+  direction = "column",
+  disabled = false
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(AppView, { row: direction === "row", flex: direction === "row", gap: 4, children: options.map((option) => /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
+    Radio,
+    {
+      checked: value === option.value,
+      onChange: () => onChange?.(option.value),
+      disabled: disabled || option.disabled,
+      children: option.label
+    },
+    option.value
+  )) });
+}
+
+// src/ui/form/Switch.tsx
+var import_react19 = require("react");
+var import_react_native15 = require("react-native");
+var import_jsx_runtime24 = require("nativewind/jsx-runtime");
+function Switch({
+  checked,
+  defaultChecked,
+  onChange,
+  disabled = false,
+  size = "md",
+  className,
+  testID,
+  style
+}) {
+  const colors = useThemeColors();
+  const [internalChecked, setInternalChecked] = (0, import_react19.useState)(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__ */ (0, import_jsx_runtime24.jsx)(
+    import_react_native15.TouchableOpacity,
+    {
+      onPress: toggle,
+      disabled,
+      className: cn(className),
+      testID,
+      activeOpacity: disabled ? 1 : 0.8,
+      children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
+        AppView,
+        {
+          className: "rounded-full",
+          style: [
+            styles7.track,
+            {
+              width: config.width,
+              height: config.height,
+              backgroundColor: isChecked ? checkedTrackColor : uncheckedTrackColor,
+              opacity: disabled ? disabledOpacity : 1
+            },
+            style
+          ],
+          children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
+            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 = import_react_native15.StyleSheet.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
+var import_react21 = require("react");
+var import_react_native16 = require("react-native");
+
+// src/ui/form/useFormTheme.ts
+var import_react20 = require("react");
+function useFormThemeColors() {
+  const { isDark } = useOptionalTheme();
+  const colors = useThemeColors();
+  return (0, import_react20.useMemo)(
+    () => ({
+      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
+var import_jsx_runtime25 = require("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] = (0, import_react21.useState)(defaultValue);
+  const [trackWidth, setTrackWidth] = (0, import_react21.useState)(0);
+  const [isDragging, setIsDragging] = (0, import_react21.useState)(false);
+  const currentValue = value !== void 0 ? value : internalValue;
+  const disabledOpacity = 0.4;
+  const progress = (currentValue - min) / (max - min) * 100;
+  const getValueFromPosition = (0, import_react21.useCallback)(
+    (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 = (0, import_react21.useCallback)(
+    (newValue) => {
+      const clampedValue = Math.min(max, Math.max(min, newValue));
+      if (value === void 0) {
+        setInternalValue(clampedValue);
+      }
+      onChange?.(clampedValue);
+    },
+    [value, min, max, onChange]
+  );
+  const panResponder = (0, import_react21.useRef)(
+    import_react_native16.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 = (0, import_react21.useCallback)(
+    (event) => {
+      if (disabled) return;
+      const { locationX } = event.nativeEvent;
+      const newValue = getValueFromPosition(locationX);
+      setValue(newValue);
+      onChangeEnd?.(newValue);
+    },
+    [disabled, getValueFromPosition, setValue, onChangeEnd]
+  );
+  const onLayout = (0, import_react21.useCallback)((event) => {
+    setTrackWidth(event.nativeEvent.layout.width);
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(AppView, { className: cn("py-2", className), children: [
+    showTooltip && isDragging && /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(
+      AppView,
+      {
+        className: "absolute rounded px-2 py-1 -top-8",
+        style: [
+          styles8.tooltip,
+          {
+            backgroundColor: colors.surfaceMuted,
+            left: `${progress}%`,
+            transform: [{ translateX: -16 }]
+          }
+        ],
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(AppText, { size: "xs", style: { color: colors.text }, children: Math.round(currentValue) }),
+          /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+            AppView,
+            {
+              style: [
+                styles8.tooltipArrow,
+                {
+                  borderTopColor: colors.surfaceMuted
+                }
+              ]
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(
+      import_react_native16.View,
+      {
+        onLayout,
+        className: "rounded-full",
+        style: [
+          styles8.track,
+          { backgroundColor: colors.divider, opacity: disabled ? disabledOpacity : 1 }
+        ],
+        onTouchEnd: handleTrackPress,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+            AppView,
+            {
+              className: "rounded-full",
+              style: [
+                styles8.filledTrack,
+                {
+                  backgroundColor: colors.primary,
+                  width: `${progress}%`
+                }
+              ]
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+            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__ */ (0, import_jsx_runtime25.jsx)(
+                AppView,
+                {
+                  className: "rounded-full",
+                  style: [
+                    styles8.thumbDot,
+                    {
+                      backgroundColor: colors.primary
+                    }
+                  ]
+                }
+              )
+            }
+          )
+        ]
+      }
+    )
+  ] });
+}
+var styles8 = import_react_native16.StyleSheet.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
+var import_react22 = require("react");
+var import_react_native17 = require("react-native");
+var import_jsx_runtime26 = require("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] = (0, import_react22.useState)(false);
+  const [searchKeyword, setSearchKeyword] = (0, import_react22.useState)("");
+  const selectedValues = (0, import_react22.useMemo)(() => {
+    if (multiple) {
+      return Array.isArray(value) ? value : [];
+    }
+    return value ? [value] : [];
+  }, [value, multiple]);
+  const displayText = (0, import_react22.useMemo)(() => {
+    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 = (0, import_react22.useMemo)(() => {
+    if (!searchable || !searchKeyword) return options;
+    return options.filter((opt) => opt.label.toLowerCase().includes(searchKeyword.toLowerCase()));
+  }, [options, searchable, searchKeyword]);
+  const handleSelect = (0, import_react22.useCallback)(
+    (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 = (0, import_react22.useCallback)(
+    (e) => {
+      e.stopPropagation();
+      onChange?.(multiple ? [] : "");
+    },
+    [multiple, onChange]
+  );
+  const handleSearch = (0, import_react22.useCallback)(
+    (text) => {
+      setSearchKeyword(text);
+      onSearch?.(text);
+    },
+    [onSearch]
+  );
+  const renderOption = (0, import_react22.useCallback)(
+    ({ item }) => {
+      const isSelected = selectedValues.includes(item.value);
+      return /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(
+        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__ */ (0, import_jsx_runtime26.jsx)(AppText, { style: { color: isSelected ? colors.primary : colors.text }, children: item.label }),
+            isSelected && /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(Icon, { name: "check", size: "sm", color: "primary-500" })
+          ]
+        }
+      );
+    },
+    [selectedValues, handleSelect, colors]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(import_jsx_runtime26.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(
+      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__ */ (0, import_jsx_runtime26.jsx)(
+            AppText,
+            {
+              className: "flex-1",
+              style: { color: selectedValues.length === 0 ? colors.textMuted : colors.text },
+              numberOfLines: 1,
+              children: displayText
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(import_react_native17.View, { className: "flex-row items-center", children: [
+            clearable && selectedValues.length > 0 && !disabled && /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(import_react_native17.TouchableOpacity, { onPress: handleClear, className: "mr-2 p-1", children: /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(Icon, { name: "close", size: "sm", color: colors.icon }) }),
+            /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(Icon, { name: "keyboard-arrow-down", size: "md", color: colors.icon })
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
+      import_react_native17.Modal,
+      {
+        visible,
+        transparent: true,
+        animationType: "slide",
+        onRequestClose: () => setVisible(false),
+        children: /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(AppView, { className: "flex-1", style: { backgroundColor: colors.overlay }, justify: "end", children: /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(
+          AppView,
+          {
+            className: "rounded-t-2xl max-h-[70%]",
+            style: { backgroundColor: colors.surface },
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(
+                AppView,
+                {
+                  row: true,
+                  between: true,
+                  items: "center",
+                  className: "px-4 py-3",
+                  style: [styles9.header, { borderBottomColor: colors.divider }],
+                  children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(AppText, { className: "text-lg font-semibold", style: { color: colors.text }, children: multiple ? "\u9009\u62E9\u9009\u9879" : "\u8BF7\u9009\u62E9" }),
+                    /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(import_react_native17.TouchableOpacity, { onPress: () => setVisible(false), children: /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(Icon, { name: "close", size: "md", color: colors.icon }) })
+                  ]
+                }
+              ),
+              searchable && /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
+                AppView,
+                {
+                  className: "px-4 py-3",
+                  style: [styles9.searchBox, { borderBottomColor: colors.divider }],
+                  children: /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(
+                    AppView,
+                    {
+                      row: true,
+                      items: "center",
+                      className: "px-3 py-2 rounded-lg",
+                      style: { backgroundColor: colors.surfaceMuted },
+                      children: [
+                        /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(import_react_native17.View, { style: { marginRight: 8 }, children: /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(Icon, { name: "search", size: "sm", color: colors.icon }) }),
+                        /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
+                          import_react_native17.TextInput,
+                          {
+                            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__ */ (0, import_jsx_runtime26.jsx)(import_react_native17.TouchableOpacity, { onPress: () => setSearchKeyword(""), children: /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(Icon, { name: "close", size: "sm", color: colors.icon }) })
+                      ]
+                    }
+                  )
+                }
+              ),
+              /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
+                import_react_native17.FlatList,
+                {
+                  data: filteredOptions,
+                  keyExtractor: (item) => item.value,
+                  renderItem: renderOption,
+                  ListEmptyComponent: /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(AppView, { center: true, className: "py-8", children: /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(AppText, { style: { color: colors.textMuted }, children: "\u6682\u65E0\u9009\u9879" }) })
+                }
+              ),
+              multiple && /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(
+                AppView,
+                {
+                  row: true,
+                  between: true,
+                  items: "center",
+                  className: "px-4 py-3",
+                  style: [styles9.footer, { borderTopColor: colors.divider }],
+                  children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(AppText, { style: { color: colors.textMuted }, children: [
+                      "\u5DF2\u9009\u62E9 ",
+                      selectedValues.length,
+                      " \u9879"
+                    ] }),
+                    /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
+                      import_react_native17.TouchableOpacity,
+                      {
+                        className: "px-4 py-2 rounded-lg",
+                        style: { backgroundColor: colors.primary },
+                        onPress: () => setVisible(false),
+                        children: /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(AppText, { className: "font-medium", style: { color: colors.textInverse }, children: "\u786E\u5B9A" })
+                      }
+                    )
+                  ]
+                }
+              )
+            ]
+          }
+        ) })
+      }
+    )
+  ] });
+}
+var styles9 = import_react_native17.StyleSheet.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
+var import_react23 = require("react");
+var import_react_native18 = require("react-native");
+var import_jsx_runtime27 = require("nativewind/jsx-runtime");
+function PickerColumn({
+  title,
+  values,
+  selectedValue,
+  onSelect,
+  isDisabled,
+  formatLabel = (value) => String(value),
+  showDivider = false,
+  colors
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)(
+    AppView,
+    {
+      flex: true,
+      style: [
+        showDivider && styles10.column,
+        showDivider ? { borderRightColor: colors.divider } : void 0
+      ],
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(AppView, { center: true, className: "py-2", style: { backgroundColor: colors.headerSurface }, children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(AppText, { className: "text-sm font-medium", style: { color: colors.textMuted }, children: title }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(AppView, { className: "flex-1", children: values.map((value) => {
+          const selected = selectedValue === value;
+          const disabled = isDisabled(value);
+          return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
+            import_react_native18.TouchableOpacity,
+            {
+              className: cn("py-2 items-center", selected && "bg-primary-50"),
+              style: selected ? { backgroundColor: colors.primarySurface } : void 0,
+              disabled,
+              onPress: () => onSelect(value),
+              children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
+                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] = (0, import_react23.useState)(false);
+  const [tempDate, setTempDate] = (0, import_react23.useState)(value || /* @__PURE__ */ new Date());
+  const displayText = (0, import_react23.useMemo)(() => {
+    return value ? formatDate(value, format) : placeholder;
+  }, [value, format, placeholder]);
+  const handleConfirm = (0, import_react23.useCallback)(() => {
+    onChange?.(tempDate);
+    setVisible(false);
+  }, [tempDate, onChange]);
+  const years = (0, import_react23.useMemo)(() => {
+    const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+    const arr = [];
+    for (let i = currentYear - 50; i <= currentYear + 50; i++) {
+      arr.push(i);
+    }
+    return arr;
+  }, []);
+  const months = (0, import_react23.useMemo)(() => {
+    return Array.from({ length: 12 }, (_, i) => i + 1);
+  }, []);
+  const days = (0, import_react23.useMemo)(() => {
+    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 = (0, import_react23.useCallback)(
+    (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 = (0, import_react23.useCallback)(
+    (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__ */ (0, import_jsx_runtime27.jsxs)(import_jsx_runtime27.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)(
+      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__ */ (0, import_jsx_runtime27.jsx)(
+            AppText,
+            {
+              className: "flex-1",
+              style: { color: value ? colors.text : colors.textMuted },
+              numberOfLines: 1,
+              children: displayText
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(Icon, { name: "calendar-today", size: "md", color: colors.icon })
+        ]
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
+      import_react_native18.Modal,
+      {
+        visible,
+        transparent: true,
+        animationType: "slide",
+        onRequestClose: () => setVisible(false),
+        children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(AppView, { className: "flex-1", style: { backgroundColor: colors.overlay }, justify: "end", children: /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)(AppView, { className: "rounded-t-2xl", style: { backgroundColor: colors.surface }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)(
+            AppView,
+            {
+              row: true,
+              between: true,
+              items: "center",
+              className: "px-4 py-3",
+              style: [styles10.header, { borderBottomColor: colors.divider }],
+              children: [
+                /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_react_native18.TouchableOpacity, { onPress: () => setVisible(false), children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(AppText, { style: { color: colors.textMuted }, children: "\u53D6\u6D88" }) }),
+                /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(AppText, { className: "text-lg font-semibold", style: { color: colors.text }, children: "\u9009\u62E9\u65E5\u671F" }),
+                /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_react_native18.TouchableOpacity, { onPress: handleConfirm, children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(AppText, { style: { color: colors.primary }, className: "font-medium", children: "\u786E\u5B9A" }) })
+              ]
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(AppView, { center: true, className: "py-4", style: { backgroundColor: colors.headerSurface }, children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(AppText, { className: "text-2xl font-semibold", style: { color: colors.text }, children: formatDate(tempDate, "yyyy\u5E74MM\u6708dd\u65E5") }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)(AppView, { row: true, className: "h-48", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
+              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__ */ (0, import_jsx_runtime27.jsx)(
+              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__ */ (0, import_jsx_runtime27.jsx)(
+              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__ */ (0, import_jsx_runtime27.jsxs)(
+            AppView,
+            {
+              row: true,
+              className: "px-4 py-3 gap-2",
+              style: [styles10.footer, { borderTopColor: colors.divider }],
+              children: [
+                /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
+                  import_react_native18.TouchableOpacity,
+                  {
+                    className: "flex-1 py-2 items-center rounded-lg",
+                    style: { backgroundColor: colors.surfaceMuted },
+                    onPress: () => setTempDate(/* @__PURE__ */ new Date()),
+                    children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(AppText, { style: { color: colors.text }, children: "\u4ECA\u5929" })
+                  }
+                ),
+                minDate && /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
+                  import_react_native18.TouchableOpacity,
+                  {
+                    className: "flex-1 py-2 items-center rounded-lg",
+                    style: { backgroundColor: colors.surfaceMuted },
+                    onPress: () => setTempDate(minDate),
+                    children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(AppText, { style: { color: colors.text }, children: "\u6700\u65E9" })
+                  }
+                ),
+                maxDate && /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
+                  import_react_native18.TouchableOpacity,
+                  {
+                    className: "flex-1 py-2 items-center rounded-lg",
+                    style: { backgroundColor: colors.surfaceMuted },
+                    onPress: () => setTempDate(maxDate),
+                    children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(AppText, { style: { color: colors.text }, children: "\u6700\u665A" })
+                  }
+                )
+              ]
+            }
+          )
+        ] }) })
+      }
+    )
+  ] });
+}
+var styles10 = import_react_native18.StyleSheet.create({
+  trigger: {
+    borderWidth: 0.5
+  },
+  header: {
+    borderBottomWidth: 0.5
+  },
+  column: {
+    borderRightWidth: 0.5
+  },
+  footer: {
+    borderTopWidth: 0.5
+  }
+});
+
+// src/ui/form/FormItem.tsx
+var import_jsx_runtime28 = require("nativewind/jsx-runtime");
+function FormItem({
+  name: _name,
+  label,
+  error,
+  help,
+  required,
+  children,
+  className,
+  labelClassName
+}) {
+  const colors = useThemeColors();
+  return /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)(AppView, { className: cn("mb-4", className), children: [
+    label && /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)(AppView, { row: true, items: "center", gap: 1, className: cn("mb-2", labelClassName), children: [
+      /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(AppText, { size: "sm", weight: "medium", style: { color: colors.textSecondary }, children: label }),
+      required && /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(AppText, { color: "error-500", children: "*" })
+    ] }),
+    children,
+    error && /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(AppText, { size: "sm", color: "error-500", className: "mt-1", children: error }),
+    help && !error && /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(AppText, { size: "sm", className: "mt-1", style: { color: colors.textMuted }, children: help })
+  ] });
+}
+
+// src/ui/form/useForm.ts
+var import_react24 = require("react");
+function useForm({
+  schema,
+  defaultValues
+}) {
+  const [values, setValues] = (0, import_react24.useState)(defaultValues);
+  const [errors, setErrors] = (0, import_react24.useState)({});
+  const [isSubmitting, setIsSubmitting] = (0, import_react24.useState)(false);
+  const isDirty = (0, import_react24.useMemo)(() => {
+    return JSON.stringify(values) !== JSON.stringify(defaultValues);
+  }, [values, defaultValues]);
+  const isValid = (0, import_react24.useMemo)(() => {
+    return Object.keys(errors).length === 0;
+  }, [errors]);
+  const setValue = (0, import_react24.useCallback)((name, value) => {
+    setValues((prev) => ({ ...prev, [name]: value }));
+    setErrors((prev) => {
+      const next = { ...prev };
+      delete next[name];
+      return next;
+    });
+  }, []);
+  const getValue = (0, import_react24.useCallback)(
+    (name) => {
+      return values[name];
+    },
+    [values]
+  );
+  const validateField = (0, import_react24.useCallback)(
+    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 = (0, import_react24.useCallback)(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 = (0, import_react24.useCallback)(() => {
+    setValues(defaultValues);
+    setErrors({});
+    setIsSubmitting(false);
+  }, [defaultValues]);
+  const handleSubmit = (0, import_react24.useCallback)(
+    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
+var import_react25 = require("react");
+function useToggle(defaultValue = false) {
+  const [value, setValue] = (0, import_react25.useState)(defaultValue);
+  const toggle = (0, import_react25.useCallback)(() => {
+    setValue((v) => !v);
+  }, []);
+  const set = (0, import_react25.useCallback)((newValue) => {
+    setValue(newValue);
+  }, []);
+  const setTrue = (0, import_react25.useCallback)(() => {
+    setValue(true);
+  }, []);
+  const setFalse = (0, import_react25.useCallback)(() => {
+    setValue(false);
+  }, []);
+  return [value, { toggle, set, setTrue, setFalse }];
+}
+
+// src/ui/hooks/useDebounce.ts
+var import_react26 = require("react");
+function useDebounce(value, delay = 500) {
+  const [debouncedValue, setDebouncedValue] = (0, import_react26.useState)(value);
+  (0, import_react26.useEffect)(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+
+// src/ui/hooks/useThrottle.ts
+var import_react27 = require("react");
+function useThrottle(value, delay = 200) {
+  const [throttledValue, setThrottledValue] = (0, import_react27.useState)(value);
+  const lastUpdatedRef = (0, import_react27.useRef)(Date.now());
+  (0, import_react27.useEffect)(() => {
+    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
+var import_react28 = require("react");
+var import_react_native19 = require("react-native");
+function useKeyboard() {
+  const [visible, setVisible] = (0, import_react28.useState)(false);
+  const [height, setHeight] = (0, import_react28.useState)(0);
+  (0, import_react28.useEffect)(() => {
+    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 = import_react_native19.Keyboard.addListener(
+      import_react_native19.Platform.OS === "ios" ? "keyboardWillShow" : "keyboardDidShow",
+      import_react_native19.Platform.OS === "ios" ? handleKeyboardWillShow : handleKeyboardDidShow
+    );
+    const willHideSub = import_react_native19.Keyboard.addListener(
+      import_react_native19.Platform.OS === "ios" ? "keyboardWillHide" : "keyboardDidHide",
+      import_react_native19.Platform.OS === "ios" ? handleKeyboardWillHide : handleKeyboardDidHide
+    );
+    return () => {
+      willShowSub.remove();
+      willHideSub.remove();
+    };
+  }, []);
+  const dismiss = (0, import_react28.useCallback)(() => {
+    import_react_native19.Keyboard.dismiss();
+  }, []);
+  return { visible, height, dismiss };
+}
+
+// src/ui/hooks/useDimensions.ts
+var import_react29 = require("react");
+var import_react_native20 = require("react-native");
+function useDimensions() {
+  const [dimensions, setDimensions] = (0, import_react29.useState)(() => {
+    const window = import_react_native20.Dimensions.get("window");
+    return {
+      width: window.width,
+      height: window.height,
+      scale: window.scale,
+      fontScale: window.fontScale
+    };
+  });
+  (0, import_react29.useEffect)(() => {
+    const handleChange = ({ window }) => {
+      setDimensions({
+        width: window.width,
+        height: window.height,
+        scale: window.scale,
+        fontScale: window.fontScale
+      });
+    };
+    const subscription = import_react_native20.Dimensions.addEventListener("change", handleChange);
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+  return dimensions;
+}
+
+// src/ui/hooks/useOrientation.ts
+var import_react30 = require("react");
+var import_react_native21 = require("react-native");
+function useOrientation() {
+  const getOrientation = () => {
+    const { width, height } = import_react_native21.Dimensions.get("window");
+    return width > height ? "landscape" : "portrait";
+  };
+  const [orientation, setOrientation] = (0, import_react30.useState)(getOrientation);
+  (0, import_react30.useEffect)(() => {
+    const handleChange = ({ window }) => {
+      const newOrientation = window.width > window.height ? "landscape" : "portrait";
+      setOrientation(newOrientation);
+    };
+    const subscription = import_react_native21.Dimensions.addEventListener("change", handleChange);
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+  return {
+    orientation,
+    isPortrait: orientation === "portrait",
+    isLandscape: orientation === "landscape"
+  };
+}
+
+// src/navigation/provider.tsx
+var import_react31 = __toESM(require("react"));
+var import_native = require("@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
+var import_jsx_runtime29 = require("nativewind/jsx-runtime");
+function NavigationProvider({
+  children,
+  linking,
+  fallback,
+  onReady,
+  onStateChange,
+  onUnhandledAction,
+  theme: customTheme
+}) {
+  const { theme, isDark } = useTheme();
+  const navigationTheme = import_react31.default.useMemo(
+    () => customTheme || createNavigationTheme(theme, isDark),
+    [customTheme, theme, isDark]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(
+    import_native.NavigationContainer,
+    {
+      theme: navigationTheme,
+      linking,
+      fallback,
+      onReady,
+      onStateChange,
+      onUnhandledAction,
+      children
+    }
+  );
+}
+
+// src/navigation/vendor/stack.ts
+var import_stack = require("@react-navigation/stack");
+
+// src/navigation/navigators/StackNavigator.tsx
+var import_jsx_runtime30 = require("nativewind/jsx-runtime");
+var NativeStack = (0, import_stack.createStackNavigator)();
+var defaultScreenOptions = {
+  headerShown: false,
+  ...import_stack.TransitionPresets.SlideFromRightIOS
+};
+function StackNavigator({ initialRouteName, screenOptions, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(
+    NativeStack.Navigator,
+    {
+      initialRouteName,
+      screenOptions: { ...defaultScreenOptions, ...screenOptions },
+      children
+    }
+  );
+}
+StackNavigator.Screen = NativeStack.Screen;
+StackNavigator.Group = NativeStack.Group;
+function createStackScreens(routes) {
+  return routes.map((route) => /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(
+    StackNavigator.Screen,
+    {
+      name: route.name,
+      component: route.component,
+      options: route.options,
+      initialParams: route.initialParams
+    },
+    route.name
+  ));
+}
+
+// src/navigation/navigators/TabNavigator.tsx
+var import_react32 = __toESM(require("react"));
+var import_bottom_tabs = require("@react-navigation/bottom-tabs");
+
+// src/navigation/components/BottomTabBar.tsx
+var import_react_native22 = require("react-native");
+var import_react_native_safe_area_context2 = require("react-native-safe-area-context");
+var import_jsx_runtime31 = require("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 = (0, import_react_native_safe_area_context2.useSafeAreaInsets)();
+  const activeColor = activeTintColor || colors.primary;
+  const inactiveColor = inactiveTintColor || colors.textMuted;
+  const backgroundColor = style?.backgroundColor || colors.card;
+  const borderTopColor = colors.divider;
+  return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+    import_react_native22.View,
+    {
+      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__ */ (0, import_jsx_runtime31.jsxs)(
+          import_react_native22.TouchableOpacity,
+          {
+            accessibilityRole: "button",
+            accessibilityState: isFocused ? { selected: true } : {},
+            accessibilityLabel: options.tabBarAccessibilityLabel,
+            testID: options.tabBarTestID,
+            onPress,
+            onLongPress,
+            style: [
+              styles11.tab,
+              {
+                backgroundColor: isFocused ? activeBackgroundColor : inactiveBackgroundColor
+              }
+            ],
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime31.jsxs)(import_react_native22.View, { style: [styles11.iconContainer, iconStyle], children: [
+                iconName,
+                badge != null && /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(import_react_native22.View, { style: [styles11.badge, { backgroundColor: activeColor }], children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(AppText, { style: styles11.badgeText, children: typeof badge === "number" && badge > 99 ? "99+" : badge }) })
+              ] }),
+              showLabel && /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+                AppText,
+                {
+                  style: [
+                    styles11.label,
+                    { color: isFocused ? activeColor : inactiveColor },
+                    labelStyle
+                  ],
+                  numberOfLines: 1,
+                  children: label
+                }
+              )
+            ]
+          },
+          route.key
+        );
+      })
+    }
+  );
+}
+var styles11 = import_react_native22.StyleSheet.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
+var import_jsx_runtime32 = require("nativewind/jsx-runtime");
+var NativeTab = (0, import_bottom_tabs.createBottomTabNavigator)();
+var defaultScreenOptions2 = {
+  headerShown: false,
+  tabBarShowLabel: true
+};
+function TabNavigator({
+  initialRouteName,
+  tabBarOptions,
+  tabBar,
+  screenOptions,
+  children
+}) {
+  const mergedScreenOptions = import_react32.default.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 = import_react32.default.useMemo(() => {
+    if (tabBar) return tabBar;
+    return (props) => /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(
+      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__ */ (0, import_jsx_runtime32.jsx)(
+    NativeTab.Navigator,
+    {
+      initialRouteName,
+      screenOptions: mergedScreenOptions,
+      tabBar: resolvedTabBar,
+      children
+    }
+  );
+}
+TabNavigator.Screen = NativeTab.Screen;
+function createTabScreens(routes) {
+  return routes.map((route) => /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(
+    TabNavigator.Screen,
+    {
+      name: route.name,
+      component: route.component,
+      options: route.options,
+      initialParams: route.initialParams
+    },
+    route.name
+  ));
+}
+
+// src/navigation/navigators/DrawerNavigator.tsx
+var import_react33 = __toESM(require("react"));
+var import_drawer = require("@react-navigation/drawer");
+var import_jsx_runtime33 = require("nativewind/jsx-runtime");
+var NativeDrawer = (0, import_drawer.createDrawerNavigator)();
+function DrawerNavigator({
+  initialRouteName,
+  screenOptions,
+  drawerContent,
+  drawerOptions,
+  children
+}) {
+  const { theme, isDark } = useTheme();
+  const navigationTheme = createNavigationTheme(theme, isDark);
+  const mergedScreenOptions = import_react33.default.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__ */ (0, import_jsx_runtime33.jsx)(
+    NativeDrawer.Navigator,
+    {
+      initialRouteName,
+      screenOptions: mergedScreenOptions,
+      drawerContent,
+      children
+    }
+  );
+}
+DrawerNavigator.Screen = NativeDrawer.Screen;
+function createDrawerScreens(routes) {
+  return routes.map((route) => /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(
+    DrawerNavigator.Screen,
+    {
+      name: route.name,
+      component: route.component,
+      options: route.options,
+      initialParams: route.initialParams
+    },
+    route.name
+  ));
+}
+
+// src/navigation/components/AppHeader.tsx
+var import_react_native23 = require("react-native");
+var import_react_native_safe_area_context3 = require("react-native-safe-area-context");
+var import_jsx_runtime34 = require("nativewind/jsx-runtime");
+function AppHeader({
+  title,
+  subtitle,
+  leftIcon = "chevron-left",
+  onLeftPress,
+  rightIcons = [],
+  transparent = false,
+  safeArea = true,
+  style
+}) {
+  const colors = useThemeColors();
+  const insets = (0, import_react_native_safe_area_context3.useSafeAreaInsets)();
+  const backgroundColor = transparent ? "transparent" : colors.card;
+  return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+    AppView,
+    {
+      style: [
+        {
+          backgroundColor,
+          paddingTop: safeArea ? insets.top : 0
+        },
+        style
+      ],
+      children: /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(AppView, { row: true, items: "center", px: 4, style: styles12.container, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(AppView, { style: [styles12.sideContainer, styles12.leftContainer], children: leftIcon && /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(AppPressable, { onPress: onLeftPress, style: styles12.iconButton, children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(Icon, { name: leftIcon, size: 24, color: colors.text }) }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(AppView, { style: styles12.centerContainer, children: [
+          title && /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+            AppText,
+            {
+              size: "lg",
+              weight: "semibold",
+              style: [styles12.title, { color: colors.text }],
+              numberOfLines: 1,
+              children: title
+            }
+          ),
+          subtitle && /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+            AppText,
+            {
+              size: "xs",
+              style: [styles12.subtitle, { color: colors.textMuted }],
+              numberOfLines: 1,
+              children: subtitle
+            }
+          )
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(AppView, { row: true, items: "center", style: [styles12.sideContainer, styles12.rightContainer], children: rightIcons.map((icon, index) => /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(AppPressable, { onPress: icon.onPress, style: styles12.iconButton, children: /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(AppView, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(Icon, { name: icon.icon, size: 24, color: colors.text }),
+          icon.badge ? /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(AppView, { style: styles12.badge, children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(AppText, { size: "xs", color: "white", style: styles12.badgeText, children: icon.badge > 99 ? "99+" : icon.badge }) }) : null
+        ] }) }, index)) })
+      ] })
+    }
+  );
+}
+var styles12 = import_react_native23.StyleSheet.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
+var import_react_native24 = require("react-native");
+var import_drawer2 = require("@react-navigation/drawer");
+var import_jsx_runtime35 = require("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__ */ (0, import_jsx_runtime35.jsxs)(import_drawer2.DrawerContentScrollView, { style: [styles13.container, { backgroundColor }], children: [
+    header && /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(import_react_native24.View, { style: [styles13.header, { borderBottomColor: dividerColor }], children: header }),
+    /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(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__ */ (0, import_jsx_runtime35.jsxs)(
+        import_react_native24.TouchableOpacity,
+        {
+          onPress,
+          style: [styles13.item, isFocused && { backgroundColor: activeBgColor }],
+          children: [
+            item.icon && /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(import_react_native24.View, { style: styles13.iconContainer, children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+              Icon,
+              {
+                name: item.icon,
+                size: "md",
+                color: isFocused ? activeColor : inactiveColor
+              }
+            ) }),
+            /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+              AppText,
+              {
+                style: [
+                  styles13.label,
+                  { color: isFocused ? activeColor : inactiveColor },
+                  isFocused && styles13.activeLabel
+                ],
+                numberOfLines: 1,
+                children: item.label
+              }
+            ),
+            item.badge != null && /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(import_react_native24.View, { style: [styles13.badge, { backgroundColor: activeColor }], children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(AppText, { style: styles13.badgeText, children: typeof item.badge === "number" && item.badge > 99 ? "99+" : item.badge }) })
+          ]
+        },
+        item.name
+      );
+    }) }),
+    footer && /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(import_react_native24.View, { style: [styles13.footer, { borderTopColor: dividerColor }], children: footer })
+  ] });
+}
+var styles13 = import_react_native24.StyleSheet.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
+var import_react34 = require("react");
+var import_native2 = require("@react-navigation/native");
+function useNavigation() {
+  return (0, import_native2.useNavigation)();
+}
+function useStackNavigation() {
+  return (0, import_native2.useNavigation)();
+}
+function useTabNavigation() {
+  return (0, import_native2.useNavigation)();
+}
+function useDrawerNavigation() {
+  return (0, import_native2.useNavigation)();
+}
+function useBackHandler(handler) {
+  const navigation = (0, import_native2.useNavigation)();
+  (0, import_react34.useEffect)(() => {
+    const unsubscribe = navigation.addListener("beforeRemove", (e) => {
+      if (!handler()) {
+        e.preventDefault();
+      }
+    });
+    return unsubscribe;
+  }, [navigation, handler]);
+}
+
+// src/navigation/hooks/useRoute.ts
+var import_native3 = require("@react-navigation/native");
+function useRoute() {
+  return (0, import_native3.useRoute)();
+}
+
+// src/navigation/hooks/useNavigationState.ts
+var import_native4 = require("@react-navigation/native");
+function useNavigationState(selector) {
+  return (0, import_native4.useNavigationState)(selector);
+}
+
+// src/navigation/index.ts
+var import_native5 = require("@react-navigation/native");
+
+// src/overlay/AppProvider.tsx
+var import_react_native_safe_area_context4 = require("react-native-safe-area-context");
+
+// src/overlay/AppStatusBar.tsx
+var import_react_native25 = require("react-native");
+var import_jsx_runtime36 = require("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__ */ (0, import_jsx_runtime36.jsx)(
+    import_react_native25.StatusBar,
+    {
+      barStyle: resolvedBarStyle,
+      backgroundColor: resolvedBackgroundColor,
+      translucent,
+      ...props
+    }
+  );
+}
+
+// src/overlay/loading/provider.tsx
+var import_react36 = require("react");
+
+// src/overlay/loading/context.ts
+var import_react35 = require("react");
+var LoadingContext = (0, import_react35.createContext)(null);
+function useLoadingContext() {
+  const ctx = (0, import_react35.useContext)(LoadingContext);
+  if (!ctx) throw new Error("useLoading must be used within OverlayProvider");
+  return ctx;
+}
+
+// src/overlay/loading/component.tsx
+var import_react_native26 = require("react-native");
+var import_jsx_runtime37 = require("nativewind/jsx-runtime");
+function LoadingModal({ visible, text }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(import_react_native26.Modal, { transparent: true, visible, animationType: "fade", children: /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(import_react_native26.View, { style: styles14.overlay, children: /* @__PURE__ */ (0, import_jsx_runtime37.jsxs)(import_react_native26.View, { style: [styles14.loadingBox, { backgroundColor: "rgba(0,0,0,0.8)" }], children: [
+    /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(import_react_native26.ActivityIndicator, { size: "large", color: "#fff" }),
+    text && /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(AppText, { className: "text-white mt-3 text-sm", children: text })
+  ] }) }) });
+}
+var styles14 = import_react_native26.StyleSheet.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
+var import_jsx_runtime38 = require("nativewind/jsx-runtime");
+function LoadingProvider({ children }) {
+  const [state, setState] = (0, import_react36.useState)({ visible: false });
+  const show = (0, import_react36.useCallback)((text) => {
+    setState({ visible: true, text });
+  }, []);
+  const hide = (0, import_react36.useCallback)(() => {
+    setState({ visible: false });
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime38.jsxs)(LoadingContext.Provider, { value: { show, hide }, children: [
+    children,
+    /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(LoadingModal, { ...state })
+  ] });
+}
+
+// src/overlay/toast/provider.tsx
+var import_react39 = require("react");
+var import_react_native28 = require("react-native");
+
+// src/overlay/toast/context.ts
+var import_react37 = require("react");
+var ToastContext = (0, import_react37.createContext)(null);
+function useToastContext() {
+  const ctx = (0, import_react37.useContext)(ToastContext);
+  if (!ctx) throw new Error("useToast must be used within OverlayProvider");
+  return ctx;
+}
+
+// src/overlay/toast/component.tsx
+var import_react38 = require("react");
+var import_react_native27 = require("react-native");
+var import_jsx_runtime39 = require("nativewind/jsx-runtime");
+function ToastItemView({ message, type, onHide }) {
+  const fadeAnim = (0, import_react38.useRef)(new import_react_native27.Animated.Value(0)).current;
+  (0, import_react38.useEffect)(() => {
+    import_react_native27.Animated.sequence([
+      import_react_native27.Animated.timing(fadeAnim, { toValue: 1, duration: 200, useNativeDriver: true }),
+      import_react_native27.Animated.delay(2500),
+      import_react_native27.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__ */ (0, import_jsx_runtime39.jsx)(
+    import_react_native27.Animated.View,
+    {
+      style: {
+        opacity: fadeAnim,
+        transform: [
+          {
+            translateY: fadeAnim.interpolate({
+              inputRange: [0, 1],
+              outputRange: [-20, 0]
+            })
+          }
+        ]
+      },
+      children: /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(AppView, { className: `${bgColors[type]} px-4 py-3 rounded-lg mb-2 mx-4 shadow-lg`, children: /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(AppText, { className: "text-white text-center", children: message }) })
+    }
+  );
+}
+
+// src/overlay/toast/provider.tsx
+var import_jsx_runtime40 = require("nativewind/jsx-runtime");
+function ToastProvider({ children }) {
+  const [toasts, setToasts] = (0, import_react39.useState)([]);
+  const timersRef = (0, import_react39.useRef)(/* @__PURE__ */ new Map());
+  const remove = (0, import_react39.useCallback)((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 = (0, import_react39.useCallback)(
+    (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 = (0, import_react39.useCallback)(
+    (message, duration) => show(message, "success", duration),
+    [show]
+  );
+  const error = (0, import_react39.useCallback)(
+    (message, duration) => show(message, "error", duration),
+    [show]
+  );
+  const info = (0, import_react39.useCallback)(
+    (message, duration) => show(message, "info", duration),
+    [show]
+  );
+  const warning = (0, import_react39.useCallback)(
+    (message, duration) => show(message, "warning", duration),
+    [show]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime40.jsxs)(ToastContext.Provider, { value: { show, success, error, info, warning }, children: [
+    children,
+    /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(import_react_native28.View, { style: styles15.toastContainer, pointerEvents: "none", children: toasts.map((toast) => /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(ToastItemView, { ...toast, onHide: () => remove(toast.id) }, toast.id)) })
+  ] });
+}
+var styles15 = import_react_native28.StyleSheet.create({
+  toastContainer: {
+    position: "absolute",
+    top: 60,
+    left: 0,
+    right: 0,
+    zIndex: 9999
+  }
+});
+
+// src/overlay/alert/provider.tsx
+var import_react41 = require("react");
+
+// src/overlay/alert/context.ts
+var import_react40 = require("react");
+var AlertContext = (0, import_react40.createContext)(null);
+function useAlertContext() {
+  const ctx = (0, import_react40.useContext)(AlertContext);
+  if (!ctx) throw new Error("useAlert must be used within OverlayProvider");
+  return ctx;
+}
+
+// src/overlay/alert/component.tsx
+var import_react_native29 = require("react-native");
+var import_jsx_runtime41 = require("nativewind/jsx-runtime");
+function AlertModal({
+  visible,
+  title,
+  message,
+  confirmText,
+  cancelText,
+  showCancel,
+  onConfirm,
+  onCancel
+}) {
+  if (!visible) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_react_native29.Modal, { transparent: true, visible: true, animationType: "fade", children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_react_native29.View, { style: styles16.overlay, children: /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(import_react_native29.View, { style: styles16.alertBox, children: [
+    title && /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(AppText, { className: "text-lg font-semibold text-center mb-2", children: title }),
+    message && /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(AppText, { className: "text-gray-600 text-center mb-4", children: message }),
+    /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(AppView, { row: true, gap: 3, className: "mt-2", children: [
+      showCancel && /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(AppPressable, { onPress: onCancel, className: "flex-1 py-3 bg-gray-100 rounded-lg", children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(AppText, { className: "text-center text-gray-700", children: cancelText || "\u53D6\u6D88" }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(AppPressable, { onPress: onConfirm, className: "flex-1 py-3 bg-primary-500 rounded-lg", children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(AppText, { className: "text-center text-white", children: confirmText || "\u786E\u5B9A" }) })
+    ] })
+  ] }) }) });
+}
+var styles16 = import_react_native29.StyleSheet.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
+var import_jsx_runtime42 = require("nativewind/jsx-runtime");
+function AlertProvider({ children }) {
+  const [alert, setAlert] = (0, import_react41.useState)(null);
+  const showAlert = (0, import_react41.useCallback)((options) => {
+    setAlert({ ...options, visible: true });
+  }, []);
+  const confirm = (0, import_react41.useCallback)(
+    (options) => {
+      showAlert({ ...options, showCancel: true });
+    },
+    [showAlert]
+  );
+  const hide = (0, import_react41.useCallback)(() => {
+    setAlert(null);
+  }, []);
+  const handleConfirm = (0, import_react41.useCallback)(() => {
+    alert?.onConfirm?.();
+    hide();
+  }, [alert, hide]);
+  const handleCancel = (0, import_react41.useCallback)(() => {
+    alert?.onCancel?.();
+    hide();
+  }, [alert, hide]);
+  return /* @__PURE__ */ (0, import_jsx_runtime42.jsxs)(AlertContext.Provider, { value: { alert: showAlert, confirm }, children: [
+    children,
+    /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(
+      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
+var import_jsx_runtime43 = require("nativewind/jsx-runtime");
+function OverlayProvider({ children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime43.jsx)(LoadingProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime43.jsx)(ToastProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime43.jsx)(AlertProvider, { children }) }) });
+}
+
+// src/overlay/AppProvider.tsx
+var import_jsx_runtime44 = require("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__ */ (0, import_jsx_runtime44.jsx)(OverlayProvider, { children: content });
+  }
+  if (enableNavigation) {
+    content = /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(NavigationProvider, { ...navigationProps, children: content });
+  }
+  if (enableTheme) {
+    content = /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(ThemeProvider, { light: lightTheme, dark: darkTheme, defaultDark, isDark, children: /* @__PURE__ */ (0, import_jsx_runtime44.jsxs)(import_jsx_runtime44.Fragment, { children: [
+      enableStatusBar && /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(AppStatusBar, { testID: "status-bar", ...statusBarProps }),
+      content
+    ] }) });
+  }
+  if (enableSafeArea) {
+    content = /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_react_native_safe_area_context4.SafeAreaProvider, { children: content });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(import_jsx_runtime44.Fragment, { 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
+var import_react_native_safe_area_context5 = require("react-native-safe-area-context");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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,
+  NavigationContainer,
+  NavigationIcons,
+  NavigationProvider,
+  OverlayProvider,
+  Page,
+  Progress,
+  Radio,
+  RadioGroup,
+  Row,
+  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.js.map