@opengeoweb/webmap-react 19.0.0 → 19.1.1

package/dist/src/lib/components/OpenLayers/draw/storyComponents/GeoJSONTextField.d.ts

@@ -0,0 +1,11 @@
+import type { SxProps } from '@mui/material';
+import React from 'react';
+interface GeoJSONTextFieldProps {
+    geoJSON: GeoJSON.FeatureCollection;
+    onChangeGeoJSON?: (geoJSON: GeoJSON.FeatureCollection) => void;
+    title?: string;
+    sx?: SxProps;
+    maxRows?: number;
+}
+declare const GeoJSONTextField: React.FC<GeoJSONTextFieldProps>;
+export default GeoJSONTextField;

package/dist/src/lib/components/OpenLayers/draw/storyComponents/IntersectionSelect.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+interface IntersectionElement {
+    geojson: GeoJSON.FeatureCollection;
+    title: string;
+}
+interface IntersectionSelectProps {
+    intersections: IntersectionElement[];
+    onChangeIntersection: (geojson: GeoJSON.FeatureCollection, title: string) => void;
+    isDisabled?: boolean;
+}
+export declare const IntersectionSelect: React.FC<IntersectionSelectProps>;
+export default IntersectionSelect;

package/dist/src/lib/components/OpenLayers/draw/storyComponents/SelectField.d.ts

@@ -0,0 +1,9 @@
+export declare const SelectField: React.FC<{
+    label: string;
+    value: string;
+    onChangeValue: (value: string) => void;
+    options: string[];
+    width?: string;
+    showValueAsColor?: boolean;
+    labelSuffix?: string;
+}>;

package/dist/src/lib/components/OpenLayers/draw/storyComponents/StoryLayout.d.ts

@@ -0,0 +1,9 @@
+import type { DrawModeExitCallback } from '../..';
+import type { OpenLayersLayerProps } from '../../layers';
+interface StoryLayoutProps {
+    layers: OpenLayersLayerProps[];
+    children: React.ReactElement;
+    onExitDrawMode: (reason: DrawModeExitCallback) => void;
+}
+export declare const StoryLayout: React.FC<StoryLayoutProps>;
+export default StoryLayout;

package/dist/src/lib/components/OpenLayers/draw/storyComponents/StoryLayoutGrid.d.ts

@@ -0,0 +1,4 @@
+export declare const StoryLayoutGrid: React.FC<{
+    children: React.ReactNode;
+    mapComponent: React.ReactNode;
+}>;

package/dist/src/lib/components/OpenLayers/draw/storyComponents/ToolButton.d.ts

@@ -0,0 +1,9 @@
+import type { DrawMode } from '..';
+interface ToolButtonProps {
+    mode: DrawMode;
+    isSelected: boolean;
+    onClick: () => void;
+    icon: React.ReactElement;
+}
+export declare const ToolButton: React.FC<ToolButtonProps>;
+export default ToolButton;

package/dist/src/lib/components/OpenLayers/draw/storyComponents/geojsonExamples.d.ts

@@ -0,0 +1,12 @@
+export declare const simplePolygonGeoJSON: GeoJSON.FeatureCollection<GeoJSON.Polygon>;
+export declare const simplePointsGeojson: GeoJSON.FeatureCollection<GeoJSON.Point>;
+export declare const simpleSmallLineStringGeoJSON: GeoJSON.FeatureCollection<GeoJSON.LineString>;
+export declare const simpleFlightRoutePointsGeoJSON: GeoJSON.FeatureCollection<GeoJSON.Point>;
+export declare const simpleLineStringGeoJSON: GeoJSON.FeatureCollection<GeoJSON.LineString>;
+export declare const simpleBoxGeoJSON: GeoJSON.FeatureCollection<GeoJSON.Polygon>;
+export declare const simpleBoxGeoJSONWrongOrder: GeoJSON.FeatureCollection<GeoJSON.Polygon>;
+export declare const simpleFlightRouteLineStringGeoJSON: GeoJSON.FeatureCollection<GeoJSON.LineString>;
+export declare const simpleMultiPolygon: GeoJSON.FeatureCollection<GeoJSON.MultiPolygon>;
+export declare const intersectionFeatureNL: GeoJSON.Feature<GeoJSON.Polygon>;
+export declare const intersectionFeatureBE: GeoJSON.Feature<GeoJSON.Polygon>;
+export declare const simpleGeometryCollectionGeoJSON: GeoJSON.FeatureCollection<GeoJSON.GeometryCollection<GeoJSON.MultiPolygon>>;

