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

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;

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;
+}

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

@@ -0,0 +1,77 @@
+// loaders.gl, MIT licenses
+
+/** All capabilities of a WFS service - response to a WFS `GetCapabilities` data structure extracted from XML */
+export type WFSCapabilities = {
+  serviceIdentification: {
+    title: string;
+    serviceTypeVersion: string;
+    serviceType: string;
+  };
+
+  serviceProvider: {
+    providerName: string;
+    providerSite: string;
+    serviceContact: {
+      individualName: string;
+      positionName: string;
+      contactInfo: {
+        address: {
+          administrativeArea: string;
+          city: string;
+          country: string;
+          deliveryPoint: string;
+          electronicMailAddress: string;
+          postalCode: string;
+        };
+        phone: {
+          voice: string;
+        };
+      };
+    };
+  };
+
+  operationsMetadata: {
+    GetCapabilities: any;
+    GetFeatureInfo: any;
+    GetTile: any;
+  };
+
+  contents: {
+    layers: {
+      abstract: string;
+      identifier: string;
+      title: string;
+      formats: string[];
+      styles: {
+        identifier: string;
+        isDefault: string;
+        title: string;
+        abstract?: string;
+      }[];
+      bounds: {
+        left: number;
+        right: number;
+        bottom: number;
+        top: number;
+      };
+      tileMatrixSetLinks: {
+        tileMatrixSet: string;
+      }[];
+      tileMatrixSets: {
+        identifier: string;
+        matrixIds: {
+          identifier: string;
+          matrixHeight: number;
+          matrixWidth: number;
+          scaleDenominator: number;
+          tileWidth: number;
+          tileHeight: number;
+          topLeftCorner: {
+            lon: number;
+            lat: number;
+          };
+        }[];
+      };
+    }[];
+  };
+};

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

@@ -122,8 +122,21 @@ export function parseWMSLayerDescription(text: string, options): WMSLayerDescrip
   return parsedXML as unknown as WMSLayerDescription;
 }
 
+/**
+ * Extract an error message from WMS error response XML
+ * @param text
+ * @param options
+ * @returns a string with a human readable message
+ */
 export function parseWMSError(text: string, options): string {
-  const parsedXML = XMLLoader.parseTextSync(text, options);
-  const error = parsedXML?.ServiceExceptionReport?.ServiceException || 'Unknown error';
-  return String(error);
+  const parsedXML = XMLLoader.parseTextSync?.(text, options);
+  const serviceExceptionXML =
+    parsedXML?.ServiceExceptionReport?.ServiceException ||
+    parsedXML?.['ogc:ServiceExceptionReport']?.['ogc:ServiceException'];
+  // Sigh, can be either a string or an object
+  const message =
+    typeof serviceExceptionXML === 'string'
+      ? serviceExceptionXML
+      : serviceExceptionXML['#text'] || serviceExceptionXML.code || 'Unknown error';
+  return message;
 }

package/src/wip/arcgis-feature-service.ts

