@loaders.gl/wms 3.3.0-alpha.12 → 3.3.0-alpha.13

package/src/lib/data-sources/wms-service.ts

@@ -2,36 +2,38 @@
 
 /* eslint-disable camelcase */
 
-import type {WMSCapabilities, WMSFeatureInfo, WMSLayerDescription} from '@loaders.gl/wms';
-import {
-  WMSCapabilitiesLoader,
-  WMSFeatureInfoLoader,
-  WMSLayerDescriptionLoader,
-  WMSErrorLoader
-} from '@loaders.gl/wms';
-import {ImageLoader, ImageType} from '@loaders.gl/images';
+import type {ImageType} from '@loaders.gl/images';
+import {ImageLoader} from '@loaders.gl/images';
 import {LoaderOptions} from '@loaders.gl/loader-utils';
 
+import type {ImageSourceMetadata, GetImageParameters} from './image-source';
+import {ImageSource} from './image-source';
+
+import type {WMSCapabilities, WMSFeatureInfo, WMSLayerDescription} from '../wms/wms-types';
+import {WMSCapabilitiesLoader} from '../../wms-capabilities-loader';
+import {WMSFeatureInfoLoader} from '../../wip/wms-feature-info-loader';
+import {WMSLayerDescriptionLoader} from '../../wip/wms-layer-description-loader';
+import {WMSErrorLoader} from '../../wms-error-loader';
+
 type FetchLike = (url: string, options?: RequestInit) => Promise<Response>;
 
