@gridsuite/commons-ui 0.97.0 → 0.99.0

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

@@ -0,0 +1,102 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { Box, LinearProgress } from "@mui/material";
+import LoadFlowParametersHeader from "./load-flow-parameters-header.js";
+import LoadFlowParametersContent from "./load-flow-parameters-content.js";
+import "react-intl";
+import "@mui/icons-material";
+import "react";
+import "react-hook-form";
+import { CustomFormProvider } from "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "yup";
+import "notistack";
+import "../../overflowableText/OverflowableText.js";
+import "../../treeViewFinder/TreeViewFinder.js";
+import "../../inputs/reactHookForm/agGridTable/BottomRightButtons.js";
+import "../../customAGGrid/customAggrid.js";
+import "ag-grid-community";
+import "react-papaparse";
+import "react-csv-downloader";
+import "../../inputs/reactHookForm/numbers/RangeInput.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/types/equipmentType.js";
+import "../../../utils/yupConfig.js";
+import "@react-querybuilder/material";
+import "../../filter/expert/expertFilterConstants.js";
+import "../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "uuid";
+import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
+import "react-querybuilder";
+function LoadFlowParametersForm({
+  loadflowMethods,
+  renderTitleFields,
+  renderActions
+}) {
+  const {
+    formMethods,
+    formSchema,
+    selectedTab,
+    handleTabChange,
+    tabIndexesWithError,
+    formattedProviders,
+    specificParameters,
+    params,
+    currentProvider,
+    defaultLimitReductions,
+    paramsLoaded
+  } = loadflowMethods;
+  return /* @__PURE__ */ jsxs(CustomFormProvider, { validationSchema: formSchema, ...formMethods, removeOptional: true, children: [
+    renderTitleFields == null ? void 0 : renderTitleFields(),
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        sx: {
+          height: "100%",
+          display: "flex",
+          position: "relative",
+          flexDirection: "column"
+        },
+        children: [
+          paramsLoaded ? /* @__PURE__ */ jsxs(
+            Box,
+            {
+              sx: {
+                height: "100%",
+                display: "flex",
+                position: "relative",
+                flexDirection: "column"
+              },
+              children: [
+                /* @__PURE__ */ jsx(
+                  LoadFlowParametersHeader,
+                  {
+                    selectedTab,
+                    handleTabChange,
+                    tabIndexesWithError,
+                    formattedProviders
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  LoadFlowParametersContent,
+                  {
+                    selectedTab,
+                    currentProvider: currentProvider ?? "",
+                    specificParameters,
+                    params,
+                    defaultLimitReductions
+                  }
+                )
+              ]
+            }
+          ) : /* @__PURE__ */ jsx(LinearProgress, {}),
+          renderActions == null ? void 0 : renderActions()
+        ]
+      }
+    )
+  ] });
+}
+export {
+  LoadFlowParametersForm
+};

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

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { TabValues } from './load-flow-parameters-utils';
+declare function LoadFlowParametersHeader({ selectedTab, handleTabChange, tabIndexesWithError, formattedProviders, }: Readonly<{
+    selectedTab: string;
+    handleTabChange: (event: React.SyntheticEvent, newValue: TabValues) => void;
+    tabIndexesWithError: TabValues[];
+    formattedProviders: {
+        id: string;
+        label: string;
+    }[];
+}>): import("react/jsx-runtime").JSX.Element;
+export default LoadFlowParametersHeader;

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

