@atlaskit/editor-wikimarkup-transformer 9.5.3

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

@@ -0,0 +1,52 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+// TODO: Create a type for rawContentProcessor which will be shared among parsers
+export function commonMacro(input, schema, opt) {
+  /**
+   * Forging the opening regex, the result would look something like
+   * /^\{(quote)(?::([^\{\n\}]*))?\}/i
+   */
+  var opening = new RegExp("^{(".concat(opt.keyword, ")(?::([^{\n}]*))?}"), 'i');
+  var matchOpening = input.match(opening);
+
+  if (!matchOpening) {
+    return fallback(input);
+  }
+
+  var _matchOpening = _slicedToArray(matchOpening, 3),
+      name = _matchOpening[1],
+      rawAttrs = _matchOpening[2];
+
+  var openingLength = matchOpening[0].length;
+
+  if (!opt.paired) {
+    /**
+     * Some macros do not have a closing symbol, for example
+     * {anchor:here} {loremipsum}
+     */
+    return opt.rawContentProcessor(rawAttrs, '', openingLength, schema, opt.context);
+  }
+  /**
+   * Forging the closing regex, the result would look something like
+   * /\{quote\}/
+   */
+
+
+  var closing = new RegExp("{".concat(name, "}"));
+  var matchClosing = closing.exec(input.substring(openingLength));
+  var rawContent = '';
+
+  if (matchClosing) {
+    rawContent = input.substring(openingLength, openingLength + matchClosing.index);
+  }
+
+  var length = matchClosing ? openingLength + matchClosing.index + matchClosing[0].length : openingLength;
+  return opt.rawContentProcessor(rawAttrs, rawContent, length, schema, opt.context);
+}
+
+function fallback(input) {
+  return {
+    type: 'text',
+    text: input.substr(0, 1),
+    length: 1
+  };
+}

package/dist/esm/parser/tokenize/dash-token-creator.js

@@ -0,0 +1,33 @@
+export var createDashTokenParser = function createDashTokenParser(token, fallback) {
+  return function (_ref) {
+    var input = _ref.input,
+        position = _ref.position;
+
+    /**
+     * From Jira https://stash.atlassian.com/projects/JIRACLOUD/repos/jira/browse/jira-components/jira-renderer/src/main/java/com/atlassian/renderer/v2/components/phrase/DashRendererComponent.java
+     *  public static final Replacer EN_DASH = new Replacer(Pattern.compile("(^|\\s)--(\\s|$)"), "$1–$2", "--");
+     *  public static final Replacer EM_DASH = new Replacer(Pattern.compile("(^|\\s)---(\\s|$)"), "$1—$2", "---");
+     */
+    if (position > 0) {
+      var charBeforeToken = input.charAt(position - 1);
+
+      if (!isSpace(charBeforeToken)) {
+        return fallback;
+      }
+    }
+
+    if (position + token.length < input.length) {
+      var charAfterToken = input.charAt(position + token.length);
+
+      if (!isSpace(charAfterToken)) {
+        return fallback;
+      }
+    }
+
+    return token;
+  };
+};
+
+var isSpace = function isSpace(char) {
+  return /\s/.test(char);
+};

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

