ol 9.2.5-sh.2 → 10.0.1-dev.1722076459273

package/source/VectorTile.js

@@ -16,7 +16,7 @@ import {
   intersects,
 } from '../extent.js';
 import {createXYZ, extentFromProjection} from '../tilegrid.js';
-import {fromKey, getCacheKeyForTileKey, getKeyZXY} from '../tilecoord.js';
+import {getCacheKeyForTileKey} from '../tilecoord.js';
 import {isEmpty} from '../obj.js';
 import {loadFeaturesXhr} from '../featureloader.js';
 import {toSize} from '../size.js';
@@ -28,7 +28,7 @@ import {toSize} from '../size.js';
  * @property {boolean} [attributionsCollapsible=true] Attributions are collapsible.
  * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least twice the number of tiles in the viewport.
  * @property {import("../extent.js").Extent} [extent] Extent.
- * @property {import("../format/Feature.js").default<import("../format/Feature.js").FeatureToFeatureClass<FeatureType>>} [format] Feature format for tiles. Used and required by the default.
+ * @property {import("../format/Feature.js").default<FeatureType>} [format] Feature format for tiles. Used and required by the default.
  * @property {boolean} [overlaps=true] This source may have overlapping geometries. Setting this
  * to `false` (e.g. for sources with polygons that represent administrative
  * boundaries or TopoJSON sources) allows the renderer to optimise fill and
