@equinor/echo-framework 2.2.2 → 2.3.0

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "peerDependencies": {
-    "@equinor/echo-base": ">= 2.2.1 < 3.0.0",
-    "@equinor/echo-components": ">= 2.2.2 < 3.0.0",
-    "@equinor/echo-core": ">= 2.2.1 < 3.0.0",
-    "@equinor/echo-search": ">= 2.2.2 < 3.0.0",
-    "@equinor/echo-utils": ">= 2.2.2 < 3.0.0",
+    "@equinor/echo-base": ">= 2.3.0 < 3.0.0",
+    "@equinor/echo-components": ">= 2.3.0 < 3.0.0",
+    "@equinor/echo-core": ">= 2.3.0 < 3.0.0",
+    "@equinor/echo-search": ">= 2.3.0 < 3.0.0",
+    "@equinor/echo-utils": ">= 2.3.0 < 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';
@@ -76,6 +77,7 @@ export { getPdmsPlantCodeForTag } from './lib/utils/getPdmsPlantCodeForTag';
 export { isImage, isVideo } from './lib/utils/mediaTypeUtils';
 export { convertPathNameToReadableString } from './lib/utils/moduleNameUtils';
 export * from './lib/utils/startup';
+export type { ProcosysProject } from './types/procosysProject';
 export declare const registerEchopediaComponent: ({ name, component }: {
     name: import("./lib/services/componentRegistry/componentRegistry").RegisteredComponentName;
     component: import("react").FunctionComponent<any>;

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

@@ -0,0 +1,7 @@
+import { GlobalSelectionItemType, GlobalSelectionObject } from '../globalSelectionStore/globalSelectionStore.types';
+/**
+ *
+ * @param {GlobalSelectionItemType} itemType
+ * @returns Map of given item types stored in global selection.
+ */
+export declare function useGlobalSelectionItemsByTypeAsMap<T extends GlobalSelectionItemType>(itemType: T): GlobalSelectionObject[T];

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

@@ -5,6 +5,7 @@ export { useAreAllItemsVisible } from './hooks/useAreAllItemsVisible';
 export { useGlobalSelectionByItemId } from './hooks/useGlobalSelectionByItemId';
 export { useGlobalSelectionItems } from './hooks/useGlobalSelectionItems';
 export { useGlobalSelectionItemsByType } from './hooks/useGlobalSelectionItemsByType';
+export { useGlobalSelectionItemsByTypeAsMap } from './hooks/useGlobalSelectionItemsByTypeAsMap';
 export { useGlobalSelectionLists } from './hooks/useGlobalSelectionLists';
 export { useGlobalSelectionTags } from './hooks/useGlobalSelectionTags';
 export { useGlobalSelectionWorkOrders } from './hooks/useGlobalSelectionWorkOrders';

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/legendTextSelector/LegendTextSelector.d.ts

@@ -1,8 +1,7 @@
-import React from 'react';
-interface LegendTextSelectorProps {
-    options: ReadonlyArray<string>;
-    selectedOption: string;
-    onOptionSelected?: (option: string) => void;
+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.
@@ -17,5 +16,5 @@ interface LegendTextSelectorProps {
  * @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: React.FC<LegendTextSelectorProps>;
+export declare const LegendTextSelector: <T extends string>(props: LegendTextSelectorProps<T>) => import("react/jsx-runtime").JSX.Element | null;
 export {};

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

@@ -1,12 +1,12 @@
 import { ItemMarkerSize } from '@equinor/echo-components';
 import React from 'react';
-import { Marker } from '../../../types/legendMarkerBadge.type';
+import { GroupedMarker } from '../utils/splitMarkerByBadgeSelectionGroup.types';
 interface LegendColoredMarkerIconProps {
     hasPointer: boolean;
     isActive: boolean;
     onClick: () => void;
     hiddenBadges: string[];
-    marker: Marker;
+    marker: GroupedMarker;
 }
 /**
  * Renders a colored marker icon with optional pointer and badges.

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

@@ -6,7 +6,7 @@ interface MultipleMarkersByLegendsProps {
     onOpenPopover: RequestPopoverHandler;
     onClosePopover: () => void;
     currentPopover?: PopoverContent;
-    positionString: string;
+    uniqueIdentifier: string;
 }
 export declare const MultipleMarkersByLegends: import("react").MemoExoticComponent<(props: MultipleMarkersByLegendsProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

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

@@ -2,6 +2,6 @@ import { LegendDataId, LegendId } from '../../../../types/legendType';
 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

@@ -1,5 +1,5 @@
 import { LegendDataId, LegendId } from '../../../../types/legendType';
-export type RequestPopoverHandler = (itemId: LegendDataId, legendId: LegendId, positionString: string, fetchPopoverContent: () => Promise<ReadonlyArray<React.JSX.Element>>) => void;
+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;
@@ -10,5 +10,5 @@ export interface PopoverContent {
 export interface ActiveItem {
     itemId: LegendDataId;
     legendId: LegendId;
-    positionString: string;
+    uniqueIdentifier: string;
 }

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

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

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

@@ -0,0 +1,5 @@
+/**
+ * SelectionLegendActions renders the action buttons for the Selection Legend.
+ * It provides options to toggle the visibility of highlights around selection group markers.
+ */
+export declare const SelectionLegendActions: () => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,4 @@
+/**
+ * Allows the user to select how to display markers that are not in any selection group.
+ */
+export declare const SelectionLegendOtherMarkers: () => import("react/jsx-runtime").JSX.Element;

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

@@ -1,4 +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;
+export declare const useAllGroupedMarkersForLegends: () => import("../../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types").GroupedMarker[] | undefined;

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

@@ -1,6 +1,6 @@
 import { Guid } from '@equinor/echo-utils';
 import { GlobalSelectionTypes, SelectionGroup } from '../../../globalSelection';
-import { GroupKey } from '../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
+import { GroupedMarker, 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
@@ -32,3 +32,11 @@ export declare const getSelectionGroupMostUsedColor: (selectionGroup: SelectionG
  * @returns The standardized group key
  */
 export declare const createSelectionGroupKey: (groupId: Guid, color: string) => GroupKey;
+/**
+ * Checks if a marker belongs to the "Not in Selection" group.
+ *
+ * @param marker - The marker to check.
+ *
+ * @returns True if the marker is in the "Not in Selection" group, false otherwise.
+ */
+export declare const isMarkerOutsideSelection: (marker: GroupedMarker) => boolean;

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

@@ -6,11 +6,11 @@ import { LegendId } from '../types/legendType';
  * This also adds additional logic for counting badges where this is needed.
  * @param legendId
  * @param markers
- * @param includeHiddenMarkers If enabled hidden markers will also be returned
+ * @param hiddenMarkers If included hidden markers will be filtered out
  * @returns
  */
 export declare const useGroupedMarkers: (args: {
     legendId: LegendId;
     markers: Marker[];
-    includeHiddenMarkers: boolean;
+    hiddenMarkers?: string[];
 }) => GroupedMarker[] | undefined;

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

@@ -3,6 +3,7 @@ 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.

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

@@ -7,12 +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 } 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/stores/initializeLegendInStores.d.ts

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

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

@@ -1,5 +1,5 @@
 import { PersistOptions } from 'zustand/middleware';
-import { LegendId, LegendState } from './types/legendType';
+import { LegendId, LegendState } from '../../types/legendType';
 type LegendsDictionary = Record<LegendId, LegendState>;
 export interface LegendStoreData {
     legends: LegendsDictionary;
@@ -8,20 +8,11 @@ export interface LegendStoreActions {
     updateLegend: (legendId: LegendId, updates: Partial<Omit<LegendState, 'isLoading'>>) => void;
     startLoading: (legendId: LegendId) => void;
     finishLoading: (legendId: LegendId) => void;
-    setHiddenMarker: (args: {
-        legendId: LegendId;
-        marker: string;
-        isHidden: boolean;
-    }) => void;
-    setHiddenBadge: (args: {
-        legendId: LegendId;
-        badge: string;
-        isHidden: boolean;
-    }) => void;
     getLegendById: (legendId: LegendId) => LegendState | undefined;
+    initializeLegendInStore: (legendId: LegendId) => void;
 }
 type LegendStore = LegendStoreData & LegendStoreActions;
-type PersistedLegendState = Omit<LegendState, 'isLoading' | 'hiddenMarkers' | 'hiddenBadges'>;
+type PersistedLegendState = Omit<LegendState, 'isLoading'>;
 type PersistedLegendStoreData = {
     legends: Record<LegendId, PersistedLegendState>;
 };
@@ -52,8 +43,52 @@ export declare const useLegendStore: import("zustand").UseBoundStore<Omit<Omit<O
         type: string;
     } | undefined): void;
 }>;
-export declare function useLegendById(legendId: LegendId): LegendState;
+/**
+ * Hook to access a legend by ID with optional property selection for optimized re-renders.
+ *
+ * @param legendId - The ID of the legend to access
+ * @param selector - Optional selector function to pick specific properties from the legend
+ *
+ * @example
+ * // Watch all properties (triggers re-render on any change):
+ * const legend = useLegendById('Tag Legend');
+ *
+ * @example
+ * // Watch only isEnabled (triggers re-render only when isEnabled changes):
+ * const isEnabled = useLegendById('Tag Legend', (legend) => legend?.isEnabled);
+ *
+ * @example
+ * // Watch multiple specific properties:
+ * const { isEnabled, isLoading } = useLegendById('Tag Legend', useShallow((legend) => ({
+ *   isEnabled: legend?.isEnabled,
+ *   isLoading: legend?.isLoading
+ * })));
+ */
+export declare function useLegendById(legendId: LegendId): LegendState | undefined;
+export declare function useLegendById<T>(legendId: LegendId, selector: (legend: LegendState | undefined) => T): T;
+export declare function legendExistsInLegendStore(legendId: LegendId): boolean;
+/**
+ * Hook to access all legends with optional property selection for optimized re-renders.
+ *
+ * @param selector - Optional selector function to transform the legends array
+ *
+ * @example
+ * // Watch all properties (triggers re-render on any change):
+ * const legends = useAllLegends();
+ *
+ * @example
+ * // Watch only specific properties with useShallow for optimal performance:
+ * import { useShallow } from 'zustand/react/shallow';
+ * const legendsMinimal = useAllLegends(
+ *   useShallow((legends) => legends.map(l => ({ legendId: l.legendId, isEnabled: l.isEnabled })))
+ * );
+ *
+ * @example
+ * // Get only enabled legends:
+ * const enabledLegends = useAllLegends((legends) => legends.filter(l => l.isEnabled));
+ */
 export declare function useAllLegends(): LegendState[];
+export declare function useAllLegends<T>(selector: (legends: LegendState[]) => T): T;
 export declare function legendSnapShot(): LegendStore;
 export declare const legendStoreSubscribe: {
     (listener: (selectedState: LegendStore, previousSelectedState: LegendStore) => void): () => void;

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

@@ -0,0 +1,38 @@
+import { LegendId } from '../../types/legendType';
+import { LegendUIState, LegendUIStore } from './legendUIStore.types';
+/**
+ * Non-persisted store for managing UI state of legends, such as accordion expansion and hidden markers/badges.
+ */
+export declare const useLegendUIStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<LegendUIStore>, "setState"> & {
+    setState(nextStateOrUpdater: LegendUIStore | Partial<LegendUIStore> | ((state: import("immer").WritableDraft<LegendUIStore>) => void), shouldReplace?: boolean | undefined): void;
+}>;
+/**
+ * Hook to access a legend by ID with optional property selection for optimized re-renders.
+ *
+ * @param legendId - The ID of the legend to access
+ * @param selector - Optional selector function to pick specific properties from the legend
+ *
+ * @example
+ * // Watch all properties (triggers re-render on any change):
+ * const legend = useLegendUIById('Tag Legend');
+ *
+ * @example
+ * // Watch only isAccordionExpanded (triggers re-render only when isAccordionExpanded changes):
+ * const isAccordionExpanded = useLegendUIById('Tag Legend', (legend) => legend?.isAccordionExpanded);
+ *
+ * @example
+ * // Watch multiple specific properties:
+ * const { isAccordionExpanded, hiddenMarkers } = useLegendUIById('Tag Legend', useShallow((legend) => ({
+ *   isAccordionExpanded: legend?.isAccordionExpanded,
+ *   hiddenMarkers: legend?.hiddenMarkers
+ * })));
+ */
+export declare function useLegendUIById(legendId: LegendId): LegendUIState | undefined;
+export declare function useLegendUIById<T>(legendId: LegendId, selector: (legend: LegendUIState | undefined) => T): T;
+export declare function legendExistsInLegendUIStore(legendId: LegendId): boolean;
+/**
+ * Helper function to toggle visibility of an item in an array.
+ * Adds the item if isHidden is true and it's not present, removes it if isHidden is false and it exists.
+ * @internal - Exported for testing purposes only
+ */
+export declare function toggleItemInArray(array: string[], item: string, isHidden: boolean): void;

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

@@ -0,0 +1,32 @@
+import { LegendId } from '../../types/legendType';
+export interface LegendUIState {
+    readonly isAccordionExpanded: boolean;
+    readonly hiddenMarkers: string[];
+    readonly hiddenBadges: string[];
+}
+export type LegendUIDictionary = Record<LegendId, LegendUIState>;
+export type MarkersOutsideSelectionVisibility = 'Show' | 'Ghost' | 'Hide';
+export type LegendUIStoreValues = {
+    readonly legends: LegendUIDictionary;
+    readonly selectionLegend: {
+        readonly isHighlightVisible: boolean;
+        readonly markersOutsideSelectionVisibility: MarkersOutsideSelectionVisibility;
+    };
+};
+export interface LegendUIStoreActions {
+    toggleAccordion: (legendId: LegendId, newValue: boolean) => void;
+    setHiddenMarker: (args: {
+        legendId: LegendId;
+        marker: string;
+        isHidden: boolean;
+    }) => void;
+    setHiddenBadge: (args: {
+        legendId: LegendId;
+        badge: string;
+        isHidden: boolean;
+    }) => void;
+    setMarkersOutsideSelectionVisibility: (visibility: MarkersOutsideSelectionVisibility) => void;
+    initializeLegendInStore: (legendId: LegendId) => void;
+    setSelectionLegendIsHighlightVisible: (visible: boolean) => void;
+}
+export type LegendUIStore = LegendUIStoreValues & LegendUIStoreActions;

package/src/lib/feature/legend/{legendVisibleDataAsTagsStore.logic.d.ts → stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore.logic.d.ts}

@@ -1,3 +1,3 @@
+import { LegendEquipmentId } from '../../types/legendType';
 import { TagWithEquipmentId } from './legendVisibleDataAsTagsStore.type';
-import { LegendEquipmentId } from './types/legendType';
 export declare function fetchTagsByEquipment(equipmentIds: ReadonlyArray<LegendEquipmentId>, abortController: AbortController): Promise<TagWithEquipmentId[] | undefined>;

package/src/lib/feature/legend/{legendVisibleDataStore.d.ts → stores/legendVisibleDataStore/legendVisibleDataStore.d.ts}

@@ -1,4 +1,4 @@
-import { LegendDataId, LegendEquipmentId, LegendTagId } from './types/legendType';
+import { LegendDataId, LegendEquipmentId, LegendTagId } from '../../types/legendType';
 /**
  * Maps (string) keyword to the data type.
  * We don't have any other sources so far, pdf has TagNo and EquipmentId (ecm)

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

@@ -1,24 +1,19 @@
 import { Brand } from '@equinor/echo-utils';
 import { GlobalSelectionTypes } from '../../globalSelection';
-type TemporaryLegendIdsForTesting = 'Work Orders with Custom UI';
-export type KnownLegendIds = 'Equipment' | 'Tag Legend' | TemporaryLegendIdsForTesting;
+export type KnownLegendIds = 'Equipment Legend' | 'Tag Legend' | 'Work Order Legend';
 export type LegendId = KnownLegendIds | Brand<string, 'LegendId'>;
-export declare function createLegendId(id: string): LegendId;
 export declare const knownLegendIds: {
     equipmentLegendId: LegendId;
     tagLegendId: LegendId;
     workOrderLegendId: LegendId;
 };
 export interface LegendState {
-    legendId: LegendId;
-    isEnabled: boolean;
-    isLoading: boolean;
-    hiddenMarkers: string[];
-    hiddenBadges: string[];
-    selectedMarkerOption: LegendOptionConfig;
-    selectedBadgeOption: LegendOptionConfig;
-    selectedBadgeTextOptions: Record<string, string>;
-    isExpanded: boolean;
+    readonly legendId: LegendId;
+    readonly isEnabled: boolean;
+    readonly isLoading: boolean;
+    readonly selectedMarkerOption: LegendOptionConfig;
+    readonly selectedBadgeOption: LegendOptionConfig;
+    readonly selectedBadgeTextOptions: Record<string, string>;
 }
 export type LegendTagId = GlobalSelectionTypes.TagId;
 export type LegendEquipmentId = GlobalSelectionTypes.EquipmentId;
@@ -36,4 +31,3 @@ export interface LegendOptionConfig<T = string> {
     displayName: string;
     showChipsInViewportOnly?: boolean;
 }
-export {};