@cloudtower/eagle 0.33.4 → 0.33.6

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

@@ -0,0 +1,63 @@
+import { styled } from '@linaria/react';
+import { LineChartColorBlock } from './LineChartLegend.js';
+import { TooltipWrapper, TooltipColumn } from './styled.js';
+import dayjs from 'dayjs';
+import React__default from 'react';
+import { Typo } from '../Typo/index.js';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {})) if (__hasOwnProp.call(b, prop)) __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols) for (var prop of __getOwnPropSymbols(b)) {
+    if (__propIsEnum.call(b, prop)) __defNormalProp(a, prop, b[prop]);
+  }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const TooltipTitle = /*#__PURE__*/styled('div')({
+  name: "TooltipTitle",
+  class: "E_t1616y1o",
+  propsAsIs: false
+});
+const TooltipFormatter = props => {
+  const {
+    active,
+    payload,
+    deselected,
+    legends,
+    format
+  } = props;
+  if (!active || !(payload == null ? void 0 : payload.length)) {
+    return null;
+  }
+  return /* @__PURE__ */React__default.createElement(TooltipWrapper, null, /* @__PURE__ */React__default.createElement(TooltipTitle, {
+    className: Typo.Label.l4_bold_title
+  }, dayjs(Number(payload[0].payload.t)).format("MM/DD HH:mm:ss")), payload.map((item, index) => {
+    return __spreadProps(__spreadValues({}, item), {
+      legend: legends[index]
+    });
+  }).sort((a, b) => b.value - a.value).map(item => {
+    return deselected.includes(item.legend.id) ? null : /* @__PURE__ */React__default.createElement(TooltipColumn, {
+      key: item.legend.id
+    }, /* @__PURE__ */React__default.createElement("div", null, /* @__PURE__ */React__default.createElement(LineChartColorBlock, {
+      background: item.legend.color,
+      borderd: true
+    }), item.legend.name), /* @__PURE__ */React__default.createElement("div", {
+      className: "column-value"
+    }, format(item)));
+  }));
+};
+var TooltipFormatter$1 = TooltipFormatter;
+
+export { TooltipFormatter$1 as default };

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

@@ -0,0 +1,57 @@
+import { parrotI18n } from '@cloudtower/parrot';
+import ErrorBoundary from '../ErrorBoundary/index.js';
+import Pointer from './Pointer.js';
+import RenderChart from './RenderChart.js';
+import { LineChartWrapper } from './styled.js';
+import cs from 'classnames';
+import React__default, { useState, useRef, useEffect } from 'react';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const LineChart = React__default.forwardRef(
+  (props, ref) => {
+    const {
+      height = 154,
+      showPointer = true,
+      showLegend = true,
+      showXaxis = false,
+      chartProps
+    } = props;
+    const [width, setWidth] = useState(0);
+    const wrapperRef = useRef(null);
+    useEffect(() => {
+      var _a;
+      setWidth(((_a = wrapperRef.current) == null ? void 0 : _a.offsetWidth) || 0);
+    }, []);
+    return /* @__PURE__ */ React__default.createElement(ErrorBoundary, { i18n: parrotI18n }, /* @__PURE__ */ React__default.createElement(
+      LineChartWrapper,
+      {
+        className: cs("metric-wrapper", !showXaxis && "hidden-xaxis"),
+        ref: wrapperRef,
+        style: { height: showLegend ? height + 30 : height }
+      },
+      /* @__PURE__ */ React__default.createElement(RenderChart, __spreadProps(__spreadValues({}, chartProps), { width })),
+      showPointer && /* @__PURE__ */ React__default.createElement(Pointer, { uuid: chartProps.syncId, metricWidth: width })
+    ));
+  }
+);
+var LineChart$1 = LineChart;
+
+export { LineChart$1 as default };

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

