@atlaskit/editor-plugin-mentions 13.1.1 → 13.3.0

package/dist/es2019/nodeviews/disabledTooltipRenderer.js

@@ -0,0 +1,168 @@
+/* disabledTooltipRenderer.tsx generated by @compiled/babel-plugin v0.39.1 */
+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';
+const 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.
+ */
+const 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.
+ */
+const 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.
+ */
+const useBridgedTriggerListeners = (chip, triggerProps) => {
+  useEffect(() => {
+    // 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.
+    const bindings = TRIGGER_EVENT_MAP.flatMap(([propName, eventName]) => {
+      const handler = triggerProps[propName];
+      if (!handler) {
+        return [];
+      }
+      return [{
+        type: eventName,
+        listener: event => {
+          handler(event);
+        }
+      }];
+    });
+    if (bindings.length === 0) {
+      return;
+    }
+    const unbind = bindAll(chip, bindings);
+    return unbind;
+  }, [chip, triggerProps]);
+};
+const AnchoredTooltip = ({
+  subscribe,
+  getInitialTooltip,
+  referenceElement
+}) => {
+  const [tooltip, setTooltipState] = useState(getInitialTooltip);
+  useEffect(() => subscribe(setTooltipState), [subscribe]);
+  if (!tooltip) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(Tooltip, {
+    content: tooltip,
+    position: "top"
+  }, tooltipProps => /*#__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.
+ */
+const TriggerBridge = ({
+  referenceElement,
+  tooltipProps
+}) => {
+  useBridgedTriggerListeners(referenceElement, tooltipProps);
+  return /*#__PURE__*/React.createElement("span", {
+    ref: () => assignRef(tooltipProps.ref, referenceElement),
+    "aria-hidden": "true",
+    className: ax([styles.hiddenTrigger])
+  });
+};
+export const disabledTooltipRenderer = ({
+  chipElement,
+  portalProviderAPI
+}) => {
+  // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- mirror existing renderer pattern
+  const key = uuid();
+  let currentTooltip;
+  const listeners = new Set();
+  const broadcast = () => {
+    listeners.forEach(listener => listener(currentTooltip));
+  };
+  const getInitialTooltip = () => currentTooltip;
+  const subscribe = listener => {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  };
+  const renderElement = () => /*#__PURE__*/React.createElement(AnchoredTooltip, {
+    referenceElement: chipElement,
+    getInitialTooltip: getInitialTooltip,
+    subscribe: subscribe
+  });
+  portalProviderAPI.render(renderElement, chipElement, key);
+  return {
+    setTooltip(text) {
+      currentTooltip = text;
+      broadcast();
+    },
+    destroy() {
+      portalProviderAPI.remove(key);
+      listeners.clear();
+    }
+  };
+};

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.0";
+const PACKAGE_VERSION = "13.2.0";
 const setProvider = provider => (state, dispatch) => {
   if (dispatch) {
     dispatch(state.tr.setMeta(mentionPluginKey, {

package/dist/esm/mentionsPlugin.js

@@ -14,6 +14,7 @@ import { IconMention } from '@atlaskit/editor-common/quick-insert';
 import { isResolvingMentionProvider } from '@atlaskit/mention/resource';
 import { MentionNameStatus, isPromise } from '@atlaskit/mention/types';
 import { fg } from '@atlaskit/platform-feature-flags';
+import { expVal } from '@atlaskit/tmp-editor-statsig/expVal';
 import { insertMention } from './editor-commands';
 import { mentionNodeSpec } from './nodeviews/mentionNodeSpec';
 import { mentionPluginKey } from './pm-plugins/key';
@@ -187,6 +188,13 @@ var mentionsPlugin = function mentionsPlugin(_ref3) {
           options.handleMentionsChanged(mentionChanges);
         }
       },
+      updateSectionTitle: function updateSectionTitle(props) {
+        var _api$typeAhead$action, _api$typeAhead2, _api$typeAhead2$updat;
+        if (!expVal('platform_editor_agent_mentions', 'isEnabled', false)) {
+          return false;
+        }
+        return (_api$typeAhead$action = api === null || api === void 0 || (_api$typeAhead2 = api.typeAhead) === null || _api$typeAhead2 === void 0 || (_api$typeAhead2 = _api$typeAhead2.actions) === null || _api$typeAhead2 === void 0 || (_api$typeAhead2$updat = _api$typeAhead2.updateSectionTitle) === null || _api$typeAhead2$updat === void 0 ? void 0 : _api$typeAhead2$updat.call(_api$typeAhead2, props)) !== null && _api$typeAhead$action !== void 0 ? _api$typeAhead$action : false;
+      },
       setProvider: function () {
         var _setProvider = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(providerPromise) {
           var _api$core$actions$exe;
@@ -255,13 +263,13 @@ var mentionsPlugin = function mentionsPlugin(_ref3) {
             return /*#__PURE__*/React.createElement(IconMention, null);
           },
           action: function action(insert, state) {
-            var _api$typeAhead2;
+            var _api$typeAhead3;
             var tr = insert(undefined);
             var pluginState = mentionPluginKey.getState(state);
             if (pluginState && pluginState.canInsertMention === false) {
               return false;
             }
-            api === null || api === void 0 || (_api$typeAhead2 = api.typeAhead) === null || _api$typeAhead2 === void 0 || _api$typeAhead2.actions.openAtTransaction({
+            api === null || api === void 0 || (_api$typeAhead3 = api.typeAhead) === null || _api$typeAhead3 === void 0 || _api$typeAhead3.actions.openAtTransaction({
               triggerHandler: typeAhead,
               inputMethod: INPUT_METHOD.QUICK_INSERT
             })(tr);

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();
+    }
+  };
+};