my-openlayer 2.4.10 → 2.5.1

package/core/line/LineFlowAnimator.d.ts

@@ -0,0 +1,53 @@
+import Map from 'ol/Map';
+import { LineString } from 'ol/geom';
+import type { FlowLineLayerHandle, FlowLineOptions } from '../../types';
+/**
+ * 流动线动画器
+ * 负责动画生命周期、postrender 与 RAF 驱动。
+ */
+export default class LineFlowAnimator {
+    private readonly map;
+    private readonly onRemove?;
+    private readonly maxSymbolCount;
+    private readonly styleFactory;
+    private readonly animationPointGeometry;
+    private readonly animationPointFeature;
+    private options;
+    private normalizedFeatures;
+    private baseSource;
+    private animationSource;
+    private baseLayer;
+    private animationLayer;
+    private dashStyle;
+    private state;
+    private startTime;
+    private pausedAt;
+    private pausedDuration;
+    private frozenProgress;
+    private rafId;
+    private postrenderKey;
+    constructor(map: Map, data: unknown, options?: FlowLineOptions, onRemove?: (layerName: string) => void);
+    createHandle(): FlowLineLayerHandle | null;
+    getProgressByTime(now: number, startTime: number, duration: number, speed: number, loop: boolean): number;
+    getCoordinateAndRotation(line: LineString, progress: number): {
+        coordinate: number[];
+        rotation: number;
+    };
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    setVisible(visible: boolean): void;
+    updateData(data: unknown): void;
+    remove(): void;
+    private createBaseLayer;
+    private createAnimationLayer;
+    private normalizeOptions;
+    private updateSources;
+    private bindPostrender;
+    private unbindPostrender;
+    private startRafLoop;
+    private stopRafLoop;
+    private getCurrentProgress;
+    private getNow;
+}

package/core/line/LineFlowAnimator.js

