ol 10.7.1-dev.1768898466014 → 10.7.1-dev.1769081428801

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ol",
-  "version": "10.7.1-dev.1768898466014",
+  "version": "10.7.1-dev.1769081428801",
   "description": "OpenLayers mapping library",
   "keywords": [
     "map",
@@ -26,7 +26,8 @@
     "earcut": "^3.0.0",
     "geotiff": "^2.1.3",
     "pbf": "4.0.1",
-    "rbush": "^4.0.0"
+    "rbush": "^4.0.0",
+    "zarrita": "^0.5.4"
   },
   "browserslist": [
     "> 1%",

package/source/GeoZarr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GeoZarr.d.ts","sourceRoot":"","sources":["GeoZarr.js"],"names":[],"mappings":"AAkBA;;GAEG;AAEH;;;;;;;;;;;GAWG;AAEH;IACE;;OAEG;IACH,qBAFW,OAAO,EA4EjB;IAjEC;;OAEG;IACH,MAFU,MAAM,CAEO;IAEvB;;OAEG;IACH,QAFU,MAAM,CAEW;IAE3B;;OAEG;IACH,QAFU,KAAK,GAAC,IAAI,CAEF;IAElB;;OAEG;IACH,OAFU,OAAO,SAAS,EAAE,KAAK,CAAC,GAAG,CAAC,CAErB;IAEjB;;OAEG;IACH,uBAFU,GAAG,GAAC,IAAI,CAEe;IAEjC;;OAEG;IACH,QAFU,KAAK,CAAC,MAAM,CAAC,CAEI;IAE3B;;OAEG;IACH,eAFU;YAAO,MAAM,GAAE,KAAK,CAAC,MAAM,CAAC;KAAC,GAAG,IAAI,CAErB;IAEzB;;OAEG;IACH,YAFU,MAAM,GAAC,SAAS,CAEX;IAEf;;OAEG;IACH,iBAFU,cAAc,CAE2B;IASnD;;OAEG;IACH,UAFU,OAAO,qBAAqB,EAAE,OAAO,CAElC;IAYf,4BA0DC;IAED;;;;;;;OAOG;IACH,kBAkEC;CACF;;;;;iBAIa,WAAW;;;;sBACX,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;;;;;;;;;;;;iBAUrB,iBAAiB;;;;;;wBAKjB,GAAG;;;;qBACH,GAAG;;;;;;cAKH,YAAY;;;;gBACZ,OAAO,uBAAuB,EAAE,OAAO;;;;;;;;;;;;6BAlQxC,SAAS,GAAC,QAAQ;;;;;SAKjB,MAAM;;;;WACN,MAAM;;;;WACN,KAAK,CAAC,MAAM,CAAC;;;;;iBACb,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;2BAlBtB,eAAe;yBADjB,qBAAqB"}
+{"version":3,"file":"GeoZarr.d.ts","sourceRoot":"","sources":["GeoZarr.js"],"names":[],"mappings":"AAkBA;;GAEG;AAEH;;;;;;;;;;;GAWG;AAEH;IACE;;OAEG;IACH,qBAFW,OAAO,EA4EjB;IAjEC;;OAEG;IACH,MAFU,MAAM,CAEO;IAEvB;;OAEG;IACH,QAFU,MAAM,CAEW;IAE3B;;OAEG;IACH,QAFU,KAAK,GAAC,IAAI,CAEF;IAElB;;OAEG;IACH,OAFU,OAAO,SAAS,EAAE,KAAK,CAAC,GAAG,CAAC,CAErB;IAEjB;;OAEG;IACH,uBAFU,GAAG,GAAC,IAAI,CAEe;IAEjC;;OAEG;IACH,QAFU,KAAK,CAAC,MAAM,CAAC,CAEI;IAE3B;;OAEG;IACH,eAFU;YAAO,MAAM,GAAE,KAAK,CAAC,MAAM,CAAC;KAAC,GAAG,IAAI,CAErB;IAEzB;;OAEG;IACH,YAFU,MAAM,GAAC,SAAS,CAEX;IAEf;;OAEG;IACH,iBAFU,cAAc,CAE2B;IASnD;;OAEG;IACH,UAFU,OAAO,qBAAqB,EAAE,OAAO,CAElC;IAYf,4BAmEC;IAED;;;;;;;OAOG;IACH,kBAkEC;CACF;;;;;iBAIa,WAAW;;;;sBACX,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;;;;;;;;;;;;iBAUrB,iBAAiB;;;;;;wBAKjB,GAAG;;;;qBACH,GAAG;;;;;;cAKH,YAAY;;;;gBACZ,OAAO,uBAAuB,EAAE,OAAO;;;;;;;;;;;;6BA3QxC,SAAS,GAAC,QAAQ;;;;;SAKjB,MAAM;;;;WACN,MAAM;;;;WACN,KAAK,CAAC,MAAM,CAAC;;;;;iBACb,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;2BAlBtB,eAAe;yBADjB,qBAAqB"}

package/source/GeoZarr.js

@@ -152,12 +152,21 @@ export default class GeoZarr extends DataTileSource {
       this.tileGrid = tileGrid;
       this.projection = projection;
       this.fillValue_ = fillValue;
-    } else if ('tile_matrix_set' in attributes.multiscales) {
+    }
+    if ('tile_matrix_set' in attributes.multiscales) {
+      // If available, use tile_matrix_set (legacy attributes) to get a tile grid, because it
+      // provides a better mapping of tiles to zarr chunks.
       const {tileGrid, projection} = getTileGridInfoFromLegacyAttributes(
         /** @type {LegacyDatasetAttributes} */ (attributes),
       );
       this.tileGrid = tileGrid;
-      this.projection = projection;
+      if (!this.projection) {
+        // If there were no required zarr conventions, we don't have a projection yet
+        this.projection = projection;
+      }
+    }
+    if (!this.tileGrid) {
+      throw new Error('Could not determine tile grid');
     }
 
     const extent = this.tileGrid.getExtent();
@@ -426,6 +435,27 @@ function composeData(
               }
               break;
             }
