@loaders.gl/wms 3.4.0-alpha.1 → 3.4.0-alpha.3

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

@@ -0,0 +1,361 @@
+// loaders.gl, MIT license
+
+import {XMLLoader} from '@loaders.gl/xml';
+import {
+  getXMLArray,
+  getXMLStringArray,
+  getXMLInteger,
+  getXMLFloat,
+  getXMLBoolean
+} from '../xml/parse-xml-helpers';
+
+/** All capabilities of a WMS service - response to a WMS `GetCapabilities` data structure extracted from XML */
+export type WMSCapabilities = {
+  /** Version of the WMS service */
+  version?: string; // '1.3.0' | '1.1.1' | '1.1.0' | '1.0.0'
+  /** A short name for the service */
+  name: string;
+  /** A human readable name for the service */
+  title?: string;
+  /** A more extensive description of the service */
+  abstract?: string;
+  /** A set of keywords e.g. for searching services */
+  keywords: string[];
+  /** A field of unspecified format, if present describes any access constraints required to use the service. */
+  accessConstraints?: string;
+  /** A field of unspecified format, if present describes any fees associated with the use of the service */
+  fees?: string;
+  /** If present, the max number of layers that can be rendered by the service */
+  layerLimit?: number;
+  /** If present, the widest image that can be rendered by the service */
+  maxWidth?: number;
+  /** If present, the tallest image that can be rendered by the service */
+  maxHeight?: number;
+  /** Hierarchical list of layers. */
+  layers: WMSLayer[];
+  /** A map with information about supported WMS requests. If a record is present, the request is supported by the service */
+  requests: Record<string, WMSRequest>;
+  /** Information about any exceptions that the service will report (HTTP status != 2xx) */
+  exceptions?: WMSExceptions;
+  /** Only if `options.raw`: raw untyped JSON parsed from XML. Can include information not extracted in the typed response. */
+  raw?: Record<string, unknown>;
+  /** Only if `options.xml`, the unparsed XML string can be requested */
+  xml?: string;
+};
+
+/**
+ * Metadata about a layer
+ * Layers inherit many properties from their parent layers, see description of individual props for details.
+ * @see https://www.ogc.org/standard/wms/ 7.2.4.6
+ */
+export type WMSLayer = {
+  /** The title is a human readable name. It is mandatory on each layer. Not inherited.  */
+  title: string;
+  /** A layer is renderable if it has a name. A named parent layer will render all its sublayers. Not inherited. */
+  name?: string;
+  /** A narrative description of the map layer. */
+  abstract?: string;
+  /** A set of keywords e.g. for searching layers */
+  keywords: string[];
+  /** layer limits in unspecified CRS:84-like lng/lat, for quick access w/o CRS calculations.  Defined or inherited. */
+  geographicBoundingBox?: [min: [x: number, y: number], max: [x: number, y: number]];
+  /** Supported CRS. Either defined or inherited. */
+  crs?: string[];
+  /** Bounding boxes in specific CRS:es */
+  boundingBoxes?: WMSBoundingBox[];
+
+  // minScale: number;
+  // maxScale: number;
+  // dimensions: ?? 7.2.4.6.10
+  // MetadataURL
+  // Attribution
+  // Identifier and AuthorityURL
+  // FeatureListURL
+  // DataURL
+
+  /** Whether queries can be performed on the layer */
+  queryable?: boolean;
+  /** `false` if layer has significant no-data areas that the client can display as transparent. */
+  opaque?: boolean;
+  /** WMS cascading allows server to expose layers coming from other WMS servers as if they were local layers */
+  cascaded?: boolean;
+  // noSubsets: boolean
+  // fixedWith: number
+  // fixedHeight: number
+
+  /** A list of styles. @note not yet supported by WMSCapabilitiesLoader */
+  styles?: unknown[];
+
+  /** Sublayers - these inherit crs and boundingBox) if not overridden) */
+  layers?: WMSLayer[];
+};
+
+/**
+ * A bounding box specifies the coordinate range for data in the layer.
+ * No data is available outside the bounding box.
+ */
+export type WMSBoundingBox = {
+  /** CRS indicates the Layer CRS that applies to this bounding box. */
+  crs: string;
+  /** `[[w, s], [e, n]]`, indicates the limits of the bounding box using the axis units and order of the specified CRS. */
+  boundingBox: [min: [x: number, y: number], max: [x: number, y: number]];
+  /** Spatial horizontal resolution of data in same units as bounding box */
+  xResolution?: number;
+  /** Spatial vertical resolution of data in same units as bounding box */
+  yResolution?: number;
+};
+
+/** Metadata about a supported WMS request  */
+export type WMSRequest = {
+  /** MIMEtypes that can be returned by this request. */
+  mimeTypes: string[];
+};
+
+export type WMSExceptions = {
+  /** MIME types for exception response payloads. */
+  mimeTypes: string[];
+};
+
+export type parseWMSCapabilitiesOptions = {
+  /** Add inherited layer information to sub layers */
+  inheritedLayerProps?: boolean;
+  /** Include the "raw" JSON (parsed but untyped, unprocessed XML). May contain additional fields */
+  includeRawData?: boolean;
+  /** Include the original XML document text. May contain additional information. */
+  includeXMLText?: boolean;
+  /** @deprecated Use includeRawData` */
+  raw?: boolean;
+
+  // xml options are passed through to xml loader
+};
+
+/**
+ * Parses a typed data structure from raw XML for `GetCapabilities` response
+ * @note Error handlings is fairly weak
+ */
+export function parseWMSCapabilities(
+  xmlText: string,
+  options?: parseWMSCapabilitiesOptions
+): WMSCapabilities {
+  const parsedXML = XMLLoader.parseTextSync(xmlText, options);
+  const xmlCapabilities: any =
+    parsedXML.WMT_MS_Capabilities || parsedXML.WMS_Capabilities || parsedXML;
+  const capabilities = extractCapabilities(xmlCapabilities);
+  // In case the processed, normalized capabilities do not contain everything,
+  // the user can get the parsed XML structure.
+  if (options?.inheritedLayerProps) {
+    // Traverse layers and inject missing props from parents
+    for (const layer of capabilities.layers) {
+      addInheritedLayerProps(layer, null);
+    }
+    // Not yet implemented
+  }
+
+  if (options?.includeRawData || options?.raw) {
+    capabilities.raw = xmlCapabilities;
+  }
+
+  if (options?.includeXMLText) {
+    capabilities.xml = xmlText;
+  }
+
+  return capabilities;
+}
+
+/** Extract typed capability data from XML */
+function extractCapabilities(xml: any): WMSCapabilities {
+  const capabilities: WMSCapabilities = {
+    version: String(xml.version || ''),
+    name: String(xml.Service?.Name || 'unnamed'),
+    title: xml.Service?.Title ? String(xml.Service?.Title) : undefined,
+    abstract: xml.Service?.Abstract ? String(xml.Service?.Abstract) : undefined,
+    keywords: getXMLStringArray(xml.Service?.KeywordList?.Keyword),
+    fees: xml.Service?.Fees ? JSON.stringify(xml.Service?.Fees) : undefined,
+    accessConstraints: xml.Service?.AccessConstraints
+      ? JSON.stringify(xml.Service?.AccessConstraints)
+      : undefined,
+    layerLimit: getXMLInteger(xml.Service?.LayerLimit),
+    maxWidth: getXMLInteger(xml.Service?.maxWidth),
+    maxHeight: getXMLInteger(xml.Service?.maxHeight),
+    layers: [],
+    requests: extractRequests(xml.Capability?.Request),
+    exceptions: extractExceptions(xml.Exception)
+    // contact field is a mess of largely irrelevant information, put it last
+    // contact: xml.Service?.Contact ? JSON.stringify(xml.Service?.Contact) : undefined,
+  };
+
+  // LAYERS
+  const xmlLayers = getXMLArray(xml.Capability?.Layer);
+  for (const xmlSubLayer of xmlLayers) {
+    capabilities.layers.push(extractLayer(xmlSubLayer));
+  }
+
+  // Clean up object
+  for (const [key, value] of Object.entries(capabilities)) {
+    if (value === undefined) {
+      delete capabilities[key];
+    }
+  }
+
+  return capabilities;
+}
+
+/** Extract typed request metadata from XML requests field */
+function extractRequests(xmlRequests: any): Record<string, WMSRequest> {
+  const requests: Record<string, WMSRequest> = {};
+  for (const [name, xmlRequest] of Object.entries(xmlRequests || {}) as any) {
+    const mimeTypes = getXMLStringArray(xmlRequest?.Format);
+    requests[name] = {mimeTypes};
+  }
+  return requests;
+}
+
+function extractExceptions(xmlException: any): WMSExceptions | undefined {
+  const xmlExceptionFormats = getXMLArray(xmlException?.Format);
+  if (xmlExceptionFormats.length > 0) {
+    return {
+      mimeTypes: getXMLStringArray(xmlException)
+    };
+  }
+  return undefined;
+}
+
+/** Extract request data */
+// eslint-disable-next-line complexity, max-statements
+function extractLayer(xmlLayer: any): WMSLayer {
+  const layer: WMSLayer = {
+    // All layers must have a title
+    title: String(xmlLayer?.Title || ''),
+    // Name is required only if renderable
+    name: String(xmlLayer?.Name),
+    abstract: String(xmlLayer?.Abstract),
+    keywords: getXMLStringArray(xmlLayer.KeywordList?.Keyword)
+  };
+
+  // WMS 1.3.0 changes SRS to CRS
+  const crs = xmlLayer?.CRS || xmlLayer?.SRS;
+  if (crs && Array.isArray(crs) && crs.every((_) => typeof _ === 'string')) {
+    layer.crs = crs;
+  }
+
+  // v1.3.0 extract simple geographic bounding box
+  let geographicBoundingBox =
+    xmlLayer?.EX_GeographicBoundingBox && extractEXBoundingBox(xmlLayer?.EX_GeographicBoundingBox);
+  if (geographicBoundingBox) {
+    layer.geographicBoundingBox = geographicBoundingBox;
+  }
+
+  // v1.1.1 extract simple geographic bounding box
+  geographicBoundingBox =
+    xmlLayer?.LatLonBoundingBox && extractLatLonBoundingBox(xmlLayer?.LatLonBoundingBox);
+  if (geographicBoundingBox) {
+    layer.geographicBoundingBox = geographicBoundingBox;
+  }
+
+  // Extract per-CRS bounding boxes
+  const boundingBoxes = xmlLayer?.BoundingBox && extractWMSBoundingBoxes(xmlLayer?.BoundingBox);
+  if (boundingBoxes && boundingBoxes.length > 0) {
+    layer.boundingBoxes = boundingBoxes;
+  }
+
+  if (xmlLayer?.opaque) {
+    layer.opaque = getXMLBoolean(xmlLayer?.opaque);
+  }
+  if (xmlLayer?.cascaded) {
+    layer.cascaded = getXMLBoolean(xmlLayer?.cascaded);
+  }
+  if (xmlLayer?.queryable) {
+    layer.queryable = getXMLBoolean(xmlLayer?.queryable);
+  }
+
+  // Single layer is not represented as array in XML
+  const xmlLayers = getXMLArray(xmlLayer?.Layer);
+  const layers: WMSLayer[] = [];
+
+  for (const xmlSubLayer of xmlLayers) {
+    layers.push(extractLayer(xmlSubLayer));
+  }
+
+  if (layers.length > 0) {
+    layer.layers = layers;
+  }
+
+  // Clean up object
+  for (const [key, value] of Object.entries(layer)) {
+    if (value === undefined) {
+      delete layer[key];
+    }
+  }
+
+  return layer;
+}
+
+/** WMS 1.3.0 Loosely defined geospatial bounding box in unspecified CRS for quick content searches */
+function extractEXBoundingBox(xmlBoundingBox: any): [[number, number], [number, number]] {
+  const {
+    westBoundLongitude: w,
+    northBoundLatitude: n,
+    eastBoundLongitude: e,
+    southBoundLatitude: s
+  } = xmlBoundingBox;
+  return [
+    [w, s],
+    [e, n]
+  ];
+}
+
+/** WMS 1.1.1 Loosely defined geospatial bounding box in unspecified CRS for quick content searches */
+function extractLatLonBoundingBox(xmlBoundingBox: any): [[number, number], [number, number]] {
+  const {minx, miny, maxx, maxy} = xmlBoundingBox;
+  return [
+    [minx, miny],
+    [maxx, maxy]
+  ];
+}
+
+/** Loosely defined geospatial bounding box in unspecified CRS for quick content searches */
+function extractWMSBoundingBoxes(xmlBoundingBoxes: any): WMSBoundingBox[] {
+  const xmlBoxes = getXMLArray(xmlBoundingBoxes);
+  return xmlBoxes.map((xmlBox) => extractWMSBoundingBox(xmlBox));
+}
+
+/** Loosely defined geospatial bounding box in unspecified CRS for quick content searches */
+function extractWMSBoundingBox(xmlBoundingBox: any): WMSBoundingBox {
+  const {CRS, SRS, minx, miny, maxx, maxy, resx, resy} = xmlBoundingBox;
+  const boundingBox: WMSBoundingBox = {
+    // CRS in 1.3.0, SRS in 1.1.1
+    crs: CRS || SRS,
+    boundingBox: [
+      [getXMLFloat(minx) as number, getXMLFloat(miny) as number],
+      [getXMLFloat(maxx) as number, getXMLFloat(maxy) as number]
+    ]
+  };
+  if (resx) {
+    boundingBox.xResolution = resx;
+  }
+  if (resy) {
+    boundingBox.yResolution = resy;
+  }
+  return boundingBox;
+}
+
+/** Traverse layers and inject missing props from parents */
+function addInheritedLayerProps(layer: WMSLayer, parent: WMSLayer | null): void {
+  if (parent && parent.geographicBoundingBox && !layer.geographicBoundingBox) {
+    layer.geographicBoundingBox = [...parent.geographicBoundingBox];
+  }
+
+  if (parent && parent.crs && !layer.crs) {
+    layer.crs = [...parent.crs];
+  }
+
+  if (parent && parent.boundingBoxes && !layer.boundingBoxes) {
+    layer.boundingBoxes = [...parent.boundingBoxes];
+  }
+
+  // TODO inherit other elements
+
+  for (const subLayer of layer.layers || []) {
+    addInheritedLayerProps(subLayer, layer);
+  }
+}

