@atlaskit/editor-plugin-list 0.2.0 → 1.0.0

package/dist/cjs/commands/listBackspace.js

@@ -0,0 +1,284 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.listBackspace = exports.calcJoinListScenario = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _utils = require("@atlaskit/editor-common/utils");
+var _utils2 = require("@atlaskit/editor-prosemirror/utils");
+var _selection = require("../utils/selection");
+var _BACKSPACE_COMMANDS;
+//Cases below refer to the cases found in this document: https://product-fabric.atlassian.net/wiki/spaces/E/pages/1146954996/List+Backspace+and+Delete+Behaviour
+//Case for two adjacent list items of the same indentation
+var listBackspaceCase2 = function listBackspaceCase2(tr, dispatch, $prev, $head) {
+  /* CASE 2
+   * Initial Structure:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph D { text1 |textInsertPos| }       //Cant have children since that would be Case 4
+   *   |$prev||childrenGInsertPos| }
+   *   ListItem E {
+   *     Paragraph F { |$head| text2 }
+   *     ...Children G
+   *   }
+   * }
+   *
+   * Converts to:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph C { text1text2 }
+   *     ...Children G
+   *   }
+   * }
+   *
+   */
+
+  var listItemE = $head.node(-1); //Head is inside listItem E so it must have a first and last child
+  if (!listItemE.firstChild) {
+    return false;
+  }
+  var beforeListItemE = $head.before(-1);
+  var afterListItemE = $head.after(-1);
+  var textInsertPos = $prev.pos - 1; //Paragraph D must be directly behind $prev otherwise it would be case 4
+  var childrenGInsertPos = $prev.pos;
+  var textContent = $head.parent.content;
+  var childrenGContent = listItemE.content.cut(listItemE.firstChild.nodeSize);
+  (0, _utils.insertContentDeleteRange)(tr, function (tr) {
+    return tr.doc.resolve(textInsertPos);
+  }, [[textContent, textInsertPos], [childrenGContent, childrenGInsertPos]], [[beforeListItemE, afterListItemE]]);
+  if (dispatch) {
+    dispatch(tr);
+  }
+  return true;
+};
+
+//Case for two adjacent list items with the first being of lower indentation
+var listBackspaceCase3 = function listBackspaceCase3(tr, dispatch, $prev, $head) {
+  /* CASE 3
+   * Initial Structure:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph D { text1 |$prev||textInsertPos| } |childrenHInsertPos|
+   *     List E { |childrenJInsertPos|
+   *       ListItem F {
+   *         Paragraph G { |$head| text2 }
+   *         ...Children H
+   *         List? I {
+   *           ...Children J
+   *         }
+   *       }
+   *       ...Children K
+   *     }
+   *   }
+   * }
+   *
+   * Converts to:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph D { text1text2 }
+   *     ...Children H
+   *     List E {
+   *       ...Children J
+   *       ...Children K
+   *     }
+   *   }
+   * }
+   *
+   */
+
+  var listE = $head.node(-2);
+  var listItemF = $head.node(-1); //Head is inside listItem F so it must have a first and last child
+  if (!listItemF.firstChild || !listItemF.lastChild) {
+    return false;
+  }
+  var beforeListE = $head.before(-2);
+  var beforeListItemF = $head.before(-1);
+  var afterParagraphD = $prev.after();
+  var afterListE = $head.after(-2);
+  var afterListItemF = $head.after(-1);
+  var startListE = $head.start(-2);
+  var containsChildrenJ = (0, _utils.isListNode)(listItemF.lastChild);
+  var shouldRemoveListE = listE.childCount === 1 && !containsChildrenJ; //Assures no Children J and K
+  var textInsertPos = $prev.pos;
+  var childrenHInsertPos = afterParagraphD;
+  var childrenJInsertPos = startListE;
+  var textContent = $head.parent.content;
+  var childrenHContent = containsChildrenJ ? listItemF.content.cut(listItemF.firstChild.nodeSize, listItemF.nodeSize - listItemF.lastChild.nodeSize - 2) : listItemF.content.cut(listItemF.firstChild.nodeSize); //If Children J doesn't exist then Children H will include the last node
+  var childrenJContent = listItemF.lastChild.content; //Will be invalid if there are no Children J but it will be unused
+
+  (0, _utils.insertContentDeleteRange)(tr, function (tr) {
+    return tr.doc.resolve(textInsertPos);
+  }, containsChildrenJ ? [[textContent, textInsertPos], [childrenHContent, childrenHInsertPos], [childrenJContent, childrenJInsertPos]] : [[textContent, textInsertPos], [childrenHContent, childrenHInsertPos]], [shouldRemoveListE ? [beforeListE, afterListE] : [beforeListItemF, afterListItemF]]);
+  if (dispatch) {
+    dispatch(tr);
+  }
+  return true;
+};
+
+//Case for two adjacent list items with the first being of greater indentation
+var listBackspaceCase4 = function listBackspaceCase4(tr, dispatch, $prev, $head, $last) {
+  /* CASE 4
+   * Initial Structure:
+   *
+   * List A {
+   *   ListItem B {
+   *     Paragraph C { text1 }
+   *     ...Children D
+   *     List E {
+   *       ...
+   *         List F {       //May be multiple levels of lists
+   *           ...Children G
+   *           ListItem H {        //Last node of the block
+   *             ...Children I
+   *             Paragraph J { text2 |$last||textInsertPos| } |childrenMInsertPos|        //Cant have children since this ListItem is the last of the block
+   *           }
+   *         }
+   *       ...
+   *     |childrenOInsertPosition| }
+   *   |$prev| }
+   *   ListItem K {
+   *      Paragraph L { |$head| text3 }
+   *      ...Children M
+   *      List? N {
+   *       ...Children O
+   *      }
+   *   }
+   * }
+   *
+   * Converts to:
+   *
+   * List A {
+   *   ListItem B {
+   *     Paragraph C { text1 }
+   *     ...Children D
+   *     List E {
+   *       ...
+   *         List F {
+   *           ...Children G
+   *           ListItem H {
+   *             ...Children I
+   *             Paragraph J { text2text3 }
+   *             ...Children M
+   *           }
+   *         }
+   *       ...
+   *       ...Children O
+   *     }
+   *   }
+   * }
+   *
+   */
+
+  if (!$last) {
+    //Exit if an invalid last was given as a parameter
+    return false;
+  }
+  var listItemK = $head.node(-1); //Head is inside listItem K so it must have a first and last child
+  if (!listItemK.firstChild || !listItemK.lastChild) {
+    return false;
+  }
+  var paragraphL = $head.parent;
+  var beforeListItemK = $head.before(-1);
+  var afterParagraphJ = $last.after();
+  var afterListItemK = $head.after(-1);
+  var containsChildrenO = (0, _utils.isListNode)(listItemK.lastChild);
+  var textInsertPos = $last.pos;
+  var childrenMInsertPos = afterParagraphJ;
+  var childrenOInsertPos = $prev.pos - 1; //Last item of listItem B must be a list therefore we can simply decrement $prev to get there
+
+  var textContent = paragraphL.content;
+  var childrenMContent = containsChildrenO ? listItemK.content.cut(listItemK.firstChild.nodeSize, listItemK.nodeSize - listItemK.lastChild.nodeSize - 2) : listItemK.content.cut(listItemK.firstChild.nodeSize);
+  var childrenOContent = listItemK.lastChild.content;
+  (0, _utils.insertContentDeleteRange)(tr, function (tr) {
+    return tr.doc.resolve(textInsertPos);
+  }, containsChildrenO ? [[textContent, textInsertPos], [childrenMContent, childrenMInsertPos], [childrenOContent, childrenOInsertPos]] : [[textContent, textInsertPos], [childrenMContent, childrenMInsertPos]], [[beforeListItemK, afterListItemK]]);
+  if (dispatch) {
+    dispatch(tr);
+  }
+  return true;
+};
+var BACKSPACE_COMMANDS = (_BACKSPACE_COMMANDS = {}, (0, _defineProperty2.default)(_BACKSPACE_COMMANDS, _analytics.LIST_TEXT_SCENARIOS.JOIN_SIBLINGS, listBackspaceCase2), (0, _defineProperty2.default)(_BACKSPACE_COMMANDS, _analytics.LIST_TEXT_SCENARIOS.JOIN_DESCENDANT_TO_PARENT, listBackspaceCase3), (0, _defineProperty2.default)(_BACKSPACE_COMMANDS, _analytics.LIST_TEXT_SCENARIOS.JOIN_TO_SIBLING_DESCENDANT, listBackspaceCase4), _BACKSPACE_COMMANDS);
+var calcJoinListScenario = function calcJoinListScenario(walkNode, $head, tr) {
+  var $prev = walkNode.$pos,
+    prevFoundNode = walkNode.foundNode;
+  var prevInList = (0, _selection.isPosInsideList)($prev);
+  var headInParagraph = (0, _selection.isPosInsideParagraph)($head);
+  var headInFirstChild = $head.index(-1) === 0;
+  var headInList = (0, _selection.isPosInsideList)($head);
+
+  //Must be at the start of the selection of the first child in the listItem
+
+  if (!prevFoundNode || !prevInList || !headInParagraph || !headInFirstChild || !headInList) {
+    return false;
+  }
+  var prevInParagraph = (0, _selection.isPosInsideParagraph)($prev);
+  if (prevInParagraph) {
+    return [_analytics.LIST_TEXT_SCENARIOS.JOIN_DESCENDANT_TO_PARENT, null];
+  }
+  var prevParentLastChildIsList = $prev.parent.lastChild && (0, _utils.isListNode)($prev.parent.lastChild);
+  var prevParentLastChildIsParagraph = (0, _utils.isParagraphNode)($prev.parent.lastChild);
+
+  // Will search for the possible last node for case 4 (where the list could be indented multiple times)
+  // $last is required to determine whether we are in case 2 or 4
+  var $last = tr.doc.resolve($prev.pos);
+  var lastFoundNode;
+  do {
+    var _walkNode = (0, _utils.walkPrevNode)($last);
+    $last = _walkNode.$pos;
+    lastFoundNode = _walkNode.foundNode;
+  } while (lastFoundNode && !$last.parent.isTextblock);
+  var lastInParagraph = (0, _selection.isPosInsideParagraph)($last);
+  if (lastFoundNode && prevParentLastChildIsList && lastInParagraph) {
+    return [_analytics.LIST_TEXT_SCENARIOS.JOIN_TO_SIBLING_DESCENDANT, $last];
+  } else if (prevParentLastChildIsParagraph) {
+    return [_analytics.LIST_TEXT_SCENARIOS.JOIN_SIBLINGS, null];
+  }
+  return false;
+};
+exports.calcJoinListScenario = calcJoinListScenario;
+var listBackspace = function listBackspace(editorAnalyticsAPI) {
+  return function (state, dispatch) {
+    var tr = state.tr,
+      $head = state.selection.$head;
+    var walkNode = (0, _utils.walkPrevNode)($head);
+    if (!(0, _utils.isEmptySelectionAtStart)(state)) {
+      return false;
+    }
+    var scenario = calcJoinListScenario(walkNode, $head, tr);
+    if (!scenario) {
+      return false;
+    }
+    var _state$schema$nodes = state.schema.nodes,
+      bulletList = _state$schema$nodes.bulletList,
+      orderedList = _state$schema$nodes.orderedList;
+    var listParent = (0, _utils2.findParentNodeOfType)([bulletList, orderedList])(tr.selection);
+    var actionSubjectId = _analytics.ACTION_SUBJECT_ID.FORMAT_LIST_BULLET;
+    if (listParent && listParent.node.type === orderedList) {
+      actionSubjectId = _analytics.ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER;
+    }
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+      action: _analytics.ACTION.LIST_ITEM_JOINED,
+      actionSubject: _analytics.ACTION_SUBJECT.LIST,
+      actionSubjectId: actionSubjectId,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      attributes: {
+        inputMethod: _analytics.INPUT_METHOD.KEYBOARD,
+        direction: _analytics.DELETE_DIRECTION.BACKWARD,
+        scenario: scenario[0]
+      }
+    })(tr);
+    return BACKSPACE_COMMANDS[scenario[0]](tr, dispatch, walkNode.$pos, $head, scenario[1]);
+  };
+};
+exports.listBackspace = listBackspace;