@@ -0,0 +1,84 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Box, Grid, Tabs, Tab } from "@mui/material";
+import { FormattedMessage } from "react-intl";
+import { TabValues } from "./load-flow-parameters-utils.js";
+import { parametersStyles, getTabStyle } from "../parameters-style.js";
+import "@mui/icons-material";
+import "react";
+import "react-hook-form";
+import "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "yup";
+import "notistack";
+import "../../overflowableText/OverflowableText.js";
+import "../../treeViewFinder/TreeViewFinder.js";
+import "../../inputs/reactHookForm/agGridTable/BottomRightButtons.js";
+import "../../customAGGrid/customAggrid.js";
+import "ag-grid-community";
+import "react-papaparse";
+import "react-csv-downloader";
+import "../../inputs/reactHookForm/numbers/RangeInput.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import { MuiSelectInput } from "../../inputs/reactHookForm/selectInputs/MuiSelectInput.js";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/types/equipmentType.js";
+import "../../../utils/yupConfig.js";
+import "@react-querybuilder/material";
+import "../../filter/expert/expertFilterConstants.js";
+import "../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "uuid";
+import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
+import "react-querybuilder";
+import { PROVIDER } from "../common/constant.js";
+import { LineSeparator } from "../common/line-separator.js";
+import "../../dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
+import "../../dialogs/elementSaveDialog/ElementSaveDialog.js";
+import "../common/widget/parameter-line-slider.js";
+import "../common/limitreductions/columns-definitions.js";
+function LoadFlowParametersHeader({
+  selectedTab,
+  handleTabChange,
+  tabIndexesWithError,
+  formattedProviders
+}) {
+  return /* @__PURE__ */ jsx(Box, { sx: { flexGrow: 0, paddingLeft: 1, paddingTop: 1 }, children: /* @__PURE__ */ jsxs(
+    Grid,
+    {
+      container: true,
+      spacing: 1,
+      sx: {
+        padding: 0,
+        paddingBottom: 0,
+        height: "fit-content"
+      },
+      justifyContent: "space-between",
+      children: [
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: 5, sx: parametersStyles.parameterName, children: /* @__PURE__ */ jsx(FormattedMessage, { id: "Provider" }) }),
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: "auto", sx: parametersStyles.controlItem, children: /* @__PURE__ */ jsx(MuiSelectInput, { name: PROVIDER, size: "small", options: Object.values(formattedProviders) }) }),
+        /* @__PURE__ */ jsx(LineSeparator, {}),
+        /* @__PURE__ */ jsx(Grid, { item: true, sx: { width: "100%" }, children: /* @__PURE__ */ jsxs(Tabs, { value: selectedTab, onChange: handleTabChange, children: [
+          /* @__PURE__ */ jsx(
+            Tab,
+            {
+              label: /* @__PURE__ */ jsx(FormattedMessage, { id: TabValues.GENERAL }),
+              value: TabValues.GENERAL,
+              sx: getTabStyle(tabIndexesWithError, TabValues.GENERAL)
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Tab,
+            {
+              label: /* @__PURE__ */ jsx(FormattedMessage, { id: TabValues.LIMIT_REDUCTIONS }),
+              value: TabValues.LIMIT_REDUCTIONS,
+              sx: getTabStyle(tabIndexesWithError, TabValues.LIMIT_REDUCTIONS)
+            }
+          )
+        ] }) })
+      ]
+    }
+  ) });
+}
+export {
+  LoadFlowParametersHeader as default
+};

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

