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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/wms",
-  "version": "3.3.0-alpha.10",
+  "version": "3.3.0-alpha.12",
   "description": "Framework-independent loaders for the WMS (Web Map Service) standard",
   "license": "MIT",
   "publishConfig": {
@@ -13,9 +13,15 @@
   "keywords": [
     "WMS",
     "web map service",
+    "WFS",
+    "web feature service",
+    "WMTS",
+    "web map tile service",
+    "GML",
+    "geographic markup language",
+    "gis",
     "loader",
     "geospatial",
-    "webgl",
     "OGC"
   ],
   "types": "dist/index.d.ts",
@@ -33,11 +39,15 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "3.3.0-alpha.10",
-    "@loaders.gl/schema": "3.3.0-alpha.10"
+    "@loaders.gl/images": "3.3.0-alpha.12",
+    "@loaders.gl/loader-utils": "3.3.0-alpha.12",
+    "@loaders.gl/schema": "3.3.0-alpha.12",
+    "@loaders.gl/xml": "3.3.0-alpha.12",
+    "@turf/rewind": "^5.1.5",
+    "deep-strict-equal": "^0.2.0"
   },
   "devDependencies": {
     "xmldom": "0.6.0"
   },
-  "gitHead": "53bc8d3f18fbc3445a00f8509038479119895c78"
+  "gitHead": "e807cde8f2fcb3503fa01ae3ac6b148ff5326649"
 }

package/src/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/index.ts

@@ -1,13 +1,32 @@
 // loaders.gl, MIT license
 
-// WMSCapabilitiesLoader
+// WMS
 
-export type {WMSCapabilities, WMSFeatureInfo, WMSLayerDescription} from './wms-types';
+export {WMSErrorLoader} from './wms-error-loader';
 
+export type {WMSCapabilities, WMSFeatureInfo, WMSLayerDescription} from './lib/wms/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';
+export type {WMSServiceProps} from './lib/data-sources/wms-service';
+export {WMSService} from './lib/data-sources/wms-service';
+
+// WFS
+
+export type {WFSCapabilities} from './lib/wfs/wfs-types';
+export type {WFSLoaderOptions} from './wfs-capabilities-loader';
+export {WFSCapabilitiesLoader} from './wfs-capabilities-loader';
+
+// WMTS
+
+export type {WMTSCapabilities} from './lib/wmts/wmts-types';
+export type {WMTSLoaderOptions} from './wmts-capabilities-loader';
+export {WMTSCapabilitiesLoader} from './wmts-capabilities-loader';
+
+// GML
+
+export type {GeoJSON} from '@loaders.gl/schema';
+export type {GMLLoaderOptions} from './gml-loader';
+export {GMLLoader} from './gml-loader';

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

@@ -1,7 +1,6 @@
 // loaders.gl, MIT license
 
