@atlaskit/editor-plugin-code-block 0.1.0

package/dist/esm/actions.js

@@ -0,0 +1,191 @@
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { copyToClipboard } from '@atlaskit/editor-common/clipboard';
+import { withAnalytics } from '@atlaskit/editor-common/editor-analytics';
+import { shouldSplitSelectedNodeOnNodeInsertion } from '@atlaskit/editor-common/insert';
+import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
+import { findParentNodeOfType, findSelectedNodeOfType, isNodeSelection, removeParentNodeOfType, removeSelectedNode, safeInsert } from '@atlaskit/editor-prosemirror/utils';
+import { pluginKey } from './plugin-key';
+import { ACTIONS } from './pm-plugins/actions';
+import { copySelectionPluginKey } from './pm-plugins/codeBlockCopySelectionPlugin';
+import { transformToCodeBlockAction } from './transform-to-code-block';
+export var removeCodeBlock = function removeCodeBlock(state, dispatch) {
+  var nodes = state.schema.nodes,
+    tr = state.tr;
+  if (dispatch) {
+    var removeTr = tr;
+    if (findSelectedNodeOfType(nodes.codeBlock)(tr.selection)) {
+      removeTr = removeSelectedNode(tr);
+    } else {
+      removeTr = removeParentNodeOfType(nodes.codeBlock)(tr);
+    }
+    dispatch(removeTr);
+  }
+  return true;
+};
+export var changeLanguage = function changeLanguage(editorAnalyticsAPI) {
+  return function (language) {
+    return function (state, dispatch) {
+      var _pluginKey$getState;
+      var codeBlock = state.schema.nodes.codeBlock;
+      var pos = (_pluginKey$getState = pluginKey.getState(state)) === null || _pluginKey$getState === void 0 ? void 0 : _pluginKey$getState.pos;
+      if (typeof pos !== 'number') {
+        return false;
+      }
+      var tr = state.tr.setNodeMarkup(pos, codeBlock, {
+        language: language
+      }).setMeta('scrollIntoView', false);
+      var selection = isNodeSelection(state.selection) ? NodeSelection.create(tr.doc, pos) : tr.selection;
+      var result = tr.setSelection(selection);
+      if (dispatch) {
+        editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
+          action: ACTION.LANGUAGE_SELECTED,
+          actionSubject: ACTION_SUBJECT.CODE_BLOCK,
+          attributes: {
+            language: language
+          },
+          eventType: EVENT_TYPE.TRACK
+        })(result);
+        dispatch(result);
+      }
+      return true;
+    };
+  };
+};
+export var copyContentToClipboard = function copyContentToClipboard(state, dispatch) {
+  var nodes = state.schema.nodes,
+    tr = state.tr;
+  var codeBlock = findParentNodeOfType(nodes.codeBlock)(tr.selection);
+  var textContent = codeBlock && codeBlock.node.textContent;
+  if (textContent) {
+    copyToClipboard(textContent);
+    var copyToClipboardTr = tr;
+    copyToClipboardTr.setMeta(pluginKey, {
+      type: ACTIONS.SET_COPIED_TO_CLIPBOARD,
+      data: true
+    });
+    copyToClipboardTr.setMeta(copySelectionPluginKey, 'remove-selection');
+    if (dispatch) {
+      dispatch(copyToClipboardTr);
+    }
+  }
+  return true;
+};
+export var resetCopiedState = function resetCopiedState(state, dispatch) {
+  var tr = state.tr;
+  var codeBlockState = pluginKey.getState(state);
+  var resetCopiedStateTr = tr;
+  if (codeBlockState && codeBlockState.contentCopied) {
+    resetCopiedStateTr.setMeta(pluginKey, {
+      type: ACTIONS.SET_COPIED_TO_CLIPBOARD,
+      data: false
+    });
+    resetCopiedStateTr.setMeta(copySelectionPluginKey, 'remove-selection');
+    if (dispatch) {
+      dispatch(resetCopiedStateTr);
+    }
+  } else {
+    var clearSelectionStateTransaction = state.tr;
+    clearSelectionStateTransaction.setMeta(copySelectionPluginKey, 'remove-selection');
+    // note: dispatch should always be defined when called from the
+    // floating toolbar. Howver the Command type which floating toolbar uses
+    // (and resetCopiedState) uses suggests it's optional.
+    if (dispatch) {
+      dispatch(clearSelectionStateTransaction);
+    }
+  }
+  return true;
+};
+export var ignoreFollowingMutations = function ignoreFollowingMutations(state, dispatch) {
+  var tr = state.tr;
+  var ignoreFollowingMutationsTr = tr;
+  ignoreFollowingMutationsTr.setMeta(pluginKey, {
+    type: ACTIONS.SET_SHOULD_IGNORE_FOLLOWING_MUTATIONS,
+    data: true
+  });
+  if (dispatch) {
+    dispatch(ignoreFollowingMutationsTr);
+  }
+  return true;
+};
+export var resetShouldIgnoreFollowingMutations = function resetShouldIgnoreFollowingMutations(state, dispatch) {
+  var tr = state.tr;
+  var ignoreFollowingMutationsTr = tr;
+  ignoreFollowingMutationsTr.setMeta(pluginKey, {
+    type: ACTIONS.SET_SHOULD_IGNORE_FOLLOWING_MUTATIONS,
+    data: false
+  });
+  if (dispatch) {
+    dispatch(ignoreFollowingMutationsTr);
+  }
+  return true;
+};
+
+/**
+ * This function creates a new transaction that inserts a code block,
+ * if there is text selected it will wrap the current selection if not it will
+ * append the codeblock to the end of the document.
+ */
+export function createInsertCodeBlockTransaction(_ref) {
+  var _state$selection$$fro;
+  var state = _ref.state;
+  var tr = state.tr;
+  var from = state.selection.from;
+  var codeBlock = state.schema.nodes.codeBlock;
+  var grandParentNodeType = (_state$selection$$fro = state.selection.$from.node(-1)) === null || _state$selection$$fro === void 0 ? void 0 : _state$selection$$fro.type;
+  var parentNodeType = state.selection.$from.parent.type;
+
+  /** We always want to append a codeBlock unless we're inserting into a paragraph
+   * AND it's a valid child of the grandparent node.
+   * Insert the current selection as codeBlock content unless it contains nodes other
+   * than paragraphs and inline.
+   */
+  var canInsertCodeBlock = shouldSplitSelectedNodeOnNodeInsertion({
+    parentNodeType: parentNodeType,
+    grandParentNodeType: grandParentNodeType,
+    content: codeBlock.createAndFill()
+  }) && contentAllowedInCodeBlock(state);
+  if (canInsertCodeBlock) {
+    tr = transformToCodeBlockAction(state, from);
+  } else {
+    safeInsert(codeBlock.createAndFill())(tr).scrollIntoView();
+  }
+  return tr;
+}
+
+/**
+ * Check if the current selection contains any nodes that are not permitted
+ * as codeBlock child nodes. Note that this allows paragraphs and inline nodes
+ * as we extract their text content.
+ */
+function contentAllowedInCodeBlock(state) {
+  var _state$selection = state.selection,
+    $from = _state$selection.$from,
+    $to = _state$selection.$to;
+  var isAllowedChild = true;
+  state.doc.nodesBetween($from.pos, $to.pos, function (node) {
+    if (!isAllowedChild) {
+      return false;
+    }
+    return isAllowedChild = node.type === state.schema.nodes.listItem || node.type === state.schema.nodes.bulletList || node.type === state.schema.nodes.orderedList || node.type === state.schema.nodes.paragraph || node.isInline || node.isText;
+  });
+  return isAllowedChild;
+}
+export function insertCodeBlockWithAnalytics(inputMethod, analyticsAPI) {
+  return withAnalytics(analyticsAPI, {
+    action: ACTION.INSERTED,
+    actionSubject: ACTION_SUBJECT.DOCUMENT,
+    actionSubjectId: ACTION_SUBJECT_ID.CODE_BLOCK,
+    attributes: {
+      inputMethod: inputMethod
+    },
+    eventType: EVENT_TYPE.TRACK
+  })(function (state, dispatch) {
+    var tr = createInsertCodeBlockTransaction({
+      state: state
+    });
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  });
+}

