@opengeoweb/store 19.1.0 → 19.1.1

package/dist/src/store/generic/syncGroups/__mocks__/mockState.d.ts

@@ -0,0 +1,2 @@
+import type { SynchronizationGroupState } from '../types';
+export declare const createSyncGroupMockState: () => SynchronizationGroupState;

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

@@ -0,0 +1,5 @@
+export declare const SYNCGROUPS_TYPE_SETTIME = "SYNCGROUPS_TYPE_SETTIME";
+export declare const SYNCGROUPS_TYPE_SETBBOX = "SYNCGROUPS_TYPE_SETBBOX";
+export declare const SYNCGROUPS_TYPE_SETFEATURES = "SYNCGROUPS_TYPE_SETFEATURES";
+export declare const SYNCGROUPS_TYPE_SETLAYERACTIONS = "SYNCGROUPS_TYPE_SETLAYERACTIONS";
+export declare const SYNCGROUPS_SET_VIEW_STATE = "SYNCGROUPS_SET_VIEW_STATE";

package/dist/src/store/generic/syncGroups/featureGroupUtils.d.ts

@@ -0,0 +1,11 @@
+import type { SynchronizationGroupState } from './types';
+export declare const WARNING_DIALOG_PANEL_ID = "warning-dialog";
+export type WorkspaceViewsById = Record<string, {
+    componentType?: string;
+}>;
+export declare const getFeatureSourcePanelId: (group: SynchronizationGroupState["groups"]["byId"][string] | undefined) => string | undefined;
+export declare const isFeatureSource: (source: SynchronizationGroupState["sources"]["byId"][string] | undefined) => boolean;
+export declare const isMapSource: (source: SynchronizationGroupState["sources"]["byId"][string] | undefined) => boolean;
+export declare const getMapSourceIds: (state: SynchronizationGroupState) => Set<string>;
+export declare const getFeatureSourceIds: (state: SynchronizationGroupState) => string[];
+export declare const shouldRemoveFeatureGroupForPanel: (panelId: string, views?: WorkspaceViewsById, isActiveFeatureSource?: boolean) => boolean;

package/dist/src/store/generic/syncGroups/featureLinks.d.ts

@@ -0,0 +1,6 @@
+import type { SynchronizationGroupState } from './types';
+export declare const FEATURE_GROUP_PREFIX = "Features_";
+export declare const getFeatureGroupId: (panelId: string) => string;
+export declare const getLinkedTargetIdsForFeatureSourcePanel: (syncState: SynchronizationGroupState | undefined, panelId?: string) => string[];
+export declare const getFeatureLinksForAllPanelsFromState: (syncState: SynchronizationGroupState | undefined) => Record<string, string[]>;
+export declare const getLinkedFeatureSourcePanelIdsForMapId: (linksByPanelId: Record<string, string[]>, mapId: string) => string[];

package/dist/src/store/generic/syncGroups/featureSyncLayers.d.ts

@@ -0,0 +1,10 @@
+import type { Dispatch, UnknownAction } from '@reduxjs/toolkit';
+import type { FeatureLayer, FeatureSyncLayerMetadata, LayerState, ReduxLayer } from '../../map/layer/types';
+export declare const makeFeatureSyncLayerId: (panelId: string, featureLayerKey: string, mapId: string) => string;
+export declare const getFeatureSyncLayerMetadata: (layer?: ReduxLayer) => FeatureSyncLayerMetadata | undefined;
+export declare const getFeatureSyncLayersForPanel: (layersState: LayerState | undefined, panelId: string) => {
+    layerId: string;
+    featureLayerKey: string;
+    mapId: string;
+}[];
+export declare const upsertFeatureSyncLayer: (layersState: LayerState | undefined, dispatch: Dispatch<UnknownAction>, panelId: string, featureLayerKey: string, mapId: string, featureLayerData: FeatureLayer) => void;

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

