@atlaskit/editor-core 178.1.1 → 179.0.0

package/dist/es2019/utils/insert.js

@@ -6,23 +6,18 @@ import { isEmptyParagraph } from './document';
 import { GapCursorSelection, Side } from '../plugins/selection/gap-cursor-selection';
 import { normaliseNestedLayout } from './selection';
 export let LookDirection;
-
 (function (LookDirection) {
   LookDirection["Before"] = "before";
   LookDirection["After"] = "after";
 })(LookDirection || (LookDirection = {}));
-
 const isLastChild = ($pos, doc) => doc.resolve($pos.after()).node().lastChild === $pos.node();
-
 const isFirstChild = ($pos, doc) => doc.resolve($pos.before()).node().firstChild === $pos.node();
-
 const nodeIsInsideAList = tr => {
   const {
     nodes
   } = tr.doc.type.schema;
   return hasParentNodeOfType([nodes.orderedList, nodes.bulletList])(tr.selection);
 };
-
 const insertBeforeOrAfter = (tr, lookDirection, $parentPos, $proposedPosition, content) => {
   /**
    * This block caters for the first item in a parent with the cursor being at the very start
@@ -34,45 +29,44 @@ const insertBeforeOrAfter = (tr, lookDirection, $parentPos, $proposedPosition, c
    *  li
    *  li Scenario two{<>}
    */
+
   if (isFirstChild($proposedPosition, tr.doc) && lookDirection === LookDirection.Before || isLastChild($proposedPosition, tr.doc) && lookDirection === LookDirection.After) {
     return tr.insert($parentPos[lookDirection](), content);
   }
-
   return tr.insert($proposedPosition[lookDirection](), content);
-}; // FIXME: A more sustainable and configurable way to choose when to split
-
+};
 
+// FIXME: A more sustainable and configurable way to choose when to split
 const shouldSplit = (nodeType, schemaNodes) => {
   return [schemaNodes.bulletList, schemaNodes.orderedList, schemaNodes.panel].includes(nodeType);
 };
-
 export const safeInsert = (content, position) => tr => {
   var _tr$selection$$from$n;
-
   const {
     nodes
   } = tr.doc.type.schema;
-  const whitelist = [nodes.rule, nodes.mediaSingle]; // fallback if the node to insert is not in the whitelist, or if the insertion should happen within a list.
+  const whitelist = [nodes.rule, nodes.mediaSingle];
 
+  // fallback if the node to insert is not in the whitelist, or if the insertion should happen within a list.
   if (content instanceof Fragment || !whitelist.includes(content.type) || nodeIsInsideAList(tr)) {
     return null;
-  } // Check for selection
-
+  }
 
+  // Check for selection
   if (!tr.selection.empty || isNodeSelection(tr.selection)) {
     // NOT IMPLEMENTED
     return null;
   }
-
   const {
     $from
   } = tr.selection;
   const $insertPos = position ? tr.doc.resolve(position) : isNodeSelection(tr.selection) ? tr.doc.resolve($from.pos + 1) : $from;
   let lookDirection;
   const insertPosEnd = $insertPos.end();
-  const insertPosStart = $insertPos.start(); // When parent node is an empty paragraph,
-  // check the empty paragraph is the first or last node of its parent.
+  const insertPosStart = $insertPos.start();
 
+  // When parent node is an empty paragraph,
+  // check the empty paragraph is the first or last node of its parent.
   if (isEmptyParagraph($insertPos.parent)) {
     if (isLastChild($insertPos, tr.doc)) {
       lookDirection = LookDirection.After;
@@ -86,10 +80,8 @@ export const safeInsert = (content, position) => tr => {
       lookDirection = LookDirection.Before;
     }
   }
-
   const grandParentNodeType = (_tr$selection$$from$n = tr.selection.$from.node(-1)) === null || _tr$selection$$from$n === void 0 ? void 0 : _tr$selection$$from$n.type;
   const parentNodeType = tr.selection.$from.parent.type;
-
   if (!lookDirection && !shouldSplitSelectedNodeOnNodeInsertion({
     parentNodeType,
     grandParentNodeType,
@@ -98,63 +90,55 @@ export const safeInsert = (content, position) => tr => {
     // node to be inserted is an invalid child of selection so insert below selected node
     return pmSafeInsert(content, tr.selection.from)(tr);
   }
-
   if (!lookDirection) {
     // fallback to consumer for now
     return null;
-  } // Replace empty paragraph
-
+  }
 
+  // Replace empty paragraph
   if (isEmptyParagraph($insertPos.parent) && canInsert(tr.doc.resolve($insertPos[lookDirection]()), content)) {
     return finaliseInsert(tr.replaceWith($insertPos.before(), $insertPos.after(), content), -1);
   }
-
   let $proposedPosition = $insertPos;
-
   while ($proposedPosition.depth > 0) {
     const $parentPos = tr.doc.resolve($proposedPosition[lookDirection]());
-    const parentNode = $parentPos.node(); // Insert at position (before or after target pos)
+    const parentNode = $parentPos.node();
 
+    // Insert at position (before or after target pos)
     if (canInsert($proposedPosition, content)) {
       return finaliseInsert(tr.insert($proposedPosition.pos, content), content.nodeSize);
-    } // If we can't insert, and we think we should split, we fallback to consumer for now
-
+    }
 
+    // If we can't insert, and we think we should split, we fallback to consumer for now
     if (shouldSplit(parentNode.type, tr.doc.type.schema.nodes)) {
       return finaliseInsert(insertBeforeOrAfter(tr, lookDirection, $parentPos, $proposedPosition, content), content.nodeSize);
-    } // Can not insert into current parent, step up one parent
-
+    }
 
+    // Can not insert into current parent, step up one parent
     $proposedPosition = $parentPos;
   }
-
   return finaliseInsert(tr.insert($proposedPosition.pos, content), content.nodeSize);
 };
