@atlaskit/editor-plugin-list 0.2.0 → 1.0.0

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

@@ -0,0 +1,156 @@
+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 { 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';
+var listPluginKey = new PluginKey('listPlugin');
+export var pluginKey = listPluginKey;
+var initialState = {
+  bulletListActive: false,
+  bulletListDisabled: false,
+  orderedListActive: false,
+  orderedListDisabled: false,
+  decorationSet: DecorationSet.empty
+};
+export var getDecorations = function getDecorations(doc, state, featureFlags) {
+  var decorations = [];
+
+  // this stack keeps track of each (nested) list to calculate the indentation level
+  var processedListsStack = [];
+  doc.nodesBetween(0, doc.content.size, function (node, currentNodeStartPos) {
+    if (processedListsStack.length > 0) {
+      var isOutsideLastList = true;
+      while (isOutsideLastList && processedListsStack.length > 0) {
+        var lastList = processedListsStack[processedListsStack.length - 1];
+        var 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: node,
+        startPos: currentNodeStartPos
+      });
+      var from = currentNodeStartPos;
+      var to = currentNodeStartPos + node.nodeSize;
+      var depth = processedListsStack.length;
+      decorations.push(Decoration.node(from, to, {
+        'data-indent-level': "".concat(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
+        var 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);
+};
+var handleDocChanged = function handleDocChanged(featureFlags) {
+  return function (tr, pluginState, editorState) {
+    var nextPluginState = handleSelectionChanged(tr, pluginState);
+    var decorationSet = getDecorations(tr.doc, editorState, featureFlags);
+    return _objectSpread(_objectSpread({}, nextPluginState), {}, {
+      decorationSet: decorationSet
+    });
+  };
+};
+var handleSelectionChanged = function handleSelectionChanged(tr, pluginState) {
+  var _tr$doc$type$schema$n = tr.doc.type.schema.nodes,
+    bulletList = _tr$doc$type$schema$n.bulletList,
+    orderedList = _tr$doc$type$schema$n.orderedList;
+  var listParent = findParentNodeOfType([bulletList, orderedList])(tr.selection);
+  var bulletListActive = !!listParent && listParent.node.type === bulletList;
+  var orderedListActive = !!listParent && listParent.node.type === orderedList;
+  var bulletListDisabled = !(bulletListActive || orderedListActive || isWrappingPossible(bulletList, tr.selection));
+  var orderedListDisabled = !(bulletListActive || orderedListActive || isWrappingPossible(orderedList, tr.selection));
+  if (bulletListActive !== pluginState.bulletListActive || orderedListActive !== pluginState.orderedListActive || bulletListDisabled !== pluginState.bulletListDisabled || orderedListDisabled !== pluginState.orderedListDisabled) {
+    var nextPluginState = _objectSpread(_objectSpread({}, pluginState), {}, {
+      bulletListActive: bulletListActive,
+      orderedListActive: orderedListActive,
+      bulletListDisabled: bulletListDisabled,
+      orderedListDisabled: orderedListDisabled
+    });
+    return nextPluginState;
+  }
+  return pluginState;
+};
+var reducer = function reducer() {
+  return function (state) {
+    return state;
+  };
+};
+var createInitialState = function createInitialState(featureFlags) {
+  return function (state) {
+    return _objectSpread(_objectSpread({}, initialState), {}, {
+      decorationSet: getDecorations(state.doc, state, featureFlags)
+    });
+  };
+};
+export var createPlugin = function createPlugin(eventDispatch, featureFlags) {
+  var _pluginFactory = pluginFactory(listPluginKey, reducer(), {
+      onDocChanged: handleDocChanged(featureFlags),
+      onSelectionChanged: handleSelectionChanged
+    }),
+    getPluginState = _pluginFactory.getPluginState,
+    createPluginState = _pluginFactory.createPluginState;
+  return new SafePlugin({
+    state: createPluginState(eventDispatch, createInitialState(featureFlags)),
+    key: listPluginKey,
+    props: {
+      decorations: function decorations(state) {
+        var _getPluginState = getPluginState(state),
+          decorationSet = _getPluginState.decorationSet;
+        return decorationSet;
+      },
+      handleClick: function handleClick(view, pos, event) {
+        var state = view.state;
+        if (['LI', 'UL'].includes((event === null || event === void 0 ? void 0 : event.target).tagName)) {
+          var _nodeAtPos$firstChild;
+          var nodeAtPos = state.tr.doc.nodeAt(pos);
+          var _view$state$schema$no = view.state.schema.nodes,
+            listItem = _view$state$schema$no.listItem,
+            codeBlock = _view$state$schema$no.codeBlock;
+          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;
+            var bufferPx = 50;
+            var 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(".".concat(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/esm/transforms.js

@@ -0,0 +1,91 @@
+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) {
+  var $from = selection.$from,
+    $to = selection.$to;
+  var nodeType = tr.doc.type.schema.nodes.listItem;
+  var range = $from.blockRange($to, function (node) {
+    return !!node.childCount && !!node.firstChild && node.firstChild.type === nodeType;
+  });
+  if (!range || range.depth < 2 || $from.node(range.depth - 1).type !== nodeType) {
+    return tr;
+  }
+  var end = range.end;
+  var 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) {
+  var listItem = tr.doc.type.schema.nodes.listItem;
+  var lifted = false;
+  tr.doc.nodesBetween(from, to, function (node, pos) {
+    if (!lifted && node.type === listItem && pos > from) {
+      lifted = true;
+      var listDepth = rootListDepth + 3;
+      while (listDepth > rootListDepth + 2) {
+        var start = tr.doc.resolve(tr.mapping.map(pos));
+        listDepth = start.depth;
+        var end = tr.doc.resolve(tr.mapping.map(pos + node.textContent.length));
+        var sel = new TextSelection(start, end);
+        tr = liftListItem(sel, tr);
+      }
+    }
+  });
+  return tr;
+}
+export function liftNodeSelectionList(selection, tr) {
+  var from = selection.from;
+  var listItem = tr.doc.type.schema.nodes.listItem;
+  var mappedPosition = tr.mapping.map(from);
+  var nodeAtPos = tr.doc.nodeAt(mappedPosition);
+  var start = tr.doc.resolve(mappedPosition);
+  if ((start === null || start === void 0 ? void 0 : start.parent.type) !== listItem) {
+    return tr;
+  }
+  var end = tr.doc.resolve(mappedPosition + ((nodeAtPos === null || nodeAtPos === void 0 ? void 0 : nodeAtPos.nodeSize) || 1));
+  var range = start.blockRange(end);
+  if (range) {
+    var _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) {
+  var from = selection.from,
+    to = selection.to;
+  var paragraph = tr.doc.type.schema.nodes.paragraph;
+  var listCol = [];
+  tr.doc.nodesBetween(from, to, function (node, pos) {
+    if (node.type === paragraph) {
+      listCol.push({
+        node: node,
+        pos: pos
+      });
+    }
+  });
+  for (var i = listCol.length - 1; i >= 0; i--) {
+    var _paragraph = listCol[i];
+    var start = tr.doc.resolve(tr.mapping.map(_paragraph.pos));
+    if (start.depth > 0) {
+      var end = void 0;
+      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));
+      }
+      var range = start.blockRange(end);
+      if (range) {
+        tr.lift(range, getListLiftTarget(start));
+      }
+    }
+  }
+  return tr;
+}

package/dist/esm/types.js

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

package/dist/esm/utils/analytics.js

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

package/dist/esm/utils/find.js

@@ -0,0 +1,59 @@
+import { isListItemNode, isListNode } from '@atlaskit/editor-common/utils';
+import { findParentNodeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
+export function findFirstParentListNode($pos) {
+  var currentNode = $pos.doc.nodeAt($pos.pos);
+  var listNodePosition = null;
+  if (isListNode(currentNode)) {
+    listNodePosition = $pos.pos;
+  } else {
+    var result = findParentNodeClosestToPos($pos, isListNode);
+    listNodePosition = result && result.pos;
+  }
+  if (listNodePosition == null) {
+    return null;
+  }
+  var node = $pos.doc.nodeAt(listNodePosition);
+  if (!node) {
+    return null;
+  }
+  return {
+    node: node,
+    pos: listNodePosition
+  };
+}
+export function findFirstParentListItemNode($pos) {
+  var currentNode = $pos.doc.nodeAt($pos.pos);
+  var listItemNodePosition = isListItemNode(currentNode) ? $pos : findParentNodeClosestToPos($pos, isListItemNode);
+  if (!listItemNodePosition || listItemNodePosition.pos === null) {
+    return null;
+  }
+  var node = $pos.doc.nodeAt(listItemNodePosition.pos);
+  if (!node) {
+    return null;
+  }
+  return {
+    node: node,
+    pos: listItemNodePosition.pos
+  };
+}
+export var findRootParentListNode = function findRootParentListNode($pos) {
+  var doc = $pos.doc;
+  if ($pos.pos + 1 > doc.content.size) {
+    return null;
+  }
+  if ($pos.depth === 0) {
+    return doc.resolve($pos.pos + 1);
+  }
+  var currentNode = doc.nodeAt($pos.pos);
+  var beforePosition = $pos.before();
+  var nodeBefore = doc.nodeAt(beforePosition);
+  if (isListNode(currentNode) && !isListItemNode(nodeBefore)) {
+    return doc.resolve($pos.pos + 1);
+  }
+  var parentList = findParentNodeClosestToPos($pos, isListNode);
+  if (!parentList) {
+    return null;
+  }
+  var listNodePosition = doc.resolve(parentList.pos);
+  return findRootParentListNode(listNodePosition);
+};

package/dist/esm/utils/indentation.js

@@ -0,0 +1,15 @@
+import { isListItemNode, isListNode } from '@atlaskit/editor-common/utils';
+// This will return (depth - 1) for root list parent of a list.
+export var getListLiftTarget = function getListLiftTarget(resPos) {
+  var target = resPos.depth;
+  for (var i = resPos.depth; i > 0; i--) {
+    var node = resPos.node(i);
+    if (isListNode(node)) {
+      target = i;
+    }
+    if (!isListItemNode(node) && !isListNode(node)) {
+      break;
+    }
+  }
+  return target - 1;
+};

package/dist/esm/utils/mark.js

@@ -0,0 +1,33 @@
+export var sanitiseMarksInSelection = function sanitiseMarksInSelection(tr, newParentType) {
+  var _tr$selection = tr.selection,
+    from = _tr$selection.from,
+    to = _tr$selection.to;
+  var nodesSanitized = [];
+  tr.doc.nodesBetween(from, to, function (node, pos, parent) {
+    if (node.isText) {
+      return false;
+    }
+    // Skip expands and layouts if they are outside selection
+    // but continue to iterate over their children.
+    if (['expand', 'layoutSection'].includes(node.type.name) && (pos < from || pos > to)) {
+      return true;
+    }
+    node.marks.forEach(function (mark) {
+      if (!(parent !== null && parent !== void 0 && parent.type.allowsMarkType(mark.type)) || newParentType && !newParentType.allowsMarkType(mark.type)) {
+        var filteredMarks = node.marks.filter(function (m) {
+          return m.type !== mark.type;
+        });
+        var position = pos > 0 ? pos : 0;
+        var marksRemoved = node.marks.filter(function (m) {
+          return m.type === mark.type;
+        });
+        nodesSanitized.push({
+          node: node,
+          marksRemoved: marksRemoved
+        });
+        tr.setNodeMarkup(position, undefined, node.attrs, filteredMarks);
+      }
+    });
+  });
+  return nodesSanitized;
+};

package/dist/esm/utils/node.js

@@ -0,0 +1,10 @@
+import { isListItemNode } from '@atlaskit/editor-common/utils';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+export function isListNodeValidContent(node) {
+  var bulletList = node.type.schema.nodes.bulletList;
+  if (!bulletList) {
+    return false;
+  }
+  var listFragment = Fragment.from(bulletList.createAndFill());
+  return !isListItemNode(node) && node.type.validContent(listFragment);
+}

package/dist/esm/utils/selection.js

@@ -0,0 +1,81 @@
+import { GapCursorSelection } from '@atlaskit/editor-common/selection';
+import { isListItemNode, isListNode, isParagraphNode } from '@atlaskit/editor-common/utils';
+import { findWrapping } from '@atlaskit/editor-prosemirror/transform';
+import { findParentNodeOfType, hasParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
+export var isPosInsideParagraph = function isPosInsideParagraph($pos) {
+  return $pos.parent.type.name === 'paragraph';
+};
+export var isPosInsideList = function isPosInsideList($pos) {
+  var posGrandParent = $pos.node(-1);
+  return isListItemNode($pos.parent) || isListNode($pos.parent) || isListItemNode(posGrandParent);
+};
+export var isWrappingPossible = function isWrappingPossible(nodeType, selection) {
+  var $from = selection.$from,
+    $to = selection.$to;
+  var range;
+  if (selection instanceof GapCursorSelection && $from.nodeAfter) {
+    var nodeSize = $from.nodeAfter.nodeSize || 1;
+    range = $from.blockRange($from.doc.resolve($from.pos + nodeSize));
+  } else {
+    range = $from.blockRange($to);
+  }
+  if (!range) {
+    return false;
+  }
+  var wrap = findWrapping(range, nodeType);
+  if (!wrap) {
+    return false;
+  }
+  return true;
+};
+
+// canOutdent
+export var isInsideListItem = function isInsideListItem(state) {
+  var parent = state.selection.$from.parent;
+  var listItem = state.schema.nodes.listItem;
+  if (state.selection instanceof GapCursorSelection) {
+    return isListItemNode(parent);
+  }
+  return hasParentNodeOfType(listItem)(state.selection) && isParagraphNode(parent);
+};
+export var isInsideTableCell = function isInsideTableCell(state) {
+  var _state$schema$nodes = state.schema.nodes,
+    tableCell = _state$schema$nodes.tableCell,
+    tableHeader = _state$schema$nodes.tableHeader;
+  return !!findParentNodeOfType([tableCell, tableHeader])(state.selection);
+};
+export var canJoinToPreviousListItem = function canJoinToPreviousListItem(state) {
+  var $from = state.selection.$from;
+  var $before = state.doc.resolve($from.pos - 1);
+  var nodeBefore = $before ? $before.nodeBefore : null;
+  if (state.selection instanceof GapCursorSelection) {
+    nodeBefore = $from.nodeBefore;
+  }
+  return isListNode(nodeBefore);
+};
+export var selectionContainsList = function selectionContainsList(tr) {
+  var _tr$selection = tr.selection,
+    from = _tr$selection.from,
+    to = _tr$selection.to;
+  var foundListNode = null;
+  tr.doc.nodesBetween(from, to, function (node) {
+    if (isListNode(node)) {
+      foundListNode = node;
+    }
+    if (foundListNode) {
+      return false;
+    }
+    return true;
+  });
+  return foundListNode;
+};
+export var createListNodeRange = function createListNodeRange(_ref) {
+  var selection = _ref.selection;
+  var $from = selection.$from,
+    $to = selection.$to;
+  var range = $from.blockRange($to, isListNode);
+  if (!range) {
+    return null;
+  }
+  return range;
+};

package/dist/types/actions/conversions.d.ts

@@ -0,0 +1,6 @@
+import type { NodeType } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare function convertListType({ tr, nextListNodeType, }: {
+    tr: Transaction;
+    nextListNodeType: NodeType;
+}): void;

package/dist/types/actions/indent-list-items-selected.d.ts

@@ -0,0 +1,2 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare const indentListItemsSelected: (tr: Transaction) => false | null | undefined;

package/dist/types/actions/indent-list.d.ts

@@ -0,0 +1,2 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare const indentList: (tr: Transaction) => false | undefined;

package/dist/types/actions/join-list-items-forward.d.ts

@@ -0,0 +1,13 @@
+import { LIST_TEXT_SCENARIOS } from '@atlaskit/editor-common/analytics';
+import type { WalkNode } from '@atlaskit/editor-common/utils';
+import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+type ScenariosAllowed = LIST_TEXT_SCENARIOS.JOIN_PARAGRAPH_WITH_LIST | LIST_TEXT_SCENARIOS.JOIN_SIBLINGS | LIST_TEXT_SCENARIOS.JOIN_DESCENDANT_TO_PARENT | LIST_TEXT_SCENARIOS.JOIN_PARENT_SIBLING_TO_PARENT_CHILD | LIST_TEXT_SCENARIOS.JOIN_LIST_ITEM_WITH_PARAGRAPH;
+type DeleteAction = (props: {
+    tr: Transaction;
+    $next: ResolvedPos;
+    $head: ResolvedPos;
+}) => boolean;
+type ScenarioAction = false | [ScenariosAllowed, DeleteAction];
+export declare const calcJoinListScenario: (walkNode: WalkNode, $head: ResolvedPos) => ScenarioAction;
+export {};

package/dist/types/actions/join-list-items-scenarios/index.d.ts

@@ -0,0 +1,5 @@
+export { joinParagrapWithList } from './join-paragraph-with-list';
+export { joinSiblingListItems } from './join-sibling-list-items';
+export { joinNestedListWithParentListItem } from './join-nested-list-with-parent-list-item';
+export { joinListItemWithParentNestedList } from './join-list-item-with-parent-nested-list';
+export { joinListItemWithParagraph } from './join-list-item-with-paragraph';

package/dist/types/actions/join-list-items-scenarios/join-list-item-with-paragraph.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+type DeleteAction = (props: {
+    tr: Transaction;
+    $next: ResolvedPos;
+    $head: ResolvedPos;
+}) => boolean;
+export declare const joinListItemWithParagraph: DeleteAction;
+export {};

package/dist/types/actions/join-list-items-scenarios/join-list-item-with-parent-nested-list.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+type DeleteAction = (props: {
+    tr: Transaction;
+    $next: ResolvedPos;
+    $head: ResolvedPos;
+}) => boolean;
+export declare const joinListItemWithParentNestedList: DeleteAction;
+export {};

package/dist/types/actions/join-list-items-scenarios/join-nested-list-with-parent-list-item.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+type DeleteAction = (props: {
+    tr: Transaction;
+    $next: ResolvedPos;
+    $head: ResolvedPos;
+}) => boolean;
+export declare const joinNestedListWithParentListItem: DeleteAction;
+export {};

package/dist/types/actions/join-list-items-scenarios/join-paragraph-with-list.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+type DeleteAction = (props: {
+    tr: Transaction;
+    $next: ResolvedPos;
+    $head: ResolvedPos;
+}) => boolean;
+export declare const joinParagrapWithList: DeleteAction;
+export {};

package/dist/types/actions/join-list-items-scenarios/join-sibling-list-items.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+type DeleteAction = (props: {
+    tr: Transaction;
+    $next: ResolvedPos;
+    $head: ResolvedPos;
+}) => boolean;
+export declare const joinSiblingListItems: DeleteAction;
+export {};

package/dist/types/actions/merge-lists.d.ts

@@ -0,0 +1,7 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+type MergeNextListAtPositionProps = {
+    listPosition: number;
+    tr: Transaction;
+};
+export declare function mergeNextListAtPosition({ tr, listPosition, }: MergeNextListAtPositionProps): void;
+export {};

package/dist/types/actions/outdent-list-items-selected.d.ts

@@ -0,0 +1,3 @@
+import type { FeatureFlags } from '@atlaskit/editor-common/types';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare const outdentListItemsSelected: (tr: Transaction, state: EditorState, featureFlags: FeatureFlags) => void;

package/dist/types/actions/wrap-and-join-lists.d.ts

@@ -0,0 +1,17 @@
+import type { NodeType } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+/**
+ * Wraps the selection in a list with the given type. If this results in
+ * two adjacent lists of the same type, those will be joined together.
+ */
+export declare function wrapInListAndJoin(nodeType: NodeType, tr: Transaction): void;
+type Attrs = {
+    [key: string]: any;
+};
+/**
+ * Wraps the selection in a list with the given type and attributes.
+ *
+ * Adapted from https://github.com/ProseMirror/prosemirror-schema-list/blob/master/src/schema-list.js#L64-L89
+ */
+export declare function wrapInList(listType: NodeType, attrs?: Attrs): (tr: Transaction) => boolean;
+export {};

package/dist/types/commands/indent-list.d.ts

@@ -0,0 +1,6 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { Command } from '@atlaskit/editor-common/types';
+type InputMethod = INPUT_METHOD.KEYBOARD | INPUT_METHOD.TOOLBAR;
+export declare const indentList: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (inputMethod?: InputMethod) => Command;
+export {};

package/dist/types/commands/index.d.ts

@@ -0,0 +1,16 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { Command, FeatureFlags } from '@atlaskit/editor-common/types';
+import type { NodeType, ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { indentList } from './indent-list';
+import { outdentList } from './outdent-list';
+export { outdentList, indentList };
+export type InputMethod = INPUT_METHOD.KEYBOARD | INPUT_METHOD.TOOLBAR;
+export declare const enterKeyCommand: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (featureFlags: FeatureFlags) => Command;
+export declare const backspaceKeyCommand: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (featureFlags: FeatureFlags) => Command;
+export declare const deleteKeyCommand: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => Command;
+export declare const rootListDepth: (pos: ResolvedPos, nodes: Record<string, NodeType>) => number | undefined;
+export declare const toggleList: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (inputMethod: InputMethod, listType: 'bulletList' | 'orderedList') => Command;
+export declare const toggleBulletList: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, inputMethod?: InputMethod) => boolean;
+export declare const toggleOrderedList: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, inputMethod?: InputMethod) => boolean;

package/dist/types/commands/isFirstChildOfParent.d.ts

@@ -0,0 +1,2 @@
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+export declare const isFirstChildOfParent: (state: EditorState) => boolean;

package/dist/types/commands/join-list-item-forward.d.ts

@@ -0,0 +1,3 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { Command } from '@atlaskit/editor-common/types';
+export declare const joinListItemForward: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => Command;

package/dist/types/commands/listBackspace.d.ts

@@ -0,0 +1,10 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { LIST_TEXT_SCENARIOS } from '@atlaskit/editor-common/analytics';
+import type { CommandDispatch } from '@atlaskit/editor-common/types';
+import type { WalkNode } from '@atlaskit/editor-common/utils';
+import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+type ScenariosAllowed = LIST_TEXT_SCENARIOS.JOIN_SIBLINGS | LIST_TEXT_SCENARIOS.JOIN_DESCENDANT_TO_PARENT | LIST_TEXT_SCENARIOS.JOIN_TO_SIBLING_DESCENDANT;
+export declare const calcJoinListScenario: (walkNode: WalkNode, $head: ResolvedPos, tr: Transaction) => [ScenariosAllowed, ResolvedPos | null] | false;
+export declare const listBackspace: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (state: EditorState, dispatch?: CommandDispatch) => boolean;
+export {};

package/dist/types/commands/outdent-list.d.ts

@@ -0,0 +1,6 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { Command, FeatureFlags } from '@atlaskit/editor-common/types';
+type InputMethod = INPUT_METHOD.KEYBOARD | INPUT_METHOD.TOOLBAR;
+export declare const outdentList: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (inputMethod: InputMethod | undefined, featureFlags: FeatureFlags) => Command;
+export {};