-export type WMSGetCapabilitiesParameters = {
+type WMSCommonParameters = {
   /** In case the endpoint supports multiple services */
   service?: 'WMS';
   /** In case the endpoint supports multiple WMS versions */
   version?: '1.1.1' | '1.3.0';
+};
+
+export type WMSGetCapabilitiesParameters = WMSCommonParameters & {
   /** Request type */
   request?: 'GetCapabilities';
 };
 
-export type WMSGetMapParameters = {
-  /** In case the endpoint supports multiple services */
-  service?: 'WMS';
-  /** In case the endpoint supports multiple WMS versions */
-  version?: '1.1.1' | '1.3.0';
+export type WMSGetMapParameters = WMSCommonParameters & {
   /** Request type */
   request?: 'GetMap';
   /** Layers to render */
-  layers: string[];
+  layers: string | string[];
   /** Styling */
   styles?: unknown;
   /** bounding box of the requested map image */
@@ -47,11 +49,7 @@ export type WMSGetMapParameters = {
 };
 
 // https://imagery.pasda.psu.edu/arcgis/services/pasda/UrbanTreeCanopy_Landcover/MapServer/WmsServer?SERVICE=WMS&
-export type WMSGetFeatureInfoParameters = {
-  /** In case the endpoint supports multiple services */
-  service?: 'WMS';
-  /** In case the endpoint supports multiple WMS versions */
-  version?: '1.1.1' | '1.3.0';
+export type WMSGetFeatureInfoParameters = WMSCommonParameters & {
   /** Request type */
   request?: 'GetFeatureInfo';
 
@@ -62,7 +60,7 @@ export type WMSGetFeatureInfoParameters = {
   /** list of layers to query (could be different from rendered layers) */
   query_layers: string[];
   /** MIME type of returned feature info */
-  info_format: 'text/plain';
+  info_format?: 'text/plain';
 
   /** Layers to render */
   layers: string[];
@@ -80,234 +78,270 @@ export type WMSGetFeatureInfoParameters = {
   format?: 'image/png';
 };
 
-export type WMSDescribeLayerParameters = {
-  /** In case the endpoint supports multiple services */
-  service?: 'WMS';
-  /** In case the endpoint supports multiple WMS versions */
-  version?: '1.1.1' | '1.3.0';
+export type WMSDescribeLayerParameters = WMSCommonParameters & {
   /** Request type */
   request?: 'DescribeLayer';
 };
 
-export type WMSGetLegendGraphicParameters = {
-  /** In case the endpoint supports multiple services */
-  service?: 'WMS';
-  /** In case the endpoint supports multiple WMS versions */
-  version?: '1.1.1' | '1.3.0';
+export type WMSGetLegendGraphicParameters = WMSCommonParameters & {
   /** Request type */
   request?: 'GetLegendGraphic';
 };
 
-const WMS_GET_CAPABILITIES_DEFAULT_PARAMETERS: Required<WMSGetCapabilitiesParameters> = {
-  service: 'WMS',
-  version: '1.1.1',
-  request: 'GetCapabilities'
-};
-
-const WMS_GET_MAP_DEFAULT_PARAMETERS: Required<WMSGetMapParameters> = {
-  service: 'WMS',
-  version: '1.1.1',
-  request: 'GetMap',
-  layers: [],
-  styles: undefined,
-  bbox: [-77.87304, 40.78975, -77.85828, 40.80228],
-  width: 1200,
-  height: 900,
-  srs: 'EPSG:4326',
-  format: 'image/png'
-};
-
-const WMS_GET_FEATURE_INFO_DEFAULT_PARAMETERS: Required<WMSGetFeatureInfoParameters> = {
-  service: 'WMS',
-  version: '1.1.1',
-  request: 'GetFeatureInfo',
-  layers: [],
-  styles: undefined,
-  bbox: [-77.87304, 40.78975, -77.85828, 40.80228],
-  width: 1200,
-  height: 900,
-  srs: 'EPSG:4326',
-  format: 'image/png',
-
-  x: undefined!,
-  y: undefined!,
-  query_layers: [],
-  info_format: 'text/plain'
-};
-
-const WMS_DESCRIBE_LAYER_DEFAULT_PARAMETERS: Required<WMSDescribeLayerParameters> = {
-  service: 'WMS',
-  version: '1.1.1',
-  request: 'DescribeLayer'
-};
-
-const WMS_GET_LEGEND_GRAPHIC_DEFAULT_PARAMETERS: Required<WMSGetLegendGraphicParameters> = {
-  service: 'WMS',
-  version: '1.1.1',
-  request: 'GetLegendGraphic'
-};
-
+/** Properties that can be specified when creating a new WMS service */
 export type WMSServiceProps = {
-  url: string;
+  /** Base URL to the service */
+  serviceUrl: string;
+  /** Any load options to the loaders.gl Loaders used by the WMSService methods */
   loadOptions?: LoaderOptions;
+  /** Override the fetch function if required */
   fetch?: typeof fetch | FetchLike;
 };
 
-export class WMSService {
-  url: string;
-  loadOptions: LoaderOptions;
+/**
+ * The WMSService class provides
+ * - provides type safe methods to form URLs to a WMS service
+ * - provides type safe methods to query and parse results (and errors) from a WMS service
+ * - implements the ImageService interface
+ * @note Only the URL parameter conversion is supported. XML posts are not supported.
+ */
+export class WMSService extends ImageSource {
+  serviceUrl: string;
+  loadOptions: LoaderOptions = {
+    // We want error responses to throw exceptions, the WMSErrorLoader can do this
+    wms: {throwOnError: true}
+  };
   fetch: typeof fetch | FetchLike;
 
+  /** A list of loaders used by the WMSService methods */
+  readonly loaders = [
+    ImageLoader,
+    WMSErrorLoader,
+    WMSCapabilitiesLoader,
+    WMSFeatureInfoLoader,
+    WMSLayerDescriptionLoader
+  ];
+
+  /** Create a WMSService */
   constructor(props: WMSServiceProps) {
-    this.url = props.url;
-    this.loadOptions = props.loadOptions || {};
+    super();
+    this.serviceUrl = props.serviceUrl;
+    // TODO Need an options merge function from loaders.gl to merge subobjects
+    Object.assign(this.loadOptions, props.loadOptions);
     this.fetch = props.fetch || fetch;
   }
 
-  // Typed URL creators
-
-  getCapabilitiesURL(
-    parameters?: WMSGetCapabilitiesParameters,
-    extra?: Record<string, unknown>
-  ): string {
-    const options: Required<WMSGetCapabilitiesParameters> = {
-      ...WMS_GET_CAPABILITIES_DEFAULT_PARAMETERS,
-      ...parameters,
-      ...extra
-    };
-    return this.getWMSUrl(options, extra);
-  }
-
-  getMapURL(parameters: WMSGetMapParameters, extra?: Record<string, unknown>): string {
-    const options: Required<WMSGetMapParameters> = {
-      ...WMS_GET_MAP_DEFAULT_PARAMETERS,
-      ...parameters,
-      ...extra
-    };
-    return this.getWMSUrl(options, extra);
-  }
-
-  getFeatureInfoURL(
-    parameters: WMSGetFeatureInfoParameters,
-    extra?: Record<string, unknown>
-  ): string {
-    const options: Required<WMSGetFeatureInfoParameters> = {
-      ...WMS_GET_FEATURE_INFO_DEFAULT_PARAMETERS,
-      ...parameters,
-      ...extra
-    };
-    return this.getWMSUrl(options, extra);
-  }
-
-  describeLayerURL(
-    parameters: WMSDescribeLayerParameters,
-    extra?: Record<string, unknown>
-  ): string {
-    const options: Required<WMSDescribeLayerParameters> = {
-      ...WMS_DESCRIBE_LAYER_DEFAULT_PARAMETERS,
-      ...parameters,
-      ...extra
-    };
-    return this.getWMSUrl(options, extra);
+  // ImageSource implementation
+  getMetadata(): Promise<ImageSourceMetadata> {
+    return this.getCapabilities();
   }
 
-  getLegendGraphicURL(
-    parameters: WMSGetLegendGraphicParameters,
-    extra?: Record<string, unknown>
-  ): string {
-    const options: Required<WMSGetLegendGraphicParameters> = {
-      ...WMS_GET_LEGEND_GRAPHIC_DEFAULT_PARAMETERS,
-      ...parameters,
-      ...extra
-    };
-    return this.getWMSUrl(options, extra);
+  getImage(parameters: GetImageParameters): Promise<ImageType> {
+    return this.getMap(parameters);
   }
 
   // WMS Service API Stubs
 
   /** Get Capabilities */
   async getCapabilities(
-    parameters?: WMSGetCapabilitiesParameters,
-    extra?: Record<string, unknown>
+    wmsParameters?: WMSGetCapabilitiesParameters,
+    vendorParameters?: Record<string, unknown>
   ): Promise<WMSCapabilities> {
-    const url = this.getCapabilitiesURL(parameters, extra);
-    const response = await this.fetch(url, this.loadOptions);
-    await this.checkResponse(response);
+    const url = this.getCapabilitiesURL(wmsParameters, vendorParameters);
+    const {fetch} = this;
+    const response = await fetch(url, this.loadOptions);
     const arrayBuffer = await response.arrayBuffer();
+    this._checkResponse(response, arrayBuffer);
     return await WMSCapabilitiesLoader.parse(arrayBuffer, this.loadOptions);
   }
 
   /** Get a map image */
-  async getMap(options: WMSGetMapParameters, extra?: Record<string, unknown>): Promise<ImageType> {
-    const url = this.getMapURL(options, extra);
-    const response = await this.fetch(url, this.loadOptions);
-    await this.checkResponse(response);
+  async getMap(
+    options: WMSGetMapParameters,
+    vendorParameters?: Record<string, unknown>
+  ): Promise<ImageType> {
+    const url = this.getMapURL(options, vendorParameters);
+    const {fetch} = this;
+    const response = await fetch(url, this.loadOptions);
     const arrayBuffer = await response.arrayBuffer();
-    return await ImageLoader.parse(arrayBuffer, this.loadOptions);
+    this._checkResponse(response, arrayBuffer);
+    try {
+      return await ImageLoader.parse(arrayBuffer, this.loadOptions);
+    } catch {
+      throw this._parseError(arrayBuffer);
+    }
   }
 
   /** Get Feature Info for a coordinate */
   async getFeatureInfo(
     options: WMSGetFeatureInfoParameters,
-    extra?: Record<string, unknown>
+    vendorParameters?: Record<string, unknown>
   ): Promise<WMSFeatureInfo> {
-    const url = this.getFeatureInfoURL(options, extra);
+    const url = this.getFeatureInfoURL(options, vendorParameters);
     const response = await this.fetch(url, this.loadOptions);
-    await this.checkResponse(response);
     const arrayBuffer = await response.arrayBuffer();
+    this._checkResponse(response, arrayBuffer);
     return await WMSFeatureInfoLoader.parse(arrayBuffer, this.loadOptions);
   }
 
   /** Get more information about a layer */
   async describeLayer(
     options: WMSDescribeLayerParameters,
-    extra?: Record<string, unknown>
+    vendorParameters?: Record<string, unknown>
   ): Promise<WMSLayerDescription> {
-    const url = this.describeLayerURL(options, extra);
+    const url = this.describeLayerURL(options, vendorParameters);
     const response = await this.fetch(url, this.loadOptions);
-    await this.checkResponse(response);
     const arrayBuffer = await response.arrayBuffer();
+    this._checkResponse(response, arrayBuffer);
     return await WMSLayerDescriptionLoader.parse(arrayBuffer, this.loadOptions);
   }
 
   /** Get an image with a semantic legend */
   async getLegendGraphic(
     options: WMSGetLegendGraphicParameters,
-    extra?: Record<string, unknown>
+    vendorParameters?: Record<string, unknown>
   ): Promise<ImageType> {
-    const url = this.getLegendGraphicURL(options, extra);
+    const url = this.getLegendGraphicURL(options, vendorParameters);
     const response = await this.fetch(url, this.loadOptions);
-    await this.checkResponse(response);
     const arrayBuffer = await response.arrayBuffer();
-    return await ImageLoader.parse(arrayBuffer, this.loadOptions);
+    this._checkResponse(response, arrayBuffer);
+    try {
+      return await ImageLoader.parse(arrayBuffer, this.loadOptions);
+    } catch {
+      throw this._parseError(arrayBuffer);
+    }
+  }
+
+  // Typed URL creators
+  // For applications that want full control of fetching and parsing
+
+  /** Generate a URL for the GetCapabilities request */
+  getCapabilitiesURL(
+    wmsParameters?: WMSGetCapabilitiesParameters,
+    vendorParameters?: Record<string, unknown>
+  ): string {
+    const options: Required<WMSGetCapabilitiesParameters> = {
+      service: 'WMS',
+      version: '1.1.1',
+      request: 'GetCapabilities',
+      ...wmsParameters,
+      ...vendorParameters
+    };
+    return this._getWMSUrl(options, vendorParameters);
+  }
+
+  /** Generate a URL for the GetMap request */
+  getMapURL(
+    wmsParameters: WMSGetMapParameters,
+    vendorParameters?: Record<string, unknown>
+  ): string {
+    const options: Required<WMSGetMapParameters> = {
+      service: 'WMS',
+      version: '1.1.1',
+      request: 'GetMap',
+      // layers: [],
+      // bbox: [-77.87304, 40.78975, -77.85828, 40.80228],
+      // width: 1200,
+      // height: 900,
+      styles: undefined,
+      srs: 'EPSG:4326',
+      format: 'image/png',
+      ...wmsParameters,
+      ...vendorParameters
+    };
+    return this._getWMSUrl(options, vendorParameters);
+  }
+
+  /** Generate a URL for the GetFeatureInfo request */
+  getFeatureInfoURL(
+    wmsParameters: WMSGetFeatureInfoParameters,
+    vendorParameters?: Record<string, unknown>
+  ): string {
+    const options: Required<WMSGetFeatureInfoParameters> = {
+      service: 'WMS',
+      version: '1.1.1',
+      request: 'GetFeatureInfo',
+      // layers: [],
+      // bbox: [-77.87304, 40.78975, -77.85828, 40.80228],
+      // width: 1200,
+      // height: 900,
+      // x: undefined!,
+      // y: undefined!,
+      // query_layers: [],
+      srs: 'EPSG:4326',
+      format: 'image/png',
+      info_format: 'text/plain',
+      styles: undefined,
+      ...wmsParameters,
+      ...vendorParameters
+    };
+    return this._getWMSUrl(options, vendorParameters);
+  }
+
+  /** Generate a URL for the GetFeatureInfo request */
+  describeLayerURL(
+    wmsParameters: WMSDescribeLayerParameters,
+    vendorParameters?: Record<string, unknown>
+  ): string {
+    const options: Required<WMSDescribeLayerParameters> = {
+      service: 'WMS',
+      version: '1.1.1',
+      request: 'DescribeLayer',
+      ...wmsParameters,
+      ...vendorParameters
+    };
+    return this._getWMSUrl(options, vendorParameters);
+  }
+
+  getLegendGraphicURL(
+    wmsParameters: WMSGetLegendGraphicParameters,
+    vendorParameters?: Record<string, unknown>
+  ): string {
+    const options: Required<WMSGetLegendGraphicParameters> = {
+      service: 'WMS',
+      version: '1.1.1',
+      request: 'GetLegendGraphic',
+      ...wmsParameters,
+      ...vendorParameters
+    };
+    return this._getWMSUrl(options, vendorParameters);
   }
 
   // INTERNAL METHODS
 
   /**
-   * @note protected, since perhaps getWMSUrl may need to be overridden to handle certain backends?
-   * @note if override is common, maybe add a callback prop?
+   * @note case _getWMSUrl may need to be overridden to handle certain backends?
    * */
-  protected getWMSUrl(
-    options: {
-      request: string;
-      layers?: string[];
-    },
-    extra?: Record<string, unknown>
+  protected _getWMSUrl(
+    options: Record<string, unknown>,
+    vendorParameters?: Record<string, unknown>
   ): string {
-    let url = `${this.url}?REQUEST=${options.request}`;
-    if (options.layers?.length) {
-      url += `&LAYERS=[${options.layers.join(',')}]`;
+    let url = `${this.serviceUrl}`;
+    let first = true;
+    for (const [key, value] of Object.entries(options)) {
+      url += first ? '?' : '&';
+      first = false;
+      if (Array.isArray(value)) {
+        url += `${key.toUpperCase()}=${value.join(',')}`;
+      } else {
+        url += `${key.toUpperCase()}=${value ? String(value) : ''}`;
+      }
     }
-    return url;
+    return encodeURI(url);
   }
 
   /** Checks for and parses a WMS XML formatted ServiceError and throws an exception */
-  protected async checkResponse(response: Response) {
-    if (!response.ok || response.headers['content-type'] === WMSErrorLoader.mimeTypes[0]) {
-      const arrayBuffer = await response.arrayBuffer();
-      const error = await WMSErrorLoader.parse(arrayBuffer, this.loadOptions);
+  protected _checkResponse(response: Response, arrayBuffer: ArrayBuffer): void {
+    const contentType = response.headers['content-type'];
+    if (!response.ok || WMSErrorLoader.mimeTypes.includes(contentType)) {
+      const error = WMSErrorLoader.parseSync(arrayBuffer, this.loadOptions);
       throw new Error(error);
     }
   }
+
+  /** Error situation detected */
+  protected _parseError(arrayBuffer: ArrayBuffer): Error {
+    const error = WMSErrorLoader.parseSync(arrayBuffer, this.loadOptions);
+    return new Error(error);
+  }
 }

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

@@ -22,7 +22,7 @@ import type {
 } from '@loaders.gl/schema';
 
 import {XMLLoader} from '@loaders.gl/xml';
-import deepStrictEqual from 'deep-strict-equal';
+import {deepStrictEqual} from './deep-strict-equal';
 import rewind from '@turf/rewind';
 
 function noTransform(...coords) {

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;