@atlaskit/editor-plugin-code-block-advanced 1.0.0

package/dist/es2019/nodeviews/codeBlockAdvanced.js

@@ -0,0 +1,170 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { closeBrackets } from '@codemirror/autocomplete';
+import { syntaxHighlighting } from '@codemirror/language';
+import { Compartment, EditorSelection } from '@codemirror/state';
+import { EditorView as CodeMirror, lineNumbers } from '@codemirror/view';
+import { isCodeBlockWordWrapEnabled } from '@atlaskit/editor-common/code-block';
+import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
+import { highlightStyle } from '../ui/syntaxHighlightingTheme';
+import { cmTheme } from '../ui/theme';
+import { syncCMWithPM } from './codemirrorSync/syncCMWithPM';
+import { updateCMSelection } from './codemirrorSync/updateCMSelection';
+import { bidiCharWarningExtension } from './extensions/bidiCharWarning';
+import { keymapExtension } from './extensions/keymap';
+import { LanguageLoader } from './languages/loader';
+// Based on: https://prosemirror.net/examples/codemirror/
+class CodeBlockAdvancedNodeView {
+  // eslint-disable-next-line @typescript-eslint/max-params
+  constructor(node, view, getPos, config) {
+    var _config$api, _config$api$selection, _config$api2, _config$api2$editorDi;
+    _defineProperty(this, "lineWrappingCompartment", new Compartment());
+    _defineProperty(this, "languageCompartment", new Compartment());
+    _defineProperty(this, "readOnlyCompartment", new Compartment());
+    _defineProperty(this, "maybeTryingToReachNodeSelection", false);
+    _defineProperty(this, "wordWrappingEnabled", false);
+    this.node = node;
+    this.view = view;
+    this.getPos = getPos;
+    this.selectionAPI = (_config$api = config.api) === null || _config$api === void 0 ? void 0 : (_config$api$selection = _config$api.selection) === null || _config$api$selection === void 0 ? void 0 : _config$api$selection.actions;
+    const getNode = () => this.node;
+    const onMaybeNodeSelection = () => this.maybeTryingToReachNodeSelection = true;
+    this.cleanupDisabledState = (_config$api2 = config.api) === null || _config$api2 === void 0 ? void 0 : (_config$api2$editorDi = _config$api2.editorDisabled) === null || _config$api2$editorDi === void 0 ? void 0 : _config$api2$editorDi.sharedState.onChange(() => {
+      this.updateReadonlyState();
+    });
+    this.languageLoader = new LanguageLoader(lang => {
+      this.updating = true;
+      this.cm.dispatch({
+        effects: this.languageCompartment.reconfigure(lang)
+      });
+      this.updating = false;
+    });
+    this.cm = new CodeMirror({
+      doc: this.node.textContent,
+      extensions: [...config.extensions, this.lineWrappingCompartment.of([]), this.languageCompartment.of([]), keymapExtension({
+        view,
+        getPos,
+        getNode,
+        selectCodeBlockNode: this.selectCodeBlockNode.bind(this),
+        onMaybeNodeSelection
+      }), cmTheme, syntaxHighlighting(highlightStyle), lineNumbers(), CodeMirror.updateListener.of(update => this.forwardUpdate(update)), this.readOnlyCompartment.of(CodeMirror.editable.of(this.view.editable)), closeBrackets(), CodeMirror.editorAttributes.of({
+        class: 'code-block'
+      }), bidiCharWarningExtension]
+    });
+
+    // The editor's outer node is our DOM representation
+    this.dom = this.cm.dom;
+
+    // This flag is used to avoid an update loop between the outer and
+    // inner editor
+    this.updating = false;
+    this.updateLanguage();
+  }
+  destroy() {
+    var _this$cleanupDisabled;
+    (_this$cleanupDisabled = this.cleanupDisabledState) === null || _this$cleanupDisabled === void 0 ? void 0 : _this$cleanupDisabled.call(this);
+  }
+  forwardUpdate(update) {
+    var _this$getPos, _this$getPos2;
+    if (this.updating || !this.cm.hasFocus) {
+      return;
+    }
+    const offset = ((_this$getPos = (_this$getPos2 = this.getPos) === null || _this$getPos2 === void 0 ? void 0 : _this$getPos2.call(this)) !== null && _this$getPos !== void 0 ? _this$getPos : 0) + 1;
+    syncCMWithPM({
+      view: this.view,
+      update,
+      offset
+    });
+  }
+  setSelection(anchor, head) {
+    if (!this.maybeTryingToReachNodeSelection) {
+      this.cm.focus();
+    }
+    this.updating = true;
+    this.cm.dispatch({
+      selection: {
+        anchor,
+        head
+      }
+    });
+    this.updating = false;
+  }
+  updateReadonlyState() {
+    this.updating = true;
+    this.cm.dispatch({
+      effects: this.readOnlyCompartment.reconfigure(CodeMirror.editable.of(this.view.editable))
+    });
+    this.updating = false;
+  }
+  updateLanguage() {
+    this.languageLoader.updateLanguage(this.node.attrs.language);
+  }
+  selectCodeBlockNode(relativeSelectionPos) {
+    var _this$selectionAPI, _this$getPos3, _this$getPos4;
+    const tr = (_this$selectionAPI = this.selectionAPI) === null || _this$selectionAPI === void 0 ? void 0 : _this$selectionAPI.selectNearNode({
+      selectionRelativeToNode: relativeSelectionPos,
+      selection: NodeSelection.create(this.view.state.doc, (_this$getPos3 = (_this$getPos4 = this.getPos) === null || _this$getPos4 === void 0 ? void 0 : _this$getPos4.call(this)) !== null && _this$getPos3 !== void 0 ? _this$getPos3 : 0)
+    })(this.view.state);
+    if (tr) {
+      this.view.dispatch(tr);
+    }
+  }
+  updateWordWrap(node) {
+    if (this.wordWrappingEnabled !== isCodeBlockWordWrapEnabled(node)) {
+      this.updating = true;
+      this.cm.dispatch({
+        effects: [this.lineWrappingCompartment.reconfigure(isCodeBlockWordWrapEnabled(node) ? CodeMirror.lineWrapping : [])]
+      });
+      this.updating = false;
+      this.wordWrappingEnabled = !this.wordWrappingEnabled;
+    }
+  }
+  update(node) {
+    this.maybeTryingToReachNodeSelection = false;
+    if (node.type !== this.node.type) {
+      return false;
+    }
+    this.updateWordWrap(node);
+    this.node = node;
+    if (this.updating) {
+      return true;
+    }
+    this.updateLanguage();
+    const newText = node.textContent,
+      curText = this.cm.state.doc.toString();
+    updateCMSelection(curText, newText, tr => {
+      this.updating = true;
+      this.cm.dispatch(tr);
+      this.updating = false;
+    });
+    return true;
+  }
+  stopEvent(e) {
+    var _this$getPos5;
+    if (e instanceof MouseEvent && e.type === 'mousedown') {
+      // !Warning: Side effect!
+      // CodeMirror on blur updates the dom observer with a `setTimeout(..., 10);`
+      // We need to select the nodeview after this has taken place to ensure
+      // ProseMirror takes over
+      // https://github.com/codemirror/view/commit/70a9a253df04a57004247b9463198c17832f92f4#diff-cb8cbffa623ff0975389e7e8c315e69d5e10345239ffe2c9b4b7986a56ad95efR720
+      setTimeout(() => {
+        // Ensure the CM selection is reset - if we have a ranged selection when we do node selection can
+        // cause funky behaviour
+        this.updating = true;
+        this.cm.dispatch({
+          selection: EditorSelection.create([EditorSelection.cursor(0)], 0)
+        });
+        this.updating = false;
+        this.selectCodeBlockNode(undefined);
+        this.view.focus();
+      }, 20);
+    }
+    // If we have selected the node we should not stop these events
+    if (e instanceof KeyboardEvent && this.view.state.selection instanceof NodeSelection && this.view.state.selection.from === ((_this$getPos5 = this.getPos) === null || _this$getPos5 === void 0 ? void 0 : _this$getPos5.call(this))) {
+      return false;
+    }
+    return true;
+  }
+}
+export const getCodeBlockAdvancedNodeView = props => (node, view, getPos) => {
+  return new CodeBlockAdvancedNodeView(node, view, getPos, props);
+};