-/*
-import {ImageType} from '@loaders.gl/images';
+// from '@loaders.gl/images';
 
 /** General data source class *
 export abstract class DataSource {};

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

@@ -0,0 +1,313 @@
+// loaders.gl, MIT license
+
+/* 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 {LoaderOptions} from '@loaders.gl/loader-utils';
+
+type FetchLike = (url: string, options?: RequestInit) => Promise<Response>;
+
+export type WMSGetCapabilitiesParameters = {
+  /** In case the endpoint supports multiple services */
+  service?: 'WMS';
+  /** In case the endpoint supports multiple WMS versions */
+  version?: '1.1.1' | '1.3.0';
+  /** 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';
+  /** Request type */
+  request?: 'GetMap';
+  /** Layers to render */
+  layers: string[];
+  /** Styling */
+  styles?: unknown;
+  /** bounding box of the requested map image */
+  bbox: [number, number, number, number];
+  /** pixel width of returned image */
+  width: number;
+  /** pixels */
+  height: number;
+  /** srs for the image (not the bounding box) */
+  srs?: string;
+  /** requested format for the return image */
+  format?: 'image/png';
+};
+
+// 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';
+  /** Request type */
+  request?: 'GetFeatureInfo';
+
+  /** x coordinate for the feature info request */
+  x: number;
+  /** y coordinate for the feature info request */
+  y: number;
+  /** list of layers to query (could be different from rendered layers) */
+  query_layers: string[];
+  /** MIME type of returned feature info */
+  info_format: 'text/plain';
+
+  /** Layers to render */
+  layers: string[];
+  /** Styling */
+  styles?: unknown;
+  /** bounding box of the requested map image */
+  bbox: [number, number, number, number];
+  /** pixel width of returned image */
+  width: number;
+  /** pixels */
+  height: number;
+  /** srs for the image (not the bounding box) */
+  srs?: string;
+  /** requested format for the return image */
+  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';
+  /** 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';
+  /** 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'
+};
+
+export type WMSServiceProps = {
+  url: string;
+  loadOptions?: LoaderOptions;
+  fetch?: typeof fetch | FetchLike;
+};
+
+export class WMSService {
+  url: string;
+  loadOptions: LoaderOptions;
+  fetch: typeof fetch | FetchLike;
+
+  constructor(props: WMSServiceProps) {
+    this.url = props.url;
+    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);
+  }
+
+  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);
+  }
+
+  // WMS Service API Stubs
+
+  /** Get Capabilities */
+  async getCapabilities(
+    parameters?: WMSGetCapabilitiesParameters,
+    extra?: Record<string, unknown>
+  ): Promise<WMSCapabilities> {
+    const url = this.getCapabilitiesURL(parameters, extra);
+    const response = await this.fetch(url, this.loadOptions);
+    await this.checkResponse(response);
+    const arrayBuffer = await 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);
+    const arrayBuffer = await response.arrayBuffer();
+    return await ImageLoader.parse(arrayBuffer, this.loadOptions);
+  }
+
+  /** Get Feature Info for a coordinate */
+  async getFeatureInfo(
+    options: WMSGetFeatureInfoParameters,
+    extra?: Record<string, unknown>
+  ): Promise<WMSFeatureInfo> {
+    const url = this.getFeatureInfoURL(options, extra);
+    const response = await this.fetch(url, this.loadOptions);
+    await this.checkResponse(response);
+    const arrayBuffer = await response.arrayBuffer();
+    return await WMSFeatureInfoLoader.parse(arrayBuffer, this.loadOptions);
+  }
+
+  /** Get more information about a layer */
+  async describeLayer(
+    options: WMSDescribeLayerParameters,
+    extra?: Record<string, unknown>
+  ): Promise<WMSLayerDescription> {
+    const url = this.describeLayerURL(options, extra);
+    const response = await this.fetch(url, this.loadOptions);
+    await this.checkResponse(response);
+    const arrayBuffer = await response.arrayBuffer();
+    return await WMSLayerDescriptionLoader.parse(arrayBuffer, this.loadOptions);
+  }
+
+  /** Get an image with a semantic legend */
+  async getLegendGraphic(
+    options: WMSGetLegendGraphicParameters,
+    extra?: Record<string, unknown>
+  ): Promise<ImageType> {
+    const url = this.getLegendGraphicURL(options, extra);
+    const response = await this.fetch(url, this.loadOptions);
+    await this.checkResponse(response);
+    const arrayBuffer = await response.arrayBuffer();
+    return await ImageLoader.parse(arrayBuffer, this.loadOptions);
+  }
+
+  // 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?
+   * */
+  protected getWMSUrl(
+    options: {
+      request: string;
+      layers?: string[];
+    },
+    extra?: Record<string, unknown>
+  ): string {
+    let url = `${this.url}?REQUEST=${options.request}`;
+    if (options.layers?.length) {
+      url += `&LAYERS=[${options.layers.join(',')}]`;
+    }
+    return 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);
+      throw new Error(error);
+    }
+  }
+}