@gridsuite/commons-ui 0.237.0 → 0.239.0

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

@@ -0,0 +1,12 @@
+import { ChangeEvent } from 'react';
+import { SelectChangeEvent } from '@mui/material';
+import { FilterParams } from '../../custom-aggrid-types';
+export declare const useCustomAggridComparatorFilter: (colId: string, filterParams: FilterParams) => {
+    selectedFilterData: unknown;
+    selectedFilterComparator: string;
+    decimalAfterDot: number;
+    isNumberInput: boolean;
+    handleFilterComparatorChange: (event: SelectChangeEvent) => void;
+    handleFilterTextChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    handleClearFilter: () => void;
+};

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

@@ -0,0 +1,65 @@
+import { useMemo } from "react";
+import "react/jsx-runtime";
+import "react-intl";
+import "../../../../../utils/conversionUtils.js";
+import "../../../../../utils/types/equipmentType.js";
+import "@mui/icons-material";
+import "@mui/material";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import { useSnackMessage } from "../../../../../hooks/useSnackMessage.js";
+import { FilterDataTypes, FilterTextComparators } from "../../custom-aggrid-types.js";
+import { countDecimalPlacesFromString } from "../../../../../utils/rounding.js";
+import { computeTolerance } from "../utils/filter-tolerance-utils.js";
+import { useCustomAggridColumnFilter } from "./use-custom-aggrid-column-filter.js";
+const useCustomAggridComparatorFilter = (colId, filterParams) => {
+  const { dataType = FilterDataTypes.TEXT, comparators = [] } = filterParams;
+  const isNumberInput = dataType === FilterDataTypes.NUMBER;
+  const { selectedFilterData, selectedFilterComparator, handleChangeFilterValue, handleChangeComparator } = useCustomAggridColumnFilter(colId, filterParams);
+  const { snackWarning } = useSnackMessage();
+  const handleFilterComparatorChange = (event) => {
+    const newType = event.target.value;
+    handleChangeComparator(newType);
+  };
+  const handleClearFilter = () => {
+    if ((selectedFilterComparator === FilterTextComparators.IS_EMPTY || selectedFilterComparator === FilterTextComparators.IS_NOT_EMPTY) && comparators.length > 0) {
+      handleChangeComparator(comparators[0]);
+    } else {
+      handleChangeFilterValue({
+        value: void 0
+      });
+    }
+  };
+  const handleFilterTextChange = (event) => {
+    const value = event.target.value.toUpperCase();
+    handleChangeFilterValue({
+      value,
+      tolerance: isNumberInput ? computeTolerance(value) : void 0
+    });
+  };
+  const decimalAfterDot = useMemo(() => {
+    if (isNumberInput) {
+      const countDecimalAfterDot = countDecimalPlacesFromString(String(selectedFilterData));
+      if (countDecimalAfterDot >= 13) {
+        snackWarning({
+          headerId: "filter.warnRounding"
+        });
+      }
+      return countDecimalAfterDot;
+    }
+    return 0;
+  }, [isNumberInput, selectedFilterData, snackWarning]);
+  return {
+    selectedFilterData,
+    selectedFilterComparator,
+    decimalAfterDot,
+    isNumberInput,
+    handleFilterComparatorChange,
+    handleFilterTextChange,
+    handleClearFilter
+  };
+};
+export {
+  useCustomAggridComparatorFilter
+};

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

