@atlaskit/editor-core 178.1.0 → 178.1.2

package/dist/es2019/utils/commands.js

@@ -3,21 +3,17 @@ import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
 import { transformSmartCharsMentionsAndEmojis } from '../plugins/text-formatting/commands/transform-to-code';
 import { GapCursorSelection } from '../plugins/selection/gap-cursor-selection';
 import { isEmptyParagraph } from './document';
-
 const filter = (predicates, cmd) => {
   return function (state, dispatch, view) {
     if (!Array.isArray(predicates)) {
       predicates = [predicates];
     }
-
     if (predicates.some(pred => !pred(state, view))) {
       return false;
     }
-
     return cmd(state, dispatch, view) || false;
   };
 };
-
 const isEmptySelectionAtStart = state => {
   const {
     empty,
@@ -25,7 +21,6 @@ const isEmptySelectionAtStart = state => {
   } = state.selection;
   return empty && ($from.parentOffset === 0 || state.selection instanceof GapCursorSelection);
 };
-
 const isEmptySelectionAtEnd = state => {
   const {
     empty,
@@ -33,13 +28,13 @@ const isEmptySelectionAtEnd = state => {
   } = state.selection;
   return empty && ($from.end() === $from.pos || state.selection instanceof GapCursorSelection);
 };
-
 const isFirstChildOfParent = state => {
   const {
     $from
   } = state.selection;
   return $from.depth > 1 ? state.selection instanceof GapCursorSelection && $from.parentOffset === 0 || $from.index($from.depth - 1) === 0 : true;
 };
+
 /**
  * Creates a filter that checks if the node at a given number of parents above the current
  * selection is of the correct node type.
@@ -48,8 +43,6 @@ const isFirstChildOfParent = state => {
  * the current selection's parent, which will be the containing node when the selection
  * is usually inside the text content.
  */
-
-
 const isNthParentOfType = (nodeType, depthAway) => {
   return state => {
     const {
@@ -58,14 +51,14 @@ const isNthParentOfType = (nodeType, depthAway) => {
     const parent = $from.node($from.depth - depthAway);
     return !!parent && parent.type === state.schema.nodes[nodeType];
   };
-}; // https://github.com/ProseMirror/prosemirror-commands/blob/master/src/commands.js#L90
+};
+
+// https://github.com/ProseMirror/prosemirror-commands/blob/master/src/commands.js#L90
 // Keep going left up the tree, without going across isolating boundaries, until we
 // can go along the tree at that same level
 //
 // You can think of this as, if you could construct each document like we do in the tests,
 // return the position of the first ) backwards from the current selection.
-
-
 function findCutBefore($pos) {
   // parent is non-isolating, so we can look across this boundary
   if (!$pos.parent.type.spec.isolating) {
@@ -76,16 +69,13 @@ function findCutBefore($pos) {
       if ($pos.index(i) > 0) {
         return $pos.doc.resolve($pos.before(i + 1));
       }
-
       if ($pos.node(i).type.spec.isolating) {
         break;
       }
     }
   }
-
   return null;
 }
-
 const applyMarkOnRange = (from, to, removeMark, mark, tr) => {
   const {
     schema
@@ -93,34 +83,29 @@ const applyMarkOnRange = (from, to, removeMark, mark, tr) => {
   const {
     code
   } = schema.marks;
-
   if (mark.type === code) {
     transformSmartCharsMentionsAndEmojis(from, to, tr);
   }
-
   tr.doc.nodesBetween(tr.mapping.map(from), tr.mapping.map(to), (node, pos) => {
     if (!node.isText) {
       return true;
-    } // This is an issue when the user selects some text.
+    }
+
+    // This is an issue when the user selects some text.
     // We need to check if the current node position is less than the range selection from.
     // If it’s true, that means we should apply the mark using the range selection,
     // not the current node position.
-
-
     const nodeBetweenFrom = Math.max(pos, tr.mapping.map(from));
     const nodeBetweenTo = Math.min(pos + node.nodeSize, tr.mapping.map(to));
-
     if (removeMark) {
       tr.removeMark(nodeBetweenFrom, nodeBetweenTo, mark);
     } else {
       tr.addMark(nodeBetweenFrom, nodeBetweenTo, mark);
     }
-
     return true;
   });
   return tr;
 };
-
 const entireSelectionContainsMark = (mark, doc, fromPos, toPos) => {
   let onlyContainsMark = true;
   doc.nodesBetween(fromPos, toPos, node => {
@@ -128,17 +113,14 @@ const entireSelectionContainsMark = (mark, doc, fromPos, toPos) => {
     if (!onlyContainsMark) {
       return false;
     }
-
     if (node.isText) {
       onlyContainsMark &&= mark.isInSet(node.marks);
     }
   });
   return onlyContainsMark;
 };
-
 const toggleMarkInRange = mark => (state, dispatch) => {
   const tr = state.tr;
-
   if (state.selection instanceof CellSelection) {
     let removeMark = true;
     const cells = [];
@@ -151,7 +133,6 @@ const toggleMarkInRange = mark => (state, dispatch) => {
       const to = cellPos + cell.nodeSize;
       removeMark &&= entireSelectionContainsMark(mark, state.doc, from, to);
     });
-
     for (let i = cells.length - 1; i >= 0; i--) {
       const cell = cells[i];
       const from = cell.pos;
@@ -162,65 +143,55 @@ const toggleMarkInRange = mark => (state, dispatch) => {
     const {
       $from,
       $to
-    } = state.selection; // We decide to remove the mark only if the entire selection contains the mark
+    } = state.selection;
+    // We decide to remove the mark only if the entire selection contains the mark
     // Examples with *bold* text
     // Scenario 1: Selection contains both bold and non-bold text -> bold entire selection
     // Scenario 2: Selection contains only bold text -> un-bold entire selection
     // Scenario 3: Selection contains no bold text -> bold entire selection
-
     const removeMark = entireSelectionContainsMark(mark, state.doc, $from.pos, $to.pos);
     applyMarkOnRange($from.pos, $to.pos, removeMark, mark, tr);
   }
-
   if (tr.docChanged) {
     if (dispatch) {
       dispatch(tr);
     }
-
     return true;
   }
-
   return false;
 };
+
 /**
  * A wrapper over the default toggleMark, except when we have a selection
  * we only toggle marks on text nodes rather than inline nodes.
  * @param markType
  * @param attrs
  */
-
-
 const toggleMark = (markType, attrs) => (state, dispatch) => {
-  const mark = markType.create(attrs); // For cursor selections we can use the default behaviour.
+  const mark = markType.create(attrs);
 
+  // For cursor selections we can use the default behaviour.
   if (state.selection instanceof TextSelection && state.selection.$cursor) {
     const tr = state.tr;
-
     if (mark.isInSet(state.storedMarks || state.selection.$cursor.marks())) {
       tr.removeStoredMark(mark);
     } else {
       tr.addStoredMark(mark);
     }
-
     if (dispatch) {
       dispatch(tr);
       return true;
     }
-
     return false;
   }
-
   return toggleMarkInRange(mark)(state, dispatch);
 };
-
 const withScrollIntoView = command => (state, dispatch, view) => command(state, tr => {
   tr.scrollIntoView();
-
   if (dispatch) {
     dispatch(tr);
   }
 }, view);
-
 /**
  * Walk forwards from a position until we encounter the (inside) start of
  * the next node, or reach the end of the document.
@@ -228,40 +199,38 @@ const withScrollIntoView = command => (state, dispatch, view) => command(state,
  * @param $startPos Position to start walking from.
  */
 const walkNextNode = $startPos => {
-  let $pos = $startPos; // invariant 1: don't walk past the end of the document
+  let $pos = $startPos;
+
+  // invariant 1: don't walk past the end of the document
   // invariant 2: we are at the beginning or
   //              we haven't walked to the start of *any* node
   //              parentOffset includes textOffset.
-
   while ($pos.pos < $pos.doc.nodeSize - 2 && ($pos.pos === $startPos.pos || $pos.parentOffset > 0)) {
     $pos = $pos.doc.resolve($pos.pos + 1);
   }
-
   return {
     $pos: $pos,
     foundNode: $pos.pos < $pos.doc.nodeSize - 2
   };
 };
+
 /**
  * Walk backwards from a position until we encounter the (inside) end of
  * the previous node, or reach the start of the document.
  *
  * @param $startPos Position to start walking from.
  */
-
-
 const walkPrevNode = $startPos => {
   let $pos = $startPos;
-
   while ($pos.pos > 0 && ($pos.pos === $startPos.pos || $pos.parentOffset < $pos.parent.nodeSize - 2)) {
     $pos = $pos.doc.resolve($pos.pos - 1);
   }
-
   return {
     $pos: $pos,
     foundNode: $pos.pos > 0
   };
 };
+
 /**
  * Insert content, delete a range and create a new selection
  * This function automatically handles the mapping of positions for insertion and deletion.
@@ -272,7 +241,6 @@ const walkPrevNode = $startPos => {
  * @param deletions the ranges to delete
  */
 
-
 const insertContentDeleteRange = (tr, getSelectionResolvedPos, insertions, deletions) => {
   insertions.forEach(contentInsert => {
     let [content, pos] = contentInsert;
@@ -284,14 +252,13 @@ const insertContentDeleteRange = (tr, getSelectionResolvedPos, insertions, delet
   });
   tr.setSelection(new TextSelection(getSelectionResolvedPos(tr)));
 };
-
 const selectNode = pos => (state, dispatch) => {
   if (dispatch) {
     dispatch(state.tr.setSelection(new NodeSelection(state.doc.resolve(pos))));
   }
-
   return true;
 };
+
 /**
  * If the selection is empty, is inside a paragraph node and `canNextNodeMoveUp` is true then delete current paragraph
  * and move the node below it up. The selection will be retained, to be placed in the moved node.
@@ -299,8 +266,6 @@ const selectNode = pos => (state, dispatch) => {
  * @param canNextNodeMoveUp check if node directly after the selection is able to be brought up to selection
  * @returns PM Command
  */
-
-
 const deleteEmptyParagraphAndMoveBlockUp = canNextNodeMoveUp => {
   return (state, dispatch, view) => {
     const {
@@ -319,19 +284,14 @@ const deleteEmptyParagraphAndMoveBlockUp = canNextNodeMoveUp => {
       $pos
     } = walkNextNode($head);
     const nextPMNode = doc.nodeAt($pos.pos - 1);
-
     if (empty && nextPMNode && canNextNodeMoveUp(nextPMNode) && isEmptyParagraph(parent) && view !== null && view !== void 0 && view.endOfTextblock('right')) {
       tr.deleteRange(pos - 1, pos + 1);
-
       if (dispatch) {
         dispatch(tr);
       }
-
       return true;
     }
-
     return false;
   };
 };
-
 export { filter, isEmptySelectionAtStart, isEmptySelectionAtEnd, isFirstChildOfParent, isNthParentOfType, findCutBefore, toggleMark, applyMarkOnRange, withScrollIntoView, walkNextNode, walkPrevNode, insertContentDeleteRange, selectNode, deleteEmptyParagraphAndMoveBlockUp };

package/dist/es2019/utils/count-nodes.js

@@ -1,35 +1,27 @@
 export function countNodes(state) {
   var _nodeTypes$extension, _nodeTypes$inlineExte, _nodeTypes$bodiedExte;
-
   const nodeCount = {};
   const extensionNodeCount = {};
   const nodeTypes = state.schema.nodes;
   const extensionNodeTypes = [(_nodeTypes$extension = nodeTypes.extension) === null || _nodeTypes$extension === void 0 ? void 0 : _nodeTypes$extension.name, (_nodeTypes$inlineExte = nodeTypes.inlineExtension) === null || _nodeTypes$inlineExte === void 0 ? void 0 : _nodeTypes$inlineExte.name, (_nodeTypes$bodiedExte = nodeTypes.bodiedExtension) === null || _nodeTypes$bodiedExte === void 0 ? void 0 : _nodeTypes$bodiedExte.name];
   state.doc.descendants(node => {
     var _node$attrs;
-
     const nodeName = node.type.name;
-
     if (nodeName in nodeCount) {
       nodeCount[nodeName]++;
     } else {
       nodeCount[nodeName] = 1;
     }
-
     let extensionNodeName = nodeName;
-
     if (extensionNodeTypes.includes(extensionNodeName) && (_node$attrs = node.attrs) !== null && _node$attrs !== void 0 && _node$attrs.extensionType) {
       var _node$attrs2;
-
       extensionNodeName = `${node.attrs.extensionType} - ${(_node$attrs2 = node.attrs) === null || _node$attrs2 === void 0 ? void 0 : _node$attrs2.extensionKey}`;
-
       if (extensionNodeName in extensionNodeCount) {
         extensionNodeCount[extensionNodeName]++;
       } else {
         extensionNodeCount[extensionNodeName] = 1;
       }
     }
-
     return true;
   });
   return {

package/dist/es2019/utils/deprecation-warnings.js

@@ -1,12 +1,9 @@
 import { nextMajorVersion } from '../version-wrapper';
-
 const deprecationWarnings = (className, props, deprecations) => {
   if (process.env.NODE_ENV === 'production') {
     return;
   }
-
   const nextVersion = nextMajorVersion();
-
   for (const deprecation of deprecations) {
     const {
       property,
@@ -14,7 +11,6 @@ const deprecationWarnings = (className, props, deprecations) => {
       description = '',
       condition = () => true
     } = deprecation;
-
     if (props.hasOwnProperty(property)) {
       if (condition(props)) {
         // eslint-disable-next-line no-console
@@ -23,5 +19,4 @@ const deprecationWarnings = (className, props, deprecations) => {
     }
   }
 };
-
 export default deprecationWarnings;

package/dist/es2019/utils/document-logger.js

@@ -57,30 +57,23 @@ const hash = {
     annotation: 'anno'
   }
 };
-
 function shortHash(type, isMark) {
   const code = hash[isMark ? 'marks' : 'nodes'][type];
   return code ? code : type;
 }
-
 function compactStringifier(node) {
   var _node$marks;
-
   const isContentEmpty = !node.content;
   const isTextNode = (node === null || node === void 0 ? void 0 : node.type) === 'text';
   const hasMarks = (_node$marks = node.marks) === null || _node$marks === void 0 ? void 0 : _node$marks.length;
   const isContentArray = Array.isArray(node.content);
-
   const marks = child => {
     if (hasMarks) {
       return node.marks.reduce((str, mark) => `${shortHash(mark, true)}(${str})`, child);
     }
-
     return child;
   };
-
   let content;
-
   if (isTextNode) {
     content = String(node.nodeSize);
   } else if (isContentEmpty) {
@@ -88,24 +81,19 @@ function compactStringifier(node) {
   } else if (isContentArray) {
     content = node.content.map(node => compactStringifier(node)).join(',');
   }
-
   return marks(`${shortHash(node.type, false)}(${content})`);
 }
-
 export const getDocStructure = (doc, options) => {
   try {
     const result = getBlockNode(doc, 0);
-
     if (options !== null && options !== void 0 && options.compact) {
       return compactStringifier(result);
     }
-
     return result;
   } catch (error) {
     return `Error logging document structure: ${error}`;
   }
 };
-
 const getBlockNode = (node, pos) => {
   const blockNode = {
     type: node.type.name,
@@ -113,30 +101,23 @@ const getBlockNode = (node, pos) => {
     nodeSize: node.nodeSize
   };
   const content = getBlockNodeContent(node.content, pos);
-
   if (content.length > 0) {
     blockNode.content = content;
   }
-
   const marks = getMarks(node);
-
   if (marks.length > 0) {
     blockNode.marks = marks;
   }
-
   return blockNode;
 };
-
 const getBlockNodeContent = (node, pos) => {
   if (!node || !node.content || !node.content.length) {
     return [];
   }
-
   let blockNodeContent = [];
   const {
     content
   } = node;
-
   if (content[0].isBlock) {
     // children are block nodes
     let prevNode;
@@ -151,10 +132,8 @@ const getBlockNodeContent = (node, pos) => {
     blockNodeContent = result.inlineNodes;
     pos = result.pos;
   }
-
   return blockNodeContent;
 };
-
 const getInlineNodes = (nodes, pos) => {
   let inlineNodes = nodes.map(node => {
     const {
@@ -166,11 +145,9 @@ const getInlineNodes = (nodes, pos) => {
       nodeSize
     };
     const marks = getMarks(node);
-
     if (marks.length > 0) {
       inlineNode.marks = marks;
     }
-
     pos += nodeSize;
     return inlineNode;
   });
@@ -179,5 +156,4 @@ const getInlineNodes = (nodes, pos) => {
     pos
   };
 };
-
 const getMarks = node => node.marks.map(mark => mark.type.name);