@vunk/form 0.0.1-alpha.2 → 0.0.1-alpha.20

package/components/button/index.d.ts

@@ -0,0 +1,4 @@
+import VkfButton from './src/index.vue';
+export * as __VkfButton from './src/types';
+export { VkfButton, };
+export default VkfButton;

package/components/button/index.js

@@ -0,0 +1,121 @@
+import { _VkfFormItemCtx, VkfFormItem } from '@vunk/form/components/form-item';
+import { buttonProps, buttonEmits, ElButton, ElMessage } from 'element-plus';
+import { defineComponent, inject, resolveComponent, openBlock, createBlock, normalizeProps, guardReactiveProps, withCtx, createVNode, mergeProps, toHandlers, createSlots, renderSlot, createTextVNode, toDisplayString, renderList, resolveDynamicComponent } from 'vue';
+import { createButtonBindProps, createButtonOnEmits } from '@vunk/form/shared/element-plus';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues(__spreadValues({}, _VkfFormItemCtx.props), buttonProps), {
+  buttonSlots: {
+    type: Object,
+    default: () => ({})
+  },
+  buttonLabel: {
+    type: String,
+    default: ""
+  },
+  validate: {
+    type: Boolean,
+    default: true
+  }
+});
+const emits = __spreadValues({}, buttonEmits);
+
+var script = defineComponent({
+  name: "VkfButton",
+  components: {
+    VkfFormItem,
+    ElButton
+  },
+  emits,
+  props,
+  setup(props2, { emit }) {
+    const coreBindProps = createButtonBindProps(props2);
+    const coreOnEmits = createButtonOnEmits(emit, ["click"]);
+    const formBindProps = _VkfFormItemCtx.createBindProps(props2);
+    const elFormRef = inject("elFormRef", null);
+    const handleClick = (e) => {
+      if (!elFormRef || !props2.validate)
+        return emit("click", e);
+      elFormRef.value.validate().then((flag) => {
+        if (flag) {
+          emit("click", e);
+        }
+      }).catch((err) => {
+        let msg = "";
+        for (const key in err) {
+          err[key].forEach((v) => {
+            msg += v.message + ";";
+          });
+        }
+        ElMessage({
+          type: "warning",
+          message: msg
+        });
+      });
+    };
+    return {
+      formBindProps,
+      coreBindProps,
+      coreOnEmits,
+      handleClick
+    };
+  }
+});
+
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElButton = resolveComponent("ElButton");
+  const _component_VkfFormItem = resolveComponent("VkfFormItem");
+  return openBlock(), createBlock(_component_VkfFormItem, normalizeProps(guardReactiveProps(_ctx.formBindProps)), {
+    default: withCtx(() => [
+      createVNode(_component_ElButton, mergeProps(_ctx.coreBindProps, toHandlers(_ctx.coreOnEmits), { onClick: _ctx.handleClick }), createSlots({
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", {}, () => [
+            createTextVNode(toDisplayString(_ctx.buttonLabel), 1)
+          ])
+        ]),
+        _: 2
+      }, [
+        renderList(_ctx.buttonSlots, (item, key) => {
+          return {
+            name: key,
+            fn: withCtx((e) => [
+              (openBlock(), createBlock(resolveDynamicComponent(item == null ? void 0 : item(e))))
+            ])
+          };
+        })
+      ]), 1040, ["onClick"])
+    ]),
+    _: 3
+  }, 16);
+}
+
+script.render = render;
+script.__file = "button/src/index.vue";
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+script.install = (app) => {
+  app.component(script.name, script);
+};
+
+export { script as VkfButton, types as __VkfButton, script as default };

package/components/button/src/ctx.d.ts