@@ -0,0 +1,14 @@
+/**
+ * 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-autocomplete-filter';
+export * from './custom-aggrid-comparator-filter';
+export * from './custom-aggrid-comparator-selector';
+export * from './custom-aggrid-filter';
+export * from './custom-aggrid-text-filter';
+export * from './custom-filter-icon';
+export * from './hooks';
+export * from './utils';

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

@@ -0,0 +1,21 @@
+import { CustomAggridAutocompleteFilter } from "./custom-aggrid-autocomplete-filter.js";
+import { CustomAggridComparatorFilter } from "./custom-aggrid-comparator-filter.js";
+import { CustomAggridComparatorSelector } from "./custom-aggrid-comparator-selector.js";
+import { CustomAggridFilter } from "./custom-aggrid-filter.js";
+import { CustomAggridTextFilter } from "./custom-aggrid-text-filter.js";
+import { CustomFilterIcon } from "./custom-filter-icon.js";
+import { useCustomAggridColumnFilter } from "./hooks/use-custom-aggrid-column-filter.js";
+import { useCustomAggridComparatorFilter } from "./hooks/use-custom-aggrid-comparator-filter.js";
+import { addToleranceToFilter, computeTolerance } from "./utils/filter-tolerance-utils.js";
+export {
+  CustomAggridAutocompleteFilter,
+  CustomAggridComparatorFilter,
+  CustomAggridComparatorSelector,
+  CustomAggridFilter,
+  CustomAggridTextFilter,
+  CustomFilterIcon,
+  addToleranceToFilter,
+  computeTolerance,
+  useCustomAggridColumnFilter,
+  useCustomAggridComparatorFilter
+};

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

@@ -0,0 +1,7 @@
+import { FilterConfig } from '../../custom-aggrid-types';
+/**
+ * Compute the tolerance that should be applied when comparing filter values to database values
+ * @param value value entered in the filter
+ */
+export declare const computeTolerance: (value: unknown) => number;
+export declare const addToleranceToFilter: (filters: FilterConfig[], tolerance?: number | undefined) => FilterConfig[];

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

@@ -0,0 +1,79 @@
+import { isNumber } from "mathjs";
+import { countDecimalPlaces, countDecimalPlacesFromString } from "../../../../../utils/rounding.js";
+import { FilterDataTypes, FilterNumberComparators, UndisplayedFilterNumberComparators } from "../../custom-aggrid-types.js";
+const computeTolerance = (value) => {
+  if (!value) {
+    return 0;
+  }
+  let decimalPrecision;
+  if (isNumber(value)) {
+    decimalPrecision = countDecimalPlaces(value);
+  } else {
+    decimalPrecision = countDecimalPlacesFromString(value);
+  }
+  return 1 / 10 ** decimalPrecision * 0.5;
+};
+const addToleranceToFilter = (filters, tolerance = void 0) => {
+  let finalTolerance;
+  if (tolerance !== void 0) {
+    finalTolerance = tolerance;
+  }
+  return filters.map((filter) => {
+    const valueAsNumber = typeof filter.value === "string" ? parseFloat(filter.value) : filter.value;
+    if (typeof valueAsNumber === "number" && !Number.isNaN(valueAsNumber) && filter.dataType === FilterDataTypes.NUMBER) {
+      if (tolerance === void 0) {
+        finalTolerance = computeTolerance(filter.value);
+      }
+      switch (filter.type) {
+        // Creates two conditions to test we are not in [value-tolerance..value+tolerance] (handles rounded decimal precision)
+        case FilterNumberComparators.NOT_EQUAL:
+          return [
+            {
+              ...filter,
+              type: UndisplayedFilterNumberComparators.GREATER_THAN,
+              originalType: filter.type,
+              value: valueAsNumber + finalTolerance
+            },
+            {
+              ...filter,
+              type: UndisplayedFilterNumberComparators.LESS_THAN,
+              originalType: filter.type,
+              value: valueAsNumber - finalTolerance
+            }
+          ];
+        case FilterNumberComparators.EQUALS:
+          return [
+            {
+              ...filter,
+              type: FilterNumberComparators.GREATER_THAN_OR_EQUAL,
+              originalType: filter.type,
+              value: valueAsNumber - finalTolerance
+            },
+            {
+              ...filter,
+              type: FilterNumberComparators.LESS_THAN_OR_EQUAL,
+              originalType: filter.type,
+              value: valueAsNumber + finalTolerance
+            }
+          ];
+        case FilterNumberComparators.LESS_THAN_OR_EQUAL:
+          return {
+            ...filter,
+            value: valueAsNumber + finalTolerance
+          };
+        case FilterNumberComparators.GREATER_THAN_OR_EQUAL:
+          return {
+            ...filter,
+            value: valueAsNumber - finalTolerance
+          };
+        default:
+          return filter;
+      }
+    }
+    return filter;
+  }).flat();
+};
+export {
+  addToleranceToFilter,
+  computeTolerance
+};

