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

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

@@ -0,0 +1,142 @@
+// loaders.gl, MIT license
+
+import type {
+  WMSCapabilities,
+  WMSLayer,
+  WMSRequest,
+  WMSFeatureInfo,
+  WMSLayerDescription
+  // WMSFeature,
+  // WMSLayerDescription
+} from './wms-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 parseWMSCapabilities(text: string, options): WMSCapabilities {
+  const parsedXML = XMLLoader.parseTextSync(text, options);
+  const xmlCapabilities: any =
+    parsedXML.WMT_MS_Capabilities || parsedXML.WMS_Capabilities || parsedXML;
+  return extractCapabilities(xmlCapabilities);
+}
+
+/** Extract typed capability data from XML */
+function extractCapabilities(xml: any): WMSCapabilities {
+  const capabilities: WMSCapabilities = {
+    name: xml.Service?.Name || 'unnamed',
+    title: xml.Service?.Title,
+    keywords: [],
+    requests: {},
+    layer: extractLayer(xml.Capability?.Layer),
+    raw: xml
+  };
+
+  for (const keyword of xml.Service?.KeywordList?.Keyword || []) {
+    capabilities.keywords.push(keyword);
+  }
+
+  for (const [name, xmlRequest] of Object.entries(xml.Capability?.Request || {})) {
+    capabilities.requests[name] = extractRequest(name, xmlRequest);
+  }
+
+  return capabilities;
+}
+
+/** Extract typed request data from XML */
+function extractRequest(name: string, xmlRequest: any): WMSRequest {
+  const format: string | string[] = xmlRequest?.Format;
+  const mimeTypes: string[] = Array.isArray(format) ? format : [format];
+  return {name, mimeTypes};
+}
+
+/** Extract request data */
+function extractLayer(xmlLayer: any): WMSLayer {
+  const layer: WMSLayer = {
+    name: xmlLayer?.Name,
+    title: xmlLayer?.Title,
+    srs: xmlLayer?.SRS || [],
+    layers: []
+  };
+
+  // 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
+
+/**
+ * Parses a typed data structure from raw XML for `GetFeatureInfo` response
+ * @note Error handlings is fairly weak
+ */
+export function parseWMSFeatureInfo(text: string, options): WMSFeatureInfo {
+  const parsedXML = XMLLoader.parseTextSync(text, options);
+  const xmlFeatureInfo: any = parsedXML.FeatureInfoResponse?.FIELDS || [];
+
+  const xmlFeatures = Array.isArray(xmlFeatureInfo) ? xmlFeatureInfo : [xmlFeatureInfo];
+
+  return {
+    features: xmlFeatures.map((xmlFeature) => extractFeature(xmlFeature))
+  };
+}
+
+function extractFeature(xmlFeature: any) {
+  const xmlFields = xmlFeature || {};
+  // 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}

@@ -1,35 +1,87 @@
 // loaders.gl, MIT licenses
 
-export type GetCapabilities = {
-  request: 'GetCapabilities';
-  format: string[];
-  dcpType: unknown;
+/** All capabilities of a WMS service - response to a WMS `GetCapabilities` data structure extracted from XML */
+export type WMSCapabilities = {
+  name: string;
+  title?: string;
+  abstract?: string;
+  keywords: string[];
+  layer: {
+    name: string;
+    title?: string;
+    srs?: string[];
+    boundingBox?: [number, number, number, number];
+    layers: WMSLayer[];
+  };
+  requests: Record<string, WMSRequest>;
+  raw: Record<string, unknown>;
 };
 
-export type GetMap = {
-  request: 'GetMap';
-  format: string[];
-  dcpType: unknown;
+export type WMSLayer = {
+  name: string;
+  title?: string;
+  srs?: string[];
+  boundingBox?: [number, number, number, number];
+  layers: WMSLayer[];
 };
 
-export type GetFeatureInfo = {
-  request: 'GetFeatureInfo';
-  format: string[];
-  dcpType: unknown;
+export type WMSRequest = {
+  name: string;
+  mimeTypes: string[];
+};
+
+// GetFeatureInfo
+
+/** WMS Feature info - response to a WMS `GetFeatureInfo` request */
+export type WMSFeatureInfo = {
+  features: WMSFeature[];
 };
 
-export type GetLegendGraphic = {
-  request: 'GetLegendGraphic';
-  format: string[];
-  dcpType: unknown;
+export type WMSFeature = {
+  attributes: Record<string, number | string>;
+  type: string;
+  bounds: {top: number; bottom: number; left: number; right: number};
 };
 
-export type GetStyles = {
-  request: 'GetStyles';
-  format: string[];
-  dcpType: unknown;
+// DescribeLayer
+
+/** Layer description - response to a WMS `DescribeLayer` request  */
+export type WMSLayerDescription = {
+  layers: {}[];
 };
 
+// // WIP
+
+// export type GetCapabilities = {
+//   request: 'GetCapabilities';
+//   format: string[];
+//   dcpType: unknown;
+// };
+
+// export type GetMap = {
+//   request: 'GetMap';
+//   format: string[];
+//   dcpType: unknown;
+// };
+
+// export type GetFeatureInfo = {
+//   request: 'GetFeatureInfo';
+//   format: string[];
+//   dcpType: unknown;
+// };
+
+// export type GetLegendGraphic = {
+//   request: 'GetLegendGraphic';
+//   format: string[];
+//   dcpType: unknown;
+// };
+
+// export type GetStyles = {
+//   request: 'GetStyles';
+//   format: string[];
+//   dcpType: unknown;
+// };
+
 /**
  * <EX_GeographicBoundingBox>
  *     <westBoundLongitude>-180</westBoundLongitude>
@@ -75,7 +127,7 @@ export type Style = {
   };
 };
 
-export type Capability = GetCapabilities | GetMap;
+// export type Capability = GetCapabilities | GetMap;
 
 export type WMSService = {
   rawData: unknown;
@@ -86,9 +138,9 @@ export type WMSService = {
   maxWidth?: number;
   maxHeight?: number;
   capabilities: {
-    getCapabilities: GetCapabilities;
-    getMap: GetMap;
-    getFeatureInfo?: GetFeatureInfo;
+    // getCapabilities: GetCapabilities;
+    // getMap: GetMap;
+    // getFeatureInfo?: GetFeatureInfo;
   };
 
   untypedData: unknown; // The raw, untyped JSON converted from XML

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', });
+  }
+}