@gridsuite/commons-ui 0.192.0 → 0.193.0

package/dist/components/parameters/dynamic-security-analysis/dynamic-security-analysis.type.js

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

package/dist/components/parameters/dynamic-security-analysis/scenario-parameters.js

@@ -1,15 +1,24 @@
 import { jsx } from "react/jsx-runtime";
 import { Grid } from "@mui/material";
-import { TYPES, makeComponents } from "../util/make-component-utils.js";
 import { SCENARIO_DURATION } from "./constants.js";
-const defParams = {
-  [SCENARIO_DURATION]: {
-    type: TYPES.FLOAT,
+import "../../../utils/conversionUtils.js";
+import "../../../utils/types/equipmentType.js";
+import { ParameterType } from "../../../utils/types/parameters.type.js";
+import "@mui/icons-material";
+import "../../../utils/yupConfig.js";
+import ParameterField from "../common/parameter-field.js";
+const params = [
+  {
+    name: SCENARIO_DURATION,
+    type: ParameterType.DOUBLE,
     label: "DynamicSecurityAnalysisScenarioDuration"
   }
-};
+];
 function ScenarioParameters({ path }) {
-  return /* @__PURE__ */ jsx(Grid, { xl: 8, container: true, children: makeComponents(defParams, 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 {
   ScenarioParameters as default

package/dist/components/parameters/dynamic-security-analysis/use-dynamic-security-analysis-parameters-form.d.ts

@@ -2,10 +2,6 @@ import { FieldValues } from 'react-hook-form';
 import { default as yup } from '../../../utils/yupConfig';
 import { DynamicSecurityAnalysisParametersFetchReturn, DynamicSecurityAnalysisParametersInfos } from '../../../utils';
 import { UseComputationParametersFormReturn } from '../common/utils';
-export declare enum TabValues {
-    SCENARIO = "scenario",
-    CONTINGENCY = "contingency"
-}
 export declare const formSchema: yup.ObjectSchema<{
     provider: string;
     scenario: {
@@ -40,12 +36,11 @@ export declare const emptyFormData: {
 };
 export declare const toFormValues: (_params: DynamicSecurityAnalysisParametersFetchReturn) => FieldValues;
 export declare const toParamsInfos: (_formData: FieldValues) => DynamicSecurityAnalysisParametersFetchReturn;
-export type UseDynamicSecurityAnalysisParametersFormReturn = UseComputationParametersFormReturn<TabValues>;
 type UseDynamicSecurityAnalysisParametersFormProps = {
     providers: Record<string, string>;
     params: DynamicSecurityAnalysisParametersInfos | null;
     name: string | null;
     description: string | null;
 };
-export declare function useDynamicSecurityAnalysisParametersForm({ providers, params, name: initialName, description: initialDescription, }: Readonly<UseDynamicSecurityAnalysisParametersFormProps>): UseDynamicSecurityAnalysisParametersFormReturn;
+export declare function useDynamicSecurityAnalysisParametersForm(props: Readonly<UseDynamicSecurityAnalysisParametersFormProps>): UseComputationParametersFormReturn;
 export {};

package/dist/components/parameters/dynamic-security-analysis/use-dynamic-security-analysis-parameters-form.js

@@ -1,6 +1,3 @@
-import { useForm } from "react-hook-form";
-import { useMemo, useEffect } from "react";
-import { yupResolver } from "@hookform/resolvers/yup";
 import "../../../utils/yupConfig.js";
 import { ID } from "../../../utils/constants/filterConstant.js";
 import "../../../utils/conversionUtils.js";
@@ -10,10 +7,12 @@ import "@mui/icons-material";
 import { PROVIDER } from "../common/constants.js";
 import "@mui/material";
 import "react-intl";
+import "react";
 import "localized-countries";
 import "localized-countries/data/fr";
 import "localized-countries/data/en";
 import "notistack";
+import "react-hook-form";
 import "../../inputs/reactHookForm/provider/CustomFormProvider.js";
 import "../../dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
 import "../../dialogs/elementSaveDialog/ElementSaveDialog.js";
@@ -41,15 +40,9 @@ import "react-querybuilder";
 import "../common/widget/parameter-line-slider.js";
 import "../common/limitreductions/columns-definitions.js";
 import "../common/contingency-table/columns-definitions.js";
-import "../../filter/HeaderFilterForm.js";
-import { getNameElementEditorSchema, getNameElementEditorEmptyFormData } from "../common/name-element-editor/name-element-editor-utils.js";
+import { useParametersForm } from "../common/hook/use-parameters-form.js";
 import { SCENARIO_DURATION, CONTINGENCIES_LIST_INFOS, CONTINGENCIES_START_TIME } from "./constants.js";
-import { useTabs } from "../common/utils.js";
-var TabValues = /* @__PURE__ */ ((TabValues2) => {
-  TabValues2["SCENARIO"] = "scenario";
-  TabValues2["CONTINGENCY"] = "contingency";
-  return TabValues2;
-})(TabValues || {});
+import { TabValues } from "./dynamic-security-analysis.type.js";
 const scenarioFormSchema = yup.object().shape({
   [SCENARIO_DURATION]: yup.number().required()
 }).required();
@@ -64,14 +57,8 @@ const contingencyFormSchema = yup.object().shape({
 });
 const formSchema = yup.object().shape({
   [PROVIDER]: yup.string().required(),
-  [
-    "scenario"
-    /* SCENARIO */
-  ]: scenarioFormSchema,
-  [
-    "contingency"
-    /* CONTINGENCY */
-  ]: contingencyFormSchema
+  [TabValues.SCENARIO]: scenarioFormSchema,
+  [TabValues.CONTINGENCY]: contingencyFormSchema
 });
 const scenarioEmptyFormData = {
   [SCENARIO_DURATION]: 0
@@ -82,98 +69,34 @@ const contingencyEmptyFormData = {
 };
 const emptyFormData = {
   [PROVIDER]: "",
-  [
-    "scenario"
-    /* SCENARIO */
-  ]: { ...scenarioEmptyFormData },
-  [
-    "contingency"
-    /* CONTINGENCY */
-  ]: { ...contingencyEmptyFormData }
+  [TabValues.SCENARIO]: { ...scenarioEmptyFormData },
+  [TabValues.CONTINGENCY]: { ...contingencyEmptyFormData }
 };
 const toFormValues = (_params) => ({
   [PROVIDER]: _params.provider,
-  [
-    "scenario"
-    /* SCENARIO */
-  ]: {
+  [TabValues.SCENARIO]: {
     [SCENARIO_DURATION]: _params.scenarioDuration
   },
-  [
-    "contingency"
-    /* CONTINGENCY */
-  ]: {
+  [TabValues.CONTINGENCY]: {
     [CONTINGENCIES_START_TIME]: _params.contingenciesStartTime,
     [CONTINGENCIES_LIST_INFOS]: _params.contingencyListInfos
   }
 });
 const toParamsInfos = (_formData) => ({
   provider: _formData[PROVIDER],
-  scenarioDuration: _formData[
-    "scenario"
-    /* SCENARIO */
-  ][SCENARIO_DURATION],
-  contingenciesStartTime: _formData[
-    "contingency"
-    /* CONTINGENCY */
-  ][CONTINGENCIES_START_TIME],
-  contingencyListInfos: _formData[
-    "contingency"
-    /* CONTINGENCY */
-  ][CONTINGENCIES_LIST_INFOS]
+  scenarioDuration: _formData[TabValues.SCENARIO][SCENARIO_DURATION],
+  contingenciesStartTime: _formData[TabValues.CONTINGENCY][CONTINGENCIES_START_TIME],
+  contingencyListInfos: _formData[TabValues.CONTINGENCY][CONTINGENCIES_LIST_INFOS]
 });
-function useDynamicSecurityAnalysisParametersForm({
-  providers,
-  params,
-  name: initialName,
-  description: initialDescription
-}) {
-  const paramsLoaded = useMemo(() => !!params, [params]);
-  const formattedProviders = useMemo(
-    () => Object.entries(providers).map(([key, value]) => ({
-      id: key,
-      label: value
-    })),
-    [providers]
-  );
-  const returnFormSchema = useMemo(() => {
-    return initialName === null ? formSchema : formSchema.concat(getNameElementEditorSchema(initialName));
-  }, [initialName]);
-  const newEmptyFormData = useMemo(() => {
-    return {
-      ...initialName === null ? {} : getNameElementEditorEmptyFormData(initialName, initialDescription),
-      ...emptyFormData
-    };
-  }, [initialName, initialDescription]);
-  const returnFormMethods = useForm({
-    defaultValues: newEmptyFormData,
-    resolver: yupResolver(returnFormSchema)
+function useDynamicSecurityAnalysisParametersForm(props) {
+  return useParametersForm({
+    ...props,
+    formSchema,
+    emptyFormData,
+    toFormValues
   });
-  const { reset } = returnFormMethods;
-  useEffect(() => {
-    if (params) {
-      console.log("xxx Resetting form with params:", params);
-      reset(toFormValues(params));
-    }
-  }, [params, paramsLoaded, reset]);
-  const { selectedTab, tabsWithError, onTabChange, onError } = useTabs({
-    defaultTab: "scenario",
-    tabEnum: TabValues
-  });
-  return {
-    formMethods: returnFormMethods,
-    formSchema: returnFormSchema,
-    paramsLoaded,
-    formattedProviders,
-    /* tab-related handling */
-    selectedTab,
-    tabsWithError,
-    onTabChange,
-    onError
-  };
 }
 export {
-  TabValues,
   emptyFormData,
   formSchema,
   toFormValues,

package/dist/components/parameters/dynamic-simulation/curve/common/checkbox-select.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2023, 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/.
+ */
+interface CheckBoxSelectProps {
+    options: string[];
+    getOptionLabel: (label: string) => string;
+    onChange: (newSelectedOption: string[]) => void;
+    value: string[];
+    disabled: boolean;
+}
+declare function CheckboxSelect({ options, getOptionLabel, onChange, value: initialSelectedOptions, disabled, }: Readonly<CheckBoxSelectProps>): import("react/jsx-runtime").JSX.Element;
+export default CheckboxSelect;

package/dist/components/parameters/dynamic-simulation/curve/common/checkbox-select.js

@@ -0,0 +1,83 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { Select, MenuItem, ListItemText, Checkbox } from "@mui/material";
+import { useState, useCallback } from "react";
+import { useIntl } from "react-intl";
+const ITEM_HEIGHT = 48;
+const ITEM_PADDING_TOP = 8;
+const MenuProps = {
+  PaperProps: {
+    style: {
+      maxHeight: ITEM_HEIGHT * 4.5 + ITEM_PADDING_TOP,
+      maxWidth: "200"
+    }
+  }
+};
+const CHECK_ALL = { label: "SelectAll", value: "check_all" };
+const UNCHECK_ALL = { label: "UnselectAll", value: "uncheck_all" };
+function CheckboxSelect({
+  options,
+  getOptionLabel,
+  onChange,
+  value: initialSelectedOptions,
+  disabled
+}) {
+  const intl = useIntl();
+  const [selectedOptions, setSelectedOptions] = useState(initialSelectedOptions ?? []);
+  const [prevInitialSelectedOptions, setPrevInitialSelectedOptions] = useState(initialSelectedOptions);
+  if (initialSelectedOptions !== prevInitialSelectedOptions) {
+    setPrevInitialSelectedOptions(initialSelectedOptions);
+    setSelectedOptions(initialSelectedOptions);
+  }
+  const handleChange = useCallback(
+    (event) => {
+      const {
+        target: { value: eventValue }
+      } = event;
+      const values = Array.isArray(eventValue) ? eventValue : [eventValue];
+      let newSelectedOptions;
+      if (values.includes(CHECK_ALL.value)) {
+        newSelectedOptions = options;
+      } else if (values.includes(UNCHECK_ALL.value)) {
+        newSelectedOptions = [];
+      } else {
+        newSelectedOptions = values;
+      }
+      setSelectedOptions(newSelectedOptions);
+      onChange?.(newSelectedOptions);
+    },
+    [options, onChange]
+  );
+  return /* @__PURE__ */ jsxs(
+    Select,
+    {
+      id: "multiple-checkbox",
+      size: "small",
+      multiple: true,
+      value: selectedOptions,
+      onChange: handleChange,
+      renderValue: (_selectedOptions) => {
+        if (_selectedOptions.length === 1) {
+          return getOptionLabel(_selectedOptions[0]);
+        }
+        if (_selectedOptions.length > 1) {
+          return `${getOptionLabel(_selectedOptions.at(-1) ?? "")} (+${_selectedOptions.length - 1})`;
+        }
+        return "";
+      },
+      MenuProps,
+      sx: { width: "100%" },
+      disabled,
+      children: [
+        /* @__PURE__ */ jsx(MenuItem, { value: CHECK_ALL.value, children: /* @__PURE__ */ jsx(ListItemText, { primary: intl.formatMessage({ id: CHECK_ALL.label }) }) }, CHECK_ALL.value),
+        /* @__PURE__ */ jsx(MenuItem, { value: UNCHECK_ALL.value, children: /* @__PURE__ */ jsx(ListItemText, { primary: intl.formatMessage({ id: UNCHECK_ALL.label }) }) }, UNCHECK_ALL.value),
+        options.map((option) => /* @__PURE__ */ jsxs(MenuItem, { value: option, children: [
+          /* @__PURE__ */ jsx(Checkbox, { checked: selectedOptions.includes(option) }),
+          /* @__PURE__ */ jsx(ListItemText, { children: getOptionLabel(option) })
+        ] }, option))
+      ]
+    }
+  );
+}
+export {
+  CheckboxSelect as default
+};

package/dist/components/parameters/dynamic-simulation/curve/common/checkbox-treeview.d.ts

@@ -0,0 +1,22 @@
+import { Ref } from 'react';
+import { SxProps } from '@mui/material';
+export type ItemData = {
+    id: string;
+    parentId?: string;
+    name?: string;
+};
+export type CheckboxTreeviewApi<TData extends ItemData = ItemData> = {
+    getSelectedItems: () => TData[];
+};
+type CheckBoxTreeViewProps<TData extends ItemData = ItemData> = {
+    data: TData[];
+    checkAll: boolean;
+    onSelectionChanged?: (newSelection: TData[]) => void;
+    getLabel: (element: TData) => string;
+    sx?: SxProps;
+};
+declare function CheckboxTreeview<TData extends ItemData>({ data: items, checkAll, onSelectionChanged, getLabel, sx }: Readonly<CheckBoxTreeViewProps<TData>>, ref: Ref<CheckboxTreeviewApi<TData>>): import("react/jsx-runtime").JSX.Element;
+declare const _default: <TData extends ItemData>(props: CheckBoxTreeViewProps<TData> & {
+    ref?: Ref<CheckboxTreeviewApi<TData>>;
+}) => ReturnType<typeof CheckboxTreeview>;
+export default _default;

package/dist/components/parameters/dynamic-simulation/curve/common/checkbox-treeview.js

@@ -0,0 +1,163 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { forwardRef, useMemo, useState, useEffect, useCallback, useImperativeHandle } from "react";
+import { styled, alpha, useTheme, Checkbox } from "@mui/material";
+import { TreeItem, treeItemClasses, SimpleTreeView } from "@mui/x-tree-view";
+const BorderedTreeItem = styled(TreeItem)(({ theme, root }) => {
+  const border = `1px dashed ${alpha(theme.palette.text.primary, 0.4)}`;
+  return {
+    position: "relative",
+    "&:before": {
+      pointerEvents: "none",
+      content: '""',
+      position: "absolute",
+      width: 16,
+      left: -16,
+      top: 20,
+      borderBottom: root ? "none" : border
+    },
+    [`& .${treeItemClasses.groupTransition}`]: {
+      marginLeft: 15,
+      paddingLeft: 18,
+      borderLeft: border
+    },
+    [`& .${treeItemClasses.content}`]: {
+      paddingLeft: 8,
+      width: "max-content"
+    },
+    [`& .${treeItemClasses.label}`]: {
+      whiteSpace: "nowrap"
+    }
+  };
+});
+function CheckboxTreeview({ data: items, checkAll, onSelectionChanged, getLabel, sx }, ref) {
+  const theme = useTheme();
+  const initialItemStates = useMemo(
+    () => Object.fromEntries(items.map((elem) => [
+      elem.id,
+      checkAll ? "CHECKED" : "UNCHECKED"
+      /* UNCHECKED */
+    ])),
+    [items, checkAll]
+  );
+  const [itemStates, setItemStates] = useState(initialItemStates);
+  useEffect(() => {
+    setItemStates(initialItemStates);
+  }, [initialItemStates]);
+  const updateItemState = useCallback(
+    (_itemStates, _items, onClickedId) => {
+      const updateStateParent = (__itemStates, __items, childId) => {
+        const child = __items.find((elem) => elem.id === childId);
+        const parent = __items.find((elem) => elem.id === child?.parentId);
+        if (!parent) {
+          return;
+        }
+        const childrenIds = __items.filter((elem) => elem.parentId === parent.id).map((elem) => elem.id);
+        const childrenStates = childrenIds.map((id) => __itemStates[id]);
+        __itemStates[parent.id] = "INDETERMINATE";
+        if (childrenStates.every(
+          (state) => state === "CHECKED"
+          /* CHECKED */
+        )) {
+          __itemStates[parent.id] = "CHECKED";
+        }
+        if (childrenStates.every(
+          (state) => state === "UNCHECKED"
+          /* UNCHECKED */
+        )) {
+          __itemStates[parent.id] = "UNCHECKED";
+        }
+        updateStateParent(__itemStates, __items, parent.id);
+      };
+      const setState = (__itemStates, __items, id, newState) => {
+        __itemStates[id] = newState;
+        const children = __items.filter((elem) => elem.parentId === id);
+        children.forEach((elem) => setState(__itemStates, __items, elem.id, newState));
+        updateStateParent(__itemStates, __items, id);
+      };
+      const newItemStates = { ..._itemStates };
+      const currentState = _itemStates[onClickedId];
+      setState(
+        newItemStates,
+        _items,
+        onClickedId,
+        currentState === "CHECKED" ? "UNCHECKED" : "CHECKED"
+        /* CHECKED */
+      );
+      return newItemStates;
+    },
+    []
+  );
+  const handleItemSelect = useCallback(
+    (event, id) => {
+      event.stopPropagation();
+      const newItemStates = updateItemState(itemStates, items, id);
+      setItemStates(newItemStates);
+      if (onSelectionChanged) {
+        const selectedItems = items.filter(
+          (item) => newItemStates[item.id] === "CHECKED" && items.every((elem) => elem.parentId !== item.id)
+          // no children
+        );
+        onSelectionChanged(selectedItems);
+      }
+    },
+    [itemStates, items, updateItemState, onSelectionChanged]
+  );
+  const handleExpand = useCallback((event) => {
+    event.stopPropagation();
+  }, []);
+  const getSelectedItems = useCallback(() => {
+    return items.filter(
+      (item) => itemStates[item.id] === "CHECKED" && !items.some((elem) => elem.parentId === item.id)
+      // no children
+    );
+  }, [items, itemStates]);
+  useImperativeHandle(
+    ref,
+    () => ({
+      getSelectedItems
+    }),
+    [getSelectedItems]
+  );
+  const itemsByParent = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    items.forEach((item) => {
+      const key = item.parentId ?? null;
+      if (!map.has(key)) map.set(key, []);
+      map.get(key)?.push(item);
+    });
+    return map;
+  }, [items]);
+  const renderTree = useCallback(
+    (parentId = null) => {
+      const itemsToRender = itemsByParent.get(parentId) ?? [];
+      return itemsToRender.map((elem) => /* @__PURE__ */ jsx(
+        BorderedTreeItem,
+        {
+          theme,
+          itemId: elem.id,
+          onClick: handleExpand,
+          root: !elem.parentId,
+          label: /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(
+              Checkbox,
+              {
+                checked: "CHECKED" === itemStates[elem.id],
+                indeterminate: "INDETERMINATE" === itemStates[elem.id],
+                onClick: (event) => handleItemSelect(event, elem.id)
+              }
+            ),
+            getLabel ? getLabel(elem) : elem.name
+          ] }),
+          children: renderTree(elem.id)
+        },
+        elem.id
+      ));
+    },
+    [itemsByParent, theme, handleExpand, itemStates, getLabel, handleItemSelect]
+  );
+  return /* @__PURE__ */ jsx(SimpleTreeView, { sx, children: renderTree(null) });
+}
+const CheckboxTreeview$1 = forwardRef(CheckboxTreeview);
+export {
+  CheckboxTreeview$1 as default
+};

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

@@ -0,0 +1,14 @@
+import { EquipmentType } from '../../../../../utils/types/equipmentType';
+import { ItemData } from './checkbox-treeview';
+export type DynamicSimulationModel = {
+    name: string;
+    equipmentType: EquipmentType;
+};
+export type ModelVariable = ItemData & {
+    variableId?: string;
+};
+export type Curve = {
+    equipmentType: EquipmentType;
+    equipmentId: string;
+    variableId?: string;
+};

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

@@ -0,0 +1 @@
+

package/dist/components/parameters/dynamic-simulation/curve/common/grid-buttons.d.ts

@@ -0,0 +1,8 @@
+interface GridButtonsProps {
+    onAddButton: () => void;
+    onDeleteButton: () => void;
+    disabledAdd?: boolean;
+    disabledDelete?: boolean;
+}
+export declare function GridButtons({ onAddButton, onDeleteButton, disabledAdd, disabledDelete }: Readonly<GridButtonsProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/parameters/dynamic-simulation/curve/common/grid-buttons.js

@@ -0,0 +1,39 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { Grid, Tooltip, IconButton } from "@mui/material";
+import { AddCircle, Delete } from "@mui/icons-material";
+import { useCallback } from "react";
+import { useIntl } from "react-intl";
+function GridButtons({ onAddButton, onDeleteButton, disabledAdd, disabledDelete }) {
+  const intl = useIntl();
+  const handleAddButton = useCallback(() => {
+    onAddButton();
+  }, [onAddButton]);
+  const handleDeleteButton = useCallback(() => {
+    onDeleteButton();
+  }, [onDeleteButton]);
+  return /* @__PURE__ */ jsxs(Grid, { container: true, item: true, xs: true, spacing: 1, sx: { justifyContent: "flex-end", alignItems: "flex-end" }, children: [
+    /* @__PURE__ */ jsx(Grid, { item: true, children: /* @__PURE__ */ jsx(
+      Tooltip,
+      {
+        title: intl.formatMessage({
+          id: "AddRows"
+        }),
+        placement: "top",
+        children: /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(IconButton, { color: "primary", onClick: () => handleAddButton(), disabled: disabledAdd, children: /* @__PURE__ */ jsx(AddCircle, {}) }) })
+      }
+    ) }),
+    /* @__PURE__ */ jsx(Grid, { item: true, children: /* @__PURE__ */ jsx(
+      Tooltip,
+      {
+        title: intl.formatMessage({
+          id: "DeleteRows"
+        }),
+        placement: "top",
+        children: /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(IconButton, { color: "primary", onClick: () => handleDeleteButton(), disabled: disabledDelete, children: /* @__PURE__ */ jsx(Delete, {}) }) })
+      }
+    ) })
+  ] });
+}
+export {
+  GridButtons
+};

package/dist/components/parameters/dynamic-simulation/curve/common/grid-search.d.ts

@@ -0,0 +1,8 @@
+import { RefObject } from 'react';
+import { AgGridReact } from 'ag-grid-react';
+interface GridSearchProps {
+    gridRef: RefObject<AgGridReact | null>;
+    disabled?: boolean;
+}
+export declare const GridSearch: import('react').ForwardRefExoticComponent<GridSearchProps & import('react').RefAttributes<unknown>>;
+export {};

package/dist/components/parameters/dynamic-simulation/curve/common/grid-search.js

@@ -0,0 +1,60 @@
+import { jsx } from "react/jsx-runtime";
+import { TextField, InputAdornment } from "@mui/material";
+import { useIntl } from "react-intl";
+import { forwardRef, useRef, useCallback, useImperativeHandle } from "react";
+import { Search } from "@mui/icons-material";
+const styles = {
+  searchSection: (theme) => ({
+    paddingRight: theme.spacing(1),
+    alignItems: "center"
+  })
+};
+const GridSearch = forwardRef(({ gridRef, disabled }, ref) => {
+  const intl = useIntl();
+  const inputRef = useRef(null);
+  const applyQuickFilter = useCallback(
+    (filterValue) => {
+      gridRef.current?.api?.setGridOption("quickFilterText", filterValue);
+    },
+    [gridRef]
+  );
+  const resetFilter = useCallback(() => {
+    inputRef.current.value = "";
+    applyQuickFilter("");
+  }, [applyQuickFilter]);
+  const getFilterValue = useCallback(() => {
+    return inputRef.current.value;
+  }, []);
+  useImperativeHandle(ref, () => {
+    return {
+      resetFilter,
+      getFilterValue
+    };
+  }, [getFilterValue, resetFilter]);
+  const handleChangeFilter = useCallback(
+    (event) => {
+      applyQuickFilter(event.target.value);
+    },
+    [applyQuickFilter]
+  );
+  return /* @__PURE__ */ jsx(
+    TextField,
+    {
+      disabled,
+      size: "small",
+      placeholder: `${intl.formatMessage({ id: "filter" })}...`,
+      onChange: handleChangeFilter,
+      inputRef,
+      fullWidth: true,
+      InputProps: {
+        sx: {
+          input: styles.searchSection
+        },
+        startAdornment: /* @__PURE__ */ jsx(InputAdornment, { position: "start", children: /* @__PURE__ */ jsx(Search, { color: disabled ? "disabled" : "inherit" }) })
+      }
+    }
+  );
+});
+export {
+  GridSearch
+};

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

@@ -0,0 +1,11 @@
+/**
+ * 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 Curve {
+    EQUIPMENT_ID = "equipmentId",
+    VARIABLE_ID = "variableId",
+    CURVES = "curves"
+}