giser-convert-crs 1.0.1 → 1.0.2

package/dist/geometryCrs.esm.js

@@ -1,487 +0,0 @@
-const PI = Math.PI;
-const X_PI = PI * 3000.0 / 180.0;
-const SEMI_MAJOR_AXIS = 6378245.0;
-const ECCENTRICITY_SQUARED = 0.00669342162296594323;
-
-const GPS = {
-  PI,
-  x_pi: X_PI,
-
-  delta(lat, lon) {
-    let dLat = this.transformLat(lon - 105.0, lat - 35.0);
-    let dLon = this.transformLon(lon - 105.0, lat - 35.0);
-    const radLat = lat / 180.0 * PI;
-    const sinLat = Math.sin(radLat);
-    const magic = 1 - ECCENTRICITY_SQUARED * sinLat * sinLat;
-    const sqrtMagic = Math.sqrt(magic);
-
-    dLat = (dLat * 180.0) / ((SEMI_MAJOR_AXIS * (1 - ECCENTRICITY_SQUARED)) / (magic * sqrtMagic) * PI);
-    dLon = (dLon * 180.0) / (SEMI_MAJOR_AXIS / sqrtMagic * Math.cos(radLat) * PI);
-
-    return { lat: dLat, lon: dLon };
-  },
-
-  wgs84_gcj02(wgsLon, wgsLat) {
-    this._assertLonLat(wgsLon, wgsLat);
-    if (this.outOfChina(wgsLat, wgsLon)) return [wgsLon, wgsLat];
-
-    const d = this.delta(wgsLat, wgsLon);
-    return [wgsLon + d.lon, wgsLat + d.lat];
-  },
-
-  gcj02_wgs84(gcjLon, gcjLat) {
-    this._assertLonLat(gcjLon, gcjLat);
-    if (this.outOfChina(gcjLat, gcjLon)) return [gcjLon, gcjLat];
-
-    const d = this.delta(gcjLat, gcjLon);
-    return [gcjLon - d.lon, gcjLat - d.lat];
-  },
-
-  gcj02_wgs84_precise(gcjLon, gcjLat) {
-    this._assertLonLat(gcjLon, gcjLat);
-    if (this.outOfChina(gcjLat, gcjLon)) return [gcjLon, gcjLat];
-
-    const threshold = 0.000000001;
-    let minLat = gcjLat - 0.01;
-    let minLon = gcjLon - 0.01;
-    let maxLat = gcjLat + 0.01;
-    let maxLon = gcjLon + 0.01;
-    let wgsLat = gcjLat;
-    let wgsLon = gcjLon;
-
-    for (let i = 0; i < 10000; i++) {
-      wgsLat = (minLat + maxLat) / 2;
-      wgsLon = (minLon + maxLon) / 2;
-      const [tmpLon, tmpLat] = this.wgs84_gcj02(wgsLon, wgsLat);
-      const dLat = tmpLat - gcjLat;
-      const dLon = tmpLon - gcjLon;
-
-      if (Math.abs(dLat) < threshold && Math.abs(dLon) < threshold) break;
-      if (dLat > 0) maxLat = wgsLat;
-      else minLat = wgsLat;
-      if (dLon > 0) maxLon = wgsLon;
-      else minLon = wgsLon;
-    }
-
-    return [wgsLon, wgsLat];
-  },
-
-  gcj02_bd09ll(gcjLon, gcjLat) {
-    this._assertLonLat(gcjLon, gcjLat);
-    const z = Math.sqrt(gcjLon * gcjLon + gcjLat * gcjLat) + 0.00002 * Math.sin(gcjLat * X_PI);
-    const theta = Math.atan2(gcjLat, gcjLon) + 0.000003 * Math.cos(gcjLon * X_PI);
-    return [z * Math.cos(theta) + 0.0065, z * Math.sin(theta) + 0.006];
-  },
-
-  bd09ll_gcj02(bdLon, bdLat) {
-    this._assertLonLat(bdLon, bdLat);
-    const x = bdLon - 0.0065;
-    const y = bdLat - 0.006;
-    const z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * X_PI);
-    const theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * X_PI);
-    return [z * Math.cos(theta), z * Math.sin(theta)];
-  },
-
-  wgs84_bd09ll(wgsLon, wgsLat) {
-    const gcj = this.wgs84_gcj02(wgsLon, wgsLat);
-    return this.gcj02_bd09ll(gcj[0], gcj[1]);
-  },
-
-  bd09ll_wgs84(bdLon, bdLat) {
-    const gcj = this.bd09ll_gcj02(bdLon, bdLat);
-    return this.gcj02_wgs84(gcj[0], gcj[1]);
-  },
-
-  bd09ll_wgs84_precise(bdLon, bdLat) {
-    const gcj = this.bd09ll_gcj02(bdLon, bdLat);
-    return this.gcj02_wgs84_precise(gcj[0], gcj[1]);
-  },
-
-  outOfChina(lat, lon) {
-    return lon < 72.004 || lon > 137.8347 || lat < 0.8293 || lat > 55.8271;
-  },
-
-  transformLat(x, y) {
-    let ret = -100 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(Math.abs(x));
-    ret += (20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0 / 3.0;
-    ret += (20.0 * Math.sin(y * PI) + 40.0 * Math.sin(y / 3.0 * PI)) * 2.0 / 3.0;
-    ret += (160.0 * Math.sin(y / 12.0 * PI) + 320.0 * Math.sin(y * PI / 30.0)) * 2.0 / 3.0;
-    return ret;
-  },
-
-  transformLon(x, y) {
-    let ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(Math.abs(x));
-    ret += (20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0 / 3.0;
-    ret += (20.0 * Math.sin(x * PI) + 40.0 * Math.sin(x / 3.0 * PI)) * 2.0 / 3.0;
-    ret += (150.0 * Math.sin(x / 12.0 * PI) + 300.0 * Math.sin(x / 30.0 * PI)) * 2.0 / 3.0;
-    return ret;
-  },
-
-  gcj_encrypt(wgsLat, wgsLon) {
-    const [lon, lat] = this.wgs84_gcj02(wgsLon, wgsLat);
-    return { lat, lon };
-  },
-
-  _assertLonLat(lon, lat) {
-    if (!Number.isFinite(lon) || !Number.isFinite(lat)) {
-      throw new Error('Invalid coordinate: longitude and latitude must be finite numbers.');
-    }
-  }
-};
-
-const crs = {
-  bd09ll: '+proj=longlat +datum=BD09',
-  gcj02: '+proj=longlat +datum=GCJ02',
-  wgs84: '+proj=longlat +datum=WGS84 +no_defs'
-};
-
-const CRS_ALIASES = {
-  'bd-09': 'bd09ll',
-  'bd09': 'bd09ll',
-  'bd09ll': 'bd09ll',
-  'epsg:4326': 'wgs84',
-  'gcj-02': 'gcj02',
-  'gcj02': 'gcj02',
-  'wgs-84': 'wgs84',
-  'wgs84': 'wgs84'
-};
-
-const ProjectionTransform = {
-  crs,
-
-  transform(source, fromCRS, toCRS) {
-    if (source == null) return null;
-
-    const from = this._normalizeCRS(fromCRS);
-    const to = this._normalizeCRS(toCRS);
-
-    if (this._isCoord(source)) {
-      return this._transformCoordinate(source, from, to);
-    }
-
-    if (Array.isArray(source)) {
-      return this._transformCoordinateTree(source, from, to);
-    }
-
-    return this._transformGeoJSON(source, from, to);
-  },
-
-  _transformGeoJSON(geoJSON, fromCRS, toCRS) {
-    if (!geoJSON || typeof geoJSON !== 'object') {
-      throw new Error('Invalid GeoJSON object.');
-    }
-
-    if (geoJSON.type === 'Feature') {
-      return {
-        ...geoJSON,
-        geometry: geoJSON.geometry ? this.transform(geoJSON.geometry, fromCRS, toCRS) : null
-      };
-    }
-
-    if (geoJSON.type === 'FeatureCollection') {
-      if (!Array.isArray(geoJSON.features)) throw new Error('Invalid FeatureCollection: features must be an array.');
-      return {
-        ...geoJSON,
-        features: geoJSON.features.map(feature => this.transform(feature, fromCRS, toCRS))
-      };
-    }
-
-    if (geoJSON.type === 'GeometryCollection') {
-      if (!Array.isArray(geoJSON.geometries)) throw new Error('Invalid GeometryCollection: geometries must be an array.');
-      return {
-        ...geoJSON,
-        geometries: geoJSON.geometries.map(geometry => this.transform(geometry, fromCRS, toCRS))
-      };
-    }
-
-    if ('coordinates' in geoJSON) {
-      return {
-        ...geoJSON,
-        coordinates: this._transformCoordinateTree(geoJSON.coordinates, fromCRS, toCRS)
-      };
-    }
-
-    throw new Error(`Unsupported GeoJSON type: ${geoJSON.type || 'unknown'}.`);
-  },
-
-  _transformCoordinateTree(coordinates, fromCRS, toCRS) {
-    if (coordinates == null) return coordinates;
-    if (this._isCoord(coordinates)) return this._transformCoordinate(coordinates, fromCRS, toCRS);
-    if (!Array.isArray(coordinates)) throw new Error('Invalid coordinates: expected coordinate array.');
-    return coordinates.map(item => this._transformCoordinateTree(item, fromCRS, toCRS));
-  },
-
-  _transformCoordinate(coordinate, fromCRS, toCRS) {
-    const from = this._normalizeCRS(fromCRS);
-    const to = this._normalizeCRS(toCRS);
-    const lon = Number(coordinate[0]);
-    const lat = Number(coordinate[1]);
-
-    if (!Number.isFinite(lon) || !Number.isFinite(lat)) {
-      throw new Error('Invalid coordinate: longitude and latitude must be finite numbers.');
-    }
-
-    if (from === to) return [lon, lat, ...coordinate.slice(2)];
-
-    const method = `${from}_${to}`;
-    if (typeof GPS[method] !== 'function') {
-      throw new Error(`Unsupported CRS transform: ${fromCRS} -> ${toCRS}.`);
-    }
-
-    const transformed = GPS[method](lon, lat);
-    return [transformed[0], transformed[1], ...coordinate.slice(2)];
-  },
-
-  _normalizeCRS(value) {
-    if (!value) throw new Error('must provide a valid fromCRS and toCRS.');
-
-    if (typeof value === 'object') {
-      if (value.type === 'proj4' && value.properties && value.properties.proj) {
-        const crsName = this._toCRS(value.properties.proj);
-        if (crsName) return crsName;
-      }
-      throw new Error('Unsupported CRS object.');
-    }
-
-    const key = String(value).trim().toLowerCase();
-    const normalized = CRS_ALIASES[key];
-    if (!normalized) throw new Error(`Unsupported CRS: ${value}.`);
-    return normalized;
-  },
-
-  _toCRS(proj) {
-    for (const key in this.crs) {
-      if (proj === this.crs[key]) return key;
-    }
-    return null;
-  },
-
-  _isCoord(coordinate) {
-    return Array.isArray(coordinate) &&
-      coordinate.length >= 2 &&
-      Number.isFinite(Number(coordinate[0])) &&
-      Number.isFinite(Number(coordinate[1])) &&
-      !Array.isArray(coordinate[0]) &&
-      !Array.isArray(coordinate[1]);
-  }
-};
-
-const TYPE_MAP = {
-  POINT: 'Point',
-  LINESTRING: 'LineString',
-  POLYGON: 'Polygon',
-  MULTIPOINT: 'MultiPoint',
-  MULTILINESTRING: 'MultiLineString',
-  MULTIPOLYGON: 'MultiPolygon'
-};
-
-const REVERSE_TYPE_MAP = Object.fromEntries(
-  Object.entries(TYPE_MAP).map(([wktType, geoJSONType]) => [geoJSONType, wktType])
-);
-
-const WKT = {
-  parse(wkt) {
-    if (typeof wkt !== 'string' || !wkt.trim()) {
-      throw new Error('Invalid WKT string.');
-    }
-
-    const source = wkt.trim();
-    const header = source.match(/^([A-Za-z]+)(?:\s+(ZM|Z|M))?\s*/i);
-    if (!header) throw new Error('Invalid WKT string.');
-
-    const wktType = header[1].toUpperCase();
-    const geoJSONType = TYPE_MAP[wktType];
-    if (!geoJSONType) throw new Error(`Unsupported WKT type: ${wktType}.`);
-
-    const body = source.slice(header[0].length).trim();
-    if (/^EMPTY$/i.test(body)) {
-      return { type: geoJSONType, coordinates: this._emptyCoordinates(geoJSONType) };
-    }
-
-    if (!body.startsWith('(') || !body.endsWith(')')) {
-      throw new Error('Invalid WKT string: missing coordinate parentheses.');
-    }
-
-    const content = this._stripOuterParens(body);
-    return {
-      type: geoJSONType,
-      coordinates: this._parseCoordinates(content, geoJSONType)
-    };
-  },
-
-  stringify(geoJSON) {
-    if (!geoJSON || typeof geoJSON !== 'object' || !geoJSON.type) {
-      throw new Error('Invalid GeoJSON.');
-    }
-
-    const wktType = REVERSE_TYPE_MAP[geoJSON.type];
-    if (!wktType) throw new Error(`Unsupported geometry type: ${geoJSON.type}.`);
-
-    const coords = geoJSON.coordinates;
-    if (this._isEmpty(coords)) return `${wktType} EMPTY`;
-
-    return `${wktType}(${this._stringifyCoordinates(coords, geoJSON.type)})`;
-  },
-
-  _parseCoordinates(content, type) {
-    switch (type) {
-      case 'Point':
-        return this._parsePoint(content);
-      case 'LineString':
-        return this._parsePointList(content);
-      case 'Polygon':
-        return this._parsePolygon(content);
-      case 'MultiPoint':
-        return this._parseMultiPoint(content);
-      case 'MultiLineString':
-        return this._splitTopLevel(content).map(line => this._parsePointList(this._stripOptionalOuterParens(line)));
-      case 'MultiPolygon':
-        return this._splitTopLevel(content).map(poly => this._parsePolygon(this._stripOptionalOuterParens(poly)));
-      default:
-        throw new Error(`Unsupported geometry type: ${type}.`);
-    }
-  },
-
-  _parsePoint(value) {
-    const numbers = value.trim().split(/\s+/).filter(Boolean).map(Number);
-    if (numbers.length < 2 || numbers.some(n => !Number.isFinite(n))) {
-      throw new Error(`Invalid WKT coordinate: ${value}.`);
-    }
-    return numbers;
-  },
-
-  _parsePointList(value) {
-    const points = this._splitTopLevel(value).map(part => this._parsePoint(this._stripOptionalOuterParens(part)));
-    if (!points.length) throw new Error('Invalid WKT coordinate list.');
-    return points;
-  },
-
-  _parsePolygon(value) {
-    const rings = this._splitTopLevel(value).map(ring => this._parsePointList(this._stripOptionalOuterParens(ring)));
-    if (!rings.length) throw new Error('Invalid WKT polygon.');
-    return rings;
-  },
-
-  _parseMultiPoint(value) {
-    return this._splitTopLevel(value).map(point => this._parsePoint(this._stripOptionalOuterParens(point)));
-  },
-
-  _splitTopLevel(value) {
-    const parts = [];
-    let depth = 0;
-    let start = 0;
-
-    for (let i = 0; i < value.length; i++) {
-      const char = value[i];
-      if (char === '(') depth++;
-      else if (char === ')') depth--;
-
-      if (depth < 0) throw new Error('Invalid WKT string: unbalanced parentheses.');
-
-      if (char === ',' && depth === 0) {
-        parts.push(value.slice(start, i).trim());
-        start = i + 1;
-      }
-    }
-
-    if (depth !== 0) throw new Error('Invalid WKT string: unbalanced parentheses.');
-    const last = value.slice(start).trim();
-    if (last) parts.push(last);
-    return parts;
-  },
-
-  _stripOuterParens(value) {
-    const trimmed = value.trim();
-    if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {
-      throw new Error('Invalid WKT string: missing coordinate parentheses.');
-    }
-    return trimmed.slice(1, -1).trim();
-  },
-
-  _stripOptionalOuterParens(value) {
-    const trimmed = value.trim();
-    if (!trimmed.startsWith('(')) return trimmed;
-    return this._stripOuterParens(trimmed);
-  },
-
-  _stringifyCoordinates(coords, type) {
-    switch (type) {
-      case 'Point':
-        return this._stringifyPoint(coords);
-      case 'LineString':
-        return this._stringifyPointList(coords);
-      case 'Polygon':
-        return this._stringifyPolygon(coords);
-      case 'MultiPoint':
-        return coords.map(point => `(${this._stringifyPoint(point)})`).join(', ');
-      case 'MultiLineString':
-        return coords.map(line => `(${this._stringifyPointList(line)})`).join(', ');
-      case 'MultiPolygon':
-        return coords.map(poly => `(${this._stringifyPolygon(poly)})`).join(', ');
-      default:
-        throw new Error(`Unsupported geometry type: ${type}.`);
-    }
-  },
-
-  _stringifyPoint(point) {
-    if (!Array.isArray(point) || point.length < 2) throw new Error('Invalid coordinate.');
-    return point.map(value => {
-      const number = Number(value);
-      if (!Number.isFinite(number)) throw new Error('Invalid coordinate value.');
-      return String(number);
-    }).join(' ');
-  },
-
-  _stringifyPointList(points) {
-    if (!Array.isArray(points)) throw new Error('Invalid coordinate list.');
-    return points.map(point => this._stringifyPoint(point)).join(', ');
-  },
-
-  _stringifyPolygon(rings) {
-    if (!Array.isArray(rings)) throw new Error('Invalid polygon coordinates.');
-    return rings.map(ring => `(${this._stringifyPointList(ring)})`).join(', ');
-  },
-
-  _emptyCoordinates(type) {
-    return type === 'Point' ? [] : [];
-  },
-
-  _isEmpty(coords) {
-    return Array.isArray(coords) && coords.length === 0;
-  }
-};
-
-const geometryCrs = {
-  GPS,
-  ProjectionTransform,
-  WKT,
-
-  transform(input, fromCRS, toCRS) {
-    if (input == null || input === '') return null;
-
-    if (typeof input === 'string') {
-      const geoJSON = WKT.parse(input);
-      return WKT.stringify(ProjectionTransform.transform(geoJSON, fromCRS, toCRS));
-    }
-
-    return ProjectionTransform.transform(input, fromCRS, toCRS);
-  },
-
-  transformPoint(coord, fromCRS, toCRS) {
-    return this.transform(coord, fromCRS, toCRS);
-  },
-
-  transformPoints(points, fromCRS, toCRS) {
-    return this.transform(points, fromCRS, toCRS);
-  },
-
-  transformGeoJSON(geoJSON, fromCRS, toCRS) {
-    return this.transform(geoJSON, fromCRS, toCRS);
-  },
-
-  transformWKT(wkt, fromCRS, toCRS) {
-    return this.transform(wkt, fromCRS, toCRS);
-  }
-};
-
-export { GPS, ProjectionTransform, WKT, geometryCrs as default };