@equinor/echo-framework 1.0.0 → 1.1.1

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

@@ -1,27 +1,26 @@
 import { ResultArray } from '@equinor/echo-search';
 import { Guid } from '@equinor/echo-utils';
 import { GlobalSelectionItemType, GlobalSelectionItemTypeToDataMap, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from '../../../globalSelectionStore/globalSelectionStore.types';
-/**
- * @deprecated A group should not be created with label and subLabel.
- * Use `groupId` instead to specify the group.
- * This type will be removed in the future.
- */
-export type AddByGroupIdAndLabel = {
-    label: string;
-    subLabel: string;
-} | {
-    label?: undefined;
-    subLabel?: undefined;
-};
-export type AddItemArgs<ItemIdType extends GlobalSelectionTypes.ItemId> = {
+type AddItemArgsBase<ItemIdType extends GlobalSelectionTypes.ItemId> = {
     itemIds: Readonly<ItemIdType[]>;
     replaceItems?: boolean;
     getActionResult?: boolean;
-    groupId?: Guid;
-} & AddByGroupIdAndLabel;
+};
+type AddItemArgsExclusive = {
+    groupId: Guid;
+    label?: undefined;
+    subLabel?: undefined;
+} | {
+    groupId?: undefined;
+    label: string;
+    subLabel: string;
+} | {};
+export type AddItemArgs<ItemIdType extends GlobalSelectionTypes.ItemId> = AddItemArgsBase<ItemIdType> & AddItemArgsExclusive;
 export type AddItemsResponse<T extends GlobalSelectionItemType> = {
     fetchResults: ResultArray<GlobalSelectionItemTypeToDataMap[T]>[];
     itemsAdded: Readonly<SelectionItemTypeToItemIdMap[T][]>;
     actionResult: SelectionTreeActionResult;
+    affectedGroupId?: Guid;
 };
 export type SelectionTreeActionResult = 'ItemsUpdated' | 'ItemsAdded' | 'NewGroupCreated' | 'NoChanges';
+export {};

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

@@ -0,0 +1,21 @@
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionCategoryId, SelectionTreeStore } from '../selectionTree.store.types';
+/**
+ * Sets the visibility of selection items within a specified group and category.
+ *
+ * This function locates the relevant selection category and updates the visibility
+ * of all items within that category, or all items in the group if no category is specified.
+ * Only unique item IDs are processed for visibility changes.
+ *
+ * @param get - A function that returns the current `SelectionTreeStore` state.
+ * @param args - The arguments for the action, including:
+ *   - `groupId`: The ID of the group containing the items.
+ *   - `isVisible`: The desired visibility state to set for the items.
+ *   - `categoryId` (optional): The ID of the category within the group. If omitted, all categories in the group are affected.
+ */
+export declare function setVisibilityById(get: () => SelectionTreeStore, args: SetVisibilityActionArgs): void;
+export type SetVisibilityActionArgs = {
+    groupId: Guid;
+    categoryId?: GlobalSelectionCategoryId;
+    isVisible: boolean;
+};

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

@@ -1,9 +1,19 @@
 import { Guid } from '@equinor/echo-utils';
-import { ApiSelectionTreeRoot } from '../selectionTree.api.types';
+import { ApiSelectionTreeRoot, ApiSelectionTreeRootBase } from '../selectionTree.api.types';
 import { SelectionGroup } from '../selectionTree.store.types';
-export declare function saveSelectionTreeToApi(id: string | undefined, data: {
-    data: SelectionGroup[];
-}): Promise<void>;
+/**
+ * Maps the selection tree data to the API format.
+ * @param data The selection tree data to map
+ * @param lifetime The lifetime of the selection
+ * @returns The mapped API selection tree root
+ */
+export declare function mapToApiSelectionRoot(data: {
+    args: SelectionGroup[];
+}, lifetime: 'Short' | 'Long'): ApiSelectionTreeRootBase;
+export declare function saveSelectionTreeToApi(args: {
+    id: string | undefined;
+    itemToSave: ApiSelectionTreeRootBase;
+}): Promise<Guid | undefined>;
 export declare function fetchSelectionTreeById(id: string): Promise<ApiSelectionTreeRoot | undefined>;
 export declare function fetchUserSelectionIds(): Promise<Guid[]>;
 export declare function deleteSelectionId(id: string): Promise<void>;

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

