@equinor/echo-framework 0.22.0-beta-0 → 0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "0.22.0-beta-0",
+  "version": "0.22.0",
   "peerDependencies": {
     "@equinor/echo-base": ">= 0.7.0 < 0.8.0",
     "@equinor/echo-components": ">= 0.12.0 < 0.13.0",

package/src/index.d.ts

@@ -12,17 +12,19 @@ export { fetchEquipmentFromApi } from './lib/feature/equipment/api/api-equipment
 export * from './lib/feature/equipment/index';
 export * from './lib/feature/globalSelection';
 export { SelectionActionBar } from './lib/feature/globalSelection/components/SelectionActionBar';
-export type { OptimizedWorkOrderDto } from './lib/feature/globalSelection/globalSelectionStore/globalSelectionStore.types';
 export { PanTo3DButton } from './lib/feature/globalSelection/panToEcho3d/panTo3DButton';
 export { useIsAllIGlobalSelectionItemsHidden } from './lib/feature/globalSelection/selectionMenu/hooks/useIsAllIGlobalSelectionItemsHidden';
 export { GlobalSelectionCategoryId, SelectionMenuDefaultListIds } from './lib/feature/globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.types';
 export * from './lib/feature/legacyLegend/index';
+export { PositionalLegendMarkers } from './lib/feature/legend/components/pdfMarkers/PositionalLegendMarkers';
+export * from './lib/feature/legend/index';
+export { subscribeToLegendDataChanged } from './lib/feature/legend/legendUpdater';
+export type { LegendDataId, LegendEquipmentId, LegendState, LegendTagId } from './lib/feature/legend/types/legendType';
 export { getLatestMeasurementDate, sortMeasuringPointsByMeasurementDate } from './lib/feature/measuringPoint/components/measuringPoints.utils';
 export * from './lib/feature/measuringPoint/index';
 export * from './lib/feature/measuringPoint/types/measuringPoint';
 export * from './lib/feature/openItemsIn3d';
 export { createEcho3dInternalLink } from './lib/feature/openItemsIn3d/logic/createEcho3dInternalLink';
-export { OpenIn3dSelectedItemsMenu } from './lib/feature/openItemsIn3d/OpenIn3dSelectedItemsMenu';
 export { WorkOrderContent } from './lib/feature/workOrder/WorkOrderContent';
 export { RegisteredHookName } from './lib/hooks/hookLibrary';
 export { useCloseActiveTopMenuAtBreakPoint } from './lib/hooks/useCloseActiveTopMenuAtBreakPoint';

package/src/lib/coreApplication/EchoContent.d.ts

@@ -1,7 +1,8 @@
 import React from 'react';
 interface CorePanelsProps {
     children: React.ReactNode;
-    Legend?: React.FC;
+    Legend: React.FC | null | undefined;
+    isOnboardingCompleted: boolean;
 }
 export declare const EchoContent: React.FC<CorePanelsProps>;
 export {};

package/src/lib/feature/equipment/types/equipment.d.ts

@@ -28,6 +28,8 @@ export interface Equipment {
     readonly tagId: string | undefined;
     readonly tagPlantId: string | undefined;
     readonly userStatusIds: string[];
+    readonly partType?: string;
+    readonly partTypeText?: string;
 }
 export declare enum EquipmentCategoryId {
     L = "L",

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

@@ -1,7 +1,7 @@
-import { GlobalSelectionTypes, OptimizedWorkOrderDto } from '../globalSelectionStore/globalSelectionStore.types';
+import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
 import { GlobalSelectionCategoryId } from '../selectionMenu/selectionTreeStore/selectionTree.store.types';
 export interface SelectionActionBarProps {
-    itemId: GlobalSelectionTypes.TagId | OptimizedWorkOrderDto;
+    itemId: GlobalSelectionTypes.ItemId;
     categoryId: GlobalSelectionCategoryId;
 }
 export declare const SelectionActionBar: React.FC<SelectionActionBarProps>;

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

@@ -1,7 +1,7 @@
 import { GlobalSelectionTypes } from './globalSelectionStore/globalSelectionStore.types';
-import { AddTagsArgs } from './selectionMenu/selectionTreeStore/actions/addTag.action.types';
+import { AddItemArgs } from './selectionMenu/selectionTreeStore/actions/selectionTree.action.types';
 import { AddTagsReturnType, GlobalSelectionCategoryId, SelectionTreeTypes } from './selectionMenu/selectionTreeStore/selectionTree.store.types';
-type AddTagsType = <T extends boolean | undefined = undefined>(args: AddTagsArgs & {
+type AddTagsType = <T extends boolean | undefined = undefined>(args: AddItemArgs<GlobalSelectionTypes.TagId> & {
     getActionResult?: T;
 }) => Promise<AddTagsReturnType<T>>;
 export declare const globalSelectionApi: Readonly<{
@@ -59,7 +59,15 @@ export declare const globalSelectionApi: Readonly<{
          */
         listById: (args: {
             groupId: import("dist/libs/echo-utils/src").Guid;
-            categoryId?: GlobalSelectionCategoryId;
+            categoryId? /**
+             * Removes all items by their IDs, from all groups, from the state.
+             *
+             * If the given item ids are in more than one group, then a confirmation dialog will be shown to confirm the action.
+             *
+             * @param {Object} args - The arguments object.
+             * @param {GlobalSelectionTypes.ItemId[]} args.itemIds - The array of item IDs to remove.
+             * @returns {void}
+             */: GlobalSelectionCategoryId;
         }) => void;
     }>;
     add: Readonly<{
@@ -67,7 +75,7 @@ export declare const globalSelectionApi: Readonly<{
          * Adds tags to a selection and updates the state accordingly.
          * Creates a group if label and sublabel are passed and the group doesn't exist.
          *
-         * @param {AddTagsArgs} args - The arguments for adding tags.
+         * @param {AddItemArgs} args - The arguments for adding tags.
          * @param {Array<string>} args.itemIds - The IDs of the items to add tags to.
          * @param {boolean} [args.replaceItems=false] - Whether to replace existing items with the new tags.
          * @param {boolean} [args.getActionResult] - Optional, temporary. Will be removed. When passed the function will return with the actionResult as well.
@@ -86,32 +94,20 @@ export declare const globalSelectionApi: Readonly<{
          *
          * @param {Object} args - The arguments for adding work orders.
          * @param {Guid} args.groupId - Optional. The ID of the list to which the work orders should be added. If not provided, it will be added to the "Local Selection".
-         * @param {Readonly<Readonly<OptimizedWorkOrderDto>[]>} args.items - An array of OptimizedWorkOrderDto objects representing the work orders to be added.
+         * @param {Readonly<Readonly<GlobalSelectionTypes.WorkOrderId>[]>} args.items - An array of WorkOrderId objects representing the work orders to be added.
          */
-        workOrders: (args: {
-            groupId?: import("dist/libs/echo-utils/src").Guid;
-            items: Readonly<Readonly<import("./globalSelectionStore/globalSelectionStore.types").OptimizedWorkOrderDto>[]>;
-        }) => void;
+        workOrders: (args: AddItemArgs<GlobalSelectionTypes.WorkOrderId>) => void;
         /**
          * Adds items to a specified list in the selection menu panel.
          *
          * @param {Object} args - The arguments for adding items.
          * @param {Guid} args.groupId - Optional. The ID of the list to which the items should be added. If not provided, the default list ID is used.
-         * @param {GlobalSelectionTypes.TagId | OptimizedWorkOrderDto)[]} args.itemIds - ItemIds to be added. Only tags or work orders can be added for now.
+         * @param {GlobalSelectionTypes.ItemId[]} args.itemIds - ItemIds to be added. Only tags or work orders can be added for now.
          *
          */
         addItems: (args: {
-            groupId? /**
-             * Removes items from a specified list in the selection menu panel by their IDs.
-             *
-             * @param {Object} args - The arguments for removing items.
-             * @param {Readonly<GlobalSelectionTypes.ItemId[]>} args.itemIds - An array of item IDs representing the items to be removed.
-             * @param {Guid} args.groupId - Optional. The ID of the list where the subList of the items are located.
-             * Local selection will be used by default.
-             * @param {GlobalSelectionCategoryId} args.category - The ID of the list where the items to be removed are located.
-             */: import("dist/libs/echo-utils/src").Guid;
-            itemIds: (GlobalSelectionTypes.TagId | import("./globalSelectionStore/globalSelectionStore.types").OptimizedWorkOrderDto)[];
-        }) => void;
+            itemIds: GlobalSelectionTypes.ItemId[];
+        } & import("./selectionMenu/selectionTreeStore/actions/selectionTree.action.types").AddByLabel) => void;
     }>;
     search: {
         /**

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

@@ -0,0 +1,18 @@
+import { ResultArray } from '@equinor/echo-search';
+import { StoreApi } from 'zustand';
+import { GlobalSelectionItemType, GlobalSelectionItemTypeToDataMap, GlobalSelectionStore, GlobalSelectionTypes } from '../globalSelectionStore.types';
+type FetchFunction<T, U> = (itemIds: Readonly<U[]>) => Promise<ResultArray<T>[]>;
+type NullItemGenerator<T, U> = (itemId: U) => T;
+type ItemIdTypeMap = {
+    [GlobalSelectionItemType.WorkOrder]: GlobalSelectionTypes.WorkOrderId;
+    [GlobalSelectionItemType.Tag]: GlobalSelectionTypes.TagId;
+    [GlobalSelectionItemType.Equipment]: GlobalSelectionTypes.EquipmentId;
+};
+type SetFunction = (set: (state: GlobalSelectionStore) => void, shouldReplace?: boolean | undefined, action?: string) => void;
+export declare function addItemsToSelection<T extends GlobalSelectionItemType>(set: SetFunction, get: StoreApi<GlobalSelectionStore>['getState'], args: {
+    itemIds: ItemIdTypeMap[T][];
+}, itemType: T, fetchFunction: FetchFunction<GlobalSelectionItemTypeToDataMap[T], ItemIdTypeMap[T]>, nullItemGenerator: NullItemGenerator<GlobalSelectionItemTypeToDataMap[T], ItemIdTypeMap[T]>): Promise<{
+    fetchResult: ResultArray<GlobalSelectionItemTypeToDataMap[T]>[];
+    actionResult: GlobalSelectionTypes.ActionResult;
+}>;
+export {};

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

@@ -0,0 +1,4 @@
+import { WorkOrderData } from '@equinor/echo-search';
+import { GlobalSelectionTypes } from './globalSelectionStore.types';
+export declare function createNullTagSummaryDb(itemId: GlobalSelectionTypes.TagId): GlobalSelectionTypes.TagDto;
+export declare function createNullWorkOrderData(itemId: GlobalSelectionTypes.WorkOrderId): WorkOrderData;

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

@@ -1,8 +1,7 @@
-import { WritableDraft } from 'immer';
-import { GlobalSelectionItemType, GlobalSelectionTypes } from './globalSelectionStore.types';
-export declare const initialWorkOrderList: WritableDraft<GlobalSelectionTypes.WorkOrderList>;
-export declare const initialTagList: WritableDraft<GlobalSelectionTypes.TagList>;
-export declare const initialEquipmentList: WritableDraft<GlobalSelectionTypes.EquipmentList>;
+import { GlobalSelectionStore, GlobalSelectionTypes } from './globalSelectionStore.types';
+export declare const initialWorkOrderList: GlobalSelectionTypes.WorkOrderList;
+export declare const initialTagList: GlobalSelectionTypes.TagList;
+export declare const initialEquipmentList: GlobalSelectionTypes.EquipmentList;
 /**
  * The single source of truth for items stored in Global Selection.
  * Each item is stored here once, does not store item grouping in any way.
@@ -21,29 +20,33 @@ export declare const initialEquipmentList: WritableDraft<GlobalSelectionTypes.Eq
  *
  * For accessing and using global selection features, use the globalSelectionApi from echo-framework.
  */
-export declare const useGlobalSelectionStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<import("./globalSelectionStore.types").GlobalSelectionStore>, "setState"> & {
+export declare const useGlobalSelectionStore: import("zustand").UseBoundStore<Omit<Omit<Omit<Omit<import("zustand").StoreApi<GlobalSelectionStore>, "setState"> & {
     setState<A extends string | {
         type: string;
-    }>(partial: import("./globalSelectionStore.types").GlobalSelectionStore | Partial<import("./globalSelectionStore.types").GlobalSelectionStore> | ((state: import("./globalSelectionStore.types").GlobalSelectionStore) => import("./globalSelectionStore.types").GlobalSelectionStore | Partial<import("./globalSelectionStore.types").GlobalSelectionStore>), replace?: boolean | undefined, action?: A | undefined): void;
+    }>(partial: GlobalSelectionStore | Partial<GlobalSelectionStore> | ((state: GlobalSelectionStore) => GlobalSelectionStore | Partial<GlobalSelectionStore>), replace?: boolean | undefined, action?: A | undefined): void;
 }, "subscribe"> & {
     subscribe: {
-        (listener: (selectedState: import("./globalSelectionStore.types").GlobalSelectionStore, previousSelectedState: import("./globalSelectionStore.types").GlobalSelectionStore) => void): () => void;
-        <U>(selector: (state: import("./globalSelectionStore.types").GlobalSelectionStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+        (listener: (selectedState: GlobalSelectionStore, previousSelectedState: GlobalSelectionStore) => void): () => void;
+        <U>(selector: (state: GlobalSelectionStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
             equalityFn?: ((a: U, b: U) => boolean) | undefined;
             fireImmediately?: boolean;
         } | undefined): () => void;
     };
+}, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<GlobalSelectionStore, GlobalSelectionStore>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: GlobalSelectionStore) => void) => () => void;
+        onFinishHydration: (fn: (state: GlobalSelectionStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<GlobalSelectionStore, GlobalSelectionStore>>;
+    };
 }, "setState"> & {
-    setState(nextStateOrUpdater: import("./globalSelectionStore.types").GlobalSelectionStore | Partial<import("./globalSelectionStore.types").GlobalSelectionStore> | ((state: WritableDraft<import("./globalSelectionStore.types").GlobalSelectionStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+    setState(nextStateOrUpdater: GlobalSelectionStore | Partial<GlobalSelectionStore> | ((state: import("immer").WritableDraft<GlobalSelectionStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;
     } | undefined): void;
 }>;
-/**
- * Determine if a given selection type has any items being loaded.
- * @param {GlobalSelectionItemType} selectionType - A specific type from GlobalSelectionItemType for the list to check.
- * @returns {boolean} - Returns true if there are any items being loaded in the specified selection type.
- */
-export declare function useIsGlobalSelectionListLoading<K extends GlobalSelectionItemType>(selectionType: K): boolean;
 /**
  * Get a snapshot of the current global selection store state.
  *

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

@@ -0,0 +1,8 @@
+import { PersistOptions } from 'zustand/middleware';
+import { GlobalSelectionStore } from './globalSelectionStore.types';
+declare function loadAndPopulateStoreMetadata(store: GlobalSelectionStore): Promise<void>;
+export declare const globalSelectionRepository: {
+    loadAndPopulateStoreMetadata: typeof loadAndPopulateStoreMetadata;
+    persistOptions: PersistOptions<GlobalSelectionStore, GlobalSelectionStore>;
+};
+export {};

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

@@ -1,36 +1,41 @@
-import { ResultArray, TagSummaryDto } from '@equinor/echo-search';
+import { ResultArray, TagSummaryDto, WorkOrderData } from '@equinor/echo-search';
+import { Brand } from '@equinor/echo-utils';
 import { Equipment } from '../../equipment';
 export declare enum GlobalSelectionItemType {
     WorkOrder = "WorkOrder",
     Tag = "Tag",
     Equipment = "Equipment"
 }
-interface GlobalSelectionItemTypeToDataMap {
-    WorkOrder: OptimizedWorkOrderDto;
-    Tag: TagSummaryDto;
+type GlobalSelectionTagDto = TagSummaryDto;
+type GlobalSelectionWorkOrderDto = WorkOrderData;
+export interface GlobalSelectionItemTypeToDataMap {
+    WorkOrder: GlobalSelectionWorkOrderDto;
+    Tag: GlobalSelectionTagDto;
     Equipment: Equipment;
 }
 type GlobalSelectionList<T extends GlobalSelectionItemType> = {
     label: string;
     type: T;
-    items: GlobalSelectionTypes.GenericItem<T>[];
-    itemsBeingLoaded: GlobalSelectionTypes.ItemId[];
+    items: Map<GlobalSelectionTypes.ItemIdString, GlobalSelectionTypes.GenericItem<T>>;
 };
 export type GlobalSelectionObject = {
     [K in GlobalSelectionItemType]: GlobalSelectionList<K>;
 };
-/**
- * @deprecated We plan to make this private in the future: Use the public GlobalSelectionTypes namespace to access this type.
- */
-export type GlobalSelectionGenericItem<T extends GlobalSelectionItemType> = {
+export interface GlobalSelectionStoreData {
+    lists: GlobalSelectionObject;
+}
+export type SelectionItemSystemStatus = 'isLoading' | 'notFound' | 'loadedSuccessfully';
+export interface GlobalSelectionMetaData {
+    color: string;
+    isHiddenByUser: boolean;
+    errorStatus?: string;
+    systemStatus: SelectionItemSystemStatus;
+}
+type GlobalSelectionGenericItem<T extends GlobalSelectionItemType> = {
     id: GlobalSelectionTypes.ItemId;
     type: T;
     data: GlobalSelectionTypes.ItemTypeToDataMap[T];
-    metaData: {
-        color: string;
-        isHiddenByUser: boolean;
-        errorStatus?: string;
-    };
+    metaData: GlobalSelectionMetaData;
 };
 type EquipmentGlobalSelectionList = GlobalSelectionTypes.List<GlobalSelectionItemType.Equipment>;
 type WorkOrderGlobalSelectionList = GlobalSelectionTypes.List<GlobalSelectionItemType.WorkOrder>;
@@ -40,14 +45,13 @@ interface ItemErrorStatusUpdates {
     itemId: GlobalSelectionTypes.ItemId;
     errorStatus: string;
 }
-export interface GlobalSelectionStore {
-    lists: GlobalSelectionObject;
+export interface GlobalSelectionStore extends GlobalSelectionStoreData {
     addWorkOrdersToSelection: (args: {
-        workOrders: Readonly<OptimizedWorkOrderDto[]>;
-    }) => void;
+        workOrderIds: GlobalSelectionTypes.WorkOrderId[];
+    }) => Promise<GlobalSelectionAddItemResult<ResultArray<WorkOrderData>[]>>;
     addTagsToSelection: (args: {
-        tagIds: Readonly<GlobalSelectionTypes.TagId[]>;
-    }) => Promise<AddTagActionResult>;
+        tagIds: GlobalSelectionTypes.TagId[];
+    }) => Promise<GlobalSelectionAddItemResult<ResultArray<TagSummaryDto>[]>>;
     removeItemsFromSelection: (args: {
         itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
     }) => void;
@@ -55,6 +59,10 @@ export interface GlobalSelectionStore {
         itemIds: Readonly<Readonly<GlobalSelectionTypes.ItemId>>[];
         isVisible: boolean;
     }) => void;
+    setItemMetaData: (args: ReadonlyArray<{
+        itemId: GlobalSelectionTypes.ItemId;
+        metaData: Partial<GlobalSelectionMetaData>;
+    }>) => void;
     resetItemErrorStatuses: () => void;
     resetState: () => void;
     setErrorStatusForItems: (args: {
@@ -65,15 +73,18 @@ export interface GlobalSelectionStore {
     }) => void;
 }
 type GlobalSelectionActionResult = 'NoChanges' | 'ItemsAdded';
-type AddTagActionResult = {
-    fetchResult: ResultArray<TagSummaryDto>[];
+export type GlobalSelectionAddItemResult<DataType> = {
+    fetchResult: DataType;
     actionResult: GlobalSelectionActionResult;
 };
 export declare namespace GlobalSelectionTypes {
-    type WorkOrderId = Pick<OptimizedWorkOrderDto, 'workOrderId'>;
+    type WorkOrderId = Pick<GlobalSelectionWorkOrderDto, 'workOrderId'>;
     type EquipmentId = Pick<Equipment, 'equipmentId'>;
     type TagId = Pick<TagSummaryDto, 'tagNo' | 'instCode'>;
     type ItemId = WorkOrderId | EquipmentId | TagId;
+    type ItemIdString = Brand<string, 'ItemIdString'>;
+    type TagDto = GlobalSelectionTagDto;
+    type WorkOrderDto = GlobalSelectionWorkOrderDto;
     type EquipmentItem = GlobalSelectionGenericItem<GlobalSelectionItemType.Equipment>;
     type WorkOrderItem = GlobalSelectionGenericItem<GlobalSelectionItemType.WorkOrder>;
     type TagItem = GlobalSelectionGenericItem<GlobalSelectionItemType.Tag>;
@@ -88,37 +99,8 @@ export declare namespace GlobalSelectionTypes {
     type EquipmentList = EquipmentGlobalSelectionList;
     type ListUnion = GlobalSelectionListUnion;
     type ItemTypeToDataMap = GlobalSelectionItemTypeToDataMap;
-    type AddTagResult = AddTagActionResult;
-}
-export interface OptimizedWorkOrderDto {
-    workOrderId: string;
-    tagId: string | undefined;
-    tagPlantId: string;
-    workCenterId?: string;
-    workCenterPlantId: string;
-    plannerGroupId: string;
-    workOrderTypeId: string;
-    revisionCodeId: string;
-    systemId?: string;
-    isOpen: boolean;
-    hasStatusTECO: boolean;
-    hasStatusRDOP: boolean;
-    hasStatusCANC: boolean;
-    hasStatusSTRT: boolean;
-    hasStatusRDEX: boolean;
-    hasStatusPREP: boolean;
-    hasStatusPRCO: boolean;
-    title: string;
-    plantId: string;
-    planningPlantId: string;
-    sortField: string;
-    locationId: string;
-    revisionId: string;
-    basicStartDateTime?: string | null;
-    basicEndDateTime?: string | null;
-    createdDateTime?: string | null;
-    _links: {
-        related: string;
-    };
+    type AddTagResult = GlobalSelectionAddItemResult<ResultArray<TagSummaryDto>[]>;
+    type ActionResult = GlobalSelectionActionResult;
+    type ItemSystemStatus = SelectionItemSystemStatus;
 }
 export {};

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

@@ -1,6 +1,4 @@
 import { GlobalSelectionItemType, GlobalSelectionTypes } from './globalSelectionStore.types';
-export declare function toGlobalSelectionItem<T extends GlobalSelectionTypes.ItemTypeToDataMap[K], K extends GlobalSelectionItemType>(item: T, type: K): GlobalSelectionTypes.GenericItem<K>;
-export declare function toGlobalSelectionItems<T extends GlobalSelectionTypes.ItemTypeToDataMap[K], K extends GlobalSelectionItemType>(items: T[], type: K): GlobalSelectionTypes.GenericItem<K>[];
 declare function idsEqual(itemA: GlobalSelectionTypes.ItemId, itemB: GlobalSelectionTypes.ItemId): boolean;
 declare function isWorkOrderId(itemId: GlobalSelectionTypes.ItemId): itemId is GlobalSelectionTypes.WorkOrderId;
 declare function isEquipmentId(itemId: GlobalSelectionTypes.ItemId): itemId is GlobalSelectionTypes.EquipmentId;
@@ -31,7 +29,8 @@ declare function mapToId(item: GlobalSelectionTypes.WorkOrderId): GlobalSelectio
 declare function mapToId(item: GlobalSelectionTypes.EquipmentId): GlobalSelectionTypes.EquipmentId;
 declare function mapToId(item: GlobalSelectionTypes.TagId): GlobalSelectionTypes.TagId;
 declare function mapToId(item: GlobalSelectionTypes.ItemId): GlobalSelectionTypes.ItemId;
-declare function itemIdToString(itemId: GlobalSelectionTypes.ItemId): string;
+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.
  *
@@ -49,6 +48,7 @@ export declare const globalSelectionUtils: Readonly<{
     isTagId: typeof isTagId;
     idsEqual: typeof idsEqual;
     mapToId: typeof mapToId;
+    mapIdToItemType: typeof mapIdToItemType;
     itemIdToString: typeof itemIdToString;
 }>;
 export {};

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

@@ -1,4 +1,5 @@
 import { PlantAndTagForOpenIn3d } from '../../openItemsIn3d/logic/openItemsIn3d.utils';
+import { GlobalSelectionItemType, GlobalSelectionTypes, SelectionItemSystemStatus } from './globalSelectionStore.types';
 /**
  * Converts global selection items to plant tag pairs.
  *
@@ -12,3 +13,15 @@ import { PlantAndTagForOpenIn3d } from '../../openItemsIn3d/logic/openItemsIn3d.
  * @returns {Promise<PlantAndTagForOpenIn3d[]>} A promise that resolves to an array of plant tag pairs.
  */
 export declare function convertGlobalSelectionItemsToPlantTagPairs(): Promise<PlantAndTagForOpenIn3d[]>;
+export declare function toGlobalSelectionItem<T extends GlobalSelectionTypes.ItemTypeToDataMap[K], K extends GlobalSelectionItemType>(item: T, type: K, systemStatus: SelectionItemSystemStatus): GlobalSelectionTypes.GenericItem<K>;
+export declare function toGlobalSelectionItems<T extends GlobalSelectionTypes.ItemTypeToDataMap[K], K extends GlobalSelectionItemType>(items: T[], type: K, systemStatus: SelectionItemSystemStatus): GlobalSelectionTypes.GenericItem<K>[];
+export declare function finalizeLoadStateByItemType<T extends GlobalSelectionItemType>(args: {
+    itemType: GlobalSelectionItemType;
+    state: GlobalSelectionTypes.Store;
+    itemDataToStore: GlobalSelectionTypes.ItemTypeToDataMap[T][];
+}): void;
+export declare function setNotFoundStatusByItemIds(args: {
+    itemType: GlobalSelectionItemType;
+    state: GlobalSelectionTypes.Store;
+    notFoundItemIds: GlobalSelectionTypes.ItemId[];
+}): void;

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

@@ -0,0 +1,2 @@
+import { GlobalSelectionItemType, GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
+export declare function useGlobalSelectionByItemId<T extends GlobalSelectionItemType>(itemType: T, itemId: GlobalSelectionTypes.ItemId): GlobalSelectionTypes.GenericItem<T> | undefined;

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

@@ -0,0 +1,7 @@
+import { GlobalSelectionItemType, GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
+/**
+ *
+ * @param {GlobalSelectionItemType} itemType
+ * @returns Array of given item types stored in global selection.
+ */
+export declare function useGlobalSelectionItemsByType<T extends GlobalSelectionItemType>(itemType: T): GlobalSelectionTypes.GenericItem<T>[];

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

@@ -1,19 +1,8 @@
 /**
  * Hook for returning all lists stored in the global selection.
  */
-export declare function useGlobalSelectionLists(): ({
+export declare function useGlobalSelectionLists(): {
     label: string;
-    type: import("..").GlobalSelectionItemType.WorkOrder;
-    items: import("..").GlobalSelectionTypes.GenericItem<import("..").GlobalSelectionItemType.WorkOrder>[];
-    itemsBeingLoaded: import("..").GlobalSelectionTypes.ItemId[];
-} | {
-    label: string;
-    type: import("..").GlobalSelectionItemType.Tag;
-    items: import("..").GlobalSelectionTypes.GenericItem<import("..").GlobalSelectionItemType.Tag>[];
-    itemsBeingLoaded: import("..").GlobalSelectionTypes.ItemId[];
-} | {
-    label: string;
-    type: import("..").GlobalSelectionItemType.Equipment;
-    items: import("..").GlobalSelectionTypes.GenericItem<import("..").GlobalSelectionItemType.Equipment>[];
-    itemsBeingLoaded: import("..").GlobalSelectionTypes.ItemId[];
-})[];
+    type: import("..").GlobalSelectionItemType;
+    items: (import("..").GlobalSelectionTypes.GenericItem<import("..").GlobalSelectionItemType.WorkOrder> | import("..").GlobalSelectionTypes.GenericItem<import("..").GlobalSelectionItemType.Tag> | import("..").GlobalSelectionTypes.GenericItem<import("..").GlobalSelectionItemType.Equipment>)[];
+}[];

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

@@ -1,13 +1,15 @@
+export { RemoveSelectionItemsConfirmDialog } from './components/RemoveSelectionItemsConfirmDialog';
 export { globalSelectionApi } from './globalSelection.api';
 export * from './globalSelectionStore/globalSelectionStore.types';
 export { globalSelectionUtils } from './globalSelectionStore/globalSelectionStore.utils';
 export { convertGlobalSelectionItemsToPlantTagPairs } from './globalSelectionStore/globalSelectionStoreHelpers';
+export { useGlobalSelectionByItemId } from './hooks/useGlobalSelectionByItemId';
 export { useGlobalSelectionItems } from './hooks/useGlobalSelectionItems';
+export { useGlobalSelectionItemsByType } from './hooks/useGlobalSelectionItemsByType';
 export { useGlobalSelectionLists } from './hooks/useGlobalSelectionLists';
 export { useGlobalSelectionTags } from './hooks/useGlobalSelectionTags';
 export { useGlobalSelectionWorkOrders } from './hooks/useGlobalSelectionWorkOrders';
 export { useSelectionCategoriesByGroupId } from './hooks/useSelectionCategoriesByGroupId';
 export { OpenGlobalSelectionIn3DButton } from './OpenGlobalSelectionIn3DButton';
 export { useSelectionMenuGroups } from './selectionMenu/hooks/useSelectionMenuGroups';
-export { RemoveSelectionItemsConfirmDialog } from './components/RemoveSelectionItemsConfirmDialog';
 export * from './selectionMenu/selectionTreeStore/selectionTree.store.types';

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

@@ -1,5 +1,5 @@
 import { Guid } from '@equinor/echo-utils';
-interface useIsAllIGlobalSelectionItemsHiddenArgs {
+interface UseIsAllIGlobalSelectionItemsHiddenArgs {
     groupId: Guid;
     categoryId?: string;
 }
@@ -15,5 +15,5 @@ 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 declare const useIsAllIGlobalSelectionItemsHidden: (args: UseIsAllIGlobalSelectionItemsHiddenArgs) => boolean;
 export {};

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

@@ -0,0 +1,13 @@
+import { ResultArray, TagSummaryDto } from '@equinor/echo-search';
+import { StoreApi } from 'zustand';
+import { GlobalSelectionTypes } 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) => void;
+export declare function addTagsAction(set: SetFunction, get: StoreApi<SelectionTreeStore>['getState'], args: AddItemArgs<GlobalSelectionTypes.TagId> & {
+    getActionResult: true;
+}): Promise<AddItemsResponse<ResultArray<TagSummaryDto>[]>>;
+export declare function addTagsAction(set: SetFunction, get: StoreApi<SelectionTreeStore>['getState'], args: AddItemArgs<GlobalSelectionTypes.TagId> & {
+    getActionResult?: false;
+}): Promise<ResultArray<TagSummaryDto>[]>;
+export {};

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

@@ -0,0 +1,6 @@
+import { WorkOrderData } from '@equinor/echo-search';
+import { GlobalSelectionTypes } 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<GlobalSelectionTypes.WorkOrderId>) => Promise<import("./selectionTree.action.types").AddItemsResponse<import("@equinor/echo-search").ResultArray<unknown>[]> | {
+    fetchResults: import("@equinor/echo-search").ResultArray<WorkOrderData>[][];
+    actionResult: string;
+}>;

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

@@ -0,0 +1,16 @@
+import { ResultArray } from '@equinor/echo-search';
+import { StoreApi } from 'zustand';
+import { GlobalSelectionAddItemResult, GlobalSelectionItemType, GlobalSelectionTypes } from '../../../globalSelectionStore/globalSelectionStore.types';
+import { GlobalSelectionCategoryId, SelectionTreeStore } from '../selectionTree.store.types';
+import { AddItemArgs, AddItemsResponse } from './selectionTree.action.types';
+type SetFunction = (set: (state: SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void;
+export declare function addItemsActionFactory<G_ItemId extends GlobalSelectionTypes.ItemId, G_ResponseData>(args: {
+    addItemToGlobalSelection: (uniqueNewItems: G_ItemId[]) => Promise<GlobalSelectionAddItemResult<ResultArray<G_ResponseData>[]>>;
+    itemType: GlobalSelectionItemType;
+    itemCategory: GlobalSelectionCategoryId;
+    categoryOrderIndex: number;
+}): (set: SetFunction, get: StoreApi<SelectionTreeStore>["getState"], args: AddItemArgs<G_ItemId>) => Promise<AddItemsResponse<ResultArray<unknown>[]> | {
+    fetchResults: ResultArray<G_ResponseData>[][];
+    actionResult: string;
+}>;
+export {};

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

@@ -1,7 +1,6 @@
-import { WritableDraft } from 'immer';
 import { GlobalSelectionTypes } from '../../../globalSelectionStore/globalSelectionStore.types';
 import { SelectionTreeStore } from '../selectionTree.store.types';
-type SetFunction = (set: (state: WritableDraft<SelectionTreeStore>) => void, shouldReplace?: boolean | undefined, action?: string) => void;
+type SetFunction = (set: (state: SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void;
 /**
  * Removes all items by their IDs, from all groups, from the state.
  *

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/{addTag.action.types.d.ts → selectionTree.action.types.d.ts}

@@ -1,18 +1,16 @@
-import { ResultArray, TagSummaryDto } from '@equinor/echo-search';
 import { GlobalSelectionTypes } from '../../../globalSelectionStore/globalSelectionStore.types';
-export type AddTagsArgs = {
-    itemIds: Readonly<GlobalSelectionTypes.TagId[]>;
-    replaceItems?: boolean;
-    getActionResult?: boolean;
-} & ({
-    label: string;
-    subLabel: string;
-} | {
+import { SelectionBase } from '../selectionTree.store.types';
+export type AddByLabel = SelectionBase | {
     label?: undefined;
     subLabel?: undefined;
-});
-export type AddTagsResponse = {
-    fetchResults: ResultArray<TagSummaryDto>[];
+};
+export type AddItemArgs<ItemIdType extends GlobalSelectionTypes.ItemId> = {
+    itemIds: Readonly<ItemIdType[]>;
+    replaceItems?: boolean;
+    getActionResult?: boolean;
+} & AddByLabel;
+export type AddItemsResponse<FetchResponseType> = {
+    fetchResults: FetchResponseType;
     actionResult: SelectionTreeActionResult;
 };
 export type SelectionTreeActionResult = 'ItemsUpdated' | 'ItemsAdded' | 'NewGroupCreated' | 'NoChanges';

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

@@ -1,5 +1,5 @@
 import { SelectionTreeStore } from './selectionTree.store.types';
-export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<SelectionTreeStore>, "setState"> & {
+export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit<Omit<Omit<Omit<import("zustand").StoreApi<SelectionTreeStore>, "setState"> & {
     setState<A extends string | {
         type: string;
     }>(partial: SelectionTreeStore | Partial<SelectionTreeStore> | ((state: SelectionTreeStore) => SelectionTreeStore | Partial<SelectionTreeStore>), replace?: boolean | undefined, action?: A | undefined): void;
@@ -11,6 +11,16 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
             fireImmediately?: boolean;
         } | undefined): () => void;
     };
+}, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SelectionTreeStore, SelectionTreeStore>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: SelectionTreeStore) => void) => () => void;
+        onFinishHydration: (fn: (state: SelectionTreeStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SelectionTreeStore, SelectionTreeStore>>;
+    };
 }, "setState"> & {
     setState(nextStateOrUpdater: SelectionTreeStore | Partial<SelectionTreeStore> | ((state: import("immer").WritableDraft<SelectionTreeStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;

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

@@ -0,0 +1,8 @@
+import { PersistOptions } from 'zustand/middleware';
+import { SelectionTreeStore } from './selectionTree.store.types';
+declare function loadAndPopulateStore(store: SelectionTreeStore): Promise<void>;
+export declare const selectionTreeRepository: {
+    loadAndPopulateStore: typeof loadAndPopulateStore;
+    persistOptions: PersistOptions<SelectionTreeStore, SelectionTreeStore>;
+};
+export {};