@cloudtower/eagle 4100.0.18 → 4100.0.19

package/dist/esm/core/LineChart/areaHighlightUtils.js

@@ -0,0 +1,87 @@
+const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const getLineChartInterpolatedValue = (currentPoint, nextPoint, timestamp) => {
+  if (!isFiniteNumber(currentPoint.v) || !isFiniteNumber(nextPoint.v) || currentPoint.t === nextPoint.t) {
+    return void 0;
+  }
+  if (timestamp === currentPoint.t) {
+    return currentPoint.v;
+  }
+  if (timestamp === nextPoint.t) {
+    return nextPoint.v;
+  }
+  const ratio = (timestamp - currentPoint.t) / (nextPoint.t - currentPoint.t);
+  return currentPoint.v + (nextPoint.v - currentPoint.v) * ratio;
+};
+const isSameAreaHighlightPoint = (prev, next) => {
+  if (!prev) {
+    return false;
+  }
+  return Math.abs(prev.t - next.t) < 1e-6 && Math.abs(prev.value - next.value) < 1e-6;
+};
+const pushLineChartAreaHighlightPoint = (points, next) => {
+  if (!isSameAreaHighlightPoint(points[points.length - 1], next)) {
+    points.push(next);
+  }
+};
+const getLineChartAreaHighlightPointRuns = (points, range) => {
+  const runs = [];
+  let highlightedPoints = [];
+  const flushHighlightedPoints = () => {
+    if (highlightedPoints.length >= 2) {
+      runs.push(highlightedPoints);
+    }
+    highlightedPoints = [];
+  };
+  for (let index = 0; index < points.length - 1; index++) {
+    const currentPoint = points[index];
+    const nextPoint = points[index + 1];
+    if (!isFiniteNumber(currentPoint == null ? void 0 : currentPoint.t) || !isFiniteNumber(nextPoint == null ? void 0 : nextPoint.t) || !isFiniteNumber(currentPoint == null ? void 0 : currentPoint.v) || !isFiniteNumber(nextPoint == null ? void 0 : nextPoint.v) || currentPoint.t === nextPoint.t) {
+      flushHighlightedPoints();
+      continue;
+    }
+    if (nextPoint.t < range.start || currentPoint.t > range.end) {
+      continue;
+    }
+    const segmentStart = Math.max(range.start, currentPoint.t);
+    const segmentEnd = Math.min(range.end, nextPoint.t);
+    if (segmentStart >= segmentEnd) {
+      continue;
+    }
+    const startValue = getLineChartInterpolatedValue(
+      currentPoint,
+      nextPoint,
+      segmentStart
+    );
+    const endValue = getLineChartInterpolatedValue(
+      currentPoint,
+      nextPoint,
+      segmentEnd
+    );
+    if (!isFiniteNumber(startValue) || !isFiniteNumber(endValue)) {
+      flushHighlightedPoints();
+      continue;
+    }
+    const startPoint = {
+      t: segmentStart,
+      value: startValue
+    };
+    const endPoint = {
+      t: segmentEnd,
+      value: endValue
+    };
+    if (highlightedPoints.length && isSameAreaHighlightPoint(
+      highlightedPoints[highlightedPoints.length - 1],
+      startPoint
+    )) {
+      pushLineChartAreaHighlightPoint(highlightedPoints, endPoint);
+    } else {
+      flushHighlightedPoints();
+      highlightedPoints = [startPoint, endPoint];
+    }
+  }
+  flushHighlightedPoints();
+  return runs;
+};
+const getLineChartAreaHighlightRuns = (points, range) => getLineChartAreaHighlightPointRuns(points, range);
+
+export { getLineChartAreaHighlightRuns };

package/dist/esm/core/LineChart/index.js

@@ -3,8 +3,9 @@ import ErrorBoundary from '../ErrorBoundary/index.js';
 import Pointer from './Pointer.js';
 import RenderChart from './RenderChart.js';
 import { LineChartWrapper } from './styled.js';
+import useElementResize from '../../hooks/useElementResize.js';
 import cs from 'classnames';
-import React__default, { useState, useRef, useEffect } from 'react';
+import React__default, { useState, useRef, useCallback, useEffect } from 'react';
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -37,15 +38,32 @@ const LineChart = React__default.forwardRef(
     } = props;
     const [width, setWidth] = useState(0);
     const wrapperRef = useRef(null);
