@titaui/pc 1.10.44 → 1.10.45

package/lib/components/rich-editor/plugins/block/lists/utils/analytics.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCommonListAnalyticsAttributes = exports.countListItemsInSelection = void 0;
+
+var _node = require("./node");
+
+var _selection = require("./selection");
+
+var getCommonListAnalyticsAttributes = function getCommonListAnalyticsAttributes(state) {
+  var _state$selection = state.selection,
+      $from = _state$selection.$from,
+      $to = _state$selection.$to;
+  var fromAttrs = (0, _selection.getListItemAttributes)($from);
+  var toAttrs = (0, _selection.getListItemAttributes)($to);
+  return {
+    itemIndexAtSelectionStart: fromAttrs.itemIndex,
+    itemIndexAtSelectionEnd: toAttrs.itemIndex,
+    indentLevelAtSelectionStart: fromAttrs.indentLevel,
+    indentLevelAtSelectionEnd: toAttrs.indentLevel,
+    itemsInSelection: countListItemsInSelection(state)
+  };
+};
+
+exports.getCommonListAnalyticsAttributes = getCommonListAnalyticsAttributes;
+
+var countListItemsInSelection = function countListItemsInSelection(state) {
+  var _state$selection2 = state.selection,
+      from = _state$selection2.from,
+      to = _state$selection2.to;
+
+  if (from === to) {
+    return 1;
+  }
+
+  var count = 0;
+  var listSlice = state.doc.cut(from, to);
+  listSlice.content.nodesBetween(0, listSlice.content.size, function (node, pos, parent, index) {
+    if (parent && (0, _node.isListItemNode)(parent) && !(0, _node.isListNode)(node) && index === 0) {
+      count++;
+    }
+  });
+  return count;
+};
+
+exports.countListItemsInSelection = countListItemsInSelection;

package/lib/components/rich-editor/plugins/block/lists/utils/find.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findFirstNestedList = findFirstNestedList;
+exports.findFirstParentListItemNode = findFirstParentListItemNode;
+exports.findFirstParentListNode = findFirstParentListNode;
+exports.findRootParentListNode = findRootParentListNode;
+
+var _prosemirrorUtils = require("prosemirror-utils");
+
+var _node = require("./node");
+
+function findFirstNestedList($pos) {
+  var currentNode = $pos.doc.nodeAt($pos.pos);
+  var currentListItemPos = null;
+
+  if ((0, _node.isListItemNode)(currentNode)) {
+    currentListItemPos = $pos.pos;
+  } else {
+    var result = (0, _prosemirrorUtils.findParentNodeClosestToPos)($pos, _node.isListItemNode);
+    currentListItemPos = (result === null || result === void 0 ? void 0 : result.pos) || null;
+  }
+
+  if (!currentListItemPos) {
+    return null;
+  }
+
+  var currentListItemNode = $pos.doc.nodeAt(currentListItemPos);
+
+  if (!currentListItemNode) {
+    return null;
+  }
+
+  var lastListItemChild = currentListItemNode.child(currentListItemNode.childCount - 1);
+
+  if (!(0, _node.isListNode)(lastListItemChild)) {
+    return null;
+  }
+
+  var firstNestedListPosition = currentListItemNode.nodeSize - lastListItemChild.nodeSize;
+  var firstNestedListNode = $pos.doc.nodeAt(firstNestedListPosition);
+
+  if (!(0, _node.isListNode)(firstNestedListNode)) {
+    return null;
+  }
+
+  return $pos.doc.resolve(firstNestedListPosition);
+}
+
+function findFirstParentListNode($pos) {
+  var currentNode = $pos.doc.nodeAt($pos.pos);
+  var listNodePosition = null;
+
+  if ((0, _node.isListNode)(currentNode)) {
+    listNodePosition = $pos.pos;
+  } else {
+    var result = (0, _prosemirrorUtils.findParentNodeClosestToPos)($pos, _node.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
+  };
+}
+
+function findFirstParentListItemNode($pos) {
+  var currentNode = $pos.doc.nodeAt($pos.pos);
+  var listItemNodePosition = (0, _node.isListItemNode)(currentNode) ? $pos : (0, _prosemirrorUtils.findParentNodeClosestToPos)($pos, _node.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
+  };
+}
+
+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 ((0, _node.isListNode)(currentNode) && !(0, _node.isListItemNode)(nodeBefore)) {
+    return doc.resolve($pos.pos + 1);
+  }
+
+  var parentList = (0, _prosemirrorUtils.findParentNodeClosestToPos)($pos, _node.isListNode);
+
+  if (!parentList) {
+    return null;
+  }
+
+  var listNodePosition = doc.resolve(parentList.pos);
+  return findRootParentListNode(listNodePosition);
+}