package/dist/src/lib/components/OpenLayers/draw/storyComponents/index.d.ts

@@ -0,0 +1,8 @@
+export { default as GeoJSONTextField } from './GeoJSONTextField';
+export { default as FeatureLayers } from './FeatureLayers';
+export { default as EditModeButtonField } from './EditModeButton';
+export * from './geojsonExamples';
+export * from './storyUtils';
+export * from './StoryLayoutGrid';
+export * from './SelectField';
+export * from './IntersectionSelect';

package/dist/src/lib/components/OpenLayers/draw/storyComponents/storyUtils.d.ts

@@ -0,0 +1,48 @@
+export declare const drawPolyStoryStyles: {
+    MapDrawGeoJSONContainer: {
+        display: string;
+        gridTemplateColumns: string;
+        gridTemplateRows: string;
+        gridTemplateAreas: string;
+        width: string;
+        height: string;
+    };
+    MapDrawGeoJSONMapContainer: {
+        gridArea: string;
+        width: string;
+        height: string;
+    };
+    MapDrawGeoJSONControlsContainer: {
+        gridArea: string;
+        width: string;
+        height: string;
+    };
+    MapDrawGeoJSONTextAreaContainer: {
+        gridArea: string;
+        width: string;
+        height: string;
+    };
+    MapDrawGeoJSONTextArea: {
+        padding: number;
+        border: string;
+        width: string;
+        height: string;
+        fontSize: string;
+    };
+};
+export declare const useGeoJSON: () => {
+    editModes: {
+        key: string;
+        value: string;
+    }[];
+    isInEditMode: boolean;
+    geojson: GeoJSON.FeatureCollection;
+    setGeojson: (geojson: GeoJSON.FeatureCollection) => void;
+    geojsonText: string;
+    setGeojsonText: (text: string) => void;
+    drawMode: string;
+    currentFeatureNrToEdit: number;
+    setCurrentFeatureNrToEdit: (featureNumber: number) => void;
+    changeDrawMode: (mode: string) => void;
+    setEditMode: (on: boolean) => void;
+};

package/dist/src/lib/components/OpenLayers/draw/storyExamplesMapDrawTool.d.ts

@@ -0,0 +1,9 @@
+import type { SelectionType } from './types';
+import type { MapDrawToolOptions } from './useMapDrawTool';
+export declare const opacityOptions: string[];
+export declare const fillOptions: any[];
+export declare const strokeWidthOptions: string[];
+export declare const getToolIcon: (selectionType: SelectionType) => React.ReactElement;
+export declare const basicExampleDrawOptions: MapDrawToolOptions;
+export declare const basicExampleMultipleShapeDrawOptions: MapDrawToolOptions;
+export declare const basicExampleMultipleShapeWithValuesDrawOptions: MapDrawToolOptions;

package/dist/src/lib/components/OpenLayers/draw/storyExamplesMapDrawToolIntersection.d.ts

@@ -0,0 +1,9 @@
+import type { SelectionType } from './types';
+import type { MapDrawToolOptions } from './useMapDrawTool';
+export declare const getIntersectionToolIcon: (selectionType: SelectionType) => React.ReactElement;
+export declare const exampleIntersections: {
+    title: string;
+    geojson: import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties>;
+}[];
+export declare const exampleIntersectionOptions: MapDrawToolOptions;
+export declare const exampleIntersectionWithShapeOptions: MapDrawToolOptions;

package/dist/src/lib/components/OpenLayers/draw/storyExamplesMapDrawToolMultipleDrawTools.d.ts

@@ -0,0 +1,12 @@
+import type { DrawMode } from './types';
+import type { MapDrawToolOptions } from './useMapDrawTool';
+export declare const firSelectionType = "fir";
+export declare const exampleIntersectionsMultiDrawTool: {
+    title: string;
+    geojson: GeoJSON.FeatureCollection;
+}[];
+export declare const getDoubleControlToolIcon: (drawMode: DrawMode) => React.ReactElement;
+export declare const getFirTitle: (isNL: boolean) => string;
+export declare const updateEditModeButtonsWithFir: (drawModes: DrawMode[], newFirGeoJSON: GeoJSON.FeatureCollection) => DrawMode[];
+export declare const startToolExampleConfig: MapDrawToolOptions;
+export declare const endToolExampleConfig: MapDrawToolOptions;

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

