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

package/dist/wip/wmts-capabilities-loader.js

@@ -0,0 +1,31 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckWMTSCapabilitiesLoader = exports.WMTSCapabilitiesLoader = void 0;
+const parse_wmts_1 = require("../lib/wmts/parse-wmts");
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+/**
+ * Loader for the response to the WMTS GetCapability request
+ */
+exports.WMTSCapabilitiesLoader = {
+    id: 'wmts-capabilities',
+    name: 'WMTS Capabilities',
+    module: 'wms',
+    version: VERSION,
+    worker: false,
+    extensions: ['xml'],
+    mimeTypes: ['application/vnd.ogc.wmts_xml', 'application/xml', 'text/xml'],
+    testText: testXMLFile,
+    options: {
+        wms: {}
+    },
+    parse: async (arrayBuffer, options) => (0, parse_wmts_1.parseWMTSCapabilities)(new TextDecoder().decode(arrayBuffer), options),
+    parseTextSync: (text, options) => (0, parse_wmts_1.parseWMTSCapabilities)(text, options)
+};
+function testXMLFile(text) {
+    // TODO - There could be space first.
+    return text.startsWith('<?xml');
+}
+exports._typecheckWMTSCapabilitiesLoader = exports.WMTSCapabilitiesLoader;

package/dist/wms-capabilities-loader.d.ts

