draft-js-export-html-forked/esm/stateToHTML.js

DraftJS: Export ContentState to HTML

var _DEFAULT_STYLE_MAP, _ENTITY_ATTR_MAP, _DATA_TO_ATTR;

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { keys.push.apply(keys, Object.getOwnPropertySymbols(object)); } if (enumerableOnly) keys = keys.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

import combineOrderedStyles from './helpers/combineOrderedStyles';
import normalizeAttributes from './helpers/normalizeAttributes';
import styleToCSS from './helpers/styleToCSS';
import { getEntityRanges, BLOCK_TYPE, ENTITY_TYPE, INLINE_STYLE } from 'draft-js-utils';
var BOLD = INLINE_STYLE.BOLD,
    CODE = INLINE_STYLE.CODE,
    ITALIC = INLINE_STYLE.ITALIC,
    STRIKETHROUGH = INLINE_STYLE.STRIKETHROUGH,
    UNDERLINE = INLINE_STYLE.UNDERLINE;
var INDENT = '  ';
var BREAK = '<br>';
var DATA_ATTRIBUTE = /^data-([a-z0-9-]+)$/;
var DEFAULT_STYLE_MAP = (_DEFAULT_STYLE_MAP = {}, _defineProperty(_DEFAULT_STYLE_MAP, BOLD, {
  element: 'strong'
}), _defineProperty(_DEFAULT_STYLE_MAP, CODE, {
  element: 'code'
}), _defineProperty(_DEFAULT_STYLE_MAP, ITALIC, {
  element: 'em'
}), _defineProperty(_DEFAULT_STYLE_MAP, STRIKETHROUGH, {
  element: 'del'
}), _defineProperty(_DEFAULT_STYLE_MAP, UNDERLINE, {
  element: 'u'
}), _DEFAULT_STYLE_MAP); // Order: inner-most style to outer-most.
// Examle: <em><strong>foo</strong></em>

var DEFAULT_STYLE_ORDER = [BOLD, ITALIC, UNDERLINE, STRIKETHROUGH, CODE]; // Map entity data to element attributes.

var ENTITY_ATTR_MAP = (_ENTITY_ATTR_MAP = {}, _defineProperty(_ENTITY_ATTR_MAP, ENTITY_TYPE.LINK, {
  url: 'href',
  href: 'href',
  rel: 'rel',
  target: 'target',
  title: 'title',
  className: 'class'
}), _defineProperty(_ENTITY_ATTR_MAP, ENTITY_TYPE.IMAGE, {
  src: 'src',
  height: 'height',
  width: 'width',
  alt: 'alt',
  className: 'class'
}), _ENTITY_ATTR_MAP); // Map entity data to element attributes.

var DATA_TO_ATTR = (_DATA_TO_ATTR = {}, _defineProperty(_DATA_TO_ATTR, ENTITY_TYPE.LINK, function (entityType, entity) {
  var attrMap = ENTITY_ATTR_MAP.hasOwnProperty(entityType) ? ENTITY_ATTR_MAP[entityType] : {};
  var data = entity.getData();
  var attrs = {};

  for (var _i = 0, _Object$keys = Object.keys(data); _i < _Object$keys.length; _i++) {
    var dataKey = _Object$keys[_i];
    var dataValue = data[dataKey];

    if (attrMap.hasOwnProperty(dataKey)) {
      var attrKey = attrMap[dataKey];
      attrs[attrKey] = dataValue;
    } else if (DATA_ATTRIBUTE.test(dataKey)) {
      attrs[dataKey] = dataValue;
    }
  }

  return attrs;
}), _defineProperty(_DATA_TO_ATTR, ENTITY_TYPE.IMAGE, function (entityType, entity) {
  var attrMap = ENTITY_ATTR_MAP.hasOwnProperty(entityType) ? ENTITY_ATTR_MAP[entityType] : {};
  var data = entity.getData();
  var attrs = {};

  for (var _i2 = 0, _Object$keys2 = Object.keys(data); _i2 < _Object$keys2.length; _i2++) {
    var dataKey = _Object$keys2[_i2];
    var dataValue = data[dataKey];

    if (attrMap.hasOwnProperty(dataKey)) {
      var attrKey = attrMap[dataKey];
      attrs[attrKey] = dataValue;
    } else if (DATA_ATTRIBUTE.test(dataKey)) {
      attrs[dataKey] = dataValue;
    }
  }

  return attrs;
}), _DATA_TO_ATTR); // The reason this returns an array is because a single block might get wrapped
// in two tags.