@@ -0,0 +1,43 @@
+import type { Feature, Polygon, MultiPolygon } from 'geojson';
+export declare enum DRAWMODE {
+    POLYGON = "POLYGON",
+    BOX = "BOX",
+    MULTIPOINT = "MULTIPOINT",
+    POINT = "POINT",
+    LINESTRING = "LINESTRING",
+    SMOOTHLINE = "SMOOTHLINE",
+    CIRCLE = "CIRCLE",
+    SQUARE = "SQUARE",
+    OVAL = "OVAL",
+    LOCATION = "LOCATION",
+    FREEHANDLINE = "FREEHANDLINE",
+    SPLIT = "SPLIT",
+    ROTATABLEBOX = "ROTATABLEBOX"
+}
+export interface FeatureEvent {
+    coordinateIndexInFeature: number;
+    featureIndex: number;
+    screenCoords: {
+        x: number;
+        y: number;
+    };
+    mouseX: number;
+    mouseY: number;
+    isInEditMode: boolean;
+    feature: GeoJSON.Feature;
+}
+export type DrawModeExitCallback = 'escaped' | 'completed' | 'doubleClicked' | 'clickedNearStartingPoint';
+export type DrawModeValue = DRAWMODE | 'DELETE' | '';
+type DefaultSelectionTypes = 'poly' | 'point' | 'box' | 'linestring';
+export type SelectionType = DefaultSelectionTypes | string;
+export interface DrawMode {
+    drawModeId: string;
+    value: DrawModeValue;
+    shape: GeoJSON.Feature | GeoJSON.FeatureCollection;
+    title: string;
+    isSelectable: boolean;
+    selectionType: SelectionType;
+}
+export type ProjectFn = (feat: Feature<Polygon | MultiPolygon>) => Feature<Polygon | MultiPolygon>;
+export type UnprojectFn = (feat: Feature<Polygon | MultiPolygon>) => Feature<Polygon | MultiPolygon>;
+export {};

package/dist/src/lib/components/OpenLayers/draw/useMapDrawTool.d.ts

@@ -0,0 +1,61 @@
+import React from 'react';
+import type { DrawMode, DrawModeValue, SelectionType } from './types';
+import type { OpenLayersLayerProps } from '../layers';
+export declare const defaultIntersectionStyleProperties: GeoJSON.GeoJsonProperties;
+export declare const emptyLineString: GeoJSON.Feature;
+export declare const emptyPoint: GeoJSON.Feature;
+export declare const emptyPolygon: GeoJSON.Feature;
+export declare const emptyIntersectionShape: GeoJSON.FeatureCollection;
+type DrawLayerType = 'geoJSON' | 'geoJSONIntersection' | 'geoJSONIntersectionBounds';
+export interface MapDrawToolProps {
+    geoJSON: GeoJSON.FeatureCollection;
+    geoJSONIntersection?: GeoJSON.FeatureCollection;
+    geoJSONIntersectionBounds?: GeoJSON.FeatureCollection;
+    setGeoJSON: (geojson: GeoJSON.Feature | GeoJSON.FeatureCollection, reason?: string) => GeoJSON.FeatureCollection[];
+    setGeoJSONIntersectionBounds: (geojson: GeoJSON.FeatureCollection) => void;
+    drawModes: DrawMode[];
+    changeDrawMode: (mode: DrawModeValue) => void;
+    setDrawModes: (drawModes: DrawMode[]) => void;
+    isInEditMode: boolean;
+    setEditMode: (shouldEnable: boolean) => void;
+    featureLayerIndex: number;
+    setFeatureLayerIndex: (newIndex: number) => void;
+    activeTool: string;
+    changeActiveTool: (newMode: DrawMode) => void;
+    setActiveTool: (newToolId: string) => void;
+    layers: OpenLayersLayerProps[];
+    getLayer: (layerType: DrawLayerType, layerId: string) => OpenLayersLayerProps;
+    deactivateTool: () => void;
+    changeProperties: (geoJSONProperties: GeoJSON.GeoJsonProperties) => void;
+    getProperties: () => GeoJSON.GeoJsonProperties;
+}
+export interface MapDrawToolOptions {
+    shouldAllowMultipleShapes?: boolean;
+    defaultDrawModes?: DrawMode[];
+    defaultGeoJSON?: GeoJSON.FeatureCollection;
+    defaultGeoJSONIntersection?: GeoJSON.FeatureCollection;
+    defaultGeoJSONIntersectionBounds?: GeoJSON.FeatureCollection;
+    defaultGeoJSONIntersectionProperties?: GeoJSON.GeoJsonProperties;
+    geoJSONLayerId?: string;
+    geoJSONIntersectionLayerId?: string;
+    geoJSONIntersectionBoundsLayerId?: string;
+    projection?: string | undefined;
+}
+export declare const getIcon: (selectionType: SelectionType) => React.ReactElement | null;
+export declare const defaultPoint: DrawMode;
+export declare const defaultPolygon: DrawMode;
+export declare const defaultBox: DrawMode;
+export declare const defaultLineString: DrawMode;
+export declare const defaultDelete: DrawMode;
+export declare const defaultCircle: DrawMode;
+export declare const defaultSquare: DrawMode;
+export declare const defaultFreehandLine: DrawMode;
+export declare const defaultOval: DrawMode;
+export declare const defaultLocation: DrawMode;
+export declare const defaultSmoothLine: DrawMode;
+export declare const defaultSplit: DrawMode;
+export declare const defaultRotatableBox: DrawMode;
+export declare const defaultModes: DrawMode[];
+export declare const currentlySupportedDrawModes: DrawMode[];
+export declare const useMapDrawTool: ({ defaultDrawModes, shouldAllowMultipleShapes, defaultGeoJSON, defaultGeoJSONIntersection, defaultGeoJSONIntersectionBounds, defaultGeoJSONIntersectionProperties, geoJSONLayerId, geoJSONIntersectionLayerId, geoJSONIntersectionBoundsLayerId, projection, }: MapDrawToolOptions) => MapDrawToolProps;
+export {};

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

