@atlaskit/editor-core 180.0.0 → 181.0.0

package/dist/cjs/editor-next/utils/deprecationWarnings.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = deprecationWarnings;
+var _versionWrapper = require("../../version-wrapper");
+function deprecationWarnings(props) {
+  var _props$allowTextColor;
+  if (process.env.NODE_ENV === 'production') {
+    return;
+  }
+  var nextVersion = (0, _versionWrapper.nextMajorVersion)();
+  var deprecatedProperties = {
+    allowTasksAndDecisions: {
+      message: 'To allow tasks and decisions use taskDecisionProvider – <Editor taskDecisionProvider={{ provider }} />',
+      type: 'removed'
+    },
+    allowConfluenceInlineComment: {
+      message: 'To integrate inline comments use experimental annotationProvider – <Editor annotationProviders={{ provider }} />',
+      type: 'removed'
+    },
+    smartLinks: {
+      message: 'To use smartLinks, pass the same object into the smartlinks key of linking - <Editor linking={{ smartLinks: {existing object} }}.',
+      type: 'removed'
+    }
+  };
+  Object.keys(deprecatedProperties).forEach(function (property) {
+    if (props.hasOwnProperty(property)) {
+      var meta = deprecatedProperties[property];
+      var type = meta.type || 'enabled by default';
+
+      // eslint-disable-next-line no-console
+      console.warn("".concat(property, " property is deprecated. ").concat(meta.message || '', " [Will be ").concat(type, " in editor-core@").concat(nextVersion, "]"));
+    }
+  });
+  if (props.hasOwnProperty('allowTables') && typeof props.allowTables !== 'boolean' && (!props.allowTables || !props.allowTables.advanced)) {
+    // eslint-disable-next-line no-console
+    console.warn("Advanced table options are deprecated (except isHeaderRowRequired) to continue using advanced table features use - <Editor allowTables={{ advanced: true }} /> [Will be changed in editor-core@".concat(nextVersion, "]"));
+  }
+  if (props.hasOwnProperty('allowTextColor') && typeof props.allowTextColor !== 'boolean' && (props === null || props === void 0 ? void 0 : (_props$allowTextColor = props.allowTextColor) === null || _props$allowTextColor === void 0 ? void 0 : _props$allowTextColor.allowMoreTextColors) !== undefined) {
+    // eslint-disable-next-line no-console
+    console.warn("\"allowMoreTextColors\" field of \"allowTextColor\" property is deprecated. It will be removedin editor-core@".concat(nextVersion, ". The color palette now shows more colors by default."));
+  }
+}

package/dist/cjs/editor-next/utils/editorMeasureTTICallback.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = editorMeasureTTICallback;
+var _utils = require("@atlaskit/editor-common/utils");
+var _ufo = require("@atlaskit/editor-common/ufo");
+var _analytics = require("@atlaskit/editor-common/analytics");
+function editorMeasureTTICallback(tti, ttiFromInvocation, canceled, performanceTracking, featureFlags, createAnalyticsEvent, experienceStore) {
+  var _performanceTracking$;
+  if (performanceTracking !== null && performanceTracking !== void 0 && (_performanceTracking$ = performanceTracking.ttiTracking) !== null && _performanceTracking$ !== void 0 && _performanceTracking$.enabled && createAnalyticsEvent) {
+    var _ttiTracking;
+    var ttiEvent = {
+      payload: {
+        action: _analytics.ACTION.EDITOR_TTI,
+        actionSubject: _analytics.ACTION_SUBJECT.EDITOR,
+        attributes: {
+          tti: tti,
+          ttiFromInvocation: ttiFromInvocation,
+          canceled: canceled
+        },
+        eventType: _analytics.EVENT_TYPE.OPERATIONAL
+      }
+    };
+    if ((_ttiTracking = performanceTracking.ttiTracking) !== null && _ttiTracking !== void 0 && _ttiTracking.trackSeverity) {
+      var _ttiTracking2 = performanceTracking.ttiTracking,
+        ttiSeverityNormalThreshold = _ttiTracking2.ttiSeverityNormalThreshold,
+        ttiSeverityDegradedThreshold = _ttiTracking2.ttiSeverityDegradedThreshold,
+        ttiFromInvocationSeverityNormalThreshold = _ttiTracking2.ttiFromInvocationSeverityNormalThreshold,
+        ttiFromInvocationSeverityDegradedThreshold = _ttiTracking2.ttiFromInvocationSeverityDegradedThreshold;
+      var _getTTISeverity = (0, _utils.getTTISeverity)(tti, ttiFromInvocation, ttiSeverityNormalThreshold, ttiSeverityDegradedThreshold, ttiFromInvocationSeverityNormalThreshold, ttiFromInvocationSeverityDegradedThreshold),
+        ttiSeverity = _getTTISeverity.ttiSeverity,
+        ttiFromInvocationSeverity = _getTTISeverity.ttiFromInvocationSeverity;
+      ttiEvent.payload.attributes.ttiSeverity = ttiSeverity;
+      ttiEvent.payload.attributes.ttiFromInvocationSeverity = ttiFromInvocationSeverity;
+    }
+    (0, _analytics.fireAnalyticsEvent)(createAnalyticsEvent)(ttiEvent);
+  }
+  if (featureFlags !== null && featureFlags !== void 0 && featureFlags.ufo) {
+    experienceStore === null || experienceStore === void 0 ? void 0 : experienceStore.mark(_ufo.EditorExperience.loadEditor, _analytics.ACTION.EDITOR_TTI, tti);
+    experienceStore === null || experienceStore === void 0 ? void 0 : experienceStore.success(_ufo.EditorExperience.loadEditor);
+  }
+}

