easybill-ui 1.2.26 → 1.3.1

package/components/CurdGroupForm/src/CurdGroupForm.vue

@@ -0,0 +1,95 @@
+<template>
+  <CurdFormGroup v-for="(item, index) in props.schema.items" v-show="!schemaItemHidden(item)" :key="index" :item="item" :title="item.groupName" :icon="item.icon" :label-position="item.labelPosition">
+    <template v-if="item.headerRight" #headerRight>
+      <component :is="item.headerRight" :schema="props.schema" :schemaItem="item" :form-model="form" />
+    </template>
+    <template v-if="item.headerTitle" #title>
+      <component :is="item.headerTitle" :schema="props.schema" :schemaItem="item" :form-model="form" />
+    </template>
+    <template v-if="item.headerBottom" #headerBottom>
+      <component :is="item.headerBottom" :schema="props.schema" :schemaItem="item" :form-model="form" />
+    </template>
+    <div class="curdform-group-content" data-instance-form-wrap>
+      <CurdForm
+        :ref="(el: Element | ComponentPublicInstance | null) => (formRef[(item.step || '') + item.groupName + index] = el as InstanceType<typeof CurdForm>)"
+        v-model="form"
+        :form-schema="item.schema"
+        :extend-context="extendContext"
+        :validateOnRuleChange="false"
+        :scroll-to-error="true"
+        @change="onChange"
+      />
+    </div>
+  </CurdFormGroup>
+</template>
+
+<script lang="ts" setup>
+import { CurdForm } from "easybill-ui"
+import type { ComponentPublicInstance, PropType } from "vue"
+import { watch } from "vue"
+import type { CurdGroupFormSchema } from "../types"
+import CurdFormGroup from "./components/CurdFormGroup.vue"
+import { useFormHook } from "./hooks/useFormHook"
+const props = defineProps({
+  modelValue: {
+    type: Object as PropType<Record<string, unknown>>,
+    default: () => ({}),
+  },
+  schema: {
+    type: Object as PropType<CurdGroupFormSchema>,
+    default: () => ({}),
+  },
+})
+
+const emits = defineEmits(["update:modelValue", "change", "loadOptions"])
+const { form, formRef, schema: formSchema, validate, schemaItemHidden } = useFormHook()
+const init = () => {
+  form.value = props.modelValue || {}
+  formSchema.value = props.schema
+}
+init()
+watch(
+  () => props.schema,
+  () => {
+    formSchema.value = props.schema
+  },
+)
+
+watch(
+  () => props.modelValue,
+  () => {
+    if (form.value != props.modelValue) {
+      form.value = props.modelValue
+      // emits("update:modelValue", form.value)
+    }
+  },
+)
+
+const loadOptions = (prop: string, config?: unknown) => {
+  if (!props.schema) return
+  let has = false
+  for (const index in props.schema.items) {
+    const group = props.schema.items[index]
+    const formItem = group.schema.formItem
+    for (const i in formItem) {
+      const item = formItem[i]
+      if (item.prop == prop) {
+        has = true
+        formRef.value[(group.step || "") + group.groupName + index]?.loadOptions(prop, config)
+      }
+    }
+  }
+  if (!has) {
+    emits("loadOptions", prop)
+  }
+}
+const extendContext = {
+  loadOptions,
+}
+
+const onChange = (v: unknown, l: unknown) => {
+  emits("change", v, l)
+}
+
+defineExpose({ loadOptions, validate })
+</script>

package/components/CurdGroupForm/src/components/CurdFormGroup.vue

@@ -0,0 +1,39 @@
+<template>
+  <div class="curdform-group" :style="props.item.style" :class="props.item.class">
+    <div v-if="props.title || $slots.title" class="curdform-group-head">
+      <div class="left">
+        <span v-if="props.icon" class="icon"><i v-if="typeof props.icon == 'string'" :class="props.icon"></i><component v-else :is="props.icon"></component></span>
+        <div v-if="!$slots.title" class="title">{{ props.title }}</div>
+        <slot name="title"></slot>
+      </div>
+      <div class="right">
+        <slot name="headerRight"></slot>
+      </div>
+    </div>
+    <div v-if="props.item.desc" class="curdform-group-desc">{{ props.item.desc }}</div>
+    <slot name="headerBottom"></slot>
+    <div v-if="$slots.default" class="curdform-group-body">
+      <slot></slot>
+    </div>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import type { PropType } from "vue"
+import type { CurdGroupFormSchemaItem } from "../../types"
+
+const props = defineProps({
+  title: {
+    type: String,
+    default: "",
+  },
+  icon: {
+    type: String,
+    default: "",
+  },
+  item: {
+    type: Object as PropType<CurdGroupFormSchemaItem>,
+    default: () => ({}),
+  },
+})
+</script>

