@wavemaker-ai/react-runtime 1.0.0-rc.309

package/components/data/table/utils/validation.js

@@ -0,0 +1,125 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateField = exports.updateValidationErrors = exports.resetValidationState = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _lodashEs = require("lodash-es");
+/**
+ * Validates a single field and updates validation state
+ */
+var validateField = exports.validateField = function validateField(rowId, fieldName, value, column, validationState) {
+  var _cellUpdateCallbacks$5, _cellUpdateCallbacks$6;
+  var fieldKey = "".concat(rowId, "_").concat(fieldName);
+  var fieldRefs = validationState.fieldRefs,
+    fieldValidationErrors = validationState.fieldValidationErrors,
+    cellUpdateCallbacks = validationState.cellUpdateCallbacks;
+  if (!(column !== null && column !== void 0 && column.required)) return true;
+
+  // Check required validation
+  if (column !== null && column !== void 0 && column.required && (value === undefined || value === null || value === "")) {
+    var _cellUpdateCallbacks$, _cellUpdateCallbacks$2;
+    fieldValidationErrors.current[fieldKey] = true;
+    (_cellUpdateCallbacks$ = (_cellUpdateCallbacks$2 = cellUpdateCallbacks.current)[fieldKey]) === null || _cellUpdateCallbacks$ === void 0 || _cellUpdateCallbacks$.call(_cellUpdateCallbacks$2);
+    return false;
+  }
+
+  // Check HTML5 validation
+  var fieldElement = fieldRefs.current[fieldKey];
+  if (fieldElement) {
+    var input = fieldElement.querySelector("input, textarea, select");
+    if (input && !input.validity.valid) {
+      var _cellUpdateCallbacks$3, _cellUpdateCallbacks$4;
+      fieldValidationErrors.current[fieldKey] = true;
+      (_cellUpdateCallbacks$3 = (_cellUpdateCallbacks$4 = cellUpdateCallbacks.current)[fieldKey]) === null || _cellUpdateCallbacks$3 === void 0 || _cellUpdateCallbacks$3.call(_cellUpdateCallbacks$4);
+      return false;
+    }
+  }
+
+  // Mark as valid
+  fieldValidationErrors.current[fieldKey] = false;
+  (_cellUpdateCallbacks$5 = (_cellUpdateCallbacks$6 = cellUpdateCallbacks.current)[fieldKey]) === null || _cellUpdateCallbacks$5 === void 0 || _cellUpdateCallbacks$5.call(_cellUpdateCallbacks$6);
+  return true;
+};
+
+/**
+ * Resets validation state for specific context
+ */
+var resetValidationState = exports.resetValidationState = function resetValidationState(context, editingRowId, validationState) {
+  var fieldRefs = validationState.fieldRefs,
+    fieldValidationErrors = validationState.fieldValidationErrors,
+    cellUpdateCallbacks = validationState.cellUpdateCallbacks;
+  if (context === "editing" && editingRowId) {
+    // Clear only editing row fields
+    (0, _lodashEs.forEach)((0, _lodashEs.keys)(fieldRefs.current), function (key) {
+      if (key.startsWith("".concat(editingRowId, "_"))) {
+        delete fieldRefs.current[key];
+        delete fieldValidationErrors.current[key];
+        delete cellUpdateCallbacks.current[key];
+      }
+    });
+  } else if (context === "new-row") {
+    // Clear only new row fields
+    (0, _lodashEs.forEach)((0, _lodashEs.keys)(fieldRefs.current), function (key) {
+      if (key.startsWith("new-row_")) {
+        delete fieldRefs.current[key];
+        delete fieldValidationErrors.current[key];
+        delete cellUpdateCallbacks.current[key];
+      }
+    });
+  } else {
+    // Clear all
+    (0, _lodashEs.forEach)((0, _lodashEs.keys)(fieldRefs.current), function (key) {
+      delete fieldRefs.current[key];
+    });
+    fieldValidationErrors.current = {};
+    cellUpdateCallbacks.current = {};
+  }
+};
+
+/**
+ * Updates validation errors for fields based on validation results
+ */
+var updateValidationErrors = exports.updateValidationErrors = function updateValidationErrors(validationResult, relevantFieldRefs, validationState) {
+  var fieldValidationErrors = validationState.fieldValidationErrors,
+    cellUpdateCallbacks = validationState.cellUpdateCallbacks;
+
+  // Initialize all fields as valid
+  var errors = {};
+  (0, _lodashEs.forEach)((0, _lodashEs.keys)(relevantFieldRefs), function (fieldKey) {
+    errors[fieldKey] = false;
+  });
+
+  // If we have the invalidFieldKeys property, use it directly
+  if (validationResult.invalidFieldKeys && validationResult.invalidFieldKeys.length > 0) {
+    (0, _lodashEs.forEach)(validationResult.invalidFieldKeys, function (fieldKey) {
+      errors[fieldKey] = true;
+    });
+  } else {
+    // Fallback to the previous method using invalidElements
+    validationResult.invalidElements.forEach(function (invalidElement) {
+      (0, _lodashEs.forEach)((0, _lodashEs.entries)(relevantFieldRefs), function (_ref) {
+        var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+          fieldKey = _ref2[0],
+          fieldElement = _ref2[1];
+        if (fieldElement === invalidElement || fieldElement !== null && fieldElement !== void 0 && fieldElement.contains(invalidElement)) {
+          errors[fieldKey] = true;
+        }
+      });
+    });
+  }
+
+  // Update validation errors for each field key
+  (0, _lodashEs.forEach)((0, _lodashEs.entries)(errors), function (_ref3) {
+    var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
+      fieldKey = _ref4[0],
+      hasError = _ref4[1];
+    if (fieldValidationErrors.current[fieldKey] !== hasError) {
+      var _cellUpdateCallbacks$7, _cellUpdateCallbacks$8;
+      fieldValidationErrors.current[fieldKey] = hasError;
+      (_cellUpdateCallbacks$7 = (_cellUpdateCallbacks$8 = cellUpdateCallbacks.current)[fieldKey]) === null || _cellUpdateCallbacks$7 === void 0 || _cellUpdateCallbacks$7.call(_cellUpdateCallbacks$8);
+    }
+  });
+};

