@wavemaker-ai/react-runtime 1.0.0-next.27766

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

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,62 @@
+import { DataSource, FormWidgetType } from "../types";
+import { includes, isObject } from "lodash-es";
+const DATASET_WIDGETS = [
+  "select",
+  "autocomplete",
+  "typeahead",
+  "chips",
+  "checkboxset",
+  "radioset",
+  "rating",
+  "switch"
+];
+const isDataSetWidget = (widgettype) => {
+  return DATASET_WIDGETS.includes(widgettype == null ? void 0 : widgettype.toLowerCase());
+};
+const getDistinctFieldProperties = (dataSource, formField) => {
+  const props = {};
+  let fieldColumn;
+  if (formField["isRelated"]) {
+    props.tableName = formField["lookup-type"];
+    fieldColumn = formField["lookup-field"];
+    props.distinctField = fieldColumn;
+    props.aliasColumn = fieldColumn == null ? void 0 : fieldColumn.replace(".", "$");
+    props.filterExpr = formField.filterexpressions ? isObject(formField.filterexpressions) ? formField.filterexpressions : JSON.parse(formField.filterexpressions) : {};
+  } else {
+    props.tableName = dataSource.execute(DataSource.Operation.GET_ENTITY_NAME);
+    fieldColumn = formField["fieldcol"] || formField.key;
+    props.distinctField = fieldColumn;
+    props.aliasColumn = fieldColumn;
+  }
+  return props;
+};
+function getDistinctValues(dataSource, formField, widget) {
+  let props;
+  return new Promise((res, rej) => {
+    if (isDataSetWidget(formField.widget) && (!formField.isDataSetBound || widget === "filterwidget")) {
+      props = getDistinctFieldProperties(dataSource, formField);
+      dataSource.execute(DataSource.Operation.GET_DISTINCT_DATA_BY_FIELDS, {
+        fields: props.distinctField,
+        entityName: props.tableName,
+        pagesize: formField.limit,
+        filterExpr: formField.filterexpressions ? JSON.parse(formField.filterexpressions) : {}
+      }).then((response) => {
+        res({ field: formField, data: response.data, aliasColumn: props.aliasColumn });
+      }, rej).catch((error) => {
+        rej({ field: formField, data: [], aliasColumn: props.aliasColumn });
+      });
+    }
+  });
+}
+function isSearchWidgetType(widget) {
+  return includes(
+    [FormWidgetType.AUTOCOMPLETE, FormWidgetType.TYPEAHEAD, FormWidgetType.CHIPS],
+    widget
+  );
+}
+export {
+  getDistinctFieldProperties,
+  getDistinctValues,
+  isDataSetWidget,
+  isSearchWidgetType
+};

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,79 @@
+import { forEach, isFunction, isObject, debounce } from "lodash-es";
+import {
+  getDistinctFieldProperties,
+  getDistinctValues,
+  isSearchWidgetType
+} from "./field-data-utils";
+import { getEnableEmptyFilter } from "./";
+const 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"
+};
+const stringStartsWith = (str, startsWith, ignoreCase) => {
+  if (!str) {
+    return false;
+  }
+  const regEx = new RegExp("^" + startsWith, ignoreCase ? "i" : "");
+  return regEx.test(str);
+};
+function interpolateBindExpressions(context, filterexpressions, callbackFn) {
+  const debouncedFn = debounce(() => {
+    if (isFunction(callbackFn)) {
+      callbackFn(filterexpressions);
+    }
+  }, 300);
+  debouncedFn();
+  const filterExpressions = filterexpressions ? isObject(filterexpressions) ? filterexpressions : JSON.parse(filterexpressions) : {};
+  processFilterExpBindNode(context, filterExpressions);
+}
+const processFilterExpBindNode = (context, filterExpressions, variable) => {
+  const traverseFilterExpressions = (expressions) => {
+    if (expressions.rules) {
+      forEach(expressions.rules, (filExpObj, i) => {
+        if (filExpObj.rules) {
+          traverseFilterExpressions(filExpObj);
+        }
+      });
+    }
+  };
+  traverseFilterExpressions(filterExpressions);
+  return filterExpressions;
+};
+function getDistinctValuesForField(dataSource, formField, options) {
+  if (!dataSource || !formField || formField.isDataSetBound) {
+    return;
+  }
+  if (isSearchWidgetType(formField[options.widget])) {
+    const dataoptions = getDistinctFieldProperties(dataSource, formField);
+    formField.dataoptions = dataoptions;
+    formField.setFieldDataSet(formField, Object.assign(options || {}, dataoptions));
+  } else {
+    interpolateBindExpressions(
+      formField.viewParent,
+      formField.filterexpressions,
+      (filterexpressions) => {
+        formField.filterexpressions = filterexpressions;
+        getDistinctValues(dataSource, formField, options.widget).then((res) => {
+          formField.setFieldDataSet(res.data, {
+            aliasColumn: res.aliasColumn,
+            widget: options.widget,
+            isEnableEmptyFilter: getEnableEmptyFilter(options.enableemptyfilter),
+            EMPTY_VALUE: options.EMPTY_VALUE
+          });
+        });
+      }
+    );
+  }
+}
+export {
+  LIVE_CONSTANTS,
+  getDistinctValuesForField,
+  interpolateBindExpressions,
+  processFilterExpBindNode,
+  stringStartsWith
+};

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[];