package/dist/esm/ide-ux/bracket-handling.js

@@ -0,0 +1,29 @@
+export var BRACKET_MAP = {
+  '{': '}',
+  '[': ']',
+  '(': ')'
+};
+export var shouldAutoCloseBracket = function shouldAutoCloseBracket(before, after) {
+  // when directly before a closing bracket
+  if (/^[}\])]/.test(after)) {
+    return true;
+  }
+
+  // exclusion: when directly before a non-whitespace character
+  if (/^[^\s]/.test(after)) {
+    return false;
+  }
+  return true;
+};
+export var getAutoClosingBracketInfo = function getAutoClosingBracketInfo(before, after) {
+  var left = Object.keys(BRACKET_MAP).find(function (item) {
+    return before.endsWith(item);
+  });
+  var right = left ? BRACKET_MAP[left] : undefined;
+  var hasTrailingMatchingBracket = right ? after.startsWith(right) : false;
+  return {
+    left: left,
+    right: right,
+    hasTrailingMatchingBracket: hasTrailingMatchingBracket
+  };
+};

package/dist/esm/ide-ux/commands.js

@@ -0,0 +1,107 @@
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INDENT_DIRECTION, INDENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { forEachLine, getLineInfo, getLinesFromSelection, getStartOfCurrentLine } from './line-handling';
+
+/**
+ * Return the current indentation level
+ * @param indentText - Text in the code block that represent an indentation
+ * @param indentSize - Size of the indentation token in a string
+ */
+function getIndentLevel(indentText, indentSize) {
+  if (indentSize === 0 || indentText.length === 0) {
+    return 0;
+  }
+  return indentText.length / indentSize;
+}
+export var indent = function indent(editorAnalyticsAPI) {
+  return function (state, dispatch) {
+    var _getLinesFromSelectio = getLinesFromSelection(state),
+      text = _getLinesFromSelectio.text,
+      start = _getLinesFromSelectio.start;
+    var tr = state.tr,
+      selection = state.selection;
+    forEachLine(text, function (line, offset) {
+      var _getLineInfo = getLineInfo(line),
+        indentText = _getLineInfo.indentText,
+        indentToken = _getLineInfo.indentToken;
+      var indentLevel = getIndentLevel(indentText, indentToken.size);
+      var indentToAdd = indentToken.token.repeat(indentToken.size - indentText.length % indentToken.size || indentToken.size);
+      tr.insertText(indentToAdd, tr.mapping.map(start + offset, -1));
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
+        action: ACTION.FORMATTED,
+        actionSubject: ACTION_SUBJECT.TEXT,
+        actionSubjectId: ACTION_SUBJECT_ID.FORMAT_INDENT,
+        eventType: EVENT_TYPE.TRACK,
+        attributes: {
+          inputMethod: INPUT_METHOD.KEYBOARD,
+          previousIndentationLevel: indentLevel,
+          newIndentLevel: indentLevel + 1,
+          direction: INDENT_DIRECTION.INDENT,
+          indentType: INDENT_TYPE.CODE_BLOCK
+        }
+      })(tr);
+      if (!selection.empty) {
+        tr.setSelection(TextSelection.create(tr.doc, tr.mapping.map(selection.from, -1), tr.selection.to));
+      }
+    });
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  };
+};
+export var outdent = function outdent(editorAnalyticsAPI) {
+  return function (state, dispatch) {
+    var _getLinesFromSelectio2 = getLinesFromSelection(state),
+      text = _getLinesFromSelectio2.text,
+      start = _getLinesFromSelectio2.start;
+    var tr = state.tr;
+    forEachLine(text, function (line, offset) {
+      var _getLineInfo2 = getLineInfo(line),
+        indentText = _getLineInfo2.indentText,
+        indentToken = _getLineInfo2.indentToken;
+      if (indentText) {
+        var indentLevel = getIndentLevel(indentText, indentToken.size);
+        var unindentLength = indentText.length % indentToken.size || indentToken.size;
+        tr.delete(tr.mapping.map(start + offset), tr.mapping.map(start + offset + unindentLength));
+        editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
+          action: ACTION.FORMATTED,
+          actionSubject: ACTION_SUBJECT.TEXT,
+          actionSubjectId: ACTION_SUBJECT_ID.FORMAT_INDENT,
+          eventType: EVENT_TYPE.TRACK,
+          attributes: {
+            inputMethod: INPUT_METHOD.KEYBOARD,
+            previousIndentationLevel: indentLevel,
+            newIndentLevel: indentLevel - 1,
+            direction: INDENT_DIRECTION.OUTDENT,
+            indentType: INDENT_TYPE.CODE_BLOCK
+          }
+        })(tr);
+      }
+    });
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  };
+};
+export function insertIndent(state, dispatch) {
+  var _getStartOfCurrentLin = getStartOfCurrentLine(state),
+    textAtStartOfLine = _getStartOfCurrentLin.text;
+  var _getLineInfo3 = getLineInfo(textAtStartOfLine),
+    indentToken = _getLineInfo3.indentToken;
+  var indentToAdd = indentToken.token.repeat(indentToken.size - textAtStartOfLine.length % indentToken.size || indentToken.size);
+  dispatch(state.tr.insertText(indentToAdd));
+  return true;
+}
+export function insertNewlineWithIndent(state, dispatch) {
+  var _getStartOfCurrentLin2 = getStartOfCurrentLine(state),
+    textAtStartOfLine = _getStartOfCurrentLin2.text;
+  var _getLineInfo4 = getLineInfo(textAtStartOfLine),
+    indentText = _getLineInfo4.indentText;
+  if (indentText && dispatch) {
+    dispatch(state.tr.insertText('\n' + indentText));
+    return true;
+  }
+  return false;
+}

