@opengeoweb/store 19.1.0 → 19.1.1

package/dist/src/store/map/layer/types.d.ts

@@ -0,0 +1,198 @@
+import type { Action } from '@reduxjs/toolkit';
+import type { FeatureCollection } from 'geojson';
+import type { LayerFoundation } from '@opengeoweb/webmap';
+import type { UpdateLayerInfoPayload } from '@opengeoweb/webmap-react';
+import type { SyncGroupActionOrigin } from '../../generic/syncGroups/types';
+import type { uiTypes } from '../../ui';
+import type { Dimension } from '../map/types';
+export declare enum LayerStatus {
+    default = "default",
+    error = "error"
+}
+export declare enum LayerActionOrigin {
+    layerManager = "layerManager",
+    wmsLoader = "WMSLayerTreeConnect",
+    ReactMapViewParseLayer = "ReactMapViewParseLayer",
+    updateLayerInformationListener = "updateLayerInformationListener",
+    toggleAutoUpdateListener = "toggleAutoUpdateListener",
+    unregisterMapListener = "unregisterMapListener",
+    dataExplorer = "dataExplorer",
+    legend = "legend",
+    featureSync = "featureSync"
+}
+export interface FeatureLayer {
+    geojson?: FeatureCollection;
+    originalId?: string;
+    defaultGeoJSONProperties?: GeoJSON.GeoJsonProperties;
+    selectedFeatureIds?: string[];
+    hoveredFeatureIds?: string[];
+    isInEditMode?: boolean;
+    drawMode?: string;
+    isSelectable?: boolean;
+}
+export interface FeatureSyncLayerMetadata {
+    sourcePanelId: string;
+    featureLayerKey: string;
+}
+/**
+ * ReduxLayer is used to reflect the shape of the layer in the redux layers store.
+ * It is a subset of Layer since some properties like the styles list now come from the service store.
+ */
+export interface ReduxLayer extends LayerFoundation, FeatureLayer {
+    dimensions?: Dimension[];
+    mapId?: string;
+    status?: LayerStatus;
+    useLatestReferenceTime?: boolean;
+    featureSync?: FeatureSyncLayerMetadata;
+}
+/**
+ * Layer is used to define a layer with all its possible properties.
+ */
+export interface Layer extends ReduxLayer {
+    headers?: Headers[];
+}
+export interface AvailableBaseLayersType {
+    byId: Record<string, ReduxLayer>;
+    allIds: string[];
+}
+export interface LayerState {
+    byId: Record<string, ReduxLayer>;
+    allIds: string[];
+    availableBaseLayers: AvailableBaseLayersType;
+    activeLayerInfo?: {
+        layerName: string;
+        serviceUrl: string;
+        style?: string;
+    };
+}
+export interface LayerPayload {
+    layerId: string;
+    origin?: string;
+}
+export interface SetLayersPayload {
+    mapId: string;
+    layers: ReduxLayer[];
+    origin?: string;
+}
+export interface SetBaseLayersPayload {
+    mapId: string;
+    layers: ReduxLayer[];
+    origin?: LayerActionOrigin | SyncGroupActionOrigin.layerActions;
+}
+export interface SetLayerOpacityPayload extends LayerPayload {
+    opacity: number;
+    mapId?: string;
+    origin?: LayerActionOrigin;
+}
+export interface SetLayerNamePayload extends LayerPayload {
+    name: string;
+    mapId?: string;
+    origin?: LayerActionOrigin;
+}
+export interface SetLayerServicePayload extends LayerPayload {
+    service: string;
+    mapId?: string;
+    origin?: LayerActionOrigin;
+}
+export interface SetLayerOptionsPayload extends LayerPayload {
+    options: LayerFoundation['options'];
+    mapId?: string;
+    origin?: LayerActionOrigin;
+}
+export interface SetLayerEnabledPayload extends LayerPayload {
+    enabled: boolean;
+    mapId?: string;
+    origin?: LayerActionOrigin;
+}
+export interface SetLayerDimensionPayload extends LayerPayload {
+    dimension: Dimension;
+    service?: string;
+    origin?: LayerActionOrigin;
+    mapId?: string;
+}
+export interface SetLayerGeojsonPayload extends LayerPayload {
+    geojson: FeatureCollection;
+}
+export interface SetLayerGeojsonFromLayerPayload extends LayerPayload {
+    sourceLayerId: string;
+}
+export interface DeleteLayerPayload extends LayerPayload {
+    mapId: string;
+    layerIndex?: number;
+    origin?: LayerActionOrigin | SyncGroupActionOrigin.delete;
+}
+export interface AddLayerPayload {
+    mapId: string;
+    layerId: string;
+    layer: Layer;
+    origin: string;
+}
+export interface DuplicateMapLayerPayload {
+    mapId: string;
+    oldLayerId: string;
+    newLayerId: string;
+    origin: string;
+}
+export interface AddBaseLayerPayload {
+    mapId: string;
+    layerId: string;
+    layer: Layer;
+    origin?: string;
+}
+export interface AddAvailableBaseLayerPayload {
+    layer: Layer;
+    origin?: string;
+}
+export interface AddAvailableBaseLayersPayload {
+    layers: ReduxLayer[];
+    origin?: string;
+}
+export interface SetAvailableBaseLayersPayload extends AddAvailableBaseLayersPayload {
+    mapId: string;
+}
+export interface ErrorLayerPayload extends LayerPayload {
+    error: string;
+}
+export interface UpdateLayerInfo extends Action {
+    type: `layerReducer/onUpdateLayerInformation`;
+    payload: UpdateLayerInfoPayload;
+}
+export interface SetSelectedFeaturesPayload extends LayerPayload {
+    selectedFeatureIds?: string[];
+}
+export interface SetHoveredFeaturesPayload extends LayerPayload {
+    hoveredFeatureIds?: string[];
+}
+export interface UpdateFeaturePayload extends LayerPayload {
+    geojson: GeoJSON.FeatureCollection;
+    shouldAllowMultipleShapes?: boolean;
+    reason?: string;
+    geoJSONIntersectionLayerId?: string;
+    geoJSONIntersectionBoundsLayerId?: string;
+    selectionType?: string;
+}
+export interface UpdateFeaturePropertiesPayload extends LayerPayload {
+    properties: GeoJSON.GeoJsonProperties;
+    targetFeatureIndex?: number;
+}
+export interface ToggleFeatureModePayload extends LayerPayload {
+    isInEditMode?: boolean;
+    drawMode?: string;
+}
+export interface ExitFeatureDrawModePayload extends LayerPayload {
+    reason: string;
+    shouldAllowMultipleShapes?: boolean;
+}
+export interface ShowLayerInfoPayload {
+    serviceUrl: string;
+    layerName: string;
+    mapId: string;
+    source?: uiTypes.Source;
+    style?: string;
+}
+export interface SetLayerLegendVisibilityPayload {
+    layerId: string;
+    showLayerLegend: boolean;
+    mapId: string;
+    origin: string;
+}