package/dist/cjs/editor-next/utils/editorPropTypes.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultProps = void 0;
+exports.propTypes = propTypes;
+/**
+ *
+ * Logic for Editor prop types (ie. `static propTypes = propTypes(message)`)
+ * for use with 'prop-types' library
+ *
+ * @param errorMessage
+ * @returns Editor prop-types
+ */
+function propTypes(errorMessage) {
+  return {
+    minHeight: function minHeight(_ref) {
+      var appearance = _ref.appearance,
+        _minHeight = _ref.minHeight;
+      if (_minHeight && appearance && !['comment', 'chromeless'].includes(appearance)) {
+        return new Error(errorMessage);
+      }
+      return null;
+    }
+  };
+}
+var defaultProps = {
+  appearance: 'comment',
+  disabled: false,
+  extensionHandlers: {},
+  allowHelpDialog: true,
+  allowNewInsertionBehaviour: true,
+  quickInsert: true
+};
+exports.defaultProps = defaultProps;

package/dist/cjs/editor-next/utils/getBaseFontSize.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBaseFontSize = getBaseFontSize;
+var _editorSharedStyles = require("@atlaskit/editor-shared-styles");
+/**
+ * @param appearance
+ * @returns default font size if valid
+ */
+function getBaseFontSize(appearance) {
+  if (appearance === undefined) {
+    return _editorSharedStyles.akEditorFullPageDefaultFontSize;
+  }
+  return !['comment', 'chromeless', 'mobile'].includes(appearance) ? _editorSharedStyles.akEditorFullPageDefaultFontSize : undefined;
+}

