@dtjoy/dt-design 1.0.0 → 1.0.2

package/esm/splitter/hooks/useSizes.js

@@ -0,0 +1,80 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import React from 'react';
+import { autoPtgSizes } from "./sizeUtil";
+export function getPtg(str) {
+  return Number(str.slice(0, -1)) / 100;
+}
+function isPtg(itemSize) {
+  return typeof itemSize === 'string' && itemSize.endsWith('%');
+}
+export default function useSizes(items, containerSize) {
+  var propSizes = items.map(function (item) {
+    return item.size;
+  });
+  var itemsCount = items.length;
+  var mergedContainerSize = containerSize || 0;
+  var ptg2px = function ptg2px(ptg) {
+    return ptg * mergedContainerSize;
+  };
+  var _React$useState = React.useState(function () {
+      return items.map(function (item) {
+        return item.defaultSize;
+      });
+    }),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    innerSizes = _React$useState2[0],
+    setInnerSizes = _React$useState2[1];
+  var sizes = React.useMemo(function () {
+    var mergedSizes = [];
+    for (var i = 0; i < itemsCount; i += 1) {
+      var _propSizes$i;
+      mergedSizes[i] = (_propSizes$i = propSizes[i]) !== null && _propSizes$i !== void 0 ? _propSizes$i : innerSizes[i];
+    }
+    return mergedSizes;
+  }, [itemsCount, innerSizes, propSizes]);
+  var postPercentMinSizes = React.useMemo(function () {
+    return items.map(function (item) {
+      if (isPtg(item.min)) {
+        return getPtg(item.min);
+      }
+      return (item.min || 0) / mergedContainerSize;
+    });
+  }, [items, mergedContainerSize]);
+  var postPercentMaxSizes = React.useMemo(function () {
+    return items.map(function (item) {
+      if (isPtg(item.max)) {
+        return getPtg(item.max);
+      }
+      return (item.max || mergedContainerSize) / mergedContainerSize;
+    });
+  }, [items, mergedContainerSize]);
+  var postPercentSizes = React.useMemo(function () {
+    var ptgList = [];
+    for (var i = 0; i < itemsCount; i += 1) {
+      var itemSize = sizes[i];
+      if (isPtg(itemSize)) {
+        ptgList[i] = getPtg(itemSize);
+      } else if (itemSize || itemSize === 0) {
+        var num = Number(itemSize);
+        if (!Number.isNaN(num)) {
+          ptgList[i] = num / mergedContainerSize;
+        }
+      } else {
+        ptgList[i] = undefined;
+      }
+    }
+    return autoPtgSizes(ptgList, postPercentMinSizes, postPercentMaxSizes);
+  }, [sizes, mergedContainerSize, postPercentMinSizes, postPercentMaxSizes]);
+  var postPxSizes = React.useMemo(function () {
+    return postPercentSizes.map(ptg2px);
+  }, [postPercentSizes, mergedContainerSize]);
+  var panelSizes = React.useMemo(function () {
+    return containerSize ? postPxSizes : sizes;
+  }, [postPxSizes, containerSize]);
+  return [panelSizes, postPxSizes, postPercentSizes, postPercentMinSizes, postPercentMaxSizes, setInnerSizes];
+}

package/esm/splitter/index.d.ts

@@ -0,0 +1,8 @@
+import Panel from './Panel';
+import SplitterComp from './Splitter';
+export type { SplitterProps } from './interface';
+declare type CompoundedComponent = typeof SplitterComp & {
+    Panel: typeof Panel;
+};
+declare const Splitter: CompoundedComponent;
+export default Splitter;

package/esm/splitter/index.js

@@ -0,0 +1,5 @@
+import Panel from "./Panel";
+import SplitterComp from "./Splitter";
+var Splitter = SplitterComp;
+Splitter.Panel = Panel;
+export default Splitter;