package/dist/src/store/map/layer/utils.d.ts

@@ -0,0 +1,41 @@
+import type { Draft } from '@reduxjs/toolkit';
+import type { WMJSDimension } from '@opengeoweb/webmap';
+import type { Dimension, ReduxLayer } from '../types';
+import type { LayerState } from './types';
+export declare const getFeatureSelectionKey: (feature?: GeoJSON.Feature) => string | undefined;
+export declare const getSelectedFeatureIndexByIds: (geojson: GeoJSON.FeatureCollection | undefined, selectedFeatureIds: string[] | undefined) => number | undefined;
+export declare const isActionLayerSynced: (state: LayerState, layerIdFromAction: string, dimension: Dimension) => boolean;
+export declare const produceDimensionActionForMapLayer: (layerDim: Dimension, wmjsDimension: WMJSDimension, newDimension: Dimension) => Dimension;
+/**
+ * Reset the selection only for the re-initialized layer when its value is no
+ * longer selectable. Duplicate layers keep their own selection, so toggling
+ * one layer's visibility never changes another's. Time dimensions are excluded.
+ */
+export declare const shouldResetCurrentValueToParsedValue: (dimension: Dimension, isReinitializedLayer: boolean, wmDimension: WMJSDimension | undefined, parsedValues: string | undefined) => boolean;
+/**
+ * For the given dimension, it creates a new draft state for all other (linked or synced) layers inside the map.
+ * @param draft
+ * @param dimension
+ * @param mapId
+ */
+export declare const produceDraftStateForAllLayersForDimensionWithinMap: (draft: Draft<LayerState>, dimension: Dimension, mapId: string, layerIdFromAction: string) => void;
+/**
+ * Returns the list of dimensions without the time dimension
+ * @param dimensions Dimension[]
+ */
+export declare const filterNonTimeDimensions: (dimensions: Dimension[]) => Dimension[];
+/**
+ * Returns the list of dimensions without the time dimension
+ * @param dimensions Dimension[]
+ */
+export declare const filterCurrentValueFromDimensions: (dimensions: Dimension[]) => Dimension[];
+/**
+ * The timeslider range is depending on values set via reference_time dimension.
+ * This code will update minValue and maxValue accordingly based on the value of the reference_time.
+ *
+ * @param draft
+ * @param layerId
+ * @param dimensionValueToUpdate
+ * @returns
+ */
+export declare const updateMinMaxValueWhenReferenceTimeChanges: (draftLayer: Draft<ReduxLayer>, dimensionValueToUpdate: Dimension) => void;

