@gridsuite/commons-ui 0.207.0 → 0.208.0

package/dist/index.js

@@ -264,9 +264,10 @@ import { MODIFICATION_TYPES, ModificationType } from "./utils/types/modification
 import { FieldType } from "./utils/types/fieldType.js";
 import { ParameterType } from "./utils/types/parameters.type.js";
 import { SolverType } from "./utils/types/dynamic-simulation.type.js";
-import { DistributionType, SensitivityType } from "./utils/types/sensitivity-analysis.type.js";
+import { DistributionType, SensitivityType, enrichSensitivityAnalysisParameters, mapSensitivityAnalysisParameters } from "./utils/types/sensitivity-analysis.type.js";
 import { CalculationType, LoadModelsRule } from "./utils/types/dynamic-margin-calculation.type.js";
 import { OperationType } from "./utils/types/network-modification-types.js";
+import { enrichPccMinParameters, mapPccMinParameters } from "./utils/types/pcc-min.type.js";
 import { areIdsEqual, getIdOrSelf, getIdOrValue, getLabelOrValue, getObjectId, notNull, notUndefined, parseIntData, removeNullFields, richTypeEquals, sanitizeString } from "./utils/ts-utils.js";
 import { toNumber, validateValueIsANumber } from "./utils/validation-functions.js";
 import { NO_ITEM_SELECTION_FOR_COPY } from "./utils/directory-utils.js";
@@ -274,11 +275,12 @@ import "./utils/yupConfig.js";
 import "react";
 import { fetchAppsMetadata, fetchBaseVoltages, fetchDefaultCountry, fetchEnv, fetchFavoriteAndDefaultCountries, fetchStudyMetadata, isExploreMetadata, isStudyMetadata } from "./services/appsMetadata.js";
 import { fetchConfigParameter, fetchConfigParameters, getAppName, updateConfigParameter } from "./services/config.js";
-import { PermissionType, elementAlreadyExists, fetchDirectoryContent, fetchDirectoryElementPath, fetchRootFolders, hasElementPermission } from "./services/directory.js";
+import { PermissionType, elementAlreadyExists, fetchDirectoryContent, fetchDirectoryElementPath, fetchElementNames, fetchRootFolders, hasElementPermission } from "./services/directory.js";
 import { createFilter, createParameter, fetchElementsInfos, saveFilter, updateParameter } from "./services/explore.js";
 import { PREFIX_STUDY_QUERIES, fetchLoadFlowParameters, getLoadFlowDefaultLimitReductions, getLoadFlowProviders, getLoadFlowSpecificParametersDescription, getLoadFlowUrl, setLoadFlowParameters } from "./services/loadflow.js";
 import { fetchPccMinParameters, getPccMinStudyParameters, updatePccMinParameters } from "./services/pcc-min.js";
 import { fetchSecurityAnalysisParameters, fetchSecurityAnalysisProviders, getSecurityAnalysisDefaultLimitReductions, getSecurityAnalysisParameters, getStudyUrl, setSecurityAnalysisParameters, updateSecurityAnalysisParameters } from "./services/security-analysis.js";
+import { fetchSensitivityAnalysisParameters, fetchSensitivityAnalysisProviders, getSensiUrl, getSensitivityAnalysisFactorsCount, getSensitivityAnalysisParameters, getStudyUrlWithNodeUuidAndRootNetworkUuid, setSensitivityAnalysisParameters, updateSensitivityAnalysisParameters } from "./services/sensitivity-analysis.js";
 import { exportFilter, getAvailableComponentLibraries, getStudyNetworkVisualizationsParameters, getStudyShortCircuitParameters, setStudyNetworkVisualizationParameters, updateVoltageInitParameters } from "./services/study.js";
 import { getNetworkVisualizationsParameters } from "./services/study-config.js";
 import { fetchCurrentAnnouncement, fetchUserDetails } from "./services/userAdmin.js";
