@vunk/form 0.0.1-alpha.4 → 0.0.1-alpha.41

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

@@ -0,0 +1,77 @@
+import { RadioProps } from '@vunk/form/shared/types/form';
+import { PropType } from 'vue';
+export declare const props: {
+    options: {
+        type: PropType<RadioProps[]>;
+        default: () => never[];
+    };
+    type: {
+        type: PropType<"default" | "button">;
+        default: string;
+    };
+    modelValue: {
+        type: PropType<string | number>;
+    };
+    defaultModelValue: null;
+    id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, 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;
+    fill: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    textColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    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;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+};
+export declare const emits: {
+    "update:modelValue": (val: string | number | boolean) => boolean;
+    change: (val: string | number | boolean) => boolean;
+};

package/components/radio/src/ctx.js

@@ -0,0 +1,39 @@
+import { _VkfFormItemCtx } from '@vunk/form/components/form-item';
+import { radioGroupProps, radioGroupEmits } 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), radioGroupProps), {
+  options: {
+    type: Array,
+    default: () => []
+  },
+  type: {
+    type: String,
+    default: "default"
+  },
+  modelValue: {
+    type: [String, Number]
+  },
+  defaultModelValue: null
+});
+const emits = __spreadValues({}, radioGroupEmits);
+
+export { emits, props };

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

@@ -0,0 +1,204 @@
+declare const _default: import("vue").DefineComponent<{
+    options: {
+        type: import("vue").PropType<import("../../../shared/types/form").RadioProps[]>;
+        default: () => never[];
+    };
+    type: {
+        type: import("vue").PropType<"default" | "button">;
+        default: string;
+    };
+    modelValue: {
+        type: import("vue").PropType<string | number>;
+    };
+    defaultModelValue: null;
+    id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, 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;
+    fill: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    textColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    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;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}, {
+    formItemBindProps: 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;
+        readonly: boolean | undefined;
+    }>;
+    coreBindProps: import("vue").ComputedRef<{
+        label: string | undefined;
+        size: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never> | undefined;
+        fill: string;
+        name: string | undefined;
+        id: string | undefined;
+        validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        modelValue: string | number | undefined;
+        textColor: string;
+    }>;
+    coreOnEmits: {
+        change: (val: string | number | boolean) => void;
+        "update:modelValue": (val: string | number | boolean) => void;
+    };
+    options: import("vue").ComputedRef<import("../../../shared/types/form").RadioProps[]>;
+    pickObject: <T extends import("@vunk/core").NormalObject, EX extends (keyof T)[] | undefined, KI extends keyof T>(data: T, opts?: {
+        excludes?: EX | undefined;
+        includes?: KI[] | undefined;
+    } | undefined) => { [P in EX extends (infer KE)[] ? Exclude<KI, KE> : KI]: T[P]; };
+    readonly: import("vue").ComputedRef<boolean>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (val: string | number | boolean) => boolean;
+    change: (val: string | number | boolean) => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    options: {
+        type: import("vue").PropType<import("../../../shared/types/form").RadioProps[]>;
+        default: () => never[];
+    };
+    type: {
+        type: import("vue").PropType<"default" | "button">;
+        default: string;
+    };
+    modelValue: {
+        type: import("vue").PropType<string | number>;
+    };
+    defaultModelValue: null;
+    id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, 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;
+    fill: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    textColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    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;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((val: string | number | boolean) => any) | undefined;
+    onChange?: ((val: string | number | boolean) => any) | undefined;
+}, {
+    required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    type: "default" | "button";
+    label: string;
+    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;
+    readonly: boolean;
+    fill: string;
+    name: string;
+    disabled: boolean;
+    id: string;
+    validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    options: import("../../../shared/types/form").RadioProps[];
+    textColor: string;
+}>;
+export default _default;

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

@@ -0,0 +1 @@
+export {};

package/components/radio/src/types.js

@@ -0,0 +1 @@
+

package/components/select/index.css

@@ -0,0 +1,11 @@
+
+.el-select.is-readonly{
+  --el-readonly-cursor: text;
+  --el-disabled-bg-color: initial;
+  --el-disabled-text-color: var(--el-input-text-color);
+}
+.el-select.is-readonly .el-input.is-disabled .el-input__inner,
+.el-select.is-readonly .el-input.is-disabled .el-select__caret,
+.el-select.is-readonly .el-input.is-disabled .el-input__wrapper{
+  cursor: var(--el-readonly-cursor);
+}

package/components/select/index.js

@@ -1,39 +1,9 @@
 import { _VkfFormItemCtx, VkfFormItem } from '@vunk/form/components/form-item';
 import { selectProps, selectEmits, createSelectBindProps, createSelectOnEmits } from '@vunk/form/shared/element-plus';
-import { defineComponent, computed, resolveComponent, openBlock, createBlock, normalizeProps, guardReactiveProps, withCtx, createVNode, mergeProps, toHandlers, createSlots, createElementBlock, Fragment, renderList, renderSlot, resolveDynamicComponent } from 'vue';
+import { defineComponent, ref, watch, computed, nextTick, resolveComponent, openBlock, createBlock, normalizeProps, guardReactiveProps, withCtx, mergeProps, toHandlers, createSlots, createElementBlock, Fragment, renderList, renderSlot, resolveDynamicComponent, createCommentVNode } from 'vue';
 import { ElSelect, ElOption } from 'element-plus';
 import { isPlainObject } from '@vunk/core/shared/utils-object';