@@ -0,0 +1,84 @@
+import type { FeatureCollection, GeoJsonProperties, Point, Geometry } from 'geojson';
+import type { Bbox } from '@opengeoweb/webmap';
+import type { DrawMode, SelectionType } from './types';
+/**
+ * Adds properties to the first geojson feature based on the given property object.
+ * It only extends or changes the properties which are defined in styleConfig,
+ * all other properties in the geojson are left unchanged.
+ * @param geojson
+ * @param featureProperties
+ */
+export declare const addFeatureProperties: (geojson: GeoJSON.FeatureCollection | undefined, featureProperties: GeoJSON.GeoJsonProperties, featureIndex?: number) => GeoJSON.FeatureCollection;
+/**
+ * Matches OpenLayers' default `Draw.clickTolerance`. A pointer that moves
+ * further than this between mousedown and mouseup is treated as a drag.
+ */
+export declare const POINTER_CLICK_TOLERANCE_PX = 6;
+/**
+ * Returns true if a `click` event actually came from a drag — i.e. the pointer
+ * moved further than the click tolerance between mousedown and mouseup (e.g.
+ * the user pressed, panned the map, then released).
+ *
+ * Used to prevent panning the map mid-draw from accidentally closing the
+ * polygon: the browser still fires a `click` after a drag, and without this
+ * check it could trigger the close-on-near-start handler.
+ */
+export declare const isClickFromDrag: (event: MouseEvent, pointerDownPx: [number, number] | null) => boolean;
+/**
+ * Checks if the geometry of the feature is empty as defined per GeoJSON spec.
+ * According to the specification, an empty geometry is type 'Polygon' and coordinates
+ * equal [[]]. Also GeoWeb uses empty linestring and poit geometries (coordinates [])
+ * which are supported as well.
+ *
+ * @param feature Feature to test
+ * @returns Whether `feature` is empty or not
+ */
+export declare const isGeoJSONGeometryEmpty: (feature: GeoJSON.Feature) => boolean;
+export declare const getGeoJSONPropertyValue: (property: string, properties: GeoJSON.GeoJsonProperties, polygonDrawMode: DrawMode | undefined, defaultProperties?: GeoJSON.GeoJsonProperties) => number | string;
+/**
+ * moves geoJSON feature as new feature. Mutates newGeoJSON
+ * @constructor
+ * @param {GeoJSON.FeatureCollection} currentGeoJSON - current geoJSON
+ * @param {GeoJSON.FeatureCollection} newGeoJSON - new geoJSON
+ * @param {number} featureLayerIndex - feature layer index
+ * @param {string} text - reason of change
+ */
+export declare const moveFeature: (currentGeoJSON: GeoJSON.FeatureCollection | undefined, newGeoJSON: GeoJSON.FeatureCollection, featureLayerIndex: number, reason: string, selectionType?: string) => number | undefined;
+/**
+ * Returns the intersection of two point features. In case of a polygon, only the first feature is used.
+ * @param intersectA Feature A
+ * @param intersectB Feature B
+ * @returns The intersection of the two features.
+ */
+export declare const intersectPointGeoJSONS: (intersectA: GeoJSON.FeatureCollection<GeoJSON.Point>, intersectB: GeoJSON.FeatureCollection, geoJSONProperties?: {
+    stroke: string;
+    'stroke-width': number;
+    'stroke-opacity': number;
+    fill: string;
+    'fill-opacity': number;
+}) => GeoJSON.FeatureCollection;
+/**
+ * Returns the intersection of two (multi) polygon features. In case of a polygon, only the first feature is used.
+ * @param intersectA Feature A
+ * @param intersectB Feature B
+ * @returns The intersection of the two features.
+ */
+export declare function intersectPolygonGeoJSONS(intersectA: FeatureCollection<Geometry, GeoJsonProperties>, // drawn polygon (WGS84)
+intersectB: FeatureCollection<Geometry, GeoJsonProperties>, // FIR polygon (WGS84)
+geoJSONProperties?: GeoJsonProperties, projectionCode?: string): FeatureCollection<Geometry, GeoJsonProperties>;
+export declare const isPointFeatureCollection: (geojson: GeoJSON.FeatureCollection) => geojson is GeoJSON.FeatureCollection<Point>;
+/**
+ * Adds the intersectionStart and intersectionEnd properties to the GeoJSONS structure
+ * @param geoJSONs
+ * @returns GeoJSONS extend with intersections
+ */
+export declare const createInterSections: (geojson: GeoJSON.FeatureCollection, otherGeoJSON: GeoJSON.FeatureCollection, geoJSONproperties?: GeoJSON.GeoJsonProperties, proj?: string) => GeoJSON.FeatureCollection;
+export declare const getGeoJson: (geojson: GeoJSON.FeatureCollection, shouldAllowMultipleShapes: boolean) => GeoJSON.FeatureCollection;
+export declare const getLastEmptyFeatureIndex: (geoJSONFeatureCollection: GeoJSON.FeatureCollection) => number | undefined;
+export declare const getFeatureCollection: (geoJSONFeature: GeoJSON.Feature | GeoJSON.FeatureCollection, shouldAllowMultipleShapes: boolean, geoJSONFeatureCollection?: GeoJSON.FeatureCollection) => GeoJSON.FeatureCollection;
+export declare const isGeoJSONFeatureCreatedByTool: (existingJSON: GeoJSON.FeatureCollection, selectionType: SelectionType, featureLayerIndex?: number) => boolean;
+export declare const rewindGeometry: (geoJSON: FeatureCollection) => FeatureCollection;
+export declare const addGeoJSONProperties: (geoJSON: GeoJSON.Feature | GeoJSON.FeatureCollection, newProperties: GeoJsonProperties) => GeoJSON.Feature | GeoJSON.FeatureCollection;
+export declare const addSelectionTypeToGeoJSON: (geoJSON: GeoJSON.Feature | GeoJSON.FeatureCollection, selectionType: SelectionType) => GeoJSON.Feature | GeoJSON.FeatureCollection;
+export declare const getFeatureExtent: (geoJSON: GeoJSON.Feature | GeoJSON.FeatureCollection) => Bbox;
+export declare const getDrawModeIdFromSelectionType: (selectionType: string, drawModes: DrawMode[]) => string;

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

