@opengeoweb/store 9.25.0 → 9.25.2

package/index.esm.js

@@ -10,7 +10,7 @@ import { useSelector, useDispatch, Provider } from 'react-redux';
 import { useCallback, useEffect } from 'react';
 import { createStore as createStore$1 } from '@redux-eggs/redux-toolkit';
 import { getSagaExtension } from '@redux-eggs/saga-extension';
-import { takeLatest, takeEvery, select, put, all, call as call$e, delay } from 'redux-saga/effects';
+import { takeEvery, call as call$e, put, select, delay, all, takeLatest } from 'redux-saga/effects';
 import { metronome } from '@opengeoweb/metronome';
 import { jsx } from 'react/jsx-runtime';
 
@@ -1999,7 +1999,7 @@ var LayerActionOrigin;
   LayerActionOrigin["layerManager"] = "layerManager";
   LayerActionOrigin["wmsLoader"] = "WMSLayerTreeConnect";
   LayerActionOrigin["ReactMapViewParseLayer"] = "ReactMapViewParseLayer";
-  LayerActionOrigin["setLayerDimensionSaga"] = "setLayerDimensionSaga";
+  LayerActionOrigin["updateLayerInformationListener"] = "updateLayerInformationListener";
   LayerActionOrigin["toggleAutoUpdateListener"] = "toggleAutoUpdateListener";
   LayerActionOrigin["unregisterMapSaga"] = "unregisterMapSaga";
 })(LayerActionOrigin || (LayerActionOrigin = {}));
@@ -7631,104 +7631,6 @@ const isAnimationEndTimeValid = animationEndTime => {
   const parsedDate = dateUtils.parseISO(animationEndTime);
   return dateUtils.isValid(parsedDate);
 };