package/dist/cjs/commands/outdent-list.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.outdentList = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _lists = require("@atlaskit/editor-common/lists");
+var _utils = require("@atlaskit/editor-common/utils");
+var _history = require("@atlaskit/editor-prosemirror/history");
+var _outdentListItemsSelected = require("../actions/outdent-list-items-selected");
+var _analytics2 = require("../utils/analytics");
+var _find = require("../utils/find");
+var _selection = require("../utils/selection");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var outdentList = function outdentList(editorAnalyticsAPI) {
+  return function () {
+    var inputMethod = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _analytics.INPUT_METHOD.KEYBOARD;
+    var featureFlags = arguments.length > 1 ? arguments[1] : undefined;
+    return function (state, dispatch) {
+      if (!(0, _selection.isInsideListItem)(state)) {
+        return false;
+      }
+      var $from = state.selection.$from;
+      var parentListNode = (0, _find.findFirstParentListNode)($from);
+      if (!parentListNode) {
+        // Even though this is a non-operation, we don't want to send this event to the browser. Because if we return false, the browser will move the focus to another place
+        return true;
+      }
+
+      // Save the history, so it could undo/revert to the same state before the outdent, see https://product-fabric.atlassian.net/browse/ED-14753
+      (0, _history.closeHistory)(state.tr);
+      var actionSubjectId = (0, _utils.isBulletList)(parentListNode.node) ? _analytics.ACTION_SUBJECT_ID.FORMAT_LIST_BULLET : _analytics.ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER;
+      var customTr = state.tr;
+      (0, _outdentListItemsSelected.outdentListItemsSelected)(customTr, state, featureFlags);
+      if (!customTr || !customTr.docChanged) {
+        // Even though this is a non-operation, we don't want to send this event to the browser. Because if we return false, the browser will move the focus to another place
+        // If inside table cell and can't outdent list, then let it handle by table keymap
+        return !(0, _selection.isInsideTableCell)(state);
+      }
+      var restartListsAttributes = {};
+      if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
+        var _getRestartListsAttri = (0, _analytics2.getRestartListsAttributes)(customTr),
+          outdentScenario = _getRestartListsAttri.outdentScenario,
+          splitListStartNumber = _getRestartListsAttri.splitListStartNumber;
+        if (outdentScenario === _analytics.OUTDENT_SCENARIOS.SPLIT_LIST) {
+          restartListsAttributes.outdentScenario = outdentScenario;
+          restartListsAttributes.splitListStartNumber = splitListStartNumber;
+        }
+      }
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+        action: _analytics.ACTION.OUTDENTED,
+        actionSubject: _analytics.ACTION_SUBJECT.LIST,
+        actionSubjectId: actionSubjectId,
+        eventType: _analytics.EVENT_TYPE.TRACK,
+        attributes: _objectSpread(_objectSpread(_objectSpread({}, (0, _lists.getCommonListAnalyticsAttributes)(state)), restartListsAttributes), {}, {
+          inputMethod: inputMethod
+        })
+      })(customTr);
+      if (dispatch) {
+        dispatch(customTr);
+      }
+      return true;
+    };
+  };
+};
+exports.outdentList = outdentList;

