@gridsuite/commons-ui 0.166.0 → 0.167.0

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

@@ -0,0 +1,176 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { Grid } from "@mui/material";
+import { useIntl, FormattedMessage } from "react-intl";
+import { useState, useCallback, useEffect } from "react";
+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 { DynamicMarginCalculationForm } from "./dynamic-margin-calculation-form.js";
+import { useDynamicMarginCalculationParametersForm, toParamsInfos, toFormValues } from "./use-dynamic-margin-calculation-parameters-form.js";
+import { LabelledButton } from "../common/parameters.js";
+import { SubmitButton } from "../../inputs/reactHookForm/utils/SubmitButton.js";
+import { PopupConfirmationDialog } from "../../dialogs/popupConfirmationDialog/PopupConfirmationDialog.js";
+import { parametersStyles } from "../parameters-style.js";
+import { CreateParameterDialog } from "../common/parameters-creation-dialog.js";
+import "../../overflowableText/OverflowableText.js";
+import "react-hook-form";
+import { fetchDynamicMarginCalculationParameters } from "../../../services/dynamic-margin-calculation.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import { useSnackMessage } from "../../../hooks/useSnackMessage.js";
+import "../../inputs/reactHookForm/provider/CustomFormProvider.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 "@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 "@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";
+function DynamicMarginCalculationInline({
+  studyUuid,
+  parametersBackend,
+  setHaveDirtyFields
+}) {
+  const [providers, , , , , params, , updateParams, resetParams, ,] = parametersBackend;
+  const dynamicMarginCalculationMethods = useDynamicMarginCalculationParametersForm({
+    providers,
+    params,
+    name: null,
+    description: null
+  });
+  const intl = useIntl();
+  const { snackError } = useSnackMessage();
+  const [openCreateParameterDialog, setOpenCreateParameterDialog] = useState(false);
+  const [openSelectParameterDialog, setOpenSelectParameterDialog] = useState(false);
+  const [openResetConfirmation, setOpenResetConfirmation] = useState(false);
+  const { formMethods, onError } = dynamicMarginCalculationMethods;
+  const { reset, handleSubmit, getValues, formState } = formMethods;
+  const handleResetClick = useCallback(() => {
+    setOpenResetConfirmation(true);
+  }, []);
+  const handleCancelReset = useCallback(() => {
+    setOpenResetConfirmation(false);
+  }, []);
+  const handleReset = useCallback(() => {
+    resetParams();
+    setOpenResetConfirmation(false);
+  }, [resetParams]);
+  const onSubmit = useCallback(
+    (formData) => {
+      updateParams(toParamsInfos(formData));
+    },
+    [updateParams]
+  );
+  const handleLoadParameter = useCallback(
+    (newParams) => {
+      if (newParams?.length) {
+        setOpenSelectParameterDialog(false);
+        const parametersUuid = newParams[0].id;
+        fetchDynamicMarginCalculationParameters(parametersUuid).then((_params) => {
+          reset(toFormValues(_params), {
+            keepDefaultValues: true
+          });
+        }).catch((error) => {
+          snackWithFallback(snackError, error, { headerId: "paramsRetrievingError" });
+        });
+      }
+      setOpenSelectParameterDialog(false);
+    },
+    [reset, snackError]
+  );
+  useEffect(() => {
+    setHaveDirtyFields(!!Object.keys(formState.dirtyFields).length);
+  }, [formState, setHaveDirtyFields]);
+  const renderActions = () => {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Grid, { container: true, item: true, children: /* @__PURE__ */ jsxs(
+        Grid,
+        {
+          sx: mergeSx(parametersStyles.controlParametersItem, {
+            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, onError), children: /* @__PURE__ */ jsx(FormattedMessage, { id: "validate" }) })
+          ]
+        }
+      ) }),
+      openCreateParameterDialog && /* @__PURE__ */ jsx(
+        CreateParameterDialog,
+        {
+          studyUuid,
+          open: openCreateParameterDialog,
+          onClose: () => setOpenCreateParameterDialog(false),
+          parameterValues: getValues,
+          parameterFormatter: toParamsInfos,
+          parameterType: ElementType.DYNAMIC_MARGIN_CALCULATION_PARAMETERS
+        }
+      ),
+      openSelectParameterDialog && /* @__PURE__ */ jsx(
+        DirectoryItemSelector,
+        {
+          open: openSelectParameterDialog,
+          onClose: handleLoadParameter,
+          types: [ElementType.DYNAMIC_MARGIN_CALCULATION_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(
+    DynamicMarginCalculationForm,
+    {
+      dynamicMarginCalculationMethods,
+      renderActions
+    }
+  );
+}
+export {
+  DynamicMarginCalculationInline
+};

package/dist/components/parameters/dynamic-margin-calculation/dynamic-margin-calculation.type.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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_LOADS_VARIATIONS = "TAB_LOADS_VARIATIONS"
+}

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

@@ -0,0 +1,8 @@
+var TabValues = /* @__PURE__ */ ((TabValues2) => {
+  TabValues2["TAB_TIME_DELAY"] = "TAB_TIME_DELAY";
+  TabValues2["TAB_LOADS_VARIATIONS"] = "TAB_LOADS_VARIATIONS";
+  return TabValues2;
+})(TabValues || {});
+export {
+  TabValues
+};

package/dist/components/parameters/dynamic-margin-calculation/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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 './constants';
+export * from './dynamic-margin-calculation-inline';

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

@@ -0,0 +1,17 @@
+import { ACCURACY, ACTIVE, CALCULATION_TYPE, LOADS_VARIATIONS, LOAD_FILTERS, LOAD_INCREASE_START_TIME, LOAD_INCREASE_STOP_TIME, LOAD_MODELS_RULE, MARGIN_CALCULATION_START_TIME, START_TIME, STOP_TIME, VARIATION } from "./constants.js";
+import { DynamicMarginCalculationInline } from "./dynamic-margin-calculation-inline.js";
+export {
+  ACCURACY,
+  ACTIVE,
+  CALCULATION_TYPE,
+  DynamicMarginCalculationInline,
+  LOADS_VARIATIONS,
+  LOAD_FILTERS,
+  LOAD_INCREASE_START_TIME,
+  LOAD_INCREASE_STOP_TIME,
+  LOAD_MODELS_RULE,
+  MARGIN_CALCULATION_START_TIME,
+  START_TIME,
+  STOP_TIME,
+  VARIATION
+};

package/dist/components/parameters/dynamic-margin-calculation/loads-variations-parameters.d.ts

@@ -0,0 +1,29 @@
+import { default as yup } from '../../../utils/yupConfig';
+export declare const formSchema: yup.ObjectSchema<{
+    calculationType: string;
+    accuracy: number;
+    loadModelsRule: string;
+    loadsVariations: {
+        active?: yup.Maybe<boolean | null | undefined>;
+        id?: string | null | undefined;
+        loadFilters?: {
+            name?: yup.Maybe<string | null | undefined>;
+            id: string;
+        }[] | undefined;
+        variation: number;
+    }[] | undefined;
+}, yup.AnyObject, {
+    calculationType: undefined;
+    accuracy: undefined;
+    loadModelsRule: undefined;
+    loadsVariations: "";
+}, "">;
+export declare const emptyFormData: {
+    calculationType: string;
+    accuracy: number;
+    loadModelsRule: string;
+    loadsVariations: never[];
+};
+export default function LoadsVariationsParameters({ path }: Readonly<{
+    path: string;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/dynamic-margin-calculation/loads-variations-parameters.js

@@ -0,0 +1,154 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { useIntl } from "react-intl";
+import { Grid } from "@mui/material";
+import "../../../utils/yupConfig.js";
+import { LOADS_VARIATIONS, ACTIVE, VARIATION, LOAD_FILTERS, LOAD_MODELS_RULE, ACCURACY, CALCULATION_TYPE } from "./constants.js";
+import { ID } from "../../../utils/constants/filterConstant.js";
+import "../../../utils/conversionUtils.js";
+import { ElementType } from "../../../utils/types/elementType.js";
+import { EquipmentType } from "../../../utils/types/equipmentType.js";
+import { ParameterType } from "../../../utils/types/parameters.type.js";
+import { CalculationType, LoadModelsRule } from "../../../utils/types/dynamic-margin-calculation.type.js";
+import "@mui/icons-material";
+import ParameterField from "../common/parameter-field.js";
+import "../../overflowableText/OverflowableText.js";
+import "react-hook-form";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import * as yup from "yup";
+import "../../treeViewFinder/TreeViewFinder.js";
+import { NAME } from "../../inputs/reactHookForm/constants.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 "@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 "@react-querybuilder/material";
+import "../../filter/expert/expertFilterConstants.js";
+import "../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "uuid";
+import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
+import "react-querybuilder";
+import ParameterDndTableField from "../common/parameter-dnd-table-field.js";
+import "@hello-pangea/dnd";
+import { DndColumnType } from "../../dnd-table/dnd-table.type.js";
+const formSchema = yup.object().shape({
+  [CALCULATION_TYPE]: yup.string().required(),
+  [ACCURACY]: yup.number().required(),
+  [LOAD_MODELS_RULE]: yup.string().required(),
+  [LOADS_VARIATIONS]: yup.array().of(
+    yup.object().shape({
+      [ID]: yup.string().nullable(),
+      // not shown in form, used to identify a row
+      [LOAD_FILTERS]: yup.array().of(
+        yup.object().shape({
+          [ID]: yup.string().required(),
+          [NAME]: yup.string().nullable().notRequired()
+        })
+      ).min(1),
+      [VARIATION]: yup.number().min(0).required(),
+      [ACTIVE]: yup.boolean().nullable().notRequired()
+    })
+  )
+});
+const emptyFormData = {
+  [CALCULATION_TYPE]: "",
+  [ACCURACY]: 0,
+  [LOAD_MODELS_RULE]: "",
+  [LOADS_VARIATIONS]: []
+};
+const params = [
+  {
+    name: CALCULATION_TYPE,
+    type: ParameterType.STRING,
+    label: "DynamicMarginCalculationCalculationType",
+    possibleValues: [
+      { id: CalculationType.GLOBAL_MARGIN, label: "DynamicMarginCalculationCalculationTypeGlobalMargin" },
+      { id: CalculationType.LOCAL_MARGIN, label: "DynamicMarginCalculationCalculationTypeLocalMargin" }
+    ],
+    sx: { width: "100%" }
+  },
+  {
+    name: ACCURACY,
+    type: ParameterType.DOUBLE,
+    label: "DynamicMarginCalculationAccuracy"
+  },
+  {
+    name: LOAD_MODELS_RULE,
+    type: ParameterType.STRING,
+    label: "DynamicMarginCalculationLoadModelsRule",
+    possibleValues: [
+      { id: LoadModelsRule.ALL_LOADS, label: "DynamicMarginCalculationLoadModelsRuleAllLoads" },
+      { id: LoadModelsRule.TARGETED_LOADS, label: "DynamicMarginCalculationLoadModelsRuleTargetedLoads" }
+    ],
+    sx: { width: "100%" }
+  }
+  // LOADS_VARIATIONS displayed in a separated component, i.e., ParameterDndTableField
+];
+const loadsVariationsColumnsDefinition = [
+  {
+    label: "DynamicMarginCalculationLoadsFilter",
+    dataKey: LOAD_FILTERS,
+    initialValue: [],
+    editable: true,
+    type: DndColumnType.DIRECTORY_ITEMS,
+    equipmentTypes: [EquipmentType.LOAD],
+    elementType: ElementType.FILTER,
+    titleId: "FiltersListsSelection"
+  },
+  {
+    label: "DynamicMarginCalculationLoadsVariation",
+    dataKey: VARIATION,
+    editable: true,
+    type: DndColumnType.NUMERIC,
+    textAlign: "right"
+  },
+  {
+    label: "DynamicMarginCalculationLoadsActive",
+    initialValue: true,
+    dataKey: ACTIVE,
+    editable: true,
+    width: 100,
+    type: DndColumnType.SWITCH
+  }
+];
+function LoadsVariationsParameters({ path }) {
+  const inlt = useIntl();
+  const translatedColumnsDefinition = useMemo(() => {
+    return loadsVariationsColumnsDefinition.map((colDef) => ({
+      ...colDef,
+      label: inlt.formatMessage({ id: colDef.label })
+    }));
+  }, [inlt]);
+  return /* @__PURE__ */ jsxs(Grid, { container: true, children: [
+    params.map((param) => {
+      const { name, type, ...otherParams } = param;
+      return /* @__PURE__ */ jsx(ParameterField, { id: path, name: param.name, type: param.type, ...otherParams }, param.name);
+    }),
+    /* @__PURE__ */ jsx(
+      ParameterDndTableField,
+      {
+        name: `${path}.${LOADS_VARIATIONS}`,
+        label: "DynamicMarginCalculationLoadsVariations",
+        tooltipProps: { title: "DynamicMarginCalculationLoadsVariations" },
+        columnsDefinition: translatedColumnsDefinition,
+        tableHeight: 270
+      }
+    )
+  ] });
+}
+export {
+  LoadsVariationsParameters as default,
+  emptyFormData,
+  formSchema
+};

package/dist/components/parameters/dynamic-margin-calculation/time-delay-parameters.d.ts

@@ -0,0 +1,24 @@
+import { default as yup } from '../../../utils/yupConfig';
+export declare const formSchema: yup.ObjectSchema<{
+    startTime: number;
+    stopTime: number;
+    marginCalculationStartTime: number;
+    loadIncreaseStartTime: number;
+    loadIncreaseStopTime: number;
+}, yup.AnyObject, {
+    startTime: undefined;
+    stopTime: undefined;
+    marginCalculationStartTime: undefined;
+    loadIncreaseStartTime: undefined;
+    loadIncreaseStopTime: undefined;
+}, "">;
+export declare const emptyFormData: {
+    startTime: number;
+    stopTime: number;
+    marginCalculationStartTime: number;
+    loadIncreaseStartTime: number;
+    loadIncreaseStopTime: number;
+};
+export default function TimeDelayParameters({ path }: Readonly<{
+    path: string;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/dynamic-margin-calculation/time-delay-parameters.js

@@ -0,0 +1,62 @@
+import { jsx } from "react/jsx-runtime";
+import { Grid } from "@mui/material";
+import "../../../utils/yupConfig.js";
+import { LOAD_INCREASE_STOP_TIME, LOAD_INCREASE_START_TIME, MARGIN_CALCULATION_START_TIME, STOP_TIME, START_TIME } from "./constants.js";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/types/equipmentType.js";
+import { ParameterType } from "../../../utils/types/parameters.type.js";
+import "@mui/icons-material";
+import ParameterField from "../common/parameter-field.js";
+import * as yup from "yup";
+const formSchema = yup.object().shape({
+  [START_TIME]: yup.number().required(),
+  [STOP_TIME]: yup.number().required(),
+  [MARGIN_CALCULATION_START_TIME]: yup.number().required(),
+  [LOAD_INCREASE_START_TIME]: yup.number().required(),
+  [LOAD_INCREASE_STOP_TIME]: yup.number().required()
+});
+const emptyFormData = {
+  [START_TIME]: 0,
+  [STOP_TIME]: 0,
+  [MARGIN_CALCULATION_START_TIME]: 0,
+  [LOAD_INCREASE_START_TIME]: 0,
+  [LOAD_INCREASE_STOP_TIME]: 0
+};
+const params = [
+  {
+    name: START_TIME,
+    type: ParameterType.DOUBLE,
+    label: "DynamicMarginCalculationStartTime"
+  },
+  {
+    name: STOP_TIME,
+    type: ParameterType.DOUBLE,
+    label: "DynamicMarginCalculationStopTime"
+  },
+  {
+    name: MARGIN_CALCULATION_START_TIME,
+    type: ParameterType.DOUBLE,
+    label: "DynamicMarginCalculationMarginCalculationStartTime"
+  },
+  {
+    name: LOAD_INCREASE_START_TIME,
+    type: ParameterType.DOUBLE,
+    label: "DynamicMarginCalculationLoadIncreaseStartTime"
+  },
+  {
+    name: LOAD_INCREASE_STOP_TIME,
+    type: ParameterType.DOUBLE,
+    label: "DynamicMarginCalculationLoadIncreaseStopTime"
+  }
+];
+function TimeDelayParameters({ path }) {
+  return /* @__PURE__ */ jsx(Grid, { container: true, children: params.map((param) => {
+    const { name, type, ...otherParams } = param;
+    return /* @__PURE__ */ jsx(ParameterField, { id: path, name: param.name, type: param.type, ...otherParams }, param.name);
+  }) });
+}
+export {
+  TimeDelayParameters as default,
+  emptyFormData,
+  formSchema
+};

package/dist/components/parameters/dynamic-margin-calculation/use-dynamic-margin-calculation-parameters-form.d.ts

@@ -0,0 +1,30 @@
+import { FieldErrors, FieldValues, UseFormReturn } from 'react-hook-form';
+import { ObjectSchema } from 'yup';
+import { SyntheticEvent } from 'react';
+import { DynamicMarginCalculationParametersInfos } from '../../../utils/types/dynamic-margin-calculation.type';
+import { TabValues } from './dynamic-margin-calculation.type';
+export declare const toFormValues: (_params: DynamicMarginCalculationParametersInfos) => FieldValues;
+export declare const toParamsInfos: (_formData: FieldValues) => DynamicMarginCalculationParametersInfos;
+export type UseTabsReturn<TTabValue extends string> = {
+    selectedTab: TTabValue;
+    tabsWithError: TTabValue[];
+    onTabChange: (event: SyntheticEvent, newValue: TTabValue) => void;
+    onError: (errors: FieldErrors) => void;
+};
+export type UseComputationParametersFormReturn<TTabValue extends string> = UseTabsReturn<TTabValue> & {
+    formMethods: UseFormReturn;
+    formSchema: ObjectSchema<any>;
+    paramsLoaded: boolean;
+    formattedProviders: {
+        id: string;
+        label: string;
+    }[];
+};
+export type UseDynamicMarginCalculationParametersFormReturn = UseComputationParametersFormReturn<TabValues>;
+export type UseParametersFormProps = {
+    providers: Record<string, string>;
+    params: DynamicMarginCalculationParametersInfos | null;
+    name: string | null;
+    description: string | null;
+};
+export declare function useDynamicMarginCalculationParametersForm({ providers, params, name: initialName, description: initialDescription, }: Readonly<UseParametersFormProps>): UseDynamicMarginCalculationParametersFormReturn;