@equinor/echo-framework 4.0.1 → 4.1.0

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

@@ -0,0 +1,15 @@
+import { Marker } from '../../../../../types/legendMarkerBadge.type';
+import { MarkerId } from '../../../utils/markerId.utils';
+import { ColorGroupedMarker } from '../../../utils/splitMarkerByColor.types';
+/**
+ * Builds the list of color-grouped markers to render for a single legend item.
+ *
+ * When the item has no selection grouping, wraps the raw marker as a single transparent-key variant.
+ * Always returns markers sorted by color key for stable render order.
+ */
+export declare function buildMarkersToRender(marker: Marker, groupedMarkers: ReadonlyArray<ColorGroupedMarker> | null | undefined): ColorGroupedMarker[];
+/**
+ * Finds the best new markerId to migrate the active popover to after the old marker disappears.
+ * Prefers a marker with the same color key, falls back to the first available.
+ */
+export declare function findNewMarkerId(markerIds: MarkerId[], previousMarkerId: MarkerId): MarkerId | undefined;

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

@@ -0,0 +1,19 @@
+import { MarkerId } from '../../../utils/markerId.utils';
+import { ColorGroupedMarker } from '../../../utils/splitMarkerByColor.types';
+interface UseStalePopoverMarkersProps {
+    readonly markersToRender: ReadonlyArray<ColorGroupedMarker> | null;
+    readonly markerIds: ReadonlyArray<MarkerId>;
+    readonly selectionMarkerIds: ReadonlyArray<MarkerId>;
+}
+/**
+ * Holds stale markers visible while selection feedback is displayed after a delayed close or migration.
+ *
+ * When `shouldDelayPopoverUpdate` is true and the active popover's marker disappears (e.g. last item
+ * removed from a color group), this hook keeps the old `MarkerWithPopover` rendered for
+ * `POPOVER_UPDATE_DELAY_MS`. That gives the loading indicator and feedback message ("Removed",
+ * "Color changed") time to be visible before the popover closes or migrates to a new marker.
+ *
+ * @returns The markers that should be rendered — either the stale snapshot or the live `markersToRender`.
+ */
+export declare function useStalePopoverMarkers({ markersToRender, markerIds, selectionMarkerIds }: UseStalePopoverMarkersProps): ReadonlyArray<ColorGroupedMarker> | null;
+export {};

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

@@ -1,6 +1,7 @@
 import { LegendDataId, LegendId } from '../../../../types/legendType';
 import { MarkerId } from '../../utils/markerId.utils';
 import { ColorGroupedMarker } from '../../utils/splitMarkerByColor.types';
+export declare const POPOVER_UPDATE_DELAY_MS = 2000;
 /**
  * Hook to manage popover state and async content loading for legend markers.
  * When fetching, it will show a loading spinner if content takes too long to load.

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

@@ -1,6 +1,10 @@
 import { Brand } from '@equinor/echo-utils';
 import { LegendId } from '../../../types/legendType';
 export type MarkerId = Brand<string, 'MarkerId'>;
+/**
+ * Color key used when a marker is not in any selection group (fallback/transparent state).
+ */
+export declare const TRANSPARENT_COLOR_KEY = "color_transparent";
 /**
  * Creates a unique marker ID from its component parts.
  * Format: positionId::legendId::groupKey
@@ -16,3 +20,8 @@ export declare function getPositionIdFromMarkerId(markerId: MarkerId): string |
  * Checks if a marker ID belongs to a specific position.
  */
 export declare function isMarkerAtPosition(markerId: MarkerId | undefined, positionId: string): boolean;
+/**
+ * Extracts the color/group key from a marker ID.
+ * Returns undefined if the marker ID is invalid.
+ */
+export declare function getColorKeyFromMarkerId(markerId: MarkerId): string | undefined;

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

