@equinor/echo-framework 6.0.0 → 6.2.0

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.d.ts

@@ -84,6 +84,15 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
                 label: string;
                 items: Map<import("../..").GlobalSelectionTypes.ItemIdString, {
                     id: {
+                        x: number;
+                        y: number;
+                        z: number;
+                        name: string;
+                        description: string | undefined;
+                        instCode: string;
+                        plantCode: string;
+                        plantNo: string;
+                    } | {
                         workOrderId: string;
                     } | {
                         instCode: string;
@@ -102,6 +111,15 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
                     type: import("../..").GlobalSelectionItemType;
                     relatedTo?: {
                         id: {
+                            x: number;
+                            y: number;
+                            z: number;
+                            name: string;
+                            description: string | undefined;
+                            instCode: string;
+                            plantCode: string;
+                            plantNo: string;
+                        } | {
                             workOrderId: string;
                         } | {
                             instCode: string;

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.types.d.ts

@@ -1,17 +1,14 @@
 import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionItemType, GlobalSelectionTypes, RelatedToItemType, RelatedToItemTypeToIdMap, SelectionItemTypeToItemIdMap } from '../../globalSelectionStore/globalSelectionStore.types';
+import { GlobalSelectionItemType, GlobalSelectionTypes, RelatedToItem, SelectionItemTypeToItemIdMap } from '../../globalSelectionStore/globalSelectionStore.types';
 import { AddItemArgs, AddItemsResponse, SelectionTreeActionResult } from './actions/selectionTree.action.types';
 export declare enum GlobalSelectionCategoryId {
     Tags = "DEFAULT_TAG_LIST_ID",
     WorkOrders = "DEFAULT_WORK_ORDER_LIST_ID",
     Equipments = "DEFAULT_EQUIPMENT_LIST_ID",
-    MeasuringPoints = "DEFAULT_MEASURING_POINT_LIST_ID"
+    MeasuringPoints = "DEFAULT_MEASURING_POINT_LIST_ID",
+    Coordinates = "DEFAULT_COORDINATE_LIST_ID"
 }
 export declare const globalSelectionDefaultGroupId: Guid;
-export interface RelatedToItem {
-    readonly id: RelatedToItemTypeToIdMap[RelatedToItemType];
-    readonly type: RelatedToItemType;
-}
 export type SelectionTreeItem<T extends GlobalSelectionItemType> = {
     readonly id: SelectionItemTypeToItemIdMap[T];
     readonly type: T;

package/src/lib/feature/globalSelection/strategies/coordinateSelection.strategy.d.ts

@@ -0,0 +1,3 @@
+import { GlobalSelectionItemType } from '../globalSelectionStore/globalSelectionStore.types';
+import type { SelectionItemTypeStrategy } from './selectionItemTypeStrategy.types';
+export declare const coordinateSelectionStrategy: SelectionItemTypeStrategy<GlobalSelectionItemType.Coordinate>;

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

@@ -1,12 +1,11 @@
 import { ItemMarkerSize } from '@equinor/echo-components';
 import React from 'react';
-import { ColorGroupedMarker } from '../utils/splitMarkerByColor.types';
+import { CombinedMarker } from '../../../types/legendMarkerBadge.type';
 interface LegendColoredMarkerIconProps {
-    hasPointer: boolean;
-    isActive: boolean;
-    onClick: () => void;
-    hiddenBadges: string[];
-    marker: ColorGroupedMarker;
+    readonly hasPointer: boolean;
+    readonly isActive: boolean;
+    readonly onClick: () => void;
+    readonly marker: CombinedMarker;
 }
 /**
  * Renders a colored marker icon with optional pointer and badges.
@@ -14,8 +13,7 @@ interface LegendColoredMarkerIconProps {
  * @param {boolean} hasPointer - Flag to indicate if the marker should have a pointer, currently in lower right corner.
  * @param {boolean} isActive - Flag to indicate if the marker is active (selected).
  * @param {() => void} onClick - Callback invoked when the marker is clicked.
- * @param {string[]} hiddenBadges - Array of badge titles that should be hidden.
- * @param {Marker} marker - The marker data to be rendered.
+ * @param {CombinedMarker} marker - The marker data to be rendered.
  *
  * @returns {React.JSX.Element | null} The rendered colored marker icon or null if no marker is provided.
  *
@@ -24,7 +22,6 @@ interface LegendColoredMarkerIconProps {
  *   hasPointer={true}
  *   isActive={false}
  *   onClick={() => console.log('Marker clicked')}
- *   hiddenBadges={['Badge1', 'Badge2']}
  *   marker={markerData}
  * />
  */

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

@@ -1,13 +1,12 @@
 import type { MarkerId } from '../../../../shared/markerId.types';
+import { CombinedMarker } from '../../../types/legendMarkerBadge.type';
 import { LegendDataId, LegendId } from '../../../types/legendType';
-import { ColorGroupedMarker } from '../utils/splitMarkerByColor.types';
 interface MarkerWithPopoverProps {
-    legendId: LegendId;
-    hasPointer: boolean;
-    hiddenBadges: string[];
-    marker: ColorGroupedMarker;
-    itemId: LegendDataId;
-    markerId: MarkerId;
+    readonly legendId: LegendId;
+    readonly hasPointer: boolean;
+    readonly marker: CombinedMarker;
+    readonly itemId: LegendDataId;
+    readonly markerId: MarkerId;
 }
 export declare const MarkerWithPopover: (props: MarkerWithPopoverProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,13 +1,11 @@
 import type { MarkerId } from '../../../../../../shared/markerId.types';
-import { Marker } from '../../../../../types/legendMarkerBadge.type';
-import { ColorGroupedMarker } from '../../../utils/splitMarkerByColor.types';
+import { CombinedMarker } from '../../../../../types/legendMarkerBadge.type';
 /**
- * Builds the list of color-grouped markers to render for a single legend item.
- *
- * When the item has no selection grouping, wraps the raw marker as a single transparent-key variant.
- * Always returns markers sorted by color key for stable render order.
+ * Sorts markers by their highlight color key, with a fallback to alphabetical order.
+ * The transparent fallback marker (with TRANSPARENT_COLOR_KEY) is always sorted last.
+ * Returns an empty array if input is undefined or empty.
  */
-export declare function buildMarkersToRender(marker: Marker, groupedMarkers: ReadonlyArray<ColorGroupedMarker> | null | undefined): ColorGroupedMarker[];
+export declare function sortMarkersByHighlightColor(markers: ReadonlyArray<CombinedMarker> | undefined): ReadonlyArray<CombinedMarker>;
 /**
  * Finds the best new markerId to migrate the active popover to after the old marker disappears.
  * Prefers a marker with the same color key, falls back to the first available.

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

@@ -1,7 +1,7 @@
 import type { MarkerId } from '../../../../../../shared/markerId.types';
-import { ColorGroupedMarker } from '../../../utils/splitMarkerByColor.types';
+import { CombinedMarker } from '../../../../../types/legendMarkerBadge.type';
 interface UseStalePopoverMarkersProps {
-    readonly markersToRender: ReadonlyArray<ColorGroupedMarker> | null;
+    readonly markersToRender: ReadonlyArray<CombinedMarker> | null;
     readonly markerIds: ReadonlyArray<MarkerId>;
     readonly selectionMarkerIds: ReadonlyArray<MarkerId>;
 }
@@ -15,5 +15,5 @@ interface UseStalePopoverMarkersProps {
  *
  * @returns The markers that should be rendered — either the stale snapshot or the live `markersToRender`.
  */
-export declare function useStalePopoverMarkers({ markersToRender, markerIds, selectionMarkerIds }: UseStalePopoverMarkersProps): ReadonlyArray<ColorGroupedMarker> | null;
+export declare function useStalePopoverMarkers({ markersToRender, markerIds, selectionMarkerIds }: UseStalePopoverMarkersProps): ReadonlyArray<CombinedMarker> | null;
 export {};

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

@@ -1,6 +1,6 @@
 import type { MarkerId } from '../../../../../shared/markerId.types';
+import type { CombinedMarker } from '../../../../types/legendMarkerBadge.type';
 import { LegendDataId, LegendId } from '../../../../types/legendType';
-import { ColorGroupedMarker } from '../../utils/splitMarkerByColor.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.
@@ -11,7 +11,7 @@ import { ColorGroupedMarker } from '../../utils/splitMarkerByColor.types';
  * @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: ColorGroupedMarker): {
+export declare function useMarkerPopover(markerId: MarkerId, legendId: LegendId, itemId: LegendDataId, marker: CombinedMarker): {
     isPopoverActive: boolean;
     elements: readonly import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>[];
     handleOpen: () => Promise<void>;

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

@@ -1,14 +1,17 @@
+import { Brand } from '@equinor/echo-utils';
 import type { MarkerId } from '../../../../shared/markerId.types';
+import { CombinedMarker } from '../../../types/legendMarkerBadge.type';
 import { LegendId } from '../../../types/legendType';
+export type MarkerSelectionColorGroupKey = Brand<string, 'MarkerSelectionColorGroupKey'>;
 /**
  * Color key used when a marker is not in any selection group (fallback/transparent state).
  */
-export declare const TRANSPARENT_COLOR_KEY = "color_transparent";
+export declare const TRANSPARENT_COLOR_KEY: MarkerSelectionColorGroupKey;
 /**
  * Creates a unique marker ID from its component parts.
  * Format: positionId::legendId::groupKey
  */
-export declare function createMarkerId(positionId: string, legendId: LegendId, groupKey: string): MarkerId;
+export declare function createMarkerId(positionId: string, legendId: LegendId, groupKey: MarkerSelectionColorGroupKey): MarkerId;
 /**
  * Extracts the position ID from a marker ID.
  * Returns undefined if the marker ID is invalid.
@@ -23,4 +26,9 @@ export declare function isMarkerAtPosition(markerId: MarkerId | undefined, posit
  * Extracts the color/group key from a marker ID.
  * Returns undefined if the marker ID is invalid.
  */
-export declare function getColorKeyFromMarkerId(markerId: MarkerId): string | undefined;
+export declare function getColorKeyFromMarkerId(markerId: MarkerId): MarkerSelectionColorGroupKey | undefined;
+/**
+ * Derives a colorKey from a marker's highlightColor.
+ * Used for creating unique marker IDs.
+ */
+export declare function getColorKeyFromMarker(marker: CombinedMarker): MarkerSelectionColorGroupKey;

package/src/lib/feature/legend/components/popover/LegendPopoverContent.logic.d.ts

@@ -1,27 +1,20 @@
 import { LegendState } from '../../types/legendType';
-import { Marker } from './../../types/legendMarkerBadge.type';
-/**
- * Returns an array of visible PopoverChip for the given markers and legend state.
- *
- * Filters out markers and badges that are hidden (using isHiddenMarker/isHiddenBadge) or whose titles match any value in the
- * excludedLegendTitles array (case-insensitive). Badge chips are only included if selectedMarkerOption !== selectedBadgeOption.
- *
- * @param {object} params - The function parameters.
- * @param {ReadonlyArray<Marker>} params.markers - The list of marker objects to process.
- * @param {LegendState} params.legend - The legend state, used for filtering and selection logic.
- * @param {ReadonlyArray<string>} [params.excludedLegendTitles] - Optional array of titles to exclude from the chips (case-insensitive).
- * @returns {PopoverChip[]} The filtered and mapped array of PopoverChip for rendering.
- */
+import { RawMarkerData } from './../../types/legendMarkerBadge.type';
 interface GetPopoverChipsParams {
-    markers: ReadonlyArray<Marker>;
-    legendSelectedBadgeOption?: LegendState['selectedBadgeOption'];
-    legendSelectedMarkerOption?: LegendState['selectedMarkerOption'];
-    excludedLegendTitles?: ReadonlyArray<string>;
+    readonly markers: ReadonlyArray<RawMarkerData>;
+    readonly legendSelectedBadgeOption?: LegendState['selectedBadgeOption'];
+    readonly legendSelectedMarkerOption?: LegendState['selectedMarkerOption'];
+    readonly excludedLegendTitles?: ReadonlyArray<string>;
 }
 interface PopoverChip {
-    text: string;
-    backgroundColor: string;
-    textColor: string;
+    readonly text: string;
+    readonly backgroundColor: string;
+    readonly textColor: string;
 }
-export declare function getPopoverChips({ markers, legendSelectedBadgeOption, legendSelectedMarkerOption, excludedLegendTitles }: GetPopoverChipsParams): PopoverChip[];
+/**
+ * Generates an array of chips to be displayed in the legend popover based on the provided markers and legend options.
+ * It includes marker appearances and, if the selected marker and badge options are different, badge appearances as well.
+ * Chips with titles included in the excludedLegendTitles array will be filtered out (case-insensitive).
+ */
+export declare function getPopoverChips({ markers, legendSelectedBadgeOption, legendSelectedMarkerOption, excludedLegendTitles }: GetPopoverChipsParams): ReadonlyArray<PopoverChip>;
 export {};

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

@@ -1,12 +1,12 @@
-import { Marker } from '../../../types/legendMarkerBadge.type';
+import { RawMarkerData } from '../../../types/legendMarkerBadge.type';
 import { LegendDataId, LegendId } from '../../../types/legendType';
 /**
- * Returns all markers for a specific legend based on the provided item IDs.
+ * Returns all raw markers for a specific legend based on the provided item IDs.
  * The markers are only returned if the legend is enabled.
  */
-export declare const useMarkersFromEnabledLegend: (legendId: LegendId, itemIds: LegendDataId[]) => readonly Marker[];
+export declare const useRawMarkersFromEnabledLegend: (legendId: LegendId, itemIds: LegendDataId[]) => readonly RawMarkerData[];
 /**
- * Returns all enabled legend's marker itemIDs, including those from badges on markers.
+ * Returns all enabled legend's marker itemIDs from raw markers.
  * Only returns item IDs that actually have markers from enabled legends.
  */
 export declare const useAllMarkerItemIdsForEnabledLegends: () => LegendDataId[];

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

@@ -1,10 +1,11 @@
 import { Guid } from '@equinor/echo-utils';
 import { GlobalSelectionItemType } from '../../../globalSelection';
-import { ColorGroupedMarker, GroupKey } from '../pdfMarkers/utils/splitMarkerByColor.types';
+import type { LegendSelectionGroupKey } from '../../stores/legendUIStore/legendUIStore.types';
+import { CombinedMarker } from '../../types/legendMarkerBadge.type';
 /**
- * Key used for badges that don't belong to any selection group
+ * Key used for markers that don't belong to any selection group
  */
-export declare const NOT_IN_SELECTION_GROUP_KEY: GroupKey;
+export declare const NOT_IN_SELECTION_GROUP_KEY: LegendSelectionGroupKey;
 /**
  * Determines if groups should be split by item type.
  * Only true for the default local selection group (Local Selection).
@@ -25,13 +26,12 @@ export declare const shouldSplitGroupsByItemType: (groupId: Guid) => boolean;
  * @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, itemType?: GlobalSelectionItemType) => GroupKey;
+export declare const createSelectionGroupKey: (groupId: Guid, color: string, itemType?: GlobalSelectionItemType) => LegendSelectionGroupKey;
 /**
- * Checks if a marker belongs to the "Not in Selection" group.
- * With color-based grouping, this checks if all badges are outside any selection.
+ * Checks if a marker is outside any selection group.
+ * A marker is outside selection if its highlight color is 'transparent'.
  *
  * @param marker - The marker to check.
- *
- * @returns True if the marker is in the "Not in Selection" group, false otherwise.
+ * @returns True if the marker is not in any selection group, false otherwise.
  */
-export declare const isMarkerOutsideSelection: (marker: ColorGroupedMarker) => boolean;
+export declare const isMarkerOutsideSelection: (marker: CombinedMarker) => boolean;

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

@@ -0,0 +1,7 @@
+import type { LegendChipProps } from '@equinor/echo-components';
+import type { LegendId } from '../types/legendType';
+/**
+ * Returns legend chip props for all unique badges for the given legendId.
+ * Handles hide/show state and the showChipsInViewportOnly option.
+ */
+export declare function useLegendBadgeChips(legendId: LegendId): ReadonlyArray<LegendChipProps>;

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

@@ -1,7 +1,5 @@
-import { LegendUIState } from '../stores/legendUIStore/legendUIStore.types';
+import type { ToggleableLegend } 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).
  *
@@ -15,19 +13,11 @@ type HiddenItemsKey = keyof Pick<LegendUIState, 'hiddenMarkers' | 'hiddenBadges'
  *
  * @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)
+ * @returns The full hiddenItems 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');
+ * const hiddenMarkers = useLegendHiddenItemsSubscription(legendId, groupKeys);
  * ```
  */
-export declare const useLegendHiddenItemsSubscription: (legendId: LegendId, potentialKeys: string[], storeKey: HiddenItemsKey) => string[];
-export {};
+export declare const useLegendHiddenItemsSubscription: (legendId: LegendId, potentialKeys: ReadonlyArray<ToggleableLegend>) => ReadonlyArray<ToggleableLegend>;

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

@@ -0,0 +1,7 @@
+import type { LegendChipProps } from '@equinor/echo-components';
+import type { LegendId } from '../types/legendType';
+/**
+ * Returns legend chip props for all unique markers for the given legendId.
+ * Handles hide/show state and the showChipsInViewportOnly option.
+ */
+export declare function useLegendMarkerChips(legendId: LegendId): ReadonlyArray<LegendChipProps>;

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

@@ -0,0 +1,17 @@
+import type { CombinedMarker } from '../../types/legendMarkerBadge.type';
+import type { LegendDataId, LegendId } from '../../types/legendType';
+export interface UseLegendMarkersProps {
+    readonly legendId: LegendId;
+    readonly itemIds: LegendDataId[];
+}
+/**
+ * Resolves the given itemIds against the legend strategy into combined markers for the PDF,
+ * with one marker per unique highlight color. Hidden display keys and hidden
+ * selection groups are excluded. Returns undefined when the legend is disabled
+ * or no markers remain visible.
+ *
+ * @param props.legendId - The legend to get markers from
+ * @param props.itemIds - The item IDs to create markers from
+ * @returns Markers grouped by highlight color, or undefined if the legend is disabled or empty
+ */
+export declare function useLegendMarkers(props: UseLegendMarkersProps): ReadonlyArray<CombinedMarker> | undefined;

package/src/lib/feature/legend/hooks/useLegendMarkers/useLegendMarkers.logic.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Pure logic functions for legend marker processing.
+ *
+ * All functions in this module are pure (no hooks, no React imports).
+ * They handle: filtering, processing raw→processed markers, selection info lookup,
+ * grouping by highlight color, and badge combination.
+ */
+import { GlobalSelectionTypes } from '../../../globalSelection/globalSelectionStore/globalSelectionStore.types';
+import type { LegendDisplayKey, LegendSelectionGroupKey, ToggleableLegend } from '../../stores/legendUIStore/legendUIStore.types';
+import type { Badge, CombinedMarker, ProcessedMarker, RawMarkerData } from '../../types/legendMarkerBadge.type';
+import { type LegendBadgeColorMode, type LegendBadgeOptionConfig, type LegendDataId } from '../../types/legendType';
+/**
+ * Collects displayKeys from raw markers AND their badges for early hidden state subscription.
+ * This is cheap - just computes title+color hash without selection lookups.
+ * Includes badge displayKeys so hiding a badge type hides the entire marker.
+ */
+export declare const collectRawDisplayKeys: (rawMarkers: ReadonlyArray<RawMarkerData>) => ReadonlyArray<LegendDisplayKey>;
+/**
+ * Filters hidden appearances from raw markers BEFORE expensive processing.
+ * - Removes individual hidden markerAppearances and badgeAppearances from each marker.
+ * - Drops the marker entirely only when no visible markerAppearances remain.
+ *
+ * This ensures the surviving appearance determines the final color when one is toggled off.
+ */
+export declare const filterHiddenRawMarkers: (rawMarkers: ReadonlyArray<RawMarkerData>, hiddenItems: ReadonlyArray<ToggleableLegend>) => ReadonlyArray<RawMarkerData>;
+/**
+ * Processes raw badge data into full badges.
+ * When badgeColorMode is 'marker', resolves badge color from the marker's appearances:
+ * - If all marker appearances share a single color, uses that color.
+ * - If multiple distinct marker colors exist, uses the "multiple" color.
+ */
+export declare const processRawBadges: (rawMarker: RawMarkerData, markerColor: string, badgeColorMode?: LegendBadgeColorMode) => ReadonlyArray<Badge>;
+/**
+ * Collects toggleable groupKeys from processed markers for selection group visibility subscription.
+ */
+export declare const collectGroupKeys: (markers: ReadonlyArray<ProcessedMarker>) => ReadonlyArray<LegendSelectionGroupKey>;
+/**
+ * Filters out markers whose selection group is hidden.
+ */
+export declare const filterHiddenGroups: (markers: ReadonlyArray<ProcessedMarker>, hiddenGroups: ReadonlyArray<ToggleableLegend>) => ReadonlyArray<ProcessedMarker>;
+/**
+ * Groups markers by highlight color and combines each group into a single marker.
+ * Returns an array of final markers (without processing data), one per unique highlight color.
+ */
+export declare const groupAndFinalizeMarkersByHighlightColor: (markers: ReadonlyArray<ProcessedMarker>, selectedBadgeOption?: LegendBadgeOptionConfig, combinedMarkerIcon?: string) => ReadonlyArray<CombinedMarker>;
+/**
+ * Collects all item ID strings from raw markers for selection subscription.
+ */
+export declare const collectSelectionItemIdStrings: (rawMarkers: ReadonlyArray<RawMarkerData>) => ReadonlyArray<GlobalSelectionTypes.ItemIdString>;
+/**
+ * Processes raw marker data into full markers.
+ * Highlight colors and group keys are frozen at creation time (not read dynamically)
+ * so that stale markers preserve their old colors during transitions.
+ */
+export declare const processRawMarkers: (rawMarkers: ReadonlyArray<RawMarkerData>, selectedBadgeOption?: LegendBadgeOptionConfig) => ReadonlyArray<ProcessedMarker>;
+interface SelectionInfo {
+    readonly highlightColor: string;
+    readonly groupKey: LegendSelectionGroupKey;
+}
+/**
+ * Gets the selection info (highlight color and group key) for an item from global selection.
+ * Returns transparent color and NOT_IN_SELECTION_GROUP_KEY if not in any selection group.
+ */
+export declare const getSelectionInfoForItem: (itemId: LegendDataId) => SelectionInfo;
+export {};

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

@@ -0,0 +1,14 @@
+import type { RawMarkerData } from '../../types/legendMarkerBadge.type';
+import { type LegendDataId, type LegendId } from '../../types/legendType';
+/**
+ * Development helper to track hook calls
+ */
+export declare const trackMarkerCallsInDevelopment: () => void;
+/**
+ * Helper to get unique data from the legend visible data store
+ */
+export declare const useUniqueVisibleData: () => LegendDataId[];
+/**
+ * Gets raw marker data from the strategy.
+ */
+export declare const useRawMarkerData: (legendId: LegendId, data: LegendDataId[]) => ReadonlyArray<RawMarkerData>;

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

@@ -12,4 +12,4 @@ import { WorkOrderDto } from '@equinor/echo-search';
  * ```
  *
  */
-export declare function useWorkOrdersByTagsQuery(tagNos: string[]): import("@tanstack/react-query").UseQueryResult<readonly WorkOrderDto[], Error>;
+export declare function useWorkOrdersByTagsQuery(tagNos: string[]): import("@tanstack/react-query").UseQueryResult<NoInfer<readonly WorkOrderDto[]>, Error>;

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

@@ -1,6 +1,6 @@
+import './legendStrategies/iocAnnotationStrategy/iocAnnotationStrategy';
 import './legendStrategies/notificationStrategy/notificationStrategy';
 import './legendStrategies/workOrderStrategy/WorkOrderLegend';
-export { getBadgeChips, getMarkerChips } from './components/basicLegendRenderer.logic';
 export { LegendList } from './components/LegendList';
 export { LegendSelectorContainer } from './components/LegendSelectorContainer';
 export { PositionalItem } from './components/pdfMarkers/PositionalItem';
@@ -9,18 +9,20 @@ export { LegendPopoverContent } from './components/popover/LegendPopoverContent'
 export type { LegendPopoverContentProps } from './components/popover/LegendPopoverContent';
 export { trackEventNewLegendAccordionToggled, trackEventNewLegendSelectedBadgeOptionChanged, trackEventNewLegendSelectedMarkerOptionChanged } from './legendAnalytics';
 export { legendFacade } from './legendFacade';
+export { convertIocAnnotationStateToLegendStatus, getPrioritizedIocAnnotationLegendStatus } from './legendStrategies/iocAnnotationStrategy/hooks/useIocAnnotationMarkers.utils';
+export type { IocAnnotationState } from './legendStrategies/iocAnnotationStrategy/iocAnnotationStrategy.types';
 export { getLegendStrategy } from './legendStrategies/legendCollections';
 export { legendSnapShot } from './stores/legendDataStore/legendStore';
-export type { Badge, Marker } from './types/legendMarkerBadge.type';
+export type { Badge, CombinedMarker, LegendChipData, RawItemAppearance, RawMarkerData } from './types/legendMarkerBadge.type';
 export type { LegendStrategy } from './types/legendStrategy.type';
-export type { LegendBadgeOptionConfig, LegendId, LegendMarkerOptionConfig, LegendOptionConfig, LegendOptionDisplayOption } from './types/legendType';
-export { useLegendUniqueBadges } from './hooks/useLegendUniqueBadges';
-export { useLegendUniqueMarkers } from './hooks/useLegendUniqueMarkers';
+export type { LegendBadgeColorMode, LegendBadgeOptionConfig, LegendId, LegendMarkerOptionConfig, LegendOptionConfig, LegendOptionDisplayOption } from './types/legendType';
+export { useLegendMarkerChips } from './hooks/useLegendMarkerChips';
 export { useOpenWorkOrdersByTagNos } from './hooks/useWorkOrdersByTagNos';
 export { useWorkOrdersByTagsQuery } from './hooks/useWorkOrdersByTagsQuery';
 export { isCountMode, isIdMode, normalizeBadges } from './logic/normalizeBadges';
 export { getColorForLegendStatus } from './logic/getColorForLegendStatus';
-export { createArrayAccessor, createCountAccessor, createDateAccessor, createStringAccessor, getPropertyValues, toSingleTitle } from './logic/propertyAccessor.utils';
+export { createArrayAccessor, createDateAccessor, createStringAccessor, getPropertyValues } from './logic/propertyAccessor.utils';
 export type { PropertyAccessor } from './logic/propertyAccessor.utils';
 export { useLegendUIStore } from './stores/legendUIStore/legendUIStore';
 export { useLegendVisibleDataStore } from './stores/legendVisibleDataStore/legendVisibleDataStore';
+export { createDisplayKey } from './logic/displayKeys.logic';

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

@@ -2,7 +2,7 @@ import { getLegendStrategy, injectLegendStrategy } from './legendStrategies/lege
 import { isLegendDataIdEqualWithTag } from './logic/isLegendDataIdEqualWithTag';
 import { legendExistsInLegendStore, legendSnapShot, legendStoreSubscribe, useAllLegends, useLegendById } from './stores/legendDataStore/legendStore';
 import { legendExistsInLegendUIStore, useLegendUIById } from './stores/legendUIStore/legendUIStore';
-import type { LegendFeedbackVariant } from './stores/legendUIStore/legendUIStore.types';
+import type { LegendFeedbackVariant, ToggleableLegend } from './stores/legendUIStore/legendUIStore.types';
 import { visibleDataAsTagsSnapshot } from './stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore';
 import { LegendId } from './types/legendType';
 /**
@@ -31,25 +31,18 @@ export declare const legendFacade: Readonly<{
             } | undefined) => void;
             resetFeedback: (legendId: LegendId) => void;
         };
-        markers: {
+        hiddenItems: {
             setHidden: (params: {
                 legendId: LegendId;
-                marker: string;
+                item: ToggleableLegend;
                 isHidden: boolean;
             }) => void;
             setHiddenBatch: (updates: Array<{
                 legendId: LegendId;
-                marker: string;
+                item: ToggleableLegend;
                 isHidden: boolean;
             }>) => void;
         };
-        badges: {
-            setHidden: (params: {
-                legendId: LegendId;
-                badge: string;
-                isHidden: boolean;
-            }) => void;
-        };
     };
     exists: (legendId: LegendId) => boolean;
     visibleData: {
@@ -161,9 +154,10 @@ export declare const legendFacade: Readonly<{
         };
     };
     knownLegendIds: {
-        equipmentLegendId: LegendId;
-        tagLegendId: LegendId;
-        workOrderLegendId: LegendId;
-        notificationLegendId: LegendId;
+        equipmentLegendId: "Equipment Legend";
+        tagLegendId: "Tag Legend";
+        workOrderLegendId: "Work Order Legend";
+        notificationLegendId: "Notification Legend";
+        iocAnnotationLegendId: "IOC Annotation Legend";
     };
 }>;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/api/iocAnnotationLegend.api.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionalLocation, IocAnnotationDto, IocAnnotationFunctionalLocationLookup, IocAnnotationTagLookup } from '../iocAnnotationStrategy.types';
+export declare function fetchIocAnnotationFunctionalLocationLookups(tagLookups: ReadonlyArray<IocAnnotationTagLookup>): Promise<ReadonlyArray<IocAnnotationFunctionalLocationLookup>>;
+export declare function fetchIocAnnotationsByFunctionalLocations(functionalLocations: ReadonlyArray<FunctionalLocation>): Promise<ReadonlyArray<IocAnnotationDto>>;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/hooks/useIocAnnotationMarkers.d.ts

@@ -0,0 +1,3 @@
+import type { RawMarkerData } from '../../../types/legendMarkerBadge.type';
+import type { LegendDataId } from '../../../types/legendType';
+export declare function useIocAnnotationMarkers(itemIds: ReadonlyArray<LegendDataId>): ReadonlyArray<RawMarkerData>;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/hooks/useIocAnnotationMarkers.utils.d.ts

@@ -0,0 +1,21 @@
+import type { RawItemAppearance, RawMarkerData } from '../../../types/legendMarkerBadge.type';
+import type { IocAnnotationDto, IocAnnotationFunctionalLocationLookup, IocAnnotationMarkerData, IocAnnotationMarkerDataByTagKey, IocAnnotationState, IocAnnotationTagKey, IocAnnotationTagLookup } from '../iocAnnotationStrategy.types';
+/**
+ * Maps an IOC annotation state code (e.g. `ow`, `ip`, `er`) to its corresponding
+ * `LegendStatus`. Single source of truth for the conversion — re-exported via
+ * `@equinor/echo-framework` so legacy code paths in echopedia-web can consume
+ * the same mapping while the new legend rolls out behind a feature flag.
+ */
+export declare function convertIocAnnotationStateToLegendStatus(state: string): IocAnnotationState;
+export declare function getPrioritizedIocAnnotationLegendStatus(iocAnnotationStates: ReadonlyArray<string>): IocAnnotationState;
+export declare function createIocAnnotationTagKey(tagLookup: IocAnnotationTagLookup): IocAnnotationTagKey;
+export declare function getUniqueSortedIocAnnotationTagLookups(tagLookups: ReadonlyArray<IocAnnotationTagLookup>): ReadonlyArray<IocAnnotationTagLookup>;
+export declare function createIocAnnotationTagLookupQueryKey(sortedTagLookups: ReadonlyArray<IocAnnotationTagLookup>): ReadonlyArray<IocAnnotationTagKey>;
+export declare function createIocAnnotationTagLookupsFromQueryKey(tagLookupQueryKey: ReadonlyArray<IocAnnotationTagKey>): ReadonlyArray<IocAnnotationTagLookup>;
+export declare function buildIocAnnotationMarkerDataByTagKey({ iocAnnotations, functionalLocationLookups }: {
+    readonly iocAnnotations: ReadonlyArray<IocAnnotationDto>;
+    readonly functionalLocationLookups: ReadonlyArray<IocAnnotationFunctionalLocationLookup>;
+}): IocAnnotationMarkerDataByTagKey;
+export declare function createIocAnnotationMarkers(markerData: IocAnnotationMarkerData): ReadonlyArray<RawMarkerData>;
+export declare const getIOCMarkerAppearances: (iocAnnotation: IocAnnotationDto) => ReadonlyArray<RawItemAppearance>;
+export declare const getIOCBadgeAppearances: (iocAnnotation: IocAnnotationDto) => ReadonlyArray<RawItemAppearance>;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/iocAnnotationStrategy.d.ts

@@ -0,0 +1 @@
+export {};

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/iocAnnotationStrategy.types.d.ts

@@ -0,0 +1,25 @@
+import type { IocAnnotationData } from '@equinor/echo-search';
+import { LegendStatus } from '../../../legacyLegend/legend';
+import { type LegendId } from '../../types/legendType';
+export declare const iocAnnotationLegendId: LegendId;
+export type IocAnnotationDto = IocAnnotationData;
+export type InstCode = string;
+export type TagNo = string;
+export type FunctionalLocation = string;
+export type IocAnnotationTagKey = string;
+export type IocAnnotationMarkerOptions = 'status';
+export type IocAnnotationBadgeOptions = 'count';
+export interface IocAnnotationTagLookup {
+    readonly tagNo: TagNo;
+    readonly instCode: InstCode;
+}
+export interface IocAnnotationFunctionalLocationLookup extends IocAnnotationTagLookup {
+    readonly functionalLocation: FunctionalLocation;
+}
+export type IocAnnotationState = LegendStatus.OnWatch | LegendStatus.InProgress | LegendStatus.IocAnnotationError | LegendStatus.Note | LegendStatus.Archived | LegendStatus.Unknown;
+export interface IocAnnotationMarkerData {
+    readonly status: IocAnnotationState;
+    readonly tagNo: TagNo;
+    readonly iocAnnotations: ReadonlyArray<IocAnnotationDto>;
+}
+export type IocAnnotationMarkerDataByTagKey = ReadonlyMap<IocAnnotationTagKey, IocAnnotationMarkerData>;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/optionConfigs/iocAnnotationBadgeLegendOptionConfig.d.ts

@@ -0,0 +1,3 @@
+import { type LegendBadgeOptionConfig } from '../../../types/legendType';
+import type { IocAnnotationBadgeOptions } from '../iocAnnotationStrategy.types';
+export declare const IOC_ANNOTATION_LEGEND_BADGE_OPTIONS: ReadonlyArray<LegendBadgeOptionConfig<IocAnnotationBadgeOptions>>;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/optionConfigs/iocAnnotationMarkerLegendOptionConfig.d.ts

@@ -0,0 +1,3 @@
+import type { LegendMarkerOptionConfig } from '../../../types/legendType';
+import type { IocAnnotationMarkerOptions } from '../iocAnnotationStrategy.types';
+export declare const IOC_ANNOTATION_LEGEND_MARKER_OPTIONS: ReadonlyArray<LegendMarkerOptionConfig<IocAnnotationMarkerOptions>>;