@loaders.gl/wkt 4.0.0-alpha.9 → 4.0.0-beta.1

package/src/lib/parse-wkt.ts

@@ -1,5 +1,8 @@
+// loaders.gl, MIT license
 // Fork of https://github.com/mapbox/wellknown under ISC license (MIT/BSD-2-clause equivalent)
 
+import {Geometry} from '@loaders.gl/schema';
+
 /* eslint-disable */
 // @ts-nocheck
 
@@ -7,216 +10,314 @@ 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('
+  // We only support this "geojson" subset of the OGC simple features standard
+];
+
+export type ParseWKTOptions = {
+  wkt?: {
+    /** Whether to add any CRS, if found, as undocumented CRS property on the return geometry */
+    crs?: boolean;
+  };
+};
+
+/** 
+ * 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: string): boolean {
+  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
  *
- * @param {string} _ A WKT geometry
- * @return {?Object} A GeoJSON geometry object
+ * @note We only support the "geojson" subset of the OGC simple features standard
  **/
-export default function parseWKT(input) {
+export function parseWKT(input: string, options?: ParseWKTOptions): Geometry {
+  // TODO handle options.wkt.shape
+  return parseWKTToGeometry(input, options)!;
+}
+
+/** State of parser, passed around between parser functions */
+type ParseWKTState = {
+  parts: string[];
+  _: string | undefined;
+  i: number;
+};
+
+/** Parse into GeoJSON geometry */
+function parseWKTToGeometry(input: string, options?: ParseWKTOptions): Geometry | null {
   const parts = input.split(';');
   let _ = parts.pop();
   const srid = (parts.shift() || '').split('=').pop();
 
-  let i = 0;
-
-  function $(re) {
-    const match = _.substring(i).match(re);
-    if (!match) return null;
-    else {
-      i += match[0].length;
-      return match[0];
-    }
-  }
+  const state: ParseWKTState = {parts, _, i: 0};
 
-  function crs(obj) {
-    if (obj && srid.match(/\d+/)) {
-      obj.crs = {
-        type: 'name',
-        properties: {
-          name: 'urn:ogc:def:crs:EPSG::' + srid
-        }
-      };
-    }
+  const geometry = parseGeometry(state);
 
-    return obj;
-  }
-
-  function white() {
-    $(/^\s*/);
-  }
-
-  function multicoords() {
-    white();
-    let depth = 0;
-    const rings = [];
-    const stack = [rings];
-    let pointer = rings;
-    let elem;
-
-    while ((elem = $(/^(\()/) || $(/^(\))/) || $(/^(,)/) || $(tuples))) {
-      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();
-    }
+  return options?.wkt?.crs ? addCRS(geometry, srid) : geometry;
+}
 
-    if (depth !== 0) return null;
+function parseGeometry(state: ParseWKTState): Geometry | null {
+  return (
+    parsePoint(state) ||
+    parseLineString(state) ||
+    parsePolygon(state) ||
+    parseMultiPoint(state) ||
+    parseMultiLineString(state) ||
+    parseMultiPolygon(state) ||
+    parseGeometryCollection(state)
+  );
+}
 
-    return rings;
+/** Adds a coordinate reference system as an undocumented  */
+function addCRS(obj: Geometry | null, srid?: string): Geometry | null {
+  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;
   }
 
-  function coords() {
-    const list = [];
-    let item;
-    let pt;
-    while ((pt = $(tuples) || $(/^(,)/))) {
-      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();
-    }
+  return obj;
+}
 
-    if (item) list.push(item);
-    else return null;
+// GEOMETRIES
 
-    return list.length ? list : null;
+function parsePoint(state: ParseWKTState): Geometry | null {
+  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 point() {
-    if (!$(/^(point(\sz)?)/i)) return null;
-    white();
-    if (!$(/^(\()/)) return null;
-    const c = coords();
-    if (!c) return null;
-    white();
-    if (!$(/^(\))/)) return null;
-    return {
-      type: 'Point',
-      coordinates: c[0]
-    };
+function parseMultiPoint(state: ParseWKTState): Geometry | null {
+  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 multipoint() {
-    if (!$(/^(multipoint)/i)) return null;
-    white();
-    const newCoordsFormat = _.substring(_.indexOf('(') + 1, _.length - 1)
-      .replace(/\(/g, '')
-      .replace(/\)/g, '');
-    _ = 'MULTIPOINT (' + newCoordsFormat + ')';
-    const c = multicoords();
-    if (!c) return null;
-    white();
-    return {
-      type: 'MultiPoint',
-      coordinates: c
-    };
+function parseLineString(state: ParseWKTState): Geometry | null {
+  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 multilinestring() {
-    if (!$(/^(multilinestring)/i)) return null;
-    white();
-    const c = multicoords();
-    if (!c) return null;
-    white();
-    return {
-      type: 'MultiLineString',
-      coordinates: c
-    };
+function parseMultiLineString(state: ParseWKTState): Geometry | null {
+  if (!$(/^(MULTILINESTRING)/i, state)) return null;
+  white(state);
+  const c = multicoords(state);
+  if (!c) {
+    return null;
   }
+  white(state);
+  return {
+    type: 'MultiLineString',
+    // @ts-expect-error
+    coordinates: c
+  };
+}
 
-  function linestring() {
-    if (!$(/^(linestring(\sz)?)/i)) return null;
-    white();
-    if (!$(/^(\()/)) return null;
-    const c = coords();
-    if (!c) return null;
-    if (!$(/^(\))/)) return null;
-    return {
-      type: 'LineString',
-      coordinates: c
-    };
+function parsePolygon(state: ParseWKTState): Geometry | null {
+  if (!$(/^(POLYGON(\sz)?)/i, state)) {
+    return null;
   }
+  white(state);
+  const c = multicoords(state);
+  if (!c) {
+    return null;
+  }
+  return {
+    type: 'Polygon',
+    // @ts-expect-error
+    coordinates: c
+  };
+}
 
-  function polygon() {
-    if (!$(/^(polygon(\sz)?)/i)) return null;
-    white();
-    const c = multicoords();
-    if (!c) return null;
-    return {
-      type: 'Polygon',
-      coordinates: c
-    };
+function parseMultiPolygon(state: ParseWKTState): Geometry | null {
+  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 multipolygon() {
-    if (!$(/^(multipolygon)/i)) return null;
-    white();
-    const c = multicoords();
-    if (!c) return null;
-    return {
-      type: 'MultiPolygon',
-      coordinates: c
-    };
+function parseGeometryCollection(state: ParseWKTState): Geometry | null {
+  const geometries: Geometry[] = [];
+  let geometry: Geometry | null;
+
+  if (!$(/^(GEOMETRYCOLLECTION)/i, state)) {
+    return null;
   }
+  white(state);
 
-  function geometrycollection() {
-    const geometries = [];
-    let geometry;
+  if (!$(/^(\()/, state)) {
+    return null;
+  }
+  while ((geometry = parseGeometry(state))) {
+    geometries.push(geometry);
+    white(state);
+    $(/^(,)/, state);
+    white(state);
+  }
+  if (!$(/^(\))/, state)) {
+    return null;
+  }
 
-    if (!$(/^(geometrycollection)/i)) return null;
-    white();
+  return {
+    type: 'GeometryCollection',
+    geometries: geometries
+  };
+}
+
+// COORDINATES
+
+function multicoords(state: ParseWKTState): number[][] | null {
+  white(state);
+  let depth = 0;
+  const rings: number[][] = [];
+  const stack = [rings];
+  let pointer: any = 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;
 
-    if (!$(/^(\()/)) return null;
-    while ((geometry = root())) {
-      geometries.push(geometry);
-      white();
-      $(/^(,)/);
-      white();
+      // @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;
     }
-    if (!$(/^(\))/)) return null;
+    white(state);
+  }
 
-    return {
-      type: 'GeometryCollection',
-      geometries: geometries
-    };
+  if (depth !== 0) return null;
+
+  return rings;
+}
+
+function coords(state: ParseWKTState): number[][] | null {
+  const list: number[][] = [];
+  let item: any;
+  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);
   }
 
-  function root() {
-    return (
-      point() ||
-      linestring() ||
-      polygon() ||
-      multipoint() ||
-      multilinestring() ||
-      multipolygon() ||
-      geometrycollection()
-    );
+  if (item) list.push(item);
+  else return null;
+
+  return list.length ? list : null;
+}
+
+// HELPERS
+
+function $(regexp: RegExp, state: ParseWKTState) {
+  const match = state._?.substring(state.i).match(regexp);
+  if (!match) return null;
+  else {
+    state.i += match[0].length;
+    return match[0];
   }
+}
 
-  return crs(root());
+function white(state: ParseWKTState) {
+  $(/^\s*/, state);
 }

package/src/lib/utils/base64-encoder.ts

@@ -0,0 +1,153 @@
+/* 
+const binary_to_b64_map = [
+  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
+  'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
+  'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a',
+  'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
+  'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
+  't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1',
+  '2', '3', '4', '5', '6', '7', '8', '9', '+',
+  '/', '='
+];
+const b64_to_binary_map = {
+  '0': 52, '1': 53, '2': 54, '3': 55, '4': 56, '5': 57, '6': 58, '7': 59, '8': 60, '9': 61,
+  A: 0, B: 1, C: 2, D: 3, E: 4, F: 5, G: 6, H: 7, I: 8, J: 9, K: 10, L: 11, M: 12, N: 13, O: 14,
+  P: 15, Q: 16, R: 17, S: 18, T: 19, U: 20, V: 21, W: 22, X: 23, Y: 24, Z: 25, a: 26, b: 27,
+  c: 28, d: 29, e: 30, f: 31, g: 32, h: 33, i: 34, j: 35, k: 36, l: 37, m: 38, n: 39, o: 40,
+  p: 41, q: 42, r: 43, s: 44, t: 45, u: 46, v: 47, w: 48, x: 49, y: 50, z: 51, '+': 62, '/': 63,
+  '=': 64
+};
+
+*/
+
+export class Base64Encoder {
+  getDecodedLength(array: Uint8Array): number {
+    return Math.ceil(array.byteLength / 4) * 3;
+  }
+
+  decode(array: Uint8Array, target?: ArrayBuffer) {} // eslint-disable-line
+}
+
+/*
+
+//generates an array iterator that returns 3 elements at a time. Use to loop through the Uint8Array Array Buffer
+// to be converted to Base64.  (binary array buffer) 8bits * 3 = 6bits * 4 (base64 representation)
+const generateTripleIterator = (arr) => {
+  return {
+      *[Symbol.iterator]() {
+          for(let n = 0; n < arr.length; n+=3) {
+              let result = [];
+              result.push(arr[n]);
+
+              if(n+1 < arr.length)
+                  result.push(arr[n+1]);
+              if(n+2 < arr.length)
+                  result.push(arr[n+2]);
+
+              yield result;
+          }
+      }
+  };
+};
+
+//generates an array iterator that returns 4 elements at a time.  Use to loop through
+// Base64 string because Base64 string is multiples of 4 characters.
+const generateQuadrupleIterator = (arr) => {
+  return {
+      *[Symbol.iterator]() {
+          for(let n = 0; n < arr.length; n+=4) {
+              yield [...arr.slice(n, n+4)];
+          }
+      }
+  };
+};
+
+// Converts a triple of 8 bits into a quadruple of 6 bits.  use to convert binary to base64 representation
+const tripleConvert = (first, second, third) => {
+  let [] = triple;
+  let binary = null, a = null, b = null, c = null, d = null;
+  if (triple.length === 1) {
+      binary = (first << 4);
+      a = ((binary & 4032) >>> 6);
+      b = (binary & 63);
+      c = 64;
+      d = 64;
+  } else if (triple.length === 2) {
+      binary = ((first << 10) | (second << 2));
+      a = ((binary & 258048) >>> 12);
+      b = ((binary & 4032) >>> 6);
+      c = (binary & 63);
+      d = 64;
+  } else {
+      binary = ((first << 16) | (second << 8) | third);
+      a = ((binary & 16515072) >>> 18);
+      b = ((binary & 258048) >>> 12);
+      c = ((binary & 4032) >>> 6);
+      d = (binary & 63);
+  }
+
+  return [a, b, c, d];
+};
+
+// Converts a quadruple of 6 bits into a triple of 8 bits.  use to convert base64 representation into binary
+const quadrupleConvert = (quadruple) => {
+  let [a, b, c, d] = quadruple;
+  let binary = null, first = null, second = null, third = null;
+
+  if(c === 64 && d === 64) {
+      //two padding
+      binary = ((a << 6) | b);
+      first = (binary >> 4);   //shift off 4 bits, 2 bits per padding
+  } else if(d === 64) {
+      //one padding
+      binary = ((a << 12) | (b << 6) | c );
+      binary = (binary >> 2); //shift off 2 bits
+      first = binary >> 8;
+      second = ((binary << 24) >>> 24);
+  } else {
+      //no padding
+      binary = ((a << 18) | (b << 12) | (c << 6) | d );
+      first = (binary >>> 16);
+      second = ((binary << 16) >>> 24);
+      third = ((binary << 24) >>> 24);
+  }
+
+  return [first, second, third];
+};
+
+// Convert 8Bits Array Buffer to Base64 string
+export const ab2b64 = (buffer) => {
+  const b64strArray = [];
+  const view = new Uint8Array(buffer);
+  let iterator = generateTripleIterator(view);
+  for(let triple of iterator) {
+      b64strArray.push(...tripleConvert(triple));
+  }
+  return b64strArray.map(b64CharCodePoint => binary_to_b64_map[b64CharCodePoint]).join("");
+};
+
+// Convert Base64 String to 8Bits Array Buffer
+export const b642ab = (b64str) => {
+  let buffer_length = (b64str.length / 4) * 3;
+  if(b64str.slice(-2) === '==') {
+      buffer_length -= 2;
+  } else if(b64str.slice(-1) === '=') {
+      buffer_length -= 1;
+  }
+
+  let buffer = new ArrayBuffer(buffer_length);
+  const view = new Uint8Array(buffer);
+  let iterator = generateQuadrupleIterator(b64str.split("").map(b64char => b64_to_binary_map[b64char]));
+  let byteIndex = 0;
+  for(let quadruple of iterator) {
+      quadrupleConvert(quadruple).forEach(byte => {
+          if(byte != null) {
+              view[byteIndex] = byte;
+              byteIndex++;
+          }
+      });
+  }
+  return buffer;
+};
+
+*/