@atlaskit/editor-common 103.2.0 → 103.3.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @atlaskit/editor-common
 
+## 103.3.0
+
+### Minor Changes
+
+- [#137860](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/137860)
+  [`04e753d1ba0f4`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/04e753d1ba0f4) -
+  Created a new Annotation manager implementation and interface and updated CCFE to create and share
+  this instance around
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 103.2.0
 
 ### Minor Changes

package/dist/cjs/annotation/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AnnotationUpdateEmitter = void 0;
+exports.createAnnotationManager = createAnnotationManager;
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
@@ -12,6 +13,7 @@ var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/ge
 var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 var _events = require("events");
+var _manager = require("./manager");
 function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
@@ -32,4 +34,17 @@ var AnnotationUpdateEmitter = exports.AnnotationUpdateEmitter = /*#__PURE__*/fun
       return _superPropGet(AnnotationUpdateEmitter, "removeListener", this, 3)([event, listener]);
     }
   }]);
-}(_events.EventEmitter);
+}(_events.EventEmitter); // type ActionResult = { step: Step; doc: JSONDocNode } | false;
+// } & AnnotationByMatches)
+// | false;
+// ### Events
+// ### Hook Results
+/**
+ * This is the list of methods which exist on the Manager interface. These are the methods that can be hooked into.
+ */
+/*
+ * This is the public interface for the AnnotationManager. It provides methods for interacting with the manager.
+ */
+function createAnnotationManager() {
+  return new _manager.SharedAnnotationManager();
+}

package/dist/cjs/annotation/manager.js

