cosey 0.5.0 → 0.5.2

package/components/form/{form-item.d.ts → form-item.api.d.ts}

@@ -1,7 +1,7 @@
-import { type FormItemInstance, type FormItemProps as ElFormItemProps } from 'element-plus';
+import { type FormItemInstance, FormItemProps as ElFormItemProps } from 'element-plus';
 import { type VNodeChild, type PropType } from 'vue';
 import { type MapFieldTypeComponentProps, type FieldType } from '../field';
-import { type ColProps } from '../col';
+import { type ColPublicProps } from '../col';
 export type FormItemPresetWidth = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export type FormItemWidth = number | FormItemPresetWidth | (string & {});
 export declare const mapFormItemWidth: {
@@ -11,50 +11,10 @@ export declare const mapFormItemWidth: {
     lg: number;
     xl: number;
 };
-export interface FormItemProps<T extends FieldType> extends Partial<ElFormItemProps> {
-    fieldType?: T;
-    fieldProps?: MapFieldTypeComponentProps[T]['componentProps'];
-    fieldSlots?: MapFieldTypeComponentProps[FieldType]['componentSlots'];
-    fieldRef?: (el: any) => void;
-    modelValue?: NonNullable<MapFieldTypeComponentProps[T]['componentProps']>['modelValue'] | null;
-    width?: FormItemWidth;
-    placeholder?: string;
-    disabled?: boolean;
-    readonly?: boolean;
-    colProps?: ColProps;
-    internalIndex?: number;
-    tooltip?: VNodeChild;
-    extra?: VNodeChild;
-}
-export declare const defaultFormItemProps: {
-    showMessage: boolean;
-    labelWidth: string;
-    required: undefined;
-    inlineMessage: string;
-    disabled: boolean;
-    readonly: boolean;
-};
-export declare const exlucdeFieldSlotNames: readonly ["error", "label", "default", "tooltip", "extra"];
-type ExlucdeFieldSlotNames = (typeof exlucdeFieldSlotNames)[number];
-type OptionExlucdeFieldSlotNames = `field-${ExlucdeFieldSlotNames}`;
-export type ElFormItemSlots = {
-    default?: (props: Record<string, any>) => any;
-    label?: (props: {
-        label: string;
-    }) => any;
-    error?: (props: {
-        error: string;
-    }) => any;
-    tooltip?: (props: Record<string, any>) => any;
-    extra?: (props: Record<string, any>) => any;
-} & {
-    [K in OptionExlucdeFieldSlotNames]?: (...args: any[]) => any;
-};
-export type FormItemSlots<T extends FieldType> = NonNullable<MapFieldTypeComponentProps[T]['componentSlots']> & ElFormItemSlots;
 export declare const formItemProps: {
     fieldType: {
         type: PropType<FieldType>;
-        default: string;
+        default: "input";
     };
     fieldProps: {
         type: PropType<MapFieldTypeComponentProps[FieldType]["componentProps"]>;
@@ -62,6 +22,38 @@ export declare const formItemProps: {
     fieldSlots: {
         type: PropType<MapFieldTypeComponentProps[FieldType]["componentSlots"]>;
     };
+    fieldRef: {
+        type: PropType<(el: any) => void>;
+    };
+    modelValue: {
+        type: PropType<NonNullable<MapFieldTypeComponentProps[FieldType]["componentProps"]>["modelValue"] | null>;
+    };
+    width: {
+        type: PropType<FormItemWidth>;
+    };
+    placeholder: {
+        type: StringConstructor;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colProps: {
+        type: PropType<ColPublicProps>;
+    };
+    internalIndex: {
+        type: NumberConstructor;
+    };
+    tooltip: {
+        type: PropType<VNodeChild>;
+    };
+    extra: {
+        type: PropType<VNodeChild>;
+    };
     label: StringConstructor;
     labelWidth: {
         readonly type: PropType<string | number>;
@@ -130,6 +122,38 @@ export declare const formItemProps: {
         __epPropKey: true;
     };
 };
+export interface FormItemProps<T extends FieldType> extends Partial<ElFormItemProps> {
+    fieldType?: T;
+    fieldProps?: MapFieldTypeComponentProps[T]['componentProps'];
+    fieldSlots?: MapFieldTypeComponentProps[T]['componentSlots'];
+    modelValue?: NonNullable<MapFieldTypeComponentProps[T]['componentProps']>['modelValue'] | null;
+    fieldRef?: (el: any) => void;
+    width?: FormItemWidth;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    colProps?: ColPublicProps;
+    internalIndex?: number;
+    tooltip?: VNodeChild;
+    extra?: VNodeChild;
+}
+export declare const exlucdeFieldSlotNames: readonly ["error", "label", "default", "tooltip", "extra"];
+type ExlucdeFieldSlotNames = (typeof exlucdeFieldSlotNames)[number];
+type OptionExlucdeFieldSlotNames = `field-${ExlucdeFieldSlotNames}`;
+export type ElFormItemSlots = {
+    default?: (props: Record<string, any>) => any;
+    label?: (props: {
+        label: string;
+    }) => any;
+    error?: (props: {
+        error: string;
+    }) => any;
+    tooltip?: (props: Record<string, any>) => any;
+    extra?: (props: Record<string, any>) => any;
+} & {
+    [K in OptionExlucdeFieldSlotNames]?: (...args: any[]) => any;
+};
+export type FormItemSlots<T extends FieldType> = NonNullable<MapFieldTypeComponentProps[T]['componentSlots']> & ElFormItemSlots;
 export declare const formItemPropsKeys: string[];
 export interface FormItemEmits {
     (e: 'update:modelValue', value: unknown): void;

package/components/form/{form-item.js → form-item.api.js}

@@ -7,15 +7,6 @@ const mapFormItemWidth = {
   lg: 440,
   xl: 552
 };
-const defaultFormItemProps = {
-  showMessage: true,
-  labelWidth: "",
-  required: void 0,
-  inlineMessage: "",
-  disabled: false,
-  readonly: false
-};
-const exlucdeFieldSlotNames = ["error", "label", "default", "tooltip", "extra"];
 const formItemProps = {
   ...formItemProps$1,
   fieldType: {
@@ -27,8 +18,41 @@ const formItemProps = {
   },
   fieldSlots: {
     type: Object
+  },
+  fieldRef: {
+    type: Function
+  },
+  modelValue: {
+    type: null
+  },
+  width: {
+    type: [Number, String]
+  },
+  placeholder: {
+    type: String
+  },
+  disabled: {
+    type: Boolean,
+    default: false
+  },
+  readonly: {
+    type: Boolean,
+    default: false
+  },
+  colProps: {
+    type: Object
+  },
+  internalIndex: {
+    type: Number
+  },
+  tooltip: {
+    type: null
+  },
+  extra: {
+    type: null
   }
 };
+const exlucdeFieldSlotNames = ["error", "label", "default", "tooltip", "extra"];
 const formItemPropsKeys = Object.keys(formItemProps);
 const elFormItemExposeKeys = [
   "size",
@@ -40,4 +64,4 @@ const elFormItemExposeKeys = [
 ];
 const formItemExposeKeys = [...elFormItemExposeKeys];
 
-export { defaultFormItemProps, exlucdeFieldSlotNames, formItemExposeKeys, formItemProps, formItemPropsKeys, mapFormItemWidth };
+export { exlucdeFieldSlotNames, formItemExposeKeys, formItemProps, formItemPropsKeys, mapFormItemWidth };

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

@@ -1,4 +1,4 @@
-import { type FormItemSlots, type FormItemEmits, type FormItemProps } from './form-item';
+import { type FormItemSlots, type FormItemEmits, type FormItemProps } from './form-item.api';
 import { type FieldType } from '../field';
 import { type FormItemInstance } from 'element-plus';
 declare const _default: <T extends FieldType>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{

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

@@ -1,50 +1,51 @@
-import { defineComponent, mergeDefaults, useAttrs, useSlots, inject, useTemplateRef, computed, mergeProps, resolveComponent, createBlock, openBlock, unref, withCtx, createVNode, createSlots, createElementVNode, normalizeStyle, normalizeClass, renderSlot, createElementBlock, createCommentVNode, resolveDynamicComponent, renderList, normalizeProps, guardReactiveProps } from 'vue';
-import { exlucdeFieldSlotNames, defaultFormItemProps, formItemExposeKeys } from './form-item.js';
-import { formContextSymbol } from './form.js';
+import { defineComponent, computed, useSlots, useAttrs, inject, ref, mergeProps, createBlock, openBlock, unref, withCtx, createVNode, createSlots, createElementVNode, normalizeStyle, normalizeClass, renderSlot, createElementBlock, createCommentVNode, Fragment, createTextVNode, toDisplayString } from 'vue';
+import { exlucdeFieldSlotNames, formItemExposeKeys } from './form-item.api.js';
+import { formContextSymbol } from './form.api.js';
 import { Field as _Field } from '../field/index.js';
-import { formQueryContextSymbol } from '../form-query/form-query.js';
+import { formQueryContextSymbol } from '../form-query/form-query.api.js';
 import { OptionalWrapper as _OptionalWrapper } from '../optional-wrapper/index.js';
 import { Col as _Col } from '../col/index.js';
 import stdin_default$1 from '../icon/icon.vue.js';
 import { useFormItemWidth } from './useFormItemWidth.js';
-import { ElFormItem } from 'element-plus';
+import { ElFormItem, ElTooltip } from 'element-plus';
 import { reactiveOmit } from '@vueuse/core';
 import { useToken } from '../theme/util/useToken.js';
 import { omit } from 'lodash-es';
 import { omitUndefined } from '../../utils/object.js';
-import { createMergedExpose, defineTemplate } from '../../utils/vue.js';
-import { useComponentConfig } from '../config-provider/config-provider.js';
+import { useComponentConfig } from '../config-provider/config-provider.api.js';
 import { useLocale } from '../../hooks/useLocale.js';
+import { createMergedExpose } from '../../utils/vue.js';
 import { toArray } from '../../utils/array.js';
 import { isString, isNumber } from '../../utils/is.js';
 
 var stdin_default = /* @__PURE__ */defineComponent({
   ...{
-    name: "FormItem",
+    name: "CoFormItem",
     inheritAttrs: false
   },
   __name: "form-item",
-  props: /* @__PURE__ */mergeDefaults({
+  props: {
     fieldType: {
       type: null,
       required: false
     },
     fieldProps: {
-      type: Object,
+      type: null,
       required: false
     },
     fieldSlots: {
       type: null,
       required: false
     },
-    fieldRef: {
-      type: Function,
-      required: false
-    },
     modelValue: {
       type: null,
       required: false
     },
+    fieldRef: {
+      type: Function,
+      required: false,
+      default: () => {}
+    },
     width: {
       type: [Number, String, Object],
       required: false
@@ -62,7 +63,7 @@ var stdin_default = /* @__PURE__ */defineComponent({
       required: false
     },
     colProps: {
-      type: Object,
+      type: void 0,
       required: false
     },
     internalIndex: {
@@ -127,13 +128,17 @@ var stdin_default = /* @__PURE__ */defineComponent({
       type: null,
       required: false
     }
-  }, defaultFormItemProps),
+  },
   emits: ["update:modelValue"],
   setup(__props, {
     expose: __expose,
     emit: __emit
   }) {
     const props = __props;
+    const fieldType = computed(() => props.fieldType || "input");
+    const slots = useSlots();
+    const attrs = useAttrs();
+    const emit = __emit;
     const {
       prefixCls
     } = useComponentConfig("form", props);
@@ -144,11 +149,8 @@ var stdin_default = /* @__PURE__ */defineComponent({
       t
     } = useLocale();
     const formItemProps = reactiveOmit(props, "colProps", "width", "fieldType", "fieldProps", "fieldRef", "modelValue", "placeholder", "disabled", "readonly");
-    const attrs = useAttrs();
-    const slots = useSlots();
-    const emit = __emit;
     const formContext = inject(formContextSymbol, null);
-    const formItemRef = useTemplateRef("form-item");
+    const formItemRef = ref();
     __expose(createMergedExpose(formItemExposeKeys, () => formItemRef.value));
     const formQueryContext = inject(formQueryContextSymbol, null);
     const hidden = computed(() => {
@@ -219,7 +221,6 @@ var stdin_default = /* @__PURE__ */defineComponent({
     const mergedReadonly = computed(() => {
       return formContext?.readonly || props.readonly;
     });
-    const formItemSlotNames = ["error"];
     const fieldSlots = computed(() => {
       return {
         ...Object.fromEntries(exlucdeFieldSlotNames.map(name => [name, slots[`field-${name}`]])),
@@ -227,54 +228,58 @@ var stdin_default = /* @__PURE__ */defineComponent({
         ...props.fieldSlots
       };
     });
-    const labelTemplate = defineTemplate(() => props.label);
-    const tooptipTemplate = defineTemplate(() => props.tooltip);
-    const extraTemplate = defineTemplate(() => props.extra);
     return (_ctx, _cache) => {
-      const _component_el_tooltip = resolveComponent("el-tooltip");
       return openBlock(), createBlock(unref(_OptionalWrapper), {
         when: unref(formContext)?.grid,
         component: unref(_Col),
         props: mergedColProps.value
       }, {
         default: withCtx(() => [createVNode(unref(ElFormItem), mergeProps(mergedFormItemProps.value, {
-          ref: "form-item",
+          ref_key: "formItemRef",
+          ref: formItemRef,
           class: [unref(hashId), `${unref(prefixCls)}-item`]
         }), createSlots({
+          error: withCtx(() => [renderSlot(_ctx.$slots, "error")]),
           default: withCtx(() => [createElementVNode("div", {
             class: normalizeClass(`${unref(prefixCls)}-item-content`),
             style: normalizeStyle(unref(fixedWidthStyle))
           }, [renderSlot(_ctx.$slots, "default", {}, () => [createVNode(unref(_Field), {
             readonly: mergedReadonly.value,
-            type: _ctx.fieldType,
+            type: fieldType.value,
             "component-props": mergedFieldProps.value,
             "component-slots": fieldSlots.value,
             "component-ref": _ctx.fieldRef
-          }, null, 8, ["readonly", "type", "component-props", "component-slots", "component-ref"])]), _ctx.extra || _ctx.$slots.extra ? (openBlock(), createElementBlock("div", {
+          }, null, 8, ["readonly", "type", "component-props", "component-slots", "component-ref"])]), _ctx.extra || slots.extra ? (openBlock(), createElementBlock("div", {
             key: 0,
             class: normalizeClass(`${unref(prefixCls)}-item-extra`)
-          }, [_ctx.extra ? (openBlock(), createBlock(resolveDynamicComponent(unref(extraTemplate)), {
+          }, [_ctx.extra ? (openBlock(), createElementBlock(Fragment, {
             key: 0
-          })) : renderSlot(_ctx.$slots, "extra", {
+          }, [createTextVNode(toDisplayString(_ctx.extra), 1
+          /* TEXT */)], 64
+          /* STABLE_FRAGMENT */)) : renderSlot(_ctx.$slots, "extra", {
             key: 1
           })], 2
           /* CLASS */)) : createCommentVNode("v-if", true)], 6
           /* CLASS, STYLE */)]),
           _: 2
           /* DYNAMIC */
-        }, [_ctx.label || _ctx.$slots.label ? {
+        }, [_ctx.label || slots.label ? {
           name: "label",
-          fn: withCtx(() => [_ctx.label ? (openBlock(), createBlock(resolveDynamicComponent(unref(labelTemplate)), {
+          fn: withCtx(() => [_ctx.label ? (openBlock(), createElementBlock(Fragment, {
             key: 0
-          })) : renderSlot(_ctx.$slots, "label", {
+          }, [createTextVNode(toDisplayString(_ctx.label), 1
+          /* TEXT */)], 64
+          /* STABLE_FRAGMENT */)) : renderSlot(_ctx.$slots, "label", {
             key: 1
-          }), _ctx.tooltip || _ctx.$slots.tooltip ? (openBlock(), createBlock(_component_el_tooltip, {
+          }), _ctx.tooltip || slots.tooltip ? (openBlock(), createBlock(unref(ElTooltip), {
             key: 2,
             placement: "top"
           }, {
-            content: withCtx(() => [_ctx.tooltip ? (openBlock(), createBlock(resolveDynamicComponent(unref(tooptipTemplate)), {
+            content: withCtx(() => [_ctx.tooltip ? (openBlock(), createElementBlock(Fragment, {
               key: 0
-            })) : renderSlot(_ctx.$slots, "tooltip", {
+            }, [createTextVNode(toDisplayString(_ctx.tooltip), 1
+            /* TEXT */)], 64
+            /* STABLE_FRAGMENT */)) : renderSlot(_ctx.$slots, "tooltip", {
               key: 1
             })]),
             default: withCtx(() => [createVNode(stdin_default$1, {
@@ -286,12 +291,7 @@ var stdin_default = /* @__PURE__ */defineComponent({
             /* FORWARDED */
           })) : createCommentVNode("v-if", true)]),
           key: "0"
-        } : void 0, renderList(formItemSlotNames, name => {
-          return {
-            name,
-            fn: withCtx(slotProps => [renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps)))])
-          };
-        })]), 1040, ["class"])]),
+        } : void 0]), 1040, ["class"])]),
         _: 3
         /* FORWARDED */
       }, 8, ["when", "component", "props"]);

package/components/form/form.api.d.ts

@@ -0,0 +1,173 @@
+import { type ButtonProps, FormItemProp, FormValidateCallback, FormValidationResult, FormItemContext } from 'element-plus';
+import { ExtractPropTypes, SlotsType, type PropType } from 'vue';
+import { type RowProps } from '../row';
+import { type ColProps } from '../col';
+import { type FormItemWidth } from './form-item.api';
+import { Arrayable } from '@vueuse/core';
+export declare const formProps: {
+    width: {
+        type: PropType<FormItemWidth>;
+    };
+    grid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    rowProps: {
+        type: PropType<RowProps>;
+    };
+    colProps: {
+        type: PropType<ColProps>;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    submit: {
+        type: PropType<() => any | Promise<any>>;
+    };
+    reset: {
+        type: PropType<() => any>;
+    };
+    submitText: {
+        type: StringConstructor;
+        default: string;
+    };
+    resetText: {
+        type: StringConstructor;
+        default: string;
+    };
+    submitProps: {
+        type: PropType<ButtonProps>;
+    };
+    resetProps: {
+        type: PropType<ButtonProps>;
+    };
+    hideSubmit: {
+        type: BooleanConstructor;
+    };
+    hideReset: {
+        type: BooleanConstructor;
+    };
+    model: ObjectConstructor;
+    rules: {
+        readonly type: PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    labelPosition: {
+        readonly type: PropType<"left" | "right" | "top">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "right";
+    };
+    requireAsteriskPosition: {
+        readonly type: PropType<"left" | "right">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "left";
+    };
+    labelWidth: {
+        readonly type: PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    labelSuffix: {
+        readonly type: PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    inline: BooleanConstructor;
+    inlineMessage: BooleanConstructor;
+    statusIcon: BooleanConstructor;
+    showMessage: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    validateOnRuleChange: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    hideRequiredAsterisk: BooleanConstructor;
+    scrollToError: BooleanConstructor;
+    scrollIntoViewOptions: {
+        readonly type: PropType<boolean | Record<string, any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    size: {
+        readonly type: PropType<"" | "default" | "large" | "small">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+};
+export type FormProps = ExtractPropTypes<typeof formProps>;
+export declare const formPropsOmit: readonly ["grid", "rowProps", "colProps", "width"];
+export interface FormSlots {
+    default: {};
+    button: {
+        submitting: boolean;
+        submit: () => any | Promise<any>;
+        reset: () => any;
+    };
+}
+export declare const formSlots: SlotsType<FormSlots>;
+export declare const formEmits: {
+    validate: (prop: FormItemProp, isValid: boolean, message: string) => boolean;
+};
+export type FormEmits = typeof formEmits;
+export interface FormExpose {
+    reset: () => void;
+    submit: () => Promise<any>;
+    validate: (callback?: FormValidateCallback) => FormValidationResult;
+    validateField: (props?: Arrayable<FormItemProp>, callback?: FormValidateCallback) => FormValidationResult;
+    resetFields: (props?: Arrayable<FormItemProp>) => void;
+    clearValidate: (props?: Arrayable<FormItemProp>) => void;
+    scrollToField: (prop: FormItemProp) => void;
+    fields: FormItemContext[];
+}
+export declare const formExposeKeys: string[];
+export interface FormContext {
+    colProps?: ColProps;
+    grid?: boolean;
+    readonly?: boolean;
+    width?: FormItemWidth;
+    addResetField: (reset: () => void) => void;
+    removeResetField: (reset: () => void) => void;
+}
+export declare const formContextSymbol: unique symbol;
+export interface FormBubbleData {
+    readonly: boolean;
+    submitting: boolean;
+    submit: (throwError?: boolean, shouldReset?: boolean) => any | Promise<any>;
+    reset: () => any;
+    resetFields: () => any;
+    clearValidate: () => any;
+}
+export interface FormBubbleContext {
+    setFormBubbleData: (data: FormBubbleData) => void;
+}
+export declare const formBubbleContextSymbol: unique symbol;

package/components/form/form.api.js

@@ -0,0 +1,66 @@
+import { formEmits as formEmits$1, formProps as formProps$1 } from 'element-plus';
+
+const formProps = {
+  ...formProps$1,
+  width: {
+    type: [String, Number]
+  },
+  grid: {
+    type: Boolean,
+    default: false
+  },
+  rowProps: {
+    type: Object
+  },
+  colProps: {
+    type: Object
+  },
+  readonly: {
+    type: Boolean,
+    default: false
+  },
+  submit: {
+    type: Function
+  },
+  reset: {
+    type: Function
+  },
+  submitText: {
+    type: String,
+    default: "co.form.submit"
+  },
+  resetText: {
+    type: String,
+    default: "co.form.reset"
+  },
+  submitProps: {
+    type: Object
+  },
+  resetProps: {
+    type: Object
+  },
+  hideSubmit: {
+    type: Boolean
+  },
+  hideReset: {
+    type: Boolean
+  }
+};
+const formPropsOmit = ["grid", "rowProps", "colProps", "width"];
+const formSlots = Object;
+const formEmits = {
+  ...formEmits$1
+};
+const elFormExposeKeys = [
+  "validate",
+  "validateField",
+  "resetFields",
+  "scrollToField",
+  "clearValidate",
+  "fields"
+];
+const formExposeKeys = [...elFormExposeKeys, "submit", "reset"];
+const formContextSymbol = Symbol("form");
+const formBubbleContextSymbol = Symbol("formBubble");
+
+export { formBubbleContextSymbol, formContextSymbol, formEmits, formExposeKeys, formProps, formPropsOmit, formSlots };