@@ -0,0 +1,25 @@
+import { styled } from '@linaria/react';
+
+const MetricLegendTabStyle = "E_mn7joto";
+const LegendStyle = "E_l1bifhon";
+const LegendItemsStyle = "E_ltthzck";
+const LegendItemsStyleDropdown = "E_l1mumj7o";
+const ExtraResource = "E_e45tc5l";
+const LineChartWrapper = /*#__PURE__*/styled('div')({
+  name: "LineChartWrapper",
+  class: "E_lqeaosa",
+  propsAsIs: false
+});
+const TooltipWrapper = /*#__PURE__*/styled('div')({
+  name: "TooltipWrapper",
+  class: "E_t2pr38p",
+  propsAsIs: false
+});
+const TooltipColumn = /*#__PURE__*/styled('div')({
+  name: "TooltipColumn",
+  class: "E_tecdsj7",
+  propsAsIs: false
+});
+const LineChartColorBlockStyle = "E_ljhvvia";
+
+export { ExtraResource, LegendItemsStyle, LegendItemsStyleDropdown, LegendStyle, LineChartColorBlockStyle, LineChartWrapper, MetricLegendTabStyle, TooltipColumn, TooltipWrapper };

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

@@ -0,0 +1,26 @@
+var ILineChartTimeUnit = /* @__PURE__ */ ((ILineChartTimeUnit2) => {
+  ILineChartTimeUnit2["Day"] = "DAY";
+  ILineChartTimeUnit2["Hour"] = "HOUR";
+  ILineChartTimeUnit2["Month"] = "MONTH";
+  return ILineChartTimeUnit2;
+})(ILineChartTimeUnit || {});
+var ILineChartMetricUnit = /* @__PURE__ */ ((ILineChartMetricUnit2) => {
+  ILineChartMetricUnit2["Count"] = "COUNT";
+  ILineChartMetricUnit2["DataRateBit"] = "DATA_RATE_BIT";
+  ILineChartMetricUnit2["DataRateByte"] = "DATA_RATE_BYTE";
+  ILineChartMetricUnit2["DataSize"] = "DATA_SIZE";
+  ILineChartMetricUnit2["Frequency"] = "FREQUENCY";
+  ILineChartMetricUnit2["Load"] = "LOAD";
+  ILineChartMetricUnit2["Percent"] = "PERCENT";
+  ILineChartMetricUnit2["Ratio"] = "RATIO";
+  ILineChartMetricUnit2["Temperature"] = "TEMPERATURE";
+  ILineChartMetricUnit2["Time"] = "TIME";
+  return ILineChartMetricUnit2;
+})(ILineChartMetricUnit || {});
+var ILineChartGraphType = /* @__PURE__ */ ((ILineChartGraphType2) => {
+  ILineChartGraphType2["Area"] = "AREA";
+  ILineChartGraphType2["Stack"] = "STACK";
+  return ILineChartGraphType2;
+})(ILineChartGraphType || {});
+
+export { ILineChartGraphType, ILineChartMetricUnit, ILineChartTimeUnit };

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

