@equinor/echo-framework 6.1.0 → 6.2.0

package/src/lib/types/hookLibrary.d.ts

@@ -1,24 +1,36 @@
-export type SetActiveTagNo = (argsORtagNo: string | {
-    tagNo: string;
-    activeTagTab?: string;
-    activeTagSubTab?: string;
-    instCode?: string;
-    activePanelKey?: string;
-    keepLastNavigationItem?: boolean;
-    openInPanel?: boolean;
-    displayMessageOnItemNotFound?: boolean;
-    allowToggle?: boolean;
-    omitTagNoFromUrl?: boolean;
-}, activeTagTab?: string, activeTagSubTab?: string, instCode?: string, openInPanel?: boolean, displayMessageOnItemNotFound?: boolean) => void;
+export type SetActiveTagNo = {
+    (args: {
+        tagNo: string;
+        activeTagTab?: string;
+        activeTagSubTab?: string;
+        instCode?: string;
+        activePanelKey?: string;
+        keepLastNavigationItem?: boolean;
+        openInPanel?: boolean;
+        displayMessageOnItemNotFound?: boolean;
+        allowToggle?: boolean;
+        omitTagNoFromUrl?: boolean;
+    }): void;
+    /** @deprecated Use the args object form instead: `setActiveTagNo({ tagNo, activeTagTab?, activeTagSubTab?, instCode?, openInPanel?, displayMessageOnItemNotFound? })` */
+    (tagNo: string, activeTagTab?: string, activeTagSubTab?: string, instCode?: string, openInPanel?: boolean, displayMessageOnItemNotFound?: boolean): void;
+};
 export type TagData = [(tagNo: string, instCode: string) => void];
-export type SetActiveCommPackNo = (argsORcommPackNo: string | {
-    commPackNo: string;
-    activeCommPackProject: string;
-    activePanelKey?: string;
-}, activeCommPackProject?: string) => void;
-export type SetActiveMcPackNo = (argsORmcPackNo: string | {
-    mcPackNo: string;
-    activeMcPackProject: string;
-    activePanelKey?: string;
-}, activeMcPackProject?: string) => void;
+export type SetActiveCommPackNo = {
+    (args: {
+        commPackNo: string;
+        activeCommPackProject: string;
+        activePanelKey?: string;
+    }): void;
+    /** @deprecated Use the args object form instead: `setActiveCommPackNo({ commPackNo, activeCommPackProject, activePanelKey? })` */
+    (commPackNo: string, activeCommPackProject: string): void;
+};
+export type SetActiveMcPackNo = {
+    (args: {
+        mcPackNo: string;
+        activeMcPackProject: string;
+        activePanelKey?: string;
+    }): void;
+    /** @deprecated Use the args object form instead: `setActiveMcPackNo({ mcPackNo, activeMcPackProject, activePanelKey? })` */
+    (mcPackNo: string, activeMcPackProject: string): void;
+};
 export type ScreenOrientation = 'landscape' | 'portrait' | undefined;

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

@@ -1,5 +0,0 @@
-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, hiddenMarkers: string[]) => LegendChipProps[];
-export declare const getBadgeChips: (badges: ReadonlyArray<Badge>, legend: LegendState, hiddenBadges: string[]) => LegendChipProps[];

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

