@atlaskit/editor-plugin-text-formatting 0.1.0

package/dist/cjs/plugin.js

@@ -0,0 +1,133 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.textFormattingPlugin = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _adfSchema = require("@atlaskit/adf-schema");
+var _withPluginState = require("@atlaskit/editor-common/with-plugin-state");
+var _actions = require("./actions");
+var _clearFormatting = require("./pm-plugins/clear-formatting");
+var _clearFormattingKeymap = _interopRequireDefault(require("./pm-plugins/clear-formatting-keymap"));
+var _cursor = _interopRequireDefault(require("./pm-plugins/cursor"));
+var _inputRule = _interopRequireDefault(require("./pm-plugins/input-rule"));
+var _keymap = _interopRequireDefault(require("./pm-plugins/keymap"));
+var _main = require("./pm-plugins/main");
+var _smartInputRule = _interopRequireDefault(require("./pm-plugins/smart-input-rule"));
+var _Toolbar = _interopRequireDefault(require("./ui/Toolbar"));
+var textFormattingPlugin = function textFormattingPlugin() {
+  var _api$dependencies$ana7, _api$dependencies$ana8, _api$dependencies$ana9, _api$dependencies$ana10, _api$dependencies$ana11, _api$dependencies$ana12, _api$dependencies$ana13;
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var api = arguments.length > 1 ? arguments[1] : undefined;
+  return {
+    name: 'textFormatting',
+    marks: function marks() {
+      return [{
+        name: 'em',
+        mark: _adfSchema.em
+      }, {
+        name: 'strong',
+        mark: _adfSchema.strong
+      }, {
+        name: 'strike',
+        mark: _adfSchema.strike
+      }].concat(options.disableCode ? [] : {
+        name: 'code',
+        mark: _adfSchema.code
+      }).concat(options.disableSuperscriptAndSubscript ? [] : {
+        name: 'subsup',
+        mark: _adfSchema.subsup
+      }).concat(options.disableUnderline ? [] : {
+        name: 'underline',
+        mark: _adfSchema.underline
+      });
+    },
+    pmPlugins: function pmPlugins() {
+      return [{
+        name: 'textFormatting',
+        plugin: function plugin(_ref) {
+          var _api$dependencies$ana;
+          var dispatch = _ref.dispatch;
+          return (0, _main.plugin)(dispatch, api === null || api === void 0 ? void 0 : (_api$dependencies$ana = api.dependencies.analytics) === null || _api$dependencies$ana === void 0 ? void 0 : _api$dependencies$ana.actions);
+        }
+      }, {
+        name: 'textFormattingCursor',
+        plugin: function plugin() {
+          return _cursor.default;
+        }
+      }, {
+        name: 'textFormattingInputRule',
+        plugin: function plugin(_ref2) {
+          var _api$dependencies$ana2;
+          var schema = _ref2.schema;
+          return (0, _inputRule.default)(schema, api === null || api === void 0 ? void 0 : (_api$dependencies$ana2 = api.dependencies.analytics) === null || _api$dependencies$ana2 === void 0 ? void 0 : _api$dependencies$ana2.actions);
+        }
+      }, {
+        name: 'textFormattingSmartRule',
+        plugin: function plugin() {
+          var _api$dependencies$ana3;
+          return !options.disableSmartTextCompletion ? (0, _smartInputRule.default)(api === null || api === void 0 ? void 0 : (_api$dependencies$ana3 = api.dependencies.analytics) === null || _api$dependencies$ana3 === void 0 ? void 0 : _api$dependencies$ana3.actions) : undefined;
+        }
+      }, {
+        name: 'textFormattingClear',
+        plugin: function plugin(_ref3) {
+          var dispatch = _ref3.dispatch;
+          return (0, _clearFormatting.plugin)(dispatch);
+        }
+      }, {
+        name: 'textFormattingClearKeymap',
+        plugin: function plugin() {
+          var _api$dependencies$ana4;
+          return (0, _clearFormattingKeymap.default)(api === null || api === void 0 ? void 0 : (_api$dependencies$ana4 = api.dependencies.analytics) === null || _api$dependencies$ana4 === void 0 ? void 0 : _api$dependencies$ana4.actions);
+        }
+      }, {
+        name: 'textFormattingKeymap',
+        plugin: function plugin(_ref4) {
+          var _api$dependencies$ana5;
+          var schema = _ref4.schema;
+          return (0, _keymap.default)(schema, api === null || api === void 0 ? void 0 : (_api$dependencies$ana5 = api.dependencies.analytics) === null || _api$dependencies$ana5 === void 0 ? void 0 : _api$dependencies$ana5.actions);
+        }
+      }];
+    },
+    primaryToolbarComponent: function primaryToolbarComponent(_ref5) {
+      var editorView = _ref5.editorView,
+        popupsMountPoint = _ref5.popupsMountPoint,
+        popupsScrollableElement = _ref5.popupsScrollableElement,
+        isToolbarReducedSpacing = _ref5.isToolbarReducedSpacing,
+        toolbarSize = _ref5.toolbarSize,
+        disabled = _ref5.disabled;
+      return /*#__PURE__*/_react.default.createElement(_withPluginState.WithPluginState, {
+        plugins: {
+          textFormattingState: _main.pluginKey,
+          clearFormattingPluginState: _clearFormatting.pluginKey
+        },
+        render: function render() {
+          var _api$dependencies$ana6;
+          return /*#__PURE__*/_react.default.createElement(_Toolbar.default, {
+            editorState: editorView.state,
+            popupsMountPoint: popupsMountPoint,
+            popupsScrollableElement: popupsScrollableElement,
+            toolbarSize: toolbarSize,
+            isReducedSpacing: isToolbarReducedSpacing,
+            editorView: editorView,
+            isToolbarDisabled: disabled,
+            shouldUseResponsiveToolbar: Boolean(options.responsiveToolbarMenu),
+            editorAnalyticsAPI: api === null || api === void 0 ? void 0 : (_api$dependencies$ana6 = api.dependencies.analytics) === null || _api$dependencies$ana6 === void 0 ? void 0 : _api$dependencies$ana6.actions
+          });
+        }
+      });
+    },
+    actions: {
+      toggleSuperscript: (0, _actions.toggleSuperscriptWithAnalytics)(api === null || api === void 0 ? void 0 : (_api$dependencies$ana7 = api.dependencies.analytics) === null || _api$dependencies$ana7 === void 0 ? void 0 : _api$dependencies$ana7.actions),
+      toggleSubscript: (0, _actions.toggleSubscriptWithAnalytics)(api === null || api === void 0 ? void 0 : (_api$dependencies$ana8 = api.dependencies.analytics) === null || _api$dependencies$ana8 === void 0 ? void 0 : _api$dependencies$ana8.actions),
+      toggleStrike: (0, _actions.toggleStrikeWithAnalytics)(api === null || api === void 0 ? void 0 : (_api$dependencies$ana9 = api.dependencies.analytics) === null || _api$dependencies$ana9 === void 0 ? void 0 : _api$dependencies$ana9.actions),
+      toggleCode: (0, _actions.toggleCodeWithAnalytics)(api === null || api === void 0 ? void 0 : (_api$dependencies$ana10 = api.dependencies.analytics) === null || _api$dependencies$ana10 === void 0 ? void 0 : _api$dependencies$ana10.actions),
+      toggleUnderline: (0, _actions.toggleUnderlineWithAnalytics)(api === null || api === void 0 ? void 0 : (_api$dependencies$ana11 = api.dependencies.analytics) === null || _api$dependencies$ana11 === void 0 ? void 0 : _api$dependencies$ana11.actions),
+      toggleEm: (0, _actions.toggleEmWithAnalytics)(api === null || api === void 0 ? void 0 : (_api$dependencies$ana12 = api.dependencies.analytics) === null || _api$dependencies$ana12 === void 0 ? void 0 : _api$dependencies$ana12.actions),
+      toggleStrong: (0, _actions.toggleStrongWithAnalytics)(api === null || api === void 0 ? void 0 : (_api$dependencies$ana13 = api.dependencies.analytics) === null || _api$dependencies$ana13 === void 0 ? void 0 : _api$dependencies$ana13.actions)
+    }
+  };
+};
+exports.textFormattingPlugin = textFormattingPlugin;

