@carefrees/form-utils-vue-hooks 0.0.13

package/README.md

@@ -0,0 +1,7 @@
+# vue-hooks
+
+## 安装
+
+```bash
+npm install @carefrees/form-utils-vue-hooks # yarn add @carefrees/form-utils # pnpm add @carefrees/form-utils
+```

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

@@ -0,0 +1,94 @@
+import { FormInstanceBase } from '../../instance/formInstance';
+import { FormItemInstanceBase } from '../../instance/formItemInstance';
+import { RegisterFormItemOptions } from './../register/register.FormItem';
+import { Ref } from 'vue';
+import type { RuleInstanceBase } from '../../instance/ruleIntsnace';
+export interface FormItemAttrOptions extends RegisterFormItemOptions {
+    /**依赖更新项*/
+    dependencies?: string[];
+    /**通知 只用于校验规则提示 字段 */
+    noticeOnlyRuleDataField?: string[];
+    /**是否保护值(不进行表单项组件卸载重置初始值)*/
+    preserve?: boolean;
+    /**重写规则*/
+    useRules?: (ruleInstance: Ref<RuleInstanceBase>, form: Ref<FormInstanceBase>, formItemInstance: Ref<FormItemInstanceBase>) => void;
+    /**输入框属性重写*/
+    useAttrs?: (attrs: any, form: Ref<FormInstanceBase>, formItemInstance: Ref<FormItemInstanceBase>) => any;
+    /**输入框属性*/
+    inputAttrs?: Object;
+    /**传递组件字段*/
+    valuePropName?: string;
+    /**取值字段(默认和valuePropName值相同)*/
+    getValuePath?: string;
+    /**自定义获取值*/
+    getValueFromEvent?: (event: any, form: Ref<FormInstanceBase>, formItemInstance: Ref<FormItemInstanceBase>) => any;
+    /**值格式化*/
+    formatValue?: (value: any, form: Ref<FormInstanceBase>, formItemInstance: Ref<FormItemInstanceBase>, event: any) => any;
+    /**触发数据更新之后触发（用于数据联动之类的）*/
+    onAfterUpdate?: (value: any, form: Ref<FormInstanceBase>, formItemInstance: Ref<FormItemInstanceBase>, event: any) => void;
+    /**事件名称*/
+    trigger?: string;
+}
+/**表单项参数*/
+export declare const useFormItemAttr: (options: FormItemAttrOptions) => {
+    valuePropName: string;
+    htmlFor: import("vue").ComputedRef<string>;
+    onChange: (event: any) => void;
+    formItemInstance: Ref<FormItemInstanceBase, FormItemInstanceBase>;
+    form: Ref<FormInstanceBase<any>, FormInstanceBase<any>>;
+    ruleInstance: Ref<RuleInstanceBase, RuleInstanceBase>;
+    newAttrs: import("vue").ComputedRef<{
+        name: string;
+        id: string;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    }>;
+    attrsLastData: Ref<{
+        name: string;
+        id: string;
+        constructor: Function;
+        toString: () => string;
+        toLocaleString: () => string;
+        valueOf: () => Object;
+        hasOwnProperty: (v: PropertyKey) => boolean;
+        isPrototypeOf: (v: Object) => boolean;
+        propertyIsEnumerable: (v: PropertyKey) => boolean;
+    }, {
+        name: string;
+        id: string;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    } | {
+        name: string;
+        id: string;
+        constructor: Function;
+        toString: () => string;
+        toLocaleString: () => string;
+        valueOf: () => Object;
+        hasOwnProperty: (v: PropertyKey) => boolean;
+        isPrototypeOf: (v: Object) => boolean;
+        propertyIsEnumerable: (v: PropertyKey) => boolean;
+    }>;
+    validateResult: Ref<{
+        tip: string | (string | undefined)[];
+        isInvalid: boolean;
+    }, {
+        tip: string | (string | undefined)[];
+        isInvalid: boolean;
+    } | {
+        tip: string | (string | undefined)[];
+        isInvalid: boolean;
+    }>;
+    newSort: import("vue").ComputedRef<string>;
+    newName: import("vue").ComputedRef<string>;
+};

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

