@atlaskit/editor-common 69.2.1 → 69.3.0

package/dist/esm/node-width/index.js

@@ -0,0 +1,72 @@
+import { findParentNodeOfTypeClosestToPos } from 'prosemirror-utils';
+import { akEditorFullWidthLayoutWidth, akLayoutGutterOffset, gridMediumMaxWidth } from '@atlaskit/editor-shared-styles';
+import { BODIED_EXT_PADDING } from '../styles/shared/extension';
+import { LAYOUT_COLUMN_PADDING, LAYOUT_SECTION_MARGIN } from '../styles/shared/layout';
+import { absoluteBreakoutWidth } from '../utils/breakout';
+/**
+ * Calculates width of parent node of a nested node (inside layouts, extension)
+ * If current node selection is not nested will return undefined
+ */
+
+export var getParentNodeWidth = function getParentNodeWidth(pos, state, containerWidth, isFullWidthModeEnabled) {
+  if (!pos) {
+    return;
+  }
+
+  var node = getNestedParentNode(pos, state);
+
+  if (!node) {
+    return;
+  }
+
+  var layout = node.attrs.layout || 'default';
+  var schema = state.schema;
+  var breakoutMark = schema.marks.breakout && schema.marks.breakout.isInSet(node.marks);
+
+  if (breakoutMark && breakoutMark.attrs.mode) {
+    layout = breakoutMark.attrs.mode;
+  }
+
+  var parentWidth = calcBreakoutNodeWidth(layout, containerWidth, isFullWidthModeEnabled);
+
+  if (node.type === schema.nodes.layoutSection) {
+    parentWidth += akLayoutGutterOffset * 2; // extra width that gets added to layout
+
+    if (containerWidth.width > gridMediumMaxWidth) {
+      parentWidth -= (LAYOUT_SECTION_MARGIN + 2) * (node.childCount - 1); // margin between sections
+
+      var $pos = state.doc.resolve(pos);
+      var column = findParentNodeOfTypeClosestToPos($pos, [state.schema.nodes.layoutColumn]);
+
+      if (column && column.node && !isNaN(column.node.attrs.width)) {
+        // get exact width of parent layout column using node attrs
+        parentWidth = Math.round(parentWidth * column.node.attrs.width * 0.01);
+      }
+    }
+  } // account for the padding of the parent node
+
+
+  if (node.type === schema.nodes.layoutSection) {
+    parentWidth -= LAYOUT_COLUMN_PADDING * 2;
+  } else if (node.type === schema.nodes.bodiedExtension) {
+    parentWidth -= BODIED_EXT_PADDING * 2;
+  }
+
+  parentWidth -= 2; // border
+
+  return parentWidth;
+};
+
+var getNestedParentNode = function getNestedParentNode(tablePos, state) {
+  if (tablePos === undefined) {
+    return null;
+  }
+
+  var $pos = state.doc.resolve(tablePos);
+  var parent = findParentNodeOfTypeClosestToPos($pos, [state.schema.nodes.bodiedExtension, state.schema.nodes.layoutSection, state.schema.nodes.expand]);
+  return parent ? parent.node : null;
+};
+
+var calcBreakoutNodeWidth = function calcBreakoutNodeWidth(layout, containerWidth, isFullWidthModeEnabled) {
+  return isFullWidthModeEnabled ? Math.min(containerWidth.lineLength, akEditorFullWidthLayoutWidth) : absoluteBreakoutWidth(layout, containerWidth.width);
+};

package/dist/esm/react-node-view/index.js

