@atlaskit/editor-wikimarkup-transformer 9.5.3

package/dist/cjs/parser/tokenize/links/mention-link.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mentionLinkResolver = mentionLinkResolver;
+
+function mentionLinkResolver(link, schema, context) {
+  // [CS-1896] Empty mention nodes should fallback to plaintext
+  if (link.notLinkBody.toLowerCase() === '~accountid:' || link.notLinkBody === '~') {
+    return [schema.nodes.paragraph.createChecked({}, [schema.nodes.text.create({})])];
+  }
+
+  if (link.notLinkBody.startsWith('~')) {
+    var mentionText = link.notLinkBody.substring(1);
+    var mentionKey = mentionText.toLowerCase();
+    var id = context.conversion && context.conversion.mentionConversion && context.conversion.mentionConversion[mentionKey] ? context.conversion.mentionConversion[mentionKey] : mentionText;
+    return [schema.nodes.mention.createChecked({
+      id: id
+    })];
+  }
+
+  return;
+}

package/dist/cjs/parser/tokenize/links/url-link.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.urlLinkResolver = urlLinkResolver;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _index = require("../index");
+
+var _adfSchema = require("@atlaskit/adf-schema");
+
+var _text = require("../../text");
+
+var _text2 = require("../../utils/text");
+
+function urlLinkResolver(link, schema, context) {
+  var output = [];
+  var url = link.notLinkBody;
+  var textRepresentation = link.linkBody || link.notLinkBody;
+
+  if (!(0, _adfSchema.isSafeUrl)(url)) {
+    return;
+  }
+
+  var ignoreTokenTypes = [_index.TokenType.DOUBLE_DASH_SYMBOL, _index.TokenType.TRIPLE_DASH_SYMBOL, _index.TokenType.QUADRUPLE_DASH_SYMBOL, _index.TokenType.LINK_TEXT, _index.TokenType.ISSUE_KEY];
+  var rawContent = (0, _text.parseString)({
+    ignoreTokenTypes: ignoreTokenTypes,
+    schema: schema,
+    context: context,
+    input: textRepresentation.replace(/^mailto:/, '')
+  });
+  var decoratedContent = rawContent.map(function (n) {
+    var mark = schema.marks.link.create({
+      href: url
+    }); // We don't want to mix `code` mark with others
+
+    if (n.type.name === 'text' && !(0, _text2.hasAnyOfMarks)(n, ['link', 'code'])) {
+      return n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [mark]));
+    }
+
+    return n;
+  });
+  output.push.apply(output, (0, _toConsumableArray2.default)(decoratedContent));
+
+  if (!hasTextNode(rawContent)) {
+    var mark = schema.marks.link.create({
+      href: url
+    });
+    var linkTextNode = schema.text(textRepresentation, [mark]);
+    output.push(linkTextNode);
+  }
+
+  return output;
+}
+
+function hasTextNode(nodes) {
+  return nodes.find(function (n) {
+    return n.type.name === 'text';
+  });
+}

package/dist/cjs/parser/tokenize/list.js

