@equinor/echo-framework 5.0.0-beta-r19 → 5.0.0-beta-r19-1

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

@@ -1,5 +1,4 @@
 import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
 import { SelectionGroup, SelectionTreeStore } from './selectionTree.store.types';
 /**
  * Zustand store hook for managing the selection tree state in the global selection feature.
@@ -34,13 +33,14 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
             guid: Guid | undefined;
         }) => void;
         addItems: (args: {
-            itemIds: GlobalSelectionTypes.ItemId[];
+            itemIds: ReadonlyArray<import("../..").GlobalSelectionTypes.ItemId>;
             groupId?: Guid;
+            useDefaultSelectionTypeColors?: boolean;
         }) => Promise<void>;
-        addTags: (args: import("./actions/selectionTree.action.types").AddItemArgs<GlobalSelectionTypes.TagId>) => import("./selectionTree.store.types").AddTagsReturnType;
-        addWorkOrders: (args: import("./actions/selectionTree.action.types").AddItemArgs<GlobalSelectionTypes.WorkOrderId>) => import("./selectionTree.store.types").AddWorkOrdersReturnType;
-        addEquipments: (args: import("./actions/selectionTree.action.types").AddItemArgs<GlobalSelectionTypes.EquipmentId>) => import("./selectionTree.store.types").AddEquipmentsReturnType;
-        addMeasuringPoints: (args: import("./actions/selectionTree.action.types").AddItemArgs<GlobalSelectionTypes.MeasuringPointId>) => import("./selectionTree.store.types").AddMeasuringPointsReturnType;
+        addTags: (args: import("./actions/selectionTree.action.types").AddItemArgs<import("../..").GlobalSelectionTypes.TagId>) => import("./selectionTree.store.types").AddTagsReturnType;
+        addWorkOrders: (args: import("./actions/selectionTree.action.types").AddItemArgs<import("../..").GlobalSelectionTypes.WorkOrderId>) => import("./selectionTree.store.types").AddWorkOrdersReturnType;
+        addEquipments: (args: import("./actions/selectionTree.action.types").AddItemArgs<import("../..").GlobalSelectionTypes.EquipmentId>) => import("./selectionTree.store.types").AddEquipmentsReturnType;
+        addMeasuringPoints: (args: import("./actions/selectionTree.action.types").AddItemArgs<import("../..").GlobalSelectionTypes.MeasuringPointId>) => import("./selectionTree.store.types").AddMeasuringPointsReturnType;
         createGroup: (args: {
             groupId?: string;
             label: string;
@@ -59,15 +59,15 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
         removeItemsById: (args: {
             groupId?: Guid;
             categoryId: import("./selectionTree.store.types").GlobalSelectionCategoryId;
-            itemIds: GlobalSelectionTypes.ItemId[];
+            itemIds: ReadonlyArray<import("../..").GlobalSelectionTypes.ItemId>;
         }) => void;
         removeAllItemsById: (args: {
-            itemIds: GlobalSelectionTypes.ItemId[];
+            itemIds: ReadonlyArray<import("../..").GlobalSelectionTypes.ItemId>;
         }) => void;
         moveItems: (args: {
             sourceGroupId: Guid;
             sourceCategoryId?: import("./selectionTree.store.types").GlobalSelectionCategoryId;
-            sourceItemId?: GlobalSelectionTypes.ItemId;
+            sourceItemId?: import("../..").GlobalSelectionTypes.ItemId;
             targetGroupId: Guid;
         }) => void;
         setVisibilityById: (args: {
@@ -85,7 +85,7 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
             categories: {
                 id: import("./selectionTree.store.types").GlobalSelectionCategoryId;
                 label: string;
-                items: Map<GlobalSelectionTypes.ItemIdString, {
+                items: Map<import("../..").GlobalSelectionTypes.ItemIdString, {
                     id: {
                         workOrderId: string;
                     } | {
@@ -102,7 +102,7 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
                     } | {
                         measuringPointId: string;
                     };
-                    type: import("../../globalSelectionStore/globalSelectionStore.types").GlobalSelectionItemType;
+                    type: import("../..").GlobalSelectionItemType;
                 }>;
             }[];
             groupId: Guid;

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

@@ -35,8 +35,9 @@ export interface SelectionTreeStore extends SelectionTreeData {
         guid: Guid | undefined;
     }) => void;
     addItems: (args: {
-        itemIds: GlobalSelectionTypes.ItemId[];
+        itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
         groupId?: Guid;
+        useDefaultSelectionTypeColors?: boolean;
     }) => Promise<void>;
     addTags: (args: AddItemArgs<GlobalSelectionTypes.TagId>) => AddTagsReturnType;
     addWorkOrders: (args: AddItemArgs<GlobalSelectionTypes.WorkOrderId>) => AddWorkOrdersReturnType;
@@ -60,10 +61,10 @@ export interface SelectionTreeStore extends SelectionTreeData {
     removeItemsById: (args: {
         groupId?: Guid;
         categoryId: GlobalSelectionCategoryId;
-        itemIds: GlobalSelectionTypes.ItemId[];
+        itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
     }) => void;
     removeAllItemsById: (args: {
-        itemIds: GlobalSelectionTypes.ItemId[];
+        itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
     }) => void;
     moveItems: (args: {
         sourceGroupId: Guid;

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

@@ -50,7 +50,7 @@ export declare function findSelectionCategoryById(args: {
  */
 export declare function itemsNotFoundInSelectionTree(args: {
     groups: SelectionTreeTypes.Group[];
-    itemIds: GlobalSelectionTypes.ItemId[];
+    itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
 }): GlobalSelectionTypes.ItemId[];
 /**
  * Get an array of group IDs where any of the item IDs are found.
@@ -64,7 +64,7 @@ export declare function itemsNotFoundInSelectionTree(args: {
  * @returns {Object[]} An array of group IDs, with labels and sublabels, where any of the item IDs are found.
  */
 export declare function getGroupIdsByItemIds(args: {
-    itemIds: GlobalSelectionTypes.ItemId[];
+    itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
     groups: SelectionTreeTypes.Group[];
 }): {
     id: Guid;
@@ -103,8 +103,8 @@ export declare function isSelectionEmpty(groups: SelectionTreeTypes.Group[]): bo
  * @param {GlobalSelectionTypes.ItemId[]} itemIds - The list of item IDs to be checked and potentially removed.
  * @returns {void}
  */
-export declare function removeStaleItemsFromGlobalSelection(groups: SelectionTreeTypes.Group[], itemIds: GlobalSelectionTypes.ItemId[]): void;
-export declare function getItemsByIdsFromGlobalSelectionStore(itemIds: GlobalSelectionTypes.ItemId[]): GlobalSelectionTypes.SelectionItem[];
+export declare function removeStaleItemsFromGlobalSelection(groups: SelectionTreeTypes.Group[], itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>): void;
+export declare function getItemsByIdsFromGlobalSelectionStore(itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>): GlobalSelectionTypes.SelectionItem[];
 /**
  * Returns an array of selection colors sorted by their frequency for the specified item IDs within a group.
  *
@@ -122,7 +122,7 @@ export declare function getItemsByIdsFromGlobalSelectionStore(itemIds: GlobalSel
  */
 export declare function getSelectionColorFrequencyByIds(args: {
     groupId: string;
-    itemIds: GlobalSelectionTypes.ItemId[];
+    itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
     allGroups: ReadonlyArray<SelectionTreeTypes.Group>;
 }): string[];
 /**
@@ -143,8 +143,9 @@ export declare function handleItemColorization(args: {
     itemType: GlobalSelectionItemType;
     treeState: SelectionTreeStore;
     affectedGroupId?: Guid;
-    itemIds: GlobalSelectionTypes.ItemId[];
+    itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
     handleColorConflicts?: boolean;
+    useDefaultSelectionTypeColors?: boolean;
 }): string | undefined;
 /**
  * Assigns a color to a set of items within a specified group in the selection tree.
@@ -164,5 +165,6 @@ export declare function assignColorToItemsInGroup(args: {
     itemType: GlobalSelectionItemType;
     allGroups: ReadonlyArray<SelectionTreeTypes.Group>;
     groupId: string;
-    itemIdsToColor: GlobalSelectionTypes.ItemId[];
+    itemIdsToColor: ReadonlyArray<GlobalSelectionTypes.ItemId>;
+    useDefaultSelectionTypeColors?: boolean;
 }): string | undefined;

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

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

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

@@ -0,0 +1,2 @@
+import './registerStrategies';
+export { selectionItemTypeRegistry } from './selectionItemTypeRegistry';

package/src/lib/feature/globalSelection/strategies/isItemIdOfType.d.ts

@@ -0,0 +1,2 @@
+import type { GlobalSelectionItemType, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from '../globalSelectionStore/globalSelectionStore.types';
+export declare function isItemIdOfType<T extends GlobalSelectionItemType>(type: T, itemId: GlobalSelectionTypes.ItemId): itemId is SelectionItemTypeToItemIdMap[T];

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

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

package/src/lib/feature/globalSelection/strategies/registerStrategies.d.ts

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

package/src/lib/feature/globalSelection/strategies/selectionItemTypeRegistry.d.ts

@@ -0,0 +1,37 @@
+import type { GlobalSelectionItemType } from '../globalSelectionStore/globalSelectionStore.types';
+import type { OrderedSelectionItemTypeStrategy, RegistrationOptions, SelectionItemTypeStrategy } from './selectionItemTypeStrategy.types';
+export declare class SelectionItemTypeRegistry {
+    private readonly strategies;
+    private cachedAll;
+    private cachedAllByRegistrationOrder;
+    /**
+     * Register a strategy for the given item type. Throws if the type is already registered.
+     * @param strategy - The strategy implementation for a specific item type.
+     * @param options - Registration options including categoryOrderIndex for UI sort order.
+     */
+    register<T extends GlobalSelectionItemType>(strategy: SelectionItemTypeStrategy<T>, options: RegistrationOptions): void;
+    /**
+     * Retrieve the strategy for a specific item type. Throws if no strategy is registered.
+     * @param type - The item type to look up (e.g. GlobalSelectionItemType.Tag).
+     */
+    get<T extends GlobalSelectionItemType>(type: T): OrderedSelectionItemTypeStrategy<T>;
+    /**
+     * Returns all strategies sorted by `categoryOrderIndex` — use for **UI rendering**.
+     *
+     * `categoryOrderIndex` is a display-order index assigned at registration time that
+     * controls the visual order of categories in the selection menu (e.g. Tags=0, WorkOrders=1, …).
+     * It is independent of registration order and can be set to any value as long as it is unique.
+     */
+    getAll(): ReadonlyArray<OrderedSelectionItemTypeStrategy>;
+    /**
+     * Returns all strategies in the order they were registered — use for **type-guard dispatch**.
+     *
+     * When identifying an unknown `ItemId` (e.g. in `mapIdToItemType`), strategies are tried
+     * in this order until one's `isItemId()` returns true. Registration order therefore controls
+     * type-guard priority: if type A's `isItemId()` can match type B's IDs,
+     * type B must be registered before type A so it is checked first.
+     * See `registerStrategies.ts` for the concrete ordering rationale.
+     */
+    getAllByRegistrationOrder(): ReadonlyArray<OrderedSelectionItemTypeStrategy>;
+}
+export declare const selectionItemTypeRegistry: SelectionItemTypeRegistry;