+            case 'linear': {
+              const row0 = Math.floor(chunkRow);
+              const col0 = Math.floor(chunkCol);
+              if (row0 < chunkRowCount && col0 < chunkColCount) {
+                const row1 = Math.min(row0 + 1, chunkRowCount - 1);
+                const col1 = Math.min(col0 + 1, chunkColCount - 1);
+
+                const v00 = chunk.data[row0 * chunkColCount + col0];
+                const v01 = chunk.data[row0 * chunkColCount + col1];
+                const v10 = chunk.data[row1 * chunkColCount + col0];
+                const v11 = chunk.data[row1 * chunkColCount + col1];
+
+                const dx = chunkCol - col0;
+                const dy = chunkRow - row0;
+
+                value =
+                  (1 - dy) * ((1 - dx) * v00 + dx * v01) +
+                  dy * ((1 - dx) * v10 + dx * v11);
+              }
+              break;
+            }
             default: {
               throw new Error(`Unsupported resample method: ${resampleMethod}`);
             }

package/source/OGCMap.d.ts

@@ -0,0 +1,170 @@
+export default OGCMap;
+export type Options = {
+    /**
+     * Attributions.
+     */
+    attributions?: import("./Source.js").AttributionLike | undefined;
+    /**
+     * 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;
+    /**
+     * Optional function to load an image given a URL.
+     */
+    imageLoadFunction?: import("../Image.js").LoadFunction | undefined;
+    /**
+     * Use interpolated values when resampling.  By default,
+     * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
+     */
+    interpolate?: boolean | undefined;
+    /**
+     * OGC Maps request parameters.
+     * No param is required by default. `width`, `height`, `bbox`, `crs` and `bbox-crs` will be set dynamically.
+     */
+    params?: {
+        [x: string]: any;
+    } | undefined;
+    /**
+     * Projection. Default is the view projection.
+     */
+    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.
+     */
+    ratio?: number | undefined;
+    /**
+     * Resolutions.
+     * If specified, requests will be made for these resolutions only.
+     */
+    resolutions?: number[] | undefined;
+    /**
+     * OGC Maps service URL.
+     */
+    url?: string | undefined;
+};
+/**
+ * @typedef {Object} Options
+ * @property {import("./Source.js").AttributionLike} [attributions] Attributions.
+ * @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 {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 {Object<string,*>} [params] OGC Maps request parameters.
+ * No param is required by default. `width`, `height`, `bbox`, `crs` and `bbox-crs` 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.
+ * @property {Array<number>} [resolutions] Resolutions.
+ * If specified, requests will be made for these resolutions only.
+ * @property {string} [url] OGC Maps service URL.
+ */
+/**
+ * @classdesc
+ * Source for OGC Maps servers providing single, untiled images.
+ *
+ * @fires module:ol/source/Image.ImageSourceEvent
+ * @api
+ */
+declare class OGCMap extends ImageSource {
+    /**
+     * @param {Options} [options] OGCMapOptions options.
+     */
+    constructor(options?: Options);
+    /**
+     * @private
+     * @type {?string}
+     */
+    private crossOrigin_;
+    /**
+     * @private
+     * @type {string|undefined}
+     */
+    private url_;
+    /**
+     * @private
+     * @type {import("../Image.js").LoadFunction}
+     */
+    private imageLoadFunction_;
+    /**
+     * @private
+     * @type {!Object}
+     */
+    private params_;
+    /**
+     * @private
+     * @type {boolean}
+     */
+    private hidpi_;
+    /**
+     * @private
+     * @type {number}
+     */
+    private renderedRevision_;
+    /**
+     * @private
+     * @type {number}
+     */
+    private ratio_;
+    /**
+     * @private
+     * @type {import("../proj/Projection.js").default}
+     */
+    private loaderProjection_;
+    /**
+     * Get the user-provided params, i.e. those passed to the constructor through
+     * the "params" option, and possibly updated using the updateParams method.
+     * @return {Object} Params.
+     * @api
+     */
+    getParams(): any;
+    /**
+     * Return the image load function of the source.
+     * @return {import("../Image.js").LoadFunction} The image load function.
+     * @api
+     */
+    getImageLoadFunction(): import("../Image.js").LoadFunction;
+    /**
+     * Return the URL used for this OGC Maps source.
+     * @return {string|undefined} URL.
+     * @api
+     */
+    getUrl(): string | undefined;
+    /**
+     * Set the image load function of the source.
+     * @param {import("../Image.js").LoadFunction} imageLoadFunction Image load function.
+     * @api
+     */
+    setImageLoadFunction(imageLoadFunction: import("../Image.js").LoadFunction): void;
+    /**
+     * Set the URL to use for requests.
+     * @param {string|undefined} url URL.
+     * @api
+     */
+    setUrl(url: string | undefined): void;
+    /**
+     * Set the user-provided params.
+     * @param {Object} params Params.
+     * @api
+     */
+    setParams(params: any): void;
+    /**
+     * Update the user-provided params.
+     * @param {Object} params Params.
+     * @api
+     */
+    updateParams(params: any): void;
+}
+import ImageSource from './Image.js';
+//# sourceMappingURL=OGCMap.d.ts.map