@@ -125,7 +125,6 @@ class VectorTile extends UrlTile {
       attributionsCollapsible: options.attributionsCollapsible,
       cacheSize: options.cacheSize,
       interpolate: true,
-      opaque: false,
       projection: projection,
       state: options.state,
       tileGrid: tileGrid,
@@ -142,7 +141,7 @@ class VectorTile extends UrlTile {
 
     /**
      * @private
-     * @type {import("../format/Feature.js").default<import("../format/Feature.js").FeatureToFeatureClass<FeatureType>>|null}
+     * @type {import("../format/Feature.js").default<FeatureType>|null}
      */
     this.format_ = options.format ? options.format : null;
 
@@ -150,7 +149,7 @@ class VectorTile extends UrlTile {
      * @private
      * @type {TileCache}
      */
-    this.sourceTileCache = new TileCache(this.tileCache.highWaterMark);
+    this.sourceTileCache_ = new TileCache(128);
 
     /**
      * @private
@@ -171,51 +170,6 @@ class VectorTile extends UrlTile {
     this.tileGrids_ = {};
   }
 
-  /**
-   * Get features whose bounding box intersects the provided extent. Only features for cached
-   * tiles for the last rendered zoom level are available in the source. So this method is only
-   * suitable for requesting tiles for extents that are currently rendered.
-   *
-   * Features are returned in random tile order and as they are included in the tiles. This means
-   * they can be clipped, duplicated across tiles, and simplified to the render resolution.
-   *
-   * @param {import("../extent.js").Extent} extent Extent.
-   * @return {Array<FeatureType>} Features.
-   * @api
-   */
-  getFeaturesInExtent(extent) {
-    const features = [];
-    const tileCache = this.tileCache;
-    if (tileCache.getCount() === 0) {
-      return features;
-    }
-    const z = fromKey(tileCache.peekFirstKey())[0];
-    const tileGrid = this.tileGrid;
-    tileCache.forEach(function (tile) {
-      if (tile.tileCoord[0] !== z || tile.getState() !== TileState.LOADED) {
-        return;
-      }
-      const sourceTiles = tile.getSourceTiles();
-      for (let i = 0, ii = sourceTiles.length; i < ii; ++i) {
-        const sourceTile = sourceTiles[i];
-        const tileCoord = sourceTile.tileCoord;
-        if (intersects(extent, tileGrid.getTileCoordExtent(tileCoord))) {
-          const tileFeatures = sourceTile.getFeatures();
-          if (tileFeatures) {
-            for (let j = 0, jj = tileFeatures.length; j < jj; ++j) {
-              const candidate = tileFeatures[j];
-              const geometry = candidate.getGeometry();
-              if (intersects(extent, geometry.getExtent())) {
-                features.push(candidate);
-              }
-            }
-          }
-        }
-      }
-    });
-    return features;
-  }
-
   /**
    * @return {boolean} The source can have overlapping geometries.
    */
@@ -226,15 +180,16 @@ class VectorTile extends UrlTile {
   /**
    * clear {@link module:ol/TileCache~TileCache} and delete all source tiles
    * @api
+   * @override
    */
   clear() {
-    this.tileCache.clear();
-    this.sourceTileCache.clear();
+    this.sourceTileCache_.clear();
   }
 
   /**
    * @param {import("../proj/Projection.js").default} projection Projection.
    * @param {!Object<string, boolean>} usedTiles Used tiles.
+   * @override
    */
   expireCache(projection, usedTiles) {
     const tileCache = this.getTileCacheForProjection(projection);
@@ -250,7 +205,7 @@ class VectorTile extends UrlTile {
       return acc;
     }, {});
     super.expireCache(projection, usedTiles);
-    this.sourceTileCache.expireCache(usedSourceTiles);
+    this.sourceTileCache_.expireCache(usedSourceTiles);
   }
 
   /**
@@ -285,8 +240,8 @@ class VectorTile extends UrlTile {
           pixelRatio,
           projection,
         );
-        const sourceTile = this.sourceTileCache.containsKey(tileUrl)
-          ? this.sourceTileCache.get(tileUrl)
+        const sourceTile = this.sourceTileCache_.containsKey(tileUrl)
+          ? this.sourceTileCache_.get(tileUrl)
           : new this.tileClass(
               sourceTileCoord,
               tileUrl ? TileState.IDLE : TileState.EMPTY,
@@ -333,7 +288,7 @@ class VectorTile extends UrlTile {
           sourceTile.resolution = sourceTileGrid.getResolution(
             sourceTileCoord[0],
           );
-          this.sourceTileCache.set(tileUrl, sourceTile);
+          this.sourceTileCache_.set(tileUrl, sourceTile);
           sourceTile.load();
         }
       });
@@ -358,17 +313,9 @@ class VectorTile extends UrlTile {
    * @param {number} pixelRatio Pixel ratio.
    * @param {import("../proj/Projection.js").default} projection Projection.
    * @return {!VectorRenderTile} Tile.
+   * @override
    */
   getTile(z, x, y, pixelRatio, projection) {
-    const coordKey = getKeyZXY(z, x, y);
-    const key = this.getKey();
-    let tile;
-    if (this.tileCache.containsKey(coordKey)) {
-      tile = this.tileCache.get(coordKey);
-      if (tile.key === key) {
-        return tile;
-      }
-    }
     const tileCoord = [z, x, y];
     let urlTileCoord = this.getTileCoordForTileUrlFunction(
       tileCoord,
@@ -404,21 +351,14 @@ class VectorTile extends UrlTile {
       urlTileCoord,
       this.getSourceTiles.bind(this, pixelRatio, projection),
     );
-
-    newTile.key = key;
-    if (tile) {
-      newTile.interimTile = tile;
-      newTile.refreshInterimChain();
-      this.tileCache.replace(coordKey, newTile);
-    } else {
-      this.tileCache.set(coordKey, newTile);
-    }
+    newTile.key = this.getKey();
     return newTile;
   }
 
   /**
    * @param {import("../proj/Projection.js").default} projection Projection.
    * @return {!import("../tilegrid/TileGrid.js").default} Tile grid.
+   * @override
    */
   getTileGridForProjection(projection) {
     const code = projection.getCode();
@@ -455,6 +395,7 @@ class VectorTile extends UrlTile {
    * Get the tile pixel ratio for this source.
    * @param {number} pixelRatio Pixel ratio.
    * @return {number} Tile pixel ratio.
+   * @override
    */
   getTilePixelRatio(pixelRatio) {
     return pixelRatio;
@@ -465,6 +406,7 @@ class VectorTile extends UrlTile {
    * @param {number} pixelRatio Pixel ratio.
    * @param {import("../proj/Projection.js").default} projection Projection.
    * @return {import("../size.js").Size} Tile size.
+   * @override
    */
   getTilePixelSize(z, pixelRatio, projection) {
     const tileGrid = this.getTileGridForProjection(projection);
@@ -474,17 +416,6 @@ class VectorTile extends UrlTile {
       Math.round(tileSize[1] * pixelRatio),
     ];
   }
-
-  /**
-   * Increases the cache size if needed
-   * @param {number} tileCount Minimum number of tiles needed.
-   * @param {import("../proj/Projection.js").default} projection Projection.
-   */
-  updateCacheSize(tileCount, projection) {
-    super.updateCacheSize(tileCount * 2, projection);
-    this.sourceTileCache.highWaterMark =
-      this.getTileCacheForProjection(projection).highWaterMark;
-  }
 }
 
 export default VectorTile;

package/source/WMTS.d.ts

@@ -27,7 +27,7 @@ export default WMTS;
 /**
  * Request encoding. One of 'KVP', 'REST'.
  */
-export type RequestEncoding = 'KVP' | 'REST';
+export type RequestEncoding = "KVP" | "REST";
 export type Options = {
     /**
      * Attributions.
@@ -38,7 +38,7 @@ export type Options = {
      */
     attributionsCollapsible?: boolean | undefined;
     /**
-     * Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
+     * Deprecated.  Use the cacheSize option on the layer instead.
      */
     cacheSize?: number | undefined;
     /**
@@ -150,7 +150,7 @@ export type Options = {
  * @typedef {Object} Options
  * @property {import("./Source.js").AttributionLike} [attributions] Attributions.
  * @property {boolean} [attributionsCollapsible=true] Attributions are collapsible.
- * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
+ * @property {number} [cacheSize] Deprecated.  Use the cacheSize option on the layer instead.
  * @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.

package/source/WMTS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WMTS.d.ts","sourceRoot":"","sources":["WMTS.js"],"names":[],"mappings":"AAiVA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,oEAHY,OAAO,GAAC,IAAI,CAuOvB;;;;;8BAhkBY,KAAK,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAab,OAAO,qBAAqB,EAAE,OAAO;;;;iBACrC,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;WAInC,MAAM;;;;WACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;eAQN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA7BpB;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAwFjB;IArDC;;;OAGG;IACH,iBAAyE;IAEzE;;;OAGG;IACH,gBAA2E;IAE3E;;;OAGG;IACH,oBAC4D;IAE5D;;;OAGG;IACH,eAA2B;IAE3B;;;OAGG;IACH,mBAAmC;IAEnC;;;OAGG;IACH,eAA2B;IAK3B;;;OAGG;IACH,yBAAuC;IA2BzC;;;;;;OAMG;IACH,qBAEC;IAED;;;;OAIG;IACH,aAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,YAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,gBAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,sBAHY,eAAe,CAK1B;IAED;;;;OAIG;IACH,YAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,cAHY,MAAM,CAKjB;IAED;;;OAGG;IACH,6BAMC;IAED;;;;OAIG;IACH,wCAGC;IAED;;;OAGG;IACH,iCAHW,MAAM,GACL,OAAO,YAAY,EAAE,WAAW,CAkE3C;CACF;sBAzUqB,gBAAgB"}
+{"version":3,"file":"WMTS.d.ts","sourceRoot":"","sources":["WMTS.js"],"names":[],"mappings":"AAkVA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,8DArBW,GAAO,GAkBN,OAAO,GAAC,IAAI,CAuOvB;;;;;8BAjkBY,KAAK,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAab,OAAO,qBAAqB,EAAE,OAAO;;;;iBACrC,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;WAInC,MAAM;;;;WACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;eAQN,MAAM;;;;;iBACN,GAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA9BrB;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAwFjB;IArDC;;;OAGG;IACH,iBAAyE;IAEzE;;;OAGG;IACH,gBAA2E;IAE3E;;;OAGG;IACH,oBAC4D;IAE5D;;;OAGG;IACH,eAA2B;IAE3B;;;OAGG;IACH,mBAAmC;IAEnC;;;OAGG;IACH,eAA2B;IAK3B;;;OAGG;IACH,yBAAuC;IA4BzC;;;;;;OAMG;IACH,iBAHY,GAAO,CAKlB;IAED;;;;OAIG;IACH,aAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,YAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,gBAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,sBAHY,eAAe,CAK1B;IAED;;;;OAIG;IACH,YAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,cAHY,MAAM,CAKjB;IAED;;;OAGG;IACH,6BAMC;IAED;;;;OAIG;IACH,wCAGC;IAED;;;OAGG;IACH,iCAHW,MAAM,GACL,OAAO,YAAY,EAAE,WAAW,CAkE3C;CACF;sBA1UqB,gBAAgB"}

package/source/WMTS.js

@@ -3,10 +3,10 @@
  */
 
 import TileImage from './TileImage.js';
-import {appendParams} from '../uri.js';
+import {appendParams, expandUrl} from '../uri.js';
 import {containsExtent} from '../extent.js';
 import {createFromCapabilitiesMatrixSet} from '../tilegrid/WMTS.js';
-import {createFromTileUrlFunctions, expandUrl} from '../tileurlfunction.js';
+import {createFromTileUrlFunctions} from '../tileurlfunction.js';
 import {equivalent, get as getProjection, transformExtent} from '../proj.js';
 
 /**
@@ -18,7 +18,7 @@ import {equivalent, get as getProjection, transformExtent} from '../proj.js';
  * @typedef {Object} Options
  * @property {import("./Source.js").AttributionLike} [attributions] Attributions.
  * @property {boolean} [attributionsCollapsible=true] Attributions are collapsible.
- * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
+ * @property {number} [cacheSize] Deprecated.  Use the cacheSize option on the layer instead.
  * @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.
@@ -163,6 +163,7 @@ class WMTS extends TileImage {
    * Set the URLs to use for requests.
    * URLs may contain OGC conform URL Template Variables: {TileMatrix}, {TileRow}, {TileCol}.
    * @param {Array<string>} urls URLs.
+   * @override
    */
   setUrls(urls) {
     this.urls = urls;
@@ -448,7 +449,7 @@ export function optionsFromCapabilities(wmtsCap, config) {
   }
 
   let wrapX = false;
-  const switchXY = projection.getAxisOrientation().substr(0, 2) == 'ne';
+  const switchXY = projection.getAxisOrientation().startsWith('ne');
 
   let matrix = matrixSetObj.TileMatrix[0];
 

package/source/XYZ.d.ts

@@ -9,7 +9,7 @@ export type Options = {
      */
     attributionsCollapsible?: boolean | undefined;
     /**
-     * Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
+     * Deprecated.  Use the cacheSize option on the layer instead.
      */
     cacheSize?: number | undefined;
     /**
@@ -23,10 +23,6 @@ export type Options = {
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
      */
     interpolate?: boolean | undefined;
-    /**
-     * Whether the layer is opaque.
-     */
-    opaque?: boolean | undefined;
     /**
      * Projection.
      */
@@ -53,7 +49,8 @@ export type Options = {
      */
     tileGrid?: import("../tilegrid.js").TileGrid | undefined;
     /**
-     * Optional function to load a tile given a URL. The default is
+     * Deprecated.  Use an ImageTile source with a loader
+     * instead.  Optional function to load a tile given a URL. The default is
      * ```js
      * function(imageTile, src) {
      * imageTile.getImage().src = src;
@@ -80,9 +77,8 @@ export type Options = {
      */
     gutter?: number | undefined;
     /**
-     * Optional function to get
-     * tile URL given a tile coordinate and the projection.
-     * Required if `url` or `urls` are not provided.
+     * Deprecated.  Use an ImageTile source and provide a function
+     * for the url option instead.
      */
     tileUrlFunction?: import("../Tile.js").UrlFunction | undefined;
     /**
@@ -92,7 +88,8 @@ export type Options = {
      */
     url?: string | undefined;
     /**
-     * An array of URL templates.
+     * Deprecated.  Use an ImageTile source and provide an array of URLs for the
+     * url option instead.
      */
     urls?: string[] | undefined;
     /**
@@ -114,13 +111,12 @@ export type Options = {
  * @typedef {Object} Options
  * @property {import("./Source.js").AttributionLike} [attributions] Attributions.
  * @property {boolean} [attributionsCollapsible=true] Attributions are collapsible.
- * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
+ * @property {number} [cacheSize] Deprecated.  Use the cacheSize option on the layer instead.
  * @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} [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 {boolean} [opaque=false] Whether the layer is opaque.
  * @property {import("../proj.js").ProjectionLike} [projection='EPSG:3857'] Projection.
  * @property {number} [reprojectionErrorThreshold=0.5] Maximum allowed reprojection error (in pixels).
  * Higher values can increase reprojection performance, but decrease precision.
@@ -128,7 +124,8 @@ export type Options = {
  * @property {number} [minZoom=0] Optional min zoom level. Not used if `tileGrid` is provided.
  * @property {number} [maxResolution] Optional tile grid resolution at level zero. Not used if `tileGrid` is provided.
  * @property {import("../tilegrid/TileGrid.js").default} [tileGrid] Tile grid.
- * @property {import("../Tile.js").LoadFunction} [tileLoadFunction] Optional function to load a tile given a URL. The default is
+ * @property {import("../Tile.js").LoadFunction} [tileLoadFunction] Deprecated.  Use an ImageTile source with a loader
+ * instead.  Optional function to load a tile given a URL. The default is
  * ```js
  * function(imageTile, src) {
  *   imageTile.getImage().src = src;
@@ -143,13 +140,13 @@ export type Options = {
  * @property {number} [gutter=0] The size in pixels of the gutter around image tiles to ignore.
  * This allows artifacts of rendering at tile edges to be ignored.
  * Supported images should be wider and taller than the tile size by a value of `2 x gutter`.
- * @property {import("../Tile.js").UrlFunction} [tileUrlFunction] Optional function to get
- * tile URL given a tile coordinate and the projection.
- * Required if `url` or `urls` are not provided.
+ * @property {import("../Tile.js").UrlFunction} [tileUrlFunction] Deprecated.  Use an ImageTile source and provide a function
+ * for the url option instead.
  * @property {string} [url] URL template. Must include `{x}`, `{y}` or `{-y}`,
  * and `{z}` placeholders. A `{?-?}` template pattern, for example `subdomain{a-f}.domain.com`,
  * may be used instead of defining each one separately in the `urls` option.
- * @property {Array<string>} [urls] An array of URL templates.
+ * @property {Array<string>} [urls] Deprecated.  Use an ImageTile source and provide an array of URLs for the
+ * url option instead.
  * @property {boolean} [wrapX=true] Whether to wrap the world horizontally.
  * @property {number} [transition=250] Duration of the opacity transition for rendering.
  * To disable the opacity transition, pass `transition: 0`.

package/source/XYZ.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"XYZ.d.ts","sourceRoot":"","sources":["XYZ.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAXjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IACE;;OAEG;IACH,2CA0CC;IALC;;;OAGG;IACH,gBAAgE;CASnE;sBA1HqB,gBAAgB"}
+{"version":3,"file":"XYZ.d.ts","sourceRoot":"","sources":["XYZ.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAVjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IACE;;OAEG;IACH,2CAyCC;IALC;;;OAGG;IACH,gBAAgE;CAUnE;sBA1HqB,gBAAgB"}

package/source/XYZ.js

@@ -9,13 +9,12 @@ import {createXYZ, extentFromProjection} from '../tilegrid.js';
  * @typedef {Object} Options
  * @property {import("./Source.js").AttributionLike} [attributions] Attributions.
  * @property {boolean} [attributionsCollapsible=true] Attributions are collapsible.
- * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
+ * @property {number} [cacheSize] Deprecated.  Use the cacheSize option on the layer instead.
  * @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} [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 {boolean} [opaque=false] Whether the layer is opaque.
  * @property {import("../proj.js").ProjectionLike} [projection='EPSG:3857'] Projection.
  * @property {number} [reprojectionErrorThreshold=0.5] Maximum allowed reprojection error (in pixels).
  * Higher values can increase reprojection performance, but decrease precision.
@@ -23,7 +22,8 @@ import {createXYZ, extentFromProjection} from '../tilegrid.js';
  * @property {number} [minZoom=0] Optional min zoom level. Not used if `tileGrid` is provided.
  * @property {number} [maxResolution] Optional tile grid resolution at level zero. Not used if `tileGrid` is provided.
  * @property {import("../tilegrid/TileGrid.js").default} [tileGrid] Tile grid.
- * @property {import("../Tile.js").LoadFunction} [tileLoadFunction] Optional function to load a tile given a URL. The default is
+ * @property {import("../Tile.js").LoadFunction} [tileLoadFunction] Deprecated.  Use an ImageTile source with a loader
+ * instead.  Optional function to load a tile given a URL. The default is
  * ```js
  * function(imageTile, src) {
  *   imageTile.getImage().src = src;
@@ -38,13 +38,13 @@ import {createXYZ, extentFromProjection} from '../tilegrid.js';
  * @property {number} [gutter=0] The size in pixels of the gutter around image tiles to ignore.
  * This allows artifacts of rendering at tile edges to be ignored.
  * Supported images should be wider and taller than the tile size by a value of `2 x gutter`.
- * @property {import("../Tile.js").UrlFunction} [tileUrlFunction] Optional function to get
- * tile URL given a tile coordinate and the projection.
- * Required if `url` or `urls` are not provided.
+ * @property {import("../Tile.js").UrlFunction} [tileUrlFunction] Deprecated.  Use an ImageTile source and provide a function
+ * for the url option instead.
  * @property {string} [url] URL template. Must include `{x}`, `{y}` or `{-y}`,
  * and `{z}` placeholders. A `{?-?}` template pattern, for example `subdomain{a-f}.domain.com`,
  * may be used instead of defining each one separately in the `urls` option.
- * @property {Array<string>} [urls] An array of URL templates.
+ * @property {Array<string>} [urls] Deprecated.  Use an ImageTile source and provide an array of URLs for the
+ * url option instead.
  * @property {boolean} [wrapX=true] Whether to wrap the world horizontally.
  * @property {number} [transition=250] Duration of the opacity transition for rendering.
  * To disable the opacity transition, pass `transition: 0`.
@@ -96,7 +96,6 @@ class XYZ extends TileImage {
       cacheSize: options.cacheSize,
       crossOrigin: options.crossOrigin,
       interpolate: options.interpolate,
-      opaque: options.opaque,
       projection: projection,
       reprojectionErrorThreshold: options.reprojectionErrorThreshold,
       tileGrid: tileGrid,
@@ -120,6 +119,7 @@ class XYZ extends TileImage {
 
   /**
    * @return {number} Gutter.
+   * @override
    */
   getGutter() {
     return this.gutter_;

package/source/Zoomify.d.ts

@@ -18,19 +18,20 @@ export class CustomTile extends ImageTile {
      */
     private zoomifyImage_;
     /**
+     * @private
      * @type {import("../size.js").Size}
      */
-    tileSize_: import("../size.js").Size;
+    private tileSize_;
 }
 export default Zoomify;
-export type TierSizeCalculation = 'default' | 'truncated';
+export type TierSizeCalculation = "default" | "truncated";
 export type Options = {
     /**
      * Attributions.
      */
     attributions?: import("./Source.js").AttributionLike | undefined;
     /**
-     * Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
+     * Deprecated.  Use the cacheSize option on the layer instead.
      */
     cacheSize?: number | undefined;
     /**
@@ -106,7 +107,7 @@ import ImageTile from '../ImageTile.js';
 /**
  * @typedef {Object} Options
  * @property {import("./Source.js").AttributionLike} [attributions] Attributions.
- * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
+ * @property {number} [cacheSize] Deprecated.  Use the cacheSize option on the layer instead.
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value  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.

package/source/Zoomify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Zoomify.d.ts","sourceRoot":"","sources":["Zoomify.js"],"names":[],"mappings":"AAcA;;GAEG;AAEH;IACE;;;;;;;;OAQG;IACH,sBARW,OAAO,YAAY,EAAE,IAAI,aACzB,OAAO,iBAAiB,EAAE,SAAS,mBAEnC,MAAM,eACL,MAAM,2BACP,OAAO,YAAY,EAAE,YAAY,sDAwB3C;IAVC;;;OAGG;IACH,sBAAyB;IAEzB;;OAEG;IACH,WAFU,OAAO,YAAY,EAAE,IAAI,CAEV;CAyB5B;;kCA1DY,SAAS,GAAG,WAAW;;;;;;;;;;;;;;;;;;;;;;;;iBAqEtB,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;SAInC,MAAM;;;;;;;;UAYN,OAAO,YAAY,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;sBA/FjB,iBAAiB;AAsEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH;;;;;GAKG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EA4JjB;CACF;sBAhRqB,gBAAgB"}
+{"version":3,"file":"Zoomify.d.ts","sourceRoot":"","sources":["Zoomify.js"],"names":[],"mappings":"AAeA;;GAEG;AAEH;IACE;;;;;;;;OAQG;IACH,sBARW,OAAO,YAAY,EAAE,IAAI,aACzB,OAAO,iBAAiB,EAAE,SAAS,SACnC,GAAiC,OACjC,MAAM,eACL,MAAM,OAAA,oBACP,OAAO,YAAY,EAAE,YAAY,sDAyB3C;IAXC;;;OAGG;IACH,sBAAyB;IAEzB;;;OAGG;IACH,kBAAyB;CA0B5B;;kCA5DY,SAAS,GAAG,WAAW;;;;;;;;;;;;;;;;;;;;;;;;iBAuEtB,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;SAInC,MAAM;;;;;;;;UAYN,OAAO,YAAY,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;sBAlGjB,iBAAiB;AAyEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH;;;;;GAKG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EA4JjB;CACF;sBAnRqB,gBAAgB"}

package/source/Zoomify.js

@@ -8,7 +8,8 @@ import TileGrid from '../tilegrid/TileGrid.js';
 import TileImage from './TileImage.js';
 import TileState from '../TileState.js';
 import {createCanvasContext2D} from '../dom.js';
-import {createFromTileUrlFunctions, expandUrl} from '../tileurlfunction.js';
+import {createFromTileUrlFunctions} from '../tileurlfunction.js';
+import {expandUrl} from '../uri.js';
 import {getCenter} from '../extent.js';
 import {toSize} from '../size.js';
 
@@ -44,6 +45,7 @@ export class CustomTile extends ImageTile {
     this.zoomifyImage_ = null;
 
     /**
+     * @private
      * @type {import("../size.js").Size}
      */
     this.tileSize_ = tileSize;
@@ -52,6 +54,7 @@ export class CustomTile extends ImageTile {
   /**
    * Get the image element for this tile.
    * @return {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} Image.
+   * @override
    */
   getImage() {
     if (this.zoomifyImage_) {
@@ -76,7 +79,7 @@ export class CustomTile extends ImageTile {
 /**
  * @typedef {Object} Options
  * @property {import("./Source.js").AttributionLike} [attributions] Attributions.
- * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
+ * @property {number} [cacheSize] Deprecated.  Use the cacheSize option on the layer instead.
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value  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.

package/source/arcgisRest.d.ts

@@ -26,7 +26,7 @@ export function getRequestUrl(baseUrl: string, extent: import("../extent.js").Ex
  * 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
+ * @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
@@ -38,7 +38,7 @@ export function getRequestUrl(baseUrl: string, extent: import("../extent.js").Ex
  * @return {import('../Image.js').ImageObjectPromiseLoader} ArcGIS Rest image.
  * @api
  */
-export function createLoader(options: LoaderOptions): import('../Image.js').ImageObjectPromiseLoader;
+export function createLoader(options: LoaderOptions): import("../Image.js").ImageObjectPromiseLoader;
 export type LoaderOptions = {
     /**
      * The `crossOrigin` attribute for loaded images.  Note that
@@ -77,12 +77,12 @@ export type LoaderOptions = {
      * ArcGIS Rest service URL for a Map Service or Image Service. The url
      * should include /MapServer or /ImageServer.
      */
-    url?: string | undefined;
+    url: string;
     /**
      * 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;
+    load?: ((arg0: HTMLImageElement, arg1: string) => Promise<import("../DataTile.js").ImageLike>) | undefined;
 };
 //# sourceMappingURL=arcgisRest.d.ts.map

package/source/arcgisRest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arcgisRest.d.ts","sourceRoot":"","sources":["arcgisRest.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AACH,uCARW,MAAM,UACN,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,gBAEtC,MAAM,CAqCjB;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"}
+{"version":3,"file":"arcgisRest.d.ts","sourceRoot":"","sources":["arcgisRest.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AACH,uCARW,MAAM,UACN,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,gBAEtC,MAAM,CAqCjB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;GAKG;AACH,sCAJW,aAAa,GACZ,OAAO,aAAa,EAAE,wBAAwB,CAwCzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAvDa,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;SAKnC,MAAM;;;;;;mBAEG,gBAAgB,QAAE,MAAM,KAAG,OAAO,CAAC,OAAO,gBAAgB,EAAE,SAAS,CAAC"}

package/source/arcgisRest.js

@@ -74,7 +74,7 @@ export function getRequestUrl(
  * 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
+ * @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
@@ -90,6 +90,8 @@ export function getRequestUrl(
 export function createLoader(options) {
   const load = options.load ? options.load : decode;
   const projection = getProjection(options.projection || 'EPSG:3857');
+  const ratio = options.ratio ?? 1.5;
+  const crossOrigin = options.crossOrigin ?? null;
 
   /** @type {import('../Image.js').ImageObjectPromiseLoader} */
   return function (extent, resolution, pixelRatio) {
@@ -102,7 +104,7 @@ export function createLoader(options) {
     };
     Object.assign(params, options.params);
 
-    extent = getRequestExtent(extent, resolution, pixelRatio, options.ratio);
+    extent = getRequestExtent(extent, resolution, pixelRatio, ratio);
 
     const src = getRequestUrl(
       options.url,
@@ -114,9 +116,7 @@ export function createLoader(options) {
     );
 
     const image = new Image();
-    if (options.crossOrigin !== null) {
-      image.crossOrigin = options.crossOrigin;
-    }
+    image.crossOrigin = crossOrigin;
 
     return load(image, src).then((image) => {
       // Update resolution, because the server may return a smaller size than requested

package/source/mapguide.d.ts

@@ -4,12 +4,12 @@
  * @return {import('../Image.js').ImageObjectPromiseLoader} ArcGIS Rest image.
  * @api
  */
-export function createLoader(options: LoaderOptions): import('../Image.js').ImageObjectPromiseLoader;
+export function createLoader(options: LoaderOptions): import("../Image.js").ImageObjectPromiseLoader;
 export type LoaderOptions = {
     /**
      * The mapagent url.
      */
-    url?: string | undefined;
+    url: string;
     /**
      * 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.
@@ -47,6 +47,6 @@ export type LoaderOptions = {
      * 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;
+    load?: ((arg0: HTMLImageElement, arg1: string) => Promise<import("../DataTile.js").ImageLike>) | undefined;
 };
 //# sourceMappingURL=mapguide.d.ts.map

package/source/mapguide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapguide.d.ts","sourceRoot":"","sources":["mapguide.js"],"names":[],"mappings":"AAqFA;;;;;GAKG;AACH,sCAJW,aAAa,GACZ,OAAO,aAAa,EAAE,wBAAwB,CA2BzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA5FsB,gBAAgB,QAAE,MAAM,KAAG,QAAQ,OAAO,gBAAgB,EAAE,SAAS,CAAC"}
+{"version":3,"file":"mapguide.d.ts","sourceRoot":"","sources":["mapguide.js"],"names":[],"mappings":"AAqFA;;;;;GAKG;AACH,sCAJW,aAAa,GACZ,OAAO,aAAa,EAAE,wBAAwB,CA8BzD;;;;;SA3Ga,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAYG,gBAAgB,QAAE,MAAM,KAAG,OAAO,CAAC,OAAO,gBAAgB,EAAE,SAAS,CAAC"}