@@ -0,0 +1,339 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.list = exports.MAX_LIST_DEPTH = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _listBuilder = require("../builder/list-builder");
+
+var _text = require("../text");
+
+var _normalize = require("../utils/normalize");
+
+var _keyword = require("./keyword");
+
+var _ = require("./");
+
+var _whitespace = require("./whitespace");
+
+var MAX_LIST_DEPTH = 20;
+exports.MAX_LIST_DEPTH = MAX_LIST_DEPTH;
+var LIST_ITEM_REGEXP = new RegExp("^ *([*\\-#]{1,".concat(MAX_LIST_DEPTH, "}) "));
+var EMPTY_LINE_REGEXP = /^[ \t]*\r?\n/;
+var RULER_SYMBOL_REGEXP = /^-{4,5}/;
+var processState = {
+  NEW_LINE: 0,
+  BUFFER: 1,
+  END: 2,
+  MACRO: 3
+};
+
+var list = function list(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema,
+      context = _ref.context;
+
+  /**
+   * The following token types will be ignored in parsing
+   * the content of a listItem
+   */
+  var ignoreTokenTypes = [_.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.LIST, _.TokenType.TABLE];
+  var index = position;
+  var state = processState.NEW_LINE;
+  var buffer = [];
+  var lastListSymbols = null;
+  var builder = null;
+  var contentBuffer = [];
+  var output = [];
+
+  while (index < input.length) {
+    var char = input.charAt(index);
+
+    switch (state) {
+      case processState.NEW_LINE:
+        {
+          var substring = input.substring(index);
+          var listMatch = substring.match(LIST_ITEM_REGEXP);
+
+          if (listMatch) {
+            var _listMatch = (0, _slicedToArray2.default)(listMatch, 2),
+                symbols = _listMatch[1]; // Handle ruler in list
+
+
+            var rulerMatch = symbols.match(RULER_SYMBOL_REGEXP);
+
+            if (rulerMatch) {
+              var remainingAfterSymbol = input.substring(index + rulerMatch[0].length);
+
+              var _emptyLineMatch = remainingAfterSymbol.match(EMPTY_LINE_REGEXP); // If this is an empty line skip to the buffering step rather than match as a list element
+
+
+              if (_emptyLineMatch) {
+                state = processState.BUFFER;
+                continue;
+              }
+            }
+
+            if (!builder) {
+              // It happens because this is the first item of the list
+              builder = new _listBuilder.ListBuilder(schema, symbols);
+              lastListSymbols = symbols;
+            } else {
+              /**
+               * There is a builder, so we are in the middle of building a list
+               * and now there is a new list item
+               */
+              if (buffer.length > 0) {
+                var _contentBuffer;
+
+                // Wrap up previous list item and clear buffer
+                var content = (0, _text.parseString)({
+                  ignoreTokenTypes: ignoreTokenTypes,
+                  schema: schema,
+                  context: context,
+                  input: buffer.join(''),
+                  includeLeadingSpace: true
+                });
+
+                (_contentBuffer = contentBuffer).push.apply(_contentBuffer, (0, _toConsumableArray2.default)(content));
+
+                builder.add([{
+                  style: lastListSymbols,
+                  content: sanitize((0, _normalize.normalizePMNodes)(contentBuffer, schema), schema)
+                }]);
+                buffer = [];
+                contentBuffer = [];
+              } // We finished last list item here, going to the new one
+
+
+              lastListSymbols = symbols;
+              var type = (0, _listBuilder.getType)(symbols); // If it's top level and doesn't match, create a new list
+
+              if (type !== builder.type && symbols.length === 1) {
+                output.push.apply(output, (0, _toConsumableArray2.default)(builder.buildPMNode()));
+                builder = new _listBuilder.ListBuilder(schema, symbols);
+              }
+            }
+
+            index += listMatch[0].length;
+          } // If we encounter an empty line, we should end the list
+
+
+          var emptyLineMatch = substring.match(EMPTY_LINE_REGEXP);
+
+          if (emptyLineMatch) {
+            state = processState.END;
+            continue;
+          }
+
+          state = processState.BUFFER;
+          continue;
+        }
+
+      case processState.BUFFER:
+        {
+          var length = (0, _whitespace.parseNewlineOnly)(input.substring(index));
+
+          if (length) {
+            buffer.push(input.substr(index, length));
+            state = processState.NEW_LINE;
+            index += length;
+            continue;
+          }
+
+          if (char === '{') {
+            state = processState.MACRO;
+            continue;
+          } else {
+            buffer.push(char);
+          }
+
+          break;
+        }
+
+      case processState.MACRO:
+        {
+          var match = (0, _keyword.parseMacroKeyword)(input.substring(index));
+
+          if (!match) {
+            buffer.push(char);
+            state = processState.BUFFER;
+            break;
+          }
+
+          var token = (0, _.parseToken)(input, match.type, index, schema, context);
+
+          if (token.type === 'text') {
+            buffer.push(token.text);
+          } else {
+            var _contentBuffer3;
+
+            // We found a macro in the list...
+            if (!builder) {
+              // Something is really wrong here
+              return fallback(input, position);
+            }
+
+            if (buffer.length > 0) {
+              var _contentBuffer2;
+
+              /**
+               * Wrapup what is already in the string buffer and save it to
+               * contentBuffer
+               */
+              var _content = (0, _text.parseString)({
+                ignoreTokenTypes: ignoreTokenTypes,
+                schema: schema,
+                context: context,
+                input: buffer.join(''),
+                includeLeadingSpace: true
+              });
+
+              (_contentBuffer2 = contentBuffer).push.apply(_contentBuffer2, (0, _toConsumableArray2.default)(sanitize(_content, schema)));
+
+              buffer = [];
+            }
+
+            (_contentBuffer3 = contentBuffer).push.apply(_contentBuffer3, (0, _toConsumableArray2.default)(sanitize(token.nodes, schema)));
+          }
+
+          index += token.length;
+          state = processState.BUFFER;
+          continue;
+        }
+
+      case processState.END:
+        {
+          if (!builder) {
+            // Something is really wrong here
+            return fallback(input, position);
+          }
+
+          if (buffer.length > 0) {
+            var _contentBuffer4;
+
+            // Wrap up previous list item and clear buffer
+            var _content2 = (0, _text.parseString)({
+              ignoreTokenTypes: ignoreTokenTypes,
+              schema: schema,
+              context: context,
+              input: buffer.join(''),
+              includeLeadingSpace: true
+            });
+
+            (_contentBuffer4 = contentBuffer).push.apply(_contentBuffer4, (0, _toConsumableArray2.default)(_content2));
+          }
+
+          builder.add([{
+            style: lastListSymbols,
+            content: sanitize((0, _normalize.normalizePMNodes)(contentBuffer, schema), schema)
+          }]);
+          output.push.apply(output, (0, _toConsumableArray2.default)(builder.buildPMNode()));
+          return {
+            type: 'pmnode',
+            nodes: output,
+            length: index - position
+          };
+        }
+    }
+
+    index++;
+  }
+
+  if (buffer.length > 0) {
+    var _contentBuffer5;
+
+    // Wrap up what's left in the buffer
+    var _content3 = (0, _text.parseString)({
+      ignoreTokenTypes: ignoreTokenTypes,
+      schema: schema,
+      context: context,
+      input: buffer.join(''),
+      includeLeadingSpace: true
+    });
+
+    (_contentBuffer5 = contentBuffer).push.apply(_contentBuffer5, (0, _toConsumableArray2.default)(_content3));
+  }
+
+  if (builder) {
+    builder.add([{
+      style: lastListSymbols,
+      content: sanitize((0, _normalize.normalizePMNodes)(contentBuffer, schema), schema)
+    }]);
+    output.push.apply(output, (0, _toConsumableArray2.default)(builder.buildPMNode()));
+  }
+
+  return {
+    type: 'pmnode',
+    nodes: output,
+    length: index - position
+  };
+};
+
+exports.list = list;
+
+function sanitize(nodes, schema) {
+  return nodes.reduce(function (result, curr) {
+    switch (curr.type.name) {
+      case 'blockquote':
+        {
+          /**
+           * If a blockquote is inside a list item
+           * - Convert it to paragraph
+           */
+          curr.content.forEach(function (n) {
+            result.push(n);
+          });
+          break;
+        }
+
+      case 'heading':
+        {
+          /**
+           * If a heading is inside a list item
+           * - Convert the heading to paragraph
+           * - Convert text to upper case
+           * - Mark text with strong.
+           */
+          var contentBuffer = [];
+          curr.content.forEach(function (n) {
+            var mark = schema.marks.strong.create();
+
+            if (n.type.name === 'text') {
+              if (n.text) {
+                n.text = n.text.toUpperCase();
+              }
+
+              contentBuffer.push(n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [mark])));
+            } else {
+              contentBuffer.push(n);
+            }
+          });
+          var p = schema.nodes.paragraph.createChecked({}, contentBuffer);
+          result.push(p);
+          break;
+        }
+
+      default:
+        result.push(curr);
+    }
+
+    return result;
+  }, []);
+}
+
+function fallback(input, position) {
+  return {
+    type: 'text',
+    text: input.substr(position, 1),
+    length: 1
+  };
+}

