@equinor/echo-framework 2.2.1 → 2.2.3

package/package.json

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

package/src/index.d.ts

@@ -26,7 +26,8 @@ export * from './lib/feature/legacyLegend/index';
 export { PositionalLegendMarkers } from './lib/feature/legend/components/pdfMarkers/PositionalLegendMarkers';
 export { PopoverLoading } from './lib/feature/legend/components/pdfMarkers/subComponents/components/PopoverLoading';
 export * from './lib/feature/legend/index';
-export { legendVisibleTagsSubscribeToStore } from './lib/feature/legend/legendVisibleDataAsTagsStore';
+export { legendVisibleTagsSubscribeToStore } from './lib/feature/legend/stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore';
+export { knownLegendIds } from './lib/feature/legend/types/legendType';
 export type { LegendDataId, LegendEquipmentId, LegendState, LegendTagId } from './lib/feature/legend/types/legendType';
 export { getLatestMeasurementDate, sortMeasuringPointsByMeasurementDate } from './lib/feature/measuringPoint/components/measuringPoints.utils';
 export * from './lib/feature/measuringPoint/index';
@@ -50,7 +51,7 @@ export { RegisteredComponentName } from './lib/services/componentRegistry/compon
 export * from './lib/services/dataLayerPanel';
 export { EchoViewInspectionToolMode } from './lib/services/echoViewService/echoView.type';
 export type { EchoView, EchoViewEcmPdfInspectionToolConfig, EchoViewSyncSettings } from './lib/services/echoViewService/echoView.type';
-export { echoViewService, echoViewServiceAPI, setEchoView, clearEchoView } from './lib/services/echoViewService/echoViewService';
+export { clearEchoView, echoViewService, echoViewServiceAPI, setEchoView } from './lib/services/echoViewService/echoViewService';
 export * from './lib/services/eventHubActions';
 export * from './lib/services/leftPanelNavigation';
 export * from './lib/services/locationService/locationService';

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

@@ -8,6 +8,7 @@ export { useGlobalSelectionItemsByType } from './hooks/useGlobalSelectionItemsBy
 export { useGlobalSelectionLists } from './hooks/useGlobalSelectionLists';
 export { useGlobalSelectionTags } from './hooks/useGlobalSelectionTags';
 export { useGlobalSelectionWorkOrders } from './hooks/useGlobalSelectionWorkOrders';
+export { useIsInGlobalSelection } from './hooks/useIsInGlobalSelection';
 export { useSelectionCategoriesByGroupId } from './hooks/useSelectionCategoriesByGroupId';
 export { useCurrentSelectionId } from './selectionMenu/hooks/useCurrentSelectionId';
 export { useFetchSelectionHistory } from './selectionMenu/hooks/useFetchSelectionHistory';

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

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

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