package/esm/splitter/interface.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="react" />
+import { ShowCollapsibleIconMode } from './SplitBar';
+export interface SplitterProps {
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    rootClassName?: string;
+    layout?: 'horizontal' | 'vertical';
+    onResizeStart?: (sizes: number[]) => void;
+    onResize?: (sizes: number[]) => void;
+    onResizeEnd?: (sizes: number[]) => void;
+    lazy?: boolean;
+}
+export interface PanelProps {
+    className?: string;
+    style?: React.CSSProperties;
+    min?: number | string;
+    max?: number | string;
+    size?: number | string;
+    collapsible?: boolean | {
+        start?: boolean;
+        end?: boolean;
+        showCollapsibleIcon?: ShowCollapsibleIconMode;
+    };
+    resizable?: boolean;
+    defaultSize?: number | string;
+}
+export interface InternalPanelProps extends PanelProps {
+    className?: string;
+    prefixCls?: string;
+}
+export interface UseResizeProps extends Pick<SplitterProps, 'onResize'> {
+    basicsState: number[];
+    items: PanelProps[];
+    panelsRef: React.RefObject<(HTMLDivElement | null)[]>;
+    reverse: boolean;
+    setBasicsState: React.Dispatch<React.SetStateAction<number[]>>;
+}
+export interface UseResize {
+    setSize: (data: {
+        size: number;
+        index: number;
+    }[]) => void;
+    setOffset: (offset: number, containerSize: number, index: number) => void;
+}
+export interface UseHandleProps extends Pick<SplitterProps, 'layout' | 'onResizeStart' | 'onResizeEnd'> {
+    basicsState: number[];
+    containerRef?: React.RefObject<HTMLDivElement | null>;
+    setOffset: UseResize['setOffset'];
+    setResizing: React.Dispatch<React.SetStateAction<boolean>>;
+}
+export interface UseHandle {
+    onStart: (x: number, y: number, index: number) => void;
+}
+export interface UseCollapsibleProps {
+    basicsState: number[];
+    collapsible?: PanelProps['collapsible'];
+    index: number;
+    reverse: boolean;
+    setSize?: UseResize['setSize'];
+}
+export interface UseCollapsible {
+    nextIcon: boolean;
+    overlap: boolean;
+    previousIcon: boolean;
+    onFold: (type: 'previous' | 'next') => void;
+    setOldBasics: () => void;
+}

package/esm/splitter/interface.js

@@ -0,0 +1 @@
+export {};

package/esm/splitter/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style';
+import './index.less';

package/esm/splitter/style/index.js

@@ -0,0 +1,2 @@
+import "../../style";
+import "./index.less";

package/esm/splitter/style/index.less

