@atlaskit/editor-plugin-list 0.2.0 → 1.0.0

package/dist/esm/commands/listBackspace.js

@@ -0,0 +1,275 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var _BACKSPACE_COMMANDS;
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, DELETE_DIRECTION, EVENT_TYPE, INPUT_METHOD, LIST_TEXT_SCENARIOS } from '@atlaskit/editor-common/analytics';
+import { insertContentDeleteRange, isEmptySelectionAtStart, isListNode, isParagraphNode, walkPrevNode } from '@atlaskit/editor-common/utils';
+import { findParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
+import { isPosInsideList, isPosInsideParagraph } from '../utils/selection';
+//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);
+  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 = 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
+
+  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 = 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;
+  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 = {}, _defineProperty(_BACKSPACE_COMMANDS, LIST_TEXT_SCENARIOS.JOIN_SIBLINGS, listBackspaceCase2), _defineProperty(_BACKSPACE_COMMANDS, LIST_TEXT_SCENARIOS.JOIN_DESCENDANT_TO_PARENT, listBackspaceCase3), _defineProperty(_BACKSPACE_COMMANDS, LIST_TEXT_SCENARIOS.JOIN_TO_SIBLING_DESCENDANT, listBackspaceCase4), _BACKSPACE_COMMANDS);
+export var calcJoinListScenario = function calcJoinListScenario(walkNode, $head, tr) {
+  var $prev = walkNode.$pos,
+    prevFoundNode = walkNode.foundNode;
+  var prevInList = isPosInsideList($prev);
+  var headInParagraph = isPosInsideParagraph($head);
+  var headInFirstChild = $head.index(-1) === 0;
+  var headInList = 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 = isPosInsideParagraph($prev);
+  if (prevInParagraph) {
+    return [LIST_TEXT_SCENARIOS.JOIN_DESCENDANT_TO_PARENT, null];
+  }
+  var prevParentLastChildIsList = $prev.parent.lastChild && isListNode($prev.parent.lastChild);
+  var prevParentLastChildIsParagraph = 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 = walkPrevNode($last);
+    $last = _walkNode.$pos;
+    lastFoundNode = _walkNode.foundNode;
+  } while (lastFoundNode && !$last.parent.isTextblock);
+  var lastInParagraph = isPosInsideParagraph($last);
+  if (lastFoundNode && prevParentLastChildIsList && lastInParagraph) {
+    return [LIST_TEXT_SCENARIOS.JOIN_TO_SIBLING_DESCENDANT, $last];
+  } else if (prevParentLastChildIsParagraph) {
+    return [LIST_TEXT_SCENARIOS.JOIN_SIBLINGS, null];
+  }
+  return false;
+};
+export var listBackspace = function listBackspace(editorAnalyticsAPI) {
+  return function (state, dispatch) {
+    var tr = state.tr,
+      $head = state.selection.$head;
+    var walkNode = walkPrevNode($head);
+    if (!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 = findParentNodeOfType([bulletList, orderedList])(tr.selection);
+    var actionSubjectId = ACTION_SUBJECT_ID.FORMAT_LIST_BULLET;
+    if (listParent && listParent.node.type === orderedList) {
+      actionSubjectId = ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER;
+    }
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+      action: ACTION.LIST_ITEM_JOINED,
+      actionSubject: ACTION_SUBJECT.LIST,
+      actionSubjectId: actionSubjectId,
+      eventType: EVENT_TYPE.TRACK,
+      attributes: {
+        inputMethod: INPUT_METHOD.KEYBOARD,
+        direction: DELETE_DIRECTION.BACKWARD,
+        scenario: scenario[0]
+      }
+    })(tr);
+    return BACKSPACE_COMMANDS[scenario[0]](tr, dispatch, walkNode.$pos, $head, scenario[1]);
+  };
+};

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

