@carefrees/form-utils-react-taro 0.0.4

package/lib/hooks/register/register.FormItem.js

@@ -0,0 +1,76 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useRegisterFormItem: ()=>useRegisterFormItem
+});
+const external_react_namespaceObject = require("react");
+const form_utils_namespaceObject = require("@carefrees/form-utils");
+const external_useUpdate_js_namespaceObject = require("../useUpdate.js");
+const external_useForm_js_namespaceObject = require("../useForm.js");
+const external_useFormItem_js_namespaceObject = require("../useFormItem.js");
+const external_useFormItemParentName_js_namespaceObject = require("../useFormItemParentName.js");
+const useRegisterFormItem = (options)=>{
+    const { name, rules, sort, isJoinParentField = true } = options;
+    const form = (0, external_useForm_js_namespaceObject.useFormInstance)();
+    const { newName, newSort, parentName } = (0, external_useFormItemParentName_js_namespaceObject.useFormItemParentName)({
+        name,
+        sort,
+        isJoinParentField
+    });
+    const ruleInstance = (0, external_react_namespaceObject.useRef)(new form_utils_namespaceObject.RuleInstanceBase()).current;
+    (0, external_react_namespaceObject.useMemo)(()=>ruleInstance.ctor(newName, rules), [
+        rules,
+        newName
+    ]);
+    ruleInstance.instance = form;
+    ruleInstance.sort = newSort;
+    const formItemInstance = (0, external_useFormItem_js_namespaceObject.useFormItem)();
+    (0, external_react_namespaceObject.useMemo)(()=>formItemInstance.ctor(newName, ruleInstance), []);
+    formItemInstance.instance = form;
+    formItemInstance.sort = newSort;
+    formItemInstance.parentDataField = parentName;
+    const _updated = (0, external_useUpdate_js_namespaceObject.useUpdate)();
+    formItemInstance.updated = _updated.current;
+    ruleInstance.updated = _updated.current;
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        const unMount = form.registerFormItem(formItemInstance);
+        return ()=>unMount();
+    }, []);
+    return {
+        ruleInstance,
+        formItemInstance,
+        form,
+        parentName,
+        newName
+    };
+};
+exports.useRegisterFormItem = __webpack_exports__.useRegisterFormItem;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useRegisterFormItem"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/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("@carefrees/form-utils").RuleInstanceBase;
+    formItemInstance: import("@carefrees/form-utils").FormItemInstanceBase;
+    formListInstance: import("@carefrees/form-utils").FormListInstanceBase;
+};

package/lib/hooks/register/register.FormList.js

@@ -0,0 +1,65 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useRegisterFormList: ()=>useRegisterFormList
+});
+const external_react_namespaceObject = require("react");
+const external_register_FormItem_js_namespaceObject = require("./register.FormItem.js");
+const external_useFormList_js_namespaceObject = require("../useFormList.js");
+const useRegisterFormList = (options)=>{
+    const { ...rest } = options;
+    const { ruleInstance, formItemInstance, form, newName, parentName } = (0, external_register_FormItem_js_namespaceObject.useRegisterFormItem)({
+        ...rest
+    });
+    const formListInstance = (0, external_useFormList_js_namespaceObject.useFormList)();
+    (0, external_react_namespaceObject.useMemo)(()=>formListInstance.ctor(newName), [
+        newName
+    ]);
+    formListInstance.instance = form;
+    formListInstance.rule = ruleInstance;
+    formListInstance.sort = options.sort;
+    formListInstance.formItemInstance = formItemInstance;
+    formListInstance.parentDataField = parentName;
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        const unMount = form.registerFormList(options.name, formListInstance);
+        return ()=>unMount();
+    }, [
+        options.name,
+        formListInstance
+    ]);
+    return {
+        ruleInstance,
+        formItemInstance,
+        formListInstance
+    };
+};
+exports.useRegisterFormList = __webpack_exports__.useRegisterFormList;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useRegisterFormList"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/lib/hooks/register/register.form.js