package/components/data/utils/index.js

@@ -0,0 +1,217 @@
+import { isEmpty, forEach, some, intersection, includes, split } from "lodash-es";
+import { MatchMode } from "../types";
+import { isDefined } from "../../../core/util";
+const Live_Operations = {
+  INSERT: "insert",
+  UPDATE: "update",
+  DELETE: "delete",
+  READ: "read"
+};
+const 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"
+};
+function findOperationType(formdata, primaryKeys) {
+  let operation;
+  let isPrimary = false;
+  if (primaryKeys && !isEmpty(formdata)) {
+    if (primaryKeys.length === 1) {
+      if (formdata[primaryKeys[0]]) {
+        operation = Live_Operations.UPDATE;
+      }
+    } else if (primaryKeys.length === 0) {
+      forEach(formdata, (value) => {
+        if (value) {
+          isPrimary = true;
+        }
+      });
+      if (isPrimary) {
+        operation = Live_Operations.UPDATE;
+      }
+    } else {
+      isPrimary = some(primaryKeys, (primaryKey) => {
+        if (formdata[primaryKey]) {
+          return true;
+        }
+      });
+      if (isPrimary) {
+        operation = Live_Operations.UPDATE;
+      }
+    }
+  }
+  return operation || Live_Operations.INSERT;
+}
+function isDefinedAndNotEmpty(val) {
+  return isDefined(val) && val !== "" && val !== null;
+}
+function getRangeFieldValue(minValue, maxValue) {
+  let fieldValue;
+  if (isDefinedAndNotEmpty(minValue) && isDefinedAndNotEmpty(maxValue)) {
+    fieldValue = [minValue, maxValue];
+  } else if (isDefinedAndNotEmpty(minValue)) {
+    fieldValue = minValue;
+  } else if (isDefinedAndNotEmpty(maxValue)) {
+    fieldValue = maxValue;
+  }
+  return fieldValue;
+}
+function getRangeMatchMode(minValue, maxValue) {
+  let matchMode;
+  if (isDefinedAndNotEmpty(minValue) && isDefinedAndNotEmpty(maxValue)) {
+    matchMode = MatchMode.BETWEEN;
+  } else if (isDefinedAndNotEmpty(minValue)) {
+    matchMode = MatchMode.GREATER;
+  } else if (isDefinedAndNotEmpty(maxValue)) {
+    matchMode = MatchMode.LESSER;
+  }
+  return matchMode;
+}
+function getEnableEmptyFilter(enableemptyfilter) {
+  return enableemptyfilter && intersection(enableemptyfilter.split(","), LIVE_CONSTANTS.NULL_EMPTY).length > 0;
+}
+function getEmptyMatchMode(enableemptyfilter) {
+  let matchMode;
+  const emptyFilterOptions = split(enableemptyfilter, ",");
+  if (intersection(emptyFilterOptions, LIVE_CONSTANTS.NULL_EMPTY).length === 2) {
+    matchMode = MatchMode.NULLOREMPTY;
+  } else if (includes(emptyFilterOptions, LIVE_CONSTANTS.NULL)) {
+    matchMode = MatchMode.NULL;
+  } else if (includes(emptyFilterOptions, LIVE_CONSTANTS.EMPTY)) {
+    matchMode = MatchMode.EMPTY;
+  }
+  return matchMode;
+}
+const typesMap = {
+  number: [
+    "number",
+    "integer",
+    "big_integer",
+    "short",
+    "float",
+    "big_decimal",
+    "double",
+    "long",
+    "byte"
+  ],
+  string: ["string", "text"],
+  character: ["character"],
+  date: ["date", "time", "timestamp", "datetime"]
+};
+const modes = {
+  number: [
+    "exact",
+    "notequals",
+    "lessthan",
+    "lessthanequal",
+    "greaterthan",
+    "greaterthanequal",
+    "null",
+    "isnotnull"
+  ],
+  string: [
+    "anywhereignorecase",
+    "anywhere",
+    "startignorecase",
+    "start",
+    "endignorecase",
+    "end",
+    "exactignorecase",
+    "exact",
+    "notequalsignorecase",
+    "notequals",
+    "null",
+    "isnotnull",
+    "empty",
+    "isnotempty",
+    "nullorempty"
+  ],
+  character: [
+    "exactignorecase",
+    "exact",
+    "notequalsignorecase",
+    "notequals",
+    "null",
+    "isnotnull",
+    "empty",
+    "isnotempty",
+    "nullorempty"
+  ],
+  date: [
+    "exact",
+    "lessthan",
+    "lessthanequal",
+    "greaterthan",
+    "greaterthanequal",
+    "null",
+    "notequals",
+    "isnotnull"
+  ]
+};
+const matchModeTypesMap = {
+  boolean: ["exact", "null", "isnotnull"],
+  clob: [],
+  blob: []
+};
+const getMatchModeTypesMap = (multiMode) => {
+  if (multiMode) {
+    modes.number.push("in", "notin", "between");
+    modes.date.push("between");
+    modes.string.push("in", "notin");
+    modes.character.push("in", "notin");
+  }
+  forEach(typesMap, (types, primType) => {
+    forEach(types, (type) => {
+      matchModeTypesMap[type] = modes[primType];
+    });
+  });
+  matchModeTypesMap["default"] = [
+    ...modes["number"],
+    ...modes["string"],
+    ...modes["character"],
+    ...modes["date"]
+  ];
+  return matchModeTypesMap;
+};
+const getMatchModeMsgs = (appLocale) => {
+  return {
+    start: appLocale.LABEL_STARTS_WITH,
+    startignorecase: appLocale.LABEL_STARTS_WITH_IGNORECASE,
+    end: appLocale.LABEL_ENDS_WITH,
+    endignorecase: appLocale.LABEL_ENDS_WITH_IGNORECASE,
+    anywhere: appLocale.LABEL_CONTAINS,
+    anywhereignorecase: appLocale.LABEL_CONTAINS_IGNORECASE,
+    exact: appLocale.LABEL_IS_EQUAL_TO,
+    exactignorecase: appLocale.LABEL_IS_EQUAL_TO_IGNORECASE,
+    notequals: appLocale.LABEL_IS_NOT_EQUAL_TO,
+    notequalsignorecase: appLocale.LABEL_IS_NOT_EQUAL_TO_IGNORECASE,
+    lessthan: appLocale.LABEL_LESS_THAN,
+    lessthanequal: appLocale.LABEL_LESS_THAN_OR_EQUALS_TO,
+    greaterthan: appLocale.LABEL_GREATER_THAN,
+    greaterthanequal: appLocale.LABEL_GREATER_THAN_OR_EQUALS_TO,
+    null: appLocale.LABEL_IS_NULL,
+    isnotnull: appLocale.LABEL_IS_NOT_NULL,
+    empty: appLocale.LABEL_IS_EMPTY,
+    isnotempty: appLocale.LABEL_IS_NOT_EMPTY,
+    nullorempty: appLocale.LABEL_IS_NULL_OR_EMPTY,
+    in: appLocale.LABEL_IN,
+    notin: appLocale.LABEL_NOT_IN,
+    between: appLocale.LABEL_BETWEEN
+  };
+};
+const unsupportedStatePersistenceTypes = ["On-Demand", "Scroll"];
+export {
+  LIVE_CONSTANTS,
+  findOperationType,
+  getEmptyMatchMode,
+  getEnableEmptyFilter,
+  getMatchModeMsgs,
+  getMatchModeTypesMap,
+  getRangeFieldValue,
+  getRangeMatchMode,
+  unsupportedStatePersistenceTypes
+};