@@ -0,0 +1,20 @@
+import type { TimeSliderStartEndStepCurrent } from '../../map/map/types';
+/**
+ * Registers/unregisters a panel as a feature-sync source.
+ */
+export declare const useRegisterFeatureSyncSource: (panelId: string) => void;
+/**
+ * This registers a new syncgroup source for given panelId. The source is not synced to any group by default.
+ * When the user links the source with a group, this hook returns an object with the timeslider state (start, end, step and current time) for the panel (if effectively linked).
+ *
+ * How it works:
+ * - Registers/unregisters the source on mount/unmount.
+ * - Returns `{ start, end, step, current }` when linked.
+ * - Uses linked map selected time as `current` when available.
+ * - Falls back to sync source "now" timestamp when
+ *   synced state is not initialized yet.
+ *
+ * @param panelId panelId to register as sync source
+ * @returns timeslider state
+ */
+export declare const useSyncgroupTimeState: (panelId: string, debounceMs?: number) => TimeSliderStartEndStepCurrent | undefined;

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

@@ -0,0 +1,13 @@
+import { syncGroupsListener } from './listener';
+export { syncGroupsListener };
+export { syncGroupsActions, initialState, syncGroupsReducer } from './reducer';
+export * as syncConstants from './constants';
+export * as types from './types';
+export type { SynchronizationGroupModuleState } from './types';
+export * as syncGroupsSelectors from './selectors';
+export * as syncGroupsTypes from './types';
+export * as syncGroupsSelector from './selector';
+export * from './featureLinks';
+export * from './featureSyncLayers';
+export * from './syncSourceDisplayName';
+export * from './hooks';

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

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

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

