@equinor/echo-framework 0.25.0 → 0.25.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "0.25.0",
+  "version": "0.25.2",
   "peerDependencies": {
     "@equinor/echo-base": ">= 0.7.5 < 0.8.0",
     "@equinor/echo-components": ">= 0.12.4 < 0.13.0",
@@ -29,5 +29,5 @@
   },
   "main": "./index.cjs.js",
   "type": "commonjs",
-  "types": "./index.cjs.d.ts"
+  "types": "./index.d.ts"
 }

package/src/index.d.ts

@@ -1,5 +1,6 @@
 import { getLegendStatusColor } from './lib/feature/legacyLegend/utils/legendUtils';
 import './lib/globalStyles.css';
+import * as hooks from './lib/hooks';
 import { getPlantsInfo, getTagDetails } from './lib/services/api';
 export * from './lib/components';
 export { NotificationListItem } from './lib/components/notificationListItem';
@@ -21,7 +22,7 @@ export { GlobalSelectionCategoryId } from './lib/feature/globalSelection/selecti
 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 { legendVisibleTagsSubscribeToStore } from './lib/feature/legend/legendVisibleDataAsTagsStore';
 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';
@@ -84,8 +85,8 @@ declare const EchoFramework: Readonly<{
         }>;
     }>;
     Hooks: Readonly<{
+        useClosePanelByKey: typeof hooks.useClosePanelByKey;
         useInstCodeSafe: () => string;
-        useClosePanelByKey(panelKey?: string): () => void;
         useEchoHistory(): (path: string, params?: {
             [key: string]: string;
         } | undefined, state?: any) => void;
@@ -117,12 +118,12 @@ declare const EchoFramework: Readonly<{
             tagNo: string;
             instCode: string;
         }): {
-            tagDetails: import("dist/libs/echo-search/src").TagDetailsDto | undefined;
+            tagDetails: import("@equinor/echo-search").TagDetailsDto | undefined;
             isTagDetailsLoading: boolean;
             hasError: boolean;
         };
         useSetActiveTagNo: () => import("./lib/types/hookLibrary").SetActiveTagNo;
-        useContextMenuDataInfo: (tagNo: string, expanded: boolean, setActivePanel?: () => void) => import("dist/libs/echo-components/src").DataInformation[];
+        useContextMenuDataInfo: (tagNo: string, expanded: boolean, setActivePanel?: () => void) => import("@equinor/echo-components").DataInformation[];
         useTagData: () => import("./lib/types/hookLibrary").TagData;
         useIsContextMenuInfoLoading: () => boolean;
         useSetActiveCommPackNo: () => import("./lib/types/hookLibrary").SetActiveCommPackNo;

package/src/lib/components/contextualAppLinks/hooks/useContextualAppLinksContext.d.ts

@@ -1,4 +1,4 @@
 export declare function useContextualAppLinksContext(): {
-    tag: import("dist/libs/echo-search/src").TagSummaryDto;
+    tag: import("@equinor/echo-search").TagSummaryDto;
     instCode: string;
 };

package/src/lib/components/notificationListItem/types/types.d.ts

@@ -8,4 +8,5 @@ export interface NotificationListItemProps {
     isHeader?: boolean;
     colorMap?: ColorMap;
     className?: string;
+    isHighlightable?: boolean;
 }

package/src/lib/feature/globalSelection/OpenGlobalSelectionIn3DButton.utils.d.ts

@@ -0,0 +1,14 @@
+import { PlantAndTagForOpenIn3d } from '../openItemsIn3d/logic/openItemsIn3d.utils';
+/**
+ * Converts global selection items to plant tag pairs.
+ *
+ * This function processes different types of global selection items (Tag, WorkOrder, Equipment)
+ * and converts them into an array of `PlantAndTagForOpenIn3d` objects. It ensures that all
+ * enum cases are handled by using a switch statement and the `assertUnreachable` function.
+ *
+ * The resulting array is then filtered to remove duplicates based on the combination of
+ * `instCode`, `pdmsPlantCode`, and `tagNo`.
+ *
+ * @returns {Promise<PlantAndTagForOpenIn3d[]>} A promise that resolves to an array of plant tag pairs.
+ */
+export declare function convertGlobalSelectionItemsToPlantTagPairs(): Promise<PlantAndTagForOpenIn3d[]>;

