@atlaskit/editor-wikimarkup-transformer 9.5.3

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

@@ -0,0 +1,50 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { TokenType } from '../index';
+import { isSafeUrl } from '@atlaskit/adf-schema';
+import { parseString } from '../../text';
+import { hasAnyOfMarks } from '../../utils/text';
+export function urlLinkResolver(link, schema, context) {
+  var output = [];
+  var url = link.notLinkBody;
+  var textRepresentation = link.linkBody || link.notLinkBody;
+
+  if (!isSafeUrl(url)) {
+    return;
+  }
+
+  var ignoreTokenTypes = [TokenType.DOUBLE_DASH_SYMBOL, TokenType.TRIPLE_DASH_SYMBOL, TokenType.QUADRUPLE_DASH_SYMBOL, TokenType.LINK_TEXT, TokenType.ISSUE_KEY];
+  var rawContent = 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' && !hasAnyOfMarks(n, ['link', 'code'])) {
+      return n.mark([].concat(_toConsumableArray(n.marks), [mark]));
+    }
+
+    return n;
+  });
+  output.push.apply(output, _toConsumableArray(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/esm/parser/tokenize/list.js

@@ -0,0 +1,318 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { getType as getListType, ListBuilder } from '../builder/list-builder';
+import { parseString } from '../text';
+import { normalizePMNodes } from '../utils/normalize';
+import { parseMacroKeyword } from './keyword';
+import { TokenType, parseToken } from './';
+import { parseNewlineOnly } from './whitespace';
+export var MAX_LIST_DEPTH = 20;
+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
+};
+export 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 = _slicedToArray(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(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 = parseString({
+                  ignoreTokenTypes: ignoreTokenTypes,
+                  schema: schema,
+                  context: context,
+                  input: buffer.join(''),
+                  includeLeadingSpace: true
+                });
+
+                (_contentBuffer = contentBuffer).push.apply(_contentBuffer, _toConsumableArray(content));
+
+                builder.add([{
+                  style: lastListSymbols,
+                  content: sanitize(normalizePMNodes(contentBuffer, schema), schema)
+                }]);
+                buffer = [];
+                contentBuffer = [];
+              } // We finished last list item here, going to the new one
+
+
+              lastListSymbols = symbols;
+              var type = getListType(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, _toConsumableArray(builder.buildPMNode()));
+                builder = new 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 = 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 = parseMacroKeyword(input.substring(index));
+
+          if (!match) {
+            buffer.push(char);
+            state = processState.BUFFER;
+            break;
+          }
+
+          var token = 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 = parseString({
+                ignoreTokenTypes: ignoreTokenTypes,
+                schema: schema,
+                context: context,
+                input: buffer.join(''),
+                includeLeadingSpace: true
+              });
+
+              (_contentBuffer2 = contentBuffer).push.apply(_contentBuffer2, _toConsumableArray(sanitize(_content, schema)));
+
+              buffer = [];
+            }
+
+            (_contentBuffer3 = contentBuffer).push.apply(_contentBuffer3, _toConsumableArray(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 = parseString({
+              ignoreTokenTypes: ignoreTokenTypes,
+              schema: schema,
+              context: context,
+              input: buffer.join(''),
+              includeLeadingSpace: true
+            });
+
+            (_contentBuffer4 = contentBuffer).push.apply(_contentBuffer4, _toConsumableArray(_content2));
+          }
+
+          builder.add([{
+            style: lastListSymbols,
+            content: sanitize(normalizePMNodes(contentBuffer, schema), schema)
+          }]);
+          output.push.apply(output, _toConsumableArray(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 = parseString({
+      ignoreTokenTypes: ignoreTokenTypes,
+      schema: schema,
+      context: context,
+      input: buffer.join(''),
+      includeLeadingSpace: true
+    });
+
+    (_contentBuffer5 = contentBuffer).push.apply(_contentBuffer5, _toConsumableArray(_content3));
+  }
+
+  if (builder) {
+    builder.add([{
+      style: lastListSymbols,
+      content: sanitize(normalizePMNodes(contentBuffer, schema), schema)
+    }]);
+    output.push.apply(output, _toConsumableArray(builder.buildPMNode()));
+  }
+
+  return {
+    type: 'pmnode',
+    nodes: output,
+    length: index - position
+  };
+};
+
+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(_toConsumableArray(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/esm/parser/tokenize/media.js

@@ -0,0 +1,36 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import getMediaSingleNodeView from '../nodes/mediaSingle';
+import { parseAttrs } from '../utils/attrs';
+import { commonFormatter } from './common-formatter';
+export 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 = _slicedToArray(_raw$split, 2),
+        rawContent = _raw$split2[0],
+        _raw$split2$ = _raw$split2[1],
+        rawAttrs = _raw$split2$ === void 0 ? '' : _raw$split2$;
+
+    var node = getMediaSingleNodeView(schema, rawContent, parseAttrs(rawAttrs, ','), context);
+    return {
+      type: 'pmnode',
+      nodes: [node],
+      length: length
+    };
+  };
+
+  return commonFormatter(input, position, schema, {
+    opening: '!',
+    closing: '!',
+    context: context,
+    rawContentProcessor: rawContentProcessor
+  });
+};

package/dist/esm/parser/tokenize/monospace.js

@@ -0,0 +1,47 @@
+import { TokenType } from './';
+import { commonFormatter } from './common-formatter';
+import { parseString } from '../text';
+export var monospace = function monospace(_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
+   */
+  var ignoreTokenTypes = [TokenType.ADF_MACRO, TokenType.ANCHOR_MACRO, TokenType.CODE_MACRO, TokenType.QUOTE_MACRO, TokenType.NOFORMAT_MACRO, TokenType.PANEL_MACRO, TokenType.COLOR_MACRO, TokenType.LOREM_MACRO, TokenType.QUOTE, TokenType.STRING, TokenType.ISSUE_KEY, TokenType.LINK_FORMAT, TokenType.LINK_TEXT, TokenType.MEDIA, TokenType.HEADING, TokenType.LIST, TokenType.TABLE, TokenType.RULER, TokenType.HARD_BREAK, TokenType.DOUBLE_DASH_SYMBOL, TokenType.TRIPLE_DASH_SYMBOL, TokenType.QUADRUPLE_DASH_SYMBOL, TokenType.STRONG, TokenType.MONOSPACE, TokenType.SUPERSCRIPT, TokenType.SUBSCRIPT, TokenType.EMPHASIS, TokenType.CITATION, TokenType.DELETED, TokenType.INSERTED, TokenType.EMOJI, TokenType.FORCE_LINE_BREAK]; // Add code mark to each text
+
+  var contentDecorator = function contentDecorator(n) {
+    var mark = schema.marks.code.create(); // We don't want to mix `code` mark with others
+
+    if (n.type.name === 'text' && n.marks.length) {
+      return n;
+    }
+
+    return n.mark([mark]);
+  };
+
+  var rawContentProcessor = function rawContentProcessor(raw, length) {
+    var content = parseString({
+      ignoreTokenTypes: ignoreTokenTypes,
+      schema: schema,
+      context: context,
+      input: raw
+    });
+    var decoratedContent = content.map(contentDecorator);
+    return {
+      type: 'pmnode',
+      nodes: decoratedContent,
+      length: length
+    };
+  };
+
+  return commonFormatter(input, position, schema, {
+    opening: '{{',
+    closing: '}}',
+    context: context,
+    rawContentProcessor: rawContentProcessor
+  });
+};