@deephaven/jsapi-utils 0.42.1-beta.2 → 0.43.0

package/dist/TableUtils.js

@@ -1,1367 +0,0 @@
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-import { Type as FilterType, Operator as FilterOperator } from '@deephaven/filters';
-import Log from '@deephaven/log';
-import { PromiseUtils, TextUtils, TimeoutError } from '@deephaven/utils';
-import DateUtils from "./DateUtils.js";
-var log = Log.module('TableUtils');
-/** Utility class to provide some functions for working with tables */
-export class TableUtils {
-  // Regex looking for a negative or positive integer or decimal number
-
-  /**
-   * Executes a callback on a given table and returns a Promise that will resolve
-   * the next time a particular event type fires on the table.
-   * @param exec Callback function to execute.
-   * @param table Table that gets passed to the `exec` function and that is
-   * subscribed to for a given `eventType`.
-   * @param eventType The event type to listen for.
-   * @param timeout If the event doesn't fire within the timeout, the returned
-   * Promise will be rejected.
-   * @returns a Promise to the original table that resolves on next `eventType`
-   * event
-   */
-
-  static getSortIndex(sort, columnName) {
-    for (var i = 0; i < sort.length; i += 1) {
-      var _s$column;
-      var s = sort[i];
-      if (((_s$column = s.column) === null || _s$column === void 0 ? void 0 : _s$column.name) === columnName) {
-        return i;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * @param tableSort The sorts from the table to get the sort from
-   * @param columnName The name of the column to get the sort for
-   * @returns The sort for the column, or null if it's not sorted
-   */
-  static getSortForColumn(tableSort, columnName) {
-    var sortIndex = TableUtils.getSortIndex(tableSort, columnName);
-    if (sortIndex != null) {
-      return tableSort[sortIndex];
-    }
-    return null;
-  }
-  static getFilterText(filter) {
-    if (filter) {
-      return filter.toString();
-    }
-    return null;
-  }
-
-  /** Return the valid filter types for the column */
-  static getFilterTypes(columnType) {
-    if (TableUtils.isBooleanType(columnType)) {
-      return [FilterType.isTrue, FilterType.isFalse, FilterType.isNull];
-    }
-    if (TableUtils.isCharType(columnType) || TableUtils.isNumberType(columnType) || TableUtils.isDateType(columnType)) {
-      return [FilterType.eq, FilterType.notEq, FilterType.greaterThan, FilterType.greaterThanOrEqualTo, FilterType.lessThan, FilterType.lessThanOrEqualTo];
-    }
-    if (TableUtils.isTextType(columnType)) {
-      return [FilterType.eq, FilterType.eqIgnoreCase, FilterType.notEq, FilterType.notEqIgnoreCase, FilterType.contains, FilterType.notContains, FilterType.startsWith, FilterType.endsWith];
-    }
-    return [];
-  }
-  static getNextSort(columns, sorts, columnIndex) {
-    if (columnIndex < 0 || columnIndex >= columns.length) {
-      return null;
-    }
-    var sort = TableUtils.getSortForColumn(sorts, columns[columnIndex].name);
-    if (sort === null) {
-      return columns[columnIndex].sort().asc();
-    }
-    if (sort.direction === TableUtils.sortDirection.ascending) {
-      return sort.desc();
-    }
-    return null;
-  }
-  static makeColumnSort(columns, columnIndex, direction, isAbs) {
-    if (columnIndex < 0 || columnIndex >= columns.length) {
-      return null;
-    }
-    if (direction === TableUtils.sortDirection.none) {
-      return null;
-    }
-    var sort = columns[columnIndex].sort();
-    switch (direction) {
-      case TableUtils.sortDirection.ascending:
-        sort = sort.asc();
-        break;
-      case TableUtils.sortDirection.descending:
-        sort = sort.desc();
-        break;
-      default:
-        break;
-    }
-    if (isAbs) {
-      sort = sort.abs();
-    }
-    return sort;
-  }
-
-  /**
-   * Toggles the sort for the specified column
-   * @param sorts The current sorts from IrisGrid.state
-   * @param columns The columns to apply the sort to
-   * @param columnIndex The column index to apply the sort to
-   * @param addToExisting Add this sort to the existing sort
-   */
-  static toggleSortForColumn(sorts, columns, columnIndex) {
-    var addToExisting = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-    if (columnIndex < 0 || columnIndex >= columns.length) {
-      return [];
-    }
-    var newSort = TableUtils.getNextSort(columns, sorts, columnIndex);
-    return TableUtils.setSortForColumn(sorts, columns[columnIndex].name, newSort, addToExisting);
-  }
-  static sortColumn(sorts, columns, modelColumn, direction, isAbs, addToExisting) {
-    if (modelColumn < 0 || modelColumn >= columns.length) {
-      return [];
-    }
-    var newSort = TableUtils.makeColumnSort(columns, modelColumn, direction, isAbs);
-    return TableUtils.setSortForColumn(sorts, columns[modelColumn].name, newSort, addToExisting);
-  }
-
-  /**
-   * Sets the sort for the given column *and* removes any reverses
-   * @param tableSort The current sorts from IrisGrid.state
-   * @param columnName The column name to apply the sort to
-   * @param sort The sort object to add
-   * @param addToExisting Add this sort to the existing sort
-   * @returns Returns the modified array of sorts - removing reverses
-   */
-  static setSortForColumn(tableSort, columnName, sort) {
-    var addToExisting = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-    var sortIndex = TableUtils.getSortIndex(tableSort, columnName);
-    var sorts = [];
-    if (addToExisting) {
-      sorts = sorts.concat(tableSort.filter(_ref => {
-        var {
-          direction
-        } = _ref;
-        return direction !== TableUtils.sortDirection.reverse;
-      }));
-      if (sortIndex !== null) {
-        sorts.splice(sortIndex, 1);
-      }
-    }
-    if (sort !== null) {
-      sorts.push(sort);
-    }
-    return sorts;
-  }
-  static getNormalizedType(columnType) {
-    switch (columnType) {
-      case 'boolean':
-      case 'java.lang.Boolean':
-      case TableUtils.dataType.BOOLEAN:
-        return TableUtils.dataType.BOOLEAN;
-      case 'char':
-      case 'java.lang.Character':
-      case TableUtils.dataType.CHAR:
-        return TableUtils.dataType.CHAR;
-      case 'java.lang.String':
-      case TableUtils.dataType.STRING:
-        return TableUtils.dataType.STRING;
-      case 'io.deephaven.db.tables.utils.DBDateTime':
-      case 'io.deephaven.time.DateTime':
-      case 'com.illumon.iris.db.tables.utils.DBDateTime':
-      case 'java.time.Instant':
-      case 'java.time.ZonedDateTime':
-      case TableUtils.dataType.DATETIME:
-        return TableUtils.dataType.DATETIME;
-      case 'double':
-      case 'java.lang.Double':
-      case 'float':
-      case 'java.lang.Float':
-      case 'java.math.BigDecimal':
-      case TableUtils.dataType.DECIMAL:
-        return TableUtils.dataType.DECIMAL;
-      case 'int':
-      case 'java.lang.Integer':
-      case 'long':
-      case 'java.lang.Long':
-      case 'short':
-      case 'java.lang.Short':
-      case 'byte':
-      case 'java.lang.Byte':
-      case 'java.math.BigInteger':
-      case TableUtils.dataType.INT:
-        return TableUtils.dataType.INT;
-      default:
-        return TableUtils.dataType.UNKNOWN;
-    }
-  }
-  static isLongType(columnType) {
-    switch (columnType) {
-      case 'long':
-      case 'java.lang.Long':
-        return true;
-      default:
-        return false;
-    }
-  }
-  static isDateType(columnType) {
-    switch (columnType) {
-      case 'io.deephaven.db.tables.utils.DBDateTime':
-      case 'io.deephaven.time.DateTime':
-      case 'java.time.Instant':
-      case 'java.time.ZonedDateTime':
-      case 'com.illumon.iris.db.tables.utils.DBDateTime':
-        return true;
-      default:
-        return false;
-    }
-  }
-  static isNumberType(columnType) {
-    return TableUtils.isIntegerType(columnType) || TableUtils.isDecimalType(columnType);
-  }
-  static isIntegerType(columnType) {
-    switch (columnType) {
-      case 'int':
-      case 'java.lang.Integer':
-      case 'java.math.BigInteger':
-      case 'long':
-      case 'java.lang.Long':
-      case 'short':
-      case 'java.lang.Short':
-      case 'byte':
-      case 'java.lang.Byte':
-        return true;
-      default:
-        return false;
-    }
-  }
-  static isDecimalType(columnType) {
-    switch (columnType) {
-      case 'double':
-      case 'java.lang.Double':
-      case 'java.math.BigDecimal':
-      case 'float':
-      case 'java.lang.Float':
-        return true;
-      default:
-        return false;
-    }
-  }
-  static isBigDecimalType(columnType) {
-    switch (columnType) {
-      case 'java.math.BigDecimal':
-        return true;
-      default:
-        return false;
-    }
-  }
-  static isBigIntegerType(columnType) {
-    switch (columnType) {
-      case 'java.math.BigInteger':
-        return true;
-      default:
-        return false;
-    }
-  }
-  static isBooleanType(columnType) {
-    switch (columnType) {
-      case 'boolean':
-      case 'java.lang.Boolean':
-        return true;
-      default:
-        return false;
-    }
-  }
-  static isCharType(columnType) {
-    switch (columnType) {
-      case 'char':
-      case 'java.lang.Character':
-        return true;
-      default:
-        return false;
-    }
-  }
-  static isStringType(columnType) {
-    switch (columnType) {
-      case 'java.lang.String':
-        return true;
-      default:
-        return false;
-    }
-  }
-  static isTextType(columnType) {
-    return this.isStringType(columnType) || this.isCharType(columnType);
-  }
-
-  /**
-   * Get base column type
-   * @param columnType Column type
-   * @returns Element type for array columns, original type for non-array columns
-   */
-  static getBaseType(columnType) {
-    return columnType.split('[]')[0];
-  }
-
-  /**
-   * Check if the column types are compatible
-   * @param type1 Column type to check
-   * @param type2 Column type to check
-   * @returns True, if types are compatible
-   */
-  static isCompatibleType(type1, type2) {
-    return TableUtils.getNormalizedType(type1) === TableUtils.getNormalizedType(type2);
-  }
-
-  /**
-   * Adds quotes to a value if they're not already added
-   * @param value Value to add quotes around
-   */
-  static quoteValue(value) {
-    if (value.length >= 2 && (value.charAt(0) === '"' && value.charAt(value.length - 1) === '"' || value.charAt(0) === "'" && value.charAt(value.length - 1) === "'")) {
-      return value;
-    }
-    return "\"".concat(value, "\"");
-  }
-  static isRangeOperation(operation) {
-    switch (operation) {
-      case '<':
-      case '<=':
-      case '=<':
-      case '>':
-      case '>=':
-      case '=>':
-        return true;
-      default:
-        return false;
-    }
-  }
-
-  /**
-   * @param filter The column filter to apply the range operation to
-   * @param operation The range operation to run
-   * @param value The value to use for the operation
-   * @returns The condition with the specified operation
-   */
-  static makeRangeFilterWithOperation(filter, operation, value) {
-    switch (operation) {
-      case '=':
-        return filter.eq(value);
-      case '<':
-        return filter.lessThan(value);
-      case '<=':
-      case '=<':
-        return filter.lessThanOrEqualTo(value);
-      case '>':
-        return filter.greaterThan(value);
-      case '>=':
-      case '=>':
-        return filter.greaterThanOrEqualTo(value);
-      case '!=':
-      case '!':
-        return filter.notEq(value);
-      default:
-        return null;
-    }
-  }
-
-  /**
-   * Wraps a table promise in a cancelable promise that will close the table if the promise is cancelled.
-   * Use in a component that loads a table, and call cancel when unmounting.
-   * @param table The table promise to wrap
-   */
-  static makeCancelableTablePromise(table) {
-    return PromiseUtils.makeCancelable(table, resolved => {
-      resolved.close();
-    });
-  }
-
-  /**
-   * Make a cancelable promise for a one-shot table event with a timeout.
-   * @param table Table to listen for events on
-   * @param eventName Event to listen for
-   * @param timeout Event timeout in milliseconds, defaults to 0
-   * @param matcher Optional function to determine if the promise can be resolved or stays pending
-   * @returns Resolves with the event data
-   */
-  static makeCancelableTableEventPromise(table, eventName) {
-    var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-    var matcher = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
-    var eventCleanup;
-    var timeoutId;
-    var isPending = true;
-    var wrappedPromise = new Promise((resolve, reject) => {
-      timeoutId = setTimeout(() => {
-        eventCleanup();
-        isPending = false;
-        reject(new TimeoutError("Event \"".concat(eventName, "\" timed out.")));
-      }, timeout);
-      eventCleanup = table.addEventListener(eventName, event => {
-        if (matcher != null && !matcher(event)) {
-          log.debug2('Event triggered, but matcher returned false.');
-          return;
-        }
-        log.debug2('Event triggered, resolving.');
-        eventCleanup();
-        clearTimeout(timeoutId);
-        isPending = false;
-        resolve(event);
-      });
-    });
-    wrappedPromise.cancel = () => {
-      if (isPending) {
-        log.debug2('Pending promise cleanup.');
-        eventCleanup();
-        clearTimeout(timeoutId);
-        isPending = false;
-        return;
-      }
-      log.debug2('Ignoring non-pending promise cancel.');
-    };
-    return wrappedPromise;
-  }
-  static removeCommas(value) {
-    return value.replace(/[\s|,]/g, '');
-  }
-  static makeBooleanValue(text) {
-    var allowEmpty = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    if (text === '' && allowEmpty) {
-      return null;
-    }
-    switch (text === null || text === void 0 ? void 0 : text.toLowerCase()) {
-      case 'null':
-        return null;
-      case '0':
-      case 'f':
-      case 'fa':
-      case 'fal':
-      case 'fals':
-      case 'false':
-      case 'n':
-      case 'no':
-        return false;
-      case '1':
-      case 't':
-      case 'tr':
-      case 'tru':
-      case 'true':
-      case 'y':
-      case 'ye':
-      case 'yes':
-        return true;
-      default:
-        throw new Error("Invalid boolean '".concat(text, "'"));
-    }
-  }
-  static makeNumberValue(text) {
-    if (text === 'null' || text === '') {
-      return null;
-    }
-    var cleanText = text.toLowerCase().trim();
-    if (cleanText === '∞' || cleanText === 'infinity' || cleanText === 'inf') {
-      return Number.POSITIVE_INFINITY;
-    }
-    if (cleanText === '-∞' || cleanText === '-infinity' || cleanText === '-inf') {
-      return Number.NEGATIVE_INFINITY;
-    }
-    var numberText = TableUtils.removeCommas(cleanText);
-    if (TableUtils.NUMBER_REGEX.test(numberText)) {
-      return parseFloat(numberText);
-    }
-    throw new Error("Invalid number '".concat(text, "'"));
-  }
-  static getFilterOperatorString(operation) {
-    switch (operation) {
-      case FilterType.eq:
-        return '=';
-      case FilterType.notEq:
-        return '!=';
-      case FilterType.greaterThan:
-        return '>';
-      case FilterType.greaterThanOrEqualTo:
-        return '>=';
-      case FilterType.lessThan:
-        return '<';
-      case FilterType.lessThanOrEqualTo:
-        return '<=';
-      case FilterType.contains:
-        return '~';
-      case FilterType.notContains:
-        return '!~';
-      default:
-        throw new Error("Unexpected filter type ".concat(operation));
-    }
-  }
-  static isTreeTable(table) {
-    return table != null && table.expand !== undefined && table.collapse !== undefined;
-  }
-
-  /**
-   * Copies the provided array, sorts by column name case insensitive, and returns the sorted array.
-   * @param columns The columns to sort
-   * @param isAscending Whether to sort ascending
-   */
-  static sortColumns(columns) {
-    var isAscending = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    return [...columns].sort((a, b) => {
-      var aName = a.name.toUpperCase();
-      var bName = b.name.toUpperCase();
-      return TextUtils.sort(aName, bName, isAscending);
-    });
-  }
-  constructor(dh) {
-    _defineProperty(this, "dh", void 0);
-    this.dh = dh;
-  }
-
-  /**
-   * Create filter with the provided column and text. Handles multiple filters joined with && or ||
-   * @param column The column to set the filter on
-   * @param text The text string to create the filter from
-   * @param timeZone The time zone to make this value in if it is a date type. E.g. America/New_York
-   * @returns Returns the created filter, null if text could not be parsed
-   */
-  makeQuickFilter(column, text, timeZone) {
-    var orComponents = text.split('||');
-    var orFilter = null;
-    for (var i = 0; i < orComponents.length; i += 1) {
-      var orComponent = orComponents[i];
-      var andComponents = orComponent.split('&&');
-      var andFilter = null;
-      for (var j = 0; j < andComponents.length; j += 1) {
-        var andComponent = andComponents[j].trim();
-        if (andComponent.length > 0) {
-          var filter = this.makeQuickFilterFromComponent(column, andComponent, timeZone);
-          if (filter) {
-            if (andFilter) {
-              andFilter = andFilter.and(filter);
-            } else {
-              andFilter = filter;
-            }
-          } else {
-            throw new Error("Unable to parse quick filter from text ".concat(text));
-          }
-        }
-      }
-      if (orFilter && andFilter) {
-        orFilter = orFilter.or(andFilter);
-      } else {
-        orFilter = andFilter;
-      }
-    }
-    return orFilter;
-  }
-
-  /**
-   * Create filter with the provided column and text of one component (no multiple conditions)
-   * @param column The column to set the filter on
-   * @param text The text string to create the filter from
-   * @param timeZone The time zone to make this filter in if it is a date type. E.g. America/New_York
-   * @returns Returns the created filter, null if text could not be parsed
-   */
-  makeQuickFilterFromComponent(column, text, timeZone) {
-    var {
-      type
-    } = column;
-    if (TableUtils.isNumberType(type)) {
-      return this.makeQuickNumberFilter(column, text);
-    }
-    if (TableUtils.isBooleanType(type)) {
-      return this.makeQuickBooleanFilter(column, text);
-    }
-    if (timeZone != null && TableUtils.isDateType(type)) {
-      return this.makeQuickDateFilter(column, text, timeZone);
-    }
-    if (TableUtils.isCharType(type)) {
-      return this.makeQuickCharFilter(column, text);
-    }
-    return this.makeQuickTextFilter(column, text);
-  }
-  makeQuickNumberFilter(column, text) {
-    var columnFilter = column.filter();
-    var {
-      dh
-    } = this;
-    var filter = null;
-    var regex = /\s*(>=|<=|=>|=<|>|<|!=|=|!)?(\s*-\s*)?(\s*\d*(?:,\d{3})*(?:\.\d*)?\s*)?(null|nan|infinity|inf|\u221E)?(.*)/i;
-    var result = regex.exec(text);
-    var operation = null;
-    var negativeSign = null;
-    var value = null;
-    var abnormalValue = null; // includes nan, null and infinity(positive & negative)
-    var overflow = null;
-    if (result !== null && result.length > 3) {
-      [, operation, negativeSign, value, abnormalValue, overflow] = result;
-    }
-    if (overflow != null && overflow.trim().length > 0) {
-      // Some bad characters after the number, bail out!
-      return null;
-    }
-    if (operation == null) {
-      operation = '=';
-    }
-    if (abnormalValue != null) {
-      if (!(operation === '=' || operation === '!' || operation === '!=')) {
-        // only equal and not equal operations are supported for abnormal value filter
-        return null;
-      }
-      abnormalValue = abnormalValue.trim().toLowerCase();
-      switch (abnormalValue) {
-        case 'null':
-          filter = columnFilter.isNull();
-          break;
-        case 'nan':
-          filter = dh.FilterCondition.invoke('isNaN', columnFilter);
-          break;
-        case 'infinity':
-        case 'inf':
-        case '\u221E':
-          if (negativeSign != null) {
-            filter = dh.FilterCondition.invoke('isInf', columnFilter).and(columnFilter.lessThan(dh.FilterValue.ofNumber(0)));
-          } else {
-            filter = dh.FilterCondition.invoke('isInf', columnFilter).and(columnFilter.greaterThan(dh.FilterValue.ofNumber(0)));
-          }
-          break;
-        default:
-          break;
-      }
-      if (filter !== null && (operation === '!' || operation === '!=')) {
-        filter = filter.not();
-      }
-      return filter;
-    }
-    if (value == null) {
-      return null;
-    }
-    value = TableUtils.removeCommas(value);
-    if (TableUtils.isLongType(column.type)) {
-      try {
-        value = dh.FilterValue.ofNumber(dh.LongWrapper.ofString("".concat(negativeSign != null ? '-' : '').concat(value)));
-      } catch (error) {
-        log.warn('Unable to create long filter', error);
-        return null;
-      }
-    } else {
-      value = parseFloat(value);
-      if (value == null || Number.isNaN(value)) {
-        return null;
-      }
-      value = dh.FilterValue.ofNumber(negativeSign != null ? 0 - value : value);
-    }
-    filter = column.filter();
-    return TableUtils.makeRangeFilterWithOperation(filter, operation, value);
-  }
-
-  /**
-   * Given a text string from a table, escape quick filter operators in string with \
-   * ex. =test returns \=test, null returns \null
-   * @param string quickfilter string to escape
-   * @returns escaped string
-   */
-  static escapeQuickTextFilter(quickFilterText) {
-    var _operation, _value2;
-    if (quickFilterText == null) return null;
-    var regex = /^(!~|!=|~|=|!)?(.*)/;
-    // starts with zero or more \ followed by and ending with null
-    var nullRegex = /^\\*null$/;
-    var result = regex.exec(quickFilterText);
-    var operation = null;
-    var value = null;
-    if (result !== null && result.length > 2) {
-      [, operation, value] = result;
-    }
-    if (operation != null) {
-      var _value;
-      return "\\".concat(operation).concat((_value = value) !== null && _value !== void 0 ? _value : '');
-    }
-    if (value != null && nullRegex.test(value.toLowerCase())) {
-      // adds an extra escape character to matching value
-      return "\\".concat(value);
-    }
-    if (value != null && value.startsWith('*')) {
-      return "\\".concat(value);
-    }
-    if (value != null && value.endsWith('*') && !value.endsWith('\\*')) {
-      value = value.substring(0, value.length - 1);
-      return "".concat(value, "\\*");
-    }
-    return "".concat((_operation = operation) !== null && _operation !== void 0 ? _operation : '').concat((_value2 = value) !== null && _value2 !== void 0 ? _value2 : "");
-  }
-
-  /**
-   * Given an escaped quick filter, unescape the operators for giving it to the js api
-   * ex. \=test returns =test, \null returns null
-   * @param string quickfilter string to escape
-   * @returns escaped string
-   */
-  static unescapeQuickTextFilter(quickFilterText) {
-    var _operation2, _value3;
-    var regex = /^(\\!~|\\!=|\\~|\\=|\\!)?(.*)/;
-    // starts with zero or more \ followed by and ending with null
-    var nullRegex = /^\\*null$/;
-    var result = regex.exec(quickFilterText);
-    var operation = null;
-    var value = null;
-    if (result !== null && result.length > 2) {
-      [, operation, value] = result;
-    }
-    if (operation != null) {
-      operation = operation.replace('\\', '');
-    }
-    if (value != null && nullRegex.test(value.toLowerCase())) {
-      // removes the first occurance of the backslash
-      value = value.replace('\\', '');
-    }
-    if (operation == null && value != null && value.startsWith('\\*')) {
-      value = value.substring(1);
-    }
-    if (operation == null && value != null && value.endsWith('\\*')) {
-      value = value.substring(0, value.length - 2);
-      return "".concat(value, "*");
-    }
-    return "".concat((_operation2 = operation) !== null && _operation2 !== void 0 ? _operation2 : '').concat((_value3 = value) !== null && _value3 !== void 0 ? _value3 : "");
-  }
-  makeQuickTextFilter(column, text) {
-    var {
-      dh
-    } = this;
-    var cleanText = "".concat(text).trim();
-    var regex = /^(!~|!=|~|=|!)?(.*)/;
-    var result = regex.exec(cleanText);
-    var operation = null;
-    var value = null;
-    if (result !== null && result.length > 2) {
-      [, operation, value] = result;
-      if (value != null) {
-        value = value.trim();
-      }
-    }
-    if (value == null) {
-      return null;
-    }
-
-    // allow empty strings, but only for explicit equal and not equal
-    if (value.length === 0 && !(operation === '=' || operation === '!=')) {
-      return null;
-    }
-
-    // no operation is treated as an implicit equals
-    if (operation == null) {
-      operation = '=';
-    }
-    var filter = column.filter();
-    if (value.toLowerCase() === 'null') {
-      // Null is a special case!
-      switch (operation) {
-        case '=':
-          return filter.isNull();
-        case '!=':
-        case '!':
-          return filter.isNull().not();
-        default:
-        // For all other operations, treat null as a string value
-      }
-    }
-
-    var prefix = null;
-    var suffix = null;
-    if (value.startsWith('*')) {
-      prefix = '*';
-      value = value.substring(1);
-    } else if (value.endsWith('*') && !value.endsWith('\\*')) {
-      suffix = '*';
-      value = value.substring(0, value.length - 1);
-    }
-
-    // unescape any escaped operators to allow search for literal operators
-    value = TableUtils.unescapeQuickTextFilter(value);
-    switch (operation) {
-      case '~':
-        {
-          return filter.isNull().not().and(filter.invoke('matches', dh.FilterValue.ofString("(?s)(?i).*\\Q".concat(value, "\\E.*"))));
-        }
-      case '!~':
-        return filter.isNull().or(filter.invoke('matches', dh.FilterValue.ofString("(?s)(?i).*\\Q".concat(value, "\\E.*"))).not());
-      case '!=':
-        if (prefix === '*') {
-          // Does not end with
-          return filter.isNull().or(filter.invoke('matches', dh.FilterValue.ofString("(?s)(?i).*\\Q".concat(value, "\\E$"))).not());
-        }
-        if (suffix === '*') {
-          // Does not start with
-          return filter.isNull().or(filter.invoke('matches', dh.FilterValue.ofString("(?s)(?i)^\\Q".concat(value, "\\E.*"))).not());
-        }
-        return filter.notEqIgnoreCase(dh.FilterValue.ofString(value.toLowerCase()));
-      case '=':
-        if (prefix === '*') {
-          // Ends with
-          return filter.isNull().not().and(filter.invoke('matches', dh.FilterValue.ofString("(?s)(?i).*\\Q".concat(value, "\\E$"))));
-        }
-        if (suffix === '*') {
-          // Starts with
-          return filter.isNull().not().and(filter.invoke('matches', dh.FilterValue.ofString("(?s)(?i)^\\Q".concat(value, "\\E.*"))));
-        }
-        return filter.eqIgnoreCase(dh.FilterValue.ofString(value.toLowerCase()));
-      default:
-        break;
-    }
-    return null;
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  makeQuickBooleanFilter(column, text) {
-    var regex = /^(!=|=|!)?(.*)/;
-    var result = regex.exec("".concat(text).trim());
-    if (result === null) {
-      return null;
-    }
-    var [, operation, value] = result;
-    var notEqual = operation === '!' || operation === '!=';
-    var cleanValue = value.trim().toLowerCase();
-    var filter = column.filter();
-    try {
-      var boolValue = TableUtils.makeBooleanValue(cleanValue);
-      if (boolValue != null && boolValue) {
-        filter = filter.isTrue();
-      } else if (boolValue === null) {
-        filter = filter.isNull();
-      } else {
-        filter = filter.isFalse();
-      }
-      return notEqual ? filter.not() : filter;
-    } catch (e) {
-      return null;
-    }
-  }
-
-  /**
-   * Builds a date filter parsed from the text string which may or may not include an operator.
-   * @param column The column to build the filter from, with or without a leading operator.
-   * @param text The date string text to parse.
-   * @param timeZone The time zone to make this filter in if it is a date type. E.g. America/New_York
-   */
-  makeQuickDateFilter(column, text, timeZone) {
-    var cleanText = text.trim();
-    var regex = /\s*(>=|<=|=>|=<|>|<|!=|!|=)?(.*)/;
-    var result = regex.exec(cleanText);
-    if (result == null || result.length <= 2) {
-      throw new Error("Unable to parse date filter: ".concat(text));
-    }
-    var operation = null;
-    var dateText = null;
-    [, operation, dateText] = result;
-    var filterOperation = FilterType.eq;
-    switch (operation) {
-      case '<':
-        filterOperation = FilterType.lessThan;
-        break;
-      case '<=':
-      case '=<':
-        filterOperation = FilterType.lessThanOrEqualTo;
-        break;
-      case '>':
-        filterOperation = FilterType.greaterThan;
-        break;
-      case '>=':
-      case '=>':
-        filterOperation = FilterType.greaterThanOrEqualTo;
-        break;
-      case '!=':
-      case '!':
-        filterOperation = FilterType.notEq;
-        break;
-      case '=':
-      case '==':
-      default:
-        filterOperation = FilterType.eq;
-        break;
-    }
-    return this.makeQuickDateFilterWithOperation(column, dateText, filterOperation, timeZone);
-  }
-
-  /**
-   * Builds a date filter parsed from the text string with the provided filter.
-   * @param column The column to build the filter from.
-   * @param text The date string text to parse, without an operator.
-   * @param operation The filter operation to use.
-   * @param timeZone The time zone to make this filter with. E.g. America/New_York
-   */
-  makeQuickDateFilterWithOperation(column, text, operation, timeZone) {
-    var {
-      dh
-    } = this;
-    var [startDate, endDate] = DateUtils.parseDateRange(dh, text, timeZone);
-    var startValue = startDate != null ? dh.FilterValue.ofNumber(startDate) : null;
-    var endValue = endDate != null ? dh.FilterValue.ofNumber(endDate) : null;
-    var filter = column.filter();
-    if (startValue == null) {
-      return operation === FilterType.notEq ? filter.isNull().not() : filter.isNull();
-    }
-    switch (operation) {
-      case FilterType.eq:
-        {
-          if (endValue != null) {
-            var startFilter = filter.greaterThanOrEqualTo(startValue);
-            var endFilter = filter.lessThan(endValue);
-            return startFilter.and(endFilter);
-          }
-          return filter.eq(startValue);
-        }
-      case FilterType.lessThan:
-        {
-          return filter.lessThan(startValue);
-        }
-      case FilterType.lessThanOrEqualTo:
-        {
-          if (endValue != null) {
-            return filter.lessThan(endValue);
-          }
-          return filter.lessThanOrEqualTo(startValue);
-        }
-      case FilterType.greaterThan:
-        {
-          if (endValue != null) {
-            return filter.greaterThanOrEqualTo(endValue);
-          }
-          return filter.greaterThan(startValue);
-        }
-      case FilterType.greaterThanOrEqualTo:
-        return filter.greaterThanOrEqualTo(startValue);
-      case FilterType.notEq:
-        {
-          if (endValue != null) {
-            var _startFilter = filter.lessThan(startValue);
-            var _endFilter = filter.greaterThanOrEqualTo(endValue);
-            return _startFilter.or(_endFilter);
-          }
-          return filter.notEq(startValue);
-        }
-      default:
-        throw new Error("Invalid operator: ".concat(operation));
-    }
-  }
-  makeQuickCharFilter(column, text) {
-    var {
-      dh
-    } = this;
-    var cleanText = "".concat(text).trim();
-    var regex = /^(>=|<=|=>|=<|>|<|!=|=|!)?(null|"."|'.'|.)?(.*)/;
-    var result = regex.exec(cleanText);
-    var operation = null;
-    var value = null;
-    var overflow = null;
-    if (result !== null && result.length > 3) {
-      [, operation, value, overflow] = result;
-    }
-    if (overflow != null && overflow.trim().length > 0) {
-      // Some bad characters after the number, bail out!
-      return null;
-    }
-    if (value == null || value.length === 0) {
-      return null;
-    }
-    if (operation == null) {
-      operation = '=';
-    }
-    var filter = column.filter();
-    if (value.toLowerCase() === 'null') {
-      // Null is a special case!
-      switch (operation) {
-        case '=':
-          return filter.isNull();
-        case '!=':
-        case '!':
-          return filter.isNull().not();
-        default:
-          return null;
-      }
-    }
-
-    // We need to put quotes around range operations or else the API fails
-    var filterValue = dh.FilterValue.ofString(TableUtils.isRangeOperation(operation) ? TableUtils.quoteValue(value) : value);
-    return TableUtils.makeRangeFilterWithOperation(filter, operation, filterValue);
-  }
-  makeAdvancedFilter(column, options, timeZone) {
-    var {
-      filterItems,
-      filterOperators,
-      invertSelection,
-      selectedValues
-    } = options;
-    var filter = null;
-    for (var i = 0; i < filterItems.length; i += 1) {
-      var filterItem = filterItems[i];
-      var {
-        selectedType,
-        value
-      } = filterItem;
-      if (selectedType != null && selectedType.length > 0 && value != null && value.length > 0) {
-        try {
-          var newFilter = this.makeAdvancedValueFilter(column, selectedType, value, timeZone);
-          if (newFilter != null) {
-            if (i === 0) {
-              filter = newFilter;
-            } else if (filter !== null && i - 1 < filterOperators.length) {
-              var filterOperator = filterOperators[i - 1];
-              if (filterOperator === FilterOperator.and) {
-                filter = filter.and(newFilter);
-              } else if (filterOperator === FilterOperator.or) {
-                filter = filter.or(newFilter);
-              } else {
-                log.error('Unexpected filter operator', filterOperator, newFilter);
-                filter = null;
-                break;
-              }
-            }
-          } else {
-            log.debug2('Empty filter ignored for', selectedType, value);
-          }
-        } catch (err) {
-          log.error('Unable to create filter', err);
-          filter = null;
-          break;
-        }
-      }
-    }
-    var selectValueFilter = this.makeSelectValueFilter(column, selectedValues, invertSelection);
-    if (selectValueFilter != null) {
-      if (filter != null) {
-        filter = filter.and(selectValueFilter);
-      } else {
-        filter = selectValueFilter;
-      }
-    }
-    return filter;
-  }
-  makeAdvancedValueFilter(column, operation, value, timeZone) {
-    var {
-      dh
-    } = this;
-    if (TableUtils.isDateType(column.type)) {
-      return this.makeQuickDateFilterWithOperation(column, value, operation, timeZone);
-    }
-    if (TableUtils.isNumberType(column.type) || TableUtils.isCharType(column.type)) {
-      return this.makeQuickFilter(column, "".concat(TableUtils.getFilterOperatorString(operation)).concat(value));
-    }
-    var filterValue = this.makeFilterValue(column.type, value);
-    var filter = column.filter();
-    switch (operation) {
-      case FilterType.eq:
-        return filter.eq(filterValue);
-      case FilterType.eqIgnoreCase:
-        return filter.eqIgnoreCase(filterValue);
-      case FilterType.notEq:
-        return filter.notEq(filterValue);
-      case FilterType.notEqIgnoreCase:
-        return filter.notEqIgnoreCase(filterValue);
-      case FilterType.greaterThan:
-        return filter.greaterThan(filterValue);
-      case FilterType.greaterThanOrEqualTo:
-        return filter.greaterThanOrEqualTo(filterValue);
-      case FilterType.lessThan:
-        return filter.lessThan(filterValue);
-      case FilterType.lessThanOrEqualTo:
-        return filter.lessThanOrEqualTo(filterValue);
-      case FilterType.isTrue:
-        return filter.isTrue();
-      case FilterType.isFalse:
-        return filter.isFalse();
-      case FilterType.isNull:
-        return filter.isNull();
-      case FilterType.contains:
-        return filter.isNull().not().and(filter.invoke('matches', dh.FilterValue.ofString("(?s)(?i).*\\Q".concat(value, "\\E.*"))));
-      case FilterType.notContains:
-        return filter.isNull().or(filter.invoke('matches', dh.FilterValue.ofString("(?s)(?i).*\\Q".concat(value, "\\E.*"))).not());
-      case FilterType.startsWith:
-        return filter.isNull().not().and(filter.invoke('matches', dh.FilterValue.ofString("(?s)(?i)^\\Q".concat(value, "\\E.*"))));
-      case FilterType.endsWith:
-        return filter.isNull().not().and(filter.invoke('matches', dh.FilterValue.ofString("(?s)(?i).*\\Q".concat(value, "\\E$"))));
-      case FilterType.in:
-      case FilterType.inIgnoreCase:
-      case FilterType.notIn:
-      case FilterType.notInIgnoreCase:
-      case FilterType.invoke:
-      default:
-        throw new Error("Unexpected filter operation: ".concat(operation));
-    }
-  }
-
-  /**
-   * Apply a filter to a table that won't match anything.
-   * @table The table to apply the filter to
-   * @columnName The name of the column to apploy the filter to
-   * @param timeout Timeout before cancelling the promise that waits for the next
-   * dh.Table.EVENT_FILTERCHANGED event
-   * @returns a Promise to the Table that resolves after the next
-   * dh.Table.EVENT_FILTERCHANGED event
-   */
-  applyNeverFilter(table, columnName) {
-    var _arguments = arguments,
-      _this = this;
-    return _asyncToGenerator(function* () {
-      var timeout = _arguments.length > 2 && _arguments[2] !== undefined ? _arguments[2] : TableUtils.APPLY_TABLE_CHANGE_TIMEOUT_MS;
-      if (table == null) {
-        return null;
-      }
-      var column = table.findColumn(columnName);
-      var filters = [_this.makeNeverFilter(column)];
-      yield _this.applyFilter(table, filters, timeout);
-      return table;
-    })();
-  }
-
-  /**
-   * Apply custom columns to a given table. Return a Promise that resolves with
-   * the table once the dh.Table.EVENT_CUSTOMCOLUMNSCHANGED event has fired.
-   * @param table The table to apply custom columns to.
-   * @param columns The list of column expressions or definitions to apply.
-   * @returns A Promise that will be resolved with the given table after the
-   * columns are applied.
-   */
-  applyCustomColumns(table, columns) {
-    var _arguments2 = arguments,
-      _this2 = this;
-    return _asyncToGenerator(function* () {
-      var timeout = _arguments2.length > 2 && _arguments2[2] !== undefined ? _arguments2[2] : TableUtils.APPLY_TABLE_CHANGE_TIMEOUT_MS;
-      var {
-        dh
-      } = _this2;
-      return TableUtils.executeAndWaitForEvent(t => t === null || t === void 0 ? void 0 : t.applyCustomColumns(columns), table, dh.Table.EVENT_CUSTOMCOLUMNSCHANGED, timeout);
-    })();
-  }
-
-  /**
-   * Apply filters to a given table.
-   * @param table Table to apply filters to
-   * @param filters Filters to apply
-   * @param timeout Timeout before cancelling the promise that waits for the next
-   * dh.Table.EVENT_FILTERCHANGED event
-   * @returns a Promise to the Table that resolves after the next
-   * dh.Table.EVENT_FILTERCHANGED event
-   */
-  applyFilter(table, filters) {
-    var _arguments3 = arguments,
-      _this3 = this;
-    return _asyncToGenerator(function* () {
-      var timeout = _arguments3.length > 2 && _arguments3[2] !== undefined ? _arguments3[2] : TableUtils.APPLY_TABLE_CHANGE_TIMEOUT_MS;
-      var {
-        dh
-      } = _this3;
-      return TableUtils.executeAndWaitForEvent(t => t === null || t === void 0 ? void 0 : t.applyFilter(filters), table, dh.Table.EVENT_FILTERCHANGED, timeout);
-    })();
-  }
-
-  /**
-   * Apply sorts to a given Table.
-   * @param table The table to apply sorts to
-   * @param sorts The sorts to apply
-   * @param timeout Timeout before cancelling the promise that waits for the next
-   * dh.Table.EVENT_SORTCHANGED event
-   * @returns a Promise to the Table that resolves after the next
-   * dh.Table.EVENT_SORTCHANGED event
-   */
-  applySort(table, sorts) {
-    var _arguments4 = arguments,
-      _this4 = this;
-    return _asyncToGenerator(function* () {
-      var timeout = _arguments4.length > 2 && _arguments4[2] !== undefined ? _arguments4[2] : TableUtils.APPLY_TABLE_CHANGE_TIMEOUT_MS;
-      var {
-        dh
-      } = _this4;
-      return TableUtils.executeAndWaitForEvent(t => t === null || t === void 0 ? void 0 : t.applySort(sorts), table, dh.Table.EVENT_SORTCHANGED, timeout);
-    })();
-  }
-
-  /**
-   * Create a filter condition that results in zero results for a given column
-   * @param column
-   */
-  makeNeverFilter(column) {
-    var {
-      dh
-    } = this;
-    var value = null;
-    if (TableUtils.isTextType(column.type)) {
-      // Use 'a' so that it can work for String or Character types
-      value = dh.FilterValue.ofString('a');
-    } else if (TableUtils.isBooleanType(column.type)) {
-      value = dh.FilterValue.ofBoolean(true);
-    } else if (TableUtils.isDateType(column.type)) {
-      value = dh.FilterValue.ofNumber(dh.DateWrapper.ofJsDate(new Date()));
-    } else {
-      value = dh.FilterValue.ofNumber(0);
-    }
-    var eqFilter = column.filter().eq(value);
-    var notEqFilter = column.filter().notEq(value);
-    return eqFilter.and(notEqFilter);
-  }
-
-  /**
-   * @param columnType The column type to make the filter value from.
-   * @param value The value to make the filter value from.
-   * @returns The FilterValue item for this column/value combination
-   */
-  makeFilterValue(columnType, value) {
-    var {
-      dh
-    } = this;
-    var type = TableUtils.getBaseType(columnType);
-    if (TableUtils.isTextType(type)) {
-      return dh.FilterValue.ofString(value);
-    }
-    if (TableUtils.isLongType(type)) {
-      return dh.FilterValue.ofNumber(dh.LongWrapper.ofString(TableUtils.removeCommas(value)));
-    }
-    return dh.FilterValue.ofNumber(TableUtils.removeCommas(value));
-  }
-
-  /**
-   * Takes a value and converts it to an `dh.FilterValue`
-   *
-   * @param columnType The column type to make the filter value from.
-   * @param value The value to actually set
-   * @returns The FilterValue item for this column/value combination
-   */
-  makeFilterRawValue(columnType, rawValue) {
-    var {
-      dh
-    } = this;
-    if (TableUtils.isTextType(columnType)) {
-      return dh.FilterValue.ofString(rawValue);
-    }
-    if (TableUtils.isBooleanType(columnType)) {
-      return dh.FilterValue.ofBoolean(rawValue);
-    }
-    return dh.FilterValue.ofNumber(rawValue);
-  }
-
-  /**
-   * Converts a string value to a value appropriate for the column
-   * @param columnType The column type to make the value for
-   * @param text The string value to make a type for
-   * @param timeZone The time zone to make this value in if it is a date type. E.g. America/New_York
-   */
-  makeValue(columnType, text, timeZone) {
-    var {
-      dh
-    } = this;
-    if (text === 'null') {
-      return null;
-    }
-    if (TableUtils.isTextType(columnType)) {
-      return text;
-    }
-    if (TableUtils.isLongType(columnType)) {
-      return dh.LongWrapper.ofString(TableUtils.removeCommas(text));
-    }
-    if (TableUtils.isBooleanType(columnType)) {
-      return TableUtils.makeBooleanValue(text, true);
-    }
-    if (TableUtils.isDateType(columnType)) {
-      var [date] = DateUtils.parseDateRange(dh, text, timeZone);
-      return date;
-    }
-    if (TableUtils.isNumberType(columnType)) {
-      return TableUtils.makeNumberValue(text);
-    }
-    log.error('Unexpected column type', columnType);
-    return null;
-  }
-
-  /**
-   * Create a filter using the selected items
-   * Has a flag for invertSelection as we start from a "Select All" state and a user just deselects items.
-   * Since there may be millions of distinct items, it's easier to build an inverse filter.
-   * @param column The column to set the filter on
-   * @param selectedValues The values that are selected
-   * @param invertSelection Invert the selection (eg. All items are selected, then you deselect items)
-   * @returns Returns a `in` or `notIn` FilterCondition as necessary, or null if no filtering should be applied (everything selected)
-   */
-  makeSelectValueFilter(column, selectedValues, invertSelection) {
-    var {
-      dh
-    } = this;
-    if (selectedValues.length === 0) {
-      if (invertSelection) {
-        // No filter means select everything
-        return null;
-      }
-
-      // KLUDGE: Return a conflicting filter to show no results.
-      // Could recognize this situation at a higher or lower level and pause updates on the
-      // table, but this situation should be rare and that wouldn't be much gains for some added complexity
-      return this.makeNeverFilter(column);
-    }
-    var values = [];
-    var isNullSelected = false;
-    for (var i = 0; i < selectedValues.length; i += 1) {
-      var value = selectedValues[i];
-      if (value == null) {
-        isNullSelected = true;
-      } else if (TableUtils.isTextType(column.type)) {
-        values.push(dh.FilterValue.ofString(typeof value === 'number' ? String.fromCharCode(value) : value));
-      } else if (TableUtils.isBooleanType(column.type)) {
-        values.push(dh.FilterValue.ofBoolean(Boolean(value)));
-      } else {
-        values.push(dh.FilterValue.ofNumber(value));
-      }
-    }
-    if (isNullSelected) {
-      if (values.length > 0) {
-        if (invertSelection) {
-          return column.filter().isNull().not().and(column.filter().notIn(values));
-        }
-        return column.filter().isNull().or(column.filter().in(values));
-      }
-      if (invertSelection) {
-        return column.filter().isNull().not();
-      }
-      return column.filter().isNull();
-    }
-    if (invertSelection) {
-      return column.filter().notIn(values);
-    }
-    return column.filter().in(values);
-  }
-}
-_defineProperty(TableUtils, "dataType", {
-  BOOLEAN: 'boolean',
-  CHAR: 'char',
-  DATETIME: 'datetime',
-  DECIMAL: 'decimal',
-  INT: 'int',
-  STRING: 'string',
-  UNKNOWN: 'unknown'
-});
-_defineProperty(TableUtils, "sortDirection", {
-  ascending: 'ASC',
-  descending: 'DESC',
-  reverse: 'REVERSE',
-  none: null
-});
-_defineProperty(TableUtils, "APPLY_TABLE_CHANGE_TIMEOUT_MS", 30000);
-_defineProperty(TableUtils, "REVERSE_TYPE", Object.freeze({
-  NONE: 'none',
-  PRE_SORT: 'pre-sort',
-  POST_SORT: 'post-sort'
-}));
-_defineProperty(TableUtils, "NUMBER_REGEX", /^-?\d+(\.\d+)?$/);
-_defineProperty(TableUtils, "executeAndWaitForEvent", /*#__PURE__*/function () {
-  var _ref2 = _asyncToGenerator(function* (exec, table, eventType) {
-    var timeout = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : TableUtils.APPLY_TABLE_CHANGE_TIMEOUT_MS;
-    if (table == null) {
-      return null;
-    }
-    var eventPromise = TableUtils.makeCancelableTableEventPromise(table, eventType, timeout);
-    exec(table);
-    yield eventPromise;
-    return table;
-  });
-  return function (_x, _x2, _x3) {
-    return _ref2.apply(this, arguments);
-  };
-}());
-export default TableUtils;
-//# sourceMappingURL=TableUtils.js.map