@equinor/echo-framework 5.0.0 → 6.0.0

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "peerDependencies": {
-    "@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/echo-base": ">= 6.0.0 < 7.0.0",
+    "@equinor/echo-components": ">= 6.0.0 < 7.0.0",
+    "@equinor/echo-core": ">= 6.0.0 < 7.0.0",
+    "@equinor/echo-search": ">= 6.0.0 < 7.0.0",
+    "@equinor/echo-utils": ">= 6.0.0 < 7.0.0",
     "@equinor/eds-core-react": "0.49.0",
     "@equinor/eds-icons": "0.22.0",
     "@equinor/eds-tokens": "2.1.0",

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

@@ -1,4 +1,6 @@
-import { GlobalSelectionTypes } from './globalSelectionStore/globalSelectionStore.types';
+import { GlobalSelectionItemType, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from './globalSelectionStore/globalSelectionStore.types';
+import { isPdmsTagInSelection } from './pdmsTag/pdmsTag.logic';
+import { AddItemArgs } from './selectionMenu/selectionTreeStore/actions/selectionTree.action.types';
 import { GlobalSelectionCategoryId, SelectionTreeTypes } from './selectionMenu/selectionTreeStore/selectionTree.store.types';
 export declare const globalSelectionApi: Readonly<{
     /**
@@ -75,31 +77,34 @@ export declare const globalSelectionApi: Readonly<{
          * - 'ItemsUpdated': Existing items were replaced with new tags.
          * - 'ItemsAdded': New tags were added to the existing items.
          */
-        tags: (args: import("./selectionMenu/selectionTreeStore/actions/selectionTree.action.types").AddItemArgs<GlobalSelectionTypes.TagId>) => import("./selectionMenu/selectionTreeStore/selectionTree.store.types").AddTagsReturnType;
         /**
-         * Adds work orders to a specified list in the selection menu panel.
+         * Adds items of the given type to a specified list in the selection menu panel.
+         * This is the primary generic method. Per-type aliases (`tags`, `workOrders`, etc.) delegate to this.
          *
-         * @param {Object} args - The arguments for adding work orders.
-         * @param {Guid} args.groupId - Optional. The ID of the list to which the items should be added. If not provided, it will be added to the "Local Selection".
-         * @param {Readonly<Readonly<GlobalSelectionTypes.WorkOrderId>[]>} args.items - An array of WorkOrderId objects representing the work orders to be added.
+         * @param {GlobalSelectionItemType} itemType - The type of items to add.
+         * @param {AddItemArgs} args - The arguments for adding items.
          */
-        workOrders: (args: import("./selectionMenu/selectionTreeStore/actions/selectionTree.action.types").AddItemArgs<GlobalSelectionTypes.WorkOrderId>) => import("./selectionMenu/selectionTreeStore/selectionTree.store.types").AddWorkOrdersReturnType;
+        byType: <T extends GlobalSelectionItemType>(itemType: T, args: AddItemArgs<SelectionItemTypeToItemIdMap[T]>) => Promise<import("./selectionMenu/selectionTreeStore/actions/selectionTree.action.types").AddItemsResponse<T>>;
         /**
-         * Adds equipments to a specified list in the selection menu panel.
-         *
-         * @param {Object} args - The arguments for adding equipments.
-         * @param {Guid} args.groupId - Optional. The ID of the list to which the items should be added. If not provided, it will be added to the "Local Selection".
-         * @param {Readonly<Readonly<GlobalSelectionTypes.EquipmentId>[]>} args.items - An array of EquipmentId objects representing the work orders to be added.
+         * @deprecated Use `globalSelectionApi.add.byType(GlobalSelectionItemType.Tag, args)` instead.
+         * Tracked for removal once Echo3DWeb migrates: #447925
          */
-        equipments: (args: import("./selectionMenu/selectionTreeStore/actions/selectionTree.action.types").AddItemArgs<GlobalSelectionTypes.EquipmentId>) => import("./selectionMenu/selectionTreeStore/selectionTree.store.types").AddEquipmentsReturnType;
+        tags: (args: AddItemArgs<GlobalSelectionTypes.TagId>) => Promise<import("./selectionMenu/selectionTreeStore/actions/selectionTree.action.types").AddItemsResponse<GlobalSelectionItemType.Tag>>;
         /**
-         * Adds measuring points to a specified list in the selection menu panel.
-         *
-         * @param {Object} args - The arguments for adding measuring points.
-         * @param {Guid} args.groupId - Optional. The ID of the list to which the items should be added. If not provided, it will be added to the "Local Selection".
-         * @param {Readonly<Readonly<GlobalSelectionTypes.EquipmentId>[]>} args.items - An array of MeasuringPointId objects representing the work orders to be added.
+         * @deprecated Use `globalSelectionApi.add.byType(GlobalSelectionItemType.WorkOrder, args)` instead.
+         * Tracked for removal once Echo3DWeb migrates: #447925
+         */
+        workOrders: (args: AddItemArgs<GlobalSelectionTypes.WorkOrderId>) => Promise<import("./selectionMenu/selectionTreeStore/actions/selectionTree.action.types").AddItemsResponse<GlobalSelectionItemType.WorkOrder>>;
+        /**
+         * @deprecated Use `globalSelectionApi.add.byType(GlobalSelectionItemType.Equipment, args)` instead.
+         * Tracked for removal once Echo3DWeb migrates: #447925
          */
-        measuringPoints: (args: import("./selectionMenu/selectionTreeStore/actions/selectionTree.action.types").AddItemArgs<GlobalSelectionTypes.MeasuringPointId>) => import("./selectionMenu/selectionTreeStore/selectionTree.store.types").AddMeasuringPointsReturnType;
+        equipments: (args: AddItemArgs<GlobalSelectionTypes.EquipmentId>) => Promise<import("./selectionMenu/selectionTreeStore/actions/selectionTree.action.types").AddItemsResponse<GlobalSelectionItemType.Equipment>>;
+        /**
+         * @deprecated Use `globalSelectionApi.add.byType(GlobalSelectionItemType.MeasuringPoint, args)` instead.
+         * Tracked for removal once Echo3DWeb migrates: #447925
+         */
+        measuringPoints: (args: AddItemArgs<GlobalSelectionTypes.MeasuringPointId>) => Promise<import("./selectionMenu/selectionTreeStore/actions/selectionTree.action.types").AddItemsResponse<GlobalSelectionItemType.MeasuringPoint>>;
         /**
          * Adds items to a specified list in the selection menu panel.
          *
@@ -128,11 +133,6 @@ export declare const globalSelectionApi: Readonly<{
         findGroupByLabel: (args: {
             label: string;
         }) => import("@equinor/echo-utils").Guid | undefined;
-        /**
-         * Retrieves a tag item from the selection by tagNo and instCode.
-         * Returns undefined if the tag is not in the selection.
-         */
-        getTag: typeof getTag;
     };
     /**
      * Moves items, categories, or groups within the selection tree structure.
@@ -242,6 +242,10 @@ export declare const globalSelectionApi: Readonly<{
          * @returns {number} The total number of items in all categories of the given groups.
          */
         numberOfItemsInSelection: (groups?: SelectionTreeTypes.Group[]) => number;
+        /**
+         * Checks if a tag (by tagNo + instCode) is in the selection and is a PDMS tag.
+         */
+        isPdmsTagInSelection: typeof isPdmsTagInSelection;
     }>;
     /**
      * Removes all items from the selection menu panel.
@@ -263,8 +267,4 @@ export declare const globalSelectionApi: Readonly<{
 }>;
 declare function getStoreTagIds(): GlobalSelectionTypes.TagId[];
 declare function getStoreEquipmentIds(): GlobalSelectionTypes.EquipmentId[];
-declare function getTag(args: {
-    readonly tagNo: string;
-    readonly instCode: string;
-}): GlobalSelectionTypes.TagItem | undefined;
 export {};

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

@@ -23,6 +23,23 @@ export type SelectionItemTypeToItemIdMap = {
     [GlobalSelectionItemType.Equipment]: GlobalSelectionTypes.EquipmentId;
     [GlobalSelectionItemType.MeasuringPoint]: GlobalSelectionTypes.MeasuringPointId;
 };
+/**
+ * CustomData is a flexible key-value pair type that can be used in the relatedTo field of selection tree items.
+ * It allows associating any arbitrary data with a selection item, as long as it follows the structure of having a string key and a string value.
+ * This is useful for scenarios where we want to link selection items to external systems or include additional metadata that doesn't fit into the predefined item types.
+ * Cannot be set as a top-level item in the global selection, it can only be used in relatedTo.
+ */
+export interface CustomDataId {
+    readonly key: string;
+    readonly value: string;
+}
+/**
+ * Types allowed in relatedTo: all top-level types + CustomData (which is relatedTo-only).
+ */
+export type RelatedToItemType = GlobalSelectionItemType | 'CustomData';
+export type RelatedToItemTypeToIdMap = SelectionItemTypeToItemIdMap & {
+    readonly CustomData: CustomDataId;
+};
 type GlobalSelectionList<T extends GlobalSelectionItemType> = {
     readonly items: Map<GlobalSelectionTypes.ItemIdString, GlobalSelectionGenericItem<T>>;
 };
@@ -109,6 +126,7 @@ export declare namespace GlobalSelectionTypes {
      */
     type TagId = StidTagId | PdmsTagId;
     type MeasuringPointId = Pick<GlobalSelectionMeasuringPointDto, 'measuringPointId'>;
+    type RelatedToItemId = WorkOrderId | EquipmentId | TagId | MeasuringPointId | CustomDataId;
     type ItemId = WorkOrderId | EquipmentId | TagId | MeasuringPointId;
     type ItemIdString = Brand<string, 'ItemIdString'>;
     type TagDto = GlobalSelectionTagDto;

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

@@ -1,31 +1,31 @@
 import { ResultArray } from '@equinor/echo-search';
 import { GlobalSelectionItemType, GlobalSelectionItemTypeToDataMap, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from './globalSelectionStore.types';
-import { isEquipmentId, isMeasuringPointId, isTagId, isWorkOrderId } from './itemIdTypeGuards';
+import { isEquipmentId, isMeasuringPointId, isPdmsTagId, isTagId, isWorkOrderId } from './itemIdTypeGuards';
 declare function idsEqual(itemA: GlobalSelectionTypes.ItemId, itemB: GlobalSelectionTypes.ItemId): boolean;
 declare function mapToId(item: GlobalSelectionTypes.ItemId): GlobalSelectionTypes.ItemId;
 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.
+ * Utility functions for handling global selection item IDs and types.
  */
 export declare const globalSelectionUtils: Readonly<{
+    /** Checks if the passed object is a global selection `MeasuringPointId`. */
     isMeasuringPointId: typeof isMeasuringPointId;
+    /** Checks if the passed object is a global selection `WorkOrderId`. */
     isWorkOrderId: typeof isWorkOrderId;
+    /** Checks if the passed object is a global selection `EquipmentId`. */
     isEquipmentId: typeof isEquipmentId;
+    /** Checks if the passed object is a global selection `TagId` (STID). */
     isTagId: typeof isTagId;
+    /** Checks if the passed object is a PDMS `TagId` — a `TagId` with `internalTagType`, `plantNo`, and `plantCode`. */
+    isPdmsTagId: typeof isPdmsTagId;
+    /** Compares two global selection item IDs for equality using the registered strategy for their type. */
     idsEqual: typeof idsEqual;
+    /** Normalizes an `ItemId` to its canonical form via the registered strategy (e.g. trims whitespace, uppercases instCode). Preserves all properties including PDMS fields. */
     mapToId: typeof mapToId;
+    /** Returns the `GlobalSelectionItemType` enum value for a given `ItemId`. */
     mapIdToItemType: typeof mapIdToItemType;
+    /** ONE-WAY conversion of an `ItemId` to a string suitable for use as a `Map` key. Cannot be reversed. For tags, uses only `tagNo-instCode` (PDMS fields are not included). */
     itemIdToString: typeof itemIdToString;
 }>;
 /**

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

@@ -1,6 +1,11 @@
 import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
 /**
- * Hook to check if an item is in the global selection
+ * Hook to check if an item is in the global selection.
+ *
+ * The check runs inside the Zustand selector and returns a boolean.
+ * Zustand's `Object.is` comparison on the boolean means the component only
+ * re-renders when the actual in-selection status changes, not on every store mutation.
+ *
  * @param {GlobalSelectionTypes.ItemId} itemId - The itemId
  * @returns {boolean} - True if the item is in global selection, false otherwise
  */

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

@@ -1,7 +1,7 @@
 export * from './globalSelectionStore/globalSelectionStore.types';
 export * from './selectionMenu/selectionTreeStore/selectionTree.api.types';
 export * from './selectionMenu/selectionTreeStore/selectionTree.store.types';
-export { PDMS_INTERNAL_TAG_TYPES, isPdmsInternalTagType } from './pdmsTag/pdmsTag.types';
+export { isPdmsInternalTagType, PDMS_INTERNAL_TAG_TYPES } from './pdmsTag/pdmsTag.types';
 export type { PdmsInternalTagType, PdmsTagId, PdmsTagSummaryDto, StidTagId } from './pdmsTag/pdmsTag.types';
 export { useAreAllItemsVisible } from './hooks/useAreAllItemsVisible';
 export { useGlobalSelectionByItemId } from './hooks/useGlobalSelectionByItemId';
@@ -9,8 +9,6 @@ export { useGlobalSelectionItems } from './hooks/useGlobalSelectionItems';
 export { useGlobalSelectionItemsByType } from './hooks/useGlobalSelectionItemsByType';
 export { useGlobalSelectionItemsByTypeAsMap } from './hooks/useGlobalSelectionItemsByTypeAsMap';
 export { useGlobalSelectionLists } from './hooks/useGlobalSelectionLists';
-export { useGlobalSelectionTags } from './hooks/useGlobalSelectionTags';
-export { useGlobalSelectionWorkOrders } from './hooks/useGlobalSelectionWorkOrders';
 export { useIsInGlobalSelection } from './hooks/useIsInGlobalSelection';
 export { useItemGroupMembership } from './hooks/useItemGroupMembership';
 export { useSelectionCategoriesByGroupId } from './hooks/useSelectionCategoriesByGroupId';
@@ -29,6 +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 { isPdmsTagId } from './globalSelectionStore/itemIdTypeGuards';
-export { isPdmsTagInSelection } from './pdmsTag/pdmsTag.logic';
 export { createPdmsTagSummaryDto, isPdmsTagSummaryDto } from './pdmsTag/pdmsTag.utils';

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/addItems.action.d.ts

@@ -7,8 +7,8 @@ export type AddItemsActionArgs = {
     readonly useDefaultSelectionTypeColors?: boolean;
 };
 /**
- * Adds items to the selection tree store by categorizing them into tags, work orders,
- * equipments, and measuring points, then dispatching the appropriate add actions for each type.
+ * Adds items to the selection tree store by categorizing them by type using the strategy registry,
+ * then dispatching addItemsByType for each type group.
  *
  * @param get - A function that returns the current instance of the SelectionTreeStore.
  * @param args - The arguments for adding items, including an array of item IDs and additional label arguments.

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/addItemsByType.action.d.ts

@@ -0,0 +1,15 @@
+import { StoreApi } from 'zustand';
+import { GlobalSelectionItemType, SelectionItemTypeToItemIdMap } from '../../../globalSelectionStore/globalSelectionStore.types';
+import { SelectionTreeStore } from '../selectionTree.store.types';
+import { AddItemArgs, AddItemsResponse } from './selectionTree.action.types';
+type SetFunction = (set: (state: SelectionTreeStore) => void, shouldReplace: boolean | undefined, action: string | undefined) => void;
+/**
+ * Generic tree action for adding items of any registered type to the selection tree.
+ * Replaces the 4 per-type action files (addTags, addWorkOrders, addEquipments, addMeasuringPoints).
+ *
+ * Reads category config (categoryId, categoryOrderIndex) from the strategy registry so no
+ * per-type branching is needed here or in the store.
+ */
+export declare function createAddItemsByTypeAction<T extends GlobalSelectionItemType>(itemType: T): (set: (set: (state: SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: StoreApi<SelectionTreeStore>["getState"], args: AddItemArgs<SelectionItemTypeToItemIdMap[T]>) => Promise<AddItemsResponse<T>>;
+export declare function addItemsByTypeAction<T extends GlobalSelectionItemType>(set: SetFunction, get: StoreApi<SelectionTreeStore>['getState'], itemType: T, args: AddItemArgs<SelectionItemTypeToItemIdMap[T]>): Promise<AddItemsResponse<T>>;
+export {};

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/initialData.d.ts

@@ -1,12 +1,6 @@
 import { SelectionCategory, SelectionGroup } from './selectionTree.store.types';
 export declare const selectionTreeInitialData: Readonly<{
     localSelectionGroup: SelectionGroup;
-    categoryOrder: {
-        tagIndex: number;
-        workOrderIndex: number;
-        equipmentIndex: number;
-        measuringPointIndex: number;
-    };
     localSelectionGroupIndex: 0;
     getInitialCategories: () => SelectionCategory[];
 }>;

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

@@ -7,7 +7,7 @@ import { SelectionGroup } from '../selectionTree.store.types';
  * This function takes the `data` property from an API selection tree root object,
  * extracts all items from the nested structure, and groups their normalized IDs
  * by their corresponding `GlobalSelectionItemType`. It then creates selection lists
- * for each type using the `selectionTreeLoader.createListByType` utility.
+ * for each type using the strategy registry (null/loading-state items).
  *
  * @param param0 - An object containing the `data` array from the API selection tree root.
  * @returns An object containing:

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

@@ -1,6 +1,7 @@
 import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionItemType, SelectionItemTypeToItemIdMap } from '../../globalSelectionStore/globalSelectionStore.types';
+import { GlobalSelectionItemType, RelatedToItemType, RelatedToItemTypeToIdMap, SelectionItemTypeToItemIdMap } from '../../globalSelectionStore/globalSelectionStore.types';
 export type ApiSelectionTreeItemId = SelectionItemTypeToItemIdMap[GlobalSelectionItemType];
+export type ApiRelatedToItemId = RelatedToItemTypeToIdMap[RelatedToItemType];
 export interface ApiGlobalSelectionMetaData {
     readonly color: string | undefined;
     readonly isHiddenByUser: boolean | undefined;
@@ -29,10 +30,15 @@ export interface ApiSelectionGroup {
 export interface ApiSelectionCategory {
     readonly items: ApiSelectionTreeItem[];
 }
+export interface ApiRelatedToItem {
+    readonly id: ApiRelatedToItemId;
+    readonly type: RelatedToItemType;
+}
 export interface ApiSelectionTreeItem {
     readonly type: GlobalSelectionItemType;
     readonly id: ApiSelectionTreeItemId;
     readonly metaData?: ApiGlobalSelectionMetaData;
+    readonly relatedTo?: ReadonlyArray<ApiRelatedToItem>;
 }
 export interface ApiSelectionHistory {
     readonly id: Guid;

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

@@ -11,7 +11,7 @@ import { SelectionGroup, SelectionTreeStore } from './selectionTree.store.types'
  *
  * @example
  * const selectionTree = useSelectionTreeStore();
- * selectionTree.addTags({ ... });
+ * selectionTree.addItemsByType(GlobalSelectionItemType.Tag, { ... });
  *
  * @see SelectionTreeStore
  */
@@ -37,10 +37,7 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
             groupId?: Guid;
             useDefaultSelectionTypeColors?: boolean;
         }) => Promise<void>;
-        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;
+        addItemsByType: <T extends import("../..").GlobalSelectionItemType>(itemType: T, args: import("./actions/selectionTree.action.types").AddItemArgs<import("../..").SelectionItemTypeToItemIdMap[T]>) => Promise<import("./actions/selectionTree.action.types").AddItemsResponse<T>>;
         createGroup: (args: {
             groupId?: string;
             label: string;
@@ -103,6 +100,28 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
                         measuringPointId: string;
                     };
                     type: import("../..").GlobalSelectionItemType;
+                    relatedTo?: {
+                        id: {
+                            workOrderId: string;
+                        } | {
+                            instCode: string;
+                            tagNo: string;
+                        } | {
+                            internalTagType: import("../..").PdmsInternalTagType;
+                            plantNo: string;
+                            plantCode: string;
+                            instCode: string;
+                            tagNo: string;
+                        } | {
+                            equipmentId: string;
+                        } | {
+                            measuringPointId: string;
+                        } | {
+                            key: string;
+                            value: string;
+                        };
+                        type: import("../..").RelatedToItemType;
+                    }[] | undefined;
                 }>;
             }[];
             groupId: Guid;

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

@@ -1,5 +1,5 @@
 import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionItemType, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from '../../globalSelectionStore/globalSelectionStore.types';
+import { GlobalSelectionItemType, GlobalSelectionTypes, RelatedToItemType, RelatedToItemTypeToIdMap, SelectionItemTypeToItemIdMap } from '../../globalSelectionStore/globalSelectionStore.types';
 import { AddItemArgs, AddItemsResponse, SelectionTreeActionResult } from './actions/selectionTree.action.types';
 export declare enum GlobalSelectionCategoryId {
     Tags = "DEFAULT_TAG_LIST_ID",
@@ -8,9 +8,14 @@ export declare enum GlobalSelectionCategoryId {
     MeasuringPoints = "DEFAULT_MEASURING_POINT_LIST_ID"
 }
 export declare const globalSelectionDefaultGroupId: Guid;
+export interface RelatedToItem {
+    readonly id: RelatedToItemTypeToIdMap[RelatedToItemType];
+    readonly type: RelatedToItemType;
+}
 export type SelectionTreeItem<T extends GlobalSelectionItemType> = {
     readonly id: SelectionItemTypeToItemIdMap[T];
     readonly type: T;
+    readonly relatedTo?: RelatedToItem[];
 };
 export interface SelectionBase {
     readonly groupId: Guid;
@@ -39,10 +44,7 @@ export interface SelectionTreeStore extends SelectionTreeData {
         groupId?: Guid;
         useDefaultSelectionTypeColors?: boolean;
     }) => Promise<void>;
-    addTags: (args: AddItemArgs<GlobalSelectionTypes.TagId>) => AddTagsReturnType;
-    addWorkOrders: (args: AddItemArgs<GlobalSelectionTypes.WorkOrderId>) => AddWorkOrdersReturnType;
-    addEquipments: (args: AddItemArgs<GlobalSelectionTypes.EquipmentId>) => AddEquipmentsReturnType;
-    addMeasuringPoints: (args: AddItemArgs<GlobalSelectionTypes.MeasuringPointId>) => AddMeasuringPointsReturnType;
+    addItemsByType: <T extends GlobalSelectionItemType>(itemType: T, args: AddItemArgs<SelectionItemTypeToItemIdMap[T]>) => Promise<AddItemsResponse<T>>;
     createGroup: (args: {
         groupId?: string;
         label: string;
@@ -89,7 +91,3 @@ export declare namespace SelectionTreeTypes {
     type ActionResult = SelectionTreeActionResult;
     type Item = SelectionTreeItem<GlobalSelectionItemType>;
 }
-export type AddTagsReturnType = Promise<AddItemsResponse<GlobalSelectionItemType.Tag>>;
-export type AddWorkOrdersReturnType = Promise<AddItemsResponse<GlobalSelectionItemType.WorkOrder>>;
-export type AddEquipmentsReturnType = Promise<AddItemsResponse<GlobalSelectionItemType.Equipment>>;
-export type AddMeasuringPointsReturnType = Promise<AddItemsResponse<GlobalSelectionItemType.MeasuringPoint>>;

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

@@ -18,6 +18,8 @@ export interface SelectionItemTypeStrategy<T extends GlobalSelectionItemType> {
     idsEqual(itemA: SelectionItemTypeToItemIdMap[T], itemB: SelectionItemTypeToItemIdMap[T]): boolean;
     /** Create a placeholder item for loading state */
     createNullItem(itemId: SelectionItemTypeToItemIdMap[T]): GlobalSelectionItemTypeToDataMap[T];
+    /** Extract the canonical ItemId from a fetched data object. Used as a type-safe Map key. */
+    getItemId(data: GlobalSelectionItemTypeToDataMap[T]): SelectionItemTypeToItemIdMap[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).

package/src/lib/services/api/api-plantinfo.d.ts

@@ -1,5 +1,5 @@
 import { EchoHubPlant } from '../../types/echoHubPlant';
 import { ModelPermissions } from '../../types/modelPermissions';
 export declare function getPlantsInfo(instCode?: string): Promise<EchoHubPlant[]>;
-export declare function check3dPermissionForPlant(plantCode: string): Promise<ModelPermissions>;
+export declare function check3dPermissionForPlant(plantCode: string): Promise<boolean>;
 export declare function getPermitted3dModels(): Promise<ModelPermissions>;

package/src/lib/utils/plantInfo.d.ts

@@ -46,8 +46,8 @@ export declare function allPlantCodesOnInstallation(instCode: string): Promise<s
  * Method for checking a users access to a given installation
  *
  * @export
- * @param {string} instCode installation code to check access for
- * @return {*}  {Promise<boolean>} returns whether the user has access to that given installation
+ * @param instCode installation code to check access for
+ * @return returns whether the user has access to one or more 3d models on the given installation
  */
 export declare function check3dPermissionOnInstallation(instCode: string): Promise<boolean>;
 /**

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

@@ -1,6 +0,0 @@
-import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
-/**
- * Returns with the stored Tags from the global selection store
- * @returns {GlobalSelectionTypes.TagItem[]} Array of Tags with some global selection meta data.
- */
-export declare function useGlobalSelectionTags(): GlobalSelectionTypes.TagItem[];

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

@@ -1,6 +0,0 @@
-import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
-/**
- * Returns with the stored Work Orders from the global selection store
- * @returns {GlobalSelectionTypes.WorkOrderItem[]} Array of Work Orders
- */
-export declare function useGlobalSelectionWorkOrders(): GlobalSelectionTypes.WorkOrderItem[];

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/addEquipments.action.d.ts

@@ -1,2 +0,0 @@
-import { GlobalSelectionItemType } from '../../../globalSelectionStore/globalSelectionStore.types';
-export declare const addEquipmentsAction: (set: (set: (state: import("../selectionTree.store.types").SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../selectionTree.store.types").SelectionTreeStore>["getState"], args: import("./selectionTree.action.types").AddItemArgs<import("../../../globalSelectionStore/globalSelectionStore.types").GlobalSelectionTypes.EquipmentId>) => Promise<import("./selectionTree.action.types").AddItemsResponse<GlobalSelectionItemType.Equipment>>;

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/addMeasuringPoints.action.d.ts

@@ -1,2 +0,0 @@
-import { GlobalSelectionItemType } from '../../../globalSelectionStore/globalSelectionStore.types';
-export declare const addMeasuringPointsAction: (set: (set: (state: import("../selectionTree.store.types").SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../selectionTree.store.types").SelectionTreeStore>["getState"], args: import("./selectionTree.action.types").AddItemArgs<import("../../../globalSelectionStore/globalSelectionStore.types").GlobalSelectionTypes.MeasuringPointId>) => Promise<import("./selectionTree.action.types").AddItemsResponse<GlobalSelectionItemType.MeasuringPoint>>;

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/addTags.action.d.ts

@@ -1,2 +0,0 @@
-import { GlobalSelectionItemType } from '../../../globalSelectionStore/globalSelectionStore.types';
-export declare const addTagsAction: (set: (set: (state: import("../selectionTree.store.types").SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../selectionTree.store.types").SelectionTreeStore>["getState"], args: import("./selectionTree.action.types").AddItemArgs<import("../../../globalSelectionStore/globalSelectionStore.types").GlobalSelectionTypes.TagId>) => Promise<import("./selectionTree.action.types").AddItemsResponse<GlobalSelectionItemType.Tag>>;

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/addWorkOrders.action.d.ts

@@ -1,2 +0,0 @@
-import { GlobalSelectionItemType } from '../../../globalSelectionStore/globalSelectionStore.types';
-export declare const addWorkOrdersAction: (set: (set: (state: import("../selectionTree.store.types").SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../selectionTree.store.types").SelectionTreeStore>["getState"], args: import("./selectionTree.action.types").AddItemArgs<import("../../../globalSelectionStore/globalSelectionStore.types").GlobalSelectionTypes.WorkOrderId>) => Promise<import("./selectionTree.action.types").AddItemsResponse<GlobalSelectionItemType.WorkOrder>>;

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/persist/selectionTreeLoader.service.d.ts

@@ -1,42 +0,0 @@
-import { ResultArray } from '@equinor/echo-search';
-import { GlobalSelectionItemType, GlobalSelectionItemTypeToDataMap, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from '../../../globalSelectionStore/globalSelectionStore.types';
-type ListCreatorParams<T extends GlobalSelectionItemType> = {
-    nullItemGenerator: (itemId: SelectionItemTypeToItemIdMap[T]) => GlobalSelectionItemTypeToDataMap[T];
-};
-/**
- * Service responsible for managing the registration and execution of list creators and API loaders
- * for different global selection item types within the selection tree.
- *
- * Mainly used for loading and setting huge amount of data when loading selections from API and or from disk.
- *
- * This service allows dynamic registration of functions that can create selection lists or fetch
- * and update selection data for specific item types. It provides methods to register these handlers,
- * create lists, and fetch/store data by type.
- *
- * @remarks
- * - `registerListCreator` associates a list creation function with a specific item type.
- * - `registerApiLoader` associates an asynchronous data loader with a specific item type.
- * - `createListByType` uses the registered creator to generate a selection list for the given type and item IDs.
- * - `fetchAndStoreDataByType` uses the registered loader to fetch and update data for the given type and item IDs.
- *
- * @template T - The global selection item type.
- */
-declare class SelectionTreeLoaderService {
-    private listCreators;
-    private apiLoaders;
-    registerGroupCreator<T extends GlobalSelectionItemType>(type: T, params: ListCreatorParams<T>): void;
-    registerApiLoader<T extends GlobalSelectionItemType>(type: T, fetchFunction: (itemIds: SelectionItemTypeToItemIdMap[T][]) => Promise<{
-        result: ResultArray<GlobalSelectionItemTypeToDataMap[T]>;
-        itemIdsUsed: SelectionItemTypeToItemIdMap[T][];
-    }[]>): void;
-    createListByType<T extends GlobalSelectionItemType>(type: T, itemIds: SelectionItemTypeToItemIdMap[T][]): GlobalSelectionTypes.List<T>;
-    fetchAndStoreDataByType<T extends GlobalSelectionItemType>(type: T, itemIds: SelectionItemTypeToItemIdMap[T][]): Promise<void>;
-}
-/**
- * Service responsible for managing the registration and execution of list creators and API loaders
- * for different global selection item types within the selection tree.
- *
- * Used for loading and setting huge amount of data when loading selections from API and or from disk.
- */
-export declare const selectionTreeLoader: SelectionTreeLoaderService;
-export {};