@loaders.gl/wms 3.3.0-alpha.8 → 3.3.0

package/src/lib/gml/deep-strict-equal.ts

@@ -0,0 +1,119 @@
+// https://github.com/nodejs/node/commit/c1d82ac2ff15594840e2a1b9531b506ae067ed27;
+
+// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
+//
+// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
+//
+// Originally from narwhal.js (http://narwhaljs.org)
+// Copyright (c) 2009 Thomas Robinson <280north.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the 'Software'), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+/** @todo replace this ridiculous choice of deepStrictEqual */
+// eslint-disable-next-line complexity
+export function deepStrictEqual(actual: unknown, expected: unknown, strict?: boolean) {
+  // 7.1. All identical values are equivalent, as determined by ===.
+  if (actual === expected) {
+    return true;
+    // } else if (actual instanceof Buffer && expected instanceof Buffer) {
+    //   return compare(actual, expected) === 0;
+
+    // // 7.2. If the expected value is a Date object, the actual value is
+    // // equivalent if it is also a Date object that refers to the same time.
+  } else if (actual instanceof Date && expected instanceof Date) {
+    return actual.getTime() === expected.getTime();
+
+    // 7.3 If the expected value is a RegExp object, the actual value is
+    // equivalent if it is also a RegExp object with the same source and
+    // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
+  } else if (actual instanceof RegExp && expected instanceof RegExp) {
+    return (
+      actual.source === expected.source &&
+      actual.global === expected.global &&
+      actual.multiline === expected.multiline &&
+      actual.lastIndex === expected.lastIndex &&
+      actual.ignoreCase === expected.ignoreCase
+    );
+
+    // 7.4. Other pairs that do not both pass typeof value == 'object',
+    // equivalence is determined by ==.
+  } else if (
+    (actual === null || typeof actual !== 'object') &&
+    (expected === null || typeof expected !== 'object')
+  ) {
+    // eslint-disable-next-line eqeqeq
+    return strict ? actual === expected : actual == expected;
+
+    // 7.5 For all other Object pairs, including Array objects, equivalence is
+    // determined by having the same number of owned properties (as verified
+    // with Object.prototype.hasOwnProperty.call), the same set of keys
+    // (although not necessarily the same order), equivalent values for every
+    // corresponding key, and an identical 'prototype' property. Note: this
+    // accounts for both named and indexed properties on Arrays.
+  }
+  return objEquiv(actual, expected, strict);
+}
+
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const pSlice = Array.prototype.slice;
+
+function isPrimitive(arg) {
+  return arg === null || (typeof arg !== 'object' && typeof arg !== 'function');
+}
+
+function isArguments(object) {
+  // eslint-disable-next-line eqeqeq
+  return Object.prototype.toString.call(object) == '[object Arguments]';
+}
+
+// eslint-disable-next-line complexity
+function objEquiv(a: unknown, b: unknown, strict) {
+  if (a === null || a === undefined || b === null || b === undefined) return false;
+  // if one is a primitive, the other must be same
+  if (isPrimitive(a) || isPrimitive(b)) return a === b;
+  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;
+  const aIsArgs = isArguments(a);
+  const bIsArgs = isArguments(b);
+  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) return false;
+  if (aIsArgs) {
+    a = pSlice.call(a);
+    b = pSlice.call(b);
+    return deepStrictEqual(a, b, strict);
+  }
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  let key;
+  let i;
+  // having the same number of owned properties (keys incorporates
+  // hasOwnProperty)
+  if (ka.length !== kb.length) return false;
+  // the same set of keys (although not necessarily the same order),
+  ka.sort();
+  kb.sort();
+  // ~~~cheap key test
+  for (i = ka.length - 1; i >= 0; i--) {
+    if (ka[i] !== kb[i]) return false;
+  }
+  // equivalent values for every corresponding key, and
+  // ~~~possibly expensive deep test
+  for (i = ka.length - 1; i >= 0; i--) {
+    key = ka[i];
+    if (!deepStrictEqual(a[key], b[key], strict)) return false;
+  }
+  return true;
+}

package/src/lib/gml/parse-gml.ts

