@gridsuite/commons-ui 0.112.0 → 0.113.0

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

@@ -0,0 +1,357 @@
+import "../../../utils/yupConfig.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, ACTIVATED, PARAMETER_SENSI_HVDC, HVDC_LINES, PARAMETER_SENSI_INJECTION, INJECTIONS, PARAMETER_SENSI_INJECTIONS_SET, DISTRIBUTION_TYPE, COUNT, CONTINGENCIES, SENSITIVITY_TYPE, MONITORED_BRANCHES, CONTAINER_NAME, CONTAINER_ID } from "./constants.js";
+import "../../../utils/conversionUtils.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import "../../../utils/types/equipmentType.js";
+import { DistributionType, SensitivityType } from "../../../utils/types/sensitivity-analysis.type.js";
+import { PROVIDER } from "../common/constant.js";
+import "@mui/material";
+import "react-intl";
+import "react";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "react-hook-form";
+import "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "../../dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
+import "../../dialogs/elementSaveDialog/ElementSaveDialog.js";
+import "../../treeViewFinder/TreeViewFinder.js";
+import * as yup from "yup";
+import "../../overflowableText/OverflowableText.js";
+import { NAME } from "../../inputs/reactHookForm/constants.js";
+import "../../inputs/reactHookForm/agGridTable/BottomRightButtons.js";
+import "../../customAGGrid/customAggrid.js";
+import "ag-grid-community";
+import "react-papaparse";
+import "react-csv-downloader";
+import "../../inputs/reactHookForm/numbers/RangeInput.js";
+import "@react-querybuilder/material";
+import "../../filter/expert/expertFilterConstants.js";
+import "../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "uuid";
+import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
+import "react-querybuilder";
+import "../common/widget/parameter-line-slider.js";
+import "../common/limitreductions/columns-definitions.js";
+import "../../filter/HeaderFilterForm.js";
+import { getNameElementEditorSchema } from "../common/name-element-editor/name-element-editor-utils.js";
+import { ID } from "../voltage-init/constants.js";
+import "@hookform/resolvers/yup";
+import "@hello-pangea/dnd";
+const getMonitoredBranchesSchema = () => {
+  return {
+    [MONITORED_BRANCHES]: yup.array().of(
+      yup.object().shape({
+        [ID]: yup.string().required(),
+        [NAME]: yup.string().required()
+      })
+    ).required().when([ACTIVATED], {
+      is: (activated) => activated,
+      then: (schema) => schema.min(1, "FieldIsRequired")
+    })
+  };
+};
+const getSensitivityTypeSchema = () => {
+  return {
+    [SENSITIVITY_TYPE]: yup.mixed().oneOf(Object.values(SensitivityType)).when([ACTIVATED], {
+      is: (activated) => activated,
+      then: (schema) => schema.required()
+    })
+  };
+};
+const getContingenciesSchema = () => {
+  return {
+    [CONTINGENCIES]: yup.array().of(
+      yup.object().shape({
+        [ID]: yup.string().required(),
+        [NAME]: yup.string().required()
+      })
+    ),
+    [ACTIVATED]: yup.boolean().required(),
+    [COUNT]: yup.number().nullable()
+  };
+};
+const getSensiHVDCsFormSchema = () => ({
+  [PARAMETER_SENSI_HVDC]: yup.array().of(
+    yup.object().shape({
+      ...getMonitoredBranchesSchema(),
+      ...getSensitivityTypeSchema(),
+      [HVDC_LINES]: yup.array().of(
+        yup.object().shape({
+          [ID]: yup.string().required(),
+          [NAME]: yup.string().required()
+        })
+      ).required().when([ACTIVATED], {
+        is: (activated) => activated,
+        then: (schema) => schema.min(1, "FieldIsRequired")
+      }),
+      ...getContingenciesSchema()
+    })
+  )
+});
+const getSensiHvdcformatNewParams = (newParams) => {
+  var _a;
+  return {
+    [PARAMETER_SENSI_HVDC]: (_a = newParams.sensitivityHVDC) == null ? void 0 : _a.map((sensitivityHVDCs) => {
+      var _a2;
+      return {
+        [MONITORED_BRANCHES]: sensitivityHVDCs[MONITORED_BRANCHES].map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [HVDC_LINES]: sensitivityHVDCs[HVDC_LINES].map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [SENSITIVITY_TYPE]: sensitivityHVDCs[SENSITIVITY_TYPE],
+        [CONTINGENCIES]: (_a2 = sensitivityHVDCs[CONTINGENCIES]) == null ? void 0 : _a2.map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [ACTIVATED]: sensitivityHVDCs[ACTIVATED]
+      };
+    })
+  };
+};
+const getSensiInjectionsFormSchema = () => ({
+  [PARAMETER_SENSI_INJECTION]: yup.array().of(
+    yup.object().shape({
+      ...getMonitoredBranchesSchema(),
+      [INJECTIONS]: yup.array().of(
+        yup.object().shape({
+          [ID]: yup.string().required(),
+          [NAME]: yup.string().required()
+        })
+      ).required().when([ACTIVATED], {
+        is: (activated) => activated,
+        then: (schema) => schema.min(1, "FieldIsRequired")
+      }),
+      ...getContingenciesSchema()
+    })
+  )
+});
+const getSensiInjectionsformatNewParams = (newParams) => {
+  var _a;
+  return {
+    [PARAMETER_SENSI_INJECTION]: (_a = newParams.sensitivityInjection) == null ? void 0 : _a.map((sensitivityInjections) => {
+      var _a2;
+      return {
+        [MONITORED_BRANCHES]: sensitivityInjections[MONITORED_BRANCHES].map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [INJECTIONS]: sensitivityInjections[INJECTIONS].map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [CONTINGENCIES]: (_a2 = sensitivityInjections[CONTINGENCIES]) == null ? void 0 : _a2.map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [ACTIVATED]: sensitivityInjections[ACTIVATED]
+      };
+    })
+  };
+};
+const getSensiInjectionsSetFormSchema = () => ({
+  [PARAMETER_SENSI_INJECTIONS_SET]: yup.array().of(
+    yup.object().shape({
+      ...getMonitoredBranchesSchema(),
+      [INJECTIONS]: yup.array().of(
+        yup.object().shape({
+          [ID]: yup.string().required(),
+          [NAME]: yup.string().required()
+        })
+      ).required().when([ACTIVATED], {
+        is: (activated) => activated,
+        then: (schema) => schema.min(1, "FieldIsRequired")
+      }),
+      [DISTRIBUTION_TYPE]: yup.mixed().oneOf(Object.values(DistributionType)).when([ACTIVATED], {
+        is: (activated) => activated,
+        then: (schema) => schema.required()
+      }),
+      ...getContingenciesSchema()
+    })
+  )
+});
+const getGenericRowNewParams = (newRowParams) => {
+  var _a, _b, _c, _d;
+  return {
+    [MONITORED_BRANCHES]: newRowParams[MONITORED_BRANCHES].map((container) => container[ID]),
+    [INJECTIONS]: (_a = newRowParams[INJECTIONS]) == null ? void 0 : _a.map((container) => container[ID]),
+    [HVDC_LINES]: (_b = newRowParams[HVDC_LINES]) == null ? void 0 : _b.map((container) => container[ID]),
+    [PSTS]: (_c = newRowParams[PSTS]) == null ? void 0 : _c.map((container) => container[ID]),
+    [CONTINGENCIES]: (_d = newRowParams[CONTINGENCIES]) == null ? void 0 : _d.map((container) => container[ID])
+  };
+};
+const getSensiInjectionsSetformatNewParams = (newParams) => {
+  var _a;
+  return {
+    [PARAMETER_SENSI_INJECTIONS_SET]: (_a = newParams.sensitivityInjectionsSet) == null ? void 0 : _a.map((sensitivityInjectionSet) => {
+      var _a2;
+      return {
+        [MONITORED_BRANCHES]: sensitivityInjectionSet[MONITORED_BRANCHES].map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [INJECTIONS]: sensitivityInjectionSet[INJECTIONS].map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [DISTRIBUTION_TYPE]: sensitivityInjectionSet[DISTRIBUTION_TYPE],
+        [CONTINGENCIES]: (_a2 = sensitivityInjectionSet[CONTINGENCIES]) == null ? void 0 : _a2.map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [ACTIVATED]: sensitivityInjectionSet[ACTIVATED]
+      };
+    })
+  };
+};
+const getSensiNodesFormSchema = () => ({
+  [PARAMETER_SENSI_NODES]: yup.array().of(
+    yup.object().shape({
+      [SUPERVISED_VOLTAGE_LEVELS]: yup.array().of(
+        yup.object().shape({
+          [ID]: yup.string().required(),
+          [NAME]: yup.string().required()
+        })
+      ),
+      [EQUIPMENTS_IN_VOLTAGE_REGULATION]: yup.array().of(
+        yup.object().shape({
+          [ID]: yup.string().required(),
+          [NAME]: yup.string().required()
+        })
+      ),
+      ...getContingenciesSchema()
+    })
+  )
+});
+const getSensiNodesformatNewParams = (newParams) => {
+  var _a;
+  return {
+    [PARAMETER_SENSI_NODES]: (_a = newParams.sensitivityNodes) == null ? void 0 : _a.map((sensitivityNode) => {
+      var _a2, _b, _c;
+      return {
+        [SUPERVISED_VOLTAGE_LEVELS]: (_a2 = sensitivityNode[SUPERVISED_VOLTAGE_LEVELS]) == null ? void 0 : _a2.map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [EQUIPMENTS_IN_VOLTAGE_REGULATION]: (_b = sensitivityNode[EQUIPMENTS_IN_VOLTAGE_REGULATION]) == null ? void 0 : _b.map(
+          (container) => {
+            return {
+              [CONTAINER_ID]: container[ID],
+              [CONTAINER_NAME]: container[NAME]
+            };
+          }
+        ),
+        [CONTINGENCIES]: (_c = sensitivityNode[CONTINGENCIES]) == null ? void 0 : _c.map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [ACTIVATED]: sensitivityNode[ACTIVATED]
+      };
+    })
+  };
+};
+const getSensiPSTsFormSchema = () => ({
+  [PARAMETER_SENSI_PST]: yup.array().of(
+    yup.object().shape({
+      ...getMonitoredBranchesSchema(),
+      ...getSensitivityTypeSchema(),
+      [PSTS]: yup.array().of(
+        yup.object().shape({
+          [ID]: yup.string().required(),
+          [NAME]: yup.string().required()
+        })
+      ).required().when([ACTIVATED], {
+        is: (activated) => activated,
+        then: (schema) => schema.min(1, "FieldIsRequired")
+      }),
+      ...getContingenciesSchema()
+    })
+  )
+});
+const getSensiPstformatNewParams = (newParams) => {
+  var _a;
+  return {
+    [PARAMETER_SENSI_PST]: (_a = newParams.sensitivityPST) == null ? void 0 : _a.map((sensitivityPSTs) => {
+      var _a2;
+      return {
+        [MONITORED_BRANCHES]: sensitivityPSTs[MONITORED_BRANCHES].map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [PSTS]: sensitivityPSTs[PSTS].map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [SENSITIVITY_TYPE]: sensitivityPSTs[SENSITIVITY_TYPE],
+        [CONTINGENCIES]: (_a2 = sensitivityPSTs[CONTINGENCIES]) == null ? void 0 : _a2.map((container) => {
+          return {
+            [CONTAINER_ID]: container[ID],
+            [CONTAINER_NAME]: container[NAME]
+          };
+        }),
+        [ACTIVATED]: sensitivityPSTs[ACTIVATED]
+      };
+    })
+  };
+};
+const formSchema = yup.object().shape({
+  [PROVIDER]: yup.string().required(),
+  [FLOW_FLOW_SENSITIVITY_VALUE_THRESHOLD]: yup.number().required(),
+  [ANGLE_FLOW_SENSITIVITY_VALUE_THRESHOLD]: yup.number().required(),
+  [FLOW_VOLTAGE_SENSITIVITY_VALUE_THRESHOLD]: yup.number().required(),
+  ...getSensiInjectionsSetFormSchema(),
+  ...getSensiInjectionsFormSchema(),
+  ...getSensiHVDCsFormSchema(),
+  ...getSensiPSTsFormSchema(),
+  ...getSensiNodesFormSchema()
+}).required();
+const getFormSchema = (name) => {
+  return formSchema.concat(getNameElementEditorSchema(name));
+};
+export {
+  formSchema,
+  getFormSchema,
+  getGenericRowNewParams,
+  getSensiHVDCsFormSchema,
+  getSensiHvdcformatNewParams,
+  getSensiInjectionsFormSchema,
+  getSensiInjectionsSetFormSchema,
+  getSensiInjectionsSetformatNewParams,
+  getSensiInjectionsformatNewParams,
+  getSensiNodesFormSchema,
+  getSensiNodesformatNewParams,
+  getSensiPSTsFormSchema,
+  getSensiPstformatNewParams
+};

