@gridsuite/commons-ui 0.192.0 → 0.193.0

package/dist/components/parameters/dynamic-simulation/curve/dialog/model-filter-utils.js

@@ -0,0 +1,68 @@
+const modelsToVariablesTree = (models) => {
+  return models.reduce(
+    (obj, model) => ({
+      ...obj,
+      [model.modelName]: {
+        ...model.variableDefinitions.reduce(
+          (_obj, variable) => ({
+            ..._obj,
+            [variable.name]: variable.name
+          }),
+          {}
+        ),
+        ...model.variablesSets.reduce(
+          (_obj, variablesSet) => ({
+            ..._obj,
+            [variablesSet.name]: variablesSet.variableDefinitions.reduce(
+              (__obj, variable) => ({
+                ...__obj,
+                [variable.name]: variable.name
+              }),
+              {}
+            )
+          }),
+          {}
+        )
+      }
+    }),
+    {}
+  );
+};
+const variablesTreeToVariablesArray = (variablesTree, parentId) => {
+  let result = [];
+  Object.entries(variablesTree).forEach(([key, value]) => {
+    const id = parentId ? `${parentId}/${key}` : key;
+    if (typeof value === "object") {
+      result = [
+        ...result,
+        {
+          id,
+          name: key,
+          parentId
+        }
+      ];
+      result = [...result, ...variablesTreeToVariablesArray(value, id)];
+    }
+    if (typeof value === "string") {
+      result = [
+        ...result,
+        {
+          id,
+          name: value,
+          parentId,
+          variableId: key
+        }
+      ];
+    }
+    return result;
+  });
+  return result;
+};
+function modelsToVariables(models) {
+  const variablesTree = modelsToVariablesTree(models);
+  const variables = variablesTreeToVariablesArray(variablesTree);
+  return variables;
+}
+export {
+  modelsToVariables
+};

package/dist/components/parameters/dynamic-simulation/curve/dialog/model-filter.d.ts

@@ -0,0 +1,12 @@
+import { DynamicSimulationModelInfos } from '../../../../../utils/types/dynamic-simulation.type';
+import { EquipmentType } from '../../../../../utils/types/equipmentType';
+import { ModelVariable } from '../common/curve.type';
+export type ModelFilterApi = {
+    getSelectedVariables: () => ModelVariable[];
+};
+interface ModelFilterProps {
+    equipmentType: EquipmentType;
+    modelsFetcher?: () => Promise<DynamicSimulationModelInfos[]> | undefined;
+}
+declare const ModelFilter: import('react').ForwardRefExoticComponent<ModelFilterProps & import('react').RefAttributes<ModelFilterApi>>;
+export default ModelFilter;

package/dist/components/parameters/dynamic-simulation/curve/dialog/model-filter.js

