@opengeoweb/webmap-react 19.0.0 → 19.1.1

package/dist/src/lib/components/OpenLayers/styles/useIconStyle.d.ts

@@ -0,0 +1,25 @@
+import { Style } from 'ol/style';
+import type { Options } from 'ol/style/Icon';
+type IconSVG = string | {
+    path: string;
+    width?: number;
+    height?: number;
+};
+interface IconParameters {
+    render?: {
+        fillStyle?: string | CanvasGradient | CanvasPattern;
+        strokeStyle?: string | CanvasGradient | CanvasPattern;
+        lineWidth?: number;
+    };
+    icon?: Omit<Options, 'img'>;
+}
+interface UseIconStyleProps {
+    svgPath: string;
+    options: IconParameters;
+}
+interface IconStyle {
+    icon: Style;
+}
+export declare const createIconStyle: ((input: IconSVG, options: IconParameters) => Style) & import("lodash").MemoizedFunction;
+export declare const useIconStyle: ({ svgPath, options, }: UseIconStyleProps) => IconStyle;
+export {};

package/dist/src/lib/components/OpenLayers/tools/ClickOnMapTool.d.ts

@@ -0,0 +1,9 @@
+import type { StyleLike } from 'ol/style/Style';
+export interface ClickOnMapToolProps {
+    isActive: boolean;
+    isVisible: boolean;
+    layerZIndex?: number;
+    pointStyle: StyleLike;
+    pointSelected: (coords: number[]) => void;
+}
+export declare const ClickOnMapTool: React.FC<ClickOnMapToolProps>;

package/dist/src/lib/components/OpenLayers/tools/index.d.ts

@@ -0,0 +1 @@
+export { ClickOnMapTool } from './ClickOnMapTool';

package/dist/src/lib/components/OpenLayers/types/Timespan.d.ts

@@ -0,0 +1,11 @@
+import type { RefTimeDimensionModes } from '@opengeoweb/webmap';
+export interface Timespan {
+    start: number;
+    end: number;
+    step: number;
+}
+export interface TimeContextType {
+    isAnimating: boolean;
+    prefetchList: number[];
+    refTimeDimensionModes?: RefTimeDimensionModes;
+}

package/dist/src/lib/components/OpenLayers/types/WorkerQueue.d.ts

@@ -0,0 +1,6 @@
+export type FinaliseFn = (cancelled: boolean) => void;
+export interface WorkerQueueJob {
+    task: () => Promise<FinaliseFn | void>;
+    cancelled: boolean;
+    dimValue: string;
+}

package/dist/src/lib/components/OpenLayers/useProjectionDropDown.d.ts

@@ -0,0 +1,17 @@
+import { View } from 'ol';
+import React from 'react';
+import type { EPSGCode } from '@opengeoweb/shared';
+import type { Bbox } from '@opengeoweb/webmap';
+export interface BboxAndSrs {
+    srs: EPSGCode;
+    bbox: Bbox;
+}
+export interface SrsSelectComponentProps {
+    srsAndBBOX: BboxAndSrs;
+    setSrs: (value: string) => void;
+}
+export declare const SrsSelectComponent: React.FC<SrsSelectComponentProps>;
+export declare const useProjectionDropDown: (initCRS?: string) => {
+    view: View;
+    selectComponent: React.ReactElement;
+};

package/dist/src/lib/components/OpenLayers/utils/ShowTimeAwareLayerInfo.d.ts

@@ -0,0 +1,10 @@
+import type ImageLayer from 'ol/layer/Image';
+import type { WMLayer } from '@opengeoweb/webmap';
+import type { TimeawareImageSource } from './TimeawareImageSource';
+export interface ShowTimeAwareLayerInfoProps {
+    wmLayer: WMLayer;
+    stepsToCheck: number[];
+    layer: ImageLayer<TimeawareImageSource>;
+    visible: boolean;
+}
+export declare const ShowTimeAwareLayerInfo: React.FC<ShowTimeAwareLayerInfoProps>;

package/dist/src/lib/components/OpenLayers/utils/TimeAwareImageWrapper.d.ts