@@ -0,0 +1,244 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React from 'react';
+import { ACTION_SUBJECT, ACTION_SUBJECT_ID } from '../analytics';
+import { createDispatch } from '../event-dispatcher';
+import { ErrorBoundary } from '../ui/ErrorBoundary';
+import { analyticsEventKey } from '../utils/analytics'; //import {
+//  getPerformanceOptions,
+//  startMeasureReactNodeViewRendered,
+//  stopMeasureReactNodeViewRendered,
+//} from './get-performance-options';
+
+var ReactNodeView = /*#__PURE__*/function () {
+  function ReactNodeView(_node, view, getPos, portalProviderAPI, eventDispatcher, reactComponentProps, reactComponent) {
+    var _this = this;
+
+    var hasAnalyticsContext = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;
+    var viewShouldUpdate = arguments.length > 8 ? arguments[8] : undefined;
+    var hasIntlContext = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : false;
+
+    _classCallCheck(this, ReactNodeView);
+
+    _defineProperty(this, "handleRef", function (node) {
+      return _this._handleRef(node);
+    });
+
+    _defineProperty(this, "dispatchAnalyticsEvent", function (payload) {
+      if (_this.eventDispatcher) {
+        var dispatch = createDispatch(_this.eventDispatcher);
+        dispatch(analyticsEventKey, {
+          payload: payload
+        });
+      }
+    });
+
+    this.node = _node;
+    this.view = view;
+    this.getPos = getPos;
+    this.portalProviderAPI = portalProviderAPI;
+    this.reactComponentProps = reactComponentProps || {};
+    this.reactComponent = reactComponent;
+    this.hasAnalyticsContext = hasAnalyticsContext;
+    this._viewShouldUpdate = viewShouldUpdate;
+    this.eventDispatcher = eventDispatcher;
+    this.hasIntlContext = hasIntlContext;
+  }
+  /**
+   * This method exists to move initialization logic out of the constructor,
+   * so object can be initialized properly before calling render first time.
+   *
+   * Example:
+   * Instance properties get added to an object only after super call in
+   * constructor, which leads to some methods being undefined during the
+   * first render.
+   */
+
+
+  _createClass(ReactNodeView, [{
+    key: "init",
+    value: function init() {
+      var _this2 = this;
+
+      this.domRef = this.createDomRef();
+      this.setDomAttrs(this.node, this.domRef);
+
+      var _ref = this.getContentDOM() || {
+        dom: undefined,
+        contentDOM: undefined
+      },
+          contentDOMWrapper = _ref.dom,
+          contentDOM = _ref.contentDOM;
+
+      if (this.domRef && contentDOMWrapper) {
+        this.domRef.appendChild(contentDOMWrapper);
+        this.contentDOM = contentDOM ? contentDOM : contentDOMWrapper;
+        this.contentDOMWrapper = contentDOMWrapper || contentDOM;
+      } // @see ED-3790
+      // something gets messed up during mutation processing inside of a
+      // nodeView if DOM structure has nested plain "div"s, it doesn't see the
+      // difference between them and it kills the nodeView
+
+
+      this.domRef.classList.add("".concat(this.node.type.name, "View-content-wrap")); // TODO: ED-15580
+      //const {
+      //  samplingRate,
+      //  slowThreshold,
+      //  trackingEnabled,
+      //} = getPerformanceOptions(this.view);
+      //trackingEnabled &&
+      //  startMeasureReactNodeViewRendered({ nodeTypeName: this.node.type.name });
+
+      this.renderReactComponent(function () {
+        return _this2.render(_this2.reactComponentProps, _this2.handleRef);
+      }); //trackingEnabled &&
+      //  stopMeasureReactNodeViewRendered({
+      //    nodeTypeName: this.node.type.name,
+      //    dispatchAnalyticsEvent: this.dispatchAnalyticsEvent,
+      //    editorState: this.view.state,
+      //    samplingRate,
+      //    slowThreshold,
+      //  });
+
+      return this;
+    }
+  }, {
+    key: "renderReactComponent",
+    value: function renderReactComponent(component) {
+      var _this3 = this;
+
+      if (!this.domRef || !component) {
+        return;
+      }
+
+      var componentWithErrorBoundary = function componentWithErrorBoundary() {
+        var _this3$node$type$name, _this3$node, _this3$node$type;
+
+        return /*#__PURE__*/React.createElement(ErrorBoundary, {
+          component: ACTION_SUBJECT.REACT_NODE_VIEW,
+          componentId: (_this3$node$type$name = _this3 === null || _this3 === void 0 ? void 0 : (_this3$node = _this3.node) === null || _this3$node === void 0 ? void 0 : (_this3$node$type = _this3$node.type) === null || _this3$node$type === void 0 ? void 0 : _this3$node$type.name) !== null && _this3$node$type$name !== void 0 ? _this3$node$type$name : ACTION_SUBJECT_ID.UNKNOWN_NODE,
+          dispatchAnalyticsEvent: _this3.dispatchAnalyticsEvent
+        }, component());
+      };
+
+      this.portalProviderAPI.render(componentWithErrorBoundary, this.domRef, this.hasAnalyticsContext, this.hasIntlContext);
+    }
+  }, {
+    key: "createDomRef",
+    value: function createDomRef() {
+      if (!this.node.isInline) {
+        return document.createElement('div');
+      }
+
+      var htmlElement = document.createElement('span');
+      return htmlElement;
+    }
+  }, {
+    key: "getContentDOM",
+    value: function getContentDOM() {
+      return undefined;
+    }
+  }, {
+    key: "_handleRef",
+    value: function _handleRef(node) {
+      var contentDOM = this.contentDOMWrapper || this.contentDOM; // move the contentDOM node inside the inner reference after rendering
+
+      if (node && contentDOM && !node.contains(contentDOM)) {
+        node.appendChild(contentDOM);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render(props, forwardRef) {
+      return this.reactComponent ? /*#__PURE__*/React.createElement(this.reactComponent, _extends({
+        view: this.view,
+        getPos: this.getPos,
+        node: this.node,
+        forwardRef: forwardRef
+      }, props)) : null;
+    }
+  }, {
+    key: "update",
+    value: function update(node, _decorations, _innerDecorations) {
+      var _this4 = this;
+
+      var validUpdate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {
+        return true;
+      };
+      // @see https://github.com/ProseMirror/prosemirror/issues/648
+      var isValidUpdate = this.node.type === node.type && validUpdate(this.node, node);
+
+      if (!isValidUpdate) {
+        return false;
+      }
+
+      if (this.domRef && !this.node.sameMarkup(node)) {
+        this.setDomAttrs(node, this.domRef);
+      } // View should not process a re-render if this is false.
+      // We dont want to destroy the view, so we return true.
+
+
+      if (!this.viewShouldUpdate(node)) {
+        this.node = node;
+        return true;
+      }
+
+      this.node = node;
+      this.renderReactComponent(function () {
+        return _this4.render(_this4.reactComponentProps, _this4.handleRef);
+      });
+      return true;
+    }
+  }, {
+    key: "viewShouldUpdate",
+    value: function viewShouldUpdate(nextNode) {
+      if (this._viewShouldUpdate) {
+        return this._viewShouldUpdate(nextNode);
+      }
+
+      return true;
+    }
+    /**
+     * Copies the attributes from a ProseMirror Node to a DOM node.
+     * @param node The Prosemirror Node from which to source the attributes
+     */
+
+  }, {
+    key: "setDomAttrs",
+    value: function setDomAttrs(node, element) {
+      Object.keys(node.attrs || {}).forEach(function (attr) {
+        element.setAttribute(attr, node.attrs[attr]);
+      });
+    }
+  }, {
+    key: "dom",
+    get: function get() {
+      return this.domRef;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (!this.domRef) {
+        return;
+      }
+
+      this.portalProviderAPI.remove(this.domRef);
+      this.domRef = undefined;
+      this.contentDOM = undefined;
+    }
+  }], [{
+    key: "fromComponent",
+    value: function fromComponent(component, portalProviderAPI, eventDispatcher, props, viewShouldUpdate) {
+      var hasIntlContext = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+      return function (node, view, getPos) {
+        return new ReactNodeView(node, view, getPos, portalProviderAPI, eventDispatcher, props, component, false, viewShouldUpdate, hasIntlContext).init();
+      };
+    }
+  }]);
+
+  return ReactNodeView;
+}();
+
+export { ReactNodeView as default };

package/dist/esm/react-node-view/types.js

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

package/dist/esm/selection/gap-cursor/selection.js

@@ -0,0 +1,176 @@
+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 _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 { Slice } from 'prosemirror-model';
+import { Selection } from 'prosemirror-state';
+import { isValidTargetNode } from './utils/is-valid-target-node';
+export var Side;
+
+(function (Side) {
+  Side["LEFT"] = "left";
+  Side["RIGHT"] = "right";
+})(Side || (Side = {}));
+
+export var JSON_ID = 'gapcursor';
+export var GapCursorSelection = /*#__PURE__*/function (_Selection) {
+  _inherits(GapCursorSelection, _Selection);
+
+  var _super = _createSuper(GapCursorSelection);
+
+  /**
+   * Construct a GapCursorSelection
+   * @param {ResolvedPos} $pos resolved position
+   * @param {Side} side side where the gap cursor is drawn
+   */
+  function GapCursorSelection($pos) {
+    var _this;
+
+    var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Side.LEFT;
+
+    _classCallCheck(this, GapCursorSelection);
+
+    _this = _super.call(this, $pos, $pos);
+
+    _defineProperty(_assertThisInitialized(_this), "visible", false);
+
+    _this.side = side;
+    return _this;
+  }
+
+  _createClass(GapCursorSelection, [{
+    key: "map",
+    value: function map(doc, mapping) {
+      var $pos = doc.resolve(mapping.map(this.head));
+      return GapCursorSelection.valid($pos) ? new GapCursorSelection($pos, this.side) : Selection.near($pos);
+    }
+  }, {
+    key: "eq",
+    value: function eq(other) {
+      return other instanceof GapCursorSelection && other.head === this.head;
+    }
+  }, {
+    key: "content",
+    value: function content() {
+      return Slice.empty;
+    }
+  }, {
+    key: "getBookmark",
+    value: function getBookmark() {
+      return new GapBookmark(this.anchor);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        pos: this.head,
+        type: JSON_ID,
+        side: this.side
+      };
+    }
+  }], [{
+    key: "valid",
+    value: function valid($pos) {
+      var parent = $pos.parent,
+          nodeBefore = $pos.nodeBefore,
+          nodeAfter = $pos.nodeAfter;
+      var targetNode = isValidTargetNode(nodeBefore) ? nodeBefore : isValidTargetNode(nodeAfter) ? nodeAfter : null;
+
+      if (!targetNode || parent.isTextblock) {
+        return false;
+      }
+
+      var deflt = parent.contentMatchAt($pos.index()).defaultType;
+      return deflt && deflt.isTextblock;
+    }
+  }, {
+    key: "findFrom",
+    value: function findFrom($pos, dir) {
+      var mustMove = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var side = dir === 1 ? Side.RIGHT : Side.LEFT;
+
+      if (!mustMove && GapCursorSelection.valid($pos)) {
+        return new GapCursorSelection($pos, side);
+      }
+
+      var pos = $pos.pos; // TODO: Fix any, potential issue. ED-5048
+
+      var next = null; // Scan up from this position
+
+      for (var d = $pos.depth;; d--) {
+        var parent = $pos.node(d);
+
+        if (side === Side.RIGHT ? $pos.indexAfter(d) < parent.childCount : $pos.index(d) > 0) {
+          next = parent.maybeChild(side === Side.RIGHT ? $pos.indexAfter(d) : $pos.index(d) - 1);
+          break;
+        } else if (d === 0) {
+          return null;
+        }
+
+        pos += dir;
+        var $cur = $pos.doc.resolve(pos);
+
+        if (GapCursorSelection.valid($cur)) {
+          return new GapCursorSelection($cur, side);
+        }
+      } // And then down into the next node
+
+
+      for (;;) {
+        next = side === Side.RIGHT ? next.firstChild : next.lastChild;
+
+        if (next === null) {
+          break;
+        }
+
+        pos += dir;
+
+        var _$cur = $pos.doc.resolve(pos);
+
+        if (GapCursorSelection.valid(_$cur)) {
+          return new GapCursorSelection(_$cur, side);
+        }
+      }
+
+      return null;
+    }
+  }, {
+    key: "fromJSON",
+    value: function fromJSON(doc, json) {
+      return new GapCursorSelection(doc.resolve(json.pos), json.side);
+    }
+  }]);
+
+  return GapCursorSelection;
+}(Selection);
+Selection.jsonID(JSON_ID, GapCursorSelection);
+export var GapBookmark = /*#__PURE__*/function () {
+  function GapBookmark(pos) {
+    _classCallCheck(this, GapBookmark);
+
+    this.pos = pos;
+  }
+
+  _createClass(GapBookmark, [{
+    key: "map",
+    value: function map(mapping) {
+      return new GapBookmark(mapping.map(this.pos));
+    }
+  }, {
+    key: "resolve",
+    value: function resolve(doc) {
+      var $pos = doc.resolve(this.pos);
+      return GapCursorSelection.valid($pos) ? new GapCursorSelection($pos) : Selection.near($pos);
+    }
+  }]);
+
+  return GapBookmark;
+}();

package/dist/esm/selection/gap-cursor/utils/index.js

@@ -0,0 +1,2 @@
+export { isIgnored } from './is-ignored';
+export { isValidTargetNode } from './is-valid-target-node';

package/dist/esm/selection/gap-cursor/utils/is-ignored.js

@@ -0,0 +1,5 @@
+// we don't show gap cursor for those nodes
+var IGNORED_NODES = ['paragraph', 'bulletList', 'orderedList', 'listItem', 'taskItem', 'decisionItem', 'heading', 'blockquote', 'layoutColumn', 'caption', 'media'];
+export var isIgnored = function isIgnored(node) {
+  return !!node && IGNORED_NODES.indexOf(node.type.name) !== -1;
+};

package/dist/esm/selection/gap-cursor/utils/is-valid-target-node.js

@@ -0,0 +1,4 @@
+import { isIgnored } from './is-ignored';
+export var isValidTargetNode = function isValidTargetNode(node) {
+  return !!node && !isIgnored(node);
+};

package/dist/esm/selection/index.js

@@ -0,0 +1,4 @@
+export { RelativeSelectionPos } from './types';
+export { GapCursorSelection, Side, JSON_ID, GapBookmark } from './gap-cursor/selection';
+export { isIgnored, isValidTargetNode } from './gap-cursor/utils';
+export { isSelectionAtStartOfNode, isSelectionAtEndOfNode } from './utils';

package/dist/esm/selection/types.js

@@ -0,0 +1,8 @@
+export var RelativeSelectionPos;
+
+(function (RelativeSelectionPos) {
+  RelativeSelectionPos["Before"] = "Before";
+  RelativeSelectionPos["Start"] = "Start";
+  RelativeSelectionPos["Inside"] = "Inside";
+  RelativeSelectionPos["End"] = "End";
+})(RelativeSelectionPos || (RelativeSelectionPos = {}));

package/dist/esm/selection/utils.js

@@ -0,0 +1,38 @@
+export var isSelectionAtStartOfNode = function isSelectionAtStartOfNode($pos, parentNode) {
+  if (!parentNode) {
+    return false;
+  }
+
+  for (var i = $pos.depth + 1; i > 0; i--) {
+    var node = $pos.node(i);
+
+    if (node && node.eq(parentNode.node)) {
+      break;
+    }
+
+    if (i > 1 && $pos.before(i) !== $pos.before(i - 1) + 1) {
+      return false;
+    }
+  }
+
+  return true;
+};
+export var isSelectionAtEndOfNode = function isSelectionAtEndOfNode($pos, parentNode) {
+  if (!parentNode) {
+    return false;
+  }
+
+  for (var i = $pos.depth + 1; i > 0; i--) {
+    var node = $pos.node(i);
+
+    if (node && node.eq(parentNode.node)) {
+      break;
+    }
+
+    if (i > 1 && $pos.after(i) !== $pos.after(i - 1) - 1) {
+      return false;
+    }
+  }
+
+  return true;
+};

package/dist/esm/styles/index.js

@@ -18,4 +18,6 @@ export { dateSharedStyle, DateSharedCssClassName } from './shared/date';
 export { tasksAndDecisionsStyles, TaskDecisionSharedCssClassName } from './shared/task-decision';
 export { StatusSharedCssClassName } from './shared/status';
 export { smartCardSharedStyles, SmartCardSharedCssClassName } from './shared/smart-card';
-export { CodeBlockSharedCssClassName, codeBlockSharedStyles } from './shared/code-block';
+export { CodeBlockSharedCssClassName, codeBlockSharedStyles } from './shared/code-block';
+export { LAYOUT_SECTION_MARGIN, LAYOUT_COLUMN_PADDING } from './shared/layout';
+export { EXTENSION_PADDING, BODIED_EXT_PADDING } from './shared/extension';

package/dist/esm/styles/shared/extension.js

@@ -0,0 +1,3 @@
+import { gridSize } from '@atlaskit/theme/constants';
+export var EXTENSION_PADDING = gridSize();
+export var BODIED_EXT_PADDING = EXTENSION_PADDING * 2;

package/dist/esm/styles/shared/layout.js

@@ -0,0 +1,3 @@
+import { gridSize } from '@atlaskit/theme/constants';
+export var LAYOUT_SECTION_MARGIN = gridSize();
+export var LAYOUT_COLUMN_PADDING = gridSize() * 1.5;

package/dist/esm/styles/shared/table.js

@@ -32,7 +32,9 @@ export var TableSharedCssClassName = {
   TABLE_STICKY_SENTINEL_BOTTOM: "".concat(tablePrefixSelector, "-sticky-sentinel-bottom"),
   TABLE_CELL_NODEVIEW_CONTENT_DOM: tableCellContentDomSelector,
   TABLE_CELL_WRAPPER: tableCellSelector,
-  TABLE_HEADER_CELL_WRAPPER: tableHeaderSelector
+  TABLE_HEADER_CELL_WRAPPER: tableHeaderSelector,
+  TABLE_ROW_CONTROLS_WRAPPER: "".concat(tablePrefixSelector, "-row-controls-wrapper"),
+  TABLE_COLUMN_CONTROLS_DECORATIONS: "".concat(tablePrefixSelector, "-column-controls-decoration")
 };
 
 var tableSharedStyle = function tableSharedStyle(props) {

package/dist/esm/transforms/expand.js

@@ -0,0 +1,34 @@
+import { Fragment, Slice } from 'prosemirror-model';
+import { findParentNodeOfType, findSelectedNodeOfType } from 'prosemirror-utils';
+import { mapChildren } from '../utils/slice';
+export var findExpand = function findExpand(state, selection) {
+  var _state$schema$nodes = state.schema.nodes,
+      expand = _state$schema$nodes.expand,
+      nestedExpand = _state$schema$nodes.nestedExpand;
+  return findSelectedNodeOfType([expand, nestedExpand])(selection || state.selection) || findParentNodeOfType([expand, nestedExpand])(selection || state.selection);
+}; // If the top level is a single expand, and the expand is not
+// a part of copied content, then return unwrap contents.
+// This is needed for handling content copied from expand.
+// https://product-fabric.atlassian.net/browse/ED-9146
+
+export var transformSliceToRemoveOpenExpand = function transformSliceToRemoveOpenExpand(slice, schema) {
+  if (slice.openStart > 1 && slice.openEnd > 1 && slice.content.childCount === 1 && slice.content.firstChild && slice.content.firstChild.type === schema.nodes.expand) {
+    return new Slice(slice.content.firstChild.content, slice.openStart - 1, slice.openEnd - 1);
+  }
+
+  return slice;
+};
+export var transformSliceNestedExpandToExpand = function transformSliceNestedExpandToExpand(slice, schema) {
+  var _schema$nodes = schema.nodes,
+      expand = _schema$nodes.expand,
+      nestedExpand = _schema$nodes.nestedExpand;
+  var children = [];
+  mapChildren(slice.content, function (node) {
+    if (node.type === nestedExpand) {
+      children.push(expand.createChecked(node.attrs, node.content, node.marks));
+    } else {
+      children.push(node);
+    }
+  });
+  return new Slice(Fragment.fromArray(children), slice.openStart, slice.openEnd);
+};

package/dist/esm/transforms/extension.js

@@ -0,0 +1,24 @@
+import { Slice } from 'prosemirror-model';
+import { mapFragment } from '../utils/slice';
+/**
+ * Lift content out of "open" top-level bodiedExtensions.
+ * Will not work if bodiedExtensions are nested, or when bodiedExtensions are not in the top level
+ */
+
+export var transformSliceToRemoveOpenBodiedExtension = function transformSliceToRemoveOpenBodiedExtension(slice, schema) {
+  var bodiedExtension = schema.nodes.bodiedExtension;
+  var fragment = mapFragment(slice.content, function (node, parent, index) {
+    if (node.type === bodiedExtension && !parent) {
+      var currentNodeIsAtStartAndIsOpen = slice.openStart && index === 0;
+      var currentNodeIsAtEndAndIsOpen = slice.openEnd && index + 1 === slice.content.childCount;
+
+      if (currentNodeIsAtStartAndIsOpen || currentNodeIsAtEndAndIsOpen) {
+        return node.content;
+      }
+    }
+
+    return node;
+  }); // If the first/last child has changed - then we know we've removed a bodied extension & to decrement the open depth
+
+  return new Slice(fragment, fragment.firstChild && fragment.firstChild.type !== slice.content.firstChild.type ? slice.openStart - 1 : slice.openStart, fragment.lastChild && fragment.lastChild.type !== slice.content.lastChild.type ? slice.openEnd - 1 : slice.openEnd);
+};

package/dist/esm/transforms/index.js

@@ -0,0 +1,3 @@
+export { unwrapContentFromLayout, removeLayoutFromFirstChild, removeLayoutFromLastChild, transformSliceToRemoveOpenLayoutNodes } from './layout';
+export { findExpand, transformSliceToRemoveOpenExpand, transformSliceNestedExpandToExpand } from './expand';
+export { transformSliceToRemoveOpenBodiedExtension } from './extension';