@atlaskit/editor-wikimarkup-transformer 9.5.3

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

@@ -0,0 +1,48 @@
+// 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
+   */
+  const opening = new RegExp(`^\{(${opt.keyword})(?::([^\{\n\}]*))?\}`, 'i');
+  const matchOpening = input.match(opening);
+
+  if (!matchOpening) {
+    return fallback(input);
+  }
+
+  const [, name, rawAttrs] = matchOpening;
+  const 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\}/
+   */
+
+
+  const closing = new RegExp(`\{${name}\}`);
+  const matchClosing = closing.exec(input.substring(openingLength));
+  let rawContent = '';
+
+  if (matchClosing) {
+    rawContent = input.substring(openingLength, openingLength + matchClosing.index);
+  }
+
+  const 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/es2019/parser/tokenize/dash-token-creator.js

@@ -0,0 +1,31 @@
+export const createDashTokenParser = (token, fallback) => ({
+  input,
+  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) {
+    const charBeforeToken = input.charAt(position - 1);
+
+    if (!isSpace(charBeforeToken)) {
+      return fallback;
+    }
+  }
+
+  if (position + token.length < input.length) {
+    const charAfterToken = input.charAt(position + token.length);
+
+    if (!isSpace(charAfterToken)) {
+      return fallback;
+    }
+  }
+
+  return token;
+};
+
+const isSpace = char => {
+  return /\s/.test(char);
+};

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

@@ -0,0 +1,49 @@
+import { TokenType } from './';
+import { hasAnyOfMarks } from '../utils/text';
+import { commonFormatter } from './common-formatter';
+import { parseString } from '../text';
+export const deleted = ({
+  input,
+  position,
+  schema,
+  context
+}) => {
+  /**
+   * The following token types will be ignored in parsing
+   * the content
+   */
+  const ignoreTokenTypes = [TokenType.DOUBLE_DASH_SYMBOL, TokenType.TRIPLE_DASH_SYMBOL, TokenType.QUADRUPLE_DASH_SYMBOL, TokenType.ISSUE_KEY, TokenType.TABLE];
+  /** Add strike mark to each text */
+
+  const contentDecorator = n => {
+    const 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([...n.marks, mark]);
+    }
+
+    return n;
+  };
+
+  const rawContentProcessor = (raw, length) => {
+    const content = parseString({
+      ignoreTokenTypes,
+      schema,
+      context,
+      input: raw
+    });
+    const decoratedContent = content.map(contentDecorator);
+    return {
+      type: 'pmnode',
+      nodes: decoratedContent,
+      length
+    };
+  };
+
+  return commonFormatter(input, position, schema, {
+    opening: '-',
+    closing: '-',
+    context,
+    rawContentProcessor
+  });
+};

package/dist/es2019/parser/tokenize/double-dash-symbol.js

@@ -0,0 +1,11 @@
+import { createDashTokenParser } from './dash-token-creator';
+const token = {
+  type: 'text',
+  text: '\u2013',
+  // EN DASH
+  length: 2
+};
+const fallback = { ...token,
+  text: '--'
+};
+export const doubleDashSymbol = createDashTokenParser(token, fallback);

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

@@ -0,0 +1,174 @@
+const emptyOrWhitespaceRegex = new RegExp(/^$|\s/);
+export const emoji = ({
+  input,
+  position,
+  schema
+}) => {
+  const substring = input.substring(position);
+  /**
+   * The length of wikimakrup emoji test ranges from 2 to 9 characters at the time of writing.
+   */
+
+  for (let i = 2; i <= 9 && i <= substring.length; ++i) {
+    const candidateText = substring.substring(0, i);
+    const 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 const 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 const 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/es2019/parser/tokenize/emphasis.js

@@ -0,0 +1,48 @@
+import { TokenType } from './';
+import { hasAnyOfMarks } from '../utils/text';
+import { commonFormatter } from './common-formatter';
+import { parseString } from '../text';
+export const emphasis = ({
+  input,
+  position,
+  schema,
+  context
+}) => {
+  /**
+   * The following token types will be ignored in parsing
+   * the content of a  mark
+   */
+  const ignoreTokenTypes = [TokenType.DOUBLE_DASH_SYMBOL, TokenType.TRIPLE_DASH_SYMBOL, TokenType.QUADRUPLE_DASH_SYMBOL, TokenType.ISSUE_KEY, TokenType.TABLE]; // Add underline mark to each text
+
+  const contentDecorator = n => {
+    const 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([...n.marks, mark]);
+    }
+
+    return n;
+  };
+
+  const rawContentProcessor = (raw, length) => {
+    const content = parseString({
+      ignoreTokenTypes,
+      schema,
+      context,
+      input: raw
+    });
+    const decoratedContent = content.map(contentDecorator);
+    return {
+      type: 'pmnode',
+      nodes: decoratedContent,
+      length
+    };
+  };
+
+  return commonFormatter(input, position, schema, {
+    opening: '_',
+    closing: '_',
+    context,
+    rawContentProcessor
+  });
+};

package/dist/es2019/parser/tokenize/file-link.js

@@ -0,0 +1,25 @@
+import getMediaGroupNodeView from '../nodes/mediaGroup';
+// [^attachment.pdf]
+const FILE_LINK_REGEXP = /^\[\^([\(\)\w. -]+)\]/;
+export function fileLink(input, position, schema) {
+  const match = input.substring(position).match(FILE_LINK_REGEXP);
+
+  if (!match) {
+    return fallback(input, position);
+  }
+
+  const 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/es2019/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*\\\\)");
+ */
+const FORCE_LINE_BREAK_REGEX = /^\\{2}(?!\S*\\)/;
+export const forceLineBreak = ({
+  input,
+  position,
+  schema
+}) => {
+  if (position > 0) {
+    const charBefore = input.charAt(position - 1);
+
+    if (charBefore === '\\') {
+      return fallback(input, position);
+    }
+  }
+
+  const 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
+  };
+}

package/dist/es2019/parser/tokenize/hardbreak.js

@@ -0,0 +1,24 @@
+import { parseNewlineOnly } from './whitespace';
+export const hardbreak = ({
+  input,
+  position,
+  schema
+}) => {
+  // Look for normal hardbreak \r, \n, \r\n
+  const length = parseNewlineOnly(input.substring(position));
+
+  if (length === 0) {
+    // not a valid hardbreak
+    return {
+      type: 'text',
+      text: input.substr(position, 1),
+      length: 1
+    };
+  }
+
+  return {
+    type: 'pmnode',
+    nodes: [schema.nodes.hardBreak.createChecked()],
+    length
+  };
+};