package/dist/cjs/index.js

@@ -2,4 +2,11 @@
 
 Object.defineProperty(exports, "__esModule", {
   value: true
-});
+});
+Object.defineProperty(exports, "listPlugin", {
+  enumerable: true,
+  get: function get() {
+    return _plugin.listPlugin;
+  }
+});
+var _plugin = require("./plugin");

package/dist/cjs/messages.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.messages = void 0;
+var _reactIntlNext = require("react-intl-next");
+// Common Translations will live here
+
+var messages = (0, _reactIntlNext.defineMessages)({
+  unorderedList: {
+    id: 'fabric.editor.unorderedList',
+    defaultMessage: 'Bullet list',
+    description: 'A list with bullets. Also known as an “unordered” list'
+  },
+  unorderedListDescription: {
+    id: 'fabric.editor.unorderedList.description',
+    defaultMessage: 'Create an unordered list',
+    description: ''
+  },
+  orderedList: {
+    id: 'fabric.editor.orderedList',
+    defaultMessage: 'Numbered list',
+    description: 'A list with ordered items 1… 2… 3…'
+  },
+  orderedListDescription: {
+    id: 'fabric.editor.orderedList.description',
+    defaultMessage: 'Create an ordered list',
+    description: ''
+  },
+  lists: {
+    id: 'fabric.editor.lists',
+    defaultMessage: 'Lists',
+    description: 'Menu shows ordered/bullet list and unordered/numbered lists'
+  }
+});
+exports.messages = messages;

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.listPlugin = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _adfSchema = require("@atlaskit/adf-schema");
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _keymaps = require("@atlaskit/editor-common/keymaps");
+var _messages = require("@atlaskit/editor-common/messages");
+var _quickInsert = require("@atlaskit/editor-common/quick-insert");
+var _commands = require("./commands");
+var _inputRules = _interopRequireDefault(require("./pm-plugins/input-rules"));
+var _keymap = _interopRequireDefault(require("./pm-plugins/keymap"));
+var _main = require("./pm-plugins/main");
+var _find = require("./utils/find");
+var _selection = require("./utils/selection");
+/*
+  Toolbar buttons to bullet and ordered list can be found in
+  packages/editor/editor-core/src/plugins/toolbar-lists-indentation/ui/Toolbar.tsx
+ */
+var listPlugin = function listPlugin(options, api) {
+  var _api$dependencies$ana;
+  var featureFlags = (api === null || api === void 0 ? void 0 : api.dependencies.featureFlags.sharedState.currentState()) || {};
+  var editorAnalyticsAPI = 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;
+  return {
+    name: 'list',
+    actions: {
+      indentList: (0, _commands.indentList)(editorAnalyticsAPI),
+      outdentList: (0, _commands.outdentList)(editorAnalyticsAPI),
+      toggleOrderedList: (0, _commands.toggleOrderedList)(editorAnalyticsAPI),
+      toggleBulletList: (0, _commands.toggleBulletList)(editorAnalyticsAPI),
+      isInsideListItem: _selection.isInsideListItem,
+      findRootParentListNode: _find.findRootParentListNode
+    },
+    getSharedState: function getSharedState(editorState) {
+      if (!editorState) {
+        return undefined;
+      }
+      return _main.pluginKey.getState(editorState);
+    },
+    nodes: function nodes() {
+      return [{
+        name: 'bulletList',
+        node: _adfSchema.bulletList
+      }, {
+        name: 'orderedList',
+        node: options !== null && options !== void 0 && options.restartNumberedLists ? _adfSchema.orderedListWithOrder : _adfSchema.orderedList
+      }, {
+        name: 'listItem',
+        node: _adfSchema.listItem
+      }];
+    },
+    pmPlugins: function pmPlugins() {
+      return [{
+        name: 'list',
+        plugin: function plugin(_ref) {
+          var dispatch = _ref.dispatch;
+          return (0, _main.createPlugin)(dispatch, featureFlags);
+        }
+      }, {
+        name: 'listInputRule',
+        plugin: function plugin(_ref2) {
+          var _api$dependencies$ana2;
+          var schema = _ref2.schema,
+            featureFlags = _ref2.featureFlags;
+          return (0, _inputRules.default)(schema, featureFlags, 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: 'listKeymap',
+        plugin: function plugin() {
+          var _api$dependencies$ana3;
+          return (0, _keymap.default)(featureFlags, 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);
+        }
+      }];
+    },
+    pluginsOptions: {
+      quickInsert: function quickInsert(_ref3) {
+        var formatMessage = _ref3.formatMessage;
+        return [{
+          id: 'unorderedList',
+          title: formatMessage(_messages.listMessages.unorderedList),
+          description: formatMessage(_messages.listMessages.unorderedListDescription),
+          keywords: ['ul', 'unordered'],
+          priority: 1100,
+          keyshortcut: (0, _keymaps.tooltip)(_keymaps.toggleBulletList),
+          icon: function icon() {
+            return /*#__PURE__*/_react.default.createElement(_quickInsert.IconList, null);
+          },
+          action: function action(insert, state) {
+            var tr = insert(state.schema.nodes.bulletList.createChecked({}, state.schema.nodes.listItem.createChecked({}, state.schema.nodes.paragraph.createChecked())));
+            editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+              action: _analytics.ACTION.INSERTED,
+              actionSubject: _analytics.ACTION_SUBJECT.LIST,
+              actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_LIST_BULLET,
+              eventType: _analytics.EVENT_TYPE.TRACK,
+              attributes: {
+                inputMethod: _analytics.INPUT_METHOD.QUICK_INSERT
+              }
+            })(tr);
+            return tr;
+          }
+        }, {
+          id: 'orderedList',
+          title: formatMessage(_messages.listMessages.orderedList),
+          description: formatMessage(_messages.listMessages.orderedListDescription),
+          keywords: ['ol', 'ordered'],
+          priority: 1200,
+          keyshortcut: (0, _keymaps.tooltip)(_keymaps.toggleOrderedList),
+          icon: function icon() {
+            return /*#__PURE__*/_react.default.createElement(_quickInsert.IconListNumber, null);
+          },
+          action: function action(insert, state) {
+            var tr = insert(state.schema.nodes.orderedList.createChecked({}, state.schema.nodes.listItem.createChecked({}, state.schema.nodes.paragraph.createChecked())));
+            editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+              action: _analytics.ACTION.INSERTED,
+              actionSubject: _analytics.ACTION_SUBJECT.LIST,
+              actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER,
+              eventType: _analytics.EVENT_TYPE.TRACK,
+              attributes: {
+                inputMethod: _analytics.INPUT_METHOD.QUICK_INSERT
+              }
+            })(tr);
+            return tr;
+          }
+        }];
+      }
+    }
+  };
+};
+exports.listPlugin = listPlugin;