@@ -0,0 +1,51 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useRegisterForm: ()=>useRegisterForm
+});
+const external_react_namespaceObject = require("react");
+const external_useMultipleForm_js_namespaceObject = require("../useMultipleForm.js");
+const useRegisterForm = (form, name)=>{
+    const multipleForm = (0, external_useMultipleForm_js_namespaceObject.useMultipleFormInstance)();
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        let onMounted;
+        if (name) onMounted = multipleForm.ctor(name, form);
+        return ()=>{
+            onMounted?.();
+        };
+    }, [
+        name,
+        form
+    ]);
+    return multipleForm;
+};
+exports.useRegisterForm = __webpack_exports__.useRegisterForm;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useRegisterForm"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/hooks/useAttrs.d.ts

@@ -0,0 +1,25 @@
+import type { LayoutFormItemProps } from '../layout/layout.formItem';
+export interface AttrsOptions {
+    /**列数据*/
+    colCount?: number;
+    /**规则校验失败错误提示位置*/
+    errorLayout?: LayoutFormItemProps['errorLayout'];
+    /**label显示模式*/
+    labelMode?: LayoutFormItemProps['labelMode'];
+    /**是否显示label后的冒号*/
+    showColon?: boolean;
+    /**表单项 className*/
+    formItemClassName?: string;
+    /**表单项 style*/
+    formItemStyle?: React.CSSProperties;
+    /**表单项 label  className*/
+    formItemLabelClassName?: string;
+    /**表单项 label  style*/
+    formItemLabelStyle?: React.CSSProperties;
+    /**输入框底部边框*/
+    inputBordered?: boolean;
+}
+/**公共属性 Context */
+export declare const AttrsContext: import("react").Context<AttrsOptions>;
+/**子项中获取公共属性*/
+export declare const useAttrs: () => AttrsOptions;

package/lib/hooks/useAttrs.js

@@ -0,0 +1,47 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useAttrs: ()=>useAttrs,
+    AttrsContext: ()=>AttrsContext
+});
+const external_react_namespaceObject = require("react");
+const AttrsContext = (0, external_react_namespaceObject.createContext)({
+    colCount: 4,
+    errorLayout: 'left-bottom',
+    labelMode: 'top',
+    showColon: true,
+    inputBordered: true
+});
+const useAttrs = ()=>(0, external_react_namespaceObject.useContext)(AttrsContext);
+exports.AttrsContext = __webpack_exports__.AttrsContext;
+exports.useAttrs = __webpack_exports__.useAttrs;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "AttrsContext",
+    "useAttrs"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/hooks/useForm.d.ts

@@ -0,0 +1,7 @@
+import { FormInstanceBase } from '@carefrees/form-utils';
+/**表单实例 Context */
+export declare const FormInstanceContext: import("react").Context<FormInstanceBase<any>>;
+/**子项中获取表单实例*/
+export declare function useFormInstance<T = any>(): FormInstanceBase<T>;
+/**初始化表单实例*/
+export declare function useForm<T = any>(form?: FormInstanceBase<T>): FormInstanceBase<T>;

package/lib/hooks/useForm.js

@@ -0,0 +1,53 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    FormInstanceContext: ()=>FormInstanceContext,
+    useForm: ()=>useForm,
+    useFormInstance: ()=>useFormInstance
+});
+const form_utils_namespaceObject = require("@carefrees/form-utils");
+const external_react_namespaceObject = require("react");
+const FormInstanceContext = (0, external_react_namespaceObject.createContext)(new form_utils_namespaceObject.FormInstanceBase());
+function useFormInstance() {
+    return (0, external_react_namespaceObject.useContext)(FormInstanceContext);
+}
+function useForm(form) {
+    const ref = (0, external_react_namespaceObject.useRef)();
+    if (!ref.current) if (form) ref.current = form;
+    else ref.current = new form_utils_namespaceObject.FormInstanceBase();
+    return ref.current;
+}
+exports.FormInstanceContext = __webpack_exports__.FormInstanceContext;
+exports.useForm = __webpack_exports__.useForm;
+exports.useFormInstance = __webpack_exports__.useFormInstance;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "FormInstanceContext",
+    "useForm",
+    "useFormInstance"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/hooks/useFormItem.d.ts

