wkt-parse-and-geojson 1.0.3 → 1.0.5

package/README.md

@@ -21,6 +21,7 @@
   - [featureToWkt(feature)](#7-featuretowktfeature)
   - [featureCollectionToWkt(fc)](#8-featurecollectiontowktfc)
   - [GeoJSON 工厂方法](#9-geojson-工厂方法)
+  - [校验工具](#10-校验工具)
 - [类型定义](#类型定义)
 - [注意事项与边界行为](#注意事项与边界行为)
 - [本地调试](#本地调试)
@@ -82,8 +83,12 @@ npm install wkt-parse-and-geojson
 // CommonJS
 const { parse, build, wktToFeature } = require('wkt-parse-and-geojson');
 
-// ES Module
+// ES Module - 按需导入
 import { parse, build, wktToFeature } from 'wkt-parse-and-geojson';
+
+// ES Module - 命名空间导入（避免命名冲突）
+import WKT from 'wkt-parse-and-geojson';
+const geom = WKT.parse('POINT (116.39 39.91)');
 ```
 
 ### 浏览器 (script 标签)
@@ -92,13 +97,13 @@ import { parse, build, wktToFeature } from 'wkt-parse-and-geojson';
 <!-- UMD 方式：通过 script 标签直接引入，全局变量 WKTGeoJSON -->
 <script src="https://unpkg.com/wkt-parse-and-geojson/dist/index.umd.js"></script>
 <script>
+  // 方式一：使用命名空间（推荐，避免命名冲突）
   const geom = WKTGeoJSON.parse('POINT (116.39 39.91)');
   console.log(geom);
-  // → { type: 'Point', coordinates: [116.39, 39.91] }
 
-  const wkt = WKTGeoJSON.build(geom);
-  console.log(wkt);
-  // → "POINT (116.39 39.91)"
+  // 方式二：解构赋值（需注意命名冲突）
+  const { parse, build } = WKTGeoJSON;
+  const wkt = build(geom);
 </script>
 ```
 
@@ -480,6 +485,84 @@ createGeometryCollection([
 
 ---
 
+## 10. 校验工具
+
+### `validateWKT(wkt)`
+
+校验 WKT 字符串格式是否合法。
+
+```javascript
+import { validateWKT } from 'wkt-parse-and-geojson';
+
+validateWKT('POINT (30.5 40.5)')
+// → { valid: true }
+
+validateWKT('POINT EMPTY')
+// → { valid: false, error: 'POINT EMPTY cannot be represented...' }
+
+validateWKT('INVALID WKT')
+// → { valid: false, error: 'Unknown geometry type: INVALID' }
+```
+
+### `validateGeoJSON(geojson)`
+
+校验 GeoJSON Geometry 对象是否合法。
+
+```javascript
+import { validateGeoJSON } from 'wkt-parse-and-geojson';
+
+validateGeoJSON({ type: 'Point', coordinates: [30.5, 40.5] })
+// → { valid: true }
+
+validateGeoJSON({ type: 'Point' })
+// → { valid: false, error: 'Point must have "coordinates"' }
+
+validateGeoJSON({ type: 'InvalidType', coordinates: [] })
+// → { valid: false, error: 'Invalid geometry type: InvalidType...' }
+```
+
+### `tryFixWKT(wkt)`
+
+尝试修复不规范的 WKT 字符串（处理尾部多余字符）。
+
+```javascript
+import { tryFixWKT } from 'wkt-parse-and-geojson';
+
+tryFixWKT('POINT (30.5 40.5) garbage')
+// → { fixed: 'POINT (30.5 40.5)', changed: true }
+```
+
+### `cloneGeometry(geometry)`
+
+深度克隆几何对象，避免意外修改原对象。
+
+```javascript
+import { cloneGeometry } from 'wkt-parse-and-geojson';
+
+const original = { type: 'Point', coordinates: [0, 0] };
+const cloned = cloneGeometry(original);
+cloned.coordinates[0] = 100;
+// original.coordinates[0] === 0 (未改变)
+```
+
+### `geometryEquals(a, b)`
+
+判断两个几何对象是否相等。
+
+```javascript
+import { geometryEquals } from 'wkt-parse-and-geojson';
+
+const a = { type: 'Point', coordinates: [30.5, 40.5] };
+const b = { type: 'Point', coordinates: [30.5, 40.5] };
+geometryEquals(a, b)
+// → true
+
+geometryEquals(a, { type: 'Point', coordinates: [0, 0] })
+// → false
+```
+
+---
+
 ## 类型定义
 
 ```typescript

package/dist/index.cjs.js

@@ -1,5 +1,9 @@
 'use strict';
 
+var types = /*#__PURE__*/Object.freeze({
+    __proto__: null
+});
+
 // Precompiled regex for better performance
 const RE_WHITESPACE = /\s/;
 const RE_NUMBER_START = /[0-9\-]/;
@@ -316,16 +320,21 @@ function parse(wkt) {
     return parser.parse(wkt);
 }
 
+var wktParser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    WKTParser: WKTParser,
+    parse: parse
+});
+
 /**
  * 将坐标数值格式化为字符串，避免科学计数法（WKT 不支持）。
  * 例：1e-7 → "0.0000001"，1.50000 → "1.5"，1.0 → "1"
  */
 function formatNumber(v) {
-    // 有小数则最多保留 15 位有效位，再去掉尾零
     if (v % 1 !== 0) {
-        return parseFloat(v.toFixed(15)).toString();
+        return Number(v.toFixed(15)).toString();
     }
-    return v.toFixed(0);
+    return String(v);
 }
 function positionToWkt(pos) {
     return pos.map(formatNumber).join(' ');
@@ -333,6 +342,28 @@ function positionToWkt(pos) {
 function coordsToWkt(coords) {
     return coords.map(positionToWkt).join(', ');
 }
+// 检查坐标是否包含 Z（3个分量）
+function hasZ(coordinates) {
+    if (!Array.isArray(coordinates))
+        return false;
+    if (coordinates.length === 0)
+        return false;
+    const first = coordinates[0];
+    if (Array.isArray(first)) {
+        if (typeof first[0] === 'number') {
+            return first.length === 3;
+        }
+        if (Array.isArray(first[0])) {
+            const firstRing = first;
+            return firstRing.length > 0 && firstRing[0].length === 3;
+        }
+    }
+    return false;
+}
+// 获取 Z 后缀字符串
+function zSuffix(coordinates) {
+    return hasZ(coordinates) ? ' Z' : '';
+}
 class WKTBuilder {
     build(geometry) {
         switch (geometry.type) {
@@ -355,21 +386,18 @@ class WKTBuilder {
         }
     }
     buildPoint(geom) {
-        const hasZ = geom.coordinates.length === 3;
-        return `POINT${hasZ ? ' Z' : ''} (${positionToWkt(geom.coordinates)})`;
+        return `POINT${zSuffix(geom.coordinates)} (${positionToWkt(geom.coordinates)})`;
     }
     buildLineString(geom) {
         if (geom.coordinates.length === 0)
             return 'LINESTRING EMPTY';
-        const hasZ = geom.coordinates[0].length === 3;
-        return `LINESTRING${hasZ ? ' Z' : ''} (${coordsToWkt(geom.coordinates)})`;
+        return `LINESTRING${zSuffix(geom.coordinates)} (${coordsToWkt(geom.coordinates)})`;
     }
     buildPolygon(geom) {
         if (geom.coordinates.length === 0)
             return 'POLYGON EMPTY';
-        const hasZ = geom.coordinates[0].length > 0 && geom.coordinates[0][0].length === 3;
         const ringStr = geom.coordinates.map(ring => `(${coordsToWkt(ring)})`).join(', ');
-        return `POLYGON${hasZ ? ' Z' : ''} (${ringStr})`;
+        return `POLYGON${zSuffix(geom.coordinates)} (${ringStr})`;
     }
     /**
      * 按 OGC/ISO WKT 标准，MULTIPOINT 每个点用括号包裹：
@@ -378,26 +406,23 @@ class WKTBuilder {
     buildMultiPoint(geom) {
         if (geom.coordinates.length === 0)
             return 'MULTIPOINT EMPTY';
-        const hasZ = geom.coordinates[0].length === 3;
         const pts = geom.coordinates.map(p => `(${positionToWkt(p)})`).join(', ');
-        return `MULTIPOINT${hasZ ? ' Z' : ''} (${pts})`;
+        return `MULTIPOINT${zSuffix(geom.coordinates)} (${pts})`;
     }
     buildMultiLineString(geom) {
         if (geom.coordinates.length === 0)
             return 'MULTILINESTRING EMPTY';
-        const hasZ = geom.coordinates[0].length > 0 && geom.coordinates[0][0].length === 3;
         const lines = geom.coordinates.map(line => `(${coordsToWkt(line)})`).join(', ');
-        return `MULTILINESTRING${hasZ ? ' Z' : ''} (${lines})`;
+        return `MULTILINESTRING${zSuffix(geom.coordinates)} (${lines})`;
     }
     buildMultiPolygon(geom) {
         if (geom.coordinates.length === 0)
             return 'MULTIPOLYGON EMPTY';
-        const hasZ = geom.coordinates[0].length > 0 && geom.coordinates[0][0].length > 0 && geom.coordinates[0][0][0].length === 3;
         const polys = geom.coordinates.map(poly => {
             const rings = poly.map(ring => `(${coordsToWkt(ring)})`).join(', ');
             return `(${rings})`;
         }).join(', ');
-        return `MULTIPOLYGON${hasZ ? ' Z' : ''} (${polys})`;
+        return `MULTIPOLYGON${zSuffix(geom.coordinates)} (${polys})`;
     }
     buildGeometryCollection(geom) {
         if (geom.geometries.length === 0)
@@ -411,6 +436,12 @@ function build(geometry) {
     return new WKTBuilder().build(geometry);
 }
 
+var wktBuilder = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    WKTBuilder: WKTBuilder,
+    build: build
+});
+
 // ─── 内部工具：判断是否为 Position（[number, number] 或 [number, number, number]）
 function isPosition(v) {
     return (Array.isArray(v) &&
@@ -557,6 +588,18 @@ function createGeometryCollection(geometries) {
     return _builder.createGeometryCollection(geometries);
 }
 
+var geojsonBuilder = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    GeoJSONBuilder: GeoJSONBuilder,
+    createGeometryCollection: createGeometryCollection,
+    createLineString: createLineString,
+    createMultiLineString: createMultiLineString,
+    createMultiPoint: createMultiPoint,
+    createMultiPolygon: createMultiPolygon,
+    createPoint: createPoint,
+    createPolygon: createPolygon
+});
+
 /**
  * 将 WKT 字符串转换为 GeoJSON Geometry 对象。
  *
@@ -608,6 +651,13 @@ function wktToFeatureCollection(wkts, properties) {
     return { type: 'FeatureCollection', features };
 }
 
+var wktToGeojson = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    wktToFeature: wktToFeature,
+    wktToFeatureCollection: wktToFeatureCollection,
+    wktToGeoJSON: wktToGeoJSON
+});
+
 /**
  * 将 GeoJSON Geometry 对象转换为 WKT 字符串。
  *
@@ -653,10 +703,272 @@ function featureCollectionToWkt(fc) {
     });
 }
 
+var geojsonToWkt$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    featureCollectionToWkt: featureCollectionToWkt,
+    featureToWkt: featureToWkt,
+    geojsonToWkt: geojsonToWkt
+});
+
+/**
+ * 校验 WKT 字符串格式是否合法
+ */
+function validateWKT(wkt) {
+    if (!wkt || typeof wkt !== 'string') {
+        return { valid: false, error: 'WKT must be a non-empty string' };
+    }
+    const trimmed = wkt.trim();
+    if (trimmed.length === 0) {
+        return { valid: false, error: 'WKT cannot be empty' };
+    }
+    try {
+        parse(wkt);
+        return { valid: true };
+    }
+    catch (e) {
+        return { valid: false, error: e.message };
+    }
+}
+/**
+ * 校验 GeoJSON Geometry 对象是否合法
+ */
+function validateGeoJSON(geojson) {
+    if (!geojson || typeof geojson !== 'object') {
+        return { valid: false, error: 'GeoJSON must be an object' };
+    }
+    const obj = geojson;
+    // 检查 type 字段
+    if (!obj.type || typeof obj.type !== 'string') {
+        return { valid: false, error: 'GeoJSON must have a "type" property' };
+    }
+    const type = obj.type;
+    const validTypes = [
+        'Point', 'LineString', 'Polygon',
+        'MultiPoint', 'MultiLineString', 'MultiPolygon',
+        'GeometryCollection'
+    ];
+    if (!validTypes.includes(type)) {
+        return { valid: false, error: `Invalid geometry type: "${type}". Must be one of: ${validTypes.join(', ')}` };
+    }
+    // GeometryCollection 特殊处理
+    if (type === 'GeometryCollection') {
+        if (!obj.geometries || !Array.isArray(obj.geometries)) {
+            return { valid: false, error: 'GeometryCollection must have a "geometries" array' };
+        }
+        for (let i = 0; i < obj.geometries.length; i++) {
+            const result = validateGeoJSON(obj.geometries[i]);
+            if (!result.valid) {
+                return { valid: false, error: `GeometryCollection[${i}]: ${result.error}` };
+            }
+        }
+        return { valid: true };
+    }
+    // 其他几何类型必须要有 coordinates
+    if (obj.coordinates === undefined) {
+        return { valid: false, error: `${type} must have "coordinates"` };
+    }
+    // 校验坐标格式
+    return validateCoordinates(type, obj.coordinates);
+}
+function validateCoordinates(type, coords) {
+    switch (type) {
+        case 'Point':
+            return validatePosition(coords);
+        case 'LineString':
+        case 'MultiPoint':
+            if (!Array.isArray(coords)) {
+                return { valid: false, error: `${type} coordinates must be an array` };
+            }
+            for (let i = 0; i < coords.length; i++) {
+                const result = validatePosition(coords[i]);
+                if (!result.valid) {
+                    return { valid: false, error: `${type}[${i}]: ${result.error}` };
+                }
+            }
+            return { valid: true };
+        case 'Polygon':
+        case 'MultiLineString':
+            if (!Array.isArray(coords)) {
+                return { valid: false, error: `${type} coordinates must be a nested array` };
+            }
+            for (let i = 0; i < coords.length; i++) {
+                if (!Array.isArray(coords[i])) {
+                    return { valid: false, error: `${type}[${i}] must be an array of positions` };
+                }
+                for (let j = 0; j < coords[i].length; j++) {
+                    const result = validatePosition(coords[i][j]);
+                    if (!result.valid) {
+                        return { valid: false, error: `${type}[${i}][${j}]: ${result.error}` };
+                    }
+                }
+            }
+            return { valid: true };
+        case 'MultiPolygon':
+            if (!Array.isArray(coords)) {
+                return { valid: false, error: `${type} coordinates must be a deeply nested array` };
+            }
+            for (let i = 0; i < coords.length; i++) {
+                if (!Array.isArray(coords[i])) {
+                    return { valid: false, error: `${type}[${i}] must be an array of rings` };
+                }
+                for (let j = 0; j < coords[i].length; j++) {
+                    if (!Array.isArray(coords[i][j])) {
+                        return { valid: false, error: `${type}[${i}][${j}] must be an array of positions` };
+                    }
+                    for (let k = 0; k < coords[i][j].length; k++) {
+                        const result = validatePosition(coords[i][j][k]);
+                        if (!result.valid) {
+                            return { valid: false, error: `${type}[${i}][${j}][${k}]: ${result.error}` };
+                        }
+                    }
+                }
+            }
+            return { valid: true };
+        default:
+            return { valid: true };
+    }
+}
+function validatePosition(pos) {
+    if (!Array.isArray(pos)) {
+        return { valid: false, error: 'Position must be an array of numbers' };
+    }
+    if (pos.length < 2 || pos.length > 3) {
+        return { valid: false, error: `Position must have 2 or 3 coordinates, got ${pos.length}` };
+    }
+    for (let i = 0; i < pos.length; i++) {
+        if (typeof pos[i] !== 'number' || isNaN(pos[i])) {
+            return { valid: false, error: `Position[${i}] must be a valid number` };
+        }
+    }
+    return { valid: true };
+}
+/**
+ * 尝试从可能不规范的 WKT 中恢复出有效结果
+ * 主要处理尾部多余字符的情况
+ */
+function tryFixWKT(wkt) {
+    const trimmed = wkt.trim();
+    if (!trimmed) {
+        return { fixed: wkt, changed: false };
+    }
+    // 先尝试直接解析，如果成功则不需要修复
+    try {
+        parse(trimmed);
+        return { fixed: trimmed, changed: false };
+    }
+    catch {
+        // 解析失败，尝试修复
+    }
+    // 尝试找到最后一个有效的 geometry 结束位置
+    const patterns = [
+        /\)\s*[A-Z]/i, // 括号后跟字母 (如 POLYGON ((...)) POINT )
+        /EMPTY\s+[A-Z]/i, // EMPTY 后跟字母
+        /\)\s*$/, // 括号结尾后有多余内容
+    ];
+    for (const pattern of patterns) {
+        const match = trimmed.match(pattern);
+        if (match) {
+            const fixed = trimmed.slice(0, match.index + (match[0].match(/\)/)?.[0].length || 0));
+            try {
+                parse(fixed);
+                return { fixed, changed: true };
+            }
+            catch {
+                // 这个修复方案不行，尝试下一个
+            }
+        }
+    }
+    // 尝试去除尾部垃圾字符
+    const lastValidIndex = findLastValidPosition(trimmed);
+    if (lastValidIndex > 0) {
+        const fixed = trimmed.slice(0, lastValidIndex + 1);
+        try {
+            parse(fixed);
+            return { fixed, changed: true };
+        }
+        catch {
+            // 修复失败
+        }
+    }
+    return { fixed: wkt, changed: false };
+}
+function findLastValidPosition(wkt) {
+    // 从后往前找第一个有效的右括号位置
+    let depth = 0;
+    for (let i = wkt.length - 1; i >= 0; i--) {
+        const c = wkt[i];
+        if (c === ')')
+            depth++;
+        else if (c === '(')
+            depth--;
+        else if (c === ' ' && depth === 0 && i < wkt.length - 1) {
+            // 检查这个空格是否在有效位置
+            const afterSpace = wkt.slice(i + 1).trim();
+            if (!afterSpace)
+                continue;
+            if (!/^[A-Z]/.test(afterSpace))
+                continue;
+            // 如果空格后面是字母开头，可能是垃圾字符
+            if (i > 5 && /[A-Z]$/.test(wkt.slice(0, i).trim())) {
+                return i - 1;
+            }
+        }
+    }
+    return wkt.length - 1;
+}
+/**
+ * 深度克隆 GeoJSON 对象（用于避免意外修改原对象）
+ */
+function cloneGeometry(geometry) {
+    return JSON.parse(JSON.stringify(geometry));
+}
+/**
+ * 判断两个几何对象是否相等（坐标对比）
+ */
+function geometryEquals(a, b) {
+    if (a.type !== b.type)
+        return false;
+    // Point 比较最常见，单独优化
+    if (a.type === 'Point') {
+        const aCoords = a.coordinates;
+        const bCoords = b.coordinates;
+        return aCoords.length === bCoords.length &&
+            aCoords[0] === bCoords[0] &&
+            aCoords[1] === bCoords[1] &&
+            (aCoords.length === 2 || aCoords[2] === bCoords[2]);
+    }
+    // 其他类型使用 JSON.stringify（缓存 key 优化可后续添加）
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+
+var validate = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    cloneGeometry: cloneGeometry,
+    geometryEquals: geometryEquals,
+    tryFixWKT: tryFixWKT,
+    validateGeoJSON: validateGeoJSON,
+    validateWKT: validateWKT
+});
+
+// 命名空间导出 - 所有公共 API 汇总
+// 使用方式: import WKT from 'wkt-parse-and-geojson';
+//          WKT.parse(...), WKT.build(...), etc.
+const WKT = {
+    ...types,
+    ...wktParser,
+    ...wktBuilder,
+    ...geojsonBuilder,
+    ...wktToGeojson,
+    ...geojsonToWkt$1,
+    ...validate,
+};
+
 exports.GeoJSONBuilder = GeoJSONBuilder;
+exports.WKT = WKT;
 exports.WKTBuilder = WKTBuilder;
 exports.WKTParser = WKTParser;
 exports.build = build;
+exports.cloneGeometry = cloneGeometry;
 exports.createGeometryCollection = createGeometryCollection;
 exports.createLineString = createLineString;
 exports.createMultiLineString = createMultiLineString;
@@ -667,7 +979,11 @@ exports.createPolygon = createPolygon;
 exports.featureCollectionToWkt = featureCollectionToWkt;
 exports.featureToWkt = featureToWkt;
 exports.geojsonToWkt = geojsonToWkt;
+exports.geometryEquals = geometryEquals;
 exports.parse = parse;
+exports.tryFixWKT = tryFixWKT;
+exports.validateGeoJSON = validateGeoJSON;
+exports.validateWKT = validateWKT;
 exports.wktToFeature = wktToFeature;
 exports.wktToFeatureCollection = wktToFeatureCollection;
 exports.wktToGeoJSON = wktToGeoJSON;

package/dist/index.d.ts

@@ -4,3 +4,5 @@ export { build, WKTBuilder } from './wkt-builder';
 export { createPoint, createLineString, createPolygon, createMultiPoint, createMultiLineString, createMultiPolygon, createGeometryCollection, GeoJSONBuilder, } from './geojson-builder';
 export { wktToGeoJSON, wktToFeature, wktToFeatureCollection } from './wkt-to-geojson';
 export { geojsonToWkt, featureToWkt, featureCollectionToWkt } from './geojson-to-wkt';
+export { validateWKT, validateGeoJSON, tryFixWKT, cloneGeometry, geometryEquals, type ValidationResult, } from './validate';
+export { default as WKT } from './namespace';