@opengeoweb/core 4.6.1 → 4.7.0

package/lib/components/LayerManager/DockedLayerManagerConnect.d.ts

@@ -1,6 +1,7 @@
 import * as React from 'react';
 import { Layer } from '../../store/mapStore/types';
 import { Service } from '../WMSLoader/services';
+import { Source } from '../../store/ui/types';
 interface DockedLayerManagerConnectProps {
     mapId: string;
     preloadedAvailableBaseLayers?: Layer[];
@@ -8,6 +9,7 @@ interface DockedLayerManagerConnectProps {
     bounds?: string;
     showTitle?: boolean;
     leftHeaderComponent?: React.ReactElement;
+    source?: Source;
 }
 /**
  * Docked Layer Manager connected to the store displaying the layers for the corresponding map it's included in

package/lib/components/ReactMapView/AdagucMapDraw.d.ts

@@ -40,17 +40,6 @@ export interface FeatureEvent {
     isInEditMode: boolean;
     feature: GeoJsonFeature;
 }
-export interface AdagucMapDrawDrawFunctionArgs {
-    context: CanvasRenderingContext2D;
-    featureIndex: number;
-    coord: Coordinate;
-    selected: boolean;
-    isInEditMode: boolean;
-    feature: GeoJsonFeature;
-    mouseX: number;
-    mouseY: number;
-    isHovered: boolean;
-}
 export interface AdagucMapDrawProps {
     webmapjs: WMJSMap;
     geojson: GeoJSON.FeatureCollection;

package/lib/components/ReactMapView/AdagucMapDrawTools.d.ts

@@ -7,3 +7,21 @@ export declare type CheckHoverFeaturesResult = {
 } | null;
 export declare const distance: (a: Coordinate, b: Coordinate) => number;
 export declare const checkHoverFeatures: (geojson: GeoJSON.FeatureCollection, mouseX: number, mouseY: number, convertGeoCoordsToScreenCoords: (featureCoords: Position[]) => Coordinate[], ignoreCoordinateIndexInFeature?: boolean | undefined) => CheckHoverFeaturesResult;
+export interface AdagucMapDrawDrawFunctionArgs {
+    context: CanvasRenderingContext2D;
+    featureIndex: number;
+    coord: Coordinate;
+    selected: boolean;
+    isInEditMode: boolean;
+    feature: GeoJsonFeature;
+    mouseX: number;
+    mouseY: number;
+    isHovered: boolean;
+}
+declare type DrawFunction = {
+    id: string;
+    drawMethod: (args: AdagucMapDrawDrawFunctionArgs) => void;
+};
+export declare const getDrawFunctionFromStore: (id: string) => DrawFunction['drawMethod'] | undefined;
+export declare const registerDrawFunction: (drawFunction?: DrawFunction['drawMethod']) => string;
+export {};

package/lib/components/ReactMapView/ReactMapView.d.ts

@@ -54,8 +54,7 @@ declare class ReactMapView extends React.Component<ReactMapViewProps, ReactMapVi
         shouldAutoFetch: boolean;
         displayMapPin: boolean;
         disableMapPin: boolean;
-        onMount: () => void;
-        onUnMount: () => void;
+        onWMJSMount: () => void;
         onMapChangeDimension: () => void;
         onUpdateLayerInformation: () => void;
         onMapZoomEnd: () => void;

package/lib/components/ReactMapView/types.d.ts

@@ -26,11 +26,9 @@ export interface ReactMapViewProps {
     showLayerInfo?: boolean;
     disableMapPin?: boolean;
     services?: Services;
-    onMount?: (mapId: string, WMJSMapInstance: WMJSMap) => void;
-    onUnMount?: (mapId: string, WMJSMapInstance: WMJSMap) => void;
+    onWMJSMount?: (mapId: string) => void;
     onMapChangeDimension?: (payload: SetMapDimensionPayload) => void;
     onMapZoomEnd?: (payload: SetBboxPayload) => void;
-    onRegisterAdaguc?: (WMJSMapInstance: WMJSMap) => void;
     onMapPinChangeLocation?: (payload: MapPinLocationPayload) => void;
     onUpdateLayerInformation?: (payload: UpdateLayerInfoPayload) => void;
 }

package/lib/components/TimeSlider/TimeSliderButtons/AnimationLengthButton/AnimationLengthButton.d.ts

@@ -3,7 +3,8 @@ export declare const title = "Animation";
 interface AnimationLengthButtonProps {
     disabled?: boolean;
     animationLength?: AnimationLength;
+    animationLengthInMinutes?: number;
     onChangeAnimationLength: (length: number) => void;
 }
-declare const AnimationLengthButton: ({ disabled, animationLength, onChangeAnimationLength, }: AnimationLengthButtonProps) => JSX.Element;
+declare const AnimationLengthButton: ({ disabled, animationLength, animationLengthInMinutes, onChangeAnimationLength, }: AnimationLengthButtonProps) => JSX.Element;
 export default AnimationLengthButton;

package/lib/components/TimeSlider/TimeSliderButtons/OptionsMenuButton/OptionsMenuButton.d.ts

@@ -1,5 +1,4 @@
 import React, { FC } from 'react';
-import { Dimension, MapActionOrigin } from '../../../../store/mapStore/types';
 interface OptionsMenuButtonProps {
     nowBtn?: React.ReactChild;
     autoUpdateBtn?: React.ReactChild;
@@ -8,10 +7,6 @@ interface OptionsMenuButtonProps {
     timeScaleBtn?: React.ReactChild;
     animationLengthBtn?: React.ReactChild;
     isOpenByDefault?: boolean;
-    timeStep?: number;
-    timeDimension?: Dimension;
-    onChangeTimeStep?: (scale: number, origin?: MapActionOrigin) => void;
-    isTimestepAuto?: boolean;
 }
 declare const OptionsMenuButton: FC<OptionsMenuButtonProps>;
 export default OptionsMenuButton;

package/lib/components/TimeSlider/TimeSliderButtons/PlayButton/PlayButtonConnect.d.ts

@@ -16,7 +16,7 @@ export interface PlayButtonConnectProps {
 declare const connectRedux: import("react-redux").InferableComponentEnhancerWithProps<{
     animationStartTime: string | undefined;
     animationEndTime: string | undefined;
-    timeStep: number | undefined;
+    timeStep: number;
     linkedMapAnimationInfo: {
         isAnimating: boolean;
         id: string;

package/lib/components/TimeSlider/TimeSliderButtons/TimeSliderMenu/TimeSliderMenu.d.ts

@@ -15,5 +15,6 @@ export interface TimeSliderMenuProps {
     handleAutoClick?: () => void;
     isAutoSelected?: boolean;
     onChangeMouseWheel?: (element: Mark) => void;
+    animationLength?: number;
 }
-export declare const TimeSliderMenu: ({ marks, value, isOpenByDefault, handleMenuItemClick, isDisabled, handleAutoClick, isAutoSelected, title, icon, onChangeMouseWheel, }: TimeSliderMenuProps) => JSX.Element;
+export declare const TimeSliderMenu: ({ marks, value, isOpenByDefault, handleMenuItemClick, isDisabled, handleAutoClick, isAutoSelected, title, icon, onChangeMouseWheel, animationLength, }: TimeSliderMenuProps) => JSX.Element;

package/lib/components/TimeSlider/TimeSliderButtons/TimeStepButton/TimeStepButton.d.ts

@@ -4,7 +4,7 @@ export declare const timeStepTitle = "Time step";
 export interface TimeStepButtonProps {
     timeStep: number;
     disabled?: boolean;
-    isTimestepAuto?: boolean;
+    isTimestepAuto: boolean;
     timeDimension?: Dimension;
     onChangeTimeStep: (scale: number, origin?: MapActionOrigin) => void;
     onToggleTimestepAuto?: () => void;

package/lib/components/TimeSlider/TimeSliderLegend/TimeSliderLegend.d.ts

@@ -1,5 +1,7 @@
 import * as React from 'react';
 import { Scale } from '../../../store/mapStore/types';
+export declare const TIME_SLIDER_LEGEND_HEIGHT = 24;
+export declare const DRAG_AREA_WIDTH = 24;
 export interface TimeSliderLegendProps {
     mapId: string;
     centerTime: number;
@@ -23,7 +25,5 @@ export interface TimeSliderLegendProps {
     onSetAnimationStartTime?: (time: string) => void;
     onSetAnimationEndTime?: (time: string) => void;
 }
-export declare const DRAG_AREA_WIDTH = 24;
 declare const TimeSliderLegend: React.FC<TimeSliderLegendProps>;
-export declare const TIME_SLIDER_LEGEND_HEIGHT = 24;
 export default TimeSliderLegend;

package/lib/components/TimeSlider/TimeSliderUtils.d.ts

@@ -1,6 +1,5 @@
 import moment from 'moment';
 import React from 'react';
-import { TimeInterval } from '@opengeoweb/webmap';
 import { Dimension, Layer, Scale, SpeedFactorType } from '../../store/mapStore/types';
 import CanvasComponent from '../CanvasComponent/CanvasComponent';
 export declare const millisecondsInSecond = 1000;
@@ -45,8 +44,6 @@ export declare const getPreviousTimeStepvalue: (value: number, min: number) => n
 export declare const setPreviousTimeStep: (timeStep: number, curTime: string, dataStartTime: number, onSetNewDate: (newDate: string) => void) => void;
 export declare const setNextTimeStep: (timeStep: number, curTime: string, dataEndTime: number, onSetNewDate: (newDate: string) => void) => void;
 export declare const getValueFromKeyboardEvent: (event: React.KeyboardEvent<HTMLInputElement>, value: number, min: number, max: number, supportFourDirectionNavigation?: boolean) => number;
-export declare const getTimeStepFromDataInterval: (timeInterval: TimeInterval) => number;
-export declare const getActiveLayerTimeStep: (timeDimension: Dimension) => number | null;
 /**
  * This function calculates a suitable secondsPerpx value,
  * when a data scale is selected. secondsPerPx is different for every data set
@@ -117,3 +114,10 @@ export declare const getAutoMoveAreaWidth: (scale: Scale) => number;
  * Used in NowButton and TimeSliderLegend.
  */
 export declare const handleSetNowEvent: (timeStep: number, dataStartTime: number, dataEndTime: number, currentTime: number, onSetNewDate: (newDate: string) => void, onSetCenterTime: (newTime: number) => void) => void;
+export declare enum TimeInMinutes {
+    YEAR = 525600,
+    MONTH = 43800,
+    DAY = 1440,
+    HOUR = 60
+}
+export declare const minutesToDescribedDuration: (minutes: number) => string;

package/lib/components/TimeSlider/index.d.ts

@@ -1,2 +1,3 @@
 export { default as TimeSlider } from './TimeSlider';
 export { default as TimeSliderConnect } from './TimeSliderConnect';
+export * as timeSliderUtils from './TimeSliderUtils';

package/lib/hooks/useSetupDialog/useSetupDialog.d.ts

@@ -1,4 +1,5 @@
 import type { uiTypes } from '../..';
+import { Source } from '../../store/ui/types';
 export interface SetupDialogReturnValue {
     setDialogOrder: () => void;
     dialogOrder: number;
@@ -8,4 +9,4 @@ export interface SetupDialogReturnValue {
     uiIsLoading: boolean;
     uiError: string;
 }
-export declare const useSetupDialog: (dialogType: uiTypes.DialogType) => SetupDialogReturnValue;
+export declare const useSetupDialog: (dialogType: uiTypes.DialogType, source?: Source) => SetupDialogReturnValue;

package/lib/index.d.ts

@@ -1,12 +1,13 @@
-import { mapSelectors, uiActions, uiSelectors, layerActions, genericActions, snackbarActions } from './store';
+import { mapSelectors, uiActions, uiSelectors, layerActions, genericActions, snackbarActions, layerSelectors } from './store';
 import * as mapTypes from './store/mapStore/types';
+import * as layerTypes from './store/mapStore/layers/types';
 import * as mapUtils from './store/mapStore/map/utils';
 import * as uiTypes from './store/ui/types';
 import { reducer as layerReducer } from './store/mapStore/layers/reducer';
 import synchronizationGroupConfig from './store/generic/config';
 import * as SyncGroups from './store/generic/synchronizationGroups';
 import coreModuleConfig from './store/coreModuleConfig';
-import { LayerManagerConnect, LayerSelectConnect, LayerManagerMapButtonConnect } from './components/LayerManager';
+import { LayerManagerConnect, LayerSelectConnect, LayerManagerMapButtonConnect, DockedLayerManagerConnect } from './components/LayerManager';
 import { MultiDimensionSelectMapButtonsConnect, MultiMapDimensionSelectConnect } from './components/MultiMapDimensionSelect';
 export * from './hooks';
 export * from './components/MultiMapView/MultiMapViewConnect';
@@ -15,7 +16,7 @@ export { MapViewConnect, MapView, MapViewLayer } from './components/MapView';
 export { ReactMapView, ReactMapViewLayer } from './components/ReactMapView';
 export { LegendConnect, Legend, LegendMapButtonConnect, } from './components/Legend';
 export { ZoomControls, ZoomControlConnect } from './components/MapControls';
-export { TimeSliderConnect } from './components/TimeSlider';
+export { TimeSliderConnect, timeSliderUtils } from './components/TimeSlider';
 export { MapControls } from './components/MapControls';
 export declare const mapActions: {
     serviceSetLayers: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetLayersForServicePayload, string>;
@@ -36,7 +37,6 @@ export declare const mapActions: {
     setTimeStep: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetTimeStepPayload, string>;
     setAnimationStartTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetAnimationStartTimePayload, string>;
     setAnimationEndTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetAnimationEndTimePayload, string>;
-    setSelectedFeature: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetSelectedFeaturePayload, string>;
     setAnimationDelay: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetAnimationDelayPayload, string>;
     layerMoveLayer: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.MoveLayerPayload, string>;
     setActiveLayerId: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetActiveLayerIdPayload, string>;
@@ -52,9 +52,6 @@ export declare const mapActions: {
     setMapPinLocation: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.MapPinLocationPayload, string>;
     setDisableMapPin: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.DisableMapPinPayload, string>;
     toggleMapPinIsVisible: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.ToggleMapPinIsVisiblePayload, string>;
-    setActiveMapPresetId: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetActiveMapPresetPayload, string>;
-    setHasMapPresetChanges: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetIsMapPresetHasChangesPayload, string>;
-    toggleDockedLayerManager: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.ToggleDockedLayerManagedPayload, string>;
     addLayer: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.AddLayerPayload, string>;
     layerChangeDimension: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetLayerDimensionPayload, string>;
     layerChangeEnabled: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetLayerEnabledPayload, string>;
@@ -73,8 +70,9 @@ export declare const mapActions: {
     addAvailableBaseLayers: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.AddAvailableBaseLayersPayload, string>;
     setAvailableBaseLayers: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetAvailableBaseLayersPayload, string>;
     onUpdateLayerInformation: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.UpdateLayerInfoPayload, string>;
+    setSelectedFeature: import("@reduxjs/toolkit").ActionCreatorWithPayload<mapTypes.SetSelectedFeaturePayload, string>;
 };
-export { mapSelectors, mapTypes, mapUtils, layerReducer, layerActions, uiActions, uiSelectors, uiTypes, genericActions as syncGroupActions, snackbarActions, };
+export { mapSelectors, mapTypes, mapUtils, layerTypes, layerReducer, layerActions, uiActions, uiSelectors, uiTypes, genericActions as syncGroupActions, snackbarActions, layerSelectors, };
 export { synchronizationGroupConfig as synchronizationGroupModuleConfig };
 export * from './components/ComponentsLookUp';
 export * from './components/ConfigurableMap';
@@ -84,7 +82,7 @@ export { SyncGroups };
 export { store } from './storybookUtils/store';
 export * from './types/types';
 export { coreModuleConfig };
-export { LayerManagerConnect, LayerSelectConnect, LayerManagerMapButtonConnect, };
+export { LayerManagerConnect, LayerSelectConnect, LayerManagerMapButtonConnect, DockedLayerManagerConnect, };
 export { MultiDimensionSelectMapButtonsConnect, MultiMapDimensionSelectConnect, };
 export * as publicLayers from './utils/publicLayers';
 export * as publicServices from './utils/publicServices';
@@ -98,4 +96,6 @@ export { default as uiModuleConfig } from './store/ui/config';
 export { default as mapModuleConfig } from './store/mapStore/config';
 export { default as synchronizationGroupsConfig } from './store/generic/config';
 export * from './components/MapWarning/MapWarningProperties';
-export type { FeatureEvent, GeoFeatureStyle, AdagucMapDrawDrawFunctionArgs, GeoJsonFeature, } from './components/ReactMapView/AdagucMapDraw';
+export type { FeatureEvent, GeoFeatureStyle, GeoJsonFeature, } from './components/ReactMapView/AdagucMapDraw';
+export type { AdagucMapDrawDrawFunctionArgs } from './components/ReactMapView/AdagucMapDrawTools';
+export { getDrawFunctionFromStore, registerDrawFunction, } from './components/ReactMapView/AdagucMapDrawTools';

package/lib/store/mapStore/layers/reducer.d.ts

@@ -1,5 +1,5 @@
 import { PayloadAction } from '@reduxjs/toolkit';
-import { LayerState, Layer, AddLayerPayload, SetLayerDimensionPayload, SetLayerEnabledPayload, SetLayerOpacityPayload, SetLayerStylePayload, SetLayerNamePayload, SetLayerGeojsonPayload, DeleteLayerPayload, ErrorLayerPayload, SetLayersPayload, SetBaseLayersPayload, AddBaseLayerPayload, SetLayerDimensionsPayload, AddAvailableBaseLayerPayload, AddAvailableBaseLayersPayload, UpdateLayerInfoPayload, SetAvailableBaseLayersPayload } from './types';
+import { LayerState, Layer, AddLayerPayload, SetLayerDimensionPayload, SetLayerEnabledPayload, SetLayerOpacityPayload, SetLayerStylePayload, SetLayerNamePayload, SetLayerGeojsonPayload, DeleteLayerPayload, ErrorLayerPayload, SetLayersPayload, SetBaseLayersPayload, AddBaseLayerPayload, SetLayerDimensionsPayload, AddAvailableBaseLayerPayload, AddAvailableBaseLayersPayload, UpdateLayerInfoPayload, SetAvailableBaseLayersPayload, SetSelectedFeaturePayload } from './types';
 export declare const createLayer: ({ id, opacity, enabled, layerType, status, ...props }: Layer) => Layer;
 export declare const initialState: LayerState;
 export declare const slice: import("@reduxjs/toolkit").Slice<LayerState, {
@@ -21,6 +21,7 @@ export declare const slice: import("@reduxjs/toolkit").Slice<LayerState, {
     addAvailableBaseLayers: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<AddAvailableBaseLayersPayload>) => void;
     setAvailableBaseLayers: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetAvailableBaseLayersPayload>) => void;
     onUpdateLayerInformation: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<UpdateLayerInfoPayload>) => LayerState;
+    setSelectedFeature: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetSelectedFeaturePayload>) => void;
 }, "layerReducer">;
 export declare const reducer: import("redux").Reducer<LayerState, import("redux").AnyAction>;
 export declare const layerActions: import("@reduxjs/toolkit").CaseReducerActions<{
@@ -42,5 +43,6 @@ export declare const layerActions: import("@reduxjs/toolkit").CaseReducerActions
     addAvailableBaseLayers: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<AddAvailableBaseLayersPayload>) => void;
     setAvailableBaseLayers: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetAvailableBaseLayersPayload>) => void;
     onUpdateLayerInformation: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<UpdateLayerInfoPayload>) => LayerState;