-
 const finaliseInsert = (tr, nodeLength) => {
   const lastStep = tr.steps[tr.steps.length - 1];
-
   if (!(lastStep instanceof ReplaceStep || lastStep instanceof ReplaceAroundStep)) {
     return null;
-  } // Place gap cursor after the newly inserted node
-
+  }
 
+  // Place gap cursor after the newly inserted node
   const gapCursorPos = lastStep.to + lastStep.slice.openStart + nodeLength;
   return tr.setSelection(new GapCursorSelection(tr.doc.resolve(gapCursorPos), Side.RIGHT)).scrollIntoView();
 };
+
 /**
  * Method extracted from typeahed plugin to be shared with the element browser on handling element insertion.
  */
-
-
 export const insertSelectedItem = (maybeNode, opts = {}) => (state, tr, start) => {
   if (!maybeNode) {
     return tr;
   }
-
   const isInputFragment = maybeNode instanceof Fragment;
   let node;
-
   try {
     node = maybeNode instanceof Node || isInputFragment ? maybeNode : typeof maybeNode === 'string' ? state.schema.text(maybeNode) : Node.fromJSON(state.schema, maybeNode);
   } catch (e) {
@@ -162,9 +146,9 @@ export const insertSelectedItem = (maybeNode, opts = {}) => (state, tr, start) =
     console.error(e);
     return tr;
   }
-
   if (node.isText) {
     tr = tr.replaceWith(start, start, node);
+
     /**
      *
      * Replacing a type ahead query mark with a block node.
@@ -172,6 +156,7 @@ export const insertSelectedItem = (maybeNode, opts = {}) => (state, tr, start) =
      */
   } else if (node.isBlock) {
     tr = pmSafeInsert(normaliseNestedLayout(state, node), undefined, true)(tr);
+
     /**
      *
      * Replacing a type ahead query mark with an inline node.
@@ -180,7 +165,6 @@ export const insertSelectedItem = (maybeNode, opts = {}) => (state, tr, start) =
   } else if (node.isInline || isInputFragment) {
     const fragment = isInputFragment ? node : Fragment.fromArray([node, state.schema.text(' ')]);
     tr = tr.replaceWith(start, start, fragment);
-
     if (opts.selectInlineNode) {
       // Select inserted node
       tr = tr.setSelection(NodeSelection.create(tr.doc, start));
@@ -189,15 +173,14 @@ export const insertSelectedItem = (maybeNode, opts = {}) => (state, tr, start) =
       tr = tr.setSelection(Selection.near(tr.doc.resolve(start + fragment.size)));
     }
   }
-
   return tr;
 };
+
 /**
  * ED-14584: Util to check if the destination node is a paragraph & the
  * content being inserted is a valid child of the grandparent node.
  * In this case, the destination node should split
  */
-
 export const shouldSplitSelectedNodeOnNodeInsertion = ({
   parentNodeType,
   grandParentNodeType,
@@ -206,6 +189,5 @@ export const shouldSplitSelectedNodeOnNodeInsertion = ({
   if (parentNodeType.name === 'doc' || parentNodeType.name === 'paragraph' && grandParentNodeType.validContent(Fragment.from(content))) {
     return true;
   }
-
   return false;
 };

package/dist/es2019/utils/is-text-input.js

@@ -1,11 +1,9 @@
 import { ReplaceStep } from 'prosemirror-transform';
 export const isTextInput = tr => {
   const [step] = tr.steps;
-
   if (!step || !(step instanceof ReplaceStep)) {
     return false;
   }
-
   const {
     slice: {
       content

package/dist/es2019/utils/keymap.js

@@ -1,6 +1,7 @@
 import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { keydownHandler } from 'prosemirror-keymap';
 import { base, keyName } from 'w3c-keyname';
+
 /**
  * A workaround for mostly Cyrillic but should have a positive affect
  * on other languages / layouts. Attempts a similar approach to OS X.
@@ -8,15 +9,14 @@ import { base, keyName } from 'w3c-keyname';
  * @see https://github.com/ProseMirror/prosemirror/issues/957
  * @param bindings
  */
-
 export function keymap(bindings) {
   return new SafePlugin({
     props: {
       handleKeyDown(view, event) {
         const name = keyName(event);
         let keyboardEvent = event;
-
-        if (event.ctrlKey && name.length === 1 && // Check the unicode of the character to
+        if (event.ctrlKey && name.length === 1 &&
+        // Check the unicode of the character to
         // assert that its not an ASCII character.
         // These are characters outside Latin's range.
         /[^\u0000-\u007f]/.test(name)) {
@@ -26,10 +26,8 @@ export function keymap(bindings) {
             ctrlKey: true
           });
         }
-
         return keydownHandler(bindings)(view, keyboardEvent);
       }
-
     }
   });
 }

package/dist/es2019/utils/linking-utils.js

@@ -10,31 +10,26 @@ export const buildEditLinkPayload = type => {
     eventType: EVENT_TYPE.UI
   };
 };
-
 const mapLinkTypeToCardAppearance = type => {
   switch (type) {
     case ACTION_SUBJECT_ID.CARD_INLINE:
       {
         return 'inline';
       }
-
     case ACTION_SUBJECT_ID.CARD_BLOCK:
       {
         return 'block';
       }
-
     case ACTION_SUBJECT_ID.EMBEDS:
       {
         return 'embed';
       }
-
     default:
       {
         return 'url';
       }
   }
 };
-
 export const buildVisitedLinkPayload = type => {
   return type === ACTION_SUBJECT_ID.HYPERLINK ? {
     action: ACTION.VISITED,

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

@@ -1,5 +1,6 @@
-import { indentList, outdentList, toggleOrderedList, toggleBulletList } from '../plugins/list/commands'; // getListCommands provides commands for manipulating lists in the document.
+import { indentList, outdentList, toggleOrderedList, toggleBulletList } from '../plugins/list/commands';
 
+// getListCommands provides commands for manipulating lists in the document.
 export const getListCommands = () => {
   return {
     indentList,

package/dist/es2019/utils/mark.js

@@ -9,28 +9,22 @@ export const isMarkAllowedInRange = (doc, ranges, type) => {
       if (can) {
         return false;
       }
-
       can = node.inlineContent && node.type.allowsMarkType(type);
       return;
     });
-
     if (can) {
       return can;
     }
   }
-
   return false;
 };
 export const isMarkExcluded = (type, marks) => {
   if (marks) {
     return marks.some(mark => mark.type !== type && mark.type.excludes(type));
   }
-
   return false;
 };
-
 const not = fn => arg => !fn(arg);
-
 export const removeBlockMarks = (state, marks) => {
   const {
     selection,
@@ -38,25 +32,21 @@ export const removeBlockMarks = (state, marks) => {
   } = state;
   let {
     tr
-  } = state; // Marks might not exist in Schema
+  } = state;
 
+  // Marks might not exist in Schema
   const marksToRemove = marks.filter(Boolean);
-
   if (marksToRemove.length === 0) {
     return undefined;
   }
-  /** Saves an extra dispatch */
-
 
+  /** Saves an extra dispatch */
   let blockMarksExists = false;
-
   const hasMark = mark => marksToRemove.indexOf(mark.type) > -1;
   /**
    * When you need to toggle the selection
    * when another type which does not allow alignment is applied
    */
-
-
   state.doc.nodesBetween(selection.from, selection.to, (node, pos) => {
     if (node.type === schema.nodes.paragraph && node.marks.some(hasMark)) {
       blockMarksExists = true;
@@ -67,10 +57,10 @@ export const removeBlockMarks = (state, marks) => {
   });
   return blockMarksExists ? tr : undefined;
 };
+
 /**
  * Removes marks from nodes in the current selection that are not supported
  */
-
 export const sanitiseSelectionMarksForWrapping = (state, newParentType) => {
   const {
     tr
@@ -87,14 +77,12 @@ export const sanitiseMarksInSelection = (tr, newParentType) => {
   tr.doc.nodesBetween(from, to, (node, pos, parent) => {
     if (node.isText) {
       return false;
-    } // Skip expands and layouts if they are outside selection
+    }
+    // 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(mark => {
       if (!parent.type.allowsMarkType(mark.type) || newParentType && !newParentType.allowsMarkType(mark.type)) {
         const filteredMarks = node.marks.filter(m => m.type !== mark.type);

package/dist/es2019/utils/node-width.js

@@ -1,8 +1,8 @@
 export { getParentNodeWidth } from '@atlaskit/editor-common/node-width';
+
 /**
  * Returns the breakout mode of a given node
  */
-
 export const getBreakoutMode = (node, breakout) => {
   const breakoutMark = breakout && breakout.isInSet(node.marks);
   return breakoutMark ? breakoutMark.attrs.mode : node.attrs.layout;

package/dist/es2019/utils/nodes-by-localIds.js

@@ -1,31 +1,26 @@
 export const findNodePosByLocalIds = (state, ids, option = {}) => {
   var _state$doc$attrs;
-
   if (ids.length === 0) {
     return [];
   }
-
   const nodes = [];
   const localIdSet = new Set(ids);
-
   if (option.includeDocNode && localIdSet.has((_state$doc$attrs = state.doc.attrs) === null || _state$doc$attrs === void 0 ? void 0 : _state$doc$attrs.localId)) {
     nodes.push({
       node: state.doc,
       pos: 0
     });
   }
-
   state.doc.descendants((node, pos) => {
     var _node$attrs;
-
     if (localIdSet.has((_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId)) {
       nodes.push({
         node,
         pos
       });
-    } // stop traversing once we found all the nodes
-
+    }
 
+    // stop traversing once we found all the nodes
     return localIdSet.size !== nodes.length;
   });
   return nodes;
@@ -34,26 +29,22 @@ export const findNodePosByFragmentLocalIds = (state, ids) => {
   if (ids.length === 0) {
     return [];
   }
-
   const nodes = [];
   const localIdSet = new Set(ids);
   state.doc.descendants((node, pos) => {
     var _node$marks;
-
     const fragmentLocalIdList = (_node$marks = node.marks) === null || _node$marks === void 0 ? void 0 : _node$marks.filter(m => m.type.name === 'fragment').map(m => {
       var _m$attrs;
-
       return (_m$attrs = m.attrs) === null || _m$attrs === void 0 ? void 0 : _m$attrs.localId;
     }).filter(id => id && localIdSet.has(id));
-
     if (fragmentLocalIdList.length > 0) {
       nodes.push({
         node,
         pos
       });
-    } // stop traversing once we found all the nodes
-
+    }
 
+    // stop traversing once we found all the nodes
     return localIdSet.size !== nodes.length;
   });
   return nodes;

package/dist/es2019/utils/performance/components/RenderTracking.js

@@ -12,7 +12,6 @@ export function RenderTracking(props) {
       if (!renderCount) {
         return;
       }
-
       debouncedHandleAnalyticsEvent({
         payload: {
           action: props.action,

package/dist/es2019/utils/performance/instrumented-plugin.js

@@ -15,10 +15,8 @@ export class InstrumentedPlugin extends SafePlugin {
       dispatchAnalyticsEvent
     } = options;
     const shouldOverrideApply = transactionTracking.enabled && transactionTracker || saferDispatchedTransactions || saferDispatchedTransactionsAnalyticsOnly;
-
     if (shouldOverrideApply && spec.state) {
       const originalApply = spec.state.apply.bind(spec.state);
-
       spec.state.apply = (aTr, value, oldState, newState) => {
         const self = this;
         const tr = saferDispatchedTransactions || saferDispatchedTransactionsAnalyticsOnly ? new Proxy(aTr, freezeUnsafeTransactionProperties({
@@ -27,11 +25,9 @@ export class InstrumentedPlugin extends SafePlugin {
           analyticsOnly: saferDispatchedTransactionsAnalyticsOnly
         })) : aTr;
         const shouldTrackTransactions = transactionTracker === null || transactionTracker === void 0 ? void 0 : transactionTracker.shouldTrackTransaction(transactionTracking);
-
         if (!shouldTrackTransactions || !transactionTracker) {
           return originalApply(tr, value, oldState, newState);
         }
-
         const {
           startMeasure,
           stopMeasure
@@ -43,34 +39,26 @@ export class InstrumentedPlugin extends SafePlugin {
         return result;
       };
     }
-
     if (uiTracking.enabled && spec.view) {
       const originalView = spec.view.bind(spec);
-
       spec.view = editorView => {
         const self = this;
         const measure = `🦉${self.key}::view::update`;
         const view = originalView(editorView);
-
         if (view.update) {
           const originalUpdate = view.update;
-
           view.update = (view, state) => {
             startMeasure(measure);
             originalUpdate(view, state);
             stopMeasure(measure, () => {});
           };
         }
-
         return view;
       };
     }
-
     super(spec);
   }
-
   static fromPlugin(plugin, options, transactionTracker) {
     return new InstrumentedPlugin(plugin.spec, options, transactionTracker);
   }
-
 }

package/dist/es2019/utils/performance/outlier.js

@@ -2,11 +2,9 @@ import { percentile } from './percentile';
 export const outlier = (input, factor) => {
   const q1 = percentile(input, 0.25);
   const q3 = percentile(input, 0.75);
-
   if (typeof q1 === 'undefined' || typeof q3 === 'undefined') {
     return;
   }
-
   const iqr = q3 - q1;
   return q3 + iqr * factor;
 };

package/dist/es2019/utils/performance/percentile.js

@@ -3,14 +3,11 @@ export const percentile = (input, fraction) => {
   const position = sorted.length * fraction;
   const base = Math.floor(position);
   const rest = position - base;
-
   if (rest > 0) {
     return sorted[base];
   }
-
   const item = sorted[base - 1];
   const next = sorted[base];
-
   if (typeof item !== 'undefined' && typeof next !== 'undefined') {
     return (item + next) / 2;
   }

package/dist/es2019/utils/performance/plugin-performance-observer.js

@@ -8,73 +8,58 @@ export class PluginPerformanceObserver {
       nodeCount: {},
       extensionNodeCount: {}
     }, 0]);
-
     _defineProperty(this, "getPlugins", () => []);
-
     _defineProperty(this, "getOptions", () => ({}));
-
     _defineProperty(this, "reportCount", 0);
-
     _defineProperty(this, "simpleObserver", new SimpleMeasurementLogger());
-
     _defineProperty(this, "onObserveration", entries => {
       const reports = entries.getEntriesByName(EVENT_NAME_DISPATCH_TRANSACTION).map(entry => PluginPerformanceReport.fromEntry(entry).withCount(++this.reportCount).withEntryList(entries).withNodes(...this.getNodeCounts()).withPlugins(this.getPlugins()).withOptions(this.getOptions()).toJSON());
       reports.filter(report => report.trigger !== 'none').forEach(report => this.callback(report));
     });
-
     this.callback = callback;
     this.observer = window.PerformanceObserver ? new PerformanceObserver(this.onObserveration) : {
       observe() {},
-
       disconnect() {},
-
       takeRecords() {
         return [];
       }
-
     };
   }
-
   get isSimpleTracking() {
     const {
       usePerformanceMarks = DEFAULT_USE_PERFORMANCE_MARK
     } = this.getOptions();
     return !usePerformanceMarks;
   }
-
   withNodeCounts(getNodeCounts) {
     this.getNodeCounts = () => {
       const start = performance.now();
       const result = getNodeCounts();
       return [result, performance.now() - start];
     };
-
     return this;
   }
-
   withPlugins(getPlugins) {
     this.getPlugins = getPlugins;
     return this;
   }
-
   withOptions(getOptions) {
     this.getOptions = getOptions;
     return this;
   }
-
   withTransactionTracker(getTransactionTracker) {
     this.getTransactionTracker = getTransactionTracker;
     return this;
   }
-
   observe() {
     if (this.isSimpleTracking) {
       this.simpleObserver.setPluginNames(this.getPlugins());
       this.simpleObserver.setOnObservation(entries => {
         this.onObserveration(entries, this.observer);
-      }); // can trigger a callback when stopMeasure() measures something.
-      // use that to trigger this.onObservation()
+      });
 
+      // can trigger a callback when stopMeasure() measures something.
+      // use that to trigger this.onObservation()
       this.getTransactionTracker && this.getTransactionTracker().addMeasureListener(this.simpleObserver.observed);
     } else {
       try {
@@ -90,7 +75,6 @@ export class PluginPerformanceObserver {
       }
     }
   }
-
   disconnect() {
     if (this.isSimpleTracking) {
       this.getTransactionTracker && this.getTransactionTracker().removeMeasureListener(this.simpleObserver.observed);
@@ -98,9 +82,7 @@ export class PluginPerformanceObserver {
       this.observer.disconnect();
     }
   }
-
   takeRecords() {
     return this.observer.takeRecords();
   }
-
 }