@@ -1,4 +1,4 @@
-import { GlobalSelectionTypes } from '../../globalSelection';
+import type { GlobalSelectionTypes } from '../../globalSelection/globalSelectionStore/globalSelectionStore.types';
 import { ItemToSelectionGroupsMap } from '../stores/itemToSelectionGroupsMapStore/itemToSelectionGroupsMapStore.types';
 interface ItemToSelectionGroupsMapSubscriptionResult {
     /** The complete itemToSelectionGroupsMap for looking up item -> selection groups */
@@ -11,7 +11,7 @@ interface ItemToSelectionGroupsMapSubscriptionResult {
  * and only triggers a re-render when any of the watched items change group membership.
  * Returns the full itemToSelectionGroupsMap so the caller can look up selection groups for each badge.
  *
- * @param watchItemIds - Array of item ID strings to watch (e.g., all badge item IDs from a marker)
+ * @param watchItemIds - Array of global selection item ID strings to watch
  * @returns Object containing the complete itemToSelectionGroupsMap for lookups
  *
  * @example
@@ -25,5 +25,5 @@ interface ItemToSelectionGroupsMapSubscriptionResult {
  * const { itemToSelectionGroupsMap } = useItemToSelectionGroupsMapSubscription(badgeItemIds);
  * ```
  */
-export declare const useItemToSelectionGroupsMapSubscription: (watchItemIds: GlobalSelectionTypes.ItemIdString[]) => ItemToSelectionGroupsMapSubscriptionResult;
+export declare const useItemToSelectionGroupsMapSubscription: (watchItemIds: ReadonlyArray<GlobalSelectionTypes.ItemIdString>) => ItemToSelectionGroupsMapSubscriptionResult;
 export {};

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

@@ -1,4 +1,4 @@
-import { GlobalSelectionTypes } from '../../globalSelection';
+import { type GlobalSelectionTypes } from '../../globalSelection/globalSelectionStore/globalSelectionStore.types';
 /**
  * Creates a per-marker subscription to selection item color changes.
  *
@@ -10,7 +10,7 @@ import { GlobalSelectionTypes } from '../../globalSelection';
  * the selection color of THIS marker's specific items changes, not when any
  * item's color changes in the global selection.
  *
- * @param itemIdStrings - Sorted array of item ID strings to watch
+ * @param itemIdStrings - Sorted array of global selection item ID strings to watch
  * @returns A combined key string representing current selection item colors for these items
  */
-export declare const useSelectionItemColorSubscription: (itemIdStrings: GlobalSelectionTypes.ItemIdString[]) => string;
+export declare const useSelectionItemColorSubscription: (itemIdStrings: ReadonlyArray<GlobalSelectionTypes.ItemIdString>) => string;

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

@@ -0,0 +1,8 @@
+import type { GlobalSelectionTypes } from '../../globalSelection/globalSelectionStore/globalSelectionStore.types';
+import { Marker } from '../types/legendMarkerBadge.type';
+/**
+ * Returns unique global-selection item ID strings from all badges on the marker.
+ * Non-selection items are filtered out since they
+ * don't exist in global selection and need no selection lookups.
+ */
+export declare const useUniqueSelectionOnlyBadgeIdStrings: (marker?: Marker) => GlobalSelectionTypes.ItemIdString[];

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

@@ -1,3 +1,4 @@
+import './legendStrategies/notificationStrategy/notificationStrategy';
 import './legendStrategies/workOrderStrategy/WorkOrderLegend';
 export { getBadgeChips, getMarkerChips } from './components/basicLegendRenderer.logic';
 export { LegendList } from './components/LegendList';

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

@@ -1,8 +1,8 @@
-import type { LegendFeedbackVariant } from './components/LegendFeedbackMessage';
 import { getLegendStrategy, injectLegendStrategy } from './legendStrategies/legendCollections';
 import { isLegendDataIdEqualWithTag } from './logic/isLegendDataIdEqualWithTag';
 import { legendExistsInLegendStore, legendSnapShot, legendStoreSubscribe, useAllLegends, useLegendById } from './stores/legendDataStore/legendStore';
 import { legendExistsInLegendUIStore, useLegendUIById } from './stores/legendUIStore/legendUIStore';
+import type { LegendFeedbackVariant } from './stores/legendUIStore/legendUIStore.types';
 import { visibleDataAsTagsSnapshot } from './stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore';
 import { LegendId } from './types/legendType';
 /**
@@ -143,10 +143,19 @@ export declare const legendFacade: Readonly<{
     };
     utils: {
         isLegendDataIdEqualWithTag: typeof isLegendDataIdEqualWithTag;
+        dataIdToString: (id: import("./types/legendType").LegendDataId) => import("./types/legendType").LegendDataIdString;
+        dataIdToSelectionItemIdString: (id: import("./types/legendType").LegendDataId) => import("../globalSelection").GlobalSelectionTypes.ItemIdString | undefined;
+        isGlobalSelectionItemId: (id: import("./types/legendType").LegendDataId) => id is import("./types/legendType").GlobalSelectionLegendDataId;
+        selectionGuards: {
+            readonly WorkOrder: (legendDataId: import("./types/legendType").LegendDataId) => legendDataId is import("../globalSelection").GlobalSelectionTypes.WorkOrderId;
+            readonly Tag: (legendDataId: import("./types/legendType").LegendDataId) => legendDataId is import("../globalSelection").GlobalSelectionTypes.TagId;
+            readonly Equipment: (legendDataId: import("./types/legendType").LegendDataId) => legendDataId is import("../globalSelection").GlobalSelectionTypes.EquipmentId;
+        };
     };
     knownLegendIds: {
         equipmentLegendId: LegendId;
         tagLegendId: LegendId;
         workOrderLegendId: LegendId;
+        notificationLegendId: LegendId;
     };
 }>;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/notificationStrategy.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,4 +1,3 @@
-import { GlobalSelectionTypes } from '../../../globalSelection';
 import { LegendDataId } from '../../types/legendType';
 /**
  * Creates popover content for a work order legend item.
@@ -11,4 +10,4 @@ import { LegendDataId } from '../../types/legendType';
  * @param itemIds - Selected item ids used to filter which work orders should be shown in the popover.
  * @returns A JSX element array when work orders are found, otherwise a single fallback JSX element.
  */
-export declare function createPopoverContent(legendDataId: LegendDataId, itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>): Promise<JSX.Element | JSX.Element[]>;
+export declare function createPopoverContent(legendDataId: LegendDataId, itemIds: ReadonlyArray<LegendDataId>): Promise<JSX.Element | JSX.Element[]>;

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

@@ -1,5 +1,5 @@
-import { LegendDataId } from '../../types/legendType';
 import { Marker } from '../../types/legendMarkerBadge.type';
+import { LegendDataId } from '../../types/legendType';
 /**
  * Creates legend markers for work orders grouped by `tagId`.
  *

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/workOrderPopover.types.d.ts

@@ -1,8 +1,7 @@
 import { LegendDataId } from '../../types/legendType';
-import { GlobalSelectionTypes } from '../../../globalSelection';
 export type PopoverProps = {
     legendDataId: LegendDataId;
-    itemIds?: ReadonlyArray<GlobalSelectionTypes.ItemId>;
+    itemIds?: ReadonlyArray<LegendDataId>;
 };
 export interface WorkOrderPopover {
     workOrderId: string;

package/src/lib/feature/legend/logic/legendDataId.utils.d.ts

@@ -0,0 +1,50 @@
+import { GlobalSelectionItemType, type GlobalSelectionTypes } from '../../globalSelection';
+import type { SelectionItemTypeToItemIdMap } from '../../globalSelection/globalSelectionStore/globalSelectionStore.types';
+import { LegendDataId, LegendDataIdString, type GlobalSelectionLegendDataId } from '../types/legendType';
+/**
+ * Mapped type that produces proper TypeScript type predicates for each selection type.
+ * - Derives the GlobalSelectionItemType keys whose ID types are part of GlobalSelectionLegendDataId
+ * - Creates type guard functions that narrow `LegendDataId` to the specific ID type
+ */
+type SelectionGuardMap = {
+    readonly [K in GlobalSelectionItemType as SelectionItemTypeToItemIdMap[K] extends GlobalSelectionLegendDataId ? K : never]: (legendDataId: LegendDataId) => legendDataId is Extract<SelectionItemTypeToItemIdMap[K], LegendDataId>;
+};
+/**
+ * Type guards that narrow LegendDataId to specific selection ID types.
+ * Record-based exhaustiveness: if a new type is added to GlobalSelectionLegendDataId,
+ * SelectionGuardMap expands and demands a new entry — compile error.
+ *
+ * **Adding a new selection-based legend?**
+ * 1. Add its type to legendType.ts
+ * 2. Add its guard here (compile error until you do)
+ *
+ * isGlobalSelectionItemId automatically picks up new guards.
+ */
+export declare const selectionGuards: SelectionGuardMap;
+/**
+ * This is the bridge between the legend system and global selection.
+ * The generic legend infrastructure (color subscription, grouping, marker splitting)
+ * uses this to determine which items participate in selection-based features.
+ *
+ * Automatically includes all guards from selectionGuards.
+ */
+export declare const isGlobalSelectionItemId: (id: LegendDataId) => id is GlobalSelectionLegendDataId;
+/**
+ * Converts any LegendDataId to a stable, unique string.
+ * For global selection types this delegates to globalSelectionUtils.itemIdToString.
+ * For non-selection types (e.g. notifications) it produces a prefixed string
+ * that will never collide with global selection ID strings.
+ */
+export declare const dataIdToString: (id: LegendDataId) => LegendDataIdString;
+/**
+ * Converts a LegendDataId to a GlobalSelection ItemIdString if the ID
+ * belongs to global selection (tag, equipment, work order).
+ * Returns undefined for non-selection IDs (e.g. notifications) since they have no corresponding item ID string.
+ */
+export declare const dataIdToSelectionItemIdString: (id: LegendDataId) => GlobalSelectionTypes.ItemIdString | undefined;
+/**
+ * Maps a LegendDataId to its GlobalSelectionItemType, or undefined
+ * if the ID does not belong to global selection (e.g. notifications).
+ */
+export declare const dataIdToSelectionItemType: (id: LegendDataId) => GlobalSelectionItemType | undefined;
+export {};

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

@@ -1,6 +1,8 @@
-import type { LegendFeedbackVariant } from '../../components/LegendFeedbackMessage';
+import type { SelectionFeedbackType } from '../../../globalSelection/components/SelectionActionBar/selectionFeedback.types';
 import { MarkerId } from '../../components/pdfMarkers/utils/markerId.utils';
 import { LegendId } from '../../types/legendType';
+export type { SelectionFeedbackType };
+export type LegendFeedbackVariant = 'error' | 'info' | 'warning';
 export interface LegendUIState {
     readonly accordionFeedback?: {
         message: string;
@@ -17,11 +19,16 @@ export type LegendUIStoreValues = {
     readonly activePopover: {
         readonly id?: MarkerId;
         readonly elements: ReadonlyArray<React.ReactElement>;
+        readonly selectionFeedback?: {
+            readonly isLoading: boolean;
+            readonly feedbackType: SelectionFeedbackType | null;
+        };
     };
     readonly selectionLegend: {
         readonly isHighlightVisible: boolean;
         readonly markersOutsideSelectionVisibility: MarkersOutsideSelectionVisibility;
     };
+    readonly shouldDelayPopoverUpdate: boolean;
 };
 export interface LegendUIStoreActions {
     toggleAccordion: (legendId: LegendId, newValue: boolean) => void;
@@ -45,6 +52,11 @@ export interface LegendUIStoreActions {
     setSelectionLegendIsHighlightVisible: (visible: boolean) => void;
     setActivePopoverId: (popoverId: MarkerId | undefined) => void;
     setActivePopoverElements: (elements: ReadonlyArray<React.ReactElement>) => void;
+    setPopoverSelectionFeedback: (feedback: {
+        isLoading: boolean;
+        feedbackType: SelectionFeedbackType | null;
+    } | undefined) => void;
+    setShouldDelayPopoverUpdate: (delay: boolean) => void;
     setAccordionFeedback: (legendId: LegendId, feedback: {
         message: string;
         variant?: LegendFeedbackVariant;

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

@@ -59,15 +59,14 @@ export declare const useLegendVisibleDataStore: import("zustand").UseBoundStore<
         data: {
             Tag: {
                 [x: string]: ({
-                    tagNo: string;
                     instCode: string;
+                    tagNo: string;
+                } | {
                     internalTagType: import("../../../globalSelection").PdmsInternalTagType;
                     plantNo: string;
                     plantCode: string;
-                } | {
                     instCode: string;
                     tagNo: string;
-                    internalTagType?: never | undefined;
                 })[];
             };
             Equipment: {

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

@@ -6,13 +6,18 @@ export interface Marker {
     getDisplayKey: () => string;
     getHighlightColor: () => string;
     badges: ReadonlyArray<Badge>;
+    /**
+     * When true, renders as plain text instead of a colored chip in the legend panel.
+     * Typically used to display informational messages to the user, such as enable syncing.
+     */
     showAsPlainLabel?: boolean;
 }
 export interface Badge {
     getTitle: () => string;
     getColor: () => string;
     /**
-     * Returns a key that can be used for clustering or grouping badges together if they share the same key.
+     * Returns a unique identity key used to track which badges are hidden/toggled off in the legend panel.
+     * Typically implemented as a combination of title and color to ensure uniqueness.
      */
     getDisplayKey: () => string;
     getItemId: () => LegendDataId;

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

@@ -1,4 +1,3 @@
-import { GlobalSelectionTypes } from '../../globalSelection';
 import { Marker } from './legendMarkerBadge.type';
 import { LegendDataId, LegendId, LegendOptionConfig } from './legendType';
 /**
@@ -36,10 +35,10 @@ export interface LegendStrategy {
      * This function is asynchronous because the popover content may depend on data that needs to be fetched before rendering,
      * such as related equipment, work orders, or other resources.
      * @param {LegendDataId} legendDataId - The identifier for the legend item for which to render popover content.
-     * @param {ReadonlyArray<GlobalSelectionTypes.ItemId>} itemIds - The item ids to be included in the popover content.
+     * @param {ReadonlyArray<LegendDataId>} itemIds - The item ids to be included in the popover content.
      * @returns A Promise resolving to one or more React elements to display in the popover.
      */
-    popoverContent: (legendDataId: LegendDataId, itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>) => Promise<React.ReactElement | ReadonlyArray<React.ReactElement>>;
+    popoverContent: (legendDataId: LegendDataId, itemIds: ReadonlyArray<LegendDataId>) => Promise<React.ReactElement | ReadonlyArray<React.ReactElement>>;
     /**
      * Returns the custom legend component for the legend, if this is omitted the default basicLegendRenderer will be used
      */

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

@@ -1,11 +1,13 @@
 import { Brand } from '@equinor/echo-utils';
 import { GlobalSelectionTypes } from '../../globalSelection';
-export type KnownLegendIds = 'Equipment Legend' | 'Tag Legend' | 'Work Order Legend';
+export type KnownLegendIds = 'Equipment Legend' | 'Tag Legend' | 'Work Order Legend' | 'Notification Legend';
 export type LegendId = KnownLegendIds | Brand<string, 'LegendId'>;
+export type LegendDataIdString = Brand<string, 'LegendDataIdString'>;
 export declare const knownLegendIds: {
     equipmentLegendId: LegendId;
     tagLegendId: LegendId;
     workOrderLegendId: LegendId;
+    notificationLegendId: LegendId;
 };
 export interface LegendState {
     readonly legendId: LegendId;
@@ -18,7 +20,20 @@ export interface LegendState {
 export type LegendTagId = GlobalSelectionTypes.TagId;
 export type LegendEquipmentId = GlobalSelectionTypes.EquipmentId;
 export type LegendWorkOrderId = GlobalSelectionTypes.WorkOrderId;
-export type LegendDataId = LegendTagId | LegendEquipmentId | LegendWorkOrderId;
+export type LegendNotificationId = {
+    testId: string;
+};
+/**
+ * Union of LegendDataId types that correspond to global selection item IDs.
+ * These can be safely used with globalSelectionUtils.
+ *
+ * **Adding a new selection-based legend?**
+ * 1. Add its type to here
+ * 2. Go to legendDataId.utils.ts and update selectionGuards (this will cause a compile error until you add a guard for the new type)
+ */
+export type GlobalSelectionLegendDataId = LegendTagId | LegendEquipmentId | LegendWorkOrderId;
+type NonGlobalSelectionLegendDataId = LegendNotificationId;
+export type LegendDataId = GlobalSelectionLegendDataId | NonGlobalSelectionLegendDataId;
 export interface LegendOptionConfig<T = string> {
     propertyName: T;
     /**
@@ -31,3 +46,4 @@ export interface LegendOptionConfig<T = string> {
     displayName: string;
     showChipsInViewportOnly?: boolean;
 }
+export {};

package/src/lib/services/dataLayerPanel/dataLayerPanel.store.d.ts

@@ -1,16 +1,17 @@
 import { WritableDraft } from 'immer';
 export interface PanelUserSettings {
-    isTagsVisible: boolean;
-    isTagsFromDocumentVisible: boolean;
-    isTagsFromSelectionVisible: boolean;
-    isWorkOrdersVisible: boolean;
-    isWorkOrdersFromDocumentVisible: boolean;
-    isWorkOrdersFromSelectionVisible: boolean;
-    isEquipmentsVisible: boolean;
-    isEquipmentsFromDocumentVisible: boolean;
-    isEquipmentsFromSelectionVisible: boolean;
-    isIocAnnotationsVisible: boolean;
-    isDataFromStidAnnoDetails: boolean;
+    readonly isTagsVisible: boolean;
+    readonly isTagsFromDocumentVisible: boolean;
+    readonly isTagsFromSelectionVisible: boolean;
+    readonly isWorkOrdersVisible: boolean;
+    readonly isWorkOrdersFromDocumentVisible: boolean;
+    readonly isWorkOrdersFromSelectionVisible: boolean;
+    readonly isEquipmentsVisible: boolean;
+    readonly isEquipmentsFromDocumentVisible: boolean;
+    readonly isEquipmentsFromSelectionVisible: boolean;
+    readonly isIocAnnotationsVisible: boolean;
+    readonly isDataFromStidAnnoDetails: boolean;
+    readonly isNotificationsVisible: boolean;
 }
 export interface DataLayerPanelState {
     isOpen: boolean;
@@ -59,6 +60,7 @@ export declare const useDataLayerPanelStore: import("zustand").UseBoundStore<Omi
             isEquipmentsFromSelectionVisible: boolean;
             isIocAnnotationsVisible: boolean;
             isDataFromStidAnnoDetails: boolean;
+            isNotificationsVisible: boolean;
         };
         togglePanel: () => void;
         toggleTags: () => void;

package/src/lib/feature/globalSelection/components/AddToSelectionMenuTrigger/AddToSelectionMenuItem.d.ts

@@ -1,8 +0,0 @@
-import { Guid } from '@equinor/echo-utils';
-import { SelectionGroup } from '../../selectionMenu/selectionTreeStore/selectionTree.store.types';
-interface AddToSelectionMenuItemProps {
-    group: SelectionGroup;
-    onAddToSelection: (groupId: Guid) => void;
-}
-export declare const AddToSelectionMenuItem: (props: AddToSelectionMenuItemProps) => import("react/jsx-runtime").JSX.Element;
-export {};

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

@@ -1,6 +0,0 @@
-import { Guid } from '@equinor/echo-utils';
-interface AddToSelectionMenuTriggerProps {
-    onAddToSelection: (groupId: Guid) => void;
-}
-export declare const AddToSelectionMenuTrigger: (props: AddToSelectionMenuTriggerProps) => import("react/jsx-runtime").JSX.Element;
-export {};

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

@@ -1,6 +0,0 @@
-import { GlobalSelectionTypes } from '../../globalSelection';
-import { Marker } from '../types/legendMarkerBadge.type';
-/**
- * Returns unique item ID strings from all badges on the marker.
- */
-export declare const useUniqueBadgeItemIdStrings: (marker?: Marker) => GlobalSelectionTypes.ItemIdString[];