my-openlayer 0.1.18 → 1.0.1

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

@@ -1,20 +1,107 @@
 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";
+/**
+ * 河流级别宽度映射配置
+ */
+interface RiverLevelWidthMap {
+    [level: number]: number;
+}
+/**
+ * 河流图层配置选项
+ */
+interface RiverLayerOptions extends LineOptions {
+    /** 河流级别数量，默认为5 */
+    levelCount?: number;
+    /** 缩放级别偏移量，默认为8 */
+    zoomOffset?: number;
+    /** 河流级别宽度映射 */
+    levelWidthMap?: RiverLevelWidthMap;
+    /** 是否删除同名图层 */
+    removeExisting?: boolean;
+}
+/**
+ * 线要素管理类
+ * 用于在地图上添加和管理线要素，包括普通线要素、河流图层等
+ *
+ * @example
+ * ```typescript
+ * const lineManager = new Line(map);
+ * const layer = lineManager.addLine(geoJsonData, {
+ *   type: 'road',
+ *   strokeColor: '#ff0000',
+ *   strokeWidth: 3
+ * });
+ * ```
+ */
 export default class Line {
-    private map;
-    riverLayerList: any[];
-    riverLayerShow: boolean;
-    [propertyName: string]: any;
+    /** OpenLayers 地图实例 */
+    private readonly map;
+    /** 河流图层列表 */
+    private riverLayerList;
+    /** 河流图层显示状态 */
+    private riverLayerShow;
+    /** 默认河流级别宽度映射 */
+    private readonly defaultLevelWidthMap;
+    /**
+     * 构造函数
+     * @param map OpenLayers地图实例
+     */
     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 创建的矢量图层
+     */
+    addLine(data: MapJSONData, options?: LineOptions): VectorLayer<VectorSource>;
+    /**
+     * 添加分级河流图层，根据缩放级别显示不同级别的河流
+     * @param fyRiverJson 河流 GeoJSON 数据
+     * @param options 河流图层配置选项
+     * @throws {Error} 当数据格式无效时抛出错误
+     */
+    addRiverLayersByZoom(fyRiverJson: MapJSONData, options?: RiverLayerOptions): void;
+    /**
+     * 显示或隐藏河流图层
+     * @param show 是否显示河流图层
+     */
     showRiverLayer(show: boolean): void;
+    /**
+     * 根据缩放级别显示对应的河流图层
+     * 缩放级别越高，显示的河流级别越详细
+     */
     showRiverLayerByZoom(): void;
-    addRiverWidthByLev(arr?: any): void;
-    setFeatureAttr(feature: {
-        get: (arg0: string) => any;
-    }): Style;
+    /**
+     * 添加按级别显示不同宽度的河流图层
+     * @param data 河流 GeoJSON 数据
+     * @param options 河流图层配置选项
+     * @returns 创建的河流图层
+     */
+    addRiverWidthByLevel(data: MapJSONData, options?: RiverLayerOptions): VectorLayer<VectorSource>;
+    /**
+     * 移除线图层
+     * @param layerName 图层名称
+     */
+    removeLineLayer(layerName: string): void;
+    /**
+     * 清除所有河流图层
+     */
+    clearRiverLayers(): void;
+    /**
+     * 获取河流图层显示状态
+     * @returns 河流图层是否显示
+     */
+    getRiverLayerVisibility(): boolean;
+    /**
+     * 获取河流图层列表
+     * @returns 河流图层数组的副本
+     */
+    getRiverLayers(): VectorLayer<VectorSource>[];
+    /**
+     * 销毁线管理器，清理所有资源
+     */
+    destroy(): void;
 }
+export {};