package/dist/components/parameters/voltage-init/general-parameters.js

@@ -5,7 +5,6 @@ import { FormattedMessage } from "react-intl";
 import { Grid, Alert, Box } from "@mui/material";
 import { GENERAL, GENERAL_APPLY_MODIFICATIONS, UPDATE_BUS_VOLTAGE, REACTIVE_SLACKS_THRESHOLD, SHUNT_COMPENSATOR_ACTIVATION_THRESHOLD } from "./constants.js";
 import { ReactivePowerAdornment } from "../common/constant.js";
-import "../../../utils/yupConfig.js";
 import { LineSeparator } from "../common/line-separator.js";
 import { parametersStyles } from "../parameters-style.js";
 import "../../../utils/types/equipmentType.js";
@@ -27,6 +26,7 @@ import "react-papaparse";
 import "react-csv-downloader";
 import "../../inputs/reactHookForm/numbers/RangeInput.js";
 import "../../../utils/conversionUtils.js";
+import "../../../utils/yupConfig.js";
 import "@react-querybuilder/material";
 import "../../filter/expert/expertFilterConstants.js";
 import "../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";

package/dist/hooks/index.d.ts

@@ -16,3 +16,4 @@ export * from './useSnackMessage';
 export * from './useFormatLabelWithUnit';
 export * from './useSelectAppearance';
 export * from './use-parameters-backend';
