@deephaven/iris-grid 0.10.0 → 0.10.1-beta.0

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

@@ -0,0 +1,748 @@
+import Log from '@deephaven/log';
+import TableUtils from "../../TableUtils.js";
+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.isTextType(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.isTextType(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.isTextType(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.isTextType(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(columns, rules) {
+  var result = [];
+  var ruleMap = {
+    [FormatterType.ROWS]: new Map(),
+    [FormatterType.CONDITIONAL]: new Map()
+  };
+  rules.forEach(_ref => {
+    var _ruleMap$formatterTyp;
+
+    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 = (_ruleMap$formatterTyp = ruleMap[formatterType].get(col.name)) !== null && _ruleMap$formatterTyp !== void 0 ? _ruleMap$formatterTyp : null;
+    var rule = makeTernaryFormatRule(config, prevRule);
+
+    if (rule === undefined) {
+      log.debug("Ignoring format rule.", config);
+      return;
+    }
+
+    var index = result.indexOf(prevRule);
+
+    if (index > -1) {
+      result.splice(index, 1);
+    }
+
+    var formatColumn = formatterType === FormatterType.CONDITIONAL ? makeColumnFormatColumn(col, rule) : makeRowFormatColumn(rule);
+    result.push(formatColumn);
+    ruleMap[formatterType].set(col.name, rule);
+  });
+  return result;
+}
+//# sourceMappingURL=ConditionalFormattingUtils.js.map