ol-stac 1.5.0 → 1.6.0

package/source/GeoZarr.d.ts

@@ -0,0 +1,601 @@
+/**
+ * @typedef {'nearest'|'linear'} ResampleMethod
+ */
+/**
+ * @typedef {Object} Band
+ * @property {string} name The band name.
+ * @property {string} group The group path relative to the `url`, containing this band
+ * (e.g. `'measurements/reflectance'`).
+ */
+/**
+ * @typedef {Object} GeoZarrStoreOptions
+ * @property {Object<string, string>} [headers] additional key-value pairs of headers to be passed with each request. Key is the header name, value the header value.
+ * @property {string} [credentials] How credentials shall be handled. See
+ * https://developer.mozilla.org/en-US/docs/Web/API/fetch for reference and possible values
+ */
+/**
+ * @typedef {Object} Options
+ * @property {string} url When `bands` contains plain strings, this must be the full URL to the
+ * multiscales group (e.g. `'https://example.com/store.zarr/measurements/reflectance'`).
+ * When `bands` contains {@link Band} objects, this is the base URL from which each band's
+ * `group` path is resolved (e.g. `'https://example.com/store.zarr/satellite/sentinel2'`).
+ * @property {Array<string|Band>} [bands] The bands to render, for stores where each
+ * band is a separate array. Mutually exclusive with `variable`.  Each entry is either a band name
+ * string (single-group mode) or a {@link Band} object specifying both the band name and the
+ * group it belongs to (multi-group mode).  In multi-group mode, the first band's group
+ * determines the tile grid and must follow at least the proj: and spatial: conventions.
+ * If it also has a multiscales layout (all three conventions), multiple resolution levels are
+ * supported.  Otherwise a single-resolution tile grid is derived from `spatial:bbox`,
+ * `proj:code`, and `spatial:shape` (or the array shape from consolidated metadata).
+ * Bands from additional groups do not need to follow any convention; they can be multi-scale
+ * (array located at `<matrixId>/<bandName>`) or single-scale (array at the group root).
+ * @property {GeoZarrStoreOptions} [storeOptions] Additional options to be passed to
+ * [zarrita](https://zarrita.dev/)'s `FetchStore` with each request to the Zarr store.
+ * @property {import("ol/proj.js").ProjectionLike} [projection] Source projection.
+ * If not provided, the GeoZarr 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='linear'] Resampling method if bands are not available for all multi-scale levels.
+ * @property {Object<string, number|string>} [dimensions] Fixed index for each non-spatial
+ * dimension of the band arrays, keyed by dimension name (e.g. `{time: 0}` for the first time step
+ * of a `[time, y, x]` cube); unspecified dimensions default to `0`. Names come from each array's
+ * `dimension_names`, or are the axis position as a string when it has none. Only integer indices
+ * are supported. Use the names from {@link getDimensions}, and change the selection on the fly with
+ * {@link module:ol/source/GeoZarr~GeoZarr#updateDimensions}.
+ * @property {string} [variable] The name of an n-dimensional data array (variable) to
+ * render, for stores where all bands are packed into a single array (e.g. a
+ * `(time, band, y, x)` datacube). The array must exist within each multiscale level
+ * group (or at the group root for single-scale stores). Mutually exclusive with `bands`.
+ * @property {Object<string, number|string|Array<number|string>>} [selector] For
+ * `variable` mode: how to slice each non-spatial dimension, keyed by dimension name
+ * (from the array's `dimension_names`). Values are 0-based indices (number), coordinate
+ * labels (string), or an array of these. At most one dimension may map to an array; its
+ * entries are rendered as separate bands (in the given order). Unlisted non-spatial
+ * dimensions default to index 0. Labels are resolved against the dimension's coordinate
+ * array; if that array cannot be read, pass indices instead.
+ * @property {import("ol/extent.js").Extent} [extent] Fallback extent of the data, in
+ * coordinates of the source projection. Only used when the store neither declares its
+ * extent (`spatial:bbox` or `bounds` attributes) nor has coordinate arrays to infer it.
+ * @property {boolean} [flipY] Fallback orientation: set to `true` when the data is
+ * stored south-up (ascending y). Only used when the orientation can neither be read
+ * from the store metadata nor inferred from its coordinate arrays.
+ */
+/**
+ * Source for GeoZarr stores conforming to the following conventions:
+ * - [Zarr multiscales convention](https://github.com/zarr-conventions/multiscales)
+ * - [Geospatial projection convention](https://github.com/zarr-conventions/geo-proj)
+ * - [Spatial convention](https://github.com/zarr-conventions/spatial)
+ *
+ * When all three conventions are present, multiple resolution levels are supported.
+ * When only proj: and spatial: are present, a single-resolution tile grid is derived
+ * from `spatial:bbox`, `proj:code`, and `spatial:shape`.
+ * The legacy `tile_matrix_set` attribute is also supported, as is the GeoZarr-style
+ * `multiscales` array attribute (`[{tile_matrix_set, datasets: [{path, ...}]}]`).
+ *
+ * Two data layouts are supported:
+ * - One array per band (`bands` option), addressed by name at `<matrixId>/<bandName>`
+ *   (multi-scale) or at the group root (single-scale). Supports Zarr v3.
+ * - A single n-dimensional data array shared by all bands (`variable` + `selector`
+ *   options), e.g. a `(time, band, y, x)` datacube. Supports Zarr v2 and v3; the
+ *   extent, resolution, projection and y-axis orientation are read from the store
+ *   metadata or inferred from the coordinate arrays.
+ */
+export default class GeoZarr extends DataTileSource<import("ol/DataTile.js").default> {
+    /**
+     * @param {Options} options The options.
+     */
+    constructor(options: Options);
+    /**
+     * @type {string}
+     * @private
+     */
+    private url_;
+    /**
+     * @type {GeoZarrStoreOptions|undefined}
+     * @private
+     */
+    private storeOptions_;
+    /**
+     * Fixed index per non-spatial dimension name, from the `dimensions` option.
+     * @type {Object<string, number|string>}
+     * @private
+     */
+    private dimensions_;
+    /**
+     * @type {string|undefined}
+     * @private
+     */
+    private variable_;
+    /**
+     * @type {Object<string, number|string|Array<number|string>>}
+     * @private
+     */
+    private selector_;
+    /**
+     * @type {import("ol/extent.js").Extent|undefined}
+     * @private
+     */
+    private fallbackExtent_;
+    /**
+     * @type {boolean|undefined}
+     * @private
+     */
+    private fallbackFlipY_;
+    /**
+     * The zarrita open function, pinned to v2 when the store cannot be
+     * probed for v3 metadata (e.g. servers answering 403 for missing keys).
+     * @type {Function}
+     * @private
+     */
+    private openFn_;
+    /**
+     * Group path prefix per tile matrix id, for stores whose levels are not
+     * addressed by the matrix id itself (empty string for the group root).
+     * `null` when the matrix id is the prefix.
+     * @type {Object<string, string>|null}
+     * @private
+     */
+    private levelPaths_;
+    /**
+     * Row axis information per tile matrix id, for data with non-square
+     * pixels or south-up (flipped) rows.
+     * @type {Object<string, {rowResolution: number, shapeY: number|undefined, flip: boolean}>|null}
+     * @private
+     */
+    private levelRowInfo_;
+    /**
+     * The axis selected as multiple bands through the `selector` option,
+     * or -1.
+     * @type {number}
+     * @private
+     */
+    private multiAxis_;
+    /**
+     * @type {Error|null}
+     */
+    error_: Error | null;
+    /**
+     * @type {Array<import('zarrita').Group<any>>}
+     * @private
+     */
+    private groups_;
+    /**
+     * @type {Object<string, *>|null}
+     * @private
+     */
+    private consolidatedMetadata_;
+    /**
+     * Cache of opened zarrita arrays keyed by path. Caching the Promise
+     * (not the resolved value) deduplicates concurrent opens for the same
+     * array path across tiles at the same zoom level.
+     * @private
+     * @type {Map<string, Promise<import('zarrita').Array<import('zarrita').DataType, any>>>}
+     */
+    private arrayCache_;
+    /**
+     * @type {Array<string>|undefined}
+     * @private
+     */
+    private groupPaths_;
+    /**
+     * Maps each band index to the index of the group it belongs to in `this.groups_`.
+     * @type {Array<number>}
+     * @private
+     */
+    private bandGroupIndex_;
+    /**
+     * Pixel resolution for single-scale bands.  When set, indicates that the
+     * band lives directly at its group root (no matrixId subdirectory) and
+     * provides the pixel resolution to use for coordinate calculations.
+     * Undefined for multi-scale bands.
+     * @type {Array<number|undefined>}
+     * @private
+     */
+    private bandSingleScaleResolution_;
+    /**
+     * @type {Array<string>}
+     * @private
+     */
+    private bands_;
+    /**
+     * Per-band selection along non-spatial dimensions: `undefined` for 2-D
+     * arrays, otherwise an array aligned to the array rank with a fixed integer
+     * at each extra axis and `null` at the two spatial axes (e.g. `[2, null,
+     * null]` for a `[time, y, x]` array with `time: 2`).
+     * @type {Array<Array<number|null>|undefined>}
+     * @private
+     */
+    private bandExtraSelection_;
+    /**
+     * Per-band spatial (y, x) axis positions, as `{row, col}`.
+     * @type {Array<{row: number, col: number}>}
+     * @private
+     */
+    private bandSpatialAxes_;
+    /**
+     * The two spatial axis names from the group's `spatial:dimensions` (`[y, x]`).
+     * @type {Array<string>|undefined}
+     * @private
+     */
+    private spatialDimensionNames_;
+    /**
+     * Non-spatial dimensions of the bands, exposed via {@link getDimensions}.
+     * @type {Array<{name: string, size: number}>}
+     * @private
+     */
+    private extraDimensions_;
+    /**
+     * @type {Object<string, Array<string>>|null|undefined}
+     * @private
+     */
+    private bandsByLevel_;
+    /**
+     * @type {number|undefined}
+     * @private
+     */
+    private fillValue_;
+    /**
+     * @type {ResampleMethod}
+     * @private
+     */
+    private resampleMethod_;
+    /**
+     * @type {import("ol/tilegrid/WMTS.js").default}
+     * @override
+     */
+    override tileGrid: import("ol/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('ol/source/DataTile.js').LoaderOptions} options The loader options.
+     * @return {Promise<import("ol/DataTile.js").Data>} The composed tile data.
+     * @private
+     */
+    private loadTile_;
+    /**
+     * For multi-group mode: determine which group owns each band and supplement
+     * bandsByLevel with bands from additional groups.
+     * @private
+     */
+    private resolveBandOwnership_;
+    /**
+     * Open a Zarr array (path relative to its group) through the shared cache, so
+     * concurrent opens of the same array are deduplicated.
+     * @param {number} groupIndex The band's group index.
+     * @param {string} path The array path relative to the group.
+     * @return {Promise<import('zarrita').Array<import('zarrita').DataType, any>>} The array.
+     * @private
+     */
+    private openArray_;
+    /**
+     * Consolidated metadata for a group, with keys relative to that group.
+     * @param {number} groupIndex The group index.
+     * @return {Object<string, *>} The group's consolidated metadata.
+     * @private
+     */
+    private groupMetadata_;
+    /**
+     * Look up a band's Zarr v3 array metadata from consolidated metadata, trying
+     * the multi-scale key (`<matrixId>/<band>`) first and falling back to a
+     * single-scale key (`<band>`).
+     * @param {string} band The band name.
+     * @param {number} groupIndex The index of the band's group.
+     * @return {Object<string, *>|undefined} The array metadata, or undefined when unavailable.
+     * @private
+     */
+    private getBandArrayMeta_;
+    /**
+     * Locate the 1-D coordinate array for a non-spatial dimension, by name among
+     * the group's 1-D arrays.
+     * @param {string} name The dimension name.
+     * @return {{path: string, groupIndex: number, meta: Object<string, *>}|null} The path
+     *     (relative to the group), group index, and array metadata; or `null`.
+     * @private
+     */
+    private coordinateArray_;
+    /**
+     * Get the non-spatial dimensions of the bands (e.g. `time`) that can be fixed
+     * through the `dimensions` option, keyed by dimension name. Each entry has its
+     * `size` and the `attributes` of its coordinate array (e.g. `units`, for
+     * interpreting the values from {@link getValue}), or `attributes: null` when
+     * there is no coordinate array. Resolves with an empty object for 2-D bands,
+     * once the source is `ready`; rejects if the source fails to load.
+     * @return {Promise<Object<string, {size: number, attributes: Object|null}>>}
+     *     The selectable dimensions.
+     */
+    getDimensions(): Promise<{
+        [x: string]: {
+            size: number;
+            attributes: any | null;
+        };
+    }>;
+    /**
+     * Read the coordinate value at an index along a non-spatial dimension (e.g.
+     * the timestamp for a `time` index), for labeling the current selection. The
+     * value is returned raw (as stored, e.g. a `bigint` for a 64-bit integer
+     * axis); use the `attributes` from {@link getDimensions} to interpret it.
+     * Returns `null` for a dimension without a coordinate array. Available once
+     * the source is `ready`.
+     * @param {string} name The dimension name (see {@link getDimensions}).
+     * @param {number} index The index along the dimension.
+     * @return {Promise<number|bigint|null>} The coordinate value, or null.
+     */
+    getValue(name: string, index: number): Promise<number | bigint | null>;
+    /**
+     * Change the fixed index of one or more non-spatial dimensions (e.g. move to
+     * another `time` slice) without rebuilding the source. Values are merged into
+     * the current selection, so a partial update like `{time: 3}` leaves the other
+     * dimensions untouched. Takes effect immediately when the source is `ready`,
+     * otherwise once it becomes ready.
+     * @param {Object<string, number|string>} dimensions Index per dimension name
+     *     to change; see the `dimensions` constructor option.
+     */
+    updateDimensions(dimensions: {
+        [x: string]: number | string;
+    }): void;
+    /**
+     * Locate the spatial (y, x) axes of an array (see {@link getSpatialAxes}) and
+     * its remaining non-spatial axes.
+     * @param {Object<string, *>|undefined} arrayMeta Zarr v3 array metadata.
+     * @return {{row: number, col: number, extra: Array<number>}} The row (y) and
+     *     column (x) axis positions and the remaining extra axes, in array order.
+     * @private
+     */
+    private axesOf_;
+    /**
+     * Describe the non-spatial dimensions of an array. Each is named by its
+     * `dimension_names` entry, or by its axis position when there are none.
+     * @param {Object<string, *>|undefined} arrayMeta Zarr v3 array metadata.
+     * @return {Array<{name: string, size: number, axis: number}>} The extra dimensions, outermost first.
+     * @private
+     */
+    private extraDimsOf_;
+    /**
+     * Resolve the fixed index for each non-spatial dimension of a band array from
+     * the `dimensions` option. Returns `undefined` for 2-D arrays, otherwise an
+     * array aligned to the array rank with a fixed integer at each extra axis and
+     * `null` at the two spatial axes (e.g. `[2, null, null]` for a `[time, y, x]`
+     * array with `{time: 2}`).
+     * @param {Object<string, *>|undefined} arrayMeta Zarr v3 array metadata.
+     * @param {Object<string, number|string>} dimensions The dimension indices
+     *     to resolve against.
+     * @return {Array<number|null>|undefined} The extra-axis selection template.
+     * @private
+     */
+    private resolveExtraSelection_;
+    /**
+     * Open the group, retrying as Zarr v2 without probing for v3 metadata
+     * first, for servers that answer 403 for missing keys.
+     * @param {*} source The store or location to open.
+     * @return {Promise<import('zarrita').Group<any>>} The opened group.
+     * @private
+     */
+    private openGroup_;
+    /**
+     * @param {Object<string, *>} attributes The dataset attributes.
+     * @param {FetchStore} store The store, for metadata requests not covered
+     * by consolidated metadata.
+     * @private
+     */
+    private configureDatacube_;
+    /**
+     * Determine the projection from the store metadata: the proj: convention,
+     * a CRS code from the multiscale metadata or xarray-style attributes, a
+     * `proj4` definition, or (for degree-like extents) EPSG:4326.
+     * @param {Object<string, *>} attributes The dataset attributes.
+     * @param {string|null} crsHint A CRS code from the multiscale metadata.
+     * @param {import("ol/extent.js").Extent} extent The extent.
+     * @return {import("ol/proj/Projection.js").default} The projection.
+     * @private
+     */
+    private inferProjection_;
+    /**
+     * Read the first and last value of a 1-dimensional coordinate array.
+     * @param {string} levelPath The level group path ('' for the root).
+     * @param {string} dimName The dimension (and coordinate array) name.
+     * @return {Promise<Array<number>>} The first value, last value, and length.
+     * @private
+     */
+    private readCoordinateEndpoints_;
+    /**
+     * Resolve a coordinate label to its index by reading the dimension's
+     * coordinate array.
+     * @param {string} dimName The dimension name.
+     * @param {string} label The label to resolve.
+     * @param {string} [levelPath] The level group path ('' for the root).
+     * @return {Promise<number>} The index of the label.
+     * @private
+     */
+    private resolveCoordinateLabel_;
+}
+export type ShardInfo = {
+    /**
+     * The shard (outer chunk) shape [rows, cols].
+     */
+    shardShape: Array<number>;
+    /**
+     * The inner chunk shape [rows, cols].
+     */
+    innerChunkShape: Array<number>;
+};
+export type ResampleMethod = 'nearest' | 'linear';
+export type Band = {
+    /**
+     * The band name.
+     */
+    name: string;
+    /**
+     * The group path relative to the `url`, containing this band
+     * (e.g. `'measurements/reflectance'`).
+     */
+    group: string;
+};
+export type GeoZarrStoreOptions = {
+    /**
+     * additional key-value pairs of headers to be passed with each request. Key is the header name, value the header value.
+     */
+    headers?: {
+        [x: string]: string;
+    } | undefined;
+    /**
+     * How credentials shall be handled. See
+     * https://developer.mozilla.org/en-US/docs/Web/API/fetch for reference and possible values
+     */
+    credentials?: string | undefined;
+};
+export type Options = {
+    /**
+     * When `bands` contains plain strings, this must be the full URL to the
+     * multiscales group (e.g. `'https://example.com/store.zarr/measurements/reflectance'`).
+     * When `bands` contains {@link Band } objects, this is the base URL from which each band's
+     * `group` path is resolved (e.g. `'https://example.com/store.zarr/satellite/sentinel2'`).
+     */
+    url: string;
+    /**
+     * The bands to render, for stores where each
+     * band is a separate array. Mutually exclusive with `variable`.  Each entry is either a band name
+     * string (single-group mode) or a {@link Band } object specifying both the band name and the
+     * group it belongs to (multi-group mode).  In multi-group mode, the first band's group
+     * determines the tile grid and must follow at least the proj: and spatial: conventions.
+     * If it also has a multiscales layout (all three conventions), multiple resolution levels are
+     * supported.  Otherwise a single-resolution tile grid is derived from `spatial:bbox`,
+     * `proj:code`, and `spatial:shape` (or the array shape from consolidated metadata).
+     * Bands from additional groups do not need to follow any convention; they can be multi-scale
+     * (array located at `<matrixId>/<bandName>`) or single-scale (array at the group root).
+     */
+    bands?: (string | Band)[] | undefined;
+    /**
+     * Additional options to be passed to
+     * [zarrita](https://zarrita.dev/)'s `FetchStore` with each request to the Zarr store.
+     */
+    storeOptions?: GeoZarrStoreOptions | undefined;
+    /**
+     * Source projection.
+     * If not provided, the GeoZarr metadata will be read for projection information.
+     */
+    projection?: import("ol/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;
+    /**
+     * Resampling method if bands are not available for all multi-scale levels.
+     */
+    resample?: ResampleMethod | undefined;
+    /**
+     * Fixed index for each non-spatial
+     * dimension of the band arrays, keyed by dimension name (e.g. `{time: 0}` for the first time step
+     * of a `[time, y, x]` cube); unspecified dimensions default to `0`. Names come from each array's
+     * `dimension_names`, or are the axis position as a string when it has none. Only integer indices
+     * are supported. Use the names from {@link getDimensions }, and change the selection on the fly with
+     * {@link module :ol/source/GeoZarr~GeoZarr#updateDimensions}.
+     */
+    dimensions?: {
+        [x: string]: string | number;
+    } | undefined;
+    /**
+     * The name of an n-dimensional data array (variable) to
+     * render, for stores where all bands are packed into a single array (e.g. a
+     * `(time, band, y, x)` datacube). The array must exist within each multiscale level
+     * group (or at the group root for single-scale stores). Mutually exclusive with `bands`.
+     */
+    variable?: string | undefined;
+    /**
+     * For
+     * `variable` mode: how to slice each non-spatial dimension, keyed by dimension name
+     * (from the array's `dimension_names`). Values are 0-based indices (number), coordinate
+     * labels (string), or an array of these. At most one dimension may map to an array; its
+     * entries are rendered as separate bands (in the given order). Unlisted non-spatial
+     * dimensions default to index 0. Labels are resolved against the dimension's coordinate
+     * array; if that array cannot be read, pass indices instead.
+     */
+    selector?: {
+        [x: string]: string | number | (string | number)[];
+    } | undefined;
+    /**
+     * Fallback extent of the data, in
+     * coordinates of the source projection. Only used when the store neither declares its
+     * extent (`spatial:bbox` or `bounds` attributes) nor has coordinate arrays to infer it.
+     */
+    extent?: import("ol/extent.js").Extent | undefined;
+    /**
+     * Fallback orientation: set to `true` when the data is
+     * stored south-up (ascending y). Only used when the orientation can neither be read
+     * from the store metadata nor inferred from its coordinate arrays.
+     */
+    flipY?: boolean | undefined;
+};
+/**
+ * *
+ */
+export type DatasetAttributes = {
+    multiscales: Multiscales;
+    zarr_conventions: Array<{
+        uuid: string;
+    }>;
+    'spatial:bbox': import("ol/extent.js").Extent;
+    'spatial:shape': Array<number>;
+    'spatial:dimensions'?: Array<string>;
+    'proj:wkt2'?: string;
+    'proj:projjson'?: any;
+    'proj:code'?: string | null;
+};
+export type Multiscales = {
+    /**
+     * The layout.
+     */
+    layout: Array<{
+        [x: string]: 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("ol/proj/Projection.js").default;
+    /**
+     * Available bands by level.
+     */
+    bandsByLevel?: {
+        [x: string]: string[];
+    } | undefined;
+    /**
+     * The fill value.
+     */
+    fillValue?: number | undefined;
+    /**
+     * The tile sizes for each level, if available.
+     */
+    tileSizes?: Array<import("ol/size.js").Size> | undefined;
+};
+import DataTileSource from 'ol/source/DataTile.js';
+import WMTSTileGrid from 'ol/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":["../../../src/ol/source/GeoZarr.js"],"names":[],"mappings":"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"}