@@ -0,0 +1,7 @@
+import { FormItemInstanceBase } from '@carefrees/form-utils';
+/**表单项实例 Context */
+export declare const FormItemInstanceContext: import("react").Context<FormItemInstanceBase>;
+/**子项中获取表单项实例*/
+export declare const useFormItemInstance: () => FormItemInstanceBase;
+/**s初始化 表单项实例*/
+export declare const useFormItem: (formItem?: FormItemInstanceBase) => FormItemInstanceBase;

package/lib/hooks/useFormItem.js

@@ -0,0 +1,51 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    FormItemInstanceContext: ()=>FormItemInstanceContext,
+    useFormItem: ()=>useFormItem,
+    useFormItemInstance: ()=>useFormItemInstance
+});
+const form_utils_namespaceObject = require("@carefrees/form-utils");
+const external_react_namespaceObject = require("react");
+const FormItemInstanceContext = (0, external_react_namespaceObject.createContext)(new form_utils_namespaceObject.FormItemInstanceBase());
+const useFormItemInstance = ()=>(0, external_react_namespaceObject.useContext)(FormItemInstanceContext);
+const useFormItem = (formItem)=>{
+    const ref = (0, external_react_namespaceObject.useRef)();
+    if (!ref.current) if (formItem) ref.current = formItem;
+    else ref.current = new form_utils_namespaceObject.FormItemInstanceBase();
+    return ref.current;
+};
+exports.FormItemInstanceContext = __webpack_exports__.FormItemInstanceContext;
+exports.useFormItem = __webpack_exports__.useFormItem;
+exports.useFormItemInstance = __webpack_exports__.useFormItemInstance;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "FormItemInstanceContext",
+    "useFormItem",
+    "useFormItemInstance"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/hooks/useFormItemParentName.d.ts

@@ -0,0 +1,30 @@
+export declare const FormItemParentNameContext: import("react").Context<{
+    name: string;
+    sort: string;
+}>;
+export interface FormItemParentNamOptions {
+    /**字段*/
+    name: string;
+    /**排序*/
+    sort?: string;
+    /**是否拼接父级字段*/
+    isJoinParentField?: boolean;
+}
+interface FormItemParentNameProviderProps extends Omit<FormItemParentNamOptions, 'isJoinParentField'> {
+    children?: React.ReactNode;
+}
+export declare const FormItemParentNameProvider: (props: FormItemParentNameProviderProps) => import("react").FunctionComponentElement<import("react").ProviderProps<{
+    name: string;
+    sort: string;
+}>>;
+/**表单项获取父级字段*/
+export declare const useFormItemParentName: (options: FormItemParentNamOptions) => {
+    newName: string;
+    newSort: string;
+    parentItem: {
+        name: string;
+        sort: string;
+    };
+    parentName: string;
+};
+export {};

package/lib/hooks/useFormItemParentName.js

@@ -0,0 +1,101 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    FormItemParentNameContext: ()=>FormItemParentNameContext,
+    useFormItemParentName: ()=>useFormItemParentName,
+    FormItemParentNameProvider: ()=>FormItemParentNameProvider
+});
+const external_react_namespaceObject = require("react");
+const FormItemParentNameContext = (0, external_react_namespaceObject.createContext)({
+    name: '',
+    sort: ''
+});
+const FormItemParentNameProvider = (props)=>{
+    const { name, sort, children } = props;
+    const value = (0, external_react_namespaceObject.useMemo)(()=>({
+            name,
+            sort
+        }), [
+        name,
+        sort
+    ]);
+    return (0, external_react_namespaceObject.createElement)(FormItemParentNameContext.Provider, {
+        value,
+        children
+    });
+};
+const useFormItemParentName = (options)=>{
+    const { isJoinParentField = true, sort, name } = options;
+    const parentItem = (0, external_react_namespaceObject.useContext)(FormItemParentNameContext);
+    const parentName = parentItem.name;
+    const parentSort = parentItem.sort;
+    const newName = (0, external_react_namespaceObject.useMemo)(()=>{
+        if (parentName && isJoinParentField) {
+            if (/^\./.test(`${name}`)) ;
+            else if (name) return [
+                parentName,
+                '.',
+                name
+            ].filter(Boolean).join('');
+            return [
+                parentName,
+                name
+            ].filter(Boolean).join('');
+        }
+        return [
+            name
+        ].filter(Boolean).join('');
+    }, [
+        isJoinParentField,
+        name,
+        parentName
+    ]);
+    const newSort = (0, external_react_namespaceObject.useMemo)(()=>[
+            isJoinParentField ? parentSort : '',
+            sort
+        ].filter(Boolean).join('-'), [
+        isJoinParentField,
+        parentSort,
+        sort
+    ]);
+    return {
+        newName,
+        newSort,
+        parentItem,
+        parentName: parentName
+    };
+};
+exports.FormItemParentNameContext = __webpack_exports__.FormItemParentNameContext;
+exports.FormItemParentNameProvider = __webpack_exports__.FormItemParentNameProvider;
+exports.useFormItemParentName = __webpack_exports__.useFormItemParentName;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "FormItemParentNameContext",
+    "FormItemParentNameProvider",
+    "useFormItemParentName"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/hooks/useFormList.d.ts

