@loaders.gl/wkt 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/lib/parse-wkt-crs.js

@@ -1,96 +1,120 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// parse-wkt-crs was forked from https://github.com/DanielJDufour/wkt-crs under Creative Commons CC0 1.0 license.
+/**
+ *
+ * @param wkt
+ * @param options
+ * @returns
+ */
 export function parseWKTCRS(wkt, options) {
-  if (options !== null && options !== void 0 && options.debug) {
-    console.log('[wktcrs] parse starting with\n', wkt);
-  }
-  wkt = wkt.replace(/[A-Z][A-Z\d_]+\[/gi, match => `["${match.substr(0, match.length - 1)}",`);
-  wkt = wkt.replace(/, ?([A-Z][A-Z\d_]+[,\]])/gi, (match, p1) => {
-    const varname = p1.substr(0, p1.length - 1);
-    return ',' + `"${options !== null && options !== void 0 && options.raw ? 'raw:' : ''}${varname}"${p1[p1.length - 1]}`;
-  });
-  if (options !== null && options !== void 0 && options.raw) {
-    wkt = wkt.replace(/, {0,2}(-?[\.\d]+)(?=,|\])/g, function (match, p1) {
-      return ',' + `"${options !== null && options !== void 0 && options.raw ? 'raw:' : ''}${p1}"`;
-    });
-  }
-  if (options !== null && options !== void 0 && options.debug) {
-    console.log(`[wktcrs] json'd wkt: '${wkt}'`);
-  }
-  let data;
-  try {
-    data = JSON.parse(wkt);
-  } catch (error) {
-    console.error(`[wktcrs] failed to parse '${wkt}'`);
-    throw error;
-  }
-  if (options !== null && options !== void 0 && options.debug) {
-    console.log(`[wktcrs] json parsed: '${wkt}'`);
-  }
-  function process(data, parent) {
-    const kw = data[0];
-    data.forEach(function (it) {
-      if (Array.isArray(it)) {
-        process(it, data);
-      }
+    if (options?.debug) {
+        console.log('[wktcrs] parse starting with\n', wkt);
+    }
+    // move all keywords into first array item slot
+    // from PARAM[12345, 67890] to ["PARAM", 12345, 67890]
+    wkt = wkt.replace(/[A-Z][A-Z\d_]+\[/gi, (match) => `["${match.substr(0, match.length - 1)}",`);
+    // wrap variables in strings
+    // from [...,NORTH] to [...,"NORTH"]
+    wkt = wkt.replace(/, ?([A-Z][A-Z\d_]+[,\]])/gi, (match, p1) => {
+        const varname = p1.substr(0, p1.length - 1);
+        return ',' + `"${options?.raw ? 'raw:' : ''}${varname}"${p1[p1.length - 1]}`;
     });
-    const kwarr = `MULTIPLE_${kw}`;
-    if (kwarr in parent) {
-      parent[kwarr].push(data);
-    } else if (kw in parent) {
-      parent[kwarr] = [parent[kw], data];
-      delete parent[kw];
-    } else {
-      parent[kw] = data;
+    if (options?.raw) {
+        // replace all numbers with strings
+        wkt = wkt.replace(/, {0,2}(-?[\.\d]+)(?=,|\])/g, function (match, p1) {
+            return ',' + `"${options?.raw ? 'raw:' : ''}${p1}"`;
+        });
+    }
+    // str should now be valid JSON
+    if (options?.debug) {
+        console.log(`[wktcrs] json'd wkt: '${wkt}'`);
+    }
+    let data;
+    try {
+        data = JSON.parse(wkt);
     }
-    return parent;
-  }
-  const result = process(data, [data]);
-  if (options !== null && options !== void 0 && options.debug) {
-    console.log('[wktcrs] parse returning', result);
-  }
-  if (options !== null && options !== void 0 && options.sort) {
-    sort(result, options);
-  }
-  return result;
+    catch (error) {
+        console.error(`[wktcrs] failed to parse '${wkt}'`);
+        throw error;
+    }
+    if (options?.debug) {
+        console.log(`[wktcrs] json parsed: '${wkt}'`);
+    }
+    function process(data, parent) {
+        const kw = data[0];
+        // after removing the first element with .shift()
+        // data is now just an array of attributes
+        data.forEach(function (it) {
+            if (Array.isArray(it)) {
+                process(it, data);
+            }
+        });
+        const kwarr = `MULTIPLE_${kw}`;
+        if (kwarr in parent) {
+            parent[kwarr].push(data);
+        }
+        else if (kw in parent) {
+            parent[kwarr] = [parent[kw], data];
+            delete parent[kw];
+        }
+        else {
+            parent[kw] = data;
+        }
+        return parent;
+    }
+    const result = process(data, [data]);
+    if (options?.debug) {
+        console.log('[wktcrs] parse returning', result);
+    }
+    if (options?.sort) {
+        sort(result, options);
+    }
+    return result;
 }
 function sort(data, options) {
-  const keys = Object.keys(data).filter(k => !/\d+/.test(k));
-  const keywords = (options === null || options === void 0 ? void 0 : options.keywords) || [];
-  if (!(options !== null && options !== void 0 && options.keywords)) {
-    const counts = {};
-    if (Array.isArray(data)) {
-      data.forEach(it => {
-        if (Array.isArray(it) && it.length >= 2 && typeof it[1] === 'string') {
-          const k = it[0];
-          if (!counts[k]) counts[k] = 0;
-          counts[k]++;
+    const keys = Object.keys(data).filter((k) => !/\d+/.test(k));
+    const keywords = options?.keywords || [];
+    if (!options?.keywords) {
+        // try to find multiples
+        const counts = {};
+        if (Array.isArray(data)) {
+            data.forEach((it) => {
+                if (Array.isArray(it) && it.length >= 2 && typeof it[1] === 'string') {
+                    const k = it[0];
+                    if (!counts[k])
+                        counts[k] = 0;
+                    counts[k]++;
+                }
+            });
+            for (const k in counts) {
+                if (counts[k] > 0)
+                    keywords.push(k);
+            }
         }
-      });
-      for (const k in counts) {
-        if (counts[k] > 0) keywords.push(k);
-      }
     }
-  }
-  keys.forEach(key => {
-    data[key] = sort(data[key]);
-  });
-  keywords.forEach(key => {
-    const indices = [];
-    const params = [];
-    data.forEach((item, i) => {
-      if (Array.isArray(item) && item[0] === key) {
-        indices.push(i);
-        params.push(item);
-      }
-    });
-    params.sort((a, b) => {
-      a = a[1].toString();
-      b = b[1].toString();
-      return a < b ? -1 : a > b ? 1 : 0;
+    keys.forEach((key) => {
+        data[key] = sort(data[key]);
     });
-    params.forEach((param, i) => {
-      data[indices[i]] = param;
+    keywords.forEach((key) => {
+        const indices = [];
+        const params = [];
+        data.forEach((item, i) => {
+            if (Array.isArray(item) && item[0] === key) {
+                indices.push(i);
+                params.push(item);
+            }
+        });
+        params.sort((a, b) => {
+            a = a[1].toString();
+            b = b[1].toString();
+            return a < b ? -1 : a > b ? 1 : 0;
+        });
+        // replace in order
+        params.forEach((param, i) => {
+            data[indices[i]] = param;
+        });
     });
-  });
-  return data;
+    return data;
 }
-//# sourceMappingURL=parse-wkt-crs.js.map

package/dist/lib/parse-wkt.js

@@ -1,222 +1,288 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Fork of https://github.com/mapbox/wellknown under ISC license (MIT/BSD-2-clause equivalent)
+/* eslint-disable */
+// @ts-nocheck
 const numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
+// Matches sequences like '100 100' or '100 100 100'.
 const tuples = new RegExp('^' + numberRegexp.source + '(\\s' + numberRegexp.source + '){1,}');
-export const WKT_MAGIC_STRINGS = ['POINT(', 'LINESTRING(', 'POLYGON(', 'MULTIPOINT(', 'MULTILINESTRING(', 'MULTIPOLYGON(', 'GEOMETRYCOLLECTION('];
+export const WKT_MAGIC_STRINGS = [
+    'POINT(',
+    'LINESTRING(',
+    'POLYGON(',
+    'MULTIPOINT(',
+    'MULTILINESTRING(',
+    'MULTIPOLYGON(',
+    'GEOMETRYCOLLECTION('
+    // We only support this "geojson" subset of the OGC simple features standard
+];
+/**
+ * Check if a string is WKT.
+ * @param input A potential WKT geometry string
+ * @return `true` if input appears to be a WKT geometry string, `false` otherwise
+
+ * @note We only support the "geojson" subset of the OGC simple features standard
+ * @todo Does not handle leading spaces which appear to be permitted per the spec:
+ * "A WKT string contains no white space outside of double quotes.
+ * However padding with white space to improve human readability is permitted;
+ * the examples of WKT that are included in this document have
+ * spaces and line feeds inserted to improve clarity. Any padding is stripped out or ignored by parsers."
+ */
 export function isWKT(input) {
-  return WKT_MAGIC_STRINGS.some(magicString => input.startsWith(magicString));
+    return WKT_MAGIC_STRINGS.some((magicString) => input.startsWith(magicString));
 }
+/**
+ * Parse WKT and return GeoJSON.
+ * @param input A WKT geometry string
+ * @return A GeoJSON geometry object
+ *
+ * @note We only support the "geojson" subset of the OGC simple features standard
+ **/
 export function parseWKT(input, options) {
-  return parseWKTToGeometry(input, options);
+    // TODO handle options.wkt.shape
+    return parseWKTToGeometry(input, options);
 }
+/** Parse into GeoJSON geometry */
 function parseWKTToGeometry(input, options) {
-  var _options$wkt;
-  const parts = input.split(';');
-  let _ = parts.pop();
-  const srid = (parts.shift() || '').split('=').pop();
-  const state = {
-    parts,
-    _,
-    i: 0
-  };
-  const geometry = parseGeometry(state);
-  return options !== null && options !== void 0 && (_options$wkt = options.wkt) !== null && _options$wkt !== void 0 && _options$wkt.crs ? addCRS(geometry, srid) : geometry;
+    const parts = input.split(';');
+    let _ = parts.pop();
+    const srid = (parts.shift() || '').split('=').pop();
+    const state = { parts, _, i: 0 };
+    const geometry = parseGeometry(state);
+    return options?.wkt?.crs ? addCRS(geometry, srid) : geometry;
 }
 function parseGeometry(state) {
-  return parsePoint(state) || parseLineString(state) || parsePolygon(state) || parseMultiPoint(state) || parseMultiLineString(state) || parseMultiPolygon(state) || parseGeometryCollection(state);
+    return (parsePoint(state) ||
+        parseLineString(state) ||
+        parsePolygon(state) ||
+        parseMultiPoint(state) ||
+        parseMultiLineString(state) ||
+        parseMultiPolygon(state) ||
+        parseGeometryCollection(state));
 }
+/** Adds a coordinate reference system as an undocumented  */
 function addCRS(obj, srid) {
-  if (obj && srid !== null && srid !== void 0 && srid.match(/\d+/)) {
-    const crs = {
-      type: 'name',
-      properties: {
-        name: 'urn:ogc:def:crs:EPSG::' + srid
-      }
-    };
-    obj.crs = crs;
-  }
-  return obj;
+    if (obj && srid?.match(/\d+/)) {
+        const crs = {
+            type: 'name',
+            properties: {
+                name: 'urn:ogc:def:crs:EPSG::' + srid
+            }
+        };
+        // @ts-expect-error we assign an undocumented property on the geometry
+        obj.crs = crs;
+    }
+    return obj;
 }
+// GEOMETRIES
 function parsePoint(state) {
-  if (!$(/^(POINT(\sz)?)/i, state)) {
-    return null;
-  }
-  white(state);
-  if (!$(/^(\()/, state)) {
-    return null;
-  }
-  const c = coords(state);
-  if (!c) {
-    return null;
-  }
-  white(state);
-  if (!$(/^(\))/, state)) {
-    return null;
-  }
-  return {
-    type: 'Point',
-    coordinates: c[0]
-  };
+    if (!$(/^(POINT(\sz)?)/i, state)) {
+        return null;
+    }
+    white(state);
+    if (!$(/^(\()/, state)) {
+        return null;
+    }
+    const c = coords(state);
+    if (!c) {
+        return null;
+    }
+    white(state);
+    if (!$(/^(\))/, state)) {
+        return null;
+    }
+    return {
+        type: 'Point',
+        coordinates: c[0]
+    };
 }
 function parseMultiPoint(state) {
-  var _state$_, _state$_2;
-  if (!$(/^(MULTIPOINT)/i, state)) {
-    return null;
-  }
-  white(state);
-  const newCoordsFormat = (_state$_ = state._) === null || _state$_ === void 0 ? void 0 : _state$_.substring(((_state$_2 = state._) === null || _state$_2 === void 0 ? void 0 : _state$_2.indexOf('(')) + 1, state._.length - 1).replace(/\(/g, '').replace(/\)/g, '');
-  state._ = 'MULTIPOINT (' + newCoordsFormat + ')';
-  const c = multicoords(state);
-  if (!c) {
-    return null;
-  }
-  white(state);
-  return {
-    type: 'MultiPoint',
-    coordinates: c
-  };
+    if (!$(/^(MULTIPOINT)/i, state)) {
+        return null;
+    }
+    white(state);
+    const newCoordsFormat = state._?.substring(state._?.indexOf('(') + 1, state._.length - 1)
+        .replace(/\(/g, '')
+        .replace(/\)/g, '');
+    state._ = 'MULTIPOINT (' + newCoordsFormat + ')';
+    const c = multicoords(state);
+    if (!c) {
+        return null;
+    }
+    white(state);
+    return {
+        type: 'MultiPoint',
+        coordinates: c
+    };
 }
 function parseLineString(state) {
-  if (!$(/^(LINESTRING(\sz)?)/i, state)) {
-    return null;
-  }
-  white(state);
-  if (!$(/^(\()/, state)) {
-    return null;
-  }
-  const c = coords(state);
-  if (!c) {
-    return null;
-  }
-  if (!$(/^(\))/, state)) {
-    return null;
-  }
-  return {
-    type: 'LineString',
-    coordinates: c
-  };
+    if (!$(/^(LINESTRING(\sz)?)/i, state)) {
+        return null;
+    }
+    white(state);
+    if (!$(/^(\()/, state)) {
+        return null;
+    }
+    const c = coords(state);
+    if (!c) {
+        return null;
+    }
+    if (!$(/^(\))/, state)) {
+        return null;
+    }
+    return {
+        type: 'LineString',
+        coordinates: c
+    };
 }
 function parseMultiLineString(state) {
-  if (!$(/^(MULTILINESTRING)/i, state)) return null;
-  white(state);
-  const c = multicoords(state);
-  if (!c) {
-    return null;
-  }
-  white(state);
-  return {
-    type: 'MultiLineString',
-    coordinates: c
-  };
+    if (!$(/^(MULTILINESTRING)/i, state))
+        return null;
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+        return null;
+    }
+    white(state);
+    return {
+        // @ts-ignore
+        type: 'MultiLineString',
+        // @ts-expect-error
+        coordinates: c
+    };
 }
 function parsePolygon(state) {
-  if (!$(/^(POLYGON(\sz)?)/i, state)) {
-    return null;
-  }
-  white(state);
-  const c = multicoords(state);
-  if (!c) {
-    return null;
-  }
-  return {
-    type: 'Polygon',
-    coordinates: c
-  };
+    if (!$(/^(POLYGON(\sz)?)/i, state)) {
+        return null;
+    }
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+        return null;
+    }
+    return {
+        // @ts-ignore
+        type: 'Polygon',
+        // @ts-expect-error
+        coordinates: c
+    };
 }
 function parseMultiPolygon(state) {
-  if (!$(/^(MULTIPOLYGON)/i, state)) {
-    return null;
-  }
-  white(state);
-  const c = multicoords(state);
-  if (!c) {
-    return null;
-  }
-  return {
-    type: 'MultiPolygon',
-    coordinates: c
-  };
+    if (!$(/^(MULTIPOLYGON)/i, state)) {
+        return null;
+    }
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+        return null;
+    }
+    return {
+        type: 'MultiPolygon',
+        // @ts-expect-error
+        coordinates: c
+    };
 }
 function parseGeometryCollection(state) {
-  const geometries = [];
-  let geometry;
-  if (!$(/^(GEOMETRYCOLLECTION)/i, state)) {
-    return null;
-  }
-  white(state);
-  if (!$(/^(\()/, state)) {
-    return null;
-  }
-  while (geometry = parseGeometry(state)) {
-    geometries.push(geometry);
-    white(state);
-    $(/^(,)/, state);
+    const geometries = [];
+    let geometry;
+    if (!$(/^(GEOMETRYCOLLECTION)/i, state)) {
+        return null;
+    }
     white(state);
-  }
-  if (!$(/^(\))/, state)) {
-    return null;
-  }
-  return {
-    type: 'GeometryCollection',
-    geometries: geometries
-  };
+    if (!$(/^(\()/, state)) {
+        return null;
+    }
+    while ((geometry = parseGeometry(state))) {
+        geometries.push(geometry);
+        white(state);
+        $(/^(,)/, state);
+        white(state);
+    }
+    if (!$(/^(\))/, state)) {
+        return null;
+    }
+    return {
+        type: 'GeometryCollection',
+        geometries: geometries
+    };
 }
+// COORDINATES
 function multicoords(state) {
-  white(state);
-  let depth = 0;
-  const rings = [];
-  const stack = [rings];
-  let pointer = rings;
-  let elem;
-  while (elem = $(/^(\()/, state) || $(/^(\))/, state) || $(/^(,)/, state) || $(tuples, state)) {
-    if (elem === '(') {
-      stack.push(pointer);
-      pointer = [];
-      stack[stack.length - 1].push(pointer);
-      depth++;
-    } else if (elem === ')') {
-      if (pointer.length === 0) return null;
-      pointer = stack.pop();
-      if (!pointer) return null;
-      depth--;
-      if (depth === 0) break;
-    } else if (elem === ',') {
-      pointer = [];
-      stack[stack.length - 1].push(pointer);
-    } else if (!elem.split(/\s/g).some(isNaN)) {
-      Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
-    } else {
-      return null;
-    }
     white(state);
-  }
-  if (depth !== 0) return null;
-  return rings;
+    let depth = 0;
+    const rings = [];
+    const stack = [rings];
+    let pointer = rings;
+    let elem;
+    while ((elem = $(/^(\()/, state) || $(/^(\))/, state) || $(/^(,)/, state) || $(tuples, state))) {
+        if (elem === '(') {
+            stack.push(pointer);
+            pointer = [];
+            stack[stack.length - 1].push(pointer);
+            depth++;
+        }
+        else if (elem === ')') {
+            // For the case: Polygon(), ...
+            if (pointer.length === 0)
+                return null;
+            // @ts-ignore
+            pointer = stack.pop();
+            // the stack was empty, input was malformed
+            if (!pointer)
+                return null;
+            depth--;
+            if (depth === 0)
+                break;
+        }
+        else if (elem === ',') {
+            pointer = [];
+            stack[stack.length - 1].push(pointer);
+        }
+        else if (!elem.split(/\s/g).some(isNaN)) {
+            Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
+        }
+        else {
+            return null;
+        }
+        white(state);
+    }
+    if (depth !== 0)
+        return null;
+    return rings;
 }
 function coords(state) {
-  const list = [];
-  let item;
-  let pt;
-  while (pt = $(tuples, state) || $(/^(,)/, state)) {
-    if (pt === ',') {
-      list.push(item);
-      item = [];
-    } else if (!pt.split(/\s/g).some(isNaN)) {
-      if (!item) item = [];
-      Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
+    const list = [];
+    let item;
+    let pt;
+    while ((pt = $(tuples, state) || $(/^(,)/, state))) {
+        if (pt === ',') {
+            list.push(item);
+            item = [];
+        }
+        else if (!pt.split(/\s/g).some(isNaN)) {
+            if (!item)
+                item = [];
+            Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
+        }
+        white(state);
     }
-    white(state);
-  }
-  if (item) list.push(item);else return null;
-  return list.length ? list : null;
+    if (item)
+        list.push(item);
+    else
+        return null;
+    return list.length ? list : null;
 }
+// HELPERS
 function $(regexp, state) {
-  var _state$_3;
-  const match = (_state$_3 = state._) === null || _state$_3 === void 0 ? void 0 : _state$_3.substring(state.i).match(regexp);
-  if (!match) return null;else {
-    state.i += match[0].length;
-    return match[0];
-  }
+    const match = state._?.substring(state.i).match(regexp);
+    if (!match)
+        return null;
+    else {
+        state.i += match[0].length;
+        return match[0];
+    }
 }
 function white(state) {
-  $(/^\s*/, state);
+    $(/^\s*/, state);
 }
-//# sourceMappingURL=parse-wkt.js.map