@gridsuite/commons-ui 0.112.0 → 0.113.0

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

@@ -0,0 +1,274 @@
+import { jsxs, jsx, Fragment } from "react/jsx-runtime";
+import { useState, useCallback, useEffect, useMemo } from "react";
+import { useIntl, FormattedMessage } from "react-intl";
+import { Grid, Tabs, Tab, Box, CircularProgress } from "@mui/material";
+import { ErrorOutline } from "@mui/icons-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/types/equipmentType.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import { useCreateRowDataSensi } from "../../../hooks/use-create-row-data-sensi.js";
+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 "yup";
+import "../../overflowableText/OverflowableText.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 "../../../utils/conversionUtils.js";
+import "../../../utils/yupConfig.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";
+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",
+    justifyContent: "right",
+    flex: "auto",
+    flexGrow: "1",
+    whiteSpace: "pre-wrap"
+  }
+};
+function SensitivityParametersSelector({
+  onFormChanged,
+  onChangeParams,
+  launchLoader,
+  analysisComputeComplexity,
+  enableDeveloperMode,
+  isStudyLinked
+}) {
+  const intl = useIntl();
+  const [tabValue, setTabValue] = useState(SensiTabValues.SensitivityBranches);
+  const [subTabValue, setSubTabValue] = useState(SensiBranchesTabValues.SensiInjectionsSet);
+  const handleTabChange = useCallback((event, newValue) => {
+    setTabValue(newValue);
+  }, []);
+  const handleSubTabChange = useCallback((event, newValue) => {
+    setSubTabValue(newValue);
+  }, []);
+  const tabInfo = [
+    {
+      label: "SensitivityBranches",
+      subTabs: [
+        { label: "SensiInjectionsSet" },
+        { label: "SensiInjection" },
+        { label: "SensiHVDC" },
+        { label: "SensiPST" }
+      ]
+    },
+    ...enableDeveloperMode && [{ label: "SensitivityNodes" }] || []
+  ];
+  const [rowDataInjectionsSet, useFieldArrayOutputInjectionsSet] = useCreateRowDataSensi(
+    SensiInjectionsSet
+  );
+  const [rowDataInjections, useFieldArrayOutputInjections] = useCreateRowDataSensi(SensiInjection);
+  const [rowDataHvdc, useFieldArrayOutputHvdc] = useCreateRowDataSensi(SensiHvdcs);
+  const [rowDataPst, useFieldArrayOutputPst] = useCreateRowDataSensi(SensiPsts);
+  const [rowDataNodes, useFieldArrayOutputNodes] = useCreateRowDataSensi(SensiNodes);
+  const getColumnsDefinition = useCallback(
+    (sensiColumns) => {
+      if (sensiColumns) {
+        return sensiColumns.map((column) => ({
+          ...column,
+          label: intl.formatMessage({ id: column.label })
+        }));
+      }
+      return [];
+    },
+    [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 (!enableDeveloperMode) {
+      setTabValue(SensiTabValues.SensitivityBranches);
+    }
+  }, [enableDeveloperMode]);
+  const ComputingEvent = useMemo(() => {
+    const renderComputingEvent = () => {
+      if (analysisComputeComplexity < 999999 && analysisComputeComplexity > 5e5) {
+        return /* @__PURE__ */ jsxs(Box, { sx: styles.textAlert, children: [
+          /* @__PURE__ */ jsx(ErrorOutline, { sx: styles.errorOutlineIcon }),
+          /* @__PURE__ */ jsx(
+            FormattedMessage,
+            {
+              id: "sensitivityAnalysis.simulatedComputations",
+              values: {
+                count: analysisComputeComplexity.toString()
+              }
+            }
+          )
+        ] });
+      }
+      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()
+            }
+          }
+        ) });
+      }
+      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
+    )) }),
+    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(
+          Tab,
+          {
+            value: subIndex,
+            sx: {
+              fontWeight: "bold",
+              textTransform: "capitalize"
+            },
+            label: /* @__PURE__ */ jsx(FormattedMessage, { id: subTab.label })
+          },
+          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,
+          {
+            arrayFormName: `${SensiInjectionsSet.name}`,
+            columnsDefinition: getColumnsDefinition(
+              COLUMNS_DEFINITIONS_INJECTIONS_SET
+            ),
+            useFieldArrayOutput: useFieldArrayOutputInjectionsSet,
+            createRows: rowDataInjectionsSet,
+            tableHeight: 300,
+            onFormChanged,
+            onChangeParams
+          }
+        ) }),
+        /* @__PURE__ */ jsx(TabPanel, { index: SensiBranchesTabValues.SensiInjection, value: subTabValue, children: /* @__PURE__ */ jsx(
+          SensitivityTable,
+          {
+            arrayFormName: `${SensiInjection.name}`,
+            columnsDefinition: getColumnsDefinition(COLUMNS_DEFINITIONS_INJECTIONS),
+            useFieldArrayOutput: useFieldArrayOutputInjections,
+            createRows: rowDataInjections,
+            tableHeight: 300,
+            onFormChanged,
+            onChangeParams
+          }
+        ) }),
+        /* @__PURE__ */ jsx(TabPanel, { index: SensiBranchesTabValues.SensiHVDC, value: subTabValue, children: /* @__PURE__ */ jsx(
+          SensitivityTable,
+          {
+            arrayFormName: `${SensiHvdcs.name}`,
+            columnsDefinition: getColumnsDefinition(COLUMNS_DEFINITIONS_HVDCS),
+            useFieldArrayOutput: useFieldArrayOutputHvdc,
+            createRows: rowDataHvdc,
+            tableHeight: 300,
+            onFormChanged,
+            onChangeParams
+          }
+        ) }),
+        /* @__PURE__ */ jsx(TabPanel, { index: SensiBranchesTabValues.SensiPST, value: subTabValue, children: /* @__PURE__ */ jsx(
+          SensitivityTable,
+          {
+            arrayFormName: `${SensiPsts.name}`,
+            columnsDefinition: getColumnsDefinition(COLUMNS_DEFINITIONS_PSTS),
+            useFieldArrayOutput: useFieldArrayOutputPst,
+            createRows: rowDataPst,
+            tableHeight: 300,
+            onFormChanged,
+            onChangeParams
+          }
+        ) })
+      ] }),
+      tabValue === SensiTabValues.SensitivityNodes && /* @__PURE__ */ jsx(
+        SensitivityTable,
+        {
+          arrayFormName: `${SensiNodes.name}`,
+          columnsDefinition: getColumnsDefinition(COLUMNS_DEFINITIONS_NODES),
+          useFieldArrayOutput: useFieldArrayOutputNodes,
+          createRows: rowDataNodes,
+          tableHeight: 367,
+          onFormChanged,
+          onChangeParams
+        }
+      )
+    ] }, tab.label))
+  ] });
+}
+export {
+  SensitivityParametersSelector as default
+};

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

