@gridsuite/commons-ui 0.191.0 → 0.193.0

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

@@ -0,0 +1,283 @@
+import { EquipmentType, EQUIPMENTS_WITH_ONE_SUBSTATION, EQUIPMENTS_WITH_TWO_SUBSTATIONS, EQUIPMENTS_WITH_ONE_NOMINAL_VOLTAGE, EQUIPMENTS_WITH_TWO_NOMINAL_VOLTAGES, EQUIPMENTS_WITH_THREE_NOMINAL_VOLTAGES } from "../../../../../utils/types/equipmentType.js";
+import { FieldType } from "../../../../../utils/types/fieldType.js";
+import { DataType, OperatorType, CombinatorType } from "../../../../filter/expert/expertFilter.type.js";
+import { FilterType } from "../../../../filter/constants/FilterConstants.js";
+const CURVE_EQUIPMENT_TYPES = [
+  EquipmentType.GENERATOR,
+  EquipmentType.LOAD,
+  EquipmentType.BUS,
+  EquipmentType.BUSBAR_SECTION
+];
+const getReferencedEquipmentTypeForModel = (equipmentType) => {
+  return equipmentType === EquipmentType.BUSBAR_SECTION ? EquipmentType.BUS : equipmentType;
+};
+const getTopologyKindIfNecessary = (equipmentType) => {
+  return equipmentType === EquipmentType.BUS ? {
+    topologyKind: "BUS_BREAKER"
+  } : {};
+};
+const buildSubstationPropertiesRules = (equipmentType, substationProperties, rules) => {
+  if (EQUIPMENTS_WITH_ONE_SUBSTATION.includes(equipmentType)) {
+    let propertyField = FieldType.SUBSTATION_PROPERTIES;
+    if (equipmentType === EquipmentType.SUBSTATION) {
+      propertyField = FieldType.FREE_PROPERTIES;
+    }
+    Object.entries(substationProperties).forEach(([propertyName, propertyValues]) => {
+      if (propertyValues?.length) {
+        const substationPropertiesRule = {
+          field: propertyField,
+          operator: OperatorType.IN,
+          propertyName,
+          propertyValues,
+          dataType: DataType.PROPERTY
+        };
+        rules.push(substationPropertiesRule);
+      }
+    });
+  } else if (EQUIPMENTS_WITH_TWO_SUBSTATIONS.includes(equipmentType)) {
+    Object.entries(substationProperties).forEach(([propertyName, propertyValues]) => {
+      if (propertyValues?.length) {
+        const substationPropertiesRule = {
+          combinator: CombinatorType.OR,
+          dataType: DataType.COMBINATOR,
+          rules: [
+            {
+              field: FieldType.SUBSTATION_PROPERTIES_1,
+              operator: OperatorType.IN,
+              propertyName,
+              propertyValues,
+              dataType: DataType.PROPERTY
+            },
+            {
+              field: FieldType.SUBSTATION_PROPERTIES_2,
+              operator: OperatorType.IN,
+              propertyName,
+              propertyValues,
+              dataType: DataType.PROPERTY
+            }
+          ]
+        };
+        rules.push(substationPropertiesRule);
+      }
+    });
+  }
+};
+const buildExpertRules = (equipmentType, voltageLevelIds, countries, nominalVoltages, substationProperties, ids) => {
+  const rules = [];
+  if (voltageLevelIds?.length) {
+    const voltageLevelIdsRule = {
+      field: FieldType.VOLTAGE_LEVEL_ID,
+      operator: OperatorType.IN,
+      values: voltageLevelIds,
+      dataType: DataType.STRING
+    };
+    rules.push(voltageLevelIdsRule);
+  }
+  if (countries?.length && EQUIPMENTS_WITH_ONE_SUBSTATION.includes(equipmentType)) {
+    const countriesRule = {
+      field: FieldType.COUNTRY,
+      operator: OperatorType.IN,
+      values: countries,
+      dataType: DataType.ENUM
+    };
+    rules.push(countriesRule);
+  } else if (countries?.length && EQUIPMENTS_WITH_TWO_SUBSTATIONS.includes(equipmentType)) {
+    const countriesRule = {
+      combinator: CombinatorType.OR,
+      dataType: DataType.COMBINATOR,
+      rules: [
+        {
+          field: FieldType.COUNTRY_1,
+          operator: OperatorType.IN,
+          values: countries,
+          dataType: DataType.ENUM
+        },
+        {
+          field: FieldType.COUNTRY_2,
+          operator: OperatorType.IN,
+          values: countries,
+          dataType: DataType.ENUM
+        }
+      ]
+    };
+    rules.push(countriesRule);
+  }
+  if (nominalVoltages?.length && EQUIPMENTS_WITH_ONE_NOMINAL_VOLTAGE.includes(equipmentType)) {
+    const nominalVoltagesRule = {
+      field: FieldType.NOMINAL_VOLTAGE,
+      operator: OperatorType.IN,
+      values: nominalVoltages,
+      dataType: DataType.NUMBER
+    };
+    rules.push(nominalVoltagesRule);
+  } else if (nominalVoltages?.length && EQUIPMENTS_WITH_TWO_NOMINAL_VOLTAGES.includes(equipmentType)) {
+    const nominalVoltagesRule = {
+      combinator: CombinatorType.OR,
+      dataType: DataType.COMBINATOR,
+      rules: [
+        {
+          field: FieldType.NOMINAL_VOLTAGE_1,
+          operator: OperatorType.IN,
+          values: nominalVoltages,
+          dataType: DataType.NUMBER
+        },
+        {
+          field: FieldType.NOMINAL_VOLTAGE_2,
+          operator: OperatorType.IN,
+          values: nominalVoltages,
+          dataType: DataType.NUMBER
+        }
+      ]
+    };
+    rules.push(nominalVoltagesRule);
+  } else if (nominalVoltages?.length && EQUIPMENTS_WITH_THREE_NOMINAL_VOLTAGES.includes(equipmentType)) {
+    const nominalVoltagesRule = {
+      combinator: CombinatorType.OR,
+      dataType: DataType.COMBINATOR,
+      rules: [
+        {
+          field: FieldType.NOMINAL_VOLTAGE_1,
+          operator: OperatorType.IN,
+          values: nominalVoltages,
+          dataType: DataType.NUMBER
+        },
+        {
+          field: FieldType.NOMINAL_VOLTAGE_2,
+          operator: OperatorType.IN,
+          values: nominalVoltages,
+          dataType: DataType.NUMBER
+        },
+        {
+          field: FieldType.NOMINAL_VOLTAGE_3,
+          operator: OperatorType.IN,
+          values: nominalVoltages,
+          dataType: DataType.NUMBER
+        }
+      ]
+    };
+    rules.push(nominalVoltagesRule);
+  }
+  if (substationProperties) {
+    buildSubstationPropertiesRules(equipmentType, substationProperties, rules);
+  }
+  Object.entries(ids ?? {}).forEach(([eqType, values]) => {
+    if (eqType === EquipmentType.SUBSTATION) {
+      if (EQUIPMENTS_WITH_ONE_SUBSTATION.includes(equipmentType)) {
+        const idsRule = {
+          field: equipmentType === EquipmentType.SUBSTATION ? FieldType.ID : FieldType.SUBSTATION_ID,
+          operator: OperatorType.IN,
+          values,
+          dataType: DataType.STRING
+        };
+        rules.push(idsRule);
+      } else if (EQUIPMENTS_WITH_TWO_SUBSTATIONS.includes(equipmentType)) {
+        const idsRule = {
+          combinator: CombinatorType.OR,
+          dataType: DataType.COMBINATOR,
+          rules: [
+            {
+              field: FieldType.SUBSTATION_ID_1,
+              operator: OperatorType.IN,
+              values,
+              dataType: DataType.STRING
+            },
+            {
+              field: FieldType.SUBSTATION_ID_2,
+              operator: OperatorType.IN,
+              values,
+              dataType: DataType.STRING
+            }
+          ]
+        };
+        rules.push(idsRule);
+      }
+    } else if (eqType === EquipmentType.VOLTAGE_LEVEL) {
+      if (EQUIPMENTS_WITH_ONE_NOMINAL_VOLTAGE.includes(equipmentType)) {
+        const idsRule = {
+          field: equipmentType === EquipmentType.VOLTAGE_LEVEL ? FieldType.ID : FieldType.VOLTAGE_LEVEL_ID,
+          operator: OperatorType.IN,
+          values,
+          dataType: DataType.STRING
+        };
+        rules.push(idsRule);
+      } else if (EQUIPMENTS_WITH_TWO_NOMINAL_VOLTAGES.includes(equipmentType)) {
+        const idsRule = {
+          combinator: CombinatorType.OR,
+          dataType: DataType.COMBINATOR,
+          rules: [
+            {
+              field: FieldType.VOLTAGE_LEVEL_ID_1,
+              operator: OperatorType.IN,
+              values,
+              dataType: DataType.STRING
+            },
+            {
+              field: FieldType.VOLTAGE_LEVEL_ID_2,
+              operator: OperatorType.IN,
+              values,
+              dataType: DataType.STRING
+            }
+          ]
+        };
+        rules.push(idsRule);
+      } else if (EQUIPMENTS_WITH_THREE_NOMINAL_VOLTAGES.includes(equipmentType)) {
+        const idsRule = {
+          combinator: CombinatorType.OR,
+          dataType: DataType.COMBINATOR,
+          rules: [
+            {
+              field: FieldType.VOLTAGE_LEVEL_ID_1,
+              operator: OperatorType.IN,
+              values,
+              dataType: DataType.STRING
+            },
+            {
+              field: FieldType.VOLTAGE_LEVEL_ID_2,
+              operator: OperatorType.IN,
+              values,
+              dataType: DataType.STRING
+            },
+            {
+              field: FieldType.VOLTAGE_LEVEL_ID_3,
+              operator: OperatorType.IN,
+              values,
+              dataType: DataType.STRING
+            }
+          ]
+        };
+        rules.push(idsRule);
+      }
+    } else {
+      const idsRule = {
+        field: FieldType.ID,
+        operator: OperatorType.IN,
+        values,
+        dataType: DataType.STRING
+      };
+      rules.push(idsRule);
+    }
+  });
+  return {
+    combinator: CombinatorType.AND,
+    dataType: DataType.COMBINATOR,
+    rules
+  };
+};
+const buildExpertFilter = (equipmentType, voltageLevelIds, countries, nominalVoltages, substationProperties, ids) => {
+  return {
+    ...getTopologyKindIfNecessary(equipmentType),
+    // for optimizing 'search bus' in filter-server
+    type: FilterType.EXPERT.id,
+    equipmentType,
+    rules: buildExpertRules(equipmentType, voltageLevelIds, countries, nominalVoltages, substationProperties, ids)
+  };
+};
+const NOMINAL_VOLTAGE_UNIT = "kV";
+export {
+  CURVE_EQUIPMENT_TYPES,
+  NOMINAL_VOLTAGE_UNIT,
+  buildExpertFilter,
+  buildExpertRules,
+  getReferencedEquipmentTypeForModel,
+  getTopologyKindIfNecessary
+};

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

