@gridsuite/commons-ui 0.207.0 → 0.209.0

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/translations/en/networkModificationsEn.d.ts

@@ -194,6 +194,11 @@ export declare const networkModificationsEn: {
     addNewAssignment: string;
     changeTypeConfirmation: string;
     Or: string;
+    CreateBattery: string;
+    BatteryCreationError: string;
+    Connectivity: string;
+    ActiveLimits: string;
+    ReactiveLimits: string;
     NormalizedPercentage: string;
     On: string;
     Off: string;
@@ -205,12 +210,17 @@ export declare const networkModificationsEn: {
     ReactiveLimitsKindCurve: string;
     MinimumReactivePower: string;
     MaximumReactivePower: string;
+    ActiveLimitsMinMaxInvalid: string;
+    ReactiveLimitsMinMaxInvalid: string;
+    MinReactivePowerRequired: string;
+    MaxReactivePowerRequired: string;
     ReactiveCapabilityCurveCreationErrorMissingPoints: string;
     ReactiveCapabilityCurveCreationErrorPInvalid: string;
     ReactiveCapabilityCurveCreationErrorPOutOfRange: string;
     ReactiveCapabilityCurveCreationErrorQminPQmaxPIncoherence: string;
     ReactiveCapabilityCurveCreationErrorMissingNegativeP: string;
     ReactiveCapabilityCurveCreationErrorMissingPositiveP: string;
+    ActivePowerMustBeZeroOrBetweenMinAndMaxActivePower: string;
     P: string;
     QminP: string;
     QmaxP: string;

package/dist/translations/en/networkModificationsEn.js

@@ -200,6 +200,11 @@ const networkModificationsEn = {
   addNewAssignment: "Modify another field",
   changeTypeConfirmation: "The type will be changed. All fields values will be erased.",
   Or: "or",
+  CreateBattery: "Create battery",
+  BatteryCreationError: "Error while creating battery",
+  Connectivity: "Connectivity",
+  ActiveLimits: "Active limits",
+  ReactiveLimits: "Reactive limits",
   NormalizedPercentage: "This percentage must be between 0 and 100",
   On: "On",
   Off: "Off",
@@ -211,12 +216,17 @@ const networkModificationsEn = {
   ReactiveLimitsKindCurve: "By diagram",
   MinimumReactivePower: "Minimum reactive power",
   MaximumReactivePower: "Maximum reactive power",
+  ActiveLimitsMinMaxInvalid: "Maximum active power must be greater than minimum active power",
+  ReactiveLimitsMinMaxInvalid: "Maximum reactive power must be greater than minimum reactive power",
+  MinReactivePowerRequired: "Minimum reactive power is required if maximum is defined",
+  MaxReactivePowerRequired: "Maximum reactive power is required if minimum is defined",
   ReactiveCapabilityCurveCreationErrorMissingPoints: "The table of reactive capability curve must have at least four points.",
   ReactiveCapabilityCurveCreationErrorPInvalid: "Each active power value must be a valid unique number.",
   ReactiveCapabilityCurveCreationErrorPOutOfRange: "Each active power value must be within the min P and max P values.",
   ReactiveCapabilityCurveCreationErrorQminPQmaxPIncoherence: "Each minimum reactive power value must be less than or equal to the corresponding maximum reactive power value.",
   ReactiveCapabilityCurveCreationErrorMissingNegativeP: "The reactive capability curve table must have at least one row with negative active power",
   ReactiveCapabilityCurveCreationErrorMissingPositiveP: "The reactive capability curve table must have at least one row with positive active power",
+  ActivePowerMustBeZeroOrBetweenMinAndMaxActivePower: "Active power value must be equal to 0 or between minimum and maximum active power values",
   P: "P{labelSuffix}",
   QminP: "QminP{labelSuffix}",
   QmaxP: "QmaxP{labelSuffix}",

package/dist/translations/fr/networkModificationsFr.d.ts

@@ -194,6 +194,11 @@ export declare const networkModificationsFr: {
     addNewAssignment: string;
     changeTypeConfirmation: string;
     Or: string;
+    CreateBattery: string;
+    BatteryCreationError: string;
+    Connectivity: string;
+    ActiveLimits: string;
+    ReactiveLimits: string;
     NormalizedPercentage: string;
     On: string;
     Off: string;
@@ -205,12 +210,17 @@ export declare const networkModificationsFr: {
     ReactiveLimitsKindCurve: string;
     MinimumReactivePower: string;
     MaximumReactivePower: string;
+    ActiveLimitsMinMaxInvalid: string;
+    ReactiveLimitsMinMaxInvalid: string;
+    MinReactivePowerRequired: string;
+    MaxReactivePowerRequired: string;
     ReactiveCapabilityCurveCreationErrorMissingPoints: string;
     ReactiveCapabilityCurveCreationErrorPInvalid: string;
     ReactiveCapabilityCurveCreationErrorPOutOfRange: string;
     ReactiveCapabilityCurveCreationErrorQminPQmaxPIncoherence: string;
     ReactiveCapabilityCurveCreationErrorMissingNegativeP: string;
     ReactiveCapabilityCurveCreationErrorMissingPositiveP: string;
+    ActivePowerMustBeZeroOrBetweenMinAndMaxActivePower: string;
     P: string;
     QminP: string;
     QmaxP: string;

package/dist/translations/fr/networkModificationsFr.js

@@ -200,6 +200,11 @@ const networkModificationsFr = {
   addNewAssignment: "Modifier un autre champ",
   changeTypeConfirmation: "Le type va être modifié. Toutes les valeurs des champs seront effacées.",
   Or: "ou",
+  CreateBattery: "Créer une batterie",
+  BatteryCreationError: "Erreur lors de la création d'une batterie",
+  Connectivity: "Connectivité",
+  ActiveLimits: "Limites en actif",
+  ReactiveLimits: "Limites en réactif",
   NormalizedPercentage: "Ce pourcentage doit être compris entre 0 et 100",
   On: "Activé",
   Off: "Désactivé",
@@ -211,12 +216,17 @@ const networkModificationsFr = {
   ReactiveLimitsKindCurve: "Par diagramme",
   MinimumReactivePower: "Puissance réactive minimale",
   MaximumReactivePower: "Puissance réactive maximale",
+  ActiveLimitsMinMaxInvalid: "La puissance active maximale doit être supérieure à la puissance active minimale",
+  ReactiveLimitsMinMaxInvalid: "La puissance réactive maximale doit être supérieure à la puissance réactive minimale",
+  MinReactivePowerRequired: "La puissance réactive minimale est requise si la maximale est définie",
+  MaxReactivePowerRequired: "La puissance réactive maximale est requise si la minimale est définie",
   ReactiveCapabilityCurveCreationErrorMissingPoints: "Le tableau des limites de réactifs par diagramme doit comporter au moins quatre points.",
   ReactiveCapabilityCurveCreationErrorPInvalid: "Chaque valeur de puissance active doit être un nombre unique et valide.",
   ReactiveCapabilityCurveCreationErrorPOutOfRange: "Chaque valeur de puissance active doit être comprise entre les valeurs P min et P max.",
   ReactiveCapabilityCurveCreationErrorQminPQmaxPIncoherence: "Chaque valeur de puissance réactive minimale doit être inférieure ou égale à la puissance réactive maximale correspondante.",
   ReactiveCapabilityCurveCreationErrorMissingNegativeP: "Le tableau des limites de réactifs par diagramme doit comporter au moins une ligne avec une puissance active négative",
   ReactiveCapabilityCurveCreationErrorMissingPositiveP: "Le tableau des limites de réactifs par diagramme doit comporter au moins une ligne avec une puissance active positive",
+  ActivePowerMustBeZeroOrBetweenMinAndMaxActivePower: "La valeur de la puissance active doit être égale à 0 ou comprise entre la valeur de la puissance active min et la valeur de la puissance active max",
   P: "P{labelSuffix}",
   QminP: "QminP{labelSuffix}",
   QmaxP: "QmaxP{labelSuffix}",

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/network-modification-metadata.d.ts

@@ -13,4 +13,5 @@ export interface NetworkModificationMetadata {
 export interface ComposedModificationMetadata extends NetworkModificationMetadata {
     subModifications: ComposedModificationMetadata[];
     maxDepth?: number;
+    name?: string;
 }

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 {};