@@ -0,0 +1,15 @@
+import { UseFieldArrayReturn } from 'react-hook-form';
+import { IColumnsDef } from './columns-definitions';
+interface SensitivityTableProps {
+    arrayFormName: string;
+    useFieldArrayOutput: UseFieldArrayReturn;
+    columnsDefinition: IColumnsDef[];
+    tableHeight: number;
+    createRows: (a: number) => void;
+    disableAdd?: boolean;
+    disableDelete?: boolean;
+    onFormChanged: (a: boolean) => void;
+    onChangeParams: (a: Record<string, any>, b: string, c: number) => void;
+}
+export declare function SensitivityTable({ arrayFormName, useFieldArrayOutput, columnsDefinition, tableHeight, createRows, disableAdd, disableDelete, onFormChanged, onChangeParams, }: Readonly<SensitivityTableProps>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,134 @@
+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 { 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 "../../../utils/types/equipmentType.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "yup";
+import "../../overflowableText/OverflowableText.js";
+import "../../treeViewFinder/TreeViewFinder.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 "../../../utils/conversionUtils.js";
+import "../../../utils/yupConfig.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";
+function SensitivityTable({
+  arrayFormName,
+  useFieldArrayOutput,
+  columnsDefinition,
+  tableHeight,
+  createRows,
+  disableAdd,
+  disableDelete = false,
+  onFormChanged,
+  onChangeParams
+}) {
+  const intl = useIntl();
+  const { getValues } = useFormContext();
+  const { fields: currentRows, append, remove } = useFieldArrayOutput;
+  const handleAddRowsButton = useCallback(() => {
+    if (currentRows.length >= MAX_ROWS_NUMBER) {
+      return;
+    }
+    append(createRows(1));
+  }, [append, createRows, currentRows.length]);
+  const fetchCount = useCallback(
+    (providedArrayFormName, index, source) => {
+      var _a, _b, _c, _d;
+      const row = getValues(providedArrayFormName)[index];
+      const isActivated = row[ACTIVATED];
+      const hasMonitoredBranches = ((_a = row[MONITORED_BRANCHES]) == null ? void 0 : _a.length) > 0;
+      const hasInjections = ((_b = row[INJECTIONS]) == null ? void 0 : _b.length) > 0 || ((_c = row[HVDC_LINES]) == null ? void 0 : _c.length) > 0 || ((_d = row[PSTS]) == null ? void 0 : _d.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;
+        }
+        remove(index);
+      }
+      if (isFormChanged) {
+        onFormChanged(true);
+      }
+    },
+    [arrayFormName, getValues, onFormChanged, remove]
+  );
+  return /* @__PURE__ */ jsx(
+    TableContainer,
+    {
+      sx: {
+        height: tableHeight,
+        border: "solid 0px rgba(0,0,0,0.1)"
+      },
+      children: /* @__PURE__ */ jsxs(Table, { stickyHeader: true, size: "small", sx: { tableLayout: "fixed" }, children: [
+        /* @__PURE__ */ jsx(TableHead, { children: /* @__PURE__ */ jsxs(TableRow, { children: [
+          columnsDefinition.map((column) => /* @__PURE__ */ jsx(TableCell, { sx: { width: column.width, textAlign: "center" }, children: /* @__PURE__ */ jsx(Box, { children: column.label }) }, column.dataKey)),
+          /* @__PURE__ */ jsx(TableCell, { sx: { width: "5rem", textAlign: "center" }, children: /* @__PURE__ */ jsx(
+            Tooltip,
+            {
+              title: intl.formatMessage({
+                id: "AddRows"
+              }),
+              children: /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(IconButton, { disabled: disableAdd, onClick: handleAddRowsButton, children: /* @__PURE__ */ jsx(AddCircle, {}) }) })
+            }
+          ) })
+        ] }) }),
+        /* @__PURE__ */ jsx(TableBody, { children: currentRows.map((row, index) => /* @__PURE__ */ jsx(
+          TableRowComponent,
+          {
+            arrayFormName,
+            columnsDefinition,
+            index,
+            handleDeleteButton,
+            disableDelete,
+            fetchCount
+          },
+          row.id
+        )) })
+      ] })
+    }
+  );
+}
+export {
+  SensitivityTable
+};

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

