@carefrees/form-utils-vue 0.0.10 → 0.0.12

package/esm/formItem/form.hide.item.js

@@ -0,0 +1,126 @@
+import { createBlock, createCommentVNode, createSlots, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderList, renderSlot, unref, useSlots, withCtx } from "vue";
+import form_Item_base from "./form.Item.base.js";
+import { useRegisterFormHideItem } from "../hooks/register/register.FormHideItem.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    name: "FormHideItem",
+    inheritAttrs: false,
+    __name: "form.hide.item",
+    props: {
+        noStyle: {
+            type: Boolean
+        },
+        input: {},
+        dependencies: {},
+        noticeOnlyRuleDataField: {},
+        isNoticeParentField: {
+            type: Boolean
+        },
+        noticeWatchField: {},
+        preserve: {
+            type: Boolean
+        },
+        useRules: {},
+        useAttrs: {},
+        inputAttrs: {},
+        valuePropName: {},
+        getValuePath: {},
+        getValueFromEvent: {},
+        formatValue: {},
+        onAfterUpdate: {},
+        trigger: {},
+        name: {},
+        rules: {},
+        sort: {},
+        isJoinParentField: {
+            type: Boolean
+        },
+        errorLayout: {},
+        required: {
+            type: Boolean
+        },
+        labelMode: {},
+        onlyRuleStyle: {
+            type: Boolean
+        },
+        label: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        helpText: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        extra: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        showColon: {
+            type: Boolean
+        },
+        colSpan: {},
+        rowSpan: {},
+        htmlFor: {},
+        validateResult: {},
+        style: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        class: {},
+        labelStyle: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        labelClass: {}
+    },
+    setup (__props) {
+        const props = __props;
+        const slots = useSlots();
+        const { isHide } = useRegisterFormHideItem({
+            name: props.name,
+            sort: props.sort,
+            isJoinParentField: props.isJoinParentField
+        });
+        return (_ctx, _cache)=>unref(isHide) ? createCommentVNode("", true) : (openBlock(), createBlock(form_Item_base, normalizeProps(mergeProps({
+                key: 0
+            }, props)), createSlots({
+                _: 2
+            }, [
+                renderList(slots, (item, name)=>({
+                        name,
+                        fn: withCtx((slotProps)=>[
+                                renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps)))
+                            ])
+                    }))
+            ]), 1040));
+    }
+});
+const form_hide_item = _sfc_main;
+export { form_hide_item as default };

package/esm/formItem/form.hide.item.vue.d.ts

@@ -1,15 +1,13 @@
-import { FormItemProps } from '../interface/index';
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<FormItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FormItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, Readonly<{
+import type { FormItemProps } from "../interface/index";
+type __VLS_Slots = {
     label: (params: any) => any;
     helpText: (params: any) => any;
     extra: (params: any) => any;
-}> & {
-    label: (params: any) => any;
-    helpText: (params: any) => any;
-    extra: (params: any) => any;
-}>;
+};
+declare const __VLS_component: import("vue").DefineComponent<FormItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/esm/formItem/formItem.js

@@ -0,0 +1,155 @@
+import { createBlock, createSlots, defineComponent, guardReactiveProps, mergeProps, normalizeClass, normalizeProps, normalizeStyle, openBlock, renderList, renderSlot, useSlots, withCtx } from "vue";
+import layout_formItem from "../layout/layout.formItem.js";
+import form_Item_base from "./form.Item.base.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    name: "FormItem",
+    inheritAttrs: false,
+    __name: "formItem",
+    props: {
+        noStyle: {
+            type: Boolean
+        },
+        input: {},
+        dependencies: {},
+        noticeOnlyRuleDataField: {},
+        isNoticeParentField: {
+            type: Boolean
+        },
+        noticeWatchField: {},
+        preserve: {
+            type: Boolean
+        },
+        useRules: {},
+        useAttrs: {},
+        inputAttrs: {},
+        valuePropName: {},
+        getValuePath: {},
+        getValueFromEvent: {},
+        formatValue: {},
+        onAfterUpdate: {},
+        trigger: {},
+        name: {},
+        rules: {},
+        sort: {},
+        isJoinParentField: {
+            type: Boolean
+        },
+        errorLayout: {},
+        required: {
+            type: Boolean
+        },
+        labelMode: {},
+        onlyRuleStyle: {
+            type: Boolean
+        },
+        label: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        helpText: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        extra: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        showColon: {
+            type: Boolean
+        },
+        colSpan: {},
+        rowSpan: {},
+        htmlFor: {},
+        validateResult: {},
+        style: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        class: {},
+        labelStyle: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        labelClass: {}
+    },
+    setup (__props) {
+        const props = __props;
+        const slots = useSlots();
+        return (_ctx, _cache)=>props.name ? (openBlock(), createBlock(form_Item_base, normalizeProps(mergeProps({
+                key: 0
+            }, props)), createSlots({
+                _: 2
+            }, [
+                renderList(slots, (_, name)=>({
+                        name,
+                        fn: withCtx((slotProps)=>[
+                                renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps)))
+                            ])
+                    }))
+            ]), 1040)) : (openBlock(), createBlock(layout_formItem, {
+                key: 1,
+                label: props.label,
+                errorLayout: props.errorLayout,
+                labelMode: props.labelMode,
+                onlyRuleStyle: props.onlyRuleStyle,
+                showColon: props.showColon,
+                colSpan: props.colSpan,
+                rowSpan: props.rowSpan,
+                style: normalizeStyle(props.style),
+                class: normalizeClass(props.class),
+                labelStyle: props.labelStyle,
+                labelClass: props.labelClass
+            }, createSlots({
+                _: 2
+            }, [
+                renderList(slots, (_, name)=>({
+                        name,
+                        fn: withCtx((slotProps)=>[
+                                renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps)))
+                            ])
+                    }))
+            ]), 1032, [
+                "label",
+                "errorLayout",
+                "labelMode",
+                "onlyRuleStyle",
+                "showColon",
+                "colSpan",
+                "rowSpan",
+                "style",
+                "class",
+                "labelStyle",
+                "labelClass"
+            ]));
+    }
+});
+const formItem = _sfc_main;
+export { formItem as default };