package/components/data/types.d.ts

@@ -0,0 +1,104 @@
+declare enum Operation {
+    LIST_RECORDS = "listRecords",
+    UPDATE_RECORD = "updateRecord",
+    INSERT_RECORD = "insertRecord",
+    DELETE_RECORD = "deleteRecord",
+    INVOKE = "invoke",
+    UPDATE = "update",
+    NOTIFY = "notify",
+    IS_API_AWARE = "isApiAware",
+    SUPPORTS_CRUD = "supportsCRUD",
+    SUPPORTS_DISTINCT_API = "supportsDistinctAPI",
+    IS_PAGEABLE = "isPageable",
+    IS_SORTABLE = "isSortable",
+    GET_OPERATION_TYPE = "getOperationType",
+    GET_RELATED_PRIMARY_KEYS = "getRelatedTablePrimaryKeys",
+    GET_ENTITY_NAME = "getEntityName",
+    SET_INPUT = "setinput",
+    GET_RELATED_TABLE_DATA = "getRelatedTableData",
+    GET_DISTINCT_DATA_BY_FIELDS = "getDistinctDataByFields",
+    GET_AGGREGATED_DATA = "getAggregatedData",
+    GET_MATCH_MODE = "getMatchMode",
+    DOWNLOAD = "download",
+    GET_NAME = "getName",
+    GET_PROPERTIES_MAP = "getPropertiesMap",
+    GET_PRIMARY_KEY = "getPrimaryKey",
+    GET_BLOB_URL = "getBlobURL",
+    SUPPORTS_SERVER_FILTER = "supportsServerFilter",
+    GET_OPTIONS = "getOptions",
+    SEARCH_RECORDS = "searchRecords",
+    GET_REQUEST_PARAMS = "getRequestParams",
+    GET_PAGING_OPTIONS = "getPagingOptions",
+    FETCH_DISTINCT_VALUES = "fetchDistinctValues",
+    GET_UNIQUE_IDENTIFIER = "getUniqueIdentifier",
+    GET_CONTEXT_IDENTIFIER = "getContextIdentifier",
+    IS_UPDATE_REQUIRED = "isUpdateRequired",
+    ADD_ITEM = "addItem",
+    SET_ITEM = "setItem",
+    REMOVE_ITEM = "removeItem",
+    IS_BOUND_TO_LOCALE = "isBoundToLocale",
+    GET_DEFAULT_LOCALE = "getDefaultLocale",
+    CANCEL = "cancel",
+    SET_PAGINATION = "setPagination"
+}
+export declare const DataSource: {
+    Operation: typeof Operation;
+};
+export declare enum MatchMode {
+    BETWEEN = "between",
+    GREATER = "greaterthanequal",
+    LESSER = "lessthanequal",
+    NULL = "null",
+    EMPTY = "empty",
+    NULLOREMPTY = "nullorempty",
+    EQUALS = "exact"
+}
+export declare enum FormWidgetType {
+    AUTOCOMPLETE = "autocomplete",
+    CHECKBOX = "checkbox",
+    CHECKBOXSET = "checkboxset",
+    CHIPS = "chips",
+    COLORPICKER = "colorpicker",
+    CURRENCY = "currency",
+    CUSTOMWIDGET = "custom-widget",
+    DATE = "date",
+    DATETIME = "datetime",
+    NUMBER = "number",
+    PASSWORD = "password",
+    RADIOSET = "radioset",
+    RATING = "rating",
+    RICHTEXT = "richtext",
+    SELECT = "select",
+    TOGGLE = "toggle",
+    SLIDER = "slider",
+    SWITCH = "switch",
+    TEXT = "text",
+    TEXTAREA = "textarea",
+    TIME = "time",
+    TIMESTAMP = "timestamp",
+    TYPEAHEAD = "typeahead",
+    UPLOAD = "upload"
+}
+export declare enum DataType {
+    INTEGER = "integer",
+    BIG_INTEGER = "big_integer",
+    SHORT = "short",
+    FLOAT = "float",
+    BIG_DECIMAL = "big_decimal",
+    DOUBLE = "double",
+    LONG = "long",
+    BYTE = "byte",
+    STRING = "string",
+    CHARACTER = "character",
+    TEXT = "text",
+    DATE = "date",
+    TIME = "time",
+    TIMESTAMP = "timestamp",
+    DATETIME = "datetime",
+    LOCALDATETIME = "localdatetime",
+    BOOLEAN = "boolean",
+    LIST = "list",
+    CLOB = "clob",
+    BLOB = "blob"
+}
+export {};