@@ -0,0 +1,8 @@
+/**
+ * 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/.
+ */
+declare function EditableTableCell(arrayFormName: string, rowIndex: number, column: any, onRowChanged: (a: boolean, source: string) => void): import("react/jsx-runtime").JSX.Element;
+export default EditableTableCell;

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

@@ -0,0 +1,86 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { TableCell } from "@mui/material";
+import "react-intl";
+import "react";
+import "react-hook-form";
+import "../../../utils/types/equipmentType.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "@mui/icons-material";
+import "yup";
+import "../../overflowableText/OverflowableText.js";
+import { DirectoryItemsInput } from "../../inputs/reactHookForm/DirectoryItemsInput.js";
+import "../../inputs/reactHookForm/agGridTable/BottomRightButtons.js";
+import "../../customAGGrid/customAggrid.js";
+import "ag-grid-community";
+import "react-papaparse";
+import "react-csv-downloader";
+import { SwitchInput } from "../../inputs/reactHookForm/booleans/SwitchInput.js";
+import { FloatInput } from "../../inputs/reactHookForm/numbers/FloatInput.js";
+import { TextInput } from "../../inputs/reactHookForm/text/TextInput.js";
+import "../../inputs/reactHookForm/numbers/RangeInput.js";
+import { MuiSelectInput } from "../../inputs/reactHookForm/selectInputs/MuiSelectInput.js";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/yupConfig.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";
+function EditableTableCell(arrayFormName, rowIndex, column, onRowChanged) {
+  const handleDirectoryItemsChange = () => {
+    onRowChanged(true, "directory");
+  };
+  const handleSwitchInputChange = () => {
+    onRowChanged(true, "switch");
+  };
+  return /* @__PURE__ */ jsxs(
+    TableCell,
+    {
+      sx: {
+        width: column.width
+      },
+      children: [
+        column.directoryItems && /* @__PURE__ */ jsx(
+          DirectoryItemsInput,
+          {
+            name: `${arrayFormName}[${rowIndex}].${column.dataKey}`,
+            equipmentTypes: column.equipmentTypes,
+            elementType: column.elementType,
+            titleId: column.titleId,
+            hideErrorMessage: true,
+            label: void 0,
+            itemFilter: void 0,
+            onRowChanged: handleDirectoryItemsChange
+          }
+        ),
+        column.menuItems && /* @__PURE__ */ jsx(
+          MuiSelectInput,
+          {
+            name: `${arrayFormName}[${rowIndex}].${column.dataKey}`,
+            options: column.equipmentTypes,
+            size: "small",
+            fullWidth: true
+          }
+        ),
+        column.checkboxItems && /* @__PURE__ */ jsx("span", { onChange: handleSwitchInputChange, children: /* @__PURE__ */ jsx(SwitchInput, { name: `${arrayFormName}[${rowIndex}].${column.dataKey}` }) }),
+        column.floatItems && /* @__PURE__ */ jsx(FloatInput, { name: `${arrayFormName}[${rowIndex}].${column.dataKey}` }),
+        column.textItems && /* @__PURE__ */ jsx(
+          TextInput,
+          {
+            name: `${arrayFormName}[${rowIndex}].${column.dataKey}`,
+            formProps: { disabled: !column.editable }
+          }
+        )
+      ]
+    },
+    column.dataKey
+  );
+}
+export {
+  EditableTableCell as default
+};

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