@@ -0,0 +1,369 @@
+import { ILineChartMetricUnit, ILineChartGraphType } from './type.js';
+import { HOUR, DAY, SECOND, MINUTE, unitRules, formatPercent, formatCount, formatBytes, formatBps, formatBitPerSecond, formatNanoSecond, formatFrequency, formatTemperature } from '../../utils/tower.js';
+import dayjs from 'dayjs';
+import _ from 'lodash';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function filterLineChartPointsByDateRange(points, dateRange) {
+  const [startDate, endDate] = dateRange != null ? dateRange : [dayjs(), dayjs()];
+  return points == null ? void 0 : points.filter((point) => {
+    const pointDate = dayjs(point.t);
+    if (startDate && pointDate.isBefore(startDate)) {
+      return false;
+    }
+    if (endDate && pointDate.isAfter(endDate)) {
+      return false;
+    }
+    return true;
+  });
+}
+const parseLineChartRange = (range) => {
+  const span = parseInt(range.slice(0, range.length - 1));
+  const unit = range.slice(range.length - 1);
+  return { span, unit };
+};
+function getRangeTimestamp(dateRange) {
+  const [startDate, endDate] = dateRange;
+  return endDate.valueOf() - startDate.valueOf();
+}
+const lineChartXaxisCal = (lastTime, dateRange, width) => {
+  const tangeTime = getRangeTimestamp(dateRange);
+  const baseline = lastTime || dateRange[1].valueOf();
+  if (width < 290) {
+    const tick = tangeTime / 4;
+    return [baseline - tick * 3, baseline - tick];
+  } else if (width < 380) {
+    const tick = tangeTime / 6;
+    return [baseline - tick * 5, baseline - tick * 3, baseline - tick];
+  } else {
+    const tick = tangeTime / 8;
+    return [
+      baseline - tick * 7,
+      baseline - tick * 5,
+      baseline - tick * 3,
+      baseline - tick
+    ];
+  }
+};
+const lineChartTickFormatter = (tick, dateRange) => {
+  const rangeTime = getLineChartRangeTimestamp(dateRange);
+  if (rangeTime <= 2 * HOUR * 1e3) {
+    return dayjs(tick).format("HH:mm:ss");
+  }
+  if (rangeTime <= 4 * DAY * 1e3) {
+    return dayjs(tick).format("MM/DD HH:mm:ss");
+  }
+  return dayjs(tick).format("MM/DD");
+};
+function getLineChartXAxisDomain(dateRange, xaxisLastTime) {
+  const [startDate, endDate] = dateRange;
+  return [startDate.valueOf(), xaxisLastTime != null ? xaxisLastTime : endDate.valueOf()];
+}
+const getLineChartRangeTimestamp = (dateRange) => {
+  const [startDate, endDate] = dateRange;
+  return endDate.valueOf() - startDate.valueOf();
+};
+const getLineChartStep = (dateRange) => {
+  const [startDate, endDate] = dateRange;
+  const range = endDate.valueOf() - startDate.valueOf();
+  if (range <= 2 * 60 * 60 * 1e3) {
+    return SECOND * 30 * 1e3;
+  }
+  if (range <= 24 * 60 * 60 * 1e3) {
+    return MINUTE * 5 * 1e3;
+  }
+  if (range <= 7 * 24 * 60 * 60 * 1e3) {
+    return MINUTE * 30 * 1e3;
+  }
+  if (range <= 30 * 24 * 60 * 60 * 1e3) {
+    return DAY * 1e3;
+  }
+  return DAY * 1e3;
+};
+const filterLineChartDataOverlapping = (data, startTimestamp, length, step, tolerance) => {
+  const points = [...new Array(Math.round(length))].map((_2, index) => {
+    return startTimestamp + index * step;
+  }).map((timestamp) => {
+    const closestPoint = _.minBy(
+      data.filter((value) => {
+        return Math.abs(value.t - timestamp) < tolerance;
+      }),
+      (value) => {
+        return Math.abs(value.t - timestamp);
+      }
+    );
+    if (closestPoint == null) {
+      return {
+        t: timestamp,
+        v: -Infinity
+      };
+    }
+    return closestPoint;
+  });
+  return points;
+};
+const convertLineChartDataStruct = (streams) => {
+  const points = streams.flatMap((points2, index) => {
+    return points2.map((point) => {
+      return __spreadProps(__spreadValues({}, point), { [`v${index}`]: point.v });
+    });
+  });
+  const groupedPoints = _.groupBy(points, (point) => {
+    return point.t;
+  });
+  const combinedPoints = Object.entries(groupedPoints).map(([key, values]) => {
+    return values.reduce((p, c) => {
+      const _a = __spreadValues(__spreadValues({}, p), c), values2 = __objRest(_a, ["v"]);
+      return values2;
+    }, {});
+  });
+  return combinedPoints;
+};
+const filterLineChartOverlappingMetric = (metric, dateRange) => {
+  const range = getLineChartRangeTimestamp(dateRange);
+  return __spreadProps(__spreadValues({}, metric), {
+    sample_streams: metric.sample_streams.map((stream) => __spreadProps(__spreadValues({}, stream), {
+      points: filterLineChartDataOverlapping(
+        stream.points,
+        dateRange[0].valueOf(),
+        range / stream.step,
+        stream.step,
+        stream.tolerance
+      )
+    }))
+  });
+};
+const deletePointsOutOfRange = (data, timeRange, now) => {
+  const first = now - getLineChartRangeTimestamp(timeRange);
+  return (data == null ? void 0 : data.filter((item) => {
+    return item.t >= first && item.t <= now;
+  })) || [];
+};
+const getFirstExpectedTimestamp = (data, timeRange, now, step, dateRange) => {
+  const first = timeRange ? now - getLineChartRangeTimestamp(timeRange) : dayjs(dateRange == null ? void 0 : dateRange[0]).valueOf();
+  const firstRealTimestamp = data[0].t;
+  return firstRealTimestamp - Math.floor((firstRealTimestamp - first) / step) * step;
+};
+const getFaultToleranceTime = (timeRange) => {
+  const [startDate, endDate] = timeRange;
+  const range = endDate.valueOf() - startDate.valueOf();
+  switch (range) {
+    case 5 * MINUTE:
+      return 5 * 1e3;
+    case 15 * MINUTE:
+      return 15 * 1e3;
+    case 1 * HOUR:
+      return 60 * 1e3;
+    case 2 * HOUR:
+      return 120 * 1e3;
+    case 24 * HOUR:
+      return 10 * 60 * 1e3;
+    case 7 * DAY:
+    case 30 * DAY:
+      return 60 * 60 * 1e3;
+    case 182 * DAY:
+      return 24 * 60 * 60 * 1e3;
+  }
+  return 120 * 1e3;
+};
+const addMissingDataWithZero = (data, timeRange, unit, step, dateRange) => {
+  const now = Date.now();
+  const inRangePoints = deletePointsOutOfRange(data, timeRange, now);
+  if (!inRangePoints.length) {
+    return [];
+  }
+  const firsExpectedTimestamp = getFirstExpectedTimestamp(
+    inRangePoints,
+    timeRange,
+    now,
+    step,
+    dateRange
+  );
+  const expectedPoints = [];
+  const tolerance = getFaultToleranceTime(timeRange);
+  if (inRangePoints[0].t - firsExpectedTimestamp > tolerance + step) {
+    inRangePoints.unshift({
+      t: firsExpectedTimestamp,
+      v: -Infinity
+    });
+  }
+  if (now - inRangePoints[inRangePoints.length - 1].t > tolerance + step) {
+    inRangePoints.push({
+      t: now,
+      v: -Infinity
+    });
+  }
+  inRangePoints.forEach((item, index) => {
+    var _a;
+    expectedPoints.push({
+      t: item == null ? void 0 : item.t,
+      v: item == null ? void 0 : item.v
+    });
+    if (index + 1 <= inRangePoints.length - 1) {
+      const nowTimeRange = ((_a = inRangePoints[index + 1]) == null ? void 0 : _a.t) - (item == null ? void 0 : item.t);
+      if (nowTimeRange > tolerance + step) {
+        const n = Math.floor(nowTimeRange / step);
+        for (let i = 1; i < n; i++) {
+          expectedPoints.push({
+            t: (item == null ? void 0 : item.t) + step * i,
+            v: -Infinity
+          });
+        }
+      }
+    }
+  });
+  return filterLineChartPointsByDateRange(
+    expectedPoints.map((p) => __spreadProps(__spreadValues({}, p), { unit })),
+    dateRange
+  );
+};
+const convertLineChartUnit = (value, from, to, decimals) => {
+  if (from === to || !value)
+    return value;
+  const ruleIndex = unitRules.findIndex((rule) => rule.unit.includes(from));
+  if (ruleIndex === -1) {
+    return value;
+  }
+  const { unit, divider } = unitRules[ruleIndex];
+  let fromIdx = unit.indexOf(from);
+  const toIdx = unit.indexOf(to);
+  if (toIdx === -1) {
+    return value;
+  }
+  if (fromIdx < toIdx) {
+    while (fromIdx < toIdx) {
+      value /= divider[fromIdx];
+      fromIdx++;
+    }
+  } else {
+    while (fromIdx > toIdx) {
+      value *= divider[fromIdx - 1];
+      fromIdx--;
+    }
+  }
+  return _.isInteger(value) ? value : _.isNil(decimals) ? value : parseFloat(value.toFixed(decimals));
+};
+const UNIT_FORMATTER = {
+  [ILineChartMetricUnit.Percent]: [formatPercent, "%", 2, false],
+  [ILineChartMetricUnit.Ratio]: [formatPercent, "%"],
+  [ILineChartMetricUnit.Count]: [formatCount, ""],
+  [ILineChartMetricUnit.DataSize]: [formatBytes, "B"],
+  [ILineChartMetricUnit.DataRateByte]: [formatBps, "Bps"],
+  [ILineChartMetricUnit.DataRateBit]: [formatBitPerSecond, "bps"],
+  [ILineChartMetricUnit.Time]: [formatNanoSecond, "ns"],
+  [ILineChartMetricUnit.Frequency]: [formatFrequency, "Hz"],
+  [ILineChartMetricUnit.Temperature]: [formatTemperature, "\u2103"],
+  [ILineChartMetricUnit.Load]: [formatCount, ""]
+};
+const getLineChartYDataMax = (dataPoints, type) => {
+  const values = dataPoints.map((p) => {
+    if (_.isNumber(p == null ? void 0 : p.v)) {
+      return p.v;
+    }
+    const entries = Object.entries(p);
+    if (type === ILineChartGraphType.Stack) {
+      let sum = 0;
+      for (const [key, value] of entries) {
+        if (/^v(\d*)$/.test(key) && _.isNumber(value)) {
+          sum += value;
+        }
+      }
+      return sum;
+    } else {
+      let max = 0;
+      for (const [key, value] of entries) {
+        if (/^v(\d*)$/.test(key) && _.isNumber(value) && value > max) {
+          max = value;
+        }
+      }
+      return max;
+    }
+  });
+  return Math.max(...values, 0);
+};
+const getYAxisUpperBound = (max, type) => {
+  const DIVISOR = 2;
+  switch (type) {
+    case ILineChartMetricUnit.Count:
+    case ILineChartMetricUnit.Load:
+    case ILineChartMetricUnit.DataSize:
+    case ILineChartMetricUnit.DataRateByte:
+    case ILineChartMetricUnit.Time:
+    case ILineChartMetricUnit.Frequency:
+    case ILineChartMetricUnit.DataRateBit:
+    case ILineChartMetricUnit.Temperature: {
+      const [format, base] = UNIT_FORMATTER[type];
+      const { value, unit } = format(max);
+      const _value = Math.ceil(Number(value) / DIVISOR) * DIVISOR;
+      return convertLineChartUnit(_value, unit, base);
+    }
+    case ILineChartMetricUnit.Percent: {
+      const [format, base, decimals, saturated] = UNIT_FORMATTER[type];
+      const { value, unit } = format(max, decimals, saturated);
+      const _value = Math.ceil(Number(value) / DIVISOR) * DIVISOR;
+      return convertLineChartUnit(_value, unit, base);
+    }
+    case ILineChartMetricUnit.Ratio: {
+      const [format, base] = UNIT_FORMATTER[type];
+      const { value, unit } = format(max * 100);
+      const _value = Math.ceil(Number(value) / DIVISOR) * DIVISOR;
+      return convertLineChartUnit(_value, unit, base) / 100;
+    }
+    default:
+      return 2;
+  }
+};
+const getYAxisDomain = (dataPoints, graphType, unitType) => {
+  const max = getLineChartYDataMax(dataPoints, graphType);
+  if (!max) {
+    if (unitType === ILineChartMetricUnit.Ratio) {
+      return [0, 1];
+    } else {
+      return [0, 2];
+    }
+  }
+  return [0, getYAxisUpperBound(max, unitType)];
+};
+function lineChartYaxisTickFormatter(value, unit) {
+  if (_.isNil(unit)) {
+    return `${value}`;
+  }
+  if (_.isNil(value)) {
+    return "0";
+  }
+  const [format] = UNIT_FORMATTER[unit];
+  const { value: _value, unit: _unit } = format(value);
+  return `${_value} ${_unit}`;
+}
+
+export { UNIT_FORMATTER, addMissingDataWithZero, convertLineChartDataStruct, convertLineChartUnit, deletePointsOutOfRange, filterLineChartDataOverlapping, filterLineChartOverlappingMetric, filterLineChartPointsByDateRange, getFirstExpectedTimestamp, getLineChartRangeTimestamp, getLineChartStep, getLineChartXAxisDomain, getLineChartYDataMax, getYAxisDomain, getYAxisUpperBound, lineChartTickFormatter, lineChartXaxisCal, lineChartYaxisTickFormatter, parseLineChartRange };

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