package/esm/formItem/formItem.vue.d.ts

@@ -1,17 +1,14 @@
-import { FormItemProps } from '../interface/index';
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Partial<FormItemProps>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Partial<FormItemProps>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, Readonly<{
+import type { FormItemProps } from "../interface/index";
+type __VLS_Slots = {
     default: (params: any) => any;
     label: (params: any) => any;
     helpText: (params: any) => any;
     extra: (params: any) => any;
-}> & {
-    default: (params: any) => any;
-    label: (params: any) => any;
-    helpText: (params: any) => any;
-    extra: (params: any) => any;
-}>;
+};
+declare const __VLS_component: import("vue").DefineComponent<Partial<FormItemProps>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Partial<FormItemProps>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/esm/formItem/index.d.ts

@@ -1,69 +1,56 @@
-export declare const FormItemBase: import('../utils').SFCWithInstall<{
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('..').FormItemProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+export declare const FormItemBase: import("../utils").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../index.js").FormItemProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<import('..').FormItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
-} & import('vue').ComponentOptionsBase<Readonly<import('..').FormItemProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
-    $slots: Readonly<{
-        label: (params: any) => any;
-        helpText: (params: any) => any;
-        extra: (params: any) => any;
-    }> & {
+    }, Readonly<import("../index.js").FormItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("../index.js").FormItemProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
         label: (params: any) => any;
         helpText: (params: any) => any;
         extra: (params: any) => any;
     };
 })> & Record<string, any>;
-export declare const FormItem: import('../utils').SFCWithInstall<{
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<Partial<import('..').FormItemProps>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+export declare const FormItem: import("../utils").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<Partial<import("../index.js").FormItemProps>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<Partial<import('..').FormItemProps>> & Readonly<{}>, {}, {}, {}, {}, {}>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
-} & import('vue').ComponentOptionsBase<Readonly<Partial<import('..').FormItemProps>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
-    $slots: Readonly<{
-        default: (params: any) => any;
-        label: (params: any) => any;
-        helpText: (params: any) => any;
-        extra: (params: any) => any;
-    }> & {
+    }, Readonly<Partial<import("../index.js").FormItemProps>> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<Partial<import("../index.js").FormItemProps>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
         default: (params: any) => any;
         label: (params: any) => any;
         helpText: (params: any) => any;
         extra: (params: any) => any;
     };
 })> & Record<string, any>;
-export declare const FormHideItem: import('../utils').SFCWithInstall<{
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('..').FormItemProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+export declare const FormHideItem: import("../utils").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../index.js").FormItemProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<import('..').FormItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
-} & import('vue').ComponentOptionsBase<Readonly<import('..').FormItemProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
-    $slots: Readonly<{
-        label: (params: any) => any;
-        helpText: (params: any) => any;
-        extra: (params: any) => any;
-    }> & {
+    }, Readonly<import("../index.js").FormItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("../index.js").FormItemProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
         label: (params: any) => any;
         helpText: (params: any) => any;
         extra: (params: any) => any;

package/esm/formItem/index.js

