cnhis-design-vue 3.1.24-beta.7 → 3.1.24-beta.8

package/es/components/shortcut-setter/src/ShortcutSetterItem.js

@@ -0,0 +1,73 @@
+import { defineComponent, ref, computed, openBlock, createElementBlock, createVNode, unref, withModifiers } from 'vue';
+import { NInput } from 'naive-ui';
+import { getDisplaySignature } from '../../shortcut-provider/src/utils/index.js';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.js';
+
+const _hoisted_1 = { class: "shortcut-setter-item__wrapper" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ShortcutSetterItem",
+  props: {
+    shortcutKey: null,
+    shortcutSignature: null,
+    value: null,
+    onChange: null,
+    onFocus: null,
+    placeholder: { default: "\u70B9\u51FB\u8BBE\u7F6E\u5FEB\u6377\u952E" },
+    editPlaceholder: { default: "\u952E\u76D8\u6309\u4E0B\u8981\u8BBE\u7F6E\u7684\u5FEB\u6377\u952E\u7EC4\u5408" }
+  },
+  emits: ["shortcutChange"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const currentSetShortcut = ref(getDisplaySignature(props.shortcutSignature));
+    const state = ref(0);
+    const isEditState = computed(() => state.value === 0);
+    const currentEditShortcut = ref("");
+    const showContent = computed(() => {
+      return isEditState.value ? currentSetShortcut.value : currentEditShortcut.value;
+    });
+    const placeholder = computed(() => {
+      return isEditState.value ? props.placeholder : props.editPlaceholder;
+    });
+    function onInputFocus() {
+      state.value = 1;
+    }
+    const inputRef = ref();
+    function onInputBlur() {
+      var _a;
+      state.value = 0;
+      currentEditShortcut.value = "";
+      (_a = inputRef.value) == null ? void 0 : _a.blur();
+    }
+    const onInputKeyDown = (event) => {
+      currentEditShortcut.value = getDisplaySignature(event);
+    };
+    const onInputKeyUp = async (event) => {
+      try {
+        await new Promise((resolve, reject) => {
+          emit("shortcutChange", { key: props.shortcutKey, info: event, resolve, reject });
+        });
+        currentSetShortcut.value = getDisplaySignature(event);
+      } finally {
+        onInputBlur();
+        currentEditShortcut.value = "";
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("section", _hoisted_1, [
+        createVNode(unref(NInput), {
+          ref_key: "inputRef",
+          ref: inputRef,
+          value: unref(showContent),
+          placeholder: unref(placeholder),
+          onFocus: onInputFocus,
+          onBlur: onInputBlur,
+          onKeydown: withModifiers(onInputKeyDown, ["prevent", "stop"]),
+          onKeyup: withModifiers(onInputKeyUp, ["prevent", "stop"])
+        }, null, 8, ["value", "placeholder", "onKeydown", "onKeyup"])
+      ]);
+    };
+  }
+});
+var ShortcutSetterItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "ShortcutSetterItem.vue"]]);
+
+export { ShortcutSetterItem as default };

package/es/components/shortcut-setter/src/ShortcutSetterItem.vue.d.ts

