my-openlayer 2.4.10 → 2.5.1

package/utils/ValidationUtils.js

@@ -1,188 +1,112 @@
 /**
  * 验证工具类
- * 统一管理所有验证方法
+ * 统一管理参数校验逻辑，错误记录由调用方或 ErrorHandler 负责。
  */
-import { ErrorHandler } from './ErrorHandler';
-export class ValidationUtils {
+export default class ValidationUtils {
     /**
-     * 验证坐标是否有效
-     * @param longitude 经度
-     * @param latitude 纬度
-     * @returns 是否有效
+     * 判断值是否为有效数字。
+     */
+    static isFiniteNumber(value) {
+        return typeof value === 'number' && Number.isFinite(value);
+    }
+    /**
+     * 验证坐标是否有效。
      */
     static isValidCoordinate(longitude, latitude) {
-        return (typeof longitude === 'number' &&
-            typeof latitude === 'number' &&
-            !isNaN(longitude) &&
-            !isNaN(latitude) &&
+        return (ValidationUtils.isFiniteNumber(longitude) &&
+            ValidationUtils.isFiniteNumber(latitude) &&
             longitude >= -180 &&
             longitude <= 180 &&
             latitude >= -90 &&
             latitude <= 90);
     }
     /**
-     * 验证经纬度坐标（简化版本）
-     * @param lgtd 经度
-     * @param lttd 纬度
-     * @returns 是否有效
+     * 验证经纬度坐标，保留布尔返回以兼容旧调用。
      */
     static validateLngLat(lgtd, lttd) {
-        if (!lgtd || !lttd || isNaN(lgtd) || isNaN(lttd)) {
-            ErrorHandler.getInstance().error('Invalid longitude or latitude coordinates');
-            return false;
-        }
-        return true;
+        return ValidationUtils.isValidCoordinate(lgtd, lttd);
     }
     /**
-     * 验证点数据数组
-     * @param pointData 点数据数组
-     * @returns 是否有效
+     * 验证点数据数组，保留布尔返回以兼容旧调用。
      */
     static validatePointData(pointData) {
-        if (!pointData || pointData.length === 0) {
-            ErrorHandler.getInstance().warn('Point data is empty or undefined');
-            return false;
-        }
-        return true;
+        return Array.isArray(pointData) && pointData.length > 0;
     }
     /**
-     * 验证单个点的坐标
-     * @param item 包含坐标的数据项
-     * @returns 是否有效
+     * 验证单个点的坐标，保留布尔返回以兼容旧调用。
      */
     static validateCoordinates(item) {
-        if (!item.lgtd || !item.lttd) {
-            ErrorHandler.getInstance().warn('Invalid coordinates for point:', item);
+        if (!item || item.lgtd === undefined || item.lgtd === null || item.lttd === undefined || item.lttd === null) {
             return false;
         }
-        return true;
+        return ValidationUtils.isValidCoordinate(Number(item.lgtd), Number(item.lttd));
     }
     /**
-     * 验证颜色字符串是否有效
-     * @param color 颜色字符串
-     * @returns 是否有效
+     * 验证颜色字符串是否有效。
      */
     static isValidColor(color) {
         if (!color || typeof color !== 'string') {
             return false;
         }
-        // 简单的颜色格式验证
         const colorRegex = /^(#[0-9A-Fa-f]{3,8}|rgba?\([^)]+\)|[a-zA-Z]+)$/;
         return colorRegex.test(color);
     }
     /**
-     * 验证图层名称是否有效
-     * @param layerName 图层名称
-     * @returns 是否有效
+     * 验证图层名称是否有效。
      */
     static isValidLayerName(layerName) {
-        return (typeof layerName === 'string' &&
-            layerName.length > 0 &&
-            layerName.trim().length > 0);
+        return typeof layerName === 'string' && layerName.trim().length > 0;
     }
     /**
-     * 验证范围是否有效
-     * @param extent 范围数组 [minX, minY, maxX, maxY]
-     * @returns 是否有效
+     * 验证范围是否有效。
      */
     static isValidExtent(extent) {
         return (Array.isArray(extent) &&
             extent.length === 4 &&
-            extent.every(coord => typeof coord === 'number' && !isNaN(coord)) &&
-            extent[0] < extent[2] && // minX < maxX
-            extent[1] < extent[3] // minY < maxY
-        );
+            extent.every(coord => ValidationUtils.isFiniteNumber(coord)) &&
+            extent[0] < extent[2] &&
+            extent[1] < extent[3]);
     }
     /**
-     * 验证GeoJSON数据
-     * @param data GeoJSON数据
-     * @returns 是否有效
+     * 验证 GeoJSON 数据，保留布尔返回以兼容旧调用。
      */
     static validateGeoJSONData(data) {
-        if (!data) {
-            ErrorHandler.getInstance().warn('GeoJSON data is required');
-            return false;
-        }
-        if (!data.features || !Array.isArray(data.features)) {
-            ErrorHandler.getInstance().warn('Invalid GeoJSON data: features array is required');
-            return false;
-        }
-        return true;
+        return !!data && Array.isArray(data.features);
     }
     /**
-     * 验证配置选项
-     * @param options 配置选项
-     * @returns 是否有效
+     * 验证配置选项，保留布尔返回以兼容旧调用。
      */
     static validateOptions(options) {
-        if (!options || typeof options !== 'object') {
-            ErrorHandler.getInstance().warn('Options are required and must be an object');
-            return false;
-        }
-        return true;
+        return !!options && typeof options === 'object';
     }
     /**
-     * 验证数值范围
-     * @param value 数值
-     * @param min 最小值
-     * @param max 最大值
-     * @returns 是否有效
+     * 验证数值范围。
      */
     static validateNumberRange(value, min, max) {
-        return (typeof value === 'number' &&
-            !isNaN(value) &&
-            value >= min &&
-            value <= max);
+        return ValidationUtils.isFiniteNumber(value) && value >= min && value <= max;
     }
     /**
-     * 验证DOM元素ID
-     * @param id 元素ID
-     * @returns 是否有效
+     * 验证 DOM 元素 ID，保留布尔返回以兼容旧调用。
      */
     static validateElementId(id) {
-        if (!id) {
-            ErrorHandler.getInstance().error('Element ID is required');
-            return false;
-        }
-        return true;
+        return typeof id === 'string' && id.trim().length > 0;
     }
     /**
-     * 验证Vue相关参数
-     * @param pointInfoList 点位信息列表
-     * @param template Vue组件模板
-     * @param Vue Vue实例
-     * @returns 是否有效
+     * 验证 Vue 相关参数，保留布尔返回以兼容旧调用。
      */
     static validateVueParams(pointInfoList, template, Vue) {
-        if (!pointInfoList || !Array.isArray(pointInfoList) || pointInfoList.length === 0) {
-            ErrorHandler.getInstance().error('Valid point info list is required');
-            return false;
-        }
-        if (!template) {
-            ErrorHandler.getInstance().error('Vue template is required');
-            return false;
-        }
-        if (!Vue) {
-            ErrorHandler.getInstance().error('Vue instance is required');
-            return false;
-        }
-        return true;
+        return Array.isArray(pointInfoList) && pointInfoList.length > 0 && !!template && !!Vue;
     }
     /**
-     * 验证图层名称（抛出异常版本）
-     * @param layerName 图层名称
-     * @throws 如果图层名称无效则抛出异常
+     * 验证图层名称（抛出异常版本）。
      */
     static validateLayerName(layerName) {
-        if (!layerName) {
+        if (!ValidationUtils.isValidLayerName(layerName)) {
             throw new Error('Layer name is required');
         }
     }
     /**
-     * 验证图像数据
-     * @param imageData 图像数据
-     * @param allowEmptyImg 是否允许img为空
-     * @throws 如果图像数据无效则抛出异常
+     * 验证图像数据。
      */
     static validateImageData(imageData, allowEmptyImg = false) {
         if (!imageData) {
@@ -191,53 +115,38 @@ export class ValidationUtils {
         if (!allowEmptyImg && !imageData.img) {
             throw new Error('Invalid image data: img is required');
         }
-        if (imageData.extent && (!Array.isArray(imageData.extent) || imageData.extent.length !== 4)) {
+        if (imageData.extent && !ValidationUtils.isValidExtent(imageData.extent)) {
             throw new Error('Invalid extent: must be an array of 4 numbers [minX, minY, maxX, maxY]');
         }
     }
     /**
-     * 验证遮罩数据
-     * @param data 遮罩数据
-     * @throws 如果遮罩数据无效则抛出异常
+     * 验证遮罩数据。
      */
     static validateMaskData(data) {
-        if (!data) {
+        if (data === undefined || data === null) {
             throw new Error('Mask data is required');
         }
     }
     /**
-     * 验证地图实例
-     * @param map 地图实例
-     * @throws 如果地图实例无效则抛出异常
+     * 验证地图实例。
      */
     static validateMapInstance(map) {
-        if (!map) {
-            throw new Error('Map instance is required');
-        }
+        ValidationUtils.validateMap(map);
     }
     /**
-     * 验证必需参数
-     * @param value 要验证的值
-     * @param message 错误消息
-     * @throws 如果值为空则抛出异常
+     * 验证必需参数。
      */
     static validateRequired(value, message) {
-        if (!value) {
+        if (value === undefined || value === null || value === '') {
             throw new Error(message);
         }
     }
     /**
-     * 验证坐标（抛出异常版本）
-     * @param longitude 经度
-     * @param latitude 纬度
-     * @throws 如果坐标无效则抛出异常
+     * 验证坐标（抛出异常版本）。
      */
     static validateCoordinate(longitude, latitude) {
-        if (typeof longitude !== 'number' || typeof latitude !== 'number') {
-            throw new Error('Longitude and latitude must be numbers');
-        }
-        if (isNaN(longitude) || isNaN(latitude)) {
-            throw new Error('Valid longitude and latitude are required');
+        if (!ValidationUtils.isFiniteNumber(longitude) || !ValidationUtils.isFiniteNumber(latitude)) {
+            throw new Error('Longitude and latitude must be valid numbers');
         }
         if (longitude < -180 || longitude > 180) {
             throw new Error('Longitude must be between -180 and 180');
@@ -247,11 +156,7 @@ export class ValidationUtils {
         }
     }
     /**
-     * 验证类型
-     * @param value 要验证的值
-     * @param expectedType 期望的类型
-     * @param message 错误消息
-     * @throws 如果类型不匹配则抛出异常
+     * 验证类型。
      */
     static validateType(value, expectedType, message) {
         if (typeof value !== expectedType) {
@@ -259,20 +164,15 @@ export class ValidationUtils {
         }
     }
     /**
-     * 验证非空字符串（抛出异常版本）
-     * @param str 字符串
-     * @param message 错误消息
-     * @throws 如果字符串为空则抛出异常
+     * 验证非空字符串。
      */
     static validateNonEmptyString(str, message) {
-        if (!str || typeof str !== 'string') {
+        if (!ValidationUtils.isValidLayerName(str)) {
             throw new Error(message);
         }
     }
     /**
-     * 验证地图实例（通用版本）
-     * @param map 地图实例
-     * @throws 如果地图实例无效则抛出异常
+     * 验证地图实例（通用版本）。
      */
     static validateMap(map) {
         if (!map) {
@@ -280,33 +180,28 @@ export class ValidationUtils {
         }
     }
     /**
-     * 验证测量类型
-     * @param type 测量类型
-     * @throws 如果测量类型无效则抛出异常
+     * 验证测量类型。
      */
     static validateMeasureType(type) {
-        if (!type || (type !== 'LineString' && type !== 'Polygon')) {
+        if (type !== 'LineString' && type !== 'Polygon') {
             throw new Error('Invalid measure type. Must be "LineString" or "Polygon"');
         }
     }
     /**
-     * 验证正数
-     * @param value 数值
-     * @param message 错误消息
-     * @throws 如果数值不是正数则抛出异常
+     * 验证正数。
      */
     static validatePositiveNumber(value, message) {
-        if (!value || value <= 0) {
+        if (!ValidationUtils.isFiniteNumber(value) || value <= 0) {
             throw new Error(message);
         }
     }
     /**
-     * 验证图层名称参数
-     * @param layerName 图层名称（字符串或字符串数组）
-     * @throws 如果图层名称参数无效则抛出异常
+     * 验证图层名称参数。
      */
     static validateLayerNameParam(layerName) {
-        if (!layerName || (typeof layerName !== 'string' && !Array.isArray(layerName))) {
+        const isValidString = typeof layerName === 'string' && layerName.trim().length > 0;
+        const isValidArray = Array.isArray(layerName) && layerName.length > 0 && layerName.every(ValidationUtils.isValidLayerName);
+        if (!isValidString && !isValidArray) {
             throw new Error('Valid layer name is required');
         }
     }

package/core/DomPoint.d.ts

@@ -1,21 +0,0 @@
-import Map from "ol/Map";
-interface Options {
-    Vue: any;
-    Template: any;
-    lgtd: number;
-    lttd: number;
-    props?: any;
-    type?: string;
-    sttp?: string;
-    zIndex?: number;
-}
-export default class DomPoint {
-    private map;
-    private app;
-    private anchor;
-    private dom;
-    constructor(map: Map, options: Options);
-    setVisible(visible: boolean): void;
-    remove(): void;
-}
-export {};

package/core/DomPoint.js

@@ -1,36 +0,0 @@
-// import { createApp } from "vue";
-import Overlay from "ol/Overlay";
-export default class DomPoint {
-    constructor(map, options) {
-        this.map = map;
-        const { Vue, Template, lgtd, lttd, props, } = options;
-        this.dom = document.createElement('div');
-        this.map.getViewport().appendChild(this.dom);
-        if (Vue.version.startsWith('3')) {
-            this.app = Vue.createApp(Object.assign(Template, {
-                props: { ...props }
-            }));
-            this.app.mount(this.dom);
-        }
-        else {
-            this.app = new Vue({
-                el: this.dom,
-                render: (h) => h(Template, { props })
-            });
-        }
-        this.anchor = new Overlay({
-            element: this.dom,
-            positioning: 'center-center',
-            stopEvent: false
-        });
-        this.anchor.setPosition([lgtd, lttd]);
-        this.map.addOverlay(this.anchor);
-    }
-    setVisible(visible) {
-        this.dom.style.visibility = visible ? 'visible' : 'hidden';
-    }
-    remove() {
-        this.app.unmount();
-        this.map.removeOverlay(this.anchor);
-    }
-}

package/core/Line.d.ts

@@ -1,49 +0,0 @@
-import Map from "ol/Map";
-import VectorSource from "ol/source/Vector";
-import VectorLayer from "ol/layer/Vector";
-import { LineOptions, MapJSONData } from "../types";
-/**
- * 线要素管理类
- * 用于在地图上添加和管理线要素
- *
- * @example
- * ```typescript
- * const lineManager = new Line(map);
- * const layer = lineManager.addLine(geoJsonData, {
- *   type: 'road',
- *   strokeColor: '#ff0000',
- *   strokeWidth: 3
- * });
- * ```
- */
-export default class Line {
-    /** OpenLayers 地图实例 */
-    private readonly map;
-    private mergeDefaultOptions;
-    private createStyleFunction;
-    private createLayer;
-    /**
-     * 构造函数
-     * @param map OpenLayers地图实例
-     */
-    constructor(map: Map);
-    /**
-     * 添加线要素
-     * @param data GeoJSON格式的线数据
-     * @param options 配置项
-     * @returns 创建的矢量图层
-     */
-    addLine(data: MapJSONData, options?: LineOptions): VectorLayer<VectorSource>;
-    /**
-     * 从URL添加线要素
-     * @param url 数据URL
-     * @param options 配置项
-     * @returns 创建的矢量图层
-     */
-    addLineByUrl(url: string, options?: LineOptions): VectorLayer<VectorSource>;
-    /**
-     * 移除线图层
-     * @param layerName 图层名称
-     */
-    removeLineLayer(layerName: string): void;
-}

package/core/Line.js

@@ -1,114 +0,0 @@
-import VectorSource from "ol/source/Vector";
-import GeoJSON from "ol/format/GeoJSON";
-import VectorLayer from "ol/layer/Vector";
-import { Stroke, Style } from "ol/style";
-import { Feature } from "ol";
-import MapTools from "./MapTools";
-import { ValidationUtils } from "../utils/ValidationUtils";
-import { ConfigManager } from "./ConfigManager";
-/**
- * 线要素管理类
- * 用于在地图上添加和管理线要素
- *
- * @example
- * ```typescript
- * const lineManager = new Line(map);
- * const layer = lineManager.addLine(geoJsonData, {
- *   type: 'road',
- *   strokeColor: '#ff0000',
- *   strokeWidth: 3
- * });
- * ```
- */
-export default class Line {
-    mergeDefaultOptions(options) {
-        const layerName = options?.layerName || ConfigManager.DEFAULT_LINE_OPTIONS.layerName;
-        const defaultOptions = {
-            ...ConfigManager.DEFAULT_LINE_OPTIONS,
-            layerName
-        };
-        const mergedOptions = { ...defaultOptions, ...options };
-        return { ...mergedOptions, layerName };
-    }
-    createStyleFunction(mergedOptions) {
-        return (feature) => {
-            if (feature instanceof Feature) {
-                feature.set('type', mergedOptions.type);
-                feature.set('layerName', mergedOptions.layerName);
-            }
-            if (mergedOptions.style) {
-                if (typeof mergedOptions.style === 'function') {
-                    return mergedOptions.style(feature);
-                }
-                else {
-                    return mergedOptions.style;
-                }
-            }
-            return new Style({
-                stroke: new Stroke({
-                    color: mergedOptions.strokeColor,
-                    width: mergedOptions.strokeWidth,
-                    lineDash: mergedOptions.lineDash,
-                    lineDashOffset: mergedOptions.lineDashOffset
-                })
-            });
-        };
-    }
-    createLayer(source, mergedOptions) {
-        const layer = new VectorLayer({
-            properties: {
-                name: mergedOptions.layerName,
-                layerName: mergedOptions.layerName
-            },
-            source,
-            style: this.createStyleFunction(mergedOptions),
-            zIndex: mergedOptions.zIndex
-        });
-        layer.setVisible(mergedOptions.visible);
-        this.map.addLayer(layer);
-        return layer;
-    }
-    /**
-     * 构造函数
-     * @param map OpenLayers地图实例
-     */
-    constructor(map) {
-        ValidationUtils.validateMapInstance(map);
-        this.map = map;
-    }
-    /**
-     * 添加线要素
-     * @param data GeoJSON格式的线数据
-     * @param options 配置项
-     * @returns 创建的矢量图层
-     */
-    addLine(data, options) {
-        ValidationUtils.validateGeoJSONData(data);
-        const mergedOptions = this.mergeDefaultOptions(options);
-        const features = new GeoJSON().readFeatures(data, options?.projectionOptOptions);
-        const source = new VectorSource({ features });
-        return this.createLayer(source, mergedOptions);
-    }
-    /**
-     * 从URL添加线要素
-     * @param url 数据URL
-     * @param options 配置项
-     * @returns 创建的矢量图层
-     */
-    addLineByUrl(url, options = {}) {
-        const mergedOptions = this.mergeDefaultOptions(options);
-        const source = new VectorSource({
-            url,
-            format: new GeoJSON(options.projectionOptOptions)
-        });
-        return this.createLayer(source, mergedOptions);
-    }
-    /**
-     * 移除线图层
-     * @param layerName 图层名称
-     */
-    removeLineLayer(layerName) {
-        ValidationUtils.validateLayerName(layerName);
-        MapTools.removeLayer(this.map, layerName);
-    }
-}