@opengeoweb/store 12.2.0 → 12.3.0

package/index.esm.js

@@ -1,4 +1,4 @@
-import { createSlice, createSelector, createAction, createListenerMiddleware, isAnyOf, createEntityAdapter, combineReducers, configureStore, compose, EnhancerArray } from '@reduxjs/toolkit';
+import { createSlice, createSelector, createAction, createListenerMiddleware, isAnyOf, createEntityAdapter, combineReducers, configureStore } from '@reduxjs/toolkit';
 import { isEqual, isEmpty, compact } from 'lodash';
 import { dateUtils, PROJECTION, defaultDelay } from '@opengeoweb/shared';
 import { webmapUtils, parseISO8601IntervalToDateInterval, LayerType, getWMJSMapById, webmapTestSettings, WMLayer, getWMSRequests, handleDateUtilsISOString, isProjectionSupported, queryWMSLayers, getWMLayerById, WMInvalidDateValues } from '@opengeoweb/webmap';
@@ -2201,9 +2201,10 @@ var slice$6 = createSlice({
         targets = _action$payload24.targets,
         source = _action$payload24.source;
       return targets.reduce(function (prevState, target) {
+        var actionType = (source === null || source === void 0 ? void 0 : source.type) || 'GENERIC_SYNC_SETLAYERACTIONS';
         var action = {
           payload: target,
-          type: source && source.type
+          type: actionType
         };
         /* Handle the Layer action with the same logic, using the same reducer */
         return layerReducer(prevState, action);
@@ -2964,9 +2965,10 @@ var slice$4 = createSlice({
         targets = _action$payload37.targets,
         source = _action$payload37.source;
       return targets.reduce(function (prevState, target) {
+        var actionType = (source === null || source === void 0 ? void 0 : source.type) || 'GENERIC_SYNC_SETLAYERACTIONS';
         var action = {
           payload: target,
-          type: source && source.type
+          type: actionType
         };
         /* Handle the Layer action with the same logic, using the same reducer */
         return mapReducer(prevState, action);
@@ -7391,6 +7393,7 @@ var getGroupForMap = function getGroupForMap(mapId, state) {
 openlayersListener.startListening({
   actionCreator: mapActions.setBbox,
   effect: function effect(_ref, listenerApi) {
+    var _window$visualViewpor, _window$visualViewpor2;
     var payload = _ref.payload;
     var mapId = payload.mapId,
       bbox = payload.bbox,
@@ -7402,11 +7405,16 @@ openlayersListener.startListening({
       center: getCenter(extent)
     });
     storedViewForMap.setView(view);
-    // 1024 is the current best guess for width / height of a map
+    // OpenLayers View need a viewportsize to optimally fit an extent to a map. Try to find it in the following order:
+    // 1. Try to find the div element containing the layers and get its clientWidth/clientHeight
+    // 2. If that fails try the viewport visualViewport width/height
+    // 3. If that fails, fallback to 1024 / 1024
     // Feature request made for OL to help us get this right https://github.com/openlayers/openlayers/issues/16572
-    view.setViewportSize([1024, 1024]);
-    var resolution = view.getResolutionForExtent(extent);
-    view.setResolution(resolution);
+    var mapElement = document.getElementById("mapcontainer_".concat(mapId));
+    var viewPortWidth = (mapElement === null || mapElement === void 0 ? void 0 : mapElement.clientWidth) || ((_window$visualViewpor = window.visualViewport) === null || _window$visualViewpor === void 0 ? void 0 : _window$visualViewpor.width) || 1024;
+    var viewPortHeight = (mapElement === null || mapElement === void 0 ? void 0 : mapElement.clientHeight) || ((_window$visualViewpor2 = window.visualViewport) === null || _window$visualViewpor2 === void 0 ? void 0 : _window$visualViewpor2.height) || 1024;
+    view.setViewportSize([viewPortWidth, viewPortHeight]);
+    view.fit(extent);
     // Also: if this map is part of a group and the srs has changed => change group view
     var mapSyncGroup = getGroupForMap(mapId, listenerApi.getState());
     if (!mapSyncGroup) {
@@ -8930,9 +8938,6 @@ var createMockStore = function createMockStore(mockState) {
     }
   });
 };
-var getDefaultEnhancers = function getDefaultEnhancers() {
-  return new EnhancerArray();
-};
 /**
  * This creates an OpenGeoWeb redux store for redux connected components
  *
@@ -8947,12 +8952,12 @@ var configureOpenGeoWebStore = function configureOpenGeoWebStore() {
   var preloadedState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var extraReducers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var extraMiddleWares = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-  var extraEnhancers = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : getDefaultEnhancers();
+  var extraEnhancers = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
   var enableDevTools = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
   var allReducers = unifyReducerMaps([storeReducerMap, extraReducers]);
   var openGeoWebReducers = combineReducers(allReducers);
   // Combine middlewares
-  var middlewares = [mapListener.middleware, serviceListener.middleware, layersListener.middleware, genericListener.middleware].concat(_toConsumableArray(extraMiddleWares));
+  var middlewares = [mapListener.middleware, serviceListener.middleware, layersListener.middleware, genericListener.middleware, openlayersListener.middleware].concat(_toConsumableArray(extraMiddleWares));
   // Ensure we do not add middlewares twice
   var uniqueMiddlewares = Array.from(new Set(middlewares.map(function (obj) {
     return obj;
@@ -8960,19 +8965,19 @@ var configureOpenGeoWebStore = function configureOpenGeoWebStore() {
   return configureStore({
     reducer: openGeoWebReducers,
     preloadedState: preloadedState,
-    enhancers: function enhancers(defaultEnhancers) {
-      return [compose.apply(void 0, [].concat(_toConsumableArray(defaultEnhancers), _toConsumableArray(extraEnhancers)))];
+    enhancers: function enhancers(getDefaultEnhancers) {
+      return getDefaultEnhancers().concat(extraEnhancers);
     },
     devTools: enableDevTools,
     middleware: function middleware(getDefaultMiddleware) {
-      return _toConsumableArray(getDefaultMiddleware({
+      return getDefaultMiddleware({
         serializableCheck: {
           warnAfter: 128
         },
         immutableCheck: {
           warnAfter: 128
         }
-      })).concat(uniqueMiddlewares);
+      }).concat(uniqueMiddlewares);
     }
   });
 };

package/package.json

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

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

@@ -1,3 +1,3 @@
 import { DrawtoolModuleStore } from './reducer';
 import { WebMapStateModuleState } from '../map';
-export declare const drawingToolListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<DrawtoolModuleStore & WebMapStateModuleState, import("@reduxjs/toolkit").ThunkDispatch<DrawtoolModuleStore & WebMapStateModuleState, unknown, import("redux").AnyAction>, unknown>;
+export declare const drawingToolListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<DrawtoolModuleStore & WebMapStateModuleState, import("redux-thunk").ThunkDispatch<DrawtoolModuleStore & WebMapStateModuleState, unknown, import("redux").UnknownAction>, unknown>;

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

@@ -9,11 +9,11 @@ export interface DrawToolItem {
     geoJSONIntersectionLayerId?: string;
     geoJSONIntersectionBoundsLayerId?: string;
 }
-export type DrawingToolState = EntityState<DrawToolItem>;
+export type DrawingToolState = EntityState<DrawToolItem, string>;
 export interface DrawtoolModuleStore {
     drawingtools?: DrawingToolState;
 }
-export declare const drawAdapter: import("@reduxjs/toolkit").EntityAdapter<DrawToolItem>;
+export declare const drawAdapter: import("@reduxjs/toolkit").EntityAdapter<DrawToolItem, string>;
 export declare const initialState: DrawingToolState;
 export declare const drawingToolReducer: import("redux").Reducer<DrawingToolState>, drawingToolActions: import("@reduxjs/toolkit").CaseReducerActions<{
     registerDrawTool: (draft: Draft<DrawingToolState>, action: PayloadAction<MapDrawToolOptions & {

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

@@ -1,43 +1,347 @@
 import type { DrawingToolState, DrawtoolModuleStore } from './reducer';
 export declare const getDrawingtoolStore: (store: DrawtoolModuleStore) => DrawingToolState;
-export declare const selectDrawToolById: (state: DrawtoolModuleStore, id: import("@reduxjs/toolkit").EntityId) => import("./reducer").DrawToolItem | undefined, selectAllDrawingTools: (state: DrawtoolModuleStore) => import("./reducer").DrawToolItem[];
-export declare const getActiveDrawToolId: ((state: DrawtoolModuleStore) => string) & import("reselect").OutputSelectorFields<(args_0: import("./reducer").DrawToolItem[]) => string, {
-    clearCache: () => void;
-}> & {
+export declare const selectDrawToolById: (state: DrawtoolModuleStore, id: string) => {
+    drawToolId: string;
+    geoJSONLayerId: string;
+    activeDrawModeId: string;
+    drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+    shouldAllowMultipleShapes: boolean;
+    geoJSONIntersectionLayerId?: string | undefined;
+    geoJSONIntersectionBoundsLayerId?: string | undefined;
+}, selectAllDrawingTools: (state: DrawtoolModuleStore) => import("./reducer").DrawToolItem[];
+export declare const getActiveDrawToolId: ((state: DrawtoolModuleStore) => string) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("./reducer").DrawToolItem[]) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: import("./reducer").DrawToolItem[]) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(state: DrawtoolModuleStore) => import("./reducer").DrawToolItem[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getDrawModeById: ((state: DrawtoolModuleStore, _drawToolId: string, drawModeId: string) => import("dist/libs/webmap-react/src").DrawMode | undefined) & import("reselect").OutputSelectorFields<(args_0: import("./reducer").DrawToolItem | undefined, args_1: string) => import("dist/libs/webmap-react/src").DrawMode | undefined, {
-    clearCache: () => void;
-}> & {
+export declare const getDrawModeById: ((state: DrawtoolModuleStore, _drawToolId: string, drawModeId: string) => import("dist/libs/webmap-react/src").DrawMode | undefined) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }, resultFuncArgs_1: string) => import("dist/libs/webmap-react/src").DrawMode | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }, resultFuncArgs_1: string) => import("dist/libs/webmap-react/src").DrawMode | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("dist/libs/webmap-react/src").DrawMode | undefined;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }, (_store: DrawtoolModuleStore, _drawToolId: string, drawModeId: string) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getActiveDrawModeId: ((state: DrawtoolModuleStore, id: import("@reduxjs/toolkit").EntityId) => string) & import("reselect").OutputSelectorFields<(args_0: import("./reducer").DrawToolItem | undefined) => string, {
-    clearCache: () => void;
-}> & {
+export declare const getActiveDrawModeId: ((state: DrawtoolModuleStore, id: string) => string) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getDrawToolGeoJSONLayerId: ((state: DrawtoolModuleStore, id: import("@reduxjs/toolkit").EntityId) => string) & import("reselect").OutputSelectorFields<(args_0: import("./reducer").DrawToolItem | undefined) => string, {
-    clearCache: () => void;
-}> & {
+export declare const getDrawToolGeoJSONLayerId: ((state: DrawtoolModuleStore, id: string) => string) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getGeoJSONIntersectionLayerId: ((state: DrawtoolModuleStore, id: import("@reduxjs/toolkit").EntityId) => string | undefined) & import("reselect").OutputSelectorFields<(args_0: import("./reducer").DrawToolItem | undefined) => string | undefined, {
-    clearCache: () => void;
-}> & {
+export declare const getGeoJSONIntersectionLayerId: ((state: DrawtoolModuleStore, id: string) => string | undefined) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string | undefined;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getGeoJSONIntersectionBoundsLayerId: ((state: DrawtoolModuleStore, id: import("@reduxjs/toolkit").EntityId) => string | undefined) & import("reselect").OutputSelectorFields<(args_0: import("./reducer").DrawToolItem | undefined) => string | undefined, {
-    clearCache: () => void;
-}> & {
+export declare const getGeoJSONIntersectionBoundsLayerId: ((state: DrawtoolModuleStore, id: string) => string | undefined) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string | undefined;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getShouldAllowMultipleShapes: ((state: DrawtoolModuleStore, id: import("@reduxjs/toolkit").EntityId) => boolean) & import("reselect").OutputSelectorFields<(args_0: import("./reducer").DrawToolItem | undefined) => boolean, {
-    clearCache: () => void;
-}> & {
+export declare const getShouldAllowMultipleShapes: ((state: DrawtoolModuleStore, id: string) => boolean) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getActiveDrawMode: ((state: DrawtoolModuleStore, id: import("@reduxjs/toolkit").EntityId) => import("dist/libs/webmap-react/src").DrawMode | undefined) & import("reselect").OutputSelectorFields<(args_0: import("./reducer").DrawToolItem | undefined) => import("dist/libs/webmap-react/src").DrawMode | undefined, {
-    clearCache: () => void;
-}> & {
+export declare const getActiveDrawMode: ((state: DrawtoolModuleStore, id: string) => import("dist/libs/webmap-react/src").DrawMode | undefined) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => import("dist/libs/webmap-react/src").DrawMode | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => import("dist/libs/webmap-react/src").DrawMode | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("dist/libs/webmap-react/src").DrawMode | undefined;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("dist/libs/webmap-react/src").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };

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

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

package/src/store/generic/loadingIndicator/reducer.d.ts

@@ -1,13 +1,13 @@
 import { PayloadAction, EntityState } from '@reduxjs/toolkit';
 import { LoadingIndicatorType, SetIsEDRLoadingPayload, SetIsGetCapabilitiesLoadingPayload, SetIsGetMapLoadingPayload } from './types';
-export declare const loadingIndicatorAdapter: import("@reduxjs/toolkit").EntityAdapter<LoadingIndicatorType>;
-export declare const slice: import("@reduxjs/toolkit").Slice<EntityState<LoadingIndicatorType>, {
-    setGetMapIsLoading: (draft: EntityState<LoadingIndicatorType>, action: PayloadAction<SetIsGetMapLoadingPayload>) => void;
-    setGetCapabilitiesIsLoading: (draft: EntityState<LoadingIndicatorType>, action: PayloadAction<SetIsGetCapabilitiesLoadingPayload>) => void;
-    setEDRIsLoading: (draft: EntityState<LoadingIndicatorType>, action: PayloadAction<SetIsEDRLoadingPayload>) => void;
-}, "loadingIndicatorReducer">;
+export declare const loadingIndicatorAdapter: import("@reduxjs/toolkit").EntityAdapter<LoadingIndicatorType, string>;
+export declare const slice: import("@reduxjs/toolkit").Slice<EntityState<LoadingIndicatorType, string>, {
+    setGetMapIsLoading: (draft: EntityState<LoadingIndicatorType, string>, action: PayloadAction<SetIsGetMapLoadingPayload>) => void;
+    setGetCapabilitiesIsLoading: (draft: EntityState<LoadingIndicatorType, string>, action: PayloadAction<SetIsGetCapabilitiesLoadingPayload>) => void;
+    setEDRIsLoading: (draft: EntityState<LoadingIndicatorType, string>, action: PayloadAction<SetIsEDRLoadingPayload>) => void;
+}, "loadingIndicatorReducer", "loadingIndicatorReducer", import("@reduxjs/toolkit").SliceSelectors<EntityState<LoadingIndicatorType, string>>>;
 export declare const loadingIndicatorActions: import("@reduxjs/toolkit").CaseReducerActions<{
-    setGetMapIsLoading: (draft: EntityState<LoadingIndicatorType>, action: PayloadAction<SetIsGetMapLoadingPayload>) => void;
-    setGetCapabilitiesIsLoading: (draft: EntityState<LoadingIndicatorType>, action: PayloadAction<SetIsGetCapabilitiesLoadingPayload>) => void;
-    setEDRIsLoading: (draft: EntityState<LoadingIndicatorType>, action: PayloadAction<SetIsEDRLoadingPayload>) => void;
-}, "loadingIndicatorReducer">, loadingIndicatorReducer: import("redux").Reducer<EntityState<LoadingIndicatorType>>;
+    setGetMapIsLoading: (draft: EntityState<LoadingIndicatorType, string>, action: PayloadAction<SetIsGetMapLoadingPayload>) => void;
+    setGetCapabilitiesIsLoading: (draft: EntityState<LoadingIndicatorType, string>, action: PayloadAction<SetIsGetCapabilitiesLoadingPayload>) => void;
+    setEDRIsLoading: (draft: EntityState<LoadingIndicatorType, string>, action: PayloadAction<SetIsEDRLoadingPayload>) => void;
+}, "loadingIndicatorReducer">, loadingIndicatorReducer: import("redux").Reducer<EntityState<LoadingIndicatorType, string>>;