@equinor/echo-framework 0.21.0-beta-2 → 0.21.1-beta-0

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "0.21.0-beta-2",
+  "version": "0.21.1-beta-0",
   "peerDependencies": {
     "@equinor/echo-base": ">= 0.7.0 < 0.8.0",
-    "@equinor/echo-components": "0.12.0-beta-1",
+    "@equinor/echo-components": ">= 0.12.0 < 0.13.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",

package/src/index.d.ts

@@ -14,10 +14,8 @@ 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 { useAllItemsHiddenByUser } from './lib/feature/globalSelection/selectionMenu/hooks/useAllItemsHiddenByUser';
-export { useSelectionMenuLists } from './lib/feature/globalSelection/selectionMenu/hooks/useSelectionMenuLists';
-export { SelectionMenuDefaultListIds } from './lib/feature/globalSelection/selectionMenu/selectionMenuStore/selectionMenu.store';
-export type { SelectionMenuList } from './lib/feature/globalSelection/selectionMenu/selectionMenuStore/selectionMenu.store.types';
+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 { getLatestMeasurementDate, sortMeasuringPointsByMeasurementDate } from './lib/feature/measuringPoint/components/measuringPoints.utils';
 export * from './lib/feature/measuringPoint/index';
@@ -54,6 +52,7 @@ export { PingableSources } from './lib/types/pingableSources';
 export { SearchItemDetailsType as searchItemDetailsType } from './lib/types/searchItemDetailsType';
 export * from './lib/utils';
 export { getPdmsPlantCodeForTag } from './lib/utils/getPdmsPlantCodeForTag';
+export { isImage, isVideo } from './lib/utils/mediaTypeUtils';
 export { convertPathNameToReadableString } from './lib/utils/moduleNameUtils';
 export * from './lib/utils/startup';
 export declare const registerEchopediaComponent: ({ name, component }: {

package/src/lib/components/prepview/api/api.d.ts

@@ -8,6 +8,7 @@ export declare function getPunchDetails(instCode: string, punchId: string): Prom
 export declare function getTagInformation(itemId: string, isWorkOrder?: boolean): Promise<PrepviewTagInformation>;
 export declare function getAttachments(itemId: string, isWorkOrder?: boolean): Promise<PrepviewAttachment[]>;
 export declare function getAttachmentFile(type: string, id: string, attachment: PrepviewAttachment, isWorkOrder?: boolean): Promise<Blob>;
+export declare function getAttachmentFileUrl(type: string, id: string, attachment: PrepviewAttachment, isWorkOrder?: boolean): Promise<Blob>;
 export declare function getDocuments(itemId: string, isWorkOrder?: boolean): Promise<PrepviewDocumentGroup[]>;
 export declare function getHistory(itemId: string, isWorkOrder?: boolean): Promise<PrepviewHistory>;
 export declare function getSafetyCards(itemId: string, isWorkOrder?: boolean): Promise<PrepviewSafety[]>;

package/src/lib/components/prepview/context/PrepviewContext.d.ts

@@ -1,8 +1,8 @@
 import React from 'react';
 import { SideSheetOrientation } from '@equinor/echo-components';
+import { SEBadgeType, SNBadgeType, WoBadgeType } from '../colors';
 import { Coordinates, HistoricNotificationItem, HistoricPunchItem, HistoricWorkOrderItem, ItemTypes, WorkOrderEquipment } from '../types';
 import { WorkItemType } from '../utils';
-import { SEBadgeType, SNBadgeType, WoBadgeType } from '../colors';
 interface PrepviewContext {
     orientation: SideSheetOrientation;
     tagClicked: (tagId: string, instCode: string) => void;

package/src/lib/components/prepview/panels/attachments/AttachmentItem.d.ts

@@ -4,5 +4,5 @@ interface AttachmentItemProps {
     recordId: string;
     attachment: PrepviewAttachment;
 }
-declare function AttachmentItem({ recordType, recordId, attachment, }: AttachmentItemProps): import("react/jsx-runtime").JSX.Element;
+declare function AttachmentItem({ recordType, recordId, attachment }: AttachmentItemProps): import("react/jsx-runtime").JSX.Element;
 export { AttachmentItem };

package/src/lib/components/prepview/types/shared.d.ts

@@ -27,6 +27,7 @@ export type PrepviewAttachment = {
     id: string;
     fileName: string;
     fileSize: number;
+    fileType: string;
     createdDateTime: Date;
 };
 export type PrepviewDocumentGroup = {

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

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

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

@@ -1,33 +1,8 @@
-import { ResultValue, TagSummaryDto } from '@equinor/echo-search';
 import { GlobalSelectionTypes } from './globalSelectionStore/globalSelectionStore.types';
-/**
- * A frozen object that provides various API methods for managing global selections.
- *
- * @constant
- * @namespace globalSelectionApi
- *
- * @property {Function} removeItemsByListId - Removes items by their list ID.
- *
- * @property {Object} add - Contains methods for adding items.
- * @property {Function} add.tags - Adds tags to the selection.
- * @property {Function} add.workOrders - Adds work orders to the selection.
- *
- * @property {Object} search - Contains methods for searching items.
- * @property {Function} search.isItemIdInList - Checks if an item ID is in the list.
- * @property {Function} search.isItemIdInTheSelection - Checks if an item ID is in the selection.
- * @property {Function} search.findListById - Finds a selection list by its ID.
- *
- * @property {Object} visibility - Contains methods for setting visibility.
- * @property {Function} visibility.setByItemIds - Sets visibility by item IDs.
- * @property {Function} visibility.setByListId - Sets visibility by list ID.
- *
- * @property {Object} errorStatus - Contains methods for managing error statuses.
- * @property {Function} errorStatus.setByItemIds - Sets error status for items by their IDs.
- * @property {Function} errorStatus.removeByItemIds - Removes error status for items by their IDs.
- * @property {Function} errorStatus.reset - Resets item error statuses.
- */
+import { GlobalSelectionCategoryId, SelectionTreeTypes } from './selectionMenu/selectionTreeStore/selectionTree.store.types';
 export declare const globalSelectionApi: Readonly<{
     /**
+     * @deprecated Use globalSelectionApi.remove.itemsById() instead
      * Removes items from a specified list in the selection menu panel by their IDs.
      *
      * @param {Object} args - The arguments for removing items.
@@ -41,61 +16,91 @@ export declare const globalSelectionApi: Readonly<{
         listId: string;
         itemIds: GlobalSelectionTypes.ItemId[];
     }) => void;
-    add: Readonly<{
+    remove: Readonly<{
+        /**
+         * 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.
+         */
+        itemsById: (args: {
+            groupId?: import("dist/libs/echo-utils/src").Guid;
+            categoryId: GlobalSelectionCategoryId;
+            itemIds: GlobalSelectionTypes.ItemId[];
+        }) => void;
         /**
-         * Adds tags to a specified list in the selection menu panel.
+         * Removes a group or category by ID from the selection store.
          *
-         * @param {Object} args - The arguments for adding tags.
-         * @param {string} args.listId - Optional - The ID of the list to which the tags should be added. If not provided, the default tag list ID is used.
-         * @param {Readonly<Readonly<TagSummaryDto>[]>} args.items - An array of TagSummaryDto objects representing the tags to be added.
+         * If a categoryId is provided, it removes all items from the specified category within the group.
+         * If no categoryId is provided, it removes the entire group and all its items.
          *
-         * @example
-         * addTags({ listId: '123', items: [{ id: 'tag1', name: 'Tag 1' }, { id: 'tag2', name: 'Tag 2' }] });
+         * @param {Object} args - The function arguments.
+         * @param {Guid} args.groupId - The ID of the group to remove.
+         * @param {GlobalSelectionCategoryId} [args.categoryId] - The ID of the category to remove (optional).
          */
-        tags: (args: {
-            listId?: string;
-            itemIds: Readonly<GlobalSelectionTypes.TagId[]>;
-        }) => Promise<import("@equinor/echo-search").ResultArray<TagSummaryDto>[]>;
+        listById: (args: {
+            groupId: import("dist/libs/echo-utils/src").Guid;
+            categoryId?: GlobalSelectionCategoryId;
+        }) => void;
+    }>;
+    add: 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 {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.
+         * Otherwise it just returns with ResultArray<TagSummaryDto>[]>.
+         * @returns {Promise<AddTagsResponse>} response The response of the add tags action.
+         * @returns {Array<Object>} response.tagFetchResults - The results of the tag fetch operation.
+         * @returns {string} response.actionResult - The result of the action, if 'getActionResult' is set to true. It can be the following:
+         * - 'NoChanges': No new tags were added.
+         * - 'NewGroupCreated': A new group was created.
+         * - 'ItemsUpdated': Existing items were replaced with new tags.
+         * - 'ItemsAdded': New tags were added to the existing items.
+         */
+        tags: <T extends boolean | undefined>(args: import("./selectionMenu/selectionTreeStore/actions/addTag.action.types").AddTagsArgs & {
+            getActionResult?: T;
+        }) => Promise<import("./selectionMenu/selectionTreeStore/selectionTree.store.types").AddTagsReturnType<T>>;
         /**
          * Adds work orders to a specified list in the selection menu panel.
          *
          * @param {Object} args - The arguments for adding work orders.
-         * @param {string} args.listId - Optional. The ID of the list to which the work orders should be added. If not provided, the default work order list ID is used.
+         * @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.
-         *
-         * @example
-         * addWorkOrders({ listId: '456', items: [{ id: 'wo1', name: 'Work Order 1' }, { id: 'wo2', name: 'Work Order 2' }] });
          */
         workOrders: (args: {
-            listId?: string;
+            groupId?: import("dist/libs/echo-utils/src").Guid;
             items: Readonly<Readonly<import("./globalSelectionStore/globalSelectionStore.types").OptimizedWorkOrderDto>[]>;
         }) => void;
         /**
          * Adds items to a specified list in the selection menu panel.
          *
          * @param {Object} args - The arguments for adding items.
-         * @param {string} args.listId - Optional. The ID of the list to which the items should be added. If not provided, the default list ID is used.
+         * @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.
          *
          */
         addItems: (args: {
-            listId?: string;
+            groupId? /**
+             * Removes a group or category by ID from the selection store.
+             *
+             * If a categoryId is provided, it removes all items from the specified category within the group.
+             * If no categoryId is provided, it removes the entire group and all its items.
+             *
+             * @param {Object} args - The function arguments.
+             * @param {Guid} args.groupId - The ID of the group to remove.
+             * @param {GlobalSelectionCategoryId} [args.categoryId] - The ID of the category to remove (optional).
+             */: import("dist/libs/echo-utils/src").Guid;
             itemIds: (GlobalSelectionTypes.TagId | import("./globalSelectionStore/globalSelectionStore.types").OptimizedWorkOrderDto)[];
         }) => void;
     }>;
-    search: Readonly<{
-        /**
-         * Checks if a given item ID is present in a specified list.
-         *
-         * @param args - An object containing the item ID and the list ID.
-         * @param {GlobalSelectionTypes.ItemId} args.itemId - The ID of the item to check for.
-         * @param {string} args.listId - The ID of the list to search within.
-         * @returns {boolean} A boolean indicating whether the item ID is found in the list.
-         */
-        isItemIdInList: (args: {
-            itemId: GlobalSelectionTypes.ItemId;
-            listId: string;
-        }) => boolean;
+    search: {
         /**
          * Checks if a given item ID is present in the selection lists.
          *
@@ -106,33 +111,27 @@ export declare const globalSelectionApi: Readonly<{
         isItemIdInTheSelection: (args: {
             itemId: GlobalSelectionTypes.ItemId;
         }) => boolean;
-        /**
-         * Finds a selection list by its ID from a given list of selection menu lists.
-         * If the list is not found at the top level, it searches within the sublists of each top-level list.
-         *
-         * @param args - The arguments object.
-         * @param {string} args.listId - The ID of the selection list to find.
-         * @returns {SelectionMenuList | undefined} The selection menu list with the specified ID, or `undefined` if not found.
-         */
-        findListById: (listId: string) => import("./selectionMenu/selectionMenuStore/selectionMenu.store.types").SelectionMenuList | undefined;
-    }>;
+        findGroupByLabel: (args: {
+            label: string;
+        }) => import("dist/libs/echo-utils/src").Guid | undefined;
+    };
     visibility: Readonly<{
         setByItemIds: (args: {
             itemIds: Readonly<Readonly<GlobalSelectionTypes.ItemId>>[];
             isVisible: boolean;
         }) => void;
         /**
-         * Sets the visibility of items in a specified list in the selection menu store.
+         * Sets the visibility of items in a specified list in global selection.
          *
          * @param {Object} args - The arguments for setting visibility.
-         * @param {string} args.listId - The ID of the list for which the visibility should be set.
+         * @param {Guid} args.groupId - The ID of the group for which the visibility should be set.
+         * @param {GlobalSelectionCategoryId} args.categoryId - Optional. The ID of the category for which the visibility should be set.
+         * If not passed, every item's visibility in the given group will be set.
          * @param {boolean} args.isVisible - The visibility state to set for the items in the list.
-         *
-         * @example
-         * setVisibilityByListId({ listId: '123', isVisible: true });
          */
-        setByListId: (args: {
-            listId: string;
+        setById: (args: {
+            groupId: import("dist/libs/echo-utils/src").Guid;
+            categoryId?: GlobalSelectionCategoryId;
             isVisible: boolean;
         }) => void;
     }>;
@@ -174,38 +173,22 @@ export declare const globalSelectionApi: Readonly<{
          */
         reset: () => void;
     }>;
+    utils: Readonly<{
+        /**
+         * Calculates the total number of items in the selection.
+         * Each instance of the same item is counted separately.
+         *
+         * @param {SelectionTreeTypes.Group[]} [groups] - Optional list of groups to calculate the total number of items for. If not provided, the current state of the selection tree store is used.
+         * @returns {number} The total number of items in all categories of the given groups.
+         */
+        numberOfItemsInSelection: (groups?: SelectionTreeTypes.Group[]) => number;
+    }>;
     /**
      * Removes all items from the selection menu panel.
      */
     clearSelection: () => void;
+    createGroup: (args: {
+        label: string;
+        subLabel: string;
+    }) => import("dist/libs/echo-utils/src").Guid;
 }>;
-interface UseGlobalSelectionStore {
-    addTagToSelection: (tagId: GlobalSelectionTypes.TagId) => Promise<ResultValue<TagSummaryDto>>;
-    removeItemFromSelection: (tagId: GlobalSelectionTypes.TagId) => void;
-}
-interface GlobalSelectionState {
-    resetItemErrorStatuses: typeof globalSelectionApi.errorStatus.reset;
-    setErrorStatusForItems: typeof globalSelectionApi.errorStatus.setByItemIds;
-}
-interface UseGlobalSelectionStoreFunction extends UseGlobalSelectionStore {
-    (): UseGlobalSelectionStore;
-    getState: () => GlobalSelectionState;
-}
-/**
- * @deprecated Do not use this! Will be removed soon.
- * Only made for 3D team to maintain some legacy API they are using.
- * Please use globalSelectionApi instead (find the new functions to call below)
- *
- * Old --> New
- * ---------------------------------------------
- * addTagToSelection() --> globalSelectionApi.add.tags()
- *       - Now returns with ResultArray instead of Result: Promise<ResultArray<TagSummaryDto>[]>
- * removeItemFromSelection() --> globalSelectionApi.removeItemsByListId()
- *       - Now a listId is required as well.
- *       - Use SelectionMenuDefaultListIds.TagList from echo-framework for removing item from the default tag list.
- *
- * resetItemErrorStatuses() --> globalSelectionApi.errorStatus.reset()
- * setErrorStatusForItems() --> globalSelectionApi.errorStatus.setByItemIds()
- */
-export declare const useGlobalSelectionStore: UseGlobalSelectionStoreFunction;
-export {};

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

@@ -47,7 +47,7 @@ export interface GlobalSelectionStore {
     }) => void;
     addTagsToSelection: (args: {
         tagIds: Readonly<GlobalSelectionTypes.TagId[]>;
-    }) => Promise<ResultArray<TagSummaryDto>[]>;
+    }) => Promise<AddTagActionResult>;
     removeItemsFromSelection: (args: {
         itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
     }) => void;
@@ -64,6 +64,11 @@ export interface GlobalSelectionStore {
         itemIds: Readonly<GlobalSelectionTypes.ItemId[]>;
     }) => void;
 }
+type GlobalSelectionActionResult = 'NoChanges' | 'ItemsAdded';
+type AddTagActionResult = {
+    fetchResult: ResultArray<TagSummaryDto>[];
+    actionResult: GlobalSelectionActionResult;
+};
 export declare namespace GlobalSelectionTypes {
     type WorkOrderId = Pick<OptimizedWorkOrderDto, 'workOrderId'>;
     type EquipmentId = Pick<Equipment, 'equipmentId'>;
@@ -83,6 +88,7 @@ export declare namespace GlobalSelectionTypes {
     type EquipmentList = EquipmentGlobalSelectionList;
     type ListUnion = GlobalSelectionListUnion;
     type ItemTypeToDataMap = GlobalSelectionItemTypeToDataMap;
+    type AddTagResult = AddTagActionResult;
 }
 export interface OptimizedWorkOrderDto {
     workOrderId: string;

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

@@ -31,7 +31,7 @@ declare function mapToId(item: GlobalSelectionTypes.WorkOrderId): GlobalSelectio
 declare function mapToId(item: GlobalSelectionTypes.EquipmentId): GlobalSelectionTypes.EquipmentId;
 declare function mapToId(item: GlobalSelectionTypes.TagId): GlobalSelectionTypes.TagId;
 declare function mapToId(item: GlobalSelectionTypes.ItemId): GlobalSelectionTypes.ItemId;
-declare function itemIdToString(itemId: Record<string, string | number>): string;
+declare function itemIdToString(itemId: GlobalSelectionTypes.ItemId): string;
 /**
  * A utility object that provides various functions for handling global selections.
  *

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

@@ -0,0 +1,11 @@
+import { Guid } from '@equinor/echo-utils';
+import { SelectionTreeTypes } from '../selectionMenu/selectionTreeStore/selectionTree.store.types';
+/**
+ * Custom hook to get the selection categories by group ID from the global selection tree hiearchy.
+ *
+ * This hook retrieves the categories for a given group ID from the selection tree store.
+ *
+ * @param {Guid} groupId - The ID of the group to get categories for.
+ * @returns {SelectionTreeTypes.Category[] | undefined} The categories for the given group ID, or undefined if not found.
+ */
+export declare function useSelectionCategoriesByGroupId(groupId: Guid): SelectionTreeTypes.Category[] | undefined;

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

@@ -1,4 +1,4 @@
-export { globalSelectionApi, useGlobalSelectionStore } from './globalSelection.api';
+export { globalSelectionApi } from './globalSelection.api';
 export * from './globalSelectionStore/globalSelectionStore.types';
 export { globalSelectionUtils } from './globalSelectionStore/globalSelectionStore.utils';
 export { convertGlobalSelectionItemsToPlantTagPairs } from './globalSelectionStore/globalSelectionStoreHelpers';
@@ -6,4 +6,7 @@ export { useGlobalSelectionItems } from './hooks/useGlobalSelectionItems';
 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 * from './selectionMenu/selectionTreeStore/selectionTree.store.types';

package/src/lib/feature/globalSelection/selectionMenu/hooks/{useAllItemsHiddenByUser.d.ts → useIsAllIGlobalSelectionItemsHidden.d.ts}

@@ -1,7 +1,13 @@
+import { Guid } from '@equinor/echo-utils';
+interface useIsAllIGlobalSelectionItemsHiddenArgs {
+    groupId: Guid;
+    categoryId?: string;
+}
 /**
  * Custom hook to determine if all items in a selection list are hidden by the user.
  *
- * @param {string} listId - The ID of the selection list to check.
+ * @param {Guid} groupId - The ID of the list group.
+ * @param {string} [categoryId] - The ID of the category, inside the given list group.
  * @returns {boolean} - A boolean indicating whether all items in the list are hidden by the user.
  *
  * This hook uses the `useGlobalSelectionLists` hook to get the current global selection state and
@@ -9,4 +15,5 @@
  *
  * The hook returns `true` if all items in the list are hidden by the user, and `false` otherwise.
  */
-export declare const useAllItemsHiddenByUser: (listId: string) => boolean;
+export declare const useIsAllIGlobalSelectionItemsHidden: (args: useIsAllIGlobalSelectionItemsHiddenArgs) => boolean;
+export {};

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

@@ -0,0 +1,7 @@
+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.
+ */
+export declare function useSelectionMenuGroups(): SelectionTreeTypes.Group[];

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

@@ -0,0 +1,13 @@
+import { ResultArray, TagSummaryDto } from '@equinor/echo-search';
+import { WritableDraft } from 'immer';
+import { StoreApi } from 'zustand';
+import { SelectionTreeStore } from '../selectionTree.store.types';
+import { AddTagsArgs, AddTagsResponse } from './addTag.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 & {
+    getActionResult: true;
+}): Promise<AddTagsResponse>;
+export declare function addTagsAction(set: SetFunction, get: StoreApi<SelectionTreeStore>['getState'], args: AddTagsArgs & {
+    getActionResult?: false;
+}): Promise<ResultArray<TagSummaryDto>[]>;
+export {};

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

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

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

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

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

@@ -0,0 +1,22 @@
+import { SelectionTreeStore } from './selectionTree.store.types';
+export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<SelectionTreeStore>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: SelectionTreeStore | Partial<SelectionTreeStore> | ((state: SelectionTreeStore) => SelectionTreeStore | Partial<SelectionTreeStore>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: SelectionTreeStore, previousSelectedState: SelectionTreeStore) => void): () => void;
+        <U>(selector: (state: SelectionTreeStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: SelectionTreeStore | Partial<SelectionTreeStore> | ((state: import("immer").WritableDraft<SelectionTreeStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: string;
+    } | undefined): void;
+}>;
+/**
+ * Get a snapshot of the current selection tree store state.
+ */
+export declare function getSelectionTreeStoreSnapshot(): SelectionTreeStore;

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

@@ -0,0 +1,83 @@
+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;
+export declare enum GlobalSelectionCategoryId {
+    Tags = "DEFAULT_TAG_LIST_ID",
+    WorkOrders = "DEFAULT_WORK_ORDER_LIST_ID"
+}
+export declare const globalSelectionDefaultGroupId: Guid;
+/**  @deprecated Use GlobalSelectionCategoryId instead */
+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;
+}
+interface SelectionBase {
+    label: string;
+    subLabel?: string;
+}
+export interface SelectionCategory extends SelectionBase {
+    id: GlobalSelectionCategoryId;
+    items: SelectionItem[];
+}
+export interface SelectionGroup extends SelectionBase {
+    id: Guid;
+    categories: SelectionCategory[];
+}
+export interface SelectionTreeStore {
+    groups: SelectionGroup[];
+    addTags: <T extends boolean | undefined>(args: AddTagsArgs & {
+        getActionResult?: T;
+    }) => Promise<AddTagsReturnType<T>>;
+    addWorkOrders: (args: {
+        groupId?: Guid;
+        items: Readonly<Readonly<OptimizedWorkOrderDto>[]>;
+    }) => void;
+    addItems: (args: {
+        groupId?: Guid;
+        itemIds: (GlobalSelectionTypes.TagId | OptimizedWorkOrderDto)[];
+    }) => void;
+    createGroup: (args: {
+        label: string;
+        subLabel: string;
+    }) => Guid;
+    removeGroupById: (args: {
+        groupId: Guid;
+        categoryId?: GlobalSelectionCategoryId;
+    }) => void;
+    findGroupIdByLabel: (args: {
+        label: string;
+    }) => Guid | undefined;
+    removeItemsById: (args: {
+        groupId?: Guid;
+        categoryId: GlobalSelectionCategoryId;
+        itemIds: GlobalSelectionTypes.ItemId[];
+    }) => void;
+    setVisibilityById: (args: {
+        groupId: Guid;
+        categoryId?: GlobalSelectionCategoryId;
+        isVisible: boolean;
+    }) => void;
+    resetState: () => void;
+}
+export declare namespace SelectionTreeTypes {
+    type Category = SelectionCategory;
+    type Group = SelectionGroup;
+    type Item = SelectionItem;
+    type ActionResult = SelectionTreeActionResult;
+}
+export type AddTagsReturnType<T extends boolean | undefined> = T extends true ? Promise<AddTagsResponse> : Promise<ResultArray<TagSummaryDto>[]>;
+export {};