@atlaskit/editor-plugin-block-controls 20.1.3 → 20.1.4

package/dist/esm/ui/block-controls-right-surfaces.js

@@ -15,14 +15,13 @@ import { BLOCK_CONTROLS_RIGHT_SURFACE } from '@atlaskit/editor-common/block-cont
 import { useSharedPluginStateWithSelector } from '@atlaskit/editor-common/hooks';
 import { isCSSAnchorSupported } from '@atlaskit/editor-common/styles';
 import { createSurfaceContext } from '@atlaskit/editor-ui-control-model/create-surface-context';
-import { willSurfaceRender } from '@atlaskit/editor-ui-control-model/surface-renderer';
 import { getNodeTypeWithLevel } from '../pm-plugins/decorations-common';
 import { BlockControlsRightSurface } from './block-controls-right-surface';
+import { getBlockControlsRightSurfaceComponents } from './block-controls-surface-components';
 import { createBlockControlsSurfaceContextForPosition } from './block-controls-surface-context';
 import { getBlockControlsSurfaceTargets } from './block-controls-surface-targets';
 import { getNodeContentElement } from './utils/get-node-content-element';
 import { getAbsoluteSurfacePlacement, getAnchoredSurfacePlacement, getSurfacePlacement, toMeasuredSurfaceWrapperPlacement } from './utils/get-surface-placement';
-import { hasSurfaceControls } from './utils/has-surface-controls';
 var EMPTY_SURFACE_POSITIONS = [];
 var EMPTY_SURFACE_ANCHORS = new Map();
 var EMPTY_SURFACE_COMPONENTS = [];
@@ -69,7 +68,8 @@ export var BlockControlsRightSurfaces = function BlockControlsRightSurfaces(_ref
         return [];
       }
       var surfaceContext = createSurfaceContext(BLOCK_CONTROL_UI_CONTEXT, context);
-      if (!hasSurfaceControls(components) || !willSurfaceRender(components, BLOCK_CONTROLS_RIGHT_SURFACE, surfaceContext)) {
+      var surfaceComponents = getBlockControlsRightSurfaceComponents(components, surfaceContext);
+      if (!surfaceComponents) {
         return [];
       }
       // The cache supplies the same anchor names used by ProseMirror decorations.
@@ -77,6 +77,7 @@ export var BlockControlsRightSurfaces = function BlockControlsRightSurfaces(_ref
       return [_objectSpread(_objectSpread({}, target), {}, {
         anchorName: anchorName,
         blockControlsContext: context,
+        surfaceComponents: surfaceComponents,
         surfaceContext: surfaceContext
       })];
     });