+    setSelectedFeature: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetSelectedFeaturePayload>) => void;
 }>;
 export declare type LayerActions = ReturnType<typeof layerActions.layerSetDimensions> | ReturnType<typeof layerActions.layerChangeStyle> | ReturnType<typeof layerActions.addAvailableBaseLayer> | ReturnType<typeof layerActions.addAvailableBaseLayers> | ReturnType<typeof layerActions.addBaseLayer> | ReturnType<typeof layerActions.addLayer> | ReturnType<typeof layerActions.baseLayerDelete> | ReturnType<typeof layerActions.onUpdateLayerInformation> | ReturnType<typeof layerActions.layerChangeDimension> | ReturnType<typeof layerActions.layerChangeEnabled> | ReturnType<typeof layerActions.layerChangeGeojson> | ReturnType<typeof layerActions.layerChangeName> | ReturnType<typeof layerActions.layerChangeOpacity> | ReturnType<typeof layerActions.layerDelete> | ReturnType<typeof layerActions.layerError> | ReturnType<typeof layerActions.setBaseLayers> | ReturnType<typeof layerActions.setLayers>;

package/lib/store/mapStore/layers/selectors.d.ts

@@ -365,3 +365,43 @@ export declare const getAvailableBaseLayersForMap: ((state: {
 }> & {
     clearCache: () => void;
 };
+/**
+ * Returns the selected geojson feature for the given layer
+ *
+ * Example const selectedFeature = getSelectedFeature(store, 'layerId1')
+ * @param {object} store store: object - store object
+ * @param {string} mapId layerId: string - Id of the layer
+ * @returns {number} selectedFeatureIndex: the index of the selected geojson feature
+ */
+export declare const getSelectedFeatureIndex: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0: string) => number | undefined) & import("reselect").OutputSelectorFields<(args_0: Layer) => number & {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets layerIds that contain passed dimension
+ *
+ * Example: dimension = getDimensionLayerIds(store, 'elevation')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} dimensionName dimensionName: string - name of dimension you want to retrieve the dimension data for
+ * @returns {string[]} returnType: string[] - layerIds
+ */
+export declare const getDimensionLayerIds: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0: string) => string[]) & import("reselect").OutputSelectorFields<((args_0: string[], args_1: Record<string, ReduxLayer> | null, args_2: string) => string[]) & {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};

