@atlaskit/editor-plugin-paste-options-toolbar 11.2.2 → 11.3.0

package/dist/es2019/ui/utils/paste-menu-rules/isNotSingleLink.js

@@ -0,0 +1,111 @@
+/**
+ * Returns true if the given text node's sole mark is a `link` mark whose href
+ * matches the node's text content exactly (i.e. the link label IS the URL).
+ */
+const isUrlOnlyLinkTextNode = node => {
+  var _node$marks$0$attrs$h, _node$marks$0$attrs;
+  if (!node.isText) {
+    return false;
+  }
+  if (node.marks.length !== 1 || node.marks[0].type.name !== 'link') {
+    return false;
+  }
+  const href = (_node$marks$0$attrs$h = (_node$marks$0$attrs = node.marks[0].attrs) === null || _node$marks$0$attrs === void 0 ? void 0 : _node$marks$0$attrs.href) !== null && _node$marks$0$attrs$h !== void 0 ? _node$marks$0$attrs$h : '';
+  return node.text === href;
+};
+
+/**
+ * Returns true if the slice represents a single inline card (smartlink) node.
+ * Handles two shapes:
+ *  - paragraph > inlineCard  (smartlink from editor/renderer, wrapped in a paragraph)
+ *  - inlineCard              (top-level inlineCard with no paragraph wrapper)
+ */
+const isSingleInlineCard = slice => {
+  if (slice.content.childCount !== 1) {
+    return false;
+  }
+  const topNode = slice.content.child(0);
+
+  // Top-level inlineCard (no paragraph wrapper)
+  if (topNode.type.name === 'inlineCard') {
+    return true;
+  }
+
+  // paragraph > inlineCard
+  if (topNode.type.name !== 'paragraph') {
+    return false;
+  }
+  if (topNode.childCount !== 1) {
+    return false;
+  }
+  return topNode.child(0).type.name === 'inlineCard';
+};
+
+/**
+ * Returns the children of a Fragment, filtering out whitespace-only text nodes.
+ * This handles trailing/leading spaces that browsers sometimes include when
+ * copying a link (e.g. `<a href="...">URL</a> `).
+ */
+const significantChildren = fragment => {
+  const children = [];
+  fragment.forEach(child => {
+    var _child$text;
+    if (child.isText && ((_child$text = child.text) === null || _child$text === void 0 ? void 0 : _child$text.trim()) === '') {
+      return;
+    }
+    children.push(child);
+  });
+  return children;
+};
+
+/**
+ * Returns true if the slice represents a single bare link with no label.
+ * Handles two shapes:
+ *  - paragraph > text(link mark)  (standard rich-text paste, wrapped in a paragraph)
+ *  - text(link mark)              (top-level text node with no paragraph wrapper)
+ * Whitespace-only sibling text nodes are ignored in both cases.
+ */
+const isSingleBareLink = slice => {
+  // Top-level text node with a link mark (no paragraph wrapper)
+  const significantTopChildren = significantChildren(slice.content);
+  if (significantTopChildren.length === 1 && isUrlOnlyLinkTextNode(significantTopChildren[0])) {
+    return true;
+  }
+
+  // paragraph > text(link mark)
+  if (slice.content.childCount !== 1) {
+    return false;
+  }
+  const topNode = slice.content.child(0);
+  if (topNode.type.name !== 'paragraph') {
+    return false;
+  }
+  const children = significantChildren(topNode.content);
+  if (children.length !== 1) {
+    return false;
+  }
+  return isUrlOnlyLinkTextNode(children[0]);
+};
+
+/**
+ * Returns `true` when the pasted content is NOT a single standalone link.
+ *
+ * A paste is considered a "single link" (returns `false`) when:
+ *  - The slice contains exactly one paragraph with one text node whose text
+ *    equals its `link` mark href (bare URL link, no custom label), OR
+ *  - The slice contains exactly one paragraph with a single `inlineCard` node
+ *    (smartlink from the renderer or editor).
+ *
+ * Returns `true` (not a single link) when:
+ *  - The pasted link has a custom label (text ≠ href)
+ *  - There are multiple paragraphs or sibling nodes
+ *  - There is additional text alongside the link in the same paragraph
+ *  - The slice is absent (plain-text paste)
+ */
+export const isNotSingleLink = slice => {
+  if (!slice || !slice.content.size) {
+    // No rich-text slice → plain text paste, not a single link in the relevant sense
+    return true;
+  }
+  return !isSingleBareLink(slice) && !isSingleInlineCard(slice);
+};