@@ -260,10 +261,11 @@ export var BlockControlsRightSurfaces = function BlockControlsRightSurfaces(_ref
     var _activeNode$handleOpt, _anchoredPlacements$g;
     var position = _ref6.position,
       source = _ref6.source,
+      surfaceComponents = _ref6.surfaceComponents,
       surfaceContext = _ref6.surfaceContext;
     return /*#__PURE__*/React.createElement(BlockControlsRightSurface, {
       api: api,
-      components: components,
+      components: surfaceComponents,
       forceVisibleOnMouseOut: Boolean(activeNode === null || activeNode === void 0 || (_activeNode$handleOpt = activeNode.handleOptions) === null || _activeNode$handleOpt === void 0 ? void 0 : _activeNode$handleOpt.isFocused),
       key: position,
       placement: (_anchoredPlacements$g = anchoredPlacements.get(position)) !== null && _anchoredPlacements$g !== void 0 ? _anchoredPlacements$g : placements.get(position),

package/dist/esm/ui/block-controls-surface-components.js

@@ -0,0 +1,133 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["isHidden"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import React, { createContext, useContext, useMemo } from 'react';
+import { BLOCK_CONTROLS_LEFT_GROUP, BLOCK_CONTROLS_LEFT_SECTION, BLOCK_CONTROLS_LEFT_SURFACE, BLOCK_CONTROLS_RIGHT_GROUP, BLOCK_CONTROLS_RIGHT_SECTION, BLOCK_CONTROLS_RIGHT_SURFACE } from '@atlaskit/editor-common/block-controls/surface-keys';
+import { getComponentIdentity, resolveSurface } from '@atlaskit/editor-ui-control-model/surface-renderer';
+import { partitionComponentsByPersistence } from './utils/partition-components-by-persistence';
+import { VisibilityWrapper } from './visibility-container';
+var BlockControlsVisibilityContext = /*#__PURE__*/createContext({
+  shouldHideHoverControls: false,
+  useCssStyles: false
+});
+var BlockControlItem = function BlockControlItem(_ref) {
+  var children = _ref.children;
+  return /*#__PURE__*/React.createElement("div", {
+    "data-editor-block-control-item": true
+  }, children);
+};
+var HoverBlockControlItem = function HoverBlockControlItem(_ref2) {
+  var children = _ref2.children;
+  var _useContext = useContext(BlockControlsVisibilityContext),
+    shouldHideHoverControls = _useContext.shouldHideHoverControls,
+    useCssStyles = _useContext.useCssStyles;
+  return /*#__PURE__*/React.createElement(BlockControlItem, null, /*#__PURE__*/React.createElement(VisibilityWrapper, {
+    shouldHide: shouldHideHoverControls,
+    useCssStyles: useCssStyles
+  }, children));
+};
+var PersistentBlockControlItem = function PersistentBlockControlItem(_ref3) {
+  var children = _ref3.children;
+  var _useContext2 = useContext(BlockControlsVisibilityContext),
+    useCssStyles = _useContext2.useCssStyles;
+  return /*#__PURE__*/React.createElement(BlockControlItem, null, /*#__PURE__*/React.createElement(VisibilityWrapper, {
+    shouldHide: false,
+    useCssStyles: useCssStyles
+  }, children));
+};
+export var BlockControlsVisibilityProvider = function BlockControlsVisibilityProvider(_ref4) {
+  var children = _ref4.children,
+    shouldHideHoverControls = _ref4.shouldHideHoverControls,
+    useCssStyles = _ref4.useCssStyles;
+  var value = useMemo(function () {
+    return {
+      shouldHideHoverControls: shouldHideHoverControls,
+      useCssStyles: useCssStyles
+    };
+  }, [shouldHideHoverControls, useCssStyles]);
+  return /*#__PURE__*/React.createElement(BlockControlsVisibilityContext.Provider, {
+    value: value
+  }, children);
+};
+var withoutVisibilityPredicate = function withoutVisibilityPredicate(component) {
+  var _isHidden = component.isHidden,
+    visibleComponent = _objectWithoutProperties(component, _excluded);
+  return visibleComponent;
+};
+
+/**
+ * Replaces the shared surface group with one stable wrapper group per visible control. The wrappers
+ * inherit each control's rank, so SurfaceRenderer keeps the registry order without re-evaluating
+ * the controls' visibility predicates.
+ */
+var getBlockControlsSurfaceComponents = function getBlockControlsSurfaceComponents(components, _ref5, surfaceContext) {
+  var _resolvedSurface$chil;
+  var group = _ref5.group,
+    section = _ref5.section,
+    surface = _ref5.surface;
+  var resolvedSurface = resolveSurface(components, surface);
+  var groupIdentity = getComponentIdentity(group);
+  var controls = (_resolvedSurface$chil = resolvedSurface.childrenMap.get(groupIdentity)) !== null && _resolvedSurface$chil !== void 0 ? _resolvedSurface$chil : [];
+  var visibleControls = controls.filter(function (control) {
+    var _control$isHidden, _control$isHidden2;
+    return !((_control$isHidden = (_control$isHidden2 = control.isHidden) === null || _control$isHidden2 === void 0 ? void 0 : _control$isHidden2.call(control, {
+      surfaceContext: surfaceContext
+    })) !== null && _control$isHidden !== void 0 ? _control$isHidden : false);
+  });
+  if (!resolvedSurface.root || visibleControls.length === 0) {
+    return undefined;
+  }
+  var controlIdentities = new Set(controls.map(getComponentIdentity));
+  var visibleControlIdentities = new Set(visibleControls.map(getComponentIdentity));
+  var _partitionComponentsB = partitionComponentsByPersistence(resolvedSurface.components.filter(function (component) {
+      var identity = getComponentIdentity(component);
+      return !controlIdentities.has(identity) || visibleControlIdentities.has(identity);
+    }), surface, surfaceContext),
+    persistentComponents = _partitionComponentsB.persistentComponents;
+  var persistentIdentities = new Set(persistentComponents.map(getComponentIdentity));
+  var structuralComponents = resolvedSurface.components.filter(function (component) {
+    var identity = getComponentIdentity(component);
+    return identity !== groupIdentity && !controlIdentities.has(identity);
+  }).map(withoutVisibilityPredicate);
+  var wrappedControls = visibleControls.flatMap(function (control) {
+    var _control$parents$find, _control$parents;
+    var identity = getComponentIdentity(control);
+    var rank = (_control$parents$find = (_control$parents = control.parents) === null || _control$parents === void 0 || (_control$parents = _control$parents.find(function (parent) {
+      return getComponentIdentity(parent) === groupIdentity;
+    })) === null || _control$parents === void 0 ? void 0 : _control$parents.rank) !== null && _control$parents$find !== void 0 ? _control$parents$find : 0;
+    var wrapper = {
+      component: persistentIdentities.has(identity) ? PersistentBlockControlItem : HoverBlockControlItem,
+      key: "block-control-item:".concat(identity),
+      parents: [_objectSpread(_objectSpread({}, section), {}, {
+        rank: rank
+      })],
+      type: 'group'
+    };
+    var visibleControl = _objectSpread(_objectSpread({}, withoutVisibilityPredicate(control)), {}, {
+      parents: [{
+        key: wrapper.key,
+        rank: 0,
+        type: wrapper.type
+      }]
+    });
+    return [wrapper, visibleControl];
+  });
+  return [].concat(_toConsumableArray(structuralComponents), _toConsumableArray(wrappedControls));
+};
+export var getBlockControlsLeftSurfaceComponents = function getBlockControlsLeftSurfaceComponents(components, surfaceContext) {
+  return getBlockControlsSurfaceComponents(components, {
+    group: BLOCK_CONTROLS_LEFT_GROUP,
+    section: BLOCK_CONTROLS_LEFT_SECTION,
+    surface: BLOCK_CONTROLS_LEFT_SURFACE
+  }, surfaceContext);
+};
+export var getBlockControlsRightSurfaceComponents = function getBlockControlsRightSurfaceComponents(components, surfaceContext) {
+  return getBlockControlsSurfaceComponents(components, {
+    group: BLOCK_CONTROLS_RIGHT_GROUP,
+    section: BLOCK_CONTROLS_RIGHT_SECTION,
+    surface: BLOCK_CONTROLS_RIGHT_SURFACE
+  }, surfaceContext);
+};

package/dist/esm/ui/utils/get-surface-placement.js

@@ -1,4 +1,6 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var _excluded = ["leftGutterBoundary"];
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import { shouldBeSticky } from '../../pm-plugins/utils/drag-handle-positions';
@@ -43,18 +45,40 @@ export var getSurfacePlacement = function getSurfacePlacement(_ref2) {
   var gap = dragHandleGap(nodeType, parentNodeType);
   var top = nodeRect.top + topPositionAdjustment(nodeTypeWithLevel, layout);
   var height = shouldBeSticky(nodeType) ? nodeRect.height : undefined;
-  return side === 'right' ? {
-    left: nodeRect.right + gap,
-    top: top,
-    transform: '',
-    height: height
-  } : {
+  if (side === 'right') {
+    return {
+      left: nodeRect.right + gap,
+      top: top,
+      transform: '',
+      height: height
+    };
+  }
+  return {
     left: nodeRect.left,
     top: top,
     transform: "translateX(calc(-100% - ".concat(gap, "px))"),
     height: height
   };
 };
+/**
+ * Expands a measured left surface from the available gutter boundary to the target node.
+ */
+export var getLeftGutterSurfacePlacement = function getLeftGutterSurfacePlacement(_ref3) {
+  var leftGutterBoundary = _ref3.leftGutterBoundary,
+    options = _objectWithoutProperties(_ref3, _excluded);
+  var placement = getSurfacePlacement(_objectSpread(_objectSpread({}, options), {}, {
+    side: 'left'
+  }));
+  if (options.nodeType === 'layoutColumn') {
+    return placement;
+  }
+  var gap = dragHandleGap(options.nodeType, options.parentNodeType);
+  return _objectSpread(_objectSpread({}, placement), {}, {
+    left: leftGutterBoundary,
+    transform: '',
+    width: Math.max(0, options.nodeRect.left - leftGutterBoundary - gap)
+  });
+};
 
 /**
  * The insets to apply to a surface wrapper, plus whether that wrapper spans its target node.
@@ -75,12 +99,14 @@ export var getSurfacePlacement = function getSurfacePlacement(_ref2) {
 export var toMeasuredSurfaceWrapperPlacement = function toMeasuredSurfaceWrapperPlacement(placement) {
   return {
     isSticky: placement.height !== undefined,
-    style: {
+    style: _objectSpread({
       height: placement.height,
       left: placement.left,
       top: placement.top,
       transform: placement.transform
-    }
+    }, placement.width !== undefined ? {
+      width: placement.width
+    } : {})
   };
 };
 
@@ -96,13 +122,13 @@ export var toMeasuredSurfaceWrapperPlacement = function toMeasuredSurfaceWrapper
 var INVALID_ANCHOR_OFFSCREEN_PX = 9999;
 var INVALID_ANCHOR_FALLBACK_TOP = "-".concat(INVALID_ANCHOR_OFFSCREEN_PX, "px");
 var INVALID_ANCHOR_FALLBACK_BOTTOM = "".concat(INVALID_ANCHOR_OFFSCREEN_PX, "px");
-export var getAnchoredSurfacePlacement = function getAnchoredSurfacePlacement(_ref3) {
-  var anchorName = _ref3.anchorName,
-    layout = _ref3.layout,
-    nodeType = _ref3.nodeType,
-    nodeTypeWithLevel = _ref3.nodeTypeWithLevel,
-    parentNodeType = _ref3.parentNodeType,
-    side = _ref3.side;
+export var getAnchoredSurfacePlacement = function getAnchoredSurfacePlacement(_ref4) {
+  var anchorName = _ref4.anchorName,
+    layout = _ref4.layout,
+    nodeType = _ref4.nodeType,
+    nodeTypeWithLevel = _ref4.nodeTypeWithLevel,
+    parentNodeType = _ref4.parentNodeType,
+    side = _ref4.side;
   if (nodeType === 'layoutColumn') {
     // The column's horizontal midpoint, matching the measured `nodeRect.left + width / 2` and the
     // legacy drag handle's own layout-column formula. Side-independent.
@@ -132,4 +158,25 @@ export var getAnchoredSurfacePlacement = function getAnchoredSurfacePlacement(_r
       transform: side === 'right' ? '' : "translateX(calc(-100% - ".concat(gap, "px))")
     })
   };
+};
+/**
+ * Expands an anchored left surface across the available gutter without runtime measurement.
+ */
+export var getAnchoredLeftGutterSurfacePlacement = function getAnchoredLeftGutterSurfacePlacement(options) {
+  var placement = getAnchoredSurfacePlacement(_objectSpread(_objectSpread({}, options), {}, {
+    side: 'left'
+  }));
+  if (options.nodeType === 'layoutColumn') {
+    return placement;
+  }
+  var gap = dragHandleGap(options.nodeType, options.parentNodeType);
+  return _objectSpread(_objectSpread({}, placement), {}, {
+    style: _objectSpread(_objectSpread({}, placement.style), {}, {
+      left: 0,
+      // In a `right` inset, `anchor(... left)` resolves from the containing block's right edge
+      // to the anchor's left edge. Adding the gap ends this wrapper just before the node.
+      right: "calc(anchor(".concat(options.anchorName, " left) + ").concat(gap, "px)"),
+      transform: ''
+    })
+  });
 };

package/dist/esm/ui/visibility-container.js

@@ -46,13 +46,16 @@ var hiddenStylesCSS = css({
 var displayContentsStylesCSS = css({
   display: 'contents'
 });
-export var VisibilityContainer = function VisibilityContainer(_ref) {
+
+/**
+ * Resolves visibility once so a surface can apply the same state to each rendered control without
+ * creating a plugin-state subscription and hide-delay timer for every control wrapper.
+ */
+export var useBlockControlsVisibility = function useBlockControlsVisibility(_ref) {
   var api = _ref.api,
-    children = _ref.children,
     controlSide = _ref.controlSide,
     forceVisibleOnMouseOut = _ref.forceVisibleOnMouseOut,
-    isPersistent = _ref.isPersistent,
-    shouldUseDisplayContents = _ref.shouldUseDisplayContents;
+    isPersistent = _ref.isPersistent;
   var _useSharedPluginState = useSharedPluginStateWithSelector(api, ['typeAhead', 'blockControls', 'editorViewMode', 'userIntent', 'showDiff'], function (states) {
       var _states$typeAheadStat, _states$blockControls, _states$blockControls2, _states$blockControls3, _states$editorViewMod, _states$userIntentSta, _states$showDiffState, _states$blockControls4;
       return {
@@ -128,9 +131,20 @@ export var VisibilityContainer = function VisibilityContainer(_ref) {
     };
   }, [shouldHideImmediate, isRightControlViewMode]);
   var shouldHide = isRightControlViewMode ? delayedShouldHide : shouldHideImmediate;
-  if (editorExperiment('platform_editor_preview_panel_responsiveness', true, {
+  var useCssStyles = editorExperiment('platform_editor_preview_panel_responsiveness', true, {
     exposure: true
-  })) {
+  });
+  return {
+    shouldHide: shouldHide,
+    useCssStyles: useCssStyles
+  };
+};
+export var VisibilityWrapper = function VisibilityWrapper(_ref2) {
+  var children = _ref2.children,
+    shouldHide = _ref2.shouldHide,
+    shouldUseDisplayContents = _ref2.shouldUseDisplayContents,
+    useCssStyles = _ref2.useCssStyles;
+  if (useCssStyles) {
     return jsx("div", {
       css: [baseStylesCSS, shouldHide ? hiddenStylesCSS : visibleStylesCSS, shouldUseDisplayContents && displayContentsStylesCSS]
     }, children);
@@ -140,4 +154,25 @@ export var VisibilityContainer = function VisibilityContainer(_ref) {
   , {
     xcss: [baseStyles, shouldHide ? hiddenStyles : visibleStyles, shouldUseDisplayContents && displayContentsStyles]
   }, children);
+};
+export var VisibilityContainer = function VisibilityContainer(_ref3) {
+  var api = _ref3.api,
+    children = _ref3.children,
+    controlSide = _ref3.controlSide,
+    forceVisibleOnMouseOut = _ref3.forceVisibleOnMouseOut,
+    isPersistent = _ref3.isPersistent,
+    shouldUseDisplayContents = _ref3.shouldUseDisplayContents;
+  var _useBlockControlsVisi = useBlockControlsVisibility({
+      api: api,
+      controlSide: controlSide,
+      forceVisibleOnMouseOut: forceVisibleOnMouseOut,
+      isPersistent: isPersistent
+    }),
+    shouldHide = _useBlockControlsVisi.shouldHide,
+    useCssStyles = _useBlockControlsVisi.useCssStyles;
+  return jsx(VisibilityWrapper, {
+    shouldHide: shouldHide,
+    shouldUseDisplayContents: shouldUseDisplayContents,
+    useCssStyles: useCssStyles
+  }, children);
 };

package/dist/types/ui/block-controls-surface-components.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { RegisterComponent, SurfaceContext } from '@atlaskit/editor-ui-control-model/types';
+type BlockControlsVisibility = {
+    shouldHideHoverControls: boolean;
+    useCssStyles: boolean;
+};
+type BlockControlsVisibilityProviderProps = BlockControlsVisibility & {
+    children: React.ReactNode;
+};
+export declare const BlockControlsVisibilityProvider: ({ children, shouldHideHoverControls, useCssStyles, }: BlockControlsVisibilityProviderProps) => React.JSX.Element;
+export declare const getBlockControlsLeftSurfaceComponents: (components: RegisterComponent[], surfaceContext: SurfaceContext) => RegisterComponent[] | undefined;
+export declare const getBlockControlsRightSurfaceComponents: (components: RegisterComponent[], surfaceContext: SurfaceContext) => RegisterComponent[] | undefined;
+export {};

package/dist/types/ui/utils/get-surface-placement.d.ts

@@ -10,6 +10,7 @@ export type SurfacePlacement = {
     left: number;
     top: number;
     transform: string;
+    width?: number;
 };
 export type SurfaceSide = 'left' | 'right';
 export type SurfacePlacementOptions = {
@@ -37,6 +38,13 @@ export declare const getAbsoluteSurfacePlacement: ({ offsetParentRect, offsetPar
  * can be folded straight into `left` with no transform needed.
  */
 export declare const getSurfacePlacement: ({ layout, nodeRect, nodeType, nodeTypeWithLevel, parentNodeType, side, }: SurfacePlacementOptions) => SurfacePlacement;
+export type LeftGutterSurfacePlacementOptions = Omit<SurfacePlacementOptions, 'side'> & {
+    leftGutterBoundary: number;
+};
+/**
+ * Expands a measured left surface from the available gutter boundary to the target node.
+ */
+export declare const getLeftGutterSurfacePlacement: ({ leftGutterBoundary, ...options }: LeftGutterSurfacePlacementOptions) => SurfacePlacement;
 /**
  * The insets to apply to a surface wrapper, plus whether that wrapper spans its target node.
  *
@@ -67,3 +75,8 @@ export type AnchoredSurfacePlacementOptions = {
     side: SurfaceSide;
 };
 export declare const getAnchoredSurfacePlacement: ({ anchorName, layout, nodeType, nodeTypeWithLevel, parentNodeType, side, }: AnchoredSurfacePlacementOptions) => SurfaceWrapperPlacement;
+export type AnchoredLeftGutterSurfacePlacementOptions = Omit<AnchoredSurfacePlacementOptions, 'side'>;
+/**
+ * Expands an anchored left surface across the available gutter without runtime measurement.
+ */
+export declare const getAnchoredLeftGutterSurfacePlacement: (options: AnchoredLeftGutterSurfacePlacementOptions) => SurfaceWrapperPlacement;

package/dist/types/ui/visibility-container.d.ts

@@ -17,5 +17,19 @@ interface VisibilityContainerProps {
      */
     shouldUseDisplayContents?: boolean;
 }
+type VisibilityWrapperProps = Pick<VisibilityContainerProps, 'children' | 'shouldUseDisplayContents'> & {
+    shouldHide: boolean;
+    useCssStyles: boolean;
+};
+type BlockControlsVisibilityOptions = Omit<VisibilityContainerProps, 'children' | 'shouldUseDisplayContents'>;
+/**
+ * Resolves visibility once so a surface can apply the same state to each rendered control without
+ * creating a plugin-state subscription and hide-delay timer for every control wrapper.
+ */
+export declare const useBlockControlsVisibility: ({ api, controlSide, forceVisibleOnMouseOut, isPersistent, }: BlockControlsVisibilityOptions) => {
+    shouldHide: boolean;
+    useCssStyles: boolean;
+};
+export declare const VisibilityWrapper: ({ children, shouldHide, shouldUseDisplayContents, useCssStyles, }: VisibilityWrapperProps) => jsx.JSX.Element;
 export declare const VisibilityContainer: ({ api, children, controlSide, forceVisibleOnMouseOut, isPersistent, shouldUseDisplayContents, }: VisibilityContainerProps) => jsx.JSX.Element;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-block-controls",
-	"version": "20.1.3",
+	"version": "20.1.4",
 	"description": "Block controls plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -61,7 +61,7 @@
 		"@atlaskit/primitives": "^22.5.0",
 		"@atlaskit/section-message": "^10.2.0",
 		"@atlaskit/theme": "^28.2.0",
-		"@atlaskit/tmp-editor-statsig": "^203.0.0",
+		"@atlaskit/tmp-editor-statsig": "^204.0.0",
 		"@atlaskit/tokens": "^19.0.0",
 		"@atlaskit/tooltip": "^24.3.0",
 		"@babel/runtime": "^7.0.0",