impact-ui 3.7.34-alpha.2 → 3.7.34-alpha.3

package/dist/components/Table/filterUtils.d.ts

@@ -0,0 +1,157 @@
+export declare const getOperatorListForColumn: (columnDef: any) => any;
+export declare const getDefaultOperationForColumn: (columnDef: any, filter?: null) => any;
+/**
+ * Removes special characters from numeric strings
+ * Supports: currency symbols ($, €, £, ¥, ₹), commas, spaces, percentages
+ * @param {string} value - The value to clean
+ * @returns {string} - Cleaned value
+ */
+export declare const cleanNumericValue: (value: any) => any;
+/**
+ * Parses a filter value based on the column type and definition
+ * @param {*} value - The raw filter value
+ * @param {object} columnDef - The column definition from AG Grid
+ * @returns {object} - { parsedValue, filterType }
+ */
+export declare const parseFilterValue: (value: any, columnDef: any) => {
+    parsedValue: any;
+    filterType: string;
+};
+/**
+ * Determines if a column value is a string or number by checking first row data
+ * Used to decide between "equals" (numbers) vs "contains" (strings) filter type
+ * @param {object} api - AG Grid API
+ * @param {string} columnId - Column ID to check
+ * @returns {boolean} - true if column contains string values
+ */
+export declare const isColumnDataString: (api: any, columnId: any) => boolean;
+/**
+ * Builds a filter model entry for AG Grid
+ * Supports all AG Grid filter operators including:
+ * - Text: contains, notContains, equals, notEqual, startsWith, endsWith, blank, notBlank
+ * - Number: equals, notEqual, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, blank, notBlank
+ * - Date: equals, notEqual, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, inRange, blank, notBlank
+ *
+ * @param {*} parsedValue - The parsed filter value
+ * @param {string} filterType - The filter type (equals, contains, etc.)
+ * @param {object} columnDef - The column definition
+ * @param {string} operationType - Optional operation type from advance search
+ * @returns {object|undefined} - Filter model entry or undefined if invalid
+ */
+export declare const buildFilterModelEntry: (parsedValue: any, filterType: any, columnDef: any, operationType?: null) => {
+    filterType: string;
+    type: any;
+    dateFrom?: undefined;
+    dateTo?: undefined;
+    filter?: undefined;
+} | {
+    filterType: string;
+    type: string;
+    dateFrom: any;
+    dateTo: any;
+    filter?: undefined;
+} | {
+    filterType: string;
+    type: any;
+    dateFrom: any;
+    dateTo?: undefined;
+    filter?: undefined;
+} | {
+    filterType: string;
+    type: any;
+    filter: any;
+    dateFrom?: undefined;
+    dateTo?: undefined;
+} | undefined;
+/**
+ * Recursively finds a column definition by field or colId
+ * @param {array} colDefs - Array of column definitions
+ * @param {string} field - Field or colId to find
+ * @returns {object|null} - Column definition or null
+ */
+export declare const findColumnDef: (colDefs: any, field: any) => any;
+/**
+ * Applies inline search filter for a single column
+ * Handles special logic for number columns with formatted vs raw data
+ * @param {*} value - Search value
+ * @param {object} columnDef - Column definition
+ * @param {object} api - AG Grid API
+ * @param {string} columnId - Column ID
+ * @returns {object} - { parsedValue, filterType }
+ */
+export declare const parseInlineSearchValue: (value: any, columnDef: any, api: any, columnId: any) => {
+    parsedValue: any;
+    filterType: string;
+};
+/**
+ * Validates if a parsed value is valid for filtering
+ * @param {*} parsedValue - The parsed value to validate
+ * @returns {boolean} - true if valid
+ */
+export declare const isValidFilterValue: (parsedValue: any) => boolean;
+/**
+ * Gets the display label for a column (handles nested/hierarchical columns)
+ * @param {string} columnId - The column ID
+ * @param {object} columnDef - The column definition
+ * @param {array} colDefs - All column definitions
+ * @returns {string} - Display label for the column
+ */
+export declare const getColumnLabel: (columnId: any, columnDef: any, colDefs: any) => any;
+/**
+ * Validates if a filter in the filter model has a valid value
+ * @param {object} filter - Filter object from filter model
+ * @returns {boolean} - true if filter has valid value
+ */
+export declare const hasValidFilterValue: (filter: any) => boolean;
+/**
+ * Converts AG Grid filter model entry to advance search modal format
+ * @param {string} columnId - Column ID
+ * @param {object} filter - Filter from filter model
+ * @param {object} columnDef - Column definition
+ * @param {array} colDefs - All column definitions
+ * @returns {object} - Filter in modal format
+ */
+export declare const convertFilterToModalFormat: (columnId: any, filter: any, columnDef: any, colDefs: any) => {
+    column: {
+        label: any;
+        value: any;
+        type: any;
+    };
+    operation: {
+        label: any;
+        value: any;
+    };
+    value: any;
+};
+/**
+ * Updates existing filters or adds new filter
+ * @param {array} existingFilters - Current filters in modal format
+ * @param {string} columnId - Column ID being updated
+ * @param {*} value - New filter value
+ * @param {object} columnDef - Column definition
+ * @param {array} colDefs - All column definitions
+ * @returns {array} - Updated filters array
+ */
+export declare const updateOrAddFilter: (existingFilters: any, columnId: any, value: any, columnDef: any, colDefs: any) => any;
+/**
+ * Syncs AG Grid filter model with advance search modal state
+ * Clean, step-by-step approach for better maintainability
+ *
+ * @param {object} api - AG Grid API
+ * @param {string} currentColumnId - Current column being filtered
+ * @param {*} inputValue - The filter value
+ * @param {object} columnDef - Column definition
+ * @param {array} colDefs - All column definitions
+ * @param {function} setValue - Form setValue function
+ * @param {function} setInitialFilters - Set initial filters function
+ * @param {function} getOptionFromDropdownValue - Function to convert dropdown values
+ */
+export declare const syncFiltersWithModal: (api: any, currentColumnId: any, inputValue: any, columnDef: any, colDefs: any, setValue: any, setInitialFilters: any, getOptionFromDropdownValue: any) => void;
+/**
+ * Processes advance search filters and builds AG Grid filter model
+ * @param {array} formValues - Array of filter objects from form
+ * @param {array} colDefs - Column definitions
+ * @returns {object} - AG Grid filter model
+ */
+export declare const buildAdvanceSearchFilterModel: (formValues: any, colDefs: any) => {};
+//# sourceMappingURL=filterUtils.d.ts.map

