@gridsuite/commons-ui 0.237.0 → 0.239.0

package/dist/components/composite/agGridTable/BottomTableButtons.d.ts

@@ -10,4 +10,4 @@ export interface BottomTableButtonsProps {
     handleMoveRowDown: () => void;
     csvProps?: CsvProps;
 }
-export declare function BottomTableButtons({ name, disableUp, disableDown, disableDelete, handleAddRow, handleDeleteRows, handleMoveRowUp, handleMoveRowDown, csvProps, }: BottomTableButtonsProps): import("react/jsx-runtime").JSX.Element;
+export declare function BottomTableButtons({ name, disableUp, disableDown, disableDelete, handleAddRow, handleDeleteRows, handleMoveRowUp, handleMoveRowDown, csvProps, }: BottomTableButtonsProps): import("react").JSX.Element;

package/dist/components/composite/agGridTable/CustomAgGridTable.js

@@ -10,6 +10,12 @@ import { hasNonEmptyRows } from "../../../utils/functions.js";
 import "@mui/icons-material";
 import { CustomAGGrid } from "../customAGGrid/customAggrid.js";
 import "react-intl";
+import "../customAGGrid/context/custom-aggrid-context.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "mathjs";
 const getDropIndicatorPosition = ({ overNode, y }) => {
   if (!overNode) {
     return null;
@@ -62,7 +68,7 @@ const style = (customProps) => ({
   })
 });
 const CustomAgGridTable = forwardRef(
-  function CustomAgGridTable2({ name, makeDefaultRowData, csvProps, cssProps, rowSelection, stopEditingWhenCellsLoseFocus = true, ...props }, ref) {
+  function CustomAgGridTableComponent({ name, makeDefaultRowData, csvProps, cssProps, rowSelection, stopEditingWhenCellsLoseFocus = true, ...props }, ref) {
     const theme = useTheme();
     const [gridApi, setGridApi] = useState(null);
     const [selectedRows, setSelectedRows] = useState([]);

package/dist/components/composite/agGridTable/cellEditors/numericEditor.d.ts

@@ -20,4 +20,4 @@ export declare const suppressNonNumericKeyboardEvent: (params: SuppressKeyboardE
  * Columns using this editor should also set `suppressKeyboardEvent: suppressNonNumericKeyboardEvent`
  * so that a non-numeric key on a focused cell doesn't start an edit.
  */
-export declare function NumericEditor({ value, onValueChange, eventKey }: CustomCellEditorProps): import("react/jsx-runtime").JSX.Element;
+export declare function NumericEditor({ value, onValueChange, eventKey }: CustomCellEditorProps): import("react").JSX.Element;

package/dist/components/composite/customAGGrid/cell-renderers.d.ts

@@ -1,15 +1,15 @@
 import { ReactNode } from 'react';
 import { ICellRendererParams } from 'ag-grid-community';
 import { CustomCellRendererProps } from 'ag-grid-react';
-export declare function BooleanCellRenderer({ value }: Readonly<any>): import("react/jsx-runtime").JSX.Element;
-export declare function BooleanNullableCellRenderer({ value }: Readonly<any>): import("react/jsx-runtime").JSX.Element;
+export declare function BooleanCellRenderer({ value }: Readonly<any>): import("react").JSX.Element;
+export declare function BooleanNullableCellRenderer({ value }: Readonly<any>): import("react").JSX.Element;
 export interface NumericCellRendererProps extends CustomCellRendererProps {
     fractionDigits?: number;
 }
-export declare function NumericCellRenderer({ value, fractionDigits }: Readonly<NumericCellRendererProps>): import("react/jsx-runtime").JSX.Element;
-export declare function ErrorCellRenderer({ value }: Readonly<CustomCellRendererProps>): import("react/jsx-runtime").JSX.Element;
-export declare function DefaultCellRenderer(props: Readonly<CustomCellRendererProps>): import("react/jsx-runtime").JSX.Element;
-export declare function NetworkModificationNameCellRenderer({ value }: Readonly<CustomCellRendererProps>): import("react/jsx-runtime").JSX.Element;
+export declare function NumericCellRenderer({ value, fractionDigits }: Readonly<NumericCellRendererProps>): import("react").JSX.Element;
+export declare function ErrorCellRenderer({ value }: Readonly<CustomCellRendererProps>): import("react").JSX.Element;
+export declare function DefaultCellRenderer(props: Readonly<CustomCellRendererProps>): import("react").JSX.Element;
+export declare function NetworkModificationNameCellRenderer({ value }: Readonly<CustomCellRendererProps>): import("react").JSX.Element;
 export declare function MessageLogCellRenderer({ param, highlightColor, currentHighlightColor, searchTerm, currentResultIndex, searchResults, }: Readonly<{
     param: ICellRendererParams;
     highlightColor?: string;
@@ -17,10 +17,10 @@ export declare function MessageLogCellRenderer({ param, highlightColor, currentH
     searchTerm?: string;
     currentResultIndex?: number;
     searchResults?: number[];
-}>): import("react/jsx-runtime").JSX.Element;
+}>): import("react").JSX.Element;
 export declare function ContingencyCellRenderer({ value, }: Readonly<{
     value: {
         cellValue: ReactNode;
         tooltipValue: ReactNode;
     };
-}>): import("react/jsx-runtime").JSX.Element | null;
+}>): import("react").JSX.Element | null;

package/dist/components/composite/customAGGrid/cell-renderers.js

@@ -1,5 +1,5 @@
 import { jsx } from "react/jsx-runtime";
-import { Checkbox, Box } from "@mui/material";
+import { Box, Checkbox } from "@mui/material";
 import { useRef, useState } from "react";
 import { useIntl } from "react-intl";
 import { CustomTooltip } from "../../ui/tooltip/CustomTooltip.js";

package/dist/components/composite/customAGGrid/context/custom-aggrid-context.d.ts

@@ -0,0 +1,13 @@
+import { FilterConfig, FilterParams, SortConfig, SortParams } from '../custom-aggrid-types';
+export interface CustomAggridSortContextValue {
+    getSortConfig: (sortParams: SortParams | undefined) => SortConfig[] | undefined;
+    setSortConfig: (sortParams: SortParams, updatedSortConfig: SortConfig[]) => void;
+}
+export declare const CustomAggridSortContext: import('react').Context<CustomAggridSortContextValue | null>;
+export declare const useCustomAggridSortContext: () => CustomAggridSortContextValue;
+export interface CustomAggridFilterContextValue {
+    getFilters: (params: Pick<FilterParams, 'type' | 'tab'>) => FilterConfig[];
+    updateFilter: (colId: string, filterParams: FilterParams, updatedFilters: FilterConfig[], colFilter: FilterConfig | undefined) => void;
+}
+export declare const CustomAggridFilterContext: import('react').Context<CustomAggridFilterContextValue | null>;
+export declare const useCustomAggridFilterContext: () => CustomAggridFilterContextValue;

package/dist/components/composite/customAGGrid/context/custom-aggrid-context.js

@@ -0,0 +1,23 @@
+import { createContext, useContext } from "react";
+const CustomAggridSortContext = createContext(null);
+const useCustomAggridSortContext = () => {
+  const ctx = useContext(CustomAggridSortContext);
+  if (!ctx) {
+    throw new Error("useCustomAggridSortContext must be used within a CustomAggridSortContext.Provider");
+  }
+  return ctx;
+};
+const CustomAggridFilterContext = createContext(null);
+const useCustomAggridFilterContext = () => {
+  const ctx = useContext(CustomAggridFilterContext);
+  if (!ctx) {
+    throw new Error("useCustomAggridFilterContext must be used within a CustomAggridFilterContext.Provider");
+  }
+  return ctx;
+};
+export {
+  CustomAggridFilterContext,
+  CustomAggridSortContext,
+  useCustomAggridFilterContext,
+  useCustomAggridSortContext
+};

package/dist/components/composite/customAGGrid/context/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 './custom-aggrid-context';

package/dist/components/composite/customAGGrid/context/index.js

@@ -0,0 +1,7 @@
+import { CustomAggridFilterContext, CustomAggridSortContext, useCustomAggridFilterContext, useCustomAggridSortContext } from "./custom-aggrid-context.js";
+export {
+  CustomAggridFilterContext,
+  CustomAggridSortContext,
+  useCustomAggridFilterContext,
+  useCustomAggridSortContext
+};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/custom-aggrid-autocomplete-filter.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { CustomAggridFilterParams } from '../custom-aggrid-types';
+export interface CustomAggridAutocompleteFilterParams extends CustomAggridFilterParams {
+    getOptionLabel?: (value: string) => string;
+    options?: string[];
+}
+export declare function CustomAggridAutocompleteFilter({ api, colId, filterParams, getOptionLabel, options, }: CustomAggridAutocompleteFilterParams): React.JSX.Element;

package/dist/components/composite/customAGGrid/custom-aggrid-filters/custom-aggrid-autocomplete-filter.js

@@ -0,0 +1,74 @@
+import { jsx } from "react/jsx-runtime";
+import { useState, useCallback, useEffect } from "react";
+import { Autocomplete, TextField } from "@mui/material";
+import { useIntl } from "react-intl";
+import { useCustomAggridColumnFilter } from "./hooks/use-custom-aggrid-column-filter.js";
+import "../../../../utils/conversionUtils.js";
+import "../../../../utils/types/equipmentType.js";
+import "@mui/icons-material";
+import { isNonEmptyStringOrArray } from "../../../../utils/ts-utils.js";
+import { FilterTextComparators } from "../custom-aggrid-types.js";
+function CustomAggridAutocompleteFilter({
+  api,
+  colId,
+  filterParams,
+  getOptionLabel,
+  options
+}) {
+  const intl = useIntl();
+  const { selectedFilterData, handleChangeFilterValue } = useCustomAggridColumnFilter(colId, filterParams);
+  const [computedFilterOptions, setComputedFilterOptions] = useState(options ?? []);
+  const getUniqueValues = useCallback(() => {
+    const uniqueValues = /* @__PURE__ */ new Set();
+    let allNumbers = true;
+    api.forEachNode((node) => {
+      const value = api.getCellValue({
+        rowNode: node,
+        colKey: colId
+      });
+      if (value !== void 0 && value !== null && value !== "") {
+        uniqueValues.add(value);
+        if (allNumbers && Number.isNaN(Number(value))) {
+          allNumbers = false;
+        }
+      }
+    });
+    if (allNumbers) {
+      return Array.from(uniqueValues).sort((a, b) => Number(a) - Number(b));
+    }
+    return Array.from(uniqueValues);
+  }, [api, colId]);
+  useEffect(() => {
+    if (!options) {
+      setComputedFilterOptions(getUniqueValues());
+    }
+  }, [options, getUniqueValues]);
+  const handleFilterAutoCompleteChange = (_, data) => {
+    handleChangeFilterValue({ value: data, type: FilterTextComparators.EQUALS });
+  };
+  return /* @__PURE__ */ jsx(
+    Autocomplete,
+    {
+      multiple: true,
+      value: Array.isArray(selectedFilterData) ? selectedFilterData : [],
+      options: computedFilterOptions,
+      getOptionLabel: (option) => String(getOptionLabel ? getOptionLabel(option) : option),
+      onChange: handleFilterAutoCompleteChange,
+      size: "small",
+      disableCloseOnSelect: true,
+      renderInput: (params) => /* @__PURE__ */ jsx(
+        TextField,
+        {
+          ...params,
+          placeholder: !isNonEmptyStringOrArray(selectedFilterData) ? intl.formatMessage({
+            id: "filter.filterOoo"
+          }) : ""
+        }
+      ),
+      fullWidth: true
+    }
+  );
+}
+export {
+  CustomAggridAutocompleteFilter
+};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/custom-aggrid-comparator-filter.d.ts

@@ -0,0 +1,2 @@
+import { CustomAggridFilterParams } from '../custom-aggrid-types';
+export declare function CustomAggridComparatorFilter({ colId, filterParams }: CustomAggridFilterParams): import("react").JSX.Element;

package/dist/components/composite/customAGGrid/custom-aggrid-filters/custom-aggrid-comparator-filter.js

@@ -0,0 +1,52 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { Grid, IconButton } from "@mui/material";
+import { Close } from "@mui/icons-material";
+import { CustomAggridComparatorSelector } from "./custom-aggrid-comparator-selector.js";
+import { CustomAggridTextFilter } from "./custom-aggrid-text-filter.js";
+import { FilterTextComparators } from "../custom-aggrid-types.js";
+import "react";
+import "../context/custom-aggrid-context.js";
+import "mathjs";
+import { useCustomAggridComparatorFilter } from "./hooks/use-custom-aggrid-comparator-filter.js";
+function CustomAggridComparatorFilter({ colId, filterParams }) {
+  const {
+    selectedFilterData,
+    selectedFilterComparator,
+    decimalAfterDot,
+    isNumberInput,
+    handleFilterComparatorChange,
+    handleFilterTextChange,
+    handleClearFilter
+  } = useCustomAggridComparatorFilter(colId, filterParams);
+  const {
+    comparators = []
+    // used for text filter as a UI type (examples: contains, startsWith..)
+  } = filterParams;
+  const isComparatorWithoutValue = selectedFilterComparator === FilterTextComparators.IS_EMPTY || selectedFilterComparator === FilterTextComparators.IS_NOT_EMPTY;
+  return /* @__PURE__ */ jsxs(Grid, { container: true, direction: "column", gap: 0.8, sx: { padding: "8px" }, children: [
+    /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: "4px" }, children: [
+      /* @__PURE__ */ jsx("div", { style: { flex: 1 }, children: /* @__PURE__ */ jsx(
+        CustomAggridComparatorSelector,
+        {
+          value: selectedFilterComparator,
+          onChange: handleFilterComparatorChange,
+          options: comparators
+        }
+      ) }),
+      isComparatorWithoutValue && selectedFilterData !== void 0 && /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: handleClearFilter, children: /* @__PURE__ */ jsx(Close, {}) })
+    ] }),
+    !isComparatorWithoutValue && /* @__PURE__ */ jsx(
+      CustomAggridTextFilter,
+      {
+        value: selectedFilterData,
+        onChange: handleFilterTextChange,
+        onClear: handleClearFilter,
+        isNumberInput,
+        decimalAfterDot
+      }
+    )
+  ] });
+}
+export {
+  CustomAggridComparatorFilter
+};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/custom-aggrid-comparator-selector.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { SelectChangeEvent } from '@mui/material';
+interface CustomAggridComparatorSelectorProps {
+    value: string;
+    onChange: (event: SelectChangeEvent) => void;
+    options: string[];
+}
+export declare function CustomAggridComparatorSelector({ value, onChange, options }: CustomAggridComparatorSelectorProps): React.JSX.Element;
+export {};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/custom-aggrid-comparator-selector.js

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { Select, MenuItem } from "@mui/material";
+import { useIntl } from "react-intl";
+const styles = {
+  input: {
+    minWidth: "250px",
+    maxWidth: "40%"
+  }
+};
+function CustomAggridComparatorSelector({ value, onChange, options }) {
+  const intl = useIntl();
+  return /* @__PURE__ */ jsx(Select, { value, onChange, displayEmpty: true, size: "small", sx: styles.input, children: options.map((filterComparator) => /* @__PURE__ */ jsx(MenuItem, { value: filterComparator, children: intl.formatMessage({
+    id: `filter.${filterComparator}`
+  }) }, filterComparator)) });
+}
+export {
+  CustomAggridComparatorSelector
+};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/custom-aggrid-filter.d.ts

