@opengeoweb/store 9.23.1 → 9.24.0

package/index.esm.js

@@ -1,4 +1,4 @@
-import { webmapUtils, LayerType, getWMJSMapById, WMLayer, webmapTestSettings, getWMSRequests, isProjectionSupported, handleDateUtilsISOString, getCapabilities } from '@opengeoweb/webmap';
+import { webmapUtils, LayerType, getWMJSMapById, WMLayer, webmapTestSettings, isProjectionSupported, handleDateUtilsISOString, getCapabilities, getWMSRequests } from '@opengeoweb/webmap';
 import { createAction, createSlice, createSelector, createEntityAdapter, createListenerMiddleware, isAnyOf } from '@reduxjs/toolkit';
 import { getGeoJson, moveFeature, createInterSections, getLastEmptyFeatureIndex, defaultLayers, emptyGeoJSON, addSelectionTypeToGeoJSON, getFeatureCollection, defaultIntersectionStyleProperties } from '@opengeoweb/webmap-react';
 export { defaultLayers } from '@opengeoweb/webmap-react';
@@ -2000,7 +2000,7 @@ var LayerActionOrigin;
   LayerActionOrigin["wmsLoader"] = "WMSLayerTreeConnect";
   LayerActionOrigin["ReactMapViewParseLayer"] = "ReactMapViewParseLayer";
   LayerActionOrigin["setLayerDimensionSaga"] = "setLayerDimensionSaga";
-  LayerActionOrigin["toggleAutoUpdateSaga"] = "toggleAutoUpdateSaga";
+  LayerActionOrigin["toggleAutoUpdateListener"] = "toggleAutoUpdateListener";
   LayerActionOrigin["unregisterMapSaga"] = "unregisterMapSaga";
 })(LayerActionOrigin || (LayerActionOrigin = {}));
 
@@ -7621,115 +7621,6 @@ fixRegExpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNa
   ];
 }, BUGGY || !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);
 
-/* A map with all the timerIds and their current step */
-const stepMap = new Map();
-/* A map with a list of timers and their dwell */
-const timerDwellMap = new Map();
-/**
- * Returns the next step for given timerId.
- * @param timerId The timer id
- * @param numberOfStepsInAnimation Animation length in steps
- * @param numStepsToGoForward Amount of steps to go forwards, defaults to 1. Can be positive and negative
- * @returns
- */
-const getNextStep = (timerId, numberOfStepsInAnimation, numStepsToGoForward = 1) => {
-  const currentStep = getCurrentStep(timerId);
-  const nextStep = currentStep + numStepsToGoForward;
-  const nextStepClipped = (nextStep % numberOfStepsInAnimation + numberOfStepsInAnimation) % numberOfStepsInAnimation;
-  return nextStepClipped;
-};
-/**
- * Handles dwell at the end of the animation loop sequence. The number of steps to wait till proceed can be set by the dwell parameter.
- * @param timerId The timer id
- * @param numberOfStepsInAnimation Number of steps in the animation
- * @param dwell The number of steps to wait at the end of the animation sequence before to continue
- * @returns
- */
-const handleTimerDwell = (timerId, numberOfStepsInAnimation, dwell = 8) => {
-  if (dwell > 0) {
-    const currentStep = getCurrentStep(timerId);
-    // Reset the dwell if we are not at the last animation step
-    if (currentStep < numberOfStepsInAnimation - 1) {
-      timerDwellMap.set(timerId, dwell);
-      return false;
-    }
-    // We are at the last animation step, check the dwell
-    const timerDwell = timerDwellMap.has(timerId) && timerDwellMap.get(timerId) || 0;
-    if (currentStep === numberOfStepsInAnimation - 1 && timerDwell > 0) {
-      timerDwellMap.set(timerId, timerDwell - 1);
-      return true;
-    }
-  }
-  return false;
-};
-/**
- * Set step for the timerId
- * @param timerId
- * @param timerStep
- */
-const setStep = (timerId, timerStep) => {
-  stepMap.set(timerId, timerStep);
-};
-/**
- * Gets the current step for the timer
- * @param timerId
- * @returns
- */
-const getCurrentStep = timerId => {
-  return stepMap.get(timerId) || 0;
-};
-const MAX_NUMBER_STEPS_FORWARD_TO_PREFETCH = 2;
-const MAX_NUMBER_OF_PARALLEL_LOADING_IMAGES = 8;
-/**
- * This prefetches all images connected to the same sync group as provided timerId
- * @param timerId The timerId
- * @param animationListValues List of animation steps in isostring to animate
- * @param targets List of targets to check
- * @returns True if all maps are ready to go forward, false if the map has no data to display yet.
- */
-const prefetchAnimationTargetsForMetronome = (timerId, animationListValues, targets) => {
-  let timerShouldStepForward = true;
-  // The following code prefetches/buffers for all maps in the group
-  for (let numPrefetch = 0; numPrefetch < MAX_NUMBER_STEPS_FORWARD_TO_PREFETCH; numPrefetch += 1) {
-    const nextStep = getNextStep(timerId, animationListValues.length, numPrefetch + 1);
-    const nextTimeValueStepToCheck = animationListValues[nextStep];
-    for (const target of targets) {
-      const targetMapId = target.targetId;
-      const wmMap = getWMJSMapById(targetMapId);
-      if (wmMap) {
-        const layersImageUrls = getWMSRequests(wmMap, [{
-          name: 'time',
-          currentValue: nextTimeValueStepToCheck
-        }]);
-        for (const layersImageUrl of layersImageUrls) {
-          const image = wmMap.getMapImageStore.getImage(layersImageUrl.url);
-          if (!image.isLoaded()) {
-            if (wmMap.getMapImageStore.getNumImagesLoading() < MAX_NUMBER_OF_PARALLEL_LOADING_IMAGES) {
-              image.load();
-            }
-            if (numPrefetch === 0) {
-              const altImage = wmMap.getAlternativeImage(layersImageUrl.url, wmMap.getBBOX(), true);
-              // No alternative image available yet, so skipping animation.
-              if (altImage.length === 0) {
-                // This is useful to indicate that the map is loading and has nothing yet to display.
-                // console.warn('No data available: Not stepping forward');
-                timerShouldStepForward = false;
-              }
-            }
-          } else if (image.isStale()) {
-            if (wmMap.getMapImageStore.getNumImagesLoading() < MAX_NUMBER_OF_PARALLEL_LOADING_IMAGES) {
-              image.forceReload(true);
-            }
-          }
-        }
-      } else {
-        return false; // Map was not registered so there is nothing to prefetch
-      }
-    }
-  }
-  return timerShouldStepForward;
-};
-
 const isAnimationEndTimeValid = animationEndTime => {
   const hasValidPrefix = animationEndTime.split(/[-+]/)[0] === 'NOW' || animationEndTime.split(/[-+]/)[0] === 'TODAY';
   const durationString = animationEndTime.substring(animationEndTime.indexOf('PT') + 2);
@@ -7740,37 +7631,6 @@ const isAnimationEndTimeValid = animationEndTime => {
   const parsedDate = dateUtils.parseISO(animationEndTime);
   return dateUtils.isValid(parsedDate);
 };
-function* startAnimationSaga({
-  payload
-}) {
-  const {
-    mapId,
-    initialTime
-  } = payload;
-  const speedDelay = yield select(getMapAnimationDelay, mapId);
-  const speed = 1000 / (speedDelay || 1);
-  metronome.register(null, speed, mapId);
-  const timeList = yield select(getAnimationList, mapId);
-  // In case of the timeList
-  if (timeList && timeList.length > 0) {
-    // Determine animation step based on initialTime and timeList
-    const initalTimerStep = timeList === null || timeList === void 0 ? void 0 : timeList.findIndex(timeNameValue => {
-      return timeNameValue.value === initialTime;
-    });
-    if (initalTimerStep !== -1) {
-      setStep(mapId, initalTimerStep);
-    }
-  }
-}
-// eslint-disable-next-line require-yield
-function* stopAnimationSaga({
-  payload
-}) {
-  const {
-    mapId
-  } = payload;
-  metronome.unregister(mapId);
-}
 function* deleteLayerSaga({
   payload
 }) {
@@ -7784,7 +7644,7 @@ function* deleteLayerSaga({
     }));
   }
 }