@@ -977,6 +979,8 @@ export {
   emptyFormData,
   emptyModificationByAssignmentFormData,
   emptyProperties,
+  enrichPccMinParameters,
+  enrichSensitivityAnalysisParameters,
   equalsArray,
   equipmentDeletionDtoToForm,
   equipmentDeletionEmptyFormData,
@@ -1021,6 +1025,7 @@ export {
   fetchDynamicSimulationModels,
   fetchDynamicSimulationParameters,
   fetchDynamicSimulationProviders,
+  fetchElementNames,
   fetchElementsInfos,
   fetchEnv,
   fetchFavoriteAndDefaultCountries,
@@ -1031,6 +1036,8 @@ export {
   fetchRootFolders,
   fetchSecurityAnalysisParameters,
   fetchSecurityAnalysisProviders,
+  fetchSensitivityAnalysisParameters,
+  fetchSensitivityAnalysisProviders,
   fetchShortCircuitParameters,
   fetchStudyMetadata,
   fetchSubModificationsForExpandedRows,
@@ -1130,6 +1137,9 @@ export {
   getRowEmptyFormData,
   getSecurityAnalysisDefaultLimitReductions,
   getSecurityAnalysisParameters,
+  getSensiUrl,
+  getSensitivityAnalysisFactorsCount,
+  getSensitivityAnalysisParameters,
   getSetPointsEmptyFormData,
   getSetPointsSchema,
   getShortCircuitEmptyFormData,
@@ -1140,6 +1150,7 @@ export {
   getStudyShortCircuitParameters,
   getStudyUrl,
   getStudyUrlWithNodeUuid,
+  getStudyUrlWithNodeUuidAndRootNetworkUuid,
   getSystemLanguage,
   getUserToken,
   getVoltageInitParameters,
@@ -1188,6 +1199,8 @@ export {
   loginFr,
   logout,
   makeComposeClasses,
+  mapPccMinParameters,
+  mapSensitivityAnalysisParameters,
   mergeModificationAndEquipmentProperties,
   mergeSubModificationsIntoTree,
   mergeSx,
@@ -1232,6 +1245,7 @@ export {
   setLogoutError,
   setSecurityAnalysisParameters,
   setSelectedReactiveLimits,
+  setSensitivityAnalysisParameters,
   setShowAuthenticationRouterLogin,
   setSignInCallbackError,
   setStudyNetworkVisualizationParameters,
@@ -1278,6 +1292,7 @@ export {
   updateParameter,
   updatePccMinParameters,
   updateSecurityAnalysisParameters,
+  updateSensitivityAnalysisParameters,
   updateShortCircuitParameters,
   updateSubModificationsOfACompositeInTree,
   updateVoltageInitParameters,

package/dist/services/directory.d.ts

@@ -1,5 +1,5 @@
 import { UUID } from 'node:crypto';
-import { ElementAttributes } from '../utils';
+import { ElementAttributes } from '../utils/types/types';
 export declare function fetchRootFolders(types: string[]): Promise<ElementAttributes[]>;
 export declare function fetchDirectoryContent(directoryUuid: UUID, types?: string[]): Promise<ElementAttributes[]>;
 export declare function fetchDirectoryElementPath(elementUuid: UUID): Promise<ElementAttributes[]>;
@@ -10,3 +10,4 @@ export declare enum PermissionType {
     MANAGE = "MANAGE"
 }
 export declare function hasElementPermission(elementUuid: UUID, permission: PermissionType): Promise<boolean>;
+export declare function fetchElementNames(elementUuids: Set<string>): Promise<any>;

package/dist/services/directory.js

@@ -52,11 +52,22 @@ function hasElementPermission(elementUuid, permission) {
     return false;
   });
 }
+function fetchElementNames(elementUuids) {
+  console.info("fetch directory element names");
+  const params = new URLSearchParams();
+  elementUuids.forEach((id) => {
+    params.append("ids", id);
+  });
+  const url = `${PREFIX_EXPLORE_SERVER_QUERIES}/v1/explore/elements/name?${params.toString()}`;
+  console.log(url);
+  return backendFetchJson(url);
+}
 export {
   PermissionType,
   elementAlreadyExists,
   fetchDirectoryContent,
   fetchDirectoryElementPath,
+  fetchElementNames,
   fetchRootFolders,
   hasElementPermission
 };

package/dist/services/index.d.ts

@@ -11,6 +11,7 @@ export * from './explore';
 export * from './loadflow';
 export * from './pcc-min';
 export * from './security-analysis';
+export * from './sensitivity-analysis';
 export * from './study';
 export * from './study-config';
 export * from './userAdmin';

package/dist/services/index.js

@@ -1,10 +1,11 @@
 import { fetchAppsMetadata, fetchBaseVoltages, fetchDefaultCountry, fetchEnv, fetchFavoriteAndDefaultCountries, fetchStudyMetadata, isExploreMetadata, isStudyMetadata } from "./appsMetadata.js";
 import { fetchConfigParameter, fetchConfigParameters, getAppName, updateConfigParameter } from "./config.js";
-import { PermissionType, elementAlreadyExists, fetchDirectoryContent, fetchDirectoryElementPath, fetchRootFolders, hasElementPermission } from "./directory.js";
+import { PermissionType, elementAlreadyExists, fetchDirectoryContent, fetchDirectoryElementPath, fetchElementNames, fetchRootFolders, hasElementPermission } from "./directory.js";
 import { createFilter, createParameter, fetchElementsInfos, saveFilter, updateParameter } from "./explore.js";
 import { PREFIX_STUDY_QUERIES, fetchLoadFlowParameters, getLoadFlowDefaultLimitReductions, getLoadFlowProviders, getLoadFlowSpecificParametersDescription, getLoadFlowUrl, setLoadFlowParameters } from "./loadflow.js";
 import { fetchPccMinParameters, getPccMinStudyParameters, updatePccMinParameters } from "./pcc-min.js";
 import { fetchSecurityAnalysisParameters, fetchSecurityAnalysisProviders, getSecurityAnalysisDefaultLimitReductions, getSecurityAnalysisParameters, getStudyUrl, setSecurityAnalysisParameters, updateSecurityAnalysisParameters } from "./security-analysis.js";
+import { fetchSensitivityAnalysisParameters, fetchSensitivityAnalysisProviders, getSensiUrl, getSensitivityAnalysisFactorsCount, getSensitivityAnalysisParameters, getStudyUrlWithNodeUuidAndRootNetworkUuid, setSensitivityAnalysisParameters, updateSensitivityAnalysisParameters } from "./sensitivity-analysis.js";
 import { exportFilter, getAvailableComponentLibraries, getStudyNetworkVisualizationsParameters, getStudyShortCircuitParameters, setStudyNetworkVisualizationParameters, updateVoltageInitParameters } from "./study.js";
 import { getNetworkVisualizationsParameters } from "./study-config.js";
 import { fetchCurrentAnnouncement, fetchUserDetails } from "./userAdmin.js";
@@ -47,6 +48,7 @@ export {
   fetchDynamicSimulationModels,
   fetchDynamicSimulationParameters,
   fetchDynamicSimulationProviders,
+  fetchElementNames,
   fetchElementsInfos,
   fetchEnv,
   fetchFavoriteAndDefaultCountries,
@@ -56,6 +58,8 @@ export {
   fetchRootFolders,
   fetchSecurityAnalysisParameters,
   fetchSecurityAnalysisProviders,
+  fetchSensitivityAnalysisParameters,
+  fetchSensitivityAnalysisProviders,
   fetchShortCircuitParameters,
   fetchStudyMetadata,
   fetchUserDetails,
@@ -73,11 +77,15 @@ export {
   getRequestParamFromList,
   getSecurityAnalysisDefaultLimitReductions,
   getSecurityAnalysisParameters,
+  getSensiUrl,
+  getSensitivityAnalysisFactorsCount,
+  getSensitivityAnalysisParameters,
   getShortCircuitSpecificParametersDescription,
   getStudyNetworkVisualizationsParameters,
   getStudyShortCircuitParameters,
   getStudyUrl,
   getStudyUrlWithNodeUuid,
+  getStudyUrlWithNodeUuidAndRootNetworkUuid,
   getVoltageInitParameters,
   getVoltageInitUrl,
   handleNotOkResponse,
@@ -89,6 +97,7 @@ export {
   saveFilter,
   setLoadFlowParameters,
   setSecurityAnalysisParameters,
+  setSensitivityAnalysisParameters,
   setStudyNetworkVisualizationParameters,
   updateConfigParameter,
   updateDynamicMarginCalculationParameters,
@@ -97,6 +106,7 @@ export {
   updateParameter,
   updatePccMinParameters,
   updateSecurityAnalysisParameters,
+  updateSensitivityAnalysisParameters,
   updateShortCircuitParameters,
   updateVoltageInitParameters
 };

package/dist/services/pcc-min.d.ts

@@ -1,8 +1,5 @@
 import { UUID } from 'node:crypto';
-import { FilterIdentifier, FILTERS } from '../utils/constants/filterConstant';
-export type PccMinParameters = {
-    [FILTERS]: FilterIdentifier[];
-};
-export declare function getPccMinStudyParameters(studyUuid: UUID): Promise<PccMinParameters | null>;
-export declare function fetchPccMinParameters(parameterUuid: UUID): Promise<PccMinParameters>;
-export declare function updatePccMinParameters(studyUuid: UUID | null, newParams: PccMinParameters | null): Promise<Response>;
+import { PccMinParametersEnriched } from '../utils';
+export declare function getPccMinStudyParameters(studyUuid: UUID): Promise<PccMinParametersEnriched | null>;
+export declare function fetchPccMinParameters(parameterUuid: UUID): Promise<PccMinParametersEnriched>;
+export declare function updatePccMinParameters(studyUuid: UUID | null, newParams: PccMinParametersEnriched | null): Promise<Response>;

package/dist/services/pcc-min.js

@@ -1,20 +1,23 @@
 import { backendFetchJson, backendFetch } from "./utils.js";
 import { getStudyUrl } from "./security-analysis.js";
+import { enrichPccMinParameters, mapPccMinParameters } from "../utils/types/pcc-min.type.js";
 const PREFIX_PCC_MIN_SERVER_QUERIES = `${"api/gateway"}/pcc-min`;
 function getPccMinUrl() {
   return `${PREFIX_PCC_MIN_SERVER_QUERIES}/v1/`;
 }
 function getPccMinStudyParameters(studyUuid) {
   console.info("get pcc min study parameters");
-  const getPccMintParams = `${getStudyUrl(studyUuid)}/pcc-min/parameters`;
-  console.debug(getPccMintParams);
-  return backendFetchJson(getPccMintParams);
+  const url = `${getStudyUrl(studyUuid)}/pcc-min/parameters`;
+  console.debug(url);
+  const parametersPromise = backendFetchJson(url);
+  return parametersPromise.then((parameters) => enrichPccMinParameters(parameters));
 }
 function fetchPccMinParameters(parameterUuid) {
   console.info("fetch pcc min parameters");
   const url = `${getPccMinUrl()}parameters/${encodeURIComponent(parameterUuid)}`;
   console.debug(url);
-  return backendFetchJson(url);
+  const parametersPromise = backendFetchJson(url);
+  return parametersPromise.then((parameters) => enrichPccMinParameters(parameters));
 }
 function updatePccMinParameters(studyUuid, newParams) {
   console.info("set study pcc min parameters");
@@ -26,7 +29,7 @@ function updatePccMinParameters(studyUuid, newParams) {
       Accept: "application/json",
       "Content-Type": "application/json"
     },
-    body: newParams == null ? null : JSON.stringify(newParams)
+    body: newParams == null ? null : JSON.stringify(mapPccMinParameters(newParams))
   });
 }
 export {

package/dist/services/security-analysis.d.ts

@@ -1,8 +1,9 @@
 import { UUID } from 'node:crypto';
+import { SAParametersEnriched } from '../components/parameters/security-analysis/types';
 export declare const getStudyUrl: (studyUuid: UUID | null) => string;
 export declare function fetchSecurityAnalysisProviders(): Promise<any>;
-export declare function fetchSecurityAnalysisParameters(parameterUuid: string): Promise<any>;
+export declare function fetchSecurityAnalysisParameters(parameterUuid: string): Promise<SAParametersEnriched>;
 export declare function getSecurityAnalysisDefaultLimitReductions(): Promise<any>;
-export declare function getSecurityAnalysisParameters(studyUuid: UUID): Promise<any>;
-export declare function setSecurityAnalysisParameters(studyUuid: UUID, newParams: any): Promise<Response>;
-export declare function updateSecurityAnalysisParameters(parameterUuid: UUID, newParams: any): Promise<Response>;
+export declare function getSecurityAnalysisParameters(studyUuid: UUID): Promise<SAParametersEnriched>;
+export declare function setSecurityAnalysisParameters(studyUuid: UUID, newParams: SAParametersEnriched | null): Promise<Response>;
+export declare function updateSecurityAnalysisParameters(parameterUuid: UUID, newParams: SAParametersEnriched | null): Promise<Response>;

package/dist/services/security-analysis.js

@@ -1,5 +1,6 @@
 import { safeEncodeURIComponent, backendFetchJson, backendFetch } from "./utils.js";
 import { PREFIX_STUDY_QUERIES } from "./loadflow.js";
+import { enrichSecurityAnalysisParameters, mapSecurityAnalysisParameters } from "../components/parameters/security-analysis/types.js";
 const PREFIX_SECURITY_ANALYSIS_SERVER_QUERIES = `${"api/gateway"}/security-analysis`;
 const getStudyUrl = (studyUuid) => `${PREFIX_STUDY_QUERIES}/v1/studies/${safeEncodeURIComponent(studyUuid)}`;
 function getSecurityAnalysisUrl() {
@@ -15,7 +16,8 @@ function fetchSecurityAnalysisParameters(parameterUuid) {
   console.info("fetch security analysis parameters");
   const url = `${getSecurityAnalysisUrl()}parameters/${encodeURIComponent(parameterUuid)}`;
   console.debug(url);
-  return backendFetchJson(url);
+  const parametersPromise = backendFetchJson(url);
+  return parametersPromise.then((parameters) => enrichSecurityAnalysisParameters(parameters));
 }
 function getSecurityAnalysisDefaultLimitReductions() {
   console.info("get security analysis default limit reductions");
@@ -27,7 +29,8 @@ function getSecurityAnalysisParameters(studyUuid) {
   console.info("get security analysis parameters");
   const url = `${getStudyUrl(studyUuid)}/security-analysis/parameters`;
   console.debug(url);
-  return backendFetchJson(url);
+  const parametersPromise = backendFetchJson(url);
+  return parametersPromise.then((parameters) => enrichSecurityAnalysisParameters(parameters));
 }
 function setSecurityAnalysisParameters(studyUuid, newParams) {
   console.info("set security analysis parameters");
@@ -39,7 +42,7 @@ function setSecurityAnalysisParameters(studyUuid, newParams) {
       Accept: "application/json",
       "Content-Type": "application/json"
     },
-    body: newParams ? JSON.stringify(newParams) : null
+    body: newParams ? JSON.stringify(mapSecurityAnalysisParameters(newParams)) : null
   });
 }
 function updateSecurityAnalysisParameters(parameterUuid, newParams) {
@@ -52,7 +55,7 @@ function updateSecurityAnalysisParameters(parameterUuid, newParams) {
       Accept: "application/json",
       "Content-Type": "application/json"
     },
-    body: newParams ? JSON.stringify(newParams) : null
+    body: newParams ? JSON.stringify(mapSecurityAnalysisParameters(newParams)) : null
   });
 }
 export {

package/dist/services/sensitivity-analysis.d.ts

@@ -1,11 +1,10 @@
 import { UUID } from 'node:crypto';
-import { FactorsCount, SensitivityAnalysisParametersInfos } from '../utils';
-export declare const getStudyUrl: (studyUuid: UUID | null) => string;
+import { FactorsCount, SensitivityAnalysisParametersInfosEnriched } from '../utils';
 export declare const getStudyUrlWithNodeUuidAndRootNetworkUuid: (studyUuid: string | null | undefined, nodeUuid: string | undefined, rootNetworkUuid: string | undefined | null) => string;
 export declare function getSensiUrl(): string;
 export declare function fetchSensitivityAnalysisProviders(): Promise<string[]>;
-export declare function getSensitivityAnalysisParameters(studyUuid: UUID): Promise<any>;
-export declare function fetchSensitivityAnalysisParameters(parameterUuid: string): Promise<any>;
-export declare function setSensitivityAnalysisParameters(studyUuid: UUID | null, newParams: SensitivityAnalysisParametersInfos | null): Promise<Response>;
-export declare function getSensitivityAnalysisFactorsCount(studyUuid: UUID | null, currentNodeUuid: UUID, currentRootNetworkUuid: UUID, newParams: SensitivityAnalysisParametersInfos, abortSignal: AbortSignal): Promise<FactorsCount>;
+export declare function getSensitivityAnalysisParameters(studyUuid: UUID): Promise<SensitivityAnalysisParametersInfosEnriched>;
+export declare function fetchSensitivityAnalysisParameters(parameterUuid: string): Promise<SensitivityAnalysisParametersInfosEnriched>;
+export declare function setSensitivityAnalysisParameters(studyUuid: UUID | null, newParams: SensitivityAnalysisParametersInfosEnriched | null): Promise<Response>;
+export declare function getSensitivityAnalysisFactorsCount(studyUuid: UUID | null, currentNodeUuid: UUID, currentRootNetworkUuid: UUID, newParams: SensitivityAnalysisParametersInfosEnriched, abortSignal: AbortSignal): Promise<FactorsCount>;
 export declare function updateSensitivityAnalysisParameters(parameterUuid: UUID, newParams: any): Promise<Response>;

package/dist/services/sensitivity-analysis.js

@@ -1,4 +1,10 @@
 import { safeEncodeURIComponent, backendFetchJson, backendFetch } from "./utils.js";
+import "../utils/conversionUtils.js";
+import "../utils/types/equipmentType.js";
+import { enrichSensitivityAnalysisParameters, mapSensitivityAnalysisParameters } from "../utils/types/sensitivity-analysis.type.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import "../utils/yupConfig.js";
 import { PREFIX_STUDY_QUERIES } from "./loadflow.js";
 const GET_PARAMETERS_PREFIX = `${"api/gateway"}/sensitivity-analysis/v1/parameters`;
 const PREFIX_SENSITIVITY_ANALYSIS_SERVER_QUERIES = `${"api/gateway"}/sensitivity-analysis`;
@@ -19,13 +25,15 @@ function getSensitivityAnalysisParameters(studyUuid) {
   console.info("get sensitivity analysis parameters");
   const url = `${getStudyUrl(studyUuid)}/sensitivity-analysis/parameters`;
   console.debug(url);
-  return backendFetchJson(url);
+  const parametersPromise = backendFetchJson(url);
+  return parametersPromise.then((parameters) => enrichSensitivityAnalysisParameters(parameters));
 }
 function fetchSensitivityAnalysisParameters(parameterUuid) {
   console.info("get sensitivity analysis parameters");
   const url = `${GET_PARAMETERS_PREFIX}/${parameterUuid}`;
   console.debug(url);
-  return backendFetchJson(url);
+  const parametersPromise = backendFetchJson(url);
+  return parametersPromise.then((parameters) => enrichSensitivityAnalysisParameters(parameters));
 }
 function setSensitivityAnalysisParameters(studyUuid, newParams) {
   console.info("set sensitivity analysis parameters");
@@ -37,7 +45,7 @@ function setSensitivityAnalysisParameters(studyUuid, newParams) {
       Accept: "application/json",
       "Content-Type": "application/json"
     },
-    body: newParams ? JSON.stringify(newParams) : null
+    body: newParams ? JSON.stringify(mapSensitivityAnalysisParameters(newParams)) : null
   });
 }
 function getSensitivityAnalysisFactorsCount(studyUuid, currentNodeUuid, currentRootNetworkUuid, newParams, abortSignal) {
@@ -49,7 +57,7 @@ function getSensitivityAnalysisFactorsCount(studyUuid, currentNodeUuid, currentR
     headers: {
       "Content-Type": "application/json"
     },
-    body: JSON.stringify(newParams),
+    body: JSON.stringify(mapSensitivityAnalysisParameters(newParams)),
     signal: abortSignal
   });
 }
@@ -63,7 +71,7 @@ function updateSensitivityAnalysisParameters(parameterUuid, newParams) {
       Accept: "application/json",
       "Content-Type": "application/json"
     },
-    body: newParams ? JSON.stringify(newParams) : null
+    body: newParams ? JSON.stringify(mapSensitivityAnalysisParameters(newParams)) : null
   });
 }
 export {
@@ -72,7 +80,6 @@ export {
   getSensiUrl,
   getSensitivityAnalysisFactorsCount,
   getSensitivityAnalysisParameters,
-  getStudyUrl,
   getStudyUrlWithNodeUuidAndRootNetworkUuid,
   setSensitivityAnalysisParameters,
   updateSensitivityAnalysisParameters

package/dist/utils/index.js

@@ -28,9 +28,10 @@ import { MODIFICATION_TYPES, ModificationType } from "./types/modificationType.j
 import { FieldType } from "./types/fieldType.js";
 import { ParameterType } from "./types/parameters.type.js";
 import { SolverType } from "./types/dynamic-simulation.type.js";
-import { DistributionType, SensitivityType } from "./types/sensitivity-analysis.type.js";
+import { DistributionType, SensitivityType, enrichSensitivityAnalysisParameters, mapSensitivityAnalysisParameters } from "./types/sensitivity-analysis.type.js";
 import { CalculationType, LoadModelsRule } from "./types/dynamic-margin-calculation.type.js";
 import { OperationType } from "./types/network-modification-types.js";
+import { enrichPccMinParameters, mapPccMinParameters } from "./types/pcc-min.type.js";
 import { areIdsEqual, getIdOrSelf, getIdOrValue, getLabelOrValue, getObjectId, notNull, notUndefined, parseIntData, removeNullFields, richTypeEquals, sanitizeString } from "./ts-utils.js";
 import { toNumber, validateValueIsANumber } from "./validation-functions.js";
 import { NO_ITEM_SELECTION_FOR_COPY } from "./directory-utils.js";
@@ -144,6 +145,8 @@ export {
   convertInputValue,
   convertOutputValue,
   copyToClipboard,
+  enrichPccMinParameters,
+  enrichSensitivityAnalysisParameters,
   equalsArray,
   equipmentStyles,
   equipmentTypesForPredefinedPropertiesMapper,
@@ -163,6 +166,8 @@ export {
   keyGenerator,
   kiloUnitToUnit,
   makeComposeClasses,
+  mapPccMinParameters,
+  mapSensitivityAnalysisParameters,
   mergeSx,
   microUnitToUnit,
   notNull,

package/dist/utils/types/index.d.ts

@@ -21,4 +21,5 @@ export * from './loadflow.type';
 export * from './sensitivity-analysis.type';
 export * from './dynamic-margin-calculation.type';
 export * from './network-modification-types';
+export * from './pcc-min.type';
 export * from './network-modification-metadata';

package/dist/utils/types/index.js

@@ -9,9 +9,10 @@ import { MODIFICATION_TYPES, ModificationType } from "./modificationType.js";
 import { FieldType } from "./fieldType.js";
 import { ParameterType } from "./parameters.type.js";
 import { SolverType } from "./dynamic-simulation.type.js";
-import { DistributionType, SensitivityType } from "./sensitivity-analysis.type.js";
+import { DistributionType, SensitivityType, enrichSensitivityAnalysisParameters, mapSensitivityAnalysisParameters } from "./sensitivity-analysis.type.js";
 import { CalculationType, LoadModelsRule } from "./dynamic-margin-calculation.type.js";
 import { OperationType } from "./network-modification-types.js";
+import { enrichPccMinParameters, mapPccMinParameters } from "./pcc-min.type.js";
 export {
   ALL_EQUIPMENTS,
   AnnouncementSeverity,
@@ -62,8 +63,12 @@ export {
   VL_TAG_MAX_SIZE,
   VSC,
   VoltageLevel,
+  enrichPccMinParameters,
+  enrichSensitivityAnalysisParameters,
   equipmentStyles,
   getConnectionDirectionLabel,
   getEquipmentsInfosForSearchBar,
-  getLoadTypeLabel
+  getLoadTypeLabel,
+  mapPccMinParameters,
+  mapSensitivityAnalysisParameters
 };

package/dist/utils/types/parameters.type.d.ts

@@ -4,9 +4,9 @@ import { LoadFlowParametersInfos } from './loadflow.type';
 import { DynamicSecurityAnalysisParametersFetchReturn } from './dynamic-security-analysis.type';
 import { ILimitReductionsByVoltageLevel } from '../../components/parameters/common/limitreductions/columns-definitions';
 import { DynamicSimulationParametersInfos } from './dynamic-simulation.type';
-import { SensitivityAnalysisParametersInfos } from './sensitivity-analysis.type';
+import { SensitivityAnalysisParametersInfosEnriched } from './sensitivity-analysis.type';
 import { ShortCircuitParametersInfos } from '../../components/parameters/short-circuit/short-circuit-parameters.type';
-import { SAParameters } from '../../components/parameters/security-analysis/types';
+import { SAParametersEnriched } from '../../components/parameters/security-analysis/types';
 import { DynamicMarginCalculationParametersInfos } from './dynamic-margin-calculation.type';
 export declare enum ParameterType {
     BOOLEAN = "BOOLEAN",
@@ -29,7 +29,7 @@ export type SpecificParameterInfos = {
 export type SpecificParametersDescription = Record<string, SpecificParameterInfos[]>;
 export type SpecificParametersValues = Record<string, any>;
 export type SpecificParametersPerProvider = Record<string, SpecificParametersValues>;
-export type ParametersInfos<T extends ComputingType> = T extends ComputingType.SENSITIVITY_ANALYSIS ? SensitivityAnalysisParametersInfos : T extends ComputingType.SECURITY_ANALYSIS ? SAParameters : T extends ComputingType.LOAD_FLOW ? LoadFlowParametersInfos : T extends ComputingType.DYNAMIC_SIMULATION ? DynamicSimulationParametersInfos : T extends ComputingType.DYNAMIC_SECURITY_ANALYSIS ? DynamicSecurityAnalysisParametersFetchReturn : T extends ComputingType.DYNAMIC_MARGIN_CALCULATION ? DynamicMarginCalculationParametersInfos : T extends ComputingType.SHORT_CIRCUIT ? ShortCircuitParametersInfos : Record<string, any>;
+export type ParametersInfos<T extends ComputingType> = T extends ComputingType.SENSITIVITY_ANALYSIS ? SensitivityAnalysisParametersInfosEnriched : T extends ComputingType.SECURITY_ANALYSIS ? SAParametersEnriched : T extends ComputingType.LOAD_FLOW ? LoadFlowParametersInfos : T extends ComputingType.DYNAMIC_SIMULATION ? DynamicSimulationParametersInfos : T extends ComputingType.DYNAMIC_SECURITY_ANALYSIS ? DynamicSecurityAnalysisParametersFetchReturn : T extends ComputingType.DYNAMIC_MARGIN_CALCULATION ? DynamicMarginCalculationParametersInfos : T extends ComputingType.SHORT_CIRCUIT ? ShortCircuitParametersInfos : Record<string, any>;
 export type BackendFunctions<T extends ComputingType> = {
     backendFetchProviders?: (() => Promise<string[]>) | null;
     backendFetchParameters: (paramsUuidOrStudyUuid: UUID) => Promise<ParametersInfos<T>>;

package/dist/utils/types/pcc-min.type.d.ts

@@ -0,0 +1,10 @@
+import { UUID } from 'node:crypto';
+import { FilterIdentifier, FILTERS } from '../constants';
+export type PccMinParametersEnriched = {
+    [FILTERS]: FilterIdentifier[];
+};
+export type PccMinParameters = {
+    [FILTERS]: UUID[];
+};
+export declare function mapPccMinParameters(parametersInfos: PccMinParametersEnriched): PccMinParameters;
+export declare function enrichPccMinParameters(parameters: PccMinParameters): Promise<PccMinParametersEnriched>;

package/dist/utils/types/pcc-min.type.js

@@ -0,0 +1,31 @@
+import { fetchElementNames } from "../../services/directory.js";
+import { FILTERS } from "../constants/filterConstant.js";
+function mapPccMinParameters(parametersInfos) {
+  return {
+    ...parametersInfos,
+    [FILTERS]: parametersInfos.filters?.map((filter) => filter.filterId)
+  };
+}
+function getFilterIdentifierIds(params) {
+  return new Set(params[FILTERS]);
+}
+function enrichPccMinParameters(parameters) {
+  const allElementIds = getFilterIdentifierIds(parameters);
+  const elementNamesPromise = allElementIds.size === 0 ? Promise.resolve(null) : fetchElementNames(allElementIds);
+  return elementNamesPromise.then((elementNames) => {
+    const mapIdsToFilterIdentifiers = (ids) => {
+      return ids ? ids.map((id) => ({
+        filterId: id,
+        filterName: elementNames?.[id] ?? null
+      })) : [];
+    };
+    return {
+      ...parameters,
+      [FILTERS]: mapIdsToFilterIdentifiers(parameters[FILTERS])
+    };
+  });
+}
+export {
+  enrichPccMinParameters,
+  mapPccMinParameters
+};

package/dist/utils/types/sensitivity-analysis.type.d.ts

@@ -13,34 +13,35 @@ interface EquipmentsContainer {
     containerId: string;
     containerName: string;
 }
-interface SensitivityParamsCommon {
-    contingencies?: EquipmentsContainer[];
+type EquipmentsInfos = EquipmentsContainer | UUID;
+interface SensitivityParamsCommon<T extends EquipmentsInfos> {
+    contingencies?: T[];
     activated?: boolean | null;
 }
-export interface SensitivityInjectionsSet extends SensitivityParamsCommon {
-    monitoredBranches?: EquipmentsContainer[];
-    injections?: EquipmentsContainer[];
+export interface SensitivityInjectionsSet<T extends EquipmentsInfos> extends SensitivityParamsCommon<T> {
+    monitoredBranches?: T[];
+    injections?: T[];
     distributionType?: DistributionType;
 }
-export interface SensitivityInjection extends SensitivityParamsCommon {
-    monitoredBranches?: EquipmentsContainer[];
-    injections?: EquipmentsContainer[];
+export interface SensitivityInjection<T extends EquipmentsInfos> extends SensitivityParamsCommon<T> {
+    monitoredBranches?: T[];
+    injections?: T[];
 }
-export interface SensitivityHVDC extends SensitivityParamsCommon {
-    monitoredBranches?: EquipmentsContainer[];
+export interface SensitivityHVDC<T extends EquipmentsInfos> extends SensitivityParamsCommon<T> {
+    monitoredBranches?: T[];
     sensitivityType?: SensitivityType;
-    hvdcs?: EquipmentsContainer[];
+    hvdcs?: T[];
 }
-export interface SensitivityPST extends SensitivityParamsCommon {
-    monitoredBranches?: EquipmentsContainer[];
+export interface SensitivityPST<T extends EquipmentsInfos> extends SensitivityParamsCommon<T> {
+    monitoredBranches?: T[];
     sensitivityType?: SensitivityType;
-    psts?: EquipmentsContainer[];
+    psts?: T[];
 }
-export interface SensitivityNodes extends SensitivityParamsCommon {
-    monitoredVoltageLevels?: EquipmentsContainer[];
-    equipmentsInVoltageRegulation?: EquipmentsContainer[];
+export interface SensitivityNodes<T extends EquipmentsInfos> extends SensitivityParamsCommon<T> {
+    monitoredVoltageLevels?: T[];
+    equipmentsInVoltageRegulation?: T[];
 }
-export interface SensitivityAnalysisParametersInfos {
+export interface SensitivityAnalysisParameters<T extends EquipmentsInfos> {
     provider: string;
     uuid?: UUID;
     date?: Date;
@@ -48,12 +49,14 @@ export interface SensitivityAnalysisParametersInfos {
     flowFlowSensitivityValueThreshold: number;
     angleFlowSensitivityValueThreshold: number;
     flowVoltageSensitivityValueThreshold: number;
-    sensitivityInjectionsSet?: SensitivityInjectionsSet[];
-    sensitivityInjection?: SensitivityInjection[];
-    sensitivityHVDC?: SensitivityHVDC[];
-    sensitivityPST?: SensitivityPST[];
-    sensitivityNodes?: SensitivityNodes[];
+    sensitivityInjectionsSet?: SensitivityInjectionsSet<T>[];
+    sensitivityInjection?: SensitivityInjection<T>[];
+    sensitivityHVDC?: SensitivityHVDC<T>[];
+    sensitivityPST?: SensitivityPST<T>[];
+    sensitivityNodes?: SensitivityNodes<T>[];
 }
+export type SensitivityAnalysisParametersInfosEnriched = SensitivityAnalysisParameters<EquipmentsContainer>;
+export type SensitivityAnalysisParametersInfos = SensitivityAnalysisParameters<UUID>;
 export interface FactorsCount {
     resultCount: number | null;
     variableCount: number | null;
@@ -95,4 +98,6 @@ export type SensitivityResultFilterOptions = {
     allFunctionIds?: string[];
     allVariableIds?: string[];
 };
+export declare function mapSensitivityAnalysisParameters(parameters: SensitivityAnalysisParametersInfosEnriched): SensitivityAnalysisParametersInfos;
+export declare function enrichSensitivityAnalysisParameters(parameters: SensitivityAnalysisParametersInfos): Promise<SensitivityAnalysisParametersInfosEnriched>;
 export {};