package/dist/components/composite/customAGGrid/custom-aggrid-filters/utils/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 './filter-tolerance-utils';

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

@@ -0,0 +1,5 @@
+import { addToleranceToFilter, computeTolerance } from "./filter-tolerance-utils.js";
+export {
+  addToleranceToFilter,
+  computeTolerance
+};

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

@@ -0,0 +1,15 @@
+import { default as React, ComponentType } from 'react';
+import { CustomHeaderProps } from 'ag-grid-react';
+import { CustomMenuProps } from './custom-aggrid-menu';
+import { CustomAggridFilterParams, SortParams } from './custom-aggrid-types';
+interface CustomHeaderComponentProps<F extends CustomAggridFilterParams, T> extends CustomHeaderProps {
+    displayName: string;
+    sortParams?: SortParams;
+    menu?: CustomMenuProps<T>;
+    forceDisplayFilterIcon: boolean;
+    filterComponent: ComponentType<F>;
+    filterComponentParams: F;
+    isInvalid?: boolean;
+}
+export declare function CustomHeaderComponent<F extends CustomAggridFilterParams, T>({ column, displayName, sortParams, menu, forceDisplayFilterIcon, filterComponent, filterComponentParams, api, isInvalid, }: CustomHeaderComponentProps<F, T>): React.JSX.Element;
+export {};

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

