@equinor/echo-framework 0.20.23-beta-0 → 0.21.0-beta-0

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "0.20.23-beta-0",
+  "version": "0.21.0-beta-0",
   "peerDependencies": {
     "@equinor/echo-base": ">= 0.7.0 < 0.8.0",
-    "@equinor/echo-components": ">= 0.11.0 < 0.12.0",
+    "@equinor/echo-components": ">= 0.11.0 < 0.12.0-beta-0",
     "@equinor/echo-core": ">= 0.9.0 < 0.10.0",
     "@equinor/echo-search": ">= 0.15.0 < 0.16.0",
     "@equinor/echo-utils": ">= 0.4.0 < 0.5.0",
-    "@equinor/eds-core-react": "0.34.0",
-    "@equinor/eds-icons": "0.19.3",
+    "@equinor/eds-core-react": "0.43.0",
+    "@equinor/eds-icons": "0.22.0",
     "react": ">= 17.0.2",
     "react-dom": ">= 17.0.2",
     "@tanstack/react-query": ">= 5.14.2 < 6",

package/src/index.d.ts

@@ -3,9 +3,9 @@ import './lib/globalStyles.css';
 import { getPlantsInfo, getTagDetails } from './lib/services/api';
 export * from './lib/components';
 export { PrepviewButton } from './lib/components/prepviewButton/prepviewButton';
+export { useFetchPlantInfo } from './lib/components/requestAccess/hooks/fetchPlantInfo';
 export { RequestProCoSysAccess } from './lib/components/requestAccess/RequestProCoSysAccess';
 export { RequestSapAccess } from './lib/components/requestAccess/RequestSapAccess';
-export { useFetchPlantInfo } from './lib/components/requestAccess/hooks/fetchPlantInfo';
 export { WorkOrderListItem } from './lib/components/workOrderListItem';
 export * from './lib/coreApplication';
 export { fetchEquipmentFromApi } from './lib/feature/equipment/api/api-equipmentWithMeasuringPoints';
@@ -14,20 +14,17 @@ export * from './lib/feature/globalSelection';
 export { SelectionActionBar } from './lib/feature/globalSelection/components/SelectionActionBar';
 export type { OptimizedWorkOrderDto } from './lib/feature/globalSelection/globalSelectionStore/globalSelectionStore.types';
 export { PanTo3DButton } from './lib/feature/globalSelection/panToEcho3d/panTo3DButton';
-export { useIsAllIGlobalSelectionItemsHidden } from './lib/feature/globalSelection/selectionMenu/hooks/useIsAllIGlobalSelectionItemsHidden';
-export { GlobalSelectionCategoryId, SelectionMenuDefaultListIds } from './lib/feature/globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.types';
+export { 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 * from './lib/feature/legacyLegend/index';
-export * from './lib/feature/legend';
-export { PositionalLegendMarkers } from './lib/feature/legend/components/pdfMarkers/PositionalLegendMarkers';
-export * from './lib/feature/legend/index';
-export { subscribeToLegendDataChanged } from './lib/feature/legend/legendUpdater';
-export type { LegendDataId, LegendEquipmentId, LegendState, LegendTagId } from './lib/feature/legend/types/legendType';
 export { getLatestMeasurementDate, sortMeasuringPointsByMeasurementDate } from './lib/feature/measuringPoint/components/measuringPoints.utils';
 export * from './lib/feature/measuringPoint/index';
 export * from './lib/feature/measuringPoint/types/measuringPoint';
 export * from './lib/feature/openItemsIn3d';
-export { OpenIn3dSelectedItemsMenu } from './lib/feature/openItemsIn3d/OpenIn3dSelectedItemsMenu';
 export { createEcho3dInternalLink } from './lib/feature/openItemsIn3d/logic/createEcho3dInternalLink';
+export { OpenIn3dSelectedItemsMenu } from './lib/feature/openItemsIn3d/OpenIn3dSelectedItemsMenu';
 export { WorkOrderContent } from './lib/feature/workOrder/WorkOrderContent';
 export { RegisteredHookName } from './lib/hooks/hookLibrary';
 export { useCloseActiveTopMenuAtBreakPoint } from './lib/hooks/useCloseActiveTopMenuAtBreakPoint';

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

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

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

@@ -1,8 +1,33 @@
+import { ResultValue, TagSummaryDto } from '@equinor/echo-search';
 import { GlobalSelectionTypes } from './globalSelectionStore/globalSelectionStore.types';
-import { GlobalSelectionCategoryId, SelectionTreeTypes } from './selectionMenu/selectionTreeStore/selectionTree.store.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.
+ */
 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.
@@ -16,81 +41,61 @@ 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 {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.
+         * @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' }] });
          */
         tags: (args: {
-            groupId? /**
-             * Removes items from a specified list in the selection menu panel by their IDs.
-             *
-             * @param {Object} args - The arguments for removing items.
-             * @param {Readonly<GlobalSelectionTypes.ItemId[]>} args.itemIds - An array of item IDs representing the items to be removed.
-             * @param {Guid} args.groupId - Optional. The ID of the list where the subList of the items are located.
-             * Local selection will be used by default.
-             * @param {GlobalSelectionCategoryId} args.category - The ID of the list where the items to be removed are located.
-             */: import("dist/libs/echo-utils/src").Guid;
+            listId?: string;
             itemIds: Readonly<GlobalSelectionTypes.TagId[]>;
-        }) => Promise<import("dist/libs/echo-search/src").ResultArray<import("dist/libs/echo-search/src").TagSummaryDto>[]>;
+        }) => Promise<import("@equinor/echo-search").ResultArray<TagSummaryDto>[]>;
         /**
          * Adds work orders to a specified list in the selection menu panel.
          *
          * @param {Object} args - The arguments for adding work orders.
-         * @param {Guid} args.groupId - Optional. The ID of the list to which the work orders should be added. If not provided, it will be added to the "Local Selection".
+         * @param {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 {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: {
-            groupId?: import("dist/libs/echo-utils/src").Guid;
+            listId?: string;
             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 {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 {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 {GlobalSelectionTypes.TagId | OptimizedWorkOrderDto)[]} args.itemIds - ItemIds to be added. Only tags or work orders can be added for now.
          *
          */
         addItems: (args: {
-            groupId?: import("dist/libs/echo-utils/src").Guid;
+            listId?: string;
             itemIds: (GlobalSelectionTypes.TagId | import("./globalSelectionStore/globalSelectionStore.types").OptimizedWorkOrderDto)[];
         }) => void;
     }>;
