@atlaskit/editor-core 187.17.6 → 187.18.1

package/dist/esm/plugins/text-formatting/pm-plugins/clear-formatting.js

@@ -1,28 +0,0 @@
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { PluginKey } from '@atlaskit/editor-prosemirror/state';
-import { checkFormattingIsPresent } from '../utils';
-export var pluginKey = new PluginKey('clearFormattingPlugin');
-export var plugin = function plugin(dispatch) {
-  return new SafePlugin({
-    state: {
-      init: function init(_config, state) {
-        return {
-          formattingIsPresent: checkFormattingIsPresent(state)
-        };
-      },
-      apply: function apply(_tr, pluginState, _oldState, newState) {
-        var formattingIsPresent = checkFormattingIsPresent(newState);
-        if (formattingIsPresent !== pluginState.formattingIsPresent) {
-          dispatch(pluginKey, {
-            formattingIsPresent: formattingIsPresent
-          });
-          return {
-            formattingIsPresent: formattingIsPresent
-          };
-        }
-        return pluginState;
-      }
-    },
-    key: pluginKey
-  });
-};

package/dist/esm/plugins/text-formatting/pm-plugins/cursor.js

@@ -1,48 +0,0 @@
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { TextSelection } from '@atlaskit/editor-prosemirror/state';
-export default new SafePlugin({
-  props: {
-    handleClick: function handleClick(view, clickPos, event) {
-      // Don't apply in Edge as per ED-4546
-      if (navigator && /Edge\/\d/.test(navigator.userAgent)) {
-        return false;
-      }
-
-      // @see ED-6231
-      if (clickPos > view.state.doc.content.size) {
-        return false;
-      }
-      var code = view.state.schema.marks.code;
-      var paragraph = view.state.schema.nodes.paragraph;
-      var $click = view.state.doc.resolve(clickPos);
-      var clickWasAtEdgeOfATextNode = ($click.nodeBefore ? $click.nodeBefore.isInline : $click.nodeAfter) && ($click.nodeAfter ? $click.nodeAfter.isInline : $click.nodeBefore) && $click.textOffset === 0;
-      var clickWasNearACodeMark = code && ($click.nodeBefore && code.isInSet($click.nodeBefore.marks) || $click.nodeAfter && code.isInSet($click.nodeAfter.marks));
-
-      // Find the starting position of the clicked dom-element
-      // TODO: Remove calls to private API
-      var clickedDOMElementPosition = event.target && event.target instanceof Node && view.posAtDOM(event.target);
-      var clickNode = view.state.doc.nodeAt(clickPos);
-      var clickWasAtTextNode = !!(clickNode && clickNode.isText);
-      var clickWasAtEndOfAParagraphNode = $click.parent.type === paragraph && $click.textOffset === 0 && $click.nodeAfter === null;
-      if (clickWasAtEdgeOfATextNode && clickWasNearACodeMark && clickedDOMElementPosition && (
-      // if click did not occur at a text node or end of paragraph, then
-      // it was at a directly adjacent non-text node, so we skip this manual
-      // text selection logic to preserve that non-text node's selection
-      clickWasAtTextNode || clickWasAtEndOfAParagraphNode)) {
-        var clickWasInsideNodeDOM = event.target.parentNode === view.domAtPos(clickedDOMElementPosition).node && code.isInSet(view.state.doc.resolve(clickedDOMElementPosition).nodeAfter.marks);
-        var nodeNextToClick = $click.nodeBefore && code.isInSet($click.nodeBefore.marks) ? $click.nodeAfter : $click.nodeBefore;
-
-        // Need to set the selection here to allow clicking between [code('text'),{<>},emoji()]
-        var tr = view.state.tr.setSelection(TextSelection.near($click));
-        if (clickWasInsideNodeDOM) {
-          tr.setStoredMarks([code.create()]);
-        } else {
-          tr.setStoredMarks(nodeNextToClick ? nodeNextToClick.marks : []);
-        }
-        view.dispatch(tr);
-        return true;
-      }
-      return false;
-    }
-  }
-});

package/dist/esm/plugins/text-formatting/pm-plugins/input-rule.js