package/dist/es2019/nodeviews/codeBlockNodeWithToDOMFixed.js

@@ -0,0 +1,42 @@
+import { codeBlock } from '@atlaskit/adf-schema';
+import { CodeBlockSharedCssClassName } from '@atlaskit/editor-common/styles';
+const codeBlockClassNames = {
+  container: CodeBlockSharedCssClassName.CODEBLOCK_CONTAINER,
+  start: CodeBlockSharedCssClassName.CODEBLOCK_START,
+  end: CodeBlockSharedCssClassName.CODEBLOCK_END,
+  contentWrapper: CodeBlockSharedCssClassName.CODEBLOCK_CONTENT_WRAPPER,
+  contentWrapped: CodeBlockSharedCssClassName.CODEBLOCK_CONTENT_WRAPPED,
+  gutter: CodeBlockSharedCssClassName.CODEBLOCK_LINE_NUMBER_GUTTER,
+  content: CodeBlockSharedCssClassName.CODEBLOCK_CONTENT,
+  lineNumberWidget: CodeBlockSharedCssClassName.CODEBLOCK_CONTAINER_LINE_NUMBER_WIDGET
+};
+
+// From: `packages/editor/editor-plugin-code-block/src/nodeviews/code-block.ts`
+const toDOM = (node, contentEditable, formattedAriaLabel) => ['div', {
+  class: codeBlockClassNames.container
+}, ['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: contentEditable ? 'true' : 'false',
+  'data-testid': 'code-block--code',
+  'aria-label': formattedAriaLabel
+}, 0]]], ['div', {
+  class: codeBlockClassNames.end,
+  contenteditable: 'false'
+}]];
+export const codeBlockNodeWithFixedToDOM = () => {
+  return {
+    ...codeBlock,
+    toDOM: node => toDOM(node, false, '')
+  };
+};