@@ -0,0 +1,312 @@
+@import '../../style/themes/index.less';
+        
+@splitter-prefix-cls: ~'@{ant-prefix}-splitter';
+
+@splitter-resize-spinner-size: 20px;
+@splitter-split-bar-draggable-size: @splitter-resize-spinner-size;
+@splitter-split-bar-size: 2px;
+@splitter-split-trigger-size: 6px;
+
+@splitterBarPreviewOffsetVar: ~'@{splitter-prefix-cls}-bar-preview-offset';
+@splitter-transform-x: ~'translateX(var(--@{splitterBarPreviewOffsetVar}))';
+@splitter-transform-y: ~'translateY(var(--@{splitterBarPreviewOffsetVar}))';
+
+.center-position() {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+}
+
+.@{splitter-prefix-cls} {
+    display: flex;
+    width: 100%;
+    height: 100%;
+    align-items: stretch;
+
+    & > .@{splitter-prefix-cls}-bar {
+        flex: none;
+        position: relative;
+        user-select: none;
+
+        .@{splitter-prefix-cls}-bar-dragger {
+            .center-position();
+            z-index: 1;
+            pointer-events: auto;
+
+            &::before {
+                content: '';
+                background: @item-hover-bg;
+                .center-position();
+            }
+
+            &::after {
+                content: '';
+                background: rgba(0, 0, 0, 0.15);
+                .center-position();
+            }
+
+            &:hover:not(.@{splitter-prefix-cls}-bar-dragger-active) {
+                &::before {
+                    background: @item-active-bg;
+                }
+            }
+
+            &.@{splitter-prefix-cls}-bar-dragger-active {
+                z-index: 2;
+
+                &::before {
+                    background: @item-active-bg;
+                }
+            }
+
+            &.@{splitter-prefix-cls}-bar-dragger-disabled {
+                z-index: 0;
+                cursor: default;
+
+                &,
+                &:hover,
+                &.@{splitter-prefix-cls}-bar-dragger-active {
+                    &::before {
+                        background: @disabled-bg;
+                    }
+                }
+
+                &::after {
+                    display: none;
+                }
+            }
+        }
+
+        .@{splitter-prefix-cls}-bar-collapse-bar {
+            .center-position();
+            z-index: @zindex-popover;
+            background: @item-hover-bg;
+            font-size: @font-size-base;
+            border-radius: @border-radius-base;
+            color: @text-color;
+            cursor: pointer;
+            opacity: 0;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+
+            &:hover {
+                background: @item-active-bg;
+            }
+
+            &:active {
+                background: @item-active-bg;
+            }
+        }
+
+        &:hover,
+        &:active {
+            .@{splitter-prefix-cls}-bar-collapse-bar-hover-only {
+                opacity: 1;
+            }
+        }
+
+        .@{splitter-prefix-cls}-bar-collapse-bar-hover-only {
+            @media (hover: none) {
+                opacity: 1;
+            }
+        }
+
+        .@{splitter-prefix-cls}-bar-collapse-bar-always-hidden {
+            display: none;
+        }
+
+        .@{splitter-prefix-cls}-bar-collapse-bar-always-visible {
+            opacity: 1;
+        }
+    }
+
+    .@{splitter-prefix-cls}-mask {
+        position: fixed;
+        z-index: 9999;
+        top: 0;
+        right: 0;
+        bottom: 0;
+        left: 0;
+        background: transparent;
+
+        &.@{splitter-prefix-cls}-mask-horizontal {
+            cursor: col-resize;
+        }
+
+        &.@{splitter-prefix-cls}-mask-vertical {
+            cursor: row-resize;
+        }
+    }
+
+    &.@{splitter-prefix-cls}-horizontal {
+        flex-direction: row;
+
+        & > .@{splitter-prefix-cls}-bar {
+            width: 0;
+
+            .@{splitter-prefix-cls}-bar-preview {
+                height: 100%;
+                width: @splitter-split-bar-size;
+                position: absolute;
+                background: @primary-color;
+                opacity: 0.2;
+                pointer-events: none;
+                transition: none;
+                z-index: 1;
+                display: none;
+
+                &.@{splitter-prefix-cls}-bar-preview-active {
+                    display: block;
+
+                    transform: @splitter-transform-x;
+                }
+            }
+
+            .@{splitter-prefix-cls}-bar-dragger {
+                cursor: col-resize;
+                height: 100%;
+                width: @splitter-split-trigger-size;
+
+                &::before {
+                    height: 100%;
+                    width: @splitter-split-bar-size;
+                }
+
+                &::after {
+                    height: @splitter-split-bar-draggable-size;
+                    width: @splitter-split-bar-size;
+                }
+            }
+
+            .@{splitter-prefix-cls}-bar-collapse-bar {
+                width: @font-size-sm;
+                height: @btn-height-sm;
+
+                &.@{splitter-prefix-cls}-bar-collapse-bar-start {
+                    left: auto;
+                    right: (@splitter-split-trigger-size / 2);
+                    transform: translateY(-50%);
+                }
+
+                &.@{splitter-prefix-cls}-bar-collapse-bar-end {
+                    left: (@splitter-split-trigger-size / 2);
+                    right: auto;
+                    transform: translateY(-50%);
+                }
+            }
+        }
+    }
+
+    &.@{splitter-prefix-cls}-vertical {
+        flex-direction: column;
+
+        & > .@{splitter-prefix-cls}-bar {
+            height: 0;
+
+            .@{splitter-prefix-cls}-bar-preview {
+                height: @splitter-split-bar-size;
+                width: 100%;
+                position: absolute;
+                background: @primary-color;
+                opacity: 0.2;
+                pointer-events: none;
+                transition: none;
+                z-index: 1;
+                display: none;
+
+                &.@{splitter-prefix-cls}-bar-preview-active {
+                    display: block;
+                    transform: @splitter-transform-y;
+                }
+            }
+
+            .@{splitter-prefix-cls}-bar-dragger {
+                cursor: row-resize;
+                width: 100%;
+                height: @splitter-split-trigger-size;
+
+                &::before {
+                    width: 100%;
+                    height: @splitter-split-bar-size;
+                }
+
+                &::after {
+                    width: @splitter-split-bar-draggable-size;
+                    height: @splitter-split-bar-size;
+                }
+            }
+
+            .@{splitter-prefix-cls}-bar-collapse-bar {
+                height: @font-size-sm;
+                width: @btn-height-sm;
+
+                &.@{splitter-prefix-cls}-bar-collapse-bar-start {
+                    top: auto;
+                    bottom: (@splitter-split-trigger-size / 2);
+                    transform: translateX(-50%);
+                }
+
+                &.@{splitter-prefix-cls}-bar-collapse-bar-end {
+                    top: (@splitter-split-trigger-size / 2);
+                    bottom: auto;
+                    transform: translateX(-50%);
+                }
+            }
+        }
+    }
+
+    .@{splitter-prefix-cls}-panel {
+        overflow: auto;
+        padding: 0 1px;
+        box-sizing: border-box;
+
+        &::-webkit-scrollbar {
+            width: 8px;
+            height: 8px;
+        }
+
+        &::-webkit-scrollbar-thumb {
+            background: @table-sticky-scroll-bar-bg;
+            border-radius: @table-sticky-scroll-bar-radius;
+        }
+
+        &.@{splitter-prefix-cls}-panel-hidden {
+            padding: 0;
+            overflow: hidden;
+        }
+
+        &:has(.@{splitter-prefix-cls}:only-child) {
+            overflow: hidden;
+        }
+    }
+
+    &.@{ant-prefix}-rtl.@{splitter-prefix-cls}-horizontal {
+        & > .@{splitter-prefix-cls}-bar {
+            .@{splitter-prefix-cls}-bar-collapse-previous {
+                right: 0;
+                left: unset;
+            }
+
+            .@{splitter-prefix-cls}-bar-collapse-next {
+                right: unset;
+                left: 0;
+            }
+        }
+    }
+
+    &.@{ant-prefix}-rtl.@{splitter-prefix-cls}-vertical {
+        & > .@{splitter-prefix-cls}-bar {
+            .@{splitter-prefix-cls}-bar-collapse-previous {
+                right: 50%;
+                left: unset;
+            }
+
+            .@{splitter-prefix-cls}-bar-collapse-next {
+                right: 50%;
+                left: unset;
+            }
+        }
+    }
+}