@@ -0,0 +1,104 @@
+import { get } from "../../utils/index.js";
+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', preserve, valuePropName = 'value', getValuePath = valuePropName, getValueFromEvent, formatValue, onAfterUpdate, useAttrs, useRules, noticeOnlyRuleDataField } = options;
+    const { formItemInstance, form, ruleInstance, newName, newSort } = useRegisterFormItem(options);
+    formItemInstance.value.noticeOnlyRuleDataField = noticeOnlyRuleDataField;
+    formItemInstance.value.onAfterUpdate = onAfterUpdate;
+    formItemInstance.value.preserve = preserve;
+    const oldValue = ref(get(toValue(form.value.formData), toValue(newName)));
+    const oldInputAttrs = ref(options.inputAttrs || {});
+    watch(()=>options.inputAttrs, (newVal)=>{
+        oldInputAttrs.value = newVal || {};
+    });
+    watch(()=>[
+            get(toValue(form.value.formData), toValue(newName)),
+            toValue(newName)
+        ], ()=>{
+        oldValue.value = form.value.getFieldValue(toValue(newName));
+    }, {
+        immediate: true
+    });
+    watch(()=>[
+            toValue(formItemInstance).noticeOnlyRuleDataField,
+            toValue(oldValue)
+        ], ()=>{
+        const formInstance = toValue(form);
+        const newVal = toValue(formItemInstance).noticeOnlyRuleDataField;
+        if (Array.isArray(newVal) && newVal.length) formInstance.onlyValidate(newVal);
+    }, {
+        immediate: true
+    });
+    const onValueChange = (event)=>{
+        try {
+            const formItem = toValue(formItemInstance);
+            const formInstance = toValue(form);
+            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) {
+                formInstance.updatedFieldValue(toValue(newName), value, 'validate');
+                formItem.onAfterUpdate?.(value, form, formItemInstance, event);
+            }
+        } catch (error) {
+            console.log(error);
+        }
+    };
+    const htmlFor = useHtmlFor(newName);
+    watch(()=>toValue(htmlFor), ()=>{
+        formItemInstance.value.htmlFor = htmlFor.value;
+    }, {
+        immediate: true
+    });
+    const newAttrs = computed(()=>{
+        const _attr = oldInputAttrs.value || {};
+        return {
+            ..._attr,
+            [trigger]: onValueChange,
+            name: toValue(newName),
+            id: toValue(htmlFor),
+            [valuePropName]: toValue(oldValue)
+        };
+    });
+    const attrsLastData = ref(toValue(newAttrs));
+    watch(()=>[
+            toValue(newAttrs),
+            toValue(oldValue)
+        ], ()=>{
+        attrsLastData.value = useAttrs?.(toValue(newAttrs), form, formItemInstance) || toValue(newAttrs);
+        formItemInstance.value.control = attrsLastData;
+    }, {
+        immediate: true
+    });
+    const validateResult = ref(toValue(ruleInstance).getValidateResult());
+    watch(()=>[
+            toValue(oldValue),
+            toValue(toValue(ruleInstance).rules)
+        ], ()=>{
+        useRules?.(ruleInstance, form, formItemInstance);
+        ruleInstance.value.validate();
+    });
+    watch(()=>[
+            toValue(toValue(ruleInstance).messages),
+            toValue(toValue(ruleInstance).rules)
+        ], ()=>{
+        validateResult.value = toValue(ruleInstance).getValidateResult();
+    });
+    return {
+        valuePropName,
+        htmlFor,
+        onChange: onValueChange,
+        formItemInstance,
+        form,
+        ruleInstance,
+        newAttrs,
+        attrsLastData,
+        validateResult,
+        newSort,
+        newName
+    };
+};
+export { useFormItemAttr };

package/esm/hooks/index.d.ts

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

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

@@ -0,0 +1,9 @@
+import { RegisterFormItemOptions } from './register.FormItem';
+interface RegisterFormHideItemOptions extends Omit<RegisterFormItemOptions, 'rules'> {
+}
+/**注册表单隐藏表单项到表单实例中*/
+export declare const useRegisterFormHideItem: (options: RegisterFormHideItemOptions) => {
+    form: import("vue").Ref<import("../..").FormInstanceBase<any>, import("../..").FormInstanceBase<any>>;
+    isHide: import("vue").Ref<any, any>;
+};
+export {};

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