@@ -0,0 +1,297 @@
+import Feature from 'ol/Feature';
+import { LineString, Point as OlPoint } from 'ol/geom';
+import VectorLayer from 'ol/layer/Vector';
+import VectorSource from 'ol/source/Vector';
+import { getVectorContext } from 'ol/render';
+import { unByKey } from 'ol/Observable';
+import { ConfigManager } from '../map';
+import LineFeatureFactory from './LineFeatureFactory';
+import LineStyleFactory from './LineStyleFactory';
+/**
+ * 流动线动画器
+ * 负责动画生命周期、postrender 与 RAF 驱动。
+ */
+export default class LineFlowAnimator {
+    constructor(map, data, options = {}, onRemove) {
+        this.maxSymbolCount = 12;
+        this.styleFactory = new LineStyleFactory();
+        this.animationPointGeometry = new OlPoint([0, 0]);
+        this.animationPointFeature = new Feature(this.animationPointGeometry);
+        this.normalizedFeatures = [];
+        this.baseSource = new VectorSource();
+        this.animationSource = new VectorSource();
+        this.dashStyle = this.styleFactory.createDashStyle(ConfigManager.DEFAULT_FLOW_LINE_OPTIONS);
+        this.state = 'stopped';
+        this.startTime = 0;
+        this.pausedAt = 0;
+        this.pausedDuration = 0;
+        this.frozenProgress = 0;
+        this.rafId = null;
+        this.postrenderKey = null;
+        this.map = map;
+        this.onRemove = onRemove;
+        this.options = this.normalizeOptions(options);
+        this.normalizedFeatures = LineFeatureFactory.normalizeLineFeatures(data, this.options);
+        this.dashStyle = this.styleFactory.createDashStyle(this.options);
+        this.baseLayer = this.createBaseLayer();
+        this.animationLayer = this.createAnimationLayer();
+        this.updateSources(this.normalizedFeatures);
+    }
+    createHandle() {
+        if (this.normalizedFeatures.length === 0) {
+            return null;
+        }
+        this.map.addLayer(this.baseLayer);
+        this.map.addLayer(this.animationLayer);
+        if (this.options.autoStart) {
+            this.start();
+        }
+        return {
+            layer: this.baseLayer,
+            animationLayer: this.animationLayer,
+            start: () => this.start(),
+            pause: () => this.pause(),
+            resume: () => this.resume(),
+            stop: () => this.stop(),
+            setVisible: (visible) => this.setVisible(visible),
+            updateData: (data) => this.updateData(data),
+            remove: () => this.remove()
+        };
+    }
+    getProgressByTime(now, startTime, duration, speed, loop) {
+        const safeDuration = duration > 0 ? duration : ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.duration;
+        const safeSpeed = speed > 0 ? speed : 1;
+        const elapsed = Math.max(0, now - startTime) * safeSpeed;
+        const progress = elapsed / safeDuration;
+        if (loop) {
+            return progress % 1;
+        }
+        return Math.min(progress, 1);
+    }
+    getCoordinateAndRotation(line, progress) {
+        const safeProgress = Math.max(0, Math.min(progress, 1));
+        const epsilon = 0.0001;
+        const coordinate = line.getCoordinateAt(safeProgress);
+        const nextCoordinate = line.getCoordinateAt(Math.min(safeProgress + epsilon, 1));
+        const dx = nextCoordinate[0] - coordinate[0];
+        const dy = nextCoordinate[1] - coordinate[1];
+        return {
+            coordinate,
+            rotation: Math.atan2(dy, dx)
+        };
+    }
+    start() {
+        if (this.state === 'removed' || this.state === 'running' || this.normalizedFeatures.length === 0) {
+            return;
+        }
+        this.bindPostrender();
+        this.state = 'running';
+        this.startTime = this.getNow();
+        this.pausedAt = 0;
+        this.pausedDuration = 0;
+        this.frozenProgress = 0;
+        this.startRafLoop();
+    }
+    pause() {
+        if (this.state !== 'running') {
+            return;
+        }
+        this.frozenProgress = this.getCurrentProgress();
+        this.pausedAt = this.getNow();
+        this.state = 'paused';
+        this.stopRafLoop();
+        this.animationLayer.changed();
+    }
+    resume() {
+        if (this.state !== 'paused') {
+            return;
+        }
+        const now = this.getNow();
+        this.pausedDuration += now - this.pausedAt;
+        this.pausedAt = 0;
+        this.state = 'running';
+        this.bindPostrender();
+        this.startRafLoop();
+    }
+    stop() {
+        if (this.state === 'removed') {
+            return;
+        }
+        this.state = 'stopped';
+        this.frozenProgress = 0;
+        this.pausedAt = 0;
+        this.pausedDuration = 0;
+        this.startTime = 0;
+        this.stopRafLoop();
+        this.animationLayer.changed();
+    }
+    setVisible(visible) {
+        this.baseLayer.setVisible(visible);
+        this.animationLayer.setVisible(visible);
+    }
+    updateData(data) {
+        if (this.state === 'removed') {
+            return;
+        }
+        const nextFeatures = LineFeatureFactory.normalizeLineFeatures(data, this.options);
+        this.normalizedFeatures = nextFeatures;
+        this.updateSources(nextFeatures);
+        this.animationLayer.changed();
+        if (this.state === 'running') {
+            this.startRafLoop();
+        }
+    }
+    remove() {
+        if (this.state === 'removed') {
+            return;
+        }
+        this.stopRafLoop();
+        this.unbindPostrender();
+        this.normalizedFeatures = [];
+        this.baseSource.clear();
+        this.animationSource.clear();
+        this.styleFactory.clearCaches();
+        this.onRemove?.(this.options.layerName);
+        this.map.removeLayer(this.baseLayer);
+        this.map.removeLayer(this.animationLayer);
+        this.state = 'removed';
+    }
+    createBaseLayer() {
+        return new VectorLayer({
+            properties: {
+                name: this.options.layerName,
+                layerName: this.options.layerName
+            },
+            source: this.baseSource,
+            style: feature => this.styleFactory.getFlowBaseLineStyle(feature, this.options),
+            zIndex: this.options.zIndex
+        });
+    }
+    createAnimationLayer() {
+        return new VectorLayer({
+            properties: {
+                name: `${this.options.layerName}__flow-animation`,
+                layerName: `${this.options.layerName}__flow-animation`
+            },
+            source: this.animationSource,
+            style: () => this.styleFactory.getAnimationLayerStyle(this.options, this.dashStyle),
+            zIndex: this.options.zIndex + 1
+        });
+    }
+    normalizeOptions(options) {
+        const mergedOptions = {
+            ...ConfigManager.DEFAULT_FLOW_LINE_OPTIONS,
+            ...options
+        };
+        const flowSymbolOptions = {
+            ...ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.flowSymbol,
+            ...options.flowSymbol
+        };
+        return {
+            ...mergedOptions,
+            layerName: options.layerName || ConfigManager.DEFAULT_LINE_OPTIONS.layerName,
+            duration: mergedOptions.duration > 0 ? mergedOptions.duration : ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.duration,
+            loop: mergedOptions.loop ?? ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.loop,
+            autoStart: mergedOptions.autoStart ?? ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.autoStart,
+            showBaseLine: mergedOptions.showBaseLine ?? ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.showBaseLine,
+            animationMode: mergedOptions.animationMode ?? ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.animationMode,
+            trailEnabled: mergedOptions.trailEnabled ?? ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.trailEnabled,
+            trailLength: mergedOptions.trailLength ?? ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.trailLength,
+            speed: mergedOptions.speed && mergedOptions.speed > 0 ? mergedOptions.speed : 1,
+            zIndex: mergedOptions.zIndex ?? ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.zIndex,
+            flowSymbol: {
+                src: flowSymbolOptions.src,
+                scale: flowSymbolOptions.scale,
+                color: flowSymbolOptions.color,
+                rotateWithView: flowSymbolOptions.rotateWithView,
+                count: Math.min(this.maxSymbolCount, Math.max(1, Math.round(flowSymbolOptions.count))),
+                spacing: Math.max(0.01, Math.min(0.5, flowSymbolOptions.spacing))
+            }
+        };
+    }
+    updateSources(features) {
+        this.baseSource.clear();
+        this.animationSource.clear();
+        this.baseSource.addFeatures(LineFeatureFactory.cloneLineFeatures(features));
+        this.animationSource.addFeatures(LineFeatureFactory.cloneLineFeatures(features));
+    }
+    bindPostrender() {
+        if (this.postrenderKey || (this.options.animationMode !== 'icon' && this.options.animationMode !== 'icon+dash')) {
+            return;
+        }
+        this.postrenderKey = this.animationLayer.on('postrender', event => {
+            if (this.state === 'removed' || !this.animationLayer.getVisible()) {
+                return;
+            }
+            const vectorContext = getVectorContext(event);
+            const baseProgress = this.getCurrentProgress();
+            this.normalizedFeatures.forEach(feature => {
+                const geometry = feature.getGeometry();
+                if (!(geometry instanceof LineString)) {
+                    return;
+                }
+                for (let symbolIndex = 0; symbolIndex < this.options.flowSymbol.count; symbolIndex += 1) {
+                    const offsetProgress = baseProgress - (symbolIndex * this.options.flowSymbol.spacing);
+                    const normalizedProgress = this.options.loop
+                        ? ((offsetProgress % 1) + 1) % 1
+                        : Math.max(0, Math.min(offsetProgress, 1));
+                    if (!this.options.loop && (normalizedProgress <= 0 || normalizedProgress >= 1) && symbolIndex > 0) {
+                        continue;
+                    }
+                    const { coordinate, rotation } = this.getCoordinateAndRotation(geometry, normalizedProgress);
+                    this.animationPointGeometry.setCoordinates(coordinate);
+                    const style = this.styleFactory.getMovingSymbolStyle(rotation, this.options);
+                    vectorContext.setStyle(style);
+                    vectorContext.drawFeature(this.animationPointFeature, style);
+                }
+            });
+        });
+    }
+    unbindPostrender() {
+        if (!this.postrenderKey) {
+            return;
+        }
+        unByKey(this.postrenderKey);
+        this.postrenderKey = null;
+    }
+    startRafLoop() {
+        if (this.rafId !== null) {
+            return;
+        }
+        const dashFallback = this.styleFactory.getDashFallback();
+        const renderFrame = () => {
+            if (this.state !== 'running') {
+                this.rafId = null;
+                return;
+            }
+            if (this.options.animationMode === 'dash' || this.options.animationMode === 'icon+dash') {
+                const dashOffset = -this.getCurrentProgress() * (this.options.lineDash?.reduce((sum, item) => sum + item, 0) ??
+                    dashFallback.reduce((sum, item) => sum + item, 0));
+                this.dashStyle.getStroke()?.setLineDashOffset(dashOffset);
+                this.animationLayer.changed();
+            }
+            this.map.render();
+            this.rafId = requestAnimationFrame(renderFrame);
+        };
+        this.rafId = requestAnimationFrame(renderFrame);
+    }
+    stopRafLoop() {
+        if (this.rafId === null) {
+            return;
+        }
+        cancelAnimationFrame(this.rafId);
+        this.rafId = null;
+    }
+    getCurrentProgress() {
+        if (this.state === 'paused') {
+            return this.frozenProgress;
+        }
+        if (this.state === 'stopped' || this.startTime === 0) {
+            return 0;
+        }
+        return this.getProgressByTime(this.getNow() - this.pausedDuration, this.startTime, this.options.duration, this.options.speed, this.options.loop);
+    }
+    getNow() {
+        return typeof performance !== 'undefined' ? performance.now() : Date.now();
+    }
+}