@@ -0,0 +1,44 @@
+import type { Extent } from 'ol/extent';
+import ImageWrapper from 'ol/Image';
+import type { Projection } from 'ol/proj';
+import type { WMImage } from '@opengeoweb/webmap';
+import { WMImageStore } from '@opengeoweb/webmap';
+export declare const openLayersGetMapImageStore: WMImageStore;
+export declare const clearImageCacheForAllMaps: () => void;
+interface TimeAwareGeoreferencedImageSrc {
+    src: string;
+    extent: Extent;
+    resolution: number;
+}
+interface TimeAwareGeoreferencedImage {
+    el: HTMLImageElement;
+    extent: Extent;
+    resolution: number;
+    isLoaded: boolean;
+    hasError: boolean;
+    isLoadedWithoutErrors: boolean;
+    isLoading: boolean;
+}
+declare class TimeAwareImageWrapper extends ImageWrapper {
+    private _extentToLoad;
+    private _resolutionToLoad;
+    private _pixelRatioToLoad;
+    private _paramsToLoad;
+    private _dimPropsToLoad;
+    private _getMapUrl;
+    private projection;
+    private _resolvers;
+    private _styleName;
+    private _layerName;
+    constructor(extent: Extent, resolution: number, pixelRatio: number);
+    getWMSGetMapRequestURL(extentToLoad: Extent, resolutionToLoad: number, __pixelRatio: number, projection: Projection | null, getMapUrl: string | null, params: Record<string, string>, layerName: string | null, styleName: string, dimProps: Record<string, string>): TimeAwareGeoreferencedImageSrc;
+    getAlternativeImage(extent: Extent, resolution: number, pixelRatio: number, projection: Projection, getMapUrl: string, params: Record<string, string>, layerName: string, styleName: string, dimsProps: Record<string, string>): TimeAwareGeoreferencedImage | false;
+    hasImage(extent: Extent, resolution: number, pixelRatio: number, projection: Projection, getMapUrl: string, params: Record<string, string>, layerName: string, styleName: string, dimsProps: Record<string, string>): TimeAwareGeoreferencedImage | false;
+    setGeoReferencedImage(image: TimeAwareGeoreferencedImage): void;
+    load(): void;
+    setState(state: number): void;
+    private _rejectAll;
+    private _resolveAll;
+    loadAndResolve(extentToLoad: Extent, resolutionToLoad: number, pixelRatio: number, projection: Projection, getMapUrl: string, params: Record<string, string>, layerName: string, styleName: string, dimProps: Record<string, string>): Promise<WMImage>;
+}
+export default TimeAwareImageWrapper;

package/dist/src/lib/components/OpenLayers/utils/TimeawareImageSource.d.ts