package/esm/statusTag/index.d.ts

@@ -0,0 +1,28 @@
+import React, { CSSProperties, HTMLAttributes, ReactNode } from 'react';
+import './style';
+export declare const PRESET_COLOR_TYPES: readonly ["blue", "yellow", "green", "gray", "red", "purple", "cyan", "pink"];
+export declare const STATUS_TAG_TYPES: readonly ["default", "outline", "fill"];
+export declare type PresetColorType = (typeof PRESET_COLOR_TYPES)[number] | (string & {});
+export declare type StatusTagType = (typeof STATUS_TAG_TYPES)[number];
+export interface IStatusTagProps extends HTMLAttributes<HTMLDivElement> {
+    /** 状态类型 */
+    type?: StatusTagType;
+    /** 是否圆角 */
+    rounded?: boolean;
+    /** 状态颜色（支持预设值/自定义十六进制/RGB） */
+    color?: PresetColorType;
+    /** 是否加载中 */
+    loading?: boolean;
+    /** 自定义图标 */
+    icon?: ReactNode;
+    /** 背景颜色（仅fill类型生效），未设置时使用color的0.15透明度 */
+    background?: string;
+    /** 类名 */
+    className?: string;
+    /** 子节点 */
+    children?: ReactNode;
+    /** 自定义样式 */
+    style?: CSSProperties;
+}
+declare const StatusTag: React.FC<IStatusTagProps>;
+export default StatusTag;

package/esm/statusTag/index.js

