@carefrees/form-utils-vue-hooks 0.0.13

package/lib/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/lib/hooks/useAttrs.js

@@ -0,0 +1,63 @@
+"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__, {
+    useAttrsProvide: ()=>useAttrsProvide,
+    useAttrsInject: ()=>useAttrsInject
+});
+const external_vue_namespaceObject = require("vue");
+const attrsProvideSymbol = Symbol('carefrees-attrs');
+function useAttrsProvide(options) {
+    const { colCount = (0, external_vue_namespaceObject.ref)(4), errorLayout = (0, external_vue_namespaceObject.ref)('left-bottom'), labelMode = (0, external_vue_namespaceObject.ref)('top'), showColon = (0, external_vue_namespaceObject.ref)(true), formItemClass, formItemStyle, formItemLabelClass, formItemLabelStyle } = options;
+    const data = (0, external_vue_namespaceObject.computed)(()=>({
+            colCount,
+            errorLayout,
+            labelMode,
+            showColon,
+            formItemClass,
+            formItemStyle,
+            formItemLabelClass,
+            formItemLabelStyle
+        }));
+    (0, external_vue_namespaceObject.provide)(attrsProvideSymbol, (0, external_vue_namespaceObject.reactive)(data));
+}
+function useAttrsInject() {
+    const attrs = (0, external_vue_namespaceObject.inject)(attrsProvideSymbol, (0, external_vue_namespaceObject.computed)(()=>({
+            colCount: (0, external_vue_namespaceObject.ref)(4),
+            errorLayout: (0, external_vue_namespaceObject.ref)('left-bottom'),
+            labelMode: (0, external_vue_namespaceObject.ref)('top'),
+            showColon: (0, external_vue_namespaceObject.ref)(true)
+        })));
+    return attrs;
+}
+exports.useAttrsInject = __webpack_exports__.useAttrsInject;
+exports.useAttrsProvide = __webpack_exports__.useAttrsProvide;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useAttrsInject",
+    "useAttrsProvide"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/hooks/useEffect.d.ts

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

package/lib/hooks/useEffect.js

@@ -0,0 +1,46 @@
+"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__, {
+    useEffect: ()=>useEffect
+});
+const external_vue_namespaceObject = require("vue");
+const useEffect = (fun)=>{
+    const unRegisterRef = (0, external_vue_namespaceObject.ref)();
+    (0, external_vue_namespaceObject.onMounted)(()=>{
+        unRegisterRef.value = fun();
+    });
+    (0, external_vue_namespaceObject.onUnmounted)(()=>{
+        'function' == typeof unRegisterRef.value && unRegisterRef.value();
+        unRegisterRef.value = void 0;
+    });
+};
+exports.useEffect = __webpack_exports__.useEffect;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useEffect"
+].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,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/lib/hooks/useForm.js

@@ -0,0 +1,61 @@
+"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__, {
+    useFormProvide: ()=>useFormProvide,
+    useForm: ()=>useForm,
+    useFormInject: ()=>useFormInject
+});
+const formInstance_js_namespaceObject = require("../instance/formInstance.js");
+const external_vue_namespaceObject = require("vue");
+const formProvideSymbol = Symbol('carefrees-form');
+function useFormProvide(form) {
+    const newForm = useForm(form);
+    (0, external_vue_namespaceObject.provide)(formProvideSymbol, newForm);
+}
+function useFormInject() {
+    const form = (0, external_vue_namespaceObject.inject)(formProvideSymbol, (0, external_vue_namespaceObject.ref)(new formInstance_js_namespaceObject.FormInstanceBase()));
+    return form;
+}
+function useForm(form) {
+    const refForm = (0, external_vue_namespaceObject.ref)();
+    if (!refForm.value) {
+        const value = (0, external_vue_namespaceObject.toValue)(form);
+        if (value) refForm.value = value;
+        else refForm.value = new formInstance_js_namespaceObject.FormInstanceBase();
+    }
+    return refForm;
+}
+exports.useForm = __webpack_exports__.useForm;
+exports.useFormInject = __webpack_exports__.useFormInject;
+exports.useFormProvide = __webpack_exports__.useFormProvide;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useForm",
+    "useFormInject",
+    "useFormProvide"
+].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,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/lib/hooks/useFormItem.js

