@atlaskit/editor-plugin-list 0.2.0 → 1.0.0

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

@@ -0,0 +1,60 @@
+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 const outdentList = editorAnalyticsAPI => (inputMethod = INPUT_METHOD.KEYBOARD, featureFlags) => {
+  return function (state, dispatch) {
+    if (!isInsideListItem(state)) {
+      return false;
+    }
+    const {
+      $from
+    } = state.selection;
+    const 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);
+    const actionSubjectId = isBulletList(parentListNode.node) ? ACTION_SUBJECT_ID.FORMAT_LIST_BULLET : ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER;
+    let 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);
+    }
+    const restartListsAttributes = {};
+    if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
+      const {
+        outdentScenario,
+        splitListStartNumber
+      } = getRestartListsAttributes(customTr);
+      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,
+      eventType: EVENT_TYPE.TRACK,
+      attributes: {
+        ...getCommonListAnalyticsAttributes(state),
+        ...restartListsAttributes,
+        inputMethod
+      }
+    })(customTr);
+    if (dispatch) {
+      dispatch(customTr);
+    }
+    return true;
+  };
+};

package/dist/es2019/index.js

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

package/dist/es2019/messages.js

@@ -0,0 +1,29 @@
+// Common Translations will live here
+import { defineMessages } from 'react-intl-next';
+export const 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/es2019/plugin.js