@@ -0,0 +1,96 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { FormattedMessage } from "react-intl";
+import { Grid, Tooltip } from "@mui/material";
+import { WarningAmber } from "@mui/icons-material";
+import { CustomAggridSort } from "./custom-aggrid-sort.js";
+import { CustomMenu } from "./custom-aggrid-menu.js";
+import { useCustomAggridSort } from "./hooks/use-custom-aggrid-sort.js";
+import { CustomAggridFilter } from "./custom-aggrid-filters/custom-aggrid-filter.js";
+const styles = {
+  displayName: {
+    overflow: "hidden",
+    textOverflow: "ellipsis"
+  },
+  invalidIcon: {
+    display: "flex",
+    alignItems: "center",
+    ml: 0.5
+  }
+};
+function CustomHeaderComponent({
+  column,
+  displayName,
+  sortParams,
+  menu,
+  forceDisplayFilterIcon,
+  filterComponent,
+  filterComponentParams,
+  api,
+  isInvalid
+}) {
+  const [isHoveringColumnHeader, setIsHoveringColumnHeader] = useState(false);
+  const { handleSortChange } = useCustomAggridSort(column.getId(), sortParams, api);
+  const isSortable = !!sortParams;
+  const handleClickHeader = () => {
+    handleSortChange();
+  };
+  const handleCloseFilter = () => {
+    setIsHoveringColumnHeader(false);
+  };
+  const handleMouseEnter = useCallback(() => {
+    setIsHoveringColumnHeader(true);
+  }, []);
+  const handleMouseLeave = useCallback(() => {
+    setIsHoveringColumnHeader(false);
+  }, []);
+  return /* @__PURE__ */ jsx(Grid, { container: true, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, children: /* @__PURE__ */ jsxs(Grid, { container: true, alignItems: "center", wrap: "nowrap", children: [
+    /* @__PURE__ */ jsx(
+      Grid,
+      {
+        container: true,
+        sx: {
+          cursor: isSortable ? "pointer" : "default"
+        },
+        flexBasis: forceDisplayFilterIcon ? "0%" : "100%",
+        children: /* @__PURE__ */ jsx(
+          Grid,
+          {
+            container: true,
+            sx: {
+              overflow: "hidden"
+            },
+            onClick: handleClickHeader,
+            children: /* @__PURE__ */ jsxs(Grid, { container: true, sx: styles.displayName, alignItems: "center", wrap: "nowrap", children: [
+              /* @__PURE__ */ jsx(Grid, { item: true, children: displayName }),
+              isInvalid && /* @__PURE__ */ jsx(Grid, { item: true, sx: styles.invalidIcon, children: /* @__PURE__ */ jsx(
+                Tooltip,
+                {
+                  title: /* @__PURE__ */ jsx(FormattedMessage, { id: "spreadsheet/column/invalid-without-loadflow" }),
+                  children: /* @__PURE__ */ jsx(WarningAmber, { fontSize: "small", color: "warning" })
+                }
+              ) }),
+              sortParams && /* @__PURE__ */ jsx(Grid, { item: true, children: /* @__PURE__ */ jsx(CustomAggridSort, { colId: column.getId(), sortParams }) })
+            ] })
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsxs(Grid, { container: true, flex: "1", wrap: "nowrap", children: [
+      filterComponent && /* @__PURE__ */ jsx(
+        CustomAggridFilter,
+        {
+          filterComponent,
+          filterComponentParams: { ...filterComponentParams, colId: column.getId(), api },
+          isHoveringColumnHeader,
+          forceDisplayFilterIcon,
+          handleCloseFilter
+        }
+      ),
+      menu && /* @__PURE__ */ jsx(CustomMenu, { ...menu })
+    ] })
+  ] }) });
+}
+export {
+  CustomHeaderComponent
+};

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

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+export interface CustomMenuProps<T> {
+    Menu: React.FC<T | DialogMenuProps>;
+    menuParams: T;
+}
+export interface DialogMenuProps {
+    open: boolean;
+    anchorEl: HTMLElement | null;
+    onClose: () => void;
+}
+export declare function CustomMenu<T>({ Menu, menuParams }: CustomMenuProps<T>): React.JSX.Element;

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

@@ -0,0 +1,20 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { useState, useRef } from "react";
+import { Grid, IconButton, Badge } from "@mui/material";
+import { MoreVert } from "@mui/icons-material";
+const styles = {
+  iconSize: {
+    fontSize: "1rem"
+  }
+};
+function CustomMenu({ Menu, menuParams }) {
+  const [menuOpen, setMenuOpen] = useState(false);
+  const menuButtonRef = useRef(null);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Grid, { container: true, direction: "row", children: /* @__PURE__ */ jsx(IconButton, { ref: menuButtonRef, size: "small", onClick: () => setMenuOpen(true), children: /* @__PURE__ */ jsx(Badge, { color: "secondary", children: /* @__PURE__ */ jsx(MoreVert, { sx: styles.iconSize }) }) }) }),
+    /* @__PURE__ */ jsx(Menu, { open: menuOpen, onClose: () => setMenuOpen(false), anchorEl: menuButtonRef.current, ...menuParams })
+  ] });
+}
+export {
+  CustomMenu
+};

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

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+import { SortParams } from './custom-aggrid-types';
+interface CustomAggridSortProps {
+    colId: string;
+    sortParams: SortParams;
+}
+export declare function CustomAggridSort({ colId, sortParams }: CustomAggridSortProps): false | React.JSX.Element;
+export {};

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

@@ -0,0 +1,21 @@
+import { jsx } from "react/jsx-runtime";
+import { IconButton } from "@mui/material";
+import { ArrowUpward, ArrowDownward } from "@mui/icons-material";
+import { SortWay } from "./custom-aggrid-types.js";
+import { useCustomAggridSort } from "./hooks/use-custom-aggrid-sort.js";
+const styles = {
+  iconSize: {
+    fontSize: "1rem"
+  }
+};
+function CustomAggridSort({ colId, sortParams }) {
+  const { columnSort, handleSortChange } = useCustomAggridSort(colId, sortParams);
+  const handleClick = () => {
+    handleSortChange();
+  };
+  const isColumnSorted = !!columnSort;
+  return isColumnSorted && /* @__PURE__ */ jsx(IconButton, { onClick: handleClick, children: columnSort.sort === SortWay.ASC ? /* @__PURE__ */ jsx(ArrowUpward, { sx: styles.iconSize }) : /* @__PURE__ */ jsx(ArrowDownward, { sx: styles.iconSize }) });
+}
+export {
+  CustomAggridSort
+};

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