package/dist/es2019/nodeviews/codemirrorSync/syncCMWithPM.js

@@ -0,0 +1,35 @@
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+/**
+ *
+ * Synchronises the CodeMirror update changes with the Prosemirror editor
+ *
+ * @param props.view EditorView - Prosemirror EditorView
+ * @param props.update ViewUpdate - CodeMirror ViewUpdate
+ * @param props.offset number - position where the code block starts in prosemirror
+ */
+export const syncCMWithPM = ({
+  view,
+  update,
+  offset
+}) => {
+  const {
+    main
+  } = update.state.selection;
+  const selFrom = offset + main.from;
+  const selTo = offset + main.to;
+  const pmSel = view.state.selection;
+  if (update.docChanged || pmSel.from !== selFrom || pmSel.to !== selTo) {
+    const tr = view.state.tr;
+    // eslint-disable-next-line @typescript-eslint/max-params
+    update.changes.iterChanges((fromA, toA, fromB, toB, text) => {
+      if (text.length) {
+        tr.replaceWith(offset + fromA, offset + toA, view.state.schema.text(text.toString()));
+      } else {
+        tr.delete(offset + fromA, offset + toA);
+      }
+      offset += toB - fromB - (toA - fromA);
+    });
+    tr.setSelection(TextSelection.create(tr.doc, selFrom, selTo));
+    view.dispatch(tr);
+  }
+};

package/dist/es2019/nodeviews/codemirrorSync/updateCMSelection.js

@@ -0,0 +1,30 @@
+/**
+ *
+ * Compares the updated text with the current to determine the transaction to fire
+ * in the CodeMirror editor.
+ *
+ * @param curText string - the current CodeMirror text
+ * @param newText string - the new CodeMirror text
+ * @param updateCallback Callback to process the CodeMirror transaction
+ */
+export const updateCMSelection = (curText, newText, updateCallback) => {
+  if (newText !== curText) {
+    let start = 0,
+      curEnd = curText.length,
+      newEnd = newText.length;
+    while (start < curEnd && curText.charCodeAt(start) === newText.charCodeAt(start)) {
+      ++start;
+    }
+    while (curEnd > start && newEnd > start && curText.charCodeAt(curEnd - 1) === newText.charCodeAt(newEnd - 1)) {
+      curEnd--;
+      newEnd--;
+    }
+    updateCallback({
+      changes: {
+        from: start,
+        to: curEnd,
+        insert: newText.slice(start, newEnd)
+      }
+    });
+  }
+};

package/dist/es2019/nodeviews/extensions/bidiCharWarning.js