@@ -1,34 +0,0 @@
-import { ItemToSelectionGroupsMap } from '../../../stores/itemToSelectionGroupsMapStore/itemToSelectionGroupsMapStore.types';
-import { Marker } from '../../../types/legendMarkerBadge.type';
-import { ColorGroupedMarker } from './splitMarkerByColor.types';
-/**
- * Splits a marker into variants based on selection color only (not selection group).
- *
- * The selection color is the color assigned to items in the global selection store
- * (item.metaData.color). This is used for the marker highlight color on the PDF.
-
- * Example: Marker with 3 equipment badges:
- * - Badge A (group1, red selection color)
- * - Badge B (group2, red selection color)
- * - Badge C (group3, blue selection color)
- *
- * Returns 2 marker variants:
- * - Red variant: [BadgeA(from group1), BadgeB(from group2)]
- * - Blue variant: [BadgeC(from group3)]
- *
- * When group2 is hidden, red variant filters to [BadgeA] only.
- *
- * @param itemToGroupsMap - Pre-built map of itemIdString -> SelectionGroup[] for lookup
- * @param marker - The marker containing badges to be split by selection color
- * @returns Array of selection-color-grouped marker variants
- */
-export declare const splitMarkerByColor: (itemToGroupsMap: ItemToSelectionGroupsMap, marker?: Marker) => ColorGroupedMarker[];
-/**
- * Filters a color-grouped marker's badges by hidden groups.
- * Returns undefined if all badges are hidden (marker should not render).
- *
- * @param marker - The color-grouped marker to filter
- * @param hiddenGroupKeys - Array of hidden group key strings
- * @returns Marker with filtered badges, or undefined if all hidden
- */
-export declare const filterBadgesByHiddenGroups: (marker: ColorGroupedMarker, hiddenGroupKeys: string[]) => ColorGroupedMarker | undefined;

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

@@ -1,37 +0,0 @@
-import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionItemType } from '../../../../globalSelection';
-import { Badge, Marker } from '../../../types/legendMarkerBadge.type';
-export interface GroupKey {
-    /** Helper to get the full string representation of the group key based on groupId, color, and optional itemType */
-    toString: () => string;
-    groupId: Guid;
-    color: string;
-    /** Optional item type for local selection which will be split by type */
-    itemType?: GlobalSelectionItemType;
-}
-/**
- * Badge with its associated group key for visibility filtering.
- */
-export interface BadgeWithGroup {
-    badge: Badge;
-    /** The group key this badge belongs to, for visibility filtering */
-    groupKey: GroupKey;
-}
-/**
- * A group of badges that share the same selection color.
- */
-export interface SelectionColorGroup {
-    selectionColor: string;
-    badgesWithGroups: BadgeWithGroup[];
-}
-/**
- * A color-grouped marker variant.
- * Contains badges of the same color, each tracking its own group for filtering.
- */
-export interface ColorGroupedMarker extends Marker {
-    /** Color-based key for this marker variant.
-     * We could use Marker.getHighlightColor() here, but using a key allows for future flexibility only related to PDF rendering.*/
-    getColorKey: () => string;
-    /** Badges with their group info for filtering */
-    badgesWithGroups: BadgeWithGroup[];
-}

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

@@ -1,23 +0,0 @@
-import { ColorGroupedMarker } from '../components/pdfMarkers/utils/splitMarkerByColor.types';
-import { Marker } from '../types/legendMarkerBadge.type';
-import { LegendId } from '../types/legendType';
-/**
- * Processes a marker and groups them by color, filtering badges by hidden groups.
- *
- * This hook splits marker into variants based on badge color (not selection group),
- * then filters individual badges based on whether their group is hidden.
- *
- * Rules:
- * - marker are grouped by **color only**
- * - Badges track their selection group for visibility filtering
- * - When a group is hidden, badges from that group are filtered out
- * - Marker variant hides only when ALL its badges are hidden
- *
- * @param args.legendId - The legend ID for UI state subscriptions
- * @param args.marker - The marker to process (typically a single marker)
- * @returns Array of color-grouped marker variants, or undefined if selection legend is disabled
- */
-export declare const useGroupedMarkers: (args: {
-    legendId: LegendId;
-    marker?: Marker;
-}) => ColorGroupedMarker[] | undefined;

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

@@ -1,9 +0,0 @@
-import { SelectionGroup } from '../../globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.types';
-import { Marker } from '../types/legendMarkerBadge.type';
-/**
- * Gets all potential group keys a marker could generate.
- * Used for per-marker hidden state subscriptions.
- * @param marker - The marker to get group keys for
- * @param itemToGroupsMap - Pre-built map of itemIdString -> selectionGroups - handled in store
- */
-export declare const getPotentialGroupKeysForMarker: (marker: Marker, itemToGroupsMap: Map<string, SelectionGroup[]>) => string[];

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