@@ -0,0 +1,68 @@
+import type { Extent } from 'ol/extent';
+import type ImageWrapper from 'ol/Image';
+import type { Projection } from 'ol/proj';
+import ImageSource from 'ol/source/Image';
+import type { WMImage } from '@opengeoweb/webmap';
+import TimeAwareImageWrapper from './TimeAwareImageWrapper';
+export declare const initImageWrapper: () => TimeAwareImageWrapper;
+interface TimeawareImageSourceOptions {
+    wmsUrl: string;
+    params?: Record<string, string>;
+    layerName: string;
+    layerId: string;
+    dimProps?: Record<string, string>;
+    styleName?: string | undefined;
+    timeStampsToPrefetch?: string[];
+    visible?: boolean;
+}
+export declare class TimeawareImageSource extends ImageSource {
+    private _wmsUrl;
+    private _extraWMSParams;
+    private _timeStampsToPrefetch;
+    private _prefetchWorkers;
+    private _lastRequestedExtent;
+    private _lastRequestedResolution;
+    private _lastRequestedPixelRatio;
+    private _lastRequestedProjection;
+    private _loadedExtent;
+    private _loadedResolution;
+    private _loadedPixelRatio;
+    private _loadedProjection;
+    private _previousPrefetchExtent;
+    private _dimProperties;
+    private _imWrapperEmptyButLoading;
+    private _imWrapperForOlSource;
+    private _imWrapperForAltImage;
+    private _styleName;
+    private _layerName;
+    private throttledPrefetch;
+    private throttledImageLoad;
+    private _layerId;
+    constructor({ wmsUrl, timeStampsToPrefetch, layerName, layerId, styleName, dimProps, params, visible, }: TimeawareImageSourceOptions);
+    private _conditionalPrefetch;
+    private _loadImagery;
+    private prefetch;
+    triggerPrefetch(): void;
+    cancelPrefetch(): void;
+    getImage(extent: Extent, resolution: number, pixelRatio: number, projection: Projection): ImageWrapper;
+    setDimProps(params: Record<string, string>): void;
+    /**
+     * Check if an image is available and loaded for requested date. Used for showlayerinfo to proceed.
+     * @param isoTime
+     * @returns
+     */
+    hasImageLoadedForTimeValue(isoTime: string): boolean;
+    getAltGeoReferencedImages(isoTime: string): WMImage[];
+    /**
+     * This function can be used to determine if the animation can proceed to the next step.
+     * @param isoTime ISO8601 string formatat like `YYYY-MM-DDTHH:MM:SSZ`
+     * @returns Only specic case it returns false: when a image is available and is loading. That means we wait till it is loaded.
+     *          This function returns true if an image is not available in the store. Or true if it is available and already loaded.
+     */
+    isImageLoadingForTimestep(isoTime: string): boolean;
+    setImageForTimeValue(timeStampsToPrefetch: string): void;
+    setStyle(styleName: string): void;
+    setLayerName(layerName: string): void;
+    setTimeValuesValuesToPrefetch(timeStampsToPrefetch: string[]): void;
+}
+export {};

package/dist/src/lib/components/OpenLayers/utils/WorkerQueue.d.ts

@@ -0,0 +1,14 @@
+import type { WorkerQueueJob } from '../types/WorkerQueue';
+export declare class WorkerQueue {
+    maxConcurrency: number;
+    tasksInProcess: WorkerQueueJob[];
+    taskQueue: WorkerQueueJob[];
+    private disposed;
+    constructor(concurrency: number);
+    dispose(): void;
+    ensureWork(): void;
+    clearJobs(): void;
+    addJobs(work: WorkerQueueJob[]): void;
+    addJobsWithoutReorder(work: WorkerQueueJob[]): void;
+    private _startJob;
+}

package/dist/src/lib/components/OpenLayers/utils/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const MAX_NUMBER_TO_PREFETCH = 200;
+export declare const MAX_NUMBER_STEPS_IN_TIME_SLIDER_TO_PREFETCH = 10000;
+export declare const NUMBER_PREFETCH_WORKERS = 4;
+export declare const ENABLE_PREFETCH = true;
+export declare const ADD_SHOW_DIMS_OPTION = false;
+export declare const NUM_IMAGES_TO_CACHE = 10000;
+export declare const WMS_EXTENT_RATIO_TO_VIEWPORT = 1.2;
+export declare const TIMEAWAREIMAGEWRAPPER_IMAGEDIDNOTLOADSUCCESFULLY = "Image did not load succesfully";

package/dist/src/lib/components/OpenLayers/utils/makeDimValuesToPrefetch.d.ts

@@ -0,0 +1,26 @@
+import type { WMJSDimension, Dimension, WMLayer } from '@opengeoweb/webmap';
+import type { Timespan } from '../types/Timespan';
+/**
+ *
+ * @param wmTimeDim WMDimension time containing dimension values
+ * @param stepsToCheck Array with timestamps as posix timestamps to check
+ * @param isAnimating If the application is running an animation loop
+ * @returns A string list with ISO8601 values to fetch
+ */
+export declare const makeDimValuesToPrefetch: (wmTimeDim: WMJSDimension, stepsToCheck: number[], isAnimating: boolean) => string[];
+export declare const extendPrefetchListWithModelRunTimeSteps: (wmLayer: WMLayer, stepsToCheck: number[]) => number[];
+/**
+ * We use the WMLayer dimension logic to obtain the dimension value to use in the WMS GetMap request. The input is the dimensions array which is typically the properties set for the layer component.
+ * The input time is descretized to the closest value which is available in the WMS layer.
+ *
+ * @param dimensions Array of dimension key/values to use as input
+ * @param wmLayer The layer for which we would like to do the request
+ * @returns A map which returns a key/value to use
+ */
+export declare const getDimensionParamsForWMS: (dimensions: Dimension[], wmLayer: WMLayer | null) => Record<string, string> | undefined;
+/**
+ * Calculates number of timesteps for given timespan
+ * @param timespan Object of Timespan, with start/stop/end in milliseconds
+ * @returns Timestams array in milliseconds
+ */
+export declare const makeTimeList: ((timespan: Timespan) => number[]) & import("lodash").MemoizedFunction;

