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

package/dist/wip/data-source.js

@@ -4,22 +4,10 @@
 // export abstract class DataSource {};
 // export type DataSourceMetadata = {};
 // ImageSource
+// Tile Source
 /** Data source that serves data by tile index *
 export abstract class TileDataSource extends DataSource {};
 
-// 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>;
-}
-
 // Image Tile Data Source
 
 export type ImageTileDataSourceCapabilities = {
@@ -54,4 +42,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/wms",
-  "version": "3.3.0-alpha.13",
+  "version": "3.3.0-alpha.14",
   "description": "Framework-independent loaders for the WMS (Web Map Service) standard",
   "license": "MIT",
   "publishConfig": {
@@ -39,10 +39,10 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/images": "3.3.0-alpha.13",
-    "@loaders.gl/loader-utils": "3.3.0-alpha.13",
-    "@loaders.gl/schema": "3.3.0-alpha.13",
-    "@loaders.gl/xml": "3.3.0-alpha.13",
+    "@loaders.gl/images": "3.3.0-alpha.14",
+    "@loaders.gl/loader-utils": "3.3.0-alpha.14",
+    "@loaders.gl/schema": "3.3.0-alpha.14",
+    "@loaders.gl/xml": "3.3.0-alpha.14",
     "@turf/rewind": "^5.1.5",
     "deep-strict-equal": "^0.2.0",
     "lerc": "^4.0.1"
@@ -50,5 +50,5 @@
   "devDependencies": {
     "xmldom": "0.6.0"
   },
-  "gitHead": "429a5667c9903cc2de4d1f3e55e1c2f2e58a3ff6"
+  "gitHead": "cc91201ca3c0581a5c9edf7a8bc0fc230212bf3d"
 }

package/src/index.ts

@@ -9,14 +9,18 @@ export type {WMSLoaderOptions} from './wms-capabilities-loader';
 export type {WMSCapabilities} from './lib/wms/wms-types';
 export {WMSCapabilitiesLoader} from './wms-capabilities-loader';
 
-export type {WMSServiceProps} from './lib/data-sources/wms-service';
-export {WMSService} from './lib/data-sources/wms-service';
-
 // NOTE: Will likely move to tiles module
-export type {ImageSourceMetadata as _ImageSourceMetadata} from './lib/data-sources/image-source';
-export {ImageSource as _ImageSource} from './lib/data-sources/image-source';
+export type {ImageSourceMetadata} from './lib/data-sources/image-source';
+export type {ImageType} from '@loaders.gl/images';
+export {ImageSource} from './lib/data-sources/image-source';
+
+export type {ImageServiceType} from './lib/data-sources/create-image-source';
+export {createImageSource} from './lib/data-sources/create-image-source';
 
-export {AdHocImageService as _AdHocImageService} from './lib/data-sources/adhoc-image-service';
+export type {ImageServiceProps} from './lib/data-sources/image-services/image-service';
+export {ImageService} from './lib/data-sources/image-services/image-service';
+export {WMSService} from './lib/data-sources/image-services/wms-service';
+export {ArcGISImageService as _ArcGISImageService} from './lib/data-sources/image-services/arcgis-image-service';
 
 // WIP /////////////////////////////////////////////////////////////////
 // Plumbing set up but details of parsing and typing not yet completed
@@ -49,5 +53,6 @@ export {GMLLoader as _GMLLoader} from './wip/gml-loader';
 
 // LERC
 
-export type {LERCData} from './lib/lerc/lerc-types';
-export {LERCLoader} from './lerc-loader';
+// TODO - restore once esbuild bundling issues have been resolved
+// export type {LERCData} from './lib/lerc/lerc-types';
+// export {LERCLoader} from './lerc-loader';

package/src/lib/data-sources/adhoc-image-service.ts

@@ -17,6 +17,9 @@ export type AdHocImageServiceProps = {
  * Accepts a template url string and builds requests URLs
  */
 export class AdHocImageService extends ImageSource {
+  static type: 'template' = 'template';
+  static testURL = (url: string): boolean => url.toLowerCase().includes('{');
+
   templateUrl: string;
 
   constructor(props: AdHocImageServiceProps) {

package/src/lib/data-sources/arcgis-image-service.ts

@@ -0,0 +1,146 @@
+// loaders.gl, MIT license
+
+import {LoaderOptions} from '@loaders.gl/loader-utils';
+import {/* ImageLoader, */ ImageType} from '@loaders.gl/images';
+import type {ImageSourceMetadata, GetImageParameters} from './image-source';
+import {ImageSource} from './image-source';
+
+type FetchLike = (url: string, options?: RequestInit) => Promise<Response>;
+
+export type ArcGISImageServiceProps = {
+  url: string;
+  loadOptions?: LoaderOptions;
+  fetch?: typeof fetch | FetchLike;
+};
+
+export class ArcGISImageService extends ImageSource {
+  static type: 'arcgis-image-server' = 'arcgis-image-server';
+  static testURL = (url: string): boolean => url.toLowerCase().includes('ImageServer');
+
+  url: string;
+  loadOptions: LoaderOptions;
+  fetch: typeof fetch | FetchLike;
+
+  constructor(props: ArcGISImageServiceProps) {
+    super();
+    this.url = props.url;
+    this.loadOptions = props.loadOptions || {};
+    this.fetch = props.fetch || fetch;
+  }
+
+  // ImageSource (normalized endpoints)
+
+  async getMetadata(): Promise<ImageSourceMetadata> {
+    return (await this.info()) as ImageSourceMetadata;
+    // TODO - normalize metadata
+  }
+
+  async getImage(parameters: GetImageParameters): Promise<ImageType> {
+    throw new Error('not implemented');
+    // TODO - Map generic parameters to ArcGIS specific parameters
+    // return await this.exportImage(parameters);
+  }
+
+  // ImageServer endpoints
+
+  async info(): Promise<unknown> {
+    // We just need a JSON parsing...
+    // return this.getUrl({path: '', ...options});
+    throw new Error('not implemented');
+  }
+
+  /** 
+   * Form a URL to an ESRI ImageServer
+   // https://sampleserver6.arcgisonline.com/arcgis/rest/services/NLCDLandCover2001/ImageServer/exportImage?bbox=${bounds[0]},${bounds[1]},${bounds[2]},${bounds[3]}&bboxSR=4326&size=${width},${height}&imageSR=102100&time=&format=jpgpng&pixelType=U8&noData=&noDataInterpretation=esriNoDataMatchAny&interpolation=+RSP_NearestNeighbor&compression=&compressionQuality=&bandIds=&mosaicRule=&renderingRule=&f=image`,
+   */
+  exportImage(options: {
+    boundingBox: [number, number, number, number];
+    boundingBoxSR?: string;
+    width: number;
+    height: number;
+    imageSR?: string;
+    time?: never;
+    format?: 'jpgpng';
+    pixelType?: 'U8';
+    noData?: never;
+    noDataInterpretation?: 'esriNoDataMatchAny';
+    interpolation?: '+RSP_NearestNeighbor';
+    compression?: never;
+    compressionQuality?: never;
+    bandIds?: never;
+    mosaicRule?: never;
+    renderingRule?: never;
+    f?: 'image';
+  }): Promise<ImageType> {
+    // See WMSService.getMap()
+    throw new Error('not implemented');
+  }
+
+  // URL creators
+
+  infoURL(options: {parameters?: Record<string, unknown>}): string {
+    return this.url;
+    // return this.getUrl({path: '', ...options});
+  }
+
+  /** 
+   * Form a URL to an ESRI ImageServer
+   // https://sampleserver6.arcgisonline.com/arcgis/rest/services/NLCDLandCover2001/ImageServer/exportImage?bbox=${bounds[0]},${bounds[1]},${bounds[2]},${bounds[3]}&bboxSR=4326&size=${width},${height}&imageSR=102100&time=&format=jpgpng&pixelType=U8&noData=&noDataInterpretation=esriNoDataMatchAny&interpolation=+RSP_NearestNeighbor&compression=&compressionQuality=&bandIds=&mosaicRule=&renderingRule=&f=image`,
+   */
+  exportImageURL(options: {
+    boundingBox: [number, number, number, number];
+    boundingBoxSR?: string;
+    width: number;
+    height: number;
+    imageSR?: string;
+    time?: never;
+    format?: 'jpgpng';
+    pixelType?: 'U8';
+    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'});
+    return this.url;
+  }
+
+  // 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 getUrl(options: Record<string, unknown>, extra?: Record<string, unknown>): string {
+    let url = `${this.url}`;
+    let first = true;
+    for (const [key, value] of Object.entries(options)) {
+      url += first ? '?' : '&';
+      first = false;
+      if (Array.isArray(value)) {
+        url += `${key.toUpperCase()}=${value.join(',')}`;
+      } else {
+        url += `${key.toUpperCase()}=${value ? String(value) : ''}`;
+      }
+    }
+    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');
+    }
+  }
+}

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

@@ -0,0 +1,46 @@
+// loaders.gl, MIT license
+
+import {ImageSource} from './image-source';
+import {ImageService, ImageServiceProps} from './image-services/image-service';
+import {WMSService} from './image-services/wms-service';
+import {ArcGISImageService} from './image-services/arcgis-image-service';
+
+export type ImageServiceType = 'wms' | 'arcgis-image-server' | 'template';
+
+const SERVICES = [WMSService, ArcGISImageService, ImageService];
+
+type Props = ImageServiceProps & {
+  type?: ImageServiceType | 'auto';
+};
+
+/**
+ * Creates an image source
+ * If type is not supplied, will try to automatically detec the the
+ * @param url URL to the image source
+ * @param type type of source. if not known, set to 'auto'
+ * @returns an ImageSource instance
+ */
+export function createImageSource(props: Props): ImageSource {
+  const {type = 'auto'} = props;
+  const serviceType = type === 'auto' ? guessServiceType(props.url) : type;
+  switch (serviceType) {
+    case 'template':
+      return new ImageService(props);
+    case 'wms':
+      return new WMSService(props);
+    default:
+      // currently only wms service supported
+      throw new Error('Not a valid image source type');
+  }
+}
+
+/** Guess service type from URL */
+function guessServiceType(url: string): ImageServiceType {
+  for (const Service of SERVICES) {
+    if (Service.testURL && Service.testURL(url)) {
+      return Service.type;
+    }
+  }
+  // If all else fails, guess that this is MS service
+  return 'wms';
+}

package/src/lib/data-sources/image-services/arcgis-image-service.ts

@@ -0,0 +1,136 @@
+// loaders.gl, MIT license
+
+import {ImageType} from '@loaders.gl/images';
+import type {ImageSourceMetadata, GetImageParameters} from '../image-source';
+import {ImageSource} from '../image-source';
+import {ImageServiceProps, mergeImageServiceProps, getFetchFunction} from './image-service';
+
+export class ArcGISImageService extends ImageSource {
+  static type: 'arcgis-image-server' = 'arcgis-image-server';
+  static testURL = (url: string): boolean => url.toLowerCase().includes('ImageServer');
+
+  props: Required<ImageServiceProps>;
+  fetch: (url: string, options?: RequestInit) => Promise<Response>;
+
+  constructor(props: ImageServiceProps) {
+    super();
+    this.props = mergeImageServiceProps(props);
+    this.fetch = getFetchFunction(this.props);
+  }
+
+  // ImageSource (normalized endpoints)
+
+  async getMetadata(): Promise<ImageSourceMetadata> {
+    return (await this.info()) as ImageSourceMetadata;
+    // TODO - normalize metadata
+  }
+
+  async getImage(parameters: GetImageParameters): Promise<ImageType> {
+    throw new Error('not implemented');
+    // TODO - Map generic parameters to ArcGIS specific parameters
+    // return await this.exportImage(parameters);
+  }
+
+  // ImageServer endpoints
+
+  async info(): Promise<unknown> {
+    // We just need a JSON parsing...
+    // return this.getUrl({path: '', ...options});
+    throw new Error('not implemented');
+  }
+
+  /** 
+   * Form a URL to an ESRI ImageServer
+   // https://sampleserver6.arcgisonline.com/arcgis/rest/services/NLCDLandCover2001/ImageServer/exportImage?bbox=${bounds[0]},${bounds[1]},${bounds[2]},${bounds[3]}&bboxSR=4326&size=${width},${height}&imageSR=102100&time=&format=jpgpng&pixelType=U8&noData=&noDataInterpretation=esriNoDataMatchAny&interpolation=+RSP_NearestNeighbor&compression=&compressionQuality=&bandIds=&mosaicRule=&renderingRule=&f=image`,
+   */
+  exportImage(options: {
+    boundingBox: [number, number, number, number];
+    boundingBoxSR?: string;
+    width: number;
+    height: number;
+    imageSR?: string;
+    time?: never;
+    format?: 'jpgpng';
+    pixelType?: 'U8';
+    noData?: never;
+    noDataInterpretation?: 'esriNoDataMatchAny';
+    interpolation?: '+RSP_NearestNeighbor';
+    compression?: never;
+    compressionQuality?: never;
+    bandIds?: never;
+    mosaicRule?: never;
+    renderingRule?: never;
+    f?: 'image';
+  }): Promise<ImageType> {
+    // See WMSService.getMap()
+    throw new Error('not implemented');
+  }
+
+  // URL creators
+
+  infoURL(options: {parameters?: Record<string, unknown>}): string {
+    return this.props.url;
+    // return this.getUrl({path: '', ...options});
+  }
+
+  /** 
+   * Form a URL to an ESRI ImageServer
+   // https://sampleserver6.arcgisonline.com/arcgis/rest/services/NLCDLandCover2001/ImageServer/exportImage?bbox=${bounds[0]},${bounds[1]},${bounds[2]},${bounds[3]}&bboxSR=4326&size=${width},${height}&imageSR=102100&time=&format=jpgpng&pixelType=U8&noData=&noDataInterpretation=esriNoDataMatchAny&interpolation=+RSP_NearestNeighbor&compression=&compressionQuality=&bandIds=&mosaicRule=&renderingRule=&f=image`,
+   */
+  exportImageURL(options: {
+    boundingBox: [number, number, number, number];
+    boundingBoxSR?: string;
+    width: number;
+    height: number;
+    imageSR?: string;
+    time?: never;
+    format?: 'jpgpng';
+    pixelType?: 'U8';
+    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'});
+    return this.props.url;
+  }
+
+  // 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 getUrl(options: Record<string, unknown>, extra?: Record<string, unknown>): string {
+    let url = `${this.props.url}`;
+    let first = true;
+    for (const [key, value] of Object.entries(options)) {
+      url += first ? '?' : '&';
+      first = false;
+      if (Array.isArray(value)) {
+        url += `${key.toUpperCase()}=${value.join(',')}`;
+      } else {
+        url += `${key.toUpperCase()}=${value ? String(value) : ''}`;
+      }
+    }
+    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');
+    }
+  }
+}