package/lib/components/rich-editor/plugins/block/lists/utils/indentation.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasValidListIndentationLevel = exports.getNextSiblingListItemPosition = exports.getListLiftTarget = void 0;
+
+var _selection = require("./selection");
+
+var _node = require("./node");
+
+// This will return (depth - 1) for root list parent of a list.
+var getListLiftTarget = function getListLiftTarget(resPos) {
+  var target = resPos.depth;
+
+  for (var i = resPos.depth; i > 0; i--) {
+    var node = resPos.node(i);
+
+    if ((0, _node.isListNode)(node)) {
+      target = i;
+    }
+
+    if (!(0, _node.isListItemNode)(node) && !(0, _node.isListNode)(node)) {
+      break;
+    }
+  }
+
+  return target - 1;
+};
+
+exports.getListLiftTarget = getListLiftTarget;
+
+var getNextSiblingListItemPosition = function getNextSiblingListItemPosition($pos) {
+  var _$pos$doc$nodeAt;
+
+  var target = $pos.depth;
+  var found = false;
+
+  for (var i = $pos.depth; i > 0; i--) {
+    var node = $pos.node(i);
+
+    if ((0, _node.isListItemNode)(node)) {
+      target = i;
+      found = true;
+    }
+
+    if (found) {
+      break;
+    }
+  }
+
+  var listItemPosition = target - 1;
+  var listItemNodePosition = ((_$pos$doc$nodeAt = $pos.doc.nodeAt(listItemPosition)) === null || _$pos$doc$nodeAt === void 0 ? void 0 : _$pos$doc$nodeAt.nodeSize) || 0;
+  var nextListItemPosition = listItemPosition + listItemNodePosition;
+  var nextListItemNode = $pos.doc.nodeAt(nextListItemPosition);
+
+  if (nextListItemNode) {
+    return $pos.doc.resolve(nextListItemPosition);
+  }
+
+  return null;
+};
+
+exports.getNextSiblingListItemPosition = getNextSiblingListItemPosition;
+
+var hasValidListIndentationLevel = function hasValidListIndentationLevel(_ref) {
+  var tr = _ref.tr,
+      maxIndentation = _ref.maxIndentation;
+  var initialIndentationLevel = (0, _selection.numberNestedLists)(tr.selection.$from);
+  var currentIndentationLevel;
+  var currentPos = tr.selection.$to.pos;
+
+  do {
+    var resolvedPos = tr.doc.resolve(currentPos);
+    currentIndentationLevel = (0, _selection.numberNestedLists)(resolvedPos);
+
+    if (currentIndentationLevel > maxIndentation) {
+      return false;
+    }
+
+    currentPos++;
+  } while (currentIndentationLevel >= initialIndentationLevel);
+
+  return true;
+};
+
+exports.hasValidListIndentationLevel = hasValidListIndentationLevel;

package/lib/components/rich-editor/plugins/block/lists/utils/node.js

