@equinor/echo-framework 4.2.0 → 4.3.0-beta-0

package/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./src/index";
-export { default } from "./src/index";
+export * from "./src\\index";
+export { default } from "./src\\index";

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "4.2.0",
+  "version": "4.3.0-beta-0",
   "peerDependencies": {
-    "@equinor/echo-base": ">= 4.2.0 < 5.0.0",
-    "@equinor/echo-components": ">= 4.2.0 < 5.0.0",
-    "@equinor/echo-core": ">= 4.2.0 < 5.0.0",
-    "@equinor/echo-search": ">= 4.2.0 < 5.0.0",
-    "@equinor/echo-utils": ">= 4.2.0 < 5.0.0",
+    "@equinor/echo-base": "4.3.0-beta-0",
+    "@equinor/echo-components": "4.3.0-beta-0",
+    "@equinor/echo-core": "4.3.0-beta-0",
+    "@equinor/echo-search": "4.3.0-beta-0",
+    "@equinor/echo-utils": "4.3.0-beta-0",
     "@equinor/eds-core-react": "0.49.0",
     "@equinor/eds-icons": "0.22.0",
     "@equinor/eds-tokens": "2.1.0",
@@ -19,11 +19,11 @@
     "react-router-dom": ">= 6.30.3 < 7",
     "zustand": ">= 4.4.7 < 5",
     "immer": ">= 11.1.4 < 12.0.0",
-    "msw": "2.12.10",
+    "msw": ">= 2.0.0 < 3",
     "date-fns": "4.1.0"
   },
   "dependencies": {
-    "dexie": "4.3.0",
+    "dexie": "4.4.2",
     "mark.js": "8.11.1",
     "ag-charts-community": "12.3.1",
     "ag-charts-react": "12.3.1",

package/src/index.d.ts

@@ -19,7 +19,7 @@ export { ReturnToExternalAppButton } from './lib/feature/echoView/ReturnToExtern
 export { fetchEquipmentFromApi } from './lib/feature/equipment/api/api-equipmentWithMeasuringPoints';
 export * from './lib/feature/equipment/index';
 export * from './lib/feature/globalSelection';
-export { SelectionActionBar } from './lib/feature/globalSelection/components/SelectionActionBar';
+export { ItemDetailsSelectionActionBar, SelectionActionBar } from './lib/feature/globalSelection/components/SelectionActionBar';
 export { PanTo3DButton } from './lib/feature/globalSelection/panToEcho3d/panTo3DButton';
 export { useIsAllIGlobalSelectionItemsHidden } from './lib/feature/globalSelection/selectionMenu/hooks/useIsAllIGlobalSelectionItemsHidden';
 export { useSelectionColorFrequencyByIds } from './lib/feature/globalSelection/selectionMenu/hooks/useSelectionColorFrequency';
@@ -137,8 +137,8 @@ declare const EchoFramework: Readonly<{
         usePlantAvailableIn3dWeb(plantCode?: string): boolean;
         useScreenOrientation(): import("./lib/types/hookLibrary").ScreenOrientation;
         useScreenValues(): {
-            isScreenMobileSize: boolean;
-            screenOrientation: import("./lib/types/hookLibrary").ScreenOrientation;
+            readonly isScreenMobileSize: boolean;
+            readonly screenOrientation: import("./lib/types/hookLibrary").ScreenOrientation;
         };
         useSelectionGroupLabelsPerItem: () => Map<string, string[]>;
         useTabTitle(): void;

package/src/lib/components/prepview/panels/tagDocumentRefs/HorizontalDocumentGroups.d.ts

@@ -3,5 +3,5 @@ interface HorizontalDocumentGroupsProps {
     documentGroups: Array<PrepviewDocumentGroup>;
     tagNo: string;
 }
-declare function HorizontalDocumentGroups({ documentGroups, tagNo, }: HorizontalDocumentGroupsProps): import("react/jsx-runtime").JSX.Element;
+declare function HorizontalDocumentGroups({ documentGroups, tagNo }: HorizontalDocumentGroupsProps): import("react/jsx-runtime").JSX.Element;
 export { HorizontalDocumentGroups };

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

@@ -0,0 +1,12 @@
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
+import { type SelectionGroup } from '../../selectionMenu/selectionTreeStore/selectionTree.store.types';
+interface SelectionActionBarMenuItemProps {
+    readonly isInGroup: boolean;
+    readonly group: SelectionGroup;
+    readonly addToSelection: (groupId: Guid, itemId: GlobalSelectionTypes.ItemId) => void;
+    readonly removeFromSelection: (groupId: Guid, itemId: GlobalSelectionTypes.ItemId) => void;
+    readonly itemId: GlobalSelectionTypes.ItemId;
+}
+export declare const SelectionActionBarMenuItem: (props: SelectionActionBarMenuItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -5,3 +5,8 @@ export interface SelectionActionBarProps {
     readonly showPopoverUpdateDelay?: boolean;
 }
 export declare const SelectionActionBar: React.FC<SelectionActionBarProps>;
+/**
+ * Simple wrapper to apply custom styles to the SelectionActionBar when used in the ItemDetails pages,
+ * without affecting the SelectionActionBar used elsewhere.
+ */
+export declare const ItemDetailsSelectionActionBar: (props: SelectionActionBarProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,5 +1,5 @@
+import type { SelectionBarFeedbackType } from '@equinor/echo-components';
 import { Guid } from '@equinor/echo-utils';
-import type { SelectionFeedbackType } from '../components/SelectionActionBar/selectionFeedback.types';
 import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
 /**
  *
@@ -14,7 +14,7 @@ import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionSto
  */
 export declare function useSelectionAction(showPopoverUpdateDelay?: boolean): {
     isLoading: boolean;
-    feedbackType: SelectionFeedbackType | null;
+    feedbackType: SelectionBarFeedbackType | null;
     addToSelection: (groupId: Guid, itemId: GlobalSelectionTypes.ItemId) => Promise<void>;
     removeFromSelection: (groupId: Guid, itemId: GlobalSelectionTypes.ItemId) => void;
     changeColor: (itemId: GlobalSelectionTypes.ItemId, color: string) => void;

package/src/lib/feature/legend/components/BasicLegendRenderer.d.ts

@@ -1,6 +1,6 @@
 import { LegendId } from '../types/legendType';
 interface LegendSelectorMenuProps {
-    legendId: LegendId;
+    readonly legendId: LegendId;
 }
 export declare const BasicLegendRenderer: import("react").NamedExoticComponent<LegendSelectorMenuProps>;
 export {};

package/src/lib/feature/legend/components/LegendSelectorContainer.d.ts

@@ -0,0 +1,17 @@
+import { LegendChipProps } from '@equinor/echo-components';
+import { type LegendOptionConfig } from '../types/legendType';
+interface LegendSelectorContainerProps {
+    readonly selectedOption: LegendOptionConfig;
+    readonly onSelectedOptionChange?: (option: LegendOptionConfig) => void;
+    readonly options: ReadonlyArray<LegendOptionConfig>;
+    readonly legendChips: ReadonlyArray<LegendChipProps>;
+    /** Whether this is a marker or badge selector (affects icon displayed) */
+    readonly variant: 'marker' | 'badge';
+}
+/**
+ * A reusable container for legend selectors that handles both option selection
+ * and display option selection (how the badge text is rendered) based on LegendOptionConfigs.
+ * Display options are only available for badge variants with enableDisplayOptions: true.
+ */
+export declare const LegendSelectorContainer: (props: LegendSelectorContainerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import { type LegendId } from '../../../types/legendType';
+interface ItemMarkerPopoverContainerProps {
+    legendId: LegendId;
+    elements: ReadonlyArray<React.ReactElement>;
+    isPopoverActive: boolean;
+    handleClose: () => void;
+}
+export declare const ItemMarkerPopoverContainer: ({ legendId, elements, isPopoverActive, handleClose }: ItemMarkerPopoverContainerProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/src/lib/feature/legend/components/popover/LegendPopoverContent.d.ts

@@ -1,41 +1,24 @@
-import { FC } from 'react';
-import { Marker } from '../../types/legendMarkerBadge.type';
 import { LegendDataId, LegendId } from '../../types/legendType';
 export interface LegendPopoverContentProps {
     legendId: LegendId;
     legendDataId: LegendDataId;
-    title: string | React.ReactNode;
-    description: string;
-    tertiary?: LegendPopoverTertiaryLabels | React.ReactNode;
     onPopoverClicked?: () => void;
     children?: React.ReactNode;
-    excludedLegendTitles?: ReadonlyArray<string>;
+    excludedChipLegendTitles?: ReadonlyArray<string>;
     showAddToSelectionButton?: boolean;
-    getMarkersForChipsCreation?: () => ReadonlyArray<Marker>;
 }
-export type LegendPopoverTertiaryLabels = {
-    first: string;
-    second?: string;
-    third?: string;
-};
 /**
  * Renders the content for a legend popover, typically used as the content for the ItemMarkerPopover component.
- *
- * Uses `legendId` and `legendDataId` to look up and render relevant `LegendChip` components for the given legend item.
- * Displays a title, description, and optional tertiary content (either a structured object with up to three strings, or a custom ReactNode).
- * Additional custom content can be rendered via `children`.
- * Optionally, chips can be created from markers provided by the `getMarkersForChipsCreation` callback.
+ * The content includes dynamically generated chips based on the markers associated with the provided legendId and legendDataId.
+ * It is possible to exclude certain chips based on their legend titles using props. Chips with excluded titles will not be rendered in the popover.
+ * The component also includes an optional "Add to Selection" button that allows users to add the item to their global selection groups.
  *
  * @component
- * @param {object} props - Component props
  * @param {LegendId} props.legendId - The identifier used to look up legend strategy.
  * @param {LegendDataId} props.legendDataId - The identifier for retrieving the markers.
- * @param {string | React.ReactNode} props.title - The main title of the popover.
- * @param {string} props.description - The description or supporting text.
- * @param {LegendPopoverTertiaryLabels | React.ReactNode} [props.tertiary] - Optional tertiary content. If an object, displays up to three labeled strings; if a ReactNode, renders as-is.
- * @param {() => void} [props.onPopoverClicked] - Optional callback for popover click events.
- * @param {React.ReactNode} [props.children] - Optional custom content to render below the predefined main content.
- * @param {ReadonlyArray<string>} [props.excludedLegendTitles] - Optional array of titles to exclude from the legend chips.
- * @param {() => ReadonlyArray<Marker>} [props.getMarkersForChipsCreation] - Optional callback that returns the markers to be used for chip creation.
+ * @param {() => void} [props.onPopoverClicked] - Optional callback for popover content click events.
+ * @param {React.ReactNode} [props.children] - Optional custom content to render inside the popover content area, will be above chips.
+ * @param {ReadonlyArray<string>} [props.excludedChipLegendTitles] - Optional array of titles to exclude from the legend chips.
+ * @param {boolean} [props.showAddToSelectionButton] - Optional flag to show or hide the "Add to Selection" button.
  */
-export declare const LegendPopoverContent: FC<LegendPopoverContentProps>;
+export declare const LegendPopoverContent: (props: LegendPopoverContentProps) => import("react/jsx-runtime").JSX.Element;

package/src/lib/feature/legend/components/popover/LegendPopoverContent.logic.d.ts

@@ -1,8 +1,7 @@
-import { LegendChipProps } from '@equinor/echo-components';
 import { LegendState } from '../../types/legendType';
 import { Marker } from './../../types/legendMarkerBadge.type';
 /**
- * Returns an array of visible LegendChipProps for the given markers and legend state.
+ * Returns an array of visible PopoverChip for the given markers and legend state.
  *
  * Filters out markers and badges that are hidden (using isHiddenMarker/isHiddenBadge) or whose titles match any value in the
  * excludedLegendTitles array (case-insensitive). Badge chips are only included if selectedMarkerOption !== selectedBadgeOption.
@@ -11,11 +10,18 @@ import { Marker } from './../../types/legendMarkerBadge.type';
  * @param {ReadonlyArray<Marker>} params.markers - The list of marker objects to process.
  * @param {LegendState} params.legend - The legend state, used for filtering and selection logic.
  * @param {ReadonlyArray<string>} [params.excludedLegendTitles] - Optional array of titles to exclude from the chips (case-insensitive).
- * @returns {LegendChipProps[]} The filtered and mapped array of LegendChipProps for rendering.
+ * @returns {PopoverChip[]} The filtered and mapped array of PopoverChip for rendering.
  */
-export declare function getLegendChipsFromMarkers({ markers, legendSelectedBadgeOption, legendSelectedMarkerOption, excludedLegendTitles }: {
+interface GetPopoverChipsParams {
     markers: ReadonlyArray<Marker>;
-    excludedLegendTitles?: ReadonlyArray<string>;
     legendSelectedBadgeOption?: LegendState['selectedBadgeOption'];
     legendSelectedMarkerOption?: LegendState['selectedMarkerOption'];
-}): LegendChipProps[];
+    excludedLegendTitles?: ReadonlyArray<string>;
+}
+interface PopoverChip {
+    text: string;
+    backgroundColor: string;
+    textColor: string;
+}
+export declare function getPopoverChips({ markers, legendSelectedBadgeOption, legendSelectedMarkerOption, excludedLegendTitles }: GetPopoverChipsParams): PopoverChip[];
+export {};

package/src/lib/feature/legend/hooks/useGroupedMarkers.utils.d.ts

@@ -1,9 +1,5 @@
 import { SelectionGroup } from '../../globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.types';
 import { Marker } from '../types/legendMarkerBadge.type';
-/**
- * Checks if a marker has badges from multiple different item IDs.
- */
-export declare const hasBadgesFromMultipleItemIds: (marker: Marker) => boolean;
 /**
  * Gets all potential group keys a marker could generate.
  * Used for per-marker hidden state subscriptions.

package/src/lib/feature/legend/hooks/useLegendMarker/useLegendMarker.utils.d.ts

@@ -18,4 +18,4 @@ export declare const useUniqueVisibleData: () => LegendDataId[];
  * Common logic for creating markers from data using strategy.
  * Selection-based grouping is handled at the viewport rendering level.
  */
-export declare const useCreateMarkers: (legendId: LegendId, data: LegendDataId[], isViewport?: boolean) => ReadonlyArray<Marker>;
+export declare const useCreateMarkers: (legendId: LegendId, data: LegendDataId[]) => ReadonlyArray<Marker>;

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

@@ -4,6 +4,4 @@ import { LegendId } from '../types/legendType';
  * Returns all unique badges for the given legendId, determined by unique title + color.
  * This will also return markers that are not visible on screen.
  */
-export declare function useLegendUniqueBadges(legendId: LegendId, options?: {
-    isViewport?: boolean;
-}): ReadonlyArray<Badge>;
+export declare function useLegendUniqueBadges(legendId: LegendId): ReadonlyArray<Badge>;

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

@@ -4,6 +4,4 @@ import { LegendId } from '../types/legendType';
  * Returns all unique markers for the given legendId, determined by unique displayKey (title + color).
  * This will also return markers that are not visible on screen.
  */
-export declare function useLegendUniqueMarkers(legendId: LegendId, options?: {
-    isViewport?: boolean;
-}): ReadonlyArray<Marker>;
+export declare function useLegendUniqueMarkers(legendId: LegendId): ReadonlyArray<Marker>;

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: {