@opengeoweb/store 12.13.0 → 13.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeoweb/store",
-  "version": "12.13.0",
+  "version": "13.0.0",
   "description": "GeoWeb Store library for the opengeoweb project",
   "license": "Apache-2.0",
   "repository": {
@@ -8,15 +8,15 @@
     "url": "git@gitlab.com:opengeoweb/opengeoweb.git"
   },
   "dependencies": {
-    "@opengeoweb/shared": "12.13.0",
+    "@opengeoweb/shared": "13.0.0",
     "react-redux": "^9.2.0",
     "@reduxjs/toolkit": "^2.6.1",
-    "@opengeoweb/webmap-react": "12.13.0",
-    "@opengeoweb/webmap": "12.13.0",
+    "@opengeoweb/webmap-react": "13.0.0",
+    "@opengeoweb/webmap": "13.0.0",
     "immer": "^10.0.3",
     "lodash": "^4.17.21",
-    "@opengeoweb/metronome": "12.13.0",
-    "@opengeoweb/timeslider": "12.13.0",
+    "@opengeoweb/metronome": "13.0.0",
+    "@opengeoweb/time-slider": "13.0.0",
     "react-router-dom": "^6.23.1",
     "ol": "^10.4.0",
     "@turf/turf": "^7.2.0",

package/src/store/generic/linking/constants.d.ts

@@ -1,5 +1,6 @@
 export declare enum SupportedComponentTypes {
     WarningList = "WarningList",
-    TimeSeries = "TimeSeries"
+    TimeSeries = "TimeSeries",
+    Soundings = "Soundings"
 }
 export declare const supportedComponentTypesForLinking: string[];

package/src/store/generic/selectors.d.ts

@@ -1,18 +1,18 @@
 import type { CoreAppStore } from '../types';
 import type { LinkedState, PotentialData, SynchronizationGroupState, SynchronizationSource } from './syncGroups/types';
 export declare const getSynchronizationGroupStore: (store: CoreAppStore) => SynchronizationGroupState;
-export declare const getTime: ((state: SynchronizationGroupState, id: string) => string | null) & {
+export declare const getTime: ((state: SynchronizationGroupState, id: string) => import("./synchronizationActions/types").SetTimeSyncProps | null) & {
     clearCache: () => void;
     resultsCount: () => number;
     resetResultsCount: () => void;
 } & {
-    resultFunc: (resultFuncArgs_0: SynchronizationSource) => string | null;
-    memoizedResultFunc: ((resultFuncArgs_0: SynchronizationSource) => string | null) & {
+    resultFunc: (resultFuncArgs_0: SynchronizationSource) => import("./synchronizationActions/types").SetTimeSyncProps | null;
+    memoizedResultFunc: ((resultFuncArgs_0: SynchronizationSource) => import("./synchronizationActions/types").SetTimeSyncProps | null) & {
         clearCache: () => void;
         resultsCount: () => number;
         resetResultsCount: () => void;
     };
-    lastResult: () => string | null;
+    lastResult: () => import("./synchronizationActions/types").SetTimeSyncProps | null;
     dependencies: [(state: SynchronizationGroupState, id: string) => SynchronizationSource];
     recomputations: () => number;
     resetRecomputations: () => void;

package/src/store/generic/synchronizationActions/types.d.ts

@@ -1,8 +1,17 @@
 import { setBbox, setTime } from '../actions';
 import { SyncLayerPayloads } from '../types';
+export interface SetTimeSyncProps {
+    currentTime?: string;
+    timeSliderCenterTime?: number;
+    timeSliderSpan?: number;
+    timeSliderStep?: number;
+    timeSliderAnimationStartTime?: string;
+    timeSliderAnimationEndTime?: string;
+    timeSliderAnimationDelay?: number;
+}
 export interface SetTimeSyncPayload {
     targetId: string;
-    value: string;
+    value: SetTimeSyncProps;
 }
 export interface SetBboxSyncPayload {
     targetId: string;

package/src/store/generic/types.d.ts

@@ -1,10 +1,11 @@
 import { SetLayerStylePayload } from '@opengeoweb/webmap-react';
 import { MapActionOrigin } from '../map/map/enums';
 import type { AddLayerPayload, DeleteLayerPayload, MoveLayerPayload, SetAutoLayerIdPayload, SetBaseLayersPayload, SetLayerDimensionPayload, SetLayerEnabledPayload, SetLayerNamePayload, SetLayerOpacityPayload } from '../map/types';
+import type { SetTimeSyncProps } from './synchronizationActions/types';
 export interface SetTimePayload {
     sourceId: string;
     origin: string;
-    value: string;
+    value: SetTimeSyncProps;
 }
 export interface SetBboxPayload {
     sourceId: string;

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

@@ -1,6 +1,6 @@
 import { Draft, PayloadAction } from '@reduxjs/toolkit';
 import { SetLayerDimensionsPayload, SetLayerStylePayload, UpdateLayerInfoPayload } from '@opengeoweb/webmap-react';
-import { LayerState, Layer, AddLayerPayload, SetLayerDimensionPayload, SetLayerEnabledPayload, SetLayerOpacityPayload, SetLayerNamePayload, SetLayerGeojsonPayload, DeleteLayerPayload, ErrorLayerPayload, SetLayersPayload, SetBaseLayersPayload, AddBaseLayerPayload, AddAvailableBaseLayerPayload, AddAvailableBaseLayersPayload, SetAvailableBaseLayersPayload, SetSelectedFeaturePayload, UpdateFeaturePayload, ExitFeatureDrawModePayload, ToggleFeatureModePayload, UpdateFeaturePropertiesPayload, DuplicateMapLayerPayload, ShowLayerInfoPayload, SetLayerGeojsonFromLayerPayload } from './types';
+import { LayerState, Layer, AddLayerPayload, SetLayerDimensionPayload, SetLayerEnabledPayload, SetLayerOpacityPayload, SetLayerNamePayload, SetLayerGeojsonPayload, DeleteLayerPayload, ErrorLayerPayload, SetLayersPayload, SetBaseLayersPayload, AddBaseLayerPayload, AddAvailableBaseLayerPayload, AddAvailableBaseLayersPayload, SetAvailableBaseLayersPayload, SetSelectedFeaturePayload, UpdateFeaturePayload, ExitFeatureDrawModePayload, ToggleFeatureModePayload, UpdateFeaturePropertiesPayload, DuplicateMapLayerPayload, ShowLayerInfoPayload, SetLayerGeojsonFromLayerPayload, SetLayerOptionsPayload } from './types';
 export declare const createLayer: ({ id, opacity, acceptanceTimeInMinutes, enabled, layerType, status, useLatestReferenceTime, ...props }: Layer) => Layer;
 export declare const initialState: LayerState;
 export declare const slice: import("@reduxjs/toolkit").Slice<LayerState, {
@@ -15,6 +15,7 @@ export declare const slice: import("@reduxjs/toolkit").Slice<LayerState, {
         acceptanceTime: number | undefined;
     }>) => void;
     layerChangeName: (draft: Draft<LayerState>, action: PayloadAction<SetLayerNamePayload>) => void;
+    layerChangeOptions: (draft: Draft<LayerState>, action: PayloadAction<SetLayerOptionsPayload>) => void;
     layerChangeGeojson: (draft: Draft<LayerState>, action: PayloadAction<SetLayerGeojsonPayload>) => void;
     layerSetGeojsonFromLayer: (draft: Draft<LayerState>, action: PayloadAction<SetLayerGeojsonFromLayerPayload>) => void;
     layerDelete: (draft: Draft<LayerState>, action: PayloadAction<DeleteLayerPayload>) => void;
@@ -55,6 +56,7 @@ export declare const layerReducer: import("redux").Reducer<LayerState>, layerAct
         acceptanceTime: number | undefined;
     }>) => void;
     layerChangeName: (draft: Draft<LayerState>, action: PayloadAction<SetLayerNamePayload>) => void;
+    layerChangeOptions: (draft: Draft<LayerState>, action: PayloadAction<SetLayerOptionsPayload>) => void;
     layerChangeGeojson: (draft: Draft<LayerState>, action: PayloadAction<SetLayerGeojsonPayload>) => void;
     layerSetGeojsonFromLayer: (draft: Draft<LayerState>, action: PayloadAction<SetLayerGeojsonFromLayerPayload>) => void;
     layerDelete: (draft: Draft<LayerState>, action: PayloadAction<DeleteLayerPayload>) => void;

package/src/store/map/layer/selectors.d.ts

@@ -2162,6 +2162,47 @@ export declare const getLayerType: ((state: any, layerId: any) => LayerType | "m
     memoize: typeof import("reselect").weakMapMemoize;
     argsMemoize: typeof import("reselect").weakMapMemoize;
 };
+export declare const getLayerOptions: ((state: any, layerId: any) => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined;
+    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => ReduxLayer | undefined;
+        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
 /**
  * Gets all overlayers for a given mapId
  * Example: overlayers = getOverlayersForMapId(store, 'mapId123')
@@ -2202,3 +2243,230 @@ export declare const getOverlayersForMapId: ((state: CoreAppStore, mapId: string
     memoize: typeof import("reselect").weakMapMemoize;
     argsMemoize: typeof import("reselect").weakMapMemoize;
 };
+/**
+ * Gets the layer title from the service store using the layerId
+ *
+ * Example: layerTitle = getLayerTitleFromService(store, 'layerId_1')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @returns {string} returnType: string - string containing layer title
+ */
+export declare const getLayerTitleFromService: ((state: any, ...params: any[]) => string | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (...resultFuncArgs: readonly any[]) => string | undefined;
+    memoizedResultFunc: ((...resultFuncArgs: readonly any[]) => string | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string | undefined;
+    dependencies: import("reselect").SelectorArray<any>;
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Gets layer displayname. For EDR layers with multiple parameters, the collectionId is used as displayname. Otherwise the layer title from the service is used.
+ *
+ * Example: layerName = getLayerDisplayName(store, 'layerId_1')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @returns {string} returnType: string -  layer displayname
+ */
+export declare const getLayerDisplayName: ((state: any, layerId: any) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: LayerType | "mapLayer", resultFuncArgs_1: import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined, resultFuncArgs_2: string | undefined, resultFuncArgs_3: string) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: LayerType | "mapLayer", resultFuncArgs_1: import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined, resultFuncArgs_2: string | undefined, resultFuncArgs_3: string) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [((state: any, layerId: any) => LayerType | "mapLayer") & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => LayerType | "mapLayer";
+        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => LayerType | "mapLayer") & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => LayerType | "mapLayer";
+        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
+            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => ReduxLayer | undefined;
+            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import("reselect").weakMapMemoize;
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }, ((state: any, layerId: any) => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined;
+        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
+            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => ReduxLayer | undefined;
+            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import("reselect").weakMapMemoize;
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }, ((state: any, ...params: any[]) => string | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (...resultFuncArgs: readonly any[]) => string | undefined;
+        memoizedResultFunc: ((...resultFuncArgs: readonly any[]) => string | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string | undefined;
+        dependencies: import("reselect").SelectorArray<any>;
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }, ((state: any, layerId: any) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => string;
+        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => string) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string;
+        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
+            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => ReduxLayer | undefined;
+            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import("reselect").weakMapMemoize;
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Gets the layer missing status. A layer is missing if it is not found in the service store or if its status is 'error'.
+ *
+ * Example: isLayerMissing = getIsLayerMissing(store, 'layerId_1')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @returns {boolean} returnType: boolean - true if layer is missing
+ */
+export declare const getIsLayerMissing: ((state: any, ...params: any[]) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (...resultFuncArgs: readonly any[]) => boolean;
+    memoizedResultFunc: ((...resultFuncArgs: readonly any[]) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: import("reselect").SelectorArray<any>;
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};

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

@@ -78,6 +78,11 @@ export interface SetLayerNamePayload extends LayerPayload {
     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;

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

@@ -11,10 +11,11 @@ export declare const mapUtils: {
     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/timeslider").SpeedFactorType;
+    getSpeedFactor: (speedDelay: number) => import("@opengeoweb/time-slider").SpeedFactorType;
     getAnimationDuration: (animationEndTime: string | undefined, animationStartTime: string | undefined) => number;
     generateAnimationList: (unixAnimationStart: number, unixAnimationEnd: number, timeValues: string | undefined) => 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';

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

@@ -1,6 +1,6 @@
 import { PayloadAction, Draft } from '@reduxjs/toolkit';
 import { 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, SetTimeSliderSecondsPerPxPayload, ToggleTimeSliderIsVisiblePayload, SetDockedLayerManagerSize, ToggleAnimationLengthAutoPayload, SetDefaultMapSettingsPayload } from './types';
+import type { WebMapState, SetAutoLayerIdPayload, SetMapAnimationStartPayload, SetMapAnimationStopPayload, SetTimeSliderSpanPayload, SetTimeStepPayload, SetAnimationStartTimePayload, SetAnimationEndTimePayload, SetAnimationDelayPayload, MoveLayerPayload, SetTimeSliderWidthPayload, SetTimeSliderCenterTimePayload, SetEndTimeOverriding, ToggleAutoUpdatePayload, ToggleTimestepAutoPayload, ToggleTimeSpanAutoPayload, ToggleTimeSliderHoverPayload, DisableMapPinPayload, ToggleTimeSliderIsVisiblePayload, SetDockedLayerManagerSize, ToggleAnimationLengthAutoPayload, SetDefaultMapSettingsPayload } from './types';
 import { ToggleMapPinIsVisiblePayload, ToggleZoomControlsPayload } from '../types';
 import { MapActionOrigin } from './enums';
 /**
@@ -42,7 +42,6 @@ export declare const slice: import("@reduxjs/toolkit").Slice<WebMapState, {
     }>) => void;
     setTimeSliderWidth: (draft: Draft<WebMapState>, action: PayloadAction<SetTimeSliderWidthPayload>) => void;
     setTimeSliderCenterTime: (draft: Draft<WebMapState>, action: PayloadAction<SetTimeSliderCenterTimePayload>) => 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;
@@ -99,7 +98,6 @@ export declare const mapActions: {
     }, "mapReducer/setAutoUpdateLayerId">;
     setTimeSliderWidth: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetTimeSliderWidthPayload, "mapReducer/setTimeSliderWidth">;
     setTimeSliderCenterTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetTimeSliderCenterTimePayload, "mapReducer/setTimeSliderCenterTime">;
-    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">;

package/src/store/map/map/selectors.d.ts

@@ -953,9 +953,38 @@ export declare const isAnimating: (store: CoreAppStore, mapId: string) => boolea
  * @param {string} mapId mapId: string - Id of the map
  * @returns {object} returnType: object - object containing isAnimating boolean and id string
  */
-export declare const linkedMapAnimationInfo: (store: CoreAppStore, mapId: string) => {
+export declare const linkedMapAnimationInfo: ((state: CoreAppStore, mapId: string) => {
     isAnimating: boolean;
     id: string;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WebMapState | undefined, resultFuncArgs_1: import("../../generic/syncGroups/types").SynchronizationGroupState, resultFuncArgs_2: WebMap | undefined) => {
+        isAnimating: boolean;
+        id: string;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: WebMapState | undefined, resultFuncArgs_1: import("../../generic/syncGroups/types").SynchronizationGroupState, resultFuncArgs_2: WebMap | undefined) => {
+        isAnimating: boolean;
+        id: string;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        isAnimating: boolean;
+        id: string;
+    };
+    dependencies: [(store: CoreAppStore) => WebMapState | undefined, (store: CoreAppStore) => import("../../generic/syncGroups/types").SynchronizationGroupState, (store: CoreAppStore, mapId: string) => WebMap | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  * Gets start time of animation
@@ -2882,6 +2911,127 @@ export declare const getAnimationList: ((state: CoreAppStore, mapId: string) =>
     memoize: typeof import("reselect").weakMapMemoize;
     argsMemoize: typeof import("reselect").weakMapMemoize;
 };
+export declare const getAnimationListAsEpochTimes: ((state: CoreAppStore, mapId: string) => number[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WebMapAnimationList) => number[];
+    memoizedResultFunc: ((resultFuncArgs_0: WebMapAnimationList) => number[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number[];
+    dependencies: [((state: CoreAppStore, mapId: string) => WebMapAnimationList) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: Record<string, ReduxLayer> | null, resultFuncArgs_1: WebMap | undefined, resultFuncArgs_2: string | undefined, resultFuncArgs_3: string | undefined, resultFuncArgs_4: number) => WebMapAnimationList;
+        memoizedResultFunc: ((resultFuncArgs_0: Record<string, ReduxLayer> | null, resultFuncArgs_1: WebMap | undefined, resultFuncArgs_2: string | undefined, resultFuncArgs_3: string | undefined, resultFuncArgs_4: number) => WebMapAnimationList) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => WebMapAnimationList;
+        dependencies: [((state: CoreAppStore) => Record<string, ReduxLayer> | null) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: import("../types").LayerState | undefined) => Record<string, ReduxLayer> | null;
+            memoizedResultFunc: ((resultFuncArgs_0: import("../types").LayerState | undefined) => Record<string, ReduxLayer> | null) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => Record<string, ReduxLayer> | null;
+            dependencies: [(store: CoreAppStore) => import("../types").LayerState | undefined];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import("reselect").weakMapMemoize;
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+        }, (store: CoreAppStore, mapId: string) => WebMap | undefined, ((state: CoreAppStore, mapId: string) => string | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: WebMap | undefined) => string | undefined;
+            memoizedResultFunc: ((resultFuncArgs_0: WebMap | undefined) => string | undefined) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => string | undefined;
+            dependencies: [(store: CoreAppStore, mapId: string) => WebMap | undefined];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import("reselect").weakMapMemoize;
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+        }, ((state: CoreAppStore, mapId: string) => string | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: WebMap | undefined) => string | undefined;
+            memoizedResultFunc: ((resultFuncArgs_0: WebMap | undefined) => string | undefined) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => string | undefined;
+            dependencies: [(store: CoreAppStore, mapId: string) => WebMap | undefined];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import("reselect").weakMapMemoize;
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+        }, ((state: CoreAppStore, mapId: string) => number) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: WebMap | undefined) => number;
+            memoizedResultFunc: ((resultFuncArgs_0: WebMap | undefined) => number) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => number;
+            dependencies: [(store: CoreAppStore, mapId: string) => WebMap | undefined];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import("reselect").weakMapMemoize;
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
 /**
  * @param {object} store store: object - store object
  * @param {string} mapId mapId: string - Id of the map

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

@@ -1,6 +1,6 @@
 import { TimeInterval } from '@opengeoweb/webmap';
 import { MapLocation } from '@opengeoweb/webmap-react';
-import { SpeedFactorType } from '@opengeoweb/timeslider';
+import { SpeedFactorType } from '@opengeoweb/time-slider';
 import type { Layer, LayerActionOrigin } from '../types';
 import { MapActionOrigin } from './enums';
 export interface Dimension {

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

@@ -1,5 +1,6 @@
 import { TimeInterval } from '@opengeoweb/webmap';
-import { SpeedFactorType } from '@opengeoweb/timeslider';
+import { SpeedFactorType } from '@opengeoweb/time-slider';
+import { Draft } from 'immer';
 import { Bbox, Dimension } from './types';
 import type { WebMapState, WebMap, ISO8601Interval, WebMapAnimationList } from '../types';
 import type { Layer } from '../layer/types';
@@ -83,3 +84,4 @@ export declare const generateAnimationList: (unixAnimationStart: number, unixAni
  * @returns An array of ISO8601 intervals
  */
 export declare const parseTimeDimToISO8601Interval: (timeInterval: string | undefined) => ISO8601Interval[];
+export declare const produceTimeSliderTimeSpan: (draft: Draft<WebMapState>, mapId: string, timeSliderSpan: number) => void;