@gridsuite/commons-ui 0.106.1 → 0.107.1

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

@@ -0,0 +1,147 @@
+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 "../../../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 "../../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 { CreateParameterDialog } from "../common/parameters-creation-dialog.js";
+import "../common/widget/parameter-line-slider.js";
+import "../common/limitreductions/columns-definitions.js";
+import { SHORT_CIRCUIT_WITH_FEEDER_RESULT, SHORT_CIRCUIT_PREDEFINED_PARAMS, SHORT_CIRCUIT_WITH_LOADS, SHORT_CIRCUIT_WITH_VSC_CONVERTER_STATIONS, SHORT_CIRCUIT_WITH_SHUNT_COMPENSATORS, SHORT_CIRCUIT_WITH_NEUTRAL_POSITION, SHORT_CIRCUIT_INITIAL_VOLTAGE_PROFILE_MODE, InitialVoltage } from "./constants.js";
+import { fetchShortCircuitParameters } from "../../../services/short-circuit-analysis.js";
+import { ShortCircuitParametersForm } from "./short-circuit-parameters-form.js";
+import { useShortCircuitParametersForm } from "./use-short-circuit-parameters-form.js";
+function ShortCircuitParametersInLine({
+  studyUuid,
+  setHaveDirtyFields,
+  shortCircuitParameters
+}) {
+  const shortCircuitMethods = useShortCircuitParametersForm({
+    parametersUuid: null,
+    name: null,
+    description: null,
+    studyUuid,
+    studyShortCircuitParameters: shortCircuitParameters
+  });
+  const intl = useIntl();
+  const [openCreateParameterDialog, setOpenCreateParameterDialog] = useState(false);
+  const [openSelectParameterDialog, setOpenSelectParameterDialog] = useState(false);
+  const { snackError } = useSnackMessage();
+  const { getCurrentValues, formMethods } = shortCircuitMethods;
+  const { setValue, formState, handleSubmit } = formMethods;
+  const replaceFormValues = useCallback(
+    (param) => {
+      const dirty = { shouldDirty: true };
+      setValue(SHORT_CIRCUIT_WITH_FEEDER_RESULT, param.parameters.withFeederResult, dirty);
+      setValue(SHORT_CIRCUIT_PREDEFINED_PARAMS, param.predefinedParameters, dirty);
+      setValue(SHORT_CIRCUIT_WITH_LOADS, param.parameters.withLoads, dirty);
+      setValue(SHORT_CIRCUIT_WITH_VSC_CONVERTER_STATIONS, param.parameters.withVSCConverterStations, dirty);
+      setValue(SHORT_CIRCUIT_WITH_SHUNT_COMPENSATORS, param.parameters.withShuntCompensators, dirty);
+      setValue(SHORT_CIRCUIT_WITH_NEUTRAL_POSITION, !param.parameters.withNeutralPosition, dirty);
+      setValue(
+        SHORT_CIRCUIT_INITIAL_VOLTAGE_PROFILE_MODE,
+        param.parameters.initialVoltageProfileMode === InitialVoltage.CONFIGURED ? InitialVoltage.CEI909 : param.parameters.initialVoltageProfileMode,
+        dirty
+      );
+    },
+    [setValue]
+  );
+  const handleLoadParameters = useCallback(
+    (newParams) => {
+      if (newParams == null ? void 0 : newParams.length) {
+        setOpenSelectParameterDialog(false);
+        const paramUuid = newParams[0].id;
+        fetchShortCircuitParameters(paramUuid).then((parameters) => {
+          replaceFormValues(parameters);
+        }).catch((error) => {
+          console.error(error);
+          snackError({
+            messageTxt: error.message,
+            headerId: "paramsRetrievingError"
+          });
+        });
+      }
+      setOpenSelectParameterDialog(false);
+    },
+    [snackError, replaceFormValues]
+  );
+  useEffect(() => {
+    setHaveDirtyFields(!!Object.keys(formState.dirtyFields).length);
+  }, [formState, setHaveDirtyFields]);
+  return /* @__PURE__ */ jsx(
+    ShortCircuitParametersForm,
+    {
+      shortCircuitMethods,
+      renderActions: () => {
+        return /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsxs(Grid, { container: true, item: true, children: [
+            /* @__PURE__ */ jsx(
+              LabelledButton,
+              {
+                callback: () => setOpenSelectParameterDialog(true),
+                label: "settings.button.chooseSettings"
+              }
+            ),
+            /* @__PURE__ */ jsx(LabelledButton, { callback: () => setOpenCreateParameterDialog(true), label: "save" }),
+            /* @__PURE__ */ jsx(SubmitButton, { onClick: handleSubmit(shortCircuitMethods.onSaveInline), variant: "outlined", children: /* @__PURE__ */ jsx(FormattedMessage, { id: "validate" }) })
+          ] }),
+          openCreateParameterDialog && /* @__PURE__ */ jsx(
+            CreateParameterDialog,
+            {
+              studyUuid,
+              open: openCreateParameterDialog,
+              onClose: () => setOpenCreateParameterDialog(false),
+              parameterValues: () => getCurrentValues(),
+              parameterFormatter: (newParams) => newParams,
+              parameterType: ElementType.SHORT_CIRCUIT_PARAMETERS
+            }
+          ),
+          openSelectParameterDialog && /* @__PURE__ */ jsx(
+            DirectoryItemSelector,
+            {
+              open: openSelectParameterDialog,
+              onClose: handleLoadParameters,
+              types: [ElementType.SHORT_CIRCUIT_PARAMETERS],
+              title: intl.formatMessage({
+                id: "showSelectParameterDialog"
+              }),
+              multiSelect: false,
+              validationButtonText: intl.formatMessage({
+                id: "validate"
+              })
+            }
+          )
+        ] });
+      }
+    }
+  );
+}
+export {
+  ShortCircuitParametersInLine
+};

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

