@equinor/echo-framework 2.4.2 → 2.4.3

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "2.4.2",
+  "version": "2.4.3",
   "peerDependencies": {
-    "@equinor/echo-base": ">= 2.4.2 < 3.0.0",
-    "@equinor/echo-components": ">= 2.4.2 < 3.0.0",
+    "@equinor/echo-base": ">= 2.4.3 < 3.0.0",
+    "@equinor/echo-components": ">= 2.4.3 < 3.0.0",
     "@equinor/echo-core": ">= 2.4.2 < 3.0.0",
-    "@equinor/echo-search": ">= 2.4.2 < 3.0.0",
-    "@equinor/echo-utils": ">= 2.4.2 < 3.0.0",
+    "@equinor/echo-search": ">= 2.4.3 < 3.0.0",
+    "@equinor/echo-utils": ">= 2.4.3 < 3.0.0",
     "@equinor/eds-core-react": "0.49.0",
     "@equinor/eds-icons": "0.22.0",
     "react": ">= 17.0.2",
@@ -15,7 +15,7 @@
     "@microsoft/signalr": "9.0.6",
     "classnames": "2.5.1",
     "history": "5.3.0",
-    "lodash": "4.17.21",
+    "lodash": "4.17.23",
     "react-router-dom": "5.3.4",
     "zustand": ">= 4.4.7 < 5",
     "immer": "11.1.3",

package/src/lib/components/searchListItem/searchListItem.d.ts

@@ -36,6 +36,7 @@ type BaseProps = {
     isHighlightable?: boolean;
     itemActions?: React.ReactNode;
     footer?: React.ReactNode;
+    showChevron?: boolean;
 };
 type SearchListItemProps = BaseProps & WithVisualOrIconOptions;
 export {};
@@ -54,6 +55,7 @@ export {};
  * @property {boolean} [isHighlightable] - Whether the text is highlightable.
  * @property {React.ReactNode} [itemActions] - Custom actions to display in the list item.
  * @property {React.ReactNode} [footer] - Footer content for the list item.
+ * @property {boolean} [showChevron] - Whether to show the navigation chevron. Defaults to true.
  */
 /**
  * Visual component properties for the SearchListItem component.

package/src/lib/feature/globalSelection/globalSelectionStore/actions/addTagsToSelection.action.d.ts

@@ -1,8 +1,12 @@
-import { GlobalSelectionTypes } from '../globalSelectionStore.types';
-export declare const addTagsToSelectionAction: (set: (set: (state: import("../globalSelectionStore.types").GlobalSelectionStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../globalSelectionStore.types").GlobalSelectionStore>["getState"], args: {
+import type { ResultArray, TagSummaryDto } from '@equinor/echo-search';
+import type { StoreApi } from 'zustand';
+import { GlobalSelectionStore, GlobalSelectionTypes } from '../globalSelectionStore.types';
+export declare function addTagsToSelectionAction(set: SetFunction, get: StoreApi<GlobalSelectionStore>['getState'], args: {
     itemIds: GlobalSelectionTypes.TagId[];
     color?: string;
-}) => Promise<{
-    fetchResult: import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").TagSummaryDto>[];
+}): Promise<{
+    fetchResult: ResultArray<TagSummaryDto>[];
     actionResult: GlobalSelectionTypes.ActionResult;
 }>;
+type SetFunction = (set: (state: GlobalSelectionStore) => void, shouldReplace?: boolean | undefined, action?: string) => void;
+export {};

package/src/lib/feature/globalSelection/globalSelectionStore/actions/tagFetch.logic.d.ts

@@ -0,0 +1,10 @@
+import { type TagSummaryDto } from '@equinor/echo-search';
+import type { GlobalSelectionTypes } from '../globalSelectionStore.types';
+export type TagFetchResult = {
+    result: {
+        values: TagSummaryDto[];
+        isSuccess: boolean;
+    };
+    itemIdsUsed: GlobalSelectionTypes.TagId[];
+};
+export declare function fetchStidTags(stidTags: readonly GlobalSelectionTypes.TagId[]): Promise<TagFetchResult[]>;

package/src/lib/feature/globalSelection/globalSelectionStore/globalSelectionStore.d.ts

@@ -55,11 +55,11 @@ export declare const useGlobalSelectionStore: import("zustand").UseBoundStore<Om
             itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
         }) => void;
         setColorByItemIds: (args: {
-            itemIds: ReadonlyArray<Readonly<GlobalSelectionTypes.ItemId>>;
+            itemIds: readonly Readonly<GlobalSelectionTypes.ItemId>[];
             color: string;
         }) => void;
         setVisibilityByItemIds: (args: {
-            itemIds: ReadonlyArray<Readonly<GlobalSelectionTypes.ItemId>>;
+            itemIds: readonly Readonly<GlobalSelectionTypes.ItemId>[];
             isVisible: boolean;
         }) => void;
         setAllItemsVisibility: (args: {
@@ -80,9 +80,16 @@ export declare const useGlobalSelectionStore: import("zustand").UseBoundStore<Om
                 items: Map<GlobalSelectionTypes.ItemIdString, {
                     id: {
                         workOrderId: string;
+                    } | {
+                        tagNo: string;
+                        instCode: string;
+                        internalTagType: import("..").PdmsInternalTagType;
+                        plantNo: string;
+                        plantCode: string;
                     } | {
                         instCode: string;
                         tagNo: string;
+                        internalTagType?: never | undefined;
                     } | {
                         equipmentId: string;
                     } | {
@@ -120,9 +127,16 @@ export declare const useGlobalSelectionStore: import("zustand").UseBoundStore<Om
                 items: Map<GlobalSelectionTypes.ItemIdString, {
                     id: {
                         workOrderId: string;
+                    } | {
+                        tagNo: string;
+                        instCode: string;
+                        internalTagType: import("..").PdmsInternalTagType;
+                        plantNo: string;
+                        plantCode: string;
                     } | {
                         instCode: string;
                         tagNo: string;
+                        internalTagType?: never | undefined;
                     } | {
                         equipmentId: string;
                     } | {
@@ -165,9 +179,16 @@ export declare const useGlobalSelectionStore: import("zustand").UseBoundStore<Om
                 items: Map<GlobalSelectionTypes.ItemIdString, {
                     id: {
                         workOrderId: string;
+                    } | {
+                        tagNo: string;
+                        instCode: string;
+                        internalTagType: import("..").PdmsInternalTagType;
+                        plantNo: string;
+                        plantCode: string;
                     } | {
                         instCode: string;
                         tagNo: string;
+                        internalTagType?: never | undefined;
                     } | {
                         equipmentId: string;
                     } | {
@@ -203,9 +224,16 @@ export declare const useGlobalSelectionStore: import("zustand").UseBoundStore<Om
                 items: Map<GlobalSelectionTypes.ItemIdString, {
                     id: {
                         workOrderId: string;
+                    } | {
+                        tagNo: string;
+                        instCode: string;
+                        internalTagType: import("..").PdmsInternalTagType;
+                        plantNo: string;
+                        plantCode: string;
                     } | {
                         instCode: string;
                         tagNo: string;
+                        internalTagType?: never | undefined;
                     } | {
                         equipmentId: string;
                     } | {

package/src/lib/feature/globalSelection/globalSelectionStore/globalSelectionStore.types.d.ts

@@ -1,5 +1,6 @@
 import type { EquipmentData, MeasuringPointData, ResultArray, TagSummaryDto, WorkOrderData } from '@equinor/echo-search';
 import { Brand } from '@equinor/echo-utils';
+import type { PdmsTagId } from '../pdmsTag/pdmsTag.types';
 export declare enum GlobalSelectionItemType {
     WorkOrder = "WorkOrder",
     Tag = "Tag",
@@ -106,36 +107,46 @@ export type GlobalSelectionAddItemResult<DataType> = {
 };
 export type PersistedGlobalSelectionMetaData = Pick<GlobalSelectionMetaData, 'color' | 'isHiddenByUser'>;
 export declare namespace GlobalSelectionTypes {
-    type WorkOrderId = Pick<GlobalSelectionWorkOrderDto, 'workOrderId'>;
-    type EquipmentId = Pick<GlobalSelectionEquipmentDto, 'equipmentId'>;
-    type TagId = Pick<GlobalSelectionTagDto, 'tagNo' | 'instCode'>;
-    type MeasuringPointId = Pick<GlobalSelectionMeasuringPointDto, 'measuringPointId'>;
-    type ItemId = WorkOrderId | EquipmentId | TagId | MeasuringPointId;
-    type ItemIdString = Brand<string, 'ItemIdString'>;
-    type TagDto = GlobalSelectionTagDto;
-    type WorkOrderDto = GlobalSelectionWorkOrderDto;
-    type EquipmentDto = GlobalSelectionEquipmentDto;
-    type MeasuringPointDto = GlobalSelectionMeasuringPointDto;
-    type EquipmentItem = GlobalSelectionGenericItem<GlobalSelectionItemType.Equipment>;
-    type WorkOrderItem = GlobalSelectionGenericItem<GlobalSelectionItemType.WorkOrder>;
-    type TagItem = GlobalSelectionGenericItem<GlobalSelectionItemType.Tag>;
-    type MeasuringPointItem = GlobalSelectionGenericItem<GlobalSelectionItemType.MeasuringPoint>;
-    type List<T extends GlobalSelectionItemType> = GlobalSelectionList<T>;
-    type SelectionItem = EquipmentItem | WorkOrderItem | TagItem | MeasuringPointItem;
-    type SelectionItemList = EquipmentItem[] | WorkOrderItem[] | TagItem[] | MeasuringPointItem[];
-    type GenericItem<T extends GlobalSelectionItemType> = GlobalSelectionGenericItem<T>;
-    type Store = GlobalSelectionStore;
-    type ItemErrorStatusUpdate = ItemErrorStatusUpdates;
-    type WorkOrderList = WorkOrderGlobalSelectionList;
-    type TagList = TagGlobalSelectionList;
-    type EquipmentList = EquipmentGlobalSelectionList;
-    type MeasuringPointList = MeasuringPointGlobalSelectionList;
-    type ListUnion = GlobalSelectionListUnion;
-    type ItemTypeToDataMap = GlobalSelectionItemTypeToDataMap;
-    type AddTagResult = GlobalSelectionAddItemResult<ResultArray<TagSummaryDto>[]>;
-    type AddEquipmentsResult = GlobalSelectionAddItemResult<ResultArray<EquipmentData>[]>;
-    type AddMeasuringPointResult = GlobalSelectionAddItemResult<ResultArray<MeasuringPointData>[]>;
-    type ActionResult = GlobalSelectionActionResult;
-    type ItemSystemStatus = SelectionItemSystemStatus;
+    export type WorkOrderId = Pick<GlobalSelectionWorkOrderDto, 'workOrderId'>;
+    export type EquipmentId = Pick<GlobalSelectionEquipmentDto, 'equipmentId'>;
+    /**
+     * TagId is the identifier for tags in the global selection.
+     * - For STID tags: { tagNo, instCode }
+     * - For internal tags (PDMS): { tagNo, instCode, internalTagType, plantNo, plantCode }
+     */
+    type BaseTagId = Pick<GlobalSelectionTagDto, 'tagNo' | 'instCode'>;
+    type StidTagId = BaseTagId & {
+        readonly internalTagType?: never;
+    };
+    export type TagId = StidTagId | PdmsTagId;
+    export type MeasuringPointId = Pick<GlobalSelectionMeasuringPointDto, 'measuringPointId'>;
+    export type ItemId = WorkOrderId | EquipmentId | TagId | MeasuringPointId;
+    export type ItemIdString = Brand<string, 'ItemIdString'>;
+    export type TagDto = GlobalSelectionTagDto;
+    export type WorkOrderDto = GlobalSelectionWorkOrderDto;
+    export type EquipmentDto = GlobalSelectionEquipmentDto;
+    export type MeasuringPointDto = GlobalSelectionMeasuringPointDto;
+    export type EquipmentItem = GlobalSelectionGenericItem<GlobalSelectionItemType.Equipment>;
+    export type WorkOrderItem = GlobalSelectionGenericItem<GlobalSelectionItemType.WorkOrder>;
+    export type TagItem = GlobalSelectionGenericItem<GlobalSelectionItemType.Tag>;
+    export type MeasuringPointItem = GlobalSelectionGenericItem<GlobalSelectionItemType.MeasuringPoint>;
+    export type List<T extends GlobalSelectionItemType> = GlobalSelectionList<T>;
+    export type SelectionItem = EquipmentItem | WorkOrderItem | TagItem | MeasuringPointItem;
+    export type SelectionItemList = EquipmentItem[] | WorkOrderItem[] | TagItem[] | MeasuringPointItem[];
+    export type GenericItem<T extends GlobalSelectionItemType> = GlobalSelectionGenericItem<T>;
+    export type Store = GlobalSelectionStore;
+    export type ItemErrorStatusUpdate = ItemErrorStatusUpdates;
+    export type WorkOrderList = WorkOrderGlobalSelectionList;
+    export type TagList = TagGlobalSelectionList;
+    export type EquipmentList = EquipmentGlobalSelectionList;
+    export type MeasuringPointList = MeasuringPointGlobalSelectionList;
+    export type ListUnion = GlobalSelectionListUnion;
+    export type ItemTypeToDataMap = GlobalSelectionItemTypeToDataMap;
+    export type AddTagResult = GlobalSelectionAddItemResult<ResultArray<TagSummaryDto>[]>;
+    export type AddEquipmentsResult = GlobalSelectionAddItemResult<ResultArray<EquipmentData>[]>;
+    export type AddMeasuringPointResult = GlobalSelectionAddItemResult<ResultArray<MeasuringPointData>[]>;
+    export type ActionResult = GlobalSelectionActionResult;
+    export type ItemSystemStatus = SelectionItemSystemStatus;
+    export {};
 }
 export {};

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