@@ -0,0 +1,122 @@
+import { ColDef, ComponentType, GridApi, IFilterOptionDef } from 'ag-grid-community';
+import { UUID } from 'crypto';
+import { DYNAMIC_SIMULATION_RESULT_SORT_STORE, LOADFLOW_RESULT_SORT_STORE, PCCMIN_ANALYSIS_RESULT_SORT_STORE, SECURITY_ANALYSIS_RESULT_SORT_STORE, SENSITIVITY_ANALYSIS_RESULT_SORT_STORE, SHORTCIRCUIT_ANALYSIS_RESULT_SORT_STORE, SPREADSHEET_SORT_STORE, STATEESTIMATION_RESULT_SORT_STORE } from '../../../utils/store-sort-filter-fields';
+export declare enum TableType {
+    Loadflow = "Loadflow",
+    SecurityAnalysis = "SecurityAnalysis",
+    SensitivityAnalysis = "SensitivityAnalysis",
+    ShortcircuitAnalysis = "ShortcircuitAnalysis",
+    DynamicSimulation = "DynamicSimulation",
+    Spreadsheet = "Spreadsheet",
+    Logs = "Logs",
+    StateEstimation = "StateEstimation",
+    PccMin = "PccMin",
+    VoltageInit = "VoltageInit"
+}
+export declare enum FilterDataTypes {
+    TEXT = "text",
+    NUMBER = "number",
+    BOOLEAN = "boolean"
+}
+export declare enum FilterTextComparators {
+    EQUALS = "equals",
+    CONTAINS = "contains",
+    STARTS_WITH = "startsWith",
+    IS_EMPTY = "blank",
+    IS_NOT_EMPTY = "notBlank"
+}
+export declare enum FilterNumberComparators {
+    EQUALS = "equals",
+    NOT_EQUAL = "notEqual",
+    LESS_THAN_OR_EQUAL = "lessThanOrEqual",
+    GREATER_THAN_OR_EQUAL = "greaterThanOrEqual"
+}
+export type FilterParams = {
+    type: TableType;
+    tab: string;
+    dataType?: string;
+    comparators?: string[];
+    debounceMs?: number;
+};
+export interface CustomAggridFilterParams {
+    api: GridApi;
+    colId: string;
+    filterParams: FilterParams;
+}
+export declare enum UndisplayedFilterNumberComparators {
+    GREATER_THAN = "greaterThan",
+    LESS_THAN = "lessThan"
+}
+export type FilterData = {
+    dataType?: string;
+    type?: string;
+    originalType?: string;
+    value: unknown;
+    tolerance?: number;
+};
+export type FilterConfig = FilterData & {
+    column: string;
+};
+export type SortConfig = {
+    colId: string;
+    sort: SortWay;
+    children?: boolean;
+};
+export declare enum SortWay {
+    ASC = "asc",
+    DESC = "desc"
+}
+export type TableSortConfig = Record<string, SortConfig[]>;
+export type TableSort = {
+    [SPREADSHEET_SORT_STORE]: TableSortConfig;
+    [LOADFLOW_RESULT_SORT_STORE]: TableSortConfig;
+    [SECURITY_ANALYSIS_RESULT_SORT_STORE]: TableSortConfig;
+    [SENSITIVITY_ANALYSIS_RESULT_SORT_STORE]: TableSortConfig;
+    [DYNAMIC_SIMULATION_RESULT_SORT_STORE]: TableSortConfig;
+    [SHORTCIRCUIT_ANALYSIS_RESULT_SORT_STORE]: TableSortConfig;
+    [STATEESTIMATION_RESULT_SORT_STORE]: TableSortConfig;
+    [PCCMIN_ANALYSIS_RESULT_SORT_STORE]: TableSortConfig;
+};
+export type TableSortKeysType = keyof TableSort;
+export type SortParams = {
+    table: TableSortKeysType;
+    tab: string;
+    isChildren?: boolean;
+    persistSort?: (api: GridApi, sort: SortConfig) => Promise<void>;
+};
+export declare enum ColumnTypes {
+    TEXT = "TEXT",
+    ENUM = "ENUM",
+    NUMBER = "NUMBER",
+    BOOLEAN = "BOOLEAN"
+}
+export interface ColumnContext<F extends CustomAggridFilterParams = CustomAggridFilterParams> {
+    agGridFilterParams?: {
+        filterOptions: IFilterOptionDef[];
+    };
+    tabUuid?: UUID;
+    columnType?: ColumnTypes;
+    columnWidth?: number;
+    fractionDigits?: number;
+    isDefaultSort?: boolean;
+    numeric?: boolean;
+    forceDisplayFilterIcon?: boolean;
+    tabIndex?: number;
+    isCustomColumn?: boolean;
+    Menu?: React.ComponentType<any>;
+    filterComponent?: ComponentType<F>;
+    filterComponentParams?: Omit<F, 'colId' | 'api'>;
+    sortParams?: SortParams;
+}
+export type CustomCellType = {
+    cellValue: number;
+    tooltipValue: number;
+};
+export interface ValidationError {
+    error: string;
+}
+export type CustomAggridValue = boolean | string | number | CustomCellType | ValidationError;
+export interface CustomColDef<TData = any, F extends CustomAggridFilterParams = CustomAggridFilterParams> extends ColDef<TData, CustomAggridValue> {
+    colId: string;
+    context?: ColumnContext<F>;
+}

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

