@equinor/echo-framework 0.20.20 → 0.20.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "0.20.20",
+  "version": "0.20.22",
   "peerDependencies": {
     "@equinor/echo-base": ">= 0.7.0 < 0.8.0",
     "@equinor/echo-components": ">= 0.11.0 < 0.12.0",

package/src/index.d.ts

@@ -11,12 +11,11 @@ export * from './lib/coreApplication';
 export { fetchEquipmentFromApi } from './lib/feature/equipment/api/api-equipmentWithMeasuringPoints';
 export * from './lib/feature/equipment/index';
 export * from './lib/feature/globalSelection';
+export { SelectionActionBar } from './lib/feature/globalSelection/components/SelectionActionBar';
 export type { OptimizedWorkOrderDto } from './lib/feature/globalSelection/globalSelectionStore/globalSelectionStore.types';
 export { PanTo3DButton } from './lib/feature/globalSelection/panToEcho3d/panTo3DButton';
-export { 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';

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

@@ -0,0 +1,7 @@
+import { GlobalSelectionTypes, OptimizedWorkOrderDto } from '../globalSelectionStore/globalSelectionStore.types';
+import { GlobalSelectionCategoryId } from '../selectionMenu/selectionTreeStore/selectionTree.store.types';
+export interface SelectionActionBarProps {
+    itemId: GlobalSelectionTypes.TagId | OptimizedWorkOrderDto;
+    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,49 +16,81 @@ export declare const globalSelectionApi: Readonly<{
         listId: string;
         itemIds: GlobalSelectionTypes.ItemId[];
     }) => void;
+    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;
+        /**
+         * 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).
+         */
+        listById: (args: {
+            groupId: import("dist/libs/echo-utils/src").Guid;
+            categoryId?: GlobalSelectionCategoryId;
+        }) => void;
+    }>;
     add: Readonly<{
         /**
          * Adds tags to a specified list in the selection menu panel.
          *
          * @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.
-         *
-         * @example
-         * addTags({ listId: '123', items: [{ id: 'tag1', name: 'Tag 1' }, { id: 'tag2', name: 'Tag 2' }] });
+         * @param {Guid} args.groupId - Optional - The ID of the group to which the tags should be added. If not provided, it will be added to the "Local Selection".
+         * @param {Readonly<GlobalSelectionTypes.TagId[]>} args.itemIds - An array of TagId objects representing the tags to be added.
          */
         tags: (args: {
-            listId?: string;
+            groupId? /**
+             * Removes items from a specified list in the selection menu panel by their IDs.
+             *
+             * @param {Object} args - The arguments for removing items.
+             * @param {Readonly<GlobalSelectionTypes.ItemId[]>} args.itemIds - An array of item IDs representing the items to be removed.
+             * @param {Guid} args.groupId - Optional. The ID of the list where the subList of the items are located.
+             * Local selection will be used by default.
+             * @param {GlobalSelectionCategoryId} args.category - The ID of the list where the items to be removed are located.
+             */: import("dist/libs/echo-utils/src").Guid;
             itemIds: Readonly<GlobalSelectionTypes.TagId[]>;
-        }) => Promise<import("@equinor/echo-search").ResultArray<TagSummaryDto>[]>;
+        }) => Promise<import("dist/libs/echo-search/src").ResultArray<import("dist/libs/echo-search/src").TagSummaryDto>[]>;
         /**
          * 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;
-    }>;
-    search: Readonly<{
         /**
-         * Checks if a given item ID is present in a specified list.
+         * Adds items to a specified list in the selection menu panel.
+         *
+         * @param {Object} args - The arguments for adding items.
+         * @param {Guid} args.groupId - Optional. The ID of the list to which the items should be added. If not provided, the default list ID is used.
+         * @param {GlobalSelectionTypes.TagId | OptimizedWorkOrderDto)[]} args.itemIds - ItemIds to be added. Only tags or work orders can be added for now.
          *
-         * @param 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;
+        addItems: (args: {
+            groupId?: import("dist/libs/echo-utils/src").Guid;
+            itemIds: (GlobalSelectionTypes.TagId | import("./globalSelectionStore/globalSelectionStore.types").OptimizedWorkOrderDto)[];
+        }) => void;
+    }>;
+    search: {
         /**
          * Checks if a given item ID is present in the selection lists.
          *
@@ -94,33 +101,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;
     }>;
@@ -162,38 +163,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 | undefined;
 }>;
-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.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/useIsInGlobalSelection.d.ts

@@ -0,0 +1,8 @@
+import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
+/**
+ * Hook to check if an item is in the global selection
+ * @param {GlobalSelectionTypes.ItemId} itemId - The itemId
+ * @param {GlobalSelectionItemType} itemType - The item type
+ * @returns {boolean} - True if the item is in global selection, false otherwise
+ */
+export declare function useIsInGlobalSelection(itemId: GlobalSelectionTypes.ItemId): boolean;

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