package/dist/src/lib/components/OpenLayers/utils/projections.d.ts

@@ -0,0 +1,16 @@
+import type { LayerProps } from '@opengeoweb/webmap';
+export declare const initializeOpenLayersProjections: () => void;
+/**
+ * Returns a preferred projection to use with a particular layer. It will search the layer props for
+ * a supported srs that either matches the current view srs or an srs that geoweb has reprojection math
+ * for. The first priority is the view srs and then any of the other supported srs. If no shared SRS
+ * is found, the function will return EPSG:3857 since that is almost always supported. There may be
+ * layers for which we do not have LayerProps for (for example layers not visible in a GetCapabilities
+ * document for a service) and thus defaulting to EPSG:3857 makes sense.
+ *
+ * @param viewSrs
+ * @param layerProps
+ * @returns
+ */
+export declare const selectPreferredWMSProjection: (viewSrs: string, layerProps: LayerProps | null) => string;
+export declare const useProjection: () => string | undefined;

package/dist/src/lib/components/OpenLayers/utils/setMapCenter.d.ts

@@ -0,0 +1,2 @@
+import type { Map } from 'ol';
+export declare const setMapCenter: (map: Map, lon: number, lat: number, zoomLevel?: number) => void;

package/dist/src/lib/components/OpenLayers/utils/types.d.ts

@@ -0,0 +1,19 @@
+import type { Feature } from 'ol';
+import type { Dimension } from '@opengeoweb/webmap';
+export interface HoverSelect {
+    onHover?: (f: Feature | undefined) => void;
+    active: boolean;
+}
+export interface ClickOnFeature {
+    onClick: (f: Feature[], isShiftClick?: boolean) => void;
+    hitTolerance?: number;
+}
+export interface BoxSelect {
+    onBoxSelect: (features: Feature[], addToSelection: boolean) => void;
+    active: boolean;
+}
+export interface OnInitializeLayerProps {
+    layerId: string;
+    style: string;
+    dimensions: Dimension[];
+}

package/dist/src/lib/components/OpenLayers/utils/viewUtils.d.ts

@@ -0,0 +1,11 @@
+import type { FeatureCollection, Geometry, GeoJsonProperties } from 'geojson';
+import { View } from 'ol';
+import type { Bbox } from '@opengeoweb/webmap';
+export declare const setViewFromExtent: (view: View, bbox: Bbox) => void;
+export declare const setViewFromFeature: (view: View, geojsonFeature: FeatureCollection<Geometry, GeoJsonProperties> | undefined) => void;
+export declare const makeView: (projectionCode?: string) => View;
+export declare const viewUtils: {
+    setViewFromExtent: (view: View, bbox: Bbox) => void;
+    setViewFromFeature: (view: View, geojsonFeature: FeatureCollection<Geometry, GeoJsonProperties> | undefined) => void;
+    makeView: (projectionCode?: string) => View;
+};

package/dist/src/lib/components/Providers/Providers.d.ts

@@ -0,0 +1,2 @@
+import type { ThemeProviderProps } from '@opengeoweb/theme';
+export declare const WebmapReactThemeProvider: React.FC<ThemeProviderProps>;

package/dist/src/lib/components/Providers/index.d.ts

@@ -0,0 +1 @@
+export * from './Providers';

package/dist/src/lib/components/TanStackDemo/storyUtils.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface StoryWrapperProps {
+    children: [] | React.ReactElement;
+}
+export declare const StoryWrapper: ({ children, }: StoryWrapperProps) => React.ReactElement;
+export {};