package/source/OGCMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OGCMap.d.ts","sourceRoot":"","sources":["OGCMap.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;AAbjD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;GAMG;AACH;IACE;;OAEG;IACH,sBAFW,OAAO,EA+DjB;IAnDC;;;OAGG;IACH,qBACgE;IAEhE;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,2BAG8B;IAE9B;;;OAGG;IACH,gBAAgD;IAEhD;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,0BAA0B;IAE1B;;;OAGG;IACH,eAA+D;IAE/D;;;OAGG;IACH,0BAA6B;IAG/B;;;;;OAKG;IACH,iBAEC;IAmCD;;;;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,6BAKC;IAED;;;;OAIG;IACH,gCAGC;CASF;wBAnNmD,YAAY"}

package/source/OGCMap.js

@@ -0,0 +1,219 @@
+/**
+ * @module ol/source/OGCMap
+ */
+
+import {decode} from '../Image.js';
+import ImageSource, {defaultImageLoadFunction} from './Image.js';
+import {createLoader} from './ogcMapUtil.js';
+
+/**
+ * @typedef {Object} Options
+ * @property {import("./Source.js").AttributionLike} [attributions] Attributions.
+ * @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 {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 {Object<string,*>} [params] OGC Maps request parameters.
+ * No param is required by default. `width`, `height`, `bbox`, `crs` and `bbox-crs` 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.
+ * @property {Array<number>} [resolutions] Resolutions.
+ * If specified, requests will be made for these resolutions only.
+ * @property {string} [url] OGC Maps service URL.
+ */
+
+/**
+ * @classdesc
+ * Source for OGC Maps servers providing single, untiled images.
+ *
+ * @fires module:ol/source/Image.ImageSourceEvent
+ * @api
+ */
+class OGCMap extends ImageSource {
+  /**
+   * @param {Options} [options] OGCMapOptions options.
+   */
+  constructor(options) {
+    options = options ? options : {};
+
+    super({
+      attributions: options.attributions,
+      interpolate: options.interpolate,
+      projection: options.projection,
+      resolutions: options.resolutions,
+    });
+
+    /**
+     * @private
+     * @type {?string}
+     */
+    this.crossOrigin_ =
+      options.crossOrigin !== undefined ? options.crossOrigin : null;
+
+    /**
+     * @private
+     * @type {string|undefined}
+     */
+    this.url_ = options.url;
+
+    /**
+     * @private
+     * @type {import("../Image.js").LoadFunction}
+     */
+    this.imageLoadFunction_ =
+      options.imageLoadFunction !== undefined
+        ? options.imageLoadFunction
+        : defaultImageLoadFunction;
+
+    /**
+     * @private
+     * @type {!Object}
+     */
+    this.params_ = Object.assign({}, options.params);
+
+    /**
+     * @private
+     * @type {boolean}
+     */
+    this.hidpi_ = options.hidpi !== undefined ? options.hidpi : true;
+
+    /**
+     * @private
+     * @type {number}
+     */
+    this.renderedRevision_ = 0;
+
+    /**
+     * @private
+     * @type {number}
+     */
+    this.ratio_ = options.ratio !== undefined ? options.ratio : 1.5;
+
+    /**
+     * @private
+     * @type {import("../proj/Projection.js").default}
+     */
+    this.loaderProjection_ = null;
+  }
+
+  /**
+   * Get the user-provided params, i.e. those passed to the constructor through
+   * the "params" option, and possibly updated using the updateParams method.
+   * @return {Object} Params.
+   * @api
+   */
+  getParams() {
+    return this.params_;
+  }
+
+  /**
+   * @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.
+   * @override
+   */
+  getImageInternal(extent, resolution, pixelRatio, projection) {
+    if (this.url_ === undefined) {
+      return null;
+    }
+    if (!this.loader || this.loaderProjection_ !== projection) {
+      // Lazily create loader to pick up the view projection and to allow `params` updates
+      this.loaderProjection_ = projection;
+      this.loader = createLoader({
+        crossOrigin: this.crossOrigin_,
+        params: this.params_,
+        projection: projection,
+        hidpi: this.hidpi_,
+        url: this.url_,
+        ratio: this.ratio_,
+        load: (image, src) => {
+          this.image.setImage(image);
+          this.imageLoadFunction_(this.image, src);
+          return decode(image);
+        },
+      });
+    }
+
+    return super.getImageInternal(extent, resolution, pixelRatio, projection);
+  }
+
+  /**
+   * Return the image load function of the source.
+   * @return {import("../Image.js").LoadFunction} The image load function.
+   * @api
+   */
+  getImageLoadFunction() {
+    return this.imageLoadFunction_;
+  }
+
+  /**
+   * Return the URL used for this OGC Maps source.
+   * @return {string|undefined} URL.
+   * @api
+   */
+  getUrl() {
+    return this.url_;
+  }
+
+  /**
+   * Set the image load function of the source.
+   * @param {import("../Image.js").LoadFunction} imageLoadFunction Image load function.
+   * @api
+   */
+  setImageLoadFunction(imageLoadFunction) {
+    this.imageLoadFunction_ = imageLoadFunction;
+    this.changed();
+  }
+
+  /**
+   * Set the URL to use for requests.
+   * @param {string|undefined} url URL.
+   * @api
+   */
+  setUrl(url) {
+    if (url != this.url_) {
+      this.url_ = url;
+      this.loader = null;
+      this.changed();
+    }
+  }
+
+  /**
+   * Set the user-provided params.
+   * @param {Object} params Params.
+   * @api
+   */
+  setParams(params) {
+    this.params_ = Object.assign({}, params);
+    // Reset loader to pick up new params
+    this.loader = null;
+    this.changed();
+  }
+
+  /**
+   * Update the user-provided params.
+   * @param {Object} params Params.
+   * @api
+   */
+  updateParams(params) {
+    Object.assign(this.params_, params);
+    this.changed();
+  }
+
+  /**
+   * @override
+   */
+  changed() {
+    this.image = null;
+    super.changed();
+  }
+}
+
+export default OGCMap;