package/dist/esm/ide-ux/line-handling.js

@@ -0,0 +1,73 @@
+import { getCursor } from '../utils';
+export var isSelectionEntirelyInsideCodeBlock = function isSelectionEntirelyInsideCodeBlock(state) {
+  return state.selection.$from.sameParent(state.selection.$to) && state.selection.$from.parent.type === state.schema.nodes.codeBlock;
+};
+export var isCursorInsideCodeBlock = function isCursorInsideCodeBlock(state) {
+  return !!getCursor(state.selection) && isSelectionEntirelyInsideCodeBlock(state);
+};
+export var getStartOfCurrentLine = function getStartOfCurrentLine(state) {
+  var $from = state.selection.$from;
+  if ($from.nodeBefore && $from.nodeBefore.isText) {
+    var prevNewLineIndex = $from.nodeBefore.text.lastIndexOf('\n');
+    return {
+      text: $from.nodeBefore.text.substring(prevNewLineIndex + 1),
+      pos: $from.start() + prevNewLineIndex + 1
+    };
+  }
+  return {
+    text: '',
+    pos: $from.pos
+  };
+};
+export var getEndOfCurrentLine = function getEndOfCurrentLine(state) {
+  var $to = state.selection.$to;
+  if ($to.nodeAfter && $to.nodeAfter.isText) {
+    var nextNewLineIndex = $to.nodeAfter.text.indexOf('\n');
+    return {
+      text: $to.nodeAfter.text.substring(0, nextNewLineIndex >= 0 ? nextNewLineIndex : undefined),
+      pos: nextNewLineIndex >= 0 ? $to.pos + nextNewLineIndex : $to.end()
+    };
+  }
+  return {
+    text: '',
+    pos: $to.pos
+  };
+};
+export function getLinesFromSelection(state) {
+  var _getStartOfCurrentLin = getStartOfCurrentLine(state),
+    start = _getStartOfCurrentLin.pos;
+  var _getEndOfCurrentLine = getEndOfCurrentLine(state),
+    end = _getEndOfCurrentLine.pos;
+  var text = state.doc.textBetween(start, end);
+  return {
+    text: text,
+    start: start,
+    end: end
+  };
+}
+export var forEachLine = function forEachLine(text, callback) {
+  var offset = 0;
+  text.split('\n').forEach(function (line) {
+    callback(line, offset);
+    offset += line.length + 1;
+  });
+};
+var SPACE = {
+  token: ' ',
+  size: 2,
+  regex: /[^ ]/
+};
+var TAB = {
+  token: '\t',
+  size: 1,
+  regex: /[^\t]/
+};
+export var getLineInfo = function getLineInfo(line) {
+  var indentToken = line.startsWith('\t') ? TAB : SPACE;
+  var indentLength = line.search(indentToken.regex);
+  var indentText = line.substring(0, indentLength >= 0 ? indentLength : line.length);
+  return {
+    indentToken: indentToken,
+    indentText: indentText
+  };
+};