@@ -0,0 +1,8 @@
+import form_Item_base from "./form.Item.base.js";
+import formItem from "./formItem.js";
+import form_hide_item from "./form.hide.item.js";
+import { withInstall } from "../utils/index.js";
+const FormItemBase = withInstall(form_Item_base);
+const FormItem = withInstall(formItem);
+const FormHideItem = withInstall(form_hide_item);
+export { FormHideItem, FormItem, FormItemBase };

package/esm/hooks/attr/attr.FormItem.d.ts

@@ -1,7 +1,7 @@
 import { FormInstanceBase, FormItemInstanceBase } from '@carefrees/form-utils';
 import { RegisterFormItemOptions } from './../register/register.FormItem';
 import { Ref } from 'vue';
-import { RuleInstanceBase2 } from '../../instance/ruleIntsnace';
+import type { RuleInstanceBase2 } from '../../instance/ruleIntsnace';
 export interface FormItemAttrOptions extends RegisterFormItemOptions {
     /**依赖更新项*/
     dependencies?: string[];
@@ -35,12 +35,12 @@ export interface FormItemAttrOptions extends RegisterFormItemOptions {
 /**表单项参数*/
 export declare const useFormItemAttr: (options: FormItemAttrOptions) => {
     valuePropName: string;
-    htmlFor: import('vue').ComputedRef<string>;
+    htmlFor: import("vue").ComputedRef<string>;
     onChange: (event: any) => void;
     formItemInstance: FormItemInstanceBase;
     form: FormInstanceBase<any>;
     ruleInstance: Ref<RuleInstanceBase2, RuleInstanceBase2>;
-    newAttrs: import('vue').ComputedRef<{
+    newAttrs: import("vue").ComputedRef<{
         name: string;
         id: string;
         constructor: Function;
@@ -92,6 +92,6 @@ export declare const useFormItemAttr: (options: FormItemAttrOptions) => {
         tip: string | (string | undefined)[];
         isInvalid: boolean;
     }>;
-    newSort: import('vue').ComputedRef<string>;
-    newName: import('vue').ComputedRef<string>;
+    newSort: import("vue").ComputedRef<string>;
+    newName: import("vue").ComputedRef<string>;
 };

package/esm/hooks/attr/attr.FormItem.js

@@ -0,0 +1,97 @@
+import { get } from "@carefrees/form-utils";
+import { useHtmlFor } from "../useHtmlFor.js";
+import { useRegisterFormItem } from "../register/register.FormItem.js";
+import { computed, ref, toValue, watch } from "vue";
+const useFormItemAttr = (options)=>{
+    const { trigger = 'onChange', dependencies, noticeOnlyRuleDataField, isNoticeParentField, noticeWatchField, preserve, valuePropName = 'value', getValuePath = valuePropName, getValueFromEvent, formatValue, onAfterUpdate, useAttrs, useRules, inputAttrs, ...rest } = options;
+    const { formItemInstance, form, ruleInstance, newName, newSort, deepRefData } = useRegisterFormItem({
+        ...rest
+    });
+    formItemInstance.dependencies = dependencies;
+    formItemInstance.noticeOnlyRuleDataField = noticeOnlyRuleDataField;
+    formItemInstance.isNoticeParentField = isNoticeParentField;
+    formItemInstance.onAfterUpdate = onAfterUpdate;
+    formItemInstance.noticeWatchField = noticeWatchField;
+    formItemInstance.preserve = preserve;
+    const oldValue = ref(get(form.formData, toValue(newName)));
+    watch(()=>[
+            get(form.formData, toValue(newName)),
+            toValue(newName)
+        ], ()=>{
+        oldValue.value = form.getFieldValue(toValue(newName));
+    }, {
+        immediate: true
+    });
+    const onValueChange = (event)=>{
+        try {
+            let value = event;
+            if ('function' == typeof getValueFromEvent) value = getValueFromEvent(event, form, formItemInstance);
+            else if (event && event.target && 'object' == typeof event.target && getValuePath in event.target) value = get(event.target, getValuePath);
+            if ('function' == typeof formatValue) value = formatValue(value, form, formItemInstance, event);
+            if (oldValue.value !== value) {
+                form.updatedFieldValue(toValue(newName), value, 'validate');
+                formItemInstance.onAfterUpdate?.(value, form, formItemInstance, event);
+                if (Array.isArray(formItemInstance.noticeWatchField) && formItemInstance.noticeWatchField.length) form.noticeWatch(formItemInstance.noticeWatchField);
+                if (Array.isArray(formItemInstance.noticeOnlyRuleDataField) && formItemInstance.noticeOnlyRuleDataField.length) form.onlyValidate(formItemInstance.noticeOnlyRuleDataField);
+                if (formItemInstance.isNoticeParentField && formItemInstance.parentDataField) form.notice(formItemInstance.parentDataField);
+            }
+        } catch (error) {
+            console.log(error);
+        }
+    };
+    formItemInstance.onChange = onValueChange;
+    const htmlFor = useHtmlFor(newName);
+    watch(()=>htmlFor, ()=>{
+        formItemInstance.htmlFor = htmlFor.value;
+    }, {
+        immediate: true
+    });
+    const newAttrs = computed(()=>{
+        const _attr = inputAttrs || {};
+        return {
+            ..._attr,
+            [trigger]: onValueChange,
+            name: toValue(newName),
+            id: toValue(htmlFor),
+            [valuePropName]: toValue(oldValue)
+        };
+    });
+    const attrsLastData = ref(toValue(newAttrs));
+    watch(()=>[
+            toValue(newAttrs),
+            toValue(deepRefData),
+            toValue(oldValue)
+        ], ()=>{
+        attrsLastData.value = useAttrs?.(toValue(newAttrs), form, formItemInstance) || toValue(newAttrs);
+    }, {
+        immediate: true
+    });
+    const validateResult = ref(toValue(ruleInstance).getValidateResult());
+    watch(()=>[
+            toValue(deepRefData),
+            toValue(oldValue)
+        ], ()=>{
+        useRules?.(ruleInstance, form, formItemInstance);
+    });
+    watch(()=>[
+            toValue(ruleInstance).messages,
+            toValue(ruleInstance).rules,
+            toValue(oldValue)
+        ], ()=>{
+        validateResult.value = toValue(ruleInstance).getValidateResult();
+    });
+    return {
+        valuePropName,
+        htmlFor,
+        onChange: onValueChange,
+        formItemInstance,
+        form,
+        ruleInstance,
+        newAttrs,
+        attrsLastData,
+        validateResult,
+        newSort,
+        newName
+    };
+};
+export { useFormItemAttr };

package/esm/hooks/index.js

@@ -0,0 +1,13 @@
+export * from "./useAttrs.js";
+export * from "./useForm.js";
+export * from "./useFormItem.js";
+export * from "./useFormList.js";
+export * from "./useHtmlFor.js";
+export * from "./useMultipleForm.js";
+export * from "./useFormItemParentName.js";
+export * from "./useEffect.js";
+export * from "./register/register.FormHideItem.js";
+export * from "./register/register.FormItem.js";
+export * from "./register/register.FormList.js";
+export * from "./register/register.form.js";
+export * from "./attr/attr.FormItem.js";

package/esm/hooks/register/register.FormHideItem.d.ts

@@ -3,7 +3,7 @@ interface RegisterFormHideItemOptions extends Omit<RegisterFormItemOptions, 'rul
 }
 /**注册表单隐藏表单项到表单实例中*/
 export declare const useRegisterFormHideItem: (options: RegisterFormHideItemOptions) => {
-    form: import('@carefrees/form-utils').FormInstanceBase<any>;
-    isHide: import('vue').Ref<any, any>;
+    form: import("@carefrees/form-utils").FormInstanceBase<any>;
+    isHide: import("vue").Ref<any, any>;
 };
 export {};

package/esm/hooks/register/register.FormHideItem.js

@@ -0,0 +1,42 @@
+import { ref, toValue, watch } from "vue";
+import { FormHideItemInstanceBase } from "@carefrees/form-utils";
+import { useFormItemParentNameInject } from "../useFormItemParentName.js";
+import { useFormInject } from "../useForm.js";
+import { useEffect } from "../useEffect.js";
+const useRegisterFormHideItem = (options)=>{
+    const { name, sort, isJoinParentField = true } = options;
+    const form = useFormInject();
+    const { newName, newSort } = useFormItemParentNameInject({
+        name,
+        sort,
+        isJoinParentField
+    });
+    const hideItemInstance = ref(new FormHideItemInstanceBase().ctor(newName.value));
+    const isHide = ref(form.getFieldHideValue(newName.value));
+    watch(()=>[
+            toValue(isHide)
+        ], ()=>{
+        hideItemInstance.value.preHideValue = isHide.value;
+    }, {
+        immediate: true
+    });
+    const setValue = ()=>{
+        isHide.value = form.getFieldHideValue(newName.value);
+    };
+    hideItemInstance.value.updatedItem = setValue;
+    watch(()=>[
+            form,
+            toValue(newSort)
+        ], ()=>{
+        hideItemInstance.value.instance = form;
+        hideItemInstance.value.sort = toValue(newSort);
+    }, {
+        immediate: true
+    });
+    useEffect(()=>form.registerFormHideItem(toValue(hideItemInstance)));
+    return {
+        form,
+        isHide
+    };
+};
+export { useRegisterFormHideItem };