@@ -0,0 +1,62 @@
+import type { PayloadAction, Draft } from '@reduxjs/toolkit';
+import type { SynchronizationGroupState, SyncGroupAddTargetPayload, SyncGroupAddGroupPayload, SyncGroupRemoveTargetPayload, SyncGroupRemoveGroupPayload, SyncGroupSetViewStatePayload, SyncGroupLinkTargetPayload, SyncGroupRemoveSourcePayload, SyncGroupsAddSourcePayload, SyncGroupToggleIsTimeScrollingEnabled, UpdateLinkedMap, AddFeatureSyncState, DeleteFeatureSyncState, DeleteFeatureLayer, SetLinkedMap } from './types';
+export declare const initialState: SynchronizationGroupState;
+export declare const slice: import("@reduxjs/toolkit").Slice<SynchronizationGroupState, {
+    /** Sets the links map.
+     *  This is used to override the links when changing workspaces.
+     * @param draft sync state
+     * @param {Record<string, string[]>} action.newLinks the new links object
+     */
+    setLinkedMap: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SetLinkedMap>) => void;
+    /** Updates the links map.
+     *  This is used to update the links when operating the link menu.
+     * @param draft sync state
+     * @param {string} action.panelId id of the panel updating it's links
+     * @param {string[]} action.mapIds the new linked maps
+     */
+    updateLinkedMap: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<UpdateLinkedMap>) => void;
+    removeLinkedMap: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<string>) => void;
+    addFeatureSyncState: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<AddFeatureSyncState>) => void;
+    deleteFeatureSyncState: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<DeleteFeatureSyncState>) => void;
+    deleteFeatureLayer: (draft: Draft<SynchronizationGroupState>, _action: PayloadAction<DeleteFeatureLayer>) => void;
+    syncGroupAddSource: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupsAddSourcePayload>) => void;
+    syncGroupRemoveSource: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupRemoveSourcePayload>) => void;
+    syncGroupAddTarget: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupAddTargetPayload>) => void;
+    syncGroupRemoveTarget: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupRemoveTargetPayload>) => void;
+    syncGroupLinkTarget: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupLinkTargetPayload>) => void;
+    syncGroupAddGroup: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupAddGroupPayload>) => void;
+    syncGroupRemoveGroup: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupRemoveGroupPayload>) => void;
+    syncGroupClear: () => SynchronizationGroupState;
+    syncGroupSetViewState: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupSetViewStatePayload>) => void;
+    syncGroupToggleIsTimeScrollingEnabled: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupToggleIsTimeScrollingEnabled>) => void;
+}, "synchronizationGroupsReducer", "synchronizationGroupsReducer", import("@reduxjs/toolkit").SliceSelectors<SynchronizationGroupState>>;
+export declare const syncGroupAddGroup: import("@reduxjs/toolkit").ActionCreatorWithPayload<SyncGroupAddGroupPayload, "synchronizationGroupsReducer/syncGroupAddGroup">, syncGroupAddSource: import("@reduxjs/toolkit").ActionCreatorWithPayload<SyncGroupsAddSourcePayload, "synchronizationGroupsReducer/syncGroupAddSource">, syncGroupAddTarget: import("@reduxjs/toolkit").ActionCreatorWithPayload<SyncGroupAddTargetPayload, "synchronizationGroupsReducer/syncGroupAddTarget">, syncGroupClear: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"synchronizationGroupsReducer/syncGroupClear">, syncGroupLinkTarget: import("@reduxjs/toolkit").ActionCreatorWithPayload<SyncGroupLinkTargetPayload, "synchronizationGroupsReducer/syncGroupLinkTarget">, syncGroupRemoveGroup: import("@reduxjs/toolkit").ActionCreatorWithPayload<SyncGroupRemoveGroupPayload, "synchronizationGroupsReducer/syncGroupRemoveGroup">, syncGroupRemoveSource: import("@reduxjs/toolkit").ActionCreatorWithPayload<SyncGroupRemoveSourcePayload, "synchronizationGroupsReducer/syncGroupRemoveSource">, syncGroupRemoveTarget: import("@reduxjs/toolkit").ActionCreatorWithPayload<SyncGroupRemoveTargetPayload, "synchronizationGroupsReducer/syncGroupRemoveTarget">, syncGroupSetViewState: import("@reduxjs/toolkit").ActionCreatorWithPayload<SyncGroupSetViewStatePayload, "synchronizationGroupsReducer/syncGroupSetViewState">;
+export declare const syncGroupsReducer: import("redux").Reducer<SynchronizationGroupState>, syncGroupsActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    /** Sets the links map.
+     *  This is used to override the links when changing workspaces.
+     * @param draft sync state
+     * @param {Record<string, string[]>} action.newLinks the new links object
+     */
+    setLinkedMap: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SetLinkedMap>) => void;
+    /** Updates the links map.
+     *  This is used to update the links when operating the link menu.
+     * @param draft sync state
+     * @param {string} action.panelId id of the panel updating it's links
+     * @param {string[]} action.mapIds the new linked maps
+     */
+    updateLinkedMap: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<UpdateLinkedMap>) => void;
+    removeLinkedMap: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<string>) => void;
+    addFeatureSyncState: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<AddFeatureSyncState>) => void;
+    deleteFeatureSyncState: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<DeleteFeatureSyncState>) => void;
+    deleteFeatureLayer: (draft: Draft<SynchronizationGroupState>, _action: PayloadAction<DeleteFeatureLayer>) => void;
+    syncGroupAddSource: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupsAddSourcePayload>) => void;
+    syncGroupRemoveSource: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupRemoveSourcePayload>) => void;
+    syncGroupAddTarget: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupAddTargetPayload>) => void;
+    syncGroupRemoveTarget: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupRemoveTargetPayload>) => void;
+    syncGroupLinkTarget: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupLinkTargetPayload>) => void;
+    syncGroupAddGroup: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupAddGroupPayload>) => void;
+    syncGroupRemoveGroup: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupRemoveGroupPayload>) => void;
+    syncGroupClear: () => SynchronizationGroupState;
+    syncGroupSetViewState: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupSetViewStatePayload>) => void;
+    syncGroupToggleIsTimeScrollingEnabled: (draft: Draft<SynchronizationGroupState>, action: PayloadAction<SyncGroupToggleIsTimeScrollingEnabled>) => void;
+}, "synchronizationGroupsReducer">;

package/dist/src/store/generic/syncGroups/selector.d.ts

