@equinor/echo-framework 4.3.0 → 4.3.1

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "4.3.0",
+  "version": "4.3.1",
   "peerDependencies": {
-    "@equinor/echo-base": ">= 4.3.0 < 5.0.0",
-    "@equinor/echo-components": ">= 4.3.0 < 5.0.0",
-    "@equinor/echo-core": ">= 4.3.0 < 5.0.0",
-    "@equinor/echo-search": ">= 4.3.0 < 5.0.0",
-    "@equinor/echo-utils": ">= 4.3.0 < 5.0.0",
+    "@equinor/echo-base": ">= 4.3.1 < 5.0.0",
+    "@equinor/echo-components": ">= 4.3.1 < 5.0.0",
+    "@equinor/echo-core": ">= 4.3.1 < 5.0.0",
+    "@equinor/echo-search": ">= 4.3.1 < 5.0.0",
+    "@equinor/echo-utils": ">= 4.3.1 < 5.0.0",
     "@equinor/eds-core-react": "0.49.0",
     "@equinor/eds-icons": "0.22.0",
     "@equinor/eds-tokens": "2.1.0",

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

@@ -160,6 +160,14 @@ export declare const useGlobalSelectionStore: import("zustand").UseBoundStore<Om
                             type: string;
                             value: string;
                         }[];
+                        coordinates: {
+                            tagSeqNo: number;
+                            xEasting: number;
+                            yNorthing: number;
+                            zElevation: number;
+                            uom: string;
+                            linePosition: number | undefined;
+                        }[];
                         tagNo: string;
                         description: string;
                         projectCode: string;

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

@@ -2,7 +2,6 @@ import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionSto
 /**
  * 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

@@ -1,9 +1,10 @@
 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.
+ * Custom hook to get the selection categories by group ID from the global selection tree hierarchy.
  *
- * This hook retrieves the categories for a given group ID from the selection tree store.
+ * Zustand's Object.is equality check on the selector return value ensures re-renders only
+ * happen when this specific group's categories change, not on unrelated group mutations.
  *
  * @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.

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

@@ -5,14 +5,17 @@ import { GlobalSelectionTypes } from '../../globalSelectionStore/globalSelection
  * This hook retrieves the global selection items and filters them based on the provided item IDs,
  * extracts their associated colors, and sorts the colors by frequency.
  *
+ * Callers must provide a referentially stable `itemIds` array (e.g. via `useMemo`)
+ * to avoid unnecessary recomputation on every render.
+ *
  * @param itemIds - An array of item IDs to match against global selection items.
  * @returns An array of color strings sorted by frequency, most frequent first.
  */
-export declare function useSelectionColorFrequencyByIds(itemIds: GlobalSelectionTypes.ItemId[]): string[];
+export declare function useSelectionColorFrequencyByIds(itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>): readonly string[];
 /**
  * Returns the most frequently used selection color from the provided item IDs.
  *
  * @param itemIds - An array of item IDs to analyze for color frequency.
  * @returns The most used selection color as a string, or `undefined` if no colors are present.
  */
-export declare function useMostUsedSelectionColorByIds(itemIds: GlobalSelectionTypes.ItemId[]): string | undefined;
+export declare function useMostUsedSelectionColorByIds(itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>): string | undefined;

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

@@ -126,6 +126,14 @@ export declare const legendFacade: Readonly<{
                             type: string;
                             value: string;
                         }[];
+                        coordinates: {
+                            tagSeqNo: number;
+                            xEasting: number;
+                            yNorthing: number;
+                            zElevation: number;
+                            uom: string;
+                            linePosition: number | undefined;
+                        }[];
                         tagNo: string;
                         description: string;
                         projectCode: string;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/api/fetchNotificationDetailsByIds.d.ts

@@ -0,0 +1,8 @@
+import type { NotificationDetails } from '@equinor/echo-search';
+import type { LegendNotificationId } from '../../../types/legendType';
+export declare const notificationDetailsQueryOptions: (notificationIds: ReadonlyArray<LegendNotificationId>) => {
+    queryKey: readonly ["notificationDetails", readonly LegendNotificationId[]];
+    queryFn: () => Promise<readonly NotificationDetails[]>;
+    staleTime: number;
+    gcTime: number;
+};