package/dist/src/store/map/map/actions.d.ts

@@ -0,0 +1,9 @@
+import type { SetMapDimensionPayload } from '@opengeoweb/webmap-react';
+import type { SetMapPresetPayload } from './types';
+/**
+ * These actions causes circular dependency if they are defined in the reducer.ts file.
+ * Therefor they are instead added to this file
+ * https://redux-toolkit.js.org/usage/usage-guide#exporting-and-using-slices
+ */
+export declare const mapChangeDimension: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetMapDimensionPayload, string>;
+export declare const setMapPreset: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetMapPresetPayload, string>;

package/dist/src/store/map/map/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const IS_LEGEND_OPEN_BY_DEFAULT = true;
+export declare const SECONDS_IN_DAY = 86400;
+export declare const SECONDS_IN_HOUR = 3600;

package/dist/src/store/map/map/enums.d.ts

@@ -0,0 +1,3 @@
+export declare enum MapActionOrigin {
+    map = "map"
+}

package/dist/src/store/map/map/filterLayers.d.ts

@@ -0,0 +1,10 @@
+import type { layerTypes } from '../layer';
+export declare const filterLayers: (layers?: layerTypes.Layer[], layerParser?: (layer: layerTypes.Layer) => layerTypes.Layer) => FilteredLayerList;
+export declare const createEmtpyFilteredList: (existingList: []) => FilteredLayerList;
+export interface FilteredLayerList {
+    mapLayers: layerTypes.Layer[];
+    baseLayers: layerTypes.Layer[];
+    overLayers?: layerTypes.Layer[];
+}
+export declare const parseBoolean: (value: string | boolean) => boolean;
+export declare const parseLayer: (layer: layerTypes.Layer) => layerTypes.Layer;

package/dist/src/store/map/map/index.d.ts