package/lib/store/mapStore/layers/types.d.ts

@@ -47,6 +47,7 @@ export interface ReduxLayer {
     status?: LayerStatus;
     format?: string;
     geojson?: FeatureCollection;
+    selectedFeatureIndex?: number;
 }
 /**
  * Layer is used to define a layer with all its possible properties.
@@ -161,3 +162,6 @@ export interface UpdateLayerInfo extends Action {
     type: `layerReducer/onUpdateLayerInformation`;
     payload: UpdateLayerInfoPayload;
 }
+export interface SetSelectedFeaturePayload extends LayerPayload {
+    selectedFeatureIndex: number;
+}

package/lib/store/mapStore/map/reducer.d.ts

@@ -1,6 +1,6 @@
 import { PayloadAction } from '@reduxjs/toolkit';
-import { WebMapState, SetActiveLayerIdPayload, SetBboxPayload, SetMapAnimationStartPayload, SetMapAnimationStopPayload, SetTimeSliderScalePayload, SetTimeStepPayload, SetAnimationStartTimePayload, SetAnimationEndTimePayload, SetSelectedFeaturePayload, SetAnimationDelayPayload, MoveLayerPayload, SetTimeSliderCenterTimePayload, SetTimeSliderDataScaleToSecondsPerPxPayload, ToggleAutoUpdatePayload, ToggleTimestepAutoPayload, ToggleTimeSliderHoverPayload, MapPinLocationPayload, DisableMapPinPayload, SetActiveMapPresetPayload, SetTimeSliderSecondsPerPxPayload, UpdateAllMapDimensionsPayload, SetIsMapPresetHasChangesPayload, ToggleTimeSliderIsVisiblePayload } from './types';
-import { ToggleMapPinIsVisiblePayload, ToggleZoomControlsPayload, ToggleDockedLayerManagedPayload, SetTimeSliderUnfilteredSelectedTimePayload } from '../types';
+import { WebMapState, SetActiveLayerIdPayload, SetBboxPayload, SetMapAnimationStartPayload, SetMapAnimationStopPayload, SetTimeSliderScalePayload, SetTimeStepPayload, SetAnimationStartTimePayload, SetAnimationEndTimePayload, SetAnimationDelayPayload, MoveLayerPayload, SetTimeSliderCenterTimePayload, SetTimeSliderDataScaleToSecondsPerPxPayload, ToggleAutoUpdatePayload, ToggleTimestepAutoPayload, ToggleTimeSliderHoverPayload, MapPinLocationPayload, DisableMapPinPayload, SetTimeSliderSecondsPerPxPayload, UpdateAllMapDimensionsPayload, ToggleTimeSliderIsVisiblePayload } from './types';
+import { ToggleMapPinIsVisiblePayload, ToggleZoomControlsPayload, SetTimeSliderUnfilteredSelectedTimePayload } from '../types';
 /**
  * Checks if the layer id is already taken in one of the maps.
  * @param state The WebMapState
@@ -30,7 +30,6 @@ export declare const slice: import("@reduxjs/toolkit").Slice<WebMapState, {
     setTimeStep: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetTimeStepPayload>) => void;
     setAnimationStartTime: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetAnimationStartTimePayload>) => void;
     setAnimationEndTime: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetAnimationEndTimePayload>) => void;
-    setSelectedFeature: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetSelectedFeaturePayload>) => void;
     setAnimationDelay: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetAnimationDelayPayload>) => void;
     layerMoveLayer: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<MoveLayerPayload>) => void;
     setActiveLayerId: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetActiveLayerIdPayload>) => void;
@@ -46,9 +45,6 @@ export declare const slice: import("@reduxjs/toolkit").Slice<WebMapState, {
     setMapPinLocation: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<MapPinLocationPayload>) => void;
     setDisableMapPin: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<DisableMapPinPayload>) => void;
     toggleMapPinIsVisible: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<ToggleMapPinIsVisiblePayload>) => void;
-    setActiveMapPresetId: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetActiveMapPresetPayload>) => void;
-    setHasMapPresetChanges: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetIsMapPresetHasChangesPayload>) => void;
-    toggleDockedLayerManager: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<ToggleDockedLayerManagedPayload>) => void;
 }, "mapReducer">;
 export declare const mapActions: {
     setMapPreset: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetMapPresetPayload, string>;
@@ -67,7 +63,6 @@ export declare const mapActions: {
     setTimeStep: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetTimeStepPayload, string>;
     setAnimationStartTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetAnimationStartTimePayload, string>;
     setAnimationEndTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetAnimationEndTimePayload, string>;
-    setSelectedFeature: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetSelectedFeaturePayload, string>;
     setAnimationDelay: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetAnimationDelayPayload, string>;
     layerMoveLayer: import("@reduxjs/toolkit").ActionCreatorWithPayload<MoveLayerPayload, string>;
     setActiveLayerId: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetActiveLayerIdPayload, string>;
@@ -83,8 +78,5 @@ export declare const mapActions: {
     setMapPinLocation: import("@reduxjs/toolkit").ActionCreatorWithPayload<MapPinLocationPayload, string>;
     setDisableMapPin: import("@reduxjs/toolkit").ActionCreatorWithPayload<DisableMapPinPayload, string>;
     toggleMapPinIsVisible: import("@reduxjs/toolkit").ActionCreatorWithPayload<ToggleMapPinIsVisiblePayload, string>;
-    setActiveMapPresetId: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetActiveMapPresetPayload, string>;
-    setHasMapPresetChanges: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetIsMapPresetHasChangesPayload, string>;
-    toggleDockedLayerManager: import("@reduxjs/toolkit").ActionCreatorWithPayload<ToggleDockedLayerManagedPayload, string>;
 };
 export declare const reducer: import("redux").Reducer<WebMapState, import("redux").AnyAction>;

package/lib/store/mapStore/map/sagas.d.ts

@@ -3,8 +3,6 @@ import { Moment } from 'moment';
 import { mapActions } from '.';
 import { layerActions } from '../layers';
 import { Layer } from '../layers/types';
-import { genericActions } from '../../generic';
-import { uiActions } from '../../ui';
 export declare const generateTimeList: (start: Moment, end: Moment, interval: number) => {
     name: string;
     value: string;
@@ -18,9 +16,6 @@ export declare function setLayerDimensionsSaga({ payload, }: ReturnType<typeof l
 export declare function toggleAutoUpdateSaga({ payload, }: ReturnType<typeof mapActions.toggleAutoUpdate>): SagaIterator;
 export declare function handleBaseLayersSaga(mapId: string, baseLayers: Layer[]): SagaIterator;
 export declare function setMapPresetSaga({ payload, }: ReturnType<typeof mapActions.setMapPreset>): SagaIterator;
-export declare type SupportedMapPresetChangeActions = ReturnType<typeof layerActions.setBaseLayers> | ReturnType<typeof layerActions.layerDelete> | ReturnType<typeof layerActions.addLayer> | ReturnType<typeof layerActions.layerChangeEnabled> | ReturnType<typeof layerActions.layerChangeName> | ReturnType<typeof layerActions.layerChangeStyle> | ReturnType<typeof layerActions.layerChangeOpacity> | ReturnType<typeof layerActions.layerChangeDimension> | ReturnType<typeof mapActions.layerMoveLayer> | ReturnType<typeof mapActions.setActiveLayerId> | ReturnType<typeof mapActions.toggleAutoUpdate> | ReturnType<typeof mapActions.mapStartAnimation> | ReturnType<typeof mapActions.mapStopAnimation> | ReturnType<typeof mapActions.toggleTimeSliderIsVisible> | ReturnType<typeof mapActions.setTimeStep> | ReturnType<typeof mapActions.setAnimationDelay> | ReturnType<typeof mapActions.toggleTimestepAuto> | ReturnType<typeof uiActions.setActiveMapIdForDialog> | ReturnType<typeof uiActions.setToggleOpenDialog> | ReturnType<typeof genericActions.setBbox>;
-export declare const mapPresetChangeActions: (string | import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetMapAnimationStopPayload, string> | import("@reduxjs/toolkit").ActionCreatorWithPayload<import("../../ui/types").UIToggleDialogPayload, string>)[];
-export declare function checkMapPresetForChangesSaga(action: SupportedMapPresetChangeActions): SagaIterator;
 export declare function unregisterMapSaga({ payload, }: ReturnType<typeof mapActions.unregisterMap>): Generator;
 export declare function rootSaga(): SagaIterator;
 export default rootSaga;

package/lib/store/mapStore/map/selectors.d.ts

@@ -438,6 +438,18 @@ export declare const getMapTimeStep: ((state: {
     services?: import("../types").ServiceState | undefined;
     layers?: import("../types").LayerState | undefined;
     layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0: string) => number) & import("reselect").OutputSelectorFields<(args_0: WebMap) => number & {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const getMapTimeStepWithoutDefault: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: UIStoreType | undefined;
+    webmap?: WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: import("../types").LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
 }, params_0: string) => number | undefined) & import("reselect").OutputSelectorFields<(args_0: WebMap) => number & {
     clearCache: () => void;
 }> & {
@@ -788,7 +800,7 @@ export declare const getDisableMapPin: ((state: {
     clearCache: () => void;
 };
 /**
- * Returns the diplay map pin boolean for the current map
+ * Returns the display map pin boolean for the current map
  *
  * Example getDisplayMapPin(store);
  * @param {object} store store: object - store object
@@ -807,46 +819,6 @@ export declare const getDisplayMapPin: ((state: {
 }> & {
     clearCache: () => void;
 };
-/**
- * Returns the selected geojson feature for the given map
- *
- * Example const selectedFeature = getSelectedFeature(store, 'mapId1')
- * @param {object} store store: object - store object
- * @param {string} mapId mapId: string - Id of the map
- * @returns {number} selectedFeatureIndex: the index of the selected geojson feature
- */
-export declare const getSelectedFeatureIndex: ((state: {
-    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
-    ui?: UIStoreType | undefined;
-    webmap?: WebMapState | undefined;
-    services?: import("../types").ServiceState | undefined;
-    layers?: import("../types").LayerState | undefined;
-    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
-}, params_0: string) => number | undefined) & import("reselect").OutputSelectorFields<(args_0: WebMap) => number & {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
-};
-/**
- * Returns the active map preset id
- *
- * Example getActiveMapPresetId(store, mapId);
- * @param {object} store store: object - store object
- * @param {string} mapId mapId: string - Id of the map
- * @returns {boolean} returnType: boolean or undefined
- */
-export declare const getActiveMapPresetId: ((state: {
-    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
-    ui?: UIStoreType | undefined;
-    webmap?: WebMapState | undefined;
-    services?: import("../types").ServiceState | undefined;
-    layers?: import("../types").LayerState | undefined;
-    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
-}, params_0: string) => string | undefined) & import("reselect").OutputSelectorFields<(args_0: WebMap) => string & {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
-};
 /**
  * Returns the legend id
  *
@@ -882,47 +854,48 @@ export declare const getMapPreset: ((state: {
     services?: import("../types").ServiceState | undefined;
     layers?: import("../types").LayerState | undefined;
     layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
-}, params_0: string) => MapPreset) & import("reselect").OutputSelectorFields<((args_0: import("../types").ReduxLayer[], args_1: import("../types").ReduxLayer[], args_2: import("../types").ReduxLayer[], args_3: Bbox, args_4: string, args_5: string | undefined, args_6: boolean, args_7: boolean, args_8: boolean | undefined, args_9: boolean | undefined, args_10: boolean | undefined, args_11: number | undefined, args_12: number | undefined, args_13: boolean | undefined, args_14: string | undefined, args_15: UIStoreType) => MapPreset) & {
+}, params_0: string) => MapPreset) & import("reselect").OutputSelectorFields<((args_0: import("../types").ReduxLayer[], args_1: import("../types").ReduxLayer[], args_2: import("../types").ReduxLayer[], args_3: Bbox, args_4: string, args_5: string | undefined, args_6: boolean, args_7: boolean, args_8: boolean | undefined, args_9: boolean | undefined, args_10: boolean | undefined, args_11: number, args_12: number | undefined, args_13: boolean | undefined, args_14: string | undefined, args_15: UIStoreType) => MapPreset) & {
     clearCache: () => void;
 }> & {
     clearCache: () => void;
 };
 /**
- * Returns the has changes state of the map preset
+ * Gets all enabled layerIds for map
  *
- * Example getHasMapPresetChanges(store, mapId);
- * @param {object} store store: object - store object
+ * Example: getMapLayerIdsEnabled = getLayerIdsEnabled(store, 'mapId_1')
+ * @param {object} store store: object - store
  * @param {string} mapId mapId: string - Id of the map
- * @returns {boolean} returnType: boolean
+ * @returns {string[]} returnType: string[] -  array of enabled layerIds
  */