@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JoinDirection = void 0;
+exports.isBulletList = isBulletList;
+exports.isDocumentNode = isDocumentNode;
+exports.isListItemNode = isListItemNode;
+exports.isListNode = isListNode;
+exports.isListNodeValidContent = isListNodeValidContent;
+exports.isParagraphNode = isParagraphNode;
+exports.joinSiblingLists = void 0;
+
+var _prosemirrorModel = require("prosemirror-model");
+
+function isDocumentNode(node) {
+  return Boolean(node && node.type && node.type.name === 'doc');
+}
+
+function isListNode(node) {
+  return Boolean(node && node.type && ['orderedList', 'bulletList'].includes(node.type.name));
+}
+
+function isParagraphNode(node) {
+  return Boolean(node && node.type && 'paragraph' === node.type.name);
+}
+
+function isListItemNode(node) {
+  return Boolean(node && node.type && 'listItem' === node.type.name);
+}
+
+function isBulletList(node) {
+  return Boolean(node && node.type && 'bulletList' === node.type.name);
+}
+
+function isListNodeValidContent(node) {
+  var bulletList = node.type.schema.nodes.bulletList;
+
+  if (!bulletList) {
+    return false;
+  }
+
+  var listFragment = _prosemirrorModel.Fragment.from(bulletList.createAndFill());
+
+  return !isListItemNode(node) && node.type.validContent(listFragment);
+}
+
+var JoinDirection;
+exports.JoinDirection = JoinDirection;
+
+(function (JoinDirection) {
+  JoinDirection[JoinDirection["LEFT"] = 1] = "LEFT";
+  JoinDirection[JoinDirection["RIGHT"] = -1] = "RIGHT";
+})(JoinDirection || (exports.JoinDirection = JoinDirection = {}));
+
+var joinSiblingLists = function joinSiblingLists(_ref) {
+  var tr = _ref.tr,
+      direction = _ref.direction,
+      forceListType = _ref.forceListType;
+  var result = {
+    orderedList: 0,
+    bulletList: 0
+  };
+  var doc = tr.doc,
+      _tr$selection = tr.selection,
+      $from = _tr$selection.$from,
+      $to = _tr$selection.$to,
+      selection = tr.selection;
+  var range = $from.blockRange($to, isListNodeValidContent);
+
+  if (!range) {
+    return result;
+  }
+
+  var rootListNode = doc.nodeAt(range.start);
+  var from = isListNode(rootListNode) ? range.start : 0;
+  var to = isListNode(rootListNode) ? range.end : tr.doc.content.size;
+  var joins = [];
+  doc.nodesBetween(from, to, function (node, pos, parent) {
+    var resolvedPos = doc.resolve(pos);
+    var nodeBefore = resolvedPos.nodeBefore,
+        nodeAfter = resolvedPos.nodeAfter;
+
+    if (!nodeBefore || !nodeAfter || !isListNode(nodeBefore) || !isListNode(nodeAfter)) {
+      return;
+    }
+
+    var isNestedList = isListItemNode(parent);
+
+    if (!isNestedList && nodeBefore.type !== nodeAfter.type && !forceListType) {
+      return;
+    }
+
+    var index = resolvedPos.index();
+    var positionPreviousNode = resolvedPos.posAtIndex(index - 1);
+    var positionCurrentNode = resolvedPos.posAtIndex(index); // If the previous node is part of the selection, OR
+    // If the previous node is not part of the selection and the previous node has the same list type that we’re converting to
+
+    var joinBefore = positionPreviousNode >= from || nodeBefore.type === forceListType;
+
+    if (forceListType) {
+      if (joinBefore) {
+        tr.setNodeMarkup(positionPreviousNode, forceListType);
+      }
+
+      tr.setNodeMarkup(positionCurrentNode, forceListType);
+    }
+
+    if (isNestedList && nodeBefore.type !== nodeAfter.type) {
+      var nodeType = direction === JoinDirection.RIGHT ? nodeAfter.type : nodeBefore.type;
+      tr.setNodeMarkup(positionPreviousNode, nodeType);
+    }
+
+    if (joinBefore) {
+      joins.push(pos);
+    }
+  });
+
+  if (selection.empty && rootListNode && isListNode(rootListNode)) {
+    var resolvedPos = doc.resolve(range.start + rootListNode.nodeSize);
+    var nodeBefore = resolvedPos.nodeBefore,
+        nodeAfter = resolvedPos.nodeAfter;
+
+    if (nodeBefore && nodeAfter && isListNode(nodeBefore) && isListNode(nodeAfter) && nodeAfter.type === nodeBefore.type) {
+      joins.push(resolvedPos.pos);
+    }
+  }
+
+  for (var i = joins.length - 1; i >= 0; i--) {
+    var listNode = tr.doc.nodeAt(joins[i]);
+
+    if (listNode) {
+      var amount = result[listNode.type.name] || 0;
+      result[listNode.type.name] = amount + 1;
+    }
+
+    tr.join(joins[i]);
+  }
+
+  return result;
+};
+
+exports.joinSiblingLists = joinSiblingLists;