-function* updateAnimation(mapId, maxValue) {
+function* updateAnimation$1(mapId, maxValue) {
   const shouldEndtimeOverride$1 = yield select(shouldEndtimeOverride, mapId);
   if (shouldEndtimeOverride$1 === true) {
     return;
@@ -7862,59 +7722,7 @@ function* setLayerDimensionsSaga({
           }))));
         }
       }
-      yield call$e(updateAnimation, mapId, incomingMaxTime);
-    }
-  } catch (error) {
-    // eslint-disable-next-line no-console
-    console.warn(error);
-  }
-}
-function* toggleAutoUpdateSaga({
-  payload
-}) {
-  const {
-    shouldAutoUpdate,
-    mapId
-  } = payload;
-  if (!shouldAutoUpdate) {
-    return;
-  }
-  try {
-    // go to end of active layer
-    const autoUpdateLayerId = yield select(getAutoUpdateLayerId, mapId);
-    const timeDimension = yield select(getLayerTimeDimension, autoUpdateLayerId);
-    if (timeDimension === null || timeDimension === void 0 ? void 0 : timeDimension.maxValue) {
-      yield put(layerActions.layerChangeDimension({
-        layerId: autoUpdateLayerId,
-        origin: LayerActionOrigin.toggleAutoUpdateSaga,
-        dimension: {
-          name: 'time',
-          currentValue: timeDimension.maxValue
-        }
-      }));
-      // Change time value for all other timesliders that are synced by syncgroups
-      const syncedMapIds = yield select(getSyncedMapIdsForTimeslider);
-      if (syncedMapIds.length > 0) {
-        yield all(syncedMapIds.map(syncedMapId => put(setTime({
-          origin: 'mapStore saga',
-          sourceId: syncedMapId,
-          value: timeDimension.maxValue
-        }))));
-        // When timesliders are synced by syncgrous autoupdate is toggled on, toggle autoupdate off for other timesliders
-        const payloads = syncedMapIds.reduce((syncedMapIdList, syncedMapId) => {
-          if (syncedMapId !== mapId) {
-            return syncedMapIdList.concat({
-              mapId: syncedMapId,
-              shouldAutoUpdate: false
-            });
-          }
-          return syncedMapIdList;
-        }, []);
-        if (payloads.length > 0) {
-          yield all(payloads.map(payload => put(mapActions.toggleAutoUpdate(payload))));
-        }
-      }
-      yield call$e(updateAnimation, mapId, timeDimension.maxValue);
+      yield call$e(updateAnimation$1, mapId, incomingMaxTime);
     }
   } catch (error) {
     // eslint-disable-next-line no-console
@@ -8250,11 +8058,8 @@ function* setStepBackwardOrForwardSaga({
 }
 function* rootSaga$2() {
   // resets IWMJSMap state
-  yield takeLatest(mapActions.mapStopAnimation.type, stopAnimationSaga);
-  yield takeLatest(mapActions.mapStartAnimation.type, startAnimationSaga);
   yield takeLatest(layerActions.layerDelete.type, deleteLayerSaga);
   yield takeLatest(layerActions.onUpdateLayerInformation.type, setLayerDimensionsSaga);
-  yield takeLatest(mapActions.toggleAutoUpdate.type, toggleAutoUpdateSaga);
   yield takeEvery(mapActions.setMapPreset.type, setMapPresetSaga);
   yield takeEvery(mapActions.unregisterMap.type, unregisterMapSaga);
   yield takeEvery(mapActions.setStepBackwardOrForward.type, setStepBackwardOrForwardSaga);
@@ -8290,6 +8095,115 @@ function* rootSaga$1() {
   yield takeEvery(serviceActions.fetchInitialServices, fetchInitialServicesSaga);
 }
 
+/* A map with all the timerIds and their current step */
+const stepMap = new Map();
+/* A map with a list of timers and their dwell */
+const timerDwellMap = new Map();
+/**
+ * Returns the next step for given timerId.
+ * @param timerId The timer id
+ * @param numberOfStepsInAnimation Animation length in steps
+ * @param numStepsToGoForward Amount of steps to go forwards, defaults to 1. Can be positive and negative
+ * @returns
+ */
+const getNextStep = (timerId, numberOfStepsInAnimation, numStepsToGoForward = 1) => {
+  const currentStep = getCurrentStep(timerId);
+  const nextStep = currentStep + numStepsToGoForward;
+  const nextStepClipped = (nextStep % numberOfStepsInAnimation + numberOfStepsInAnimation) % numberOfStepsInAnimation;
+  return nextStepClipped;
+};
+/**
+ * Handles dwell at the end of the animation loop sequence. The number of steps to wait till proceed can be set by the dwell parameter.
+ * @param timerId The timer id
+ * @param numberOfStepsInAnimation Number of steps in the animation
+ * @param dwell The number of steps to wait at the end of the animation sequence before to continue
+ * @returns
+ */
+const handleTimerDwell = (timerId, numberOfStepsInAnimation, dwell = 8) => {
+  if (dwell > 0) {
+    const currentStep = getCurrentStep(timerId);
+    // Reset the dwell if we are not at the last animation step
+    if (currentStep < numberOfStepsInAnimation - 1) {
+      timerDwellMap.set(timerId, dwell);
+      return false;
+    }
+    // We are at the last animation step, check the dwell
+    const timerDwell = timerDwellMap.has(timerId) && timerDwellMap.get(timerId) || 0;
+    if (currentStep === numberOfStepsInAnimation - 1 && timerDwell > 0) {
+      timerDwellMap.set(timerId, timerDwell - 1);
+      return true;
+    }
+  }
+  return false;
+};
+/**
+ * Set step for the timerId
+ * @param timerId
+ * @param timerStep
+ */
+const setStep = (timerId, timerStep) => {
+  stepMap.set(timerId, timerStep);
+};
+/**
+ * Gets the current step for the timer
+ * @param timerId
+ * @returns
+ */
+const getCurrentStep = timerId => {
+  return stepMap.get(timerId) || 0;
+};
+const MAX_NUMBER_STEPS_FORWARD_TO_PREFETCH = 2;
+const MAX_NUMBER_OF_PARALLEL_LOADING_IMAGES = 8;
+/**
+ * This prefetches all images connected to the same sync group as provided timerId
+ * @param timerId The timerId
+ * @param animationListValues List of animation steps in isostring to animate
+ * @param targets List of targets to check
+ * @returns True if all maps are ready to go forward, false if the map has no data to display yet.
+ */
+const prefetchAnimationTargetsForMetronome = (timerId, animationListValues, targets) => {
+  let timerShouldStepForward = true;
+  // The following code prefetches/buffers for all maps in the group
+  for (let numPrefetch = 0; numPrefetch < MAX_NUMBER_STEPS_FORWARD_TO_PREFETCH; numPrefetch += 1) {
+    const nextStep = getNextStep(timerId, animationListValues.length, numPrefetch + 1);
+    const nextTimeValueStepToCheck = animationListValues[nextStep];
+    for (const target of targets) {
+      const targetMapId = target.targetId;
+      const wmMap = getWMJSMapById(targetMapId);
+      if (wmMap) {
+        const layersImageUrls = getWMSRequests(wmMap, [{
+          name: 'time',
+          currentValue: nextTimeValueStepToCheck
+        }]);
+        for (const layersImageUrl of layersImageUrls) {
+          const image = wmMap.getMapImageStore.getImage(layersImageUrl.url);
+          if (!image.isLoaded()) {
+            if (wmMap.getMapImageStore.getNumImagesLoading() < MAX_NUMBER_OF_PARALLEL_LOADING_IMAGES) {
+              image.load();
+            }
+            if (numPrefetch === 0) {
+              const altImage = wmMap.getAlternativeImage(layersImageUrl.url, wmMap.getBBOX(), true);
+              // No alternative image available yet, so skipping animation.
+              if (altImage.length === 0) {
+                // This is useful to indicate that the map is loading and has nothing yet to display.
+                // console.warn('No data available: Not stepping forward');
+                timerShouldStepForward = false;
+              }
+            }
+          } else if (image.isStale()) {
+            if (wmMap.getMapImageStore.getNumImagesLoading() < MAX_NUMBER_OF_PARALLEL_LOADING_IMAGES) {
+              image.forceReload(true);
+            }
+          }
+        }
+      } else {
+        return false; // Map was not registered so there is nothing to prefetch
+      }
+    }
+  }
+  return timerShouldStepForward;
+};
+
 /**
  * This handler is triggered by the metronome. An array of timerIds is given as argument.
  * It will update the animation loop of multiple maps and sliders
@@ -8447,10 +8361,130 @@ mapUiListener.startListening({
             setOpen: false
           }));
         }
-      });
+      });
+    }
+  })
+});
+
+const mapListener = createListenerMiddleware();
+const updateAnimation = (mapId, maxValue, listenerApi) => {
+  const shouldEndtimeOverride$1 = shouldEndtimeOverride(listenerApi.getState(), mapId);
+  if (shouldEndtimeOverride$1 === true) {
+    return;
+  }
+  const animationStart = getAnimationStartTime(listenerApi.getState(), mapId);
+  // Calculate how much time the animation start need to move forwards
+  const animationEnd = getAnimationEndTime(listenerApi.getState(), mapId);
+  const animationEndUnix = dateUtils.unix(dateUtils.utc(animationEnd));
+  const maxTimeAsUnix = dateUtils.unix(dateUtils.utc(maxValue));
+  const timeInSecondToShiftAnimationForwards = maxTimeAsUnix - animationEndUnix;
+  const animationStartUnix = dateUtils.unix(dateUtils.utc(animationStart));
+  const newAnimationStartTime = dateUtils.dateToString(dateUtils.fromUnix(animationStartUnix + timeInSecondToShiftAnimationForwards), dateFormat);
+  const newAnimationEndTime = dateUtils.dateToString(dateUtils.fromUnix(animationEndUnix + timeInSecondToShiftAnimationForwards), dateFormat);
+  if (!newAnimationStartTime || !newAnimationEndTime) {
+    return;
+  }
+  listenerApi.dispatch(mapActions.setAnimationEndTime({
+    mapId,
+    animationEndTime: newAnimationEndTime
+  }));
+  listenerApi.dispatch(mapActions.setAnimationStartTime({
+    mapId,
+    animationStartTime: newAnimationStartTime
+  }));
+};
+mapListener.startListening({
+  actionCreator: mapActions.toggleAutoUpdate,
+  effect: ({
+    payload
+  }, listenerApi) => __awaiter(void 0, void 0, void 0, function* () {
+    listenerApi.cancelActiveListeners();
+    const {
+      shouldAutoUpdate,
+      mapId
+    } = payload;
+    if (!shouldAutoUpdate) {
+      return;
+    }
+    try {
+      const autoUpdateLayerId = getAutoUpdateLayerId(listenerApi.getState(), mapId);
+      const timeDimension = getLayerTimeDimension(listenerApi.getState(), autoUpdateLayerId);
+      const syncedMapIds = getSyncedMapIdsForTimeslider(listenerApi.getState());
+      // go to end of active layer
+      if ((timeDimension === null || timeDimension === void 0 ? void 0 : timeDimension.maxValue) && autoUpdateLayerId) {
+        listenerApi.dispatch(layerActions.layerChangeDimension({
+          layerId: autoUpdateLayerId,
+          origin: LayerActionOrigin.toggleAutoUpdateListener,
+          dimension: {
+            name: 'time',
+            currentValue: timeDimension.maxValue
+          }
+        }));
+        // Change time value for all timesliders that are synced by syncgroups
+        if (syncedMapIds.length > 0) {
+          syncedMapIds.map(syncedMapId => listenerApi.dispatch(setTime({
+            origin: LayerActionOrigin.toggleAutoUpdateListener,
+            sourceId: syncedMapId,
+            value: timeDimension.maxValue
+          })));
+        }
+        updateAnimation(mapId, timeDimension.maxValue, listenerApi);
+      }
+      // Toggle autoupdate off for synced timesliders
+      const payloads = syncedMapIds.reduce((syncedMapIdList, syncedMapId) => {
+        if (syncedMapId !== mapId) {
+          return syncedMapIdList.concat({
+            mapId: syncedMapId,
+            shouldAutoUpdate: false
+          });
+        }
+        return syncedMapIdList;
+      }, []);
+      if (payloads.length > 0) {
+        payloads.map(payload => listenerApi.dispatch(mapActions.toggleAutoUpdate(payload)));
+      }
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.warn(error);
     }
   })
 });
+mapListener.startListening({
+  actionCreator: mapActions.mapStartAnimation,
+  effect: ({
+    payload
+  }, listenerApi) => {
+    const {
+      mapId,
+      initialTime
+    } = payload;
+    const speedDelay = getMapAnimationDelay(listenerApi.getState(), mapId);
+    const speed = 1000 / (speedDelay || 1);
+    metronome.register(null, speed, mapId);
+    const timeList = getAnimationList(listenerApi.getState(), mapId);
+    // In case of the timeList
+    if (timeList && timeList.length > 0) {
+      // Determine animation step based on initialTime and timeList
+      const initalTimerStep = timeList === null || timeList === void 0 ? void 0 : timeList.findIndex(timeNameValue => {
+        return timeNameValue.value === initialTime;
+      });
+      if (initalTimerStep !== -1) {
+        setStep(mapId, initalTimerStep);
+      }
+    }
+  }
+});
+mapListener.startListening({
+  actionCreator: mapActions.mapStopAnimation,
+  effect: ({
+    payload
+  }) => {
+    const {
+      mapId
+    } = payload;
+    metronome.unregister(mapId);
+  }
+});
 
 // TODO: This fixes typecheck errors but maybe there is a better way to do that
 createStore$1({
@@ -8465,7 +8499,7 @@ const mapStoreModuleConfig = {
   id: 'webmap-module',
   reducersMap: mapStoreReducers,
   sagas: [rootSaga$2, rootSaga$1],
-  middlewares: [metronomeListener.middleware, layersListener.middleware, mapUiListener.middleware]
+  middlewares: [metronomeListener.middleware, layersListener.middleware, mapUiListener.middleware, mapListener.middleware]
 };
 
 const mapStoreActions = Object.assign(Object.assign(Object.assign({}, layerActions), mapActions), serviceActions);
@@ -8664,132 +8698,55 @@ const getMapBaseLayerActionsTargets = (state, payload, actionType) => {
 };
 
 const setTimeValidatorRexexp = /^(19|20)\d\d-(0[1-9]|1[012])-([012]\d|3[01])T([01]\d|2[0-3]):([0-5]\d):([0-5]\d)Z$/;
-function* setTimeSaga({
-  payload
-}) {
-  const {
-    value,
-    origin
-  } = payload;
-  /* Test if the value is according to the expected time format */
-  if (!setTimeValidatorRexexp.test(value)) {
-    console.error(`setTime value ${value} does not conform to format [YYYY-MM-DDThh:mm:ssZ]. It was triggered by ${origin}`);
-  } else {
-    const targets = yield select(getTargets, payload, SYNCGROUPS_TYPE_SETTIME);
-    const groups = yield select(getTargetGroups, payload, SYNCGROUPS_TYPE_SETTIME);
-    yield put(setTimeSync(payload, targets, groups));
-  }
-}
-function* setBBoxSaga({
-  payload
-}) {
-  const targets = yield select(getTargets, payload, SYNCGROUPS_TYPE_SETBBOX);
-  const groups = yield select(getTargetGroups, payload, SYNCGROUPS_TYPE_SETBBOX);
-  yield put(setBboxSync(payload, targets, groups));
-}
-function* layerActionsSaga({
-  payload,
-  type
-}) {
-  /* Should not listen to actions from itself */
-  if (payload && payload.origin === LayerActionOrigin.ReactMapViewParseLayer) {
-    return;
-  }
-  const targets = yield select(getLayerActionsTargets, payload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
-  if (targets && targets.length > 0) {
-    yield put(setLayerActionSync(payload, targets, type));
-  }
-}
-function* addLayerActionsSaga({
-  payload,
-  type
-}) {
-  /* Should not listen to actions from itself */
-  if (payload && payload.origin === LayerActionOrigin.ReactMapViewParseLayer) {
-    return;
-  }
-  const targets = yield select(getAddLayerActionsTargets, payload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
-  if (targets && targets.length > 0) {
-    yield put(setLayerActionSync(payload, targets, type));
-  }
-}
-function* duplicateMapLayerActionsSaga({
-  payload
-}) {
-  const sourceLayer = yield select(getLayerById, payload.oldLayerId);
-  const newPayload = {
-    mapId: payload.mapId,
-    layer: sourceLayer,
-    origin: payload.origin
-  };
-  const targets = yield select(getAddLayerActionsTargets, newPayload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
-  if (targets && targets.length > 0) {
-    yield put(setLayerActionSync(newPayload, targets, layerActions.addLayer.type));
-  }
-}
-function* deleteLayerActionsSaga({
-  payload,
-  type
-}) {
-  /* Should not listen to actions from itself */
-  if (payload && payload.origin === LayerActionOrigin.ReactMapViewParseLayer) {
-    return;
-  }
-  const targets = yield select(getLayerDeleteActionsTargets, payload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
-  if (targets && targets.length > 0) {
-    yield put(setLayerActionSync(payload, targets, type));
-  }
-}
-function* moveLayerActionsSaga({
-  payload,
-  type
-}) {
-  /* Should not listen to actions from itself */
-  if (payload && payload.origin === LayerActionOrigin.ReactMapViewParseLayer) {
-    return;
-  }
-  const targets = yield select(getLayerMoveActionsTargets, payload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
-  if (targets && targets.length > 0) {
-    yield put(setLayerActionSync(payload, targets, type));
-  }
-}
-function* setAutoLayerIdActionsSaga({
-  payload,
-  type
-}) {
-  const targets = yield select(getSetActiveLayerIdActionsTargets, payload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
-  if (targets && targets.length > 0) {
-    yield put(setLayerActionSync(payload, targets, type));
-  }
-}
-function* mapBaseLayerActionsSaga({
-  payload,
-  type
-}) {
-  /* Should not listen to actions from itself */
-  if (payload && payload.origin === LayerActionOrigin.ReactMapViewParseLayer) {
-    return;
-  }
-  const targets = yield select(getMapBaseLayerActionsTargets, payload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
-  if (targets && targets.length > 0) {
-    yield put(setLayerActionSync(payload, targets, type));
-  }
-}
-function* rootSaga() {
-  yield takeLatest(setTime.type, setTimeSaga);
-  yield takeLatest(setBbox.type, setBBoxSaga);
-  yield takeLatest(layerActions.layerChangeName.type, layerActionsSaga);
-  yield takeLatest(layerActions.layerChangeEnabled.type, layerActionsSaga);
-  yield takeLatest(layerActions.layerChangeOpacity.type, layerActionsSaga);
-  yield takeLatest(layerActions.layerChangeDimension.type, layerActionsSaga);
-  yield takeLatest(layerActions.layerChangeStyle.type, layerActionsSaga);
-  yield takeLatest(layerActions.layerDelete.type, deleteLayerActionsSaga);
-  yield takeLatest(layerActions.addLayer.type, addLayerActionsSaga);
-  yield takeLatest(layerActions.duplicateMapLayer.type, duplicateMapLayerActionsSaga);
-  yield takeLatest(mapActions.layerMoveLayer.type, moveLayerActionsSaga);
-  yield takeLatest(mapActions.setAutoLayerId.type, setAutoLayerIdActionsSaga);
-  yield takeLatest(layerActions.setBaseLayers.type, mapBaseLayerActionsSaga);
-}
+const genericListener = createListenerMiddleware();
+genericListener.startListening({
+  actionCreator: setTime,
+  effect: ({
+    payload
+  }, listenerApi) => __awaiter(void 0, void 0, void 0, function* () {
+    listenerApi.cancelActiveListeners();
+    const {
+      value,
+      origin
+    } = payload;
+    /* Test if the value is according to the expected time format */
+    if (!setTimeValidatorRexexp.test(value)) {
+      console.error(`setTime value ${value} does not conform to format [YYYY-MM-DDThh:mm:ssZ]. It was triggered by ${origin}`);
+    } else {
+      const targets = getTargets(listenerApi.getState(), payload, SYNCGROUPS_TYPE_SETTIME);
+      const groups = getTargetGroups(listenerApi.getState(), payload, SYNCGROUPS_TYPE_SETTIME);
+      listenerApi.dispatch(setTimeSync(payload, targets, groups));
+    }
+  })
+});
+genericListener.startListening({
+  actionCreator: setBbox,
+  effect: ({
+    payload
+  }, listenerApi) => __awaiter(void 0, void 0, void 0, function* () {
+    listenerApi.cancelActiveListeners();
+    const targets = getTargets(listenerApi.getState(), payload, SYNCGROUPS_TYPE_SETBBOX);
+    const groups = getTargetGroups(listenerApi.getState(), payload, SYNCGROUPS_TYPE_SETBBOX);
+    listenerApi.dispatch(setBboxSync(payload, targets, groups));
+  })
+});
+genericListener.startListening({
+  matcher: isAnyOf(layerActions.layerChangeName, layerActions.layerChangeEnabled, layerActions.layerChangeOpacity, layerActions.layerChangeDimension, layerActions.layerChangeStyle),
+  effect: ({
+    payload,
+    type
+  }, listenerApi) => __awaiter(void 0, void 0, void 0, function* () {
+    listenerApi.cancelActiveListeners();
+    /* Should not listen to actions from itself */
+    if (payload && payload.origin === LayerActionOrigin.ReactMapViewParseLayer) {
+      return;
+    }
+    const targets = getLayerActionsTargets(listenerApi.getState(), payload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
+    if (targets && targets.length > 0) {
+      listenerApi.dispatch(setLayerActionSync(payload, targets, type));
+    }
+  })
+});
 
 /* *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -9641,6 +9598,106 @@ var storeTestUtils = /*#__PURE__*/Object.freeze({
 	webmapStateWithAddedLayer: webmapStateWithAddedLayer
 });
 
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2020 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2020 - Finnish Meteorological Institute (FMI)
+ * */
+function* addLayerActionsSaga({
+  payload,
+  type
+}) {
+  /* Should not listen to actions from itself */
+  if (payload && payload.origin === LayerActionOrigin.ReactMapViewParseLayer) {
+    return;
+  }
+  const targets = yield select(getAddLayerActionsTargets, payload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
+  if (targets && targets.length > 0) {
+    yield put(setLayerActionSync(payload, targets, type));
+  }
+}
+function* duplicateMapLayerActionsSaga({
+  payload
+}) {
+  const sourceLayer = yield select(getLayerById, payload.oldLayerId);
+  const newPayload = {
+    mapId: payload.mapId,
+    layer: sourceLayer,
+    origin: payload.origin
+  };
+  const targets = yield select(getAddLayerActionsTargets, newPayload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
+  if (targets && targets.length > 0) {
+    yield put(setLayerActionSync(newPayload, targets, layerActions.addLayer.type));
+  }
+}
+function* deleteLayerActionsSaga({
+  payload,
+  type
+}) {
+  /* Should not listen to actions from itself */
+  if (payload && payload.origin === LayerActionOrigin.ReactMapViewParseLayer) {
+    return;
+  }
+  const targets = yield select(getLayerDeleteActionsTargets, payload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
+  if (targets && targets.length > 0) {
+    yield put(setLayerActionSync(payload, targets, type));
+  }
+}
+function* moveLayerActionsSaga({
+  payload,
+  type
+}) {
+  /* Should not listen to actions from itself */
+  if (payload && payload.origin === LayerActionOrigin.ReactMapViewParseLayer) {
+    return;
+  }
+  const targets = yield select(getLayerMoveActionsTargets, payload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
+  if (targets && targets.length > 0) {
+    yield put(setLayerActionSync(payload, targets, type));
+  }
+}
+function* setAutoLayerIdActionsSaga({
+  payload,
+  type
+}) {
+  const targets = yield select(getSetActiveLayerIdActionsTargets, payload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
+  if (targets && targets.length > 0) {
+    yield put(setLayerActionSync(payload, targets, type));
+  }
+}
+function* mapBaseLayerActionsSaga({
+  payload,
+  type
+}) {
+  /* Should not listen to actions from itself */
+  if (payload && payload.origin === LayerActionOrigin.ReactMapViewParseLayer) {
+    return;
+  }
+  const targets = yield select(getMapBaseLayerActionsTargets, payload, SYNCGROUPS_TYPE_SETLAYERACTIONS);
+  if (targets && targets.length > 0) {
+    yield put(setLayerActionSync(payload, targets, type));
+  }
+}
+function* rootSaga() {
+  yield takeLatest(layerActions.layerDelete.type, deleteLayerActionsSaga);
+  yield takeLatest(layerActions.addLayer.type, addLayerActionsSaga);
+  yield takeLatest(layerActions.duplicateMapLayer.type, duplicateMapLayerActionsSaga);
+  yield takeLatest(mapActions.layerMoveLayer.type, moveLayerActionsSaga);
+  yield takeLatest(mapActions.setAutoLayerId.type, setAutoLayerIdActionsSaga);
+  yield takeLatest(layerActions.setBaseLayers.type, mapBaseLayerActionsSaga);
+}
+
 /* *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -9713,7 +9770,7 @@ const synchronizationGroupConfig = {
     loadingIndicatorStore: loadingIndicatorReducer
   },
   sagas: [rootSaga],
-  middlewares: [syncGroupsListener.middleware]
+  middlewares: [genericListener.middleware, syncGroupsListener.middleware]
 };
 
 /* *
@@ -9759,7 +9816,7 @@ const coreModuleConfig = [mapStoreModuleConfig, synchronizationGroupConfig, uiMo
 
 const createStore = () => createStore$1({
   extensions: [getSagaExtension({}), {
-    middlewares: [metronomeListener.middleware]
+    middlewares: [metronomeListener.middleware, mapListener.middleware]
   }]
 });
 const WrapperWithModules = withEggs(coreModuleConfig)(({
@@ -9782,4 +9839,4 @@ const StoreProvider = ({
   })
 }));
 
-export { IS_LEGEND_OPEN_BY_DEFAULT, StoreProvider, coreModuleConfig, createStore, drawtoolActions, drawtoolModuleConfig, reducer as drawtoolReducer, selectors as drawtoolSelectors, filterLayers$1 as filterLayers, genericActions, rootSaga as genericSaga, selectors$4 as genericSelectors, types$1 as genericTypes, getSingularDrawtoolDrawLayerId, getUserAddedServices, initialState$3 as initialState, layerActions, reducer$6 as layerReducer, selectors$7 as layerSelectors, types$5 as layerTypes, utils$2 as layerUtils, loadingIndicatorActions, constants as loadingIndicatorConstants, loadingIndicatorReducer, selectors$3 as loadingIndicatorSelectors, mapActions, enums as mapEnums, rootSaga$2 as mapSaga, selectors$2 as mapSelectors, mapStoreActions, mapStoreModuleConfig, mapStoreReducers, types$4 as mapTypes, mapUtils, routerActions, routerModuleConfig, utils as routerUtils, selectorMemoizationOptions, serviceActions, selectors$1 as serviceSelectors, types as serviceTypes, setUserAddedServices, storeTestSettings, storeTestUtils, utils$1 as storeUtils, constants$1 as syncConstants, actions as syncGroupsActions, reducer$3 as syncGroupsReducer, selector as syncGroupsSelector, selectors$5 as syncGroupsSelectors, types$2 as syncGroupsTypes, types$2 as types, uiActions, uiModuleConfig, reducer$5 as uiReducer, selectors$6 as uiSelectors, types$3 as uiTypes, useSetupDialog, reducer$4 as webmapReducer };
+export { IS_LEGEND_OPEN_BY_DEFAULT, StoreProvider, coreModuleConfig, createStore, drawtoolActions, drawtoolModuleConfig, reducer as drawtoolReducer, selectors as drawtoolSelectors, filterLayers$1 as filterLayers, genericActions, genericListener, selectors$4 as genericSelectors, types$1 as genericTypes, getSingularDrawtoolDrawLayerId, getUserAddedServices, initialState$3 as initialState, layerActions, reducer$6 as layerReducer, selectors$7 as layerSelectors, types$5 as layerTypes, utils$2 as layerUtils, loadingIndicatorActions, constants as loadingIndicatorConstants, loadingIndicatorReducer, selectors$3 as loadingIndicatorSelectors, mapActions, enums as mapEnums, rootSaga$2 as mapSaga, selectors$2 as mapSelectors, mapStoreActions, mapStoreModuleConfig, mapStoreReducers, types$4 as mapTypes, mapUtils, routerActions, routerModuleConfig, utils as routerUtils, selectorMemoizationOptions, serviceActions, selectors$1 as serviceSelectors, types as serviceTypes, setUserAddedServices, storeTestSettings, storeTestUtils, utils$1 as storeUtils, constants$1 as syncConstants, actions as syncGroupsActions, reducer$3 as syncGroupsReducer, selector as syncGroupsSelector, selectors$5 as syncGroupsSelectors, types$2 as syncGroupsTypes, types$2 as types, uiActions, uiModuleConfig, reducer$5 as uiReducer, selectors$6 as uiSelectors, types$3 as uiTypes, useSetupDialog, reducer$4 as webmapReducer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeoweb/store",
-  "version": "9.23.1",
+  "version": "9.24.0",
   "description": "GeoWeb Store library for the opengeoweb project",
   "license": "Apache-2.0",
   "repository": {

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

@@ -0,0 +1,2 @@
+import { SynchronizationGroupModuleState } from './synchronizationGroups/types';
+export declare const genericListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<SynchronizationGroupModuleState, import("@reduxjs/toolkit").ThunkDispatch<SynchronizationGroupModuleState, unknown, import("redux").AnyAction>, unknown>;

package/src/store/generic/listener.spec.d.ts

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

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

@@ -1,10 +1,6 @@
 import { SagaIterator } from 'redux-saga';
 import { mapActions } from '../mapStore';
-import { setBbox, setTime } from './actions';
-import { layerActions, LayerActions } from '../mapStore/layers/reducer';
-export declare function setTimeSaga({ payload, }: ReturnType<typeof setTime>): SagaIterator;
-export declare function setBBoxSaga({ payload, }: ReturnType<typeof setBbox>): SagaIterator;
-export declare function layerActionsSaga({ payload, type, }: LayerActions): SagaIterator;
+import { layerActions } from '../mapStore/layers/reducer';
 export declare function addLayerActionsSaga({ payload, type, }: ReturnType<typeof layerActions.addLayer>): SagaIterator;
 export declare function duplicateMapLayerActionsSaga({ payload, }: ReturnType<typeof layerActions.duplicateMapLayer>): SagaIterator;
 export declare function deleteLayerActionsSaga({ payload, type, }: ReturnType<typeof layerActions.layerDelete>): SagaIterator;

package/src/store/index.d.ts

@@ -1,7 +1,7 @@
 export * from './mapStore';
 export * from './ui';
 export * from './generic';
-export { rootSaga as genericSaga } from './generic/sagas';
+export { genericListener } from './generic/listener';
 export * from './router';
 export * from './drawingtool';
 export * from './types';

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

@@ -14,7 +14,7 @@ export declare enum LayerActionOrigin {
     wmsLoader = "WMSLayerTreeConnect",
     ReactMapViewParseLayer = "ReactMapViewParseLayer",
     setLayerDimensionSaga = "setLayerDimensionSaga",
-    toggleAutoUpdateSaga = "toggleAutoUpdateSaga",
+    toggleAutoUpdateListener = "toggleAutoUpdateListener",
     unregisterMapSaga = "unregisterMapSaga"
 }
 export interface FeatureLayer {

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

@@ -0,0 +1,3 @@
+import { AnyAction, ThunkDispatch } from '@reduxjs/toolkit';
+import { WebMapStateModuleState } from '../types';
+export declare const mapListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<WebMapStateModuleState, ThunkDispatch<WebMapStateModuleState, unknown, AnyAction>, unknown>;

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

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

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

@@ -4,12 +4,9 @@ import { layerActions } from '../layers';
 import { Layer } from '../layers/types';
 export declare const getAnimationEndTime: (animationEndTime: string) => string;
 export declare const isAnimationEndTimeValid: (animationEndTime: string) => boolean;
-export declare function startAnimationSaga({ payload, }: ReturnType<typeof mapActions.mapStartAnimation>): Generator;
-export declare function stopAnimationSaga({ payload, }: ReturnType<typeof mapActions.mapStopAnimation>): Generator;
 export declare function deleteLayerSaga({ payload, }: ReturnType<typeof layerActions.layerDelete>): SagaIterator;
 export declare function updateAnimation(mapId: string, maxValue: string): SagaIterator;
 export declare function setLayerDimensionsSaga({ payload, }: ReturnType<typeof layerActions.onUpdateLayerInformation>): SagaIterator;
-export declare function toggleAutoUpdateSaga({ payload, }: ReturnType<typeof mapActions.toggleAutoUpdate>): SagaIterator;
 export declare function handleBaseLayersSaga(mapId: string, baseLayers: Layer[]): SagaIterator;
 export declare function setMapPresetSaga({ payload, }: ReturnType<typeof mapActions.setMapPreset>): SagaIterator;
 export declare function unregisterMapSaga({ payload, }: ReturnType<typeof mapActions.unregisterMap>): Generator;