@@ -0,0 +1,6 @@
+import { LegendId } from '../types/legendType';
+interface LegendWrapperProps {
+    legendId: LegendId;
+}
+export declare const LegendRendererWrapper: (props: LegendWrapperProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/src/lib/feature/legend/components/basicLegendRenderer.logic.d.ts

@@ -1,5 +1,5 @@
 import { LegendChipProps } from '@equinor/echo-components';
 import { Badge, Marker } from '../types/legendMarkerBadge.type';
 import { LegendState } from '../types/legendType';
-export declare const getMarkerChips: (markers: ReadonlyArray<Marker>, legend: LegendState) => LegendChipProps[];
-export declare const getBadgeChips: (badges: ReadonlyArray<Badge>, legend: LegendState) => LegendChipProps[];
+export declare const getMarkerChips: (markers: ReadonlyArray<Marker>, legend: LegendState, hiddenMarkers: string[]) => LegendChipProps[];
+export declare const getBadgeChips: (badges: ReadonlyArray<Badge>, legend: LegendState, hiddenBadges: string[]) => LegendChipProps[];

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

@@ -1,13 +1,33 @@
 import { ItemMarkerSize } from '@equinor/echo-components';
 import React from 'react';
-import { LegendDataId, LegendId } from '../../../types/legendType';
+import { Marker } from '../../../types/legendMarkerBadge.type';
 interface LegendColoredMarkerIconProps {
-    legendId: LegendId;
-    itemId: LegendDataId;
     hasPointer: boolean;
     isActive: boolean;
     onClick: () => void;
+    hiddenBadges: string[];
+    marker: Marker;
 }
-export declare const MemoizedLegendColoredMarkerIcon: React.NamedExoticComponent<LegendColoredMarkerIconProps>;
+/**
+ * Renders a colored marker icon with optional pointer and badges.
+ *
+ * @param {boolean} hasPointer - Flag to indicate if the marker should have a pointer, currently in lower right corner.
+ * @param {boolean} isActive - Flag to indicate if the marker is active (selected).
+ * @param {() => void} onClick - Callback invoked when the marker is clicked.
+ * @param {string[]} hiddenBadges - Array of badge titles that should be hidden.
+ * @param {Marker} marker - The marker data to be rendered.
+ *
+ * @returns {JSX.Element | null} The rendered colored marker icon or null if no marker is provided.
+ *
+ * @example
+ * <LegendColoredMarkerIcon
+ *   hasPointer={true}
+ *   isActive={false}
+ *   onClick={() => console.log('Marker clicked')}
+ *   hiddenBadges={['Badge1', 'Badge2']}
+ *   marker={markerData}
+ * />
+ */
+export declare const LegendColoredMarkerIcon: React.FC<LegendColoredMarkerIconProps>;
 export declare const MARKER_ICON_WIDTH = ItemMarkerSize.Default;
 export {};

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

@@ -4,6 +4,8 @@ interface LegendPositionItem {
     itemId: LegendDataId;
     positionString: string;
     hasPointer: boolean;
+    /** Unique identifier that doesn't change on viewport changes */
+    uniqueIdentifier: string;
 }
 interface LegendMarkersRendererProps {
     positionItems: ReadonlyArray<LegendPositionItem>;

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

@@ -1,35 +1,12 @@
-import React from 'react';
-import { LegendDataId, LegendId } from '../../../types/legendType';
+import { LegendDataId } from '../../../types/legendType';
+import { PopoverContent, RequestPopoverHandler } from './hooks/usePopoverHandler.types';
 interface MultipleMarkersByLegendsProps {
     itemId: LegendDataId;
     hasPointer: boolean;
     onOpenPopover: RequestPopoverHandler;
     onClosePopover: () => void;
     currentPopover?: PopoverContent;
-    positionString: string;
+    uniqueIdentifier: string;
 }
-export type RequestPopoverHandler = (itemId: LegendDataId, legendId: LegendId, positionString: string, fetchPopoverContent: () => Promise<ReadonlyArray<React.JSX.Element>>) => void;
-export interface PopoverContent {
-    elements: ReadonlyArray<JSX.Element>;
-    activeItem: ActiveItem;
-}
-/**
- * We use active for the icon. Several icons might be active if they have the same tagNo on the PDF, but only 1 of them is open.
- */
-interface ActiveItem {
-    itemId: LegendDataId;
-    legendId: LegendId;
-    positionString: string;
-}
-/**
- * Renders 1 marker for each legend.
- *
- * @param {LegendDataId} itemId - The ID of the legend item.
- * @param {boolean} hasPointer - Flag to indicate if the marker should have a pointer, currently in lower right corner.
- * @param {RequestPopoverHandler} onOpenPopover - Callback invoked when a marker is clicked; fetchPopoverContent should be called to fetch/populate the popover.
- * @param {() => void} onClosePopover - Callback invoked to close the popover
- * @param {(value: PopoverContent | undefined) => void} setOpenItem - Callback function to handle opening the popover.
- */
-export declare const MultipleMarkersByLegendsComponent: React.FC<MultipleMarkersByLegendsProps>;
-export declare const MultipleMarkersByLegends: React.NamedExoticComponent<MultipleMarkersByLegendsProps>;
+export declare const MultipleMarkersByLegends: import("react").MemoExoticComponent<(props: MultipleMarkersByLegendsProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

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

@@ -0,0 +1,10 @@
+import { LegendDataId, LegendId } from '../../../types/legendType';
+interface MultipleMarkersBySingleLegendComponentProps {
+    legendId: LegendId;
+    itemId: LegendDataId;
+    hasPointer: boolean;
+    isActive: boolean;
+    onClick: () => void;
+}
+export declare const MultipleMarkersBySingleLegend: import("react").MemoExoticComponent<(props: MultipleMarkersBySingleLegendComponentProps) => import("react/jsx-runtime").JSX.Element[] | null>;
+export {};

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

@@ -1,7 +1,7 @@
 import { LegendDataId, LegendId } from '../../../../types/legendType';
-import { PopoverContent } from '../MultipleMarkersByLegends';
+import { PopoverContent } from './usePopoverHandler.types';
 export declare function usePopoverHandler(): {
     currentPopover: PopoverContent | undefined;
-    handleOpenPopover: (itemId: LegendDataId, legendId: LegendId, positionString: string, fetchPopoverContent: () => Promise<ReadonlyArray<React.JSX.Element>>) => Promise<void>;
+    handleOpenPopover: (itemId: LegendDataId, legendId: LegendId, uniqueIdentifier: string, fetchPopoverContent: () => Promise<ReadonlyArray<React.JSX.Element>>) => Promise<void>;
     handleClosePopover: () => void;
 };

package/src/lib/feature/legend/components/pdfMarkers/subComponents/hooks/usePopoverHandler.types.d.ts

@@ -0,0 +1,14 @@
+import { LegendDataId, LegendId } from '../../../../types/legendType';
+export type RequestPopoverHandler = (itemId: LegendDataId, legendId: LegendId, uniqueIdentifier: string, fetchPopoverContent: () => Promise<ReadonlyArray<React.JSX.Element>>) => void;
+export interface PopoverContent {
+    elements: ReadonlyArray<JSX.Element>;
+    activeItem: ActiveItem;
+}
+/**
+ * We use active for the icon. Several icons might be active if they have the same tagNo on the PDF, but only 1 of them is open.
+ */
+export interface ActiveItem {
+    itemId: LegendDataId;
+    legendId: LegendId;
+    uniqueIdentifier: string;
+}

package/src/lib/feature/legend/components/pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.d.ts

@@ -0,0 +1,22 @@
+import { SelectionGroup } from '../../../../globalSelection';
+import { Marker } from '../../../types/legendMarkerBadge.type';
+import { GroupedMarker } from './splitMarkerByBadgeSelectionGroup.types';
+/**
+ * Splits a marker into multiple variants based on badge selection groups.
+ *
+ * Each variant represents a selection group and contains only badges from that group.
+ *
+ * Example: Marker with 3 equipment badges at Tag1 position:
+ * - Badge A (in SelectionGroupRed)
+ * - Badge B (in SelectionGroupRed)
+ * - Badge C (in SelectionGroupBlue)
+ *
+ * Returns 2 marker variants:
+ * - Marker variant 1: Badges [A, B], red highlight
+ * - Marker variant 2: Badge [C], blue highlight
+ *
+ * @param marker - The marker to split by badge selection groups
+ * @param selectionGroups - Global selection groups
+ * @returns Array of marker variants (one per selection group found in badges)
+ */
+export declare function splitMarkerByBadgeSelectionGroup(selectionGroups: SelectionGroup[], marker?: Marker): GroupedMarker[];

package/src/lib/feature/legend/components/pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types.d.ts

@@ -0,0 +1,19 @@
+import { Guid } from '@equinor/echo-utils';
+import { Badge, Marker } from '../../../types/legendMarkerBadge.type';
+export interface GroupKey {
+    /** Helper to get the full string representation of the group key based on groupId and color */
+    toString: () => string;
+    groupId: Guid;
+    color: string;
+}
+export interface BadgeGroup {
+    groupKey: GroupKey;
+    highlightColor: string;
+    badges: Badge[];
+}
+/**
+ * Markers that has been processed based on Selection Groups will have a group key.
+ */
+export interface GroupedMarker extends Marker {
+    getGroupKey: () => GroupKey;
+}

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

@@ -13,8 +13,9 @@ import { Marker } from './../../types/legendMarkerBadge.type';
  * @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.
  */
-export declare function getLegendChipsFromMarkers({ markers, legend, excludedLegendTitles }: {
+export declare function getLegendChipsFromMarkers({ markers, legendSelectedBadgeOption, legendSelectedMarkerOption, excludedLegendTitles }: {
     markers: ReadonlyArray<Marker>;
-    legend: LegendState;
     excludedLegendTitles?: ReadonlyArray<string>;
+    legendSelectedBadgeOption?: LegendState['selectedBadgeOption'];
+    legendSelectedMarkerOption?: LegendState['selectedMarkerOption'];
 }): LegendChipProps[];

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

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

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

@@ -0,0 +1,7 @@
+interface LegendItemProps {
+    label: string;
+    backgroundColor?: string;
+    onClick: (isDisabled: boolean) => void;
+}
+export declare const SelectionLegendChip: import("react").MemoExoticComponent<(props: LegendItemProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

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

@@ -0,0 +1,5 @@
+/**
+ * Returns all markers for all legends with grouping. Hidden markers are included.
+ * Only markers from enabled legends are returned.
+ */
+export declare const useAllGroupedMarkersForLegends: () => import("../../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types").GroupedMarker[] | undefined;

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

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

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

@@ -0,0 +1,34 @@
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionTypes, SelectionGroup } from '../../../globalSelection';
+import { GroupKey } from '../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
+/**
+ * TODO: Remove this flag when Selection Legend is stable and ready for production
+ * Flag to enable/disable Selection Legend feature
+ */
+export declare const isSelectionLegendEnabled: () => boolean;
+/**
+ * Key used for badges that don't belong to any selection group
+ */
+export declare const NOT_IN_SELECTION_GROUP_KEY: GroupKey;
+/**
+ * Extracts all item IDs from selection group categories
+ */
+export declare const extractSelectionGroupItemIds: (selectionGroup: SelectionGroup) => GlobalSelectionTypes.ItemId[];
+/**
+ * Gets the most frequently used color for a selection group
+ */
+export declare const getSelectionGroupMostUsedColor: (selectionGroup: SelectionGroup, allGroups: SelectionGroup[]) => string | undefined;
+/**
+ * Creates a standardized group key for a selection group.
+ * This key is used across the legend system to:
+ * - Identify marker variants split by selection groups (viewport)
+ * - Toggle visibility of selection groups (SelectionLegendRenderer)
+ * - Filter hidden selection groups (groupMarkersBySelection)
+ *
+ * Format as string: `group_${groupId}_${color}`
+ *
+ * @param groupId - The unique identifier of the selection group
+ * @param color - The highlight color for the group
+ * @returns The standardized group key
+ */
+export declare const createSelectionGroupKey: (groupId: Guid, color: string) => GroupKey;

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

@@ -0,0 +1,16 @@
+import { GroupedMarker } from '../components/pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
+import { Marker } from '../types/legendMarkerBadge.type';
+import { LegendId } from '../types/legendType';
+/**
+ * Will process markers and group them based on groups in Selection.
+ * This also adds additional logic for counting badges where this is needed.
+ * @param legendId
+ * @param markers
+ * @param hiddenMarkers If included hidden markers will be filtered out
+ * @returns
+ */
+export declare const useGroupedMarkers: (args: {
+    legendId: LegendId;
+    markers: Marker[];
+    hiddenMarkers?: string[];
+}) => GroupedMarker[] | undefined;

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

@@ -0,0 +1,11 @@
+import { Marker } from '../../types/legendMarkerBadge.type';
+import { LegendDataId, LegendId } from '../../types/legendType';
+export interface UseLegendMarkerProps {
+    legendId: LegendId;
+    itemIds: LegendDataId[];
+    hiddenMarkers: string[];
+}
+/**
+ * Returns the visible markers for the given legendId and itemId.
+ */
+export declare function useLegendMarker(props: UseLegendMarkerProps): Marker | undefined;

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

@@ -0,0 +1,21 @@
+/**
+ * Utility functions for legend visible markers functionality.
+ *
+ * This module contains shared utilities, helper functions, and debugging tools
+ * used across the legend marker hooks.
+ */
+import { Marker } from '../../types/legendMarkerBadge.type';
+import { LegendDataId, LegendId } from '../../types/legendType';
+/**
+ * Development helper to track hook calls
+ */
+export declare const trackMarkerCallsInDevelopment: () => void;
+/**
+ * Helper to get unique data from the legend visible data store
+ */
+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>;

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

@@ -0,0 +1,9 @@
+import { Badge } from '../types/legendMarkerBadge.type';
+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>;

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

@@ -0,0 +1,9 @@
+import { Marker } from '../types/legendMarkerBadge.type';
+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>;

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

@@ -7,10 +7,14 @@ export { MultipleMarkersByLegends } from './components/pdfMarkers/subComponents/
 export { LegendPopoverContent } from './components/popover/LegendPopoverContent';
 export type { LegendPopoverContentProps, LegendPopoverTertiaryLabels } from './components/popover/LegendPopoverContent';
 export { legendFacade } from './legendFacade';
-export { legendSnapShot } from './legendStore';
 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 { useLegendVisibleDataStore } from './../legend/legendVisibleDataStore';
-export { useLegendUniqueBadges, useLegendUniqueMarkers } from './hooks/useLegendMarkers';
+export { useLegendUniqueBadges } from './hooks/useLegendUniqueBadges';
+export { useLegendUniqueMarkers } from './hooks/useLegendUniqueMarkers';
+export { COUNT_MODE_KEYWORD } from './logic/normalizeBadges';
+export { useLegendVisibleDataStore } from './stores/legendVisibleDataStore/legendVisibleDataStore';
+export { isWorkOrderLegendFeatureEnabled } from './legendStrategies/workOrderStrategy/WorkOrderLegend';
+export { useLegendUIStore } from './stores/legendUIStore/legendUIStore';

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

@@ -1,8 +1,9 @@
-import { legendSnapShot, useAllLegends, useLegendById } from './legendStore';
 import { getLegendStrategy, injectLegendStrategy } from './legendStrategies/legendCollections';
-import { visibleDataAsTagsSnapshot } from './legendVisibleDataAsTagsStore';
 import { isLegendDataIdEqualWithTag } from './logic/isLegendDataIdEqualWithTag';
-import { createLegendId } from './types/legendType';
+import { legendExistsInLegendStore, legendSnapShot, useAllLegends, useLegendById } from './stores/legendDataStore/legendStore';
+import { legendExistsInLegendUIStore, useLegendUIById } from './stores/legendUIStore/legendUIStore';
+import { visibleDataAsTagsSnapshot } from './stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore';
+import { LegendId } from './types/legendType';
 /**
  * Public facade for the legend.
  */
@@ -11,26 +12,41 @@ export declare const legendFacade: Readonly<{
         inject: typeof injectLegendStrategy;
         get: typeof getLegendStrategy;
     };
-    store: {
+    data: {
+        useAll: typeof useAllLegends;
+        useById: typeof useLegendById;
+        exists: typeof legendExistsInLegendStore;
+        snapshot: typeof legendSnapShot;
         subscribe: {
-            (listener: (selectedState: import("./legendStore").LegendStoreData & import("./legendStore").LegendStoreActions, previousSelectedState: import("./legendStore").LegendStoreData & import("./legendStore").LegendStoreActions) => void): () => void;
-            <U>(selector: (state: import("./legendStore").LegendStoreData & import("./legendStore").LegendStoreActions) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            (listener: (selectedState: import("./stores/legendDataStore/legendStore").LegendStoreData & import("./stores/legendDataStore/legendStore").LegendStoreActions, previousSelectedState: import("./stores/legendDataStore/legendStore").LegendStoreData & import("./stores/legendDataStore/legendStore").LegendStoreActions) => void): () => void;
+            <U>(selector: (state: import("./stores/legendDataStore/legendStore").LegendStoreData & import("./stores/legendDataStore/legendStore").LegendStoreActions) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
                 equalityFn?: ((a: U, b: U) => boolean) | undefined;
                 fireImmediately?: boolean;
             } | undefined): () => void;
         };
     };
-    storeSnapshot: typeof legendSnapShot;
-    legend: {
-        createId: typeof createLegendId;
-        knownLegendIds: {
-            equipmentLegendId: import("./types/legendType").LegendId;
-            tagLegendId: import("./types/legendType").LegendId;
-            workOrderLegendId: import("./types/legendType").LegendId;
+    ui: {
+        useById: typeof useLegendUIById;
+        exists: typeof legendExistsInLegendUIStore;
+        accordion: {
+            toggle: (legendId: LegendId, newValue: boolean) => void;
+        };
+        markers: {
+            setHidden: (params: {
+                legendId: LegendId;
+                marker: string;
+                isHidden: boolean;
+            }) => void;
+        };
+        badges: {
+            setHidden: (params: {
+                legendId: LegendId;
+                badge: string;
+                isHidden: boolean;
+            }) => void;
         };
-        useBy: typeof useLegendById;
-        useAll: typeof useAllLegends;
     };
+    exists: (legendId: LegendId) => boolean;
     visibleData: {
         getBy: <T extends keyof {
             Tag: import("./types/legendType").LegendTagId;
@@ -60,46 +76,39 @@ export declare const legendFacade: Readonly<{
             removePreviousItems?: boolean;
         }) => void;
         subscribe: {
-            (listener: (selectedState: import("./legendVisibleDataStore").LegendVisibleDataStore, previousSelectedState: import("./legendVisibleDataStore").LegendVisibleDataStore) => void): () => void;
-            <U>(selector: (state: import("./legendVisibleDataStore").LegendVisibleDataStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            (listener: (selectedState: import("./stores/legendVisibleDataStore/legendVisibleDataStore").LegendVisibleDataStore, previousSelectedState: import("./stores/legendVisibleDataStore/legendVisibleDataStore").LegendVisibleDataStore) => void): () => void;
+            <U>(selector: (state: import("./stores/legendVisibleDataStore/legendVisibleDataStore").LegendVisibleDataStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
                 equalityFn?: ((a: U, b: U) => boolean) | undefined;
                 fireImmediately?: boolean;
             } | undefined): () => void;
         };
     };
     visibleDataAsTags: {
-        useStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<import("./legendVisibleDataAsTagsStore").VisibleDataAsTagsStore>, "setState"> & {
+        useStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore>, "setState"> & {
             setState<A extends string | {
                 type: string;
-            }>(partial: import("./legendVisibleDataAsTagsStore").VisibleDataAsTagsStore | Partial<import("./legendVisibleDataAsTagsStore").VisibleDataAsTagsStore> | ((state: import("./legendVisibleDataAsTagsStore").VisibleDataAsTagsStore) => import("./legendVisibleDataAsTagsStore").VisibleDataAsTagsStore | Partial<import("./legendVisibleDataAsTagsStore").VisibleDataAsTagsStore>), replace?: boolean | undefined, action?: A | undefined): void;
+            }>(partial: import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore | Partial<import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore> | ((state: import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore) => import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore | Partial<import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore>), replace?: boolean | undefined, action?: A | undefined): void;
         }, "subscribe"> & {
             subscribe: {
-                (listener: (selectedState: import("./legendVisibleDataAsTagsStore").VisibleDataAsTagsStore, previousSelectedState: import("./legendVisibleDataAsTagsStore").VisibleDataAsTagsStore) => void): () => void;
-                <U>(selector: (state: import("./legendVisibleDataAsTagsStore").VisibleDataAsTagsStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+                (listener: (selectedState: import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore, previousSelectedState: import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore) => void): () => void;
+                <U>(selector: (state: import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
                     equalityFn?: ((a: U, b: U) => boolean) | undefined;
                     fireImmediately?: boolean;
                 } | undefined): () => void;
             };
         }, "setState"> & {
-            setState(nextStateOrUpdater: import("./legendVisibleDataAsTagsStore").VisibleDataAsTagsStore | Partial<import("./legendVisibleDataAsTagsStore").VisibleDataAsTagsStore> | ((state: import("immer").WritableDraft<import("./legendVisibleDataAsTagsStore").VisibleDataAsTagsStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+            setState(nextStateOrUpdater: import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore | Partial<import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore> | ((state: import("immer").WritableDraft<import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
                 type: string;
             } | undefined): void;
         }>;
-        snapShot: typeof visibleDataAsTagsSnapshot;
+        snapshot: typeof visibleDataAsTagsSnapshot;
     };
     utils: {
         isLegendDataIdEqualWithTag: typeof isLegendDataIdEqualWithTag;
     };
+    knownLegendIds: {
+        equipmentLegendId: LegendId;
+        tagLegendId: LegendId;
+        workOrderLegendId: LegendId;
+    };
 }>;
-/**
-             <PositionalLegendMarkers
-                items={visibleItemsWithPosition}
-                pdfRotation={pdfRotation}
-                currentPageScale={currentPageScale}
-                pdfZoom={pdfZoom}
-            />
-
- */
-export type { LegendStoreActions, LegendStoreData } from './legendStore';
-export type { VisibleDataAsTagsStore } from './legendVisibleDataAsTagsStore';
-export type { LegendVisibleDataStore } from './legendVisibleDataStore';

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

@@ -1 +1 @@
-export {};
+export declare const isWorkOrderLegendFeatureEnabled: () => boolean;

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

@@ -0,0 +1,33 @@
+import { Badge } from '../types/legendMarkerBadge.type';
+/**
+ * Keyword used to identify count mode in badge text options. This changes
+ * the way we normalize badges.
+ */
+export declare const COUNT_MODE_KEYWORD = "Count";
+/**
+ * Determines if count mode should be enabled based on badge text options.
+ * Count mode is enabled when any option value exactly equals 'Count'.
+ *
+ * @param badgeTextOptions - Badge text configuration options from legend state
+ * @returns Whether count mode should be enabled
+ */
+export declare function isCountMode(badgeTextOptions: Record<string, string> | undefined): boolean;
+/**
+ * Creates badges with count displayed as title.
+ * Takes all badges (including duplicates) and unique badges, and returns unique badges
+ * with their titles replaced by the count of how many times they appear.
+ *
+ * @param allBadges - All badges including duplicates
+ * @param uniqueBadges - Unique badges to be displayed
+ * @returns Array of badges with count as title
+ */
+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.
+ *
+ * @param badges - Array of badges to normalize
+ * @param badgeTextOptions - Badge text configuration options from legend state
+ * @returns Normalized array of badges
+ */
+export declare function normalizeBadges(badges: ReadonlyArray<Badge>, badgeTextOptions: Record<string, string> | undefined): Badge[];

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

@@ -0,0 +1,2 @@
+import { LegendId } from '../types/legendType';
+export declare const initializeLegendInStores: (legendId: LegendId) => void;