@@ -1,259 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _get from "@babel/runtime/helpers/get";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-var _ValidCombinations;
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-import { createRule, createPlugin, leafNodeReplacementCharacter } from '@atlaskit/prosemirror-input-rules';
-import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { transformSmartCharsMentionsAndEmojis } from '@atlaskit/editor-common/mark';
-import { inputRuleWithAnalytics } from '@atlaskit/editor-common/utils';
-var ValidAutoformatChars = /*#__PURE__*/function (ValidAutoformatChars) {
-  ValidAutoformatChars["STRONG"] = "__";
-  ValidAutoformatChars["STRIKE"] = "~~";
-  ValidAutoformatChars["STRONG_MARKDOWN"] = "**";
-  ValidAutoformatChars["ITALIC_MARKDOWN"] = "*";
-  ValidAutoformatChars["ITALIC"] = "_";
-  ValidAutoformatChars["CODE"] = "`";
-  return ValidAutoformatChars;
-}(ValidAutoformatChars || {});
-export var ValidCombinations = (_ValidCombinations = {}, _defineProperty(_ValidCombinations, ValidAutoformatChars.STRIKE, [
-// e.g: _~~lol~~_
-ValidAutoformatChars.ITALIC,
-// e.g: __~~lol~~__
-ValidAutoformatChars.STRONG,
-// e.g: **~~lol~~**
-ValidAutoformatChars.STRONG_MARKDOWN,
-// e.g: *~~lol~~*
-ValidAutoformatChars.ITALIC_MARKDOWN]), _defineProperty(_ValidCombinations, ValidAutoformatChars.STRONG, [
-// e.g: ~~__lol__~~
-ValidAutoformatChars.STRIKE,
-// e.g: *__lol__*
-ValidAutoformatChars.ITALIC_MARKDOWN]), _defineProperty(_ValidCombinations, ValidAutoformatChars.STRONG_MARKDOWN, [
-// e.g: _**lol**_
-ValidAutoformatChars.ITALIC,
-// e.g: ~~**lol**~~
-ValidAutoformatChars.STRIKE]), _defineProperty(_ValidCombinations, ValidAutoformatChars.ITALIC_MARKDOWN, [
-// e.g: ~~*lol*~~
-ValidAutoformatChars.STRIKE,
-// e.g: __*lol*__
-ValidAutoformatChars.STRONG]), _defineProperty(_ValidCombinations, ValidAutoformatChars.ITALIC, [
-// e.g: ~~_lol_~~
-ValidAutoformatChars.STRIKE,
-// e.g: **_lol_**
-ValidAutoformatChars.STRONG_MARKDOWN]), _defineProperty(_ValidCombinations, ValidAutoformatChars.CODE, [
-// e.g: loko (`some code`
-'( ']), _ValidCombinations);
-function addMark(markType, schema, char) {
-  return function (state, match, start, end) {
-    var _schema$marks, _schema$marks$code;
-    var doc = state.doc,
-      schema = state.schema,
-      tr = state.tr;
-    var textPrefix = state.doc.textBetween(start, start + char.length);
-
-    // fixes the following case: my `*name` is *
-    // expected result: should ignore special characters inside "code"
-    if (textPrefix !== char || schema !== null && schema !== void 0 && (_schema$marks = schema.marks) !== null && _schema$marks !== void 0 && (_schema$marks$code = _schema$marks.code) !== null && _schema$marks$code !== void 0 && _schema$marks$code.isInSet(doc.resolve(start + 1).marks())) {
-      return null;
-    }
-
-    // Prevent autoformatting across hardbreaks
-    var containsHardBreak;
-    doc.nodesBetween(start, end, function (node) {
-      if (node.type === schema.nodes.hardBreak) {
-        containsHardBreak = true;
-        return false;
-      }
-      return !containsHardBreak;
-    });
-    if (containsHardBreak) {
-      return null;
-    }
-
-    // fixes autoformatting in heading nodes: # Heading *bold*
-    // expected result: should not autoformat *bold*; <h1>Heading *bold*</h1>
-    var startPosResolved = doc.resolve(start);
-    var endPosResolved = doc.resolve(end);
-    if (startPosResolved.sameParent(endPosResolved) && !startPosResolved.parent.type.allowsMarkType(markType)) {
-      return null;
-    }
-    if (markType.name === 'code') {
-      transformSmartCharsMentionsAndEmojis(tr.mapping.map(start), tr.mapping.map(end), tr);
-    }
-    var mappedStart = tr.mapping.map(start);
-    var mappedEnd = tr.mapping.map(end);
-    tr.addMark(mappedStart, mappedEnd, markType.create());
-    var textSuffix = tr.doc.textBetween(mappedEnd - char.length, mappedEnd);
-    if (textSuffix === char) {
-      tr.delete(mappedEnd - char.length, mappedEnd);
-    }
-    if (textPrefix === char) {
-      tr.delete(mappedStart, mappedStart + char.length);
-    }
-    return tr.removeStoredMark(markType);
-  };
-}
-var ReverseRegexExp = /*#__PURE__*/function (_RegExp) {
-  _inherits(ReverseRegexExp, _RegExp);
-  var _super = _createSuper(ReverseRegexExp);
-  function ReverseRegexExp() {
-    _classCallCheck(this, ReverseRegexExp);
-    return _super.apply(this, arguments);
-  }
-  _createClass(ReverseRegexExp, [{
-    key: "exec",
-    value: function exec(str) {
-      if (!str) {
-        return null;
-      }
-      var reverseStr = _toConsumableArray(str).reverse().join('');
-      var result = _get(_getPrototypeOf(ReverseRegexExp.prototype), "exec", this).call(this, reverseStr);
-      if (!result) {
-        return null;
-      }
-      for (var i = 0; i < result.length; i++) {
-        if (result[i] && typeof result[i] === 'string') {
-          result[i] = _toConsumableArray(result[i]).reverse().join('');
-        }
-      }
-      if (result.input && typeof result.input === 'string') {
-        result.input = _toConsumableArray(result.input).reverse().join('');
-      }
-      if (result.input && result[0]) {
-        result.index = result.input.length - result[0].length;
-      }
-      return result;
-    }
-  }]);
-  return ReverseRegexExp;
-}( /*#__PURE__*/_wrapNativeSuper(RegExp));
-var buildRegex = function buildRegex(char) {
-  var escapedChar = char.replace(/(\W)/g, '\\$1');
-  var combinations = ValidCombinations[char].map(function (c) {
-    return c.replace(/(\W)/g, '\\$1');
-  }).join('|');
-
-  // Single X - https://regex101.com/r/McT3yq/14/
-  // Double X - https://regex101.com/r/pQUgjx/1/
-  var baseRegex = '^X(?=[^X\\s]).*?[^\\sX]X(?=[\\sOBJECT_REPLACEMENT_CHARACTER]COMBINATIONS|$)'.replace('OBJECT_REPLACEMENT_CHARACTER', leafNodeReplacementCharacter).replace('COMBINATIONS', combinations ? "|".concat(combinations) : '');
-  var replacedRegex = String.prototype.hasOwnProperty('replaceAll') ? baseRegex.replaceAll('X', escapedChar) : baseRegex.replace(/X/g, escapedChar);
-  return new ReverseRegexExp(replacedRegex);
-};
-export var strongRegex1 = buildRegex(ValidAutoformatChars.STRONG);
-export var strongRegex2 = buildRegex(ValidAutoformatChars.STRONG_MARKDOWN);
-export var italicRegex1 = buildRegex(ValidAutoformatChars.ITALIC);
-export var italicRegex2 = buildRegex(ValidAutoformatChars.ITALIC_MARKDOWN);
-export var strikeRegex = buildRegex(ValidAutoformatChars.STRIKE);
-export var codeRegex = buildRegex(ValidAutoformatChars.CODE);
-
-/**
- * Create input rules for strong mark
- *
- * @param {Schema} schema
- * @returns {InputRuleWrapper[]}
- */
-function getStrongInputRules(schema, editorAnalyticsAPI) {
-  var ruleWithStrongAnalytics = inputRuleWithAnalytics({
-    action: ACTION.FORMATTED,
-    actionSubject: ACTION_SUBJECT.TEXT,
-    actionSubjectId: ACTION_SUBJECT_ID.FORMAT_STRONG,
-    eventType: EVENT_TYPE.TRACK,
-    attributes: {
-      inputMethod: INPUT_METHOD.FORMATTING
-    }
-  }, editorAnalyticsAPI);
-  // **string** or __strong__ should bold the text
-  var doubleUnderscoreRule = createRule(strongRegex1, addMark(schema.marks.strong, schema, ValidAutoformatChars.STRONG));
-  var doubleAsterixRule = createRule(strongRegex2, addMark(schema.marks.strong, schema, ValidAutoformatChars.STRONG_MARKDOWN));
-  return [ruleWithStrongAnalytics(doubleUnderscoreRule), ruleWithStrongAnalytics(doubleAsterixRule)];
-}
-
-/**
- * Create input rules for em mark
- *
- * @param {Schema} schema
- * @returns {InputRuleWrapper[]}
- */
-function getItalicInputRules(schema, editorAnalyticsAPI) {
-  var ruleWithItalicAnalytics = inputRuleWithAnalytics({
-    action: ACTION.FORMATTED,
-    actionSubject: ACTION_SUBJECT.TEXT,
-    actionSubjectId: ACTION_SUBJECT_ID.FORMAT_ITALIC,
-    eventType: EVENT_TYPE.TRACK,
-    attributes: {
-      inputMethod: INPUT_METHOD.FORMATTING
-    }
-  }, editorAnalyticsAPI);
-  var underscoreRule = createRule(italicRegex1, addMark(schema.marks.em, schema, ValidAutoformatChars.ITALIC));
-  var asterixRule = createRule(italicRegex2, addMark(schema.marks.em, schema, ValidAutoformatChars.ITALIC_MARKDOWN));
-  return [ruleWithItalicAnalytics(underscoreRule), ruleWithItalicAnalytics(asterixRule)];
-}
-
-/**
- * Create input rules for strike mark
- *
- * @param {Schema} schema
- * @returns {InputRuleWrapper[]}
- */
-function getStrikeInputRules(schema, editorAnalyticsAPI) {
-  var ruleWithStrikeAnalytics = inputRuleWithAnalytics({
-    action: ACTION.FORMATTED,
-    actionSubject: ACTION_SUBJECT.TEXT,
-    actionSubjectId: ACTION_SUBJECT_ID.FORMAT_STRIKE,
-    eventType: EVENT_TYPE.TRACK,
-    attributes: {
-      inputMethod: INPUT_METHOD.FORMATTING
-    }
-  }, editorAnalyticsAPI);
-  var doubleTildeRule = createRule(strikeRegex, addMark(schema.marks.strike, schema, ValidAutoformatChars.STRIKE));
-  return [ruleWithStrikeAnalytics(doubleTildeRule)];
-}
-
-/**
- * Create input rules for code mark
- *
- * @param {Schema} schema
- * @returns {InputRuleWrapper[]}
- */
-function getCodeInputRules(schema, editorAnalyticsAPI) {
-  var ruleWithCodeAnalytics = inputRuleWithAnalytics({
-    action: ACTION.FORMATTED,
-    actionSubject: ACTION_SUBJECT.TEXT,
-    actionSubjectId: ACTION_SUBJECT_ID.FORMAT_CODE,
-    eventType: EVENT_TYPE.TRACK,
-    attributes: {
-      inputMethod: INPUT_METHOD.FORMATTING
-    }
-  }, editorAnalyticsAPI);
-  var backTickRule = createRule(codeRegex, addMark(schema.marks.code, schema, ValidAutoformatChars.CODE));
-  return [ruleWithCodeAnalytics(backTickRule)];
-}
-export function inputRulePlugin(schema,
-// Don't remove the unused featureFlags, this gets used to test if we're properly passing them to the PM plugin
-_featureFlags, editorAnalyticsAPI) {
-  var rules = [];
-  if (schema.marks.strong) {
-    rules.push.apply(rules, _toConsumableArray(getStrongInputRules(schema, editorAnalyticsAPI)));
-  }
-  if (schema.marks.em) {
-    rules.push.apply(rules, _toConsumableArray(getItalicInputRules(schema, editorAnalyticsAPI)));
-  }
-  if (schema.marks.strike) {
-    rules.push.apply(rules, _toConsumableArray(getStrikeInputRules(schema, editorAnalyticsAPI)));
-  }
-  if (schema.marks.code) {
-    rules.push.apply(rules, _toConsumableArray(getCodeInputRules(schema, editorAnalyticsAPI)));
-  }
-  if (rules.length !== 0) {
-    return createPlugin('text-formatting', rules);
-  }
-  return;
-}
-export default inputRulePlugin;