@@ -0,0 +1,89 @@
+// @ts-nocheck
+
+import {LoaderOptions} from '@loaders.gl/loader-utils';
+// import {GeoJSONLoader} from '@loaders.gl/geojson';
+
+type FetchLike = (url: string, options?: RequestInit) => Promise<Response>;
+
+export type ArcGISImageServiceQueryOptions = {
+  returnGeometry: boolean;
+  where: '1%3D1';
+  outSR: 4326;
+  outFields: string | '*';
+  inSR: 4326;
+  geometry: `${-90}%2C+${30}%2C+${-70}%2C+${50}`;
+  geometryType: 'esriGeometryEnvelope'; // TODO - look up valid values in Esri docs
+  spatialRel: 'esriSpatialRelIntersects'; // TODO - look up valid values in Esri docs
+  geometryPrecision: number; // TODO - look up valid values in Esri docs
+  resultType: 'tile'; // TODO - look up valid values in Esri docs
+  f?: 'geojson'; // TODO - look up valid values in Esri docs
+}
+
+// const DEFAULT_QUERY_OPTIONS: Required<ArcGISImageServiceQueryOptions>  = {
+//   returnGeometry:true,
+//   where: '1%3D1',
+//   outSR: 4326,
+//   outFields: '*',
+//   inSR: 4326,
+//   geometry: `${-90}%2C+${30}%2C+${-70}%2C+${50}`,
+//   geometryType: 'esriGeometryEnvelope',
+//   spatialRel: 'esriSpatialRelIntersects',
+//   geometryPrecision: 6,
+//   resultType: 'tile',
+//   f: 'geojson'
+// };
+
+export type ArcGISFeatureServiceProps = ArcGISImageServiceQueryOptions & {
+  url: string;
+  loadOptions?: LoaderOptions;
+  fetch?: typeof fetch | FetchLike;
+};
+
+export class ArcGISFeatureService {
+  url: string;
+  loadOptions: LoaderOptions;
+  fetch: typeof fetch | FetchLike;
+
+  constructor(props: ArcGISFeatureServiceProps) {
+    this.url = props.url;
+    this.loadOptions = props.loadOptions || {};
+    this.fetch = props.fetch || fetch;
+  }
+
+ // URL creators
+
+  metadataURL(options: {parameters?: Record<string, unknown>}): string {
+    return this.getUrl({...options});
+  }
+
+  /** 
+   * Form a URL to an ESRI FeatureServer
+// https://services2.arcgis.com/CcI36Pduqd0OR4W9/ArcGIS/rest/services/Bicycle_Routes_Public/FeatureServer/0/query?
+//   returnGeometry=true&where=1%3D1&outSR=4326&outFields=*&inSR=4326&geometry=${-90}%2C+${30}%2C+${-70}%2C+${50}&
+//   geometryType=esriGeometryEnvelope&spatialRel=esriSpatialRelIntersects&geometryPrecision=6&resultType=tile&f=geojson`
+   */
+  exportImageURL(options: {
+    boundingBox: [number, number, number, number];
+    boundingBoxSR?: string;
+    width: number;
+    height: number;
+    imageSR?: string;
+    time?: never;
+    f?: 'geojson';
+    resultType?: 'tile';
+    noData?: never;
+    noDataInterpretation?: 'esriNoDataMatchAny';
+    interpolation?: '+RSP_NearestNeighbor';
+    compression?: never
+    compressionQuality?: never;
+    bandIds?: never;
+    mosaicRule?: never;
+    renderingRule?: never;
+    f?: 'image';
+  }): string {
+    const {boundingBox} = options;
+    // const bbox = `bbox=${boundingBox[0]},${boundingBox[1]},${boundingBox[2]},${boundingBox[3]}`;
+    // const size = `size=${width},${height}`
+    return this.getUrl({path: 'exportImage', });
+  }
+}

package/src/{lib/data-sources/image-data-source.ts → wip/data-source.ts}

@@ -1,51 +1,16 @@
 // loaders.gl, MIT license
 
-// from '@loaders.gl/images';
+/** General data source class */
+// export abstract class DataSource {};
+// export type DataSourceMetadata = {};
 
-/** General data source class *
-export abstract class DataSource {};
+// ImageSource
+
+// Tile Source
 
 /** Data source that serves data by tile index *
 export abstract class TileDataSource extends DataSource {};
 
-export type ImageFeatureInfo = {};
-
-export type ImageLayerInfo = {};
-
-export type ImageDataSourceCapabilities = {}
-
-/**
- * ImageDataSource - data sources that allow data to be queried by (geospatial) extents
- * @note
- * - If geospatial, bounding box is expected to be in web mercator coordinates
- *
-export abstract class ImageDataSource extends DataSource {
-  abstract getCapabilities(): Promise<ImageDataSourceCapabilities>;
-  abstract getImage({boundingBox, width, height, layers, parameters}): Promise<ImageType>;
-  getFeatureInfo({layers, parameters}): Promise<ImageFeatureInfo> {
-    throw new Error('not implemented');
-  }
-  getLayerInfo({layers, parameters}): Promise<ImageLayerInfo> {
-    throw new Error('not implemented');
-  }
-  getLegendImage({layers, parameters}): Promise<ImageType> {
-    throw new Error('not implemented');
-  }
-}
-
-// Vector Tile Data Source
-
-export type VectorTileDataSourceCapabilities = {
-  // check tile.json
-}
-
-export type VectorTile = Record<string, any>;
-
-export abstract class VectorTileDataSource extends TileDataSource {
-  abstract getCapabilities(): Promise<VectorTileDataSourceCapabilities>;
-  abstract getTile({x, y, z, width, height, layers, parameters}): Promise<VectorTile>;
-}
-
 // Image Tile Data Source
 
 export type ImageTileDataSourceCapabilities = {
@@ -80,4 +45,18 @@ export abstract class ImageTileDataSource extends TileDataSource {
     return [0, 0, 1, 1];
   }
 }
+
+// Vector Tile Source
+
+export type VectorTileDataSourceCapabilities = {
+  // check tile.json
+}
+
+export type VectorTile = Record<string, any>;
+
+export abstract class VectorTileDataSource extends TileDataSource {
+  abstract getCapabilities(): Promise<VectorTileDataSourceCapabilities>;
+  abstract getTile({x, y, z, width, height, layers, parameters}): Promise<VectorTile>;
+}
+
 */