package/src/lib/parsers/wms/parse-wms-error.ts

@@ -0,0 +1,22 @@
+// loaders.gl, MIT license
+
+import {XMLLoader} from '@loaders.gl/xml';
+
+/**
+ * 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.value || serviceExceptionXML.code || 'Unknown error';
+  return message;
+}

package/src/lib/parsers/wms/parse-wms-features.ts

@@ -0,0 +1,39 @@
+// loaders.gl, MIT license
+
+import {XMLLoader} from '@loaders.gl/xml';
+
+/** WMS Feature info - response to a WMS `GetFeatureInfo` request */
+export type WMSFeatureInfo = {
+  features: WMSFeature[];
+};
+
+export type WMSFeature = {
+  attributes: Record<string, number | string>;
+  type: string;
+  bounds: {top: number; bottom: number; left: number; right: number};
+};
+
+/**
+ * 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}
+  };
+}

package/src/lib/parsers/wms/parse-wms-layer-description.ts

@@ -0,0 +1,18 @@
+// loaders.gl, MIT license
+
+import {XMLLoader} from '@loaders.gl/xml';
+
+/** Layer description - response to a WMS `DescribeLayer` request  */
+export type WMSLayerDescription = {
+  layers: {}[];
+};
+
+/**
+ * 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;
+}

package/src/lib/parsers/xml/parse-xml-helpers.ts

@@ -0,0 +1,65 @@
+// loaders.gl, MIT license
+
+/** A single element of an array is not represented as an array in XML */
+export function getXMLArray(xmlValue: any): any[] {
+  // Already an array, return as is
+  if (Array.isArray(xmlValue)) {
+    return xmlValue;
+  }
+  // Single value, wrap in array
+  if (xmlValue) {
+    return [xmlValue];
+  }
+  // nullish, return empty array
+  return [];
+}
+
+/** Get a list of strings from XML */
+export function getXMLStringArray(xmlValue: any): string[] {
+  const xmlArray = getXMLArray(xmlValue);
+  if (xmlArray.length > 0 && xmlArray.every((_) => typeof _ === 'string')) {
+    return xmlArray as string[];
+  }
+  // TODO - error handling?
+  return [];
+}
+
+/** Get XML float */
+export function getXMLFloat(xmlValue: any, defaultValue = undefined): number | undefined {
+  switch (typeof xmlValue) {
+    case 'number':
+      return xmlValue;
+    case 'string':
+      return parseFloat(xmlValue);
+    default:
+      return undefined;
+  }
+}
+
+/** Get XML integer */
+export function getXMLInteger(xmlValue: any, defaultValue = undefined): number | undefined {
+  switch (typeof xmlValue) {
+    case 'number':
+      return xmlValue;
+    case 'string':
+      return parseInt(xmlValue, 10);
+    default:
+      return undefined;
+  }
+}
+
+/** Somewhat arbitrary boolean parsing */
+export function getXMLBoolean(xmlValue: any): boolean {
+  switch (xmlValue) {
+    case 'true':
+      return true;
+    case 'false':
+      return false;
+    case '1':
+      return true;
+    case '0':
+      return false;
+    default:
+      return false;
+  }
+}

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