@@ -0,0 +1,82 @@
+import { PropType } from 'vue';
+import { ButtonSlots } from './types';
+export declare const props: {
+    buttonSlots: {
+        type: PropType<ButtonSlots>;
+        default: () => {};
+    };
+    buttonLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    validate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+    type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "success" | "text" | "primary" | "warning" | "info" | "danger", unknown, "", boolean>;
+    icon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown, "", boolean>;
+    nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "submit" | "reset", unknown, "button", boolean>;
+    loading: BooleanConstructor;
+    loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown, () => import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>, boolean>;
+    plain: BooleanConstructor;
+    text: BooleanConstructor;
+    link: BooleanConstructor;
+    bg: BooleanConstructor;
+    autofocus: BooleanConstructor;
+    round: BooleanConstructor;
+    circle: BooleanConstructor;
+    color: StringConstructor;
+    dark: BooleanConstructor;
+    autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    label: StringConstructor;
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    prop: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rules: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    formItemSize: {
+        type: PropType<"default" | "small" | "large">;
+        default: string;
+    };
+    formItemSlots: {
+        type: PropType<import("../../form-item/src/types").FormItemSlots>;
+        default: undefined;
+    };
+    elRef: {
+        type: PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare const emits: {
+    click: (evt: MouseEvent) => boolean;
+};

package/components/button/src/ctx.js

@@ -0,0 +1,39 @@
+import { _VkfFormItemCtx } from '@vunk/form/components/form-item';
+import { buttonProps, buttonEmits } from 'element-plus';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues(__spreadValues({}, _VkfFormItemCtx.props), buttonProps), {
+  buttonSlots: {
+    type: Object,
+    default: () => ({})
+  },
+  buttonLabel: {
+    type: String,
+    default: ""
+  },
+  validate: {
+    type: Boolean,
+    default: true
+  }
+});
+const emits = __spreadValues({}, buttonEmits);
+
+export { emits, props };

package/components/button/src/index.vue.d.ts

@@ -0,0 +1,222 @@
+declare const _default: import("vue").DefineComponent<{
+    buttonSlots: {
+        type: import("vue").PropType<import("./types").ButtonSlots>;
+        default: () => {};
+    };
+    buttonLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    validate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+    type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "success" | "text" | "primary" | "warning" | "info" | "danger", unknown, "", boolean>;
+    icon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown, "", boolean>;
+    nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "submit" | "reset", unknown, "button", boolean>;
+    loading: BooleanConstructor;
+    loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown, () => import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>, boolean>;
+    plain: BooleanConstructor;
+    text: BooleanConstructor;
+    link: BooleanConstructor;
+    bg: BooleanConstructor;
+    autofocus: BooleanConstructor;
+    round: BooleanConstructor;
+    circle: BooleanConstructor;
+    color: StringConstructor;
+    dark: BooleanConstructor;
+    autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    label: StringConstructor;
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: string;
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("../../form-item/src/types").FormItemSlots>;
+        default: undefined;
+    };
+    elRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    formBindProps: import("vue").ComputedRef<{
+        required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
+        label: string | undefined;
+        labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+        prop: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown> | undefined;
+        rules: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown> | undefined;
+        error: string | undefined;
+        validateStatus: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
+        for: string | undefined;
+        inlineMessage: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
+        showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        formItemSize: "default" | "small" | "large";
+        formItemSlots: import("../../form-item/src/types").FormItemSlots | undefined;
+        elRef: any;
+        inline: boolean;
+    }>;
+    coreBindProps: import("vue").ComputedRef<{
+        type: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "success" | "text" | "primary" | "warning" | "info" | "danger", unknown>;
+        size: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never> | undefined;
+        link: boolean;
+        disabled: boolean;
+        icon: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>;
+        nativeType: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "button" | "submit" | "reset", unknown>;
+        loading: boolean;
+        loadingIcon: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>;
+        plain: boolean;
+        text: boolean;
+        bg: boolean;
+        autofocus: boolean;
+        round: boolean;
+        circle: boolean;
+        color: string | undefined;
+        dark: boolean;
+        autoInsertSpace: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
+    }>;
+    coreOnEmits: {};
+    handleClick: (e: MouseEvent) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (evt: MouseEvent) => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    buttonSlots: {
+        type: import("vue").PropType<import("./types").ButtonSlots>;
+        default: () => {};
+    };
+    buttonLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    validate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+    type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "success" | "text" | "primary" | "warning" | "info" | "danger", unknown, "", boolean>;
+    icon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown, "", boolean>;
+    nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "submit" | "reset", unknown, "button", boolean>;
+    loading: BooleanConstructor;
+    loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown, () => import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>, boolean>;
+    plain: BooleanConstructor;
+    text: BooleanConstructor;
+    link: BooleanConstructor;
+    bg: BooleanConstructor;
+    autofocus: BooleanConstructor;
+    round: BooleanConstructor;
+    circle: BooleanConstructor;
+    color: StringConstructor;
+    dark: BooleanConstructor;
+    autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    label: StringConstructor;
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: string;
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("../../form-item/src/types").FormItemSlots>;
+        default: undefined;
+    };
+    elRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onClick?: ((evt: MouseEvent) => any) | undefined;
+}, {
+    required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    type: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "success" | "text" | "primary" | "warning" | "info" | "danger", unknown>;
+    labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+    inlineMessage: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
+    showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    formItemSize: "default" | "small" | "large";
+    formItemSlots: import("../../form-item/src/types").FormItemSlots;
+    inline: boolean;
+    link: boolean;
+    validate: boolean;
+    disabled: boolean;
+    icon: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>;
+    nativeType: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "button" | "submit" | "reset", unknown>;
+    loading: boolean;
+    loadingIcon: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>;
+    plain: boolean;
+    text: boolean;
+    bg: boolean;
+    autofocus: boolean;
+    round: boolean;
+    circle: boolean;
+    dark: boolean;
+    autoInsertSpace: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    buttonSlots: import("./types").ButtonSlots;
+    buttonLabel: string;
+}>;
+export default _default;

