@atlaskit/editor-core 178.1.1 → 178.1.2

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

@@ -4,51 +4,36 @@ import { EVENT_NAME_STATE_APPLY, EVENT_NAME_UPDATE_STATE, EVENT_NAME_ON_CHANGE,
 export class PluginPerformanceReport {
   constructor(entry) {
     _defineProperty(this, "count", 0);
-
     _defineProperty(this, "pluginNames", []);
-
     _defineProperty(this, "nodes", {});
-
     _defineProperty(this, "extensionNodes", {});
-
     _defineProperty(this, "nodesDuration", 0);
-
     _defineProperty(this, "plugins", {});
-
     _defineProperty(this, "slowPlugins", {});
-
     _defineProperty(this, "options", {
       samplingRate: 100,
       slowThreshold: 300,
       outlierThreshold: 30,
       outlierFactor: 3
     });
-
     _defineProperty(this, "isChild", child => child.startTime >= this.entry.startTime && child.startTime + child.duration <= this.entry.startTime + this.entry.duration);
-
     this.entry = entry;
   }
-
   static fromEntry(entry) {
     return new PluginPerformanceReport(entry);
   }
-
   getEntryByName(entryList, name) {
     return entryList.getEntriesByName(name).find(this.isChild);
   }
-
   getMethodSum(methods) {
     return Object.values(methods).reduce((a, b) => a + b, 0);
   }
-
   greaterEquals(a, b) {
     return typeof b === 'number' ? a >= b : false;
   }
-
   hasOutlierMethods(methods, outliers) {
     return this.greaterEquals(methods.stateApply, outliers.stateApplyOutlier) || this.greaterEquals(methods.viewUpdate, outliers.viewUpdateOutlier);
   }
-
   get trigger() {
     if (this.entry.duration > this.options.slowThreshold) {
       return 'slow';
@@ -60,11 +45,9 @@ export class PluginPerformanceReport {
       return 'none';
     }
   }
-
   get hasSlowPlugins() {
     return Object.keys(this.slowPlugins).length > 0;
   }
-
   withEntryList(entryList) {
     this.entryList = entryList;
     this.stateApplied = this.getEntryByName(entryList, EVENT_NAME_STATE_APPLY);
@@ -74,7 +57,6 @@ export class PluginPerformanceReport {
     this.withPlugins(this.pluginNames);
     return this;
   }
-
   withPlugins(pluginNames) {
     const emptyEntry = {
       duration: 0
@@ -91,7 +73,6 @@ export class PluginPerformanceReport {
       };
       return acc;
     }, {});
-
     if (this.stateApplied && pluginNames.length > 0) {
       const pluginEntries = Object.entries(this.plugins);
       const stateApplyOutlier = outlier(pluginEntries.map(([, {
@@ -101,42 +82,37 @@ export class PluginPerformanceReport {
         viewUpdate
       }]) => viewUpdate), this.options.outlierFactor);
       const budget = this.options.outlierThreshold / pluginEntries.length;
+
       /**
        * Consider plugin methods slow that are
        * statistically significantly slower than peers
        * AND where the sum of methods for a plugin is slower than 16.7ms / plugins.length
        */
-
       const pluginIsOutlier = ([, methods]) => this.getMethodSum(methods) > budget && this.hasOutlierMethods(methods, {
         stateApplyOutlier,
         viewUpdateOutlier
       });
-
-      this.slowPlugins = pluginEntries.filter(pluginIsOutlier).reduce((acc, [n, d]) => ({ ...acc,
+      this.slowPlugins = pluginEntries.filter(pluginIsOutlier).reduce((acc, [n, d]) => ({
+        ...acc,
         [n]: d
       }), {});
     }
-
     return this;
   }
-
   withNodes(nodesCount, nodesDuration = 0) {
     this.nodes = nodesCount.nodeCount;
     this.extensionNodes = nodesCount.extensionNodeCount;
     this.nodesDuration = nodesDuration;
     return this;
   }
-
   withCount(count) {
     this.count = count;
     return this;
   }
-
   withOptions(options) {
     Object.assign(this.options, options);
     return this;
   }
-
   toJSON() {
     return {
       trigger: this.trigger,
@@ -154,5 +130,4 @@ export class PluginPerformanceReport {
       }
     };
   }
-
 }

package/dist/es2019/utils/performance/safer-transactions.js

@@ -1,10 +1,9 @@
 import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '../../plugins/analytics';
-export const UNSAFE_PROPERTY_SET_ERROR = 'Setting an unsafe property on transaction after dispatch!'; // since selection uses curSelection under the hood, we guard setSelection instead
+export const UNSAFE_PROPERTY_SET_ERROR = 'Setting an unsafe property on transaction after dispatch!';
 
+// since selection uses curSelection under the hood, we guard setSelection instead
 const isUnsafeMethod = prop => ['setSelection'].includes(prop.toString());
-
 const isReadOnlyProperty = prop => ['doc', 'docs', 'steps', 'selection'].includes(prop.toString());
-
 export const freezeUnsafeTransactionProperties = ({
   dispatchAnalyticsEvent,
   pluginKey,
@@ -24,25 +23,21 @@ export const freezeUnsafeTransactionProperties = ({
         }
       });
     }
-
     if (!analyticsOnly) {
       throw new Error(UNSAFE_PROPERTY_SET_ERROR);
     }
   };
-
   return {
     get: function (target, prop, receiver) {
       if (isUnsafeMethod(prop)) {
         isUnsafe();
       }
-
       return Reflect.get(target, prop, receiver);
     },
     set: function (target, prop, receiver) {
       if (isReadOnlyProperty(prop)) {
         isUnsafe();
       }
-
       return Reflect.set(target, prop, receiver);
     }
   };

package/dist/es2019/utils/performance/simple-measure-to-entries.js

@@ -1,6 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { EVENT_NAME_DISPATCH_TRANSACTION, EVENT_NAME_STATE_APPLY, EVENT_NAME_UPDATE_STATE, EVENT_NAME_VIEW_STATE_UPDATED, EVENT_NAME_ON_CHANGE } from './track-transactions';
 const EVENT_NAMES = [EVENT_NAME_STATE_APPLY, EVENT_NAME_UPDATE_STATE, EVENT_NAME_VIEW_STATE_UPDATED, EVENT_NAME_ON_CHANGE, EVENT_NAME_DISPATCH_TRANSACTION];
+
 /**
  * A class that logs and collates measurement entries until
  * EVENT_NAME_DISPATCHTRANSACTION is detected.
@@ -12,21 +13,16 @@ const EVENT_NAMES = [EVENT_NAME_STATE_APPLY, EVENT_NAME_UPDATE_STATE, EVENT_NAME
  * We are able to make use of this method as the measurements
  * which occur during dispatchTransactions are synchronous.
  */
-
 export class SimpleMeasurementLogger {
   constructor() {
     _defineProperty(this, "currentBatch", []);
-
     _defineProperty(this, "pluginNameCache", new Set());
-
     _defineProperty(this, "setPluginNames", names => {
       this.pluginNameCache = new Set(names);
     });
-
     _defineProperty(this, "setOnObservation", callback => {
       this.observationCallback = callback;
     });
-
     _defineProperty(this, "createPerformanceEntry", reading => {
       return {
         entryType: 'mark',
@@ -41,7 +37,6 @@ export class SimpleMeasurementLogger {
         })
       };
     });
-
     _defineProperty(this, "convertToEntryList", batch => {
       return {
         getEntries: () => batch,
@@ -50,44 +45,39 @@ export class SimpleMeasurementLogger {
         getEntriesByType: type => batch
       };
     });
-
     _defineProperty(this, "observed", reading => {
       // Given that this is only used for tracking transactions and
       // transactions are synchronous, we can assume that anything measured
       // between EVENT_NAME_DISPATCHTRANSACTION is encapsulated.
       const {
         name
-      } = reading; // Transaction tracking event are prefixed with Owl emoji
+      } = reading;
 
+      // Transaction tracking event are prefixed with Owl emoji
       if (name.startsWith('🦉')) {
         var _name$split$;
-
         // check if its logging InstrumentedPlugin.state.apply()
         const pluginName = ((_name$split$ = name.split(':')[0]) === null || _name$split$ === void 0 ? void 0 : _name$split$.split('🦉')[1]) || '';
         const isPluginApply = this.pluginNameCache.has(pluginName);
         const isTransactionMeasurement = EVENT_NAMES.includes(name);
-
         if (!isTransactionMeasurement && process.env.NODE_ENV === 'development') {
           // eslint-disable-next-line no-console
           console.warn(`SimpleMeasurementLogger: unknown transaction event name '${name}'`);
         }
-
         if (isPluginApply || isTransactionMeasurement) {
           this.currentBatch.push(this.createPerformanceEntry(reading));
         }
-      } // Trigger a report
-
+      }
 
+      // Trigger a report
       if (name === EVENT_NAME_DISPATCH_TRANSACTION) {
         // convert the batch into a bunch of entries
         if (this.observationCallback) {
           const entries = this.convertToEntryList([...this.currentBatch]);
           this.observationCallback(entries);
         }
-
         this.currentBatch = [];
       }
     });
   }
-
 }

package/dist/es2019/utils/performance/track-transactions.js

@@ -8,76 +8,59 @@ export const EVENT_NAME_ON_CHANGE = `🦉 ReactEditorView::onChange`;
 export const EVENT_NAME_DISPATCH_TRANSACTION = `🦉 ReactEditorView::dispatchTransaction`;
 export const DEFAULT_USE_PERFORMANCE_MARK = false;
 const DEFAULT_SAMPLING_RATE = 100;
-
 const noop = () => {};
-
 export class TransactionTracker {
   constructor() {
     _defineProperty(this, "dispatchCallCounter", 0);
-
     _defineProperty(this, "measureMap", new Map());
-
     _defineProperty(this, "measureListeners", []);
-
     _defineProperty(this, "bumpDispatchCounter", options => {
       const {
         enabled: trackingEnabled,
         samplingRate = DEFAULT_SAMPLING_RATE
       } = options;
-
       if (trackingEnabled) {
         if (this.dispatchCallCounter >= samplingRate) {
           this.dispatchCallCounter = 0;
         }
-
         this.dispatchCallCounter++;
       }
-
       return this.dispatchCallCounter;
     });
-
     _defineProperty(this, "getMeasureHelpers", options => {
       const {
         usePerformanceMarks = DEFAULT_USE_PERFORMANCE_MARK
       } = options;
-
       if (!this.shouldTrackTransaction(options)) {
         return {
           startMeasure: noop,
           stopMeasure: noop
         };
       }
-
       return {
         startMeasure: usePerformanceMarks ? startMeasure : this.startMeasureSimple,
         stopMeasure: usePerformanceMarks ? stopMeasure : this.stopMeasureSimple
       };
     });
-
     _defineProperty(this, "startMeasureSimple", measureName => {
       if (!isPerformanceAPIAvailable()) {
         return;
       }
-
       this.measureMap.set(measureName, performance.now());
     });
-
     _defineProperty(this, "stopMeasureSimple", (measureName, onMeasureComplete) => {
       if (!isPerformanceAPIAvailable()) {
         return;
       }
-
       const startTime = this.measureMap.get(measureName);
-
       if (startTime) {
         const duration = getTimeSince(startTime);
         this.measureMap.delete(measureName);
-
         if (onMeasureComplete) {
           onMeasureComplete(duration, startTime);
-        } // Call each subscribed listener
-
+        }
 
+        // Call each subscribed listener
         this.measureListeners.forEach(listener => listener({
           name: measureName,
           duration,
@@ -86,19 +69,15 @@ export class TransactionTracker {
       }
     });
   }
-
   addMeasureListener(listener) {
     this.measureListeners.push(listener);
   }
-
   removeMeasureListener(listener) {
     const index = this.measureListeners.indexOf(listener);
-
     if (index > -1) {
       this.measureListeners.splice(index, 1);
     }
   }
-
   shouldTrackTransaction(options) {
     const {
       enabled: trackingEnabled,
@@ -106,5 +85,4 @@ export class TransactionTracker {
     } = options;
     return trackingEnabled && this.dispatchCallCounter === samplingRate;
   }
-
 }

package/dist/es2019/utils/pick-by.js

@@ -1,5 +1,5 @@
-const pickBy = (test, object) => Object.keys(object).reduce((obj, key) => test(String(key), object[key]) ? { ...obj,
+const pickBy = (test, object) => Object.keys(object).reduce((obj, key) => test(String(key), object[key]) ? {
+  ...obj,
   [key]: object[key]
 } : obj, {});
-
 export default pickBy;

package/dist/es2019/utils/prosemirror/autojoin.js

@@ -1,4 +1,5 @@
 import { canJoin } from 'prosemirror-transform';
+
 /**
  * Checks whether two adjacent nodes can be joined. If so, the document
  * will be updated to join those nodes. If not, the original transaction
@@ -9,59 +10,45 @@ import { canJoin } from 'prosemirror-transform';
  *
  * Adapted from https://github.com/ProseMirror/prosemirror-commands/blob/master/src/commands.js#L597-L610
  */
-
 export function autoJoinTr(tr, isJoinable) {
   if (Array.isArray(isJoinable)) {
     let types = isJoinable;
-
     isJoinable = node => types.indexOf(node.type.name) > -1;
   }
-
   const ranges = [];
-
   for (let i = 0; i < tr.mapping.maps.length; i++) {
     const map = tr.mapping.maps[i];
-
     for (let j = 0; j < ranges.length; j++) {
       ranges[j] = map.map(ranges[j]);
     }
-
     map.forEach((_s, _e, from, to) => ranges.push(from, to));
-  } // Figure out which joinable points exist inside those ranges,
-  // by checking all node boundaries in their parent nodes.
-
+  }
 
+  // Figure out which joinable points exist inside those ranges,
+  // by checking all node boundaries in their parent nodes.
   const joinable = [];
-
   for (let i = 0; i < ranges.length; i += 2) {
     const from = ranges[i];
     const to = ranges[i + 1];
     const $from = tr.doc.resolve(from);
     const depth = $from.sharedDepth(to);
     const parent = $from.node(depth);
-
     for (let index = $from.indexAfter(depth), pos = $from.after(depth + 1); pos <= to; ++index) {
       const after = parent.maybeChild(index);
-
       if (!after) {
         break;
       }
-
       if (index && joinable.indexOf(pos) === -1) {
         const before = parent.child(index - 1);
-
         if (before.type === after.type && isJoinable(before, after)) {
           joinable.push(pos);
         }
       }
-
       pos += after.nodeSize;
     }
-  } // Join the joinable points
-
-
+  }
+  // Join the joinable points
   joinable.sort((a, b) => a - b);
-
   for (let i = joinable.length - 1; i >= 0; i--) {
     if (canJoin(tr.doc, joinable[i])) {
       tr.join(joinable[i]);

package/dist/es2019/utils/prosemirror/position.js

@@ -20,15 +20,12 @@ export function atTheEndOfBlock(state) {
   const {
     $to
   } = selection;
-
   if (selection instanceof GapCursorSelection) {
     return false;
   }
-
   if (selection instanceof NodeSelection && selection.node.isBlock) {
     return true;
   }
-
   return endPositionOfParent($to) === $to.pos + 1;
 }
 export function atTheBeginningOfBlock(state) {
@@ -38,15 +35,12 @@ export function atTheBeginningOfBlock(state) {
   const {
     $from
   } = selection;
-
   if (selection instanceof GapCursorSelection) {
     return false;
   }
-
   if (selection instanceof NodeSelection && selection.node.isBlock) {
     return true;
   }
-
   return startPositionOfParent($from) === $from.pos;
 }
 export function startPositionOfParent(resolvedPos) {

package/dist/es2019/utils/react-hooks/use-abortable-effect/index.js

@@ -1,22 +1,18 @@
 import { useEffect, useMemo, useCallback } from 'react';
-
 const safeError = message => {
   if (process.env.NODE_ENV !== 'production') {
     throw new Error(message);
-  } // eslint-disable-next-line no-console
-
+  }
 
+  // eslint-disable-next-line no-console
   console.error(message);
 };
-
 const createAbortController = () => {
   if (typeof AbortController === 'undefined') {
     safeError('Missing AbortController');
   }
-
   return new AbortController();
 };
-
 /**
  * Similar to useEffect but integrated with the AbortController to make it useful for async operations.
  * On unmount, the abort function will be called and the signal will be passed down to the function so
@@ -29,11 +25,12 @@ const createAbortController = () => {
  * @param deps
  */
 export function useAbortableEffect(callback, deps) {
-  const abortController = useMemo(() => createAbortController(), // eslint-disable-next-line react-hooks/exhaustive-deps
+  const abortController = useMemo(() => createAbortController(),
+  // eslint-disable-next-line react-hooks/exhaustive-deps
   deps);
-  const abort = useCallback(() => abortController.abort(), [abortController]); // AFP-2511 TODO: Fix automatic suppressions below
+  const abort = useCallback(() => abortController.abort(), [abortController]);
+  // AFP-2511 TODO: Fix automatic suppressions below
   // eslint-disable-next-line react-hooks/exhaustive-deps
-
   const fn = useCallback(callback, deps);
   useEffect(() => {
     const teardown = fn(abortController.signal);
@@ -41,9 +38,9 @@ export function useAbortableEffect(callback, deps) {
       if (typeof teardown === 'function') {
         teardown();
       }
-
       abort();
     };
-  }, [abortController, abort, fn, // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [abortController, abort, fn,
+  // eslint-disable-next-line react-hooks/exhaustive-deps
   ...deps]);
 }

package/dist/es2019/utils/react-hooks/use-state-from-promise/index.js

@@ -1,6 +1,5 @@
 import { useState, useCallback } from 'react';
 import { useAbortableEffect } from '../use-abortable-effect';
-
 /**
  * Similar to useState but deals with async values.
  * Simply pass a promise and it will set the state when it resolves. It won't try to set if
@@ -22,10 +21,10 @@ export function useStateFromPromise(callback, deps, initialValue) {
       if (signal.aborted) {
         return;
       }
-
       setValue(result);
     });
-  }, // eslint-disable-next-line react-hooks/exhaustive-deps
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
   [...deps]);
   return [value, setValue];
 }

package/dist/es2019/utils/rich-media-utils.js

@@ -7,7 +7,6 @@ export const isRichMediaInsideOfBlockNode = (view, pos) => {
   if (typeof pos !== 'number' || isNaN(pos) || !view) {
     return false;
   }
-
   const $pos = view.state.doc.resolve(pos);
   const {
     expand,
@@ -23,7 +22,6 @@ export const alignAttributes = (layout, oldAttrs, gridSize = 12, originalWidth,
   const newLayoutIsNonWrapped = nonWrappedLayouts.indexOf(layout) > -1;
   const newLayoutIsWrapped = wrappedLayouts.indexOf(layout) > -1;
   const oldLayoutIsWrapped = wrappedLayouts.indexOf(oldLayout) > -1;
-
   if (oldLayoutIsNonWrapped && shouldAddDefaultWrappedWidth(layout, originalWidth, lineLength)) {
     // 'full-width' or 'wide' or 'center' -> 'wrap-left' or 'wrap-right' or 'align-end' or 'align-start'
     if (!width || width >= 100 || oldLayout !== 'center' // == 'full-width' or 'wide'
@@ -38,7 +36,6 @@ export const alignAttributes = (layout, oldAttrs, gridSize = 12, originalWidth,
   } else if (width) {
     const cols = Math.round(width / 100 * gridSize);
     let targetCols = cols;
-
     if (oldLayoutIsWrapped && newLayoutIsNonWrapped) {
       // wrap -> center needs to align to even grid
       targetCols = Math.floor(targetCols / 2) * 2;
@@ -50,6 +47,7 @@ export const alignAttributes = (layout, oldAttrs, gridSize = 12, originalWidth,
       // !originalWidth || !lineLength || small image
       // AND
       // width defined!
+
       // cannot resize to full column width, and cannot resize to 1 column
       if (cols <= 1) {
         targetCols = 2;
@@ -57,13 +55,12 @@ export const alignAttributes = (layout, oldAttrs, gridSize = 12, originalWidth,
         targetCols = 10;
       }
     }
-
     if (targetCols !== cols) {
       width = targetCols / gridSize * 100;
     }
   }
-
-  return { ...oldAttrs,
+  return {
+    ...oldAttrs,
     layout,
     width
   };
@@ -83,35 +80,29 @@ export function calculateSnapPoints({
   wrappedLayout
 }) {
   const snapTargets = [];
-
   for (let i = 0; i < gridWidth; i++) {
     const pxFromColumns = calcPxFromColumns(i, lineLength, gridWidth);
     snapTargets.push(insideLayout ? pxFromColumns : pxFromColumns - offsetLeft);
-  } // full width
-
-
+  }
+  // full width
   snapTargets.push(lineLength - offsetLeft);
   const columns = wrappedLayout || insideInlineLike ? 1 : 2;
   const minimumWidth = calcPxFromColumns(columns, lineLength, gridSize);
   let snapPoints = snapTargets.filter(width => width >= minimumWidth);
-
   if (!$pos) {
     return snapPoints;
   }
-
   snapPoints = isVideoFile ? snapPoints.filter(width => width > 320) : snapPoints;
   const isTopLevel = $pos.parent.type.name === 'doc';
-
   if (isTopLevel && allowBreakoutSnapPoints) {
     snapPoints.push(akEditorWideLayoutWidth);
     const fullWidthPoint = containerWidth - akEditorBreakoutPadding;
-
     if (fullWidthPoint > akEditorWideLayoutWidth) {
       snapPoints.push(fullWidthPoint);
     }
-  } // EDM-1107: Ensure new snapPoints are sorted with existing points
-
+  }
 
+  // EDM-1107: Ensure new snapPoints are sorted with existing points
   snapPoints = snapPoints.sort((a, b) => a - b);
   return snapPoints;
 }

package/dist/es2019/utils/selection.js

@@ -29,29 +29,28 @@ export const normaliseNestedLayout = ({
 }, node) => {
   if (selection.$from.depth > 1) {
     if (node.attrs.layout && node.attrs.layout !== 'default') {
-      return node.type.createChecked({ ...node.attrs,
+      return node.type.createChecked({
+        ...node.attrs,
         layout: 'default'
       }, node.content, node.marks);
-    } // If its a breakout layout, we can remove the mark
-    // Since default isn't a valid breakout mode.
-
+    }
 
+    // If its a breakout layout, we can remove the mark
+    // Since default isn't a valid breakout mode.
     const breakoutMark = doc.type.schema.marks.breakout;
-
     if (breakoutMark && breakoutMark.isInSet(node.marks)) {
       const newMarks = breakoutMark.removeFromSet(node.marks);
       return node.type.createChecked(node.attrs, node.content, newMarks);
     }
   }
-
   return node;
-}; // checks if the given position is within the ProseMirror document
+};
 
+// checks if the given position is within the ProseMirror document
 export const isValidPosition = (pos, state) => {
   if (pos >= 0 && pos <= state.doc.resolve(0).end()) {
     return true;
   }
-
   return false;
 };
 export const duplicateSelection = (selectionToDuplicate, doc) => {

package/dist/es2019/utils/table.js

@@ -7,22 +7,16 @@ export function isPositionNearTableRow(pos, schema, direction) {
   if (!schema.nodes.tableRow) {
     return false;
   }
-
   let doc = pos.doc;
   let resolved = pos;
   const sibling = direction === 'before' ? 'nodeBefore' : 'nodeAfter';
-
   while (resolved.depth > 0) {
     var _resolved$sibling;
-
     const siblingType = (_resolved$sibling = resolved[sibling]) === null || _resolved$sibling === void 0 ? void 0 : _resolved$sibling.type;
-
     if (siblingType === schema.nodes.tableRow) {
       return true;
     }
-
     resolved = doc.resolve(resolved[direction]());
   }
-
   return false;
 }