@atlaskit/editor-plugin-mentions 13.2.0 → 13.3.1

package/dist/es2019/nodeviews/mentionNodeView.js

@@ -1,4 +1,3 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { getBrowserInfo } from '@atlaskit/editor-common/browser';
 import { ZERO_WIDTH_SPACE } from '@atlaskit/editor-common/whitespace';
 import { DOMSerializer } from '@atlaskit/editor-prosemirror/model';
@@ -6,6 +5,7 @@ import { isResolvingMentionProvider, MentionNameStatus } from '@atlaskit/mention
 import { isRestricted } from '@atlaskit/mention/types';
 import { fg } from '@atlaskit/platform-feature-flags';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { disabledTooltipRenderer } from './disabledTooltipRenderer';
 import { profileCardRenderer } from './profileCardRenderer';
 const primitiveClassName = 'editor-mention-primitive';
 // @ts-ignore - TS1501 TypeScript 5.9.2 upgrade
@@ -55,7 +55,10 @@ const handleProviderName = async (mentionProvider, node) => {
     return processName(resolvedNameDetail);
   }
 };
-const getNewState = (isHighlighted, isRestricted) => {
+const getNewState = (isHighlighted, isRestricted, isDisabled) => {
+  if (isDisabled) {
+    return 'disabled';
+  }
   if (isHighlighted) {
     return 'self';
   }
@@ -67,7 +70,6 @@ const getNewState = (isHighlighted, isRestricted) => {
 export class MentionNodeView {
   constructor(node, config) {
     var _this$domElement$quer, _api$mention$sharedSt;
-    _defineProperty(this, "state", 'default');
     const {
       options,
       api,
@@ -87,10 +89,12 @@ export class MentionNodeView {
       mentionProvider
     } = (_api$mention$sharedSt = api === null || api === void 0 ? void 0 : api.mention.sharedState.currentState()) !== null && _api$mention$sharedSt !== void 0 ? _api$mention$sharedSt : {};
     this.updateState(mentionProvider);
+    this.subscribeToProviderDisabledStateChanges(mentionProvider);
     this.cleanup = api === null || api === void 0 ? void 0 : api.mention.sharedState.onChange(({
       nextSharedState
     }) => {
       this.updateState(nextSharedState === null || nextSharedState === void 0 ? void 0 : nextSharedState.mentionProvider);
+      this.subscribeToProviderDisabledStateChanges(nextSharedState === null || nextSharedState === void 0 ? void 0 : nextSharedState.mentionProvider);
     });
     const {
       destroyProfileCard,
@@ -115,10 +119,88 @@ export class MentionNodeView {
     this.destroyProfileCard = destroyProfileCard;
     this.removeProfileCard = removeProfileCard;
   }
-  setClassList(state) {
-    var _this$mentionPrimitiv, _this$mentionPrimitiv2;
+  setClassList(state, disabledTooltip) {
+    var _this$mentionPrimitiv, _this$mentionPrimitiv2, _this$mentionPrimitiv3;
     (_this$mentionPrimitiv = this.mentionPrimitiveElement) === null || _this$mentionPrimitiv === void 0 ? void 0 : _this$mentionPrimitiv.classList.toggle('mention-self', state === 'self');
     (_this$mentionPrimitiv2 = this.mentionPrimitiveElement) === null || _this$mentionPrimitiv2 === void 0 ? void 0 : _this$mentionPrimitiv2.classList.toggle('mention-restricted', state === 'restricted');
+    (_this$mentionPrimitiv3 = this.mentionPrimitiveElement) === null || _this$mentionPrimitiv3 === void 0 ? void 0 : _this$mentionPrimitiv3.classList.toggle('mention-disabled', state === 'disabled');
+    // Mirror the React `<Mention>` a11y behaviour: when the chip is
+    // disabled, expose `aria-disabled` so assistive tech announces it as
+    // such. Also surface the tooltip text via `aria-label` so screen-reader
+    // users hear *why* the chip is disabled, matching the React `<Mention>`
+    // behaviour at `Mention/index.tsx` line 152.
+    if (this.domElement) {
+      if (state === 'disabled') {
+        this.domElement.setAttribute('aria-disabled', 'true');
+        if (disabledTooltip) {
+          const text = this.node.attrs.text || '@...';
+          this.domElement.setAttribute('aria-label', `${text} — ${disabledTooltip}`);
+        }
+      } else {
+        this.domElement.removeAttribute('aria-disabled');
+        this.domElement.removeAttribute('aria-label');
+      }
+    }
+  }
+  getDisabledState(mentionProvider) {
+    var _mentionProvider$getM;
+    const input = {
+      id: this.node.attrs.id
+    };
+    return mentionProvider === null || mentionProvider === void 0 ? void 0 : (_mentionProvider$getM = mentionProvider.getMentionDisabledState) === null || _mentionProvider$getM === void 0 ? void 0 : _mentionProvider$getM.call(mentionProvider, input);
+  }
+
+  /**
+   * Subscribes this NodeView to disabled-state-change notifications on the
+   * supplied provider so already-rendered chips can re-evaluate themselves
+   * when the consumer's predicate inputs change (e.g. the active agent
+   * selection toggling in Rovo Chat). No-op for providers that don't
+   * implement `subscribeToDisabledStateChanges`.
+   *
+   * Idempotent: re-calling with the same provider keeps the existing
+   * subscription; passing a different provider tears the old subscription
+   * down before attaching the new one. Safe to call from the sharedState
+   * `onChange` handler when the editor swaps providers.
+   */
+  subscribeToProviderDisabledStateChanges(mentionProvider) {
+    var _this$unsubscribeFrom;
+    if (this.subscribedProvider === mentionProvider) {
+      return;
+    }
+    (_this$unsubscribeFrom = this.unsubscribeFromDisabledStateChanges) === null || _this$unsubscribeFrom === void 0 ? void 0 : _this$unsubscribeFrom.call(this);
+    this.unsubscribeFromDisabledStateChanges = undefined;
+    this.subscribedProvider = mentionProvider;
+    if (!(mentionProvider !== null && mentionProvider !== void 0 && mentionProvider.subscribeToDisabledStateChanges)) {
+      return;
+    }
+    this.unsubscribeFromDisabledStateChanges = mentionProvider.subscribeToDisabledStateChanges(() => {
+      this.updateState(this.subscribedProvider);
+    });
+  }
+  syncDisabledTooltip(disabledState) {
+    // Capture the tooltip text into a local so the rest of the method can
+    // branch on a truthy string instead of re-asserting non-null fields
+    // off of `disabledState`.
+    const tooltipText = disabledState !== null && disabledState !== void 0 && disabledState.disabled ? disabledState.tooltip : undefined;
+    const chip = this.mentionPrimitiveElement;
+    const {
+      portalProviderAPI
+    } = this.config;
+    if (!chip || !portalProviderAPI) {
+      return;
+    }
+    if (tooltipText) {
+      if (!this.disabledTooltip) {
+        this.disabledTooltip = disabledTooltipRenderer({
+          chipElement: chip,
+          portalProviderAPI
+        });
+      }
+      this.disabledTooltip.setTooltip(tooltipText);
+    } else if (this.disabledTooltip) {
+      this.disabledTooltip.destroy();
+      this.disabledTooltip = undefined;
+    }
   }
   setTextContent(name) {
     if (name && !this.node.attrs.text && this.mentionPrimitiveElement) {
@@ -145,14 +227,25 @@ export class MentionNodeView {
     const isHighlighted = expValEquals('platform_editor_vc90_transition_mentions', 'isEnabled', true) ? this.shouldHighlightMention(mentionProvider) : (_mentionProvider$shou2 = mentionProvider === null || mentionProvider === void 0 ? void 0 : mentionProvider.shouldHighlightMention({
       id: this.node.attrs.id
     })) !== null && _mentionProvider$shou2 !== void 0 ? _mentionProvider$shou2 : false;
-    const newState = getNewState(isHighlighted, isRestricted(this.node.attrs.accessLevel));
-    if (newState !== this.state) {
-      this.setClassList(newState);
-      this.state = newState;
-    }
+    const disabledState = this.getDisabledState(mentionProvider);
+    const isDisabled = !!(disabledState !== null && disabledState !== void 0 && disabledState.disabled);
+    const newState = getNewState(isHighlighted, isRestricted(this.node.attrs.accessLevel), isDisabled);
+    const disabledTooltip = disabledState !== null && disabledState !== void 0 && disabledState.disabled ? disabledState.tooltip : undefined;
+    // `setClassList` always runs so the aria-label (which depends on the
+    // tooltip text) stays in sync when the tooltip reason changes while
+    // the chip remains disabled. State-change-only writes would leave a
+    // stale aria-label after a tooltip-text-only update.
+    this.setClassList(newState, disabledTooltip);
+    // Tooltip wiring runs every update (not just on state change) so that
+    // the tooltip text stays in sync if the disabled reason changes while
+    // the chip is already disabled.
+    this.syncDisabledTooltip(disabledState);
     const name = await handleProviderName(mentionProvider, this.node);
     this.setTextContent(name);
-    if (name && this.domElement && (_this$config$options2 = this.config.options) !== null && _this$config$options2 !== void 0 && _this$config$options2.profilecardProvider) {
+    // Only overwrite the disabled-state aria-label with the name-based one
+    // when the chip is NOT disabled; otherwise the disabled reason set in
+    // `setClassList` would be silently clobbered, regressing a11y.
+    if (name && this.domElement && (_this$config$options2 = this.config.options) !== null && _this$config$options2 !== void 0 && _this$config$options2.profilecardProvider && newState !== 'disabled') {
       this.domElement.setAttribute('aria-label', getAccessibilityLabelFromName(name));
     }
   }
@@ -176,9 +269,27 @@ export class MentionNodeView {
     return true;
   }
   destroy() {
-    var _this$cleanup, _this$destroyProfileC;
+    var _this$cleanup, _this$destroyProfileC, _this$disabledTooltip, _this$unsubscribeFrom2;
+    // Surface the destruction to the provider before tearing down so the
+    // chat layer can react (e.g. drop the agent id from `selectedAgentIds`).
+    // This is the lowest-level deletion signal — fires for backspace,
+    // select-and-delete, programmatic doc replaces, and editor unmount.
+    try {
+      var _this$subscribedProvi, _this$subscribedProvi2;
+      (_this$subscribedProvi = this.subscribedProvider) === null || _this$subscribedProvi === void 0 ? void 0 : (_this$subscribedProvi2 = _this$subscribedProvi.notifyMentionDestroyed) === null || _this$subscribedProvi2 === void 0 ? void 0 : _this$subscribedProvi2.call(_this$subscribedProvi, {
+        id: this.node.attrs.id
+      });
+    } catch (_error) {
+      // Defensive: never let consumer-side notification errors prevent
+      // the NodeView from cleaning up its own resources below.
+    }
     (_this$cleanup = this.cleanup) === null || _this$cleanup === void 0 ? void 0 : _this$cleanup.call(this);
     (_this$destroyProfileC = this.destroyProfileCard) === null || _this$destroyProfileC === void 0 ? void 0 : _this$destroyProfileC.call(this);
+    (_this$disabledTooltip = this.disabledTooltip) === null || _this$disabledTooltip === void 0 ? void 0 : _this$disabledTooltip.destroy();
+    this.disabledTooltip = undefined;
+    (_this$unsubscribeFrom2 = this.unsubscribeFromDisabledStateChanges) === null || _this$unsubscribeFrom2 === void 0 ? void 0 : _this$unsubscribeFrom2.call(this);
+    this.unsubscribeFromDisabledStateChanges = undefined;
+    this.subscribedProvider = undefined;
   }
   deselectNode() {
     var _this$removeProfileCa;

package/dist/es2019/pm-plugins/main.js

@@ -17,7 +17,7 @@ export const ACTIONS = {
 const AGENT_USER_TYPES = new Set(['APP', 'AGENT']);
 const AI_STREAMING_TRANSFORMATION_META_KEY = 'isAIStreamingTransformation';
 const PACKAGE_NAME = "@atlaskit/editor-plugin-mentions";
-const PACKAGE_VERSION = "13.1.1";
+const PACKAGE_VERSION = "13.3.0";
 const setProvider = provider => (state, dispatch) => {
   if (dispatch) {
     dispatch(state.tr.setMeta(mentionPluginKey, {

package/dist/esm/nodeviews/disabledTooltipRenderer.compiled.css

@@ -0,0 +1 @@
+._1e0cglyw{display:none}

package/dist/esm/nodeviews/disabledTooltipRenderer.js

@@ -0,0 +1,184 @@
+/* disabledTooltipRenderer.tsx generated by @compiled/babel-plugin v0.39.1 */
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import "./disabledTooltipRenderer.compiled.css";
+import { ax, ix } from "@compiled/react/runtime";
+import React, { useEffect, useState } from 'react';
+import { bindAll } from 'bind-event-listener';
+// eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- mirror existing renderer pattern
+import uuid from 'uuid/v4';
+import Tooltip from '@atlaskit/tooltip';
+var styles = {
+  hiddenTrigger: "_1e0cglyw"
+};
+
+/**
+ * ADS `<Tooltip>` hands us a ref via its render-prop child. That ref may be
+ * either a callback ref or a mutable ref object — React supports both shapes
+ * and ADS's typing keeps both possible. This helper assigns the supplied
+ * element to whichever ref shape was provided so the tooltip ends up using
+ * the chip's bounding box for positioning and its DOM for trigger events.
+ */
+var assignRef = function assignRef(ref, element) {
+  if (typeof ref === 'function') {
+    ref(element);
+  } else if (ref) {
+    ref.current = element;
+  }
+};
+
+/**
+ * Names of the React-style trigger-prop handlers we forward from ADS
+ * `<Tooltip>` onto the chip element.
+ */
+
+/**
+ * Maps each React-style trigger-prop handler ADS `<Tooltip>` hands us in its
+ * render-prop callback to the DOM event name we attach to the chip via
+ * `bind-event-listener`. The chip lives in the ProseMirror document and is
+ * not a React child of the tooltip, so we have to bridge React handlers to
+ * native event listeners ourselves.
+ *
+ * Names are listed in the same order ADS internally registers them.
+ */
+var TRIGGER_EVENT_MAP = [['onMouseOver', 'mouseover'], ['onMouseOut', 'mouseout'], ['onMouseMove', 'mousemove'], ['onMouseDown', 'mousedown'], ['onFocus', 'focusin'], ['onBlur', 'focusout']];
+
+/**
+ * Anchors an ADS `<Tooltip>` to a ProseMirror chip element that is **not** a
+ * React child of the tooltip. The chip itself stays in the PM document; this
+ * renderer mounts an always-present React subtree via `portalProviderAPI` whose
+ * sole job is to host the tooltip and forward the ADS-provided trigger ref +
+ * event handlers onto the chip.
+ *
+ * The forwarding is deliberate: ADS `<Tooltip>` expects to attach its hover /
+ * focus / blur listeners to its render-prop child, but our render-prop child
+ * is a `display: none` placeholder span that no real event can reach. We bridge
+ * those listeners to the chip via `addEventListener` so the tooltip opens and
+ * closes in response to the user actually interacting with the chip — keyboard
+ * focus, mouse hover, screen-reader focus, the lot.
+ */
+
+/**
+ * Hook that mirrors ADS Tooltip's React trigger props onto a DOM element
+ * which is not a React child of the tooltip. Re-attaches whenever ADS hands
+ * us a fresh set of props (which happens on every render of the render-prop
+ * child) and cleans up on unmount.
+ *
+ * We use `bind-event-listener`'s `bindAll` rather than raw
+ * `addEventListener` / `removeEventListener` calls so the lifetime of every
+ * subscription is paired with a single `UnbindFn` — the AFM-mandated pattern
+ * for keeping listener bookkeeping leak-free.
+ */
+var useBridgedTriggerListeners = function useBridgedTriggerListeners(chip, triggerProps) {
+  useEffect(function () {
+    // Build the bindAll bindings array out of only the handlers ADS actually
+    // supplied. Each React handler is wrapped in a thin adapter so the
+    // listener signature matches the native `EventListener` shape; ADS
+    // handlers ignore the synthetic-event-only fields they don't use
+    // (target, currentTarget), so passing the raw DOM event through
+    // `unknown` is safe in practice.
+    var bindings = TRIGGER_EVENT_MAP.flatMap(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        propName = _ref2[0],
+        eventName = _ref2[1];
+      var handler = triggerProps[propName];
+      if (!handler) {
+        return [];
+      }
+      return [{
+        type: eventName,
+        listener: function listener(event) {
+          handler(event);
+        }
+      }];
+    });
+    if (bindings.length === 0) {
+      return;
+    }
+    var unbind = bindAll(chip, bindings);
+    return unbind;
+  }, [chip, triggerProps]);
+};
+var AnchoredTooltip = function AnchoredTooltip(_ref3) {
+  var subscribe = _ref3.subscribe,
+    getInitialTooltip = _ref3.getInitialTooltip,
+    referenceElement = _ref3.referenceElement;
+  var _useState = useState(getInitialTooltip),
+    _useState2 = _slicedToArray(_useState, 2),
+    tooltip = _useState2[0],
+    setTooltipState = _useState2[1];
+  useEffect(function () {
+    return subscribe(setTooltipState);
+  }, [subscribe]);
+  if (!tooltip) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(Tooltip, {
+    content: tooltip,
+    position: "top"
+  }, function (tooltipProps) {
+    return /*#__PURE__*/React.createElement(TriggerBridge, {
+      referenceElement: referenceElement,
+      tooltipProps: tooltipProps
+    });
+  });
+};
+
+/**
+ * Render-prop child for ADS `<Tooltip>`. The element it returns is a
+ * `display: none` placeholder that satisfies the render-prop API; the
+ * real trigger surface is the chip in the PM document, which receives
+ * both the ADS ref and the bridged event listeners via the side-effects
+ * declared on this component.
+ */
+var TriggerBridge = function TriggerBridge(_ref4) {
+  var referenceElement = _ref4.referenceElement,
+    tooltipProps = _ref4.tooltipProps;
+  useBridgedTriggerListeners(referenceElement, tooltipProps);
+  return /*#__PURE__*/React.createElement("span", {
+    ref: function ref() {
+      return assignRef(tooltipProps.ref, referenceElement);
+    },
+    "aria-hidden": "true",
+    className: ax([styles.hiddenTrigger])
+  });
+};
+export var disabledTooltipRenderer = function disabledTooltipRenderer(_ref5) {
+  var chipElement = _ref5.chipElement,
+    portalProviderAPI = _ref5.portalProviderAPI;
+  // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- mirror existing renderer pattern
+  var key = uuid();
+  var currentTooltip;
+  var listeners = new Set();
+  var broadcast = function broadcast() {
+    listeners.forEach(function (listener) {
+      return listener(currentTooltip);
+    });
+  };
+  var getInitialTooltip = function getInitialTooltip() {
+    return currentTooltip;
+  };
+  var subscribe = function subscribe(listener) {
+    listeners.add(listener);
+    return function () {
+      listeners.delete(listener);
+    };
+  };
+  var renderElement = function renderElement() {
+    return /*#__PURE__*/React.createElement(AnchoredTooltip, {
+      referenceElement: chipElement,
+      getInitialTooltip: getInitialTooltip,
+      subscribe: subscribe
+    });
+  };
+  portalProviderAPI.render(renderElement, chipElement, key);
+  return {
+    setTooltip: function setTooltip(text) {
+      currentTooltip = text;
+      broadcast();
+    },
+    destroy: function destroy() {
+      portalProviderAPI.remove(key);
+      listeners.clear();
+    }
+  };
+};

package/dist/esm/nodeviews/mentionNodeView.js

@@ -12,6 +12,7 @@ import { isResolvingMentionProvider, MentionNameStatus } from '@atlaskit/mention
 import { isRestricted } from '@atlaskit/mention/types';
 import { fg } from '@atlaskit/platform-feature-flags';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { disabledTooltipRenderer } from './disabledTooltipRenderer';
 import { profileCardRenderer } from './profileCardRenderer';
 var primitiveClassName = 'editor-mention-primitive';
 // @ts-ignore - TS1501 TypeScript 5.9.2 upgrade
@@ -81,7 +82,10 @@ var handleProviderName = /*#__PURE__*/function () {
     return _ref.apply(this, arguments);
   };
 }();
-var getNewState = function getNewState(isHighlighted, isRestricted) {
+var getNewState = function getNewState(isHighlighted, isRestricted, isDisabled) {
+  if (isDisabled) {
+    return 'disabled';
+  }
   if (isHighlighted) {
     return 'self';
   }
@@ -96,7 +100,6 @@ export var MentionNodeView = /*#__PURE__*/function () {
       _api$mention$sharedSt,
       _this = this;
     _classCallCheck(this, MentionNodeView);
-    _defineProperty(this, "state", 'default');
     var options = config.options,
       api = config.api,
       portalProviderAPI = config.portalProviderAPI;
@@ -112,9 +115,11 @@ export var MentionNodeView = /*#__PURE__*/function () {
     var _ref2 = (_api$mention$sharedSt = api === null || api === void 0 ? void 0 : api.mention.sharedState.currentState()) !== null && _api$mention$sharedSt !== void 0 ? _api$mention$sharedSt : {},
       mentionProvider = _ref2.mentionProvider;
     this.updateState(mentionProvider);
+    this.subscribeToProviderDisabledStateChanges(mentionProvider);
     this.cleanup = api === null || api === void 0 ? void 0 : api.mention.sharedState.onChange(function (_ref3) {
       var nextSharedState = _ref3.nextSharedState;
       _this.updateState(nextSharedState === null || nextSharedState === void 0 ? void 0 : nextSharedState.mentionProvider);
+      _this.subscribeToProviderDisabledStateChanges(nextSharedState === null || nextSharedState === void 0 ? void 0 : nextSharedState.mentionProvider);
     });
     var _profileCardRenderer = profileCardRenderer({
         dom: dom,
@@ -140,10 +145,93 @@ export var MentionNodeView = /*#__PURE__*/function () {
   }
   return _createClass(MentionNodeView, [{
     key: "setClassList",
-    value: function setClassList(state) {
-      var _this$mentionPrimitiv, _this$mentionPrimitiv2;
+    value: function setClassList(state, disabledTooltip) {
+      var _this$mentionPrimitiv, _this$mentionPrimitiv2, _this$mentionPrimitiv3;
       (_this$mentionPrimitiv = this.mentionPrimitiveElement) === null || _this$mentionPrimitiv === void 0 || _this$mentionPrimitiv.classList.toggle('mention-self', state === 'self');
       (_this$mentionPrimitiv2 = this.mentionPrimitiveElement) === null || _this$mentionPrimitiv2 === void 0 || _this$mentionPrimitiv2.classList.toggle('mention-restricted', state === 'restricted');
+      (_this$mentionPrimitiv3 = this.mentionPrimitiveElement) === null || _this$mentionPrimitiv3 === void 0 || _this$mentionPrimitiv3.classList.toggle('mention-disabled', state === 'disabled');
+      // Mirror the React `<Mention>` a11y behaviour: when the chip is
+      // disabled, expose `aria-disabled` so assistive tech announces it as
+      // such. Also surface the tooltip text via `aria-label` so screen-reader
+      // users hear *why* the chip is disabled, matching the React `<Mention>`
+      // behaviour at `Mention/index.tsx` line 152.
+      if (this.domElement) {
+        if (state === 'disabled') {
+          this.domElement.setAttribute('aria-disabled', 'true');
+          if (disabledTooltip) {
+            var text = this.node.attrs.text || '@...';
+            this.domElement.setAttribute('aria-label', "".concat(text, " \u2014 ").concat(disabledTooltip));
+          }
+        } else {
+          this.domElement.removeAttribute('aria-disabled');
+          this.domElement.removeAttribute('aria-label');
+        }
+      }
+    }
+  }, {
+    key: "getDisabledState",
+    value: function getDisabledState(mentionProvider) {
+      var _mentionProvider$getM;
+      var input = {
+        id: this.node.attrs.id
+      };
+      return mentionProvider === null || mentionProvider === void 0 || (_mentionProvider$getM = mentionProvider.getMentionDisabledState) === null || _mentionProvider$getM === void 0 ? void 0 : _mentionProvider$getM.call(mentionProvider, input);
+    }
+
+    /**
+     * Subscribes this NodeView to disabled-state-change notifications on the
+     * supplied provider so already-rendered chips can re-evaluate themselves
+     * when the consumer's predicate inputs change (e.g. the active agent
+     * selection toggling in Rovo Chat). No-op for providers that don't
+     * implement `subscribeToDisabledStateChanges`.
+     *
+     * Idempotent: re-calling with the same provider keeps the existing
+     * subscription; passing a different provider tears the old subscription
+     * down before attaching the new one. Safe to call from the sharedState
+     * `onChange` handler when the editor swaps providers.
+     */
+  }, {
+    key: "subscribeToProviderDisabledStateChanges",
+    value: function subscribeToProviderDisabledStateChanges(mentionProvider) {
+      var _this$unsubscribeFrom,
+        _this2 = this;
+      if (this.subscribedProvider === mentionProvider) {
+        return;
+      }
+      (_this$unsubscribeFrom = this.unsubscribeFromDisabledStateChanges) === null || _this$unsubscribeFrom === void 0 || _this$unsubscribeFrom.call(this);
+      this.unsubscribeFromDisabledStateChanges = undefined;
+      this.subscribedProvider = mentionProvider;
+      if (!(mentionProvider !== null && mentionProvider !== void 0 && mentionProvider.subscribeToDisabledStateChanges)) {
+        return;
+      }
+      this.unsubscribeFromDisabledStateChanges = mentionProvider.subscribeToDisabledStateChanges(function () {
+        _this2.updateState(_this2.subscribedProvider);
+      });
+    }
+  }, {
+    key: "syncDisabledTooltip",
+    value: function syncDisabledTooltip(disabledState) {
+      // Capture the tooltip text into a local so the rest of the method can
+      // branch on a truthy string instead of re-asserting non-null fields
+      // off of `disabledState`.
+      var tooltipText = disabledState !== null && disabledState !== void 0 && disabledState.disabled ? disabledState.tooltip : undefined;
+      var chip = this.mentionPrimitiveElement;
+      var portalProviderAPI = this.config.portalProviderAPI;
+      if (!chip || !portalProviderAPI) {
+        return;
+      }
+      if (tooltipText) {
+        if (!this.disabledTooltip) {
+          this.disabledTooltip = disabledTooltipRenderer({
+            chipElement: chip,
+            portalProviderAPI: portalProviderAPI
+          });
+        }
+        this.disabledTooltip.setTooltip(tooltipText);
+      } else if (this.disabledTooltip) {
+        this.disabledTooltip.destroy();
+        this.disabledTooltip = undefined;
+      }
     }
   }, {
     key: "setTextContent",
@@ -173,24 +261,34 @@ export var MentionNodeView = /*#__PURE__*/function () {
     value: function () {
       var _updateState = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(mentionProvider) {
         var _mentionProvider$shou2, _this$config$options2;
-        var isHighlighted, newState, name;
+        var isHighlighted, disabledState, isDisabled, newState, disabledTooltip, name;
         return _regeneratorRuntime.wrap(function (_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
               isHighlighted = expValEquals('platform_editor_vc90_transition_mentions', 'isEnabled', true) ? this.shouldHighlightMention(mentionProvider) : (_mentionProvider$shou2 = mentionProvider === null || mentionProvider === void 0 ? void 0 : mentionProvider.shouldHighlightMention({
                 id: this.node.attrs.id
               })) !== null && _mentionProvider$shou2 !== void 0 ? _mentionProvider$shou2 : false;
-              newState = getNewState(isHighlighted, isRestricted(this.node.attrs.accessLevel));
-              if (newState !== this.state) {
-                this.setClassList(newState);
-                this.state = newState;
-              }
+              disabledState = this.getDisabledState(mentionProvider);
+              isDisabled = !!(disabledState !== null && disabledState !== void 0 && disabledState.disabled);
+              newState = getNewState(isHighlighted, isRestricted(this.node.attrs.accessLevel), isDisabled);
+              disabledTooltip = disabledState !== null && disabledState !== void 0 && disabledState.disabled ? disabledState.tooltip : undefined; // `setClassList` always runs so the aria-label (which depends on the
+              // tooltip text) stays in sync when the tooltip reason changes while
+              // the chip remains disabled. State-change-only writes would leave a
+              // stale aria-label after a tooltip-text-only update.
+              this.setClassList(newState, disabledTooltip);
+              // Tooltip wiring runs every update (not just on state change) so that
+              // the tooltip text stays in sync if the disabled reason changes while
+              // the chip is already disabled.
+              this.syncDisabledTooltip(disabledState);
               _context2.next = 1;
               return handleProviderName(mentionProvider, this.node);
             case 1:
               name = _context2.sent;
               this.setTextContent(name);
-              if (name && this.domElement && (_this$config$options2 = this.config.options) !== null && _this$config$options2 !== void 0 && _this$config$options2.profilecardProvider) {
+              // Only overwrite the disabled-state aria-label with the name-based one
+              // when the chip is NOT disabled; otherwise the disabled reason set in
+              // `setClassList` would be silently clobbered, regressing a11y.
+              if (name && this.domElement && (_this$config$options2 = this.config.options) !== null && _this$config$options2 !== void 0 && _this$config$options2.profilecardProvider && newState !== 'disabled') {
                 this.domElement.setAttribute('aria-label', getAccessibilityLabelFromName(name));
               }
             case 2:
@@ -229,9 +327,27 @@ export var MentionNodeView = /*#__PURE__*/function () {
   }, {
     key: "destroy",
     value: function destroy() {
-      var _this$cleanup, _this$destroyProfileC;
+      var _this$cleanup, _this$destroyProfileC, _this$disabledTooltip, _this$unsubscribeFrom2;
+      // Surface the destruction to the provider before tearing down so the
+      // chat layer can react (e.g. drop the agent id from `selectedAgentIds`).
+      // This is the lowest-level deletion signal — fires for backspace,
+      // select-and-delete, programmatic doc replaces, and editor unmount.
+      try {
+        var _this$subscribedProvi, _this$subscribedProvi2;
+        (_this$subscribedProvi = this.subscribedProvider) === null || _this$subscribedProvi === void 0 || (_this$subscribedProvi2 = _this$subscribedProvi.notifyMentionDestroyed) === null || _this$subscribedProvi2 === void 0 || _this$subscribedProvi2.call(_this$subscribedProvi, {
+          id: this.node.attrs.id
+        });
+      } catch (_error) {
+        // Defensive: never let consumer-side notification errors prevent
+        // the NodeView from cleaning up its own resources below.
+      }
       (_this$cleanup = this.cleanup) === null || _this$cleanup === void 0 || _this$cleanup.call(this);
       (_this$destroyProfileC = this.destroyProfileCard) === null || _this$destroyProfileC === void 0 || _this$destroyProfileC.call(this);
+      (_this$disabledTooltip = this.disabledTooltip) === null || _this$disabledTooltip === void 0 || _this$disabledTooltip.destroy();
+      this.disabledTooltip = undefined;
+      (_this$unsubscribeFrom2 = this.unsubscribeFromDisabledStateChanges) === null || _this$unsubscribeFrom2 === void 0 || _this$unsubscribeFrom2.call(this);
+      this.unsubscribeFromDisabledStateChanges = undefined;
+      this.subscribedProvider = undefined;
     }
   }, {
     key: "deselectNode",

package/dist/esm/pm-plugins/main.js

@@ -24,7 +24,7 @@ export var ACTIONS = {
 var AGENT_USER_TYPES = new Set(['APP', 'AGENT']);
 var AI_STREAMING_TRANSFORMATION_META_KEY = 'isAIStreamingTransformation';
 var PACKAGE_NAME = "@atlaskit/editor-plugin-mentions";
-var PACKAGE_VERSION = "13.1.1";
+var PACKAGE_VERSION = "13.3.0";
 var setProvider = function setProvider(provider) {
   return function (state, dispatch) {
     if (dispatch) {

package/dist/types/nodeviews/disabledTooltipRenderer.d.ts

@@ -0,0 +1,25 @@
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal';
+/**
+ * Anchors an ADS `<Tooltip>` to a ProseMirror chip element that is **not** a
+ * React child of the tooltip. The chip itself stays in the PM document; this
+ * renderer mounts an always-present React subtree via `portalProviderAPI` whose
+ * sole job is to host the tooltip and forward the ADS-provided trigger ref +
+ * event handlers onto the chip.
+ *
+ * The forwarding is deliberate: ADS `<Tooltip>` expects to attach its hover /
+ * focus / blur listeners to its render-prop child, but our render-prop child
+ * is a `display: none` placeholder span that no real event can reach. We bridge
+ * those listeners to the chip via `addEventListener` so the tooltip opens and
+ * closes in response to the user actually interacting with the chip — keyboard
+ * focus, mouse hover, screen-reader focus, the lot.
+ */
+export interface DisabledTooltipController {
+    /** Tear down the React subtree. */
+    destroy: () => void;
+    /** Update the tooltip text. Passing `undefined` hides the tooltip. */
+    setTooltip: (text: string | undefined) => void;
+}
+export declare const disabledTooltipRenderer: ({ chipElement, portalProviderAPI, }: {
+    chipElement: HTMLElement;
+    portalProviderAPI: PortalProviderAPI;
+}) => DisabledTooltipController;