@@ -0,0 +1,38 @@
+import { InitialVoltage, PredefinedParameters } from './constants';
+export interface VoltageRange {
+    minimumNominalVoltage: number;
+    maximumNominalVoltage: number;
+}
+export interface ShortCircuitParametersDto {
+    withFeederResult: boolean;
+    withLoads: boolean;
+    withVSCConverterStations: boolean;
+    withShuntCompensators: boolean;
+    withNeutralPosition: boolean;
+    initialVoltageProfileMode: InitialVoltage;
+    voltageRanges?: VoltageRange[];
+}
+export interface ShortCircuitParametersInfos {
+    parameters: ShortCircuitParametersDto;
+    predefinedParameters: PredefinedParameters;
+    cei909VoltageRanges?: any;
+}
+interface VoltageRanges {
+    maximumNominalVoltage: number;
+    minimumNominalVoltage: number;
+    voltage: number;
+    voltageRangeCoefficient: number;
+}
+export interface ShortCircuitParameters {
+    predefinedParameters: NonNullable<PredefinedParameters | undefined>;
+    parameters: {
+        withFeederResult: boolean;
+        withLoads: boolean;
+        withVSCConverterStations: boolean;
+        withShuntCompensators: boolean;
+        withNeutralPosition: boolean;
+        initialVoltageProfileMode: NonNullable<InitialVoltage | undefined>;
+        voltageRanges?: VoltageRanges;
+    };
+}
+export {};

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

@@ -0,0 +1 @@
+

package/dist/components/parameters/short-circuit/short-circuit-voltage-table.d.ts