@@ -0,0 +1,37 @@
+import { SelectionTreeStore } from './selectionTree.store.types';
+/**
+ * Store for the selection menu, in a left panel.
+ *
+ * Stores the hierachry, tree structure of the items in Global Selection.
+ * With this, it is in charge of:
+ *   - tracking which item belongs to which list
+ *   - adding items to global selection
+ *   - remove items from global selection
+ *   - update items (visibility, removal etc.) via list ids
+ *   - maintaining the global selection store based on the changes in the items, in the selection menu panel
+ *
+ * You shouldn't use this store directly in any code, unless you have very special reason to do so.
+ *
+ * For accessing and using global selection features, use the globalSelectionApi from echo-framework.
+ */
+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,84 @@
+import { ResultArray, TagSummaryDto } from '@equinor/echo-search';
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionItemType, GlobalSelectionTypes, OptimizedWorkOrderDto } from '../../globalSelectionStore/globalSelectionStore.types';
+type SelectionItem = SelectionItemTag | SelectionItemWorkOrder | SelectionItemEquipment;
+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"
+}
+interface SelectionItemTag {
+    id: GlobalSelectionTypes.TagId;
+    type: GlobalSelectionItemType.Tag;
+}
+interface SelectionItemWorkOrder {
+    id: GlobalSelectionTypes.WorkOrderId;
+    type: GlobalSelectionItemType.WorkOrder;
+}
+interface SelectionItemEquipment {
+    id: GlobalSelectionTypes.EquipmentId;
+    type: GlobalSelectionItemType.Equipment;
+}
+interface SelectionBase {
+    label: string;
+    subLabel?: string;
+}
+interface SelectionCategory extends SelectionBase {
+    id: GlobalSelectionCategoryId;
+    items: SelectionItem[];
+}
+interface SelectionGroup extends SelectionBase {
+    id: Guid;
+    categories: SelectionCategory[];
+}
+export interface SelectionTreeStore {
+    groups: SelectionGroup[];
+    addTags: (args: {
+        groupId?: Guid;
+        itemIds: Readonly<GlobalSelectionTypes.TagId[]>;
+    }) => Promise<ResultArray<TagSummaryDto>[]>;
+    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 | undefined;
+    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 TagItem = SelectionItemTag;
+    type WorkOrderItem = SelectionItemWorkOrder;
+    type EquipmentItem = SelectionItemEquipment;
+}
+export {};

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