package/dist/components/Table/filterUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterUtils.d.ts","sourceRoot":"","sources":["../../../src/components/Table/filterUtils.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,wBAAwB,GAAI,cAAS,QAoDjD,CAAC;AAGF,eAAO,MAAM,4BAA4B,GAAI,cAAS,EAAE,aAAa,QAyBpE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAK,QAMtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,UAAK,EAAE,cAAS;;;CAsFhD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAG,EAAE,aAAQ,YAQ/C,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,GAAI,gBAAW,EAAE,eAAU,EAAE,cAAS,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;aAoG7F,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,YAAO,EAAE,UAAK,QAoB3C,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,GAAI,UAAK,EAAE,cAAS,EAAE,QAAG,EAAE,aAAQ;;;CA0ErE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,gBAAW,YAwB7C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,aAAQ,EAAE,cAAS,EAAE,YAAO,QAc1D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,WAAM,YAUzC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,GAAI,aAAQ,EAAE,WAAM,EAAE,cAAS,EAAE,YAAO;;;;;;;;;;;CA4C9E,CAAC;AAqGF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAAI,oBAAe,EAAE,aAAQ,EAAE,UAAK,EAAE,cAAS,EAAE,YAAO,QAUrF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAG,EACH,oBAAe,EACf,eAAU,EACV,cAAS,EACT,YAAO,EACP,aAAQ,EACR,sBAAiB,EACjB,+BAA0B,SA2B3B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,GAAI,eAAU,EAAE,YAAO,OAqChE,CAAC"}

package/dist/components/Table/filterUtils.js

