@opengeoweb/store 12.2.0 → 12.3.0

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

@@ -1,5 +1,5 @@
-import { AnyAction, ListenerEffectAPI, ThunkDispatch } from '@reduxjs/toolkit';
+import { UnknownAction, ListenerEffectAPI, ThunkDispatch } from '@reduxjs/toolkit';
 import { FetchInitialServicesPayload, SetLayersForServicePayload, WebMapStateModuleState } from '../types';
-export declare const serviceListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<WebMapStateModuleState, ThunkDispatch<WebMapStateModuleState, unknown, AnyAction>, unknown>;
-export declare const fetchService: (service: SetLayersForServicePayload, listenerApi: ListenerEffectAPI<WebMapStateModuleState, ThunkDispatch<WebMapStateModuleState, unknown, AnyAction>, unknown>) => Promise<void>;
-export declare const fetchInitialServices: (payload: FetchInitialServicesPayload, listenerApi: ListenerEffectAPI<WebMapStateModuleState, ThunkDispatch<WebMapStateModuleState, unknown, AnyAction>, unknown>) => Promise<void>;
+export declare const serviceListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<WebMapStateModuleState, ThunkDispatch<WebMapStateModuleState, unknown, UnknownAction>, unknown>;
+export declare const fetchService: (service: SetLayersForServicePayload, listenerApi: ListenerEffectAPI<WebMapStateModuleState, ThunkDispatch<WebMapStateModuleState, unknown, UnknownAction>, unknown>) => Promise<void>;
+export declare const fetchInitialServices: (payload: FetchInitialServicesPayload, listenerApi: ListenerEffectAPI<WebMapStateModuleState, ThunkDispatch<WebMapStateModuleState, unknown, UnknownAction>, unknown>) => Promise<void>;

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

@@ -8,10 +8,26 @@ import { ServiceState, ReduxService } from './types';
  * @param {object} store store: object - object from which the service state will be extracted
  * @returns {array} returnType: array - an array of all serviceIds
  */