package/source/ogcMapUtil.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @param {string} baseUrl Base URL.
+ * @param {import("../extent.js").Extent} extent Extent.
+ * @param {import("../size.js").Size} size Size.
+ * @param {import("../proj/Projection.js").default} projection Projection.
+ * @param {Object} params OGC Map params. Will be modified in place.
+ * @return {string} Request URL.
+ */
+export function getRequestUrl(baseUrl: string, extent: import("../extent.js").Extent, size: import("../size.js").Size, projection: import("../proj/Projection.js").default, params: any): string;
+/**
+ * @param {import("../extent").Extent} extent Extent.
+ * @param {number} resolution Resolution.
+ * @param {number} pixelRatio pixel ratio.
+ * @param {import("../proj.js").Projection} projection Projection.
+ * @param {string} url OGC Map service url.
+ * @param {Object} params OGC Map params.
+ * @return {string} Image src.
+ */
+export function getImageSrc(extent: import("../extent").Extent, resolution: number, pixelRatio: number, projection: import("../proj.js").Projection, url: string, 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] OGC Map request parameters.
+ * No param is required by default. `width`, `height`, `bbox`, `crs` and `bbox-crs` will be set dynamically.
+ * @property {import("../proj.js").ProjectionLike} [projection] Projection. Default is 'EPSG:3857'.
+ * @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.
+ * @property {string} url OGC Map service URL.
+ * @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 OGC Map images.
+ * @param {LoaderOptions} options Loader options.
+ * @return {import("../Image.js").ImageObjectPromiseLoader} Loader.
+ * @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;
+    /**
+     * OGC Map request parameters.
+     * No param is required by default. `width`, `height`, `bbox`, `crs` and `bbox-crs` will be set dynamically.
+     */
+    params?: {
+        [x: string]: any;
+    } | undefined;
+    /**
+     * Projection. Default is 'EPSG:3857'.
+     */
+    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.
+     */
+    ratio?: number | undefined;
+    /**
+     * OGC Map service URL.
+     */
+    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;
+};
+//# sourceMappingURL=ogcMapUtil.d.ts.map