@@ -0,0 +1,11 @@
+import { default as React, ComponentType } from 'react';
+import { CustomAggridFilterParams } from '../custom-aggrid-types';
+interface CustomAggridFilterWrapperParams<F extends CustomAggridFilterParams> {
+    filterComponent: ComponentType<F>;
+    filterComponentParams: F;
+    isHoveringColumnHeader: boolean;
+    forceDisplayFilterIcon: boolean;
+    handleCloseFilter: () => void;
+}
+export declare function CustomAggridFilter<F extends CustomAggridFilterParams>({ filterComponent: FilterComponent, filterComponentParams, isHoveringColumnHeader, forceDisplayFilterIcon, handleCloseFilter, }: CustomAggridFilterWrapperParams<F>): React.JSX.Element;
+export {};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/custom-aggrid-filter.js

@@ -0,0 +1,77 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { useState, useMemo } from "react";
+import { Popover } from "@mui/material";
+import { CustomFilterIcon } from "./custom-filter-icon.js";
+import { FilterTextComparators } from "../custom-aggrid-types.js";
+import { useCustomAggridColumnFilter } from "./hooks/use-custom-aggrid-column-filter.js";
+const styles = {
+  input: {
+    minWidth: "250px",
+    maxWidth: "40%"
+  },
+  autoCompleteInput: {
+    width: "30%"
+  }
+};
+function CustomAggridFilter({
+  filterComponent: FilterComponent,
+  filterComponentParams,
+  isHoveringColumnHeader,
+  forceDisplayFilterIcon = false,
+  handleCloseFilter
+}) {
+  const [filterAnchorElement, setFilterAnchorElement] = useState(null);
+  const { selectedFilterData, selectedFilterComparator } = useCustomAggridColumnFilter(
+    filterComponentParams.colId,
+    filterComponentParams.filterParams
+  );
+  const handleShowFilter = (event) => {
+    setFilterAnchorElement(event.currentTarget);
+  };
+  const onClose = () => {
+    handleCloseFilter();
+    setFilterAnchorElement(null);
+  };
+  const isFilterActive = (Array.isArray(selectedFilterData) ? selectedFilterData.length > 0 : !!selectedFilterData) || selectedFilterComparator === FilterTextComparators.IS_EMPTY || selectedFilterComparator === FilterTextComparators.IS_NOT_EMPTY;
+  const shouldDisplayFilterIcon = useMemo(
+    () => !!FilterComponent && isHoveringColumnHeader || isFilterActive || !!filterAnchorElement || forceDisplayFilterIcon,
+    [FilterComponent, filterAnchorElement, forceDisplayFilterIcon, isHoveringColumnHeader, isFilterActive]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    shouldDisplayFilterIcon && /* @__PURE__ */ jsx(
+      CustomFilterIcon,
+      {
+        selectedFilterData,
+        selectedFilterComparator,
+        handleShowFilter
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Popover,
+      {
+        id: `${filterComponentParams.colId}-filter-popover`,
+        open: !!filterAnchorElement,
+        anchorEl: filterAnchorElement,
+        onClose,
+        anchorOrigin: {
+          vertical: "bottom",
+          horizontal: "left"
+        },
+        transformOrigin: {
+          vertical: "top",
+          horizontal: "left"
+        },
+        slotProps: {
+          paper: {
+            // Test for specific parameter presence to apply a style
+            sx: styles[filterComponentParams?.options ? "autoCompleteInput" : "input"]
+          }
+        },
+        children: /* @__PURE__ */ jsx(FilterComponent, { ...filterComponentParams })
+      }
+    )
+  ] });
+}
+export {
+  CustomAggridFilter
+};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/custom-aggrid-text-filter.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface CustomAggridTextFilterProps {
+    value: unknown;
+    onChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    onClear: () => void;
+    isNumberInput: boolean;
+    decimalAfterDot: number;
+}
+export declare function CustomAggridTextFilter({ value, onChange, onClear, isNumberInput, decimalAfterDot, }: CustomAggridTextFilterProps): React.JSX.Element;
+export {};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/custom-aggrid-text-filter.js