package/dist/es2019/ui/utils/paste-menu-rules/rules.js

@@ -1,11 +1,19 @@
+import { hasMixedNodes } from './hasMixedNodes';
 import { hasTableNode } from './hasTableNode';
 import { isNotProse } from './isNotProse';
+import { isNotSingleLink } from './isNotSingleLink';
 /**
  * Returns a rule that hides the paste-menu button when the pasted plain-text
  * is shorter than `minChars` characters.
  */
 const minCharsRule = minChars => context => context.getPlaintextLength() < minChars;
 
+/**
+ * Returns a rule that hides the paste-menu button when the pasted plain-text
+ * is longer than `maxChars` characters.
+ */
+const maxCharsRule = maxChars => context => context.getPlaintextLength() > maxChars;
+
 /**
  * A rule that hides the paste-menu button when the pasted content is plain
  * text (i.e. not rich-text / prose).
@@ -29,6 +37,63 @@ const containsTableRule = context => hasTableNode(context.getPastedSlice());
  */
 const excludedAncestorRule = excludedNames => context => context.getAncestorNodeNames().some(name => excludedNames.includes(name));
 
+/**
+ * Returns a rule that hides the paste-menu button when the pasted content contains
+ * more than one node type (e.g. a mix of paragraphs and headings, or a table
+ * with multiple cell types).
+ */
+const hideIfMixedNodesRule = context => {
+  const slice = context.getPastedSlice();
+  if (!slice) {
+    return false;
+  }
+  return hasMixedNodes(slice);
+};
+
+/**
+ * Returns a rule that hides the paste-menu button when the pasted content contains
+ * only a single node type (e.g. a single paragraph, or a table with only one cell type).
+ * This is the inverse of `hideIfMixedNodesRule` and can be used in combination with it
+ * to target pastes that contain either exactly one node type or more than one node type.
+ */
+const hideIfSingleNodeRule = context => {
+  const slice = context.getPastedSlice();
+  if (!slice) {
+    return false;
+  }
+  return !hasMixedNodes(slice);
+};
+
+/**
+ * A rule that hides the paste-menu button when the paste source is NOT an
+ * external application (i.e. the content was pasted from within the Fabric
+ * editor or renderer rather than from a third-party source).
+ */
+const notExternalPasteRule = context => {
+  const source = context.getPasteSource();
+  return source === 'fabric-editor' || source === 'fabric-renderer';
+};
+
+/**
+ * A rule that hides the paste-menu button when the pasted content is a single
+ * standalone link — i.e. a bare URL link (text equals href) alone in a
+ * paragraph, or a single inline card (smartlink) alone in a paragraph.
+ *
+ * Returns `true` (hidden) when the paste is NOT a single link — e.g. a link
+ * with a custom label, a link accompanied by other text or sibling nodes, or
+ * multiple paragraphs.
+ */
+const notSingleLinkRule = context => isNotSingleLink(context.getPastedSlice());
+
+/**
+ * A rule that hides the paste-menu button when the pasted content IS a single
+ * standalone link (the inverse of `notSingleLinkRule`).
+ *
+ * Use this to suppress buttons (e.g. Improve Writing, Fix Spelling) that
+ * should not appear for single-link pastes.
+ */
+const isSingleLinkRule = context => !isNotSingleLink(context.getPastedSlice());
+
 /**
  * Combines multiple context-aware rules with short-circuit evaluation.
  * Returns `true` (hidden) as soon as the first rule returns `true`; returns
@@ -61,6 +126,12 @@ export const createPasteMenuRuleFactories = getContext => ({
   allRules: (...rules) => bind(getContext, allRules(...rules)),
   containsTableRule: bind(getContext, containsTableRule),
   excludedAncestorRule: excludedNames => bind(getContext, excludedAncestorRule(excludedNames)),
+  hideIfMixedNodesRule: bind(getContext, hideIfMixedNodesRule),
+  hideIfSingleNodeRule: bind(getContext, hideIfSingleNodeRule),
+  isSingleLinkRule: bind(getContext, isSingleLinkRule),
+  maxCharsRule: maxChars => bind(getContext, maxCharsRule(maxChars)),
   minCharsRule: minChars => bind(getContext, minCharsRule(minChars)),
-  notProseRule: bind(getContext, notProseRule)
+  notExternalPasteRule: bind(getContext, notExternalPasteRule),
+  notProseRule: bind(getContext, notProseRule),
+  notSingleLinkRule: bind(getContext, notSingleLinkRule)
 });

package/dist/esm/pasteOptionsToolbarPlugin.js

@@ -22,37 +22,75 @@ export var pasteOptionsToolbarPlugin = function pasteOptionsToolbarPlugin(_ref)
       api: api
     }));
   }
+  if (config !== null && config !== void 0 && config.pasteMenuButtonsFactory && config !== null && config !== void 0 && config.usePopupBasedPasteActionsMenu) {
+    var _api$uiControlRegistr2;
+    var rules = function () {
+      var getContext = function getContext() {
+        var _api$pasteOptionsTool, _api$paste;
+        var pasteOptsState = api === null || api === void 0 || (_api$pasteOptionsTool = api.pasteOptionsToolbarPlugin) === null || _api$pasteOptionsTool === void 0 ? void 0 : _api$pasteOptionsTool.sharedState.currentState();
+        var pasteState = api === null || api === void 0 || (_api$paste = api.paste) === null || _api$paste === void 0 ? void 0 : _api$paste.sharedState.currentState();
+        return {
+          getPlaintextLength: function getPlaintextLength() {
+            var _pasteOptsState$plain;
+            return (_pasteOptsState$plain = pasteOptsState === null || pasteOptsState === void 0 ? void 0 : pasteOptsState.plaintextLength) !== null && _pasteOptsState$plain !== void 0 ? _pasteOptsState$plain : 0;
+          },
+          getAncestorNodeNames: function getAncestorNodeNames() {
+            var _pasteOptsState$paste;
+            return (_pasteOptsState$paste = pasteOptsState === null || pasteOptsState === void 0 ? void 0 : pasteOptsState.pasteAncestorNodeNames) !== null && _pasteOptsState$paste !== void 0 ? _pasteOptsState$paste : [];
+          },
+          getPastedText: function getPastedText() {
+            var _pasteState$lastConte, _pasteState$lastConte2;
+            return (_pasteState$lastConte = pasteState === null || pasteState === void 0 || (_pasteState$lastConte2 = pasteState.lastContentPasted) === null || _pasteState$lastConte2 === void 0 ? void 0 : _pasteState$lastConte2.text) !== null && _pasteState$lastConte !== void 0 ? _pasteState$lastConte : '';
+          },
+          getPastedSlice: function getPastedSlice() {
+            var _pasteState$lastConte3;
+            return pasteState === null || pasteState === void 0 || (_pasteState$lastConte3 = pasteState.lastContentPasted) === null || _pasteState$lastConte3 === void 0 ? void 0 : _pasteState$lastConte3.pastedSlice;
+          },
+          getNodeTypes: function getNodeTypes() {
+            return [];
+          },
+          getPasteSource: function getPasteSource() {
+            var _pasteState$lastConte4;
+            return pasteState === null || pasteState === void 0 || (_pasteState$lastConte4 = pasteState.lastContentPasted) === null || _pasteState$lastConte4 === void 0 ? void 0 : _pasteState$lastConte4.pasteSource;
+          }
+        };
+      };
+      return createPasteMenuRuleFactories(getContext);
+    }();
+    var productButtons = config.pasteMenuButtonsFactory(rules);
+    api === null || api === void 0 || (_api$uiControlRegistr2 = api.uiControlRegistry) === null || _api$uiControlRegistr2 === void 0 || _api$uiControlRegistr2.actions.register(productButtons);
+  }
   return {
     name: 'pasteOptionsToolbarPlugin',
     actions: {
       getPasteMenuRules: function getPasteMenuRules() {
         var getContext = function getContext() {
-          var _api$pasteOptionsTool, _api$paste;
-          var pasteOptsState = api === null || api === void 0 || (_api$pasteOptionsTool = api.pasteOptionsToolbarPlugin) === null || _api$pasteOptionsTool === void 0 ? void 0 : _api$pasteOptionsTool.sharedState.currentState();
-          var pasteState = api === null || api === void 0 || (_api$paste = api.paste) === null || _api$paste === void 0 ? void 0 : _api$paste.sharedState.currentState();
+          var _api$pasteOptionsTool2, _api$paste2;
+          var pasteOptsState = api === null || api === void 0 || (_api$pasteOptionsTool2 = api.pasteOptionsToolbarPlugin) === null || _api$pasteOptionsTool2 === void 0 ? void 0 : _api$pasteOptionsTool2.sharedState.currentState();
+          var pasteState = api === null || api === void 0 || (_api$paste2 = api.paste) === null || _api$paste2 === void 0 ? void 0 : _api$paste2.sharedState.currentState();
           return {
             getPlaintextLength: function getPlaintextLength() {
-              var _pasteOptsState$plain;
-              return (_pasteOptsState$plain = pasteOptsState === null || pasteOptsState === void 0 ? void 0 : pasteOptsState.plaintextLength) !== null && _pasteOptsState$plain !== void 0 ? _pasteOptsState$plain : 0;
+              var _pasteOptsState$plain2;
+              return (_pasteOptsState$plain2 = pasteOptsState === null || pasteOptsState === void 0 ? void 0 : pasteOptsState.plaintextLength) !== null && _pasteOptsState$plain2 !== void 0 ? _pasteOptsState$plain2 : 0;
             },
             getAncestorNodeNames: function getAncestorNodeNames() {
-              var _pasteOptsState$paste;
-              return (_pasteOptsState$paste = pasteOptsState === null || pasteOptsState === void 0 ? void 0 : pasteOptsState.pasteAncestorNodeNames) !== null && _pasteOptsState$paste !== void 0 ? _pasteOptsState$paste : [];
+              var _pasteOptsState$paste2;
+              return (_pasteOptsState$paste2 = pasteOptsState === null || pasteOptsState === void 0 ? void 0 : pasteOptsState.pasteAncestorNodeNames) !== null && _pasteOptsState$paste2 !== void 0 ? _pasteOptsState$paste2 : [];
             },
             getPastedText: function getPastedText() {
-              var _pasteState$lastConte, _pasteState$lastConte2;
-              return (_pasteState$lastConte = pasteState === null || pasteState === void 0 || (_pasteState$lastConte2 = pasteState.lastContentPasted) === null || _pasteState$lastConte2 === void 0 ? void 0 : _pasteState$lastConte2.text) !== null && _pasteState$lastConte !== void 0 ? _pasteState$lastConte : '';
+              var _pasteState$lastConte5, _pasteState$lastConte6;
+              return (_pasteState$lastConte5 = pasteState === null || pasteState === void 0 || (_pasteState$lastConte6 = pasteState.lastContentPasted) === null || _pasteState$lastConte6 === void 0 ? void 0 : _pasteState$lastConte6.text) !== null && _pasteState$lastConte5 !== void 0 ? _pasteState$lastConte5 : '';
             },
             getPastedSlice: function getPastedSlice() {
-              var _pasteState$lastConte3;
-              return pasteState === null || pasteState === void 0 || (_pasteState$lastConte3 = pasteState.lastContentPasted) === null || _pasteState$lastConte3 === void 0 ? void 0 : _pasteState$lastConte3.pastedSlice;
+              var _pasteState$lastConte7;
+              return pasteState === null || pasteState === void 0 || (_pasteState$lastConte7 = pasteState.lastContentPasted) === null || _pasteState$lastConte7 === void 0 ? void 0 : _pasteState$lastConte7.pastedSlice;
             },
             getNodeTypes: function getNodeTypes() {
               return [];
             },
             getPasteSource: function getPasteSource() {
-              var _pasteState$lastConte4;
-              return pasteState === null || pasteState === void 0 || (_pasteState$lastConte4 = pasteState.lastContentPasted) === null || _pasteState$lastConte4 === void 0 ? void 0 : _pasteState$lastConte4.pasteSource;
+              var _pasteState$lastConte8;
+              return pasteState === null || pasteState === void 0 || (_pasteState$lastConte8 = pasteState.lastContentPasted) === null || _pasteState$lastConte8 === void 0 ? void 0 : _pasteState$lastConte8.pasteSource;
             }
           };
         };

package/dist/esm/ui/utils/paste-menu-rules/hasMixedNodes.js

@@ -0,0 +1,70 @@
+/**
+ * Structural container nodes are nodes whose children are determined by
+ * document structure (e.g. list items inside a list, rows inside a table)
+ * rather than by content choice. Having different child types inside these
+ * nodes does NOT indicate mixed content.
+ *
+ * All other container nodes (listItem, blockTaskItem, blockquote, panel,
+ * expand, layoutColumn, tableCell, tableHeader, bodiedExtension, etc.) hold
+ * rich block content, so mixed block children inside them IS mixing.
+ */
+var STRUCTURAL_CONTAINERS = new Set(['bulletList', 'orderedList', 'listItem', 'taskList', 'decisionList', 'table', 'tableRow']);
+
+/**
+ * Returns true if a node's direct block-level children include more than one
+ * distinct node type — i.e. the children are "mixed".
+ */
+var hasBlockSiblings = function hasBlockSiblings(node) {
+  var types = new Set();
+  node.forEach(function (child) {
+    if (child.isBlock) {
+      types.add(child.type.name);
+    }
+  });
+  return types.size > 1;
+};
+
+/**
+ * Returns true if the slice contains sibling block nodes of different types
+ * at the same level anywhere in the document tree.
+ *
+ * Structural container nodes (bulletList, orderedList, taskList, decisionList,
+ * table, tableRow) are excluded from the sibling check because their children
+ * are typed by structure, not content. All other container nodes are checked.
+ */
+export var hasMixedNodes = function hasMixedNodes(slice) {
+  var _slice$content;
+  if (!(slice !== null && slice !== void 0 && (_slice$content = slice.content) !== null && _slice$content !== void 0 && _slice$content.size)) {
+    return false;
+  }
+
+  // Check the top-level children of the slice (Fragment has no parent Node,
+  // so we construct a synthetic check by iterating slice.content directly).
+  var topLevelTypes = new Set();
+  slice.content.forEach(function (node) {
+    if (node.isBlock) {
+      topLevelTypes.add(node.type.name);
+    }
+  });
+  if (topLevelTypes.size > 1) {
+    return true;
+  }
+
+  // Walk every descendant node and check its direct block children for mixing,
+  // skipping structural containers (their children are structural, not content).
+  var mixed = false;
+  slice.content.descendants(function (node) {
+    if (mixed) {
+      return false; // short-circuit once found
+    }
+    if (STRUCTURAL_CONTAINERS.has(node.type.name)) {
+      return true; // recurse into but don't check children for mixing
+    }
+    if (hasBlockSiblings(node)) {
+      mixed = true;
+      return false;
+    }
+    return true;
+  });
+  return mixed;
+};