@@ -0,0 +1,14 @@
+export { default as MapContext } from './context/MapContext';
+export * from './component/OpenLayersMapView';
+export * from './utils/TimeAwareImageWrapper';
+export type * from './utils/types';
+export * from './utils/projections';
+export * from './utils/setMapCenter';
+export * from './utils/viewUtils';
+export * from './controls';
+export * from './draw';
+export * from './styles/useIconStyle';
+export * from './OlStyles';
+export * from './OlColors';
+export * from './tools';
+export * from './layers';

package/dist/src/lib/components/OpenLayers/layers/DefaultBaseLayers.d.ts

@@ -0,0 +1,9 @@
+export declare enum BaseLayerType {
+    LIGHT_GREY_CANVAS = 0,
+    WORLD_TOPO = 1
+}
+interface DefaultBaseLayersOptions {
+    type?: BaseLayerType;
+}
+export declare const DefaultBaseLayers: React.FC<DefaultBaseLayersOptions>;
+export {};

package/dist/src/lib/components/OpenLayers/layers/FeatureLayer.d.ts

@@ -0,0 +1,16 @@
+import type { Feature } from 'ol';
+import type { StyleLike } from 'ol/style/Style';
+import type { BoxSelect, ClickOnFeature, HoverSelect } from '../utils/types';
+export interface FeatureLayerProps {
+    features: Feature[];
+    style: StyleLike;
+    zIndex?: number;
+    hoverSelect?: HoverSelect;
+    clickOnFeature?: ClickOnFeature;
+    boxSelect?: BoxSelect;
+    testId?: string;
+    opacity?: number;
+    declutter?: boolean;
+    visible?: boolean;
+}
+export declare const FeatureLayer: React.FC<FeatureLayerProps>;

