@gridsuite/commons-ui 0.170.0 → 0.171.0

package/dist/components/inputs/reactHookForm/selectInputs/CountriesInput.js

@@ -26,16 +26,19 @@ function CountriesInput({ name, label, dataTestId }) {
       getOptionLabel: translateOption,
       fullWidth: true,
       multiple: true,
-      renderTags: (val, getTagsProps) => val.map((code, index) => /* @__PURE__ */ jsx(
-        Chip,
-        {
-          "data-testid": `${dataTestId}.${code}`,
-          size: "small",
-          label: translate(code),
-          ...getTagsProps({ index })
-        },
-        code
-      ))
+      renderTags: (val, getTagsProps) => val.map((code, index) => {
+        const { key, ...tagProps } = getTagsProps({ index });
+        return /* @__PURE__ */ jsx(
+          Chip,
+          {
+            "data-testid": `${dataTestId}.${code}`,
+            size: "small",
+            label: translate(code),
+            ...tagProps
+          },
+          key ?? code
+        );
+      })
     }
   );
 }

package/dist/components/parameters/dynamic-margin-calculation/dynamic-margin-calculation-inline.js

@@ -50,7 +50,7 @@ function DynamicMarginCalculationInline({
   parametersBackend,
   setHaveDirtyFields
 }) {
-  const [providers, , , , , params, , updateParams, resetParams, ,] = parametersBackend;
+  const { providers, params, updateParameters, resetParameters } = parametersBackend;
   const dynamicMarginCalculationMethods = useDynamicMarginCalculationParametersForm({
     providers,
     params,
@@ -71,14 +71,14 @@ function DynamicMarginCalculationInline({
     setOpenResetConfirmation(false);
   }, []);
   const handleReset = useCallback(() => {
-    resetParams();
+    resetParameters();
     setOpenResetConfirmation(false);
-  }, [resetParams]);
+  }, [resetParameters]);
   const onSubmit = useCallback(
     (formData) => {
-      updateParams(toParamsInfos(formData));
+      updateParameters(toParamsInfos(formData));
     },
-    [updateParams]
+    [updateParameters]
   );
   const handleLoadParameter = useCallback(
     (newParams) => {

package/dist/components/parameters/loadflow/load-flow-parameters-dialog.js

@@ -8,7 +8,7 @@ import "../../../utils/types/equipmentType.js";
 import { LANG_ENGLISH } from "../../../utils/langs.js";
 import "@mui/icons-material";
 import "../../../utils/yupConfig.js";
-import { getLoadFlowDefaultLimitReductions, getLoadFlowSpecificParametersDescription, setLoadFlowParameters, fetchLoadFlowParameters, getDefaultLoadFlowProvider, getLoadFlowProviders } from "../../../services/loadflow.js";
+import { getLoadFlowDefaultLimitReductions, getLoadFlowProviders, fetchLoadFlowParameters, setLoadFlowParameters, getLoadFlowSpecificParametersDescription } from "../../../services/loadflow.js";
 import "react";
 import "@mui/material";
 import "react-intl";
@@ -57,20 +57,13 @@ function LoadFlowParametersEditionDialog({
   language = LANG_ENGLISH,
   isDeveloperMode = false
 }) {
-  const parametersBackend = useParametersBackend(
-    user,
-    id,
-    ComputingType.LOAD_FLOW,
-    OptionalServicesStatus.Up,
-    getLoadFlowProviders,
-    null,
-    getDefaultLoadFlowProvider,
-    null,
-    fetchLoadFlowParameters,
-    setLoadFlowParameters,
-    getLoadFlowSpecificParametersDescription,
-    getLoadFlowDefaultLimitReductions
-  );
+  const parametersBackend = useParametersBackend(user, id, ComputingType.LOAD_FLOW, OptionalServicesStatus.Up, {
+    backendFetchProviders: getLoadFlowProviders,
+    backendFetchParameters: fetchLoadFlowParameters,
+    backendUpdateParameters: setLoadFlowParameters,
+    backendFetchSpecificParametersDescription: getLoadFlowSpecificParametersDescription,
+    backendFetchDefaultLimitReductions: getLoadFlowDefaultLimitReductions
+  });
   const loadflowMethods = useLoadFlowParametersForm(parametersBackend, isDeveloperMode, id, name, description);
   const {
     formState: { errors, dirtyFields }

package/dist/components/parameters/loadflow/load-flow-parameters-form.js

@@ -74,7 +74,7 @@ function LoadFlowParametersForm({
     formattedProviders,
     specificParametersDescriptionForProvider,
     params,
-    currentProvider,
+    watchProvider,
     defaultLimitReductions,
     paramsLoaded
   } = loadflowMethods;
@@ -94,7 +94,7 @@ function LoadFlowParametersForm({
         LoadFlowParametersContent,
         {
           selectedTab,
-          currentProvider: currentProvider ?? "",
+          currentProvider: watchProvider ?? "",
           specificParameters: specificParametersDescriptionForProvider,
           params,
           defaultLimitReductions

package/dist/components/parameters/loadflow/load-flow-parameters-inline.js

@@ -55,7 +55,7 @@ function LoadFlowParametersInline({
   setHaveDirtyFields,
   isDeveloperMode
 }) {
-  const [, , , , resetProvider, , , , resetParameters, ,] = parametersBackend;
+  const { resetParameters } = parametersBackend;
   const loadflowMethods = useLoadFlowParametersForm(parametersBackend, isDeveloperMode, null, null, null);
   const intl = useIntl();
   const [openCreateParameterDialog, setOpenCreateParameterDialog] = useState(false);
@@ -64,9 +64,8 @@ function LoadFlowParametersInline({
   const { snackError } = useSnackMessage();
   const executeResetAction = useCallback(() => {
     resetParameters();
-    resetProvider();
     setOpenResetConfirmation(false);
-  }, [resetParameters, resetProvider]);
+  }, [resetParameters]);
   const handleResetAllClick = useCallback(() => {
     setOpenResetConfirmation(true);
   }, []);
@@ -79,7 +78,6 @@ function LoadFlowParametersInline({
       if (newParams && newParams.length > 0) {
         setOpenSelectParameterDialog(false);
         fetchLoadFlowParameters(newParams[0].id).then((parameters) => {
-          loadflowMethods.setCurrentProvider(parameters.provider);
           console.info(`loading the following loadflow parameters : ${parameters.uuid}`);
           reset(loadflowMethods.toLoadFlowFormValues(parameters), {
             keepDefaultValues: true

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

@@ -1,5 +1,5 @@
 import { FieldErrors, UseFormReturn } from 'react-hook-form';
-import { Dispatch, SetStateAction, SyntheticEvent } from 'react';
+import { SyntheticEvent } from 'react';
 import { ObjectSchema } from 'yup';
 import { UUID } from 'node:crypto';
 import { TabValues } from './load-flow-parameters-utils';
@@ -22,8 +22,7 @@ export interface UseLoadFlowParametersFormReturn {
     toLoadFlowFormValues: (_params: LoadFlowParametersInfos) => any;
     formatNewParams: (formData: Record<string, any>) => LoadFlowParametersInfos;
     params: LoadFlowParametersInfos | null;
-    currentProvider: string | undefined;
-    setCurrentProvider: Dispatch<SetStateAction<string | undefined>>;
+    watchProvider: string | undefined;
     paramsLoaded: boolean;
     onValidationError: (errors: FieldErrors) => void;
     onSaveInline: (formData: Record<string, any>) => void;

package/dist/components/parameters/loadflow/use-load-flow-parameters-form.js

@@ -1,6 +1,6 @@
 import { useForm } from "react-hook-form";
 import { yupResolver } from "@hookform/resolvers/yup";
-import { useState, useCallback, useMemo, useEffectEvent, useEffect } from "react";
+import { useState, useRef, useCallback, useMemo, useEffect, useEffectEvent } from "react";
 import { TabValues, getCommonLoadFlowParametersFormSchema, mapLimitReductions, setLimitReductions } from "./load-flow-parameters-utils.js";
 import { PROVIDER, SPECIFIC_PARAMETERS, COMMON_PARAMETERS, VERSION_PARAMETER } from "../common/constants.js";
 import "react/jsx-runtime";
@@ -47,30 +47,18 @@ import "../../filter/HeaderFilterForm.js";
 import { getNameElementEditorSchema, getNameElementEditorEmptyFormData } from "../common/name-element-editor/name-element-editor-utils.js";
 import { getDefaultSpecificParamsValues, getSpecificParametersFormSchema, getAllSpecificParametersValues, formatSpecificParameters, setSpecificParameters } from "../common/utils.js";
 const useLoadFlowParametersForm = (parametersBackend, isDeveloperMode, parametersUuid, name, description) => {
-  const [
-    providers,
-    provider,
-    ,
-    ,
-    ,
-    params,
-    ,
-    updateParameters,
-    ,
-    specificParamsDescriptions,
-    defaultLimitReductions
-  ] = parametersBackend;
-  const [currentProvider, setCurrentProvider] = useState(params?.provider);
+  const { providers, params, updateParameters, specificParamsDescription, defaultLimitReductions } = parametersBackend;
   const [selectedTab, setSelectedTab] = useState(TabValues.GENERAL);
   const [limitReductionNumber, setLimitReductionNumber] = useState(0);
   const [tabIndexesWithError, setTabIndexesWithError] = useState([]);
+  const [specificParametersDescriptionForProvider, setSpecificParametersDescriptionForProvider] = useState(() => {
+    return params?.provider && specificParamsDescription ? specificParamsDescription[params.provider] : [];
+  });
   const { snackError } = useSnackMessage();
+  const previousWatchProviderRef = useRef(void 0);
   const handleTabChange = useCallback((event, newValue) => {
     setSelectedTab(newValue);
   }, []);
-  const specificParametersDescriptionForProvider = useMemo(() => {
-    return currentProvider && specificParamsDescriptions ? specificParamsDescriptions[currentProvider] : [];
-  }, [currentProvider, specificParamsDescriptions]);
   const specificParametersDefaultValues = useMemo(() => {
     return getDefaultSpecificParamsValues(specificParametersDescriptionForProvider);
   }, [specificParametersDescriptionForProvider]);
@@ -86,7 +74,7 @@ const useLoadFlowParametersForm = (parametersBackend, isDeveloperMode, parameter
   const formMethods = useForm({
     defaultValues: {
       ...getNameElementEditorEmptyFormData(name, description),
-      [PROVIDER]: provider,
+      [PROVIDER]: params?.provider,
       [PARAM_LIMIT_REDUCTION]: null,
       [COMMON_PARAMETERS]: {
         ...params?.commonParameters
@@ -100,6 +88,14 @@ const useLoadFlowParametersForm = (parametersBackend, isDeveloperMode, parameter
   });
   const { watch, reset } = formMethods;
   const watchProvider = watch(PROVIDER);
+  useEffect(() => {
+    const provider = watchProvider ?? params?.provider;
+    if (!provider || !specificParamsDescription) {
+      setSpecificParametersDescriptionForProvider([]);
+      return;
+    }
+    setSpecificParametersDescriptionForProvider(specificParamsDescription[provider] ?? []);
+  }, [watchProvider, params?.provider, specificParamsDescription]);
   const toLimitReductions = useCallback(
     (formLimits) => {
       if (formLimits?.length === 0) {
@@ -143,6 +139,7 @@ const useLoadFlowParametersForm = (parametersBackend, isDeveloperMode, parameter
   const toLoadFlowFormValues = useCallback(
     (_params) => {
       const specificParamsListForCurrentProvider = _params.specificParametersPerProvider[_params.provider];
+      const specificParametersForLoadedProvider = specificParamsDescription?.[_params.provider] ?? [];
       return {
         [PROVIDER]: _params.provider,
         [PARAM_LIMIT_REDUCTION]: _params.limitReduction,
@@ -151,16 +148,16 @@ const useLoadFlowParametersForm = (parametersBackend, isDeveloperMode, parameter
         },
         [SPECIFIC_PARAMETERS]: {
           ...formatSpecificParameters(
-            specificParametersDescriptionForProvider,
+            specificParametersForLoadedProvider,
             specificParamsListForCurrentProvider
           )
         },
         ...toFormValuesLimitReductions(_params.limitReductions)
       };
     },
-    [specificParametersDescriptionForProvider]
+    [specificParamsDescription]
   );
-  const paramsLoaded = useMemo(() => !!params && !!currentProvider, [currentProvider, params]);
+  const paramsLoaded = useMemo(() => !!params && !!watchProvider, [watchProvider, params]);
   const formattedProviders = useMemo(() => {
     return Object.entries(providers).filter(([key]) => !key.includes("DynaFlow") || isDeveloperMode).map(([key, value]) => ({
       id: key,
@@ -214,28 +211,22 @@ const useLoadFlowParametersForm = (parametersBackend, isDeveloperMode, parameter
     resetForm(params);
   }, [paramsLoaded, params]);
   useEffect(() => {
-    if (watchProvider && watchProvider !== currentProvider) {
-      setCurrentProvider(watchProvider);
-      setSpecificParameters(watchProvider, specificParamsDescriptions, formMethods);
-      setLimitReductions(watchProvider, defaultLimitReductions, formMethods);
-      if (watchProvider === PARAM_PROVIDER_OPENLOADFLOW) {
-        if (currentProvider) {
-          setLimitReductionNumber(defaultLimitReductions?.at(0)?.temporaryLimitReductions?.length ?? 0);
-        } else {
-          setLimitReductionNumber(params?.limitReductions?.at(0)?.temporaryLimitReductions?.length ?? 0);
-        }
+    if (!watchProvider || watchProvider === previousWatchProviderRef.current) {
+      return;
+    }
+    setSpecificParameters(watchProvider, specificParamsDescription, formMethods);
+    setLimitReductions(watchProvider, defaultLimitReductions, formMethods);
+    if (watchProvider === PARAM_PROVIDER_OPENLOADFLOW) {
+      if (previousWatchProviderRef.current) {
+        setLimitReductionNumber(defaultLimitReductions?.at(0)?.temporaryLimitReductions?.length ?? 0);
       } else {
-        setLimitReductionNumber(0);
+        setLimitReductionNumber(params?.limitReductions?.at(0)?.temporaryLimitReductions?.length ?? 0);
       }
+    } else {
+      setLimitReductionNumber(0);
     }
-  }, [
-    currentProvider,
-    defaultLimitReductions,
-    formMethods,
-    params?.limitReductions,
-    specificParamsDescriptions,
-    watchProvider
-  ]);
+    previousWatchProviderRef.current = watchProvider;
+  }, [defaultLimitReductions, formMethods, params?.limitReductions, specificParamsDescription, watchProvider]);
   return {
     formMethods,
     formSchema,
@@ -248,8 +239,7 @@ const useLoadFlowParametersForm = (parametersBackend, isDeveloperMode, parameter
     toLoadFlowFormValues,
     formatNewParams,
     params,
-    currentProvider,
-    setCurrentProvider,
+    watchProvider,
     paramsLoaded,
     onValidationError,
     onSaveInline,

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

@@ -6,7 +6,7 @@ import { ElementType } from "../../../utils/types/elementType.js";
 import "../../../utils/types/equipmentType.js";
 import "@mui/icons-material";
 import "../../../utils/yupConfig.js";
-import { getSecurityAnalysisDefaultLimitReductions, updateSecurityAnalysisParameters, fetchSecurityAnalysisParameters, fetchDefaultSecurityAnalysisProvider, fetchSecurityAnalysisProviders } from "../../../services/security-analysis.js";
+import { getSecurityAnalysisDefaultLimitReductions, fetchSecurityAnalysisProviders, fetchSecurityAnalysisParameters, updateSecurityAnalysisParameters } from "../../../services/security-analysis.js";
 import "@mui/material";
 import "localized-countries";
 import "localized-countries/data/fr";
@@ -60,14 +60,12 @@ function SecurityAnalysisParametersDialog({
     id,
     ComputingType.SECURITY_ANALYSIS,
     OptionalServicesStatus.Up,
-    fetchSecurityAnalysisProviders,
-    null,
-    fetchDefaultSecurityAnalysisProvider,
-    null,
-    fetchSecurityAnalysisParameters,
-    updateSecurityAnalysisParameters,
-    void 0,
-    getSecurityAnalysisDefaultLimitReductions
+    {
+      backendFetchProviders: fetchSecurityAnalysisProviders,
+      backendFetchParameters: fetchSecurityAnalysisParameters,
+      backendUpdateParameters: updateSecurityAnalysisParameters,
+      backendFetchDefaultLimitReductions: getSecurityAnalysisDefaultLimitReductions
+    }
   );
   const securityAnalysisMethods = useSecurityAnalysisParametersForm(parametersBackend, id, name, description);
   const {

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

@@ -134,7 +134,7 @@ function SecurityAnalysisParametersForm({
                           SecurityAnalysisParametersSelector,
                           {
                             params: securityAnalysisMethods.params,
-                            currentProvider: securityAnalysisMethods.currentProvider?.trim(),
+                            currentProvider: securityAnalysisMethods.watchProvider?.trim(),
                             isDeveloperMode,
                             defaultLimitReductions: securityAnalysisMethods.defaultLimitReductions
                           }

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

@@ -56,7 +56,7 @@ function SecurityAnalysisParametersInline({
   isDeveloperMode
 }) {
   const securityAnalysisMethods = useSecurityAnalysisParametersForm(parametersBackend, null, null, null);
-  const [, , , , resetProvider, , , , resetParameters, , ,] = parametersBackend;
+  const { resetParameters } = parametersBackend;
   const intl = useIntl();
   const [openCreateParameterDialog, setOpenCreateParameterDialog] = useState(false);
   const [openSelectParameterDialog, setOpenSelectParameterDialog] = useState(false);
@@ -65,9 +65,8 @@ function SecurityAnalysisParametersInline({
   const { handleSubmit, formState, reset, getValues } = securityAnalysisMethods.formMethods;
   const executeResetAction = useCallback(() => {
     resetParameters();
-    resetProvider();
     setOpenResetConfirmation(false);
-  }, [resetParameters, resetProvider]);
+  }, [resetParameters]);
   const handleResetAllClick = useCallback(() => {
     setOpenResetConfirmation(true);
   }, []);

package/dist/components/parameters/security-analysis/use-security-analysis-parameters-form.d.ts

@@ -1,6 +1,5 @@
 import { UseFormReturn } from 'react-hook-form';
 import { ObjectSchema } from 'yup';
-import { Dispatch, SetStateAction } from 'react';
 import { UUID } from 'node:crypto';
 import { UseParametersBackendReturnProps } from '../../../utils';
 import { ComputingType, ILimitReductionsByVoltageLevel } from '../common';
@@ -16,8 +15,7 @@ export interface UseSecurityAnalysisParametersFormReturn {
     toFormValueSaParameters: (_params: SAParameters) => any;
     formatNewParams: (formData: Record<string, any>) => SAParameters;
     params: SAParameters | null;
-    currentProvider: string | undefined;
-    setCurrentProvider: Dispatch<SetStateAction<string | undefined>>;
+    watchProvider: string | undefined;
     paramsLoaded: boolean;
     onSaveInline: (formData: Record<string, any>) => void;
     onSaveDialog: (formData: Record<string, any>) => void;

package/dist/components/parameters/security-analysis/use-security-analysis-parameters-form.js

@@ -1,5 +1,5 @@
 import { useForm } from "react-hook-form";
-import { useState, useMemo, useCallback, useEffect } from "react";
+import { useRef, useMemo, useCallback, useEffect } from "react";
 import { yupResolver } from "@hookform/resolvers/yup";
 import "../../../utils/conversionUtils.js";
 import { snackWithFallback } from "../../../utils/error.js";
@@ -45,8 +45,8 @@ import { getNameElementEditorEmptyFormData } from "../common/name-element-editor
 import { getSAParametersFormSchema, toFormValueSaParameters } from "./columns-definitions.js";
 import { ACTIVATED, DESCRIPTION, NAME, ID } from "../common/parameter-table/constants.js";
 const useSecurityAnalysisParametersForm = (parametersBackend, parametersUuid, name, description) => {
-  const [providers, provider, , , , params, , updateParameters, , , defaultLimitReductions] = parametersBackend;
-  const [currentProvider, setCurrentProvider] = useState(params?.provider);
+  const { providers, params, updateParameters, defaultLimitReductions } = parametersBackend;
+  const previousWatchProviderRef = useRef(void 0);
   const { snackError } = useSnackMessage();
   const formattedProviders = useMemo(() => {
     return Object.entries(providers).filter(([key]) => !key.includes("DynaFlow")).map(([key, value]) => ({
@@ -54,14 +54,13 @@ const useSecurityAnalysisParametersForm = (parametersBackend, parametersUuid, na
       label: value
     }));
   }, [providers]);
-  const paramsLoaded = useMemo(() => !!params && !!currentProvider, [currentProvider, params]);
   const formSchema = useMemo(() => {
     return getSAParametersFormSchema(name, params?.limitReductions);
   }, [name, params?.limitReductions]);
   const formMethods = useForm({
     defaultValues: {
       ...getNameElementEditorEmptyFormData(name, description),
-      [PARAM_SA_PROVIDER]: provider,
+      [PARAM_SA_PROVIDER]: params?.provider,
       [CONTINGENCY_LISTS_INFOS]: [],
       [LIMIT_REDUCTIONS_FORM]: [],
       [PARAM_SA_FLOW_PROPORTIONAL_THRESHOLD]: null,
@@ -74,6 +73,7 @@ const useSecurityAnalysisParametersForm = (parametersBackend, parametersUuid, na
   });
   const { reset, watch } = formMethods;
   const watchProvider = watch(PARAM_SA_PROVIDER);
+  const paramsLoaded = useMemo(() => !!params && !!watchProvider, [watchProvider, params]);
   const toContingencyListsInfos = useCallback(
     (formContingencyListsInfos) => {
       if (!formContingencyListsInfos) {
@@ -149,9 +149,8 @@ const useSecurityAnalysisParametersForm = (parametersBackend, parametersUuid, na
     [parametersUuid, formatNewParams, snackError]
   );
   useEffect(() => {
-    if (watchProvider !== currentProvider) {
-      setCurrentProvider(watchProvider);
-      if (watchProvider !== void 0 && currentProvider !== void 0) {
+    if (watchProvider !== void 0 && watchProvider !== previousWatchProviderRef.current) {
+      if (previousWatchProviderRef.current !== void 0) {
         if (params !== null) {
           params.limitReductions = defaultLimitReductions;
         }
@@ -160,8 +159,9 @@ const useSecurityAnalysisParametersForm = (parametersBackend, parametersUuid, na
           toFormValuesLimitReductions(defaultLimitReductions)[LIMIT_REDUCTIONS_FORM]
         );
       }
+      previousWatchProviderRef.current = watchProvider;
     }
-  }, [watchProvider, currentProvider, formMethods, setCurrentProvider, defaultLimitReductions, params]);
+  }, [watchProvider, formMethods, defaultLimitReductions, params]);
   useEffect(() => {
     if (!params) {
       return;
@@ -176,8 +176,7 @@ const useSecurityAnalysisParametersForm = (parametersBackend, parametersUuid, na
     toFormValueSaParameters,
     formatNewParams,
     params,
-    currentProvider,
-    setCurrentProvider,
+    watchProvider,
     paramsLoaded,
     onSaveInline,
     onSaveDialog

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

@@ -39,7 +39,7 @@ import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
 import "react-querybuilder";
 import "../common/widget/parameter-line-slider.js";
 import "../common/limitreductions/columns-definitions.js";
-import { updateSensitivityAnalysisParameters, fetchSensitivityAnalysisParameters, fetchDefaultSensitivityAnalysisProvider, fetchSensitivityAnalysisProviders } from "../../../services/sensitivity-analysis.js";
+import { fetchSensitivityAnalysisProviders, fetchSensitivityAnalysisParameters, updateSensitivityAnalysisParameters } from "../../../services/sensitivity-analysis.js";
 import { NameElementEditorForm } from "../common/name-element-editor/name-element-editor-form.js";
 import { useSensitivityAnalysisParametersForm } from "./use-sensitivity-analysis-parameters.js";
 import { SensitivityAnalysisParametersForm } from "./sensitivity-analysis-parameters-form.js";
@@ -60,12 +60,11 @@ function SensitivityAnalysisParametersDialog({
     id,
     ComputingType.SENSITIVITY_ANALYSIS,
     OptionalServicesStatus.Up,
-    fetchSensitivityAnalysisProviders,
-    null,
-    fetchDefaultSensitivityAnalysisProvider,
-    null,
-    fetchSensitivityAnalysisParameters,
-    updateSensitivityAnalysisParameters
+    {
+      backendFetchProviders: fetchSensitivityAnalysisProviders,
+      backendFetchParameters: fetchSensitivityAnalysisParameters,
+      backendUpdateParameters: updateSensitivityAnalysisParameters
+    }
   );
   const sensitivityAnalysisMethods = useSensitivityAnalysisParametersForm({
     studyUuid: null,

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

@@ -56,7 +56,7 @@ const useSensitivityAnalysisParametersForm = ({
   name,
   description
 }) => {
-  const [providers, , , , , params, , updateParameters] = parametersBackend;
+  const { providers, params, updateParameters } = parametersBackend;
   const [sensitivityAnalysisParams, setSensitivityAnalysisParams] = useState(params);
   const { snackError } = useSnackMessage();
   const [factorsCount, setFactorsCount] = useState(DEFAULT_FACTOR_COUNT);

package/dist/components/parameters/short-circuit/short-circuit-parameters-dialog.js

@@ -7,7 +7,7 @@ import { ElementType } from "../../../utils/types/elementType.js";
 import "../../../utils/types/equipmentType.js";
 import "@mui/icons-material";
 import "../../../utils/yupConfig.js";
-import { getShortCircuitSpecificParametersDescription, updateShortCircuitParameters, fetchShortCircuitParameters } from "../../../services/short-circuit-analysis.js";
+import { fetchShortCircuitParameters, updateShortCircuitParameters, getShortCircuitSpecificParametersDescription } from "../../../services/short-circuit-analysis.js";
 import "react";
 import "@mui/material";
 import "react-intl";
@@ -55,19 +55,11 @@ function ShortCircuitParametersEditionDialog({
   language,
   isDeveloperMode
 }) {
-  const parametersBackend = useParametersBackend(
-    user,
-    id,
-    ComputingType.SHORT_CIRCUIT,
-    OptionalServicesStatus.Up,
-    null,
-    null,
-    null,
-    null,
-    fetchShortCircuitParameters,
-    updateShortCircuitParameters,
-    getShortCircuitSpecificParametersDescription
-  );
+  const parametersBackend = useParametersBackend(user, id, ComputingType.SHORT_CIRCUIT, OptionalServicesStatus.Up, {
+    backendFetchParameters: fetchShortCircuitParameters,
+    backendUpdateParameters: updateShortCircuitParameters,
+    backendFetchSpecificParametersDescription: getShortCircuitSpecificParametersDescription
+  });
   const shortCircuitMethods = useShortCircuitParametersForm({
     parametersBackend,
     parametersUuid: id,

package/dist/components/parameters/short-circuit/short-circuit-parameters-inline.js

@@ -59,7 +59,7 @@ function ShortCircuitParametersInLine({
   const intl = useIntl();
   const [openCreateParameterDialog, setOpenCreateParameterDialog] = useState(false);
   const [openSelectParameterDialog, setOpenSelectParameterDialog] = useState(false);
-  const [, , , , , , , , resetParameters, ,] = parametersBackend;
+  const { resetParameters } = parametersBackend;
   const [openResetConfirmation, setOpenResetConfirmation] = useState(false);
   const [pendingResetAction, setPendingResetAction] = useState(null);
   const { snackError } = useSnackMessage();

package/dist/components/parameters/short-circuit/use-short-circuit-parameters-form.d.ts

@@ -13,7 +13,6 @@ export interface UseShortCircuitParametersFormReturn {
     toShortCircuitFormValues: (_params: ShortCircuitParametersInfos) => any;
     formatNewParams: (formData: Record<string, any>) => ShortCircuitParametersInfos;
     params: ShortCircuitParametersInfos | null;
-    provider: string | undefined;
     paramsLoaded: boolean;
     onValidationError: (errors: FieldErrors) => void;
     onSaveInline: (formData: Record<string, any>) => void;

package/dist/components/parameters/short-circuit/use-short-circuit-parameters-form.js

@@ -51,12 +51,13 @@ const useShortCircuitParametersForm = ({
   name,
   description
 }) => {
-  const [, provider, , , , params, , updateParameters, , specificParamsDescriptions] = parametersBackend;
+  const { params, updateParameters, specificParamsDescription } = parametersBackend;
+  const provider = params?.provider;
   const [paramsLoaded, setParamsLoaded] = useState(false);
   const { snackError } = useSnackMessage();
   const specificParametersDescriptionForProvider = useMemo(() => {
-    return provider && specificParamsDescriptions?.[provider] ? specificParamsDescriptions[provider] : [];
-  }, [provider, specificParamsDescriptions]);
+    return provider && specificParamsDescription?.[provider] ? specificParamsDescription[provider] : [];
+  }, [provider, specificParamsDescription]);
   const specificParametersDefaultValues = useMemo(() => {
     return {
       ...getDefaultShortCircuitSpecificParamsValues(specificParametersDescriptionForProvider, snackError)
@@ -192,12 +193,12 @@ const useShortCircuitParametersForm = ({
     [formatNewParams, parametersUuid, snackError]
   );
   useEffect(() => {
-    if (!params || !provider || !specificParamsDescriptions) {
+    if (!params || !provider || !specificParamsDescription) {
       return;
     }
     reset(toShortCircuitFormValues(params));
     setParamsLoaded(true);
-  }, [provider, params, reset, specificParamsDescriptions, toShortCircuitFormValues]);
+  }, [provider, params, reset, specificParamsDescription, toShortCircuitFormValues]);
   return {
     formMethods,
     formSchema,
@@ -205,7 +206,6 @@ const useShortCircuitParametersForm = ({
     toShortCircuitFormValues,
     formatNewParams,
     params,
-    provider,
     paramsLoaded,
     onValidationError,
     onSaveInline,

package/dist/hooks/use-parameters-backend.d.ts

@@ -1,11 +1,10 @@
 import { UUID } from 'node:crypto';
 import { User } from 'oidc-client';
 import { ComputingType } from '../components/parameters/common/computing-type';
-import { ILimitReductionsByVoltageLevel } from '../components/parameters/common/limitreductions/columns-definitions';
-import { ParametersInfos, SpecificParametersDescription, UseParametersBackendReturnProps } from '../utils/types/parameters.type';
+import { BackendFunctions, UseParametersBackendReturnProps } from '../utils/types/parameters.type';
 export declare enum OptionalServicesStatus {
     Up = "UP",
     Down = "DOWN",
     Pending = "PENDING"
 }
-export declare const useParametersBackend: <T extends ComputingType>(user: User | null, studyUuid: UUID | null, type: T, optionalServiceStatus: OptionalServicesStatus | undefined, backendFetchProviders: (() => Promise<string[]>) | null, backendFetchProvider: ((studyUuid: UUID) => Promise<string>) | null, backendFetchDefaultProvider: (() => Promise<string>) | null, backendUpdateProvider: ((studyUuid: UUID, newProvider: string) => Promise<any>) | null, backendFetchParameters: (studyUuid: UUID) => Promise<ParametersInfos<T>>, backendUpdateParameters?: (studyUuid: UUID, newParam: ParametersInfos<T> | null) => Promise<any>, backendFetchSpecificParametersDescription?: () => Promise<SpecificParametersDescription>, backendFetchDefaultLimitReductions?: () => Promise<ILimitReductionsByVoltageLevel[]>) => UseParametersBackendReturnProps<T>;
+export declare const useParametersBackend: <T extends ComputingType>(user: User | null, studyUuid: UUID | null, type: T, optionalServiceStatus: OptionalServicesStatus | undefined, backendFunctions: BackendFunctions<T>) => UseParametersBackendReturnProps<T>;

package/dist/hooks/use-parameters-backend.js

@@ -1,101 +1,48 @@
-import { useRef, useState, useMemo, useCallback, useEffect } from "react";
+import { useState, useCallback, useEffect } from "react";
 import { useSnackMessage } from "./useSnackMessage.js";
-import { useDebounce } from "./useDebounce.js";
 import { formatComputingTypeLabel } from "../components/parameters/common/computing-type.js";
 import { snackWithFallback } from "../utils/error.js";
-const INITIAL_PROVIDERS = {};
 var OptionalServicesStatus = /* @__PURE__ */ ((OptionalServicesStatus2) => {
   OptionalServicesStatus2["Up"] = "UP";
   OptionalServicesStatus2["Down"] = "DOWN";
   OptionalServicesStatus2["Pending"] = "PENDING";
   return OptionalServicesStatus2;
 })(OptionalServicesStatus || {});
-const useParametersBackend = (user, studyUuid, type, optionalServiceStatus, backendFetchProviders, backendFetchProvider, backendFetchDefaultProvider, backendUpdateProvider, backendFetchParameters, backendUpdateParameters, backendFetchSpecificParametersDescription, backendFetchDefaultLimitReductions) => {
+const useParametersBackend = (user, studyUuid, type, optionalServiceStatus, backendFunctions) => {
   const { snackError, snackWarning } = useSnackMessage();
-  const providersRef = useRef(INITIAL_PROVIDERS);
-  const [provider, setProvider] = useState();
-  const providerRef = useRef(provider);
-  providerRef.current = provider;
+  const {
+    backendFetchProviders,
+    backendFetchParameters,
+    backendUpdateParameters,
+    backendFetchSpecificParametersDescription,
+    backendFetchDefaultLimitReductions
+  } = backendFunctions;
+  const [providers, setProviders] = useState({});
   const [params, setParams] = useState(null);
   const [specificParamsDescription, setSpecificParamsDescription] = useState(
     null
   );
   const [defaultLimitReductions, setDefaultLimitReductions] = useState([]);
-  const optionalServiceStatusRef = useRef(optionalServiceStatus);
-  optionalServiceStatusRef.current = optionalServiceStatus;
-  const currentParams = useMemo(() => {
-    if (params && "provider" in params && provider) {
-      return { ...params, provider };
-    }
-    return params;
-  }, [params, provider]);
-  const updateProvider = useCallback(
-    (newProvider) => {
-      if (!studyUuid) {
-        return;
-      }
-      const oldProvider = providerRef.current;
-      setProvider(newProvider);
-      backendUpdateProvider?.(studyUuid, newProvider).catch((error) => {
-        setProvider(oldProvider);
-        snackWithFallback(snackError, error, {
-          headerId: `update${formatComputingTypeLabel(type)}ProviderError`
-        });
-      });
-    },
-    [backendUpdateProvider, studyUuid, snackError, type]
-  );
-  const resetProvider = useCallback(() => {
-    backendFetchDefaultProvider?.().then((defaultProvider) => {
-      const providerNames = Object.keys(providersRef.current);
-      if (providerNames.length > 0) {
-        const newProvider = defaultProvider in providersRef.current ? defaultProvider : providerNames[0];
-        if (newProvider !== providerRef.current) {
-          updateProvider(newProvider);
-        }
-      }
-    }).catch((error) => {
-      snackWithFallback(snackError, error, {
-        headerId: `fetchDefault${formatComputingTypeLabel(type)}ProviderError`
-      });
-    });
-  }, [backendFetchDefaultProvider, updateProvider, snackError, type]);
   const fetchAvailableProviders = useCallback(() => {
-    return backendFetchProviders?.().then((providers) => {
-      const providersObj = providers.reduce((acc, v) => {
+    return backendFetchProviders?.().then((response) => {
+      const providersObj = response.reduce((acc, v) => {
         return {
           ...acc,
           [v]: v
         };
       }, {});
-      providersRef.current = providersObj;
+      setProviders(providersObj);
     }).catch((error) => {
       snackWithFallback(snackError, error, {
         headerId: `fetch${formatComputingTypeLabel(type)}ProvidersError`
       });
     });
   }, [backendFetchProviders, snackError, type]);
-  const fetchProvider = useCallback(
-    (_studyUuid) => {
-      backendFetchProvider?.(_studyUuid).then((newProvider) => {
-        if (newProvider in providersRef.current) {
-          setProvider(newProvider);
-        } else {
-          resetProvider();
-        }
-      }).catch((error) => {
-        snackWithFallback(snackError, error, {
-          headerId: `fetch${formatComputingTypeLabel(type)}ProviderError`
-        });
-      });
-    },
-    [backendFetchProvider, resetProvider, snackError, type]
-  );
   useEffect(() => {
-    if (user !== null && studyUuid && optionalServiceStatus === "UP") {
-      fetchAvailableProviders()?.then(() => fetchProvider(studyUuid));
+    if (user !== null && optionalServiceStatus === "UP") {
+      fetchAvailableProviders();
     }
-  }, [fetchAvailableProviders, fetchProvider, optionalServiceStatus, studyUuid, user]);
+  }, [fetchAvailableProviders, optionalServiceStatus, user]);
   const fetchSpecificParametersDescription = useCallback(() => {
     backendFetchSpecificParametersDescription?.().then((specificParams) => {
       setSpecificParamsDescription(specificParams);
@@ -109,7 +56,7 @@ const useParametersBackend = (user, studyUuid, type, optionalServiceStatus, back
     if (optionalServiceStatus === "UP") {
       fetchSpecificParametersDescription();
     }
-  }, [optionalServiceStatus, studyUuid, fetchSpecificParametersDescription]);
+  }, [optionalServiceStatus, fetchSpecificParametersDescription]);
   const fetchDefaultLimitReductions = useCallback(() => {
     backendFetchDefaultLimitReductions?.().then((defaultLimits) => {
       setDefaultLimitReductions(defaultLimits);
@@ -122,44 +69,27 @@ const useParametersBackend = (user, studyUuid, type, optionalServiceStatus, back
       fetchDefaultLimitReductions();
     }
   }, [optionalServiceStatus, fetchDefaultLimitReductions]);
-  const backendUpdateParametersCb = useCallback(
-    (_studyUuid, newParams, oldParams) => {
-      backendUpdateParameters?.(_studyUuid, newParams).catch((error) => {
-        setParams(oldParams);
-        if (oldParams && "provider" in oldParams) {
-          setProvider(oldParams.provider);
-        } else {
-          setProvider(void 0);
-        }
-        snackWithFallback(snackError, error, {
-          headerId: `update${formatComputingTypeLabel(type)}ParametersError`
-        });
-      });
-    },
-    [backendUpdateParameters, snackError, type]
-  );
-  const debouncedBackendUpdateParameters = useDebounce(backendUpdateParametersCb, 1e3);
-  const updateParameter = useCallback(
+  const updateParameters = useCallback(
     (newParams) => {
       if (!studyUuid) {
         return;
       }
-      const oldParams = currentParams ? { ...currentParams } : null;
+      const oldParams = params ? { ...params } : null;
       setParams(newParams);
-      if (newParams && "provider" in newParams) {
-        setProvider(newParams.provider);
-      } else {
-        setProvider(void 0);
-      }
-      debouncedBackendUpdateParameters(studyUuid, newParams, oldParams);
+      backendUpdateParameters?.(studyUuid, newParams).catch((error) => {
+        setParams(oldParams);
+        snackWithFallback(snackError, error, {
+          headerId: `update${formatComputingTypeLabel(type)}ParametersError`
+        });
+      });
     },
-    [debouncedBackendUpdateParameters, currentParams, studyUuid]
+    [backendUpdateParameters, params, snackError, studyUuid, type]
   );
   const resetParameters = useCallback(() => {
     if (!studyUuid || !backendUpdateParameters) {
-      return Promise.reject();
+      return;
     }
-    return backendUpdateParameters(studyUuid, null).then((response) => {
+    backendUpdateParameters(studyUuid, null).then((response) => {
       if (response.status === 204) {
         snackWarning({
           headerId: `reset${formatComputingTypeLabel(type)}ParametersWarning`
@@ -175,9 +105,6 @@ const useParametersBackend = (user, studyUuid, type, optionalServiceStatus, back
     (_studyUuid) => {
       backendFetchParameters(_studyUuid).then((_params) => {
         setParams(_params);
-        if ("provider" in _params) {
-          setProvider(_params.provider);
-        }
       }).catch((error) => {
         snackWithFallback(snackError, error, {
           headerId: `fetch${formatComputingTypeLabel(type)}ParametersError`
@@ -191,19 +118,15 @@ const useParametersBackend = (user, studyUuid, type, optionalServiceStatus, back
       fetchParameters(studyUuid);
     }
   }, [optionalServiceStatus, studyUuid, fetchParameters]);
-  return [
-    providersRef.current,
-    provider,
-    fetchProvider,
-    updateProvider,
-    resetProvider,
-    currentParams,
+  return {
+    providers,
+    params,
     fetchParameters,
-    updateParameter,
+    updateParameters,
     resetParameters,
     specificParamsDescription,
     defaultLimitReductions
-  ];
+  };
 };
 export {
   OptionalServicesStatus,

package/dist/index.js

@@ -209,9 +209,9 @@ import { fetchAppsMetadata, fetchBaseVoltages, fetchDefaultCountry, fetchEnv, fe
 import { fetchConfigParameter, fetchConfigParameters, getAppName, updateConfigParameter } from "./services/config.js";
 import { PermissionType, elementAlreadyExists, fetchDirectoryContent, fetchDirectoryElementPath, fetchRootFolders, hasElementPermission } from "./services/directory.js";
 import { createFilter, createParameter, fetchElementsInfos, saveFilter, updateParameter } from "./services/explore.js";
-import { PREFIX_STUDY_QUERIES, fetchLoadFlowParameters, getDefaultLoadFlowProvider, getLoadFlowDefaultLimitReductions, getLoadFlowProviders, getLoadFlowSpecificParametersDescription, getLoadFlowUrl, setLoadFlowParameters } from "./services/loadflow.js";
+import { PREFIX_STUDY_QUERIES, fetchLoadFlowParameters, getLoadFlowDefaultLimitReductions, getLoadFlowProviders, getLoadFlowSpecificParametersDescription, getLoadFlowUrl, setLoadFlowParameters } from "./services/loadflow.js";
 import { fetchPccMinParameters, getPccMinStudyParameters, updatePccMinParameters } from "./services/pcc-min.js";
-import { fetchDefaultSecurityAnalysisProvider, fetchSecurityAnalysisParameters, fetchSecurityAnalysisProviders, getSecurityAnalysisDefaultLimitReductions, getSecurityAnalysisParameters, getStudyUrl, setSecurityAnalysisParameters, updateSecurityAnalysisParameters, updateSecurityAnalysisProvider } from "./services/security-analysis.js";
+import { fetchSecurityAnalysisParameters, fetchSecurityAnalysisProviders, getSecurityAnalysisDefaultLimitReductions, getSecurityAnalysisParameters, getStudyUrl, setSecurityAnalysisParameters, updateSecurityAnalysisParameters } from "./services/security-analysis.js";
 import { exportFilter, getAvailableComponentLibraries, getStudyNetworkVisualizationsParameters, getStudyShortCircuitParameters, setStudyNetworkVisualizationParameters, updateVoltageInitParameters } from "./services/study.js";
 import { getNetworkVisualizationsParameters } from "./services/study-config.js";
 import { fetchCurrentAnnouncement, fetchUserDetails } from "./services/userAdmin.js";
@@ -817,7 +817,6 @@ export {
   fetchCsvSeparator,
   fetchCurrentAnnouncement,
   fetchDefaultCountry,
-  fetchDefaultSecurityAnalysisProvider,
   fetchDirectoryContent,
   fetchDirectoryElementPath,
   fetchDynamicMarginCalculationParameters,
@@ -849,7 +848,6 @@ export {
   getAvailableComponentLibraries,
   getComputedLanguage,
   getConcatenatedProperties,
-  getDefaultLoadFlowProvider,
   getEquipmentTypeShortLabel,
   getEquipmentsInfosForSearchBar,
   getExpertFilterEmptyFormData,
@@ -988,7 +986,6 @@ export {
   updateParameter,
   updatePccMinParameters,
   updateSecurityAnalysisParameters,
-  updateSecurityAnalysisProvider,
   updateShortCircuitParameters,
   updateVoltageInitParameters,
   useConfidentialityWarning,

package/dist/services/index.js

@@ -2,9 +2,9 @@ import { fetchAppsMetadata, fetchBaseVoltages, fetchDefaultCountry, fetchEnv, fe
 import { fetchConfigParameter, fetchConfigParameters, getAppName, updateConfigParameter } from "./config.js";
 import { PermissionType, elementAlreadyExists, fetchDirectoryContent, fetchDirectoryElementPath, fetchRootFolders, hasElementPermission } from "./directory.js";
 import { createFilter, createParameter, fetchElementsInfos, saveFilter, updateParameter } from "./explore.js";
-import { PREFIX_STUDY_QUERIES, fetchLoadFlowParameters, getDefaultLoadFlowProvider, getLoadFlowDefaultLimitReductions, getLoadFlowProviders, getLoadFlowSpecificParametersDescription, getLoadFlowUrl, setLoadFlowParameters } from "./loadflow.js";
+import { PREFIX_STUDY_QUERIES, fetchLoadFlowParameters, getLoadFlowDefaultLimitReductions, getLoadFlowProviders, getLoadFlowSpecificParametersDescription, getLoadFlowUrl, setLoadFlowParameters } from "./loadflow.js";
 import { fetchPccMinParameters, getPccMinStudyParameters, updatePccMinParameters } from "./pcc-min.js";
-import { fetchDefaultSecurityAnalysisProvider, fetchSecurityAnalysisParameters, fetchSecurityAnalysisProviders, getSecurityAnalysisDefaultLimitReductions, getSecurityAnalysisParameters, getStudyUrl, setSecurityAnalysisParameters, updateSecurityAnalysisParameters, updateSecurityAnalysisProvider } from "./security-analysis.js";
+import { fetchSecurityAnalysisParameters, fetchSecurityAnalysisProviders, getSecurityAnalysisDefaultLimitReductions, getSecurityAnalysisParameters, getStudyUrl, setSecurityAnalysisParameters, updateSecurityAnalysisParameters } from "./security-analysis.js";
 import { exportFilter, getAvailableComponentLibraries, getStudyNetworkVisualizationsParameters, getStudyShortCircuitParameters, setStudyNetworkVisualizationParameters, updateVoltageInitParameters } from "./study.js";
 import { getNetworkVisualizationsParameters } from "./study-config.js";
 import { fetchCurrentAnnouncement, fetchUserDetails } from "./userAdmin.js";
@@ -30,7 +30,6 @@ export {
   fetchConfigParameters,
   fetchCurrentAnnouncement,
   fetchDefaultCountry,
-  fetchDefaultSecurityAnalysisProvider,
   fetchDirectoryContent,
   fetchDirectoryElementPath,
   fetchDynamicMarginCalculationParameters,
@@ -49,7 +48,6 @@ export {
   fetchUserDetails,
   getAppName,
   getAvailableComponentLibraries,
-  getDefaultLoadFlowProvider,
   getLoadFlowDefaultLimitReductions,
   getLoadFlowProviders,
   getLoadFlowSpecificParametersDescription,
@@ -81,7 +79,6 @@ export {
   updateParameter,
   updatePccMinParameters,
   updateSecurityAnalysisParameters,
-  updateSecurityAnalysisProvider,
   updateShortCircuitParameters,
   updateVoltageInitParameters
 };

package/dist/services/loadflow.d.ts

@@ -4,6 +4,5 @@ export declare function getLoadFlowUrl(): string;
 export declare function getLoadFlowProviders(): Promise<any>;
 export declare function getLoadFlowSpecificParametersDescription(): Promise<any>;
 export declare function getLoadFlowDefaultLimitReductions(): Promise<any>;
-export declare function getDefaultLoadFlowProvider(): Promise<string>;
 export declare function fetchLoadFlowParameters(parameterUuid: string): Promise<any>;
 export declare function setLoadFlowParameters(parameterUuid: UUID, newParams: any): Promise<Response>;

package/dist/services/loadflow.js

@@ -1,4 +1,4 @@
-import { backendFetchJson, backendFetchText, backendFetch } from "./utils.js";
+import { backendFetchJson, backendFetch } from "./utils.js";
 const PREFIX_LOADFLOW_SERVER_QUERIES = `${"api/gateway"}/loadflow`;
 const PREFIX_STUDY_QUERIES = `${"api/gateway"}/study`;
 function getLoadFlowUrl() {
@@ -22,12 +22,6 @@ function getLoadFlowDefaultLimitReductions() {
   console.debug(getLoadFlowDefaultLimitReductionsUrl);
   return backendFetchJson(getLoadFlowDefaultLimitReductionsUrl);
 }
-function getDefaultLoadFlowProvider() {
-  console.info("get default load flow provier");
-  const getDefaultLoadFlowProviderUrl = `${PREFIX_STUDY_QUERIES}/v1/loadflow-default-provider`;
-  console.debug(getDefaultLoadFlowProviderUrl);
-  return backendFetchText(getDefaultLoadFlowProviderUrl);
-}
 function fetchLoadFlowParameters(parameterUuid) {
   console.info("fetch load flow parameters");
   const url = `${getLoadFlowUrl()}parameters/${encodeURIComponent(parameterUuid)}`;
@@ -50,7 +44,6 @@ function setLoadFlowParameters(parameterUuid, newParams) {
 export {
   PREFIX_STUDY_QUERIES,
   fetchLoadFlowParameters,
-  getDefaultLoadFlowProvider,
   getLoadFlowDefaultLimitReductions,
   getLoadFlowProviders,
   getLoadFlowSpecificParametersDescription,

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

@@ -3,8 +3,6 @@ export declare const getStudyUrl: (studyUuid: UUID | null) => string;
 export declare function fetchSecurityAnalysisProviders(): Promise<any>;
 export declare function fetchSecurityAnalysisParameters(parameterUuid: string): Promise<any>;
 export declare function getSecurityAnalysisDefaultLimitReductions(): Promise<any>;
-export declare function updateSecurityAnalysisProvider(studyUuid: UUID, newProvider: string): Promise<Response>;
-export declare function fetchDefaultSecurityAnalysisProvider(): Promise<string>;
 export declare function getSecurityAnalysisParameters(studyUuid: UUID): Promise<any>;
 export declare function setSecurityAnalysisParameters(studyUuid: UUID, newParams: any): Promise<Response>;
 export declare function updateSecurityAnalysisParameters(parameterUuid: UUID, newParams: any): Promise<Response>;

package/dist/services/security-analysis.js

@@ -1,4 +1,4 @@
-import { safeEncodeURIComponent, backendFetchJson, backendFetch, backendFetchText } from "./utils.js";
+import { safeEncodeURIComponent, backendFetchJson, backendFetch } from "./utils.js";
 import { PREFIX_STUDY_QUERIES } from "./loadflow.js";
 const PREFIX_SECURITY_ANALYSIS_SERVER_QUERIES = `${"api/gateway"}/security-analysis`;
 const getStudyUrl = (studyUuid) => `${PREFIX_STUDY_QUERIES}/v1/studies/${safeEncodeURIComponent(studyUuid)}`;
@@ -23,25 +23,6 @@ function getSecurityAnalysisDefaultLimitReductions() {
   console.debug(url);
   return backendFetchJson(url);
 }
-function updateSecurityAnalysisProvider(studyUuid, newProvider) {
-  console.info("update security analysis provider");
-  const url = `${getStudyUrl(studyUuid)}/security-analysis/provider`;
-  console.debug(url);
-  return backendFetch(url, {
-    method: "POST",
-    headers: {
-      Accept: "application/json",
-      "Content-Type": "application/json"
-    },
-    body: newProvider
-  });
-}
-function fetchDefaultSecurityAnalysisProvider() {
-  console.info("fetch default security analysis provider");
-  const url = `${PREFIX_STUDY_QUERIES}/v1/security-analysis-default-provider`;
-  console.debug(url);
-  return backendFetchText(url);
-}
 function getSecurityAnalysisParameters(studyUuid) {
   console.info("get security analysis parameters");
   const url = `${getStudyUrl(studyUuid)}/security-analysis/parameters`;
@@ -75,13 +56,11 @@ function updateSecurityAnalysisParameters(parameterUuid, newParams) {
   });
 }
 export {
-  fetchDefaultSecurityAnalysisProvider,
   fetchSecurityAnalysisParameters,
   fetchSecurityAnalysisProviders,
   getSecurityAnalysisDefaultLimitReductions,
   getSecurityAnalysisParameters,
   getStudyUrl,
   setSecurityAnalysisParameters,
-  updateSecurityAnalysisParameters,
-  updateSecurityAnalysisProvider
+  updateSecurityAnalysisParameters
 };

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

@@ -8,5 +8,4 @@ export declare function getSensitivityAnalysisParameters(studyUuid: UUID): Promi
 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, newParams: SensitivityAnalysisParametersInfos): Promise<FactorsCount>;
-export declare function fetchDefaultSensitivityAnalysisProvider(): Promise<string>;
 export declare function updateSensitivityAnalysisParameters(parameterUuid: UUID, newParams: any): Promise<Response>;

package/dist/services/sensitivity-analysis.js

@@ -1,4 +1,4 @@
-import { safeEncodeURIComponent, backendFetchJson, backendFetch, backendFetchText } from "./utils.js";
+import { safeEncodeURIComponent, backendFetchJson, backendFetch } from "./utils.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`;
@@ -52,12 +52,6 @@ function getSensitivityAnalysisFactorsCount(studyUuid, currentNodeUuid, currentR
     body: JSON.stringify(newParams)
   });
 }
-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}`;
@@ -72,7 +66,6 @@ function updateSensitivityAnalysisParameters(parameterUuid, newParams) {
   });
 }
 export {
-  fetchDefaultSensitivityAnalysisProvider,
   fetchSensitivityAnalysisParameters,
   fetchSensitivityAnalysisProviders,
   getSensiUrl,

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

@@ -236,19 +236,12 @@ export declare const parametersEn: {
     fetchLoadFlowProvidersError: string;
     fetchLoadFlowSpecificParametersError: string;
     updateLoadFlowParametersError: string;
-    updateLoadFlowProviderError: string;
-    fetchDefaultSecurityAnalysisProviderError: string;
     fetchSecurityAnalysisParametersError: string;
-    fetchSecurityAnalysisProviderError: string;
     fetchSecurityAnalysisProvidersError: string;
     updateSecurityAnalysisParametersError: string;
-    updateSecurityAnalysisProviderError: string;
-    fetchDefaultSensitivityAnalysisProviderError: string;
     fetchSensitivityAnalysisParametersError: string;
-    fetchSensitivityAnalysisProviderError: string;
     fetchSensitivityAnalysisProvidersError: string;
     updateSensitivityAnalysisParametersError: string;
-    updateSensitivityAnalysisProviderError: string;
     getSensitivityAnalysisFactorsCountError: string;
     resetLoadFlowParametersWarning: string;
     PccMinParametersError: string;

package/dist/translations/en/parameters.js

@@ -232,21 +232,14 @@ const parametersEn = {
   fetchLoadFlowProvidersError: "An error occurred while fetching the load flow providers",
   fetchLoadFlowSpecificParametersError: "An error occured when fetching the load flow specific parameters",
   updateLoadFlowParametersError: "An error occurred while updating the load flow parameters",
-  updateLoadFlowProviderError: "An error occurred while updating the load flow provider",
   // SecurityAnalysis
-  fetchDefaultSecurityAnalysisProviderError: "An error occured when fetching default security analysis provider",
   fetchSecurityAnalysisParametersError: "An error occured when fetching the security analysis parameters",
-  fetchSecurityAnalysisProviderError: "An error occured when fetching security analysis provider",
   fetchSecurityAnalysisProvidersError: "An error occured when fetching security analysis provider list",
   updateSecurityAnalysisParametersError: "An error occurred while updating the security analysis parameters",
-  updateSecurityAnalysisProviderError: "An error occured when updating security analysis provider",
   // SensitivityAnalysis
-  fetchDefaultSensitivityAnalysisProviderError: "An error occured when fetching default sensitivity analysis provider",
   fetchSensitivityAnalysisParametersError: "An error occured when fetching the sensitivity analysis parameters",
-  fetchSensitivityAnalysisProviderError: "An error occured when fetching sensitivity analysis provider",
   fetchSensitivityAnalysisProvidersError: "An error occured when fetching sensitivity analysis provider list",
   updateSensitivityAnalysisParametersError: "An error occurred while updating the sensitivity analysis parameters",
-  updateSensitivityAnalysisProviderError: "An error occured when updating sensitivity analysis provider",
   getSensitivityAnalysisFactorsCountError: "An error occured while estimating sensitivity analysis computations",
   // Other
   resetLoadFlowParametersWarning: "Impossible to retrieve the load flow parameters defined in the user profile (default values are used)",

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

@@ -231,25 +231,17 @@ export declare const parametersFr: {
     loadingComputing: string;
     AddRows: string;
     Optional: string;
-    fetchDefaultLoadFlowProviderError: string;
     fetchLoadFlowParametersError: string;
     fetchLoadFlowProviderError: string;
     fetchLoadFlowProvidersError: string;
     fetchLoadFlowSpecificParametersError: string;
     updateLoadFlowParametersError: string;
-    updateLoadFlowProviderError: string;
-    fetchDefaultSecurityAnalysisProviderError: string;
     fetchSecurityAnalysisParametersError: string;
-    fetchSecurityAnalysisProviderError: string;
     fetchSecurityAnalysisProvidersError: string;
     updateSecurityAnalysisParametersError: string;
-    updateSecurityAnalysisProviderError: string;
-    fetchDefaultSensitivityAnalysisProviderError: string;
     fetchSensitivityAnalysisParametersError: string;
-    fetchSensitivityAnalysisProviderError: string;
     fetchSensitivityAnalysisProvidersError: string;
     updateSensitivityAnalysisParametersError: string;
-    updateSensitivityAnalysisProviderError: string;
     getSensitivityAnalysisFactorsCountError: string;
     resetLoadFlowParametersWarning: string;
     PccMinParametersError: string;

package/dist/translations/fr/parameters.js

@@ -227,27 +227,19 @@ const parametersFr = {
   Optional: " (optionnel)",
   // Computed translations used in the snackbars
   // LoadFlow
-  fetchDefaultLoadFlowProviderError: "Une erreur est survenue lors de la récupération du fournisseur de calcul de répartition par défaut",
   fetchLoadFlowParametersError: "Une erreur est survenue lors de la récupération des paramètres de calcul de répartition",
   fetchLoadFlowProviderError: "Une erreur est survenue lors de la récupération du fournisseur de calcul de répartition",
   fetchLoadFlowProvidersError: "Une erreur est survenue lors de la récupération des fournisseurs de calcul de répartition",
   fetchLoadFlowSpecificParametersError: "Une erreur est survenue lors de la récupération des paramètres spécifiques de calcul de répartition",
   updateLoadFlowParametersError: "Une erreur est survenue lors de la mise à jour des paramètres de calcul de répartition",
-  updateLoadFlowProviderError: "Une erreur est survenue lors de la mise à jour du fournisseur courant de calcul de répartition",
   // SecurityAnalysis
-  fetchDefaultSecurityAnalysisProviderError: "Une erreur est survenue lors de la récupération du fournisseur d'analyse de sécurité par défaut",
   fetchSecurityAnalysisParametersError: "Une erreur est survenue lors de la récupération des paramètres de l'analyse de sécurité",
-  fetchSecurityAnalysisProviderError: "Une erreur est survenue lors de la récupération du fournisseur courant d'analyse de sécurité",
   fetchSecurityAnalysisProvidersError: "Une erreur est survenue lors de la récupération des fournisseurs d'analyse de sécurité",
   updateSecurityAnalysisParametersError: "Une erreur est survenue lors de la mise a jour des paramètres de l'analyse de sécurité",
-  updateSecurityAnalysisProviderError: "Une erreur est survenue lors de la mise a jour du fournisseur courant d'analyse de sécurité",
   // SensitivityAnalysis
-  fetchDefaultSensitivityAnalysisProviderError: "Une erreur est survenue lors de la récupération du fournisseur d'analyse de sensibilité par défaut",
   fetchSensitivityAnalysisParametersError: "Une erreur est survenue lors de la récupération des paramètres de l'analyse de sensibilité",
-  fetchSensitivityAnalysisProviderError: "Une erreur est survenue lors de la récupération du fournisseur courant d'analyse de sensibilité",
   fetchSensitivityAnalysisProvidersError: "Une erreur est survenue lors de la récupération des fournisseurs d'analyse de sensibilité",
   updateSensitivityAnalysisParametersError: "Une erreur est survenue lors de la mise a jour des paramètres de l'analyse de sensibilité",
-  updateSensitivityAnalysisProviderError: "Une erreur est survenue lors de la mise a jour du fournisseur courant d'analyse de sensibilité",
   getSensitivityAnalysisFactorsCountError: "Une erreur est survenue lors de l'estimation du nombre de calculs",
   // Other
   resetLoadFlowParametersWarning: "Impossible de récupérer les paramètres de calcul de répartition définis dans le profil utilisateur (les valeurs par défaut sont appliquées)",

package/dist/utils/types/parameters.type.d.ts

@@ -30,16 +30,19 @@ export type SpecificParametersDescription = Record<string, SpecificParameterInfo
 export type SpecificParametersValues = Record<string, any>;
 export type SpecificParametersPerProvider = Record<string, SpecificParametersValues>;
 export type ParametersInfos<T extends ComputingType> = T extends ComputingType.SENSITIVITY_ANALYSIS ? SensitivityAnalysisParametersInfos : T extends ComputingType.SECURITY_ANALYSIS ? SAParameters : T extends ComputingType.LOAD_FLOW ? LoadFlowParametersInfos : T extends ComputingType.DYNAMIC_SIMULATION ? DynamicSimulationParametersFetchReturn : T extends ComputingType.DYNAMIC_SECURITY_ANALYSIS ? DynamicSecurityAnalysisParametersFetchReturn : T extends ComputingType.DYNAMIC_MARGIN_CALCULATION ? DynamicMarginCalculationParametersInfos : T extends ComputingType.SHORT_CIRCUIT ? ShortCircuitParametersInfos : Record<string, any>;
-export type UseParametersBackendReturnProps<T extends ComputingType> = [
-    Record<string, string>,
-    string | undefined,
-    (studyUuid: UUID) => void,
-    (newProvider: string) => void,
-    () => void,
-    ParametersInfos<T> | null,
-    (studyUuid: UUID) => void,
-    (newParams: ParametersInfos<T>) => void,
-    () => Promise<void> | undefined,
-    SpecificParametersDescription | null,
-    ILimitReductionsByVoltageLevel[]
-];
+export type BackendFunctions<T extends ComputingType> = {
+    backendFetchProviders?: (() => Promise<string[]>) | null;
+    backendFetchParameters: (paramsUuidOrStudyUuid: UUID) => Promise<ParametersInfos<T>>;
+    backendUpdateParameters?: (paramsUuidOrStudyUuid: UUID, newParam: ParametersInfos<T> | null) => Promise<any>;
+    backendFetchSpecificParametersDescription?: () => Promise<SpecificParametersDescription>;
+    backendFetchDefaultLimitReductions?: () => Promise<ILimitReductionsByVoltageLevel[]>;
+};
+export type UseParametersBackendReturnProps<T extends ComputingType> = {
+    providers: Record<string, string>;
+    params: ParametersInfos<T> | null;
+    fetchParameters: (paramsUuidOrStudyUuid: UUID) => void;
+    updateParameters: (newParams: ParametersInfos<T>) => void;
+    resetParameters: () => void;
+    specificParamsDescription: SpecificParametersDescription | null;
+    defaultLimitReductions: ILimitReductionsByVoltageLevel[];
+};

package/package.json

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