@@ -1,4 +1,5 @@
 export * from './globalSelectionStore/globalSelectionStore.types';
+export * from './pdmsTag/pdmsTag.types';
 export * from './selectionMenu/selectionTreeStore/selectionTree.api.types';
 export * from './selectionMenu/selectionTreeStore/selectionTree.store.types';
 export { useAreAllItemsVisible } from './hooks/useAreAllItemsVisible';
@@ -26,3 +27,4 @@ export { invalidateHistorySelectionQuery } from './selectionMenu/invalidateHisto
 export { saveEquipmentAsNewSelectionToApi } from './selectionMenu/selectionTreeStore/api/selectionTree.equipment';
 export { SelectionColorConflictDialog } from './selectionMenu/selectionTreeStore/colorConflictHandling/SelectionColorConflictDialog';
 export { simulatedSelectionTreeApiError } from './selectionMenu/selectionTreeStore/persist/devOnlySimulateOffline';
+export { createPdmsTagSummaryDto, isPdmsTagId, isPdmsTagSummaryDto } from './pdmsTag/pdmsTag.utils';

package/src/lib/feature/globalSelection/pdmsTag/pdmsTag.types.d.ts

@@ -0,0 +1,13 @@
+import type { TagSummaryDto } from '@equinor/echo-search';
+export declare const PDMS_INTERNAL_TAG_TYPES: readonly ["PdmsTag", "PdmsPart"];
+export type PdmsInternalTagType = (typeof PDMS_INTERNAL_TAG_TYPES)[number];
+export declare const isPdmsInternalTagType: (value: string) => value is PdmsInternalTagType;
+export interface PdmsTagId {
+    readonly tagNo: string;
+    readonly instCode: string;
+    readonly internalTagType: PdmsInternalTagType;
+    readonly plantNo: string;
+    readonly plantCode: string;
+}
+export interface PdmsTagSummaryDto extends TagSummaryDto, PdmsTagId {
+}

