ol 10.7.1-dev.1766142301376 → 10.7.1-dev.1766335921056

package/render/canvas.d.ts

@@ -351,11 +351,11 @@ export type TextState = {
     /**
      * BackgroundFill.
      */
-    backgroundFill?: import("../style/Fill.js").default | undefined;
+    backgroundFill?: import("../style.js").Fill | undefined;
     /**
      * BackgroundStroke.
      */
-    backgroundStroke?: import("../style/Stroke.js").default | undefined;
+    backgroundStroke?: import("../style.js").Stroke | undefined;
     /**
      * Scale.
      */

package/renderer/canvas/ImageLayer.d.ts

@@ -8,7 +8,7 @@ declare class CanvasImageLayerRenderer extends CanvasLayerRenderer<any> {
     /**
      * @param {import("../../layer/Image.js").default} imageLayer Image layer.
      */
-    constructor(imageLayer: import("../../layer/Image.js").default<any>);
+    constructor(imageLayer: import("../../layer.js").Image<any>);
     /**
      * @protected
      * @type {?import("../../Image.js").default}

package/renderer/canvas/ImageLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageLayer.d.ts","sourceRoot":"","sources":["ImageLayer.js"],"names":[],"mappings":";AAqBA;;;;GAIG;AACH;IACE;;OAEG;IACH,qEAQC;IALC;;;OAGG;IACH,iBAFW,OAAO,gBAAgB,EAAE,OAAO,OAAA,CAE1B;IAGnB;;OAEG;IACH,YAFY,OAAO,mBAAmB,EAAE,SAAS,CAIhD;IAsDD;;;;OAIG;IACH,wBAJW,OAAO,gBAAgB,EAAE,KAAK,GAC7B,iBAAiB,CA0C5B;IAED;;;;;;OAMG;IACH,iCALW,OAAO,cAAc,EAAE,UAAU,UACjC,WAAW,GACV,WAAW,CAuFtB;CACF;gCA1N+B,YAAY"}
+{"version":3,"file":"ImageLayer.d.ts","sourceRoot":"","sources":["ImageLayer.js"],"names":[],"mappings":";AAqBA;;;;GAIG;AACH;IACE;;OAEG;IACH,6DAQC;IALC;;;OAGG;IACH,iBAFW,OAAO,gBAAgB,EAAE,OAAO,OAAA,CAE1B;IAGnB;;OAEG;IACH,YAFY,OAAO,mBAAmB,EAAE,SAAS,CAIhD;IAsDD;;;;OAIG;IACH,wBAJW,OAAO,gBAAgB,EAAE,KAAK,GAC7B,iBAAiB,CA0C5B;IAED;;;;;;OAMG;IACH,iCALW,OAAO,cAAc,EAAE,UAAU,UACjC,WAAW,GACV,WAAW,CAuFtB;CACF;gCA1N+B,YAAY"}

package/renderer/canvas/TileLayer.d.ts

@@ -19,7 +19,7 @@ export type Options = {
  * @template {import("../../layer/Tile.js").default|import("../../layer/VectorTile.js").default} [LayerType=import("../../layer/Tile.js").default<import("../../source/Tile.js").default>|import("../../layer/VectorTile.js").default]
  * @extends {CanvasLayerRenderer<LayerType>}
  */
-declare class CanvasTileLayerRenderer<LayerType extends import("../../layer/Tile.js").default | import("../../layer/VectorTile.js").default = import("../../layer/Tile.js").default<import("../../source/Tile.js").default<import("../../Tile.js").default>> | import("../../layer/VectorTile.js").default<import("../../source.js").VectorTile<any>, any>> extends CanvasLayerRenderer<LayerType> {
+declare class CanvasTileLayerRenderer<LayerType extends import("../../layer/Tile.js").default | import("../../layer/VectorTile.js").default = import("../../layer.js").Tile<import("../../source.js").Tile<import("../../Tile.js").default>> | import("../../layer.js").VectorTile<import("../../source.js").VectorTile<any>, any>> extends CanvasLayerRenderer<LayerType> {
     /**
      * @param {LayerType} tileLayer Tile layer.
      * @param {Options} [options] Options.

package/renderer/canvas/VectorTileLayer.d.ts

@@ -5,7 +5,7 @@ export default CanvasVectorTileLayerRenderer;
  * @api
  * @extends {CanvasTileLayerRenderer<import("../../layer/VectorTile.js").default<import('../../source/VectorTile.js').default<import('../../Feature.js').FeatureLike>>>}
  */
-declare class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer<import("../../layer/VectorTile.js").default<import("../../source/VectorTile.js").default<import("../../Feature.js").FeatureLike>, import("../../Feature.js").FeatureLike>> {
+declare class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer<import("../../layer.js").VectorTile<import("../../source.js").VectorTile<import("../../Feature.js").FeatureLike>, import("../../Feature.js").FeatureLike>> {
     /**
      * @param {import("../../layer/VectorTile.js").default} layer VectorTile layer.
      * @param {import("./TileLayer.js").Options} options Options.

package/source/Cluster.d.ts

@@ -1,6 +1,6 @@
 export default Cluster;
 export type GeometryFunction<FeatureType extends import("../Feature.js").FeatureLike = import("../Feature.js").FeatureLike> = (feature: FeatureType) => (Point | null);
-export type Options<FeatureType extends import("../Feature.js").FeatureLike = Feature<import("../geom/Geometry.js").default>> = {
+export type Options<FeatureType extends import("../Feature.js").FeatureLike = Feature<import("../geom.js").Geometry>> = {
     /**
      * Attributions.
      */
@@ -112,7 +112,7 @@ export type Options<FeatureType extends import("../Feature.js").FeatureLike = Fe
  * @template {import('../Feature.js').FeatureLike} [FeatureType=import('../Feature.js').default]
  * @extends {VectorSource<Feature<import("../geom/Geometry.js").default>>}
  */
-declare class Cluster<FeatureType extends import("../Feature.js").FeatureLike = Feature<import("../geom/Geometry.js").default>> extends VectorSource<Feature<import("../geom/Geometry.js").default>> {
+declare class Cluster<FeatureType extends import("../Feature.js").FeatureLike = Feature<import("../geom.js").Geometry>> extends VectorSource<Feature<import("../geom.js").Geometry>> {
     /**
      * @param {Options<FeatureType>} [options] Cluster options.
      */

package/source/GeoZarr.d.ts

@@ -0,0 +1,163 @@
+/**
+ * @typedef {'nearest'|'linear'} ResampleMethod
+ */
+/**
+ * @typedef {Object} Options
+ * @property {string} url The Zarr URL.
+ * @property {string} group The group with arrays to render.
+ * @property {Array<string>} bands The band names to render.
+ * @property {import("../proj.js").ProjectionLike} [projection] Source projection.  If not provided, the GeoTIFF metadata
+ * will be read for projection information.
+ * @property {number} [transition=250] Duration of the opacity transition for rendering.
+ * To disable the opacity transition, pass `transition: 0`.
+ * @property {boolean} [wrapX=false] Render tiles beyond the tile grid extent.
+ * @property {ResampleMethod} [resample='nearest'] Resamplilng method if bands are not available for all multi-scale levels.
+ */
+export default class GeoZarr extends DataTileSource<import("../DataTile.js").default> {
+    /**
+     * @param {Options} options The options.
+     */
+    constructor(options: Options);
+    /**
+     * @type {string}
+     */
+    url_: string;
+    /**
+     * @type {string}
+     */
+    group_: string;
+    /**
+     * @type {Error|null}
+     */
+    error_: Error | null;
+    /**
+     * @type {import('zarrita').Group<any>}
+     */
+    root_: import("zarrita").Group<any>;
+    /**
+     * @type {any|null}
+     */
+    consolidatedMetadata_: any | null;
+    /**
+     * @type {Array<string>}
+     */
+    bands_: Array<string>;
+    /**
+     * @type {Object<string, Array<string>> | null}
+     */
+    bandsByLevel_: {
+        [x: string]: Array<string>;
+    } | null;
+    /**
+     * @type {number|undefined}
+     */
+    fillValue_: number | undefined;
+    /**
+     * @type {ResampleMethod}
+     */
+    resampleMethod_: ResampleMethod;
+    /**
+     * @type {import("../tilegrid/WMTS.js").default}
+     */
+    tileGrid: import("../tilegrid/WMTS.js").default;
+    configure_(): Promise<void>;
+    /**
+     * @param {number} z The z tile index.
+     * @param {number} x The x tile index.
+     * @param {number} y The y tile index.
+     * @param {import('./DataTile.js').LoaderOptions} options The loader options.
+     * @return {Promise} The composed tile data.
+     * @private
+     */
+    private loadTile_;
+}
+export type DatasetAttributes = {
+    /**
+     * The multiscales attribute.
+     */
+    multiscales: Multiscales;
+    /**
+     * The zarr conventions attribute.
+     */
+    zarr_conventions: Array<{
+        uuid: string;
+    }>;
+};
+export type Multiscales = {
+    /**
+     * The layout.
+     */
+    layout: any;
+};
+export type LegacyDatasetAttributes = {
+    /**
+     * The multiscales attribute.
+     */
+    multiscales: LegacyMultiscales;
+};
+export type LegacyMultiscales = {
+    /**
+     * The tile matrix limits.
+     */
+    tile_matrix_limits: any;
+    /**
+     * The tile matrix set.
+     */
+    tile_matrix_set: any;
+};
+export type TileGridInfo = {
+    /**
+     * The tile grid.
+     */
+    tileGrid: WMTSTileGrid;
+    /**
+     * The projection.
+     */
+    projection: import("../proj/Projection.js").default;
+    /**
+     * Available bands by level.
+     */
+    bandsByLevel?: {
+        [x: string]: string[];
+    } | undefined;
+    /**
+     * The fill value.
+     */
+    fillValue?: number | undefined;
+};
+export type ResampleMethod = "nearest" | "linear";
+export type Options = {
+    /**
+     * The Zarr URL.
+     */
+    url: string;
+    /**
+     * The group with arrays to render.
+     */
+    group: string;
+    /**
+     * The band names to render.
+     */
+    bands: Array<string>;
+    /**
+     * Source projection.  If not provided, the GeoTIFF metadata
+     * will be read for projection information.
+     */
+    projection?: import("../proj.js").ProjectionLike;
+    /**
+     * Duration of the opacity transition for rendering.
+     * To disable the opacity transition, pass `transition: 0`.
+     */
+    transition?: number | undefined;
+    /**
+     * Render tiles beyond the tile grid extent.
+     */
+    wrapX?: boolean | undefined;
+    /**
+     * Resamplilng method if bands are not available for all multi-scale levels.
+     */
+    resample?: ResampleMethod | undefined;
+};
+import DataTileSource from './DataTile.js';
+import WMTSTileGrid from '../tilegrid/WMTS.js';
+//# sourceMappingURL=GeoZarr.d.ts.map

package/source/GeoZarr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeoZarr.d.ts","sourceRoot":"","sources":["GeoZarr.js"],"names":[],"mappings":"AAkBA;;GAEG;AAEH;;;;;;;;;;;GAWG;AAEH;IACE;;OAEG;IACH,qBAFW,OAAO,EAuEjB;IA5DC;;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;IAInD;;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;;;;;;;;;;;;6BA7PxC,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

@@ -0,0 +1,437 @@
+/**
+ * @module ol/source/GeoZarr
+ */
+
+import {FetchStore, get, open, slice} from 'zarrita';
+import {getCenter} from '../extent.js';
+import {get as getProjection, toUserCoordinate, toUserExtent} from '../proj.js';
+import {toSize} from '../size.js';
+import WMTSTileGrid from '../tilegrid/WMTS.js';
+import DataTileSource from './DataTile.js';
+import {parseTileMatrixSet} from './ogcTileUtil.js';
+
+const REQUIRED_ZARR_CONVENTIONS = [
+  'd35379db-88df-4056-af3a-620245f8e347', // multisacles
+  'f17cb550-5864-4468-aeb7-f3180cfb622f', // proj:
+  '689b58e2-cf7b-45e0-9fff-9cfc0883d6b4', // spatial:
+];
+
+/**
+ * @typedef {'nearest'|'linear'} ResampleMethod
+ */
+
+/**
+ * @typedef {Object} Options
+ * @property {string} url The Zarr URL.
+ * @property {string} group The group with arrays to render.
+ * @property {Array<string>} bands The band names to render.
+ * @property {import("../proj.js").ProjectionLike} [projection] Source projection.  If not provided, the GeoTIFF metadata
+ * will be read for projection information.
+ * @property {number} [transition=250] Duration of the opacity transition for rendering.
+ * To disable the opacity transition, pass `transition: 0`.
+ * @property {boolean} [wrapX=false] Render tiles beyond the tile grid extent.
+ * @property {ResampleMethod} [resample='nearest'] Resamplilng method if bands are not available for all multi-scale levels.
+ */
+
+export default class GeoZarr extends DataTileSource {
+  /**
+   * @param {Options} options The options.
+   */
+  constructor(options) {
+    super({
+      state: 'loading',
+      tileGrid: null,
+      projection: options.projection || null,
+      transition: options.transition,
+      wrapX: options.wrapX,
+    });
+
+    /**
+     * @type {string}
+     */
+    this.url_ = options.url;
+
+    /**
+     * @type {string}
+     */
+    this.group_ = options.group;
+
+    /**
+     * @type {Error|null}
+     */
+    this.error_ = null;
+
+    /**
+     * @type {import('zarrita').Group<any>}
+     */
+    this.root_ = null;
+
+    /**
+     * @type {any|null}
+     */
+    this.consolidatedMetadata_ = null;
+
+    /**
+     * @type {Array<string>}
+     */
+    this.bands_ = options.bands;
+
+    /**
+     * @type {Object<string, Array<string>> | null}
+     */
+    this.bandsByLevel_ = null;
+
+    /**
+     * @type {number|undefined}
+     */
+    this.fillValue_;
+
+    /**
+     * @type {ResampleMethod}
+     */
+    this.resampleMethod_ = options.resample || 'linear';
+
+    this.setLoader(this.loadTile_.bind(this));
+
+    /**
+     * @type {import("../tilegrid/WMTS.js").default}
+     */
+    this.tileGrid;
+
+    this.configure_()
+      .then(() => {
+        this.setState('ready');
+      })
+      .catch((err) => {
+        this.error_ = err;
+        this.setState('error');
+      });
+  }
+
+  async configure_() {
+    const store = new FetchStore(this.url_);
+
+    this.root_ = await open(store, {kind: 'group'});
+
+    try {
+      this.consolidatedMetadata_ = JSON.parse(
+        new TextDecoder().decode(
+          await store.get(this.root_.resolve('zarr.json').path),
+        ),
+      ).consolidated_metadata.metadata;
+    } catch {
+      // empty catch block
+    }
+
+    const group = await open(this.root_.resolve(this.group_), {kind: 'group'});
+
+    const attributes =
+      /** @type {LegacyDatasetAttributes | DatasetAttributes} */ (group.attrs);
+
+    if (
+      'zarr_conventions' in attributes &&
+      Array.isArray(attributes.zarr_conventions) &&
+      REQUIRED_ZARR_CONVENTIONS.every((uuid) =>
+        attributes.zarr_conventions.find((c) => c.uuid === uuid),
+      ) &&
+      'layout' in attributes.multiscales
+    ) {
+      const {tileGrid, projection, bandsByLevel, fillValue} =
+        getTileGridInfoFromAttributes(
+          /** @type {DatasetAttributes} */ (attributes),
+          this.consolidatedMetadata_,
+          this.group_,
+          this.bands_,
+        );
+      this.bandsByLevel_ = bandsByLevel;
+      this.tileGrid = tileGrid;
+      this.projection = projection;
+      this.fillValue_ = fillValue;
+    } else if ('tile_matrix_set' in attributes.multiscales) {
+      const {tileGrid, projection} = getTileGridInfoFromLegacyAttributes(
+        /** @type {LegacyDatasetAttributes} */ (attributes),
+      );
+      this.tileGrid = tileGrid;
+      this.projection = projection;
+    }
+
+    const extent = this.tileGrid.getExtent();
+    setTimeout(() => {
+      this.viewResolver({
+        showFullExtent: true,
+        projection: this.projection,
+        resolutions: this.tileGrid.getResolutions(),
+        center: toUserCoordinate(getCenter(extent), this.projection),
+        extent: toUserExtent(extent, this.projection),
+        zoom: 1,
+      });
+    });
+  }
+
+  /**
+   * @param {number} z The z tile index.
+   * @param {number} x The x tile index.
+   * @param {number} y The y tile index.
+   * @param {import('./DataTile.js').LoaderOptions} options The loader options.
+   * @return {Promise} The composed tile data.
+   * @private
+   */
+  async loadTile_(z, x, y, options) {
+    const resolutions = this.tileGrid.getResolutions();
+    const tileResolution = this.tileGrid.getResolution(z);
+    const tileExtent = this.tileGrid.getTileCoordExtent([z, x, y]);
+
+    const bandPromises = [];
+    const bandResolutions = [];
+    for (const band of this.bands_) {
+      let bandMatrixId;
+      let bandResolution;
+      let bandZ = 0;
+
+      if (!this.bandsByLevel_) {
+        // TODO: remove this if we stop supporting legacy attributes
+        bandMatrixId = this.tileGrid.getMatrixId(z);
+        bandResolution = tileResolution;
+        bandZ = z;
+      } else {
+        for (
+          let candidateZ = 0;
+          candidateZ < resolutions.length;
+          candidateZ += 1
+        ) {
+          const candidateResolution = resolutions[candidateZ];
+          if (bandMatrixId && candidateResolution < tileResolution) {
+            break;
+          }
+          const candidateMatrixId = this.tileGrid.getMatrixId(candidateZ);
+          if (this.bandsByLevel_[candidateMatrixId].includes(band)) {
+            bandMatrixId = candidateMatrixId;
+            bandResolution = this.tileGrid.getResolution(candidateZ);
+            bandZ = candidateZ;
+          }
+        }
+      }
+
+      if (!bandMatrixId || !bandResolution) {
+        throw new Error(`Could not find available resolution for band ${band}`);
+      }
+
+      const origin = this.tileGrid.getOrigin(bandZ);
+      const minCol = Math.round((tileExtent[0] - origin[0]) / bandResolution);
+      const maxCol = Math.round((tileExtent[2] - origin[0]) / bandResolution);
+
+      const minRow = Math.round((origin[1] - tileExtent[3]) / bandResolution);
+      const maxRow = Math.round((origin[1] - tileExtent[1]) / bandResolution);
+
+      const path = `${this.group_}/${bandMatrixId}/${band}`;
+      const array = await open(this.root_.resolve(path), {kind: 'array'});
+      bandPromises.push(
+        get(array, [slice(minRow, maxRow), slice(minCol, maxCol)]),
+      );
+      bandResolutions.push(bandResolution);
+    }
+
+    const bandChunks = await Promise.all(bandPromises);
+    const [tileColCount, tileRowCount] = toSize(this.tileGrid.getTileSize(z));
+    return composeData(
+      bandChunks,
+      bandResolutions,
+      tileColCount,
+      tileRowCount,
+      tileResolution,
+      this.resampleMethod_,
+      this.fillValue_ || 0,
+    );
+  }
+}
+
+/**
+ * @typedef {Object} DatasetAttributes
+ * @property {Multiscales} multiscales The multiscales attribute.
+ * @property {Array<{uuid: string}>} zarr_conventions The zarr conventions attribute.
+ */
+
+/**
+ * @typedef {Object} Multiscales
+ * @property {Object} layout The layout.
+ */
+
+/**
+ * @typedef {Object} LegacyDatasetAttributes
+ * @property {LegacyMultiscales} multiscales The multiscales attribute.
+ */
+
+/**
+ * @typedef {Object} LegacyMultiscales
+ * @property {any} tile_matrix_limits The tile matrix limits.
+ * @property {any} tile_matrix_set The tile matrix set.
+ */
+
+/**
+ * @typedef {Object} TileGridInfo
+ * @property {WMTSTileGrid} tileGrid The tile grid.
+ * @property {import("../proj/Projection.js").default} projection The projection.
+ * @property {Object<string, Array<string>>} [bandsByLevel] Available bands by level.
+ * @property {number} [fillValue] The fill value.
+ */
+
+/**
+ * @param {DatasetAttributes} attributes The dataset attributes.
+ * @param {any} consolidatedMetadata The consolidated metadata.
+ * @param {string} wantedGroup The path to the wanted group.
+ * @param {Array<string>} wantedBands The wanted bands.
+ * @return {TileGridInfo} The tile grid info.
+ */
+function getTileGridInfoFromAttributes(
+  attributes,
+  consolidatedMetadata,
+  wantedGroup,
+  wantedBands,
+) {
+  const multiscales = attributes.multiscales;
+  const extent = attributes['spatial:bbox'];
+  const projection = getProjection(attributes['proj:code']);
+  /** @type {Array<{matrixId: string, resolution: number, origin: import("ol/coordinate").Coordinate}>} */
+  const groupInfo = [];
+  const bandsByLevel = consolidatedMetadata ? {} : null;
+  let fillValue;
+  for (const groupMetadata of multiscales.layout) {
+    //TODO Handle the complete transform (rotation and different x/y resolutions)
+    const transform = groupMetadata['spatial:transform'];
+    const resolution = transform[0];
+    const origin = [transform[2], transform[5]];
+    const matrixId = groupMetadata.asset;
+    groupInfo.push({
+      matrixId,
+      resolution,
+      origin,
+    });
+    if (consolidatedMetadata) {
+      const availableBands = [];
+      for (const band of wantedBands) {
+        const bandArray =
+          consolidatedMetadata[`${wantedGroup}/${matrixId}/${band}`];
+        if (bandArray) {
+          availableBands.push(band);
+          if (fillValue === undefined) {
+            fillValue = bandArray['fill_value'];
+          }
+        }
+      }
+      bandsByLevel[matrixId] = availableBands;
+    }
+  }
+  groupInfo.sort((a, b) => b.resolution - a.resolution);
+  const tileGrid = new WMTSTileGrid({
+    extent: extent,
+    origins: groupInfo.map((g) => g.origin),
+    resolutions: groupInfo.map((g) => g.resolution),
+    matrixIds: groupInfo.map((g) => g.matrixId),
+  });
+
+  return {tileGrid, projection, bandsByLevel, fillValue};
+}
+
+/**
+ * @param {LegacyDatasetAttributes} attributes The dataset attributes.
+ * @return {TileGridInfo} The tile grid info.
+ */
+function getTileGridInfoFromLegacyAttributes(attributes) {
+  const multiscales = attributes.multiscales;
+  const tileMatrixSet = multiscales.tile_matrix_set;
+  const tileMatrixLimitsObject = multiscales.tile_matrix_limits;
+
+  const numMatrices = tileMatrixSet.tileMatrices.length;
+  const tileMatrixLimits = new Array(numMatrices);
+  let overrideTileSize = false;
+  for (let i = 0; i < numMatrices; i += 1) {
+    const tileMatrix = tileMatrixSet.tileMatrices[i];
+    const tilematrixId = tileMatrix.id;
+    if (tileMatrix.tileWidth > 512 || tileMatrix.tileHeight > 512) {
+      // Avoid tile sizes that are too large for rendering
+      overrideTileSize = true;
+    }
+    tileMatrixLimits[i] = tileMatrixLimitsObject[tilematrixId];
+  }
+
+  const info = parseTileMatrixSet(
+    {},
+    tileMatrixSet,
+    undefined,
+    tileMatrixLimits,
+  );
+
+  let tileGrid = info.grid;
+
+  // Tile size sanity
+  if (overrideTileSize) {
+    tileGrid = new WMTSTileGrid({
+      tileSize: 512,
+      extent: tileGrid.getExtent(),
+      origins: tileGrid.getOrigins(),
+      resolutions: tileGrid.getResolutions(),
+      matrixIds: tileGrid.getMatrixIds(),
+    });
+  }
+  return {tileGrid, projection: info.projection};
+}
+
+/**
+ * @param {Array<import("zarrita").Chunk<import("zarrita").DataType>>} chunks The input chunks.
+ * @param {Array<number>} chunkResolutions The resolutions for each band.
+ * @param {number} tileColCount The number of columns in the output data.
+ * @param {number} tileRowCount The number of rows in the output data.
+ * @param {number} tileResolution The tile resolution.
+ * @param {ResampleMethod} resampleMethod The resampling method.
+ * @param {number} fillValue The fill value.
+ * @return {Float32Array} The tile data.
+ */
+function composeData(
+  chunks,
+  chunkResolutions,
+  tileColCount,
+  tileRowCount,
+  tileResolution,
+  resampleMethod,
+  fillValue,
+) {
+  const bandCount = chunks.length;
+  const tileData = new Float32Array(tileColCount * tileRowCount * bandCount);
+  for (let tileRow = 0; tileRow < tileRowCount; tileRow++) {
+    for (let tileCol = 0; tileCol < tileColCount; tileCol++) {
+      for (let band = 0; band < bandCount; ++band) {
+        const chunk = chunks[band];
+        const chunkRowCount = chunk.shape[0];
+        const chunkColCount = chunk.shape[1];
+        const scaleFactor = tileResolution / chunkResolutions[band];
+        let value = fillValue;
+        if (scaleFactor === 1) {
+          if (tileRow < chunkRowCount && tileCol < chunkColCount) {
+            value = chunk.data[tileRow * chunkColCount + tileCol];
+          }
+        } else {
+          const chunkRow = tileRow * scaleFactor;
+          const chunkCol = tileCol * scaleFactor;
+          switch (resampleMethod) {
+            case 'nearest': {
+              const valueRow = Math.round(chunkRow);
+              const valueCol = Math.round(chunkCol);
+              if (valueRow < chunkRowCount && valueCol < chunkColCount) {
+                value = chunk.data[valueRow * chunkColCount + valueCol];
+              }
+              break;
+            }
+            default: {
+              throw new Error(`Unsupported resample method: ${resampleMethod}`);
+            }
+          }
+        }
+        if (isNaN(value)) {
+          value = fillValue;
+        }
+        tileData[bandCount * (tileRow * tileColCount + tileCol) + band] = value;
+      }
+    }
+  }
+  return tileData;
+}

package/source/ImageTile.d.ts

@@ -57,7 +57,7 @@ export type Options = {
     /**
      * Tile grid.
      */
-    tileGrid?: import("../tilegrid/TileGrid.js").default | undefined;
+    tileGrid?: import("../tilegrid.js").TileGrid | undefined;
     /**
      * The source state.
      */

package/source/TileArcGISRest.d.ts

@@ -43,7 +43,7 @@ export type Options = {
      * extent, the grid will be based on that; if not, a grid based on a global
      * extent with origin at 0,0 will be used.
      */
-    tileGrid?: import("../tilegrid/TileGrid.js").default | undefined;
+    tileGrid?: import("../tilegrid.js").TileGrid | undefined;
     /**
      * Projection. Default is the view projection.
      * The projection code must contain a numeric end portion separated by :