@@ -0,0 +1,61 @@
+"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__, {
+    useFormItemProvide: ()=>useFormItemProvide,
+    useFormItem: ()=>useFormItem,
+    useFormItemInject: ()=>useFormItemInject
+});
+const formItemInstance_js_namespaceObject = require("../instance/formItemInstance.js");
+const external_vue_namespaceObject = require("vue");
+const formItemProvideSymbol = Symbol('carefrees-form-item');
+function useFormItemProvide(formItem) {
+    const newFormItem = useFormItem(formItem);
+    (0, external_vue_namespaceObject.provide)(formItemProvideSymbol, newFormItem);
+}
+function useFormItemInject() {
+    const formItem = (0, external_vue_namespaceObject.inject)(formItemProvideSymbol, (0, external_vue_namespaceObject.ref)(new formItemInstance_js_namespaceObject.FormItemInstanceBase()));
+    return formItem;
+}
+function useFormItem(formItem) {
+    const refForm = (0, external_vue_namespaceObject.ref)();
+    if (!refForm.value) {
+        const value = (0, external_vue_namespaceObject.toValue)(formItem);
+        if (value) refForm.value = value;
+        else refForm.value = new formItemInstance_js_namespaceObject.FormItemInstanceBase();
+    }
+    return refForm;
+}
+exports.useFormItem = __webpack_exports__.useFormItem;
+exports.useFormItemInject = __webpack_exports__.useFormItemInject;
+exports.useFormItemProvide = __webpack_exports__.useFormItemProvide;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useFormItem",
+    "useFormItemInject",
+    "useFormItemProvide"
+].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,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/lib/hooks/useFormItemParentName.js

@@ -0,0 +1,84 @@
+"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__, {
+    useFormItemParentNameInject: ()=>useFormItemParentNameInject,
+    useFormItemParentNameProvide: ()=>useFormItemParentNameProvide
+});
+const external_vue_namespaceObject = require("vue");
+const parentNameProvideSymbol = Symbol('carefrees-parent-name');
+const useFormItemParentNameProvide = (props)=>{
+    const { name, sort } = props;
+    (0, external_vue_namespaceObject.provide)(parentNameProvideSymbol, (0, external_vue_namespaceObject.computed)(()=>({
+            name,
+            sort
+        })));
+};
+const useFormItemParentNameInject = (options)=>{
+    const { isJoinParentField = true, sort, name } = options;
+    const parentItem = (0, external_vue_namespaceObject.inject)(parentNameProvideSymbol, (0, external_vue_namespaceObject.computed)(()=>({
+            name: (0, external_vue_namespaceObject.ref)(''),
+            sort: (0, external_vue_namespaceObject.ref)('')
+        })));
+    const newName = (0, external_vue_namespaceObject.computed)(()=>{
+        const _name = (0, external_vue_namespaceObject.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 = (0, external_vue_namespaceObject.computed)(()=>{
+        const _sort = (0, external_vue_namespaceObject.toValue)(parentItem.value.sort);
+        return [
+            isJoinParentField ? _sort : '',
+            sort
+        ].filter(Boolean).join('-');
+    });
+    return {
+        newName,
+        newSort,
+        parentItem
+    };
+};
+exports.useFormItemParentNameInject = __webpack_exports__.useFormItemParentNameInject;
+exports.useFormItemParentNameProvide = __webpack_exports__.useFormItemParentNameProvide;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useFormItemParentNameInject",
+    "useFormItemParentNameProvide"
+].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,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>;

package/lib/hooks/useFormList.js

@@ -0,0 +1,61 @@
+"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,
+    useFormListInject: ()=>useFormListInject,
+    useFormListProvide: ()=>useFormListProvide
+});
+const formListInstance_js_namespaceObject = require("../instance/formListInstance.js");
+const external_vue_namespaceObject = require("vue");
+const formListProvideSymbol = Symbol('carefrees-form-list');
+function useFormListProvide(formList) {
+    const newFormList = useFormList(formList);
+    (0, external_vue_namespaceObject.provide)(formListProvideSymbol, newFormList);
+}
+function useFormListInject() {
+    const formList = (0, external_vue_namespaceObject.inject)(formListProvideSymbol, (0, external_vue_namespaceObject.ref)(new formListInstance_js_namespaceObject.FormListInstanceBase()));
+    return formList;
+}
+function useFormList(formList) {
+    const refForm = (0, external_vue_namespaceObject.ref)();
+    if (!refForm.value) {
+        const value = (0, external_vue_namespaceObject.toValue)(formList);
+        if (value) refForm.value = value;
+        else refForm.value = new formListInstance_js_namespaceObject.FormListInstanceBase();
+    }
+    return refForm;
+}
+exports.useFormList = __webpack_exports__.useFormList;
+exports.useFormListInject = __webpack_exports__.useFormListInject;
+exports.useFormListProvide = __webpack_exports__.useFormListProvide;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useFormList",
+    "useFormListInject",
+    "useFormListProvide"
+].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,2 @@
+import { Ref } from 'vue';
+export declare const useHtmlFor: (suffix: Ref<string>) => import("vue").ComputedRef<string>;

