@atlaskit/editor-wikimarkup-transformer 9.5.3

package/dist/esm/parser/tokenize/adf-macro.js

@@ -0,0 +1,39 @@
+import { commonMacro } from './common-macro';
+export var adfMacro = function adfMacro(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema,
+      context = _ref.context;
+  return commonMacro(input.substring(position), schema, {
+    keyword: 'adf',
+    paired: true,
+    context: context,
+    rawContentProcessor: rawContentProcessor
+  });
+};
+
+var rawContentProcessor = function rawContentProcessor(_rawAttrs, rawContent, length, schema, _context) {
+  try {
+    var json = JSON.parse(rawContent);
+    var node = schema.nodeFromJSON(json);
+    return {
+      type: 'pmnode',
+      nodes: [node],
+      length: length
+    };
+  } catch (_e) {
+    var textContent = "Invalid ADF Macro: ".concat(rawContent);
+    var textNode = rawContent.length ? schema.text(textContent) : undefined;
+    var codeBlock = schema.nodes.codeBlock;
+
+    var _node = codeBlock.create({
+      language: undefined
+    }, textNode);
+
+    return {
+      type: 'pmnode',
+      nodes: [_node],
+      length: length
+    };
+  }
+};

package/dist/esm/parser/tokenize/anchor-macro.js

@@ -0,0 +1,21 @@
+import { commonMacro } from './common-macro';
+export var anchorMacro = function anchorMacro(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema,
+      context = _ref.context;
+  return commonMacro(input.substring(position), schema, {
+    keyword: 'anchor',
+    paired: false,
+    context: context,
+    rawContentProcessor: rawContentProcessor
+  });
+};
+
+var rawContentProcessor = function rawContentProcessor(_rawAttrs, _rawContent, length, _schema, _context) {
+  return {
+    type: 'text',
+    text: '',
+    length: length
+  };
+};

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

@@ -0,0 +1,28 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { rawContentProcessor } from './quote-macro';
+// bq. foobarbaz
+var BLOCKQUOTE_REGEXP = /^bq\.(.*)/;
+export var blockquote = function blockquote(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema,
+      context = _ref.context;
+  var match = input.substring(position).match(BLOCKQUOTE_REGEXP);
+
+  if (!match) {
+    return fallback(input, position);
+  }
+
+  var _match = _slicedToArray(match, 2),
+      rawContent = _match[1];
+
+  return rawContentProcessor('', rawContent, match[0].length, schema, context);
+};
+
+function fallback(input, position) {
+  return {
+    type: 'text',
+    text: input.substr(position, 1),
+    length: 1
+  };
+}

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

@@ -0,0 +1,54 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { TokenType } from './';
+import { hasAnyOfMarks } from '../utils/text';
+import { commonFormatter } from './common-formatter';
+import { parseString } from '../text';
+import { EM_DASH } from '../../char';
+export var citation = function citation(_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.DOUBLE_DASH_SYMBOL, TokenType.TRIPLE_DASH_SYMBOL, TokenType.QUADRUPLE_DASH_SYMBOL, TokenType.ISSUE_KEY]; // Add code mark to each text
+
+  var contentDecorator = function contentDecorator(n, index) {
+    var mark = schema.marks.em.create(); // We don't want to mix `code` mark with others
+
+    if (n.type.name === 'text' && !hasAnyOfMarks(n, ['em', 'code'])) {
+      if (index === 0) {
+        n.text = "".concat(EM_DASH, " ").concat(n.text);
+      }
+
+      return n.mark([].concat(_toConsumableArray(n.marks), [mark]));
+    }
+
+    return n;
+  };
+
+  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
+  });
+};

package/dist/esm/parser/tokenize/code-macro.js

