@equinor/echo-framework 4.2.0 → 4.3.0

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

@@ -2,22 +2,25 @@ import './legendStrategies/notificationStrategy/notificationStrategy';
 import './legendStrategies/workOrderStrategy/WorkOrderLegend';
 export { getBadgeChips, getMarkerChips } from './components/basicLegendRenderer.logic';
 export { LegendList } from './components/LegendList';
-export { LegendTextSelector } from './components/legendTextSelector/LegendTextSelector';
+export { LegendSelectorContainer } from './components/LegendSelectorContainer';
 export { PositionalItem } from './components/pdfMarkers/PositionalItem';
 export { MultipleMarkersByLegends } from './components/pdfMarkers/subComponents/MultipleMarkersByLegends';
 export { LegendPopoverContent } from './components/popover/LegendPopoverContent';
-export type { LegendPopoverContentProps, LegendPopoverTertiaryLabels } from './components/popover/LegendPopoverContent';
+export type { LegendPopoverContentProps } from './components/popover/LegendPopoverContent';
 export { trackEventNewLegendAccordionToggled, trackEventNewLegendSelectedBadgeOptionChanged, trackEventNewLegendSelectedMarkerOptionChanged } from './legendAnalytics';
 export { legendFacade } from './legendFacade';
 export { getLegendStrategy } from './legendStrategies/legendCollections';
 export { legendSnapShot } from './stores/legendDataStore/legendStore';
 export type { Badge, Marker } from './types/legendMarkerBadge.type';
 export type { LegendStrategy } from './types/legendStrategy.type';
-export type { LegendId, LegendOptionConfig } from './types/legendType';
+export type { LegendBadgeOptionConfig, LegendId, LegendMarkerOptionConfig, LegendOptionConfig, LegendOptionDisplayOption } from './types/legendType';
 export { useLegendUniqueBadges } from './hooks/useLegendUniqueBadges';
 export { useLegendUniqueMarkers } from './hooks/useLegendUniqueMarkers';
 export { useOpenWorkOrdersByTagNos } from './hooks/useWorkOrdersByTagNos';
 export { useWorkOrdersByTagsQuery } from './hooks/useWorkOrdersByTagsQuery';
-export { COUNT_MODE_KEYWORD } from './logic/normalizeBadges';
-export { useLegendVisibleDataStore } from './stores/legendVisibleDataStore/legendVisibleDataStore';
+export { isCountMode, isIdMode, normalizeBadges } from './logic/normalizeBadges';
+export { getColorForLegendStatus } from './logic/getColorForLegendStatus';
+export { createArrayAccessor, createCountAccessor, createDateAccessor, createStringAccessor, getPropertyValues, toSingleTitle } from './logic/propertyAccessor.utils';
+export type { PropertyAccessor } from './logic/propertyAccessor.utils';
 export { useLegendUIStore } from './stores/legendUIStore/legendUIStore';
+export { useLegendVisibleDataStore } from './stores/legendVisibleDataStore/legendVisibleDataStore';

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

@@ -0,0 +1,7 @@
+import { NotificationDto } from '@equinor/echo-search';
+export declare function createFunctionalLocationList(tagNos: ReadonlyArray<string>, plantNo: string): ReadonlyArray<string>;
+export interface RequestTagsNotifications {
+    readonly tagNos: ReadonlyArray<string>;
+    readonly instCode: string;
+}
+export declare function getOpenNotificationsForTagsApi({ instCode, tagNos }: RequestTagsNotifications): Promise<ReadonlyArray<NotificationDto>>;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/components/NotificationPopover.d.ts

