expo-gaode-map 2.2.8-next.0 → 2.2.8

package/build/utils/MapPreloader.js

@@ -1,742 +0,0 @@
-/**
- * 地图预加载管理器
- * 统一的预加载 API，自动选择原生或 JS 层预加载
- * - 如果原生预加载可用，优先使用原生方案（性能提升 60-80%）
- * - 否则回退到 JS 层预加载（性能提升 5-25%）
- */
-// 动态导入原生模块，避免在模块不可用时报错
-let NativeModule = null;
-try {
-    NativeModule = require('../ExpoGaodeMapModule').default;
-}
-catch (error) {
-    console.warn('[MapPreloader] 原生模块加载失败，将只使用 JS 层预加载');
-}
-/**
- * 地图预加载管理器类
- * 单例模式，管理地图实例的预加载
- */
-class MapPreloaderManager {
-    static instance;
-    preloadInstances = new Map();
-    config = {
-        poolSize: 1,
-        delay: 0,
-        enabled: true,
-        timeout: 15000, // 增加到 15 秒，给原生预加载更充足的时间
-        strategy: 'auto',
-        fallbackOnTimeout: true,
-        instanceTTL: 5 * 60 * 1000, // 默认 5 分钟过期
-    };
-    currentStrategy = 'js';
-    hybridNativeReady = false;
-    hybridJSReady = false;
-    nativePreloadAvailable = null;
-    preloadTimer = null;
-    listeners = new Set();
-    isPreloading = false;
-    activeCheckInterval = null;
-    activeTimeoutTimer = null;
-    // 性能统计
-    performanceMetrics = {
-        totalPreloads: 0,
-        successfulPreloads: 0,
-        failedPreloads: 0,
-        nativePreloads: 0,
-        jsPreloads: 0,
-        hybridPreloads: 0,
-        averageDuration: 0,
-        totalDuration: 0,
-        instancesUsed: 0,
-        instancesExpired: 0,
-    };
-    constructor() {
-        // 检测热重载，清理原生状态
-        this.detectAndHandleHotReload();
-        // 启动过期检查定时器（每分钟检查一次）
-        setInterval(() => {
-            this.cleanupExpiredInstances();
-        }, 60 * 1000);
-    }
-    /**
-     * 检测并处理热重载
-     */
-    detectAndHandleHotReload() {
-        if (NativeModule) {
-            try {
-                // 检查原生是否有残留的预加载状态
-                const status = NativeModule.getMapPreloadStatus();
-                if (status && status.isPreloading) {
-                    console.warn('[MapPreloader] 检测到热重载，清理原生预加载状态');
-                    // 清理原生池
-                    NativeModule.clearMapPreloadPool();
-                }
-            }
-            catch (error) {
-                // 忽略错误
-            }
-        }
-    }
-    /**
-     * 获取管理器单例实例
-     */
-    static getInstance() {
-        if (!MapPreloaderManager.instance) {
-            MapPreloaderManager.instance = new MapPreloaderManager();
-        }
-        return MapPreloaderManager.instance;
-    }
-    /**
-     * 配置预加载参数
-     * @param config 预加载配置
-     */
-    configure(config) {
-        this.config = {
-            ...this.config,
-            ...config,
-            strategy: config.strategy || 'auto',
-            fallbackOnTimeout: config.fallbackOnTimeout !== undefined ? config.fallbackOnTimeout : true,
-        };
-        // 重新检测策略
-        this.detectStrategy();
-    }
-    /**
-     * 检测并选择最优预加载策略
-     */
-    detectStrategy() {
-        if (this.config.strategy === 'js') {
-            this.currentStrategy = 'js';
-            console.log('[MapPreloader] 使用 JS 层预加载策略');
-            return;
-        }
-        if (this.config.strategy === 'native') {
-            this.currentStrategy = 'native';
-            console.log('[MapPreloader] 强制使用原生预加载策略');
-            return;
-        }
-        if (this.config.strategy === 'hybrid') {
-            this.currentStrategy = 'hybrid';
-            console.log('[MapPreloader] 使用混合预加载策略（原生 + JS 同时进行）');
-            return;
-        }
-        // auto 模式：自动检测
-        if (this.nativePreloadAvailable === null) {
-            this.nativePreloadAvailable = this.checkNativePreloadAvailable();
-        }
-        this.currentStrategy = this.nativePreloadAvailable ? 'native' : 'js';
-        console.log(`[MapPreloader] 自动选择策略: ${this.currentStrategy}`);
-    }
-    /**
-     * 检查原生预加载是否可用
-     */
-    checkNativePreloadAvailable() {
-        try {
-            // 检查原生模块是否存在预加载方法
-            return (NativeModule &&
-                typeof NativeModule?.startMapPreload === 'function' &&
-                typeof NativeModule?.getMapPreloadStatus === 'function');
-        }
-        catch (error) {
-            console.warn('[MapPreloader] 原生预加载不可用:', error);
-            return false;
-        }
-    }
-    /**
-     * 清理过期的预加载实例
-     */
-    cleanupExpiredInstances() {
-        const now = Date.now();
-        let expiredCount = 0;
-        // 使用 Array.from 避免 TypeScript downlevelIteration 错误
-        Array.from(this.preloadInstances.entries()).forEach(([id, instance]) => {
-            if (instance.status === 'ready' && now - instance.timestamp > this.config.instanceTTL) {
-                this.preloadInstances.delete(id);
-                expiredCount++;
-            }
-        });
-        if (expiredCount > 0) {
-            this.performanceMetrics.instancesExpired += expiredCount;
-            console.log(`[MapPreloader] 🧹 清理了 ${expiredCount} 个过期实例（总计: ${this.performanceMetrics.instancesExpired}）`);
-        }
-    }
-    /**
-     * 记录性能指标
-     */
-    recordPerformanceMetric(duration, success) {
-        this.performanceMetrics.totalPreloads++;
-        if (success) {
-            this.performanceMetrics.successfulPreloads++;
-            this.performanceMetrics.totalDuration += duration;
-            this.performanceMetrics.averageDuration =
-                this.performanceMetrics.totalDuration / this.performanceMetrics.successfulPreloads;
-            // 记录策略统计
-            if (this.currentStrategy === 'native') {
-                this.performanceMetrics.nativePreloads++;
-            }
-            else if (this.currentStrategy === 'js') {
-                this.performanceMetrics.jsPreloads++;
-            }
-            else if (this.currentStrategy === 'hybrid') {
-                this.performanceMetrics.hybridPreloads++;
-            }
-        }
-        else {
-            this.performanceMetrics.failedPreloads++;
-        }
-    }
-    /**
-     * 获取当前配置
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-    /**
-     * 开始预加载
-     * 根据配置和策略选择最优的预加载方式
-     */
-    startPreload() {
-        if (!this.config.enabled) {
-            console.log('[MapPreloader] 预加载已禁用');
-            return;
-        }
-        if (this.isPreloading) {
-            console.log('[MapPreloader] 预加载已在进行中');
-            return;
-        }
-        // 清理之前的定时器和检查
-        this.cleanupActiveTimers();
-        // 检测策略
-        this.detectStrategy();
-        // 清除之前的定时器
-        if (this.preloadTimer) {
-            clearTimeout(this.preloadTimer);
-        }
-        // 延迟执行预加载
-        this.preloadTimer = setTimeout(() => {
-            if (this.currentStrategy === 'hybrid') {
-                this.executeHybridPreload();
-            }
-            else if (this.currentStrategy === 'native') {
-                this.executeNativePreload();
-            }
-            else {
-                this.executeJSPreload();
-            }
-        }, this.config.delay);
-    }
-    /**
-     * 执行混合预加载（同时启动原生和 JS）
-     */
-    async executeHybridPreload() {
-        this.cleanupActiveTimers();
-        this.isPreloading = true;
-        this.hybridNativeReady = false;
-        this.hybridJSReady = false;
-        this.notifyListeners('loading');
-        console.log(`[MapPreloader] 🚀 开始混合预加载（原生 + JS 同时进行）`);
-        const startTime = Date.now();
-        // 同时启动原生和 JS 预加载
-        const nativePromise = this.executeHybridNativePreload(startTime).catch((error) => {
-            console.warn('[MapPreloader] 原生预加载失败:', error);
-            return null; // 原生失败不影响整体流程
-        });
-        const jsPromise = this.executeHybridJSPreload(startTime).catch((error) => {
-            console.warn('[MapPreloader] JS 预加载失败:', error);
-            return null; // JS 失败不影响整体流程
-        });
-        // 等待任意一个完成
-        try {
-            await Promise.race([nativePromise, jsPromise]);
-            // 确保至少有一个成功
-            if (!this.hybridNativeReady && !this.hybridJSReady) {
-                // 两者都失败了，等待另一个
-                await Promise.race([
-                    nativePromise.then(() => this.hybridNativeReady),
-                    jsPromise.then(() => this.hybridJSReady),
-                ]);
-            }
-            // 如果还是都没有完成，标记为错误
-            if (!this.hybridNativeReady && !this.hybridJSReady) {
-                throw new Error('原生和 JS 预加载都失败了');
-            }
-        }
-        catch (error) {
-            console.error('[MapPreloader] 混合预加载失败:', error);
-            this.isPreloading = false;
-            this.notifyListeners('error');
-        }
-    }
-    /**
-     * 混合模式下的原生预加载
-     */
-    async executeHybridNativePreload(startTime) {
-        if (!NativeModule) {
-            console.log('[MapPreloader] 原生模块不可用，跳过原生预加载');
-            return;
-        }
-        try {
-            // 清理原生池
-            await NativeModule.clearMapPreloadPool();
-            // 开始原生预加载
-            await NativeModule.startMapPreload({ poolSize: this.config.poolSize });
-            let consecutiveReadyCount = 0;
-            const REQUIRED_READY_COUNT = 2;
-            return new Promise((resolve, reject) => {
-                const checkInterval = setInterval(() => {
-                    // 如果 JS 已经完成，停止检查
-                    if (this.hybridJSReady) {
-                        clearInterval(checkInterval);
-                        console.log('[MapPreloader] JS 已完成，停止原生检查');
-                        resolve();
-                        return;
-                    }
-                    try {
-                        const status = NativeModule.getMapPreloadStatus();
-                        if (status && !status.isPreloading && status.poolSize > 0) {
-                            consecutiveReadyCount++;
-                            if (consecutiveReadyCount >= REQUIRED_READY_COUNT) {
-                                clearInterval(checkInterval);
-                                // 使用原子操作避免竞态条件
-                                if (!this.hybridNativeReady && !this.hybridJSReady) {
-                                    this.hybridNativeReady = true;
-                                    const duration = Date.now() - startTime;
-                                    // 延迟设置状态，确保状态变更的原子性
-                                    setTimeout(() => {
-                                        if (this.hybridNativeReady) { // 再次确认
-                                            this.isPreloading = false;
-                                            this.recordPerformanceMetric(duration, true);
-                                            this.notifyListeners('ready');
-                                            console.log(`[MapPreloader] ✅ 原生预加载先完成（耗时: ${duration}ms）`);
-                                        }
-                                    }, 0);
-                                    resolve();
-                                }
-                            }
-                        }
-                        else {
-                            consecutiveReadyCount = 0;
-                        }
-                    }
-                    catch (error) {
-                        clearInterval(checkInterval);
-                        console.warn('[MapPreloader] 原生预加载检查失败:', error);
-                        reject(error);
-                    }
-                }, 100);
-                // 超时处理
-                setTimeout(() => {
-                    if (!this.hybridNativeReady && !this.hybridJSReady) {
-                        clearInterval(checkInterval);
-                        console.warn('[MapPreloader] ⚠️ 原生预加载超时，等待 JS 完成');
-                    }
-                }, this.config.timeout);
-            });
-        }
-        catch (error) {
-            console.error('[MapPreloader] 原生预加载启动失败:', error);
-            throw error;
-        }
-    }
-    /**
-     * 混合模式下的 JS 预加载
-     */
-    async executeHybridJSPreload(startTime) {
-        // 创建预加载实例
-        for (let i = 0; i < this.config.poolSize; i++) {
-            const instanceId = `preload_hybrid_${Date.now()}_${i}`;
-            const instance = {
-                id: instanceId,
-                status: 'loading',
-                timestamp: Date.now(),
-            };
-            this.preloadInstances.set(instanceId, instance);
-        }
-        return new Promise((resolve) => {
-            setTimeout(() => {
-                // 如果原生已经完成，不需要通知
-                if (this.hybridNativeReady) {
-                    this.preloadInstances.forEach((instance) => {
-                        instance.status = 'ready';
-                    });
-                    console.log('[MapPreloader] JS 预加载完成（原生已先完成）');
-                    resolve();
-                    return;
-                }
-                // JS 先完成，使用原子操作
-                if (!this.hybridJSReady && !this.hybridNativeReady) {
-                    this.hybridJSReady = true;
-                    this.preloadInstances.forEach((instance) => {
-                        instance.status = 'ready';
-                    });
-                    const duration = Date.now() - startTime;
-                    // 延迟设置状态，确保状态变更的原子性
-                    setTimeout(() => {
-                        if (this.hybridJSReady) { // 再次确认
-                            this.isPreloading = false;
-                            this.recordPerformanceMetric(duration, true);
-                            this.notifyListeners('ready');
-                            console.log(`[MapPreloader] ✅ JS 预加载先完成（耗时: ${duration}ms）`);
-                        }
-                    }, 0);
-                }
-                resolve();
-            }, 100);
-        });
-    }
-    /**
-     * 清理活动的定时器
-     */
-    cleanupActiveTimers() {
-        if (this.activeCheckInterval) {
-            clearInterval(this.activeCheckInterval);
-            this.activeCheckInterval = null;
-        }
-        if (this.activeTimeoutTimer) {
-            clearTimeout(this.activeTimeoutTimer);
-            this.activeTimeoutTimer = null;
-        }
-    }
-    /**
-     * 执行原生预加载
-     */
-    async executeNativePreload() {
-        // 清理之前可能残留的定时器
-        this.cleanupActiveTimers();
-        this.isPreloading = true;
-        this.notifyListeners('loading');
-        console.log(`[MapPreloader] 开始原生预加载 ${this.config.poolSize} 个地图实例（超时: ${this.config.timeout}ms）`);
-        try {
-            const startTime = Date.now();
-            // 先清理原生池，避免热重载导致的状态不一致
-            try {
-                await NativeModule.clearMapPreloadPool();
-                console.log('[MapPreloader] 已清理原生预加载池');
-            }
-            catch (e) {
-                // 忽略清理错误
-            }
-            // 开始新的预加载
-            await NativeModule.startMapPreload({ poolSize: this.config.poolSize });
-            let consecutiveReadyCount = 0;
-            const REQUIRED_READY_COUNT = 2; // 减少到 2 次确认，提高响应速度
-            // 等待预加载完成
-            this.activeCheckInterval = setInterval(() => {
-                try {
-                    const status = NativeModule.getMapPreloadStatus();
-                    // 检查是否真正完成
-                    if (status && !status.isPreloading && status.poolSize > 0) {
-                        consecutiveReadyCount++;
-                        if (consecutiveReadyCount >= REQUIRED_READY_COUNT) {
-                            this.cleanupActiveTimers();
-                            const duration = Date.now() - startTime;
-                            this.isPreloading = false;
-                            this.recordPerformanceMetric(duration, true);
-                            this.notifyListeners('ready');
-                            console.log(`[MapPreloader] ✅ 原生预加载完成（耗时: ${duration}ms，池大小: ${status.poolSize}）`);
-                        }
-                    }
-                    else {
-                        consecutiveReadyCount = 0;
-                    }
-                }
-                catch (error) {
-                    this.cleanupActiveTimers();
-                    console.error('[MapPreloader] 原生预加载检查失败:', error);
-                    if (this.config.fallbackOnTimeout) {
-                        console.log('[MapPreloader] 回退到 JS 预加载');
-                        this.currentStrategy = 'js';
-                        this.executeJSPreload();
-                    }
-                    else {
-                        this.isPreloading = false;
-                        this.notifyListeners('error');
-                    }
-                }
-            }, 100);
-            // 超时处理
-            this.activeTimeoutTimer = setTimeout(() => {
-                if (this.isPreloading) {
-                    this.cleanupActiveTimers();
-                    const duration = Date.now() - startTime;
-                    // 最后检查一次
-                    try {
-                        const finalStatus = NativeModule.getMapPreloadStatus();
-                        if (finalStatus && !finalStatus.isPreloading && finalStatus.poolSize > 0) {
-                            this.isPreloading = false;
-                            this.notifyListeners('ready');
-                            console.log(`[MapPreloader] ✅ 原生预加载完成（耗时: ${duration}ms，接近超时）`);
-                            return;
-                        }
-                    }
-                    catch (e) {
-                        // 忽略
-                    }
-                    console.warn(`[MapPreloader] ⚠️ 原生预加载超时（${duration}ms > ${this.config.timeout}ms）`);
-                    console.warn('[MapPreloader] 💡 提示: 热重载可能导致原生状态不同步，建议重启应用');
-                    if (this.config.fallbackOnTimeout) {
-                        console.log('[MapPreloader] 自动回退到 JS 预加载');
-                        this.currentStrategy = 'js';
-                        this.executeJSPreload();
-                    }
-                    else {
-                        this.isPreloading = false;
-                        this.notifyListeners('error');
-                    }
-                }
-            }, this.config.timeout);
-        }
-        catch (error) {
-            this.cleanupActiveTimers();
-            console.error('[MapPreloader] 原生预加载启动失败:', error);
-            this.isPreloading = false;
-            this.notifyListeners('error');
-            if (this.config.fallbackOnTimeout) {
-                console.log('[MapPreloader] 回退到 JS 预加载');
-                this.currentStrategy = 'js';
-                this.executeJSPreload();
-            }
-        }
-    }
-    /**
-     * 执行 JS 层预加载逻辑
-     */
-    executeJSPreload() {
-        this.isPreloading = true;
-        this.notifyListeners('loading');
-        const startTime = Date.now();
-        console.log(`[MapPreloader] 开始 JS 层预加载 ${this.config.poolSize} 个地图实例`);
-        // 创建预加载实例
-        for (let i = 0; i < this.config.poolSize; i++) {
-            const instanceId = `preload_${Date.now()}_${i}`;
-            const instance = {
-                id: instanceId,
-                status: 'loading',
-                timestamp: Date.now(),
-            };
-            this.preloadInstances.set(instanceId, instance);
-        }
-        // 模拟预加载完成（实际场景中，这里会触发原生地图初始化）
-        setTimeout(() => {
-            this.preloadInstances.forEach((instance) => {
-                instance.status = 'ready';
-            });
-            this.isPreloading = false;
-            const duration = Date.now() - startTime;
-            this.recordPerformanceMetric(duration, true);
-            this.notifyListeners('ready');
-            console.log(`[MapPreloader] ✅ JS 层预加载完成（耗时: ${duration}ms）`);
-        }, 100);
-    }
-    /**
-     * 停止预加载
-     */
-    stopPreload() {
-        if (this.preloadTimer) {
-            clearTimeout(this.preloadTimer);
-            this.preloadTimer = null;
-        }
-        this.isPreloading = false;
-        this.notifyListeners('idle');
-    }
-    /**
-     * 清理所有预加载实例
-     */
-    clearPreloadedInstances() {
-        console.log(`[MapPreloader] 清理 ${this.preloadInstances.size} 个预加载实例`);
-        this.preloadInstances.clear();
-        this.isPreloading = false;
-        this.notifyListeners('idle');
-    }
-    /**
-     * 获取一个可用的预加载实例
-     * @returns 预加载实例 ID，如果没有可用实例则返回 null
-     */
-    getPreloadedInstance() {
-        const now = Date.now();
-        // 使用 Array.from 避免 TypeScript downlevelIteration 错误
-        for (const [id, instance] of Array.from(this.preloadInstances.entries())) {
-            if (instance.status === 'ready') {
-                // 检查是否过期
-                if (now - instance.timestamp > this.config.instanceTTL) {
-                    this.preloadInstances.delete(id);
-                    console.log(`[MapPreloader] 预加载实例已过期，已删除: ${id}`);
-                    continue;
-                }
-                // 标记为已使用（从池中移除）
-                this.preloadInstances.delete(id);
-                this.performanceMetrics.instancesUsed++;
-                console.log(`[MapPreloader] 使用预加载实例: ${id}，剩余: ${this.preloadInstances.size}，总使用: ${this.performanceMetrics.instancesUsed}`);
-                return id;
-            }
-        }
-        return null;
-    }
-    /**
-     * 获取预加载状态
-     */
-    getStatus() {
-        // 如果使用原生预加载，检查原生状态
-        if (this.currentStrategy === 'native') {
-            try {
-                const nativeStatus = NativeModule.getMapPreloadStatus();
-                if (nativeStatus.isPreloading) {
-                    return 'loading';
-                }
-                if (nativeStatus.poolSize > 0) {
-                    return 'ready';
-                }
-            }
-            catch (error) {
-                console.warn('[MapPreloader] 获取原生状态失败:', error);
-            }
-        }
-        // JS 层状态检查
-        if (this.isPreloading) {
-            return 'loading';
-        }
-        const hasReadyInstance = Array.from(this.preloadInstances.values()).some((instance) => instance.status === 'ready');
-        if (hasReadyInstance) {
-            return 'ready';
-        }
-        const hasError = Array.from(this.preloadInstances.values()).some((instance) => instance.status === 'error');
-        if (hasError) {
-            return 'error';
-        }
-        return 'idle';
-    }
-    /**
-     * 获取当前使用的预加载策略
-     */
-    getCurrentStrategy() {
-        return this.currentStrategy;
-    }
-    /**
-     * 检查原生预加载是否可用
-     */
-    isNativePreloadAvailable() {
-        if (this.nativePreloadAvailable === null) {
-            this.nativePreloadAvailable = this.checkNativePreloadAvailable();
-        }
-        return this.nativePreloadAvailable;
-    }
-    /**
-     * 获取性能统计信息
-     */
-    getPerformanceMetrics() {
-        return {
-            ...this.performanceMetrics,
-            successRate: this.performanceMetrics.totalPreloads > 0
-                ? (this.performanceMetrics.successfulPreloads / this.performanceMetrics.totalPreloads) * 100
-                : 0,
-        };
-    }
-    /**
-     * 获取预加载实例数量统计
-     */
-    getStats() {
-        // 混合模式：返回综合统计
-        if (this.currentStrategy === 'hybrid') {
-            const jsInstances = Array.from(this.preloadInstances.values());
-            let nativePoolSize = 0;
-            try {
-                const nativeStatus = NativeModule.getMapPreloadStatus();
-                nativePoolSize = nativeStatus.poolSize;
-            }
-            catch (error) {
-                // 忽略
-            }
-            return {
-                total: Math.max(jsInstances.length, nativePoolSize),
-                ready: this.hybridNativeReady || this.hybridJSReady ? 1 : 0,
-                loading: !this.hybridNativeReady && !this.hybridJSReady ? 1 : 0,
-                error: 0,
-                strategy: 'hybrid',
-            };
-        }
-        // 如果使用原生预加载，返回原生统计
-        if (this.currentStrategy === 'native') {
-            try {
-                const nativeStatus = NativeModule.getMapPreloadStatus();
-                return {
-                    total: nativeStatus.poolSize,
-                    ready: nativeStatus.isPreloading ? 0 : nativeStatus.poolSize,
-                    loading: nativeStatus.isPreloading ? nativeStatus.poolSize : 0,
-                    error: 0,
-                    strategy: 'native',
-                };
-            }
-            catch (error) {
-                console.warn('[MapPreloader] 获取原生统计失败:', error);
-            }
-        }
-        // JS 层统计
-        const instances = Array.from(this.preloadInstances.values());
-        return {
-            total: instances.length,
-            ready: instances.filter((i) => i.status === 'ready').length,
-            loading: instances.filter((i) => i.status === 'loading').length,
-            error: instances.filter((i) => i.status === 'error').length,
-            strategy: 'js',
-        };
-    }
-    /**
-     * 添加状态监听器
-     * @param listener 状态变化回调函数
-     * @returns 取消监听的函数
-     */
-    addListener(listener) {
-        this.listeners.add(listener);
-        return () => {
-            this.listeners.delete(listener);
-        };
-    }
-    /**
-     * 通知所有监听器状态变化
-     */
-    notifyListeners(status) {
-        this.listeners.forEach((listener) => {
-            try {
-                listener(status);
-            }
-            catch (error) {
-                console.error('[MapPreloader] 监听器执行错误:', error);
-            }
-        });
-    }
-    /**
-     * 重置管理器状态
-     */
-    reset() {
-        this.stopPreload();
-        this.clearPreloadedInstances();
-        this.listeners.clear();
-        console.log('[MapPreloader] 管理器已重置');
-    }
-}
-/**
- * 导出单例实例
- */
-export const MapPreloader = MapPreloaderManager.getInstance();
-/**
- * 便捷函数：配置并启动预加载
- * @param config 预加载配置
- */
-export function preloadMap(config) {
-    if (config) {
-        MapPreloader.configure(config);
-    }
-    MapPreloader.startPreload();
-}
-/**
- * 便捷函数：获取预加载状态
- */
-export function getPreloadStatus() {
-    return MapPreloader.getStatus();
-}
-/**
- * 便捷函数：清理预加载实例
- */
-export function clearPreloadedMaps() {
-    MapPreloader.clearPreloadedInstances();
-}
-//# sourceMappingURL=MapPreloader.js.map