package/dist/src/lib/components/OpenLayers/layers/GeoTIFFLayer.d.ts

@@ -0,0 +1,13 @@
+import type ImageLayer from 'ol/layer/Image';
+import type { LayerFoundation } from '@opengeoweb/webmap';
+export interface TiledWMSLayerProps {
+    url: string;
+    layerName: string;
+    layerOptions: ConstructorParameters<typeof ImageLayer>[0];
+    layerProps?: LayerFoundation;
+    projection?: string;
+    shouldRender?: boolean;
+    geotiffStyle?: object;
+    normalize?: boolean;
+}
+export declare const GeoTIFFLayer: React.FC<TiledWMSLayerProps>;

package/dist/src/lib/components/OpenLayers/layers/OpenLayersFeatureLayer.d.ts

@@ -0,0 +1,16 @@
+import type { FeatureCollection } from 'geojson';
+import type { StyleLike } from 'ol/style/Style';
+import type { BoxSelect, ClickOnFeature, HoverSelect } from '../utils/types';
+export interface OpenLayersFeatureLayerProps {
+    featureCollection?: FeatureCollection;
+    style?: StyleLike;
+    zIndex?: number;
+    hoverSelect?: HoverSelect;
+    clickOnFeature?: ClickOnFeature;
+    boxSelect?: BoxSelect;
+    testId?: string;
+    opacity?: number;
+    declutter?: boolean;
+    visible?: boolean;
+}
+export declare const OpenLayersFeatureLayer: React.FC<OpenLayersFeatureLayerProps>;

package/dist/src/lib/components/OpenLayers/layers/OpenLayersLayer.d.ts

@@ -0,0 +1,20 @@
+import type { LayerFoundation, TileServerSettings } from '@opengeoweb/webmap';
+import type { DrawModeExitCallback, FeatureEvent } from '../draw/types';
+import type { OnInitializeLayerProps } from '../utils/types';
+export interface OpenLayersLayerProps extends LayerFoundation {
+    zIndex?: number;
+    onInitializeLayer?: (payload: OnInitializeLayerProps) => void;
+    onLayerReady?: (layerId: string) => void;
+    onLayerError?: (layerId: string, message: string) => void;
+    debugMode?: boolean;
+    id: string;
+    isInEditMode?: boolean;
+    drawMode?: string;
+    updateGeojson?: (geoJson: GeoJSON.FeatureCollection, reason: string) => void;
+    exitDrawModeCallback?: (reason: DrawModeExitCallback) => void;
+    selectedFeatureIndex?: number;
+    onClickFeature?: (event?: FeatureEvent) => void;
+    onHoverFeature?: (event: FeatureEvent) => void;
+    tileServerSettings?: TileServerSettings;
+}
+export declare const OpenLayersLayer: (layerProps: OpenLayersLayerProps) => React.ReactElement | null;

package/dist/src/lib/components/OpenLayers/layers/TiledWMSLayer.d.ts

@@ -0,0 +1,10 @@
+import type ImageLayer from 'ol/layer/Image';
+import type { LayerFoundation } from '@opengeoweb/webmap';
+export interface TiledWMSLayerProps {
+    url: string;
+    layerName: string;
+    styleName: string;
+    layerOptions: ConstructorParameters<typeof ImageLayer>[0];
+    layerProps?: LayerFoundation;
+}
+export declare const TiledWMSLayer: React.FC<TiledWMSLayerProps>;

package/dist/src/lib/components/OpenLayers/layers/TimeAwareEDRLocationLayer.d.ts

