my-openlayer 3.0.1 → 3.1.0

package/utils/GeoJSONProcessor.js

@@ -0,0 +1,299 @@
+/**
+ * GeoJSON 数据标准化工具。
+ *
+ * 本模块借鉴 mapshaper 对地理数据输入的统一处理思路，
+ * 但仅提供轻量的点数据标准化能力，不包含拓扑简化、dissolve、clip/erase 等 GIS 编辑功能。
+ * 参见 https://github.com/mbloch/mapshaper (MPL-2.0, Node >=20.11)。
+ */
+/** *********************内部工具函数*********************/
+/**
+ * 判断输入是否为合法的 GeoJSON Feature（type 为 'Feature' 且包含 geometry）。
+ */
+function isFeature(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        obj.type === 'Feature' &&
+        typeof obj.geometry === 'object');
+}
+/**
+ * 判断输入是否为 GeoJSON FeatureCollection。
+ */
+function isFeatureCollection(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        obj.type === 'FeatureCollection' &&
+        Array.isArray(obj.features));
+}
+/**
+ * 判断输入是否为裸 GeoJSON Point geometry。
+ */
+function isPointGeometry(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        obj.type === 'Point' &&
+        Array.isArray(obj.coordinates));
+}
+/**
+ * 判断输入是否为裸 GeoJSON MultiPoint geometry。
+ */
+function isMultiPointGeometry(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        obj.type === 'MultiPoint' &&
+        Array.isArray(obj.coordinates));
+}
+/**
+ * 验证单个坐标对 [lng, lat] 是否合法。
+ * 要求两个分量均为有限数。
+ */
+function isValidCoordinate(coord) {
+    return (Array.isArray(coord) &&
+        coord.length >= 2 &&
+        Number.isFinite(coord[0]) &&
+        Number.isFinite(coord[1]));
+}
+/**
+ * 从 GeoJSON Feature 提取单个点。
+ * 仅处理 geometry.type === 'Point' 的 Feature，其他类型返回 undefined。
+ */
+function extractPointFromFeature(feature) {
+    if (feature.geometry?.type !== 'Point')
+        return undefined;
+    const coords = feature.geometry.coordinates;
+    if (!isValidCoordinate(coords))
+        return undefined;
+    return {
+        ...feature.properties,
+        lgtd: coords[0],
+        lttd: coords[1],
+    };
+}
+/**
+ * 从 GeoJSON MultiPoint Feature 提取多个点。
+ */
+function extractPointsFromMultiPointFeature(feature) {
+    if (feature.geometry?.type !== 'MultiPoint')
+        return [];
+    const coords = feature.geometry.coordinates;
+    const results = [];
+    for (const pair of coords) {
+        if (!isValidCoordinate(pair))
+            continue;
+        results.push({
+            ...feature.properties,
+            lgtd: pair[0],
+            lttd: pair[1],
+        });
+    }
+    return results;
+}
+/** *********************公开 API*********************/
+/**
+ * 将多种形态的点数据输入统一标准化为 `PointData[]`。
+ *
+ * 支持的输入形态：
+ * - `PointData[]`：原样返回（深拷贝后过滤非法坐标）
+ * - GeoJSON `FeatureCollection`：遍历 features，提取 Point / MultiPoint geometry
+ * - 单个 GeoJSON `Feature`：提取其 Point 或 MultiPoint geometry
+ * - 裸 `Point` geometry：转为单元素 PointData 数组
+ * - 裸 `MultiPoint` geometry：拆成多个 PointData
+ *
+ * 过滤规则：
+ * - 非 Point / MultiPoint geometry 的 Feature 会被跳过
+ * - 坐标含 NaN / Infinity / 缺失的点会被跳过
+ * - null / undefined 输入返回空数组
+ *
+ * @param input 任意兼容的点数据输入
+ * @returns 标准化后的 PointData 数组
+ */
+export function normalizePointData(input) {
+    if (input == null)
+        return [];
+    // 数组 — 逐项处理，兼容 PointData[] 和 FeatureData[] 混合
+    if (Array.isArray(input)) {
+        const results = [];
+        for (const item of input) {
+            if (typeof item !== 'object' || item === null)
+                continue;
+            // PointData 形状（有 lgtd/lttd）
+            if (Number.isFinite(item.lgtd) && Number.isFinite(item.lttd)) {
+                results.push({ ...item });
+                continue;
+            }
+            // Feature 形状
+            if (isFeature(item)) {
+                const pt = extractPointFromFeature(item);
+                if (pt)
+                    results.push(pt);
+                continue;
+            }
+            // 裸 Point geometry
+            if (isPointGeometry(item) && isValidCoordinate(item.coordinates)) {
+                results.push({ lgtd: item.coordinates[0], lttd: item.coordinates[1] });
+            }
+        }
+        return results;
+    }
+    // 非对象直接返回空
+    if (typeof input !== 'object')
+        return [];
+    // GeoJSON FeatureCollection
+    if (isFeatureCollection(input)) {
+        const results = [];
+        for (const feature of input.features) {
+            if (feature.geometry?.type === 'Point') {
+                const pt = extractPointFromFeature(feature);
+                if (pt)
+                    results.push(pt);
+            }
+            else if (feature.geometry?.type === 'MultiPoint') {
+                results.push(...extractPointsFromMultiPointFeature(feature));
+            }
+            // 其他 geometry 类型跳过
+        }
+        return results;
+    }
+    // 单个 GeoJSON Feature
+    if (isFeature(input)) {
+        if (input.geometry?.type === 'Point') {
+            const pt = extractPointFromFeature(input);
+            return pt ? [pt] : [];
+        }
+        if (input.geometry?.type === 'MultiPoint') {
+            return extractPointsFromMultiPointFeature(input);
+        }
+        return [];
+    }
+    // 裸 Point geometry
+    if (isPointGeometry(input)) {
+        if (!isValidCoordinate(input.coordinates))
+            return [];
+        return [{ lgtd: input.coordinates[0], lttd: input.coordinates[1] }];
+    }
+    // 裸 MultiPoint geometry
+    if (isMultiPointGeometry(input)) {
+        const results = [];
+        for (const pair of input.coordinates) {
+            if (!isValidCoordinate(pair))
+                continue;
+            results.push({ lgtd: pair[0], lttd: pair[1] });
+        }
+        return results;
+    }
+    return [];
+}
+/** *********************GeoJSON 分组处理*********************/
+/**
+ * 将 GeoJSON geometry 类型归类为简化的三大类。
+ * 无法识别的类型返回 null。
+ */
+export function classifyGeometryType(geometryType) {
+    switch (geometryType) {
+        case 'Point':
+        case 'MultiPoint':
+            return 'point';
+        case 'LineString':
+        case 'MultiLineString':
+            return 'line';
+        case 'Polygon':
+        case 'MultiPolygon':
+            return 'polygon';
+        default:
+            return null;
+    }
+}
+/**
+ * 将单个 GeoJSON 输入项标准化为 FeatureData 数组。
+ * @internal
+ */
+function normalizeOneGeoJSON(input) {
+    // FeatureCollection
+    if (isFeatureCollection(input)) {
+        return input.features;
+    }
+    // Feature
+    if (isFeature(input)) {
+        return [input];
+    }
+    // 裸 geometry → 包装为 Feature
+    if (typeof input === 'object' && input !== null && 'type' in input && 'coordinates' in input) {
+        const geom = input;
+        return [{
+                type: 'Feature',
+                properties: {},
+                geometry: {
+                    type: geom.type,
+                    coordinates: geom.coordinates,
+                },
+            }];
+    }
+    return [];
+}
+/**
+ * 将 addGeoJSON 的多种输入形态统一标准化为带 datasetKey 的 FeatureData 数组。
+ *
+ * - 单个 JSON → datasetKey 为 `'default'`
+ * - 数组 → datasetKey 为字符串索引 `'0'`, `'1'`, ...
+ * - `Record<string, json>` → datasetKey 为 key
+ */
+export function normalizeGeoJSONInputs(data) {
+    if (data == null)
+        return [];
+    // 数组
+    if (Array.isArray(data)) {
+        return data.map((item, index) => ({
+            datasetKey: String(index),
+            features: normalizeOneGeoJSON(item),
+        }));
+    }
+    // 非对象
+    if (typeof data !== 'object')
+        return [];
+    // Record<string, json> — 有 type 字段的当作单个 GeoJSON，不是 Record
+    const obj = data;
+    if ('type' in obj && typeof obj.type === 'string') {
+        // 单个 GeoJSON（FeatureCollection / Feature / Geometry）
+        return [{ datasetKey: 'default', features: normalizeOneGeoJSON(data) }];
+    }
+    // Record<string, json>
+    const results = [];
+    for (const key of Object.keys(obj)) {
+        const item = obj[key];
+        results.push({ datasetKey: key, features: normalizeOneGeoJSON(item) });
+    }
+    return results;
+}
+export function splitByGroupAndGeometry(normalized, groupBy) {
+    const result = {};
+    for (const { datasetKey, features } of normalized) {
+        for (let index = 0; index < features.length; index++) {
+            const feature = features[index];
+            const geomType = feature.geometry?.type;
+            if (!geomType)
+                continue;
+            const category = classifyGeometryType(geomType);
+            if (!category)
+                continue;
+            // 确定 groupKey
+            let groupKey;
+            if (groupBy === undefined) {
+                groupKey = datasetKey;
+            }
+            else if (typeof groupBy === 'string') {
+                const val = feature.properties?.[groupBy];
+                groupKey = val != null ? String(val) : datasetKey;
+            }
+            else {
+                const val = groupBy(feature.properties ?? {}, { datasetKey, geometryType: category, feature, index });
+                groupKey = val != null ? String(val) : datasetKey;
+            }
+            // 初始化分组
+            if (!result[groupKey]) {
+                result[groupKey] = { point: [], line: [], polygon: [] };
+            }
+            // 附加 datasetKey 元数据
+            result[groupKey][category].push({ ...feature, _datasetKey: datasetKey });
+        }
+    }
+    return result;
+}