@@ -0,0 +1,26 @@
+import { ref, toValue, watch } from "vue";
+import { useFormItemParentNameInject } from "../useFormItemParentName.js";
+import { useFormInject } from "../useForm.js";
+const useRegisterFormHideItem = (options)=>{
+    const { name, sort, isJoinParentField = true } = options;
+    const form = useFormInject();
+    const { newName } = useFormItemParentNameInject({
+        name,
+        sort,
+        isJoinParentField
+    });
+    const isHide = ref(form.value.getFieldHideValue(newName.value));
+    watch(()=>[
+            toValue(form),
+            toValue(newName)
+        ], ()=>{
+        isHide.value = form.value.getFieldHideValue(toValue(newName));
+    }, {
+        immediate: true
+    });
+    return {
+        form,
+        isHide
+    };
+};
+export { useRegisterFormHideItem };

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

@@ -0,0 +1,24 @@
+/**
+ * @description 注册组件
+ */
+import type { RuleItem } from 'async-validator';
+export interface RegisterFormItemOptions {
+    /**字段*/
+    name: string;
+    /**规则*/
+    rules?: RuleItem[];
+    /**排序值*/
+    sort?: string;
+    /**是否拼接父级字段*/
+    isJoinParentField?: boolean;
+}
+/**注册表单项到表单实例中*/
+export declare const useRegisterFormItem: (options: RegisterFormItemOptions) => {
+    ruleInstance: import("vue").Ref<import("../..").RuleInstanceBase, import("../..").RuleInstanceBase>;
+    formItemInstance: import("vue").Ref<import("../..").FormItemInstanceBase, import("../..").FormItemInstanceBase>;
+    form: import("vue").Ref<import("../..").FormInstanceBase<any>, import("../..").FormInstanceBase<any>>;
+    newName: import("vue").ComputedRef<string>;
+    newSort: import("vue").ComputedRef<string>;
+    parentItem: import("vue").ComputedRef<import("../..").PartialComputedRefs<Omit<import("../useFormItemParentName").FormItemParentNamOptions, "isJoinParentField">>>;
+    deepRefData: import("vue").Ref<any, any>;
+};

package/esm/hooks/register/register.FormItem.js

@@ -0,0 +1,67 @@
+import { ref, toValue, watch } from "vue";
+import { useFormInject } from "../useForm.js";
+import { useFormItem } from "../useFormItem.js";
+import { useFormItemParentNameInject } from "../useFormItemParentName.js";
+import { useEffect } from "../useEffect.js";
+import { useRules } from "../useRule.js";
+const useRegisterFormItem = (options)=>{
+    const { name, rules, sort, isJoinParentField = true } = options;
+    const form = useFormInject();
+    const deepRefData = ref({});
+    const { newName, newSort, parentItem } = useFormItemParentNameInject({
+        name,
+        sort,
+        isJoinParentField
+    });
+    const formItemInstance = useFormItem();
+    const ruleInstance = useRules();
+    const ruleItems = ref(rules || []);
+    watch(()=>toValue(options.rules), (newVal)=>{
+        ruleItems.value = newVal || [];
+    });
+    watch(()=>[
+            toValue(form)
+        ], ()=>{
+        ruleInstance.value.instance = form;
+        formItemInstance.value.instance = form;
+    }, {
+        immediate: true
+    });
+    watch(()=>[
+            toValue(newName),
+            toValue(ruleInstance)
+        ], ()=>{
+        ruleInstance.value.name = toValue(newName);
+        ruleInstance.value.rules = ruleItems;
+        formItemInstance.value.name = toValue(newName);
+        formItemInstance.value.rule = ruleInstance;
+    }, {
+        immediate: true
+    });
+    watch(()=>[
+            toValue(newSort)
+        ], ()=>{
+        ruleInstance.value.sort = toValue(newSort);
+        formItemInstance.value.sort = toValue(newSort);
+    }, {
+        immediate: true
+    });
+    watch(()=>[
+            toValue(parentItem)
+        ], ()=>{
+        formItemInstance.value.parentDataField = toValue(toValue(parentItem).name);
+    }, {
+        immediate: true
+    });
+    useEffect(()=>form.value.registerFormItem(formItemInstance));
+    return {
+        ruleInstance,
+        formItemInstance,
+        form,
+        newName,
+        newSort,
+        parentItem,
+        deepRefData
+    };
+};
+export { useRegisterFormItem };

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

