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

package/src/lib/feature/legend/components/pdfMarkers/subComponents/MultipleMarkersByLegends.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { LegendDataId } from '../../../types/legendType';
+interface MultipleMarkersByLegendsProps {
+    itemId: LegendDataId;
+    hasPointer: boolean;
+    popoverOffset: string;
+    setOpenItem: (value: PopoverContent | undefined) => void;
+    activeItem: ActiveItem | undefined;
+}
+export interface PopoverContent {
+    elements: JSX.Element[];
+    popoverOffset: string;
+    activeItem: ActiveItem;
+}
+interface ActiveItem {
+    itemId: LegendDataId;
+    legendId: string;
+}
+export declare const MultipleMarkersByLegendsComponent: React.FC<MultipleMarkersByLegendsProps>;
+export declare const MultipleMarkersByLegends: React.NamedExoticComponent<MultipleMarkersByLegendsProps>;
+export {};

package/src/lib/feature/legend/components/pdfMarkers/subComponents/iconPositionTransform.d.ts

@@ -0,0 +1,18 @@
+import { Point } from '@equinor/echo-utils';
+export declare const calculateIconScale: (currentPageScale: number) => number;
+export declare function calculatePopoverStyling(args: {
+    pdfZoom: number;
+    hasPointer: boolean;
+    position: Point;
+    pdfRotation: number;
+    currentPageScale: number;
+    markerHeight: number;
+}): string;
+export declare function iconPositionTransform(args: {
+    position: Point;
+    pdfRotation: number;
+    currentPageScale: number;
+    isMobileDevice: boolean;
+    pdfZoom: number;
+    hasPointer: boolean;
+}): string;

package/src/lib/feature/legend/hooks/useLegendMarkers.d.ts

@@ -0,0 +1,19 @@
+import { Badge, Marker } from '../types/legendMarkerBadge.type';
+import { LegendDataId } from '../types/legendType';
+/**
+ * Returns the markers for the given legendId and itemId.
+ */
+export declare function useLegendMarker(args: {
+    legendId: string;
+    itemId: LegendDataId;
+}): Marker[];
+/**
+ * Returns all unique markers for the given legendId, determined by unique markerKey (title + color).
+ */
+export declare function useLegendUniqueMarkers(args: {
+    legendId: string;
+}): Marker[];
+/**
+ * Returns all unique badges for the given legendId, determined by unique title + color.
+ */
+export declare function useLegendUniqueBadges(legendId: string): Badge[];

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

@@ -0,0 +1,7 @@
+import './legendStrategies/workOrderStrategy/WorkOrderLegend';
+export { LegendList as LegendsRenderer } from './components/LegendList';
+export { PositionalItem } from './components/pdfMarkers/PositionalItem';
+export { PositionalLegendMarkers } from './components/pdfMarkers/PositionalLegendMarkers';
+export { legendFacade } from './legendFacade';
+export type { Badge, Marker } from './types/legendMarkerBadge.type';
+export type { LegendStrategy } from './types/legendStrategy.type';

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

@@ -0,0 +1,29 @@
+import { legendSnapShot, useAllLegends, useLegendById } from './legendStore';
+import { getLegendStrategy, injectLegendStrategy } from './legendStrategies/legendCollections';
+import { legendVisibleDataSnapshot, useAddVisibleItems } from './legendVisibleDataStore';
+export declare const legendFacade: Readonly<{
+    injectLegendStrategy: typeof injectLegendStrategy;
+    useVisibleDataStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions>, "setState"> & {
+        setState<A extends string | {
+            type: string;
+        }>(partial: (import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions) | Partial<import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions> | ((state: import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions) => (import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions) | Partial<import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions>), replace?: boolean | undefined, action?: A | undefined): void;
+    }, "subscribe"> & {
+        subscribe: {
+            (listener: (selectedState: import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions, previousSelectedState: import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions) => void): () => void;
+            <U>(selector: (state: import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+                equalityFn?: ((a: U, b: U) => boolean) | undefined;
+                fireImmediately?: boolean;
+            } | undefined): () => void;
+        };
+    }, "setState"> & {
+        setState(nextStateOrUpdater: (import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions) | Partial<import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions> | ((state: import("immer").WritableDraft<import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+            type: string;
+        } | undefined): void;
+    }>;
+    visibleDataSnapshot: typeof legendVisibleDataSnapshot;
+    storeSnapshot: typeof legendSnapShot;
+    getStrategy: typeof getLegendStrategy;
+    useLegendById: typeof useLegendById;
+    useAllLegends: typeof useAllLegends;
+    useAddVisibleItems: typeof useAddVisibleItems;
+}>;

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

@@ -0,0 +1,43 @@
+import { PersistOptions } from 'zustand/middleware';
+import { LegendState } from './types/legendType';
+interface LegendStoreData {
+    legends: Record<string, LegendState>;
+}
+interface LegendStoreActions {
+    updateLegend: (legendId: string, updates: Partial<LegendState>) => void;
+    setHiddenMarker: (legendId: string, marker: string, isHidden: boolean) => void;
+    setHiddenBadge: (legendId: string, badge: string, isHidden: boolean) => void;
+    getLegendById: (legendId: string) => LegendState | undefined;
+}
+type LegendStore = LegendStoreData & LegendStoreActions;
+export declare const useLegendStore: import("zustand").UseBoundStore<Omit<Omit<Omit<Omit<import("zustand").StoreApi<LegendStore>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: LegendStore | Partial<LegendStore> | ((state: LegendStore) => LegendStore | Partial<LegendStore>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: LegendStore, previousSelectedState: LegendStore) => void): () => void;
+        <U>(selector: (state: LegendStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<PersistOptions<LegendStore, LegendStore>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: LegendStore) => void) => () => void;
+        onFinishHydration: (fn: (state: LegendStore) => void) => () => void;
+        getOptions: () => Partial<PersistOptions<LegendStore, LegendStore>>;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: LegendStore | Partial<LegendStore> | ((state: import("immer").WritableDraft<LegendStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: string;
+    } | undefined): void;
+}>;
+export declare function useLegendById(legendId: string): LegendState;
+export declare function useAllLegends(): LegendState[];
+export declare function legendSnapShot(): LegendStore;
+export {};

