@atlaskit/editor-core 178.1.1 → 179.0.0

package/dist/es2019/utils/index.js

@@ -15,30 +15,26 @@ export { isParagraph, isText, isLinkMark, validateNodes } from './nodes';
 export { normaliseNestedLayout, setNodeSelection, setAllSelection, setGapCursorSelection, setCellSelection, setTextSelection, isValidPosition } from './selection';
 export { containsClassName } from './dom';
 export { default as measurements } from './performance/measure-enum';
-
 function validateNode(_node) {
   return false;
 }
-
 function isMarkTypeCompatibleWithMark(markType, mark) {
   return !mark.type.excludes(markType) && !markType.excludes(mark.type);
 }
-
 function isMarkTypeAllowedInNode(markType, state) {
   return toggleMark(markType)(state);
 }
-
 export function canMoveUp(state) {
   const {
     selection,
     doc
   } = state;
+
   /**
    * If there's a media element on the selection,
    * add text blocks with arrow navigation.
    * Also, the selection could be media | mediaGroup.
    */
-
   if (selection instanceof NodeSelection) {
     if (selection.node.type.name === 'media') {
       /** Weird way of checking if the previous element is a paragraph */
@@ -49,13 +45,11 @@ export function canMoveUp(state) {
       return !!(mediaGroupAncestorNode && mediaGroupAncestorNode.type.name === 'paragraph');
     }
   }
-
   if (selection instanceof TextSelection) {
     if (!selection.empty) {
       return true;
     }
   }
-
   return !atTheBeginningOfDoc(state);
 }
 export function canMoveDown(state) {
@@ -63,12 +57,12 @@ export function canMoveDown(state) {
     selection,
     doc
   } = state;
+
   /**
    * If there's a media element on the selection,
    * add text blocks with arrow navigation.
    * Also, the selection could be media | mediaGroup.
    */
-
   if (selection instanceof NodeSelection) {
     if (selection.node.type.name === 'media') {
       const nodeAfter = doc.nodeAt(selection.$head.after());
@@ -77,13 +71,11 @@ export function canMoveDown(state) {
       return !(selection.$head.parentOffset === selection.$anchor.parent.content.size);
     }
   }
-
   if (selection instanceof TextSelection) {
     if (!selection.empty) {
       return true;
     }
   }
-
   return !atTheEndOfDoc(state);
 }
 export function isSelectionInsideLastNodeInDocument(selection) {
@@ -94,44 +86,39 @@ export function isSelectionInsideLastNodeInDocument(selection) {
 export function getCursor(selection) {
   return selection.$cursor || undefined;
 }
+
 /**
  * Check if a mark is allowed at the current selection / cursor based on a given state.
  * This method looks at both the currently active marks on the transaction, as well as
  * the node and marks at the current selection to determine if the given mark type is
  * allowed.
  */
-
 export function isMarkTypeAllowedInCurrentSelection(markType, state) {
   if (state.selection instanceof FakeTextCursorSelection) {
     return true;
   }
-
   if (!isMarkTypeAllowedInNode(markType, state)) {
     return false;
   }
-
   const {
     empty,
     $cursor,
     ranges
   } = state.selection;
-
   if (empty && !$cursor) {
     return false;
   }
+  let isCompatibleMarkType = mark => isMarkTypeCompatibleWithMark(markType, mark);
 
-  let isCompatibleMarkType = mark => isMarkTypeCompatibleWithMark(markType, mark); // Handle any new marks in the current transaction
-
-
+  // Handle any new marks in the current transaction
   if (state.tr.storedMarks && !state.tr.storedMarks.every(isCompatibleMarkType)) {
     return false;
   }
-
   if ($cursor) {
     return $cursor.marks().every(isCompatibleMarkType);
-  } // Check every node in a selection - ensuring that it is compatible with the current mark type
-
+  }
 
+  // Check every node in a selection - ensuring that it is compatible with the current mark type
   return ranges.every(({
     $from,
     $to
@@ -146,33 +133,34 @@ export function isMarkTypeAllowedInCurrentSelection(markType, state) {
 export function createSliceWithContent(content, state) {
   return new Slice(Fragment.from(state.schema.text(content)), 0, 0);
 }
+
 /**
  * Determines if content inside a selection can be joined with the next block.
  * We need this check since the built-in method for "joinDown" will join a orderedList with bulletList.
  */
-
 export function canJoinDown(selection, doc, nodeType) {
   return checkNodeDown(selection, doc, node => node.type === nodeType);
 }
 export function checkNodeDown(selection, doc, filter) {
-  const ancestorDepth = findAncestorPosition(doc, selection.$to).depth; // Top level node
+  const ancestorDepth = findAncestorPosition(doc, selection.$to).depth;
 
+  // Top level node
   if (ancestorDepth === 0) {
     return false;
   }
-
   const res = doc.resolve(selection.$to.after(ancestorDepth));
   return res.nodeAfter ? filter(res.nodeAfter) : false;
 }
+
 /**
  * Determines if content inside a selection can be joined with the previous block.
  * We need this check since the built-in method for "joinUp" will join a orderedList with bulletList.
  */
-
 export function canJoinUp(selection, doc, nodeType) {
   const res = doc.resolve(selection.$from.before(findAncestorPosition(doc, selection.$from).depth));
   return res.nodeBefore && res.nodeBefore.type === nodeType;
 }
+
 /**
  * Finds all "selection-groups" within a range. A selection group is based on ancestors.
  *
@@ -189,12 +177,10 @@ export function canJoinUp(selection, doc, nodeType) {
  *
  * The output will be two selection-groups. One within the ul and one with the two paragraphs.
  */
-
 export function getGroupsInRange(doc, $from, $to, isNodeValid = validateNode) {
   const groups = Array();
   const commonAncestor = hasCommonAncestor(doc, $from, $to);
   const fromAncestor = findAncestorPosition(doc, $from);
-
   if (commonAncestor || fromAncestor.depth === 1 && isNodeValid($from.node(1))) {
     groups.push({
       $from,
@@ -202,15 +188,13 @@ export function getGroupsInRange(doc, $from, $to, isNodeValid = validateNode) {
     });
   } else {
     let current = $from;
-
     while (current.pos < $to.pos) {
       let ancestorPos = findAncestorPosition(doc, current);
-
       while (ancestorPos.depth > 1) {
         ancestorPos = findAncestorPosition(doc, ancestorPos);
       }
-
-      const endPos = doc.resolve(Math.min( // should not be smaller then start position in case of an empty paragraph for example.
+      const endPos = doc.resolve(Math.min(
+      // should not be smaller then start position in case of an empty paragraph for example.
       Math.max(ancestorPos.start(ancestorPos.depth), ancestorPos.end(ancestorPos.depth) - 3), $to.pos));
       groups.push({
         $from: current,
@@ -219,42 +203,35 @@ export function getGroupsInRange(doc, $from, $to, isNodeValid = validateNode) {
       current = doc.resolve(Math.min(endPos.after(1) + 1, doc.nodeSize - 2));
     }
   }
-
   return groups;
 }
+
 /**
  * Traverse the document until an "ancestor" is found. Any nestable block can be an ancestor.
  */
-
 export function findAncestorPosition(doc, pos) {
   const nestableBlocks = ['blockquote', 'bulletList', 'orderedList'];
-
   if (pos.depth === 1) {
     return pos;
   }
-
   let node = pos.node(pos.depth);
   let newPos = pos;
-
   while (pos.depth >= 1) {
     pos = doc.resolve(pos.before(pos.depth));
     node = pos.node(pos.depth);
-
     if (node && nestableBlocks.indexOf(node.type.name) !== -1) {
       newPos = pos;
     }
   }
-
   return newPos;
 }
+
 /**
  * Determine if two positions have a common ancestor.
  */
-
 export function hasCommonAncestor(doc, $from, $to) {
   let current;
   let target;
-
   if ($from.depth > $to.depth) {
     current = findAncestorPosition(doc, $from);
     target = findAncestorPosition(doc, $to);
@@ -262,29 +239,27 @@ export function hasCommonAncestor(doc, $from, $to) {
     current = findAncestorPosition(doc, $to);
     target = findAncestorPosition(doc, $from);
   }
-
   while (current.depth > target.depth && current.depth > 1) {
     current = findAncestorPosition(doc, current);
   }
-
   return current.node(current.depth) === target.node(target.depth);
 }
+
 /**
  * Takes a selection $from and $to and lift all text nodes from their parents to document-level
  */
-
 export function liftSelection(tr, doc, $from, $to) {
   let startPos = $from.start($from.depth);
   let endPos = $to.end($to.depth);
   const target = Math.max(0, findAncestorPosition(doc, $from).depth - 1);
   tr.doc.nodesBetween(startPos, endPos, (node, pos) => {
-    if (node.isText || // Text node
+    if (node.isText ||
+    // Text node
     node.isTextblock && !node.textContent // Empty paragraph
     ) {
       const res = tr.doc.resolve(tr.mapping.map(pos));
       const sel = new NodeSelection(res);
       const range = sel.$from.blockRange(sel.$to);
-
       if (liftTarget(range) !== undefined) {
         tr.lift(range, target);
       }
@@ -301,10 +276,10 @@ export function liftSelection(tr, doc, $from, $to) {
     $to: tr.doc.resolve(endPos)
   };
 }
+
 /**
  * Lift nodes in block to one level above.
  */
-
 export function liftSiblingNodes(view) {
   const {
     tr
@@ -318,10 +293,10 @@ export function liftSiblingNodes(view) {
   const range = blockStart.blockRange(blockEnd);
   view.dispatch(tr.lift(range, blockStart.depth - 1));
 }
+
 /**
  * Lift sibling nodes to document-level and select them.
  */
-
 export function liftAndSelectSiblingNodes(view) {
   const {
     tr
@@ -331,8 +306,8 @@ export function liftAndSelectSiblingNodes(view) {
     $to
   } = view.state.selection;
   const blockStart = tr.doc.resolve($from.start($from.depth - 1));
-  const blockEnd = tr.doc.resolve($to.end($to.depth - 1)); // TODO: [ts30] handle void and null properly
-
+  const blockEnd = tr.doc.resolve($to.end($to.depth - 1));
+  // TODO: [ts30] handle void and null properly
   const range = blockStart.blockRange(blockEnd);
   tr.setSelection(new TextSelection(blockStart, blockEnd));
   tr.lift(range, blockStart.depth - 1);
@@ -341,11 +316,9 @@ export function liftAndSelectSiblingNodes(view) {
 export function wrapIn(nodeType, tr, $from, $to) {
   const range = $from.blockRange($to);
   const wrapping = range && findWrapping(range, nodeType);
-
   if (wrapping) {
     tr = tr.wrap(range, wrapping).scrollIntoView();
   }
-
   return tr;
 }
 const transformer = new JSONTransformer();
@@ -355,24 +328,22 @@ export function toJSON(node) {
 export function nodeToJSON(node) {
   return transformer.encodeNode(node);
 }
+
 /**
  * Repeating string for multiple times
  */
-
 export function stringRepeat(text, length) {
   let result = '';
-
   for (let x = 0; x < length; x++) {
     result += text;
   }
-
   return result;
 }
+
 /*
  * From Modernizr
  * Returns the kind of transitionevent available for the element
  */
-
 export function whichTransitionEvent() {
   const el = document.createElement('fakeelement');
   const transitions = {
@@ -381,7 +352,6 @@ export function whichTransitionEvent() {
     OTransition: 'oTransitionEnd',
     WebkitTransition: 'webkitTransitionEnd'
   };
-
   for (const t in transitions) {
     if (el.style[t] !== undefined) {
       // Use a generic as the return type because TypeScript doesnt know
@@ -391,16 +361,14 @@ export function whichTransitionEvent() {
       return transitions[t];
     }
   }
-
   return;
 }
+
 /**
  * Function will create a list of wrapper blocks present in a selection.
  */
-
 function getSelectedWrapperNodes(state) {
   const nodes = [];
-
   if (state.selection) {
     const {
       $from,
@@ -424,14 +392,12 @@ function getSelectedWrapperNodes(state) {
       }
     });
   }
-
   return nodes;
 }
+
 /**
  * Function will check if changing block types: Paragraph, Heading is enabled.
  */
-
-
 export function areBlockTypesDisabled(state) {
   const nodesTypes = getSelectedWrapperNodes(state);
   const {
@@ -461,46 +427,38 @@ export const isEmptyNode = schema => {
     mediaGroup,
     mediaSingle
   } = schema.nodes;
-
   const innerIsEmptyNode = node => {
     switch (node.type) {
       case media:
       case mediaGroup:
       case mediaSingle:
         return false;
-
       case paragraph:
       case codeBlock:
       case heading:
       case taskItem:
       case decisionItem:
         return node.content.size === 0;
-
       case blockquote:
       case panel:
       case listItem:
         return node.content.size === 2 && innerIsEmptyNode(node.content.firstChild);
-
       case bulletList:
       case orderedList:
         return node.content.size === 4 && innerIsEmptyNode(node.content.firstChild);
-
       case taskList:
       case decisionList:
         return node.content.size === 2 && innerIsEmptyNode(node.content.firstChild);
-
       case doc:
         let isEmpty = true;
         node.content.forEach(child => {
           isEmpty = isEmpty && innerIsEmptyNode(child);
         });
         return isEmpty;
-
       default:
         return isNodeEmpty(node);
     }
   };
-
   return innerIsEmptyNode;
 };
 export const insideTableCell = state => {
@@ -550,20 +508,20 @@ export function dedupe(list = [], iteratee = p => p) {
       `-.__.,--'
     Gotta go fast!
   */
+
   const seen = new Set();
   list.forEach(l => seen.add(iteratee(l)));
   return list.filter(l => {
     const it = iteratee(l);
-
     if (seen.has(it)) {
       seen.delete(it);
       return true;
     }
-
     return false;
   });
 }
 export { isTextSelection, isElementInTableCell, isLastItemMediaGroup, nonNullable } from '@atlaskit/editor-common/utils';
+
 /** Helper type for single arg function */
 
 /**
@@ -582,11 +540,9 @@ export function pipe(...fns) {
   if (fns.length === 0) {
     return a => a;
   }
-
   if (fns.length === 1) {
     return fns[0];
   }
-
   return fns.reduce((prevFn, nextFn) => (...args) => nextFn(prevFn(...args)));
 }
 export function shallowEqual(obj1 = {}, obj2 = {}) {

package/dist/es2019/utils/input-rules.js

@@ -11,13 +11,12 @@ export const ruleWithAnalytics = getPayload => {
     const onHandlerApply = (state, tr, matchResult) => {
       const payload = typeof getPayload === 'function' ? getPayload(state, matchResult) : getPayload;
       addAnalytics(state, tr, payload);
-
       if (originalRule.onHandlerApply) {
         originalRule.onHandlerApply(state, tr, matchResult);
       }
     };
-
-    return { ...originalRule,
+    return {
+      ...originalRule,
       onHandlerApply
     };
   };
@@ -26,13 +25,12 @@ export const ruleWithTransform = transform => {
   return originalRule => {
     const onHandlerApply = (state, tr, matchResult) => {
       transform(state, tr);
-
       if (originalRule.onHandlerApply) {
         originalRule.onHandlerApply(state, tr, matchResult);
       }
     };
-
-    return { ...originalRule,
+    return {
+      ...originalRule,
       onHandlerApply
     };
   };
@@ -51,7 +49,6 @@ export const createPlugin = (pluginName, rules, options = {}) => {
     isBlockNodeRule = false,
     allowInsertTextOnDocument = true
   } = options;
-
   const onInputEvent = ({
     state,
     from,
@@ -59,14 +56,11 @@ export const createPlugin = (pluginName, rules, options = {}) => {
   }) => {
     const unsupportedMarks = isBlockNodeRule ? ['code', 'link', 'typeAheadQuery'] : ['code'];
     const $from = state.selection.$from;
-
     if ($from.parent.type.spec.code || !(state.selection instanceof TextSelection) && !(state.selection instanceof GapCursorSelection) || hasUnsupportedMarks(state, from, to, unsupportedMarks) || isBlockNodeRule && isCursorInsideUnsupportedMarks(state, unsupportedMarks)) {
       return false;
     }
-
     return true;
   };
-
   return createInputRulePlugin(pluginName, rules, {
     allowInsertTextOnDocument,
     onInputEvent,
@@ -85,14 +79,11 @@ export const createWrappingTextBlockRule = ({
     const $start = state.doc.resolve(fixedStart);
     const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
     const nodeBefore = $start.node(-1);
-
     if (nodeBefore && !nodeBefore.canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)) {
       return null;
     }
-
     return state.tr.delete(fixedStart, end).setBlockType(fixedStart, fixedStart, nodeType, attrs);
   };
-
   return createRule(match, handler);
 };
 export const createWrappingJoinRule = ({
@@ -109,49 +100,38 @@ export const createWrappingJoinRule = ({
     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);
     const featureFlags = getFeatureFlags(state);
-
     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))) {
           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))) {
       tr.join(fixedStart - 1);
     }
-
     return tr;
   };
-
   return createRule(match, handler);
 };
 export const createJoinNodesRule = (match, nodeType) => {
@@ -162,32 +142,24 @@ export const createJoinNodesRule = (match, nodeType) => {
     joinPredicate: (_, node) => node.type === nodeType
   });
 };
-
 const hasUnsupportedMarks = (state, start, end, marksNameUnsupported) => {
   const isUnsupportedMark = node => (marksNameUnsupported || []).includes(node.type.name);
-
   const $from = state.doc.resolve(start);
   const $to = state.doc.resolve(end);
   const marksInSelection = start === end ? $from.marks() : $from.marksAcross($to);
   return (marksInSelection || []).some(isUnsupportedMark);
 };
-
 const isCursorInsideUnsupportedMarks = (state, marksNameUnsupported) => {
   var _$cursor$nodeBefore, _$cursor$nodeBefore$m;
-
   const {
     selection
   } = state;
-
   if (!(selection instanceof TextSelection)) {
     return false;
   }
-
   const {
     $cursor
   } = selection;
-
   const isUnsupportedMark = node => marksNameUnsupported.includes(node.type.name);
-
   return Boolean($cursor === null || $cursor === void 0 ? void 0 : (_$cursor$nodeBefore = $cursor.nodeBefore) === null || _$cursor$nodeBefore === void 0 ? void 0 : (_$cursor$nodeBefore$m = _$cursor$nodeBefore.marks) === null || _$cursor$nodeBefore$m === void 0 ? void 0 : _$cursor$nodeBefore$m.some(isUnsupportedMark));
 };