tanxin-ui 0.2.0

package/lib/form/src/form-item.d.ts

@@ -0,0 +1,86 @@
+import type { PropType } from 'vue';
+import type { ValidateRuleItem } from './context';
+declare const _default: import("vue").DefineComponent<{
+    label: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    labelWidth: import("vue-types").VueTypeDef<string | number>;
+    labelFor: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    contentAlign: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    error: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    showTip: import("vue-types").VueTypeValidableDef<boolean>;
+    marginBottom: import("vue-types").VueTypeDef<string | number>;
+    required: import("vue-types").VueTypeValidableDef<boolean>;
+    prop: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    ruleName: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    labelColon: import("vue-types").VueTypeValidableDef<boolean>;
+    rules: PropType<ValidateRuleItem | ValidateRuleItem[]>;
+    validateStatus: import("vue-types").VueTypeDef<string>;
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    label: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    labelWidth: import("vue-types").VueTypeDef<string | number>;
+    labelFor: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    contentAlign: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    error: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    showTip: import("vue-types").VueTypeValidableDef<boolean>;
+    marginBottom: import("vue-types").VueTypeDef<string | number>;
+    required: import("vue-types").VueTypeValidableDef<boolean>;
+    prop: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    ruleName: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    labelColon: import("vue-types").VueTypeValidableDef<boolean>;
+    rules: PropType<ValidateRuleItem | ValidateRuleItem[]>;
+    validateStatus: import("vue-types").VueTypeDef<string>;
+}>>, {
+    label: string;
+    error: string;
+    disabled: boolean;
+    prop: string;
+    labelFor: string;
+    contentAlign: string;
+    ruleName: string;
+}>;
+export default _default;

