@carefrees/form-utils-vue 0.0.10 → 0.0.12

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

@@ -1,5 +1,8 @@
+/**
+ * @description 注册组件
+ */
 import { Ref } from 'vue';
-import { RuleItem } from 'async-validator';
+import type { RuleItem } from 'async-validator';
 import { RuleInstanceBase2 } from '../../instance/ruleIntsnace';
 export interface RegisterFormItemOptions {
     /**字段*/
@@ -14,10 +17,10 @@ export interface RegisterFormItemOptions {
 /**注册表单项到表单实例中*/
 export declare const useRegisterFormItem: (options: RegisterFormItemOptions) => {
     ruleInstance: Ref<RuleInstanceBase2, RuleInstanceBase2>;
-    formItemInstance: import('@carefrees/form-utils').FormItemInstanceBase;
-    form: import('@carefrees/form-utils').FormInstanceBase<any>;
-    newName: import('vue').ComputedRef<string>;
-    newSort: import('vue').ComputedRef<string>;
-    parentItem: import('vue').ComputedRef<import('../..').PartialComputedRefs<Omit<import('../useFormItemParentName').FormItemParentNamOptions, "isJoinParentField">>>;
+    formItemInstance: import("@carefrees/form-utils").FormItemInstanceBase;
+    form: import("@carefrees/form-utils").FormInstanceBase<any>;
+    newName: import("vue").ComputedRef<string>;
+    newSort: import("vue").ComputedRef<string>;
+    parentItem: import("vue").ComputedRef<import("../..").PartialComputedRefs<Omit<import("..").FormItemParentNamOptions, "isJoinParentField">>>;
     deepRefData: 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 { RuleInstanceBase2 } from "../../instance/ruleIntsnace.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 ruleInstance = ref(new RuleInstanceBase2());
+    const formItemInstance = useFormItem();
+    watch(()=>[
+            form
+        ], ()=>{
+        ruleInstance.value.instance = form;
+        formItemInstance.instance = form;
+    }, {
+        immediate: true
+    });
+    watch(()=>[
+            toValue(newName)
+        ], ()=>{
+        ruleInstance.value.ctor(toValue(newName), rules || []);
+        formItemInstance.ctor(toValue(newName), toValue(ruleInstance));
+    }, {
+        immediate: true
+    });
+    watch(()=>[
+            toValue(newSort)
+        ], ()=>{
+        ruleInstance.value.sort = toValue(newSort);
+        formItemInstance.sort = toValue(newSort);
+    }, {
+        immediate: true
+    });
+    watch(()=>[
+            toValue(parentItem)
+        ], ()=>{
+        formItemInstance.parentDataField = toValue(toValue(parentItem).name);
+    }, {
+        immediate: true
+    });
+    const updated = ()=>{
+        deepRefData.value = {
+            __temp: new Date().valueOf()
+        };
+    };
+    formItemInstance.updated = updated;
+    ruleInstance.value.updated = updated;
+    useEffect(()=>form.registerFormItem(formItemInstance));
+    return {
+        ruleInstance,
+        formItemInstance,
+        form,
+        newName,
+        newSort,
+        parentItem,
+        deepRefData
+    };
+};
+export { useRegisterFormItem };

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

@@ -3,7 +3,7 @@ export interface RegisterFormListOptions extends RegisterFormItemOptions {
 }
 /**注册表单List到表单实例中*/
 export declare const useRegisterFormList: (options: RegisterFormListOptions) => {
-    ruleInstance: import('vue').Ref<import('../../instance/ruleIntsnace').RuleInstanceBase2, import('../../instance/ruleIntsnace').RuleInstanceBase2>;
-    formItemInstance: import('@carefrees/form-utils').FormItemInstanceBase;
-    formListInstance: import('@carefrees/form-utils').FormListInstanceBase;
+    ruleInstance: import("vue").Ref<import("../../instance/ruleIntsnace").RuleInstanceBase2, import("../../instance/ruleIntsnace").RuleInstanceBase2>;
+    formItemInstance: import("@carefrees/form-utils").FormItemInstanceBase;
+    formListInstance: import("@carefrees/form-utils").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.ctor(toValue(newName));
+    }, {
+        immediate: true
+    });
+    watch(()=>[
+            form,
+            formItemInstance,
+            toValue(ruleInstance)
+        ], ()=>{
+        formListInstance.instance = form;
+        formListInstance.formItemInstance = formItemInstance;
+        formListInstance.rule = toValue(ruleInstance);
+    }, {
+        immediate: true
+    });
+    watch(()=>[
+            options.sort,
+            toValue(parentItem)
+        ], ()=>{
+        formListInstance.sort = toValue(parentItem.value.sort);
+        formListInstance.parentDataField = toValue(parentItem.value.name);
+    }, {
+        immediate: true
+    });
+    useEffect(()=>form.registerFormList(newName.value, formListInstance));
+    return {
+        ruleInstance,
+        formItemInstance,
+        formListInstance
+    };
+};
+export { useRegisterFormList };

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

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