+export * from './use-create-row-data-sensi';

package/dist/hooks/index.js

@@ -11,11 +11,13 @@ import { useSnackMessage } from "./useSnackMessage.js";
 import { useFormatLabelWithUnit } from "./useFormatLabelWithUnit.js";
 import { useSelectAppearance } from "./useSelectAppearance.js";
 import { OptionalServicesStatus, useParametersBackend } from "./use-parameters-backend.js";
+import { useCreateRowDataSensi } from "./use-create-row-data-sensi.js";
 export {
   OptionalServicesStatus,
   getComputedLanguage,
   getSystemLanguage,
   useConfidentialityWarning,
+  useCreateRowDataSensi,
   useDebounce,
   useFormatLabelWithUnit,
   useIntlRef,

package/dist/hooks/use-create-row-data-sensi.d.ts

@@ -0,0 +1,4 @@
+import { ISensiParameters } from '../components/parameters/sensi/columns-definitions';
+export declare function useCreateRowDataSensi(sensiParam: ISensiParameters): readonly [() => {
+    [key: string]: any;
+}[], import('react-hook-form').UseFieldArrayReturn<import('react-hook-form').FieldValues, string, "id">];

package/dist/hooks/use-create-row-data-sensi.js

@@ -0,0 +1,20 @@
+import { useFieldArray } from "react-hook-form";
+import { useMemo } from "react";
+import { COUNT } from "../components/parameters/sensi/constants.js";
+function useCreateRowDataSensi(sensiParam) {
+  const useFieldArrayOutput = useFieldArray({
+    name: sensiParam.name || ""
+  });
+  const newRowData = useMemo(() => {
+    const rowData = { [COUNT]: 0 };
+    sensiParam.columnsDef.forEach((column) => {
+      rowData[column.dataKey] = column.initialValue;
+    });
+    return rowData;
+  }, [sensiParam.columnsDef]);
+  const createNewRowData = () => [newRowData];
+  return [createNewRowData, useFieldArrayOutput];
+}
+export {
+  useCreateRowDataSensi
+};

package/dist/index.js

@@ -130,7 +130,6 @@ import { LeftPanelCloseIcon } from "./components/icons/LeftPanelCloseIcon.js";
 import { DeviceHubIcon } from "./components/icons/DeviceHubIcon.js";
 import { ComputingType, formatComputingTypeLabel, isValidComputingType } from "./components/parameters/common/computing-type.js";
 import { PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD, PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD, PARAM_SA_HIGH_VOLTAGE_PROPORTIONAL_THRESHOLD, PARAM_SA_LOW_VOLTAGE_ABSOLUTE_THRESHOLD, PARAM_SA_LOW_VOLTAGE_PROPORTIONAL_THRESHOLD, PARAM_SA_PROVIDER, PROVIDER, ReactivePowerAdornment, VOLTAGE_LEVEL, VoltageAdornment } from "./components/parameters/common/constant.js";
-import { getDialogParametersFormSchema } from "./components/parameters/common/parameters-edition-dialog-props.js";
 import { LineSeparator } from "./components/parameters/common/line-separator.js";
 import { LabelledButton, SwitchWithLabel, TabPanel } from "./components/parameters/common/parameters.js";
 import { CreateParameterDialog } from "./components/parameters/common/parameters-creation-dialog.js";
@@ -152,7 +151,6 @@ import { CENTER_LABEL, COMPONENT_LIBRARY, DIAGONAL_LABEL, INIT_NAD_WITH_GEO_DATA
 import { MAP_BASEMAP_CARTO, MAP_BASEMAP_CARTO_NOLABEL, MAP_BASEMAP_ETALAB, MAP_BASEMAP_MAPBOX, SubstationLayout } from "./components/parameters/network-visualizations/network-visualizations.types.js";
 import { NetworkVisualizationParametersInline } from "./components/parameters/network-visualizations/network-visualizations-parameters-inline.js";
 import { NetworkVisualizationsParametersEditionDialog } from "./components/parameters/network-visualizations/network-visualizations-parameters-dialog.js";
-import { getTabIndicatorStyle, getTabStyle, parametersStyles } from "./components/parameters/parameters-style.js";
 import { BALANCE_TYPE, COMMON_PARAMETERS, CONNECTED_COMPONENT_MODE, COUNTRIES_TO_BALANCE, DC, DC_POWER_FACTOR, DC_USE_TRANSFORMER_RATIO, DEFAULT_LIMIT_REDUCTION_VALUE, DISTRIBUTED_SLACK, HVDC_AC_EMULATION, MAX_VALUE_ALLOWED_FOR_LIMIT_REDUCTION, MIN_VALUE_ALLOWED_FOR_LIMIT_REDUCTION, PARAM_LIMIT_REDUCTION, PARAM_PROVIDER_OPENLOADFLOW, PHASE_SHIFTER_REGULATION_ON, READ_SLACK_BUS, SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON, SPECIFIC_PARAMETERS, TWT_SPLIT_SHUNT_ADMITTANCE, USE_REACTIVE_LIMITS, VOLTAGE_INIT_MODE, WRITE_SLACK_BUS, alertThresholdMarks } from "./components/parameters/loadflow/constants.js";
 import { LoadFlowParametersInline } from "./components/parameters/loadflow/load-flow-parameters-inline.js";
 import { LoadFlowParametersEditionDialog } from "./components/parameters/loadflow/load-flow-parameters-dialog.js";
@@ -165,6 +163,10 @@ import { VoltageInitParametersEditionDialog } from "./components/parameters/volt
 import { VoltageInitParametersInLine } from "./components/parameters/voltage-init/voltage-init-parameters-inline.js";
 import { SecurityAnalysisParametersInline } from "./components/parameters/security-analysis/security-analysis-parameters-inline.js";
 import { SecurityAnalysisParametersDialog } from "./components/parameters/security-analysis/security-analysis-parameters-dialog.js";
+import { SensitivityAnalysisParametersInline } from "./components/parameters/sensi/sensitivity-analysis-parameters-inline.js";
+import { SensitivityAnalysisParametersDialog } from "./components/parameters/sensi/sensitivity-analysis-parameters-dialog.js";
+import { COLUMNS_DEFINITIONS_HVDCS, COLUMNS_DEFINITIONS_INJECTIONS, COLUMNS_DEFINITIONS_INJECTIONS_SET, COLUMNS_DEFINITIONS_NODES, COLUMNS_DEFINITIONS_PSTS, EQUIPMENTS_IN_VOLTAGE_REGULATION_TYPES, HVDC_EQUIPMENT_TYPES, INJECTIONS_EQUIPMENT_TYPES, INJECTION_DISTRIBUTION_TYPES, MONITORED_BRANCHES_EQUIPMENT_TYPES, MONITORED_VOLTAGE_LEVELS_EQUIPMENT_TYPES, PSTS_EQUIPMENT_TYPES, SENSITIVITY_TYPES, SensiBranchesTabValues, SensiHvdcs, SensiInjection, SensiInjectionsSet, SensiNodes, SensiPsts, SensiTabValues } from "./components/parameters/sensi/columns-definitions.js";
+import { SensitivityTable } from "./components/parameters/sensi/sensitivity-table.js";
 import { CustomMenuItem, CustomNestedMenuItem } from "./components/menus/custom-nested-menu.js";
 import { useStateBoolean } from "./hooks/customStates/useStateBoolean.js";
 import { useStateNumber } from "./hooks/customStates/useStateNumber.js";
@@ -179,6 +181,7 @@ import { useSnackMessage } from "./hooks/useSnackMessage.js";
 import { useFormatLabelWithUnit } from "./hooks/useFormatLabelWithUnit.js";
 import { useSelectAppearance } from "./hooks/useSelectAppearance.js";
 import { OptionalServicesStatus, useParametersBackend } from "./hooks/use-parameters-backend.js";
+import { useCreateRowDataSensi } from "./hooks/use-create-row-data-sensi.js";
 import { LOGOUT_ERROR, RESET_AUTHENTICATION_ROUTER_ERROR, SHOW_AUTH_INFO_LOGIN, SIGNIN_CALLBACK_ERROR, UNAUTHORIZED_USER_INFO, USER, USER_VALIDATION_ERROR, resetAuthenticationRouterError, setLoggedUser, setLogoutError, setShowAuthenticationRouterLogin, setSignInCallbackError, setUnauthorizedUserInfo, setUserValidationError } from "./redux/actions/authActions.js";
 import { getUserToken, setCommonStore } from "./redux/commonStore.js";
 import { backendFetch, backendFetchJson, backendFetchText, catchErrorHandler, getRequestParamFromList } from "./services/utils.js";
@@ -283,7 +286,12 @@ export {
   BottomRightButtons,
   BusBar,
   CENTER_LABEL,
+  COLUMNS_DEFINITIONS_HVDCS,
+  COLUMNS_DEFINITIONS_INJECTIONS,
+  COLUMNS_DEFINITIONS_INJECTIONS_SET,
   COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS,
+  COLUMNS_DEFINITIONS_NODES,
+  COLUMNS_DEFINITIONS_PSTS,
   COMBINATOR_OPTIONS,
   COMMON_PARAMETERS,
   COMPONENT_LIBRARY,
@@ -347,6 +355,7 @@ export {
   DndTableBottomLeftButtons,
   DndTableBottomRightButtons,
   ENERGY_SOURCE_OPTIONS,
+  EQUIPMENTS_IN_VOLTAGE_REGULATION_TYPES,
   EQUIPMENT_TYPE,
   EXPERT_FILTER_EQUIPMENTS,
   EXPERT_FILTER_FIELDS,
@@ -395,11 +404,14 @@ export {
   GroupValueEditor,
   HIGH_VOLTAGE_LIMIT,
   HVDC_AC_EMULATION,
+  HVDC_EQUIPMENT_TYPES,
   HelperPreviousValue,
   Hvdc,
   HvdcType,
   ID,
   INIT_NAD_WITH_GEO_DATA,
+  INJECTIONS_EQUIPMENT_TYPES,
+  INJECTION_DISTRIBUTION_TYPES,
   INTL_LINE_FLOW_MODE_OPTIONS,
   INTL_MAP_BASE_MAP_OPTIONS,
   INTL_SUBSTATION_LAYOUT_OPTIONS,
@@ -452,6 +464,8 @@ export {
   MICRO_SIEMENS,
   MIN_VALUE_ALLOWED_FOR_LIMIT_REDUCTION,
   MODIFICATION_TYPES,
+  MONITORED_BRANCHES_EQUIPMENT_TYPES,
+  MONITORED_VOLTAGE_LEVELS_EQUIPMENT_TYPES,
   MidFormError,
   ModificationType,
   ModifyElementSelection,
@@ -500,6 +514,7 @@ export {
   PREFIX_STUDY_QUERIES,
   PRIORITY,
   PROVIDER,
+  PSTS_EQUIPMENT_TYPES,
   ParameterFloat,
   ParameterGroup,
   ParameterLineDirectoryItemsInput,
@@ -528,6 +543,7 @@ export {
   SEARCH_EQUIPMENTS,
   SELECTED,
   SELECTION_TYPE,
+  SENSITIVITY_TYPES,
   SHORT_CIRCUIT_INITIAL_VOLTAGE_PROFILE_MODE,
   SHORT_CIRCUIT_PREDEFINED_PARAMS,
   SHORT_CIRCUIT_WITH_FEEDER_RESULT,
@@ -550,6 +566,16 @@ export {
   SecurityAnalysisParametersInline,
   SelectClearable,
   SelectInput,
+  SensiBranchesTabValues,
+  SensiHvdcs,
+  SensiInjection,
+  SensiInjectionsSet,
+  SensiNodes,
+  SensiPsts,
+  SensiTabValues,
+  SensitivityAnalysisParametersDialog,
+  SensitivityAnalysisParametersInline,
+  SensitivityTable,
   SensitivityType,
   ShortCircuitParametersEditionDialog,
   ShortCircuitParametersInLine,
@@ -679,7 +705,6 @@ export {
   getCriteriaBasedFormData,
   getCriteriaBasedSchema,
   getDefaultLoadFlowProvider,
-  getDialogParametersFormSchema,
   getEquipmentsInfosForSearchBar,
   getExpertFilterEmptyFormData,
   getExplicitNamingFilterEmptyFormData,
@@ -702,8 +727,6 @@ export {
   getStudyShortCircuitParameters,
   getStudyUrl,
   getSystemLanguage,
-  getTabIndicatorStyle,
-  getTabStyle,
   getUserToken,
   getVoltageInitParameters,
   getVoltageInitUrl,
@@ -743,7 +766,6 @@ export {
   networkModificationsFr,
   parametersEn,
   parametersFr,
-  parametersStyles,
   queryValidator,
   recursiveRemove,
   reportViewerEn,
@@ -791,6 +813,7 @@ export {
   updateVoltageInitParameters,
   useConfidentialityWarning,
   useConvertValue,
+  useCreateRowDataSensi,
   useCsvExport,
   useCustomFormContext,
   useDebounce,

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

@@ -0,0 +1,12 @@
+import { UUID } from 'crypto';
+import { SensitivityAnalysisFactorsCountParameters, SensitivityAnalysisParametersInfos } from '../utils';
+export declare const getStudyUrl: (studyUuid: UUID | null) => string;
+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, isInjectionsSet: boolean, newParams: SensitivityAnalysisFactorsCountParameters): Promise<Response>;
+export declare function fetchDefaultSensitivityAnalysisProvider(): Promise<string>;
+export declare function updateSensitivityAnalysisParameters(parameterUuid: UUID, newParams: any): Promise<Response>;

package/dist/services/sensitivity-analysis.js

@@ -0,0 +1,87 @@
+import { backendFetchJson, backendFetch, backendFetchText } from "./utils.js";
+import { safeEncodeURIComponent } from "./security-analysis.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`;
+const getStudyUrl = (studyUuid) => `${PREFIX_STUDY_QUERIES}/v1/studies/${safeEncodeURIComponent(studyUuid)}`;
+const getStudyUrlWithNodeUuidAndRootNetworkUuid = (studyUuid, nodeUuid, rootNetworkUuid) => `${PREFIX_STUDY_QUERIES}/v1/studies/${safeEncodeURIComponent(studyUuid)}/root-networks/${safeEncodeURIComponent(
+  rootNetworkUuid
+)}/nodes/${safeEncodeURIComponent(nodeUuid)}`;
+function getSensiUrl() {
+  return `${PREFIX_SENSITIVITY_ANALYSIS_SERVER_QUERIES}/v1/`;
+}
+function fetchSensitivityAnalysisProviders() {
+  console.info("fetch sensitivity analysis providers");
+  const url = `${getSensiUrl()}providers`;
+  console.debug(url);
+  return backendFetchJson(url);
+}
+function getSensitivityAnalysisParameters(studyUuid) {
+  console.info("get sensitivity analysis parameters");
+  const url = `${getStudyUrl(studyUuid)}/sensitivity-analysis/parameters`;
+  console.debug(url);
+  return backendFetchJson(url);
+}
+function fetchSensitivityAnalysisParameters(parameterUuid) {
+  console.info("get sensitivity analysis parameters");
+  const url = `${GET_PARAMETERS_PREFIX}/${parameterUuid}`;
+  console.debug(url);
+  return backendFetchJson(url);
+}
+function setSensitivityAnalysisParameters(studyUuid, newParams) {
+  console.info("set sensitivity analysis parameters");
+  const url = `${getStudyUrl(studyUuid)}/sensitivity-analysis/parameters`;
+  console.debug(url);
+  return backendFetch(url, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    body: newParams ? JSON.stringify(newParams) : null
+  });
+}
+function getSensitivityAnalysisFactorsCount(studyUuid, currentNodeUuid, currentRootNetworkUuid, isInjectionsSet, newParams) {
+  console.info("get sensitivity analysis parameters computing count");
+  const urlSearchParams = new URLSearchParams();
+  const jsoned = JSON.stringify(isInjectionsSet);
+  urlSearchParams.append("isInjectionsSet", jsoned);
+  Object.keys(newParams).filter((key) => newParams[key]).forEach((key) => urlSearchParams.append(`ids[${key}]`, newParams[key]));
+  const url = `${getStudyUrlWithNodeUuidAndRootNetworkUuid(studyUuid, currentNodeUuid, currentRootNetworkUuid)}
+      /sensitivity-analysis/factors-count?${urlSearchParams}`;
+  console.debug(url);
+  return backendFetch(url, {
+    method: "GET"
+  });
+}
+function fetchDefaultSensitivityAnalysisProvider() {
+  console.info("fetch default sensitivity analysis provider");
+  const url = `${PREFIX_STUDY_QUERIES}/v1/sensitivity-analysis-default-provider`;
+  console.debug(url);
+  return backendFetchText(url);
+}
+function updateSensitivityAnalysisParameters(parameterUuid, newParams) {
+  console.info("set security analysis parameters");
+  const setSecurityAnalysisParametersUrl = `${getSensiUrl()}parameters/${parameterUuid}`;
+  console.debug(setSecurityAnalysisParametersUrl);
+  return backendFetch(setSecurityAnalysisParametersUrl, {
+    method: "PUT",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    body: newParams ? JSON.stringify(newParams) : null
+  });
+}
+export {
+  fetchDefaultSensitivityAnalysisProvider,
+  fetchSensitivityAnalysisParameters,
+  fetchSensitivityAnalysisProviders,
+  getSensiUrl,
+  getSensitivityAnalysisFactorsCount,
+  getSensitivityAnalysisParameters,
+  getStudyUrl,
+  getStudyUrlWithNodeUuidAndRootNetworkUuid,
+  setSensitivityAnalysisParameters,
+  updateSensitivityAnalysisParameters
+};