@@ -0,0 +1,99 @@
+import { AnyObject } from '../../../../es/shared/types';
+import { ShortcutSignatureInfo } from '../../../../es/components/shortcut-provider';
+declare enum ShortcutInputState {
+    STATIC = 0,
+    EDIT = 1
+}
+declare const _default: import("vue").DefineComponent<{
+    shortcutKey: {
+        type: StringConstructor;
+        required: true;
+    };
+    shortcutSignature: {
+        type: null;
+        required: true;
+    };
+    value: {
+        type: null;
+        required: true;
+    };
+    onChange: {
+        type: null;
+        required: true;
+    };
+    onFocus: {
+        type: null;
+        required: true;
+    };
+    placeholder: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    editPlaceholder: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}, {
+    props: {
+        shortcutKey: string;
+        shortcutSignature: ShortcutSignatureInfo;
+        value: unknown;
+        onChange: unknown;
+        onFocus: unknown;
+        placeholder: string;
+        editPlaceholder: string;
+    };
+    ShortcutInputState: typeof ShortcutInputState;
+    currentSetShortcut: import("vue").Ref<string>;
+    state: import("vue").Ref<ShortcutInputState>;
+    isEditState: import("vue").ComputedRef<boolean>;
+    currentEditShortcut: import("vue").Ref<string>;
+    showContent: import("vue").ComputedRef<string>;
+    placeholder: import("vue").ComputedRef<string>;
+    onInputFocus: () => void;
+    inputRef: import("vue").Ref<AnyObject | undefined>;
+    onInputBlur: () => void;
+    onInputKeyDown: (event: KeyboardEvent) => void;
+    emit: (event: "shortcutChange", ...args: any[]) => void;
+    onInputKeyUp: (event: KeyboardEvent) => Promise<void>;
+    NInput: any;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "shortcutChange"[], "shortcutChange", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    shortcutKey: {
+        type: StringConstructor;
+        required: true;
+    };
+    shortcutSignature: {
+        type: null;
+        required: true;
+    };
+    value: {
+        type: null;
+        required: true;
+    };
+    onChange: {
+        type: null;
+        required: true;
+    };
+    onFocus: {
+        type: null;
+        required: true;
+    };
+    placeholder: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    editPlaceholder: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}>> & {
+    onShortcutChange?: ((...args: any[]) => any) | undefined;
+}, {
+    placeholder: string;
+    editPlaceholder: string;
+}>;
+export default _default;

package/es/components/shortcut-setter/src/types/index.d.ts

@@ -0,0 +1,6 @@
+import { ShortcutSignatureInfo } from '../../../../../es/components/shortcut-provider';
+export interface ShortcutSetterExpose {
+    loadSignature(): void;
+    getSignature(): Record<string, ShortcutSignatureInfo>;
+    setSignature(): void;
+}

package/es/components/shortcut-setter/src/types/index.js

@@ -0,0 +1 @@
+

package/es/components/shortcut-setter/style/index.css

@@ -0,0 +1 @@
+.shortcut-setter-item__wrapper{display:flex}.shortcut-setter-item__operation{display:flex;gap:12px;margin-left:12px}

package/es/components/steps-wheel/index.d.ts

@@ -0,0 +1,112 @@
+import { SFCWithInstall } from '../../../es/shared/types';
+declare const StepsWheel: SFCWithInstall<import("vue").DefineComponent<{
+    stepInfo: {
+        type: ObjectConstructor;
+        default: () => {
+            list: never[];
+            cols: number;
+        };
+    };
+    currentStep: {
+        type: NumberConstructor;
+        default: number;
+    };
+    toolTipShow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    lastNodeRender: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noDataMsg: {
+        type: StringConstructor;
+        default: string;
+    };
+    placement: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        stepInfo: {
+            type: ObjectConstructor;
+            default: () => {
+                list: never[];
+                cols: number;
+            };
+        };
+        currentStep: {
+            type: NumberConstructor;
+            default: number;
+        };
+        toolTipShow: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        lastNodeRender: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        noDataMsg: {
+            type: StringConstructor;
+            default: string;
+        };
+        placement: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & {}>>;
+    nodeRowCount: import("vue").ComputedRef<number>;
+    lastNodeRenderShow: import("vue").ComputedRef<boolean>;
+    noDataMsg: import("vue").Ref<string>;
+    stepItemRef: any;
+    countBoxWidth: import("vue").ComputedRef<string>;
+    stepInfoList: import("vue").Ref<any[]>;
+    handleNode: (nodeList: any[], cols: number) => void;
+    lineCircleLeft: (stepItem: any) => boolean;
+    lineCircleRight: (stepItem: any) => boolean;
+    lineActiveShow: (stepItem: any, index: number) => boolean;
+    format2DArray: (baseArray: any[], cols: number) => never[];
+    lastLineHidden: (index: number) => boolean;
+    handleFinishLastNodeCss: (index: number) => boolean;
+    handleFinishLastNodeLine: (index: number) => boolean;
+    NTooltip: any;
+    NEmpty: any;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    stepInfo: {
+        type: ObjectConstructor;
+        default: () => {
+            list: never[];
+            cols: number;
+        };
+    };
+    currentStep: {
+        type: NumberConstructor;
+        default: number;
+    };
+    toolTipShow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    lastNodeRender: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noDataMsg: {
+        type: StringConstructor;
+        default: string;
+    };
+    placement: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    noDataMsg: string;
+    stepInfo: Record<string, any>;
+    currentStep: number;
+    toolTipShow: boolean;
+    lastNodeRender: boolean;
+    placement: string;
+}>>;
+export default StepsWheel;

