@opengeoweb/store 20.0.1 → 20.1.0-nightly-20261017

package/dist/index.esm.js

@@ -3,9 +3,9 @@ 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, MAX_ANIMATION_STEPS, AnimationLengthMode, defaultExactSelections, withDraggedRange, anchorInstantFor, roundWithTimeStep, resolveAnimationRange, isValidAnimationLength, defaultOffsetSelections, isAnchoredMode, getAnimationLengthFromRange, withModeSelections, getSpeedDelay, isWithinAnimationStepLimit } from '@opengeoweb/time-slider';
+import { secondsPerPxFromCanvasWidth, defaultTimeSpan, defaultSecondsPerPx, defaultAnimationDelayAtStart, defaultTimeStep, MAX_ANIMATION_STEPS, AnimationLengthMode, defaultExactSelections, withDraggedRange, roundWithTimeStep, isValidAnimationLength, isWithinAnimationStepLimit, settingRange, isAnchoredMode, resolveAnimationRange, defaultOffsetSelections, getAnimationLengthFromRange, withModeSelections, getSpeedDelay } 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';
+import { getLastEmptyFeatureIndex, getGeoJson, moveFeature, createInterSections, defaultLayers, fetchStacCatalogRoot, defaultEdrStyles, normalizeEDRLabel, fetchEDRJson, stacCatalogCollectionToLayerProps, fetchStacCatalogCollections, emptyGeoJSON, defaultIntersectionStyleProperties, addSelectionTypeToGeoJSON, getFeatureCollection } from '@opengeoweb/webmap-react';
 export { defaultLayers } from '@opengeoweb/webmap-react';
 import { v4 } from 'uuid';
 import React, { useEffect, useRef, useCallback } from 'react';
@@ -351,6 +351,9 @@ function _setPrototypeOf(t, e) {
 function _slicedToArray(r, e) {
   return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
 }
+function _toArray(r) {
+  return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest();
+}
 function _toConsumableArray(r) {
   return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
 }
@@ -1069,6 +1072,25 @@ var generateAnimationList = function generateAnimationList(unixAnimationStart, u
   });
   return animationList;
 };
