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

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "0.21.4-beta-0",
+  "version": "0.21.4",
   "peerDependencies": {
     "@equinor/echo-base": ">= 0.7.0 < 0.8.0",
     "@equinor/echo-components": ">= 0.12.0 < 0.13.0",
-    "@equinor/echo-core": "0.9.18-beta-0",
+    "@equinor/echo-core": ">= 0.9.0 < 0.10.0",
     "@equinor/echo-search": ">= 0.15.0 < 0.16.0",
     "@equinor/echo-utils": ">= 0.4.0 < 0.5.0",
     "@equinor/eds-core-react": "0.43.0",

package/src/index.d.ts

@@ -12,11 +12,14 @@ 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';

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<{
@@ -67,7 +67,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,31 +86,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)[];
+            groupId?: import("dist/libs/echo-utils/src").Guid;
+            itemIds: GlobalSelectionTypes.ItemId[];
         }) => void;
     }>;
     search: {

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

@@ -0,0 +1,19 @@
+import { ResultArray } from '@equinor/echo-search';
+import { WritableDraft } from 'immer';
+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: WritableDraft<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,5 +1,5 @@
 import { WritableDraft } from 'immer';
-import { GlobalSelectionItemType, GlobalSelectionTypes } from './globalSelectionStore.types';
+import { GlobalSelectionStore, 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>;
@@ -21,29 +21,23 @@ 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<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;
     };
 }, "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: 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.types.d.ts

@@ -1,13 +1,18 @@
-import { ResultArray, TagSummaryDto } from '@equinor/echo-search';
+import { ResultArray, TagSummaryDto, WorkOrderData } from '@equinor/echo-search';
 import { Equipment } from '../../equipment';
 export declare enum GlobalSelectionItemType {
     WorkOrder = "WorkOrder",
     Tag = "Tag",
     Equipment = "Equipment"
 }