package/dist/esm/ui/utils/paste-menu-rules/isNotSingleLink.js

@@ -0,0 +1,111 @@
+/**
+ * Returns true if the given text node's sole mark is a `link` mark whose href
+ * matches the node's text content exactly (i.e. the link label IS the URL).
+ */
+var isUrlOnlyLinkTextNode = function isUrlOnlyLinkTextNode(node) {
+  var _node$marks$0$attrs$h, _node$marks$0$attrs;
+  if (!node.isText) {
+    return false;
+  }
+  if (node.marks.length !== 1 || node.marks[0].type.name !== 'link') {
+    return false;
+  }
+  var href = (_node$marks$0$attrs$h = (_node$marks$0$attrs = node.marks[0].attrs) === null || _node$marks$0$attrs === void 0 ? void 0 : _node$marks$0$attrs.href) !== null && _node$marks$0$attrs$h !== void 0 ? _node$marks$0$attrs$h : '';
+  return node.text === href;
+};
+
+/**
+ * Returns true if the slice represents a single inline card (smartlink) node.
+ * Handles two shapes:
+ *  - paragraph > inlineCard  (smartlink from editor/renderer, wrapped in a paragraph)
+ *  - inlineCard              (top-level inlineCard with no paragraph wrapper)
+ */
+var isSingleInlineCard = function isSingleInlineCard(slice) {
+  if (slice.content.childCount !== 1) {
+    return false;
+  }
+  var topNode = slice.content.child(0);
+
+  // Top-level inlineCard (no paragraph wrapper)
+  if (topNode.type.name === 'inlineCard') {
+    return true;
+  }
+
+  // paragraph > inlineCard
+  if (topNode.type.name !== 'paragraph') {
+    return false;
+  }
+  if (topNode.childCount !== 1) {
+    return false;
+  }
+  return topNode.child(0).type.name === 'inlineCard';
+};
+
+/**
+ * Returns the children of a Fragment, filtering out whitespace-only text nodes.
+ * This handles trailing/leading spaces that browsers sometimes include when
+ * copying a link (e.g. `<a href="...">URL</a> `).
+ */
+var significantChildren = function significantChildren(fragment) {
+  var children = [];
+  fragment.forEach(function (child) {
+    var _child$text;
+    if (child.isText && ((_child$text = child.text) === null || _child$text === void 0 ? void 0 : _child$text.trim()) === '') {
+      return;
+    }
+    children.push(child);
+  });
+  return children;
+};
+
+/**
+ * Returns true if the slice represents a single bare link with no label.
+ * Handles two shapes:
+ *  - paragraph > text(link mark)  (standard rich-text paste, wrapped in a paragraph)
+ *  - text(link mark)              (top-level text node with no paragraph wrapper)
+ * Whitespace-only sibling text nodes are ignored in both cases.
+ */
+var isSingleBareLink = function isSingleBareLink(slice) {
+  // Top-level text node with a link mark (no paragraph wrapper)
+  var significantTopChildren = significantChildren(slice.content);
+  if (significantTopChildren.length === 1 && isUrlOnlyLinkTextNode(significantTopChildren[0])) {
+    return true;
+  }
+
+  // paragraph > text(link mark)
+  if (slice.content.childCount !== 1) {
+    return false;
+  }
+  var topNode = slice.content.child(0);
+  if (topNode.type.name !== 'paragraph') {
+    return false;
+  }
+  var children = significantChildren(topNode.content);
+  if (children.length !== 1) {
+    return false;
+  }
+  return isUrlOnlyLinkTextNode(children[0]);
+};
+
+/**
+ * Returns `true` when the pasted content is NOT a single standalone link.
+ *
+ * A paste is considered a "single link" (returns `false`) when:
+ *  - The slice contains exactly one paragraph with one text node whose text
+ *    equals its `link` mark href (bare URL link, no custom label), OR
+ *  - The slice contains exactly one paragraph with a single `inlineCard` node
+ *    (smartlink from the renderer or editor).
+ *
+ * Returns `true` (not a single link) when:
+ *  - The pasted link has a custom label (text ≠ href)
+ *  - There are multiple paragraphs or sibling nodes
+ *  - There is additional text alongside the link in the same paragraph
+ *  - The slice is absent (plain-text paste)
+ */
+export var isNotSingleLink = function isNotSingleLink(slice) {
+  if (!slice || !slice.content.size) {
+    // No rich-text slice → plain text paste, not a single link in the relevant sense
+    return true;
+  }
+  return !isSingleBareLink(slice) && !isSingleInlineCard(slice);
+};