+/**
+ * Returns the adjacent time (unix seconds) in a comma separated list of time values,
+ * or undefined when the values are empty, contain ISO8601 intervals or there is no adjacent time.
+ */
+var getAdjacentTimeValue = function getAdjacentTimeValue(timeValues, currentUnix, isForwardStep) {
+  if (!timeValues || timeValues.includes('/')) {
+    return undefined;
+  }
+  var unixTimes = timeValues.split(',').map(function (timeValue) {
+    return dateUtils.unix(dateUtils.utc(timeValue.trim()));
+  }).filter(Number.isFinite).sort(function (first, second) {
+    return first - second;
+  });
+  return isForwardStep ? unixTimes.find(function (time) {
+    return time > currentUnix;
+  }) : unixTimes.filter(function (time) {
+    return time < currentUnix;
+  }).pop();
+};
 /**
  * Parses the time dimension values string to an array of ISO8601 intervals
  * @param timeInterval
@@ -1114,6 +1136,7 @@ var utils$2 = /*#__PURE__*/Object.freeze({
   dateFormat: dateFormat,
   findMapIdFromLayerId: findMapIdFromLayerId,
   generateAnimationList: generateAnimationList,
+  getAdjacentTimeValue: getAdjacentTimeValue,
   getAnimationDuration: getAnimationDuration,
   getDraftMapById: getDraftMapById,
   getSpeedFactor: getSpeedFactor,
@@ -1298,6 +1321,9 @@ var trimTrailingSlashes = function trimTrailingSlashes(url) {
 var getSTACServiceRootUrl = function getSTACServiceRootUrl(serviceUrl) {
   return trimTrailingSlashes(serviceUrl).replace(/\/collections\/[^/]+$/, '');
 };
+var getEDRServiceRootUrl = function getEDRServiceRootUrl(serviceUrl) {
+  return trimTrailingSlashes(serviceUrl).replace(/\/collections\/[^/]+$/, '');
+};
 var getTrailingSlashVariant = function getTrailingSlashVariant(url) {
   return url.endsWith('/') ? url.slice(0, -1) : "".concat(url, "/");
 };
@@ -1561,6 +1587,7 @@ var utils$1 = /*#__PURE__*/Object.freeze({
   filterCurrentValueFromDimensions: filterCurrentValueFromDimensions,
   filterNonTimeDimensions: filterNonTimeDimensions,
   generateFeatureId: generateFeatureId,
+  getEDRServiceRootUrl: getEDRServiceRootUrl,
   getFeatureSelectionKey: getFeatureSelectionKey,
   getSTACServiceRootUrl: getSTACServiceRootUrl,
   getSelectedFeatureIndexByIds: getSelectedFeatureIndexByIds,
@@ -2454,7 +2481,11 @@ var exactSelectionsFrom = function exactSelectionsFrom(animationLength, animatio
 };
 /** A moved edge edits the selected mode; a map without a mode gains an exact one. */
 var animationLengthForMovedEdge = function animationLengthForMovedEdge(map, movedEdge, referenceTime) {
-  return map.animationLength ? withDraggedRange(map.animationLength, movedEdge, anchorInstantFor(map.animationLength, referenceTime)) : {
+  var _map$timeStep;
+  return map.animationLength ? withDraggedRange(map.animationLength, movedEdge, {
+    referenceTime: referenceTime,
+    timeStep: (_map$timeStep = map.timeStep) !== null && _map$timeStep !== void 0 ? _map$timeStep : defaultTimeStep
+  }) : {
     mode: AnimationLengthMode.Exact,
     exact: exactSelectionsFrom(map.animationLength, map.animationStartTime, map.animationEndTime)
   };
@@ -3179,6 +3210,7 @@ var slice$6 = createSlice({
       draft.byId[mapId].baseLayers = [];
       draft.byId[mapId].mapLayers = [];
       draft.byId[mapId].overLayers = [];
+      draft.byId[mapId].featureLayers = [];
       draft.byId[mapId].isAutoUpdating = false;
       draft.byId[mapId].isAnimating = false;
       draft.byId[mapId].isTimeSliderVisible = true;
@@ -5188,6 +5220,15 @@ var useSyncgroupTimeState = function useSyncgroupTimeState(panelId) {
 var layerStore = function layerStore(store) {
   return store === null || store === void 0 ? void 0 : store.layers;
 };
+var getCollectionServiceRootUrl = function getCollectionServiceRootUrl(layerType, serviceUrl) {
+  if (layerType === LayerType.edrFeatureLayer) {
+    return getEDRServiceRootUrl(serviceUrl);
+  }
+  if (layerType === LayerType.stacGeoTIFFLayer) {
+    return getSTACServiceRootUrl(serviceUrl);
+  }
+  return undefined;
+};
 /**
  * Gets a layer from the layers part of the store by its Id
  *
@@ -5460,7 +5501,8 @@ var getLayerService = createSelector(getLayerById, function (layer) {
 var getLayerServiceName = createSelector(function (store) {
   return store;
 }, getLayerById, getLayerService, function (store, layer, service) {
-  var layerService = getServiceByUrl(store, service) || ((layer === null || layer === void 0 ? void 0 : layer.layerType) === LayerType.stacGeoTIFFLayer ? getServiceByUrl(store, getSTACServiceRootUrl(service)) || getServiceByUrl(store, getTrailingSlashVariant(getSTACServiceRootUrl(service))) : undefined);
+  var serviceRootUrl = getCollectionServiceRootUrl(layer === null || layer === void 0 ? void 0 : layer.layerType, service);
+  var layerService = getServiceByUrl(store, service) || (serviceRootUrl ? getServiceByUrl(store, serviceRootUrl) || getServiceByUrl(store, getTrailingSlashVariant(serviceRootUrl)) : undefined);
   return layerService !== null && layerService !== void 0 && layerService.name ? layerService === null || layerService === void 0 ? void 0 : layerService.name : '';
 }, selectorMemoizationOptions);
 /**
@@ -5718,8 +5760,9 @@ var getIsLayerMissing = createSelector(function (store) {
   if (type === LayerType.featureLayer || type === LayerType.stacGeoTIFFLayer) {
     return false;
   }
-  var layer = getLayerFromService(store, service, name);
-  return !layer || status === LayerStatus.error;
+  var serviceRootUrl = getCollectionServiceRootUrl(type, service);
+  var serviceLayer = getLayerFromService(store, service, name) || (serviceRootUrl ? getLayerFromService(store, serviceRootUrl, name) || getLayerFromService(store, getTrailingSlashVariant(serviceRootUrl), name) : undefined);
+  return !serviceLayer || status === LayerStatus.error;
 }, selectorMemoizationOptions);
 var getIsLayerSelectable = createSelector(getLayerById, function (layer) {
   return Boolean(layer === null || layer === void 0 ? void 0 : layer.isSelectable);
@@ -7478,6 +7521,15 @@ var getAnimationRange = createSelector(getLayersById, getAutoTimeStepLayerId, ge
     animationEndTime: animationEndTime
   };
 }, selectorMemoizationOptions);
+var getAnimationAnchorInputs = createSelector(getLayersById, getAutoTimeStepLayerId, getMapTimeStep, function (layers, autoTimeStepLayerId, timeStep) {
+  var _layers$autoTimeStepL3;
+  return {
+    referenceTime: autoTimeStepLayerId && (layers === null || layers === void 0 || (_layers$autoTimeStepL3 = layers[autoTimeStepLayerId]) === null || _layers$autoTimeStepL3 === void 0 || (_layers$autoTimeStepL3 = _layers$autoTimeStepL3.dimensions) === null || _layers$autoTimeStepL3 === void 0 || (_layers$autoTimeStepL3 = _layers$autoTimeStepL3.find(function (dimension) {
+      return dimension.name === 'reference_time';
+    })) === null || _layers$autoTimeStepL3 === void 0 ? void 0 : _layers$autoTimeStepL3.currentValue) || undefined,
+    timeStep: timeStep
+  };
+}, selectorMemoizationOptions);
 /**
  * Gets intialViewMapPreset from webmap state
  *
@@ -7527,6 +7579,7 @@ var selectors$1 = /*#__PURE__*/Object.freeze({
   getAllMapIds: getAllMapIds,
   getAllMapsByIds: getAllMapsByIds,
   getAllUniqueDimensions: getAllUniqueDimensions,
+  getAnimationAnchorInputs: getAnimationAnchorInputs,
   getAnimationEndTime: getAnimationEndTime,
   getAnimationLength: getAnimationLength,
   getAnimationList: getAnimationList,
@@ -8110,7 +8163,7 @@ genericListener.startListening({
             payload = _ref2.payload, type = _ref2.type;
             listenerApi.cancelActiveListeners();
             sourceId = payload.mapId;
-            if (!(type === mapActions.setAnimationLength.type && payload.skipSync)) {
+            if (!((type === mapActions.setAnimationLength.type || type === mapActions.refreshAnimationRange.type) && payload.skipSync)) {
               _context2.n = 1;
               break;
             }
@@ -8397,6 +8450,64 @@ genericListener.startListening({
   }()
 });
 
+var ANIMATION_CLOCK_INTERVAL = 1000 * 60;
+/** Auto is left out: its selector derives the range from the leading layer. */
+var resolveMapAnimationRange = function resolveMapAnimationRange(state, mapId) {
+  var animationLength = getAnimationLength(state, mapId);
+  if (!animationLength || animationLength.mode === AnimationLengthMode.Auto) {
+    return undefined;
+  }
+  var anchorInputs = getAnimationAnchorInputs(state, mapId);
+  var isUsableRange = isValidAnimationLength(animationLength, anchorInputs) && isWithinAnimationStepLimit(animationLength, getMapTimeStep(state, mapId), anchorInputs);
+  return isUsableRange ? settingRange(animationLength, anchorInputs) : undefined;
+};
+var isSameInstant = function isSameInstant(time, storedTime) {
+  return !!storedTime && dateUtils.utc(time).getTime() === dateUtils.utc(storedTime).getTime();
+};
+var isStoredRange = function isStoredRange(state, mapId, _ref) {
+  var animationStartTime = _ref.animationStartTime,
+    animationEndTime = _ref.animationEndTime;
+  return isSameInstant(animationStartTime, getAnimationStartTime(state, mapId)) && isSameInstant(animationEndTime, getAnimationEndTime(state, mapId));
+};
+var reconcileAnimationRange = function reconcileAnimationRange(mapId, listenerApi) {
+  var skipSync = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var range = resolveMapAnimationRange(listenerApi.getState(), mapId);
+  if (range && !isStoredRange(listenerApi.getState(), mapId, range)) {
+    listenerApi.dispatch(mapActions.refreshAnimationRange(_objectSpread2(_objectSpread2({
+      mapId: mapId
+    }, range), skipSync && {
+      skipSync: skipSync
+    })));
+  }
+};
+var mapIdOfLeadingLayer = function mapIdOfLeadingLayer(state, layerId) {
+  var _layerSelectors$getLa;
+  var mapId = (_layerSelectors$getLa = getLayerById(state, layerId)) === null || _layerSelectors$getLa === void 0 ? void 0 : _layerSelectors$getLa.mapId;
+  return mapId && getAutoTimeStepLayerId(state, mapId) === layerId ? mapId : undefined;
+};
+var mapIdToReconcile = function mapIdToReconcile(action, state) {
+  if (layerActions.onUpdateLayerInformation.match(action)) {
+    var _action$payload$layer;
+    return mapIdOfLeadingLayer(state, (_action$payload$layer = action.payload.layerDimensions) === null || _action$payload$layer === void 0 ? void 0 : _action$payload$layer.layerId);
+  }
+  if (layerActions.layerChangeDimension.match(action)) {
+    return action.payload.dimension.name === 'reference_time' ? mapIdOfLeadingLayer(state, action.payload.layerId) : undefined;
+  }
+  return action.payload.mapId;
+};
+var isSyncSkippedBy = function isSyncSkippedBy(action) {
+  return mapActions.setAnimationLength.match(action) && !!action.payload.skipSync;
+};
+var hasAnchoredAnimationLength = function hasAnchoredAnimationLength(state, mapId) {
+  var _getAnimationLength;
+  return isAnchoredMode((_getAnimationLength = getAnimationLength(state, mapId)) === null || _getAnimationLength === void 0 ? void 0 : _getAnimationLength.mode);
+};
+var endsAnimationClockOf = function endsAnimationClockOf(mapId) {
+  return function (action) {
+    return (mapActions.setAnimationLength.match(action) || mapActions.unregisterMap.match(action)) && action.payload.mapId === mapId;
+  };
+};
+
 /* A map with all the timerIds and their current step */
 var stepMap = new Map();
 /* A map with a list of timers and their dwell */
@@ -8679,6 +8790,7 @@ mapListener.startListening({
   effect: function effect(_ref2, listenerApi) {
     var payload = _ref2.payload;
     try {
+      var _state$layers;
       var layerDimensions = payload.layerDimensions;
       if (!layerDimensions) {
         return;
@@ -8692,21 +8804,10 @@ mapListener.startListening({
       var newTimeDimension = dimensions.find(function (dimension) {
         return dimension.name === 'time';
       });
-      var hasReferenceTimeDimension = dimensions.some(function (dimension) {
-        return dimension.name === 'reference_time';
-      });
       var mapId = layer.mapId;
       if (!mapId) {
         return;
       }
-      if (hasReferenceTimeDimension) {
-        var _layerSelectors$getLa, _layerSelectors$getLa2;
-        var previousReferenceTime = (_layerSelectors$getLa = getLayerDimension(listenerApi.getOriginalState(), layerId, 'reference_time')) === null || _layerSelectors$getLa === void 0 ? void 0 : _layerSelectors$getLa.currentValue;
-        var referenceTime = (_layerSelectors$getLa2 = getLayerDimension(listenerApi.getState(), layerId, 'reference_time')) === null || _layerSelectors$getLa2 === void 0 ? void 0 : _layerSelectors$getLa2.currentValue;
-        if (referenceTime && referenceTime !== previousReferenceTime) {
-          updateReferenceTimeAnimationRange(mapId, layerId, referenceTime, listenerApi);
-        }
-      }
       listenerApi.dispatch(mapActions.mapUpdateAllMapDimensions({
         mapId: mapId,
         dimensions: getMapDimensionsFromLayers(listenerApi.getState(), mapId),
@@ -8765,6 +8866,37 @@ mapListener.startListening({
         }
         updateAnimation(mapId, incomingMaxTime, listenerApi);
       }
+      var state = listenerApi.getState();
+      // Metadata updates affect all layers with the same name and service;
+      // resolve each layer's time against its own map's selected time.
+      Object.values(((_state$layers = state.layers) === null || _state$layers === void 0 ? void 0 : _state$layers.byId) || {}).forEach(function (updatedLayer) {
+        var _updatedLayer$dimensi;
+        if (!(updatedLayer !== null && updatedLayer !== void 0 && updatedLayer.id) || !updatedLayer.mapId || updatedLayer.name !== layer.name || updatedLayer.service !== layer.service) {
+          return;
+        }
+        var wmLayer = webmapUtils.getWMLayerById(updatedLayer.id);
+        var wmTimeDimension = wmLayer === null || wmLayer === void 0 ? void 0 : wmLayer.getDimension('time');
+        var mapTime = getMapDimension(state, updatedLayer.mapId, 'time');
+        var timeDimension = (_updatedLayer$dimensi = updatedLayer.dimensions) === null || _updatedLayer$dimensi === void 0 ? void 0 : _updatedLayer$dimensi.find(function (dimension) {
+          return dimension.name === 'time';
+        });
+        if ((wmLayer === null || wmLayer === void 0 ? void 0 : wmLayer.layerType) !== LayerType.mapLayer || !(wmTimeDimension !== null && wmTimeDimension !== void 0 && wmTimeDimension.linked) || !(mapTime !== null && mapTime !== void 0 && mapTime.currentValue) || !timeDimension) {
+          return;
+        }
+        var currentValue = wmTimeDimension.getClosestValue(mapTime.currentValue, true);
+        if (WMInvalidDateValues.has(currentValue) || currentValue === timeDimension.currentValue) {
+          return;
+        }
+        listenerApi.dispatch(layerActions.layerSetDimensions({
+          layerId: updatedLayer.id,
+          origin: LayerActionOrigin.updateLayerInformationListener,
+          dimensions: updatedLayer.dimensions.map(function (dimension) {
+            return dimension.name === 'time' ? _objectSpread2(_objectSpread2({}, dimension), {}, {
+              currentValue: currentValue
+            }) : _objectSpread2({}, dimension);
+          })
+        }));
+      });
     } catch (error) {
       console.warn(error);
     }
@@ -8810,17 +8942,38 @@ var updateAnimation = function updateAnimation(mapId, maxValue, listenerApi) {
     }));
   });
 };
+// Returns the maps among the given sync targets, in the order the sync groups dialog lists them
+var getMapIdsInSyncListOrder = function getMapIdsInSyncListOrder(state, targetIds) {
+  var _getSynchronizationGr, _getSynchronizationGr2;
+  var sourceIds = Object.keys((_getSynchronizationGr = (_getSynchronizationGr2 = getSynchronizationGroupState(state)) === null || _getSynchronizationGr2 === void 0 ? void 0 : _getSynchronizationGr2.sources.byId) !== null && _getSynchronizationGr !== void 0 ? _getSynchronizationGr : {});
+  var orderedTargetIds = [].concat(_toConsumableArray(sourceIds.filter(function (sourceId) {
+    return targetIds.includes(sourceId);
+  })), _toConsumableArray(targetIds.filter(function (targetId) {
+    return !sourceIds.includes(targetId);
+  })));
+  return orderedTargetIds.filter(function (targetId) {
+    return getMapById(state, targetId);
+  });
+};
+var isHigherSyncedMapAutoUpdating = function isHigherSyncedMapAutoUpdating(state, mapId) {
+  var syncedMapIds = getMapIdsInSyncListOrder(state, getSyncedMapIdsForTimeslider(state));
+  var mapIndex = syncedMapIds.indexOf(mapId);
+  return syncedMapIds.slice(0, Math.max(mapIndex, 0)).some(function (syncedMapId) {
+    return isAutoUpdating(state, syncedMapId);
+  });
+};
 mapListener.startListening({
   actionCreator: mapActions.toggleAutoUpdate,
   effect: function () {
     var _effect = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref3, listenerApi) {
-      var payload, shouldAutoUpdate, mapId, autoUpdateLayerId, timeDimension, syncedMapIds, payloads;
+      var payload, shouldAutoUpdate, mapId, origin, syncedMapIds, autoUpdateLayerId, timeDimension, payloads;
       return _regenerator().w(function (_context) {
         while (1) switch (_context.n) {
           case 0:
             payload = _ref3.payload;
             listenerApi.cancelActiveListeners();
-            shouldAutoUpdate = payload.shouldAutoUpdate, mapId = payload.mapId;
+            // origin is passed on so that the presets of all affected maps get marked as changed
+            shouldAutoUpdate = payload.shouldAutoUpdate, mapId = payload.mapId, origin = payload.origin;
             if (shouldAutoUpdate) {
               _context.n = 1;
               break;
@@ -8828,9 +8981,9 @@ mapListener.startListening({
             return _context.a(2);
           case 1:
             try {
+              syncedMapIds = getSyncedMapIdsForTimeslider(listenerApi.getState());
               autoUpdateLayerId = getAutoUpdateLayerId(listenerApi.getState(), mapId);
-              timeDimension = getLayerTimeDimension(listenerApi.getState(), autoUpdateLayerId);
-              syncedMapIds = getSyncedMapIdsForTimeslider(listenerApi.getState()); // go to end of active layer
+              timeDimension = getLayerTimeDimension(listenerApi.getState(), autoUpdateLayerId); // go to end of active layer
               if (timeDimension !== null && timeDimension !== void 0 && timeDimension.maxValue && autoUpdateLayerId) {
                 listenerApi.dispatch(layerActions.layerChangeDimension({
                   layerId: autoUpdateLayerId,
@@ -8856,10 +9009,11 @@ mapListener.startListening({
               }
               // Toggle autoupdate off for synced timesliders
               payloads = syncedMapIds.reduce(function (syncedMapIdList, syncedMapId) {
-                if (syncedMapId !== mapId) {
+                if (syncedMapId !== mapId && isAutoUpdating(listenerApi.getState(), syncedMapId)) {
                   return syncedMapIdList.concat({
                     mapId: syncedMapId,
-                    shouldAutoUpdate: false
+                    shouldAutoUpdate: false,
+                    origin: origin
                   });
                 }
                 return syncedMapIdList;
@@ -8884,9 +9038,35 @@ mapListener.startListening({
   }()
 });
 mapListener.startListening({
-  actionCreator: mapActions.mapStartAnimation,
+  actionCreator: genericActions.syncGroupAddTarget,
+  // When maps that auto update are synced, only the top one in the sync list keeps auto update
   effect: function effect(_ref4, listenerApi) {
     var payload = _ref4.payload;
+    var state = listenerApi.getState();
+    var group = getSynchronizationGroup(state, payload.groupId);
+    if ((group === null || group === void 0 ? void 0 : group.type) !== SYNCGROUPS_TYPE_SETTIME) {
+      return;
+    }
+    var _getMapIdsInSyncListO = getMapIdsInSyncListOrder(state, group.targets.allIds).filter(function (syncedMapId) {
+        return isAutoUpdating(state, syncedMapId);
+      }),
+      _getMapIdsInSyncListO2 = _toArray(_getMapIdsInSyncListO),
+      lowerAutoUpdatingMapIds = _arrayLikeToArray(_getMapIdsInSyncListO2).slice(1);
+    // mark the presets of affected maps as changed when the user synced the maps
+    var origin = payload.origin === 'user' ? MapActionOrigin.map : undefined;
+    lowerAutoUpdatingMapIds.forEach(function (lowerMapId) {
+      return listenerApi.dispatch(mapActions.toggleAutoUpdate({
+        mapId: lowerMapId,
+        shouldAutoUpdate: false,
+        origin: origin
+      }));
+    });
+  }
+});
+mapListener.startListening({
+  actionCreator: mapActions.mapStartAnimation,
+  effect: function effect(_ref5, listenerApi) {
+    var payload = _ref5.payload;
     var mapId = payload.mapId,
       initialTime = payload.initialTime;
     // Check if the mapId is part of a syncgroup
@@ -8915,8 +9095,8 @@ mapListener.startListening({
 });
 mapListener.startListening({
   actionCreator: mapActions.mapStopAnimation,
-  effect: function effect(_ref5, listenerApi) {
-    var mapId = _ref5.payload.mapId;
+  effect: function effect(_ref6, listenerApi) {
+    var mapId = _ref6.payload.mapId;
     // Check if the mapId is part of a syncgroup
     var syncedMapIds = getSyncedMapIdsForTimeslider(listenerApi.getState());
     var isSyncedMap = syncedMapIds.includes(mapId);
@@ -8959,12 +9139,12 @@ var handleBaseLayers = function handleBaseLayers(mapId, baseLayers, listenerApi)
 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, animationDuration, animationLengthSetting, animationEndTime, shouldEndtimeOverride, interval, timeAlreadySet, mode, endTimeFromPreset, endTime, startTime, hasNoAnimationDetails, defaultAnimationLengthSetting, effectiveAnimationLengthSetting, animationLength, animationStartTime, _autoTimeStepLayerId, layerRefTimeDimension, referenceTimeFromLayer, anchorTime, resolvedRange, shouldOpenLegend, dockedLayerManagerType, _t;
+    var _effect2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(_ref7, 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, animationDuration, animationLengthSetting, animationEndTime, shouldEndtimeOverride, interval, timeAlreadySet, mode, endTimeFromPreset, endTime, startTime, hasNoAnimationDetails, defaultAnimationLengthSetting, effectiveAnimationLengthSetting, animationLength, animationStartTime, anchorInputs, resolvedRange, shouldOpenLegend, dockedLayerManagerType, _t;
       return _regenerator().w(function (_context2) {
         while (1) switch (_context2.p = _context2.n) {
           case 0:
-            payload = _ref6.payload;
+            payload = _ref7.payload;
             _context2.p = 1;
             mapId = payload.mapId, initialProps = payload.initialProps;
             mapPreset = initialProps.mapPreset;
@@ -9081,10 +9261,10 @@ mapListener.startListening({
               }));
             }
             if (shouldAutoUpdate !== undefined && !animationEndTime) {
-              //  auto update
+              //  auto update, unless a synced map higher in the sync list already auto updates
               listenerApi.dispatch(mapActions.toggleAutoUpdate({
                 mapId: mapId,
-                shouldAutoUpdate: shouldAutoUpdate
+                shouldAutoUpdate: shouldAutoUpdate && !isHigherSyncedMapAutoUpdating(listenerApi.getState(), mapId)
               }));
             }
             if (showTimeSlider !== undefined) {
@@ -9261,11 +9441,8 @@ mapListener.startListening({
                   }));
                 }
               } 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;
+                anchorInputs = getAnimationAnchorInputs(listenerApi.getState(), mapId);
+                resolvedRange = isAnchoredMode(animationLength.mode) && isValidAnimationLength(animationLength, anchorInputs) ? resolveAnimationRange(animationLength, anchorInputs) : undefined;
                 listenerApi.dispatch(mapActions.setAnimationLength(_objectSpread2(_objectSpread2({
                   mapId: mapId,
                   animationLength: animationLength
@@ -9380,55 +9557,35 @@ mapListener.startListening({
     return effect;
   }()
 });
-/**
- * Re-resolving on a short interval keeps a range that follows the clock correct without
- * tracking what it depends on: Now slides every tick, a recurring period only rolls at
- * midnight UTC, and a tick that resolves an unchanged range leaves the state untouched.
- */
-var ANIMATION_RANGE_REFRESH_INTERVAL = 1000 * 60 * 5;
-/* Newest loop per map wins; older loops see a stale token and exit. */
-var animationRangeRefreshTokens = new Map();
 mapListener.startListening({
   actionCreator: mapActions.setAnimationLength,
   effect: function () {
-    var _effect3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(_ref7, listenerApi) {
-      var payload, mapId, refreshToken, isNewestRefreshLoop, getRefreshableAnimationLength, animationLength;
+    var _effect3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(_ref8, listenerApi) {
+      var payload, mapId, endingAction;
       return _regenerator().w(function (_context3) {
         while (1) switch (_context3.n) {
           case 0:
-            payload = _ref7.payload;
+            payload = _ref8.payload;
             mapId = payload.mapId;
             if (isAnimating(listenerApi.getState(), mapId)) {
               setStep(mapId, -1);
             }
-            refreshToken = Symbol(mapId);
-            animationRangeRefreshTokens.set(mapId, refreshToken);
-            isNewestRefreshLoop = function isNewestRefreshLoop() {
-              return animationRangeRefreshTokens.get(mapId) === refreshToken;
-            };
-            getRefreshableAnimationLength = function getRefreshableAnimationLength() {
-              var animationLength = getAnimationLength(listenerApi.getState(), mapId);
-              var timeStep = getMapTimeStep(listenerApi.getState(), mapId);
-              return isAnchoredMode(animationLength === null || animationLength === void 0 ? void 0 : animationLength.mode) && animationLength && isValidAnimationLength(animationLength) && isWithinAnimationStepLimit(animationLength, timeStep) ? animationLength : undefined;
-            };
           case 1:
-            if (!(isNewestRefreshLoop() && getRefreshableAnimationLength())) {
+            if (!hasAnchoredAnimationLength(listenerApi.getState(), mapId)) {
               _context3.n = 4;
               break;
             }
             _context3.n = 2;
-            return listenerApi.delay(ANIMATION_RANGE_REFRESH_INTERVAL);
+            return listenerApi.take(endsAnimationClockOf(mapId), ANIMATION_CLOCK_INTERVAL);
           case 2:
-            animationLength = getRefreshableAnimationLength();
-            if (!(!isNewestRefreshLoop() || !animationLength)) {
+            endingAction = _context3.v;
+            if (!endingAction) {
               _context3.n = 3;
               break;
             }
             return _context3.a(2);
           case 3:
-            listenerApi.dispatch(mapActions.refreshAnimationRange(_objectSpread2({
-              mapId: mapId
-            }, resolveAnimationRange(animationLength))));
+            reconcileAnimationRange(mapId, listenerApi);
             _context3.n = 1;
             break;
           case 4:
@@ -9444,31 +9601,30 @@ mapListener.startListening({
 });
 mapListener.startListening({
   actionCreator: mapActions.setAnimationStartTime,
-  effect: function effect(_ref8, listenerApi) {
-    var payload = _ref8.payload;
+  effect: function effect(_ref9, listenerApi) {
+    var payload = _ref9.payload;
     preserveAnimationStep(payload.mapId, listenerApi);
   }
 });
 mapListener.startListening({
   actionCreator: mapActions.setAnimationEndTime,
-  effect: function effect(_ref9, listenerApi) {
-    var payload = _ref9.payload;
+  effect: function effect(_ref0, listenerApi) {
+    var payload = _ref0.payload;
     preserveAnimationStep(payload.mapId, listenerApi);
   }
 });
 mapListener.startListening({
   actionCreator: mapActions.refreshAnimationRange,
-  effect: function effect(_ref0, listenerApi) {
-    var payload = _ref0.payload;
+  effect: function effect(_ref1, listenerApi) {
+    var payload = _ref1.payload;
     preserveAnimationStep(payload.mapId, listenerApi);
   }
 });
 mapListener.startListening({
   actionCreator: mapActions.unregisterMap,
-  effect: function effect(_ref1, listenerApi) {
-    var payload = _ref1.payload;
+  effect: function effect(_ref10, listenerApi) {
+    var payload = _ref10.payload;
     var mapId = payload.mapId;
-    animationRangeRefreshTokens["delete"](mapId);
     var layerList = getLayersByMapId(listenerApi.getState(), mapId);
     metronome.unregister(mapId);
     layerList.map(function (layer) {
@@ -9485,8 +9641,8 @@ mapListener.startListening({
 });
 mapListener.startListening({
   actionCreator: mapActions.setStepBackwardOrForward,
-  effect: function effect(_ref10, listenerApi) {
-    var payload = _ref10.payload;
+  effect: function effect(_ref11, listenerApi) {
+    var payload = _ref11.payload;
     var mapId = payload.mapId,
       isForwardStep = payload.isForwardStep;
     // timeStep is stored in minutes
@@ -9499,6 +9655,11 @@ mapListener.startListening({
     var hasValidDataStartTime = Number.isFinite(dataStartTime) && dataStartTime > 0 && dataStartTime < 2147483647;
     var hasValidDataEndTime = Number.isFinite(dataEndTime) && dataEndTime > 0;
     if (dateUtils.isValid(currentTime)) {
+      var _layerSelectors$getLa;
+      var state = listenerApi.getState();
+      var autoTimeStepLayerId = getAutoTimeStepLayerId(state, mapId);
+      var autoTimeStepValues = isTimestepAuto(state, mapId) && autoTimeStepLayerId ? (_layerSelectors$getLa = getLayerTimeDimension(state, autoTimeStepLayerId)) === null || _layerSelectors$getLa === void 0 ? void 0 : _layerSelectors$getLa.values : undefined;
+      var isIrregularTimeList = !!autoTimeStepValues && !autoTimeStepValues.includes('/');
       var makeForwardStep = function makeForwardStep() {
         // timeStep is in minutes, convert to seconds
         var timeStepInSeconds = timeStep * 60;
@@ -9520,7 +9681,17 @@ mapListener.startListening({
         var newTime = hasValidDataStartTime ? Math.max(roundedTime, dataStartTime) : roundedTime;
         return dateUtils.fromUnix(newTime).toISOString();
       };
-      var selectedTimeString = isForwardStep ? makeForwardStep() : makeBackwardStep();
+      var adjacentTime = isIrregularTimeList ? getAdjacentTimeValue(autoTimeStepValues, currentTime, !!isForwardStep) : undefined;
+      if (isIrregularTimeList && adjacentTime === undefined) {
+        return;
+      }
+      var getSelectedTimeString = function getSelectedTimeString() {
+        if (adjacentTime !== undefined) {
+          return dateUtils.fromUnix(adjacentTime).toISOString();
+        }
+        return isForwardStep ? makeForwardStep() : makeBackwardStep();
+      };
+      var selectedTimeString = getSelectedTimeString();
       var isMapAnimating = isAnimating(listenerApi.getState(), mapId);
       if (isMapAnimating) {
         listenerApi.dispatch(mapActions.mapStopAnimation({
@@ -9538,32 +9709,6 @@ mapListener.startListening({
     }
   }
 });
-var updateReferenceTimeAnimationRange = function updateReferenceTimeAnimationRange(mapId, layerId, referenceTime, listenerApi) {
-  var animationLength = getAnimationLength(listenerApi.getState(), mapId);
-  var autoTimeStepLayerId = getAutoTimeStepLayerId(listenerApi.getState(), mapId);
-  if (autoTimeStepLayerId !== layerId || (animationLength === null || animationLength === void 0 ? void 0 : animationLength.mode) !== AnimationLengthMode.ReferenceTime) {
-    return;
-  }
-  var anchorTime = dateUtils.utc(referenceTime);
-  var resolvedRange = resolveAnimationRange(animationLength, anchorTime);
-  listenerApi.dispatch(mapActions.setAnimationLength(_objectSpread2({
-    mapId: mapId,
-    animationLength: animationLength
-  }, resolvedRange)));
-};
-mapListener.startListening({
-  actionCreator: layerActions.layerChangeDimension,
-  effect: function effect(_ref11, listenerApi) {
-    var payload = _ref11.payload;
-    var mapId = payload.mapId,
-      layerId = payload.layerId,
-      dimension = payload.dimension;
-    if (!mapId || dimension.name !== 'reference_time') {
-      return;
-    }
-    updateReferenceTimeAnimationRange(mapId, layerId, dimension.currentValue, listenerApi);
-  }
-});
 var updateAnimationMode = function updateAnimationMode(mapId, listenerApi) {
   var _autoTimeStepLayer$di;
   var previousAutoTimeStepLayerId = getAutoTimeStepLayerId(listenerApi.getOriginalState(), mapId);
@@ -9580,7 +9725,9 @@ var updateAnimationMode = function updateAnimationMode(mapId, listenerApi) {
     listenerApi.dispatch(mapActions.setAnimationLength(_objectSpread2({
       mapId: mapId,
       animationLength: animationLength
-    }, resolveAnimationRange(animationLength, dateUtils.utc(referenceTimeDimension.currentValue)))));
+    }, resolveAnimationRange(animationLength, {
+      referenceTime: referenceTimeDimension.currentValue
+    }))));
     return;
   }
   var nextAnimationLength = autoTimeStepLayerId ? {
@@ -9589,7 +9736,8 @@ var updateAnimationMode = function updateAnimationMode(mapId, listenerApi) {
     mode: AnimationLengthMode.Now,
     now: defaultOffsetSelections
   };
-  var resolvedRange = nextAnimationLength.mode === AnimationLengthMode.Now && isValidAnimationLength(nextAnimationLength) ? resolveAnimationRange(nextAnimationLength) : undefined;
+  var anchorInputs = getAnimationAnchorInputs(listenerApi.getState(), mapId);
+  var resolvedRange = nextAnimationLength.mode === AnimationLengthMode.Now && isValidAnimationLength(nextAnimationLength, anchorInputs) ? resolveAnimationRange(nextAnimationLength, anchorInputs) : undefined;
   listenerApi.dispatch(mapActions.setAnimationLength(_objectSpread2({
     mapId: mapId,
     animationLength: nextAnimationLength
@@ -9609,6 +9757,16 @@ mapListener.startListening({
     updateAnimationMode(mapId, listenerApi);
   }
 });
+/* Last, so the range is resolved after the listeners above have settled the setting. */
+mapListener.startListening({
+  matcher: isAnyOf(mapActions.setAnimationLength, mapActions.setTimeStep, mapActions.setAutoLayerId, mapActions.setAutoTimestepLayerId, layerActions.layerDelete, layerActions.onUpdateLayerInformation, layerActions.layerChangeDimension),
+  effect: function effect(action, listenerApi) {
+    var mapId = mapIdToReconcile(action, listenerApi.getState());
+    if (mapId) {
+      reconcileAnimationRange(mapId, listenerApi, isSyncSkippedBy(action));
+    }
+  }
+});
 
 var copyView = function copyView(view) {
   return new View({
@@ -9815,21 +9973,59 @@ var fetchSTACLayers = /*#__PURE__*/function () {
     return _ref.apply(this, arguments);
   };
 }();
+var fetchEDRLayers = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(serviceUrl) {
+    var _data$collections;
+    var baseUrl, data;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          baseUrl = serviceUrl.endsWith('/') ? serviceUrl.slice(0, -1) : serviceUrl;
+          _context2.n = 1;
+          return fetchEDRJson("".concat(baseUrl, "/collections"));
+        case 1:
+          data = _context2.v;
+          return _context2.a(2, ((_data$collections = data.collections) !== null && _data$collections !== void 0 ? _data$collections : []).flatMap(function (collection) {
+            var _collection$parameter;
+            return Object.entries((_collection$parameter = collection.parameter_names) !== null && _collection$parameter !== void 0 ? _collection$parameter : {}).map(function (_ref3) {
+              var _parameter$label, _ref5, _collection$path, _collection$title, _parameter$observedPr, _parameter$label2;
+              var _ref4 = _slicedToArray(_ref3, 2),
+                parameterId = _ref4[0],
+                parameter = _ref4[1];
+              return {
+                name: parameterId,
+                title: (_parameter$label = parameter.label) !== null && _parameter$label !== void 0 ? _parameter$label : parameterId,
+                leaf: true,
+                path: [].concat(_toConsumableArray((_ref5 = (_collection$path = collection.path) !== null && _collection$path !== void 0 ? _collection$path : collection.groups) !== null && _ref5 !== void 0 ? _ref5 : collection.group ? [collection.group] : []), [(_collection$title = collection.title) !== null && _collection$title !== void 0 ? _collection$title : collection.id]),
+                keywords: (_parameter$observedPr = parameter.observedProperty) !== null && _parameter$observedPr !== void 0 && _parameter$observedPr.label ? [normalizeEDRLabel(parameter.observedProperty.label, (_parameter$label2 = parameter.label) !== null && _parameter$label2 !== void 0 ? _parameter$label2 : parameterId)] : [],
+                edrCollectionId: collection.id,
+                edrParameter: parameter,
+                styles: defaultEdrStyles
+              };
+            });
+          }));
+      }
+    }, _callee2);
+  }));
+  return function fetchEDRLayers(_x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
 var dispatchServiceLayers = function dispatchServiceLayers(service, layers, listenerApi) {
   listenerApi.dispatch(serviceActions.serviceSetLayers(_objectSpread2(_objectSpread2({}, service), {}, {
     layers: layers
   })));
 };
 var fetchSTACService = /*#__PURE__*/function () {
-  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(service, listenerApi) {
+  var _ref6 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(service, listenerApi) {
     var _yield$Promise$all, _yield$Promise$all2, root, layers;
-    return _regenerator().w(function (_context2) {
-      while (1) switch (_context2.n) {
+    return _regenerator().w(function (_context3) {
+      while (1) switch (_context3.n) {
         case 0:
-          _context2.n = 1;
+          _context3.n = 1;
           return Promise.all([fetchStacCatalogRoot(service.serviceUrl), fetchSTACLayers(service.serviceUrl)]);
         case 1:
-          _yield$Promise$all = _context2.v;
+          _yield$Promise$all = _context3.v;
           _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
           root = _yield$Promise$all2[0];
           layers = _yield$Promise$all2[1];
@@ -9839,117 +10035,139 @@ var fetchSTACService = /*#__PURE__*/function () {
             type: 'STAC'
           }), layers, listenerApi);
         case 2:
-          return _context2.a(2);
+          return _context3.a(2);
       }
-    }, _callee2);
+    }, _callee3);
   }));
-  return function fetchSTACService(_x2, _x3) {
-    return _ref2.apply(this, arguments);
+  return function fetchSTACService(_x3, _x4) {
+    return _ref6.apply(this, arguments);
   };
 }();
 var fetchService = /*#__PURE__*/function () {
-  var _ref3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(service, listenerApi) {
-    var layers, _t;
-    return _regenerator().w(function (_context3) {
-      while (1) switch (_context3.p = _context3.n) {
+  var _ref7 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(service, listenerApi) {
+    var layers, _layers, _t, _t2;
+    return _regenerator().w(function (_context4) {
+      while (1) switch (_context4.p = _context4.n) {
         case 0:
-          if (!(service.type === 'STAC')) {
-            _context3.n = 2;
+          if (!(service.type === 'EDR')) {
+            _context4.n = 5;
             break;
           }
-          _context3.n = 1;
-          return fetchSTACService(service, listenerApi);
-        case 1:
-          return _context3.a(2);
+          _context4.p = 1;
+          _context4.n = 2;
+          return fetchEDRLayers(service.serviceUrl);
         case 2:
-          _context3.p = 2;
-          _context3.n = 3;
-          return queryWMSLayers(service.serviceUrl);
-        case 3:
-          layers = _context3.v;
+          layers = _context4.v;
           dispatchServiceLayers(service, layers, listenerApi);
-          _context3.n = 5;
+          _context4.n = 4;
           break;
-        case 4:
-          _context3.p = 4;
-          _t = _context3.v;
+        case 3:
+          _context4.p = 3;
+          _t = _context4.v;
           if (_t instanceof Error) {
             console.warn(_t.message);
           }
+          dispatchServiceLayers(service, [], listenerApi);
+        case 4:
+          return _context4.a(2);
         case 5:
-          return _context3.a(2);
+          if (!(service.type === 'STAC')) {
+            _context4.n = 7;
+            break;
+          }
+          _context4.n = 6;
+          return fetchSTACService(service, listenerApi);
+        case 6:
+          return _context4.a(2);
+        case 7:
+          _context4.p = 7;
+          _context4.n = 8;
+          return queryWMSLayers(service.serviceUrl);
+        case 8:
+          _layers = _context4.v;
+          dispatchServiceLayers(service, _layers, listenerApi);
+          _context4.n = 10;
+          break;
+        case 9:
+          _context4.p = 9;
+          _t2 = _context4.v;
+          if (_t2 instanceof Error) {
+            console.warn(_t2.message);
+          }
+        case 10:
+          return _context4.a(2);
       }
-    }, _callee3, null, [[2, 4]]);
+    }, _callee4, null, [[7, 9], [1, 3]]);
   }));
-  return function fetchService(_x4, _x5) {
-    return _ref3.apply(this, arguments);
+  return function fetchService(_x5, _x6) {
+    return _ref7.apply(this, arguments);
   };
 }();
 var fetchInitialServices = /*#__PURE__*/function () {
-  var _ref4 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(payload, listenerApi) {
-    var _t2;
-    return _regenerator().w(function (_context5) {
-      while (1) switch (_context5.p = _context5.n) {
+  var _ref8 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(payload, listenerApi) {
+    var _t3;
+    return _regenerator().w(function (_context6) {
+      while (1) switch (_context6.p = _context6.n) {
         case 0:
           if (payload !== null && payload !== void 0 && payload.services) {
-            _context5.n = 1;
+            _context6.n = 1;
             break;
           }
-          return _context5.a(2);
+          return _context6.a(2);
         case 1:
-          _context5.p = 1;
-          _context5.n = 2;
+          _context6.p = 1;
+          _context6.n = 2;
           return Promise.all(payload.services.map(/*#__PURE__*/function () {
-            var _ref6 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(_ref5) {
+            var _ref0 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(_ref9) {
               var url, service;
-              return _regenerator().w(function (_context4) {
-                while (1) switch (_context4.n) {
+              return _regenerator().w(function (_context5) {
+                while (1) switch (_context5.n) {
                   case 0:
-                    url = _ref5.url, service = _objectWithoutProperties(_ref5, _excluded);
-                    return _context4.a(2, fetchService(_objectSpread2(_objectSpread2({}, service), {}, {
+                    url = _ref9.url, service = _objectWithoutProperties(_ref9, _excluded);
+                    return _context5.a(2, fetchService(_objectSpread2(_objectSpread2({}, service), {}, {
                       serviceUrl: url
                     }), listenerApi));
                 }
-              }, _callee4);
+              }, _callee5);
             }));
-            return function (_x8) {
-              return _ref6.apply(this, arguments);
+            return function (_x9) {
+              return _ref0.apply(this, arguments);
             };
           }()));
         case 2:
-          _context5.n = 4;
+          _context6.n = 4;
           break;
         case 3:
-          _context5.p = 3;
-          _t2 = _context5.v;
-          console.warn(_t2);
+          _context6.p = 3;
+          _t3 = _context6.v;
+          console.warn(_t3);
         case 4:
-          return _context5.a(2);
+          return _context6.a(2);
       }
-    }, _callee5, null, [[1, 3]]);
+    }, _callee6, null, [[1, 3]]);
   }));
-  return function fetchInitialServices(_x6, _x7) {
-    return _ref4.apply(this, arguments);
+  return function fetchInitialServices(_x7, _x8) {
+    return _ref8.apply(this, arguments);
   };
 }();
 serviceListener.startListening({
   actionCreator: serviceActions.fetchInitialServices,
   effect: function () {
-    var _effect = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(_ref7, listenerApi) {
+    var _effect = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(_ref1, listenerApi) {
       var payload;
-      return _regenerator().w(function (_context6) {
-        while (1) switch (_context6.n) {
+      return _regenerator().w(function (_context7) {
+        while (1) switch (_context7.n) {
           case 0:
-            payload = _ref7.payload;
+            payload = _ref1.payload;
             listenerApi.cancelActiveListeners();
-            _context6.n = 1;
+            _context7.n = 1;
             return fetchInitialServices(payload, listenerApi);
           case 1:
-            return _context6.a(2);
+            return _context7.a(2);
         }
-      }, _callee6);
+      }, _callee7);
     }));
-    function effect(_x9, _x0) {
+    function effect(_x0, _x1) {
       return _effect.apply(this, arguments);
     }
     return effect;

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

@@ -4,6 +4,7 @@ import type { Dimension, ReduxLayer } from '../types';
 import type { LayerState } from './types';
 export declare const trimTrailingSlashes: (url: string) => string;
 export declare const getSTACServiceRootUrl: (serviceUrl: string) => string;
+export declare const getEDRServiceRootUrl: (serviceUrl: string) => string;
 export declare const getTrailingSlashVariant: (url: string) => string;
 /**
  * Generates a unique id for a geoJSON feature. Feature ids need to be stable

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

@@ -0,0 +1,10 @@
+import type { ListenerEffectAPI, ThunkDispatch, UnknownAction } from '@reduxjs/toolkit';
+import type { WebMapStateModuleState } from '../types';
+type MapListenerApi = ListenerEffectAPI<WebMapStateModuleState, ThunkDispatch<WebMapStateModuleState, unknown, UnknownAction>, unknown>;
+export declare const ANIMATION_CLOCK_INTERVAL: number;
+export declare const reconcileAnimationRange: (mapId: string, listenerApi: MapListenerApi, skipSync?: boolean) => void;
+export declare const mapIdToReconcile: (action: UnknownAction, state: WebMapStateModuleState) => string | undefined;
+export declare const isSyncSkippedBy: (action: UnknownAction) => boolean;
+export declare const hasAnchoredAnimationLength: (state: WebMapStateModuleState, mapId: string) => boolean;
+export declare const endsAnimationClockOf: (mapId: string) => (action: UnknownAction) => boolean;
+export {};

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

@@ -14,6 +14,7 @@ export declare const mapUtils: {
     getSpeedFactor: (speedDelay: number) => import("libs/time-slider/dist").SpeedFactorType;
     getAnimationDuration: (animationEndTime: string | undefined, animationStartTime: string | undefined) => number;
     generateAnimationList: (unixAnimationStart: number, unixAnimationEnd: number, timeValues: string | undefined, animationInterval?: number) => mapTypes.WebMapAnimationList;
+    getAdjacentTimeValue: (timeValues: string | undefined, currentUnix: number, isForwardStep: boolean) => number | undefined;
     parseTimeDimToISO8601Interval: (timeInterval: string | undefined) => mapTypes.ISO8601Interval[];
     produceTimeSliderTimeSpan: (draft: import("immer").Draft<mapTypes.WebMapState>, mapId: string, timeSliderSpan: number) => void;
 };

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

@@ -1,4 +1,4 @@
-import type { AnimationLengthSetting } from '@opengeoweb/time-slider';
+import type { AnimationAnchorInputs, AnimationLengthSetting } from '@opengeoweb/time-slider';
 import type { Bbox, ClockPosition, ClockSize, LegendPosition, LegendSize, MapPreset, WebMap, WebMapState } from './types';
 import type { CoreAppStore } from '../../types';
 import { uiTypes } from '../../ui';
@@ -3514,6 +3514,87 @@ export declare const getAnimationRange: ((state: CoreAppStore, mapId: string) =>
     argsMemoize: typeof import("reselect").weakMapMemoize;
     memoize: typeof import("reselect").weakMapMemoize;
 };
+export declare const getAnimationAnchorInputs: ((state: CoreAppStore, mapId: string) => AnimationAnchorInputs) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, ReduxLayer> | null, resultFuncArgs_1: string | undefined, resultFuncArgs_2: number) => AnimationAnchorInputs;
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, ReduxLayer> | null, resultFuncArgs_1: string | undefined, resultFuncArgs_2: number) => AnimationAnchorInputs) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => AnimationAnchorInputs;
+    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;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: 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;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: 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;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
 /**
  * Gets intialViewMapPreset from webmap state
  *

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

@@ -233,6 +233,7 @@ export interface RefreshAnimationRangePayload {
     mapId: string;
     animationStartTime: string;
     animationEndTime: string;
+    skipSync?: boolean;
 }
 export interface ToggleTimeSliderHoverPayload {
     mapId: string;

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

@@ -78,6 +78,11 @@ export declare const getAnimationDuration: (animationEndTime: string | undefined
  * @returns WebMapAnimationList with time points
  */
 export declare const generateAnimationList: (unixAnimationStart: number, unixAnimationEnd: number, timeValues: string | undefined, animationInterval?: number) => WebMapAnimationList;
+/**
+ * Returns the adjacent time (unix seconds) in a comma separated list of time values,
+ * or undefined when the values are empty, contain ISO8601 intervals or there is no adjacent time.
+ */
+export declare const getAdjacentTimeValue: (timeValues: string | undefined, currentUnix: number, isForwardStep: boolean) => number | undefined;
 /**
  * Parses the time dimension values string to an array of ISO8601 intervals
  * @param timeInterval

package/package.json

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