@@ -0,0 +1,122 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _excluded = ["className", "type", "icon", "color", "loading", "rounded", "background", "style", "children"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React, { useMemo } from 'react';
+import { SpinOutlined } from '@dtinsight/react-icons';
+import { Spin } from 'antd';
+import { globalConfig } from 'antd/es/config-provider';
+import classNames from 'classnames';
+import "./style";
+export var PRESET_COLOR_TYPES = Object.freeze(['blue', 'yellow', 'green', 'gray', 'red', 'purple', 'cyan', 'pink']);
+export var STATUS_TAG_TYPES = Object.freeze(['default', 'outline', 'fill']);
+var DEFAULT_OPACITY = 0.15;
+/**
+ * 校验是否为预设颜色
+ * @param color 待校验颜色值
+ */
+function isPresetColor(color) {
+  if (!color || typeof color !== 'string') return false;
+  return PRESET_COLOR_TYPES.includes(color);
+}
+
+/**
+ * 计算颜色的透明版本
+ * @param color 原始颜色（支持hex/rgb/rgba）
+ * @param opacity 透明度（默认0.15）
+ */
+function calculateTransparentColor(color) {
+  var opacity = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_OPACITY;
+  if (!color) return 'rgba(0, 0, 0, 0.15)';
+  if (color.startsWith('rgb')) {
+    if (color.startsWith('rgba')) return color.replace(/,\s*[\d.]+(?=\))/, ",".concat(opacity));
+    return "".concat(color.slice(0, -1), ",").concat(opacity, ")");
+  }
+  var hex = color.trim().replace(/^#/, '');
+  if (hex.length === 3) {
+    hex = hex.split('').map(function (char) {
+      return char + char;
+    }).join('');
+  }
+  if (!/^[0-9A-Fa-f]{6}$/.test(hex)) return 'rgba(0, 0, 0, 0.15)';
+  var r = parseInt(hex.substring(0, 2), 16);
+  var g = parseInt(hex.substring(2, 4), 16);
+  var b = parseInt(hex.substring(4, 6), 16);
+  return "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(opacity, ")");
+}
+var StatusTag = /*#__PURE__*/React.memo(function (props) {
+  var className = props.className,
+    _props$type = props.type,
+    type = _props$type === void 0 ? 'default' : _props$type,
+    icon = props.icon,
+    _props$color = props.color,
+    color = _props$color === void 0 ? 'green' : _props$color,
+    _props$loading = props.loading,
+    loading = _props$loading === void 0 ? false : _props$loading,
+    _props$rounded = props.rounded,
+    rounded = _props$rounded === void 0 ? false : _props$rounded,
+    background = props.background,
+    style = props.style,
+    children = props.children,
+    restProps = _objectWithoutProperties(props, _excluded);
+  var prefixCls = globalConfig().getPrefixCls('status-tag');
+  var showDefaultIcon = useMemo(function () {
+    return icon === undefined;
+  }, [icon]);
+  var containerClasses = useMemo(function () {
+    return classNames(prefixCls, className, _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, "".concat(prefixCls, "--border"), type === 'outline'), "".concat(prefixCls, "--fill"), type === 'fill'), "".concat(prefixCls, "--rounded"), rounded), "".concat(prefixCls, "__").concat(color, "--fill"), type === 'fill' && isPresetColor(color)));
+  }, [className, type, color, rounded, prefixCls]);
+  var customColorStyle = useMemo(function () {
+    if (type !== 'fill' || isPresetColor(color)) return {};
+    return {
+      color: color,
+      background: background || calculateTransparentColor(color)
+    };
+  }, [type, color, background]);
+  var iconStyleConfig = useMemo(function () {
+    if (isPresetColor(color)) {
+      return {
+        className: classNames('anticon', _defineProperty(_defineProperty(_defineProperty({}, "".concat(prefixCls, "__").concat(color, "--icon"), true), "".concat(prefixCls, "__icon--default"), !icon), "".concat(prefixCls, "__").concat(color, "--iconBg"), !icon)),
+        style: {}
+      };
+    }
+    return {
+      className: classNames('anticon', _defineProperty({}, "".concat(prefixCls, "__icon--default"), !icon)),
+      style: {
+        color: icon ? color : undefined,
+        background: !icon ? color : undefined
+      }
+    };
+  }, [color, icon, prefixCls]);
+  var loadingIndicator = useMemo(function () {
+    return /*#__PURE__*/React.createElement(SpinOutlined, {
+      className: "".concat(prefixCls, "__icon ").concat(prefixCls, "__icon--loading")
+    });
+  }, [prefixCls]);
+  return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+    className: containerClasses,
+    style: _objectSpread(_objectSpread({}, customColorStyle), style),
+    "aria-busy": loading
+  }), loading ? /*#__PURE__*/React.createElement(Spin, {
+    spinning: true,
+    indicator: loadingIndicator,
+    size: "small"
+  }) : (icon || showDefaultIcon) && /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "__icon")
+  }, /*#__PURE__*/React.createElement("span", {
+    className: iconStyleConfig.className,
+    style: iconStyleConfig.style
+  }, icon !== null && icon !== void 0 ? icon : null)), children && /*#__PURE__*/React.createElement("span", {
+    className: "".concat(prefixCls, "__text")
+  }, children));
+});
+if (process.env.NODE_ENV !== 'production') {
+  StatusTag.displayName = 'StatusTag';
+}
+export default StatusTag;

package/esm/statusTag/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/esm/statusTag/style/index.js

@@ -0,0 +1,2 @@
+import "../../style/index.less";
+import "./index.less";