package/src/lib/feature/legend/legendStrategies/notificationStrategy/hooks/useNotificationDetailsByIds.d.ts

@@ -0,0 +1,2 @@
+import type { LegendDataId } from '../../../types/legendType';
+export declare const useNotificationDetailsByIds: (itemIds: ReadonlyArray<LegendDataId>, isEnabled: boolean) => import("@tanstack/react-query").UseQueryResult<readonly import("@equinor/echo-search").NotificationDetails[], Error>;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/hooks/useNotificationLegendData.d.ts

@@ -0,0 +1,5 @@
+export declare const useNotificationLegendData: () => {
+    isEnabled: boolean;
+    selectedMarkerOption: import("../../../types/legendType").LegendMarkerOptionConfig<string>;
+    selectedBadgeOption: import("../../../types/legendType").LegendBadgeOptionConfig<string>;
+} | undefined;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/hooks/useNotificationMarkers.d.ts

@@ -1,6 +1,10 @@
 import type { Marker } from '../../../types/legendMarkerBadge.type';
 import { type LegendDataId } from '../../../types/legendType';
 /**
- * Orchestrates fetching notifications for the given tag IDs and transforms them into markers for the notification legend.
+ * Creates notification markers from two sources:
+ * 1. Tag-based: fetches open notifications for selected tags
+ * 2. ID-based: fetches notification details by direct notification IDs
+ *
+ * Both sources are merged into a single marker array.
  */
 export declare const useNotificationMarkers: (itemIds: ReadonlyArray<LegendDataId>) => ReadonlyArray<Marker>;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/hooks/{useNotificationsByTagIds.d.ts → useOpenNotificationsByTagIds.d.ts}

@@ -4,11 +4,11 @@ export interface TagNotificationGroup {
     readonly tagId: TagNo;
     readonly notifications: ReadonlyArray<NotificationDto>;
 }