@@ -1,7 +1,7 @@
 import { LoadingWrapper, LoadingLine1, LoadingLine2, LoadingLine3 } from './style.js';
 import { FullView } from '../Styled/index.js';
-import React__default, { Fragment } from 'react';
 import cs from 'classnames';
+import React__default, { Fragment } from 'react';
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;

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

@@ -1,8 +1,8 @@
 import { styled } from '@linaria/react';
 import Link from '../Link/index.js';
-import { splitMap } from '../../utils/constants.js';
 import { IconField, Info } from './components.js';
 import Tag from '../Tag/index.js';
+import { splitMap } from '../../utils/constants.js';
 import React__default from 'react';
 
 var __defProp = Object.defineProperty;

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

@@ -1,6 +1,6 @@
 import { cx } from '@linaria/core';
 import Empty from '../Empty/index.js';
-import useParrotTranslation from '../../hooks/useParrotTranslation.js';
+import { ParrotTrans } from '../ParrotTrans/index.js';
 import isEmpty from '../../utils/isEmpty.js';
 import { formatSeconds } from '../../utils/tower.js';
 import React__default from 'react';
@@ -30,12 +30,20 @@ const Second = ({
   abbreviate,
   emptyProps
 }) => {
-  const { t } = useParrotTranslation();
   if (isEmpty(rawValue)) {
     return /* @__PURE__ */ React__default.createElement(Empty, __spreadValues({}, emptyProps));
   }
   const { value, unit } = formatSeconds(rawValue, decimals);
-  return /* @__PURE__ */ React__default.createElement("span", null, /* @__PURE__ */ React__default.createElement("span", { className: cx("value", valueClassName) }, value, " "), /* @__PURE__ */ React__default.createElement("span", { className: cx("unit", UnitStyle, unitClassName) }, t(`common.${abbreviate ? `${unit}_abbreviation` : unit}`)));
+  return /* @__PURE__ */ React__default.createElement(
+    ParrotTrans,
+    {
+      parent: "span",
+      i18nKey: `unit.${abbreviate ? `${unit}_abbreviation` : unit}`,
+      count: value
+    },
+    /* @__PURE__ */ React__default.createElement("span", { className: cx("value", valueClassName) }),
+    /* @__PURE__ */ React__default.createElement("span", { className: cx("unit", UnitStyle, unitClassName) })
+  );
 };
 var Second$1 = Second;
 