@@ -0,0 +1,60 @@
+var TableType = /* @__PURE__ */ ((TableType2) => {
+  TableType2["Loadflow"] = "Loadflow";
+  TableType2["SecurityAnalysis"] = "SecurityAnalysis";
+  TableType2["SensitivityAnalysis"] = "SensitivityAnalysis";
+  TableType2["ShortcircuitAnalysis"] = "ShortcircuitAnalysis";
+  TableType2["DynamicSimulation"] = "DynamicSimulation";
+  TableType2["Spreadsheet"] = "Spreadsheet";
+  TableType2["Logs"] = "Logs";
+  TableType2["StateEstimation"] = "StateEstimation";
+  TableType2["PccMin"] = "PccMin";
+  TableType2["VoltageInit"] = "VoltageInit";
+  return TableType2;
+})(TableType || {});
+var FilterDataTypes = /* @__PURE__ */ ((FilterDataTypes2) => {
+  FilterDataTypes2["TEXT"] = "text";
+  FilterDataTypes2["NUMBER"] = "number";
+  FilterDataTypes2["BOOLEAN"] = "boolean";
+  return FilterDataTypes2;
+})(FilterDataTypes || {});
+var FilterTextComparators = /* @__PURE__ */ ((FilterTextComparators2) => {
+  FilterTextComparators2["EQUALS"] = "equals";
+  FilterTextComparators2["CONTAINS"] = "contains";
+  FilterTextComparators2["STARTS_WITH"] = "startsWith";
+  FilterTextComparators2["IS_EMPTY"] = "blank";
+  FilterTextComparators2["IS_NOT_EMPTY"] = "notBlank";
+  return FilterTextComparators2;
+})(FilterTextComparators || {});
+var FilterNumberComparators = /* @__PURE__ */ ((FilterNumberComparators2) => {
+  FilterNumberComparators2["EQUALS"] = "equals";
+  FilterNumberComparators2["NOT_EQUAL"] = "notEqual";
+  FilterNumberComparators2["LESS_THAN_OR_EQUAL"] = "lessThanOrEqual";
+  FilterNumberComparators2["GREATER_THAN_OR_EQUAL"] = "greaterThanOrEqual";
+  return FilterNumberComparators2;
+})(FilterNumberComparators || {});
+var UndisplayedFilterNumberComparators = /* @__PURE__ */ ((UndisplayedFilterNumberComparators2) => {
+  UndisplayedFilterNumberComparators2["GREATER_THAN"] = "greaterThan";
+  UndisplayedFilterNumberComparators2["LESS_THAN"] = "lessThan";
+  return UndisplayedFilterNumberComparators2;
+})(UndisplayedFilterNumberComparators || {});
+var SortWay = /* @__PURE__ */ ((SortWay2) => {
+  SortWay2["ASC"] = "asc";
+  SortWay2["DESC"] = "desc";
+  return SortWay2;
+})(SortWay || {});
+var ColumnTypes = /* @__PURE__ */ ((ColumnTypes2) => {
+  ColumnTypes2["TEXT"] = "TEXT";
+  ColumnTypes2["ENUM"] = "ENUM";
+  ColumnTypes2["NUMBER"] = "NUMBER";
+  ColumnTypes2["BOOLEAN"] = "BOOLEAN";
+  return ColumnTypes2;
+})(ColumnTypes || {});
+export {
+  ColumnTypes,
+  FilterDataTypes,
+  FilterNumberComparators,
+  FilterTextComparators,
+  SortWay,
+  TableType,
+  UndisplayedFilterNumberComparators
+};