@@ -0,0 +1,16 @@
+import { VoltageLevelInfos } from '../../../../../utils/types/equipmentType';
+import { ModelVariable } from '../common/curve.type';
+import { DynamicSimulationModelInfos } from '../../../../../utils/types/dynamic-simulation.type';
+import { ExpertFilter, IdentifiableAttributes } from '../../../../filter/filter.type';
+export type CurveSelectorApi = {
+    getSelectedEquipments: () => IdentifiableAttributes[];
+    getSelectedVariables: () => ModelVariable[];
+};
+type CurveSelectorProps = {
+    voltageLevelsFetcher?: () => Promise<VoltageLevelInfos[]>;
+    countriesFetcher?: () => Promise<string[]>;
+    evaluateFilterFetcher?: (filter: ExpertFilter) => Promise<IdentifiableAttributes[]>;
+    modelsFetcher?: () => Promise<DynamicSimulationModelInfos[]> | undefined;
+};
+declare const CurveSelector: import('react').ForwardRefExoticComponent<Readonly<CurveSelectorProps> & import('react').RefAttributes<CurveSelectorApi>>;
+export default CurveSelector;

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

@@ -0,0 +1,96 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { Grid, Typography } from "@mui/material";
+import { FormattedMessage } from "react-intl";
+import { forwardRef, useRef, useState, useCallback, useImperativeHandle } from "react";
+import { getReferencedEquipmentTypeForModel } from "./curve-selector-utils.js";
+import ModelFilter from "./model-filter.js";
+import EquipmentFilter from "./equipment-filter.js";
+import { EquipmentType } from "../../../../../utils/types/equipmentType.js";
+const styles = {
+  h6: (theme) => ({
+    marginBottom: theme.spacing(2),
+    marginLeft: theme.spacing(1)
+  })
+};
+const CurveSelector = forwardRef(
+  ({ voltageLevelsFetcher, countriesFetcher, evaluateFilterFetcher, modelsFetcher }, ref) => {
+    const equipmentFilterRef = useRef(null);
+    const modelFilterRef = useRef(null);
+    const [equipmentType, setEquipmentType] = useState(EquipmentType.GENERATOR);
+    const handleChangeEquipmentType = useCallback((newEquipmentType) => {
+      setEquipmentType(newEquipmentType);
+    }, []);
+    useImperativeHandle(
+      ref,
+      () => ({
+        getSelectedEquipments: () => {
+          if (!equipmentFilterRef.current) {
+            return [];
+          }
+          return equipmentFilterRef.current.getSelectedEquipments();
+        },
+        getSelectedVariables: () => {
+          if (!modelFilterRef.current) {
+            return [];
+          }
+          return modelFilterRef.current.getSelectedVariables();
+        }
+      }),
+      []
+    );
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(
+        Grid,
+        {
+          item: true,
+          container: true,
+          xs: 6,
+          direction: "column",
+          alignItems: "flex-start",
+          justifyContent: "flex-start",
+          spacing: 1,
+          children: [
+            /* @__PURE__ */ jsx(Typography, { sx: styles.h6, variant: "h6", children: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurveEquipmentFilter" }) }),
+            /* @__PURE__ */ jsx(
+              EquipmentFilter,
+              {
+                ref: equipmentFilterRef,
+                equipmentType,
+                onChangeEquipmentType: handleChangeEquipmentType,
+                voltageLevelsFetcher,
+                countriesFetcher,
+                evaluateFilterFetcher
+              }
+            )
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        Grid,
+        {
+          item: true,
+          container: true,
+          xs: 6,
+          direction: "column",
+          alignItems: "flex-start",
+          justifyContent: "flex-start",
+          spacing: 1,
+          children: [
+            /* @__PURE__ */ jsx(Typography, { sx: styles.h6, variant: "h6", children: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurveCurveFilter" }) }),
+            /* @__PURE__ */ jsx(
+              ModelFilter,
+              {
+                ref: modelFilterRef,
+                equipmentType: getReferencedEquipmentTypeForModel(equipmentType),
+                modelsFetcher
+              }
+            )
+          ]
+        }
+      )
+    ] });
+  }
+);
+export {
+  CurveSelector as default
+};

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

@@ -0,0 +1,14 @@
+import { EquipmentType, VoltageLevelInfos } from '../../../../../utils/types/equipmentType';
+import { ExpertFilter, IdentifiableAttributes } from '../../../../filter';
+export type EquipmentFilterApi = {
+    getSelectedEquipments: () => IdentifiableAttributes[];
+};
+type EquipmentFilterProps = {
+    equipmentType: EquipmentType;
+    onChangeEquipmentType: (newEquipmentType: EquipmentType) => void;
+    voltageLevelsFetcher?: () => Promise<VoltageLevelInfos[]>;
+    countriesFetcher?: () => Promise<string[]>;
+    evaluateFilterFetcher?: (filter: ExpertFilter) => Promise<IdentifiableAttributes[]>;
+};
+declare const EquipmentFilter: import('react').ForwardRefExoticComponent<EquipmentFilterProps & import('react').RefAttributes<EquipmentFilterApi>>;
+export default EquipmentFilter;

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

@@ -0,0 +1,239 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { Grid, Typography, Select, MenuItem, Box } from "@mui/material";
+import { useIntl, FormattedMessage } from "react-intl";
+import { forwardRef, useState, useRef, useCallback, useEffect, useMemo, useImperativeHandle } from "react";
+import { buildExpertFilter, CURVE_EQUIPMENT_TYPES, NOMINAL_VOLTAGE_UNIT } from "./curve-selector-utils.js";
+import { AGGRID_LOCALES } from "../../../../../translations/not-intl/aggrid-locales.js";
+import { useLocalizedCountries } from "../../../../../hooks/useLocalizedCountries.js";
+import { CheckboxAutocomplete } from "../../../../inputs/checkbox-autocomplete/checkbox-autocomplete.js";
+import { CustomAGGrid } from "../../../../customAGGrid/customAggrid.js";
+import "../../../../../utils/conversionUtils.js";
+import { snackWithFallback } from "../../../../../utils/error.js";
+import "../../../../../utils/types/equipmentType.js";
+import "@mui/icons-material";
+import "../../../../../utils/yupConfig.js";
+import { useSnackMessage } from "../../../../../hooks/useSnackMessage.js";
+const styles = {
+  grid: {
+    width: "100%",
+    height: "100%"
+  },
+  criteria: {
+    width: "100%",
+    height: "56px"
+  },
+  equipment: {
+    width: "100%",
+    flexGrow: 1
+  },
+  equipmentTitle: (theme) => ({
+    marginBottom: theme.spacing(1)
+  })
+};
+const EquipmentFilter = forwardRef(
+  ({
+    equipmentType: initialEquipmentType,
+    onChangeEquipmentType,
+    voltageLevelsFetcher,
+    countriesFetcher,
+    evaluateFilterFetcher
+  }, ref) => {
+    const { snackError } = useSnackMessage();
+    const [gridReady, setGridReady] = useState(false);
+    const [isFetching, setIsFetching] = useState();
+    const intl = useIntl();
+    const [equipmentRowData, setEquipmentRowData] = useState();
+    const equipmentsRef = useRef(null);
+    const [equipmentType, setEquipmentType] = useState(initialEquipmentType);
+    const handleEquipmentTypeChange = useCallback(
+      (event) => {
+        const selectedEquipmentType = event.target.value;
+        setEquipmentType(selectedEquipmentType);
+        onChangeEquipmentType(selectedEquipmentType);
+      },
+      [onChangeEquipmentType]
+    );
+    const [voltageLevelsMap, setVoltageLevelsMap] = useState(/* @__PURE__ */ new Map());
+    const [voltageLevelIds, setVoltageLevelIds] = useState([]);
+    const [selectedVoltageLevelIds, setSelectedVoltageLevelIds] = useState([]);
+    const [nominalVoltages, setNominalVoltages] = useState([]);
+    const [selectedNominalVoltages, setSelectedNominalVoltages] = useState([]);
+    const [countries, setCountries] = useState([]);
+    const [selectedCountries, setSelectedCountries] = useState([]);
+    const { translate } = useLocalizedCountries(intl.locale);
+    useEffect(() => {
+      voltageLevelsFetcher?.().then((voltageLevels) => {
+        const vlMap = /* @__PURE__ */ new Map();
+        const nvSet = /* @__PURE__ */ new Set();
+        voltageLevels.forEach((vl) => {
+          vlMap.set(vl.id, vl.name);
+          nvSet.add(vl.nominalV);
+        });
+        setVoltageLevelsMap(vlMap);
+        setNominalVoltages([...nvSet.values()].sort((nv1, nv2) => nv1 - nv2));
+        setVoltageLevelIds([...vlMap.keys()]);
+      }).catch((error) => {
+        snackWithFallback(snackError, error, { headerId: "FetchVoltageLevelsError" });
+      });
+      countriesFetcher?.().then((countryCodes) => setCountries(countryCodes)).catch((error) => {
+        snackWithFallback(snackError, error, { headerId: "FetchCountryError" });
+      });
+    }, [voltageLevelsFetcher, countriesFetcher, snackError]);
+    const expertFilter = useMemo(() => {
+      return buildExpertFilter(
+        equipmentType,
+        selectedVoltageLevelIds,
+        selectedCountries,
+        selectedNominalVoltages
+      );
+    }, [equipmentType, selectedVoltageLevelIds, selectedCountries, selectedNominalVoltages]);
+    const [selectedRowsLength, setSelectedRowsLength] = useState(0);
+    useEffect(() => {
+      let ignore = false;
+      if (gridReady && evaluateFilterFetcher) {
+        setIsFetching(true);
+        setEquipmentRowData([]);
+        setSelectedRowsLength(0);
+        evaluateFilterFetcher(expertFilter).then((equipments) => {
+          if (!ignore) {
+            setEquipmentRowData(equipments);
+          }
+        }).catch((error) => {
+          if (!ignore) {
+            snackWithFallback(snackError, error, { headerId: "FilterEvaluationError" });
+          }
+        }).finally(() => {
+          if (!ignore) {
+            setIsFetching(false);
+          }
+        });
+      }
+      return () => {
+        ignore = true;
+      };
+    }, [evaluateFilterFetcher, expertFilter, gridReady, snackError]);
+    const columnDefs = useMemo(() => {
+      return [
+        {
+          field: "id",
+          checkboxSelection: true,
+          headerCheckboxSelection: true,
+          headerCheckboxSelectionFilteredOnly: true,
+          minWidth: 80,
+          headerName: intl.formatMessage({
+            id: "DynamicSimulationCurveDynamicModelHeader"
+          })
+        }
+      ];
+    }, [intl]);
+    const defaultColDef = useMemo(() => {
+      return {
+        flex: 1,
+        minWidth: 100,
+        filter: true,
+        sortable: true,
+        resizable: true,
+        lockPinned: true,
+        wrapHeaderText: true,
+        autoHeaderHeight: true
+      };
+    }, []);
+    const onGridReady = useCallback(() => {
+      setGridReady(true);
+    }, []);
+    const handleEquipmentSelectionChanged = useCallback(() => {
+      const selectedRows = equipmentsRef.current?.api.getSelectedRows();
+      setSelectedRowsLength(selectedRows?.length ?? 0);
+    }, []);
+    useImperativeHandle(
+      ref,
+      () => ({
+        getSelectedEquipments: () => {
+          return equipmentsRef.current?.api.getSelectedRows() ?? [];
+        }
+      }),
+      []
+    );
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(Grid, { item: true, container: true, sx: styles.criteria, children: [
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: 4, children: /* @__PURE__ */ jsx(Typography, { children: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurveEquipmentType" }) }) }),
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: 8, children: /* @__PURE__ */ jsx(
+          Select,
+          {
+            labelId: "DynamicSimulationCurveEquipmentType",
+            value: equipmentType,
+            onChange: handleEquipmentTypeChange,
+            size: "small",
+            sx: { width: "100%" },
+            children: CURVE_EQUIPMENT_TYPES.map((type) => /* @__PURE__ */ jsx(MenuItem, { value: type, children: intl.formatMessage({ id: type }) }, type))
+          }
+        ) })
+      ] }),
+      /* @__PURE__ */ jsxs(Grid, { item: true, container: true, sx: styles.criteria, children: [
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: 4, children: /* @__PURE__ */ jsx(Typography, { children: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurvePost" }) }) }),
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: 8, children: /* @__PURE__ */ jsx(
+          CheckboxAutocomplete,
+          {
+            id: "voltage-level",
+            virtualize: true,
+            maxSelection: 10,
+            options: voltageLevelIds,
+            value: selectedVoltageLevelIds,
+            getOptionLabel: (value) => voltageLevelsMap.get(value) ?? value,
+            onChange: setSelectedVoltageLevelIds
+          }
+        ) })
+      ] }),
+      /* @__PURE__ */ jsxs(Grid, { item: true, container: true, sx: styles.criteria, children: [
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: 4, children: /* @__PURE__ */ jsx(Typography, { children: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurveCountry" }) }) }),
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: 8, children: /* @__PURE__ */ jsx(
+          CheckboxAutocomplete,
+          {
+            id: "country",
+            options: countries,
+            value: selectedCountries,
+            getOptionLabel: (value) => translate(value),
+            onChange: setSelectedCountries
+          }
+        ) })
+      ] }),
+      /* @__PURE__ */ jsxs(Grid, { item: true, container: true, sx: styles.criteria, children: [
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: 4, children: /* @__PURE__ */ jsx(Typography, { children: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurveTension" }) }) }),
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: 8, children: /* @__PURE__ */ jsx(
+          CheckboxAutocomplete,
+          {
+            id: "nominal-voltage",
+            options: nominalVoltages,
+            value: selectedNominalVoltages,
+            getOptionLabel: (value) => `${value} ${NOMINAL_VOLTAGE_UNIT}`,
+            onChange: setSelectedNominalVoltages
+          }
+        ) })
+      ] }),
+      /* @__PURE__ */ jsxs(Grid, { item: true, container: true, sx: styles.equipment, direction: "column", children: [
+        /* @__PURE__ */ jsx(Grid, { item: true, children: /* @__PURE__ */ jsxs(Typography, { sx: styles.equipmentTitle, variant: "subtitle1", children: [
+          /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurveEquipment" }),
+          ` (${selectedRowsLength} / ${equipmentRowData?.length ?? 0})`
+        ] }) }),
+        /* @__PURE__ */ jsx(Grid, { item: true, xs: true, children: /* @__PURE__ */ jsx(Box, { sx: styles.grid, children: /* @__PURE__ */ jsx(
+          CustomAGGrid,
+          {
+            ref: equipmentsRef,
+            rowData: equipmentRowData,
+            columnDefs,
+            defaultColDef,
+            rowSelection: "multiple",
+            onGridReady,
+            onSelectionChanged: handleEquipmentSelectionChanged,
+            loading: isFetching,
+            overlayLoadingTemplate: intl.formatMessage({ id: "LoadingRemoteData" }),
+            overrideLocales: AGGRID_LOCALES
+          }
+        ) }) })
+      ] })
+    ] });
+  }
+);
+export {
+  EquipmentFilter as default
+};

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

@@ -0,0 +1,3 @@
+import { ModelVariable } from '../common/curve.type';
+import { DynamicSimulationModelInfos } from '../../../../../utils/types/dynamic-simulation.type';
+export declare function modelsToVariables(models: DynamicSimulationModelInfos[]): ModelVariable[];