@@ -0,0 +1,26 @@
+import * as mapTypes from './types';
+import * as utils from './utils';
+export declare const mapUtils: {
+    replaceLayerIdsToEnsureUniqueLayerIdsInStore: (layerIds: import("./replaceLayerIdsToEnsureUniqueLayerIdsInStore").LayersAndAutoLayerIds) => import("./replaceLayerIdsToEnsureUniqueLayerIdsInStore").LayersAndAutoLayerIds;
+    moveArrayElements<T>(array: T[], oldIndex: number, newIndex: number): T[];
+    dateFormat: "yyyy-MM-dd'T'HH:mm:ss'Z'";
+    createMap: ({ id, isAnimating, animationStartTime, animationEndTime, isAutoUpdating, shouldEndtimeOverride, bbox, srs, baseLayers, overLayers, mapLayers, featureLayers, dimensions, autoUpdateLayerId, autoTimeStepLayerId, timeSliderSpan, timeStep, animationDelay, timeSliderWidth, timeSliderCenterTime, timeSliderSecondsPerPx, isTimestepAuto, isTimeSpanAuto, isTimeSliderHoverOn, isTimeSliderVisible, displayMapPin, disableMapPin, shouldShowZoomControls, }: utils.CreateMapProps) => mapTypes.WebMap;
+    checkValidLayersPayload: (layers: import("../types").Layer[], mapId: string) => boolean;
+    getDraftMapById: (mapId: string, draft: mapTypes.WebMapState) => mapTypes.WebMap;
+    produceDraftStateSetWebMapDimension: (draft: mapTypes.WebMapState, mapId: string, dimensionFromAction: mapTypes.Dimension, overwriteCurrentValue: boolean) => void;
+    findMapIdFromLayerId: (mapState?: mapTypes.WebMapState, layerId?: string) => string | null;
+    produceDraftStateSetMapDimensionFromLayerChangeDimension: (draft: mapTypes.WebMapState, layerId: string, dimension: mapTypes.Dimension) => void;
+    getTimeStepFromDataInterval: (timeInterval: import("@opengeoweb/webmap").TimeInterval) => number;
+    getSpeedFactor: (speedDelay: number) => import("@opengeoweb/time-slider").SpeedFactorType;
+    getAnimationDuration: (animationEndTime: string | undefined, animationStartTime: string | undefined) => number;
+    generateAnimationList: (unixAnimationStart: number, unixAnimationEnd: number, timeValues: string | undefined, animationInterval?: number) => mapTypes.WebMapAnimationList;
+    parseTimeDimToISO8601Interval: (timeInterval: string | undefined) => mapTypes.ISO8601Interval[];
+    produceTimeSliderTimeSpan: (draft: import("immer").Draft<mapTypes.WebMapState>, mapId: string, timeSliderSpan: number) => void;
+};
+export { mapTypes };
+export { mapActions, mapReducer } from './reducer';
+export * as mapSelectors from './selectors';
+export * as mapEnums from './enums';
+export * from './constants';
+export { defaultLayers } from '@opengeoweb/webmap-react';
+export * as filterLayers from './filterLayers';

package/dist/src/store/map/map/listener.d.ts

@@ -0,0 +1,4 @@
+import type { UnknownAction, ThunkDispatch } from '@reduxjs/toolkit';
+import type { WebMapStateModuleState } from '../types';
+export declare const isAnimationEndTimeValid: (animationEndTime: string) => boolean;
+export declare const mapListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<WebMapStateModuleState, ThunkDispatch<WebMapStateModuleState, unknown, UnknownAction>, unknown>;

package/dist/src/store/map/map/mapListenerAnimationUtils.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Returns the next step for given timerId.
+ * @param timerId The timer id
+ * @param numberOfStepsInAnimation Animation length in steps
+ * @param numStepsToGoForward Amount of steps to go forwards, defaults to 1. Can be positive and negative
+ * @returns
+ */
+export declare const getNextStep: (timerId: string, numberOfStepsInAnimation: number, numStepsToGoForward?: number) => number;
+/**
+ * Handles dwell at the end of the animation loop sequence. The number of steps to wait till proceed can be set by the dwell parameter.
+ * @param timerId The timer id
+ * @param numberOfStepsInAnimation Number of steps in the animation
+ * @param dwell The number of steps to wait at the end of the animation sequence before to continue
+ * @returns
+ */
+export declare const handleTimerDwell: (timerId: string, numberOfStepsInAnimation: number, dwell?: number) => boolean;
+/**
+ * Set step for the timerId
+ * @param timerId
+ * @param timerStep
+ */
+export declare const setStep: (timerId: string, timerStep: number) => void;
+/**
+ * Gets the current step for the timer
+ * @param timerId
+ * @returns
+ */
+export declare const getCurrentStep: (timerId: string) => number;

package/dist/src/store/map/map/metronomeListener.d.ts

@@ -0,0 +1,2 @@
+import type { CoreAppStore } from '../../types';
+export declare const metronomeListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<CoreAppStore, import("redux-thunk").ThunkDispatch<CoreAppStore, unknown, import("redux").UnknownAction>, unknown>;

