@vrojs/element-plus 0.0.2 → 0.0.4

package/dist/vro-el-schema-form/useVroElSchemaForm.js

@@ -0,0 +1,31 @@
+import p from "@daysnap/banana";
+import { isFunction as v } from "@daysnap/utils";
+import { useAsyncTask as d } from "@vrojs/use";
+import { reactive as g, ref as h } from "vue";
+function V(t, e, n = {}) {
+  const { instanceRef: i, source: a, ...s } = n, o = g(v(t) ? t() : t), r = i ?? h(), { loading: c, trigger: m, error: u, data: f } = d(
+    async () => {
+      if (!r.value)
+        return;
+      try {
+        await r.value.validate();
+      } catch {
+        throw "";
+      }
+      const l = await r.value.extractValues();
+      await e?.(l);
+    },
+    { throwError: !0, ...s }
+  );
+  return a && p.assignment(a, o), {
+    data: f,
+    error: u,
+    schema: o,
+    refVroElSchemaForm: r,
+    loading: c,
+    trigger: m
+  };
+}
+export {
+  V as useVroElSchemaForm
+};

package/dist/vro-el-schema-form/vro-el-schema-form.vue.d.ts

@@ -0,0 +1,389 @@
+import { VroElSchemaFormSchema } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<string, (_: any) => any>> & Partial<Record<string, (_: any) => any>> & {
+        default?(_: {}): any;
+    };
+    refs: {
+        refForm: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly model?: Record<string, any> | undefined;
+                readonly rules?: import('element-plus').FormRules | undefined;
+                readonly labelPosition?: "left" | "right" | "top" | undefined;
+                readonly requireAsteriskPosition?: "left" | "right" | undefined;
+                readonly labelWidth?: string | number | undefined;
+                readonly labelSuffix?: string | undefined;
+                readonly inline?: boolean | undefined;
+                readonly inlineMessage?: boolean | undefined;
+                readonly statusIcon?: boolean | undefined;
+                readonly showMessage?: boolean | undefined;
+                readonly validateOnRuleChange?: boolean | undefined;
+                readonly hideRequiredAsterisk?: boolean | undefined;
+                readonly scrollToError?: boolean | undefined;
+                readonly scrollIntoViewOptions?: (ScrollIntoViewOptions | boolean) | undefined;
+                readonly size?: import('element-plus').ComponentSize | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: "validate", prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').FormProps> & Readonly<{
+                onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            }>, {
+                validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                validateField: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                resetFields: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                clearValidate: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                scrollToField: (prop: import('element-plus').FormItemProp) => void;
+                getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+                fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+                setInitialValues: (initModel: Record<string, any>) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                validate: (prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+            }, string, {
+                labelWidth: string | number;
+                labelPosition: "left" | "right" | "top";
+                requireAsteriskPosition: "left" | "right";
+                labelSuffix: string;
+                showMessage: boolean;
+                validateOnRuleChange: boolean;
+                scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            labelWidth: string | number;
+            labelPosition: "left" | "right" | "top";
+            requireAsteriskPosition: "left" | "right";
+            labelSuffix: string;
+            showMessage: boolean;
+            validateOnRuleChange: boolean;
+            scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+        }> & Omit<Readonly<import('element-plus').FormProps> & Readonly<{
+            onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }>, "labelPosition" | "requireAsteriskPosition" | "labelWidth" | "labelSuffix" | "showMessage" | "validateOnRuleChange" | "scrollIntoViewOptions" | "validate" | "validateField" | "resetFields" | "clearValidate" | "scrollToField" | "getField" | "fields" | "setInitialValues"> & import('vue').ShallowUnwrapRef<{
+            validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+            validateField: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+            resetFields: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+            clearValidate: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+            scrollToField: (prop: import('element-plus').FormItemProp) => void;
+            getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+            fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+            setInitialValues: (initModel: Record<string, any>) => void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        }) | null;
+        refComponents: unknown;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    formProps: {
+        type: import('vue').PropType<import('./types').VroElSchemaFormFormProps>;
+        default: () => {};
+    };
+    rowProps: {
+        type: import('vue').PropType<Partial<import('element-plus').RowProps>>;
+        default: () => {};
+    };
+    colProps: {
+        type: import('vue').PropType<Partial<import('element-plus').ColProps>>;
+        default: () => {};
+    };
+    formItemProps: {
+        type: import('vue').PropType<Partial<import('element-plus').FormItemProps>>;
+        default: () => {};
+    };
+    schema: {
+        type: import('vue').PropType<VroElSchemaFormSchema>;
+        default: () => {};
+    };
+}>, {
+    form: {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly model?: Record<string, any> | undefined;
+            readonly rules?: import('element-plus').FormRules | undefined;
+            readonly labelPosition?: "left" | "right" | "top" | undefined;
+            readonly requireAsteriskPosition?: "left" | "right" | undefined;
+            readonly labelWidth?: string | number | undefined;
+            readonly labelSuffix?: string | undefined;
+            readonly inline?: boolean | undefined;
+            readonly inlineMessage?: boolean | undefined;
+            readonly statusIcon?: boolean | undefined;
+            readonly showMessage?: boolean | undefined;
+            readonly validateOnRuleChange?: boolean | undefined;
+            readonly hideRequiredAsterisk?: boolean | undefined;
+            readonly scrollToError?: boolean | undefined;
+            readonly scrollIntoViewOptions?: (ScrollIntoViewOptions | boolean) | undefined;
+            readonly size?: import('element-plus').ComponentSize | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "validate", prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').FormProps> & Readonly<{
+            onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }>, {
+            validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+            validateField: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+            resetFields: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+            clearValidate: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+            scrollToField: (prop: import('element-plus').FormItemProp) => void;
+            getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+            fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+            setInitialValues: (initModel: Record<string, any>) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            validate: (prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+        }, string, {
+            labelWidth: string | number;
+            labelPosition: "left" | "right" | "top";
+            requireAsteriskPosition: "left" | "right";
+            labelSuffix: string;
+            showMessage: boolean;
+            validateOnRuleChange: boolean;
+            scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        labelWidth: string | number;
+        labelPosition: "left" | "right" | "top";
+        requireAsteriskPosition: "left" | "right";
+        labelSuffix: string;
+        showMessage: boolean;
+        validateOnRuleChange: boolean;
+        scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+    }> & Omit<Readonly<import('element-plus').FormProps> & Readonly<{
+        onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+    }>, "labelPosition" | "requireAsteriskPosition" | "labelWidth" | "labelSuffix" | "showMessage" | "validateOnRuleChange" | "scrollIntoViewOptions" | "validate" | "validateField" | "resetFields" | "clearValidate" | "scrollToField" | "getField" | "fields" | "setInitialValues"> & import('vue').ShallowUnwrapRef<{
+        validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+        validateField: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+        resetFields: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+        clearValidate: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+        scrollToField: (prop: import('element-plus').FormItemProp) => void;
+        getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+        fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+        setInitialValues: (initModel: Record<string, any>) => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    };
+    validate: () => Promise<void>;
+    resetFields: () => void | undefined;
+    trigger: (ctx: {
+        confirm: (...args: any[]) => void;
+        hide: (reason?: any) => void;
+        block: () => void;
+    }) => any;
+    extractValues: () => Promise<Record<string, any>>;
+    validateField: (key: string) => Promise<boolean | undefined>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "change-field": (...args: any[]) => void;
+    "input-field": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    formProps: {
+        type: import('vue').PropType<import('./types').VroElSchemaFormFormProps>;
+        default: () => {};
+    };
+    rowProps: {
+        type: import('vue').PropType<Partial<import('element-plus').RowProps>>;
+        default: () => {};
+    };
+    colProps: {
+        type: import('vue').PropType<Partial<import('element-plus').ColProps>>;
+        default: () => {};
+    };
+    formItemProps: {
+        type: import('vue').PropType<Partial<import('element-plus').FormItemProps>>;
+        default: () => {};
+    };
+    schema: {
+        type: import('vue').PropType<VroElSchemaFormSchema>;
+        default: () => {};
+    };
+}>> & Readonly<{
+    "onChange-field"?: ((...args: any[]) => any) | undefined;
+    "onInput-field"?: ((...args: any[]) => any) | undefined;
+}>, {
+    colProps: Partial<import('element-plus').ColProps>;
+    formItemProps: Partial<import('element-plus').FormItemProps>;
+    formProps: Partial<Omit<import('element-plus').FormProps, "rules" | "model">>;
+    rowProps: Partial<import('element-plus').RowProps>;
+    schema: VroElSchemaFormSchema;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    refForm: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly model?: Record<string, any> | undefined;
+            readonly rules?: import('element-plus').FormRules | undefined;
+            readonly labelPosition?: "left" | "right" | "top" | undefined;
+            readonly requireAsteriskPosition?: "left" | "right" | undefined;
+            readonly labelWidth?: string | number | undefined;
+            readonly labelSuffix?: string | undefined;
+            readonly inline?: boolean | undefined;
+            readonly inlineMessage?: boolean | undefined;
+            readonly statusIcon?: boolean | undefined;
+            readonly showMessage?: boolean | undefined;
+            readonly validateOnRuleChange?: boolean | undefined;
+            readonly hideRequiredAsterisk?: boolean | undefined;
+            readonly scrollToError?: boolean | undefined;
+            readonly scrollIntoViewOptions?: (ScrollIntoViewOptions | boolean) | undefined;
+            readonly size?: import('element-plus').ComponentSize | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "validate", prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').FormProps> & Readonly<{
+            onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }>, {
+            validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+            validateField: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+            resetFields: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+            clearValidate: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+            scrollToField: (prop: import('element-plus').FormItemProp) => void;
+            getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+            fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+            setInitialValues: (initModel: Record<string, any>) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            validate: (prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+        }, string, {
+            labelWidth: string | number;
+            labelPosition: "left" | "right" | "top";
+            requireAsteriskPosition: "left" | "right";
+            labelSuffix: string;
+            showMessage: boolean;
+            validateOnRuleChange: boolean;
+            scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        labelWidth: string | number;
+        labelPosition: "left" | "right" | "top";
+        requireAsteriskPosition: "left" | "right";
+        labelSuffix: string;
+        showMessage: boolean;
+        validateOnRuleChange: boolean;
+        scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+    }> & Omit<Readonly<import('element-plus').FormProps> & Readonly<{
+        onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+    }>, "labelPosition" | "requireAsteriskPosition" | "labelWidth" | "labelSuffix" | "showMessage" | "validateOnRuleChange" | "scrollIntoViewOptions" | "validate" | "validateField" | "resetFields" | "clearValidate" | "scrollToField" | "getField" | "fields" | "setInitialValues"> & import('vue').ShallowUnwrapRef<{
+        validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+        validateField: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+        resetFields: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+        clearValidate: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+        scrollToField: (prop: import('element-plus').FormItemProp) => void;
+        getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+        fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+        setInitialValues: (initModel: Record<string, any>) => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    }) | null;
+    refComponents: unknown;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/vro-el-schema-form/vro-el-schema-form.vue.js

@@ -0,0 +1,127 @@
+import { defineComponent as z, computed as S, ref as F, watchEffect as A, useTemplateRef as I, createBlock as P, openBlock as h, unref as u, mergeProps as m, withCtx as c, createVNode as B, createElementBlock as G, renderSlot as E, Fragment as H, renderList as _, createSlots as O, resolveDynamicComponent as J } from "vue";
+import Q from "@daysnap/banana";
+import { isFunction as p, isString as R, filterEmptyValue as W } from "@daysnap/utils";
+import { getSlotEntries as j } from "@vrojs/base";
+import { ElForm as X, ElRow as Y, ElCol as Z, ElFormItem as k } from "element-plus";
+import { useLocale as ee } from "../locale/useLocale.js";
+import { datePickerValueFormat as re } from "../utils/datePickerValueFormat.js";
+import { defineVroElSchemaFormFieldTrigger as ae } from "./defineVroElSchemaFormFieldTrigger.js";
+import { vroElSchemaFormProps as oe } from "./types.js";
+import { vroElSchemaFormFieldManager as te } from "./vroElSchemaFormFieldManager.js";
+const ve = /* @__PURE__ */ z({
+  name: "VroElSchemaForm",
+  __name: "vro-el-schema-form",
+  props: oe,
+  emits: ["change-field", "input-field"],
+  setup(D, { expose: $, emit: x }) {
+    const C = x, l = D, y = S(() => ({
+      validateOnRuleChange: !1,
+      ...l.formProps
+    })), { locale: K } = ee(), i = F({}), V = F({}), d = F({});
+    A(() => {
+      const { schema: e } = l;
+      d.value = {}, Object.entries(e).forEach(([t, r]) => {
+        let { hidden: a, value: o, rules: s, is: n } = r;
+        p(a) && (a = a(o, r, e)), n || (a = !0), a || (V.value[t] = o, d.value[t] = r), p(i) && (i.value = i(o, r, e)), i.value[t] = s;
+      });
+    });
+    const b = S(() => Object.entries(d.value).reduce((e, [t, r]) => {
+      let { props: a = {}, is: o, options: s, labelKey: n, valueKey: q } = r;
+      if (R(o)) {
+        const g = te.get(o);
+        if (g) {
+          let w = {};
+          R(o) && (w = K.value.el.schemaForm[o]), o === "ElDatePicker" && (a.valueFormat = re[a?.type ?? "date"]), o = g.is, a = Object.assign(
+            {},
+            g.props,
+            w,
+            W({ options: s, labelKey: n, valueKey: q }),
+            a
+          ), a.disabled && (a.placeholder = "-", o === "ElDatePicker" && (a.startPlaceholder = "-", a.endPlaceholder = "-"));
+        }
+      }
+      return e[t] = { is: o, props: a }, e;
+    }, {})), L = async (e, t) => {
+      C("change-field", { key: e, value: t }), await l.schema[e]?.onChange?.(t, l.schema[e], l.schema);
+    }, T = async (e, t) => {
+      C("input-field", { key: e, value: t }), await l.schema[e]?.onInput?.(t, l.schema[e], l.schema);
+    }, v = I("refComponents"), f = I("refForm"), U = async () => {
+      const e = v.value?.filter((t) => p(t.validate)) ?? [];
+      await Promise.all([f.value, ...e].map((t) => t?.validate()));
+    }, M = async () => {
+      const e = v.value?.filter((r) => p(r.extractValues)) ?? [], t = await Promise.all(
+        e.map((r) => r.extractValues())
+      );
+      return t.push(Q.extract(l.schema)), t.filter(Boolean).reduce((r, a) => ({ ...r, ...a }), {});
+    }, N = ae(async (e) => {
+      const t = v.value?.filter((r) => p(r.trigger)) ?? [];
+      await Promise.all(t.map((r) => r.trigger(e)));
+    });
+    return $({
+      get form() {
+        return f.value;
+      },
+      validate: U,
+      resetFields: () => f.value?.resetFields(),
+      trigger: N,
+      extractValues: M,
+      validateField: async (e) => f.value?.validateField(e)
+    }), (e, t) => (h(), P(u(X), m(y.value, {
+      ref_key: "refForm",
+      ref: f,
+      class: "vro-el-schema-form",
+      model: V.value,
+      rules: i.value
+    }), {
+      default: c(() => [
+        B(u(Y), m({ gutter: 16 }, e.rowProps), {
+          default: c(() => [
+            (h(!0), G(H, null, _(d.value, (r, a) => (h(), P(u(Z), m({ key: a }, { ref_for: !0 }, { ...e.colProps, ...r.colProps }), {
+              default: c(() => [
+                B(u(k), m({
+                  label: r.label,
+                  prop: a
+                }, { ref_for: !0 }, { ...e.formItemProps, ...r.formItemProps }), O({
+                  default: c(() => [
+                    (h(), P(J(b.value?.[a]?.is), m({
+                      modelValue: r.value,
+                      "onUpdate:modelValue": (o) => r.value = o
+                    }, { ref_for: !0 }, b.value?.[a]?.props, {
+                      ref_for: !0,
+                      ref_key: "refComponents",
+                      ref: v,
+                      onChange: (o) => L(a, o),
+                      onInput: (o) => T(a, o)
+                    }), O({ _: 2 }, [
+                      _(u(j)(r.slots), ({ source: o, target: s }) => ({
+                        name: s,
+                        fn: c((n) => [
+                          E(e.$slots, o, m({ ref_for: !0 }, n ?? {}, { item: r }))
+                        ])
+                      }))
+                    ]), 1040, ["modelValue", "onUpdate:modelValue", "onChange", "onInput"]))
+                  ]),
+                  _: 2
+                }, [
+                  _(u(j)(r.itemSlots), ({ source: o, target: s }) => ({
+                    name: s,
+                    fn: c((n) => [
+                      E(e.$slots, o, m({ ref_for: !0 }, n ?? {}, { item: r }))
+                    ])
+                  }))
+                ]), 1040, ["label", "prop"])
+              ]),
+              _: 2
+            }, 1040))), 128)),
+            E(e.$slots, "default")
+          ]),
+          _: 3
+        }, 16)
+      ]),
+      _: 3
+    }, 16, ["model", "rules"]));
+  }
+});
+export {
+  ve as default
+};

package/dist/vro-el-schema-form/vro-el-schema-form.vue2.js

@@ -0,0 +1,4 @@
+import f from "./vro-el-schema-form.vue.js";
+export {
+  f as default
+};

package/dist/vro-el-schema-form/vroElSchemaFormFieldManager.d.ts

@@ -0,0 +1,2 @@
+import { ComponentManager } from '@vrojs/base';
+export declare const vroElSchemaFormFieldManager: ComponentManager;

package/dist/vro-el-schema-form/vroElSchemaFormFieldManager.js

@@ -0,0 +1,32 @@
+import { ComponentManager as e } from "@vrojs/base";
+import { ElInput as r, ElSelect as o, ElRadioGroup as l, ElCheckboxGroup as a, ElDatePicker as d, ElInputNumber as t, ElTreeSelect as E, ElCascader as i, ElDivider as p } from "element-plus";
+import { VroElCheckboxGroup as m } from "../vro-el-checkbox-group/index.js";
+import { VroElFileUpload as c } from "../vro-el-file-upload/index.js";
+import { VroElImageUpload as u } from "../vro-el-image-upload/index.js";
+import { VroElRadioGroup as n } from "../vro-el-radio-group/index.js";
+import { VroElSelect as V } from "../vro-el-select/index.js";
+import { VroElTags as b } from "../vro-el-tags/index.js";
+import { VroElTree as f } from "../vro-el-tree/index.js";
+const s = new e();
+s.add("ElInput", r, {
+  clearable: !0,
+  showWordLimit: !0,
+  autosize: { minRows: 2 }
+}).add("ElSelect", o, {
+  clearable: !0,
+  filterable: !0
+}).add("ElRadioGroup", l).add("ElCheckboxGroup", a).add("ElDatePicker", d, {
+  type: "date",
+  clearable: !0
+}).add("ElInputNumber", t).add("ElTreeSelect", E).add("ElCascader", i, {
+  clearable: !0,
+  validateEvent: !1
+}).add("ElDivider", p, {
+  contentPosition: "center"
+}).add("VroElSelect", V, {
+  clearable: !0,
+  filterable: !0
+}).add("VroElCheckboxGroup", m).add("VroElRadioGroup", n).add("VroElImageUpload", u).add("VroElFileUpload", c).add("VroElTags", b).add("VroElTree", f);
+export {
+  s as vroElSchemaFormFieldManager
+};

package/dist/vro-el-schema-form-dialog/function-call.d.ts

@@ -0,0 +1,3 @@
+import { AppContext } from 'vue';
+import { VroElSchemaFormDialogProps } from './types';
+export declare function showVroElSchemaFormDialog<T = any>(props: Partial<VroElSchemaFormDialogProps>, appContext?: AppContext | null): Promise<T>;

package/dist/vro-el-schema-form-dialog/function-call.js

@@ -0,0 +1,17 @@
+import { showComponent as m } from "@vrojs/base";
+import { markRaw as i } from "vue";
+import { VroElWithConfig as t } from "../vro-el-with-config/index.js";
+import n from "./vro-el-schema-form-dialog.vue.js";
+function e(o, r = null) {
+  return m(
+    t,
+    {
+      ...o,
+      is: i(n)
+    },
+    r
+  );
+}
+export {
+  e as showVroElSchemaFormDialog
+};