package/dist/cjs/pm-plugins/clear-formatting-keymap.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.keymapPlugin = keymapPlugin;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var keymaps = _interopRequireWildcard(require("@atlaskit/editor-common/keymaps"));
+var _keymap = require("@atlaskit/editor-prosemirror/keymap");
+var _clearFormatting = require("../commands/clear-formatting");
+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; }
+function keymapPlugin(editorAnalyticsAPI) {
+  var list = {};
+  keymaps.bindKeymapWithCommand(keymaps.clearFormatting.common, (0, _clearFormatting.clearFormattingWithAnalytics)(_analytics.INPUT_METHOD.SHORTCUT, editorAnalyticsAPI), list);
+  return (0, _keymap.keymap)(list);
+}
+var _default = keymapPlugin;
+exports.default = _default;

package/dist/cjs/pm-plugins/clear-formatting.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pluginKey = exports.plugin = void 0;
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _utils = require("../utils");
+var pluginKey = new _state.PluginKey('clearFormattingPlugin');
+exports.pluginKey = pluginKey;
+var plugin = function plugin(dispatch) {
+  return new _safePlugin.SafePlugin({
+    state: {
+      init: function init(_config, state) {
+        return {
+          formattingIsPresent: (0, _utils.checkFormattingIsPresent)(state)
+        };
+      },
+      apply: function apply(_tr, pluginState, _oldState, newState) {
+        var formattingIsPresent = (0, _utils.checkFormattingIsPresent)(newState);
+        if (formattingIsPresent !== pluginState.formattingIsPresent) {
+          dispatch(pluginKey, {
+            formattingIsPresent: formattingIsPresent
+          });
+          return {
+            formattingIsPresent: formattingIsPresent
+          };
+        }
+        return pluginState;
+      }
+    },
+    key: pluginKey
+  });
+};
+exports.plugin = plugin;

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

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _default = new _safePlugin.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(_state.TextSelection.near($click));
+        if (clickWasInsideNodeDOM) {
+          tr.setStoredMarks([code.create()]);
+        } else {
+          tr.setStoredMarks(nodeNextToClick ? nodeNextToClick.marks : []);
+        }
+        view.dispatch(tr);
+        return true;
+      }
+      return false;
+    }
+  }
+});
+exports.default = _default;