package/components/data/types.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MatchMode = exports.FormWidgetType = exports.DataType = exports.DataSource = void 0;
+var Operation = /*#__PURE__*/function (Operation) {
+  Operation["LIST_RECORDS"] = "listRecords";
+  Operation["UPDATE_RECORD"] = "updateRecord";
+  Operation["INSERT_RECORD"] = "insertRecord";
+  Operation["DELETE_RECORD"] = "deleteRecord";
+  Operation["INVOKE"] = "invoke";
+  Operation["UPDATE"] = "update";
+  Operation["NOTIFY"] = "notify";
+  Operation["IS_API_AWARE"] = "isApiAware";
+  Operation["SUPPORTS_CRUD"] = "supportsCRUD";
+  Operation["SUPPORTS_DISTINCT_API"] = "supportsDistinctAPI";
+  Operation["IS_PAGEABLE"] = "isPageable";
+  Operation["IS_SORTABLE"] = "isSortable";
+  Operation["GET_OPERATION_TYPE"] = "getOperationType";
+  Operation["GET_RELATED_PRIMARY_KEYS"] = "getRelatedTablePrimaryKeys";
+  Operation["GET_ENTITY_NAME"] = "getEntityName";
+  Operation["SET_INPUT"] = "setinput";
+  Operation["GET_RELATED_TABLE_DATA"] = "getRelatedTableData";
+  Operation["GET_DISTINCT_DATA_BY_FIELDS"] = "getDistinctDataByFields";
+  Operation["GET_AGGREGATED_DATA"] = "getAggregatedData";
+  Operation["GET_MATCH_MODE"] = "getMatchMode";
+  Operation["DOWNLOAD"] = "download";
+  Operation["GET_NAME"] = "getName";
+  Operation["GET_PROPERTIES_MAP"] = "getPropertiesMap";
+  Operation["GET_PRIMARY_KEY"] = "getPrimaryKey";
+  Operation["GET_BLOB_URL"] = "getBlobURL";
+  Operation["SUPPORTS_SERVER_FILTER"] = "supportsServerFilter";
+  Operation["GET_OPTIONS"] = "getOptions";
+  Operation["SEARCH_RECORDS"] = "searchRecords";
+  Operation["GET_REQUEST_PARAMS"] = "getRequestParams";
+  Operation["GET_PAGING_OPTIONS"] = "getPagingOptions";
+  Operation["FETCH_DISTINCT_VALUES"] = "fetchDistinctValues";
+  Operation["GET_UNIQUE_IDENTIFIER"] = "getUniqueIdentifier";
+  Operation["GET_CONTEXT_IDENTIFIER"] = "getContextIdentifier";
+  Operation["IS_UPDATE_REQUIRED"] = "isUpdateRequired";
+  Operation["ADD_ITEM"] = "addItem";
+  Operation["SET_ITEM"] = "setItem";
+  Operation["REMOVE_ITEM"] = "removeItem";
+  Operation["IS_BOUND_TO_LOCALE"] = "isBoundToLocale";
+  Operation["GET_DEFAULT_LOCALE"] = "getDefaultLocale";
+  Operation["CANCEL"] = "cancel";
+  Operation["SET_PAGINATION"] = "setPagination";
+  return Operation;
+}(Operation || {});
+var DataSource = exports.DataSource = {
+  Operation: Operation
+};
+var MatchMode = exports.MatchMode = /*#__PURE__*/function (MatchMode) {
+  MatchMode["BETWEEN"] = "between";
+  MatchMode["GREATER"] = "greaterthanequal";
+  MatchMode["LESSER"] = "lessthanequal";
+  MatchMode["NULL"] = "null";
+  MatchMode["EMPTY"] = "empty";
+  MatchMode["NULLOREMPTY"] = "nullorempty";
+  MatchMode["EQUALS"] = "exact";
+  return MatchMode;
+}({});
+var FormWidgetType = exports.FormWidgetType = /*#__PURE__*/function (FormWidgetType) {
+  FormWidgetType["AUTOCOMPLETE"] = "autocomplete";
+  FormWidgetType["CHECKBOX"] = "checkbox";
+  FormWidgetType["CHECKBOXSET"] = "checkboxset";
+  FormWidgetType["CHIPS"] = "chips";
+  FormWidgetType["COLORPICKER"] = "colorpicker";
+  FormWidgetType["CURRENCY"] = "currency";
+  FormWidgetType["CUSTOMWIDGET"] = "custom-widget";
+  FormWidgetType["DATE"] = "date";
+  FormWidgetType["DATETIME"] = "datetime";
+  FormWidgetType["NUMBER"] = "number";
+  FormWidgetType["PASSWORD"] = "password";
+  FormWidgetType["RADIOSET"] = "radioset";
+  FormWidgetType["RATING"] = "rating";
+  FormWidgetType["RICHTEXT"] = "richtext";
+  FormWidgetType["SELECT"] = "select";
+  FormWidgetType["TOGGLE"] = "toggle";
+  FormWidgetType["SLIDER"] = "slider";
+  FormWidgetType["SWITCH"] = "switch";
+  FormWidgetType["TEXT"] = "text";
+  FormWidgetType["TEXTAREA"] = "textarea";
+  FormWidgetType["TIME"] = "time";
+  FormWidgetType["TIMESTAMP"] = "timestamp";
+  FormWidgetType["TYPEAHEAD"] = "typeahead";
+  FormWidgetType["UPLOAD"] = "upload";
+  return FormWidgetType;
+}({});
+var DataType = exports.DataType = /*#__PURE__*/function (DataType) {
+  DataType["INTEGER"] = "integer";
+  DataType["BIG_INTEGER"] = "big_integer";
+  DataType["SHORT"] = "short";
+  DataType["FLOAT"] = "float";
+  DataType["BIG_DECIMAL"] = "big_decimal";
+  DataType["DOUBLE"] = "double";
+  DataType["LONG"] = "long";
+  DataType["BYTE"] = "byte";
+  DataType["STRING"] = "string";
+  DataType["CHARACTER"] = "character";
+  DataType["TEXT"] = "text";
+  DataType["DATE"] = "date";
+  DataType["TIME"] = "time";
+  DataType["TIMESTAMP"] = "timestamp";
+  DataType["DATETIME"] = "datetime";
+  DataType["LOCALDATETIME"] = "localdatetime";
+  DataType["BOOLEAN"] = "boolean";
+  DataType["LIST"] = "list";
+  DataType["CLOB"] = "clob";
+  DataType["BLOB"] = "blob";
+  return DataType;
+}({});