-    useEffect(() => {
+    const syncWrapperWidth = useCallback(() => {
       var _a;
       setWidth(((_a = wrapperRef.current) == null ? void 0 : _a.offsetWidth) || 0);
     }, []);
+    const setWrapperNode = useCallback(
+      (node) => {
+        wrapperRef.current = node;
+        if (typeof ref === "function") {
+          ref(node);
+          return;
+        }
+        if (ref) {
+          ref.current = node;
+        }
+      },
+      [ref]
+    );
+    useEffect(() => {
+      syncWrapperWidth();
+    }, [syncWrapperWidth]);
+    useElementResize(wrapperRef, syncWrapperWidth, [showLegend, showXaxis, height]);
     return /* @__PURE__ */ React__default.createElement(ErrorBoundary, { i18n: parrotI18n }, /* @__PURE__ */ React__default.createElement(
       LineChartWrapper,
       {
         className: cs("metric-wrapper", !showXaxis && "hidden-xaxis"),
-        ref: wrapperRef,
+        ref: setWrapperNode,
         "data-testid": dataTestId,
         style: { height: showLegend ? height + 30 : height }
       },

package/dist/esm/core/LineChart/lineChartDisplayUtils.js

@@ -0,0 +1,26 @@
+const DEFAULT_LINE_CHART_STROKE = "#3182bd";
+const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const isFiniteNumericYAxisDomain = (domain) => {
+  if (!Array.isArray(domain) || domain.length !== 2) {
+    return false;
+  }
+  return isFiniteNumber(domain[0]) && isFiniteNumber(domain[1]);
+};
+const getLineChartStreamStroke = (stream) => {
+  var _a;
+  const color = (_a = stream.legend.color) != null ? _a : DEFAULT_LINE_CHART_STROKE;
+  return stream.legend.stroke ? `${color}1A` : color;
+};
+const getLineChartDefaultYAxisTicks = (domain) => {
+  if (!isFiniteNumericYAxisDomain(domain)) {
+    return void 0;
+  }
+  const [, upper] = domain;
+  return [upper / 2, upper];
+};
+const getLineChartLegacyThresholdTooltipInfo = (info) => ({
+  current: info.formattedValue,
+  max: info.formattedThresholdValue
+});
+
+export { DEFAULT_LINE_CHART_STROKE, getLineChartDefaultYAxisTicks, getLineChartLegacyThresholdTooltipInfo, getLineChartStreamStroke, isFiniteNumber };

package/dist/esm/core/LineChart/lineSegments.js

@@ -0,0 +1,87 @@
+const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const getLineChartLinePoint = (point) => {
+  if (!isFiniteNumber(point.t) || !isFiniteNumber(point.x) || !isFiniteNumber(point.y)) {
+    return void 0;
+  }
+  return {
+    t: point.t,
+    x: point.x,
+    y: point.y
+  };
+};
+const getLineChartBoundaryPoint = (previous, next, timestamp) => {
+  const duration = next.t - previous.t;
+  if (!duration) {
+    return void 0;
+  }
+  const ratio = (timestamp - previous.t) / duration;
+  return {
+    t: timestamp,
+    x: previous.x + (next.x - previous.x) * ratio,
+    y: previous.y + (next.y - previous.y) * ratio
+  };
+};
+const getLineChartLineSegments = (points, forecastStartTimestamp) => {
+  const segments = [];
+  const hasForecastStart = isFiniteNumber(forecastStartTimestamp);
+  let continuousPoints = [];
+  const flushContinuousPoints = () => {
+    if (continuousPoints.length < 2) {
+      continuousPoints = [];
+      return;
+    }
+    let segmentPoints = [continuousPoints[0]];
+    let dashed = Boolean(
+      hasForecastStart && continuousPoints[0].t >= forecastStartTimestamp
+    );
+    const pushSegment = () => {
+      if (segmentPoints.length >= 2) {
+        segments.push({ dashed, points: segmentPoints });
+      }
+    };
+    for (let index = 1; index < continuousPoints.length; index += 1) {
+      const previous = continuousPoints[index - 1];
+      const next = continuousPoints[index];
+      const nextDashed = Boolean(
+        hasForecastStart && next.t >= forecastStartTimestamp
+      );
+      if (hasForecastStart && nextDashed !== dashed) {
+        const boundaryPoint = getLineChartBoundaryPoint(
+          previous,
+          next,
+          forecastStartTimestamp
+        );
+        if (boundaryPoint) {
+          segmentPoints.push(boundaryPoint);
+          pushSegment();
+          segmentPoints = [boundaryPoint];
+          if (boundaryPoint.t !== next.t) {
+            segmentPoints.push(next);
+          }
+          dashed = nextDashed;
+          continue;
+        }
+      }
+      segmentPoints.push(next);
+    }
+    pushSegment();
+    continuousPoints = [];
+  };
+  points.forEach((point) => {
+    const linePoint = getLineChartLinePoint(point);
+    if (!linePoint) {
+      flushContinuousPoints();
+      return;
+    }
+    continuousPoints.push(linePoint);
+  });
+  flushContinuousPoints();
+  return segments;
+};
+const getLineChartLinePath = (points) => {
+  return points.map((point, index) => {
+    return `${index === 0 ? "M" : "L"}${point.x},${point.y}`;
+  }).join(" ");
+};
+
+export { getLineChartLinePath, getLineChartLineSegments };

package/dist/esm/core/LineChart/styled.js

@@ -1,25 +1,35 @@
 import { styled } from '@linaria/react';
 
-const MetricLegendTabStyle = "E_4100_0_18_mn7joto";
-const LegendStyle = "E_4100_0_18_l1bifhon";
-const LegendItemsStyle = "E_4100_0_18_ltthzck";
-const LegendItemsStyleDropdown = "E_4100_0_18_l1mumj7o";
-const ExtraResource = "E_4100_0_18_e45tc5l";
+const MetricLegendTabStyle = "E_4100_0_19_mn7joto";
+const LegendStyle = "E_4100_0_19_l1bifhon";
+const LegendItemsStyle = "E_4100_0_19_ltthzck";
+const LegendItemsStyleDropdown = "E_4100_0_19_l1mumj7o";
+const ExtraResource = "E_4100_0_19_e45tc5l";
 const LineChartWrapper = /*#__PURE__*/styled('div')({
   name: "LineChartWrapper",
-  class: "E_4100_0_18_lqeaosa",
+  class: "E_4100_0_19_lqeaosa",
+  propsAsIs: false
+});
+const ChartContentWrapper = /*#__PURE__*/styled('div')({
+  name: "ChartContentWrapper",
+  class: "E_4100_0_19_c2pr38p",
+  propsAsIs: false
+});
+const ThresholdTooltipOverlay = /*#__PURE__*/styled('div')({
+  name: "ThresholdTooltipOverlay",
+  class: "E_4100_0_19_tecdsj7",
   propsAsIs: false
 });
 const TooltipWrapper = /*#__PURE__*/styled('div')({
   name: "TooltipWrapper",
-  class: "E_4100_0_18_t2pr38p",
+  class: "E_4100_0_19_tjhvvia",
   propsAsIs: false
 });
 const TooltipColumn = /*#__PURE__*/styled('div')({
   name: "TooltipColumn",
-  class: "E_4100_0_18_tecdsj7",
+  class: "E_4100_0_19_tuyrup3",
   propsAsIs: false
 });
-const LineChartColorBlockStyle = "E_4100_0_18_ljhvvia";
+const LineChartColorBlockStyle = "E_4100_0_19_lheyn3m";
 
-export { ExtraResource, LegendItemsStyle, LegendItemsStyleDropdown, LegendStyle, LineChartColorBlockStyle, LineChartWrapper, MetricLegendTabStyle, TooltipColumn, TooltipWrapper };
+export { ChartContentWrapper, ExtraResource, LegendItemsStyle, LegendItemsStyleDropdown, LegendStyle, LineChartColorBlockStyle, LineChartWrapper, MetricLegendTabStyle, ThresholdTooltipOverlay, TooltipColumn, TooltipWrapper };

package/dist/esm/core/LineChart/utils.js

@@ -89,10 +89,92 @@ function getLineChartXAxisDomain(dateRange, xaxisLastTime) {
   const [startDate, endDate] = dateRange;
   return [startDate.valueOf(), xaxisLastTime != null ? xaxisLastTime : endDate.valueOf()];
 }
+const getLineChartMetricPayloadMatches = (payload, legends = []) => {
+  if (!(payload == null ? void 0 : payload.length)) {
+    return [];
+  }
+  return payload.flatMap((item) => {
+    const legend = legends.find((_legend, index) => `v${index}` === item.name);
+    if (!legend) {
+      return [];
+    }
+    return [{ payload: item, legend }];
+  });
+};
+const getLineChartAreaHighlightRanges = (ranges = [], xDomain) => {
+  const [domainStart, domainEnd] = xDomain;
+  return ranges.map((range) => __spreadProps(__spreadValues({}, range), {
+    start: Math.max(range.start, domainStart),
+    end: Math.min(range.end, domainEnd)
+  })).filter((range) => range.start < range.end);
+};
 const getLineChartRangeTimestamp = (dateRange) => {
   const [startDate, endDate] = dateRange;
   return endDate.valueOf() - startDate.valueOf();
 };
+const isSameIntersectionPoint = (prev, next) => {
+  if (!prev) {
+    return false;
+  }
+  return prev.streamIndex === next.streamIndex && Math.abs(prev.timestamp - next.timestamp) < 1e-6 && Math.abs(prev.value - next.value) < 1e-6;
+};
+const pushLineChartIntersection = (intersections, next) => {
+  if (!isSameIntersectionPoint(intersections[intersections.length - 1], next)) {
+    intersections.push(next);
+  }
+};
+const isValidLineChartValue = (value) => {
+  return _.isNumber(value) && Number.isFinite(value);
+};
+const getLineChartThresholdIntersections = (streams, thresholdValue, xDomain) => {
+  const [domainStart, domainEnd] = xDomain != null ? xDomain : [-Infinity, Infinity];
+  return streams.flatMap((stream, streamIndex) => {
+    const intersections = [];
+    for (let index = 0; index < stream.points.length - 1; index++) {
+      const currentPoint = stream.points[index];
+      const nextPoint = stream.points[index + 1];
+      if (!isValidLineChartValue(currentPoint == null ? void 0 : currentPoint.v) || !isValidLineChartValue(nextPoint == null ? void 0 : nextPoint.v) || currentPoint.t === nextPoint.t) {
+        continue;
+      }
+      const currentDiff = currentPoint.v - thresholdValue;
+      const nextDiff = nextPoint.v - thresholdValue;
+      if (currentDiff === 0 && nextDiff === 0) {
+        continue;
+      }
+      if (currentDiff === 0 && currentPoint.t >= domainStart && currentPoint.t <= domainEnd) {
+        pushLineChartIntersection(intersections, {
+          timestamp: currentPoint.t,
+          value: thresholdValue,
+          legend: stream.legend,
+          streamIndex
+        });
+      }
+      if (currentDiff * nextDiff < 0) {
+        const ratio = currentDiff / (currentDiff - nextDiff);
+        const timestamp = currentPoint.t + (nextPoint.t - currentPoint.t) * ratio;
+        if (timestamp >= domainStart && timestamp <= domainEnd) {
+          pushLineChartIntersection(intersections, {
+            timestamp,
+            value: thresholdValue,
+            legend: stream.legend,
+            streamIndex
+          });
+        }
+      }
+      if (nextDiff === 0 && nextPoint.t >= domainStart && nextPoint.t <= domainEnd) {
+        pushLineChartIntersection(intersections, {
+          timestamp: nextPoint.t,
+          value: thresholdValue,
+          legend: stream.legend,
+          streamIndex
+        });
+      }
+    }
+    return intersections.filter(
+      (intersection) => intersection.timestamp >= domainStart && intersection.timestamp <= domainEnd
+    );
+  });
+};
 const getLineChartStep = (dateRange) => {
   const [startDate, endDate] = dateRange;
   const range = endDate.valueOf() - startDate.valueOf();
@@ -285,7 +367,7 @@ const UNIT_FORMATTER = {
   [ILineChartMetricUnit.Temperature]: [formatTemperature, "\u2103"],
   [ILineChartMetricUnit.Load]: [formatCount, ""]
 };
-const getLineChartYDataMax = (dataPoints, type) => {
+const getLineChartYDataMax = (dataPoints, type, extraValues = []) => {
   const values = dataPoints.map((p) => {
     if (_.isNumber(p == null ? void 0 : p.v)) {
       return p.v;
@@ -309,7 +391,11 @@ const getLineChartYDataMax = (dataPoints, type) => {
       return max;
     }
   });
-  return Math.max(...values, 0);
+  return Math.max(
+    ...values,
+    0,
+    ...extraValues.filter((value) => Number.isFinite(value))
+  );
 };
 const getYAxisUpperBound = (max, type) => {
   const DIVISOR = 2;
@@ -343,8 +429,8 @@ const getYAxisUpperBound = (max, type) => {
       return 2;
   }
 };
-const getYAxisDomain = (dataPoints, graphType, unitType) => {
-  const max = getLineChartYDataMax(dataPoints, graphType);
+const getYAxisDomain = (dataPoints, graphType, unitType, extraValues = []) => {
+  const max = getLineChartYDataMax(dataPoints, graphType, extraValues);
   if (!max) {
     if (unitType === ILineChartMetricUnit.Ratio) {
       return [0, 1];
@@ -366,4 +452,4 @@ function lineChartYaxisTickFormatter(value, unit) {
   return `${_value} ${_unit}`;
 }
 
-export { UNIT_FORMATTER, addMissingDataWithZero, convertLineChartDataStruct, convertLineChartUnit, deletePointsOutOfRange, filterLineChartDataOverlapping, filterLineChartOverlappingMetric, filterLineChartPointsByDateRange, getFirstExpectedTimestamp, getLineChartRangeTimestamp, getLineChartStep, getLineChartXAxisDomain, getLineChartYDataMax, getYAxisDomain, getYAxisUpperBound, lineChartTickFormatter, lineChartXaxisCal, lineChartYaxisTickFormatter, parseLineChartRange };
+export { UNIT_FORMATTER, addMissingDataWithZero, convertLineChartDataStruct, convertLineChartUnit, deletePointsOutOfRange, filterLineChartDataOverlapping, filterLineChartOverlappingMetric, filterLineChartPointsByDateRange, getFirstExpectedTimestamp, getLineChartAreaHighlightRanges, getLineChartMetricPayloadMatches, getLineChartRangeTimestamp, getLineChartStep, getLineChartThresholdIntersections, getLineChartXAxisDomain, getLineChartYDataMax, getYAxisDomain, getYAxisUpperBound, lineChartTickFormatter, lineChartXaxisCal, lineChartYaxisTickFormatter, parseLineChartRange };

package/dist/esm/core/Link/index.js

@@ -30,7 +30,7 @@ var __objRest = (source, exclude) => {
   }
   return target;
 };
-const LinkStyle = "E_4100_0_18_l48ei06";
+const LinkStyle = "E_4100_0_19_l48ei06";
 const Link = React__default.forwardRef((_a, ref) => {
   var _b = _a,
     {

package/dist/esm/core/Loading/style.js

@@ -1,6 +1,6 @@
-const LoadingWrapper = "E_4100_0_18_lht19u8";
-const LoadingLine1 = "E_4100_0_18_lk3gkp4";
-const LoadingLine2 = "E_4100_0_18_ll4n94n";
-const LoadingLine3 = "E_4100_0_18_l17lbdo6";
+const LoadingWrapper = "E_4100_0_19_lht19u8";
+const LoadingLine1 = "E_4100_0_19_lk3gkp4";
+const LoadingLine2 = "E_4100_0_19_ll4n94n";
+const LoadingLine3 = "E_4100_0_19_l17lbdo6";
 
 export { LoadingLine1, LoadingLine2, LoadingLine3, LoadingWrapper };

package/dist/esm/core/LocalUpload/LocalUpload.style.js

@@ -2,9 +2,9 @@ import { styled } from '@linaria/react';
 
 const UploadWrapper = /*#__PURE__*/styled('div')({
   name: "UploadWrapper",
-  class: "E_4100_0_18_u3l9ivi",
+  class: "E_4100_0_19_u3l9ivi",
   propsAsIs: false
 });
-const FileInfoWrapperStyle = "E_4100_0_18_ftdwz1g";
+const FileInfoWrapperStyle = "E_4100_0_19_ftdwz1g";
 
 export { FileInfoWrapperStyle, UploadWrapper };

package/dist/esm/core/LogView/LogView.style.js

@@ -2,24 +2,24 @@ import { styled } from '@linaria/react';
 
 const LogViewContainer = /*#__PURE__*/styled('div')({
   name: "LogViewContainer",
-  class: "E_4100_0_18_l1v1luhz",
+  class: "E_4100_0_19_l1v1luhz",
   propsAsIs: false
 });
 const LogViewInnerContaier = /*#__PURE__*/styled('div')({
   name: "LogViewInnerContaier",
-  class: "E_4100_0_18_lranxiw",
+  class: "E_4100_0_19_lranxiw",
   propsAsIs: false
 });
 const LogTerminal = /*#__PURE__*/styled('div')({
   name: "LogTerminal",
-  class: "E_4100_0_18_l1y3zqy5",
+  class: "E_4100_0_19_l1y3zqy5",
   propsAsIs: false
 });
 const CustomContentOverlay = /*#__PURE__*/styled('div')({
   name: "CustomContentOverlay",
-  class: "E_4100_0_18_c1x4mn5u",
+  class: "E_4100_0_19_c1x4mn5u",
   propsAsIs: false
 });
-const SearchInputStyle = "E_4100_0_18_s4pilip";
+const SearchInputStyle = "E_4100_0_19_s4pilip";
 
 export { CustomContentOverlay, LogTerminal, LogViewContainer, LogViewInnerContaier, SearchInputStyle };

package/dist/esm/core/MediumDialog/MediumDialog.js

@@ -28,7 +28,7 @@ var __objRest = (source, exclude) => {
   }
   return target;
 };
-const MediumDialogStyle = "E_4100_0_18_m5foqp8";
+const MediumDialogStyle = "E_4100_0_19_m5foqp8";
 const MediumDialog = _a => {
   var _b = _a,
     {

package/dist/esm/core/Metric/styled.js

@@ -1,23 +1,23 @@
 import { styled } from '@linaria/react';
 
-const MetricLegendTabStyle = "E_4100_0_18_mp64wfi";
-const LegendStyle = "E_4100_0_18_l1oyigan";
-const LegendItemStyle = "E_4100_0_18_l1noi4n1";
-const ColorBlockStyle = "E_4100_0_18_cz19rz6";
-const ExtraResource = "E_4100_0_18_e17r5r9c";
+const MetricLegendTabStyle = "E_4100_0_19_mp64wfi";
+const LegendStyle = "E_4100_0_19_l1oyigan";
+const LegendItemStyle = "E_4100_0_19_l1noi4n1";
+const ColorBlockStyle = "E_4100_0_19_cz19rz6";
+const ExtraResource = "E_4100_0_19_e17r5r9c";
 const MetricWrapper = /*#__PURE__*/styled('div')({
   name: "MetricWrapper",
-  class: "E_4100_0_18_m1y1hhnr",
+  class: "E_4100_0_19_m1y1hhnr",
   propsAsIs: false
 });
 const TooltipWrapper = /*#__PURE__*/styled('div')({
   name: "TooltipWrapper",
-  class: "E_4100_0_18_tnvijvs",
+  class: "E_4100_0_19_tnvijvs",
   propsAsIs: false
 });
 const TooltipColumn = /*#__PURE__*/styled('div')({
   name: "TooltipColumn",
-  class: "E_4100_0_18_t1ub2aex",
+  class: "E_4100_0_19_t1ub2aex",
   propsAsIs: false
 });
 

package/dist/esm/core/Nav/index.js

@@ -3,7 +3,7 @@ import React__default from 'react';
 import { Typo } from '../Typo/index.js';
 import { Header, NavCenterStyle } from './style.js';
 
-const MinWidth = "E_4100_0_18_m196gn1d";
+const MinWidth = "E_4100_0_19_m196gn1d";
 const Nav = ({
   left,
   right,

package/dist/esm/core/Nav/style.js

@@ -2,9 +2,9 @@ import { styled } from '@linaria/react';
 
 const Header = /*#__PURE__*/styled('header')({
   name: "Header",
-  class: "E_4100_0_18_h12yihis",
+  class: "E_4100_0_19_h12yihis",
   propsAsIs: false
 });
-const NavCenterStyle = "E_4100_0_18_ncaepor";
+const NavCenterStyle = "E_4100_0_19_ncaepor";
 
 export { Header, NavCenterStyle };

package/dist/esm/core/Overflow/index.js

@@ -2,8 +2,8 @@ import cs from 'classnames';
 import React__default, { useRef, useState, useCallback, useLayoutEffect } from 'react';
 import useElementResize from '../../hooks/useElementResize.js';
 
-const OverflowWrapper = "E_4100_0_18_owd0kml";
-const HiddenStyle = "E_4100_0_18_h1jsgezc";
+const OverflowWrapper = "E_4100_0_19_owd0kml";
+const HiddenStyle = "E_4100_0_19_h1jsgezc";
 const Overflow = props => {
   const {
     children,

package/dist/esm/core/Pagination/index.js

@@ -6,8 +6,8 @@ import { Dropdown, Menu } from 'antd';
 import cs from 'classnames';
 import React__default, { useRef, useEffect, useMemo } from 'react';
 
-const PaginationStyle = "E_4100_0_18_phljevk";
-const DropdownOverlayStyle = "E_4100_0_18_d12rtyeg";
+const PaginationStyle = "E_4100_0_19_phljevk";
+const DropdownOverlayStyle = "E_4100_0_19_d12rtyeg";
 const Pagination = props => {
   const {
     current,

package/dist/esm/core/Progress/components.js

@@ -42,7 +42,7 @@ const _exp = /*#__PURE__*/() => ({
 }) => color || "";
 const IconFieldText = /*#__PURE__*/styled('div')({
   name: "IconFieldText",
-  class: "E_4100_0_18_i14c7jc8",
+  class: "E_4100_0_19_i14c7jc8",
   propsAsIs: false,
   vars: {
     "i14c7jc8-0": [_exp()]
@@ -59,7 +59,7 @@ const StatusIconMap = {
 };
 const IconFieldWrapper = /*#__PURE__*/styled('div')({
   name: "IconFieldWrapper",
-  class: "E_4100_0_18_i1ibuolf",
+  class: "E_4100_0_19_i1ibuolf",
   propsAsIs: false
 });
 const IconField = _a => {

package/dist/esm/core/Progress/index.js

@@ -39,7 +39,7 @@ var __objRest = (source, exclude) => {
 };
 const Row = /*#__PURE__*/styled('div')({
   name: "Row",
-  class: "E_4100_0_18_r77hffu",
+  class: "E_4100_0_19_r77hffu",
   propsAsIs: false
 });
 const _exp = /*#__PURE__*/() => ({
@@ -47,7 +47,7 @@ const _exp = /*#__PURE__*/() => ({
 }) => type === "rich" ? "6px" : "4px";
 const ProgressContainer = /*#__PURE__*/styled('div')({
   name: "ProgressContainer",
-  class: "E_4100_0_18_p1cmxsf7",
+  class: "E_4100_0_19_p1cmxsf7",
   propsAsIs: false,
   vars: {
     "p1cmxsf7-0": [_exp()]

package/dist/esm/core/Progress/progress.style.js

@@ -1,6 +1,6 @@
-const DescriptionStyle = "E_4100_0_18_d1u4ndxc";
-const FlexFullContentStyle = "E_4100_0_18_f6xb0iv";
-const BaseProgressStyle = "E_4100_0_18_b1dhu7ov";
-const ProgressStyle = "E_4100_0_18_p1as1j2z";
+const DescriptionStyle = "E_4100_0_19_d1u4ndxc";
+const FlexFullContentStyle = "E_4100_0_19_f6xb0iv";
+const BaseProgressStyle = "E_4100_0_19_b1dhu7ov";
+const ProgressStyle = "E_4100_0_19_p1as1j2z";
 
 export { BaseProgressStyle, DescriptionStyle, FlexFullContentStyle, ProgressStyle };

package/dist/esm/core/Progress/progress.widgets.js

@@ -33,11 +33,11 @@ var __objRest = (source, exclude) => {
   }
   return target;
 };
-const titleAreaStyle = "E_4100_0_18_t1gvlxt5";
+const titleAreaStyle = "E_4100_0_19_t1gvlxt5";
 const _exp2 = /*#__PURE__*/() => props => props.gap;
 const AreaWrapper = /*#__PURE__*/styled('div')({
   name: "AreaWrapper",
-  class: "E_4100_0_18_a1ji6r68",
+  class: "E_4100_0_19_a1ji6r68",
   propsAsIs: false,
   vars: {
     "a1ji6r68-0": [_exp2(), "px"]

package/dist/esm/core/Radio/index.js

@@ -30,9 +30,9 @@ var __objRest = (source, exclude) => {
   }
   return target;
 };
-const RadioStyle = "E_4100_0_18_rapgekc";
-const RadioGroupStyle = "E_4100_0_18_rp906go";
-const RadioButtonStyle = "E_4100_0_18_rcc63c8";
+const RadioStyle = "E_4100_0_19_rapgekc";
+const RadioGroupStyle = "E_4100_0_19_rp906go";
+const RadioButtonStyle = "E_4100_0_19_rcc63c8";
 const KitRadioGroupContext = React__default.createContext({});
 const Radio = _a => {
   var _b = _a,