@vunk/form 0.0.0-alpha.9 → 0.0.1-alpha.11

package/components/switch/index.js

@@ -1,9 +1,11 @@
-import { formItemProps, switchProps, switchEmits, ElSwitch } from 'element-plus';
+import { switchProps, switchEmits, ElSwitch } from 'element-plus';
+import { _VkfFormItemCtx, VkfFormItem } from '@vunk/form/components/form-item';
 import { defineComponent, resolveComponent, openBlock, createBlock, normalizeProps, guardReactiveProps, withCtx, createVNode, mergeProps, toHandlers, renderSlot } from 'vue';
-import { VkfFormItem, _VkfFormItemCtx } from '@vunk/form/components/form-item';
-import { createSwitchBindProps, createSwitchOnEmits } from '@vunk/form/shared/element-plus/ctx';
+import { createSwitchBindProps, createSwitchOnEmits } 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;
@@ -19,7 +21,17 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const props = __spreadValues(__spreadValues({}, formItemProps), switchProps);
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues(__spreadValues({}, _VkfFormItemCtx.props), switchProps), {
+  modelValue: {
+    type: Boolean,
+    default: void 0
+  },
+  defaultModelValue: {
+    type: Boolean,
+    default: false
+  }
+});
 const emits = __spreadValues({}, switchEmits);
 
 var script = defineComponent({
@@ -32,7 +44,7 @@ var script = defineComponent({
   props,
   setup(props2, { emit }) {
     const formItemBindProps = _VkfFormItemCtx.createBindProps(props2);
-    const switchBindProps = createSwitchBindProps(props2);
+    const switchBindProps = createSwitchBindProps(props2, ["modelValue"]);
     const switchOnEmits = createSwitchOnEmits(emit);
     return {
       formItemBindProps,
@@ -46,14 +58,19 @@ function render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_ElSwitch = resolveComponent("ElSwitch");
   const _component_VkfFormItem = resolveComponent("VkfFormItem");
   return openBlock(), createBlock(_component_VkfFormItem, normalizeProps(guardReactiveProps(_ctx.formItemBindProps)), {
-    default: withCtx(() => [
-      createVNode(_component_ElSwitch, mergeProps(_ctx.switchBindProps, toHandlers(_ctx.switchOnEmits)), {
-        default: withCtx(() => [
-          renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-      }, 16)
-    ]),
+    default: withCtx(() => {
+      var _a;
+      return [
+        createVNode(_component_ElSwitch, mergeProps({
+          modelValue: (_a = _ctx.modelValue) != null ? _a : _ctx.defaultModelValue
+        }, _ctx.switchBindProps, toHandlers(_ctx.switchOnEmits)), {
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "default")
+          ]),
+          _: 3
+        }, 16, ["modelValue"])
+      ];
+    }),
     _: 3
   }, 16);
 }

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

@@ -1,5 +1,12 @@
 export declare const props: {
-    modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultModelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     value: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
     disabled: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
     width: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
@@ -20,46 +27,58 @@ export declare const props: {
     beforeChange: {
         readonly type: import("vue").PropType<() => boolean | Promise<boolean>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     size: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("" | "default" | "small" | "large") & {}) | (() => "" | "default" | "small" | "large") | ((new (...args: any[]) => ("" | "default" | "small" | "large") & {}) | (() => "" | "default" | "small" | "large"))[], unknown, "" | "default" | "small" | "large">>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     tabindex: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
+    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;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
-    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
     rules: {
-        readonly type: import("vue").PropType<unknown>;
+        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;
+        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;
+        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;
+    };
 };
 export declare const emits: {
     "update:modelValue": (val: string | number | boolean) => boolean;

package/components/switch/src/ctx.js

@@ -0,0 +1,35 @@
+import { switchProps, switchEmits } from 'element-plus';
+import { _VkfFormItemCtx } from '@vunk/form/components/form-item';
+
+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), switchProps), {
+  modelValue: {
+    type: Boolean,
+    default: void 0
+  },
+  defaultModelValue: {
+    type: Boolean,
+    default: false
+  }
+});
+const emits = __spreadValues({}, switchEmits);
+
+export { emits, props };

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

@@ -1,5 +1,12 @@
 declare const _default: import("vue").DefineComponent<{
-    modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultModelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     value: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
     disabled: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
     width: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
@@ -20,60 +27,114 @@ declare const _default: import("vue").DefineComponent<{
     beforeChange: {
         readonly type: import("vue").PropType<() => boolean | Promise<boolean>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     size: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("" | "default" | "small" | "large") & {}) | (() => "" | "default" | "small" | "large") | ((new (...args: any[]) => ("" | "default" | "small" | "large") & {}) | (() => "" | "default" | "small" | "large"))[], unknown, "" | "default" | "small" | "large">>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     tabindex: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
+    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;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
-    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
     rules: {
-        readonly type: import("vue").PropType<unknown>;
+        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;
+        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;
+        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;
+    };
 }, {
-    formItemBindProps: import("vue").ComputedRef<{}>;
-    switchBindProps: import("vue").ComputedRef<{}>;
+    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;
+    }>;
+    switchBindProps: import("vue").ComputedRef<{
+        size: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("" | "default" | "small" | "large") & {}) | (() => "" | "default" | "small" | "large") | ((new (...args: any[]) => ("" | "default" | "small" | "large") & {}) | (() => "" | "default" | "small" | "large"))[], unknown, "" | "default" | "small" | "large"> | undefined;
+        name: string;
+        value: import("element-plus/es/utils").EpPropMergeType<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        tabindex: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown> | undefined;
+        validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        id: string | undefined;
+        disabled: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        width: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+        inlinePrompt: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        activeIcon: 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>;
+        inactiveIcon: 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>;
+        activeText: string;
+        inactiveText: string;
+        activeColor: string;
+        inactiveColor: string;
+        borderColor: string;
+        activeValue: import("element-plus/es/utils").EpPropMergeType<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        inactiveValue: import("element-plus/es/utils").EpPropMergeType<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        loading: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        beforeChange: (() => boolean | Promise<boolean>) | undefined;
+    }>;
     switchOnEmits: {
-        "update:modelValue": ((event: "update:modelValue", val: string | number | boolean) => void) & ((event: "change", val: string | number | boolean) => void) & ((event: "input", val: string | number | boolean) => void);
-        change: ((event: "update:modelValue", val: string | number | boolean) => void) & ((event: "change", val: string | number | boolean) => void) & ((event: "input", val: string | number | boolean) => void);
-        input: ((event: "update:modelValue", val: string | number | boolean) => void) & ((event: "change", val: string | number | boolean) => void) & ((event: "input", val: string | number | boolean) => void);
+        "update:modelValue": (val: string | number | boolean) => void;
+        change: (val: string | number | boolean) => void;
+        input: (val: string | number | boolean) => void;
     };
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (val: string | number | boolean) => boolean;
     change: (val: string | number | boolean) => boolean;
     input: (val: string | number | boolean) => boolean;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultModelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     value: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
     disabled: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
     width: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
@@ -94,64 +155,78 @@ declare const _default: import("vue").DefineComponent<{
     beforeChange: {
         readonly type: import("vue").PropType<() => boolean | Promise<boolean>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     size: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("" | "default" | "small" | "large") & {}) | (() => "" | "default" | "small" | "large") | ((new (...args: any[]) => ("" | "default" | "small" | "large") & {}) | (() => "" | "default" | "small" | "large"))[], unknown, "" | "default" | "small" | "large">>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     tabindex: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
+    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;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
-    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
     rules: {
-        readonly type: import("vue").PropType<unknown>;
+        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;
+        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;
+        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;
+    };
 }>> & {
-    onChange?: (val: string | number | boolean) => any;
-    "onUpdate:modelValue"?: (val: string | number | boolean) => any;
-    onInput?: (val: string | number | boolean) => any;
+    "onUpdate:modelValue"?: ((val: string | number | boolean) => any) | undefined;
+    onChange?: ((val: string | number | boolean) => any) | undefined;
+    onInput?: ((val: string | number | boolean) => any) | undefined;
 }, {
     required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
-    disabled: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
-    modelValue: import("element-plus/es/utils").EpPropMergeType<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
-    validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, 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;
     name: string;
     value: import("element-plus/es/utils").EpPropMergeType<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+    validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    disabled: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    modelValue: boolean;
     width: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
     inlinePrompt: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
-    activeIcon: "";
-    inactiveIcon: "";
+    activeIcon: 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>;
+    inactiveIcon: 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>;
     activeText: string;
     inactiveText: string;
     activeColor: string;
@@ -160,5 +235,6 @@ declare const _default: import("vue").DefineComponent<{
     activeValue: import("element-plus/es/utils").EpPropMergeType<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
     inactiveValue: import("element-plus/es/utils").EpPropMergeType<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
     loading: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    defaultModelValue: boolean;
 }>;
 export default _default;

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

@@ -1,3 +1 @@
-import { ReturnVoid } from 'vunk/shared/types';
-export declare type LoadEvent = {};
-export declare type OnLoad = (e: LoadEvent) => ReturnVoid;
+export {};

package/components/switch/src/types.js

@@ -0,0 +1 @@
+

package/composables/index.d.ts

@@ -0,0 +1 @@
+export * from './useSourceManager';

package/composables/index.js

@@ -0,0 +1,82 @@
+import { isRef, ref, computed, unref } from 'vue';
+
+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 useSourceManager = (source, opts = {}) => {
+  if (!isRef(source)) {
+    source = ref(source);
+  }
+  const op = __spreadProps(__spreadValues({}, opts), {
+    slotsChildren: ["default"]
+  });
+  opts.slotsChildren && op.slotsChildren.push(...opts.slotsChildren);
+  const manager = computed(() => {
+    const keyRecord = {};
+    const propRecord = {};
+    function intoData(list, k = []) {
+      list.forEach((item, index) => {
+        const currentK = [...k, index];
+        const managerInfo = {
+          source: item,
+          key: currentK,
+          nextKey: [...k, index + 1],
+          prop: item.prop
+        };
+        keyRecord[currentK.join()] = managerInfo;
+        if (item.prop) {
+          propRecord[item.prop] = managerInfo;
+        }
+        if (item.templateSlots) {
+          if (Array.isArray(item.templateSlots)) {
+            currentK.push("templateSlots");
+            intoData(item.templateSlots, currentK);
+          }
+          op.slotsChildren.forEach((filed) => {
+            if (Array.isArray(item.templateSlots[filed])) {
+              currentK.push("templateSlots", filed);
+              intoData(item.templateSlots[filed], currentK);
+            }
+          });
+        }
+      });
+    }
+    intoData(unref(source));
+    return {
+      keyRecord,
+      propRecord
+    };
+  });
+  const getManagerInfoByProp = (prop) => {
+    return manager.value.propRecord[prop];
+  };
+  const getManagerInfoByKey = (key) => {
+    return manager.value.propRecord[key.join()];
+  };
+  return [
+    source,
+    {
+      manager,
+      getManagerInfoByProp,
+      getManagerInfoByKey
+    }
+  ];
+};
+
+export { useSourceManager };

package/composables/useSourceManager.d.ts

@@ -0,0 +1,13 @@
+import { FormItemRendererSource, ManagerInfo } from '@vunk/form/shared/types';
+import { MaybeRef } from '@vunk/core';
+import { Ref } from 'vue';
+export declare const useSourceManager: <T = FormItemRendererSource<string>>(source: MaybeRef<T[]>, opts?: {
+    slotsChildren?: string[];
+}) => readonly [Ref<T[]>, {
+    readonly manager: import("vue").ComputedRef<{
+        keyRecord: Record<string, ManagerInfo<T>>;
+        propRecord: Record<string, ManagerInfo<T>>;
+    }>;
+    readonly getManagerInfoByProp: <I = T>(prop: string) => ManagerInfo<I>;
+    readonly getManagerInfoByKey: <I_1 = T>(key: (string | number)[]) => ManagerInfo<I_1>;
+}];

package/defaults.d.ts

@@ -0,0 +1,5 @@
+import type { App } from 'vue';
+declare const _default: {
+    install: (app: App<any>) => void;
+};
+export default _default;