@@ -0,0 +1,10 @@
+import { Dispatch, SetStateAction } from 'react';
+import { UUID } from 'crypto';
+import { UseParametersBackendReturnProps } from '../../../utils/types/parameters.type';
+import { ComputingType } from '../common/computing-type';
+export declare function LoadFlowParametersInline({ studyUuid, parametersBackend, setHaveDirtyFields, enableDeveloperMode, }: Readonly<{
+    studyUuid: UUID | null;
+    parametersBackend: UseParametersBackendReturnProps<ComputingType.LOAD_FLOW>;
+    setHaveDirtyFields: Dispatch<SetStateAction<boolean>>;
+    enableDeveloperMode: boolean;
+}>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,162 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useEffect } from "react";
+import { Box, Grid } from "@mui/material";
+import { useIntl, FormattedMessage } from "react-intl";
+import { LoadFlowProvider } from "./load-flow-parameters-provider.js";
+import { parametersStyles } from "../parameters-style.js";
+import "../../../utils/types/equipmentType.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import { useSnackMessage } from "../../../hooks/useSnackMessage.js";
+import "@mui/icons-material";
+import "react-hook-form";
+import "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "yup";
+import { mergeSx } from "../../../utils/styles.js";
+import "../../overflowableText/OverflowableText.js";
+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 "../../../utils/conversionUtils.js";
+import { ElementType } from "../../../utils/types/elementType.js";
+import "../../../utils/yupConfig.js";
+import { SubmitButton } from "../../inputs/reactHookForm/utils/SubmitButton.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 { LabelledButton } from "../common/parameters.js";
+import { LineSeparator } from "../common/line-separator.js";
+import { CreateParameterDialog } from "../common/parameters-creation-dialog.js";
+import "../common/widget/parameter-line-slider.js";
+import "../common/limitreductions/columns-definitions.js";
+import { fetchLoadFlowParameters } from "../../../services/loadflow.js";
+import { useLoadFlowParametersForm } from "./use-load-flow-parameters-form.js";
+import { LoadFlowParametersForm } from "./load-flow-parameters-form.js";
+function LoadFlowParametersInline({
+  studyUuid,
+  parametersBackend,
+  setHaveDirtyFields,
+  enableDeveloperMode
+}) {
+  const [, , , , resetProvider, , , , resetParameters, , ,] = parametersBackend;
+  const loadflowMethods = useLoadFlowParametersForm(parametersBackend, enableDeveloperMode, null, null, null);
+  const intl = useIntl();
+  const [openCreateParameterDialog, setOpenCreateParameterDialog] = useState(false);
+  const [openSelectParameterDialog, setOpenSelectParameterDialog] = useState(false);
+  const { snackError } = useSnackMessage();
+  const resetLFParametersAndProvider = useCallback(() => {
+    resetParameters();
+    resetProvider();
+  }, [resetParameters, resetProvider]);
+  const resetLFParameters = useCallback(() => {
+    resetParameters();
+  }, [resetParameters]);
+  const { reset, getValues, formState, handleSubmit } = loadflowMethods.formMethods;
+  const handleLoadParameter = useCallback(
+    (newParams) => {
+      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
+          });
+        }).catch((error) => {
+          console.error(error);
+          snackError({
+            messageTxt: error.message,
+            headerId: "paramsRetrievingError"
+          });
+        });
+      }
+      setOpenSelectParameterDialog(false);
+    },
+    [loadflowMethods, reset, snackError]
+  );
+  useEffect(() => {
+    setHaveDirtyFields(!!Object.keys(formState.dirtyFields).length);
+  }, [formState, setHaveDirtyFields]);
+  return /* @__PURE__ */ jsx(LoadFlowProvider, { children: /* @__PURE__ */ jsx(
+    LoadFlowParametersForm,
+    {
+      loadflowMethods,
+      renderActions: () => {
+        return /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(LineSeparator, {}),
+          /* @__PURE__ */ jsxs(
+            Grid,
+            {
+              container: true,
+              item: true,
+              sx: mergeSx(parametersStyles.controlParametersItem, parametersStyles.marginTopButton, {
+                paddingBottom: 0
+              }),
+              children: [
+                /* @__PURE__ */ jsx(
+                  LabelledButton,
+                  {
+                    callback: () => setOpenSelectParameterDialog(true),
+                    label: "settings.button.chooseSettings"
+                  }
+                ),
+                /* @__PURE__ */ jsx(LabelledButton, { callback: () => setOpenCreateParameterDialog(true), label: "save" }),
+                /* @__PURE__ */ jsx(LabelledButton, { callback: resetLFParametersAndProvider, label: "resetToDefault" }),
+                /* @__PURE__ */ jsx(LabelledButton, { label: "resetProviderValuesToDefault", callback: resetLFParameters }),
+                /* @__PURE__ */ jsx(
+                  SubmitButton,
+                  {
+                    onClick: handleSubmit(
+                      loadflowMethods.onSaveInline,
+                      loadflowMethods.onValidationError
+                    ),
+                    variant: "outlined",
+                    children: /* @__PURE__ */ jsx(FormattedMessage, { id: "validate" })
+                  }
+                )
+              ]
+            }
+          ),
+          openCreateParameterDialog && /* @__PURE__ */ jsx(
+            CreateParameterDialog,
+            {
+              studyUuid,
+              open: openCreateParameterDialog,
+              onClose: () => setOpenCreateParameterDialog(false),
+              parameterValues: () => loadflowMethods.formatNewParams(getValues()),
+              parameterFormatter: (newParams) => newParams,
+              parameterType: ElementType.LOADFLOW_PARAMETERS
+            }
+          ),
+          openSelectParameterDialog && /* @__PURE__ */ jsx(
+            DirectoryItemSelector,
+            {
+              open: openSelectParameterDialog,
+              onClose: handleLoadParameter,
+              types: [ElementType.LOADFLOW_PARAMETERS],
+              title: intl.formatMessage({
+                id: "showSelectParameterDialog"
+              }),
+              onlyLeaves: true,
+              multiSelect: false,
+              validationButtonText: intl.formatMessage({
+                id: "validate"
+              })
+            }
+          )
+        ] });
+      }
+    }
+  ) });
+}
+export {
+  LoadFlowParametersInline
+};

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