@@ -0,0 +1,9 @@
+import { RegisterFormItemOptions } from './register.FormItem';
+export interface RegisterFormListOptions extends RegisterFormItemOptions {
+}
+/**注册表单List到表单实例中*/
+export declare const useRegisterFormList: (options: RegisterFormListOptions) => {
+    ruleInstance: import("vue").Ref<import("../..").RuleInstanceBase, import("../..").RuleInstanceBase>;
+    formItemInstance: import("vue").Ref<import("../..").FormItemInstanceBase, import("../..").FormItemInstanceBase>;
+    formListInstance: import("vue").Ref<import("../..").FormListInstanceBase, import("../..").FormListInstanceBase>;
+};

package/esm/hooks/register/register.FormList.js

@@ -0,0 +1,42 @@
+import { toValue, watch } from "vue";
+import { useRegisterFormItem } from "./register.FormItem.js";
+import { useFormList } from "../useFormList.js";
+import { useEffect } from "../useEffect.js";
+const useRegisterFormList = (options)=>{
+    const { ruleInstance, formItemInstance, form, newName, parentItem } = useRegisterFormItem(options);
+    const formListInstance = useFormList();
+    watch(()=>[
+            toValue(newName)
+        ], ()=>{
+        formListInstance.value.ctor(toValue(newName));
+    }, {
+        immediate: true
+    });
+    watch(()=>[
+            toValue(form),
+            formItemInstance,
+            ruleInstance
+        ], ()=>{
+        formListInstance.value.instance = form;
+        formListInstance.value.formItemInstance = formItemInstance;
+        formListInstance.value.rule = ruleInstance;
+    }, {
+        immediate: true
+    });
+    watch(()=>[
+            options.sort,
+            toValue(parentItem)
+        ], ()=>{
+        formListInstance.value.sort = toValue(parentItem.value.sort);
+        formListInstance.value.parentDataField = toValue(parentItem.value.name);
+    }, {
+        immediate: true
+    });
+    useEffect(()=>form.value.registerFormList(newName.value, formListInstance));
+    return {
+        ruleInstance,
+        formItemInstance,
+        formListInstance
+    };
+};
+export { useRegisterFormList };

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

@@ -0,0 +1,4 @@
+import { FormInstanceBase } from '../../instance/formInstance';
+import { Ref } from 'vue';
+/**注册表单实例到多表单收集实例中*/
+export declare const useRegisterForm: (form: Ref<FormInstanceBase>, name?: string) => Ref<import("../..").MultipleInstanceBase, import("../..").MultipleInstanceBase>;

package/esm/hooks/register/register.form.js

@@ -0,0 +1,10 @@
+import { useMultipleFormInject } from "../useMultipleForm.js";
+import { useEffect } from "../useEffect.js";
+const useRegisterForm = (form, name)=>{
+    const multipleForm = useMultipleFormInject();
+    useEffect(()=>{
+        if (name) return multipleForm.value.ctor(name, form);
+    });
+    return multipleForm;
+};
+export { useRegisterForm };

package/esm/hooks/useAttrs.d.ts

@@ -0,0 +1,25 @@
+/**公共属性*/
+import { StyleValue, ComputedRef } from 'vue';
+import { ComputedRefBase } from '../interface';
+export type AttrsOptions = {
+    /**列数据*/
+    colCount?: ComputedRefBase<number | undefined>;
+    /**规则校验失败错误提示位置*/
+    errorLayout?: ComputedRefBase<'left-bottom' | 'right-bottom' | 'top-right' | 'top-left' | undefined>;
+    /**label显示模式*/
+    labelMode?: ComputedRefBase<'left' | 'top' | 'hide' | undefined>;
+    /**是否显示label后的冒号*/
+    showColon?: ComputedRefBase<boolean | undefined>;
+    /**表单项 className*/
+    formItemClass?: ComputedRefBase<string | undefined>;
+    /**表单项 style*/
+    formItemStyle?: ComputedRefBase<StyleValue | undefined>;
+    /**表单项 label  className*/
+    formItemLabelClass?: ComputedRefBase<string | undefined>;
+    /**表单项 label  style*/
+    formItemLabelStyle?: ComputedRefBase<StyleValue | undefined>;
+};
+/**公共属性 Context */
+export declare function useAttrsProvide(options: AttrsOptions): void;
+/**子项中获取公共属性*/
+export declare function useAttrsInject(): ComputedRef<AttrsOptions>;

