ol 7.5.1 → 8.0.0-dev.1692053484481

package/source/ImageStatic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageStatic.d.ts","sourceRoot":"","sources":["ImageStatic.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuBc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;SAGnC,MAAM;;AAdpB;;;;;;;;;;;;;;;GAeG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAqDjB;IApCC;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,qBAAuC;IAEvC;;;OAGG;IACH,eAQC;IAED;;;OAGG;IACH,mBAA8D;IAQhE;;;;OAIG;IACH,kBAHY,OAAO,cAAc,EAAE,MAAM,CAKxC;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,aAAa,EAAE,OAAO,CAOxC;IAED;;;;OAIG;IACH,UAHY,MAAM,CAKjB;CAkDF;wBAtKmD,YAAY"}
+{"version":3,"file":"ImageStatic.d.ts","sourceRoot":"","sources":["ImageStatic.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;iBAiBc,OAAO,cAAc,EAAE,MAAM;;;;;;;;;;;;;iBAK7B,OAAO,YAAY,EAAE,cAAc;;;;SACnC,MAAM;;AAZpB;;;;;;;;;;;;;GAaG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAuDjB;IAtCC;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,qBAAuC;IA8BzC;;;;OAIG;IACH,kBAHY,OAAO,cAAc,EAAE,MAAM,CAKxC;IAgBD;;;;OAIG;IACH,UAHY,MAAM,CAKjB;CACF;wBApHmD,YAAY"}

package/source/ImageStatic.js

@@ -4,11 +4,10 @@
 
 import EventType from '../events/EventType.js';
 import ImageSource, {defaultImageLoadFunction} from './Image.js';
-import ImageState from '../ImageState.js';
-import ImageWrapper from '../Image.js';
-import {createCanvasContext2D} from '../dom.js';
-import {getHeight, getWidth, intersects} from '../extent.js';
+import ImageWrapper, {decode} from '../Image.js';
+import {createLoader} from './static.js';
 import {get as getProjection} from '../proj.js';
+import {intersects} from '../extent.js';
 
 /**
  * @typedef {Object} Options
@@ -16,14 +15,12 @@ import {get as getProjection} from '../proj.js';
  * @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 {import("../extent.js").Extent} [imageExtent] Extent of the image in map coordinates.
+ * @property {import("../extent.js").Extent} imageExtent Extent of the image in map coordinates.
  * This is the [left, bottom, right, top] map coordinates of your image.
  * @property {import("../Image.js").LoadFunction} [imageLoadFunction] Optional function to load an image given a URL.
  * @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 {import("../proj.js").ProjectionLike} [projection] Projection. Default is the view projection.
- * @property {import("../size.js").Size} [imageSize] Size of the image in pixels. Usually the image size is auto-detected, so this
- * only needs to be set if auto-detection fails for some reason.
  * @property {string} url Image URL.
  */
 
@@ -67,23 +64,25 @@ class Static extends ImageSource {
      * @private
      * @type {import("../Image.js").default}
      */
-    this.image_ = new ImageWrapper(
+    this.image = null;
+
+    this.image = new ImageWrapper(
       this.imageExtent_,
       undefined,
       1,
-      this.url_,
-      crossOrigin,
-      imageLoadFunction,
-      createCanvasContext2D(1, 1)
+      createLoader({
+        url: options.url,
+        imageExtent: options.imageExtent,
+        crossOrigin,
+        load: (image, src) => {
+          this.image.setImage(image);
+          imageLoadFunction(this.image, src);
+          return decode(image);
+        },
+      })
     );
 
-    /**
-     * @private
-     * @type {import("../size.js").Size|null}
-     */
-    this.imageSize_ = options.imageSize ? options.imageSize : null;
-
-    this.image_.addEventListener(
+    this.image.addEventListener(
       EventType.CHANGE,
       this.handleImageChange.bind(this)
     );
@@ -106,8 +105,8 @@ class Static extends ImageSource {
    * @return {import("../Image.js").default} Single image.
    */
   getImageInternal(extent, resolution, pixelRatio, projection) {
-    if (intersects(extent, this.image_.getExtent())) {
-      return this.image_;
+    if (intersects(extent, this.image.getExtent())) {
+      return this.image;
     }
     return null;
   }
@@ -120,55 +119,6 @@ class Static extends ImageSource {
   getUrl() {
     return this.url_;
   }
-
-  /**
-   * @param {import("../events/Event.js").default} evt Event.
-   */
-  handleImageChange(evt) {
-    if (this.image_.getState() == ImageState.LOADED) {
-      const imageExtent = this.image_.getExtent();
-      const image = this.image_.getImage();
-      let imageWidth, imageHeight;
-      if (this.imageSize_) {
-        imageWidth = this.imageSize_[0];
-        imageHeight = this.imageSize_[1];
-      } else {
-        imageWidth = image.width;
-        imageHeight = image.height;
-      }
-      const extentWidth = getWidth(imageExtent);
-      const extentHeight = getHeight(imageExtent);
-      const xResolution = extentWidth / imageWidth;
-      const yResolution = extentHeight / imageHeight;
-      let targetWidth = imageWidth;
-      let targetHeight = imageHeight;
-      if (xResolution > yResolution) {
-        targetWidth = Math.round(extentWidth / yResolution);
-      } else {
-        targetHeight = Math.round(extentHeight / xResolution);
-      }
-      if (targetWidth !== imageWidth || targetHeight !== imageHeight) {
-        const context = createCanvasContext2D(targetWidth, targetHeight);
-        if (!this.getInterpolate()) {
-          context.imageSmoothingEnabled = false;
-        }
-        const canvas = context.canvas;
-        context.drawImage(
-          image,
-          0,
-          0,
-          imageWidth,
-          imageHeight,
-          0,
-          0,
-          canvas.width,
-          canvas.height
-        );
-        this.image_.setImage(canvas);
-      }
-    }
-    super.handleImageChange(evt);
-  }
 }
 
 export default Static;

package/source/ImageWMS.d.ts

@@ -45,8 +45,7 @@ export type Options = {
     projection?: import("../proj.js").ProjectionLike;
     /**
      * Ratio. `1` means image requests are the size of the map viewport, `2` means
-     * twice the width and height of the map viewport, and so on. Must be `1` or
-     * higher.
+     * twice the width and height of the map viewport, and so on. Must be `1` or higher.
      */
     ratio?: number | undefined;
     /**
@@ -79,8 +78,7 @@ export type Options = {
  * and `CRS` (`SRS` for WMS version < 1.3.0) will be set dynamically.
  * @property {import("../proj.js").ProjectionLike} [projection] Projection. Default is the view projection.
  * @property {number} [ratio=1.5] Ratio. `1` means image requests are the size of the map viewport, `2` means
- * twice the width and height of the map viewport, and so on. Must be `1` or
- * higher.
+ * twice the width and height of the map viewport, and so on. Must be `1` or higher.
  * @property {Array<number>} [resolutions] Resolutions.
  * If specified, requests will be made for these resolutions only.
  * @property {string} [url] WMS service URL.
@@ -97,11 +95,6 @@ declare class ImageWMS extends ImageSource {
      * @param {Options} [options] ImageWMS options.
      */
     constructor(options?: Options | undefined);
-    /**
-     * @private
-     * @type {CanvasRenderingContext2D}
-     */
-    private context_;
     /**
      * @private
      * @type {?string}
@@ -122,11 +115,6 @@ declare class ImageWMS extends ImageSource {
      * @type {!Object}
      */
     private params_;
-    /**
-     * @private
-     * @type {boolean}
-     */
-    private v13_;
     /**
      * @private
      * @type {import("./wms.js").ServerType}
@@ -137,16 +125,6 @@ declare class ImageWMS extends ImageSource {
      * @type {boolean}
      */
     private hidpi_;
-    /**
-     * @private
-     * @type {import("../Image.js").default}
-     */
-    private image_;
-    /**
-     * @private
-     * @type {import("../size.js").Size}
-     */
-    private imageSize_;
     /**
      * @private
      * @type {number}
@@ -194,30 +172,12 @@ declare class ImageWMS extends ImageSource {
      * @api
      */
     getParams(): any;
-    /**
-     * @param {import("../extent.js").Extent} extent Extent.
-     * @param {number} resolution Resolution.
-     * @param {number} pixelRatio Pixel ratio.
-     * @param {import("../proj/Projection.js").default} projection Projection.
-     * @return {import("../Image.js").default} Single image.
-     */
-    getImageInternal(extent: import("../extent.js").Extent, resolution: number, pixelRatio: number, projection: import("../proj/Projection.js").default): import("../Image.js").default;
     /**
      * Return the image load function of the source.
      * @return {import("../Image.js").LoadFunction} The image load function.
      * @api
      */
     getImageLoadFunction(): import("../Image.js").LoadFunction;
-    /**
-     * @param {import("../extent.js").Extent} extent Extent.
-     * @param {import("../size.js").Size} size Size.
-     * @param {number} pixelRatio Pixel ratio.
-     * @param {import("../proj/Projection.js").default} projection Projection.
-     * @param {Object} params Params.
-     * @return {string} Request URL.
-     * @private
-     */
-    private getRequestUrl_;
     /**
      * Return the URL used for this WMS source.
      * @return {string|undefined} URL.
@@ -242,10 +202,6 @@ declare class ImageWMS extends ImageSource {
      * @api
      */
     updateParams(params: any): void;
-    /**
-     * @private
-     */
-    private updateV13_;
 }
 import ImageSource from './Image.js';
 //# sourceMappingURL=ImageWMS.d.ts.map

package/source/ImageWMS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageWMS.d.ts","sourceRoot":"","sources":["ImageWMS.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;AAlBjD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;GAMG;AACH;IACE;;OAEG;IACH,2CAsFC;IA5EC;;;OAGG;IACH,iBAA2C;IAE3C;;;OAGG;IACH,qBACgE;IAEhE;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,2BAG8B;IAE9B;;;OAGG;IACH,gBAAgD;IAEhD;;;OAGG;IACH,aAAgB;IAGhB;;;OAGG;IACH,oBAAqC;IAErC;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,mBAAwB;IAExB;;;OAGG;IACH,0BAA0B;IAE1B;;;OAGG;IACH,eAA+D;IAGjE;;;;;;;;;;;;;OAaG;IACH,8BAVW,OAAO,kBAAkB,EAAE,UAAU,cACrC,MAAM,cACN,OAAO,YAAY,EAAE,cAAc,gBAKlC,MAAM,GAAC,SAAS,CAiD3B;IAED;;;;;;;;;;;;;OAaG;IACH,6DAHY,MAAM,GAAC,SAAS,CAmC3B;IAED;;;;;OAKG;IACH,iBAEC;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,aAAa,EAAE,OAAO,CAsFxC;IAED;;;;OAIG;IACH,wBAHY,OAAO,aAAa,EAAE,YAAY,CAK7C;IAED;;;;;;;;OAQG;IACH,uBA6CC;IAED;;;;OAIG;IACH,UAHY,MAAM,GAAC,SAAS,CAK3B;IAED;;;;OAIG;IACH,wCAHW,OAAO,aAAa,EAAE,YAAY,QAO5C;IAED;;;;OAIG;IACH,YAHW,MAAM,GAAC,SAAS,QAS1B;IAED;;;;OAIG;IACH,gCAKC;IAED;;OAEG;IACH,mBAGC;CACF;wBAtemD,YAAY"}
+{"version":3,"file":"ImageWMS.d.ts","sourceRoot":"","sources":["ImageWMS.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4Cc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;AAlBjD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;GAMG;AACH;IACE;;OAEG;IACH,2CA6DC;IAnDC;;;OAGG;IACH,qBACgE;IAEhE;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,2BAG8B;IAE9B;;;OAGG;IACH,gBAA6B;IAE7B;;;OAGG;IACH,oBAAqC;IAErC;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,0BAA0B;IAE1B;;;OAGG;IACH,eAA+D;IAGjE;;;;;;;;;;;;;OAaG;IACH,8BAVW,OAAO,kBAAkB,EAAE,UAAU,cACrC,MAAM,cACN,OAAO,YAAY,EAAE,cAAc,gBAKlC,MAAM,GAAC,SAAS,CAiD3B;IAED;;;;;;;;;;;;;OAaG;IACH,6DAHY,MAAM,GAAC,SAAS,CAmC3B;IAED;;;;;OAKG;IACH,iBAEC;IAkCD;;;;OAIG;IACH,wBAHY,OAAO,aAAa,EAAE,YAAY,CAK7C;IAED;;;;OAIG;IACH,UAHY,MAAM,GAAC,SAAS,CAK3B;IAED;;;;OAIG;IACH,wCAHW,OAAO,aAAa,EAAE,YAAY,QAM5C;IAED;;;;OAIG;IACH,YAHW,MAAM,GAAC,SAAS,QAS1B;IAED;;;;OAIG;IACH,gCAGC;CAMF;wBAzUmD,YAAY"}

package/source/ImageWMS.js

@@ -2,31 +2,22 @@
  * @module ol/source/ImageWMS
  */
 
-import EventType from '../events/EventType.js';
 import ImageSource, {defaultImageLoadFunction} from './Image.js';
-import ImageWrapper from '../Image.js';
-import {DEFAULT_VERSION} from './wms.js';
+import {DECIMALS} from './common.js';
+import {
+  DEFAULT_VERSION,
+  createLoader,
+  getRequestParams,
+  getRequestUrl,
+} from './wms.js';
 import {appendParams} from '../uri.js';
-import {assert} from '../asserts.js';
 import {calculateSourceResolution} from '../reproj.js';
-import {ceil, floor, round} from '../math.js';
 import {compareVersions} from '../string.js';
-import {
-  containsExtent,
-  getCenter,
-  getForViewAndSize,
-  getHeight,
-  getWidth,
-} from '../extent.js';
-import {createCanvasContext2D} from '../dom.js';
+import {decode} from '../Image.js';
+import {floor} from '../math.js';
+import {getForViewAndSize} from '../extent.js';
 import {get as getProjection, transform} from '../proj.js';
 
-/**
- * Number of decimal digits to consider in integer values when rounding.
- * @type {number}
- */
-const DECIMALS = 4;
-
 /**
  * @const
  * @type {import("../size.js").Size}
@@ -53,8 +44,7 @@ const GETFEATUREINFO_IMAGE_SIZE = [101, 101];
  * and `CRS` (`SRS` for WMS version < 1.3.0) will be set dynamically.
  * @property {import("../proj.js").ProjectionLike} [projection] Projection. Default is the view projection.
  * @property {number} [ratio=1.5] Ratio. `1` means image requests are the size of the map viewport, `2` means
- * twice the width and height of the map viewport, and so on. Must be `1` or
- * higher.
+ * twice the width and height of the map viewport, and so on. Must be `1` or higher.
  * @property {Array<number>} [resolutions] Resolutions.
  * If specified, requests will be made for these resolutions only.
  * @property {string} [url] WMS service URL.
@@ -81,12 +71,6 @@ class ImageWMS extends ImageSource {
       resolutions: options.resolutions,
     });
 
-    /**
-     * @private
-     * @type {CanvasRenderingContext2D}
-     */
-    this.context_ = createCanvasContext2D(1, 1);
-
     /**
      * @private
      * @type {?string}
@@ -113,14 +97,7 @@ class ImageWMS extends ImageSource {
      * @private
      * @type {!Object}
      */
-    this.params_ = Object.assign({}, options.params);
-
-    /**
-     * @private
-     * @type {boolean}
-     */
-    this.v13_ = true;
-    this.updateV13_();
+    this.params_ = options.params;
 
     /**
      * @private
@@ -134,18 +111,6 @@ class ImageWMS extends ImageSource {
      */
     this.hidpi_ = options.hidpi !== undefined ? options.hidpi : true;
 
-    /**
-     * @private
-     * @type {import("../Image.js").default}
-     */
-    this.image_ = null;
-
-    /**
-     * @private
-     * @type {import("../size.js").Size}
-     */
-    this.imageSize_ = [0, 0];
-
     /**
      * @private
      * @type {number}
@@ -198,24 +163,24 @@ class ImageWMS extends ImageSource {
     );
 
     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 = floor((coordinate[0] - extent[0]) / resolution, DECIMALS);
     const y = floor((extent[3] - coordinate[1]) / resolution, DECIMALS);
-    baseParams[this.v13_ ? 'I' : 'X'] = x;
-    baseParams[this.v13_ ? 'J' : 'Y'] = y;
+    const v13 = compareVersions(baseParams['VERSION'], '1.3') >= 0;
+    baseParams[v13 ? 'I' : 'X'] = x;
+    baseParams[v13 ? 'J' : 'Y'] = y;
 
-    return this.getRequestUrl_(
+    return getRequestUrl(
+      this.url_,
       extent,
       GETFEATUREINFO_IMAGE_SIZE,
-      1,
       sourceProjectionObj || projectionObj,
       baseParams
     );
@@ -290,86 +255,25 @@ class ImageWMS extends ImageSource {
     if (this.url_ === undefined) {
       return null;
     }
-
-    resolution = this.findNearestResolution(resolution);
-
-    if (pixelRatio != 1 && (!this.hidpi_ || this.serverType_ === undefined)) {
-      pixelRatio = 1;
-    }
-
-    const imageResolution = resolution / pixelRatio;
-
-    const center = getCenter(extent);
-    const viewWidth = ceil(getWidth(extent) / imageResolution, DECIMALS);
-    const viewHeight = ceil(getHeight(extent) / imageResolution, DECIMALS);
-    const viewExtent = getForViewAndSize(center, imageResolution, 0, [
-      viewWidth,
-      viewHeight,
-    ]);
-    const marginWidth = ceil(((this.ratio_ - 1) * viewWidth) / 2, DECIMALS);
-    const requestWidth = viewWidth + 2 * marginWidth;
-    const marginHeight = ceil(((this.ratio_ - 1) * viewHeight) / 2, DECIMALS);
-    const requestHeight = viewHeight + 2 * marginHeight;
-    const requestExtent = getForViewAndSize(center, imageResolution, 0, [
-      requestWidth,
-      requestHeight,
-    ]);
-
-    const image = this.image_;
-    if (
-      image &&
-      this.renderedRevision_ == this.getRevision() &&
-      image.getResolution() == resolution &&
-      image.getPixelRatio() == pixelRatio &&
-      containsExtent(image.getExtent(), viewExtent)
-    ) {
-      return image;
+    if (!this.loader) {
+      // Lazily create loader to pick up the view projection and to allow `params` updates
+      this.loader = createLoader({
+        crossOrigin: this.crossOrigin_,
+        params: this.params_,
+        projection: projection,
+        serverType: this.serverType_,
+        hidpi: this.hidpi_,
+        url: this.url_,
+        ratio: this.ratio_,
+        load: (image, src) => {
+          this.image.setImage(image);
+          this.imageLoadFunction_(this.image, src);
+          return decode(image);
+        },
+      });
     }
 
-    const params = {
-      'SERVICE': 'WMS',
-      'VERSION': DEFAULT_VERSION,
-      'REQUEST': 'GetMap',
-      'FORMAT': 'image/png',
-      'TRANSPARENT': true,
-    };
-    Object.assign(params, this.params_);
-
-    this.imageSize_[0] = round(
-      getWidth(requestExtent) / imageResolution,
-      DECIMALS
-    );
-    this.imageSize_[1] = round(
-      getHeight(requestExtent) / imageResolution,
-      DECIMALS
-    );
-
-    const url = this.getRequestUrl_(
-      requestExtent,
-      this.imageSize_,
-      pixelRatio,
-      projection,
-      params
-    );
-
-    this.image_ = new ImageWrapper(
-      requestExtent,
-      resolution,
-      pixelRatio,
-      url,
-      this.crossOrigin_,
-      this.imageLoadFunction_,
-      this.context_
-    );
-
-    this.renderedRevision_ = this.getRevision();
-
-    this.image_.addEventListener(
-      EventType.CHANGE,
-      this.handleImageChange.bind(this)
-    );
-
-    return this.image_;
+    return super.getImageInternal(extent, resolution, pixelRatio, projection);
   }
 
   /**
@@ -381,62 +285,6 @@ class ImageWMS extends ImageSource {
     return this.imageLoadFunction_;
   }
 
-  /**
-   * @param {import("../extent.js").Extent} extent Extent.
-   * @param {import("../size.js").Size} size Size.
-   * @param {number} pixelRatio Pixel ratio.
-   * @param {import("../proj/Projection.js").default} projection Projection.
-   * @param {Object} params Params.
-   * @return {string} Request URL.
-   * @private
-   */
-  getRequestUrl_(extent, size, pixelRatio, projection, params) {
-    assert(this.url_ !== undefined, 9); // `url` must be configured or set using `#setUrl()`
-
-    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, 8);
-          break;
-      }
-    }
-
-    params['WIDTH'] = size[0];
-    params['HEIGHT'] = size[1];
-
-    const axisOrientation = projection.getAxisOrientation();
-    let bbox;
-    if (this.v13_ && axisOrientation.substr(0, 2) == 'ne') {
-      bbox = [extent[1], extent[0], extent[3], extent[2]];
-    } else {
-      bbox = extent;
-    }
-    params['BBOX'] = bbox.join(',');
-
-    return appendParams(/** @type {string} */ (this.url_), params);
-  }
-
   /**
    * Return the URL used for this WMS source.
    * @return {string|undefined} URL.
@@ -452,7 +300,6 @@ class ImageWMS extends ImageSource {
    * @api
    */
   setImageLoadFunction(imageLoadFunction) {
-    this.image_ = null;
     this.imageLoadFunction_ = imageLoadFunction;
     this.changed();
   }
@@ -465,7 +312,7 @@ class ImageWMS extends ImageSource {
   setUrl(url) {
     if (url != this.url_) {
       this.url_ = url;
-      this.image_ = null;
+      this.loader = null;
       this.changed();
     }
   }
@@ -477,17 +324,12 @@ class ImageWMS extends ImageSource {
    */
   updateParams(params) {
     Object.assign(this.params_, params);
-    this.updateV13_();
-    this.image_ = null;
     this.changed();
   }
 
-  /**
-   * @private
-   */
-  updateV13_() {
-    const version = this.params_['VERSION'] || DEFAULT_VERSION;
-    this.v13_ = compareVersions(version, '1.3') >= 0;
+  changed() {
+    this.image = null;
+    super.changed();
   }
 }
 

package/source/{Stamen.d.ts → StadiaMaps.d.ts}

@@ -1,4 +1,4 @@
-export default Stamen;
+export default StadiaMaps;
 export type Options = {
     /**
      * Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
@@ -10,7 +10,7 @@ export type Options = {
      */
     interpolate?: boolean | undefined;
     /**
-     * Layer name.
+     * 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`.
      */
     layer: string;
     /**
@@ -53,13 +53,21 @@ export type Options = {
      * zoom levels. See {@link module :ol/tilegrid/TileGrid~TileGrid#getZForResolution}.
      */
     zDirection?: number | import("../array.js").NearestDirectionFunction | undefined;
+    /**
+     * Stadia Maps API key. Not required for localhost or most public web deployments. See https://docs.stadiamaps.com/authentication/ for details.
+     */
+    apiKey: string;
+    /**
+     * Use retina tiles (if available; not available for Stamen Watercolor).
+     */
+    retina: boolean;
 };
 /**
  * @typedef {Object} Options
  * @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).
@@ -78,17 +86,19 @@ export type Options = {
  * @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
  */
-declare class Stamen extends XYZ {
+declare class StadiaMaps extends XYZ {
     /**
-     * @param {Options} options Stamen options.
+     * @param {Options} options StadiaMaps options.
      */
     constructor(options: Options);
 }
 import XYZ from './XYZ.js';
-//# sourceMappingURL=Stamen.d.ts.map
+//# sourceMappingURL=StadiaMaps.d.ts.map

package/source/StadiaMaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StadiaMaps.d.ts","sourceRoot":"","sources":["StadiaMaps.js"],"names":[],"mappings":";;;;;;;;;;;;;;WAoHc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAmBN,MAAM;;;;YACN,OAAO;;AAzBrB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAsDjB;CACF;gBArMe,UAAU"}