first commit

frontend/node_modules/antd/es/steps/index.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import RcSteps from 'rc-steps';
+import type { ProgressDotRender } from 'rc-steps/lib/Steps';
+export interface StepProps {
+    className?: string;
+    description?: React.ReactNode;
+    icon?: React.ReactNode;
+    onClick?: React.MouseEventHandler<HTMLElement>;
+    status?: 'wait' | 'process' | 'finish' | 'error';
+    disabled?: boolean;
+    title?: React.ReactNode;
+    subTitle?: React.ReactNode;
+    style?: React.CSSProperties;
+}
+export interface StepsProps {
+    type?: 'default' | 'navigation' | 'inline';
+    className?: string;
+    rootClassName?: string;
+    current?: number;
+    direction?: 'horizontal' | 'vertical';
+    iconPrefix?: string;
+    initial?: number;
+    labelPlacement?: 'horizontal' | 'vertical';
+    prefixCls?: string;
+    progressDot?: boolean | ProgressDotRender;
+    responsive?: boolean;
+    size?: 'default' | 'small';
+    status?: 'wait' | 'process' | 'finish' | 'error';
+    style?: React.CSSProperties;
+    percent?: number;
+    onChange?: (current: number) => void;
+    children?: React.ReactNode;
+    items?: StepProps[];
+}
+type CompoundedComponent = React.FC<StepsProps> & {
+    Step: typeof RcSteps.Step;
+};
+declare const Steps: CompoundedComponent;
+export default Steps;

frontend/node_modules/antd/es/steps/index.js

@@ -0,0 +1,109 @@
+"use client";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import * as React from 'react';
+import CheckOutlined from "@ant-design/icons/es/icons/CheckOutlined";
+import CloseOutlined from "@ant-design/icons/es/icons/CloseOutlined";
+import classNames from 'classnames';
+import RcSteps from 'rc-steps';
+import { useComponentConfig } from '../config-provider/context';
+import useSize from '../config-provider/hooks/useSize';
+import useBreakpoint from '../grid/hooks/useBreakpoint';
+import Progress from '../progress';
+import Tooltip from '../tooltip';
+import useStyle from './style';
+import useLegacyItems from './useLegacyItems';
+const Steps = props => {
+  const {
+      percent,
+      size: customizeSize,
+      className,
+      rootClassName,
+      direction,
+      items,
+      responsive = true,
+      current = 0,
+      children,
+      style
+    } = props,
+    restProps = __rest(props, ["percent", "size", "className", "rootClassName", "direction", "items", "responsive", "current", "children", "style"]);
+  const {
+    xs
+  } = useBreakpoint(responsive);
+  const {
+    getPrefixCls,
+    direction: rtlDirection,
+    className: contextClassName,
+    style: contextStyle
+  } = useComponentConfig('steps');
+  const realDirectionValue = React.useMemo(() => responsive && xs ? 'vertical' : direction, [responsive, xs, direction]);
+  const size = useSize(customizeSize);
+  const prefixCls = getPrefixCls('steps', props.prefixCls);
+  const [wrapCSSVar, hashId, cssVarCls] = useStyle(prefixCls);
+  const isInline = props.type === 'inline';
+  const iconPrefix = getPrefixCls('', props.iconPrefix);
+  const mergedItems = useLegacyItems(items, children);
+  const mergedPercent = isInline ? undefined : percent;
+  const mergedStyle = Object.assign(Object.assign({}, contextStyle), style);
+  const stepsClassName = classNames(contextClassName, {
+    [`${prefixCls}-rtl`]: rtlDirection === 'rtl',
+    [`${prefixCls}-with-progress`]: mergedPercent !== undefined
+  }, className, rootClassName, hashId, cssVarCls);
+  const icons = {
+    finish: /*#__PURE__*/React.createElement(CheckOutlined, {
+      className: `${prefixCls}-finish-icon`
+    }),
+    error: /*#__PURE__*/React.createElement(CloseOutlined, {
+      className: `${prefixCls}-error-icon`
+    })
+  };
+  const stepIconRender = ({
+    node,
+    status
+  }) => {
+    if (status === 'process' && mergedPercent !== undefined) {
+      // currently it's hard-coded, since we can't easily read the actually width of icon
+      const progressWidth = size === 'small' ? 32 : 40;
+      // iconWithProgress
+      return /*#__PURE__*/React.createElement("div", {
+        className: `${prefixCls}-progress-icon`
+      }, /*#__PURE__*/React.createElement(Progress, {
+        type: "circle",
+        percent: mergedPercent,
+        size: progressWidth,
+        strokeWidth: 4,
+        format: () => null
+      }), node);
+    }
+    return node;
+  };
+  const itemRender = (item, stepItem) => item.description ? /*#__PURE__*/React.createElement(Tooltip, {
+    title: item.description
+  }, stepItem) : stepItem;
+  return wrapCSSVar(/*#__PURE__*/React.createElement(RcSteps, Object.assign({
+    icons: icons
+  }, restProps, {
+    style: mergedStyle,
+    current: current,
+    size: size,
+    items: mergedItems,
+    itemRender: isInline ? itemRender : undefined,
+    stepIcon: stepIconRender,
+    direction: realDirectionValue,
+    prefixCls: prefixCls,
+    iconPrefix: iconPrefix,
+    className: stepsClassName
+  })));
+};
+Steps.Step = RcSteps.Step;
+if (process.env.NODE_ENV !== 'production') {
+  Steps.displayName = 'Steps';
+}
+export default Steps;