@@ -0,0 +1,53 @@
+import { GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
+import { SelectionTreeTypes } from './selectionTree.store.types';
+/**
+ * Check if an item ID is present in the selection tree.
+ *
+ * This function checks if a given item ID is present in the selection tree within a specific group and category.
+ * If groupId or categoryId is not provided, it checks all groups and categories.
+ *
+ * @param {Object} args - The function arguments.
+ * @param {GlobalSelectionTypes.ItemId} args.itemId - The ID of the item to check.
+ * @param {string} [args.groupId] - The ID of the group to check within (optional).
+ * @param {string} [args.categoryId] - The ID of the category to check within (optional).
+ * @param {SelectionTreeTypes.Group[]} args.groups - The selection tree groups to check within.
+ * @returns {boolean} True if the item ID is present in the selection tree, false otherwise.
+ */
+export declare function isItemIdInSelectionTree(args: {
+    itemId: GlobalSelectionTypes.ItemId;
+    groupId?: string;
+    categoryId?: string;
+    groups: SelectionTreeTypes.Group[];
+}): boolean;
+/**
+ * Find a selection category by group ID and optionally category ID.
+ *
+ * This function finds the group and optionally the category within the selection tree groups.
+ *
+ * @param {Object} args - The function arguments.
+ * @param {string} args.groupId - The ID of the group to search within.
+ * @param {string} [args.categoryId] - The ID of the category to search for (optional).
+ * @param {SelectionTreeTypes.Group[]} args.groups - The selection tree groups to search within.
+ * @returns {Object | undefined} The group and optionally the category, or undefined if not found.
+ */
+export declare function findSelectionCategoryById(args: {
+    groupId: string;
+    categoryId?: string;
+    groups: SelectionTreeTypes.Group[];
+}): {
+    group: SelectionTreeTypes.Group;
+    category?: SelectionTreeTypes.Category;
+} | undefined;
+/**
+ * Retrieves an array of itemIds that were not found in the selection menu.
+ *
+ * @param {Object} args - The arguments containing the list and itemIds to check.
+ * @param {SelectionTreeTypes.Group[]} args.groups - The list of SelectionMenuList objects to search through.
+ * @param {GlobalSelectionTypes.ItemId[]} args.itemIds - An array of ItemId objects to check for presence in the list.
+ * @returns {GlobalSelectionTypes.ItemId[]} An array of itemId strings that correspond to counts of 0 in the selection menu.
+ * itemIds object values are concatenated via '-' char
+ */
+export declare function itemsNotFoundInSelectionTree(args: {
+    groups: SelectionTreeTypes.Group[];
+    itemIds: GlobalSelectionTypes.ItemId[];
+}): GlobalSelectionTypes.ItemId[];

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

@@ -8,7 +8,7 @@ export declare enum LegendStatus {
     Reserved = "Reserved",
     Future = "Future",
     Historic = "Historic",
-    OutOfService = "Out Of Service",
+    OutOfService = "Out of Service",
     Voided = "Voided",
     OK = "OK",
     OS = "OS",

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

@@ -1,7 +0,0 @@
-import { SelectionMenuList } from '../selectionMenuStore/selectionMenu.store.types';
-/**
- * Custom hook to get the selection menu lists from the selection menu store, displayed in the left selection panel.
- *
- * @returns {SelectionMenuList[]} - An array of selection menu lists.
- */
-export declare function useSelectionMenuLists(): SelectionMenuList[];

package/src/lib/feature/globalSelection/selectionMenu/selectionMenuStore/selectionMenu.store.d.ts

@@ -1,43 +0,0 @@
-import { SelectionMenuStore } from './selectionMenu.store.types';
-export declare enum SelectionMenuDefaultListIds {
-    TagList = "DEFAULT_TAG_LIST_ID",
-    WorkOrderList = "DEFAULT_WORK_ORDER_LIST_ID"
-}
-/**
- * Store for the selection menu, in a left panel.
- *
- * Stores the hierachry, tree structure of the items in Global Selection.
- * With this, it is in charge of:
- *   - tracking which item belongs to which list
- *   - adding items to global selection
- *   - remove items from global selection
- *   - update items (visibility, removal etc.) via list ids
- *   - maintaining the global selection store based on the changes in the items, in the selection menu panel
- *
- * You shouldn't use this store directly in any code, unless you have very special reason to do so.
- *
- * For accessing and using global selection features, use the globalSelectionApi from echo-framework.
- */
-export declare const useSelectionMenuStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<SelectionMenuStore>, "setState"> & {
-    setState<A extends string | {
-        type: string;
-    }>(partial: SelectionMenuStore | Partial<SelectionMenuStore> | ((state: SelectionMenuStore) => SelectionMenuStore | Partial<SelectionMenuStore>), replace?: boolean | undefined, action?: A | undefined): void;
-}, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: SelectionMenuStore, previousSelectedState: SelectionMenuStore) => void): () => void;
-        <U>(selector: (state: SelectionMenuStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}, "setState"> & {
-    setState(nextStateOrUpdater: SelectionMenuStore | Partial<SelectionMenuStore> | ((state: import("immer").WritableDraft<SelectionMenuStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
-        type: string;
-    } | undefined): void;
-}>;
-/**
- * Get a snapshot of the current selection menu store state.
- *
- * Selection menu: left panel, which holds items from global selection.
- */
-export declare function getSelectionMenuStoreSnapshot(): SelectionMenuStore;

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

@@ -1,52 +0,0 @@
-import { ResultArray, TagSummaryDto } from '@equinor/echo-search';
-import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionItemType, GlobalSelectionTypes, OptimizedWorkOrderDto } from '../../globalSelectionStore/globalSelectionStore.types';
-import { SelectionMenuDefaultListIds } from './selectionMenu.store';
-export type SelectionMenuItem = SelectionMenuTag | SelectionMenuWorkOrder | SelectionMenuEquipment;
-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;
-}
-export type SelectionMenuList = SelectionMenuWithItems | SelectionMenuWithSubLists;
-interface SelectionMenuBase {
-    id: Guid | SelectionMenuDefaultListIds;
-    label: string;
-}
-interface SelectionMenuWithItems extends SelectionMenuBase {
-    items: SelectionMenuItem[];
-    subLists?: never;
-}
-interface SelectionMenuWithSubLists extends SelectionMenuBase {
-    subLists: SelectionMenuWithItems[];
-    items?: never;
-}
-export interface SelectionMenuStore {
-    lists: SelectionMenuList[];
-    addTags: (args: {
-        listId?: string;
-        itemIds: Readonly<GlobalSelectionTypes.TagId[]>;
-    }) => Promise<ResultArray<TagSummaryDto>[]>;
-    addWorkOrders: (args: {
-        listId?: string;
-        items: Readonly<Readonly<OptimizedWorkOrderDto>[]>;
-    }) => void;
-    addList: (args: SelectionMenuList) => void;
-    removeItemsByListId: (args: {
-        listId: string;
-        itemIds: GlobalSelectionTypes.ItemId[];
-    }) => void;
-    setVisibilityByListId: (args: {
-        listId: string;
-        isVisible: boolean;
-    }) => void;
-    resetState: () => void;
-}
-export {};