@amboss/design-system 1.15.2 → 1.15.3

package/build/cjs/src/components/SegmentedProgressBar/SegmentedProgressBar.js

@@ -0,0 +1,110 @@
+'use strict';
+
+var _styled = require('@emotion/styled/base');
+var React = require('react');
+var SegmentedProgressBarUtil = require('./SegmentedProgressBarUtil.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var _styled__default = /*#__PURE__*/_interopDefault(_styled);
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+const defaultProps = {
+  "data-e2e-test-id": undefined,
+  weight: "fat",
+  squareCorners: false,
+  privateProps: {
+    monochrome: false
+  }
+};
+const getBackgroundColor = (theme, style, monochrome) => {
+  const monochromeColor = theme.values.color.segmentedProgressBar.monochrome;
+  switch (style) {
+    case "success":
+      return monochrome ? monochromeColor : theme.values.color.segmentedProgressBar.success;
+    case "warning":
+      return monochrome ? monochromeColor : theme.values.color.segmentedProgressBar.warning;
+    case "alert":
+      return monochrome ? monochromeColor : theme.values.color.segmentedProgressBar.alert;
+    case "inProgress":
+      return theme.values.color.segmentedProgressBar.inProgress;
+    default:
+      return theme.values.color.border.secondary.default;
+  }
+};
+const StyledSegmentedProgressBar = /*#__PURE__*/_styled__default.default("div", process.env.NODE_ENV === "production" ? {
+  target: "e101pf3g1"
+} : {
+  target: "e101pf3g1",
+  label: "StyledSegmentedProgressBar"
+})(_ref => {
+  let {
+    theme,
+    squareCorners,
+    weight
+  } = _ref;
+  return {
+    width: "100%",
+    display: "flex",
+    flexDirection: "row",
+    borderRadius: squareCorners ? 0 : theme.variables.size.borderRadius.progressBar,
+    overflow: "hidden",
+    height: weight === "thin" ? theme.variables.size.spacing.xxs : theme.variables.size.spacing.xs
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIlNlZ21lbnRlZFByb2dyZXNzQmFyLnRzeCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUErRW1DIiwiZmlsZSI6IlNlZ21lbnRlZFByb2dyZXNzQmFyLnRzeCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCBmcm9tIFwicmVhY3RcIjtcbmltcG9ydCBzdHlsZWQgZnJvbSBcIkBlbW90aW9uL3N0eWxlZFwiO1xuaW1wb3J0IHsgVGhlbWUgfSBmcm9tIFwiQGVtb3Rpb24vcmVhY3RcIjtcbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBpbXBvcnQvbm8tY3ljbGVcbmltcG9ydCB7XG4gIGdldFBlcmNlbnRhZ2VzRm9yVmFyaWFudHMsXG4gIHNhbml0aXplSW5wdXRWYWx1ZXMsXG59IGZyb20gXCIuL1NlZ21lbnRlZFByb2dyZXNzQmFyVXRpbFwiO1xuXG5leHBvcnQgdHlwZSBWYWx1ZXNWYXJpYW50ID0gXCJzdWNjZXNzXCIgfCBcIndhcm5pbmdcIiB8IFwiYWxlcnRcIjtcblxuZXhwb3J0IHR5cGUgU3R5bGVWYXJpYW50ID0gVmFsdWVzVmFyaWFudCB8IFwiaW5Qcm9ncmVzc1wiO1xuXG5leHBvcnQgdHlwZSBWYWx1ZSA9IG51bWJlcjtcblxuZXhwb3J0IHR5cGUgUHJvZ3Jlc3NCYXJXZWlnaHQgPSBcInRoaW5cIiB8IFwiZmF0XCI7XG5cbmV4cG9ydCB0eXBlIFNlZ21lbnRlZFByb2dyZXNzQmFyUHJvcHMgPSB7XG4gIC8qKiBUaGUgdmFsdWUgZm9yIDEwMCUgcHJvZ3Jlc3MuIENvbnN1bWVyIGRvZXMgbm90IG5lZWQgdG8gZG8gcGVyY2VudGFnZSBjYWxjdWxhdGlvbi5cbiAgICogSnVzdCBwYXNzIHRoaXMgbnVtYmVyIGFuZCBzb21lIHZhbHVlcy4gVGhlIHByb2dyZXNzIGJhciBkb2VzIGFsbCBwZXJjZW50YWcgY2FsY3VsYXRpb25zICovXG4gIG1heFZhbHVlOiBudW1iZXI7XG4gIC8qKiBUaGUgdmFsdWVzIGFscmVhZHkgcHJvZ3Jlc3NlZC4gUG9zc2libGUgVmFsdWVzVmFyaWFudHMgYXJlIHVzZWQgdG8gZGlzcGxheSBwcm9ncmVzcyBpbiBhIGRpZmZlcmVudCBjb2xvci5cbiAgICogVmFyaWFudHMgYXJlOlxuICAgKiBzdWNjZXNzID0+IGdyZWVuO1xuICAgKiB3YXJuaW5nID0+IHllbGxvdztcbiAgICogYWxlcnQgPT4gcmVkICovXG4gIHZhbHVlczogUGFydGlhbDxSZWNvcmQ8VmFsdWVzVmFyaWFudCwgVmFsdWU+PjtcbiAgc3F1YXJlQ29ybmVycz86IGJvb2xlYW47XG4gIHdlaWdodD86IFByb2dyZXNzQmFyV2VpZ2h0O1xuICBwcml2YXRlUHJvcHM/OiBTZWdtZW50ZWRQcm9ncmVzc0JhclByaXZhdGVQcm9wcztcbiAgXCJkYXRhLWUyZS10ZXN0LWlkXCI/OiBzdHJpbmc7XG59O1xuXG50eXBlIFNlZ21lbnRlZFByb2dyZXNzQmFyUHJpdmF0ZVByb3BzID0ge1xuICBtb25vY2hyb21lPzogYm9vbGVhbjtcbn07XG5cbnR5cGUgU2VnbWVudFByb3BzID0ge1xuICBzdHlsZVZhcmlhbnQ6IFN0eWxlVmFyaWFudDtcbiAgcGVyY2VudGFnZTogbnVtYmVyO1xuICBtb25vY2hyb21lOiBib29sZWFuO1xuICBcImRhdGEtZTJlLXRlc3QtaWRcIj86IHN0cmluZztcbn07XG5cbmNvbnN0IGRlZmF1bHRQcm9wczogUGFydGlhbDxTZWdtZW50ZWRQcm9ncmVzc0JhclByb3BzPiA9IHtcbiAgXCJkYXRhLWUyZS10ZXN0LWlkXCI6IHVuZGVmaW5lZCxcbiAgd2VpZ2h0OiBcImZhdFwiLFxuICBzcXVhcmVDb3JuZXJzOiBmYWxzZSxcbiAgcHJpdmF0ZVByb3BzOiB7XG4gICAgbW9ub2Nocm9tZTogZmFsc2UsXG4gIH0sXG59O1xuXG5jb25zdCBnZXRCYWNrZ3JvdW5kQ29sb3IgPSAoXG4gIHRoZW1lOiBUaGVtZSxcbiAgc3R5bGU6IFN0eWxlVmFyaWFudCxcbiAgbW9ub2Nocm9tZTogYm9vbGVhblxuKSA9PiB7XG4gIGNvbnN0IG1vbm9jaHJvbWVDb2xvciA9IHRoZW1lLnZhbHVlcy5jb2xvci5zZWdtZW50ZWRQcm9ncmVzc0Jhci5tb25vY2hyb21lO1xuICBzd2l0Y2ggKHN0eWxlKSB7XG4gICAgY2FzZSBcInN1Y2Nlc3NcIjpcbiAgICAgIHJldHVybiBtb25vY2hyb21lXG4gICAgICAgID8gbW9ub2Nocm9tZUNvbG9yXG4gICAgICAgIDogdGhlbWUudmFsdWVzLmNvbG9yLnNlZ21lbnRlZFByb2dyZXNzQmFyLnN1Y2Nlc3M7XG4gICAgY2FzZSBcIndhcm5pbmdcIjpcbiAgICAgIHJldHVybiBtb25vY2hyb21lXG4gICAgICAgID8gbW9ub2Nocm9tZUNvbG9yXG4gICAgICAgIDogdGhlbWUudmFsdWVzLmNvbG9yLnNlZ21lbnRlZFByb2dyZXNzQmFyLndhcm5pbmc7XG4gICAgY2FzZSBcImFsZXJ0XCI6XG4gICAgICByZXR1cm4gbW9ub2Nocm9tZVxuICAgICAgICA/IG1vbm9jaHJvbWVDb2xvclxuICAgICAgICA6IHRoZW1lLnZhbHVlcy5jb2xvci5zZWdtZW50ZWRQcm9ncmVzc0Jhci5hbGVydDtcbiAgICBjYXNlIFwiaW5Qcm9ncmVzc1wiOlxuICAgICAgcmV0dXJuIHRoZW1lLnZhbHVlcy5jb2xvci5zZWdtZW50ZWRQcm9ncmVzc0Jhci5pblByb2dyZXNzO1xuICAgIGRlZmF1bHQ6XG4gICAgICByZXR1cm4gdGhlbWUudmFsdWVzLmNvbG9yLmJvcmRlci5zZWNvbmRhcnkuZGVmYXVsdDtcbiAgfVxufTtcblxuY29uc3QgU3R5bGVkU2VnbWVudGVkUHJvZ3Jlc3NCYXIgPSBzdHlsZWQuZGl2PFxuICBQYXJ0aWFsPFNlZ21lbnRlZFByb2dyZXNzQmFyUHJvcHM+XG4+KCh7IHRoZW1lLCBzcXVhcmVDb3JuZXJzLCB3ZWlnaHQgfSkgPT4gKHtcbiAgd2lkdGg6IFwiMTAwJVwiLFxuICBkaXNwbGF5OiBcImZsZXhcIixcbiAgZmxleERpcmVjdGlvbjogXCJyb3dcIixcbiAgYm9yZGVyUmFkaXVzOiBzcXVhcmVDb3JuZXJzXG4gICAgPyAwXG4gICAgOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5ib3JkZXJSYWRpdXMucHJvZ3Jlc3NCYXIsXG4gIG92ZXJmbG93OiBcImhpZGRlblwiLFxuICBoZWlnaHQ6XG4gICAgd2VpZ2h0ID09PSBcInRoaW5cIlxuICAgICAgPyB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnh4c1xuICAgICAgOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnhzLFxufSkpO1xuXG5jb25zdCBTdHlsZWRTZWdtZW50ID0gc3R5bGVkLmRpdjxQYXJ0aWFsPFNlZ21lbnRQcm9wcz4+KFxuICAoeyB0aGVtZSwgc3R5bGVWYXJpYW50LCBwZXJjZW50YWdlLCBtb25vY2hyb21lIH0pID0+ICh7XG4gICAgaGVpZ2h0OiBcIjEwMCVcIixcbiAgICBiYWNrZ3JvdW5kQ29sb3I6IGdldEJhY2tncm91bmRDb2xvcih0aGVtZSwgc3R5bGVWYXJpYW50LCBtb25vY2hyb21lKSxcbiAgICB3aWR0aDogYCR7cGVyY2VudGFnZX0lYCxcbiAgfSlcbik7XG5cbmV4cG9ydCBmdW5jdGlvbiBTZWdtZW50ZWRQcm9ncmVzc0Jhcih7XG4gIG1heFZhbHVlLFxuICB2YWx1ZXMsXG4gIHdlaWdodCxcbiAgc3F1YXJlQ29ybmVycyxcbiAgcHJpdmF0ZVByb3BzOiB7IG1vbm9jaHJvbWUgfSxcbiAgXCJkYXRhLWUyZS10ZXN0LWlkXCI6IGRhdGFFMmVUZXN0SWQsXG59OiBTZWdtZW50ZWRQcm9ncmVzc0JhclByb3BzKTogUmVhY3QuUmVhY3RFbGVtZW50IHtcbiAgY29uc3QgeyBzYW5pdGl6ZWRNYXhWYWx1ZSwgc2FuaXRpemVkVmFsdWVzIH0gPSBzYW5pdGl6ZUlucHV0VmFsdWVzKFxuICAgIG1heFZhbHVlLFxuICAgIHZhbHVlc1xuICApO1xuXG4gIGNvbnN0IHBlcmNlbnRhZ2VzOiB7XG4gICAgcGVyY2VudGFnZTogbnVtYmVyO1xuICAgIHN0eWxlOiBTdHlsZVZhcmlhbnQ7XG4gIH1bXSA9IGdldFBlcmNlbnRhZ2VzRm9yVmFyaWFudHMoc2FuaXRpemVkTWF4VmFsdWUsIHNhbml0aXplZFZhbHVlcyk7XG5cbiAgcmV0dXJuIChcbiAgICA8U3R5bGVkU2VnbWVudGVkUHJvZ3Jlc3NCYXJcbiAgICAgIGRhdGEtZTJlLXRlc3QtaWQ9e2RhdGFFMmVUZXN0SWR9XG4gICAgICBkYXRhLWRzLWlkPVwiU2VnbWVudGVkUHJvZ3Jlc3NCYXJcIlxuICAgICAgc3F1YXJlQ29ybmVycz17c3F1YXJlQ29ybmVyc31cbiAgICAgIHdlaWdodD17d2VpZ2h0fVxuICAgID5cbiAgICAgIHtwZXJjZW50YWdlcy5tYXAoKHsgcGVyY2VudGFnZSwgc3R5bGUgfSkgPT4gKFxuICAgICAgICA8U3R5bGVkU2VnbWVudFxuICAgICAgICAgIGtleT17c3R5bGV9XG4gICAgICAgICAgZGF0YS1lMmUtdGVzdC1pZD17c3R5bGUgYXMgc3RyaW5nfVxuICAgICAgICAgIHN0eWxlVmFyaWFudD17c3R5bGV9XG4gICAgICAgICAgbW9ub2Nocm9tZT17bW9ub2Nocm9tZX1cbiAgICAgICAgICBwZXJjZW50YWdlPXtwZXJjZW50YWdlfVxuICAgICAgICAvPlxuICAgICAgKSl9XG4gICAgPC9TdHlsZWRTZWdtZW50ZWRQcm9ncmVzc0Jhcj5cbiAgKTtcbn1cblxuU2VnbWVudGVkUHJvZ3Jlc3NCYXIuZGVmYXVsdFByb3BzID0gZGVmYXVsdFByb3BzO1xuIl19 */");
+const StyledSegment = /*#__PURE__*/_styled__default.default("div", process.env.NODE_ENV === "production" ? {
+  target: "e101pf3g0"
+} : {
+  target: "e101pf3g0",
+  label: "StyledSegment"
+})(_ref2 => {
+  let {
+    theme,
+    styleVariant,
+    percentage,
+    monochrome
+  } = _ref2;
+  return {
+    height: "100%",
+    backgroundColor: getBackgroundColor(theme, styleVariant, monochrome),
+    width: `${percentage}%`
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+function SegmentedProgressBar(_ref3) {
+  let {
+    maxValue,
+    values,
+    weight,
+    squareCorners,
+    privateProps: {
+      monochrome
+    },
+    "data-e2e-test-id": dataE2eTestId
+  } = _ref3;
+  const {
+    sanitizedMaxValue,
+    sanitizedValues
+  } = SegmentedProgressBarUtil.sanitizeInputValues(maxValue, values);
+  const percentages = SegmentedProgressBarUtil.getPercentagesForVariants(sanitizedMaxValue, sanitizedValues);
+  return /*#__PURE__*/React__default.default.createElement(StyledSegmentedProgressBar, {
+    "data-e2e-test-id": dataE2eTestId,
+    "data-ds-id": "SegmentedProgressBar",
+    squareCorners: squareCorners,
+    weight: weight
+  }, percentages.map(_ref4 => {
+    let {
+      percentage,
+      style
+    } = _ref4;
+    return /*#__PURE__*/React__default.default.createElement(StyledSegment, {
+      key: style,
+      "data-e2e-test-id": style,
+      styleVariant: style,
+      monochrome: monochrome,
+      percentage: percentage
+    });
+  }));
+}
+SegmentedProgressBar.defaultProps = defaultProps;
+
+exports.SegmentedProgressBar = SegmentedProgressBar;

package/build/cjs/src/components/SegmentedProgressBar/SegmentedProgressBarUtil.js

@@ -0,0 +1,42 @@
+'use strict';
+
+// eslint-disable-next-line import/no-cycle
+
+const variants = ["success", "warning", "alert"];
+const getTotalFilledValue = values => variants.reduce((currentValue, variant) => values[variant] && values[variant] > 0 ? currentValue + values[variant] : currentValue, 0);
+const getPercentagesForVariants = (maxValue, values) => {
+  const result = variants.map(variant => {
+    const percentage = 100 * values[variant] / maxValue;
+    return percentage > 0 ? {
+      percentage,
+      style: variant
+    } : null;
+  });
+  const usedPercentage = result.reduce((currentValue, item) => currentValue + (item ? item.percentage : 0), 0);
+
+  // add a last segment for the remaing percentage
+  if (usedPercentage < 100) {
+    result.push({
+      percentage: 100 - usedPercentage,
+      style: "inProgress"
+    });
+  }
+
+  // we need to filter out the null values.
+  return result.filter(Boolean);
+};
+const sanitizeInputValues = (maxValue, values) => {
+  const totalFilledValue = getTotalFilledValue(values);
+  const sanitizedMaxValue = maxValue > totalFilledValue ? maxValue : totalFilledValue;
+  const sanitizedValues = {};
+  variants.forEach(variant => {
+    sanitizedValues[variant] = values[variant] && values[variant] > 0 ? values[variant] : 0;
+  });
+  return {
+    sanitizedMaxValue,
+    sanitizedValues
+  };
+};
+
+exports.getPercentagesForVariants = getPercentagesForVariants;
+exports.sanitizeInputValues = sanitizeInputValues;

package/build/cjs/src/components/Stack/Stack.js

@@ -0,0 +1,80 @@
+'use strict';
+
+var _styled = require('@emotion/styled/base');
+var React = require('react');
+var flattenChildren = require('../../shared/flattenChildren.js');
+var mediaQueries = require('../../shared/mediaQueries.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var _styled__default = /*#__PURE__*/_interopDefault(_styled);
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+const defaultProps = {
+  space: "xs",
+  "data-e2e-test-id": undefined,
+  "data-ds-id": "Stack"
+};
+const StackContainer = /*#__PURE__*/_styled__default.default("div", process.env.NODE_ENV === "production" ? {
+  target: "earxui51"
+} : {
+  target: "earxui51",
+  label: "StackContainer"
+})(_ref => {
+  let {
+    alignItems
+  } = _ref;
+  return {
+    ...mediaQueries.mq({
+      alignItems: [alignItems, {
+        left: "flex-start",
+        right: "flex-end",
+        center: "center",
+        spaceBetween: "space-between"
+      }]
+    }),
+    display: "flex",
+    flexDirection: "column"
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const StackItem = /*#__PURE__*/_styled__default.default("div", process.env.NODE_ENV === "production" ? {
+  target: "earxui50"
+} : {
+  target: "earxui50",
+  label: "StackItem"
+})(_ref2 => {
+  let {
+    theme,
+    space
+  } = _ref2;
+  return {
+    ...mediaQueries.mq({
+      marginTop: [space, theme.variables.size.spacing]
+    }),
+    "&:first-of-type": {
+      marginTop: 0
+    },
+    "&:empty": {
+      marginTop: 0
+    }
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+function Stack(_ref3) {
+  let {
+    children,
+    space,
+    alignItems,
+    "data-e2e-test-id": dataE2eTestId,
+    "data-ds-id": dataDsId
+  } = _ref3;
+  return /*#__PURE__*/React__default.default.createElement(StackContainer, {
+    "data-e2e-test-id": dataE2eTestId,
+    "data-ds-id": dataDsId,
+    alignItems: alignItems
+  }, React__default.default.Children.map(flattenChildren.flattenChildren(children), child => child && /*#__PURE__*/React__default.default.createElement(StackItem, {
+    space: space
+  }, child)));
+}
+Stack.defaultProps = defaultProps;
+
+exports.Stack = Stack;

package/build/cjs/src/components/SubThemeProvider/SubThemeProvider.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var React = require('react');
+var react = require('@emotion/react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+/* eslint-disable no-restricted-syntax */
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+function mergeDeep(target) {
+  for (var _len = arguments.length, sources = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    sources[_key - 1] = arguments[_key];
+  }
+  if (!sources.length) return target;
+  const source = sources.shift();
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!target[key]) Object.assign(target, {
+          [key]: {}
+        });
+        mergeDeep(target[key], source[key]);
+      } else {
+        Object.assign(target, {
+          [key]: source[key]
+        });
+      }
+    }
+  }
+  return mergeDeep(target, ...sources);
+}
+const subThemeCreator = (parentTheme, name) => mergeDeep({}, parentTheme, {
+  values: {
+    ...parentTheme.values.subThemes[name]
+  }
+});
+function SubThemeProvider(_ref) {
+  let {
+    name,
+    children,
+    "data-e2e-test-id": dataE2eTestId
+  } = _ref;
+  return /*#__PURE__*/React__default.default.createElement(react.ThemeProvider, {
+    theme: parentTheme => subThemeCreator(parentTheme, name)
+  }, /*#__PURE__*/React__default.default.createElement("div", {
+    "data-e2e-test-id": dataE2eTestId,
+    "data-ds-id": "SubThemeProvider"
+  }, children));
+}
+
+exports.SubThemeProvider = SubThemeProvider;

package/build/cjs/src/components/Tabs/Tabs.js

@@ -0,0 +1,137 @@
+'use strict';
+
+var _extends = require('@babel/runtime/helpers/extends');
+var _styled = require('@emotion/styled/base');
+var React = require('react');
+var mediaQueries = require('../../shared/mediaQueries.js');
+var Icon = require('../Icon/Icon.js');
+var Stack = require('../Stack/Stack.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var _extends__default = /*#__PURE__*/_interopDefault(_extends);
+var _styled__default = /*#__PURE__*/_interopDefault(_styled);
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+const BORDER_BOTTOM_WIDTH = 4;
+const StyledContainer = /*#__PURE__*/_styled__default.default("div", process.env.NODE_ENV === "production" ? {
+  target: "epth01"
+} : {
+  target: "epth01",
+  label: "StyledContainer"
+})(_ref => {
+  let {
+    theme,
+    horizontalPadding
+  } = _ref;
+  return {
+    display: "flex",
+    flexDirection: "row",
+    ...mediaQueries.mq({
+      gap: [["m", "l", "l"], theme.variables.size.spacing],
+      paddingInline: [horizontalPadding, theme.variables.size.spacing]
+    }),
+    paddingTop: theme.variables.size.spacing.m,
+    borderBottom: `1px solid ${theme.values.color.border.secondary.default}`,
+    whiteSpace: "nowrap",
+    // Scrollbar
+    overflow: "auto",
+    scrollbarWidth: "none",
+    // Firefox
+    msOverflowStyle: "none",
+    // IE 10+
+    "::-webkit-scrollbar": {
+      display: "none" // Chrome
+    }
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const StyledTab = /*#__PURE__*/_styled__default.default("button", process.env.NODE_ENV === "production" ? {
+  target: "epth00"
+} : {
+  target: "epth00",
+  label: "StyledTab"
+})(_ref2 => {
+  let {
+    theme,
+    active
+  } = _ref2;
+  return {
+    display: "flex",
+    gap: theme.variables.size.spacing.xxs,
+    alignItems: "center",
+    background: 0,
+    border: 0,
+    boxSizing: "border-box",
+    color: theme.values.color.text.secondary.default,
+    padding: 0,
+    fontFamily: theme.variables.fontFamily.lato,
+    fontWeight: theme.variables.weight.bold,
+    fontSize: theme.variables.size.font.text.s,
+    lineHeight: theme.variables.size.lineHeight.text.s,
+    transition: "background-color 0.15s",
+    textDecoration: "none",
+    // Required to maintain consistent height for the selected tab
+    borderBottom: `${BORDER_BOTTOM_WIDTH}px solid transparent`,
+    paddingBottom: `calc(${theme.variables.size.spacing.m} - ${BORDER_BOTTOM_WIDTH}px)`,
+    ...(active && {
+      color: theme.values.color.text.accent.default,
+      borderBottom: `${BORDER_BOTTOM_WIDTH}px solid ${theme.values.color.background.accent.default}`
+    }),
+    ...(!active && {
+      cursor: "pointer",
+      "&:hover": {
+        color: theme.values.color.text.primary.default,
+        borderBottom: `${BORDER_BOTTOM_WIDTH}px solid ${theme.values.color.background.transparent.hover}`
+      },
+      "&:active": {
+        color: theme.values.color.text.primary.default,
+        borderBottom: `${BORDER_BOTTOM_WIDTH}px  solid ${theme.values.color.background.highlight.default}`
+      }
+    })
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const addSubtitle = text => text ? `(${text})` : ``;
+
+/**
+ * @param label - The text to display in the tab
+ * @param sublabel - A subtext, encased in parentheses
+ * @param icon - An icon to display to the left of the label
+ * @param as - The element to render the tab as, defaults to `button`
+ */
+
+function Tabs(_ref3) {
+  let {
+    tabs,
+    horizontalPadding,
+    activeTab = 0,
+    children,
+    onTabSelect,
+    "data-e2e-test-id": dataE2eTestId
+  } = _ref3;
+  return /*#__PURE__*/React__default.default.createElement(Stack.Stack, {
+    "data-e2e-test-id": dataE2eTestId,
+    "data-ds-id": "Tabs"
+  }, /*#__PURE__*/React__default.default.createElement(StyledContainer, {
+    horizontalPadding: horizontalPadding
+  }, tabs.map((_ref4, i) => {
+    let {
+      label,
+      sublabel,
+      icon,
+      as = "button",
+      ...rest
+    } = _ref4;
+    return /*#__PURE__*/React__default.default.createElement(StyledTab, _extends__default.default({
+      type: as !== "button" ? undefined : "button",
+      as: as,
+      key: label,
+      active: activeTab === i,
+      onClick: () => onTabSelect && onTabSelect(i)
+    }, rest), icon && /*#__PURE__*/React__default.default.createElement(Icon.Icon, {
+      size: "s",
+      name: icon
+    }), label, " ", addSubtitle(sublabel));
+  })), children);
+}
+
+exports.Tabs = Tabs;

package/build/cjs/src/components/Tag/Tag.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var _styled = require('@emotion/styled/base');
+var React = require('react');
+var PictogramButton = require('../PictogramButton/PictogramButton.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var _styled__default = /*#__PURE__*/_interopDefault(_styled);
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+const TagContainer = /*#__PURE__*/_styled__default.default("span", process.env.NODE_ENV === "production" ? {
+  target: "e1i6narj2"
+} : {
+  target: "e1i6narj2",
+  label: "TagContainer"
+})(_ref => {
+  let {
+    theme,
+    colorVariant,
+    isRemovable
+  } = _ref;
+  return {
+    display: "inline-flex",
+    alignItems: "center",
+    maxWidth: "200px",
+    paddingLeft: theme.variables.size.spacing.xs,
+    paddingRight: isRemovable ? theme.variables.size.spacing.zero : theme.variables.size.spacing.xs,
+    paddingTop: isRemovable ? theme.variables.size.spacing.zero : theme.variables.size.spacing.xxs,
+    paddingBottom: isRemovable ? theme.variables.size.spacing.zero : theme.variables.size.spacing.xxs,
+    borderRadius: theme.variables.size.borderRadius.xs,
+    backgroundColor: theme.values.color.tag.background[colorVariant],
+    color: theme.values.color.tag.text[colorVariant],
+    fontFamily: theme.variables.fontFamily.lato,
+    fontSize: theme.variables.size.font.text.s,
+    lineHeight: theme.variables.size.lineHeight.text.xs
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const TagLabel = /*#__PURE__*/_styled__default.default("span", process.env.NODE_ENV === "production" ? {
+  target: "e1i6narj1"
+} : {
+  target: "e1i6narj1",
+  label: "TagLabel"
+})(() => ({
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  whiteSpace: "nowrap"
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIlRhZy50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBK0NpQiIsImZpbGUiOiJUYWcudHN4Iiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IHN0eWxlZCBmcm9tIFwiQGVtb3Rpb24vc3R5bGVkXCI7XG5pbXBvcnQgeyBQaWN0b2dyYW1CdXR0b24gfSBmcm9tIFwiLi4vUGljdG9ncmFtQnV0dG9uL1BpY3RvZ3JhbUJ1dHRvblwiO1xuXG50eXBlIEJhc2VUYWdQcm9wcyA9IHtcbiAgbGFiZWw6IHN0cmluZztcbiAgY29sb3JWYXJpYW50PzogXCJncmF5XCIgfCBcImJsdWVcIjtcbiAgXCJkYXRhLWUyZS10ZXN0LWlkXCI/OiBzdHJpbmc7XG59O1xudHlwZSBDb25kaXRpb25hbFRhZ1Byb3BzID1cbiAgfCB7XG4gICAgICBpc1JlbW92YWJsZT86IGZhbHNlO1xuICAgICAgb25DbGVhcj86IG5ldmVyO1xuICAgICAgY2xlYXJCdG5BcmlhTGFiZWw/OiBuZXZlcjtcbiAgICB9XG4gIHwge1xuICAgICAgaXNSZW1vdmFibGU6IHRydWU7XG4gICAgICBvbkNsZWFyOiAoKSA9PiB2b2lkO1xuICAgICAgY2xlYXJCdG5BcmlhTGFiZWw/OiBzdHJpbmc7XG4gICAgfTtcblxuZXhwb3J0IHR5cGUgVGFnUHJvcHMgPSBCYXNlVGFnUHJvcHMgJiBDb25kaXRpb25hbFRhZ1Byb3BzO1xuXG5jb25zdCBUYWdDb250YWluZXIgPSBzdHlsZWQuc3BhbjxQYXJ0aWFsPFRhZ1Byb3BzPj4oXG4gICh7IHRoZW1lLCBjb2xvclZhcmlhbnQsIGlzUmVtb3ZhYmxlIH0pID0+ICh7XG4gICAgZGlzcGxheTogXCJpbmxpbmUtZmxleFwiLFxuICAgIGFsaWduSXRlbXM6IFwiY2VudGVyXCIsXG4gICAgbWF4V2lkdGg6IFwiMjAwcHhcIixcbiAgICBwYWRkaW5nTGVmdDogdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy54cyxcbiAgICBwYWRkaW5nUmlnaHQ6IGlzUmVtb3ZhYmxlXG4gICAgICA/IHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcuemVyb1xuICAgICAgOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnhzLFxuICAgIHBhZGRpbmdUb3A6IGlzUmVtb3ZhYmxlXG4gICAgICA/IHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcuemVyb1xuICAgICAgOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnh4cyxcbiAgICBwYWRkaW5nQm90dG9tOiBpc1JlbW92YWJsZVxuICAgICAgPyB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnplcm9cbiAgICAgIDogdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy54eHMsXG4gICAgYm9yZGVyUmFkaXVzOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5ib3JkZXJSYWRpdXMueHMsXG4gICAgYmFja2dyb3VuZENvbG9yOiB0aGVtZS52YWx1ZXMuY29sb3IudGFnLmJhY2tncm91bmRbY29sb3JWYXJpYW50XSxcbiAgICBjb2xvcjogdGhlbWUudmFsdWVzLmNvbG9yLnRhZy50ZXh0W2NvbG9yVmFyaWFudF0sXG4gICAgZm9udEZhbWlseTogdGhlbWUudmFyaWFibGVzLmZvbnRGYW1pbHkubGF0byxcbiAgICBmb250U2l6ZTogdGhlbWUudmFyaWFibGVzLnNpemUuZm9udC50ZXh0LnMsXG4gICAgbGluZUhlaWdodDogdGhlbWUudmFyaWFibGVzLnNpemUubGluZUhlaWdodC50ZXh0LnhzLFxuICB9KVxuKTtcblxuY29uc3QgVGFnTGFiZWwgPSBzdHlsZWQuc3BhbigoKSA9PiAoe1xuICBvdmVyZmxvdzogXCJoaWRkZW5cIixcbiAgdGV4dE92ZXJmbG93OiBcImVsbGlwc2lzXCIsXG4gIHdoaXRlU3BhY2U6IFwibm93cmFwXCIsXG59KSk7XG5cbmNvbnN0IENsZWFyQnV0dG9uID0gc3R5bGVkKFBpY3RvZ3JhbUJ1dHRvbik8UGFydGlhbDxUYWdQcm9wcz4+KFxuICAoeyB0aGVtZSwgY29sb3JWYXJpYW50IH0pID0+ICh7XG4gICAgYmFja2dyb3VuZENvbG9yOiBcInRyYW5zcGFyZW50XCIsXG4gICAgY29sb3I6IHRoZW1lLnZhbHVlcy5jb2xvci50YWcudGV4dFtjb2xvclZhcmlhbnRdLFxuICAgIFwiJjpob3ZlclwiOiB7XG4gICAgICBjb2xvcjogdGhlbWUudmFsdWVzLmNvbG9yLnRhZy50ZXh0W2NvbG9yVmFyaWFudF0sXG4gICAgfSxcbiAgfSlcbik7XG5cbmV4cG9ydCBmdW5jdGlvbiBUYWcoe1xuICBsYWJlbCxcbiAgY29sb3JWYXJpYW50ID0gXCJncmF5XCIsXG4gIGlzUmVtb3ZhYmxlID0gZmFsc2UsXG4gIG9uQ2xlYXIsXG4gIGNsZWFyQnRuQXJpYUxhYmVsLFxuICBcImRhdGEtZTJlLXRlc3QtaWRcIjogZGF0YUUyZVRlc3RJZCxcbn06IFRhZ1Byb3BzKTogUmVhY3QuUmVhY3RFbGVtZW50IHtcbiAgcmV0dXJuIChcbiAgICA8VGFnQ29udGFpbmVyXG4gICAgICBkYXRhLWUyZS10ZXN0LWlkPXtkYXRhRTJlVGVzdElkfVxuICAgICAgZGF0YS1kcy1pZD1cIlRhZ1wiXG4gICAgICBjb2xvclZhcmlhbnQ9e2NvbG9yVmFyaWFudH1cbiAgICAgIGlzUmVtb3ZhYmxlPXtpc1JlbW92YWJsZX1cbiAgICA+XG4gICAgICA8VGFnTGFiZWw+e2xhYmVsfTwvVGFnTGFiZWw+XG5cbiAgICAgIHtpc1JlbW92YWJsZSAmJiAoXG4gICAgICAgIDxDbGVhckJ1dHRvblxuICAgICAgICAgIGljb249XCJ4XCJcbiAgICAgICAgICBzaXplPVwieHNcIlxuICAgICAgICAgIGFyaWEtbGFiZWw9e2NsZWFyQnRuQXJpYUxhYmVsfVxuICAgICAgICAgIG9uQ2xpY2s9e29uQ2xlYXJ9XG4gICAgICAgICAgY29sb3JWYXJpYW50PXtjb2xvclZhcmlhbnR9XG4gICAgICAgIC8+XG4gICAgICApfVxuICAgIDwvVGFnQ29udGFpbmVyPlxuICApO1xufVxuIl19 */");
+const ClearButton = /*#__PURE__*/_styled__default.default(PictogramButton.PictogramButton, process.env.NODE_ENV === "production" ? {
+  target: "e1i6narj0"
+} : {
+  target: "e1i6narj0",
+  label: "ClearButton"
+})(_ref2 => {
+  let {
+    theme,
+    colorVariant
+  } = _ref2;
+  return {
+    backgroundColor: "transparent",
+    color: theme.values.color.tag.text[colorVariant],
+    "&:hover": {
+      color: theme.values.color.tag.text[colorVariant]
+    }
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+function Tag(_ref3) {
+  let {
+    label,
+    colorVariant = "gray",
+    isRemovable = false,
+    onClear,
+    clearBtnAriaLabel,
+    "data-e2e-test-id": dataE2eTestId
+  } = _ref3;
+  return /*#__PURE__*/React__default.default.createElement(TagContainer, {
+    "data-e2e-test-id": dataE2eTestId,
+    "data-ds-id": "Tag",
+    colorVariant: colorVariant,
+    isRemovable: isRemovable
+  }, /*#__PURE__*/React__default.default.createElement(TagLabel, null, label), isRemovable && /*#__PURE__*/React__default.default.createElement(ClearButton, {
+    icon: "x",
+    size: "xs",
+    "aria-label": clearBtnAriaLabel,
+    onClick: onClear,
+    colorVariant: colorVariant
+  }));
+}
+
+exports.Tag = Tag;