@@ -0,0 +1,5 @@
+import { InitialVoltage } from './constants';
+export interface VoltageTableProps {
+    voltageProfileMode: InitialVoltage;
+}
+export declare function VoltageTable({ voltageProfileMode }: Readonly<VoltageTableProps>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/short-circuit/short-circuit-voltage-table.js

@@ -0,0 +1,38 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { Table, TableBody, TableRow, TableCell } from "@mui/material";
+import { useIntl } from "react-intl";
+import { InitialVoltage } from "./constants.js";
+function VoltageTable({ voltageProfileMode }) {
+  const intl = useIntl();
+  const rows = useMemo(
+    () => [
+      {
+        name: intl.formatMessage({ id: "shortCircuitNominalVoltage" }),
+        values: [`380 ${intl.formatMessage({ id: "Or" })} 400`, 225, 150, 90, 63, 45, 20]
+      },
+      {
+        name: intl.formatMessage({ id: "shortCircuitInitialVoltage" }),
+        values: voltageProfileMode === InitialVoltage.NOMINAL ? [400, 225, 150, 90, 63, 45, 20] : [420, 245, 165, 99, 69.3, 49.5, 22]
+      }
+    ],
+    [voltageProfileMode, intl]
+  );
+  return /* @__PURE__ */ jsx(Table, { children: /* @__PURE__ */ jsx(TableBody, { children: rows.map((row) => /* @__PURE__ */ jsxs(TableRow, { children: [
+    /* @__PURE__ */ jsx(TableCell, { children: row.name }),
+    row.values.map((value) => /* @__PURE__ */ jsx(
+      TableCell,
+      {
+        sx: {
+          width: "10%",
+          textAlign: "center"
+        },
+        children: value
+      },
+      value
+    ))
+  ] }, row.name)) }) });
+}
+export {
+  VoltageTable
+};

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

@@ -0,0 +1,29 @@
+import { FieldValues, UseFormReturn } from 'react-hook-form';
+import { ObjectSchema } from 'yup';
+import { UUID } from 'crypto';
+import { PredefinedParameters } from './constants';
+import { ShortCircuitParametersInfos } from './short-circuit-parameters.type';
+export interface UseShortCircuitParametersFormReturn {
+    formMethods: UseFormReturn;
+    formSchema: ObjectSchema<any>;
+    paramsLoading: boolean;
+    onSaveInline: (formData: Record<string, any>) => void;
+    onSaveDialog: (formData: Record<string, any>) => void;
+    resetAll: (predefinedParameter: PredefinedParameters) => void;
+    getCurrentValues: () => FieldValues;
+}
+type UseShortCircuitParametersFormProps = {
+    parametersUuid: UUID;
+    name: string;
+    description: string | null;
+    studyUuid: null;
+    studyShortCircuitParameters: null;
+} | {
+    parametersUuid: null;
+    name: null;
+    description: null;
+    studyUuid: UUID | null;
+    studyShortCircuitParameters: ShortCircuitParametersInfos | null;
+};
+export declare const useShortCircuitParametersForm: ({ parametersUuid, name, description, studyUuid, studyShortCircuitParameters, }: UseShortCircuitParametersFormProps) => UseShortCircuitParametersFormReturn;
+export {};

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

@@ -0,0 +1,222 @@
+import { useForm } from "react-hook-form";
+import { yupResolver } from "@hookform/resolvers/yup";
+import { useState, useMemo, useCallback, useEffect } from "react";
+import "../../../utils/yupConfig.js";
+import "react/jsx-runtime";
+import "react-intl";
+import "@mui/material";
+import { DESCRIPTION_INPUT, NAME } from "../../inputs/reactHookForm/DirectoryItemsInput.js";
+import "../../inputs/reactHookForm/agGridTable/BottomRightButtons.js";
+import "../../customAGGrid/customAggrid.js";
+import "ag-grid-community";
+import "react-papaparse";
+import "react-csv-downloader";
+import * 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 { ElementType } from "../../../utils/types/elementType.js";
+import "../../../utils/types/equipmentType.js";
+import { updateParameter } from "../../../services/explore.js";
+import { setStudyShortCircuitParameters, invalidateStudyShortCircuitStatus } from "../../../services/study.js";
+import { useSnackMessage } from "../../../hooks/useSnackMessage.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 { SHORT_CIRCUIT_INITIAL_VOLTAGE_PROFILE_MODE, InitialVoltage, SHORT_CIRCUIT_WITH_NEUTRAL_POSITION, SHORT_CIRCUIT_WITH_SHUNT_COMPENSATORS, SHORT_CIRCUIT_WITH_VSC_CONVERTER_STATIONS, SHORT_CIRCUIT_WITH_LOADS, SHORT_CIRCUIT_PREDEFINED_PARAMS, PredefinedParameters, SHORT_CIRCUIT_WITH_FEEDER_RESULT } from "./constants.js";
+import "../../filter/HeaderFilterForm.js";
+import { getNameElementEditorSchema, getNameElementEditorEmptyFormData } from "../common/name-element-editor/name-element-editor-utils.js";
+import { fetchShortCircuitParameters } from "../../../services/short-circuit-analysis.js";
+const useShortCircuitParametersForm = ({
+  parametersUuid,
+  name,
+  description,
+  studyUuid,
+  studyShortCircuitParameters
+}) => {
+  const { snackError } = useSnackMessage();
+  const [paramsLoading, setParamsLoading] = useState(false);
+  const [shortCircuitParameters, setShortCircuitParameters] = useState();
+  const formSchema = useMemo(() => {
+    return yup.object().shape({
+      [SHORT_CIRCUIT_WITH_FEEDER_RESULT]: yup.boolean().required(),
+      [SHORT_CIRCUIT_PREDEFINED_PARAMS]: yup.mixed().oneOf(Object.values(PredefinedParameters)).required(),
+      [SHORT_CIRCUIT_WITH_LOADS]: yup.boolean().required(),
+      [SHORT_CIRCUIT_WITH_VSC_CONVERTER_STATIONS]: yup.boolean().required(),
+      [SHORT_CIRCUIT_WITH_SHUNT_COMPENSATORS]: yup.boolean().required(),
+      [SHORT_CIRCUIT_WITH_NEUTRAL_POSITION]: yup.boolean().required(),
+      [SHORT_CIRCUIT_INITIAL_VOLTAGE_PROFILE_MODE]: yup.mixed().oneOf(Object.values(InitialVoltage)).required()
+    }).required().concat(getNameElementEditorSchema(name));
+  }, [name]);
+  const emptyFormData = useMemo(() => {
+    return {
+      ...getNameElementEditorEmptyFormData(name, description),
+      [SHORT_CIRCUIT_WITH_FEEDER_RESULT]: false,
+      [SHORT_CIRCUIT_PREDEFINED_PARAMS]: PredefinedParameters.ICC_MAX_WITH_CEI909,
+      [SHORT_CIRCUIT_WITH_LOADS]: false,
+      [SHORT_CIRCUIT_WITH_VSC_CONVERTER_STATIONS]: false,
+      [SHORT_CIRCUIT_WITH_SHUNT_COMPENSATORS]: false,
+      [SHORT_CIRCUIT_WITH_NEUTRAL_POSITION]: false,
+      [SHORT_CIRCUIT_INITIAL_VOLTAGE_PROFILE_MODE]: InitialVoltage.CEI909
+    };
+  }, [name, description]);
+  const formMethods = useForm({
+    defaultValues: emptyFormData,
+    resolver: yupResolver(formSchema)
+  });
+  const { getValues, reset, setValue } = formMethods;
+  const resetAll = useCallback(
+    (predefinedParameter) => {
+      const dirty = { shouldDirty: true };
+      setValue(SHORT_CIRCUIT_WITH_FEEDER_RESULT, true, dirty);
+      setValue(SHORT_CIRCUIT_WITH_LOADS, false, dirty);
+      setValue(
+        SHORT_CIRCUIT_WITH_VSC_CONVERTER_STATIONS,
+        predefinedParameter !== PredefinedParameters.ICC_MIN_WITH_NOMINAL_VOLTAGE_MAP,
+        dirty
+      );
+      setValue(SHORT_CIRCUIT_WITH_SHUNT_COMPENSATORS, false, dirty);
+      setValue(SHORT_CIRCUIT_WITH_NEUTRAL_POSITION, false, dirty);
+      const initialVoltageProfileMode = predefinedParameter === PredefinedParameters.ICC_MAX_WITH_CEI909 ? InitialVoltage.CEI909 : InitialVoltage.NOMINAL;
+      setValue(SHORT_CIRCUIT_INITIAL_VOLTAGE_PROFILE_MODE, initialVoltageProfileMode, dirty);
+      setValue(SHORT_CIRCUIT_PREDEFINED_PARAMS, predefinedParameter, dirty);
+    },
+    [setValue]
+  );
+  const prepareDataToSend = (shortCircuitParams, newParameters) => {
+    const oldParameters = { ...shortCircuitParams.parameters };
+    const {
+      predefinedParameters: omit,
+      [NAME]: omit2,
+      [DESCRIPTION_INPUT]: omit3,
+      ...newParametersWithoutPredefinedParameters
+    } = newParameters;
+    let parameters = {
+      ...oldParameters,
+      ...newParametersWithoutPredefinedParameters,
+      // we need to add voltageRanges to the parameters only when initialVoltageProfileMode is equals to CEI909
+      voltageRanges: void 0,
+      withNeutralPosition: !newParameters.withNeutralPosition
+    };
+    if (newParameters.initialVoltageProfileMode === InitialVoltage.CEI909) {
+      parameters = {
+        ...parameters,
+        voltageRanges: shortCircuitParams.cei909VoltageRanges,
+        initialVoltageProfileMode: InitialVoltage.CONFIGURED
+      };
+    }
+    return {
+      predefinedParameters: newParameters.predefinedParameters,
+      parameters
+    };
+  };
+  const getCurrentValues = useCallback(() => {
+    if (shortCircuitParameters) {
+      const currentValues = getValues();
+      return { ...prepareDataToSend(shortCircuitParameters, currentValues) };
+    }
+    return {};
+  }, [shortCircuitParameters, getValues]);
+  const formatShortCircuitParameters = (parameters, predefinedParameters) => {
+    return {
+      [SHORT_CIRCUIT_WITH_FEEDER_RESULT]: parameters.withFeederResult,
+      [SHORT_CIRCUIT_PREDEFINED_PARAMS]: predefinedParameters,
+      [SHORT_CIRCUIT_WITH_LOADS]: parameters.withLoads,
+      [SHORT_CIRCUIT_WITH_VSC_CONVERTER_STATIONS]: parameters.withVSCConverterStations,
+      [SHORT_CIRCUIT_WITH_SHUNT_COMPENSATORS]: parameters.withShuntCompensators,
+      [SHORT_CIRCUIT_WITH_NEUTRAL_POSITION]: !parameters.withNeutralPosition,
+      [SHORT_CIRCUIT_INITIAL_VOLTAGE_PROFILE_MODE]: parameters.initialVoltageProfileMode === InitialVoltage.CONFIGURED ? InitialVoltage.CEI909 : parameters.initialVoltageProfileMode
+    };
+  };
+  const onSaveInline = useCallback(
+    (formData) => {
+      if (studyUuid && shortCircuitParameters) {
+        const oldParams = shortCircuitParameters;
+        setStudyShortCircuitParameters(studyUuid, {
+          ...prepareDataToSend(shortCircuitParameters, formData)
+        }).then(() => {
+          invalidateStudyShortCircuitStatus(studyUuid).catch((error) => {
+            snackError({
+              messageTxt: error.message,
+              headerId: "invalidateShortCircuitStatusError"
+            });
+          });
+        }).catch((error) => {
+          setShortCircuitParameters(oldParams);
+          snackError({
+            messageTxt: error.message,
+            headerId: "paramsChangingError"
+          });
+        });
+      }
+    },
+    [shortCircuitParameters, setShortCircuitParameters, snackError, studyUuid]
+  );
+  const onSaveDialog = useCallback(
+    (formData) => {
+      if (parametersUuid && shortCircuitParameters) {
+        updateParameter(
+          parametersUuid,
+          prepareDataToSend(shortCircuitParameters, formData),
+          formData[NAME],
+          ElementType.SHORT_CIRCUIT_PARAMETERS,
+          formData[DESCRIPTION_INPUT] ?? ""
+        ).catch((error) => {
+          snackError({
+            messageTxt: error.message,
+            headerId: "paramsChangingError"
+          });
+        });
+      }
+    },
+    [parametersUuid, shortCircuitParameters, snackError]
+  );
+  useEffect(() => {
+    if (parametersUuid) {
+      const timer = setTimeout(() => {
+        setParamsLoading(true);
+      }, 700);
+      fetchShortCircuitParameters(parametersUuid).then((params) => {
+        setShortCircuitParameters(params);
+      }).catch((error) => {
+        snackError({
+          messageTxt: error.message,
+          headerId: "paramsRetrievingError"
+        });
+      }).finally(() => {
+        clearTimeout(timer);
+        setParamsLoading(false);
+      });
+    }
+  }, [parametersUuid, snackError]);
+  useEffect(() => {
+    if (studyShortCircuitParameters) {
+      setShortCircuitParameters(studyShortCircuitParameters);
+    }
+  }, [studyShortCircuitParameters]);
+  useEffect(() => {
+    if (shortCircuitParameters) {
+      const { parameters, predefinedParameters } = shortCircuitParameters;
+      reset(formatShortCircuitParameters(parameters, predefinedParameters));
+    }
+  }, [reset, shortCircuitParameters]);
+  return {
+    formMethods,
+    formSchema,
+    paramsLoading,
+    onSaveInline,
+    onSaveDialog,
+    resetAll,
+    getCurrentValues
+  };
+};
+export {
+  useShortCircuitParametersForm
+};

package/dist/components/treeViewFinder/TreeViewFinder.d.ts

@@ -2,10 +2,12 @@ import { ReactElement } from 'react';
 import { ButtonProps, ModalProps } from '@mui/material';
 import { SimpleTreeViewClasses } from '@mui/x-tree-view';
 import { UUID } from 'crypto';
+import { ElementType } from '../../utils';
 export declare const generateTreeViewFinderClass: (className: string) => string;
 export interface TreeViewFinderNodeProps {
     id: UUID;
     name: string;
+    type?: ElementType;
     description?: string;
     icon?: ReactElement;
     childrenCount?: number;

package/dist/index.js

@@ -44,6 +44,9 @@ import { FILTER_EQUIPMENTS_ATTRIBUTES } from "./components/filter/explicitNaming
 import { saveExpertFilter, saveExplicitNamingFilter } from "./components/filter/utils/filterApi.js";
 import { CONTINGENCY_LIST_EQUIPMENTS, FILTER_EQUIPMENTS } from "./components/filter/utils/filterFormUtils.js";
 import { FlatParameters, extractDefault } from "./components/flatParameters/FlatParameters.js";
+import "react/jsx-runtime";
+import "@mui/material";
+import "react-intl";
 import { SelectClearable } from "./components/inputs/SelectClearable.js";
 import { DESCRIPTION_INPUT, DirectoryItemsInput, NAME } from "./components/inputs/reactHookForm/DirectoryItemsInput.js";
 import { RawReadOnlyInput } from "./components/inputs/reactHookForm/RawReadOnlyInput.js";
@@ -140,6 +143,9 @@ import { getTabIndicatorStyle, getTabStyle, parametersStyles } from "./component
 import { BALANCE_TYPE, COMMON_PARAMETERS, CONNECTED_COMPONENT_MODE, COUNTRIES_TO_BALANCE, DC, DC_POWER_FACTOR, DC_USE_TRANSFORMER_RATIO, DEFAULT_LIMIT_REDUCTION_VALUE, DISTRIBUTED_SLACK, HVDC_AC_EMULATION, MAX_VALUE_ALLOWED_FOR_LIMIT_REDUCTION, MIN_VALUE_ALLOWED_FOR_LIMIT_REDUCTION, PARAM_LIMIT_REDUCTION, PARAM_PROVIDER_OPENLOADFLOW, PHASE_SHIFTER_REGULATION_ON, READ_SLACK_BUS, SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON, SPECIFIC_PARAMETERS, TRANSFORMER_VOLTAGE_CONTROL_ON, TWT_SPLIT_SHUNT_ADMITTANCE, USE_REACTIVE_LIMITS, VOLTAGE_INIT_MODE, WRITE_SLACK_BUS, alertThresholdMarks } from "./components/parameters/loadflow/constants.js";
 import { LoadFlowParametersInline } from "./components/parameters/loadflow/load-flow-parameters-inline.js";
 import { LoadFlowParametersEditionDialog } from "./components/parameters/loadflow/load-flow-parameters-dialog.js";
+import { InitialVoltage, PredefinedParameters, SHORT_CIRCUIT_INITIAL_VOLTAGE_PROFILE_MODE, SHORT_CIRCUIT_PREDEFINED_PARAMS, SHORT_CIRCUIT_WITH_FEEDER_RESULT, SHORT_CIRCUIT_WITH_LOADS, SHORT_CIRCUIT_WITH_NEUTRAL_POSITION, SHORT_CIRCUIT_WITH_SHUNT_COMPENSATORS, SHORT_CIRCUIT_WITH_VSC_CONVERTER_STATIONS, intlInitialVoltageProfileMode, intlPredefinedParametersOptions } from "./components/parameters/short-circuit/constants.js";
+import { ShortCircuitParametersInLine } from "./components/parameters/short-circuit/short-circuit-parameters-inline.js";
+import { ShortCircuitParametersEditionDialog } from "./components/parameters/short-circuit/short-circuit-parameters-dialog.js";
 import { CustomMenuItem, CustomNestedMenuItem } from "./components/menus/custom-nested-menu.js";
 import { useStateBoolean } from "./hooks/customStates/useStateBoolean.js";
 import { useStateNumber } from "./hooks/customStates/useStateNumber.js";
@@ -161,7 +167,7 @@ import { createFilter, createParameter, fetchElementsInfos, saveFilter, updatePa
 import { fetchAppsMetadata, fetchDefaultCountry, fetchEnv, fetchFavoriteAndDefaultCountries, fetchStudyMetadata, isStudyMetadata } from "./services/appsMetadata.js";
 import { elementAlreadyExists, fetchDirectoryContent, fetchDirectoryElementPath, fetchRootFolders } from "./services/directory.js";
 import { PREFIX_STUDY_QUERIES, fetchLoadFlowParameters, getDefaultLoadFlowProvider, getLoadFlowDefaultLimitReductions, getLoadFlowProviders, getLoadFlowSpecificParametersDescription, getLoadFlowUrl, setLoadFlowParameters } from "./services/loadflow.js";
-import { exportFilter, getAvailableComponentLibraries, getStudyNetworkVisualizationsParameters, setStudyNetworkVisualizationParameters } from "./services/study.js";
+import { exportFilter, getAvailableComponentLibraries, getStudyNetworkVisualizationsParameters, getStudyShortCircuitParameters, invalidateStudyShortCircuitStatus, setStudyNetworkVisualizationParameters, setStudyShortCircuitParameters } from "./services/study.js";
 import { getNetworkVisualizationsParameters } from "./services/study-config.js";
 import { fetchCurrentAnnouncement, fetchUserDetails } from "./services/userAdmin.js";
 import { equalsArray } from "./utils/algos.js";
@@ -353,6 +359,7 @@ export {
   INTL_MAP_BASE_MAP_OPTIONS,
   INTL_SUBSTATION_LAYOUT_OPTIONS,
   IST_FORM,
+  InitialVoltage,
   InputWithPopupConfirmation,
   IntegerInput,
   KILO_AMPERE,
@@ -450,6 +457,7 @@ export {
   ParameterSwitch,
   ParameterType,
   PopupConfirmationDialog,
+  PredefinedParameters,
   PropertyValueEditor,
   ProviderParam,
   RATIO_REGULATION_MODE_OPTIONS,
@@ -464,6 +472,13 @@ export {
   RemoveButton,
   RuleValueEditor,
   SEARCH_EQUIPMENTS,
+  SHORT_CIRCUIT_INITIAL_VOLTAGE_PROFILE_MODE,
+  SHORT_CIRCUIT_PREDEFINED_PARAMS,
+  SHORT_CIRCUIT_WITH_FEEDER_RESULT,
+  SHORT_CIRCUIT_WITH_LOADS,
+  SHORT_CIRCUIT_WITH_NEUTRAL_POSITION,
+  SHORT_CIRCUIT_WITH_SHUNT_COMPENSATORS,
+  SHORT_CIRCUIT_WITH_VSC_CONVERTER_STATIONS,
   SHOW_AUTH_INFO_LOGIN,
   SHUNT_COMPENSATOR_TYPE_OPTIONS,
   SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON,
@@ -476,6 +491,8 @@ export {
   SelectClearable,
   SelectInput,
   SensitivityType,
+  ShortCircuitParametersEditionDialog,
+  ShortCircuitParametersInLine,
   ShuntCompensator,
   SignInCallbackHandler,
   SilentRenewCallbackHandler,
@@ -602,6 +619,7 @@ export {
   getRequestParamFromList,
   getSAParametersFromSchema,
   getStudyNetworkVisualizationsParameters,
+  getStudyShortCircuitParameters,
   getSystemLanguage,
   getTabIndicatorStyle,
   getTabStyle,
@@ -617,6 +635,9 @@ export {
   initializeAuthenticationProd,
   inputsEn,
   inputsFr,
+  intlInitialVoltageProfileMode,
+  intlPredefinedParametersOptions,
+  invalidateStudyShortCircuitStatus,
   isBlankOrEmpty,
   isFieldRequired,
   isFloatNumber,
@@ -659,6 +680,7 @@ export {
   setShowAuthenticationRouterLogin,
   setSignInCallbackError,
   setStudyNetworkVisualizationParameters,
+  setStudyShortCircuitParameters,
   setUnauthorizedUserInfo,
   setUserValidationError,
   styles,

package/dist/services/index.js

@@ -3,7 +3,7 @@ import { createFilter, createParameter, fetchElementsInfos, saveFilter, updatePa
 import { fetchAppsMetadata, fetchDefaultCountry, fetchEnv, fetchFavoriteAndDefaultCountries, fetchStudyMetadata, isStudyMetadata } from "./appsMetadata.js";
 import { elementAlreadyExists, fetchDirectoryContent, fetchDirectoryElementPath, fetchRootFolders } from "./directory.js";
 import { PREFIX_STUDY_QUERIES, fetchLoadFlowParameters, getDefaultLoadFlowProvider, getLoadFlowDefaultLimitReductions, getLoadFlowProviders, getLoadFlowSpecificParametersDescription, getLoadFlowUrl, setLoadFlowParameters } from "./loadflow.js";
-import { exportFilter, getAvailableComponentLibraries, getStudyNetworkVisualizationsParameters, setStudyNetworkVisualizationParameters } from "./study.js";
+import { exportFilter, getAvailableComponentLibraries, getStudyNetworkVisualizationsParameters, getStudyShortCircuitParameters, invalidateStudyShortCircuitStatus, setStudyNetworkVisualizationParameters, setStudyShortCircuitParameters } from "./study.js";
 import { getNetworkVisualizationsParameters } from "./study-config.js";
 import { fetchCurrentAnnouncement, fetchUserDetails } from "./userAdmin.js";
 export {
@@ -37,9 +37,12 @@ export {
   getNetworkVisualizationsParameters,
   getRequestParamFromList,
   getStudyNetworkVisualizationsParameters,
+  getStudyShortCircuitParameters,
+  invalidateStudyShortCircuitStatus,
   isStudyMetadata,
   saveFilter,
   setLoadFlowParameters,
   setStudyNetworkVisualizationParameters,
+  setStudyShortCircuitParameters,
   updateParameter
 };

package/dist/services/short-circuit-analysis.d.ts

@@ -0,0 +1,2 @@
+import { ShortCircuitParametersInfos } from '../components/parameters/short-circuit/short-circuit-parameters.type';
+export declare function fetchShortCircuitParameters(parameterUuid: string): Promise<ShortCircuitParametersInfos>;

package/dist/services/short-circuit-analysis.js

@@ -0,0 +1,13 @@
+import { backendFetchJson } from "./utils.js";
+const PREFIX_SHORT_CIRCUIT_SERVER_QUERIES = `${"api/gateway"}/shortcircuit`;
+function getShortCircuitUrl() {
+  return `${PREFIX_SHORT_CIRCUIT_SERVER_QUERIES}/v1`;
+}
+function fetchShortCircuitParameters(parameterUuid) {
+  console.info("get short circuit analysis parameters");
+  const url = `${getShortCircuitUrl()}/parameters/${encodeURIComponent(parameterUuid)}`;
+  return backendFetchJson(url);
+}
+export {
+  fetchShortCircuitParameters
+};

package/dist/services/study.d.ts

@@ -1,6 +1,10 @@
 import { UUID } from 'crypto';
 import { NetworkVisualizationParameters } from '../components/parameters/network-visualizations/network-visualizations.types';
+import { ShortCircuitParameters, ShortCircuitParametersInfos } from '../components/parameters/short-circuit/short-circuit-parameters.type';
 export declare function exportFilter(studyUuid: UUID, filterUuid?: UUID, token?: string): Promise<any>;
 export declare function getAvailableComponentLibraries(): Promise<string[]>;
 export declare function getStudyNetworkVisualizationsParameters(studyUuid: UUID): Promise<NetworkVisualizationParameters>;
 export declare function setStudyNetworkVisualizationParameters(studyUuid: UUID, newParams: Record<string, any>): Promise<Response>;
+export declare function getStudyShortCircuitParameters(studyUuid: UUID): Promise<ShortCircuitParametersInfos>;
+export declare function setStudyShortCircuitParameters(studyUuid: UUID, newParams: ShortCircuitParameters): Promise<Response>;
+export declare function invalidateStudyShortCircuitStatus(studyUuid: UUID): Promise<Response>;