package/dist/esm/ide-ux/paired-character-handling.js

@@ -0,0 +1,16 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { BRACKET_MAP } from './bracket-handling';
+import { QUOTE_MAP } from './quote-handling';
+var PAIRED_CHARACTER_MAP = _objectSpread(_objectSpread({}, BRACKET_MAP), QUOTE_MAP);
+export var isCursorBeforeClosingCharacter = function isCursorBeforeClosingCharacter(after) {
+  return Object.keys(PAIRED_CHARACTER_MAP).some(function (leftCharacter) {
+    return after.startsWith(PAIRED_CHARACTER_MAP[leftCharacter]);
+  });
+};
+export var isClosingCharacter = function isClosingCharacter(text) {
+  return Object.keys(PAIRED_CHARACTER_MAP).some(function (leftCharacter) {
+    return text === PAIRED_CHARACTER_MAP[leftCharacter];
+  });
+};

package/dist/esm/ide-ux/quote-handling.js

@@ -0,0 +1,34 @@
+export var QUOTE_MAP = {
+  "'": "'",
+  '"': '"',
+  '`': '`'
+};
+export var shouldAutoCloseQuote = function shouldAutoCloseQuote(before, after) {
+  // when directly before a closing bracket
+  if (/^[}\])]/.test(after)) {
+    return true;
+  }
+
+  // exclusion: when directly before a non-whitespace character
+  if (/^[^\s]/.test(after)) {
+    return false;
+  }
+
+  // exclusion: when directly after a letter or quote
+  if (/[A-Za-z0-9]$/.test(before) || /[\'\"\`]$/.test(before)) {
+    return false;
+  }
+  return true;
+};
+export var getAutoClosingQuoteInfo = function getAutoClosingQuoteInfo(before, after) {
+  var left = Object.keys(QUOTE_MAP).find(function (item) {
+    return before.endsWith(item);
+  });
+  var right = left ? QUOTE_MAP[left] : undefined;
+  var hasTrailingMatchingQuote = right ? after.startsWith(right) : false;
+  return {
+    left: left,
+    right: right,
+    hasTrailingMatchingQuote: hasTrailingMatchingQuote
+  };
+};