package/dist/esm/plugins/text-formatting/pm-plugins/keymap.js

@@ -1,43 +0,0 @@
-import * as keymaps from '@atlaskit/editor-common/keymaps';
-import { keymap } from '@atlaskit/editor-prosemirror/keymap';
-import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { toggleStrongWithAnalytics, toggleEmWithAnalytics, toggleCodeWithAnalytics, toggleStrikeWithAnalytics, toggleSubscriptWithAnalytics, toggleSuperscriptWithAnalytics, toggleUnderlineWithAnalytics } from '../actions';
-export default function keymapPlugin(schema, editorAnalyticsAPI) {
-  var list = {};
-  if (schema.marks.strong) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleBold.common, toggleStrongWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  if (schema.marks.em) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleItalic.common, toggleEmWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  if (schema.marks.code) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleCode.common, toggleCodeWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  if (schema.marks.strike) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleStrikethrough.common, toggleStrikeWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  if (schema.marks.subsup) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleSubscript.common, toggleSubscriptWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  if (schema.marks.subsup) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleSuperscript.common, toggleSuperscriptWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  if (schema.marks.underline) {
-    keymaps.bindKeymapWithCommand(keymaps.toggleUnderline.common, toggleUnderlineWithAnalytics(editorAnalyticsAPI)({
-      inputMethod: INPUT_METHOD.SHORTCUT
-    }), list);
-  }
-  return keymap(list);
-}

