@opengeoweb/store 5.2.1 → 6.0.0

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

@@ -0,0 +1,165 @@
+import { Action } from '@reduxjs/toolkit';
+import { FeatureCollection } from 'geojson';
+import { CustomDate } from '@opengeoweb/webmap';
+import type { Dimension, UpdateAllMapDimensionsPayload } from '../map/types';
+import type { SyncGroupActionOrigin } from '../../generic/synchronizationGroups/types';
+export interface WMJSDimension {
+    getFirstValue(): string;
+    getLastValue(): string;
+    getClosestValue(currentValue?: string, evenWhenOutsideRange?: boolean): string;
+    setValue: (currentValue: string) => void;
+    name: string;
+    currentValue: string;
+    getIndexForValue: (currentValue: string, outSideOfRangeFlag?: boolean) => number;
+    getValueForIndex: (index: number) => string | CustomDate;
+    size: () => number;
+    linked: boolean;
+    values?: string;
+    units?: string;
+    unitSymbol: string;
+}
+export declare enum LayerType {
+    mapLayer = "mapLayer",
+    baseLayer = "baseLayer",
+    overLayer = "overLayer"
+}
+export declare enum LayerStatus {
+    default = "default",
+    error = "error"
+}
+export declare enum LayerActionOrigin {
+    layerManager = "layerManager",
+    wmsLoader = "WMSLayerTreeConnect",
+    ReactMapViewParseLayer = "ReactMapViewParseLayer",
+    setLayerDimensionSaga = "setLayerDimensionSaga",
+    toggleAutoUpdateSaga = "toggleAutoUpdateSaga",
+    unregisterMapSaga = "unregisterMapSaga"
+}
+/**
+ * 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 {
+    id?: string;
+    mapId?: string;
+    service?: string;
+    name?: string;
+    title?: string;
+    enabled?: boolean;
+    style?: string;
+    dimensions?: Dimension[];
+    opacity?: number;
+    type?: string;
+    layerType?: LayerType;
+    status?: LayerStatus;
+    format?: string;
+    geojson?: FeatureCollection;
+    selectedFeatureIndex?: number;
+    acceptanceTimeInMinutes?: number;
+}
+/**
+ * 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;
+}
+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 SetLayerDimensionsPayload extends LayerPayload {
+    origin: string;
+    dimensions: Dimension[];
+}
+export interface SetLayerOpacityPayload extends LayerPayload {
+    opacity: number;
+    mapId?: string;
+    origin?: LayerActionOrigin;
+}
+export interface SetLayerNamePayload extends LayerPayload {
+    name: string;
+    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 SetLayerStylePayload extends LayerPayload {
+    style: string;
+    mapId?: string;
+    origin?: LayerActionOrigin | SyncGroupActionOrigin.layerActions;
+}
+export interface SetLayerGeojsonPayload extends LayerPayload {
+    geojson: FeatureCollection;
+}
+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 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: Error;
+}
+export interface UpdateLayerInfoPayload {
+    origin: string;
+    mapDimensions?: UpdateAllMapDimensionsPayload;
+    layerStyle?: SetLayerStylePayload;
+    layerDimensions?: SetLayerDimensionsPayload;
+}
+export interface UpdateLayerInfo extends Action {
+    type: `layerReducer/onUpdateLayerInformation`;
+    payload: UpdateLayerInfoPayload;
+}
+export interface SetSelectedFeaturePayload extends LayerPayload {
+    selectedFeatureIndex: number;
+}

package/src/store/mapStore/layers/utils.d.ts

@@ -0,0 +1,12 @@
+import { Draft } from '@reduxjs/toolkit';
+import type { Dimension } from '../types';
+import type { LayerState, WMJSDimension } from './types';
+export declare const isActionLayerSynced: (state: LayerState, layerIdFromAction: string, dimension: Dimension) => boolean;
+export declare const produceDimensionActionForMapLayer: (layerDim: Dimension, wmjsDimension: WMJSDimension, newDimension: Dimension) => Dimension;
+/**
+ * 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;

package/src/store/mapStore/layers/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+import type { SetMapDimensionPayload, 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/src/store/mapStore/map/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const defaultAnimationDelayAtStart = 250;
+export declare const defaultDelay = 1000;
+export declare const defaultTimeStep = 60;
+export declare const defaultSecondsPerPx = 80;
+export declare const defaultTimeSpan: number;
+export declare const IS_LEGEND_OPEN_BY_DEFAULT = false;

package/src/store/mapStore/map/defaultLayers.d.ts

@@ -0,0 +1,15 @@
+import { LayerType } from '../types';
+export declare const baseLayerGrey: {
+    id: string;
+    name: string;
+    type: string;
+    layerType: LayerType;
+};
+export declare const overLayer: {
+    service: string;
+    name: string;
+    format: string;
+    enabled: boolean;
+    id: string;
+    layerType: LayerType;
+};

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

@@ -0,0 +1,23 @@
+export declare enum Scale {
+    Minutes5 = 0,
+    Hour = 1,
+    Hours3 = 2,
+    Hours6 = 3,
+    Day = 4,
+    Week = 5,
+    Month = 6,
+    Year = 7
+}
+export declare enum AnimationLength {
+    Minutes15 = 15,
+    Minutes30 = 30,
+    Hours1 = 60,
+    Hours2 = 120,
+    Hours3 = 180,
+    Hours6 = 360,
+    Hours12 = 720,
+    Hours24 = 1440
+}
+export declare enum MapActionOrigin {
+    map = "map"
+}

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

@@ -0,0 +1,10 @@
+import { layerTypes } from '../layers';
+export declare const filterLayers: (layers?: layerTypes.Layer[], layerParser?: (layer: layerTypes.Layer) => layerTypes.Layer) => FilteredLayerList;
+export declare const createEmtpyFilteredList: (existingList: []) => FilteredLayerList;
+export declare type 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/src/store/mapStore/map/filterLayers.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,35 @@
+import * as mapTypes from './types';
+import * as utils from './utils';
+export declare const mapUtils: {
+    replaceLayerIdsToEnsureUniqueLayerIdsInStore: (layerIds: import("./replaceLayerIdsToEnsureUniqueLayerIdsInStore").LayersAndAutoLayerIds) => import("./replaceLayerIdsToEnsureUniqueLayerIdsInStore").LayersAndAutoLayerIds;
+    moveArrayElements(array: string[], oldIndex: number, newIndex: number): string[];
+    createMap: ({ id, isAnimating, animationStartTime, animationEndTime, isAutoUpdating, isEndTimeOverriding, 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: (draft?: mapTypes.WebMapState | undefined, layerId?: string | undefined) => string;
+    produceDraftStateSetMapDimensionFromLayerChangeDimension: (draft: mapTypes.WebMapState, layerId: string, dimension: mapTypes.Dimension) => void;
+    getTimeStepFromDataInterval: (timeInterval: import("dist/libs/webmap/src").TimeInterval) => number;
+    getActiveLayerTimeStep: (timeDimension: mapTypes.Dimension | undefined) => number | undefined;
+    getSpeedFactor: (speedDelay: number) => mapTypes.SpeedFactorType;
+    getSpeedDelay: (speedFactor: mapTypes.SpeedFactorType) => number;
+    roundWithTimeStep: (unixTime: number, timeStep: number, type?: string | undefined) => number;
+    secondsPerPxToScale: Map<number, import("./enums").Scale>;
+    scaleToSecondsPerPx: {
+        0: number;
+        1: number;
+        2: number;
+        3: number;
+        4: number;
+        5: number;
+        6: number;
+        7: number;
+    };
+};
+export { mapTypes };
+export { mapActions, reducer as webmapReducer } from './reducer';
+export * as mapSelectors from './selectors';
+export * as mapEnums from './enums';
+export * as mapConstants from './constants';
+export * as defaultLayers from './defaultLayers';
+export * as filterLayers from './filterLayers';

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

@@ -0,0 +1,98 @@
+import { PayloadAction, Draft } from '@reduxjs/toolkit';
+import type { WebMapState, SetAutoLayerIdPayload, SetBboxPayload, SetMapAnimationStartPayload, SetMapAnimationStopPayload, SetTimeSliderSpanPayload, SetTimeStepPayload, SetAnimationStartTimePayload, SetAnimationEndTimePayload, SetAnimationDelayPayload, MoveLayerPayload, SetTimeSliderWidthPayload, SetTimeSliderCenterTimePayload, SetEndTimeOverriding, ToggleAutoUpdatePayload, ToggleTimestepAutoPayload, ToggleTimeSpanAutoPayload, ToggleTimeSliderHoverPayload, MapPinLocationPayload, DisableMapPinPayload, SetTimeSliderSecondsPerPxPayload, UpdateAllMapDimensionsPayload, ToggleTimeSliderIsVisiblePayload, SetDockedLayerManagerSize } 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
+ * @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;
+    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;
+    }>) => void;
+    setAutoUpdateLayerId: (draft: Draft<WebMapState>, action: PayloadAction<{
+        mapId: string;
+        autoUpdateLayerId: string | undefined;
+    }>) => void;
+    setTimeSliderWidth: (draft: Draft<WebMapState>, action: PayloadAction<SetTimeSliderWidthPayload>) => void;
+    setTimeSliderCenterTime: (draft: Draft<WebMapState>, action: PayloadAction<SetTimeSliderCenterTimePayload>) => void;
+    setTimeSliderUnfilteredSelectedTime: (draft: Draft<WebMapState>, action: PayloadAction<SetTimeSliderUnfilteredSelectedTimePayload>) => void;
+    setTimeSliderSecondsPerPx: (draft: Draft<WebMapState>, action: PayloadAction<SetTimeSliderSecondsPerPxPayload>) => 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;
+    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;
+}, "mapReducer">;
+export declare const mapActions: {
+    setMapPreset: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetMapPresetPayload, string>;
+    mapChangeDimension: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetMapDimensionPayload, string>;
+    registerMap: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+    }, "mapReducer/registerMap">;
+    unregisterMap: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+    }, "mapReducer/unregisterMap">;
+    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;
+    }, "mapReducer/setAutoTimestepLayerId">;
+    setAutoUpdateLayerId: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+        autoUpdateLayerId: string | undefined;
+    }, "mapReducer/setAutoUpdateLayerId">;
+    setTimeSliderWidth: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetTimeSliderWidthPayload, "mapReducer/setTimeSliderWidth">;
+    setTimeSliderCenterTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetTimeSliderCenterTimePayload, "mapReducer/setTimeSliderCenterTime">;
+    setTimeSliderUnfilteredSelectedTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetTimeSliderUnfilteredSelectedTimePayload, "mapReducer/setTimeSliderUnfilteredSelectedTime">;
+    setTimeSliderSecondsPerPx: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetTimeSliderSecondsPerPxPayload, "mapReducer/setTimeSliderSecondsPerPx">;
+    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">;
+    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">;
+};
+export declare const reducer: import("redux").Reducer<WebMapState, import("redux").AnyAction>;

package/src/store/mapStore/map/reducer.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

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

package/src/store/mapStore/map/replaceLayerIdsToEnsureUniqueLayerIdsInStore.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,24 @@
+import { SagaIterator } from 'redux-saga';
+import { Moment } from 'moment';
+import { AnimationList } from '@opengeoweb/webmap';
+import { mapActions } from '.';
+import { layerActions } from '../layers';
+import { Layer } from '../layers/types';
+export declare const generateTimeList: (start: Moment, end: Moment, interval: number) => {
+    name: string;
+    value: string;
+}[];
+export declare const getAnimationEndTime: (animationEndTime: string) => string;
+export declare const isAnimationEndTimeValid: (animationEndTime: string) => boolean;
+export declare function updateMapDraw(mapId: string, draw: string | AnimationList[] | undefined, initialAnimationStep?: number): void;
+export declare function startAnimationSaga({ payload, }: ReturnType<typeof mapActions.mapStartAnimation>): Generator;
+export declare function stopAnimationSaga({ payload, }: ReturnType<typeof mapActions.mapStopAnimation>): Generator;
+export declare function deleteLayerSaga({ payload, }: ReturnType<typeof layerActions.layerDelete>): SagaIterator;
+export declare function updateAnimation(mapId: string, maxValue: string): SagaIterator;
+export declare function setLayerDimensionsSaga({ payload, }: ReturnType<typeof layerActions.onUpdateLayerInformation>): SagaIterator;
+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 function unregisterMapSaga({ payload, }: ReturnType<typeof mapActions.unregisterMap>): Generator;
+export declare function rootSaga(): SagaIterator;
+export default rootSaga;

package/src/store/mapStore/map/sagas.spec.d.ts

@@ -0,0 +1 @@
+export {};