@@ -0,0 +1,14 @@
+import type { Dimension } from '@opengeoweb/webmap';
+import type { OpenLayersFeatureLayerProps } from './OpenLayersFeatureLayer';
+import type { OnInitializeLayerProps } from '../utils/types';
+interface TimeAwareEDRLocationLayerProps extends OpenLayersFeatureLayerProps {
+    layerId?: string;
+    edrBaseUrl: string;
+    parameter: string;
+    dimensions?: Dimension[];
+    onInitializeLayer?: (payload: OnInitializeLayerProps) => void;
+    opacity?: number;
+    visible?: boolean;
+}
+export declare const TimeAwareEDRLocationLayer: React.FC<TimeAwareEDRLocationLayerProps>;
+export {};

package/dist/src/lib/components/OpenLayers/layers/TimeAwareGeoTIFFLayer.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { Dimension } from '@opengeoweb/webmap';
+import type { OpenLayersFeatureLayerProps } from './OpenLayersFeatureLayer';
+import { getStacFrameItemsToRender, getStacItemLookupWindowForTimes } from './TimeAwareGeoTIFFLayerUtils';
+import type { OnInitializeLayerProps } from '../utils/types';
+export { getStacFrameItemsToRender, getStacItemLookupWindowForTimes };
+interface TimeAwareGeoTIFFLayerProps extends OpenLayersFeatureLayerProps {
+    layerId?: string;
+    stacCollectionUrl: string;
+    layerName: string;
+    styleName?: string;
+    dimensions?: Dimension[];
+    onInitializeLayer?: (payload: OnInitializeLayerProps) => void;
+    opacity?: number;
+    visible?: boolean;
+}
+export declare const TimeAwareGeoTIFFLayer: React.FC<TimeAwareGeoTIFFLayerProps>;

package/dist/src/lib/components/OpenLayers/layers/TimeAwareGeoTIFFLayerUtils.d.ts

@@ -0,0 +1,20 @@
+import type { TimeInterval } from '@opengeoweb/webmap';
+import type { STACItem } from '../../../geotiff-layer-api/api';
+export declare const STAC_ITEM_LOOKUP_WINDOW_MS: number;
+export declare const STAC_ITEM_LOOKUP_WINDOW_INTERVAL_MULTIPLIER = 20;
+export declare const STAC_GEOTIFF_FRAME_PRELOAD_RADIUS = 4;
+export interface STACFrameItem {
+    item: STACItem;
+    isSelected: boolean;
+}
+export type STACItemLookupWindow = [string | undefined, string | undefined];
+export declare const resolvePreferredStyleName: (styleNames: string[], currentStyle?: string) => string;
+export declare const getTimeIntervalInMilliseconds: (interval?: TimeInterval) => number | undefined;
+export declare const getStacItemLookupWindowForTimes: (timeValues: string[], windowMs?: number) => STACItemLookupWindow;
+export declare const isStacItemLookupWindowValidForTime: ([startDate, endDate]: STACItemLookupWindow, timeValue: string | undefined, requiredMarginMs: number) => boolean;
+export declare const getFrameStepInMilliseconds: (timeValue: string | undefined, prefetchList: number[], fallbackStepMs: number | undefined) => number | undefined;
+export declare const getLookupStepInMilliseconds: (frameStepMs: number | undefined, timeIntervalMs: number | undefined) => number | undefined;
+export declare const shouldPreloadStacFrames: (frameStepMs: number | undefined, timeIntervalMs: number | undefined) => boolean;
+export declare const getStacFrameTargetTimes: (timeValue: string | undefined, prefetchList: number[], fallbackStepMs: number | undefined, preloadRadius?: number) => number[];
+export declare const getRequiredLookupMarginInMilliseconds: (timeValue: string | undefined, frameTargetTimes: number[], fallbackMarginMs: number) => number;
+export declare const getStacFrameItemsToRender: (items: STACItem[] | undefined, timeValue?: string, frameTargetTimes?: number[]) => STACFrameItem[];

package/dist/src/lib/components/OpenLayers/layers/TimeAwareWMTSLayer.d.ts

@@ -0,0 +1,17 @@
+import TileLayer from 'ol/layer/Tile';
+import type { Dimension } from '@opengeoweb/webmap';
+import type { OnInitializeLayerProps } from '../utils/types';
+export interface TimeAwareWMTSLayerProps {
+    layerId?: string;
+    getCapsURL: string;
+    layerName: string;
+    styleName?: string;
+    layerOptions: ConstructorParameters<typeof TileLayer>[0];
+    dimensions?: Dimension[];
+    visible?: boolean;
+    onInitializeLayer?: (payload: OnInitializeLayerProps) => void;
+    onLayerReady?: (layerId: string) => void;
+    onLayerError?: (layerId: string, message: string) => void;
+    debugMode?: boolean;
+}
+export declare const TimeAwareWMTSLayer: React.FC<TimeAwareWMTSLayerProps>;