-interface UseNotificationsByTagIdsResult {
+interface UseOpenNotificationsByTagIdsResult {
     readonly data: ReadonlyArray<TagNotificationGroup>;
     readonly error: Error | undefined;
     readonly isFetching: boolean;
 }
-export declare const useNotificationsByTagIds: (enabled: boolean, tagIds: ReadonlyArray<LegendTagId>) => UseNotificationsByTagIdsResult;
+export declare const useOpenNotificationsByTagIds: (tagIds: ReadonlyArray<LegendTagId>, enabled: boolean) => UseOpenNotificationsByTagIdsResult;
 export declare const groupNotificationsByTagId: (notifications: ReadonlyArray<NotificationDto>) => ReadonlyArray<TagNotificationGroup>;
 export {};

package/src/lib/feature/legend/legendStrategies/notificationStrategy/logic/getNotificationPopover.d.ts

@@ -1,12 +1,6 @@
 import { type NotificationItemCardData } from '@equinor/echo-components';
 import type { NotificationDetails } from '@equinor/echo-search';
 import { Explicit } from '@equinor/echo-utils';
-import { type LegendDataId, type LegendNotificationId } from '../../../types/legendType';
-/**
- * Notification is not a selection-based legend, so the dataId is not directly tied to global selection item IDs.
- * Instead, we define a specific type for notification legend data IDs (LegendNotificationId) and use a type guard (isNotificationDataId) to identify them.
- * This allows us to safely handle notification data IDs without relying on global selection structures.
- */
-export declare const isNotificationDataId: (dataId: LegendDataId) => dataId is LegendNotificationId;
+import { type LegendDataId } from '../../../types/legendType';
 export declare const getPopoverContent: (_legendDataId: LegendDataId, itemIds: ReadonlyArray<LegendDataId>) => Promise<JSX.Element[]>;
 export declare const mapNotificationToNotificationItemCard: (notification: NotificationDetails) => Explicit<NotificationItemCardData>;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/logic/notificationLegend.logic.d.ts

@@ -1,12 +1,12 @@
-import { NotificationDto } from '@equinor/echo-search';
 import type { Badge, Marker } from '../../../types/legendMarkerBadge.type';
 import type { LegendBadgeOptionConfig, LegendMarkerOptionConfig } from '../../../types/legendType';
+import type { NotificationLegendData } from '../notificationStrategy.types';
 interface CreateMarkerFromNotificationsArgs {
-    readonly notifications: ReadonlyArray<NotificationDto>;
+    readonly notifications: ReadonlyArray<NotificationLegendData>;
     readonly selectedMarkerOption: LegendMarkerOptionConfig;
     readonly selectedBadgeOption: LegendBadgeOptionConfig;
 }
-export declare const createMarkerFromNotifications: ({ notifications, selectedMarkerOption, selectedBadgeOption }: CreateMarkerFromNotificationsArgs) => Marker;
-export declare const createMarkerTitle: (notifications: ReadonlyArray<NotificationDto>, selectedMarkerOption: LegendMarkerOptionConfig) => string;
-export declare const createBadges: (notifications: ReadonlyArray<NotificationDto>, selectedBadgeOption: LegendBadgeOptionConfig) => ReadonlyArray<Badge>;
+export declare const createMarkerFromNotifications: ({ notifications, selectedMarkerOption, selectedBadgeOption }: CreateMarkerFromNotificationsArgs) => Marker | undefined;
+export declare const createMarkerTitle: (notifications: ReadonlyArray<NotificationLegendData>, selectedMarkerOption: LegendMarkerOptionConfig) => string;
+export declare const createBadges: (notifications: ReadonlyArray<NotificationLegendData>, selectedBadgeOption: LegendBadgeOptionConfig) => ReadonlyArray<Badge>;
 export {};

package/src/lib/feature/legend/legendStrategies/notificationStrategy/notificationStrategy.types.d.ts

@@ -1,5 +1,13 @@
+import type { NotificationDto } from '@equinor/echo-search';
 import type { LegendStatus } from '../../../legacyLegend/legend';
-import type { NotificationBadgeOptions } from './optionConfigs/notificationBadgeLegendOptionConfig';
-import type { NotificationMarkerOptions } from './optionConfigs/notificationMarkerLegendOptionConfig';
+/**
+ * The subset of notification fields actually used in the legend marker pipeline.
+ * Only these fields are accessed by property accessors, icon resolution, and badge creation.
+ */
+export type NotificationLegendData = Pick<NotificationDto, 'maintenanceRecordId' | 'recordTypeId' | 'activeStatusIds' | 'requiredEndDateTime'>;
+type BadgeKeysFromNotificationLegendData = Pick<NotificationLegendData, 'maintenanceRecordId' | 'recordTypeId'>;
+export type NotificationBadgeOptions = keyof BadgeKeysFromNotificationLegendData | 'count';
+export type NotificationMarkerOptions = keyof Pick<NotificationLegendData, 'activeStatusIds' | 'requiredEndDateTime' | 'recordTypeId'>;
 export type AllNotificationPropertyOptions = NotificationMarkerOptions | NotificationBadgeOptions;
 export type EndDateStatusText = 'Expired' | '0-7 days' | '8 days - 1 month' | '1-3 months' | '3-6 months' | '6-12 months' | '> 1 year' | LegendStatus.Unknown;
+export {};

package/src/lib/feature/legend/legendStrategies/notificationStrategy/optionConfigs/notificationBadgeLegendOptionConfig.d.ts

@@ -1,6 +1,3 @@
-import { NotificationDto } from '@equinor/echo-search';
 import { LegendBadgeOptionConfig } from '../../../types/legendType';
-type KeysFromNotificationDto = Pick<NotificationDto, 'maintenanceRecordId' | 'recordTypeId'>;
-export type NotificationBadgeOptions = keyof KeysFromNotificationDto | 'count';
+import type { NotificationBadgeOptions } from '../notificationStrategy.types';
 export declare const NOTIFICATION_LEGEND_BADGE_OPTIONS: ReadonlyArray<LegendBadgeOptionConfig<NotificationBadgeOptions>>;
-export {};

package/src/lib/feature/legend/legendStrategies/notificationStrategy/optionConfigs/notificationMarkerLegendOptionConfig.d.ts

@@ -1,4 +1,3 @@
-import { NotificationDto } from '@equinor/echo-search';
 import { type LegendMarkerOptionConfig } from '../../../types/legendType';
-export type NotificationMarkerOptions = keyof Pick<NotificationDto, 'activeStatusIds' | 'requiredEndDateTime' | 'recordTypeId'>;
+import type { NotificationMarkerOptions } from '../notificationStrategy.types';
 export declare const NOTIFICATION_LEGEND_MARKER_OPTIONS: ReadonlyArray<LegendMarkerOptionConfig<NotificationMarkerOptions>>;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/utils/getNotificationTitlesByPropertyName.d.ts

@@ -1,2 +1,2 @@
-import { NotificationDto } from '@equinor/echo-search';
-export declare function getNotificationTitlesByPropertyName(propertyName: string, notification: NotificationDto, notifications: ReadonlyArray<NotificationDto>): ReadonlyArray<string>;
+import type { NotificationLegendData } from '../notificationStrategy.types';
+export declare function getNotificationTitlesByPropertyName(propertyName: string, notification: NotificationLegendData, notifications: ReadonlyArray<NotificationLegendData>): ReadonlyArray<string>;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/utils/notificationLegend.utils.d.ts

@@ -1,11 +1,16 @@
-import { NotificationDto } from '@equinor/echo-search';
-import type { EndDateStatusText } from '../notificationStrategy.types';
+import { type LegendDataId, type LegendNotificationId } from '../../../types/legendType';
+import type { EndDateStatusText, NotificationLegendData } from '../notificationStrategy.types';
+/**
+ * Type guard for notification legend data IDs.
+ * Notification is not a selection-based legend, so the dataId is not directly tied to global selection item IDs.
+ */
+export declare const isNotificationDataId: (dataId: LegendDataId) => dataId is LegendNotificationId;
 /**
  * Determines the appropriate icon name for a marker based on the record types of the provided notifications.
  * If there are multiple record types or no notifications, it returns a generic icon.
  * Otherwise, it returns a specific icon based on the record type.
  */
-export declare const getIconForMarker: (notifications: ReadonlyArray<NotificationDto>) => string;
+export declare const getIconForMarker: (notifications: ReadonlyArray<NotificationLegendData>) => string;
 /**
  * Returns user-friendly end date status text based on the required end date of a notification.
  */

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

@@ -56,6 +56,14 @@ export declare const useVisibleDataAsTagsStore: import("zustand").UseBoundStore<
                     type: string;
                     value: string;
                 }[];