@@ -0,0 +1,148 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { useIntl, FormattedMessage } from "react-intl";
+import { forwardRef, useState, useRef, useMemo, useCallback, useEffect, useImperativeHandle } from "react";
+import { Grid, Typography, Box } from "@mui/material";
+import CheckboxSelect from "../common/checkbox-select.js";
+import CheckboxTreeview from "../common/checkbox-treeview.js";
+import { EquipmentType } from "../../../../../utils/types/equipmentType.js";
+import { modelsToVariables } from "./model-filter-utils.js";
+import { snackWithFallback } from "../../../../../utils/error.js";
+import { useSnackMessage } from "../../../../../hooks/useSnackMessage.js";
+const makeGetModelLabel = (intl) => (value) => intl.formatMessage({
+  id: `models.${value}`
+});
+const makeGetVariableLabel = (intl) => (elem) => {
+  if (!elem.parentId) {
+    return intl.formatMessage({ id: `models.${elem.name}` });
+  }
+  if (elem.variableId) {
+    return intl.formatMessage({
+      id: `variables.${elem.name}`
+    });
+  }
+  return intl.formatMessage({
+    id: `variableSets.${elem.name}`
+  });
+};
+const styles = {
+  tree: (theme) => ({
+    width: "100%",
+    height: "100%",
+    border: "solid",
+    borderWidth: ".5px",
+    borderColor: theme.palette.divider,
+    overflow: "auto"
+  }),
+  model: {
+    width: "100%"
+  },
+  modelTitle: (theme) => ({
+    marginBottom: theme.spacing(1)
+  }),
+  variable: {
+    width: "100%",
+    flexGrow: 1
+  },
+  variableTree: {
+    maxHeight: "440px"
+  }
+};
+const ModelFilter = forwardRef(
+  ({ equipmentType = EquipmentType.GENERATOR, modelsFetcher }, ref) => {
+    const intl = useIntl();
+    const { snackError } = useSnackMessage();
+    const [allModels, setAllModels] = useState([]);
+    const [variables, setVariables] = useState([]);
+    const variablesRef = useRef(null);
+    const associatedModels = useMemo(() => {
+      const associatedModelsArray = allModels?.filter((model) => model.equipmentType === equipmentType);
+      return associatedModelsArray ? associatedModelsArray.reduce(
+        (obj, model) => ({
+          ...obj,
+          [model.name]: model.name
+        }),
+        {}
+      ) : {};
+    }, [equipmentType, allModels]);
+    const initialSelectedModels = useMemo(() => Object.keys(associatedModels) ?? [], [associatedModels]);
+    const [selectedModels, setSelectedModels] = useState([]);
+    const handleModelChange = useCallback((_selectedModels) => {
+      setSelectedModels(_selectedModels);
+    }, []);
+    useEffect(() => {
+      setSelectedModels(initialSelectedModels);
+    }, [initialSelectedModels]);
+    const filteredVariables = useMemo(
+      () => variables.filter(
+        (elem) => selectedModels.some((model) => {
+          const modelName = associatedModels[model];
+          return elem.id === modelName || elem.id.startsWith(`${modelName}/`);
+        })
+      ),
+      [variables, selectedModels, associatedModels]
+    );
+    useEffect(() => {
+      modelsFetcher?.()?.then((models) => {
+        setAllModels(
+          models.map((model) => ({
+            name: model.modelName,
+            equipmentType: model.equipmentType
+          }))
+        );
+        const variablesArray = modelsToVariables(models);
+        setVariables(variablesArray);
+      }).catch((error) => {
+        snackWithFallback(snackError, error, { headerId: "DynamicSimulationModelsFetcherError" });
+      });
+    }, [modelsFetcher, snackError]);
+    const getSelectedVariables = useCallback(() => {
+      return variablesRef.current?.getSelectedItems().filter((item) => item.variableId).filter(
+        (item, index, arr) => arr.findIndex((elem) => elem.variableId === item.variableId) === index
+      ) ?? [];
+    }, []);
+    useImperativeHandle(
+      ref,
+      () => ({
+        getSelectedVariables
+      }),
+      [getSelectedVariables]
+    );
+    const getModelLabel = useMemo(() => {
+      return makeGetModelLabel(intl);
+    }, [intl]);
+    const getVariableLabel = useMemo(() => {
+      return makeGetVariableLabel(intl);
+    }, [intl]);
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(Grid, { item: true, container: true, sx: styles.model, children: [
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: 6, children: /* @__PURE__ */ jsx(Typography, { children: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurveModel" }) }) }),
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: 6, children: /* @__PURE__ */ jsx(
+          CheckboxSelect,
+          {
+            options: initialSelectedModels,
+            getOptionLabel: getModelLabel,
+            value: selectedModels,
+            onChange: handleModelChange,
+            disabled: initialSelectedModels.length === 1
+          }
+        ) })
+      ] }),
+      /* @__PURE__ */ jsxs(Grid, { item: true, sx: styles.variable, container: true, direction: "column", children: [
+        /* @__PURE__ */ jsx(Grid, { item: true, width: "100%", children: /* @__PURE__ */ jsx(Typography, { sx: styles.modelTitle, variant: "subtitle1", children: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurveVariable" }) }) }),
+        /* @__PURE__ */ jsx(Grid, { item: true, width: "100%", xs: true, children: /* @__PURE__ */ jsx(Box, { sx: styles.tree, children: /* @__PURE__ */ jsx(
+          CheckboxTreeview,
+          {
+            ref: variablesRef,
+            data: filteredVariables,
+            getLabel: getVariableLabel,
+            checkAll: true,
+            sx: styles.variableTree
+          }
+        ) }) })
+      ] })
+    ] });
+  }
+);
+export {
+  ModelFilter as default
+};

package/dist/components/parameters/dynamic-simulation/dynamic-simulation-inline.d.ts

@@ -0,0 +1,15 @@
+import { UUID } from 'node:crypto';
+import { VoltageLevelInfos } from '../../../utils';
+import { UseParametersBackendReturnProps } from '../../../utils/types/parameters.type';
+import { ComputingType } from '../common';
+import { ExpertFilter, IdentifiableAttributes } from '../../filter';
+type DynamicSimulationInlineProps = {
+    studyUuid: UUID | null;
+    parametersBackend: UseParametersBackendReturnProps<ComputingType.DYNAMIC_SIMULATION>;
+    setHaveDirtyFields: (isDirty: boolean) => void;
+    voltageLevelsFetcher: () => Promise<VoltageLevelInfos[]>;
+    countriesFetcher: () => Promise<string[]>;
+    evaluateFilterFetcher: (filter: ExpertFilter) => Promise<IdentifiableAttributes[]>;
+};
+export declare function DynamicSimulationInline({ studyUuid, parametersBackend, setHaveDirtyFields, voltageLevelsFetcher, countriesFetcher, evaluateFilterFetcher, }: Readonly<DynamicSimulationInlineProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/parameters/dynamic-simulation/dynamic-simulation-inline.js

@@ -0,0 +1,191 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { useIntl, FormattedMessage } from "react-intl";
+import { useState, useCallback, useEffect } from "react";
+import { Grid } from "@mui/material";
+import "../../../utils/conversionUtils.js";
+import { snackWithFallback } from "../../../utils/error.js";
+import { ElementType } from "../../../utils/types/elementType.js";
+import "../../../utils/types/equipmentType.js";
+import "@mui/icons-material";
+import { mergeSx } from "../../../utils/styles.js";
+import "../../../utils/yupConfig.js";
+import { LabelledButton } from "../common/parameters.js";
+import { CreateParameterDialog } from "../common/parameters-creation-dialog.js";
+import { parametersStyles } from "../parameters-style.js";
+import "../../overflowableText/OverflowableText.js";
+import "react-hook-form";
+import { fetchDynamicSimulationParameters } from "../../../services/dynamic-simulation.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import { useSnackMessage } from "../../../hooks/useSnackMessage.js";
+import { CustomFormProvider } from "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import { SubmitButton } from "../../inputs/reactHookForm/utils/SubmitButton.js";
+import "yup";
+import { DirectoryItemSelector } from "../../directoryItemSelector/DirectoryItemSelector.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 { PopupConfirmationDialog } from "../../dialogs/popupConfirmationDialog/PopupConfirmationDialog.js";
+import "@material-symbols/svg-400/outlined/left_panel_open.svg?react";
+import "@material-symbols/svg-400/outlined/arrows_output.svg?react";
+import "@material-symbols/svg-400/outlined/left_panel_close.svg?react";
+import "@material-symbols/svg-400/outlined/add_notes.svg?react";
+import "../../dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
+import "../../inputs/reactHookForm/expandableInput/ExpandableInput.js";
+import "@react-querybuilder/material";
+import "../../filter/expert/expertFilterConstants.js";
+import "../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "uuid";
+import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
+import "react-querybuilder";
+import "../common/widget/parameter-line-slider.js";
+import "../common/limitreductions/columns-definitions.js";
+import "../common/contingency-table/columns-definitions.js";
+import "@hookform/resolvers/yup";
+import "../../filter/HeaderFilterForm.js";
+import "../../dialogs/elementSaveDialog/ElementSaveDialog.js";
+import { useDynamicSimulationParametersForm, toParamsInfos, toFormValues } from "./use-dynamic-simulation-parameters-form.js";
+import { DynamicSimulationForm } from "./dynamic-simulation-parameters-form.js";
+import useDefaultParams from "./hook/use-default-params.js";
+function DynamicSimulationInline({
+  studyUuid,
+  parametersBackend,
+  setHaveDirtyFields,
+  voltageLevelsFetcher,
+  countriesFetcher,
+  evaluateFilterFetcher
+}) {
+  const { providers, params, updateParameters, resetParameters } = parametersBackend;
+  const dynamicSimulationMethods = useDynamicSimulationParametersForm({
+    providers,
+    params,
+    name: null,
+    description: null
+  });
+  const intl = useIntl();
+  const { snackError } = useSnackMessage();
+  const { getDefaultParams, setDefaultParams } = useDefaultParams(params);
+  const [openCreateParameterDialog, setOpenCreateParameterDialog] = useState(false);
+  const [openSelectParameterDialog, setOpenSelectParameterDialog] = useState(false);
+  const [openResetConfirmation, setOpenResetConfirmation] = useState(false);
+  const { formSchema, formMethods } = dynamicSimulationMethods;
+  const { reset, handleSubmit, getValues, formState } = formMethods;
+  const handleResetClick = useCallback(() => {
+    setOpenResetConfirmation(true);
+  }, []);
+  const handleCancelReset = useCallback(() => {
+    setOpenResetConfirmation(false);
+  }, []);
+  const handleReset = useCallback(() => {
+    resetParameters();
+    setOpenResetConfirmation(false);
+  }, [resetParameters]);
+  const onSubmit = useCallback(
+    (formData) => {
+      updateParameters(toParamsInfos(formData, getDefaultParams()));
+    },
+    [updateParameters, getDefaultParams]
+  );
+  const handleLoadParameter = useCallback(
+    (newParams) => {
+      if (newParams?.length) {
+        setOpenSelectParameterDialog(false);
+        const parametersUuid = newParams[0].id;
+        fetchDynamicSimulationParameters(parametersUuid).then((_params) => {
+          reset(toFormValues(_params), {
+            keepDefaultValues: true
+          });
+          setDefaultParams(_params);
+        }).catch((error) => {
+          snackWithFallback(snackError, error, { headerId: "paramsRetrievingError" });
+        });
+      }
+      setOpenSelectParameterDialog(false);
+    },
+    [reset, setDefaultParams, snackError]
+  );
+  useEffect(() => {
+    setHaveDirtyFields(!!Object.keys(formState.dirtyFields).length);
+  }, [formState, setHaveDirtyFields]);
+  const renderActions = (onSubmitError) => {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Grid, { container: true, item: true, children: /* @__PURE__ */ jsxs(
+        Grid,
+        {
+          sx: mergeSx(parametersStyles.controlParametersItem, {
+            paddingTop: 1,
+            paddingBottom: 2,
+            paddingLeft: 0
+          }),
+          children: [
+            /* @__PURE__ */ jsx(
+              LabelledButton,
+              {
+                disabled: true,
+                callback: () => setOpenSelectParameterDialog(true),
+                label: "settings.button.chooseSettings"
+              }
+            ),
+            /* @__PURE__ */ jsx(LabelledButton, { disabled: true, callback: () => setOpenCreateParameterDialog(true), label: "save" }),
+            /* @__PURE__ */ jsx(LabelledButton, { callback: handleResetClick, label: "resetToDefault" }),
+            /* @__PURE__ */ jsx(SubmitButton, { variant: "outlined", onClick: handleSubmit(onSubmit, onSubmitError), children: /* @__PURE__ */ jsx(FormattedMessage, { id: "validate" }) })
+          ]
+        }
+      ) }),
+      openCreateParameterDialog && /* @__PURE__ */ jsx(
+        CreateParameterDialog,
+        {
+          studyUuid,
+          open: openCreateParameterDialog,
+          onClose: () => setOpenCreateParameterDialog(false),
+          parameterValues: getValues,
+          parameterFormatter: (formData) => toParamsInfos(formData, getDefaultParams()),
+          parameterType: ElementType.DYNAMIC_SIMULATION_PARAMETERS
+        }
+      ),
+      openSelectParameterDialog && /* @__PURE__ */ jsx(
+        DirectoryItemSelector,
+        {
+          open: openSelectParameterDialog,
+          onClose: handleLoadParameter,
+          types: [ElementType.DYNAMIC_SIMULATION_PARAMETERS],
+          title: intl.formatMessage({
+            id: "showSelectParameterDialog"
+          }),
+          onlyLeaves: true,
+          multiSelect: false,
+          validationButtonText: intl.formatMessage({
+            id: "validate"
+          })
+        }
+      ),
+      openResetConfirmation && /* @__PURE__ */ jsx(
+        PopupConfirmationDialog,
+        {
+          message: "resetParamsConfirmation",
+          validateButtonLabel: "validate",
+          openConfirmationPopup: openResetConfirmation,
+          setOpenConfirmationPopup: handleCancelReset,
+          handlePopupConfirmation: handleReset
+        }
+      )
+    ] });
+  };
+  return /* @__PURE__ */ jsx(CustomFormProvider, { validationSchema: formSchema, ...formMethods, children: /* @__PURE__ */ jsx(
+    DynamicSimulationForm,
+    {
+      dynamicSimulationMethods,
+      renderActions,
+      voltageLevelsFetcher,
+      countriesFetcher,
+      evaluateFilterFetcher
+    }
+  ) });
+}
+export {
+  DynamicSimulationInline
+};

