@loaders.gl/wms 3.3.0-alpha.9 → 3.3.1

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/wfs/parse-wfs.ts

@@ -0,0 +1,39 @@
+// loaders.gl, MIT license
+
+import type {WFSCapabilities} from './wfs-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/wfs/wfs-types.ts

@@ -0,0 +1,78 @@
+// 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/{parse-wms.ts → wms/parse-wms.ts}

@@ -4,10 +4,11 @@ import type {
   WMSCapabilities,
   WMSLayer,
   WMSRequest,
-  WMSFeatureInfo
+  WMSFeatureInfo,
+  WMSLayerDescription
   // WMSFeature,
   // WMSLayerDescription
-} from '../wms-types';
+} from './wms-types';
 
 import {XMLLoader} from '@loaders.gl/xml';
 
@@ -62,13 +63,26 @@ function extractLayer(xmlLayer: any): WMSLayer {
     layers: []
   };
 
-  for (const xmlSubLayer of xmlLayer?.Layer || []) {
+  // Single layer is not represented as array in XML
+  const xmlLayers = getXMLArray(xmlLayer?.Layer);
+
+  for (const xmlSubLayer of xmlLayers) {
     layer.layers?.push(extractLayer(xmlSubLayer));
   }
 
   return layer;
 }
 
+function getXMLArray(xmlValue: any) {
+  if (Array.isArray(xmlValue)) {
+    return xmlValue;
+  }
+  if (xmlValue) {
+    return [xmlValue];
+  }
+  return [];
+}
+
 // GetFeatureInfo
 
 /**
@@ -88,5 +102,41 @@ export function parseWMSFeatureInfo(text: string, options): WMSFeatureInfo {
 
 function extractFeature(xmlFeature: any) {
   const xmlFields = xmlFeature || {};
-  return {attributes: xmlFields};
+  // TODO - not correct
+  return {
+    attributes: xmlFields,
+    type: '',
+    bounds: {bottom: 0, top: 0, left: 0, right: 0}
+  };
+}
+
+// GetFeatureInfo
+
+/**
+ * Parses a typed data structure from raw XML for `GetFeatureInfo` response
+ * @note Error handlings is fairly weak
+ */
+export function parseWMSLayerDescription(text: string, options): WMSLayerDescription {
+  const parsedXML = XMLLoader.parseTextSync(text, options);
+  // TODO - implement parser
+  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 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/{wms-types.ts → lib/wms/wms-types.ts}

@@ -39,13 +39,15 @@ export type WMSFeatureInfo = {
 
 export type WMSFeature = {
   attributes: Record<string, number | string>;
+  type: string;
+  bounds: {top: number; bottom: number; left: number; right: number};
 };
 
 // DescribeLayer
 
 /** Layer description - response to a WMS `DescribeLayer` request  */
 export type WMSLayerDescription = {
-  // layers: {}[];
+  layers: {}[];
 };
 
 // // WIP

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

@@ -0,0 +1,39 @@
+// loaders.gl, MIT license
+
+import type {WMTSCapabilities} from './wmts-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 parseWMTSCapabilities(text: string, options): WMTSCapabilities {
+  // 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/wmts/wmts-types.ts

@@ -0,0 +1,77 @@
+// loaders.gl, MIT licenses
+
+/** All capabilities of a WMTS service - response to a WMTS `GetCapabilities` data structure extracted from XML */
+export type WMTSCapabilities = {
+  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/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,52 +1,16 @@
 // loaders.gl, MIT license
 
-/*
-import {ImageType} 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 = {
@@ -81,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/wip/gml-loader.ts

@@ -0,0 +1,40 @@
+// loaders.gl, MIT license
+
+import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+import {parseGML} from '../lib/gml/parse-gml';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+export type GMLLoaderOptions = LoaderOptions & {
+  gml?: {};
+};
+
+/**
+ * Loader for the response to the GML GetCapability request
+ */
+export const GMLLoader = {
+  name: 'GML',
+  id: 'gml',
+
+  module: 'wms',
+  version: VERSION,
+  worker: false,
+  extensions: ['xml'],
+  mimeTypes: ['application/vnd.ogc.gml_xml', 'application/xml', 'text/xml'],
+  testText: testXMLFile,
+  options: {
+    gml: {}
+  },
+  parse: async (arrayBuffer: ArrayBuffer, options?: GMLLoaderOptions) =>
+    parseGML(new TextDecoder().decode(arrayBuffer), options),
+  parseTextSync: (text: string, options?: GMLLoaderOptions) => parseGML(text, options)
+};
+
+function testXMLFile(text: string): boolean {
+  // TODO - There could be space first.
+  return text.startsWith('<?xml');
+}
+
+export const _typecheckGMLLoader: LoaderWithParser = GMLLoader;

package/src/wip/wcs-capabilities-loader.ts

@@ -0,0 +1,40 @@
+// loaders.gl, MIT license
+
+import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+import {parseWFSCapabilities} from '../lib/wcs/parse-wcs';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+export type WCSLoaderOptions = LoaderOptions & {
+  wcs?: {};
+};
+
+/**
+ * Loader for the response to the WCS GetCapability request
+ */
+export const WCSCapabilitiesLoader = {
+  id: 'wcs-capabilities',
+  name: 'WFS Capabilities',
+
+  module: 'wms',
+  version: VERSION,
+  worker: false,
+  extensions: ['xml'],
+  mimeTypes: ['application/vnd.ogc.wcs_xml', 'application/xml', 'text/xml'],
+  testText: testXMLFile,
+  options: {
+    wms: {}
+  },
+  parse: async (arrayBuffer: ArrayBuffer, options?: WCSLoaderOptions) =>
+    parseWFSCapabilities(new TextDecoder().decode(arrayBuffer), options),
+  parseTextSync: (text: string, options?: WCSLoaderOptions) => parseWFSCapabilities(text, options)
+};
+
+function testXMLFile(text: string): boolean {
+  // TODO - There could be space first.
+  return text.startsWith('<?xml');
+}
+
+export const _typecheckWFSCapabilitiesLoader: LoaderWithParser = WCSCapabilitiesLoader;