@@ -0,0 +1,458 @@
+import moment from "moment";
+import { TEXT_FILTER_OPTIONS, NON_TEXT_FILTER_OPTIONS, DATE_FILTER_OPTIONS, convertToOptions } from "../../utils/helper.js";
+const getOperatorListForColumn = (columnDef) => {
+  if (columnDef == null ? void 0 : columnDef.operationFilterOptions) {
+    return columnDef.operationFilterOptions;
+  }
+  if (columnDef == null ? void 0 : columnDef.thirdOptionAsDateRangePicker) {
+    return [{ label: "In range", value: "inRange" }];
+  }
+  switch (columnDef == null ? void 0 : columnDef.filter) {
+    case "agDateColumnFilter":
+      return DATE_FILTER_OPTIONS;
+    case "agNumberColumnFilter":
+      return NON_TEXT_FILTER_OPTIONS;
+    case "agTextColumnFilter":
+      if ((columnDef == null ? void 0 : columnDef.dataType) === "boolean") {
+        return [
+          { label: "Equals", value: "equals" },
+          { label: "Not equal", value: "notEqual" }
+        ];
+      }
+      if ((columnDef == null ? void 0 : columnDef.type) === "number") {
+        return TEXT_FILTER_OPTIONS;
+      }
+      return TEXT_FILTER_OPTIONS;
+  }
+  if ((columnDef == null ? void 0 : columnDef.dataType) === "boolean") {
+    return [
+      { label: "Equals", value: "equals" },
+      { label: "Not equal", value: "notEqual" }
+    ];
+  }
+  if ((columnDef == null ? void 0 : columnDef.type) === "number") {
+    return NON_TEXT_FILTER_OPTIONS;
+  }
+  return TEXT_FILTER_OPTIONS;
+};
+const getDefaultOperationForColumn = (columnDef, filter = null) => {
+  const operatorList = getOperatorListForColumn(columnDef);
+  const equalsOption = operatorList.find((opt) => opt.value === "equals");
+  if (columnDef == null ? void 0 : columnDef.thirdOptionAsDateRangePicker) {
+    return { label: "In range", value: "inRange" };
+  }
+  const prefersEquals = (columnDef == null ? void 0 : columnDef.filter) === "agDateColumnFilter" || (filter == null ? void 0 : filter.filterType) === "date" || (columnDef == null ? void 0 : columnDef.filter) === "agNumberColumnFilter" || (columnDef == null ? void 0 : columnDef.dataType) === "boolean" || (filter == null ? void 0 : filter.filterType) === "boolean" || (columnDef == null ? void 0 : columnDef.type) === "number" && (columnDef == null ? void 0 : columnDef.filter) === "agNumberColumnFilter";
+  if (prefersEquals && equalsOption) {
+    return equalsOption;
+  }
+  return operatorList[0];
+};
+const cleanNumericValue = (value) => {
+  if (typeof value !== "string") {
+    return value;
+  }
+  return value.replace(/[$€£¥₹,\s%]/g, "");
+};
+const parseFilterValue = (value, columnDef) => {
+  const type = columnDef == null ? void 0 : columnDef.type;
+  const filter = columnDef == null ? void 0 : columnDef.filter;
+  let parsedValue;
+  let filterType = "contains";
+  if (value && typeof value === "object" && (value == null ? void 0 : value.startDate) !== void 0 && (value == null ? void 0 : value.endDate) !== void 0) {
+    const startDate = moment.isMoment(value.startDate) ? value.startDate : moment(value.startDate);
+    const endDate = moment.isMoment(value.endDate) ? value.endDate : moment(value.endDate);
+    parsedValue = {
+      startDate: startDate.isValid() ? startDate.format("YYYY-MM-DD") : null,
+      endDate: endDate.isValid() ? endDate.format("YYYY-MM-DD") : null
+    };
+    return { parsedValue, filterType };
+  }
+  if (filter === "agDateColumnFilter") {
+    filterType = "equals";
+    if (value && typeof value === "object" && moment.isMoment(value)) {
+      parsedValue = value.format("YYYY-MM-DD");
+      return { parsedValue, filterType };
+    }
+    if (value && typeof value === "string") {
+      const dateMoment = moment(value, ["MM-DD-YYYY", "YYYY-MM-DD", "MM/DD/YYYY"], true);
+      if (dateMoment.isValid()) {
+        parsedValue = dateMoment.format("YYYY-MM-DD");
+        return { parsedValue, filterType };
+      }
+    }
+    if (value && typeof value === "object" && typeof (value == null ? void 0 : value.format) === "function") {
+      parsedValue = value.format("YYYY-MM-DD");
+      return { parsedValue, filterType };
+    }
+    parsedValue = void 0;
+    return { parsedValue, filterType };
+  }
+  if (filter === "agNumberColumnFilter") {
+    const cleanedValue = cleanNumericValue(value);
+    const numericValue = parseFloat(cleanedValue);
+    if (isNaN(numericValue) || cleanedValue === "") {
+      return { parsedValue: null, filterType };
+    }
+    parsedValue = numericValue;
+    filterType = "equals";
+    return { parsedValue, filterType };
+  }
+  if (type === "number" && filter === "agTextColumnFilter") {
+    parsedValue = typeof value === "string" ? value : String(value);
+    filterType = "contains";
+    return { parsedValue, filterType };
+  }
+  parsedValue = typeof value === "string" ? value : typeof value === "object" && (value == null ? void 0 : value.value) ? value.value : value;
+  return { parsedValue, filterType };
+};
+const isColumnDataString = (api, columnId) => {
+  let firstValue = null;
+  api.forEachNode((node) => {
+    if (firstValue === null && node.data) {
+      firstValue = node.data[columnId];
+    }
+  });
+  return typeof firstValue === "string";
+};
+const buildFilterModelEntry = (parsedValue, filterType, columnDef, operationType = null) => {
+  const type = columnDef == null ? void 0 : columnDef.type;
+  const filter = columnDef == null ? void 0 : columnDef.filter;
+  const operator = operationType || filterType;
+  if (operator === "blank" || operator === "notBlank") {
+    let filterTypeForBlank = "text";
+    if (filter === "agDateColumnFilter") {
+      filterTypeForBlank = "date";
+    } else if (filter === "agNumberColumnFilter" || type === "number") {
+      filterTypeForBlank = "number";
+    } else if ((columnDef == null ? void 0 : columnDef.dataType) === "boolean" && filter === "agTextColumnFilter") {
+      filterTypeForBlank = "text";
+    }
+    return {
+      filterType: filterTypeForBlank,
+      type: operator
+    };
+  }
+  if (parsedValue === null || parsedValue === void 0 || parsedValue === "") {
+    return void 0;
+  }
+  if (filter === "agDateColumnFilter" && typeof parsedValue === "object" && parsedValue.startDate && parsedValue.endDate) {
+    return {
+      filterType: "date",
+      type: "inRange",
+      dateFrom: parsedValue.startDate,
+      dateTo: parsedValue.endDate
+    };
+  }
+  if (filter === "agDateColumnFilter") {
+    return {
+      filterType: "date",
+      type: operator,
+      dateFrom: parsedValue
+    };
+  }
+  if (filter === "agNumberColumnFilter") {
+    return {
+      filterType: "number",
+      type: operator,
+      filter: parsedValue
+    };
+  }
+  if ((columnDef == null ? void 0 : columnDef.dataType) === "boolean") {
+    return {
+      filterType: "text",
+      type: operator,
+      filter: String(parsedValue)
+    };
+  }
+  if (type === "number" && filter === "agTextColumnFilter") {
+    return {
+      filterType: "text",
+      type: operator,
+      filter: String(parsedValue)
+    };
+  }
+  if (type === "number") {
+    return {
+      filterType: "number",
+      type: operator,
+      filter: parsedValue
+    };
+  }
+  const filterEntry = {
+    type: operator,
+    filter: parsedValue,
+    filterType: "text"
+  };
+  return filterEntry;
+};
+const findColumnDef = (colDefs, field) => {
+  var _a;
+  for (const col of colDefs) {
+    if (col.children) {
+      const found = findColumnDef(col.children, field);
+      if (found) return found;
+    }
+    if (col.toShowDuplicateColumnInAdvanceSearch && col.columnFieldsInAdvanceSearch) {
+      const index = (_a = col.columnFieldsInAdvanceSearch) == null ? void 0 : _a.indexOf(field);
+      if (index !== -1) {
+        return {
+          ...col,
+          currentColumnField: `${field}${index + 1}`
+          // add index + 1
+        };
+      }
+    } else if (col.colId && col.colId === field || col.field && col.field === field) {
+      return col;
+    }
+  }
+  return null;
+};
+const parseInlineSearchValue = (value, columnDef, api, columnId) => {
+  const type = columnDef == null ? void 0 : columnDef.type;
+  const filter = columnDef == null ? void 0 : columnDef.filter;
+  if (filter === "agDateColumnFilter") {
+    if (value && typeof value === "object" && (value == null ? void 0 : value.startDate) !== void 0 && (value == null ? void 0 : value.endDate) !== void 0) {
+      const startDate = moment.isMoment(value.startDate) ? value.startDate : moment(value.startDate);
+      const endDate = moment.isMoment(value.endDate) ? value.endDate : moment(value.endDate);
+      return {
+        parsedValue: {
+          startDate: startDate.isValid() ? startDate.format("YYYY-MM-DD") : null,
+          endDate: endDate.isValid() ? endDate.format("YYYY-MM-DD") : null
+        },
+        filterType: "inRange"
+      };
+    }
+    if (value && typeof value === "object" && moment.isMoment(value)) {
+      return {
+        parsedValue: value.format("YYYY-MM-DD"),
+        filterType: "equals"
+      };
+    }
+    if (value && typeof value === "string") {
+      const dateMoment = moment(value, ["MM-DD-YYYY", "YYYY-MM-DD", "MM/DD/YYYY"]);
+      if (dateMoment.isValid()) {
+        return {
+          parsedValue: dateMoment.format("YYYY-MM-DD"),
+          filterType: "equals"
+        };
+      }
+    }
+    return { parsedValue: void 0, filterType: "equals" };
+  }
+  if (filter === "agNumberColumnFilter" || type === "number") {
+    const cleanedValue = cleanNumericValue(value);
+    const parsedNumber = parseFloat(cleanedValue);
+    if (isNaN(parsedNumber) || cleanedValue === "") {
+      return { parsedValue: null, filterType: "contains" };
+    }
+    const isStringColumn = isColumnDataString(api, columnId);
+    if (isStringColumn) {
+      return { parsedValue: value, filterType: "contains" };
+    } else {
+      return { parsedValue: parsedNumber, filterType: "equals" };
+    }
+  }
+  if ((columnDef == null ? void 0 : columnDef.dataType) === "boolean") {
+    return { parsedValue: value, filterType: "equals" };
+  }
+  return { parsedValue: value, filterType: "contains" };
+};
+const isValidFilterValue = (parsedValue) => {
+  if (parsedValue === null || parsedValue === void 0) {
+    return false;
+  }
+  if (typeof parsedValue === "number" && isNaN(parsedValue)) {
+    return false;
+  }
+  if (typeof parsedValue === "string" && parsedValue.trim() === "") {
+    return false;
+  }
+  if (typeof parsedValue === "object" && parsedValue.startDate !== void 0 && parsedValue.endDate !== void 0) {
+    return parsedValue.startDate !== null && parsedValue.endDate !== null;
+  }
+  return true;
+};
+const getColumnLabel = (columnId, columnDef, colDefs) => {
+  let label = (columnDef == null ? void 0 : columnDef.headerName) || columnId;
+  if (colDefs) {
+    const columnOptions = convertToOptions(colDefs);
+    const columnOption = columnOptions.find((opt) => opt.value === columnId);
+    if (columnOption == null ? void 0 : columnOption.label) {
+      label = columnOption.label;
+    }
+  }
+  return label;
+};
+const hasValidFilterValue = (filter) => {
+  if (!filter || filter === void 0 || filter === null) {
+    return false;
+  }
+  const hasValue = filter.filter !== void 0 && filter.filter !== null && filter.filter !== "" || filter.dateFrom !== void 0 && filter.dateFrom !== null && filter.dateFrom !== "";
+  return hasValue;
+};
+const convertFilterToModalFormat = (columnId, filter, columnDef, colDefs) => {
+  var _a;
+  const columnLabel = getColumnLabel(columnId, columnDef, colDefs);
+  let value = (filter == null ? void 0 : filter.filter) || "";
+  if (filter == null ? void 0 : filter.dateFrom) {
+    if (typeof filter.dateFrom === "string") {
+      value = (_a = filter.dateFrom.split(" ")) == null ? void 0 : _a[0];
+    } else if (filter.dateFrom instanceof Date) {
+      value = moment(filter.dateFrom).format("YYYY-MM-DD");
+    } else {
+      value = filter.dateFrom;
+    }
+  }
+  let operationType = filter == null ? void 0 : filter.type;
+  let operationLabel;
+  if (!operationType) {
+    const defaultOp = getDefaultOperationForColumn(columnDef, filter);
+    operationType = defaultOp.value;
+    operationLabel = defaultOp.label;
+  } else {
+    operationLabel = operationType.charAt(0).toUpperCase() + operationType.slice(1);
+  }
+  return {
+    column: {
+      label: columnLabel,
+      value: columnId,
+      type: (filter == null ? void 0 : filter.filterType) || "text"
+    },
+    operation: {
+      label: operationLabel,
+      value: operationType
+    },
+    value
+  };
+};
+const getColumnDefById = (api, colId, colDefs) => {
+  const column = api == null ? void 0 : api.getColumn(colId);
+  if (column) {
+    return column.getColDef();
+  }
+  if (colDefs) {
+    return findColumnDef(colDefs, colId);
+  }
+  return null;
+};
+const convertActiveFiltersToModalFormat = (filterModel, api, colDefs) => {
+  return Object.keys(filterModel).filter((colId) => hasValidFilterValue(filterModel[colId])).map((colId) => {
+    const filter = filterModel[colId];
+    const colDef = getColumnDefById(api, colId, colDefs);
+    return convertFilterToModalFormat(colId, filter, colDef, colDefs);
+  });
+};
+const prepareValueForModal = (inputValue, columnDef, getOptionFromDropdownValue) => {
+  const columnType = columnDef == null ? void 0 : columnDef.type;
+  switch (columnType) {
+    case "dropdown":
+    case "select":
+      if ((columnDef == null ? void 0 : columnDef.thirdOptionDropdownOptions) && inputValue) {
+        const optionObject = getOptionFromDropdownValue(inputValue, columnDef);
+        return typeof optionObject === "object" && optionObject !== null && optionObject.label ? optionObject : inputValue;
+      }
+      return inputValue;
+    case "date":
+      return inputValue;
+    case "number":
+      return inputValue;
+    case "text":
+    default:
+      if ((columnDef == null ? void 0 : columnDef.thirdOptionDropdownOptions) && inputValue) {
+        const optionObject = getOptionFromDropdownValue(inputValue, columnDef);
+        return typeof optionObject === "object" && optionObject !== null && optionObject.label ? optionObject : inputValue;
+      }
+      return inputValue;
+  }
+};
+const createModalFilterEntry = (columnId, value, columnDef, colDefs) => {
+  return {
+    column: {
+      label: getColumnLabel(columnId, columnDef, colDefs),
+      value: columnId,
+      type: (columnDef == null ? void 0 : columnDef.type) || "text"
+    },
+    operation: getDefaultOperationForColumn(columnDef),
+    value
+  };
+};
+const updateOrAddFilter = (existingFilters, columnId, value, columnDef, colDefs) => {
+  const isAlreadyPresent = existingFilters.find((f) => {
+    var _a;
+    return ((_a = f == null ? void 0 : f.column) == null ? void 0 : _a.value) === columnId;
+  });
+  if (isAlreadyPresent) {
+    return existingFilters.map((f) => {
+      var _a;
+      return ((_a = f == null ? void 0 : f.column) == null ? void 0 : _a.value) === columnId ? { ...f, value } : f;
+    });
+  } else {
+    return [...existingFilters, createModalFilterEntry(columnId, value, columnDef, colDefs)];
+  }
+};
+const syncFiltersWithModal = (api, currentColumnId, inputValue, columnDef, colDefs, setValue, setInitialFilters, getOptionFromDropdownValue) => {
+  try {
+    const currentFilterModel = (api == null ? void 0 : api.getFilterModel()) || {};
+    const filtersFromModel = convertActiveFiltersToModalFormat(currentFilterModel, api, colDefs);
+    const valueForModal = prepareValueForModal(inputValue, columnDef, getOptionFromDropdownValue);
+    const updatedFilters = updateOrAddFilter(
+      filtersFromModel,
+      currentColumnId,
+      valueForModal,
+      columnDef,
+      colDefs
+    );
+    setValue == null ? void 0 : setValue("filters", updatedFilters);
+    setInitialFilters == null ? void 0 : setInitialFilters(updatedFilters);
+  } catch (err) {
+    console.warn("Error syncing modal filters:", err);
+  }
+};
+const buildAdvanceSearchFilterModel = (formValues, colDefs) => {
+  const filterModel = {};
+  if (!formValues || !Array.isArray(formValues)) {
+    return filterModel;
+  }
+  formValues.forEach((value) => {
+    var _a, _b;
+    if (!((_a = value == null ? void 0 : value.column) == null ? void 0 : _a.value) || !((_b = value == null ? void 0 : value.operation) == null ? void 0 : _b.value)) {
+      return;
+    }
+    const columnDef = findColumnDef(colDefs, value.column.value);
+    if (!columnDef) {
+      return;
+    }
+    const { parsedValue, filterType } = parseFilterValue(value.value, columnDef);
+    if (!isValidFilterValue(parsedValue)) {
+      return;
+    }
+    const columnKey = columnDef.colId || value.column.value;
+    const filterEntry = buildFilterModelEntry(
+      parsedValue,
+      filterType,
+      columnDef,
+      value.operation.value
+    );
+    if (filterEntry) {
+      filterModel[columnKey] = filterEntry;
+    }
+  });
+  return filterModel;
+};
+export {
+  buildAdvanceSearchFilterModel,
+  buildFilterModelEntry,
+  cleanNumericValue,
+  convertFilterToModalFormat,
+  findColumnDef,
+  getColumnLabel,
+  getDefaultOperationForColumn,
+  getOperatorListForColumn,
+  hasValidFilterValue,
+  isColumnDataString,
+  isValidFilterValue,
+  parseFilterValue,
+  parseInlineSearchValue,
+  syncFiltersWithModal,
+  updateOrAddFilter
+};