package/lib/components/rich-editor/plugins/block/lists/utils/replace-content.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.moveTargetIntoList = void 0;
+
+var _prosemirrorTransform = require("prosemirror-transform");
+
+var moveTargetIntoList = function moveTargetIntoList(_ref) {
+  var _$target$nodeAfter;
+
+  var insertPosition = _ref.insertPosition,
+      $target = _ref.$target;
+  // take the text content of the paragraph and insert after the paragraph up until before the the cut
+  var from = insertPosition;
+  var to = $target.pos + (((_$target$nodeAfter = $target.nodeAfter) === null || _$target$nodeAfter === void 0 ? void 0 : _$target$nodeAfter.nodeSize) || 0); //$cut.pos + $cut.nodeAfter.nodeSize;
+
+  var gapFrom = $target.posAtIndex(0, $target.depth + 1); // start pos of the child
+
+  var gapTo = $target.doc.resolve(gapFrom).end(); // end pos of the paragraph
+
+  if (gapTo - gapFrom === 0) {
+    return new _prosemirrorTransform.ReplaceStep(from, to, $target.doc.slice(insertPosition, $target.pos));
+  }
+
+  var step = new _prosemirrorTransform.ReplaceAroundStep(from, to, gapFrom, gapTo, $target.doc.slice(insertPosition, $target.pos), 0, true);
+  return step;
+};
+
+exports.moveTargetIntoList = moveTargetIntoList;

package/lib/components/rich-editor/plugins/block/lists/utils/selection.js

@@ -0,0 +1,201 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectionContainsList = exports.resolvePositionToStartOfListItem = exports.resolvePositionToEndOfListItem = exports.numberNestedLists = exports.normalizeListItemsSelection = exports.isWrappingPossible = exports.isPosInsideParagraph = exports.isPosInsideList = exports.isInsideTableCell = exports.isInsideListItem = exports.getListItemAttributes = exports.createListNodeRange = exports.createListItemNodeRange = exports.canJoinToPreviousListItem = void 0;
+
+var _prosemirrorTransform = require("prosemirror-transform");
+
+var _prosemirrorState = require("prosemirror-state");
+
+var _prosemirrorUtils = require("prosemirror-utils");
+
+var _node = require("./node");
+
+// import { GapCursorSelection } from '../../selection/gap-cursor-selection';
+var isPosInsideParagraph = function isPosInsideParagraph($pos) {
+  return $pos.parent.type.name === 'paragraph';
+};
+
+exports.isPosInsideParagraph = isPosInsideParagraph;
+
+var isPosInsideList = function isPosInsideList($pos) {
+  var posGrandParent = $pos.node(-1);
+  return (0, _node.isListItemNode)($pos.parent) || (0, _node.isListNode)($pos.parent) || (0, _node.isListItemNode)(posGrandParent);
+};
+
+exports.isPosInsideList = isPosInsideList;
+
+var isWrappingPossible = function isWrappingPossible(nodeType, selection) {
+  var $from = selection.$from,
+      $to = selection.$to;
+  var range = $from.blockRange($to);
+
+  if (!range) {
+    return false;
+  }
+
+  var wrap = (0, _prosemirrorTransform.findWrapping)(range, nodeType);
+
+  if (!wrap) {
+    return false;
+  }
+
+  return true;
+}; // canOutdent
+
+
+exports.isWrappingPossible = isWrappingPossible;
+
+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 (0, _prosemirrorUtils.hasParentNodeOfType)(listItem)(state.selection) && (0, _node.isParagraphNode)(parent);
+};
+
+exports.isInsideListItem = isInsideListItem;
+
+var isInsideTableCell = function isInsideTableCell(state) {
+  var _state$schema$nodes = state.schema.nodes,
+      tableCell = _state$schema$nodes.tableCell,
+      tableHeader = _state$schema$nodes.tableHeader;
+  return !!(0, _prosemirrorUtils.findParentNodeOfType)([tableCell, tableHeader])(state.selection);
+};
+
+exports.isInsideTableCell = isInsideTableCell;
+
+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 (0, _node.isListNode)(nodeBefore);
+};
+
+exports.canJoinToPreviousListItem = canJoinToPreviousListItem;
+
+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 ((0, _node.isListNode)(node)) {
+      foundListNode = node;
+    }
+
+    if (foundListNode) {
+      return false;
+    }
+
+    return true;
+  });
+  return foundListNode;
+};
+
+exports.selectionContainsList = selectionContainsList;
+
+var numberNestedLists = function numberNestedLists(resolvedPos) {
+  var count = 0;
+
+  for (var i = resolvedPos.depth - 1; i > 0; i--) {
+    var node = resolvedPos.node(i);
+
+    if ((0, _node.isListNode)(node)) {
+      count += 1;
+    }
+  }
+
+  return count;
+};
+
+exports.numberNestedLists = numberNestedLists;
+
+var getListItemAttributes = function getListItemAttributes($pos) {
+  var indentLevel = numberNestedLists($pos) - 1;
+  var itemAtPos = (0, _prosemirrorUtils.findParentNodeClosestToPos)($pos, _node.isListItemNode); // Get the index of the current item relative to parent (parent is at item depth - 1)
+
+  var itemIndex = $pos.index(itemAtPos ? itemAtPos.depth - 1 : undefined);
+  return {
+    indentLevel: indentLevel,
+    itemIndex: itemIndex
+  };
+};
+
+exports.getListItemAttributes = getListItemAttributes;
+
+var normalizeListItemsSelection = function normalizeListItemsSelection(_ref) {
+  var selection = _ref.selection,
+      doc = _ref.doc;
+
+  if (selection.empty) {
+    return selection;
+  }
+
+  var $from = selection.$from,
+      $to = selection.$to;
+
+  if (selection instanceof _prosemirrorState.NodeSelection) {
+    var _head = resolvePositionToStartOfListItem($from);
+
+    return new _prosemirrorState.TextSelection(_head, _head);
+  }
+
+  var head = resolvePositionToStartOfListItem($from);
+  var anchor = resolvePositionToEndOfListItem($to);
+  return new _prosemirrorState.TextSelection(anchor, head);
+};
+
+exports.normalizeListItemsSelection = normalizeListItemsSelection;
+
+var resolvePositionToStartOfListItem = function resolvePositionToStartOfListItem($pos) {
+  var fromRange = $pos.blockRange($pos, _node.isListItemNode);
+  var fromPosition = fromRange && $pos.textOffset === 0 && fromRange.end - 1 === $pos.pos ? _prosemirrorState.Selection.near($pos.doc.resolve(fromRange.end + 1), 1).$from : $pos;
+  return fromPosition;
+};
+
+exports.resolvePositionToStartOfListItem = resolvePositionToStartOfListItem;
+
+var resolvePositionToEndOfListItem = function resolvePositionToEndOfListItem($pos) {
+  var toRange = $pos.blockRange($pos, _node.isListItemNode);
+  var toPosition = toRange && $pos.textOffset === 0 && toRange.start + 1 === $pos.pos ? _prosemirrorState.Selection.near($pos.doc.resolve(toRange.start - 1), -1).$to : $pos;
+  return toPosition;
+};
+
+exports.resolvePositionToEndOfListItem = resolvePositionToEndOfListItem;
+
+var createListNodeRange = function createListNodeRange(_ref2) {
+  var selection = _ref2.selection;
+  var $from = selection.$from,
+      $to = selection.$to;
+  var range = $from.blockRange($to, _node.isListNode);
+
+  if (!range) {
+    return null;
+  }
+
+  return range;
+};
+
+exports.createListNodeRange = createListNodeRange;
+
+var createListItemNodeRange = function createListItemNodeRange(_ref3) {
+  var selection = _ref3.selection;
+  var $from = selection.$from,
+      $to = selection.$to;
+  var range = $from.blockRange($to, _node.isListItemNode);
+
+  if (!range) {
+    return null;
+  }
+
+  return range;
+};
+
+exports.createListItemNodeRange = createListItemNodeRange;