package/components/data/utils/field-data-utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check if widget type is a dataset widget (similar to isDataSetWidget in Angular)
+ */
+export declare const isDataSetWidget: (widgettype: string) => boolean;
+export declare const getDistinctFieldProperties: (dataSource: any, formField: any) => any;
+export declare function getDistinctValues(dataSource: any, formField: any, widget: any): Promise<unknown>;
+export declare function isSearchWidgetType(widget: string): boolean;

package/components/data/utils/field-data-utils.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDistinctFieldProperties = void 0;
+exports.getDistinctValues = getDistinctValues;
+exports.isDataSetWidget = void 0;
+exports.isSearchWidgetType = isSearchWidgetType;
+var _types = require("../types");
+var _lodashEs = require("lodash-es");
+var DATASET_WIDGETS = ["select", "autocomplete", "typeahead", "chips", "checkboxset", "radioset", "rating", "switch"];
+
+/**
+ * Check if widget type is a dataset widget (similar to isDataSetWidget in Angular)
+ */
+var isDataSetWidget = exports.isDataSetWidget = function isDataSetWidget(widgettype) {
+  return DATASET_WIDGETS.includes(widgettype === null || widgettype === void 0 ? void 0 : widgettype.toLowerCase());
+};
+var getDistinctFieldProperties = exports.getDistinctFieldProperties = function getDistinctFieldProperties(dataSource, formField) {
+  var props = {};
+  var fieldColumn;
+  if (formField["isRelated"]) {
+    var _fieldColumn;
+    props.tableName = formField["lookup-type"];
+    fieldColumn = formField["lookup-field"];
+    props.distinctField = fieldColumn;
+    props.aliasColumn = (_fieldColumn = fieldColumn) === null || _fieldColumn === void 0 ? void 0 : _fieldColumn.replace(".", "$"); // For related fields, In response . is replaced by $
+    props.filterExpr = formField.filterexpressions ? (0, _lodashEs.isObject)(formField.filterexpressions) ? formField.filterexpressions : JSON.parse(formField.filterexpressions) : {};
+  } else {
+    props.tableName = dataSource.execute(_types.DataSource.Operation.GET_ENTITY_NAME);
+    fieldColumn = formField["fieldcol"] || formField.key;
+    props.distinctField = fieldColumn;
+    props.aliasColumn = fieldColumn;
+  }
+  return props;
+};
+function getDistinctValues(dataSource, formField, widget) {
+  var props;
+  return new Promise(function (res, rej) {
+    if (isDataSetWidget(formField.widget) && (!formField.isDataSetBound || widget === "filterwidget")) {
+      props = getDistinctFieldProperties(dataSource, formField);
+      dataSource.execute(_types.DataSource.Operation.GET_DISTINCT_DATA_BY_FIELDS, {
+        fields: props.distinctField,
+        entityName: props.tableName,
+        pagesize: formField.limit,
+        filterExpr: formField.filterexpressions ? JSON.parse(formField.filterexpressions) : {}
+      }).then(function (response) {
+        res({
+          field: formField,
+          data: response.data,
+          aliasColumn: props.aliasColumn
+        });
+      }, rej)["catch"](function (error) {
+        rej({
+          field: formField,
+          data: [],
+          aliasColumn: props.aliasColumn
+        });
+      });
+    }
+  });
+}
+function isSearchWidgetType(widget) {
+  return (0, _lodashEs.includes)([_types.FormWidgetType.AUTOCOMPLETE, _types.FormWidgetType.TYPEAHEAD, _types.FormWidgetType.CHIPS], widget);
+}

