@elastic/eui 68.0.0 → 70.0.0

package/lib/components/code/code_block.js

@@ -11,31 +11,21 @@ var _propTypes = _interopRequireDefault(require("prop-types"));
 
 var _classnames = _interopRequireDefault(require("classnames"));
 
-var _reactWindow = require("react-window");
-
 var _services = require("../../services");
 
-var _auto_sizer = require("../auto_sizer");
-
-var _button = require("../button");
-
-var _common = require("../common");
-
-var _copy = require("../copy");
-
-var _focus_trap = require("../focus_trap");
+var _utils = require("./utils");
 
-var _i18n = require("../i18n");
+var _code_block_overflow = require("./code_block_overflow");
 
-var _inner_text = require("../inner_text");
+var _code_block_copy = require("./code_block_copy");
 
-var _mutation_observer = require("../observer/mutation_observer");
+var _code_block_full_screen = require("./code_block_full_screen");
 
-var _resize_observer = require("../observer/resize_observer");
+var _code_block_controls = require("./code_block_controls");
 
-var _overlay_mask = require("../overlay_mask");
+var _code_block_virtualized = require("./code_block_virtualized");
 
-var _utils = require("./utils");
+var _code_block = require("./code_block.styles");
 
 var _react2 = require("@emotion/react");
 
@@ -79,21 +69,9 @@ var fontSizeToRowHeightMap = {
   m: 21,
   l: 24
 };
-var fontSizeToClassNameMap = {
-  s: 'euiCodeBlock--fontSmall',
-  m: 'euiCodeBlock--fontMedium',
-  l: 'euiCodeBlock--fontLarge'
-};
-var FONT_SIZES = (0, _common.keysOf)(fontSizeToClassNameMap);
+var FONT_SIZES = ['s', 'm', 'l'];
 exports.FONT_SIZES = FONT_SIZES;