@@ -0,0 +1,4 @@
+import { ReactNode } from 'react';
+export declare function LoadFlowProvider({ children }: Readonly<{
+    children: ReactNode;
+}>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,20 @@
+import { jsx } from "react/jsx-runtime";
+import { useState, useMemo } from "react";
+import { LoadFlowContext } from "./load-flow-parameters-context.js";
+function LoadFlowProvider({ children }) {
+  const [showAdvancedLfParams, setShowAdvancedLfParams] = useState(false);
+  const [showSpecificLfParams, setShowSpecificLfParams] = useState(false);
+  const contextValue = useMemo(
+    () => ({
+      showAdvancedLfParams,
+      setShowAdvancedLfParams,
+      showSpecificLfParams,
+      setShowSpecificLfParams
+    }),
+    [showAdvancedLfParams, showSpecificLfParams]
+  );
+  return /* @__PURE__ */ jsx(LoadFlowContext.Provider, { value: contextValue, children });
+}
+export {
+  LoadFlowProvider
+};

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

@@ -0,0 +1,100 @@
+import { UseFormReturn } from 'react-hook-form';
+import { ILimitReductionsByVoltageLevel } from '../common/limitreductions/columns-definitions';
+import { default as yup } from '../../../utils/yupConfig';
+import { SpecificParameterInfos } from '../../../utils/types/parameters.type';
+import { SpecificParametersPerProvider } from '../../../utils/types/loadflow.type';
+export declare enum TabValues {
+    GENERAL = "General",
+    LIMIT_REDUCTIONS = "LimitReductions"
+}
+export declare const getBasicLoadFlowParametersFormSchema: () => yup.ObjectSchema<{
+    transformerVoltageControlOn: NonNullable<boolean | undefined>;
+    phaseShifterRegulationOn: NonNullable<boolean | undefined>;
+    dc: NonNullable<boolean | undefined>;
+    balanceType: string;
+    countriesToBalance: (string | undefined)[];
+    connectedComponentMode: string;
+    hvdcAcEmulation: NonNullable<boolean | undefined>;
+}, yup.AnyObject, {
+    transformerVoltageControlOn: undefined;
+    phaseShifterRegulationOn: undefined;
+    dc: undefined;
+    balanceType: undefined;
+    countriesToBalance: "";
+    connectedComponentMode: undefined;
+    hvdcAcEmulation: undefined;
+}, "">;
+export declare const getAdvancedLoadFlowParametersFormSchema: () => yup.ObjectSchema<{
+    voltageInitMode: string;
+    useReactiveLimits: NonNullable<boolean | undefined>;
+    twtSplitShuntAdmittance: NonNullable<boolean | undefined>;
+    readSlackBus: NonNullable<boolean | undefined>;
+    writeSlackBus: NonNullable<boolean | undefined>;
+    distributedSlack: NonNullable<boolean | undefined>;
+    shuntCompensatorVoltageControlOn: NonNullable<boolean | undefined>;
+    dcUseTransformerRatio: NonNullable<boolean | undefined>;
+    dcPowerFactor: number;
+}, yup.AnyObject, {
+    voltageInitMode: undefined;
+    useReactiveLimits: undefined;
+    twtSplitShuntAdmittance: undefined;
+    readSlackBus: undefined;
+    writeSlackBus: undefined;
+    distributedSlack: undefined;
+    shuntCompensatorVoltageControlOn: undefined;
+    dcUseTransformerRatio: undefined;
+    dcPowerFactor: undefined;
+}, "">;
+export declare const getDialogLoadFlowParametersFormSchema: (name: string | null) => {
+    [key: string]: yup.AnySchema;
+};
+export declare const getCommonLoadFlowParametersFormSchema: () => yup.ObjectSchema<{
+    commonParameters: {
+        transformerVoltageControlOn?: unknown;
+        phaseShifterRegulationOn?: unknown;
+        dc?: unknown;
+        balanceType?: unknown;
+        countriesToBalance?: unknown;
+        connectedComponentMode?: unknown;
+        hvdcAcEmulation?: unknown;
+        voltageInitMode?: unknown;
+        useReactiveLimits?: unknown;
+        twtSplitShuntAdmittance?: unknown;
+        readSlackBus?: unknown;
+        writeSlackBus?: unknown;
+        distributedSlack?: unknown;
+        shuntCompensatorVoltageControlOn?: unknown;
+        dcUseTransformerRatio?: unknown;
+        dcPowerFactor?: unknown;
+    };
+}, yup.AnyObject, {
+    commonParameters: {
+        voltageInitMode: undefined;
+        useReactiveLimits: undefined;
+        twtSplitShuntAdmittance: undefined;
+        readSlackBus: undefined;
+        writeSlackBus: undefined;
+        distributedSlack: undefined;
+        shuntCompensatorVoltageControlOn: undefined;
+        dcUseTransformerRatio: undefined;
+        dcPowerFactor: undefined;
+        transformerVoltageControlOn: undefined;
+        phaseShifterRegulationOn: undefined;
+        dc: undefined;
+        balanceType: undefined;
+        countriesToBalance: undefined;
+        connectedComponentMode: undefined;
+        hvdcAcEmulation: undefined;
+    };
+}, "">;
+export declare const getSpecificLoadFlowParametersFormSchema: (specificParameters: SpecificParameterInfos[]) => yup.ObjectSchema<{
+    specificParametersPerProvider: {};
+}, yup.AnyObject, {
+    specificParametersPerProvider: {
+        [x: string]: any;
+    };
+}, "">;
+export declare const getDefaultSpecificParamsValues: (specificParams: SpecificParameterInfos[]) => SpecificParametersPerProvider;
+export declare const setSpecificParameters: (provider: string, specificParamsDescriptions: Record<string, SpecificParameterInfos[]> | null, formMethods: UseFormReturn) => void;
+export declare const setLimitReductions: (provider: string, defaultLimitReductions: ILimitReductionsByVoltageLevel[], formMethods: UseFormReturn) => void;
+export declare const mapLimitReductions: (vlLimits: ILimitReductionsByVoltageLevel, formLimits: Record<string, unknown>[], indexVl: number) => ILimitReductionsByVoltageLevel;

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

@@ -0,0 +1,158 @@
+import { LIMIT_REDUCTIONS_FORM, IST_FORM, LIMIT_DURATION_FORM } from "../common/limitreductions/columns-definitions.js";
+import { HVDC_AC_EMULATION, CONNECTED_COMPONENT_MODE, COUNTRIES_TO_BALANCE, BALANCE_TYPE, DC, PHASE_SHIFTER_REGULATION_ON, TRANSFORMER_VOLTAGE_CONTROL_ON, DC_POWER_FACTOR, DC_USE_TRANSFORMER_RATIO, SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON, DISTRIBUTED_SLACK, WRITE_SLACK_BUS, READ_SLACK_BUS, TWT_SPLIT_SHUNT_ADMITTANCE, USE_REACTIVE_LIMITS, VOLTAGE_INIT_MODE, COMMON_PARAMETERS, SPECIFIC_PARAMETERS, PARAM_PROVIDER_OPENLOADFLOW, PARAM_LIMIT_REDUCTION, DEFAULT_LIMIT_REDUCTION_VALUE } from "./constants.js";
+import { toFormValuesLimitReductions } from "../common/limitreductions/limit-reductions-form-util.js";
+import "../../../utils/yupConfig.js";
+import { ParameterType } from "../../../utils/types/parameters.type.js";
+import "react/jsx-runtime";
+import "react-intl";
+import "@mui/material";
+import { NAME, DESCRIPTION_INPUT } from "../../inputs/reactHookForm/DirectoryItemsInput.js";
+import "react-hook-form";
+import "../../inputs/reactHookForm/agGridTable/BottomRightButtons.js";
+import "react";
+import "../../customAGGrid/customAggrid.js";
+import "ag-grid-community";
+import "react-papaparse";
+import "react-csv-downloader";
+import * as yup from "yup";
+import "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "@mui/icons-material";
+import "../../inputs/reactHookForm/numbers/RangeInput.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/types/equipmentType.js";
+import "notistack";
+import "@react-querybuilder/material";
+import "../../filter/expert/expertFilterConstants.js";
+import "../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "uuid";
+import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
+import "react-querybuilder";
+var TabValues = /* @__PURE__ */ ((TabValues2) => {
+  TabValues2["GENERAL"] = "General";
+  TabValues2["LIMIT_REDUCTIONS"] = "LimitReductions";
+  return TabValues2;
+})(TabValues || {});
+const getBasicLoadFlowParametersFormSchema = () => {
+  return yup.object().shape({
+    [TRANSFORMER_VOLTAGE_CONTROL_ON]: yup.boolean().required(),
+    [PHASE_SHIFTER_REGULATION_ON]: yup.boolean().required(),
+    [DC]: yup.boolean().required(),
+    [BALANCE_TYPE]: yup.string().required(),
+    [COUNTRIES_TO_BALANCE]: yup.array().of(yup.string()).required(),
+    [CONNECTED_COMPONENT_MODE]: yup.string().required(),
+    [HVDC_AC_EMULATION]: yup.boolean().required()
+  });
+};
+const getAdvancedLoadFlowParametersFormSchema = () => {
+  return yup.object().shape({
+    [VOLTAGE_INIT_MODE]: yup.string().required(),
+    [USE_REACTIVE_LIMITS]: yup.boolean().required(),
+    [TWT_SPLIT_SHUNT_ADMITTANCE]: yup.boolean().required(),
+    [READ_SLACK_BUS]: yup.boolean().required(),
+    [WRITE_SLACK_BUS]: yup.boolean().required(),
+    [DISTRIBUTED_SLACK]: yup.boolean().required(),
+    [SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON]: yup.boolean().required(),
+    [DC_USE_TRANSFORMER_RATIO]: yup.boolean().required(),
+    [DC_POWER_FACTOR]: yup.number().required().positive("dcPowerFactorGreaterThan0").max(1, "dcPowerFactorLessOrEqualThan1")
+  });
+};
+const getDialogLoadFlowParametersFormSchema = (name) => {
+  const shape = {};
+  if (name) {
+    shape[NAME] = yup.string().required();
+    shape[DESCRIPTION_INPUT] = yup.string();
+  }
+  return shape;
+};
+const getCommonLoadFlowParametersFormSchema = () => {
+  return yup.object().shape({
+    [COMMON_PARAMETERS]: yup.object().shape({
+      ...getBasicLoadFlowParametersFormSchema().fields,
+      ...getAdvancedLoadFlowParametersFormSchema().fields
+    })
+  });
+};
+const getSpecificLoadFlowParametersFormSchema = (specificParameters) => {
+  const shape = {};
+  specificParameters == null ? void 0 : specificParameters.forEach((param) => {
+    switch (param.type) {
+      case ParameterType.STRING:
+        shape[param.name] = yup.string().required();
+        break;
+      case ParameterType.DOUBLE:
+        shape[param.name] = yup.number().required();
+        break;
+      case ParameterType.INTEGER:
+        shape[param.name] = yup.number().required();
+        break;
+      case ParameterType.BOOLEAN:
+        shape[param.name] = yup.boolean().required();
+        break;
+      case ParameterType.STRING_LIST:
+        shape[param.name] = yup.array().of(yup.string()).required();
+        break;
+      default:
+        shape[param.name] = yup.mixed().required();
+    }
+  });
+  return yup.object().shape({
+    [SPECIFIC_PARAMETERS]: yup.object().shape(shape)
+  });
+};
+const getDefaultSpecificParamsValues = (specificParams) => {
+  return specificParams == null ? void 0 : specificParams.reduce((acc, param) => {
+    if (param.type === ParameterType.STRING_LIST && param.defaultValue === null) {
+      acc[param.name] = [];
+    } else if ((param.type === ParameterType.DOUBLE || param.type === ParameterType.INTEGER) && Number.isNaN(Number(param.defaultValue))) {
+      acc[param.name] = 0;
+    } else {
+      acc[param.name] = param.defaultValue;
+    }
+    return acc;
+  }, {});
+};
+const setSpecificParameters = (provider, specificParamsDescriptions, formMethods) => {
+  const specificParams = provider ? (specificParamsDescriptions == null ? void 0 : specificParamsDescriptions[provider]) ?? [] : [];
+  const specificParamsValues = getDefaultSpecificParamsValues(specificParams);
+  formMethods.setValue(SPECIFIC_PARAMETERS, specificParamsValues);
+};
+const setLimitReductions = (provider, defaultLimitReductions, formMethods) => {
+  if (provider === PARAM_PROVIDER_OPENLOADFLOW) {
+    formMethods.setValue(
+      LIMIT_REDUCTIONS_FORM,
+      toFormValuesLimitReductions(defaultLimitReductions)[LIMIT_REDUCTIONS_FORM]
+    );
+    formMethods.setValue(PARAM_LIMIT_REDUCTION, null);
+  } else {
+    formMethods.setValue(PARAM_LIMIT_REDUCTION, DEFAULT_LIMIT_REDUCTION_VALUE);
+    formMethods.setValue(LIMIT_REDUCTIONS_FORM, []);
+  }
+};
+const mapLimitReductions = (vlLimits, formLimits, indexVl) => {
+  const vlLNewLimits = {
+    ...vlLimits,
+    permanentLimitReduction: formLimits[indexVl][IST_FORM]
+  };
+  vlLimits.temporaryLimitReductions.forEach((temporaryLimit, index) => {
+    vlLNewLimits.temporaryLimitReductions[index] = {
+      ...temporaryLimit,
+      reduction: formLimits[indexVl][LIMIT_DURATION_FORM + index]
+    };
+  });
+  return vlLNewLimits;
+};
+export {
+  TabValues,
+  getAdvancedLoadFlowParametersFormSchema,
+  getBasicLoadFlowParametersFormSchema,
+  getCommonLoadFlowParametersFormSchema,
+  getDefaultSpecificParamsValues,
+  getDialogLoadFlowParametersFormSchema,
+  getSpecificLoadFlowParametersFormSchema,
+  mapLimitReductions,
+  setLimitReductions,
+  setSpecificParameters
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) 2025, 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 const useLoadFlowContext: () => import('./load-flow-parameters-context').LoadFlowContextProps;