@atlaskit/editor-core 150.0.3 → 151.0.0

package/dist/es2019/utils/react-hooks/use-component-renderer-tracking/index.js

@@ -1,33 +1,66 @@
-import { useEffect, useRef } from 'react';
+import { useMemo, useEffect, useRef } from 'react';
+import debounce from 'lodash/debounce';
 import { getShallowPropsDifference, getPropsDifference } from '../../compare';
 import { EVENT_TYPE } from '../../../plugins/analytics';
-export function useComponentRenderTracking(props, action, actionSubject, handleAnalyticsEvent, propsToIgnore = [], useShallow) {
+export function useComponentRenderTracking({
+  onRender,
+  propsDiffingOptions,
+  zeroBasedCount = true
+}) {
   const propsRef = useRef();
-  const renderCountRef = useRef(0);
+  const renderCountRef = useRef(zeroBasedCount ? 0 : 1);
   useEffect(() => {
     const lastProps = propsRef.current;
     const renderCount = renderCountRef.current;
+    let propsDifference;
 
-    if (lastProps) {
-      let difference = useShallow ? getShallowPropsDifference(lastProps, props) : getPropsDifference(lastProps, props, 0, 2, propsToIgnore);
-      handleAnalyticsEvent({
-        payload: {
-          action,
-          actionSubject,
-          attributes: {
-            propsDifference: difference,
-            count: renderCount
-          },
-          eventType: EVENT_TYPE.OPERATIONAL
-        }
-      });
+    if (propsDiffingOptions !== null && propsDiffingOptions !== void 0 && propsDiffingOptions.enabled && lastProps) {
+      propsDifference = propsDiffingOptions !== null && propsDiffingOptions !== void 0 && propsDiffingOptions.useShallow ? getShallowPropsDifference(lastProps, propsDiffingOptions.props) : getPropsDifference(lastProps, propsDiffingOptions.props, 0, 2, propsDiffingOptions === null || propsDiffingOptions === void 0 ? void 0 : propsDiffingOptions.propsToIgnore);
+    }
+
+    const result = {
+      renderCount,
+      propsDifference
+    };
+    onRender(result);
+
+    if (propsDiffingOptions !== null && propsDiffingOptions !== void 0 && propsDiffingOptions.enabled) {
+      propsRef.current = propsDiffingOptions.props;
     }
 
-    propsRef.current = props;
     renderCountRef.current = renderCountRef.current + 1;
   }); // No dependencies run on each render
 }
 export function RenderTracking(props) {
-  useComponentRenderTracking(props.componentProps, props.action, props.actionSubject, props.handleAnalyticsEvent, props.propsToIgnore, props.useShallow);
+  const debouncedHandleAnalyticsEvent = useMemo(() => debounce(props.handleAnalyticsEvent, 500), [props.handleAnalyticsEvent]);
+  useComponentRenderTracking({
+    onRender: ({
+      renderCount,
+      propsDifference
+    }) => {
+      if (!renderCount) {
+        return;
+      }
+
+      debouncedHandleAnalyticsEvent({
+        payload: {
+          action: props.action,
+          actionSubject: props.actionSubject,
+          attributes: {
+            count: renderCount,
+            propsDifference: propsDifference
+          },
+          eventType: EVENT_TYPE.OPERATIONAL
+        }
+      });
+    },
+    propsDiffingOptions: {
+      enabled: true,
+      props: props.componentProps,
+      propsToIgnore: props.propsToIgnore,
+      useShallow: props.useShallow
+    },
+    zeroBasedCount: true
+  });
   return null;
 }

package/dist/es2019/version-wrapper.js

@@ -1,5 +1,5 @@
 export const name = "@atlaskit/editor-core";
-export const version = "150.0.3";
+export const version = "151.0.0";
 export const nextMajorVersion = () => {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/editor-core",
-	"version": "150.0.3",
+	"version": "151.0.0",
 	"sideEffects": false
 }

package/dist/esm/actions/index.js

@@ -4,7 +4,7 @@ import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { Node } from 'prosemirror-model';
-import { TextSelection, Selection } from 'prosemirror-state';
+import { TextSelection } from 'prosemirror-state';
 import { toJSON } from '../utils';
 import { processRawValue, isEmptyDocument } from '../utils/document';
 import { getEditorValueWithMedia, __temporaryFixForConfigPanel as _temporaryFixForConfigPanel } from '../utils/action';
@@ -244,31 +244,13 @@ var EditorActions = /*#__PURE__*/function () {
         return false;
       }
 
-      var state = this.editorView.state;
-      var schema = state.schema;
-      var content = processRawValue(schema, rawValue, undefined, undefined, this.contentTransformer, this.dispatchAnalyticsEvent);
-
-      if (!content) {
-        return false;
-      } // In case of replacing a whole document, we only need a content of a top level node e.g. document.
-
-
-      var tr = state.tr.replaceWith(0, state.doc.nodeSize - 2, content.content);
-
-      if (!shouldScrollToBottom && !tr.selectionSet) {
-        // Restore selection at start of document instead of the end.
-        tr.setSelection(Selection.atStart(tr.doc));
-      }
-
-      if (shouldScrollToBottom) {
-        tr = tr.scrollIntoView();
-      }
-
-      if (!shouldAddToHistory) {
-        tr.setMeta('addToHistory', false);
+      if (this.eventDispatcher) {
+        this.eventDispatcher.emit('resetEditorState', {
+          doc: rawValue,
+          shouldScrollToBottom: shouldScrollToBottom
+        });
       }
 
-      this.editorView.dispatch(tr);
       return true;
     }
   }, {

package/dist/esm/create-editor/ErrorBoundary.js

@@ -8,6 +8,10 @@ import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstruct
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
@@ -16,6 +20,7 @@ import React from 'react';
 import uuid from 'uuid';
 import memoizeOne from 'memoize-one';
 import { sniffUserBrowserExtensions } from '@atlaskit/editor-common';
+import { ExperienceStore } from '@atlaskit/editor-common/ufo';
 import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '../plugins/analytics';
 import { editorAnalyticsChannel } from '../plugins/analytics/consts';
 import { getFeatureFlags } from '../plugins/feature-flags-context';
@@ -26,16 +31,12 @@ export var ErrorBoundaryWithEditorView = /*#__PURE__*/function (_React$Component
 
   var _super = _createSuper(ErrorBoundaryWithEditorView);
 
-  function ErrorBoundaryWithEditorView() {
+  function ErrorBoundaryWithEditorView(props) {
     var _this;
 
     _classCallCheck(this, ErrorBoundaryWithEditorView);
 
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-
-    _this = _super.call.apply(_super, [this].concat(args));
+    _this = _super.call(this, props);
 
     _defineProperty(_assertThisInitialized(_this), "browserExtensions", undefined);
 
@@ -51,102 +52,138 @@ export var ErrorBoundaryWithEditorView = /*#__PURE__*/function (_React$Component
       return getFeatureFlags(editorView.state);
     }));
 
-    _defineProperty(_assertThisInitialized(_this), "fireAnalytics", function (analyticsErrorPayload) {
-      var createAnalyticsEvent = _this.props.createAnalyticsEvent;
-
-      _this.getProductName().then(function (product) {
-        if (createAnalyticsEvent) {
-          var error = analyticsErrorPayload.error,
-              errorInfo = analyticsErrorPayload.errorInfo,
-              errorStack = analyticsErrorPayload.errorStack;
-          var sharedId = uuid();
-          var event = {
-            action: ACTION.EDITOR_CRASHED,
-            actionSubject: ACTION_SUBJECT.EDITOR,
-            eventType: EVENT_TYPE.OPERATIONAL,
-            attributes: {
-              product: product,
-              browserInfo: window && window.navigator && window.navigator.userAgent ? window.navigator.userAgent : 'unknown',
-              error: error,
-              errorInfo: errorInfo,
-              errorId: sharedId,
-              browserExtensions: _this.browserExtensions
-            }
-          }; // Add doc structure if the feature flag is on
+    _defineProperty(_assertThisInitialized(_this), "sendErrorData", /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(analyticsErrorPayload) {
+        var product, error, errorInfo, errorStack, sharedId, attributes, _this$experienceStore;
 
-          if (_this.featureFlags.errorBoundaryDocStructure && _this.props.editorView) {
-            event.attributes.docStructure = getDocStructure(_this.props.editorView.state.doc, {
-              compact: true
-            });
-          }
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return _this.getProductName();
+
+              case 2:
+                product = _context.sent;
+                error = analyticsErrorPayload.error, errorInfo = analyticsErrorPayload.errorInfo, errorStack = analyticsErrorPayload.errorStack;
+                sharedId = uuid();
+                attributes = {
+                  product: product,
+                  browserInfo: window && window.navigator && window.navigator.userAgent ? window.navigator.userAgent : 'unknown',
+                  error: error,
+                  errorInfo: errorInfo,
+                  errorId: sharedId,
+                  browserExtensions: _this.browserExtensions,
+                  docStructure: _this.featureFlags.errorBoundaryDocStructure && _this.props.editorView ? getDocStructure(_this.props.editorView.state.doc, {
+                    compact: true
+                  }) : undefined
+                };
+
+                _this.fireAnalyticsEvent({
+                  action: ACTION.EDITOR_CRASHED,
+                  actionSubject: ACTION_SUBJECT.EDITOR,
+                  eventType: EVENT_TYPE.OPERATIONAL,
+                  attributes: attributes
+                });
+
+                _this.fireAnalyticsEvent({
+                  action: ACTION.EDITOR_CRASHED_ADDITIONAL_INFORMATION,
+                  actionSubject: ACTION_SUBJECT.EDITOR,
+                  eventType: EVENT_TYPE.OPERATIONAL,
+                  attributes: {
+                    errorStack: errorStack,
+                    errorId: sharedId
+                  }
+                });
+
+                if (_this.featureFlags.ufo && _this.props.editorView) {
+                  (_this$experienceStore = _this.experienceStore) === null || _this$experienceStore === void 0 ? void 0 : _this$experienceStore.failAll(_objectSpread(_objectSpread({}, _this.getExperienceMetadata(attributes)), {}, {
+                    errorStack: errorStack
+                  }));
+                }
 
-          createAnalyticsEvent(event).fire(editorAnalyticsChannel);
-          createAnalyticsEvent({
-            action: ACTION.EDITOR_CRASHED_ADDITIONAL_INFORMATION,
-            actionSubject: ACTION_SUBJECT.EDITOR,
-            eventType: EVENT_TYPE.OPERATIONAL,
-            attributes: {
-              errorStack: errorStack,
-              errorId: sharedId
+              case 9:
+              case "end":
+                return _context.stop();
             }
-          }).fire(editorAnalyticsChannel);
-        } else {
-          // eslint-disable-next-line no-console
-          console.error('Editor Error Boundary: Missing `createAnalyticsEvent` prop.', {
-            channel: editorAnalyticsChannel,
-            product: product,
-            error: analyticsErrorPayload
-          });
-        }
-      }).catch(function (e) {
-        // eslint-disable-next-line no-console
-        console.error('Failed to resolve product name from contextIdentifierProvider.', e);
-      });
-    });
+          }
+        }, _callee);
+      }));
+
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }());
 
