@opengeoweb/store 19.0.0 → 19.1.1

package/dist/src/store/generic/hooks.d.ts

@@ -0,0 +1,6 @@
+import type { PotentialData } from './syncGroups/types';
+import type { FeatureLayer } from '../map/layer/types';
+export declare const useUpdateSharedData: (data: PotentialData, panelId?: string, options?: {
+    requireLinkedMaps?: boolean;
+}) => PotentialData;
+export declare const useUpdateFeatureSyncLayers: (featureLayers: Record<string, FeatureLayer>, panelId?: string) => void;

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

@@ -0,0 +1,27 @@
+export declare const genericActions: {
+    initialSyncState: import("./syncGroups/types").SynchronizationGroupState;
+    setTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetTimePayload, string>;
+    setBbox: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetBboxPayload, string>;
+    setLinkedMap: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").SetLinkedMap, "synchronizationGroupsReducer/setLinkedMap">;
+    updateLinkedMap: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").UpdateLinkedMap, "synchronizationGroupsReducer/updateLinkedMap">;
+    removeLinkedMap: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "synchronizationGroupsReducer/removeLinkedMap">;
+    addFeatureSyncState: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").AddFeatureSyncState, "synchronizationGroupsReducer/addFeatureSyncState">;
+    deleteFeatureSyncState: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").DeleteFeatureSyncState, "synchronizationGroupsReducer/deleteFeatureSyncState">;
+    deleteFeatureLayer: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").DeleteFeatureLayer, "synchronizationGroupsReducer/deleteFeatureLayer">;
+    syncGroupAddSource: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").SyncGroupsAddSourcePayload, "synchronizationGroupsReducer/syncGroupAddSource">;
+    syncGroupRemoveSource: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").SyncGroupRemoveSourcePayload, "synchronizationGroupsReducer/syncGroupRemoveSource">;
+    syncGroupAddTarget: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").SyncGroupAddTargetPayload, "synchronizationGroupsReducer/syncGroupAddTarget">;
+    syncGroupRemoveTarget: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").SyncGroupRemoveTargetPayload, "synchronizationGroupsReducer/syncGroupRemoveTarget">;
+    syncGroupLinkTarget: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").SyncGroupLinkTargetPayload, "synchronizationGroupsReducer/syncGroupLinkTarget">;
+    syncGroupAddGroup: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").SyncGroupAddGroupPayload, "synchronizationGroupsReducer/syncGroupAddGroup">;
+    syncGroupRemoveGroup: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").SyncGroupRemoveGroupPayload, "synchronizationGroupsReducer/syncGroupRemoveGroup">;
+    syncGroupClear: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"synchronizationGroupsReducer/syncGroupClear">;
+    syncGroupSetViewState: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").SyncGroupSetViewStatePayload, "synchronizationGroupsReducer/syncGroupSetViewState">;
+    syncGroupToggleIsTimeScrollingEnabled: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./syncGroups/types").SyncGroupToggleIsTimeScrollingEnabled, "synchronizationGroupsReducer/syncGroupToggleIsTimeScrollingEnabled">;
+};
+export * as genericSelectors from './selectors';
+export * from './hooks';
+export * from './syncGroups';
+export type * as genericTypes from './types';
+export type * from './synchronizationActions/types';
+export * from './loadingIndicator';

package/dist/src/store/generic/linking/constants.d.ts

@@ -0,0 +1,6 @@
+export declare enum SupportedComponentTypes {
+    WarningList = "WarningList",
+    TimeSeries = "TimeSeries",
+    Soundings = "Soundings"
+}
+export declare const supportedComponentTypesForLinking: string[];

package/dist/src/store/generic/linking/index.d.ts

@@ -0,0 +1,2 @@
+export * as linkComponentTypesConstants from './constants';
+export * from './utils';

package/dist/src/store/generic/linking/utils.d.ts

