@gridsuite/commons-ui 0.150.0 → 0.151.0

package/dist/components/parameters/sensi/constants.d.ts

@@ -26,4 +26,9 @@ export declare const PARAMETER_SENSI_PST = "sensitivityPST";
 export declare const PARAMETER_SENSI_NODES = "sensitivityNodes";
 export declare const CONTAINER_ID = "containerId";
 export declare const CONTAINER_NAME = "containerName";
-export declare const COUNT = "count";
+export declare const MAX_RESULTS_COUNT = 500000;
+export declare const MAX_VARIABLES_COUNT = 5000;
+export declare const DEFAULT_FACTOR_COUNT: {
+    resultCount: number;
+    variableCount: number;
+};

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

@@ -20,20 +20,24 @@ const PARAMETER_SENSI_PST = "sensitivityPST";
 const PARAMETER_SENSI_NODES = "sensitivityNodes";
 const CONTAINER_ID = "containerId";
 const CONTAINER_NAME = "containerName";
-const COUNT = "count";
+const MAX_RESULTS_COUNT = 5e5;
+const MAX_VARIABLES_COUNT = 5e3;
+const DEFAULT_FACTOR_COUNT = { resultCount: 0, variableCount: 0 };
 export {
   ACTIVATED,
   ANGLE_FLOW_SENSITIVITY_VALUE_THRESHOLD,
   CONTAINER_ID,
   CONTAINER_NAME,
   CONTINGENCIES,
-  COUNT,
+  DEFAULT_FACTOR_COUNT,
   DISTRIBUTION_TYPE,
   EQUIPMENTS_IN_VOLTAGE_REGULATION,
   FLOW_FLOW_SENSITIVITY_VALUE_THRESHOLD,
   FLOW_VOLTAGE_SENSITIVITY_VALUE_THRESHOLD,
   HVDC_LINES,
   INJECTIONS,
+  MAX_RESULTS_COUNT,
+  MAX_VARIABLES_COUNT,
   MONITORED_BRANCHES,
   PARAMETER_SENSI_HVDC,
   PARAMETER_SENSI_INJECTION,

package/dist/components/parameters/sensi/sensitivity-analysis-parameters-factor-count.d.ts

@@ -0,0 +1,8 @@
+interface SensitivityAnalysisParametersFactorCountProps {
+    count: number;
+    maxCount: number;
+    messageId: string;
+    isLoading: boolean;
+}
+export declare function SensitivityAnalysisParametersFactorCount(props: SensitivityAnalysisParametersFactorCountProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/parameters/sensi/sensitivity-analysis-parameters-factor-count.js

@@ -0,0 +1,53 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { Box, CircularProgress } from "@mui/material";
+import { FormattedMessage } from "react-intl";
+import { ErrorOutline } from "@mui/icons-material";
+const styles = {
+  circularProgress: (theme) => ({
+    display: "flex",
+    marginRight: theme.spacing(1),
+    color: theme.palette.primary.main
+  }),
+  errorOutlineIcon: (theme) => ({
+    marginRight: theme.spacing(1),
+    color: theme.palette.error.main,
+    display: "flex"
+  }),
+  textInfo: (theme) => ({
+    color: theme.palette.primary.main,
+    display: "flex"
+  }),
+  textInitial: {
+    color: "grey"
+  },
+  textAlert: (theme) => ({
+    color: theme.palette.error.main,
+    display: "flex"
+  })
+};
+const renderLoadingState = () => {
+  return /* @__PURE__ */ jsx(Box, { sx: styles.textInfo, children: /* @__PURE__ */ jsx(CircularProgress, { size: "1em", sx: styles.circularProgress }) });
+};
+function SensitivityAnalysisParametersFactorCount(props) {
+  const { count, maxCount, messageId, isLoading } = props;
+  if (isLoading) return renderLoadingState();
+  const isOverMillion = count > 999999;
+  const isOverLimit = count > maxCount;
+  const isZero = count === 0;
+  const isAlert = isOverMillion || isOverLimit;
+  let sx = styles.textInfo;
+  if (isAlert) {
+    sx = styles.textAlert;
+  } else if (isZero) {
+    sx = styles.textInitial;
+  }
+  const displayCount = isOverMillion ? "999999" : count.toString();
+  const suffix = isOverMillion ? "+" : "";
+  return /* @__PURE__ */ jsxs(Box, { sx, children: [
+    isAlert && /* @__PURE__ */ jsx(ErrorOutline, { sx: styles.errorOutlineIcon }),
+    /* @__PURE__ */ jsx(FormattedMessage, { id: messageId, values: { count: displayCount, suffix } })
+  ] });
+}
+export {
+  SensitivityAnalysisParametersFactorCount
+};

package/dist/components/parameters/sensi/sensitivity-analysis-parameters-form.js

@@ -108,9 +108,8 @@ function SensitivityAnalysisParametersForm({
                   SensitivityParametersSelector,
                   {
                     onFormChanged: sensitivityAnalysisMethods.onFormChanged,
-                    onChangeParams: sensitivityAnalysisMethods.onChangeParams,
-                    launchLoader: sensitivityAnalysisMethods.launchLoader,
-                    analysisComputeComplexity: sensitivityAnalysisMethods.analysisComputeComplexity,
+                    isLoading: sensitivityAnalysisMethods.isLoading,
+                    factorsCount: sensitivityAnalysisMethods.factorsCount,
                     isDeveloperMode,
                     isStudyLinked: sensitivityAnalysisMethods.isStudyLinked
                   }

package/dist/components/parameters/sensi/sensitivity-analysis-parameters-inline.js

@@ -73,7 +73,7 @@ function SensitivityAnalysisParametersInline({
           reset(sensitivityAnalysisMethods.fromSensitivityAnalysisParamsDataToFormValues(parameters), {
             keepDefaultValues: true
           });
-          sensitivityAnalysisMethods.initRowsCount();
+          sensitivityAnalysisMethods.onFormChanged();
         }).catch((error) => {
           snackWithFallback(snackError, error, { headerId: "paramsRetrievingError" });
         });
@@ -90,7 +90,7 @@ function SensitivityAnalysisParametersInline({
   const clear = useCallback(() => {
     reset(sensitivityAnalysisMethods.emptyFormData);
     resetSensitivityAnalysisParameters();
-    sensitivityAnalysisMethods.setAnalysisComputeComplexity(0);
+    sensitivityAnalysisMethods.resetFactorsCount();
     setOpenResetConfirmation(false);
   }, [reset, sensitivityAnalysisMethods, resetSensitivityAnalysisParameters]);
   const handleResetClick = useCallback(() => {
@@ -125,7 +125,7 @@ function SensitivityAnalysisParametersInline({
                   {
                     onClick: handleSubmit(sensitivityAnalysisMethods.onSaveInline),
                     variant: "outlined",
-                    disabled: sensitivityAnalysisMethods.launchLoader || sensitivityAnalysisMethods.isMaxReached,
+                    disabled: sensitivityAnalysisMethods.isLoading || sensitivityAnalysisMethods.isMaxResultsReached || sensitivityAnalysisMethods.isMaxVariablesReached,
                     children: /* @__PURE__ */ jsx(FormattedMessage, { id: "validate" })
                   }
                 )

package/dist/components/parameters/sensi/sensitivity-parameters-selector.d.ts

@@ -1,16 +1,10 @@
-/**
- * Copyright (c) 2023, RTE (http://www.rte-france.com)
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
+import { FactorsCount } from '../../../utils';
 interface SensitivityParametersSelectorProps {
-    onFormChanged: (hasFormChanged: boolean) => void;
-    onChangeParams: (a: any, b: any, c: number) => void;
-    launchLoader: boolean;
-    analysisComputeComplexity: number;
+    onFormChanged: () => void;
+    isLoading: boolean;
+    factorsCount: FactorsCount;
     isDeveloperMode: boolean;
     isStudyLinked: boolean;
 }
-declare function SensitivityParametersSelector({ onFormChanged, onChangeParams, launchLoader, analysisComputeComplexity, isDeveloperMode, isStudyLinked, }: Readonly<SensitivityParametersSelectorProps>): import("react/jsx-runtime").JSX.Element;
+declare function SensitivityParametersSelector({ onFormChanged, isLoading, factorsCount, isDeveloperMode, isStudyLinked, }: Readonly<SensitivityParametersSelectorProps>): import("react/jsx-runtime").JSX.Element;
 export default SensitivityParametersSelector;

package/dist/components/parameters/sensi/sensitivity-parameters-selector.js

@@ -1,13 +1,13 @@
 import { jsxs, jsx, Fragment } from "react/jsx-runtime";
-import { useState, useCallback, useEffect, useMemo } from "react";
+import { useState, useCallback, useEffect } from "react";
 import { useIntl, FormattedMessage } from "react-intl";
-import { Grid, Tabs, Tab, Box, CircularProgress } from "@mui/material";
-import { ErrorOutline } from "@mui/icons-material";
+import { Grid, Box, Tabs, Tab } from "@mui/material";
 import { SensiTabValues, SensiBranchesTabValues, SensiInjectionsSet, SensiInjection, SensiHvdcs, SensiPsts, SensiNodes, COLUMNS_DEFINITIONS_INJECTIONS_SET, COLUMNS_DEFINITIONS_INJECTIONS, COLUMNS_DEFINITIONS_HVDCS, COLUMNS_DEFINITIONS_PSTS, COLUMNS_DEFINITIONS_NODES } from "./columns-definitions.js";
 import { SensitivityTable } from "./sensitivity-table.js";
 import { TabPanel } from "../common/parameters.js";
 import "../../../utils/conversionUtils.js";
 import "../../../utils/types/equipmentType.js";
+import "@mui/icons-material";
 import "../../../utils/yupConfig.js";
 import "localized-countries";
 import "localized-countries/data/fr";
@@ -35,28 +35,9 @@ import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
 import "react-querybuilder";
 import "../common/widget/parameter-line-slider.js";
 import "../common/limitreductions/columns-definitions.js";
+import { SensitivityAnalysisParametersFactorCount } from "./sensitivity-analysis-parameters-factor-count.js";
+import { MAX_VARIABLES_COUNT, MAX_RESULTS_COUNT } from "./constants.js";
 const styles = {
-  circularProgress: (theme) => ({
-    display: "flex",
-    marginRight: theme.spacing(1),
-    color: theme.palette.primary.main
-  }),
-  errorOutlineIcon: (theme) => ({
-    marginRight: theme.spacing(1),
-    color: theme.palette.error.main,
-    display: "flex"
-  }),
-  textInfo: (theme) => ({
-    color: theme.palette.primary.main,
-    display: "flex"
-  }),
-  textInitial: {
-    color: "grey"
-  },
-  textAlert: (theme) => ({
-    color: theme.palette.error.main,
-    display: "flex"
-  }),
   boxContent: {
     display: "flex",
     alignItems: "end",
@@ -68,9 +49,8 @@ const styles = {
 };
 function SensitivityParametersSelector({
   onFormChanged,
-  onChangeParams,
-  launchLoader,
-  analysisComputeComplexity,
+  isLoading,
+  factorsCount,
   isDeveloperMode,
   isStudyLinked
 }) {
@@ -114,76 +94,71 @@ function SensitivityParametersSelector({
     },
     [intl]
   );
-  const renderComputingEventLoading = () => {
-    return /* @__PURE__ */ jsxs(Box, { sx: styles.textInfo, children: [
-      /* @__PURE__ */ jsx(CircularProgress, { size: "1em", sx: styles.circularProgress }),
-      /* @__PURE__ */ jsx(FormattedMessage, { id: "loadingComputing" })
-    ] });
-  };
   useEffect(() => {
     if (!isDeveloperMode) {
       setTabValue(SensiTabValues.SensitivityBranches);
     }
   }, [isDeveloperMode]);
-  const ComputingEvent = useMemo(() => {
-    const renderComputingEvent = () => {
-      if (analysisComputeComplexity < 999999 && analysisComputeComplexity > 5e5) {
-        return /* @__PURE__ */ jsxs(Box, { sx: styles.textAlert, children: [
-          /* @__PURE__ */ jsx(ErrorOutline, { sx: styles.errorOutlineIcon }),
+  return /* @__PURE__ */ jsxs(Grid, { sx: { width: "100%" }, children: [
+    /* @__PURE__ */ jsxs(Box, { sx: { display: "flex", justifyContent: "space-between", alignItems: "center", width: "100%" }, children: [
+      /* @__PURE__ */ jsx(Tabs, { value: tabValue, onChange: handleTabChange, children: tabInfo.map((tab, index) => /* @__PURE__ */ jsx(
+        Tab,
+        {
+          label: /* @__PURE__ */ jsx(FormattedMessage, { id: tab.label }),
+          value: index,
+          sx: {
+            fontSize: 17,
+            fontWeight: "bold",
+            textTransform: "capitalize"
+          }
+        },
+        tab.label
+      )) }),
+      isStudyLinked && /* @__PURE__ */ jsxs(Box, { sx: { display: "flex", alignItems: "center", gap: 2 }, children: [
+        /* @__PURE__ */ jsxs(Box, { sx: { ...styles.boxContent, minWidth: 300 }, children: [
+          /* @__PURE__ */ jsx(
+            SensitivityAnalysisParametersFactorCount,
+            {
+              count: factorsCount.variableCount,
+              maxCount: MAX_VARIABLES_COUNT,
+              messageId: "sensitivityAnalysis.simulatedVariables",
+              isLoading
+            }
+          ),
+          /* @__PURE__ */ jsx(FormattedMessage, { id: "sensitivityAnalysis.separator" }),
           /* @__PURE__ */ jsx(
             FormattedMessage,
             {
-              id: "sensitivityAnalysis.simulatedComputations",
+              id: "sensitivityAnalysis.maximumFactorsCount",
               values: {
-                count: analysisComputeComplexity.toString()
+                maxFactorsCount: MAX_VARIABLES_COUNT.toLocaleString()
               }
             }
           )
-        ] });
-      }
-      if (analysisComputeComplexity > 999999) {
-        return /* @__PURE__ */ jsxs(Box, { sx: styles.textAlert, children: [
-          /* @__PURE__ */ jsx(ErrorOutline, { sx: styles.errorOutlineIcon }),
-          /* @__PURE__ */ jsx(FormattedMessage, { id: "sensitivityAnalysis.moreThanOneMillionComputations" })
-        ] });
-      }
-      if (analysisComputeComplexity === 0) {
-        return /* @__PURE__ */ jsx(Box, { sx: styles.textInitial, children: /* @__PURE__ */ jsx(
-          FormattedMessage,
-          {
-            id: "sensitivityAnalysis.simulatedComputations",
-            values: {
-              count: analysisComputeComplexity.toString()
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { sx: { ...styles.boxContent, minWidth: 300 }, children: [
+          /* @__PURE__ */ jsx(
+            SensitivityAnalysisParametersFactorCount,
+            {
+              count: factorsCount.resultCount,
+              maxCount: MAX_RESULTS_COUNT,
+              messageId: "sensitivityAnalysis.simulatedResults",
+              isLoading
             }
-          }
-        ) });
-      }
-      return /* @__PURE__ */ jsx(Box, { sx: styles.textInfo, children: /* @__PURE__ */ jsx(
-        FormattedMessage,
-        {
-          id: "sensitivityAnalysis.simulatedComputations",
-          values: {
-            count: analysisComputeComplexity.toString()
-          }
-        }
-      ) });
-    };
-    return launchLoader ? renderComputingEventLoading() : renderComputingEvent();
-  }, [analysisComputeComplexity, launchLoader]);
-  return /* @__PURE__ */ jsxs(Grid, { sx: { width: "100%" }, children: [
-    /* @__PURE__ */ jsx(Tabs, { value: tabValue, onChange: handleTabChange, children: tabInfo.map((tab, index) => /* @__PURE__ */ jsx(
-      Tab,
-      {
-        label: /* @__PURE__ */ jsx(FormattedMessage, { id: tab.label }),
-        value: index,
-        sx: {
-          fontSize: 17,
-          fontWeight: "bold",
-          textTransform: "capitalize"
-        }
-      },
-      tab.label
-    )) }),
+          ),
+          /* @__PURE__ */ jsx(FormattedMessage, { id: "sensitivityAnalysis.separator" }),
+          /* @__PURE__ */ jsx(
+            FormattedMessage,
+            {
+              id: "sensitivityAnalysis.maximumFactorsCount",
+              values: {
+                maxFactorsCount: MAX_RESULTS_COUNT.toLocaleString()
+              }
+            }
+          )
+        ] })
+      ] })
+    ] }),
     tabInfo.map((tab, index) => /* @__PURE__ */ jsxs(TabPanel, { value: tabValue, index, sx: { paddingTop: 1 }, children: [
       tabValue === SensiTabValues.SensitivityBranches && tab.subTabs && /* @__PURE__ */ jsxs(Fragment, { children: [
         /* @__PURE__ */ jsx(Tabs, { value: subTabValue, onChange: handleSubTabChange, children: tab.subTabs.map((subTab, subIndex) => /* @__PURE__ */ jsx(
@@ -198,11 +173,6 @@ function SensitivityParametersSelector({
           },
           subTab.label
         )) }),
-        isStudyLinked && /* @__PURE__ */ jsxs(Box, { sx: styles.boxContent, children: [
-          ComputingEvent,
-          /* @__PURE__ */ jsx(FormattedMessage, { id: "sensitivityAnalysis.separator" }),
-          /* @__PURE__ */ jsx(FormattedMessage, { id: "sensitivityAnalysis.maximumSimulatedComputations" })
-        ] }),
         /* @__PURE__ */ jsx(TabPanel, { index: SensiBranchesTabValues.SensiInjectionsSet, value: subTabValue, children: /* @__PURE__ */ jsx(
           SensitivityTable,
           {
@@ -213,8 +183,7 @@ function SensitivityParametersSelector({
             useFieldArrayOutput: useFieldArrayOutputInjectionsSet,
             createRows: rowDataInjectionsSet,
             tableHeight: 300,
-            onFormChanged,
-            onChangeParams
+            onFormChanged
           }
         ) }),
         /* @__PURE__ */ jsx(TabPanel, { index: SensiBranchesTabValues.SensiInjection, value: subTabValue, children: /* @__PURE__ */ jsx(
@@ -225,8 +194,7 @@ function SensitivityParametersSelector({
             useFieldArrayOutput: useFieldArrayOutputInjections,
             createRows: rowDataInjections,
             tableHeight: 300,
-            onFormChanged,
-            onChangeParams
+            onFormChanged
           }
         ) }),
         /* @__PURE__ */ jsx(TabPanel, { index: SensiBranchesTabValues.SensiHVDC, value: subTabValue, children: /* @__PURE__ */ jsx(
@@ -237,8 +205,7 @@ function SensitivityParametersSelector({
             useFieldArrayOutput: useFieldArrayOutputHvdc,
             createRows: rowDataHvdc,
             tableHeight: 300,
-            onFormChanged,
-            onChangeParams
+            onFormChanged
           }
         ) }),
         /* @__PURE__ */ jsx(TabPanel, { index: SensiBranchesTabValues.SensiPST, value: subTabValue, children: /* @__PURE__ */ jsx(
@@ -249,8 +216,7 @@ function SensitivityParametersSelector({
             useFieldArrayOutput: useFieldArrayOutputPst,
             createRows: rowDataPst,
             tableHeight: 300,
-            onFormChanged,
-            onChangeParams
+            onFormChanged
           }
         ) })
       ] }),
@@ -262,8 +228,7 @@ function SensitivityParametersSelector({
           useFieldArrayOutput: useFieldArrayOutputNodes,
           createRows: rowDataNodes,
           tableHeight: 367,
-          onFormChanged,
-          onChangeParams
+          onFormChanged
         }
       )
     ] }, tab.label))

package/dist/components/parameters/sensi/sensitivity-table.d.ts

@@ -8,8 +8,7 @@ interface SensitivityTableProps {
     createRows: (a: number) => void;
     disableAdd?: boolean;
     disableDelete?: boolean;
-    onFormChanged: (a: boolean) => void;
-    onChangeParams: (a: Record<string, any>, b: string, c: number) => void;
+    onFormChanged: () => void;
 }
-export declare function SensitivityTable({ arrayFormName, useFieldArrayOutput, columnsDefinition, tableHeight, createRows, disableAdd, disableDelete, onFormChanged, onChangeParams, }: Readonly<SensitivityTableProps>): import("react/jsx-runtime").JSX.Element;
+export declare function SensitivityTable({ arrayFormName, useFieldArrayOutput, columnsDefinition, tableHeight, createRows, disableAdd, disableDelete, onFormChanged, }: Readonly<SensitivityTableProps>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/parameters/sensi/sensitivity-table.js

@@ -1,11 +1,10 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { TableContainer, Table, TableHead, TableRow, TableCell, Box, Tooltip, IconButton, TableBody } from "@mui/material";
 import { AddCircle } from "@mui/icons-material";
-import { useCallback } from "react";
+import { useRef, useCallback } from "react";
 import { useIntl } from "react-intl";
 import { useFormContext } from "react-hook-form";
 import { TableRowComponent } from "./table-row.js";
-import { ACTIVATED, MONITORED_BRANCHES, INJECTIONS, HVDC_LINES, PSTS, COUNT } from "./constants.js";
 import "@hello-pangea/dnd";
 import { MAX_ROWS_NUMBER } from "../../dnd-table/dnd-table.type.js";
 import "../../overflowableText/OverflowableText.js";
@@ -31,6 +30,7 @@ import "../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";
 import "uuid";
 import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
 import "react-querybuilder";
+import { isValidSensiParameterRow } from "./utils.js";
 function SensitivityTable({
   arrayFormName,
   useFieldArrayOutput,
@@ -39,55 +39,45 @@ function SensitivityTable({
   createRows,
   disableAdd,
   disableDelete = false,
-  onFormChanged,
-  onChangeParams
+  onFormChanged
 }) {
   const intl = useIntl();
   const { getValues } = useFormContext();
   const { fields: currentRows, append, remove } = useFieldArrayOutput;
+  const validRowCountRef = useRef(
+    (getValues(arrayFormName) || []).filter((row) => isValidSensiParameterRow(row)).length
+  );
+  const handleRowChanged = useCallback(
+    (index) => {
+      const currentRowValues = getValues(arrayFormName);
+      const row = currentRowValues[index];
+      const currentValidRowCount = currentRowValues.filter(
+        (r) => isValidSensiParameterRow(r)
+      ).length;
+      const previousValidRowCount = validRowCountRef.current;
+      validRowCountRef.current = currentValidRowCount;
+      if (currentValidRowCount !== previousValidRowCount || isValidSensiParameterRow(row)) {
+        onFormChanged();
+      }
+    },
+    [getValues, arrayFormName, onFormChanged]
+  );
   const handleAddRowsButton = useCallback(() => {
     if (currentRows.length >= MAX_ROWS_NUMBER) {
       return;
     }
     append(createRows(1));
   }, [append, createRows, currentRows.length]);
-  const fetchCount = useCallback(
-    (providedArrayFormName, index, source) => {
-      const row = getValues(providedArrayFormName)[index];
-      const isActivated = row[ACTIVATED];
-      const hasMonitoredBranches = row[MONITORED_BRANCHES]?.length > 0;
-      const hasInjections = row[INJECTIONS]?.length > 0 || row[HVDC_LINES]?.length > 0 || row[PSTS]?.length > 0;
-      if (source === "switch" && hasMonitoredBranches && hasInjections) {
-        if (isActivated) {
-          onChangeParams(row, providedArrayFormName, index);
-        } else {
-          onFormChanged(true);
-        }
-      }
-      if (source === "directory" && isActivated) {
-        if (hasMonitoredBranches && hasInjections) {
-          onChangeParams(row, providedArrayFormName, index);
-        } else if ((!hasMonitoredBranches || !hasInjections) && row.count === 0) {
-          onFormChanged(false);
-        } else if (!hasMonitoredBranches || !hasInjections) {
-          onFormChanged(true);
-        }
-      }
-    },
-    [onChangeParams, onFormChanged, getValues]
-  );
   const handleDeleteButton = useCallback(
     (index) => {
       const currentRowsValues = getValues(arrayFormName);
-      let isFormChanged = false;
       if (index >= 0 && index < currentRowsValues.length) {
-        if (currentRowsValues[index][COUNT] && currentRowsValues[index][ACTIVATED]) {
-          isFormChanged = true;
-        }
+        const wasValid = isValidSensiParameterRow(currentRowsValues[index]);
         remove(index);
-      }
-      if (isFormChanged) {
-        onFormChanged(true);
+        if (wasValid) {
+          validRowCountRef.current -= 1;
+          onFormChanged();
+        }
       }
     },
     [arrayFormName, getValues, onFormChanged, remove]
@@ -120,7 +110,7 @@ function SensitivityTable({
             index,
             handleDeleteButton,
             disableDelete,
-            fetchCount
+            handleRowChanged
           },
           row.id
         )) })

package/dist/components/parameters/sensi/table-cell.d.ts

@@ -4,5 +4,5 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
-declare function EditableTableCell(arrayFormName: string, rowIndex: number, column: any, onRowChanged: (a: boolean, source: string) => void): import("react/jsx-runtime").JSX.Element;
+declare function EditableTableCell(arrayFormName: string, rowIndex: number, column: any, onRowChanged: () => void): import("react/jsx-runtime").JSX.Element;
 export default EditableTableCell;

package/dist/components/parameters/sensi/table-cell.js

@@ -32,12 +32,6 @@ import "uuid";
 import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
 import "react-querybuilder";
 function EditableTableCell(arrayFormName, rowIndex, column, onRowChanged) {
-  const handleDirectoryItemsChange = () => {
-    onRowChanged(true, "directory");
-  };
-  const handleSwitchInputChange = () => {
-    onRowChanged(true, "switch");
-  };
   return /* @__PURE__ */ jsxs(
     TableCell,
     {
@@ -55,7 +49,7 @@ function EditableTableCell(arrayFormName, rowIndex, column, onRowChanged) {
             hideErrorMessage: true,
             label: void 0,
             itemFilter: void 0,
-            onRowChanged: handleDirectoryItemsChange
+            onRowChanged
           }
         ),
         column.menuItems && /* @__PURE__ */ jsx(
@@ -67,7 +61,7 @@ function EditableTableCell(arrayFormName, rowIndex, column, onRowChanged) {
             fullWidth: true
           }
         ),
-        column.checkboxItems && /* @__PURE__ */ jsx("span", { onChange: handleSwitchInputChange, children: /* @__PURE__ */ jsx(SwitchInput, { name: `${arrayFormName}[${rowIndex}].${column.dataKey}` }) }),
+        column.checkboxItems && /* @__PURE__ */ jsx("span", { onChange: onRowChanged, children: /* @__PURE__ */ jsx(SwitchInput, { name: `${arrayFormName}[${rowIndex}].${column.dataKey}` }) }),
         column.floatItems && /* @__PURE__ */ jsx(FloatInput, { name: `${arrayFormName}[${rowIndex}].${column.dataKey}` }),
         column.textItems && /* @__PURE__ */ jsx(
           TextInput,

package/dist/components/parameters/sensi/table-row.d.ts

@@ -5,7 +5,7 @@ interface TableRowComponentProps {
     index: number;
     handleDeleteButton: (index: number) => void;
     disableDelete: boolean;
-    fetchCount: (a: string, b: number, c: string) => void;
+    handleRowChanged: (a: number) => void;
 }
-export declare function TableRowComponent({ arrayFormName, columnsDefinition, index, handleDeleteButton, disableDelete, fetchCount, }: Readonly<TableRowComponentProps>): import("react/jsx-runtime").JSX.Element;
+export declare function TableRowComponent({ arrayFormName, columnsDefinition, index, handleDeleteButton, disableDelete, handleRowChanged, }: Readonly<TableRowComponentProps>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/parameters/sensi/table-row.js

@@ -10,21 +10,19 @@ function TableRowComponent({
   index,
   handleDeleteButton,
   disableDelete = false,
-  fetchCount
+  handleRowChanged
 }) {
   const [isHover, setIsHover] = useState(false);
   const intl = useIntl();
   function handleHover(enter) {
     return setIsHover(enter);
   }
-  const handleRowChanged = (isChanged, source) => {
-    if (isChanged) {
-      fetchCount(arrayFormName, index, source);
-    }
+  const handleCellChanged = () => {
+    handleRowChanged(index);
   };
   return /* @__PURE__ */ jsxs(TableRow, { onMouseEnter: () => handleHover(true), onMouseLeave: () => handleHover(false), children: [
     columnsDefinition.map(
-      (column) => EditableTableCell(arrayFormName, index, column, handleRowChanged)
+      (column) => EditableTableCell(arrayFormName, index, column, handleCellChanged)
     ),
     !disableDelete && /* @__PURE__ */ jsx(TableCell, { sx: { width: "5rem", textAlign: "center" }, children: isHover && /* @__PURE__ */ jsx(
       Tooltip,

package/dist/components/parameters/sensi/use-sensitivity-analysis-parameters.d.ts

@@ -1,10 +1,8 @@
 import { UseFormReturn } from 'react-hook-form';
 import { ObjectSchema } from 'yup';
-import { Dispatch, SetStateAction } from 'react';
 import { UUID } from 'node:crypto';
 import { ComputingType } from '../common';
-import { SensitivityAnalysisParametersInfos, UseParametersBackendReturnProps } from '../../../utils';
-type SubTabsValues = 'sensitivityInjectionsSet' | 'sensitivityInjection' | 'sensitivityHVDC' | 'sensitivityPST';
+import { FactorsCount, SensitivityAnalysisParametersInfos, UseParametersBackendReturnProps } from '../../../utils';
 export interface UseSensitivityAnalysisParametersReturn {
     formMethods: UseFormReturn<any>;
     formSchema: ObjectSchema<any>;
@@ -19,14 +17,13 @@ export interface UseSensitivityAnalysisParametersReturn {
     isStudyLinked: boolean;
     onSaveInline: (formData: Record<string, any>) => void;
     onSaveDialog: (formData: Record<string, any>) => void;
-    isMaxReached: boolean;
-    launchLoader: boolean;
-    initRowsCount: () => void;
-    onFormChanged: (formChanged: boolean) => void;
-    onChangeParams: (row: any, arrayFormName: SubTabsValues, index: number) => void;
+    isMaxResultsReached: boolean;
+    isMaxVariablesReached: boolean;
+    isLoading: boolean;
+    onFormChanged: () => void;
     emptyFormData: Record<string, unknown>;
-    analysisComputeComplexity: number;
-    setAnalysisComputeComplexity: Dispatch<SetStateAction<number>>;
+    factorsCount: FactorsCount;
+    resetFactorsCount: () => void;
 }
 type UseSensitivityAnalysisParametersFormProps = {
     name: string;