@atlaskit/editor-plugin-extension 0.4.2 → 0.5.1

package/dist/esm/context-panel.js

@@ -0,0 +1,261 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _typeof from "@babel/runtime/helpers/typeof";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import React from 'react';
+import { getExtensionKeyAndNodeKey } from '@atlaskit/editor-common/extensions';
+import { GapCursorSelection } from '@atlaskit/editor-common/selection';
+import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
+import { buildExtensionNode } from './actions';
+import { clearEditingContext, forceAutoSave, updateState } from './commands';
+import { getPluginState } from './pm-plugins/main';
+import ConfigPanelLoader from './ui/ConfigPanel/ConfigPanelLoader';
+import { SaveIndicator } from './ui/SaveIndicator/SaveIndicator';
+import { getSelectedExtension } from './utils';
+var areParametersEqual = function areParametersEqual(firstParameters, secondParameters) {
+  if (_typeof(firstParameters) === 'object' && _typeof(secondParameters) === 'object' && firstParameters !== null && secondParameters !== null) {
+    var firstKeys = Object.keys(firstParameters);
+    var secondKeys = Object.keys(secondParameters);
+    return firstKeys.length === secondKeys.length && firstKeys.every(function (key) {
+      return firstParameters[key] === secondParameters[key];
+    });
+  }
+  return firstParameters === secondParameters;
+};
+export var duplicateSelection = function duplicateSelection(selectionToDuplicate, doc) {
+  if (selectionToDuplicate instanceof NodeSelection) {
+    return NodeSelection.create(doc, selectionToDuplicate.from);
+  } else if (selectionToDuplicate instanceof TextSelection) {
+    return TextSelection.create(doc, selectionToDuplicate.from, selectionToDuplicate.to);
+  } else if (selectionToDuplicate instanceof GapCursorSelection) {
+    return new GapCursorSelection(doc.resolve(selectionToDuplicate.from), selectionToDuplicate.side);
+  } else if (selectionToDuplicate instanceof CellSelection) {
+    return new CellSelection(doc.resolve(selectionToDuplicate.$anchorCell.pos), doc.resolve(selectionToDuplicate.$headCell.pos));
+  }
+};
+export var getContextPanel = function getContextPanel(getEditorView) {
+  return function (allowAutoSave, featureFlags, applyChange) {
+    return function (state) {
+      var nodeWithPos = getSelectedExtension(state, true);
+
+      // Adding checks to bail out early
+      if (!nodeWithPos) {
+        return;
+      }
+      var extensionState = getPluginState(state);
+      var autoSaveResolve = extensionState.autoSaveResolve,
+        autoSaveReject = extensionState.autoSaveReject,
+        showContextPanel = extensionState.showContextPanel,
+        extensionProvider = extensionState.extensionProvider,
+        processParametersBefore = extensionState.processParametersBefore,
+        processParametersAfter = extensionState.processParametersAfter;
+      if (extensionState && showContextPanel && extensionProvider && processParametersAfter) {
+        var _nodeWithPos$node$att = nodeWithPos.node.attrs,
+          extensionType = _nodeWithPos$node$att.extensionType,
+          extensionKey = _nodeWithPos$node$att.extensionKey,
+          parameters = _nodeWithPos$node$att.parameters;
+        var _getExtensionKeyAndNo = getExtensionKeyAndNodeKey(extensionKey, extensionType),
+          _getExtensionKeyAndNo2 = _slicedToArray(_getExtensionKeyAndNo, 2),
+          extKey = _getExtensionKeyAndNo2[0],
+          nodeKey = _getExtensionKeyAndNo2[1];
+        var configParams = processParametersBefore ? processParametersBefore(parameters || {}) : parameters;
+        return /*#__PURE__*/React.createElement(SaveIndicator, {
+          duration: 5000,
+          visible: allowAutoSave
+        }, function (_ref) {
+          var onSaveStarted = _ref.onSaveStarted,
+            onSaveEnded = _ref.onSaveEnded;
+          var editorView = getEditorView === null || getEditorView === void 0 ? void 0 : getEditorView();
+          if (!editorView) {
+            return null;
+          }
+          return /*#__PURE__*/React.createElement(ConfigPanelLoader, {
+            showHeader: true,
+            closeOnEsc: true,
+            extensionType: extensionType,
+            extensionKey: extKey,
+            nodeKey: nodeKey,
+            extensionParameters: parameters,
+            parameters: configParams,
+            extensionProvider: extensionProvider,
+            autoSave: allowAutoSave,
+            autoSaveTrigger: autoSaveResolve,
+            autoSaveReject: autoSaveReject,
+            onChange: /*#__PURE__*/function () {
+              var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(updatedParameters) {
+                return _regeneratorRuntime.wrap(function _callee$(_context) {
+                  while (1) switch (_context.prev = _context.next) {
+                    case 0:
+                      _context.next = 2;
+                      return onChangeAction(editorView, updatedParameters, parameters, nodeWithPos, onSaveStarted);
+                    case 2:
+                      onSaveEnded();
+                      if (autoSaveResolve) {
+                        autoSaveResolve();
+                      }
+                      if (!allowAutoSave) {
+                        clearEditingContext(applyChange)(editorView.state, editorView.dispatch);
+                      }
+                    case 5:
+                    case "end":
+                      return _context.stop();
+                  }
+                }, _callee);
+              }));
+              return function (_x) {
+                return _ref2.apply(this, arguments);
+              };
+            }(),
+            onCancel: /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+              return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+                while (1) switch (_context2.prev = _context2.next) {
+                  case 0:
+                    if (!allowAutoSave) {
+                      _context2.next = 9;
+                      break;
+                    }
+                    _context2.prev = 1;
+                    _context2.next = 4;
+                    return new Promise(function (resolve, reject) {
+                      forceAutoSave(applyChange)(resolve, reject)(editorView.state, editorView.dispatch);
+                    });
+                  case 4:
+                    _context2.next = 9;
+                    break;
+                  case 6:
+                    _context2.prev = 6;
+                    _context2.t0 = _context2["catch"](1);
+                    // Even if the save failed, we should proceed with closing the panel
+                    // eslint-disable-next-line no-console
+                    console.error("Autosave failed with error", _context2.t0);
+                  case 9:
+                    clearEditingContext(applyChange)(editorView.state, editorView.dispatch);
+                  case 10:
+                  case "end":
+                    return _context2.stop();
+                }
+              }, _callee2, null, [[1, 6]]);
+            })),
+            featureFlags: featureFlags
+          });
+        });
+      }
+    };
+  };
+};
+export function onChangeAction(_x2) {
+  return _onChangeAction.apply(this, arguments);
+}
+function _onChangeAction() {
+  _onChangeAction = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(editorView) {
+    var updatedParameters,
+      oldParameters,
+      nodeWithPos,
+      onSaving,
+      _ref4,
+      processParametersAfter,
+      processParametersBefore,
+      unwrappedOldParameters,
+      key,
+      _ref5,
+      previousPositions,
+      newParameters,
+      _ref6,
+      positions,
+      node,
+      newNode,
+      positionUpdated,
+      transaction,
+      prevSelection,
+      selection,
+      positionsLess,
+      _args3 = arguments;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          updatedParameters = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : {};
+          oldParameters = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : {};
+          nodeWithPos = _args3.length > 3 ? _args3[3] : undefined;
+          onSaving = _args3.length > 4 ? _args3[4] : undefined;
+          // WARNING: editorView.state stales quickly, do not unpack
+          _ref4 = getPluginState(editorView.state), processParametersAfter = _ref4.processParametersAfter, processParametersBefore = _ref4.processParametersBefore;
+          if (processParametersAfter) {
+            _context3.next = 7;
+            break;
+          }
+          return _context3.abrupt("return");
+        case 7:
+          unwrappedOldParameters = processParametersBefore ? processParametersBefore(oldParameters) : oldParameters; // todo: update to only check parameters which are in the manifest's field definitions
+          if (!areParametersEqual(unwrappedOldParameters, updatedParameters)) {
+            _context3.next = 10;
+            break;
+          }
+          return _context3.abrupt("return");
+        case 10:
+          if (onSaving) {
+            onSaving();
+          }
+          key = Date.now();
+          _ref5 = getPluginState(editorView.state), previousPositions = _ref5.positions;
+          _context3.next = 15;
+          return updateState({
+            positions: _objectSpread(_objectSpread({}, previousPositions), {}, _defineProperty({}, key, nodeWithPos.pos))
+          })(editorView.state, editorView.dispatch);
+        case 15:
+          _context3.next = 17;
+          return processParametersAfter(updatedParameters);
+        case 17:
+          newParameters = _context3.sent;
+          _ref6 = getPluginState(editorView.state), positions = _ref6.positions;
+          if (positions) {
+            _context3.next = 21;
+            break;
+          }
+          return _context3.abrupt("return");
+        case 21:
+          if (key in positions) {
+            _context3.next = 23;
+            break;
+          }
+          return _context3.abrupt("return");
+        case 23:
+          node = nodeWithPos.node;
+          newNode = buildExtensionNode(nodeWithPos.node.toJSON().type, editorView.state.schema, _objectSpread(_objectSpread({}, node.attrs), {}, {
+            parameters: _objectSpread(_objectSpread({}, oldParameters), newParameters)
+          }), node.content, node.marks);
+          if (newNode) {
+            _context3.next = 27;
+            break;
+          }
+          return _context3.abrupt("return");
+        case 27:
+          positionUpdated = positions[key];
+          transaction = editorView.state.tr.replaceWith(positionUpdated, positionUpdated + newNode.nodeSize, newNode); // Ensure we preserve the selection, tr.replaceWith causes it to be lost in some cases
+          // when replacing the node
+          prevSelection = editorView.state.selection;
+          if (!prevSelection.eq(transaction.selection)) {
+            selection = duplicateSelection(prevSelection, transaction.doc);
+            if (selection) {
+              transaction.setSelection(selection);
+            }
+          }
+          positionsLess = _objectSpread({}, getPluginState(editorView.state).positions);
+          delete positionsLess[key];
+          _context3.next = 35;
+          return updateState({
+            positions: positionsLess
+          })(editorView.state, editorView.dispatch);
+        case 35:
+          editorView.dispatch(transaction);
+        case 36:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return _onChangeAction.apply(this, arguments);
+}

package/dist/esm/extension-api.js

@@ -0,0 +1,259 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import { validator } from '@atlaskit/adf-utils/validator';
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { nodeToJSON } from '@atlaskit/editor-common/utils';
+import { JSONTransformer } from '@atlaskit/editor-json-transformer';
+import { Fragment, Mark } from '@atlaskit/editor-prosemirror/model';
+import { NodeSelection, Selection } from '@atlaskit/editor-prosemirror/state';
+import { setTextSelection } from '@atlaskit/editor-prosemirror/utils';
+import { setEditingContextToContextPanel } from './commands';
+import { insertMacroFromMacroBrowser } from './pm-plugins/macro/actions';
+import { pluginKey as macroPluginKey } from './pm-plugins/macro/plugin-key';
+import { findNodePosWithLocalId, getDataConsumerMark, getNodeTypesReferenced, getSelectedExtension } from './utils';
+export var getEditInLegacyMacroBrowser = function getEditInLegacyMacroBrowser(_ref) {
+  var view = _ref.view,
+    macroProvider = _ref.macroProvider,
+    editorAnalyticsAPI = _ref.editorAnalyticsAPI;
+  return function () {
+    if (!view) {
+      throw new Error("Missing view. Can't update without EditorView");
+    }
+    if (!macroProvider) {
+      throw new Error("Missing macroProvider. Can't use the macro browser for updates");
+    }
+    var nodeWithPos = getSelectedExtension(view.state, true);
+    if (!nodeWithPos) {
+      throw new Error("Missing nodeWithPos. Can't determine position of node");
+    }
+    insertMacroFromMacroBrowser(editorAnalyticsAPI)(macroProvider, nodeWithPos.node, true)(view);
+  };
+};
+var extensionAPICallPayload = function extensionAPICallPayload(functionName) {
+  return {
+    action: ACTION.INVOKED,
+    actionSubject: ACTION_SUBJECT.EXTENSION,
+    actionSubjectId: ACTION_SUBJECT_ID.EXTENSION_API,
+    attributes: {
+      functionName: functionName
+    },
+    eventType: EVENT_TYPE.TRACK
+  };
+};
+export var createExtensionAPI = function createExtensionAPI(options) {
+  var schema = options.editorView.state.schema,
+    editorAnalyticsAPI = options.editorAnalyticsAPI;
+  var nodes = Object.keys(schema.nodes);
+  var marks = Object.keys(schema.marks);
+  var validate = validator(nodes, marks, {
+    allowPrivateAttributes: true
+  });
+
+  /**
+   * Finds the node and its position by `localId`. Throws if the node could not be found.
+   *
+   * @returns {NodeWithPos}
+   */
+  var ensureNodePosByLocalId = function ensureNodePosByLocalId(localId, _ref2) {
+    var opName = _ref2.opName;
+    // Be extra cautious since 3rd party devs can use regular JS without type safety
+    if (typeof localId !== 'string' || localId === '') {
+      throw new Error("".concat(opName, "(): Invalid localId '").concat(localId, "'."));
+    }
+
+    // Find the node + position matching the given ID
+    var state = options.editorView.state;
+    var nodePos = findNodePosWithLocalId(state, localId);
+    if (!nodePos) {
+      throw new Error("".concat(opName, "(): Could not find node with ID '").concat(localId, "'."));
+    }
+    return nodePos;
+  };
+  var doc = {
+    insertAfter: function insertAfter(localId, adf, opt) {
+      try {
+        validate(adf);
+      } catch (e) {
+        throw new Error("insertAfter(): Invalid ADF given.");
+      }
+      var nodePos = ensureNodePosByLocalId(localId, {
+        opName: 'insertAfter'
+      });
+      var editorView = options.editorView;
+      var dispatch = editorView.dispatch,
+        state = editorView.state;
+
+      // Validate the given ADF
+      var tr = state.tr,
+        schema = state.schema;
+      var nodeType = schema.nodes[adf.type];
+      if (!nodeType) {
+        throw new Error("insertAfter(): Invalid ADF type '".concat(adf.type, "'."));
+      }
+      var fragment = Fragment.fromJSON(schema, adf.content);
+      var marks = (adf.marks || []).map(function (markEntity) {
+        return Mark.fromJSON(schema, markEntity);
+      });
+      var newNode = nodeType === null || nodeType === void 0 ? void 0 : nodeType.createChecked(adf.attrs, fragment, marks);
+      if (!newNode) {
+        throw new Error('insertAfter(): Could not create a node for given ADFEntity.');
+      }
+      var insertPosition = nodePos.pos + nodePos.node.nodeSize;
+      tr.insert(insertPosition, newNode);
+
+      // Validate if the document is valid at this point
+      try {
+        tr.doc.check();
+      } catch (err) {
+        throw new Error("insertAfter(): The given ADFEntity cannot be inserted in the current position.\n".concat(err));
+      }
+
+      // Analytics - tracking the api call
+      var apiCallPayload = extensionAPICallPayload('insertAfter');
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent(apiCallPayload)(tr);
+
+      // Analytics - tracking node types added
+      var nodesAdded = [newNode];
+      newNode.descendants(function (node) {
+        nodesAdded.push(node);
+        return true;
+      });
+      nodesAdded.forEach(function (node) {
+        var _node$attrs = node.attrs,
+          extensionKey = _node$attrs.extensionKey,
+          extensionType = _node$attrs.extensionType;
+        var dataConsumerMark = getDataConsumerMark(node);
+        var stringIds = (dataConsumerMark === null || dataConsumerMark === void 0 ? void 0 : dataConsumerMark.attrs.sources.map(function (sourceId) {
+          return sourceId;
+        })) || [];
+        var hasReferentiality = !!dataConsumerMark;
+        var nodeTypesReferenced = hasReferentiality ? getNodeTypesReferenced(stringIds, state) : undefined;
+
+        // fire off analytics for this ADF
+        var payload = {
+          action: ACTION.INSERTED,
+          actionSubject: ACTION_SUBJECT.DOCUMENT,
+          attributes: {
+            nodeType: node.type.name,
+            inputMethod: INPUT_METHOD.EXTENSION_API,
+            hasReferentiality: hasReferentiality,
+            nodeTypesReferenced: nodeTypesReferenced,
+            layout: node.attrs.layout,
+            extensionType: extensionType,
+            extensionKey: extensionKey
+          },
+          eventType: EVENT_TYPE.TRACK
+        };
+        editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent(payload)(tr);
+      });
+      if (opt && opt.allowSelectionToNewNode) {
+        tr.setSelection(new NodeSelection(tr.doc.resolve(insertPosition)));
+      }
+      dispatch(tr);
+    },
+    scrollTo: function scrollTo(localId) {
+      var nodePos = ensureNodePosByLocalId(localId, {
+        opName: 'scrollTo'
+      });
+
+      // Analytics - tracking the api call
+      var apiCallPayload = extensionAPICallPayload('scrollTo');
+      var _options$editorView = options.editorView,
+        dispatch = _options$editorView.dispatch,
+        state = _options$editorView.state;
+      var tr = state.tr;
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent(apiCallPayload)(tr);
+      tr = setTextSelection(nodePos.pos)(tr);
+      tr = tr.scrollIntoView();
+      dispatch(tr);
+    },
+    update: function update(localId, mutationCallback) {
+      var _changedValues$marks;
+      var _ensureNodePosByLocal = ensureNodePosByLocalId(localId, {
+          opName: 'update'
+        }),
+        node = _ensureNodePosByLocal.node,
+        pos = _ensureNodePosByLocal.pos;
+      var _options$editorView2 = options.editorView,
+        dispatch = _options$editorView2.dispatch,
+        state = _options$editorView2.state;
+      var tr = state.tr,
+        schema = state.schema;
+      var changedValues = mutationCallback({
+        content: nodeToJSON(node).content,
+        attrs: node.attrs,
+        marks: node.marks.map(function (pmMark) {
+          return {
+            type: pmMark.type.name,
+            attrs: pmMark.attrs
+          };
+        })
+      });
+      var ensureValidMark = function ensureValidMark(mark) {
+        if (_typeof(mark) !== 'object' || Array.isArray(mark)) {
+          throw new Error("update(): Invalid mark given.");
+        }
+        var _state$doc$resolve = state.doc.resolve(pos),
+          parent = _state$doc$resolve.parent;
+        // Ensure that the given mark is present in the schema
+        var markType = schema.marks[mark.type];
+        if (!markType) {
+          throw new Error("update(): Invalid ADF mark type '".concat(mark.type, "'."));
+        }
+        if (!parent.type.allowsMarkType(markType)) {
+          throw new Error("update(): Parent of type '".concat(parent.type.name, "' does not allow marks of type '").concat(mark.type, "'."));
+        }
+        return {
+          mark: markType,
+          attrs: mark.attrs
+        };
+      };
+      var newMarks = changedValues.hasOwnProperty('marks') ? (_changedValues$marks = changedValues.marks) === null || _changedValues$marks === void 0 ? void 0 : _changedValues$marks.map(ensureValidMark).map(function (_ref3) {
+        var mark = _ref3.mark,
+          attrs = _ref3.attrs;
+        return mark.create(attrs);
+      }) : node.marks;
+      var newContent = changedValues.hasOwnProperty('content') ? Fragment.fromJSON(schema, changedValues.content) : node.content;
+      var newAttrs = changedValues.hasOwnProperty('attrs') ? changedValues.attrs : node.attrs;
+
+      // Validate if the new attributes, content and marks result in a valid node and adf.
+      try {
+        var newNode = node.type.createChecked(newAttrs, newContent, newMarks);
+        var newNodeAdf = new JSONTransformer().encodeNode(newNode);
+        validate(newNodeAdf);
+        tr.replaceWith(pos, pos + node.nodeSize, newNode);
+
+        // Keep selection if content does not change
+        if (newContent === node.content) {
+          tr.setSelection(Selection.fromJSON(tr.doc, state.selection.toJSON()));
+        }
+      } catch (err) {
+        throw new Error("update(): The given ADFEntity cannot be inserted in the current position.\n".concat(err));
+      }
+
+      // Analytics - tracking the api call
+      var apiCallPayload = extensionAPICallPayload('update');
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent(apiCallPayload)(tr);
+      dispatch(tr);
+    }
+  };
+  return {
+    editInContextPanel: function editInContextPanel(transformBefore, transformAfter) {
+      var editorView = options.editorView;
+      setEditingContextToContextPanel(transformBefore, transformAfter, options.applyChange)(editorView.state, editorView.dispatch, editorView);
+    },
+    _editInLegacyMacroBrowser: function _editInLegacyMacroBrowser() {
+      var editorView = options.editorView;
+      var editInLegacy = options.editInLegacyMacroBrowser;
+      if (!editInLegacy) {
+        var macroState = macroPluginKey.getState(editorView.state);
+        editInLegacy = getEditInLegacyMacroBrowser({
+          view: options.editorView,
+          macroProvider: (macroState === null || macroState === void 0 ? void 0 : macroState.macroProvider) || undefined,
+          editorAnalyticsAPI: editorAnalyticsAPI
+        });
+      }
+      editInLegacy();
+    },
+    doc: doc
+  };
+};

package/dist/esm/index.js

@@ -1 +1 @@
-export {};
+export { extensionPlugin } from './plugin';

package/dist/esm/plugin-factory.js

@@ -0,0 +1,25 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { pluginFactory } from '@atlaskit/editor-common/utils';
+import { pluginKey } from './plugin-key';
+import reducer from './reducer';
+var factory = pluginFactory(pluginKey, reducer, {
+  mapping: function mapping(tr, state) {
+    var _ref = state,
+      previousPositions = _ref.positions;
+    if (!previousPositions) {
+      return state;
+    }
+    var positions = _objectSpread({}, previousPositions);
+    for (var key in positions) {
+      positions[key] = tr.mapping.map(positions[key]);
+    }
+    return _objectSpread(_objectSpread({}, state), {}, {
+      positions: positions
+    });
+  }
+});
+export var createPluginState = factory.createPluginState;
+export var createCommand = factory.createCommand;
+export var getPluginState = factory.getPluginState;

package/dist/esm/plugin-key.js

@@ -0,0 +1,2 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export var pluginKey = new PluginKey('extensionPlugin');