package/src/lib/feature/globalSelection/pdmsTag/pdmsTag.utils.d.ts

@@ -0,0 +1,6 @@
+import { type TagSummaryDto } from '@equinor/echo-search';
+import type { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
+import type { PdmsTagId, PdmsTagSummaryDto } from './pdmsTag.types';
+export declare function isPdmsTagId(itemId: GlobalSelectionTypes.ItemId): itemId is PdmsTagId;
+export declare function isPdmsTagSummaryDto(dto: TagSummaryDto): dto is PdmsTagSummaryDto;
+export declare function createPdmsTagSummaryDto(pdmsTagId: PdmsTagId): PdmsTagSummaryDto;

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

@@ -88,9 +88,16 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
                 items: Map<GlobalSelectionTypes.ItemIdString, {
                     id: {
                         workOrderId: string;
+                    } | {
+                        tagNo: string;
+                        instCode: string;
+                        internalTagType: import("../..").PdmsInternalTagType;
+                        plantNo: string;
+                        plantCode: string;
                     } | {
                         instCode: string;
                         tagNo: string;
+                        internalTagType?: never | undefined;
                     } | {
                         equipmentId: string;
                     } | {

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

@@ -86,6 +86,7 @@ export declare namespace SelectionTreeTypes {
     type Category = SelectionCategory;
     type Group = SelectionGroup;
     type ActionResult = SelectionTreeActionResult;
+    type Item = SelectionTreeItem<GlobalSelectionItemType>;
 }
 export type AddTagsReturnType = Promise<AddItemsResponse<GlobalSelectionItemType.Tag>>;
 export type AddWorkOrdersReturnType = Promise<AddItemsResponse<GlobalSelectionItemType.WorkOrder>>;

package/src/lib/feature/legend/components/LegendFeedbackMessage.d.ts

@@ -0,0 +1,12 @@
+export type LegendFeedbackVariant = 'error' | 'info' | 'warning';
+interface LegendFeedbackMessageProps {
+    className?: string;
+    variant?: LegendFeedbackVariant;
+    message: string;
+}
+/**
+ * Component to display a feedback message in the legend accordion.
+ * Will default to 'info' variant if none is provided.
+ */
+export declare const LegendFeedbackMessage: (props: LegendFeedbackMessageProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/lib/feature/legend/components/pdfMarkers/PositionalItem.d.ts

@@ -10,5 +10,5 @@ interface PositionalItemProps {
 /**
  * An item that can be positioned anywhere in the absolute container.
  */
-export declare const PositionalItem: React.FC<PositionalItemProps>;
+export declare const PositionalItem: React.MemoExoticComponent<(props: PositionalItemProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/src/lib/feature/legend/components/pdfMarkers/PositionalLegendMarkers.d.ts

@@ -12,13 +12,5 @@ interface PositionalLegendMarkersProps {
     currentPageScale: number;
     pdfZoom: number;
 }
-/**
- * Component that renders positional legend markers on a PDF or on other view.
- *
- * @param {ReadonlyArray<LegendPositionItem>} items - Array of position items.
- * @param {number} pdfRotation - The rotation angle of the PDF.
- * @param {number} currentPageScale - The current scale of the PDF page.
- * @param {number} pdfZoom - The zoom level of the PDF.
- */
-export declare const PositionalLegendMarkers: React.FC<PositionalLegendMarkersProps>;
+export declare const PositionalLegendMarkers: React.NamedExoticComponent<PositionalLegendMarkersProps>;
 export {};

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

@@ -1,12 +1,12 @@
 import { ItemMarkerSize } from '@equinor/echo-components';
 import React from 'react';
-import { GroupedMarker } from '../utils/splitMarkerByBadgeSelectionGroup.types';
+import { ColorGroupedMarker } from '../utils/splitMarkerByColor.types';
 interface LegendColoredMarkerIconProps {
     hasPointer: boolean;
     isActive: boolean;
     onClick: () => void;
     hiddenBadges: string[];
-    marker: GroupedMarker;
+    marker: ColorGroupedMarker;
 }
 /**
  * Renders a colored marker icon with optional pointer and badges.

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

@@ -10,8 +10,5 @@ interface LegendPositionItem {
 interface LegendMarkersRendererProps {
     positionItems: ReadonlyArray<LegendPositionItem>;
 }
-/**
- * Renders all the position items, with markers for each legends. And has 1 popover which is the last active item clicked.
- */
-export declare const LegendMarkersRenderer: React.FC<LegendMarkersRendererProps>;
+export declare const LegendMarkersRenderer: React.NamedExoticComponent<LegendMarkersRendererProps>;
 export {};

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

@@ -1,11 +1,11 @@
 import { LegendDataId, LegendId } from '../../../types/legendType';
 import { MarkerId } from '../utils/markerId.utils';
-import { GroupedMarker } from '../utils/splitMarkerByBadgeSelectionGroup.types';
+import { ColorGroupedMarker } from '../utils/splitMarkerByColor.types';
 interface MarkerWithPopoverProps {
     legendId: LegendId;
     hasPointer: boolean;
     hiddenBadges: string[];
-    marker: GroupedMarker;
+    marker: ColorGroupedMarker;
     itemId: LegendDataId;
     markerId: MarkerId;
 }

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

@@ -1,9 +1,8 @@
-import { LegendDataId, LegendId } from '../../../types/legendType';
-interface MultipleMarkersBySingleLegendComponentProps {
+import { LegendDataId, LegendId } from '../../../../../types/legendType';
+export interface MultipleMarkersBySingleLegendComponentProps {
     legendId: LegendId;
     itemId: LegendDataId;
     hasPointer: boolean;
     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/components/MultipleMarkersBySingleLegend/MultipleMarkersBySingleLegendContainer.d.ts

@@ -0,0 +1,4 @@
+import { MultipleMarkersBySingleLegendComponentProps } from './MultipleMarkersBySingleLegend';
+type MultipleMarkersBySingleLegendContainerProps = MultipleMarkersBySingleLegendComponentProps;
+export declare const MultipleMarkersBySingleLegendContainer: import("react").MemoExoticComponent<(props: MultipleMarkersBySingleLegendContainerProps) => import("react/jsx-runtime").JSX.Element | null>;
+export {};

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

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

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

@@ -0,0 +1,34 @@
+import { ItemToSelectionGroupsMap } from '../../../stores/itemToSelectionGroupsMapStore/itemToSelectionGroupsMapStore.types';
+import { Marker } from '../../../types/legendMarkerBadge.type';
+import { ColorGroupedMarker } from './splitMarkerByColor.types';
+/**
+ * Splits a marker into variants based on selection color only (not selection group).
+ *
+ * The 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.
+
+ * Example: Marker with 3 equipment badges:
+ * - Badge A (group1, red selection color)
+ * - Badge B (group2, red selection color)
+ * - Badge C (group3, blue selection color)
+ *
+ * Returns 2 marker variants:
+ * - Red variant: [BadgeA(from group1), BadgeB(from group2)]
+ * - Blue variant: [BadgeC(from group3)]
+ *
+ * When group2 is hidden, red variant filters to [BadgeA] only.
+ *
+ * @param itemToGroupsMap - Pre-built map of itemIdString -> SelectionGroup[] for lookup
+ * @param marker - The marker containing badges to be split by selection color
+ * @returns Array of selection-color-grouped marker variants
+ */
+export declare const splitMarkerByColor: (itemToGroupsMap: ItemToSelectionGroupsMap, marker?: Marker) => ColorGroupedMarker[];
+/**
+ * Filters a color-grouped marker's badges by hidden groups.
+ * Returns undefined if all badges are hidden (marker should not render).
+ *
+ * @param marker - The color-grouped marker to filter
+ * @param hiddenGroupKeys - Array of hidden group key strings
+ * @returns Marker with filtered badges, or undefined if all hidden
+ */
+export declare const filterBadgesByHiddenGroups: (marker: ColorGroupedMarker, hiddenGroupKeys: string[]) => ColorGroupedMarker | undefined;

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

@@ -0,0 +1,37 @@
+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;
+}
+/**
+ * Badge with its associated group key for visibility filtering.
+ */
+export interface BadgeWithGroup {
+    badge: Badge;
+    /** The group key this badge belongs to, for visibility filtering */
+    groupKey: GroupKey;
+}
+/**
+ * A group of badges that share the same selection color.
+ */
+export interface SelectionColorGroup {
+    selectionColor: string;
+    badgesWithGroups: BadgeWithGroup[];
+}
+/**
+ * A color-grouped marker variant.
+ * Contains badges of the same color, each tracking its own group for filtering.
+ */
+export interface ColorGroupedMarker extends Marker {
+    /** Color-based key for this marker variant.
+     * We could use Marker.getHighlightColor() here, but using a key allows for future flexibility only related to PDF rendering.*/
+    getColorKey: () => string;
+    /** Badges with their group info for filtering */
+    badgesWithGroups: BadgeWithGroup[];
+}

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

@@ -0,0 +1,12 @@
+import { Marker } from '../../../types/legendMarkerBadge.type';
+import { LegendDataId, LegendId } from '../../../types/legendType';
+/**
+ * Returns all 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[];
+/**
+ * Returns all enabled legend's marker itemIDs, including those from badges on markers.
+ * Only returns item IDs that actually have markers from enabled legends.
+ */
+export declare const useAllMarkerItemIdsForEnabledLegends: () => LegendDataId[];

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

@@ -1,5 +1,8 @@
 import { SelectionGroupDisplay } from './useSelectionGroupsForLegendRenderer.utils';
 /**
- * Hook to get selection groups formatted for the legend renderer.
+ * Builds selection display groups directly from selection groups and visible item IDs
+ * on the current PDF, NOT from filtered grouped markers. This ensures legend chips
+ * are always shown even when all markers in a group are hidden, allowing users
+ * to unhide them.
  */
 export declare const useSelectionGroupsForLegendRenderer: () => SelectionGroupDisplay[];

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

@@ -1,6 +1,6 @@
 import { Guid } from '@equinor/echo-utils';
 import { GlobalSelectionItemType, SelectionGroup } from '../../../../globalSelection';
-import { GroupedMarker } from '../../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
+import { LegendDataId } from '../../../types/legendType';
 export interface SelectionGroupDisplay {
     readonly label: string;
     readonly highlightColors: string[];
@@ -10,8 +10,12 @@ export interface SelectionGroupDisplay {
 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.
+ * Builds a map of selection groups directly from selection groups and visible item IDs.
+ * This function does NOT depend on filtered grouped markers, so it shows all groups
+ * even when their markers are hidden.
+ *
+ * @param selectionGroups - All selection groups
+ * @param visibleItemIds - Item IDs visible on the current PDF (from legend visible data)
  */
-export declare function buildSelectionGroupMap(allGroupedMarkers: GroupedMarker[] | undefined, selectionGroups: SelectionGroup[]): GroupMap;
+export declare function buildSelectionGroupMapFromVisibleItems(selectionGroups: SelectionGroup[], visibleItemIds: LegendDataId[]): GroupMap;
 export {};

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

@@ -1,6 +1,6 @@
 import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionItemType, GlobalSelectionTypes, SelectionGroup } from '../../../globalSelection';
-import { GroupedMarker, GroupKey } from '../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
+import { GlobalSelectionItemType } from '../../../globalSelection';
+import { ColorGroupedMarker, GroupKey } from '../pdfMarkers/utils/splitMarkerByColor.types';
 /**
  * TODO: Remove this flag when Selection Legend is stable and ready for production
  * Flag to enable/disable Selection Legend feature
@@ -10,10 +10,6 @@ export declare const isSelectionLegendEnabled: () => boolean;
  * Key used for badges that don't belong to any selection group
  */
 export declare const NOT_IN_SELECTION_GROUP_KEY: GroupKey;
-/**
- * Extracts all item IDs from selection group categories
- */
-export declare const extractSelectionGroupItemIds: (selectionGroup: SelectionGroup) => GlobalSelectionTypes.ItemId[];
 /**
  * Determines if groups should be split by item type.
  * Only true for the default local selection group (Local Selection).
@@ -37,9 +33,10 @@ export declare const shouldSplitGroupsByItemType: (groupId: Guid) => boolean;
 export declare const createSelectionGroupKey: (groupId: Guid, color: string, itemType?: GlobalSelectionItemType) => GroupKey;
 /**
  * Checks if a marker belongs to the "Not in Selection" group.
+ * With color-based grouping, this checks if all badges are outside any selection.
  *
  * @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;
+export declare const isMarkerOutsideSelection: (marker: ColorGroupedMarker) => boolean;

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

@@ -1,16 +1,23 @@
-import { GroupedMarker } from '../components/pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
+import { ColorGroupedMarker } from '../components/pdfMarkers/utils/splitMarkerByColor.types';
 import { Marker } from '../types/legendMarkerBadge.type';
 import { LegendId } from '../types/legendType';
 /**
- * Will process markers and group them based on groups in Selection.
- * This also adds additional logic for counting badges where this is needed.
- * @param legendId
- * @param markers
- * @param hiddenMarkers If included hidden markers will be filtered out
- * @returns
+ * Processes a marker and groups them by color, filtering badges by hidden groups.
+ *
+ * This hook splits marker into variants based on badge color (not selection group),
+ * then filters individual badges based on whether their group is hidden.
+ *
+ * Rules:
+ * - marker are grouped by **color only**
+ * - Badges track their selection group for visibility filtering
+ * - When a group is hidden, badges from that group are filtered out
+ * - Marker variant hides only when ALL its badges are hidden
+ *
+ * @param args.legendId - The legend ID for UI state subscriptions
+ * @param args.marker - The marker to process (typically a single marker)
+ * @returns Array of color-grouped marker variants, or undefined if selection legend is disabled
  */
 export declare const useGroupedMarkers: (args: {
     legendId: LegendId;
-    markers: Marker[];
-    hiddenMarkers?: string[];
-}) => GroupedMarker[] | undefined;
+    marker?: Marker;
+}) => ColorGroupedMarker[] | undefined;

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[];