package/src/lib/feature/globalSelection/strategies/selectionItemTypeStrategy.types.d.ts

@@ -0,0 +1,50 @@
+import type { ResultArray } from '@equinor/echo-search';
+import type { GlobalSelectionItemType, GlobalSelectionItemTypeToDataMap, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from '../globalSelectionStore/globalSelectionStore.types';
+import type { GlobalSelectionCategoryId } from '../selectionMenu/selectionTreeStore/selectionTree.store.types';
+export interface SelectionItemTypeStrategy<T extends GlobalSelectionItemType> {
+    /** Discriminant — e.g. GlobalSelectionItemType.Tag */
+    readonly itemType: T;
+    /** Category ID for tree grouping */
+    readonly categoryId: GlobalSelectionCategoryId;
+    /** Category label shown in UI */
+    readonly categoryLabel: string;
+    /** Type guard: narrows ItemId to this type's ID */
+    isItemId(itemId: GlobalSelectionTypes.ItemId): itemId is SelectionItemTypeToItemIdMap[T];
+    /** Convert raw ItemId to canonical form (trim, normalize) */
+    normalizeId(itemId: SelectionItemTypeToItemIdMap[T]): SelectionItemTypeToItemIdMap[T];
+    /** Serialize ItemId to unique string key */
+    itemIdToString(itemId: SelectionItemTypeToItemIdMap[T]): GlobalSelectionTypes.ItemIdString;
+    /** Check equality of two IDs of this type */
+    idsEqual(itemA: SelectionItemTypeToItemIdMap[T], itemB: SelectionItemTypeToItemIdMap[T]): boolean;
+    /** Create a placeholder item for loading state */
+    createNullItem(itemId: SelectionItemTypeToItemIdMap[T]): GlobalSelectionItemTypeToDataMap[T];
+    /**
+     * Resolve items synchronously from the ID alone — no loading state, no API call.
+     * Only implement when item data is embedded in the ID itself (e.g. PDMS tags).
+     *
+     * The generic action calls this first (if present) and only passes the `remaining` IDs
+     * to `fetchAsync`, skipping the isLoading → fetched cycle for the resolved items.
+     * If absent, all IDs are forwarded directly to `fetchAsync`.
+     */
+    resolveSync?(itemIds: ReadonlyArray<SelectionItemTypeToItemIdMap[T]>): {
+        readonly resolved: ReadonlyArray<{
+            readonly data: GlobalSelectionItemTypeToDataMap[T];
+            readonly id: SelectionItemTypeToItemIdMap[T];
+        }>;
+        readonly remaining: ReadonlyArray<SelectionItemTypeToItemIdMap[T]>;
+    };
+    /**
+     * Fetch real data from the API for items that could not be resolved synchronously.
+     * Called only with the `remaining` IDs returned by resolveSync (or all IDs if resolveSync is absent).
+     */
+    fetchAsync(itemIds: ReadonlyArray<SelectionItemTypeToItemIdMap[T]>): Promise<ReadonlyArray<{
+        readonly result: ResultArray<GlobalSelectionItemTypeToDataMap[T]>;
+        readonly itemIdsUsed: ReadonlyArray<SelectionItemTypeToItemIdMap[T]>;
+    }>>;
+}
+export interface RegistrationOptions {
+    readonly categoryOrderIndex: number;
+}
+export type OrderedSelectionItemTypeStrategy<T extends GlobalSelectionItemType = GlobalSelectionItemType> = SelectionItemTypeStrategy<T> & {
+    readonly categoryOrderIndex: number;
+};

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

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

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

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

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

@@ -1,6 +1,6 @@
 import { LegendId } from '../types/legendType';
 interface LegendSelectorMenuProps {
-    legendId: LegendId;
+    readonly legendId: LegendId;
 }
 export declare const BasicLegendRenderer: import("react").NamedExoticComponent<LegendSelectorMenuProps>;
 export {};

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

@@ -0,0 +1,17 @@
+import { LegendChipProps } from '@equinor/echo-components';
+import { type LegendOptionConfig } from '../types/legendType';
+interface LegendSelectorContainerProps {
+    readonly selectedOption: LegendOptionConfig;
+    readonly onSelectedOptionChange?: (option: LegendOptionConfig) => void;
+    readonly options: ReadonlyArray<LegendOptionConfig>;
+    readonly legendChips: ReadonlyArray<LegendChipProps>;
+    /** Whether this is a marker or badge selector (affects icon displayed) */
+    readonly variant: 'marker' | 'badge';
+}
+/**
+ * A reusable container for legend selectors that handles both option selection
+ * and display option selection (how the badge text is rendered) based on LegendOptionConfigs.
+ * Display options are only available for badge variants with enableDisplayOptions: true.
+ */
+export declare const LegendSelectorContainer: (props: LegendSelectorContainerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import { type LegendId } from '../../../types/legendType';
+interface ItemMarkerPopoverContainerProps {
+    legendId: LegendId;
+    elements: ReadonlyArray<React.ReactElement>;
+    isPopoverActive: boolean;
+    handleClose: () => void;
+}
+export declare const ItemMarkerPopoverContainer: ({ legendId, elements, isPopoverActive, handleClose }: ItemMarkerPopoverContainerProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -1,5 +1,5 @@
+import type { MarkerId } from '../../../../shared/markerId.types';
 import { LegendDataId, LegendId } from '../../../types/legendType';
-import { MarkerId } from '../utils/markerId.utils';
 import { ColorGroupedMarker } from '../utils/splitMarkerByColor.types';
 interface MarkerWithPopoverProps {
     legendId: LegendId;

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

@@ -1,5 +1,5 @@
+import type { MarkerId } from '../../../../../../shared/markerId.types';
 import { Marker } from '../../../../../types/legendMarkerBadge.type';
-import { MarkerId } from '../../../utils/markerId.utils';
 import { ColorGroupedMarker } from '../../../utils/splitMarkerByColor.types';
 /**
  * Builds the list of color-grouped markers to render for a single legend item.

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

@@ -1,4 +1,4 @@
-import { MarkerId } from '../../../utils/markerId.utils';
+import type { MarkerId } from '../../../../../../shared/markerId.types';
 import { ColorGroupedMarker } from '../../../utils/splitMarkerByColor.types';
 interface UseStalePopoverMarkersProps {
     readonly markersToRender: ReadonlyArray<ColorGroupedMarker> | null;
@@ -8,9 +8,9 @@ interface UseStalePopoverMarkersProps {
 /**
  * Holds stale markers visible while selection feedback is displayed after a delayed close or migration.
  *
- * When `shouldDelayPopoverUpdate` is true and the active popover's marker disappears (e.g. last item
+ * When `selectionActionFeedback.isFeedbackActive` is true and the active popover's marker disappears (e.g. last item
  * removed from a color group), this hook keeps the old `MarkerWithPopover` rendered for
- * `POPOVER_UPDATE_DELAY_MS`. That gives the loading indicator and feedback message ("Removed",
+ * `FEEDBACK_DISPLAY_DURATION_MS`. That gives the loading indicator and feedback message ("Removed",
  * "Color changed") time to be visible before the popover closes or migrates to a new marker.
  *
  * @returns The markers that should be rendered — either the stale snapshot or the live `markersToRender`.

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

@@ -1,7 +1,6 @@
+import type { MarkerId } from '../../../../../shared/markerId.types';
 import { LegendDataId, LegendId } from '../../../../types/legendType';
-import { MarkerId } from '../../utils/markerId.utils';
 import { ColorGroupedMarker } from '../../utils/splitMarkerByColor.types';
-export declare const POPOVER_UPDATE_DELAY_MS = 2000;
 /**
  * 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.

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

@@ -1,6 +1,5 @@
-import { Brand } from '@equinor/echo-utils';
+import type { MarkerId } from '../../../../shared/markerId.types';
 import { LegendId } from '../../../types/legendType';
-export type MarkerId = Brand<string, 'MarkerId'>;
 /**
  * Color key used when a marker is not in any selection group (fallback/transparent state).
  */

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

@@ -1,41 +1,24 @@
-import { FC } from 'react';
-import { Marker } from '../../types/legendMarkerBadge.type';
 import { LegendDataId, LegendId } from '../../types/legendType';
 export interface LegendPopoverContentProps {
     legendId: LegendId;
     legendDataId: LegendDataId;
-    title: string | React.ReactNode;
-    description: string;
-    tertiary?: LegendPopoverTertiaryLabels | React.ReactNode;
     onPopoverClicked?: () => void;
     children?: React.ReactNode;
-    excludedLegendTitles?: ReadonlyArray<string>;
+    excludedChipLegendTitles?: ReadonlyArray<string>;
     showAddToSelectionButton?: boolean;
-    getMarkersForChipsCreation?: () => ReadonlyArray<Marker>;
 }
-export type LegendPopoverTertiaryLabels = {
-    first: string;
-    second?: string;
-    third?: string;
-};
 /**
  * Renders the content for a legend popover, typically used as the content for the ItemMarkerPopover component.
- *
- * Uses `legendId` and `legendDataId` to look up and render relevant `LegendChip` components for the given legend item.
- * Displays a title, description, and optional tertiary content (either a structured object with up to three strings, or a custom ReactNode).
- * Additional custom content can be rendered via `children`.
- * Optionally, chips can be created from markers provided by the `getMarkersForChipsCreation` callback.
+ * The content includes dynamically generated chips based on the markers associated with the provided legendId and legendDataId.
+ * It is possible to exclude certain chips based on their legend titles using props. Chips with excluded titles will not be rendered in the popover.
+ * The component also includes an optional "Add to Selection" button that allows users to add the item to their global selection groups.
  *
  * @component
- * @param {object} props - Component props
  * @param {LegendId} props.legendId - The identifier used to look up legend strategy.
  * @param {LegendDataId} props.legendDataId - The identifier for retrieving the markers.
- * @param {string | React.ReactNode} props.title - The main title of the popover.
- * @param {string} props.description - The description or supporting text.
- * @param {LegendPopoverTertiaryLabels | React.ReactNode} [props.tertiary] - Optional tertiary content. If an object, displays up to three labeled strings; if a ReactNode, renders as-is.
- * @param {() => void} [props.onPopoverClicked] - Optional callback for popover click events.
- * @param {React.ReactNode} [props.children] - Optional custom content to render below the predefined main content.
- * @param {ReadonlyArray<string>} [props.excludedLegendTitles] - Optional array of titles to exclude from the legend chips.
- * @param {() => ReadonlyArray<Marker>} [props.getMarkersForChipsCreation] - Optional callback that returns the markers to be used for chip creation.
+ * @param {() => void} [props.onPopoverClicked] - Optional callback for popover content click events.
+ * @param {React.ReactNode} [props.children] - Optional custom content to render inside the popover content area, will be above chips.
+ * @param {ReadonlyArray<string>} [props.excludedChipLegendTitles] - Optional array of titles to exclude from the legend chips.
+ * @param {boolean} [props.showAddToSelectionButton] - Optional flag to show or hide the "Add to Selection" button.
  */
-export declare const LegendPopoverContent: FC<LegendPopoverContentProps>;
+export declare const LegendPopoverContent: (props: LegendPopoverContentProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,8 +1,7 @@
-import { LegendChipProps } from '@equinor/echo-components';
 import { LegendState } from '../../types/legendType';
 import { Marker } from './../../types/legendMarkerBadge.type';
 /**
- * Returns an array of visible LegendChipProps for the given markers and legend state.
+ * 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.
@@ -11,11 +10,18 @@ import { Marker } from './../../types/legendMarkerBadge.type';
  * @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 {LegendChipProps[]} The filtered and mapped array of LegendChipProps for rendering.
+ * @returns {PopoverChip[]} The filtered and mapped array of PopoverChip for rendering.
  */
-export declare function getLegendChipsFromMarkers({ markers, legendSelectedBadgeOption, legendSelectedMarkerOption, excludedLegendTitles }: {
+interface GetPopoverChipsParams {
     markers: ReadonlyArray<Marker>;
-    excludedLegendTitles?: ReadonlyArray<string>;
     legendSelectedBadgeOption?: LegendState['selectedBadgeOption'];
     legendSelectedMarkerOption?: LegendState['selectedMarkerOption'];
-}): LegendChipProps[];
+    excludedLegendTitles?: ReadonlyArray<string>;
+}
+interface PopoverChip {
+    text: string;
+    backgroundColor: string;
+    textColor: string;
+}
+export declare function getPopoverChips({ markers, legendSelectedBadgeOption, legendSelectedMarkerOption, excludedLegendTitles }: GetPopoverChipsParams): PopoverChip[];
+export {};

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

@@ -1,9 +1,5 @@
 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.

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

@@ -18,4 +18,4 @@ export declare const useUniqueVisibleData: () => LegendDataId[];
  * Common logic for creating markers from data using strategy.
  * Selection-based grouping is handled at the viewport rendering level.
  */
-export declare const useCreateMarkers: (legendId: LegendId, data: LegendDataId[], isViewport?: boolean) => ReadonlyArray<Marker>;
+export declare const useCreateMarkers: (legendId: LegendId, data: LegendDataId[]) => ReadonlyArray<Marker>;

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

@@ -4,6 +4,4 @@ import { LegendId } from '../types/legendType';
  * Returns all unique badges for the given legendId, determined by unique title + color.
  * This will also return markers that are not visible on screen.
  */
-export declare function useLegendUniqueBadges(legendId: LegendId, options?: {
-    isViewport?: boolean;
-}): ReadonlyArray<Badge>;
+export declare function useLegendUniqueBadges(legendId: LegendId): ReadonlyArray<Badge>;

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

@@ -4,6 +4,4 @@ import { LegendId } from '../types/legendType';
  * Returns all unique markers for the given legendId, determined by unique displayKey (title + color).
  * This will also return markers that are not visible on screen.
  */
-export declare function useLegendUniqueMarkers(legendId: LegendId, options?: {
-    isViewport?: boolean;
-}): ReadonlyArray<Marker>;
+export declare function useLegendUniqueMarkers(legendId: LegendId): ReadonlyArray<Marker>;

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

@@ -2,22 +2,25 @@ import './legendStrategies/notificationStrategy/notificationStrategy';
 import './legendStrategies/workOrderStrategy/WorkOrderLegend';
 export { getBadgeChips, getMarkerChips } from './components/basicLegendRenderer.logic';
 export { LegendList } from './components/LegendList';
-export { LegendTextSelector } from './components/legendTextSelector/LegendTextSelector';
+export { LegendSelectorContainer } from './components/LegendSelectorContainer';
 export { PositionalItem } from './components/pdfMarkers/PositionalItem';
 export { MultipleMarkersByLegends } from './components/pdfMarkers/subComponents/MultipleMarkersByLegends';
 export { LegendPopoverContent } from './components/popover/LegendPopoverContent';
-export type { LegendPopoverContentProps, LegendPopoverTertiaryLabels } from './components/popover/LegendPopoverContent';
+export type { LegendPopoverContentProps } from './components/popover/LegendPopoverContent';
 export { trackEventNewLegendAccordionToggled, trackEventNewLegendSelectedBadgeOptionChanged, trackEventNewLegendSelectedMarkerOptionChanged } from './legendAnalytics';
 export { legendFacade } from './legendFacade';
 export { getLegendStrategy } from './legendStrategies/legendCollections';
 export { legendSnapShot } from './stores/legendDataStore/legendStore';
 export type { Badge, Marker } from './types/legendMarkerBadge.type';
 export type { LegendStrategy } from './types/legendStrategy.type';
-export type { LegendId, LegendOptionConfig } from './types/legendType';
+export type { LegendBadgeOptionConfig, LegendId, LegendMarkerOptionConfig, LegendOptionConfig, LegendOptionDisplayOption } from './types/legendType';
 export { useLegendUniqueBadges } from './hooks/useLegendUniqueBadges';
 export { useLegendUniqueMarkers } from './hooks/useLegendUniqueMarkers';
 export { useOpenWorkOrdersByTagNos } from './hooks/useWorkOrdersByTagNos';
 export { useWorkOrdersByTagsQuery } from './hooks/useWorkOrdersByTagsQuery';
-export { COUNT_MODE_KEYWORD } from './logic/normalizeBadges';
-export { useLegendVisibleDataStore } from './stores/legendVisibleDataStore/legendVisibleDataStore';
+export { isCountMode, isIdMode, normalizeBadges } from './logic/normalizeBadges';
+export { getColorForLegendStatus } from './logic/getColorForLegendStatus';
+export { createArrayAccessor, createCountAccessor, createDateAccessor, createStringAccessor, getPropertyValues, toSingleTitle } from './logic/propertyAccessor.utils';
+export type { PropertyAccessor } from './logic/propertyAccessor.utils';
 export { useLegendUIStore } from './stores/legendUIStore/legendUIStore';
+export { useLegendVisibleDataStore } from './stores/legendVisibleDataStore/legendVisibleDataStore';

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

@@ -1,4 +1,4 @@
-import type { MarkerId } from './components/pdfMarkers/utils/markerId.utils';
+import type { MarkerId } from '../shared/markerId.types';
 import type { LegendId, LegendState } from './types/legendType';
 export declare const LEGEND_OBJECT_NAME = "Legend";
 export declare function trackEventNewLegendSelectedMarkerOptionChanged(legendId: LegendId, legendState: LegendState): void;

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

@@ -126,6 +126,14 @@ export declare const legendFacade: Readonly<{
                             type: string;
                             value: string;
                         }[];
+                        coordinates: {
+                            tagSeqNo: number;
+                            xEasting: number;
+                            yNorthing: number;
+                            zElevation: number;
+                            uom: string;
+                            linePosition: number | undefined;
+                        }[];
                         tagNo: string;
                         description: string;
                         projectCode: string;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/api/fetchNotificationDetailsByIds.d.ts

@@ -0,0 +1,8 @@
+import type { NotificationDetails } from '@equinor/echo-search';
+import type { LegendNotificationId } from '../../../types/legendType';
+export declare const notificationDetailsQueryOptions: (notificationIds: ReadonlyArray<LegendNotificationId>) => {
+    queryKey: readonly ["notificationDetails", readonly LegendNotificationId[]];
+    queryFn: () => Promise<readonly NotificationDetails[]>;
+    staleTime: number;
+    gcTime: number;
+};

package/src/lib/feature/legend/legendStrategies/notificationStrategy/api/notificationsLegend.api.d.ts

@@ -0,0 +1,7 @@
+import { NotificationDto } from '@equinor/echo-search';
+export declare function createFunctionalLocationList(tagNos: ReadonlyArray<string>, plantNo: string): ReadonlyArray<string>;
+export interface RequestTagsNotifications {
+    readonly tagNos: ReadonlyArray<string>;
+    readonly instCode: string;
+}
+export declare function getOpenNotificationsForTagsApi({ instCode, tagNos }: RequestTagsNotifications): Promise<ReadonlyArray<NotificationDto>>;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/components/NotificationPopover.d.ts

@@ -0,0 +1,8 @@
+import type { NotificationItemCardData } from '@equinor/echo-components';
+import { type LegendDataId } from '../../../types/legendType';
+interface NotificationPopoverProps {
+    legendDataId: LegendDataId;
+    notification: NotificationItemCardData;
+}
+export declare const NotificationPopover: (props: NotificationPopoverProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/lib/feature/legend/legendStrategies/notificationStrategy/hooks/useNotificationDetailsByIds.d.ts

@@ -0,0 +1,2 @@
+import type { LegendDataId } from '../../../types/legendType';
+export declare const useNotificationDetailsByIds: (itemIds: ReadonlyArray<LegendDataId>, isEnabled: boolean) => import("@tanstack/react-query").UseQueryResult<readonly import("@equinor/echo-search").NotificationDetails[], Error>;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/hooks/useNotificationLegendData.d.ts

@@ -0,0 +1,5 @@
+export declare const useNotificationLegendData: () => {
+    isEnabled: boolean;
+    selectedMarkerOption: import("../../../types/legendType").LegendMarkerOptionConfig<string>;
+    selectedBadgeOption: import("../../../types/legendType").LegendBadgeOptionConfig<string>;
+} | undefined;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/hooks/useNotificationMarkers.d.ts

@@ -0,0 +1,10 @@
+import type { Marker } from '../../../types/legendMarkerBadge.type';
+import { type LegendDataId } from '../../../types/legendType';
+/**
+ * Creates notification markers from two sources:
+ * 1. Tag-based: fetches open notifications for selected tags
+ * 2. ID-based: fetches notification details by direct notification IDs
+ *
+ * Both sources are merged into a single marker array.
+ */
+export declare const useNotificationMarkers: (itemIds: ReadonlyArray<LegendDataId>) => ReadonlyArray<Marker>;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/hooks/useOpenNotificationsByTagIds.d.ts

@@ -0,0 +1,14 @@
+import { TagNo, type NotificationDto } from '@equinor/echo-search';
+import { type LegendTagId } from '../../../types/legendType';
+export interface TagNotificationGroup {
+    readonly tagId: TagNo;
+    readonly notifications: ReadonlyArray<NotificationDto>;
+}
+interface UseOpenNotificationsByTagIdsResult {
+    readonly data: ReadonlyArray<TagNotificationGroup>;
+    readonly error: Error | undefined;
+    readonly isFetching: boolean;
+}
+export declare const useOpenNotificationsByTagIds: (tagIds: ReadonlyArray<LegendTagId>, enabled: boolean) => UseOpenNotificationsByTagIdsResult;
+export declare const groupNotificationsByTagId: (notifications: ReadonlyArray<NotificationDto>) => ReadonlyArray<TagNotificationGroup>;
+export {};