@atlaskit/editor-core 173.0.1 → 175.0.0

package/dist/esm/ui/WithPluginState/index.js

@@ -1,307 +1,2 @@
-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';
-import { startMeasure, stopMeasure } from '@atlaskit/editor-common/utils';
-import { createDispatch } from '../../event-dispatcher';
-import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '../../plugins/analytics';
-import { analyticsEventKey } from '@atlaskit/editor-common/utils';
-import { analyticsPluginKey } from '../../plugins/analytics/plugin-key';
-import { getParticipantsCount } from '../../plugins/collab-edit/get-participants-count';
-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), "callsCount", 0);
-
-    _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 () {
-        var measure = "\uD83E\uDD89".concat(pluginName, "::WithPluginState");
-        performanceOptions.trackingEnabled && startMeasure(measure);
-
-        _this.setState(_this.notAppliedState, function () {
-          performanceOptions.trackingEnabled && stopMeasure(measure, function (duration) {
-            // Each WithPluginState component will fire analytics event no more than once every `samplingLimit` times
-            if (++_this.callsCount % performanceOptions.samplingRate === 0 && duration > performanceOptions.slowThreshold) {
-              var editorView = _this.getEditorView();
-
-              _this.dispatchAnalyticsEvent({
-                action: ACTION.WITH_PLUGIN_STATE_CALLED,
-                actionSubject: ACTION_SUBJECT.EDITOR,
-                eventType: EVENT_TYPE.OPERATIONAL,
-                attributes: {
-                  plugin: pluginName,
-                  duration: duration,
-                  participants: getParticipantsCount(editorView && editorView.state)
-                }
-              });
-            }
-          });
-        });
-
-        _this.debounce = null;
-        _this.notAppliedState = {};
-      });
-    });
-
-    _defineProperty(_assertThisInitialized(_this), "dispatchAnalyticsEvent", function (payload) {
-      var eventDispatcher = _this.getEventDispatcher();
-
-      if (eventDispatcher) {
-        var dispatch = createDispatch(eventDispatcher);
-        dispatch(analyticsEventKey, {
-          payload: payload
-        });
-      }
-    });
-
-    _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: 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;
-      }
-
-      var analyticsPlugin = analyticsPluginKey.getState(editorView.state);
-      var uiTracking = analyticsPlugin && analyticsPlugin.performanceTracking ? analyticsPlugin.performanceTracking.uiTracking || {} : {};
-      var trackingEnabled = uiTracking.enabled === true;
-      var samplingRate = uiTracking.samplingRate || DEFAULT_SAMPLING_RATE;
-      var slowThreshold = uiTracking.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 as default };
+import { WithPluginState } from '@atlaskit/editor-common/with-plugin-state';
+export default WithPluginState;

package/dist/esm/utils/commands.js

@@ -3,6 +3,7 @@ import { TextSelection, NodeSelection } from 'prosemirror-state';
 import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
 import { transformSmartCharsMentionsAndEmojis } from '../plugins/text-formatting/commands/transform-to-code';
 import { GapCursorSelection } from '../plugins/selection/gap-cursor-selection';