package/dist/cjs/parser/tokenize/media.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.media = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _mediaSingle = _interopRequireDefault(require("../nodes/mediaSingle"));
+
+var _attrs = require("../utils/attrs");
+
+var _commonFormatter = require("./common-formatter");
+
+var media = function media(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema,
+      context = _ref.context;
+
+  var rawContentProcessor = function rawContentProcessor(raw, length) {
+    /**
+     * !image.gif|align=right, vspace=4|ignore-this!
+     * If it splits into more than 2 items, we ignore the rest
+     */
+    var _raw$split = raw.split('|'),
+        _raw$split2 = (0, _slicedToArray2.default)(_raw$split, 2),
+        rawContent = _raw$split2[0],
+        _raw$split2$ = _raw$split2[1],
+        rawAttrs = _raw$split2$ === void 0 ? '' : _raw$split2$;
+
+    var node = (0, _mediaSingle.default)(schema, rawContent, (0, _attrs.parseAttrs)(rawAttrs, ','), context);
+    return {
+      type: 'pmnode',
+      nodes: [node],
+      length: length
+    };
+  };
+
+  return (0, _commonFormatter.commonFormatter)(input, position, schema, {
+    opening: '!',
+    closing: '!',
+    context: context,
+    rawContentProcessor: rawContentProcessor
+  });
+};
+
+exports.media = media;