@equinor/echo-framework 0.20.22 → 0.20.23-beta-1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "0.20.22",
+  "version": "0.20.23-beta-1",
   "peerDependencies": {
     "@equinor/echo-base": ">= 0.7.0 < 0.8.0",
     "@equinor/echo-components": ">= 0.11.0 < 0.12.0",

package/src/index.d.ts

@@ -17,6 +17,10 @@ export { PanTo3DButton } from './lib/feature/globalSelection/panToEcho3d/panTo3D
 export { useIsAllIGlobalSelectionItemsHidden } from './lib/feature/globalSelection/selectionMenu/hooks/useIsAllIGlobalSelectionItemsHidden';
 export { GlobalSelectionCategoryId, SelectionMenuDefaultListIds } from './lib/feature/globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.types';
 export * from './lib/feature/legacyLegend/index';
+export { PositionalLegendMarkers } from './lib/feature/legend/components/pdfMarkers/PositionalLegendMarkers';
+export * from './lib/feature/legend/index';
+export { subscribeToLegendDataChanged } from './lib/feature/legend/legendUpdater';
+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';
 export * from './lib/feature/measuringPoint/types/measuringPoint';

package/src/lib/feature/legend/components/BasicLegendRenderer.d.ts

@@ -0,0 +1,6 @@
+interface LegendSelectorMenuProps {
+    legendId: string;
+    isExpanded?: boolean;
+}
+export declare const BasicLegendRenderer: import("react").NamedExoticComponent<LegendSelectorMenuProps>;
+export {};

package/src/lib/feature/legend/components/LegendList.d.ts

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+/**
+ * This will render all legends in lower left, with customLegendUi if available, otherwise BasicLegendRenderer.
+ */
+export declare const LegendList: FC;

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

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

package/src/lib/feature/legend/components/pdfMarkers/PositionalItem.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface PositionalItemProps {
+    position: string;
+    isOpen: boolean;
+    children: React.ReactNode;
+}
+export declare const PositionalItem: React.FC<PositionalItemProps>;
+export {};

package/src/lib/feature/legend/components/pdfMarkers/PositionalLegendMarkers.d.ts

@@ -0,0 +1,24 @@
+import { Point } from '@equinor/echo-utils';
+import React from 'react';
+import { LegendDataId } from '../../types/legendType';
+interface LegendPositionItem {
+    itemId: LegendDataId;
+    position: Point;
+    hasPointer: boolean;
+}
+interface PositionalLegendMarkersProps {
+    items: ReadonlyArray<LegendPositionItem>;
+    pdfRotation: number;
+    currentPageScale: number;
+    pdfZoom: number;
+}
+/**
+ * Component that renders positional legend markers on a PDF or on other view.
+ *
+ * @param {ReadonlyArray<LegendPositionItem>} items - Array of position items.
+ * @param {number} pdfRotation - The rotation angle of the PDF.
+ * @param {number} currentPageScale - The current scale of the PDF page.
+ * @param {number} pdfZoom - The zoom level of the PDF.
+ */
+export declare const PositionalLegendMarkers: React.FC<PositionalLegendMarkersProps>;
+export {};

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import { LegendDataId } from '../../../types/legendType';
+interface LegendColoredMarkerIconProps {
+    legendId: string;
+    itemId: LegendDataId;
+    hasPointer: boolean;
+    isActive: boolean;
+    onClick: () => void;
+}
+export declare const MemoizedLegendColoredMarkerIcon: React.NamedExoticComponent<LegendColoredMarkerIconProps>;
+export {};

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

@@ -0,0 +1,13 @@
+import React from 'react';
+import { LegendDataId } from '../../../types/legendType';
+interface LegendPositionItem {
+    itemId: LegendDataId;
+    positionString: string;
+    hasPointer: boolean;
+    popoverOffset: string;
+}
+interface LegendMarkersRendererWithPopoverProps {
+    positionItems: ReadonlyArray<LegendPositionItem>;
+}
+export declare const LegendMarkersRendererWithPopover: React.FC<LegendMarkersRendererWithPopoverProps>;
+export {};

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

@@ -0,0 +1,21 @@
+import React from 'react';
+import { LegendDataId } from '../../../types/legendType';
+interface MultipleMarkersByLegendsProps {
+    itemId: LegendDataId;
+    hasPointer: boolean;
+    popoverOffset: string;
+    setOpenItem: (value: PopoverContent | undefined) => void;
+    activeItem: ActiveItem | undefined;
+}
+export interface PopoverContent {
+    elements: JSX.Element[];
+    popoverOffset: string;
+    activeItem: ActiveItem;
+}
+interface ActiveItem {
+    itemId: LegendDataId;
+    legendId: string;
+}
+export declare const MultipleMarkersByLegendsComponent: React.FC<MultipleMarkersByLegendsProps>;
+export declare const MultipleMarkersByLegends: React.NamedExoticComponent<MultipleMarkersByLegendsProps>;
+export {};

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

@@ -0,0 +1,18 @@
+import { Point } from '@equinor/echo-utils';
+export declare const calculateIconScale: (currentPageScale: number) => number;
+export declare function calculatePopoverStyling(args: {
+    pdfZoom: number;
+    hasPointer: boolean;
+    position: Point;
+    pdfRotation: number;
+    currentPageScale: number;
+    markerHeight: number;
+}): string;
+export declare function iconPositionTransform(args: {
+    position: Point;
+    pdfRotation: number;
+    currentPageScale: number;
+    isMobileDevice: boolean;
+    pdfZoom: number;
+    hasPointer: boolean;
+}): string;

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

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

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

@@ -0,0 +1,7 @@
+import './legendStrategies/workOrderStrategy/WorkOrderLegend';
+export { LegendList as LegendsRenderer } from './components/LegendList';
+export { PositionalItem } from './components/pdfMarkers/PositionalItem';
+export { MultipleMarkersByLegends } from './components/pdfMarkers/subComponents/MultipleMarkersByLegends';
+export { legendFacade } from './legendFacade';
+export type { Badge, Marker } from './types/legendMarkerBadge.type';
+export type { LegendStrategy } from './types/legendStrategy.type';

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

@@ -0,0 +1,29 @@
+import { legendSnapShot, useAllLegends, useLegendById } from './legendStore';
+import { getLegendStrategy, injectLegendStrategy } from './legendStrategies/legendCollections';
+import { legendVisibleDataSnapshot, useAddVisibleItems } from './legendVisibleDataStore';
+export declare const legendFacade: Readonly<{
+    injectLegendStrategy: typeof injectLegendStrategy;
+    useVisibleDataStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions>, "setState"> & {
+        setState<A extends string | {
+            type: string;
+        }>(partial: (import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions) | Partial<import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions> | ((state: import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions) => (import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions) | Partial<import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions>), replace?: boolean | undefined, action?: A | undefined): void;
+    }, "subscribe"> & {
+        subscribe: {
+            (listener: (selectedState: import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions, previousSelectedState: import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions) => void): () => void;
+            <U>(selector: (state: import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+                equalityFn?: ((a: U, b: U) => boolean) | undefined;
+                fireImmediately?: boolean;
+            } | undefined): () => void;
+        };
+    }, "setState"> & {
+        setState(nextStateOrUpdater: (import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions) | Partial<import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions> | ((state: import("immer").WritableDraft<import("./legendVisibleDataStore").LegendVisibleData & import("./legendVisibleDataStore").LegendVisibleDataStoreActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+            type: string;
+        } | undefined): void;
+    }>;
+    visibleDataSnapshot: typeof legendVisibleDataSnapshot;
+    storeSnapshot: typeof legendSnapShot;
+    getStrategy: typeof getLegendStrategy;
+    useLegendById: typeof useLegendById;
+    useAllLegends: typeof useAllLegends;
+    useAddVisibleItems: typeof useAddVisibleItems;
+}>;

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

@@ -0,0 +1,43 @@
+import { PersistOptions } from 'zustand/middleware';
+import { LegendState } from './types/legendType';
+interface LegendStoreData {
+    legends: Record<string, LegendState>;
+}
+interface LegendStoreActions {
+    updateLegend: (legendId: string, updates: Partial<LegendState>) => void;
+    setHiddenMarker: (legendId: string, marker: string, isHidden: boolean) => void;
+    setHiddenBadge: (legendId: string, badge: string, isHidden: boolean) => void;
+    getLegendById: (legendId: string) => LegendState | undefined;
+}
+type LegendStore = LegendStoreData & LegendStoreActions;
+export declare const useLegendStore: import("zustand").UseBoundStore<Omit<Omit<Omit<Omit<import("zustand").StoreApi<LegendStore>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: LegendStore | Partial<LegendStore> | ((state: LegendStore) => LegendStore | Partial<LegendStore>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: LegendStore, previousSelectedState: LegendStore) => void): () => void;
+        <U>(selector: (state: LegendStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<PersistOptions<LegendStore, LegendStore>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: LegendStore) => void) => () => void;
+        onFinishHydration: (fn: (state: LegendStore) => void) => () => void;
+        getOptions: () => Partial<PersistOptions<LegendStore, LegendStore>>;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: LegendStore | Partial<LegendStore> | ((state: import("immer").WritableDraft<LegendStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: string;
+    } | undefined): void;
+}>;
+export declare function useLegendById(legendId: string): LegendState;
+export declare function useAllLegends(): LegendState[];
+export declare function legendSnapShot(): LegendStore;
+export {};

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