@@ -0,0 +1,53 @@
+/**
+ * Code based on warning from @atlaskit/code
+ */
+import { EditorView as CodeMirror, ViewPlugin, Decoration, MatchDecorator, WidgetType } from '@codemirror/view';
+const bidiCharacterRegex = /[\u202A-\u202E\u2066-\u2069]/gu;
+const placeholderMatcher = new MatchDecorator({
+  regexp: bidiCharacterRegex,
+  decoration: match => Decoration.replace({
+    widget: new PlaceholderWidget(match[0])
+  })
+});
+export const bidiCharWarningExtension = ViewPlugin.fromClass(class {
+  constructor(view) {
+    this.placeholders = placeholderMatcher.createDeco(view);
+  }
+  update(update) {
+    this.placeholders = placeholderMatcher.updateDeco(update, this.placeholders);
+  }
+}, {
+  decorations: instance => instance.placeholders,
+  provide: plugin => CodeMirror.atomicRanges.of(view => {
+    var _view$plugin;
+    return ((_view$plugin = view.plugin(plugin)) === null || _view$plugin === void 0 ? void 0 : _view$plugin.placeholders) || Decoration.none;
+  })
+});
+function getBidiCharacterCode(bidiCharacter) {
+  var _bidiCharacter$codePo;
+  const bidiCharacterCode = (_bidiCharacter$codePo = bidiCharacter.codePointAt(0)) === null || _bidiCharacter$codePo === void 0 ? void 0 : _bidiCharacter$codePo.toString(16);
+  return `U+${bidiCharacterCode}`;
+}
+class PlaceholderWidget extends WidgetType {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  eq(other) {
+    return this.name === other.name;
+  }
+  toDOM() {
+    const elt = document.createElement('span');
+    elt.setAttribute('data-bidi-character-code', this.name);
+    elt.style.cssText = `
+      padding: 0 3px;
+      color: ${"var(--ds-text-warning, #A54800)"};
+			background: ${"var(--ds-background-warning, #FFF7D6)"};
+			aria-hidden="true"`;
+    elt.textContent = `<${getBidiCharacterCode(this.name)}>`;
+    return elt;
+  }
+  ignoreEvent() {
+    return false;
+  }
+}

package/dist/es2019/nodeviews/extensions/keymap/backspace.js

@@ -0,0 +1,28 @@
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+export const backspaceKeymap = ({
+  cm,
+  view,
+  getPos,
+  getNode
+}) => {
+  var _getPos;
+  const ranges = cm.state.selection.ranges;
+  if (ranges.length > 1) {
+    return false;
+  }
+  const selection = ranges[0];
+  if (selection && (!selection.empty || selection.anchor > 0)) {
+    return false;
+  }
+  if (cm.state.doc.lines >= 2) {
+    return false;
+  }
+  const state = view.state;
+  const pos = (_getPos = getPos()) !== null && _getPos !== void 0 ? _getPos : 0;
+  const node = getNode();
+  const tr = state.tr.replaceWith(pos, pos + node.nodeSize, state.schema.nodes.paragraph.createChecked({}, node.content));
+  tr.setSelection(TextSelection.near(tr.doc.resolve(pos)));
+  view.dispatch(tr);
+  view.focus();
+  return true;
+};

package/dist/es2019/nodeviews/extensions/keymap/index.js

