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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/wms",
-  "version": "3.3.0-alpha.8",
+  "version": "3.3.0-alpha.9",
   "description": "Framework-independent loaders for the WMS (Web Map Service) standard",
   "license": "MIT",
   "publishConfig": {
@@ -33,11 +33,11 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "3.3.0-alpha.8",
-    "@loaders.gl/schema": "3.3.0-alpha.8"
+    "@loaders.gl/loader-utils": "3.3.0-alpha.9",
+    "@loaders.gl/schema": "3.3.0-alpha.9"
   },
   "devDependencies": {
     "xmldom": "0.6.0"
   },
-  "gitHead": "69cfde0340328dd800c7c90151b56b406f47e9ae"
+  "gitHead": "c95a4ff72512668a93d9041ce8636bac09333fd5"
 }

package/src/bundle.ts

@@ -1,3 +1,5 @@
+// loaders.gl, MIT license
+
 // @ts-nocheck
 const moduleExports = require('./index');
 globalThis.loaders = globalThis.loaders || {};

package/src/index.ts

@@ -2,5 +2,12 @@
 
 // WMSCapabilitiesLoader
 
-export type {WMSCapabilitiesLoaderOptions} from './wms-capabilities-loader';
+export type {WMSCapabilities, WMSFeatureInfo, WMSLayerDescription} from './wms-types';
+
+export type {WMSLoaderOptions} from './wms-capabilities-loader';
 export {WMSCapabilitiesLoader} from './wms-capabilities-loader';
+export {WMSFeatureInfoLoader} from './wms-feature-info-loader';
+export {WMSLayerDescriptionLoader} from './wms-layer-description-loader';
+
+export type {WMSDataSourceProps as _WMSDataSourceProps} from './lib/data-sources/wms-data-source';
+export {WMSDataSource as _WMSDataSource} from './lib/data-sources/wms-data-source';

package/src/lib/data-sources/image-data-source.ts

@@ -0,0 +1,84 @@
+// loaders.gl, MIT license
+
+/*
+import {ImageType} from '@loaders.gl/images';
+
+/** General data source class *
+export abstract class DataSource {};
+
+/** 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 = {
+}
+
+export type ImageTile = Record<string, any>;
+
+export type FeatureInfo = {};
+
+export abstract class ImageTileDataSource extends TileDataSource {
+  source: ImageDataSource;
+  
+  constructor(source: ImageDataSource) {
+    super();
+    this.source = source;
+  }
+
+  getCapabilities(): Promise<ImageTileDataSourceCapabilities> {
+    return this.source.getCapabilities();
+  }
+
+  getTile({x, y, z, width, height, layers, parameters}): Promise<ImageType> {
+    const boundingBox = this.getBoundingBoxFromTileIndex(x, y, z);
+    return this.source.getImage({boundingBox, width, height, layers, parameters});
+  }
+
+  getFeatureInfo(): FeatureInfo | null {
+    return null;
+  }
+
+  getBoundingBoxFromTileIndex(x: number, y: number, z: number): [number, number, number, number] {
+    return [0, 0, 1, 1];
+  }
+}
+*/

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

