taro-uno-ui 0.9.0-beta

package/dist/js/index-DFdcksbe.js

@@ -0,0 +1,1165 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Taro = require("@tarojs/taro");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const Taro__namespace = /* @__PURE__ */ _interopNamespaceDefault(Taro);
+const PLATFORM_NAMES = {
+  weapp: "微信小程序",
+  alipay: "支付宝小程序",
+  swan: "百度小程序",
+  tt: "字节跳动小程序",
+  qq: "QQ小程序",
+  h5: "H5",
+  rn: "React Native",
+  jd: "京东小程序"
+};
+const PLATFORM_FEATURES = {
+  weapp: {
+    supportsStorage: true,
+    supportsNetwork: true,
+    supportsLocation: true,
+    supportsCamera: true,
+    supportsPayment: true,
+    supportsShare: true,
+    supportsBiometrics: true
+  },
+  alipay: {
+    supportsStorage: true,
+    supportsNetwork: true,
+    supportsLocation: true,
+    supportsCamera: true,
+    supportsPayment: true,
+    supportsShare: true,
+    supportsBiometrics: true
+  },
+  swan: {
+    supportsStorage: true,
+    supportsNetwork: true,
+    supportsLocation: true,
+    supportsCamera: true,
+    supportsPayment: true,
+    supportsShare: true,
+    supportsBiometrics: false
+  },
+  tt: {
+    supportsStorage: true,
+    supportsNetwork: true,
+    supportsLocation: true,
+    supportsCamera: true,
+    supportsPayment: true,
+    supportsShare: true,
+    supportsBiometrics: false
+  },
+  qq: {
+    supportsStorage: true,
+    supportsNetwork: true,
+    supportsLocation: true,
+    supportsCamera: true,
+    supportsPayment: true,
+    supportsShare: true,
+    supportsBiometrics: false
+  },
+  h5: {
+    supportsStorage: true,
+    supportsNetwork: true,
+    supportsLocation: true,
+    supportsCamera: true,
+    supportsPayment: true,
+    supportsShare: true,
+    supportsBiometrics: false
+  },
+  rn: {
+    supportsStorage: true,
+    supportsNetwork: true,
+    supportsLocation: true,
+    supportsCamera: true,
+    supportsPayment: true,
+    supportsShare: true,
+    supportsBiometrics: true
+  },
+  jd: {
+    supportsStorage: true,
+    supportsNetwork: true,
+    supportsLocation: true,
+    supportsCamera: true,
+    supportsPayment: true,
+    supportsShare: true,
+    supportsBiometrics: false
+  }
+};
+const PLATFORM_APIS = {
+  weapp: {
+    request: "wx.request",
+    storage: {
+      set: "wx.setStorage",
+      get: "wx.getStorage",
+      remove: "wx.removeStorage",
+      clear: "wx.clearStorage"
+    },
+    location: {
+      get: "wx.getLocation",
+      open: "wx.openLocation"
+    },
+    camera: {
+      take: "wx.cameraTake",
+      choose: "wx.chooseImage"
+    }
+  },
+  alipay: {
+    request: "my.request",
+    storage: {
+      set: "my.setStorage",
+      get: "my.getStorage",
+      remove: "my.removeStorage",
+      clear: "my.clearStorage"
+    },
+    location: {
+      get: "my.getLocation",
+      open: "my.openLocation"
+    },
+    camera: {
+      take: "my.cameraTake",
+      choose: "my.chooseImage"
+    }
+  },
+  swan: {
+    request: "swan.request",
+    storage: {
+      set: "swan.setStorage",
+      get: "swan.getStorage",
+      remove: "swan.removeStorage",
+      clear: "swan.clearStorage"
+    },
+    location: {
+      get: "swan.getLocation",
+      open: "swan.openLocation"
+    },
+    camera: {
+      take: "swan.cameraTake",
+      choose: "swan.chooseImage"
+    }
+  },
+  tt: {
+    request: "tt.request",
+    storage: {
+      set: "tt.setStorage",
+      get: "tt.getStorage",
+      remove: "tt.removeStorage",
+      clear: "tt.clearStorage"
+    },
+    location: {
+      get: "tt.getLocation",
+      open: "tt.openLocation"
+    },
+    camera: {
+      take: "tt.cameraTake",
+      choose: "tt.chooseImage"
+    }
+  },
+  qq: {
+    request: "qq.request",
+    storage: {
+      set: "qq.setStorage",
+      get: "qq.getStorage",
+      remove: "qq.removeStorage",
+      clear: "qq.clearStorage"
+    },
+    location: {
+      get: "qq.getLocation",
+      open: "qq.openLocation"
+    },
+    camera: {
+      take: "qq.cameraTake",
+      choose: "qq.chooseImage"
+    }
+  },
+  h5: {
+    request: "fetch",
+    storage: {
+      set: "localStorage.setItem",
+      get: "localStorage.getItem",
+      remove: "localStorage.removeItem",
+      clear: "localStorage.clear"
+    },
+    location: {
+      get: "navigator.geolocation.getCurrentPosition",
+      open: "window.open"
+    },
+    camera: {
+      take: "navigator.mediaDevices.getUserMedia",
+      choose: "input[type=file].click()"
+    }
+  },
+  rn: {
+    request: "fetch",
+    storage: {
+      set: "AsyncStorage.setItem",
+      get: "AsyncStorage.getItem",
+      remove: "AsyncStorage.removeItem",
+      clear: "AsyncStorage.clear"
+    },
+    location: {
+      get: "Geolocation.getCurrentPosition",
+      open: "Linking.openURL"
+    },
+    camera: {
+      take: "Camera.takePictureAsync",
+      choose: "ImagePicker.launchImageLibrary"
+    }
+  },
+  jd: {
+    request: "jd.request",
+    storage: {
+      set: "jd.setStorage",
+      get: "jd.getStorage",
+      remove: "jd.removeStorage",
+      clear: "jd.clearStorage"
+    },
+    location: {
+      get: "jd.getLocation",
+      open: "jd.openLocation"
+    },
+    camera: {
+      take: "jd.cameraTake",
+      choose: "jd.chooseImage"
+    }
+  }
+};
+class WeappAdapter {
+  constructor() {
+    __publicField(this, "storage", {
+      async set(key, value) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.setStorage({
+            key,
+            data: value,
+            success: () => resolve(),
+            fail: reject
+          });
+        });
+      },
+      async get(key) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.getStorage({
+            key,
+            success: (res) => resolve(res.data),
+            fail: reject
+          });
+        });
+      },
+      async remove(key) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.removeStorage({
+            key,
+            success: () => resolve(),
+            fail: reject
+          });
+        });
+      },
+      async clear() {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.clearStorage({
+            success: () => resolve(),
+            fail: reject
+          });
+        });
+      },
+      async getInfo() {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.getStorageInfo({
+            success: (res) => resolve({
+              currentSize: res.currentSize,
+              limitSize: res.limitSize
+            }),
+            fail: reject
+          });
+        });
+      }
+    });
+    __publicField(this, "location", {
+      async getCurrentPosition() {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.getLocation({
+            success: resolve,
+            fail: reject
+          });
+        });
+      },
+      async openLocation(options) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.openLocation({
+            ...options,
+            success: () => resolve(),
+            fail: reject
+          });
+        });
+      },
+      async chooseLocation() {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.chooseLocation({
+            success: resolve,
+            fail: reject
+          });
+        });
+      }
+    });
+    __publicField(this, "camera", {
+      async takePhoto(options) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.cameraTakePhoto({
+            ...options,
+            success: resolve,
+            fail: reject
+          });
+        });
+      },
+      async chooseImage(options) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.chooseImage({
+            ...options,
+            success: resolve,
+            fail: reject
+          });
+        });
+      },
+      async chooseVideo(options) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.chooseVideo({
+            ...options,
+            success: resolve,
+            fail: reject
+          });
+        });
+      }
+    });
+    __publicField(this, "payment", {
+      async requestPayment(options) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.requestPayment({
+            ...options,
+            success: () => resolve(),
+            fail: reject
+          });
+        });
+      }
+    });
+    __publicField(this, "share", {
+      async shareAppMessage(options) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.shareAppMessage({
+            ...options,
+            success: () => resolve(),
+            fail: reject
+          });
+        });
+      },
+      async shareToTimeline(options) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.shareToTimeline({
+            ...options,
+            success: () => resolve(),
+            fail: reject
+          });
+        });
+      }
+    });
+    __publicField(this, "biometrics", {
+      async checkIsAvailable() {
+        return new Promise((resolve) => {
+          Taro__namespace.checkIsSoterEnrolledInDevice({
+            checkAuthMode: "fingerPrint",
+            success: (res) => resolve(res.isEnrolled),
+            fail: () => resolve(false)
+          });
+        });
+      },
+      async startVerify(options) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.startSoterAuthentication({
+            ...options,
+            success: resolve,
+            fail: reject
+          });
+        });
+      }
+    });
+    __publicField(this, "system", {
+      async getSystemInfo() {
+        return Promise.resolve(Taro__namespace.getSystemInfoSync());
+      },
+      async getNetworkType() {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.getNetworkType({
+            success: resolve,
+            fail: reject
+          });
+        });
+      },
+      async getBatteryInfo() {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.getBatteryInfo({
+            success: resolve,
+            fail: reject
+          });
+        });
+      },
+      async getScreenBrightness() {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.getScreenBrightness({
+            success: (res) => resolve(res.value),
+            fail: reject
+          });
+        });
+      },
+      async setScreenBrightness(value) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.setScreenBrightness({
+            value,
+            success: () => resolve(),
+            fail: reject
+          });
+        });
+      },
+      async keepScreenOn(keepScreenOn) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.setKeepScreenOn({
+            keepScreenOn,
+            success: () => resolve(),
+            fail: reject
+          });
+        });
+      },
+      async vibrate() {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.vibrate({
+            success: () => resolve(),
+            fail: reject
+          });
+        });
+      }
+    });
+    __publicField(this, "clipboard", {
+      async set(text) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.setClipboardData({
+            data: text,
+            success: () => resolve(),
+            fail: reject
+          });
+        });
+      },
+      async get() {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.getClipboardData({
+            success: (res) => resolve(res.data),
+            fail: reject
+          });
+        });
+      }
+    });
+    __publicField(this, "scan", {
+      async scanCode(options) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.scanCode({
+            ...options,
+            success: resolve,
+            fail: reject
+          });
+        });
+      }
+    });
+    __publicField(this, "file", {
+      async saveFile(options) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.saveFile({
+            ...options,
+            success: resolve,
+            fail: reject
+          });
+        });
+      },
+      async getFileInfo(options) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.getFileInfo({
+            ...options,
+            success: resolve,
+            fail: reject
+          });
+        });
+      },
+      async getSavedFileList() {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.getSavedFileList({
+            success: resolve,
+            fail: reject
+          });
+        });
+      },
+      async removeSavedFile(options) {
+        return new Promise((resolve, reject) => {
+          Taro__namespace.removeSavedFile({
+            ...options,
+            success: () => resolve(),
+            fail: reject
+          });
+        });
+      }
+    });
+  }
+  getPlatformInfo() {
+    const system = Taro__namespace.getSystemInfoSync();
+    const accountInfo = Taro__namespace.getAccountInfoSync();
+    return {
+      platform: "weapp",
+      isMiniProgram: true,
+      isH5: false,
+      isRN: false,
+      system,
+      SDKVersion: accountInfo.miniProgram.sdkVersion || accountInfo.miniProgram.version,
+      version: accountInfo.miniProgram.version
+    };
+  }
+  async request(config) {
+    return new Promise((resolve, reject) => {
+      Taro__namespace.request({
+        url: config.url,
+        method: config.method || "GET",
+        header: config.header,
+        data: config.data,
+        timeout: config.timeout,
+        success: (res) => {
+          resolve({
+            data: res.data,
+            statusCode: res.statusCode,
+            statusMessage: res.errMsg,
+            header: res.header
+          });
+        },
+        fail: (err) => {
+          const error = {
+            message: err.errMsg || "Request failed",
+            code: err.errCode,
+            detail: err
+          };
+          reject(error);
+        }
+      });
+    });
+  }
+}
+class H5Adapter {
+  constructor() {
+    __publicField(this, "storage", {
+      async set(key, value) {
+        localStorage.setItem(key, JSON.stringify(value));
+      },
+      async get(key) {
+        const value = localStorage.getItem(key);
+        return value ? JSON.parse(value) : null;
+      },
+      async remove(key) {
+        localStorage.removeItem(key);
+      },
+      async clear() {
+        localStorage.clear();
+      },
+      async getInfo() {
+        let size = 0;
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i);
+          if (key) {
+            size += (key + localStorage.getItem(key)).length;
+          }
+        }
+        return {
+          currentSize: size,
+          limitSize: 5 * 1024 * 1024
+          // 5MB 估算
+        };
+      }
+    });
+    __publicField(this, "location", {
+      async getCurrentPosition() {
+        return new Promise((resolve, reject) => {
+          if (!navigator.geolocation) {
+            reject(new Error("Geolocation is not supported"));
+            return;
+          }
+          navigator.geolocation.getCurrentPosition(
+            (position) => {
+              resolve({
+                latitude: position.coords.latitude || 0,
+                longitude: position.coords.longitude || 0,
+                accuracy: position.coords.accuracy || 0,
+                altitude: position.coords.altitude || 0,
+                verticalAccuracy: position.coords.altitudeAccuracy || 0,
+                horizontalAccuracy: position.coords.accuracy || 0,
+                speed: position.coords.speed || 0,
+                errMsg: "getLocation:ok"
+              });
+            },
+            (error) => {
+              reject(error);
+            }
+          );
+        });
+      },
+      async openLocation(options) {
+        const url = `https://maps.google.com/maps?q=${options.latitude},${options.longitude}`;
+        window.open(url, "_blank");
+      },
+      async chooseLocation() {
+        throw new Error("chooseLocation is not supported in H5 environment");
+      }
+    });
+    __publicField(this, "camera", {
+      async takePhoto() {
+        throw new Error("takePhoto is not supported in H5 environment");
+      },
+      async chooseImage(options) {
+        return new Promise((resolve, reject) => {
+          const input = document.createElement("input");
+          input.type = "file";
+          input.accept = "image/*";
+          if ((options == null ? void 0 : options.count) && options.count > 1) {
+            input.multiple = true;
+          }
+          input.onchange = (event) => {
+            const files = Array.from(event.target.files || []);
+            const tempFilePaths = files.map((file) => URL.createObjectURL(file));
+            resolve({
+              tempFilePaths,
+              tempFiles: files.map((file) => ({
+                path: URL.createObjectURL(file),
+                size: file.size,
+                type: file.type,
+                originalFileObj: file
+              })),
+              errMsg: "chooseImage:ok"
+            });
+          };
+          input.onerror = () => {
+            reject(new Error("Failed to choose image"));
+          };
+          input.click();
+        });
+      },
+      async chooseVideo() {
+        return new Promise((resolve, reject) => {
+          const input = document.createElement("input");
+          input.type = "file";
+          input.accept = "video/*";
+          input.onchange = (event) => {
+            var _a;
+            const file = (_a = event.target.files) == null ? void 0 : _a[0];
+            if (!file) {
+              reject(new Error("No file selected"));
+              return;
+            }
+            resolve({
+              tempFilePath: URL.createObjectURL(file),
+              duration: 0,
+              // 需要额外的逻辑获取视频时长
+              size: file.size,
+              height: 0,
+              // 需要额外的逻辑获取视频尺寸
+              width: 0,
+              errMsg: "chooseVideo:ok"
+            });
+          };
+          input.onerror = () => {
+            reject(new Error("Failed to choose video"));
+          };
+          input.click();
+        });
+      }
+    });
+    __publicField(this, "payment", {
+      async requestPayment() {
+        throw new Error("Payment is not supported in H5 environment");
+      }
+    });
+    __publicField(this, "share", {
+      async shareAppMessage() {
+        if (navigator.share) {
+          await navigator.share({
+            title: document.title,
+            url: window.location.href
+          });
+        } else {
+          throw new Error("Web Share API is not supported");
+        }
+      },
+      async shareToTimeline() {
+        throw new Error("shareToTimeline is not supported in H5 environment");
+      }
+    });
+    __publicField(this, "biometrics", {
+      async checkIsAvailable() {
+        return false;
+      },
+      async startVerify() {
+        throw new Error("Biometric authentication is not supported in H5 environment");
+      }
+    });
+    __publicField(this, "system", {
+      async getSystemInfo() {
+        return Promise.resolve(Taro__namespace.getSystemInfoSync());
+      },
+      async getNetworkType() {
+        const connection = navigator.connection;
+        let networkType = "unknown";
+        if (connection) {
+          if (connection.effectiveType) {
+            networkType = connection.effectiveType;
+          }
+        }
+        return {
+          networkType,
+          errMsg: "getNetworkType:ok"
+        };
+      },
+      async getBatteryInfo() {
+        throw new Error("Battery API is not supported");
+      },
+      async getScreenBrightness() {
+        return 1;
+      },
+      async setScreenBrightness() {
+      },
+      async keepScreenOn() {
+      },
+      async vibrate() {
+        if (navigator.vibrate) {
+          navigator.vibrate(200);
+        }
+      }
+    });
+    __publicField(this, "clipboard", {
+      async set(text) {
+        if (navigator.clipboard) {
+          await navigator.clipboard.writeText(text);
+        } else {
+          const textArea = document.createElement("textarea");
+          textArea.value = text;
+          document.body.appendChild(textArea);
+          textArea.select();
+          document.execCommand("copy");
+          document.body.removeChild(textArea);
+        }
+      },
+      async get() {
+        if (navigator.clipboard) {
+          return await navigator.clipboard.readText();
+        } else {
+          return "";
+        }
+      }
+    });
+    __publicField(this, "scan", {
+      async scanCode() {
+        throw new Error("scanCode is not supported in H5 environment");
+      }
+    });
+    __publicField(this, "file", {
+      async saveFile() {
+        throw new Error("saveFile is not supported in H5 environment");
+      },
+      async getFileInfo() {
+        throw new Error("getFileInfo is not supported in H5 environment");
+      },
+      async getSavedFileList() {
+        throw new Error("getSavedFileList is not supported in H5 environment");
+      },
+      async removeSavedFile() {
+        throw new Error("removeSavedFile is not supported in H5 environment");
+      }
+    });
+  }
+  getPlatformInfo() {
+    const system = Taro__namespace.getSystemInfoSync();
+    return {
+      platform: "h5",
+      isMiniProgram: false,
+      isH5: true,
+      isRN: false,
+      system
+    };
+  }
+  /** Headers对象转普通对象 */
+  headersToObject(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  async request(config) {
+    const url = new URL(config.url, window.location.origin);
+    if (config.params) {
+      Object.entries(config.params).forEach(([key, value]) => {
+        url.searchParams.append(key, String(value));
+      });
+    }
+    const options = {
+      method: config.method || "GET",
+      headers: {
+        "Content-Type": "application/json",
+        ...config.header
+      }
+    };
+    if (config.data && ["POST", "PUT", "PATCH"].includes(config.method || "GET")) {
+      options.body = JSON.stringify(config.data);
+    }
+    try {
+      const response = await fetch(url.toString(), options);
+      const data = await response.json();
+      return {
+        data,
+        statusCode: response.status,
+        statusMessage: response.statusText,
+        header: this.headersToObject(response.headers)
+      };
+    } catch (error) {
+      const requestError = {
+        message: error instanceof Error ? error.message : "Network error",
+        detail: error
+      };
+      throw requestError;
+    }
+  }
+}
+class RNAdapter {
+  constructor() {
+    // React Native的存储实现需要使用AsyncStorage
+    __publicField(this, "storage", {
+      async set(_key, _value) {
+        throw new Error("AsyncStorage not implemented");
+      },
+      async get(_key) {
+        throw new Error("AsyncStorage not implemented");
+      },
+      async remove(_key) {
+        throw new Error("AsyncStorage not implemented");
+      },
+      async clear() {
+        throw new Error("AsyncStorage not implemented");
+      },
+      async getInfo() {
+        throw new Error("Storage info not available in React Native");
+      }
+    });
+    // 其他React Native平台的实现...
+    // 由于React Native的API实现较为复杂，这里只提供基础框架
+    __publicField(this, "location", {
+      async getCurrentPosition() {
+        throw new Error("Location service not implemented");
+      },
+      async openLocation() {
+        throw new Error("openLocation not implemented");
+      },
+      async chooseLocation() {
+        throw new Error("chooseLocation not implemented");
+      }
+    });
+    __publicField(this, "camera", {
+      async takePhoto() {
+        throw new Error("Camera service not implemented");
+      },
+      async chooseImage() {
+        throw new Error("chooseImage not implemented");
+      },
+      async chooseVideo() {
+        throw new Error("chooseVideo not implemented");
+      }
+    });
+    __publicField(this, "payment", {
+      async requestPayment() {
+        throw new Error("Payment service not implemented");
+      }
+    });
+    __publicField(this, "share", {
+      async shareAppMessage() {
+        throw new Error("Share service not implemented");
+      },
+      async shareToTimeline() {
+        throw new Error("Share service not implemented");
+      }
+    });
+    __publicField(this, "biometrics", {
+      async checkIsAvailable() {
+        throw new Error("Biometric service not implemented");
+      },
+      async startVerify() {
+        throw new Error("Biometric service not implemented");
+      }
+    });
+    __publicField(this, "system", {
+      async getSystemInfo() {
+        return Promise.resolve(Taro__namespace.getSystemInfoSync());
+      },
+      async getNetworkType() {
+        throw new Error("Network type service not implemented");
+      },
+      async getBatteryInfo() {
+        throw new Error("Battery service not implemented");
+      },
+      async getScreenBrightness() {
+        throw new Error("Screen brightness service not implemented");
+      },
+      async setScreenBrightness() {
+        throw new Error("Screen brightness service not implemented");
+      },
+      async keepScreenOn() {
+        throw new Error("Keep screen on service not implemented");
+      },
+      async vibrate() {
+        throw new Error("Vibrate service not implemented");
+      }
+    });
+    __publicField(this, "clipboard", {
+      async set(_text) {
+        throw new Error("Clipboard service not implemented");
+      },
+      async get() {
+        throw new Error("Clipboard service not implemented");
+      }
+    });
+    __publicField(this, "scan", {
+      async scanCode() {
+        throw new Error("Scan service not implemented");
+      }
+    });
+    __publicField(this, "file", {
+      async saveFile() {
+        throw new Error("File service not implemented");
+      },
+      async getFileInfo() {
+        throw new Error("File service not implemented");
+      },
+      async getSavedFileList() {
+        throw new Error("File service not implemented");
+      },
+      async removeSavedFile() {
+        throw new Error("File service not implemented");
+      }
+    });
+  }
+  getPlatformInfo() {
+    const system = Taro__namespace.getSystemInfoSync();
+    return {
+      platform: "rn",
+      isMiniProgram: false,
+      isH5: false,
+      isRN: true,
+      system
+    };
+  }
+  /** Headers对象转普通对象 */
+  headersToObject(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  async request(config) {
+    const url = new URL(config.url);
+    if (config.params) {
+      Object.entries(config.params).forEach(([key, value]) => {
+        url.searchParams.append(key, String(value));
+      });
+    }
+    const options = {
+      method: config.method || "GET",
+      headers: {
+        "Content-Type": "application/json",
+        ...config.header
+      }
+    };
+    if (config.data && ["POST", "PUT", "PATCH"].includes(config.method || "GET")) {
+      options.body = JSON.stringify(config.data);
+    }
+    try {
+      const response = await fetch(url.toString(), options);
+      const data = await response.json();
+      return {
+        data,
+        statusCode: response.status,
+        statusMessage: response.statusText,
+        header: this.headersToObject(response.headers)
+      };
+    } catch (error) {
+      const requestError = {
+        message: error instanceof Error ? error.message : "Network error",
+        detail: error
+      };
+      throw requestError;
+    }
+  }
+}
+const _PlatformManager = class _PlatformManager {
+  constructor() {
+    __publicField(this, "adapter");
+    __publicField(this, "platformInfo");
+    const platform = this.detectPlatform();
+    this.adapter = this.createAdapter(platform);
+    this.platformInfo = this.adapter.getPlatformInfo();
+  }
+  /** 获取单例实例 */
+  static getInstance() {
+    if (!_PlatformManager.instance) {
+      _PlatformManager.instance = new _PlatformManager();
+    }
+    return _PlatformManager.instance;
+  }
+  /** 检测当前平台 */
+  detectPlatform() {
+    if (typeof window !== "undefined" && window.wx && window.wx.getSystemInfo) {
+      return "weapp";
+    } else if (typeof window !== "undefined" && window.my && window.my.getSystemInfo) {
+      return "alipay";
+    } else if (typeof window !== "undefined" && window.swan && window.swan.getSystemInfo) {
+      return "swan";
+    } else if (typeof window !== "undefined" && window.tt && window.tt.getSystemInfo) {
+      return "tt";
+    } else if (typeof window !== "undefined" && window.qq && window.qq.getSystemInfo) {
+      return "qq";
+    } else if (typeof window !== "undefined" && window.jd && window.jd.getSystemInfo) {
+      return "jd";
+    } else if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+      return "rn";
+    } else {
+      return "h5";
+    }
+  }
+  /** 创建平台适配器 */
+  createAdapter(platform) {
+    switch (platform) {
+      case "weapp":
+        return new WeappAdapter();
+      case "alipay":
+        return new WeappAdapter();
+      case "swan":
+        return new WeappAdapter();
+      case "tt":
+        return new WeappAdapter();
+      case "qq":
+        return new WeappAdapter();
+      case "jd":
+        return new WeappAdapter();
+      case "h5":
+        return new H5Adapter();
+      case "rn":
+        return new RNAdapter();
+      default:
+        return new H5Adapter();
+    }
+  }
+  /** 获取平台适配器 */
+  getAdapter() {
+    return this.adapter;
+  }
+  /** 获取平台信息 */
+  getPlatformInfo() {
+    return this.platformInfo;
+  }
+  /** 获取当前平台 */
+  getPlatform() {
+    return this.platformInfo.platform;
+  }
+  /** 判断是否为指定平台 */
+  isPlatform(targetPlatform) {
+    return this.platformInfo.platform === targetPlatform;
+  }
+  /** 判断是否为小程序环境 */
+  isMiniProgram() {
+    return this.platformInfo.isMiniProgram;
+  }
+  /** 判断是否为H5环境 */
+  isH5() {
+    return this.platformInfo.isH5;
+  }
+  /** 判断是否为React Native环境 */
+  isRN() {
+    return this.platformInfo.isRN;
+  }
+  /** 检查功能支持 */
+  isFeatureSupported(feature) {
+    var _a;
+    const platform = this.platformInfo.platform;
+    return ((_a = PLATFORM_FEATURES[platform]) == null ? void 0 : _a[feature]) || false;
+  }
+  /** 获取平台API映射 */
+  getPlatformAPIs() {
+    const platform = this.platformInfo.platform;
+    return PLATFORM_APIS[platform] || PLATFORM_APIS.h5;
+  }
+  /** 获取平台名称 */
+  getPlatformName() {
+    const platform = this.platformInfo.platform;
+    return PLATFORM_NAMES[platform] || "Unknown";
+  }
+  /** 重置平台管理器（主要用于测试） */
+  reset() {
+    _PlatformManager.instance = new _PlatformManager();
+  }
+};
+__publicField(_PlatformManager, "instance");
+let PlatformManager = _PlatformManager;
+const platformManager = PlatformManager.getInstance();
+const platformAdapter = platformManager.getAdapter();
+const platformUtils = {
+  getPlatform: () => platformManager.getPlatform(),
+  getPlatformInfo: () => platformManager.getPlatformInfo(),
+  isPlatform: (platform) => platformManager.isPlatform(platform),
+  isMiniProgram: () => platformManager.isMiniProgram(),
+  isH5: () => platformManager.isH5(),
+  isRN: () => platformManager.isRN(),
+  isFeatureSupported: (feature) => platformManager.isFeatureSupported(feature),
+  getPlatformAPIs: () => platformManager.getPlatformAPIs(),
+  getPlatformName: () => platformManager.getPlatformName()
+};
+const {
+  getPlatform,
+  getPlatformInfo,
+  isPlatform,
+  isMiniProgram,
+  isH5,
+  isRN,
+  isFeatureSupported,
+  getPlatformAPIs,
+  getPlatformName
+} = platformUtils;
+exports.PlatformManager = PlatformManager;
+exports.getPlatform = getPlatform;
+exports.getPlatformAPIs = getPlatformAPIs;
+exports.getPlatformInfo = getPlatformInfo;
+exports.getPlatformName = getPlatformName;
+exports.isFeatureSupported = isFeatureSupported;
+exports.isH5 = isH5;
+exports.isMiniProgram = isMiniProgram;
+exports.isPlatform = isPlatform;
+exports.isRN = isRN;
+exports.platformAdapter = platformAdapter;
+exports.platformManager = platformManager;
+exports.platformUtils = platformUtils;
+//# sourceMappingURL=index-DFdcksbe.js.map