@elastic/eui 97.3.0 → 97.3.1-borealis.0

package/optimize/es/services/color/eui_palettes.js

@@ -9,6 +9,7 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 
 import chroma from 'chroma-js';
 import { colorPalette } from './color_palette';
+import { EUI_VIS_COLOR_STORE } from './vis_color_store';
 var flatten = function flatten(arr) {
   var _ref;
   return (_ref = []).concat.apply(_ref, _toConsumableArray(arr));
@@ -24,6 +25,14 @@ var euiPalette = function euiPalette(colors, steps) {
   }
   return colorPalette(colors, steps, diverge, categorical);
 };
+/**
+ * NOTE: These functions rely on base vis colors of the theme which are provided via a global
+ * singleton instance `EUI_VIS_COLOR_STORE` that's updated by the EuiProvider on theme change.
+ * Make sure the function is recalled on theme change to retrieve theme-related colors.
+ *
+ * Outside of a react component you can use the `subscibe()` method on the `EUI_VIS_COLOR_STORE`
+ * to subscribe to updates and update your usages to ensure latest colors are loaded.
+ */
 export var euiPaletteColorBlind = function euiPaletteColorBlind() {
   var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
     _ref2$rotations = _ref2.rotations,
@@ -37,26 +46,8 @@ export var euiPaletteColorBlind = function euiPaletteColorBlind() {
     _ref2$sortShift = _ref2.sortShift,
     sortShift = _ref2$sortShift === void 0 ? '-100' : _ref2$sortShift;
   var colors = [];
-  var base = ['#54B399',
-  // 0 green
-  '#6092C0',
-  // 1 blue
-  '#D36086',
-  // 2 dark pink
-  '#9170B8',
-  // 3 purple
-  '#CA8EAE',
-  // 4 light pink
-  '#D6BF57',
-  // 5 yellow
-  '#B9A888',
-  // 6 tan
-  '#DA8B45',
-  // 7 orange
-  '#AA6556',
-  // 8 brown
-  '#E7664C' // 9 red
-  ];
+  var visColors = EUI_VIS_COLOR_STORE.visColors;
+  var base = [visColors.euiColorVis0, visColors.euiColorVis1, visColors.euiColorVis2, visColors.euiColorVis3, visColors.euiColorVis4, visColors.euiColorVis5, visColors.euiColorVis6, visColors.euiColorVis7, visColors.euiColorVis8, visColors.euiColorVis9];
   if (sortBy === 'natural') {
     // Sort the colors based on the color wheel, but shifting the values based on sortShift
     base = _toConsumableArray(base).sort(function (a, b) {
@@ -102,78 +93,156 @@ export var euiPaletteColorBlind = function euiPaletteColorBlind() {
 /**
  * Color blind palette with text is meant for use when text is applied on top of the color.
  * It increases the brightness of the color to give the text more contrast.
+ *
+ * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
+ * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
  */
 export var euiPaletteColorBlindBehindText = function euiPaletteColorBlindBehindText() {
   var paletteProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var hasVisColorAdjustment = EUI_VIS_COLOR_STORE.hasVisColorAdjustment;
   var originalPalette = euiPaletteColorBlind(paletteProps);
+
+  // new theme palette has required contrast, we don't need to adjust them
+  if (!hasVisColorAdjustment) return originalPalette;
   var newPalette = originalPalette.map(function (color) {
     return chroma(color).brighten(0.5).hex();
   });
   return newPalette;
 };
+var _getVisColorsAsText = function _getVisColorsAsText(visColors, keys) {
+  return keys.reduce(function (colors, curr) {
+    return [].concat(_toConsumableArray(colors), [visColors[curr]]);
+  }, []);
+};
+
+/**
+ * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
+ * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
+ */
 export var euiPaletteForLightBackground = function euiPaletteForLightBackground() {
-  return ['#006BB4', '#017D73', '#F5A700', '#BD271E', '#DD0A73'];
+  var visColors = EUI_VIS_COLOR_STORE.visColors;
+  var visColorsAsTextKeys = Object.keys(visColors).filter(function (color) {
+    return color.includes('AsTextLight');
+  });
+  return _getVisColorsAsText(visColors, visColorsAsTextKeys);
 };
+
+/**
+ * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
+ * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
+ */
 export var euiPaletteForDarkBackground = function euiPaletteForDarkBackground() {
-  return ['#1BA9F5', '#7DE2D1', '#F990C0', '#F66', '#FFCE7A'];
+  var visColors = EUI_VIS_COLOR_STORE.visColors;
+  var visColorsAsTextKeys = Object.keys(visColors).filter(function (color) {
+    return color.includes('AsTextDark');
+  });
+  return _getVisColorsAsText(visColors, visColorsAsTextKeys);
 };
-var greenColor = '#209280';
-var redColor = '#CC5642';
-var lightRedColor = euiPaletteColorBlind()[9];
-var coolArray = [euiPaletteColorBlind()[1], '#6092C0'];
-var warmArray = [euiPaletteColorBlind()[7], euiPaletteColorBlind()[9]];
+
+/**
+ * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
+ * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
+ */
 export var euiPaletteForStatus = function euiPaletteForStatus(steps) {
+  var visColors = EUI_VIS_COLOR_STORE.visColors;
   if (steps === 1) {
-    return [greenColor];
+    return [visColors.euiColorVisSuccess0];
   }
   if (steps <= 3) {
-    return euiPalette([greenColor, euiPaletteColorBlind()[5], redColor], steps, true);
+    return euiPalette([visColors.euiColorVisSuccess0, visColors.euiColorVisWarning0, visColors.euiColorVisDanger0], steps, true);
   }
-  return euiPalette([greenColor, euiPaletteColorBlind()[0], euiPaletteColorBlind()[5], lightRedColor, redColor], steps, true);
+  return euiPalette([visColors.euiColorVisSuccess0, visColors.euiColorVisSuccess1, visColors.euiColorVisWarning0, visColors.euiColorVisDanger1, visColors.euiColorVisDanger0], steps, true);
 };
+
+/**
+ * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
+ * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
+ */
 export var euiPaletteForTemperature = function euiPaletteForTemperature(steps) {
-  var cools = colorPalette([].concat(_toConsumableArray(coolArray.slice().reverse()), ['#EBEFF5']), 3);
-  var warms = colorPalette(['#F4F3DB'].concat(warmArray), 3);
+  var hasVisColorAdjustment = EUI_VIS_COLOR_STORE.hasVisColorAdjustment,
+    visColors = EUI_VIS_COLOR_STORE.visColors;
   if (steps === 1) {
-    return [cools[0]];
+    return [visColors.euiColorVisCool2];
   } else if (steps <= 3) {
-    return euiPalette([cools[0], lightRedColor], steps, true);
+    return euiPalette([visColors.euiColorVisCool2, visColors.euiColorVisWarm2], steps, true);
   }
-  return euiPalette([].concat(_toConsumableArray(cools), _toConsumableArray(warms)), steps, true);
+  var cools = colorPalette([visColors.euiColorVisCool2, visColors.euiColorVisCool1, visColors.euiColorVisCool0], 3);
+  var warms = colorPalette([visColors.euiColorVisWarm0, visColors.euiColorVisWarm1, visColors.euiColorVisWarm2], 3);
+  var paletteColors = hasVisColorAdjustment ? [].concat(_toConsumableArray(cools), _toConsumableArray(warms)) : [].concat(_toConsumableArray(cools), [visColors.euiColorVisNeutral0], _toConsumableArray(warms));
+  return euiPalette(paletteColors, steps, true);
 };
+
+/**
+ * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
+ * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
+ */
 export var euiPaletteComplementary = function euiPaletteComplementary(steps) {
+  var hasVisColorAdjustment = EUI_VIS_COLOR_STORE.hasVisColorAdjustment,
+    visColors = EUI_VIS_COLOR_STORE.visColors;
   if (steps === 1) {
-    return [euiPaletteColorBlind()[1]];
+    return [visColors.euiColorVisComplementary0];
   }
-  return euiPalette([euiPaletteColorBlind()[1], euiPaletteColorBlind()[7]], steps, true);
+  var paletteColors = hasVisColorAdjustment ? [visColors.euiColorVisComplementary0, visColors.euiColorVisComplementary1] : [visColors.euiColorVisComplementary0, visColors.euiColorVisNeutral0, visColors.euiColorVisComplementary1];
+  return euiPalette(paletteColors, steps, true);
 };
+
+/**
+ * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
+ * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
+ */
 export var euiPaletteRed = function euiPaletteRed(steps) {
+  var visColors = EUI_VIS_COLOR_STORE.visColors;
   if (steps === 1) {
-    return [lightRedColor];
+    return [visColors.euiColorVisDanger1];
   }
-  return euiPalette(['white', redColor], steps);
+  return euiPalette([visColors.euiColorVisNeutral0, visColors.euiColorVisDanger0], steps);
 };
+
+/**
+ * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
+ * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
+ */
 export var euiPaletteGreen = function euiPaletteGreen(steps) {
+  var visColors = EUI_VIS_COLOR_STORE.visColors;
   if (steps === 1) {
-    return [euiPaletteColorBlind()[0]];
+    return [visColors.euiColorVisSuccess1];
   }
-  return euiPalette(['white', greenColor], steps);
+  return euiPalette([visColors.euiColorVisNeutral0, visColors.euiColorVisSuccess0], steps);
 };
+
+/**
+ * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
+ * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
+ */
 export var euiPaletteCool = function euiPaletteCool(steps) {
+  var hasVisColorAdjustment = EUI_VIS_COLOR_STORE.hasVisColorAdjustment,
+    visColors = EUI_VIS_COLOR_STORE.visColors;
   if (steps === 1) {
-    return [coolArray[1]];
+    return [visColors.euiColorVisCool1];
   }
-  return euiPalette(['white'].concat(coolArray), steps);
+  return euiPalette([hasVisColorAdjustment ? visColors.euiColorVisNeutral0 : visColors.euiColorVisCool0, visColors.euiColorVisCool1, visColors.euiColorVisCool2], steps);
 };
+
+/**
+ * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
+ * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
+ */
 export var euiPaletteWarm = function euiPaletteWarm(steps) {
+  var visColors = EUI_VIS_COLOR_STORE.visColors;
   if (steps === 1) {
-    return [lightRedColor];
+    return [visColors.euiColorVisWarm2];
   }
-  return euiPalette(['#FBFBDC'].concat(warmArray), steps);
+  return euiPalette([visColors.euiColorVisWarm0, visColors.euiColorVisWarm1, visColors.euiColorVisWarm2], steps);
 };
+
+/**
+ * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
+ * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
+ */
 export var euiPaletteGray = function euiPaletteGray(steps) {
+  var visColors = EUI_VIS_COLOR_STORE.visColors;
   if (steps === 1) {
-    return ['#98a2b3'];
+    return [visColors.euiColorVisGrey1];
   }
-  return euiPalette(['white', '#d3dae6', '#98a2b3', '#69707d', '#343741'], steps, false);
+  return euiPalette([visColors.euiColorVisNeutral0, visColors.euiColorVisGrey0, visColors.euiColorVisGrey1, visColors.euiColorVisGrey2, visColors.euiColorVisGrey3], steps, false);
 };

package/optimize/es/services/color/index.js

@@ -16,6 +16,7 @@ export { rgbToHex } from './rgb_to_hex';
 export { rgbToHsv } from './rgb_to_hsv';
 export { calculateContrast, calculateLuminance } from './luminance_and_contrast';
 export { VISUALIZATION_COLORS, DEFAULT_VISUALIZATION_COLOR } from './visualization_colors';
+export { EUI_VIS_COLOR_STORE } from './vis_color_store';
 export { colorPalette } from './color_palette';
 export { euiPaletteForLightBackground, euiPaletteForDarkBackground, euiPaletteColorBlind, euiPaletteColorBlindBehindText, euiPaletteForStatus, euiPaletteForTemperature, euiPaletteComplementary, euiPaletteRed, euiPaletteGreen, euiPaletteCool, euiPaletteWarm, euiPaletteGray } from './eui_palettes';
 export { getSteppedGradient } from './stepped_gradient';

package/optimize/es/services/color/vis_color_store.js

@@ -0,0 +1,13 @@
+/*
+ * 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.
+ */
+
+import { EuiVisColorStore } from '@elastic/eui-theme-common';
+import { colorVis } from '../../global_styling/variables/_colors_vis';
+
+// initialsetup of Vis color storage with default colors
+export var EUI_VIS_COLOR_STORE = EuiVisColorStore.getInstance(colorVis, true);

package/optimize/es/services/index.js

@@ -12,7 +12,7 @@ export { htmlIdGenerator, useGeneratedHtmlId } from './accessibility';
 export { CENTER_ALIGNMENT, LEFT_ALIGNMENT, RIGHT_ALIGNMENT } from './alignment';
 export { CurrentEuiBreakpointContext, CurrentEuiBreakpointProvider, useCurrentEuiBreakpoint, useIsWithinBreakpoints, useIsWithinMaxBreakpoint, useIsWithinMinBreakpoint } from './breakpoint';
 export { CanvasTextUtils } from './canvas';
-export { brighten, calculateContrast, calculateLuminance, colorPalette, darken, DEFAULT_VISUALIZATION_COLOR, desaturate, euiPaletteColorBlind, euiPaletteColorBlindBehindText, euiPaletteComplementary, euiPaletteCool, euiPaletteForDarkBackground, euiPaletteForLightBackground, euiPaletteForStatus, euiPaletteForTemperature, euiPaletteGray, euiPaletteRed, euiPaletteGreen, euiPaletteWarm, getSteppedGradient, hexToHsv, hexToRgb, hsvToHex, hsvToRgb, isColorDark, isValidHex, lightness, makeDisabledContrastColor, makeHighContrastColor, rgbToHex, rgbToHsv, saturate, shade, shadeOrTint, tint, tintOrShade, transparentize, VISUALIZATION_COLORS, wcagContrastMin } from './color';
+export { brighten, calculateContrast, calculateLuminance, colorPalette, darken, DEFAULT_VISUALIZATION_COLOR, desaturate, euiPaletteColorBlind, euiPaletteColorBlindBehindText, euiPaletteComplementary, euiPaletteCool, euiPaletteForDarkBackground, euiPaletteForLightBackground, euiPaletteForStatus, euiPaletteForTemperature, euiPaletteGray, euiPaletteRed, euiPaletteGreen, euiPaletteWarm, getSteppedGradient, hexToHsv, hexToRgb, hsvToHex, hsvToRgb, isColorDark, isValidHex, lightness, makeDisabledContrastColor, makeHighContrastColor, rgbToHex, rgbToHsv, saturate, shade, shadeOrTint, tint, tintOrShade, transparentize, VISUALIZATION_COLORS, EUI_VIS_COLOR_STORE, wcagContrastMin } from './color';
 export { useColorPickerState, useColorStopsState } from './color_picker';
 export * from './console';
 export * from './copy';

package/optimize/es/services/theme/provider.js

@@ -19,6 +19,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 import React, { useContext, useEffect, useRef, useMemo, useState, useCallback, Fragment } from 'react';
 import { Global } from '@emotion/react';
 import isEqual from 'lodash/isEqual';
+import { EUI_EXPERIMENTAL_THEME_ENABLED_KEY } from '../../themes/themes';
 import { cloneElementWithCss } from '../emotion';
 import { css, cx } from '../emotion/css';
 import { CurrentEuiBreakpointProvider } from '../breakpoint/current_breakpoint';
@@ -26,6 +27,7 @@ import { EuiSystemContext, EuiThemeContext, EuiNestedThemeContext, EuiModificati
 import { EuiEmotionThemeProvider } from './emotion';
 import { EuiThemeMemoizedStylesProvider } from './style_memoization';
 import { buildTheme, getColorMode, getComputed, mergeDeep } from './utils';
+import { EUI_VIS_COLOR_STORE } from '../color';
 import { jsx as ___EmotionJSX } from "@emotion/react";
 export var EuiThemeProvider = function EuiThemeProvider(_ref) {
   var _system = _ref.theme,
@@ -65,19 +67,41 @@ export var EuiThemeProvider = function EuiThemeProvider(_ref) {
     setColorMode = _useState6[1];
   var prevColorMode = useRef(colorMode);
   var isParentTheme = useRef(prevSystemKey.current === parentSystem.key && colorMode === parentColorMode && isEqual(parentModifications, modifications));
+  var updateVisColorStore = useCallback(function (theme) {
+    var _theme$flags$hasVisCo, _theme$flags;
+    EUI_VIS_COLOR_STORE.setVisColors(theme.colors.vis, (_theme$flags$hasVisCo = (_theme$flags = theme.flags) === null || _theme$flags === void 0 ? void 0 : _theme$flags.hasVisColorAdjustment) !== null && _theme$flags$hasVisCo !== void 0 ? _theme$flags$hasVisCo : true);
+  }, []);
+  var getInitialTheme = function getInitialTheme() {
+    var theme = getComputed(system, buildTheme(modifications, "_".concat(system.key)), colorMode);
+    setTimeout(function () {
+      updateVisColorStore(theme);
+    });
+    return theme;
+  };
   var _useState7 = useState(isParentTheme.current && Object.keys(parentTheme).length ? _objectSpread({}, parentTheme) // Intentionally create a new object to break referential equality
-    : getComputed(system, buildTheme(modifications, "_".concat(system.key)), colorMode)),
+    : getInitialTheme()),
     _useState8 = _slicedToArray(_useState7, 2),
     theme = _useState8[0],
     setTheme = _useState8[1];
+
+  // TODO: temp. testing code only, remove once obsolete
+  useEffect(function () {
+    if (process.env.NODE_ENV === 'development') {
+      var isEnabled = localStorage.getItem(EUI_EXPERIMENTAL_THEME_ENABLED_KEY) != null;
+      if (!isEnabled) {
+        localStorage.setItem(EUI_EXPERIMENTAL_THEME_ENABLED_KEY, 'true');
+      }
+    }
+  }, []);
   useEffect(function () {
     var newSystem = _system || parentSystem;
     if (prevSystemKey.current !== newSystem.key) {
       setSystem(newSystem);
       prevSystemKey.current = newSystem.key;
       isParentTheme.current = false;
+      updateVisColorStore(theme);
     }
-  }, [_system, parentSystem]);
+  }, [_system, parentSystem, theme, updateVisColorStore]);
   useEffect(function () {
     var newModifications = mergeDeep(parentModifications, _modifications);
     if (!isEqual(prevModifications.current, newModifications)) {

package/optimize/es/services/theme/types.js

@@ -5,9 +5,4 @@
  * in compliance with, at your election, the Elastic License 2.0 or the Server
  * Side Public License, v 1.
  */
-
-export var COLOR_MODES_STANDARD = {
-  light: 'LIGHT',
-  dark: 'DARK'
-};
-export var COLOR_MODES_INVERSE = 'INVERSE';
+export { COLOR_MODES_STANDARD, COLOR_MODES_INVERSE } from '@elastic/eui-theme-common';

package/optimize/es/services/theme/utils.js

@@ -1,10 +1,3 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _typeof from "@babel/runtime/helpers/typeof";
-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; }
 /*
  * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
  * or more contributor license agreements. Licensed under the Elastic License
@@ -13,291 +6,4 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
  * Side Public License, v 1.
  */
 
-import { COLOR_MODES_STANDARD, COLOR_MODES_INVERSE } from './types';
-export var DEFAULT_COLOR_MODE = COLOR_MODES_STANDARD.light;
-
-/**
- * Returns whether the parameter is an object
- * @param {any} obj - Anything
- */
-var isObject = function isObject(obj) {
-  return obj && _typeof(obj) === 'object';
-};
-
-/**
- * Returns whether the provided color mode is `inverse`
- * @param {string} colorMode - `light`, `dark`, or `inverse`
- */
-export var isInverseColorMode = function isInverseColorMode(colorMode) {
-  return colorMode === 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
- */
-export var getColorMode = function getColorMode(colorMode, parentColorMode) {
-  if (colorMode == null) {
-    return parentColorMode || DEFAULT_COLOR_MODE;
-  }
-  var mode = colorMode.toUpperCase();
-  if (isInverseColorMode(mode)) {
-    return parentColorMode === COLOR_MODES_STANDARD.dark || parentColorMode === undefined ? COLOR_MODES_STANDARD.light : COLOR_MODES_STANDARD.dark;
-  } else {
-    return mode;
-  }
-};
-
-/**
- * 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`
- */
-export var 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];
-      }
-    }
-  }
-  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
- */
-export var 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];
-  }
-  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
- */
-export var Computed = /*#__PURE__*/function () {
-  function Computed(computer) {
-    var dependencies = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    _classCallCheck(this, Computed);
-    this.computer = computer;
-    this.dependencies = dependencies;
-  }
-
-  /**
-   * 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 _createClass(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.
- */
-
-export 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`
- */
-export var 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(_toConsumableArray(Object.values(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);
-        }
-      }
-    });
-  }
-  // 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
- */
-export var 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
- */
-export var 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;
-  }
-  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;
-};
+export { DEFAULT_COLOR_MODE, isInverseColorMode, getColorMode, getOn, setOn, Computed, computed, getComputed, buildTheme, mergeDeep } from '@elastic/eui-theme-common';