package/dist/src/lib/components/WMSViewerDemo/components/WMSDimTimeYearSelector.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+export declare enum TimeMode {
+    YEAR = 0,
+    MONTH = 1,
+    DAY = 2,
+    HOUR = 3,
+    MINUTE = 4,
+    SECOND = 5
+}
+interface WMSDimTimeYearSelectorProps {
+    selectedISOTime: string;
+    layerId: string;
+    onSelectTime: (time: string) => void;
+    mode: TimeMode;
+}
+export declare const increaseTime: (selectedISOTime: string, timeRes: string) => string;
+declare const WMSDimTimeYearSelector: ({ selectedISOTime, layerId, onSelectTime, mode, }: WMSDimTimeYearSelectorProps) => React.ReactElement<WMSDimTimeYearSelectorProps> | null;
+export default WMSDimTimeYearSelector;

package/dist/src/lib/components/WMSViewerDemo/components/WMSLayerSelector.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { LayerProps, LayerFoundation } from '@opengeoweb/webmap';
+interface WMSLayerSelectorProps {
+    layer: LayerFoundation;
+    layers: LayerProps[];
+    onSelectLayer: (layer: LayerProps) => void;
+}
+declare const WMSLayerSelector: ({ layer, layers, onSelectLayer, }: WMSLayerSelectorProps) => React.ReactElement<WMSLayerSelectorProps>;
+export default WMSLayerSelector;

package/dist/src/lib/components/WMSViewerDemo/components/WMSStyleSelector.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { LayerFoundation } from '@opengeoweb/webmap';
+interface WMSStyleSelectorProps {
+    layer: LayerFoundation;
+    onSelectStyle: (layer: LayerFoundation) => void;
+}
+declare const WMSStyleSelector: ({ layer, onSelectStyle, }: WMSStyleSelectorProps) => React.ReactElement<WMSStyleSelectorProps> | null;
+export default WMSStyleSelector;

package/dist/src/lib/components/WMSViewerDemo/components/WMSTimeSlider.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface WMSTimeSliderProps {
+    selectedISOTime: string;
+    layerId: string;
+    onSelectTime: (time: string) => void;
+}
+declare const WMSTimeSlider: ({ selectedISOTime, layerId, onSelectTime, }: WMSTimeSliderProps) => React.ReactElement<WMSTimeSliderProps> | null;
+export default WMSTimeSlider;

package/dist/src/lib/components/index.d.ts

@@ -0,0 +1,9 @@
+export * from './Legend';
+export * from './MapTime';
+export * from './MapControls';
+export * from './MapWarning';
+export * from './MapDimensionSelect';
+export * from './LayerInfo';
+export * from './OpenLayers';
+export * from './MapMeasure';
+export * from './Clock';

package/dist/src/lib/edr-layer-api/api.d.ts

@@ -0,0 +1,7 @@
+import type { Coverage, CoverageCollection, EDRInstance, PointDomain, PointSeriesDomain } from '@opengeoweb/shared';
+export declare const handleResponse: (response: Response) => Promise<unknown>;
+export declare const joinUrlParams: (params: string[]) => string;
+export declare const fetchEDRCollectionDetails: (edrBaseUrlWithCollection: string, instanceId?: string) => Promise<EDRInstance>;
+export declare const fetchEDRCube: (edrBaseUrlWithCollection: string, parameterName: string, datetime?: string, instanceId?: string, bbox?: string) => Promise<CoverageCollection<PointDomain | PointSeriesDomain> | Coverage<PointDomain | PointSeriesDomain>>;
+export declare const fetchEDRArea: (edrBaseUrlWithCollection: string, parameterName: string, datetime?: string, instanceId?: string, coords?: string) => Promise<CoverageCollection<PointDomain | PointSeriesDomain> | Coverage<PointDomain | PointSeriesDomain>>;
+export declare const fetchEDRParameter: (collection: EDRInstance | undefined, edrBaseUrlWithCollection: string, parameterName: string, datetime?: string, instanceId?: string) => Promise<CoverageCollection<PointDomain | PointSeriesDomain> | Coverage<PointDomain | PointSeriesDomain> | undefined>;

package/dist/src/lib/edr-layer-api/colormaps/colormaps.d.ts