@@ -0,0 +1,80 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import { commonMacro } from './common-macro';
+import { parseAttrs } from '../utils/attrs';
+import { title } from '../utils/title';
+var SUPPORTED_CODEBOCK_LANGUAGES = ['abap', 'actionscript', 'ada', 'arduino', 'autoit', 'c', 'c++', 'clojure', 'coffeescript', 'csharp', 'css', 'cuda', 'd', 'dart', 'delphi', 'elixir', 'erlang', 'fortran', 'foxpro', 'go', 'groovy', 'haskell', 'haxe', 'html', 'java', 'javascript', 'json', 'julia', 'kotlin', 'latex', 'livescript', 'lua', 'mathematica', 'matlab', 'objective-c', 'objective-j', 'objectpascal', 'ocaml', 'octave', 'perl', 'php', 'powershell', 'prolog', 'puppet', 'python', 'qml', 'r', 'racket', 'restructuredtext', 'ruby', 'rust', 'sass', 'scala', 'scheme', 'shell', 'smalltalk', 'sql', 'standardml', 'swift', 'tcl', 'tex', 'typescript', 'vala', 'vbnet', 'verilog', 'vhdl', 'xml', 'xquery'];
+export var codeMacro = function codeMacro(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema,
+      context = _ref.context;
+  return commonMacro(input.substring(position), schema, {
+    keyword: 'code',
+    paired: true,
+    context: context,
+    rawContentProcessor: rawContentProcessor
+  });
+};
+
+var rawContentProcessor = function rawContentProcessor(rawAttrs, rawContent, length, schema) {
+  var output = [];
+  var codeBlock = schema.nodes.codeBlock;
+  var parsedAttrs = parseAttrs(rawAttrs);
+  var trimedContent = rawContent.replace(/^\s+|\s+$/g, '');
+  var textNode = trimedContent.length ? schema.text(trimedContent) : undefined;
+
+  if (parsedAttrs.title) {
+    output.push(title(parsedAttrs.title, schema));
+  }
+
+  var nodeAttrs = _objectSpread(_objectSpread({}, parsedAttrs), {}, {
+    language: getCodeLanguage(parsedAttrs)
+  });
+
+  output.push(codeBlock.createChecked(nodeAttrs, textNode));
+  return {
+    type: 'pmnode',
+    nodes: output,
+    length: length
+  };
+};
+
+function getCodeLanguage(attrs) {
+  var keys = Object.keys(attrs).map(function (key) {
+    return key.toLowerCase();
+  });
+
+  var _iterator = _createForOfIteratorHelper(SUPPORTED_CODEBOCK_LANGUAGES),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var language = _step.value;
+
+      if (keys.indexOf(language) !== -1) {
+        return language;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  if (keys.indexOf('objc') !== -1) {
+    return 'objective-c';
+  }
+
+  return 'java';
+}

package/dist/esm/parser/tokenize/color-macro.js

@@ -0,0 +1,46 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { TokenType } from '.';
+import { commonMacro } from './common-macro';
+import { parseAttrs } from '../utils/attrs';
+import { parseString } from '../text';
+import { getEditorColor } from '../color';
+import { hasAnyOfMarks } from '../utils/text';
+export var colorMacro = function colorMacro(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema,
+      context = _ref.context;
+  return commonMacro(input.substring(position), schema, {
+    keyword: 'color',
+    paired: true,
+    context: context,
+    rawContentProcessor: rawContentProcessor
+  });
+};
+
+var rawContentProcessor = function rawContentProcessor(rawAttrs, rawContent, length, schema, context) {
+  var ignoreTokenTypes = [TokenType.DOUBLE_DASH_SYMBOL, TokenType.TRIPLE_DASH_SYMBOL, TokenType.QUADRUPLE_DASH_SYMBOL, TokenType.ISSUE_KEY, TokenType.TABLE];
+  var parsedAttrs = parseAttrs(rawAttrs);
+  var content = parseString({
+    ignoreTokenTypes: ignoreTokenTypes,
+    schema: schema,
+    context: context,
+    input: rawContent
+  });
+  var decoratedContent = content.map(function (n) {
+    var mark = schema.marks.textColor.create({
+      color: getEditorColor(parsedAttrs) || '#000000'
+    }); // We don't want to mix `code` mark with others
+
+    if (n.type.name === 'text' && !hasAnyOfMarks(n, ['textColor', 'code'])) {
+      return n.mark([].concat(_toConsumableArray(n.marks), [mark]));
+    }
+
+    return n;
+  });
+  return {
+    type: 'pmnode',
+    nodes: decoratedContent,
+    length: length
+  };
+};

package/dist/esm/parser/tokenize/common-formatter.js

@@ -0,0 +1,216 @@
+import { TokenType } from './';
+import { linkFormat } from './links/link-format';
+import { parseNewlineOnly } from './whitespace';
+import { parseMacroKeyword } from './keyword';
+import { parseToken } from '.';
+import { escapeHandler } from '../utils/escape';
+var processState = {
+  START: 0,
+  BUFFER: 1,
+  END: 2,
+  INLINE_MACRO: 3,
+  LINK_FORMAT: 4,
+  ESCAPE: 5
+};
+export function commonFormatter(input, position, schema, opt) {
+  var index = position;
+  var state = processState.START;
+  var buffer = [];
+  var openingSymbolLength = opt.opening.length;
+  var closingSymbolLength = opt.closing.length;
+
+  while (index < input.length) {
+    var char = input.charAt(index);
+    var twoChar = input.substr(index, 2);
+    var charsMatchClosingSymbol = input.substr(index, closingSymbolLength);
+
+    switch (state) {
+      case processState.START:
+        {
+          if (position > 0) {
+            /**
+             * If the previous char is a alphanumeric, then it's not a valid
+             * formatter
+             */
+            var charBeforeOpening = input.charAt(position - 1);
+
+            if (/[a-zA-Z0-9]|[^\u0000-\u007F]/.test(charBeforeOpening)) {
+              return fallback(input, index, openingSymbolLength);
+            }
+          }
+
+          var charAfterOpening = input.charAt(index + openingSymbolLength);
+
+          if (!input.substring(position).startsWith(opt.opening) || charAfterOpening === ' ') {
+            // this is not a valid formatter mark
+            return fallback(input, position, openingSymbolLength);
+          }
+
+          state = processState.BUFFER;
+          index += openingSymbolLength;
+          continue;
+        }
+
+      case processState.BUFFER:
+        {
+          // the linebreak would break the strong marks
+          var _length = parseNewlineOnly(input.substring(index));
+
+          if (_length) {
+            return fallback(input, position, openingSymbolLength);
+          }
+
+          if (charsMatchClosingSymbol === opt.closing) {
+            state = processState.END;
+            continue;
+          } else if (twoChar === '{{') {
+            // this is a monospace
+            buffer.push(twoChar);
+            index += 2;
+            continue;
+          } else if (char === '{') {
+            state = processState.INLINE_MACRO;
+            continue;
+          } else if (char === '[') {
+            state = processState.LINK_FORMAT;
+            continue;
+          } else if (char === '\\') {
+            state = processState.ESCAPE;
+            continue;
+          } else {
+            buffer.push(char);
+          }
+
+          break;
+        }
+
+      case processState.END:
+        {
+          index += closingSymbolLength; // empty formatter mark is treated as normal text
+
+          if (buffer.length === 0) {
+            return fallback(input, position, openingSymbolLength);
+          }
+          /**
+           * If the closing symbol is followed by a alphanumeric, it's
+           * not a valid formatter, and we keep looking for
+           * next valid closing formatter
+           */
+
+
+          if (index < input.length) {
+            var charAfterEnd = input.charAt(index);
+
+            if (/[a-zA-Z0-9]|[^\u0000-\u007F]/.test(charAfterEnd)) {
+              buffer.push(charsMatchClosingSymbol);
+              state = processState.BUFFER;
+              continue;
+            }
+          }
+          /**
+           * If the closing symbol has an empty space before it,
+           * it's not a valid formatter
+           */
+
+
+          if (buffer.length > 0 && buffer[buffer.length - 1].endsWith(' ')) {
+            return fallback(input, position, openingSymbolLength);
+          }
+
+          return opt.rawContentProcessor(buffer.join(''), index - position);
+        }
+
+      case processState.INLINE_MACRO:
+        {
+          var match = parseMacroKeyword(input.substring(index));
+
+          if (!match) {
+            buffer.push(char);
+            state = processState.BUFFER;
+            break;
+          }
+          /**
+           * Is not a problem send an empty context because we're only checking
+           * if it has a nested macro inside.
+           */
+
+
+          var token = parseToken(input, match.type, index, schema, {});
+
+          if (token.type === 'text') {
+            buffer.push(token.text);
+            index += token.length;
+            state = processState.BUFFER;
+            continue;
+          } else if (match.type === TokenType.COLOR_MACRO) {
+            /**
+             * {color} is valid in formatter, we simply jump over the length
+             */
+            buffer.push(input.substr(index, token.length));
+            index += token.length;
+            state = processState.BUFFER;
+            continue;
+          } else {
+            // No macro are accepted in formater
+            return fallback(input, position, openingSymbolLength);
+          }
+        }
+
+      case processState.LINK_FORMAT:
+        {
+          /**
+           * We should "fly over" the link format and we dont want
+           * -awesome [link|https://www.atlass-ian.com] nice
+           * to be a strike through because of the '-' in link
+           *
+           * Also, is not a problem send an empty context because we're only
+           * checking if it has a nested macro inside.
+           */
+          var _token = linkFormat({
+            input: input,
+            schema: schema,
+            position: index,
+            context: {}
+          });
+
+          if (_token.type === 'text') {
+            buffer.push(_token.text);
+            index += _token.length;
+            state = processState.BUFFER;
+            continue;
+          } else if (_token.type === 'pmnode') {
+            buffer.push(input.substr(index, _token.length));
+            index += _token.length;
+            state = processState.BUFFER;
+            continue;
+          }
+
+          return fallback(input, position, openingSymbolLength);
+        }
+
+      case processState.ESCAPE:
+        {
+          var _token2 = escapeHandler(input, index);
+
+          buffer.push(_token2.text);
+          index += _token2.length;
+          state = processState.BUFFER;
+          continue;
+        }
+
+      default:
+    }
+
+    index++;
+  }
+
+  return fallback(input, position, openingSymbolLength);
+}
+
+function fallback(input, position, length) {
+  return {
+    type: 'text',
+    text: input.substr(position, length),
+    length: length
+  };
+}