@equinor/echo-framework 6.1.0 → 6.2.0

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

@@ -0,0 +1,25 @@
+import type { IocAnnotationData } from '@equinor/echo-search';
+import { LegendStatus } from '../../../legacyLegend/legend';
+import { type LegendId } from '../../types/legendType';
+export declare const iocAnnotationLegendId: LegendId;
+export type IocAnnotationDto = IocAnnotationData;
+export type InstCode = string;
+export type TagNo = string;
+export type FunctionalLocation = string;
+export type IocAnnotationTagKey = string;
+export type IocAnnotationMarkerOptions = 'status';
+export type IocAnnotationBadgeOptions = 'count';
+export interface IocAnnotationTagLookup {
+    readonly tagNo: TagNo;
+    readonly instCode: InstCode;
+}
+export interface IocAnnotationFunctionalLocationLookup extends IocAnnotationTagLookup {
+    readonly functionalLocation: FunctionalLocation;
+}
+export type IocAnnotationState = LegendStatus.OnWatch | LegendStatus.InProgress | LegendStatus.IocAnnotationError | LegendStatus.Note | LegendStatus.Archived | LegendStatus.Unknown;
+export interface IocAnnotationMarkerData {
+    readonly status: IocAnnotationState;
+    readonly tagNo: TagNo;
+    readonly iocAnnotations: ReadonlyArray<IocAnnotationDto>;
+}
+export type IocAnnotationMarkerDataByTagKey = ReadonlyMap<IocAnnotationTagKey, IocAnnotationMarkerData>;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/optionConfigs/iocAnnotationBadgeLegendOptionConfig.d.ts

@@ -0,0 +1,3 @@
+import { type LegendBadgeOptionConfig } from '../../../types/legendType';
+import type { IocAnnotationBadgeOptions } from '../iocAnnotationStrategy.types';
+export declare const IOC_ANNOTATION_LEGEND_BADGE_OPTIONS: ReadonlyArray<LegendBadgeOptionConfig<IocAnnotationBadgeOptions>>;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/optionConfigs/iocAnnotationMarkerLegendOptionConfig.d.ts

@@ -0,0 +1,3 @@
+import type { LegendMarkerOptionConfig } from '../../../types/legendType';
+import type { IocAnnotationMarkerOptions } from '../iocAnnotationStrategy.types';
+export declare const IOC_ANNOTATION_LEGEND_MARKER_OPTIONS: ReadonlyArray<LegendMarkerOptionConfig<IocAnnotationMarkerOptions>>;

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

@@ -1,2 +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>;
+export declare const useNotificationDetailsByIds: (itemIds: ReadonlyArray<LegendDataId>, isEnabled: boolean) => import("@tanstack/react-query").UseQueryResult<NoInfer<readonly import("@equinor/echo-search").NotificationDetails[]>, Error>;

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

@@ -0,0 +1,10 @@
+import type { RawMarkerData } from '../../../types/legendMarkerBadge.type';
+import { type LegendDataId } from '../../../types/legendType';
+/**
+ * Creates raw notification marker data 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 raw marker array.
+ */
+export declare const useNotificationRawMarkers: (itemIds: ReadonlyArray<LegendDataId>) => ReadonlyArray<RawMarkerData>;

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

@@ -1,12 +1,12 @@
-import type { Badge, Marker } from '../../../types/legendMarkerBadge.type';
+import type { RawItemAppearance, RawMarkerData } from '../../../types/legendMarkerBadge.type';
 import type { LegendBadgeOptionConfig, LegendMarkerOptionConfig } from '../../../types/legendType';
 import type { NotificationLegendData } from '../notificationStrategy.types';