package/lib/form/src/form-item.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var vue = require("vue");
+var type = require("../../utils/type.js");
+var useConfig = require("../../utils/hooks/useConfig.js");
+var context = require("./context.js");
+var common = require("../../utils/common.js");
+var Schema = require("async-validator");
+var useGetSlot = require("../../utils/hooks/useGetSlot.js");
+var element = require("../../utils/element.js");
+var cn = require("../../utils/validator-messages/cn.js");
+var cloneDeep = require("lodash-es/cloneDeep");
+function _interopDefaultLegacy(e) {
+  return e && typeof e === "object" && "default" in e ? e : { "default": e };
+}
+var Schema__default = /* @__PURE__ */ _interopDefaultLegacy(Schema);
+var cloneDeep__default = /* @__PURE__ */ _interopDefaultLegacy(cloneDeep);
+const formItemProps = {
+  label: type.PropTypes.string.def(""),
+  labelWidth: type.PropTypes.oneOfType([type.PropTypes.number, type.PropTypes.string]),
+  labelFor: type.PropTypes.string.def(""),
+  contentAlign: type.PropTypes.oneOf(["left", "right", "center"]).def("left"),
+  error: type.PropTypes.string.def(""),
+  showTip: type.PropTypes.emptyBool,
+  marginBottom: type.PropTypes.oneOfType([type.PropTypes.number, type.PropTypes.string]),
+  required: type.PropTypes.emptyBool,
+  prop: type.PropTypes.string,
+  disabled: type.PropTypes.bool.def(false),
+  ruleName: type.PropTypes.string,
+  labelColon: type.PropTypes.emptyBool,
+  rules: Object,
+  validateStatus: type.PropTypes.oneOf(["success", "warning", "error", "validating"])
+};
+var FormItem = vue.defineComponent({
+  name: "TFormItem",
+  props: formItemProps,
+  setup(props, {
+    slots
+  }) {
+    const {
+      prefixCls
+    } = useConfig.useConfig("form-item", props);
+    const formContext = context.injectForm();
+    const required = vue.computed(() => {
+      if (props.required !== void 0)
+        return props.required;
+      return rules.value.findIndex((item) => item.required) >= 0;
+    });
+    const showTip = vue.computed(() => {
+      if (props.showTip !== void 0)
+        return props.showTip;
+      return formContext.showTip.value;
+    });
+    const classes = vue.computed(() => {
+      return [prefixCls.value, {
+        [`is-required`]: required.value && !formContext.hideRequired.value,
+        [`status-sucess`]: validateStatus.value == "sucess",
+        [`status-error`]: validateStatus.value == "error",
+        [`status-warning`]: validateStatus.value == "warning",
+        [`status-validating`]: validateStatus.value == "validating",
+        [formContext.itemClass.value]: !!formContext.itemClass.value
+      }];
+    });
+    const initialValue = vue.ref();
+    const errors = vue.ref([]);
+    const validateStatus = vue.ref(props.validateStatus);
+    const styles = vue.computed(() => {
+      const style = {};
+      if (formContext.itemWidth.value)
+        style.width = common.getLength(formContext.itemWidth.value);
+      if (props.marginBottom !== void 0)
+        style.marginBottom = common.getLength(props.marginBottom);
+      return style;
+    });
+    const labelWidth = vue.computed(() => {
+      if (props.labelWidth !== void 0)
+        return common.getLengthNumber(props.labelWidth);
+      return formContext.labelWidth.value;
+    });
+    const labelStyles = vue.computed(() => {
+      const style = {};
+      if (props.labelWidth)
+        style.width = common.getLength(props.labelWidth);
+      return style;
+    });
+    const contentStyles = vue.computed(() => {
+      return {
+        marginLeft: -formContext.gutter.value / 2 + "px",
+        marginRight: -formContext.gutter.value / 2 + "px",
+        textAlign: props.contentAlign
+      };
+    });
+    const resetField = () => {
+      const model = formContext.model.value;
+      setField(model, props.prop, initialValue.value);
+      validateStatus.value = "";
+      errors.value = [];
+    };
+    const rules = vue.computed(() => {
+      var _a, _b;
+      let rules2 = [];
+      const ruleName = (_a = props.ruleName) != null ? _a : props.prop;
+      const rulesFromForm = (_b = formContext.rules.value[ruleName]) != null ? _b : null;
+      if (rulesFromForm) {
+        rules2 = type.isArray(rulesFromForm) ? rulesFromForm : [rulesFromForm];
+      }
+      const itemRules = props.rules ? type.isArray(props.rules) ? props.rules : [props.rules] : null;
+      if (itemRules)
+        rules2 = [...rules2, ...itemRules];
+      return rules2;
+    });
+    const existField = (model, field) => {
+      const arr = field.replace(/\[([^\[\]]*)\]/g, ".$1").split(".");
+      if (arr.length <= 1)
+        return model.hasOwnProperty(field);
+      let object = model;
+      for (let i = 0; i < arr.length; i++) {
+        if (!object.hasOwnProperty(arr[i]))
+          return false;
+        object = object[arr[i]];
+      }
+      return true;
+    };
+    const getField = (model, field) => {
+      if (!model || !field)
+        return null;
+      const arr = field.replace(/\[([^\[\]]*)\]/g, ".$1").split(".");
+      if (arr.length <= 1)
+        return model[field];
+      let object = cloneDeep__default["default"](model);
+      for (let i = 0; i < arr.length; i++) {
+        if (!object.hasOwnProperty(arr[i]))
+          return null;
+        object = object[arr[i]];
+        if (object === null)
+          return null;
+        if (object === void 0)
+          return void 0;
+      }
+      return object;
+    };
+    const setField = (model, field, value) => {
+      if (!model)
+        return;
+      const arr = field.replace(/\[([^\[\]]*)\]/g, ".$1").split(".");
+      if (arr.length <= 1)
+        model[field] = value;
+      let object = model;
+      for (let i = 0; i < arr.length - 1; i++) {
+        object = object[arr[i]];
+      }
+      object[arr[arr.length - 1]] = value;
+    };
+    const validate = (validateRules = []) => {
+      if (props.disabled)
+        return Promise.resolve(false);
+      const field = props.prop;
+      if (!field)
+        return Promise.resolve(true);
+      const exists = existField(formContext.model.value, field);
+      if (!exists) {
+        return Promise.reject(`validate: value ${field} is not in model`);
+      }
+      const value = getField(formContext.model.value, field);
+      if (validateRules.length == 0)
+        validateRules = rules.value;
+      const schema = new Schema__default["default"]({
+        [field]: validateRules.map((rule) => {
+          if (!rule.type && !rule.validator) {
+            rule.type = "string";
+          }
+          return rule;
+        })
+      });
+      schema.messages(cn.messages);
+      return schema.validate({
+        [field]: value
+      }).then(() => {
+        clearValidate();
+      }).catch(({
+        errors: aErrors
+      }) => {
+        validateStatus.value = "error";
+        errors.value = formatErrors(aErrors);
+        return Promise.resolve(errors.value);
+      });
+    };
+    const clearValidate = () => {
+      validateStatus.value = "";
+      errors.value = [];
+    };
+    const formatErrors = (errors2) => {
+      return errors2.map((error) => {
+        let message = error.message.replace(props.prop, props.label);
+        const childType = checkChildType.value;
+        const selectComs = ["TSelect", "TRadio", "TTreeSelect", "TCascader", "TDatePicker"];
+        if (selectComs.includes(childType))
+          message = message.replace("\u8BF7\u8F93\u5165", "\u8BF7\u9009\u62E9");
+        else if (childType == "TUpload")
+          message = message.replace("\u8BF7\u8F93\u5165", "\u8BF7\u4E0A\u4F20");
+        error.message = message;
+        return error;
+      });
+    };
+    const addField = () => {
+      const formItemInfo = vue.reactive({
+        prop: props.prop,
+        resetField,
+        validate,
+        clearValidate
+      });
+      formContext.addField(formItemInfo);
+    };
+    const saveInitialValue = () => {
+      const model = formContext.model.value;
+      initialValue.value = getField(model, props.prop);
+    };
+    const checkChildType = vue.computed(() => {
+      var _a, _b, _c;
+      return (_c = (_b = (_a = children.value) == null ? void 0 : _a[0]["type"]) == null ? void 0 : _b["name"]) != null ? _c : "";
+    });
+    vue.onMounted(() => {
+      if (props.prop)
+        addField();
+      saveInitialValue();
+    });
+    vue.onBeforeMount(() => {
+      if (props.prop)
+        formContext.removeField(props.prop);
+    });
+    vue.watch(() => props.validateStatus, () => {
+      validateStatus.value = props.validateStatus;
+    });
+    const blurRules = vue.computed(() => {
+      return rules.value.filter((rule) => {
+        return rule.trigger.split(",").includes("blur");
+      });
+    });
+    const changeRules = vue.computed(() => {
+      return rules.value.filter((rule) => {
+        return rule.trigger.split(",").includes("change");
+      });
+    });
+    const defaultSlot = useGetSlot["default"](slots, "default");
+    const labelColon = vue.computed(() => {
+      return props.labelColon !== void 0 ? props.labelColon : formContext.labelColon.value;
+    });
+    const children = vue.computed(() => {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      const children2 = (_b = (_a = defaultSlot.value) == null ? void 0 : _a.call(defaultSlot)) != null ? _b : [];
+      if (children2.length <= 0)
+        return null;
+      const mergeProps = {};
+      if ((_e = (_d = (_c = children2[0]) == null ? void 0 : _c["type"]) == null ? void 0 : _d["props"]) == null ? void 0 : _e.hasOwnProperty("placeholder")) {
+        mergeProps["placeholder"] = props.label;
+      }
+      if (formContext.disabled.value !== void 0) {
+        mergeProps["disabled"] = formContext.disabled.value;
+      }
+      if (formContext.size.value !== void 0 && ((_h = (_g = (_f = children2[0]) == null ? void 0 : _f["type"]) == null ? void 0 : _g["props"]) == null ? void 0 : _h.hasOwnProperty("size"))) {
+        mergeProps["size"] = formContext.size.value;
+      }
+      if (blurRules.value.length > 0) {
+        mergeProps["onBlur"] = () => {
+          validate(blurRules.value);
+        };
+      }
+      if (changeRules.value.length > 0) {
+        mergeProps["onChange"] = () => {
+          validate(changeRules.value);
+        };
+      }
+      element.mergeChildren(children2, mergeProps);
+      return children2;
+    });
+    const labelElement = vue.computed(() => {
+      var _a, _b, _c;
+      if (labelWidth.value <= 0)
+        return null;
+      const labelContent = (_b = props.label) != null ? _b : (_a = slots.label) == null ? void 0 : _a.call(slots);
+      const content = vue.createVNode(vue.Fragment, null, [labelContent, labelColon.value && labelContent ? "\uFF1A" : "", labelContent ? null : vue.createVNode("span", null, null)]);
+      return formContext.labelAlign.value == "top" ? vue.createVNode("label", {
+        "class": `${prefixCls.value}-label`,
+        "for": props.labelFor,
+        "style": labelStyles.value
+      }, [vue.createVNode("div", null, [content]), vue.createVNode("div", null, [(_c = slots.right) == null ? void 0 : _c.call(slots)])]) : vue.createVNode("label", {
+        "class": `${prefixCls.value}-label`,
+        "for": props.labelFor,
+        "style": labelStyles.value
+      }, [content]);
+    });
+    return () => {
+      var _a, _b, _c;
+      return vue.createVNode("div", {
+        "class": classes.value,
+        "style": styles.value
+      }, [labelElement.value, vue.createVNode("div", {
+        "class": `${prefixCls.value}-content`
+      }, [vue.createVNode("div", {
+        "class": `${prefixCls.value}-content-wrapper`,
+        "style": contentStyles.value
+      }, [children.value]), slots.desc ? vue.createVNode("div", {
+        "class": `${prefixCls.value}-desc`
+      }, [(_a = slots.desc) == null ? void 0 : _a.call(slots)]) : null, showTip.value ? vue.createVNode("div", {
+        "class": `${prefixCls.value}-tip`,
+        "title": (_b = errors.value[0]) == null ? void 0 : _b.message
+      }, [(_c = errors.value[0]) == null ? void 0 : _c.message]) : null])]);
+    };
+  }
+});
+exports["default"] = FormItem;