package/dist/esm/plugins/text-formatting/pm-plugins/main.js

@@ -1,98 +0,0 @@
-// TODO: Ideally this should use the custom toggleMark function from @atlaskit/editor-common so we also disable the options when selecting inline nodes but it disables the marks when the selection is empty at this point in time which is undesirable
-// import { toggleMark } from '@atlaskit/editor-common/mark';
-import { toggleMark } from '@atlaskit/editor-prosemirror/commands';
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import * as keymaps from '@atlaskit/editor-common/keymaps';
-import { shallowEqual } from '@atlaskit/editor-common/utils';
-import { createInlineCodeFromTextInputWithAnalytics } from '../commands/text-formatting';
-import * as commands from '../commands/text-formatting';
-import { anyMarkActive } from '@atlaskit/editor-common/mark';
-import { pluginKey } from './plugin-key';
-export { pluginKey };
-var getTextFormattingState = function getTextFormattingState(editorState, editorAnalyticsAPI) {
-  var _editorState$schema$m = editorState.schema.marks,
-    em = _editorState$schema$m.em,
-    code = _editorState$schema$m.code,
-    strike = _editorState$schema$m.strike,
-    strong = _editorState$schema$m.strong,
-    subsup = _editorState$schema$m.subsup,
-    underline = _editorState$schema$m.underline;
-  var state = {};
-  if (code) {
-    state.codeActive = anyMarkActive(editorState, code.create());
-    state.codeDisabled = !toggleMark(code)(editorState);
-  }
-  if (em) {
-    state.emActive = anyMarkActive(editorState, em);
-    state.emDisabled = state.codeActive ? true : !toggleMark(em)(editorState);
-  }
-  if (strike) {
-    state.strikeActive = anyMarkActive(editorState, strike);
-    state.strikeDisabled = state.codeActive ? true : !toggleMark(strike)(editorState);
-  }
-  if (strong) {
-    state.strongActive = anyMarkActive(editorState, strong);
-    state.strongDisabled = state.codeActive ? true : !toggleMark(strong)(editorState);
-  }
-  if (subsup) {
-    var subMark = subsup.create({
-      type: 'sub'
-    });
-    var supMark = subsup.create({
-      type: 'sup'
-    });
-    state.subscriptActive = anyMarkActive(editorState, subMark);
-    state.subscriptDisabled = state.codeActive ? true : !toggleMark(subsup, {
-      type: 'sub'
-    })(editorState);
-    state.superscriptActive = anyMarkActive(editorState, supMark);
-    state.superscriptDisabled = state.codeActive ? true : !toggleMark(subsup, {
-      type: 'sup'
-    })(editorState);
-  }
-  if (underline) {
-    state.underlineActive = anyMarkActive(editorState, underline);
-    state.underlineDisabled = state.codeActive ? true : !toggleMark(underline)(editorState);
-  }
-  return state;
-};
-export var plugin = function plugin(dispatch, editorAnalyticsAPI) {
-  return new SafePlugin({
-    state: {
-      init: function init(_config, state) {
-        return getTextFormattingState(state, editorAnalyticsAPI);
-      },
-      apply: function apply(_tr, pluginState, _oldState, newState) {
-        var state = getTextFormattingState(newState, editorAnalyticsAPI);
-        if (!shallowEqual(pluginState, state)) {
-          dispatch(pluginKey, state);
-          return state;
-        }
-        return pluginState;
-      }
-    },
-    key: pluginKey,
-    props: {
-      handleKeyDown: function handleKeyDown(view, event) {
-        var state = view.state,
-          dispatch = view.dispatch;
-        if (event.key === keymaps.moveRight.common && !event.metaKey) {
-          return commands.moveRight()(state, dispatch);
-        } else if (event.key === keymaps.moveLeft.common && !event.metaKey) {
-          return commands.moveLeft()(state, dispatch);
-        }
-        return false;
-      },
-      handleTextInput: function handleTextInput(view, from, to, text) {
-        var state = view.state,
-          dispatch = view.dispatch;
-        var schema = state.schema,
-          parentNodeType = state.selection.$from.parent.type;
-        if (parentNodeType.allowsMarkType(schema.marks.code)) {
-          return createInlineCodeFromTextInputWithAnalytics(editorAnalyticsAPI)(from, to, text)(state, dispatch);
-        }
-        return false;
-      }
-    }
-  });
-};

