@equinor/echo-framework 2.2.3 → 2.4.0

package/src/lib/feature/legend/components/pdfMarkers/subComponents/MultipleMarkersByLegends.d.ts

@@ -1,12 +1,8 @@
 import { LegendDataId } from '../../../types/legendType';
-import { PopoverContent, RequestPopoverHandler } from './hooks/usePopoverHandler.types';
 interface MultipleMarkersByLegendsProps {
     itemId: LegendDataId;
     hasPointer: boolean;
-    onOpenPopover: RequestPopoverHandler;
-    onClosePopover: () => void;
-    currentPopover?: PopoverContent;
-    uniqueIdentifier: string;
+    positionId: string;
 }
 export declare const MultipleMarkersByLegends: import("react").MemoExoticComponent<(props: MultipleMarkersByLegendsProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/src/lib/feature/legend/components/pdfMarkers/subComponents/MultipleMarkersBySingleLegend.d.ts

@@ -3,8 +3,7 @@ interface MultipleMarkersBySingleLegendComponentProps {
     legendId: LegendId;
     itemId: LegendDataId;
     hasPointer: boolean;
-    isActive: boolean;
-    onClick: () => void;
+    positionId: string;
 }
 export declare const MultipleMarkersBySingleLegend: import("react").MemoExoticComponent<(props: MultipleMarkersBySingleLegendComponentProps) => import("react/jsx-runtime").JSX.Element[] | null>;
 export {};

package/src/lib/feature/legend/components/pdfMarkers/subComponents/hooks/useMarkerPopover.d.ts

@@ -0,0 +1,19 @@
+import { LegendDataId, LegendId } from '../../../../types/legendType';
+import { MarkerId } from '../../utils/markerId.utils';
+import { GroupedMarker } from '../../utils/splitMarkerByBadgeSelectionGroup.types';
+/**
+ * Hook to manage popover state and async content loading for legend markers.
+ * When fetching, it will show a loading spinner if content takes too long to load.
+ *
+ * @param markerId - Unique identifier for this marker
+ * @param legendId - The legend this marker belongs to
+ * @param itemId - The data ID for this legend item
+ * @param marker - The grouped marker data containing badges
+ * @returns Object with isActive state, elements array, and handlers for open/close
+ */
+export declare function useMarkerPopover(markerId: MarkerId, legendId: LegendId, itemId: LegendDataId, marker: GroupedMarker): {
+    isPopoverActive: boolean;
+    elements: readonly import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>[];
+    handleOpen: () => Promise<void>;
+    handleClose: () => void;
+};

package/src/lib/feature/legend/components/pdfMarkers/utils/markerId.utils.d.ts

@@ -0,0 +1,18 @@
+import { Brand } from '@equinor/echo-utils';
+import { LegendId } from '../../../types/legendType';
+export type MarkerId = Brand<string, 'MarkerId'>;
+/**
+ * Creates a unique marker ID from its component parts.
+ * Format: positionId::legendId::groupKey
+ */
+export declare function createMarkerId(positionId: string, legendId: LegendId, groupKey: string): MarkerId;
+/**
+ * Extracts the position ID from a marker ID.
+ * Returns undefined if the marker ID is invalid.
+ * @internal - Only exported for testing purposes
+ */
+export declare function getPositionIdFromMarkerId(markerId: MarkerId): string | undefined;
+/**
+ * Checks if a marker ID belongs to a specific position.
+ */
+export declare function isMarkerAtPosition(markerId: MarkerId | undefined, positionId: string): boolean;

package/src/lib/feature/legend/components/pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types.d.ts

@@ -1,10 +1,13 @@
 import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionItemType } from '../../../../globalSelection';
 import { Badge, Marker } from '../../../types/legendMarkerBadge.type';
 export interface GroupKey {
-    /** Helper to get the full string representation of the group key based on groupId and color */
+    /** Helper to get the full string representation of the group key based on groupId, color, and optional itemType */
     toString: () => string;
     groupId: Guid;
     color: string;
+    /** Optional item type for local selection which will be split by type */
+    itemType?: GlobalSelectionItemType;
 }
 export interface BadgeGroup {
     groupKey: GroupKey;

package/src/lib/feature/legend/components/selectionLegend/SelectionLegend.d.ts

@@ -1 +1 @@
-export declare const SelectionLegendRenderer: import("react").MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+export declare const SelectionLegendRenderer: import("react").MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element | null>;

package/src/lib/feature/legend/components/selectionLegend/SelectionLegendChip.d.ts

@@ -1,7 +1,7 @@
 interface LegendItemProps {
     label: string;
-    backgroundColor?: string;
     onClick: (isDisabled: boolean) => void;
+    colors: string[];
 }
 export declare const SelectionLegendChip: import("react").MemoExoticComponent<(props: LegendItemProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/src/lib/feature/legend/components/selectionLegend/components/SelectionLegendActions.d.ts

@@ -0,0 +1,5 @@
+/**
+ * SelectionLegendActions renders the action buttons for the Selection Legend.
+ * It provides options to toggle the visibility of highlights around selection group markers.
+ */
+export declare const SelectionLegendActions: () => import("react/jsx-runtime").JSX.Element;

package/src/lib/feature/legend/components/selectionLegend/components/SelectionLegendOtherMarkers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Allows the user to select how to display markers that are not in any selection group.
+ */
+export declare const SelectionLegendOtherMarkers: () => import("react/jsx-runtime").JSX.Element;

package/src/lib/feature/legend/components/selectionLegend/hooks/useSelectionGroupsForLegendRenderer.d.ts

@@ -0,0 +1,5 @@
+import { SelectionGroupDisplay } from './useSelectionGroupsForLegendRenderer.utils';
+/**
+ * Hook to get selection groups formatted for the legend renderer.
+ */
+export declare const useSelectionGroupsForLegendRenderer: () => SelectionGroupDisplay[];

package/src/lib/feature/legend/components/selectionLegend/hooks/useSelectionGroupsForLegendRenderer.utils.d.ts

@@ -0,0 +1,17 @@
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionItemType, SelectionGroup } from '../../../../globalSelection';
+import { GroupedMarker } from '../../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
+export interface SelectionGroupDisplay {
+    readonly label: string;
+    readonly highlightColors: string[];
+    readonly selectionGroupId: Guid;
+    readonly itemType?: GlobalSelectionItemType;
+}
+type GroupMapKey = string;
+type GroupMap = Record<GroupMapKey, SelectionGroupDisplay>;
+/**
+ * Builds a map of selection groups with their colors from grouped markers.
+ * Groups markers by selection group, collecting all unique colors for each group.
+ */
+export declare function buildSelectionGroupMap(allGroupedMarkers: GroupedMarker[] | undefined, selectionGroups: SelectionGroup[]): GroupMap;
+export {};

package/src/lib/feature/legend/components/selectionLegend/selectionLegend.utils.d.ts

@@ -1,6 +1,6 @@
 import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionTypes, SelectionGroup } from '../../../globalSelection';