@@ -0,0 +1,9 @@
+interface LinkedViewMeta {
+    componentType?: string;
+}
+interface TakenWarningTimelineOptions {
+    excludedWarningListPanelId?: string;
+}
+export declare const getTakenWarningTimelineIds: (linksByPanelId: Record<string, string[]>, viewsById: Record<string, LinkedViewMeta>, options?: TakenWarningTimelineOptions) => Set<string>;
+export declare const isWarningsTimelineLinkSourceAllowed: (sourceComponentType?: string) => boolean;
+export {};

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

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

package/dist/src/store/generic/loadingIndicator/constants.d.ts

@@ -0,0 +1 @@
+export declare const ANY_EDR_SERVICE = "any_edr";

package/dist/src/store/generic/loadingIndicator/index.d.ts

@@ -0,0 +1,3 @@
+export { loadingIndicatorActions, loadingIndicatorReducer } from './reducer';
+export * as loadingIndicatorSelectors from './selectors';
+export * as loadingIndicatorConstants from './constants';

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

@@ -0,0 +1,13 @@
+import type { PayloadAction, EntityState } from '@reduxjs/toolkit';
+import type { LoadingIndicatorType, SetIsEDRLoadingPayload, SetIsGetCapabilitiesLoadingPayload, SetIsGetMapLoadingPayload } from './types';
+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, 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>>;

package/dist/src/store/generic/loadingIndicator/selectors.d.ts