package/dist/src/lib/components/OpenLayers/layers/TimeawareImageSourceWMSLayer.d.ts

@@ -0,0 +1,18 @@
+import ImageLayer from 'ol/layer/Image';
+import type { Dimension } from '@opengeoweb/webmap';
+import type { OnInitializeLayerProps } from '../utils/types';
+interface TimeawareImageSourceWMSLayerProps {
+    layerId?: string;
+    getCapsURL: string;
+    layerName: string;
+    styleName?: string;
+    layerOptions: ConstructorParameters<typeof ImageLayer>[0];
+    dimensions?: Dimension[];
+    visible?: boolean;
+    onInitializeLayer?: (payload: OnInitializeLayerProps) => void;
+    onLayerReady?: (layerId: string) => void;
+    onLayerError?: (layerId: string, message: string) => void;
+    debugMode?: boolean;
+}
+export declare const TimeawareImageSourceWMSLayer: React.FC<TimeawareImageSourceWMSLayerProps>;
+export {};

package/dist/src/lib/components/OpenLayers/layers/WMSLayer.d.ts

@@ -0,0 +1,10 @@
+import ImageLayer from 'ol/layer/Image';
+import type { LayerFoundation } from '@opengeoweb/webmap';
+export interface WMSLayerProps {
+    url: string;
+    layerName: string;
+    styleName: string;
+    layerOptions: ConstructorParameters<typeof ImageLayer>[0];
+    layerProps?: LayerFoundation;
+}
+export declare const WMSLayer: React.FC<WMSLayerProps>;

package/dist/src/lib/components/OpenLayers/layers/WMTSLayer.d.ts

@@ -0,0 +1,10 @@
+import TileLayer from 'ol/layer/Tile';
+import type { LayerFoundation } from '@opengeoweb/webmap';
+export interface WMTSLayerProps {
+    getCapsURL: string;
+    layerName: string;
+    tileMatrixSet: string;
+    layerOptions: ConstructorParameters<typeof TileLayer>[0];
+    layerProps?: LayerFoundation;
+}
+export declare const WMTSLayer: React.FC<WMTSLayerProps>;

package/dist/src/lib/components/OpenLayers/layers/XYZLayer.d.ts

@@ -0,0 +1,9 @@
+import TileLayer from 'ol/layer/Tile';
+import type { LayerFoundation } from '@opengeoweb/webmap';
+export interface XYZLayerProps {
+    urlTemplate: string;
+    layerOptions: ConstructorParameters<typeof TileLayer>[0];
+    layerProps?: LayerFoundation;
+    tileProjectionCode?: string;
+}
+export declare const XYZLayer: React.FC<XYZLayerProps>;

package/dist/src/lib/components/OpenLayers/layers/fakeApiWmtsQueries.d.ts

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

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

@@ -0,0 +1,11 @@
+export * from './TimeawareImageSourceWMSLayer';
+export * from './WMSLayer';
+export * from './WMTSLayer';
+export * from './XYZLayer';
+export * from './DefaultBaseLayers';
+export * from './OpenLayersLayer';
+export * from './FeatureLayer';
+export * from './OpenLayersFeatureLayer';
+export * from './TimeAwareEDRLocationLayer';
+export * from './TimeAwareWMTSLayer';
+export * from './TimeAwareGeoTIFFLayer';

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

@@ -0,0 +1,2 @@
+import type { Dimension } from '@opengeoweb/webmap';
+export declare const WMTSDimensionsFromDimensions: (dimensions: Dimension[]) => Record<string, string>;

package/dist/src/lib/components/OpenLayers/storyComponents/OlStoryLayout.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { DrawModeExitCallback } from '../draw';
+import type { OpenLayersLayerProps } from '../layers';
+interface OlStoryLayoutProps {
+    layers: OpenLayersLayerProps[];
+    children: React.ReactElement;
+    onExitDrawMode: (reason: DrawModeExitCallback) => void;
+}
+export declare const OlStoryLayout: React.FC<OlStoryLayoutProps>;
+export {};

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

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