@cloudtower/eagle 0.32.40 → 0.32.41

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/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';

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;

package/dist/esm/coreX/DateRangePicker/Calendar.js

@@ -1,4 +1,5 @@
 import { ArrowChevronUp16BoldBlueIcon, ArrowChevronDown16BoldBlueIcon } from '@cloudtower/icons-react';
+import { parrotI18n } from '@cloudtower/parrot';
 import { cx } from '@linaria/core';
 import Button from '../../core/Button/index.js';
 import Icon from '../../core/Icon/index.js';
@@ -10,7 +11,6 @@ import dayjs from 'dayjs';
 import React__default, { useState, useEffect, useRef } from 'react';
 import { getDiffMonthAndDate, getTime, checkDateNotInRange, getClassNameForDateBlock } from './common.js';
 import { CalendarStyle } from './DateRangePicker.style.js';
-import { parrotI18n } from '@cloudtower/parrot';
 import { getCalendarTitle } from '../common/getCalendarTitle.js';
 
 const Year = (props) => {

package/dist/esm/coreX/Dialogs/DeleteDialog/DeleteDialog.js

@@ -0,0 +1,41 @@
+import { cx } from '@linaria/core';
+import { Typo } from '../../../core/Typo/index.js';
+import useParrotTranslation from '../../../hooks/useParrotTranslation.js';
+import React__default from 'react';
+import { SmallDialog } from '../SmallDialog.js';
+
+const ContentStyle = "E_cevhqx7";
+const SecondaryDescStyle = "E_snbqlt4";
+const DeleteDialog = props => {
+  const {
+    t
+  } = useParrotTranslation();
+  const {
+    title,
+    description,
+    secondaryDesc,
+    cancelText = t("common.cancel"),
+    okText = t("common.delete"),
+    onOk,
+    onCancel,
+    className
+  } = props;
+  return /* @__PURE__ */React__default.createElement(SmallDialog, {
+    title,
+    showOk: true,
+    onOk,
+    onCancel,
+    className,
+    okText,
+    cancelText,
+    okButtonProps: {
+      danger: true
+    }
+  }, description && /* @__PURE__ */React__default.createElement("div", {
+    className: cx(ContentStyle, Typo.Label.l2_regular)
+  }, description), secondaryDesc && /* @__PURE__ */React__default.createElement("div", {
+    className: cx(SecondaryDescStyle, Typo.Label.l3_regular)
+  }, secondaryDesc));
+};
+
+export { DeleteDialog };

package/dist/esm/coreX/Dialogs/RejectDialog/RejectDialog.js

@@ -0,0 +1,81 @@
+import { cx } from '@linaria/core';
+import { Typo } from '../../../core/Typo/index.js';
+import React__default from 'react';
+import { SmallDialog } from '../SmallDialog.js';
+import { RejectDialogType } from './RejectDialog.type.js';
+
+const ContentList = "E_c1ss4prm";
+const MultiRejectContentList = "E_ms3tlei";
+const Description = "E_du44iy7";
+const SecondaryDesc = "E_s1qmhanr";
+const Divider = "E_drje1h0";
+const SingleRejectContent = ({
+  content
+}) => {
+  if (Array.isArray(content) && content.length > 1) {
+    return /* @__PURE__ */React__default.createElement("div", {
+      className: cx(ContentList)
+    }, content.map((reason, index) => /* @__PURE__ */React__default.createElement("li", {
+      className: Typo.Label.l4_regular,
+      key: index
+    }, index + 1, ". ", reason)));
+  }
+  return /* @__PURE__ */React__default.createElement("div", {
+    className: cx(ContentList, Typo.Label.l4_regular)
+  }, content);
+};
+const MultiRejectContent = ({
+  content
+}) => /* @__PURE__ */React__default.createElement("div", {
+  className: cx(MultiRejectContentList)
+}, Object.entries(content).map(([name, reasons], index) => /* @__PURE__ */React__default.createElement("li", {
+  className: Typo.Label.l4_regular,
+  key: index
+}, name, ": ", reasons.join("; "))));
+const RejectDialog = props => {
+  const {
+    title,
+    cancelText,
+    description,
+    className,
+    footerClassName
+  } = props;
+  const renderContent = () => {
+    switch (props.type) {
+      case RejectDialogType.Single:
+        return /* @__PURE__ */React__default.createElement(SingleRejectContent, {
+          content: props.content
+        });
+      case RejectDialogType.All:
+      case RejectDialogType.Part:
+        return /* @__PURE__ */React__default.createElement(React__default.Fragment, null, props.secondaryDesc && /* @__PURE__ */React__default.createElement("div", {
+          className: cx(SecondaryDesc, Typo.Label.l4_regular)
+        }, props.secondaryDesc), props.type === RejectDialogType.Part && /* @__PURE__ */React__default.createElement(React__default.Fragment, null, /* @__PURE__ */React__default.createElement("div", {
+          className: Divider
+        }), /* @__PURE__ */React__default.createElement("div", {
+          className: cx(Description, Typo.Label.l3_regular)
+        }, props.partialDescription)), /* @__PURE__ */React__default.createElement(MultiRejectContent, {
+          content: props.content
+        }));
+      case RejectDialogType.Custom:
+        return props.customContent;
+    }
+  };
+  return /* @__PURE__ */React__default.createElement(SmallDialog, {
+    title,
+    cancelText,
+    showOk: props.type === RejectDialogType.Part,
+    okText: props.type === RejectDialogType.Part ? props.okText : void 0,
+    onOk: props.type === RejectDialogType.Part ? props.onOk : void 0,
+    okButtonProps: {
+      danger: props.type === RejectDialogType.Part
+    },
+    onCancel: props.onCancel,
+    className,
+    footerClassName
+  }, description && /* @__PURE__ */React__default.createElement("div", {
+    className: cx(Description, Typo.Label.l3_regular)
+  }, description), renderContent());
+};
+
+export { RejectDialog };

package/dist/esm/coreX/Dialogs/RejectDialog/RejectDialog.type.js

@@ -0,0 +1,9 @@
+var RejectDialogType = /* @__PURE__ */ ((RejectDialogType2) => {
+  RejectDialogType2["Single"] = "RejectSingle";
+  RejectDialogType2["All"] = "RejectAll";
+  RejectDialogType2["Part"] = "RejectPart";
+  RejectDialogType2["Custom"] = "RejectCustom";
+  return RejectDialogType2;
+})(RejectDialogType || {});
+
+export { RejectDialogType };