package/source/ogcMapUtil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogcMapUtil.d.ts","sourceRoot":"","sources":["ogcMapUtil.js"],"names":[],"mappings":"AAYA;;;;;;;GAOG;AACH,uCAPW,MAAM,UACN,OAAO,cAAc,EAAE,MAAM,QAC7B,OAAO,YAAY,EAAE,IAAI,cACzB,OAAO,uBAAuB,EAAE,OAAO,gBAEtC,MAAM,CAejB;AAED;;;;;;;;GAQG;AACH,oCARW,OAAO,WAAW,EAAE,MAAM,cAC1B,MAAM,cACN,MAAM,cACN,OAAO,YAAY,EAAE,UAAU,OAC/B,MAAM,gBAEL,MAAM,CAwBjB;AAED;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;GAKG;AACH,sCAJW,aAAa,GACZ,OAAO,aAAa,EAAE,wBAAwB,CA2BzD;;;;;;;;;;;;;;;;;;;;;;;iBAvCa,OAAO,YAAY,EAAE,cAAc;;;;;;;;;SAGnC,MAAM;;;;;;mBACG,gBAAgB,QAAE,MAAM,KAAG,OAAO,CAAC,OAAO,gBAAgB,EAAE,SAAS,CAAC"}

package/source/ogcMapUtil.js

