@equinor/echo-framework 2.2.2 → 2.2.3

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "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.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/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/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/{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/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,32 @@
+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;

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

@@ -0,0 +1,25 @@
+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 LegendUIStoreValues = {
+    legends: LegendUIDictionary;
+};
+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;
+    initializeLegendInStore: (legendId: LegendId) => 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 {};