@@ -0,0 +1,26 @@
+import type { LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
+export type WMSLoaderOptions = LoaderOptions & {
+    wms?: {};
+};
+/**
+ * Loader for the response to the WMS GetCapability request
+ */
+export declare const WMSCapabilitiesLoader: {
+    id: string;
+    name: string;
+    module: string;
+    version: any;
+    worker: boolean;
+    extensions: string[];
+    mimeTypes: string[];
+    testText: typeof testXMLFile;
+    options: {
+        wms: {};
+    };
+    parse: (arrayBuffer: ArrayBuffer, options?: WMSLoaderOptions) => Promise<import(".").WMSCapabilities>;
+    parseTextSync: (text: string, options?: WMSLoaderOptions) => import(".").WMSCapabilities;
+};
+declare function testXMLFile(text: string): boolean;
+export declare const _typecheckWMSCapabilitiesLoader: LoaderWithParser;
+export {};
+//# sourceMappingURL=wms-capabilities-loader.d.ts.map

package/dist/wms-capabilities-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wms-capabilities-loader.d.ts","sourceRoot":"","sources":["../src/wms-capabilities-loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAO9E,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE,EAAE,CAAC;CACV,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;yBAaL,WAAW,YAAY,gBAAgB;0BAE5C,MAAM,YAAY,gBAAgB;CACzD,CAAC;AAEF,iBAAS,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAG1C;AAED,eAAO,MAAM,+BAA+B,EAAE,gBAAwC,CAAC"}

package/dist/wms-capabilities-loader.js

@@ -0,0 +1,31 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckWMSCapabilitiesLoader = exports.WMSCapabilitiesLoader = void 0;
+const parse_wms_1 = require("./lib/wms/parse-wms");
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+/**
+ * Loader for the response to the WMS GetCapability request
+ */
+exports.WMSCapabilitiesLoader = {
+    id: 'wms-capabilities',
+    name: 'WMS Capabilities',
+    module: 'wms',
+    version: VERSION,
+    worker: false,
+    extensions: ['xml'],
+    mimeTypes: ['application/vnd.ogc.wms_xml', 'application/xml', 'text/xml'],
+    testText: testXMLFile,
+    options: {
+        wms: {}
+    },
+    parse: async (arrayBuffer, options) => (0, parse_wms_1.parseWMSCapabilities)(new TextDecoder().decode(arrayBuffer), options),
+    parseTextSync: (text, options) => (0, parse_wms_1.parseWMSCapabilities)(text, options)
+};
+function testXMLFile(text) {
+    // TODO - There could be space first.
+    return text.startsWith('<?xml');
+}
+exports._typecheckWMSCapabilitiesLoader = exports.WMSCapabilitiesLoader;

package/dist/wms-error-loader.d.ts

@@ -0,0 +1,34 @@
+import type { LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
+export type WMSLoaderOptions = LoaderOptions & {
+    wms?: {
+        /** By default the error loader will throw an error with the parsed error message */
+        throwOnError?: boolean;
+        /** Do not add any text to errors */
+        minimalErrors?: boolean;
+    };
+};
+/**
+ * Loader for the response to the WMS GetCapability request
+ */
+export declare const WMSErrorLoader: {
+    id: string;
+    name: string;
+    module: string;
+    version: any;
+    worker: boolean;
+    extensions: string[];
+    mimeTypes: string[];
+    testText: typeof testXMLFile;
+    options: {
+        wms: {
+            throwOnError: boolean;
+        };
+    };
+    parse: (arrayBuffer: ArrayBuffer, options?: WMSLoaderOptions) => Promise<string>;
+    parseSync: (arrayBuffer: ArrayBuffer, options?: WMSLoaderOptions) => string;
+    parseTextSync: (text: string, options?: WMSLoaderOptions) => string;
+};
+declare function testXMLFile(text: string): boolean;
+export declare const _typecheckWMSErrorLoader: LoaderWithParser;
+export {};
+//# sourceMappingURL=wms-error-loader.d.ts.map

package/dist/wms-error-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wms-error-loader.d.ts","sourceRoot":"","sources":["../src/wms-error-loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAO9E,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE;QACJ,oFAAoF;QACpF,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,oCAAoC;QACpC,aAAa,CAAC,EAAE,OAAO,CAAC;KACzB,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;yBAeE,WAAW,YAAY,gBAAgB,KAAG,QAAQ,MAAM,CAAC;6BAE3D,WAAW,YAAY,gBAAgB,KAAG,MAAM;0BAEnD,MAAM,YAAY,gBAAgB,KAAG,MAAM;CAClE,CAAC;AAEF,iBAAS,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAG1C;AAYD,eAAO,MAAM,wBAAwB,EAAE,gBAAiC,CAAC"}

package/dist/wms-error-loader.js

@@ -0,0 +1,43 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckWMSErrorLoader = exports.WMSErrorLoader = void 0;
+const parse_wms_1 = require("./lib/wms/parse-wms");
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+/**
+ * Loader for the response to the WMS GetCapability request
+ */
+exports.WMSErrorLoader = {
+    id: 'wms-error',
+    name: 'WMS Error',
+    module: 'wms',
+    version: VERSION,
+    worker: false,
+    extensions: ['xml'],
+    mimeTypes: ['application/vnd.ogc.se_xml', 'application/xml', 'text/xml'],
+    testText: testXMLFile,
+    options: {
+        wms: {
+            throwOnError: false
+        }
+    },
+    parse: async (arrayBuffer, options) => parseTextSync(new TextDecoder().decode(arrayBuffer), options),
+    parseSync: (arrayBuffer, options) => parseTextSync(new TextDecoder().decode(arrayBuffer), options),
+    parseTextSync: (text, options) => parseTextSync(text, options)
+};
+function testXMLFile(text) {
+    // TODO - There could be space first.
+    return text.startsWith('<?xml');
+}
+function parseTextSync(text, options) {
+    const wmsOptions = { ...exports.WMSErrorLoader.options.wms, ...options?.wms };
+    const error = (0, parse_wms_1.parseWMSError)(text, wmsOptions);
+    const message = wmsOptions.minimalErrors ? error : `WMS Service error: ${error}`;
+    if (wmsOptions.throwOnError) {
+        throw new Error(message);
+    }
+    return message;
+}
+exports._typecheckWMSErrorLoader = exports.WMSErrorLoader;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/wms",
-  "version": "3.3.0-alpha.9",
+  "version": "3.3.0",
   "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",
@@ -29,15 +35,20 @@
   ],
   "scripts": {
     "pre-build": "npm run build-bundle",
-    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js --platform=node"
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "3.3.0-alpha.9",
-    "@loaders.gl/schema": "3.3.0-alpha.9"
+    "@loaders.gl/images": "3.3.0",
+    "@loaders.gl/loader-utils": "3.3.0",
+    "@loaders.gl/schema": "3.3.0",
+    "@loaders.gl/xml": "3.3.0",
+    "@turf/rewind": "^5.1.5",
+    "deep-strict-equal": "^0.2.0",
+    "lerc": "^4.0.1"
   },
   "devDependencies": {
     "xmldom": "0.6.0"
   },
-  "gitHead": "c95a4ff72512668a93d9041ce8636bac09333fd5"
+  "gitHead": "566d194f175a03e042d3e588cdd514048f428cc1"
 }

package/src/index.ts

@@ -1,13 +1,58 @@
 // loaders.gl, MIT license
 
-// WMSCapabilitiesLoader
+// WMS
 
