@gridsuite/commons-ui 0.223.0 → 0.224.0

package/dist/features/parameters/sensi/utils.js

@@ -1,5 +1,5 @@
 import * as yup from "yup";
-import { FLOW_VOLTAGE_SENSITIVITY_VALUE_THRESHOLD, ANGLE_FLOW_SENSITIVITY_VALUE_THRESHOLD, FLOW_FLOW_SENSITIVITY_VALUE_THRESHOLD, PARAMETER_SENSI_NODES, EQUIPMENTS_IN_VOLTAGE_REGULATION, SUPERVISED_VOLTAGE_LEVELS, PARAMETER_SENSI_PST, PSTS, PARAMETER_SENSI_HVDC, HVDC_LINES, PARAMETER_SENSI_INJECTION, INJECTIONS, PARAMETER_SENSI_INJECTIONS_SET, DISTRIBUTION_TYPE, SENSITIVITY_TYPE, MONITORED_BRANCHES, CONTAINER_NAME, CONTAINER_ID } from "./constants.js";
+import { FLOW_VOLTAGE_SENSITIVITY_VALUE_THRESHOLD, ANGLE_FLOW_SENSITIVITY_VALUE_THRESHOLD, FLOW_FLOW_SENSITIVITY_VALUE_THRESHOLD, PARAMETER_SENSI_NODES, EQUIPMENTS_IN_VOLTAGE_REGULATION, SUPERVISED_VOLTAGE_LEVELS, PARAMETER_SENSI_PST, PSTS, PARAMETER_SENSI_HVDC, HVDC_LINES, PARAMETER_SENSI_INJECTION, INJECTIONS, PARAMETER_SENSI_INJECTIONS_SET, DISTRIBUTION_TYPE, SENSITIVITY_TYPE, MONITORED_BRANCHES } from "./constants.js";
 import { ID } from "../../../utils/constants/filterConstant.js";
 import { YUP_REQUIRED } from "../../../utils/constants/translationKeys.js";
 import "../../../utils/conversionUtils.js";