package/lib/components/rich-editor/plugins/block/lists/utils.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isWrappingPossible = exports.getListLiftTarget = void 0;
+
+var _prosemirrorTransform = require("prosemirror-transform");
+
+var _node = require("./utils/node");
+
+var isWrappingPossible = function isWrappingPossible(nodeType, state) {
+  var _state$selection = state.selection,
+      $from = _state$selection.$from,
+      $to = _state$selection.$to;
+  var range = $from.blockRange($to);
+
+  if (!range) {
+    return false;
+  }
+
+  var wrap = (0, _prosemirrorTransform.findWrapping)(range, nodeType);
+
+  if (!wrap) {
+    return false;
+  }
+
+  return true;
+}; // This will return (depth - 1) for root list parent of a list.
+
+
+exports.isWrappingPossible = isWrappingPossible;
+
+var getListLiftTarget = function getListLiftTarget(resPos) {
+  var target = resPos.depth;
+
+  for (var i = resPos.depth; i > 0; i--) {
+    var node = resPos.node(i);
+
+    if ((0, _node.isListNode)(node)) {
+      target = i;
+    }
+
+    if (!(0, _node.isListItemNode)(node) && !(0, _node.isListNode)(node)) {
+      break;
+    }
+  }
+
+  return target - 1;
+};
+
+exports.getListLiftTarget = getListLiftTarget;