@equinor/echo-framework 2.2.3 → 2.3.0

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "2.2.3",
+  "version": "2.3.0",
   "peerDependencies": {
-    "@equinor/echo-base": ">= 2.2.3 < 3.0.0",
-    "@equinor/echo-components": ">= 2.2.3 < 3.0.0",
-    "@equinor/echo-core": ">= 2.2.3 < 3.0.0",
-    "@equinor/echo-search": ">= 2.2.3 < 3.0.0",
-    "@equinor/echo-utils": ">= 2.2.3 < 3.0.0",
+    "@equinor/echo-base": ">= 2.3.0 < 3.0.0",
+    "@equinor/echo-components": ">= 2.3.0 < 3.0.0",
+    "@equinor/echo-core": ">= 2.3.0 < 3.0.0",
+    "@equinor/echo-search": ">= 2.3.0 < 3.0.0",
+    "@equinor/echo-utils": ">= 2.3.0 < 3.0.0",
     "@equinor/eds-core-react": "0.49.0",
     "@equinor/eds-icons": "0.22.0",
     "react": ">= 17.0.2",

package/src/index.d.ts

@@ -77,6 +77,7 @@ export { getPdmsPlantCodeForTag } from './lib/utils/getPdmsPlantCodeForTag';
 export { isImage, isVideo } from './lib/utils/mediaTypeUtils';
 export { convertPathNameToReadableString } from './lib/utils/moduleNameUtils';
 export * from './lib/utils/startup';
+export type { ProcosysProject } from './types/procosysProject';
 export declare const registerEchopediaComponent: ({ name, component }: {
     name: import("./lib/services/componentRegistry/componentRegistry").RegisteredComponentName;
     component: import("react").FunctionComponent<any>;

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

@@ -0,0 +1,7 @@
+import { GlobalSelectionItemType, GlobalSelectionObject } from '../globalSelectionStore/globalSelectionStore.types';
+/**
+ *
+ * @param {GlobalSelectionItemType} itemType
+ * @returns Map of given item types stored in global selection.
+ */
+export declare function useGlobalSelectionItemsByTypeAsMap<T extends GlobalSelectionItemType>(itemType: T): GlobalSelectionObject[T];

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

@@ -5,6 +5,7 @@ export { useAreAllItemsVisible } from './hooks/useAreAllItemsVisible';
 export { useGlobalSelectionByItemId } from './hooks/useGlobalSelectionByItemId';
 export { useGlobalSelectionItems } from './hooks/useGlobalSelectionItems';
 export { useGlobalSelectionItemsByType } from './hooks/useGlobalSelectionItemsByType';
+export { useGlobalSelectionItemsByTypeAsMap } from './hooks/useGlobalSelectionItemsByTypeAsMap';
 export { useGlobalSelectionLists } from './hooks/useGlobalSelectionLists';
 export { useGlobalSelectionTags } from './hooks/useGlobalSelectionTags';
 export { useGlobalSelectionWorkOrders } from './hooks/useGlobalSelectionWorkOrders';

package/src/lib/feature/legend/components/legendTextSelector/LegendTextSelector.d.ts

@@ -1,8 +1,7 @@
-import React from 'react';
-interface LegendTextSelectorProps {
-    options: ReadonlyArray<string>;
-    selectedOption: string;
-    onOptionSelected?: (option: string) => void;
+interface LegendTextSelectorProps<T extends string> {
+    options: ReadonlyArray<T>;
+    selectedOption: T;
+    onOptionSelected?: (option: T, e: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
 }
 /**
  * LegendTextSelector renders a group of selectable buttons for legend text options.
@@ -17,5 +16,5 @@ interface LegendTextSelectorProps {
  * @param {(option: string) => void} [props.onOptionSelected] - Callback invoked when a new option is selected.
  * @returns {JSX.Element | null} The rendered button group, or null if no options are provided.
  */
-export declare const LegendTextSelector: React.FC<LegendTextSelectorProps>;
+export declare const LegendTextSelector: <T extends string>(props: LegendTextSelectorProps<T>) => import("react/jsx-runtime").JSX.Element | null;
 export {};

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

@@ -1,12 +1,12 @@
 import { ItemMarkerSize } from '@equinor/echo-components';
 import React from 'react';
-import { Marker } from '../../../types/legendMarkerBadge.type';
+import { GroupedMarker } from '../utils/splitMarkerByBadgeSelectionGroup.types';
 interface LegendColoredMarkerIconProps {
     hasPointer: boolean;
     isActive: boolean;
     onClick: () => void;
     hiddenBadges: string[];
-    marker: Marker;
+    marker: GroupedMarker;
 }
 /**
  * Renders a colored marker icon with optional pointer and badges.

package/src/lib/feature/legend/components/selectionLegend/SelectionLegend.d.ts

@@ -1 +1 @@
-export declare const SelectionLegendRenderer: import("react").MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+export declare const SelectionLegendRenderer: import("react").MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element | null>;

package/src/lib/feature/legend/components/selectionLegend/components/SelectionLegendActions.d.ts

@@ -0,0 +1,5 @@
+/**
+ * SelectionLegendActions renders the action buttons for the Selection Legend.
+ * It provides options to toggle the visibility of highlights around selection group markers.
+ */
+export declare const SelectionLegendActions: () => import("react/jsx-runtime").JSX.Element;

package/src/lib/feature/legend/components/selectionLegend/components/SelectionLegendOtherMarkers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Allows the user to select how to display markers that are not in any selection group.
+ */
+export declare const SelectionLegendOtherMarkers: () => import("react/jsx-runtime").JSX.Element;

package/src/lib/feature/legend/components/selectionLegend/selectionLegend.utils.d.ts

@@ -1,6 +1,6 @@
 import { Guid } from '@equinor/echo-utils';
 import { GlobalSelectionTypes, SelectionGroup } from '../../../globalSelection';
-import { GroupKey } from '../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
+import { GroupedMarker, GroupKey } from '../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
 /**
  * TODO: Remove this flag when Selection Legend is stable and ready for production
  * Flag to enable/disable Selection Legend feature
@@ -32,3 +32,11 @@ export declare const getSelectionGroupMostUsedColor: (selectionGroup: SelectionG
  * @returns The standardized group key
  */
 export declare const createSelectionGroupKey: (groupId: Guid, color: string) => GroupKey;
+/**
+ * Checks if a marker belongs to the "Not in Selection" group.
+ *
+ * @param marker - The marker to check.
+ *
+ * @returns True if the marker is in the "Not in Selection" group, false otherwise.
+ */
+export declare const isMarkerOutsideSelection: (marker: GroupedMarker) => boolean;

package/src/lib/feature/legend/stores/legendUIStore/legendUIStore.d.ts

@@ -30,3 +30,9 @@ export declare const useLegendUIStore: import("zustand").UseBoundStore<Omit<impo
 export declare function useLegendUIById(legendId: LegendId): LegendUIState | undefined;
 export declare function useLegendUIById<T>(legendId: LegendId, selector: (legend: LegendUIState | undefined) => T): T;
 export declare function legendExistsInLegendUIStore(legendId: LegendId): boolean;
+/**
+ * Helper function to toggle visibility of an item in an array.
+ * Adds the item if isHidden is true and it's not present, removes it if isHidden is false and it exists.
+ * @internal - Exported for testing purposes only
+ */
+export declare function toggleItemInArray(array: string[], item: string, isHidden: boolean): void;

package/src/lib/feature/legend/stores/legendUIStore/legendUIStore.types.d.ts

@@ -5,8 +5,13 @@ export interface LegendUIState {
     readonly hiddenBadges: string[];
 }
 export type LegendUIDictionary = Record<LegendId, LegendUIState>;
+export type MarkersOutsideSelectionVisibility = 'Show' | 'Ghost' | 'Hide';
 export type LegendUIStoreValues = {
-    legends: LegendUIDictionary;
+    readonly legends: LegendUIDictionary;
+    readonly selectionLegend: {
+        readonly isHighlightVisible: boolean;
+        readonly markersOutsideSelectionVisibility: MarkersOutsideSelectionVisibility;
+    };
 };
 export interface LegendUIStoreActions {
     toggleAccordion: (legendId: LegendId, newValue: boolean) => void;
@@ -20,6 +25,8 @@ export interface LegendUIStoreActions {
         badge: string;
         isHidden: boolean;
     }) => void;
+    setMarkersOutsideSelectionVisibility: (visibility: MarkersOutsideSelectionVisibility) => void;
     initializeLegendInStore: (legendId: LegendId) => void;
+    setSelectionLegendIsHighlightVisible: (visible: boolean) => void;
 }
 export type LegendUIStore = LegendUIStoreValues & LegendUIStoreActions;

package/src/lib/services/dataLayerPanel/dataLayerPanel.store.d.ts

@@ -1,23 +1,38 @@
 import { WritableDraft } from 'immer';
-interface PanelUserSettings {
-    readonly isTagsVisible: boolean;
-    readonly isWorkOrdersVisible: boolean;
-    readonly isEquipmentsVisible: boolean;
-    readonly isIocAnnotationsVisible: boolean;
+export interface PanelUserSettings {
+    isTagsVisible: boolean;
+    isTagsFromDocumentVisible: boolean;
+    isTagsFromSelectionVisible: boolean;
+    isWorkOrdersVisible: boolean;
+    isWorkOrdersFromDocumentVisible: boolean;
+    isWorkOrdersFromSelectionVisible: boolean;
+    isEquipmentsVisible: boolean;
+    isEquipmentsFromDocumentVisible: boolean;
+    isEquipmentsFromSelectionVisible: boolean;
+    isIocAnnotationsVisible: boolean;
+    isDataFromStidAnnoDetails: boolean;
 }
-interface DataLayerPanelState {
-    readonly isOpen: boolean;
+export interface DataLayerPanelState {
+    isOpen: boolean;
     readonly userSettings: PanelUserSettings;
 }
 interface DataLayerPanelActions {
     togglePanel: () => void;
+    toggleTags: () => void;
+    toggleTagsFromDocumentVisible: () => void;
+    toggleTagsFromSelectionVisible: () => void;
     toggleWorkOrders: () => void;
+    toggleWorkOrdersFromDocumentVisible: () => void;
+    toggleWorkOrdersFromSelectionVisible: () => void;
     toggleEquipments: () => void;
-    toggleTags: () => void;
+    toggleEquipmentsFromDocumentVisible: () => void;
+    toggleEquipmentsFromSelectionVisible: () => void;
+    setEquipmentsForEcm: () => void;
     toggleIocAnnotations: () => void;
+    setIsDataFromStidAnnoDetails: (value: boolean) => void;
 }
 type DataLayerPanelStore = DataLayerPanelState & DataLayerPanelActions;
-export declare const useDataLayerPanelStore: import("zustand").UseBoundStore<Omit<Omit<Omit<Omit<import("zustand").StoreApi<DataLayerPanelStore>, "setState"> & {
+export declare const useDataLayerPanelStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<DataLayerPanelStore>, "setState"> & {
     setState<A extends string | {
         type: string;
     }>(partial: DataLayerPanelStore | Partial<DataLayerPanelStore> | ((state: DataLayerPanelStore) => DataLayerPanelStore | Partial<DataLayerPanelStore>), replace?: boolean | undefined, action?: A | undefined): void;
@@ -29,16 +44,6 @@ export declare const useDataLayerPanelStore: import("zustand").UseBoundStore<Omi
             fireImmediately?: boolean;
         } | undefined): () => void;
     };
-}, "persist"> & {
-    persist: {
-        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<DataLayerPanelStore, unknown>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => Promise<void> | void;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: DataLayerPanelStore) => void) => () => void;
-        onFinishHydration: (fn: (state: DataLayerPanelStore) => void) => () => void;
-        getOptions: () => Partial<import("zustand/middleware").PersistOptions<DataLayerPanelStore, unknown>>;
-    };
 }, "setState"> & {
     setState(nextStateOrUpdater: DataLayerPanelStore | Partial<DataLayerPanelStore> | ((state: WritableDraft<DataLayerPanelStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;

package/src/types/procosysProject.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ProcosysProject represents a project from the ProCoSys API.
+ * This is the canonical type for project data throughout the application.
+ */
+export interface ProcosysProject {
+    projectCode: string;
+    stidDeliveryCode: number;
+    description: string;
+    isRevProject: string;
+    filter: {
+        value: string;
+        text: string;
+    };
+    instCode: string;
+    insertedDate: string;
+    insertedBy: string;
+    updatedDate: string;
+    updatedBy: string;
+    validFlg: string;
+}

package/src/lib/feature/legend/components/selectionLegend/hooks/useIsSelectionLegendVisible.d.ts

@@ -1,6 +0,0 @@
-/**
- * Decides if selection legend should be visible or not.
- * Will be visible if Selection has items. Does not check if Selection has items
- * that are visible on the current PDF.
- */
-export declare const useIsSelectionLegendVisible: () => boolean;