@@ -0,0 +1,9 @@
+export type ColorMap = string[];
+export declare const temperatureLegendColorsWoW: ColorMap;
+export declare const precipitationMMLegendColorsWoW: ColorMap;
+export declare const temperatureLegendColorsCWK: ColorMap;
+export declare const colorMaps: {
+    temperatureLegendColorsWoW: ColorMap;
+    precipitationMMLegendColorsWoW: ColorMap;
+    temperatureLegendColorsCWK: ColorMap;
+};

package/dist/src/lib/edr-layer-api/colormaps/edrOlLegendUtils.d.ts

@@ -0,0 +1,32 @@
+import type { FeatureLike } from 'ol/Feature';
+import { Circle, Style } from 'ol/style';
+import type { ColorMap } from './colormaps';
+export interface EdrMapLegendEntry {
+    min: number;
+    max: number;
+    color: string;
+    image: Circle;
+}
+export interface EdrOlColorLegend {
+    legend: EdrMapLegendEntry[];
+}
+export declare const makeLegendFromStyleName: (styleName: string) => EdrOlColorLegend | null;
+export declare const makeLegendFromColorMap: (props: {
+    colors: ColorMap;
+    min: number;
+    max: number;
+}) => EdrOlColorLegend;
+export declare const generateImageFromLegend: (edrColorLegend: EdrOlColorLegend, ctx: CanvasRenderingContext2D, opacity?: number) => number;
+export declare const getLegendClass: (edrColorLegend: EdrOlColorLegend, value: number, clip?: boolean) => EdrMapLegendEntry | undefined;
+export declare const makeFeatureStyleWind: (feature: FeatureLike) => Style[];
+export declare const makeFeatureStyleMultiParam: (feature: FeatureLike) => Style[];
+export declare const makeFeatureStyleMultiParamLoading: () => Style;
+export declare const makeFeatureStyleDisc: (feature: FeatureLike, legend: EdrOlColorLegend) => Style;
+export declare const makeFeatureStyleLoading: (feature: FeatureLike) => Style;
+export declare const styleNameToStyleLike: ((styleName: string, multiParam?: boolean) => ((feature: FeatureLike) => Style | Style[])) & import("lodash").MemoizedFunction;
+export declare const defaultEdrStyles: {
+    name: string;
+    title: string;
+    abstract: string;
+    legendURL: string;
+}[];

package/dist/src/lib/edr-layer-api/colormaps/index.d.ts

@@ -0,0 +1,2 @@
+export * from './colormaps';
+export * from './edrOlLegendUtils';

package/dist/src/lib/edr-layer-api/fakeApi.d.ts

@@ -0,0 +1 @@
+export declare const fakeEdrLayerApiHandlers: import("msw").HttpHandler[];

package/dist/src/lib/edr-layer-api/hooks.d.ts

