@equinor/echo-framework 2.2.1 → 2.2.3

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/legendMarkerBadge.type.d.ts

@@ -1,12 +1,11 @@
+import { GlobalSelectionTypes } from '../../globalSelection';
 export interface Marker {
     getTitle: () => string;
     getColor: () => string;
     getIcon: () => string;
-    /**
-     * Returns a key that can be used for clustering or grouping markers together if they share the same key.
-     */
-    getGroupKey: () => string;
-    badges: Badge[];
+    getDisplayKey: () => string;
+    getHighlightColor: () => string;
+    badges: ReadonlyArray<Badge>;
     showAsPlainLabel?: boolean;
 }
 export interface Badge {
@@ -15,5 +14,6 @@ export interface Badge {
     /**
      * Returns a key that can be used for clustering or grouping badges together if they share the same key.
      */
-    getGroupKey: () => string;
+    getDisplayKey: () => string;
+    getItemId: () => GlobalSelectionTypes.ItemId;
 }

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

@@ -19,9 +19,14 @@ export interface LegendStrategy {
     badgeOptions?: ReadonlyArray<LegendOptionConfig>;
     getBadgeTextOptions?: (selectedBadgeOption: LegendOptionConfig) => ReadonlyArray<string> | undefined;
     /**
-     * Returns ONE marker per itemId.
+     * Returns 1 marker with badges for each incoming itemId. The viewport will make them unique when needed, and
+     * also split into groups based on (global) selection tree
+     *
+     * @param itemIds - The legend data IDs to create markers for
+     * @param isViewport - Optional use this for rendering different markers/badges in viewport compared to legendRenderer. For example equipmentLegend, where we render part-type name in legendRenderer, but id in viewport.
+     * @returns Array of markers with badges, 1 marker with badges for each incoming itemId
      */
-    useMarkers: (itemIds: ReadonlyArray<LegendDataId>) => ReadonlyArray<Marker>;
+    useMarkers: (itemIds: ReadonlyArray<LegendDataId>, isViewport?: boolean) => ReadonlyArray<Marker>;
     /**
      * Returns popover content that supports pagination for the given itemId.
      *

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 {};

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

@@ -1,19 +0,0 @@
-import { Badge, Marker } from '../types/legendMarkerBadge.type';
-import { LegendDataId, LegendId } from '../types/legendType';
-/**
- * Returns the marker for the given legendId and itemId.
- */
-export declare function useLegendMarker(args: {
-    legendId: LegendId;
-    itemId: LegendDataId;
-}): Marker | undefined;
-/**
- * Returns all unique markers for the given legendId, determined by unique markerKey (title + color).
- */
-export declare function useLegendUniqueMarkers(args: {
-    legendId: LegendId;
-}): ReadonlyArray<Marker>;
-/**
- * Returns all unique badges for the given legendId, determined by unique title + color.
- */
-export declare function useLegendUniqueBadges(legendId: LegendId): ReadonlyArray<Badge>;