@@ -0,0 +1,59 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { Grid, TextField, InputAdornment, IconButton } from "@mui/material";
+import { Clear } from "@mui/icons-material";
+import { useIntl } from "react-intl";
+import "../../../../utils/conversionUtils.js";
+import "../../../../utils/types/equipmentType.js";
+import { mergeSx } from "../../../../utils/styles.js";
+import { DisplayRounding } from "../display-rounding.js";
+import { FilterDataTypes } from "../custom-aggrid-types.js";
+const styles = {
+  input: {
+    minWidth: "250px",
+    maxWidth: "40%"
+  },
+  noArrows: {
+    "& input::-webkit-outer-spin-button, & input::-webkit-inner-spin-button": {
+      display: "none"
+    },
+    "& input[type=number]": {
+      MozAppearance: "textfield"
+    }
+  }
+};
+function CustomAggridTextFilter({
+  value,
+  onChange,
+  onClear,
+  isNumberInput,
+  decimalAfterDot = 0
+}) {
+  const intl = useIntl();
+  const isRoundingDisplayed = useMemo(() => !!(isNumberInput && value), [isNumberInput, value]);
+  return /* @__PURE__ */ jsxs(Grid, { container: true, direction: "column", gap: 0.2, children: [
+    /* @__PURE__ */ jsx(Grid, { item: true, children: /* @__PURE__ */ jsx(
+      TextField,
+      {
+        size: "small",
+        fullWidth: true,
+        value: value || "",
+        onChange,
+        placeholder: intl.formatMessage({
+          id: "filter.filterOoo"
+        }),
+        inputProps: {
+          type: isNumberInput ? FilterDataTypes.NUMBER : FilterDataTypes.TEXT
+        },
+        sx: mergeSx(styles.input, isNumberInput ? styles.noArrows : void 0),
+        InputProps: {
+          endAdornment: value ? /* @__PURE__ */ jsx(InputAdornment, { position: "end", children: /* @__PURE__ */ jsx(IconButton, { "aria-label": "clear filter", onClick: onClear, edge: "end", size: "small", children: /* @__PURE__ */ jsx(Clear, {}) }) }) : null
+        }
+      }
+    ) }),
+    isRoundingDisplayed && /* @__PURE__ */ jsx(Grid, { item: true, children: /* @__PURE__ */ jsx(DisplayRounding, { decimalAfterDot }) })
+  ] });
+}
+export {
+  CustomAggridTextFilter
+};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/custom-filter-icon.d.ts

