@equinor/echo-framework 1.1.0 → 1.2.0

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "peerDependencies": {
-    "@equinor/echo-base": ">= 1.0.0 < 2.0.0",
-    "@equinor/echo-components": ">= 1.0.0 < 2.0.0",
-    "@equinor/echo-core": ">= 1.0.0 < 2.0.0",
-    "@equinor/echo-search": ">= 1.0.0 < 2.0.0",
-    "@equinor/echo-utils": ">= 1.1.0 < 2.0.0",
+    "@equinor/echo-base": ">= 1.2.0 < 2.0.0",
+    "@equinor/echo-components": ">= 1.2.0 < 2.0.0",
+    "@equinor/echo-core": ">= 1.2.0 < 2.0.0",
+    "@equinor/echo-search": ">= 1.2.0 < 2.0.0",
+    "@equinor/echo-utils": ">= 1.2.0 < 2.0.0",
     "@equinor/eds-core-react": "0.43.0",
     "@equinor/eds-icons": "0.22.0",
     "react": ">= 17.0.2",

package/src/index.d.ts

@@ -18,10 +18,10 @@ export * from './lib/feature/equipment/index';
 export * from './lib/feature/globalSelection';
 export { SelectionActionBar } from './lib/feature/globalSelection/components/SelectionActionBar';
 export { PanTo3DButton } from './lib/feature/globalSelection/panToEcho3d/panTo3DButton';
-export { useGlobalSelectionColorsSortedByFrequency } from './lib/feature/globalSelection/selectionMenu/hooks/useGlobalSelectionColorsSortedByFrequency';
 export { useIsAllIGlobalSelectionItemsHidden } from './lib/feature/globalSelection/selectionMenu/hooks/useIsAllIGlobalSelectionItemsHidden';
+export { useSelectionColorFrequencyByIds } from './lib/feature/globalSelection/selectionMenu/hooks/useSelectionColorFrequency';
+export { useSelectionTreeAutoSave } from './lib/feature/globalSelection/selectionMenu/selectionTreeStore/persist/useSelectionTreeAutoSave';
 export { GlobalSelectionCategoryId } from './lib/feature/globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.types';
-export { useSelectionTreeAutoSave } from './lib/feature/globalSelection/selectionMenu/selectionTreeStore/useSelectionTreeAutoSave';
 export * from './lib/feature/legacyLegend/index';
 export { PositionalLegendMarkers } from './lib/feature/legend/components/pdfMarkers/PositionalLegendMarkers';
 export { PopoverLoading } from './lib/feature/legend/components/pdfMarkers/subComponents/components/PopoverLoading';

package/src/lib/components/fullScreenButtons/index.d.ts

@@ -1,3 +1 @@
-export * from './FullScreenChip';
 export * from './FullScreenModeButton';
-export * from './FullScreenModeChip';

package/src/lib/components/panel/useCalculateLegendHeight.d.ts

@@ -0,0 +1 @@
+export declare const useCalculateLegendHeight: () => number;

package/src/lib/components/prepview/panels/tagInformation/TagInformation.d.ts

@@ -6,5 +6,5 @@ interface Props {
  * TagInformationPanel
  * this panel requires the user to have maintenance access to show data.
  */
-declare function TagInformationPanel({ itemId, isWorkOrder }: Props): import("react/jsx-runtime").JSX.Element;
+declare function TagInformationPanel({ itemId, isWorkOrder }: Readonly<Props>): import("react/jsx-runtime").JSX.Element;
 export { TagInformationPanel };

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

@@ -1,10 +1,6 @@
 import { Panel } from '@equinor/echo-core';
-/** Used in echo-client for creating a host application for echo modules in dev mode **/
+/** These are not used in echopedia! Only used in echo-dev-host for creating a host application for echo modules in dev mode **/
 /**
  * Core Main menu panel registered at client startup
  */
 export declare const mainMenu: Panel;
-/**
- * Core Application search panel registered at client startup
- */
-export declare const searchPanel: Panel;

package/src/lib/feature/equipment/components/equipmentItemHeader/showEquipmentIn3dButton.d.ts

@@ -1,6 +1,6 @@
 import { EquipmentData } from '@equinor/echo-search';
 interface ShowEquipmentIn3DButtonArgs {
-    equipmentProps: Pick<EquipmentData, 'equipmentId' | 'e3DRef' | 'tagId'>;
+    equipmentProps: Pick<EquipmentData, 'equipmentId' | 'e3DRef' | 'tagId' | 'tagPlantId'>;
 }
 export declare const ShowEquipmentIn3DButton: ({ equipmentProps }: ShowEquipmentIn3DButtonArgs) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -111,7 +111,7 @@ export declare const globalSelectionApi: Readonly<{
         addItems: (args: {
             itemIds: GlobalSelectionTypes.ItemId[];
             groupId?: import("@equinor/echo-utils").Guid;
-        } & import("./selectionMenu/selectionTreeStore/actions/selectionTree.action.types").AddByGroupIdAndLabel) => Promise<void>;
+        }) => Promise<void>;
     }>;
     search: {
         /**
@@ -128,9 +128,35 @@ export declare const globalSelectionApi: Readonly<{
             label: string;
         }) => import("@equinor/echo-utils").Guid | undefined;
     };
+    /**
+     * Moves items, categories, or groups within the selection tree structure.
+     *
+     * Depending on the provided arguments, this function will:
+     * - Move a single item from one category/group to another.
+     * - Move an entire category from one group to another, optionally removing the source group if empty.
+     * - Move an entire group to another location, removing the original group.
+     *
+     * @param set - The state setter function used to update the selection tree.
+     * @param args - The arguments specifying the source and target locations for the move operation.
+     *   - `sourceGroupId`: The ID of the group from which the item/category/group is moved.
+     *   - `sourceCategoryId`: (Optional) The ID of the category from which the item is moved.
+     *   - `sourceItemId`: (Optional) The ID of the item to move.
+     *   - `targetGroupId`: The ID of the group to which the item/category/group is moved.
+     *
+     * @remarks
+     * - If `sourceItemId` is provided, `sourceCategoryId` must also be provided.
+     * - After moving a single item, the source group is not removed.
+     * - After moving a category or group, the source group may be removed if empty.
+     */
+    moveItems: (args: {
+        sourceGroupId: import("@equinor/echo-utils").Guid;
+        sourceCategoryId?: GlobalSelectionCategoryId;
+        sourceItemId?: GlobalSelectionTypes.ItemId;
+        targetGroupId: import("@equinor/echo-utils").Guid;
+    }) => void;
     visibility: Readonly<{
         setByItemIds: (args: {
-            itemIds: Readonly<Readonly<GlobalSelectionTypes.ItemId>>[];
+            itemIds: ReadonlyArray<Readonly<GlobalSelectionTypes.ItemId>>;
             isVisible: boolean;
         }) => void;
         /**
@@ -159,7 +185,7 @@ export declare const globalSelectionApi: Readonly<{
     }>;
     color: Readonly<{
         setByItemIds: (args: {
-            itemIds: Readonly<Readonly<GlobalSelectionTypes.ItemId>>[];
+            itemIds: ReadonlyArray<Readonly<GlobalSelectionTypes.ItemId>>;
             color: string;
         }) => void;
     }>;
@@ -224,7 +250,7 @@ export declare const globalSelectionApi: Readonly<{
         /**
          * Retrieves the unique IDs of all items stored in the selection menu panel.
          */
-        getAll: () => Readonly<GlobalSelectionTypes.ItemId[]>;
+        getAll: () => ReadonlyArray<GlobalSelectionTypes.ItemId>;
         getTagIds: typeof getStoreTagIds;
         getEquipmentIds: typeof getStoreEquipmentIds;
     };

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

@@ -1,5 +1,5 @@
 import { Guid } from '@equinor/echo-utils';
-import { deleteSelectionId, fetchUserSelectionIds } from './selectionMenu/selectionTreeStore/api/selectionTree.api';
+import { deleteSelectionId, fetchSelectionHistory, fetchUserSelectionIds } from './selectionMenu/selectionTreeStore/api/selectionTree.api';
 /**
  * Internal that should only be used by echopedia
  */
@@ -7,6 +7,7 @@ export declare const globalSelectionInternal: Readonly<{
     loadFromApi: typeof loadFromApi;
     deleteSelectionId: typeof deleteSelectionId;
     fetchUserSelectionIds: typeof fetchUserSelectionIds;
+    fetchSelectionHistory: typeof fetchSelectionHistory;
 }>;
-declare function loadFromApi(idToLoad: Guid): Promise<void>;
+declare function loadFromApi(idToLoad: Guid): Promise<boolean>;
 export {};

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

@@ -0,0 +1,57 @@
+import { GlobalSelectionItemType } from './globalSelectionStore/globalSelectionStore.types';
+type ColorServiceState = {
+    /**
+     * Maps a color to the set of keys assigned to it.
+     */
+    colorToKeysMap: Map<string, Set<string>>;
+    /**
+     * Maps a key to its assigned color.
+     */
+    keyToColorMap: Map<string, string>;
+    /**
+     * Assigns a new, unused color to the given keys and tracks them.
+     * @param keys Array of string keys to assign the color to.
+     * @returns The assigned color.
+     */
+    assignNextAvailableColor: (keys: string[]) => string;
+    /**
+     * Releases the color assignment for the given keys.
+     * If a color has no keys left, it is considered unused.
+     * @param keys Array of string keys to release.
+     */
+    releaseColorByKeys: (keys: string[]) => void;
+    /**
+     * Returns all colors currently in use.
+     */
+    getUsedColors: () => string[];
+    /**
+     * Returns all colors not currently in use.
+     */
+    getUnusedColors: () => string[];
+    /**
+     * Returns the color assigned to the given key, or undefined if not assigned.
+     * @param key The key to look up.
+     */
+    getColorByKey: (key: string) => string | undefined;
+    /**
+     * Clears all color assignments.
+     */
+    reset: () => void;
+};
+export declare const useColorServiceStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ColorServiceState>>;
+export declare const SELECTION_COLOR_PICKER_COLORS: Readonly<string>[];
+declare const UNIFIED_COLOR_POOL: string[];
+export { UNIFIED_COLOR_POOL };
+/**
+ * Should be only used in local selection context!
+ *
+ * Returns the color associated with a given `GlobalSelectionItemType`.
+ *
+ * This function maps specific item types to their corresponding selection colors,
+ * as defined in the `echoPrimitives.seletionColorsSelectioncolor*` constants.
+ * If the provided `itemType` does not match any known type, a default color (`#FF6F00`) is returned.
+ *
+ * @param itemType - The type of the global selection item for which to retrieve the color.
+ * @returns The color string associated with the specified item type.
+ */
+export declare function getLocalSelectionColorByItemType(itemType: GlobalSelectionItemType): string;

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

@@ -0,0 +1,3 @@
+import { Brand } from '@equinor/echo-utils';
+export declare const SELECTION_PLACEHOLDER_COLOR = "#B0B0B0";
+export type HexColor = Brand<string, 'ItemIdString'>;

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

@@ -1,5 +1,6 @@
 export declare const addEquipmentsToSelectionAction: (set: (set: (state: import("../globalSelectionStore.types").GlobalSelectionStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../globalSelectionStore.types").GlobalSelectionStore>["getState"], args: {
     itemIds: import("../globalSelectionStore.types").GlobalSelectionTypes.EquipmentId[];
+    color?: string;
 }) => Promise<{
     fetchResult: import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").EquipmentData>[];
     actionResult: import("../globalSelectionStore.types").GlobalSelectionTypes.ActionResult;

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

@@ -13,6 +13,7 @@ export declare function addItemsToSelectionFactory<T extends GlobalSelectionItem
     nullItemGenerator: NullItemGenerator<GlobalSelectionItemTypeToDataMap[T], SelectionItemTypeToItemIdMap[T]>;
 }): (set: SetFunction, get: StoreApi<GlobalSelectionStore>["getState"], args: {
     itemIds: SelectionItemTypeToItemIdMap[T][];
+    color?: string;
 }) => Promise<{
     fetchResult: ResultArray<GlobalSelectionItemTypeToDataMap[T]>[];
     actionResult: GlobalSelectionTypes.ActionResult;

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

@@ -1,5 +1,6 @@
 export declare const addMeasuringPointsToSelectionAction: (set: (set: (state: import("../globalSelectionStore.types").GlobalSelectionStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../globalSelectionStore.types").GlobalSelectionStore>["getState"], args: {
     itemIds: import("../globalSelectionStore.types").GlobalSelectionTypes.MeasuringPointId[];
+    color?: string;
 }) => Promise<{
     fetchResult: import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").MeasuringPointData>[];
     actionResult: import("../globalSelectionStore.types").GlobalSelectionTypes.ActionResult;

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

@@ -1,6 +1,7 @@
 import { GlobalSelectionTypes } from '../globalSelectionStore.types';
 export declare const addTagsToSelectionAction: (set: (set: (state: import("../globalSelectionStore.types").GlobalSelectionStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../globalSelectionStore.types").GlobalSelectionStore>["getState"], args: {
     itemIds: GlobalSelectionTypes.TagId[];
+    color?: string;
 }) => Promise<{
     fetchResult: import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").TagSummaryDto>[];
     actionResult: GlobalSelectionTypes.ActionResult;

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

@@ -1,5 +1,6 @@
 export declare const addWorkOrdersToSelectionAction: (set: (set: (state: import("../globalSelectionStore.types").GlobalSelectionStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../globalSelectionStore.types").GlobalSelectionStore>["getState"], args: {
     itemIds: import("../globalSelectionStore.types").GlobalSelectionTypes.WorkOrderId[];
+    color?: string;
 }) => Promise<{
     fetchResult: import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").WorkOrderData>[];
     actionResult: import("../globalSelectionStore.types").GlobalSelectionTypes.ActionResult;

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

@@ -1,7 +1,7 @@
 import { ApiSelectionGroup } from '../selectionMenu/selectionTreeStore/selectionTree.api.types';
 import { GlobalSelectionStore } from './globalSelectionStore.types';
-declare function loadAndPopulateStoreMetadataFromApi(store: GlobalSelectionStore, data: ApiSelectionGroup[]): Promise<void>;
+declare function setStoreItemMetadataFromApiData(store: GlobalSelectionStore, data: ApiSelectionGroup[]): void;
 export declare const globalSelectionRepository: {
-    loadAndPopulateStoreMetadataFromApi: typeof loadAndPopulateStoreMetadataFromApi;
+    setStoreItemMetadataFromApiData: typeof setStoreItemMetadataFromApiData;
 };
 export {};

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

@@ -23,8 +23,6 @@ export type SelectionItemTypeToItemIdMap = {
     [GlobalSelectionItemType.MeasuringPoint]: GlobalSelectionTypes.MeasuringPointId;
 };
 type GlobalSelectionList<T extends GlobalSelectionItemType> = {
-    label: string;
-    type: T;
     items: Map<GlobalSelectionTypes.ItemIdString, GlobalSelectionTypes.GenericItem<T>>;
 };
 export type GlobalSelectionObject = {
@@ -62,25 +60,29 @@ interface ItemErrorStatusUpdates {
 export interface GlobalSelectionStore extends GlobalSelectionStoreData {
     addWorkOrdersToSelection: (args: {
         workOrderIds: GlobalSelectionTypes.WorkOrderId[];
+        color?: string;
     }) => Promise<GlobalSelectionAddItemResult<ResultArray<WorkOrderData>[]>>;
     addTagsToSelection: (args: {
         tagIds: GlobalSelectionTypes.TagId[];
+        color?: string;
     }) => Promise<GlobalSelectionAddItemResult<ResultArray<TagSummaryDto>[]>>;
     addEquipmentsToSelection: (args: {
         equipmentIds: GlobalSelectionTypes.EquipmentId[];
+        color?: string;
     }) => Promise<GlobalSelectionAddItemResult<ResultArray<EquipmentData>[]>>;
     addMeasuringPointsToSelection: (args: {
         measuringPointIds: GlobalSelectionTypes.MeasuringPointId[];
+        color?: string;
     }) => Promise<GlobalSelectionAddItemResult<ResultArray<MeasuringPointData>[]>>;
     removeItemsFromSelection: (args: {
         itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
     }) => void;
     setColorByItemIds: (args: {
-        itemIds: Readonly<Readonly<GlobalSelectionTypes.ItemId>>[];
+        itemIds: ReadonlyArray<Readonly<GlobalSelectionTypes.ItemId>>;
         color: string;
     }) => void;
     setVisibilityByItemIds: (args: {
-        itemIds: Readonly<Readonly<GlobalSelectionTypes.ItemId>>[];
+        itemIds: ReadonlyArray<Readonly<GlobalSelectionTypes.ItemId>>;
         isVisible: boolean;
     }) => void;
     setAllItemsVisibility: (args: {
@@ -88,7 +90,7 @@ export interface GlobalSelectionStore extends GlobalSelectionStoreData {
     }) => void;
     setItemMetaData: (args: ReadonlyArray<GlobalSelectionItemIdMetadata>) => void;
     resetItemErrorStatuses: () => void;
-    getStoredItemIds: () => Readonly<GlobalSelectionTypes.ItemId[]>;
+    getStoredItemIds: () => ReadonlyArray<GlobalSelectionTypes.ItemId>;
     resetState: () => void;
     setErrorStatusForItems: (args: {
         itemErrorStatuses: GlobalSelectionTypes.ItemErrorStatusUpdate[];

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

@@ -1,4 +1,5 @@
-import { GlobalSelectionItemType, GlobalSelectionTypes } from './globalSelectionStore.types';
+import { ResultArray } from '@equinor/echo-search';
+import { GlobalSelectionItemType, GlobalSelectionItemTypeToDataMap, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from './globalSelectionStore.types';
 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;
@@ -34,7 +35,6 @@ declare function mapToId(item: GlobalSelectionTypes.MeasuringPointId): GlobalSel
 declare function mapToId(item: GlobalSelectionTypes.ItemId): GlobalSelectionTypes.ItemId;
 declare function itemIdToString(itemId: GlobalSelectionTypes.ItemId): GlobalSelectionTypes.ItemIdString;
 export declare function mapIdToItemType(itemId: GlobalSelectionTypes.ItemId): GlobalSelectionItemType;
-export declare function sortByFrequency(list: string[]): string[];
 /**
  * A utility object that provides various functions for handling global selections.
  *
@@ -45,7 +45,6 @@ export declare function sortByFrequency(list: string[]): string[];
  * @property {Function} idsEqual - Compares two global selection item IDs for equality.
  * @property {Function} mapToId - Maps an object to its global selection item ID.
  * @property {Function} itemIdToString - Converts a global selection item id object to a string, each value is concatenated by a '-'
- * @property {Function} sortByFrequency - Sorts and aggregates a list of strings.
  */
 export declare const globalSelectionUtils: Readonly<{
     isMeasuringPointId: typeof isMeasuringPointId;
@@ -56,6 +55,27 @@ export declare const globalSelectionUtils: Readonly<{
     mapToId: typeof mapToId;
     mapIdToItemType: typeof mapIdToItemType;
     itemIdToString: typeof itemIdToString;
-    sortByFrequency: typeof sortByFrequency;
 }>;
+/**
+ * Updates the global selection list in the store by processing the results of multiple fetch operations.
+ *
+ * This function handles three types of updates:
+ * - Successfully fetched items are added or updated in the list.
+ * - Items that resulted in errors during fetching are marked accordingly.
+ * - Items that were not found in the fetch responses are marked as not found.
+ *
+ * @template T - The type of the global selection item.
+ * @param state - The current global selection store state.
+ * @param itemType - The type of items being updated in the selection list.
+ * @param itemIds - The array of item IDs that were requested to be fetched.
+ * @param fetchResponse - An array of fetch responses, each containing the result and the item IDs used in that fetch.
+ *
+ * @remarks
+ * This utility function is intended to be used internally by the global selection store to batch process updates
+ * after fetching multiple items, ensuring the store reflects the latest state of each item (success, error, or not found).
+ */
+export declare function batchUpdateGlobalSelectionList<T extends GlobalSelectionItemType>(state: GlobalSelectionTypes.Store, itemType: T, itemIds: SelectionItemTypeToItemIdMap[T][], fetchResponse: {
+    result: ResultArray<GlobalSelectionItemTypeToDataMap[T]>;
+    itemIdsUsed: SelectionItemTypeToItemIdMap[T][];
+}[]): void;
 export {};

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

@@ -1,6 +1,16 @@
 import { GlobalSelectionItemType, GlobalSelectionTypes, SelectionItemSystemStatus } from './globalSelectionStore.types';
-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 toGlobalSelectionItem<T extends GlobalSelectionTypes.ItemTypeToDataMap[K], K extends GlobalSelectionItemType>(args: {
+    item: T;
+    type: K;
+    systemStatus: SelectionItemSystemStatus;
+    color?: string;
+}): GlobalSelectionTypes.GenericItem<K>;
+export declare function toGlobalSelectionItems<T extends GlobalSelectionTypes.ItemTypeToDataMap[K], K extends GlobalSelectionItemType>(args: {
+    items: T[];
+    type: K;
+    systemStatus: SelectionItemSystemStatus;
+    color?: string;
+}): GlobalSelectionTypes.GenericItem<K>[];
 export declare function setNotFoundStatusByItemIds(args: {
     itemType: GlobalSelectionItemType;
     state: GlobalSelectionTypes.Store;

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

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

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

@@ -10,11 +10,16 @@ export { useGlobalSelectionWorkOrders } from './hooks/useGlobalSelectionWorkOrde
 export { useSelectionCategoriesByGroupId } from './hooks/useSelectionCategoriesByGroupId';
 export { useCurrentSelectionId } from './selectionMenu/hooks/useCurrentSelectionId';
 export { useGlobalSelectionGroups } from './selectionMenu/hooks/useGlobalSelectionGroups';
-export { useMoveSelectionTreeItems } from './selectionMenu/hooks/useMoveSelectionTreeItems';
-export { loadEchoViewIdAndSelectionIdFromUrl } from '../../services/echoViewService/loadEchoViewIdAndSelectionIdFromUrl';
+export { useMostUsedSelectionColorByIds } from './selectionMenu/hooks/useSelectionColorFrequency';
+export { useFetchSelectionHistory } from './selectionMenu/hooks/useFetchSelectionHistory';
 export { RemoveSelectionItemsConfirmDialog } from './components/RemoveSelectionItemsConfirmDialog';
 export { globalSelectionApi } from './globalSelection.api';
 export { globalSelectionInternal } from './globalSelection.internal';
+export { SELECTION_COLOR_PICKER_COLORS } from './globalSelectionColorService';
 export { globalSelectionUtils } from './globalSelectionStore/globalSelectionStore.utils';
 export { OpenGlobalSelectionIn3DButton } from './OpenGlobalSelectionIn3DButton';
 export { convertGlobalSelectionItemsToPlantTagPairs } from './OpenGlobalSelectionIn3DButton.utils';
+export { saveEquipmentAsNewSelectionToApi } from './selectionMenu/selectionTreeStore/api/selectionTree.equipment';
+export { invalidateHistorySelectionQuery } from './selectionMenu/invalidateHistorySelectionQuery';
+export { SelectionColorConflictDialog } from './selectionMenu/selectionTreeStore/colorConflictHandling/SelectionColorConflictDialog';
+export { simulatedSelectionTreeApiError } from './selectionMenu/selectionTreeStore/persist/devOnlySimulateOffline';

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

@@ -0,0 +1,5 @@
+export declare const historySelectionQueryKey = "historySelection";
+export declare const useFetchSelectionHistory: () => {
+    status: "error" | "success" | "pending";
+    data: import("../selectionTreeStore/selectionTree.api.types").ApiSelectionHistory[] | undefined;
+};

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

@@ -1,7 +1,30 @@
+import { GlobalSelectionItemType, GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
 import { SelectionTreeTypes } from '../selectionTreeStore/selectionTree.store.types';
 /**
  * Custom hook to get the selection menu lists from the selection menu store, displayed in the left selection panel.
  *
- * @returns {SelectionTreeTypes.Group[]} - An array of selection menu lists.
+ * Usage:
+ * - `useGlobalSelectionGroups()` or `useGlobalSelectionGroups({ withData: false })` returns groups with only item references (IDs).
+ * - `useGlobalSelectionGroups({ withData: true })` returns groups with full item data and metaData merged in.
+ *
+ * @param options Options object. If withData is true, returns groups with actual item data/metadata included, not just item ids.
+ * @returns An array of selection menu groups, either with only item references or with full item data, depending on options.
  */
 export declare function useGlobalSelectionGroups(): SelectionTreeTypes.Group[];
+export declare function useGlobalSelectionGroups(options: {
+    withData: false;
+}): SelectionTreeTypes.Group[];
+export declare function useGlobalSelectionGroups(options: {
+    withData: true;
+}): SelectionTreeGroupWithData[];
+type SelectionTreeItemWithData<T extends GlobalSelectionItemType> = SelectionTreeTypes.Category['items'] extends Map<infer _, infer V> ? V & {
+    data?: GlobalSelectionTypes.ItemTypeToDataMap[T];
+    metaData?: GlobalSelectionTypes.GenericItem<T>['metaData'];
+} : never;
+type SelectionTreeCategoryWithData = Omit<SelectionTreeTypes.Category, 'items'> & {
+    items: Map<GlobalSelectionTypes.ItemIdString, SelectionTreeItemWithData<GlobalSelectionItemType>>;
+};
+type SelectionTreeGroupWithData = Omit<SelectionTreeTypes.Group, 'categories'> & {
+    categories: SelectionTreeCategoryWithData[];
+};
+export {};

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

@@ -0,0 +1,18 @@
+import { GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
+/**
+ * Returns an array of color strings sorted by their frequency of occurrence among the selected items.
+ *
+ * This hook retrieves the global selection items and filters them based on the provided item IDs,
+ * extracts their associated colors, and sorts the colors by frequency.
+ *
+ * @param itemIds - An array of item IDs to match against global selection items.
+ * @returns An array of color strings sorted by frequency, most frequent first.
+ */
+export declare function useSelectionColorFrequencyByIds(itemIds: GlobalSelectionTypes.ItemId[]): string[];
+/**
+ * Returns the most frequently used selection color from the provided item IDs.
+ *
+ * @param itemIds - An array of item IDs to analyze for color frequency.
+ * @returns The most used selection color as a string, or `undefined` if no colors are present.
+ */
+export declare function useMostUsedSelectionColorByIds(itemIds: GlobalSelectionTypes.ItemId[]): string | undefined;

package/src/lib/feature/globalSelection/selectionMenu/invalidateHistorySelectionQuery.d.ts

@@ -0,0 +1 @@
+export declare const invalidateHistorySelectionQuery: () => Promise<void>;

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

@@ -0,0 +1,16 @@
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionTypes } from '../../../globalSelectionStore/globalSelectionStore.types';
+import { SelectionTreeStore } from '../selectionTree.store.types';
+/**
+ * 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.
+ *
+ * @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.
+ * @returns A promise that resolves when all items have been added to the store.
+ */
+export declare function addItems(get: () => SelectionTreeStore, args: AddItemsActionArgs): Promise<void>;
+export type AddItemsActionArgs = {
+    itemIds: GlobalSelectionTypes.ItemId[];
+    groupId?: Guid;
+};

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

@@ -5,7 +5,7 @@ import { GlobalSelectionCategoryId, SelectionTreeStore } from '../selectionTree.
 import { AddItemArgs, AddItemsResponse } from './selectionTree.action.types';
 type SetFunction = (set: (state: SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void;
 export declare function addItemsToSelectionTreeActionFactory<G_ItemType extends GlobalSelectionItemType>(args: {
-    addItemToGlobalSelection: (uniqueNewItems: SelectionItemTypeToItemIdMap[G_ItemType][]) => Promise<GlobalSelectionAddItemResult<ResultArray<GlobalSelectionItemTypeToDataMap[G_ItemType]>[]>>;
+    addItemsToGlobalSelection: (uniqueNewItems: SelectionItemTypeToItemIdMap[G_ItemType][], color?: string) => Promise<GlobalSelectionAddItemResult<ResultArray<GlobalSelectionItemTypeToDataMap[G_ItemType]>[]>>;
     itemType: G_ItemType;
     itemCategory: GlobalSelectionCategoryId;
     categoryOrderIndex: number;

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

@@ -0,0 +1,5 @@
+import { WritableDraft } from 'immer';
+import { SelectionTreeStore } from '../selectionTree.store.types';
+export type SetFunction = (nextStateOrUpdater: SelectionTreeStore | Partial<SelectionTreeStore> | ((state: WritableDraft<SelectionTreeStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+    type: string;
+} | undefined) => void;

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

@@ -0,0 +1,20 @@
+import { Guid } from '@equinor/echo-utils';
+import { SelectionTreeStore } from '../selectionTree.store.types';
+import { SetFunction } from './common.action.types';
+/**
+ * Creates a new group in the selection tree store if a group with the specified label does not already exist.
+ * If a group with the given label exists, returns its groupId instead of creating a new group.
+ *
+ * @param get - A function that returns the current state of the selection tree store.
+ * @param set - A function to update the selection tree store state.
+ * @param args - An object containing:
+ *   @param groupId - (Optional) The ID to assign to the new group. If not provided, a new GUID is generated.
+ *   @param label - The label for the group. Used to check for existing groups.
+ *   @param subLabel - The sub-label for the group.
+ * @returns The groupId of the newly created group, or the groupId of an existing group with the same label.
+ */
+export declare function createGroup(get: () => SelectionTreeStore, set: SetFunction, args: {
+    groupId?: string;
+    label: string;
+    subLabel: string;
+}): Guid;

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

@@ -0,0 +1,31 @@
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionTypes } from '../../../globalSelectionStore/globalSelectionStore.types';
+import { GlobalSelectionCategoryId } from '../selectionTree.store.types';
+import { SetFunction } from './common.action.types';
+/**
+ * Moves items, categories, or groups within the selection tree structure.
+ *
+ * Depending on the provided arguments, this function will:
+ * - Move a single item from one category/group to another.
+ * - Move an entire category from one group to another, optionally removing the source group if empty.
+ * - Move an entire group to another location, removing the original group.
+ *
+ * @param set - The state setter function used to update the selection tree.
+ * @param args - The arguments specifying the source and target locations for the move operation.
+ *   - `sourceGroupId`: The ID of the group from which the item/category/group is moved.
+ *   - `sourceCategoryId`: (Optional) The ID of the category from which the item is moved.
+ *   - `sourceItemId`: (Optional) The ID of the item to move.
+ *   - `targetGroupId`: The ID of the group to which the item/category/group is moved.
+ *
+ * @remarks
+ * - If `sourceItemId` is provided, `sourceCategoryId` must also be provided.
+ * - After moving a single item, the source group is not removed.
+ * - After moving a category or group, the source group may be removed if empty.
+ */
+export declare function moveItems(set: SetFunction, args: MoveSelectionArgs): void;
+export type MoveSelectionArgs = {
+    sourceGroupId: Guid;
+    sourceCategoryId?: GlobalSelectionCategoryId;
+    sourceItemId?: GlobalSelectionTypes.ItemId;
+    targetGroupId: Guid;
+};

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

@@ -0,0 +1,21 @@
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionCategoryId } from '../selectionTree.store.types';
+import { SetFunction } from './common.action.types';
+/**
+ * Removes a group or a category within a group from the global selection state.
+ *
+ * If a `categoryId` is provided, only the specified category within the group is cleared of its items.
+ * If no `categoryId` is provided, the entire group and all its categories are removed.
+ * All items associated with the removed group or category are also removed from the global selection.
+ *
+ * @param set - The state setter function used to update the selection tree store.
+ * @param args - The arguments specifying which group and optionally which category to remove.
+ * @param args.groupId - The ID of the group to remove.
+ * @param args.categoryId - (Optional) The ID of the category within the group to remove.
+ */
+export declare function removeGroupById(set: SetFunction, args: RemoveGroupByIdArgs): void;
+type RemoveGroupByIdArgs = {
+    groupId: Guid;
+    categoryId?: GlobalSelectionCategoryId;
+};
+export {};

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

@@ -0,0 +1,24 @@
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionTypes } from '../../../globalSelectionStore/globalSelectionStore.types';
+import { GlobalSelectionCategoryId } from '../selectionTree.store.types';
+import { SetFunction } from './common.action.types';
+/**
+ * Removes items from a selection category by their IDs.
+ *
+ * This function locates the target category within the specified group and removes the provided item IDs.
+ * If the group becomes empty after removal, it is also removed from the selection state.
+ * Additionally, the items are removed from the global selection.
+ *
+ * @param set - The state setter function used to update the selection tree store.
+ * @param args - Arguments specifying the group ID, category ID, and the list of item IDs to remove.
+ *   - groupId: The ID of the group containing the category (optional; defaults to local selection group).
+ *   - categoryId: The ID of the category from which items will be removed.
+ *   - itemIds: An array of item IDs to be removed from the category.
+ */
+export declare function removeItemsById(set: SetFunction, args: RemoveItemsByIdArgs): void;
+type RemoveItemsByIdArgs = {
+    groupId?: Guid;
+    categoryId: GlobalSelectionCategoryId;
+    itemIds: GlobalSelectionTypes.ItemId[];
+};
+export {};