package/dist/esm/ui/utils/paste-menu-rules/rules.js

@@ -1,5 +1,7 @@
+import { hasMixedNodes } from './hasMixedNodes';
 import { hasTableNode } from './hasTableNode';
 import { isNotProse } from './isNotProse';
+import { isNotSingleLink } from './isNotSingleLink';
 /**
  * Returns a rule that hides the paste-menu button when the pasted plain-text
  * is shorter than `minChars` characters.
@@ -10,6 +12,16 @@ var _minCharsRule = function minCharsRule(minChars) {
   };
 };
 
+/**
+ * Returns a rule that hides the paste-menu button when the pasted plain-text
+ * is longer than `maxChars` characters.
+ */
+var _maxCharsRule = function maxCharsRule(maxChars) {
+  return function (context) {
+    return context.getPlaintextLength() > maxChars;
+  };
+};
+
 /**
  * A rule that hides the paste-menu button when the pasted content is plain
  * text (i.e. not rich-text / prose).
@@ -41,6 +53,67 @@ var _excludedAncestorRule = function excludedAncestorRule(excludedNames) {
   };
 };
 
+/**
+ * Returns a rule that hides the paste-menu button when the pasted content contains
+ * more than one node type (e.g. a mix of paragraphs and headings, or a table
+ * with multiple cell types).
+ */
+var hideIfMixedNodesRule = function hideIfMixedNodesRule(context) {
+  var slice = context.getPastedSlice();
+  if (!slice) {
+    return false;
+  }
+  return hasMixedNodes(slice);
+};
+
+/**
+ * Returns a rule that hides the paste-menu button when the pasted content contains
+ * only a single node type (e.g. a single paragraph, or a table with only one cell type).
+ * This is the inverse of `hideIfMixedNodesRule` and can be used in combination with it
+ * to target pastes that contain either exactly one node type or more than one node type.
+ */
+var hideIfSingleNodeRule = function hideIfSingleNodeRule(context) {
+  var slice = context.getPastedSlice();
+  if (!slice) {
+    return false;
+  }
+  return !hasMixedNodes(slice);
+};
+
+/**
+ * A rule that hides the paste-menu button when the paste source is NOT an
+ * external application (i.e. the content was pasted from within the Fabric
+ * editor or renderer rather than from a third-party source).
+ */
+var notExternalPasteRule = function notExternalPasteRule(context) {
+  var source = context.getPasteSource();
+  return source === 'fabric-editor' || source === 'fabric-renderer';
+};
+
+/**
+ * A rule that hides the paste-menu button when the pasted content is a single
+ * standalone link — i.e. a bare URL link (text equals href) alone in a
+ * paragraph, or a single inline card (smartlink) alone in a paragraph.
+ *
+ * Returns `true` (hidden) when the paste is NOT a single link — e.g. a link
+ * with a custom label, a link accompanied by other text or sibling nodes, or
+ * multiple paragraphs.
+ */
+var notSingleLinkRule = function notSingleLinkRule(context) {
+  return isNotSingleLink(context.getPastedSlice());
+};
+
+/**
+ * A rule that hides the paste-menu button when the pasted content IS a single
+ * standalone link (the inverse of `notSingleLinkRule`).
+ *
+ * Use this to suppress buttons (e.g. Improve Writing, Fix Spelling) that
+ * should not appear for single-link pastes.
+ */
+var isSingleLinkRule = function isSingleLinkRule(context) {
+  return !isNotSingleLink(context.getPastedSlice());
+};
+
 /**
  * Combines multiple context-aware rules with short-circuit evaluation.
  * Returns `true` (hidden) as soon as the first rule returns `true`; returns
@@ -88,9 +161,17 @@ export var createPasteMenuRuleFactories = function createPasteMenuRuleFactories(
     excludedAncestorRule: function excludedAncestorRule(excludedNames) {
       return bind(getContext, _excludedAncestorRule(excludedNames));
     },
+    hideIfMixedNodesRule: bind(getContext, hideIfMixedNodesRule),
+    hideIfSingleNodeRule: bind(getContext, hideIfSingleNodeRule),
+    isSingleLinkRule: bind(getContext, isSingleLinkRule),
+    maxCharsRule: function maxCharsRule(maxChars) {
+      return bind(getContext, _maxCharsRule(maxChars));
+    },
     minCharsRule: function minCharsRule(minChars) {
       return bind(getContext, _minCharsRule(minChars));
     },
-    notProseRule: bind(getContext, notProseRule)
+    notExternalPasteRule: bind(getContext, notExternalPasteRule),
+    notProseRule: bind(getContext, notProseRule),
+    notSingleLinkRule: bind(getContext, notSingleLinkRule)
   };
 };

package/dist/types/pasteOptionsToolbarPluginType.d.ts

@@ -2,6 +2,7 @@ import type { NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/t
 import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
 import type { PastePlugin } from '@atlaskit/editor-plugin-paste';
 import type { UiControlRegistryPlugin } from '@atlaskit/editor-plugin-ui-control-registry';
+import type { RegisterComponent } from '@atlaskit/editor-ui-control-model';
 import type { ToolbarDropdownOption } from './types/types';
 import type { PasteMenuRuleFactories } from './ui/utils/paste-menu-rules/types';
 export type PasteOptionsToolbarPluginDependencies = [
@@ -35,6 +36,22 @@ export type PasteOptionsToolbarPlugin = NextEditorPlugin<'pasteOptionsToolbarPlu
     };
     dependencies: PasteOptionsToolbarPluginDependencies;
     pluginConfiguration?: {
+        /**
+         * Optional factory for composing product-specific paste menu buttons.
+         * Called with the pre-bound rule factories so products can compose
+         * `isHidden` callbacks before plugin setup.
+         *
+         * @example
+         * pasteMenuButtonsFactory: (rules) => [
+         *   {
+         *     type: 'menu-item',
+         *     key: 'my-product-button',
+         *     isHidden: rules.allRules(rules.notProseRule, rules.minCharsRule(100)),
+         *     component: () => <MyProductButton />,
+         *   },
+         * ]
+         */
+        pasteMenuButtonsFactory?: (rules: PasteMenuRuleFactories) => RegisterComponent[];
         usePopupBasedPasteActionsMenu?: boolean;
     };
     sharedState: PasteOptionsToolbarSharedState;

