my-openlayer 0.1.18 → 1.0.1

package/dist/core/MapTools.d.ts

@@ -5,15 +5,31 @@ import VectorSource from "ol/source/Vector";
 import BaseLayer from "ol/layer/Base";
 import ImageLayer from "ol/layer/Image";
 import ImageSource from "ol/source/Image";
+import { EventManager, MapEventData } from "./EventManager";
+/**
+ * 地图工具类
+ * 提供地图的基础操作功能
+ */
 export default class MapTools {
     private readonly map;
+    private eventManager;
+    private errorHandler;
     constructor(map: Map);
     /**
      * 根据名称获取图层
      * @param layerName 图层名称
+     * @returns 图层数组
+     * @throws 当参数无效时抛出错误
      */
-    getLayerByLayerName(layerName: string | string[]): (BaseLayer | VectorLayer<VectorSource<import("ol/geom").Geometry>> | ImageLayer<ImageSource>)[];
-    static getLayerByLayerName(map: Map, layerName: string | string[]): (BaseLayer | VectorLayer<VectorSource<import("ol/geom").Geometry>> | ImageLayer<ImageSource>)[];
+    getLayerByLayerName(layerName: string | string[]): (VectorLayer<VectorSource> | BaseLayer | ImageLayer<ImageSource>)[];
+    /**
+     * 根据图层名称获取图层
+     * @param map 地图实例
+     * @param layerName 图层名称
+     * @returns 图层数组
+     * @throws 当参数无效时抛出错误
+     */
+    static getLayerByLayerName(map: Map, layerName: string | string[]): (VectorLayer<VectorSource> | BaseLayer | ImageLayer<ImageSource>)[];
     /**
      * 设置地图裁剪
      */
@@ -21,29 +37,83 @@ export default class MapTools {
     /**
      * 移除图层
      * @param layerName 图层名称
+     * @throws 当参数无效时抛出错误
      */
     removeLayer(layerName: string | string[]): void;
     /**
-     * 移除图层
+     * 移除图层（静态方法，兼容性保留）
      * @param map 地图对象
      * @param layerName 图层名称
+     * @throws 当参数无效时抛出错误
      */
     static removeLayer(map: Map, layerName: string | string[]): void;
+    /**
+     * 设置图层可见性
+     * @param layerName 图层名称
+     * @param visible 是否可见
+     * @throws 当参数无效时抛出错误
+     */
     setLayerVisible(layerName: string, visible: boolean): void;
     /**
      * 设置图层可见性
-     * @param map
+     * @param map 地图实例
      * @param layerName 图层名称
      * @param visible 是否可见
+     * @throws 当参数无效时抛出错误
      */
     static setLayerVisible: (map: Map, layerName: string, visible: boolean) => void;
-    mapOnEvent(eventType: EventType, callback: (feature?: any, e?: any) => void, clickType?: 'point' | 'line' | 'polygon' | undefined): void;
     /**
      * 地图监听事件
-     * @param map
      * @param eventType 事件类型
-     * @param clickType 点击类型
      * @param callback 回调函数
+     * @param options 事件选项
+     * @returns 事件监听器ID
+     * @throws 当参数无效时抛出错误
+     */
+    mapOnEvent(eventType: EventType, callback: (feature?: any, e?: any) => void, options?: {
+        clickType?: 'point' | 'line' | 'polygon';
+        once?: boolean;
+        filter?: (event: MapEventData) => boolean;
+    }): string;
+    /**
+     * 地图监听事件（静态方法，兼容性保留）
+     * @param map 地图实例
+     * @param eventType 事件类型
+     * @param callback 回调函数
+     * @param clickType 点击类型
+     * @throws 当参数无效时抛出错误
+     * @deprecated 推荐使用实例方法 mapOnEvent
      */
     static mapOnEvent(map: Map, eventType: EventType, callback: (feature?: any, e?: any) => void, clickType?: 'point' | 'line' | 'polygon'): void;
+    /**
+     * 兼容性方法：使用传统方式注册事件
+     * @private
+     */
+    private registerEventWithManager;
+    /**
+     * 转换事件类型
+     * @private
+     */
+    private convertToMapEventType;
+    /**
+     * 移除事件监听器
+     * @param listenerId 监听器ID
+     * @returns 是否成功移除
+     */
+    removeEventListener(listenerId: string): boolean;
+    /**
+     * 移除指定类型的所有事件监听器
+     * @param eventType 事件类型
+     */
+    removeAllEventListeners(eventType?: EventType): void;
+    /**
+     * 获取 EventManager 实例
+     * @returns EventManager 实例
+     */
+    getEventManager(): EventManager;
+    /**
+     * 获取地图实例
+     * @returns 地图实例
+     */
+    getMap(): Map;
 }

package/dist/core/MapTools.js

@@ -4,35 +4,69 @@ import VectorSource from "ol/source/Vector";
 import GeoJSON from "ol/format/GeoJSON";
 import { Fill, Style } from "ol/style";
 import { getVectorContext } from "ol/render";
+import { EventManager } from "./EventManager";
+import { ErrorHandler, ErrorType } from "../utils/ErrorHandler";
+import { ValidationUtils } from "../utils/ValidationUtils";
+/**
+ * 地图工具类
+ * 提供地图的基础操作功能
+ */
 class MapTools {
     constructor(map) {
-        this.map = map;
+        this.errorHandler = ErrorHandler.getInstance();
+        try {
+            ValidationUtils.validateMap(map);
+            this.map = map;
+            this.eventManager = new EventManager(map);
+        }
+        catch (error) {
+            this.errorHandler.createAndHandleError(`Failed to initialize MapTools: ${error}`, ErrorType.MAP_ERROR, { map, error });
+            throw error;
+        }
     }
     /**
      * 根据名称获取图层
      * @param layerName 图层名称
+     * @returns 图层数组
+     * @throws 当参数无效时抛出错误
      */
     getLayerByLayerName(layerName) {
-        if (!this.map)
-            return [];
+        if (!this.map) {
+            throw new Error('Map instance is not available');
+        }
         return MapTools.getLayerByLayerName(this.map, layerName);
     }
+    /**
+     * 根据图层名称获取图层
+     * @param map 地图实例
+     * @param layerName 图层名称
+     * @returns 图层数组
+     * @throws 当参数无效时抛出错误
+     */
     static getLayerByLayerName(map, layerName) {
+        ValidationUtils.validateMap(map);
+        ValidationUtils.validateLayerNameParam(layerName);
         const targetLayer = [];
-        const layers = map.getLayers().getArray();
-        Object.values(layers).forEach((layer) => {
-            const _layerName = layer.get('layerName');
-            if (typeof layerName === "string") {
-                if (_layerName && _layerName === layerName) {
-                    targetLayer.push(layer);
+        try {
+            const layers = map.getLayers().getArray();
+            layers.forEach((layer) => {
+                const _layerName = layer.get('layerName');
+                if (typeof layerName === "string") {
+                    if (_layerName && _layerName === layerName) {
+                        targetLayer.push(layer);
+                    }
                 }
-            }
-            else {
-                if (_layerName && layerName.includes(_layerName)) {
-                    targetLayer.push(layer);
+                else {
+                    if (_layerName && layerName.includes(_layerName)) {
+                        targetLayer.push(layer);
+                    }
                 }
-            }
-        });
+            });
+        }
+        catch (error) {
+            console.error('Error getting layers:', error);
+            throw new Error('Failed to retrieve layers from map');
+        }
         return targetLayer;
     }
     /**
@@ -72,84 +106,249 @@ class MapTools {
     /**
      * 移除图层
      * @param layerName 图层名称
+     * @throws 当参数无效时抛出错误
      */
     removeLayer(layerName) {
-        if (!this.map)
-            return;
-        MapTools.removeLayer(this.map, layerName);
+        if (!this.map) {
+            throw new Error('Map instance is not available');
+        }
+        try {
+            const layers = this.getLayerByLayerName(layerName);
+            layers.forEach(layer => {
+                this.map.removeLayer(layer);
+            });
+        }
+        catch (error) {
+            console.error('Error removing layers:', error);
+            throw new Error('Failed to remove layers from map');
+        }
     }
     /**
-     * 移除图层
+     * 移除图层（静态方法，兼容性保留）
      * @param map 地图对象
      * @param layerName 图层名称
+     * @throws 当参数无效时抛出错误
      */
     static removeLayer(map, layerName) {
-        const layers = MapTools.getLayerByLayerName(map, layerName);
-        layers.forEach(layer => {
-            map.removeLayer(layer);
-        });
+        if (!map) {
+            throw new Error('Map instance is required');
+        }
+        try {
+            const layers = MapTools.getLayerByLayerName(map, layerName);
+            layers.forEach(layer => {
+                map.removeLayer(layer);
+            });
+        }
+        catch (error) {
+            console.error('Error removing layers:', error);
+            throw new Error('Failed to remove layers from map');
+        }
     }
+    /**
+     * 设置图层可见性
+     * @param layerName 图层名称
+     * @param visible 是否可见
+     * @throws 当参数无效时抛出错误
+     */
     setLayerVisible(layerName, visible) {
-        if (!this.map)
-            return;
-        MapTools.setLayerVisible(this.map, layerName, visible);
-    }
-    mapOnEvent(eventType, callback, clickType) {
-        if (!this.map)
-            return;
-        MapTools.mapOnEvent(this.map, eventType, callback, clickType);
+        if (!this.map) {
+            throw new Error('Map instance is not available');
+        }
+        try {
+            const layers = this.getLayerByLayerName(layerName);
+            layers.forEach(layer => {
+                layer.setVisible(visible);
+            });
+        }
+        catch (error) {
+            console.error('Error setting layer visibility:', error);
+            throw new Error('Failed to set layer visibility');
+        }
     }
     /**
      * 地图监听事件
-     * @param map
      * @param eventType 事件类型
-     * @param clickType 点击类型
      * @param callback 回调函数
+     * @param options 事件选项
+     * @returns 事件监听器ID
+     * @throws 当参数无效时抛出错误
+     */
+    mapOnEvent(eventType, callback, options) {
+        try {
+            ErrorHandler.validateMap(this.map);
+            if (!eventType) {
+                throw new Error('Event type is required');
+            }
+            if (typeof callback !== 'function') {
+                throw new Error('Callback must be a function');
+            }
+            return this.registerEventWithManager(eventType, callback, options);
+        }
+        catch (error) {
+            this.errorHandler.createAndHandleError(`Failed to register map event: ${error}`, ErrorType.COMPONENT_ERROR, { eventType, callback, options, error });
+            throw error;
+        }
+    }
+    /**
+     * 地图监听事件（静态方法，兼容性保留）
+     * @param map 地图实例
+     * @param eventType 事件类型
+     * @param callback 回调函数
+     * @param clickType 点击类型
+     * @throws 当参数无效时抛出错误
+     * @deprecated 推荐使用实例方法 mapOnEvent
      */
     static mapOnEvent(map, eventType, callback, clickType) {
-        const clickTypeObj = {
-            point: ['point'],
-            line: ['line'],
-            polygon: ['polygon', 'MultiPolygon']
-        };
-        if (eventType === "click") {
-            map.on("click", (e) => {
-                // 获取点位 feature
-                const pixel = map.getEventPixel(e.originalEvent);
-                const features = map.getFeaturesAtPixel(pixel);
-                let feature = undefined;
-                if (features.length > 0)
-                    feature = features[0];
-                callback(feature, { features, pixel });
-            });
+        const errorHandler = ErrorHandler.getInstance();
+        try {
+            ErrorHandler.validateMap(map);
+            if (!eventType) {
+                throw new Error('Event type is required');
+            }
+            if (typeof callback !== 'function') {
+                throw new Error('Callback must be a function');
+            }
+            const eventManager = new EventManager(map);
+            const mapTools = new MapTools(map);
+            mapTools.registerEventWithManager(eventType, callback, { clickType });
+        }
+        catch (error) {
+            errorHandler.createAndHandleError(`Failed to register static map event: ${error}`, ErrorType.COMPONENT_ERROR, { map, eventType, callback, clickType, error });
+            throw error;
         }
-        else if (eventType === 'moveend') {
-            map.on('moveend', function () {
-                const zoom = map.getView().getZoom();
-                if (zoom) {
-                    callback(zoom);
+    }
+    /**
+     * 兼容性方法：使用传统方式注册事件
+     * @private
+     */
+    registerEventWithManager(eventType, callback, options) {
+        const mapEventType = this.convertToMapEventType(eventType);
+        const eventCallback = (event) => {
+            try {
+                if (eventType === 'click') {
+                    const feature = event.feature;
+                    const extraData = {
+                        features: event.features || [],
+                        pixel: event.pixel
+                    };
+                    // 应用点击类型过滤
+                    if (options?.clickType && feature) {
+                        const geometryType = feature.getGeometry()?.getType();
+                        const clickTypeMap = {
+                            point: ['Point', 'MultiPoint'],
+                            line: ['LineString', 'MultiLineString'],
+                            polygon: ['Polygon', 'MultiPolygon']
+                        };
+                        if (geometryType && !clickTypeMap[options.clickType].includes(geometryType)) {
+                            return; // 不符合点击类型过滤条件
+                        }
+                    }
+                    callback(feature, extraData);
                 }
-            });
+                else if (eventType === 'moveend') {
+                    callback(event.zoom);
+                }
+                else if (eventType === 'hover') {
+                    callback({
+                        features: event.features || [],
+                        pixel: event.pixel
+                    });
+                }
+            }
+            catch (error) {
+                this.errorHandler.createAndHandleError(`Error in event callback: ${error}`, ErrorType.COMPONENT_ERROR, { eventType, event, error });
+            }
+        };
+        return this.eventManager.on(mapEventType, eventCallback, {
+            once: options?.once,
+            filter: options?.filter
+        });
+    }
+    /**
+     * 转换事件类型
+     * @private
+     */
+    convertToMapEventType(eventType) {
+        const typeMap = {
+            'click': 'click',
+            'hover': 'hover',
+            'moveend': 'moveend'
+        };
+        return typeMap[eventType] || 'click';
+    }
+    /**
+     * 移除事件监听器
+     * @param listenerId 监听器ID
+     * @returns 是否成功移除
+     */
+    removeEventListener(listenerId) {
+        try {
+            return this.eventManager.off(listenerId);
         }
-        else if (eventType === 'hover') {
-            map.on('pointermove', (e) => {
-                const pixel = map.getEventPixel(e.originalEvent);
-                const features = map.getFeaturesAtPixel(pixel);
-                callback({ features, pixel });
-            });
+        catch (error) {
+            this.errorHandler.createAndHandleError(`Failed to remove event listener: ${error}`, ErrorType.COMPONENT_ERROR, { listenerId, error });
+            return false;
         }
     }
+    /**
+     * 移除指定类型的所有事件监听器
+     * @param eventType 事件类型
+     */
+    removeAllEventListeners(eventType) {
+        try {
+            if (eventType) {
+                const mapEventType = this.convertToMapEventType(eventType);
+                this.eventManager.offAll(mapEventType);
+            }
+            else {
+                this.eventManager.clear();
+            }
+        }
+        catch (error) {
+            this.errorHandler.createAndHandleError(`Failed to remove event listeners: ${error}`, ErrorType.COMPONENT_ERROR, { eventType, error });
+        }
+    }
+    /**
+     * 获取 EventManager 实例
+     * @returns EventManager 实例
+     */
+    getEventManager() {
+        return this.eventManager;
+    }
+    /**
+     * 获取地图实例
+     * @returns 地图实例
+     */
+    getMap() {
+        return this.map;
+    }
 }
 /**
  * 设置图层可见性
- * @param map
+ * @param map 地图实例
  * @param layerName 图层名称
  * @param visible 是否可见
+ * @throws 当参数无效时抛出错误
  */
 MapTools.setLayerVisible = (map, layerName, visible) => {
-    const layers = MapTools.getLayerByLayerName(map, layerName);
-    layers.forEach(layer => {
-        layer.setVisible(visible);
-    });
+    if (!map) {
+        throw new Error('Map instance is required');
+    }
+    if (typeof layerName !== 'string') {
+        throw new Error('Layer name must be a string');
+    }
+    if (typeof visible !== 'boolean') {
+        throw new Error('Visible parameter must be a boolean');
+    }
+    try {
+        const layers = MapTools.getLayerByLayerName(map, layerName);
+        layers.forEach(layer => {
+            layer.setVisible(visible);
+        });
+    }
+    catch (error) {
+        console.error('Error setting layer visibility:', error);
+        throw new Error('Failed to set layer visibility');
+    }
 };
 export default MapTools;

package/dist/core/MeasureHandler.d.ts

@@ -1,7 +1,8 @@
 import Map from "ol/Map";
 import { MeasureHandlerType } from "../types";
 /**
- * @classdesc MeausreHandler
+ * 测量工具处理类
+ * 提供距离和面积测量功能
  */
 export default class MeasureHandler {
     private readonly source;
@@ -9,14 +10,19 @@ export default class MeasureHandler {
     private sketch;
     private helpTooltipElement;
     private helpTooltip;
-    private _map;
+    private readonly _map;
     private measureTooltipElement;
     private measureTooltip;
-    private continuePolygonMsg;
-    private continueLineMsg;
+    private readonly continuePolygonMsg;
+    private readonly continueLineMsg;
     private _tipsCollection;
     private _mouseListener;
     private _draw;
+    /**
+     * 构造函数
+     * @param map OpenLayers地图实例
+     * @throws 当地图实例无效时抛出错误
+     */
     constructor(map: Map);
     /**
      * destory the object
@@ -35,8 +41,9 @@ export default class MeasureHandler {
      */
     formatArea(polygon: any): string;
     /**
-     *
-     * @param {String} type the values such as  'Polygon','LineString'
+     * 开始测量
+     * @param type 测量类型
+     * @throws 当测量类型无效时抛出错误
      */
     start(type: MeasureHandlerType): void;
     /**

package/dist/core/MeasureHandler.js

@@ -6,13 +6,21 @@ import { Vector as VectorSource } from 'ol/source.js';
 import { Vector as VectorLayer } from 'ol/layer.js';
 import { getArea, getLength } from 'ol/sphere.js';
 import { unByKey } from 'ol/Observable.js';
+import { ValidationUtils } from '../utils/ValidationUtils';
 /**
- * @classdesc MeausreHandler
+ * 测量工具处理类
+ * 提供距离和面积测量功能
  */
 export default class MeasureHandler {
+    /**
+     * 构造函数
+     * @param map OpenLayers地图实例
+     * @throws 当地图实例无效时抛出错误
+     */
     constructor(map) {
-        this._map = null;
         this._draw = null;
+        ValidationUtils.validateMap(map);
+        this._map = map;
         this.source = new VectorSource();
         this.vector = new VectorLayer({
             source: this.source,
@@ -37,7 +45,6 @@ export default class MeasureHandler {
             }),
             zIndex: 999,
         });
-        this._map = map;
         /**
          * Currently drawn feature.
          * @type {import("ol/Feature.js").default}
@@ -149,17 +156,23 @@ export default class MeasureHandler {
         return output;
     }
     /**
-     *
-     * @param {String} type the values such as  'Polygon','LineString'
+     * 开始测量
+     * @param type 测量类型
+     * @throws 当测量类型无效时抛出错误
      */
     start(type) {
-        if (!this._map) {
-            throw new Error("MeasureHandler has not been register to the map");
+        ValidationUtils.validateMeasureType(type);
+        ValidationUtils.validateMap(this._map);
+        try {
+            this.createMeasureTooltip();
+            this.createHelpTooltip();
+            if (this._draw) {
+                this._map.removeInteraction(this._draw);
+            }
         }
-        this.createMeasureTooltip();
-        this.createHelpTooltip();
-        if (this._draw) {
-            this._map.removeInteraction(this._draw);
+        catch (error) {
+            console.error('Error starting measurement:', error);
+            throw new Error('Failed to start measurement');
         }
         this._draw = new Draw({
             source: this.source,
@@ -196,22 +209,25 @@ export default class MeasureHandler {
             this.sketch = evt.feature;
             /** @type {import("ol/coordinate.js").Coordinate|undefined} */
             let tooltipCoord = evt?.coordinate;
-            listener = this.sketch.getGeometry().on('change', (evt) => {
-                const geom = evt.target;
-                let output;
-                if (geom instanceof Polygon) {
-                    output = this.formatArea(geom);
-                    tooltipCoord = geom.getInteriorPoint().getCoordinates();
-                }
-                else if (geom instanceof LineString) {
-                    output = this.formatLength(geom);
-                    tooltipCoord = geom.getLastCoordinate();
-                }
-                if (this.measureTooltipElement) {
-                    this.measureTooltipElement.innerHTML = output;
-                }
-                this.measureTooltip?.setPosition(tooltipCoord);
-            });
+            const geometry = this.sketch?.getGeometry();
+            if (geometry) {
+                listener = geometry.on('change', (evt) => {
+                    const geom = evt.target;
+                    let output;
+                    if (geom instanceof Polygon) {
+                        output = this.formatArea(geom);
+                        tooltipCoord = geom.getInteriorPoint().getCoordinates();
+                    }
+                    else if (geom instanceof LineString) {
+                        output = this.formatLength(geom);
+                        tooltipCoord = geom.getLastCoordinate();
+                    }
+                    if (this.measureTooltipElement) {
+                        this.measureTooltipElement.innerHTML = output;
+                    }
+                    this.measureTooltip?.setPosition(tooltipCoord);
+                });
+            }
         });
         this._draw.on('drawend', () => {
             if (this.measureTooltipElement) {