-export declare const getHasMapPresetChanges: ((state: {
+export declare const getMapLayerIdsEnabled: ((state: {
     syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
     ui?: UIStoreType | undefined;
     webmap?: WebMapState | undefined;
     services?: import("../types").ServiceState | undefined;
     layers?: import("../types").LayerState | undefined;
     layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
-}, params_0: string) => boolean) & import("reselect").OutputSelectorFields<(args_0: WebMap) => boolean & {
+}, params_0: string) => string[]) & import("reselect").OutputSelectorFields<((args_0: string[], args_1: Record<string, import("../types").ReduxLayer> | null) => string[]) & {
     clearCache: () => void;
 }> & {
     clearCache: () => void;
 };
 /**
- * Returns whether the docked layer manager is open
+ * Returns if a map dimension is used for any enabled layers on that map
  *
- * Example getIsDockedLayerManagerOpen(store, mapId);
+ * Example getIsEnabledLayersForMapDimension(store, mapId);
  * @param {object} store store: object - store object
  * @param {string} mapId mapId: string - Id of the map
+ * @param {string} dimensionName dimensionName: string - name of the dimension
  * @returns {Boolean} returnType: boolean
  */
-export declare const getIsDockedLayerManagerOpen: ((state: {
+export declare const getIsEnabledLayersForMapDimension: ((state: {
     syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
     ui?: UIStoreType | undefined;
     webmap?: WebMapState | undefined;
     services?: import("../types").ServiceState | undefined;
     layers?: import("../types").LayerState | undefined;
     layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
-}, params_0: string) => boolean) & import("reselect").OutputSelectorFields<(args_0: WebMap) => boolean & {
+}, params_0: string, params_1: {}) => any) & import("reselect").OutputSelectorFields<((args_0: string[], args_1: string[]) => any) & {
     clearCache: () => void;
 }> & {
     clearCache: () => void;

package/lib/store/mapStore/map/types.d.ts

@@ -11,9 +11,6 @@ export interface Dimension {
     validSyncSelection?: boolean;
     values?: string;
 }
-export interface DockedLayerManager {
-    isOpen: boolean;
-}
 export interface WebMap {
     id: string;
     isAnimating: boolean;
@@ -42,11 +39,7 @@ export interface WebMap {
     mapPinLocation?: MapLocation;
     disableMapPin?: boolean;
     displayMapPin?: boolean;
-    selectedFeatureIndex?: number;
-    activeMapPresetId?: string;
-    hasMapPresetChanges?: boolean;
     legendId?: string;
-    dockedLayerManager: DockedLayerManager;
 }
 export interface WebMapState {
     byId: Record<string, WebMap>;
@@ -228,23 +221,7 @@ export interface ToggleMapPinIsVisiblePayload {
     mapId: string;
     displayMapPin: boolean;
 }
-export interface SetSelectedFeaturePayload {
-    mapId: string;
-    selectedFeatureIndex: number;
-}
 export interface SetMapPresetPayload {
     mapId: string;
     initialProps: MapPresetInitialProps;
 }
-export interface SetActiveMapPresetPayload {
-    mapId: string;
-    presetId: string;
-}
-export interface SetIsMapPresetHasChangesPayload {
-    mapId: string;
-    hasChanges: boolean;
-}
-export interface ToggleDockedLayerManagedPayload {
-    mapId: string;
-    openDockedLayerManager: boolean;
-}