package/dist/cjs/pm-plugins/input-rule.js

@@ -0,0 +1,274 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.codeRegex = exports.ValidCombinations = void 0;
+exports.inputRulePlugin = inputRulePlugin;
+exports.strongRegex2 = exports.strongRegex1 = exports.strikeRegex = exports.italicRegex2 = exports.italicRegex1 = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _mark = require("@atlaskit/editor-common/mark");
+var _utils = require("@atlaskit/editor-common/utils");
+var _prosemirrorInputRules = require("@atlaskit/prosemirror-input-rules");
+var _ValidCombinations;
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } }
+var ValidAutoformatChars = /*#__PURE__*/function (ValidAutoformatChars) {
+  ValidAutoformatChars["STRONG"] = "__";
+  ValidAutoformatChars["STRIKE"] = "~~";
+  ValidAutoformatChars["STRONG_MARKDOWN"] = "**";
+  ValidAutoformatChars["ITALIC_MARKDOWN"] = "*";
+  ValidAutoformatChars["ITALIC"] = "_";
+  ValidAutoformatChars["CODE"] = "`";
+  return ValidAutoformatChars;
+}(ValidAutoformatChars || {});
+var ValidCombinations = (_ValidCombinations = {}, (0, _defineProperty2.default)(_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]), (0, _defineProperty2.default)(_ValidCombinations, ValidAutoformatChars.STRONG, [
+// e.g: ~~__lol__~~
+ValidAutoformatChars.STRIKE,
+// e.g: *__lol__*
+ValidAutoformatChars.ITALIC_MARKDOWN]), (0, _defineProperty2.default)(_ValidCombinations, ValidAutoformatChars.STRONG_MARKDOWN, [
+// e.g: _**lol**_
+ValidAutoformatChars.ITALIC,
+// e.g: ~~**lol**~~
+ValidAutoformatChars.STRIKE]), (0, _defineProperty2.default)(_ValidCombinations, ValidAutoformatChars.ITALIC_MARKDOWN, [
+// e.g: ~~*lol*~~
+ValidAutoformatChars.STRIKE,
+// e.g: __*lol*__
+ValidAutoformatChars.STRONG]), (0, _defineProperty2.default)(_ValidCombinations, ValidAutoformatChars.ITALIC, [
+// e.g: ~~_lol_~~
+ValidAutoformatChars.STRIKE,
+// e.g: **_lol_**
+ValidAutoformatChars.STRONG_MARKDOWN]), (0, _defineProperty2.default)(_ValidCombinations, ValidAutoformatChars.CODE, [
+// e.g: loko (`some code`
+'( ']), _ValidCombinations);
+exports.ValidCombinations = 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') {
+      (0, _mark.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) {
+  (0, _inherits2.default)(ReverseRegexExp, _RegExp);
+  var _super = _createSuper(ReverseRegexExp);
+  function ReverseRegexExp() {
+    (0, _classCallCheck2.default)(this, ReverseRegexExp);
+    return _super.apply(this, arguments);
+  }
+  (0, _createClass2.default)(ReverseRegexExp, [{
+    key: "exec",
+    value: function exec(str) {
+      if (!str) {
+        return null;
+      }
+      var reverseStr = (0, _toConsumableArray2.default)(str).reverse().join('');
+      var result = (0, _get2.default)((0, _getPrototypeOf2.default)(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] = (0, _toConsumableArray2.default)(result[i]).reverse().join('');
+        }
+      }
+      if (result.input && typeof result.input === 'string') {
+        result.input = (0, _toConsumableArray2.default)(result.input).reverse().join('');
+      }
+      if (result.input && result[0]) {
+        result.index = result.input.length - result[0].length;
+      }
+      return result;
+    }
+  }]);
+  return ReverseRegexExp;
+}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(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', _prosemirrorInputRules.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);
+};
+var strongRegex1 = buildRegex(ValidAutoformatChars.STRONG);
+exports.strongRegex1 = strongRegex1;
+var strongRegex2 = buildRegex(ValidAutoformatChars.STRONG_MARKDOWN);
+exports.strongRegex2 = strongRegex2;
+var italicRegex1 = buildRegex(ValidAutoformatChars.ITALIC);
+exports.italicRegex1 = italicRegex1;
+var italicRegex2 = buildRegex(ValidAutoformatChars.ITALIC_MARKDOWN);
+exports.italicRegex2 = italicRegex2;
+var strikeRegex = buildRegex(ValidAutoformatChars.STRIKE);
+exports.strikeRegex = strikeRegex;
+var codeRegex = buildRegex(ValidAutoformatChars.CODE);
+
+/**
+ * Create input rules for strong mark
+ *
+ * @param {Schema} schema
+ * @returns {InputRuleWrapper[]}
+ */
+exports.codeRegex = codeRegex;
+function getStrongInputRules(schema, editorAnalyticsAPI) {
+  var ruleWithStrongAnalytics = (0, _utils.inputRuleWithAnalytics)({
+    action: _analytics.ACTION.FORMATTED,
+    actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+    actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_STRONG,
+    eventType: _analytics.EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: _analytics.INPUT_METHOD.FORMATTING
+    }
+  }, editorAnalyticsAPI);
+  // **string** or __strong__ should bold the text
+  var doubleUnderscoreRule = (0, _prosemirrorInputRules.createRule)(strongRegex1, addMark(schema.marks.strong, schema, ValidAutoformatChars.STRONG));
+  var doubleAsterixRule = (0, _prosemirrorInputRules.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 = (0, _utils.inputRuleWithAnalytics)({
+    action: _analytics.ACTION.FORMATTED,
+    actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+    actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_ITALIC,
+    eventType: _analytics.EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: _analytics.INPUT_METHOD.FORMATTING
+    }
+  }, editorAnalyticsAPI);
+  var underscoreRule = (0, _prosemirrorInputRules.createRule)(italicRegex1, addMark(schema.marks.em, schema, ValidAutoformatChars.ITALIC));
+  var asterixRule = (0, _prosemirrorInputRules.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 = (0, _utils.inputRuleWithAnalytics)({
+    action: _analytics.ACTION.FORMATTED,
+    actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+    actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_STRIKE,
+    eventType: _analytics.EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: _analytics.INPUT_METHOD.FORMATTING
+    }
+  }, editorAnalyticsAPI);
+  var doubleTildeRule = (0, _prosemirrorInputRules.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 = (0, _utils.inputRuleWithAnalytics)({
+    action: _analytics.ACTION.FORMATTED,
+    actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+    actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_CODE,
+    eventType: _analytics.EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: _analytics.INPUT_METHOD.FORMATTING
+    }
+  }, editorAnalyticsAPI);
+  var backTickRule = (0, _prosemirrorInputRules.createRule)(codeRegex, addMark(schema.marks.code, schema, ValidAutoformatChars.CODE));
+  return [ruleWithCodeAnalytics(backTickRule)];
+}
+function inputRulePlugin(schema, editorAnalyticsAPI) {
+  var rules = [];
+  if (schema.marks.strong) {
+    rules.push.apply(rules, (0, _toConsumableArray2.default)(getStrongInputRules(schema, editorAnalyticsAPI)));
+  }
+  if (schema.marks.em) {
+    rules.push.apply(rules, (0, _toConsumableArray2.default)(getItalicInputRules(schema, editorAnalyticsAPI)));
+  }
+  if (schema.marks.strike) {
+    rules.push.apply(rules, (0, _toConsumableArray2.default)(getStrikeInputRules(schema, editorAnalyticsAPI)));
+  }
+  if (schema.marks.code) {
+    rules.push.apply(rules, (0, _toConsumableArray2.default)(getCodeInputRules(schema, editorAnalyticsAPI)));
+  }
+  if (rules.length !== 0) {
+    return (0, _prosemirrorInputRules.createPlugin)('text-formatting', rules);
+  }
+  return;
+}
+var _default = inputRulePlugin;
+exports.default = _default;

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

