@equinor/echo-framework 0.20.15 → 0.20.16

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,43 @@
+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

@@ -0,0 +1,52 @@
+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 {};

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/hooks/useAddTagToLegendRegistry.d.ts

@@ -1,4 +1,4 @@
-import { LegendItemStatus } from '../legend';
+import { LegendItemStatus } from '../legacyLegend';
 /**
  * @deprecated Don't use this - the current legend registry service is a heavily outdated solution,
  * we shouldn't increase the tech dept even further.

package/src/lib/feature/measuringPoint/components/measuringPointDetails/mediaItemView/NavigationButton.d.ts

@@ -0,0 +1,8 @@
+type Direction = 'previous' | 'next';
+interface NavigationButtonProps {
+    direction: Direction;
+    onClick: () => void;
+    disabled?: boolean;
+}
+export declare const NavigationButton: React.FC<NavigationButtonProps>;
+export {};

package/src/lib/feature/measuringPoint/components/measuringPointDetails/mediaItemView/desktopMediaView.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface DesktopMediaViewProps {
+    imageSrc: string;
+    showPrevious: () => void;
+    showNext: () => void;
+    showNextIcon: boolean;
+    showPrevIcon: boolean;
+}
+export declare const DesktopMediaView: React.FC<React.PropsWithChildren<DesktopMediaViewProps>>;
+export {};

package/src/lib/feature/measuringPoint/components/measuringPointDetails/mediaItemView/mediaViewUtils.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { SwipeableProps } from 'react-swipeable';
+export declare const Swipeable: React.FC<React.PropsWithChildren<SwipeableProps>>;

package/src/lib/feature/measuringPoint/components/measuringPointDetails/mediaItemView/mobileMediaView.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface MobileMediaViewProps {
+    imageSrc: string;
+    showPrevious: () => void;
+    showNext: () => void;
+    showNextIcon: boolean;
+    showPrevIcon: boolean;
+}
+export declare const MobileMediaView: React.FC<React.PropsWithChildren<MobileMediaViewProps>>;
+export {};

package/src/lib/feature/openItemsIn3d/OpenIn3dSelectedItemsMenu.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface OpenIn3dSelectedItemsMenuProps {
+    onOpenIn3dButtonClick: () => void;
+    children?: React.ReactNode;
+    disabled?: boolean;
+}
+export declare const OpenIn3dSelectedItemsMenu: React.FC<OpenIn3dSelectedItemsMenuProps>;
+export {};

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

@@ -1,4 +1,4 @@
 export { tagIdPlantIdToPlantTagPairs } from './logic/convertToPlantTagPairs';
 export type { Plant3dInfo, PlantAndTagForOpenIn3d } from './logic/openItemsIn3d.utils';
+export { OpenIn3dSelectedItemsMenu } from './OpenIn3dSelectedItemsMenu';
 export { OpenItemsIn3dDialog } from './openItemsIn3dDialog';
-export { SelectedItemsMenu } from './SelectedItemsMenu';

package/src/lib/feature/openItemsIn3d/logic/openItemsIn3d.utils.d.ts

@@ -8,27 +8,6 @@
 export declare function getUniquePlantsWithItemCount(args: {
     items: PlantAndTagForOpenIn3d[];
 }): Plant3dInfoCount[];
-/**
- * Retrieves the items from the given array that have the same plant number as the selected plant number.
- *
- * @param selectedItems - The array of PlantTagPair objects.
- * @param selectedPlantNo - The selected plant number.
- * @returns An array of PlantTagPair objects that have the same plant number as the selected plant number.
- */
-export declare function getItemsForSelectedPlantNo(selectedItems: PlantAndTagForOpenIn3d[], selectedPlantNo: string): PlantAndTagForOpenIn3d[];
-/**
- * Checks if there are more then one unique plant numbers in the passed PlantTagPair[].
- *
- * @param items - The array of PlantTagPair objects to check.
- * @returns A boolean indicating whether multiple, unique plant numbers are present in the passed array.
- */
-export declare function isMultiplePlantNoSelected(items: PlantAndTagForOpenIn3d[]): boolean;
-/**
- * Retrieves the plant SAP ID from an array of PlantTagPair. It will return with the first, non empty plant SAP ID found.
- * @param items - The array of PlantTagPair items.
- * @returns The plant SAP ID if found, otherwise undefined.
- */
-export declare function getFirstPlantSapIdFromItems(items: PlantAndTagForOpenIn3d[]): string | undefined;
 export interface Plant3dInfo {
     instCode: string;
     sapId: string | undefined;

package/src/lib/feature/openItemsIn3d/openIn3dMenu.d.ts

@@ -1,7 +1,6 @@
 import React from 'react';
-import { ObjectsToSendTo3dTypes } from '../../utils/openIn3d/tagLists';
 interface OpenIn3dMenuProps {
-    onOpenIn3dButtonClick: (objectsToSendTo3d: ObjectsToSendTo3dTypes) => void;
+    onOpenIn3dButtonClick: () => void;
     disabled: boolean;
 }
 export declare const OpenIn3dMenu: React.FC<OpenIn3dMenuProps>;

package/src/lib/services/locationService/locationService.d.ts

@@ -0,0 +1,10 @@
+import { InternalApplicationLinks } from '../../types/navigation';
+export declare function setLocationServicePathname(pathname: InternalApplicationLinks | string): void;
+declare function isOnPage(applicationLink: InternalApplicationLinks | string): boolean;
+export declare const locationService: Readonly<{
+    isOnPage: typeof isOnPage;
+    isOnPdfViewer: () => boolean;
+    isOnEcho3dPage: () => boolean;
+    isOnHomePage: () => boolean;
+}>;
+export {};

package/src/lib/services/stores/createSimpleStore.d.ts

@@ -0,0 +1,29 @@
+type SimpleStore<T, Name extends string> = {
+    [K in Name]: T;
+} & {
+    [K in `set${Capitalize<Name>}`]: (value: T) => void;
+};
+/**
+ * Factory for creating a simple Zustand store with a value and a setter function. If more is needed, use a normal zustand store instead.
+ *
+ * The store will have the following structure:
+ * - A value corresponding to the `name` parameter.
+ * - A setter function dynamically named `set<Name>` to update the value.
+ *
+ * @template T The type of the value stored in the store (can be any type: string, number, object, etc.).
+ * @template Name The name of the state, used for both the key and the setter function.
+ *
+ * @param {T} initialValue The initial value of the store.
+ * @param {Name} name The name of the state, which will be used for the store key and setter function.
+ *
+ * @example
+ * const useCountStore = createSimpleStore(0, 'count');
+ *
+ * const { count, setCount } = useCountStore();
+ * console.log(count); // 0
+ *
+ * setCount(10);
+ * console.log(count); // 10
+ */
+export declare function createSimpleStore<T, Name extends string>(initialValue: T, name: Name): import("zustand").UseBoundStore<import("zustand").StoreApi<SimpleStore<T, Name>>>;
+export {};

package/src/lib/types/eventTypes/legendEvent.d.ts

@@ -1,4 +1,4 @@
-import { LegendItemStatus, LegendType } from '../../feature/legend/legend';
+import { LegendItemStatus, LegendType } from '../../feature/legacyLegend/legend';
 export interface LegendChangedEvent {
     newLegendType: LegendType;
 }

package/src/lib/types/navigation/internalApplicationLinks.d.ts

@@ -16,5 +16,6 @@ export declare enum InternalApplicationLinks {
     EchoMaps = "/maps",
     Echo3dWeb = "/echo3d",
     Turnaround = "/turnaround",
-    Sandbox = "/sandbox"
+    Sandbox = "/sandbox",
+    Home = "/"
 }

package/src/lib/utils/openIn3d/index.d.ts

@@ -1,2 +1,2 @@
-export { ObjectsToSendTo3dTypes, generateTemporaryTagListObject, getRandomColor, getTemporarilyEchoHubListFor3d } from './tagLists';
+export { generateTemporaryTagListObject, getRandomColor, getTemporarilyEchoHubListFor3d } from './tagLists';
 export type { HubListReturnType } from './tagLists';

package/src/lib/utils/openIn3d/tagLists.d.ts

@@ -3,10 +3,6 @@ export declare const getTemporarilyEchoHubListFor3d: (instCode: string, request:
     app3dUrl: string;
     web3dUrl: string;
 }>;
-export declare enum ObjectsToSendTo3dTypes {
-    workOrders = "workOrders",
-    tags = "tags"
-}
 export type HubListReturnType = {
     app3dUrl: string;
     web3dUrl: string;
@@ -23,7 +19,6 @@ export type HubListReturnType = {
  * @return {*} {TemporaryEchoHubListDto} temporary tag list object
  */
 export declare const generateTemporaryTagListObject: (args: {
-    ObjectsToSendTo3d: ObjectsToSendTo3dTypes;
     sourceModuleName: string;
     createdBy: string;
     plantCode: string;

package/src/lib/feature/openItemsIn3d/SelectedItemsMenu.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import { ObjectsToSendTo3dTypes } from '../../utils';
-interface SelectedItemsProps {
-    onOpenIn3dButtonClick: (ObjectsToSendTo3d: ObjectsToSendTo3dTypes) => void;
-    children?: React.ReactNode;
-    disabled?: boolean;
-}
-export declare const SelectedItemsMenu: React.FC<SelectedItemsProps>;
-export declare function getIsGlobalSelectionEnabled(): boolean;
-export {};