@@ -1,19 +0,0 @@
-import { Marker } from '../../types/legendMarkerBadge.type';
-import { LegendDataId, LegendId } from '../../types/legendType';
-export interface UseLegendMarkerProps {
-    legendId: LegendId;
-    itemIds: LegendDataId[];
-}
-/**
- * Returns the visible marker for the given legendId and itemIds.
- * If the legend is disabled or the marker is hidden, returns undefined.
- *
- * Performance optimization:
- * Uses per-marker subscription to hidden state - only re-renders when THIS specific
- * marker's visibility changes, not when any marker in the legend is hidden/shown.
- *
- * @param props.legendId - The legend to get the marker from
- * @param props.itemIds - The item IDs to create the marker from
- * @returns The marker if visible and legend is enabled, undefined otherwise
- */
-export declare function useLegendMarker(props: UseLegendMarkerProps): Marker | undefined;

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

@@ -1,21 +0,0 @@
-/**
- * Utility functions for legend visible markers functionality.
- *
- * This module contains shared utilities, helper functions, and debugging tools
- * used across the legend marker hooks.
- */
-import { Marker } from '../../types/legendMarkerBadge.type';
-import { LegendDataId, LegendId } from '../../types/legendType';
-/**
- * Development helper to track hook calls
- */
-export declare const trackMarkerCallsInDevelopment: () => void;
-/**
- * Helper to get unique data from the legend visible data store
- */
-export declare const useUniqueVisibleData: () => LegendDataId[];
-/**
- * Common logic for creating markers from data using strategy.
- * Selection-based grouping is handled at the viewport rendering level.
- */
-export declare const useCreateMarkers: (legendId: LegendId, data: LegendDataId[]) => ReadonlyArray<Marker>;

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

@@ -1,7 +0,0 @@
-import { Badge } from '../types/legendMarkerBadge.type';
-import { LegendId } from '../types/legendType';
-/**
- * Returns all unique badges for the given legendId, determined by unique title + color.
- * This will also return markers that are not visible on screen.
- */
-export declare function useLegendUniqueBadges(legendId: LegendId): ReadonlyArray<Badge>;

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

@@ -1,7 +0,0 @@
-import { Marker } from '../types/legendMarkerBadge.type';
-import { LegendId } from '../types/legendType';
-/**
- * Returns all unique markers for the given legendId, determined by unique displayKey (title + color).
- * This will also return markers that are not visible on screen.
- */
-export declare function useLegendUniqueMarkers(legendId: LegendId): ReadonlyArray<Marker>;

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

@@ -1,8 +0,0 @@
-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/legendStrategies/notificationStrategy/hooks/useNotificationMarkers.d.ts

@@ -1,10 +0,0 @@
-import type { Marker } from '../../../types/legendMarkerBadge.type';
-import { type LegendDataId } from '../../../types/legendType';
-/**
- * Creates notification markers from two sources:
- * 1. Tag-based: fetches open notifications for selected tags
- * 2. ID-based: fetches notification details by direct notification IDs
- *
- * Both sources are merged into a single marker array.
- */
-export declare const useNotificationMarkers: (itemIds: ReadonlyArray<LegendDataId>) => ReadonlyArray<Marker>;

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

@@ -1,6 +0,0 @@
-import { Badge, Marker } from '../types/legendMarkerBadge.type';
-import { LegendId } from '../types/legendType';
-export declare function isHiddenMarker(marker: Marker, hiddenMarkers: ReadonlyArray<string>): boolean;
-export declare function setHiddenMarker(marker: Marker, isHidden: boolean, legendId: LegendId): void;
-export declare function isHiddenBadge(badge: Badge, hiddenBadges: ReadonlyArray<string>): boolean;
-export declare function setHiddenBadge(badge: Badge, isHidden: boolean, legendId: LegendId): void;