expo-gaode-map-navigation 1.1.5 → 1.1.6

package/build/map/ExpoGaodeMapModule.js

@@ -1,51 +1,619 @@
 "use strict";
-/**
- * 高德地图原生模块
- * 提供 SDK 初始化、定位、权限管理等功能
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSDKConfig = getSDKConfig;
 exports.getWebKey = getWebKey;
 const expo_1 = require("expo");
+const react_native_1 = require("react-native");
+const ErrorHandler_1 = require("./utils/ErrorHandler");
+const GeoUtils_1 = require("./utils/GeoUtils");
 // 获取原生模块实例 - 添加容错处理
 let nativeModule = null;
 try {
-    nativeModule = (0, expo_1.requireNativeModule)('NaviMap');
+    nativeModule = (0, expo_1.requireNativeModule)('ExpoGaodeMap');
 }
 catch (error) {
-    // 原生模块加载失败时的静默处理
-    // 这是正常的，因为 navigation 包可以独立使用，不一定需要完整的地图功能
-    if (__DEV__) {
-        console.warn('[expo-gaode-map-navigation] NaviMap 原生模块未加载，地图相关功能将不可用');
-    }
+    console.error('Failed to load ExpoGaodeMap native module:', error);
+    const moduleError = ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+    ErrorHandler_1.ErrorLogger.log(moduleError);
 }
 // 记录最近一次 initSDK 的配置（含 webKey）
 let _sdkConfig = null;
+let _isSDKInitialized = false;
 // 扩展原生模块，添加便捷方法
 const ExpoGaodeMapModuleWithHelpers = {
     ...(nativeModule || {}),
     /**
      * 初始化 SDK，并缓存配置（包含 webKey）
+     * 注意：允许不提供任何 API Key，因为原生端可能已通过 Config Plugin 配置
      */
     initSDK(config) {
-        var _a;
-        _sdkConfig = config !== null && config !== void 0 ? config : null;
-        (_a = nativeModule === null || nativeModule === void 0 ? void 0 : nativeModule.initSDK) === null || _a === void 0 ? void 0 : _a.call(nativeModule, config);
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            // 检查是否有任何 key 被提供
+            const hasJSKeys = !!(config.androidKey || config.iosKey);
+            const hasWebKey = !!config.webKey;
+            // 如果 JS 端没有提供 androidKey/iosKey,检查原生端是否已配置
+            if (!hasJSKeys) {
+                const isNativeConfigured = nativeModule.isNativeSDKConfigured();
+                if (!isNativeConfigured && !hasWebKey) {
+                    throw ErrorHandler_1.ErrorHandler.invalidApiKey('both');
+                }
+                // 如果原生已配置,或者只提供了 webKey,继续初始化
+                ErrorHandler_1.ErrorLogger.warn(isNativeConfigured
+                    ? 'SDK 使用原生端配置的 API Key'
+                    : 'SDK 初始化仅使用 webKey', { config });
+            }
+            _sdkConfig = config ?? null;
+            nativeModule.initSDK(config);
+            _isSDKInitialized = true;
+            ErrorHandler_1.ErrorLogger.warn('SDK 初始化成功', { config });
+        }
+        catch (error) {
+            _isSDKInitialized = false;
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, 'SDK 初始化');
+        }
+    },
+    isSDKInitialized() {
+        return _isSDKInitialized;
+    },
+    calculateDistanceBetweenPoints(p1, p2) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        return nativeModule.distanceBetweenCoordinates((0, GeoUtils_1.normalizeLatLng)(p1), (0, GeoUtils_1.normalizeLatLng)(p2));
+    },
+    calculateDistance(lat1, lon1, lat2, lon2) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        return nativeModule.distanceBetweenCoordinates({ latitude: lat1, longitude: lon1 }, { latitude: lat2, longitude: lon2 });
+    },
+    setLoadWorldVectorMap(enabled) {
+        if (!nativeModule)
+            return;
+        try {
+            nativeModule.setLoadWorldVectorMap(enabled);
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('setLoadWorldVectorMap 失败', { enabled, error });
+        }
+    },
+    getVersion() {
+        if (!nativeModule)
+            return '0.0.0';
+        try {
+            return nativeModule.getVersion();
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('getVersion 失败', { error });
+            return '0.0.0';
+        }
+    },
+    start() {
+        if (!nativeModule)
+            return;
+        try {
+            nativeModule.start();
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('start 失败', { error });
+        }
+    },
+    stop() {
+        if (!nativeModule)
+            return;
+        try {
+            nativeModule.stop();
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('stop 失败', { error });
+        }
+    },
+    isStarted() {
+        if (!nativeModule)
+            return Promise.resolve(false);
+        try {
+            return nativeModule.isStarted();
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('isStarted 失败', { error });
+            return Promise.resolve(false);
+        }
+    },
+    async getCurrentLocation() {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return await nativeModule.getCurrentLocation();
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '获取当前位置');
+        }
+    },
+    async coordinateConvert(coordinate, type) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return await nativeModule.coordinateConvert((0, GeoUtils_1.normalizeLatLng)(coordinate), type);
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '坐标转换');
+        }
+    },
+    setLocatingWithReGeocode(isReGeocode) {
+        if (!nativeModule)
+            return;
+        try {
+            nativeModule.setLocatingWithReGeocode(isReGeocode);
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('setLocatingWithReGeocode 失败', { isReGeocode, error });
+        }
+    },
+    get isBackgroundLocationEnabled() {
+        if (!nativeModule)
+            return false;
+        return nativeModule.isBackgroundLocationEnabled === true;
+    },
+    /**
+     * 检查位置权限状态
+     */
+    async checkLocationPermission() {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return await nativeModule.checkLocationPermission();
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '检查权限');
+        }
+    },
+    /**
+     * 请求前台位置权限（增强版）
+     */
+    async requestLocationPermission() {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            const result = await nativeModule.requestLocationPermission();
+            if (!result.granted) {
+                ErrorHandler_1.ErrorLogger.warn('前台位置权限未授予', result);
+            }
+            return result;
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '请求前台权限');
+        }
+    },
+    /**
+     * 请求后台位置权限
+     * 注意：必须在前台权限已授予后才能请求
+     */
+    async requestBackgroundLocationPermission() {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            const result = await nativeModule.requestBackgroundLocationPermission();
+            if (!result.granted) {
+                ErrorHandler_1.ErrorLogger.warn('后台位置权限未授予', result);
+            }
+            return result;
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '请求后台权限');
+        }
+    },
+    /**
+     * 打开应用设置页面
+     * 引导用户手动授予权限
+     */
+    openAppSettings() {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            nativeModule.openAppSettings();
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '打开设置');
+        }
+    },
+    setAllowsBackgroundLocationUpdates(allows) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        if (react_native_1.Platform.OS === 'ios' &&
+            allows &&
+            nativeModule &&
+            nativeModule.isBackgroundLocationEnabled === false) {
+            ErrorHandler_1.ErrorLogger.warn('⚠️ [ExpoGaodeMap] iOS 后台定位未正确配置，setAllowsBackgroundLocationUpdates(true) 可能不会生效，请检查 Info.plist 是否包含 UIBackgroundModes: location，或者在 app.json 中配置 enableBackgroundLocation: true，然后重新执行 npx expo prebuild');
+        }
+        if (react_native_1.Platform.OS === 'android' &&
+            allows &&
+            nativeModule &&
+            nativeModule.checkLocationPermission) {
+            nativeModule
+                .checkLocationPermission()
+                .then((status) => {
+                if (!status.backgroundLocation) {
+                    ErrorHandler_1.ErrorLogger.warn('⚠️ [ExpoGaodeMap] Android 后台位置权限未授予，setAllowsBackgroundLocationUpdates(true) 可能不会生效，请先通过 requestBackgroundLocationPermission 或系统设置授予后台定位权限,或者检查是否在 app.json 中配置了 enableBackgroundLocation: true，然后重新执行 npx expo prebuild');
+                }
+            })
+                .catch(() => {
+                // 忽略检查失败，只影响日志，不影响功能
+            });
+        }
+        nativeModule.setAllowsBackgroundLocationUpdates(allows);
     },
     /**
      * 添加定位监听器（便捷方法）
      * 自动订阅 onLocationUpdate 事件，提供容错处理
      * @param listener 定位回调函数
      * @returns 订阅对象，调用 remove() 取消监听
-     * @throws 如果底层模块不可用，返回一个空操作的订阅对象
+     * 注意：如果使用 Config Plugin 配置了 API Key，无需调用 initSDK()
      */
     addLocationListener(listener) {
-        var _a;
-        // 使用可选链和空值合并，确保即使模块不可用也不会崩溃
-        return ((_a = nativeModule === null || nativeModule === void 0 ? void 0 : nativeModule.addListener) === null || _a === void 0 ? void 0 : _a.call(nativeModule, 'onLocationUpdate', listener)) || {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        if (!nativeModule?.addListener) {
+            ErrorHandler_1.ErrorLogger.warn('Native module does not support events');
+        }
+        return nativeModule?.addListener?.('onLocationUpdate', listener) || {
             remove: () => { },
         };
     },
+    // ==================== 几何计算方法 ====================
+    /**
+     * 计算两个坐标点之间的距离
+     * @param coordinate1 第一个坐标点
+     * @param coordinate2 第二个坐标点
+     * @returns 两点之间的距离（单位：米）
+     */
+    distanceBetweenCoordinates(coordinate1, coordinate2) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return nativeModule.distanceBetweenCoordinates((0, GeoUtils_1.normalizeLatLng)(coordinate1), (0, GeoUtils_1.normalizeLatLng)(coordinate2));
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '计算距离');
+        }
+    },
+    /**
+     * 判断点是否在圆内
+     * @param point 要判断的点
+     * @param center 圆心坐标
+     * @param radius 圆半径（单位：米）
+     * @returns 是否在圆内
+     */
+    isPointInCircle(point, center, radius) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return nativeModule.isPointInCircle((0, GeoUtils_1.normalizeLatLng)(point), (0, GeoUtils_1.normalizeLatLng)(center), radius);
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '判断点是否在圆内');
+        }
+    },
+    /**
+     * 判断点是否在多边形内
+     * @param point 要判断的点
+     * @param polygon 多边形的顶点坐标数组
+     * @returns 是否在多边形内
+     */
+    isPointInPolygon(point, polygon) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return nativeModule.isPointInPolygon((0, GeoUtils_1.normalizeLatLng)(point), (0, GeoUtils_1.normalizeLatLngList)(polygon));
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '判断点是否在多边形内');
+        }
+    },
+    /**
+     * 计算多边形面积
+     * @param polygon 多边形的顶点坐标数组
+     * @returns 面积（单位：平方米）
+     */
+    calculatePolygonArea(polygon) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return nativeModule.calculatePolygonArea((0, GeoUtils_1.normalizeLatLngList)(polygon));
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '计算多边形面积');
+        }
+    },
+    /**
+     * 计算矩形面积
+     * @param southWest 西南角坐标
+     * @param northEast 东北角坐标
+     * @returns 面积（单位：平方米）
+     */
+    calculateRectangleArea(southWest, northEast) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return nativeModule.calculateRectangleArea((0, GeoUtils_1.normalizeLatLng)(southWest), (0, GeoUtils_1.normalizeLatLng)(northEast));
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '计算矩形面积');
+        }
+    },
+    /**
+     * 获取路径上距离目标点最近的点
+     * @param path 路径点集合
+     * @param target 目标点
+     * @returns 最近点信息，包含坐标、索引和距离
+     */
+    getNearestPointOnPath(path, target) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return nativeModule.getNearestPointOnPath((0, GeoUtils_1.normalizeLatLngList)(path), (0, GeoUtils_1.normalizeLatLng)(target));
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '获取最近点');
+        }
+    },
+    /**
+     * 计算多边形质心
+     * @param polygon 多边形顶点坐标数组
+     * @returns 质心坐标
+     */
+    calculateCentroid(polygon) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return nativeModule.calculateCentroid((0, GeoUtils_1.normalizeLatLngList)(polygon));
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '计算质心');
+        }
+    },
+    /**
+     * 计算路径边界和中心点
+     * @param points 路径点集合
+     * @returns 边界信息，包含 north, south, east, west 和 center
+     */
+    calculatePathBounds(points) {
+        if (!nativeModule)
+            return null;
+        try {
+            const normalized = (0, GeoUtils_1.normalizeLatLngList)(points);
+            if (normalized.length === 0)
+                return null;
+            return nativeModule.calculatePathBounds(normalized);
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('calculatePathBounds 失败', { pointsCount: points.length, error });
+            return null;
+        }
+    },
+    /**
+     * GeoHash 编码
+     * @param coordinate 坐标点
+     * @param precision 精度 (1-12)
+     * @returns GeoHash 字符串
+     */
+    encodeGeoHash(coordinate, precision) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return nativeModule.encodeGeoHash((0, GeoUtils_1.normalizeLatLng)(coordinate), precision);
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, 'GeoHash 编码');
+        }
+    },
+    /**
+     * 轨迹抽稀 (RDP 算法)
+     * @param points 原始轨迹点
+     * @param tolerance 允许误差(米)
+     * @returns 简化后的轨迹点
+     */
+    simplifyPolyline(points, tolerance) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return nativeModule.simplifyPolyline((0, GeoUtils_1.normalizeLatLngList)(points), tolerance);
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '轨迹抽稀');
+        }
+    },
+    /**
+     * 计算路径总长度
+     * @param points 路径点
+     * @returns 长度(米)
+     */
+    calculatePathLength(points) {
+        if (!nativeModule)
+            return 0;
+        try {
+            return nativeModule.calculatePathLength((0, GeoUtils_1.normalizeLatLngList)(points));
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('calculatePathLength 失败', { pointsCount: points.length, error });
+            return 0;
+        }
+    },
+    /**
+     * 解析高德地图 API 返回的 Polyline 字符串
+     * 格式: "lng,lat;lng,lat;..."
+     * @param polylineStr 高德原始 polyline 字符串，或包含 polyline 属性的对象
+     * @returns 解析后的点集
+     */
+    parsePolyline(polylineStr) {
+        if (!nativeModule || !polylineStr)
+            return [];
+        try {
+            // 兼容性处理：如果传入的是对象 { polyline: '...' }，自动提取字符串
+            let finalStr = '';
+            if (typeof polylineStr === 'object' && polylineStr !== null && 'polyline' in polylineStr) {
+                finalStr = polylineStr.polyline || '';
+            }
+            else if (typeof polylineStr === 'string') {
+                finalStr = polylineStr;
+            }
+            if (!finalStr)
+                return [];
+            return nativeModule.parsePolyline(finalStr);
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('解析 Polyline 失败', { polylineStr, error });
+            return [];
+        }
+    },
+    /**
+     * 获取路径上指定距离的点
+     * @param points 路径点
+     * @param distance 距离起点的米数
+     * @returns 点信息(坐标+角度)
+     */
+    getPointAtDistance(points, distance) {
+        if (!nativeModule) {
+            throw ErrorHandler_1.ErrorHandler.nativeModuleUnavailable();
+        }
+        try {
+            return nativeModule.getPointAtDistance((0, GeoUtils_1.normalizeLatLngList)(points), distance);
+        }
+        catch (error) {
+            throw ErrorHandler_1.ErrorHandler.wrapNativeError(error, '获取路径上的点');
+        }
+    },
+    /**
+     * 经纬度转换为地图瓦片坐标
+     * @param coordinate 经纬度点
+     * @param zoom 缩放级别
+     * @returns 瓦片坐标(x, y, z)
+     */
+    latLngToTile(coordinate, zoom) {
+        if (!nativeModule)
+            return null;
+        try {
+            return nativeModule.latLngToTile((0, GeoUtils_1.normalizeLatLng)(coordinate), zoom);
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('latLngToTile 失败', { coordinate, zoom, error });
+            return null;
+        }
+    },
+    /**
+     * 地图瓦片坐标转换为经纬度
+     * @param tile 瓦片坐标(x, y, z)
+     * @returns 经纬度点
+     */
+    tileToLatLng(tile) {
+        if (!nativeModule)
+            return null;
+        try {
+            return nativeModule.tileToLatLng(tile);
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('tileToLatLng 失败', { tile, error });
+            return null;
+        }
+    },
+    /**
+     * 经纬度转换为地图像素坐标
+     * @param coordinate 经纬度点
+     * @param zoom 缩放级别
+     * @returns 像素坐标(x, y)
+     */
+    latLngToPixel(coordinate, zoom) {
+        if (!nativeModule)
+            return null;
+        try {
+            return nativeModule.latLngToPixel((0, GeoUtils_1.normalizeLatLng)(coordinate), zoom);
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('latLngToPixel 失败', { coordinate, zoom, error });
+            return null;
+        }
+    },
+    /**
+     * 地图像素坐标转换为经纬度
+     * @param pixel 像素坐标(x, y)
+     * @param zoom 缩放级别
+     * @returns 经纬度点
+     */
+    pixelToLatLng(pixel, zoom) {
+        if (!nativeModule)
+            return null;
+        try {
+            return nativeModule.pixelToLatLng(pixel, zoom);
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('pixelToLatLng 失败', { pixel, zoom, error });
+            return null;
+        }
+    },
+    /**
+     * 批量地理围栏检测
+     * @param point 待检查的点
+     * @param polygons 多边形数组，格式为 LatLngPoint[][] 或 LatLngPoint[][][]
+     * @returns 包含点索引的数组（-1 表示不在任何多边形内）
+     */
+    findPointInPolygons(point, polygons) {
+        if (!nativeModule)
+            return -1;
+        try {
+            const normalizedPoint = (0, GeoUtils_1.normalizeLatLng)(point);
+            let normalizedPolygons;
+            // 处理三维数组 (LatLngPoint[][][]) 和二维数组 (LatLngPoint[][])
+            if (Array.isArray(polygons[0]) && Array.isArray(polygons[0][0])) {
+                // LatLngPoint[][][] -> 扁平化为 LatLngPoint[][] 用于 C++ 遍历
+                normalizedPolygons = polygons.reduce((acc, val) => acc.concat(val), []);
+            }
+            else {
+                normalizedPolygons = polygons;
+            }
+            const processedPolygons = normalizedPolygons.map(p => (0, GeoUtils_1.normalizeLatLngList)(p));
+            return nativeModule.findPointInPolygons(normalizedPoint, processedPolygons);
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('findPointInPolygons 失败', { point, error });
+            return -1;
+        }
+    },
+    /**
+     * 生成网格聚合数据 (常用于展示网格聚合图或大规模点数据处理)
+     * @param points 包含经纬度和权重的点数组
+     * @param gridSizeMeters 网格大小（米）
+     * @returns 包含经纬度和强度的网格点数组
+     */
+    generateHeatmapGrid(points, gridSizeMeters) {
+        if (!nativeModule || points.length === 0)
+            return [];
+        try {
+            return nativeModule.generateHeatmapGrid(points, gridSizeMeters);
+        }
+        catch (error) {
+            ErrorHandler_1.ErrorLogger.warn('generateHeatmapGrid 失败', { pointsCount: points.length, gridSizeMeters, error });
+            return [];
+        }
+    },
 };
 /**
 * 获取最近一次 initSDK 的配置
@@ -57,6 +625,6 @@ function getSDKConfig() {
 * 获取用于 Web API 的 webKey（若未初始化或未提供则返回 undefined）
 */
 function getWebKey() {
-    return _sdkConfig === null || _sdkConfig === void 0 ? void 0 : _sdkConfig.webKey;
+    return _sdkConfig?.webKey;
 }
 exports.default = ExpoGaodeMapModuleWithHelpers;