@@ -0,0 +1,99 @@
+// loaders.gl, MIT license
+
+import type {WMSCapabilities, WMSFeatureInfo, WMSLayerDescription} from '@loaders.gl/wms';
+import {
+  WMSCapabilitiesLoader,
+  WMSFeatureInfoLoader,
+  WMSLayerDescriptionLoader
+} from '@loaders.gl/wms';
+import {ImageLoader, ImageType} from '@loaders.gl/images';
+import {LoaderOptions} from '@loaders.gl/loader-utils';
+
+// import {ImageDataSource} from './image-data-sources';
+
+type FetchLike = (url: string, options?: RequestInit) => Promise<Response>;
+
+export type WMSDataSourceProps = {
+  url: string;
+  loadOptions?: LoaderOptions;
+  fetch?: typeof fetch | FetchLike;
+};
+
+export class WMSDataSource {
+  // implements ImageDataSource {
+  url: string;
+  loadOptions: LoaderOptions;
+  fetch: typeof fetch | FetchLike;
+
+  constructor(props: WMSDataSourceProps) {
+    this.url = props.url;
+    this.loadOptions = props.loadOptions || {};
+    this.fetch = props.fetch || fetch;
+  }
+
+  async getCapabilities(options: {parameters?: Record<string, unknown>}): Promise<WMSCapabilities> {
+    const url = this.getUrl({request: 'GetCapabilities', ...options});
+    const response = await this.fetch(url, this.loadOptions);
+    const arrayBuffer = await response.arrayBuffer();
+    return await WMSCapabilitiesLoader.parse(arrayBuffer, this.loadOptions);
+  }
+
+  async getImage(options: {
+    boundingBox;
+    width;
+    height;
+    layers: string[];
+    parameters?: Record<string, unknown>;
+  }): Promise<ImageType> {
+    const url = this.getUrl({request: 'GetMap', ...options});
+    const response = await this.fetch(url, this.loadOptions);
+    const arrayBuffer = await response.arrayBuffer();
+    return await ImageLoader.parse(arrayBuffer, this.loadOptions);
+  }
+
+  async getFeatureInfo(options: {
+    layers: string[];
+    parameters?: Record<string, unknown>;
+  }): Promise<WMSFeatureInfo> {
+    const url = this.getUrl({request: 'GetFeatureInfo', ...options});
+    const response = await this.fetch(url, this.loadOptions);
+    const arrayBuffer = await response.arrayBuffer();
+    return await WMSFeatureInfoLoader.parse(arrayBuffer, this.loadOptions);
+  }
+
+  async getLayerInfo(options: {
+    layers: string[];
+    parameters?: Record<string, unknown>;
+  }): Promise<WMSLayerDescription> {
+    const url = this.getUrl({request: 'GetLayerInfo', ...options});
+    const response = await this.fetch(url, this.loadOptions);
+    const arrayBuffer = await response.arrayBuffer();
+    return await WMSLayerDescriptionLoader.parse(arrayBuffer, this.loadOptions);
+  }
+
+  async getLegendImage(options: {
+    layers: string[];
+    parameters?: Record<string, unknown>;
+  }): Promise<ImageType> {
+    const url = this.getUrl({request: 'GetLegendImage', ...options});
+    const response = await this.fetch(url, this.loadOptions);
+    const arrayBuffer = await response.arrayBuffer();
+    return await ImageLoader.parse(arrayBuffer, this.loadOptions);
+  }
+
+  /**
+   * @note protected, since perhaps getUrl may need to be overridden to handle certain backends?
+   * @note if override is common, maybe add a callback prop?
+   * */
+  protected getUrl(options: {
+    request: string;
+    layers?: string[];
+    parameters?: Record<string, unknown>;
+  }): string {
+    let url = `${this.url}?REQUEST=${options.request}`;
+    if (options.layers?.length) {
+      url += `&LAYERS=[${options.layers.join(',')}]`;
+    }
+    return url;
+  }
+}

package/src/lib/parse-wms.ts

@@ -0,0 +1,92 @@
+// loaders.gl, MIT license
+
+import type {
+  WMSCapabilities,
+  WMSLayer,
+  WMSRequest,
+  WMSFeatureInfo
+  // 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: []
+  };
+
+  for (const xmlSubLayer of xmlLayer?.Layer || []) {
+    layer.layers?.push(extractLayer(xmlSubLayer));
+  }
+
+  return layer;
+}
+
+// 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 || {};
+  return {attributes: xmlFields};
+}

package/src/wms-capabilities-loader.ts

@@ -1,20 +1,23 @@
+// loaders.gl, MIT license
+
 import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
-import {parseWMSCapabilities} from './lib/parse-wms-capabilities';
+import {parseWMSCapabilities} from './lib/parse-wms';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
 const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 