@@ -0,0 +1,5 @@
+import { EquipmentData } from '@equinor/echo-search';
+import { Guid } from '@equinor/echo-utils';
+import { SelectionGroup } from '../selectionTree.store.types';
+export declare function saveEquipmentAsNewSelectionToApi(equipmentsToSend: ReadonlyArray<EquipmentData>, selectionGroupLabel?: string): Promise<Guid | undefined>;
+export declare function createSelectionGroupsFromEquipment(equipmentIds: string[], selectionGroupLabel: string): SelectionGroup[];

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/colorConflictHandling/SelectionColorConflictDialog.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+/**
+ * Displays a dialog when there is a color conflict during selection list import.
+ *
+ * This dialog informs the user that one or more items being added to the selection already exist and have assigned colors.
+ * It notifies the user that the latest (incoming) color will be assigned to these items.
+ * The dialog is rendered via a portal and adapts its width for mobile devices.
+ *
+ * @returns {JSX.Element} The portal-rendered dialog component.
+ */
+export declare const SelectionColorConflictDialog: React.FC;

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

@@ -0,0 +1,27 @@
+import { GlobalSelectionTypes } from '../../../globalSelectionStore/globalSelectionStore.types';
+export type SelectionColorConflict = {
+    itemId: GlobalSelectionTypes.ItemId;
+    existingColor: string;
+};
+/**
+ * Zustand store for managing global selection color conflicts.
+ *
+ * @remarks
+ * This store keeps track of color conflicts that occur in selection trees,
+ * providing methods to set and clear the list of conflicts.
+ *
+ * @returns
+ * - `conflicts`: An array of `SelectionColorConflict` objects representing current conflicts.
+ * - `setConflicts`: Function to update the conflicts array.
+ * - `clearConflicts`: Function to reset the conflicts array to empty.
+ */
+export declare const useSelectionColorConflictStore: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    conflicts: SelectionColorConflict[];
+    setConflicts: (conflicts: SelectionColorConflict[]) => void;
+    clearConflicts: () => void;
+}>>;
+export declare const getSelectionColorConflictState: () => {
+    conflicts: SelectionColorConflict[];
+    setConflicts: (conflicts: SelectionColorConflict[]) => void;
+    clearConflicts: () => void;
+};

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

@@ -0,0 +1,7 @@
+declare function setSimulateSelectionTreeApiError(enabled: boolean): void;
+declare function getSimulateSelectionTreeApiError(): boolean;
+export declare const simulatedSelectionTreeApiError: Readonly<{
+    get: typeof getSimulateSelectionTreeApiError;
+    set: typeof setSimulateSelectionTreeApiError;
+}>;
+export {};

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/persist/diskId.type.d.ts

@@ -0,0 +1,2 @@
+import { Brand } from '@equinor/echo-utils';
+export type DiskId = Brand<string, 'DiskId'>;

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

@@ -0,0 +1,5 @@
+import { BaseError } from '@equinor/echo-base';
+export declare function createPersistError(args: {
+    userFriendlyMessage: string;
+    error: unknown;
+}): BaseError;

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

@@ -0,0 +1,45 @@
+import { Guid } from '@equinor/echo-utils';
+import { ApiSelectionTreeRootBase } from '../selectionTree.api.types';
+import { DiskId } from './diskId.type';
+export interface OfflineSelectionTreeData {
+    diskId: DiskId;
+    apiId?: Guid;
+    apiSelectionTreeRoot: ApiSelectionTreeRootBase;
+    timestamp: Date;
+    isSavedToApi: boolean;
+}
+declare function backupSelectionTreeToDisk(apiId: Guid | undefined, apiSelectionTreeRoot: ApiSelectionTreeRootBase): Promise<DiskId>;
+interface SelectionTreeBackup {
+    apiId: Guid | undefined;
+    apiSelectionTreeRoot: ApiSelectionTreeRootBase;
+    timestamp: Date;
+}
+declare function getBackupSelectionTreeFromDisk(id: Guid | DiskId): Promise<SelectionTreeBackup | undefined>;
+/**
+ * Sets the API ID for a disk backup and marks it as saved to the API.
+ * @param diskId The disk ID of the backup.
+ * @param apiId The API ID to set.
+ */
+declare function setSavedToApi(diskId: DiskId | undefined, apiId: Guid): Promise<void>;
+/**
+ * Tries to save any unsaved backup selection trees to the API, and deletes all that are saved to API except current apiId.
+ * These backups are created by starting a new selection in offline mode (clear selection, or remove all groups).
+ */
+declare function saveAllBackupsToApiAndDeleteThemExceptFor(apiId: Guid): Promise<void>;
+/**
+ * Checks if a disk backup exists for the given API ID and deletes it if it has been saved to the API.
+ * @param apiId The API ID of the selection tree to check and possibly delete.
+ */
+declare function deleteDiskBackupIfAlreadySavedToApi(apiId: Guid): Promise<void>;
+export declare const selectionTreeDiskBackup: Readonly<{
+    save: typeof backupSelectionTreeToDisk;
+    load: typeof getBackupSelectionTreeFromDisk;
+    setSavedToApi: typeof setSavedToApi;
+    saveAllBackupsToApiAndDeleteThemExceptFor: typeof saveAllBackupsToApiAndDeleteThemExceptFor;
+    deleteDiskBackupIfAlreadySavedToApi: typeof deleteDiskBackupIfAlreadySavedToApi;
+    /**
+     * TEST-ONLY: Returns all disk backups for testing purposes.
+     */
+    getAllBackupsForTest: () => Promise<OfflineSelectionTreeData[]>;
+}>;
+export {};

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