frontend/node_modules/antd/es/steps/style/custom-icon.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { StepsToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genStepsCustomIconStyle: GenerateStyle<StepsToken, CSSObject>;
+export default genStepsCustomIconStyle;

frontend/node_modules/antd/es/steps/style/custom-icon.js

@@ -0,0 +1,35 @@
+import { unit } from '@ant-design/cssinjs';
+const genStepsCustomIconStyle = token => {
+  const {
+    componentCls,
+    customIconTop,
+    customIconSize,
+    customIconFontSize
+  } = token;
+  return {
+    [`${componentCls}-item-custom`]: {
+      [`> ${componentCls}-item-container > ${componentCls}-item-icon`]: {
+        height: 'auto',
+        background: 'none',
+        border: 0,
+        [`> ${componentCls}-icon`]: {
+          top: customIconTop,
+          width: customIconSize,
+          height: customIconSize,
+          fontSize: customIconFontSize,
+          lineHeight: unit(customIconSize)
+        }
+      }
+    },
+    // Only adjust horizontal customize icon width
+    [`&:not(${componentCls}-vertical)`]: {
+      [`${componentCls}-item-custom`]: {
+        [`${componentCls}-item-icon`]: {
+          width: 'auto',
+          background: 'none'
+        }
+      }
+    }
+  };
+};
+export default genStepsCustomIconStyle;

frontend/node_modules/antd/es/steps/style/horizontal.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { StepsToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genHorizontalStyle: GenerateStyle<StepsToken, CSSObject>;
+export default genHorizontalStyle;

frontend/node_modules/antd/es/steps/style/horizontal.js

@@ -0,0 +1,14 @@
+const genHorizontalStyle = token => {
+  const {
+    componentCls
+  } = token;
+  const stepsItemCls = `${componentCls}-item`; // .ant-steps-item
+  return {
+    [`${componentCls}-horizontal`]: {
+      [`${stepsItemCls}-tail`]: {
+        transform: 'translateY(-50%)'
+      }
+    }
+  };
+};
+export default genHorizontalStyle;

frontend/node_modules/antd/es/steps/style/index.d.ts

@@ -0,0 +1,102 @@
+import type { CSSProperties } from 'react';
+import type { FullToken, GetDefaultToken } from '../../theme/internal';
+export interface ComponentToken {
+    /**
+     * @desc 描述区域最大宽度
+     * @descEN Max width of description area
+     */
+    descriptionMaxWidth: number;
+    /**
+     * @desc 自定义图标容器尺寸
+     * @descEN Size of custom icon container
+     */
+    customIconSize: number;
+    /**
+     * @desc 自定义图标 top
+     * @descEN Top of custom icon
+     */
+    customIconTop: number;
+    /**
+     * @desc 自定义图标大小
+     * @descEN Font size of custom icon
+     */
+    customIconFontSize: number;
+    /**
+     * @desc 图标容器尺寸
+     * @descEN Size of icon container
+     */
+    iconSize: number;
+    /**
+     * @desc 图标 top
+     * @descEN Top of icon
+     */
+    iconTop: number;
+    /**
+     * @desc 图标大小
+     * @descEN Size of icon
+     */
+    iconFontSize: number;
+    /**
+     * @desc 点状步骤点大小
+     * @descEN Size of dot
+     */
+    dotSize: number;
+    /**
+     * @desc 点状步骤点当前大小
+     * @descEN Current size of dot
+     */
+    dotCurrentSize: number;
+    /**
+     * @desc 可跳转步骤条箭头颜色
+     * @descEN Color of arrow in nav
+     */
+    navArrowColor: string;
+    /**
+     * @desc 可跳转步骤条内容最大宽度
+     * @descEN Max width of nav content
+     */
+    navContentMaxWidth: CSSProperties['maxWidth'];
+    /**
+     * @desc 小号步骤条图标大小
+     * @descEN Size of small steps icon
+     */
+    iconSizeSM: number;
+    /**
+     * @desc 标题行高
+     * @descEN Line height of title
+     */
+    titleLineHeight: number | string;
+}
+export interface StepsToken extends FullToken<'Steps'> {
+    processTailColor: string;
+    processIconColor: string;
+    processTitleColor: string;
+    processDescriptionColor: string;
+    processIconBgColor: string;
+    processIconBorderColor: string;
+    processDotColor: string;
+    waitTitleColor: string;
+    waitDescriptionColor: string;
+    waitTailColor: string;
+    waitDotColor: string;
+    finishIconColor: string;
+    finishTitleColor: string;
+    finishDescriptionColor: string;
+    finishTailColor: string;
+    finishDotColor: string;
+    errorIconColor: string;
+    errorTitleColor: string;
+    errorDescriptionColor: string;
+    errorTailColor: string;
+    errorIconBgColor: string;
+    errorIconBorderColor: string;
+    errorDotColor: string;
+    stepsNavActiveColor: string;
+    stepsProgressSize: number;
+    inlineDotSize: number;
+    inlineTitleColor: string;
+    inlineTailColor: string;
+}
+export declare const prepareComponentToken: GetDefaultToken<'Steps'>;
+declare const _default: (prefixCls: string, rootCls?: string) => readonly [(node: React.ReactElement) => React.ReactElement, string, string];
+export default _default;

frontend/node_modules/antd/es/steps/style/index.js

@@ -0,0 +1,304 @@
+import { unit } from '@ant-design/cssinjs';
+import { genFocusOutline, resetComponent } from '../../style';
+import { genStyleHooks, mergeToken } from '../../theme/internal';
+import genStepsCustomIconStyle from './custom-icon';
+import genStepsHorizontalStyle from './horizontal';
+import genStepsInlineStyle from './inline';
+import genStepsLabelPlacementStyle from './label-placement';
+import genStepsNavStyle from './nav';
+import genStepsProgressStyle from './progress';
+import genStepsProgressDotStyle from './progress-dot';
+import genStepsRTLStyle from './rtl';
+import genStepsSmallStyle from './small';
+import genStepsVerticalStyle from './vertical';
+const STEP_ITEM_STATUS_WAIT = 'wait';
+const STEP_ITEM_STATUS_PROCESS = 'process';
+const STEP_ITEM_STATUS_FINISH = 'finish';
+const STEP_ITEM_STATUS_ERROR = 'error';
+const genStepsItemStatusStyle = (status, token) => {
+  const prefix = `${token.componentCls}-item`;
+  const iconColorKey = `${status}IconColor`;
+  const titleColorKey = `${status}TitleColor`;
+  const descriptionColorKey = `${status}DescriptionColor`;
+  const tailColorKey = `${status}TailColor`;
+  const iconBgColorKey = `${status}IconBgColor`;
+  const iconBorderColorKey = `${status}IconBorderColor`;
+  const dotColorKey = `${status}DotColor`;
+  return {
+    [`${prefix}-${status} ${prefix}-icon`]: {
+      backgroundColor: token[iconBgColorKey],
+      borderColor: token[iconBorderColorKey],
+      [`> ${token.componentCls}-icon`]: {
+        color: token[iconColorKey],
+        [`${token.componentCls}-icon-dot`]: {
+          background: token[dotColorKey]
+        }
+      }
+    },
+    [`${prefix}-${status}${prefix}-custom ${prefix}-icon`]: {
+      [`> ${token.componentCls}-icon`]: {
+        color: token[dotColorKey]
+      }
+    },
+    [`${prefix}-${status} > ${prefix}-container > ${prefix}-content > ${prefix}-title`]: {
+      color: token[titleColorKey],
+      '&::after': {
+        backgroundColor: token[tailColorKey]
+      }
+    },
+    [`${prefix}-${status} > ${prefix}-container > ${prefix}-content > ${prefix}-description`]: {
+      color: token[descriptionColorKey]
+    },
+    [`${prefix}-${status} > ${prefix}-container > ${prefix}-tail::after`]: {
+      backgroundColor: token[tailColorKey]
+    }
+  };
+};
+const genStepsItemStyle = token => {
+  const {
+    componentCls,
+    motionDurationSlow
+  } = token;
+  const stepsItemCls = `${componentCls}-item`; // .ant-steps-item
+  const stepItemIconCls = `${stepsItemCls}-icon`;
+  return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({
+    [stepsItemCls]: {
+      position: 'relative',
+      display: 'inline-block',
+      flex: 1,
+      overflow: 'hidden',
+      verticalAlign: 'top',
+      '&:last-child': {
+        flex: 'none',
+        [`> ${stepsItemCls}-container > ${stepsItemCls}-tail, > ${stepsItemCls}-container >  ${stepsItemCls}-content > ${stepsItemCls}-title::after`]: {
+          display: 'none'
+        }
+      }
+    },
+    [`${stepsItemCls}-container`]: {
+      outline: 'none',
+      [`&:focus-visible ${stepItemIconCls}`]: genFocusOutline(token)
+    },
+    [`${stepItemIconCls}, ${stepsItemCls}-content`]: {
+      display: 'inline-block',
+      verticalAlign: 'top'
+    },
+    [stepItemIconCls]: {
+      width: token.iconSize,
+      height: token.iconSize,
+      marginTop: 0,
+      marginBottom: 0,
+      marginInlineStart: 0,
+      marginInlineEnd: token.marginXS,
+      fontSize: token.iconFontSize,
+      fontFamily: token.fontFamily,
+      lineHeight: unit(token.iconSize),
+      textAlign: 'center',
+      borderRadius: token.iconSize,
+      border: `${unit(token.lineWidth)} ${token.lineType} transparent`,
+      transition: `background-color ${motionDurationSlow}, border-color ${motionDurationSlow}`,
+      [`${componentCls}-icon`]: {
+        position: 'relative',
+        top: token.iconTop,
+        color: token.colorPrimary,
+        lineHeight: 1
+      }
+    },
+    [`${stepsItemCls}-tail`]: {
+      position: 'absolute',
+      top: token.calc(token.iconSize).div(2).equal(),
+      insetInlineStart: 0,
+      width: '100%',
+      '&::after': {
+        display: 'inline-block',
+        width: '100%',
+        height: token.lineWidth,
+        background: token.colorSplit,
+        borderRadius: token.lineWidth,
+        transition: `background ${motionDurationSlow}`,
+        content: '""'
+      }
+    },
+    [`${stepsItemCls}-title`]: {
+      position: 'relative',
+      display: 'inline-block',
+      paddingInlineEnd: token.padding,
+      color: token.colorText,
+      fontSize: token.fontSizeLG,
+      lineHeight: unit(token.titleLineHeight),
+      '&::after': {
+        position: 'absolute',
+        top: token.calc(token.titleLineHeight).div(2).equal(),
+        insetInlineStart: '100%',
+        display: 'block',
+        width: 9999,
+        height: token.lineWidth,
+        background: token.processTailColor,
+        content: '""'
+      }
+    },
+    [`${stepsItemCls}-subtitle`]: {
+      display: 'inline',
+      marginInlineStart: token.marginXS,
+      color: token.colorTextDescription,
+      fontWeight: 'normal',
+      fontSize: token.fontSize
+    },
+    [`${stepsItemCls}-description`]: {
+      color: token.colorTextDescription,
+      fontSize: token.fontSize
+    }
+  }, genStepsItemStatusStyle(STEP_ITEM_STATUS_WAIT, token)), genStepsItemStatusStyle(STEP_ITEM_STATUS_PROCESS, token)), {
+    [`${stepsItemCls}-process > ${stepsItemCls}-container > ${stepsItemCls}-title`]: {
+      fontWeight: token.fontWeightStrong
+    }
+  }), genStepsItemStatusStyle(STEP_ITEM_STATUS_FINISH, token)), genStepsItemStatusStyle(STEP_ITEM_STATUS_ERROR, token)), {
+    [`${stepsItemCls}${componentCls}-next-error > ${componentCls}-item-title::after`]: {
+      background: token.colorError
+    },
+    [`${stepsItemCls}-disabled`]: {
+      cursor: 'not-allowed'
+    }
+  });
+};
+// ============================= Clickable ===========================
+const genStepsClickableStyle = token => {
+  const {
+    componentCls,
+    motionDurationSlow
+  } = token;
+  return {
+    [`& ${componentCls}-item`]: {
+      [`&:not(${componentCls}-item-active)`]: {
+        [`& > ${componentCls}-item-container[role='button']`]: {
+          cursor: 'pointer',
+          [`${componentCls}-item`]: {
+            [`&-title, &-subtitle, &-description, &-icon ${componentCls}-icon`]: {
+              transition: `color ${motionDurationSlow}`
+            }
+          },
+          '&:hover': {
+            [`${componentCls}-item`]: {
+              '&-title, &-subtitle, &-description': {
+                color: token.colorPrimary
+              }
+            }
+          }
+        },
+        [`&:not(${componentCls}-item-process)`]: {
+          [`& > ${componentCls}-item-container[role='button']:hover`]: {
+            [`${componentCls}-item`]: {
+              '&-icon': {
+                borderColor: token.colorPrimary,
+                [`${componentCls}-icon`]: {
+                  color: token.colorPrimary
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    [`&${componentCls}-horizontal:not(${componentCls}-label-vertical)`]: {
+      [`${componentCls}-item`]: {
+        paddingInlineStart: token.padding,
+        whiteSpace: 'nowrap',
+        '&:first-child': {
+          paddingInlineStart: 0
+        },
+        [`&:last-child ${componentCls}-item-title`]: {
+          paddingInlineEnd: 0
+        },
+        '&-tail': {
+          display: 'none'
+        },
+        '&-description': {
+          maxWidth: token.descriptionMaxWidth,
+          whiteSpace: 'normal'
+        }
+      }
+    }
+  };
+};
+const genStepsStyle = token => {
+  const {
+    componentCls
+  } = token; // .ant-steps
+  return {
+    [componentCls]: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, resetComponent(token)), {
+      display: 'flex',
+      width: '100%',
+      fontSize: 0,
+      textAlign: 'initial'
+    }), genStepsItemStyle(token)), genStepsClickableStyle(token)), genStepsCustomIconStyle(token)), genStepsSmallStyle(token)), genStepsVerticalStyle(token)), genStepsHorizontalStyle(token)), genStepsLabelPlacementStyle(token)), genStepsProgressDotStyle(token)), genStepsNavStyle(token)), genStepsRTLStyle(token)), genStepsProgressStyle(token)), genStepsInlineStyle(token))
+  };
+};
+// ============================== Export ==============================
+export const prepareComponentToken = token => ({
+  titleLineHeight: token.controlHeight,
+  customIconSize: token.controlHeight,
+  customIconTop: 0,
+  customIconFontSize: token.controlHeightSM,
+  iconSize: token.controlHeight,
+  iconTop: -0.5,
+  // magic for ui experience
+  iconFontSize: token.fontSize,
+  iconSizeSM: token.fontSizeHeading3,
+  dotSize: token.controlHeight / 4,
+  dotCurrentSize: token.controlHeightLG / 4,
+  navArrowColor: token.colorTextDisabled,
+  navContentMaxWidth: 'unset',
+  descriptionMaxWidth: 140,
+  waitIconColor: token.wireframe ? token.colorTextDisabled : token.colorTextLabel,
+  waitIconBgColor: token.wireframe ? token.colorBgContainer : token.colorFillContent,
+  waitIconBorderColor: token.wireframe ? token.colorTextDisabled : 'transparent',
+  finishIconBgColor: token.wireframe ? token.colorBgContainer : token.controlItemBgActive,
+  finishIconBorderColor: token.wireframe ? token.colorPrimary : token.controlItemBgActive
+});
+export default genStyleHooks('Steps', token => {
+  const {
+    colorTextDisabled,
+    controlHeightLG,
+    colorTextLightSolid,
+    colorText,
+    colorPrimary,
+    colorTextDescription,
+    colorTextQuaternary,
+    colorError,
+    colorBorderSecondary,
+    colorSplit
+  } = token;
+  const stepsToken = mergeToken(token, {
+    // Steps component less variable
+    processIconColor: colorTextLightSolid,
+    processTitleColor: colorText,
+    processDescriptionColor: colorText,
+    processIconBgColor: colorPrimary,
+    processIconBorderColor: colorPrimary,
+    processDotColor: colorPrimary,
+    processTailColor: colorSplit,
+    waitTitleColor: colorTextDescription,
+    waitDescriptionColor: colorTextDescription,
+    waitTailColor: colorSplit,
+    waitDotColor: colorTextDisabled,
+    finishIconColor: colorPrimary,
+    finishTitleColor: colorText,
+    finishDescriptionColor: colorTextDescription,
+    finishTailColor: colorPrimary,
+    finishDotColor: colorPrimary,
+    errorIconColor: colorTextLightSolid,
+    errorTitleColor: colorError,
+    errorDescriptionColor: colorError,
+    errorTailColor: colorSplit,
+    errorIconBgColor: colorError,
+    errorIconBorderColor: colorError,
+    errorDotColor: colorError,
+    stepsNavActiveColor: colorPrimary,
+    stepsProgressSize: controlHeightLG,
+    // Steps inline variable
+    inlineDotSize: 6,
+    inlineTitleColor: colorTextQuaternary,
+    inlineTailColor: colorBorderSecondary
+  });
+  return genStepsStyle(stepsToken);
+}, prepareComponentToken);