@@ -0,0 +1,7 @@
+import { FormListInstanceBase } from '@carefrees/form-utils';
+/**表单List实例 Context */
+export declare const FormListInstanceContext: import("react").Context<FormListInstanceBase>;
+/**子项中获取表单List实例*/
+export declare const useFormListInstance: () => FormListInstanceBase;
+/**初始化 表单List实例*/
+export declare const useFormList: (formList?: FormListInstanceBase) => FormListInstanceBase;

package/lib/hooks/useFormList.js

@@ -0,0 +1,51 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useFormList: ()=>useFormList,
+    FormListInstanceContext: ()=>FormListInstanceContext,
+    useFormListInstance: ()=>useFormListInstance
+});
+const form_utils_namespaceObject = require("@carefrees/form-utils");
+const external_react_namespaceObject = require("react");
+const FormListInstanceContext = (0, external_react_namespaceObject.createContext)(new form_utils_namespaceObject.FormListInstanceBase());
+const useFormListInstance = ()=>(0, external_react_namespaceObject.useContext)(FormListInstanceContext);
+const useFormList = (formList)=>{
+    const ref = (0, external_react_namespaceObject.useRef)();
+    if (!ref.current) if (formList) ref.current = formList;
+    else ref.current = new form_utils_namespaceObject.FormListInstanceBase();
+    return ref.current;
+};
+exports.FormListInstanceContext = __webpack_exports__.FormListInstanceContext;
+exports.useFormList = __webpack_exports__.useFormList;
+exports.useFormListInstance = __webpack_exports__.useFormListInstance;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "FormListInstanceContext",
+    "useFormList",
+    "useFormListInstance"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/hooks/useHtmlFor.d.ts

@@ -0,0 +1 @@
+export declare const useHtmlFor: (suffix: string) => string;

package/lib/hooks/useHtmlFor.js

@@ -0,0 +1,44 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useHtmlFor: ()=>useHtmlFor
+});
+const external_react_namespaceObject = require("react");
+let localId = 0;
+const useHtmlFor = (suffix)=>{
+    const count = (0, external_react_namespaceObject.useRef)(localId++);
+    return (0, external_react_namespaceObject.useMemo)(()=>`carefree-form-item_${count.current.toString(32)}_${suffix}`, [
+        count.current,
+        suffix
+    ]);
+};
+exports.useHtmlFor = __webpack_exports__.useHtmlFor;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useHtmlFor"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/hooks/useMultipleForm.d.ts

@@ -0,0 +1,13 @@
+import { MultipleInstanceBase } from '@carefrees/form-utils';
+/**多表单收集 Context */
+export declare const MultipleFormInstanceContext: import("react").Context<MultipleInstanceBase>;
+/**子项中获取 多表单收集 实例*/
+export declare const useMultipleFormInstance: () => MultipleInstanceBase;
+/**初始化 多表单收集 实例*/
+export declare const useMultipleForm: (multipleForm?: MultipleInstanceBase) => MultipleInstanceBase;
+export interface MultipleFormProviderProps {
+    children: React.ReactNode;
+    multipleForm?: MultipleInstanceBase;
+}
+/**多表单收集 Provider */
+export declare const MultipleFormProvider: (props: MultipleFormProviderProps) => import("react").FunctionComponentElement<import("react").ProviderProps<MultipleInstanceBase>>;