@gridsuite/commons-ui 0.123.0 → 0.125.0

package/dist/components/flatParameters/FlatParameters.js

@@ -1,5 +1,5 @@
 import { jsx, jsxs, Fragment as Fragment$1 } from "react/jsx-runtime";
-import { useState, useCallback, Fragment } from "react";
+import { useState, useCallback, Fragment, createElement } from "react";
 import { List, ListItem, Tooltip, Typography, Divider, Select, MenuItem, TextField, IconButton, Autocomplete, Chip, Switch } from "@mui/material";
 import { Tune } from "@mui/icons-material";
 import { useIntl, FormattedMessage } from "react-intl";
@@ -274,7 +274,14 @@ function FlatParameters({
               onChange: (e, value) => onFieldChange(value, param),
               value: fieldValue,
               renderTags: (values, getTagProps) => {
-                return values.map((value, index) => /* @__PURE__ */ jsx(Chip, { label: getTranslatedValue(param.name, value), ...getTagProps({ index }) }));
+                return values.map((value, index) => /* @__PURE__ */ createElement(
+                  Chip,
+                  {
+                    label: getTranslatedValue(param.name, value),
+                    ...getTagProps({ index }),
+                    key: `chip_${value}`
+                  }
+                ));
               },
               renderInput: (inputProps) => /* @__PURE__ */ jsx(TextField, { ...inputProps, variant })
             }
@@ -292,7 +299,16 @@ function FlatParameters({
             onChange: (e, value) => onFieldChange(value, param),
             value: fieldValue,
             renderTags: (values, getTagProps) => {
-              return values.map((value, index) => /* @__PURE__ */ jsx(Chip, { id: `chip_${value}`, size: "small", label: value, ...getTagProps({ index }) }));
+              return values.map((value, index) => /* @__PURE__ */ createElement(
+                Chip,
+                {
+                  id: `chip_${value}`,
+                  size: "small",
+                  label: value,
+                  ...getTagProps({ index }),
+                  key: `chip_${value}`
+                }
+              ));
             },
             renderInput: (inputProps) => /* @__PURE__ */ jsx(TextField, { ...inputProps, variant })
           }

package/dist/components/parameters/common/computing-type.js

@@ -26,6 +26,8 @@ const formatComputingTypeLabel = (type) => {
       return "NonEvacuatedEnergy";
     case "SHORT_CIRCUIT":
       return "ShortCircuit";
+    case "SHORT_CIRCUIT_ONE_BUS":
+      return "OneBusShortCircuitAnalysis";
     case "VOLTAGE_INITIALIZATION":
       return "VoltageInit";
     case "DYNAMIC_SIMULATION":

package/dist/components/parameters/common/limitreductions/columns-definitions.d.ts

@@ -44,9 +44,9 @@ export declare const TAB_INFO: {
     developerModeOnly: boolean;
 }[];
 export interface LimitReductionIColumnsDef {
-    label: string;
+    label: React.ReactNode;
     dataKey: string;
-    tooltip: string;
+    tooltip: React.ReactNode;
     width?: string;
 }
 export declare const COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS: LimitReductionIColumnsDef[];

package/dist/components/parameters/common/limitreductions/limit-reduction-table-cell.d.ts

@@ -1,5 +1,6 @@
-import { LimitReductionIColumnsDef } from './columns-definitions';
-export declare function LimitReductionTableCell({ rowIndex, column, }: Readonly<{
+import { LimitReductionIColumnsDef, ILimitReductionsByVoltageLevel } from './columns-definitions';
+export declare function LimitReductionTableCell({ rowIndex, column, limits, }: Readonly<{
     rowIndex: number;
     column: LimitReductionIColumnsDef;
+    limits: ILimitReductionsByVoltageLevel[];
 }>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/common/limitreductions/limit-reduction-table-cell.js

@@ -1,7 +1,7 @@
 import { jsx } from "react/jsx-runtime";
-import { TableCell } from "@mui/material";
+import { Tooltip, TableCell } from "@mui/material";
+import { FormattedMessage } from "react-intl";
 import { VOLTAGE_LEVELS_FORM, LIMIT_REDUCTIONS_FORM } from "./columns-definitions.js";
-import "react-intl";
 import "react";
 import "react-hook-form";
 import "../../../../utils/types/equipmentType.js";
@@ -32,9 +32,25 @@ import "../../../inputs/reactQueryBuilder/PropertyValueEditor.js";
 import "react-querybuilder";
 function LimitReductionTableCell({
   rowIndex,
-  column
+  column,
+  limits
 }) {
-  return /* @__PURE__ */ jsx(TableCell, { sx: { fontWeight: "bold" }, children: column.dataKey === VOLTAGE_LEVELS_FORM ? /* @__PURE__ */ jsx(RawReadOnlyInput, { name: `${LIMIT_REDUCTIONS_FORM}[${rowIndex}].${column.dataKey}` }) : /* @__PURE__ */ jsx(FloatInput, { name: `${LIMIT_REDUCTIONS_FORM}[${rowIndex}].${column.dataKey}` }) });
+  return column.dataKey === VOLTAGE_LEVELS_FORM && limits[rowIndex] ? /* @__PURE__ */ jsx(
+    Tooltip,
+    {
+      title: /* @__PURE__ */ jsx(
+        FormattedMessage,
+        {
+          id: "VoltageRangeInterval",
+          values: {
+            lowBound: `${limits[rowIndex].voltageLevel.lowBound}`,
+            highBound: `${limits[rowIndex].voltageLevel.highBound}`
+          }
+        }
+      ),
+      children: /* @__PURE__ */ jsx(TableCell, { sx: { fontWeight: "bold" }, children: /* @__PURE__ */ jsx(RawReadOnlyInput, { name: `${LIMIT_REDUCTIONS_FORM}[${rowIndex}].${column.dataKey}` }) })
+    }
+  ) : /* @__PURE__ */ jsx(TableCell, { sx: { fontWeight: "bold" }, children: column.dataKey === VOLTAGE_LEVELS_FORM ? /* @__PURE__ */ jsx(RawReadOnlyInput, { name: `${LIMIT_REDUCTIONS_FORM}[${rowIndex}].${column.dataKey}` }) : /* @__PURE__ */ jsx(FloatInput, { name: `${LIMIT_REDUCTIONS_FORM}[${rowIndex}].${column.dataKey}` }) });
 }
 export {
   LimitReductionTableCell

package/dist/components/parameters/common/limitreductions/limit-reduction-table-row.d.ts

@@ -1,7 +1,8 @@
-import { LimitReductionIColumnsDef } from './columns-definitions';
+import { ILimitReductionsByVoltageLevel, LimitReductionIColumnsDef } from './columns-definitions';
 interface TableRowComponentProps {
     columnsDefinition: LimitReductionIColumnsDef[];
     index: number;
+    limits: ILimitReductionsByVoltageLevel[];
 }
-export declare function LimitReductionTableRow({ columnsDefinition, index }: Readonly<TableRowComponentProps>): import("react/jsx-runtime").JSX.Element;
+export declare function LimitReductionTableRow({ columnsDefinition, index, limits }: Readonly<TableRowComponentProps>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/parameters/common/limitreductions/limit-reduction-table-row.js

@@ -1,8 +1,8 @@
 import { jsx } from "react/jsx-runtime";
 import { TableRow } from "@mui/material";
 import { LimitReductionTableCell } from "./limit-reduction-table-cell.js";
-function LimitReductionTableRow({ columnsDefinition, index }) {
-  return /* @__PURE__ */ jsx(TableRow, { children: columnsDefinition.map((column) => /* @__PURE__ */ jsx(LimitReductionTableCell, { rowIndex: index, column }, `${column.dataKey}`)) });
+function LimitReductionTableRow({ columnsDefinition, index, limits }) {
+  return /* @__PURE__ */ jsx(TableRow, { children: columnsDefinition.map((column) => /* @__PURE__ */ jsx(LimitReductionTableCell, { rowIndex: index, column, limits }, `${column.dataKey}`)) });
 }
 export {
   LimitReductionTableRow

package/dist/components/parameters/common/limitreductions/limit-reductions-label-column.d.ts

@@ -0,0 +1,6 @@
+import { ITemporaryLimitReduction } from './columns-definitions';
+type LimitReductionsLabelColumnProps = {
+    limits: ITemporaryLimitReduction;
+};
+export declare function LimitReductionsLabelColumn({ limits }: Readonly<LimitReductionsLabelColumnProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/parameters/common/limitreductions/limit-reductions-label-column.js

@@ -0,0 +1,22 @@
+import { jsx } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+function LimitReductionsLabelColumn({ limits }) {
+  const highBound = Math.trunc(limits.limitDuration.lowBound / 60);
+  const lowBound = Math.trunc(limits.limitDuration.highBound / 60);
+  if (lowBound === 0) {
+    return /* @__PURE__ */ jsx(FormattedMessage, { id: "LimitVoltageAfterIST", values: { highBound: `${highBound}` } });
+  }
+  return /* @__PURE__ */ jsx(
+    FormattedMessage,
+    {
+      id: "LimitVoltageInterval",
+      values: {
+        lowBound: `${lowBound}`,
+        highBound: `${highBound}`
+      }
+    }
+  );
+}
+export {
+  LimitReductionsLabelColumn
+};

package/dist/components/parameters/common/limitreductions/limit-reductions-table-form.js

@@ -1,6 +1,6 @@
 import { jsx } from "react/jsx-runtime";
-import { useCallback, useMemo } from "react";
-import { useIntl } from "react-intl";
+import { useMemo } from "react";
+import { FormattedMessage } from "react-intl";
 import { COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS, LIMIT_DURATION_FORM, LIMIT_REDUCTIONS_FORM } from "./columns-definitions.js";
 import { CustomVoltageLevelTable } from "../voltage-level-table/custom-voltage-level-table.js";
 import "@mui/material";
@@ -29,56 +29,33 @@ import "../../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";
 import "uuid";
 import "../../../inputs/reactQueryBuilder/PropertyValueEditor.js";
 import "react-querybuilder";
-const getLabelColumn = (limit) => {
-  const lowBound = `${Math.trunc(limit.limitDuration.lowBound / 60)} min`;
-  const highBoundValue = Math.trunc(limit.limitDuration.highBound / 60);
-  const highBound = highBoundValue === 0 ? "∞" : `${Math.trunc(limit.limitDuration.highBound / 60)} min`;
-  const lowerBoundClosed = limit.limitDuration.lowClosed ? "[" : "]";
-  const highBoundClosed = limit.limitDuration.highClosed || null ? "]" : "[";
-  return `${lowerBoundClosed}${lowBound}, ${highBound}${highBoundClosed}`;
-};
+import { LimitReductionsToolTipColumn } from "./limit-reductions-tooltip-column.js";
+import { LimitReductionsLabelColumn } from "./limit-reductions-label-column.js";
 function LimitReductionsTableForm({ limits }) {
-  const intl = useIntl();
-  const getToolTipColumn = useCallback(
-    (limit) => {
-      const lowBound = Math.trunc(limit.limitDuration.lowBound / 60);
-      const highBound = Math.trunc(limit.limitDuration.highBound / 60);
-      if (lowBound === 0) {
-        return intl.formatMessage({ id: "LimitDurationAfterIST" }, { value: highBound });
-      }
-      return intl.formatMessage(
-        { id: "LimitDurationInterval" },
-        {
-          lowBound: `IT${lowBound}`,
-          highBound: highBound === 0 ? "IST" : `IT${highBound}`
-        }
-      );
-    },
-    [intl]
-  );
   const columnsDefinition = useMemo(() => {
     const columnsDef = COLUMNS_DEFINITIONS_LIMIT_REDUCTIONS.map((column) => ({
       ...column,
-      label: intl.formatMessage({ id: column.label }),
-      tooltip: intl.formatMessage({ id: column.tooltip })
+      label: /* @__PURE__ */ jsx(FormattedMessage, { id: column.label }),
+      tooltip: /* @__PURE__ */ jsx(FormattedMessage, { id: column.tooltip })
     }));
     if (limits !== null && limits.length > 0) {
       limits[0].temporaryLimitReductions.forEach((tlimit, index) => {
         columnsDef.push({
-          label: getLabelColumn(tlimit),
+          label: /* @__PURE__ */ jsx(LimitReductionsLabelColumn, { limits: tlimit }),
           dataKey: LIMIT_DURATION_FORM + index,
-          tooltip: getToolTipColumn(tlimit)
+          tooltip: /* @__PURE__ */ jsx(LimitReductionsToolTipColumn, { limits: tlimit })
         });
       });
     }
     return columnsDef;
-  }, [intl, limits, getToolTipColumn]);
+  }, [limits]);
   return /* @__PURE__ */ jsx(
     CustomVoltageLevelTable,
     {
       formName: LIMIT_REDUCTIONS_FORM,
       columnsDefinition,
-      tableHeight: 450
+      tableHeight: 450,
+      limits
     }
   );
 }

package/dist/components/parameters/common/limitreductions/limit-reductions-tooltip-column.d.ts

@@ -0,0 +1,6 @@
+import { ITemporaryLimitReduction } from './columns-definitions';
+type LimitReductionsLabelColumnProps = {
+    limits: ITemporaryLimitReduction;
+};
+export declare function LimitReductionsToolTipColumn({ limits }: Readonly<LimitReductionsLabelColumnProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/parameters/common/limitreductions/limit-reductions-tooltip-column.js

@@ -0,0 +1,24 @@
+import { jsx } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+function LimitReductionsToolTipColumn({ limits }) {
+  const lowBound = `${Math.trunc(limits.limitDuration.lowBound / 60)} min`;
+  const highBoundValue = Math.trunc(limits.limitDuration.highBound / 60);
+  const highBound = highBoundValue === 0 ? "∞" : `${Math.trunc(limits.limitDuration.highBound / 60)} min`;
+  const lowerBoundClosed = limits.limitDuration.lowClosed ? "[" : "]";
+  const higherBoundClosed = limits.limitDuration.highClosed || null ? "]" : "[";
+  return /* @__PURE__ */ jsx(
+    FormattedMessage,
+    {
+      id: "LimitDurationInterval",
+      values: {
+        lowBound: `${lowBound}`,
+        highBound: `${highBound}`,
+        higherBoundClosed: `${higherBoundClosed}`,
+        lowerBoundClosed: `${lowerBoundClosed}`
+      }
+    }
+  );
+}
+export {
+  LimitReductionsToolTipColumn
+};

package/dist/components/parameters/common/voltage-level-table/custom-voltage-level-table.d.ts

@@ -1,8 +1,9 @@
-import { LimitReductionIColumnsDef } from '../limitreductions/columns-definitions';
+import { LimitReductionIColumnsDef, ILimitReductionsByVoltageLevel } from '../limitreductions/columns-definitions';
 interface LimitReductionsTableProps {
     columnsDefinition: LimitReductionIColumnsDef[];
     tableHeight: number;
     formName: string;
+    limits?: ILimitReductionsByVoltageLevel[];
 }
-export declare function CustomVoltageLevelTable({ formName, columnsDefinition, tableHeight, }: Readonly<LimitReductionsTableProps>): import("react/jsx-runtime").JSX.Element;
+export declare function CustomVoltageLevelTable({ formName, columnsDefinition, tableHeight, limits, }: Readonly<LimitReductionsTableProps>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/parameters/common/voltage-level-table/custom-voltage-level-table.js

@@ -1,6 +1,5 @@
 import { jsx, jsxs } from "react/jsx-runtime";
-import { TableContainer, Table, TableHead, TableRow, TableCell, TableBody } from "@mui/material";
-import { useMemo } from "react";
+import { TableContainer, Table, TableHead, TableRow, Tooltip, TableCell, TableBody } from "@mui/material";
 import { useFieldArray } from "react-hook-form";
 import { LIMIT_REDUCTIONS_FORM } from "../limitreductions/columns-definitions.js";
 import { LimitReductionTableRow } from "../limitreductions/limit-reduction-table-row.js";
@@ -8,15 +7,12 @@ import { CustomVoltageLevelTableRow } from "./custom-voltage-level-table-row.js"
 function CustomVoltageLevelTable({
   formName,
   columnsDefinition,
-  tableHeight
+  tableHeight,
+  limits
 }) {
   const { fields: rows } = useFieldArray({
     name: formName
   });
-  const TableRowComponent = useMemo(
-    () => formName === LIMIT_REDUCTIONS_FORM ? LimitReductionTableRow : CustomVoltageLevelTableRow,
-    [formName]
-  );
   return /* @__PURE__ */ jsx(
     TableContainer,
     {
@@ -26,26 +22,35 @@ function CustomVoltageLevelTable({
         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__ */ jsx(TableRow, { children: columnsDefinition.map((column) => /* @__PURE__ */ jsx(
+        /* @__PURE__ */ jsx(TableHead, { children: /* @__PURE__ */ jsx(TableRow, { children: columnsDefinition.map((column) => /* @__PURE__ */ jsx(Tooltip, { title: column.tooltip, children: /* @__PURE__ */ jsx(
           TableCell,
           {
             sx: {
               textAlign: "center"
             },
-            title: column.tooltip,
             children: column.label
           },
           column.dataKey
-        )) }) }),
-        /* @__PURE__ */ jsx(TableBody, { children: rows.map((row, index) => /* @__PURE__ */ jsx(
-          TableRowComponent,
-          {
-            columnsDefinition,
-            index,
-            formName
-          },
-          `${row.id}`
-        )) })
+        ) })) }) }),
+        /* @__PURE__ */ jsx(TableBody, { children: rows.map(
+          (row, index) => formName === LIMIT_REDUCTIONS_FORM && limits ? /* @__PURE__ */ jsx(
+            LimitReductionTableRow,
+            {
+              columnsDefinition,
+              index,
+              limits
+            },
+            `${row.id}`
+          ) : /* @__PURE__ */ jsx(
+            CustomVoltageLevelTableRow,
+            {
+              columnsDefinition,
+              index,
+              formName
+            },
+            `${row.id}`
+          )
+        ) })
       ] })
     }
   );

package/dist/components/parameters/loadflow/load-flow-parameters-inline.d.ts

@@ -1,4 +1,3 @@
-import { Dispatch, SetStateAction } from 'react';
 import { UUID } from 'crypto';
 import { UseParametersBackendReturnProps } from '../../../utils/types/parameters.type';
 import { ComputingType } from '../common/computing-type';
@@ -7,6 +6,6 @@ export declare function LoadFlowParametersInline({ studyUuid, language, paramete
     studyUuid: UUID | null;
     language: GsLang;
     parametersBackend: UseParametersBackendReturnProps<ComputingType.LOAD_FLOW>;
-    setHaveDirtyFields: Dispatch<SetStateAction<boolean>>;
+    setHaveDirtyFields: (isDirty: boolean) => void;
     enableDeveloperMode: boolean;
 }>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/network-visualizations/network-visualizations-parameters-inline.d.ts

@@ -1,10 +1,9 @@
-import { Dispatch, SetStateAction } from 'react';
 import { UUID } from 'crypto';
 import { User } from 'oidc-client';
 import { NetworkVisualizationParameters } from './network-visualizations.types';
 export declare function NetworkVisualizationParametersInline({ studyUuid, setHaveDirtyFields, user, parameters, }: Readonly<{
     studyUuid: UUID | null;
-    setHaveDirtyFields: Dispatch<SetStateAction<boolean>>;
+    setHaveDirtyFields: (isDirty: boolean) => void;
     user: User | null;
     parameters: NetworkVisualizationParameters | null;
 }>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/security-analysis/security-analysis-parameters-inline.d.ts

@@ -1,10 +1,9 @@
-import { Dispatch, SetStateAction } from 'react';
 import { UUID } from 'crypto';
 import { UseParametersBackendReturnProps } from '../../../utils';
 import { ComputingType } from '../common';
 export declare function SecurityAnalysisParametersInline({ studyUuid, parametersBackend, setHaveDirtyFields, enableDeveloperMode, }: Readonly<{
     studyUuid: UUID | null;
     parametersBackend: UseParametersBackendReturnProps<ComputingType.SECURITY_ANALYSIS>;
-    setHaveDirtyFields: Dispatch<SetStateAction<boolean>>;
+    setHaveDirtyFields: (isDirty: boolean) => void;
     enableDeveloperMode: boolean;
 }>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/security-analysis/security-analysis-parameters-selector.js

@@ -66,8 +66,7 @@ function SecurityAnalysisParametersSelector({
           value: index,
           sx: {
             fontSize: 17,
-            fontWeight: "bold",
-            textTransform: "capitalize"
+            fontWeight: "bold"
           }
         },
         tab.label

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

@@ -6,7 +6,7 @@ interface SensitivityAnalysisParametersProps {
     currentNodeUuid: UUID | null;
     currentRootNetworkUuid: UUID | null;
     parametersBackend: UseParametersBackendReturnProps<ComputingType.SENSITIVITY_ANALYSIS>;
-    setHaveDirtyFields: any;
+    setHaveDirtyFields: (isDirty: boolean) => void;
     enableDeveloperMode: boolean;
 }
 export declare function SensitivityAnalysisParametersInline({ studyUuid, currentNodeUuid, currentRootNetworkUuid, parametersBackend, setHaveDirtyFields, enableDeveloperMode, }: Readonly<SensitivityAnalysisParametersProps>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/short-circuit/short-circuit-parameters-inline.d.ts

@@ -1,8 +1,7 @@
-import { Dispatch, SetStateAction } from 'react';
 import { UUID } from 'crypto';
 import { ShortCircuitParametersInfos } from './short-circuit-parameters.type';
 export declare function ShortCircuitParametersInLine({ studyUuid, setHaveDirtyFields, shortCircuitParameters, }: Readonly<{
     studyUuid: UUID | null;
-    setHaveDirtyFields: Dispatch<SetStateAction<boolean>>;
+    setHaveDirtyFields: (isDirty: boolean) => void;
     shortCircuitParameters: ShortCircuitParametersInfos | null;
 }>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/voltage-init/voltage-init-parameters-inline.d.ts

@@ -1,8 +1,7 @@
-import { Dispatch, SetStateAction } from 'react';
 import { UUID } from 'crypto';
 import { VoltageInitStudyParameters } from './voltage-init.type';
 export declare function VoltageInitParametersInLine({ studyUuid, setHaveDirtyFields, voltageInitParameters, }: Readonly<{
     studyUuid: UUID | null;
-    setHaveDirtyFields: Dispatch<SetStateAction<boolean>>;
+    setHaveDirtyFields: (isDirty: boolean) => void;
     voltageInitParameters: VoltageInitStudyParameters | null;
 }>): import("react/jsx-runtime").JSX.Element;

package/dist/hooks/use-unique-name-validation.js

@@ -20,11 +20,10 @@ function useUniqueNameValidation({
     setError,
     clearErrors,
     trigger,
-    formState: { errors, defaultValues }
+    formState: { errors, defaultValues, isDirty: formIsDirty }
   } = useFormContext();
   const {
-    field: { value },
-    fieldState: { isDirty }
+    field: { value }
   } = useController({ name });
   const {
     field: { value: selectedDirectory }
@@ -65,10 +64,13 @@ function useUniqueNameValidation({
     if (selectedDirectory) {
       debouncedHandleCheckName(trimmedValue);
     }
-    if (!isDirty) {
+    if (!formIsDirty) {
       clearErrors(name);
       return;
     }
+    if (trimmedValue === defaultFieldValue && trimmedValue.length > 0) {
+      return;
+    }
     if (trimmedValue) {
       clearErrors(name);
       setError("root.isValidating", {
@@ -89,7 +91,7 @@ function useUniqueNameValidation({
     setError,
     clearErrors,
     name,
-    isDirty,
+    formIsDirty,
     defaultFieldValue,
     directory,
     selectedDirectory

package/dist/translations/en/parameters.d.ts

@@ -55,9 +55,11 @@ export declare const parametersEn: {
     General: string;
     LimitReductions: string;
     IST: string;
+    LimitVoltageInterval: string;
+    LimitVoltageAfterIST: string;
     LimitDurationInterval: string;
-    LimitDurationAfterIST: string;
     voltageRange: string;
+    VoltageRangeInterval: string;
     Provider: string;
     LimitReduction: string;
     Default: string;

package/dist/translations/en/parameters.js

@@ -48,10 +48,12 @@ const parametersEn = {
   RealPercentage: "This value must be between 0 and 1",
   General: "General",
   LimitReductions: "Limit reductions",
-  IST: "IST",
-  LimitDurationInterval: "Between {highBound} and {lowBound}",
-  LimitDurationAfterIST: "Beyond IT{value}",
+  IST: "PATL",
+  LimitVoltageInterval: "Between TATL{lowBound} and TATL{highBound}",
+  LimitVoltageAfterIST: "Between PATL and TATL{highBound}",
+  LimitDurationInterval: "Duration {lowerBoundClosed}{lowBound}, {highBound}{higherBoundClosed}",
   voltageRange: "Voltage range",
+  VoltageRangeInterval: "Voltage interval ]{lowBound} kV,{highBound} kV]",
   Provider: "Provider",
   LimitReduction: "Limit reduction",
   Default: "Default",

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

@@ -55,9 +55,11 @@ export declare const parametersFr: {
     General: string;
     LimitReductions: string;
     IST: string;
+    LimitVoltageInterval: string;
+    LimitVoltageAfterIST: string;
     LimitDurationInterval: string;
-    LimitDurationAfterIST: string;
     voltageRange: string;
+    VoltageRangeInterval: string;
     Provider: string;
     LimitReduction: string;
     Default: string;

package/dist/translations/fr/parameters.js

@@ -49,9 +49,11 @@ const parametersFr = {
   General: "Général",
   LimitReductions: "Abattements",
   IST: "IST",
-  LimitDurationInterval: "Entre {highBound} et {lowBound}",
-  LimitDurationAfterIST: "Au-delà de IT{value}",
+  LimitVoltageInterval: "Entre IT{lowBound} et IT{highBound}",
+  LimitVoltageAfterIST: "Entre IST et IT{highBound}",
+  LimitDurationInterval: "Tempo {lowerBoundClosed}{lowBound}, {highBound}{higherBoundClosed}",
   voltageRange: "Niveau de tension",
+  VoltageRangeInterval: "Plage de tension ]{lowBound} kV,{highBound} kV]",
   Provider: "Simulateur",
   LimitReduction: "Abattement des seuils",
   Default: "Défaut",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gridsuite/commons-ui",
-    "version": "0.123.0",
+    "version": "0.125.0",
     "description": "common react components for gridsuite applications",
     "author": "gridsuite team",
     "homepage": "https://github.com/gridsuite",