package/dist/src/store/map/map/olMapListenerAnimationUtils.d.ts

@@ -0,0 +1,46 @@
+import type { Dispatch, ListenerEffectAPI } from '@reduxjs/toolkit';
+import type { CoreAppStore } from '../../types';
+import type { ReduxLayer } from '../types';
+/**
+ * Returns the next step for given timerId.
+ * @param timerId The timer id
+ * @param numberOfStepsInAnimation Animation length in steps
+ * @param numStepsToGoForward Amount of steps to go forwards, defaults to 1. Can be positive and negative
+ * @returns
+ */
+export declare const getNextStep: (timerId: string, numberOfStepsInAnimation: number, numStepsToGoForward?: number) => number;
+/**
+ * Handles dwell at the end of the animation loop sequence. The number of steps to wait till proceed can be set by the dwell parameter.
+ * @param timerId The timer id
+ * @param numberOfStepsInAnimation Number of steps in the animation
+ * @param dwell The number of steps to wait at the end of the animation sequence before to continue
+ * @returns
+ */
+export declare const handleTimerDwell: (timerId: string, numberOfStepsInAnimation: number, dwell?: number) => boolean;
+/**
+ * Set step for the timerId
+ * @param timerId
+ * @param timerStep
+ */
+export declare const setStep: (timerId: string, timerStep: number) => void;
+/**
+ * Gets the current step for the timer
+ * @param timerId
+ * @returns
+ */
+export declare const getCurrentStep: (timerId: string) => number;
+/**
+ * Checks if the next step is available for all provided layers
+ * @param reduxLayers
+ * @param nextTimeString
+ * @returns
+ */
+export declare const isNextStepAvailable: (reduxLayers: ReduxLayer[], nextTimeString: string) => boolean;
+/**
+ * This handler is triggered by the metronome. An array of timerIds is given as argument.
+ * It will update the animation loop of multiple maps and sliders
+ * It will prefetch images for maps
+ * @param timerIds string[] array of timerIds
+ * @param listenerApi ListenerEffectAPI<CoreAppStore, Dispatch, unknown> listenerApi as received from listener
+ */
+export declare const olMetronomeHandler: (timerIds: string[], listenerApi: ListenerEffectAPI<CoreAppStore, Dispatch, unknown>) => void;

package/dist/src/store/map/map/reducer.d.ts