-    search: {
+    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;
         /**
          * Checks if a given item ID is present in the selection lists.
          *
@@ -101,27 +106,33 @@ export declare const globalSelectionApi: Readonly<{
         isItemIdInTheSelection: (args: {
             itemId: GlobalSelectionTypes.ItemId;
         }) => boolean;
-        findGroupByLabel: (args: {
-            label: string;
-        }) => import("dist/libs/echo-utils/src").Guid | undefined;
-    };
+        /**
+         * 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;
+    }>;
     visibility: Readonly<{
         setByItemIds: (args: {
             itemIds: Readonly<Readonly<GlobalSelectionTypes.ItemId>>[];
             isVisible: boolean;
         }) => void;
         /**
-         * Sets the visibility of items in a specified list in global selection.
+         * Sets the visibility of items in a specified list in the selection menu store.
          *
          * @param {Object} args - The arguments for setting visibility.
-         * @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 {string} args.listId - The ID of the list for which the visibility should be set.
          * @param {boolean} args.isVisible - The visibility state to set for the items in the list.
+         *
+         * @example
+         * setVisibilityByListId({ listId: '123', isVisible: true });
          */
-        setById: (args: {
-            groupId: import("dist/libs/echo-utils/src").Guid;
-            categoryId?: GlobalSelectionCategoryId;
+        setByListId: (args: {
+            listId: string;
             isVisible: boolean;
         }) => void;
     }>;
@@ -163,22 +174,38 @@ 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: GlobalSelectionTypes.ItemId): string;
+declare function itemIdToString(itemId: Record<string, string | number>): string;
 /**
  * A utility object that provides various functions for handling global selections.
  *

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

@@ -1,4 +1,4 @@
-export { globalSelectionApi } from './globalSelection.api';
+export { globalSelectionApi, useGlobalSelectionStore } from './globalSelection.api';
 export * from './globalSelectionStore/globalSelectionStore.types';
 export { globalSelectionUtils } from './globalSelectionStore/globalSelectionStore.utils';
 export { convertGlobalSelectionItemsToPlantTagPairs } from './globalSelectionStore/globalSelectionStoreHelpers';
@@ -6,7 +6,4 @@ 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/{useIsAllIGlobalSelectionItemsHidden.d.ts → useAllItemsHiddenByUser.d.ts}

@@ -1,13 +1,7 @@
-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 {Guid} groupId - The ID of the list group.
- * @param {string} [categoryId] - The ID of the category, inside the given list group.
+ * @param {string} listId - The ID of the selection list to check.
  * @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
@@ -15,5 +9,4 @@ interface useIsAllIGlobalSelectionItemsHiddenArgs {
  *
  * The hook returns `true` if all items in the list are hidden by the user, and `false` otherwise.
  */
-export declare const useIsAllIGlobalSelectionItemsHidden: (args: useIsAllIGlobalSelectionItemsHiddenArgs) => boolean;
-export {};
+export declare const useAllItemsHiddenByUser: (listId: string) => boolean;

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,28 @@
+import { SelectionMenuStore } from './selectionMenu.store.types';
+export declare enum SelectionMenuDefaultListIds {
+    TagList = "DEFAULT_TAG_LIST_ID",
+    WorkOrderList = "DEFAULT_WORK_ORDER_LIST_ID"
+}
+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

@@ -0,0 +1,56 @@
+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[];
+    addItems: (args: {
+        listId?: string;
+        itemIds: (GlobalSelectionTypes.TagId | OptimizedWorkOrderDto)[];
+    }) => void;
+    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 {};

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

@@ -0,0 +1,56 @@
+import { GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
+import { SelectionMenuList } from './selectionMenu.store.types';
+/**
+ * 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.
+ * @param {SelectionMenuList[]} args.lists - An optional array of selection menu lists to search within.
+ * If not provided, the function will use the lists from the selection menu store state.
+ * If you want to alter the store state, you should provide the lists as an argument.
+ * @returns {SelectionMenuList | undefined} The selection menu list with the specified ID, or `undefined` if not found.
+ */
+export declare function findSelectionListById(args: {
+    listId: string;
+    lists: SelectionMenuList[];
+}): SelectionMenuList | undefined;
+/**
+ * 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.
+ * @param {SelectionMenuList[]} args.lists - The selection menu lists where you would like to search for the given item.
+ * @returns {boolean} A boolean indicating whether the item ID is found in the list.
+ */
+export declare function isItemIdInList(args: {
+    itemId: GlobalSelectionTypes.ItemId;
+    listId: string;
+    lists: SelectionMenuList[];
+}): boolean;
+/**
+ * Checks if a given item ID is present in the selection lists.
+ *
+ * @param args - An object containing the item ID to check.
+ * @param {GlobalSelectionTypes.ItemId} args.itemId - The item ID to check for presence in the selection lists.
+ * @param {SelectionMenuList[]} args.lists - The selection menu lists where you would like to search for the given item.
+ * @returns {boolean} A boolean indicating whether the item ID is present in the selection lists.
+ */
+export declare function isItemIdInTheSelection(args: {
+    itemId?: GlobalSelectionTypes.ItemId;
+    lists: SelectionMenuList[];
+}): boolean;
+/**
+ * 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 {SelectionMenuList[]} args.list - 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 {string[]} 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 itemsNotFoundInSelectionMenu(args: {
+    lists: SelectionMenuList[];
+    itemIds: GlobalSelectionTypes.ItemId[];
+}): string[];

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

@@ -1,11 +0,0 @@
-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/selectionMenu/hooks/useSelectionMenuGroups.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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;