package/dist/esm/plugins/text-formatting/pm-plugins/plugin-key.js

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

package/dist/esm/plugins/text-formatting/pm-plugins/smart-input-rule.js

@@ -1,169 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import { Selection } from '@atlaskit/editor-prosemirror/state';
-import { createRule, createPlugin } from '@atlaskit/prosemirror-input-rules';
-import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, PUNC, SYMBOL } from '@atlaskit/editor-common/analytics';
-import { inputRuleWithAnalytics } from '@atlaskit/editor-common/utils';
-
-/**
- * Creates an InputRuleHandler that will match on a regular expression of the
- * form `(prefix, content, suffix?)`, and replace it with some given text,
- * maintaining prefix and suffix around the replacement.
- *
- * @param text text to replace with
- */
-function replaceTextUsingCaptureGroup(text) {
-  return function (state, match, start, end) {
-    var _match = _slicedToArray(match, 4),
-      prefix = _match[1],
-      suffix = _match[3];
-    var replacement = text + (suffix || '');
-    var tr = state.tr,
-      $to = state.selection.$to;
-    var startPos = start + (prefix || '').length;
-    var safePos = Math.min(
-    // I know it is almost impossible to have a negative value at this point.
-    // But, this is JS #trustnoone
-    Math.max(startPos, 0), end);
-    tr.replaceWith(safePos, end, state.schema.text(replacement, $to.marks()));
-    tr.setSelection(Selection.near(tr.doc.resolve(tr.selection.to)));
-    return tr;
-  };
-}
-function createReplacementRule(to, from) {
-  return createRule(from, replaceTextUsingCaptureGroup(to));
-}
-
-/**
- * Create replacement rules fiven a replacement map
- * @param replMap - Replacement map
- * @param trackingEventName - Analytics V2 tracking event name
- * @param replacementRuleWithAnalytics - Analytics GAS V3 middleware for replacement and rules.
- */
-function createReplacementRules(replMap, replacementRuleWithAnalytics) {
-  return Object.keys(replMap).map(function (replacement) {
-    var regex = replMap[replacement];
-    var rule = createReplacementRule(replacement, regex);
-    if (replacementRuleWithAnalytics) {
-      return replacementRuleWithAnalytics(replacement)(rule);
-    }
-    return rule;
-  });
-}
-
-// We don't agressively upgrade single quotes to smart quotes because
-// they may clash with an emoji. Only do that when we have a matching
-// single quote, or a contraction.
-function createSingleQuotesRules() {
-  return [
-  // wrapped text
-  createRule(/(\s|^)'(\S+.*\S+)'$/, function (state, match, start, end) {
-    var OPEN_SMART_QUOTE_CHAR = '‘';
-    var CLOSED_SMART_QUOTE_CHAR = '’';
-    var _match2 = _slicedToArray(match, 3),
-      spacing = _match2[1],
-      innerContent = _match2[2];
-    // Edge case where match begins with some spacing. We need to add
-    // it back to the document
-    var openQuoteReplacement = spacing + OPEN_SMART_QUOTE_CHAR;
-    // End is not always where the closed quote is, edge case exists
-    // when there is spacing after the closed quote. We need to
-    // determine position of closed quote from the start position.
-    var positionOfClosedQuote = start + openQuoteReplacement.length + innerContent.length;
-    return state.tr.insertText(CLOSED_SMART_QUOTE_CHAR, positionOfClosedQuote, end).insertText(openQuoteReplacement, start, start + openQuoteReplacement.length);
-  }),
-  // apostrophe
-  createReplacementRule('’', /(\w+)(')(\w+)$/)];
-}
-
-/**
- * Get replacement rules related to product
- */
-function getProductRules(editorAnalyticsAPI) {
-  var productRuleWithAnalytics = function productRuleWithAnalytics(product) {
-    return inputRuleWithAnalytics(function (_, match) {
-      return {
-        action: ACTION.SUBSTITUTED,
-        actionSubject: ACTION_SUBJECT.TEXT,
-        actionSubjectId: ACTION_SUBJECT_ID.PRODUCT_NAME,
-        eventType: EVENT_TYPE.TRACK,
-        attributes: {
-          product: product,
-          originalSpelling: match[2]
-        }
-      };
-    }, editorAnalyticsAPI);
-  };
-  return createReplacementRules({
-    Atlassian: /(\s+|^)(atlassian)(\s)$/,
-    Jira: /(\s+|^)(jira|JIRA)(\s)$/,
-    Bitbucket: /(\s+|^)(bitbucket|BitBucket)(\s)$/,
-    Hipchat: /(\s+|^)(hipchat|HipChat)(\s)$/,
-    Trello: /(\s+|^)(trello)(\s)$/
-  }, productRuleWithAnalytics);
-}
-
-/**
- * Get replacement rules related to symbol
- */
-function getSymbolRules(editorAnalyticsAPI) {
-  var symbolToString = {
-    '→': SYMBOL.ARROW_RIGHT,
-    '←': SYMBOL.ARROW_LEFT,
-    '↔︎': SYMBOL.ARROW_DOUBLE
-  };
-  var symbolRuleWithAnalytics = function symbolRuleWithAnalytics(symbol) {
-    return inputRuleWithAnalytics({
-      action: ACTION.SUBSTITUTED,
-      actionSubject: ACTION_SUBJECT.TEXT,
-      actionSubjectId: ACTION_SUBJECT_ID.SYMBOL,
-      eventType: EVENT_TYPE.TRACK,
-      attributes: {
-        symbol: symbolToString[symbol]
-      }
-    }, editorAnalyticsAPI);
-  };
-  return createReplacementRules({
-    '→': /(\s+|^)(--?>)(\s)$/,
-    '←': /(\s+|^)(<--?)(\s)$/,
-    '↔︎': /(\s+|^)(<->?)(\s)$/
-  }, symbolRuleWithAnalytics);
-}
-
-/**
- * Get replacement rules related to punctuation
- */
-function getPunctuationRules(editorAnalyticsAPI) {
-  var punctuationToString = _defineProperty({
-    '–': PUNC.DASH,
-    '…': PUNC.ELLIPSIS,
-    '”': PUNC.QUOTE_DOUBLE
-  }, PUNC.QUOTE_SINGLE, PUNC.QUOTE_SINGLE);
-  var punctuationRuleWithAnalytics = function punctuationRuleWithAnalytics(punctuation) {
-    return inputRuleWithAnalytics({
-      action: ACTION.SUBSTITUTED,
-      actionSubject: ACTION_SUBJECT.TEXT,
-      actionSubjectId: ACTION_SUBJECT_ID.PUNC,
-      eventType: EVENT_TYPE.TRACK,
-      attributes: {
-        punctuation: punctuationToString[punctuation]
-      }
-    }, editorAnalyticsAPI);
-  };
-  var dashEllipsisRules = createReplacementRules({
-    '–': /(\s+|^)(--)(\s)$/,
-    '…': /()(\.\.\.)$/
-  }, punctuationRuleWithAnalytics);
-  var doubleQuoteRules = createReplacementRules({
-    '“': /((?:^|[\s\{\[\(\<'"\u2018\u201C]))(")$/,
-    '”': /"$/
-  }, punctuationRuleWithAnalytics);
-  var singleQuoteRules = createSingleQuotesRules();
-  return [].concat(_toConsumableArray(dashEllipsisRules), _toConsumableArray(doubleQuoteRules), _toConsumableArray(singleQuoteRules.map(function (rule) {
-    return punctuationRuleWithAnalytics(PUNC.QUOTE_SINGLE)(rule);
-  })));
-}
-export default (function (editorAnalyticsAPI) {
-  return createPlugin('text-formatting:smart-input', [].concat(_toConsumableArray(getProductRules(editorAnalyticsAPI)), _toConsumableArray(getSymbolRules(editorAnalyticsAPI)), _toConsumableArray(getPunctuationRules(editorAnalyticsAPI))));
-});

package/dist/esm/plugins/text-formatting/ui/Toolbar/constants.js

@@ -1,8 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-var _ResponsiveCustomButt, _ResponsiveCustomMenu;
-import { ToolbarSize } from '@atlaskit/editor-common/types';
-import { IconTypes } from './types';
-export var DefaultButtonsToolbar = [IconTypes.strong, IconTypes.em];
-export var DefaultButtonsMenu = [IconTypes.underline, IconTypes.strike, IconTypes.code, IconTypes.subscript, IconTypes.superscript];
-export var ResponsiveCustomButtonToolbar = (_ResponsiveCustomButt = {}, _defineProperty(_ResponsiveCustomButt, ToolbarSize.XXL, DefaultButtonsToolbar), _defineProperty(_ResponsiveCustomButt, ToolbarSize.XL, DefaultButtonsToolbar), _defineProperty(_ResponsiveCustomButt, ToolbarSize.L, DefaultButtonsToolbar), _defineProperty(_ResponsiveCustomButt, ToolbarSize.M, []), _defineProperty(_ResponsiveCustomButt, ToolbarSize.S, []), _defineProperty(_ResponsiveCustomButt, ToolbarSize.XXXS, []), _ResponsiveCustomButt);
-export var ResponsiveCustomMenu = (_ResponsiveCustomMenu = {}, _defineProperty(_ResponsiveCustomMenu, ToolbarSize.XXL, DefaultButtonsMenu), _defineProperty(_ResponsiveCustomMenu, ToolbarSize.XL, DefaultButtonsMenu), _defineProperty(_ResponsiveCustomMenu, ToolbarSize.L, DefaultButtonsMenu), _defineProperty(_ResponsiveCustomMenu, ToolbarSize.M, [IconTypes.strong, IconTypes.em].concat(DefaultButtonsMenu)), _defineProperty(_ResponsiveCustomMenu, ToolbarSize.S, [IconTypes.strong, IconTypes.em].concat(DefaultButtonsMenu)), _defineProperty(_ResponsiveCustomMenu, ToolbarSize.XXXS, [IconTypes.strong, IconTypes.em].concat(DefaultButtonsMenu)), _ResponsiveCustomMenu);