function getTags(blockType, defaultBlockTag) {
  switch (blockType) {
    case BLOCK_TYPE.HEADER_ONE:
      return ['h1'];

    case BLOCK_TYPE.HEADER_TWO:
      return ['h2'];

    case BLOCK_TYPE.HEADER_THREE:
      return ['h3'];

    case BLOCK_TYPE.HEADER_FOUR:
      return ['h4'];

    case BLOCK_TYPE.HEADER_FIVE:
      return ['h5'];

    case BLOCK_TYPE.HEADER_SIX:
      return ['h6'];

    case BLOCK_TYPE.UNORDERED_LIST_ITEM:
    case BLOCK_TYPE.ORDERED_LIST_ITEM:
      return ['li'];

    case BLOCK_TYPE.BLOCKQUOTE:
      return ['blockquote'];

    case BLOCK_TYPE.CODE:
      return ['pre', 'code'];

    case BLOCK_TYPE.ATOMIC:
      return ['figure'];

    default:
      if (defaultBlockTag === null) {
        return [];
      }

      return [defaultBlockTag || 'p'];
  }
}

function getWrapperTag(blockType) {
  switch (blockType) {
    case 'spoiler':
      return "div class=\"spoiler\"";

    case BLOCK_TYPE.UNORDERED_LIST_ITEM:
      return 'ul';

    case BLOCK_TYPE.ORDERED_LIST_ITEM:
      return 'ol';

    default:
      return null;
  }
}