@@ -0,0 +1,107 @@
+import { defaultKeymap, indentWithTab } from '@codemirror/commands';
+import { keymap as cmKeymap } from '@codemirror/view';
+import { exitCode } from '@atlaskit/editor-prosemirror/commands';
+import { undo, redo } from '@atlaskit/editor-prosemirror/history';
+import { backspaceKeymap } from './backspace';
+import { maybeEscapeKeymap } from './maybeEscape';
+export const keymapExtension = ({
+  view,
+  getNode,
+  getPos,
+  selectCodeBlockNode,
+  onMaybeNodeSelection
+}) => {
+  return cmKeymap.of(codeBlockKeymap({
+    view,
+    getNode,
+    getPos,
+    selectCodeBlockNode,
+    onMaybeNodeSelection
+  }));
+};
+const codeBlockKeymap = ({
+  view,
+  getNode,
+  getPos,
+  selectCodeBlockNode,
+  onMaybeNodeSelection
+}) => {
+  return [{
+    key: 'ArrowUp',
+    run: cm => maybeEscapeKeymap({
+      unit: 'line',
+      dir: -1,
+      cm,
+      view,
+      getNode,
+      getPos,
+      selectCodeBlockNode,
+      onMaybeNodeSelection
+    })
+  }, {
+    key: 'ArrowLeft',
+    run: cm => maybeEscapeKeymap({
+      unit: 'char',
+      dir: -1,
+      cm,
+      view,
+      getNode,
+      getPos,
+      selectCodeBlockNode,
+      onMaybeNodeSelection
+    })
+  }, {
+    key: 'ArrowDown',
+    run: cm => maybeEscapeKeymap({
+      unit: 'line',
+      dir: 1,
+      cm,
+      view,
+      getNode,
+      getPos,
+      selectCodeBlockNode,
+      onMaybeNodeSelection
+    })
+  }, {
+    key: 'ArrowRight',
+    run: cm => maybeEscapeKeymap({
+      unit: 'char',
+      dir: 1,
+      cm,
+      view,
+      getNode,
+      getPos,
+      selectCodeBlockNode,
+      onMaybeNodeSelection
+    })
+  }, {
+    key: 'Ctrl-Enter',
+    run: () => {
+      if (!exitCode(view.state, view.dispatch)) {
+        return false;
+      }
+      view.focus();
+      return true;
+    }
+  }, {
+    key: 'Ctrl-z',
+    mac: 'Cmd-z',
+    run: () => undo(view.state, view.dispatch)
+  }, {
+    key: 'Shift-Ctrl-z',
+    mac: 'Shift-Cmd-z',
+    run: () => redo(view.state, view.dispatch)
+  }, {
+    key: 'Ctrl-y',
+    mac: 'Cmd-y',
+    run: () => redo(view.state, view.dispatch)
+  }, {
+    key: 'Backspace',
+    run: cm => backspaceKeymap({
+      cm,
+      view,
+      getNode,
+      getPos
+    })
+  }, ...defaultKeymap.concat(indentWithTab)];
+};

package/dist/es2019/nodeviews/extensions/keymap/maybeEscape.js

@@ -0,0 +1,57 @@
+import { RelativeSelectionPos } from '@atlaskit/editor-common/selection';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+export const maybeEscapeKeymap = ({
+  unit,
+  dir,
+  view,
+  cm,
+  getPos,
+  getNode,
+  onMaybeNodeSelection,
+  selectCodeBlockNode
+}) => {
+  var _getPos;
+  if (unit === 'char') {
+    onMaybeNodeSelection();
+  }
+  const node = getNode();
+  const {
+    state
+  } = cm;
+  let main = state.selection.main;
+  if (!main.empty) {
+    return false;
+  }
+  if (unit === 'line') {
+    main = {
+      ...state.doc.lineAt(main.head),
+      head: 0,
+      empty: false
+    };
+  }
+  if (dir < 0 ? main.from > 0 : main.to < state.doc.length) {
+    return false;
+  }
+  const targetPos = ((_getPos = getPos === null || getPos === void 0 ? void 0 : getPos()) !== null && _getPos !== void 0 ? _getPos : 0) + (dir < 0 ? 0 : node.nodeSize);
+  if (unit === 'char') {
+    view.focus();
+    selectCodeBlockNode(dir === -1 ? RelativeSelectionPos.Start : RelativeSelectionPos.End);
+    return true;
+  } else {
+    createParagraphIfEndOfDoc(view, targetPos);
+    const tr = view.state.tr;
+    const selection = Selection.near(tr.doc.resolve(targetPos), dir);
+    tr.setSelection(selection).scrollIntoView();
+    view.dispatch(tr);
+    view.focus();
+    return true;
+  }
+};
+const createParagraphIfEndOfDoc = (view, targetPos) => {
+  if (targetPos === view.state.doc.content.size) {
+    const paragraph = view.state.schema.nodes.paragraph.createChecked({});
+    const tr = view.state.tr.insert(targetPos, paragraph);
+    // Note: we purposefully do a multi-dispatch here, otherwise we get stuck in codemirror
+    view.dispatch(tr);
+  }
+};

package/dist/es2019/nodeviews/languages/languageMap.js