@@ -0,0 +1,14 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import type { EDRInstance } from '@opengeoweb/shared';
+export declare const webmapEDRQueryOptions: {
+    readonly getCollectionDetailsQuery: (edrBaseUrlWithCollection: string, enabled: boolean, instanceId?: string) => import("@tanstack/query-core").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<EDRInstance, Error, EDRInstance, string[]>, "queryFn"> & {
+        queryFn?: import("@tanstack/query-core").QueryFunction<EDRInstance, string[], never> | undefined;
+    } & {
+        queryKey: string[] & {
+            [dataTagSymbol]: EDRInstance;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+};
+export declare const useEDRGetCollectionDetails: (edrBaseUrlWithCollection: string, instanceId?: string, enabled?: boolean) => UseQueryResult<EDRInstance>;
+export declare const useEDRGetParameterData: (edrBaseUrlWithCollection: string, parameterName: string, datetime?: string, instanceId?: string) => UseQueryResult<GeoJSON.FeatureCollection | undefined>;

package/dist/src/lib/edr-layer-api/index.d.ts

@@ -0,0 +1,3 @@
+export * from './hooks';
+export * from './colormaps';
+export { useEDRWMLayer } from './utils/useEDRWMLayer';

package/dist/src/lib/edr-layer-api/utils/coverageCollectionToFeatureCollection.d.ts

@@ -0,0 +1,2 @@
+import type { Coverage, CoverageCollection, PointDomain, PointSeriesDomain } from '@opengeoweb/shared';
+export declare const coverageCollectionToFeatureCollection: (cov: CoverageCollection<PointDomain | PointSeriesDomain> | Coverage<PointDomain | PointSeriesDomain> | undefined, parameterNames: string) => GeoJSON.FeatureCollection;

package/dist/src/lib/edr-layer-api/utils/useEDRWMLayer.d.ts

@@ -0,0 +1,11 @@
+import { WMLayer } from '@opengeoweb/webmap';
+import type { OnInitializeLayerProps } from '../../components/OpenLayers/utils/types';
+/**
+ * Returns WMLayer instance in EDR mode. The layer will contains parsed dimensions and styles and keeps a state for these properties.
+ *
+ * @param {string} serviceUrl
+ * @param {string} name
+ * @returns {(WMLayer | null)}
+ */
+export declare const useCreateEDRWMLayer: (serviceUrl: string, name: string, id?: string, onLayerError?: (layerId: string, message: string) => void) => WMLayer | null;
+export declare const useEDRWMLayer: (edrBaseUrl: string, parameter: string, layerId?: string, onInitializeLayer?: (payload: OnInitializeLayerProps) => void) => WMLayer | null;

package/dist/src/lib/geotiff-layer-api/api.d.ts

@@ -0,0 +1,92 @@
+import type { Geometry } from 'geojson';
+import type { LayerProps } from '@opengeoweb/webmap';
+interface Properties {
+    datetime: string | null;
+    'proj:wkt2'?: string;
+}
+interface STACAsset {
+    href: string;
+    type: string;
+    created: string;
+}
+export interface STACExtent {
+    spatial?: {
+        bbox?: number[][];
+    };
+    temporal?: {
+        interval?: (string | null)[][];
+    };
+}
+export interface STACLink {
+    href: string;
+    rel: string;
+}
+export interface STACItem {
+    type: 'Feature';
+    stac_version: string;
+    id: string;
+    geometry: Geometry | null;
+    bbox: number[];
+    properties: Properties;
+    links: STACLink[];
+    assets: Record<string, STACAsset>;
+}
+export type STACColormapEntry = [number, number, number, number];
+export interface STACRenderEntry {
+    title?: string;
+    assets: string[];
+    rescale?: number[][];
+    colormap?: Record<string, STACColormapEntry>;
+}
+export interface STACCollection {
+    type: 'Collection';
+    stac_version: string;
+    id: string;
+    description: string;
+    license: string;
+    keywords?: string[];
+    properties?: Record<string, unknown>;
+    extent: STACExtent;
+    links: STACLink[];
+    features: STACItem[];
+    renders?: Record<string, STACRenderEntry>;
+}
+export declare const STAC_ITEM_PAGE_LIMIT = 1000;
+export declare const STAC_TEMPORAL_STEP_SAMPLE_LIMIT = 11;
+export declare const getStacItemsUrl: (stacBaseUrlWithCollection: string, startDate?: string, endDate?: string) => string;
+export declare const fetchStacCollection: (stacBaseUrlWithCollection: string) => Promise<STACCollection>;
+export declare const fetchStacItem: (stacItemUrl: string) => Promise<STACItem>;
+export declare const fetchStacItems: (collectionUrl: string) => Promise<STACItem[]>;
+export declare const fetchStacItemsPage: (baseUrl: string, itemLimit?: number, offset?: number) => Promise<STACItem[]>;
+/**
+ * Fetches STAC items with pagination support to handle cases where results exceed limit.
+ * Uses STAC next links when available, otherwise falls back to offset pagination
+ * until a page returns fewer items than the limit.
+ *
+ * @param baseUrl - Base URL with collection and query params (without offset/limit)
+ * @param itemLimit - Max items per page (default: 1000)
+ * @returns Array of all fetched STAC items
+ */
+export declare const fetchStacItemsWithPagination: (baseUrl: string, itemLimit?: number) => Promise<STACItem[]>;
+export interface STACCatalogCollection {
+    id: string;
+    title?: string;
+    description?: string;
+    extent?: STACExtent;
+    keywords?: string[];
+    links: STACLink[];
+    renders?: Record<string, STACRenderEntry>;
+}
+export interface STACCatalogRoot {
+    type?: string;
+    stac_version?: string;
+    id?: string;
+    title?: string;
+    description?: string;
+    links: STACLink[];
+    conformsTo?: string[];
+}
+export declare const fetchStacCatalogRoot: (url: string) => Promise<STACCatalogRoot>;
+export declare const fetchStacCatalogCollections: (baseUrl: string) => Promise<STACCatalogCollection[]>;
+export declare const stacCatalogCollectionToLayerProps: (collection: STACCatalogCollection) => LayerProps;
+export {};

package/dist/src/lib/geotiff-layer-api/fakeApi.d.ts

@@ -0,0 +1 @@
+export declare const fakeStacApiHandlers: import("msw").HttpHandler[];

package/dist/src/lib/geotiff-layer-api/hooks.d.ts

@@ -0,0 +1,5 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import type { STACCollection, STACItem } from './api';
+export declare const useStacCollection: (stacBaseUrlWithCollection: string, instanceId?: string, enabled?: boolean) => UseQueryResult<STACCollection, Error>;
+export declare const useStacItems: (stacBaseUrlWithCollection: string, startDate?: string, endDate?: string) => UseQueryResult<STACItem[], Error>;
+export declare const useStacTemporalStepItems: (stacBaseUrlWithCollection: string, startDate?: string, endDate?: string, enabled?: boolean) => UseQueryResult<STACItem[], Error>;

package/dist/src/lib/geotiff-layer-api/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './hooks';
+export * from './utils/stacColormapToOlStyle';

package/dist/src/lib/geotiff-layer-api/utils/stacColormapToOlStyle.d.ts

@@ -0,0 +1,25 @@
+import type { Style } from '@opengeoweb/webmap';
+import type { STACColormapEntry, STACRenderEntry } from '../api';
+/**
+ * Converts a STAC render extension colormap to an OpenLayers WebGLTile palette style.
+ *
+ * The STAC colormap maps pixel values (0–255) to RGBA arrays where each channel is 0–255.
+ * The returned object is suitable for use as the `style` option of `ol/layer/WebGLTile`.
+ */
+export declare const stacColormapToOlStyle: (colormap: Record<string, STACColormapEntry>) => object;
+/**
+ * Returns a grayscale WebGLTile style where band-1 value maps from black (0)
+ * to white (255). Used as a safe default when no STAC render colormap exists.
+ */
+export declare const stacGrayscaleOlStyle: () => object;
+/**
+ * Returns a grayscale style for normalized GeoTIFF samples where `['band', 1]`
+ * is expected in [0, 1]. This avoids white-only output when raw data range is
+ * not strictly 0-255.
+ */
+export declare const stacNormalizedGrayscaleOlStyle: () => object;
+/**
+ * Converts a STAC render extension `renders` map to an array of `Style` objects
+ * compatible with the Layer Manager style selector.
+ */
+export declare const getRendersAsStyles: (renders: Record<string, STACRenderEntry>) => Style[];

package/dist/src/lib/geotiff-layer-api/utils/stacTimeStepUtils.d.ts

@@ -0,0 +1,18 @@
+import type { STACCollection, STACItem } from '../api';
+/**
+ * Infers the temporal step (time resolution) from STAC collection metadata and items.
+ * Attempts multiple strategies:
+ * 1. Look for 'temporal-resolution' in collection properties
+ * 2. Calculate from actual item timestamps
+ * 3. Fall back to PT1H if unable to determine
+ *
+ * @param collection - STAC collection with metadata and items
+ * @returns ISO 8601 duration string (e.g., 'PT5M', 'PT1H', 'P1D')
+ */
+export declare const inferTemporalStep: (collection: STACCollection | undefined, items?: STACItem[]) => string;
+/**
+ * Converts milliseconds to ISO 8601 duration string
+ * @param ms - Duration in milliseconds
+ * @returns ISO 8601 duration string
+ */
+export declare const millisecondsToISO8601Duration: (ms: number) => string;