@@ -0,0 +1,142 @@
+import type { PayloadAction, Draft } from '@reduxjs/toolkit';
+import type { MapPinLocationPayload, SetBboxPayload, SetStepBackWardOrForward, UpdateAllMapDimensionsPayload } from '@opengeoweb/webmap-react';
+import type { WebMapState, SetAutoLayerIdPayload, SetMapAnimationStartPayload, SetMapAnimationStopPayload, SetTimeSliderSpanPayload, SetTimeStepPayload, SetAnimationStartTimePayload, SetAnimationEndTimePayload, SetAnimationDelayPayload, MoveLayerPayload, SetTimeSliderWidthPayload, SetTimeSliderCenterTimePayload, SetEndTimeOverriding, ToggleAutoUpdatePayload, ToggleTimestepAutoPayload, ToggleTimeSpanAutoPayload, ToggleTimeSliderHoverPayload, DisableMapPinPayload, ToggleTimeSliderIsVisiblePayload, SetDockedLayerManagerSize, SetDockedLayerManagerPosition, SetDockedLayerManagerDimensions, ToggleAnimationLengthAutoPayload, SetDefaultMapSettingsPayload, ToggleClockPayload, SetClockPositionSizePayload } from './types';
+import type { ToggleMapPinIsVisiblePayload, ToggleZoomControlsPayload } from '../types';
+import type { MapActionOrigin } from './enums';
+/**
+ * Checks if the layer id is already taken in one of the maps.
+ * @param state The WebMapState
+ * @param layerIdToCheck The layerId to check
+ * @returns true if the layerId is already taken somewhere else.
+ */
+export declare const checkIfMapLayerIdIsAlreadyTaken: (state: WebMapState, layerId: string) => boolean;
+export declare const initialState: WebMapState;
+export declare const slice: import("@reduxjs/toolkit").Slice<WebMapState, {
+    registerMap: (draft: Draft<WebMapState>, action: PayloadAction<{
+        mapId: string;
+    }>) => void;
+    unregisterMap: (draft: Draft<WebMapState>, action: PayloadAction<{
+        mapId: string;
+    }>) => void;
+    setStepBackwardOrForward: (_draft: Draft<WebMapState>, _action: PayloadAction<SetStepBackWardOrForward>) => void;
+    setBbox: (draft: Draft<WebMapState>, action: PayloadAction<SetBboxPayload>) => void;
+    mapUpdateAllMapDimensions: (draft: Draft<WebMapState>, action: PayloadAction<UpdateAllMapDimensionsPayload>) => void;
+    mapStartAnimation: (draft: Draft<WebMapState>, action: PayloadAction<SetMapAnimationStartPayload>) => void;
+    mapStopAnimation: (draft: Draft<WebMapState>, action: PayloadAction<SetMapAnimationStopPayload>) => void;
+    setTimeSliderSpan: (draft: Draft<WebMapState>, action: PayloadAction<SetTimeSliderSpanPayload>) => void;
+    setTimeStep: (draft: Draft<WebMapState>, action: PayloadAction<SetTimeStepPayload>) => void;
+    setAnimationStartTime: (draft: Draft<WebMapState>, action: PayloadAction<SetAnimationStartTimePayload>) => void;
+    setAnimationEndTime: (draft: Draft<WebMapState>, action: PayloadAction<SetAnimationEndTimePayload>) => void;
+    setAnimationDelay: (draft: Draft<WebMapState>, action: PayloadAction<SetAnimationDelayPayload>) => void;
+    layerMoveLayer: (draft: Draft<WebMapState>, action: PayloadAction<MoveLayerPayload>) => void;
+    setAutoLayerId: (draft: Draft<WebMapState>, action: PayloadAction<SetAutoLayerIdPayload>) => void;
+    setAutoTimestepLayerId: (draft: Draft<WebMapState>, action: PayloadAction<{
+        mapId: string;
+        autoTimestepLayerId: string | undefined;
+        origin?: MapActionOrigin;
+    }>) => void;
+    setAutoUpdateLayerId: (draft: Draft<WebMapState>, action: PayloadAction<{
+        mapId: string;
+        autoUpdateLayerId: string | undefined;
+        origin?: MapActionOrigin;
+    }>) => void;
+    setTimeSliderWidth: (draft: Draft<WebMapState>, action: PayloadAction<SetTimeSliderWidthPayload>) => void;
+    setTimeSliderCenterTime: (draft: Draft<WebMapState>, action: PayloadAction<SetTimeSliderCenterTimePayload>) => void;
+    toggleAutoUpdate: (draft: Draft<WebMapState>, action: PayloadAction<ToggleAutoUpdatePayload>) => void;
+    setEndTimeOverriding: (draft: Draft<WebMapState>, action: PayloadAction<SetEndTimeOverriding>) => void;
+    toggleTimestepAuto: (draft: Draft<WebMapState>, action: PayloadAction<ToggleTimestepAutoPayload>) => void;
+    toggleTimeSpanAuto: (draft: Draft<WebMapState>, action: PayloadAction<ToggleTimeSpanAutoPayload>) => void;
+    toggleAnimationLengthAuto: (draft: Draft<WebMapState>, action: PayloadAction<ToggleAnimationLengthAutoPayload>) => void;
+    toggleTimeSliderHover: (draft: Draft<WebMapState>, action: PayloadAction<ToggleTimeSliderHoverPayload>) => void;
+    toggleTimeSliderIsVisible: (draft: Draft<WebMapState>, action: PayloadAction<ToggleTimeSliderIsVisiblePayload>) => void;
+    toggleZoomControls: (draft: Draft<WebMapState>, action: PayloadAction<ToggleZoomControlsPayload>) => void;
+    setMapPinLocation: (draft: Draft<WebMapState>, action: PayloadAction<MapPinLocationPayload>) => void;
+    setDisableMapPin: (draft: Draft<WebMapState>, action: PayloadAction<DisableMapPinPayload>) => void;
+    toggleMapPinIsVisible: (draft: Draft<WebMapState>, action: PayloadAction<ToggleMapPinIsVisiblePayload>) => void;
+    setDockedLayerManagerSize: (draft: Draft<WebMapState>, action: PayloadAction<SetDockedLayerManagerSize>) => void;
+    setDockedLayerManagerPosition: (draft: Draft<WebMapState>, action: PayloadAction<SetDockedLayerManagerPosition>) => void;
+    setDockedLayerManagerDimensions: (draft: Draft<WebMapState>, action: PayloadAction<SetDockedLayerManagerDimensions>) => void;
+    setMapPresetError: (_draft: Draft<WebMapState>, _action: PayloadAction<{
+        mapId: string;
+        error?: string;
+    }>) => void;
+    setDefaultMapSettings: (draft: Draft<WebMapState>, action: PayloadAction<SetDefaultMapSettingsPayload>) => void;
+    changeOverlayer: (draft: Draft<WebMapState>, action: PayloadAction<{
+        mapId: string;
+        selectedOverlayer: string;
+        origin: string;
+    }>) => void;
+    toggleClock: (draft: Draft<WebMapState>, action: PayloadAction<ToggleClockPayload>) => void;
+    toggleClockOptions: (draft: Draft<WebMapState>, action: PayloadAction<{
+        mapId: string;
+        isClockOptionsMenuVisible: boolean;
+        origin?: string;
+    }>) => void;
+    setClockPositionSize: (draft: Draft<WebMapState>, action: PayloadAction<SetClockPositionSizePayload>) => void;
+}, "mapReducer", "mapReducer", import("@reduxjs/toolkit").SliceSelectors<WebMapState>>;
+export declare const mapActions: {
+    setMapPreset: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetMapPresetPayload, string>;
+    mapChangeDimension: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("@opengeoweb/webmap-react").SetMapDimensionPayload, string>;
+    registerMap: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+    }, "mapReducer/registerMap">;
+    unregisterMap: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+    }, "mapReducer/unregisterMap">;
+    setStepBackwardOrForward: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetStepBackWardOrForward, "mapReducer/setStepBackwardOrForward">;
+    setBbox: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetBboxPayload, "mapReducer/setBbox">;
+    mapUpdateAllMapDimensions: import("@reduxjs/toolkit").ActionCreatorWithPayload<UpdateAllMapDimensionsPayload, "mapReducer/mapUpdateAllMapDimensions">;
+    mapStartAnimation: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetMapAnimationStartPayload, "mapReducer/mapStartAnimation">;
+    mapStopAnimation: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetMapAnimationStopPayload, "mapReducer/mapStopAnimation">;
+    setTimeSliderSpan: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetTimeSliderSpanPayload, "mapReducer/setTimeSliderSpan">;
+    setTimeStep: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetTimeStepPayload, "mapReducer/setTimeStep">;
+    setAnimationStartTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetAnimationStartTimePayload, "mapReducer/setAnimationStartTime">;
+    setAnimationEndTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetAnimationEndTimePayload, "mapReducer/setAnimationEndTime">;
+    setAnimationDelay: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetAnimationDelayPayload, "mapReducer/setAnimationDelay">;
+    layerMoveLayer: import("@reduxjs/toolkit").ActionCreatorWithPayload<MoveLayerPayload, "mapReducer/layerMoveLayer">;
+    setAutoLayerId: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetAutoLayerIdPayload, "mapReducer/setAutoLayerId">;
+    setAutoTimestepLayerId: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+        autoTimestepLayerId: string | undefined;
+        origin?: MapActionOrigin;
+    }, "mapReducer/setAutoTimestepLayerId">;
+    setAutoUpdateLayerId: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+        autoUpdateLayerId: string | undefined;
+        origin?: MapActionOrigin;
+    }, "mapReducer/setAutoUpdateLayerId">;
+    setTimeSliderWidth: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetTimeSliderWidthPayload, "mapReducer/setTimeSliderWidth">;
+    setTimeSliderCenterTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetTimeSliderCenterTimePayload, "mapReducer/setTimeSliderCenterTime">;
+    toggleAutoUpdate: import("@reduxjs/toolkit").ActionCreatorWithPayload<ToggleAutoUpdatePayload, "mapReducer/toggleAutoUpdate">;
+    setEndTimeOverriding: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetEndTimeOverriding, "mapReducer/setEndTimeOverriding">;
+    toggleTimestepAuto: import("@reduxjs/toolkit").ActionCreatorWithPayload<ToggleTimestepAutoPayload, "mapReducer/toggleTimestepAuto">;
+    toggleTimeSpanAuto: import("@reduxjs/toolkit").ActionCreatorWithPayload<ToggleTimeSpanAutoPayload, "mapReducer/toggleTimeSpanAuto">;
+    toggleAnimationLengthAuto: import("@reduxjs/toolkit").ActionCreatorWithPayload<ToggleAnimationLengthAutoPayload, "mapReducer/toggleAnimationLengthAuto">;
+    toggleTimeSliderHover: import("@reduxjs/toolkit").ActionCreatorWithPayload<ToggleTimeSliderHoverPayload, "mapReducer/toggleTimeSliderHover">;
+    toggleTimeSliderIsVisible: import("@reduxjs/toolkit").ActionCreatorWithPayload<ToggleTimeSliderIsVisiblePayload, "mapReducer/toggleTimeSliderIsVisible">;
+    toggleZoomControls: import("@reduxjs/toolkit").ActionCreatorWithPayload<ToggleZoomControlsPayload, "mapReducer/toggleZoomControls">;
+    setMapPinLocation: import("@reduxjs/toolkit").ActionCreatorWithPayload<MapPinLocationPayload, "mapReducer/setMapPinLocation">;
+    setDisableMapPin: import("@reduxjs/toolkit").ActionCreatorWithPayload<DisableMapPinPayload, "mapReducer/setDisableMapPin">;
+    toggleMapPinIsVisible: import("@reduxjs/toolkit").ActionCreatorWithPayload<ToggleMapPinIsVisiblePayload, "mapReducer/toggleMapPinIsVisible">;
+    setDockedLayerManagerSize: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetDockedLayerManagerSize, "mapReducer/setDockedLayerManagerSize">;
+    setDockedLayerManagerPosition: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetDockedLayerManagerPosition, "mapReducer/setDockedLayerManagerPosition">;
+    setDockedLayerManagerDimensions: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetDockedLayerManagerDimensions, "mapReducer/setDockedLayerManagerDimensions">;
+    setMapPresetError: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+        error?: string;
+    }, "mapReducer/setMapPresetError">;
+    setDefaultMapSettings: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetDefaultMapSettingsPayload, "mapReducer/setDefaultMapSettings">;
+    changeOverlayer: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+        selectedOverlayer: string;
+        origin: string;
+    }, "mapReducer/changeOverlayer">;
+    toggleClock: import("@reduxjs/toolkit").ActionCreatorWithPayload<ToggleClockPayload, "mapReducer/toggleClock">;
+    toggleClockOptions: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+        isClockOptionsMenuVisible: boolean;
+        origin?: string;
+    }, "mapReducer/toggleClockOptions">;
+    setClockPositionSize: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetClockPositionSizePayload, "mapReducer/setClockPositionSize">;
+};
+export declare const mapReducer: import("redux").Reducer<WebMapState>;

package/dist/src/store/map/map/replaceLayerIdsToEnsureUniqueLayerIdsInStore.d.ts

@@ -0,0 +1,7 @@
+import type { layerTypes } from '../layer';
+export interface LayersAndAutoLayerIds {
+    layers: layerTypes.Layer[];
+    autoTimeStepLayerId?: string;
+    autoUpdateLayerId?: string;
+}
+export declare const replaceLayerIdsToEnsureUniqueLayerIdsInStore: (layerIds: LayersAndAutoLayerIds) => LayersAndAutoLayerIds;