@@ -0,0 +1,243 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SharedAnnotationManager = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _events = require("events");
+var SharedAnnotationManager = exports.SharedAnnotationManager = /*#__PURE__*/function () {
+  function SharedAnnotationManager() {
+    (0, _classCallCheck2.default)(this, SharedAnnotationManager);
+    /**
+     * This is the event emitter that is used to emit events from the manager. It is used to communicate with
+     * other parts of the application.
+     */
+    (0, _defineProperty2.default)(this, "emitter", new _events.EventEmitter());
+    /**
+     * This is the map of hooks that can be added to the manager. Hooks are a 1:1 mapping of methods that can be
+     * called on the manager. They are used to extend the functionality of the manager.
+     */
+    (0, _defineProperty2.default)(this, "hooks", new Map());
+    (0, _defineProperty2.default)(this, "preemptiveGate", function () {
+      return Promise.resolve(true);
+    });
+  }
+  return (0, _createClass2.default)(SharedAnnotationManager, [{
+    key: "setPreemptiveGate",
+    value: function setPreemptiveGate(handler) {
+      this.preemptiveGate = handler;
+      return this;
+    }
+  }, {
+    key: "checkPreemptiveGate",
+    value: function checkPreemptiveGate() {
+      return this.preemptiveGate();
+    }
+  }, {
+    key: "onDraftAnnotationStarted",
+    value: function onDraftAnnotationStarted(handler) {
+      this.emitter.on('draftAnnotationStarted', handler);
+      return this;
+    }
+  }, {
+    key: "offDraftAnnotationStarted",
+    value: function offDraftAnnotationStarted(handler) {
+      this.emitter.off('draftAnnotationStarted', handler);
+      return this;
+    }
+  }, {
+    key: "onAnnotationSelectionChange",
+    value: function onAnnotationSelectionChange(handler) {
+      this.emitter.on('annotationSelectionChanged', handler);
+      return this;
+    }
+  }, {
+    key: "offAnnotationSelectionChange",
+    value: function offAnnotationSelectionChange(handler) {
+      this.emitter.off('annotationSelectionChanged', handler);
+      return this;
+    }
+  }, {
+    key: "emit",
+    value: function emit(event) {
+      this.emitter.emit(event.name, event.data);
+      return this;
+    }
+  }, {
+    key: "hook",
+    value: function hook(method, handler) {
+      this.hooks.set(method, handler);
+      return this;
+    }
+  }, {
+    key: "unhook",
+    value: function unhook(method, handler) {
+      if (!this.hooks.has(method) || this.hooks.get(method) !== handler) {
+        return this;
+      }
+      this.hooks.delete(method);
+      return this;
+    }
+  }, {
+    key: "allowAnnotation",
+    value: function allowAnnotation() {
+      var fn = this.hooks.get('allowAnnotation');
+      if (!fn) {
+        return false;
+      }
+      try {
+        return fn();
+      } catch (error) {
+        return false;
+      }
+    }
+  }, {
+    key: "startDraft",
+    value: function startDraft() {
+      var fn = this.hooks.get('startDraft');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        var result = fn();
+        if (result.success) {
+          this.emitter.emit('draftAnnotationStarted', {
+            targetElement: result.targetElement,
+            inlineNodeTypes: result.inlineNodeTypes,
+            actionResult: result.actionResult
+          });
+        }
+        return result;
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }, {
+    key: "clearDraft",
+    value: function clearDraft() {
+      var fn = this.hooks.get('clearDraft');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        return fn();
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }, {
+    key: "applyDraft",
+    value: function applyDraft(id) {
+      var fn = this.hooks.get('applyDraft');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        return fn(id);
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }, {
+    key: "getDraft",
+    value: function getDraft() {
+      var fn = this.hooks.get('getDraft');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        return fn();
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }, {
+    key: "setIsAnnotationSelected",
+    value: function setIsAnnotationSelected(id, isSelected) {
+      var fn = this.hooks.get('setIsAnnotationSelected');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        // NOTE: The hook needs to manage the firing the annotationSelectionChanged event when a change is made. This is
+        // because the hook is responsible for the state of the selection. The manager is not responsible for the state of
+        // the selection.
+        return fn(id, isSelected);
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }, {
+    key: "setIsAnnotationHovered",
+    value: function setIsAnnotationHovered(id, isHovered) {
+      var fn = this.hooks.get('setIsAnnotationHovered');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        return fn(id, isHovered);
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }, {
+    key: "clearAnnotation",
+    value: function clearAnnotation(id) {
+      var fn = this.hooks.get('clearAnnotation');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        return fn(id);
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }]);
+}();

package/dist/cjs/monitoring/error.js

@@ -17,7 +17,7 @@ function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 var SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 var packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-var packageVersion = "103.2.0";
+var packageVersion = "103.3.0";
 var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/cjs/ui/DropList/index.js

@@ -23,7 +23,7 @@ function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.
  * @jsx jsx
  */ // eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled -- Ignored via go/DSP-18766
 var packageName = "@atlaskit/editor-common";
-var packageVersion = "103.2.0";
+var packageVersion = "103.3.0";
 var halfFocusRing = 1;
 var dropOffset = '0, 8';
 // Ignored via go/ees005

package/dist/es2019/annotation/index.js

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'events';
+import { SharedAnnotationManager } from './manager';
 export class AnnotationUpdateEmitter extends EventEmitter {
   on(event, listener) {
     return super.on(event, listener);
@@ -6,4 +7,25 @@ export class AnnotationUpdateEmitter extends EventEmitter {
   off(event, listener) {
     return super.removeListener(event, listener);
   }
+}
+
+// type ActionResult = { step: Step; doc: JSONDocNode } | false;
+
+// } & AnnotationByMatches)
+// | false;
+
+// ### Events
+
+// ### Hook Results
+
+/**
+ * This is the list of methods which exist on the Manager interface. These are the methods that can be hooked into.
+ */
+
+/*
+ * This is the public interface for the AnnotationManager. It provides methods for interacting with the manager.
+ */
+
+export function createAnnotationManager() {
+  return new SharedAnnotationManager();
 }

package/dist/es2019/annotation/manager.js

@@ -0,0 +1,196 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { EventEmitter } from 'events';
+export class SharedAnnotationManager {
+  constructor() {
+    /**
+     * This is the event emitter that is used to emit events from the manager. It is used to communicate with
+     * other parts of the application.
+     */
+    _defineProperty(this, "emitter", new EventEmitter());
+    /**
+     * This is the map of hooks that can be added to the manager. Hooks are a 1:1 mapping of methods that can be
+     * called on the manager. They are used to extend the functionality of the manager.
+     */
+    _defineProperty(this, "hooks", new Map());
+    _defineProperty(this, "preemptiveGate", () => Promise.resolve(true));
+  }
+  setPreemptiveGate(handler) {
+    this.preemptiveGate = handler;
+    return this;
+  }
+  checkPreemptiveGate() {
+    return this.preemptiveGate();
+  }
+  onDraftAnnotationStarted(handler) {
+    this.emitter.on('draftAnnotationStarted', handler);
+    return this;
+  }
+  offDraftAnnotationStarted(handler) {
+    this.emitter.off('draftAnnotationStarted', handler);
+    return this;
+  }
+  onAnnotationSelectionChange(handler) {
+    this.emitter.on('annotationSelectionChanged', handler);
+    return this;
+  }
+  offAnnotationSelectionChange(handler) {
+    this.emitter.off('annotationSelectionChanged', handler);
+    return this;
+  }
+  emit(event) {
+    this.emitter.emit(event.name, event.data);
+    return this;
+  }
+  hook(method, handler) {
+    this.hooks.set(method, handler);
+    return this;
+  }
+  unhook(method, handler) {
+    if (!this.hooks.has(method) || this.hooks.get(method) !== handler) {
+      return this;
+    }
+    this.hooks.delete(method);
+    return this;
+  }
+  allowAnnotation() {
+    const fn = this.hooks.get('allowAnnotation');
+    if (!fn) {
+      return false;
+    }
+    try {
+      return fn();
+    } catch (error) {
+      return false;
+    }
+  }
+  startDraft() {
+    const fn = this.hooks.get('startDraft');
+    if (!fn) {
+      return {
+        success: false,
+        reason: 'manager-not-initialized'
+      };
+    }
+    try {
+      const result = fn();
+      if (result.success) {
+        this.emitter.emit('draftAnnotationStarted', {
+          targetElement: result.targetElement,
+          inlineNodeTypes: result.inlineNodeTypes,
+          actionResult: result.actionResult
+        });
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        reason: 'hook-execution-error'
+      };
+    }
+  }
+  clearDraft() {
+    const fn = this.hooks.get('clearDraft');
+    if (!fn) {
+      return {
+        success: false,
+        reason: 'manager-not-initialized'
+      };
+    }
+    try {
+      return fn();
+    } catch (error) {
+      return {
+        success: false,
+        reason: 'hook-execution-error'
+      };
+    }
+  }
+  applyDraft(id) {
+    const fn = this.hooks.get('applyDraft');
+    if (!fn) {
+      return {
+        success: false,
+        reason: 'manager-not-initialized'
+      };
+    }
+    try {
+      return fn(id);
+    } catch (error) {
+      return {
+        success: false,
+        reason: 'hook-execution-error'
+      };
+    }
+  }
+  getDraft() {
+    const fn = this.hooks.get('getDraft');
+    if (!fn) {
+      return {
+        success: false,
+        reason: 'manager-not-initialized'
+      };
+    }
+    try {
+      return fn();
+    } catch (error) {
+      return {
+        success: false,
+        reason: 'hook-execution-error'
+      };
+    }
+  }
+  setIsAnnotationSelected(id, isSelected) {
+    const fn = this.hooks.get('setIsAnnotationSelected');
+    if (!fn) {
+      return {
+        success: false,
+        reason: 'manager-not-initialized'
+      };
+    }
+    try {
+      // NOTE: The hook needs to manage the firing the annotationSelectionChanged event when a change is made. This is
+      // because the hook is responsible for the state of the selection. The manager is not responsible for the state of
+      // the selection.
+      return fn(id, isSelected);
+    } catch (error) {
+      return {
+        success: false,
+        reason: 'hook-execution-error'
+      };
+    }
+  }
+  setIsAnnotationHovered(id, isHovered) {
+    const fn = this.hooks.get('setIsAnnotationHovered');
+    if (!fn) {
+      return {
+        success: false,
+        reason: 'manager-not-initialized'
+      };
+    }
+    try {
+      return fn(id, isHovered);
+    } catch (error) {
+      return {
+        success: false,
+        reason: 'hook-execution-error'
+      };
+    }
+  }
+  clearAnnotation(id) {
+    const fn = this.hooks.get('clearAnnotation');
+    if (!fn) {
+      return {
+        success: false,
+        reason: 'manager-not-initialized'
+      };
+    }
+    try {
+      return fn(id);
+    } catch (error) {
+      return {
+        success: false,
+        reason: 'hook-execution-error'
+      };
+    }
+  }
+}

package/dist/es2019/monitoring/error.js

@@ -1,7 +1,7 @@
 import { isFedRamp } from './environment';
 const SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 const packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-const packageVersion = "103.2.0";
+const packageVersion = "103.3.0";
 const sanitiseSentryEvents = (data, _hint) => {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/es2019/ui/DropList/index.js

@@ -13,7 +13,7 @@ import withAnalyticsContext from '@atlaskit/analytics-next/withAnalyticsContext'
 import withAnalyticsEvents from '@atlaskit/analytics-next/withAnalyticsEvents';
 import Layer from '../Layer';
 const packageName = "@atlaskit/editor-common";
-const packageVersion = "103.2.0";
+const packageVersion = "103.3.0";
 const halfFocusRing = 1;
 const dropOffset = '0, 8';
 // Ignored via go/ees005

package/dist/esm/annotation/index.js

@@ -8,6 +8,7 @@ function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstruct
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 function _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
 import { EventEmitter } from 'events';
+import { SharedAnnotationManager } from './manager';
 export var AnnotationUpdateEmitter = /*#__PURE__*/function (_EventEmitter) {
   function AnnotationUpdateEmitter() {
     _classCallCheck(this, AnnotationUpdateEmitter);
@@ -25,4 +26,25 @@ export var AnnotationUpdateEmitter = /*#__PURE__*/function (_EventEmitter) {
       return _superPropGet(AnnotationUpdateEmitter, "removeListener", this, 3)([event, listener]);
     }
   }]);
-}(EventEmitter);
+}(EventEmitter);
+
+// type ActionResult = { step: Step; doc: JSONDocNode } | false;
+
+// } & AnnotationByMatches)
+// | false;
+
+// ### Events
+
+// ### Hook Results
+
+/**
+ * This is the list of methods which exist on the Manager interface. These are the methods that can be hooked into.
+ */
+
+/*
+ * This is the public interface for the AnnotationManager. It provides methods for interacting with the manager.
+ */
+
+export function createAnnotationManager() {
+  return new SharedAnnotationManager();
+}

package/dist/esm/annotation/manager.js

@@ -0,0 +1,236 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { EventEmitter } from 'events';
+export var SharedAnnotationManager = /*#__PURE__*/function () {
+  function SharedAnnotationManager() {
+    _classCallCheck(this, SharedAnnotationManager);
+    /**
+     * This is the event emitter that is used to emit events from the manager. It is used to communicate with
+     * other parts of the application.
+     */
+    _defineProperty(this, "emitter", new EventEmitter());
+    /**
+     * This is the map of hooks that can be added to the manager. Hooks are a 1:1 mapping of methods that can be
+     * called on the manager. They are used to extend the functionality of the manager.
+     */
+    _defineProperty(this, "hooks", new Map());
+    _defineProperty(this, "preemptiveGate", function () {
+      return Promise.resolve(true);
+    });
+  }
+  return _createClass(SharedAnnotationManager, [{
+    key: "setPreemptiveGate",
+    value: function setPreemptiveGate(handler) {
+      this.preemptiveGate = handler;
+      return this;
+    }
+  }, {
+    key: "checkPreemptiveGate",
+    value: function checkPreemptiveGate() {
+      return this.preemptiveGate();
+    }
+  }, {
+    key: "onDraftAnnotationStarted",
+    value: function onDraftAnnotationStarted(handler) {
+      this.emitter.on('draftAnnotationStarted', handler);
+      return this;
+    }
+  }, {
+    key: "offDraftAnnotationStarted",
+    value: function offDraftAnnotationStarted(handler) {
+      this.emitter.off('draftAnnotationStarted', handler);
+      return this;
+    }
+  }, {
+    key: "onAnnotationSelectionChange",
+    value: function onAnnotationSelectionChange(handler) {
+      this.emitter.on('annotationSelectionChanged', handler);
+      return this;
+    }
+  }, {
+    key: "offAnnotationSelectionChange",
+    value: function offAnnotationSelectionChange(handler) {
+      this.emitter.off('annotationSelectionChanged', handler);
+      return this;
+    }
+  }, {
+    key: "emit",
+    value: function emit(event) {
+      this.emitter.emit(event.name, event.data);
+      return this;
+    }
+  }, {
+    key: "hook",
+    value: function hook(method, handler) {
+      this.hooks.set(method, handler);
+      return this;
+    }
+  }, {
+    key: "unhook",
+    value: function unhook(method, handler) {
+      if (!this.hooks.has(method) || this.hooks.get(method) !== handler) {
+        return this;
+      }
+      this.hooks.delete(method);
+      return this;
+    }
+  }, {
+    key: "allowAnnotation",
+    value: function allowAnnotation() {
+      var fn = this.hooks.get('allowAnnotation');
+      if (!fn) {
+        return false;
+      }
+      try {
+        return fn();
+      } catch (error) {
+        return false;
+      }
+    }
+  }, {
+    key: "startDraft",
+    value: function startDraft() {
+      var fn = this.hooks.get('startDraft');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        var result = fn();
+        if (result.success) {
+          this.emitter.emit('draftAnnotationStarted', {
+            targetElement: result.targetElement,
+            inlineNodeTypes: result.inlineNodeTypes,
+            actionResult: result.actionResult
+          });
+        }
+        return result;
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }, {
+    key: "clearDraft",
+    value: function clearDraft() {
+      var fn = this.hooks.get('clearDraft');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        return fn();
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }, {
+    key: "applyDraft",
+    value: function applyDraft(id) {
+      var fn = this.hooks.get('applyDraft');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        return fn(id);
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }, {
+    key: "getDraft",
+    value: function getDraft() {
+      var fn = this.hooks.get('getDraft');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        return fn();
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }, {
+    key: "setIsAnnotationSelected",
+    value: function setIsAnnotationSelected(id, isSelected) {
+      var fn = this.hooks.get('setIsAnnotationSelected');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        // NOTE: The hook needs to manage the firing the annotationSelectionChanged event when a change is made. This is
+        // because the hook is responsible for the state of the selection. The manager is not responsible for the state of
+        // the selection.
+        return fn(id, isSelected);
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }, {
+    key: "setIsAnnotationHovered",
+    value: function setIsAnnotationHovered(id, isHovered) {
+      var fn = this.hooks.get('setIsAnnotationHovered');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        return fn(id, isHovered);
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }, {
+    key: "clearAnnotation",
+    value: function clearAnnotation(id) {
+      var fn = this.hooks.get('clearAnnotation');
+      if (!fn) {
+        return {
+          success: false,
+          reason: 'manager-not-initialized'
+        };
+      }
+      try {
+        return fn(id);
+      } catch (error) {
+        return {
+          success: false,
+          reason: 'hook-execution-error'
+        };
+      }
+    }
+  }]);
+}();

package/dist/esm/monitoring/error.js

@@ -7,7 +7,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 import { isFedRamp } from './environment';
 var SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 var packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-var packageVersion = "103.2.0";
+var packageVersion = "103.3.0";
 var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
   // Remove URL as it has UGC
   // Ignored via go/ees007

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

@@ -20,7 +20,7 @@ import withAnalyticsContext from '@atlaskit/analytics-next/withAnalyticsContext'
 import withAnalyticsEvents from '@atlaskit/analytics-next/withAnalyticsEvents';
 import Layer from '../Layer';
 var packageName = "@atlaskit/editor-common";
-var packageVersion = "103.2.0";
+var packageVersion = "103.3.0";
 var halfFocusRing = 1;
 var dropOffset = '0, 8';
 // Ignored via go/ees005

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

@@ -2,6 +2,9 @@
 /// <reference types="node/events" />
 /// <reference types="typings/events" />
 import { EventEmitter } from 'events';
+import type { AnnotationId } from '@atlaskit/adf-schema';
+import type { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import type { Step } from '@atlaskit/editor-prosemirror/transform';
 export type UpdateEvent = 'create' | 'delete' | 'resolve' | 'unresolve' | 'setselectedannotation' | 'sethoveredannotation' | 'removehoveredannotation';
 export type VisibilityEvent = 'setvisibility';
 type AnnotationCallback = (params: string) => void;
@@ -11,4 +14,133 @@ export declare class AnnotationUpdateEmitter extends EventEmitter {
     on(event: UpdateEvent, listener: (annotationId: string) => void): this;
     off(event: string, listener: AnnotationCallback | VisibilityCallback): this;
 }
+type ActionResult = {
+    step: Step;
+    doc: JSONDocNode;
+    /** The list of types of all inline nodes, which were wrapped by annotation. */
+    inlineNodeTypes?: string[];
+    targetNodeType?: string;
+};
+export type AnnotationDraftStartedData = {
+    targetElement: HTMLElement | undefined;
+    /**
+     * This list of inline node types at the draft selection location
+     */
+    inlineNodeTypes: string[];
+    /**
+     * The actionResult can be used by Product so they're able to perform the
+     * required NCS transaction to add the annotation to the document.
+     */
+    actionResult: ActionResult | undefined;
+};
+export type AnnotationSelectedChangeData = {
+    annotationId: AnnotationId;
+    isSelected: boolean;
+    inlineNodeTypes: string[];
+};
+export type AnnotationManagerEvents = {
+    name: 'draftAnnotationStarted';
+    data: AnnotationDraftStartedData;
+} | {
+    name: 'annotationSelectionChanged';
+    data: AnnotationSelectedChangeData;
+};
+export type ManagerFailureReasons = 'manager-not-initialized' | 'hook-execution-error';
+export type StartDraftResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'invalid-range' | 'draft-in-progress';
+} | ({
+    success: true;
+} & AnnotationDraftStartedData);
+export type ClearDraftResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'draft-not-started';
+} | {
+    success: true;
+};
+export type ApplyDraftResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'draft-not-started' | 'range-no-longer-exists';
+} | {
+    success: true;
+    targetElement: HTMLElement | undefined;
+};
+export type GetDraftResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'draft-not-started';
+} | ({
+    success: true;
+} & AnnotationDraftStartedData);
+export type ClearAnnotationResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'id-not-valid';
+} | {
+    success: true;
+    actionResult: ActionResult | undefined;
+};
+export type SelectAnnotationResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'id-not-valid';
+} | {
+    success: true;
+    isSelected: boolean;
+};
+export type HoverAnnotationResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'id-not-valid';
+} | {
+    success: true;
+    isHovered: boolean;
+};
+/**
+ * This is the list of methods which exist on the Manager interface. These are the methods that can be hooked into.
+ */
+export type AnnotationManagerMethods = {
+    allowAnnotation: () => boolean;
+    startDraft: () => StartDraftResult;
+    clearDraft: () => ClearDraftResult;
+    applyDraft: (id: AnnotationId) => ApplyDraftResult;
+    getDraft: () => GetDraftResult;
+    setIsAnnotationSelected: (id: AnnotationId, isSelected: boolean) => SelectAnnotationResult;
+    setIsAnnotationHovered: (id: AnnotationId, isHovered: boolean) => HoverAnnotationResult;
+    clearAnnotation: (id: AnnotationId) => ClearAnnotationResult;
+};
+export type AnnotationManager = AnnotationManagerMethods & {
+    /**
+     * This method is used to set a preemptive gate. A preemptive gate is a function that will be called
+     * before the manager performs an action. If the function returns false, the action will not be performed.
+     */
+    setPreemptiveGate(handler: () => Promise<boolean>): AnnotationManager;
+    /**
+     * This method is used to run the configured preemptive gate check.
+     * @internal
+     */
+    checkPreemptiveGate(): Promise<boolean>;
+    onDraftAnnotationStarted(handler: (data: AnnotationDraftStartedData) => void): AnnotationManager;
+    offDraftAnnotationStarted(handler: (data: AnnotationDraftStartedData) => void): AnnotationManager;
+    onAnnotationSelectionChange(handler: (data: AnnotationSelectedChangeData) => void): AnnotationManager;
+    offAnnotationSelectionChange(handler: (data: AnnotationSelectedChangeData) => void): AnnotationManager;
+    /**
+     * @internal
+     * This method is intended for internal Platform use only. It is not intended for use by Product code.
+     */
+    emit(event: {
+        name: 'draftAnnotationStarted';
+        data: AnnotationDraftStartedData;
+    } | {
+        name: 'annotationSelectionChanged';
+        data: AnnotationSelectedChangeData;
+    }): AnnotationManager;
+    /**
+     * @internal
+     * This method is intended for internal Platform use only. It is not intended for use by Product code.
+     */
+    hook<H extends keyof AnnotationManagerMethods>(method: H, handler: AnnotationManagerMethods[H]): AnnotationManager;
+    /**
+     * @internal
+     * This method is intended for internal Platform use only. It is not intended for use by Product code.
+     */
+    unhook<H extends keyof AnnotationManagerMethods>(method: H, handler: AnnotationManagerMethods[H]): AnnotationManager;
+};
+export declare function createAnnotationManager(): AnnotationManager;
 export {};

package/dist/types/annotation/manager.d.ts

@@ -0,0 +1,32 @@
+import type { AnnotationId } from '@atlaskit/adf-schema';
+import type { AnnotationDraftStartedData, AnnotationManager, AnnotationManagerEvents, AnnotationManagerMethods, AnnotationSelectedChangeData, ApplyDraftResult, ClearAnnotationResult, ClearDraftResult, GetDraftResult, HoverAnnotationResult, SelectAnnotationResult, StartDraftResult } from './index';
+export declare class SharedAnnotationManager implements AnnotationManager {
+    /**
+     * This is the event emitter that is used to emit events from the manager. It is used to communicate with
+     * other parts of the application.
+     */
+    private emitter;
+    /**
+     * This is the map of hooks that can be added to the manager. Hooks are a 1:1 mapping of methods that can be
+     * called on the manager. They are used to extend the functionality of the manager.
+     */
+    private hooks;
+    private preemptiveGate;
+    setPreemptiveGate(handler: () => Promise<boolean>): AnnotationManager;
+    checkPreemptiveGate(): Promise<boolean>;
+    onDraftAnnotationStarted(handler: (data: AnnotationDraftStartedData) => void): AnnotationManager;
+    offDraftAnnotationStarted(handler: (data: AnnotationDraftStartedData) => void): AnnotationManager;
+    onAnnotationSelectionChange(handler: (data: AnnotationSelectedChangeData) => void): AnnotationManager;
+    offAnnotationSelectionChange(handler: (data: AnnotationSelectedChangeData) => void): AnnotationManager;
+    emit(event: AnnotationManagerEvents): AnnotationManager;
+    hook<H extends keyof AnnotationManagerMethods>(method: H, handler: AnnotationManagerMethods[H]): AnnotationManager;
+    unhook<H extends keyof AnnotationManagerMethods>(method: H, handler: AnnotationManagerMethods[H]): AnnotationManager;
+    allowAnnotation(): boolean;
+    startDraft(): StartDraftResult;
+    clearDraft(): ClearDraftResult;
+    applyDraft(id: AnnotationId): ApplyDraftResult;
+    getDraft(): GetDraftResult;
+    setIsAnnotationSelected(id: string, isSelected: boolean): SelectAnnotationResult;
+    setIsAnnotationHovered(id: string, isHovered: boolean): HoverAnnotationResult;
+    clearAnnotation(id: AnnotationId): ClearAnnotationResult;
+}

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

@@ -2,6 +2,7 @@
 import type { AnnotationId, AnnotationTypes } from '@atlaskit/adf-schema';
 import type { JSONDocNode } from '@atlaskit/editor-json-transformer';
 import type { Step } from '@atlaskit/editor-prosemirror/transform';
+import type { AnnotationManager } from '../../annotation';
 import type { AnnotationState, AnnotationUpdateEmitter } from './emitter';
 export type AnnotationByMatches = {
     originalSelection: string;
@@ -141,5 +142,6 @@ export type InlineCommentAnnotationProvider = AnnotationTypeProvider<AnnotationT
 };
 export type AnnotationProviders = {
     inlineComment: InlineCommentAnnotationProvider;
+    annotationManager?: AnnotationManager;
 };
 export {};

package/dist/types-ts4.5/annotation/index.d.ts

@@ -2,6 +2,9 @@
 /// <reference types="node/events" />
 /// <reference types="typings/events" />
 import { EventEmitter } from 'events';
+import type { AnnotationId } from '@atlaskit/adf-schema';
+import type { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import type { Step } from '@atlaskit/editor-prosemirror/transform';
 export type UpdateEvent = 'create' | 'delete' | 'resolve' | 'unresolve' | 'setselectedannotation' | 'sethoveredannotation' | 'removehoveredannotation';
 export type VisibilityEvent = 'setvisibility';
 type AnnotationCallback = (params: string) => void;
@@ -11,4 +14,133 @@ export declare class AnnotationUpdateEmitter extends EventEmitter {
     on(event: UpdateEvent, listener: (annotationId: string) => void): this;
     off(event: string, listener: AnnotationCallback | VisibilityCallback): this;
 }
+type ActionResult = {
+    step: Step;
+    doc: JSONDocNode;
+    /** The list of types of all inline nodes, which were wrapped by annotation. */
+    inlineNodeTypes?: string[];
+    targetNodeType?: string;
+};
+export type AnnotationDraftStartedData = {
+    targetElement: HTMLElement | undefined;
+    /**
+     * This list of inline node types at the draft selection location
+     */
+    inlineNodeTypes: string[];
+    /**
+     * The actionResult can be used by Product so they're able to perform the
+     * required NCS transaction to add the annotation to the document.
+     */
+    actionResult: ActionResult | undefined;
+};
+export type AnnotationSelectedChangeData = {
+    annotationId: AnnotationId;
+    isSelected: boolean;
+    inlineNodeTypes: string[];
+};
+export type AnnotationManagerEvents = {
+    name: 'draftAnnotationStarted';
+    data: AnnotationDraftStartedData;
+} | {
+    name: 'annotationSelectionChanged';
+    data: AnnotationSelectedChangeData;
+};
+export type ManagerFailureReasons = 'manager-not-initialized' | 'hook-execution-error';
+export type StartDraftResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'invalid-range' | 'draft-in-progress';
+} | ({
+    success: true;
+} & AnnotationDraftStartedData);
+export type ClearDraftResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'draft-not-started';
+} | {
+    success: true;
+};
+export type ApplyDraftResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'draft-not-started' | 'range-no-longer-exists';
+} | {
+    success: true;
+    targetElement: HTMLElement | undefined;
+};
+export type GetDraftResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'draft-not-started';
+} | ({
+    success: true;
+} & AnnotationDraftStartedData);
+export type ClearAnnotationResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'id-not-valid';
+} | {
+    success: true;
+    actionResult: ActionResult | undefined;
+};
+export type SelectAnnotationResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'id-not-valid';
+} | {
+    success: true;
+    isSelected: boolean;
+};
+export type HoverAnnotationResult = {
+    success: false;
+    reason: ManagerFailureReasons | 'id-not-valid';
+} | {
+    success: true;
+    isHovered: boolean;
+};
+/**
+ * This is the list of methods which exist on the Manager interface. These are the methods that can be hooked into.
+ */
+export type AnnotationManagerMethods = {
+    allowAnnotation: () => boolean;
+    startDraft: () => StartDraftResult;
+    clearDraft: () => ClearDraftResult;
+    applyDraft: (id: AnnotationId) => ApplyDraftResult;
+    getDraft: () => GetDraftResult;
+    setIsAnnotationSelected: (id: AnnotationId, isSelected: boolean) => SelectAnnotationResult;
+    setIsAnnotationHovered: (id: AnnotationId, isHovered: boolean) => HoverAnnotationResult;
+    clearAnnotation: (id: AnnotationId) => ClearAnnotationResult;
+};
+export type AnnotationManager = AnnotationManagerMethods & {
+    /**
+     * This method is used to set a preemptive gate. A preemptive gate is a function that will be called
+     * before the manager performs an action. If the function returns false, the action will not be performed.
+     */
+    setPreemptiveGate(handler: () => Promise<boolean>): AnnotationManager;
+    /**
+     * This method is used to run the configured preemptive gate check.
+     * @internal
+     */
+    checkPreemptiveGate(): Promise<boolean>;
+    onDraftAnnotationStarted(handler: (data: AnnotationDraftStartedData) => void): AnnotationManager;
+    offDraftAnnotationStarted(handler: (data: AnnotationDraftStartedData) => void): AnnotationManager;
+    onAnnotationSelectionChange(handler: (data: AnnotationSelectedChangeData) => void): AnnotationManager;
+    offAnnotationSelectionChange(handler: (data: AnnotationSelectedChangeData) => void): AnnotationManager;
+    /**
+     * @internal
+     * This method is intended for internal Platform use only. It is not intended for use by Product code.
+     */
+    emit(event: {
+        name: 'draftAnnotationStarted';
+        data: AnnotationDraftStartedData;
+    } | {
+        name: 'annotationSelectionChanged';
+        data: AnnotationSelectedChangeData;
+    }): AnnotationManager;
+    /**
+     * @internal
+     * This method is intended for internal Platform use only. It is not intended for use by Product code.
+     */
+    hook<H extends keyof AnnotationManagerMethods>(method: H, handler: AnnotationManagerMethods[H]): AnnotationManager;
+    /**
+     * @internal
+     * This method is intended for internal Platform use only. It is not intended for use by Product code.
+     */
+    unhook<H extends keyof AnnotationManagerMethods>(method: H, handler: AnnotationManagerMethods[H]): AnnotationManager;
+};
+export declare function createAnnotationManager(): AnnotationManager;
 export {};

package/dist/types-ts4.5/annotation/manager.d.ts

@@ -0,0 +1,32 @@
+import type { AnnotationId } from '@atlaskit/adf-schema';
+import type { AnnotationDraftStartedData, AnnotationManager, AnnotationManagerEvents, AnnotationManagerMethods, AnnotationSelectedChangeData, ApplyDraftResult, ClearAnnotationResult, ClearDraftResult, GetDraftResult, HoverAnnotationResult, SelectAnnotationResult, StartDraftResult } from './index';
+export declare class SharedAnnotationManager implements AnnotationManager {
+    /**
+     * This is the event emitter that is used to emit events from the manager. It is used to communicate with
+     * other parts of the application.
+     */
+    private emitter;
+    /**
+     * This is the map of hooks that can be added to the manager. Hooks are a 1:1 mapping of methods that can be
+     * called on the manager. They are used to extend the functionality of the manager.
+     */
+    private hooks;
+    private preemptiveGate;
+    setPreemptiveGate(handler: () => Promise<boolean>): AnnotationManager;
+    checkPreemptiveGate(): Promise<boolean>;
+    onDraftAnnotationStarted(handler: (data: AnnotationDraftStartedData) => void): AnnotationManager;
+    offDraftAnnotationStarted(handler: (data: AnnotationDraftStartedData) => void): AnnotationManager;
+    onAnnotationSelectionChange(handler: (data: AnnotationSelectedChangeData) => void): AnnotationManager;
+    offAnnotationSelectionChange(handler: (data: AnnotationSelectedChangeData) => void): AnnotationManager;
+    emit(event: AnnotationManagerEvents): AnnotationManager;
+    hook<H extends keyof AnnotationManagerMethods>(method: H, handler: AnnotationManagerMethods[H]): AnnotationManager;
+    unhook<H extends keyof AnnotationManagerMethods>(method: H, handler: AnnotationManagerMethods[H]): AnnotationManager;
+    allowAnnotation(): boolean;
+    startDraft(): StartDraftResult;
+    clearDraft(): ClearDraftResult;
+    applyDraft(id: AnnotationId): ApplyDraftResult;
+    getDraft(): GetDraftResult;
+    setIsAnnotationSelected(id: string, isSelected: boolean): SelectAnnotationResult;
+    setIsAnnotationHovered(id: string, isHovered: boolean): HoverAnnotationResult;
+    clearAnnotation(id: AnnotationId): ClearAnnotationResult;
+}

package/dist/types-ts4.5/types/annotation/index.d.ts

@@ -2,6 +2,7 @@
 import type { AnnotationId, AnnotationTypes } from '@atlaskit/adf-schema';
 import type { JSONDocNode } from '@atlaskit/editor-json-transformer';
 import type { Step } from '@atlaskit/editor-prosemirror/transform';
+import type { AnnotationManager } from '../../annotation';
 import type { AnnotationState, AnnotationUpdateEmitter } from './emitter';
 export type AnnotationByMatches = {
     originalSelection: string;
@@ -141,5 +142,6 @@ export type InlineCommentAnnotationProvider = AnnotationTypeProvider<AnnotationT
 };
 export type AnnotationProviders = {
     inlineComment: InlineCommentAnnotationProvider;
+    annotationManager?: AnnotationManager;
 };
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-common",
-	"version": "103.2.0",
+	"version": "103.3.0",
 	"description": "A package that contains common classes and components for editor and renderer",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"