@cloudtower/eagle 0.0.0-testid-rc-0 → 0.0.0-theme-rc-1

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

@@ -0,0 +1,483 @@
+'use strict';
+
+var type = require('./type.js');
+var tower = require('../../utils/tower.js');
+var dayjs = require('dayjs');
+var _ = require('lodash');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefault(dayjs);
+var ___default = /*#__PURE__*/_interopDefault(_);
+
+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__default.default(), dayjs__default.default()];
+  return points == null ? void 0 : points.filter((point) => {
+    const pointDate = dayjs__default.default(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 * tower.HOUR * 1e3) {
+    return dayjs__default.default(tick).format("HH:mm:ss");
+  }
+  if (rangeTime <= 4 * tower.DAY * 1e3) {
+    return dayjs__default.default(tick).format("MM/DD HH:mm:ss");
+  }
+  return dayjs__default.default(tick).format("MM/DD");
+};
+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 ___default.default.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();
+  if (range <= 2 * 60 * 60 * 1e3) {
+    return tower.SECOND * 30 * 1e3;
+  }
+  if (range <= 24 * 60 * 60 * 1e3) {
+    return tower.MINUTE * 5 * 1e3;
+  }
+  if (range <= 7 * 24 * 60 * 60 * 1e3) {
+    return tower.MINUTE * 30 * 1e3;
+  }
+  if (range <= 30 * 24 * 60 * 60 * 1e3) {
+    return tower.DAY * 1e3;
+  }
+  return tower.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 = ___default.default.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 = ___default.default.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__default.default(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 * tower.MINUTE:
+      return 5 * 1e3;
+    case 15 * tower.MINUTE:
+      return 15 * 1e3;
+    case 1 * tower.HOUR:
+      return 60 * 1e3;
+    case 2 * tower.HOUR:
+      return 120 * 1e3;
+    case 24 * tower.HOUR:
+      return 10 * 60 * 1e3;
+    case 7 * tower.DAY:
+    case 30 * tower.DAY:
+      return 60 * 60 * 1e3;
+    case 182 * tower.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 = tower.unitRules.findIndex((rule) => rule.unit.includes(from));
+  if (ruleIndex === -1) {
+    return value;
+  }
+  const { unit, divider } = tower.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 ___default.default.isInteger(value) ? value : ___default.default.isNil(decimals) ? value : parseFloat(value.toFixed(decimals));
+};
+const UNIT_FORMATTER = {
+  [type.ILineChartMetricUnit.Percent]: [tower.formatPercent, "%", 2, false],
+  [type.ILineChartMetricUnit.Ratio]: [tower.formatPercent, "%"],
+  [type.ILineChartMetricUnit.Count]: [tower.formatCount, ""],
+  [type.ILineChartMetricUnit.DataSize]: [tower.formatBytes, "B"],
+  [type.ILineChartMetricUnit.DataRateByte]: [tower.formatBps, "Bps"],
+  [type.ILineChartMetricUnit.DataRateBit]: [tower.formatBitPerSecond, "bps"],
+  [type.ILineChartMetricUnit.Time]: [tower.formatNanoSecond, "ns"],
+  [type.ILineChartMetricUnit.Frequency]: [tower.formatFrequency, "Hz"],
+  [type.ILineChartMetricUnit.Temperature]: [tower.formatTemperature, "\u2103"],
+  [type.ILineChartMetricUnit.Load]: [tower.formatCount, ""]
+};
+const getLineChartYDataMax = (dataPoints, type$1, extraValues = []) => {
+  const values = dataPoints.map((p) => {
+    if (___default.default.isNumber(p == null ? void 0 : p.v)) {
+      return p.v;
+    }
+    const entries = Object.entries(p);
+    if (type$1 === type.ILineChartGraphType.Stack) {
+      let sum = 0;
+      for (const [key, value] of entries) {
+        if (/^v(\d*)$/.test(key) && ___default.default.isNumber(value)) {
+          sum += value;
+        }
+      }
+      return sum;
+    } else {
+      let max = 0;
+      for (const [key, value] of entries) {
+        if (/^v(\d*)$/.test(key) && ___default.default.isNumber(value) && value > max) {
+          max = value;
+        }
+      }
+      return max;
+    }
+  });
+  return Math.max(
+    ...values,
+    0,
+    ...extraValues.filter((value) => Number.isFinite(value))
+  );
+};
+const getYAxisUpperBound = (max, type$1) => {
+  const DIVISOR = 2;
+  switch (type$1) {
+    case type.ILineChartMetricUnit.Count:
+    case type.ILineChartMetricUnit.Load:
+    case type.ILineChartMetricUnit.DataSize:
+    case type.ILineChartMetricUnit.DataRateByte:
+    case type.ILineChartMetricUnit.Time:
+    case type.ILineChartMetricUnit.Frequency:
+    case type.ILineChartMetricUnit.DataRateBit:
+    case type.ILineChartMetricUnit.Temperature: {
+      const [format, base] = UNIT_FORMATTER[type$1];
+      const { value, unit } = format(max);
+      const _value = Math.ceil(Number(value) / DIVISOR) * DIVISOR;
+      return convertLineChartUnit(_value, unit, base);
+    }
+    case type.ILineChartMetricUnit.Percent: {
+      const [format, base, decimals, saturated] = UNIT_FORMATTER[type$1];
+      const { value, unit } = format(max, decimals, saturated);
+      const _value = Math.ceil(Number(value) / DIVISOR) * DIVISOR;
+      return convertLineChartUnit(_value, unit, base);
+    }
+    case type.ILineChartMetricUnit.Ratio: {
+      const [format, base] = UNIT_FORMATTER[type$1];
+      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, extraValues = []) => {
+  const max = getLineChartYDataMax(dataPoints, graphType, extraValues);
+  if (!max) {
+    if (unitType === type.ILineChartMetricUnit.Ratio) {
+      return [0, 1];
+    } else {
+      return [0, 2];
+    }
+  }
+  return [0, getYAxisUpperBound(max, unitType)];
+};
+function lineChartYaxisTickFormatter(value, unit) {
+  if (___default.default.isNil(unit)) {
+    return `${value}`;
+  }
+  if (___default.default.isNil(value)) {
+    return "0";
+  }
+  const [format] = UNIT_FORMATTER[unit];
+  const { value: _value, unit: _unit } = format(value);
+  return `${_value} ${_unit}`;
+}
+
+exports.UNIT_FORMATTER = UNIT_FORMATTER;
+exports.addMissingDataWithZero = addMissingDataWithZero;
+exports.convertLineChartDataStruct = convertLineChartDataStruct;
+exports.convertLineChartUnit = convertLineChartUnit;
+exports.deletePointsOutOfRange = deletePointsOutOfRange;
+exports.filterLineChartDataOverlapping = filterLineChartDataOverlapping;
+exports.filterLineChartOverlappingMetric = filterLineChartOverlappingMetric;
+exports.filterLineChartPointsByDateRange = filterLineChartPointsByDateRange;
+exports.getFirstExpectedTimestamp = getFirstExpectedTimestamp;
+exports.getLineChartAreaHighlightRanges = getLineChartAreaHighlightRanges;
+exports.getLineChartMetricPayloadMatches = getLineChartMetricPayloadMatches;
+exports.getLineChartRangeTimestamp = getLineChartRangeTimestamp;
+exports.getLineChartStep = getLineChartStep;
+exports.getLineChartThresholdIntersections = getLineChartThresholdIntersections;
+exports.getLineChartXAxisDomain = getLineChartXAxisDomain;
+exports.getLineChartYDataMax = getLineChartYDataMax;
+exports.getYAxisDomain = getYAxisDomain;
+exports.getYAxisUpperBound = getYAxisUpperBound;
+exports.lineChartTickFormatter = lineChartTickFormatter;
+exports.lineChartXaxisCal = lineChartXaxisCal;
+exports.lineChartYaxisTickFormatter = lineChartYaxisTickFormatter;
+exports.parseLineChartRange = parseLineChartRange;

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

@@ -0,0 +1,62 @@
+'use strict';
+
+var index = require('../Button/index.js');
+var cs = require('classnames');
+var React = require('react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var cs__default = /*#__PURE__*/_interopDefault(cs);
+var React__default = /*#__PURE__*/_interopDefault(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));
+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;
+};
+const LinkStyle = "E_0_0_0_theme_rc_1_l48ei06";
+const Link = React__default.default.forwardRef((_a, ref) => {
+  var _b = _a,
+    {
+      className,
+      disabled,
+      type = "default"
+    } = _b,
+    props = __objRest(_b, ["className", "disabled", "type"]);
+  return /* @__PURE__ */React__default.default.createElement(index, __spreadProps(__spreadValues({}, props), {
+    ref,
+    disabled,
+    className: cs__default.default(LinkStyle, className, {
+      "ui-kit-link-disabled": disabled,
+      "ui-kit-link-primary": type === "primary",
+      "ui-kit-link-secondary": type === "secondary"
+    }),
+    type: "link"
+  }));
+});
+var Link$1 = Link;
+
+module.exports = Link$1;

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

@@ -0,0 +1,58 @@
+'use strict';
+
+var style = require('./style.js');
+var index = require('../Styled/index.js');
+var cs = require('classnames');
+var React = require('react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var cs__default = /*#__PURE__*/_interopDefault(cs);
+var React__default = /*#__PURE__*/_interopDefault(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));
+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;
+};
+const Loading = (_a) => {
+  var _b = _a, {
+    fullView = true,
+    className
+  } = _b, restProps = __objRest(_b, [
+    "fullView",
+    "className"
+  ]);
+  const Wrapper = fullView ? index.FullView : React.Fragment;
+  const props = fullView ? { className: "loading-full-view" } : {};
+  return /* @__PURE__ */ React__default.default.createElement(Wrapper, __spreadProps(__spreadValues({}, props), { "data-testid": "loading" }), /* @__PURE__ */ React__default.default.createElement("div", __spreadValues({ className: cs__default.default(style.LoadingWrapper, className) }, restProps), /* @__PURE__ */ React__default.default.createElement("div", { className: style.LoadingLine1 }), /* @__PURE__ */ React__default.default.createElement("div", { className: style.LoadingLine2 }), /* @__PURE__ */ React__default.default.createElement("div", { className: style.LoadingLine3 })));
+};
+var Loading$1 = Loading;
+
+module.exports = Loading$1;

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

@@ -0,0 +1,11 @@
+'use strict';
+
+const LoadingWrapper = "E_0_0_0_theme_rc_1_lht19u8";
+const LoadingLine1 = "E_0_0_0_theme_rc_1_lk3gkp4";
+const LoadingLine2 = "E_0_0_0_theme_rc_1_ll4n94n";
+const LoadingLine3 = "E_0_0_0_theme_rc_1_l17lbdo6";
+
+exports.LoadingLine1 = LoadingLine1;
+exports.LoadingLine2 = LoadingLine2;
+exports.LoadingLine3 = LoadingLine3;
+exports.LoadingWrapper = LoadingWrapper;

package/dist/cjs/core/LocalUpload/LocalUpload.hooks.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var React = require('react');
+
+const useFileValidation = ({
+  fileList,
+  setFileList,
+  validate,
+  createNewFile = false
+}) => {
+  const latestFileList = React.useRef(fileList);
+  React.useEffect(() => {
+    latestFileList.current = fileList;
+    if (!validate)
+      return;
+    const updateFile = (fileId, file) => {
+      const currentList = latestFileList.current;
+      const index = currentList.findIndex((f) => f.uid === fileId);
+      if (index !== -1) {
+        const newList = [...currentList];
+        const fileToUpdate = createNewFile ? (() => {
+          const newFile = new File([file], file.name, { type: file.type });
+          Object.assign(newFile, file);
+          return newFile;
+        })() : file;
+        newList.splice(index, 1, fileToUpdate);
+        setFileList(newList);
+      }
+    };
+    for (const _file of fileList) {
+      if (_file.fileStatus !== "need-validate") {
+        continue;
+      }
+      _file.fileStatus = "validating";
+      updateFile(_file.uid, _file);
+      validate(_file, fileList).then((result) => {
+        if (result.error) {
+          _file.error = result.error;
+          _file.fileStatus = "error";
+        } else {
+          _file.error = void 0;
+          _file.fileStatus = "success";
+          _file.data = result.data;
+        }
+        updateFile(_file.uid, _file);
+        return;
+      });
+    }
+  }, [fileList, setFileList, validate, createNewFile]);
+};
+const useFileCountErrorClear = ({
+  fileList,
+  maxCount,
+  setError
+}) => {
+  const fileCountRef = React.useRef(fileList.length);
+  React.useEffect(() => {
+    if (fileList.length === fileCountRef.current) {
+      return;
+    }
+    fileCountRef.current = fileList.length;
+    if (fileCountRef.current <= maxCount) {
+      setError("");
+    }
+  }, [fileList.length, maxCount, setError]);
+};
+
+exports.useFileCountErrorClear = useFileCountErrorClear;
+exports.useFileValidation = useFileValidation;