@cloudtower/eagle 4100.0.17 → 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_17_mn7joto";
-const LegendStyle = "E_4100_0_17_l1bifhon";
-const LegendItemsStyle = "E_4100_0_17_ltthzck";
-const LegendItemsStyleDropdown = "E_4100_0_17_l1mumj7o";
-const ExtraResource = "E_4100_0_17_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_17_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_17_t2pr38p",
+  class: "E_4100_0_19_tjhvvia",
   propsAsIs: false
 });
 const TooltipColumn = /*#__PURE__*/styled('div')({
   name: "TooltipColumn",
-  class: "E_4100_0_17_tecdsj7",
+  class: "E_4100_0_19_tuyrup3",
   propsAsIs: false
 });
-const LineChartColorBlockStyle = "E_4100_0_17_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_17_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_17_lht19u8";
-const LoadingLine1 = "E_4100_0_17_lk3gkp4";
-const LoadingLine2 = "E_4100_0_17_ll4n94n";
-const LoadingLine3 = "E_4100_0_17_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.hooks.js

@@ -1,4 +1,4 @@
-import { useEffect, useRef } from 'react';
+import { useRef, useEffect } from 'react';
 
 const useFileValidation = ({
   fileList,
@@ -6,13 +6,16 @@ const useFileValidation = ({
   validate,
   createNewFile = false
 }) => {
+  const latestFileList = useRef(fileList);
   useEffect(() => {
+    latestFileList.current = fileList;
     if (!validate)
       return;
     const updateFile = (fileId, file) => {
-      const index = fileList.findIndex((f) => f.uid === fileId);
+      const currentList = latestFileList.current;
+      const index = currentList.findIndex((f) => f.uid === fileId);
       if (index !== -1) {
-        const newList = [...fileList];
+        const newList = [...currentList];
         const fileToUpdate = createNewFile ? (() => {
           const newFile = new File([file], file.name, { type: file.type });
           Object.assign(newFile, file);

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

@@ -1,4 +1,5 @@
 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';
@@ -24,6 +25,7 @@ const UploadComp = React__default.forwardRef(
     className,
     "data-testid": dataTestId,
     label,
+    labelPosition = "top",
     description,
     type = "dragger",
     multiple = false,
@@ -35,66 +37,71 @@ const UploadComp = React__default.forwardRef(
     setFileList,
     validate,
     buttonProps,
-    listType = "list",
     disableRemoveList = false,
-    onRemove
+    onRemove,
+    error
   }, ref) => {
     const { t } = useParrotTranslation();
     const removeFile = (id) => {
-      const index = fileList.findIndex((f) => f.uid === id);
-      if (index !== -1) {
-        const file = fileList[index];
-        fileList.splice(index, 1);
-        setFileList([...fileList]);
-        onRemove == null ? void 0 : onRemove(file);
+      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,
+        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,
-      description ? /* @__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
-        }, buttonProps)),
-        t("components.select_file")
-      ) : /* @__PURE__ */ React__default.createElement(
-        UploadComp.Dragger,
-        __spreadValues({}, {
-          accept,
-          multiple,
-          disabled,
-          maxCount,
-          fileList,
-          setFileList,
-          validate
-        })
-      ),
-      info != null ? info : /* @__PURE__ */ React__default.createElement(React__default.Fragment, null),
-      type === "button" || !isSingleSelect ? /* @__PURE__ */ React__default.createElement(
-        UploadComp.FileList,
-        {
-          fileList,
-          removeFile,
-          type: listType,
-          disableRemove: disableRemoveList,
-          onRemove
-        }
-      ) : null
+      labelPosition === "left" && label ? /* @__PURE__ */ React__default.createElement("div", { className: "upload-main" }, uploadContent) : uploadContent
     );
   }
 );

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_17_u3l9ivi",
+  class: "E_4100_0_19_u3l9ivi",
   propsAsIs: false
 });
-const FileInfoWrapperStyle = "E_4100_0_17_ftdwz1g";
+const FileInfoWrapperStyle = "E_4100_0_19_ftdwz1g";
 
 export { FileInfoWrapperStyle, UploadWrapper };