@opengeoweb/store 19.6.1-nightly-20260917 → 20.0.0

package/dist/index.esm.js

@@ -3,7 +3,7 @@ import { isEqual, mergeWith, merge, isEmpty, compact } from 'lodash';
 import { webmapUtils, parseISO8601IntervalToDateInterval, LayerType, handleDateUtilsISOString, webmapTestSettings, WMLayer, getWMLayerById, WMInvalidDateValues, isProjectionSupported, queryWMSLayers } from '@opengeoweb/webmap';
 export { LayerType } from '@opengeoweb/webmap';
 import { dateUtils, PROJECTION, defaultDelay, useDebounce } from '@opengeoweb/shared';
-import { secondsPerPxFromCanvasWidth, defaultTimeSpan, defaultSecondsPerPx, defaultAnimationDelayAtStart, defaultTimeStep, AnimationLengthMode, defaultExactSelections, roundWithTimeStep, resolveAnimationRange, isValidAnimationLength, defaultOffsetSelections, withModeSelections, isAnchoredMode, getSpeedDelay, isWithinAnimationStepLimit } from '@opengeoweb/time-slider';
+import { secondsPerPxFromCanvasWidth, defaultTimeSpan, defaultSecondsPerPx, defaultAnimationDelayAtStart, defaultTimeStep, AnimationLengthMode, defaultExactSelections, roundWithTimeStep, resolveAnimationRange, isValidAnimationLength, defaultOffsetSelections, isAnchoredMode, getAnimationLengthFromRange, withModeSelections, getSpeedDelay, isWithinAnimationStepLimit } from '@opengeoweb/time-slider';
 import { produce } from 'immer';
 import { getLastEmptyFeatureIndex, getGeoJson, moveFeature, createInterSections, defaultLayers, fetchStacCatalogRoot, stacCatalogCollectionToLayerProps, fetchStacCatalogCollections, emptyGeoJSON, defaultIntersectionStyleProperties, addSelectionTypeToGeoJSON, getFeatureCollection } from '@opengeoweb/webmap-react';
 export { defaultLayers } from '@opengeoweb/webmap-react';
