my-openlayer 0.1.17 → 1.0.0

package/dist/core/EventManager.js

@@ -0,0 +1,257 @@
+import { ErrorHandler, ErrorType } from '../utils/ErrorHandler';
+/**
+ * 事件管理器类
+ * 用于统一管理地图事件的注册、触发和移除
+ */
+export class EventManager {
+    /**
+     * 构造函数
+     * @param map OpenLayers地图实例
+     */
+    constructor(map) {
+        this.listeners = new Map();
+        this.eventCounters = new Map();
+        ErrorHandler.validateMap(map);
+        this.map = map;
+        this.initializeEventCounters();
+    }
+    /**
+     * 初始化事件计数器
+     */
+    initializeEventCounters() {
+        const eventTypes = ['click', 'dblclick', 'hover', 'moveend', 'zoomend', 'pointermove'];
+        eventTypes.forEach(type => {
+            this.eventCounters.set(type, 0);
+        });
+    }
+    /**
+     * 注册事件监听器
+     * @param type 事件类型
+     * @param callback 回调函数
+     * @param options 选项
+     * @returns 事件监听器ID
+     */
+    on(type, callback, options) {
+        ErrorHandler.validate(typeof callback === 'function', 'Event callback must be a function', { type, callback });
+        const id = this.generateListenerId(type);
+        const listener = {
+            id,
+            type,
+            callback,
+            options
+        };
+        this.listeners.set(id, listener);
+        this.attachMapEvent(type);
+        return id;
+    }
+    /**
+     * 移除事件监听器
+     * @param id 监听器ID
+     */
+    off(id) {
+        const listener = this.listeners.get(id);
+        if (!listener) {
+            return false;
+        }
+        this.listeners.delete(id);
+        this.detachMapEventIfNeeded(listener.type);
+        return true;
+    }
+    /**
+     * 移除指定类型的所有事件监听器
+     * @param type 事件类型
+     */
+    offAll(type) {
+        const idsToRemove = [];
+        this.listeners.forEach((listener, id) => {
+            if (listener.type === type) {
+                idsToRemove.push(id);
+            }
+        });
+        idsToRemove.forEach(id => {
+            this.listeners.delete(id);
+        });
+        this.detachMapEventIfNeeded(type);
+    }
+    /**
+     * 清除所有事件监听器
+     */
+    clear() {
+        this.listeners.clear();
+        this.eventCounters.forEach((_, type) => {
+            this.detachMapEventIfNeeded(type);
+        });
+    }
+    /**
+     * 获取指定类型的监听器数量
+     * @param type 事件类型
+     */
+    getListenerCount(type) {
+        let count = 0;
+        this.listeners.forEach((listener) => {
+            if (listener.type === type) {
+                count++;
+            }
+        });
+        return count;
+    }
+    /**
+     * 生成监听器ID
+     * @param type 事件类型
+     */
+    generateListenerId(type) {
+        const counter = this.eventCounters.get(type) || 0;
+        this.eventCounters.set(type, counter + 1);
+        return `${type}_${counter + 1}_${Date.now()}`;
+    }
+    /**
+     * 附加地图事件
+     * @param type 事件类型
+     */
+    attachMapEvent(type) {
+        const existingListeners = this.getListenerCount(type);
+        if (existingListeners > 1) {
+            return; // 已经附加过该类型的事件
+        }
+        switch (type) {
+            case 'click':
+                this.map.on('click', this.handleClickEvent.bind(this));
+                break;
+            case 'dblclick':
+                this.map.on('dblclick', this.handleDblClickEvent.bind(this));
+                break;
+            case 'hover':
+            case 'pointermove':
+                this.map.on('pointermove', this.handlePointerMoveEvent.bind(this));
+                break;
+            case 'moveend':
+                this.map.on('moveend', this.handleMoveEndEvent.bind(this));
+                break;
+            case 'zoomend':
+                this.map.getView().on('change:resolution', this.handleZoomEndEvent.bind(this));
+                break;
+        }
+    }
+    /**
+     * 分离地图事件（如果不再需要）
+     * @param type 事件类型
+     */
+    detachMapEventIfNeeded(type) {
+        const remainingListeners = this.getListenerCount(type);
+        if (remainingListeners > 0) {
+            return; // 还有其他监听器需要该事件
+        }
+        // 注意：OpenLayers 不提供直接移除特定事件监听器的方法
+        // 这里只是示例，实际实现可能需要保存事件监听器的引用
+        console.warn(`Event type '${type}' detachment not fully implemented`);
+    }
+    /**
+     * 处理点击事件
+     * @param event 地图浏览器事件
+     */
+    handleClickEvent(event) {
+        const eventData = this.createEventData('click', event);
+        this.triggerListeners('click', eventData);
+    }
+    /**
+     * 处理双击事件
+     * @param event 地图浏览器事件
+     */
+    handleDblClickEvent(event) {
+        const eventData = this.createEventData('dblclick', event);
+        this.triggerListeners('dblclick', eventData);
+    }
+    /**
+     * 处理指针移动事件
+     * @param event 地图浏览器事件
+     */
+    handlePointerMoveEvent(event) {
+        const eventData = this.createEventData('pointermove', event);
+        this.triggerListeners('hover', eventData);
+        this.triggerListeners('pointermove', eventData);
+    }
+    /**
+     * 处理移动结束事件
+     */
+    handleMoveEndEvent() {
+        const eventData = {
+            type: 'moveend',
+            zoom: this.map.getView().getZoom(),
+            coordinate: this.map.getView().getCenter()
+        };
+        this.triggerListeners('moveend', eventData);
+    }
+    /**
+     * 处理缩放结束事件
+     */
+    handleZoomEndEvent() {
+        const eventData = {
+            type: 'zoomend',
+            zoom: this.map.getView().getZoom(),
+            coordinate: this.map.getView().getCenter()
+        };
+        this.triggerListeners('zoomend', eventData);
+    }
+    /**
+     * 创建事件数据
+     * @param type 事件类型
+     * @param event 原始事件
+     */
+    createEventData(type, event) {
+        const pixel = this.map.getEventPixel(event.originalEvent);
+        const features = this.map.getFeaturesAtPixel(pixel);
+        return {
+            type,
+            originalEvent: event.originalEvent,
+            coordinate: event.coordinate,
+            pixel,
+            features,
+            feature: features.length > 0 ? features[0] : undefined
+        };
+    }
+    /**
+     * 触发监听器
+     * @param type 事件类型
+     * @param eventData 事件数据
+     */
+    triggerListeners(type, eventData) {
+        const typeListeners = [];
+        this.listeners.forEach((listener) => {
+            if (listener.type === type) {
+                typeListeners.push(listener);
+            }
+        });
+        typeListeners.forEach((listener) => {
+            try {
+                // 应用过滤器
+                if (listener.options?.filter && !listener.options.filter(eventData)) {
+                    return;
+                }
+                // 执行回调
+                listener.callback(eventData);
+                // 如果是一次性监听器，移除它
+                if (listener.options?.once) {
+                    this.off(listener.id);
+                }
+            }
+            catch (error) {
+                ErrorHandler.getInstance().createAndHandleError(`Error in event listener: ${error}`, ErrorType.COMPONENT_ERROR, { listener, eventData, error });
+            }
+        });
+    }
+    /**
+     * 获取监听器信息（用于调试）
+     */
+    getListenersInfo() {
+        const result = [];
+        this.listeners.forEach((listener) => {
+            result.push({
+                id: listener.id,
+                type: listener.type,
+                hasFilter: !!listener.options?.filter,
+                isOnce: !!listener.options?.once
+            });
+        });
+        return result;
+    }
+}