package/esm/hooks/useAttrs.d.ts

@@ -1,3 +1,4 @@
+/**公共属性*/
 import { StyleValue, ComputedRef } from 'vue';
 import { ComputedRefBase } from '../interface';
 export type 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.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

@@ -5,4 +5,4 @@ export declare function useFormProvide<T = any>(form: FormInstanceBase<T>): void
 /**子项中获取表单实例*/
 export declare function useFormInject<T = any>(): FormInstanceBase<T>;
 /**初始化表单实例*/
-export declare function useForm<T = any>(form?: FormInstanceBase<T>): Ref<FormInstanceBase<T>, FormInstanceBase<T>>;
+export declare function useForm<T = any>(form?: FormInstanceBase<T>): Ref<FormInstanceBase<T>>;

package/esm/hooks/useForm.js

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

package/esm/hooks/useFormItem.js

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

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.js

@@ -0,0 +1,17 @@
+import { FormListInstanceBase } from "@carefrees/form-utils";
+import { inject, provide, ref } from "vue";
+const formListProvideSymbol = Symbol('carefrees-form-list');
+function useFormListProvide(formList) {
+    provide(formListProvideSymbol, formList);
+}
+function useFormListInject() {
+    const formList = inject(formListProvideSymbol, new FormListInstanceBase());
+    return formList;
+}
+function useFormList(formList) {
+    const refForm = ref();
+    if (!refForm.value) if (formList) refForm.value = formList;
+    else refForm.value = new FormListInstanceBase();
+    return refForm.value;
+}
+export { useFormList, useFormListInject, useFormListProvide };

package/esm/hooks/useHtmlFor.d.ts

@@ -1,2 +1,2 @@
 import { Ref } from 'vue';
-export declare const useHtmlFor: (suffix: Ref<string>) => import('vue').ComputedRef<string>;
+export declare const useHtmlFor: (suffix: Ref<string>) => import("vue").ComputedRef<string>;

package/esm/hooks/useHtmlFor.js

@@ -0,0 +1,7 @@
+import { computed, ref } from "vue";
+let localId = 0;
+const useHtmlFor = (suffix)=>{
+    const count = ref(localId++);
+    return computed(()=>`carefree-vue-form-item_${count.value.toString(32)}_${suffix.value}`);
+};
+export { useHtmlFor };

package/esm/hooks/useMultipleForm.d.ts

@@ -1,4 +1,4 @@
-import { MultipleInstanceBase } from '@carefrees/form-utils';
+import { MultipleInstanceBase } from "@carefrees/form-utils";
 /**多表单收集 Context */
 export declare function useMultipleFormProvide(multipleForm?: MultipleInstanceBase): void;
 /**子项中获取 多表单收集 实例*/

package/esm/hooks/useMultipleForm.js