package/esm/hooks/useAttrs.js

@@ -0,0 +1,26 @@
+import { computed, inject, provide, reactive, ref } from "vue";
+const attrsProvideSymbol = Symbol('carefrees-attrs');
+function useAttrsProvide(options) {
+    const { colCount = ref(4), errorLayout = ref('left-bottom'), labelMode = ref('top'), showColon = ref(true), formItemClass, formItemStyle, formItemLabelClass, formItemLabelStyle } = options;
+    const data = computed(()=>({
+            colCount,
+            errorLayout,
+            labelMode,
+            showColon,
+            formItemClass,
+            formItemStyle,
+            formItemLabelClass,
+            formItemLabelStyle
+        }));
+    provide(attrsProvideSymbol, reactive(data));
+}
+function useAttrsInject() {
+    const attrs = inject(attrsProvideSymbol, computed(()=>({
+            colCount: ref(4),
+            errorLayout: ref('left-bottom'),
+            labelMode: ref('top'),
+            showColon: ref(true)
+        })));
+    return attrs;
+}
+export { useAttrsInject, useAttrsProvide };

package/esm/hooks/useEffect.d.ts

@@ -0,0 +1,2 @@
+/**挂载卸载*/
+export declare const useEffect: (fun: () => Function | undefined) => void;

package/esm/hooks/useEffect.js

@@ -0,0 +1,12 @@
+import { onMounted, onUnmounted, ref } from "vue";
+const useEffect = (fun)=>{
+    const unRegisterRef = ref();
+    onMounted(()=>{
+        unRegisterRef.value = fun();
+    });
+    onUnmounted(()=>{
+        'function' == typeof unRegisterRef.value && unRegisterRef.value();
+        unRegisterRef.value = void 0;
+    });
+};
+export { useEffect };

package/esm/hooks/useForm.d.ts

@@ -0,0 +1,8 @@
+import { FormInstanceBase } from '../instance/formInstance';
+import { Ref } from 'vue';
+/**表单实例 Context */
+export declare function useFormProvide<T = any>(form: Ref<FormInstanceBase<T>> | FormInstanceBase<T>): void;
+/**子项中获取表单实例*/
+export declare function useFormInject<T = any>(): Ref<FormInstanceBase<T>, FormInstanceBase<T>>;
+/**初始化表单实例*/
+export declare function useForm<T = any>(form?: Ref<FormInstanceBase<T>> | FormInstanceBase<T>): Ref<FormInstanceBase<T>>;

package/esm/hooks/useForm.js

@@ -0,0 +1,21 @@
+import { FormInstanceBase } from "../instance/formInstance.js";
+import { inject, provide, ref, toValue } from "vue";
+const formProvideSymbol = Symbol('carefrees-form');
+function useFormProvide(form) {
+    const newForm = useForm(form);
+    provide(formProvideSymbol, newForm);
+}
+function useFormInject() {
+    const form = inject(formProvideSymbol, ref(new FormInstanceBase()));
+    return form;
+}
+function useForm(form) {
+    const refForm = ref();
+    if (!refForm.value) {
+        const value = toValue(form);
+        if (value) refForm.value = value;
+        else refForm.value = new FormInstanceBase();
+    }
+    return refForm;
+}
+export { useForm, useFormInject, useFormProvide };

package/esm/hooks/useFormItem.d.ts

@@ -0,0 +1,8 @@
+import { FormItemInstanceBase } from '../instance/formItemInstance';
+import { Ref } from 'vue';
+/**表单项实例 Context */
+export declare function useFormItemProvide(formItem: Ref<FormItemInstanceBase> | FormItemInstanceBase): void;
+/**子项中获取表单项实例*/
+export declare function useFormItemInject(): Ref<FormItemInstanceBase, FormItemInstanceBase>;
+/** 初始化 表单项实例*/
+export declare function useFormItem(formItem?: Ref<FormItemInstanceBase> | FormItemInstanceBase): Ref<FormItemInstanceBase>;

