@gridsuite/commons-ui 0.222.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

@@ -260,17 +260,18 @@ import { CustomError } from "./utils/types/CustomError.js";
 import { ProblemDetailError } from "./utils/types/ProblemDetailError.js";
 import { NetworkTimeoutError } from "./utils/types/NetworkTimeoutError.js";
 import { ElementType } from "./utils/types/elementType.js";
-import { ALL_EQUIPMENTS, BASE_EQUIPMENTS, CONNECTION_DIRECTIONS, EQUIPMENTS_WITH_ONE_NOMINAL_VOLTAGE, EQUIPMENTS_WITH_ONE_SUBSTATION, EQUIPMENTS_WITH_THREE_NOMINAL_VOLTAGES, EQUIPMENTS_WITH_TWO_NOMINAL_VOLTAGES, EQUIPMENTS_WITH_TWO_SUBSTATIONS, EquipmentType, ExtendedEquipmentType, HvdcType, LOAD_TYPES, OperatingStatus, SEARCH_EQUIPMENTS, TYPE_TAG_MAX_SIZE, UNDEFINED_CONNECTION_DIRECTION, UNDEFINED_LOAD_TYPE, VL_TAG_MAX_SIZE, equipmentStyles, getConnectionDirectionLabel, getEquipmentsInfosForSearchBar, getLoadTypeLabel } from "./utils/types/equipmentType.js";
+import { ALL_EQUIPMENTS, BASE_EQUIPMENTS, CONNECTION_DIRECTIONS, ENERGY_SOURCES, EQUIPMENTS_WITH_ONE_NOMINAL_VOLTAGE, EQUIPMENTS_WITH_ONE_SUBSTATION, EQUIPMENTS_WITH_THREE_NOMINAL_VOLTAGES, EQUIPMENTS_WITH_TWO_NOMINAL_VOLTAGES, EQUIPMENTS_WITH_TWO_SUBSTATIONS, EquipmentType, ExtendedEquipmentType, HvdcType, LOAD_TYPES, OperatingStatus, SEARCH_EQUIPMENTS, TYPE_TAG_MAX_SIZE, UNDEFINED_CONNECTION_DIRECTION, UNDEFINED_LOAD_TYPE, VL_TAG_MAX_SIZE, equipmentStyles, getConnectionDirectionLabel, getEnergySourceLabel, getEquipmentsInfosForSearchBar, getLoadTypeLabel } from "./utils/types/equipmentType.js";
 import { Battery, BoundaryLine, BusBar, Generator, Hvdc, LCC, Line, Load, SVC, ShuntCompensator, Substation, ThreeWindingTransfo, TwoWindingTransfo, VSC, VoltageLevel, isInjection } from "./utils/types/equipmentTypes.js";
 import { AnnouncementSeverity, ArrayAction } from "./utils/types/types.js";
 import { MODIFICATION_TYPES, ModificationType } from "./utils/types/modificationType.js";
 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";