@@ -0,0 +1,8 @@
+import type { NotificationItemCardData } from '@equinor/echo-components';
+import { type LegendDataId } from '../../../types/legendType';
+interface NotificationPopoverProps {
+    legendDataId: LegendDataId;
+    notification: NotificationItemCardData;
+}
+export declare const NotificationPopover: (props: NotificationPopoverProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+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.
+ */
+export declare const useNotificationMarkers: (itemIds: ReadonlyArray<LegendDataId>) => ReadonlyArray<Marker>;

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

@@ -0,0 +1,14 @@
+import { TagNo, type NotificationDto } from '@equinor/echo-search';
+import { type LegendTagId } from '../../../types/legendType';
+export interface TagNotificationGroup {
+    readonly tagId: TagNo;
+    readonly notifications: ReadonlyArray<NotificationDto>;
+}
+interface UseNotificationsByTagIdsResult {
+    readonly data: ReadonlyArray<TagNotificationGroup>;
+    readonly error: Error | undefined;
+    readonly isFetching: boolean;
+}
+export declare const useNotificationsByTagIds: (enabled: boolean, tagIds: ReadonlyArray<LegendTagId>) => UseNotificationsByTagIdsResult;
+export declare const groupNotificationsByTagId: (notifications: ReadonlyArray<NotificationDto>) => ReadonlyArray<TagNotificationGroup>;
+export {};

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

@@ -0,0 +1,12 @@
+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;
+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

@@ -0,0 +1,12 @@
+import { NotificationDto } from '@equinor/echo-search';
+import type { Badge, Marker } from '../../../types/legendMarkerBadge.type';
+import type { LegendBadgeOptionConfig, LegendMarkerOptionConfig } from '../../../types/legendType';
+interface CreateMarkerFromNotificationsArgs {
+    readonly notifications: ReadonlyArray<NotificationDto>;
+    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 {};

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

@@ -0,0 +1,5 @@
+import type { LegendStatus } from '../../../legacyLegend/legend';
+import type { NotificationBadgeOptions } from './optionConfigs/notificationBadgeLegendOptionConfig';
+import type { NotificationMarkerOptions } from './optionConfigs/notificationMarkerLegendOptionConfig';
+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;

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

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

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

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

package/src/lib/feature/legend/legendStrategies/notificationStrategy/testing/createTestNotification.d.ts

@@ -0,0 +1,2 @@
+import type { NotificationDto } from '@equinor/echo-search';
+export declare const createTestNotification: (overrides?: Partial<NotificationDto>) => NotificationDto;

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

@@ -0,0 +1,7 @@
+import type { LegendOptionConfig } from '../../../types/legendType';
+/**
+ * Determines the appropriate color for a notification legend item based on its title and the selected property.
+ * It uses a predefined color mapping for specific notification properties,
+ * and falls back to a general status color if no specific mapping is found.
+ */
+export declare const getColorForNotificationLegendStatus: (title: string, selectedProperty: LegendOptionConfig) => string;

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

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

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

@@ -0,0 +1,12 @@
+import { NotificationDto } from '@equinor/echo-search';
+import type { EndDateStatusText } from '../notificationStrategy.types';
+/**
+ * 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;
+/**
+ * Returns user-friendly end date status text based on the required end date of a notification.
+ */
+export declare function getEndDateStatusText(date: Date | undefined): EndDateStatusText;

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

@@ -0,0 +1,5 @@
+/**
+ * Wrapper for pre-existing legend status colors, to avoid importing legacy utils into new legend code.
+ * Also handles new 'Unknown' and 'Multiple' statuses correctly, which legacy utils do not.
+ */
+export declare const getColorForLegendStatus: (status: string) => string;

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

@@ -1,17 +1,19 @@
 import { Badge } from '../types/legendMarkerBadge.type';
+import { type LegendOptionDisplayOption } from '../types/legendType';
 /**
- * Keyword used to identify count mode in badge text options. This changes
- * the way we normalize badges.
+ * Determines if count mode should be enabled based on badge text option.
+ *
+ * @param badgeDisplayOption - Badge text configuration option from legend state
+ * @returns Whether count mode should be enabled
  */
-export declare const COUNT_MODE_KEYWORD = "Count";
+export declare function isCountMode(badgeDisplayOption?: LegendOptionDisplayOption): boolean;
 /**
- * Determines if count mode should be enabled based on badge text options.
- * Count mode is enabled when any option value exactly equals 'Count'.
+ * Determines if ID mode should be enabled based on badge display option.
  *
- * @param badgeTextOptions - Badge text configuration options from legend state
- * @returns Whether count mode should be enabled
+ * @param badgeDisplayOption - Badge text configuration option from legend state
+ * @returns Whether ID mode should be enabled
  */
-export declare function isCountMode(badgeTextOptions: Record<string, string> | undefined): boolean;
+export declare function isIdMode(badgeDisplayOption?: LegendOptionDisplayOption): boolean;
 /**
  * Creates badges with count displayed as title.
  * Takes all badges (including duplicates) and unique badges, and returns unique badges
@@ -23,11 +25,22 @@ export declare function isCountMode(badgeTextOptions: Record<string, string> | u
  */
 export declare function createBadgesWithCount(allBadges: ReadonlyArray<Badge>, uniqueBadges: ReadonlyArray<Badge>): Badge[];
 /**
- * Normalizes badges for display by removing duplicates and optionally applying count mode.
- * Count mode is determined from the badge text options configuration.
+ * Creates badges with their item's ID displayed as title.
+ * Each badge's title is replaced with the primary identifier from its itemId.
+ *
+ * @param badges - Array of badges to transform
+ * @returns Array of badges with item ID as title
+ */
+export declare function createBadgesWithId(badges: ReadonlyArray<Badge>): Badge[];
+/**
+ * Normalizes badges for display by removing duplicates and applying display mode transformations.
+ * Supports three display modes:
+ * - 'displayName' (default): Shows the original badge title
+ * - 'id': Shows the item's primary identifier (tagNo, equipmentId, workOrderId)
+ * - 'count': Shows the count of badges with the same title
  *
  * @param badges - Array of badges to normalize
- * @param badgeTextOptions - Badge text configuration options from legend state
+ * @param badgeDisplayOption - Badge display option from legend state ('displayName' | 'id' | 'count')
  * @returns Normalized array of badges
  */
-export declare function normalizeBadges(badges: ReadonlyArray<Badge>, badgeTextOptions: Record<string, string> | undefined): Badge[];
+export declare function normalizeBadges(badges: ReadonlyArray<Badge>, badgeDisplayOption?: LegendOptionDisplayOption): Badge[];

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

@@ -0,0 +1,36 @@
+/**
+ * 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>;
+/**
+ * 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>>;
+/**
+ * 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>>;
+/**
+ * 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>>;
+/**
+ * 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;

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

@@ -1,10 +1,9 @@
 import type { LegendStrategy } from '../types/legendStrategy.type';
-import type { LegendOptionConfig } from '../types/legendType';
+import type { LegendBadgeOptionConfig, LegendMarkerOptionConfig } from '../types/legendType';
 export interface InitialValues {
     readonly isEnabled?: boolean;
-    readonly selectedMarkerOption?: LegendOptionConfig;
-    readonly selectedBadgeOption?: LegendOptionConfig;
-    readonly selectedBadgeTextOptions?: Record<string, string>;
+    readonly selectedMarkerOption?: LegendMarkerOptionConfig;
+    readonly selectedBadgeOption?: LegendBadgeOptionConfig;
 }
 /**
  * Ensures that a legend exists in all relevant stores. If the legend already exists,

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

@@ -11,7 +11,6 @@ export interface LegendStoreActions {
     setIsEnabled: (legendId: LegendId, isEnabled: boolean) => void;
     setSelectedMarkerOption: (legendId: LegendId, option: LegendState['selectedMarkerOption']) => void;
     setSelectedBadgeOption: (legendId: LegendId, option: LegendState['selectedBadgeOption']) => void;
-    setSelectedBadgeTextOptions: (legendId: LegendId, options: LegendState['selectedBadgeTextOptions']) => void;
 }
 type LegendStore = LegendStoreData & LegendStoreActions;
 /**

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

@@ -1,7 +1,7 @@
-import type { SelectionFeedbackType } from '../../../globalSelection/components/SelectionActionBar/selectionFeedback.types';
+import type { SelectionBarFeedbackType } from '@equinor/echo-components';
 import { MarkerId } from '../../components/pdfMarkers/utils/markerId.utils';
 import { LegendId } from '../../types/legendType';
-export type { SelectionFeedbackType };
+export type { SelectionBarFeedbackType } from '@equinor/echo-components';
 export type LegendFeedbackVariant = 'error' | 'info' | 'warning';
 export interface LegendUIState {
     readonly accordionFeedback?: {
@@ -13,7 +13,7 @@ export interface LegendUIState {
     readonly hiddenBadges: string[];
 }
 export type LegendUIDictionary = Record<LegendId, LegendUIState>;
-export type MarkersOutsideSelectionVisibility = 'Show' | 'Ghost' | 'Hide';
+export type MarkersOutsideSelectionVisibility = 'show' | 'ghost' | 'hide';
 export type LegendUIStoreValues = {
     readonly legends: LegendUIDictionary;
     readonly activePopover: {
@@ -21,7 +21,7 @@ export type LegendUIStoreValues = {
         readonly elements: ReadonlyArray<React.ReactElement>;
         readonly selectionFeedback?: {
             readonly isLoading: boolean;
-            readonly feedbackType: SelectionFeedbackType | null;
+            readonly feedbackType: SelectionBarFeedbackType | null;
         };
     };
     readonly selectionLegend: {
@@ -54,7 +54,7 @@ export interface LegendUIStoreActions {
     setActivePopoverElements: (elements: ReadonlyArray<React.ReactElement>) => void;
     setPopoverSelectionFeedback: (feedback: {
         isLoading: boolean;
-        feedbackType: SelectionFeedbackType | null;
+        feedbackType: SelectionBarFeedbackType | null;
     } | undefined) => void;
     setShouldDelayPopoverUpdate: (delay: boolean) => void;
     setAccordionFeedback: (legendId: LegendId, feedback: {

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

@@ -1,5 +1,5 @@
 import { Marker } from './legendMarkerBadge.type';
-import { LegendDataId, LegendId, LegendOptionConfig } from './legendType';
+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.
  * The specific implementation (like tagStrategy, equipmentStrategy, etc) will implement this, and inject it with legendFacade.injectLegendStrategy.
@@ -12,21 +12,21 @@ export interface LegendStrategy {
     /**
      * Marker options that is selectable by the user.
      */
-    markerOptions?: ReadonlyArray<LegendOptionConfig>;
+    markerOptions?: ReadonlyArray<LegendMarkerOptionConfig>;
     /**
      * Badge options that is selectable by the user.
+     * Each badge option can have enableDisplayOptions: true to show display options (id, count, displayName).
+     * The displayOption property controls how the badge text is rendered.
      */
-    badgeOptions?: ReadonlyArray<LegendOptionConfig>;
-    getBadgeTextOptions?: (selectedBadgeOption: LegendOptionConfig) => ReadonlyArray<string> | undefined;
+    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
      *
      * @param itemIds - The legend data IDs to create markers for
-     * @param isViewport - Optional use this for rendering different markers/badges in viewport compared to legendRenderer. For example equipmentLegend, where we render part-type name in legendRenderer, but id in viewport.
      * @returns Array of markers with badges, 1 marker with badges for each incoming itemId
      */
-    useMarkers: (itemIds: ReadonlyArray<LegendDataId>, isViewport?: boolean) => ReadonlyArray<Marker>;
+    useMarkers: (itemIds: ReadonlyArray<LegendDataId>) => ReadonlyArray<Marker>;
     /**
      * 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.

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

@@ -1,3 +1,4 @@
+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';
@@ -9,20 +10,17 @@ export declare const knownLegendIds: {
     workOrderLegendId: LegendId;
     notificationLegendId: LegendId;
 };
-export interface LegendState {
+export interface LegendState<MarkerOptionType = string, BadgeOptionType = string> {
     readonly legendId: LegendId;
     readonly isEnabled: boolean;
     readonly isLoading: boolean;
-    readonly selectedMarkerOption: LegendOptionConfig;
-    readonly selectedBadgeOption: LegendOptionConfig;
-    readonly selectedBadgeTextOptions: Record<string, string>;
+    readonly selectedMarkerOption: LegendMarkerOptionConfig<MarkerOptionType>;
+    readonly selectedBadgeOption: LegendBadgeOptionConfig<BadgeOptionType>;
 }
 export type LegendTagId = GlobalSelectionTypes.TagId;
 export type LegendEquipmentId = GlobalSelectionTypes.EquipmentId;
 export type LegendWorkOrderId = GlobalSelectionTypes.WorkOrderId;
-export type LegendNotificationId = {
-    testId: string;
-};
+export type LegendNotificationId = Pick<NotificationDto, 'maintenanceRecordId'>;
 /**
  * Union of LegendDataId types that correspond to global selection item IDs.
  * These can be safely used with globalSelectionUtils.
@@ -32,18 +30,27 @@ export type LegendNotificationId = {
  * 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;
-type NonGlobalSelectionLegendDataId = LegendNotificationId;
+export type NonGlobalSelectionLegendDataId = LegendNotificationId;
 export type LegendDataId = GlobalSelectionLegendDataId | NonGlobalSelectionLegendDataId;
-export interface LegendOptionConfig<T = string> {
-    propertyName: T;
-    /**
-     * The idea with this is to use it with general rules for strategies US.
-     * Indicates whether the propertyName corresponds to a field in an object structure.
-     * When true, propertyName refers to an actual field in a data object.
-     * When false, propertyName is just a string identifier not tied to object fields.
-     * Comment it in when it is needed.
-     */
-    displayName: string;
-    showChipsInViewportOnly?: boolean;
+/**
+ * Base configuration for legend options (markers and badges).
+ */
+interface LegendOptionConfigBase<T = string> {
+    readonly propertyName: T;
+    readonly displayName: string;
+    readonly showChipsInViewportOnly?: boolean;
+}
+export type LegendMarkerOptionConfig<T = string> = LegendOptionConfigBase<T>;
+/**
+ * Configuration for badge options. Badges can have display options to control
+ * how badge text is rendered (displayName, id, or count).
+ */
+export interface LegendBadgeOptionConfig<T = string> extends LegendOptionConfigBase<T> {
+    readonly enableDisplayOptions?: boolean;
+    readonly displayOption?: LegendOptionDisplayOption;
 }
+export type LegendOptionConfig<T = string> = LegendMarkerOptionConfig<T> | LegendBadgeOptionConfig<T>;
+export declare const ID_MODE_KEYWORD = "id";
+export declare const COUNT_MODE_KEYWORD = "count";
+export type LegendOptionDisplayOption = 'displayName' | typeof ID_MODE_KEYWORD | typeof COUNT_MODE_KEYWORD;
 export {};

package/src/lib/hooks/useOpenPdfFile.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Hook that returns a callback to open a standard PDF file in the viewer.
+ * Navigates to `/viewer` with `docNo`, `fileId`, and `revNo` as query params.
+ *
+ * @returns A callback that accepts `{ instCode, docNo, fileId, revNo, tagNo? }` and navigates to the viewer.
+ */
 export declare function useOpenPdfFile(): (args: {
     instCode: string;
     docNo: string;
@@ -5,6 +11,12 @@ export declare function useOpenPdfFile(): (args: {
     revNo: string;
     tagNo?: string;
 }) => void;
+/**
+ * Hook that returns a callback to open a loop file (external URL) in the viewer.
+ * Navigates to `/viewer` with `fileUrl` as query param instead of `fileId`.
+ *
+ * @returns A callback that accepts `{ instCode, fileUrl, tagNo? }` and navigates to the viewer.
+ */
 export declare function useOpenPdfFileUrl(): (args: {
     instCode: string;
     fileUrl: string;

package/src/lib/hooks/useScreenValues.d.ts

@@ -6,8 +6,8 @@ import { ScreenOrientation } from '../types/hookLibrary';
  * @returns {ScreenOrientation} response.screenOrientation
  */
 type DeviceValues = {
-    isScreenMobileSize: boolean;
-    screenOrientation: ScreenOrientation;
+    readonly isScreenMobileSize: boolean;
+    readonly screenOrientation: ScreenOrientation;
 };
 export declare function useScreenValues(): DeviceValues;
 export {};

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

@@ -30,6 +30,7 @@ interface DataLayerPanelActions {
     toggleEquipmentsFromSelectionVisible: () => void;
     setEquipmentsForEcm: () => void;
     toggleIocAnnotations: () => void;
+    toggleNotifications: () => void;
     setIsDataFromStidAnnoDetails: (value: boolean) => void;
 }
 export type DataLayerPanelStore = DataLayerPanelState & DataLayerPanelActions;
@@ -74,6 +75,7 @@ export declare const useDataLayerPanelStore: import("zustand").UseBoundStore<Omi
         toggleEquipmentsFromSelectionVisible: () => void;
         setEquipmentsForEcm: () => void;
         toggleIocAnnotations: () => void;
+        toggleNotifications: () => void;
         setIsDataFromStidAnnoDetails: (value: boolean) => void;
     }) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;

package/src/lib/feature/globalSelection/components/SelectionActionBar/SelectionFeedbackDisplay.d.ts

@@ -1,7 +0,0 @@
-import type { SelectionFeedbackType } from './selectionFeedback.types';
-interface SelectionFeedbackDisplayProps {
-    readonly feedbackType: SelectionFeedbackType;
-    readonly className?: string;
-}
-export declare const SelectionFeedbackDisplay: React.FC<SelectionFeedbackDisplayProps>;
-export {};

package/src/lib/feature/globalSelection/components/SelectionActionBar/selectionFeedback.types.d.ts

@@ -1 +0,0 @@
-export type SelectionFeedbackType = 'added' | 'removed' | 'addError' | 'removeError' | 'colorChanged' | 'colorChangeError';

package/src/lib/feature/globalSelection/components/SelectionActionBar.d.ts

@@ -1,7 +0,0 @@
-import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
-export interface SelectionActionBarProps {
-    readonly itemId: GlobalSelectionTypes.ItemId;
-    readonly className?: string;
-    readonly showPopoverUpdateDelay?: boolean;
-}
-export declare const SelectionActionBar: React.FC<SelectionActionBarProps>;

package/src/lib/feature/globalSelection/components/SelectionMenuTrigger/SelectionGroupMenuItem.d.ts

@@ -1,9 +0,0 @@
-import { Guid } from '@equinor/echo-utils';
-import { SelectionGroup } from '../../selectionMenu/selectionTreeStore/selectionTree.store.types';
-interface SelectionGroupMenuItemProps {
-    readonly group: SelectionGroup;
-    readonly isItemInGroup: boolean;
-    readonly onSelectionChanged: (groupId: Guid) => void;
-}
-export declare const SelectionGroupMenuItem: (props: SelectionGroupMenuItemProps) => import("react/jsx-runtime").JSX.Element;
-export {};

package/src/lib/feature/globalSelection/components/SelectionMenuTrigger/SelectionMenuTrigger.d.ts

@@ -1,12 +0,0 @@
-import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
-interface SelectionMenuTriggerProps {
-    readonly itemId: GlobalSelectionTypes.ItemId;
-    readonly onAddToSelection: (groupId: Guid) => void;
-    readonly onRemoveFromSelection: (groupId: Guid) => void;
-    readonly partOfListsText?: string;
-    readonly isError?: boolean;
-    readonly isLoading?: boolean;
-}
-export declare const SelectionMenuTrigger: (props: SelectionMenuTriggerProps) => import("react/jsx-runtime").JSX.Element;
-export {};

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

@@ -1,20 +0,0 @@
-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.
- *
- * Displays each option as a button, highlights the currently selected option, and calls the `onSelect` callback when a different option is chosen.
- * Uses Echo UI components and compact density for consistent styling.
- *
- * @component
- * @param {object} props - Component props
- * @param {ReadonlyArray<string>} props.options - List of selectable options.
- * @param {string} props.selectedOption - The currently selected option.
- * @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: <T extends string>(props: LegendTextSelectorProps<T>) => import("react/jsx-runtime").JSX.Element | null;
-export {};

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/components/WorkOrderPopoverPrimaryRow.d.ts

@@ -1,15 +0,0 @@
-/**
- * Renders the primary (first) row of the Work Order popover.
- *
- * Displays the work order number, an active/completed status label, and (if present)
- * a list of unique notification type identifiers resolved for the work order.
- *
- * @param props \- Component props.
- * @param props.workOrderId \- Work order identifier used for display and for fetching related objects.
- * @param props.isActive \- Whether the work order is active \(`true`\) or completed \(`false`\).
- * @returns A React element containing the primary row content.
- */
-export declare const WorkOrderPopoverPrimaryRow: ({ workOrderId, isActive }: {
-    workOrderId: string;
-    isActive: boolean;
-}) => import("react/jsx-runtime").JSX.Element;

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/components/WorkOrderPopoverThirdRow.d.ts

@@ -1,16 +0,0 @@
-/**
- * Renders the 3rd row in the Work Order popover (plant, work center, and finish date).
- *
- * @param props \- Component props.
- * @param props.plantNo \- The plant identifier/number to display.
- * @param props.workCenter \- The work center identifier to display.
- * @param props.basicFinishDateTime \- Optional planned/basic finish date/time for the work order.
- * @param props.basicFinishDateStatus \- Optional status label associated with the finish date (e.g. overdue, upcoming).
- * @returns A React element containing the 3rd row content.
- */
-export declare const WorkOrderPopoverThirdRow: ({ plantNo, workCenter, basicFinishDateTime, basicFinishDateStatus }: {
-    plantNo: string;
-    workCenter: string;
-    basicFinishDateTime: Date | undefined;
-    basicFinishDateStatus: string | undefined;
-}) => import("react/jsx-runtime").JSX.Element;