package/lib/form/src/form.d.ts

@@ -0,0 +1,128 @@
+import type { PropType } from 'vue';
+import type { ValidateRuleItem } from './context';
+import type { ValidateError } from 'async-validator';
+declare const _default: import("vue").DefineComponent<{
+    model: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }> & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    rules: PropType<{
+        [field: string]: ValidateRuleItem | ValidateRuleItem[];
+    }>;
+    labelWidth: import("vue-types").VueTypeDef<string | number> & {
+        default: string | number;
+    };
+    itemWidth: import("vue-types").VueTypeDef<string | number>;
+    labelAlign: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    inline: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    showTip: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    hideRequired: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    disabled: import("vue-types").VueTypeValidableDef<boolean>;
+    itemClass: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    autoValidate: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    gutter: import("vue-types").VueTypeDef<string | number>;
+    marginBottom: import("vue-types").VueTypeDef<string | number>;
+    size: import("vue-types").VueTypeDef<string>;
+    labelColon: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+}, {
+    render: () => JSX.Element;
+    validate: (fieldList?: string[], callback?: (errors: false | Record<string, ValidateError[]>) => void) => Promise<boolean | Record<string, ValidateError[]>>;
+    validatePartical: (fieldList?: string[], callback?: (errors: false | Record<string, ValidateError[]>) => void) => Promise<boolean | Record<string, ValidateError[]>>;
+    resetFields: () => void;
+    clearValidate: (fieldList?: string[]) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("validate" | "resetFields" | "validateSuccess" | "validateFail")[], "validate" | "resetFields" | "validateSuccess" | "validateFail", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    model: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }> & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    rules: PropType<{
+        [field: string]: ValidateRuleItem | ValidateRuleItem[];
+    }>;
+    labelWidth: import("vue-types").VueTypeDef<string | number> & {
+        default: string | number;
+    };
+    itemWidth: import("vue-types").VueTypeDef<string | number>;
+    labelAlign: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    inline: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    showTip: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    hideRequired: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    disabled: import("vue-types").VueTypeValidableDef<boolean>;
+    itemClass: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    autoValidate: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    gutter: import("vue-types").VueTypeDef<string | number>;
+    marginBottom: import("vue-types").VueTypeDef<string | number>;
+    size: import("vue-types").VueTypeDef<string>;
+    labelColon: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+}>> & {
+    onValidate?: (...args: any[]) => any;
+    onResetFields?: (...args: any[]) => any;
+    onValidateSuccess?: (...args: any[]) => any;
+    onValidateFail?: (...args: any[]) => any;
+}, {
+    inline: boolean;
+    model: {
+        [key: string]: any;
+    };
+    labelWidth: string | number;
+    labelAlign: string;
+    showTip: boolean;
+    hideRequired: boolean;
+    itemClass: string;
+    autoValidate: boolean;
+    labelColon: boolean;
+}>;
+export default _default;