-    _defineProperty(_assertThisInitialized(_this), "getProductName", /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    _defineProperty(_assertThisInitialized(_this), "getProductName", /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
       var contextIdentifierProvider, context;
-      return _regeneratorRuntime.wrap(function _callee$(_context) {
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
         while (1) {
-          switch (_context.prev = _context.next) {
+          switch (_context2.prev = _context2.next) {
             case 0:
               contextIdentifierProvider = _this.props.contextIdentifierProvider;
 
               if (!contextIdentifierProvider) {
-                _context.next = 7;
+                _context2.next = 7;
                 break;
               }
 
-              _context.next = 4;
+              _context2.next = 4;
               return contextIdentifierProvider;
 
             case 4:
-              context = _context.sent;
+              context = _context2.sent;
 
               if (!context.product) {
-                _context.next = 7;
+                _context2.next = 7;
                 break;
               }
 
-              return _context.abrupt("return", context.product);
+              return _context2.abrupt("return", context.product);
 
             case 7:
-              return _context.abrupt("return", 'atlaskit');
+              return _context2.abrupt("return", 'atlaskit');
 
             case 8:
             case "end":
-              return _context.stop();
+              return _context2.stop();
           }
         }
-      }, _callee);
+      }, _callee2);
     })));
 
+    _defineProperty(_assertThisInitialized(_this), "fireAnalyticsEvent", function (event) {
+      var _this$props$createAna, _this$props;
+
+      (_this$props$createAna = (_this$props = _this.props).createAnalyticsEvent) === null || _this$props$createAna === void 0 ? void 0 : _this$props$createAna.call(_this$props, event).fire(editorAnalyticsChannel);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "getExperienceMetadata", function (attributes) {
+      var _attributes$browserEx;
+
+      return {
+        browserInfo: attributes.browserInfo,
+        error: attributes.error.toString(),
+        errorInfo: {
+          componentStack: attributes.errorInfo.componentStack
+        },
+        errorId: attributes.errorId,
+        browserExtensions: (_attributes$browserEx = attributes.browserExtensions) === null || _attributes$browserEx === void 0 ? void 0 : _attributes$browserEx.toString(),
+        docStructure: attributes.docStructure
+      };
+    });
+
+    if (props.editorView) {
+      _this.experienceStore = ExperienceStore.getInstance(props.editorView);
+    }
+
     return _this;
   }
 
   _createClass(ErrorBoundaryWithEditorView, [{
     key: "featureFlags",
-    get: function get() {
+    get: // Memoizing this as react alternative suggestion of https://reactjs.org/docs/react-component.html#unsafe_componentwillreceiveprops
+    function get() {
       return this.getFeatureFlags(this.props.editorView);
     }
   }, {
@@ -154,13 +191,11 @@ export var ErrorBoundaryWithEditorView = /*#__PURE__*/function (_React$Component
     value: function componentDidCatch(error, errorInfo) {
       var _this2 = this;
 
-      // Log the error
-      this.fireAnalytics({
+      this.sendErrorData({
         error: error.toString(),
         errorInfo: errorInfo,
         errorStack: error.stack
-      }); //
-      // // Update state to allow a re-render to attempt graceful recovery (in the event that
+      }); // // Update state to allow a re-render to attempt graceful recovery (in the event that
       // // the error was caused by a race condition or is intermittent)
 
       this.setState({
@@ -180,12 +215,12 @@ export var ErrorBoundaryWithEditorView = /*#__PURE__*/function (_React$Component
   }, {
     key: "componentDidMount",
     value: function () {
-      var _componentDidMount = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      var _componentDidMount = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
           while (1) {
-            switch (_context2.prev = _context2.next) {
+            switch (_context3.prev = _context3.next) {
               case 0:
-                _context2.next = 2;
+                _context3.next = 2;
                 return sniffUserBrowserExtensions({
                   extensions: ['grammarly'],
                   async: true,
@@ -193,14 +228,14 @@ export var ErrorBoundaryWithEditorView = /*#__PURE__*/function (_React$Component
                 });
 
               case 2:
-                this.browserExtensions = _context2.sent;
+                this.browserExtensions = _context3.sent;
 
               case 3:
               case "end":
-                return _context2.stop();
+                return _context3.stop();
             }
           }
-        }, _callee2, this);
+        }, _callee3, this);
       }));
 
       function componentDidMount() {