-interface CreateMarkerFromNotificationsArgs {
+interface CreateRawMarkersFromNotificationsArgs {
     readonly notifications: ReadonlyArray<NotificationLegendData>;
     readonly selectedMarkerOption: LegendMarkerOptionConfig;
     readonly selectedBadgeOption: LegendBadgeOptionConfig;
 }
-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 declare const createRawMarkersFromNotifications: ({ notifications, selectedMarkerOption, selectedBadgeOption }: CreateRawMarkersFromNotificationsArgs) => ReadonlyArray<RawMarkerData>;
+export declare const createMarkerAppearances: (titles: ReadonlyArray<string>, selectedMarkerOption: LegendMarkerOptionConfig) => ReadonlyArray<RawItemAppearance>;
+export declare const createBadgeAppearances: (notification: NotificationLegendData, selectedBadgeOption: LegendBadgeOptionConfig) => ReadonlyArray<RawItemAppearance>;
 export {};

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

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

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

@@ -6,11 +6,9 @@ import type { EndDateStatusText, NotificationLegendData } from '../notificationS
  */
 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.
+ * Determines the appropriate icon name for a marker based on the record type
  */
-export declare const getIconForMarker: (notifications: ReadonlyArray<NotificationLegendData>) => string;
+export declare const getIconForMarker: (notification: NotificationLegendData) => string;
 /**
  * Returns user-friendly end date status text based on the required end date of a notification.
  */

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

@@ -1,7 +1,9 @@
-import { Marker } from '../../types/legendMarkerBadge.type';
+import { RawMarkerData } from '../../types/legendMarkerBadge.type';
 import { LegendDataId } from '../../types/legendType';
 /**
- * Creates legend markers for work orders grouped by `tagId`.
+ * // TODO: #426625 - Fix marker and badge appearances to be based on work order properties instead of hardcoded values.
+ *
+ * Creates raw legend marker data for work orders grouped by `tagId`.
  *
  * The hook:
  * \- filters `itemIds` to tag selections,
@@ -10,8 +12,9 @@ import { LegendDataId } from '../../types/legendType';
  * \- maps each group to a purple marker with orange badges (one per work order).
  *
  * Badge titles are derived from `workOrderId` using `removeLeadingZeros`.
+ * DisplayKeys and highlight colors are computed in useLegendMarker.
  *
  * @param itemIds \- Current legend selection ids.
- * @returns An array of `Marker` objects, or an empty array when no data is available.
+ * @returns An array of `RawMarkerData` objects, or an empty array when no data is available.
  */
-export declare const useCreateWorkOrderMarkers: (itemIds: ReadonlyArray<LegendDataId>) => readonly Marker[];
+export declare const useCreateWorkOrderMarkers: (itemIds: ReadonlyArray<LegendDataId>) => ReadonlyArray<RawMarkerData>;

package/src/lib/feature/legend/logic/displayKeys.logic.d.ts

@@ -0,0 +1,11 @@
+import type { LegendDisplayKey } from '../stores/legendUIStore/legendUIStore.types';
+/**
+ * Creates a display key for a legend item from title and color.
+ * Plain-label markers use 'transparent' instead of actual color so toggling is color-independent.
+ */
+export declare const createDisplayKey: (title: string, color: string, showAsPlainLabel?: boolean) => LegendDisplayKey;
+/**
+ * Creates a combined display key from multiple display keys.
+ * Used when multiple markers are combined into one.
+ */
+export declare const createCombinedDisplayKey: (displayKeys: ReadonlyArray<LegendDisplayKey>) => LegendDisplayKey;

package/src/lib/feature/legend/logic/legendChips.logic.d.ts

@@ -0,0 +1,8 @@
+import type { LegendChipProps } from '@equinor/echo-components';
+import type { LegendChipData, RawMarkerData, ToggleableItem } from '../types/legendMarkerBadge.type';
+import type { LegendId } from '../types/legendType';
+export declare const toChipProps: (chip: LegendChipData, hiddenItems: ReadonlyArray<string>, legendId: LegendId) => LegendChipProps;
+export declare const toMarkerChipData: (rawMarker: RawMarkerData) => ReadonlyArray<LegendChipData>;
+export declare const toBadgeChipData: (rawMarker: RawMarkerData) => ReadonlyArray<LegendChipData>;
+export declare function isHiddenItem(item: ToggleableItem, hiddenItems: ReadonlyArray<string>): boolean;
+export declare const setHiddenItem: (item: ToggleableItem, isHidden: boolean, legendId: LegendId) => void;

package/src/lib/feature/legend/logic/propertyAccessor.utils.d.ts

@@ -2,35 +2,24 @@
  * Property accessor function type that returns all values as an array.
  * Takes an item and optional context (like a collection) and returns string values.
  */
-export type PropertyAccessor<TItem, TContext = ReadonlyArray<TItem>> = (item: TItem, context: TContext) => ReadonlyArray<string>;
+export type PropertyAccessor<TItem> = (item: TItem) => ReadonlyArray<string>;
 /**
  * Creates an accessor that extracts a string property value as a single-element array.
  * Returns empty array if the value is empty or not a string.
  */
-export declare function createStringAccessor<TItem>(property: keyof TItem): PropertyAccessor<TItem, ReadonlyArray<TItem>>;
+export declare function createStringAccessor<TItem>(property: keyof TItem): PropertyAccessor<TItem>;
 /**
  * Creates an accessor that returns all elements from an array property.
  * Returns empty array if the property is not an array.
  */
-export declare function createArrayAccessor<TItem>(property: keyof TItem): PropertyAccessor<TItem, ReadonlyArray<TItem>>;
+export declare function createArrayAccessor<TItem>(property: keyof TItem): PropertyAccessor<TItem>;
 /**
  * Creates an accessor that converts a Date property to ISO string as a single-element array.
  * Returns empty array if the value is not a Date.
  */
-export declare function createDateAccessor<TItem>(property: keyof TItem): PropertyAccessor<TItem, ReadonlyArray<TItem>>;
-/**
- * Creates a count accessor that returns the size of the context collection.
- */
-export declare function createCountAccessor<TItem>(): PropertyAccessor<TItem, ReadonlyArray<TItem>>;
+export declare function createDateAccessor<TItem>(property: keyof TItem): PropertyAccessor<TItem>;
 /**
  * Looks up property values using a map of accessors.
  * Returns empty array if the property is not found in the accessor map.
  */
-export declare function getPropertyValues<TItem, TContext = ReadonlyArray<TItem>>(item: TItem, propertyName: string, context: TContext, accessors: Readonly<Record<string, PropertyAccessor<TItem, TContext>>>): ReadonlyArray<string>;
-/**
- * Normalizes an array of values to a single display title:
- * - Empty array → "Unknown"
- * - Single unique value → that value
- * - Multiple unique values → "Multiple"
- */
-export declare function toSingleTitle(values: ReadonlyArray<string>): string;
+export declare function getPropertyValues<TItem>(item: TItem, propertyName: string, accessors: Readonly<Record<string, PropertyAccessor<TItem>>>): ReadonlyArray<string>;

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

@@ -21,9 +21,9 @@ export declare const useLegendUIStore: UseBoundStore<StoreApi<LegendUIStore>>;
  *
  * @example
  * // Watch multiple specific properties:
- * const { isAccordionExpanded, hiddenMarkers } = useLegendUIById('Tag Legend', useShallow((legend) => ({
+ * const { isAccordionExpanded, hiddenItems } = useLegendUIById('Tag Legend', useShallow((legend) => ({
  *   isAccordionExpanded: legend?.isAccordionExpanded,
- *   hiddenMarkers: legend?.hiddenMarkers
+ *   hiddenItems: legend?.hiddenItems
  * })));
  */
 export declare function useLegendUIById(legendId: LegendId): LegendUIState | undefined;

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

@@ -1,18 +1,36 @@
+import type { Brand } from '@equinor/echo-utils';
 import type { MarkerId } from '../../../shared/markerId.types';
 import { LegendId } from '../../types/legendType';
 export type { SelectionBarFeedbackType } from '@equinor/echo-components';
 export type LegendFeedbackVariant = 'error' | 'info' | 'warning';
+/**
+ * Identifies a marker/badge appearance in the legend list.
+ * Produced by `createDisplayKey` / `createCombinedDisplayKey`.
+ * Format: `title-color`, `title-transparent`, or pipe-joined combinations.
+ */
+export type LegendDisplayKey = Brand<string, 'LegendDisplayKey'>;
+/**
+ * Identifies a selection group row in the Selection Legend.
+ * Produced by `createSelectionGroupKey` (plus the `NOT_IN_SELECTION_GROUP_KEY` sentinel).
+ * Format: `group_<guid>_<color>` (optionally with `_<itemType>` for Local Selection).
+ */
+export type LegendSelectionGroupKey = Brand<string, 'LegendSelectionGroupKey'>;
+/**
+ * Any key that can be stored in `LegendUIState.hiddenItems` to toggle visibility.
+ * The legend store is format-agnostic; specific producers/consumers should use
+ * the narrower `LegendDisplayKey` or `LegendSelectionGroupKey` types instead.
+ */
+export type ToggleableLegend = LegendDisplayKey | LegendSelectionGroupKey;
+export type MarkersOutsideSelectionVisibility = 'show' | 'ghost' | 'hide';
 export interface LegendUIState {
     readonly accordionFeedback?: {
         message: string;
         variant?: LegendFeedbackVariant;
     };
     readonly isAccordionExpanded: boolean;
-    readonly hiddenMarkers: string[];
-    readonly hiddenBadges: string[];
+    readonly hiddenItems: ToggleableLegend[];
 }
 export type LegendUIDictionary = Record<LegendId, LegendUIState>;
-export type MarkersOutsideSelectionVisibility = 'show' | 'ghost' | 'hide';
 export type LegendUIStoreValues = {
     readonly legends: LegendUIDictionary;
     readonly activePopover: {
@@ -26,21 +44,16 @@ export type LegendUIStoreValues = {
 };
 export interface LegendUIStoreActions {
     toggleAccordion: (legendId: LegendId, newValue: boolean) => void;
-    setHiddenMarker: (args: {
+    setHiddenLegendItem: (args: {
         legendId: LegendId;
-        marker: string;
+        item: ToggleableLegend;
         isHidden: boolean;
     }) => void;
-    setHiddenMarkersBatch: (updates: Array<{
+    setHiddenLegendItemsBatch: (updates: Array<{
         legendId: LegendId;
-        marker: string;
+        item: ToggleableLegend;
         isHidden: boolean;
     }>) => void;
-    setHiddenBadge: (args: {
-        legendId: LegendId;
-        badge: string;
-        isHidden: boolean;
-    }) => void;
     setMarkersOutsideSelectionVisibility: (visibility: MarkersOutsideSelectionVisibility) => void;
     initializeLegendInStore: (legendId: LegendId) => void;
     setSelectionLegendIsHighlightVisible: (visible: boolean) => void;

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

@@ -1,24 +1,87 @@
+import type { LegendDisplayKey, LegendSelectionGroupKey } from '../stores/legendUIStore/legendUIStore.types';
 import type { LegendDataId } from './legendType';
-export interface Marker {
+export interface RawItemAppearance {
+    readonly getTitle: () => string;
+    readonly getColor: () => string;
+}
+/**
+ * Raw marker data from strategy. Contains the source information and marker data.
+ */
+export interface RawMarkerData {
+    readonly getIcon: () => string;
+    /**
+     * Possible appearances for marker fill, based on selectedMarkerOption.
+     */
+    readonly markerAppearances: ReadonlyArray<RawItemAppearance>;
+    /**
+     * Possible appearances for badges, based on selectedBadgeOption.
+     */
+    readonly badgeAppearances: ReadonlyArray<RawItemAppearance>;
+    /** The specific item ID this marker represents - used for popover content and selection lookup */
+    readonly itemId: LegendDataId;
+    /**
+     * When true, renders as plain text instead of a colored chip in the legend panel.
+     * Typically used to display informational messages to the user, such as enable syncing.
+     */
+    readonly showAsPlainLabel?: boolean;
+}
+/**
+ * Minimal interface for items that can be toggled (hidden/shown) in the legend panel.
+ */
+export interface ToggleableItem {
+    readonly getDisplayKey: () => LegendDisplayKey;
+}
+/**
+ * Lightweight data for rendering a legend chip and tracking toggle state.
+ */
+export interface LegendChipData extends ToggleableItem {
+    readonly title: string;
+    readonly color: string;
+    readonly showAsPlainLabel?: boolean;
+}
+/**
+ * Processed badge with computed displayKey.
+ * Created from RawItemAppearance in useLegendMarker.
+ * All properties are getter functions for consistent API with Marker.
+ */
+export interface Badge extends ToggleableItem {
+    getTitle(): string;
+    getColor(): string;
+    /**
+     * Item ID shared from original raw marker. Needed for display options (mode=ID)
+     */
+    getItemId(): LegendDataId;
+}
+/**
+ * Final marker output consumed by rendering. Contains only display-relevant data.
+ * Created from RawMarkerData in useLegendMarker, potentially split by highlight color.
+ */
+export interface CombinedMarker extends ToggleableItem {
     getTitle: () => string;
     getColor: () => string;
     getIcon: () => string;
-    getDisplayKey: () => string;
+    /** Selection highlight color */
     getHighlightColor: () => string;
-    badges: ReadonlyArray<Badge>;
+    /** Badges merged from raw markers data */
+    getBadges: () => ReadonlyArray<Badge>;
+    /** The item IDs this combined marker represents - used for popover content */
+    getItemIds: () => ReadonlyArray<LegendDataId>;
     /**
      * When true, renders as plain text instead of a colored chip in the legend panel.
      * Typically used to display informational messages to the user, such as enable syncing.
      */
-    showAsPlainLabel?: boolean;
+    readonly showAsPlainLabel?: boolean;
 }
-export interface Badge {
-    getTitle: () => string;
-    getColor: () => string;
+/**
+ * Intermediate marker used during pipeline processing.
+ * Extends CombinedMarker with appearance data needed for per-appearance counting and grouping.
+ */
+export interface ProcessedMarker extends CombinedMarker {
+    /** Individual marker appearances used for per-appearance counting */
+    getMarkerAppearances: () => ReadonlyArray<RawItemAppearance>;
     /**
-     * Returns a unique identity key used to track which badges are hidden/toggled off in the legend panel.
-     * Typically implemented as a combination of title and color to ensure uniqueness.
+     * Selection group key for toggle tracking (selection legend toggles).
+     * Used to determine if this marker should be hidden when a selection group is toggled off.
      */
-    getDisplayKey: () => string;
-    getItemId: () => LegendDataId;
+    getSelectionGroupKey: () => LegendSelectionGroupKey;
 }

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

@@ -1,4 +1,4 @@
-import { Marker } from './legendMarkerBadge.type';
+import { RawMarkerData } from './legendMarkerBadge.type';
 import { LegendBadgeOptionConfig, LegendDataId, LegendId, LegendMarkerOptionConfig } from './legendType';
 /**
  * A general interface for the legend strategy. This enables us to automatically render all the legend ui parts: the ui with selectable options, the markers & the badges.
@@ -20,13 +20,13 @@ export interface LegendStrategy {
      */
     badgeOptions?: ReadonlyArray<LegendBadgeOptionConfig>;
     /**
-     * Returns 1 marker with badges for each incoming itemId. The viewport will make them unique when needed, and
-     * also split into groups based on (global) selection tree
+     * Returns raw marker data for each incoming itemId.
+     * Contains the source information and marker data needed to render markers and badges, as well as popover content.
      *
      * @param itemIds - The legend data IDs to create markers for
-     * @returns Array of markers with badges, 1 marker with badges for each incoming itemId
+     * @returns Array of raw marker data, one per incoming itemId
      */
-    useMarkers: (itemIds: ReadonlyArray<LegendDataId>) => ReadonlyArray<Marker>;
+    useRawMarkers: (itemIds: ReadonlyArray<LegendDataId>) => ReadonlyArray<RawMarkerData>;
     /**
      * Returns popover content that supports pagination for the given legendDataId.
      * One legendDataId can have multiple items associated with it, for example a tag can have multiple work orders.
@@ -43,4 +43,9 @@ export interface LegendStrategy {
      * Returns the custom legend component for the legend, if this is omitted the default basicLegendRenderer will be used
      */
     customLegendComponent?: () => React.JSX.Element;
+    /**
+     * When rendering multiple markers for a single legend item (eg. when a tag has multiple work orders), we show a combined marker instead of multiple individual markers to avoid clutter.
+     * This property defines the icon to use for the combined marker. If not provided, a default icon will be used.
+     */
+    readonly combinedMarkerIcon: string;
 }

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

@@ -1,14 +1,15 @@
 import type { NotificationDto } from '@equinor/echo-search';
 import { Brand } from '@equinor/echo-utils';
 import { GlobalSelectionTypes } from '../../globalSelection';
-export type KnownLegendIds = 'Equipment Legend' | 'Tag Legend' | 'Work Order Legend' | 'Notification Legend';
+export type KnownLegendIds = 'Equipment Legend' | 'Tag Legend' | 'Work Order Legend' | 'Notification Legend' | 'IOC Annotation Legend';
 export type LegendId = KnownLegendIds | Brand<string, 'LegendId'>;
 export type LegendDataIdString = Brand<string, 'LegendDataIdString'>;
 export declare const knownLegendIds: {
-    equipmentLegendId: LegendId;
-    tagLegendId: LegendId;
-    workOrderLegendId: LegendId;
-    notificationLegendId: LegendId;
+    equipmentLegendId: "Equipment Legend";
+    tagLegendId: "Tag Legend";
+    workOrderLegendId: "Work Order Legend";
+    notificationLegendId: "Notification Legend";
+    iocAnnotationLegendId: "IOC Annotation Legend";
 };
 export interface LegendState<MarkerOptionType = string, BadgeOptionType = string> {
     readonly legendId: LegendId;
@@ -21,6 +22,10 @@ export type LegendTagId = GlobalSelectionTypes.TagId;
 export type LegendEquipmentId = GlobalSelectionTypes.EquipmentId;
 export type LegendWorkOrderId = GlobalSelectionTypes.WorkOrderId;
 export type LegendNotificationId = Pick<NotificationDto, 'maintenanceRecordId'>;
+export type LegendIocAnnotationId = {
+    readonly iocAnnotationId: number;
+    readonly tagNo: string;
+};
 /**
  * Union of LegendDataId types that correspond to global selection item IDs.
  * These can be safely used with globalSelectionUtils.
@@ -30,7 +35,7 @@ export type LegendNotificationId = Pick<NotificationDto, 'maintenanceRecordId'>;
  * 2. Go to legendDataId.utils.ts and update selectionGuards (this will cause a compile error until you add a guard for the new type)
  */
 export type GlobalSelectionLegendDataId = LegendTagId | LegendEquipmentId | LegendWorkOrderId;
-export type NonGlobalSelectionLegendDataId = LegendNotificationId;
+export type NonGlobalSelectionLegendDataId = LegendNotificationId | LegendIocAnnotationId;
 export type LegendDataId = GlobalSelectionLegendDataId | NonGlobalSelectionLegendDataId;
 /**
  * Base configuration for legend options (markers and badges).
@@ -41,6 +46,7 @@ interface LegendOptionConfigBase<T = string> {
     readonly showChipsInViewportOnly?: boolean;
 }
 export type LegendMarkerOptionConfig<T = string> = LegendOptionConfigBase<T>;
+export type LegendBadgeColorMode = 'status' | 'marker';
 /**
  * Configuration for badge options. Badges can have display options to control
  * how badge text is rendered (displayName, id, or count).
@@ -48,6 +54,11 @@ export type LegendMarkerOptionConfig<T = string> = LegendOptionConfigBase<T>;
 export interface LegendBadgeOptionConfig<T = string> extends LegendOptionConfigBase<T> {
     readonly enableDisplayOptions?: boolean;
     readonly displayOption?: LegendOptionDisplayOption;
+    /**
+     * Controls how badge color is determined. 'status' uses the same status color resolver as markers, while 'marker' inherits the marker color.
+     * When set to 'marker', the generic processRawBadges resolves badge color from marker appearances automatically.
+     */
+    readonly badgeColorMode?: LegendBadgeColorMode;
 }
 export type LegendOptionConfig<T = string> = LegendMarkerOptionConfig<T> | LegendBadgeOptionConfig<T>;
 export declare const ID_MODE_KEYWORD = "id";

package/src/lib/feature/measuringPoint/components/lastRecordedMeasurement/lastRecordedMeasurement.logic.d.ts

@@ -1,8 +1,3 @@
 import { MeasurementDto } from '../../types/measuringPoint';
-export type LastRecordedMeasurementData = {
-    conditionAsText: string | undefined;
-    measurementDateTime: string | undefined;
-    codeAsText: string | undefined;
-    lastRecordedMeasurement: MeasurementDto | undefined;
-};
+import type { LastRecordedMeasurementData } from './lastRecordedMeasurement.types';
 export declare const getLastRecordedMeasurement: (measurements: MeasurementDto[]) => LastRecordedMeasurementData;

package/src/lib/feature/measuringPoint/components/lastRecordedMeasurement/lastRecordedMeasurement.types.d.ts

@@ -0,0 +1,5 @@
+import type { LastRecordedMeasurementInfo } from '@equinor/echo-components';
+import type { MeasurementDto } from '../../types/measuringPoint';
+export type LastRecordedMeasurementData = LastRecordedMeasurementInfo & {
+    readonly lastRecordedMeasurement: MeasurementDto | undefined;
+};

package/src/lib/feature/measuringPoint/components/measuringPointDetails/measuringPointImageList.logic.d.ts

@@ -0,0 +1,6 @@
+import type { DocumentRelationships } from '../../types/documentRelationships';
+import type { Attachment } from './type/attachment';
+export declare function extractValidAttachmentsFromDocumentRelationships(documentRelationships: DocumentRelationships[]): {
+    documentId: string;
+    attachments: Attachment[];
+}[];

package/src/lib/feature/measuringPoint/components/measuringPointDetails/type/attachment.d.ts

@@ -1,6 +1,6 @@
 export interface Attachment {
-    attachmentImageUri?: string;
-    createdDateTime?: string;
-    quantitativeReading: number;
-    quantitativeReadingUnitId: string;
+    readonly attachmentImageUri: string | undefined;
+    readonly createdDateTime: string | undefined;
+    readonly quantitativeReading: number | undefined;
+    readonly quantitativeReadingUnitId: string | undefined;
 }

package/src/lib/feature/measuringPoint/components/measuringPoints.utils.d.ts

@@ -1,4 +1,5 @@
 import { MeasurementDto, MeasuringPointDto } from '../types/measuringPoint';
+import type { Attachment } from './measuringPointDetails/type/attachment';
 type FailureMechanismIdAndValue = {
     id: string;
     value: string;
@@ -16,4 +17,5 @@ export declare function getFailureMechanismConfigValues({ measurement, quantitat
 export declare function getFailureMechanismIdAndValue({ measurement, quantitativeCharacteristicId }: FailureMechanismParams): FailureMechanismIdAndValue | undefined;
 export declare const getLatestMeasurementDate: (point: MeasuringPointDto) => Date | undefined;
 export declare const sortMeasuringPointsByMeasurementDate: (a: MeasuringPointDto, b: MeasuringPointDto) => number;
+export declare function getReportedConditionValueFromAttachment(attachment: Attachment): string;
 export {};

package/src/lib/feature/measuringPoint/hooks/useDocumentRelationships.d.ts

@@ -1,6 +1,6 @@
 export declare function useDocumentRelationships(measuringPointId: string): {
     status: "error" | "success" | "pending";
-    documentRelationships: import("..").DocumentRelationships[];
+    documentRelationships: NoInfer<import("..").DocumentRelationships[]>;
     error: Error | null;
     totalAttachments: string;
 };

package/src/lib/feature/measuringPoint/types/documentRelationships.d.ts

@@ -1,16 +1,16 @@
 export interface DocumentRelationships {
     readonly documentId: string;
-    readonly characteristics?: DocumentRelationshipsCharacteristics[];
-    readonly attachments?: DocumentRelationshipsAttachment[];
+    readonly characteristics: DocumentRelationshipsCharacteristics[] | undefined;
+    readonly attachments: DocumentRelationshipsAttachment[] | undefined;
 }
 interface DocumentRelationshipsAttachment {
     readonly attachmentId: string;
-    readonly attachmentImageUri?: string;
-    readonly createdDateTime?: string;
-    readonly quantitativeReading: number;
-    readonly quantitativeReadingUnitId: string;
+    readonly attachmentImageUri: string | undefined;
+    readonly createdDateTime: string | undefined;
+    readonly quantitativeReading: number | undefined;
+    readonly quantitativeReadingUnitId: string | undefined;
 }
 interface DocumentRelationshipsCharacteristics {
-    readonly valueId?: string;
+    readonly valueId: string | undefined;
 }
 export {};

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

@@ -1,19 +1,19 @@
 import type { MeasuringPointData } from '@equinor/echo-search';
 export interface MeasurementDto {
-    measurementId: string;
-    measuringPointId: string;
-    measurementDateTime?: string;
-    measurementTitle?: string;
-    longTextExists?: string;
-    createdDateTime?: string;
-    maintenanceRecordId?: string;
-    workOrderId?: string;
-    quantitativeReadingInSIUnit?: number;
-    quantitativeReading?: number;
-    quantitativeReadingUnitId?: string;
-    qualitativeCodeGroupId?: string;
-    qualitativeCodeId?: string;
-    longText?: object;
+    readonly measurementId: string;
+    readonly measuringPointId: string;
+    readonly measurementDateTime: string | undefined;
+    readonly measurementTitle: string | undefined;
+    readonly longTextExists: string | undefined;
+    readonly createdDateTime: string | undefined;
+    readonly maintenanceRecordId: string | undefined;
+    readonly workOrderId: string | undefined;
+    readonly quantitativeReadingInSIUnit: number | undefined;
+    readonly quantitativeReading: number | undefined;
+    readonly quantitativeReadingUnitId: string | undefined;
+    readonly qualitativeCodeGroupId: string | undefined;
+    readonly qualitativeCodeId: string | undefined;
+    readonly longText: object | undefined;
 }
 export interface MeasuringPointDto extends MeasuringPointData {
     readonly measurements: MeasurementDto[];