package/lib/form/src/form.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var vue = require("vue");
+var type = require("../../utils/type.js");
+var useConfig = require("../../utils/hooks/useConfig.js");
+var context = require("./context.js");
+var common = require("../../utils/common.js");
+const formProps = {
+  model: type.PropTypes.object,
+  rules: Object,
+  labelWidth: type.PropTypes.oneOfType([type.PropTypes.number, type.PropTypes.string]).def(100),
+  itemWidth: type.PropTypes.oneOfType([type.PropTypes.number, type.PropTypes.string]),
+  labelAlign: type.PropTypes.oneOf(["left", "top", "right"]).def("right"),
+  inline: type.PropTypes.bool.def(false),
+  showTip: type.PropTypes.bool.def(true),
+  hideRequired: type.PropTypes.bool.def(false),
+  disabled: type.PropTypes.emptyBool,
+  itemClass: type.PropTypes.string,
+  autoValidate: type.PropTypes.bool.def(true),
+  gutter: type.PropTypes.oneOfType([type.PropTypes.number, type.PropTypes.string]),
+  marginBottom: type.PropTypes.oneOfType([type.PropTypes.number, type.PropTypes.string]),
+  size: type.PropTypes.oneOf(["xs", "sm", "md", "lg", "xl"]),
+  labelColon: type.PropTypes.bool.def(false)
+};
+var Form = vue.defineComponent({
+  name: "TForm",
+  props: formProps,
+  emits: ["validate", "resetFields", "validateSuccess", "validateFail"],
+  setup(props, {
+    slots,
+    attrs,
+    emit
+  }) {
+    const {
+      prefixCls
+    } = useConfig.useConfig("form", props);
+    const classes = vue.computed(() => {
+      return [prefixCls.value, {
+        [`label-align-${props.labelAlign}`]: props.labelAlign,
+        [`${prefixCls.value}-inline`]: props.inline
+      }];
+    });
+    const styles = vue.computed(() => {
+      const style = {};
+      const gutter = common.getLengthNumber(props.gutter);
+      if (gutter) {
+        style[`marginLeft`] = `-${gutter / 2}px`;
+        style[`marginRight`] = `-${gutter / 2}px`;
+        style[`width`] = `calc(100% + ${gutter}px)`;
+      }
+      if (props.labelWidth) {
+        style[`--t-label-width`] = common.getLength(props.labelWidth);
+      }
+      if (props.marginBottom !== void 0)
+        style[`--t-form-item-margin-bottom`] = common.getLength(props.marginBottom);
+      else if (!props.showTip)
+        style[`--t-form-item-margin-bottom`] = "12px";
+      return style;
+    });
+    const validate = async (fieldList = [], callback) => {
+      if (!props.model) {
+        return;
+      }
+      const validateList = [];
+      formItemList.map((formItem) => {
+        if (fieldList.length > 0) {
+          if (fieldList.includes(formItem.prop))
+            validateList.push(formItem.validate());
+        } else
+          validateList.push(formItem.validate());
+      });
+      const validateResults = await Promise.all(validateList);
+      const errorList = {};
+      let hasError = false;
+      validateResults.forEach((item) => {
+        if (!item)
+          return;
+        errorList[item[0].field] = item;
+        hasError = true;
+      });
+      if (callback)
+        callback(hasError ? errorList : false);
+      if (hasError)
+        return Promise.resolve(errorList);
+      else
+        return Promise.resolve(false);
+    };
+    const clearValidate = (fieldList = []) => {
+      formItemList.map((formItem) => {
+        if (fieldList.length > 0) {
+          if (fieldList.includes(formItem.prop))
+            formItem.clearValidate();
+        } else
+          formItem.clearValidate();
+      });
+    };
+    const validatePartical = (fieldList = [], callback = () => {
+    }) => {
+      return validate(fieldList, callback);
+    };
+    const handleSubmit = (event) => {
+      event.stopPropagation();
+      event.preventDefault();
+      validate().then((result) => {
+        if (result === false) {
+          emit("validateSuccess");
+        } else {
+          emit("validateFail", result);
+        }
+      });
+    };
+    const resetFields = () => {
+      if (!props.model) {
+        return;
+      }
+      formItemList.map((item) => item.resetField());
+    };
+    const formItemList = [];
+    const addField = (formItem) => {
+      const index = formItemList.findIndex((one) => (one == null ? void 0 : one.prop) == (formItem == null ? void 0 : formItem.prop));
+      if (index < 0)
+        formItemList.push(formItem);
+    };
+    const removeField = (prop) => {
+      const index = formItemList.findIndex((one) => (one == null ? void 0 : one.prop) == prop);
+      if (index >= 0)
+        formItemList.splice(index, 1);
+    };
+    context.provideForm({
+      model: vue.computed(() => props.model),
+      rules: vue.computed(() => {
+        var _a;
+        return (_a = props.rules) != null ? _a : {};
+      }),
+      gutter: vue.computed(() => common.getLengthNumber(props.gutter)),
+      hideRequired: vue.computed(() => props.hideRequired),
+      labelWidth: vue.computed(() => common.getLengthNumber(props.labelWidth)),
+      labelAlign: vue.computed(() => props.labelAlign),
+      itemClass: vue.computed(() => props.itemClass),
+      itemWidth: vue.computed(() => common.getLengthNumber(props.itemWidth)),
+      size: vue.computed(() => props.size),
+      disabled: vue.computed(() => props.disabled),
+      labelColon: vue.computed(() => props.labelColon),
+      showTip: vue.computed(() => props.showTip),
+      addField,
+      removeField
+    });
+    const render = () => {
+      var _a;
+      return vue.createVNode("form", vue.mergeProps(attrs, {
+        "class": classes.value,
+        "style": styles.value,
+        "onSubmit": handleSubmit
+      }), [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+    return {
+      render,
+      validate,
+      validatePartical,
+      resetFields,
+      clearValidate
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+exports["default"] = Form;