@@ -0,0 +1,50 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { TokenType } from './';
+import { hasAnyOfMarks } from '../utils/text';
+import { commonFormatter } from './common-formatter';
+import { parseString } from '../text';
+export var deleted = function deleted(_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, TokenType.TABLE];
+  /** Add strike mark to each text */
+
+  var contentDecorator = function contentDecorator(n) {
+    var mark = schema.marks.strike.create(); // We don't want to mix `code` mark with others
+
+    if (n.type.name === 'text' && !hasAnyOfMarks(n, ['strike', 'code'])) {
+      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/double-dash-symbol.js

@@ -0,0 +1,19 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+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 { createDashTokenParser } from './dash-token-creator';
+var token = {
+  type: 'text',
+  text: "\u2013",
+  // EN DASH
+  length: 2
+};
+
+var fallback = _objectSpread(_objectSpread({}, token), {}, {
+  text: '--'
+});
+
+export var doubleDashSymbol = createDashTokenParser(token, fallback);

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

@@ -0,0 +1,173 @@
+var emptyOrWhitespaceRegex = new RegExp(/^$|\s/);
+export var emoji = function emoji(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema;
+  var substring = input.substring(position);
+  /**
+   * The length of wikimakrup emoji test ranges from 2 to 9 characters at the time of writing.
+   */
+
+  for (var i = 2; i <= 9 && i <= substring.length; ++i) {
+    var candidateText = substring.substring(0, i);
+    var emojiId = wikiToAdfEmojiMapping[candidateText]; // Is current candidate an emoji AND next character empty string or whitespace?
+
+    if (emojiId && emptyOrWhitespaceRegex.test(substring.charAt(i))) {
+      return {
+        type: 'pmnode',
+        nodes: [schema.nodes.emoji.createChecked(adfEmojiItems[emojiId])],
+        length: i
+      };
+    }
+  }
+
+  return {
+    type: 'text',
+    text: substring.substr(0, 1),
+    length: 1
+  };
+};
+export var adfEmojiItems = {
+  '1f642': {
+    id: '1f642',
+    shortName: ':slight_smile:',
+    text: '🙂'
+  },
+  '1f61e': {
+    id: '1f61e',
+    shortName: ':disappointed:',
+    text: '😞'
+  },
+  '1f61b': {
+    id: '1f61b',
+    shortName: ':stuck_out_tongue:',
+    text: '😛'
+  },
+  '1f603': {
+    id: '1f603',
+    shortName: ':smiley:',
+    text: '😃'
+  },
+  '1f609': {
+    id: '1f609',
+    shortName: ':wink:',
+    text: '😉'
+  },
+  '1f44d': {
+    id: '1f44d',
+    shortName: ':thumbsup:',
+    text: '👍'
+  },
+  '1f44e': {
+    id: '1f44e',
+    shortName: ':thumbsdown:',
+    text: '👎'
+  },
+  'atlassian-info': {
+    id: 'atlassian-info',
+    shortName: ':info:',
+    text: ':info'
+  },
+  'atlassian-check_mark': {
+    id: 'atlassian-check_mark',
+    shortName: ':check_mark:',
+    text: ':check_mark:'
+  },
+  'atlassian-cross_mark': {
+    id: 'atlassian-cross_mark',
+    shortName: ':cross_mark:',
+    text: ':cross_mark:'
+  },
+  'atlassian-warning': {
+    id: 'atlassian-warning',
+    shortName: ':warning:',
+    text: ':warning:'
+  },
+  'atlassian-plus': {
+    id: 'atlassian-plus',
+    shortName: ':plus:',
+    text: ':plus:'
+  },
+  'atlassian-minus': {
+    id: 'atlassian-minus',
+    shortName: ':minus:',
+    text: ':minus:'
+  },
+  'atlassian-question_mark': {
+    id: 'atlassian-question_mark',
+    shortName: ':question:',
+    text: ':question:'
+  },
+  'atlassian-light_bulb_on': {
+    id: 'atlassian-light_bulb_on',
+    shortName: ':light_bulb_on:',
+    text: ':light_bulb_on:'
+  },
+  'atlassian-light_bulb_off': {
+    id: 'atlassian-light_bulb_off',
+    shortName: ':light_bulb_off:',
+    text: ':light_bulb_off:'
+  },
+  'atlassian-yellow_star': {
+    id: 'atlassian-yellow_star',
+    shortName: ':yellow_star:',
+    text: ':yellow_star:'
+  },
+  'atlassian-red_star': {
+    id: 'atlassian-red_star',
+    shortName: ':red_star:',
+    text: ':red_star:'
+  },
+  'atlassian-green_star': {
+    id: 'atlassian-green_star',
+    shortName: ':green_star:',
+    text: ':green_star:'
+  },
+  'atlassian-blue_star': {
+    id: 'atlassian-blue_star',
+    shortName: ':blue_star:',
+    text: ':blue_star:'
+  },
+  'atlassian-flag_on': {
+    id: 'atlassian-flag_on',
+    shortName: ':flag_on:',
+    text: ':flag_on:'
+  },
+  'atlassian-flag_off': {
+    id: 'atlassian-flag_off',
+    shortName: ':flag_off:',
+    text: ':flag_off:'
+  }
+};
+export var wikiToAdfEmojiMapping = {
+  ':)': '1f642',
+  ':-)': '1f642',
+  ':(': '1f61e',
+  ':-(': '1f61e',
+  ':P': '1f61b',
+  ':-P': '1f61b',
+  ':p': '1f61b',
+  ':-p': '1f61b',
+  ':D': '1f603',
+  ':-D': '1f603',
+  ';)': '1f609',
+  ';-)': '1f609',
+  '(y)': '1f44d',
+  '(n)': '1f44e',
+  '(i)': 'atlassian-info',
+  '(/)': 'atlassian-check_mark',
+  '(x)': 'atlassian-cross_mark',
+  '(!)': 'atlassian-warning',
+  '(+)': 'atlassian-plus',
+  '(-)': 'atlassian-minus',
+  '(?)': 'atlassian-question_mark',
+  '(on)': 'atlassian-light_bulb_on',
+  '(off)': 'atlassian-light_bulb_off',
+  '(*)': 'atlassian-yellow_star',
+  '(*y)': 'atlassian-yellow_star',
+  '(*r)': 'atlassian-red_star',
+  '(*g)': 'atlassian-green_star',
+  '(*b)': 'atlassian-blue_star',
+  '(flag)': 'atlassian-flag_on',
+  '(flagoff)': 'atlassian-flag_off'
+};

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

@@ -0,0 +1,49 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { TokenType } from './';
+import { hasAnyOfMarks } from '../utils/text';
+import { commonFormatter } from './common-formatter';
+import { parseString } from '../text';
+export var emphasis = function emphasis(_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  mark
+   */
+  var ignoreTokenTypes = [TokenType.DOUBLE_DASH_SYMBOL, TokenType.TRIPLE_DASH_SYMBOL, TokenType.QUADRUPLE_DASH_SYMBOL, TokenType.ISSUE_KEY, TokenType.TABLE]; // Add underline mark to each text
+
+  var contentDecorator = function contentDecorator(n) {
+    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'])) {
+      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/file-link.js

@@ -0,0 +1,25 @@
+import getMediaGroupNodeView from '../nodes/mediaGroup';
+// [^attachment.pdf]
+var FILE_LINK_REGEXP = /^\[\^([\(\)\w. -]+)\]/;
+export function fileLink(input, position, schema) {
+  var match = input.substring(position).match(FILE_LINK_REGEXP);
+
+  if (!match) {
+    return fallback(input, position);
+  }
+
+  var node = getMediaGroupNodeView(schema, match[1]);
+  return {
+    type: 'pmnode',
+    nodes: [node],
+    length: match[0].length
+  };
+}
+
+function fallback(input, position) {
+  return {
+    type: 'text',
+    text: input.substr(position, 1),
+    length: 1
+  };
+}

package/dist/esm/parser/tokenize/force-line-break.js

@@ -0,0 +1,38 @@
+/**
+ * Jira is using the following regex to match force line break
+ * private static final Pattern FORCE_NEWLINE = Pattern.compile("(?<!\\\\)\\\\{2}(?!\\S*\\\\)");
+ */
+var FORCE_LINE_BREAK_REGEX = /^\\{2}(?!\S*\\)/;
+export var forceLineBreak = function forceLineBreak(_ref) {
+  var input = _ref.input,
+      position = _ref.position,
+      schema = _ref.schema;
+
+  if (position > 0) {
+    var charBefore = input.charAt(position - 1);
+
+    if (charBefore === '\\') {
+      return fallback(input, position);
+    }
+  }
+
+  var match = input.substring(position).match(FORCE_LINE_BREAK_REGEX);
+
+  if (match) {
+    return {
+      type: 'pmnode',
+      nodes: [schema.nodes.hardBreak.createChecked()],
+      length: 2
+    };
+  }
+
+  return fallback(input, position);
+};
+
+function fallback(input, position) {
+  return {
+    type: 'text',
+    text: input.substr(position, 2),
+    length: 2
+  };
+}