package/dist/components/composite/customAGGrid/display-rounding.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+/**
+ * displays a rounding precision like this : 'Rounded to 10^decimalAfterDot' or as a decimal number if decimalAfterDot <= 4
+ */
+interface DisplayRoundingProps {
+    decimalAfterDot: number;
+}
+export declare function DisplayRounding({ decimalAfterDot }: Readonly<DisplayRoundingProps>): React.JSX.Element;
+export {};

package/dist/components/composite/customAGGrid/display-rounding.js

@@ -0,0 +1,33 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { useIntl } from "react-intl";
+import { FormHelperText, Box } from "@mui/material";
+const styles = {
+  exponent: {
+    position: "relative",
+    bottom: "1ex",
+    fontSize: "80%"
+  }
+};
+function DisplayRounding({ decimalAfterDot }) {
+  const intl = useIntl();
+  const roundedTo1 = decimalAfterDot === 0;
+  const displayAsPower10 = decimalAfterDot > 4;
+  const baseMessage = `${intl.formatMessage({
+    id: roundedTo1 ? "filter.roundedToOne" : "filter.rounded"
+  })} `;
+  const decimalAfterDotStr = -decimalAfterDot;
+  let roundingPrecision = null;
+  if (!roundedTo1) {
+    roundingPrecision = displayAsPower10 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      "10",
+      /* @__PURE__ */ jsx(Box, { component: "span", sx: styles.exponent, children: decimalAfterDotStr })
+    ] }) : 1 / 10 ** decimalAfterDot;
+  }
+  return /* @__PURE__ */ jsxs(FormHelperText, { children: [
+    baseMessage,
+    roundingPrecision
+  ] });
+}
+export {
+  DisplayRounding
+};

package/dist/components/composite/customAGGrid/hooks/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 './use-custom-aggrid-sort';

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

@@ -0,0 +1,4 @@
+import { useCustomAggridSort } from "./use-custom-aggrid-sort.js";
+export {
+  useCustomAggridSort
+};

package/dist/components/composite/customAGGrid/hooks/use-custom-aggrid-sort.d.ts

@@ -0,0 +1,6 @@
+import { GridApi } from 'ag-grid-community';
+import { SortParams } from '../custom-aggrid-types';
+export declare const useCustomAggridSort: (colId: string, sortParams?: SortParams, api?: GridApi) => {
+    columnSort: import('..').SortConfig | undefined;
+    handleSortChange: () => void;
+};