my-openlayer 1.0.14 → 2.0.0

package/MyOl.js

@@ -1,382 +1,381 @@
-"use strict";
-// OpenLayers 核心导入
-import { register as olProj4Register } from 'ol/proj/proj4';
-import { Projection as olProjProjection, addProjection as olProjAddProjection, fromLonLat as olProjFromLonLat } from 'ol/proj';
-import View from "ol/View";
-import Map from "ol/Map";
-import { defaults as defaultControls } from 'ol/control';
-import proj4 from "proj4";
-// 内部模块导入
-import Polygon from "./core/Polygon";
-import Point from "./core/Point";
-import Line from "./core/Line";
-import MapBaseLayers from "./core/MapBaseLayers";
-import MapTools from "./core/MapTools";
-import { ErrorHandler, MyOpenLayersError, ErrorType } from './utils/ErrorHandler';
-import { EventManager } from './core/EventManager';
-import { ConfigManager } from './core/ConfigManager';
-/**
- * MyOl 地图核心类
- * 提供完整的地图操作功能，包括点、线、面要素管理，底图切换，工具操作等
- */
-class MyOl {
-    /**
-     * 构造函数
-     * @param id 地图容器 DOM 元素 ID
-     * @param options 地图初始化配置
-     */
-    constructor(id, options) {
-        // 初始化错误处理器（必须最先初始化）
-        this.errorHandler = ErrorHandler.getInstance();
-        try {
-            // 初始化配置管理器
-            this.configManager = new ConfigManager();
-            // 合并配置（处理 undefined 情况）
-            this.options = ConfigManager.mergeOptions(MyOl.DefaultOptions, options || {});
-            // 参数验证
-            this.validateConstructorParams(id, this.options);
-            // 初始化坐标系
-            MyOl.initializeProjections();
-            // 准备图层
-            const layers = Array.isArray(this.options.layers) ? this.options.layers : [];
-            // 创建地图实例
-            // 确保 view 选项不会传递给 OpenLayers Map 构造函数，避免 "then is not a function" 错误
-            // 我们完全控制传递给 Map 的选项，不直接传递用户的 options
-            const mapOptions = {
-                target: id,
-                view: this.options.view || MyOl.createView(this.options),
-                layers: layers,
-                controls: this.createControls()
-            };
-            this.map = new Map(mapOptions);
-            if (this.options.token && (layers.length === 0 || this.options.annotation)) {
-                this.getMapBaseLayers();
-            }
-            // 初始化基础事件监听（地图错误等）
-            this.initializeEventListeners();
-        }
-        catch (error) {
-            this.errorHandler.handleError(new MyOpenLayersError(`地图初始化失败: ${error instanceof Error ? error.message : '未知错误'}`, ErrorType.MAP_ERROR, { id, options }));
-            throw error;
-        }
-    }
-    /**
-     * 验证构造函数参数
-     * @private
-     */
-    validateConstructorParams(id, options) {
-        if (!id || typeof id !== 'string') {
-            throw new Error('地图容器 ID 必须是非空字符串');
-        }
-        if (!options || typeof options !== 'object') {
-            throw new Error('地图配置选项不能为空');
-        }
-        // 检查 DOM 元素是否存在
-        const element = document.getElementById(id);
-        if (!element) {
-            throw new Error(`找不到 ID 为 '${id}' 的 DOM 元素`);
-        }
-    }
-    /**
-     * 初始化坐标系
-     * @private
-     */
-    static initializeProjections() {
-        // 定义 CGCS2000 坐标系
-        proj4.defs(MyOl.PROJECTIONS.CGCS2000, "+proj=longlat +ellps=GRS80 +no_defs");
-        proj4.defs(MyOl.PROJECTIONS.CGCS2000_3_DEGREE, "+proj=tmerc +lat_0=0 +lon_0=120 +k=1 +x_0=500000 +y_0=0 +ellps=GRS80 +units=m +no_defs");
-        // 注册到 OpenLayers
-        olProj4Register(proj4);
-        // 添加 CGCS2000 投影
-        const cgsc2000 = new olProjProjection({
-            code: MyOl.PROJECTIONS.CGCS2000,
-            extent: [-180, -90, 180, 90],
-            worldExtent: [-180, -90, 180, 90],
-            units: "degrees"
-        });
-        olProjAddProjection(cgsc2000);
-    }
-    /**
-     * 创建地图控件
-     * @private
-     */
-    createControls() {
-        return defaultControls({
-            zoom: false,
-            rotate: false,
-            attribution: false
-        }).extend([]);
-    }
-    /**
-     * 初始化事件监听
-     * @private
-     */
-    initializeEventListeners() {
-        const eventManager = this.getEventManager();
-        // 地图加载完成事件
-        eventManager.on('rendercomplete', (eventData) => {
-            console.debug('地图初始化完成', { map: this.map });
-        }, { once: true });
-        // 地图错误事件
-        eventManager.on('error', (eventData) => {
-            this.errorHandler.handleError(new MyOpenLayersError('地图渲染错误', ErrorType.MAP_ERROR, { error: eventData.error }));
-        });
-    }
-    /**
-     * 创建地图视图
-     * @param options 视图配置
-     * @returns View 地图视图实例
-     */
-    static createView(options = MyOl.DefaultOptions) {
-        try {
-            const projection = new olProjProjection({
-                code: MyOl.PROJECTIONS.CGCS2000,
-                extent: [-180, -90, 180, 90],
-                worldExtent: [-180, -90, 180, 90],
-                units: "degrees"
-            });
-            const viewOptions = {
-                projection,
-                center: olProjFromLonLat(options.center, projection),
-                zoom: options.zoom ?? MyOl.DefaultOptions.zoom,
-                minZoom: options.minZoom,
-                maxZoom: options.maxZoom,
-                ...(options.extent && { extent: options.extent })
-            };
-            return new View(viewOptions);
-        }
-        catch (error) {
-            throw new MyOpenLayersError(`视图创建失败: ${error instanceof Error ? error.message : '未知错误'}`, ErrorType.MAP_ERROR, { options });
-        }
-    }
-    /**
-     * 获取视图（向后兼容）
-     * @deprecated 请使用 createView 方法
-     */
-    static getView(options = MyOl.DefaultOptions) {
-        console.warn('getView 方法已废弃，请使用 createView 方法');
-        return MyOl.createView(options);
-    }
-    // ==========================================
-    // 功能模块获取方法（懒加载模式）
-    // ==========================================
-    /**
-     * 获取面要素操作模块
-     * @returns Polygon 面要素操作实例
-     */
-    getPolygon() {
-        try {
-            if (!this._polygon) {
-                this._polygon = new Polygon(this.map);
-                console.debug('面要素模块已加载');
-            }
-            return this._polygon;
-        }
-        catch (error) {
-            this.errorHandler.handleError(new MyOpenLayersError('面要素模块初始化失败', ErrorType.COMPONENT_ERROR, { error }));
-            throw error;
-        }
-    }
-    /**
-     * 获取底图图层管理模块
-     * @returns MapBaseLayers 底图管理实例
-     */
-    getMapBaseLayers() {
-        try {
-            if (!this._baseLayers) {
-                // 检查是否设置了自定义底图
-                if (Array.isArray(this.options.layers)) {
-                    console.warn('已设置默认底图，MapBaseLayers 中的 switchBaseLayer 方法将失效');
-                }
-                const layerOptions = {
-                    layers: this.options.layers,
-                    annotation: this.options.annotation,
-                    zIndex: 1,
-                    mapClip: !!this.options.mapClipData,
-                    mapClipData: this.options.mapClipData,
-                    token: this.options.token || ''
-                };
-                this._baseLayers = new MapBaseLayers(this.map, layerOptions);
-                console.debug('基础图层模块已加载');
-            }
-            return this._baseLayers;
-        }
-        catch (error) {
-            this.errorHandler.handleError(new MyOpenLayersError('基础图层模块初始化失败', ErrorType.COMPONENT_ERROR, { error }));
-            throw error;
-        }
-    }
-    /**
-     * 获取点要素操作模块
-     * @returns Point 点要素操作实例
-     */
-    getPoint() {
-        try {
-            if (!this._point) {
-                this._point = new Point(this.map);
-                console.debug('点要素模块已加载');
-            }
-            return this._point;
-        }
-        catch (error) {
-            this.errorHandler.handleError(new MyOpenLayersError('点要素模块初始化失败', ErrorType.COMPONENT_ERROR, { error }));
-            throw error;
-        }
-    }
-    /**
-     * 获取线要素操作模块
-     * @returns Line 线要素操作实例
-     */
-    getLine() {
-        try {
-            if (!this._line) {
-                this._line = new Line(this.map);
-                console.debug('线要素模块已加载');
-            }
-            return this._line;
-        }
-        catch (error) {
-            this.errorHandler.handleError(new MyOpenLayersError('线要素模块初始化失败', ErrorType.COMPONENT_ERROR, { error }));
-            throw error;
-        }
-    }
-    /**
-     * 获取地图工具模块
-     * @returns MapTools 地图工具实例
-     */
-    getTools() {
-        try {
-            if (!this._mapTools) {
-                this._mapTools = new MapTools(this.map);
-                console.debug('工具模块已加载');
-            }
-            return this._mapTools;
-        }
-        catch (error) {
-            this.errorHandler.handleError(new MyOpenLayersError('工具模块初始化失败', ErrorType.COMPONENT_ERROR, { error }));
-            throw error;
-        }
-    }
-    // ==========================================
-    // 地图操作方法
-    // ==========================================
-    /**
-     * 重置地图位置到初始中心点
-     * @param duration 动画持续时间（毫秒）
-     */
-    resetPosition(duration = 3000) {
-        try {
-            if (!this.options.center) {
-                throw new Error('未设置中心点，无法重置位置');
-            }
-            const [longitude, latitude] = this.options.center;
-            this.locationAction(longitude, latitude, this.options.zoom, duration);
-        }
-        catch (error) {
-            this.errorHandler.handleError(new MyOpenLayersError(`重置地图位置失败: ${error instanceof Error ? error.message : '未知错误'}`, ErrorType.MAP_ERROR, { center: this.options.center, duration }));
-        }
-    }
-    /**
-     * 地图定位到指定坐标
-     * @param longitude 经度
-     * @param latitude 纬度
-     * @param zoom 缩放级别
-     * @param duration 动画持续时间（毫秒）
-     */
-    locationAction(longitude, latitude, zoom = 20, duration = 3000) {
-        try {
-            // 参数验证
-            if (typeof longitude !== 'number' || typeof latitude !== 'number') {
-                throw new Error('经纬度必须是数字类型');
-            }
-            if (longitude < -180 || longitude > 180) {
-                throw new Error('经度值必须在 -180 到 180 之间');
-            }
-            if (latitude < -90 || latitude > 90) {
-                throw new Error('纬度值必须在 -90 到 90 之间');
-            }
-            this.getPoint().locationAction(longitude, latitude, zoom, duration);
-            // 记录定位操作
-            console.debug('地图定位完成', {
-                longitude,
-                latitude,
-                zoom,
-                duration
-            });
-        }
-        catch (error) {
-            this.errorHandler.handleError(new MyOpenLayersError(`地图定位失败: ${error instanceof Error ? error.message : '未知错误'}`, ErrorType.MAP_ERROR, { longitude, latitude, zoom, duration }));
-            throw error;
-        }
-    }
-    // ==========================================
-    // 管理器访问方法
-    // ==========================================
-    /**
-     * 获取错误处理器实例
-     * @returns ErrorHandler 错误处理器
-     */
-    getErrorHandler() {
-        return this.errorHandler;
-    }
-    /**
-     * 获取事件管理器实例
-     * @returns EventManager 事件管理器
-     */
-    getEventManager() {
-        if (!this._eventManager) {
-            this._eventManager = new EventManager(this.map);
-        }
-        return this._eventManager;
-    }
-    /**
-     * 获取配置管理器实例
-     * @returns ConfigManager 配置管理器
-     */
-    getConfigManager() {
-        return this.configManager;
-    }
-    /**
-     * 获取当前地图配置
-     * @returns MapInitType 地图配置
-     */
-    getMapOptions() {
-        return Object.freeze({ ...this.options });
-    }
-    /**
-     * 销毁地图实例和相关资源
-     */
-    destroy() {
-        try {
-            // 清理事件监听（仅在已初始化时）
-            if (this._eventManager) {
-                this._eventManager.clear();
-            }
-            // 销毁功能模块
-            this._point = undefined;
-            this._line = undefined;
-            this._polygon = undefined;
-            this._mapTools = undefined;
-            this._baseLayers = undefined;
-            // 销毁地图
-            this.map.setTarget(undefined);
-            console.debug('地图实例已销毁', { map: this.map });
-        }
-        catch (error) {
-            this.errorHandler.handleError(new MyOpenLayersError(`销毁地图失败: ${error instanceof Error ? error.message : '未知错误'}`, ErrorType.MAP_ERROR));
-        }
-    }
-}
-// 默认配置
-MyOl.DefaultOptions = {
-    layers: undefined,
-    zoom: 10,
-    center: [119.81, 29.969],
-    extent: undefined
-};
-// 坐标系配置
-MyOl.PROJECTIONS = {
-    CGCS2000: "EPSG:4490",
-    CGCS2000_3_DEGREE: "EPSG:4549"
-};
-export default MyOl;
+"use strict";
+// OpenLayers 核心导入
+import { register as olProj4Register } from 'ol/proj/proj4';
+import { Projection as olProjProjection, addProjection as olProjAddProjection, fromLonLat as olProjFromLonLat } from 'ol/proj';
+import View from "ol/View";
+import Map from "ol/Map";
+import { defaults as defaultControls } from 'ol/control';
+import proj4 from "proj4";
+// 内部模块导入
+import Polygon from "./core/Polygon";
+import Point from "./core/Point";
+import Line from "./core/Line";
+import MapBaseLayers from "./core/MapBaseLayers";
+import MapTools from "./core/MapTools";
+import { ErrorHandler, MyOpenLayersError, ErrorType } from './utils/ErrorHandler';
+import { EventManager } from './core/EventManager';
+import { ConfigManager } from './core/ConfigManager';
+/**
+ * MyOl 地图核心类
+ * 提供完整的地图操作功能，包括点、线、面要素管理，底图切换，工具操作等
+ */
+export default class MyOl {
+    /**
+     * 构造函数
+     * @param id 地图容器 DOM 元素 ID
+     * @param options 地图初始化配置
+     */
+    constructor(id, options) {
+        // 初始化错误处理器（必须最先初始化）
+        this.errorHandler = ErrorHandler.getInstance();
+        try {
+            // 初始化配置管理器
+            this.configManager = new ConfigManager();
+            // 合并配置（处理 undefined 情况）
+            this.options = ConfigManager.mergeOptions(MyOl.DefaultOptions, options || {});
+            // 参数验证
+            this.validateConstructorParams(id, this.options);
+            // 初始化坐标系
+            MyOl.initializeProjections();
+            // 准备图层
+            const layers = Array.isArray(this.options.layers) ? this.options.layers : [];
+            // 创建地图实例
+            // 确保 view 选项不会传递给 OpenLayers Map 构造函数，避免 "then is not a function" 错误
+            // 我们完全控制传递给 Map 的选项，不直接传递用户的 options
+            const mapOptions = {
+                target: id,
+                view: this.options.view || MyOl.createView(this.options),
+                layers: layers,
+                controls: this.createControls()
+            };
+            this.map = new Map(mapOptions);
+            if (this.options.token && (layers.length === 0 || this.options.annotation)) {
+                this.getMapBaseLayers();
+            }
+            // 初始化基础事件监听（地图错误等）
+            this.initializeEventListeners();
+        }
+        catch (error) {
+            this.errorHandler.handleError(new MyOpenLayersError(`地图初始化失败: ${error instanceof Error ? error.message : '未知错误'}`, ErrorType.MAP_ERROR, { id, options }));
+            throw error;
+        }
+    }
+    /**
+     * 验证构造函数参数
+     * @private
+     */
+    validateConstructorParams(id, options) {
+        if (!id || typeof id !== 'string') {
+            throw new Error('地图容器 ID 必须是非空字符串');
+        }
+        if (!options || typeof options !== 'object') {
+            throw new Error('地图配置选项不能为空');
+        }
+        // 检查 DOM 元素是否存在
+        const element = document.getElementById(id);
+        if (!element) {
+            throw new Error(`找不到 ID 为 '${id}' 的 DOM 元素`);
+        }
+    }
+    /**
+     * 初始化坐标系
+     * @private
+     */
+    static initializeProjections() {
+        // 定义 CGCS2000 坐标系
+        proj4.defs(MyOl.PROJECTIONS.CGCS2000, "+proj=longlat +ellps=GRS80 +no_defs");
+        proj4.defs(MyOl.PROJECTIONS.CGCS2000_3_DEGREE, "+proj=tmerc +lat_0=0 +lon_0=120 +k=1 +x_0=500000 +y_0=0 +ellps=GRS80 +units=m +no_defs");
+        // 注册到 OpenLayers
+        olProj4Register(proj4);
+        // 添加 CGCS2000 投影
+        const cgsc2000 = new olProjProjection({
+            code: MyOl.PROJECTIONS.CGCS2000,
+            extent: [-180, -90, 180, 90],
+            worldExtent: [-180, -90, 180, 90],
+            units: "degrees"
+        });
+        olProjAddProjection(cgsc2000);
+    }
+    /**
+     * 创建地图控件
+     * @private
+     */
+    createControls() {
+        return defaultControls({
+            zoom: false,
+            rotate: false,
+            attribution: false
+        }).extend([]);
+    }
+    /**
+     * 初始化事件监听
+     * @private
+     */
+    initializeEventListeners() {
+        const eventManager = this.getEventManager();
+        // 地图加载完成事件
+        eventManager.on('rendercomplete', (eventData) => {
+            console.debug('地图初始化完成', { map: this.map });
+        }, { once: true });
+        // 地图错误事件
+        eventManager.on('error', (eventData) => {
+            this.errorHandler.handleError(new MyOpenLayersError('地图渲染错误', ErrorType.MAP_ERROR, { error: eventData.error }));
+        });
+    }
+    /**
+     * 创建地图视图
+     * @param options 视图配置
+     * @returns View 地图视图实例
+     */
+    static createView(options = MyOl.DefaultOptions) {
+        try {
+            const projection = new olProjProjection({
+                code: MyOl.PROJECTIONS.CGCS2000,
+                extent: [-180, -90, 180, 90],
+                worldExtent: [-180, -90, 180, 90],
+                units: "degrees"
+            });
+            const viewOptions = {
+                projection,
+                center: olProjFromLonLat(options.center, projection),
+                zoom: options.zoom ?? MyOl.DefaultOptions.zoom,
+                minZoom: options.minZoom,
+                maxZoom: options.maxZoom,
+                ...(options.extent && { extent: options.extent })
+            };
+            return new View(viewOptions);
+        }
+        catch (error) {
+            throw new MyOpenLayersError(`视图创建失败: ${error instanceof Error ? error.message : '未知错误'}`, ErrorType.MAP_ERROR, { options });
+        }
+    }
+    /**
+     * 获取视图（向后兼容）
+     * @deprecated 请使用 createView 方法
+     */
+    static getView(options = MyOl.DefaultOptions) {
+        console.warn('getView 方法已废弃，请使用 createView 方法');
+        return MyOl.createView(options);
+    }
+    // ==========================================
+    // 功能模块获取方法（懒加载模式）
+    // ==========================================
+    /**
+     * 获取面要素操作模块
+     * @returns Polygon 面要素操作实例
+     */
+    getPolygon() {
+        try {
+            if (!this._polygon) {
+                this._polygon = new Polygon(this.map);
+                console.debug('面要素模块已加载');
+            }
+            return this._polygon;
+        }
+        catch (error) {
+            this.errorHandler.handleError(new MyOpenLayersError('面要素模块初始化失败', ErrorType.COMPONENT_ERROR, { error }));
+            throw error;
+        }
+    }
+    /**
+     * 获取底图图层管理模块
+     * @returns MapBaseLayers 底图管理实例
+     */
+    getMapBaseLayers() {
+        try {
+            if (!this._baseLayers) {
+                // 检查是否设置了自定义底图
+                if (Array.isArray(this.options.layers)) {
+                    console.warn('已设置默认底图，MapBaseLayers 中的 switchBaseLayer 方法将失效');
+                }
+                const layerOptions = {
+                    layers: this.options.layers,
+                    annotation: this.options.annotation,
+                    zIndex: 1,
+                    mapClip: !!this.options.mapClipData,
+                    mapClipData: this.options.mapClipData,
+                    token: this.options.token || ''
+                };
+                this._baseLayers = new MapBaseLayers(this.map, layerOptions);
+                console.debug('基础图层模块已加载');
+            }
+            return this._baseLayers;
+        }
+        catch (error) {
+            this.errorHandler.handleError(new MyOpenLayersError('基础图层模块初始化失败', ErrorType.COMPONENT_ERROR, { error }));
+            throw error;
+        }
+    }
+    /**
+     * 获取点要素操作模块
+     * @returns Point 点要素操作实例
+     */
+    getPoint() {
+        try {
+            if (!this._point) {
+                this._point = new Point(this.map);
+                console.debug('点要素模块已加载');
+            }
+            return this._point;
+        }
+        catch (error) {
+            this.errorHandler.handleError(new MyOpenLayersError('点要素模块初始化失败', ErrorType.COMPONENT_ERROR, { error }));
+            throw error;
+        }
+    }
+    /**
+     * 获取线要素操作模块
+     * @returns Line 线要素操作实例
+     */
+    getLine() {
+        try {
+            if (!this._line) {
+                this._line = new Line(this.map);
+                console.debug('线要素模块已加载');
+            }
+            return this._line;
+        }
+        catch (error) {
+            this.errorHandler.handleError(new MyOpenLayersError('线要素模块初始化失败', ErrorType.COMPONENT_ERROR, { error }));
+            throw error;
+        }
+    }
+    /**
+     * 获取地图工具模块
+     * @returns MapTools 地图工具实例
+     */
+    getTools() {
+        try {
+            if (!this._mapTools) {
+                this._mapTools = new MapTools(this.map);
+                console.debug('工具模块已加载');
+            }
+            return this._mapTools;
+        }
+        catch (error) {
+            this.errorHandler.handleError(new MyOpenLayersError('工具模块初始化失败', ErrorType.COMPONENT_ERROR, { error }));
+            throw error;
+        }
+    }
+    // ==========================================
+    // 地图操作方法
+    // ==========================================
+    /**
+     * 重置地图位置到初始中心点
+     * @param duration 动画持续时间（毫秒）
+     */
+    resetPosition(duration = 3000) {
+        try {
+            if (!this.options.center) {
+                throw new Error('未设置中心点，无法重置位置');
+            }
+            const [longitude, latitude] = this.options.center;
+            this.locationAction(longitude, latitude, this.options.zoom, duration);
+        }
+        catch (error) {
+            this.errorHandler.handleError(new MyOpenLayersError(`重置地图位置失败: ${error instanceof Error ? error.message : '未知错误'}`, ErrorType.MAP_ERROR, { center: this.options.center, duration }));
+        }
+    }
+    /**
+     * 地图定位到指定坐标
+     * @param longitude 经度
+     * @param latitude 纬度
+     * @param zoom 缩放级别
+     * @param duration 动画持续时间（毫秒）
+     */
+    locationAction(longitude, latitude, zoom = 20, duration = 3000) {
+        try {
+            // 参数验证
+            if (typeof longitude !== 'number' || typeof latitude !== 'number') {
+                throw new Error('经纬度必须是数字类型');
+            }
+            if (longitude < -180 || longitude > 180) {
+                throw new Error('经度值必须在 -180 到 180 之间');
+            }
+            if (latitude < -90 || latitude > 90) {
+                throw new Error('纬度值必须在 -90 到 90 之间');
+            }
+            this.getPoint().locationAction(longitude, latitude, zoom, duration);
+            // 记录定位操作
+            console.debug('地图定位完成', {
+                longitude,
+                latitude,
+                zoom,
+                duration
+            });
+        }
+        catch (error) {
+            this.errorHandler.handleError(new MyOpenLayersError(`地图定位失败: ${error instanceof Error ? error.message : '未知错误'}`, ErrorType.MAP_ERROR, { longitude, latitude, zoom, duration }));
+            throw error;
+        }
+    }
+    // ==========================================
+    // 管理器访问方法
+    // ==========================================
+    /**
+     * 获取错误处理器实例
+     * @returns ErrorHandler 错误处理器
+     */
+    getErrorHandler() {
+        return this.errorHandler;
+    }
+    /**
+     * 获取事件管理器实例
+     * @returns EventManager 事件管理器
+     */
+    getEventManager() {
+        if (!this._eventManager) {
+            this._eventManager = new EventManager(this.map);
+        }
+        return this._eventManager;
+    }
+    /**
+     * 获取配置管理器实例
+     * @returns ConfigManager 配置管理器
+     */
+    getConfigManager() {
+        return this.configManager;
+    }
+    /**
+     * 获取当前地图配置
+     * @returns MapInitType 地图配置
+     */
+    getMapOptions() {
+        return Object.freeze({ ...this.options });
+    }
+    /**
+     * 销毁地图实例和相关资源
+     */
+    destroy() {
+        try {
+            // 清理事件监听（仅在已初始化时）
+            if (this._eventManager) {
+                this._eventManager.clear();
+            }
+            // 销毁功能模块
+            this._point = undefined;
+            this._line = undefined;
+            this._polygon = undefined;
+            this._mapTools = undefined;
+            this._baseLayers = undefined;
+            // 销毁地图
+            this.map.setTarget(undefined);
+            console.debug('地图实例已销毁', { map: this.map });
+        }
+        catch (error) {
+            this.errorHandler.handleError(new MyOpenLayersError(`销毁地图失败: ${error instanceof Error ? error.message : '未知错误'}`, ErrorType.MAP_ERROR));
+        }
+    }
+}
+// 默认配置
+MyOl.DefaultOptions = {
+    layers: undefined,
+    zoom: 10,
+    center: [119.81, 29.969],
+    extent: undefined
+};
+// 坐标系配置
+MyOl.PROJECTIONS = {
+    CGCS2000: "EPSG:4490",
+    CGCS2000_3_DEGREE: "EPSG:4549"
+};