@@ -312,6 +313,8 @@ import { EQUIPMENT_TYPE_ORDER, byFilterDeletionDtoToForm, byFilterDeletionFormSc
 import { ModificationByAssignmentForm } from "./features/network-modifications/by-filter/assignment/modification-by-assignment-form.js";
 import { emptyModificationByAssignmentFormData, modificationByAssignmentDtoToForm, modificationByAssignmentFormSchema, modificationByAssignmentFormToDto } from "./features/network-modifications/by-filter/assignment/modificationByAssignment.utils.js";
 import { DataType as DataType2 } from "./features/network-modifications/by-filter/assignment/assignment/assignment.type.js";
+import { generatorCreationDtoToForm, generatorCreationEmptyFormData, generatorCreationFormSchema, generatorCreationFormToDto } from "./features/network-modifications/generator/creation/generatorCreation.utils.js";
+import { GeneratorCreationForm } from "./features/network-modifications/generator/creation/GeneratorCreationForm.js";
 import { batteryCreationDtoToForm, batteryCreationEmptyFormData, batteryCreationFormSchema, batteryCreationFormToDto } from "./features/network-modifications/battery/creation/batteryCreation.utils.js";
 import { BatteryCreationForm } from "./features/network-modifications/battery/creation/BatteryCreationForm.js";
 import { batteryModificationDtoToForm, batteryModificationEmptyFormData, batteryModificationFormSchema, batteryModificationFormToDto } from "./features/network-modifications/battery/modification/batteryModification.utils.js";
@@ -345,7 +348,7 @@ import { SelectHeaderCell } from "./features/network-modification-table/renderer
 import { SwitchCell } from "./features/network-modification-table/renderers/switch-cell.js";
 import { DragCloneRow } from "./features/network-modification-table/row/drag-row-clone.js";
 import { ModificationRow } from "./features/network-modification-table/row/modification-row.js";
-import { MAX_COMPOSITE_NESTING_DEPTH, fetchSubModificationsForExpandedRows, findAllLoadedCompositeModifications, findModificationInTree, formatToComposedModification, isCompositeModification, mergeSubModificationsIntoTree, moveSubModificationInTree, updateModificationFieldInTree, updateSubModificationsOfACompositeInTree } from "./features/network-modification-table/utils.js";
+import { MAX_COMPOSITE_NESTING_DEPTH, fetchSubModificationsForExpandedRows, findAllLoadedCompositeModifications, findDepth, findModificationInTree, formatToComposedModification, isCompositeModification, mergeSubModificationsIntoTree, moveSubModificationInTree, updateModificationFieldInTree, updateSubModificationsOfACompositeInTree } from "./features/network-modification-table/utils.js";
 import { AnnouncementBanner } from "./features/announcement/AnnouncementBanner.js";
 import { AnnouncementNotification } from "./features/announcement/AnnouncementNotification.js";
 import { useGlobalAnnouncement } from "./features/announcement/useGlobalAnnouncement.js";
@@ -578,6 +581,7 @@ export {
   DynamicMarginCalculationInline,
   DynamicSecurityAnalysisInline,
   DynamicSimulationInline,
+  ENERGY_SOURCES,
   ENERGY_SOURCE_OPTIONS,
   EQUIPMENTS_IN_VOLTAGE_REGULATION_TYPES,
   EQUIPMENTS_WITH_ONE_NOMINAL_VOLTAGE,
@@ -633,6 +637,7 @@ export {
   GENERATORS_SELECTION_TYPE,
   GRIDSUITE_DEFAULT_PRECISION,
   Generator,
+  GeneratorCreationForm,
   GridLogo,
   GroupValueEditor,
   HIGH_VOLTAGE_LIMIT,
@@ -1045,6 +1050,7 @@ export {
   emptyModificationByAssignmentFormData,
   emptyProperties,
   enrichPccMinParameters,
+  enrichSecurityAnalysisParameters,
   enrichSensitivityAnalysisParameters,
   equalsArray,
   equipmentDeletionDtoToForm,
@@ -1113,6 +1119,7 @@ export {
   filterExpertFr,
   filterFr,
   findAllLoadedCompositeModifications,
+  findDepth,
   findModificationInTree,
   flatParametersEn,
   flatParametersFr,
@@ -1120,6 +1127,10 @@ export {
   formatToComposedModification,
   genHelperError,
   generateTreeViewFinderClass,
+  generatorCreationDtoToForm,
+  generatorCreationEmptyFormData,
+  generatorCreationFormSchema,
+  generatorCreationFormToDto,
   getActivePowerControlEmptyFormData,
   getActivePowerControlSchema,
   getActivePowerSetPointSchema,
@@ -1160,6 +1171,7 @@ export {
   getCreateSwitchesValidationSchema,
   getDefaultRowData,
   getDynamicMappings,
+  getEnergySourceLabel,
   getEquipmentTypeShortLabel,
   getEquipmentsInfosForSearchBar,
   getExpertFilterEmptyFormData,
@@ -1280,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/translations/en/networkModificationsEn.d.ts

@@ -67,6 +67,7 @@ export declare const networkModificationsEn: {
     'network_modifications.CREATE_VOLTAGE_LEVEL_SECTION': string;
     'network_modifications.MOVE_VOLTAGE_LEVEL_FEEDER_BAYS': string;
     ModificationReadError: string;
+    CompositeModification: string;
     CreateSubstation: string;
     DeleteEquipmentByFilter: string;
     ModifyByAssignment: string;
@@ -261,6 +262,12 @@ export declare const networkModificationsEn: {
     QminPmin: string;
     QmaxPmin: string;
     Pmax: string;
+    CreateGenerator: string;
+    GeneratorCreationError: string;
+    VoltageRegulationText: string;
+    GenerationDispatch: string;
+    generatorMinimumActivePowerMaxValueError: string;
+    PlannedActivePowerSetPointMustBeBetweenMinAndMaxActivePower: string;
     NoBusbarSectionFound: string;
     SubstationTab: string;
     ConnectivityTab: string;

package/dist/translations/en/networkModificationsEn.js

@@ -72,6 +72,7 @@ const networkModificationsEn = {
   "network_modifications.CREATE_VOLTAGE_LEVEL_SECTION": "Adding busbar section to voltage level {computedLabel}",
   "network_modifications.MOVE_VOLTAGE_LEVEL_FEEDER_BAYS": "Moving feeder bays in voltage level {computedLabel}",
   ModificationReadError: "An error occurred while fetching the modification",
+  CompositeModification: "Composite modification",
   CreateSubstation: "Create substation",
   DeleteEquipmentByFilter: "Delete equipment by filter",
   ModifyByAssignment: "Modify by filter",
@@ -266,6 +267,12 @@ const networkModificationsEn = {
   QminPmin: "QminPmin",
   QmaxPmin: "QmaxPmin",
   Pmax: "Pmax",
+  CreateGenerator: "Create generator",
+  GeneratorCreationError: "Error while creating generator",
+  VoltageRegulationText: "Voltage regulation",
+  GenerationDispatch: "Generation dispatch",
+  generatorMinimumActivePowerMaxValueError: "Minimum active power must be inferior to maximum active power",
+  PlannedActivePowerSetPointMustBeBetweenMinAndMaxActivePower: "Planned active power set point must be between minimum and maximum active power values",
   NoBusbarSectionFound: "No busbar section found for this voltage level",
   // Tabs
   SubstationTab: "Substation",