@atlaskit/editor-core 180.0.0 → 180.1.0

package/dist/esm/editor-next/utils/handleProviders.js

@@ -0,0 +1,50 @@
+/**
+ *
+ * Utility to set all the providers on a provider factory
+ *
+ * @param providerFactory
+ * @param props
+ * @param extensionProvider
+ * @param quickInsertProvider
+ */
+export default function handleProviders(providerFactory, props, extensionProvider, quickInsertProvider) {
+  var _linking$smartLinks;
+  var emojiProvider = props.emojiProvider,
+    mentionProvider = props.mentionProvider,
+    taskDecisionProvider = props.taskDecisionProvider,
+    contextIdentifierProvider = props.contextIdentifierProvider,
+    collabEditProvider = props.collabEditProvider,
+    activityProvider = props.activityProvider,
+    presenceProvider = props.presenceProvider,
+    macroProvider = props.macroProvider,
+    legacyImageUploadProvider = props.legacyImageUploadProvider,
+    media = props.media,
+    collabEdit = props.collabEdit,
+    autoformattingProvider = props.autoformattingProvider,
+    searchProvider = props.searchProvider,
+    UNSAFE_cards = props.UNSAFE_cards,
+    smartLinks = props.smartLinks,
+    linking = props.linking;
+  providerFactory.setProvider('emojiProvider', emojiProvider);
+  providerFactory.setProvider('mentionProvider', mentionProvider);
+  providerFactory.setProvider('taskDecisionProvider', taskDecisionProvider);
+  providerFactory.setProvider('contextIdentifierProvider', contextIdentifierProvider);
+  providerFactory.setProvider('mediaProvider', media && media.provider);
+  providerFactory.setProvider('imageUploadProvider', legacyImageUploadProvider);
+  providerFactory.setProvider('collabEditProvider', collabEdit && collabEdit.provider ? collabEdit.provider : collabEditProvider);
+  providerFactory.setProvider('activityProvider', activityProvider);
+  providerFactory.setProvider('searchProvider', searchProvider);
+  providerFactory.setProvider('presenceProvider', presenceProvider);
+  providerFactory.setProvider('macroProvider', macroProvider);
+  var cardProvider = (linking === null || linking === void 0 ? void 0 : (_linking$smartLinks = linking.smartLinks) === null || _linking$smartLinks === void 0 ? void 0 : _linking$smartLinks.provider) || smartLinks && smartLinks.provider || UNSAFE_cards && UNSAFE_cards.provider;
+  if (cardProvider) {
+    providerFactory.setProvider('cardProvider', cardProvider);
+  }
+  providerFactory.setProvider('autoformattingProvider', autoformattingProvider);
+  if (extensionProvider) {
+    providerFactory.setProvider('extensionProvider', Promise.resolve(extensionProvider));
+  }
+  if (quickInsertProvider) {
+    providerFactory.setProvider('quickInsertProvider', quickInsertProvider);
+  }
+}

package/dist/esm/editor-next/utils/onEditorCreated.js

@@ -0,0 +1,21 @@
+import { EditorExperience, ExperienceStore } from '@atlaskit/editor-common/ufo';
+import { startMeasure, stopMeasure } from '@atlaskit/editor-common/utils';
+import { ACTION } from '@atlaskit/editor-common/analytics';
+import measurements from '../../utils/performance/measure-enum';
+import sendDurationAnalytics from './sendDurationAnalytics';
+export default function onEditorCreated(instance, props, setExperienceStore, getExperienceStore, getCreateAnalyticsEvent, editorActions, startTime, registerEditorForActions) {
+  var _props$featureFlags;
+  registerEditorForActions(instance.view, instance.eventDispatcher, instance.transformer);
+  if ((_props$featureFlags = props.featureFlags) !== null && _props$featureFlags !== void 0 && _props$featureFlags.ufo) {
+    var _getExperienceStore;
+    setExperienceStore(ExperienceStore.getInstance(instance.view));
+    (_getExperienceStore = getExperienceStore()) === null || _getExperienceStore === void 0 ? void 0 : _getExperienceStore.start(EditorExperience.loadEditor, startTime);
+  }
+  if (props.onEditorReady) {
+    var _props$performanceTra, _props$performanceTra2, _props$featureFlags2;
+    var measureEditorReady = (props === null || props === void 0 ? void 0 : (_props$performanceTra = props.performanceTracking) === null || _props$performanceTra === void 0 ? void 0 : (_props$performanceTra2 = _props$performanceTra.onEditorReadyCallbackTracking) === null || _props$performanceTra2 === void 0 ? void 0 : _props$performanceTra2.enabled) || ((_props$featureFlags2 = props.featureFlags) === null || _props$featureFlags2 === void 0 ? void 0 : _props$featureFlags2.ufo);
+    measureEditorReady && startMeasure(measurements.ON_EDITOR_READY_CALLBACK);
+    props.onEditorReady(editorActions);
+    measureEditorReady && stopMeasure(measurements.ON_EDITOR_READY_CALLBACK, sendDurationAnalytics(ACTION.ON_EDITOR_READY_CALLBACK, props, getExperienceStore, getCreateAnalyticsEvent()));
+  }
+}

package/dist/esm/editor-next/utils/sendDurationAnalytics.js