@@ -0,0 +1,500 @@
+// loaders.gl, MIT license
+
+// Forked from https://github.com/derhuerst/parse-gml-polygon/blob/master/index.js
+// under ISC license
+
+/* eslint-disable no-continue, default-case */
+
+import type {
+  // GeoJSON,
+  // Feature,
+  // FeatureCollection,
+  Geometry,
+  Position
+  // GeoJsonProperties,
+  // Point,
+  // MultiPoint,
+  // LineString,
+  // MultiLineString,
+  // Polygon,
+  // MultiPolygon,
+  // GeometryCollection
+} from '@loaders.gl/schema';
+
+import {XMLLoader} from '@loaders.gl/xml';
+import {deepStrictEqual} from './deep-strict-equal';
+import rewind from '@turf/rewind';
+
+function noTransform(...coords) {
+  return coords;
+}
+
+export type ParseGMLOptions = {
+  transformCoords?: Function;
+  stride?: 2 | 3 | 4;
+};
+
+export type ParseGMLContext = {
+  srsDimension?: number;
+  [key: string]: any;
+};
+
+/**
+ * Parses a typed data structure from raw XML for GML features
+ * @note Error handlings is fairly weak
+ */
+export function parseGML(text: string, options) {
+  // GeoJSON | null {
+  const parsedXML = XMLLoader.parseTextSync(text, options);
+
+  options = {transformCoords: noTransform, stride: 2, ...options};
+  const context = createChildContext(parsedXML, options, {});
+
+  return parseGMLToGeometry(parsedXML, options, context);
+}
+
+/** Parse a GeoJSON geometry from GML XML */
+export function parseGMLToGeometry(
+  inputXML: any,
+  options: ParseGMLOptions,
+  context: ParseGMLContext
+): Geometry | null {
+  const childContext = createChildContext(inputXML, options, context);
+
+  let geometry: Geometry | null = null;
+
+  const [name, xml] = getFirstKeyValue(inputXML);
+
+  switch (name) {
+    // case 'gml:MultiPoint':
+    //   geometry = {
+    //     type: 'MultiPoint',
+    //     coordinates: parseMultiPoint(xml, options, childContext)
+    //   };
+    //   break;
+
+    case 'gml:LineString':
+      geometry = {
+        type: 'LineString',
+        coordinates: parseLinearRingOrLineString(xml, options, childContext)
+      };
+      break;
+
+      // case 'gml:MultiLineString':
+      //   geometry = {
+      //     type: 'MultiLineString',
+      //     coordinates: parseMultiLineString(xml, options, childContext)
+      //   };
+      //   break;
+
+    case 'gml:Polygon':
+    case 'gml:Rectangle':
+      geometry = {
+        type: 'Polygon',
+        coordinates: parsePolygonOrRectangle(xml, options, childContext)
+      };
+      break;
+    case 'gml:Surface':
+      geometry = {
+        type: 'MultiPolygon',
+        coordinates: parseSurface(xml, options, childContext)
+      };
+      break;
+    case 'gml:MultiSurface':
+      geometry = {
+        type: 'MultiPolygon',
+        coordinates: parseMultiSurface(xml, options, childContext)
+      };
+      break;
+
+    default:
+      return null;
+  }
+
+  // todo
+  return rewind(geometry, {mutate: true});
+}
+
+/** Parse a list of coordinates from a string */
+function parseCoords(s: string, options: ParseGMLOptions, context: ParseGMLContext): Position[] {
+  const stride = context.srsDimension || options.stride || 2;
+
+  // Handle white space
+  const coords = s.replace(/\s+/g, ' ').trim().split(' ');
+
+  if (coords.length === 0 || coords.length % stride !== 0) {
+    throw new Error(`invalid coordinates list (stride ${stride})`);
+  }
+
+  const points: Position[] = [];
+  for (let i = 0; i < coords.length - 1; i += stride) {
+    const point = coords.slice(i, i + stride).map(parseFloat);
+    points.push(options.transformCoords?.(...point) || point);
+  }
+
+  return points;
+}
+
+export function parsePosList(xml: any, options: ParseGMLOptions, context: ParseGMLContext) {
+  const childContext = createChildContext(xml, options, context);
+
+  const coords = textOf(xml);
+  if (!coords) {
+    throw new Error('invalid gml:posList element');
+  }
+
+  return parseCoords(coords, options, childContext);
+}
+
+export function parsePos(xml: any, options: ParseGMLOptions, context: ParseGMLContext): Position {
+  const childContext = createChildContext(xml, options, context);
+
+  const coords = textOf(xml);
+  if (!coords) {
+    throw new Error('invalid gml:pos element');
+  }
+
+  const points = parseCoords(coords, options, childContext);
+  if (points.length !== 1) {
+    throw new Error('gml:pos must have 1 point');
+  }
+  return points[0];
+}
+
+export function parsePoint(xml: any, options: ParseGMLOptions, context: ParseGMLContext): number[] {
+  const childContext = createChildContext(xml, options, context);
+
+  // TODO AV: Parse other gml:Point options
+  const pos = findIn(xml, 'gml:pos');
+  if (!pos) {
+    throw new Error('invalid gml:Point element, expected a gml:pos subelement');
+  }
+  return parsePos(pos, options, childContext);
+}
+
+export function parseLinearRingOrLineString(
+  xml: any,
+  options: ParseGMLOptions,
+  context: ParseGMLContext
+): Position[] {
+  // or a LineStringSegment
+  const childContext = createChildContext(xml, options, context);
+
+  let points: Position[] = [];
+
+  const posList = findIn(xml, 'gml:posList');
+  if (posList) {
+    points = parsePosList(posList, options, childContext);
+  } else {
+    for (const [childName, childXML] of Object.entries(xml)) {
+      switch (childName) {
+        case 'gml:Point':
+          points.push(parsePoint(childXML, options, childContext));
+          break;
+        case 'gml:pos':
+          points.push(parsePos(childXML, options, childContext));
+          break;
+        default:
+          continue;
+      }
+    }
+  }
+
+  if (points.length === 0) {
+    throw new Error(`${xml.name} must have > 0 points`);
+  }
+  return points;
+}
+
+export function parseCurveSegments(
+  xml: any,
+  options: ParseGMLOptions,
+  context: ParseGMLContext
+): Position[] {
+  const points: Position[] = [];
+
+  for (const [childName, childXML] of Object.entries(xml)) {
+    switch (childName) {
+      case 'gml:LineStringSegment':
+        const points2 = parseLinearRingOrLineString(childXML, options, context);
+
+        // remove overlapping
+        const end = points[points.length - 1];
+        const start = points2[0];
+        if (end && start && deepStrictEqual(end, start)) {
+          points2.shift();
+        }
+
+        points.push(...points2);
+        break;
+      default:
+        continue;
+    }
+  }
+
+  if (points.length === 0) {
+    throw new Error('gml:Curve > gml:segments must have > 0 points');
+  }
+  return points;
+}
+
+export function parseRing(
+  xml: any,
+  options: ParseGMLOptions,
+  context: ParseGMLContext
+): Position[] {
+  const childContext = createChildContext(xml, options, context);
+
+  const points: Position[] = [];
+
+  for (const [childName, childXML] of Object.entries(xml)) {
+    switch (childName) {
+      case 'gml:curveMember':
+        let points2;
+
+        const lineString = findIn(childXML, 'gml:LineString');
+        if (lineString) {
+          points2 = parseLinearRingOrLineString(lineString, options, childContext);
+        } else {
+          const segments = findIn(childXML, 'gml:Curve', 'gml:segments');
+          if (!segments) {
+            throw new Error(`invalid ${childName} element`);
+          }
+
+          points2 = parseCurveSegments(segments, options, childContext);
+        }
+
+        // remove overlapping
+        const end = points[points.length - 1];
+        const start = points2[0];
+        if (end && start && deepStrictEqual(end, start)) {
+          points2.shift();
+        }
+
+        points.push(...points2);
+
+        break;
+    }
+  }
+
+  if (points.length < 4) {
+    throw new Error(`${xml.name} must have >= 4 points`);
+  }
+  return points;
+}
+
+export function parseExteriorOrInterior(
+  xml: any,
+  options: ParseGMLOptions,
+  context: ParseGMLContext
+): Position[] {
+  const linearRing = findIn(xml, 'gml:LinearRing');
+  if (linearRing) {
+    return parseLinearRingOrLineString(linearRing, options, context);
+  }
+
+  const ring = findIn(xml, 'gml:Ring');
+  if (!ring) {
+    throw new Error(`invalid ${xml.name} element`);
+  }
+
+  return parseRing(ring, options, context);
+}
+
+export function parsePolygonOrRectangle(
+  xml: any,
+  options: ParseGMLOptions,
+  context: ParseGMLContext
+): Position[][] {
+  // or PolygonPatch
+  const childContext = createChildContext(xml, options, context);
+
+  const exterior = findIn(xml, 'gml:exterior');
+  if (!exterior) {
+    throw new Error(`invalid ${xml.name} element`);
+  }
+
+  const pointLists: Position[][] = [parseExteriorOrInterior(exterior, options, childContext)];
+
+  for (const [childName, childXML] of Object.entries(xml)) {
+    switch (childName) {
+      case 'gml:interior':
+        pointLists.push(parseExteriorOrInterior(childXML, options, childContext));
+        break;
+    }
+  }
+
+  return pointLists;
+}
+
+export function parseSurface(
+  xml: any,
+  options: ParseGMLOptions,
+  context: ParseGMLContext
+): Position[][][] {
+  const childContext = createChildContext(xml, options, context);
+
+  const patches = findIn(xml, 'gml:patches');
+  if (!patches) {
+    throw new Error(`invalid ${xml.name} element`);
+  }
+
+  const polygons: Position[][][] = [];
+  for (const [childName, childXML] of Object.entries(xml)) {
+    switch (childName) {
+      case 'gml:PolygonPatch':
+      case 'gml:Rectangle':
+        polygons.push(parsePolygonOrRectangle(childXML, options, childContext));
+        break;
+
+      default:
+        continue;
+    }
+  }
+
+  if (polygons.length === 0) {
+    throw new Error(`${xml.name} must have > 0 polygons`);
+  }
+
+  return polygons;
+}
+
+export function parseCompositeSurface(
+  xml: any,
+  options: ParseGMLOptions,
+  context: ParseGMLContext
+): Position[][][] {
+  const childContext = createChildContext(xml, options, context);
+
+  const polygons: Position[][][] = [];
+  for (const [childName, childXML] of Object.entries(xml)) {
+    switch (childName) {
+      case 'gml:surfaceMember':
+      case 'gml:surfaceMembers':
+        const [c2Name, c2Xml] = getFirstKeyValue(childXML);
+        switch (c2Name) {
+          case 'gml:Surface':
+            polygons.push(...parseSurface(c2Xml, options, childContext));
+            break;
+          case 'gml:Polygon':
+            polygons.push(parsePolygonOrRectangle(c2Xml, options, childContext));
+            break;
+        }
+        break;
+    }
+  }
+
+  if (polygons.length === 0) {
+    throw new Error(`${xml.name} must have > 0 polygons`);
+  }
+  return polygons;
+}
+
+export function parseMultiSurface(
+  xml: any,
+  options: ParseGMLOptions,
+  context: ParseGMLContext
+): Position[][][] {
+  let el = xml;
+
+  const surfaceMembers = findIn(xml, 'gml:LinearRing');
+  if (surfaceMembers) {
+    el = surfaceMembers;
+  }
+
+  const polygons: Position[][][] = [];
+  for (const [childName, childXML] of Object.entries(el)) {
+    switch (childName) {
+      case 'gml:Surface':
+        const polygons2 = parseSurface(childXML, options, context);
+        polygons.push(...polygons2);
+        break;
+      case 'gml:surfaceMember':
+        const polygons3 = parseSurfaceMember(childXML, options, context);
+        polygons.push(...polygons3);
+        break;
+
+      case 'gml:surfaceMembers':
+        const polygonXML = findIn(childXML, 'gml:Polygon');
+        for (const surfaceMemberXML of polygonXML as []) {
+          const polygons3 = parseSurfaceMember(surfaceMemberXML, options, context);
+          polygons.push(...polygons3);
+        }
+        break;
+    }
+  }
+
+  if (polygons.length === 0) {
+    throw new Error(`${xml.name} must have > 0 polygons`);
+  }
+
+  return polygons;
+}
+
+function parseSurfaceMember(
+  xml: any,
+  options: ParseGMLOptions,
+  context: ParseGMLContext
+): Position[][][] {
+  const [childName, childXml] = getFirstKeyValue(xml);
+  switch (childName) {
+    case 'gml:CompositeSurface':
+      return parseCompositeSurface(childXml, options, context);
+    case 'gml:Surface':
+      return parseSurface(childXml, options, context);
+    case 'gml:Polygon':
+      return [parsePolygonOrRectangle(childXml, options, context)];
+  }
+  throw new Error(`${childName} must have polygons`);
+}
+
+// Helpers
+
+function textOf(el: any): string {
+  if (typeof el !== 'string') {
+    throw new Error('expected string');
+  }
+  return el;
+}
+
+function findIn(root: any, ...tags: string[]): any {
+  let el = root;
+  for (const tag of tags) {
+    const child = el[tag];
+    if (!child) {
+      return null;
+    }
+    el = child;
+  }
+  return el;
+}
+
+/** @returns the first [key, value] pair in an object, or ['', null] if empty object */
+function getFirstKeyValue(object: any): [string, any] {
+  if (object && typeof object === 'object') {
+    for (const [key, value] of Object.entries(object)) {
+      return [key, value];
+    }
+  }
+  return ['', null];
+}
+
+/** A bit heavyweight for just tracking dimension? */
+function createChildContext(xml, options, context): ParseGMLContext {
+  const srsDimensionAttribute = xml.attributes && xml.attributes.srsDimension;
+
+  if (srsDimensionAttribute) {
+    const srsDimension = parseInt(srsDimensionAttribute);
+    if (Number.isNaN(srsDimension) || srsDimension <= 0) {
+      throw new Error(
+        `invalid srsDimension attribute value "${srsDimensionAttribute}", expected a positive integer`
+      );
+    }
+
+    const childContext = Object.create(context);
+    childContext.srsDimension = srsDimension;
+    return childContext;
+  }
+
+  return context;
+}