+import { isEmptyParagraph } from './document';
 
 var filter = function filter(predicates, cmd) {
   return function (state, dispatch, view) {
@@ -288,5 +289,43 @@ var selectNode = function selectNode(pos) {
     return true;
   };
 };
+/**
+ * If the selection is empty, is inside a paragraph node and `canNextNodeMoveUp` is true then delete current paragraph
+ * and move the node below it up. The selection will be retained, to be placed in the moved node.
+ *
+ * @param canNextNodeMoveUp check if node directly after the selection is able to be brought up to selection
+ * @returns PM Command
+ */
+
+
+var deleteEmptyParagraphAndMoveBlockUp = function deleteEmptyParagraphAndMoveBlockUp(canNextNodeMoveUp) {
+  return function (state, dispatch, view) {
+    var _state$selection4 = state.selection,
+        _state$selection4$$fr = _state$selection4.$from,
+        pos = _state$selection4$$fr.pos,
+        parent = _state$selection4$$fr.parent,
+        $head = _state$selection4.$head,
+        empty = _state$selection4.empty,
+        tr = state.tr,
+        doc = state.doc;
+
+    var _walkNextNode = walkNextNode($head),
+        $pos = _walkNextNode.$pos;
+
+    var nextPMNode = doc.nodeAt($pos.pos - 1);
+
+    if (empty && nextPMNode && canNextNodeMoveUp(nextPMNode) && isEmptyParagraph(parent) && view !== null && view !== void 0 && view.endOfTextblock('right')) {
+      tr.deleteRange(pos - 1, pos + 1);
+
+      if (dispatch) {
+        dispatch(tr);
+      }
+
+      return true;
+    }
+
+    return false;
+  };
+};
 
-export { filter, isEmptySelectionAtStart, isEmptySelectionAtEnd, isFirstChildOfParent, isNthParentOfType, findCutBefore, toggleMark, applyMarkOnRange, withScrollIntoView, walkNextNode, walkPrevNode, insertContentDeleteRange, selectNode };
+export { filter, isEmptySelectionAtStart, isEmptySelectionAtEnd, isFirstChildOfParent, isNthParentOfType, findCutBefore, toggleMark, applyMarkOnRange, withScrollIntoView, walkNextNode, walkPrevNode, insertContentDeleteRange, selectNode, deleteEmptyParagraphAndMoveBlockUp };

package/dist/esm/utils/input-rules.js

@@ -8,7 +8,7 @@ import { canJoin, findWrapping } from 'prosemirror-transform';
 import { closeHistory } from 'prosemirror-history';
 import { TextSelection } from 'prosemirror-state';
 import { addAnalytics } from '../plugins/analytics/utils';
-import { createInputRulePlugin, MAX_REGEX_MATCH } from '@atlaskit/prosemirror-input-rules';
+import { createInputRulePlugin } from '@atlaskit/prosemirror-input-rules';
 export var ruleWithAnalytics = function ruleWithAnalytics(getPayload) {
   return function (originalRule) {
     var onHandlerApply = function onHandlerApply(state, tr, matchResult) {
@@ -54,13 +54,7 @@ export var createPlugin = function createPlugin(pluginName, rules) {
   var _options$isBlockNodeR = options.isBlockNodeRule,
       isBlockNodeRule = _options$isBlockNodeR === void 0 ? false : _options$isBlockNodeR,
       _options$allowInsertT = options.allowInsertTextOnDocument,
-      allowInsertTextOnDocument = _options$allowInsertT === void 0 ? true : _options$allowInsertT,
-      _options$useUnpredict = options.useUnpredictableInputRule,
-      useUnpredictableInputRule = _options$useUnpredict === void 0 ? true : _options$useUnpredict;
-
-  if (useUnpredictableInputRule) {
-    return createUnpredictableInputRulePlugin(pluginName, rules, isBlockNodeRule);
-  }
+      allowInsertTextOnDocument = _options$allowInsertT === void 0 ? true : _options$allowInsertT;
 
   var onInputEvent = function onInputEvent(_ref) {
     var state = _ref.state,
@@ -182,130 +176,4 @@ var isCursorInsideUnsupportedMarks = function isCursorInsideUnsupportedMarks(sta
   };
 
   return Boolean($cursor === null || $cursor === void 0 ? void 0 : (_$cursor$nodeBefore = $cursor.nodeBefore) === null || _$cursor$nodeBefore === void 0 ? void 0 : (_$cursor$nodeBefore$m = _$cursor$nodeBefore.marks) === null || _$cursor$nodeBefore$m === void 0 ? void 0 : _$cursor$nodeBefore$m.some(isUnsupportedMark));
-}; // UnPredictable Input Rule
-// After the new UndoRedo system being rollout,
-// The function below can be removed.
-// https://product-fabric.atlassian.net/browse/ED-12676
-
-
-import { inputRules as unpredictableInputRulesPlugin, InputRule as UnpredictableInputRule } from 'prosemirror-inputrules';
-import { startMeasure, stopMeasure } from '@atlaskit/editor-common/utils';
-
-function createUnpredictableInputRulePlugin(pluginName, rules) {
-  var isBlockNodeRule = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-
-  var hasUnsupportedMarkForBlockInputRule = function hasUnsupportedMarkForBlockInputRule(state, start, end) {
-    var doc = state.doc,
-        marks = state.schema.marks;
-    var unsupportedMarksPresent = false;
-
-    var isUnsupportedMark = function isUnsupportedMark(node) {
-      return node.type === marks.code || node.type === marks.link || node.type === marks.typeAheadQuery;
-    };
-
-    doc.nodesBetween(start, end, function (node) {
-      unsupportedMarksPresent = unsupportedMarksPresent || node.marks.filter(isUnsupportedMark).length > 0;
-    });
-    return unsupportedMarksPresent;
-  };
-
-  var hasUnsupportedMarkForInputRule = function hasUnsupportedMarkForInputRule(state, start, end) {
-    var doc = state.doc,
-        marks = state.schema.marks;
-    var unsupportedMarksPresent = false;
-
-    var isCodemark = function isCodemark(mark) {
-      return mark.type === marks.code;
-    };
-
-    doc.nodesBetween(start, end, function (node) {
-      unsupportedMarksPresent = unsupportedMarksPresent || node.marks.filter(isCodemark).length > 0;
-    });
-    return unsupportedMarksPresent;
-  };
-
-  var wrapUnsupportedMarkCheck = function wrapUnsupportedMarkCheck(inputRule) {
-    var originalHandler = inputRule.handler.bind(inputRule);
-
-    inputRule.handler = function (state, match, start, end) {
-      var unsupportedMarks = isBlockNodeRule ? hasUnsupportedMarkForBlockInputRule(state, start, end) : hasUnsupportedMarkForInputRule(state, start, end);
-      var $from = state.selection.$from;
-
-      if ($from.parent.type.spec.code || !(state.selection instanceof TextSelection) || unsupportedMarks) {
-        return null;
-      }
-
-      return originalHandler(state, match, start, end);
-    };
-
-    return inputRule;
-  };
-
-  var wrapFixPositions = function wrapFixPositions(inputRule) {
-    var originalHandler = inputRule.handler.bind(inputRule);
-
-    inputRule.handler = function (state, match, start, end) {
-      var parentNodeStartAt = state.selection.$from.start();
-      var offset = Math.max(0, state.selection.$from.parentOffset - MAX_REGEX_MATCH);
-      var fromFixed = Math.max(parentNodeStartAt + match.index + offset, 1);
-      return originalHandler(state, match, fromFixed, end);
-    };
-
-    return inputRule;
-  };
-
-  var wrapWithOnHandlerApply = function wrapWithOnHandlerApply(onHandlerApply) {
-    return function (inputRule) {
-      if (!onHandlerApply) {
-        return inputRule;
-      }
-
-      var originalHandler = inputRule.handler.bind(inputRule);
-
-      inputRule.handler = function (state, match, start, end) {
-        var result = originalHandler(state, match, start, end);
-
-        if (result && onHandlerApply) {
-          onHandlerApply(state, result, match);
-        }
-
-        return result;
-      };
-
-      return inputRule;
-    };
-  };
-
-  var createUnpredictableRule = function createUnpredictableRule(match, handler, onHandlerApply) {
-    var unpredictableRule = new UnpredictableInputRule(match, handler);
-    var rule = [wrapUnsupportedMarkCheck, wrapFixPositions, wrapWithOnHandlerApply(onHandlerApply)].reduce(function (acc, cb) {
-      return cb(acc);
-    }, unpredictableRule);
-    return rule;
-  };
-
-  var unpredictableRules = rules.map(function (rule) {
-    var match = rule.match,
-        handler = rule.handler,
-        onHandlerApply = rule.onHandlerApply;
-    var unpredictableRule = createUnpredictableRule(match, handler, onHandlerApply);
-    return unpredictableRule;
-  });
-  var plugin = unpredictableInputRulesPlugin({
-    rules: unpredictableRules
-  });
-
-  if (process.env.NODE_ENV !== 'production') {
-    var handleTextInput = plugin.props.handleTextInput;
-    var timerId = "input-rule:".concat(pluginName);
-
-    plugin.props.handleTextInput = function (view, from, to, text) {
-      startMeasure(timerId);
-      var result = handleTextInput(view, from, to, text);
-      stopMeasure(timerId, function () {});
-      return result;
-    };
-  }
-
-  return plugin;
-}
+};

package/dist/esm/utils/insert.js

@@ -86,10 +86,14 @@ export var safeInsert = function safeInsert(content, position) {
       }
     }
 
-    var grandParentType = (_tr$selection$$from$n = tr.selection.$from.node(-1)) === null || _tr$selection$$from$n === void 0 ? void 0 : _tr$selection$$from$n.type;
-    var parentType = tr.selection.$from.parent.type;
-
-    if (!lookDirection && !shouldSplitSelectedNodeOnNodeInsertion(parentType, grandParentType, content)) {
+    var grandParentNodeType = (_tr$selection$$from$n = tr.selection.$from.node(-1)) === null || _tr$selection$$from$n === void 0 ? void 0 : _tr$selection$$from$n.type;
+    var parentNodeType = tr.selection.$from.parent.type;
+
+    if (!lookDirection && !shouldSplitSelectedNodeOnNodeInsertion({
+      parentNodeType: parentNodeType,
+      grandParentNodeType: grandParentNodeType,
+      content: content
+    })) {
       // node to be inserted is an invalid child of selection so insert below selected node
       return pmSafeInsert(content, tr.selection.from)(tr);
     }
@@ -190,12 +194,19 @@ export var insertSelectedItem = function insertSelectedItem(maybeNode) {
 
     return tr;
   };
-}; // ED-14584: Util to check if the current node is a paragraph & the content being
-// inserted is a valid child of the grandparent node
-// In this case, the node being inserted to should split
+};
+/**
+ * ED-14584: Util to check if the destination node is a paragraph & the
+ * content being inserted is a valid child of the grandparent node.
+ * In this case, the destination node should split
+ */
+
+export var shouldSplitSelectedNodeOnNodeInsertion = function shouldSplitSelectedNodeOnNodeInsertion(_ref) {
+  var parentNodeType = _ref.parentNodeType,
+      grandParentNodeType = _ref.grandParentNodeType,
+      content = _ref.content;
 
-export var shouldSplitSelectedNodeOnNodeInsertion = function shouldSplitSelectedNodeOnNodeInsertion(parentNodeType, grandParentNodeType, content) {
-  if (parentNodeType.name === 'paragraph' && grandParentNodeType.validContent(Fragment.from(content))) {
+  if (parentNodeType.name === 'doc' || parentNodeType.name === 'paragraph' && grandParentNodeType.validContent(Fragment.from(content))) {
     return true;
   }
 

package/dist/esm/utils/nodes-by-localIds.js

@@ -2,12 +2,12 @@ export var findNodePosByLocalIds = function findNodePosByLocalIds(state, ids) {
   var _state$doc$attrs;
 
   var option = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var nodes = [];
 
   if (ids.length === 0) {
     return [];
   }
 
+  var nodes = [];
   var localIdSet = new Set(ids);
 
   if (option.includeDocNode && localIdSet.has((_state$doc$attrs = state.doc.attrs) === null || _state$doc$attrs === void 0 ? void 0 : _state$doc$attrs.localId)) {
@@ -28,6 +28,38 @@ export var findNodePosByLocalIds = function findNodePosByLocalIds(state, ids) {
     } // stop traversing once we found all the nodes
 
 
+    return localIdSet.size !== nodes.length;
+  });
+  return nodes;
+};
+export var findNodePosByFragmentLocalIds = function findNodePosByFragmentLocalIds(state, ids) {
+  if (ids.length === 0) {
+    return [];
+  }
+
+  var nodes = [];
+  var localIdSet = new Set(ids);
+  state.doc.descendants(function (node, pos) {
+    var _node$marks;
+
+    var fragmentLocalIdList = (_node$marks = node.marks) === null || _node$marks === void 0 ? void 0 : _node$marks.filter(function (m) {
+      return m.type.name === 'fragment';
+    }).map(function (m) {
+      var _m$attrs;
+
+      return (_m$attrs = m.attrs) === null || _m$attrs === void 0 ? void 0 : _m$attrs.localId;
+    }).filter(function (id) {
+      return id && localIdSet.has(id);
+    });
+
+    if (fragmentLocalIdList.length > 0) {
+      nodes.push({
+        node: node,
+        pos: pos
+      });
+    } // stop traversing once we found all the nodes
+
+
     return localIdSet.size !== nodes.length;
   });
   return nodes;

package/dist/esm/utils/sendLogs.js

@@ -1,10 +1 @@
-export var sendLogs = function sendLogs(body) {
-  return fetch('https://analytics.atlassian.com/analytics/events', {
-    method: 'POST',
-    headers: {
-      Accept: 'application/json, */*',
-      'Content-Type': 'application/json'
-    },
-    body: JSON.stringify(body)
-  });
-};
+export { sendLogs } from '@atlaskit/editor-common/utils';

package/dist/esm/version-wrapper.js

@@ -1,5 +1,5 @@
 export var name = "@atlaskit/editor-core";
-export var version = "173.0.1";
+export var version = "175.0.0";
 export var nextMajorVersion = function nextMajorVersion() {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/esm/version.json

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

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

@@ -24,6 +24,7 @@ export default class EditorActions<T = any> implements EditorActionsOptions<T> {
     __temporaryFixForConfigPanel(): Promise<void>;
     getValue(): Promise<import("@atlaskit/editor-json-transformer/types").JSONDocNode | T | undefined>;
     getNodeByLocalId(id: string): Node | undefined;
+    getNodeByFragmentLocalId(id: string): Node | undefined;
     /**
      * This method will return the currently selected `Node` if the selection is a `Node`.
      * Otherwise, if the selection is textual or a non-selectable `Node` within another selectable `Node`, the closest selectable parent `Node` will be returned.

package/dist/types/create-editor/ErrorBoundary.d.ts

@@ -1,9 +1,9 @@
-import React from 'react';
 import { EditorView } from 'prosemirror-view';
+import React from 'react';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
-import type { UserBrowserExtensionResults } from '@atlaskit/editor-common/utils';
 import { ExperienceStore } from '@atlaskit/editor-common/ufo';
-import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { UserBrowserExtensionResults } from '@atlaskit/editor-common/utils';
 import { FeatureFlags } from '../types/feature-flags';
 export declare type ErrorBoundaryProps = {
     createAnalyticsEvent?: CreateUIAnalyticsEvent;

package/dist/types/extensibility.d.ts

@@ -4,7 +4,7 @@ export { toJSON } from './utils';
 export { default as Extension } from './plugins/extension/ui/Extension';
 export { default as ExtensionNodeWrapper } from './plugins/extension/ui/Extension/ExtensionNodeWrapper';
 export { ExtensionNode } from './plugins/extension/nodeviews/extension';
-export { pluginKey as tablePluginKey } from './plugins/table/pm-plugins/plugin-key';
+export { pluginKey as tablePluginKey } from '@atlaskit/editor-plugin-table/plugin-key';
 export declare const EmitterEvents: {
     TABLE_DELETED: string;
 };