package/components/CurdGroupForm/src/hooks/useFormHook.ts

@@ -0,0 +1,55 @@
+import { CurdForm } from "easybill-ui"
+import { ref, type Ref } from "vue"
+import type { Schema, SchemaItem } from "../../types"
+
+export const useFormHook = (): {
+  form: Ref<Record<string, unknown>>
+  formRef: Ref<Record<string, InstanceType<typeof CurdForm>>>
+  submit: () => void
+  schema: Ref<Schema | undefined>
+  validate: (callback: (valid: boolean) => void) => void
+  loading: Ref<boolean>
+  schemaItemHidden: (item: SchemaItem) => boolean
+} => {
+  const formRef = ref<Record<string, InstanceType<typeof CurdForm>>>({})
+  const form = ref<Record<string, unknown>>({})
+  const schema = ref<Schema>()
+  const loading = ref(false)
+  const schemaItemHidden = (item: SchemaItem) => {
+    if (item?.hidden && item?.hidden instanceof Function) {
+      return item.hidden(form.value, item)
+    }
+    return !!item?.hidden
+  }
+  const validate = (callback: (valid: boolean) => void) => {
+    const validMap: boolean[] = []
+    for (const i in formRef.value) {
+      const curSchema = schema.value?.items.find((a, index) => (a.step || "") + a.groupName + index == i)
+      // 如果当前item隐藏了，则直接跳过校验
+      if (curSchema && schemaItemHidden(curSchema)) {
+        validMap.push(true)
+        continue
+      }
+      const cur = formRef.value[i]
+      cur.validate((valid: boolean) => {
+        validMap.push(valid)
+        if (validMap.length >= Object.keys(formRef.value).length && callback) callback(validMap.every((a) => a))
+      })
+    }
+  }
+  const submit = () => {
+    validate((valid) => {
+      if (!valid) return
+    })
+  }
+
+  return {
+    form,
+    formRef,
+    submit,
+    schema,
+    validate,
+    loading,
+    schemaItemHidden,
+  }
+}

package/components/CurdGroupForm/types.ts

@@ -0,0 +1,22 @@
+import type { Fields, FormSchema } from "easybill-ui"
+import type { Component, VNode } from "vue"
+export interface CurdGroupFormSchema {
+  items: CurdGroupFormSchemaItem[]
+}
+
+export interface CurdGroupFormSchemaItem {
+  groupName: string
+  schema: FormSchema
+  icon?: string
+  prop?: string // 唯一标识 不可修改
+  desc?: string
+  step?: string
+  stepIndex?: number
+  class?: string
+  style?: string
+  labelPosition?: string | "left" | "right" | "top"
+  hidden?: boolean | ((form: Fields, schemaItem: CurdGroupFormSchemaItem) => boolean)
+  headerRight?: Component | ((props: { schema: CurdGroupFormSchema; schemaItem: CurdGroupFormSchemaItem; formModel: Fields }) => VNode | VNode[])
+  headerBottom?: Component | ((props: { schema: CurdGroupFormSchema; schemaItem: CurdGroupFormSchemaItem; formModel: Fields }) => VNode | VNode[])
+  headerTitle?: Component | ((props: { schema: CurdGroupFormSchema; schemaItem: CurdGroupFormSchemaItem; formModel: Fields }) => VNode | VNode[])
+}

package/components/FormDialog/src/FormDialog.vue

@@ -1,30 +1,43 @@
 <template>
   <component :is="componentName" v-bind="containerProps">
-    <el-steps v-if="stepSchemaList.length > 1" :active="step" align-center style="margin-bottom: 20px; position: sticky; top: 0; z-index: 2000; background: var(--el-bg-color)" v-bind="stepProps">
-      <el-step v-for="(item, i) in stepSchemaList" :key="i" :title="item.name" :description="item.description" />
+    <el-steps v-if="isGroupMode && hasMultipleSteps && !stepComponent" :active="activeStep" align-center style="margin-bottom: 20px; position: sticky; top: 0; z-index: 2000; background: var(--el-bg-color)" v-bind="stepProps">
+      <el-step v-for="(stepItem, i) in stepList" :key="i" :title="stepItem.name" />
     </el-steps>