package/dist/cjs/editor-next/utils/getProvidersFromEditorProps.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getProvidersFromEditorProps;
+function getProvidersFromEditorProps(_ref) {
+  var _linking$smartLinks;
+  var linking = _ref.linking,
+    smartLinks = _ref.smartLinks,
+    UNSAFE_cards = _ref.UNSAFE_cards,
+    autoformattingProvider = _ref.autoformattingProvider,
+    media = _ref.media,
+    emojiProvider = _ref.emojiProvider,
+    mentionProvider = _ref.mentionProvider,
+    legacyImageUploadProvider = _ref.legacyImageUploadProvider,
+    taskDecisionProvider = _ref.taskDecisionProvider,
+    contextIdentifierProvider = _ref.contextIdentifierProvider,
+    searchProvider = _ref.searchProvider,
+    macroProvider = _ref.macroProvider,
+    activityProvider = _ref.activityProvider,
+    collabEdit = _ref.collabEdit,
+    collabEditProvider = _ref.collabEditProvider,
+    presenceProvider = _ref.presenceProvider;
+  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;
+  return {
+    mediaProvider: media === null || media === void 0 ? void 0 : media.provider,
+    emojiProvider: emojiProvider,
+    mentionProvider: mentionProvider,
+    autoformattingProvider: autoformattingProvider,
+    cardProvider: cardProvider,
+    activityProvider: activityProvider,
+    imageUploadProvider: legacyImageUploadProvider,
+    taskDecisionProvider: taskDecisionProvider,
+    contextIdentifierProvider: contextIdentifierProvider,
+    searchProvider: searchProvider,
+    presenceProvider: presenceProvider,
+    macroProvider: macroProvider,
+    collabEditProvider: collabEdit && collabEdit.provider ? collabEdit.provider : collabEditProvider
+  };
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = handleProviders;
+/**
+ *
+ * Utility to set all the providers on a provider factory
+ *
+ * @param providerFactory
+ * @param props
+ * @param extensionProvider
+ * @param quickInsertProvider
+ */
+function handleProviders(providerFactory, _ref, extensionProvider, quickInsertProvider) {
+  var emojiProvider = _ref.emojiProvider,
+    mentionProvider = _ref.mentionProvider,
+    taskDecisionProvider = _ref.taskDecisionProvider,
+    contextIdentifierProvider = _ref.contextIdentifierProvider,
+    collabEditProvider = _ref.collabEditProvider,
+    activityProvider = _ref.activityProvider,
+    presenceProvider = _ref.presenceProvider,
+    macroProvider = _ref.macroProvider,
+    imageUploadProvider = _ref.imageUploadProvider,
+    mediaProvider = _ref.mediaProvider,
+    autoformattingProvider = _ref.autoformattingProvider,
+    searchProvider = _ref.searchProvider,
+    cardProvider = _ref.cardProvider;
+  providerFactory.setProvider('emojiProvider', emojiProvider);
+  providerFactory.setProvider('mentionProvider', mentionProvider);
+  providerFactory.setProvider('taskDecisionProvider', taskDecisionProvider);
+  providerFactory.setProvider('contextIdentifierProvider', contextIdentifierProvider);
+  providerFactory.setProvider('mediaProvider', mediaProvider);
+  providerFactory.setProvider('imageUploadProvider', imageUploadProvider);
+  providerFactory.setProvider('collabEditProvider', collabEditProvider);
+  providerFactory.setProvider('activityProvider', activityProvider);
+  providerFactory.setProvider('searchProvider', searchProvider);
+  providerFactory.setProvider('presenceProvider', presenceProvider);
+  providerFactory.setProvider('macroProvider', macroProvider);
+  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/cjs/editor-next/utils/onEditorCreated.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = onEditorCreated;
+var _ufo = require("@atlaskit/editor-common/ufo");
+var _utils = require("@atlaskit/editor-common/utils");
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _measureEnum = _interopRequireDefault(require("../../utils/performance/measure-enum"));
+var _sendDurationAnalytics = _interopRequireDefault(require("./sendDurationAnalytics"));
+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(_ufo.ExperienceStore.getInstance(instance.view));
+    (_getExperienceStore = getExperienceStore()) === null || _getExperienceStore === void 0 ? void 0 : _getExperienceStore.start(_ufo.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 && (0, _utils.startMeasure)(_measureEnum.default.ON_EDITOR_READY_CALLBACK);
+    props.onEditorReady(editorActions);
+    measureEditorReady && (0, _utils.stopMeasure)(_measureEnum.default.ON_EDITOR_READY_CALLBACK, (0, _sendDurationAnalytics.default)(_analytics.ACTION.ON_EDITOR_READY_CALLBACK, props, getExperienceStore, getCreateAnalyticsEvent()));
+  }
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = sendDurationAnalytics;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _ufo = require("@atlaskit/editor-common/ufo");
+var _analytics = require("@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
+ */
+function sendDurationAnalytics(action, props, getExperienceStore, createAnalyticsEvent) {
+  return /*#__PURE__*/function () {
+    var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(duration, startTime) {
+      var _props$featureFlags;
+      var contextIdentifier, objectId, experienceStore;
+      return _regenerator.default.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) {
+                (0, _analytics.fireAnalyticsEvent)(createAnalyticsEvent)({
+                  payload: {
+                    action: action,
+                    actionSubject: _analytics.ACTION_SUBJECT.EDITOR,
+                    attributes: {
+                      duration: duration,
+                      startTime: startTime,
+                      objectId: objectId
+                    },
+                    eventType: _analytics.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(_ufo.EditorExperience.loadEditor, action, startTime + duration);
+                experienceStore === null || experienceStore === void 0 ? void 0 : experienceStore.addMetadata(_ufo.EditorExperience.loadEditor, {
+                  objectId: objectId
+                });
+              }
+            case 6:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}

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

@@ -0,0 +1,101 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = trackEditorActions;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+/**
+ *
+ * Util function to be used with the Editor to track the EditorActions prop
+ *
+ * @param editorActions
+ * @param performanceTracking
+ * @param handleAnalyticsEvent
+ * @returns
+ */
+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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+          var _performanceTracking$2, _performanceTracking$3, value, _performanceTracking$4, _performanceTracking$5, _performanceTracking$6;
+          return _regenerator.default.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: _analytics.ACTION.EDITOR_CONTENT_RETRIEVAL_PERFORMED,
+                        actionSubject: _analytics.ACTION_SUBJECT.EDITOR,
+                        attributes: {
+                          success: true
+                        },
+                        eventType: _analytics.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: _analytics.ACTION.EDITOR_CONTENT_RETRIEVAL_PERFORMED,
+                        actionSubject: _analytics.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: _analytics.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;
+}