@@ -0,0 +1,50 @@
+import type { SyncGroupViewState, SynchronizationGroups, SynchronizationSources, SyncType } from './types';
+import type { CoreAppStore } from '../../types';
+export declare const groupTypes: {
+    title: string;
+    syncType: SyncType;
+    groupType: string;
+}[];
+export declare const createSyncGroupViewState: (groups: SynchronizationGroups, sources: SynchronizationSources, viewsById?: Record<string, {
+    id?: string;
+    title?: string;
+    componentType?: string;
+}>, linksByPanelId?: Record<string, string[]>) => SyncGroupViewState;
+export declare const getWorkspaceViewsById: (store: CoreAppStore) => Record<string, {
+    id?: string;
+    title?: string;
+    componentType?: string;
+}> | undefined;
+export declare const createSyncGroupViewStateSelector: ((state: CoreAppStore) => SyncGroupViewState) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SynchronizationGroups, resultFuncArgs_1: SynchronizationSources, resultFuncArgs_2: Record<string, {
+        id?: string;
+        title?: string;
+        componentType?: string;
+    }> | undefined) => SyncGroupViewState;
+    memoizedResultFunc: ((resultFuncArgs_0: SynchronizationGroups, resultFuncArgs_1: SynchronizationSources, resultFuncArgs_2: Record<string, {
+        id?: string;
+        title?: string;
+        componentType?: string;
+    }> | undefined) => SyncGroupViewState) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => SyncGroupViewState;
+    dependencies: [(store: CoreAppStore) => SynchronizationGroups, (store: CoreAppStore) => SynchronizationSources, (store: CoreAppStore) => Record<string, {
+        id?: string;
+        title?: string;
+        componentType?: string;
+    }> | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

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

@@ -0,0 +1,235 @@
+import type { SyncGroupTarget, SynchronizationGroup, SynchronizationGroupState, SynchronizationSource, SyncType } from './types';
+import type { CoreAppStore } from '../../types';
+import type { GenericSyncActionPayload } from '../synchronizationActions/types';
+import type { GenericActionPayload } from '../types';
+export declare const syncGroupStore: (store: CoreAppStore) => SynchronizationGroupState;
+/**
+ * Gets synchronization group state
+ *
+ * Example: synchronizationGroupState = getSynchronizationGroupState(store)
+ * @param {object} store store: object - Store object
+ * @returns {object} returnType: SynchronizationGroupState
+ */
+export declare const getSynchronizationGroupState: (store: CoreAppStore) => SynchronizationGroupState;
+export declare const getSynchronizationGroup: ((state: any, id: any) => SynchronizationGroup) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: string) => SynchronizationGroup;
+    memoizedResultFunc: ((resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: string) => SynchronizationGroup) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => SynchronizationGroup;
+    dependencies: [(store: CoreAppStore) => SynchronizationGroupState, (syncGroupStore: any, id: any) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getSynchronizationGroupSource: ((state: any, id: any) => SynchronizationSource) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: string) => SynchronizationSource;
+    memoizedResultFunc: ((resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: string) => SynchronizationSource) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => SynchronizationSource;
+    dependencies: [(store: CoreAppStore) => SynchronizationGroupState, (syncGroupStore: any, id: any) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getTargets: ((state: any, payload: any, actionType: any) => GenericSyncActionPayload[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: GenericActionPayload, resultFuncArgs_2: SyncType) => GenericSyncActionPayload[];
+    memoizedResultFunc: ((resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: GenericActionPayload, resultFuncArgs_2: SyncType) => GenericSyncActionPayload[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => GenericSyncActionPayload[];
+    dependencies: [(store: CoreAppStore) => SynchronizationGroupState, (syncGroupStore: any, payload: any) => GenericActionPayload, (syncGroupStore: any, payload: any, actionType: any) => SyncType];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getTargetGroups: ((state: any, payload: any, actionType: any) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: GenericActionPayload, resultFuncArgs_2: SyncType) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: GenericActionPayload, resultFuncArgs_2: SyncType) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [(store: CoreAppStore) => SynchronizationGroupState, (syncGroupStore: any, payload: any) => GenericActionPayload, (syncGroupStore: any, payload: any, actionType: any) => SyncType];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getSourceId: ((state: any, sourceId: any) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: string | {
+        sourceId: string;
+    }) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: string | {
+        sourceId: string;
+    }) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(store: CoreAppStore) => SynchronizationGroupState, (syncGroupStore: any, sourceId: any) => {
+        sourceId: string;
+    } | string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getAllTargetGroupsForSource: ((state: any, sourceId: any) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: string) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: string) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [(store: CoreAppStore) => SynchronizationGroupState, ((state: any, sourceId: any) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: string | {
+            sourceId: string;
+        }) => string;
+        memoizedResultFunc: ((resultFuncArgs_0: SynchronizationGroupState, resultFuncArgs_1: string | {
+            sourceId: string;
+        }) => string) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string;
+        dependencies: [(store: CoreAppStore) => SynchronizationGroupState, (syncGroupStore: any, sourceId: any) => {
+            sourceId: string;
+        } | string];
+        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 syncGroupGetViewState: ((state: CoreAppStore) => import("./types").SyncGroupViewState) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SynchronizationGroupState) => import("./types").SyncGroupViewState;
+    memoizedResultFunc: ((resultFuncArgs_0: SynchronizationGroupState) => import("./types").SyncGroupViewState) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").SyncGroupViewState;
+    dependencies: [(store: CoreAppStore) => SynchronizationGroupState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const isTimeScrollingEnabled: (store: CoreAppStore) => boolean;
+export declare const getSyncedMapIdsForTimeslider: ((state: CoreAppStore) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SynchronizationGroupState) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: SynchronizationGroupState) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [(store: CoreAppStore) => SynchronizationGroupState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getSyncGroupTargets: ((state: CoreAppStore) => SyncGroupTarget[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SynchronizationGroupState) => SyncGroupTarget[];
+    memoizedResultFunc: ((resultFuncArgs_0: SynchronizationGroupState) => SyncGroupTarget[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => SyncGroupTarget[];
+    dependencies: [(store: CoreAppStore) => SynchronizationGroupState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/dist/src/store/generic/syncGroups/syncSourceDisplayName.d.ts

@@ -0,0 +1,2 @@
+import type { SyncedWorkspaceViewDetails } from './types';
+export declare const constructSyncSourceDisplayName: (sourceId: string, viewMeta: SyncedWorkspaceViewDetails | undefined, fallbackName: string) => string;

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

@@ -0,0 +1,200 @@
+import type { SystemScope } from '@opengeoweb/shared';
+import type { MapFeatureClass } from '@opengeoweb/webmap-react';
+import type { LoadingIndicatorModuleState } from '../loadingIndicator/types';
+import type { GenericActionPayload } from '../types';
+import type { SYNCGROUPS_TYPE_SETFEATURES, SYNCGROUPS_TYPE_SETLAYERACTIONS } from './constants';
+import { SYNCGROUPS_TYPE_SETBBOX, SYNCGROUPS_TYPE_SETTIME } from './constants';
+export interface Group {
+    id: string;
+    name?: string;
+    selected: string[];
+}
+export interface SourceById {
+    id: string;
+    name: string;
+    disabled?: boolean;
+    disabledForGroupIds?: string[];
+}
+export interface GroupsAndSources {
+    groups: Group[];
+    sourcesById: SourceById[];
+}
+export interface SyncGroupViewState {
+    timeslider: GroupsAndSources;
+    zoompane: GroupsAndSources;
+    level: GroupsAndSources;
+    [key: string]: GroupsAndSources;
+}
+export interface SynchronizationGroup {
+    type: SyncType;
+    title?: string;
+    sourcePanelId?: string;
+    payloadByType: SynchronizationSourcePayLoadByType;
+    targets: {
+        byId: Record<string, {
+            linked: boolean;
+        }>;
+        allIds: string[];
+    };
+}
+export interface Occurrence {
+    id: string;
+    properties: OccurrenceProperties;
+}
+export interface OccurrenceProperties {
+    name?: string;
+    serviceId: string;
+    collectionId: string;
+    parameterName?: string | string[];
+}
+export interface FeatureNameObject {
+    serviceId: string;
+    serviceName?: string;
+    collectionId: string;
+    collectionName: string;
+}
+export interface PotentialDataProperties {
+    originalId?: string;
+    occurrences?: Occurrence[];
+    name?: string;
+    names?: Record<string, FeatureNameObject[]>;
+    hidden?: boolean;
+    inEditMode?: boolean;
+    highlightSelectedFeature?: boolean;
+    highlightNearbyFeature?: boolean;
+    highlightColor?: string;
+    mapFeatureClass?: MapFeatureClass;
+    iconPath?: string;
+    iconWidth?: number;
+    iconHeight?: number;
+    iconAnchor?: [number, number];
+    iconScale?: number;
+    iconFill?: string;
+    iconStroke?: string;
+    iconStrokeWidth?: number;
+    hoverIconFill?: string;
+    hoverIconStroke?: string;
+    hoverIconStrokeWidth?: number;
+    selectedIconFill?: string;
+    selectedIconStroke?: string;
+    selectedIconStrokeWidth?: number;
+    serviceId?: string;
+    selectionType?: string;
+    showNameOnHover?: boolean;
+}
+export interface PotentialData {
+    formFeatures?: {
+        id: string;
+        originalId?: string;
+        geoJSON: GeoJSON.FeatureCollection<GeoJSON.Geometry, PotentialDataProperties | null>;
+    }[];
+    selectedFeatureId?: string;
+}
+export type SynchronizationSourcePayLoadByType = Record<string, GenericActionPayload>;
+export interface SynchronizationSource {
+    types: SyncType[];
+    payloadByType: SynchronizationSourcePayLoadByType;
+    targets?: {
+        byId: Record<string, {
+            linked: boolean;
+        }>;
+        allIds: string[];
+    };
+    featureSyncState?: PotentialData;
+}
+export interface SynchronizationSources {
+    byId: Record<string, SynchronizationSource>;
+    allIds: string[];
+}
+export interface SynchronizationGroups {
+    byId: Record<string, SynchronizationGroup>;
+    allIds: string[];
+}
+export interface SynchronizationGroupState {
+    sources: SynchronizationSources;
+    groups: SynchronizationGroups;
+    viewState: SyncGroupViewState;
+    isTimeScrollingEnabled: boolean;
+}
+export interface SynchronizationGroupModuleState {
+    syncGroups?: SynchronizationGroupState;
+    loadingIndicator?: LoadingIndicatorModuleState['loadingIndicator'];
+}
+export type SyncType = typeof SYNCGROUPS_TYPE_SETBBOX | typeof SYNCGROUPS_TYPE_SETTIME | typeof SYNCGROUPS_TYPE_SETFEATURES | typeof SYNCGROUPS_TYPE_SETLAYERACTIONS;
+export interface SyncGroupsAddSourcePayload {
+    id: string;
+    type: SyncType[];
+    defaultPayload?: GenericActionPayload;
+}
+export interface SyncGroupRemoveSourcePayload {
+    id: string;
+}
+export interface SyncGroupTarget {
+    groupId: string;
+    targetId: string;
+    linked?: boolean;
+    [key: string]: unknown;
+}
+export interface SyncGroupAddTargetPayload extends SyncGroupTarget {
+    origin?: SystemScope;
+}
+export interface SyncGroupRemoveTargetPayload {
+    groupId: string;
+    targetId: string;
+    origin?: SystemScope;
+}
+export interface SyncGroupLinkTargetPayload extends SyncGroupTarget {
+    linked: boolean;
+}
+export interface SyncGroupAddGroupPayload {
+    groupId: string;
+    title: string;
+    type: SyncType;
+    sourcePanelId?: string;
+    origin?: SystemScope;
+}
+export interface SyncGroupRemoveGroupPayload {
+    groupId: string;
+}
+export interface SyncGroupSetViewStatePayload {
+    viewState: SyncGroupViewState;
+}
+export interface SyncGroupToggleIsTimeScrollingEnabled {
+    isTimeScrollingEnabled: boolean;
+    origin?: SystemScope;
+}
+export declare const SyncGroupTypeList: string[];
+export declare enum SyncGroupActionOrigin {
+    delete = "ORIGIN_GENERIC_SYNCHRONIZATIONGROUP_UTILS_DELETEACTION",
+    layerActions = "ORIGIN_GENERIC_SYNCHRONIZATIONGROUP_UTILS_LAYERACTIONS",
+    move = "ORIGIN_GENERIC_SYNCHRONIZATIONGROUP_UTILS_MOVEACTION",
+    add = "ORIGIN_GENERIC_SYNCHRONIZATIONGROUP_UTILS_ADDACTION",
+    autoLayerId = "ORIGIN_GENERIC_SYNCHRONIZATIONGROUP_UTILS_AUTOLAYERIDACTION"
+}
+export interface SetLinkedMap {
+    newLinks: Record<string, string[]>;
+}
+export interface UpdateLinkedMap {
+    panelId: string;
+    mapIds: string[];
+}
+export interface AddFeatureSyncState {
+    panelId: string;
+    data: PotentialData;
+}
+export interface DeleteFeatureSyncState {
+    panelId: string;
+}
+export interface DeleteFeatureLayer {
+    panelId: string;
+    layerId: string;
+}
+export type FormFeatureData = NonNullable<PotentialData['formFeatures']>[number];
+export interface SyncedWorkspaceViewDetails {
+    id?: string;
+    title?: string;
+    componentType?: string;
+}
+export type WorkspaceViewsById = Record<string, {
+    componentType?: string;
+}>;