ep-craft 0.1.27 → 0.1.28

package/dist/components/form/src/form.d.ts

@@ -0,0 +1,127 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type { ComponentSize } from '@element-plus/constants';
+import type { FormItemProp } from './form-item';
+import type { FormRules } from './types';
+export interface FormMetaProps {
+    /**
+     * @description Control the size of components in this form.
+     */
+    size?: ComponentSize;
+    /**
+     * @description Whether to disable all components in this form. If set to `true`, it will override the `disabled` prop of the inner component.
+     */
+    disabled?: boolean;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `FormMetaProps` instead.
+ */
+export declare const formMetaProps: {
+    readonly size: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabled: BooleanConstructor;
+};
+export interface FormProps extends FormMetaProps {
+    /**
+     * @description Data of form component.
+     */
+    model?: Record<string, any>;
+    /**
+     * @description Validation rules of form.
+     */
+    rules?: FormRules;
+    /**
+     * @description Position of label. If set to `'left'` or `'right'`, `label-width` prop is also required.
+     */
+    labelPosition?: 'left' | 'right' | 'top';
+    /**
+     * @description Position of asterisk.
+     */
+    requireAsteriskPosition?: 'left' | 'right';
+    /**
+     * @description Width of label, e.g. `'50px'`. All its direct child form items will inherit this value. `auto` is supported.
+     */
+    labelWidth?: string | number;
+    /**
+     * @description Suffix of the label.
+     */
+    labelSuffix?: string;
+    /**
+     * @description Whether the form is inline.
+     */
+    inline?: boolean;
+    /**
+     * @description Whether to display the error message inline with the form item.
+     */
+    inlineMessage?: boolean;
+    /**
+     * @description Whether to display an icon indicating the validation result.
+     */
+    statusIcon?: boolean;
+    /**
+     * @description Whether to show the error message.
+     */
+    showMessage?: boolean;
+    /**
+     * @description Whether to trigger validation when the `rules` prop is changed.
+     */
+    validateOnRuleChange?: boolean;
+    /**
+     * @description Whether to hide required fields should have a red asterisk (star) beside their labels.
+     */
+    hideRequiredAsterisk?: boolean;
+    /**
+     * @description When validation fails, scroll to the first error form entry.
+     */
+    scrollToError?: boolean;
+    /**
+     * @description When validation fails, it scrolls to the first error item based on the scrollIntoView option.
+     */
+    scrollIntoViewOptions?: ScrollIntoViewOptions | boolean;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `FormProps` instead.
+ */
+export declare const formProps: {
+    readonly model: ObjectConstructor;
+    readonly rules: {
+        readonly type: import("vue").PropType<Partial<Record<string, Record<string, any> | import("@element-plus/utils").Arrayable<import("./types").FormItemRule>>>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly labelPosition: import("@element-plus/utils").EpPropFinalized<StringConstructor, "left" | "right" | "top", unknown, "right", boolean>;
+    readonly requireAsteriskPosition: import("@element-plus/utils").EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+    readonly labelWidth: import("@element-plus/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    readonly labelSuffix: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly inline: BooleanConstructor;
+    readonly inlineMessage: BooleanConstructor;
+    readonly statusIcon: BooleanConstructor;
+    readonly showMessage: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly validateOnRuleChange: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly hideRequiredAsterisk: BooleanConstructor;
+    readonly scrollToError: BooleanConstructor;
+    readonly scrollIntoViewOptions: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => boolean | ScrollIntoViewOptions) | (() => boolean | ScrollIntoViewOptions) | (((new (...args: any[]) => boolean | ScrollIntoViewOptions) | (() => boolean | ScrollIntoViewOptions)) | null)[], unknown, unknown, true, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabled: BooleanConstructor;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `FormProps` instead.
+ */
+export type FormPropsPublic = ExtractPublicPropTypes<typeof formProps>;
+/**
+ * @deprecated Removed after 3.0.0, Use `FormMetaProps` instead.
+ */
+export type FormMetaPropsPublic = ExtractPublicPropTypes<typeof formMetaProps>;
+export declare const formEmits: {
+    validate: (prop: FormItemProp, isValid: boolean, message: string) => boolean;
+};
+export type FormEmits = typeof formEmits;

package/dist/components/form/src/form.js

@@ -0,0 +1,112 @@
+import { componentSizes as a } from "../../../constants/size.js";
+import { isBoolean as n } from "../../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import { isArray as s, isString as t } from "@vue/shared";
+import "@element-plus/icons-vue";
+import { buildProps as i, definePropType as o } from "../../../utils/vue/props/runtime.js";
+import "vue";
+const p = i({
+  /**
+   * @description Control the size of components in this form.
+   */
+  size: {
+    type: String,
+    values: a
+  },
+  /**
+   * @description Whether to disable all components in this form. If set to `true`, it will override the `disabled` prop of the inner component.
+   */
+  disabled: Boolean
+});
+i({
+  ...p,
+  /**
+   * @description Data of form component.
+   */
+  model: Object,
+  /**
+   * @description Validation rules of form.
+   */
+  rules: {
+    type: o(Object)
+  },
+  /**
+   * @description Position of label. If set to `'left'` or `'right'`, `label-width` prop is also required.
+   */
+  labelPosition: {
+    type: String,
+    values: ["left", "right", "top"],
+    default: "right"
+  },
+  /**
+   * @description Position of asterisk.
+   */
+  requireAsteriskPosition: {
+    type: String,
+    values: ["left", "right"],
+    default: "left"
+  },
+  /**
+   * @description Width of label, e.g. `'50px'`. All its direct child form items will inherit this value. `auto` is supported.
+   */
+  labelWidth: {
+    type: [String, Number],
+    default: ""
+  },
+  /**
+   * @description Suffix of the label.
+   */
+  labelSuffix: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description Whether the form is inline.
+   */
+  inline: Boolean,
+  /**
+   * @description Whether to display the error message inline with the form item.
+   */
+  inlineMessage: Boolean,
+  /**
+   * @description Whether to display an icon indicating the validation result.
+   */
+  statusIcon: Boolean,
+  /**
+   * @description Whether to show the error message.
+   */
+  showMessage: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description Whether to trigger validation when the `rules` prop is changed.
+   */
+  validateOnRuleChange: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description Whether to hide required fields should have a red asterisk (star) beside their labels.
+   */
+  hideRequiredAsterisk: Boolean,
+  /**
+   * @description When validation fails, scroll to the first error form entry.
+   */
+  scrollToError: Boolean,
+  /**
+   * @description When validation fails, it scrolls to the first error item based on the scrollIntoView option.
+   */
+  scrollIntoViewOptions: {
+    type: o([Object, Boolean]),
+    default: !0
+  }
+});
+const c = {
+  validate: (e, r, l) => (s(e) || t(e)) && n(r) && t(l)
+};
+export {
+  c as formEmits,
+  p as formMetaProps
+};

package/dist/components/form/src/types.d.ts

@@ -1,24 +1,53 @@
+import { useFormLabelWidth } from './utils';
 import type { ComponentSize } from '@element-plus/constants';
-export interface FormContext {
-    size?: ComponentSize;
-    disabled?: boolean;
-    [key: string]: any;
+import type { Arrayable, FieldPath } from '@element-plus/utils';
+import type { RuleItem, ValidateError, ValidateFieldsError } from 'async-validator';
+import type { MaybeRef, SetupContext, UnwrapRef } from 'vue';
+import type { FormItemProp, FormItemProps, FormItemValidateState } from './form-item';
+import type { FormEmits, FormProps } from './form';
+type FormLabelWidthContext = ReturnType<typeof useFormLabelWidth>;
+interface FormItemRule extends RuleItem {
+    trigger?: Arrayable<string>;
 }
-export interface FormItemContext {
-    size?: ComponentSize;
-    $el?: HTMLDivElement | undefined;
-    validateMessage?: string;
-    validateState?: '' | 'error' | 'validating' | 'success';
-    isGroup?: boolean;
-    labelId?: string;
-    inputIds?: string[];
-    hasLabel?: boolean;
-    fieldValue?: any;
-    propString?: string;
+type FormRuleValue<V> = V extends any[] ? Arrayable<FormItemRule> : V extends Record<string, any> ? Arrayable<FormItemRule> | {
+    [K in keyof V]?: FormRuleValue<V[K]>;
+} : Arrayable<FormItemRule>;
+type FormRules<T extends MaybeRef<Record<string, any> | string> = string> = UnwrapRef<T> extends Record<string, any> ? {
+    [P in FieldPath<UnwrapRef<T>>]?: P extends keyof UnwrapRef<T> ? FormRuleValue<UnwrapRef<T>[P]> : Arrayable<FormItemRule>;
+} : Partial<Record<string, Arrayable<FormItemRule> | Record<string, any>>>;
+type FormValidationResult = Promise<boolean>;
+type FormValidateCallback = (isValid: boolean, invalidFields?: ValidateFieldsError) => Promise<void> | void;
+interface FormValidateFailure {
+    errors: ValidateError[] | null;
+    fields: ValidateFieldsError;
+}
+type FormContext = FormProps & UnwrapRef<FormLabelWidthContext> & {
+    emit: SetupContext<FormEmits>['emit'];
+    getField: (prop: FormItemProp) => FormItemContext | undefined;
+    addField: (field: FormItemContext) => void;
+    removeField: (field: FormItemContext, oldPropString?: string) => void;
+    resetFields: (props?: Arrayable<FormItemProp>) => void;
+    setInitialValues: (initModel: Record<string, any>) => void;
+    clearValidate: (props?: Arrayable<FormItemProp>) => void;
+    validateField: (props?: Arrayable<FormItemProp>, callback?: FormValidateCallback) => FormValidationResult;
+};
+interface FormItemContext extends FormItemProps {
+    $el: HTMLDivElement | undefined;
+    size: ComponentSize;
+    validateMessage: string;
+    validateState: FormItemValidateState;
+    isGroup: boolean;
+    labelId: string;
+    inputIds: string[];
+    hasLabel: boolean;
+    fieldValue: any;
+    propString: string;
     addInputId: (id: string) => void;
     removeInputId: (id: string) => void;
-    validate?: (...args: any[]) => any;
-    resetField?: () => void;
-    clearValidate?: () => void;
-    [key: string]: any;
+    validate: (trigger: string, callback?: FormValidateCallback) => FormValidationResult;
+    resetField(): void;
+    clearValidate(): void;
+    setInitialValue: (value: any) => void;
+    getInitialValue: () => any;
 }
+export type { FormContext, FormItemContext, FormItemRule, FormLabelWidthContext, FormRules, FormValidateCallback, FormValidateFailure, FormValidationResult, };

package/dist/components/form/src/utils.d.ts

@@ -0,0 +1,9 @@
+import type { Arrayable } from '@element-plus/utils';
+import type { FormItemContext } from './types';
+import type { FormItemProp } from './form-item';
+export declare function useFormLabelWidth(): {
+    autoLabelWidth: import("vue").ComputedRef<string>;
+    registerLabelWidth: (val: number, oldVal: number) => void;
+    deregisterLabelWidth: (val: number) => void;
+};
+export declare const filterFields: (fields: FormItemContext[], props: Arrayable<FormItemProp>) => FormItemContext[];

package/dist/components/form/src/utils.js

@@ -0,0 +1,45 @@
+import { ref as c, computed as s } from "vue";
+import { isArray as l } from "@vue/shared";
+import { castArray as m } from "lodash-unified";
+import "@vueuse/core";
+import { debugWarn as d } from "../../../utils/error.js";
+import "@element-plus/icons-vue";
+const f = "ElForm";
+function L() {
+  const t = c([]), o = s(() => {
+    if (!t.value.length) return "0";
+    const e = Math.max(...t.value);
+    return e ? `${e}px` : "";
+  });
+  function n(e) {
+    const i = t.value.indexOf(e);
+    return i === -1 && o.value === "0" && d(f, `unexpected width ${e}`), i;
+  }
+  function r(e, i) {
+    if (e && i) {
+      const a = n(i);
+      t.value.splice(a, 1, e);
+    } else e && t.value.push(e);
+  }
+  function u(e) {
+    const i = n(e);
+    i > -1 && t.value.splice(i, 1);
+  }
+  return {
+    autoLabelWidth: o,
+    registerLabelWidth: r,
+    deregisterLabelWidth: u
+  };
+}
+const v = (t, o) => {
+  const n = m(o).map(
+    (r) => l(r) ? r.join(".") : r
+  );
+  return n.length > 0 ? t.filter(
+    (r) => r.propString && n.includes(r.propString)
+  ) : t;
+};
+export {
+  v as filterFields,
+  L as useFormLabelWidth
+};

package/dist/components/form-item/EpFormItem.vue.d.ts

@@ -0,0 +1,55 @@
+import type { FormItemProps } from '../form/src/form-item';
+declare var __VLS_9: {
+    label: string;
+}, __VLS_11: {}, __VLS_17: {
+    error: string;
+};
+type __VLS_Slots = {} & {
+    label?: (props: typeof __VLS_9) => any;
+} & {
+    default?: (props: typeof __VLS_11) => any;
+} & {
+    error?: (props: typeof __VLS_17) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<FormItemProps, {
+    /**
+     * @description Form item size.
+     */
+    size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+    /**
+     * @description Validation message.
+     */
+    validateMessage: import("vue").Ref<string, string>;
+    /**
+     * @description Validation state.
+     */
+    validateState: import("vue").Ref<"" | "error" | "success" | "validating", "" | "error" | "success" | "validating">;
+    /**
+     * @description Validate form item.
+     */
+    validate: (trigger: string, callback?: import("../form").FormValidateCallback) => import("../form").FormValidationResult;
+    /**
+     * @description Remove validation status of the field.
+     */
+    clearValidate: () => void;
+    /**
+     * @description Reset current field and remove validation result.
+     */
+    resetField: () => void;
+    /**
+     * @description Set initial value for this field. When `resetField` is called, the field will reset to this value.
+     */
+    setInitialValue: (value: any) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormItemProps> & Readonly<{}>, {
+    required: boolean;
+    labelPosition: "left" | "right" | "top" | "";
+    inlineMessage: boolean;
+    showMessage: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/form-item/EpFormItem.vue.js

@@ -0,0 +1,257 @@
+import { defineComponent as be, useSlots as ye, inject as K, ref as I, computed as a, watch as z, reactive as Ie, toRefs as Fe, provide as Se, onMounted as Ve, onBeforeUnmount as qe, openBlock as U, createElementBlock as we, unref as v, normalizeClass as F, createVNode as H, withCtx as _, createBlock as We, resolveDynamicComponent as Me, normalizeStyle as J, renderSlot as B, createTextVNode as Re, toDisplayString as O, createCommentVNode as Q, createElementVNode as X, TransitionGroup as $e, nextTick as ze } from "vue";
+import _e from "async-validator";
+import { refDebounced as Be } from "@vueuse/core";
+import { isBoolean as Ne } from "../../utils/types.js";
+import { castArray as Y, cloneDeep as Z } from "lodash-unified";
+import { isArray as k, isFunction as Pe } from "@vue/shared";
+import { getProp as N } from "../../utils/objects.js";
+import { addUnit as C } from "../../utils/dom/style.js";
+import "@element-plus/icons-vue";
+import { useNamespace as Ee } from "../../hooks/use-namespace/index.js";
+import { useId as Ae } from "../../hooks/use-id/index.js";
+import "../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import "../../hooks/use-delayed-toggle/index.js";
+import "../../hooks/use-aria/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "../../hooks/use-empty-values/index.js";
+import { useFormSize as De } from "../form/src/hooks/use-form-common-props.js";
+import je from "../form/src/form-label-wrap.js";
+import { formContextKey as Le, formItemContextKey as x } from "../form/src/constants.js";
+const Te = ["role", "aria-labelledby"], ut = /* @__PURE__ */ be({
+  name: "ElFormItem",
+  __name: "EpFormItem",
+  props: {
+    label: {},
+    labelWidth: {},
+    labelPosition: { default: "" },
+    prop: {},
+    required: { type: Boolean, default: void 0 },
+    rules: {},
+    error: {},
+    validateStatus: {},
+    for: {},
+    inlineMessage: { type: Boolean, default: void 0 },
+    showMessage: { type: Boolean, default: !0 },
+    size: {}
+  },
+  setup(P, { expose: ee }) {
+    const s = P, E = ye(), e = K(Le, void 0), te = K(x, void 0), S = De(void 0, { formItem: !1 }), o = Ee("form-item"), V = Ae().value, d = I([]), p = I(""), re = Be(p, 100), u = I(""), A = I();
+    let q, h = !1;
+    const g = a(
+      () => s.labelPosition || (e == null ? void 0 : e.labelPosition)
+    ), D = a(() => g.value === "top" ? {} : { width: C(s.labelWidth ?? (e == null ? void 0 : e.labelWidth)) }), se = a(() => {
+      if (g.value === "top" || e != null && e.inline)
+        return {};
+      if (!s.label && !s.labelWidth && oe)
+        return {};
+      const t = C(s.labelWidth ?? (e == null ? void 0 : e.labelWidth));
+      return !s.label && !E.label ? { marginLeft: t } : {};
+    }), ie = a(() => [
+      o.b(),
+      o.m(S.value),
+      o.is("error", p.value === "error"),
+      o.is("validating", p.value === "validating"),
+      o.is("success", p.value === "success"),
+      o.is("required", de.value || s.required),
+      o.is("no-asterisk", e == null ? void 0 : e.hideRequiredAsterisk),
+      (e == null ? void 0 : e.requireAsteriskPosition) === "right" ? "asterisk-right" : "asterisk-left",
+      {
+        [o.m("feedback")]: e == null ? void 0 : e.statusIcon,
+        [o.m(`label-${g.value}`)]: g.value
+      }
+    ]), le = a(
+      () => Ne(s.inlineMessage) ? s.inlineMessage : (e == null ? void 0 : e.inlineMessage) || !1
+    ), ae = a(() => [
+      o.e("error"),
+      { [o.em("error", "inline")]: le.value }
+    ]), w = a(() => s.prop ? k(s.prop) ? s.prop.join(".") : s.prop : ""), j = a(() => !!(s.label || E.label)), W = a(() => s.for ?? (d.value.length === 1 ? d.value[0] : void 0)), M = a(() => !W.value && j.value), oe = !!te, b = a(() => {
+      const t = e == null ? void 0 : e.model;
+      if (!(!t || !s.prop))
+        return N(t, s.prop).value;
+    }), R = a(() => {
+      const { required: t } = s, r = [];
+      s.rules && r.push(...Y(s.rules));
+      const i = e == null ? void 0 : e.rules;
+      if (i && s.prop) {
+        const l = N(
+          i,
+          s.prop
+        ).value;
+        l && r.push(...Y(l));
+      }
+      if (t !== void 0) {
+        const l = r.map((n, m) => [n, m]).filter(([n]) => "required" in n);
+        if (l.length > 0)
+          for (const [n, m] of l)
+            n.required !== t && (r[m] = { ...n, required: t });
+        else
+          r.push({ required: t });
+      }
+      return r;
+    }), ue = a(() => R.value.length > 0), ne = (t) => R.value.filter((i) => !i.trigger || !t ? !0 : k(i.trigger) ? i.trigger.includes(t) : i.trigger === t).map(({ trigger: i, ...l }) => l), de = a(
+      () => R.value.some((t) => t.required)
+    ), pe = a(
+      () => re.value === "error" && s.showMessage && ((e == null ? void 0 : e.showMessage) ?? !0)
+    ), L = a(
+      () => `${s.label || ""}${(e == null ? void 0 : e.labelSuffix) || ""}`
+    ), c = (t) => {
+      p.value = t;
+    }, ve = (t) => {
+      var l;
+      const { errors: r, fields: i } = t;
+      (!r || !i) && console.error(t), c("error"), u.value = r ? ((l = r == null ? void 0 : r[0]) == null ? void 0 : l.message) ?? `${s.prop} is required` : "", e == null || e.emit("validate", s.prop, !1, u.value);
+    }, ce = () => {
+      c("success"), e == null || e.emit("validate", s.prop, !0, "");
+    }, me = async (t) => {
+      const r = w.value;
+      return new _e({
+        [r]: t
+      }).validate({ [r]: b.value }, { firstFields: !0 }).then(() => (ce(), !0)).catch((l) => (ve(l), Promise.reject(l)));
+    }, T = async (t, r) => {
+      if (h || !s.prop)
+        return !1;
+      const i = Pe(r);
+      if (!ue.value)
+        return r == null || r(!1), !1;
+      const l = ne(t);
+      return l.length === 0 ? (r == null || r(!0), !0) : (c("validating"), me(l).then(() => (r == null || r(!0), !0)).catch((n) => {
+        const { fields: m } = n;
+        return r == null || r(!1, m), i ? !1 : Promise.reject(m);
+      }));
+    }, $ = () => {
+      c(""), u.value = "", h = !1;
+    }, G = async () => {
+      const t = e == null ? void 0 : e.model;
+      if (!t || !s.prop) return;
+      const r = N(t, s.prop);
+      h = !0, r.value = Z(q), await ze(), $(), h = !1;
+    }, fe = (t) => {
+      d.value.includes(t) || d.value.push(t);
+    }, he = (t) => {
+      d.value = d.value.filter((r) => r !== t);
+    }, y = (t) => {
+      q = Z(t);
+    }, ge = () => q;
+    z(
+      () => s.error,
+      (t) => {
+        u.value = t || "", c(t ? "error" : "");
+      },
+      { immediate: !0 }
+    ), z(
+      () => s.validateStatus,
+      (t) => c(t || "")
+    );
+    const f = Ie({
+      ...Fe(s),
+      $el: A,
+      size: S,
+      validateMessage: u,
+      validateState: p,
+      labelId: V,
+      inputIds: d,
+      isGroup: M,
+      hasLabel: j,
+      fieldValue: b,
+      addInputId: fe,
+      removeInputId: he,
+      resetField: G,
+      clearValidate: $,
+      validate: T,
+      propString: w,
+      setInitialValue: y,
+      getInitialValue: ge
+    });
+    return Se(x, f), z(w, (t, r) => {
+      !e || !r || (e.removeField(f, r), t && (y(b.value), e.addField(f)));
+    }), Ve(() => {
+      s.prop && (y(b.value), e == null || e.addField(f));
+    }), qe(() => {
+      e == null || e.removeField(f);
+    }), ee({
+      /**
+       * @description Form item size.
+       */
+      size: S,
+      /**
+       * @description Validation message.
+       */
+      validateMessage: u,
+      /**
+       * @description Validation state.
+       */
+      validateState: p,
+      /**
+       * @description Validate form item.
+       */
+      validate: T,
+      /**
+       * @description Remove validation status of the field.
+       */
+      clearValidate: $,
+      /**
+       * @description Reset current field and remove validation result.
+       */
+      resetField: G,
+      /**
+       * @description Set initial value for this field. When `resetField` is called, the field will reset to this value.
+       */
+      setInitialValue: y
+    }), (t, r) => {
+      var i;
+      return U(), we("div", {
+        ref_key: "formItemRef",
+        ref: A,
+        class: F(ie.value),
+        role: M.value ? "group" : void 0,
+        "aria-labelledby": M.value ? v(V) : void 0
+      }, [
+        H(v(je), {
+          "is-auto-width": D.value.width === "auto",
+          "update-all": ((i = v(e)) == null ? void 0 : i.labelWidth) === "auto"
+        }, {
+          default: _(() => [
+            P.label || t.$slots.label ? (U(), We(Me(W.value ? "label" : "div"), {
+              key: 0,
+              id: v(V),
+              for: W.value,
+              class: F(v(o).e("label")),
+              style: J(D.value)
+            }, {
+              default: _(() => [
+                B(t.$slots, "label", { label: L.value }, () => [
+                  Re(O(L.value), 1)
+                ])
+              ]),
+              _: 3
+            }, 8, ["id", "for", "class", "style"])) : Q("", !0)
+          ]),
+          _: 3
+        }, 8, ["is-auto-width", "update-all"]),
+        X("div", {
+          class: F(v(o).e("content")),
+          style: J(se.value)
+        }, [
+          B(t.$slots, "default"),
+          H($e, {
+            name: `${v(o).namespace.value}-zoom-in-top`
+          }, {
+            default: _(() => [
+              pe.value ? B(t.$slots, "error", { error: u.value }, () => [
+                X("div", {
+                  class: F(ae.value)
+                }, O(u.value), 3)
+              ], void 0, 0) : Q("", !0)
+            ]),
+            _: 3
+          }, 8, ["name"])
+        ], 6)
+      ], 10, Te);
+    };
+  }
+});
+export {
+  ut as default
+};