+    <component v-if="stepComponent" :is="stepComponent" :step="activeStep" :steps="stepList" />
     <div v-loading="confirmLoading" class="form-dialog-content">
-      <template v-for="(item, i) in stepSchemaList" :key="i">
-        <curd-form v-show="step == i" ref="curdFormRef" v-model="form" :fields="fields" :form-schema="item.formSchema" :extend-context="extendContexts" />
+      <!-- 单表单模式 -->
+      <curd-form v-if="isFormMode" ref="curdFormRef" v-model="form" :fields="fields" :form-schema="formSchema" :extend-context="extendContexts" />
+      <!-- 分组表单模式 -->
+      <template v-else-if="isGroupMode">
+        <div v-for="(stepItem, i) in stepList" :key="i" class="form-dialog-step" v-show="activeStep === i">
+          <curd-group-form :ref="(el: any) => el && (groupFormRef[i] = el)" v-model="form" :schema="stepItem.schema" :fields="fields" :extend-context="extendContexts" />
+        </div>
       </template>
     </div>
     <template #footer>
-      <span v-if="handleOk" class="dialog-footer">
+      <component v-if="footerComponent" :is="footerComponent" />
+      <span v-else-if="handleOk" class="dialog-footer">
         <el-button v-if="cancelBtnTextLabel" :disabled="confirmLoading" type="default" @click="onCancel()">{{ cancelBtnTextLabel }}</el-button>
-        <el-button v-if="stepSchemaList.length > 1 && step > 0" :disabled="confirmLoading" type="primary" plain @click="prev">{{ t("el.formDialog.preStep") }}</el-button>
-        <el-button v-if="stepSchemaList.length > 1 && step < stepSchemaList.length - 1" :disabled="confirmLoading" type="primary" plain @click="next">{{ t("el.formDialog.nextStep") }}</el-button>
-        <el-button v-if="step >= stepSchemaList.length - 1" :disabled="confirmLoading" type="primary" :loading="confirmLoading" @click="onOk">{{ confirmBtnTextLabel }}</el-button>
+        <el-button v-if="isGroupMode && hasMultipleSteps && canPrev" :disabled="confirmLoading" type="primary" plain @click="prev()">{{ t("el.formDialog.preStep") }}</el-button>
+        <el-button v-if="isGroupMode && hasMultipleSteps && canNext" :disabled="confirmLoading" type="primary" plain @click="next()">{{ t("el.formDialog.nextStep") }}</el-button>
+        <el-button v-if="!isGroupMode || isLastStep" :disabled="confirmLoading" type="primary" :loading="confirmLoading" @click="onOk">{{ confirmBtnTextLabel }}</el-button>
       </span>
     </template>
   </component>
 </template>
 
 <script lang="ts">
-import { useLocale } from "easybill-ui"
-import { computed, defineComponent, type PropType, provide, reactive, ref, type Ref, shallowRef, toRefs, useAttrs } from "vue"
+import { CurdForm, CurdGroupForm, type CurdGroupFormSchema, useLocale } from "easybill-ui"
+import { computed, defineComponent, type PropType, provide, reactive, ref, type Ref, toRefs, useAttrs } from "vue"
 import { type Fields, type FormSchema } from "../../CurdForm"