@@ -0,0 +1,121 @@
+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 const listPlugin = (options, api) => {
+  var _api$dependencies$ana;
+  const featureFlags = (api === null || api === void 0 ? void 0 : api.dependencies.featureFlags.sharedState.currentState()) || {};
+  const 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,
+      findRootParentListNode
+    },
+    getSharedState: editorState => {
+      if (!editorState) {
+        return undefined;
+      }
+      return listPluginKey.getState(editorState);
+    },
+    nodes() {
+      return [{
+        name: 'bulletList',
+        node: bulletList
+      }, {
+        name: 'orderedList',
+        node: options !== null && options !== void 0 && options.restartNumberedLists ? orderedListWithOrder : orderedList
+      }, {
+        name: 'listItem',
+        node: listItem
+      }];
+    },
+    pmPlugins() {
+      return [{
+        name: 'list',
+        plugin: ({
+          dispatch
+        }) => createPlugin(dispatch, featureFlags)
+      }, {
+        name: 'listInputRule',
+        plugin: ({
+          schema,
+          featureFlags
+        }) => {
+          var _api$dependencies$ana2;
+          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: () => {
+          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: ({
+        formatMessage
+      }) => [{
+        id: 'unorderedList',
+        title: formatMessage(messages.unorderedList),
+        description: formatMessage(messages.unorderedListDescription),
+        keywords: ['ul', 'unordered'],
+        priority: 1100,
+        keyshortcut: tooltip(toggleBulletList),
+        icon: () => /*#__PURE__*/React.createElement(IconList, null),
+        action(insert, state) {
+          const 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: () => /*#__PURE__*/React.createElement(IconListNumber, null),
+        action(insert, state) {
+          const 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/es2019/pm-plugins/input-rules/create-list-input-rule.js

@@ -0,0 +1,56 @@
+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';
+const getOrder = matchResult => Number(matchResult[1]);
+export function createRuleForListType({
+  listType,
+  expression,
+  featureFlags,
+  editorAnalyticsApi
+}) {
+  let joinScenario = JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST.NO_JOIN;
+  const isBulletList = listType.name === 'bulletList';
+  const actionSubjectId = isBulletList ? ACTION_SUBJECT_ID.FORMAT_LIST_BULLET : ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER;
+  const getAnalyticsPayload = (state, matchResult) => {
+    const analyticsPayload = {
+      action: ACTION.INSERTED,
+      actionSubject: ACTION_SUBJECT.LIST,
+      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;
+  };
+  const joinToNeighbourIfSameListType = (_, node, scenario) => {
+    const shouldJoin = node.type === listType;
+    if (shouldJoin) {
+      joinScenario = scenario;
+    }
+    return shouldJoin;
+  };
+  let getAttrs = {};
+  if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getAttrs = matchResult => {
+      return {
+        order: getOrder(matchResult)
+      };
+    };
+  }
+  const inputRule = createWrappingJoinRule({
+    featureFlags,
+    match: expression,
+    nodeType: listType,
+    getAttrs,
+    joinPredicate: joinToNeighbourIfSameListType
+  });
+  return ruleWithAnalytics(getAnalyticsPayload, editorAnalyticsApi)(inputRule);
+}

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

@@ -0,0 +1,35 @@
+import { createPlugin } from '@atlaskit/prosemirror-input-rules';
+import { createRuleForListType } from './create-list-input-rule';
+export default function inputRulePlugin(schema, featureFlags, editorAnalyticsApi) {
+  const {
+    nodes: {
+      bulletList,
+      orderedList
+    }
+  } = schema;
+  const 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,
+      editorAnalyticsApi
+    }));
+  }
+  const expression = featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists ? /((^[1-9]{1}[0-9]{0,2})|^(0))[\.\)] $/ : /^(1)[\.\)] $/;
+  if (orderedList) {
+    rules.push(createRuleForListType({
+      expression,
+      listType: orderedList,
+      featureFlags,
+      editorAnalyticsApi
+    }));
+  }
+  if (rules.length !== 0) {
+    return createPlugin('lists', rules);
+  }
+  return;
+}

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

@@ -0,0 +1,55 @@
+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 const createWrappingJoinRule = ({
+  match,
+  nodeType,
+  getAttrs,
+  joinPredicate,
+  featureFlags
+}) => {
+  const handler = (state, match, start, end) => {
+    const attrs = (getAttrs instanceof Function ? getAttrs(match) : getAttrs) || {};
+    const tr = state.tr;
+    const fixedStart = Math.max(start, 1);
+    tr.delete(fixedStart, end);
+    const $start = tr.doc.resolve(fixedStart);
+    const range = $start.blockRange();
+    const wrapping = range && findWrapping(range, nodeType, attrs);
+    if (!wrapping || !range) {
+      return null;
+    }
+    const parentNodePosMapped = tr.mapping.map(range.start);
+    const parentNode = tr.doc.nodeAt(parentNodePosMapped);
+    const lastWrap = wrapping[wrapping.length - 1];
+    if (parentNode && lastWrap) {
+      const 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
+      const $end = tr.doc.resolve(tr.mapping.map(end));
+      const node = findParentNodeOfTypeClosestToPos($end, nodeType);
+      if (node) {
+        const nodeEnd = node.pos + node.node.nodeSize;
+        const 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);
+        }
+      }
+    }
+    const 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/es2019/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) {
+  const 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;

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

@@ -0,0 +1,156 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { setGapCursorSelection, Side } from '@atlaskit/editor-common/selection';
+import { CodeBlockSharedCssClassName, getOrderedListInlineStyles, listItemCounterPadding } from '@atlaskit/editor-common/styles';
+import { getItemCounterDigitsSize, isListNode, pluginFactory } from '@atlaskit/editor-common/utils';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import { findParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
+import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { isWrappingPossible } from '../utils/selection';
+const listPluginKey = new PluginKey('listPlugin');
+export const pluginKey = listPluginKey;
+const initialState = {
+  bulletListActive: false,
+  bulletListDisabled: false,
+  orderedListActive: false,
+  orderedListDisabled: false,
+  decorationSet: DecorationSet.empty
+};
+export const getDecorations = (doc, state, featureFlags) => {
+  const decorations = [];
+
+  // this stack keeps track of each (nested) list to calculate the indentation level
+  const processedListsStack = [];
+  doc.nodesBetween(0, doc.content.size, (node, currentNodeStartPos) => {
+    if (processedListsStack.length > 0) {
+      let isOutsideLastList = true;
+      while (isOutsideLastList && processedListsStack.length > 0) {
+        const lastList = processedListsStack[processedListsStack.length - 1];
+        const lastListEndPos = lastList.startPos + lastList.node.nodeSize;
+        isOutsideLastList = currentNodeStartPos >= lastListEndPos;
+        // once we finish iterating over each innermost list, pop the stack to
+        // decrease the indent level attribute accordingly
+        if (isOutsideLastList) {
+          processedListsStack.pop();
+        }
+      }
+    }
+    if (isListNode(node)) {
+      processedListsStack.push({
+        node,
+        startPos: currentNodeStartPos
+      });
+      const from = currentNodeStartPos;
+      const to = currentNodeStartPos + node.nodeSize;
+      const depth = processedListsStack.length;
+      decorations.push(Decoration.node(from, to, {
+        'data-indent-level': `${depth}`
+      }));
+      if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
+        var _node$attrs;
+        // If a numbered list has item counters numbering >= 100, we'll need to add special
+        // spacing to account for the extra digit chars
+        const digitsSize = getItemCounterDigitsSize({
+          itemsCount: node === null || node === void 0 ? void 0 : node.childCount,
+          order: node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.order
+        });
+        if (digitsSize) {
+          decorations.push(Decoration.node(from, to, {
+            style: getOrderedListInlineStyles(digitsSize, 'string')
+          }));
+        }
+      } else {
+        if (node.childCount >= 100) {
+          decorations.push(Decoration.node(from, to, {
+            'data-child-count': '100+'
+          }));
+        }
+      }
+    }
+  });
+  return DecorationSet.empty.add(doc, decorations);
+};
+const handleDocChanged = featureFlags => (tr, pluginState, editorState) => {
+  const nextPluginState = handleSelectionChanged(tr, pluginState);
+  const decorationSet = getDecorations(tr.doc, editorState, featureFlags);
+  return {
+    ...nextPluginState,
+    decorationSet
+  };
+};
+const handleSelectionChanged = (tr, pluginState) => {
+  const {
+    bulletList,
+    orderedList
+  } = tr.doc.type.schema.nodes;
+  const listParent = findParentNodeOfType([bulletList, orderedList])(tr.selection);
+  const bulletListActive = !!listParent && listParent.node.type === bulletList;
+  const orderedListActive = !!listParent && listParent.node.type === orderedList;
+  const bulletListDisabled = !(bulletListActive || orderedListActive || isWrappingPossible(bulletList, tr.selection));
+  const orderedListDisabled = !(bulletListActive || orderedListActive || isWrappingPossible(orderedList, tr.selection));
+  if (bulletListActive !== pluginState.bulletListActive || orderedListActive !== pluginState.orderedListActive || bulletListDisabled !== pluginState.bulletListDisabled || orderedListDisabled !== pluginState.orderedListDisabled) {
+    const nextPluginState = {
+      ...pluginState,
+      bulletListActive,
+      orderedListActive,
+      bulletListDisabled,
+      orderedListDisabled
+    };
+    return nextPluginState;
+  }
+  return pluginState;
+};
+const reducer = () => state => {
+  return state;
+};
+const createInitialState = featureFlags => state => {
+  return {
+    ...initialState,
+    decorationSet: getDecorations(state.doc, state, featureFlags)
+  };
+};
+export const createPlugin = (eventDispatch, featureFlags) => {
+  const {
+    getPluginState,
+    createPluginState
+  } = pluginFactory(listPluginKey, reducer(), {
+    onDocChanged: handleDocChanged(featureFlags),
+    onSelectionChanged: handleSelectionChanged
+  });
+  return new SafePlugin({
+    state: createPluginState(eventDispatch, createInitialState(featureFlags)),
+    key: listPluginKey,
+    props: {
+      decorations(state) {
+        const {
+          decorationSet
+        } = getPluginState(state);
+        return decorationSet;
+      },
+      handleClick: (view, pos, event) => {
+        const {
+          state
+        } = view;
+        if (['LI', 'UL'].includes((event === null || event === void 0 ? void 0 : event.target).tagName)) {
+          var _nodeAtPos$firstChild;
+          const nodeAtPos = state.tr.doc.nodeAt(pos);
+          const {
+            listItem,
+            codeBlock
+          } = view.state.schema.nodes;
+          if ((nodeAtPos === null || nodeAtPos === void 0 ? void 0 : nodeAtPos.type) === listItem && (nodeAtPos === null || nodeAtPos === void 0 ? void 0 : (_nodeAtPos$firstChild = nodeAtPos.firstChild) === null || _nodeAtPos$firstChild === void 0 ? void 0 : _nodeAtPos$firstChild.type) === codeBlock) {
+            var _document, _document$elementFrom;
+            const bufferPx = 50;
+            const isCodeBlockNextToListMarker = Boolean((_document = document) === null || _document === void 0 ? void 0 : (_document$elementFrom = _document.elementFromPoint(event.clientX + (listItemCounterPadding + bufferPx), event.clientY)) === null || _document$elementFrom === void 0 ? void 0 : _document$elementFrom.closest(`.${CodeBlockSharedCssClassName.CODEBLOCK_CONTAINER}`));
+            if (isCodeBlockNextToListMarker) {
+              // +1 needed to put cursor inside li
+              // otherwise gap cursor markup will be injected as immediate child of ul resulting in invalid html
+              setGapCursorSelection(view, pos + 1, Side.LEFT);
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+    }
+  });
+};

package/dist/es2019/transforms.js

@@ -0,0 +1,101 @@
+import { Fragment, NodeRange, Slice } from '@atlaskit/editor-prosemirror/model';
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { liftTarget, ReplaceAroundStep } from '@atlaskit/editor-prosemirror/transform';
+import { getListLiftTarget } from './utils/indentation';
+function liftListItem(selection, tr) {
+  let {
+    $from,
+    $to
+  } = selection;
+  const nodeType = tr.doc.type.schema.nodes.listItem;
+  let range = $from.blockRange($to, node => !!node.childCount && !!node.firstChild && node.firstChild.type === nodeType);
+  if (!range || range.depth < 2 || $from.node(range.depth - 1).type !== nodeType) {
+    return tr;
+  }
+  let end = range.end;
+  let endOfList = $to.end(range.depth);
+  if (end < endOfList) {
+    tr.step(new ReplaceAroundStep(end - 1, endOfList, end, endOfList, new Slice(Fragment.from(nodeType.create(undefined, range.parent.copy())), 1, 0), 1, true));
+    range = new NodeRange(tr.doc.resolve($from.pos), tr.doc.resolve(endOfList), range.depth);
+  }
+  return tr.lift(range, liftTarget(range)).scrollIntoView();
+}
+
+// Function will lift list item following selection to level-1.
+export function liftFollowingList(from, to, rootListDepth, tr) {
+  const {
+    listItem
+  } = tr.doc.type.schema.nodes;
+  let lifted = false;
+  tr.doc.nodesBetween(from, to, (node, pos) => {
+    if (!lifted && node.type === listItem && pos > from) {
+      lifted = true;
+      let listDepth = rootListDepth + 3;
+      while (listDepth > rootListDepth + 2) {
+        const start = tr.doc.resolve(tr.mapping.map(pos));
+        listDepth = start.depth;
+        const end = tr.doc.resolve(tr.mapping.map(pos + node.textContent.length));
+        const sel = new TextSelection(start, end);
+        tr = liftListItem(sel, tr);
+      }
+    }
+  });
+  return tr;
+}
+export function liftNodeSelectionList(selection, tr) {
+  const {
+    from
+  } = selection;
+  const {
+    listItem
+  } = tr.doc.type.schema.nodes;
+  const mappedPosition = tr.mapping.map(from);
+  const nodeAtPos = tr.doc.nodeAt(mappedPosition);
+  const start = tr.doc.resolve(mappedPosition);
+  if ((start === null || start === void 0 ? void 0 : start.parent.type) !== listItem) {
+    return tr;
+  }
+  const end = tr.doc.resolve(mappedPosition + ((nodeAtPos === null || nodeAtPos === void 0 ? void 0 : nodeAtPos.nodeSize) || 1));
+  const range = start.blockRange(end);
+  if (range) {
+    const liftTarget = getListLiftTarget(start);
+    tr.lift(range, liftTarget);
+  }
+  return tr;
+}
+// The function will list paragraphs in selection out to level 1 below root list.
+export function liftTextSelectionList(selection, tr) {
+  const {
+    from,
+    to
+  } = selection;
+  const {
+    paragraph
+  } = tr.doc.type.schema.nodes;
+  const listCol = [];
+  tr.doc.nodesBetween(from, to, (node, pos) => {
+    if (node.type === paragraph) {
+      listCol.push({
+        node,
+        pos
+      });
+    }
+  });
+  for (let i = listCol.length - 1; i >= 0; i--) {
+    const paragraph = listCol[i];
+    const start = tr.doc.resolve(tr.mapping.map(paragraph.pos));
+    if (start.depth > 0) {
+      let end;
+      if (paragraph.node.textContent && paragraph.node.textContent.length > 0) {
+        end = tr.doc.resolve(tr.mapping.map(paragraph.pos + paragraph.node.textContent.length));
+      } else {
+        end = tr.doc.resolve(tr.mapping.map(paragraph.pos + 1));
+      }
+      const range = start.blockRange(end);
+      if (range) {
+        tr.lift(range, getListLiftTarget(start));
+      }
+    }
+  }
+  return tr;
+}

package/dist/es2019/types.js

@@ -1 +1 @@
-export {};
+export const MAX_NESTED_LIST_INDENTATION = 6;

package/dist/es2019/utils/analytics.js

@@ -0,0 +1,12 @@
+export const RESTART_LISTS_ANALYTICS_KEY = 'restartListsAnalytics';
+export const getRestartListsAttributes = tr => {
+  var _tr$getMeta;
+  return (_tr$getMeta = tr.getMeta(RESTART_LISTS_ANALYTICS_KEY)) !== null && _tr$getMeta !== void 0 ? _tr$getMeta : {};
+};
+export const storeRestartListsAttributes = (tr, attributes) => {
+  const meta = getRestartListsAttributes(tr);
+  tr.setMeta(RESTART_LISTS_ANALYTICS_KEY, {
+    ...meta,
+    ...attributes
+  });
+};