my-openlayer 1.0.0 → 1.0.2

package/dist/core/MapBaseLayers.js

@@ -11,6 +11,7 @@ import WMTSTileGrid from "ol/tilegrid/WMTS";
 import XYZ from "ol/source/XYZ";
 import MapTools from "./MapTools";
 import { ErrorHandler, ErrorType } from "../utils/ErrorHandler";
+import { ValidationUtils } from "../utils/ValidationUtils";
 /**
  * 天地图服务器配置
  */
@@ -53,10 +54,8 @@ export default class MapBaseLayers {
      * @private
      */
     validateConstructorParams(map, options) {
-        ErrorHandler.validateMap(map);
-        if (!options || typeof options !== 'object') {
-            throw new Error('Valid options object is required');
-        }
+        ValidationUtils.validateMap(map);
+        ValidationUtils.validateOptions(options);
     }
     /**
      * 合并默认配置选项
@@ -291,12 +290,8 @@ export default class MapBaseLayers {
      */
     addGeoServerLayer(url, layerName, options = {}) {
         try {
-            if (!url || typeof url !== 'string') {
-                throw new Error('Valid URL is required for GeoServer layer');
-            }
-            if (!layerName || typeof layerName !== 'string') {
-                throw new Error('Valid layer name is required for GeoServer layer');
-            }
+            ValidationUtils.validateNonEmptyString(url, 'Valid URL is required for GeoServer layer');
+            ValidationUtils.validateNonEmptyString(layerName, 'Valid layer name is required for GeoServer layer');
             const wmsLayer = new TileLayer({
                 source: new TileWMS({
                     url: url,
@@ -410,9 +405,7 @@ export default class MapBaseLayers {
      */
     static getTileGrid(length) {
         try {
-            if (!length || length <= 0) {
-                throw new Error('Valid length is required for tile grid');
-            }
+            ValidationUtils.validatePositiveNumber(length, 'Valid length is required for tile grid');
             const projection = getProjection('EPSG:4326');
             if (!projection) {
                 throw new Error('Failed to get EPSG:4326 projection');

package/dist/core/MapTools.js

@@ -6,6 +6,7 @@ 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";
 /**
  * 地图工具类
  * 提供地图的基础操作功能
@@ -14,7 +15,7 @@ class MapTools {
     constructor(map) {
         this.errorHandler = ErrorHandler.getInstance();
         try {
-            ErrorHandler.validateMap(map);
+            ValidationUtils.validateMap(map);
             this.map = map;
             this.eventManager = new EventManager(map);
         }
@@ -43,12 +44,8 @@ class MapTools {
      * @throws 当参数无效时抛出错误
      */
     static getLayerByLayerName(map, layerName) {
-        if (!map) {
-            throw new Error('Map instance is required');
-        }
-        if (!layerName || (typeof layerName !== 'string' && !Array.isArray(layerName))) {
-            throw new Error('Valid layer name is required');
-        }
+        ValidationUtils.validateMap(map);
+        ValidationUtils.validateLayerNameParam(layerName);
         const targetLayer = [];
         try {
             const layers = map.getLayers().getArray();

package/dist/core/MeasureHandler.js

@@ -6,6 +6,7 @@ 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';
 /**
  * 测量工具处理类
  * 提供距离和面积测量功能
@@ -18,9 +19,7 @@ export default class MeasureHandler {
      */
     constructor(map) {
         this._draw = null;
-        if (!map) {
-            throw new Error('Map instance is required');
-        }
+        ValidationUtils.validateMap(map);
         this._map = map;
         this.source = new VectorSource();
         this.vector = new VectorLayer({
@@ -162,12 +161,8 @@ export default class MeasureHandler {
      * @throws 当测量类型无效时抛出错误
      */
     start(type) {
-        if (!type || (type !== 'LineString' && type !== 'Polygon')) {
-            throw new Error('Invalid measure type. Must be "LineString" or "Polygon"');
-        }
-        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();

package/dist/core/Point.d.ts

@@ -5,6 +5,44 @@ import { MapJSONData, PointOptions, ClusterOptions, PointData } from '../types';
 export default class Point {
     private map;
     constructor(map: Map);
+    /**
+     * 创建文本样式
+     * @private
+     * @param options 选项
+     * @param text 文本内容
+     * @returns 文本样式
+     */
+    private createTextStyle;
+    /**
+     * 创建图标样式
+     * @private
+     * @param options 选项
+     * @returns 图标样式
+     */
+    private createIconStyle;
+    /**
+     * 创建点样式
+     * @private
+     * @param options 选项
+     * @param item 数据项
+     * @returns 样式对象
+     */
+    private createPointStyle;
+    /**
+     * 创建集群样式
+     * @private
+     * @param options 选项
+     * @param name 名称
+     * @returns 样式对象
+     */
+    private createClusterStyle;
+    /**
+     * 配置图层属性
+     * @private
+     * @param layer 图层
+     * @param options 选项
+     */
+    private configureLayer;
     /**
      *
      * @param pointData

package/dist/core/Point.js

@@ -10,10 +10,92 @@ import * as turf from '@turf/turf';
 import GeoJSON from "ol/format/GeoJSON";
 import DomPoint from './DomPoint';
 import MapTools from "./MapTools";
+import { ValidationUtils } from '../utils/ValidationUtils';
 export default class Point {
     constructor(map) {
         this.map = map;
     }
+    /**
+     * 创建文本样式
+     * @private
+     * @param options 选项
+     * @param text 文本内容
+     * @returns 文本样式
+     */
+    createTextStyle(options, text) {
+        return new Text({
+            text: text,
+            font: options.textFont || '12px Calibri,sans-serif',
+            fill: new Fill({
+                color: options.textFillColor || '#FFF'
+            }),
+            stroke: new Stroke({
+                color: options.textStrokeColor || '#000',
+                width: options.textStrokeWidth || 3
+            }),
+            offsetY: options.textOffsetY || 20,
+        });
+    }
+    /**
+     * 创建图标样式
+     * @private
+     * @param options 选项
+     * @returns 图标样式
+     */
+    createIconStyle(options) {
+        const iconOptions = {
+            src: options.img,
+            scale: options.scale ?? 1,
+        };
+        if (options.iconColor) {
+            iconOptions.color = options.iconColor;
+        }
+        return new Icon(iconOptions);
+    }
+    /**
+     * 创建点样式
+     * @private
+     * @param options 选项
+     * @param item 数据项
+     * @returns 样式对象
+     */
+    createPointStyle(options, item) {
+        const style = {};
+        if (options.nameKey && item) {
+            style.text = this.createTextStyle(options, item[options.nameKey]);
+        }
+        if (options.hasImg || options.hasImg === undefined) {
+            style.image = this.createIconStyle(options);
+        }
+        return new Style(style);
+    }
+    /**
+     * 创建集群样式
+     * @private
+     * @param options 选项
+     * @param name 名称
+     * @returns 样式对象
+     */
+    createClusterStyle(options, name) {
+        const style = {};
+        if (options.nameKey) {
+            style.text = this.createTextStyle(options, name);
+        }
+        if (options.hasImg || options.hasImg === undefined) {
+            style.image = this.createIconStyle(options);
+        }
+        return new Style(style);
+    }
+    /**
+     * 配置图层属性
+     * @private
+     * @param layer 图层
+     * @param options 选项
+     */
+    configureLayer(layer, options) {
+        layer.setVisible(options.visible === undefined ? true : options.visible);
+        this.map.addLayer(layer);
+    }
     /**
      *
      * @param pointData
@@ -25,14 +107,12 @@ export default class Point {
      * }
      */
     addPoint(pointData, options) {
-        if (!pointData || pointData.length === 0) {
-            console.warn('Point data is empty or undefined');
+        if (!ValidationUtils.validatePointData(pointData)) {
             return null;
         }
         const pointFeatureList = [];
         pointData.forEach((item) => {
-            if (!item.lgtd || !item.lttd) {
-                console.warn('Invalid coordinates for point:', item);
+            if (!ValidationUtils.validateCoordinates(item)) {
                 return;
             }
             const pointFeature = new Feature({
@@ -40,32 +120,7 @@ export default class Point {
                 type: options.layerName,
                 geometry: new olPoint([item.lgtd, item.lttd])
             });
-            const style = {};
-            if (options.nameKey) {
-                style.text = new Text({
-                    text: item[options.nameKey],
-                    font: options.textFont || '12px Calibri,sans-serif',
-                    fill: new Fill({
-                        color: options.textFillColor || '#FFF'
-                    }),
-                    stroke: new Stroke({
-                        color: options.textStrokeColor || '#000',
-                        width: options.textStrokeWidth || 3
-                    }),
-                    offsetY: options.textOffsetY || 20,
-                });
-            }
-            if (options.hasImg || options.hasImg === undefined) {
-                const iconOptions = {
-                    src: options.img,
-                    scale: options.scale ?? 1,
-                };
-                if (options.iconColor) {
-                    iconOptions.color = options.iconColor;
-                }
-                style.image = new Icon(iconOptions);
-            }
-            pointFeature.setStyle(new Style(style));
+            pointFeature.setStyle(this.createPointStyle(options, item));
             pointFeatureList.push(pointFeature);
         });
         const PointVectorLayer = new VectorLayer({
@@ -75,19 +130,16 @@ export default class Point {
             }),
             zIndex: options.zIndex || 21,
         });
-        PointVectorLayer.setVisible(options.visible === undefined ? true : options.visible);
-        this.map.addLayer(PointVectorLayer);
+        this.configureLayer(PointVectorLayer, options);
         return PointVectorLayer;
     }
     addClusterPoint(pointData, options) {
-        if (!pointData || pointData.length === 0) {
-            console.warn('Point data is empty or undefined');
+        if (!ValidationUtils.validatePointData(pointData)) {
             return null;
         }
         const pointFeatureList = [];
         pointData.forEach(item => {
-            if (!item.lgtd || !item.lttd) {
-                console.warn('Invalid coordinates for cluster point:', item);
+            if (!ValidationUtils.validateCoordinates(item)) {
                 return;
             }
             const pointFeature = new Feature({
@@ -100,45 +152,20 @@ export default class Point {
             features: pointFeatureList,
         });
         const clusterSource = new Cluster({
-            distance: 40, // The distance for clustering in pixels
+            distance: options.distance || 40, // The distance for clustering in pixels
+            minDistance: options.minDistance || 0,
             source: source,
         });
         const clusterLayer = new VectorLayer({
             layerName: options.layerName,
             source: clusterSource,
-            style: function (feature) {
+            style: (feature) => {
                 const name = feature.get('features')[0].get(options.nameKey);
-                const style = {};
-                if (options.nameKey) {
-                    style.text = new Text({
-                        text: name,
-                        font: options.textFont || '12px Calibri,sans-serif',
-                        fill: new Fill({
-                            color: options.textFillColor || '#FFF'
-                        }),
-                        stroke: new Stroke({
-                            color: options.textStrokeColor || '#000',
-                            width: options.textStrokeWidth || 3
-                        }),
-                        offsetY: options.textOffsetY || 20,
-                    });
-                }
-                if (options.hasImg || options.hasImg === undefined) {
-                    const iconOptions = {
-                        src: options.img,
-                        scale: options.scale ?? 1,
-                    };
-                    if (options.iconColor) {
-                        iconOptions.color = options.iconColor;
-                    }
-                    style.image = new Icon(iconOptions);
-                }
-                return new Style(style);
+                return this.createClusterStyle(options, name);
             },
             zIndex: options.zIndex || 21,
         });
-        clusterLayer.setVisible(options.visible === undefined ? true : options.visible);
-        this.map.addLayer(clusterLayer);
+        this.configureLayer(clusterLayer, options);
         return clusterLayer;
     }
     // 在流域中心添加闪烁点位
@@ -247,8 +274,7 @@ export default class Point {
      * @param duration 动画时长
      */
     locationAction(lgtd, lttd, zoom = 20, duration = 3000) {
-        if (!lgtd || !lttd || isNaN(lgtd) || isNaN(lttd)) {
-            console.error('[地图定位]', '经纬度不能为空或无效');
+        if (!ValidationUtils.validateLngLat(lgtd, lttd)) {
             return false;
         }
         try {
@@ -264,8 +290,11 @@ export default class Point {
      * 设置dom元素为点位
      */
     setDomPoint(id, lgtd, lttd) {
-        if (!id || !lgtd || !lttd || isNaN(lgtd) || isNaN(lttd)) {
-            console.error('Invalid parameters for setDomPoint');
+        if (!id) {
+            console.error('Element ID is required');
+            return false;
+        }
+        if (!ValidationUtils.validateLngLat(lgtd, lttd)) {
             return false;
         }
         const el = document.getElementById(id);
@@ -309,7 +338,7 @@ export default class Point {
         }
         try {
             const layer = pointInfoList.map((pointInfo) => {
-                if (!pointInfo.lgtd || !pointInfo.lttd || isNaN(pointInfo.lgtd) || isNaN(pointInfo.lttd)) {
+                if (!ValidationUtils.validateLngLat(pointInfo.lgtd, pointInfo.lttd)) {
                     throw new Error('Valid longitude and latitude are required for each point');
                 }
                 return new DomPoint(this.map, {

package/dist/core/Polygon.d.ts

@@ -96,6 +96,31 @@ export default class Polygon {
      * @throws 当数据格式无效时抛出错误
      */
     addImageLayer(imageData: ImageLayerData, options?: PolygonOptions): ImageLayer<any>;
+    /**
+     * 尝试更新现有图层
+     * @private
+     */
+    private tryUpdateExistingImageLayer;
+    /**
+     * 创建新的图像图层
+     * @private
+     */
+    private createNewImageLayer;
+    /**
+     * 更新图层属性
+     * @private
+     */
+    private updateImageLayerProperties;
+    /**
+     * 配置图层基本属性
+     * @private
+     */
+    private configureImageLayer;
+    /**
+     * 添加图层到地图并应用裁剪
+     * @private
+     */
+    private addImageLayerToMap;
     /**
      * 添加热力图图层
      * @param pointData 点数据数组

package/dist/core/Polygon.js

@@ -9,6 +9,7 @@ import { fromExtent } from "ol/geom/Polygon";
 import Feature from "ol/Feature";
 import ImageStatic from "ol/source/ImageStatic";
 import MapTools from "./MapTools";
+import { ValidationUtils } from '../utils/ValidationUtils';
 /**
  * Polygon 类用于处理地图上的面要素操作
  * 包括添加多边形、边框、图片图层、热力图等功能
@@ -47,9 +48,7 @@ export default class Polygon {
      * @throws 当数据格式无效时抛出错误
      */
     addBorderPolygon(data, options) {
-        if (!data || !data.features || !Array.isArray(data.features)) {
-            throw new Error('Invalid GeoJSON data: features array is required');
-        }
+        ValidationUtils.validateGeoJSONData(data);
         const mergedOptions = {
             layerName: 'border',
             fillColor: 'rgba(255, 255, 255, 0)',
@@ -69,9 +68,7 @@ export default class Polygon {
      * @throws 当数据格式无效时抛出错误
      */
     addPolygon(dataJSON, options) {
-        if (!dataJSON || !dataJSON.features || !Array.isArray(dataJSON.features)) {
-            throw new Error('Invalid GeoJSON data: features array is required');
-        }
+        ValidationUtils.validateGeoJSONData(dataJSON);
         const mergedOptions = {
             zIndex: 11,
             visible: true,
@@ -185,9 +182,7 @@ export default class Polygon {
      * @throws 当图层不存在时抛出错误
      */
     updateFeatureColor(layerName, colorObj, options) {
-        if (!layerName) {
-            throw new Error('Layer name is required');
-        }
+        ValidationUtils.validateLayerName(layerName);
         const layers = MapTools.getLayerByLayerName(this.map, layerName);
         if (layers.length === 0) {
             throw new Error(`Layer with name '${layerName}' not found`);
@@ -346,12 +341,9 @@ export default class Polygon {
      * @throws 当数据格式无效时抛出错误
      */
     addImageLayer(imageData, options) {
-        if (!imageData || !imageData.img || !imageData.extent) {
-            throw new Error('Invalid image data: img and extent are required');
-        }
-        if (!Array.isArray(imageData.extent) || imageData.extent.length !== 4) {
-            throw new Error('Invalid extent: must be an array of 4 numbers [minX, minY, maxX, maxY]');
-        }
+        // 检查是否允许空img（当存在layerName且存在同名图层时）
+        const allowEmptyImg = !imageData.img && !!options?.layerName;
+        ValidationUtils.validateImageData(imageData, allowEmptyImg);
         const mergedOptions = {
             opacity: 1,
             visible: true,
@@ -359,30 +351,100 @@ export default class Polygon {
             layerName: 'imageLayer',
             ...options
         };
-        // 如果指定了图层名称，先移除同名图层
+        // 尝试更新现有图层
         if (mergedOptions.layerName) {
-            MapTools.removeLayer(this.map, mergedOptions.layerName);
+            const existingLayer = this.tryUpdateExistingImageLayer(imageData, mergedOptions);
+            if (existingLayer) {
+                return existingLayer;
+            }
+        }
+        // 创建新图层
+        return this.createNewImageLayer(imageData, mergedOptions);
+    }
+    /**
+     * 尝试更新现有图层
+     * @private
+     */
+    tryUpdateExistingImageLayer(imageData, options) {
+        const existingLayers = MapTools.getLayerByLayerName(this.map, options.layerName);
+        if (existingLayers.length === 0) {
+            return null;
+        }
+        const existingLayer = existingLayers[0];
+        // 如果没有extent，直接设置source为undefined
+        if (!imageData.extent) {
+            existingLayer.setSource(undefined);
+        }
+        else {
+            // 创建新的source
+            const url = imageData.img || existingLayer.getSource()?.getUrl() || '';
+            const newSource = new ImageStatic({
+                url,
+                imageExtent: imageData.extent
+            });
+            existingLayer.setSource(newSource);
+        }
+        // 更新图层属性
+        this.updateImageLayerProperties(existingLayer, options);
+        return existingLayer;
+    }
+    /**
+     * 创建新的图像图层
+     * @private
+     */
+    createNewImageLayer(imageData, options) {
+        let source = undefined;
+        // 只有当extent存在时才创建ImageStatic source
+        if (imageData.extent) {
+            source = new ImageStatic({
+                url: imageData.img || '',
+                imageExtent: imageData.extent
+            });
         }
-        const source = new ImageStatic({
-            url: imageData.img,
-            imageExtent: imageData.extent
-        });
         const imageLayer = new ImageLayer({
             source,
-            opacity: mergedOptions.opacity,
-            visible: mergedOptions.visible
+            opacity: options.opacity,
+            visible: options.visible
         });
-        imageLayer.set('name', mergedOptions.layerName);
-        imageLayer.set('layerName', mergedOptions.layerName);
-        imageLayer.setZIndex(mergedOptions.zIndex);
-        // 应用地图裁剪
-        if (mergedOptions.mapClip && mergedOptions.mapClipData) {
-            const clippedLayer = MapTools.setMapClip(imageLayer, mergedOptions.mapClipData);
+        this.configureImageLayer(imageLayer, options);
+        return this.addImageLayerToMap(imageLayer, options);
+    }
+    /**
+     * 更新图层属性
+     * @private
+     */
+    updateImageLayerProperties(layer, options) {
+        if (options.opacity !== undefined) {
+            layer.setOpacity(options.opacity);
+        }
+        if (options.visible !== undefined) {
+            layer.setVisible(options.visible);
+        }
+        if (options.zIndex !== undefined) {
+            layer.setZIndex(options.zIndex);
+        }
+    }
+    /**
+     * 配置图层基本属性
+     * @private
+     */
+    configureImageLayer(layer, options) {
+        layer.set('name', options.layerName);
+        layer.set('layerName', options.layerName);
+        layer.setZIndex(options.zIndex);
+    }
+    /**
+     * 添加图层到地图并应用裁剪
+     * @private
+     */
+    addImageLayerToMap(layer, options) {
+        if (options.mapClip && options.mapClipData) {
+            const clippedLayer = MapTools.setMapClip(layer, options.mapClipData);
             this.map.addLayer(clippedLayer);
             return clippedLayer;
         }
-        this.map.addLayer(imageLayer);
-        return imageLayer;
+        this.map.addLayer(layer);
+        return layer;
     }
     /**
      * 添加热力图图层
@@ -427,9 +489,7 @@ export default class Polygon {
      * @throws 当数据格式无效时抛出错误
      */
     addMaskLayer(data, options) {
-        if (!data) {
-            throw new Error('Mask data is required');
-        }
+        ValidationUtils.validateMaskData(data);
         const mergedOptions = {
             fillColor: 'rgba(0, 0, 0, 0.5)',
             opacity: 1,

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export { ConfigManager } from './core/ConfigManager';
 export { EventManager } from './core/EventManager';
 export type { MapEventType, EventCallback, MapEventData } from './core/EventManager';
 export { ErrorHandler, MyOpenLayersError, ErrorType } from './utils/ErrorHandler';
+export { ValidationUtils } from './utils/ValidationUtils';
 export type { BaseOptions, StyleOptions, TextOptions } from './types';
 export type { PointOptions, LineOptions, PolygonOptions } from './types';
 export type { OptionsType } from './types';

package/dist/index.js

@@ -13,3 +13,5 @@ export { ConfigManager } from './core/ConfigManager';
 export { EventManager } from './core/EventManager';
 // 错误处理
 export { ErrorHandler, MyOpenLayersError, ErrorType } from './utils/ErrorHandler';
+// 验证工具
+export { ValidationUtils } from './utils/ValidationUtils';