-function* deleteLayerSaga({
-  payload
-}) {
-  const {
-    mapId
-  } = payload;
-  const layers = yield select(getMapLayersWithoutDimensionCurrentValue, mapId);
-  if (!layers.length) {
-    yield put(mapActions.mapStopAnimation({
-      mapId
-    }));
-  }
-}
-function* updateAnimation$1(mapId, maxValue) {
-  const shouldEndtimeOverride$1 = yield select(shouldEndtimeOverride, mapId);
-  if (shouldEndtimeOverride$1 === true) {
-    return;
-  }
-  const animationStart = yield select(getAnimationStartTime, mapId);
-  // Calculate how much time the animation start need to move forwards
-  const animationEnd = yield select(getAnimationEndTime, 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;
-  }
-  yield put(mapActions.setAnimationEndTime({
-    mapId,
-    animationEndTime: newAnimationEndTime
-  }));
-  yield put(mapActions.setAnimationStartTime({
-    mapId,
-    animationStartTime: newAnimationStartTime
-  }));
-}
-function* setLayerDimensionsSaga({
-  payload
-}) {
-  try {
-    const {
-      layerDimensions
-    } = payload;
-    if (!layerDimensions) {
-      return;
-    }
-    const {
-      dimensions,
-      layerId
-    } = layerDimensions;
-    const layer = yield select(getLayerById, layerId);
-    if (!layer) {
-      return;
-    }
-    const newTimeDimension = dimensions.find(dimension => dimension.name === 'time');
-    const {
-      mapId
-    } = layer;
-    const autoUpdateLayerId = yield select(getAutoUpdateLayerId, mapId);
-    const shouldAutoUpdate = yield select(isAutoUpdating, mapId);
-    const prevTimeDimension = yield select(getLayerTimeDimension, layerId);
-    const isAutoUpdateLayer = layerId === autoUpdateLayerId;
-    const incomingMaxTime = newTimeDimension === null || newTimeDimension === void 0 ? void 0 : newTimeDimension.maxValue;
-    const isIncomingMaxTimeLaterThanCurrentLayerTime = incomingMaxTime && (prevTimeDimension === null || prevTimeDimension === void 0 ? void 0 : prevTimeDimension.currentValue) && prevTimeDimension.currentValue !== incomingMaxTime;
-    if (isAutoUpdateLayer &&
-    // only update the active layer
-    shouldAutoUpdate && isIncomingMaxTimeLaterThanCurrentLayerTime) {
-      const isMapAnimating = yield select(isAnimating, mapId);
-      if (!isMapAnimating) {
-        yield put(layerActions.layerChangeDimension({
-          layerId,
-          origin: LayerActionOrigin.setLayerDimensionSaga,
-          dimension: {
-            name: 'time',
-            currentValue: incomingMaxTime
-          }
-        }));
-        // Each time a layer updates, set the new time for all synced timesliders
-        const syncedMapIds = yield select(getSyncedMapIdsForTimeslider);
-        if (syncedMapIds) {
-          // Change time value for all other timesliders
-          yield all(syncedMapIds.map(syncedMapId => put(setTime({
-            origin: 'mapStore saga',
-            sourceId: syncedMapId,
-            value: incomingMaxTime
-          }))));
-        }
-      }
-      yield call$e(updateAnimation$1, mapId, incomingMaxTime);
-    }
-  } catch (error) {
-    // eslint-disable-next-line no-console
-    console.warn(error);
-  }
-}
 function* handleBaseLayersSaga(mapId, baseLayers) {
   const baseLayer = baseLayers.find(layer => layer.layerType === 'baseLayer');
   const currentAvailableBaseLayers = yield select(getAvailableBaseLayersForMap, mapId);
@@ -8058,8 +7960,6 @@ function* setStepBackwardOrForwardSaga({
 }
 function* rootSaga$2() {
   // resets IWMJSMap state
-  yield takeLatest(layerActions.layerDelete.type, deleteLayerSaga);
-  yield takeLatest(layerActions.onUpdateLayerInformation.type, setLayerDimensionsSaga);
   yield takeEvery(mapActions.setMapPreset.type, setMapPresetSaga);
   yield takeEvery(mapActions.unregisterMap.type, unregisterMapSaga);
   yield takeEvery(mapActions.setStepBackwardOrForward.type, setStepBackwardOrForwardSaga);
@@ -8367,6 +8267,85 @@ mapUiListener.startListening({
 });
 
 const mapListener = createListenerMiddleware();
+mapListener.startListening({
+  actionCreator: layerActions.layerDelete,
+  effect: ({
+    payload
+  }, listenerApi) => {
+    const {
+      mapId
+    } = payload;
+    const layers = getMapLayersWithoutDimensionCurrentValue(listenerApi.getState(), mapId);
+    if (!layers.length) {
+      listenerApi.dispatch(mapActions.mapStopAnimation({
+        mapId
+      }));
+    }
+  }
+});
+// update layer, synced maps and animation on latest max time if autoupdating
+mapListener.startListening({
+  actionCreator: layerActions.onUpdateLayerInformation,
+  effect: ({
+    payload
+  }, listenerApi) => {
+    try {
+      const {
+        layerDimensions
+      } = payload;
+      if (!layerDimensions) {
+        return;
+      }
+      const {
+        dimensions,
+        layerId
+      } = layerDimensions;
+      const layer = getLayerById(listenerApi.getState(), layerId);
+      if (!layer) {
+        return;
+      }
+      const newTimeDimension = dimensions.find(dimension => dimension.name === 'time');
+      const {
+        mapId
+      } = layer;
+      const autoUpdateLayerId = getAutoUpdateLayerId(listenerApi.getState(), mapId);
+      const shouldAutoUpdate = isAutoUpdating(listenerApi.getState(), mapId);
+      const prevTimeDimension = getLayerTimeDimension(listenerApi.getState(), layerId);
+      const isAutoUpdateLayer = layerId === autoUpdateLayerId;
+      const incomingMaxTime = newTimeDimension === null || newTimeDimension === void 0 ? void 0 : newTimeDimension.maxValue;
+      const isIncomingMaxTimeLaterThanCurrentLayerTime = incomingMaxTime && (prevTimeDimension === null || prevTimeDimension === void 0 ? void 0 : prevTimeDimension.currentValue) && prevTimeDimension.currentValue !== incomingMaxTime;
+      if (isAutoUpdateLayer &&
+      // only update the active layer
+      shouldAutoUpdate && isIncomingMaxTimeLaterThanCurrentLayerTime) {
+        const isMapAnimating = isAnimating(listenerApi.getState(), mapId);
+        if (!isMapAnimating) {
+          listenerApi.dispatch(layerActions.layerChangeDimension({
+            layerId,
+            origin: LayerActionOrigin.updateLayerInformationListener,
+            dimension: {
+              name: 'time',
+              currentValue: incomingMaxTime
+            }
+          }));
+          // Each time a layer updates, set the new time for all synced timesliders
+          const syncedMapIds = getSyncedMapIdsForTimeslider(listenerApi.getState());
+          if (syncedMapIds) {
+            // Change time value for all other timesliders
+            syncedMapIds.map(syncedMapId => listenerApi.dispatch(setTime({
+              origin: LayerActionOrigin.updateLayerInformationListener,
+              sourceId: syncedMapId,
+              value: incomingMaxTime
+            })));
+          }
+        }
+        updateAnimation(mapId, incomingMaxTime, listenerApi);
+      }
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.warn(error);
+    }
+  }
+});
 const updateAnimation = (mapId, maxValue, listenerApi) => {
   const shouldEndtimeOverride$1 = shouldEndtimeOverride(listenerApi.getState(), mapId);
   if (shouldEndtimeOverride$1 === true) {

package/package.json

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

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

@@ -13,7 +13,7 @@ export declare enum LayerActionOrigin {
     layerManager = "layerManager",
     wmsLoader = "WMSLayerTreeConnect",
     ReactMapViewParseLayer = "ReactMapViewParseLayer",
-    setLayerDimensionSaga = "setLayerDimensionSaga",
+    updateLayerInformationListener = "updateLayerInformationListener",
     toggleAutoUpdateListener = "toggleAutoUpdateListener",
     unregisterMapSaga = "unregisterMapSaga"
 }

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

@@ -1,12 +1,9 @@
 import { SagaIterator } from 'redux-saga';
 import { mapActions } from '.';
-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 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 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;