easybill-ui 1.4.1 → 1.4.2

package/components/CurdForm/src/CurdForm.vue

@@ -1,500 +0,0 @@
-<template>
-  <el-form ref="schemaFormRef" :model="formModel" :rules="rules" v-bind="{ ...$attrs, ...getFormProps }" class="curd-form" :style="getFormStyle()" @submit.prevent>
-    <template v-for="formItem in schemaItems" :key="formItem.prop">
-      <!-- choose 类型特殊处理，不使用 el-form-item 包裹，避免嵌套问题 -->
-      <template v-if="formItem.type === 'choose'">
-        <div v-if="!$slots[formItem.prop + 'Item']" class="el-form-item choose-group-wrapper" :class="[getFormItemStyle(formItem), getChooseFormItemClass(formItem)]" :style="getChooseFormItemStyle(formItem)">
-          <!-- label 区域 -->
-          <label v-if="formItem.label" class="el-form-item__label" :style="{ width: getLabelWidth(formItem) }">
-            {{ formItem.label }}
-          </label>
-
-          <!-- content 区域 -->
-          <div class="el-form-item__content" :style="{ marginLeft: getLabelPosition(formItem) !== 'top' ? '' : '' }">
-            <slot :name="formItem.prop" :form-item="formItem" :form-model="formModel"></slot>
-            <FormItem v-if="!(formItem.prop && $slots[formItem.prop])" :form-item="formItem" :form-model="formModel" @change="onChange">
-              <template #prefix>
-                <slot :name="formItem.prop + 'Prefix'" :form-item="formItem" :form-model="formModel"></slot>
-              </template>
-              <template #suffix>
-                <slot :name="formItem.prop + 'Suffix'" :form-item="formItem" :form-model="formModel"></slot>
-              </template>
-            </FormItem>
-            <slot :name="formItem.prop + 'Bottom'" :form-item="formItem" :form-model="formModel"></slot>
-          </div>
-        </div>
-        <slot :name="formItem.prop + 'Item'" :form-item="formItem" :form-model="formModel"></slot>
-      </template>
-
-      <!-- 其他类型使用 el-form-item 包裹 -->
-      <template v-else>
-        <el-form-item v-if="!$slots[formItem.prop + 'Item']" :required="hasRequiredRule(formItem.prop)" :label="formItem.label" :prop="formItem.prop" :label-width="formItem.labelWidth" :class="getFormItemStyle(formItem)" v-bind="getFormItemProps(formItem)">
-          <template v-for="(item, key) in getFormItemProps(formItem)?.slots || {}" :key="key" #[key]="row">
-            <component :is="item" v-bind="row" />
-          </template>
-          <component :is="formItem.slots?.top" :formItem="formItem" :formModel="formModel" />
-          <slot :name="formItem.prop" :form-item="formItem" :form-model="formModel"></slot>
-          <FormItem v-if="!(formItem.prop && $slots[formItem.prop])" :form-item="formItem" :form-model="formModel" @change="onChange">
-            <template #prefix>
-              <slot :name="formItem.prop + 'Prefix'" :formItem="formItem" :formModel="formModel"></slot>
-            </template>
-            <template #suffix>
-              <slot :name="formItem.prop + 'Suffix'" :formItem="formItem" :formModel="formModel"></slot>
-            </template>
-          </FormItem>
-          <slot :name="formItem.prop + 'Bottom'" :formItem="formItem" :formModel="formModel"></slot>
-          <component :is="formItem.slots?.bottom" :formItem="formItem" :formModel="formModel" />
-        </el-form-item>
-        <slot :name="formItem.prop + 'Item'" :formItem="formItem" :formModel="formModel"></slot>
-      </template>
-    </template>
-    <template v-if="$slots['operate-button']">
-      <el-form-item style="max-width: 100%">
-        <slot name="operate-button"></slot>
-      </el-form-item>
-    </template>
-  </el-form>
-</template>
-
-<script lang="ts" setup>
-import { ElForm, type FormItemRule, type FormRules } from "element-plus"
-import { computed, getCurrentInstance, onMounted, provide, reactive, ref, triggerRef, watch, type PropType } from "vue"
-import FormItem from "./FormItem.vue"
-import type { CurdFormOptionItem, Fields, FormContext, FormItemProvider, FormItemSearchResult, FormItem as FormItemType, FormSchema } from "./types"
-import { deepClone } from "./utils/common"
-
-const props = defineProps({
-  formSchema: {
-    required: true,
-    type: Object as PropType<FormSchema>,
-    default: () => ({}),
-  },
-  fields: {
-    type: Object as PropType<Fields>,
-    default: () => ({}),
-  },
-  modelValue: {
-    type: Object as PropType<Fields>,
-    default: undefined,
-  },
-  extendContext: {
-    type: Object as PropType<Partial<FormContext>>,
-    default: undefined,
-  },
-})
-
-const emit = defineEmits(["update:modelValue", "change"])
-
-const schemaFormRef = ref<InstanceType<typeof ElForm> | undefined>()
-const sFormSchema = ref(props.formSchema)
-let formModel = reactive<Fields>(props.modelValue || {})
-const curdFormContext = reactive<FormContext>({} as FormContext)
-const instance = getCurrentInstance()
-const formItemProviders = new Map<string | symbol, FormItemProvider["getItems"]>()
-
-const normalizeFormItems = (items?: FormItemType[] | null) => {
-  return Array.isArray(items) ? items : []
-}
-
-const walkBuiltInFormItems = (items: FormItemType[], callback: (item: FormItemType, parent?: FormItemType, path?: string) => void | boolean, parent?: FormItemType, parentPath = "") => {
-  for (const item of normalizeFormItems(items)) {
-    const currentPath = parentPath ? `${parentPath}.${item.prop}` : item.prop
-    const shouldStop = callback(item, parent, currentPath)
-    if (shouldStop) return true
-
-    if (item.type === "choose" && item.options) {
-      for (const option of item.options) {
-        if (option.items?.length && walkBuiltInFormItems(option.items, callback, item, `${currentPath}.${option.value}`)) {
-          return true
-        }
-      }
-    }
-  }
-  return false
-}
-
-const getRegisteredFormItems = (providerId?: string | symbol) => {
-  const items: FormItemType[] = []
-  formItemProviders.forEach((getItems, id) => {
-    if (typeof providerId !== "undefined" && id !== providerId) return
-    items.push(...normalizeFormItems(getItems()))
-  })
-  return items
-}
-
-const collectDefaultValues = (items: FormItemType[]) => {
-  const values: Fields = {}
-  walkBuiltInFormItems(items, (item) => {
-    item.eventObject ??= {}
-    if (typeof item.value !== "undefined" && item.prop && (typeof formModel[item.prop] == "undefined" || formModel[item.prop] === "" || formModel[item.prop] === null)) {
-      values[item.prop] = item.value
-    }
-  })
-  return values
-}
-
-const loadFormItemOptions = async (formItem: FormItemType, option?: unknown) => {
-  if (formItem.asyncOptions && !instance?.isUnmounted) {
-    formItem.loading = true
-    triggerRef(schemaItems)
-    formItem.options =
-      (await formItem
-        .asyncOptions(formModel, formItem, curdFormContext, option)
-        .catch((err) => console.error("loadOptionError", err))
-        .finally(() => (formItem.loading = false))) || []
-    triggerRef(schemaItems)
-    if (!instance?.isUnmounted && formItem.eventObject?.optionLoaded) formItem.eventObject.optionLoaded(formModel, formItem, curdFormContext, option)
-  }
-  return formItem.options || []
-}
-
-const loadAutoloadFormItems = (items: FormItemType[]) => {
-  walkBuiltInFormItems(items, (item) => {
-    if (item.asyncOptions && (item.autoload || typeof item.autoload == "undefined") && item.asyncOptions instanceof Function) {
-      void loadFormItemOptions(item)
-    }
-  })
-}
-
-const findFormItemInItems = (items: FormItemType[], prop: string, providerId?: string | symbol): FormItemSearchResult | undefined => {
-  let result: FormItemSearchResult | undefined
-  walkBuiltInFormItems(items, (item, parent, path) => {
-    if (item.prop == prop) {
-      result = { item, parent, path: path || prop, providerId }
-      return true
-    }
-    return false
-  })
-  return result
-}
-
-const refreshFormItems = (providerId?: string | symbol) => {
-  const registeredItems = getRegisteredFormItems(providerId)
-  Object.assign(formModel, collectDefaultValues(registeredItems))
-  loadAutoloadFormItems(registeredItems)
-  triggerRef(schemaItems)
-  triggerRef(rules)
-}
-
-const registerFormItems = (provider: FormItemProvider) => {
-  formItemProviders.set(provider.id, provider.getItems)
-  refreshFormItems(provider.id)
-  return () => {
-    formItemProviders.delete(provider.id)
-    triggerRef(schemaItems)
-    triggerRef(rules)
-  }
-}
-
-watch(
-  () => props.modelValue,
-  (val) => {
-    const value = deepClone(val)
-    for (let i in formModel) {
-      delete formModel[i]
-    }
-    Object.assign(formModel, value)
-  },
-)
-watch(
-  () => formModel,
-  (val) => {
-    emit("update:modelValue", val)
-  },
-  { deep: true },
-)
-// 先从schema中读取默认值
-const schemaValues = collectDefaultValues(sFormSchema.value.formItem)
-
-Object.assign(formModel, schemaValues)
-// 如果有默认值，则覆盖
-if (props.fields) Object.assign(formModel, props.fields)
-// Object.assign(formModel, props.modelValue)
-// props.modelValue && Object.assign(formModel, props.modelValue)
-
-const schemaItems = computed(() => {
-  return sFormSchema.value.formItem.filter((item) => {
-    if (!item.hidden) {
-      return true
-    }
-    if (item.hidden instanceof Function) {
-      return !item.hidden(formModel)
-    }
-    return !item.hidden
-  })
-})
-// 异步设置默认数据
-loadAutoloadFormItems(sFormSchema.value.formItem)
-
-// 生成表单验证规则
-const rules = computed(() => {
-  // eslint-disable-next-line vue/no-async-in-computed-properties
-  Promise.resolve().then(() => {
-    triggerRef(rules)
-  })
-  let baseRules: FormRules = {}
-  if (typeof sFormSchema.value.rules == "function") {
-    baseRules = sFormSchema.value.rules(formModel, curdFormContext)
-  } else if (typeof sFormSchema.value.getRules == "function") {
-    baseRules = sFormSchema.value.getRules(formModel, curdFormContext)
-  } else {
-    baseRules = sFormSchema.value.rules || {}
-  }
-
-  // 合并 choose 类型 items 和自定义组件注册项的验证规则
-  const mergedRules: FormRules = { ...baseRules }
-  sFormSchema.value.formItem.forEach((formItem) => {
-    if (formItem.type === "choose" && formItem.options) {
-      formItem.options.forEach((option) => {
-        if (option.items) {
-          option.items.forEach((subItem) => {
-            if (subItem.prop && subItem.rules) {
-              mergedRules[subItem.prop] = subItem.rules
-            }
-          })
-        }
-      })
-    }
-  })
-  walkBuiltInFormItems(getRegisteredFormItems(), (formItem) => {
-    if (formItem.prop && formItem.rules) {
-      mergedRules[formItem.prop] = formItem.rules
-    }
-  })
-
-  return mergedRules
-})
-const normalizeFormItemRules = (rule: FormItemRule | FormItemRule[] | undefined) => {
-  if (!rule) return []
-  return Array.isArray(rule) ? rule : [rule]
-}
-const hasRequiredRule = (prop: string) => {
-  return normalizeFormItemRules(rules.value[prop] as FormItemRule | FormItemRule[] | undefined).some((rule) => Object.prototype.hasOwnProperty.call(rule, "required") && rule.required)
-}
-
-/**
- * 递归查找表单项
- * @param prop 表单项的 prop
- * @returns 找到的表单项对象，包含 parent 信息
- */
-const findFormItem = (prop: string): FormItemSearchResult | undefined => {
-  const schemaResult = findFormItemInItems(sFormSchema.value.formItem, prop)
-  if (schemaResult) return schemaResult
-
-  for (const [providerId, getItems] of formItemProviders) {
-    const providerResult = findFormItemInItems(normalizeFormItems(getItems()), prop, providerId)
-    if (providerResult) return providerResult
-  }
-
-  return undefined
-}
-const hasFormItem = (prop: string) => Boolean(findFormItem(prop))
-
-// 供外部使用
-const validate = (callback: (valid: boolean) => void) => {
-  return schemaFormRef.value?.validate(callback)
-}
-// 调用某个表单项的异步数据接口
-const loadOptions = async (prop: string, option?: unknown) => {
-  const result = findFormItem(prop)
-  if (!result) {
-    console.warn(`[CurdForm] loadOptions: 未找到 prop 为 "${prop}" 的表单项`)
-    return []
-  }
-
-  const cur = result.item
-  return loadFormItemOptions(cur, option)
-}
-const contextLoadOptions = (prop: string, option?: unknown) => {
-  if (hasFormItem(prop)) {
-    return loadOptions(prop, option)
-  }
-
-  return props.extendContext?.loadOptions?.(prop, option)
-}
-// 给某个item赋值options
-const setOptions = async (prop: string, options: CurdFormOptionItem[], option?: unknown) => {
-  const result = findFormItem(prop)
-  if (result) {
-    result.item.options = options
-    triggerRef(schemaItems)
-    if (!instance?.isUnmounted && result.item.eventObject?.optionLoaded) result.item.eventObject.optionLoaded(formModel, result.item, curdFormContext, option)
-  } else {
-    console.warn(`[CurdForm] setOptions: 未找到 prop 为 "${prop}" 的表单项`)
-  }
-  // return cur
-}
-const onChange = (formModel: Fields, formItem: FormItemType) => {
-  emit("change", formModel, formItem)
-}
-const getFormItemStyle = (formItem: FormItemType) => {
-  if (!formItem.span) return "el-form-item-full"
-  return "el-form-item-" + formItem.span
-}
-const getFormItemProps = (formItem: FormItemType) => {
-  if (formItem.formItemProps) {
-    if (formItem.formItemProps instanceof Function) {
-      return formItem.formItemProps(formModel, formItem)
-    }
-    return { ...formItem.formItemProps }
-  }
-  return {}
-}
-
-// 获取表单项的 labelWidth
-const getLabelWidth = (formItem: FormItemType) => {
-  const itemLabelWidth = formItem.labelWidth
-  if (itemLabelWidth !== undefined) {
-    return typeof itemLabelWidth === "number" ? itemLabelWidth + "px" : itemLabelWidth
-  }
-  const formLabelWidth = props.formSchema.labelWidth
-  if (formLabelWidth !== undefined) {
-    return typeof formLabelWidth === "number" ? formLabelWidth + "px" : formLabelWidth
-  }
-  return undefined
-}
-
-// 获取表单项的 labelPosition
-const getLabelPosition = (formItem: FormItemType) => {
-  return formItem.labelPosition || props.formSchema.labelPosition || ""
-}
-
-// 获取 choose 类型的额外样式类
-const getChooseFormItemClass = (_formItem: FormItemType) => {
-  const classes: string[] = []
-  const labelPosition = getLabelPosition(_formItem)
-  if (labelPosition) {
-    classes.push("el-form-item--label-" + labelPosition)
-  }
-  return classes.join(" ")
-}
-
-// 获取 choose 类型的样式
-const getChooseFormItemStyle = (formItem: FormItemType) => {
-  const style: Record<string, string> = {}
-  const labelPosition = getLabelPosition(formItem)
-  if (labelPosition === "top") {
-    // top 模式下不需要额外样式
-  } else {
-    const labelWidth = getLabelWidth(formItem)
-    if (labelWidth) {
-      // 用于让 content 区域正确对齐
-    }
-  }
-  return style
-}
-const getFormStyle = () => {
-  const gutter = props.formSchema.gutter
-  if (gutter) {
-    const guPx = +parseFloat(String(gutter))
-    return { "--curd-form-gutter": guPx + "px" }
-  }
-  return {}
-}
-const getFormProps = computed(() => {
-  const args: Record<string, unknown> = {}
-  const sm = props.formSchema
-  for (const i in sm) {
-    if (!["formItem", "rules", "getRules"].includes(i)) {
-      args[i] = sm[i as keyof FormSchema]
-    }
-  }
-  return { ...args }
-})
-
-curdFormContext.loadOptions = contextLoadOptions
-curdFormContext.setOptions = setOptions
-curdFormContext.change = onChange
-curdFormContext.formModel = formModel
-curdFormContext.formSchema = props.formSchema
-curdFormContext.findFormItem = findFormItem
-curdFormContext.hasFormItem = hasFormItem
-curdFormContext.registerFormItems = registerFormItems
-curdFormContext.refreshFormItems = refreshFormItems
-
-if (props.extendContext) {
-  const extendContext = { ...props.extendContext }
-  delete extendContext.loadOptions
-  Object.assign(curdFormContext, extendContext)
-}
-
-provide("curdFormContext", curdFormContext)
-onMounted(() => {
-  curdFormContext.formRef = schemaFormRef.value
-})
-
-defineExpose({
-  formModel,
-  schemaFormRef,
-  rules,
-  schemaItems,
-  sFormSchema,
-  getFormStyle,
-  getFormProps,
-  getFormItemStyle,
-  getFormItemProps,
-  validate,
-  findFormItem,
-  hasFormItem,
-  registerFormItems,
-  refreshFormItems,
-  loadOptions,
-  setOptions,
-  onChange,
-})
-</script>
-
-<style scoped lang="scss">
-// choose 类型容器样式，模拟 el-form-item 布局
-/*
-.choose-group-wrapper {
-  display: flex;
-  align-items: flex-start;
-
-  :deep(.el-form-item__label) {
-    display: inline-flex;
-    justify-content: flex-end;
-    align-items: flex-start;
-    flex-shrink: 0;
-    font-size: var(--el-font-size-base);
-    color: var(--el-text-color-regular);
-    height: 32px;
-    line-height: 32px;
-    padding: 0 12px 0 0;
-    box-sizing: border-box;
-  }
-
-  :deep(.el-form-item__asterisk) {
-    color: var(--el-color-danger);
-    font-size: var(--el-font-size-base);
-    margin-left: 4px;
-  }
-
-  :deep(.el-form-item__content) {
-    display: flex;
-    flex-wrap: wrap;
-    align-items: center;
-    flex: 1;
-    position: relative;
-    font-size: var(--el-font-size-base);
-    min-width: 0;
-  }
-
-  :deep(.top-label) {
-    justify-content: flex-start;
-    padding: 0 0 8px 0;
-    height: auto;
-    line-height: 1.5;
-  }
-
-  // label-top 模式
-  &.el-form-item--label-top {
-    flex-direction: column;
-
-    :deep(.el-form-item__content) {
-      margin-left: 0 !important;
-    }
-  }
-}
-*/
-</style>