package/dist/cjs/pm-plugins/input-rules/create-list-input-rule.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRuleForListType = createRuleForListType;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _utils = require("@atlaskit/editor-common/utils");
+var _wrappingJoinRule = require("./wrapping-join-rule");
+var getOrder = function getOrder(matchResult) {
+  return Number(matchResult[1]);
+};
+function createRuleForListType(_ref) {
+  var listType = _ref.listType,
+    expression = _ref.expression,
+    featureFlags = _ref.featureFlags,
+    editorAnalyticsApi = _ref.editorAnalyticsApi;
+  var joinScenario = _analytics.JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST.NO_JOIN;
+  var isBulletList = listType.name === 'bulletList';
+  var actionSubjectId = isBulletList ? _analytics.ACTION_SUBJECT_ID.FORMAT_LIST_BULLET : _analytics.ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER;
+  var getAnalyticsPayload = function getAnalyticsPayload(state, matchResult) {
+    var analyticsPayload = {
+      action: _analytics.ACTION.INSERTED,
+      actionSubject: _analytics.ACTION_SUBJECT.LIST,
+      actionSubjectId: actionSubjectId,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      attributes: {
+        inputMethod: _analytics.INPUT_METHOD.FORMATTING
+      }
+    };
+    if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists && listType === state.schema.nodes.orderedList && analyticsPayload.attributes) {
+      analyticsPayload.attributes.listStartNumber = getOrder(matchResult);
+      analyticsPayload.attributes.joinScenario = joinScenario;
+      // we reset the tracked joinScenario after storing it in the event payload
+      joinScenario = _analytics.JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST.NO_JOIN;
+    }
+    return analyticsPayload;
+  };
+  var joinToNeighbourIfSameListType = function joinToNeighbourIfSameListType(_, node, scenario) {
+    var shouldJoin = node.type === listType;
+    if (shouldJoin) {
+      joinScenario = scenario;
+    }
+    return shouldJoin;
+  };
+  var getAttrs = {};
+  if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getAttrs = function getAttrs(matchResult) {
+      return {
+        order: getOrder(matchResult)
+      };
+    };
+  }
+  var inputRule = (0, _wrappingJoinRule.createWrappingJoinRule)({
+    featureFlags: featureFlags,
+    match: expression,
+    nodeType: listType,
+    getAttrs: getAttrs,
+    joinPredicate: joinToNeighbourIfSameListType
+  });
+  return (0, _utils.inputRuleWithAnalytics)(getAnalyticsPayload, editorAnalyticsApi)(inputRule);
+}