@@ -3076,7 +3076,7 @@ var slice$6 = createSlice({
             draft.byId[targetId].animationEndTime = value.timeSliderAnimationEndTime;
           }
           /* An exact window is the stored range, so a synced range has to move it too. */
-          if ((value !== null && value !== void 0 && value.timeSliderAnimationStartTime || value !== null && value !== void 0 && value.timeSliderAnimationEndTime) && ((_draft$byId$targetId$ = draft.byId[targetId].animationLength) === null || _draft$byId$targetId$ === void 0 ? void 0 : _draft$byId$targetId$.mode) === AnimationLengthMode.Exact) {
+          if ((value !== null && value !== void 0 && value.timeSliderAnimationStartTime || value !== null && value !== void 0 && value.timeSliderAnimationEndTime) && (targetId !== sourceMapId || ((_draft$byId$targetId$ = draft.byId[targetId].animationLength) === null || _draft$byId$targetId$ === void 0 ? void 0 : _draft$byId$targetId$.mode) === AnimationLengthMode.Exact)) {
             draft.byId[targetId].animationLength = _objectSpread2(_objectSpread2({}, draft.byId[targetId].animationLength), {}, {
               mode: AnimationLengthMode.Exact,
               exact: exactSelectionsFrom(draft.byId[targetId].animationLength, draft.byId[targetId].animationStartTime, draft.byId[targetId].animationEndTime)
@@ -8090,16 +8090,22 @@ genericListener.startListening({
 });
 // Synchronize timeslider settings for actions 'centertime', 'span' and 'timestep'.
 genericListener.startListening({
-  matcher: isAnyOf(mapActions.setTimeSliderCenterTime, mapActions.setTimeSliderSpan, mapActions.setTimeStep, mapActions.setAnimationStartTime, mapActions.setAnimationEndTime, mapActions.setAnimationDelay, mapActions.mapStartAnimation),
+  matcher: isAnyOf(mapActions.setTimeSliderCenterTime, mapActions.setTimeSliderSpan, mapActions.setTimeStep, mapActions.setAnimationStartTime, mapActions.setAnimationEndTime, mapActions.setAnimationLength, mapActions.refreshAnimationRange, mapActions.setAnimationDelay, mapActions.mapStartAnimation),
   effect: function () {
     var _effect2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(_ref2, listenerApi) {
-      var payload, type, sourceId, newPayload, animationStartPayload, targets, groups;
+      var payload, type, sourceId, newPayload, _mapSelectors$getAnim, animationStartTime, animationEndTime, animationStartPayload, targets, groups;
       return _regenerator().w(function (_context2) {
         while (1) switch (_context2.n) {
           case 0:
             payload = _ref2.payload, type = _ref2.type;
             listenerApi.cancelActiveListeners();
             sourceId = payload.mapId;
+            if (!((type === mapActions.setAnimationLength.type || type === mapActions.setAnimationStartTime.type || type === mapActions.setAnimationEndTime.type) && payload.skipSync)) {
+              _context2.n = 1;
+              break;
+            }
+            return _context2.a(2);
+          case 1:
             newPayload = {
               sourceId: sourceId,
               origin: 'timeslidersynclistener',
@@ -8112,6 +8118,11 @@ genericListener.startListening({
                 timeSliderAnimationDelay: type === mapActions.setAnimationDelay.type ? payload.animationDelay : undefined
               }
             };
+            if (type === mapActions.setAnimationLength.type || type === mapActions.refreshAnimationRange.type) {
+              _mapSelectors$getAnim = getAnimationRange(listenerApi.getState(), sourceId), animationStartTime = _mapSelectors$getAnim.animationStartTime, animationEndTime = _mapSelectors$getAnim.animationEndTime;
+              newPayload.value.timeSliderAnimationStartTime = animationStartTime;
+              newPayload.value.timeSliderAnimationEndTime = animationEndTime;
+            }
             if (type === mapActions.mapStartAnimation.type) {
               animationStartPayload = payload;
               if (animationStartPayload.start) {
@@ -8124,7 +8135,7 @@ genericListener.startListening({
             targets = getTargets(listenerApi.getState(), newPayload, SYNCGROUPS_TYPE_SETTIME);
             groups = getTargetGroups(listenerApi.getState(), newPayload, SYNCGROUPS_TYPE_SETTIME);
             listenerApi.dispatch(setTimeSync(newPayload, targets, groups));
-          case 1:
+          case 2:
             return _context2.a(2);
         }
       }, _callee2);
@@ -8939,7 +8950,7 @@ mapListener.startListening({
   actionCreator: mapActions.setMapPreset,
   effect: function () {
     var _effect2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(_ref6, listenerApi) {
-      var payload, mapId, initialProps, mapPreset, _mapPreset$dimensions, layers, activeLayerId, autoTimeStepLayerId, autoUpdateLayerId, proj, shouldAutoUpdate, shouldAnimate, animationPayload, toggleTimestepAuto, showTimeSlider, displayMapPin, shouldShowZoomControls, shouldShowLegend, legendPosition, legendSize, shouldShowDockedLayerManager, shouldShowDataExplorer, dockedLayerManagerSize, dockedLayerManagerPosition, dockedLayerManagerDimensions, timeSliderSpan, toggleTimeSpanAuto, defaultOverlayer, isClockVisible, isClockOptionsMenuVisible, clockPosition, clockSize, initialZoomToLayerId, _filterLayers, mapLayers, baseLayers, overLayers, pendingInitialZoomToLayerId, _newLayerIds$layers$f, _newLayerIds$layers$f2, autoTimeStepLayerIdNew, autoUpdateLayerIdNew, onlyActiveLayerIdIsSet, newLayerIds, newAutoTimeStepLayerId, newAutoUpdateLayerId, _newLayerIds$layers$i, initialZoomLayerIndex, customLayers, customBaseLayer, customOverLayer, baseLayersWithDefaultLayer, overLayersWithDefaultLayer, allBaseLayers, _overlayersFromStore$, overlayersFromStore, foundOverlayerId, checkIsprojectionSupported, layerId, animationLength, animationLengthSetting, animationEndTime, shouldEndtimeOverride, interval, timeAlreadySet, endTime, startTime, centerTimeInSeconds, animationEnd, _startTime, _animationLength, _autoTimeStepLayerId, layerRefTimeDimension, referenceTimeFromLayer, anchorTime, resolvedRange, duration, _animationEnd, animationStart, shouldOpenLegend, dockedLayerManagerType, fiveMinuteDelayForAnimation, _animationEnd2, _animationStart, _t;
+      var payload, mapId, initialProps, mapPreset, _mapPreset$dimensions, layers, activeLayerId, autoTimeStepLayerId, autoUpdateLayerId, proj, shouldAutoUpdate, shouldAnimate, animationPayload, toggleTimestepAuto, showTimeSlider, displayMapPin, shouldShowZoomControls, shouldShowLegend, legendPosition, legendSize, shouldShowDockedLayerManager, shouldShowDataExplorer, dockedLayerManagerSize, dockedLayerManagerPosition, dockedLayerManagerDimensions, timeSliderSpan, toggleTimeSpanAuto, defaultOverlayer, isClockVisible, isClockOptionsMenuVisible, clockPosition, clockSize, initialZoomToLayerId, _filterLayers, mapLayers, baseLayers, overLayers, pendingInitialZoomToLayerId, _newLayerIds$layers$f, _newLayerIds$layers$f2, autoTimeStepLayerIdNew, autoUpdateLayerIdNew, onlyActiveLayerIdIsSet, newLayerIds, newAutoTimeStepLayerId, newAutoUpdateLayerId, _newLayerIds$layers$i, initialZoomLayerIndex, customLayers, customBaseLayer, customOverLayer, baseLayersWithDefaultLayer, overLayersWithDefaultLayer, allBaseLayers, _overlayersFromStore$, overlayersFromStore, foundOverlayerId, checkIsprojectionSupported, layerId, animationDuration, animationLengthSetting, animationEndTime, shouldEndtimeOverride, interval, timeAlreadySet, mode, endTimeFromPreset, endTime, startTime, hasNoAnimationDetails, defaultAnimationLengthSetting, effectiveAnimationLengthSetting, animationLength, animationStartTime, _autoTimeStepLayerId, layerRefTimeDimension, referenceTimeFromLayer, anchorTime, resolvedRange, shouldOpenLegend, dockedLayerManagerType, fiveMinuteDelayForAnimation, animationEnd, animationStart, _t;
       return _regenerator().w(function (_context2) {
         while (1) switch (_context2.p = _context2.n) {
           case 0:
@@ -8948,7 +8959,7 @@ mapListener.startListening({
             mapId = payload.mapId, initialProps = payload.initialProps;
             mapPreset = initialProps.mapPreset;
             if (!mapPreset) {
-              _context2.n = 7;
+              _context2.n = 9;
               break;
             }
             layers = mapPreset.layers, activeLayerId = mapPreset.activeLayerId, autoTimeStepLayerId = mapPreset.autoTimeStepLayerId, autoUpdateLayerId = mapPreset.autoUpdateLayerId, proj = mapPreset.proj, shouldAutoUpdate = mapPreset.shouldAutoUpdate, shouldAnimate = mapPreset.shouldAnimate, animationPayload = mapPreset.animationPayload, toggleTimestepAuto = mapPreset.toggleTimestepAuto, showTimeSlider = mapPreset.showTimeSlider, displayMapPin = mapPreset.displayMapPin, shouldShowZoomControls = mapPreset.shouldShowZoomControls, shouldShowLegend = mapPreset.shouldShowLegend, legendPosition = mapPreset.legendPosition, legendSize = mapPreset.legendSize, shouldShowDockedLayerManager = mapPreset.shouldShowDockedLayerManager, shouldShowDataExplorer = mapPreset.shouldShowDataExplorer, dockedLayerManagerSize = mapPreset.dockedLayerManagerSize, dockedLayerManagerPosition = mapPreset.dockedLayerManagerPosition, dockedLayerManagerDimensions = mapPreset.dockedLayerManagerDimensions, timeSliderSpan = mapPreset.timeSliderSpan, toggleTimeSpanAuto = mapPreset.toggleTimeSpanAuto, defaultOverlayer = mapPreset.defaultOverlayer, isClockVisible = mapPreset.isClockVisible, isClockOptionsMenuVisible = mapPreset.isClockOptionsMenuVisible, clockPosition = mapPreset.clockPosition, clockSize = mapPreset.clockSize, initialZoomToLayerId = mapPreset.initialZoomToLayerId;
@@ -9048,7 +9059,7 @@ mapListener.startListening({
               layerId: layerId
             }));
           case 4:
-            animationLength = animationPayload === null || animationPayload === void 0 ? void 0 : animationPayload.duration;
+            animationDuration = animationPayload === null || animationPayload === void 0 ? void 0 : animationPayload.duration;
             animationLengthSetting = animationPayload === null || animationPayload === void 0 ? void 0 : animationPayload.animationLength;
             animationEndTime = (animationPayload === null || animationPayload === void 0 ? void 0 : animationPayload.endTime) && isAnimationEndTimeValid(animationPayload.endTime) && animationPayload.endTime;
             shouldEndtimeOverride = animationPayload ? animationPayload.shouldEndtimeOverride : false;
@@ -9151,73 +9162,106 @@ mapListener.startListening({
             // If set, don't dispatch setTime action
             timeAlreadySet = (_mapPreset$dimensions = mapPreset.dimensions) === null || _mapPreset$dimensions === void 0 ? void 0 : _mapPreset$dimensions.find(function (dimension) {
               return dimension.name === 'time';
-            }); // sets animationEndTime by endTime of animationPayload
-            if (animationEndTime) {
-              endTime = animationEndTime.includes('NOW') || animationEndTime.includes('TODAY') ? dateUtils.convertNOWandTODAYFormatsToUTC(animationEndTime) : animationEndTime;
-              listenerApi.dispatch(mapActions.setAnimationEndTime({
-                mapId: mapId,
-                animationEndTime: handleDateUtilsISOString(endTime)
-              }));
-              startTime = handleDateUtilsISOString(dateUtils.sub(dateUtils.utc(endTime), {
-                minutes: 5 * 60 // set to default of 5 hours
-              }).toISOString());
-              listenerApi.dispatch(mapActions.setAnimationStartTime({
-                mapId: mapId,
-                animationStartTime: startTime
-              }));
-              if (timeAlreadySet === undefined) {
-                listenerApi.dispatch(genericActions.setTime({
-                  origin: 'map/listener.ts, setMapPreset',
-                  sourceId: mapId,
-                  value: {
-                    currentTime: startTime
-                  }
-                }));
+            });
+            if (!(animationEndTime || animationDuration)) {
+              _context2.n = 6;
+              break;
+            }
+            // set animationEndTime by endTime of animationPayload
+            // set animationStartTime by endTime minus duration of animationPayload
+            mode = function () {
+              if (animationEndTime) {
+                if (animationEndTime.includes('TODAY')) {
+                  return AnimationLengthMode.RecurringPeriod;
+                }
+                if (animationEndTime.includes('NOW')) {
+                  return AnimationLengthMode.Now;
+                }
+                return AnimationLengthMode.Exact;
               }
-              centerTimeInSeconds = new Date(handleDateUtilsISOString(endTime)).getTime();
-              listenerApi.dispatch(mapActions.setTimeSliderCenterTime({
-                mapId: mapId,
-                timeSliderCenterTime: centerTimeInSeconds
-              }));
+              return AnimationLengthMode.Now;
+            }();
+            endTimeFromPreset = animationEndTime && (animationEndTime !== null && animationEndTime !== void 0 && animationEndTime.includes('NOW') || animationEndTime !== null && animationEndTime !== void 0 && animationEndTime.includes('TODAY')) ? handleDateUtilsISOString(dateUtils.convertNOWandTODAYFormatsToUTC(animationEndTime)) : animationEndTime;
+            endTime = endTimeFromPreset || getAnimationEndTime(listenerApi.getState(), mapId);
+            if (endTime) {
+              _context2.n = 5;
+              break;
             }
-            // sets animationStartTime by duration of animationPayload
-            if (animationLength) {
-              animationEnd = getAnimationEndTime(listenerApi.getState(), mapId);
-              _startTime = handleDateUtilsISOString(dateUtils.sub(dateUtils.utc(animationEnd), {
-                minutes: animationLength
-              }).toISOString());
-              listenerApi.dispatch(mapActions.setAnimationStartTime({
-                mapId: mapId,
-                animationStartTime: _startTime
+            return _context2.a(2);
+          case 5:
+            // startTime always relative to endTime
+            startTime = handleDateUtilsISOString(dateUtils.sub(dateUtils.utc(endTime), {
+              minutes: animationDuration || 5 * 60 // default 5 hours
+            }).toISOString());
+            listenerApi.dispatch(mapActions.setAnimationLength({
+              mapId: mapId,
+              animationLength: getAnimationLengthFromRange(mode, {
+                animationStartTime: startTime,
+                animationEndTime: endTime
+              }),
+              animationStartTime: startTime,
+              animationEndTime: endTime,
+              skipSync: !!animationLengthSetting
+            }));
+            if (timeAlreadySet === undefined) {
+              listenerApi.dispatch(genericActions.setTime({
+                origin: 'map/listener.ts, setMapPreset',
+                sourceId: mapId,
+                value: {
+                  currentTime: startTime
+                }
               }));
-              if (timeAlreadySet === undefined) {
-                listenerApi.dispatch(genericActions.setTime({
-                  origin: 'map/listener.ts, setAnimationStartTime',
-                  sourceId: mapId,
-                  value: {
-                    currentTime: _startTime
-                  }
-                }));
-              }
             }
+          case 6:
             // restores how the animation length is determined, overriding duration and endTime
-            if (animationLengthSetting) {
-              _animationLength = withModeSelections(animationLengthSetting);
-              if (_animationLength.mode === AnimationLengthMode.Exact) {
-                listenerApi.dispatch(mapActions.setAnimationLength(_objectSpread2({
+            // if preset has no animation details at all: follow the auto-time-step layer if there is one, otherwise Now
+            hasNoAnimationDetails = !animationLengthSetting && !animationDuration && !animationEndTime;
+            defaultAnimationLengthSetting = getAutoTimeStepLayerId(listenerApi.getState(), mapId) ? {
+              mode: AnimationLengthMode.Auto
+            } : {
+              mode: AnimationLengthMode.Now,
+              now: defaultOffsetSelections
+            };
+            effectiveAnimationLengthSetting = function () {
+              if (animationLengthSetting) {
+                return withModeSelections(animationLengthSetting);
+              }
+              if (hasNoAnimationDetails) {
+                return defaultAnimationLengthSetting;
+              }
+              return undefined;
+            }();
+            if (effectiveAnimationLengthSetting) {
+              animationLength = effectiveAnimationLengthSetting;
+              if (animationLength.mode === AnimationLengthMode.Exact) {
+                listenerApi.dispatch(mapActions.setAnimationLength(_objectSpread2(_objectSpread2({
                   mapId: mapId,
-                  animationLength: _animationLength
-                }, _animationLength.exact)));
+                  animationLength: animationLength
+                }, animationLength.exact), {}, {
+                  skipSync: true
+                })));
+                animationStartTime = animationLength.exact.animationStartTime;
+                if (timeAlreadySet === undefined) {
+                  listenerApi.dispatch(genericActions.setTime({
+                    origin: 'map/listener.ts, setAnimationLength',
+                    sourceId: mapId,
+                    value: {
+                      currentTime: animationStartTime
+                    }
+                  }));
+                }
               } else {
                 _autoTimeStepLayerId = getAutoTimeStepLayerId(listenerApi.getState(), mapId);
                 layerRefTimeDimension = getLayerDimension(listenerApi.getState(), _autoTimeStepLayerId, 'reference_time');
                 referenceTimeFromLayer = (layerRefTimeDimension === null || layerRefTimeDimension === void 0 ? void 0 : layerRefTimeDimension.currentValue) || undefined;
                 anchorTime = dateUtils.utc(referenceTimeFromLayer);
-                resolvedRange = isAnchoredMode(_animationLength.mode) && isValidAnimationLength(_animationLength, anchorTime) ? resolveAnimationRange(_animationLength, anchorTime) : undefined;
-                listenerApi.dispatch(mapActions.setAnimationLength(_objectSpread2({
+                resolvedRange = isAnchoredMode(animationLength.mode) && isValidAnimationLength(animationLength, anchorTime) ? resolveAnimationRange(animationLength, anchorTime) : undefined;
+                listenerApi.dispatch(mapActions.setAnimationLength(_objectSpread2(_objectSpread2({
                   mapId: mapId,
-                  animationLength: _animationLength
-                }, resolvedRange)));
+                  animationLength: animationLength
+                }, resolvedRange), {}, {
+                  skipSync: true
+                })));
                 if (resolvedRange && timeAlreadySet === undefined) {
                   listenerApi.dispatch(genericActions.setTime({
                     origin: 'map/listener.ts, setAnimationLength',
@@ -9238,15 +9282,8 @@ mapListener.startListening({
             }
             //  turn animation on
             if (shouldAnimate === true) {
-              duration = animationPayload !== null && animationPayload !== void 0 && animationPayload.duration ? animationPayload.duration : 5 * 60; //  set to default of 5 hours
-              _animationEnd = shouldEndtimeOverride && animationEndTime ? getAnimationEndTime(listenerApi.getState(), mapId) : dateUtils.dateToString(dateUtils.utc(), dateFormat);
-              animationStart = shouldEndtimeOverride && animationLength ? getAnimationStartTime(listenerApi.getState(), mapId) : dateUtils.dateToString(dateUtils.sub(dateUtils.utc(_animationEnd), {
-                minutes: duration
-              }), dateFormat);
               listenerApi.dispatch(mapActions.mapStartAnimation({
                 mapId: mapId,
-                start: animationStart,
-                end: _animationEnd,
                 interval: interval || defaultTimeStep
               }));
               //  If animation interval set, set the timestep auto property to false
@@ -9310,36 +9347,36 @@ mapListener.startListening({
                 dockedLayerManagerDimensions: dockedLayerManagerDimensions
               }));
             }
-          case 5:
+          case 7:
             if (!(animationEndTime && !derivesOwnAnimationRange(animationLengthSetting) && (shouldEndtimeOverride || !(shouldAutoUpdate || shouldAnimate)))) {
-              _context2.n = 7;
+              _context2.n = 9;
               break;
             }
             fiveMinuteDelayForAnimation = 1000 * 60 * 5; // eslint-disable-next-line no-await-in-loop
-            _context2.n = 6;
+            _context2.n = 8;
             return listenerApi.delay(fiveMinuteDelayForAnimation);
-          case 6:
-            _animationEnd2 = getAnimationEndTime(listenerApi.getState(), mapId);
+          case 8:
+            animationEnd = getAnimationEndTime(listenerApi.getState(), mapId);
             listenerApi.dispatch(mapActions.setAnimationEndTime({
               mapId: mapId,
-              animationEndTime: dateUtils.add(dateUtils.utc(_animationEnd2), {
+              animationEndTime: dateUtils.add(dateUtils.utc(animationEnd), {
                 minutes: 5
               }).toISOString()
             }));
-            _animationStart = getAnimationStartTime(listenerApi.getState(), mapId);
+            animationStart = getAnimationStartTime(listenerApi.getState(), mapId);
             listenerApi.dispatch(mapActions.setAnimationStartTime({
               mapId: mapId,
-              animationStartTime: dateUtils.add(dateUtils.utc(_animationStart), {
+              animationStartTime: dateUtils.add(dateUtils.utc(animationStart), {
                 minutes: 5
               }).toISOString()
             }));
-            _context2.n = 5;
+            _context2.n = 7;
             break;
-          case 7:
-            _context2.n = 9;
+          case 9:
+            _context2.n = 11;
             break;
-          case 8:
-            _context2.p = 8;
+          case 10:
+            _context2.p = 10;
             _t = _context2.v;
             if (_t instanceof Error) {
               listenerApi.dispatch(mapActions.setMapPresetError({
@@ -9347,10 +9384,10 @@ mapListener.startListening({
                 error: _t.message
               }));
             }
-          case 9:
+          case 11:
             return _context2.a(2);
         }
-      }, _callee2, null, [[1, 8]]);
+      }, _callee2, null, [[1, 10]]);
     }));
     function effect(_x3, _x4) {
       return _effect2.apply(this, arguments);

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

@@ -200,11 +200,13 @@ export interface SetAnimationDelayPayload {
 export interface SetAnimationStartTimePayload {
     mapId: string;
     animationStartTime: string;
+    skipSync?: boolean;
     origin?: MapActionOrigin;
 }
 export interface SetAnimationEndTimePayload {
     mapId: string;
     animationEndTime: string;
+    skipSync?: boolean;
     origin?: MapActionOrigin;
 }
 export interface ToggleTimestepAutoPayload {
@@ -227,6 +229,7 @@ export interface SetAnimationLengthPayload {
     animationLength: AnimationLengthSetting;
     animationStartTime?: string;
     animationEndTime?: string;
+    skipSync?: boolean;
     origin?: MapActionOrigin;
 }
 export interface RefreshAnimationRangePayload {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@opengeoweb/store",
-    "version": "19.6.1-nightly-20260917",
+    "version": "20.0.0",
     "description": "GeoWeb Store library for the opengeoweb project",
     "license": "Apache-2.0",
     "repository": {
@@ -20,15 +20,15 @@
         }
     },
     "dependencies": {
-        "@opengeoweb/shared": "19.6.1-nightly-20260917",
+        "@opengeoweb/shared": "20.0.0",
         "react-redux": "^9.2.0",
         "@reduxjs/toolkit": "^2.6.1",
-        "@opengeoweb/webmap-react": "19.6.1-nightly-20260917",
-        "@opengeoweb/webmap": "19.6.1-nightly-20260917",
+        "@opengeoweb/webmap-react": "20.0.0",
+        "@opengeoweb/webmap": "20.0.0",
         "immer": "^10.0.3",
         "lodash": "^4.18.1",
-        "@opengeoweb/metronome": "19.6.1-nightly-20260917",
-        "@opengeoweb/time-slider": "19.6.1-nightly-20260917",
+        "@opengeoweb/metronome": "20.0.0",
+        "@opengeoweb/time-slider": "20.0.0",
         "ol": "^10.4.0",
         "@turf/turf": "^7.2.0",
         "@types/geojson": "^7946.0.14",