-import { GroupKey } from '../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
+import { GlobalSelectionItemType, GlobalSelectionTypes, SelectionGroup } from '../../../globalSelection';
+import { GroupedMarker, GroupKey } from '../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
 /**
  * TODO: Remove this flag when Selection Legend is stable and ready for production
  * Flag to enable/disable Selection Legend feature
@@ -15,20 +15,31 @@ export declare const NOT_IN_SELECTION_GROUP_KEY: GroupKey;
  */
 export declare const extractSelectionGroupItemIds: (selectionGroup: SelectionGroup) => GlobalSelectionTypes.ItemId[];
 /**
- * Gets the most frequently used color for a selection group
+ * Determines if groups should be split by item type.
+ * Only true for the default local selection group (Local Selection).
  */
-export declare const getSelectionGroupMostUsedColor: (selectionGroup: SelectionGroup, allGroups: SelectionGroup[]) => string | undefined;
+export declare const shouldSplitGroupsByItemType: (groupId: Guid) => boolean;
 /**
  * Creates a standardized group key for a selection group.
- * This key is used across the legend system to:
+ *
+ * Used across the legend system to:
  * - Identify marker variants split by selection groups (viewport)
  * - Toggle visibility of selection groups (SelectionLegendRenderer)
  * - Filter hidden selection groups (groupMarkersBySelection)
  *
- * Format as string: `group_${groupId}_${color}`
+ * Format: `group_${groupId}_${color}` or `group_${groupId}_${itemType}_${color}` for global selection
  *
  * @param groupId - The unique identifier of the selection group
  * @param color - The highlight color for the group
+ * @param itemType - Optional item type for local selection which will be split by type
  * @returns The standardized group key
  */
