@equinor/echo-framework 2.4.1 → 2.4.3

package/src/lib/feature/legend/hooks/useGroupedMarkers.utils.d.ts

@@ -0,0 +1,13 @@
+import { SelectionGroup } from '../../globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.types';
+import { Marker } from '../types/legendMarkerBadge.type';
+/**
+ * Checks if a marker has badges from multiple different item IDs.
+ */
+export declare const hasBadgesFromMultipleItemIds: (marker: Marker) => boolean;
+/**
+ * Gets all potential group keys a marker could generate.
+ * Used for per-marker hidden state subscriptions.
+ * @param marker - The marker to get group keys for
+ * @param itemToGroupsMap - Pre-built map of itemIdString -> selectionGroups - handled in store
+ */
+export declare const getPotentialGroupKeysForMarker: (marker: Marker, itemToGroupsMap: Map<string, SelectionGroup[]>) => string[];

package/src/lib/feature/legend/hooks/useItemToSelectionGroupsMapSubscription.d.ts

@@ -0,0 +1,29 @@
+import { GlobalSelectionTypes } from '../../globalSelection';
+import { ItemToSelectionGroupsMap } from '../stores/itemToSelectionGroupsMapStore/itemToSelectionGroupsMapStore.types';
+interface ItemToSelectionGroupsMapSubscriptionResult {
+    /** The complete itemToSelectionGroupsMap for looking up item -> selection groups */
+    itemToSelectionGroupsMap: ItemToSelectionGroupsMap;
+}
+/**
+ * Subscribes to group membership changes for multiple items (e.g., all badges on a marker).
+ *
+ * This hook is designed for markers that have multiple badges, it watches all of them
+ * and only triggers a re-render when any of the watched items change group membership.
+ * Returns the full itemToSelectionGroupsMap so the caller can look up selection groups for each badge.
+ *
+ * @param watchItemIds - Array of item ID strings to watch (e.g., all badge item IDs from a marker)
+ * @returns Object containing the complete itemToSelectionGroupsMap for lookups
+ *
+ * @example
+ * ```tsx
+ * // Get all badge item IDs from this marker
+ * const badgeItemIds = useMemo(() =>
+ *   marker.badges.map(b => globalSelectionUtils.itemIdToString(b.getItemId())).sort(),
+ *   [marker]
+ * );
+ * // Subscribe to group changes for ALL badges on this marker
+ * const { itemToSelectionGroupsMap } = useItemToSelectionGroupsMapSubscription(badgeItemIds);
+ * ```
+ */
+export declare const useItemToSelectionGroupsMapSubscription: (watchItemIds: GlobalSelectionTypes.ItemIdString[]) => ItemToSelectionGroupsMapSubscriptionResult;
+export {};

package/src/lib/feature/legend/hooks/useLegendHiddenItemsSubscription.d.ts

@@ -0,0 +1,33 @@
+import { LegendUIState } from '../stores/legendUIStore/legendUIStore.types';
+import { LegendId } from '../types/legendType';
+/** Explicit keys from LegendUIState that contain hidden items. Will error if keys don't exist. */
+type HiddenItemsKey = keyof Pick<LegendUIState, 'hiddenMarkers' | 'hiddenBadges'>;
+/**
+ * Subscribes to hidden state changes for multiple keys (e.g., all group keys from a marker).
+ *
+ * This hook is designed for markers that may belong to multiple groups, it watches all
+ * potential keys and only triggers a re-render when ANY of the watched keys change visibility.
+ *
+ * How it works:
+ * - Takes an array of keys (e.g., all possible group keys for this marker's badges)
+ * - Combines them into one subscription that tracks which of YOUR keys are hidden
+ * - Only re-renders when visibility of one of YOUR keys changes, not when any hidden state changes
+ *
+ * @param legendId - The legend ID to subscribe to
+ * @param potentialKeys - Array of keys to watch for visibility changes (e.g., group keys, badge keys)
+ * @param storeKey - Which hidden array to subscribe to (from LegendUIState)
+ * @returns The full hidden items array from the store (for filtering logic)
+ *
+ * @example
+ * ```tsx
+ * // Get all potential group keys for this marker's badges
+ * const groupKeys = useMemo(() =>
+ *   getPotentialGroupKeysForMarker(marker, itemToGroupsMap).map(k => k.toString()).sort(),
+ *   [marker, itemToGroupsMap]
+ * );
+ * // Subscribe to visibility changes for ALL these group keys
+ * const hiddenMarkers = useLegendHiddenItemsSubscription(legendId, groupKeys, 'hiddenMarkers');
+ * ```
+ */
+export declare const useLegendHiddenItemsSubscription: (legendId: LegendId, potentialKeys: string[], storeKey: HiddenItemsKey) => string[];
+export {};