package/core/line/LineStyleFactory.d.ts

@@ -0,0 +1,43 @@
+import Feature from 'ol/Feature';
+import { LineString } from 'ol/geom';
+import { Style } from 'ol/style';
+import type { FeatureLike } from 'ol/Feature';
+import type { FlowLineOptions, LineOptions } from '../../types';
+/**
+ * 线样式工厂
+ * 负责静态线样式、流光虚线样式和 moving symbol 样式缓存。
+ */
+export default class LineStyleFactory {
+    private readonly movingSymbolStyleCache;
+    private readonly baseLineStyle;
+    private readonly emptyStyle;
+    private readonly dashFallback;
+    /**
+     * 创建静态线样式解析函数。
+     */
+    createBaseLineStyleResolver(options: LineOptions): (feature: FeatureLike) => Style | Style[];
+    /**
+     * 创建流动线基础线样式。
+     */
+    getFlowBaseLineStyle(feature: Feature<LineString>, options: FlowLineOptions): Style | Style[] | void;
+    /**
+     * 创建流光虚线样式。
+     */
+    createDashStyle(options: FlowLineOptions): Style;
+    /**
+     * 创建动画图层样式。
+     */
+    getAnimationLayerStyle(options: FlowLineOptions, dashStyle: Style): Style;
+    /**
+     * 获取 moving symbol 样式，按旋转与配置做缓存。
+     */
+    getMovingSymbolStyle(rotation: number, options: FlowLineOptions): Style;
+    /**
+     * 清理样式缓存。
+     */
+    clearCaches(): void;
+    /**
+     * 获取 dash 默认总长度。
+     */
+    getDashFallback(): number[];
+}