@@ -0,0 +1,8 @@
+import { default as React, MouseEventHandler } from 'react';
+interface CustomFilterIconProps {
+    handleShowFilter: MouseEventHandler<HTMLButtonElement> | undefined;
+    selectedFilterData: unknown;
+    selectedFilterComparator?: string;
+}
+export declare function CustomFilterIcon({ handleShowFilter, selectedFilterData, selectedFilterComparator, }: CustomFilterIconProps): React.JSX.Element;
+export {};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/custom-filter-icon.js

@@ -0,0 +1,22 @@
+import { jsx } from "react/jsx-runtime";
+import { Grid, IconButton, Badge } from "@mui/material";
+import { FilterAlt } from "@mui/icons-material";
+import "../../../../utils/conversionUtils.js";
+import "../../../../utils/types/equipmentType.js";
+import { isNonEmptyStringOrArray } from "../../../../utils/ts-utils.js";
+import { FilterTextComparators } from "../custom-aggrid-types.js";
+const styles = {
+  iconSize: { fontSize: "1rem" },
+  gridRoot: { overflow: "visible" }
+};
+function CustomFilterIcon({
+  handleShowFilter,
+  selectedFilterData,
+  selectedFilterComparator
+}) {
+  const isFilterActive = selectedFilterData !== void 0 && selectedFilterData !== null && (isNonEmptyStringOrArray(selectedFilterData) || selectedFilterComparator === FilterTextComparators.IS_EMPTY || selectedFilterComparator === FilterTextComparators.IS_NOT_EMPTY);
+  return /* @__PURE__ */ jsx(Grid, { item: true, sx: styles.gridRoot, children: /* @__PURE__ */ jsx(Grid, { item: true, children: /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: handleShowFilter, children: /* @__PURE__ */ jsx(Badge, { color: "secondary", variant: isFilterActive ? "dot" : void 0, invisible: !isFilterActive, children: /* @__PURE__ */ jsx(FilterAlt, { sx: styles.iconSize }) }) }) }) });
+}
+export {
+  CustomFilterIcon
+};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/hooks/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 './use-custom-aggrid-column-filter';
+export * from './use-custom-aggrid-comparator-filter';