package/dist/esm/core/Timeline/Timeline.widget.js

@@ -1,12 +1,12 @@
-import React__default from 'react';
 import { cx } from '@linaria/core';
-import { splitMap } from '../../utils/constants.js';
 import Link from '../Link/index.js';
+import Tag from '../Tag/index.js';
 import { Typo } from '../Typo/index.js';
 import OverflowTooltip from '../../coreX/OverflowTooltip/index.js';
-import Tag from '../Tag/index.js';
+import { splitMap } from '../../utils/constants.js';
 import { Flex } from 'antd5';
 import cs from 'classnames';
+import React__default from 'react';
 import { InfoTextWrapper, SubInfoTextWrapper } from './Timeline.style.js';
 import { Show } from '../../coreX/Show/index.js';
 

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

@@ -1,11 +1,11 @@
 import { CheckmarkDoneSuccessCorrect16GreenIcon, XmarkFailed16RedIcon, Loading16GradientBlueIcon, NoticeTriangleFill16YellowIcon, WaitingBreathingLed16YellowIcon, TimelineNotStart16GrayIcon } from '@cloudtower/icons-react';
 import { cx } from '@linaria/core';
-import { Timeline as Timeline$1, Flex } from 'antd5';
-import React__default from 'react';
-import { EmptyWrapper, TimelineWrapper, TimelineItemWrapper } from './Timeline.style.js';
 import Alert from '../Alert/index.js';
 import Icon from '../Icon/index.js';