@@ -0,0 +1,19 @@
+import { Guid } from '@equinor/echo-utils';
+import { DiskId } from './diskId.type';
+/**
+ * Since both disk (indexDb) and api can fail/throw, we need to track what has been saved where. Local storage is most reliable for this.
+ * This is used when loading, to determine where to load from, disk or api. Disk is prioritized if it's upto date because of performance.
+ */
+export interface BackupStatus {
+    readonly savedToApiId: Guid | undefined;
+    readonly savedToDiskId: DiskId | undefined;
+}
+declare function updateSaveStatus(saveStatus: BackupStatus): void;
+declare function getSaveStatus(): BackupStatus | undefined;
+declare function clearSaveStatus(): void;
+export declare const selectionTreeDiskBackupStatus: Readonly<{
+    update: typeof updateSaveStatus;
+    get: typeof getSaveStatus;
+    clear: typeof clearSaveStatus;
+}>;
+export {};

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

@@ -0,0 +1,8 @@
+import { Guid } from '@equinor/echo-utils';
+export declare const selectionTreeRepository: Readonly<{
+    loadAndPopulateLatestSelection: typeof loadAndPopulateLatestSelection;
+    loadAndPopulateStoreFromApi: typeof loadAndPopulateStoreFromApi;
+}>;
+declare function loadAndPopulateLatestSelection(): Promise<void>;
+declare function loadAndPopulateStoreFromApi(idToLoad: Guid): Promise<boolean>;
+export {};

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

@@ -0,0 +1,42 @@
+import { ApiSelectionGroup, ApiSelectionTreeRootBase } from '../selectionTree.api.types';
+import { GlobalSelectionItemType, GlobalSelectionObject, GlobalSelectionTypes } from '../../../globalSelectionStore/globalSelectionStore.types';
+/**
+ * Processes API selection tree data and organizes item IDs by their types.
+ *
+ * This function takes the `data` property from an API selection tree root object,
+ * extracts all items from the nested structure, and groups their normalized IDs
+ * by their corresponding `GlobalSelectionItemType`. It then creates selection lists
+ * for each type using the `selectionTreeLoader.createListByType` utility.
+ *
+ * @param param0 - An object containing the `data` array from the API selection tree root.
+ * @returns An object containing:
+ *   - `lists`: A `GlobalSelectionObject` with lists of items grouped by type.
+ *   - `idsByType`: An object mapping each `GlobalSelectionItemType` to an array of item IDs.
+ */
+export declare function createListsByTypeFromApiData({ data }: {
+    data: ApiSelectionTreeRootBase['data'];
+}): {
+    lists: GlobalSelectionObject;
+    idsByType: {
+        [K in GlobalSelectionItemType]: GlobalSelectionTypes.ItemId[];
+    };
+};
+/**
+ * Applies color assignments to selection API data groups.
+ * Used when loading selection data from the API or disk to ensure consistent color usage.
+ *
+ * This function ensures that each group in the provided selection data has a color assigned.
+ * If any item within a group is missing a color (as determined by `getHexOrOriginalOrUndefined`),
+ * a color is assigned to the group using the color service. The function then returns a new array
+ * of groups where each item's `metaData.color` is set either from the API or from the assigned color.
+ *
+ * The color assignment process:
+ * 1. Resets the color service to release previous color assignments.
+ * 2. Identifies group IDs that require color assignment (where at least one item is missing a color).
+ * 3. Assigns colors to these group IDs using the color service.
+ * 4. Returns a new structure with colors applied to all items.
+ *
+ * @param groups - The array of selection groups from the API to process.
+ * @returns A new array of selection groups with colors assigned to items as needed.
+ */
+export declare function applyColorsOnSelectionApiData(groups: ApiSelectionGroup[]): ApiSelectionGroup[];

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