-export declare const getServiceIds: ((state: CoreAppStore) => string[]) & import("reselect").OutputSelectorFields<(args_0: ServiceState | undefined) => string[], {
-    clearCache: () => void;
-}> & {
+export declare const getServiceIds: ((state: CoreAppStore) => string[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ServiceState | undefined) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: ServiceState | undefined) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [(store: CoreAppStore) => ServiceState | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  * Gets map services
@@ -20,10 +36,26 @@ export declare const getServiceIds: ((state: CoreAppStore) => string[]) & import
  * @param {object} store store: object - Store object
  * @returns {object} returnType: ServiceState
  */
-export declare const getServices: ((state: CoreAppStore) => import("./types").Services) & import("reselect").OutputSelectorFields<(args_0: ServiceState | undefined) => import("./types").Services, {
-    clearCache: () => void;
-}> & {
+export declare const getServices: ((state: CoreAppStore) => import("./types").Services) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ServiceState | undefined) => import("./types").Services;
+    memoizedResultFunc: ((resultFuncArgs_0: ServiceState | undefined) => import("./types").Services) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").Services;
+    dependencies: [(store: CoreAppStore) => ServiceState | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  * Gets the service object by its url
@@ -32,10 +64,26 @@ export declare const getServices: ((state: CoreAppStore) => import("./types").Se
  * @param {object} store store: object - Store object
  * @returns {ReduxService} returnType: Service
  */
-export declare const getServiceByUrl: ((state: CoreAppStore, serviceUrl: string) => ReduxService | undefined) & import("reselect").OutputSelectorFields<(args_0: ServiceState | undefined, args_1: string) => ReduxService | undefined, {
-    clearCache: () => void;
-}> & {
+export declare const getServiceByUrl: ((state: CoreAppStore, serviceUrl: string) => ReduxService | undefined) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ServiceState | undefined, resultFuncArgs_1: string) => ReduxService | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: ServiceState | undefined, resultFuncArgs_1: string) => ReduxService | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => ReduxService | undefined;
+    dependencies: [(store: CoreAppStore) => ServiceState | undefined, (state: CoreAppStore, serviceUrl: string) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  * Gets the layer from the store using the serviceUrl and layerName
@@ -45,10 +93,46 @@ export declare const getServiceByUrl: ((state: CoreAppStore, serviceUrl: string)
  * @param {string}  serviceUrl serviceUrl: string - Url of the service where the layer belongs to
  * @returns {array} returnType: ServiceLayer[] - All layers within the service object.
  */
-export declare const getLayersFromServiceSelector: ((state: CoreAppStore, serviceUrl: string) => LayerProps[]) & import("reselect").OutputSelectorFields<(args_0: ReduxService | undefined) => LayerProps[], {
-    clearCache: () => void;
-}> & {
+export declare const getLayersFromServiceSelector: ((state: CoreAppStore, serviceUrl: string) => LayerProps[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ReduxService | undefined) => LayerProps[];
+    memoizedResultFunc: ((resultFuncArgs_0: ReduxService | undefined) => LayerProps[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => LayerProps[];
+    dependencies: [((state: CoreAppStore, serviceUrl: string) => ReduxService | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: ServiceState | undefined, resultFuncArgs_1: string) => ReduxService | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: ServiceState | undefined, resultFuncArgs_1: string) => ReduxService | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => ReduxService | undefined;
+        dependencies: [(store: CoreAppStore) => ServiceState | undefined, (state: CoreAppStore, serviceUrl: string) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  * Gets the layer from the store using the serviceUrl and layerName
@@ -59,10 +143,66 @@ export declare const getLayersFromServiceSelector: ((state: CoreAppStore, servic
  * @param {string}  layerName layerName: string - Name of the layer in the service
  * @returns {ServiceLayer} returnType: ServiceLayer - The layer from the service object.
  */
-export declare const getLayerFromService: ((state: CoreAppStore, _serviceUrl: string, layerName: string) => LayerProps | undefined) & import("reselect").OutputSelectorFields<(args_0: LayerProps[], args_1: string) => LayerProps | undefined, {
-    clearCache: () => void;
-}> & {
+export declare const getLayerFromService: ((state: CoreAppStore, _serviceUrl: string, layerName: string) => LayerProps | undefined) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: LayerProps[], resultFuncArgs_1: string) => LayerProps | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: LayerProps[], resultFuncArgs_1: string) => LayerProps | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => LayerProps | undefined;
+    dependencies: [((state: CoreAppStore, serviceUrl: string) => LayerProps[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: ReduxService | undefined) => LayerProps[];
+        memoizedResultFunc: ((resultFuncArgs_0: ReduxService | undefined) => LayerProps[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => LayerProps[];
+        dependencies: [((state: CoreAppStore, serviceUrl: string) => ReduxService | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: ServiceState | undefined, resultFuncArgs_1: string) => ReduxService | undefined;
+            memoizedResultFunc: ((resultFuncArgs_0: ServiceState | undefined, resultFuncArgs_1: string) => ReduxService | undefined) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => ReduxService | undefined;
+            dependencies: [(store: CoreAppStore) => ServiceState | undefined, (state: CoreAppStore, serviceUrl: string) => string];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import("reselect").weakMapMemoize;
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }, (_store: CoreAppStore, _serviceUrl: string, layerName: string) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  * Gets the layers stylelist from the servicestore using the serviceUrl and layerName
@@ -73,8 +213,84 @@ export declare const getLayerFromService: ((state: CoreAppStore, _serviceUrl: st
  * @param {string}  layerName layerName: string - Name of the layer in the service
  * @returns {array} returnType: Style[] - array containing layer styles
  */
-export declare const getLayerStyles: ((state: CoreAppStore, _serviceUrl: string, layerName: string) => Style[]) & import("reselect").OutputSelectorFields<(args_0: LayerProps | undefined) => Style[], {
-    clearCache: () => void;
-}> & {
+export declare const getLayerStyles: ((state: CoreAppStore, _serviceUrl: string, layerName: string) => Style[]) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: LayerProps | undefined) => Style[];
+    memoizedResultFunc: ((resultFuncArgs_0: LayerProps | undefined) => Style[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Style[];
+    dependencies: [((state: CoreAppStore, _serviceUrl: string, layerName: string) => LayerProps | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: LayerProps[], resultFuncArgs_1: string) => LayerProps | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: LayerProps[], resultFuncArgs_1: string) => LayerProps | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => LayerProps | undefined;
+        dependencies: [((state: CoreAppStore, serviceUrl: string) => LayerProps[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: ReduxService | undefined) => LayerProps[];
+            memoizedResultFunc: ((resultFuncArgs_0: ReduxService | undefined) => LayerProps[]) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => LayerProps[];
+            dependencies: [((state: CoreAppStore, serviceUrl: string) => ReduxService | undefined) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            } & {
+                resultFunc: (resultFuncArgs_0: ServiceState | undefined, resultFuncArgs_1: string) => ReduxService | undefined;
+                memoizedResultFunc: ((resultFuncArgs_0: ServiceState | undefined, resultFuncArgs_1: string) => ReduxService | undefined) & {
+                    clearCache: () => void;
+                    resultsCount: () => number;
+                    resetResultsCount: () => void;
+                };
+                lastResult: () => ReduxService | undefined;
+                dependencies: [(store: CoreAppStore) => ServiceState | undefined, (state: CoreAppStore, serviceUrl: string) => string];
+                recomputations: () => number;
+                resetRecomputations: () => void;
+                dependencyRecomputations: () => number;
+                resetDependencyRecomputations: () => void;
+            } & {
+                memoize: typeof import("reselect").weakMapMemoize;
+                argsMemoize: typeof import("reselect").weakMapMemoize;
+            }];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import("reselect").weakMapMemoize;
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+        }, (_store: CoreAppStore, _serviceUrl: string, layerName: string) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };

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

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

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

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

package/src/store/store.d.ts

@@ -1,6 +1,4 @@
-import { DevToolsEnhancerOptions, EnhancerArray, ListenerMiddleware, StoreEnhancer } from '@reduxjs/toolkit';
-import { ToolkitStore } from '@reduxjs/toolkit/dist/configureStore';
-import { ExtractDispatchExtensions } from '@reduxjs/toolkit/dist/tsHelpers';
+import { DevToolsEnhancerOptions, ListenerMiddleware, Store, StoreEnhancer } from '@reduxjs/toolkit';
 import { WebMapStateModuleState } from './map';
 import { SynchronizationGroupModuleState } from './generic/syncGroups/types';
 import { LoadingIndicatorModuleState } from './generic/loadingIndicator/types';
@@ -12,13 +10,13 @@ export declare const storeReducerMap: {
     services: import("redux").Reducer<import("./map/types").ServiceState>;
     layers: import("redux").Reducer<import("./map/types").LayerState>;
     syncGroups: import("redux").Reducer<import("./generic/syncGroups/types").SynchronizationGroupState>;
-    loadingIndicator: import("redux").Reducer<import("@reduxjs/toolkit").EntityState<import("./generic/loadingIndicator/types").LoadingIndicatorType>>;
+    loadingIndicator: import("redux").Reducer<import("@reduxjs/toolkit").EntityState<import("./generic/loadingIndicator/types").LoadingIndicatorType, string>>;
     ui: import("redux").Reducer<import("./ui/types").UIStoreType>;
     drawingtools: import("redux").Reducer<import("./drawingTool/reducer").DrawingToolState>;
     router: import("redux").Reducer<{}>;
 };
-export declare const storeMiddlewares: (ListenerMiddleware<import("./types").CoreAppStore, import("@reduxjs/toolkit").ThunkDispatch<import("./types").CoreAppStore, unknown, import("redux").AnyAction>, unknown> | ListenerMiddleware<import("./router/types").RouterModuleStore, import("@reduxjs/toolkit").ThunkDispatch<import("./router/types").RouterModuleStore, unknown, import("redux").AnyAction>, unknown>)[];
-export declare const createMockStore: (mockState?: WebMapStateModuleState | SynchronizationGroupModuleState | LoadingIndicatorModuleState | UIModuleState | DrawtoolModuleStore) => ToolkitStore;
+export declare const storeMiddlewares: (ListenerMiddleware<import("./types").CoreAppStore, import("redux-thunk").ThunkDispatch<import("./types").CoreAppStore, unknown, import("redux").UnknownAction>, unknown> | ListenerMiddleware<import("./router/types").RouterModuleStore, import("redux-thunk").ThunkDispatch<import("./router/types").RouterModuleStore, unknown, import("redux").UnknownAction>, unknown>)[];
+export declare const createMockStore: (mockState?: WebMapStateModuleState | SynchronizationGroupModuleState | LoadingIndicatorModuleState | UIModuleState | DrawtoolModuleStore) => Store;
 export { getViewObjectForSyncGroup, getViewObjectForMapId, createViewObjectForNewMap, } from './mapStore/openlayers/syncGroupViewStore';
 /**
  * This creates an OpenGeoWeb redux store for redux connected components
@@ -30,8 +28,4 @@ export { getViewObjectForSyncGroup, getViewObjectForMapId, createViewObjectForNe
  * @param enableDevTools Set to true to enable redux devtools.
  * @returns A redux store you can use with the core components
  */
-export declare const configureOpenGeoWebStore: (preloadedState?: object, extraReducers?: ReducerMap, extraMiddleWares?: ListenerMiddleware[], extraEnhancers?: EnhancerArray<[
-    StoreEnhancer<{
-        dispatch: ExtractDispatchExtensions<unknown>;
-    }>
-]>, enableDevTools?: boolean | DevToolsEnhancerOptions) => ToolkitStore;
+export declare const configureOpenGeoWebStore: (preloadedState?: object, extraReducers?: ReducerMap, extraMiddleWares?: ListenerMiddleware[], extraEnhancers?: StoreEnhancer[], enableDevTools?: boolean | DevToolsEnhancerOptions) => Store;

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

@@ -19,7 +19,7 @@ export declare const slice: import("@reduxjs/toolkit").Slice<UIStoreType, {
     setActiveWindowId: (draft: Draft<UIStoreType>, action: PayloadAction<SetActiveWindowIdPayload>) => void;
     toggleIsLoadingDialog: (draft: Draft<UIStoreType>, action: PayloadAction<UIToggleIsLoadingPayload>) => void;
     setErrorDialog: (draft: Draft<UIStoreType>, action: PayloadAction<UISetErrorPayload>) => void;
-}, "uiReducer">;
+}, "uiReducer", "uiReducer", import("@reduxjs/toolkit").SliceSelectors<UIStoreType>>;
 export declare const uiReducer: import("redux").Reducer<UIStoreType>, uiActions: import("@reduxjs/toolkit").CaseReducerActions<{
     registerDialog: (draft: Draft<UIStoreType>, action: PayloadAction<UIRegisterDialogPayload>) => void;
     unregisterDialog: (draft: Draft<UIStoreType>, action: PayloadAction<UIUnRegisterDialogPayload>) => void;

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

@@ -1,6 +1,6 @@
 import { TypedUseSelectorHook } from 'react-redux';
 import type { CoreAppStore } from '../types';
-import type { UIModuleState, UIStoreType, UIType } from './types';
+import type { DialogType, UIModuleState, UIStoreType, UIType } from './types';
 export declare const useAppSelector: TypedUseSelectorHook<CoreAppStore>;
 export declare const getUiStore: (store: UIModuleState) => UIStoreType;
 /**
@@ -19,10 +19,26 @@ export declare const getDialogDetailsByType: (store: UIModuleState, dialogType:
  * @param {string} dialogType type of the dialog
  * @returns {boolean} returnType: boolean
  */
-export declare const getisDialogOpen: ((state: UIModuleState, dialogType: string) => boolean) & import("reselect").OutputSelectorFields<(args_0: UIType) => boolean, {
-    clearCache: () => void;
-}> & {
+export declare const getisDialogOpen: ((state: UIModuleState, dialogType: string) => boolean) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: UIType) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: UIType) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(store: UIModuleState, dialogType: string) => UIType];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  *For a given ui component: gets the active map Id
@@ -31,10 +47,26 @@ export declare const getisDialogOpen: ((state: UIModuleState, dialogType: string
  * @param {string} dialogType type of the dialog
  * @returns {string} returnType: string - the active map id
  */
-export declare const getDialogMapId: ((state: UIModuleState, dialogType: string) => string) & import("reselect").OutputSelectorFields<(args_0: UIType) => string, {
-    clearCache: () => void;
-}> & {
+export declare const getDialogMapId: ((state: UIModuleState, dialogType: string) => string) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: UIType) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: UIType) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(store: UIModuleState, dialogType: string) => UIType];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  *For a given ui component: gets the order of visible dialog
@@ -43,10 +75,26 @@ export declare const getDialogMapId: ((state: UIModuleState, dialogType: string)
  * @param {DialogType} dialogType type of the dialog
  * @returns {number} the higher the order number the higher the zIndex
  */
-export declare const getDialogOrder: ((state: UIModuleState, dialogType: string) => number) & import("reselect").OutputSelectorFields<(args_0: number) => number, {
-    clearCache: () => void;
-}> & {
+export declare const getDialogOrder: ((state: UIModuleState, dialogType: string) => number) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: number) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: number) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [(store: UIModuleState, dialogType: DialogType) => number];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  *For a given ui component: returns if ordered on top
@@ -55,15 +103,47 @@ export declare const getDialogOrder: ((state: UIModuleState, dialogType: string)
  * @param {DialogType} dialogType type of the dialog
  * @returns {boolean}
  */
-export declare const getDialogIsOrderedOnTop: ((state: UIModuleState, dialogType: string) => boolean) & import("reselect").OutputSelectorFields<(args_0: boolean) => boolean, {
-    clearCache: () => void;
-}> & {
+export declare const getDialogIsOrderedOnTop: ((state: UIModuleState, dialogType: string) => boolean) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(store: UIModuleState, dialogType: DialogType) => boolean];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getDialogSource: ((state: UIModuleState, dialogType: string) => import("dist/libs/shared/src/lib/components/ToolContainer/ToolContainerDraggable").Source) & import("reselect").OutputSelectorFields<(args_0: UIType) => import("dist/libs/shared/src/lib/components/ToolContainer/ToolContainerDraggable").Source, {
-    clearCache: () => void;
-}> & {
+export declare const getDialogSource: ((state: UIModuleState, dialogType: string) => import("dist/libs/shared/src/lib/components/ToolContainer/ToolContainerDraggable").Source) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: UIType) => import("dist/libs/shared/src/lib/components/ToolContainer/ToolContainerDraggable").Source;
+    memoizedResultFunc: ((resultFuncArgs_0: UIType) => import("dist/libs/shared/src/lib/components/ToolContainer/ToolContainerDraggable").Source) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("dist/libs/shared/src/lib/components/ToolContainer/ToolContainerDraggable").Source;
+    dependencies: [(store: UIModuleState, dialogType: string) => UIType];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  * Get the active window that should receive keyboard shortcuts
@@ -72,10 +152,26 @@ export declare const getDialogSource: ((state: UIModuleState, dialogType: string
  * @param {object} store store object from which the window state will be extracted
  * @returns {string} active window id
  */
-export declare const getActiveWindowId: ((state: UIModuleState) => string) & import("reselect").OutputSelectorFields<(args_0: UIStoreType) => string, {
-    clearCache: () => void;
-}> & {
+export declare const getActiveWindowId: ((state: UIModuleState) => string) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: UIStoreType) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: UIStoreType) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(store: UIModuleState) => UIStoreType];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  * Gets the panelId of which the dialog is opened from
@@ -84,10 +180,26 @@ export declare const getActiveWindowId: ((state: UIModuleState) => string) & imp
  * @param {object} store store object from which the panelId state will be extracted
  * @returns {string} the dialog type
  */
-export declare const getSourcePanelId: ((state: UIModuleState, dialogType: string) => string) & import("reselect").OutputSelectorFields<(args_0: UIType | undefined) => string, {
-    clearCache: () => void;
-}> & {
+export declare const getSourcePanelId: ((state: UIModuleState, dialogType: string) => string) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: UIType | undefined) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: UIType | undefined) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(store: UIModuleState, dialogType: DialogType) => UIType | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  * Gets if this is the active window
@@ -96,19 +208,67 @@ export declare const getSourcePanelId: ((state: UIModuleState, dialogType: strin
  * @param {object} store store object from which the window state will be extracted
  * @returns {string} active window id
  */
-export declare const getIsActiveWindowId: ((state: UIModuleState, viewId: string) => boolean) & import("reselect").OutputSelectorFields<(args_0: UIStoreType, args_1: string) => boolean, {
-    clearCache: () => void;
-}> & {
+export declare const getIsActiveWindowId: ((state: UIModuleState, viewId: string) => boolean) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: UIStoreType, resultFuncArgs_1: string) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: UIStoreType, resultFuncArgs_1: string) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(store: UIModuleState) => UIStoreType, (_store: UIModuleState, viewId: string) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getDialogIsLoading: ((state: UIModuleState, dialogType: string) => boolean) & import("reselect").OutputSelectorFields<(args_0: UIType) => boolean, {
-    clearCache: () => void;
-}> & {
+export declare const getDialogIsLoading: ((state: UIModuleState, dialogType: string) => boolean) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: UIType) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: UIType) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(store: UIModuleState, dialogType: string) => UIType];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getDialogError: ((state: UIModuleState, dialogType: string) => string) & import("reselect").OutputSelectorFields<(args_0: UIType) => string, {
-    clearCache: () => void;
-}> & {
+export declare const getDialogError: ((state: UIModuleState, dialogType: string) => string) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: UIType) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: UIType) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(store: UIModuleState, dialogType: string) => UIType];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 export declare const getUiDialogsByActiveMapId: (store: UIModuleState, mapId: string) => UIType[];

package/src/store/unifyReducerMaps.d.ts

@@ -1,3 +1,3 @@
 import { Action, Reducer } from '@reduxjs/toolkit';
-export type ReducerMap = Record<string, Reducer<any, Action<unknown>>>;
+export type ReducerMap = Record<string, Reducer<any, Action<string>>>;
 export declare const unifyReducerMaps: (reducerMaps: ReducerMap[]) => ReducerMap;