+import { useStepList } from "./hooks/useStepList"
+import { useStepNavigation } from "./hooks/useStepNavigation"
 export default defineComponent({
   name: "FormDialog",
+  components: {
+    CurdForm,
+    CurdGroupForm,
+  },
   props: {
     title: {
       type: String,
@@ -35,14 +48,15 @@ export default defineComponent({
       type: Function as PropType<() => void>,
       default: null,
     },
-    stepSchema: {
-      type: Array as PropType<{ name: string; description?: string; formSchema: FormSchema }[]>,
-      default: () => [],
-    },
     formSchema: {
       // 表单项
       type: Object as PropType<FormSchema>,
-      default: () => ({}),
+      default: () => null,
+    },
+    groupSchema: {
+      // 分组表单项
+      type: Object as PropType<CurdGroupFormSchema>,
+      default: () => null,
     },
     fields: {
       // 默认值，一般编辑时传入
@@ -84,45 +98,66 @@ export default defineComponent({
       type: String as PropType<"dialog" | "drawer">,
       default: "dialog",
     },
+    stepComponent: {
+      type: Object,
+      default: null,
+    },
+    footerComponent: {
+      type: Object,
+      default: null,
+    },
   },
   setup(props) {
     const attrs = useAttrs()
     const curdFormRef = ref()
     const form = ref<Fields>({})
     const state = reactive({
-      step: 0,
       visible: true,
       confirmLoading: false,
     })
     const { t } = useLocale()
-    const stepSchemaList = props.stepSchema?.length ? shallowRef(props.stepSchema) : shallowRef([{ name: "step1", description: "", formSchema: props.formSchema }])
-    const prev = () => {
-      if (state.step > 0) {
-        state.step--
-      }
-    }
-    const next = () => {
-      if (state.step < stepSchemaList.value.length - 1) {
-        state.confirmLoading = true
-        curdFormRef.value[state.step]?.validate((valid: boolean) => {
-          state.confirmLoading = false
-          if (valid) state.step++
-        })
-      }
-    }
+
+    // 模式判断
+    const isGroupMode = computed(() => !!props.groupSchema)
+    const isFormMode = computed(() => !!props.formSchema && !isGroupMode.value)
+
+    // 步骤列表
+    const { stepList, stepCount, hasMultipleSteps } = useStepList(computed(() => props.groupSchema))
+
+    // 步骤导航
+    const { activeStep, groupFormRef, canPrev, canNext, isLastStep, prev, next, validateCurrentStep } = useStepNavigation(stepCount)
+
     const onOk = () => {
       state.confirmLoading = true
-      curdFormRef.value[state.step]
-        ?.validate()
-        .then(async () => {
+
+      const getValidatePromise = (): Promise<boolean> => {
+        if (isFormMode.value) {
+          return (
+            curdFormRef.value
+              ?.validate()
+              .then(() => true)
+              .catch(() => false) ?? Promise.resolve(true)
+          )
+        }
+
+        return new Promise<boolean>((resolve) => {
+          validateCurrentStep((valid) => resolve(valid))
+        })
+      }
+
+      getValidatePromise()
+        .then(async (valid) => {
+          if (!valid) {
+            state.confirmLoading = false
+            return
+          }
           const pass = await (props.handleOk && props.handleOk(form.value, state)).finally(() => (state.confirmLoading = false))
           if (typeof pass == "undefined" || pass) {
             state.visible = false
             onCancel()
           }
         })
-        .catch((e: Error) => {
-          console.error(e)
+        .catch(() => {
           state.confirmLoading = false
         })
     }
@@ -141,16 +176,12 @@ export default defineComponent({
       }, 300)
     }
     const loadOptions = (prop: string, config?: unknown) => {
-      if (!stepSchemaList.value.length) return
-      for (const i in stepSchemaList.value) {
-        const group = stepSchemaList.value[i]
-        const formItem = group.formSchema.formItem
-        for (const j in formItem) {
-          const item = formItem[j]
-          if (item.prop == prop) {
-            curdFormRef.value[i]?.loadOptions(prop, config)
-          }
-        }
+      if (isFormMode.value) {
+        curdFormRef.value?.loadOptions(prop, config)
+      } else if (isGroupMode.value) {
+        Object.values(groupFormRef.value).forEach((form) => {
+          form?.loadOptions(prop, config)
+        })
       }
     }
     const extendContexts = {
@@ -186,11 +217,31 @@ export default defineComponent({
     const formDialogContext = reactive({
       form,
       state,
+      stepList,
+      activeStep,
       loadOptions,
       prev,
       next,
+      goTo: (step: number) => {
+        if (step >= 0 && step < stepCount.value) {
+          // 验证当前步骤
+          validateCurrentStep((valid) => {
+            if (valid) {
+              activeStep.value = step
+            }
+          })
+        }
+      },
       close: onBeforeClose,
       handleOk: onOk,
+      validateCurrentStep,
+      canPrev,
+      canNext,
+      isLastStep,
+      isGroupMode,
+      isFormMode,
+      confirmBtnTextLabel,
+      cancelBtnTextLabel,
     })
     provide("formDialogContext", formDialogContext)
     return {
@@ -199,7 +250,7 @@ export default defineComponent({
       onCancel,
       onBeforeClose,
       curdFormRef,
-      stepSchemaList,
+      stepList,
       form,
       prev,
       next,
@@ -209,6 +260,15 @@ export default defineComponent({
       cancelBtnTextLabel,
       componentName,
       containerProps,
+      isGroupMode,
+      isFormMode,
+      hasMultipleSteps,
+      activeStep,
+      groupFormRef,
+      canPrev,
+      canNext,
+      isLastStep,
+      validateCurrentStep,
     }
   },
 })

package/components/FormDialog/src/hooks/index.ts

@@ -0,0 +1,2 @@
+export { useStepList, type StepItem } from "./useStepList"
+export { useStepNavigation } from "./useStepNavigation"

package/components/FormDialog/src/hooks/useStepList.ts

@@ -0,0 +1,49 @@
+import { computed, type ComputedRef } from "vue"
+import type { CurdGroupFormSchema } from "../../../CurdGroupForm/types"
+
+export interface StepItem {
+  name: string
+  stepIndex?: number
+  schema: {
+    items: CurdGroupFormSchema["items"]
+  }
+}
+
+export function useStepList(groupSchema: ComputedRef<CurdGroupFormSchema | null>) {
+  const stepList = computed<StepItem[]>(() => {
+    if (!groupSchema.value?.items) return []
+
+    const groups = new Map<string, StepItem>()
+
+    groupSchema.value.items.forEach((item) => {
+      const stepName = item.step || "其他"
+
+      if (!groups.has(stepName)) {
+        groups.set(stepName, {
+          name: stepName,
+          stepIndex: item.stepIndex,
+          schema: { items: [] }
+        })
+      }
+
+      groups.get(stepName)!.schema.items.push(item)
+    })
+
+    // 按 stepIndex 排序（undefined 排最后）
+    return Array.from(groups.values()).sort((a, b) => {
+      const indexA = a.stepIndex ?? Infinity
+      const indexB = b.stepIndex ?? Infinity
+      return indexA - indexB
+    })
+  })
+
+  const stepCount = computed(() => stepList.value.length)
+
+  const hasMultipleSteps = computed(() => stepList.value.length > 1)
+
+  return {
+    stepList,
+    stepCount,
+    hasMultipleSteps
+  }
+}

package/components/FormDialog/src/hooks/useStepNavigation.ts

@@ -0,0 +1,74 @@
+import { computed, ref, type Ref } from "vue"
+import type { CurdGroupForm } from "../../../CurdGroupForm"
+
+interface ValidateFunction {
+  validate: (callback: (valid: boolean) => void) => void
+}
+
+export function useStepNavigation(stepCount: Ref<number>, onStepChange?: (step: number) => void) {
+  const activeStep = ref(0)
+  const groupFormRef = ref<Record<number, InstanceType<typeof CurdGroupForm>>>({})
+
+  const canPrev = computed(() => activeStep.value > 0)
+  const canNext = computed(() => activeStep.value < stepCount.value - 1)
+  const isLastStep = computed(() => activeStep.value >= stepCount.value - 1)
+
+  const setStep = (newStep: number) => {
+    if (newStep >= 0 && newStep < stepCount.value) {
+      activeStep.value = newStep
+      onStepChange?.(newStep)
+    }
+  }
+
+  const prev = () => {
+    if (canPrev.value) {
+      setStep(activeStep.value - 1)
+    }
+  }
+
+  const next = (onValidateFail?: () => void) => {
+    if (!canNext.value) return false
+
+    const currentForm = groupFormRef.value[activeStep.value] as unknown as ValidateFunction | undefined
+    if (currentForm?.validate) {
+      currentForm.validate((valid: boolean) => {
+        if (valid) {
+          setStep(activeStep.value + 1)
+        } else if (onValidateFail) {
+          onValidateFail()
+        }
+      })
+    } else {
+      setStep(activeStep.value + 1)
+    }
+    return true
+  }
+
+  const validateCurrentStep = (callback: (valid: boolean) => void) => {
+    const currentForm = groupFormRef.value[activeStep.value] as unknown as ValidateFunction | undefined
+    if (currentForm?.validate) {
+      currentForm.validate(callback)
+    } else {
+      callback(true)
+    }
+  }
+
+  const validateCurrentStepAsync = (): Promise<boolean> => {
+    return new Promise((resolve) => {
+      validateCurrentStep((valid) => resolve(valid))
+    })
+  }
+
+  return {
+    activeStep,
+    groupFormRef,
+    canPrev,
+    canNext,
+    isLastStep,
+    setStep,
+    prev,
+    next,
+    validateCurrentStep,
+    validateCurrentStepAsync,
+  }
+}

package/components/FormDialog/src/types.ts

@@ -1,12 +1,14 @@
+import type { CurdGroupFormSchema } from "../../CurdGroupForm/types"
 import type { DialogProps, StepProps } from "element-plus"
 import type { Fields, FormContext, FormSchema } from "../../CurdForm"
+import type { StepItem } from "./hooks/useStepList"
 
 export interface FormDialogOptions extends Partial<DialogProps> {
   title?: string
   width?: string | number
   fields?: Fields
-  stepSchema?: { name: string; description?: string; formSchema: FormSchema }[]
   formSchema?: FormSchema
+  groupSchema?: CurdGroupFormSchema
   handleOk?: (modelRef: Fields) => Promise<void>
   handleClose?: (e: "close" | "cancel") => void
   setForm?: (form: Fields) => void
@@ -14,4 +16,30 @@ export interface FormDialogOptions extends Partial<DialogProps> {
   extendContext?: Partial<FormContext>
   confirmBtnText?: string
   cancelBtnText?: string
+  stepComponent?: object
+  footerComponent?: object
+}
+
+export interface FormDialogContext {
+  form: Fields
+  state: {
+    visible: boolean
+    confirmLoading: boolean
+  }
+  stepList: StepItem[]
+  activeStep: { value: number }
+  loadOptions: (prop: string, config?: unknown) => void
+  prev: () => void
+  next: () => void
+  goTo: (step: number) => void
+  close: () => void
+  handleOk: () => void
+  validateCurrentStep: (callback: (valid: boolean) => void) => void
+  canPrev: { value: boolean }
+  canNext: { value: boolean }
+  isLastStep: { value: boolean }
+  isGroupMode: { value: boolean }
+  isFormMode: { value: boolean }
+  confirmBtnTextLabel: { value: string }
+  cancelBtnTextLabel: { value: string }
 }

package/index.ts

@@ -2,21 +2,24 @@ import type { Plugin } from "vue"
 import ConstantStatus from "./components/ConstantStatus"
 import CurdForm from "./components/CurdForm"
 import CurdFormItem from "./components/CurdForm/src/CurdFormItem.vue"
+import { CurdGroupForm } from "./components/CurdGroupForm"
 import CurdTable from "./components/CurdTable"
 import DetailInfo from "./components/DetailInfo"
 import FormDialog from "./components/FormDialog"
 import TableFilter from "./components/TableFilter"
 import { makeInstaller } from "./utils/vue/make-installer"
 
-const Components = [ConstantStatus, CurdForm, TableFilter, DetailInfo, CurdFormItem, CurdTable, FormDialog] as Plugin[]
+const Components = [ConstantStatus, CurdForm, TableFilter, DetailInfo, CurdFormItem, CurdTable, FormDialog, CurdGroupForm] as Plugin[]
 export * from "./components/ConstantStatus/src/types"
 export * from "./components/CurdForm"
+export * from "./components/CurdGroupForm/types"
 export * from "./components/CurdTable/src/types"
 export * from "./components/DetailInfo/src/types"
 export * from "./components/FormDialog/src/types"
 export * from "./components/TableFilter/types"
 export * from "./utils/hooks/useGlobalConfig"
 export * from "./utils/hooks/useLocal"
-export { ConstantStatus, CurdForm, CurdFormItem, DetailInfo, TableFilter, CurdTable, FormDialog}
+
+export { ConstantStatus, CurdForm, CurdFormItem, CurdGroupForm, CurdTable, DetailInfo, FormDialog, TableFilter }
 
 export default makeInstaller([...Components])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easybill-ui",
-  "version": "1.2.26",
+  "version": "1.3.1",
   "description": "A component library for easybill",
   "author": "tuchongyang <779311998@qq.com>",
   "private": false,