package/src/lib/data-sources/image-services/image-service.ts

@@ -0,0 +1,105 @@
+// loaders.gl, MIT license
+
+import {LoaderOptions} from '@loaders.gl/loader-utils';
+import type {ImageType} from '@loaders.gl/images';
+import {ImageLoader} from '@loaders.gl/images';
+
+import type {ImageSourceMetadata, GetImageParameters} from '../image-source';
+import {ImageSource} from '../image-source';
+
+/** Template URL string should contain `${width}` etc which will be substituted. */
+export type ImageServiceProps = {
+  /** Base URL to the service */
+  url: string;
+  /** Any load options to the loaders.gl Loaders used by the WMSService methods */
+  loadOptions?: LoaderOptions;
+};
+
+/**
+ * Quickly connect to "ad hoc" image sources without subclassing ImageSource.
+ * ImageSource allows template url strings to be used to ad hoc connect to arbitrary image data sources
+ * Accepts a template url string and builds requests URLs
+ */
+export class ImageService extends ImageSource {
+  static type: 'template' = 'template';
+  static testURL = (url: string): boolean => url.toLowerCase().includes('{');
+
+  props: Required<ImageServiceProps>;
+  fetch: (url: string, options?: RequestInit) => Promise<Response>;
+
+  constructor(props: ImageServiceProps) {
+    super();
+    this.props = mergeImageServiceProps(props);
+    this.fetch = getFetchFunction(props);
+  }
+
+  // IMAGE SOURCE API
+
+  async getMetadata(): Promise<ImageSourceMetadata> {
+    throw new Error('ImageSource.getMetadata not implemented');
+  }
+
+  async getImage(parameters: GetImageParameters): Promise<ImageType> {
+    const granularParameters = this.getGranularParameters(parameters);
+    const url = this.getURLFromTemplate(granularParameters);
+    const response = await this.fetch(url);
+    const arrayBuffer = await response.arrayBuffer();
+    return await ImageLoader.parse(arrayBuffer);
+  }
+
+  // HELPERS
+
+  /** Break up bounding box in east, north, south, west */
+  protected getGranularParameters(parameters: GetImageParameters): Record<string, unknown> {
+    const [east, north, west, south] = parameters.bbox;
+    return {...parameters, east, north, south, west};
+  }
+
+  /** Supports both ${} and {} notations */
+  protected getURLFromTemplate(parameters: Record<string, unknown>): string {
+    let url = this.props.url;
+    for (const [key, value] of Object.entries(parameters)) {
+      // TODO - parameter could be repeated
+      // const regex = new RegExp(`\${${key}}`, 'g');
+      url = url.replace(`\${${key}}`, String(value));
+      url = url.replace(`{${key}}`, String(value));
+    }
+    return url;
+  }
+}
+
+/**
+ * Gets the current fetch function from options
+ * @todo - move to loader-utils module
+ * @todo - use in core module counterpart
+ * @param options
+ * @param context
+ */
+export function getFetchFunction(options?: LoaderOptions) {
+  const fetchFunction = options?.fetch;
+
+  // options.fetch can be a function
+  if (fetchFunction && typeof fetchFunction === 'function') {
+    return (url: string, fetchOptions?: RequestInit) => fetchFunction(url, fetchOptions);
+  }
+
+  // options.fetch can be an options object, use global fetch with those options
+  const fetchOptions = options?.fetch;
+  if (fetchOptions && typeof fetchOptions !== 'function') {
+    return (url) => fetch(url, fetchOptions);
+  }
+
+  // else return the global fetch function
+  return (url) => fetch(url);
+}
+
+export function mergeImageServiceProps(props: ImageServiceProps): Required<ImageServiceProps> {
+  return {
+    // Default fetch
+    ...props,
+    loadOptions: {
+      ...props.loadOptions,
+      fetch: getFetchFunction(props.loadOptions)
+    }
+  };
+}