package/core/line/LineStyleFactory.js

@@ -0,0 +1,135 @@
+import Feature from 'ol/Feature';
+import { Fill, Icon, RegularShape, Stroke, Style } from 'ol/style';
+import { ConfigManager } from '../map';
+/**
+ * 线样式工厂
+ * 负责静态线样式、流光虚线样式和 moving symbol 样式缓存。
+ */
+export default class LineStyleFactory {
+    constructor() {
+        this.movingSymbolStyleCache = new globalThis.Map();
+        this.baseLineStyle = new Style();
+        this.emptyStyle = new Style();
+        this.dashFallback = [12, 12];
+    }
+    /**
+     * 创建静态线样式解析函数。
+     */
+    createBaseLineStyleResolver(options) {
+        return (feature) => {
+            if (feature instanceof Feature) {
+                feature.set('type', options.type);
+                feature.set('layerName', options.layerName);
+            }
+            if (options.style) {
+                if (typeof options.style === 'function') {
+                    return options.style(feature);
+                }
+                return options.style;
+            }
+            this.baseLineStyle.setStroke(new Stroke({
+                color: options.strokeColor ?? ConfigManager.DEFAULT_LINE_OPTIONS.strokeColor,
+                width: options.strokeWidth ?? ConfigManager.DEFAULT_LINE_OPTIONS.strokeWidth,
+                lineDash: options.lineDash,
+                lineDashOffset: options.lineDashOffset
+            }));
+            return this.baseLineStyle;
+        };
+    }
+    /**
+     * 创建流动线基础线样式。
+     */
+    getFlowBaseLineStyle(feature, options) {
+        if (!options.showBaseLine) {
+            this.baseLineStyle.setStroke(new Stroke({ color: 'rgba(0,0,0,0)', width: 0 }));
+            return this.baseLineStyle;
+        }
+        if (options.style) {
+            if (typeof options.style === 'function') {
+                return options.style(feature);
+            }
+            return options.style;
+        }
+        this.baseLineStyle.setStroke(new Stroke({
+            color: options.strokeColor ?? ConfigManager.DEFAULT_LINE_OPTIONS.strokeColor,
+            width: options.strokeWidth ?? ConfigManager.DEFAULT_LINE_OPTIONS.strokeWidth,
+            lineDash: options.lineDash,
+            lineDashOffset: options.lineDashOffset
+        }));
+        return this.baseLineStyle;
+    }
+    /**
+     * 创建流光虚线样式。
+     */
+    createDashStyle(options) {
+        const lineDash = options.lineDash && options.lineDash.length > 0 ? options.lineDash : this.dashFallback;
+        return new Style({
+            stroke: new Stroke({
+                color: options.strokeColor ?? ConfigManager.DEFAULT_LINE_OPTIONS.strokeColor,
+                width: options.strokeWidth ?? ConfigManager.DEFAULT_LINE_OPTIONS.strokeWidth,
+                lineDash,
+                lineDashOffset: options.lineDashOffset ?? 0
+            })
+        });
+    }
+    /**
+     * 创建动画图层样式。
+     */
+    getAnimationLayerStyle(options, dashStyle) {
+        if (options.animationMode === 'icon') {
+            return this.emptyStyle;
+        }
+        return dashStyle;
+    }
+    /**
+     * 获取 moving symbol 样式，按旋转与配置做缓存。
+     */
+    getMovingSymbolStyle(rotation, options) {
+        const flowSymbol = options.flowSymbol ?? {};
+        const cacheKey = [
+            rotation.toFixed(2),
+            flowSymbol.src ?? 'builtin',
+            flowSymbol.scale ?? ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.flowSymbol.scale,
+            flowSymbol.color ?? options.strokeColor ?? ConfigManager.DEFAULT_LINE_OPTIONS.strokeColor,
+            String(flowSymbol.rotateWithView ?? ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.flowSymbol.rotateWithView)
+        ].join('|');
+        const cachedStyle = this.movingSymbolStyleCache.get(cacheKey);
+        if (cachedStyle) {
+            return cachedStyle;
+        }
+        const color = flowSymbol.color ?? options.strokeColor ?? ConfigManager.DEFAULT_LINE_OPTIONS.strokeColor;
+        const scale = flowSymbol.scale ?? ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.flowSymbol.scale;
+        const rotateWithView = flowSymbol.rotateWithView ?? ConfigManager.DEFAULT_FLOW_LINE_OPTIONS.flowSymbol.rotateWithView;
+        const image = flowSymbol.src
+            ? new Icon({
+                src: flowSymbol.src,
+                scale,
+                color: flowSymbol.color,
+                rotation,
+                rotateWithView
+            })
+            : new RegularShape({
+                points: 3,
+                radius: 10 * scale,
+                rotation: rotation - Math.PI / 2,
+                rotateWithView,
+                fill: new Fill({ color }),
+                stroke: new Stroke({ color, width: 1 })
+            });
+        const style = new Style({ image });
+        this.movingSymbolStyleCache.set(cacheKey, style);
+        return style;
+    }
+    /**
+     * 清理样式缓存。
+     */
+    clearCaches() {
+        this.movingSymbolStyleCache.clear();
+    }
+    /**
+     * 获取 dash 默认总长度。
+     */
+    getDashFallback() {
+        return this.dashFallback;
+    }
+}