package/src/lib/lerc/lerc-types.ts

@@ -0,0 +1,43 @@
+// loaders.gl, MIT license
+
+/** Data returned by LERC loader */
+export type LERCData = {
+  /**	Width of decoded image */
+  width: number;
+  /**	Height of decoded image */
+  height: number;
+  /**	The type of pixels represented in the output */
+  pixelType: LercPixelType;
+  /**	[statistics_band1, statistics_band2, …] Each element is a statistics object representing min and max values  */
+  statistics: BandStats[];
+  /**	[band1, band2, …] Each band is a typed array of width * height * depthCount */
+  pixels: TypedArray[];
+  /**	Typed array with a size of width*height, or null if all pixels are valid */
+  mask: Uint8Array;
+  /**	Depth count  */
+  depthCount: number;
+  /**	array	[band1_mask, band2_mask, …] Each band is a Uint8Array of width * height * depthCount */
+  bandMasks?: Uint8Array[];
+};
+
+export type LercPixelType = 'S8' | 'U8' | 'S16' | 'U16' | 'S32' | 'U32' | 'F32' | 'F64';
+
+export interface BandStats {
+  minValue: number;
+  maxValue: number;
+  depthStats?: {
+    minValues: Float64Array;
+    maxValues: Float64Array;
+  };
+}
+
+export type TypedArray =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array;