-export declare const createSelectionGroupKey: (groupId: Guid, color: string) => GroupKey;
+export declare const createSelectionGroupKey: (groupId: Guid, color: string, itemType?: GlobalSelectionItemType) => GroupKey;
+/**
+ * Checks if a marker belongs to the "Not in Selection" group.
+ *
+ * @param marker - The marker to check.
+ *
+ * @returns True if the marker is in the "Not in Selection" group, false otherwise.
+ */
+export declare const isMarkerOutsideSelection: (marker: GroupedMarker) => boolean;

package/src/lib/feature/legend/legendFacade.d.ts

@@ -1,6 +1,6 @@
 import { getLegendStrategy, injectLegendStrategy } from './legendStrategies/legendCollections';
 import { isLegendDataIdEqualWithTag } from './logic/isLegendDataIdEqualWithTag';
-import { legendExistsInLegendStore, legendSnapShot, useAllLegends, useLegendById } from './stores/legendDataStore/legendStore';
+import { legendExistsInLegendStore, legendSnapShot, legendStoreSubscribe, useAllLegends, useLegendById } from './stores/legendDataStore/legendStore';
 import { legendExistsInLegendUIStore, useLegendUIById } from './stores/legendUIStore/legendUIStore';
 import { visibleDataAsTagsSnapshot } from './stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore';
 import { LegendId } from './types/legendType';