@@ -0,0 +1,4 @@
+import { LegendStrategy } from '../types/legendStrategy.type';
+import { LegendState } from '../types/legendType';
+export declare function injectLegendStrategy(strategy: LegendStrategy, properties: Partial<LegendState>): void;
+export declare function getLegendStrategy(strategyTypeName: string): LegendStrategy;

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

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

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

@@ -0,0 +1,2 @@
+export declare function subscribeToLegendDataChanged(): void;
+export declare const sleep: (ms: number) => Promise<unknown>;

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

@@ -0,0 +1,61 @@
+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)
+ */
+type KnownDataTypes = {
+    Tag: LegendTagId;
+    Equipment: LegendEquipmentId;
+};
+type KnownDataTypeKeys = keyof KnownDataTypes;
+type ResolvedDataType<T extends KnownDataTypeKeys> = KnownDataTypes[T];
+/**
+ * Data structure:
+ * Data
+ * - Tag
+ *   - key1: [data1, data2, ...]
+ *   - key2: [data1, data2, ...]
+ * - Equipment
+ *   - key1: [data1, data2, ...]
+ * ...
+ */
+interface LegendVisibleData {
+    data: LegendVisibleDataState;
+}
+type LegendVisibleDataState = {
+    [K in KnownDataTypeKeys]: {
+        [key: string]: ResolvedDataType<K>[];
+    };
+};
+export interface LegendVisibleDataStoreActions {
+    addData: <T extends KnownDataTypeKeys>(type: T, key: string, value: ResolvedDataType<T>[]) => void;
+    removeData: (key: string) => void;
+    getData: <T extends KnownDataTypeKeys>(type: T) => ResolvedDataType<T>[];
+    useDataByType: <T extends KnownDataTypeKeys>(type: T) => ResolvedDataType<T>[];
+    getAll(): LegendDataId[];
+}
+type LegendVisibleDataStore = LegendVisibleData & LegendVisibleDataStoreActions;
+export declare const useLegendVisibleDataStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<LegendVisibleDataStore>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: LegendVisibleDataStore | Partial<LegendVisibleDataStore> | ((state: LegendVisibleDataStore) => LegendVisibleDataStore | Partial<LegendVisibleDataStore>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: LegendVisibleDataStore, previousSelectedState: LegendVisibleDataStore) => void): () => void;
+        <U>(selector: (state: LegendVisibleDataStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: LegendVisibleDataStore | Partial<LegendVisibleDataStore> | ((state: import("immer").WritableDraft<LegendVisibleDataStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: string;
+    } | undefined): void;
+}>;
+export declare function legendVisibleDataSnapshot(): LegendVisibleDataStore;
+/**
+ * Visible items are all items on screen that should be affected by the legend.
+ * @returns A function for adding visible items by type and key, which is automatically removed when the component unmounts.
+ */
+export declare function useAddVisibleItems(): <T extends KnownDataTypeKeys>(type: T, key: string, value: ResolvedDataType<T>[]) => void;
+export {};

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

@@ -0,0 +1,11 @@
+export interface Marker {
+    getTitle: () => string;
+    getColor: () => string;
+    getIcon: () => string;
+    badges: Badge[];
+}
+export declare function markerKey(marker: Marker): string;
+export interface Badge {
+    getColor: () => string;
+    getTitle: () => string;
+}

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

@@ -0,0 +1,11 @@
+import { Marker } from './legendMarkerBadge.type';
+import { LegendDataId } from './legendType';
+export interface LegendStrategy {
+    legendId: string;
+    useMarkers: (itemIds: ReadonlyArray<LegendDataId>) => Marker[];
+    popoverContent: (itemId: LegendDataId) => React.JSX.Element[];
+    fetchData?: (visibleItemIds: ReadonlyArray<LegendDataId>) => Promise<void>;
+    markerOptions?: string[];
+    badgeOptions?: string[];
+    customLegendUi?: () => React.JSX.Element;
+}

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

@@ -0,0 +1,15 @@
+import { GlobalSelectionTypes } from '../../globalSelection';
+export interface LegendState {
+    legendId: string;
+    isEnabled: boolean;
+    isLoading: boolean;
+    hiddenMarkers: string[];
+    hiddenBadges: string[];
+    selectedMarkerOption: string;
+    selectedBadgeOption: string;
+    isExpanded: boolean;
+}
+export type LegendTagId = GlobalSelectionTypes.TagId;
+export type LegendEquipmentId = GlobalSelectionTypes.EquipmentId;
+export type LegendWorkOrderId = GlobalSelectionTypes.WorkOrderId;
+export type LegendDataId = LegendTagId | LegendEquipmentId | LegendWorkOrderId;