-var paddingSizeToClassNameMap = {
-  none: '',
-  s: 'euiCodeBlock--paddingSmall',
-  m: 'euiCodeBlock--paddingMedium',
-  l: 'euiCodeBlock--paddingLarge'
-};
-var PADDING_SIZES = (0, _common.keysOf)(paddingSizeToClassNameMap); // This exclusive union enforces specific props based on isVirtualized
-
+var PADDING_SIZES = ['none', 's', 'm', 'l'];
 exports.PADDING_SIZES = PADDING_SIZES;
 
 var EuiCodeBlock = function EuiCodeBlock(_ref) {
@@ -117,6 +95,7 @@ var EuiCodeBlock = function EuiCodeBlock(_ref) {
       lineNumbers = _ref$lineNumbers === void 0 ? false : _ref$lineNumbers,
       rest = _objectWithoutProperties(_ref, _excluded);
 
+  var euiTheme = (0, _services.useEuiTheme)();
   var language = (0, _react.useMemo)(function () {
     return (0, _utils.checkSupportedLanguage)(_language);
   }, [_language]);
@@ -136,8 +115,8 @@ var EuiCodeBlock = function EuiCodeBlock(_ref) {
       return [];
     }
 
-    return (0, _utils.highlightByLine)(children, language, lineNumbersConfig);
-  }, [children, language, lineNumbersConfig]); // Used by `pre` when `isVirtualized=false` or `children` is not parsable
+    return (0, _utils.highlightByLine)(children, language, lineNumbersConfig, euiTheme);
+  }, [children, language, lineNumbersConfig, euiTheme]); // Used by `pre` when `isVirtualized=false` or `children` is not parsable
 
   var content = (0, _react.useMemo)(function () {
     return (0, _utils.getHtmlContent)(data, children);
@@ -146,112 +125,92 @@ var EuiCodeBlock = function EuiCodeBlock(_ref) {
     return !!(_isVirtualized && Array.isArray(data));
   }, [_isVirtualized, data]);
 
-  var _useCopy = useCopy({
+  var _useCopy = (0, _code_block_copy.useCopy)({
     isCopyable: isCopyable,
     isVirtualized: isVirtualized,
     children: children
   }),
       innerTextRef = _useCopy.innerTextRef,
-      showCopyButton = _useCopy.showCopyButton,
-      textToCopy = _useCopy.textToCopy;
+      copyButton = _useCopy.copyButton;
 
-  var _useOverflowDetection = useOverflowDetection(),
-      setWrapperRef = _useOverflowDetection.setWrapperRef,
-      tabIndex = _useOverflowDetection.tabIndex;
+  var _useOverflow = (0, _code_block_overflow.useOverflow)({
+    overflowHeight: overflowHeight
+  }),
+      setWrapperRef = _useOverflow.setWrapperRef,
+      tabIndex = _useOverflow.tabIndex,
+      overflowHeightStyles = _useOverflow.overflowHeightStyles;
 
   var combinedRef = (0, _services.useCombinedRefs)([innerTextRef, setWrapperRef]);
 
-  var _useFullScreen = useFullScreen({
+  var _useFullScreen = (0, _code_block_full_screen.useFullScreen)({
     overflowHeight: overflowHeight
   }),
-      showFullScreenButton = _useFullScreen.showFullScreenButton,
-      onKeyDown = _useFullScreen.onKeyDown,
+      fullScreenButton = _useFullScreen.fullScreenButton,
       isFullScreen = _useFullScreen.isFullScreen,
-      toggleFullScreen = _useFullScreen.toggleFullScreen; // Classes used in both fullscreen and non-fullscreen mode
-
-
-  var wrapperClasses = (0, _classnames.default)(className, 'euiCodeBlock', {
-    'euiCodeBlock--hasControl': showCopyButton || showFullScreenButton,
-    'euiCodeBlock--hasBothControls': showCopyButton && showFullScreenButton,
-    'euiCodeBlock--hasLineNumbers': lineNumbersConfig.show
-  }); // Classes used in non-fullscreen mode only
+      onKeyDown = _useFullScreen.onKeyDown;
+
+  var hasControls = !!(copyButton || fullScreenButton);
+  var hasBothControls = !!(copyButton && fullScreenButton);
+  var styles = (0, _code_block.euiCodeBlockStyles)(euiTheme);
+  var cssStyles = [styles.euiCodeBlock, styles[fontSize], transparentBackground && styles.transparentBackground, hasControls && (hasBothControls ? styles.hasBothControls[paddingSize] : styles.hasControls[paddingSize])];
+
+  var _useMemo = (0, _react.useMemo)(function () {
+    var isWhiteSpacePre = whiteSpace === 'pre' || isVirtualized;
+    var styles = (0, _code_block.euiCodeBlockPreStyles)(euiTheme);
+    var cssStyles = [styles.euiCodeBlock__pre, isWhiteSpacePre ? styles.whiteSpace.pre.pre : styles.whiteSpace.preWrap.preWrap];
+    var preProps = {
+      className: 'euiCodeBlock__pre',
+      css: [].concat(cssStyles, [styles.padding[paddingSize], hasControls && (isWhiteSpacePre ? styles.whiteSpace.pre.controlsOffset[paddingSize] : styles.whiteSpace.preWrap.controlsOffset[paddingSize])]),
+      tabIndex: isVirtualized ? 0 : tabIndex
+    };
+    var preFullscreenProps = {
+      className: 'euiCodeBlock__pre',
+      css: [].concat(cssStyles, [// Force fullscreen to use xl padding
+      styles.padding.xl, hasControls && (isWhiteSpacePre ? styles.whiteSpace.pre.controlsOffset.xl : styles.whiteSpace.preWrap.controlsOffset.xl)]),
+      tabIndex: 0,
+      onKeyDown: onKeyDown
+    };
+    return [preProps, preFullscreenProps];
+  }, [euiTheme, whiteSpace, isVirtualized, hasControls, paddingSize, onKeyDown, tabIndex]),
+      _useMemo2 = _slicedToArray(_useMemo, 2),
+      preProps = _useMemo2[0],
+      preFullscreenProps = _useMemo2[1];
 
-  var classes = (0, _classnames.default)(wrapperClasses, fontSizeToClassNameMap[fontSize], paddingSizeToClassNameMap[paddingSize], {
-    'euiCodeBlock--transparentBackground': transparentBackground
-  });
   var codeProps = (0, _react.useMemo)(function () {
+    var styles = (0, _code_block.euiCodeBlockCodeStyles)(euiTheme);
+    var cssStyles = [styles.euiCodeBlock__code, isVirtualized && styles.isVirtualized];
     return _objectSpread({
       className: 'euiCodeBlock__code',
+      css: cssStyles,
       'data-code-language': language
     }, rest);
-  }, [language, rest]);
-  var preClasses = (0, _classnames.default)('euiCodeBlock__pre', {
-    'euiCodeBlock__pre--whiteSpacePre': whiteSpace === 'pre' || isVirtualized,
-    'euiCodeBlock__pre--whiteSpacePreWrap': whiteSpace === 'pre-wrap' && !isVirtualized,
-    'euiCodeBlock__pre--isVirtualized': isVirtualized
-  });
-  var preFullscreenProps = (0, _react.useMemo)(function () {
-    return {
-      className: preClasses,
-      tabIndex: 0,
-      onKeyDown: onKeyDown
-    };
-  }, [preClasses, onKeyDown]);
-  var overflowHeightStyles = (0, _react.useMemo)(function () {
-    if (overflowHeight) {
-      var property = typeof overflowHeight === 'string' ? 'height' : 'maxHeight';
-      return _defineProperty({}, property, overflowHeight);
-    }
-
-    return {};
-  }, [overflowHeight]);
-  var wrapperProps = (0, _react.useMemo)(function () {
-    return {
-      className: classes,
-      style: overflowHeightStyles
-    };
-  }, [classes, overflowHeightStyles]);
-  var codeBlockControls = (0, _react.useMemo)(function () {
-    if (showCopyButton || showFullScreenButton) {
-      return (0, _react2.jsx)("div", {
-        className: "euiCodeBlock__controls"
-      }, showFullScreenButton && (0, _react2.jsx)(FullScreenButton, {
-        isFullScreen: isFullScreen,
-        toggleFullScreen: toggleFullScreen
-      }), showCopyButton && (0, _react2.jsx)(CopyButton, {
-        textToCopy: textToCopy
-      }));
-    }
-  }, [isFullScreen, toggleFullScreen, showCopyButton, showFullScreenButton, textToCopy]);
-  return (0, _react2.jsx)("div", wrapperProps, isVirtualized ? (0, _react2.jsx)(VirtualizedCodeBlock, {
+  }, [language, euiTheme, isVirtualized, rest]);
+  return (0, _react2.jsx)("div", {
+    css: cssStyles,
+    className: (0, _classnames.default)('euiCodeBlock', className),
+    style: overflowHeightStyles
+  }, isVirtualized ? (0, _react2.jsx)(_code_block_virtualized.EuiCodeBlockVirtualized, {
     data: data,
     rowHeight: fontSizeToRowHeightMap[fontSize],
     overflowHeight: overflowHeight,
-    preProps: preFullscreenProps // Note: the virtualized codeblock always sets a tabIndex of 0
-    ,
+    preProps: preProps,
     codeProps: codeProps
-  }) : (0, _react2.jsx)("pre", {
+  }) : (0, _react2.jsx)("pre", _extends({}, preProps, {
     ref: combinedRef,
-    style: overflowHeightStyles,
-    className: preClasses,
-    tabIndex: tabIndex
-  }, (0, _react2.jsx)("code", codeProps, content)), codeBlockControls, isFullScreen && (0, _react2.jsx)(FullScreenDisplay, {
-    className: wrapperClasses
-  }, isVirtualized ? (0, _react2.jsx)(VirtualizedCodeBlock, {
+    style: overflowHeightStyles
+  }), (0, _react2.jsx)("code", codeProps, content)), (0, _react2.jsx)(_code_block_controls.EuiCodeBlockControls, {
+    controls: [fullScreenButton, copyButton],
+    paddingSize: paddingSize
+  }), isFullScreen && (0, _react2.jsx)(_code_block_full_screen.EuiCodeBlockFullScreenWrapper, null, isVirtualized ? (0, _react2.jsx)(_code_block_virtualized.EuiCodeBlockVirtualized, {
     data: data,
     rowHeight: fontSizeToRowHeightMap.l,
     preProps: preFullscreenProps,
     codeProps: codeProps
-  }) : (0, _react2.jsx)("pre", preFullscreenProps, (0, _react2.jsx)("code", codeProps, content)), codeBlockControls));
+  }) : (0, _react2.jsx)("pre", preFullscreenProps, (0, _react2.jsx)("code", codeProps, content)), (0, _react2.jsx)(_code_block_controls.EuiCodeBlockControls, {
+    controls: [fullScreenButton, copyButton],
+    paddingSize: "l"
+  })));
 };
-/**
- * Overflow logic
- *
- * Detects whether the code block overflows and returns a tabIndex of 0 if so,
- * which allows keyboard users to use the up/down arrow keys to scroll through
- * the container.
- */
-
 
 exports.EuiCodeBlock = EuiCodeBlock;
 EuiCodeBlock.propTypes = {
@@ -266,8 +225,8 @@ EuiCodeBlock.propTypes = {
        */
   language: _propTypes.default.string,
   transparentBackground: _propTypes.default.bool,
-  paddingSize: _propTypes.default.oneOf(["none", "s", "m", "l"]),
-  fontSize: _propTypes.default.oneOf(["s", "m", "l"]),
+  paddingSize: _propTypes.default.any,
+  fontSize: _propTypes.default.any,
 
   /**
      * Specify how `white-space` inside the element is handled.
@@ -306,211 +265,4 @@ EuiCodeBlock.propTypes = {
      * `whiteSpace` can only be `pre`.
      */
   isVirtualized: _propTypes.default.oneOfType([_propTypes.default.bool, _propTypes.default.oneOfType([_propTypes.default.oneOf([true]).isRequired, _propTypes.default.oneOf([false])])])
-};
-
-var useOverflowDetection = function useOverflowDetection() {
-  var _useState = (0, _react.useState)(null),
-      _useState2 = _slicedToArray(_useState, 2),
-      wrapperRef = _useState2[0],
-      setWrapperRef = _useState2[1];
-
-  var _useState3 = (0, _react.useState)(-1),
-      _useState4 = _slicedToArray(_useState3, 2),
-      tabIndex = _useState4[0],
-      setTabIndex = _useState4[1];
-
-  var _useResizeObserver = (0, _resize_observer.useResizeObserver)(wrapperRef),
-      width = _useResizeObserver.width,
-      height = _useResizeObserver.height;
-
-  var doesOverflow = function doesOverflow() {
-    if (!wrapperRef) return;
-    var clientWidth = wrapperRef.clientWidth,
-        clientHeight = wrapperRef.clientHeight,
-        scrollWidth = wrapperRef.scrollWidth,
-        scrollHeight = wrapperRef.scrollHeight;
-    var doesOverflow = scrollHeight > clientHeight || scrollWidth > clientWidth;
-    setTabIndex(doesOverflow ? 0 : -1);
-  };
-
-  (0, _mutation_observer.useMutationObserver)(wrapperRef, doesOverflow, {
-    subtree: true,
-    childList: true
-  });
-  (0, _react.useEffect)(doesOverflow, [width, height, wrapperRef]);
-  return {
-    setWrapperRef: setWrapperRef,
-    tabIndex: tabIndex
-  };
-};
-/**
- * Copy logic
- */
-
-
-var CopyButton = function CopyButton(_ref3) {
-  var textToCopy = _ref3.textToCopy;
-  var copyButton = (0, _i18n.useEuiI18n)('euiCodeBlock.copyButton', 'Copy');
-  return (0, _react2.jsx)("div", {
-    className: "euiCodeBlock__copyButton"
-  }, (0, _react2.jsx)(_copy.EuiCopy, {
-    textToCopy: textToCopy
-  }, function (copy) {
-    return (0, _react2.jsx)(_button.EuiButtonIcon, {
-      onClick: copy,
-      iconType: "copyClipboard",
-      color: "text",
-      "aria-label": copyButton
-    });
-  }));
-};
-
-CopyButton.propTypes = {
-  textToCopy: _propTypes.default.string.isRequired
-};
-
-var useCopy = function useCopy(_ref4) {
-  var isCopyable = _ref4.isCopyable,
-      isVirtualized = _ref4.isVirtualized,
-      children = _ref4.children;
-
-  var _useInnerText = (0, _inner_text.useInnerText)(''),
-      _useInnerText2 = _slicedToArray(_useInnerText, 2),
-      innerTextRef = _useInnerText2[0],
-      _innerText = _useInnerText2[1];
-
-  var innerText = (0, _react.useMemo)(function () {
-    return (_innerText === null || _innerText === void 0 ? void 0 : _innerText.replace(/[\r\n?]{2}|\n\n/g, '\n')) || '';
-  }, [_innerText]);
-  var textToCopy = isVirtualized ? "".concat(children) : innerText; // Virtualized code blocks do not have inner text
-
-  var showCopyButton = isCopyable && textToCopy;
-  return {
-    innerTextRef: innerTextRef,
-    showCopyButton: showCopyButton,
-    textToCopy: textToCopy
-  };
-};
-/**
- * Fullscreen logic
- */
-
-
-var FullScreenButton = function FullScreenButton(_ref5) {
-  var isFullScreen = _ref5.isFullScreen,
-      toggleFullScreen = _ref5.toggleFullScreen;
-
-  var _useEuiI18n = (0, _i18n.useEuiI18n)(['euiCodeBlock.fullscreenCollapse', 'euiCodeBlock.fullscreenExpand'], ['Collapse', 'Expand']),
-      _useEuiI18n2 = _slicedToArray(_useEuiI18n, 2),
-      fullscreenCollapse = _useEuiI18n2[0],
-      fullscreenExpand = _useEuiI18n2[1];
-
-  return (0, _react2.jsx)(_button.EuiButtonIcon, {
-    className: "euiCodeBlock__fullScreenButton",
-    onClick: toggleFullScreen,
-    iconType: isFullScreen ? 'fullScreenExit' : 'fullScreen',
-    color: "text",
-    "aria-label": isFullScreen ? fullscreenCollapse : fullscreenExpand
-  });
-};
-
-FullScreenButton.propTypes = {
-  isFullScreen: _propTypes.default.bool.isRequired,
-  toggleFullScreen: _propTypes.default.func.isRequired
-};
-
-var FullScreenDisplay = function FullScreenDisplay(_ref6) {
-  var children = _ref6.children,
-      className = _ref6.className;
-  // Force fullscreen to use large font and padding.
-  var fullScreenClasses = (0, _classnames.default)(className, 'euiCodeBlock--fontLarge', 'euiCodeBlock--paddingLarge', 'euiCodeBlock-isFullScreen'); // Attaches to the body because of EuiOverlayMask's React portal usage.
-
-  return (0, _react2.jsx)(_overlay_mask.EuiOverlayMask, null, (0, _react2.jsx)(_focus_trap.EuiFocusTrap, {
-    clickOutsideDisables: true
-  }, (0, _react2.jsx)("div", {
-    className: fullScreenClasses
-  }, children)));
-};
-
-FullScreenDisplay.propTypes = {
-  className: _propTypes.default.string.isRequired
-};
-
-var useFullScreen = function useFullScreen(_ref7) {
-  var overflowHeight = _ref7.overflowHeight;
-
-  var _useState5 = (0, _react.useState)(false),
-      _useState6 = _slicedToArray(_useState5, 2),
-      isFullScreen = _useState6[0],
-      setIsFullScreen = _useState6[1];
-
-  var toggleFullScreen = (0, _react.useCallback)(function () {
-    setIsFullScreen(function (isFullScreen) {
-      return !isFullScreen;
-    });
-  }, []);
-  var onKeyDown = (0, _react.useCallback)(function (event) {
-    if (event.key === _services.keys.ESCAPE) {
-      event.preventDefault();
-      event.stopPropagation();
-      setIsFullScreen(false);
-    }
-  }, []);
-  var showFullScreenButton = !!overflowHeight;
-  return {
-    showFullScreenButton: showFullScreenButton,
-    isFullScreen: isFullScreen,
-    toggleFullScreen: toggleFullScreen,
-    onKeyDown: onKeyDown
-  };
-};
-/**
- * Virtualization logic
- */
-
-
-var ListRow = function ListRow(_ref8) {
-  var data = _ref8.data,
-      index = _ref8.index,
-      style = _ref8.style;
-  var row = data[index];
-  row.properties.style = style;
-  return (0, _utils.nodeToHtml)(row, index, data, 0);
-};
-
-var VirtualizedCodeBlock = function VirtualizedCodeBlock(_ref9) {
-  var data = _ref9.data,
-      rowHeight = _ref9.rowHeight,
-      overflowHeight = _ref9.overflowHeight,
-      preProps = _ref9.preProps,
-      codeProps = _ref9.codeProps;
-  var VirtualizedOuterElement = (0, _react.useMemo)(function () {
-    return /*#__PURE__*/(0, _react.forwardRef)(function (props, ref) {
-      return (0, _react2.jsx)("pre", _extends({}, props, {
-        ref: ref
-      }, preProps));
-    });
-  }, [preProps]);
-  var VirtualizedInnerElement = (0, _react.useMemo)(function () {
-    return /*#__PURE__*/(0, _react.forwardRef)(function (props, ref) {
-      return (0, _react2.jsx)("code", _extends({}, props, {
-        ref: ref
-      }, codeProps));
-    });
-  }, [codeProps]);
-  return (0, _react2.jsx)(_auto_sizer.EuiAutoSizer, {
-    disableHeight: typeof overflowHeight === 'number'
-  }, function (_ref10) {
-    var height = _ref10.height,
-        width = _ref10.width;
-    return (0, _react2.jsx)(_reactWindow.FixedSizeList, {
-      height: height !== null && height !== void 0 ? height : overflowHeight,
-      width: width,
-      itemData: data,
-      itemSize: rowHeight,
-      itemCount: data.length,
-      outerElementType: VirtualizedOuterElement,
-      innerElementType: VirtualizedInnerElement
-    }, ListRow);
-  });
 };

package/lib/components/code/code_block.styles.js

@@ -0,0 +1,154 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.euiCodeBlockStyles = exports.euiCodeBlockPreStyles = exports.euiCodeBlockCodeStyles = void 0;
+
+var _react = require("@emotion/react");
+
+var _global_styling = require("../../global_styling");
+
+var _code_syntax = require("./code_syntax.styles");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+
+var _ref4 = process.env.NODE_ENV === "production" ? {
+  name: "i92zwx-isFullScreen",
+  styles: "position:fixed;inset:0;label:isFullScreen;"
+} : {
+  name: "i92zwx-isFullScreen",
+  styles: "position:fixed;inset:0;label:isFullScreen;",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+
+var _ref5 = process.env.NODE_ENV === "production" ? {
+  name: "gfiv3z-transparentBackground",
+  styles: "background:transparent;label:transparentBackground;"
+} : {
+  name: "gfiv3z-transparentBackground",
+  styles: "background:transparent;label:transparentBackground;",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+
+var euiCodeBlockStyles = function euiCodeBlockStyles(euiThemeContext) {
+  var euiTheme = euiThemeContext.euiTheme;
+  var euiCodeSyntax = (0, _code_syntax.euiCodeSyntaxColors)(euiThemeContext);
+  return {
+    euiCodeBlock: /*#__PURE__*/(0, _react.css)("max-inline-size:100%;display:block;position:relative;background:", euiCodeSyntax.backgroundColor, ";", (0, _code_syntax.euiCodeSyntaxTokens)(euiThemeContext), ";;label:euiCodeBlock;"),
+    // Font size
+    s: /*#__PURE__*/(0, _react.css)((0, _global_styling.euiFontSize)(euiThemeContext, 'xs'), ";;label:s;"),
+    m: /*#__PURE__*/(0, _react.css)((0, _global_styling.euiFontSize)(euiThemeContext, 's'), ";;label:m;"),
+    l: /*#__PURE__*/(0, _react.css)((0, _global_styling.euiFontSize)(euiThemeContext, 'm'), ";;label:l;"),
+    // Variants
+    transparentBackground: _ref5,
+    isFullScreen: _ref4,
+    // Account for control heights
+    hasControls: generatePaddingCss(euiThemeContext, function (paddingSize) {
+      return /*#__PURE__*/(0, _react.css)("min-block-size:", (0, _global_styling.mathWithUnits)([euiTheme.size.l, paddingSize], function (iconSize, paddingSize) {
+        return iconSize + paddingSize * 2;
+      }), ";;label:hasControls;");
+    }),
+    hasBothControls: generatePaddingCss(euiThemeContext, function (paddingSize) {
+      return /*#__PURE__*/(0, _react.css)("min-block-size:", (0, _global_styling.mathWithUnits)([euiTheme.size.l, euiTheme.size.xs, paddingSize], function (iconSize, gap, paddingSize) {
+        return iconSize * 2 + gap + paddingSize * 2;
+      }), ";;label:hasBothControls;");
+    })
+  };
+};
+
+exports.euiCodeBlockStyles = euiCodeBlockStyles;
+
+var _ref2 = process.env.NODE_ENV === "production" ? {
+  name: "eav5br-preWrap",
+  styles: "white-space:pre-wrap;label:preWrap;"
+} : {
+  name: "eav5br-preWrap",
+  styles: "white-space:pre-wrap;label:preWrap;",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+
+var _ref3 = process.env.NODE_ENV === "production" ? {
+  name: "4dmmkq-pre",
+  styles: "white-space:pre;label:pre;"
+} : {
+  name: "4dmmkq-pre",
+  styles: "white-space:pre;label:pre;",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+
+var euiCodeBlockPreStyles = function euiCodeBlockPreStyles(euiThemeContext) {
+  var euiTheme = euiThemeContext.euiTheme;
+  return {
+    euiCodeBlock__pre: /*#__PURE__*/(0, _react.css)("block-size:100%;overflow:auto;display:block;", (0, _global_styling.euiScrollBarStyles)(euiThemeContext), ";;label:euiCodeBlock__pre;"),
+    padding: _objectSpread({}, generatePaddingCss(euiThemeContext, function (paddingSize) {
+      return /*#__PURE__*/(0, _react.css)("padding:", paddingSize, ";;label:padding;");
+    })),
+    whiteSpace: {
+      pre: {
+        pre: _ref3,
+        controlsOffset: generatePaddingCss(euiThemeContext, function (paddingSize) {
+          return /*#__PURE__*/(0, _react.css)("margin-inline-end:", (0, _global_styling.mathWithUnits)([paddingSize, euiTheme.size.l, euiTheme.size.xs], function (paddingSize, iconSize, gap) {
+            return paddingSize + gap + iconSize;
+          }), ";;label:controlsOffset;");
+        })
+      },
+      preWrap: {
+        preWrap: _ref2,
+        controlsOffset: generatePaddingCss(euiThemeContext, function (paddingSize) {
+          return /*#__PURE__*/(0, _react.css)("padding-inline-end:", (0, _global_styling.mathWithUnits)([paddingSize, euiTheme.size.l, euiTheme.size.xs], function (paddingSize, iconSize, gap) {
+            return paddingSize + gap + iconSize;
+          }), ";;label:controlsOffset;");
+        })
+      }
+    }
+  };
+};
+
+exports.euiCodeBlockPreStyles = euiCodeBlockPreStyles;
+
+var _ref = process.env.NODE_ENV === "production" ? {
+  name: "9y8iu3-isVirtualized",
+  styles: "position:relative;label:isVirtualized;"
+} : {
+  name: "9y8iu3-isVirtualized",
+  styles: "position:relative;label:isVirtualized;",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+
+var euiCodeBlockCodeStyles = function euiCodeBlockCodeStyles(euiThemeContext) {
+  var euiTheme = euiThemeContext.euiTheme;
+  var euiCodeSyntax = (0, _code_syntax.euiCodeSyntaxColors)(euiThemeContext);
+  return {
+    euiCodeBlock__code: /*#__PURE__*/(0, _react.css)("font-family:", euiTheme.font.familyCode, ";font-size:inherit;color:", euiCodeSyntax.color, ";display:block;;label:euiCodeBlock__code;"),
+    isVirtualized: _ref
+  };
+};
+/**
+ * Helper for generating keys for each code block padding size
+ */
+
+
+exports.euiCodeBlockCodeStyles = euiCodeBlockCodeStyles;
+
+var generatePaddingCss = function generatePaddingCss(euiThemeContext, callback) {
+  var cssKeys = {
+    none: /*#__PURE__*/(0, _react.css)(";label:none;"),
+    s: /*#__PURE__*/(0, _react.css)(";label:s;"),
+    m: /*#__PURE__*/(0, _react.css)(";label:m;"),
+    l: /*#__PURE__*/(0, _react.css)(";label:l;"),
+    xl: /*#__PURE__*/(0, _react.css)(";label:xl;")
+  }; // xl padding used by fullscreen mode
+
+  ['none', 's', 'm', 'l', 'xl'].forEach(function (size) {
+    var paddingSize = (0, _global_styling.euiPaddingSize)(euiThemeContext, size) || 0;
+    cssKeys[size] = callback(paddingSize);
+  });
+  return cssKeys;
+};

package/lib/components/code/code_block_controls.js

@@ -0,0 +1,48 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EuiCodeBlockControls = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _services = require("../../services");
+
+var _code_block_controls = require("./code_block_controls.styles");
+
+var _react2 = require("@emotion/react");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+var EuiCodeBlockControls = function EuiCodeBlockControls(_ref) {
+  var paddingSize = _ref.paddingSize,
+      controls = _ref.controls;
+  var euiTheme = (0, _services.useEuiTheme)();
+  var styles = (0, _code_block_controls.euiCodeBlockControlsStyles)(euiTheme);
+  var cssStyles = [styles.euiCodeBlock__controls, styles.offset[paddingSize]];
+  var hasControls = controls.some(function (control) {
+    return !!control;
+  });
+  return hasControls ? (0, _react2.jsx)("div", {
+    className: "euiCodeBlock__controls",
+    css: cssStyles
+  }, controls.map(function (control, i) {
+    return (0, _react2.jsx)(_react.Fragment, {
+      key: i
+    }, control);
+  })) : null;
+};
+
+exports.EuiCodeBlockControls = EuiCodeBlockControls;