package/src/{gml-loader.ts → wip/gml-loader.ts}

@@ -1,7 +1,7 @@
 // loaders.gl, MIT license
 
 import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
-import {parseGML} from './lib/gml/parse-gml';
+import {parseGML} from '../lib/gml/parse-gml';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.

package/src/{wcs-capabilities-loader.ts → wip/wcs-capabilities-loader.ts}

@@ -1,7 +1,7 @@
 // loaders.gl, MIT license
 
 import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
-import {parseWFSCapabilities} from './lib/wfs/parse-wfs';
+import {parseWFSCapabilities} from '../lib/wcs/parse-wcs';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
@@ -15,8 +15,8 @@ export type WCSLoaderOptions = LoaderOptions & {
  * Loader for the response to the WCS GetCapability request
  */
 export const WCSCapabilitiesLoader = {
-  name: 'WFS Capabilities',
   id: 'wcs-capabilities',
+  name: 'WFS Capabilities',
 
   module: 'wms',
   version: VERSION,

package/src/{wfs-capabilities-loader.ts → wip/wfs-capabilities-loader.ts}

@@ -1,7 +1,7 @@
 // loaders.gl, MIT license
 
 import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
-import {parseWFSCapabilities} from './lib/wfs/parse-wfs';
+import {parseWFSCapabilities} from '../lib/wfs/parse-wfs';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
@@ -15,8 +15,8 @@ export type WFSLoaderOptions = LoaderOptions & {
  * Loader for the response to the WFS GetCapability request
  */
 export const WFSCapabilitiesLoader = {
-  name: 'WFS Capabilities',
   id: 'wfs-capabilities',
+  name: 'WFS Capabilities',
 
   module: 'wms',
   version: VERSION,

package/src/{wms-feature-info-loader.ts → wip/wms-feature-info-loader.ts}

@@ -1,8 +1,8 @@
 // loaders.gl, MIT license
 
 import type {LoaderWithParser} from '@loaders.gl/loader-utils';
-import {WMSCapabilitiesLoader, WMSLoaderOptions} from './wms-capabilities-loader';
-import {parseWMSFeatureInfo} from './lib/wms/parse-wms';
+import {WMSCapabilitiesLoader, WMSLoaderOptions} from '../wms-capabilities-loader';
+import {parseWMSFeatureInfo} from '../lib/wms/parse-wms';
 
 /**
  * Loader for the response to the WMS GetFeatureInfo request
@@ -10,8 +10,8 @@ import {parseWMSFeatureInfo} from './lib/wms/parse-wms';
 export const WMSFeatureInfoLoader = {
   ...WMSCapabilitiesLoader,
 
-  name: 'WMS FeatureInfo',
   id: 'wms-feature-info',
+  name: 'WMS FeatureInfo',
 
   parse: async (arrayBuffer: ArrayBuffer, options?: WMSLoaderOptions) =>
     parseWMSFeatureInfo(new TextDecoder().decode(arrayBuffer), options),

package/src/wip/wms-layer-description-loader.md

@@ -0,0 +1,47 @@
+# WMSLayerDescriptionLoader
+
+<p class="badges">
+  <img src="https://img.shields.io/badge/From-v3.3-blue.svg?style=flat-square" alt="From-v3.3" />
+	<img src="https://img.shields.io/badge/-BETA-teal.svg" alt="BETA" />
+</p>
+
+The `WMSLayerDescriptionLoader` parses the XML-formatted response from the 
+the [OGC](https://www.opengeospatial.org/) [WMS](https://www.ogc.org/standards/wms) (Web Map Service) standard `DescribeLayer` request into a typed JavaScript data structure.
+
+> Note that the WMS standard is rather verbose and the XML responses can contain many rarely used metadata fields, not all of which are extracted by this loader. If this is a problem, it is possible to use the `XMLLoader` directly though the result will be untyped and not normalized.
+
+| Loader                | Characteristic                                       |
+| --------------------- | ---------------------------------------------------- |
+| File Extension        | `.xml`                                               |
+| File Type             | Text                                                 |
+| File Format           | [WMS](https://en.wikipedia.org/wiki/Web_Map_Service) |
+| Data Format           | Data structure         |
+| Decoder Type          | Synchronous                                          |
+| Worker Thread Support | No                                                  |
+| Streaming Support     | No                                                   |
+
+## Usage
+
+```js
+import {WMSLayerDescriptionLoader} from '@loaders.gl/wms';
+import {load} from '@loaders.gl/core';
+
+// Form a WMS request
+const url = `${WMS_SERVICE_URL}?REQUEST=DescribeLayer&LAYER=...`;
+
+const data = await load(url, WMSLayerDescriptionLoader, options);
+```
+
+## Parsed Data Format
+
+```typescript
+/** All capabilities of a WMS service. Typed data structure extracted from XML */
+export type WMSLayerDescription = {
+  // TO BE DOCUMENTED
+}
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |

package/src/{wms-layer-description-loader.ts → wip/wms-layer-description-loader.ts}

@@ -1,8 +1,8 @@
 // loaders.gl, MIT license
 
 import type {LoaderWithParser} from '@loaders.gl/loader-utils';
-import {WMSCapabilitiesLoader, WMSLoaderOptions} from './wms-capabilities-loader';
-import {parseWMSLayerDescription} from './lib/wms/parse-wms';
+import {WMSCapabilitiesLoader, WMSLoaderOptions} from '../wms-capabilities-loader';
+import {parseWMSLayerDescription} from '../lib/wms/parse-wms';
 
 /**
  * Loader for the response to the WMS DescribeLayer request
@@ -10,8 +10,8 @@ import {parseWMSLayerDescription} from './lib/wms/parse-wms';
 export const WMSLayerDescriptionLoader = {
   ...WMSCapabilitiesLoader,
 
-  name: 'WMS DescribeLayer',
   id: 'wms-layer-description',
+  name: 'WMS DescribeLayer',
 
   parse: async (arrayBuffer: ArrayBuffer, options?: WMSLoaderOptions) =>
     parseWMSLayerDescription(new TextDecoder().decode(arrayBuffer), options),

package/src/{wmts-capabilities-loader.ts → wip/wmts-capabilities-loader.ts}

@@ -1,7 +1,7 @@
 // loaders.gl, MIT license
 
 import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
-import {parseWMTSCapabilities} from './lib/wmts/parse-wmts';
+import {parseWMTSCapabilities} from '../lib/wmts/parse-wmts';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
@@ -15,8 +15,8 @@ export type WMTSLoaderOptions = LoaderOptions & {
  * Loader for the response to the WMTS GetCapability request
  */
 export const WMTSCapabilitiesLoader = {
-  name: 'WMTS Capabilities',
   id: 'wmts-capabilities',
+  name: 'WMTS Capabilities',
 
   module: 'wms',
   version: VERSION,

package/src/wms-capabilities-loader.ts

@@ -15,8 +15,8 @@ export type WMSLoaderOptions = LoaderOptions & {
  * Loader for the response to the WMS GetCapability request
  */
 export const WMSCapabilitiesLoader = {
-  name: 'WMS Capabilities',
   id: 'wms-capabilities',
+  name: 'WMS Capabilities',
 
   module: 'wms',
   version: VERSION,