package/dist/core/Line.d.ts

@@ -2,15 +2,31 @@ import Map from "ol/Map";
 import VectorSource from "ol/source/Vector";
 import VectorLayer from "ol/layer/Vector";
 import { Style } from "ol/style";
-import { OptionsType, MapJSONData } from "../types";
+import { LineOptions, MapJSONData } from "../types";
+/**
+ * 线要素管理类
+ * 用于在地图上添加和管理线要素
+ */
 export default class Line {
-    private map;
+    private readonly map;
     riverLayerList: any[];
     riverLayerShow: boolean;
     [propertyName: string]: any;
+    /**
+     * 构造函数
+     * @param map OpenLayers地图实例
+     * @throws 当地图实例无效时抛出错误
+     */
     constructor(map: Map);
-    addLine(data: MapJSONData, options: OptionsType): VectorLayer<VectorSource<import("ol/geom").Geometry>>;
-    addRiverLayersByZoom(fyRiverJson: MapJSONData, options?: OptionsType): void;
+    /**
+     * 添加线要素
+     * @param data GeoJSON格式的线数据
+     * @param options 配置项
+     * @returns 创建的矢量图层
+     * @throws 当数据格式无效时抛出错误
+     */
+    addLine(data: MapJSONData, options: LineOptions): VectorLayer<VectorSource>;
+    addRiverLayersByZoom(fyRiverJson: MapJSONData, options?: LineOptions): void;
     showRiverLayer(show: boolean): void;
     showRiverLayerByZoom(): void;
     addRiverWidthByLev(arr?: any): void;

package/dist/core/Line.js

@@ -3,18 +3,53 @@ import GeoJSON from "ol/format/GeoJSON";
 import VectorLayer from "ol/layer/Vector";
 import { Stroke, Style } from "ol/style";
 import MapTools from "./MapTools";
+/**
+ * 线要素管理类
+ * 用于在地图上添加和管理线要素
+ */
 export default class Line {
+    /**
+     * 构造函数
+     * @param map OpenLayers地图实例
+     * @throws 当地图实例无效时抛出错误
+     */
     constructor(map) {
         this.riverLayerList = [];
         this.riverLayerShow = false;
+        if (!map) {
+            throw new Error('Map instance is required');
+        }
         this.map = map;
     }
+    /**
+     * 添加线要素
+     * @param data GeoJSON格式的线数据
+     * @param options 配置项
+     * @returns 创建的矢量图层
+     * @throws 当数据格式无效时抛出错误
+     */
     addLine(data, options) {
+        if (!data) {
+            throw new Error('Line data is required');
+        }
+        if (!options || !options.type) {
+            throw new Error('Options with type is required');
+        }
+        let features;
+        try {
+            features = new GeoJSON().readFeatures(data);
+        }
+        catch (error) {
+            throw new Error(`Invalid GeoJSON data: ${error}`);
+        }
+        if (!features || features.length === 0) {
+            console.warn('No features found in line data');
+        }
         const layer = new VectorLayer({
             name: options.layerName,
             layerName: options.layerName,
             source: new VectorSource({
-                features: (new GeoJSON()).readFeatures(data)
+                features: features
             }),
             style: function (feature) {
                 feature.set('type', options.type);

package/dist/core/MapBaseLayers.d.ts

@@ -1,5 +1,7 @@
 /**
- * 地图底图图层
+ * 地图底图图层管理类
+ * 提供天地图底图、注记图层、GeoServer图层等功能
+ * 支持图层切换、裁剪等高级功能
  */
 import Map from "ol/Map";
 import { Tile as TileLayer } from "ol/layer";
@@ -7,30 +9,196 @@ import { TileWMS } from "ol/source";
 import WMTSTileGrid from "ol/tilegrid/WMTS";
 import XYZ from "ol/source/XYZ";
 import { MapLayersOptions, TiandituType, AnnotationLayerOptions } from "../types";
+/**
+ * GeoServer图层选项接口
+ */
+interface GeoServerLayerOptions {
+    /** 图层层级 */
+    zIndex?: number;
+    /** 图层可见性 */
+    visible?: boolean;
+    /** WMS版本 */
+    version?: '1.1.1' | '1.3.0';
+    /** 服务器类型 */
+    serverType?: string;
+    /** 跨域设置 */
+    crossOrigin?: string;
+    /** WMS参数 */
+    params?: Record<string, any>;
+}
+/**
+ * 天地图图层选项接口
+ */
+interface TiandituLayerOptions {
+    /** 图层类型 */
+    type: TiandituType;
+    /** 天地图token */
+    token: string;
+    /** 图层层级 */
+    zIndex: number;
+    /** 图层可见性 */
+    visible: boolean;
+}
+/**
+ * 地图底图图层管理类
+ */
 export default class MapBaseLayers {
-    private map;
+    private readonly map;
     private readonly options;
-    private readonly layers;
+    private layers;
+    private readonly errorHandler;
+    private currentBaseLayerType;
+    /**
+     * 构造函数
+     * @param map OpenLayers地图实例
+     * @param options 图层配置选项
+     */
     constructor(map: Map, options: MapLayersOptions);
+    /**
+     * 验证构造函数参数
+     * @param map 地图实例
+     * @param options 配置选项
+     * @private
+     */
+    private validateConstructorParams;
+    /**
+     * 合并默认配置选项
+     * @param options 用户配置选项
+     * @returns 合并后的配置选项
+     * @private
+     */
+    private mergeDefaultOptions;
+    /**
+     * 初始化图层
+     * @private
+     */
+    private initializeLayers;
+    /**
+     * 初始化天地图图层
+     * @private
+     */
+    private initTiandituLayers;
+    /**
+     * 添加注记图层
+     * @param token 天地图token
+     * @param baseZIndex 基础层级
+     * @private
+     */
+    private addAnnotationLayers;
+    /**
+     * 切换底图图层
+     * @param type 图层类型
+     */
     switchBaseLayer(type: TiandituType): void;
-    initLayer(): void;
-    addAnnotationLayer(options: Omit<AnnotationLayerOptions, 'token'>): void;
+    /**
+     * 获取当前底图类型
+     * @returns 当前底图类型
+     */
+    getCurrentBaseLayerType(): string | null;
+    /**
+     * 获取可用的图层类型列表
+     * @returns 图层类型数组
+     */
+    getAvailableLayerTypes(): string[];
+    /**
+     * 检查指定图层类型是否存在
+     * @param type 图层类型
+     * @returns 是否存在
+     */
+    hasLayerType(type: string): boolean;
+    /**
+     * 添加注记图层（实例方法）
+     * @param options 注记图层选项（不包含token）
+     * @returns 创建的图层
+     */
+    addAnnotationLayer(options: Omit<AnnotationLayerOptions, 'token'>): TileLayer<XYZ>;
+    /**
+     * 添加注记图层（静态方法）
+     * @param map 地图实例
+     * @param options 注记图层选项
+     * @returns 创建的图层
+     */
     static addAnnotationLayer(map: Map, options: AnnotationLayerOptions): TileLayer<XYZ>;
-    addMapLayer(): void;
-    createLayer(layer: any): any;
-    addGeoServerLayer(url: string, layer: string, options: {
-        zIndex?: number;
-        visible?: boolean;
-    }): TileLayer<TileWMS>;
-    static getTiandiTuLayer(options: {
-        type: TiandituType;
-        token: string;
-        zIndex: number;
-        visible: boolean;
-    }): TileLayer<XYZ>;
-    /**
-     * 地图注记
+    /**
+     * 将所有图层添加到地图
+     * @private
+     */
+    private addMapLayer;
+    /**
+     * 处理图层（应用裁剪等）
+     * @param layer 原始图层
+     * @returns 处理后的图层
+     * @private
+     */
+    private processLayer;
+    /**
+     * 添加GeoServer图层
+     * @param url GeoServer服务URL
+     * @param layerName 图层名称
+     * @param options 图层选项
+     * @returns 创建的WMS图层
+     */
+    addGeoServerLayer(url: string, layerName: string, options?: GeoServerLayerOptions): TileLayer<TileWMS>;
+    /**
+     * 创建天地图图层（实例方法）
+     * @param options 天地图图层选项
+     * @returns 创建的图层
+     * @private
+     */
+    private createTiandituLayer;
+    /**
+     * 创建注记图层（实例方法）
+     * @param options 注记图层选项
+     * @returns 创建的图层
+     * @private
+     */
+    private createAnnotationLayer;
+    /**
+     * 创建天地图底图图层（静态方法）
+     * @param options 天地图图层选项
+     * @returns 创建的图层
+     */
+    static getTiandiTuLayer(options: TiandituLayerOptions): TileLayer<XYZ>;
+    /**
+     * 创建天地图注记图层（静态方法）
+     * @param options 注记图层选项
+     * @returns 创建的图层
+     */
+    static createAnnotationLayer(options: AnnotationLayerOptions): TileLayer<XYZ>;
+    /**
+     * 获取天地图注记图层（向后兼容的静态方法）
+     * @param options 注记图层选项
+     * @returns 创建的图层
+     * @deprecated 使用 createAnnotationLayer 替代
      */
     static getAnnotationLayer(options: AnnotationLayerOptions): TileLayer<XYZ>;
+    /**
+     * 创建WMTS瓦片网格
+     * @param length 层级数量
+     * @returns WMTS瓦片网格
+     */
     static getTileGrid(length: number): WMTSTileGrid;
+    /**
+     * 移除指定类型的图层
+     * @param type 图层类型
+     */
+    removeLayersByType(type: string): void;
+    /**
+     * 清除所有图层
+     */
+    clearAllLayers(): void;
+    /**
+     * 获取图层数量统计
+     * @returns 图层统计信息
+     */
+    getLayerStats(): {
+        totalTypes: number;
+        totalLayers: number;
+        layersByType: Record<string, number>;
+    };
+    /**
+     * 销毁实例，清理资源
+     */
+    destroy(): void;
 }
+export {};