package/es/components/steps-wheel/index.js

@@ -0,0 +1,10 @@
+import { COMPONENT_NAMESPACE } from '../../shared/global/variable.js';
+import { safeComponentRegister } from '../../shared/utils/index.js';
+import script from './src/StepsWheel.js';
+
+const StepsWheel = script;
+StepsWheel.install = function(app) {
+  safeComponentRegister(app, StepsWheel, COMPONENT_NAMESPACE + "StepsWheel");
+};
+
+export { StepsWheel as default };

package/es/components/steps-wheel/src/StepsWheel.js

@@ -0,0 +1,318 @@
+import { defineComponent, computed, toRefs, ref, watch, openBlock, createElementBlock, normalizeStyle, unref, createElementVNode, Fragment, renderList, normalizeClass, createCommentVNode, renderSlot, toDisplayString, createBlock, withCtx, withDirectives, vShow, createVNode, createTextVNode } from 'vue';
+import { NTooltip, NEmpty } from 'naive-ui';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.js';
+
+const _hoisted_1 = {
+  key: 0,
+  class: "stepOut"
+};
+const _hoisted_2 = { style: { "list-style": "none", "width": "100%" } };
+const _hoisted_3 = ["title"];
+const _hoisted_4 = /* @__PURE__ */ createElementVNode("ul", { class: "nodeTipContent" }, [
+  /* @__PURE__ */ createElementVNode("li", null, [
+    /* @__PURE__ */ createElementVNode("p", null, [
+      /* @__PURE__ */ createElementVNode("span", { style: { "margin-right": "10px" } }, "(1)"),
+      /* @__PURE__ */ createTextVNode(" 2022-07-30 14:15:12 ")
+    ]),
+    /* @__PURE__ */ createElementVNode("p", null, "\u5468\u8001\u5E08"),
+    /* @__PURE__ */ createElementVNode("p", null, "\u6B65\u9AA4\u6761\u63D0\u793A"),
+    /* @__PURE__ */ createElementVNode("p", null, "\u54B1\u8FD9\u662F\u6D4B\u8BD5\u6848\u4F8B,\u8BF7\u4F7F\u7528\u63D2\u69FD\uFF1A#nodeTipBox \u81EA\u5B9A\u4E49")
+  ]),
+  /* @__PURE__ */ createElementVNode("li", null, [
+    /* @__PURE__ */ createElementVNode("p", null, [
+      /* @__PURE__ */ createElementVNode("span", { style: { "margin-right": "10px" } }, "(2)"),
+      /* @__PURE__ */ createTextVNode(" 2022-07-30 14:15:12 ")
+    ]),
+    /* @__PURE__ */ createElementVNode("p", null, "\u5468\u8001\u5E08"),
+    /* @__PURE__ */ createElementVNode("p", null, "\u6B65\u9AA4\u6761\u63D0\u793A"),
+    /* @__PURE__ */ createElementVNode("p", null, "\u54B1\u8FD9\u662F\u4E2A\u6D4B\u8BD5\u6848\u4F8B,\u8BF7\u4F7F\u7528\u63D2\u69FD\uFF1A#nodeTipBox \u81EA\u5B9A\u4E49")
+  ])
+], -1);
+const _hoisted_5 = ["title"];
+const _hoisted_6 = ["title"];
+const _hoisted_7 = { key: 1 };
+const _hoisted_8 = { key: 1 };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "StepsWheel",
+  props: {
+    stepInfo: {
+      type: Object,
+      default: () => {
+        return {
+          list: [],
+          cols: 6
+        };
+      }
+    },
+    currentStep: {
+      type: Number,
+      default: 1
+    },
+    toolTipShow: {
+      type: Boolean,
+      default: true
+    },
+    lastNodeRender: {
+      type: Boolean,
+      default: false
+    },
+    noDataMsg: {
+      type: String,
+      default: "\u6682\u65E0\u8282\u70B9\u6570\u636E"
+    },
+    placement: {
+      type: String,
+      default: "center"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const nodeRowCount = computed(() => {
+      return Math.ceil(stepInfoList.value.length / props.stepInfo.cols);
+    });
+    const lastNodeRenderShow = computed(() => {
+      return props.lastNodeRender;
+    });
+    const { noDataMsg } = toRefs(props);
+    const stepItemRef = ref(null);
+    const countBoxWidth = computed(() => {
+      var _a;
+      let min = 72;
+      if ((_a = stepItemRef == null ? void 0 : stepItemRef.value) == null ? void 0 : _a.length) {
+        let element = stepItemRef.value[0];
+        let style = window.getComputedStyle ? window.getComputedStyle(element) : element.currentStyle;
+        min = isNaN(parseInt(style["min-width"])) ? 72 : parseInt(style["min-width"]);
+      }
+      let width = 20 + props.stepInfo.cols * min;
+      return `${width}px`;
+    });
+    const stepInfoList = ref([]);
+    const handleNode = (nodeList, cols) => {
+      let length = nodeList.length + 1;
+      let rows = Math.ceil(nodeList.length / cols);
+      let sort = true;
+      let arr = [];
+      for (var i = 0; i < rows; i++) {
+        arr[i] = new Array(cols);
+        arr[i].fill(null);
+      }
+      let x = 0, y = 0;
+      for (let i2 = 1; i2 < length; i2++) {
+        arr[x][y] = Object.assign(nodeList[i2 - 1], {
+          nodeIndex: i2,
+          rowIndex: x + 1
+        });
+        if (sort) {
+          if (i2 % cols != 0) {
+            y++;
+          } else {
+            sort = !sort;
+            x++;
+          }
+        } else {
+          if (i2 % cols != 0) {
+            y--;
+          } else {
+            sort = !sort;
+            x++;
+          }
+        }
+      }
+      let list = [];
+      arr.map((v) => {
+        v.map((a, i2) => a && (a.sort = i2));
+        v[0] && (v[0].nodeType = "frist");
+        v[v.length - 1] && (v[v.length - 1].nodeType = "last");
+        list = [...list, ...v];
+      });
+      stepInfoList.value = list;
+    };
+    const lineCircleLeft = (stepItem) => {
+      const { list = [] } = props.stepInfo;
+      return stepItem.rowIndex % 2 == 0 && stepItem.nodeType == "frist" && stepItem.nodeIndex !== list.length;
+    };
+    const lineCircleRight = (stepItem) => {
+      const { list = [] } = props.stepInfo;
+      return stepItem.rowIndex % 2 != 0 && stepItem.nodeType == "last" && stepItem.nodeIndex !== list.length;
+    };
+    const lineActiveShow = (stepItem, index) => {
+      if (stepItem.rowIndex % 2 == 0) {
+        return props.currentStep >= index + (props.stepInfo.cols - 2 * stepItem.sort);
+      } else {
+        return props.currentStep >= index + 2;
+      }
+    };
+    const format2DArray = (baseArray, cols) => {
+      let len = baseArray.length;
+      let lineNum = len % cols === 0 ? len / cols : Math.floor(len / cols + 1);
+      let res = [];
+      for (let i = 0; i < lineNum; i++) {
+        let temp = baseArray.slice(i * cols, i * cols + cols);
+        res.push(temp);
+      }
+      return res;
+    };
+    const lastLineHidden = (index) => {
+      const { cols } = props.stepInfo;
+      let arr = format2DArray(stepInfoList.value, cols);
+      let lastRow = arr[arr.length - 1].filter((v) => v);
+      if (nodeRowCount.value % 2 == 0) {
+        return index != lastRow[lastRow.length - 1].nodeIndex - (props.stepInfo.cols - 2 * lastRow[lastRow.length - 1].sort);
+      } else {
+        return index != lastRow[lastRow.length - 1].nodeIndex - 1;
+      }
+    };
+    const handleFinishLastNodeCss = (index) => {
+      const { cols } = props.stepInfo;
+      let arr = format2DArray(stepInfoList.value, cols);
+      let lastRow = arr[arr.length - 1].filter((v) => v);
+      if (nodeRowCount.value % 2 == 0) {
+        return lastNodeRenderShow.value && index == lastRow[lastRow.length - 1].nodeIndex - (props.stepInfo.cols - 2 * lastRow[lastRow.length - 1].sort);
+      } else {
+        return lastNodeRenderShow.value && index == lastRow[lastRow.length - 1].nodeIndex - 1;
+      }
+    };
+    const handleFinishLastNodeLine = (index) => {
+      const { cols } = props.stepInfo;
+      let arr = format2DArray(stepInfoList.value, cols);
+      let lastRow = arr[arr.length - 1].filter((v) => v);
+      if (nodeRowCount.value % 2 == 0) {
+        return lastNodeRenderShow.value && index == lastRow[lastRow.length - 1].nodeIndex - (props.stepInfo.cols - 2 * lastRow[lastRow.length - 1].sort) - 1;
+      } else {
+        return lastNodeRenderShow.value && index == lastRow[lastRow.length - 1].nodeIndex - 2;
+      }
+    };
+    watch(
+      () => props.stepInfo,
+      (val) => {
+        var _a;
+        if ((_a = val == null ? void 0 : val.list) == null ? void 0 : _a.length) {
+          handleNode(val.list, val.cols);
+        }
+      },
+      { immediate: true, deep: true }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "step-wheel-box",
+        style: normalizeStyle({ minWidth: unref(countBoxWidth) })
+      }, [
+        stepInfoList.value.length ? (openBlock(), createElementBlock("div", _hoisted_1, [
+          createElementVNode("ul", _hoisted_2, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(stepInfoList.value, (stepItem, index) => {
+              return openBlock(), createElementBlock("li", {
+                class: normalizeClass(["stepItem", { [`stepItem_${index + 1}`]: true, [`${stepItem == null ? void 0 : stepItem.stepId}`]: (stepItem == null ? void 0 : stepItem.stepId) ? true : false }]),
+                ref_for: true,
+                ref_key: "stepItemRef",
+                ref: stepItemRef,
+                key: (stepItem == null ? void 0 : stepItem.stepId) || index
+              }, [
+                stepItem ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+                  createCommentVNode(" \u6B65\u9AA4\u5934\u90E8\u4FE1\u606F "),
+                  createElementVNode("div", {
+                    class: normalizeClass(["stepTopBox", {
+                      finished: handleFinishLastNodeCss(index),
+                      stepTopBox_right: __props.placement === "right",
+                      stepTopBox_left: __props.placement === "left"
+                    }])
+                  }, [
+                    renderSlot(_ctx.$slots, "stepTopBox", {}, () => [
+                      createElementVNode("span", {
+                        title: stepItem.title
+                      }, toDisplayString(stepItem.title), 9, _hoisted_3)
+                    ])
+                  ], 2),
+                  createCommentVNode(" \u6B65\u9AA4\u6761\u7684\u8282\u70B9\uFF0C\u6B64\u5904\u4E3A\u5706\u5708 "),
+                  __props.toolTipShow ? (openBlock(), createBlock(unref(NTooltip), {
+                    key: 0,
+                    placement: "top",
+                    "show-arrow": true,
+                    trigger: "hover",
+                    style: normalizeStyle({ opacity: "0.88" })
+                  }, {
+                    trigger: withCtx(() => [
+                      createElementVNode("div", {
+                        class: normalizeClass(["icon", {
+                          active: __props.currentStep >= stepItem.nodeIndex,
+                          finished: handleFinishLastNodeCss(index)
+                        }])
+                      }, null, 2)
+                    ]),
+                    default: withCtx(() => [
+                      renderSlot(_ctx.$slots, "nodeTipBox", {
+                        stepId: stepItem.stepId
+                      }, () => [
+                        _hoisted_4
+                      ])
+                    ]),
+                    _: 2
+                  }, 1032, ["style"])) : (openBlock(), createElementBlock("div", {
+                    key: 1,
+                    class: normalizeClass(["icon", {
+                      active: __props.currentStep >= stepItem.nodeIndex,
+                      finished: handleFinishLastNodeCss(index)
+                    }])
+                  }, null, 2)),
+                  createCommentVNode(" \u6B65\u9AA4\u6761\u8FDE\u63A5\u7EBF\uFF0C\u52A8\u6001\u663E\u793A  "),
+                  stepItem.nodeType !== "last" ? withDirectives((openBlock(), createElementBlock("div", {
+                    key: 2,
+                    class: normalizeClass(["line", {
+                      lineActive: lineActiveShow(stepItem, index),
+                      finished: handleFinishLastNodeLine(index)
+                    }])
+                  }, null, 2)), [
+                    [vShow, lastLineHidden(index)]
+                  ]) : createCommentVNode("v-if", true),
+                  createCommentVNode(" \u6B65\u9AA4\u6761\u5F2F\u66F2\u8FDE\u7EBF\uFF0C\u52A8\u6001\u6E32\u67D3 "),
+                  lineCircleLeft(stepItem) || lineCircleRight(stepItem) ? (openBlock(), createElementBlock("div", {
+                    key: 3,
+                    class: normalizeClass({
+                      lineCircleActive: __props.currentStep > stepItem.nodeIndex,
+                      lineCircleRight: lineCircleRight(stepItem),
+                      lineCircleLeft: lineCircleLeft(stepItem)
+                    })
+                  }, null, 2)) : createCommentVNode("v-if", true),
+                  createCommentVNode(" \u6B65\u9AA4\u5E95\u90E8\u4FE1\u606F "),
+                  createElementVNode("div", {
+                    class: normalizeClass(["stepBottomBox", { stepBottomBox_right: __props.placement === "right", stepBottomBox_left: __props.placement === "left" }])
+                  }, [
+                    renderSlot(_ctx.$slots, "stepBottomBox", {}, () => [
+                      createCommentVNode(" \u6B65\u9AA4\u540D\u79F0  "),
+                      withDirectives(createElementVNode("p", {
+                        class: normalizeClass(["stepLabel", {
+                          labelFinsh: handleFinishLastNodeCss(index),
+                          stepLabel_right: __props.placement === "right",
+                          stepLabel_left: __props.placement === "left"
+                        }]),
+                        title: stepItem.label
+                      }, toDisplayString(stepItem.label), 11, _hoisted_5), [
+                        [vShow, stepItem.label]
+                      ]),
+                      withDirectives(createElementVNode("p", {
+                        class: "stepExtra",
+                        title: stepItem.person
+                      }, toDisplayString(stepItem.person), 9, _hoisted_6), [
+                        [vShow, stepItem.person]
+                      ]),
+                      createCommentVNode(" \u6B65\u9AA4\u65F6\u95F4  "),
+                      withDirectives(createElementVNode("p", { class: "statusTime" }, toDisplayString(stepItem.statusTime), 513), [
+                        [vShow, stepItem.statusTime]
+                      ])
+                    ])
+                  ], 2)
+                ], 64)) : (openBlock(), createElementBlock("div", _hoisted_7, [
+                  createCommentVNode("null\u5143\u7D20\u5360\u4F4D")
+                ]))
+              ], 2);
+            }), 128))
+          ])
+        ])) : (openBlock(), createElementBlock("div", _hoisted_8, [
+          createVNode(unref(NEmpty), { description: unref(noDataMsg) }, null, 8, ["description"])
+        ]))
+      ], 4);
+    };
+  }
+});
+var script = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "StepsWheel.vue"]]);
+
+export { script as default };