@deephaven/iris-grid 0.43.0 → 0.44.0

package/dist/sidebar/conditional-formatting/ConditionalFormattingUtils.js

@@ -0,0 +1,635 @@
+import Log from '@deephaven/log';
+import { DateUtils, TableUtils } from '@deephaven/jsapi-utils';
+import { makeColumnFormatColumn, makeRowFormatColumn, makeTernaryFormatRule } from "./ConditionalFormattingAPIUtils.js";
+var log = Log.module('ConditionalFormattingUtils');
+export var FormatterType;
+(function (FormatterType) {
+  FormatterType["CONDITIONAL"] = "conditional";
+  FormatterType["ROWS"] = "rows";
+})(FormatterType || (FormatterType = {}));
+export var NumberCondition;
+(function (NumberCondition) {
+  NumberCondition["IS_EQUAL"] = "is-equal";
+  NumberCondition["IS_NOT_EQUAL"] = "is-not-equal";
+  NumberCondition["IS_BETWEEN"] = "is-between";
+  NumberCondition["GREATER_THAN"] = "greater-than";
+  NumberCondition["GREATER_THAN_OR_EQUAL"] = "greater-than-or-equal";
+  NumberCondition["LESS_THAN"] = "less-than";
+  NumberCondition["LESS_THAN_OR_EQUAL"] = "less-than-or-equal";
+  NumberCondition["IS_NULL"] = "is-null";
+  NumberCondition["IS_NOT_NULL"] = "is-not-null";
+})(NumberCondition || (NumberCondition = {}));
+export var StringCondition;
+(function (StringCondition) {
+  StringCondition["IS_EXACTLY"] = "is-exactly";
+  StringCondition["IS_NOT_EXACTLY"] = "is-not-exactly";
+  StringCondition["CONTAINS"] = "contains";
+  StringCondition["DOES_NOT_CONTAIN"] = "does-not-contain";
+  StringCondition["STARTS_WITH"] = "starts-with";
+  StringCondition["ENDS_WITH"] = "ends-with";
+  StringCondition["IS_NULL"] = "is-null";
+  StringCondition["IS_NOT_NULL"] = "is-not-null";
+})(StringCondition || (StringCondition = {}));
+export var DateCondition;
+(function (DateCondition) {
+  DateCondition["IS_EXACTLY"] = "is-exactly";
+  DateCondition["IS_NOT_EXACTLY"] = "is-not-exactly";
+  DateCondition["IS_BEFORE"] = "is-before";
+  DateCondition["IS_BEFORE_OR_EQUAL"] = "is-before-or-equal";
+  DateCondition["IS_AFTER"] = "is-after";
+  DateCondition["IS_AFTER_OR_EQUAL"] = "is-after-or-equal";
+  DateCondition["IS_NULL"] = "is-null";
+  DateCondition["IS_NOT_NULL"] = "is-not-null";
+})(DateCondition || (DateCondition = {}));
+export var BooleanCondition;
+(function (BooleanCondition) {
+  BooleanCondition["IS_TRUE"] = "is-true";
+  BooleanCondition["IS_FALSE"] = "is-false";
+  BooleanCondition["IS_NULL"] = "is-null";
+  BooleanCondition["IS_NOT_NULL"] = "is-not-null";
+})(BooleanCondition || (BooleanCondition = {}));
+export var CharCondition;
+(function (CharCondition) {
+  CharCondition["IS_EQUAL"] = "is-equal";
+  CharCondition["IS_NOT_EQUAL"] = "is-not-equal";
+  CharCondition["IS_NULL"] = "is-null";
+  CharCondition["IS_NOT_NULL"] = "is-not-null";
+})(CharCondition || (CharCondition = {}));
+export var FormatStyleType;
+(function (FormatStyleType) {
+  FormatStyleType["NO_FORMATTING"] = "no-formatting";
+  FormatStyleType["POSITIVE"] = "positive";
+  FormatStyleType["NEGATIVE"] = "negative";
+  FormatStyleType["WARN"] = "warn";
+  FormatStyleType["NEUTRAL"] = "neutral";
+  FormatStyleType["ACCENT_1"] = "accent-1";
+  FormatStyleType["ACCENT_2"] = "accent-2";
+  FormatStyleType["CUSTOM"] = "custom";
+})(FormatStyleType || (FormatStyleType = {}));
+export function getLabelForStyleType(option) {
+  switch (option) {
+    case FormatStyleType.NO_FORMATTING:
+      return 'No formatting';
+    case FormatStyleType.POSITIVE:
+      return 'Positive';
+    case FormatStyleType.NEGATIVE:
+      return 'Negative';
+    case FormatStyleType.WARN:
+      return 'Warn';
+    case FormatStyleType.NEUTRAL:
+      return 'Neutral';
+    case FormatStyleType.ACCENT_1:
+      return 'Accent 1';
+    case FormatStyleType.ACCENT_2:
+      return 'Accent 2';
+    case FormatStyleType.CUSTOM:
+      return 'Custom...';
+  }
+}
+export function getBackgroundForStyleConfig(config) {
+  var {
+    type,
+    customConfig
+  } = config;
+  switch (type) {
+    case FormatStyleType.NO_FORMATTING:
+      return undefined;
+    case FormatStyleType.POSITIVE:
+      return '#9fde6f';
+    case FormatStyleType.NEGATIVE:
+      return '#ff6087';
+    case FormatStyleType.WARN:
+      return '#f67f40';
+    case FormatStyleType.NEUTRAL:
+      return '#ffd95c';
+    case FormatStyleType.ACCENT_1:
+      return '#78dce8';
+    case FormatStyleType.ACCENT_2:
+      return '#ab9bf5';
+    case FormatStyleType.CUSTOM:
+      return customConfig === null || customConfig === void 0 ? void 0 : customConfig.background;
+    default:
+      return undefined;
+  }
+}
+export function getColorForStyleConfig(config) {
+  var {
+    type,
+    customConfig
+  } = config;
+  switch (type) {
+    case FormatStyleType.NO_FORMATTING:
+      return undefined;
+    case FormatStyleType.POSITIVE:
+      return '#526a3f';
+    case FormatStyleType.NEGATIVE:
+      return '#802f44';
+    case FormatStyleType.WARN:
+      return '#663318';
+    case FormatStyleType.NEUTRAL:
+      return '#63562b';
+    case FormatStyleType.ACCENT_1:
+      return '#3f6469';
+    case FormatStyleType.ACCENT_2:
+      return '#554d72';
+    case FormatStyleType.CUSTOM:
+      return customConfig === null || customConfig === void 0 ? void 0 : customConfig.color;
+    default:
+      return undefined;
+  }
+}
+export function getStyleDBString(config) {
+  var color = getColorForStyleConfig(config.style);
+  var bg = getBackgroundForStyleConfig(config.style);
+  if (color === undefined || bg === undefined) {
+    return undefined;
+  }
+  return "bgfg(`".concat(bg, "`, `").concat(color, "`)");
+}
+function getNumberConditionText(config) {
+  var {
+    column,
+    value,
+    start,
+    end
+  } = config;
+  return getTextForNumberCondition(column.name, config.condition, value, start, end);
+}
+function getStringConditionText(config) {
+  var {
+    column,
+    value
+  } = config;
+  return getTextForStringCondition(column.name, config.condition, value);
+}
+function getDateConditionText(config) {
+  var {
+    column,
+    value
+  } = config;
+  return getTextForDateCondition(column.name, config.condition, value);
+}
+function getBooleanConditionText(config) {
+  var {
+    column
+  } = config;
+  return getTextForBooleanCondition(column.name, config.condition);
+}
+function getCharConditionText(config) {
+  var {
+    column,
+    value
+  } = config;
+  return getTextForCharCondition(column.name, config.condition, value);
+}
+export function getConditionDBString(config) {
+  var {
+    column
+  } = config;
+  if (TableUtils.isNumberType(column.type)) {
+    return getNumberConditionText(config);
+  }
+  if (TableUtils.isCharType(column.type)) {
+    return getCharConditionText(config);
+  }
+  if (TableUtils.isStringType(column.type)) {
+    return getStringConditionText(config);
+  }
+  if (TableUtils.isDateType(column.type)) {
+    return getDateConditionText(config);
+  }
+  if (TableUtils.isBooleanType(column.type)) {
+    return getBooleanConditionText(config);
+  }
+  throw new Error('Invalid column type');
+}
+export function getLabelForNumberCondition(condition) {
+  switch (condition) {
+    case NumberCondition.IS_EQUAL:
+      return 'is equal to';
+    case NumberCondition.IS_NOT_EQUAL:
+      return 'is not equal to';
+    case NumberCondition.IS_BETWEEN:
+      return 'is between';
+    case NumberCondition.GREATER_THAN:
+      return 'greater than';
+    case NumberCondition.GREATER_THAN_OR_EQUAL:
+      return 'greater than or equal to';
+    case NumberCondition.LESS_THAN:
+      return 'less than';
+    case NumberCondition.LESS_THAN_OR_EQUAL:
+      return 'less than or equal to';
+    case NumberCondition.IS_NULL:
+      return 'is null';
+    case NumberCondition.IS_NOT_NULL:
+      return 'is not null';
+  }
+}
+export function getLabelForStringCondition(condition) {
+  switch (condition) {
+    case StringCondition.IS_EXACTLY:
+      return 'is exactly';
+    case StringCondition.IS_NOT_EXACTLY:
+      return 'is not exactly';
+    case StringCondition.CONTAINS:
+      return 'contains';
+    case StringCondition.DOES_NOT_CONTAIN:
+      return 'does not contain';
+    case StringCondition.STARTS_WITH:
+      return 'starts with';
+    case StringCondition.ENDS_WITH:
+      return 'ends with';
+    case StringCondition.IS_NULL:
+      return 'is null';
+    case StringCondition.IS_NOT_NULL:
+      return 'is not null';
+  }
+}
+export function getLabelForDateCondition(condition) {
+  switch (condition) {
+    case DateCondition.IS_EXACTLY:
+      return 'is';
+    case DateCondition.IS_NOT_EXACTLY:
+      return 'is not';
+    case DateCondition.IS_BEFORE:
+      return 'is before';
+    case DateCondition.IS_BEFORE_OR_EQUAL:
+      return 'is before or equal';
+    case DateCondition.IS_AFTER:
+      return 'is after';
+    case DateCondition.IS_AFTER_OR_EQUAL:
+      return 'is after or equal';
+    case DateCondition.IS_NULL:
+      return 'is null';
+    case DateCondition.IS_NOT_NULL:
+      return 'is not null';
+  }
+}
+export function getLabelForBooleanCondition(condition) {
+  switch (condition) {
+    case BooleanCondition.IS_TRUE:
+      return 'is true';
+    case BooleanCondition.IS_FALSE:
+      return 'is false';
+    case BooleanCondition.IS_NULL:
+      return 'is null';
+    case BooleanCondition.IS_NOT_NULL:
+      return 'is not null';
+  }
+}
+export function getLabelForCharCondition(condition) {
+  switch (condition) {
+    case CharCondition.IS_EQUAL:
+      return 'is';
+    case CharCondition.IS_NOT_EQUAL:
+      return 'is not';
+    case CharCondition.IS_NULL:
+      return 'is null';
+    case CharCondition.IS_NOT_NULL:
+      return 'is not null';
+  }
+}
+export function getDefaultConditionForType(columnType) {
+  if (TableUtils.isNumberType(columnType)) {
+    return NumberCondition.IS_EQUAL;
+  }
+  if (TableUtils.isCharType(columnType)) {
+    return CharCondition.IS_EQUAL;
+  }
+  if (TableUtils.isStringType(columnType)) {
+    return StringCondition.IS_EXACTLY;
+  }
+  if (TableUtils.isDateType(columnType)) {
+    return DateCondition.IS_EXACTLY;
+  }
+  if (TableUtils.isBooleanType(columnType)) {
+    return BooleanCondition.IS_TRUE;
+  }
+  throw new Error('Invalid column type');
+}
+export function getDefaultValueForType(columnType) {
+  if (TableUtils.isCharType(columnType)) {
+    return '';
+  }
+  if (TableUtils.isStringType(columnType)) {
+    return '';
+  }
+  return undefined;
+}
+export function getConditionConfig(config) {
+  var {
+    condition,
+    value,
+    start,
+    end
+  } = config;
+  return {
+    condition,
+    value,
+    start,
+    end
+  };
+}
+export function getDefaultConditionConfigForType(type) {
+  return {
+    condition: getDefaultConditionForType(type),
+    value: getDefaultValueForType(type),
+    start: undefined,
+    end: undefined
+  };
+}
+export function getDefaultStyleConfig() {
+  return {
+    type: FormatStyleType.NO_FORMATTING
+  };
+}
+function getShortLabelForStringCondition(condition) {
+  switch (condition) {
+    case StringCondition.IS_EXACTLY:
+      return '==';
+    case StringCondition.IS_NOT_EXACTLY:
+      return '!=';
+    case StringCondition.CONTAINS:
+      return 'contains';
+    case StringCondition.DOES_NOT_CONTAIN:
+      return 'does not contain';
+    case StringCondition.STARTS_WITH:
+      return 'starts with';
+    case StringCondition.ENDS_WITH:
+      return 'ends with';
+    case StringCondition.IS_NULL:
+      return 'is null';
+    case StringCondition.IS_NOT_NULL:
+      return 'is not null';
+  }
+}
+function getShortLabelForDateCondition(condition) {
+  switch (condition) {
+    case DateCondition.IS_EXACTLY:
+      return '==';
+    case DateCondition.IS_NOT_EXACTLY:
+      return '!=';
+    case DateCondition.IS_BEFORE:
+      return '<';
+    case DateCondition.IS_BEFORE_OR_EQUAL:
+      return '<=';
+    case DateCondition.IS_AFTER:
+      return '>';
+    case DateCondition.IS_AFTER_OR_EQUAL:
+      return '>=';
+    case DateCondition.IS_NULL:
+      return 'is null';
+    case DateCondition.IS_NOT_NULL:
+      return 'is not null';
+  }
+}
+function getShortLabelForBooleanCondition(condition) {
+  switch (condition) {
+    case BooleanCondition.IS_TRUE:
+      return 'is true';
+    case BooleanCondition.IS_FALSE:
+      return 'is false';
+    case BooleanCondition.IS_NULL:
+      return 'is null';
+    case BooleanCondition.IS_NOT_NULL:
+      return 'is not null';
+  }
+}
+function getShortLabelForCharCondition(condition) {
+  switch (condition) {
+    case CharCondition.IS_EQUAL:
+      return '==';
+    case CharCondition.IS_NOT_EQUAL:
+      return '!=';
+    case CharCondition.IS_NULL:
+      return 'is null';
+    case CharCondition.IS_NOT_NULL:
+      return 'is not null';
+  }
+}
+export function getShortLabelForNumberCondition(condition) {
+  switch (condition) {
+    case NumberCondition.IS_EQUAL:
+      return '==';
+    case NumberCondition.IS_NOT_EQUAL:
+      return '!=';
+    case NumberCondition.IS_BETWEEN:
+      return '==';
+    case NumberCondition.GREATER_THAN:
+      return '>';
+    case NumberCondition.GREATER_THAN_OR_EQUAL:
+      return '>=';
+    case NumberCondition.LESS_THAN:
+      return '<';
+    case NumberCondition.LESS_THAN_OR_EQUAL:
+      return '<=';
+    case NumberCondition.IS_NULL:
+      return 'is null';
+    case NumberCondition.IS_NOT_NULL:
+      return 'is not null';
+  }
+}
+export function getTextForNumberCondition(columnName, condition, value, start, end) {
+  switch (condition) {
+    case NumberCondition.IS_EQUAL:
+      return "".concat(columnName, " == ").concat(value);
+    case NumberCondition.IS_NOT_EQUAL:
+      return "".concat(columnName, " != ").concat(value);
+    case NumberCondition.IS_BETWEEN:
+      return "".concat(columnName, " > ").concat(start, " && ").concat(columnName, " < ").concat(end);
+    case NumberCondition.GREATER_THAN:
+      return "".concat(columnName, " > ").concat(value);
+    case NumberCondition.GREATER_THAN_OR_EQUAL:
+      return "".concat(columnName, " >= ").concat(value);
+    case NumberCondition.LESS_THAN:
+      return "".concat(columnName, " < ").concat(value);
+    case NumberCondition.LESS_THAN_OR_EQUAL:
+      return "".concat(columnName, " <= ").concat(value);
+    case NumberCondition.IS_NULL:
+      return "".concat(columnName, " == null");
+    case NumberCondition.IS_NOT_NULL:
+      return "".concat(columnName, " != null");
+  }
+}
+export function getTextForStringCondition(columnName, condition, value) {
+  switch (condition) {
+    case StringCondition.IS_EXACTLY:
+      return "".concat(columnName, " == \"").concat(value, "\"");
+    case StringCondition.IS_NOT_EXACTLY:
+      return "".concat(columnName, " != \"").concat(value, "\"");
+    case StringCondition.CONTAINS:
+      return "".concat(columnName, " != null && ").concat(columnName, ".contains(\"").concat(value, "\")");
+    case StringCondition.DOES_NOT_CONTAIN:
+      return "".concat(columnName, " != null && !").concat(columnName, ".contains(\"").concat(value, "\")");
+    case StringCondition.STARTS_WITH:
+      return "".concat(columnName, " != null && ").concat(columnName, ".startsWith(\"").concat(value, "\")");
+    case StringCondition.ENDS_WITH:
+      return "".concat(columnName, " != null && ").concat(columnName, ".endsWith(\"").concat(value, "\")");
+    case StringCondition.IS_NULL:
+      return "".concat(columnName, " == null");
+    case StringCondition.IS_NOT_NULL:
+      return "".concat(columnName, " != null");
+  }
+}
+export function getTextForDateCondition(columnName, condition, value) {
+  switch (condition) {
+    case DateCondition.IS_EXACTLY:
+      return "".concat(columnName, " == convertDateTime(\"").concat(value, "\")");
+    case DateCondition.IS_NOT_EXACTLY:
+      return "".concat(columnName, " != convertDateTime(`").concat(value, "`)");
+    case DateCondition.IS_BEFORE:
+      return "".concat(columnName, " < convertDateTime(`").concat(value, "`)");
+    case DateCondition.IS_BEFORE_OR_EQUAL:
+      return "".concat(columnName, " <=  convertDateTime(\"").concat(value, "\")");
+    case DateCondition.IS_AFTER:
+      return "".concat(columnName, " > convertDateTime(`").concat(value, "`)");
+    case DateCondition.IS_AFTER_OR_EQUAL:
+      return "".concat(columnName, " >=  convertDateTime(`").concat(value, "`)");
+    case DateCondition.IS_NULL:
+      return "".concat(columnName, " == null");
+    case DateCondition.IS_NOT_NULL:
+      return "".concat(columnName, " != null");
+  }
+}
+export function getTextForBooleanCondition(columnName, condition) {
+  switch (condition) {
+    case BooleanCondition.IS_TRUE:
+      return "".concat(columnName, " == true");
+    case BooleanCondition.IS_FALSE:
+      return "".concat(columnName, " == false");
+    case BooleanCondition.IS_NULL:
+      return "".concat(columnName, " == null");
+    case BooleanCondition.IS_NOT_NULL:
+      return "".concat(columnName, " != null");
+  }
+}
+export function getTextForCharCondition(columnName, condition, value) {
+  switch (condition) {
+    case CharCondition.IS_EQUAL:
+      return "".concat(columnName, " == '").concat(value, "'");
+    case CharCondition.IS_NOT_EQUAL:
+      return "".concat(columnName, " != '").concat(value, "'");
+    case CharCondition.IS_NULL:
+      return "isNull(".concat(columnName, ")");
+    case CharCondition.IS_NOT_NULL:
+      return "!isNull(".concat(columnName, ")");
+  }
+}
+export function getShortLabelForConditionType(columnType, condition) {
+  if (TableUtils.isNumberType(columnType)) {
+    return getShortLabelForNumberCondition(condition);
+  }
+  if (TableUtils.isCharType(columnType)) {
+    return getShortLabelForCharCondition(condition);
+  }
+  if (TableUtils.isStringType(columnType)) {
+    return getShortLabelForStringCondition(condition);
+  }
+  if (TableUtils.isDateType(columnType)) {
+    return getShortLabelForDateCondition(condition);
+  }
+  if (TableUtils.isBooleanType(columnType)) {
+    return getShortLabelForBooleanCondition(condition);
+  }
+  throw new Error('Invalid column type');
+}
+
+/**
+ * Get format columns array for the given columns and formatting rules
+ * @param columns Available columns
+ * @param rules Formatting rules to build the format columns from
+ * @returns Array of format columns
+ */
+export function getFormatColumns(dh, columns, rules) {
+  if (rules === undefined) {
+    log.debug("no rules passed.");
+    return [];
+  }
+  var result = [];
+  // There can be only one row format custom column
+  // and multiple column format custom columns (one per column)
+  var rowFormatConfig;
+  var columnFormatConfigMap = new Map();
+  rules.forEach(_ref => {
+    var _ref3;
+    var {
+      config,
+      type: formatterType
+    } = _ref;
+    var {
+      column
+    } = config;
+    // Check both name and type because the type can change
+    var col = columns.find(_ref2 => {
+      var {
+        name,
+        type
+      } = _ref2;
+      return name === column.name && type === column.type;
+    });
+    if (col === undefined) {
+      log.debug("Column ".concat(column.name, ":").concat(column.type, " not found. Ignoring format rule."), config);
+      return;
+    }
+    // Stack ternary format conditions by column
+    var [prevRule, prevFormatColumn] = (_ref3 = formatterType === FormatterType.CONDITIONAL ? columnFormatConfigMap.get(col.name) : rowFormatConfig) !== null && _ref3 !== void 0 ? _ref3 : ['null', undefined];
+    var rule = makeTernaryFormatRule(config, prevRule);
+    if (rule === undefined) {
+      log.debug("Ignoring format rule.", config);
+      return;
+    }
+    // Replace existing formatColumn with the new stacked format
+    var index = prevFormatColumn === undefined ? -1 : result.indexOf(prevFormatColumn);
+    if (index > -1) {
+      result.splice(index, 1);
+    }
+    var formatColumn = formatterType === FormatterType.CONDITIONAL ? makeColumnFormatColumn(col, rule) : makeRowFormatColumn(dh, rule);
+    result.push(formatColumn);
+    if (formatterType === FormatterType.CONDITIONAL) {
+      columnFormatConfigMap.set(col.name, [rule, formatColumn]);
+    } else {
+      rowFormatConfig = [rule, formatColumn];
+    }
+  });
+  return result;
+}
+
+/**
+ * Validate that a given date condition + value pair is valid.
+ * @param condition
+ * @param value
+ */
+export function isDateConditionValid(dh, condition, value) {
+  switch (condition) {
+    case DateCondition.IS_NULL:
+    case DateCondition.IS_NOT_NULL:
+      return true;
+    default:
+      {
+        var [dateTimeString, ...rest] = (value !== null && value !== void 0 ? value : '').split(' ');
+        // Reconstitute all tokens after the first ' ' in case the user included garbage data at the end
+        // e.g. '2020-01-01 NY blah'
+        var tzCode = rest.join(' ');
+        try {
+          DateUtils.parseDateTimeString(dateTimeString);
+        } catch (e) {
+          log.debug('Invalid datetime string', dateTimeString);
+          return false;
+        }
+        try {
+          dh.i18n.TimeZone.getTimeZone(tzCode);
+        } catch (e) {
+          log.debug('Invalid timezone string', tzCode);
+          return false;
+        }
+        return true;
+      }
+  }
+}
+export function isSupportedColumn(_ref4) {
+  var {
+    type
+  } = _ref4;
+  return TableUtils.isNumberType(type) || TableUtils.isCharType(type) || TableUtils.isStringType(type) || TableUtils.isDateType(type) || TableUtils.isBooleanType(type);
+}
+//# sourceMappingURL=ConditionalFormattingUtils.js.map