@cloudtower/eagle 0.0.0-no-uikit-1 → 0.0.0-theme-rc-1

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

@@ -0,0 +1,455 @@
+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 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();
+  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, extraValues = []) => {
+  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,
+    ...extraValues.filter((value) => Number.isFinite(value))
+  );
+};
+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, extraValues = []) => {
+  const max = getLineChartYDataMax(dataPoints, graphType, extraValues);
+  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, 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_l48ei06";
+const LinkStyle = "E_0_0_0_theme_rc_1_l48ei06";
 const Link = React__default.forwardRef((_a, ref) => {
   var _b = _a,
     {

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

@@ -1,5 +1,6 @@
 import { LoadingWrapper, LoadingLine1, LoadingLine2, LoadingLine3 } from './style.js';
 import { FullView } from '../Styled/index.js';
+import cs from 'classnames';
 import React__default, { Fragment } from 'react';
 
 var __defProp = Object.defineProperty;
@@ -21,10 +22,29 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-const Loading = ({ fullView = true }) => {
+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 ? FullView : Fragment;
   const props = fullView ? { className: "loading-full-view" } : {};
-  return /* @__PURE__ */ React__default.createElement(Wrapper, __spreadProps(__spreadValues({}, props), { "data-testid": "loading" }), /* @__PURE__ */ React__default.createElement("div", { className: LoadingWrapper }, /* @__PURE__ */ React__default.createElement("div", { className: LoadingLine1 }), /* @__PURE__ */ React__default.createElement("div", { className: LoadingLine2 }), /* @__PURE__ */ React__default.createElement("div", { className: LoadingLine3 })));
+  return /* @__PURE__ */ React__default.createElement(Wrapper, __spreadProps(__spreadValues({}, props), { "data-testid": "loading" }), /* @__PURE__ */ React__default.createElement("div", __spreadValues({ className: cs(LoadingWrapper, className) }, restProps), /* @__PURE__ */ React__default.createElement("div", { className: LoadingLine1 }), /* @__PURE__ */ React__default.createElement("div", { className: LoadingLine2 }), /* @__PURE__ */ React__default.createElement("div", { className: LoadingLine3 })));
 };
 var Loading$1 = Loading;
 

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

@@ -1,6 +1,6 @@
-const LoadingWrapper = "E_lht19u8";
-const LoadingLine1 = "E_lk3gkp4";
-const LoadingLine2 = "E_ll4n94n";
-const LoadingLine3 = "E_l17lbdo6";
+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";
 
 export { LoadingLine1, LoadingLine2, LoadingLine3, LoadingWrapper };

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

@@ -0,0 +1,66 @@
+import { useRef, useEffect } from 'react';
+
+const useFileValidation = ({
+  fileList,
+  setFileList,
+  validate,
+  createNewFile = false
+}) => {
+  const latestFileList = useRef(fileList);
+  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 = useRef(fileList.length);
+  useEffect(() => {
+    if (fileList.length === fileCountRef.current) {
+      return;
+    }
+    fileCountRef.current = fileList.length;
+    if (fileCountRef.current <= maxCount) {
+      setError("");
+    }
+  }, [fileList.length, maxCount, setError]);
+};
+
+export { useFileCountErrorClear, useFileValidation };

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

@@ -0,0 +1,117 @@
+import useParrotTranslation from '../../hooks/useParrotTranslation.js';
+import cs from 'classnames';
+import React__default from 'react';
+import { UploadWrapper } from './LocalUpload.style.js';
+import { UploadLabel, UploadDescription, UploadButton, UploadDragger, UploadFileList, UploadFileInfo } from './LocalUpload.widget.js';
+
+var __defProp = Object.defineProperty;
+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;
+};
+const UploadComp = React__default.forwardRef(
+  ({
+    className,
+    "data-testid": dataTestId,
+    label,
+    labelPosition = "top",
+    description,
+    type = "dragger",
+    multiple = false,
+    accept,
+    disabled,
+    maxCount,
+    info,
+    fileList,
+    setFileList,
+    validate,
+    buttonProps,
+    disableRemoveList = false,
+    onRemove,
+    error
+  }, ref) => {
+    const { t } = useParrotTranslation();
+    const removeFile = (id) => {
+      const nextFileList = fileList.filter((file) => file.uid !== id);
+      if (nextFileList.length !== fileList.length) {
+        setFileList(nextFileList);
+      }
+    };
+    const _maxCount = multiple ? maxCount || Infinity : 1;
+    const isSingleSelect = _maxCount === 1;
+    const shouldShowDescriptionAbove = !!description && !!label && labelPosition === "top";
+    const shouldShowDescriptionBelow = !!description && !shouldShowDescriptionAbove;
+    const shouldDisableRemove = disabled || disableRemoveList;
+    const uploadContent = /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, shouldShowDescriptionAbove ? /* @__PURE__ */ React__default.createElement(UploadComp.Description, null, description) : null, type === "button" ? /* @__PURE__ */ React__default.createElement(
+      UploadComp.Button,
+      __spreadValues({}, __spreadValues({
+        accept,
+        multiple,
+        disabled,
+        maxCount,
+        fileList,
+        setFileList,
+        validate,
+        error
+      }, buttonProps)),
+      t("components.select_file")
+    ) : /* @__PURE__ */ React__default.createElement(
+      UploadComp.Dragger,
+      __spreadValues({}, {
+        accept,
+        multiple,
+        disabled,
+        maxCount,
+        fileList,
+        setFileList,
+        validate,
+        disableRemove: shouldDisableRemove,
+        onRemove,
+        error
+      })
+    ), shouldShowDescriptionBelow ? /* @__PURE__ */ React__default.createElement(UploadComp.Description, { className: "description-below" }, description) : null, info, type === "button" || !isSingleSelect ? /* @__PURE__ */ React__default.createElement(
+      UploadComp.FileList,
+      {
+        fileList,
+        removeFile,
+        disableRemove: shouldDisableRemove,
+        onRemove
+      }
+    ) : null);
+    return /* @__PURE__ */ React__default.createElement(
+      UploadComp.Wrapper,
+      {
+        className: cs(
+          className,
+          label && labelPosition === "left" ? "label-left" : "label-top",
+          !label && "no-label"
+        ),
+        ref,
+        "data-testid": dataTestId
+      },
+      label ? /* @__PURE__ */ React__default.createElement(UploadComp.Label, null, label) : null,
+      labelPosition === "left" && label ? /* @__PURE__ */ React__default.createElement("div", { className: "upload-main" }, uploadContent) : uploadContent
+    );
+  }
+);
+UploadComp.Wrapper = UploadWrapper;
+UploadComp.Label = UploadLabel;
+UploadComp.Description = UploadDescription;
+UploadComp.Button = UploadButton;
+UploadComp.Dragger = UploadDragger;
+UploadComp.FileList = UploadFileList;
+UploadComp.FileInfo = UploadFileInfo;
+const LocalUpload = UploadComp;
+
+export { LocalUpload };