package/core/{RiverLayerManager.d.ts → line/RiverLayerManager.d.ts}

@@ -1,8 +1,8 @@
 import Map from "ol/Map";
 import VectorSource from "ol/source/Vector";
 import VectorLayer from "ol/layer/Vector";
-import { LineOptions, MapJSONData } from "../types";
-import { EventManager } from "./EventManager";
+import { LineOptions, MapJSONData } from "../../types";
+import { EventManager } from "../map";
 /**
  * 河流图层管理类
  * 用于创建与管理河流相关矢量图层（分级显示、按级别线宽、显示控制与清理）

package/core/{RiverLayerManager.js → line/RiverLayerManager.js}

@@ -3,11 +3,9 @@ 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 { EventManager } from "./EventManager";
-import { ErrorHandler } from "../utils/ErrorHandler";
-import { ConfigManager } from "./ConfigManager";
+import ValidationUtils from "../../utils/ValidationUtils";
+import { ErrorHandler } from "../../utils/ErrorHandler";
+import { ConfigManager, EventManager, MapTools } from "../map";
 export default class RiverLayerManager {
     /**
      * 构造函数

package/core/line/index.d.ts

@@ -0,0 +1,6 @@
+export { default as Line } from './Line';
+export { default as LineFlowAnimator } from './LineFlowAnimator';
+export { default as LineFeatureFactory } from './LineFeatureFactory';
+export { default as LineStyleFactory } from './LineStyleFactory';
+export { default as RiverLayerManager } from './RiverLayerManager';
+export type { RiverLayerOptions, RiverLevelWidthMap } from './RiverLayerManager';

package/core/line/index.js

@@ -0,0 +1,5 @@
+export { default as Line } from './Line';
+export { default as LineFlowAnimator } from './LineFlowAnimator';
+export { default as LineFeatureFactory } from './LineFeatureFactory';
+export { default as LineStyleFactory } from './LineStyleFactory';
+export { default as RiverLayerManager } from './RiverLayerManager';

package/core/{ConfigManager.d.ts → map/ConfigManager.d.ts}

@@ -2,7 +2,7 @@
  * 配置管理类
  * 用于统一管理默认配置和验证
  */