package/src/lib/feature/legend/legendStrategies/legendCollections.d.ts

@@ -0,0 +1,4 @@
+import { LegendStrategy } from '../types/legendStrategy.type';
+import { LegendState } from '../types/legendType';
+export declare function injectLegendStrategy(strategy: LegendStrategy, properties: Partial<LegendState>): void;
+export declare function getLegendStrategy(strategyTypeName: string): LegendStrategy;

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/WorkOrderLegend.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export declare function subscribeToLegendDataChanged(): void;
+export declare const sleep: (ms: number) => Promise<unknown>;

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

@@ -0,0 +1,61 @@
+import { LegendDataId, LegendEquipmentId, LegendTagId } from './types/legendType';
+/**
+ * Maps (string) keyword to the data type.
+ * We don't have any other sources so far, pdf has TagNo and EquipmentId (ecm)
+ */
+type KnownDataTypes = {
+    Tag: LegendTagId;
+    Equipment: LegendEquipmentId;
+};
+type KnownDataTypeKeys = keyof KnownDataTypes;
+type ResolvedDataType<T extends KnownDataTypeKeys> = KnownDataTypes[T];
+/**
+ * Data structure:
+ * Data
+ * - Tag
+ *   - key1: [data1, data2, ...]
+ *   - key2: [data1, data2, ...]
+ * - Equipment
+ *   - key1: [data1, data2, ...]
+ * ...
+ */
+export interface LegendVisibleData {
+    data: LegendVisibleDataState;
+}
+type LegendVisibleDataState = {
+    [K in KnownDataTypeKeys]: {
+        [key: string]: ResolvedDataType<K>[];
+    };
+};
+export interface LegendVisibleDataStoreActions {
+    addData: <T extends KnownDataTypeKeys>(type: T, key: string, value: ResolvedDataType<T>[]) => void;
+    removeData: (key: string) => void;
+    getData: <T extends KnownDataTypeKeys>(type: T) => ResolvedDataType<T>[];
+    useDataByType: <T extends KnownDataTypeKeys>(type: T) => ResolvedDataType<T>[];
+    getAll(): LegendDataId[];
+}
+type LegendVisibleDataStore = LegendVisibleData & LegendVisibleDataStoreActions;
+export declare const useLegendVisibleDataStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<LegendVisibleDataStore>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: LegendVisibleDataStore | Partial<LegendVisibleDataStore> | ((state: LegendVisibleDataStore) => LegendVisibleDataStore | Partial<LegendVisibleDataStore>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: LegendVisibleDataStore, previousSelectedState: LegendVisibleDataStore) => void): () => void;
+        <U>(selector: (state: LegendVisibleDataStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: LegendVisibleDataStore | Partial<LegendVisibleDataStore> | ((state: import("immer").WritableDraft<LegendVisibleDataStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: string;
+    } | undefined): void;
+}>;
+export declare function legendVisibleDataSnapshot(): LegendVisibleDataStore;
+/**
+ * Visible items are all items on screen that should be affected by the legend.
+ * @returns A function for adding visible items by type and key, which is automatically removed when the component unmounts.
+ */
+export declare function useAddVisibleItems(): <T extends KnownDataTypeKeys>(type: T, key: string, value: ResolvedDataType<T>[]) => void;
+export {};

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

@@ -0,0 +1,11 @@
+export interface Marker {
+    getTitle: () => string;
+    getColor: () => string;
+    getIcon: () => string;
+    badges: Badge[];
+}
+export declare function markerKey(marker: Marker): string;
+export interface Badge {
+    getColor: () => string;
+    getTitle: () => string;
+}

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

@@ -0,0 +1,11 @@
+import { Marker } from './legendMarkerBadge.type';
+import { LegendDataId } from './legendType';
+export interface LegendStrategy {
+    legendId: string;
+    useMarkers: (itemIds: ReadonlyArray<LegendDataId>) => Marker[];
+    popoverContent: (itemId: LegendDataId) => React.JSX.Element[];
+    fetchData?: (visibleItemIds: ReadonlyArray<LegendDataId>) => Promise<void>;
+    markerOptions?: string[];
+    badgeOptions?: string[];
+    customLegendUi?: () => React.JSX.Element;
+}

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

@@ -0,0 +1,15 @@
+import { GlobalSelectionTypes } from '../../globalSelection';
+export interface LegendState {
+    legendId: string;
+    isEnabled: boolean;
+    isLoading: boolean;
+    hiddenMarkers: string[];
+    hiddenBadges: string[];
+    selectedMarkerOption: string;
+    selectedBadgeOption: string;
+    isExpanded: boolean;
+}
+export type LegendTagId = GlobalSelectionTypes.TagId;
+export type LegendEquipmentId = GlobalSelectionTypes.EquipmentId;
+export type LegendWorkOrderId = GlobalSelectionTypes.WorkOrderId;
+export type LegendDataId = LegendTagId | LegendEquipmentId | LegendWorkOrderId;

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 {};

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

@@ -1,56 +0,0 @@
-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[];