package/lib/hooks/useHtmlFor.js

@@ -0,0 +1,41 @@
+"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_vue_namespaceObject = require("vue");
+let localId = 0;
+const useHtmlFor = (suffix)=>{
+    const count = (0, external_vue_namespaceObject.ref)(localId++);
+    return (0, external_vue_namespaceObject.computed)(()=>`carefree-vue-form-item_${count.value.toString(32)}_${suffix.value}`);
+};
+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,8 @@
+import { MultipleInstanceBase } from '../instance/multipleInstance';
+import { Ref } from 'vue';
+/**多表单收集 Context */
+export declare function useMultipleFormProvide(multipleForm?: Ref<MultipleInstanceBase> | MultipleInstanceBase): void;
+/**子项中获取 多表单收集 实例*/
+export declare function useMultipleFormInject(): Ref<MultipleInstanceBase, MultipleInstanceBase>;
+/**初始化 多表单收集 实例*/
+export declare function useMultipleForm(multipleForm?: Ref<MultipleInstanceBase> | MultipleInstanceBase): Ref<MultipleInstanceBase | undefined, MultipleInstanceBase | undefined>;

package/lib/hooks/useMultipleForm.js

@@ -0,0 +1,61 @@
+"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__, {
+    useMultipleFormProvide: ()=>useMultipleFormProvide,
+    useMultipleForm: ()=>useMultipleForm,
+    useMultipleFormInject: ()=>useMultipleFormInject
+});
+const multipleInstance_js_namespaceObject = require("../instance/multipleInstance.js");
+const external_vue_namespaceObject = require("vue");
+const multipleFormProvideSymbol = Symbol('carefrees-multiple-form');
+function useMultipleFormProvide(multipleForm) {
+    const newMultipleForm = useMultipleForm(multipleForm);
+    (0, external_vue_namespaceObject.provide)(multipleFormProvideSymbol, newMultipleForm);
+}
+function useMultipleFormInject() {
+    const multipleForm = (0, external_vue_namespaceObject.inject)(multipleFormProvideSymbol, (0, external_vue_namespaceObject.ref)(new multipleInstance_js_namespaceObject.MultipleInstanceBase()));
+    return multipleForm;
+}
+function useMultipleForm(multipleForm) {
+    const refForm = (0, external_vue_namespaceObject.ref)();
+    if (!refForm.value) {
+        const value = (0, external_vue_namespaceObject.toValue)(multipleForm);
+        if (value) refForm.value = value;
+        else refForm.value = new multipleInstance_js_namespaceObject.MultipleInstanceBase();
+    }
+    return refForm;
+}
+exports.useMultipleForm = __webpack_exports__.useMultipleForm;
+exports.useMultipleFormInject = __webpack_exports__.useMultipleFormInject;
+exports.useMultipleFormProvide = __webpack_exports__.useMultipleFormProvide;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useMultipleForm",
+    "useMultipleFormInject",
+    "useMultipleFormProvide"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/hooks/useRule.d.ts

@@ -0,0 +1,4 @@
+import { RuleInstanceBase } from '../instance/ruleIntsnace';
+import { Ref } from 'vue';
+/** 初始化 规则实例*/
+export declare function useRules(rules?: Ref<RuleInstanceBase> | RuleInstanceBase): Ref<RuleInstanceBase>;

package/lib/hooks/useRule.js

@@ -0,0 +1,46 @@
+"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__, {
+    useRules: ()=>useRules
+});
+const ruleIntsnace_js_namespaceObject = require("../instance/ruleIntsnace.js");
+const external_vue_namespaceObject = require("vue");
+function useRules(rules) {
+    const refRules = (0, external_vue_namespaceObject.ref)();
+    if (!refRules.value) {
+        const value = (0, external_vue_namespaceObject.toValue)(rules);
+        if (value) refRules.value = value;
+        else refRules.value = new ruleIntsnace_js_namespaceObject.RuleInstanceBase();
+    }
+    return refRules;
+}
+exports.useRules = __webpack_exports__.useRules;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useRules"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './interface';
+export * from './hooks/index';
+export * from './utils';
+export * from './instance';