@atlaskit/editor-plugin-code-block 0.1.0

package/dist/cjs/pm-plugins/main-state.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPluginState = void 0;
+var _pluginKey = require("../plugin-key");
+var getPluginState = exports.getPluginState = function getPluginState(state) {
+  return _pluginKey.pluginKey.getState(state);
+};

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

@@ -0,0 +1,114 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPlugin = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _selection = require("@atlaskit/editor-common/selection");
+var _utils = require("@atlaskit/editor-common/utils");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _actions = require("../actions");
+var _codeBlock = require("../nodeviews/code-block");
+var _pluginKey = require("../plugin-key");
+var _classNames = require("../ui/class-names");
+var _utils2 = require("../utils");
+var _actions2 = require("./actions");
+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) { (0, _defineProperty2.default)(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; }
+var createPlugin = exports.createPlugin = function createPlugin(_ref) {
+  var _ref$useLongPressSele = _ref.useLongPressSelection,
+    useLongPressSelection = _ref$useLongPressSele === void 0 ? false : _ref$useLongPressSele,
+    getIntl = _ref.getIntl,
+    appearance = _ref.appearance,
+    _ref$allowComposition = _ref.allowCompositionInputOverride,
+    allowCompositionInputOverride = _ref$allowComposition === void 0 ? false : _ref$allowComposition;
+  var handleDOMEvents = {};
+
+  // ME-1599: Composition on mobile was causing the DOM observer to mutate the code block
+  // incorrecly and lose content when pressing enter in the middle of a code block line.
+  if (allowCompositionInputOverride) {
+    handleDOMEvents.beforeinput = function (view, event) {
+      var keyEvent = event;
+      var eventInputType = keyEvent.inputType;
+      var eventText = keyEvent.data;
+      if (_utils.browser.ios && event.composed &&
+      // insertParagraph will be the input type when the enter key is pressed.
+      eventInputType === 'insertParagraph' && (0, _utils2.findCodeBlock)(view.state, view.state.selection)) {
+        event.preventDefault();
+        return true;
+      } else if (_utils.browser.android && event.composed && eventInputType === 'insertCompositionText' && eventText[(eventText === null || eventText === void 0 ? void 0 : eventText.length) - 1] === '\n' && (0, _utils2.findCodeBlock)(view.state, view.state.selection)) {
+        var resultingText = event.target.outerText + '\n';
+        if (resultingText.endsWith(eventText)) {
+          // End of paragraph
+          setTimeout(function () {
+            view.someProp('handleKeyDown', function (f) {
+              return f(view, new KeyboardEvent('keydown', {
+                bubbles: true,
+                cancelable: true,
+                key: 'Enter',
+                code: 'Enter'
+              }));
+            });
+          }, 0);
+        } else {
+          // Middle of paragraph, end of line
+          (0, _actions.ignoreFollowingMutations)(view.state, view.dispatch);
+        }
+        return true;
+      }
+      if (_utils.browser.android) {
+        (0, _actions.resetShouldIgnoreFollowingMutations)(view.state, view.dispatch);
+      }
+      return false;
+    };
+  }
+  return new _safePlugin.SafePlugin({
+    state: {
+      init: function init(_, state) {
+        var node = (0, _utils2.findCodeBlock)(state, state.selection);
+        return {
+          pos: node ? node.pos : null,
+          contentCopied: false,
+          isNodeSelected: false,
+          shouldIgnoreFollowingMutations: false
+        };
+      },
+      apply: function apply(tr, pluginState, _oldState, newState) {
+        if (tr.docChanged || tr.selectionSet) {
+          var node = (0, _utils2.findCodeBlock)(newState, tr.selection);
+          var newPluginState = _objectSpread(_objectSpread({}, pluginState), {}, {
+            pos: node ? node.pos : null,
+            isNodeSelected: tr.selection instanceof _state.NodeSelection
+          });
+          return newPluginState;
+        }
+        var meta = tr.getMeta(_pluginKey.pluginKey);
+        if ((meta === null || meta === void 0 ? void 0 : meta.type) === _actions2.ACTIONS.SET_COPIED_TO_CLIPBOARD) {
+          return _objectSpread(_objectSpread({}, pluginState), {}, {
+            contentCopied: meta.data
+          });
+        } else if ((meta === null || meta === void 0 ? void 0 : meta.type) === _actions2.ACTIONS.SET_SHOULD_IGNORE_FOLLOWING_MUTATIONS) {
+          return _objectSpread(_objectSpread({}, pluginState), {}, {
+            shouldIgnoreFollowingMutations: meta.data
+          });
+        }
+        return pluginState;
+      }
+    },
+    key: _pluginKey.pluginKey,
+    props: {
+      nodeViews: {
+        codeBlock: _codeBlock.codeBlockNodeView
+      },
+      handleClickOn: (0, _selection.createSelectionClickHandler)(['codeBlock'], function (target) {
+        return !!(target.closest(".".concat(_classNames.codeBlockClassNames.gutter)) || target.classList.contains(_classNames.codeBlockClassNames.content));
+      }, {
+        useLongPressSelection: useLongPressSelection
+      }),
+      handleDOMEvents: handleDOMEvents
+    }
+  });
+};

package/dist/cjs/refresh-browser-selection.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.refreshBrowserSelection = exports.default = void 0;
+var _utils = require("@atlaskit/editor-common/utils");
+var _pluginKey = require("./plugin-key");
+// Workaround for a firefox issue where dom selection is off sync
+// https://product-fabric.atlassian.net/browse/ED-12442
+var refreshBrowserSelection = exports.refreshBrowserSelection = function refreshBrowserSelection() {
+  var domSelection = window.getSelection();
+  if (domSelection) {
+    var domRange = domSelection && domSelection.rangeCount === 1 && domSelection.getRangeAt(0).cloneRange();
+    if (domRange) {
+      domSelection.removeAllRanges();
+      domSelection.addRange(domRange);
+    }
+  }
+};
+var refreshBrowserSelectionOnChange = function refreshBrowserSelectionOnChange(transaction, editorState) {
+  var _pluginKey$getState;
+  if (_utils.browser.gecko && transaction.docChanged &&
+  // codeblockState.pos should be set if current selection is in a codeblock.
+  typeof ((_pluginKey$getState = _pluginKey.pluginKey.getState(editorState)) === null || _pluginKey$getState === void 0 ? void 0 : _pluginKey$getState.pos) === 'number') {
+    refreshBrowserSelection();
+  }
+};
+var _default = exports.default = refreshBrowserSelectionOnChange;

package/dist/cjs/toolbar.js

@@ -0,0 +1,131 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.messages = exports.languageListFilter = exports.getToolbarConfig = void 0;
+var _reactIntlNext = require("react-intl-next");
+var _messages = _interopRequireWildcard(require("@atlaskit/editor-common/messages"));
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _copy = _interopRequireDefault(require("@atlaskit/icon/glyph/copy"));
+var _remove = _interopRequireDefault(require("@atlaskit/icon/glyph/editor/remove"));
+var _actions = require("./actions");
+var _languageList = require("./language-list");
+var _pluginKey = require("./plugin-key");
+var _codeBlockCopySelectionPlugin = require("./pm-plugins/codeBlockCopySelectionPlugin");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var messages = exports.messages = (0, _reactIntlNext.defineMessages)({
+  selectLanguage: {
+    id: 'fabric.editor.selectLanguage',
+    defaultMessage: 'Select language',
+    description: 'Code blocks display software code. A prompt to select the software language the code is written in.'
+  }
+});
+var languageList = (0, _languageList.createLanguageList)(_languageList.DEFAULT_LANGUAGES);
+var getToolbarConfig = exports.getToolbarConfig = function getToolbarConfig() {
+  var allowCopyToClipboard = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  var api = arguments.length > 1 ? arguments[1] : undefined;
+  return function (state, _ref) {
+    var _api$decorations$acti, _api$analytics, _codeBlockState$pos, _node$attrs;
+    var formatMessage = _ref.formatMessage;
+    var _ref2 = (_api$decorations$acti = api === null || api === void 0 ? void 0 : api.decorations.actions) !== null && _api$decorations$acti !== void 0 ? _api$decorations$acti : {},
+      hoverDecoration = _ref2.hoverDecoration;
+    var editorAnalyticsAPI = api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions;
+    var codeBlockState = _pluginKey.pluginKey.getState(state);
+    var pos = (_codeBlockState$pos = codeBlockState === null || codeBlockState === void 0 ? void 0 : codeBlockState.pos) !== null && _codeBlockState$pos !== void 0 ? _codeBlockState$pos : null;
+    if (!codeBlockState || pos === null) {
+      return;
+    }
+    var node = state.doc.nodeAt(pos);
+    var nodeType = state.schema.nodes.codeBlock;
+    if ((node === null || node === void 0 ? void 0 : node.type) !== nodeType) {
+      return;
+    }
+    var language = node === null || node === void 0 || (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.language;
+    var options = languageList.map(function (lang) {
+      return {
+        label: lang.name,
+        value: (0, _languageList.getLanguageIdentifier)(lang),
+        alias: lang.alias
+      };
+    });
+
+    // If language is not undefined search for it in the value and then search in the aliases
+    var defaultValue = language ? options.find(function (option) {
+      return option.value === language;
+    }) || options.find(function (option) {
+      return option.alias.includes(language);
+    }) : null;
+    var languageSelect = {
+      id: 'editor.codeBlock.languageOptions',
+      type: 'select',
+      selectType: 'list',
+      onChange: function onChange(option) {
+        return (0, _actions.changeLanguage)(editorAnalyticsAPI)(option.value);
+      },
+      defaultValue: defaultValue,
+      placeholder: formatMessage(messages.selectLanguage),
+      options: options,
+      filterOption: languageListFilter
+    };
+    var separator = {
+      type: 'separator'
+    };
+    var copyToClipboardItems = !allowCopyToClipboard ? [] : [{
+      id: 'editor.codeBlock.copy',
+      type: 'button',
+      appearance: 'subtle',
+      icon: _copy.default,
+      // note: copyContentToClipboard contains logic that also removes the
+      // visual feedback for the copy button
+      onClick: _actions.copyContentToClipboard,
+      title: formatMessage(codeBlockState.contentCopied ? _messages.codeBlockButtonMessages.copiedCodeToClipboard : _messages.codeBlockButtonMessages.copyCodeToClipboard),
+      onMouseEnter: _codeBlockCopySelectionPlugin.provideVisualFeedbackForCopyButton,
+      // note: resetCopiedState contains logic that also removes the
+      // visual feedback for the copy button
+      onMouseLeave: _actions.resetCopiedState,
+      onFocus: _codeBlockCopySelectionPlugin.provideVisualFeedbackForCopyButton,
+      onBlur: _codeBlockCopySelectionPlugin.removeVisualFeedbackForCopyButton,
+      hideTooltipOnClick: false,
+      disabled: codeBlockState.isNodeSelected,
+      tabIndex: null
+    }, separator];
+    var deleteButton = {
+      id: 'editor.codeBlock.delete',
+      type: 'button',
+      appearance: 'danger',
+      icon: _remove.default,
+      onMouseEnter: hoverDecoration === null || hoverDecoration === void 0 ? void 0 : hoverDecoration(nodeType, true),
+      onMouseLeave: hoverDecoration === null || hoverDecoration === void 0 ? void 0 : hoverDecoration(nodeType, false),
+      onFocus: hoverDecoration === null || hoverDecoration === void 0 ? void 0 : hoverDecoration(nodeType, true),
+      onBlur: hoverDecoration === null || hoverDecoration === void 0 ? void 0 : hoverDecoration(nodeType, false),
+      onClick: _actions.removeCodeBlock,
+      title: formatMessage(_messages.default.remove),
+      tabIndex: null
+    };
+    return {
+      title: 'CodeBlock floating controls',
+      getDomRef: function getDomRef(view) {
+        return (0, _utils.findDomRefAtPos)(pos, view.domAtPos.bind(view));
+      },
+      nodeType: nodeType,
+      items: [languageSelect, separator].concat(copyToClipboardItems, [deleteButton]),
+      scrollable: true
+    };
+  };
+};
+
+/**
+ * Filters language list based on both name and alias properties.
+ */
+var languageListFilter = exports.languageListFilter = function languageListFilter(option, rawInput) {
+  var _ref3 = option,
+    data = _ref3.data;
+  var searchString = rawInput.toLowerCase();
+  return data.label.toLowerCase().includes(searchString) || data.alias.some(function (alias) {
+    return alias.toLowerCase() === searchString;
+  });
+};

package/dist/cjs/transform-to-code-block.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isConvertableToCodeBlock = isConvertableToCodeBlock;
+exports.transformToCodeBlockAction = transformToCodeBlockAction;
+var _selection = require("@atlaskit/editor-common/selection");
+var _utils = require("@atlaskit/editor-common/utils");
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _state = require("@atlaskit/editor-prosemirror/state");
+function transformToCodeBlockAction(state, start, attrs) {
+  var startOfCodeBlockText = state.selection.$from;
+  var endPosition = state.selection.empty && !(state.selection instanceof _selection.GapCursorSelection) ? startOfCodeBlockText.end() : state.selection.$to.pos;
+  var startLinePosition = startOfCodeBlockText.start();
+  //when cmd+A is used to select the content. start position should be 0.
+  var parentStartPosition = startOfCodeBlockText.depth === 0 ? 0 : startOfCodeBlockText.before();
+  var contentSlice = state.doc.slice(startOfCodeBlockText.pos, endPosition);
+  var codeBlockSlice = (0, _utils.mapSlice)(contentSlice, function (node, parent, index) {
+    if (node.type === state.schema.nodes.hardBreak) {
+      return state.schema.text('\n');
+    }
+    if (node.isText) {
+      return node.mark([]);
+    }
+    if (node.isInline) {
+      // Convert dates
+      if (node.attrs.timestamp) {
+        return state.schema.text((0, _utils.timestampToString)(node.attrs.timestamp, null));
+      }
+      // Convert links
+      if (node.attrs.url) {
+        return state.schema.text(node.attrs.url);
+      }
+      return node.attrs.text ? state.schema.text(node.attrs.text) : null;
+    }
+
+    // if the current node is the last child of the Slice exit early to prevent
+    // adding additional line breaks
+    if (contentSlice.content.childCount - 1 === index) {
+      return node.content;
+    }
+
+    //useful to decide whether to append line breaks when the content has list items.
+    var isParentLastChild = parent && contentSlice.content.childCount - 1 === index;
+
+    // add line breaks at the end of each paragraph to mimic layout of selected content
+    // do not add line breaks when the 'paragraph' parent is last child.
+    if (node.content.childCount && node.type === state.schema.nodes.paragraph && !isParentLastChild) {
+      return node.content.append(_model.Fragment.from(state.schema.text('\n\n')));
+    }
+    return node.content.childCount ? node.content : null;
+  });
+  var tr = state.tr;
+
+  // Replace current block node
+  var startMapped = startLinePosition === start ? parentStartPosition : start;
+  var codeBlock = state.schema.nodes.codeBlock;
+  var codeBlockNode = codeBlock.createChecked(attrs, codeBlockSlice.content);
+  tr.replaceWith(startMapped, Math.min(endPosition, tr.doc.content.size), codeBlockNode);
+
+  // Reposition cursor when inserting into layouts or table headers
+  var mapped = tr.doc.resolve(tr.mapping.map(startMapped) + 1);
+  var selection = _state.TextSelection.findFrom(mapped, state.selection instanceof _selection.GapCursorSelection ? -1 : 1, true);
+  if (selection) {
+    return tr.setSelection(selection);
+  }
+  return tr.setSelection(_state.TextSelection.create(tr.doc, Math.min(start + startOfCodeBlockText.node().nodeSize - 1, tr.doc.content.size)));
+}
+function isConvertableToCodeBlock(state) {
+  // Before a document is loaded, there is no selection.
+  if (!state.selection) {
+    return false;
+  }
+  var $from = state.selection.$from;
+  var node = $from.parent;
+  if (!node.isTextblock || node.type === state.schema.nodes.codeBlock) {
+    return false;
+  }
+  var parentDepth = $from.depth - 1;
+  var parentNode = $from.node(parentDepth);
+  var index = $from.index(parentDepth);
+  return parentNode.canReplaceWith(index, index + 1, state.schema.nodes.codeBlock);
+}

package/dist/cjs/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/cjs/ui/class-names.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.codeBlockClassNames = void 0;
+var _styles = require("@atlaskit/editor-common/styles");
+var codeBlockClassNames = exports.codeBlockClassNames = {
+  container: _styles.CodeBlockSharedCssClassName.CODEBLOCK_CONTAINER,
+  start: _styles.CodeBlockSharedCssClassName.CODEBLOCK_START,
+  end: _styles.CodeBlockSharedCssClassName.CODEBLOCK_END,
+  contentWrapper: _styles.CodeBlockSharedCssClassName.CODEBLOCK_CONTENT_WRAPPER,
+  gutter: _styles.CodeBlockSharedCssClassName.CODEBLOCK_LINE_NUMBER_GUTTER,
+  content: _styles.CodeBlockSharedCssClassName.CODEBLOCK_CONTENT
+};

package/dist/cjs/utils.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "findCodeBlock", {
+  enumerable: true,
+  get: function get() {
+    return _transforms.findCodeBlock;
+  }
+});
+exports.getCursor = getCursor;
+Object.defineProperty(exports, "transformSingleLineCodeBlockToCodeMark", {
+  enumerable: true,
+  get: function get() {
+    return _transforms.transformSingleLineCodeBlockToCodeMark;
+  }
+});
+Object.defineProperty(exports, "transformSliceToJoinAdjacentCodeBlocks", {
+  enumerable: true,
+  get: function get() {
+    return _transforms.transformSliceToJoinAdjacentCodeBlocks;
+  }
+});
+var _transforms = require("@atlaskit/editor-common/transforms");
+function getCursor(selection) {
+  return selection.$cursor || undefined;
+}

package/dist/es2019/actions.js

@@ -0,0 +1,211 @@
+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 const removeCodeBlock = (state, dispatch) => {
+  const {
+    schema: {
+      nodes
+    },
+    tr
+  } = state;
+  if (dispatch) {
+    let removeTr = tr;
+    if (findSelectedNodeOfType(nodes.codeBlock)(tr.selection)) {
+      removeTr = removeSelectedNode(tr);
+    } else {
+      removeTr = removeParentNodeOfType(nodes.codeBlock)(tr);
+    }
+    dispatch(removeTr);
+  }
+  return true;
+};
+export const changeLanguage = editorAnalyticsAPI => language => (state, dispatch) => {
+  var _pluginKey$getState;
+  const {
+    codeBlock
+  } = state.schema.nodes;
+  const pos = (_pluginKey$getState = pluginKey.getState(state)) === null || _pluginKey$getState === void 0 ? void 0 : _pluginKey$getState.pos;
+  if (typeof pos !== 'number') {
+    return false;
+  }
+  const tr = state.tr.setNodeMarkup(pos, codeBlock, {
+    language
+  }).setMeta('scrollIntoView', false);
+  const selection = isNodeSelection(state.selection) ? NodeSelection.create(tr.doc, pos) : tr.selection;
+  const result = tr.setSelection(selection);
+  if (dispatch) {
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+      action: ACTION.LANGUAGE_SELECTED,
+      actionSubject: ACTION_SUBJECT.CODE_BLOCK,
+      attributes: {
+        language
+      },
+      eventType: EVENT_TYPE.TRACK
+    })(result);
+    dispatch(result);
+  }
+  return true;
+};
+export const copyContentToClipboard = (state, dispatch) => {
+  const {
+    schema: {
+      nodes
+    },
+    tr
+  } = state;
+  const codeBlock = findParentNodeOfType(nodes.codeBlock)(tr.selection);
+  const textContent = codeBlock && codeBlock.node.textContent;
+  if (textContent) {
+    copyToClipboard(textContent);
+    let 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 const resetCopiedState = (state, dispatch) => {
+  const {
+    tr
+  } = state;
+  const codeBlockState = pluginKey.getState(state);
+  let 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 {
+    const 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 const ignoreFollowingMutations = (state, dispatch) => {
+  const {
+    tr
+  } = state;
+  const ignoreFollowingMutationsTr = tr;
+  ignoreFollowingMutationsTr.setMeta(pluginKey, {
+    type: ACTIONS.SET_SHOULD_IGNORE_FOLLOWING_MUTATIONS,
+    data: true
+  });
+  if (dispatch) {
+    dispatch(ignoreFollowingMutationsTr);
+  }
+  return true;
+};
+export const resetShouldIgnoreFollowingMutations = (state, dispatch) => {
+  const {
+    tr
+  } = state;
+  const 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({
+  state
+}) {
+  var _state$selection$$fro;
+  let {
+    tr
+  } = state;
+  const {
+    from
+  } = state.selection;
+  const {
+    codeBlock
+  } = state.schema.nodes;
+  const grandParentNodeType = (_state$selection$$fro = state.selection.$from.node(-1)) === null || _state$selection$$fro === void 0 ? void 0 : _state$selection$$fro.type;
+  const 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.
+   */
+  const canInsertCodeBlock = shouldSplitSelectedNodeOnNodeInsertion({
+    parentNodeType,
+    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) {
+  const {
+    $from,
+    $to
+  } = state.selection;
+  let isAllowedChild = true;
+  state.doc.nodesBetween($from.pos, $to.pos, 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) {
+    let tr = createInsertCodeBlockTransaction({
+      state
+    });
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  });
+}

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

@@ -0,0 +1,27 @@
+export const BRACKET_MAP = {
+  '{': '}',
+  '[': ']',
+  '(': ')'
+};
+export const 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 const getAutoClosingBracketInfo = (before, after) => {
+  const left = Object.keys(BRACKET_MAP).find(item => before.endsWith(item));
+  const right = left ? BRACKET_MAP[left] : undefined;
+  const hasTrailingMatchingBracket = right ? after.startsWith(right) : false;
+  return {
+    left,
+    right,
+    hasTrailingMatchingBracket
+  };
+};