package/dist/components/composite/customAGGrid/custom-aggrid-filters/hooks/index.js

@@ -0,0 +1,6 @@
+import { useCustomAggridColumnFilter } from "./use-custom-aggrid-column-filter.js";
+import { useCustomAggridComparatorFilter } from "./use-custom-aggrid-comparator-filter.js";
+export {
+  useCustomAggridColumnFilter,
+  useCustomAggridComparatorFilter
+};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/hooks/use-custom-aggrid-column-filter.d.ts

@@ -0,0 +1,7 @@
+import { FilterData, FilterParams } from '../../custom-aggrid-types';
+export declare const useCustomAggridColumnFilter: (colId: string, filterParams: FilterParams) => {
+    selectedFilterData: unknown;
+    selectedFilterComparator: string;
+    handleChangeFilterValue: (filterData: FilterData) => void;
+    handleChangeComparator: (newType: string) => void;
+};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/hooks/use-custom-aggrid-column-filter.js

@@ -0,0 +1,111 @@
+import { useState, useRef, useCallback, useEffect } from "react";
+import { debounce } from "@mui/material";
+import { FilterDataTypes, FilterTextComparators } from "../../custom-aggrid-types.js";
+import { useCustomAggridFilterContext } from "../../context/custom-aggrid-context.js";
+import { computeTolerance } from "../utils/filter-tolerance-utils.js";
+const removeElementFromArrayWithFieldValue = (filtersArrayToRemoveFieldValueFrom, field) => {
+  return filtersArrayToRemoveFieldValueFrom.filter((f) => f.column !== field);
+};
+const changeValueFromArrayWithFieldValue = (filtersArrayToModify, field, newData) => {
+  const filterIndex = filtersArrayToModify.findIndex((f) => f.column === field);
+  if (filterIndex === -1) {
+    return [...filtersArrayToModify, newData];
+  }
+  const updatedArray = [...filtersArrayToModify];
+  updatedArray[filterIndex] = newData;
+  return updatedArray;
+};
+const useCustomAggridColumnFilter = (colId, filterParams) => {
+  const { type, tab, dataType, comparators = [], debounceMs = 1e3 } = filterParams;
+  const [selectedFilterComparator, setSelectedFilterComparator] = useState("");
+  const [selectedFilterData, setSelectedFilterData] = useState();
+  const [tolerance, setTolerance] = useState();
+  const isEditingRef = useRef(false);
+  const { getFilters, updateFilter: contextUpdateFilter } = useCustomAggridFilterContext();
+  const filters = getFilters({ type, tab });
+  const updateFilter = useCallback(
+    (data) => {
+      const newFilter = {
+        column: colId,
+        dataType: data.dataType,
+        tolerance: data.dataType === FilterDataTypes.NUMBER && data.type !== FilterTextComparators.IS_EMPTY && data.type !== FilterTextComparators.IS_NOT_EMPTY ? computeTolerance(data.value) : void 0,
+        type: data.type,
+        value: data.value
+      };
+      let updatedFilters;
+      const filterWithoutValue = data.type === FilterTextComparators.IS_EMPTY || data.type === FilterTextComparators.IS_NOT_EMPTY;
+      if (!data.value && !filterWithoutValue) {
+        updatedFilters = removeElementFromArrayWithFieldValue(filters, colId);
+      } else {
+        updatedFilters = changeValueFromArrayWithFieldValue(filters, colId, newFilter);
+      }
+      const colFilter = updatedFilters.find((f) => f.column === colId);
+      contextUpdateFilter(colId, filterParams, updatedFilters, colFilter);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [colId, filters, contextUpdateFilter]
+  );
+  const debouncedUpdateFilter = useCallback(
+    debounce((data) => {
+      updateFilter(data);
+      isEditingRef.current = false;
+    }, debounceMs),
+    [debounceMs]
+  );
+  const handleChangeFilterValue = useCallback(
+    (filterData) => {
+      isEditingRef.current = true;
+      setSelectedFilterData(filterData.value);
+      setTolerance(filterData.tolerance);
+      debouncedUpdateFilter({
+        value: filterData.value,
+        type: filterData.type ?? selectedFilterComparator,
+        dataType,
+        tolerance: filterData.tolerance
+      });
+    },
+    [dataType, debouncedUpdateFilter, selectedFilterComparator]
+  );
+  const handleChangeComparator = useCallback(
+    (newType) => {
+      isEditingRef.current = true;
+      setSelectedFilterComparator(newType);
+      const filterWithoutValue = newType === FilterTextComparators.IS_EMPTY || newType === FilterTextComparators.IS_NOT_EMPTY;
+      if (filterWithoutValue) {
+        debouncedUpdateFilter({ value: true, type: newType, dataType, tolerance });
+      } else if (selectedFilterData && selectedFilterData !== true) {
+        debouncedUpdateFilter({ value: selectedFilterData, type: newType, dataType, tolerance });
+      } else {
+        setSelectedFilterData(void 0);
+        debouncedUpdateFilter({ value: void 0, type: newType, dataType, tolerance });
+      }
+    },
+    [dataType, selectedFilterData, tolerance, debouncedUpdateFilter]
+  );
+  useEffect(() => {
+    if (!selectedFilterComparator && comparators.length > 0) {
+      setSelectedFilterComparator(comparators[0]);
+    }
+  }, [selectedFilterComparator, comparators]);
+  useEffect(() => {
+    if (isEditingRef.current) {
+      return;
+    }
+    const filterObject = filters?.find((filter) => filter.column === colId);
+    if (filterObject) {
+      setSelectedFilterData(filterObject.value);
+      setSelectedFilterComparator(filterObject.type ?? "");
+    } else {
+      setSelectedFilterData(void 0);
+    }
+  }, [filters, colId]);
+  return {
+    selectedFilterData,
+    selectedFilterComparator,
+    handleChangeFilterValue,
+    handleChangeComparator
+  };
+};
+export {
+  useCustomAggridColumnFilter
+};