@@ -0,0 +1,62 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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) { _defineProperty(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; }
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD, OUTDENT_SCENARIOS } from '@atlaskit/editor-common/analytics';
+import { getCommonListAnalyticsAttributes } from '@atlaskit/editor-common/lists';
+import { isBulletList } from '@atlaskit/editor-common/utils';
+import { closeHistory } from '@atlaskit/editor-prosemirror/history';
+import { outdentListItemsSelected as outdentListAction } from '../actions/outdent-list-items-selected';
+import { getRestartListsAttributes } from '../utils/analytics';
+import { findFirstParentListNode } from '../utils/find';
+import { isInsideListItem, isInsideTableCell } from '../utils/selection';
+export var outdentList = function outdentList(editorAnalyticsAPI) {
+  return function () {
+    var inputMethod = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : INPUT_METHOD.KEYBOARD;
+    var featureFlags = arguments.length > 1 ? arguments[1] : undefined;
+    return function (state, dispatch) {
+      if (!isInsideListItem(state)) {
+        return false;
+      }
+      var $from = state.selection.$from;
+      var parentListNode = 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
+      closeHistory(state.tr);
+      var actionSubjectId = isBulletList(parentListNode.node) ? ACTION_SUBJECT_ID.FORMAT_LIST_BULLET : ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER;
+      var customTr = state.tr;
+      outdentListAction(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 !isInsideTableCell(state);
+      }
+      var restartListsAttributes = {};
+      if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
+        var _getRestartListsAttri = getRestartListsAttributes(customTr),
+          outdentScenario = _getRestartListsAttri.outdentScenario,
+          splitListStartNumber = _getRestartListsAttri.splitListStartNumber;
+        if (outdentScenario === OUTDENT_SCENARIOS.SPLIT_LIST) {
+          restartListsAttributes.outdentScenario = outdentScenario;
+          restartListsAttributes.splitListStartNumber = splitListStartNumber;
+        }
+      }
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+        action: ACTION.OUTDENTED,
+        actionSubject: ACTION_SUBJECT.LIST,
+        actionSubjectId: actionSubjectId,
+        eventType: EVENT_TYPE.TRACK,
+        attributes: _objectSpread(_objectSpread(_objectSpread({}, getCommonListAnalyticsAttributes(state)), restartListsAttributes), {}, {
+          inputMethod: inputMethod
+        })
+      })(customTr);
+      if (dispatch) {
+        dispatch(customTr);
+      }
+      return true;
+    };
+  };
+};

package/dist/esm/index.js

@@ -1 +1 @@
-export {};
+export { listPlugin } from './plugin';

package/dist/esm/messages.js

@@ -0,0 +1,29 @@
+// Common Translations will live here
+import { defineMessages } from 'react-intl-next';
+export var messages = 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'
+  }
+});

package/dist/esm/plugin.js

@@ -0,0 +1,126 @@
+import React from 'react';
+import { bulletList, listItem, orderedList, orderedListWithOrder } from '@atlaskit/adf-schema';
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { toggleBulletList, toggleOrderedList, tooltip } from '@atlaskit/editor-common/keymaps';
+import { listMessages as messages } from '@atlaskit/editor-common/messages';
+import { IconList, IconListNumber } from '@atlaskit/editor-common/quick-insert';
+import { indentList, outdentList, toggleBulletList as toggleBulletListCommand, toggleOrderedList as toggleOrderedListCommand } from './commands';
+import inputRulePlugin from './pm-plugins/input-rules';
+import keymapPlugin from './pm-plugins/keymap';
+import { createPlugin, pluginKey as listPluginKey } from './pm-plugins/main';
+import { findRootParentListNode } from './utils/find';
+import { isInsideListItem } from './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
+ */
+export 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: indentList(editorAnalyticsAPI),
+      outdentList: outdentList(editorAnalyticsAPI),
+      toggleOrderedList: toggleOrderedListCommand(editorAnalyticsAPI),
+      toggleBulletList: toggleBulletListCommand(editorAnalyticsAPI),
+      isInsideListItem: isInsideListItem,
+      findRootParentListNode: findRootParentListNode
+    },
+    getSharedState: function getSharedState(editorState) {
+      if (!editorState) {
+        return undefined;
+      }
+      return listPluginKey.getState(editorState);
+    },
+    nodes: function nodes() {
+      return [{
+        name: 'bulletList',
+        node: bulletList
+      }, {
+        name: 'orderedList',
+        node: options !== null && options !== void 0 && options.restartNumberedLists ? orderedListWithOrder : orderedList
+      }, {
+        name: 'listItem',
+        node: listItem
+      }];
+    },
+    pmPlugins: function pmPlugins() {
+      return [{
+        name: 'list',
+        plugin: function plugin(_ref) {
+          var dispatch = _ref.dispatch;
+          return createPlugin(dispatch, featureFlags);
+        }
+      }, {
+        name: 'listInputRule',
+        plugin: function plugin(_ref2) {
+          var _api$dependencies$ana2;
+          var schema = _ref2.schema,
+            featureFlags = _ref2.featureFlags;
+          return inputRulePlugin(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 keymapPlugin(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.unorderedList),
+          description: formatMessage(messages.unorderedListDescription),
+          keywords: ['ul', 'unordered'],
+          priority: 1100,
+          keyshortcut: tooltip(toggleBulletList),
+          icon: function icon() {
+            return /*#__PURE__*/React.createElement(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: ACTION.INSERTED,
+              actionSubject: ACTION_SUBJECT.LIST,
+              actionSubjectId: ACTION_SUBJECT_ID.FORMAT_LIST_BULLET,
+              eventType: EVENT_TYPE.TRACK,
+              attributes: {
+                inputMethod: INPUT_METHOD.QUICK_INSERT
+              }
+            })(tr);
+            return tr;
+          }
+        }, {
+          id: 'orderedList',
+          title: formatMessage(messages.orderedList),
+          description: formatMessage(messages.orderedListDescription),
+          keywords: ['ol', 'ordered'],
+          priority: 1200,
+          keyshortcut: tooltip(toggleOrderedList),
+          icon: function icon() {
+            return /*#__PURE__*/React.createElement(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: ACTION.INSERTED,
+              actionSubject: ACTION_SUBJECT.LIST,
+              actionSubjectId: ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER,
+              eventType: EVENT_TYPE.TRACK,
+              attributes: {
+                inputMethod: INPUT_METHOD.QUICK_INSERT
+              }
+            })(tr);
+            return tr;
+          }
+        }];
+      }
+    }
+  };
+};

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