var MarkupGenerator =
/*#__PURE__*/
function () {
  // These are related to state.
  // These are related to user-defined options.
  function MarkupGenerator(contentState, options) {
    _classCallCheck(this, MarkupGenerator);

    _defineProperty(this, "blocks", void 0);

    _defineProperty(this, "contentState", void 0);

    _defineProperty(this, "currentBlock", void 0);

    _defineProperty(this, "indentLevel", void 0);

    _defineProperty(this, "output", void 0);

    _defineProperty(this, "totalBlocks", void 0);

    _defineProperty(this, "wrapperTag", void 0);

    _defineProperty(this, "options", void 0);

    _defineProperty(this, "inlineStyles", void 0);

    _defineProperty(this, "inlineStyleFn", void 0);

    _defineProperty(this, "styleOrder", void 0);

    if (options == null) {
      options = {};
    }

    this.contentState = contentState;
    this.options = options;

    var _combineOrderedStyles = combineOrderedStyles(options.inlineStyles, [DEFAULT_STYLE_MAP, DEFAULT_STYLE_ORDER]),
        _combineOrderedStyles2 = _slicedToArray(_combineOrderedStyles, 2),
        inlineStyles = _combineOrderedStyles2[0],
        styleOrder = _combineOrderedStyles2[1];

    this.inlineStyles = inlineStyles;
    this.inlineStyleFn = options.inlineStyleFn;
    this.styleOrder = styleOrder;
  }

  _createClass(MarkupGenerator, [{
    key: "generate",
    value: function generate() {
      this.output = [];
      this.blocks = this.contentState.getBlocksAsArray();
      this.totalBlocks = this.blocks.length;
      this.currentBlock = 0;
      this.indentLevel = 0;
      this.wrapperTag = null;

      while (this.currentBlock < this.totalBlocks) {
        this.processBlock();
      }

      this.closeWrapperTag();
      return this.output.join('').trim();
    }
  }, {
    key: "processBlock",
    value: function processBlock() {
      var _this$options = this.options,
          blockRenderers = _this$options.blockRenderers,
          defaultBlockTag = _this$options.defaultBlockTag;
      var block = this.blocks[this.currentBlock];
      var blockType = block.getType();
      var newWrapperTag = getWrapperTag(blockType);

      if (this.wrapperTag !== newWrapperTag) {
        if (this.wrapperTag) {
          this.closeWrapperTag();
        }

        if (newWrapperTag) {
          this.openWrapperTag(newWrapperTag);
        }
      }

      this.indent(); // Allow blocks to be rendered using a custom renderer.

      var customRenderer = blockRenderers != null && blockRenderers.hasOwnProperty(blockType) ? blockRenderers[blockType] : null;
      var customRendererOutput = customRenderer ? customRenderer(block) : null; // Renderer can return null, which will cause processing to continue as normal.

      if (customRendererOutput != null) {
        this.output.push(customRendererOutput);
        this.output.push('\n');
        this.currentBlock += 1;
        return;
      }

      this.writeStartTag(block, defaultBlockTag);
      this.output.push(this.renderBlockContent(block)); // Look ahead and see if we will nest list.

      var nextBlock = this.getNextBlock();

      if (canHaveDepth(blockType) && nextBlock && nextBlock.getDepth() === block.getDepth() + 1) {
        this.output.push('\n'); // This is a litle hacky: temporarily stash our current wrapperTag and
        // render child list(s).

        var thisWrapperTag = this.wrapperTag;
        this.wrapperTag = null;
        this.indentLevel += 1;
        this.currentBlock += 1;
        this.processBlocksAtDepth(nextBlock.getDepth());
        this.wrapperTag = thisWrapperTag;
        this.indentLevel -= 1;
        this.indent();
      } else {
        this.currentBlock += 1;
      }

      this.writeEndTag(block, defaultBlockTag);
    }
  }, {
    key: "processBlocksAtDepth",
    value: function processBlocksAtDepth(depth) {
      var block = this.blocks[this.currentBlock];

      while (block && block.getDepth() === depth) {
        this.processBlock();
        block = this.blocks[this.currentBlock];
      }

      this.closeWrapperTag();
    }
  }, {
    key: "getNextBlock",
    value: function getNextBlock() {
      return this.blocks[this.currentBlock + 1];
    }
  }, {
    key: "writeStartTag",
    value: function writeStartTag(block, defaultBlockTag) {
      var tags = getTags(block.getType(), defaultBlockTag);
      var attrString;

      if (this.options.blockStyleFn) {
        var _ref = this.options.blockStyleFn(block) || {},
            attributes = _ref.attributes,
            _style = _ref.style; // Normalize `className` -> `class`, etc.


        attributes = normalizeAttributes(attributes);

        if (_style != null) {
          var styleAttr = styleToCSS(_style);
          attributes = attributes == null ? {
            style: styleAttr
          } : _objectSpread({}, attributes, {
            style: styleAttr
          });
        }

        attrString = stringifyAttrs(attributes);
      } else {
        attrString = '';
      }

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

      try {
        for (var _iterator = tags[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var tag = _step.value;
          this.output.push("<".concat(tag).concat(attrString, ">"));
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator["return"] != null) {
            _iterator["return"]();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    }
  }, {
    key: "writeEndTag",
    value: function writeEndTag(block, defaultBlockTag) {
      var tags = getTags(block.getType(), defaultBlockTag);

      if (tags.length === 1) {
        this.output.push("</".concat(tags[0], ">\n"));
      } else {
        var output = [];
        var _iteratorNormalCompletion2 = true;
        var _didIteratorError2 = false;
        var _iteratorError2 = undefined;

        try {
          for (var _iterator2 = tags[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
            var tag = _step2.value;
            output.unshift("</".concat(tag, ">"));
          }
        } catch (err) {
          _didIteratorError2 = true;
          _iteratorError2 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
              _iterator2["return"]();
            }
          } finally {
            if (_didIteratorError2) {
              throw _iteratorError2;
            }
          }
        }

        this.output.push(output.join('') + '\n');
      }
    }
  }, {
    key: "openWrapperTag",
    value: function openWrapperTag(wrapperTag) {
      this.wrapperTag = wrapperTag;
      this.indent();
      this.output.push("<".concat(wrapperTag, ">\n"));
      this.indentLevel += 1;
    }
  }, {
    key: "closeWrapperTag",
    value: function closeWrapperTag() {
      var wrapperTag = this.wrapperTag;

      if (wrapperTag) {
        this.indentLevel -= 1;
        this.indent();
        this.output.push("</".concat(wrapperTag, ">\n"));
        this.wrapperTag = null;
      }
    }
  }, {
    key: "indent",
    value: function indent() {
      this.output.push(INDENT.repeat(this.indentLevel));
    }
  }, {
    key: "withCustomInlineStyles",
    value: function withCustomInlineStyles(content, styleSet) {
      if (!this.inlineStyleFn) {
        return content;
      }

      var renderConfig = this.inlineStyleFn(styleSet);

      if (!renderConfig) {
        return content;
      }

      var _renderConfig$element = renderConfig.element,
          element = _renderConfig$element === void 0 ? 'span' : _renderConfig$element,
          attributes = renderConfig.attributes,
          style = renderConfig.style;
      var attrString = stringifyAttrs(_objectSpread({}, attributes, {
        style: style && styleToCSS(style)
      }));
      return "<".concat(element).concat(attrString, ">").concat(content, "</").concat(element, ">");
    }
  }, {
    key: "renderBlockContent",
    value: function renderBlockContent(block) {
      var _this = this;

      var blockType = block.getType();
      var text = block.getText();

      if (text === '') {
        // Prevent element collapse if completely empty.
        return BREAK;
      }

      text = this.preserveWhitespace(text);
      var charMetaList = block.getCharacterList();
      var entityPieces = getEntityRanges(text, charMetaList);
      return entityPieces.map(function (_ref2) {
        var _ref3 = _slicedToArray(_ref2, 2),
            entityKey = _ref3[0],
            stylePieces = _ref3[1];

        var content = stylePieces.map(function (_ref4) {
          var _ref5 = _slicedToArray(_ref4, 2),
              text = _ref5[0],
              styleSet = _ref5[1];

          var content = encodeContent(text);
          var _iteratorNormalCompletion3 = true;
          var _didIteratorError3 = false;
          var _iteratorError3 = undefined;

          try {
            for (var _iterator3 = _this.styleOrder[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
              var _styleName = _step3.value;

              // If our block type is CODE then don't wrap inline code elements.
              if (_styleName === CODE && blockType === BLOCK_TYPE.CODE) {
                continue;
              }

              if (styleSet.has(_styleName)) {
                var _this$inlineStyles$_s = _this.inlineStyles[_styleName],
                    element = _this$inlineStyles$_s.element,
                    attributes = _this$inlineStyles$_s.attributes,
                    _style2 = _this$inlineStyles$_s.style;

                if (element == null) {
                  element = 'span';
                } // Normalize `className` -> `class`, etc.


                attributes = normalizeAttributes(attributes);

                if (_style2 != null) {
                  var styleAttr = styleToCSS(_style2);
                  attributes = attributes == null ? {
                    style: styleAttr
                  } : _objectSpread({}, attributes, {
                    style: styleAttr
                  });
                }

                var attrString = stringifyAttrs(attributes);
                content = "<".concat(element).concat(attrString, ">").concat(content, "</").concat(element, ">");
              }
            }
          } catch (err) {
            _didIteratorError3 = true;
            _iteratorError3 = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion3 && _iterator3["return"] != null) {
                _iterator3["return"]();
              }
            } finally {
              if (_didIteratorError3) {
                throw _iteratorError3;
              }
            }
          }

          return _this.withCustomInlineStyles(content, styleSet);
        }).join('');
        var entity = entityKey ? _this.contentState.getEntity(entityKey) : null; // Note: The `toUpperCase` below is for compatability with some libraries that use lower-case for image blocks.

        var entityType = entity == null ? null : entity.getType().toUpperCase();
        var entityStyle;

        if (entity != null && _this.options.entityStyleFn && (entityStyle = _this.options.entityStyleFn(entity))) {
          var _entityStyle = entityStyle,
              element = _entityStyle.element,
              attributes = _entityStyle.attributes,
              _style3 = _entityStyle.style;

          if (element == null) {
            element = 'span';
          } // Normalize `className` -> `class`, etc.


          attributes = normalizeAttributes(attributes);

          if (_style3 != null) {
            var styleAttr = styleToCSS(_style3);
            attributes = attributes == null ? {
              style: styleAttr
            } : _objectSpread({}, attributes, {
              style: styleAttr
            });
          }

          var attrString = stringifyAttrs(attributes);
          return "<".concat(element).concat(attrString, ">").concat(content, "</").concat(element, ">");
        } else if (entityType != null && entityType === ENTITY_TYPE.LINK) {
          var attrs = DATA_TO_ATTR.hasOwnProperty(entityType) ? DATA_TO_ATTR[entityType](entityType, entity) : null;

          var _attrString = stringifyAttrs(attrs);

          return "<a".concat(_attrString, ">").concat(content, "</a>");
        } else if (entityType != null && entityType === ENTITY_TYPE.IMAGE) {
          var _attrs = DATA_TO_ATTR.hasOwnProperty(entityType) ? DATA_TO_ATTR[entityType](entityType, entity) : null;

          var _attrString2 = stringifyAttrs(_attrs);

          return "<img".concat(_attrString2, "/>");
        } else {
          return content;
        }
      }).join('');
    }
  }, {
    key: "preserveWhitespace",
    value: function preserveWhitespace(text) {
      var length = text.length; // Prevent leading/trailing/consecutive whitespace collapse.

      var newText = new Array(length);

      for (var i = 0; i < length; i++) {
        if (text[i] === ' ' && (i === 0 || i === length - 1 || text[i - 1] === ' ')) {
          newText[i] = '\xA0';
        } else {
          newText[i] = text[i];
        }
      }

      return newText.join('');
    }
  }]);

  return MarkupGenerator;
}();

function stringifyAttrs(attrs) {
  if (attrs == null) {
    return '';
  }

  var parts = [];

  for (var _i3 = 0, _Object$keys3 = Object.keys(attrs); _i3 < _Object$keys3.length; _i3++) {
    var name = _Object$keys3[_i3];
    var value = attrs[name];

    if (value != null) {
      parts.push(" ".concat(name, "=\"").concat(encodeAttr(value + ''), "\""));
    }
  }

  return parts.join('');
}

function canHaveDepth(blockType) {
  switch (blockType) {
    case BLOCK_TYPE.UNORDERED_LIST_ITEM:
    case BLOCK_TYPE.ORDERED_LIST_ITEM:
      return true;

    default:
      return false;
  }
}

function encodeContent(text) {
  return text.split('&').join('&amp;').split('<').join('&lt;').split('>').join('&gt;').split('\xA0').join('&nbsp;').split('\n').join(BREAK + '\n');
}

function encodeAttr(text) {
  return text.split('&').join('&amp;').split('<').join('&lt;').split('>').join('&gt;').split('"').join('&quot;');
}

export default function stateToHTML(content, options) {
  return new MarkupGenerator(content, options).generate();
}