package/dist/esm/index.js

@@ -0,0 +1 @@
+export { default as codeBlockPlugin } from './plugin';

package/dist/esm/language-list.js

@@ -0,0 +1,52 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { SUPPORTED_LANGUAGES } from '@atlaskit/code/constants';
+
+// We expect alias[0] to be used for the ADF attribute, see ED-2813
+export var DEFAULT_LANGUAGES = [{
+  name: '(None)',
+  alias: ['none'],
+  value: 'none'
+}].concat(_toConsumableArray(SUPPORTED_LANGUAGES));
+export function findMatchedLanguage(supportedLanguages, language) {
+  if (!language) {
+    return undefined;
+  }
+  var matches = supportedLanguages.filter(function (supportedLanguage) {
+    return supportedLanguage.alias.indexOf(language.toLowerCase()) !== -1;
+  });
+  if (matches.length > 0) {
+    return matches[0];
+  }
+  return undefined;
+}
+export function filterSupportedLanguages(supportedLanguages) {
+  if (!supportedLanguages || !supportedLanguages.length) {
+    return DEFAULT_LANGUAGES;
+  }
+  return DEFAULT_LANGUAGES.filter(function (language) {
+    var i = language.alias.length;
+    while (i--) {
+      if (supportedLanguages.indexOf(language.alias[i]) > -1) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+export function getLanguageIdentifier(language) {
+  return language.alias[0];
+}
+export function createLanguageList(supportedLanguages) {
+  return supportedLanguages.sort(function (left, right) {
+    if (left.alias[0] === 'none') {
+      return -1;
+    }
+    if (left.name.toLowerCase() > right.name.toLowerCase()) {
+      return 1;
+    }
+    if (left.name.toLowerCase() < right.name.toLowerCase()) {
+      return -1;
+    }
+    return 0;
+  });
+}

package/dist/esm/nodeviews/code-block.js

@@ -0,0 +1,146 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import rafSchedule from 'raf-schd';
+import { browser } from '@atlaskit/editor-common/utils';
+import { DOMSerializer } from '@atlaskit/editor-prosemirror/model';
+import { resetShouldIgnoreFollowingMutations } from '../actions';
+import { getPluginState } from '../pm-plugins/main-state';
+import { codeBlockClassNames } from '../ui/class-names';
+var MATCH_NEWLINES = new RegExp('\n', 'g');
+var toDOM = function toDOM(node) {
+  return ['div', {
+    class: 'code-block'
+  }, ['div', {
+    class: codeBlockClassNames.start,
+    contenteditable: 'false'
+  }], ['div', {
+    class: codeBlockClassNames.contentWrapper
+  }, ['div', {
+    class: codeBlockClassNames.gutter,
+    contenteditable: 'false'
+  }], ['div', {
+    class: codeBlockClassNames.content
+  }, ['code', {
+    'data-language': node.attrs.language || '',
+    spellcheck: 'false',
+    contenteditable: 'true',
+    'data-testid': 'code-block--code'
+  }, 0]]], ['div', {
+    class: codeBlockClassNames.end,
+    contenteditable: 'false'
+  }]];
+};
+export var CodeBlockView = /*#__PURE__*/function () {
+  function CodeBlockView(_node, view, getPos) {
+    var _this = this;
+    _classCallCheck(this, CodeBlockView);
+    _defineProperty(this, "ensureLineNumbers", rafSchedule(function () {
+      var lines = 1;
+      _this.node.forEach(function (node) {
+        var text = node.text;
+        if (text) {
+          lines += (node.text.match(MATCH_NEWLINES) || []).length;
+        }
+      });
+      while (_this.lineNumberGutter.childElementCount < lines) {
+        _this.lineNumberGutter.appendChild(document.createElement('span'));
+      }
+      while (_this.lineNumberGutter.childElementCount > lines) {
+        _this.lineNumberGutter.removeChild(_this.lineNumberGutter.lastChild);
+      }
+    }));
+    var _DOMSerializer$render = DOMSerializer.renderSpec(document, toDOM(_node)),
+      dom = _DOMSerializer$render.dom,
+      contentDOM = _DOMSerializer$render.contentDOM;
+    this.getPos = getPos;
+    this.view = view;
+    this.node = _node;
+    this.dom = dom;
+    this.contentDOM = contentDOM;
+    this.lineNumberGutter = this.dom.querySelector(".".concat(codeBlockClassNames.gutter));
+    this.ensureLineNumbers();
+  }
+  _createClass(CodeBlockView, [{
+    key: "updateDOMAndSelection",
+    value: function updateDOMAndSelection(savedInnerHTML, newCursorPosition) {
+      var _this$dom;
+      if ((_this$dom = this.dom) !== null && _this$dom !== void 0 && _this$dom.childNodes && this.dom.childNodes.length > 1) {
+        var _contentView$childNod;
+        var contentWrapper = this.dom.childNodes[1];
+        var contentView = contentWrapper === null || contentWrapper === void 0 ? void 0 : contentWrapper.childNodes[1];
+        if ((contentView === null || contentView === void 0 || (_contentView$childNod = contentView.childNodes) === null || _contentView$childNod === void 0 ? void 0 : _contentView$childNod.length) > 0) {
+          var codeElement = contentView.firstChild;
+          codeElement.innerHTML = savedInnerHTML;
+
+          // We need to set cursor for the DOM update
+          var textElement = _toConsumableArray(codeElement.childNodes).find(function (child) {
+            return child.nodeName === '#text';
+          });
+          var sel = window.getSelection();
+          var range = document.createRange();
+          range.setStart(textElement, newCursorPosition);
+          range.collapse(true);
+          sel === null || sel === void 0 || sel.removeAllRanges();
+          sel === null || sel === void 0 || sel.addRange(range);
+        }
+      }
+    }
+  }, {
+    key: "coalesceDOMElements",
+    value: function coalesceDOMElements() {
+      var _this$dom2;
+      if ((_this$dom2 = this.dom) !== null && _this$dom2 !== void 0 && _this$dom2.childNodes && this.dom.childNodes.length > 1) {
+        var contentWrapper = this.dom.childNodes[1];
+        var contentView = contentWrapper === null || contentWrapper === void 0 ? void 0 : contentWrapper.childNodes[1];
+        if (contentView !== null && contentView !== void 0 && contentView.childNodes && contentView.childNodes.length > 1) {
+          var savedInnerHTML = '';
+          while (contentView.childNodes.length > 1) {
+            var lastChild = contentView.lastChild;
+            savedInnerHTML = lastChild.innerHTML + savedInnerHTML;
+            contentView.removeChild(lastChild);
+          }
+          var firstChild = contentView.firstChild;
+          savedInnerHTML = firstChild.innerHTML + '\n' + savedInnerHTML;
+          var newCursorPosition = firstChild.innerHTML.length + 1;
+          setTimeout(this.updateDOMAndSelection.bind(this, savedInnerHTML, newCursorPosition), 20);
+        }
+      }
+    }
+  }, {
+    key: "update",
+    value: function update(node) {
+      if (node.type !== this.node.type) {
+        return false;
+      }
+      if (node !== this.node) {
+        if (node.attrs.language !== this.node.attrs.language) {
+          this.contentDOM.setAttribute('data-language', node.attrs.language || '');
+        }
+        this.node = node;
+        this.ensureLineNumbers();
+        if (browser.android) {
+          this.coalesceDOMElements();
+          resetShouldIgnoreFollowingMutations(this.view.state, this.view.dispatch);
+        }
+      }
+      return true;
+    }
+  }, {
+    key: "ignoreMutation",
+    value: function ignoreMutation(record) {
+      var pluginState = getPluginState(this.view.state);
+      if (pluginState !== null && pluginState !== void 0 && pluginState.shouldIgnoreFollowingMutations) {
+        return true;
+      }
+
+      // Ensure updating the line-number gutter doesn't trigger reparsing the codeblock
+      return record.target === this.lineNumberGutter || record.target.parentNode === this.lineNumberGutter;
+    }
+  }]);
+  return CodeBlockView;
+}();
+export var codeBlockNodeView = function codeBlockNodeView(node, view, getPos) {
+  return new CodeBlockView(node, view, getPos);
+};

package/dist/esm/plugin-key.js

@@ -0,0 +1,2 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export var pluginKey = new PluginKey('codeBlockPlugin');