@elastic/eui 99.3.0-classic.0 → 99.4.0

package/test-env/services/theme/utils.js

@@ -1,66 +1,308 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "Computed", {
-  enumerable: true,
-  get: function get() {
-    return _euiThemeCommon.Computed;
-  }
-});
-Object.defineProperty(exports, "DEFAULT_COLOR_MODE", {
-  enumerable: true,
-  get: function get() {
-    return _euiThemeCommon.DEFAULT_COLOR_MODE;
-  }
-});
-Object.defineProperty(exports, "buildTheme", {
-  enumerable: true,
-  get: function get() {
-    return _euiThemeCommon.buildTheme;
-  }
-});
-Object.defineProperty(exports, "computed", {
-  enumerable: true,
-  get: function get() {
-    return _euiThemeCommon.computed;
+exports.buildTheme = exports.DEFAULT_COLOR_MODE = exports.Computed = void 0;
+exports.computed = computed;
+exports.setOn = exports.mergeDeep = exports.isInverseColorMode = exports.getOn = exports.getComputed = exports.getColorMode = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _types = require("./types");
+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) { (0, _defineProperty2.default)(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; } /*
+ * 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 DEFAULT_COLOR_MODE = exports.DEFAULT_COLOR_MODE = _types.COLOR_MODES_STANDARD.light;
+
+/**
+ * Returns whether the parameter is an object
+ * @param {any} obj - Anything
+ */
+var isObject = function isObject(obj) {
+  return obj && (0, _typeof2.default)(obj) === 'object';
+};
+
+/**
+ * Returns whether the provided color mode is `inverse`
+ * @param {string} colorMode - `light`, `dark`, or `inverse`
+ */
+var isInverseColorMode = exports.isInverseColorMode = function isInverseColorMode(colorMode) {
+  return colorMode === _types.COLOR_MODES_INVERSE;
+};
+
+/**
+ * Returns the color mode configured in the current EuiThemeProvider.
+ * Returns the parent color mode if none is explicity set.
+ * @param {string} colorMode - `light`, `dark`, or `inverse`
+ * @param {string} parentColorMode - `LIGHT` or `DARK`; used as the fallback
+ */
+var getColorMode = exports.getColorMode = function getColorMode(colorMode, parentColorMode) {
+  if (colorMode == null) {
+    return parentColorMode || DEFAULT_COLOR_MODE;
   }
-});
-Object.defineProperty(exports, "getColorMode", {
-  enumerable: true,
-  get: function get() {
-    return _euiThemeCommon.getColorMode;
+  var mode = colorMode.toUpperCase();
+  if (isInverseColorMode(mode)) {
+    return parentColorMode === _types.COLOR_MODES_STANDARD.dark || parentColorMode === undefined ? _types.COLOR_MODES_STANDARD.light : _types.COLOR_MODES_STANDARD.dark;
+  } else {
+    return mode;
   }
-});
-Object.defineProperty(exports, "getComputed", {
-  enumerable: true,
-  get: function get() {
-    return _euiThemeCommon.getComputed;
+};
+
+/**
+ * Returns a value at a given path on an object.
+ * If `colorMode` is provided, will scope the value to the appropriate color mode key (LIGHT\DARK)
+ * @param {object} model - Object
+ * @param {string} _path - Dot-notated string to a path on the object
+ * @param {string} colorMode - `light` or `dark`
+ */
+var getOn = exports.getOn = function getOn(model, _path, colorMode) {
+  var path = _path.split('.');
+  var node = model;
+  while (path.length) {
+    var segment = path.shift();
+    if (node.hasOwnProperty(segment) === false) {
+      if (colorMode && node.hasOwnProperty(colorMode) === true && node[colorMode].hasOwnProperty(segment) === true) {
+        if (node[colorMode][segment] instanceof Computed) {
+          node = node[colorMode][segment].getValue(null, null, node, colorMode);
+        } else {
+          node = node[colorMode][segment];
+        }
+      } else {
+        return undefined;
+      }
+    } else {
+      if (node[segment] instanceof Computed) {
+        node = node[segment].getValue(null, null, node, colorMode);
+      } else {
+        node = node[segment];
+      }
+    }
   }
-});
-Object.defineProperty(exports, "getOn", {
-  enumerable: true,
-  get: function get() {
-    return _euiThemeCommon.getOn;
+  return node;
+};
+
+/**
+ * Sets a value at a given path on an object.
+ * @param {object} model - Object
+ * @param {string} _path - Dot-notated string to a path on the object
+ * @param {any} string -  The value to set
+ */
+var setOn = exports.setOn = function setOn(model, _path, value) {
+  var path = _path.split('.');
+  var propertyName = path.pop();
+  var node = model;
+  while (path.length) {
+    var segment = path.shift();
+    if (node.hasOwnProperty(segment) === false) {
+      node[segment] = {};
+    }
+    node = node[segment];
   }
-});
-Object.defineProperty(exports, "isInverseColorMode", {
-  enumerable: true,
-  get: function get() {
-    return _euiThemeCommon.isInverseColorMode;
+  node[propertyName] = value;
+  return true;
+};
+
+/**
+ * Creates a class to store the `computer` method and its eventual parameters.
+ * Allows for on-demand computation with up-to-date parameters via `getValue` method.
+ * @constructor
+ * @param {function} computer - Function to be computed
+ * @param {string | array} dependencies - Dependencies passed to the `computer` as parameters
+ */
+var Computed = exports.Computed = /*#__PURE__*/function () {
+  function Computed(computer) {
+    var dependencies = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    (0, _classCallCheck2.default)(this, Computed);
+    this.computer = computer;
+    this.dependencies = dependencies;
   }
-});
-Object.defineProperty(exports, "mergeDeep", {
-  enumerable: true,
-  get: function get() {
-    return _euiThemeCommon.mergeDeep;
+
+  /**
+   * Executes the `computer` method with the current state of the theme
+   * by taking into account previously computed values and modifications.
+   * @param {Proxy | object} base - Computed or uncomputed theme
+   * @param {Proxy | object} modifications - Theme value overrides
+   * @param {object} working - Partially computed theme
+   * @param {string} colorMode - `light` or `dark`
+   */
+  return (0, _createClass2.default)(Computed, [{
+    key: "getValue",
+    value: function getValue(base) {
+      var modifications = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var working = arguments.length > 2 ? arguments[2] : undefined;
+      var colorMode = arguments.length > 3 ? arguments[3] : undefined;
+      if (!this.dependencies.length) {
+        return this.computer(working);
+      }
+      if (!Array.isArray(this.dependencies)) {
+        var _ref, _getOn;
+        return this.computer((_ref = (_getOn = getOn(working, this.dependencies)) !== null && _getOn !== void 0 ? _getOn : getOn(modifications, this.dependencies, colorMode)) !== null && _ref !== void 0 ? _ref : getOn(base, this.dependencies, colorMode));
+      }
+      return this.computer(this.dependencies.map(function (dependency) {
+        var _ref2, _getOn2;
+        return (_ref2 = (_getOn2 = getOn(working, dependency)) !== null && _getOn2 !== void 0 ? _getOn2 : getOn(modifications, dependency, colorMode)) !== null && _ref2 !== void 0 ? _ref2 : getOn(base, dependency, colorMode);
+      }));
+    }
+  }]);
+}();
+/**
+ * Returns a Class (`Computed`) that stores the arbitrary computer method
+ * and references to its optional dependecies.
+ * @param {function} computer - Arbitrary method to be called at compute time.
+ * @param {string | array} dependencies - Values that will be provided to `computer` at compute time.
+ */
+function computed(comp, dep) {
+  return new Computed(comp, dep);
+}
+
+/**
+ * Takes an uncomputed theme, and computes and returns all values taking
+ * into consideration value overrides and configured color mode.
+ * Overrides take precedence, and only values in the current color mode
+ * are computed and returned.
+ * @param {Proxy} base - Object to transform into Proxy
+ * @param {Proxy | object} over - Unique identifier or name
+ * @param {string} colorMode - `light` or `dark`
+ */
+var getComputed = exports.getComputed = function getComputed(base, over, colorMode) {
+  var output = {
+    themeName: base.key
+  };
+  function loop(base, over) {
+    var checkExisting = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var path = arguments.length > 3 ? arguments[3] : undefined;
+    Object.keys(base).forEach(function (key) {
+      var newPath = path ? "".concat(path, ".").concat(key) : "".concat(key);
+      // @ts-expect-error `key` is not necessarily a colorMode key
+      if ([].concat((0, _toConsumableArray2.default)(Object.values(_types.COLOR_MODES_STANDARD)), [colorMode]).includes(key)) {
+        if (key !== colorMode) {
+          return;
+        } else {
+          var colorModeSegment = new RegExp("(\\.".concat(colorMode, "\\b)|(\\b").concat(colorMode, "\\.)"));
+          newPath = newPath.replace(colorModeSegment, '');
+        }
+      }
+      var existing = checkExisting && getOn(output, newPath);
+      if (!existing || isObject(existing)) {
+        var baseValue = base[key] instanceof Computed ? base[key].getValue(base.root, over.root, output, colorMode) : base[key];
+        var overValue = over[key] instanceof Computed ? over[key].getValue(base.root, over.root, output, colorMode) : over[key];
+        if (isObject(baseValue) && !Array.isArray(baseValue)) {
+          loop(baseValue, overValue !== null && overValue !== void 0 ? overValue : {}, checkExisting, newPath);
+        } else {
+          setOn(output, newPath, overValue !== null && overValue !== void 0 ? overValue : baseValue);
+        }
+      }
+    });
   }
-});
-Object.defineProperty(exports, "setOn", {
-  enumerable: true,
-  get: function get() {
-    return _euiThemeCommon.setOn;
+  // Compute standard theme values and apply overrides
+  loop(base, over);
+  // Compute and apply extension values only
+  loop(over, {}, true);
+  return output;
+};
+
+/**
+ * Builds a Proxy with a custom `handler` designed to self-reference values
+ * and prevent arbitrary value overrides.
+ * @param {object} model - Object to transform into Proxy
+ * @param {string} key - Unique identifier or name
+ */
+var buildTheme = exports.buildTheme = function buildTheme(model, key) {
+  var handler = {
+    getPrototypeOf: function getPrototypeOf(target) {
+      return Reflect.getPrototypeOf(target.model);
+    },
+    setPrototypeOf: function setPrototypeOf(target, prototype) {
+      return Reflect.setPrototypeOf(target.model, prototype);
+    },
+    isExtensible: function isExtensible(target) {
+      return Reflect.isExtensible(target);
+    },
+    preventExtensions: function preventExtensions(target) {
+      return Reflect.preventExtensions(target.model);
+    },
+    getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, key) {
+      return Reflect.getOwnPropertyDescriptor(target.model, key);
+    },
+    defineProperty: function defineProperty(target, property, attributes) {
+      return Reflect.defineProperty(target.model, property, attributes);
+    },
+    has: function has(target, property) {
+      return Reflect.has(target.model, property);
+    },
+    get: function get(_target, property) {
+      if (property === 'key') {
+        return _target[property];
+      }
+
+      // prevent Safari from locking up when the proxy is used in dev tools
+      // as it doesn't support getPrototypeOf
+      if (property === '__proto__') return {};
+      var target = property === 'root' ? _target : _target.model || _target;
+      // @ts-ignore `string` index signature
+      var value = target[property];
+      if (isObject(value) && !Array.isArray(value)) {
+        return new Proxy({
+          model: value,
+          root: _target.root,
+          key: "_".concat(_target.key)
+        }, handler);
+      } else {
+        return value;
+      }
+    },
+    set: function set(target) {
+      return target;
+    },
+    deleteProperty: function deleteProperty(target) {
+      return target;
+    },
+    ownKeys: function ownKeys(target) {
+      return Reflect.ownKeys(target.model);
+    },
+    apply: function apply(target) {
+      return target;
+    },
+    construct: function construct(target) {
+      return target;
+    }
+  };
+  var themeProxy = new Proxy({
+    model: model,
+    root: model,
+    key: key
+  }, handler);
+  return themeProxy;
+};
+
+/**
+ * Deeply merges two objects, using `source` values whenever possible.
+ * @param {object} _target - Object with fallback values
+ * @param {object} source - Object with desired values
+ */
+var mergeDeep = exports.mergeDeep = function mergeDeep(_target) {
+  var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var target = _objectSpread({}, _target);
+  if (!isObject(target) || !isObject(source)) {
+    return source;
   }
-});
-var _euiThemeCommon = require("@elastic/eui-theme-common");
+  Object.keys(source).forEach(function (key) {
+    var targetValue = target[key];
+    var sourceValue = source[key];
+    if (isObject(targetValue) && isObject(sourceValue)) {
+      target[key] = mergeDeep(_objectSpread({}, targetValue), _objectSpread({}, sourceValue));
+    } else {
+      target[key] = sourceValue;
+    }
+  });
+  return target;
+};

package/test-env/themes/amsterdam/global_styling/functions/shadows.js

@@ -1,12 +1,24 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "getShadowColor", {
-  enumerable: true,
-  get: function get() {
-    return _euiThemeCommon.getShadowColor;
-  }
-});
-var _euiThemeCommon = require("@elastic/eui-theme-common");
+exports.getShadowColor = void 0;
+var _chromaJs = _interopRequireDefault(require("chroma-js"));
+var _types = require("../../../../services/theme/types");
+/*
+ * 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.
+ */
+
+// Create a CSS color value using whose opacity is determined based
+// on either a light or dark theme. We use a multiplier
+// of 1 for light themes and 2.5 for dark themes
+var getShadowColor = exports.getShadowColor = function getShadowColor(color, opacity, colorMode) {
+  var themeOpacity = colorMode === _types.COLOR_MODES_STANDARD.dark ? opacity * 3.5 : opacity * 1;
+  return (0, _chromaJs.default)(color).alpha(themeOpacity).css();
+};

package/test-env/themes/amsterdam/global_styling/mixins/button.js

@@ -1,54 +1,212 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "BUTTON_COLORS", {
-  enumerable: true,
-  get: function get() {
-    return _button.BUTTON_COLORS;
+exports.useEuiButtonFocusCSS = exports.useEuiButtonColorCSS = exports.euiButtonSizeMap = exports.euiButtonFillColor = exports.euiButtonEmptyColor = exports.euiButtonColor = exports.BUTTON_DISPLAYS = exports.BUTTON_COLORS = void 0;
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _react = require("@emotion/react");
+var _global_styling = require("../../../../global_styling");
+var _services = require("../../../../services");
+var _templateObject;
+/*
+ * 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 BUTTON_COLORS = exports.BUTTON_COLORS = ['text', 'accent', 'primary', 'success', 'warning', 'danger'];
+var BUTTON_DISPLAYS = exports.BUTTON_DISPLAYS = ['base', 'fill', 'empty'];
+/**
+ * Creates the `base` version of button styles with proper text contrast.
+ * @param euiThemeContext
+ * @param color One of the named button colors or 'disabled'
+ * @returns Style object `{ backgroundColor, color }`
+ */
+var euiButtonColor = exports.euiButtonColor = function euiButtonColor(euiThemeContext, color) {
+  var euiTheme = euiThemeContext.euiTheme,
+    colorMode = euiThemeContext.colorMode;
+  function tintOrShade(color) {
+    return colorMode === 'DARK' ? (0, _services.shade)(color, 0.7) : (0, _services.tint)(color, 0.8);
   }
-});
-Object.defineProperty(exports, "BUTTON_DISPLAYS", {
-  enumerable: true,
-  get: function get() {
-    return _button.BUTTON_DISPLAYS;
-  }
-});
-Object.defineProperty(exports, "euiButtonColor", {
-  enumerable: true,
-  get: function get() {
-    return _button.euiButtonColor;
-  }
-});
-Object.defineProperty(exports, "euiButtonEmptyColor", {
-  enumerable: true,
-  get: function get() {
-    return _button.euiButtonEmptyColor;
-  }
-});
-Object.defineProperty(exports, "euiButtonFillColor", {
-  enumerable: true,
-  get: function get() {
-    return _button.euiButtonFillColor;
-  }
-});
-Object.defineProperty(exports, "euiButtonSizeMap", {
-  enumerable: true,
-  get: function get() {
-    return _button.euiButtonSizeMap;
+  var foreground;
+  var background;
+  switch (color) {
+    case 'disabled':
+      return {
+        color: euiTheme.colors.disabledText,
+        backgroundColor: (0, _services.transparentize)(euiTheme.colors.lightShade, 0.15)
+      };
+    case 'text':
+      foreground = euiTheme.colors[color];
+      background = colorMode === 'DARK' ? (0, _services.shade)(euiTheme.colors.lightShade, 0.2) : (0, _services.tint)(euiTheme.colors.lightShade, 0.5);
+      break;
+    default:
+      foreground = euiTheme.colors["".concat(color, "Text")];
+      background = tintOrShade(euiTheme.colors[color]);
+      break;
   }
-});
-Object.defineProperty(exports, "useEuiButtonColorCSS", {
-  enumerable: true,
-  get: function get() {
-    return _button.useEuiButtonColorCSS;
+  return {
+    color: (0, _services.makeHighContrastColor)(foreground)(background),
+    backgroundColor: background
+  };
+};
+
+/**
+ * Creates the `fill` version of buttons styles with proper text contrast.
+ * @param euiThemeContext
+ * @param color One of the named button colors or 'disabled'
+ * @returns Style object `{ backgroundColor, color }`
+ */
+var euiButtonFillColor = exports.euiButtonFillColor = function euiButtonFillColor(euiThemeContext, color) {
+  var euiTheme = euiThemeContext.euiTheme,
+    colorMode = euiThemeContext.colorMode;
+  var getForegroundColor = function getForegroundColor(background) {
+    return _services.isColorDark.apply(void 0, (0, _toConsumableArray2.default)((0, _services.hexToRgb)(background))) ? euiTheme.colors.ghost : euiTheme.colors.ink;
+  };
+  var background;
+  var foreground;
+  switch (color) {
+    case 'disabled':
+      background = euiButtonColor(euiThemeContext, color).backgroundColor;
+      foreground = euiButtonColor(euiThemeContext, color).color;
+      break;
+    case 'text':
+      background = colorMode === 'DARK' ? euiTheme.colors.text : euiTheme.colors.darkShade;
+      foreground = getForegroundColor(background);
+      break;
+    case 'success':
+    case 'accent':
+      // Success / accent fills are hard to read on light mode even though they pass color contrast ratios
+      // TODO: If WCAG 3 gets adopted (which would calculates luminosity & would allow us to use white text instead),
+      // we can get rid of this case (https://blog.datawrapper.de/color-contrast-check-data-vis-wcag-apca/)
+      background = colorMode === 'LIGHT' ? (0, _services.tint)(euiTheme.colors[color], 0.3) : euiTheme.colors[color];
+      foreground = getForegroundColor(background);
+      break;
+    default:
+      background = euiTheme.colors[color];
+      foreground = getForegroundColor(background);
+      break;
   }
-});
-Object.defineProperty(exports, "useEuiButtonFocusCSS", {
-  enumerable: true,
-  get: function get() {
-    return _button.useEuiButtonFocusCSS;
+  return {
+    color: foreground,
+    backgroundColor: background
+  };
+};
+
+/**
+ * Creates the `empty` version of button styles using the text-variant and adding interactive styles.
+ * @param euiThemeContext
+ * @param color One of the named button colors or 'disabled'
+ * @returns Style object `{ backgroundColor, color }` where `background` is typically used for interactive states
+ */
+var euiButtonEmptyColor = exports.euiButtonEmptyColor = function euiButtonEmptyColor(euiThemeContext, color) {
+  var foreground;
+  var background;
+  switch (color) {
+    case 'disabled':
+      foreground = euiButtonColor(euiThemeContext, color).color;
+      background = 'transparent';
+      break;
+    case 'text':
+      foreground = euiButtonColor(euiThemeContext, color).color;
+      background = (0, _global_styling.euiBackgroundColor)(euiThemeContext, 'subdued', {
+        method: 'transparent'
+      });
+      break;
+    default:
+      foreground = euiButtonColor(euiThemeContext, color).color;
+      background = (0, _global_styling.euiBackgroundColor)(euiThemeContext, color, {
+        method: 'transparent'
+      });
+      break;
   }
-});
-var _button = require("../../../../global_styling/mixins/_button");
+  return {
+    color: foreground,
+    backgroundColor: background
+  };
+};
+
+/**
+ * Given the button display type, returns the Emotion based color keys.
+ * @param options Button display type
+ * @returns An object of `_EuiButtonColor` keys including `disabled`
+ */
+var useEuiButtonColorCSS = exports.useEuiButtonColorCSS = function useEuiButtonColorCSS() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _options$display = options.display,
+    display = _options$display === void 0 ? 'base' : _options$display;
+  var colorsDisplaysMap = (0, _services.useEuiMemoizedStyles)(euiButtonDisplaysColors);
+  return colorsDisplaysMap[display];
+};
+var euiButtonDisplaysColors = function euiButtonDisplaysColors(euiThemeContext) {
+  var COLORS = [].concat(BUTTON_COLORS, ['disabled']);
+  var displaysColorsMap = {};
+  BUTTON_DISPLAYS.forEach(function (display) {
+    displaysColorsMap[display] = {};
+    COLORS.forEach(function (color) {
+      switch (display) {
+        case 'base':
+          displaysColorsMap[display][color] = /*#__PURE__*/(0, _react.css)(euiButtonColor(euiThemeContext, color), ";;label:displaysColorsMap-display-color;");
+          break;
+        case 'fill':
+          displaysColorsMap[display][color] = /*#__PURE__*/(0, _react.css)(euiButtonFillColor(euiThemeContext, color), "outline-color:", euiThemeContext.colorMode === 'DARK' && color === 'text' ? 'currentColor' : euiThemeContext.euiTheme.colors.fullShade, ";;label:displaysColorsMap-display-color;");
+          break;
+        case 'empty':
+          displaysColorsMap[display][color] = /*#__PURE__*/(0, _react.css)("color:", euiButtonEmptyColor(euiThemeContext, color).color, ";&:focus,&:active{background-color:", euiButtonEmptyColor(euiThemeContext, color).backgroundColor, ";};label:displaysColorsMap-display-color;");
+          break;
+      }
+
+      // Tweak auto-generated Emotion label/className output
+      var emotionOutput = displaysColorsMap[display][color];
+      emotionOutput.styles = emotionOutput.styles.replace('label:displaysColorsMap-display-color;', "label:".concat(display, "-").concat(color, ";"));
+    });
+  });
+  return displaysColorsMap;
+};
+
+/**
+ * Creates the translate animation when button is in focus.
+ * @returns string
+ */
+var useEuiButtonFocusCSS = exports.useEuiButtonFocusCSS = function useEuiButtonFocusCSS() {
+  return (0, _services.useEuiMemoizedStyles)(euiButtonFocusCSS);
+};
+var euiButtonFocusAnimation = (0, _react.keyframes)(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2.default)(["\n  50% {\n    transform: translateY(1px);\n  }\n"])));
+var euiButtonFocusCSS = function euiButtonFocusCSS(_ref) {
+  var euiTheme = _ref.euiTheme;
+  var focusCSS = /*#__PURE__*/(0, _react.css)(_global_styling.euiCanAnimate, "{transition:transform ", euiTheme.animation.normal, " ease-in-out,background-color ", euiTheme.animation.normal, " ease-in-out;&:hover:not(:disabled){transform:translateY(-1px);}&:focus{animation:", euiButtonFocusAnimation, " ", euiTheme.animation.normal, " ", euiTheme.animation.bounce, ";}&:active:not(:disabled){transform:translateY(1px);}};label:focusCSS;");
+  // Remove the auto-generated label.
+  // We could typically avoid a label by using a plain string `` instead of css``,
+  // but we need css`` for keyframes`` to work for the focus animation
+  focusCSS.styles = focusCSS.styles.replace('label:focusCSS;', '');
+  return focusCSS;
+};
+
+/**
+ * Map of `size` props to various sizings/scales
+ * that should remain consistent across all buttons
+ */
+var euiButtonSizeMap = exports.euiButtonSizeMap = function euiButtonSizeMap(_ref2) {
+  var euiTheme = _ref2.euiTheme;
+  return {
+    xs: {
+      height: euiTheme.size.l,
+      radius: euiTheme.border.radius.small,
+      fontScale: 'xs'
+    },
+    s: {
+      height: euiTheme.size.xl,
+      radius: euiTheme.border.radius.small,
+      fontScale: 's'
+    },
+    m: {
+      height: euiTheme.size.xxl,
+      radius: euiTheme.border.radius.medium,
+      fontScale: 's'
+    }
+  };
+};