logalize/lib/formatter.js

A better window.console

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var Formatter = {
  format: function format(args) {
    var _result2;

    var formattedStrings = [];
    var styles = [];
    var formattedArgCount = 0;
    var result;

    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = args[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var arg = _step.value;

        arg = this.formatObject(arg);
        if (typeof arg === 'undefined' || !arg[1].length) break;
        formattedStrings.push(arg[0]);
        styles.push.apply(styles, _toConsumableArray(arg[1]));
        formattedArgCount += 1;
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }

    args.splice(0, formattedArgCount);
    result = [];
    if (formattedStrings.length) {
      var _result;

      result.push(formattedStrings.join(' '));
      (_result = result).push.apply(_result, styles);
    }
    (_result2 = result).push.apply(_result2, _toConsumableArray(args));
    return result;
  },
  formatObject: function formatObject(obj) {
    if (typeof obj !== 'string') return;
    return this.formatString(obj);
  },
  formatString: function formatString(string) {
    var styles = [];
    var classes;

    while (this.canFormat(string)) {
      var match = this.getRelevantMatch(string);
      if (typeof match.format.classes === 'string') {
        classes = match.format.classes;
      } else {
        classes = match.format.classes(match.match);
      }

      string = string.replace(match.format.regex, function (_, m) {
        return '%c' + m + '%c';
      });
      styles.push(this.computeStyle(classes));
      styles.push(this.computeStyle('default'));
    }

    return [string, styles];
  },
  canFormat: function canFormat(string) {
    var _iteratorNormalCompletion2 = true;
    var _didIteratorError2 = false;
    var _iteratorError2 = undefined;

    try {
      for (var _iterator2 = this.formats[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
        var format = _step2.value;

        if (format.regex.test(string)) return true;
      }
    } catch (err) {
      _didIteratorError2 = true;
      _iteratorError2 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion2 && _iterator2.return) {
          _iterator2.return();
        }
      } finally {
        if (_didIteratorError2) {
          throw _iteratorError2;
        }
      }
    }

    return false;
  },
  getRelevantMatch: function getRelevantMatch(string) {
    var matches = [];
    var _iteratorNormalCompletion3 = true;
    var _didIteratorError3 = false;
    var _iteratorError3 = undefined;

    try {
      for (var _iterator3 = this.formats[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
        var format = _step3.value;

        if (format.regex.test(string)) {
          matches.push({ match: string.match(format.regex), format: format });
        }
      }
    } catch (err) {
      _didIteratorError3 = true;
      _iteratorError3 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion3 && _iterator3.return) {
          _iterator3.return();
        }
      } finally {
        if (_didIteratorError3) {
          throw _iteratorError3;
        }
      }
    }

    return matches.sort(function (a, b) {
      return a.match.index - b.match.index;
    })[0];
  },
  computeStyle: function computeStyle(classes) {
    // Create a temporary div to compute styles
    var div = document.createElement('div');
    div.id = 'logalize';
    div.className = classes;

    // Append the div to the DOM and compute styles
    document.getElementsByTagName('body')[0].appendChild(div);
    var computedStyle = getComputedStyle(div);
    var styles = [];

    var _iteratorNormalCompletion4 = true;
    var _didIteratorError4 = false;
    var _iteratorError4 = undefined;

    try {
      for (var _iterator4 = this.supportedStyles[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
        var s = _step4.value;

        styles.push(s + ':' + computedStyle.getPropertyValue(s));
      }
    } catch (err) {
      _didIteratorError4 = true;
      _iteratorError4 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion4 && _iterator4.return) {
          _iterator4.return();
        }
      } finally {
        if (_didIteratorError4) {
          throw _iteratorError4;
        }
      }
    }

    div.remove();

    return styles.join(';');
  },


  /* eslint-disable indent, no-useless-escape */
  supportedStyles: ['margin', 'color', 'background-color', 'border-radius', 'padding', 'font-weight', 'font-style', 'text-decoration'],

  formats: [{
    // **bold**
    regex: /\*\*([^\*]+)\*\*/,
    classes: 'bold'
  }, {
    // *italic*
    regex: /\*([^\*]+)\*/,
    classes: 'italic'
  }, {
    // ~strikethrough~
    regex: /~([^~]+)~/,
    classes: 'strikethrough'
  }, {
    // _underline_
    regex: /_([^_]+)_/,
    classes: 'underline'
  }, {
    // [badge]
    regex: /\[([^\[\]]+)\](\.[\.\w]+)?/,
    classes: function badgeClasses(match) {
      var classes = 'badge';
      if (match[2]) classes += match[2] && match[2].split('.').join(' ');
      return classes;
    }
  }, {
    // custom
    // [my text].class1.class2
    regex: /\{([^\{\}]+)\}(\.[\.\w]+)/,
    classes: function classes(match) {
      return match[2].split('.').join(' ');
    }
  }]
};

exports.default = Formatter;