package/src/lib/feature/globalSelection/globalSelection.api.d.ts

@@ -27,7 +27,7 @@ export declare const globalSelectionApi: Readonly<{
          * @param {GlobalSelectionCategoryId} args.category - The ID of the list where the items to be removed are located.
          */
         itemsById: (args: {
-            groupId?: import("dist/libs/echo-utils/src").Guid;
+            groupId?: import("@equinor/echo-utils").Guid;
             categoryId: GlobalSelectionCategoryId;
             itemIds: GlobalSelectionTypes.ItemId[];
         }) => void;
@@ -54,7 +54,7 @@ export declare const globalSelectionApi: Readonly<{
          * @param {GlobalSelectionCategoryId} [args.categoryId] - The ID of the category to remove (optional).
          */
         listById: (args: {
-            groupId: import("dist/libs/echo-utils/src").Guid;
+            groupId: import("@equinor/echo-utils").Guid;
             categoryId?: GlobalSelectionCategoryId;
         }) => void;
     }>;
@@ -124,7 +124,7 @@ export declare const globalSelectionApi: Readonly<{
         }) => boolean;
         findGroupByLabel: (args: {
             label: string;
-        }) => import("dist/libs/echo-utils/src").Guid | undefined;
+        }) => import("@equinor/echo-utils").Guid | undefined;
     };
     visibility: Readonly<{
         setByItemIds: (args: {
@@ -141,7 +141,7 @@ export declare const globalSelectionApi: Readonly<{
          * @param {boolean} args.isVisible - The visibility state to set for the items in the list.
          */
         setById: (args: {
-            groupId: import("dist/libs/echo-utils/src").Guid;
+            groupId: import("@equinor/echo-utils").Guid;
             categoryId?: GlobalSelectionCategoryId;
             isVisible: boolean;
         }) => void;
@@ -199,8 +199,8 @@ export declare const globalSelectionApi: Readonly<{
      */
     clearSelection: () => void;
     createGroup: (args: {
-        groupId: string;
+        groupId?: string;
         label: string;
         subLabel: string;
-    }) => import("dist/libs/echo-utils/src").Guid;
+    }) => import("@equinor/echo-utils").Guid;
 }>;

package/src/lib/feature/globalSelection/globalSelectionStore/globalSelectionStoreHelpers.d.ts

@@ -1,18 +1,4 @@
-import { PlantAndTagForOpenIn3d } from '../../openItemsIn3d/logic/openItemsIn3d.utils';
 import { GlobalSelectionItemType, GlobalSelectionTypes, SelectionItemSystemStatus } from './globalSelectionStore.types';
-/**
- * Converts global selection items to plant tag pairs.
- *
- * This function processes different types of global selection items (Tag, WorkOrder, Equipment)
- * and converts them into an array of `PlantAndTagForOpenIn3d` objects. It ensures that all
- * enum cases are handled by using a switch statement and the `assertUnreachable` function.
- *
- * The resulting array is then filtered to remove duplicates based on the combination of
- * `instCode`, `pdmsPlantCode`, and `tagNo`.
- *
- * @returns {Promise<PlantAndTagForOpenIn3d[]>} A promise that resolves to an array of plant tag pairs.
- */
-export declare function convertGlobalSelectionItemsToPlantTagPairs(): Promise<PlantAndTagForOpenIn3d[]>;
 export declare function toGlobalSelectionItem<T extends GlobalSelectionTypes.ItemTypeToDataMap[K], K extends GlobalSelectionItemType>(item: T, type: K, systemStatus: SelectionItemSystemStatus): GlobalSelectionTypes.GenericItem<K>;
 export declare function toGlobalSelectionItems<T extends GlobalSelectionTypes.ItemTypeToDataMap[K], K extends GlobalSelectionItemType>(items: T[], type: K, systemStatus: SelectionItemSystemStatus): GlobalSelectionTypes.GenericItem<K>[];
 export declare function setNotFoundStatusByItemIds(args: {

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

@@ -1,10 +1,8 @@
-export { MeasuringPointListItem } from '../measuringPoint/components/MeasuringPointListItem';
 export { RemoveSelectionItemsConfirmDialog } from './components/RemoveSelectionItemsConfirmDialog';
 export { globalSelectionApi } from './globalSelection.api';
 export { globalSelectionInternal } from './globalSelection.internal';
 export * from './globalSelectionStore/globalSelectionStore.types';
 export { globalSelectionUtils } from './globalSelectionStore/globalSelectionStore.utils';
-export { convertGlobalSelectionItemsToPlantTagPairs } from './globalSelectionStore/globalSelectionStoreHelpers';
 export { useGlobalSelectionByItemId } from './hooks/useGlobalSelectionByItemId';
 export { useGlobalSelectionItems } from './hooks/useGlobalSelectionItems';
 export { useGlobalSelectionItemsByType } from './hooks/useGlobalSelectionItemsByType';

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/selectionTree.action.types.d.ts

@@ -1,8 +1,11 @@
 import { ResultArray } from '@equinor/echo-search';
 import { GlobalSelectionItemType, GlobalSelectionItemTypeToDataMap, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from '../../../globalSelectionStore/globalSelectionStore.types';
-import { SelectionBase } from '../selectionTree.store.types';
-export type AddByGroupIdAndLabel = SelectionBase | {
-    groupId?: undefined;
+export type AddByGroupIdAndLabel = {
+    groupId?: string;
+    label: string;
+    subLabel: string;
+} | {
+    groupId?: string;
     label?: undefined;
     subLabel?: undefined;
 };

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.types.d.ts

@@ -46,7 +46,7 @@ export interface SelectionTreeStore {
     addEquipments: (args: AddItemArgs<GlobalSelectionTypes.EquipmentId>) => AddEquipmentsReturnType;
     addMeasuringPoints: (args: AddItemArgs<GlobalSelectionTypes.MeasuringPointId>) => AddMeasuringPointsReturnType;
     createGroup: (args: {
-        groupId: string;
+        groupId?: string;
         label: string;
         subLabel: string;
     }) => Guid;

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

@@ -1,5 +1,7 @@
 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';
 /**
  * Public facade for the legend.
@@ -9,6 +11,15 @@ export declare const legendFacade: Readonly<{
         inject: typeof injectLegendStrategy;
         get: typeof getLegendStrategy;
     };
+    store: {
+        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?: {
+                equalityFn?: ((a: U, b: U) => boolean) | undefined;
+                fireImmediately?: boolean;
+            } | undefined): () => void;
+        };
+    };
     storeSnapshot: typeof legendSnapShot;
     legend: {
         createId: typeof createLegendId;
@@ -48,5 +59,47 @@ export declare const legendFacade: Readonly<{
             }[T][];
             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?: {
+                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"> & {
+            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;
+        }, "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?: {
+                    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 | {
+                type: string;
+            } | undefined): void;
+        }>;
+        snapShot: typeof visibleDataAsTagsSnapshot;
+    };
+    utils: {
+        isLegendDataIdEqualWithTag: typeof isLegendDataIdEqualWithTag;
     };
 }>;
+/**
+             <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/legendStore.d.ts

@@ -1,11 +1,13 @@
 import { PersistOptions } from 'zustand/middleware';
 import { LegendId, LegendState } from './types/legendType';
 type LegendsDictionary = Record<LegendId, LegendState>;
-interface LegendStoreData {
+export interface LegendStoreData {
     legends: LegendsDictionary;
 }
-interface LegendStoreActions {
-    updateLegend: (legendId: LegendId, updates: Partial<LegendState>) => void;
+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;
@@ -49,4 +51,11 @@ export declare const useLegendStore: import("zustand").UseBoundStore<Omit<Omit<O
 export declare function useLegendById(legendId: LegendId): LegendState;
 export declare function useAllLegends(): LegendState[];
 export declare function legendSnapShot(): LegendStore;
+export declare const legendStoreSubscribe: {
+    (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;
+};
 export {};

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

@@ -0,0 +1,41 @@
+import { TagWithEquipmentId } from './legendVisibleDataAsTagsStore.type';
+interface VisibleDataAsTagsStoreState {
+    readonly tags: TagWithEquipmentId[];
+    readonly isPending: boolean;
+}
+interface VisibleDataAsTagsStoreActions {
+    /**
+     * Will add tags that are in visible data store, the rest will be discarded.
+     * This is to ensure that we only keep tags that are relevant to the current visible data
+     */
+    updateTags: (tags: TagWithEquipmentId[]) => void;
+    setIsPending: (isPending: boolean) => void;
+}
+export interface VisibleDataAsTagsStore extends VisibleDataAsTagsStoreState, VisibleDataAsTagsStoreActions {
+}
+/**
+ * Goal here is to convert the visible data store items (like equipment) to tags.
+ * It also includes the TagSummary, and thereby have loading state.
+ *
+ * This one might be more convenient to use than the legendVisibleDataStore.
+ */
+export declare const useVisibleDataAsTagsStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<VisibleDataAsTagsStore>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: VisibleDataAsTagsStore | Partial<VisibleDataAsTagsStore> | ((state: VisibleDataAsTagsStore) => VisibleDataAsTagsStore | Partial<VisibleDataAsTagsStore>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: VisibleDataAsTagsStore, previousSelectedState: VisibleDataAsTagsStore) => void): () => void;
+        <U>(selector: (state: VisibleDataAsTagsStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: VisibleDataAsTagsStore | Partial<VisibleDataAsTagsStore> | ((state: import("immer").WritableDraft<VisibleDataAsTagsStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: string;
+    } | undefined): void;
+}>;
+export declare function visibleDataAsTagsSnapshot(): VisibleDataAsTagsStore;
+export declare function legendVisibleTagsSubscribeToStore(): void;
+export {};

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

@@ -0,0 +1,3 @@
+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/legendVisibleDataAsTagsStore.type.d.ts

@@ -0,0 +1,7 @@
+import { TagSummaryDto } from '@equinor/echo-search';
+export interface TagWithEquipmentId {
+    readonly tagNo: string;
+    readonly instCode: string;
+    readonly equipmentId: string | undefined;
+    readonly tagSummary: TagSummaryDto;
+}

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

@@ -34,7 +34,14 @@ interface LegendVisibleDataStoreActions {
     useDataByType: <T extends KnownDataTypeKeys>(type: T) => ResolvedDataType<T>[];
     getAll(): LegendDataId[];
 }
-type LegendVisibleDataStore = LegendVisibleData & LegendVisibleDataStoreActions;
+export type LegendVisibleDataStore = LegendVisibleData & LegendVisibleDataStoreActions;
+export declare function getLegendVisibleDataInitialValues(): LegendVisibleData;
+/**
+ * This is meant to be a simple store, that contains all visible data ItemIds on screen that should be visible in the legend.
+ * It should only contain ItemIds, not the actual data. Meaning we don't need to handle fetch states here like loading.
+ *
+ * LegendVisibleDataConvertedToTagsStore might be more convenient to use in the legend strategies that don't relay on the EquipmentId.
+ */
 export declare const useLegendVisibleDataStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<LegendVisibleDataStore>, "setState"> & {
     setState<A extends string | {
         type: string;
@@ -68,5 +75,12 @@ export declare const visibleData: {
     getAll: () => LegendDataId[];
     useByType: <T extends KnownDataTypeKeys>(type: T) => ResolvedDataType<T>[];
     useAddWithAutoRemove: typeof useAddWithAutoRemove;
+    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;
+    };
 };
 export {};

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

@@ -0,0 +1,12 @@
+import { LegendDataId } from '../types/legendType';
+interface TagWithEquipmentId {
+    tagNo: string;
+    instCode: string;
+    equipmentId: string | undefined;
+}
+/**
+ * Checks if the given `legendDataId` is equal to the provided `tag` based on their properties.
+ * It first tries to match the `equipmentId`, and if no match, it tries the `tagId`
+ */
+export declare function isLegendDataIdEqualWithTag(legendDataId: LegendDataId, tag: TagWithEquipmentId): boolean;
+export {};

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

@@ -9,11 +9,6 @@ export interface LegendStrategy {
      * A unique identifier for the legend. Use a friendly UI name since it's displayed in legend component.
      */
     legendId: LegendId;
-    /**
-     * not implemented yet TODO #155599 - Data Service
-     * Idea is to notify the legend that it should batch fetch data for the given visibleItemIds, and we will automatically show loading status in UI.
-     */
-    fetchData?: (visibleItemIds: ReadonlyArray<LegendDataId>) => Promise<void>;
     /**
      * Marker options that is selectable by the user.
      */

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

@@ -1,4 +1,5 @@
 export { failureMechanismConfig, MeasuringPointDetails, MeasuringPointHeader } from './components';
+export { MeasuringPointListItem } from './components/MeasuringPointListItem';
 export { useOpenMeasuringPointDetails } from './hooks';
 export type { DocumentRelationships } from './types/documentRelationships';
 export type { MeasurementDto, MeasuringPointDto } from './types/measuringPoint';

package/src/lib/feature/workOrder/api/api-prepview-workOrder.d.ts

@@ -0,0 +1,7 @@
+import { PrepViewWorkOrder, PrepViewWorkOrderDto } from '../types/workOrder';
+interface WorkOrderRequest {
+    readonly workOrderId: string;
+}
+export declare const getPrepviewWorkOrderDetails: (args: WorkOrderRequest) => Promise<PrepViewWorkOrder>;
+export declare const cleanupPrepviewWorkOrder: (workOrder: PrepViewWorkOrderDto) => PrepViewWorkOrder;
+export {};

package/src/lib/feature/workOrder/components/PanelTagInfo/PanelTagInfo.d.ts

@@ -0,0 +1,5 @@
+interface PanelTagInfoProps {
+    readonly workOrderId: string;
+}
+export declare const PanelTagInfo: (props: PanelTagInfoProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/lib/feature/workOrder/components/PanelTagInfo/api/api-prepview-workOrder-tagInfo.d.ts

@@ -0,0 +1,6 @@
+import { PrepviewTagInfo } from '../types/tagInfo';
+interface PrepviewWorkOrderTagInfoRequest {
+    readonly workOrderId: string;
+}
+export declare function getPrepviewWorkOrderTagInfo(args: PrepviewWorkOrderTagInfoRequest): Promise<PrepviewTagInfo>;
+export {};

package/src/lib/feature/workOrder/components/PanelTagInfo/hooks/usePrepviewWorkOrderTagInfo.d.ts

@@ -0,0 +1,6 @@
+import { PrepviewTagInfo } from '../types/tagInfo';
+export declare const usePrepviewWorkOrderTagInfo: (workOrderId: string) => {
+    isLoading: boolean;
+    error: Error | null;
+    tagInfo?: PrepviewTagInfo;
+};

package/src/lib/feature/workOrder/components/PanelTagInfo/types/tagInfo.d.ts

@@ -0,0 +1,32 @@
+export interface PrepviewTagInfoDto {
+    id: string;
+    functionalLocation: string;
+    location?: string | null;
+    area?: string | null;
+    overallCriticality?: string | null;
+    abcIndicator?: string | null;
+    redundancy?: string | null;
+    consequenceHse?: string | null;
+    consequenceProd?: string | null;
+    consequenceCost?: string | null;
+    consequenceFail?: string | null;
+    repairStrategy?: string | null;
+    criticalSparePartDemandTime?: string | null;
+    unsafeFailure?: Array<string>;
+}
+export interface PrepviewTagInfo {
+    id: string;
+    functionalLocation: string;
+    location?: string;
+    area?: string;
+    overallCriticality?: string;
+    abcIndicator?: string;
+    redundancy?: string;
+    consequenceHse?: string;
+    consequenceProd?: string;
+    consequenceCost?: string;
+    consequenceFail?: string;
+    repairStrategy?: string;
+    criticalSparePartDemandTime?: string;
+    unsafeFailure?: Array<string>;
+}

package/src/lib/feature/workOrder/components/WorkOrderItemDetails.d.ts

@@ -1,6 +1,6 @@
-import { WorkOrderDetails } from '../types/workOrder';
+import { PrepViewWorkOrder } from '../types/workOrder';
 interface WorkOrderItemDetailsProps {
-    readonly data: WorkOrderDetails;
+    readonly data: PrepViewWorkOrder;
 }
 export declare const WorkOrderItemDetails: (props: WorkOrderItemDetailsProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/src/lib/feature/workOrder/components/WorkOrderItemHeader.d.ts

@@ -1,10 +1,6 @@
-import { WorkOrderDetails } from '../types/workOrder';
+import { WorkOrderItemHeaderData } from './WorkOrderItemHeader.types';
 interface WorkOrderHeaderProps {
-    /**
-     * TODO: We need to improve types on WorkOrderListItem before we Pick the actual properties we need for this component.
-     *       Until then we will continue with the original mapWorkOrderDetailsToWorkOrderItem.
-     */
-    readonly data: WorkOrderDetails;
+    readonly data: WorkOrderItemHeaderData;
 }
 export declare const WorkOrderItemHeader: (props: WorkOrderHeaderProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/src/lib/feature/workOrder/components/WorkOrderItemHeader.types.d.ts

@@ -0,0 +1,2 @@
+import { PrepViewWorkOrder } from '../types/workOrder';
+export type WorkOrderItemHeaderData = Pick<PrepViewWorkOrder, 'id' | 'description' | 'orderType' | 'isActive' | 'workCenterId' | 'basicFinishDateStatus' | 'requiredEndDateTime' | 'requiredEndDateStatus' | 'maintenancePlanDate' | 'basicFinishDateTime' | 'basicStartDateTime' | 'planningPlant' | 'maintenancePlant' | 'plantId'>;

package/src/lib/feature/workOrder/components/WorkOrderItemTabInfo/WorkOrderItemTabInfo.d.ts

@@ -0,0 +1,7 @@
+import { PrepViewWorkOrder } from '../../types/workOrder';
+type WorkOrderItemTabInfoData = Pick<PrepViewWorkOrder, 'tagId' | 'instCode' | 'tagCategory' | 'id' | 'description' | 'workCenterId' | 'requiredEndDateTime' | 'basicFinishDateTime' | 'basicStartDateTime' | 'planningPlant' | 'maintenancePlant' | 'activeStatusIds' | 'personResponsible' | 'locationId' | 'plannerGroupId' | 'system' | 'systemId' | 'createdDateTime' | 'changedDateTime' | 'priority' | 'revisionId' | 'equipmentId' | 'longText'>;
+interface WorkOrderItemTabInfoProps {
+    readonly data: WorkOrderItemTabInfoData;
+}
+export declare const WorkOrderItemTabInfo: (props: WorkOrderItemTabInfoProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/lib/feature/workOrder/hooks/usePrepviewWorkOrder.d.ts

@@ -1,6 +1,6 @@
-import { WorkOrderDetails } from '../types/workOrder';
+import { PrepViewWorkOrder } from '../types/workOrder';
 export declare function usePrepviewWorkOrder(workOrderId: string): {
     isLoading: boolean;
     error: Error | null;
-    workOrder?: WorkOrderDetails;
+    workOrder?: PrepViewWorkOrder;
 };