package/dist/components/Table/index.d.ts

@@ -0,0 +1,5 @@
+import { TableProps } from './Table.types';
+
+export type { TableProps } from './Table.types';
+export declare const Table: import('react').ForwardRefExoticComponent<Omit<TableProps, "ref"> & import('react').RefAttributes<unknown>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Table/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Table/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,eAAO,MAAM,KAAK,6GAEhB,CAAC"}

package/dist/components/Table/index.js

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { Table as Table$1 } from "./TableImpl.js";
+const Table = forwardRef((props, ref) => {
+  return /* @__PURE__ */ jsx(Table$1, { ref, ...props });
+});
+Table.displayName = "Table";
+export {
+  Table
+};

package/dist/components/Table/mockData.d.ts

@@ -0,0 +1,39 @@
+export declare const carsData: {
+    make: string;
+    model: string;
+    price: number;
+    electric: boolean;
+    electric0: boolean;
+    electric1: string;
+    electric2: string;
+    electric3: string;
+    electric4: string;
+    electric5: string;
+}[];
+export declare const olympicData: {
+    athlete: string;
+    age: number;
+    country: string;
+    year: number;
+    date: string;
+    sport: string;
+    gold: number;
+    silver: number;
+    bronze: number;
+    total: number;
+}[];
+export declare const masterData: {
+    name: string;
+    account: number;
+    calls: number;
+    minutes: number;
+    callRecords: {
+        name: string;
+        callId: number;
+        duration: number;
+        switchCode: string;
+        direction: string;
+        number: string;
+    }[];
+}[];
+//# sourceMappingURL=mockData.d.ts.map

package/dist/components/Table/mockData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockData.d.ts","sourceRoot":"","sources":["../../../src/components/Table/mockData.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ;;;;;;;;;;;GAiGpB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;GAiPvB,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;GAy+BtB,CAAC"}