+import { Timeline as Timeline$1, Flex } from 'antd5';
 import cs from 'classnames';
+import React__default from 'react';
+import { EmptyWrapper, TimelineWrapper, TimelineItemWrapper } from './Timeline.style.js';
 import { TimelineArea } from './Timeline.widget.js';
 
 var __defProp = Object.defineProperty;

package/dist/esm/coreX/CheckPointList/index.js

@@ -1,8 +1,8 @@
-import React__default, { useState, useCallback } from 'react';
-import useParrotTranslation from '../../hooks/useParrotTranslation.js';
 import { XmarkFailedSeriousWarningFill16RedIcon, CheckmarkDoneSuccessCircleFill16GreenIcon, Loading16GradientBlueIcon, NoticeTriangleFill16YellowIcon } from '@cloudtower/icons-react';
-import { List } from 'antd5';
 import { cx } from '@linaria/core';
+import useParrotTranslation from '../../hooks/useParrotTranslation.js';
+import { List } from 'antd5';
+import React__default, { useState, useCallback } from 'react';
 import { CheckPointItemStyle, CheckPointListStyle, EmptyWrapper } from './checkpointlist.style.js';
 import { Show } from '../Show/index.js';
 import Icon from '../../core/Icon/index.js';
@@ -60,14 +60,15 @@ const CheckPointList = ({
   emptyRender,
   emptyText,
   emptyTextClassName,
-  onClickSwitch
+  onClickSwitch,
+  defaultChecked = false
 }) => {
   const { t } = useParrotTranslation();
-  const [checked, setChecked] = useState(false);
+  const [checked, setChecked] = useState(defaultChecked);
   const onClickSwitchFn = useCallback(() => {
     const nextChecked = !checked;
     setChecked(nextChecked);
-    onClickSwitch == null ? void 0 : onClickSwitch(checked);
+    onClickSwitch == null ? void 0 : onClickSwitch(nextChecked);
   }, [onClickSwitch, checked]);
   const isEmpty = !items.length;
   return /* @__PURE__ */ React__default.createElement("div", { className: cx(CheckPointListStyle) }, /* @__PURE__ */ React__default.createElement("header", { className: cx(Typo.Label.l4_bold) }, title, /* @__PURE__ */ React__default.createElement(Show, { condition: showSwitchControl }, /* @__PURE__ */ React__default.createElement("span", { className: "switch-text" }, /* @__PURE__ */ React__default.createElement(Switch, { checked, onChange: onClickSwitchFn, size: "small" }), /* @__PURE__ */ React__default.createElement("span", null, switchText || t("common.show_unpassed"))))), /* @__PURE__ */ React__default.createElement(

package/dist/esm/coreX/CircleLoading/index.js

@@ -1,8 +1,8 @@
-import { FullView } from '../../core/Styled/index.js';
+import { Loading64GradientBlueIcon } from '@cloudtower/icons-react';
 import Icon from '../../core/Icon/index.js';
-import React__default, { Fragment } from 'react';
+import { FullView } from '../../core/Styled/index.js';
 import cs from 'classnames';
-import { Loading64GradientBlueIcon } from '@cloudtower/icons-react';
+import React__default, { Fragment } from 'react';
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;