package/dist/components/parameters/dynamic-simulation/dynamic-simulation-parameters-form.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { FieldErrors } from 'react-hook-form';
+import { VoltageLevelInfos } from '../../../utils/types/equipmentType';
+import { ExpertFilter, IdentifiableAttributes } from '../../filter';
+import { UseComputationParametersFormReturn } from '../common/utils';
+type DynamicSimulationFormProps = {
+    dynamicSimulationMethods: UseComputationParametersFormReturn;
+    renderTitleFields?: () => ReactNode;
+    renderActions?: (onSubmitError: (errors: FieldErrors) => void) => ReactNode;
+    voltageLevelsFetcher?: () => Promise<VoltageLevelInfos[]>;
+    countriesFetcher?: () => Promise<string[]>;
+    evaluateFilterFetcher?: (filter: ExpertFilter) => Promise<IdentifiableAttributes[]>;
+};
+export declare function DynamicSimulationForm({ dynamicSimulationMethods, renderTitleFields, renderActions, voltageLevelsFetcher, countriesFetcher, evaluateFilterFetcher, }: Readonly<DynamicSimulationFormProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/parameters/dynamic-simulation/dynamic-simulation-parameters-form.js

@@ -0,0 +1,153 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { Grid, Tabs, Tab, LinearProgress } from "@mui/material";
+import { FormattedMessage } from "react-intl";
+import { TabPanel } from "../common/parameters.js";
+import "react";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/types/equipmentType.js";
+import "@mui/icons-material";
+import { mergeSx } from "../../../utils/styles.js";
+import "../../../utils/yupConfig.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "react-hook-form";
+import "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "../../dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
+import "../../dialogs/elementSaveDialog/ElementSaveDialog.js";
+import "../../treeViewFinder/TreeViewFinder.js";
+import { ProviderParam } from "../common/ProviderParam.js";
+import "../../overflowableText/OverflowableText.js";
+import "yup";
+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 "@material-symbols/svg-400/outlined/left_panel_open.svg?react";
+import "@material-symbols/svg-400/outlined/arrows_output.svg?react";
+import "@material-symbols/svg-400/outlined/left_panel_close.svg?react";
+import "@material-symbols/svg-400/outlined/add_notes.svg?react";
+import "../../inputs/reactHookForm/expandableInput/ExpandableInput.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 { getTabStyle, parametersStyles } from "../parameters-style.js";
+import "../common/widget/parameter-line-slider.js";
+import "../common/limitreductions/columns-definitions.js";
+import "../common/contingency-table/columns-definitions.js";
+import { useTabs } from "../common/hook/use-tabs.js";
+import "@hookform/resolvers/yup";
+import "../../filter/HeaderFilterForm.js";
+import { TabValues } from "./dynamic-simulation.type.js";
+import "./time-delay/time-delay-parameters-utils.js";
+import { TimeDelayParameters } from "./time-delay/time-delay-parameters.js";
+import "./solver/solver-parameters-utils.js";
+import { SolverParameters } from "./solver/solver-parameters.js";
+import { MAPPING } from "./mapping/mapping-parameters-constants.js";
+import "./mapping/mapping-parameters-utils.js";
+import { MappingParameters } from "./mapping/mapping-parameters.js";
+import "./network/network-parameters-utils.js";
+import { NetworkParameters } from "./network/network-parameters.js";
+import CurveParameters from "./curve/curve-parameters.js";
+function DynamicSimulationForm({
+  dynamicSimulationMethods,
+  renderTitleFields,
+  renderActions,
+  // fetchers for curve parameters
+  voltageLevelsFetcher,
+  countriesFetcher,
+  evaluateFilterFetcher
+}) {
+  const { paramsLoaded, formattedProviders } = dynamicSimulationMethods;
+  const { selectedTab, tabsWithError, onTabChange, onError } = useTabs({
+    defaultTab: TabValues.TAB_TIME_DELAY,
+    tabEnum: TabValues
+  });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    renderTitleFields?.(),
+    paramsLoaded ? /* @__PURE__ */ jsxs(Grid, { container: true, sx: { height: "100%" }, direction: "column", children: [
+      /* @__PURE__ */ jsx(Grid, { container: true, children: /* @__PURE__ */ jsx(ProviderParam, { options: formattedProviders }) }),
+      /* @__PURE__ */ jsx(Grid, { children: /* @__PURE__ */ jsxs(Tabs, { value: selectedTab, variant: "scrollable", onChange: onTabChange, "aria-label": "parameters", children: [
+        /* @__PURE__ */ jsx(
+          Tab,
+          {
+            label: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationTimeDelay" }),
+            value: TabValues.TAB_TIME_DELAY,
+            sx: getTabStyle(tabsWithError, TabValues.TAB_TIME_DELAY)
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Tab,
+          {
+            label: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationSolver" }),
+            value: TabValues.TAB_SOLVER,
+            sx: getTabStyle(tabsWithError, TabValues.TAB_SOLVER)
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Tab,
+          {
+            label: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationMapping" }),
+            value: TabValues.TAB_MAPPING,
+            sx: getTabStyle(tabsWithError, TabValues.TAB_MAPPING)
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Tab,
+          {
+            label: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationNetwork" }),
+            value: TabValues.TAB_NETWORK,
+            sx: getTabStyle(tabsWithError, TabValues.TAB_NETWORK)
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Tab,
+          {
+            label: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurve" }),
+            value: TabValues.TAB_CURVE,
+            sx: getTabStyle(tabsWithError, TabValues.TAB_CURVE)
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ jsxs(
+        Grid,
+        {
+          container: true,
+          item: true,
+          xs: true,
+          sx: mergeSx(parametersStyles.scrollableGrid, {
+            paddingTop: 0,
+            width: "100%"
+          }),
+          children: [
+            /* @__PURE__ */ jsx(TabPanel, { value: selectedTab, index: TabValues.TAB_TIME_DELAY, children: /* @__PURE__ */ jsx(TimeDelayParameters, { path: TabValues.TAB_TIME_DELAY }) }),
+            /* @__PURE__ */ jsx(TabPanel, { value: selectedTab, index: TabValues.TAB_SOLVER, children: /* @__PURE__ */ jsx(SolverParameters, { path: TabValues.TAB_SOLVER }) }),
+            /* @__PURE__ */ jsx(TabPanel, { value: selectedTab, index: TabValues.TAB_MAPPING, children: /* @__PURE__ */ jsx(MappingParameters, { path: TabValues.TAB_MAPPING }) }),
+            /* @__PURE__ */ jsx(TabPanel, { value: selectedTab, index: TabValues.TAB_NETWORK, children: /* @__PURE__ */ jsx(NetworkParameters, { path: TabValues.TAB_NETWORK }) }),
+            /* @__PURE__ */ jsx(TabPanel, { value: selectedTab, index: TabValues.TAB_CURVE, children: /* @__PURE__ */ jsx(
+              CurveParameters,
+              {
+                path: TabValues.TAB_CURVE,
+                mappingPath: `${TabValues.TAB_MAPPING}.${MAPPING}`,
+                voltageLevelsFetcher,
+                countriesFetcher,
+                evaluateFilterFetcher
+              }
+            ) })
+          ]
+        },
+        "dsParameters"
+      ),
+      renderActions?.(onError)
+    ] }) : /* @__PURE__ */ jsx(LinearProgress, {})
+  ] });
+}
+export {
+  DynamicSimulationForm
+};

package/dist/components/parameters/dynamic-simulation/dynamic-simulation.type.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2026, 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/.
+ */
+export declare enum TabValues {
+    TAB_TIME_DELAY = "TAB_TIME_DELAY",
+    TAB_SOLVER = "TAB_SOLVER",
+    TAB_MAPPING = "TAB_MAPPING",
+    TAB_NETWORK = "TAB_NETWORK",
+    TAB_CURVE = "TAB_CURVE"
+}

package/dist/components/parameters/dynamic-simulation/dynamic-simulation.type.js

@@ -0,0 +1,11 @@
+var TabValues = /* @__PURE__ */ ((TabValues2) => {
+  TabValues2["TAB_TIME_DELAY"] = "TAB_TIME_DELAY";
+  TabValues2["TAB_SOLVER"] = "TAB_SOLVER";
+  TabValues2["TAB_MAPPING"] = "TAB_MAPPING";
+  TabValues2["TAB_NETWORK"] = "TAB_NETWORK";
+  TabValues2["TAB_CURVE"] = "TAB_CURVE";
+  return TabValues2;
+})(TabValues || {});
+export {
+  TabValues
+};

package/dist/components/parameters/dynamic-simulation/hook/use-default-params.d.ts

@@ -0,0 +1,4 @@
+export default function useDefaultParams<T>(params: T | null): {
+    getDefaultParams: () => T | null;
+    setDefaultParams: (newParams: T) => void;
+};

package/dist/components/parameters/dynamic-simulation/hook/use-default-params.js

@@ -0,0 +1,22 @@
+import { useRef, useEffect, useCallback } from "react";
+function useDefaultParams(params) {
+  const defaultParamsRef = useRef(params);
+  useEffect(() => {
+    if (params) {
+      defaultParamsRef.current = params;
+    }
+  }, [params]);
+  const getDefaultParams = useCallback(() => {
+    return defaultParamsRef.current;
+  }, []);
+  const setDefaultParams = useCallback((newParams) => {
+    defaultParamsRef.current = newParams;
+  }, []);
+  return {
+    getDefaultParams,
+    setDefaultParams
+  };
+}
+export {
+  useDefaultParams as default
+};

package/dist/components/parameters/dynamic-simulation/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) 2026, 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/.
+ */
+export * from './dynamic-simulation-inline';