@@ -0,0 +1,11 @@
+import { IColumnsDef } from './columns-definitions';
+interface TableRowComponentProps {
+    arrayFormName: string;
+    columnsDefinition: IColumnsDef[];
+    index: number;
+    handleDeleteButton: (index: number) => void;
+    disableDelete: boolean;
+    fetchCount: (a: string, b: number, c: string) => void;
+}
+export declare function TableRowComponent({ arrayFormName, columnsDefinition, index, handleDeleteButton, disableDelete, fetchCount, }: Readonly<TableRowComponentProps>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,42 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { TableRow, TableCell, Tooltip, IconButton } from "@mui/material";
+import { useState } from "react";
+import { useIntl } from "react-intl";
+import { Delete } from "@mui/icons-material";
+import EditableTableCell from "./table-cell.js";
+function TableRowComponent({
+  arrayFormName,
+  columnsDefinition,
+  index,
+  handleDeleteButton,
+  disableDelete = false,
+  fetchCount
+}) {
+  const [isHover, setIsHover] = useState(false);
+  const intl = useIntl();
+  function handleHover(enter) {
+    return setIsHover(enter);
+  }
+  const handleRowChanged = (isChanged, source) => {
+    if (isChanged) {
+      fetchCount(arrayFormName, index, source);
+    }
+  };
+  return /* @__PURE__ */ jsxs(TableRow, { onMouseEnter: () => handleHover(true), onMouseLeave: () => handleHover(false), children: [
+    columnsDefinition.map(
+      (column) => EditableTableCell(arrayFormName, index, column, handleRowChanged)
+    ),
+    !disableDelete && /* @__PURE__ */ jsx(TableCell, { sx: { width: "5rem", textAlign: "center" }, children: isHover && /* @__PURE__ */ jsx(
+      Tooltip,
+      {
+        title: intl.formatMessage({
+          id: "DeleteRows"
+        }),
+        children: /* @__PURE__ */ jsx(IconButton, { onClick: () => handleDeleteButton(index), children: /* @__PURE__ */ jsx(Delete, {}) })
+      }
+    ) })
+  ] });
+}
+export {
+  TableRowComponent
+};

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

@@ -0,0 +1,49 @@
+import { UseFormReturn } from 'react-hook-form';
+import { ObjectSchema } from 'yup';
+import { Dispatch, SetStateAction } from 'react';
+import { UUID } from 'crypto';
+import { ComputingType } from '../common';
+import { SensitivityAnalysisParametersInfos, UseParametersBackendReturnProps } from '../../../utils';
+type SubTabsValues = 'sensitivityInjectionsSet' | 'sensitivityInjection' | 'sensitivityHVDC' | 'sensitivityPST';
+export interface UseSensitivityAnalysisParametersReturn {
+    formMethods: UseFormReturn<any>;
+    formSchema: ObjectSchema<any>;
+    formattedProviders: {
+        id: string;
+        label: string;
+    }[];
+    fromSensitivityAnalysisParamsDataToFormValues: (parameters: SensitivityAnalysisParametersInfos) => any;
+    formatNewParams: (formData: Record<string, any>) => SensitivityAnalysisParametersInfos;
+    params: SensitivityAnalysisParametersInfos | null;
+    paramsLoaded: boolean;
+    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;
+    emptyFormData: Record<string, unknown>;
+    analysisComputeComplexity: number;
+    setAnalysisComputeComplexity: Dispatch<SetStateAction<number>>;
+}
+type UseSensitivityAnalysisParametersFormProps = {
+    name: string;
+    description: string | null;
+    studyUuid: null;
+    currentNodeUuid: null;
+    currentRootNetworkUuid: null;
+    parametersBackend: UseParametersBackendReturnProps<ComputingType.SENSITIVITY_ANALYSIS>;
+    parametersUuid: UUID;
+} | {
+    name: null;
+    description: null;
+    studyUuid: UUID | null;
+    currentNodeUuid: UUID | null;
+    currentRootNetworkUuid: UUID | null;
+    parametersBackend: UseParametersBackendReturnProps<ComputingType.SENSITIVITY_ANALYSIS>;
+    parametersUuid: null;
+};
+export declare const useSensitivityAnalysisParametersForm: ({ studyUuid, currentNodeUuid, currentRootNetworkUuid, parametersBackend, parametersUuid, name, description, }: UseSensitivityAnalysisParametersFormProps) => UseSensitivityAnalysisParametersReturn;
+export {};