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

package/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./src\\index";
-export { default } from "./src\\index";
+export * from "./src/index";
+export { default } from "./src/index";

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "5.0.0-beta-r19-0",
+  "version": "5.0.0",
   "peerDependencies": {
-    "@equinor/echo-base": "5.0.0-beta-r19-0",
-    "@equinor/echo-components": "5.0.0-beta-r19-0",
-    "@equinor/echo-core": "5.0.0-beta-r19-0",
-    "@equinor/echo-search": "5.0.0-beta-r19-0",
-    "@equinor/echo-utils": "5.0.0-beta-r19-0",
+    "@equinor/echo-base": ">= 5.0.0 < 6.0.0",
+    "@equinor/echo-components": ">= 5.0.0 < 6.0.0",
+    "@equinor/echo-core": ">= 5.0.0 < 6.0.0",
+    "@equinor/echo-search": ">= 5.0.0 < 6.0.0",
+    "@equinor/echo-utils": ">= 5.0.0 < 6.0.0",
     "@equinor/eds-core-react": "0.49.0",
     "@equinor/eds-icons": "0.22.0",
     "@equinor/eds-tokens": "2.1.0",

package/src/index.d.ts

@@ -7,6 +7,11 @@ export { AppLauncherButton } from './lib/components/appLauncherButton';
 export type { AppLauncherButtonProps } from './lib/components/appLauncherButton';
 export { NotificationListItem } from './lib/components/notificationListItem';
 export type { NotificationListItemType } from './lib/components/notificationListItem';
+export { fetchWorkOrderObjectsWithSelectionIds } from './lib/components/prepview/panels/objects/objects.logic';
+export { AddSelectionListWithSameNameDialog } from './lib/components/prepview/panels/objects/selectionActionBarMultiple/AddSelectionListWithSameNameDialog';
+export { OBJECT_LIST_FOR_WORK_ORDER_LABEL_PREFIX } from './lib/components/prepview/panels/objects/selectionActionBarMultiple/logic/selectionActionBarMultiple.constants';
+export { addSelectionItemsToNewSelectionGroup } from './lib/components/prepview/panels/objects/selectionActionBarMultiple/logic/selectionActionBarMultiple.orchestration';
+export { doesSelectionGroupLabelExist } from './lib/components/prepview/panels/objects/selectionActionBarMultiple/logic/selectionActionBarMultiple.utils';
 export { PrepviewButton } from './lib/components/prepviewButton/prepviewButton';
 export { useFetchPlantInfo } from './lib/components/requestAccess/hooks/fetchPlantInfo';
 export { MissingAccessInfoButton } from './lib/components/requestAccess/MissingAccessInfoButton';
@@ -21,7 +26,7 @@ export * from './lib/feature/equipment/index';
 export * from './lib/feature/globalSelection';
 export { ItemDetailsSelectionActionBar, SelectionActionBar } from './lib/feature/globalSelection/components/selectionActionBar/SelectionActionBar';
 export { PanTo3DButton } from './lib/feature/globalSelection/panToEcho3d/panTo3DButton';
-export { useIsAllIGlobalSelectionItemsHidden } from './lib/feature/globalSelection/selectionMenu/hooks/useIsAllIGlobalSelectionItemsHidden';
+export { useIsAllGlobalSelectionItemsHidden } from './lib/feature/globalSelection/selectionMenu/hooks/useIsAllGlobalSelectionItemsHidden';
 export { useSelectionColorFrequencyByIds } from './lib/feature/globalSelection/selectionMenu/hooks/useSelectionColorFrequency';
 export { useSelectionTreeAutoSave } from './lib/feature/globalSelection/selectionMenu/selectionTreeStore/persist/useSelectionTreeAutoSave';
 export { GlobalSelectionCategoryId } from './lib/feature/globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.types';

package/src/lib/components/prepview/panels/objects/selectionActionBarMultiple/logic/selectionActionBarMultiple.logic.d.ts

@@ -0,0 +1,4 @@
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionTypes } from '../../../../../../feature/globalSelection/globalSelectionStore/globalSelectionStore.types';
+export declare function findWorkOrderColorInSelection(hiddenSelectionItemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>): string | undefined;
+export declare function overrideGroupItemColors(groupId: Guid, color: string): void;