package/components/CurdForm/src/CurdFormItem.vue

@@ -1,70 +0,0 @@
-<template>
-  <FormItemVue :form-model="model" :form-item="props.formItem" @change="onChange"></FormItemVue>
-</template>
-<script lang="ts">
-export default {
-  name: "CurdFormItem",
-}
-</script>
-<script lang="ts" setup>
-import { getCurrentInstance, type PropType, reactive, ref, watch } from "vue"
-import FormItemVue from "./FormItem.vue"
-import type { Fields, FormContext, FormItem } from "./types"
-const props = defineProps({
-  formItem: {
-    required: true,
-    type: Object as PropType<FormItem>,
-  },
-  formModel: {
-    type: Object as PropType<Fields>,
-    default: () => ({}),
-  },
-  modelValue: {
-    type: [String, Array, Object],
-    default: "",
-  },
-})
-const emit = defineEmits(["update:modelValue"])
-const model = ref(props.formModel || {})
-if (props.modelValue) {
-  model.value[props.formItem.prop] = props.modelValue
-}
-const onChange = () => {
-  emit("update:modelValue", model.value[props.formItem.prop])
-}
-watch(
-  () => props.modelValue,
-  (val) => {
-    model.value[props.formItem.prop] = val
-  },
-)
-const instance = getCurrentInstance()
-const curdFormContext = reactive<FormContext>({} as FormContext)
-// 调用某个表单项的异步数据接口
-const loadOptions = async (_prop: string) => {
-  const cur = props.formItem
-  if (cur && cur.asyncOptions && !instance?.isUnmounted) {
-    cur.loading = true
-    cur.options =
-      (await cur
-        .asyncOptions(model.value, cur, curdFormContext)
-        .catch((err) => console.error("loadOptionError", err))
-        .finally(() => (cur.loading = false))) || []
-    if (!instance?.isUnmounted && cur.eventObject?.optionLoaded) cur.eventObject.optionLoaded(model.value, cur, curdFormContext)
-  }
-  return cur?.options || []
-}
-const init = () => {
-  if (props.formItem.asyncOptions) {
-    loadOptions(props.formItem.prop)
-  }
-}
-curdFormContext.loadOptions = loadOptions
-init()
-watch(
-  () => props.formItem,
-  () => {
-    init()
-  },
-)
-</script>