@@ -96,23 +96,23 @@ const getSensiHvdcformatNewParams = (newParams) => {
   return {
     [PARAMETER_SENSI_HVDC]: newParams.sensitivityHVDC?.map((sensitivityHVDCs) => {
       return {
-        [MONITORED_BRANCHES]: sensitivityHVDCs[MONITORED_BRANCHES].map((container) => {
+        [MONITORED_BRANCHES]: sensitivityHVDCs[MONITORED_BRANCHES].map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
-        [HVDC_LINES]: sensitivityHVDCs[HVDC_LINES].map((container) => {
+        [HVDC_LINES]: sensitivityHVDCs[HVDC_LINES].map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
         [SENSITIVITY_TYPE]: sensitivityHVDCs[SENSITIVITY_TYPE],
-        [CONTINGENCIES]: sensitivityHVDCs[CONTINGENCIES]?.map((container) => {
+        [CONTINGENCIES]: sensitivityHVDCs[CONTINGENCIES]?.map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
         [ACTIVATED]: sensitivityHVDCs[ACTIVATED]
@@ -141,22 +141,22 @@ const getSensiInjectionsformatNewParams = (newParams) => {
   return {
     [PARAMETER_SENSI_INJECTION]: newParams.sensitivityInjection?.map((sensitivityInjections) => {
       return {
-        [MONITORED_BRANCHES]: sensitivityInjections[MONITORED_BRANCHES].map((container) => {
+        [MONITORED_BRANCHES]: sensitivityInjections[MONITORED_BRANCHES].map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
-        [INJECTIONS]: sensitivityInjections[INJECTIONS].map((container) => {
+        [INJECTIONS]: sensitivityInjections[INJECTIONS].map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
-        [CONTINGENCIES]: sensitivityInjections[CONTINGENCIES]?.map((container) => {
+        [CONTINGENCIES]: sensitivityInjections[CONTINGENCIES]?.map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
         [ACTIVATED]: sensitivityInjections[ACTIVATED]
@@ -185,36 +185,27 @@ const getSensiInjectionsSetFormSchema = () => ({
     })
   )
 });
-const getGenericRowNewParams = (newRowParams) => {
-  return {
-    [MONITORED_BRANCHES]: newRowParams[MONITORED_BRANCHES].map((container) => container[ID]),
-    [INJECTIONS]: newRowParams[INJECTIONS]?.map((container) => container[ID]),
-    [HVDC_LINES]: newRowParams[HVDC_LINES]?.map((container) => container[ID]),
-    [PSTS]: newRowParams[PSTS]?.map((container) => container[ID]),
-    [CONTINGENCIES]: newRowParams[CONTINGENCIES]?.map((container) => container[ID])
-  };
-};
 const getSensiInjectionsSetformatNewParams = (newParams) => {
   return {
     [PARAMETER_SENSI_INJECTIONS_SET]: newParams.sensitivityInjectionsSet?.map((sensitivityInjectionSet) => {
       return {
-        [MONITORED_BRANCHES]: sensitivityInjectionSet[MONITORED_BRANCHES].map((container) => {
+        [MONITORED_BRANCHES]: sensitivityInjectionSet[MONITORED_BRANCHES].map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
-        [INJECTIONS]: sensitivityInjectionSet[INJECTIONS].map((container) => {
+        [INJECTIONS]: sensitivityInjectionSet[INJECTIONS].map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
         [DISTRIBUTION_TYPE]: sensitivityInjectionSet[DISTRIBUTION_TYPE],
-        [CONTINGENCIES]: sensitivityInjectionSet[CONTINGENCIES]?.map((container) => {
+        [CONTINGENCIES]: sensitivityInjectionSet[CONTINGENCIES]?.map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
         [ACTIVATED]: sensitivityInjectionSet[ACTIVATED]
@@ -251,24 +242,22 @@ const getSensiNodesformatNewParams = (newParams) => {
   return {
     [PARAMETER_SENSI_NODES]: newParams.sensitivityNodes?.map((sensitivityNode) => {
       return {
-        [SUPERVISED_VOLTAGE_LEVELS]: sensitivityNode[SUPERVISED_VOLTAGE_LEVELS]?.map((container) => {
+        [SUPERVISED_VOLTAGE_LEVELS]: sensitivityNode[SUPERVISED_VOLTAGE_LEVELS]?.map((elem) => {
+          return {
+            id: elem[ID],
+            name: elem[NAME]
+          };
+        }),
+        [EQUIPMENTS_IN_VOLTAGE_REGULATION]: sensitivityNode[EQUIPMENTS_IN_VOLTAGE_REGULATION]?.map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
-        [EQUIPMENTS_IN_VOLTAGE_REGULATION]: sensitivityNode[EQUIPMENTS_IN_VOLTAGE_REGULATION]?.map(
-          (container) => {
-            return {
-              [CONTAINER_ID]: container[ID],
-              [CONTAINER_NAME]: container[NAME]
-            };
-          }
-        ),
-        [CONTINGENCIES]: sensitivityNode[CONTINGENCIES]?.map((container) => {
+        [CONTINGENCIES]: sensitivityNode[CONTINGENCIES]?.map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
         [ACTIVATED]: sensitivityNode[ACTIVATED]
@@ -298,23 +287,23 @@ const getSensiPstformatNewParams = (newParams) => {
   return {
     [PARAMETER_SENSI_PST]: newParams.sensitivityPST?.map((sensitivityPSTs) => {
       return {
-        [MONITORED_BRANCHES]: sensitivityPSTs[MONITORED_BRANCHES].map((container) => {
+        [MONITORED_BRANCHES]: sensitivityPSTs[MONITORED_BRANCHES].map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
-        [PSTS]: sensitivityPSTs[PSTS].map((container) => {
+        [PSTS]: sensitivityPSTs[PSTS].map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
         [SENSITIVITY_TYPE]: sensitivityPSTs[SENSITIVITY_TYPE],
-        [CONTINGENCIES]: sensitivityPSTs[CONTINGENCIES]?.map((container) => {
+        [CONTINGENCIES]: sensitivityPSTs[CONTINGENCIES]?.map((elem) => {
           return {
-            [CONTAINER_ID]: container[ID],
-            [CONTAINER_NAME]: container[NAME]
+            id: elem[ID],
+            name: elem[NAME]
           };
         }),
         [ACTIVATED]: sensitivityPSTs[ACTIVATED]
@@ -353,7 +342,6 @@ export {
   filterSensiParameterRows,
   formSchema,
   getFormSchema,
-  getGenericRowNewParams,
   getSensiHVDCsFormSchema,
   getSensiHvdcformatNewParams,
   getSensiInjectionsFormSchema,

package/dist/hooks/use-unique-name-validation.js

@@ -3,10 +3,10 @@ import { useFormContext, useController } from "react-hook-form";
 import { FieldConstants } from "../utils/constants/fieldConstants.js";
 import "../utils/conversionUtils.js";
 import "../utils/types/equipmentType.js";
-import { elementAlreadyExists } from "../services/directory.js";
 import "react/jsx-runtime";
 import "@mui/icons-material";
 import { useDebounce } from "./useDebounce.js";
+import { elementAlreadyExists } from "../services/directory.js";
 function useUniqueNameValidation({
   name,
   currentName = "",

package/dist/index.js

@@ -267,10 +267,11 @@ 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, enrichSensitivityAnalysisParameters, mapSensitivityAnalysisParameters } from "./utils/types/sensitivity-analysis.type.js";
+import { mapSecurityAnalysisParameters } from "./utils/types/security-analysis.type.js";
+import { DistributionType, SensitivityType, 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 { 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";
@@ -279,9 +280,9 @@ import { fetchConfigParameter, fetchConfigParameters, getAppName, updateConfigPa
 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 { enrichPccMinParameters, fetchPccMinParameters, getPccMinStudyParameters, updatePccMinParameters } from "./services/pcc-min.js";
+import { enrichSecurityAnalysisParameters, fetchSecurityAnalysisParameters, fetchSecurityAnalysisProviders, getSecurityAnalysisDefaultLimitReductions, getSecurityAnalysisParameters, getStudyUrl, setSecurityAnalysisParameters, updateSecurityAnalysisParameters } from "./services/security-analysis.js";
+import { enrichSensitivityAnalysisParameters, 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";
@@ -1049,6 +1050,7 @@ export {
   emptyModificationByAssignmentFormData,
   emptyProperties,
   enrichPccMinParameters,
+  enrichSecurityAnalysisParameters,
   enrichSensitivityAnalysisParameters,
   equalsArray,
   equipmentDeletionDtoToForm,
@@ -1290,6 +1292,7 @@ export {
   logout,
   makeComposeClasses,
   mapPccMinParameters,
+  mapSecurityAnalysisParameters,
   mapSensitivityAnalysisParameters,
   mergeModificationAndEquipmentProperties,
   mergeSubModificationsIntoTree,

package/dist/services/directory.d.ts

@@ -10,4 +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>;
+export declare function fetchElementNames(elementUuids: Set<string>): Promise<Record<string, string>>;

package/dist/services/index.js

@@ -3,9 +3,9 @@ import { fetchConfigParameter, fetchConfigParameters, getAppName, updateConfigPa
 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 { enrichPccMinParameters, fetchPccMinParameters, getPccMinStudyParameters, updatePccMinParameters } from "./pcc-min.js";
+import { enrichSecurityAnalysisParameters, fetchSecurityAnalysisParameters, fetchSecurityAnalysisProviders, getSecurityAnalysisDefaultLimitReductions, getSecurityAnalysisParameters, getStudyUrl, setSecurityAnalysisParameters, updateSecurityAnalysisParameters } from "./security-analysis.js";
+import { enrichSensitivityAnalysisParameters, 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";
@@ -31,6 +31,9 @@ export {
   createFilter,
   createParameter,
   elementAlreadyExists,
+  enrichPccMinParameters,
+  enrichSecurityAnalysisParameters,
+  enrichSensitivityAnalysisParameters,
   exportFilter,
   fetchAppsMetadata,
   fetchBaseVoltages,

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

@@ -1,5 +1,6 @@
 import { UUID } from 'node:crypto';
-import { PccMinParametersEnriched } from '../utils';
+import { PccMinParameters, PccMinParametersEnriched } from '../utils';
+export declare function enrichPccMinParameters(parameters: PccMinParameters): Promise<PccMinParametersEnriched>;
 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,10 +1,35 @@
 import { backendFetchJson, backendFetch } from "./utils.js";
 import { getStudyUrl } from "./security-analysis.js";
-import { enrichPccMinParameters, mapPccMinParameters } from "../utils/types/pcc-min.type.js";
+import { FILTERS } from "../utils/constants/filterConstant.js";
+import "../utils/conversionUtils.js";
+import "../utils/types/equipmentType.js";
+import { mapPccMinParameters } from "../utils/types/pcc-min.type.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import { fetchElementNames } from "./directory.js";
 const PREFIX_PCC_MIN_SERVER_QUERIES = `${"api/gateway"}/pcc-min`;
 function getPccMinUrl() {
   return `${PREFIX_PCC_MIN_SERVER_QUERIES}/v1/`;
 }
+function collectAllElementIds(params) {
+  return new Set(params[FILTERS]);
+}
+function enrichPccMinParameters(parameters) {
+  const allElementIds = collectAllElementIds(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] ?? void 0
+      })) : [];
+    };
+    return {
+      ...parameters,
+      [FILTERS]: mapIdsToFilterIdentifiers(parameters[FILTERS])
+    };
+  });
+}
 function getPccMinStudyParameters(studyUuid) {
   console.info("get pcc min study parameters");
   const url = `${getStudyUrl(studyUuid)}/pcc-min/parameters`;
@@ -33,6 +58,7 @@ function updatePccMinParameters(studyUuid, newParams) {
   });
 }
 export {
+  enrichPccMinParameters,
   fetchPccMinParameters,
   getPccMinStudyParameters,
   updatePccMinParameters

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

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

package/dist/services/security-analysis.js

@@ -1,6 +1,12 @@
 import { safeEncodeURIComponent, backendFetchJson, backendFetch } from "./utils.js";
 import { PREFIX_STUDY_QUERIES } from "./loadflow.js";
-import { enrichSecurityAnalysisParameters, mapSecurityAnalysisParameters } from "../features/parameters/security-analysis/types.js";
+import "../utils/conversionUtils.js";
+import "../utils/types/equipmentType.js";
+import { mapSecurityAnalysisParameters } from "../utils/types/security-analysis.type.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import { fetchElementNames } from "./directory.js";
+import { NAME, ID } from "../features/parameters/common/parameter-table/constants.js";
 const PREFIX_SECURITY_ANALYSIS_SERVER_QUERIES = `${"api/gateway"}/security-analysis`;
 const getStudyUrl = (studyUuid) => `${PREFIX_STUDY_QUERIES}/v1/studies/${safeEncodeURIComponent(studyUuid)}`;
 function getSecurityAnalysisUrl() {
@@ -12,6 +18,31 @@ function fetchSecurityAnalysisProviders() {
   console.debug(url);
   return backendFetchJson(url);
 }
+function collectElementIds(params) {
+  const allElementIds = params.contingencyListsInfos ? params.contingencyListsInfos.flatMap((cli) => cli.contingencyLists ?? []) : [];
+  return new Set(allElementIds);
+}
+function enrichSecurityAnalysisParameters(parameters) {
+  const allElementIds = collectElementIds(parameters);
+  const elementNamesPromise = allElementIds.size === 0 ? Promise.resolve(null) : fetchElementNames(allElementIds);
+  return elementNamesPromise.then((elementNames) => {
+    const mapIdsToIdNames = (ids) => {
+      return ids ? ids.map((id) => ({
+        [ID]: id,
+        [NAME]: elementNames?.[id] ?? void 0
+      })) : [];
+    };
+    return {
+      ...parameters,
+      contingencyListsInfos: parameters.contingencyListsInfos ? parameters.contingencyListsInfos.map((cli) => {
+        return {
+          ...cli,
+          contingencyLists: mapIdsToIdNames(cli.contingencyLists)
+        };
+      }) : []
+    };
+  });
+}
 function fetchSecurityAnalysisParameters(parameterUuid) {
   console.info("fetch security analysis parameters");
   const url = `${getSecurityAnalysisUrl()}parameters/${encodeURIComponent(parameterUuid)}`;
@@ -59,6 +90,7 @@ function updateSecurityAnalysisParameters(parameterUuid, newParams) {
   });
 }
 export {
+  enrichSecurityAnalysisParameters,
   fetchSecurityAnalysisParameters,
   fetchSecurityAnalysisProviders,
   getSecurityAnalysisDefaultLimitReductions,

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

@@ -1,8 +1,9 @@
 import { UUID } from 'node:crypto';
-import { FactorsCount, SensitivityAnalysisParametersInfosEnriched } from '../utils';
+import { FactorsCount, SensitivityAnalysisParametersInfos, 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 enrichSensitivityAnalysisParameters(parameters: SensitivityAnalysisParametersInfos): Promise<SensitivityAnalysisParametersInfosEnriched>;
 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>;

package/dist/services/sensitivity-analysis.js

@@ -1,10 +1,11 @@
 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 { mapSensitivityAnalysisParameters } from "../utils/types/sensitivity-analysis.type.js";
 import "react/jsx-runtime";
 import "@mui/icons-material";
 import { PREFIX_STUDY_QUERIES } from "./loadflow.js";
+import { fetchElementNames } from "./directory.js";
 const GET_PARAMETERS_PREFIX = `${"api/gateway"}/sensitivity-analysis/v1/parameters`;
 const PREFIX_SENSITIVITY_ANALYSIS_SERVER_QUERIES = `${"api/gateway"}/sensitivity-analysis`;
 const getStudyUrl = (studyUuid) => `${PREFIX_STUDY_QUERIES}/v1/studies/${safeEncodeURIComponent(studyUuid)}`;
@@ -20,6 +21,90 @@ function fetchSensitivityAnalysisProviders() {
   console.debug(url);
   return backendFetchJson(url);
 }
+function collectAllElementIds(parameters) {
+  const allElementIds = /* @__PURE__ */ new Set();
+  parameters.sensitivityInjection?.forEach((i) => {
+    i.monitoredBranches?.forEach((id) => allElementIds.add(id));
+    i.injections?.forEach((id) => allElementIds.add(id));
+    i.contingencies?.forEach((id) => allElementIds.add(id));
+  });
+  parameters.sensitivityInjectionsSet?.forEach((is) => {
+    is.monitoredBranches?.forEach((id) => allElementIds.add(id));
+    is.injections?.forEach((id) => allElementIds.add(id));
+    is.contingencies?.forEach((id) => allElementIds.add(id));
+  });
+  parameters.sensitivityHVDC?.forEach((hvdc) => {
+    hvdc.monitoredBranches?.forEach((id) => allElementIds.add(id));
+    hvdc.hvdcs?.forEach((id) => allElementIds.add(id));
+    hvdc.contingencies?.forEach((id) => allElementIds.add(id));
+  });
+  parameters.sensitivityPST?.forEach((pst) => {
+    pst.monitoredBranches?.forEach((id) => allElementIds.add(id));
+    pst.psts?.forEach((id) => allElementIds.add(id));
+    pst.contingencies?.forEach((id) => allElementIds.add(id));
+  });
+  parameters.sensitivityNodes?.forEach((n) => {
+    n.monitoredVoltageLevels?.forEach((id) => allElementIds.add(id));
+    n.equipmentsInVoltageRegulation?.forEach((id) => allElementIds.add(id));
+    n.contingencies?.forEach((id) => allElementIds.add(id));
+  });
+  return allElementIds;
+}
+function enrichSensitivityAnalysisParameters(parameters) {
+  const allElementIds = collectAllElementIds(parameters);
+  const elementNamesPromise = allElementIds.size === 0 ? Promise.resolve(null) : fetchElementNames(allElementIds);
+  return elementNamesPromise.then((elementNames) => {
+    const mapIdsToIdNames = (ids) => {
+      return ids ? ids.map((id) => ({
+        id,
+        name: elementNames?.[id] ?? void 0
+      })) : [];
+    };
+    return {
+      ...parameters,
+      sensitivityInjectionsSet: parameters.sensitivityInjectionsSet ? parameters.sensitivityInjectionsSet.map((is) => {
+        return {
+          ...is,
+          monitoredBranches: mapIdsToIdNames(is.monitoredBranches),
+          injections: mapIdsToIdNames(is.injections),
+          contingencies: mapIdsToIdNames(is.contingencies)
+        };
+      }) : [],
+      sensitivityInjection: parameters.sensitivityInjection ? parameters.sensitivityInjection.map((i) => {
+        return {
+          ...i,
+          monitoredBranches: mapIdsToIdNames(i.monitoredBranches),
+          injections: mapIdsToIdNames(i.injections),
+          contingencies: mapIdsToIdNames(i.contingencies)
+        };
+      }) : [],
+      sensitivityHVDC: parameters.sensitivityHVDC ? parameters.sensitivityHVDC.map((hvdc) => {
+        return {
+          ...hvdc,
+          monitoredBranches: mapIdsToIdNames(hvdc.monitoredBranches),
+          hvdcs: mapIdsToIdNames(hvdc.hvdcs),
+          contingencies: mapIdsToIdNames(hvdc.contingencies)
+        };
+      }) : [],
+      sensitivityPST: parameters.sensitivityPST ? parameters.sensitivityPST.map((pst) => {
+        return {
+          ...pst,
+          monitoredBranches: mapIdsToIdNames(pst.monitoredBranches),
+          psts: mapIdsToIdNames(pst.psts),
+          contingencies: mapIdsToIdNames(pst.contingencies)
+        };
+      }) : [],
+      sensitivityNodes: parameters.sensitivityNodes ? parameters.sensitivityNodes.map((n) => {
+        return {
+          ...n,
+          monitoredVoltageLevels: mapIdsToIdNames(n.monitoredVoltageLevels),
+          equipmentsInVoltageRegulation: mapIdsToIdNames(n.equipmentsInVoltageRegulation),
+          contingencies: mapIdsToIdNames(n.contingencies)
+        };
+      }) : []
+    };
+  });
+}
 function getSensitivityAnalysisParameters(studyUuid) {
   console.info("get sensitivity analysis parameters");
   const url = `${getStudyUrl(studyUuid)}/sensitivity-analysis/parameters`;
@@ -74,6 +159,7 @@ function updateSensitivityAnalysisParameters(parameterUuid, newParams) {
   });
 }
 export {
+  enrichSensitivityAnalysisParameters,
   fetchSensitivityAnalysisParameters,
   fetchSensitivityAnalysisProviders,
   getSensiUrl,

package/dist/utils/constants/filterConstant.d.ts

@@ -5,5 +5,5 @@ export declare const FILTERS = "filters";
 export declare const ID = "id";
 export type FilterIdentifier = {
     [FILTER_ID]: UUID;
-    [FILTER_NAME]: string;
+    [FILTER_NAME]?: string;
 };

package/dist/utils/index.js

@@ -28,10 +28,11 @@ 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, enrichSensitivityAnalysisParameters, mapSensitivityAnalysisParameters } from "./types/sensitivity-analysis.type.js";
+import { mapSecurityAnalysisParameters } from "./types/security-analysis.type.js";
+import { DistributionType, SensitivityType, 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 { 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";
@@ -148,8 +149,6 @@ export {
   convertInputValue,
   convertOutputValue,
   copyToClipboard,
-  enrichPccMinParameters,
-  enrichSensitivityAnalysisParameters,
   equalsArray,
   equipmentStyles,
   equipmentTypesForPredefinedPropertiesMapper,
@@ -172,6 +171,7 @@ export {
   kiloUnitToUnit,
   makeComposeClasses,
   mapPccMinParameters,
+  mapSecurityAnalysisParameters,
   mapSensitivityAnalysisParameters,
   mergeSx,
   microUnitToUnit,

package/dist/utils/types/dynamic-security-analysis.type.d.ts

@@ -1,13 +1,11 @@
 import { UUID } from 'node:crypto';
+import { IdName } from './types';
 export type DynamicSecurityAnalysisParametersInfos = {
     provider?: string;
     scenarioDuration?: number;
     contingenciesStartTime?: number;
     contingencyListIds?: UUID[];
 };
-export type DynamicSecurityAnalysisParametersFetchReturn = Exclude<DynamicSecurityAnalysisParametersInfos, 'contingencyListIds'> & {
-    contingencyListInfos?: {
-        id: string;
-        name: string;
-    }[];
+export type DynamicSecurityAnalysisParametersFetchReturn = Omit<DynamicSecurityAnalysisParametersInfos, 'contingencyListIds'> & {
+    contingencyListInfos?: IdName[];
 };

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

@@ -18,6 +18,7 @@ export * from './parameters.type';
 export * from './dynamic-security-analysis.type';
 export * from './dynamic-simulation.type';
 export * from './loadflow.type';
+export * from './security-analysis.type';
 export * from './sensitivity-analysis.type';
 export * from './dynamic-margin-calculation.type';
 export * from './network-modification-types';

package/dist/utils/types/index.js

@@ -9,10 +9,11 @@ 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, enrichSensitivityAnalysisParameters, mapSensitivityAnalysisParameters } from "./sensitivity-analysis.type.js";
+import { mapSecurityAnalysisParameters } from "./security-analysis.type.js";
+import { DistributionType, SensitivityType, 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";
+import { mapPccMinParameters } from "./pcc-min.type.js";
 export {
   ALL_EQUIPMENTS,
   AnnouncementSeverity,
@@ -64,8 +65,6 @@ export {
   VL_TAG_MAX_SIZE,
   VSC,
   VoltageLevel,
-  enrichPccMinParameters,
-  enrichSensitivityAnalysisParameters,
   equipmentStyles,
   getConnectionDirectionLabel,
   getEnergySourceLabel,
@@ -73,5 +72,6 @@ export {
   getLoadTypeLabel,
   isInjection,
   mapPccMinParameters,
+  mapSecurityAnalysisParameters,
   mapSensitivityAnalysisParameters
 };

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

@@ -6,7 +6,7 @@ import { ILimitReductionsByVoltageLevel } from '../../features/parameters/common
 import { DynamicSimulationParametersInfos } from './dynamic-simulation.type';
 import { SensitivityAnalysisParametersInfosEnriched } from './sensitivity-analysis.type';
 import { ShortCircuitParametersInfos } from '../../features/parameters/short-circuit/short-circuit-parameters.type';
-import { SAParametersEnriched } from '../../features/parameters/security-analysis/types';
+import { SAParametersEnriched } from './security-analysis.type';
 import { DynamicMarginCalculationParametersInfos } from './dynamic-margin-calculation.type';
 export declare enum ParameterType {
     BOOLEAN = "BOOLEAN",

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

@@ -7,4 +7,3 @@ export type PccMinParameters = {
     [FILTERS]: UUID[];
 };
 export declare function mapPccMinParameters(parametersInfos: PccMinParametersEnriched): PccMinParameters;
-export declare function enrichPccMinParameters(parameters: PccMinParameters): Promise<PccMinParametersEnriched>;