@@ -0,0 +1,18 @@
+import { MultipleInstanceBase } from "@carefrees/form-utils";
+import { inject, provide, ref } from "vue";
+const multipleFormProvideSymbol = Symbol("carefrees-multiple-form");
+function useMultipleFormProvide(multipleForm) {
+    const newMultipleForm = useMultipleForm(multipleForm);
+    provide(multipleFormProvideSymbol, newMultipleForm);
+}
+function useMultipleFormInject() {
+    const multipleForm = inject(multipleFormProvideSymbol, new MultipleInstanceBase());
+    return multipleForm;
+}
+function useMultipleForm(multipleForm) {
+    const refForm = ref();
+    if (!refForm.value) if (multipleForm) refForm.value = multipleForm;
+    else refForm.value = new MultipleInstanceBase();
+    return refForm.value;
+}
+export { useMultipleForm, useMultipleFormInject, useMultipleFormProvide };

package/esm/index.d.ts

@@ -1,10 +1,10 @@
-import { App } from 'vue';
 export * from './hooks';
 export * from './component';
 export * from './utils';
 export * from './interface';
 export * from './interface/layout';
 export * from './interface/layout.formItem';
+import { App } from 'vue';
 declare const _default: {
     install: (app: App) => void;
 };

package/esm/index.js

@@ -0,0 +1,13 @@
+export * from "./hooks/index.js";
+export * from "./component.js";
+export * from "./utils/index.js";
+export * from "./interface/index.js";
+export * from "./interface/layout.js";
+export * from "./interface/layout.formItem.js";
+import * as __WEBPACK_EXTERNAL_MODULE__component_js_7f599402__ from "./component.js";
+const src = {
+    install: (app)=>{
+        for(const c in __WEBPACK_EXTERNAL_MODULE__component_js_7f599402__)app.use(__WEBPACK_EXTERNAL_MODULE__component_js_7f599402__[c]);
+    }
+};
+export { src as default };

package/esm/instance/ruleIntsnace.d.ts

@@ -1,5 +1,5 @@
 import { RuleItem } from 'async-validator';
-import { MessageType, FormInstanceBase } from '@carefrees/form-utils';
+import type { MessageType, FormInstanceBase } from '@carefrees/form-utils';
 import { Ref } from 'vue';
 export declare class RuleInstanceBase2 {
     /**

package/esm/instance/ruleIntsnace.js

@@ -0,0 +1,65 @@
+import async_validator from "async-validator";
+import { ref, toValue } from "vue";
+class RuleInstanceBase2 {
+    sort;
+    instance;
+    name = '';
+    rules = ref([]);
+    messages = ref([]);
+    updated;
+    isRequired = ()=>{
+        if (this.instance?.getFieldHideRulesValue?.(this.name)) return false;
+        const findItem = (toValue(this.rules) || []).find((item)=>item?.required);
+        return !!findItem;
+    };
+    ctor = (name, rules)=>{
+        this.name = name;
+        this.rules.value = rules || [];
+        return this;
+    };
+    isValidate = ()=>{
+        if (this.instance?.getFieldHideRulesValue?.(this.name)) return false;
+        const _rules = toValue(this.rules);
+        return !!(Array.isArray(_rules) && _rules.length);
+    };
+    updatedMessages = (messages)=>{
+        this.messages.value = messages || [];
+        this.updated?.({});
+    };
+    updatedRules = (rules)=>{
+        this.rules.value = rules;
+        this.updatedMessages?.([]);
+    };
+    validate = (isOnly = false)=>new Promise((resolve, reject)=>{
+            const value = this.instance?.getFieldValue?.(this.name);
+            if (this.instance?.getFieldHideRulesValue?.(this.name)) {
+                this.updatedMessages([]);
+                resolve({
+                    [this.name]: value
+                });
+            }
+            new async_validator({
+                [this.name]: toValue(this.rules) || []
+            }).validate({
+                [this.name]: value
+            }).then((values)=>{
+                if (!isOnly) this.updatedMessages([]);
+                resolve(values);
+            }).catch(({ errors })=>{
+                if (Array.isArray(errors)) {
+                    if (!isOnly) this.updatedMessages(errors);
+                    reject(errors);
+                } else reject();
+            });
+        });
+    getValidateResult = ()=>{
+        const _messages = toValue(this.messages);
+        const tip = Array.isArray(_messages) ? _messages.map((it)=>it.message) : '';
+        const isInvalid = Array.isArray(tip) ? !!tip.length : !!tip;
+        return {
+            tip,
+            isInvalid
+        };
+    };
+}
+export { RuleInstanceBase2 };

package/esm/interface/index.d.ts

@@ -33,4 +33,6 @@ export interface FormProps<T = any> extends FormLayoutProps {
     name?: string;
     /**隐藏规则校验*/
     hideRuleData?: Record<string, boolean>;
+    /**背景颜色*/
+    bgcolor?: string;
 }