@@ -0,0 +1,52 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = keymapPlugin;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var keymaps = _interopRequireWildcard(require("@atlaskit/editor-common/keymaps"));
+var _keymap = require("@atlaskit/editor-prosemirror/keymap");
+var _actions = require("../actions");
+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; }
+function keymapPlugin(schema, editorAnalyticsAPI) {
+  var list = {};
+  if (schema.marks.strong) {
+    keymaps.bindKeymapWithCommand(keymaps.toggleBold.common, (0, _actions.toggleStrongWithAnalytics)(editorAnalyticsAPI)({
+      inputMethod: _analytics.INPUT_METHOD.SHORTCUT
+    }), list);
+  }
+  if (schema.marks.em) {
+    keymaps.bindKeymapWithCommand(keymaps.toggleItalic.common, (0, _actions.toggleEmWithAnalytics)(editorAnalyticsAPI)({
+      inputMethod: _analytics.INPUT_METHOD.SHORTCUT
+    }), list);
+  }
+  if (schema.marks.code) {
+    keymaps.bindKeymapWithCommand(keymaps.toggleCode.common, (0, _actions.toggleCodeWithAnalytics)(editorAnalyticsAPI)({
+      inputMethod: _analytics.INPUT_METHOD.SHORTCUT
+    }), list);
+  }
+  if (schema.marks.strike) {
+    keymaps.bindKeymapWithCommand(keymaps.toggleStrikethrough.common, (0, _actions.toggleStrikeWithAnalytics)(editorAnalyticsAPI)({
+      inputMethod: _analytics.INPUT_METHOD.SHORTCUT
+    }), list);
+  }
+  if (schema.marks.subsup) {
+    keymaps.bindKeymapWithCommand(keymaps.toggleSubscript.common, (0, _actions.toggleSubscriptWithAnalytics)(editorAnalyticsAPI)({
+      inputMethod: _analytics.INPUT_METHOD.SHORTCUT
+    }), list);
+  }
+  if (schema.marks.subsup) {
+    keymaps.bindKeymapWithCommand(keymaps.toggleSuperscript.common, (0, _actions.toggleSuperscriptWithAnalytics)(editorAnalyticsAPI)({
+      inputMethod: _analytics.INPUT_METHOD.SHORTCUT
+    }), list);
+  }
+  if (schema.marks.underline) {
+    keymaps.bindKeymapWithCommand(keymaps.toggleUnderline.common, (0, _actions.toggleUnderlineWithAnalytics)(editorAnalyticsAPI)({
+      inputMethod: _analytics.INPUT_METHOD.SHORTCUT
+    }), list);
+  }
+  return (0, _keymap.keymap)(list);
+}