@m4l/components 9.1.129 → 9.1.131

package/components/Chip/types.d.ts

@@ -29,7 +29,7 @@ export interface ChipProps {
     /**
      * Defines the variant of the `Chip` (default 'contained').
      */
-    variant?: ChipVariants;
+    variant?: ChipVariants | string;
     /**
      * Defines the color of the `Chip`.
      */
@@ -49,7 +49,7 @@ export interface ChipProps {
     /**
      * Function to be executed when the `Chip` is clicked.
      */
-    onClick?: () => void;
+    onClick?: (() => void) | ((event: any) => void);
     /**
      * Props for the close icon button.
      */

package/components/DataGrid/formatters/ColumnBooleanFormatter/index.js

@@ -1,8 +1,9 @@
 import { jsx } from "react/jsx-runtime";
 import { getPropertyByString } from "@m4l/core";
+import React from "react";
 import { B as BooleanFormatter } from "../../../formatters/BooleanFormatter/BooleanFormatter.js";
 function ColumnBooleanFormatter(props) {
-  const { fieldValue, presentationType, Component } = props;
+  const { fieldValue, presentationType, Component = React.Fragment } = props;
   return (obProps) => {
     const valueMaybeString = getPropertyByString(obProps, fieldValue);
     let fixedValue;

package/components/DataGrid/formatters/ColumnBooleanFormatter/useColumnBoolean.d.ts

@@ -0,0 +1,10 @@
+import { ColumnBooleanFormatterProps } from './types';
+/**
+ * Función helper que retorna
+ * el formatter de la columna, el filtro y el customSort
+ */
+export declare const useColumnBoolean: <TRow>(props: ColumnBooleanFormatterProps) => {
+    formatter: (obProps: any) => import("react/jsx-runtime").JSX.Element;
+    customFilter: (row: TRow, value: string) => boolean;
+    customSort: (a: TRow, b: TRow) => 0 | 1 | -1;
+};

package/components/DataGrid/formatters/ColumnBooleanFormatter/useColumnBoolean.js

@@ -0,0 +1,65 @@
+import { g as getFormatBoolean } from "../../../formatters/BooleanFormatter/BooleanFormatter.js";
+import { C as ColumnBooleanFormatter } from "./index.js";
+import { useModuleDictionary, getPropertyByString } from "@m4l/core";
+const getCustomBooleanFilter = (props, getLabel) => {
+  return (row, value) => {
+    const valueMaybeString = getPropertyByString(row, props.fieldValue);
+    let fixedValue;
+    if (typeof valueMaybeString === "boolean") {
+      fixedValue = valueMaybeString;
+    } else {
+      fixedValue = void 0;
+    }
+    return getFormatBoolean(
+      props.presentationType,
+      fixedValue,
+      getLabel
+    ).includes(value);
+  };
+};
+const getCustomBooleanSort = (props, getLabel) => {
+  return (a, b) => {
+    const valueMaybeStringA = getPropertyByString(a, props.fieldValue);
+    const valueMaybeStringB = getPropertyByString(b, props.fieldValue);
+    let fixedValueA;
+    let fixedValueB;
+    if (typeof valueMaybeStringA === "boolean") {
+      fixedValueA = valueMaybeStringA;
+    } else {
+      fixedValueA = void 0;
+    }
+    if (typeof valueMaybeStringB === "boolean") {
+      fixedValueB = valueMaybeStringB;
+    } else {
+      fixedValueB = void 0;
+    }
+    const valueA = getFormatBoolean(
+      props.presentationType,
+      fixedValueA,
+      getLabel
+    );
+    const valueB = getFormatBoolean(
+      props.presentationType,
+      fixedValueB,
+      getLabel
+    );
+    if (valueA > valueB) {
+      return 1;
+    }
+    if (valueA < valueB) {
+      return -1;
+    }
+    return 0;
+  };
+};
+const useColumnBoolean = (props) => {
+  const { getLabel } = useModuleDictionary();
+  return {
+    formatter: ColumnBooleanFormatter(props),
+    customFilter: getCustomBooleanFilter(props, getLabel),
+    customSort: getCustomBooleanSort(props, getLabel)
+  };
+};
+export {
+  useColumnBoolean as u
+};

package/components/DataGrid/formatters/ColumnConcatenatedValueFormatter/index.js

@@ -1,8 +1,9 @@
 import { jsx } from "react/jsx-runtime";
 import { getPropertyByString } from "@m4l/core";
+import React from "react";
 import { C as ConcatenatedFormatter } from "../../../formatters/ConcatenatedFormatter/ConcatenatedFormatter.js";
 function ColumnConcatenatedValueFormatter(props) {
-  const { fieldValue, fieldSeparator, Component } = props;
+  const { fieldValue, fieldSeparator, Component = React.Fragment } = props;
   return (obProps) => {
     const values = fieldValue.map((element) => {
       const valueMaybeString = getPropertyByString(obProps, element);

package/components/DataGrid/formatters/ColumnConcatenatedValueFormatter/types.d.ts

@@ -1,6 +1,6 @@
 import { ElementType } from 'react';
 export interface ColumnConcatenatedValuesFormatterProps {
     Component?: ElementType;
-    fieldValue: Array<string>;
+    fieldValue: string[];
     fieldSeparator: string;
 }

package/components/DataGrid/formatters/ColumnConcatenatedValueFormatter/useColumnConcatenatedValue.d.ts

@@ -0,0 +1,9 @@
+import { ColumnConcatenatedValuesFormatterProps } from './types';
+/**
+ * Funcion helper que retorna el formatter, filter y customSort de la columna concatenada.
+ */
+export declare const useColumnConcatenatedValue: <TRow>(props: ColumnConcatenatedValuesFormatterProps) => {
+    formatter: (obProps: any) => import("react/jsx-runtime").JSX.Element;
+    customFilter: (row: TRow, value: string) => boolean;
+    customSort: (a: TRow, b: TRow) => 0 | 1 | -1;
+};

package/components/DataGrid/formatters/ColumnConcatenatedValueFormatter/useColumnConcatenatedValue.js

@@ -0,0 +1,49 @@
+import { getPropertyByString } from "@m4l/core";
+import { C as ColumnConcatenatedValueFormatter } from "./index.js";
+import { g as getColumnKey } from "../../helpers/getColumnKey.js";
+import { g as getFormatConcatenated } from "../../../formatters/ConcatenatedFormatter/ConcatenatedFormatter.js";
+const getArrayValuesWithFieldValue = (row, fieldValue) => {
+  const values = fieldValue.map((element) => {
+    const keyWiouthRow = getColumnKey(element);
+    const valueMaybeString = getPropertyByString(row, keyWiouthRow);
+    let fixedValue;
+    if (typeof valueMaybeString === "string" || typeof valueMaybeString === "number") {
+      fixedValue = valueMaybeString.toString();
+    } else {
+      fixedValue = "";
+    }
+    return fixedValue;
+  });
+  return values;
+};
+const getCustomContatenatedValueFilter = (props) => {
+  return (row, value) => {
+    const values = getArrayValuesWithFieldValue(row, props.fieldValue);
+    return getFormatConcatenated(values, props.fieldSeparator).includes(value);
+  };
+};
+const getCustomConcatenatedValueSort = (props) => {
+  return (a, b) => {
+    const arrayA = getArrayValuesWithFieldValue(a, props.fieldValue);
+    const arrayB = getArrayValuesWithFieldValue(b, props.fieldValue);
+    const valueA = getFormatConcatenated(arrayA, props.fieldSeparator);
+    const valueB = getFormatConcatenated(arrayB, props.fieldSeparator);
+    if (valueA > valueB) {
+      return 1;
+    }
+    if (valueA < valueB) {
+      return -1;
+    }
+    return 0;
+  };
+};
+const useColumnConcatenatedValue = (props) => {
+  return {
+    formatter: ColumnConcatenatedValueFormatter(props),
+    customFilter: getCustomContatenatedValueFilter(props),
+    customSort: getCustomConcatenatedValueSort(props)
+  };
+};
+export {
+  useColumnConcatenatedValue as u
+};

package/components/DataGrid/formatters/ColumnDateFormatter/index.js

@@ -1,8 +1,9 @@
 import { jsx } from "react/jsx-runtime";
 import { getPropertyByString } from "@m4l/core";
+import React from "react";
 import { D as DateFormatter } from "../../../formatters/DateFormatter/DateFormatter.js";
 function ColumnDateFormatter(props) {
-  const { fieldValue, presentationType, Component } = props;
+  const { fieldValue, presentationType, Component = React.Fragment } = props;
   return (obProps) => {
     const valueMaybeDateStringNumber = getPropertyByString(obProps, fieldValue);
     let fixedValue;

package/components/DataGrid/formatters/ColumnDateFormatter/useColumnDate.d.ts

@@ -0,0 +1,14 @@
+import { ColumnDateFormatterProps } from './types';
+/**
+ * funcion para filtrar por fecha en una columna
+ */
+export declare const useCustomDateFilter: <TRow>(props: ColumnDateFormatterProps) => (row: TRow, value: string) => boolean;
+/**
+ * Funcion helper que retorna el formatter,
+ * customFilter y customSort de una columna de fecha
+ */
+export declare const useColumnDate: <TRow>(props: ColumnDateFormatterProps) => {
+    formatter: (obProps: any) => import("react/jsx-runtime").JSX.Element;
+    customFilter: (row: TRow, value: string) => boolean;
+    customSort: (a: TRow, b: TRow) => 0 | 1 | -1;
+};

package/components/DataGrid/formatters/ColumnDateFormatter/useColumnDate.js

@@ -0,0 +1,50 @@
+import { getPropertyByString } from "@m4l/core";
+import { g as getFormatDate } from "../../../formatters/DateFormatter/DateFormatter.js";
+import { C as ColumnDateFormatter } from "./index.js";
+import { g as getColumnKey } from "../../helpers/getColumnKey.js";
+import { useFormatter } from "@m4l/graphics";
+const useCustomDateFilter = (props) => {
+  const { dateFormatter } = useFormatter();
+  return (row, value) => {
+    const fieldValue = getColumnKey(props.fieldValue);
+    const rawValue = getPropertyByString(row, fieldValue);
+    let dateValue = null;
+    if (typeof rawValue === "string") {
+      dateValue = new Date(rawValue);
+    } else if (rawValue instanceof Date) {
+      dateValue = rawValue;
+    }
+    if (!dateValue || isNaN(dateValue.getTime())) {
+      return false;
+    }
+    const formattedDate = getFormatDate(props.presentationType, dateValue, dateFormatter, props.format);
+    return formattedDate.includes(value);
+  };
+};
+const getCustomDateSort = (props) => {
+  return (a, b) => {
+    const key = getColumnKey(props.fieldValue);
+    const valueMaybeDateStringNumberA = getPropertyByString(a, key);
+    const valueMaybeDateStringNumberB = getPropertyByString(b, key);
+    const fixedValueA = new Date(valueMaybeDateStringNumberA);
+    const fixedValueB = new Date(valueMaybeDateStringNumberB);
+    if (fixedValueA.getTime() > fixedValueB.getTime()) {
+      return 1;
+    }
+    if (fixedValueA.getTime() < fixedValueB.getTime()) {
+      return -1;
+    }
+    return 0;
+  };
+};
+const useColumnDate = (props) => {
+  const customFilter = useCustomDateFilter(props);
+  return {
+    formatter: ColumnDateFormatter(props),
+    customFilter,
+    customSort: getCustomDateSort(props)
+  };
+};
+export {
+  useColumnDate as u
+};

package/components/DataGrid/formatters/ColumnInteractiveCheckFormatter/useColumnInteractiveCheck.d.ts

@@ -0,0 +1,12 @@
+import { ColumnInteractiveCheckFormatterProps } from './types';
+/**
+ * Función que retorna para una columna "check":
+ * - formatter: ColumnInteractiveCheckFormatter
+ * - filter: getCustomInteractiveCheckFilter
+ * - customSort: getCustomInteractiveCheckSort
+ */
+export declare const useColumnInteractiveCheck: <TRow>(props: ColumnInteractiveCheckFormatterProps<TRow>) => {
+    formatter: import("react/jsx-runtime").JSX.Element;
+    filter: (row: TRow, value: boolean) => boolean;
+    customSort: (a: TRow, b: TRow) => 0 | 1 | -1;
+};

package/components/DataGrid/formatters/ColumnInteractiveCheckFormatter/useColumnInteractiveCheck.js

@@ -0,0 +1,29 @@
+import { C as ColumnInteractiveCheckFormatter } from "./index.js";
+const getCustomInteractiveCheckFilter = (props) => {
+  return (row, value) => {
+    return row[props.column.key] === value;
+  };
+};
+const getCustomInteractiveCheckSort = (props) => {
+  return (a, b) => {
+    const valueA = a[props.column.key];
+    const valueB = b[props.column.key];
+    if (valueA > valueB) {
+      return 1;
+    }
+    if (valueA < valueB) {
+      return -1;
+    }
+    return 0;
+  };
+};
+const useColumnInteractiveCheck = (props) => {
+  return {
+    formatter: ColumnInteractiveCheckFormatter(props),
+    filter: getCustomInteractiveCheckFilter(props),
+    customSort: getCustomInteractiveCheckSort(props)
+  };
+};
+export {
+  useColumnInteractiveCheck as u
+};

package/components/DataGrid/formatters/ColumnNestedValueFormatter/index.js

@@ -5,7 +5,7 @@ function ColumnNestedValueFormatter(props) {
   const { fieldValue, Component = WrapperComponent } = props;
   return (obProps) => {
     const property = getPropertyByString(obProps, fieldValue);
-    const value = typeof property === "object" ? "" : property;
+    const value = typeof property === "object" ? JSON.stringify(property) : property;
     return /* @__PURE__ */ jsx(Component, { children: value });
   };
 }

package/components/DataGrid/formatters/ColumnNestedValueFormatter/useColumnNestedValue.d.ts

@@ -0,0 +1,10 @@
+import { ColumnNestedValueFormatterProps } from './types';
+/**
+ * Funcion que retorna el formatter, customFilter y customSort
+ * de la columna para ColumnNestedValueFormatter.
+ */
+export declare const useColumnNestedValue: <TRow>(props: ColumnNestedValueFormatterProps) => {
+    formatter: (obProps: any) => import("react/jsx-runtime").JSX.Element;
+    customFilter: (row: TRow, value: string) => boolean;
+    customSort: (a: TRow, b: TRow) => 0 | 1 | -1;
+};

package/components/DataGrid/formatters/ColumnNestedValueFormatter/useColumnNestedValue.js

@@ -0,0 +1,37 @@
+import { getPropertyByString } from "@m4l/core";
+import { C as ColumnNestedValueFormatter } from "./index.js";
+const getCustomNestedValueFilter = (props) => {
+  return (row, value) => {
+    const property = getPropertyByString(row, props.fieldValue) ?? "";
+    if (typeof property === "object") {
+      return Object.values(property).includes(value);
+    }
+    return property.toString().includes(value);
+  };
+};
+const getCustomNestedValueSort = (props) => {
+  return (a, b) => {
+    const valueA = getPropertyByString(a, props.fieldValue);
+    const valueB = getPropertyByString(b, props.fieldValue);
+    if (typeof valueA === "object" || typeof valueB === "object" || valueA === void 0 || valueB === void 0) {
+      return 0;
+    }
+    if (valueA > valueB) {
+      return 1;
+    }
+    if (valueA < valueB) {
+      return -1;
+    }
+    return 0;
+  };
+};
+const useColumnNestedValue = (props) => {
+  return {
+    formatter: ColumnNestedValueFormatter(props),
+    customFilter: getCustomNestedValueFilter(props),
+    customSort: getCustomNestedValueSort(props)
+  };
+};
+export {
+  useColumnNestedValue as u
+};

package/components/DataGrid/formatters/ColumnPointsFormatter/index.js

@@ -1,8 +1,10 @@
 import { jsx } from "react/jsx-runtime";
+import React from "react";
 import { P as PointsFormatter } from "../../../formatters/PointsFormatter/PointsFormatter.js";
 function ColumnPointsFormatter(props) {
+  const { Component = React.Fragment } = props;
   return (obProps) => {
-    return /* @__PURE__ */ jsx(PointsFormatter, { obProps, ...props });
+    return /* @__PURE__ */ jsx(PointsFormatter, { obProps, ...props, Component });
   };
 }
 export {

package/components/DataGrid/formatters/ColumnPointsFormatter/useColumnPoints.d.ts

@@ -0,0 +1,10 @@
+import { ColumnPointsFormatterProps } from './types';
+/**
+ * Funcion helper que retorna el formatter,
+ * customFilter y customSort de la columna de puntos de calibración.
+ */
+export declare const useColumnPoints: <TRow>(props: ColumnPointsFormatterProps) => {
+    formatter: (obProps: any) => import("react/jsx-runtime").JSX.Element;
+    customFilter: (row: TRow, value: string) => boolean;
+    customSort: (a: TRow, b: TRow) => 0 | 1 | -1;
+};

package/components/DataGrid/formatters/ColumnPointsFormatter/useColumnPoints.js

@@ -0,0 +1,35 @@
+import { C as ColumnPointsFormatter } from "./index.js";
+import { g as getColumnKey } from "../../helpers/getColumnKey.js";
+import { g as getFormatPoints } from "../../../formatters/PointsFormatter/PointsFormatter.js";
+const getCustomPointsFilter = (props) => {
+  return (row, value) => {
+    const fieldValue = getColumnKey(props.fieldValue);
+    const unitValue = getColumnKey(props.fieldUnit);
+    return getFormatPoints(row, fieldValue, unitValue).toLocaleLowerCase().includes(value.toLocaleLowerCase());
+  };
+};
+const getCustomPointsSort = (props) => {
+  return (a, b) => {
+    const fieldValue = getColumnKey(props.fieldValue);
+    const unitValue = getColumnKey(props.fieldUnit);
+    const valueA = getFormatPoints(a, fieldValue, unitValue);
+    const valueB = getFormatPoints(b, fieldValue, unitValue);
+    if (valueA > valueB) {
+      return 1;
+    }
+    if (valueA < valueB) {
+      return -1;
+    }
+    return 0;
+  };
+};
+const useColumnPoints = (props) => {
+  return {
+    formatter: ColumnPointsFormatter(props),
+    customFilter: getCustomPointsFilter(props),
+    customSort: getCustomPointsSort(props)
+  };
+};
+export {
+  useColumnPoints as u
+};

package/components/DataGrid/formatters/ColumnPriceFormatter/index.js

@@ -1,8 +1,10 @@
 import { jsx } from "react/jsx-runtime";
+import React from "react";
 import { P as PriceFormatter } from "../../../formatters/PriceFormatter/PriceFormatter.js";
 function ColumnPriceFormatter(props) {
+  const { Component = React.Fragment } = props;
   return (obProps) => {
-    return /* @__PURE__ */ jsx(PriceFormatter, { obProps, ...props });
+    return /* @__PURE__ */ jsx(PriceFormatter, { obProps, ...props, Component });
   };
 }
 export {

package/components/DataGrid/formatters/ColumnPriceFormatter/useColumnPrice.d.ts

@@ -0,0 +1,10 @@
+import { ColumnPriceFormatterProps } from './types';
+/**
+ * Función helper que retorna el formatter,
+ * customFilter y customSort de la columna de precios.
+ */
+export declare const useColumnPrice: <TRow>(props: ColumnPriceFormatterProps) => {
+    formatter: (obProps: any) => import("react/jsx-runtime").JSX.Element;
+    customFilter: (row: TRow, value: string) => boolean;
+    customSort: (a: TRow, b: TRow) => 0 | 1 | -1;
+};

package/components/DataGrid/formatters/ColumnPriceFormatter/useColumnPrice.js

@@ -0,0 +1,48 @@
+import { getPropertyByString } from "@m4l/core";
+import { C as ColumnPriceFormatter } from "./index.js";
+import { g as getColumnKey } from "../../helpers/getColumnKey.js";
+import { g as getFormatPrice } from "../../../formatters/PriceFormatter/PriceFormatter.js";
+import { useFormatter } from "@m4l/graphics";
+const getCustomPriceFilter = (props) => {
+  const { currencyFormatter } = useFormatter();
+  return (row, value) => {
+    const fieldValue = getColumnKey(props.fieldValue);
+    return getFormatPrice(row, fieldValue, currencyFormatter.code, currencyFormatter.decimalDigits).includes(value);
+  };
+};
+const getCustomPriceSort = (props) => {
+  return (a, b) => {
+    const fieldValue = getColumnKey(props.fieldValue);
+    const valueMaybeStringA = getPropertyByString(a, fieldValue);
+    const valueMaybeStringB = getPropertyByString(b, fieldValue);
+    let fixedValueA;
+    let fixedValueB;
+    if (typeof valueMaybeStringA === "number") {
+      fixedValueA = valueMaybeStringA;
+    } else {
+      fixedValueA = 0;
+    }
+    if (typeof valueMaybeStringB === "number") {
+      fixedValueB = valueMaybeStringB;
+    } else {
+      fixedValueB = 0;
+    }
+    if (fixedValueA > fixedValueB) {
+      return 1;
+    }
+    if (fixedValueA < fixedValueB) {
+      return -1;
+    }
+    return 0;
+  };
+};
+const useColumnPrice = (props) => {
+  return {
+    formatter: ColumnPriceFormatter(props),
+    customFilter: getCustomPriceFilter(props),
+    customSort: getCustomPriceSort(props)
+  };
+};
+export {
+  useColumnPrice as u
+};

package/components/DataGrid/formatters/ColumnSetCheckFormatter/useColumnSetCheck.d.ts

@@ -0,0 +1,11 @@
+import { ColumnSetCheckFormatterProps } from './types';
+import { RowKey } from '../../types';
+/**
+ * Funcion helper que retorna el formatter, customFilter y customSort
+ * de la columna de selección de elementos.
+ */
+export declare const useColumnSetCheck: <TRow, TKey extends RowKey = RowKey>(props: ColumnSetCheckFormatterProps<TRow, TKey>) => {
+    formatter: (props: import('react-data-grid').FormatterProps<TRow, unknown>) => import("react/jsx-runtime").JSX.Element;
+    customFilter: (row: TRow, value: TKey) => boolean;
+    customSort: (a: TRow, b: TRow) => 0 | 1 | -1;
+};

package/components/DataGrid/formatters/ColumnSetCheckFormatter/useColumnSetCheck.js

@@ -0,0 +1,32 @@
+import { C as ColumnSetCheckFormatter } from "./index.js";
+import { getPropertyByString } from "@m4l/core";
+const getCustomFilter = (props) => {
+  return (row, value) => {
+    const valueCheck = getPropertyByString(row, props.field);
+    return valueCheck === value;
+  };
+};
+const getCustomSort = (props) => {
+  return (a, b) => {
+    const { useHook, field, rowKeyGetter } = props;
+    const [checkedRows] = useHook(field);
+    const indexA = checkedRows.has(rowKeyGetter(a));
+    const indexB = checkedRows.has(rowKeyGetter(b));
+    if (indexA && !indexB) {
+      return 1;
+    } else if (!indexA && indexB) {
+      return -1;
+    }
+    return 0;
+  };
+};
+const useColumnSetCheck = (props) => {
+  return {
+    formatter: ColumnSetCheckFormatter(props),
+    customFilter: getCustomFilter(props),
+    customSort: getCustomSort(props)
+  };
+};
+export {
+  useColumnSetCheck as u
+};

package/components/DataGrid/formatters/ColumnUncertaintyFormatter/index.js

@@ -1,8 +1,10 @@
 import { jsx } from "react/jsx-runtime";
+import React from "react";
 import { U as UncertaintyFormatter } from "../../../formatters/UncertaintyFormatter/UncertaintyFormatter.js";
 function ColumnUncertaintyFormatter(props) {
+  const { Component = React.Fragment } = props;
   return (obProps) => {
-    return /* @__PURE__ */ jsx(UncertaintyFormatter, { obProps, ...props });
+    return /* @__PURE__ */ jsx(UncertaintyFormatter, { obProps, ...props, Component });
   };
 }
 export {

package/components/DataGrid/formatters/ColumnUncertaintyFormatter/useColumnUncertainty.d.ts

@@ -0,0 +1,11 @@
+import { ColumnUncertaintyFormatterProps } from './types';
+/**
+ * Función helper que retorna el formatter,
+ * el filtro y el customSort de la columna
+ * de incertidumbre.
+ */
+export declare const useColumnCertanity: <TRow>(props: ColumnUncertaintyFormatterProps) => {
+    formatter: (obProps: any) => import("react/jsx-runtime").JSX.Element;
+    customFilter: (row: TRow, value: string) => boolean;
+    customSort: (a: TRow, b: TRow) => 0 | 1 | -1;
+};

package/components/DataGrid/formatters/ColumnUncertaintyFormatter/useColumnUncertainty.js

@@ -0,0 +1,43 @@
+import { g as getUncertaintyFormat } from "../../../formatters/UncertaintyFormatter/UncertaintyFormatter.js";
+import { C as ColumnUncertaintyFormatter } from "./index.js";
+import { g as getColumnKey } from "../../helpers/getColumnKey.js";
+const getCustomUncertaintyFilter = (props) => {
+  return (row, value) => {
+    const fieldValue = getColumnKey(props.fieldValue);
+    const fieldSymbol = getColumnKey(props.fieldSymbol);
+    const fieldUnit = getColumnKey(props.fieldUnit);
+    const format = getUncertaintyFormat(
+      row,
+      fieldValue,
+      fieldSymbol,
+      fieldUnit
+    );
+    return format.includes(value);
+  };
+};
+const getCustomUncertaintySort = (props) => {
+  return (a, b) => {
+    const fieldValue = getColumnKey(props.fieldValue);
+    const fieldSymbol = getColumnKey(props.fieldSymbol);
+    const fieldUnit = getColumnKey(props.fieldUnit);
+    const valueA = getUncertaintyFormat(a, fieldValue, fieldSymbol, fieldUnit);
+    const valueB = getUncertaintyFormat(b, fieldValue, fieldSymbol, fieldUnit);
+    if (valueA > valueB) {
+      return 1;
+    }
+    if (valueA < valueB) {
+      return -1;
+    }
+    return 0;
+  };
+};
+const useColumnCertanity = (props) => {
+  return {
+    formatter: ColumnUncertaintyFormatter(props),
+    customFilter: getCustomUncertaintyFilter(props),
+    customSort: getCustomUncertaintySort(props)
+  };
+};
+export {
+  useColumnCertanity as u
+};

package/components/DataGrid/formatters/index.d.ts

@@ -9,3 +9,12 @@ export { ColumnInteractiveCheckFormatter } from './ColumnInteractiveCheckFormatt
 export { ColumnSetCheckFormatter } from './ColumnSetCheckFormatter';
 export type { ColumnUncertaintyFormatterProps } from './ColumnUncertaintyFormatter/types';
 export { ColumnIconFormatter } from './ColumnIconFormatter';
+export { useColumnBoolean } from './ColumnBooleanFormatter/useColumnBoolean';
+export { useColumnConcatenatedValue } from './ColumnConcatenatedValueFormatter/useColumnConcatenatedValue';
+export { useColumnDate } from './ColumnDateFormatter/useColumnDate';
+export { useColumnNestedValue } from './ColumnNestedValueFormatter/useColumnNestedValue';
+export { useColumnPrice } from './ColumnPriceFormatter/useColumnPrice';
+export { useColumnCertanity } from './ColumnUncertaintyFormatter/useColumnUncertainty';
+export { useColumnPoints } from './ColumnPointsFormatter/useColumnPoints';
+export { useColumnInteractiveCheck } from './ColumnInteractiveCheckFormatter/useColumnInteractiveCheck';
+export { useColumnSetCheck } from './ColumnSetCheckFormatter/useColumnSetCheck';

package/components/DataGrid/helpers/getColumnKey.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Función utilizada para remover la parabra 'row' en la posicion cero de las keys de
+ * las columnas concatenadas. Esto se utiliza para obtener la key directa
+ * asignada en una columna.
+ * @param key - key de la columna
+ * @returns key sin la palabra 'row'
+ * @example
+ * - row.concatenated -> concatenated
+ * - row.user.name -> user.name
+ * @example
+ * getColumnKey('row.concatenated') // 'concatenated'
+ */
+export declare const getColumnKey: (key: string) => string;