-export type {WMSCapabilities, WMSFeatureInfo, WMSLayerDescription} from './wms-types';
+export {WMSErrorLoader} from './wms-error-loader';
 
 export type {WMSLoaderOptions} from './wms-capabilities-loader';
+
+export type {WMSCapabilities} from './lib/wms/wms-types';
 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';
+// NOTE: Will likely move to tiles module
+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 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
+
+// WMS
+
+export type {WMSFeatureInfo as _WMSFeatureInfo} from './lib/wms/wms-types';
+export {WMSFeatureInfoLoader as _WMSFeatureInfoLoader} from './wip/wms-feature-info-loader';
+
+export type {WMSLayerDescription as _WMSLayerDescription} from './lib/wms/wms-types';
+export {WMSLayerDescriptionLoader as _WMSLayerDescriptionLoader} from './wip/wms-layer-description-loader';
+
+// WMTS
+
+export type {WMTSCapabilities as _WMTSCapabilities} from './lib/wmts/wmts-types';
+export type {WMTSLoaderOptions as _WMTSLoaderOptions} from './wip/wmts-capabilities-loader';
+export {WMTSCapabilitiesLoader as _WMTSCapabilitiesLoader} from './wip/wmts-capabilities-loader';
+
+// WFS
+
+export type {WFSCapabilities as _WFSCapabilities} from './lib/wfs/wfs-types';
+export type {WFSLoaderOptions as _WFSLoaderOptions} from './wip/wfs-capabilities-loader';
+export {WFSCapabilitiesLoader as _WFSCapabilitiesLoader} from './wip/wfs-capabilities-loader';
+
+// GML
+
+export type {GeoJSON as _GeoJSON} from '@loaders.gl/schema';
+export type {GMLLoaderOptions as _GMLLoaderOptions} from './wip/gml-loader';
+export {GMLLoader as _GMLLoader} from './wip/gml-loader';
+
+// LERC
+
+// TODO - restore once esbuild bundling issues have been resolved
+// export type {LERCData} from './lib/lerc/lerc-types';
+// export {LERCLoader} from './lerc-loader';

package/src/lerc-loader.ts

@@ -0,0 +1,50 @@
+// loaders.gl, MIT license
+
+import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+import type {LERCData} from './lib/lerc/lerc-types';
+import * as Lerc from 'lerc';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+export type LERCLoaderOptions = LoaderOptions & {
+  lerc?: {
+    /**	The number of bytes to skip in the input byte stream. A valid Lerc file is expected at that position. */
+    inputOffset?: number;
+    /**	It is recommended to use the returned mask instead of setting this value. */
+    noDataValue?: number;
+    /**	(ndepth LERC2 only) If true, returned depth values are pixel-interleaved. */
+    returnInterleaved?: boolean;
+  };
+};
+
+/**
+ * Loader for the LERC raster format
+ */
+export const LERCLoader = {
+  id: 'lerc',
+  name: 'LERC',
+
+  module: 'wms',
+  version: VERSION,
+  worker: false,
+  extensions: ['lrc', 'lerc', 'lerc2', 'lerc1'],
+  mimeTypes: ['application/octet-stream'],
+  // test: ?,
+  options: {
+    wms: {}
+  },
+  parse: async (arrayBuffer: ArrayBuffer, options?: LERCLoaderOptions) =>
+    parseLERC(arrayBuffer, options)
+};
+
+async function parseLERC(arrayBuffer: ArrayBuffer, options?: LERCLoaderOptions): Promise<LERCData> {
+  // Load the WASM library
+  await Lerc.load();
+  // Perform the decode
+  const pixelBlock = Lerc.decode(arrayBuffer, options?.lerc);
+  return pixelBlock;
+}
+
+export const _typecheckLERCLoader: LoaderWithParser = LERCLoader;

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

@@ -0,0 +1,61 @@
+// loaders.gl, MIT license
+
+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';
+
+export type AdHocImageServiceProps = {
+  /** Template URL string should contain `${width}` etc which will be substituted. */
+  templateUrl: string;
+};
+
+/**
+ * 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 AdHocImageService extends ImageSource {
+  static type: 'template' = 'template';
+  static testURL = (url: string): boolean => url.toLowerCase().includes('{');
+
+  templateUrl: string;
+
+  constructor(props: AdHocImageServiceProps) {
+    super();
+    this.templateUrl = props.templateUrl;
+  }
+
+  // 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 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};
+  }
+
+  protected getURLFromTemplate(parameters: Record<string, unknown>): string {
+    let url = this.templateUrl;
+    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));
+    }
+    return url;
+  }
+}

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