@@ -0,0 +1 @@
+export declare function saveCurrentSelectionTree(): Promise<void>;

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

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

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/{useSelectionTreeAutoSave.d.ts → persist/useSelectionTreeAutoSave.d.ts}

@@ -1,5 +1,7 @@
+export declare const autoSaveDebounceDelayMilliseconds = 250;
 /**
  * Auto saves if the selection tree or global selection change by: Add/remove/rename items/groups, or metadata.color/isHiddenByUser
  * Ignores saving if only data object changes, or metadata.error/status
+ * Falls back to disk storage when API is unavailable
  */
 export declare function useSelectionTreeAutoSave(): void;

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

@@ -2,16 +2,21 @@ import { Guid } from '@equinor/echo-utils';
 import { GlobalSelectionItemType, GlobalSelectionMetaData, SelectionItemTypeToItemIdMap } from '../../globalSelectionStore/globalSelectionStore.types';
 export type ApiSelectionTreeItemId = SelectionItemTypeToItemIdMap[GlobalSelectionItemType];
 export type ApiGlobalSelectionMetaData = Partial<Pick<GlobalSelectionMetaData, 'color' | 'isHiddenByUser'>>;
-export interface ApiSelectionTreeRoot {
-    id?: Guid;
+export interface ApiSelectionTreeRootBase {
     data: ApiSelectionGroup[];
-    versionNo?: string;
     /**
      * Short is used by 3rd party apps, it should not be visible/selectable by user
      * Long will show up in recent sessions in UI.
      */
     lifetime: 'Short' | 'Long';
 }
+/**
+ * Represents the root of the selection tree in the API.
+ */
+export interface ApiSelectionTreeRoot extends ApiSelectionTreeRootBase {
+    id: Guid;
+    versionNo: string;
+}
 export interface ApiSelectionGroup {
     readonly groupId: Guid;
     readonly label: string;

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

@@ -1,4 +1,19 @@
 import { SelectionTreeStore } from './selectionTree.store.types';
+/**
+ * Zustand store hook for managing the selection tree state in the global selection feature.
+ *
+ * It is responsible for storing and handling the tree structure of the selection.
+ * All the data for the selection items are stored in the global selection store.
+ * This store only stores item ids.
+ *
+ * @returns {SelectionTreeStore} The selection tree store API.
+ *
+ * @example
+ * const selectionTree = useSelectionTreeStore();
+ * selectionTree.addTags({ ... });
+ *
+ * @see SelectionTreeStore
+ */
 export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<SelectionTreeStore>, "setState"> & {
     setState<A extends string | {
         type: string;

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

@@ -1,6 +1,6 @@
 import { Guid } from '@equinor/echo-utils';
 import { GlobalSelectionItemType, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from '../../globalSelectionStore/globalSelectionStore.types';
-import { AddByGroupIdAndLabel, AddItemArgs, AddItemsResponse, SelectionTreeActionResult } from './actions/selectionTree.action.types';
+import { AddItemArgs, AddItemsResponse, SelectionTreeActionResult } from './actions/selectionTree.action.types';
 export declare enum GlobalSelectionCategoryId {
     Tags = "DEFAULT_TAG_LIST_ID",
     WorkOrders = "DEFAULT_WORK_ORDER_LIST_ID",
@@ -30,11 +30,13 @@ export interface SelectionTreeData {
     readonly groups: SelectionGroup[];
 }
 export interface SelectionTreeStore extends SelectionTreeData {
-    setCurrentSelectionId: (id: Guid) => void;
+    setCurrentSelectionId: (args: {
+        guid: Guid | undefined;
+    }) => void;
     addItems: (args: {
         itemIds: GlobalSelectionTypes.ItemId[];
         groupId?: Guid;
-    } & AddByGroupIdAndLabel) => Promise<void>;
+    }) => Promise<void>;
     addTags: (args: AddItemArgs<GlobalSelectionTypes.TagId>) => AddTagsReturnType;
     addWorkOrders: (args: AddItemArgs<GlobalSelectionTypes.WorkOrderId>) => AddWorkOrdersReturnType;
     addEquipments: (args: AddItemArgs<GlobalSelectionTypes.EquipmentId>) => AddEquipmentsReturnType;
@@ -62,12 +64,22 @@ export interface SelectionTreeStore extends SelectionTreeData {
     removeAllItemsById: (args: {
         itemIds: GlobalSelectionTypes.ItemId[];
     }) => void;
+    moveItems: (args: {
+        sourceGroupId: Guid;
+        sourceCategoryId?: GlobalSelectionCategoryId;
+        sourceItemId?: GlobalSelectionTypes.ItemId;
+        targetGroupId: Guid;
+    }) => void;
     setVisibilityById: (args: {
         groupId: Guid;
         categoryId?: GlobalSelectionCategoryId;
         isVisible: boolean;
     }) => void;
     resetState: () => void;
+    setWholeState: (args: {
+        selectionId: Guid | undefined;
+        groups: SelectionGroup[];
+    }) => void;
 }
 export declare namespace SelectionTreeTypes {
     type Category = SelectionCategory;

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

@@ -1,6 +1,6 @@
 import { Guid } from '@equinor/echo-utils';
 import { GlobalSelectionItemType, GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
-import { GlobalSelectionCategoryId, SelectionTreeTypes } from './selectionTree.store.types';
+import { GlobalSelectionCategoryId, SelectionTreeStore, SelectionTreeTypes } from './selectionTree.store.types';
 /**
  * Check if an item ID is present in the selection tree.
  *
@@ -95,6 +95,7 @@ export declare function areItemsTheSameInGroup<ItemType extends GlobalSelectionT
  * @returns {void}
  */
 export declare function removeGroupIfEmpty(allGroups: SelectionTreeTypes.Group[], targetGroup: SelectionTreeTypes.Group): void;
+export declare function isSelectionEmpty(groups: SelectionTreeTypes.Group[]): boolean;
 /**
  * Removes items from the global selection if they are not present in the tree store anymore.
  *
@@ -102,5 +103,66 @@ export declare function removeGroupIfEmpty(allGroups: SelectionTreeTypes.Group[]
  * @param {GlobalSelectionTypes.ItemId[]} itemIds - The list of item IDs to be checked and potentially removed.
  * @returns {void}
  */
-export declare function removeItemsFromGlobalSelection(groups: SelectionTreeTypes.Group[], itemIds: GlobalSelectionTypes.ItemId[]): void;
+export declare function removeStaleItemsFromGlobalSelection(groups: SelectionTreeTypes.Group[], itemIds: GlobalSelectionTypes.ItemId[]): void;
 export declare function getItemsByIdsFromGlobalSelectionStore(itemIds: GlobalSelectionTypes.ItemId[]): GlobalSelectionTypes.GenericItem<GlobalSelectionItemType>[];
+/**
+ * Returns an array of selection colors sorted by their frequency for the specified item IDs within a group.
+ *
+ * This function filters the provided item IDs to include only those that belong to the specified group
+ * and are not present elsewhere in the selection tree. It then counts the occurrence of each color
+ * (excluding placeholder colors) associated with these items in the selection lists, and returns the colors
+ * sorted by their frequency in descending order.
+ *
+ * @param args - The arguments for the function.
+ * @param args.groupId - The ID of the group to filter items by.
+ * @param args.itemIds - The array of item IDs to consider for color frequency.
+ * @param args.selectionLists - (Optional) The selection lists to use. If not provided, the global selection store state is used.
+ * @param args.treeState - (Optional) The selection tree state to use. If not provided, the current selection tree store snapshot is used.
+ * @returns An array of color strings, sorted by frequency (most frequent first).
+ */
+export declare function getSelectionColorFrequencyByIds(args: {
+    groupId: string;
+    itemIds: GlobalSelectionTypes.ItemId[];
+    allGroups: ReadonlyArray<SelectionTreeTypes.Group>;
+}): string[];
+/**
+ * Handles the colorization of selection items within a group in the selection tree.
+ *
+ * This function optionally detects color conflicts among the specified items,
+ * and then assigns a color to the items in the affected group.
+ *
+ * @param args - The arguments for colorizing items.
+ * @param args.itemType - The type of the selection items to colorize.
+ * @param args.treeState - The current state of the selection tree.
+ * @param args.affectedGroupId - (Optional) The ID of the group whose items are affected. If not provided, a default group is used.
+ * @param args.itemIds - The IDs of the items to colorize.
+ * @param args.handleColorConflicts - (Optional) Whether to detect and handle color conflicts before assigning colors.
+ * @returns The color assigned to the items, or `undefined` if no color was assigned.
+ */
+export declare function handleItemColorization(args: {
+    itemType: GlobalSelectionItemType;
+    treeState: SelectionTreeStore;
+    affectedGroupId?: Guid;
+    itemIds: GlobalSelectionTypes.ItemId[];
+    handleColorConflicts?: boolean;
+}): string | undefined;
+/**
+ * Assigns a color to a set of items within a specified group in the selection tree.
+ *
+ * - If the group is the default (local) selection group, a fixed color is assigned based on the item type.
+ * - For other groups, the function determines the most frequently used color among the group's items.
+ *   If no color is found (e.g., for a new or imported group), a new color is assigned using the color service.
+ *
+ * @param args - The arguments for color assignment.
+ * @param args.itemType - The type of the items to assign a color to.
+ * @param args.allGroups - All available selection groups.
+ * @param args.groupId - The ID of the group containing the items.
+ * @param args.itemIdsToColor - The IDs of the items to assign a color to.
+ * @returns The assigned color as a string, or `undefined` if no color could be assigned.
+ */
+export declare function assignColorToItemsInGroup(args: {
+    itemType: GlobalSelectionItemType;
+    allGroups: ReadonlyArray<SelectionTreeTypes.Group>;
+    groupId: string;
+    itemIdsToColor: GlobalSelectionTypes.ItemId[];
+}): string | undefined;

package/src/lib/feature/legacyLegend/legend.d.ts

@@ -34,6 +34,7 @@ export declare enum LegendStatus {
     PM20 = "PM20",
     LC = "LC",
     LO = "LO",
+    NoValvePositionInSAP = "No Valve Position in SAP",
     OnWatch = "On watch",
     InProgress = "In progress",
     IocAnnotationError = "IocAnnotationError",

package/src/lib/feature/legend/components/legendTextSelector/LegendTextSelector.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+interface LegendTextSelectorProps {
+    options: ReadonlyArray<string>;
+    selectedOption: string;
+    onOptionSelected?: (option: string) => void;
+}
+/**
+ * LegendTextSelector renders a group of selectable buttons for legend text options.
+ *
+ * Displays each option as a button, highlights the currently selected option, and calls the `onSelect` callback when a different option is chosen.
+ * Uses Echo UI components and compact density for consistent styling.
+ *
+ * @component
+ * @param {object} props - Component props
+ * @param {ReadonlyArray<string>} props.options - List of selectable options.
+ * @param {string} props.selectedOption - The currently selected option.
+ * @param {(option: string) => void} [props.onOptionSelected] - Callback invoked when a new option is selected.
+ * @returns {JSX.Element | null} The rendered button group, or null if no options are provided.
+ */
+export declare const LegendTextSelector: React.FC<LegendTextSelectorProps>;
+export {};

package/src/lib/feature/legend/components/popover/LegendPopoverContent.d.ts

@@ -1,4 +1,5 @@
 import { FC } from 'react';
+import { Marker } from '../../types/legendMarkerBadge.type';
 import { LegendDataId, LegendId } from '../../types/legendType';
 export interface LegendPopoverContentProps {
     legendId: LegendId;
@@ -10,6 +11,7 @@ export interface LegendPopoverContentProps {
     children?: React.ReactNode;
     excludedLegendTitles?: ReadonlyArray<string>;
     showAddToSelectionButton?: boolean;
+    getMarkersForChipsCreation?: () => ReadonlyArray<Marker>;
 }
 export type LegendPopoverTertiaryLabels = {
     first: string;
@@ -22,6 +24,7 @@ export type LegendPopoverTertiaryLabels = {
  * Uses `legendId` and `legendDataId` to look up and render relevant `LegendChip` components for the given legend item.
  * Displays a title, description, and optional tertiary content (either a structured object with up to three strings, or a custom ReactNode).
  * Additional custom content can be rendered via `children`.
+ * Optionally, chips can be created from markers provided by the `getMarkersForChipsCreation` callback.
  *
  * @component
  * @param {object} props - Component props
@@ -33,5 +36,6 @@ export type LegendPopoverTertiaryLabels = {
  * @param {() => void} [props.onPopoverClicked] - Optional callback for popover click events.
  * @param {React.ReactNode} [props.children] - Optional custom content to render below the predefined main content.
  * @param {ReadonlyArray<string>} [props.excludedLegendTitles] - Optional array of titles to exclude from the legend chips.
+ * @param {() => ReadonlyArray<Marker>} [props.getMarkersForChipsCreation] - Optional callback that returns the markers to be used for chip creation.
  */
 export declare const LegendPopoverContent: FC<LegendPopoverContentProps>;

package/src/lib/feature/legend/components/popover/LegendPopoverContent.logic.d.ts

@@ -13,7 +13,7 @@ import { Marker } from './../../types/legendMarkerBadge.type';
  * @param {ReadonlyArray<string>} [params.excludedLegendTitles] - Optional array of titles to exclude from the chips (case-insensitive).
  * @returns {LegendChipProps[]} The filtered and mapped array of LegendChipProps for rendering.
  */
-export declare function getVisibleLegendChips({ markers, legend, excludedLegendTitles }: {
+export declare function getLegendChipsFromMarkers({ markers, legend, excludedLegendTitles }: {
     markers: ReadonlyArray<Marker>;
     legend: LegendState;
     excludedLegendTitles?: ReadonlyArray<string>;

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

@@ -1,10 +1,16 @@
 import './legendStrategies/workOrderStrategy/WorkOrderLegend';
+export { getBadgeChips, getMarkerChips } from './components/basicLegendRenderer.logic';
 export { LegendList } from './components/LegendList';
+export { LegendTextSelector } from './components/legendTextSelector/LegendTextSelector';
 export { PositionalItem } from './components/pdfMarkers/PositionalItem';
 export { MultipleMarkersByLegends } from './components/pdfMarkers/subComponents/MultipleMarkersByLegends';
 export { LegendPopoverContent } from './components/popover/LegendPopoverContent';
 export type { LegendPopoverContentProps, LegendPopoverTertiaryLabels } from './components/popover/LegendPopoverContent';
 export { legendFacade } from './legendFacade';
+export { legendSnapShot } from './legendStore';
+export { getLegendStrategy } from './legendStrategies/legendCollections';
 export type { Badge, Marker } from './types/legendMarkerBadge.type';
 export type { LegendStrategy } from './types/legendStrategy.type';
 export type { LegendId, LegendOptionConfig } from './types/legendType';
+export { useLegendVisibleDataStore } from './../legend/legendVisibleDataStore';
+export { useLegendUniqueBadges, useLegendUniqueMarkers } from './hooks/useLegendMarkers';

package/src/lib/feature/legend/types/legendMarkerBadge.type.d.ts

@@ -2,11 +2,18 @@ export interface Marker {
     getTitle: () => string;
     getColor: () => string;
     getIcon: () => string;
-    getMarkerKey: () => string;
+    /**
+     * Returns a key that can be used for clustering or grouping markers together if they share the same key.
+     */
+    getGroupKey: () => string;
     badges: Badge[];
     showAsPlainLabel?: boolean;
 }
 export interface Badge {
-    getColor: () => string;
     getTitle: () => string;
+    getColor: () => string;
+    /**
+     * Returns a key that can be used for clustering or grouping badges together if they share the same key.
+     */
+    getGroupKey: () => string;
 }

package/src/lib/feature/legend/types/legendStrategy.type.d.ts

@@ -17,6 +17,7 @@ export interface LegendStrategy {
      * Badge options that is selectable by the user.
      */
     badgeOptions?: ReadonlyArray<LegendOptionConfig>;
+    getBadgeTextOptions?: (selectedBadgeOption: LegendOptionConfig) => ReadonlyArray<string> | undefined;
     /**
      * Returns ONE marker per itemId.
      */

package/src/lib/feature/legend/types/legendType.d.ts

@@ -17,6 +17,7 @@ export interface LegendState {
     hiddenBadges: string[];
     selectedMarkerOption: LegendOptionConfig;
     selectedBadgeOption: LegendOptionConfig;
+    selectedBadgeTextOptions: Record<string, string>;
     isExpanded: boolean;
 }
 export type LegendTagId = GlobalSelectionTypes.TagId;