package/esm/layout/index.d.ts

@@ -1,65 +1,56 @@
-export declare const Layout: import('../utils').SFCWithInstall<{
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('..').FormLayoutProps> & 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 Layout: import("../utils").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../index.js").FormLayoutProps> & 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('..').FormLayoutProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
-} & import('vue').ComponentOptionsBase<Readonly<import('..').FormLayoutProps> & 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: any;
-        title: any;
-        extra: any;
-    }> & {
+    }, Readonly<import("../index.js").FormLayoutProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("../index.js").FormLayoutProps> & 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: any;
         title: any;
         extra: any;
     };
 })> & Record<string, any>;
-export declare const LayoutFormItem: import('../utils').SFCWithInstall<{
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('..').LayoutFormItemProps> & 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 LayoutFormItem: import("../utils").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../index.js").LayoutFormItemProps> & 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('..').LayoutFormItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
-} & import('vue').ComponentOptionsBase<Readonly<import('..').LayoutFormItemProps> & 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: any;
-        label: any;
-        helpText: any;
-        extra: any;
-    }> & {
+    }, Readonly<import("../index.js").LayoutFormItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("../index.js").LayoutFormItemProps> & 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: any;
         label: any;
         helpText: any;
         extra: any;
     };
 })> & Record<string, any>;
-export declare const FormLayoutRows: import('../utils').SFCWithInstall<{
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').HTMLAttributes> & 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 FormLayoutRows: import("../utils").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").HTMLAttributes> & 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('vue').HTMLAttributes> & Readonly<{}>, {}, {}, {}, {}, {}>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
-} & import('vue').ComponentOptionsBase<Readonly<import('vue').HTMLAttributes> & 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 () => {
+    }, Readonly<import("vue").HTMLAttributes> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").HTMLAttributes> & 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?(_: {}): any;
+        default?: (props: {}) => any;
     };
 })> & Record<string, any>;

package/esm/layout/index.js

@@ -0,0 +1,8 @@
+import layout from "./layout.js";
+import layout_formItem from "./layout.formItem.js";
+import layout_form_rows from "./layout.form.rows.js";
+import { withInstall } from "../utils/index.js";
+const Layout = withInstall(layout);
+const LayoutFormItem = withInstall(layout_formItem);
+const FormLayoutRows = withInstall(layout_form_rows);
+export { FormLayoutRows, Layout, LayoutFormItem };

package/esm/layout/layout.form.rows.js

@@ -0,0 +1,21 @@
+import { computed, createElementBlock, defineComponent, mergeProps, openBlock, renderSlot } from "vue";
+import classnames from "classnames";
+const preCls = "carefrees-form-layout";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    name: "FormLayoutRows",
+    inheritAttrs: false,
+    __name: "layout.form.rows",
+    setup (__props) {
+        const props = __props;
+        const cls = computed(()=>classnames(preCls, props.class, {
+                "all-colspan": true
+            }));
+        return (_ctx, _cache)=>(openBlock(), createElementBlock("div", mergeProps(props, {
+                class: cls.value
+            }), [
+                renderSlot(_ctx.$slots, "default")
+            ], 16));
+    }
+});
+const layout_form_rows = _sfc_main;
+export { layout_form_rows as default };

package/esm/layout/layout.form.rows.vue.d.ts

@@ -1,9 +1,12 @@
-import { HTMLAttributes } from 'vue';
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<HTMLAttributes, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<HTMLAttributes> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
-    default?(_: {}): any;
-}>;
+import { HTMLAttributes } from "vue";
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<HTMLAttributes, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HTMLAttributes> & 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;
     };