@@ -0,0 +1,61 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { EditorExperience } from '@atlaskit/editor-common/ufo';
+import { ACTION_SUBJECT, EVENT_TYPE, fireAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+/**
+ *
+ * Util function to be used with the Editor component to send duration analytics
+ *
+ * @param action
+ * @param props
+ * @param getExperienceStore return the ExperienceStore of the Editor
+ * @param getCreateAnalyticsEvent return the CreateUIAnalyticsEvent of the Editor
+ * @returns
+ */
+export default function sendDurationAnalytics(action, props, getExperienceStore, createAnalyticsEvent) {
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(duration, startTime) {
+      var _props$featureFlags;
+      var contextIdentifier, objectId, experienceStore;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return props.contextIdentifierProvider;
+            case 2:
+              contextIdentifier = _context.sent;
+              objectId = contextIdentifier === null || contextIdentifier === void 0 ? void 0 : contextIdentifier.objectId;
+              if (createAnalyticsEvent) {
+                fireAnalyticsEvent(createAnalyticsEvent)({
+                  payload: {
+                    action: action,
+                    actionSubject: ACTION_SUBJECT.EDITOR,
+                    attributes: {
+                      duration: duration,
+                      startTime: startTime,
+                      objectId: objectId
+                    },
+                    eventType: EVENT_TYPE.OPERATIONAL
+                  }
+                });
+              }
+              if ((_props$featureFlags = props.featureFlags) !== null && _props$featureFlags !== void 0 && _props$featureFlags.ufo) {
+                experienceStore = getExperienceStore();
+                experienceStore === null || experienceStore === void 0 ? void 0 : experienceStore.mark(EditorExperience.loadEditor, action, startTime + duration);
+                experienceStore === null || experienceStore === void 0 ? void 0 : experienceStore.addMetadata(EditorExperience.loadEditor, {
+                  objectId: objectId
+                });
+              }
+            case 6:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}

package/dist/esm/editor-next/utils/trackEditorActions.js

@@ -0,0 +1,94 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+/**
+ *
+ * Util function to be used with the Editor to track the EditorActions prop
+ *
+ * @param editorActions
+ * @param performanceTracking
+ * @param handleAnalyticsEvent
+ * @returns
+ */
+export default function trackEditorActions(editorActions, performanceTracking, handleAnalyticsEvent) {
+  var _performanceTracking$;
+  if (performanceTracking !== null && performanceTracking !== void 0 && (_performanceTracking$ = performanceTracking.contentRetrievalTracking) !== null && _performanceTracking$ !== void 0 && _performanceTracking$.enabled) {
+    var DEFAULT_SAMPLING_RATE = 100;
+    var getValue = editorActions.getValue.bind(editorActions);
+    if (!editorActions._contentRetrievalTracking) {
+      editorActions._contentRetrievalTracking = {
+        samplingCounters: {
+          success: 1,
+          failure: 1
+        },
+        getValueTracked: false
+      };
+    }
+    var _editorActions$_conte = editorActions._contentRetrievalTracking,
+      samplingCounters = _editorActions$_conte.samplingCounters,
+      getValueTracked = _editorActions$_conte.getValueTracked;
+    if (!getValueTracked) {
+      var getValueWithTracking = /*#__PURE__*/function () {
+        var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+          var _performanceTracking$2, _performanceTracking$3, value, _performanceTracking$4, _performanceTracking$5, _performanceTracking$6;
+          return _regeneratorRuntime.wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  _context.prev = 0;
+                  _context.next = 3;
+                  return getValue();
+                case 3:
+                  value = _context.sent;
+                  if (samplingCounters.success === ((_performanceTracking$2 = performanceTracking === null || performanceTracking === void 0 ? void 0 : (_performanceTracking$3 = performanceTracking.contentRetrievalTracking) === null || _performanceTracking$3 === void 0 ? void 0 : _performanceTracking$3.successSamplingRate) !== null && _performanceTracking$2 !== void 0 ? _performanceTracking$2 : DEFAULT_SAMPLING_RATE)) {
+                    handleAnalyticsEvent({
+                      payload: {
+                        action: ACTION.EDITOR_CONTENT_RETRIEVAL_PERFORMED,
+                        actionSubject: ACTION_SUBJECT.EDITOR,
+                        attributes: {
+                          success: true
+                        },
+                        eventType: EVENT_TYPE.OPERATIONAL
+                      }
+                    });
+                    samplingCounters.success = 0;
+                  }
+                  samplingCounters.success++;
+                  return _context.abrupt("return", value);
+                case 9:
+                  _context.prev = 9;
+                  _context.t0 = _context["catch"](0);
+                  if (samplingCounters.failure === ((_performanceTracking$4 = performanceTracking === null || performanceTracking === void 0 ? void 0 : (_performanceTracking$5 = performanceTracking.contentRetrievalTracking) === null || _performanceTracking$5 === void 0 ? void 0 : _performanceTracking$5.failureSamplingRate) !== null && _performanceTracking$4 !== void 0 ? _performanceTracking$4 : DEFAULT_SAMPLING_RATE)) {
+                    handleAnalyticsEvent({
+                      payload: {
+                        action: ACTION.EDITOR_CONTENT_RETRIEVAL_PERFORMED,
+                        actionSubject: ACTION_SUBJECT.EDITOR,
+                        attributes: {
+                          success: false,
+                          errorInfo: _context.t0.toString(),
+                          errorStack: performanceTracking !== null && performanceTracking !== void 0 && (_performanceTracking$6 = performanceTracking.contentRetrievalTracking) !== null && _performanceTracking$6 !== void 0 && _performanceTracking$6.reportErrorStack ? _context.t0.stack : undefined
+                        },
+                        eventType: EVENT_TYPE.OPERATIONAL
+                      }
+                    });
+                    samplingCounters.failure = 0;
+                  }
+                  samplingCounters.failure++;
+                  throw _context.t0;
+                case 14:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee, null, [[0, 9]]);
+        }));
+        return function getValueWithTracking() {
+          return _ref.apply(this, arguments);
+        };
+      }();
+      editorActions.getValue = getValueWithTracking;
+      editorActions._contentRetrievalTracking.getValueTracked = true;
+    }
+  }
+  return editorActions;
+}