package/components/data/utils/filter-field-util.d.ts

@@ -0,0 +1,13 @@
+export declare const LIVE_CONSTANTS: {
+    EMPTY_KEY: string;
+    EMPTY_VALUE: string;
+    LABEL_KEY: string;
+    LABEL_VALUE: string;
+    NULL_EMPTY: string[];
+    NULL: string;
+    EMPTY: string;
+};
+export declare const stringStartsWith: (str: string, startsWith: string, ignoreCase?: boolean) => boolean;
+export declare function interpolateBindExpressions(context: any, filterexpressions: any, callbackFn: any): void;
+export declare const processFilterExpBindNode: (context: any, filterExpressions: any, variable?: any) => any;
+export declare function getDistinctValuesForField(dataSource: any, formField: any, options: any): void;

package/components/data/utils/filter-field-util.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LIVE_CONSTANTS = void 0;
+exports.getDistinctValuesForField = getDistinctValuesForField;
+exports.interpolateBindExpressions = interpolateBindExpressions;
+exports.stringStartsWith = exports.processFilterExpBindNode = void 0;
+var _lodashEs = require("lodash-es");
+var _fieldDataUtils = require("./field-data-utils");
+var _ = require("./");
+var LIVE_CONSTANTS = exports.LIVE_CONSTANTS = {
+  EMPTY_KEY: "EMPTY_NULL_FILTER",
+  EMPTY_VALUE: "No Value",
+  LABEL_KEY: "key",
+  LABEL_VALUE: "value",
+  NULL_EMPTY: ["null", "empty"],
+  NULL: "null",
+  EMPTY: "empty"
+};
+var stringStartsWith = exports.stringStartsWith = function stringStartsWith(str, startsWith, ignoreCase) {
+  if (!str) {
+    return false;
+  }
+  var regEx = new RegExp("^" + startsWith, ignoreCase ? "i" : "");
+  return regEx.test(str);
+};
+function interpolateBindExpressions(context, filterexpressions, callbackFn) {
+  var debouncedFn = (0, _lodashEs.debounce)(function () {
+    if ((0, _lodashEs.isFunction)(callbackFn)) {
+      callbackFn(filterexpressions);
+    }
+  }, 300);
+
+  // Call initially for expressions without bound variables
+  debouncedFn();
+  var filterExpressions = filterexpressions ? (0, _lodashEs.isObject)(filterexpressions) ? filterexpressions : JSON.parse(filterexpressions) : {};
+
+  // Just setup the bindings - no subscription needed
+  processFilterExpBindNode(context, filterExpressions);
+  // The filterExpressions object will be mutated directly by the watchers
+  // No need for subscription since changes happen in-place
+}
+var processFilterExpBindNode = exports.processFilterExpBindNode = function processFilterExpBindNode(context, filterExpressions, variable) {
+  var _traverseFilterExpressions = function traverseFilterExpressions(expressions) {
+    if (expressions.rules) {
+      (0, _lodashEs.forEach)(expressions.rules, function (filExpObj, i) {
+        if (filExpObj.rules) {
+          _traverseFilterExpressions(filExpObj);
+        }
+      });
+    }
+  };
+  _traverseFilterExpressions(filterExpressions);
+
+  // Return the mutated filterExpressions or nothing
+  return filterExpressions;
+};
+function getDistinctValuesForField(dataSource, formField, options) {
+  if (!dataSource || !formField || formField.isDataSetBound) {
+    return;
+  }
+  if ((0, _fieldDataUtils.isSearchWidgetType)(formField[options.widget])) {
+    var dataoptions = (0, _fieldDataUtils.getDistinctFieldProperties)(dataSource, formField);
+    formField.dataoptions = dataoptions;
+    formField.setFieldDataSet(formField, Object.assign(options || {}, dataoptions));
+  } else {
+    interpolateBindExpressions(formField.viewParent, formField.filterexpressions, function (filterexpressions) {
+      formField.filterexpressions = filterexpressions;
+      (0, _fieldDataUtils.getDistinctValues)(dataSource, formField, options.widget).then(function (res) {
+        formField.setFieldDataSet(res.data, {
+          aliasColumn: res.aliasColumn,
+          widget: options.widget,
+          isEnableEmptyFilter: (0, _.getEnableEmptyFilter)(options.enableemptyfilter),
+          EMPTY_VALUE: options.EMPTY_VALUE
+        });
+      });
+    });
+  }
+}