package/components/CurdForm/src/FormItem.vue

@@ -1,105 +0,0 @@
-<template>
-  <div class="form-item">
-    <div v-if="props.formItem.prefix && isString(props.formItem.prefix)" class="form-item-prefix" v-html="props.formItem.prefix"></div>
-    <component :is="item" v-for="(item, i) in prefixList" :key="i" v-model="modelRef[props.formItem.prop || '']" :form-item="props.formItem" :form-model="modelRef" :props="formItemProps" :event-object="eventObject" />
-    <slot name="prefix"></slot>
-    <component :is="comp" v-if="comp" v-model="modelRef[props.formItem.prop || '']" :form-item="props.formItem" :form-model="modelRef" :props="formItemProps" :event-object="eventObject">
-      <template v-for="(item, key) in formItemProps.slots" :key="key" #[key]="slotScope">
-        <component :is="item" v-model="modelRef[props.formItem.prop || '']" v-bind="slotScope" :form-item="props.formItem" :form-model="modelRef" :props="formItemProps" :event-object="eventObject" />
-      </template>
-    </component>
-    <component :is="props.formItem.type" v-else v-model="modelRef[props.formItem.prop || '']" v-bind="formItemProps" v-on="eventObject">
-      <template v-for="(item, key) in formItemProps.slots" :key="key" #[key]="slotScope">
-        <component :is="item" v-model="modelRef[props.formItem.prop || '']" v-bind="slotScope" :form-item="props.formItem" :form-model="modelRef" :props="formItemProps" :event-object="eventObject" />
-      </template>
-    </component>
-
-    <FormTooltip v-if="props.formItem.tooltip" :tooltip="props.formItem.tooltip" :form-item="props.formItem" :form-model="props.formModel" />
-    <slot name="suffix"></slot>
-    <div v-if="props.formItem.suffix && isString(props.formItem.suffix)" class="form-item-suffix" v-html="props.formItem.suffix"></div>
-    <component :is="item" v-for="(item, i) in suffixList" :key="i" v-model="modelRef[props.formItem.prop || '']" :form-item="props.formItem" :form-model="modelRef" :props="formItemProps" :event-object="eventObject" />
-  </div>
-</template>
-<script lang="ts" setup>
-import { computed, type PropType, ref, type Ref } from "vue"
-import { getComponent } from "./components"
-import FormTooltip from "./FormTooltip.vue"
-import { useForm } from "./hooks"
-import type { Fields, FormItem } from "./types"
-const props = defineProps({
-  // 动态验证表单
-  formItem: {
-    required: true,
-    type: Object as PropType<FormItem>,
-  },
-  formModel: {
-    type: Object as PropType<Fields>,
-    default: () => ({}),
-  },
-})
-const emit = defineEmits(["change"])
-const { formContext } = useForm()
-const modelRef: Ref<Fields> = ref(props.formModel || {})
-// 重新组装props
-const formItemProps = computed(() => {
-  if (!props.formItem.props) {
-    return {}
-  }
-  if (props.formItem.props instanceof Function) {
-    return props.formItem.props(props.formModel, props.formItem)
-  }
-  return props.formItem.props
-})
-const comp = computed(() => (formContext.components && formContext.components[props.formItem.type || "input"]) || getComponent(props.formItem.type))
-// 重新组装eventObject
-const eventObject = ref(
-  (() => {
-    const result = { ...props.formItem.eventObject }
-    // 如果没有传eventObject，就初始一个change事件
-    if (!props.formItem.eventObject || Object.keys(props.formItem.eventObject).length <= 0) {
-      return {
-        change: () => {
-          emit("change", props.formModel, props.formItem, formContext)
-        },
-      }
-    }
-    const changeFun = props.formItem.eventObject.change
-    result.change = (...args: unknown[]) => {
-      if (changeFun) {
-        const flag = changeFun && changeFun.apply(null, [props.formModel, props.formItem, formContext, ...args])
-        if (flag) {
-          emit("change", props.formModel, props.formItem, formContext, ...args)
-        }
-      } else {
-        emit("change", props.formModel, props.formItem, formContext, ...args)
-      }
-    }
-    for (let i in result) {
-      if (i !== "change") {
-        const fun = result[i]
-        result[i] = (...args: unknown[]) => {
-          if (fun) fun(props.formModel, props.formItem, formContext, ...args)
-        }
-      }
-    }
-    return result
-  })(),
-)
-const isString = (val: unknown) => {
-  return typeof val === "string"
-}
-const prefixList = computed(() => {
-  if (!props.formItem.prefix || isString(props.formItem.prefix)) return []
-  if (Array.isArray(props.formItem.prefix)) {
-    return props.formItem.prefix
-  }
-  return [props.formItem.prefix]
-})
-const suffixList = computed(() => {
-  if (!props.formItem.suffix || isString(props.formItem.suffix)) return []
-  if (Array.isArray(props.formItem.suffix)) {
-    return props.formItem.suffix
-  }
-  return [props.formItem.suffix]
-})
-</script>