package/esm/hooks/useFormItem.js

@@ -0,0 +1,21 @@
+import { FormItemInstanceBase } from "../instance/formItemInstance.js";
+import { inject, provide, ref, toValue } from "vue";
+const formItemProvideSymbol = Symbol('carefrees-form-item');
+function useFormItemProvide(formItem) {
+    const newFormItem = useFormItem(formItem);
+    provide(formItemProvideSymbol, newFormItem);
+}
+function useFormItemInject() {
+    const formItem = inject(formItemProvideSymbol, ref(new FormItemInstanceBase()));
+    return formItem;
+}
+function useFormItem(formItem) {
+    const refForm = ref();
+    if (!refForm.value) {
+        const value = toValue(formItem);
+        if (value) refForm.value = value;
+        else refForm.value = new FormItemInstanceBase();
+    }
+    return refForm;
+}
+export { useFormItem, useFormItemInject, useFormItemProvide };

package/esm/hooks/useFormItemParentName.d.ts

@@ -0,0 +1,18 @@
+import { ComputedRef } from 'vue';
+import { PartialComputedRefs } from '../interface';
+export interface FormItemParentNamOptions {
+    /**字段*/
+    name: string;
+    /**排序*/
+    sort?: string;
+    /**是否拼接父级字段*/
+    isJoinParentField?: boolean;
+}
+export type FormItemParentNameProviderProps = PartialComputedRefs<Omit<FormItemParentNamOptions, 'isJoinParentField'>>;
+export declare const useFormItemParentNameProvide: (props: FormItemParentNameProviderProps) => void;
+/**表单项获取父级字段*/
+export declare const useFormItemParentNameInject: (options: FormItemParentNamOptions) => {
+    newName: ComputedRef<string>;
+    newSort: ComputedRef<string>;
+    parentItem: ComputedRef<PartialComputedRefs<Omit<FormItemParentNamOptions, "isJoinParentField">>>;
+};

package/esm/hooks/useFormItemParentName.js

@@ -0,0 +1,47 @@
+import { computed, inject, provide, ref, toValue } from "vue";
+const parentNameProvideSymbol = Symbol('carefrees-parent-name');
+const useFormItemParentNameProvide = (props)=>{
+    const { name, sort } = props;
+    provide(parentNameProvideSymbol, computed(()=>({
+            name,
+            sort
+        })));
+};
+const useFormItemParentNameInject = (options)=>{
+    const { isJoinParentField = true, sort, name } = options;
+    const parentItem = inject(parentNameProvideSymbol, computed(()=>({
+            name: ref(''),
+            sort: ref('')
+        })));
+    const newName = computed(()=>{
+        const _name = toValue(parentItem.value.name);
+        if (_name && isJoinParentField) {
+            if (/^\./.test(`${name}`)) ;
+            else if (name) return [
+                _name,
+                '.',
+                name
+            ].filter(Boolean).join('');
+            return [
+                _name,
+                name
+            ].filter(Boolean).join('');
+        }
+        return [
+            name
+        ].filter(Boolean).join('');
+    });
+    const newSort = computed(()=>{
+        const _sort = toValue(parentItem.value.sort);
+        return [
+            isJoinParentField ? _sort : '',
+            sort
+        ].filter(Boolean).join('-');
+    });
+    return {
+        newName,
+        newSort,
+        parentItem
+    };
+};
+export { useFormItemParentNameInject, useFormItemParentNameProvide };

package/esm/hooks/useFormList.d.ts

@@ -0,0 +1,8 @@
+import { FormListInstanceBase } from '../instance/formListInstance';
+import { Ref } from 'vue';
+/**表单List实例 Context */
+export declare function useFormListProvide(formList: Ref<FormListInstanceBase> | FormListInstanceBase): void;
+/**子项中获取表单List实例*/
+export declare function useFormListInject(): Ref<FormListInstanceBase, FormListInstanceBase>;
+/**初始化 表单List实例*/
+export declare function useFormList(formList?: Ref<FormListInstanceBase> | FormListInstanceBase): Ref<FormListInstanceBase>;