-interface GlobalSelectionItemTypeToDataMap {
-    WorkOrder: OptimizedWorkOrderDto;
-    Tag: TagSummaryDto;
+export type DeepWritable<T> = {
+    -readonly [P in keyof T]: DeepWritable<T[P]>;
+};
+type GlobalSelectionTagDto = TagSummaryDto;
+type GlobalSelectionWorkOrderDto = WorkOrderData;
+export interface GlobalSelectionItemTypeToDataMap {
+    WorkOrder: GlobalSelectionWorkOrderDto;
+    Tag: GlobalSelectionTagDto;
     Equipment: Equipment;
 }
 type GlobalSelectionList<T extends GlobalSelectionItemType> = {
@@ -19,10 +24,8 @@ type GlobalSelectionList<T extends GlobalSelectionItemType> = {
 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 type SelectionItemSystemStatus = 'isLoading' | 'notFound' | 'loadedSuccessfully';
+type GlobalSelectionGenericItem<T extends GlobalSelectionItemType> = {
     id: GlobalSelectionTypes.ItemId;
     type: T;
     data: GlobalSelectionTypes.ItemTypeToDataMap[T];
@@ -30,6 +33,7 @@ export type GlobalSelectionGenericItem<T extends GlobalSelectionItemType> = {
         color: string;
         isHiddenByUser: boolean;
         errorStatus?: string;
+        systemStatus: SelectionItemSystemStatus;
     };
 };
 type EquipmentGlobalSelectionList = GlobalSelectionTypes.List<GlobalSelectionItemType.Equipment>;
@@ -43,11 +47,11 @@ interface ItemErrorStatusUpdates {
 export interface GlobalSelectionStore {
     lists: GlobalSelectionObject;
     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;
@@ -65,15 +69,17 @@ 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 TagDto = GlobalSelectionTagDto;
+    type WorkOrderDto = GlobalSelectionWorkOrderDto;
     type EquipmentItem = GlobalSelectionGenericItem<GlobalSelectionItemType.Equipment>;
     type WorkOrderItem = GlobalSelectionGenericItem<GlobalSelectionItemType.WorkOrder>;
     type TagItem = GlobalSelectionGenericItem<GlobalSelectionItemType.Tag>;
@@ -88,37 +94,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;
@@ -32,6 +30,7 @@ declare function mapToId(item: GlobalSelectionTypes.EquipmentId): GlobalSelectio
 declare function mapToId(item: GlobalSelectionTypes.TagId): GlobalSelectionTypes.TagId;
 declare function mapToId(item: GlobalSelectionTypes.ItemId): GlobalSelectionTypes.ItemId;
 declare function itemIdToString(itemId: GlobalSelectionTypes.ItemId): string;
+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,6 @@
+import { WritableDraft } from 'immer';
 import { PlantAndTagForOpenIn3d } from '../../openItemsIn3d/logic/openItemsIn3d.utils';
+import { DeepWritable, GlobalSelectionItemType, GlobalSelectionTypes, SelectionItemSystemStatus } from './globalSelectionStore.types';
 /**
  * Converts global selection items to plant tag pairs.
  *
@@ -12,3 +14,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: WritableDraft<GlobalSelectionTypes.Store>;
+    itemDataToStore: DeepWritable<GlobalSelectionTypes.ItemTypeToDataMap[T]>[];
+}): void;
+export declare function setNotFoundStatusByItemIds(args: {
+    itemType: GlobalSelectionItemType;
+    state: WritableDraft<GlobalSelectionTypes.Store>;
+    notFoundItemIds: GlobalSelectionTypes.ItemId[];
+}): void;

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/index.d.ts

@@ -1,13 +1,14 @@
+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 { 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/selectionTreeStore/actions/{addTag.action.d.ts → addTags.action.d.ts}

@@ -1,13 +1,14 @@
 import { ResultArray, TagSummaryDto } from '@equinor/echo-search';
 import { WritableDraft } from 'immer';
 import { StoreApi } from 'zustand';
+import { GlobalSelectionTypes } from '../../../globalSelectionStore/globalSelectionStore.types';
 import { SelectionTreeStore } from '../selectionTree.store.types';
-import { AddTagsArgs, AddTagsResponse } from './addTag.action.types';
+import { AddItemArgs, AddItemsResponse } from './selectionTree.action.types';
 type SetFunction = (set: (state: WritableDraft<SelectionTreeStore>) => void, shouldReplace?: boolean | undefined, action?: string) => void;
-export declare function addTagsAction(set: SetFunction, get: StoreApi<SelectionTreeStore>['getState'], args: AddTagsArgs & {
+export declare function addTagsAction(set: SetFunction, get: StoreApi<SelectionTreeStore>['getState'], args: AddItemArgs<GlobalSelectionTypes.TagId> & {
     getActionResult: true;
-}): Promise<AddTagsResponse>;
-export declare function addTagsAction(set: SetFunction, get: StoreApi<SelectionTreeStore>['getState'], args: AddTagsArgs & {
+}): 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("immer").WritableDraft<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,17 @@
+import { ResultArray } from '@equinor/echo-search';
+import { WritableDraft } from 'immer';
+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: WritableDraft<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/{addTag.action.types.d.ts → selectionTree.action.types.d.ts}

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

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

@@ -1,8 +1,12 @@
 import { ResultArray, TagSummaryDto } from '@equinor/echo-search';
 import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionItemType, GlobalSelectionTypes, OptimizedWorkOrderDto } from '../../globalSelectionStore/globalSelectionStore.types';
-import { AddTagsArgs, AddTagsResponse, SelectionTreeActionResult } from './actions/addTag.action.types';
-type SelectionItem = SelectionMenuTag | SelectionMenuWorkOrder | SelectionMenuEquipment;
+import { GlobalSelectionItemType, GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
+import { AddItemArgs, AddItemsResponse, SelectionTreeActionResult } from './actions/selectionTree.action.types';
+export type SelectionItemTypeToItemIdMap = {
+    [GlobalSelectionItemType.Tag]: GlobalSelectionTypes.TagId;
+    [GlobalSelectionItemType.WorkOrder]: GlobalSelectionTypes.WorkOrderId;
+    [GlobalSelectionItemType.Equipment]: GlobalSelectionTypes.EquipmentId;
+};
 export declare enum GlobalSelectionCategoryId {
     Tags = "DEFAULT_TAG_LIST_ID",
     WorkOrders = "DEFAULT_WORK_ORDER_LIST_ID"
@@ -13,25 +17,17 @@ export declare enum SelectionMenuDefaultListIds {
     TagList = "DEFAULT_TAG_LIST_ID",
     WorkOrderList = "DEFAULT_WORK_ORDER_LIST_ID"
 }
-export interface SelectionMenuTag {
-    id: GlobalSelectionTypes.TagId;
-    type: GlobalSelectionItemType.Tag;
-}
-export interface SelectionMenuWorkOrder {
-    id: GlobalSelectionTypes.WorkOrderId;
-    type: GlobalSelectionItemType.WorkOrder;
-}
-export interface SelectionMenuEquipment {
-    id: GlobalSelectionTypes.EquipmentId;
-    type: GlobalSelectionItemType.Equipment;
-}
+type SelectionItem<T extends GlobalSelectionItemType> = {
+    id: SelectionItemTypeToItemIdMap[T];
+    type: T;
+};
 interface SelectionBase {
     label: string;
     subLabel?: string;
 }
 export interface SelectionCategory extends SelectionBase {
     id: GlobalSelectionCategoryId;
-    items: SelectionItem[];
+    items: SelectionItem<GlobalSelectionItemType>[];
 }
 export interface SelectionGroup extends SelectionBase {
     id: Guid;
@@ -39,16 +35,13 @@ export interface SelectionGroup extends SelectionBase {
 }
 export interface SelectionTreeStore {
     groups: SelectionGroup[];
-    addTags: <T extends boolean | undefined = undefined>(args: AddTagsArgs & {
+    addTags: <T extends boolean | undefined = undefined>(args: AddItemArgs<GlobalSelectionTypes.TagId> & {
         getActionResult?: T;
     }) => Promise<AddTagsReturnType<T>>;
-    addWorkOrders: (args: {
-        groupId?: Guid;
-        items: Readonly<Readonly<OptimizedWorkOrderDto>[]>;
-    }) => void;
+    addWorkOrders: (args: AddItemArgs<GlobalSelectionTypes.WorkOrderId>) => void;
     addItems: (args: {
         groupId?: Guid;
-        itemIds: (GlobalSelectionTypes.TagId | OptimizedWorkOrderDto)[];
+        itemIds: GlobalSelectionTypes.ItemId[];
     }) => void;
     createGroup: (args: {
         label: string;
@@ -79,8 +72,7 @@ export interface SelectionTreeStore {
 export declare namespace SelectionTreeTypes {
     type Category = SelectionCategory;
     type Group = SelectionGroup;
-    type Item = SelectionItem;
     type ActionResult = SelectionTreeActionResult;
 }
-export type AddTagsReturnType<T extends boolean | undefined = undefined> = T extends true ? AddTagsResponse : ResultArray<TagSummaryDto>[];
+export type AddTagsReturnType<T extends boolean | undefined = undefined> = T extends true ? AddItemsResponse<ResultArray<TagSummaryDto>[]> : ResultArray<TagSummaryDto>[];
 export {};

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

@@ -1,7 +1,7 @@
 import { Guid } from '@equinor/echo-utils';
+import { WritableDraft } from 'immer';
 import { GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
 import { GlobalSelectionCategoryId, SelectionTreeTypes } from './selectionTree.store.types';
-import { WritableDraft } from 'immer';
 /**
  * Check if an item ID is present in the selection tree.
  *
@@ -72,8 +72,8 @@ export declare function getGroupIdsByItemIds(args: {
     label: string;
     subLabel?: string;
 }[];
-export declare function areItemsTheSameInGroup(args: {
-    itemIds: GlobalSelectionTypes.TagId[];
+export declare function areItemsTheSameInGroup<ItemType extends GlobalSelectionTypes.ItemId>(args: {
+    itemIds: ItemType[];
     groups: SelectionTreeTypes.Group[];
     groupId: Guid;
     categoryId: GlobalSelectionCategoryId;

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

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

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

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+/**
+ * This will render all legends in lower left, with customLegendComponent if available, otherwise BasicLegendRenderer.
+ */
+export declare const LegendList: FC;

package/src/lib/feature/legend/components/basicLegendRenderer.logic.d.ts

@@ -0,0 +1,5 @@
+import { LegendChipProps } from '@equinor/echo-components';
+import { Badge, Marker } from '../types/legendMarkerBadge.type';
+import { LegendState } from '../types/legendType';
+export declare const getMarkerChips: (markers: ReadonlyArray<Marker>, legend: LegendState) => LegendChipProps[];
+export declare const getBadgeChips: (badges: ReadonlyArray<Badge>, legend: LegendState) => LegendChipProps[];

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

@@ -0,0 +1,14 @@
+import React from 'react';
+interface PositionalItemProps {
+    /**
+     * This is the CSS position string, that will be used in --transform: var(--position);
+     */
+    position: string;
+    isOpen: boolean;
+    children: React.ReactNode;
+}
+/**
+ * An item that can be positioned anywhere in the absolute container.
+ */
+export declare const PositionalItem: React.FC<PositionalItemProps>;
+export {};

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

@@ -0,0 +1,24 @@
+import { Point } from '@equinor/echo-utils';
+import React from 'react';
+import { LegendDataId } from '../../types/legendType';
+interface LegendPositionItem {
+    itemId: LegendDataId;
+    position: Point;
+    hasPointer: boolean;
+}
+interface PositionalLegendMarkersProps {
+    items: ReadonlyArray<LegendPositionItem>;
+    pdfRotation: number;
+    currentPageScale: number;
+    pdfZoom: number;
+}
+/**
+ * Component that renders positional legend markers on a PDF or on other view.
+ *
+ * @param {ReadonlyArray<LegendPositionItem>} items - Array of position items.
+ * @param {number} pdfRotation - The rotation angle of the PDF.
+ * @param {number} currentPageScale - The current scale of the PDF page.
+ * @param {number} pdfZoom - The zoom level of the PDF.
+ */
+export declare const PositionalLegendMarkers: React.FC<PositionalLegendMarkersProps>;
+export {};

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import { LegendDataId, LegendId } from '../../../types/legendType';
+interface LegendColoredMarkerIconProps {
+    legendId: LegendId;
+    itemId: LegendDataId;
+    hasPointer: boolean;
+    isActive: boolean;
+    onClick: () => void;
+}
+export declare const MemoizedLegendColoredMarkerIcon: React.NamedExoticComponent<LegendColoredMarkerIconProps>;
+export {};