wkt-parse-and-geojson 1.0.3 → 1.0.4

package/README.md

@@ -21,6 +21,7 @@
   - [featureToWkt(feature)](#7-featuretowktfeature)
   - [featureCollectionToWkt(fc)](#8-featurecollectiontowktfc)
   - [GeoJSON 工厂方法](#9-geojson-工厂方法)
+  - [校验工具](#10-校验工具)
 - [类型定义](#类型定义)
 - [注意事项与边界行为](#注意事项与边界行为)
 - [本地调试](#本地调试)
@@ -480,6 +481,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

@@ -653,10 +653,221 @@ function featureCollectionToWkt(fc) {
     });
 }
 
+/**
+ * 校验 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 };
+    }
+    // 检查是否有尾部多余字符
+    const result = validateWKT(trimmed);
+    if (result.valid) {
+        return { fixed: trimmed, changed: false };
+    }
+    // 尝试找到最后一个有效的 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));
+            if (validateWKT(fixed).valid) {
+                return { fixed, changed: true };
+            }
+        }
+    }
+    // 尝试去除尾部垃圾字符
+    const lastValidIndex = findLastValidPosition(trimmed);
+    if (lastValidIndex > 0) {
+        const fixed = trimmed.slice(0, lastValidIndex + 1);
+        if (validateWKT(fixed).valid) {
+            return { fixed, changed: true };
+        }
+    }
+    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;
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+
 exports.GeoJSONBuilder = GeoJSONBuilder;
 exports.WKTBuilder = WKTBuilder;
 exports.WKTParser = WKTParser;
 exports.build = build;
+exports.cloneGeometry = cloneGeometry;
 exports.createGeometryCollection = createGeometryCollection;
 exports.createLineString = createLineString;
 exports.createMultiLineString = createMultiLineString;
@@ -667,7 +878,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,4 @@ 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';

package/dist/index.esm.js

@@ -651,4 +651,214 @@ function featureCollectionToWkt(fc) {
     });
 }
 
-export { GeoJSONBuilder, WKTBuilder, WKTParser, build, createGeometryCollection, createLineString, createMultiLineString, createMultiPoint, createMultiPolygon, createPoint, createPolygon, featureCollectionToWkt, featureToWkt, geojsonToWkt, parse, wktToFeature, wktToFeatureCollection, wktToGeoJSON };
+/**
+ * 校验 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 };
+    }
+    // 检查是否有尾部多余字符
+    const result = validateWKT(trimmed);
+    if (result.valid) {
+        return { fixed: trimmed, changed: false };
+    }
+    // 尝试找到最后一个有效的 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));
+            if (validateWKT(fixed).valid) {
+                return { fixed, changed: true };
+            }
+        }
+    }
+    // 尝试去除尾部垃圾字符
+    const lastValidIndex = findLastValidPosition(trimmed);
+    if (lastValidIndex > 0) {
+        const fixed = trimmed.slice(0, lastValidIndex + 1);
+        if (validateWKT(fixed).valid) {
+            return { fixed, changed: true };
+        }
+    }
+    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;
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+
+export { GeoJSONBuilder, WKTBuilder, WKTParser, build, cloneGeometry, createGeometryCollection, createLineString, createMultiLineString, createMultiPoint, createMultiPolygon, createPoint, createPolygon, featureCollectionToWkt, featureToWkt, geojsonToWkt, geometryEquals, parse, tryFixWKT, validateGeoJSON, validateWKT, wktToFeature, wktToFeatureCollection, wktToGeoJSON };

package/dist/index.umd.js

@@ -657,10 +657,221 @@
         });
     }
 
+    /**
+     * 校验 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 };
+        }
+        // 检查是否有尾部多余字符
+        const result = validateWKT(trimmed);
+        if (result.valid) {
+            return { fixed: trimmed, changed: false };
+        }
+        // 尝试找到最后一个有效的 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));
+                if (validateWKT(fixed).valid) {
+                    return { fixed, changed: true };
+                }
+            }
+        }
+        // 尝试去除尾部垃圾字符
+        const lastValidIndex = findLastValidPosition(trimmed);
+        if (lastValidIndex > 0) {
+            const fixed = trimmed.slice(0, lastValidIndex + 1);
+            if (validateWKT(fixed).valid) {
+                return { fixed, changed: true };
+            }
+        }
+        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;
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+
     exports.GeoJSONBuilder = GeoJSONBuilder;
     exports.WKTBuilder = WKTBuilder;
     exports.WKTParser = WKTParser;
     exports.build = build;
+    exports.cloneGeometry = cloneGeometry;
     exports.createGeometryCollection = createGeometryCollection;
     exports.createLineString = createLineString;
     exports.createMultiLineString = createMultiLineString;
@@ -671,7 +882,11 @@
     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/validate.d.ts

@@ -0,0 +1,29 @@
+import { Geometry } from './types';
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+}
+/**
+ * 校验 WKT 字符串格式是否合法
+ */
+export declare function validateWKT(wkt: string): ValidationResult;
+/**
+ * 校验 GeoJSON Geometry 对象是否合法
+ */
+export declare function validateGeoJSON(geojson: unknown): ValidationResult;
+/**
+ * 尝试从可能不规范的 WKT 中恢复出有效结果
+ * 主要处理尾部多余字符的情况
+ */
+export declare function tryFixWKT(wkt: string): {
+    fixed: string;
+    changed: boolean;
+};
+/**
+ * 深度克隆 GeoJSON 对象（用于避免意外修改原对象）
+ */
+export declare function cloneGeometry<G extends Geometry>(geometry: G): G;
+/**
+ * 判断两个几何对象是否相等（坐标对比）
+ */
+export declare function geometryEquals(a: Geometry, b: Geometry): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wkt-parse-and-geojson",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "type": "module",
   "description": "Zero-dependency WKT parser/builder and WKT↔GeoJSON converter",
   "main": "dist/index.cjs.js",
@@ -41,5 +41,8 @@
     "rollup": "^4.40.0",
     "tslib": "^2.8.1",
     "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "wkt-parse-and-geojson": "^1.0.3"
   }
 }