@@ -17,13 +17,7 @@ export declare const legendFacade: Readonly<{
         useById: typeof useLegendById;
         exists: typeof legendExistsInLegendStore;
         snapshot: typeof legendSnapShot;
-        subscribe: {
-            (listener: (selectedState: import("./stores/legendDataStore/legendStore").LegendStoreData & import("./stores/legendDataStore/legendStore").LegendStoreActions, previousSelectedState: import("./stores/legendDataStore/legendStore").LegendStoreData & import("./stores/legendDataStore/legendStore").LegendStoreActions) => void): () => void;
-            <U>(selector: (state: import("./stores/legendDataStore/legendStore").LegendStoreData & import("./stores/legendDataStore/legendStore").LegendStoreActions) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-                equalityFn?: ((a: U, b: U) => boolean) | undefined;
-                fireImmediately?: boolean;
-            } | undefined): () => void;
-        };
+        subscribe: typeof legendStoreSubscribe;
     };
     ui: {
         useById: typeof useLegendUIById;
@@ -97,7 +91,40 @@ export declare const legendFacade: Readonly<{
                 } | undefined): () => void;
             };
         }, "setState"> & {
-            setState(nextStateOrUpdater: import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore | Partial<import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore> | ((state: import("immer").WritableDraft<import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+            setState(nextStateOrUpdater: import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore | Partial<import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore> | ((state: {
+                tags: {
+                    tagNo: string;
+                    instCode: string;
+                    equipmentId: string | undefined;
+                    tagSummary: {
+                        instCode: string;
+                        pdmsPlantCode: string | undefined;
+                        tagCategoryDescription: string;
+                        tagCategory: number;
+                        tagStatus: import("@equinor/echo-search").TagStatus;
+                        tagType: string;
+                        updatedDate: Date;
+                        locationCode: string;
+                        contrCode: string;
+                        plantNo: string;
+                        poNo: string;
+                        xCoordinate?: number | undefined;
+                        yCoordinate?: number | undefined;
+                        zCoordinate?: number | undefined;
+                        additionalFields: {
+                            type: string;
+                            value: string;
+                        }[];
+                        tagNo: string;
+                        description: string;
+                        projectCode: string;
+                        system: string;
+                    };
+                }[];
+                isPending: boolean;
+                updateTags: (tags: import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore.type").TagWithEquipmentId[]) => void;
+                setIsPending: (isPending: boolean) => void;
+            }) => void), shouldReplace?: boolean | undefined, action?: string | {
                 type: string;
             } | undefined): void;
         }>;

package/src/lib/feature/legend/stores/legendDataStore/legendStore.d.ts

@@ -1,4 +1,3 @@
-import { PersistOptions } from 'zustand/middleware';
 import { LegendId, LegendState } from '../../types/legendType';
 type LegendsDictionary = Record<LegendId, LegendState>;
 export interface LegendStoreData {
@@ -12,37 +11,6 @@ export interface LegendStoreActions {
     initializeLegendInStore: (legendId: LegendId) => void;
 }
 type LegendStore = LegendStoreData & LegendStoreActions;
-type PersistedLegendState = Omit<LegendState, 'isLoading'>;
-type PersistedLegendStoreData = {
-    legends: Record<LegendId, PersistedLegendState>;
-};
-export declare const useLegendStore: import("zustand").UseBoundStore<Omit<Omit<Omit<Omit<import("zustand").StoreApi<LegendStore>, "setState"> & {
-    setState<A extends string | {
-        type: string;
-    }>(partial: LegendStore | Partial<LegendStore> | ((state: LegendStore) => LegendStore | Partial<LegendStore>), replace?: boolean | undefined, action?: A | undefined): void;
-}, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: LegendStore, previousSelectedState: LegendStore) => void): () => void;
-        <U>(selector: (state: LegendStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}, "persist"> & {
-    persist: {
-        setOptions: (options: Partial<PersistOptions<LegendStore, PersistedLegendStoreData>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => Promise<void> | void;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: LegendStore) => void) => () => void;
-        onFinishHydration: (fn: (state: LegendStore) => void) => () => void;
-        getOptions: () => Partial<PersistOptions<LegendStore, PersistedLegendStoreData>>;
-    };
-}, "setState"> & {
-    setState(nextStateOrUpdater: LegendStore | Partial<LegendStore> | ((state: import("immer").WritableDraft<LegendStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
-        type: string;
-    } | undefined): void;
-}>;
 /**
  * Hook to access a legend by ID with optional property selection for optimized re-renders.
  *
@@ -90,11 +58,39 @@ export declare function legendExistsInLegendStore(legendId: LegendId): boolean;
 export declare function useAllLegends(): LegendState[];
 export declare function useAllLegends<T>(selector: (legends: LegendState[]) => T): T;
 export declare function legendSnapShot(): LegendStore;
-export declare const legendStoreSubscribe: {
-    (listener: (selectedState: LegendStore, previousSelectedState: LegendStore) => void): () => void;
-    <U>(selector: (state: LegendStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-        equalityFn?: ((a: U, b: U) => boolean) | undefined;
-        fireImmediately?: boolean;
-    } | undefined): () => void;
-};
+/**
+ * Subscribe to legend store changes with optional selector for granular updates.
+ *
+ * NOTE: This wrapper is required because useLegendStore has an explicit type annotation
+ * (UseBoundStore<StoreApi<T>>) to prevent rollup build errors with useLegacyTypescriptPlugin: false.
+ *
+ * Without explicit type, TypeScript infers Immer's internal types (WritableNonArrayDraft, etc.)
+ * which use complex generics that rollup's @rollup/plugin-typescript cannot "name" in generated
+ * .d.ts files, causing TS4023: "Exported variable has or is using name 'X' but cannot be named."
+ *
+ * The explicit type hides these internals from rollup, but also removes subscribeWithSelector's
+ * enhanced subscribe(selector, listener) signature. This wrapper manually restores both overloads.
+ *
+ * @example
+ * // Watch entire store:
+ * const unsubscribe = legendStoreSubscribe((state) => console.log('Changed:', state));
+ *
+ * @example
+ * // Watch specific property:
+ * const unsubscribe = legendStoreSubscribe(
+ *   (state) => state.legends['Tag Legend']?.isEnabled,
+ *   (isEnabled, prevIsEnabled) => console.log('Enabled changed:', isEnabled)
+ * );
+ */
+export declare function legendStoreSubscribe(listener: (state: LegendStore, prevState: LegendStore) => void): () => void;
+export declare function legendStoreSubscribe<U>(selector: (state: LegendStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+    equalityFn?: (a: U, b: U) => boolean;
+    fireImmediately?: boolean;
+}): () => void;
+export declare const getLegendStoreState: () => LegendStore;
+/**
+ * TEST ONLY: Reset legend store to a specific state.
+ * Only use this in tests for setup/cleanup.
+ */
+export declare const __TEST__resetLegendStore: (state: Partial<LegendStoreData>) => void;
 export {};

package/src/lib/feature/legend/stores/legendUIStore/legendUIStore.d.ts

@@ -1,11 +1,10 @@
+import { type StoreApi, type UseBoundStore } from 'zustand';
 import { LegendId } from '../../types/legendType';
 import { LegendUIState, LegendUIStore } from './legendUIStore.types';
 /**
  * Non-persisted store for managing UI state of legends, such as accordion expansion and hidden markers/badges.
  */
-export declare const useLegendUIStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<LegendUIStore>, "setState"> & {
-    setState(nextStateOrUpdater: LegendUIStore | Partial<LegendUIStore> | ((state: import("immer").WritableDraft<LegendUIStore>) => void), shouldReplace?: boolean | undefined): void;
-}>;
+export declare const useLegendUIStore: UseBoundStore<StoreApi<LegendUIStore>>;
 /**
  * Hook to access a legend by ID with optional property selection for optimized re-renders.
  *
@@ -30,3 +29,9 @@ export declare const useLegendUIStore: import("zustand").UseBoundStore<Omit<impo
 export declare function useLegendUIById(legendId: LegendId): LegendUIState | undefined;
 export declare function useLegendUIById<T>(legendId: LegendId, selector: (legend: LegendUIState | undefined) => T): T;
 export declare function legendExistsInLegendUIStore(legendId: LegendId): boolean;
+/**
+ * Helper function to toggle visibility of an item in an array.
+ * Adds the item if isHidden is true and it's not present, removes it if isHidden is false and it exists.
+ * @internal - Exported for testing purposes only
+ */
+export declare function toggleItemInArray(array: string[], item: string, isHidden: boolean): void;

package/src/lib/feature/legend/stores/legendUIStore/legendUIStore.types.d.ts

@@ -1,3 +1,4 @@
+import { MarkerId } from '../../components/pdfMarkers/utils/markerId.utils';
 import { LegendId } from '../../types/legendType';
 export interface LegendUIState {
     readonly isAccordionExpanded: boolean;
@@ -5,8 +6,17 @@ export interface LegendUIState {
     readonly hiddenBadges: string[];
 }
 export type LegendUIDictionary = Record<LegendId, LegendUIState>;
+export type MarkersOutsideSelectionVisibility = 'Show' | 'Ghost' | 'Hide';
 export type LegendUIStoreValues = {
-    legends: LegendUIDictionary;
+    readonly legends: LegendUIDictionary;
+    readonly activePopover: {
+        readonly id?: MarkerId;
+        readonly elements: ReadonlyArray<React.ReactElement>;
+    };
+    readonly selectionLegend: {
+        readonly isHighlightVisible: boolean;
+        readonly markersOutsideSelectionVisibility: MarkersOutsideSelectionVisibility;
+    };
 };
 export interface LegendUIStoreActions {
     toggleAccordion: (legendId: LegendId, newValue: boolean) => void;
@@ -20,6 +30,10 @@ export interface LegendUIStoreActions {
         badge: string;
         isHidden: boolean;
     }) => void;
+    setMarkersOutsideSelectionVisibility: (visibility: MarkersOutsideSelectionVisibility) => void;
     initializeLegendInStore: (legendId: LegendId) => void;
+    setSelectionLegendIsHighlightVisible: (visible: boolean) => void;
+    setActivePopoverId: (popoverId: MarkerId | undefined) => void;
+    setActivePopoverElements: (elements: ReadonlyArray<React.ReactElement>) => void;
 }
 export type LegendUIStore = LegendUIStoreValues & LegendUIStoreActions;

package/src/lib/feature/legend/stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore.d.ts

@@ -32,7 +32,40 @@ export declare const useVisibleDataAsTagsStore: import("zustand").UseBoundStore<
         } | undefined): () => void;
     };
 }, "setState"> & {
-    setState(nextStateOrUpdater: VisibleDataAsTagsStore | Partial<VisibleDataAsTagsStore> | ((state: import("immer").WritableDraft<VisibleDataAsTagsStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+    setState(nextStateOrUpdater: VisibleDataAsTagsStore | Partial<VisibleDataAsTagsStore> | ((state: {
+        tags: {
+            tagNo: string;
+            instCode: string;
+            equipmentId: string | undefined;
+            tagSummary: {
+                instCode: string;
+                pdmsPlantCode: string | undefined;
+                tagCategoryDescription: string;
+                tagCategory: number;
+                tagStatus: import("@equinor/echo-search").TagStatus;
+                tagType: string;
+                updatedDate: Date;
+                locationCode: string;
+                contrCode: string;
+                plantNo: string;
+                poNo: string;
+                xCoordinate?: number | undefined;
+                yCoordinate?: number | undefined;
+                zCoordinate?: number | undefined;
+                additionalFields: {
+                    type: string;
+                    value: string;
+                }[];
+                tagNo: string;
+                description: string;
+                projectCode: string;
+                system: string;
+            };
+        }[];
+        isPending: boolean;
+        updateTags: (tags: TagWithEquipmentId[]) => void;
+        setIsPending: (isPending: boolean) => void;
+    }) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;
     } | undefined): void;
 }>;

package/src/lib/feature/legend/stores/legendVisibleDataStore/legendVisibleDataStore.d.ts

@@ -55,7 +55,26 @@ export declare const useLegendVisibleDataStore: import("zustand").UseBoundStore<
         } | undefined): () => void;
     };
 }, "setState"> & {
-    setState(nextStateOrUpdater: LegendVisibleDataStore | Partial<LegendVisibleDataStore> | ((state: import("immer").WritableDraft<LegendVisibleDataStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+    setState(nextStateOrUpdater: LegendVisibleDataStore | Partial<LegendVisibleDataStore> | ((state: {
+        data: {
+            Tag: {
+                [x: string]: {
+                    instCode: string;
+                    tagNo: string;
+                }[];
+            };
+            Equipment: {
+                [x: string]: {
+                    equipmentId: string;
+                }[];
+            };
+        };
+        addData: <T extends KnownDataTypeKeys>(type: T, key: string, value: ResolvedDataType<T>[]) => void;
+        removeData: (key: string) => void;
+        getData: <T extends KnownDataTypeKeys>(type: T) => ResolvedDataType<T>[];
+        useDataByType: <T extends KnownDataTypeKeys>(type: T) => ResolvedDataType<T>[];
+        getAll: () => LegendDataId[];
+    }) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;
     } | undefined): void;
 }>;

package/src/lib/feature/legend/types/legendStrategy.type.d.ts

@@ -1,3 +1,4 @@
+import { GlobalSelectionTypes } from '../../globalSelection';
 import { Marker } from './legendMarkerBadge.type';
 import { LegendDataId, LegendId, LegendOptionConfig } from './legendType';
 /**
@@ -28,14 +29,17 @@ export interface LegendStrategy {
      */
     useMarkers: (itemIds: ReadonlyArray<LegendDataId>, isViewport?: boolean) => ReadonlyArray<Marker>;
     /**
-     * Returns popover content that supports pagination for the given itemId.
+     * Returns popover content that supports pagination for the given legendDataId.
+     * One legendDataId can have multiple items associated with it, for example a tag can have multiple work orders.
+     * Often we don't want to show all items (eg. when items are grouped), so we provide itemIds to filter the content to only relevant items.
      *
      * This function is asynchronous because the popover content may depend on data that needs to be fetched before rendering,
      * such as related equipment, work orders, or other resources.
-     * @param {LegendDataId} itemId - The identifier for the legend item for which to render popover content.
+     * @param {LegendDataId} legendDataId - The identifier for the legend item for which to render popover content.
+     * @param {ReadonlyArray<GlobalSelectionTypes.ItemId>} itemIds - The item ids to be included in the popover content.
      * @returns A Promise resolving to one or more React elements to display in the popover.
      */
-    popoverContent: (itemId: LegendDataId) => Promise<React.JSX.Element | ReadonlyArray<React.JSX.Element>>;
+    popoverContent: (legendDataId: LegendDataId, itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>) => Promise<React.ReactElement | ReadonlyArray<React.ReactElement>>;
     /**
      * Returns the custom legend component for the legend, if this is omitted the default basicLegendRenderer will be used
      */

package/src/lib/hooks/useOpenPrepview.d.ts

@@ -29,7 +29,7 @@ export declare function useOpenPrepview(): (args: {
         punchId?: string;
         instCode?: string;
     };
-    panelKey: string;
+    panelKey?: string;
     keepLastNavigationItem?: boolean;
     allowToggle?: boolean;
 }) => void;

package/src/lib/services/dataLayerPanel/dataLayerPanel.store.d.ts

@@ -1,23 +1,37 @@
-import { WritableDraft } from 'immer';
-interface PanelUserSettings {
-    readonly isTagsVisible: boolean;
-    readonly isWorkOrdersVisible: boolean;
-    readonly isEquipmentsVisible: boolean;
-    readonly isIocAnnotationsVisible: boolean;
+export interface PanelUserSettings {
+    isTagsVisible: boolean;
+    isTagsFromDocumentVisible: boolean;
+    isTagsFromSelectionVisible: boolean;
+    isWorkOrdersVisible: boolean;
+    isWorkOrdersFromDocumentVisible: boolean;
+    isWorkOrdersFromSelectionVisible: boolean;
+    isEquipmentsVisible: boolean;
+    isEquipmentsFromDocumentVisible: boolean;
+    isEquipmentsFromSelectionVisible: boolean;
+    isIocAnnotationsVisible: boolean;
+    isDataFromStidAnnoDetails: boolean;
 }
-interface DataLayerPanelState {
-    readonly isOpen: boolean;
+export interface DataLayerPanelState {
+    isOpen: boolean;
     readonly userSettings: PanelUserSettings;
 }
 interface DataLayerPanelActions {
     togglePanel: () => void;
+    toggleTags: () => void;
+    toggleTagsFromDocumentVisible: () => void;
+    toggleTagsFromSelectionVisible: () => void;
     toggleWorkOrders: () => void;
+    toggleWorkOrdersFromDocumentVisible: () => void;
+    toggleWorkOrdersFromSelectionVisible: () => void;
     toggleEquipments: () => void;
-    toggleTags: () => void;
+    toggleEquipmentsFromDocumentVisible: () => void;
+    toggleEquipmentsFromSelectionVisible: () => void;
+    setEquipmentsForEcm: () => void;
     toggleIocAnnotations: () => void;
+    setIsDataFromStidAnnoDetails: (value: boolean) => void;
 }
 type DataLayerPanelStore = DataLayerPanelState & DataLayerPanelActions;
-export declare const useDataLayerPanelStore: import("zustand").UseBoundStore<Omit<Omit<Omit<Omit<import("zustand").StoreApi<DataLayerPanelStore>, "setState"> & {
+export declare const useDataLayerPanelStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<DataLayerPanelStore>, "setState"> & {
     setState<A extends string | {
         type: string;
     }>(partial: DataLayerPanelStore | Partial<DataLayerPanelStore> | ((state: DataLayerPanelStore) => DataLayerPanelStore | Partial<DataLayerPanelStore>), replace?: boolean | undefined, action?: A | undefined): void;
@@ -29,18 +43,36 @@ export declare const useDataLayerPanelStore: import("zustand").UseBoundStore<Omi
             fireImmediately?: boolean;
         } | undefined): () => void;
     };
-}, "persist"> & {
-    persist: {
-        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<DataLayerPanelStore, unknown>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => Promise<void> | void;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: DataLayerPanelStore) => void) => () => void;
-        onFinishHydration: (fn: (state: DataLayerPanelStore) => void) => () => void;
-        getOptions: () => Partial<import("zustand/middleware").PersistOptions<DataLayerPanelStore, unknown>>;
-    };
 }, "setState"> & {
-    setState(nextStateOrUpdater: DataLayerPanelStore | Partial<DataLayerPanelStore> | ((state: WritableDraft<DataLayerPanelStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+    setState(nextStateOrUpdater: DataLayerPanelStore | Partial<DataLayerPanelStore> | ((state: {
+        isOpen: boolean;
+        userSettings: {
+            isTagsVisible: boolean;
+            isTagsFromDocumentVisible: boolean;
+            isTagsFromSelectionVisible: boolean;
+            isWorkOrdersVisible: boolean;
+            isWorkOrdersFromDocumentVisible: boolean;
+            isWorkOrdersFromSelectionVisible: boolean;
+            isEquipmentsVisible: boolean;
+            isEquipmentsFromDocumentVisible: boolean;
+            isEquipmentsFromSelectionVisible: boolean;
+            isIocAnnotationsVisible: boolean;
+            isDataFromStidAnnoDetails: boolean;
+        };
+        togglePanel: () => void;
+        toggleTags: () => void;
+        toggleTagsFromDocumentVisible: () => void;
+        toggleTagsFromSelectionVisible: () => void;
+        toggleWorkOrders: () => void;
+        toggleWorkOrdersFromDocumentVisible: () => void;
+        toggleWorkOrdersFromSelectionVisible: () => void;
+        toggleEquipments: () => void;
+        toggleEquipmentsFromDocumentVisible: () => void;
+        toggleEquipmentsFromSelectionVisible: () => void;
+        setEquipmentsForEcm: () => void;
+        toggleIocAnnotations: () => void;
+        setIsDataFromStidAnnoDetails: (value: boolean) => void;
+    }) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;
     } | undefined): void;
 }>;

package/src/lib/services/leftPanelNavigation/leftPanelNavigation.store.d.ts

@@ -1,13 +1,16 @@
+import { StoreApi, UseBoundStore } from 'zustand';
 import { LeftPanelNavigationStore } from './leftPanelNavigation.store.types';
-export declare const useLeftPanelNavigationStore: import("zustand").UseBoundStore<Omit<Omit<import("zustand").StoreApi<LeftPanelNavigationStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: LeftPanelNavigationStore, previousSelectedState: LeftPanelNavigationStore) => void): () => void;
-        <U>(selector: (state: LeftPanelNavigationStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}, "setState"> & {
-    setState(nextStateOrUpdater: LeftPanelNavigationStore | Partial<LeftPanelNavigationStore> | ((state: import("immer").WritableDraft<LeftPanelNavigationStore>) => void), shouldReplace?: boolean | undefined): void;
-}>;
+/**
+ * IMPORTANT: Explicit type annotation required for rollup builds with useLegacyTypescriptPlugin: false
+ *
+ * Without explicit type, TypeScript infers the full type including Immer's internal types like
+ * WritableNonArrayDraft which use complex generics that rollup's @rollup/plugin-typescript cannot
+ * "name" in generated .d.ts files, causing TS4023 errors.
+ *
+ * Trade-off: UseBoundStore<StoreApi<T>> removes subscribeWithSelector's enhanced subscribe(selector, listener)
+ * signature, leaving only the base subscribe(listener). Store still fully functional via hook and .getState().
+ *
+ * Stores NOT exported from public API (index.ts) can omit this explicit type and preserve middleware signatures.
+ */
+export declare const useLeftPanelNavigationStore: UseBoundStore<StoreApi<LeftPanelNavigationStore>>;
 export declare function getLeftPanelNavigationState(): LeftPanelNavigationStore;