@@ -0,0 +1,82 @@
+import { LanguageDescription } from '@codemirror/language';
+import { languages } from '@codemirror/language-data';
+// getLanguageIdentifier defines `language.alias[0]`
+export const mapLanguageToCodeMirror = language => {
+  if (!language || language === 'none') {
+    return undefined;
+  }
+  switch (language) {
+    case 'coldfusion':
+      return languages.find(l => {
+        return l.name.toLowerCase() === 'xml';
+      });
+    case 'matlab':
+      return languages.find(l => {
+        return l.name.toLowerCase() === 'octave';
+      });
+    case 'javafx':
+      return languages.find(l => {
+        return l.name.toLowerCase() === 'java';
+      });
+    case 'vbnet':
+      return languages.find(l => {
+        return l.name === 'VB.NET';
+      });
+    case 'pas':
+      return languages.find(l => {
+        return l.name.toLowerCase() === 'pascal';
+      });
+    case 'cuda':
+      return languages.find(l => {
+        return l.name.toLowerCase() === 'c++';
+      });
+    case 'racket':
+      return languages.find(l => {
+        return l.name === 'Common Lisp';
+      });
+    case 'abap':
+      return languages.find(l => {
+        return l.name === 'SQL';
+      });
+    case 'standardmL':
+      return languages.find(l => {
+        return l.name === 'SML';
+      });
+    case 'objective-j':
+      return languages.find(l => {
+        return l.name === 'Objective-C';
+      });
+    case 'docker':
+      return languages.find(l => {
+        return l.name === 'Dockerfile';
+      });
+    case 'arduino':
+      return languages.find(l => {
+        return l.name === 'C++';
+      });
+    case 'visualbasic':
+      return languages.find(l => {
+        return l.name === 'VB.NET';
+      });
+    case 'elixir':
+      return LanguageDescription.of({
+        name: 'Elixir',
+        load() {
+          return import( /* webpackChunkName: "@atlaskit-internal_@atlaskit/editor-plugin-code-block-advanced-lang-elixir" */
+          'codemirror-lang-elixir').then(m => m.elixir());
+        }
+      });
+    case 'graphql':
+      return LanguageDescription.of({
+        name: 'GraphQL',
+        load() {
+          return import( /* webpackChunkName: "@atlaskit-internal_@atlaskit/editor-plugin-code-block-advanced-lang-graphql" */
+          'cm6-graphql').then(m => m.graphqlLanguageSupport());
+        }
+      });
+    default:
+      return languages.find(l => {
+        return l.alias.includes(language) || l.name.toLowerCase() === (language === null || language === void 0 ? void 0 : language.toLowerCase());
+      });
+  }
+};

package/dist/es2019/nodeviews/languages/loader.js

@@ -0,0 +1,37 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { mapLanguageToCodeMirror } from './languageMap';
+
+/**
+ * Manages loading the languages (for syntax highlighting, etc.)
+ * from CodeMirror and updating the language in the CodeMirror view
+ */
+export class LanguageLoader {
+  constructor(updateLanguageCompartment) {
+    _defineProperty(this, "languageName", '');
+    this.updateLanguageCompartment = updateLanguageCompartment;
+  }
+  updateLanguage(languageName) {
+    if (languageName === this.languageName) {
+      return;
+    }
+    const language = mapLanguageToCodeMirror(languageName);
+    const configureEmpty = () => {
+      this.updateLanguageCompartment([]);
+      this.languageName = '';
+    };
+    if (!language) {
+      configureEmpty();
+      return;
+    }
+    language.load().then(lang => {
+      if (lang) {
+        this.updateLanguageCompartment(lang);
+        this.languageName = languageName;
+      } else {
+        configureEmpty();
+      }
+    }).catch(() => {
+      configureEmpty();
+    });
+  }
+}

package/dist/es2019/nodeviews/lazyCodeBlockAdvanced.js

@@ -0,0 +1,18 @@
+import { withLazyLoading } from '@atlaskit/editor-common/lazy-node-view';
+export const lazyCodeBlockView = props => {
+  return withLazyLoading({
+    nodeName: 'codeBlock',
+    getNodeViewOptions: () => {},
+    loader: () => {
+      const result = import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-code-block-advanced-nodeview" */
+      './codeBlockAdvanced').then(({
+        getCodeBlockAdvancedNodeView
+      }) => {
+        return (node, view, getPos) => {
+          return getCodeBlockAdvancedNodeView(props)(node, view, getPos);
+        };
+      });
+      return result;
+    }
+  });
+};

package/dist/es2019/pm-plugins/main.js

@@ -0,0 +1,11 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { lazyCodeBlockView } from '../nodeviews/lazyCodeBlockAdvanced';
+export const createPlugin = props => {
+  return new SafePlugin({
+    props: {
+      nodeViews: {
+        codeBlock: lazyCodeBlockView(props)
+      }
+    }
+  });
+};