@atlaskit/editor-common 69.2.2 → 69.3.1

package/dist/esm/with-plugin-state/index.js

@@ -0,0 +1,311 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+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); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : 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; } }
+
+import React from 'react';
+import PropTypes from 'prop-types';
+var DEFAULT_SAMPLING_RATE = 100;
+var DEFAULT_SLOW_THRESHOLD = 4;
+
+/**
+ * Wraps component in a high order component that watches state changes of given plugins
+ * and passes those states to the wrapped component.
+ *
+ * Example:
+ * <WithPluginState
+ *   eventDispatcher={eventDispatcher}
+ *   editorView={editorView}
+ *   plugins={{
+ *     hyperlink: hyperlinkPluginKey
+ *   }}
+ *   render={renderComponent}
+ * />
+ *
+ * renderComponent: ({ hyperlink }) => React.Component;
+ */
+var WithPluginState = /*#__PURE__*/function (_React$Component) {
+  _inherits(WithPluginState, _React$Component);
+
+  var _super = _createSuper(WithPluginState);
+
+  function WithPluginState() {
+    var _this;
+
+    _classCallCheck(this, WithPluginState);
+
+    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));
+
+    _defineProperty(_assertThisInitialized(_this), "listeners", {});
+
+    _defineProperty(_assertThisInitialized(_this), "debounce", null);
+
+    _defineProperty(_assertThisInitialized(_this), "notAppliedState", {});
+
+    _defineProperty(_assertThisInitialized(_this), "isSubscribed", false);
+
+    _defineProperty(_assertThisInitialized(_this), "state", _this.getPluginsStates(_this.props.plugins, _this.getEditorView(_this.props, _this.context)));
+
+    _defineProperty(_assertThisInitialized(_this), "handlePluginStateChange", function (propName, pluginName, performanceOptions, skipEqualityCheck) {
+      return function (pluginState) {
+        // skipEqualityCheck is being used for old plugins since they are mutating plugin state instead of creating a new one
+        if (_this.state[propName] !== pluginState || skipEqualityCheck) {
+          _this.updateState({
+            stateSubset: _defineProperty({}, propName, pluginState),
+            pluginName: pluginName,
+            performanceOptions: performanceOptions
+          });
+        }
+      };
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "updateState", function (_ref) {
+      var stateSubset = _ref.stateSubset,
+          pluginName = _ref.pluginName,
+          performanceOptions = _ref.performanceOptions;
+      _this.notAppliedState = _objectSpread(_objectSpread({}, _this.notAppliedState), stateSubset);
+
+      if (_this.debounce) {
+        window.clearTimeout(_this.debounce);
+      }
+
+      var debounce = _this.props.debounce !== false ? function (fn) {
+        return window.setTimeout(fn, 0);
+      } : function (fn) {
+        return fn();
+      };
+      _this.debounce = debounce(function () {
+        // TODO: ED-15580
+        //const measure = `🦉${pluginName}::WithPluginState`;
+        //performanceOptions.trackingEnabled && startMeasure(measure);
+        //              () => {
+        //  performanceOptions.trackingEnabled &&
+        //    stopMeasure(measure, (duration) => {
+        //      // Each WithPluginState component will fire analytics event no more than once every `samplingLimit` times
+        //      if (
+        //        ++this.callsCount % performanceOptions.samplingRate === 0 &&
+        //        duration > performanceOptions.slowThreshold
+        //      ) {
+        //        const editorView = this.getEditorView();
+        //        this.dispatchAnalyticsEvent({
+        //          action: ACTION.WITH_PLUGIN_STATE_CALLED,
+        //          actionSubject: ACTION_SUBJECT.EDITOR,
+        //          eventType: EVENT_TYPE.OPERATIONAL,
+        //          attributes: {
+        //            plugin: pluginName,
+        //            duration,
+        //            participants: getParticipantsCount(
+        //              editorView && editorView.state,
+        //            ),
+        //          },
+        //        });
+        //      }
+        //    });
+        //}
+        _this.setState(_this.notAppliedState);
+
+        _this.debounce = null;
+        _this.notAppliedState = {};
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onContextUpdate", function () {
+      _this.subscribe(_this.props);
+    });
+
+    return _this;
+  }
+
+  _createClass(WithPluginState, [{
+    key: "getEditorView",
+    value: function getEditorView(maybeProps, maybeContext) {
+      var props = maybeProps || this.props;
+      var context = maybeContext || this.context;
+      return props.editorView || context && context.editorActions && context.editorActions._privateGetEditorView() || context && context.editorSharedConfig && context.editorSharedConfig.editorView;
+    }
+  }, {
+    key: "getEventDispatcher",
+    value: function getEventDispatcher(maybeProps) {
+      var props = maybeProps || this.props;
+      return props.eventDispatcher || this.context && this.context.editorActions && this.context.editorActions._privateGetEventDispatcher() || this.context && this.context.editorSharedConfig && this.context.editorSharedConfig.eventDispatcher;
+    }
+  }, {
+    key: "getPluginsStates",
+    value: // TODO: ED-15580
+    //private dispatchAnalyticsEvent = (payload: AnalyticsEventPayload) => {
+    //  const eventDispatcher = this.getEventDispatcher();
+    //  if (eventDispatcher) {
+    //    const dispatch: AnalyticsDispatch = createDispatch(eventDispatcher);
+    //    dispatch(analyticsEventKey, {
+    //      payload,
+    //    });
+    //  }
+    //};
+    function getPluginsStates(plugins, editorView) {
+      if (!editorView || !plugins) {
+        return {};
+      }
+
+      var keys = Object.keys(plugins);
+      return keys.reduce(function (acc, propName) {
+        var pluginKey = plugins[propName];
+
+        if (!pluginKey) {
+          return acc;
+        }
+
+        acc[propName] = pluginKey.getState(editorView.state);
+        return acc;
+      }, {});
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe(props) {
+      var _this2 = this;
+
+      var plugins = props.plugins;
+      var eventDispatcher = this.getEventDispatcher(props);
+      var editorView = this.getEditorView(props);
+
+      if (!eventDispatcher || !editorView || this.isSubscribed) {
+        return;
+      } // TODO: ED-15580
+      //const analyticsPlugin = analyticsPluginKey.getState(editorView.state);
+      //const uiTracking =
+      //  analyticsPlugin && analyticsPlugin.performanceTracking
+      //    ? analyticsPlugin.performanceTracking.uiTracking || {}
+      //    : {};
+      //const trackingEnabled = uiTracking.enabled === true;
+      //const samplingRate = uiTracking.samplingRate || DEFAULT_SAMPLING_RATE;
+      //const slowThreshold = uiTracking.slowThreshold || DEFAULT_SLOW_THRESHOLD;
+
+
+      var trackingEnabled = false;
+      var samplingRate = DEFAULT_SAMPLING_RATE;
+      var slowThreshold = DEFAULT_SLOW_THRESHOLD;
+      this.isSubscribed = true;
+      var pluginsStates = this.getPluginsStates(plugins, editorView);
+      this.setState(pluginsStates);
+      Object.keys(plugins).forEach(function (propName) {
+        var pluginKey = plugins[propName];
+
+        if (!pluginKey) {
+          return;
+        }
+
+        var pluginName = pluginKey.key;
+        var pluginState = pluginsStates[propName];
+        var isPluginWithSubscribe = pluginState && pluginState.subscribe;
+
+        var handler = _this2.handlePluginStateChange(propName, pluginName, {
+          samplingRate: samplingRate,
+          slowThreshold: slowThreshold,
+          trackingEnabled: trackingEnabled
+        }, isPluginWithSubscribe);
+
+        if (isPluginWithSubscribe) {
+          pluginState.subscribe(handler);
+        } else {
+          eventDispatcher.on(pluginKey.key, handler);
+        }
+
+        _this2.listeners[pluginKey.key] = {
+          handler: handler,
+          pluginKey: pluginKey
+        };
+      });
+    }
+  }, {
+    key: "unsubscribe",
+    value: function unsubscribe() {
+      var _this3 = this;
+
+      var eventDispatcher = this.getEventDispatcher();
+      var editorView = this.getEditorView();
+
+      if (!eventDispatcher || !editorView || !this.isSubscribed) {
+        return;
+      }
+
+      Object.keys(this.listeners).forEach(function (key) {
+        var pluginState = _this3.listeners[key].pluginKey.getState(editorView.state);
+
+        if (pluginState && pluginState.unsubscribe) {
+          pluginState.unsubscribe(_this3.listeners[key].handler);
+        } else {
+          eventDispatcher.off(key, _this3.listeners[key].handler);
+        }
+      });
+      this.listeners = [];
+    }
+  }, {
+    key: "subscribeToContextUpdates",
+    value: function subscribeToContextUpdates(context) {
+      if (context && context.editorActions) {
+        context.editorActions._privateSubscribe(this.onContextUpdate);
+      }
+    }
+  }, {
+    key: "unsubscribeFromContextUpdates",
+    value: function unsubscribeFromContextUpdates(context) {
+      if (context && context.editorActions) {
+        context.editorActions._privateUnsubscribe(this.onContextUpdate);
+      }
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.subscribe(this.props);
+      this.subscribeToContextUpdates(this.context);
+    }
+  }, {
+    key: "UNSAFE_componentWillReceiveProps",
+    value: function UNSAFE_componentWillReceiveProps(nextProps) {
+      if (!this.isSubscribed) {
+        this.subscribe(nextProps);
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.debounce) {
+        window.clearTimeout(this.debounce);
+      }
+
+      this.unsubscribeFromContextUpdates(this.context);
+      this.unsubscribe();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var render = this.props.render;
+      return render(this.state);
+    }
+  }]);
+
+  return WithPluginState;
+}(React.Component);
+
+_defineProperty(WithPluginState, "displayName", 'WithPluginState');
+
+_defineProperty(WithPluginState, "contextTypes", {
+  editorActions: PropTypes.object,
+  editorSharedConfig: PropTypes.object
+});
+
+export { WithPluginState };

package/dist/esm/with-plugin-state/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types/analytics/api.d.ts

@@ -0,0 +1,5 @@
+import type { Transaction } from 'prosemirror-state';
+import type { AnalyticsEventPayload } from './types';
+export declare type EditorAnalyticsAPI = {
+    attachAnalyticsEvent: (payload: AnalyticsEventPayload) => (tr: Transaction) => boolean;
+};

package/dist/types/analytics/index.d.ts

@@ -0,0 +1,3 @@
+export { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, BROWSER_FREEZE_INTERACTION_TYPE, CONTENT_COMPONENT, DELETE_DIRECTION, EVENT_TYPE, FLOATING_CONTROLS_TITLE, FULL_WIDTH_MODE, GAP_CURSOR_POSITION, INDENT_DIRECTION, INDENT_TYPE, INPUT_METHOD, LAYOUT_TYPE, LINK_REPRESENTATION, LINK_RESOURCE, LINK_STATUS, LIST_TEXT_SCENARIOS, MODE, PLATFORMS, PUNC, PasteContents, PasteSources, PasteTypes, RESOLVE_METHOD, SELECTION_TYPE, SELECTION_POSITION, SMART_LINK_TYPE, SYMBOL, SmartLinkNodeContexts, TABLE_ACTION, TABLE_BREAKOUT, TARGET_SELECTION_SOURCE, TOOLBAR_ACTION_SUBJECT_ID, TRIGGER_METHOD, USER_CONTEXT, } from './types';
+export type { AnalyticsDispatch, AnalyticsEventPayload, AnalyticsEventPayloadCallback, AnalyticsEventPayloadWithChannel, AnnotationAEP, AnnotationAEPAttributes, AnnotationActionType, AnnotationDraftAEPAttributes, AnnotationResolvedAEPAttributes, CaptionTrackAction, ColorPickerAEP, CommonListAnalyticsAttributes, CreateLinkInlineDialogActionType, CreateLinkInlineDialogEventPayload, DismissedCreateLinkInlineDialogAEP, DispatchAnalyticsEvent, EditLinkToolbarAEP, EnteredTextLinkSearchInputAEP, ErrorEventAttributes, ErrorEventPayload, ExperimentalEventPayload, ExtensionEventPayload, ExtensionType, FeatureExposureAEP, FormatEventPayload, GeneralEventPayload, HighlightedSearchResultsAEP, InputMethodInsertLink, InputMethodInsertMedia, InsertEventPayload, InsertSmartLinkAEP, ListEventPayload, MediaAltTextActionType, MediaEventPayload, MediaLinkAEP, NodeCount, NodeEventPayload, PASTE_ACTION_SUBJECT_ID, PasteContent, PasteEventPayload, PasteSource, PasteType, PluginMethodReport, PluginPerformanceReportData, PluginsReport, QuickSearchPerfAEP, RecentActivitiesPerfAEP, SelectAllAEP, SelectCellAEP, SelectNodeAEP, SelectRangeAEP, SelectedSearchResultsAEP, SelectionEventPayload, SelectionJson, ShownPostQuerySearchResultsAEP, ShownPreQuerySearchResultsAEP, SimplifiedNode, SmartLinkNodeContext, SubstituteEventPayload, TableEventPayload, TextColorSelectedAEP, TextColorSelectedAttr, TextColorShowPaletteToggleAEP, TextColorShowPaletteToggleAttr, ToolbarEventPayload, TransactionEventPayload, TypeAheadPayload, UfoSessionCompletePayloadAEP, UnlinkToolbarAEP, ViewedCreateLinkInlineDialogAEP, FireAnalyticsCallback, } from './types';
+export type { EditorAnalyticsAPI } from './api';

package/dist/types/analytics/types/avatar.d.ts

@@ -0,0 +1,5 @@
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID } from './enums';
+import { UIAEP } from './utils';
+declare type AvatarButtonViewedAEP = UIAEP<ACTION.VIEWED, ACTION_SUBJECT.BUTTON, ACTION_SUBJECT_ID.AVATAR_GROUP_PLUGIN, {}, undefined>;
+export declare type AvatarEventPayload = AvatarButtonViewedAEP;
+export {};

package/dist/types/analytics/types/block.d.ts

@@ -0,0 +1,3 @@
+export declare type HeadingLevels = 1 | 2 | 3 | 4 | 5 | 6;
+export declare type NormalTextLevel = 0;
+export declare type HeadingLevelsAndNormalText = HeadingLevels | NormalTextLevel;

package/dist/types/analytics/types/config-panel-events.d.ts

@@ -0,0 +1,17 @@
+import { ACTION, ACTION_SUBJECT } from './enums';
+import { UIAEP } from './utils';
+declare type OpenAEP = UIAEP<ACTION.OPENED, ACTION_SUBJECT.CONFIG_PANEL, undefined, {}, undefined>;
+declare type CloseAEP = UIAEP<ACTION.CLOSED, ACTION_SUBJECT.CONFIG_PANEL, undefined, {}, undefined>;
+declare type ConfigPanelCrashedAEP = UIAEP<ACTION.ERRORED, ACTION_SUBJECT.CONFIG_PANEL, undefined, {
+    product: string;
+    browserInfo: string;
+    extensionKey: string;
+    fields: string;
+    error: string;
+    errorInfo?: {
+        componentStack: string;
+    };
+    errorStack?: string;
+}, undefined>;
+export declare type ConfigPanelEventPayload = OpenAEP | CloseAEP | ConfigPanelCrashedAEP;
+export {};

package/dist/types/analytics/types/cut-copy-events.d.ts

@@ -0,0 +1,12 @@
+import { ACTION, ACTION_SUBJECT } from './enums';
+import { TrackAEP } from './utils';
+declare type CopyAEP = TrackAEP<ACTION.COPIED, ACTION_SUBJECT.DOCUMENT, undefined, {
+    content: string[];
+    inputMethod?: string;
+    nodeType?: string;
+}, undefined>;
+declare type CutAEP = TrackAEP<ACTION.CUT, ACTION_SUBJECT.DOCUMENT, undefined, {
+    content: string[];
+}, undefined>;
+export declare type CutCopyEventPayload = CutAEP | CopyAEP;
+export {};

package/dist/types/analytics/types/date-events.d.ts

@@ -0,0 +1,17 @@
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, INPUT_METHOD } from './enums';
+import { TrackAEP } from './utils';
+declare type TypeDateStartedAEP = TrackAEP<ACTION.TYPING_STARTED, ACTION_SUBJECT.DATE, undefined, undefined, undefined>;
+declare type TypeDateFinishedAEP = TrackAEP<ACTION.TYPING_FINISHED, ACTION_SUBJECT.DATE, undefined, undefined, undefined>;
+declare type IncrementDateSegmentAEP = TrackAEP<ACTION.INCREMENTED, ACTION_SUBJECT.DATE_SEGMENT, undefined, {
+    dateSegment: ACTION_SUBJECT_ID.DATE_DAY | ACTION_SUBJECT_ID.DATE_MONTH | ACTION_SUBJECT_ID.DATE_YEAR;
+}, undefined>;
+declare type DecrementDateSegmentAEP = TrackAEP<ACTION.DECREMENTED, ACTION_SUBJECT.DATE_SEGMENT, undefined, {
+    dateSegment: ACTION_SUBJECT_ID.DATE_DAY | ACTION_SUBJECT_ID.DATE_MONTH | ACTION_SUBJECT_ID.DATE_YEAR;
+}, undefined>;
+declare type CommitDateAEP = TrackAEP<ACTION.COMMITTED, ACTION_SUBJECT.DATE, undefined, {
+    commitMethod: INPUT_METHOD.PICKER | INPUT_METHOD.BLUR | INPUT_METHOD.KEYBOARD;
+    isValid: true | false;
+    isToday: true | false;
+}, undefined>;
+export declare type DateEventPayload = TypeDateStartedAEP | TypeDateFinishedAEP | IncrementDateSegmentAEP | DecrementDateSegmentAEP | CommitDateAEP;
+export {};

package/dist/types/analytics/types/dispatch-analytics-event.d.ts

@@ -0,0 +1,2 @@
+import { AnalyticsEventPayload } from './events';
+export declare type DispatchAnalyticsEvent = (payload: AnalyticsEventPayload) => void;

package/dist/types/analytics/types/element-browser-events.d.ts

@@ -0,0 +1,11 @@
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID } from './enums';
+import { TrackAEP, UIAEP } from './utils';
+declare type OpenAEP = UIAEP<ACTION.OPENED, ACTION_SUBJECT.ELEMENT_BROWSER, undefined, {
+    mode: 'full' | 'inline';
+}, undefined>;
+declare type CloseAEP = UIAEP<ACTION.CLOSED, ACTION_SUBJECT.ELEMENT_BROWSER, undefined, {
+    mode: 'full' | 'inline';
+}, undefined>;
+declare type ClickedElementBrowserCategory = TrackAEP<ACTION.CLICKED, ACTION_SUBJECT.BUTTON, ACTION_SUBJECT_ID.BUTTON_CATEGORY, any, undefined>;
+export declare type ElementBrowserEventPayload = OpenAEP | CloseAEP | ClickedElementBrowserCategory;
+export {};