@@ -1,27 +1,34 @@
 // 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 {
+import type {ImageSourceMetadata, GetImageParameters} from '../../sources/image-source';
+import type {ImageSourceProps} from '../../sources/image-source';
+import {ImageSource} from '../../sources/image-source';
+
+export type ArcGISImageServerProps = ImageSourceProps & {
+  url: string;
+};
+
+/**
+ * ArcGIS ImageServer
+ * Note - exports a big API, that could be exposed here if there is a use case
+ * @see https://developers.arcgis.com/rest/services-reference/enterprise/image-service.htm
+ */
+export class ArcGISImageServer 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>;
+  props: ArcGISImageServerProps;
 
-  constructor(props: ImageServiceProps) {
-    super();
-    this.props = mergeImageServiceProps(props);
-    this.fetch = getFetchFunction(this.props);
+  constructor(props: ArcGISImageServerProps) {
+    super(props);
+    this.props = props;
   }
 
   // ImageSource (normalized endpoints)
 
   async getMetadata(): Promise<ImageSourceMetadata> {
-    return (await this.info()) as ImageSourceMetadata;
+    return (await this.metadata()) as ImageSourceMetadata;
     // TODO - normalize metadata
   }
 
@@ -33,7 +40,7 @@ export class ArcGISImageService extends ImageSource {
 
   // ImageServer endpoints
 
-  async info(): Promise<unknown> {
+  async metadata(): Promise<unknown> {
     // We just need a JSON parsing...
     // return this.getUrl({path: '', ...options});
     throw new Error('not implemented');
@@ -68,18 +75,22 @@ export class ArcGISImageService extends ImageSource {
 
   // URL creators
 
-  infoURL(options: {parameters?: Record<string, unknown>}): string {
-    return this.props.url;
-    // return this.getUrl({path: '', ...options});
+  metadataURL(options: {parameters?: Record<string, unknown>}): string {
+    return `${this.props.url}?f=pjson`;
   }
 
   /** 
    * 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`,
+   // 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;
+    bbox: [number, number, number, number];
+    boxSR?: string;
     width: number;
     height: number;
     imageSR?: string;
@@ -96,11 +107,14 @@ export class ArcGISImageService extends ImageSource {
     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;
+    const bbox = `bbox=${options.bbox[0]},${options.bbox[1]},${options.bbox[2]},${options.bbox[3]}`;
+    const size = `size=${options.width},${options.height}`;
+    const arcgisOptions = {...options, bbox, size};
+    // @ts-expect-error
+    delete arcgisOptions.width;
+    // @ts-expect-error
+    delete arcgisOptions.height;
+    return this.getUrl('exportImage', arcgisOptions);
   }
 
   // INTERNAL METHODS
@@ -109,8 +123,12 @@ export class ArcGISImageService extends ImageSource {
    * @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}`;
+  protected getUrl(
+    path: string,
+    options: Record<string, unknown>,
+    extra?: Record<string, unknown>
+  ): string {
+    let url = `${this.props.url}/${path}`;
     let first = true;
     for (const [key, value] of Object.entries(options)) {
       url += first ? '?' : '&';

package/src/lib/services/arcgis/arcgis-server.ts

@@ -0,0 +1,59 @@
+// loaders.gl, MIT license
+
+export type Service = {name: string; type: string; url: string};
+
+type FetchLike = typeof fetch;
+
+/**
+ * (Recursively) load the service directory from an ArcGIS Server URL
+ * @param url
+ * @param fetchFile= Optional fetch function override
+ * @returns
+ */
+export async function getArcGISServices(
+  url: string,
+  fetchFile: FetchLike = fetch
+): Promise<Service[] | null> {
+  if (url.includes('rest/services')) {
+    const serverUrl = url.replace(/rest\/services.*$/i, 'rest/services');
+    return loadServiceDirectory(serverUrl, fetchFile, []);
+  }
+  return null;
+}
+
+async function loadServiceDirectory(
+  serverUrl: string,
+  fetch: FetchLike,
+  path: string[]
+): Promise<Service[]> {
+  const serviceUrl = `${serverUrl}/${path.join('/')}`;
+
+  const response = await fetch(`${serviceUrl}?f=pjson`);
+  const directory = await response.json();
+
+  const services = extractServices(directory, serviceUrl);
+
+  const folders = (directory.folders || []) as string[];
+  const promises = folders.map((folder) =>
+    loadServiceDirectory(`${serverUrl}`, fetch, [...path, folder])
+  );
+
+  for (const folderServices of await Promise.all(promises)) {
+    services.push(...folderServices);
+  }
+
+  return services;
+}
+
+function extractServices(directory: unknown, url: string): Service[] {
+  const arcgisServices = ((directory as any).services || []) as {name: string; type: string}[];
+  const services: Service[] = [];
+  for (const service of arcgisServices) {
+    services.push({
+      name: service.name,
+      type: `arcgis-${service.type.toLocaleLowerCase().replace('server', '-server')}`,
+      url: `${url}${service.name}/${service.type}`
+    });
+  }
+  return services;
+}