package/src/lib/feature/legend/hooks/useLegendMarker/useLegendMarker.d.ts

@@ -3,9 +3,17 @@ import { LegendDataId, LegendId } from '../../types/legendType';
 export interface UseLegendMarkerProps {
     legendId: LegendId;
     itemIds: LegendDataId[];
-    hiddenMarkers: string[];
 }
 /**
- * Returns the visible markers for the given legendId and itemId.
+ * Returns the visible marker for the given legendId and itemIds.
+ * If the legend is disabled or the marker is hidden, returns undefined.
+ *
+ * Performance optimization:
+ * Uses per-marker subscription to hidden state - only re-renders when THIS specific
+ * marker's visibility changes, not when any marker in the legend is hidden/shown.
+ *
+ * @param props.legendId - The legend to get the marker from
+ * @param props.itemIds - The item IDs to create the marker from
+ * @returns The marker if visible and legend is enabled, undefined otherwise
  */
 export declare function useLegendMarker(props: UseLegendMarkerProps): Marker | undefined;

package/src/lib/feature/legend/hooks/useSelectionItemColorSubscription.d.ts

@@ -0,0 +1,16 @@
+import { GlobalSelectionTypes } from '../../globalSelection';
+/**
+ * Creates a per-marker subscription to selection item color changes.
+ *
+ * Selection color is the color assigned to items in the global selection store
+ * (item.metaData.color). This is used for the marker highlight color on the PDF.
+ * Note: This is NOT the same as badge.getColor() which is the badge's own color.
+ *
+ * This is a performance optimization that only triggers re-renders when
+ * the selection color of THIS marker's specific items changes, not when any
+ * item's color changes in the global selection.
+ *
+ * @param itemIdStrings - Sorted array of item ID strings to watch
+ * @returns A combined key string representing current selection item colors for these items
+ */
+export declare const useSelectionItemColorSubscription: (itemIdStrings: GlobalSelectionTypes.ItemIdString[]) => string;

package/src/lib/feature/legend/hooks/useUniqueBadgeItemIdStrings.d.ts

@@ -0,0 +1,6 @@
+import { GlobalSelectionTypes } from '../../globalSelection';
+import { Marker } from '../types/legendMarkerBadge.type';
+/**
+ * Returns unique item ID strings from all badges on the marker.
+ */
+export declare const useUniqueBadgeItemIdStrings: (marker?: Marker) => GlobalSelectionTypes.ItemIdString[];

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

@@ -1,3 +1,4 @@
+import type { LegendFeedbackVariant } from './components/LegendFeedbackMessage';
 import { getLegendStrategy, injectLegendStrategy } from './legendStrategies/legendCollections';
 import { isLegendDataIdEqualWithTag } from './logic/isLegendDataIdEqualWithTag';
 import { legendExistsInLegendStore, legendSnapShot, legendStoreSubscribe, useAllLegends, useLegendById } from './stores/legendDataStore/legendStore';