package/src/lib/wcs/parse-wcs.ts

@@ -0,0 +1,39 @@
+// loaders.gl, MIT license
+
+import type {WFSCapabilities} from './wcs-types';
+
+import {XMLLoader} from '@loaders.gl/xml';
+
+// GetCapabilities
+
+/**
+ * Parses a typed data structure from raw XML for `GetCapabilities` response
+ * @note Error handlings is fairly weak
+ */
+export function parseWFSCapabilities(text: string, options): WFSCapabilities {
+  // Remove namespaces in XML
+  options = {...options, xml: {...options?.xml, removeNSPrefix: true}};
+  const parsedXML = XMLLoader.parseTextSync(text, options);
+  const xmlCapabilities: any = parsedXML.Capabilities || parsedXML;
+  return uncapitalizeKeys(xmlCapabilities);
+}
+
+function uncapitalizeKeys(object: any): any {
+  if (object && typeof object === 'object') {
+    const newObject = {};
+    for (const [key, value] of Object.entries(object)) {
+      newObject[uncapitalize(key)] = uncapitalizeKeys(value);
+    }
+    return newObject;
+  }
+  return object;
+}
+
+/**
+ * Uncapitalize first letter of a string
+ * @param {string} str
+ * @returns {string}
+ */
+function uncapitalize(str: string): string {
+  return typeof str === 'string' ? str.charAt(0).toLowerCase() + str.slice(1) : str;
+}