@atlaskit/editor-plugin-extension 0.4.2 → 0.5.0

package/dist/cjs/extension-api.js

@@ -0,0 +1,266 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEditInLegacyMacroBrowser = exports.createExtensionAPI = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _validator = require("@atlaskit/adf-utils/validator");
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _utils = require("@atlaskit/editor-common/utils");
+var _editorJsonTransformer = require("@atlaskit/editor-json-transformer");
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _utils2 = require("@atlaskit/editor-prosemirror/utils");
+var _commands = require("./commands");
+var _actions = require("./pm-plugins/macro/actions");
+var _pluginKey = require("./pm-plugins/macro/plugin-key");
+var _utils3 = require("./utils");
+var getEditInLegacyMacroBrowser = exports.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 = (0, _utils3.getSelectedExtension)(view.state, true);
+    if (!nodeWithPos) {
+      throw new Error("Missing nodeWithPos. Can't determine position of node");
+    }
+    (0, _actions.insertMacroFromMacroBrowser)(editorAnalyticsAPI)(macroProvider, nodeWithPos.node, true)(view);
+  };
+};
+var extensionAPICallPayload = function extensionAPICallPayload(functionName) {
+  return {
+    action: _analytics.ACTION.INVOKED,
+    actionSubject: _analytics.ACTION_SUBJECT.EXTENSION,
+    actionSubjectId: _analytics.ACTION_SUBJECT_ID.EXTENSION_API,
+    attributes: {
+      functionName: functionName
+    },
+    eventType: _analytics.EVENT_TYPE.TRACK
+  };
+};
+var createExtensionAPI = exports.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 = (0, _validator.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 = (0, _utils3.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 = _model.Fragment.fromJSON(schema, adf.content);
+      var marks = (adf.marks || []).map(function (markEntity) {
+        return _model.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 = (0, _utils3.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 ? (0, _utils3.getNodeTypesReferenced)(stringIds, state) : undefined;
+
+        // fire off analytics for this ADF
+        var payload = {
+          action: _analytics.ACTION.INSERTED,
+          actionSubject: _analytics.ACTION_SUBJECT.DOCUMENT,
+          attributes: {
+            nodeType: node.type.name,
+            inputMethod: _analytics.INPUT_METHOD.EXTENSION_API,
+            hasReferentiality: hasReferentiality,
+            nodeTypesReferenced: nodeTypesReferenced,
+            layout: node.attrs.layout,
+            extensionType: extensionType,
+            extensionKey: extensionKey
+          },
+          eventType: _analytics.EVENT_TYPE.TRACK
+        };
+        editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent(payload)(tr);
+      });
+      if (opt && opt.allowSelectionToNewNode) {
+        tr.setSelection(new _state.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 = (0, _utils2.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: (0, _utils.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 ((0, _typeof2.default)(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') ? _model.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 _editorJsonTransformer.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(_state.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;
+      (0, _commands.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 = _pluginKey.pluginKey.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/cjs/index.js

@@ -2,4 +2,11 @@
 
 Object.defineProperty(exports, "__esModule", {
   value: true
-});
+});
+Object.defineProperty(exports, "extensionPlugin", {
+  enumerable: true,
+  get: function get() {
+    return _plugin.extensionPlugin;
+  }
+});
+var _plugin = require("./plugin");

package/dist/cjs/plugin-factory.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPluginState = exports.createPluginState = exports.createCommand = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _utils = require("@atlaskit/editor-common/utils");
+var _pluginKey = require("./plugin-key");
+var _reducer = _interopRequireDefault(require("./reducer"));
+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) { (0, _defineProperty2.default)(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; }
+var factory = (0, _utils.pluginFactory)(_pluginKey.pluginKey, _reducer.default, {
+  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
+    });
+  }
+});
+var createPluginState = exports.createPluginState = factory.createPluginState;
+var createCommand = exports.createCommand = factory.createCommand;
+var getPluginState = exports.getPluginState = factory.getPluginState;

package/dist/cjs/plugin-key.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pluginKey = void 0;
+var _state = require("@atlaskit/editor-prosemirror/state");
+var pluginKey = exports.pluginKey = new _state.PluginKey('extensionPlugin');

package/dist/cjs/plugin.js

@@ -0,0 +1,147 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extensionPlugin = void 0;
+var _adfSchema = require("@atlaskit/adf-schema");
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
+var _actions = require("./actions");
+var _commands = require("./commands");
+var _contextPanel = require("./context-panel");
+var _extensionApi = require("./extension-api");
+var _keymap = _interopRequireDefault(require("./pm-plugins/keymap"));
+var _macro = require("./pm-plugins/macro");
+var _actions2 = require("./pm-plugins/macro/actions");
+var _main = require("./pm-plugins/main");
+var _uniqueId = require("./pm-plugins/unique-id");
+var _toolbar = require("./toolbar");
+var extensionPlugin = exports.extensionPlugin = function extensionPlugin(_ref) {
+  var _api$featureFlags, _api$analytics2, _api$analytics3, _api$contextPanel3, _api$analytics4, _api$contextPanel4;
+  var _ref$config = _ref.config,
+    options = _ref$config === void 0 ? {} : _ref$config,
+    _api = _ref.api;
+  var featureFlags = (_api === null || _api === void 0 || (_api$featureFlags = _api.featureFlags) === null || _api$featureFlags === void 0 ? void 0 : _api$featureFlags.sharedState.currentState()) || {};
+  //Note: This is a hack to get the editor view reference in the plugin. Copied from table plugin.
+  //This is needed to get the current selection in the editor
+  var editorViewRef = {
+    current: null
+  };
+  return {
+    name: 'extension',
+    nodes: function nodes() {
+      var extensionNodes = [{
+        name: 'extension',
+        node: _adfSchema.extension
+      }, {
+        name: 'bodiedExtension',
+        node: _adfSchema.bodiedExtension
+      }, {
+        name: 'inlineExtension',
+        node: _adfSchema.inlineExtension
+      }];
+
+      // Revert to returning all nodes without local variable, once FF is removed
+      if ((0, _platformFeatureFlags.getBooleanFF)('platform.editor.multi-bodied-extension_0rygg')) {
+        extensionNodes.push({
+          name: 'extensionFrame',
+          node: _adfSchema.extensionFrame
+        });
+        extensionNodes.push({
+          name: 'multiBodiedExtension',
+          node: _adfSchema.multiBodiedExtension
+        });
+      }
+      return extensionNodes;
+    },
+    getSharedState: function getSharedState(state) {
+      if (!state) {
+        return undefined;
+      }
+      var pluginState = _main.pluginKey.getState(state);
+      return {
+        showContextPanel: pluginState === null || pluginState === void 0 ? void 0 : pluginState.showContextPanel
+      };
+    },
+    pmPlugins: function pmPlugins() {
+      return [{
+        name: 'extension',
+        plugin: function plugin(_ref2) {
+          var dispatch = _ref2.dispatch,
+            providerFactory = _ref2.providerFactory,
+            portalProviderAPI = _ref2.portalProviderAPI,
+            eventDispatcher = _ref2.eventDispatcher;
+          var extensionHandlers = options.extensionHandlers || {};
+          return (0, _main.createPlugin)(dispatch, providerFactory, extensionHandlers, portalProviderAPI, eventDispatcher, _api, options.useLongPressSelection, {
+            appearance: options.appearance
+          });
+        }
+      }, {
+        name: 'extensionKeymap',
+        plugin: function plugin() {
+          var _api$contextPanel;
+          return (0, _keymap.default)(_api === null || _api === void 0 || (_api$contextPanel = _api.contextPanel) === null || _api$contextPanel === void 0 ? void 0 : _api$contextPanel.actions.applyChange);
+        }
+      }, {
+        name: 'extensionUniqueId',
+        plugin: function plugin() {
+          return (0, _uniqueId.createPlugin)();
+        }
+      }, {
+        name: 'extensionEditorViewRef',
+        plugin: function plugin() {
+          return new _safePlugin.SafePlugin({
+            view: function view(editorView) {
+              // Do not cleanup the editorViewRef on destroy
+              // because some functions may point to a stale
+              // reference and this means we will return null.
+              // EditorView is assumed to be stable so we do not need to
+              // cleanup.
+              // See: #hot-106316
+              editorViewRef.current = editorView;
+              return {};
+            }
+          });
+        }
+      }, {
+        name: 'macro',
+        plugin: function plugin(_ref3) {
+          var dispatch = _ref3.dispatch,
+            providerFactory = _ref3.providerFactory;
+          return (0, _macro.createPlugin)(dispatch, providerFactory);
+        }
+      }];
+    },
+    actions: {
+      api: function api() {
+        var _api$contextPanel2, _api$analytics;
+        return (0, _extensionApi.createExtensionAPI)({
+          editorView: editorViewRef.current,
+          applyChange: _api === null || _api === void 0 || (_api$contextPanel2 = _api.contextPanel) === null || _api$contextPanel2 === void 0 ? void 0 : _api$contextPanel2.actions.applyChange,
+          editorAnalyticsAPI: _api === null || _api === void 0 || (_api$analytics = _api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions
+        });
+      },
+      insertMacroFromMacroBrowser: (0, _actions2.insertMacroFromMacroBrowser)(_api === null || _api === void 0 || (_api$analytics2 = _api.analytics) === null || _api$analytics2 === void 0 ? void 0 : _api$analytics2.actions),
+      editSelectedExtension: (0, _actions.createEditSelectedExtensionAction)({
+        editorViewRef: editorViewRef,
+        editorAnalyticsAPI: _api === null || _api === void 0 || (_api$analytics3 = _api.analytics) === null || _api$analytics3 === void 0 ? void 0 : _api$analytics3.actions
+      }),
+      runMacroAutoConvert: _actions2.runMacroAutoConvert,
+      forceAutoSave: _commands.forceAutoSave
+    },
+    pluginsOptions: {
+      floatingToolbar: (0, _toolbar.getToolbarConfig)({
+        breakoutEnabled: options.breakoutEnabled,
+        hoverDecoration: _api === null || _api === void 0 ? void 0 : _api.decorations.actions.hoverDecoration,
+        applyChangeToContextPanel: _api === null || _api === void 0 || (_api$contextPanel3 = _api.contextPanel) === null || _api$contextPanel3 === void 0 ? void 0 : _api$contextPanel3.actions.applyChange,
+        editorAnalyticsAPI: _api === null || _api === void 0 || (_api$analytics4 = _api.analytics) === null || _api$analytics4 === void 0 ? void 0 : _api$analytics4.actions
+      }),
+      contextPanel: (0, _contextPanel.getContextPanel)(function () {
+        var _editorViewRef$curren;
+        return (_editorViewRef$curren = editorViewRef.current) !== null && _editorViewRef$curren !== void 0 ? _editorViewRef$curren : undefined;
+      })(options.allowAutoSave, featureFlags, _api === null || _api === void 0 || (_api$contextPanel4 = _api.contextPanel) === null || _api$contextPanel4 === void 0 ? void 0 : _api$contextPanel4.actions.applyChange)
+    }
+  };
+};

package/dist/cjs/pm-plugins/keymap.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = keymapPlugin;
+var _keymaps = require("@atlaskit/editor-common/keymaps");
+var _keymap = require("@atlaskit/editor-prosemirror/keymap");
+var _commands = require("../commands");
+var _main = require("./main");
+function keymapPlugin(applyChange) {
+  var list = {};
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.escape.common, function (state, dispatch) {
+    var extensionState = (0, _main.getPluginState)(state);
+    if (!extensionState.showContextPanel) {
+      return false;
+    }
+    return (0, _commands.clearEditingContext)(applyChange)(state, dispatch);
+  }, list);
+  return (0, _keymap.keymap)(list);
+}

package/dist/cjs/pm-plugins/macro/actions.js

@@ -0,0 +1,186 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setMacroProvider = exports.runMacroAutoConvert = exports.resolveMacro = exports.insertMacroFromMacroBrowser = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _assert = _interopRequireDefault(require("assert"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _insert = require("@atlaskit/editor-common/insert");
+var _validator = require("@atlaskit/editor-common/validator");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _pluginFactory = require("../../plugin-factory");
+var _pluginKey = require("./plugin-key");
+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) { (0, _defineProperty2.default)(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; }
+var insertMacroFromMacroBrowser = exports.insertMacroFromMacroBrowser = function insertMacroFromMacroBrowser(editorAnalyticsAPI) {
+  return function (macroProvider, macroNode, isEditing) {
+    return /*#__PURE__*/function () {
+      var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(view) {
+        var newMacro, state, dispatch, currentLayout, node, selection, schema, _schema$nodes, extension, inlineExtension, bodiedExtension, extensionState, targetSelectionSource, tr, isBodiedExtensionSelected, pos, _macroNode$attrs, extensionType, extensionKey, layout, localId;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (macroProvider) {
+                _context.next = 2;
+                break;
+              }
+              return _context.abrupt("return", false);
+            case 2:
+              _context.next = 4;
+              return macroProvider.openMacroBrowser(macroNode);
+            case 4:
+              newMacro = _context.sent;
+              if (!(newMacro && macroNode)) {
+                _context.next = 20;
+                break;
+              }
+              state = view.state, dispatch = view.dispatch;
+              currentLayout = macroNode && macroNode.attrs.layout || 'default';
+              node = resolveMacro(newMacro, state, {
+                layout: currentLayout
+              });
+              if (node) {
+                _context.next = 11;
+                break;
+              }
+              return _context.abrupt("return", false);
+            case 11:
+              selection = state.selection, schema = state.schema;
+              _schema$nodes = schema.nodes, extension = _schema$nodes.extension, inlineExtension = _schema$nodes.inlineExtension, bodiedExtension = _schema$nodes.bodiedExtension;
+              extensionState = (0, _pluginFactory.getPluginState)(state);
+              targetSelectionSource = _analytics.TARGET_SELECTION_SOURCE.CURRENT_SELECTION;
+              tr = state.tr;
+              isBodiedExtensionSelected = !!(0, _utils.findSelectedNodeOfType)([bodiedExtension])(selection); // When it's a bodiedExtension but not selected
+              if (macroNode.type === bodiedExtension && !isBodiedExtensionSelected) {
+                // `isEditing` is `false` when we are inserting from insert-block toolbar
+                tr = isEditing ? (0, _utils.replaceParentNodeOfType)(bodiedExtension, node)(tr) : (0, _utils.safeInsert)(node)(tr);
+                // Replacing selected node doesn't update the selection. `selection.node` still returns the old node
+                tr.setSelection(_state.TextSelection.create(tr.doc, state.selection.anchor));
+              }
+              // If any extension is currently selected
+              else if ((0, _utils.findSelectedNodeOfType)([extension, bodiedExtension, inlineExtension])(selection)) {
+                tr = (0, _utils.replaceSelectedNode)(node)(tr);
+                // Replacing selected node doesn't update the selection. `selection.node` still returns the old node
+                tr.setSelection(_state.NodeSelection.create(tr.doc, tr.mapping.map(state.selection.anchor)));
+              }
+              // When we loose the selection. This usually happens when Synchrony resets or changes
+              // the selection when user is in the middle of updating an extension.
+              else if (extensionState.element) {
+                pos = view.posAtDOM(extensionState.element, -1);
+                if (pos > -1) {
+                  tr = tr.replaceWith(pos, pos + macroNode.nodeSize, node);
+                  tr.setSelection(_state.Selection.near(tr.doc.resolve(pos)));
+                  targetSelectionSource = _analytics.TARGET_SELECTION_SOURCE.HTML_ELEMENT;
+                }
+              }
+
+              // Only scroll if we have anything to update, best to avoid surprise scroll
+              if (dispatch && tr.docChanged) {
+                _macroNode$attrs = macroNode.attrs, extensionType = _macroNode$attrs.extensionType, extensionKey = _macroNode$attrs.extensionKey, layout = _macroNode$attrs.layout, localId = _macroNode$attrs.localId;
+                editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
+                  action: _analytics.ACTION.UPDATED,
+                  actionSubject: _analytics.ACTION_SUBJECT.EXTENSION,
+                  actionSubjectId: macroNode.type.name,
+                  eventType: _analytics.EVENT_TYPE.TRACK,
+                  attributes: {
+                    inputMethod: isEditing ? _analytics.INPUT_METHOD.MACRO_BROWSER : _analytics.INPUT_METHOD.TOOLBAR,
+                    extensionType: extensionType,
+                    extensionKey: extensionKey,
+                    layout: layout,
+                    localId: localId,
+                    selection: tr.selection.toJSON(),
+                    targetSelectionSource: targetSelectionSource
+                  }
+                })(tr);
+                dispatch(tr.scrollIntoView());
+              }
+              return _context.abrupt("return", true);
+            case 20:
+              return _context.abrupt("return", false);
+            case 21:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+  };
+};
+var resolveMacro = exports.resolveMacro = function resolveMacro(macro, state, optionalAttrs) {
+  if (!macro || !state) {
+    return null;
+  }
+  var schema = state.schema;
+  var _getValidNode = (0, _validator.getValidNode)(macro, schema),
+    type = _getValidNode.type,
+    attrs = _getValidNode.attrs;
+  var node = null;
+  if (type === 'extension') {
+    node = schema.nodes.extension.create(_objectSpread(_objectSpread({}, attrs), optionalAttrs));
+  } else if (type === 'bodiedExtension') {
+    node = schema.nodes.bodiedExtension.create(_objectSpread(_objectSpread({}, attrs), optionalAttrs), schema.nodeFromJSON(macro).content);
+  } else if (type === 'inlineExtension') {
+    node = schema.nodes.inlineExtension.create(attrs);
+  }
+  return node && (0, _insert.normaliseNestedLayout)(state, node);
+};
+
+// gets the macroProvider from the state and tries to autoConvert a given text
+var runMacroAutoConvert = exports.runMacroAutoConvert = function runMacroAutoConvert(state, text) {
+  var macroPluginState = _pluginKey.pluginKey.getState(state);
+  var macroProvider = macroPluginState && macroPluginState.macroProvider;
+  if (!macroProvider || !macroProvider.autoConvert) {
+    return null;
+  }
+  var macroAttributes = macroProvider.autoConvert(text);
+  if (!macroAttributes) {
+    return null;
+  }
+
+  // decides which kind of macro to render (inline|bodied|bodyless)
+  return resolveMacro(macroAttributes, state);
+};
+var setMacroProvider = exports.setMacroProvider = function setMacroProvider(provider) {
+  return /*#__PURE__*/function () {
+    var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(view) {
+      var resolvedProvider;
+      return _regenerator.default.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.prev = 0;
+            _context2.next = 3;
+            return provider;
+          case 3:
+            resolvedProvider = _context2.sent;
+            (0, _assert.default)(resolvedProvider && resolvedProvider.openMacroBrowser, "MacroProvider promise did not resolve to a valid instance of MacroProvider - ".concat(resolvedProvider));
+            _context2.next = 10;
+            break;
+          case 7:
+            _context2.prev = 7;
+            _context2.t0 = _context2["catch"](0);
+            resolvedProvider = null;
+          case 10:
+            view.dispatch(view.state.tr.setMeta(_pluginKey.pluginKey, {
+              macroProvider: resolvedProvider
+            }));
+            return _context2.abrupt("return", true);
+          case 12:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, null, [[0, 7]]);
+    }));
+    return function (_x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+};