@@ -24,6 +25,11 @@ export declare const legendFacade: Readonly<{
         exists: typeof legendExistsInLegendUIStore;
         accordion: {
             toggle: (legendId: LegendId, newValue: boolean) => void;
+            setFeedback: (legendId: LegendId, feedback: {
+                message: string;
+                variant?: LegendFeedbackVariant;
+            } | undefined) => void;
+            resetFeedback: (legendId: LegendId) => void;
         };
         markers: {
             setHidden: (params: {
@@ -31,6 +37,11 @@ export declare const legendFacade: Readonly<{
                 marker: string;
                 isHidden: boolean;
             }) => void;
+            setHiddenBatch: (updates: Array<{
+                legendId: LegendId;
+                marker: string;
+                isHidden: boolean;
+            }>) => void;
         };
         badges: {
             setHidden: (params: {

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

@@ -0,0 +1,22 @@
+import { ItemToSelectionGroupsMapStore } from './itemToSelectionGroupsMapStore.types';
+/**
+ * Store that maintains pre-computed maps for fast item -> group lookups.
+ * Automatically rebuilds when selection groups change.
+ *
+ * Usage for per-marker subscriptions:
+ * ```tsx
+ * // Subscribe only to specific item IDs
+ * const groupKey = useItemToSelectionGroupsMapStore((state) =>
+ *     state.itemToSelectionGroupKeyMap.get(myItemIdString)
+ * );
+ * ```
+ */
+export declare const useItemToSelectionGroupsMapStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ItemToSelectionGroupsMapStore>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: ItemToSelectionGroupsMapStore | Partial<ItemToSelectionGroupsMapStore> | ((state: ItemToSelectionGroupsMapStore) => ItemToSelectionGroupsMapStore | Partial<ItemToSelectionGroupsMapStore>), replace?: boolean | undefined, action?: A | undefined): void;
+}>;
+/**
+ * For read-only access without subscription, use getItemToSelectionGroupsMapStoreState().
+ */
+export declare const getItemToSelectionGroupsMapStoreState: () => ItemToSelectionGroupsMapStore;

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

@@ -0,0 +1,21 @@
+import { Brand } from '@equinor/echo-utils';
+import type { GlobalSelectionTypes } from '../../../globalSelection/globalSelectionStore/globalSelectionStore.types';
+import { SelectionGroup } from '../../../globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.types';
+export type ItemToSelectionGroupsMap = Map<GlobalSelectionTypes.ItemIdString, SelectionGroup[]>;
+export type ItemToSelectionGroupKeyMap = Map<GlobalSelectionTypes.ItemIdString, SelectionGroupsCombinedKey>;
+/**
+ * A combined key representing sorted joined selectionGroup ids, e.g. "groupId1::groupId2"
+ */
+export type SelectionGroupsCombinedKey = Brand<string, 'SelectionGroupsCombinedKey'>;
+interface ItemToSelectionGroupsMapStoreState {
+    /** Map of itemIdString -> SelectionGroup[] for getting full group objects */
+    itemToSelectionGroupsMap: ItemToSelectionGroupsMap;
+    /** Map of itemIdString -> "groupId1::groupId2" for fast key comparison */
+    itemToSelectionGroupKeyMap: ItemToSelectionGroupKeyMap;
+}
+interface ItemToSelectionGroupsMapStoreActions {
+    /** Rebuilds both maps from current selection groups */
+    rebuildMaps: () => void;
+}
+export type ItemToSelectionGroupsMapStore = ItemToSelectionGroupsMapStoreState & ItemToSelectionGroupsMapStoreActions;
+export {};

package/src/lib/feature/legend/stores/itemToSelectionGroupsMapStore/itemToSelectionGroupsMapStore.utils.d.ts

@@ -0,0 +1,14 @@
+import { SelectionGroup } from '../../../globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.types';
+import { ItemToSelectionGroupKeyMap, ItemToSelectionGroupsMap } from './itemToSelectionGroupsMapStore.types';
+/**
+ * Builds a map of itemIdString -> sorted joined groupIds for fast comparison.
+ * You should never need to call this directly; use the store instead.
+ * @internal Only for use within the store and tests.
+ */
+export declare function buildItemToSelectionGroupKeyMap(itemToSelectionGroupsMap: ItemToSelectionGroupsMap): ItemToSelectionGroupKeyMap;
+/**
+ * Builds a map of itemIdString -> selectionGroups for fast lookup.
+ * You should never need to call this directly; use the store instead.
+ * @internal Only for use within the store and tests.
+ */
+export declare function buildItemToSelectionGroupsMap(selectionGroups: SelectionGroup[]): ItemToSelectionGroupsMap;

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

@@ -87,7 +87,6 @@ export declare function legendStoreSubscribe<U>(selector: (state: LegendStore) =
     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.

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

@@ -1,6 +1,11 @@
+import type { LegendFeedbackVariant } from '../../components/LegendFeedbackMessage';
 import { MarkerId } from '../../components/pdfMarkers/utils/markerId.utils';
 import { LegendId } from '../../types/legendType';
 export interface LegendUIState {
+    readonly accordionFeedback?: {
+        message: string;
+        variant?: LegendFeedbackVariant;
+    };
     readonly isAccordionExpanded: boolean;
     readonly hiddenMarkers: string[];
     readonly hiddenBadges: string[];
@@ -25,6 +30,11 @@ export interface LegendUIStoreActions {
         marker: string;
         isHidden: boolean;
     }) => void;
+    setHiddenMarkersBatch: (updates: Array<{
+        legendId: LegendId;
+        marker: string;
+        isHidden: boolean;
+    }>) => void;
     setHiddenBadge: (args: {
         legendId: LegendId;
         badge: string;
@@ -35,5 +45,9 @@ export interface LegendUIStoreActions {
     setSelectionLegendIsHighlightVisible: (visible: boolean) => void;
     setActivePopoverId: (popoverId: MarkerId | undefined) => void;
     setActivePopoverElements: (elements: ReadonlyArray<React.ReactElement>) => void;
+    setAccordionFeedback: (legendId: LegendId, feedback: {
+        message: string;
+        variant?: LegendFeedbackVariant;
+    } | undefined) => void;
 }
 export type LegendUIStore = LegendUIStoreValues & LegendUIStoreActions;

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

@@ -58,10 +58,17 @@ export declare const useLegendVisibleDataStore: import("zustand").UseBoundStore<
     setState(nextStateOrUpdater: LegendVisibleDataStore | Partial<LegendVisibleDataStore> | ((state: {
         data: {
             Tag: {
-                [x: string]: {
+                [x: string]: ({
+                    tagNo: string;
+                    instCode: string;
+                    internalTagType: import("../../../globalSelection").PdmsInternalTagType;
+                    plantNo: string;
+                    plantCode: string;
+                } | {
                     instCode: string;
                     tagNo: string;
-                }[];
+                    internalTagType?: never | undefined;
+                })[];
             };
             Equipment: {
                 [x: string]: {

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

@@ -1,4 +1,4 @@
-import { GlobalSelectionTypes } from '../../globalSelection';
+import type { LegendDataId } from './legendType';
 export interface Marker {
     getTitle: () => string;
     getColor: () => string;
@@ -15,5 +15,5 @@ export interface Badge {
      * Returns a key that can be used for clustering or grouping badges together if they share the same key.
      */
     getDisplayKey: () => string;
-    getItemId: () => GlobalSelectionTypes.ItemId;
+    getItemId: () => LegendDataId;
 }

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

@@ -0,0 +1,38 @@
+type WorkOrderArgs = {
+    workOrderId: string;
+    panelKey?: string;
+    keepLastNavigationItem?: boolean;
+    allowToggle?: boolean;
+};
+/**
+ * Custom React hook that provides a function to open a work order's details in a left panel.
+ *
+ * This hook manages the navigation state for work order details, ensuring that the correct panel is opened
+ * and populated with the appropriate content. If the work order is already open in the specified panel,
+ * it will close the panel instead.
+ *
+ * @returns {(args: WorkOrderArgs) => void} A callback function to open a work order's details panel.
+ *   - `args.workOrderId` (string): The unique identifier of the work order to open.
+ *   - `args.panelKey` (string, optional): The key of the panel to open the work order in. Defaults to `ECHO_CORE_SEARCH` if not provided.
+ *   - `args.keepLastNavigationItem` (boolean, optional): Whether to keep the last navigation item in the panel.
+ *   - `args.allowToggle` (boolean, optional): Whether toggling the panel is allowed.
+ *
+ * @example
+ * const openWorkOrder = useOpenWorkOrderDetails();
+ * openWorkOrder({ workOrderId: '123', panelKey: 'workOrderPanel' });
+ */
+export declare function useOpenWorkOrderDetails(): OpenWorkOrderFn;
+/**
+ * Opens a work order in the left panel navigation.
+ *
+ * If the specified work order is already open in the given panel, it will close the active panel.
+ * Otherwise, it sets the specified panel as active and adds the work order content to the left panel.
+ *
+ * @param args - The arguments required to open the work order.
+ * @param args.workOrderId - The unique identifier of the work order to open.
+ * @param args.panelKey - (Optional) The key of the panel to open the work order in. Defaults to `ECHO_CORE_SEARCH` if not provided.
+ * @param args.keepLastNavigationItem - (Optional) Whether to keep the last navigation item in the panel.
+ * @param args.allowToggle - (Optional) Whether toggling the panel is allowed.
+ */
+export type OpenWorkOrderFn = (args: WorkOrderArgs) => void;
+export {};

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

@@ -31,7 +31,7 @@ interface DataLayerPanelActions {
     toggleIocAnnotations: () => void;
     setIsDataFromStidAnnoDetails: (value: boolean) => void;
 }
-type DataLayerPanelStore = DataLayerPanelState & DataLayerPanelActions;
+export type DataLayerPanelStore = DataLayerPanelState & DataLayerPanelActions;
 export declare const useDataLayerPanelStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<DataLayerPanelStore>, "setState"> & {
     setState<A extends string | {
         type: string;

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

@@ -1,22 +0,0 @@
-import { SelectionGroup } from '../../../../globalSelection';
-import { Marker } from '../../../types/legendMarkerBadge.type';
-import { GroupedMarker } from './splitMarkerByBadgeSelectionGroup.types';
-/**
- * Splits a marker into multiple variants based on badge selection groups.
- *
- * Each variant represents a selection group and contains only badges from that group.
- *
- * Example: Marker with 3 equipment badges at Tag1 position:
- * - Badge A (in SelectionGroupRed)
- * - Badge B (in SelectionGroupRed)
- * - Badge C (in SelectionGroupBlue)
- *
- * Returns 2 marker variants:
- * - Marker variant 1: Badges [A, B], red highlight
- * - Marker variant 2: Badge [C], blue highlight
- *
- * @param marker - The marker to split by badge selection groups
- * @param selectionGroups - Global selection groups
- * @returns Array of marker variants (one per selection group found in badges)
- */
-export declare function splitMarkerByBadgeSelectionGroup(selectionGroups: SelectionGroup[], marker?: Marker): GroupedMarker[];

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

@@ -1,22 +0,0 @@
-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, 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;
-    highlightColor: string;
-    badges: Badge[];
-}
-/**
- * Markers that has been processed based on Selection Groups will have a group key.
- */
-export interface GroupedMarker extends Marker {
-    getGroupKey: () => GroupKey;
-}

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

@@ -1,5 +0,0 @@
-/**
- * Returns all markers for all legends with grouping. Hidden markers are included.
- * Only markers from enabled legends are returned.
- */
-export declare const useAllGroupedMarkersForLegends: () => import("../../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types").GroupedMarker[] | undefined;