+                coordinates: {
+                    tagSeqNo: number;
+                    xEasting: number;
+                    yNorthing: number;
+                    zElevation: number;
+                    uom: string;
+                    linePosition: number | undefined;
+                }[];
                 tagNo: string;
                 description: string;
                 projectCode: string;

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

@@ -1,4 +1,4 @@
-export { failureMechanismConfig, MeasuringPointDetails, MeasuringPointHeader } from './components';
+export { MeasuringPointDetails, MeasuringPointHeader, failureMechanismConfig } from './components';
 export { MeasuringPointListItem } from './components/MeasuringPointListItem';
 export { useOpenMeasuringPointDetails } from './hooks';
 export type { DocumentRelationships } from './types/documentRelationships';

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

@@ -5,6 +5,7 @@ export declare function createEcho3dInternalLink(instCode: string, params: {
     e3dRef?: string;
     tagArea?: string;
     measuringPointIds?: ReadonlyArray<string>;
+    selectedMeasuringPointId?: string;
 }): {
     echo3d: string;
     params: string;

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

@@ -4,6 +4,7 @@ export * from './endDateStatus/getEndDateStatus';
 export * from './formatTimeHelpers';
 export * from './highlightTextUtil';
 export * from './navigationUtils';
+export * from './notification.utils';
 export * from './openIn3d';
 export * from './plantInfo';
 export * from './previousUtils';

package/src/lib/utils/notification.utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isNotificationClosed(systemStatusIds: string[]): boolean;
+export declare function isNotificationOpen(systemStatusIds: string[]): boolean;