@@ -0,0 +1,337 @@
+import type { LoadingIndicatorModuleState, LoadingIndicatorType } from './types';
+export declare const selectLoadingIndicatorById: (state: LoadingIndicatorModuleState, id: string) => {
+    id: string;
+    getMapLoadingPercentage: number;
+    isGetCapabilitiesLoading: boolean;
+    isEDRLoading: boolean;
+};
+export declare const getMapLoadingPercentage: ((state: LoadingIndicatorModuleState, id: string) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        id: string;
+        getMapLoadingPercentage: number;
+        isGetCapabilitiesLoading: boolean;
+        isEDRLoading: boolean;
+    }) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        id: string;
+        getMapLoadingPercentage: number;
+        isGetCapabilitiesLoading: boolean;
+        isEDRLoading: boolean;
+    }) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [(state: LoadingIndicatorModuleState, id: string) => {
+        id: string;
+        getMapLoadingPercentage: number;
+        isGetCapabilitiesLoading: boolean;
+        isEDRLoading: boolean;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const isGetMapLoading: ((state: LoadingIndicatorModuleState, id: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: number) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: number) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: LoadingIndicatorModuleState, id: string) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            id: string;
+            getMapLoadingPercentage: number;
+            isGetCapabilitiesLoading: boolean;
+            isEDRLoading: boolean;
+        }) => number;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            id: string;
+            getMapLoadingPercentage: number;
+            isGetCapabilitiesLoading: boolean;
+            isEDRLoading: boolean;
+        }) => number) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => number;
+        dependencies: [(state: LoadingIndicatorModuleState, id: string) => {
+            id: string;
+            getMapLoadingPercentage: number;
+            isGetCapabilitiesLoading: boolean;
+            isEDRLoading: boolean;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const isGetCapabilitiesLoading: ((state: LoadingIndicatorModuleState, id: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        id: string;
+        getMapLoadingPercentage: number;
+        isGetCapabilitiesLoading: boolean;
+        isEDRLoading: boolean;
+    }) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        id: string;
+        getMapLoadingPercentage: number;
+        isGetCapabilitiesLoading: boolean;
+        isEDRLoading: boolean;
+    }) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: LoadingIndicatorModuleState, id: string) => {
+        id: string;
+        getMapLoadingPercentage: number;
+        isGetCapabilitiesLoading: boolean;
+        isEDRLoading: boolean;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const isEDRLoading: ((state: LoadingIndicatorModuleState, id: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        id: string;
+        getMapLoadingPercentage: number;
+        isGetCapabilitiesLoading: boolean;
+        isEDRLoading: boolean;
+    }) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        id: string;
+        getMapLoadingPercentage: number;
+        isGetCapabilitiesLoading: boolean;
+        isEDRLoading: boolean;
+    }) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: LoadingIndicatorModuleState, id: string) => {
+        id: string;
+        getMapLoadingPercentage: number;
+        isGetCapabilitiesLoading: boolean;
+        isEDRLoading: boolean;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const isLoading: ((state: LoadingIndicatorModuleState, id: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: boolean, resultFuncArgs_2: boolean, resultFuncArgs_3: boolean) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: boolean, resultFuncArgs_2: boolean, resultFuncArgs_3: boolean) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: LoadingIndicatorModuleState, id: string) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: number) => boolean;
+        memoizedResultFunc: ((resultFuncArgs_0: number) => boolean) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => boolean;
+        dependencies: [((state: LoadingIndicatorModuleState, id: string) => number) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: {
+                id: string;
+                getMapLoadingPercentage: number;
+                isGetCapabilitiesLoading: boolean;
+                isEDRLoading: boolean;
+            }) => number;
+            memoizedResultFunc: ((resultFuncArgs_0: {
+                id: string;
+                getMapLoadingPercentage: number;
+                isGetCapabilitiesLoading: boolean;
+                isEDRLoading: boolean;
+            }) => number) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => number;
+            dependencies: [(state: LoadingIndicatorModuleState, id: string) => {
+                id: string;
+                getMapLoadingPercentage: number;
+                isGetCapabilitiesLoading: boolean;
+                isEDRLoading: boolean;
+            }];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+            memoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }, ((state: LoadingIndicatorModuleState, id: string) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            id: string;
+            getMapLoadingPercentage: number;
+            isGetCapabilitiesLoading: boolean;
+            isEDRLoading: boolean;
+        }) => boolean;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            id: string;
+            getMapLoadingPercentage: number;
+            isGetCapabilitiesLoading: boolean;
+            isEDRLoading: boolean;
+        }) => boolean) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => boolean;
+        dependencies: [(state: LoadingIndicatorModuleState, id: string) => {
+            id: string;
+            getMapLoadingPercentage: number;
+            isGetCapabilitiesLoading: boolean;
+            isEDRLoading: boolean;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }, ((state: LoadingIndicatorModuleState, id: string) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            id: string;
+            getMapLoadingPercentage: number;
+            isGetCapabilitiesLoading: boolean;
+            isEDRLoading: boolean;
+        }) => boolean;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            id: string;
+            getMapLoadingPercentage: number;
+            isGetCapabilitiesLoading: boolean;
+            isEDRLoading: boolean;
+        }) => boolean) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => boolean;
+        dependencies: [(state: LoadingIndicatorModuleState, id: string) => {
+            id: string;
+            getMapLoadingPercentage: number;
+            isGetCapabilitiesLoading: boolean;
+            isEDRLoading: boolean;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }, ((state: LoadingIndicatorModuleState) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: LoadingIndicatorType | undefined) => boolean;
+        memoizedResultFunc: ((resultFuncArgs_0: LoadingIndicatorType | undefined) => boolean) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => boolean;
+        dependencies: [(store: LoadingIndicatorModuleState) => LoadingIndicatorType | undefined];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/dist/src/store/generic/loadingIndicator/types.d.ts

@@ -0,0 +1,22 @@
+import type { EntityState } from '@reduxjs/toolkit';
+export interface LoadingIndicatorType {
+    id: string;
+    getMapLoadingPercentage: number;
+    isGetCapabilitiesLoading: boolean;
+    isEDRLoading: boolean;
+}
+export interface LoadingIndicatorModuleState {
+    loadingIndicator?: EntityState<LoadingIndicatorType, string>;
+}
+export interface SetIsGetMapLoadingPayload {
+    id: string;
+    getMapLoadingPercentage: number;
+}
+export interface SetIsGetCapabilitiesLoadingPayload {
+    id: string;
+    isGetCapabilitiesLoading: boolean;
+}
+export interface SetIsEDRLoadingPayload {
+    id: string;
+    isEDRLoading: boolean;
+}