package/dist/cjs/pm-plugins/input-rules/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inputRulePlugin;
+var _prosemirrorInputRules = require("@atlaskit/prosemirror-input-rules");
+var _createListInputRule = require("./create-list-input-rule");
+function inputRulePlugin(schema, featureFlags, editorAnalyticsApi) {
+  var _schema$nodes = schema.nodes,
+    bulletList = _schema$nodes.bulletList,
+    orderedList = _schema$nodes.orderedList;
+  var rules = [];
+  if (bulletList) {
+    rules.push((0, _createListInputRule.createRuleForListType)({
+      // Using UTF instead of • character
+      // because of issue where product converted the
+      // character into an escaped version.
+      expression: /^\s*([\*\-\u2022]) $/,
+      listType: bulletList,
+      featureFlags: featureFlags,
+      editorAnalyticsApi: editorAnalyticsApi
+    }));
+  }
+  var expression = featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists ? /((^[1-9]{1}[0-9]{0,2})|^(0))[\.\)] $/ : /^(1)[\.\)] $/;
+  if (orderedList) {
+    rules.push((0, _createListInputRule.createRuleForListType)({
+      expression: expression,
+      listType: orderedList,
+      featureFlags: featureFlags,
+      editorAnalyticsApi: editorAnalyticsApi
+    }));
+  }
+  if (rules.length !== 0) {
+    return (0, _prosemirrorInputRules.createPlugin)('lists', rules);
+  }
+  return;
+}