-export type WMSCapabilitiesLoaderOptions = LoaderOptions & {
+export type WMSLoaderOptions = LoaderOptions & {
   wms?: {};
 };
 
 /**
- * Worker loader for the OBJ geometry format
+ * Loader for the response to the WMS GetCapability request
  */
 export const WMSCapabilitiesLoader = {
   name: 'WMS Capabilities',
-  id: 'wms',
+  id: 'wms-capabilities',
+
   module: 'wms',
   version: VERSION,
   worker: false,
@@ -22,12 +25,11 @@ export const WMSCapabilitiesLoader = {
   mimeTypes: ['application/vnd.ogc.wms_xml', 'application/xml', 'text/xml'],
   testText: testXMLFile,
   options: {
-    obj: {}
+    wms: {}
   },
-  parse: async (arrayBuffer: ArrayBuffer, options?: WMSCapabilitiesLoaderOptions) =>
+  parse: async (arrayBuffer: ArrayBuffer, options?: WMSLoaderOptions) =>
     parseWMSCapabilities(new TextDecoder().decode(arrayBuffer), options),
-  parseTextSync: (text: string, options?: WMSCapabilitiesLoaderOptions) =>
-    parseWMSCapabilities(text, options)
+  parseTextSync: (text: string, options?: WMSLoaderOptions) => parseWMSCapabilities(text, options)
 };
 
 function testXMLFile(text: string): boolean {

package/src/wms-feature-info-loader.ts

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

package/src/wms-layer-description-loader.ts

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

package/src/wms-types.ts

@@ -1,35 +1,85 @@
 // 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>;
 };
 
-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 +125,7 @@ export type Style = {
   };
 };
 
-export type Capability = GetCapabilities | GetMap;
+// export type Capability = GetCapabilities | GetMap;
 
 export type WMSService = {
   rawData: unknown;
@@ -86,9 +136,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/dist/es5/lib/parse-wms-capabilities.js

@@ -1,19 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.parseWMSCapabilities = parseWMSCapabilities;
-var _xml = require("@loaders.gl/xml");
-
-function parseWMSCapabilities(text, options) {
-  var parsedXML = _xml.XMLLoader.parseTextSync(text, options);
-  if (parsedXML.WMT_MS_Capabilities) {
-    return parsedXML.WMT_MS_Capabilities;
-  }
-  if (parsedXML.WMS_Capabilities) {
-    return parsedXML.WMS_Capabilities;
-  }
-  return parsedXML;
-}
-//# sourceMappingURL=parse-wms-capabilities.js.map

package/dist/es5/lib/parse-wms-capabilities.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-wms-capabilities.js","names":["parseWMSCapabilities","text","options","parsedXML","XMLLoader","parseTextSync","WMT_MS_Capabilities","WMS_Capabilities"],"sources":["../../../src/lib/parse-wms-capabilities.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport {XMLLoader} from '@loaders.gl/xml';\n\nexport function parseWMSCapabilities(text, options) {\n  const parsedXML = XMLLoader.parseTextSync(text, options);\n  if (parsedXML.WMT_MS_Capabilities) {\n    return parsedXML.WMT_MS_Capabilities;\n  }\n  if (parsedXML.WMS_Capabilities) {\n    return parsedXML.WMS_Capabilities;\n  }\n  return parsedXML;\n}\n"],"mappings":";;;;;;AAEA;;AAEO,SAASA,oBAAoB,CAACC,IAAI,EAAEC,OAAO,EAAE;EAClD,IAAMC,SAAS,GAAGC,cAAS,CAACC,aAAa,CAACJ,IAAI,EAAEC,OAAO,CAAC;EACxD,IAAIC,SAAS,CAACG,mBAAmB,EAAE;IACjC,OAAOH,SAAS,CAACG,mBAAmB;EACtC;EACA,IAAIH,SAAS,CAACI,gBAAgB,EAAE;IAC9B,OAAOJ,SAAS,CAACI,gBAAgB;EACnC;EACA,OAAOJ,SAAS;AAClB"}

package/dist/esm/lib/parse-wms-capabilities.js

@@ -1,14 +0,0 @@
-
-
-import { XMLLoader } from '@loaders.gl/xml';
-export function parseWMSCapabilities(text, options) {
-  const parsedXML = XMLLoader.parseTextSync(text, options);
-  if (parsedXML.WMT_MS_Capabilities) {
-    return parsedXML.WMT_MS_Capabilities;
-  }
-  if (parsedXML.WMS_Capabilities) {
-    return parsedXML.WMS_Capabilities;
-  }
-  return parsedXML;
-}
-//# sourceMappingURL=parse-wms-capabilities.js.map

package/dist/esm/lib/parse-wms-capabilities.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-wms-capabilities.js","names":["XMLLoader","parseWMSCapabilities","text","options","parsedXML","parseTextSync","WMT_MS_Capabilities","WMS_Capabilities"],"sources":["../../../src/lib/parse-wms-capabilities.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport {XMLLoader} from '@loaders.gl/xml';\n\nexport function parseWMSCapabilities(text, options) {\n  const parsedXML = XMLLoader.parseTextSync(text, options);\n  if (parsedXML.WMT_MS_Capabilities) {\n    return parsedXML.WMT_MS_Capabilities;\n  }\n  if (parsedXML.WMS_Capabilities) {\n    return parsedXML.WMS_Capabilities;\n  }\n  return parsedXML;\n}\n"],"mappings":";;AAEA,SAAQA,SAAS,QAAO,iBAAiB;AAEzC,OAAO,SAASC,oBAAoB,CAACC,IAAI,EAAEC,OAAO,EAAE;EAClD,MAAMC,SAAS,GAAGJ,SAAS,CAACK,aAAa,CAACH,IAAI,EAAEC,OAAO,CAAC;EACxD,IAAIC,SAAS,CAACE,mBAAmB,EAAE;IACjC,OAAOF,SAAS,CAACE,mBAAmB;EACtC;EACA,IAAIF,SAAS,CAACG,gBAAgB,EAAE;IAC9B,OAAOH,SAAS,CAACG,gBAAgB;EACnC;EACA,OAAOH,SAAS;AAClB"}

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

@@ -1,14 +0,0 @@
-// loaders.gl, MIT license
-
-import {XMLLoader} from '@loaders.gl/xml';
-
-export function parseWMSCapabilities(text, options) {
-  const parsedXML = XMLLoader.parseTextSync(text, options);
-  if (parsedXML.WMT_MS_Capabilities) {
-    return parsedXML.WMT_MS_Capabilities;
-  }
-  if (parsedXML.WMS_Capabilities) {
-    return parsedXML.WMS_Capabilities;
-  }
-  return parsedXML;
-}