ol 7.5.1 → 8.0.0-dev.1692053484481

package/source/{Stamen.js → StadiaMaps.js}

@@ -1,5 +1,5 @@
 /**
- * @module ol/source/Stamen
+ * @module ol/source/StadiaMaps
  */
 
 import XYZ from './XYZ.js';
@@ -7,80 +7,105 @@ import {ATTRIBUTION as OSM_ATTRIBUTION} from './OSM.js';
 
 /**
  * @const
- * @type {Array<string>}
+ * @type string
  */
-const ATTRIBUTIONS = [
-  'Map tiles by <a href="https://stamen.com/" target="_blank">Stamen Design</a>, ' +
-    'under <a href="https://creativecommons.org/licenses/by/3.0/" target="_blank">CC BY' +
-    ' 3.0</a>.',
-  OSM_ATTRIBUTION,
-];
+const STADIA_ATTRIBUTION =
+  '&copy; <a href="https://www.stadiamaps.com/" target="_blank">Stadia Maps</a>';
+
+/**
+ * @const
+ * @type string
+ */
+const OMT_ATTRIBUTION =
+  '&copy; <a href="https://openmaptiles.org/" target="_blank">OpenMapTiles</a>';
+
+/**
+ * @const
+ * @type string
+ */
+const STAMEN_ATTRIBUTION =
+  '&copy; <a href="https://stamen.com/" target="_blank">Stamen Design</a>';
 
 /**
  * @type {Object<string, {extension: string, opaque: boolean}>}
  */
 const LayerConfig = {
-  'terrain': {
+  'stamen_terrain': {
     extension: 'png',
     opaque: true,
   },
-  'terrain-background': {
+  'stamen_terrain_background': {
     extension: 'png',
     opaque: true,
   },
-  'terrain-labels': {
+  'stamen_terrain_labels': {
     extension: 'png',
     opaque: false,
   },
-  'terrain-lines': {
+  'stamen_terrain_lines': {
     extension: 'png',
     opaque: false,
   },
-  'toner-background': {
+  'stamen_toner_background': {
     extension: 'png',
     opaque: true,
   },
-  'toner': {
+  'stamen_toner': {
     extension: 'png',
     opaque: true,
   },
-  'toner-hybrid': {
+  'stamen_toner_labels': {
     extension: 'png',
     opaque: false,
   },
-  'toner-labels': {
+  'stamen_toner_lines': {
     extension: 'png',
     opaque: false,
   },
-  'toner-lines': {
+  'stamen_toner_lite': {
     extension: 'png',
-    opaque: false,
+    opaque: true,
+  },
+  'stamen_watercolor': {
+    extension: 'jpg',
+    opaque: true,
   },
-  'toner-lite': {
+  'alidade_smooth': {
     extension: 'png',
     opaque: true,
   },
-  'watercolor': {
-    extension: 'jpg',
+  'alidade_smooth_dark': {
+    extension: 'png',
+    opaque: true,
+  },
+  'stadia_outdoors': {
+    extension: 'png',
+    opaque: true,
+  },
+  'osm_bright': {
+    extension: 'png',
     opaque: true,
   },
 };
 
 /**
- * @type {Object<string, {minZoom: number, maxZoom: number}>}
+ * @type {Object<string, {minZoom: number, maxZoom: number, retina: boolean}>}
  */
 const ProviderConfig = {
-  'terrain': {
+  'stamen_terrain': {
     minZoom: 0,
     maxZoom: 18,
+    retina: true,
   },
-  'toner': {
+  'stamen_toner': {
     minZoom: 0,
     maxZoom: 20,
+    retina: true,
   },
-  'watercolor': {
-    minZoom: 0,
+  'stamen_watercolor': {
+    minZoom: 1,
     maxZoom: 18,
+    retina: false,
   },
 };
 
@@ -89,7 +114,7 @@ const ProviderConfig = {
  * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
- * @property {string} layer Layer name.
+ * @property {string} layer Layer name. Valid values: `alidade_smooth`, `alidade_smooth_dark`, `stadia_outdoors`, `stamen_terrain`, `stamen_terrain_background`, `stamen_terrain_labels`, `stamen_terrain_lines`, `stamen_toner_background`, `stamen_toner`, `stamen_toner_labels`, `stamen_toner_lines`, `stamen_toner_lite`, `stamen_watercolor`, and `osm_bright`.
  * @property {number} [minZoom] Minimum zoom.
  * @property {number} [maxZoom] Maximum zoom.
  * @property {number} [reprojectionErrorThreshold=0.5] Maximum allowed reprojection error (in pixels).
@@ -108,50 +133,72 @@ const ProviderConfig = {
  * @property {number|import("../array.js").NearestDirectionFunction} [zDirection=0]
  * Choose whether to use tiles with a higher or lower zoom level when between integer
  * zoom levels. See {@link module:ol/tilegrid/TileGrid~TileGrid#getZForResolution}.
+ * @property {string} apiKey Stadia Maps API key. Not required for localhost or most public web deployments. See https://docs.stadiamaps.com/authentication/ for details.
+ * @property {boolean} retina Use retina tiles (if available; not available for Stamen Watercolor).
  */
 
 /**
  * @classdesc
- * Layer source for the Stamen tile server.
+ * Layer source for the Stadia Maps tile server.
  * @api
  */
-class Stamen extends XYZ {
+class StadiaMaps extends XYZ {
   /**
-   * @param {Options} options Stamen options.
+   * @param {Options} options StadiaMaps options.
    */
   constructor(options) {
     const i = options.layer.indexOf('-');
     const provider = i == -1 ? options.layer : options.layer.slice(0, i);
-    const providerConfig = ProviderConfig[provider];
+    const providerConfig = ProviderConfig[provider] || {
+      'minZoom': 0,
+      'maxZoom': 20,
+      'retina': true,
+    };
 
     const layerConfig = LayerConfig[options.layer];
+    const query = options.apiKey ? '?api_key=' + options.apiKey : '';
+    const retina = providerConfig.retina && options.retina ? '@2x' : '';
 
     const url =
       options.url !== undefined
         ? options.url
-        : 'https://stamen-tiles-{a-d}.a.ssl.fastly.net/' +
+        : 'https://tiles.stadiamaps.com/tiles/' +
           options.layer +
-          '/{z}/{x}/{y}.' +
-          layerConfig.extension;
+          '/{z}/{x}/{y}' +
+          retina +
+          '.' +
+          layerConfig.extension +
+          query;
+
+    const attributions = [STADIA_ATTRIBUTION, OMT_ATTRIBUTION, OSM_ATTRIBUTION];
+
+    if (options.layer.startsWith('stamen_')) {
+      attributions.splice(1, 0, STAMEN_ATTRIBUTION);
+    }
 
     super({
-      attributions: ATTRIBUTIONS,
+      attributions: attributions,
       cacheSize: options.cacheSize,
       crossOrigin: 'anonymous',
       interpolate: options.interpolate,
       maxZoom:
-        options.maxZoom != undefined ? options.maxZoom : providerConfig.maxZoom,
+        options.maxZoom !== undefined
+          ? options.maxZoom
+          : providerConfig.maxZoom,
       minZoom:
-        options.minZoom != undefined ? options.minZoom : providerConfig.minZoom,
+        options.minZoom !== undefined
+          ? options.minZoom
+          : providerConfig.minZoom,
       opaque: layerConfig.opaque,
       reprojectionErrorThreshold: options.reprojectionErrorThreshold,
       tileLoadFunction: options.tileLoadFunction,
       transition: options.transition,
       url: url,
+      tilePixelRatio: retina ? 2 : 1,
       wrapX: options.wrapX,
       zDirection: options.zDirection,
     });
   }
 }
 
-export default Stamen;
+export default StadiaMaps;

package/source/TileArcGISRest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileArcGISRest.d.ts","sourceRoot":"","sources":["TileArcGISRest.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAvBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;;;;;GAQG;AACH;IACE;;OAEG;IACH,2CAsCC;IAnBC;;;OAGG;IACH,gBAAmC;IAEnC;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,mBAA+B;IAKjC;;;OAGG;IACH,yBAOC;IAED;;;;;OAKG;IACH,iBAEC;IAED;;;;;;;;;OASG;IACH,uBAyCC;IAWD;;;;OAIG;IACH,gCAGC;CA+CF;sBAvPqB,gBAAgB"}
+{"version":3,"file":"TileArcGISRest.d.ts","sourceRoot":"","sources":["TileArcGISRest.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAvBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;;;;;GAQG;AACH;IACE;;OAEG;IACH,2CAsCC;IAnBC;;;OAGG;IACH,gBAAmC;IAEnC;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,mBAA+B;IAKjC;;;OAGG;IACH,yBAOC;IAED;;;;;OAKG;IACH,iBAEC;IAED;;;;;;;;;OASG;IACH,uBA8BC;IAWD;;;;OAIG;IACH,gCAGC;CA+CF;sBA5OqB,gBAAgB"}

package/source/TileArcGISRest.js

@@ -3,8 +3,8 @@
  */
 
 import TileImage from './TileImage.js';
-import {appendParams} from '../uri.js';
 import {createEmpty} from '../extent.js';
+import {getRequestUrl} from './arcgisRest.js';
 import {modulo} from '../math.js';
 import {scale as scaleSize, toSize} from '../size.js';
 import {hash as tileCoordHash} from '../tilecoord.js';
@@ -154,23 +154,6 @@ class TileArcGISRest extends TileImage {
     if (!urls) {
       return undefined;
     }
-
-    // ArcGIS Server only wants the numeric portion of the projection ID.
-    // (if there is no numeric portion the entire projection code must
-    // form a valid ArcGIS SpatialReference definition).
-    const srid = projection
-      .getCode()
-      .split(/:(?=\d+$)/)
-      .pop();
-
-    params['SIZE'] = tileSize[0] + ',' + tileSize[1];
-    params['BBOX'] = tileExtent.join(',');
-    params['BBOXSR'] = srid;
-    params['IMAGESR'] = srid;
-    params['DPI'] = Math.round(
-      params['DPI'] ? params['DPI'] * pixelRatio : 90 * pixelRatio
-    );
-
     let url;
     if (urls.length == 1) {
       url = urls[0];
@@ -179,10 +162,16 @@ class TileArcGISRest extends TileImage {
       url = urls[index];
     }
 
-    const modifiedUrl = url
-      .replace(/MapServer\/?$/, 'MapServer/export')
-      .replace(/ImageServer\/?$/, 'ImageServer/exportImage');
-    return appendParams(modifiedUrl, params);
+    return getRequestUrl(
+      url,
+      tileExtent,
+      (
+        this.tileGrid || this.getTileGridForProjection(projection)
+      ).getResolution(tileCoord[0]),
+      pixelRatio,
+      projection,
+      params
+    );
   }
 
   /**

package/source/TileWMS.d.ts

@@ -248,7 +248,6 @@ declare class TileWMS extends TileImage {
     getParams(): any;
     /**
      * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
-     * @param {import("../size.js").Size} tileSize Tile size.
      * @param {import("../extent.js").Extent} tileExtent Tile extent.
      * @param {number} pixelRatio Pixel ratio.
      * @param {import("../proj/Projection.js").default} projection Projection.

package/source/TileWMS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileWMS.d.ts","sourceRoot":"","sources":["TileWMS.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA0BqB,MAAM;;;;;;;;;;;;;;;;;;;;;iBAeb,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAzBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,2CAgEC;IAtCC;;;OAGG;IACH,gBAAgE;IAEhE;;;OAGG;IACH,gBAAqB;IAErB;;;OAGG;IACH,aAAgB;IAEhB;;;OAGG;IACH,oBAAqC;IAErC;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,mBAA+B;IAMjC;;;;;;;;;;;;;OAaG;IACH,8BAVW,OAAO,kBAAkB,EAAE,UAAU,cACrC,MAAM,cACN,OAAO,YAAY,EAAE,cAAc,gBAKlC,MAAM,GAAC,SAAS,CAoE3B;IAED;;;;;;;;;;;;;OAaG;IACH,6DAHY,MAAM,GAAC,SAAS,CAmC3B;IASD;;;;;OAKG;IACH,iBAEC;IAED;;;;;;;;;OASG;IACH,uBAkEC;IAWD;;;OAGG;IACH,yBAOC;IAED;;;;OAIG;IACH,gCAIC;IAED;;OAEG;IACH,mBAGC;CAuDF;sBA/cqB,gBAAgB"}
+{"version":3,"file":"TileWMS.d.ts","sourceRoot":"","sources":["TileWMS.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAwBqB,MAAM;;;;;;;;;;;;;;;;;;;;;iBAeb,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAzBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,2CAgEC;IAtCC;;;OAGG;IACH,gBAAgE;IAEhE;;;OAGG;IACH,gBAAqB;IAErB;;;OAGG;IACH,aAAgB;IAEhB;;;OAGG;IACH,oBAAqC;IAErC;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,mBAA+B;IAMjC;;;;;;;;;;;;;OAaG;IACH,8BAVW,OAAO,kBAAkB,EAAE,UAAU,cACrC,MAAM,cACN,OAAO,YAAY,EAAE,cAAc,gBAKlC,MAAM,GAAC,SAAS,CA6D3B;IAED;;;;;;;;;;;;;OAaG;IACH,6DAHY,MAAM,GAAC,SAAS,CAmC3B;IASD;;;;;OAKG;IACH,iBAEC;IAED;;;;;;;;OAQG;IACH,uBAwBC;IAWD;;;OAGG;IACH,yBAOC;IAED;;;;OAIG;IACH,gCAIC;IAED;;OAEG;IACH,mBAGC;CA4CF;sBAhZqB,gBAAgB"}

package/source/TileWMS.js

@@ -3,14 +3,12 @@
  */
 
 import TileImage from './TileImage.js';
-import {DEFAULT_VERSION} from './wms.js';
+import {DEFAULT_VERSION, getImageSrc, getRequestParams} from './wms.js';
 import {appendParams} from '../uri.js';
-import {assert} from '../asserts.js';
 import {buffer, createEmpty} from '../extent.js';
-import {buffer as bufferSize, scale as scaleSize, toSize} from '../size.js';
 import {calculateSourceResolution} from '../reproj.js';
 import {compareVersions} from '../string.js';
-import {get as getProjection, transform, transformExtent} from '../proj.js';
+import {get as getProjection, transform} from '../proj.js';
 import {modulo} from '../math.js';
 import {hash as tileCoordHash} from '../tilecoord.js';
 
@@ -163,64 +161,57 @@ class TileWMS extends TileImage {
    */
   getFeatureInfoUrl(coordinate, resolution, projection, params) {
     const projectionObj = getProjection(projection);
-    const sourceProjectionObj = this.getProjection();
+    const sourceProjectionObj = this.getProjection() || projectionObj;
 
     let tileGrid = this.getTileGrid();
     if (!tileGrid) {
-      tileGrid = this.getTileGridForProjection(projectionObj);
+      tileGrid = this.getTileGridForProjection(sourceProjectionObj);
     }
 
-    const z = tileGrid.getZForResolution(resolution, this.zDirection);
-    const tileCoord = tileGrid.getTileCoordForCoordAndZ(coordinate, z);
+    const sourceProjCoord = transform(
+      coordinate,
+      projectionObj,
+      sourceProjectionObj
+    );
+    const sourceResolution = calculateSourceResolution(
+      sourceProjectionObj,
+      projectionObj,
+      coordinate,
+      resolution
+    );
+
+    const z = tileGrid.getZForResolution(sourceResolution, this.zDirection);
+    const tileResolution = tileGrid.getResolution(z);
+    const tileCoord = tileGrid.getTileCoordForCoordAndZ(sourceProjCoord, z);
 
     if (tileGrid.getResolutions().length <= tileCoord[0]) {
       return undefined;
     }
 
-    let tileResolution = tileGrid.getResolution(tileCoord[0]);
     let tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent_);
-    let tileSize = toSize(tileGrid.getTileSize(tileCoord[0]), this.tmpSize);
 
     const gutter = this.gutter_;
     if (gutter !== 0) {
-      tileSize = bufferSize(tileSize, gutter, this.tmpSize);
       tileExtent = buffer(tileExtent, tileResolution * gutter, tileExtent);
     }
 
-    if (sourceProjectionObj && sourceProjectionObj !== projectionObj) {
-      tileResolution = calculateSourceResolution(
-        sourceProjectionObj,
-        projectionObj,
-        coordinate,
-        tileResolution
-      );
-      tileExtent = transformExtent(
-        tileExtent,
-        projectionObj,
-        sourceProjectionObj
-      );
-      coordinate = transform(coordinate, projectionObj, sourceProjectionObj);
-    }
-
     const baseParams = {
-      'SERVICE': 'WMS',
-      'VERSION': DEFAULT_VERSION,
-      'REQUEST': 'GetFeatureInfo',
-      'FORMAT': 'image/png',
-      'TRANSPARENT': true,
       'QUERY_LAYERS': this.params_['LAYERS'],
     };
-    Object.assign(baseParams, this.params_, params);
+    Object.assign(
+      baseParams,
+      getRequestParams(this.params_, 'GetFeatureInfo'),
+      params
+    );
 
-    const x = Math.floor((coordinate[0] - tileExtent[0]) / tileResolution);
-    const y = Math.floor((tileExtent[3] - coordinate[1]) / tileResolution);
+    const x = Math.floor((sourceProjCoord[0] - tileExtent[0]) / tileResolution);
+    const y = Math.floor((tileExtent[3] - sourceProjCoord[1]) / tileResolution);
 
     baseParams[this.v13_ ? 'I' : 'X'] = x;
     baseParams[this.v13_ ? 'J' : 'Y'] = y;
 
     return this.getRequestUrl_(
       tileCoord,
-      tileSize,
       tileExtent,
       1,
       sourceProjectionObj || projectionObj,
@@ -295,7 +286,6 @@ class TileWMS extends TileImage {
 
   /**
    * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
-   * @param {import("../size.js").Size} tileSize Tile size.
    * @param {import("../extent.js").Extent} tileExtent Tile extent.
    * @param {number} pixelRatio Pixel ratio.
    * @param {import("../proj/Projection.js").default} projection Projection.
@@ -303,64 +293,11 @@ class TileWMS extends TileImage {
    * @return {string|undefined} Request URL.
    * @private
    */
-  getRequestUrl_(
-    tileCoord,
-    tileSize,
-    tileExtent,
-    pixelRatio,
-    projection,
-    params
-  ) {
+  getRequestUrl_(tileCoord, tileExtent, pixelRatio, projection, params) {
     const urls = this.urls;
     if (!urls) {
       return undefined;
     }
-
-    params['WIDTH'] = tileSize[0];
-    params['HEIGHT'] = tileSize[1];
-
-    params[this.v13_ ? 'CRS' : 'SRS'] = projection.getCode();
-
-    if (!('STYLES' in this.params_)) {
-      params['STYLES'] = '';
-    }
-
-    if (pixelRatio != 1) {
-      switch (this.serverType_) {
-        case 'geoserver':
-          const dpi = (90 * pixelRatio + 0.5) | 0;
-          if ('FORMAT_OPTIONS' in params) {
-            params['FORMAT_OPTIONS'] += ';dpi:' + dpi;
-          } else {
-            params['FORMAT_OPTIONS'] = 'dpi:' + dpi;
-          }
-          break;
-        case 'mapserver':
-          params['MAP_RESOLUTION'] = 90 * pixelRatio;
-          break;
-        case 'carmentaserver':
-        case 'qgis':
-          params['DPI'] = 90 * pixelRatio;
-          break;
-        default: // Unknown `serverType` configured
-          assert(false, 52);
-          break;
-      }
-    }
-
-    const axisOrientation = projection.getAxisOrientation();
-    const bbox = tileExtent;
-    if (this.v13_ && axisOrientation.substr(0, 2) == 'ne') {
-      let tmp;
-      tmp = tileExtent[0];
-      bbox[0] = tileExtent[1];
-      bbox[1] = tmp;
-      tmp = tileExtent[2];
-      bbox[2] = tileExtent[3];
-      bbox[3] = tmp;
-    }
-    params['BBOX'] = bbox.join(',');
-
     let url;
     if (urls.length == 1) {
       url = urls[0];
@@ -368,7 +305,18 @@ class TileWMS extends TileImage {
       const index = modulo(tileCoordHash(tileCoord), urls.length);
       url = urls[index];
     }
-    return appendParams(url, params);
+
+    return getImageSrc(
+      tileExtent,
+      (
+        this.tileGrid || this.getTileGridForProjection(projection)
+      ).getResolution(tileCoord[0]),
+      pixelRatio,
+      projection,
+      url,
+      params,
+      this.serverType_
+    );
   }
 
   /**
@@ -435,30 +383,19 @@ class TileWMS extends TileImage {
 
     const tileResolution = tileGrid.getResolution(tileCoord[0]);
     let tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent_);
-    let tileSize = toSize(tileGrid.getTileSize(tileCoord[0]), this.tmpSize);
 
     const gutter = this.gutter_;
     if (gutter !== 0) {
-      tileSize = bufferSize(tileSize, gutter, this.tmpSize);
       tileExtent = buffer(tileExtent, tileResolution * gutter, tileExtent);
     }
 
-    if (pixelRatio != 1) {
-      tileSize = scaleSize(tileSize, pixelRatio, this.tmpSize);
-    }
-
-    const baseParams = {
-      'SERVICE': 'WMS',
-      'VERSION': DEFAULT_VERSION,
-      'REQUEST': 'GetMap',
-      'FORMAT': 'image/png',
-      'TRANSPARENT': true,
-    };
-    Object.assign(baseParams, this.params_);
+    const baseParams = Object.assign(
+      {},
+      getRequestParams(this.params_, 'GetMap')
+    );
 
     return this.getRequestUrl_(
       tileCoord,
-      tileSize,
       tileExtent,
       pixelRatio,
       projection,

package/source/arcgisRest.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @param {string} baseUrl Base URL for the ArcGIS Rest service.
+ * @param {import("../extent.js").Extent} extent Extent.
+ * @param {number} resolution Resolution.
+ * @param {number} pixelRatio Pixel ratio.
+ * @param {import("../proj/Projection.js").default} projection Projection.
+ * @param {Object} params Params.
+ * @return {string} Request URL.
+ */
+export function getRequestUrl(baseUrl: string, extent: import("../extent.js").Extent, resolution: number, pixelRatio: number, projection: import("../proj/Projection.js").default, params: any): string;
+/**
+ * @typedef {Object} LoaderOptions
+ * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
+ * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
+ * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
+ * @property {boolean} [hidpi=true] Use the `ol/Map#pixelRatio` value when requesting the image from
+ * the remote server.
+ * @property {Object<string,*>} [params] ArcGIS Rest parameters. This field is optional. Service
+ * defaults will be used for any fields not specified. `FORMAT` is `PNG32` by default. `F` is
+ * `IMAGE` by default. `TRANSPARENT` is `true` by default.  `BBOX`, `SIZE`, `BBOXSR`, and `IMAGESR`
+ * will be set dynamically. Set `LAYERS` to override the default service layer visibility. See
+ * https://developers.arcgis.com/rest/services-reference/export-map.htm
+ * for further reference.
+ * @property {import("../proj.js").ProjectionLike} [projection] Projection. Default is 'EPSG:3857'.
+ * The projection code must contain a numeric end portion separated by :
+ * or the entire code must form a valid ArcGIS SpatialReference definition.
+ * @property {number} [ratio=1.5] Ratio. `1` means image requests are the size of the map viewport,
+ * `2` means twice the size of the map viewport, and so on.
+ * @property {string} [url] ArcGIS Rest service URL for a Map Service or Image Service. The url
+ * should include /MapServer or /ImageServer.
+ * @property {function(HTMLImageElement, string): Promise<import('../DataTile.js').ImageLike>} [load] Function
+ * to perform loading of the image. Receives the created `HTMLImageElement` and the desired `src` as argument and
+ * returns a promise resolving to the loaded or decoded image. Default is {@link module:ol/Image.decode}.
+ */
+/**
+ * Creates a loader for ArcGIS Rest images.
+ * @param {LoaderOptions} options Image ArcGIS Rest Options.
+ * @return {import('../Image.js').ImageObjectPromiseLoader} ArcGIS Rest image.
+ * @api
+ */
+export function createLoader(options: LoaderOptions): import('../Image.js').ImageObjectPromiseLoader;
+export type LoaderOptions = {
+    /**
+     * The `crossOrigin` attribute for loaded images.  Note that
+     * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
+     * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
+     */
+    crossOrigin?: string | null | undefined;
+    /**
+     * Use the `ol/Map#pixelRatio` value when requesting the image from
+     * the remote server.
+     */
+    hidpi?: boolean | undefined;
+    /**
+     * ArcGIS Rest parameters. This field is optional. Service
+     * defaults will be used for any fields not specified. `FORMAT` is `PNG32` by default. `F` is
+     * `IMAGE` by default. `TRANSPARENT` is `true` by default.  `BBOX`, `SIZE`, `BBOXSR`, and `IMAGESR`
+     * will be set dynamically. Set `LAYERS` to override the default service layer visibility. See
+     * https://developers.arcgis.com/rest/services-reference/export-map.htm
+     * for further reference.
+     */
+    params?: {
+        [x: string]: any;
+    } | undefined;
+    /**
+     * Projection. Default is 'EPSG:3857'.
+     * The projection code must contain a numeric end portion separated by :
+     * or the entire code must form a valid ArcGIS SpatialReference definition.
+     */
+    projection?: import("../proj.js").ProjectionLike;
+    /**
+     * Ratio. `1` means image requests are the size of the map viewport,
+     * `2` means twice the size of the map viewport, and so on.
+     */
+    ratio?: number | undefined;
+    /**
+     * ArcGIS Rest service URL for a Map Service or Image Service. The url
+     * should include /MapServer or /ImageServer.
+     */
+    url?: string | undefined;
+    /**
+     * Function
+     * to perform loading of the image. Receives the created `HTMLImageElement` and the desired `src` as argument and
+     * returns a promise resolving to the loaded or decoded image. Default is {@link module :ol/Image.decode}.
+     */
+    load?: ((arg0: HTMLImageElement, arg1: string) => Promise<import('../DataTile.js').ImageLike>) | undefined;
+};
+//# sourceMappingURL=arcgisRest.d.ts.map

package/source/arcgisRest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arcgisRest.d.ts","sourceRoot":"","sources":["arcgisRest.js"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH,uCARW,MAAM,UACN,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,gBAEtC,MAAM,CAwCjB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;GAKG;AACH,sCAJW,aAAa,GACZ,OAAO,aAAa,EAAE,wBAAwB,CAwCzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAvDa,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;mBAO1B,gBAAgB,QAAE,MAAM,KAAG,QAAQ,OAAO,gBAAgB,EAAE,SAAS,CAAC"}