package/components/data/utils/index.d.ts

@@ -0,0 +1,90 @@
+export declare const LIVE_CONSTANTS: {
+    EMPTY_KEY: string;
+    EMPTY_VALUE: string;
+    LABEL_KEY: string;
+    LABEL_VALUE: string;
+    NULL_EMPTY: string[];
+    NULL: string;
+    EMPTY: string;
+};
+export declare function findOperationType(formdata: any, primaryKeys?: string[]): any;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getRangeFieldValue
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to get the field value for range
+ *
+ * @param {string} minValue min value selected
+ * @param {string} maxValue max value selected
+ */
+export declare function getRangeFieldValue(minValue: string, maxValue: string): any;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getRangeMatchMode
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to get the match mode for range
+ *
+ * @param {string} minValue min value selected
+ * @param {string} maxValue max value selected
+ */
+export declare function getRangeMatchMode(minValue: string, maxValue: string): any;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getEnableEmptyFilter
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * This function checks if enable filter options is set on live filter
+ *
+ * @param {object} enableemptyfilter empty filter options
+ */
+export declare function getEnableEmptyFilter(enableemptyfilter: string): boolean;
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getEmptyMatchMode
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to get the match mode based on the filter selected
+ *
+ * @param {object} enableemptyfilter empty filter options
+ */
+export declare function getEmptyMatchMode(enableemptyfilter: string): any;
+export declare const getMatchModeTypesMap: (multiMode?: string) => {
+    boolean: string[];
+    clob: any[];
+    blob: any[];
+};
+export declare const getMatchModeMsgs: (appLocale: any) => {
+    start: any;
+    startignorecase: any;
+    end: any;
+    endignorecase: any;
+    anywhere: any;
+    anywhereignorecase: any;
+    exact: any;
+    exactignorecase: any;
+    notequals: any;
+    notequalsignorecase: any;
+    lessthan: any;
+    lessthanequal: any;
+    greaterthan: any;
+    greaterthanequal: any;
+    null: any;
+    isnotnull: any;
+    empty: any;
+    isnotempty: any;
+    nullorempty: any;
+    in: any;
+    notin: any;
+    between: any;
+};
+export declare const unsupportedStatePersistenceTypes: string[];