@vunk/form 0.0.1-alpha.9 → 1.0.1

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;
+        modelValue: string | number | undefined;
+        validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        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;
+    };
+}>> & {
+    onChange?: ((val: string | number | boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((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,8 @@
+import { BasicSource } from '@vunk/form/shared';
+import { VueComponentPropsType } from '@vunk/core';
+import VkfRadio from './index.vue';
+export interface Source<P extends string = string> extends VueComponentPropsType<typeof VkfRadio>, BasicSource {
+    prop: P;
+    templateType: 'VkfRadio';
+}
+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,70 @@ 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([]);
+    const rUrlOptions = (url) => {
+      if (url) {
+        fetch(url).then((res) => res.json()).then((data) => {
+          optionsFromUrl.value = data;
+        });
+      } else {
+        optionsFromUrl.value = [];
+      }
+    };
+    if (props2.optionsUrl) {
+      rUrlOptions(props2.optionsUrl);
+    }
+    watch(() => props2.optionsUrl, (url) => {
+      emit("update:modelValue", void 0);
+      rUrlOptions(url);
+    });
     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 +137,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 };

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

@@ -17,15 +17,15 @@ export declare const props: {
         }, {
             ns: {
                 namespace: import("vue").ComputedRef<string>;
-                b: (blockSuffix?: string) => string;
-                e: (element?: string) => string;
-                m: (modifier?: string) => string;
-                be: (blockSuffix?: string, element?: string) => string;
-                em: (element?: string, modifier?: string) => string;
-                bm: (blockSuffix?: string, modifier?: string) => string;
-                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                b: (blockSuffix?: string | undefined) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
                 is: {
-                    (name: string, state: boolean): string;
+                    (name: string, state: boolean | undefined): string;
                     (name: string): string;
                 };
                 cssVar: (object: Record<string, string>) => Record<string, string>;
@@ -36,7 +36,7 @@ export declare const props: {
             currentLabel: import("vue").ComputedRef<any>;
             itemSelected: import("vue").ComputedRef<boolean>;
             isDisabled: import("vue").ComputedRef<any>;
-            select: import("element-plus").SelectContext;
+            select: import("element-plus").SelectContext | undefined;
             hoverItem: () => void;
             visible: import("vue").Ref<boolean>;
             hover: import("vue").Ref<boolean>;
@@ -63,17 +63,21 @@ export declare const props: {
             disabled: boolean;
             created: boolean;
         }>>>[]>;
-        default: () => any[];
+        default: () => never[];
     };
     selectSlots: {
         type: PropType<SelectSlots>;
-        default: any;
+        default: undefined;
+    };
+    optionsUrl: {
+        type: StringConstructor;
+        default: string;
     };
     name: StringConstructor;
     id: StringConstructor;
     modelValue: {
         type: (BooleanConstructor | ObjectConstructor | StringConstructor | NumberConstructor | ArrayConstructor)[];
-        default: any;
+        default: undefined;
     };
     autocomplete: {
         type: StringConstructor;
@@ -145,7 +149,7 @@ export declare const props: {
         default: string;
         type: PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "success" | "warning" | "info" | "danger", unknown>>;
         required: false;
-        validator: (val: unknown) => boolean;
+        validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
@@ -154,20 +158,20 @@ export declare const props: {
     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;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     rules: {
-        readonly type: PropType<unknown>;
+        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;
+        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;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     for: StringConstructor;
@@ -179,19 +183,27 @@ export declare const props: {
     };
     formItemSlots: {
         type: PropType<import("../../form-item/src/types").FormItemSlots>;
-        default: any;
+        default: undefined;
     };
     elRef: {
         type: PropType<any>;
         required: boolean;
     };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
 };
 export declare const emits: {
-    'update:modelValue': any;
-    change: any;
-    'remove-tag': any;
-    clear: any;
-    'visible-change': any;
-    focus: any;
-    blur: any;
+    'update:modelValue': null;
+    change: null;
+    'remove-tag': null;
+    clear: null;
+    'visible-change': null;
+    focus: null;
+    blur: null;
 };

package/components/select/src/ctx.js

@@ -28,6 +28,10 @@ const props = __spreadProps(__spreadValues(__spreadValues({}, _VkfFormItemCtx.pr
   selectSlots: {
     type: Object,
     default: void 0
+  },
+  optionsUrl: {
+    type: String,
+    default: ""
   }
 });
 const emits = __spreadValues({}, selectEmits);