expo-gaode-map 2.2.32 → 2.2.33

package/build/ExpoGaodeMapModule.js

@@ -1,148 +1,9 @@
-import { requireNativeModule } from 'expo';
-import { Platform } from 'react-native';
-import { CoordinateType, } from './types';
-import { ErrorHandler, ErrorLogger } from './utils/ErrorHandler';
-import { normalizeLatLng, normalizeLatLngList } from './utils/GeoUtils';
-let nativeModuleCache = null;
-function normalizeCoordinateType(type) {
-    switch (type) {
-        case CoordinateType.AMap:
-            return null;
-        case CoordinateType.MapBar:
-            return 1;
-        case CoordinateType.Baidu:
-            return 2;
-        case CoordinateType.MapABC:
-        case CoordinateType.SoSoMap:
-            return 3;
-        case CoordinateType.Google:
-        case CoordinateType.GPS:
-            return 0;
-        default:
-            throw ErrorHandler.invalidParameter('type', 'CoordinateType.AMap | MapBar | Baidu | MapABC | SoSoMap | Google | GPS', type);
-    }
-}
-function normalizeGeoLanguage(language) {
-    const normalized = String(language).trim().toUpperCase();
-    switch (normalized) {
-        case 'DEFAULT':
-            return 'DEFAULT';
-        case 'EN':
-        case 'EN-US':
-        case 'EN_US':
-        case 'EN-GB':
-        case 'EN_GB':
-            return 'EN';
-        case 'ZH':
-        case 'ZH-CN':
-        case 'ZH_CN':
-        case 'ZH-HANS':
-        case 'ZH_HANS':
-            return 'ZH';
-        default:
-            throw ErrorHandler.invalidParameter('language', "'DEFAULT' | 'EN' | 'ZH' | 常见别名（如 'en', 'zh-CN'）", language);
-    }
-}
-function normalizeLocationResult(location) {
-    const rawLocation = location;
-    const heading = rawLocation.heading ?? rawLocation.bearing ?? 0;
-    return {
-        ...rawLocation,
-        heading,
-    };
-}
-function normalizeHeadingEvent(payload) {
-    const raw = payload;
-    const fallbackHeading = Number(raw.heading ?? raw.trueHeading ?? raw.magneticHeading ?? 0);
-    const fallbackAccuracy = Number(raw.accuracy ?? raw.headingAccuracy ?? 0);
-    return {
-        magneticHeading: Number(raw.magneticHeading ?? fallbackHeading),
-        trueHeading: Number(raw.trueHeading ?? fallbackHeading),
-        headingAccuracy: fallbackAccuracy,
-        x: Number(raw.x ?? 0),
-        y: Number(raw.y ?? 0),
-        z: Number(raw.z ?? 0),
-        timestamp: Number(raw.timestamp ?? Date.now()),
-    };
-}
-function normalizePermissionStatus(permission) {
-    const raw = permission;
-    const rawStatus = String(raw.status ?? '');
-    let status;
-    switch (rawStatus) {
-        case 'granted':
-        case 'authorizedAlways':
-        case 'authorizedWhenInUse':
-            status = 'granted';
-            break;
-        case 'denied':
-        case 'restricted':
-            status = 'denied';
-            break;
-        case 'notDetermined':
-        case 'undetermined':
-        case 'unknown':
-        case '':
-        default:
-            status = 'undetermined';
-            break;
-    }
-    const granted = Boolean(raw.granted ?? (status === 'granted'));
-    const shouldShowRationale = typeof raw.shouldShowRationale === 'boolean' ? raw.shouldShowRationale : undefined;
-    const explicitPermanent = typeof raw.isPermanentlyDenied === 'boolean' ? raw.isPermanentlyDenied : undefined;
-    const canAskAgain = typeof raw.canAskAgain === 'boolean'
-        ? raw.canAskAgain
-        : granted
-            ? true
-            : typeof shouldShowRationale === 'boolean'
-                ? shouldShowRationale
-                : explicitPermanent === true
-                    ? false
-                    : status === 'undetermined';
-    const isPermanentlyDenied = explicitPermanent ??
-        (!granted && status === 'denied' && canAskAgain === false);
-    return {
-        ...raw,
-        expires: raw.expires ?? 'never',
-        granted,
-        status: status,
-        canAskAgain,
-        isPermanentlyDenied,
-    };
-}
-function getNativeModule(optional = false) {
-    if (nativeModuleCache) {
-        return nativeModuleCache;
-    }
-    try {
-        nativeModuleCache = requireNativeModule('ExpoGaodeMap');
-        return nativeModuleCache;
-    }
-    catch (error) {
-        if (optional) {
-            return null;
-        }
-        const moduleError = ErrorHandler.nativeModuleUnavailable();
-        ErrorLogger.log(moduleError);
-        throw moduleError;
-    }
-}
-function getBoundNativeValue(module, prop) {
-    const value = Reflect.get(module, prop, module);
-    if (typeof value === 'function') {
-        return (...args) => value.apply(module, args);
-    }
-    return value;
-}
-const nativeModule = new Proxy({}, {
-    get(_target, prop) {
-        const module = getNativeModule(true);
-        return module ? getBoundNativeValue(module, prop) : undefined;
-    },
-});
-// 记录最近一次 initSDK 的配置（含 webKey）
-let _sdkConfig = null;
-let _isSDKInitialized = false;
+import { getBoundNativeValue, getNativeModule } from './module/nativeModule';
+import { assertPrivacyReady, privacyMethods } from './module/privacy';
+import { sdkMethods, getSDKConfig, getWebKey } from './module/sdk';
+import { locationMethods } from './module/location';
+import { geometryMethods } from './module/geometry';
+export { getSDKConfig, getWebKey };
 const privacySensitiveMethodNames = new Set([
     'start',
     'stop',
@@ -174,770 +35,24 @@ const privacySensitiveMethodNames = new Set([
     'requestBackgroundLocationPermission',
     'addLocationListener',
 ]);
-function assertPrivacyReady(scene = 'sdk') {
-    const nativeModule = getNativeModule();
-    if (!nativeModule) {
-        throw ErrorHandler.nativeModuleUnavailable();
-    }
-    const status = nativeModule.getPrivacyStatus();
-    if (!status.isReady) {
-        throw ErrorHandler.privacyNotAgreed(scene);
-    }
-}
-// 扩展原生模块，添加便捷方法
-const helperMethods = {
-    /**
-     * 初始化 SDK，并缓存配置（包含 webKey）
-     * 注意：允许不提供任何 API Key，因为原生端可能已通过 Config Plugin 配置
-     */
-    initSDK(config) {
-        const nativeModule = getNativeModule();
-        if (!nativeModule)
-            throw ErrorHandler.nativeModuleUnavailable();
-        try {
-            const privacyStatus = nativeModule.getPrivacyStatus();
-            if (!privacyStatus.isReady) {
-                throw ErrorHandler.privacyNotAgreed('sdk');
-            }
-            // 检查是否有任何 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.invalidApiKey('both');
-                }
-                // 如果原生已配置,或者只提供了 webKey,继续初始化
-                ErrorLogger.warn(isNativeConfigured
-                    ? 'SDK 使用原生端配置的 API Key'
-                    : 'SDK 初始化仅使用 webKey', { config });
-            }
-            _sdkConfig = config ?? null;
-            nativeModule.initSDK(config);
-            _isSDKInitialized = true;
-            ErrorLogger.warn('SDK 初始化成功', { config });
-        }
-        catch (error) {
-            _isSDKInitialized = false;
-            throw ErrorHandler.wrapNativeError(error, 'SDK 初始化');
-        }
-    },
-    isSDKInitialized() {
-        return _isSDKInitialized;
-    },
-    /**
-     * 设置是否显示隐私政策弹窗
-     * @deprecated 请优先使用 `setPrivacyConfig`
-     */
-    setPrivacyShow(hasShow, hasContainsPrivacy) {
-        const nativeModule = getNativeModule();
-        if (!nativeModule)
-            throw ErrorHandler.nativeModuleUnavailable();
-        nativeModule.setPrivacyShow(hasShow, hasContainsPrivacy ?? hasShow);
-    },
-    /**
-     * 设置用户是否同意隐私政策
-     * @deprecated 请优先使用 `setPrivacyConfig`
-     */
-    setPrivacyAgree(hasAgree) {
-        const nativeModule = getNativeModule();
-        if (!nativeModule)
-            throw ErrorHandler.nativeModuleUnavailable();
-        nativeModule.setPrivacyAgree(hasAgree);
-    },
-    /**
-     * 设置当前隐私协议版本
-     * 当版本号变化时，之前的同意状态会失效
-     */
-    setPrivacyVersion(version) {
-        const nativeModule = getNativeModule();
-        if (!nativeModule)
-            throw ErrorHandler.nativeModuleUnavailable();
-        nativeModule.setPrivacyVersion(version);
-    },
-    /**
-     * 清空已持久化的隐私同意状态
-     */
-    resetPrivacyConsent() {
-        const nativeModule = getNativeModule();
-        if (!nativeModule)
-            throw ErrorHandler.nativeModuleUnavailable();
-        nativeModule.resetPrivacyConsent();
-    },
-    /**
-     * 一次性同步完整的隐私状态
-     * 推荐业务层只调用这个方法
-     */
-    setPrivacyConfig(config) {
-        const nativeModule = getNativeModule();
-        if (!nativeModule)
-            throw ErrorHandler.nativeModuleUnavailable();
-        if (typeof config.privacyVersion === 'string') {
-            nativeModule.setPrivacyVersion(config.privacyVersion);
-        }
-        nativeModule.setPrivacyShow(config.hasShow, config.hasContainsPrivacy ?? config.hasShow);
-        nativeModule.setPrivacyAgree(config.hasAgree);
-    },
-    getPrivacyStatus() {
-        const nativeModule = getNativeModule();
-        if (!nativeModule) {
-            return {
-                hasShow: false,
-                hasContainsPrivacy: false,
-                hasAgree: false,
-                isReady: false,
-                privacyVersion: null,
-                agreedPrivacyVersion: null,
-                restoredFromStorage: false,
-            };
-        }
-        return nativeModule.getPrivacyStatus();
-    },
-    calculateDistanceBetweenPoints(p1, p2) {
-        const nativeModule = getNativeModule();
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        return nativeModule.distanceBetweenCoordinates(normalizeLatLng(p1), normalizeLatLng(p2));
-    },
-    calculateDistance(lat1, lon1, lat2, lon2) {
-        const nativeModule = getNativeModule();
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        return nativeModule.distanceBetweenCoordinates({ latitude: lat1, longitude: lon1 }, { latitude: lat2, longitude: lon2 });
-    },
-    setLoadWorldVectorMap(enabled) {
-        const nativeModule = getNativeModule(true);
-        if (!nativeModule)
-            return;
-        try {
-            nativeModule.setLoadWorldVectorMap(enabled);
-        }
-        catch (error) {
-            ErrorLogger.warn('setLoadWorldVectorMap 失败', { enabled, error });
-        }
-    },
-    getVersion() {
-        const nativeModule = getNativeModule(true);
-        if (!nativeModule)
-            return '0.0.0';
-        try {
-            return nativeModule.getVersion();
-        }
-        catch (error) {
-            ErrorLogger.warn('getVersion 失败', { error });
-            return '0.0.0';
-        }
-    },
-    start() {
-        assertPrivacyReady('sdk');
-        const nativeModule = getNativeModule(true);
-        if (!nativeModule)
-            return;
-        try {
-            nativeModule.start();
-        }
-        catch (error) {
-            ErrorLogger.warn('start 失败', { error });
-        }
-    },
-    stop() {
-        assertPrivacyReady('sdk');
-        const nativeModule = getNativeModule(true);
-        if (!nativeModule)
-            return;
-        try {
-            nativeModule.stop();
-        }
-        catch (error) {
-            ErrorLogger.warn('stop 失败', { error });
-        }
-    },
-    isStarted() {
-        assertPrivacyReady('sdk');
-        const nativeModule = getNativeModule(true);
-        if (!nativeModule)
-            return Promise.resolve(false);
-        try {
-            return nativeModule.isStarted();
-        }
-        catch (error) {
-            ErrorLogger.warn('isStarted 失败', { error });
-            return Promise.resolve(false);
-        }
-    },
-    async getCurrentLocation() {
-        assertPrivacyReady('sdk');
-        const nativeModule = getNativeModule();
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            const location = await nativeModule.getCurrentLocation();
-            return normalizeLocationResult(location);
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '获取当前位置');
-        }
-    },
-    async coordinateConvert(coordinate, type) {
-        assertPrivacyReady('sdk');
-        const nativeModule = getNativeModule();
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            const normalizedCoordinate = normalizeLatLng(coordinate);
-            const normalizedType = normalizeCoordinateType(type);
-            if (normalizedType === null) {
-                return normalizedCoordinate;
-            }
-            return await nativeModule.coordinateConvert(normalizedCoordinate, normalizedType);
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '坐标转换');
-        }
-    },
-    setGeoLanguage(language) {
-        assertPrivacyReady('sdk');
-        const nativeModule = getNativeModule(true);
-        if (!nativeModule)
-            return;
-        try {
-            nativeModule.setGeoLanguage(normalizeGeoLanguage(language));
-        }
-        catch (error) {
-            ErrorLogger.warn('setGeoLanguage 失败', { language, error });
-        }
-    },
-    setLocatingWithReGeocode(isReGeocode) {
-        assertPrivacyReady('sdk');
-        const nativeModule = getNativeModule(true);
-        if (!nativeModule)
-            return;
-        try {
-            nativeModule.setLocatingWithReGeocode(isReGeocode);
-        }
-        catch (error) {
-            ErrorLogger.warn('setLocatingWithReGeocode 失败', { isReGeocode, error });
-        }
-    },
-    get isBackgroundLocationEnabled() {
-        const nativeModule = getNativeModule(true);
-        if (!nativeModule)
-            return false;
-        return nativeModule.isBackgroundLocationEnabled === true;
-    },
-    /**
-     * 检查位置权限状态
-     */
-    async checkLocationPermission() {
-        assertPrivacyReady('sdk');
-        const nativeModule = getNativeModule();
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            return normalizePermissionStatus(await nativeModule.checkLocationPermission());
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '检查权限');
-        }
-    },
-    /**
-     * 请求前台位置权限（增强版）
-     */
-    async requestLocationPermission() {
-        assertPrivacyReady('sdk');
-        const nativeModule = getNativeModule();
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            const result = normalizePermissionStatus(await nativeModule.requestLocationPermission());
-            if (!result.granted) {
-                ErrorLogger.warn('前台位置权限未授予', result);
-            }
-            return result;
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '请求前台权限');
-        }
-    },
-    /**
-     * 请求后台位置权限
-     * 注意：必须在前台权限已授予后才能请求
-     */
-    async requestBackgroundLocationPermission() {
-        assertPrivacyReady('sdk');
-        const nativeModule = getNativeModule();
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            const result = normalizePermissionStatus(await nativeModule.requestBackgroundLocationPermission());
-            if (!result.granted) {
-                ErrorLogger.warn('后台位置权限未授予', result);
-            }
-            return result;
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '请求后台权限');
-        }
-    },
-    /**
-     * 打开应用设置页面
-     * 引导用户手动授予权限
-     */
-    openAppSettings() {
-        const nativeModule = getNativeModule();
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            nativeModule.openAppSettings();
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '打开设置');
-        }
-    },
-    setAllowsBackgroundLocationUpdates(allows) {
-        assertPrivacyReady('sdk');
-        const nativeModule = getNativeModule();
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        if (Platform.OS === 'ios' &&
-            allows &&
-            nativeModule &&
-            nativeModule.isBackgroundLocationEnabled === false) {
-            ErrorLogger.warn('⚠️ [ExpoGaodeMap] iOS 后台定位未正确配置，setAllowsBackgroundLocationUpdates(true) 可能不会生效，请检查 Info.plist 是否包含 UIBackgroundModes: location，或者在 app.json 中配置 enableBackgroundLocation: true，然后重新执行 npx expo prebuild');
-        }
-        if (Platform.OS === 'android' &&
-            allows &&
-            nativeModule &&
-            nativeModule.checkLocationPermission) {
-            nativeModule
-                .checkLocationPermission()
-                .then((status) => {
-                if (!status.backgroundLocation) {
-                    ErrorLogger.warn('⚠️ [ExpoGaodeMap] Android 后台位置权限未授予，setAllowsBackgroundLocationUpdates(true) 可能不会生效，请先通过 requestBackgroundLocationPermission 或系统设置授予后台定位权限,或者检查是否在 app.json 中配置了 enableBackgroundLocation: true，然后重新执行 npx expo prebuild');
-                }
-            })
-                .catch(() => {
-                // 忽略检查失败，只影响日志，不影响功能
-            });
-        }
-        nativeModule.setAllowsBackgroundLocationUpdates(allows);
-    },
-    /**
-     * 添加定位监听器（便捷方法）
-     * 自动订阅 onLocationUpdate 事件，提供容错处理
-     * @param listener 定位回调函数
-     * @returns 订阅对象，调用 remove() 取消监听
-     * 注意：如果使用 Config Plugin 配置了 API Key，无需调用 initSDK()
-     */
-    addLocationListener(listener) {
-        assertPrivacyReady('sdk');
-        const module = getNativeModule();
-        if (!module) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        if (!module.addListener) {
-            ErrorLogger.warn('Native module does not support events');
-            return {
-                remove: () => { },
-            };
-        }
-        return module.addListener('onLocationUpdate', (location) => {
-            listener(normalizeLocationResult(location));
-        }) || {
-            remove: () => { },
-        };
-    },
-    /**
-     * 添加方向监听器（iOS）
-     * 自动归一化 heading 事件字段，兼容旧版原生返回结构
-     */
-    addHeadingListener(listener) {
-        assertPrivacyReady('sdk');
-        const module = getNativeModule();
-        if (!module) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        if (!module.addListener) {
-            ErrorLogger.warn('Native module does not support events');
-            return {
-                remove: () => { },
-            };
-        }
-        return module.addListener('onHeadingUpdate', (heading) => {
-            listener(normalizeHeadingEvent(heading));
-        }) || {
-            remove: () => { },
-        };
-    },
-    // ==================== 几何计算方法 ====================
-    /**
-     * 计算两个坐标点之间的距离
-     * @param coordinate1 第一个坐标点
-     * @param coordinate2 第二个坐标点
-     * @returns 两点之间的距离（单位：米）
-     */
-    distanceBetweenCoordinates(coordinate1, coordinate2) {
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            return nativeModule.distanceBetweenCoordinates(normalizeLatLng(coordinate1), normalizeLatLng(coordinate2));
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '计算距离');
-        }
-    },
-    /**
-     * 判断点是否在圆内
-     * @param point 要判断的点
-     * @param center 圆心坐标
-     * @param radius 圆半径（单位：米）
-     * @returns 是否在圆内
-     */
-    isPointInCircle(point, center, radius) {
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            return nativeModule.isPointInCircle(normalizeLatLng(point), normalizeLatLng(center), radius);
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '判断点是否在圆内');
-        }
-    },
-    /**
-     * 判断点是否在多边形内
-     * @param point 要判断的点
-     * @param polygon 多边形的顶点坐标数组，支持嵌套数组（多边形空洞）
-     * @returns 是否在多边形内
-     */
-    isPointInPolygon(point, polygon) {
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            return nativeModule.isPointInPolygon(normalizeLatLng(point), normalizeLatLngList(polygon));
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '判断点是否在多边形内');
-        }
-    },
-    /**
-     * 计算多边形面积
-     * @param polygon 多边形的顶点坐标数组，支持嵌套数组（多边形空洞）
-     * @returns 面积（单位：平方米）
-     */
-    calculatePolygonArea(polygon) {
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            return nativeModule.calculatePolygonArea(normalizeLatLngList(polygon));
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '计算多边形面积');
-        }
-    },
-    /**
-     * 计算矩形面积
-     * @param southWest 西南角坐标
-     * @param northEast 东北角坐标
-     * @returns 面积（单位：平方米）
-     */
-    calculateRectangleArea(southWest, northEast) {
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            return nativeModule.calculateRectangleArea(normalizeLatLng(southWest), normalizeLatLng(northEast));
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '计算矩形面积');
-        }
-    },
-    /**
-     * 获取路径上距离目标点最近的点
-     * @param path 路径点集合
-     * @param target 目标点
-     * @returns 最近点信息，包含坐标、索引和距离
-     */
-    getNearestPointOnPath(path, target) {
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            return nativeModule.getNearestPointOnPath(normalizeLatLngList(path), normalizeLatLng(target));
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '获取最近点');
-        }
-    },
-    /**
-     * 计算多边形质心
-     * @param polygon 多边形顶点坐标数组
-     * @returns 质心坐标
-     */
-    calculateCentroid(polygon) {
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            return nativeModule.calculateCentroid(normalizeLatLngList(polygon));
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '计算质心');
-        }
-    },
-    /**
-     * 计算路径边界和中心点
-     * @param points 路径点集合
-     * @returns 边界信息，包含 north, south, east, west 和 center
-     */
-    calculatePathBounds(points) {
-        if (!nativeModule)
-            return null;
-        try {
-            const normalized = normalizeLatLngList(points);
-            if (normalized.length === 0)
-                return null;
-            return nativeModule.calculatePathBounds(normalized);
-        }
-        catch (error) {
-            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.nativeModuleUnavailable();
-        }
-        try {
-            return nativeModule.encodeGeoHash(normalizeLatLng(coordinate), precision);
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, 'GeoHash 编码');
-        }
-    },
-    /**
-     * 轨迹抽稀 (RDP 算法)
-     * @param points 原始轨迹点
-     * @param tolerance 允许误差(米)
-     * @returns 简化后的轨迹点
-     */
-    simplifyPolyline(points, tolerance) {
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            return nativeModule.simplifyPolyline(normalizeLatLngList(points), tolerance);
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '轨迹抽稀');
-        }
-    },
-    /**
-     * 计算路径总长度
-     * @param points 路径点
-     * @returns 长度(米)
-     */
-    calculatePathLength(points) {
-        if (!nativeModule)
-            return 0;
-        try {
-            return nativeModule.calculatePathLength(normalizeLatLngList(points));
-        }
-        catch (error) {
-            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) {
-            ErrorLogger.warn('解析 Polyline 失败', { polylineStr, error });
-            return [];
-        }
-    },
-    /**
-     * 获取路径上指定距离的点
-     * @param points 路径点
-     * @param distance 距离起点的米数
-     * @returns 点信息(坐标+角度)
-     */
-    getPointAtDistance(points, distance) {
-        if (!nativeModule) {
-            throw ErrorHandler.nativeModuleUnavailable();
-        }
-        try {
-            return nativeModule.getPointAtDistance(normalizeLatLngList(points), distance);
-        }
-        catch (error) {
-            throw ErrorHandler.wrapNativeError(error, '获取路径上的点');
-        }
-    },
-    /**
-     * 经纬度转换为地图瓦片坐标
-     * @param coordinate 经纬度点
-     * @param zoom 缩放级别
-     * @returns 瓦片坐标(x, y, z)
-     */
-    latLngToTile(coordinate, zoom) {
-        if (!nativeModule)
-            return null;
-        try {
-            return nativeModule.latLngToTile(normalizeLatLng(coordinate), zoom);
-        }
-        catch (error) {
-            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) {
-            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(normalizeLatLng(coordinate), zoom);
-        }
-        catch (error) {
-            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) {
-            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 = normalizeLatLng(point);
-            // 处理三维数组 (LatLngPoint[][][]) 和二维数组 (LatLngPoint[][])
-            if (Array.isArray(polygons[0]) && Array.isArray(polygons[0][0])) {
-                const normalizedMultiPolygons = polygons.map((polygonRings) => normalizeLatLngList(polygonRings));
-                for (let index = 0; index < normalizedMultiPolygons.length; index += 1) {
-                    if (nativeModule.isPointInPolygon(normalizedPoint, normalizedMultiPolygons[index])) {
-                        return index;
-                    }
-                }
-                return -1;
-            }
-            const normalizedPolygons = polygons;
-            const processedPolygons = normalizedPolygons.map((p) => normalizeLatLngList(p));
-            return nativeModule.findPointInPolygons(normalizedPoint, processedPolygons);
-        }
-        catch (error) {
-            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) {
-            ErrorLogger.warn('generateHeatmapGrid 失败', { pointsCount: points.length, gridSizeMeters, error });
-            return [];
-        }
-    },
-};
-/**
-* 获取最近一次 initSDK 的配置
-*/
-export function getSDKConfig() {
-    return _sdkConfig;
-}
-;
+const helperMethods = Object.defineProperties({}, {
+    ...Object.getOwnPropertyDescriptors(sdkMethods),
+    ...Object.getOwnPropertyDescriptors(privacyMethods),
+    ...Object.getOwnPropertyDescriptors(locationMethods),
+    ...Object.getOwnPropertyDescriptors(geometryMethods),
+});
+const hiddenNativeMethodNames = new Set([
+    'setPrivacyShow',
+    'setPrivacyAgree',
+]);
 const ExpoGaodeMapModuleWithHelpers = new Proxy(helperMethods, {
     get(target, prop, receiver) {
         if (Reflect.has(target, prop)) {
             return Reflect.get(target, prop, receiver);
         }
+        if (hiddenNativeMethodNames.has(prop)) {
+            return undefined;
+        }
         const nativeModule = getNativeModule(true);
         if (!nativeModule) {
             return undefined;
@@ -954,11 +69,5 @@ const ExpoGaodeMapModuleWithHelpers = new Proxy(helperMethods, {
         return getBoundNativeValue(nativeModule, prop);
     },
 });
-/**
-* 获取用于 Web API 的 webKey（若未初始化或未提供则返回 undefined）
-*/
-export function getWebKey() {
-    return _sdkConfig?.webKey;
-}
 export default ExpoGaodeMapModuleWithHelpers;
 //# sourceMappingURL=ExpoGaodeMapModule.js.map