package/src/lib/feature/equipment/components/fullEquipmentItem/fullEquipmentItem.d.ts

@@ -1,7 +1,7 @@
 interface FullEquipmentItemProps {
-    equipmentId: string;
-    tagNo: string | undefined;
-    plantNo: string | undefined;
+    readonly equipmentId: string;
+    readonly tagNo: string | undefined;
+    readonly plantNo: string | undefined;
 }
 export declare const FullEquipmentItem: React.FC<FullEquipmentItemProps>;
 export {};

package/src/lib/feature/globalSelection/components/selectionActionBar/SelectionActionBar.d.ts

@@ -1,8 +1,10 @@
+import type { MarkerId } from '../../../shared/markerId.types';
 import { GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
 export interface SelectionActionBarProps {
     readonly itemId: GlobalSelectionTypes.ItemId;
     readonly className?: string;
-    readonly showPopoverUpdateDelay?: boolean;
+    /** MarkerId of the marker that owns this action bar. Scopes feedback to this popover only. */
+    readonly markerId?: MarkerId;
 }
 export declare const SelectionActionBar: React.FC<SelectionActionBarProps>;
 /**

package/src/lib/feature/globalSelection/components/selectionActionBar/hooks/useSelectionAction.d.ts

@@ -0,0 +1,28 @@
+import { Guid } from '@equinor/echo-utils';
+import type { MarkerId } from '../../../../shared/markerId.types';
+import { GlobalSelectionTypes } from '../../../globalSelectionStore/globalSelectionStore.types';
+/**
+ * Hook to manage selection actions for global selection.
+ *
+ * Feedback state (isFeedbackActive, feedbackType, actionMarkerId) is stored in a dedicated
+ * micro Zustand store so it survives component remounts during the stale-marker holding period
+ * (e.g. when a remove action causes the colored marker variant to disappear and
+ * useStalePopoverMarkers briefly unmounts/remounts the popover tree).
+ *
+ * While isFeedbackActive is true, useMarkerPopover delays popover content refresh and
+ * useStalePopoverMarkers keeps the old marker rendered so the feedback stays visible —
+ * but only for the marker identified by actionPopoverId, not globally.
+ *
+ * @param markerId - Optional ID of the popover that owns this action bar. When provided,
+ *   feedback state is scoped to this popover: only the matching popover sees feedback,
+ *   and other popovers remain unaffected. Pass `undefined` for non-popover contexts
+ *   (e.g. ItemDetails pages).
+ * @returns Object containing loading state, feedback type, and functions to add/remove items from selection.
+ */
+export declare function useSelectionAction(markerId?: MarkerId): {
+    isFeedbackActive: boolean;
+    feedbackType: import("@equinor/echo-components").SelectionBarFeedbackType | undefined;
+    addToSelection: (groupId: Guid, itemId: GlobalSelectionTypes.ItemId) => Promise<void>;
+    removeFromSelection: (groupId: Guid, itemId: GlobalSelectionTypes.ItemId) => void;
+    changeColor: (itemId: GlobalSelectionTypes.ItemId, color: string) => void;
+};

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

@@ -0,0 +1,17 @@
+import type { ResultArray } from '@equinor/echo-search';
+import type { StoreApi } from 'zustand';
+import type { SelectionItemTypeStrategy } from '../../strategies/selectionItemTypeStrategy.types';
+import type { GlobalSelectionAddItemResult, GlobalSelectionItemType, GlobalSelectionItemTypeToDataMap, GlobalSelectionStore, SelectionItemTypeToItemIdMap } from '../globalSelectionStore.types';
+type SetFunction = (updater: (state: GlobalSelectionStore) => void, shouldReplace?: boolean, action?: string) => void;
+/**
+ * Generic store action that adds items of any type to the global selection store.
+ *
+ * Handles two paths based on whether the strategy implements `resolveSync`:
+ *  1. Resolved items (e.g. PDMS tags): written directly as `loadedSuccessfully` — no loading flicker.
+ *  2. Remaining items: written as `isLoading` placeholders, then fetched via `strategy.fetchAsync`.
+ */
+export declare function addItemsByStrategyAction<T extends GlobalSelectionItemType>(set: SetFunction, get: StoreApi<GlobalSelectionStore>['getState'], strategy: SelectionItemTypeStrategy<T>, args: {
+    itemIds: ReadonlyArray<SelectionItemTypeToItemIdMap[T]>;
+    color?: string;
+}): Promise<GlobalSelectionAddItemResult<ResultArray<GlobalSelectionItemTypeToDataMap[T]>[]>>;
+export {};

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

@@ -35,22 +35,11 @@ export declare const useGlobalSelectionStore: import("zustand").UseBoundStore<Om
     };
 }, "setState"> & {
     setState(nextStateOrUpdater: GlobalSelectionStore | Partial<GlobalSelectionStore> | ((state: {
-        addWorkOrdersToSelection: (args: {
-            workOrderIds: GlobalSelectionTypes.WorkOrderId[];
-            color?: string;
-        }) => Promise<import("./globalSelectionStore.types").GlobalSelectionAddItemResult<import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").WorkOrderData>[]>>;
-        addTagsToSelection: (args: {
-            tagIds: GlobalSelectionTypes.TagId[];
-            color?: string;
-        }) => Promise<import("./globalSelectionStore.types").GlobalSelectionAddItemResult<import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").TagSummaryDto>[]>>;
-        addEquipmentsToSelection: (args: {
-            equipmentIds: GlobalSelectionTypes.EquipmentId[];
-            color?: string;
-        }) => Promise<import("./globalSelectionStore.types").GlobalSelectionAddItemResult<import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").EquipmentData>[]>>;
-        addMeasuringPointsToSelection: (args: {
-            measuringPointIds: GlobalSelectionTypes.MeasuringPointId[];
-            color?: string;
-        }) => Promise<import("./globalSelectionStore.types").GlobalSelectionAddItemResult<import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").MeasuringPointData>[]>>;
+        addItemsToSelection: <T extends GlobalSelectionItemType>(args: {
+            readonly itemType: T;
+            readonly itemIds: ReadonlyArray<import("./globalSelectionStore.types").SelectionItemTypeToItemIdMap[T]>;
+            readonly color?: string;
+        }) => Promise<import("./globalSelectionStore.types").GlobalSelectionAddItemResult<import("@equinor/echo-search").ResultArray<import("./globalSelectionStore.types").GlobalSelectionItemTypeToDataMap[T]>[]>>;
         removeItemsFromSelection: (args: {
             itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
         }) => void;
@@ -160,6 +149,14 @@ export declare const useGlobalSelectionStore: import("zustand").UseBoundStore<Om
                             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/globalSelection/globalSelectionStore/globalSelectionStore.types.d.ts

@@ -59,22 +59,15 @@ interface ItemErrorStatusUpdates {
     readonly errorStatus: string;
 }
 export interface GlobalSelectionStore extends GlobalSelectionStoreData {
-    addWorkOrdersToSelection: (args: {
-        workOrderIds: GlobalSelectionTypes.WorkOrderId[];
-        color?: string;
-    }) => Promise<GlobalSelectionAddItemResult<ResultArray<WorkOrderData>[]>>;
-    addTagsToSelection: (args: {
-        tagIds: GlobalSelectionTypes.TagId[];
-        color?: string;
-    }) => Promise<GlobalSelectionAddItemResult<ResultArray<TagSummaryDto>[]>>;
-    addEquipmentsToSelection: (args: {
-        equipmentIds: GlobalSelectionTypes.EquipmentId[];
-        color?: string;
-    }) => Promise<GlobalSelectionAddItemResult<ResultArray<EquipmentData>[]>>;
-    addMeasuringPointsToSelection: (args: {
-        measuringPointIds: GlobalSelectionTypes.MeasuringPointId[];
-        color?: string;
-    }) => Promise<GlobalSelectionAddItemResult<ResultArray<MeasuringPointData>[]>>;
+    /**
+     * Generic method to add items of any type to the selection.
+     * Replaces the 4 per-type methods below. Use this for all new code.
+     */
+    addItemsToSelection<T extends GlobalSelectionItemType>(args: {
+        readonly itemType: T;
+        readonly itemIds: ReadonlyArray<SelectionItemTypeToItemIdMap[T]>;
+        readonly color?: string;
+    }): Promise<GlobalSelectionAddItemResult<ResultArray<GlobalSelectionItemTypeToDataMap[T]>[]>>;
     removeItemsFromSelection: (args: {
         itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
     }) => void;

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

@@ -2,54 +2,20 @@ import { ResultArray } from '@equinor/echo-search';
 import { GlobalSelectionItemType, GlobalSelectionItemTypeToDataMap, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from './globalSelectionStore.types';
 import { isEquipmentId, isMeasuringPointId, isTagId, isWorkOrderId } from './itemIdTypeGuards';
 declare function idsEqual(itemA: GlobalSelectionTypes.ItemId, itemB: GlobalSelectionTypes.ItemId): boolean;
-/**
- * Overloaded function that maps an item to its corresponding ID type based on the item's properties.
- * The return type is specific to the type of item passed to the function.
- *
- * @param {GlobalSelectionTypes.WorkOrderId} item - The work order item to be mapped.
- * @returns {GlobalSelectionTypes.WorkOrderId} - The mapped work order ID.
- */
-/**
- * @param {GlobalSelectionTypes.EquipmentId} item - The equipment item to be mapped.
- * @returns {GlobalSelectionTypes.EquipmentId} - The mapped equipment ID.
- */
-/**
- * @param {GlobalSelectionTypes.TagId} item - The tag item to be mapped.
- * @returns {GlobalSelectionTypes.TagId} - The mapped tag ID.
- */
-/**
- * Maps an item to its corresponding ID object by checking the item's type and returning the appropriate ID object,
- * removing leading zeros from the ID string and trimming whitespace.
- * If the item type is not recognized, an error is thrown.
- *
- * @param {GlobalSelectionTypes.ItemId} item - The data to be mapped to its ID type.
- * @returns {GlobalSelectionTypes.ItemId} - The mapped tag ID.
- */
-declare function mapToId(item: GlobalSelectionTypes.WorkOrderId): GlobalSelectionTypes.WorkOrderId;
-declare function mapToId(item: GlobalSelectionTypes.EquipmentId): GlobalSelectionTypes.EquipmentId;
-declare function mapToId(item: GlobalSelectionTypes.TagId): GlobalSelectionTypes.TagId;
-declare function mapToId(item: GlobalSelectionTypes.MeasuringPointId): GlobalSelectionTypes.MeasuringPointId;
 declare function mapToId(item: GlobalSelectionTypes.ItemId): GlobalSelectionTypes.ItemId;
-/**
- * Converts an item ID to a string representation for use as Map keys.
- * This is a ONE-WAY conversion - the string cannot be converted back to the original ID.
- *
- * For tags: Always returns `tagNo-instCode` regardless of whether it's a STID or PDMS tag.
- * This ensures both tag types use the same key format for O(1) Map lookups.
- *
- * To preserve full ID properties (e.g., PDMS properties for API saving), use `mapToId` instead.
- */
 declare function itemIdToString(itemId: GlobalSelectionTypes.ItemId): GlobalSelectionTypes.ItemIdString;
 export declare function mapIdToItemType(itemId: GlobalSelectionTypes.ItemId): GlobalSelectionItemType;
 /**
  * A utility object that provides various functions for handling global selections.
  *
  * @namespace globalSelectionUtils
+ * @property {Function} isMeasuringPointId - Checks if the passed object is a global selection MeasuringPointID.
  * @property {Function} isWorkOrderId - Checks if the passed object is a global selection WorkOrderID.
  * @property {Function} isEquipmentId - Checks if the passed object is a global selection EquipmentID.
  * @property {Function} isTagId - Checks if the passed object is a global selection TagID.
  * @property {Function} idsEqual - Compares two global selection item IDs for equality.
  * @property {Function} mapToId - Maps an object to its global selection item ID, preserving all properties (including PDMS).
+ * @property {Function} mapIdToItemType - Returns the GlobalSelectionItemType enum value for a given ItemId.
  * @property {Function} itemIdToString - ONE-WAY conversion to string for Map keys. Cannot be reversed. For tags, uses only tagNo-instCode.
  */
 export declare const globalSelectionUtils: Readonly<{

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

@@ -0,0 +1,30 @@
+import type { SelectionBarFeedbackType } from '@equinor/echo-components';
+import type { MarkerId } from '../../shared/markerId.types';
+/**
+ * How long selection-action feedback stays visible.
+ * Legend popovers reuse this same duration when holding stale markers rendered,
+ * so the popover lifecycle matches the feedback lifecycle exactly.
+ */
+export declare const FEEDBACK_DISPLAY_DURATION_MS = 2000;
+export interface SelectionActionFeedback {
+    readonly isFeedbackActive: boolean;
+    readonly feedbackType: SelectionBarFeedbackType | undefined;
+    /** MarkerId of the marker that initiated the action. Consumers compare this to their own markerId. */
+    readonly actionMarkerId: MarkerId | undefined;
+}
+interface SelectionActionFeedbackStore extends SelectionActionFeedback {
+    /**
+     * Updates the selection action feedback state (isFeedbackActive + feedbackType).
+     * Stored in a dedicated micro store so it survives component remounts during
+     * the stale-marker holding period. While `isFeedbackActive` is true, useMarkerPopover
+     * delays popover content refresh and useStalePopoverMarkers keeps the old marker
+     * rendered so the feedback ("Added ✓", "Removed ✓") stays visible.
+     */
+    setFeedback: (feedback: SelectionActionFeedback) => void;
+}
+export declare const useSelectionActionFeedbackStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SelectionActionFeedbackStore>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: SelectionActionFeedbackStore | Partial<SelectionActionFeedbackStore> | ((state: SelectionActionFeedbackStore) => SelectionActionFeedbackStore | Partial<SelectionActionFeedbackStore>), replace?: boolean | undefined, action?: A | undefined): void;
+}>;
+export {};

package/src/lib/feature/globalSelection/hooks/useGlobalSelectionLists.d.ts

@@ -1,6 +1,8 @@
+import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
+export interface GlobalSelectionList {
+    readonly items: readonly GlobalSelectionTypes.SelectionItem[];
+}
 /**
  * Hook for returning all lists stored in the global selection.
  */
-export declare function useGlobalSelectionLists(): {
-    items: (import("..").GlobalSelectionGenericItem<import("..").GlobalSelectionItemType.WorkOrder> | import("..").GlobalSelectionGenericItem<import("..").GlobalSelectionItemType.Tag> | import("..").GlobalSelectionGenericItem<import("..").GlobalSelectionItemType.Equipment> | import("..").GlobalSelectionGenericItem<import("..").GlobalSelectionItemType.MeasuringPoint>)[];
-}[];
+export declare function useGlobalSelectionLists(): readonly GlobalSelectionList[];

package/src/lib/feature/globalSelection/hooks/useIsInGlobalSelection.d.ts

@@ -2,7 +2,6 @@ import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionSto
 /**
  * Hook to check if an item is in the global selection
  * @param {GlobalSelectionTypes.ItemId} itemId - The itemId
- * @param {GlobalSelectionItemType} itemType - The item type
  * @returns {boolean} - True if the item is in global selection, false otherwise
  */
 export declare function useIsInGlobalSelection(itemId: GlobalSelectionTypes.ItemId): boolean;

package/src/lib/feature/globalSelection/hooks/useSelectionCategoriesByGroupId.d.ts

@@ -1,9 +1,10 @@
 import { Guid } from '@equinor/echo-utils';
 import { SelectionTreeTypes } from '../selectionMenu/selectionTreeStore/selectionTree.store.types';
 /**
- * Custom hook to get the selection categories by group ID from the global selection tree hiearchy.
+ * Custom hook to get the selection categories by group ID from the global selection tree hierarchy.
  *
- * This hook retrieves the categories for a given group ID from the selection tree store.
+ * Zustand's Object.is equality check on the selector return value ensures re-renders only
+ * happen when this specific group's categories change, not on unrelated group mutations.
  *
  * @param {Guid} groupId - The ID of the group to get categories for.
  * @returns {SelectionTreeTypes.Category[] | undefined} The categories for the given group ID, or undefined if not found.

package/src/lib/feature/globalSelection/selectionMenu/hooks/{useIsAllIGlobalSelectionItemsHidden.d.ts → useIsAllGlobalSelectionItemsHidden.d.ts}

@@ -1,8 +1,4 @@
 import { Guid } from '@equinor/echo-utils';
-interface UseIsAllIGlobalSelectionItemsHiddenArgs {
-    groupId: Guid;
-    categoryId?: string;
-}
 /**
  * Custom hook to determine if all items in a selection list are hidden by the user.
  *
@@ -15,5 +11,7 @@ interface UseIsAllIGlobalSelectionItemsHiddenArgs {
  *
  * The hook returns `true` if all items in the list are hidden by the user, and `false` otherwise.
  */
-export declare const useIsAllIGlobalSelectionItemsHidden: (args: UseIsAllIGlobalSelectionItemsHiddenArgs) => boolean;
-export {};
+export declare const useIsAllGlobalSelectionItemsHidden: (args: {
+    groupId: Guid;
+    categoryId?: string;
+}) => boolean;

package/src/lib/feature/globalSelection/selectionMenu/hooks/useSelectionColorFrequency.d.ts

@@ -5,14 +5,17 @@ import { GlobalSelectionTypes } from '../../globalSelectionStore/globalSelection
  * This hook retrieves the global selection items and filters them based on the provided item IDs,
  * extracts their associated colors, and sorts the colors by frequency.
  *
+ * Callers must provide a referentially stable `itemIds` array (e.g. via `useMemo`)
+ * to avoid unnecessary recomputation on every render.
+ *
  * @param itemIds - An array of item IDs to match against global selection items.
  * @returns An array of color strings sorted by frequency, most frequent first.
  */
-export declare function useSelectionColorFrequencyByIds(itemIds: GlobalSelectionTypes.ItemId[]): string[];
+export declare function useSelectionColorFrequencyByIds(itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>): readonly string[];
 /**
  * Returns the most frequently used selection color from the provided item IDs.
  *
  * @param itemIds - An array of item IDs to analyze for color frequency.
  * @returns The most used selection color as a string, or `undefined` if no colors are present.
  */
-export declare function useMostUsedSelectionColorByIds(itemIds: GlobalSelectionTypes.ItemId[]): string | undefined;
+export declare function useMostUsedSelectionColorByIds(itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>): 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/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/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/hooks/{useNotificationsByTagIds.d.ts → useOpenNotificationsByTagIds.d.ts}

@@ -4,11 +4,11 @@ export interface TagNotificationGroup {
     readonly tagId: TagNo;
     readonly notifications: ReadonlyArray<NotificationDto>;
 }
-interface UseNotificationsByTagIdsResult {
+interface UseOpenNotificationsByTagIdsResult {
     readonly data: ReadonlyArray<TagNotificationGroup>;
     readonly error: Error | undefined;
     readonly isFetching: boolean;
 }
-export declare const useNotificationsByTagIds: (tagIds: ReadonlyArray<LegendTagId>, enabled: boolean) => UseNotificationsByTagIdsResult;
+export declare const useOpenNotificationsByTagIds: (tagIds: ReadonlyArray<LegendTagId>, enabled: boolean) => UseOpenNotificationsByTagIdsResult;
 export declare const groupNotificationsByTagId: (notifications: ReadonlyArray<NotificationDto>) => ReadonlyArray<TagNotificationGroup>;
 export {};

package/src/lib/feature/legend/legendStrategies/notificationStrategy/logic/notificationLegend.logic.d.ts

@@ -6,7 +6,7 @@ interface CreateMarkerFromNotificationsArgs {
     readonly selectedMarkerOption: LegendMarkerOptionConfig;
     readonly selectedBadgeOption: LegendBadgeOptionConfig;
 }
-export declare const createMarkerFromNotifications: ({ notifications, selectedMarkerOption, selectedBadgeOption }: CreateMarkerFromNotificationsArgs) => Marker;
+export declare const createMarkerFromNotifications: ({ notifications, selectedMarkerOption, selectedBadgeOption }: CreateMarkerFromNotificationsArgs) => Marker | undefined;
 export declare const createMarkerTitle: (notifications: ReadonlyArray<NotificationLegendData>, selectedMarkerOption: LegendMarkerOptionConfig) => string;
 export declare const createBadges: (notifications: ReadonlyArray<NotificationLegendData>, selectedBadgeOption: LegendBadgeOptionConfig) => ReadonlyArray<Badge>;
 export {};