@@ -0,0 +1,117 @@
+/**
+ * @module ol/source/ogcMapUtil
+ */
+
+import {decode} from '../Image.js';
+import {getHeight, getWidth} from '../extent.js';
+import {round} from '../math.js';
+import {get as getProjection} from '../proj.js';
+import {appendParams} from '../uri.js';
+import {getRequestExtent} from './Image.js';
+import {DECIMALS} from './common.js';
+
+/**
+ * @param {string} baseUrl Base URL.
+ * @param {import("../extent.js").Extent} extent Extent.
+ * @param {import("../size.js").Size} size Size.
+ * @param {import("../proj/Projection.js").default} projection Projection.
+ * @param {Object} params OGC Map params. Will be modified in place.
+ * @return {string} Request URL.
+ */
+export function getRequestUrl(baseUrl, extent, size, projection, params) {
+  params['width'] = size[0];
+  params['height'] = size[1];
+
+  const axisOrientation = projection.getAxisOrientation();
+  params['crs'] = projection.getCode();
+  params['bbox-crs'] = projection.getCode();
+  const bbox = axisOrientation.startsWith('ne')
+    ? [extent[1], extent[0], extent[3], extent[2]]
+    : extent;
+  params['bbox'] = bbox.join(',');
+
+  return appendParams(baseUrl, params);
+}
+
+/**
+ * @param {import("../extent").Extent} extent Extent.
+ * @param {number} resolution Resolution.
+ * @param {number} pixelRatio pixel ratio.
+ * @param {import("../proj.js").Projection} projection Projection.
+ * @param {string} url OGC Map service url.
+ * @param {Object} params OGC Map params.
+ * @return {string} Image src.
+ */
+export function getImageSrc(
+  extent,
+  resolution,
+  pixelRatio,
+  projection,
+  url,
+  params,
+) {
+  params = Object.assign({}, params);
+
+  const imageResolution = resolution / pixelRatio;
+
+  const imageSize = [
+    round(getWidth(extent) / imageResolution, DECIMALS),
+    round(getHeight(extent) / imageResolution, DECIMALS),
+  ];
+
+  if (pixelRatio !== 1) {
+    params['mm-per-pixel'] = 0.28 / pixelRatio;
+  }
+
+  return getRequestUrl(url, extent, imageSize, projection, params);
+}
+
+/**
+ * @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] OGC Map request parameters.
+ * No param is required by default. `width`, `height`, `bbox`, `crs` and `bbox-crs` will be set dynamically.
+ * @property {import("../proj.js").ProjectionLike} [projection] Projection. Default is 'EPSG:3857'.
+ * @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.
+ * @property {string} url OGC Map service URL.
+ * @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 OGC Map images.
+ * @param {LoaderOptions} options Loader options.
+ * @return {import("../Image.js").ImageObjectPromiseLoader} Loader.
+ * @api
+ */
+export function createLoader(options) {
+  const hidpi = options.hidpi === undefined ? true : options.hidpi;
+  const projection = getProjection(options.projection || 'EPSG:3857');
+  const ratio = options.ratio || 1.5;
+  const load = options.load || decode;
+  const crossOrigin = options.crossOrigin ?? null;
+
+  return (extent, resolution, pixelRatio) => {
+    extent = getRequestExtent(extent, resolution, pixelRatio, ratio);
+    if (pixelRatio !== 1 && !hidpi) {
+      pixelRatio = 1;
+    }
+    const src = getImageSrc(
+      extent,
+      resolution,
+      pixelRatio,
+      projection,
+      options.url,
+      options.params,
+    );
+    const image = new Image();
+    image.crossOrigin = crossOrigin;
+    return load(image, src).then((image) => ({image, extent, pixelRatio}));
+  };
+}

package/util.js

@@ -33,4 +33,4 @@ export function getUid(obj) {
  * OpenLayers version.
  * @type {string}
  */
-export const VERSION = '10.7.1-dev.1768898466014';
+export const VERSION = '10.7.1-dev.1769081428801';