-export declare class ConfigManager {
+export default class ConfigManager {
     /**
      * 默认点位配置
      */
@@ -38,6 +38,30 @@ export declare class ConfigManager {
         layerName: string;
         zIndex: number;
     };
+    /**
+     * 默认流动线动画配置
+     */
+    static readonly DEFAULT_FLOW_LINE_OPTIONS: {
+        readonly duration: 4000;
+        readonly loop: true;
+        readonly autoStart: true;
+        readonly showBaseLine: true;
+        readonly animationMode: "icon";
+        readonly flowSymbol: {
+            readonly scale: 0.8;
+            readonly rotateWithView: true;
+            readonly count: 1;
+            readonly spacing: 0.15;
+        };
+        readonly trailEnabled: false;
+        readonly trailLength: 0;
+        readonly zIndex: 16;
+        readonly type: string;
+        readonly strokeColor: string;
+        readonly strokeWidth: number;
+        readonly visible: boolean;
+        readonly layerName: string;
+    };
     /**
      * 默认面配置
      */

package/core/{ConfigManager.js → map/ConfigManager.js}

@@ -2,7 +2,7 @@
  * 配置管理类
  * 用于统一管理默认配置和验证
  */
-export class ConfigManager {
+class ConfigManager {
     /**
      * 合并配置选项
      * @param defaultOptions 默认配置
@@ -82,6 +82,26 @@ ConfigManager.DEFAULT_LINE_OPTIONS = {
     layerName: 'lineLayer',
     zIndex: 15
 };
+/**
+ * 默认流动线动画配置
+ */
+ConfigManager.DEFAULT_FLOW_LINE_OPTIONS = {
+    ...ConfigManager.DEFAULT_LINE_OPTIONS,
+    duration: 4000,
+    loop: true,
+    autoStart: true,
+    showBaseLine: true,
+    animationMode: 'icon',
+    flowSymbol: {
+        scale: 0.8,
+        rotateWithView: true,
+        count: 1,
+        spacing: 0.15
+    },
+    trailEnabled: false,
+    trailLength: 0,
+    zIndex: 16
+};
 /**
  * 默认面配置
  */
@@ -184,3 +204,4 @@ ConfigManager.DEFAULT_RIVER_WIDTH_BY_LEVEL_OPTIONS = {
     zIndex: 15,
     removeExisting: false
 };
+export default ConfigManager;

package/core/{EventManager.d.ts → map/EventManager.d.ts}

@@ -26,7 +26,7 @@ export interface MapEventData {
  * 事件管理器类
  * 用于统一管理地图事件的注册、触发和移除
  */
-export declare class EventManager {
+export default class EventManager {
     private readonly map;
     private listeners;
     private eventCounters;

package/core/{EventManager.js → map/EventManager.js}

@@ -1,9 +1,9 @@
-import { ErrorHandler, ErrorType } from '../utils/ErrorHandler';
+import { ErrorHandler, ErrorType } from '../../utils/ErrorHandler';
 /**
  * 事件管理器类
  * 用于统一管理地图事件的注册、触发和移除
  */
-export class EventManager {
+export default class EventManager {
     /**
      * 构造函数
      * @param map OpenLayers地图实例

package/core/{MapBaseLayers.d.ts → map/MapBaseLayers.d.ts}

@@ -8,7 +8,7 @@ import { Tile as TileLayer } from "ol/layer";
 import { TileWMS } from "ol/source";
 import WMTSTileGrid from "ol/tilegrid/WMTS";
 import XYZ from "ol/source/XYZ";
-import { MapLayersOptions, TiandituType, AnnotationLayerOptions, AnnotationType } from "../types";
+import { MapLayersOptions, TiandituType, AnnotationLayerOptions, AnnotationType } from "../../types";
 /**
  * GeoServer图层选项接口
  */