package/components/button/src/types.d.ts

@@ -0,0 +1,7 @@
+import { Func } from '@vunk/core';
+export interface ButtonSlots {
+    loading: Func;
+    icon: Func;
+    default: Func;
+}
+export {};

package/components/button/src/types.js

@@ -0,0 +1 @@
+

package/components/checkbox/index.d.ts

@@ -0,0 +1,4 @@
+import VkfCheckbox from './src/index.vue';
+export * as __VkfCheckbox from './src/types';
+export { VkfCheckbox, };
+export default VkfCheckbox;

package/components/checkbox/index.js

@@ -0,0 +1,116 @@
+import { _VkfFormItemCtx, VkfFormItem } from '@vunk/form/components/form-item';
+import { useCheckboxGroupProps, checkboxGroupEmits, ElCheckbox, ElCheckboxGroup, ElCheckboxButton } from 'element-plus';
+import { defineComponent, computed, resolveComponent, openBlock, createBlock, normalizeProps, guardReactiveProps, withCtx, createVNode, mergeProps, toHandlers, createElementBlock, Fragment, renderList, resolveDynamicComponent, createTextVNode, toDisplayString } from 'vue';
+import { createCheckboxGroupBindProps, createCheckboxGroupOnEmits } from '@vunk/form/shared/element-plus';
+import { pickObject } from '@vunk/core/shared/utils-object';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues(__spreadValues({}, _VkfFormItemCtx.props), useCheckboxGroupProps), {
+  options: {
+    type: Array,
+    default: () => []
+  },
+  type: {
+    type: String,
+    default: "default"
+  },
+  defaultModelValue: {
+    type: Array,
+    default: void 0
+  },
+  modelValue: {
+    type: Array,
+    default: void 0
+  }
+});
+const emits = __spreadValues({}, checkboxGroupEmits);
+
+var script = defineComponent({
+  name: "VkfCheckbox",
+  components: {
+    VkfFormItem,
+    ElCheckbox,
+    ElCheckboxGroup,
+    ElCheckboxButton
+  },
+  emits,
+  props,
+  setup(props2, { emit }) {
+    const formItemBindProps = _VkfFormItemCtx.createBindProps(props2);
+    const coreBindProps = createCheckboxGroupBindProps(props2);
+    const coreOnEmits = createCheckboxGroupOnEmits(emit);
+    const options = computed(() => {
+      return props2.options.filter((item) => item.value !== void 0 && item.value !== null);
+    });
+    !props2.modelValue && props2.defaultModelValue && emit("update:modelValue", props2.defaultModelValue);
+    return {
+      formItemBindProps,
+      coreBindProps,
+      coreOnEmits,
+      options,
+      pickObject
+    };
+  }
+});
+
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElCheckboxGroup = resolveComponent("ElCheckboxGroup");
+  const _component_VkfFormItem = resolveComponent("VkfFormItem");
+  return openBlock(), createBlock(_component_VkfFormItem, normalizeProps(guardReactiveProps(_ctx.formItemBindProps)), {
+    default: withCtx(() => [
+      createVNode(_component_ElCheckboxGroup, mergeProps(_ctx.coreBindProps, toHandlers(_ctx.coreOnEmits)), {
+        default: withCtx(() => [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.options, (item) => {
+            return openBlock(), createBlock(resolveDynamicComponent(_ctx.type === "button" ? "ElCheckboxButton" : "ElCheckbox"), mergeProps({
+              key: item.value,
+              label: item.value
+            }, _ctx.pickObject(item, {
+              excludes: ["label", "value"]
+            })), {
+              default: withCtx(() => {
+                var _a;
+                return [
+                  createTextVNode(toDisplayString((_a = item.label) != null ? _a : item.value), 1)
+                ];
+              }),
+              _: 2
+            }, 1040, ["label"]);
+          }), 128))
+        ]),
+        _: 1
+      }, 16)
+    ]),
+    _: 1
+  }, 16);
+}
+
+script.render = render;
+script.__file = "checkbox/src/index.vue";
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+script.install = (app) => {
+  app.component(script.name, script);
+};
+
+export { script as VkfCheckbox, types as __VkfCheckbox, script as default };