package/utils/ValidationUtils.d.ts

@@ -1,7 +1,3 @@
-/**
- * 验证工具类
- * 统一管理参数校验逻辑，错误记录由调用方或 ErrorHandler 负责。
- */
 export default class ValidationUtils {
     /**
      * 判断值是否为有效数字。

package/utils/ValidationUtils.js

@@ -2,6 +2,7 @@
  * 验证工具类
  * 统一管理参数校验逻辑，错误记录由调用方或 ErrorHandler 负责。
  */
+import { ErrorHandler, ErrorType } from './ErrorHandler';
 export default class ValidationUtils {
     /**
      * 判断值是否为有效数字。
@@ -102,7 +103,7 @@ export default class ValidationUtils {
      */
     static validateLayerName(layerName) {
         if (!ValidationUtils.isValidLayerName(layerName)) {
-            throw new Error('Layer name is required');
+            throw ErrorHandler.getInstance().createAndHandleError('Layer name is required', ErrorType.VALIDATION_ERROR);
         }
     }
     /**
@@ -110,13 +111,13 @@ export default class ValidationUtils {
      */
     static validateImageData(imageData, allowEmptyImg = false) {
         if (!imageData) {
-            throw new Error('Invalid image data: imageData is required');
+            throw ErrorHandler.getInstance().createAndHandleError('Invalid image data: imageData is required', ErrorType.VALIDATION_ERROR);
         }
         if (!allowEmptyImg && !imageData.img) {
-            throw new Error('Invalid image data: img is required');
+            throw ErrorHandler.getInstance().createAndHandleError('Invalid image data: img is required', ErrorType.VALIDATION_ERROR);
         }
         if (imageData.extent && !ValidationUtils.isValidExtent(imageData.extent)) {
-            throw new Error('Invalid extent: must be an array of 4 numbers [minX, minY, maxX, maxY]');
+            throw ErrorHandler.getInstance().createAndHandleError('Invalid extent: must be an array of 4 numbers [minX, minY, maxX, maxY]', ErrorType.VALIDATION_ERROR);
         }
     }
     /**
@@ -124,7 +125,7 @@ export default class ValidationUtils {
      */
     static validateMaskData(data) {
         if (data === undefined || data === null) {
-            throw new Error('Mask data is required');
+            throw ErrorHandler.getInstance().createAndHandleError('Mask data is required', ErrorType.VALIDATION_ERROR);
         }
     }
     /**
@@ -138,7 +139,7 @@ export default class ValidationUtils {
      */
     static validateRequired(value, message) {
         if (value === undefined || value === null || value === '') {
-            throw new Error(message);
+            throw ErrorHandler.getInstance().createAndHandleError(message, ErrorType.VALIDATION_ERROR);
         }
     }
     /**
@@ -146,13 +147,13 @@ export default class ValidationUtils {
      */
     static validateCoordinate(longitude, latitude) {
         if (!ValidationUtils.isFiniteNumber(longitude) || !ValidationUtils.isFiniteNumber(latitude)) {
-            throw new Error('Longitude and latitude must be valid numbers');
+            throw ErrorHandler.getInstance().createAndHandleError('Longitude and latitude must be valid numbers', ErrorType.VALIDATION_ERROR);
         }
         if (longitude < -180 || longitude > 180) {
-            throw new Error('Longitude must be between -180 and 180');
+            throw ErrorHandler.getInstance().createAndHandleError('Longitude must be between -180 and 180', ErrorType.VALIDATION_ERROR);
         }
         if (latitude < -90 || latitude > 90) {
-            throw new Error('Latitude must be between -90 and 90');
+            throw ErrorHandler.getInstance().createAndHandleError('Latitude must be between -90 and 90', ErrorType.VALIDATION_ERROR);
         }
     }
     /**
@@ -160,7 +161,7 @@ export default class ValidationUtils {
      */
     static validateType(value, expectedType, message) {
         if (typeof value !== expectedType) {
-            throw new Error(message);
+            throw ErrorHandler.getInstance().createAndHandleError(message, ErrorType.VALIDATION_ERROR);
         }
     }
     /**
@@ -168,7 +169,7 @@ export default class ValidationUtils {
      */
     static validateNonEmptyString(str, message) {
         if (!ValidationUtils.isValidLayerName(str)) {
-            throw new Error(message);
+            throw ErrorHandler.getInstance().createAndHandleError(message, ErrorType.VALIDATION_ERROR);
         }
     }
     /**
@@ -176,7 +177,7 @@ export default class ValidationUtils {
      */
     static validateMap(map) {
         if (!map) {
-            throw new Error('Map instance is required');
+            throw ErrorHandler.getInstance().createAndHandleError('Map instance is required', ErrorType.VALIDATION_ERROR);
         }
     }
     /**
@@ -184,7 +185,7 @@ export default class ValidationUtils {
      */
     static validateMeasureType(type) {
         if (type !== 'LineString' && type !== 'Polygon') {
-            throw new Error('Invalid measure type. Must be "LineString" or "Polygon"');
+            throw ErrorHandler.getInstance().createAndHandleError('Invalid measure type. Must be "LineString" or "Polygon"', ErrorType.VALIDATION_ERROR);
         }
     }
     /**
@@ -192,7 +193,7 @@ export default class ValidationUtils {
      */
     static validatePositiveNumber(value, message) {
         if (!ValidationUtils.isFiniteNumber(value) || value <= 0) {
-            throw new Error(message);
+            throw ErrorHandler.getInstance().createAndHandleError(message, ErrorType.VALIDATION_ERROR);
         }
     }
     /**
@@ -202,7 +203,7 @@ export default class ValidationUtils {
         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');
+            throw ErrorHandler.getInstance().createAndHandleError('Valid layer name is required', ErrorType.VALIDATION_ERROR);
         }
     }
 }

package/core/line/RiverLayerManager.d.ts

@@ -1,93 +0,0 @@
-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 "../map";
-/**
- * 河流图层管理类
- * 用于创建与管理河流相关矢量图层（分级显示、按级别线宽、显示控制与清理）
- *
- * 注意：
- * - 分级显示依赖地图缩放级别（zoom），通过 zoomOffset 控制显示阈值偏移
- * - removeExisting 为 true 时，会清理本管理器创建的分级河流图层
- */
-export interface RiverLevelWidthMap {
-    [level: number]: number;
-}
-/**
- * 河流图层配置选项
- */
-export interface RiverLayerOptions extends LineOptions {
-    /** 河流级别数量，默认为 5 */
-    levelCount?: number;
-    /** 缩放级别偏移量，默认为 8 */
-    zoomOffset?: number;
-    /** 河流级别线宽映射，key 为 level，value 为线宽 */
-    levelWidthMap?: RiverLevelWidthMap;
-    /** 是否删除已有分级河流图层（本管理器创建的） */
-    removeExisting?: boolean;
-}
-export default class RiverLayerManager {
-    private readonly map;
-    private readonly eventManager;
-    private riverLayerList;
-    private riverLayerShow;
-    private riverZoomOffset;
-    private readonly defaultLevelWidthMap;
-    /**
-     * 构造函数
-     * @param map OpenLayers 地图实例
-     * @param eventManager 可选事件管理器，未传入则内部创建
-     */
-    constructor(map: Map, eventManager?: EventManager);
-    /**
-     * 添加分级河流图层：根据缩放级别显示不同 level 的河流
-     * @param fyRiverJson 河流 GeoJSON 数据
-     * @param options 河流图层配置选项
-     */
-    addRiverLayersByZoom(fyRiverJson: MapJSONData, options?: RiverLayerOptions): void;
-    /**
-     * 从 URL 添加分级河流图层：根据缩放级别显示不同 level 的河流
-     * @param url 河流数据 URL（GeoJSON）
-     * @param options 河流图层配置选项
-     */
-    addRiverLayersByZoomByUrl(url: string, options?: RiverLayerOptions): void;
-    /**
-     * 设置分级河流图层是否显示
-     * @param show 是否显示
-     */
-    showRiverLayer(show: boolean): void;
-    /**
-     * 根据当前 zoom 显示对应分级河流图层
-     * 缩放越大，显示的 riverLevel 越多
-     */
-    showRiverLayerByZoom(): void;
-    /**
-     * 添加按级别显示不同宽度的河流图层
-     * @param data 河流 GeoJSON 数据
-     * @param options 河流图层配置选项
-     */
-    addRiverWidthByLevel(data: MapJSONData, options?: RiverLayerOptions): VectorLayer<VectorSource>;
-    /**
-     * 从 URL 添加按级别显示不同宽度的河流图层
-     * @param url 河流数据 URL（GeoJSON）
-     * @param options 河流图层配置选项
-     */
-    addRiverWidthByLevelByUrl(url: string, options?: RiverLayerOptions): VectorLayer<VectorSource>;
-    /**
-     * 清除本管理器创建的分级河流图层
-     */
-    clearRiverLayers(): void;
-    /**
-     * 获取分级河流图层显示状态
-     */
-    getRiverLayerVisibility(): boolean;
-    /**
-     * 获取分级河流图层列表副本
-     */
-    getRiverLayers(): VectorLayer<VectorSource>[];
-    /**
-     * 销毁管理器，释放资源
-     */
-    destroy(): void;
-}