@@ -0,0 +1,57 @@
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD, JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST } from '@atlaskit/editor-common/analytics';
+import { inputRuleWithAnalytics as ruleWithAnalytics } from '@atlaskit/editor-common/utils';
+import { createWrappingJoinRule } from './wrapping-join-rule';
+var getOrder = function getOrder(matchResult) {
+  return Number(matchResult[1]);
+};
+export function createRuleForListType(_ref) {
+  var listType = _ref.listType,
+    expression = _ref.expression,
+    featureFlags = _ref.featureFlags,
+    editorAnalyticsApi = _ref.editorAnalyticsApi;
+  var joinScenario = JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST.NO_JOIN;
+  var isBulletList = listType.name === 'bulletList';
+  var actionSubjectId = isBulletList ? ACTION_SUBJECT_ID.FORMAT_LIST_BULLET : ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER;
+  var getAnalyticsPayload = function getAnalyticsPayload(state, matchResult) {
+    var analyticsPayload = {
+      action: ACTION.INSERTED,
+      actionSubject: ACTION_SUBJECT.LIST,
+      actionSubjectId: actionSubjectId,
+      eventType: EVENT_TYPE.TRACK,
+      attributes: {
+        inputMethod: 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 = 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 = createWrappingJoinRule({
+    featureFlags: featureFlags,
+    match: expression,
+    nodeType: listType,
+    getAttrs: getAttrs,
+    joinPredicate: joinToNeighbourIfSameListType
+  });
+  return ruleWithAnalytics(getAnalyticsPayload, editorAnalyticsApi)(inputRule);
+}

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

@@ -0,0 +1,32 @@
+import { createPlugin } from '@atlaskit/prosemirror-input-rules';
+import { createRuleForListType } from './create-list-input-rule';
+export default function inputRulePlugin(schema, featureFlags, editorAnalyticsApi) {
+  var _schema$nodes = schema.nodes,
+    bulletList = _schema$nodes.bulletList,
+    orderedList = _schema$nodes.orderedList;
+  var rules = [];
+  if (bulletList) {
+    rules.push(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(createRuleForListType({
+      expression: expression,
+      listType: orderedList,
+      featureFlags: featureFlags,
+      editorAnalyticsApi: editorAnalyticsApi
+    }));
+  }
+  if (rules.length !== 0) {
+    return createPlugin('lists', rules);
+  }
+  return;
+}

package/dist/esm/pm-plugins/input-rules/wrapping-join-rule.js

@@ -0,0 +1,54 @@
+import { JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST } from '@atlaskit/editor-common/analytics';
+import { canJoin, findWrapping } from '@atlaskit/editor-prosemirror/transform';
+import { findParentNodeOfTypeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
+import { createRule } from '@atlaskit/prosemirror-input-rules';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+export var createWrappingJoinRule = function createWrappingJoinRule(_ref) {
+  var match = _ref.match,
+    nodeType = _ref.nodeType,
+    getAttrs = _ref.getAttrs,
+    joinPredicate = _ref.joinPredicate,
+    featureFlags = _ref.featureFlags;
+  var handler = function handler(state, match, start, end) {
+    var attrs = (getAttrs instanceof Function ? getAttrs(match) : getAttrs) || {};
+    var tr = state.tr;
+    var fixedStart = Math.max(start, 1);
+    tr.delete(fixedStart, end);
+    var $start = tr.doc.resolve(fixedStart);
+    var range = $start.blockRange();
+    var wrapping = range && findWrapping(range, nodeType, attrs);
+    if (!wrapping || !range) {
+      return null;
+    }
+    var parentNodePosMapped = tr.mapping.map(range.start);
+    var parentNode = tr.doc.nodeAt(parentNodePosMapped);
+    var lastWrap = wrapping[wrapping.length - 1];
+    if (parentNode && lastWrap) {
+      var allowedMarks = lastWrap.type.allowedMarks(parentNode.marks) || [];
+      tr.setNodeMarkup(parentNodePosMapped, parentNode.type, parentNode.attrs, allowedMarks);
+    }
+    tr.wrap(range, wrapping);
+    if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists && nodeType === state.schema.nodes.orderedList) {
+      // if an orderedList node would be inserted by the input rule match, and
+      // that orderedList node is being added directly before another orderedList
+      // node, then join those nodes
+      var $end = tr.doc.resolve(tr.mapping.map(end));
+      var _node = findParentNodeOfTypeClosestToPos($end, nodeType);
+      if (_node) {
+        var nodeEnd = _node.pos + _node.node.nodeSize;
+        var after = tr.doc.resolve(nodeEnd).nodeAfter;
+        if (after && after.type === nodeType && canJoin(tr.doc, nodeEnd) && (!joinPredicate || joinPredicate(match, after, JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST.JOINED_TO_LIST_BELOW))) {
+          tr.join(nodeEnd);
+        }
+      }
+    }
+    var before = tr.doc.resolve(fixedStart - 1).nodeBefore;
+    if (before && before.type === nodeType && canJoin(tr.doc, fixedStart - 1) && (!joinPredicate || joinPredicate(match, before, JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST.JOINED_TO_LIST_ABOVE))) {
+      tr.join(fixedStart - 1);
+    }
+    return tr;
+  };
+  return createRule(match, handler);
+};

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

@@ -0,0 +1,19 @@
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { backspace, bindKeymapWithCommand, deleteKey, enter, findKeyMapForBrowser, findShortcutByKeymap, forwardDelete, indentList, outdentList, toggleBulletList, toggleOrderedList } from '@atlaskit/editor-common/keymaps';
+import { keymap } from '@atlaskit/editor-prosemirror/keymap';
+import { backspaceKeyCommand, deleteKeyCommand, enterKeyCommand, indentList as indentListCommand, outdentList as outdentListCommand, toggleList } from '../commands';
+export function keymapPlugin(featureFlags, editorAnalyticsAPI) {
+  var list = {};
+  bindKeymapWithCommand(findShortcutByKeymap(toggleOrderedList), toggleList(editorAnalyticsAPI)(INPUT_METHOD.KEYBOARD, 'orderedList'), list);
+  bindKeymapWithCommand(findShortcutByKeymap(toggleBulletList), toggleList(editorAnalyticsAPI)(INPUT_METHOD.KEYBOARD, 'bulletList'), list);
+  bindKeymapWithCommand(indentList.common, indentListCommand(editorAnalyticsAPI)(INPUT_METHOD.KEYBOARD), list);
+  bindKeymapWithCommand(outdentList.common, outdentListCommand(editorAnalyticsAPI)(INPUT_METHOD.KEYBOARD, featureFlags), list);
+  bindKeymapWithCommand(enter.common, enterKeyCommand(editorAnalyticsAPI)(featureFlags), list);
+  bindKeymapWithCommand(backspace.common, backspaceKeyCommand(editorAnalyticsAPI)(featureFlags), list);
+  bindKeymapWithCommand(deleteKey.common, deleteKeyCommand(editorAnalyticsAPI), list);
+
+  // This shortcut is Mac only
+  bindKeymapWithCommand(findKeyMapForBrowser(forwardDelete), deleteKeyCommand(editorAnalyticsAPI), list);
+  return keymap(list);
+}
+export default keymapPlugin;