-
-var __defProp$1 = Object.defineProperty;
-var __defProps$1 = Object.defineProperties;
-var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$1 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$1.call(b, prop))
-      __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b)) {
-      if (__propIsEnum$1.call(b, prop))
-        __defNormalProp$1(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
-const props = __spreadProps$1(__spreadValues$1(__spreadValues$1({}, _VkfFormItemCtx.props), selectProps), {
-  options: {
-    type: Array,
-    default: () => []
-  },
-  selectSlots: {
-    type: Object,
-    default: void 0
-  }
-});
-const emits = __spreadValues$1({}, selectEmits);
+import { useComputedReadonly } from '@vunk/form/composables';
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -54,7 +24,31 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var script = defineComponent({
+const props = __spreadProps(__spreadValues(__spreadValues({}, _VkfFormItemCtx.props), selectProps), {
+  options: {
+    type: Array,
+    default: () => []
+  },
+  selectSlots: {
+    type: Object,
+    default: void 0
+  },
+  optionsUrl: {
+    type: String,
+    default: ""
+  }
+});
+const emits = __spreadValues({}, selectEmits);
+
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const _sfc_main = defineComponent({
   name: "VkfSelect",
   components: {
     VkfFormItem,
@@ -65,36 +59,64 @@ var script = defineComponent({
   props,
   setup(props2, { emit }) {
     const formItemBindProps = _VkfFormItemCtx.createBindProps(props2);
-    const selectBindProps = createSelectBindProps(props2);
+    const selectBindProps = createSelectBindProps(props2, ["disabled"]);
     const selectOnEmits = createSelectOnEmits(emit);
+    const readonly = useComputedReadonly(props2);
+    const optionsFromUrl = ref([]);
+    watch(() => props2.optionsUrl, (url) => {
+      emit("update:modelValue", void 0);
+      if (url) {
+        fetch(url).then((res) => res.json()).then((data) => {
+          optionsFromUrl.value = data;
+        });
+      } else {
+        optionsFromUrl.value = [];
+      }
+    }, { immediate: true });
     const getKey = (item) => isPlainObject(item.value) ? item.value[selectBindProps.value.valueKey] : item.value;
     const selectOptions = computed(() => {
-      return props2.options.reduce((a, c) => {
+      const options = optionsFromUrl.value.length ? optionsFromUrl.value : props2.options;
+      return options.reduce((a, c) => {
         const k = getKey(c);
         if (!k && k !== 0)
           return a;
-        a.push(__spreadProps(__spreadValues({}, c), {
+        a.push({
+          ...c,
           key: k
-        }));
+        });
         return a;
       }, []);
     });
+    const reshow = ref(true);
+    watch(() => selectBindProps.value.multiple, () => {
+      emit("update:modelValue", void 0);
+      reshow.value = false;
+      nextTick(() => {
+        reshow.value = true;
+      });
+    });
     return {
       formItemBindProps,
       selectBindProps,
       selectOnEmits,
-      selectOptions
+      selectOptions,
+      reshow,
+      readonly
     };
   }
 });
-
-function render(_ctx, _cache, $props, $setup, $data, $options) {
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_ElOption = resolveComponent("ElOption");
   const _component_ElSelect = resolveComponent("ElSelect");
   const _component_VkfFormItem = resolveComponent("VkfFormItem");
   return openBlock(), createBlock(_component_VkfFormItem, normalizeProps(guardReactiveProps(_ctx.formItemBindProps)), {
     default: withCtx(() => [
-      createVNode(_component_ElSelect, mergeProps(_ctx.selectBindProps, toHandlers(_ctx.selectOnEmits)), createSlots({
+      _ctx.reshow ? (openBlock(), createBlock(_component_ElSelect, mergeProps({ key: 0 }, _ctx.selectBindProps, toHandlers(_ctx.selectOnEmits), {
+        disabled: _ctx.readonly || _ctx.disabled,
+        class: {
+          "is-readonly": _ctx.readonly
+        }
+      }), createSlots({
         default: withCtx(() => [
           (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.selectOptions, (item) => {
             return openBlock(), createBlock(_component_ElOption, mergeProps(item, {
@@ -109,25 +131,23 @@ function render(_ctx, _cache, $props, $setup, $data, $options) {
           return {
             name: key,
             fn: withCtx((e) => [
-              (openBlock(), createBlock(resolveDynamicComponent(item == null ? void 0 : item(e))))
+              (openBlock(), createBlock(resolveDynamicComponent(item?.(e))))
             ])
           };
         })
-      ]), 1040)
+      ]), 1040, ["disabled", "class"])) : createCommentVNode("v-if", true)
     ]),
     _: 3
   }, 16);
 }
-
-script.render = render;
-script.__file = "select/src/index.vue";
+var VkfSelect = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "index.vue"]]);
 
 var types = /*#__PURE__*/Object.freeze({
   __proto__: null
 });
 
-script.install = (app) => {
-  app.component(script.name, script);
+VkfSelect.install = (app) => {
+  app.component(VkfSelect.name, VkfSelect);
 };
 
-export { script as VkfSelect, types as __VkfSelect, script as default };
+export { VkfSelect, types as __VkfSelect, VkfSelect as default };