package/dist/types/ui/utils/paste-menu-rules/hasMixedNodes.d.ts

@@ -0,0 +1,10 @@
+import type { Slice } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Returns true if the slice contains sibling block nodes of different types
+ * at the same level anywhere in the document tree.
+ *
+ * Structural container nodes (bulletList, orderedList, taskList, decisionList,
+ * table, tableRow) are excluded from the sibling check because their children
+ * are typed by structure, not content. All other container nodes are checked.
+ */
+export declare const hasMixedNodes: (slice: Slice | undefined) => boolean;

package/dist/types/ui/utils/paste-menu-rules/isNotSingleLink.d.ts

@@ -0,0 +1,17 @@
+import type { Slice } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Returns `true` when the pasted content is NOT a single standalone link.
+ *
+ * A paste is considered a "single link" (returns `false`) when:
+ *  - The slice contains exactly one paragraph with one text node whose text
+ *    equals its `link` mark href (bare URL link, no custom label), OR
+ *  - The slice contains exactly one paragraph with a single `inlineCard` node
+ *    (smartlink from the renderer or editor).
+ *
+ * Returns `true` (not a single link) when:
+ *  - The pasted link has a custom label (text ≠ href)
+ *  - There are multiple paragraphs or sibling nodes
+ *  - There is additional text alongside the link in the same paragraph
+ *  - The slice is absent (plain-text paste)
+ */
+export declare const isNotSingleLink: (slice: Slice | undefined) => boolean;