frontend/node_modules/antd/es/steps/style/inline.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { StepsToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genStepsInlineStyle: GenerateStyle<StepsToken, CSSObject>;
+export default genStepsInlineStyle;

frontend/node_modules/antd/es/steps/style/inline.js

@@ -0,0 +1,115 @@
+import { unit } from '@ant-design/cssinjs';
+const genStepsInlineStyle = token => {
+  const {
+    componentCls,
+    inlineDotSize,
+    inlineTitleColor,
+    inlineTailColor
+  } = token;
+  const containerPaddingTop = token.calc(token.paddingXS).add(token.lineWidth).equal();
+  const titleStyle = {
+    [`${componentCls}-item-container ${componentCls}-item-content ${componentCls}-item-title`]: {
+      color: inlineTitleColor
+    }
+  };
+  return {
+    [`&${componentCls}-inline`]: {
+      width: 'auto',
+      display: 'inline-flex',
+      [`${componentCls}-item`]: {
+        flex: 'none',
+        '&-container': {
+          padding: `${unit(containerPaddingTop)} ${unit(token.paddingXXS)} 0`,
+          margin: `0 ${unit(token.calc(token.marginXXS).div(2).equal())}`,
+          borderRadius: token.borderRadiusSM,
+          cursor: 'pointer',
+          transition: `background-color ${token.motionDurationMid}`,
+          '&:hover': {
+            background: token.controlItemBgHover
+          },
+          "&[role='button']:hover": {
+            opacity: 1
+          }
+        },
+        '&-icon': {
+          width: inlineDotSize,
+          height: inlineDotSize,
+          marginInlineStart: `calc(50% - ${unit(token.calc(inlineDotSize).div(2).equal())})`,
+          [`> ${componentCls}-icon`]: {
+            top: 0
+          },
+          [`${componentCls}-icon-dot`]: {
+            borderRadius: token.calc(token.fontSizeSM).div(4).equal(),
+            '&::after': {
+              display: 'none'
+            }
+          }
+        },
+        '&-content': {
+          width: 'auto',
+          marginTop: token.calc(token.marginXS).sub(token.lineWidth).equal()
+        },
+        '&-title': {
+          color: inlineTitleColor,
+          fontSize: token.fontSizeSM,
+          lineHeight: token.lineHeightSM,
+          fontWeight: 'normal',
+          marginBottom: token.calc(token.marginXXS).div(2).equal()
+        },
+        '&-description': {
+          display: 'none'
+        },
+        '&-tail': {
+          marginInlineStart: 0,
+          top: token.calc(inlineDotSize).div(2).add(containerPaddingTop).equal(),
+          transform: `translateY(-50%)`,
+          '&:after': {
+            width: '100%',
+            height: token.lineWidth,
+            borderRadius: 0,
+            marginInlineStart: 0,
+            background: inlineTailColor
+          }
+        },
+        [`&:first-child ${componentCls}-item-tail`]: {
+          width: '50%',
+          marginInlineStart: '50%'
+        },
+        [`&:last-child ${componentCls}-item-tail`]: {
+          display: 'block',
+          width: '50%'
+        },
+        '&-wait': Object.assign({
+          [`${componentCls}-item-icon ${componentCls}-icon ${componentCls}-icon-dot`]: {
+            backgroundColor: token.colorBorderBg,
+            border: `${unit(token.lineWidth)} ${token.lineType} ${inlineTailColor}`
+          }
+        }, titleStyle),
+        '&-finish': Object.assign({
+          [`${componentCls}-item-tail::after`]: {
+            backgroundColor: inlineTailColor
+          },
+          [`${componentCls}-item-icon ${componentCls}-icon ${componentCls}-icon-dot`]: {
+            backgroundColor: inlineTailColor,
+            border: `${unit(token.lineWidth)} ${token.lineType} ${inlineTailColor}`
+          }
+        }, titleStyle),
+        '&-error': titleStyle,
+        '&-active, &-process': Object.assign({
+          [`${componentCls}-item-icon`]: {
+            width: inlineDotSize,
+            height: inlineDotSize,
+            marginInlineStart: `calc(50% - ${unit(token.calc(inlineDotSize).div(2).equal())})`,
+            top: 0
+          }
+        }, titleStyle),
+        [`&:not(${componentCls}-item-active) > ${componentCls}-item-container[role='button']:hover`]: {
+          [`${componentCls}-item-title`]: {
+            color: inlineTitleColor
+          }
+        }
+      }
+    }
+  };
+};
+export default genStepsInlineStyle;

frontend/node_modules/antd/es/steps/style/label-placement.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { StepsToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genStepsLabelPlacementStyle: GenerateStyle<StepsToken, CSSObject>;
+export default genStepsLabelPlacementStyle;

frontend/node_modules/antd/es/steps/style/label-placement.js

@@ -0,0 +1,51 @@
+import { unit } from '@ant-design/cssinjs';
+const genStepsLabelPlacementStyle = token => {
+  const {
+    componentCls,
+    iconSize,
+    lineHeight,
+    iconSizeSM
+  } = token;
+  return {
+    [`&${componentCls}-label-vertical`]: {
+      [`${componentCls}-item`]: {
+        overflow: 'visible',
+        '&-tail': {
+          marginInlineStart: token.calc(iconSize).div(2).add(token.controlHeightLG).equal(),
+          padding: `0 ${unit(token.paddingLG)}`
+        },
+        '&-content': {
+          display: 'block',
+          width: token.calc(iconSize).div(2).add(token.controlHeightLG).mul(2).equal(),
+          marginTop: token.marginSM,
+          textAlign: 'center'
+        },
+        '&-icon': {
+          display: 'inline-block',
+          marginInlineStart: token.controlHeightLG
+        },
+        '&-title': {
+          paddingInlineEnd: 0,
+          paddingInlineStart: 0,
+          '&::after': {
+            display: 'none'
+          }
+        },
+        '&-subtitle': {
+          display: 'block',
+          marginBottom: token.marginXXS,
+          marginInlineStart: 0,
+          lineHeight
+        }
+      },
+      [`&${componentCls}-small:not(${componentCls}-dot)`]: {
+        [`${componentCls}-item`]: {
+          '&-icon': {
+            marginInlineStart: token.calc(iconSize).sub(iconSizeSM).div(2).add(token.controlHeightLG).equal()
+          }
+        }
+      }
+    }
+  };
+};
+export default genStepsLabelPlacementStyle;

frontend/node_modules/antd/es/steps/style/nav.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { StepsToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genStepsNavStyle: GenerateStyle<StepsToken, CSSObject>;
+export default genStepsNavStyle;

frontend/node_modules/antd/es/steps/style/nav.js

@@ -0,0 +1,130 @@
+import { unit } from '@ant-design/cssinjs';
+import { textEllipsis } from '../../style';
+const genStepsNavStyle = token => {
+  const {
+    componentCls,
+    navContentMaxWidth,
+    navArrowColor,
+    stepsNavActiveColor,
+    motionDurationSlow
+  } = token;
+  return {
+    [`&${componentCls}-navigation`]: {
+      paddingTop: token.paddingSM,
+      [`&${componentCls}-small`]: {
+        [`${componentCls}-item`]: {
+          '&-container': {
+            marginInlineStart: token.calc(token.marginSM).mul(-1).equal()
+          }
+        }
+      },
+      [`${componentCls}-item`]: {
+        overflow: 'visible',
+        textAlign: 'center',
+        '&-container': {
+          display: 'inline-block',
+          height: '100%',
+          marginInlineStart: token.calc(token.margin).mul(-1).equal(),
+          paddingBottom: token.paddingSM,
+          textAlign: 'start',
+          transition: `opacity ${motionDurationSlow}`,
+          [`${componentCls}-item-content`]: {
+            maxWidth: navContentMaxWidth
+          },
+          [`${componentCls}-item-title`]: Object.assign(Object.assign({
+            maxWidth: '100%',
+            paddingInlineEnd: 0
+          }, textEllipsis), {
+            '&::after': {
+              display: 'none'
+            }
+          })
+        },
+        [`&:not(${componentCls}-item-active)`]: {
+          [`${componentCls}-item-container[role='button']`]: {
+            cursor: 'pointer',
+            '&:hover': {
+              opacity: 0.85
+            }
+          }
+        },
+        '&:last-child': {
+          flex: 1,
+          '&::after': {
+            display: 'none'
+          }
+        },
+        '&::after': {
+          position: 'absolute',
+          top: `calc(50% - ${unit(token.calc(token.paddingSM).div(2).equal())})`,
+          insetInlineStart: '100%',
+          display: 'inline-block',
+          width: token.fontSizeIcon,
+          height: token.fontSizeIcon,
+          borderTop: `${unit(token.lineWidth)} ${token.lineType} ${navArrowColor}`,
+          borderBottom: 'none',
+          borderInlineStart: 'none',
+          borderInlineEnd: `${unit(token.lineWidth)} ${token.lineType} ${navArrowColor}`,
+          transform: 'translateY(-50%) translateX(-50%) rotate(45deg)',
+          content: '""'
+        },
+        '&::before': {
+          position: 'absolute',
+          bottom: 0,
+          insetInlineStart: '50%',
+          display: 'inline-block',
+          width: 0,
+          height: token.lineWidthBold,
+          backgroundColor: stepsNavActiveColor,
+          transition: `width ${motionDurationSlow}, inset-inline-start ${motionDurationSlow}`,
+          transitionTimingFunction: 'ease-out',
+          content: '""'
+        }
+      },
+      [`${componentCls}-item${componentCls}-item-active::before`]: {
+        insetInlineStart: 0,
+        width: '100%'
+      }
+    },
+    [`&${componentCls}-navigation${componentCls}-vertical`]: {
+      [`> ${componentCls}-item`]: {
+        marginInlineEnd: 0,
+        '&::before': {
+          display: 'none'
+        },
+        [`&${componentCls}-item-active::before`]: {
+          top: 0,
+          insetInlineEnd: 0,
+          insetInlineStart: 'unset',
+          display: 'block',
+          width: token.calc(token.lineWidth).mul(3).equal(),
+          height: `calc(100% - ${unit(token.marginLG)})`
+        },
+        '&::after': {
+          position: 'relative',
+          insetInlineStart: '50%',
+          display: 'block',
+          width: token.calc(token.controlHeight).mul(0.25).equal(),
+          height: token.calc(token.controlHeight).mul(0.25).equal(),
+          marginBottom: token.marginXS,
+          textAlign: 'center',
+          transform: 'translateY(-50%) translateX(-50%) rotate(135deg)'
+        },
+        '&:last-child': {
+          '&::after': {
+            display: 'none'
+          }
+        },
+        [`> ${componentCls}-item-container > ${componentCls}-item-tail`]: {
+          visibility: 'hidden'
+        }
+      }
+    },
+    [`&${componentCls}-navigation${componentCls}-horizontal`]: {
+      [`> ${componentCls}-item > ${componentCls}-item-container > ${componentCls}-item-tail`]: {
+        visibility: 'hidden'
+      }
+    }
+  };
+};
+export default genStepsNavStyle;

frontend/node_modules/antd/es/steps/style/progress-dot.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { StepsToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genStepsProgressDotStyle: GenerateStyle<StepsToken, CSSObject>;
+export default genStepsProgressDotStyle;

frontend/node_modules/antd/es/steps/style/progress-dot.js

@@ -0,0 +1,120 @@
+import { unit } from '@ant-design/cssinjs';
+const genStepsProgressDotStyle = token => {
+  const {
+    componentCls,
+    descriptionMaxWidth,
+    lineHeight,
+    dotCurrentSize,
+    dotSize,
+    motionDurationSlow
+  } = token;
+  return {
+    [`&${componentCls}-dot, &${componentCls}-dot${componentCls}-small`]: {
+      [`${componentCls}-item`]: {
+        '&-title': {
+          lineHeight
+        },
+        '&-tail': {
+          // Math.floor((token.size - token.lineWidth * 3) / 2)
+          top: token.calc(token.dotSize).sub(token.calc(token.lineWidth).mul(3).equal()).div(2).equal(),
+          width: '100%',
+          marginTop: 0,
+          marginBottom: 0,
+          marginInline: `${unit(token.calc(descriptionMaxWidth).div(2).equal())} 0`,
+          padding: 0,
+          '&::after': {
+            width: `calc(100% - ${unit(token.calc(token.marginSM).mul(2).equal())})`,
+            height: token.calc(token.lineWidth).mul(3).equal(),
+            marginInlineStart: token.marginSM
+          }
+        },
+        '&-icon': {
+          width: dotSize,
+          height: dotSize,
+          marginInlineStart: token.calc(token.descriptionMaxWidth).sub(dotSize).div(2).equal(),
+          paddingInlineEnd: 0,
+          lineHeight: unit(dotSize),
+          background: 'transparent',
+          border: 0,
+          [`${componentCls}-icon-dot`]: {
+            position: 'relative',
+            float: 'left',
+            width: '100%',
+            height: '100%',
+            borderRadius: 100,
+            // very large number
+            transition: `all ${motionDurationSlow}`,
+            /* expand hover area */
+            '&::after': {
+              position: 'absolute',
+              top: token.calc(token.marginSM).mul(-1).equal(),
+              insetInlineStart: token.calc(dotSize).sub(token.calc(token.controlHeightLG).mul(1.5).equal()).div(2).equal(),
+              width: token.calc(token.controlHeightLG).mul(1.5).equal(),
+              height: token.controlHeight,
+              background: 'transparent',
+              content: '""'
+            }
+          }
+        },
+        '&-content': {
+          width: descriptionMaxWidth
+        },
+        [`&-process ${componentCls}-item-icon`]: {
+          position: 'relative',
+          top: token.calc(dotSize).sub(dotCurrentSize).div(2).equal(),
+          width: dotCurrentSize,
+          height: dotCurrentSize,
+          lineHeight: unit(dotCurrentSize),
+          background: 'none',
+          marginInlineStart: token.calc(token.descriptionMaxWidth).sub(dotCurrentSize).div(2).equal()
+        },
+        [`&-process ${componentCls}-icon`]: {
+          [`&:first-child ${componentCls}-icon-dot`]: {
+            insetInlineStart: 0
+          }
+        }
+      }
+    },
+    [`&${componentCls}-vertical${componentCls}-dot`]: {
+      [`${componentCls}-item-icon`]: {
+        marginTop: token.calc(token.controlHeight).sub(dotSize).div(2).equal(),
+        marginInlineStart: 0,
+        background: 'none'
+      },
+      [`${componentCls}-item-process ${componentCls}-item-icon`]: {
+        marginTop: token.calc(token.controlHeight).sub(dotCurrentSize).div(2).equal(),
+        top: 0,
+        insetInlineStart: token.calc(dotSize).sub(dotCurrentSize).div(2).equal(),
+        marginInlineStart: 0
+      },
+      // https://github.com/ant-design/ant-design/issues/18354
+      [`${componentCls}-item > ${componentCls}-item-container > ${componentCls}-item-tail`]: {
+        top: token.calc(token.controlHeight).sub(dotSize).div(2).equal(),
+        insetInlineStart: 0,
+        margin: 0,
+        padding: `${unit(token.calc(dotSize).add(token.paddingXS).equal())} 0 ${unit(token.paddingXS)}`,
+        '&::after': {
+          marginInlineStart: token.calc(dotSize).sub(token.lineWidth).div(2).equal()
+        }
+      },
+      [`&${componentCls}-small`]: {
+        [`${componentCls}-item-icon`]: {
+          marginTop: token.calc(token.controlHeightSM).sub(dotSize).div(2).equal()
+        },
+        [`${componentCls}-item-process ${componentCls}-item-icon`]: {
+          marginTop: token.calc(token.controlHeightSM).sub(dotCurrentSize).div(2).equal()
+        },
+        [`${componentCls}-item > ${componentCls}-item-container > ${componentCls}-item-tail`]: {
+          top: token.calc(token.controlHeightSM).sub(dotSize).div(2).equal()
+        }
+      },
+      [`${componentCls}-item:first-child ${componentCls}-icon-dot`]: {
+        insetInlineStart: 0
+      },
+      [`${componentCls}-item-content`]: {
+        width: 'inherit'
+      }
+    }
+  };
+};
+export default genStepsProgressDotStyle;

frontend/node_modules/antd/es/steps/style/progress.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { StepsToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genStepsProgressStyle: GenerateStyle<StepsToken, CSSObject>;
+export default genStepsProgressStyle;

frontend/node_modules/antd/es/steps/style/progress.js

@@ -0,0 +1,69 @@
+import { unit } from '@ant-design/cssinjs';
+const genStepsProgressStyle = token => {
+  const {
+    antCls,
+    componentCls,
+    iconSize,
+    iconSizeSM,
+    processIconColor,
+    marginXXS,
+    lineWidthBold,
+    lineWidth,
+    paddingXXS
+  } = token;
+  const progressSize = token.calc(iconSize).add(token.calc(lineWidthBold).mul(4).equal()).equal();
+  const progressSizeSM = token.calc(iconSizeSM).add(token.calc(token.lineWidth).mul(4).equal()).equal();
+  return {
+    [`&${componentCls}-with-progress`]: {
+      [`${componentCls}-item`]: {
+        paddingTop: paddingXXS,
+        [`&-process ${componentCls}-item-container ${componentCls}-item-icon ${componentCls}-icon`]: {
+          color: processIconColor
+        }
+      },
+      [`&${componentCls}-vertical > ${componentCls}-item `]: {
+        paddingInlineStart: paddingXXS,
+        [`> ${componentCls}-item-container > ${componentCls}-item-tail`]: {
+          top: marginXXS,
+          insetInlineStart: token.calc(iconSize).div(2).sub(lineWidth).add(paddingXXS).equal()
+        }
+      },
+      [`&, &${componentCls}-small`]: {
+        [`&${componentCls}-horizontal ${componentCls}-item:first-child`]: {
+          paddingBottom: paddingXXS,
+          paddingInlineStart: paddingXXS
+        }
+      },
+      [`&${componentCls}-small${componentCls}-vertical > ${componentCls}-item > ${componentCls}-item-container > ${componentCls}-item-tail`]: {
+        insetInlineStart: token.calc(iconSizeSM).div(2).sub(lineWidth).add(paddingXXS).equal()
+      },
+      [`&${componentCls}-label-vertical ${componentCls}-item ${componentCls}-item-tail`]: {
+        top: token.calc(iconSize).div(2).add(paddingXXS).equal()
+      },
+      [`${componentCls}-item-icon`]: {
+        position: 'relative',
+        [`${antCls}-progress`]: {
+          position: 'absolute',
+          insetInlineStart: '50%',
+          top: '50%',
+          transform: 'translate(-50%, -50%)',
+          '&-inner': {
+            width: `${unit(progressSize)} !important`,
+            height: `${unit(progressSize)} !important`
+          }
+        }
+      },
+      // ============================== Small size ==============================
+      [`&${componentCls}-small`]: {
+        [`&${componentCls}-label-vertical ${componentCls}-item ${componentCls}-item-tail`]: {
+          top: token.calc(iconSizeSM).div(2).add(paddingXXS).equal()
+        },
+        [`${componentCls}-item-icon ${antCls}-progress-inner`]: {
+          width: `${unit(progressSizeSM)} !important`,
+          height: `${unit(progressSizeSM)} !important`
+        }
+      }
+    }
+  };
+};
+export default genStepsProgressStyle;

frontend/node_modules/antd/es/steps/style/rtl.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { StepsToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genStepsRTLStyle: GenerateStyle<StepsToken, CSSObject>;
+export default genStepsRTLStyle;

frontend/node_modules/antd/es/steps/style/rtl.js

@@ -0,0 +1,39 @@
+const genStepsRTLStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [`&${componentCls}-rtl`]: {
+      direction: 'rtl',
+      [`${componentCls}-item`]: {
+        '&-subtitle': {
+          float: 'left'
+        }
+      },
+      // nav
+      [`&${componentCls}-navigation`]: {
+        [`${componentCls}-item::after`]: {
+          transform: 'rotate(-45deg)'
+        }
+      },
+      // vertical
+      [`&${componentCls}-vertical`]: {
+        [`> ${componentCls}-item`]: {
+          '&::after': {
+            transform: 'rotate(225deg)'
+          },
+          [`${componentCls}-item-icon`]: {
+            float: 'right'
+          }
+        }
+      },
+      // progress-dot
+      [`&${componentCls}-dot`]: {
+        [`${componentCls}-item-icon ${componentCls}-icon-dot, &${componentCls}-small ${componentCls}-item-icon ${componentCls}-icon-dot`]: {
+          float: 'right'
+        }
+      }
+    }
+  };
+};
+export default genStepsRTLStyle;

frontend/node_modules/antd/es/steps/style/small.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { StepsToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genStepsSmallStyle: GenerateStyle<StepsToken, CSSObject>;
+export default genStepsSmallStyle;

frontend/node_modules/antd/es/steps/style/small.js

@@ -0,0 +1,62 @@
+import { unit } from '@ant-design/cssinjs';
+const genStepsSmallStyle = token => {
+  const {
+    componentCls,
+    iconSizeSM,
+    // stepsSmallIconMargin,
+    fontSizeSM,
+    fontSize,
+    colorTextDescription
+  } = token;
+  return {
+    [`&${componentCls}-small`]: {
+      [`&${componentCls}-horizontal:not(${componentCls}-label-vertical) ${componentCls}-item`]: {
+        paddingInlineStart: token.paddingSM,
+        '&:first-child': {
+          paddingInlineStart: 0
+        }
+      },
+      [`${componentCls}-item-icon`]: {
+        width: iconSizeSM,
+        height: iconSizeSM,
+        // margin: stepsSmallIconMargin,
+        marginTop: 0,
+        marginBottom: 0,
+        marginInline: `0 ${unit(token.marginXS)}`,
+        fontSize: fontSizeSM,
+        lineHeight: unit(iconSizeSM),
+        textAlign: 'center',
+        borderRadius: iconSizeSM
+      },
+      [`${componentCls}-item-title`]: {
+        paddingInlineEnd: token.paddingSM,
+        fontSize,
+        lineHeight: unit(iconSizeSM),
+        '&::after': {
+          top: token.calc(iconSizeSM).div(2).equal()
+        }
+      },
+      [`${componentCls}-item-description`]: {
+        color: colorTextDescription,
+        fontSize
+      },
+      [`${componentCls}-item-tail`]: {
+        top: token.calc(iconSizeSM).div(2).sub(token.paddingXXS).equal()
+      },
+      [`${componentCls}-item-custom ${componentCls}-item-icon`]: {
+        width: 'inherit',
+        height: 'inherit',
+        lineHeight: 'inherit',
+        background: 'none',
+        border: 0,
+        borderRadius: 0,
+        [`> ${componentCls}-icon`]: {
+          fontSize: iconSizeSM,
+          lineHeight: unit(iconSizeSM),
+          transform: 'none'
+        }
+      }
+    }
+  };
+};
+export default genStepsSmallStyle;

frontend/node_modules/antd/es/steps/style/vertical.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { StepsToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genStepsVerticalStyle: GenerateStyle<StepsToken, CSSObject>;
+export default genStepsVerticalStyle;

frontend/node_modules/antd/es/steps/style/vertical.js

@@ -0,0 +1,67 @@
+import { unit } from '@ant-design/cssinjs';
+const genStepsVerticalStyle = token => {
+  const {
+    componentCls,
+    iconSizeSM,
+    iconSize
+  } = token;
+  return {
+    [`&${componentCls}-vertical`]: {
+      display: 'flex',
+      flexDirection: 'column',
+      [`> ${componentCls}-item`]: {
+        display: 'block',
+        flex: '1 0 auto',
+        paddingInlineStart: 0,
+        overflow: 'visible',
+        [`${componentCls}-item-icon`]: {
+          float: 'left',
+          marginInlineEnd: token.margin
+        },
+        [`${componentCls}-item-content`]: {
+          display: 'block',
+          minHeight: token.calc(token.controlHeight).mul(1.5).equal(),
+          overflow: 'hidden'
+        },
+        [`${componentCls}-item-title`]: {
+          lineHeight: unit(iconSize)
+        },
+        [`${componentCls}-item-description`]: {
+          paddingBottom: token.paddingSM
+        }
+      },
+      [`> ${componentCls}-item > ${componentCls}-item-container > ${componentCls}-item-tail`]: {
+        position: 'absolute',
+        top: 0,
+        insetInlineStart: token.calc(iconSize).div(2).sub(token.lineWidth).equal(),
+        width: token.lineWidth,
+        height: '100%',
+        padding: `${unit(token.calc(token.marginXXS).mul(1.5).add(iconSize).equal())} 0 ${unit(token.calc(token.marginXXS).mul(1.5).equal())}`,
+        '&::after': {
+          width: token.lineWidth,
+          height: '100%'
+        }
+      },
+      [`> ${componentCls}-item:not(:last-child) > ${componentCls}-item-container > ${componentCls}-item-tail`]: {
+        display: 'block'
+      },
+      [` > ${componentCls}-item > ${componentCls}-item-container > ${componentCls}-item-content > ${componentCls}-item-title`]: {
+        '&::after': {
+          display: 'none'
+        }
+      },
+      [`&${componentCls}-small ${componentCls}-item-container`]: {
+        [`${componentCls}-item-tail`]: {
+          position: 'absolute',
+          top: 0,
+          insetInlineStart: token.calc(iconSizeSM).div(2).sub(token.lineWidth).equal(),
+          padding: `${unit(token.calc(token.marginXXS).mul(1.5).add(iconSizeSM).equal())} 0 ${unit(token.calc(token.marginXXS).mul(1.5).equal())}`
+        },
+        [`${componentCls}-item-title`]: {
+          lineHeight: unit(iconSizeSM)
+        }
+      }
+    }
+  };
+};
+export default genStepsVerticalStyle;

frontend/node_modules/antd/es/steps/useLegacyItems.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import type { StepProps } from '.';
+declare function useLegacyItems(items?: StepProps[], children?: React.ReactNode): StepProps[];
+export default useLegacyItems;

frontend/node_modules/antd/es/steps/useLegacyItems.js

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import toArray from "rc-util/es/Children/toArray";
+import { devUseWarning } from '../_util/warning';
+function filter(items) {
+  return items.filter(item => item);
+}
+function useLegacyItems(items, children) {
+  if (process.env.NODE_ENV === 'test') {
+    const warning = devUseWarning('Menu');
+    warning.deprecated(!children, 'Step', 'items');
+  }
+  if (items) {
+    return items;
+  }
+  const childrenItems = toArray(children).map(node => {
+    if (/*#__PURE__*/React.isValidElement(node)) {
+      const {
+        props
+      } = node;
+      const item = Object.assign({}, props);
+      return item;
+    }
+    return null;
+  });
+  return filter(childrenItems);
+}
+export default useLegacyItems;