@fangzhongya/fang-ui 0.0.3 → 0.0.5

package/dist/components/forms/src/index.cjs

@@ -5,19 +5,19 @@ const data = require("./data.cjs");
 const index$2 = require("../../forms-item/index.cjs");
 const elementPlus = require("element-plus");
 const index$1 = require("../../../hooks/cssname/index.cjs");
-require("../../../hooks/global-config/index.cjs");
-const css = require("../../../utils/css.cjs");
 const index = require("../../../hooks/locale/index.cjs");
+const css = require("../../../utils/css.cjs");
 const util = require("./util.cjs");
 const _hoisted_1 = { key: 0 };
 const _sfc_main = /* @__PURE__ */ vue.defineComponent({
   __name: "index",
   props: data.dataProps,
   emits: data.dataEmits,
-  setup(__props, { expose, emit }) {
-    const props = __props;
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const ElForm = elementPlus.ElForm;
     const { getLocale } = index.useLocale();
     const cs = index$1.useCssName("forms");
+    const props = __props;
     const buts = vue.computed(() => {
       if (typeof props.buts == "undefined") {
         return [
@@ -40,6 +40,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
       rules: {},
       defObj: {}
     });
+    const emit = __emit;
     const refForm = vue.ref();
     function setStyles(v) {
       let width = v.width;
@@ -78,11 +79,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     vue.watch(
       () => props.value,
       () => {
-        data$1.form = Object.assign(
-          {},
-          data$1.defObj,
-          props.value
-        );
+        data$1.form = Object.assign({}, data$1.defObj, props.value);
       }
     );
     vue.watch(
@@ -132,7 +129,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
       }
     }
     setForm();
-    expose({
+    __expose({
       ...data.dataExpose,
       submitForm,
       getForm
@@ -144,7 +141,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
         vue.createElementVNode("div", {
           class: vue.normalizeClass(vue.unref(cs).z("div"))
         }, [
-          vue.createVNode(vue.unref(elementPlus.ElForm), {
+          vue.createVNode(vue.unref(ElForm), {
             "status-icon": "",
             class: vue.normalizeClass(vue.unref(cs).z("el")),
             model: data$1.form,
@@ -164,9 +161,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
                     style: vue.normalizeStyle(setStyles(val))
                   }, [
                     vue.withDirectives(vue.createVNode(vue.unref(elementPlus.ElFormItem), {
-                      class: vue.normalizeClass(
-                        vue.unref(cs).z("el-item", val.class)
-                      ),
+                      class: vue.normalizeClass(vue.unref(cs).z("el-item", val.class)),
                       label: val.label,
                       prop: val.prop,
                       required: val.required,
@@ -190,12 +185,12 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
                   ], 4))
                 ], 64);
               }), 256)),
-              vue.unref(buts) && vue.unref(buts).length > 0 ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElFormItem), {
+              buts.value && buts.value.length > 0 ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElFormItem), {
                 key: 0,
                 class: vue.normalizeClass(vue.unref(cs).z("buts"))
               }, {
                 default: vue.withCtx(() => [
-                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(buts), (item, index2) => {
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(buts.value, (item, index2) => {
                     return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElButton), {
                       key: index2,
                       type: item.type,

package/dist/components/forms/src/index.d.ts

@@ -1,170 +1,263 @@
-import { type ListObj, type ButObj } from './data';
-declare const _sfc_main: import("vue").DefineComponent<{
-    list: import("../../../utils").EpPropFinalized<{
-        (arrayLength: number): ListObj[];
-        (...items: ListObj[]): ListObj[];
-        new (arrayLength: number): ListObj[];
-        new (...items: ListObj[]): ListObj[];
-        isArray(arg: any): arg is any[];
-        readonly prototype: any[];
-        from<T>(arrayLike: ArrayLike<T>): T[];
-        from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
-        from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
-        from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
-        of<T_4>(...items: T_4[]): T_4[];
-        readonly [Symbol.species]: ArrayConstructor;
-    }, unknown, unknown, () => never[], boolean>;
+import { ListObj, ButObj } from './data';
+declare function getForm(): Promise<unknown>;
+declare function submitForm(): void;
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    list: {
+        type: {
+            (arrayLength: number): ListObj[];
+            (...items: ListObj[]): ListObj[];
+            new (arrayLength: number): ListObj[];
+            new (...items: ListObj[]): ListObj[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
     disabled: {
-        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
-    };
-    selects: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
-    width: import("../../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
-    value: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+        type: BooleanConstructor;
+    };
+    selects: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    width: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: ObjectConstructor;
+        default(): {};
+    };
     buts: {
-        readonly type: import("vue").PropType<ButObj[]>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
+        type: {
+            (arrayLength: number): ButObj[];
+            (...items: ButObj[]): ButObj[];
+            new (arrayLength: number): ButObj[];
+            new (...items: ButObj[]): ButObj[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
     };
     ajax: {
-        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(StringConstructor | FunctionConstructor)[], unknown, unknown>>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
+        type: (StringConstructor | FunctionConstructor)[];
+    };
+    param: {
+        type: ObjectConstructor;
+        default(): {};
     };
-    param: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
     axios: {
-        readonly type: import("vue").PropType<Record<string, any>>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
+        type: ObjectConstructor;
+    };
+    refresh: {
+        type: NumberConstructor;
+        default: number;
+    };
+    inDataFilter: {
+        type: FunctionConstructor;
+        default(res: any): any;
     };
-    refresh: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
-    inDataFilter: import("../../../utils").EpPropFinalized<FunctionConstructor, unknown, unknown, (res: any) => any, boolean>;
     inParamFilter: {
-        readonly type: import("vue").PropType<Function>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
-    };
-}, {
-    submitForm: () => void;
-    getForm: () => Promise<unknown>;
+        type: FunctionConstructor;
+    };
+}>, {
+    submitForm: typeof submitForm;
+    getForm: typeof getForm;
     length: number;
     toString(): string;
     toLocaleString(): string;
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
     pop(): string | undefined;
     push(...items: string[]): number;
     concat(...items: ConcatArray<string>[]): string[];
     concat(...items: (string | ConcatArray<string>)[]): string[];
-    join(separator?: string | undefined): string;
+    join(separator?: string): string;
     reverse(): string[];
     shift(): string | undefined;
-    slice(start?: number | undefined, end?: number | undefined): string[];
+    slice(start?: number, end?: number): string[];
     sort(compareFn?: ((a: string, b: string) => number) | undefined): string[];
-    splice(start: number, deleteCount?: number | undefined): string[];
+    splice(start: number, deleteCount?: number): string[];
     splice(start: number, deleteCount: number, ...items: string[]): string[];
     unshift(...items: string[]): number;
-    indexOf(searchElement: string, fromIndex?: number | undefined): number;
-    lastIndexOf(searchElement: string, fromIndex?: number | undefined): number;
+    indexOf(searchElement: string, fromIndex?: number): number;
+    lastIndexOf(searchElement: string, fromIndex?: number): number;
     every<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): this is S[];
     every(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
     some(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
     forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void;
-    map<U_2>(callbackfn: (value: string, index: number, array: string[]) => U_2, thisArg?: any): U_2[];
-    filter<S_1 extends string>(predicate: (value: string, index: number, array: string[]) => value is S_1, thisArg?: any): S_1[];
+    map<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[];
+    filter<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[];
     filter(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string[];
     reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
     reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
-    reduce<U_3>(callbackfn: (previousValue: U_3, currentValue: string, currentIndex: number, array: string[]) => U_3, initialValue: U_3): U_3;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
     reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
     reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
-    reduceRight<U_4>(callbackfn: (previousValue: U_4, currentValue: string, currentIndex: number, array: string[]) => U_4, initialValue: U_4): U_4;
-    find<S_2 extends string>(predicate: (this: void, value: string, index: number, obj: string[]) => value is S_2, thisArg?: any): S_2 | undefined;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
+    find<S extends string>(predicate: (value: string, index: number, obj: string[]) => value is S, thisArg?: any): S | undefined;
     find(predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): string | undefined;
     findIndex(predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): number;
-    fill(value: string, start?: number | undefined, end?: number | undefined): string[];
-    copyWithin(target: number, start: number, end?: number | undefined): string[];
-    entries(): IterableIterator<[number, string]>;
-    keys(): IterableIterator<number>;
-    values(): IterableIterator<string>;
-    includes(searchElement: string, fromIndex?: number | undefined): boolean;
-    flatMap<U_5, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U_5 | readonly U_5[], thisArg?: This | undefined): U_5[];
+    fill(value: string, start?: number, end?: number): string[];
+    copyWithin(target: number, start: number, end?: number): string[];
+    entries(): ArrayIterator<[number, string]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<string>;
+    includes(searchElement: string, fromIndex?: number): boolean;
+    flatMap<U, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U | readonly U[], thisArg?: This | undefined): U[];
     flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
     at(index: number): string | undefined;
-    [Symbol.iterator](): IterableIterator<string>;
-    [Symbol.unscopables](): {
-        copyWithin: boolean;
-        entries: boolean;
-        fill: boolean;
-        find: boolean;
-        findIndex: boolean;
-        keys: boolean;
-        values: boolean;
-    };
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    list: import("../../../utils").EpPropFinalized<{
-        (arrayLength: number): ListObj[];
-        (...items: ListObj[]): ListObj[];
-        new (arrayLength: number): ListObj[];
-        new (...items: ListObj[]): ListObj[];
-        isArray(arg: any): arg is any[];
-        readonly prototype: any[];
-        from<T>(arrayLike: ArrayLike<T>): T[];
-        from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
-        from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
-        from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
-        of<T_4>(...items: T_4[]): T_4[];
-        readonly [Symbol.species]: ArrayConstructor;
-    }, unknown, unknown, () => never[], boolean>;
+    findLast<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S | undefined;
+    findLast(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string | undefined;
+    findLastIndex(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): number;
+    toReversed(): string[];
+    toSorted(compareFn?: ((a: string, b: string) => number) | undefined): string[];
+    toSpliced(start: number, deleteCount: number, ...items: string[]): string[];
+    toSpliced(start: number, deleteCount?: number): string[];
+    with(index: number, value: string): string[];
+    [Symbol.iterator](): ArrayIterator<string>;
+    [Symbol.unscopables]: {
+        [x: number]: boolean | undefined;
+        length?: boolean | undefined;
+        toString?: boolean | undefined;
+        toLocaleString?: boolean | undefined;
+        pop?: boolean | undefined;
+        push?: boolean | undefined;
+        concat?: boolean | undefined;
+        join?: boolean | undefined;
+        reverse?: boolean | undefined;
+        shift?: boolean | undefined;
+        slice?: boolean | undefined;
+        sort?: boolean | undefined;
+        splice?: boolean | undefined;
+        unshift?: boolean | undefined;
+        indexOf?: boolean | undefined;
+        lastIndexOf?: boolean | undefined;
+        every?: boolean | undefined;
+        some?: boolean | undefined;
+        forEach?: boolean | undefined;
+        map?: boolean | undefined;
+        filter?: boolean | undefined;
+        reduce?: boolean | undefined;
+        reduceRight?: boolean | undefined;
+        find?: boolean | undefined;
+        findIndex?: boolean | undefined;
+        fill?: boolean | undefined;
+        copyWithin?: boolean | undefined;
+        entries?: boolean | undefined;
+        keys?: boolean | undefined;
+        values?: boolean | undefined;
+        includes?: boolean | undefined;
+        flatMap?: boolean | undefined;
+        flat?: boolean | undefined;
+        at?: boolean | undefined;
+        findLast?: boolean | undefined;
+        findLastIndex?: boolean | undefined;
+        toReversed?: boolean | undefined;
+        toSorted?: boolean | undefined;
+        toSpliced?: boolean | undefined;
+        with?: boolean | undefined;
+        [Symbol.iterator]?: boolean | undefined;
+        readonly [Symbol.unscopables]?: boolean | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    list: {
+        type: {
+            (arrayLength: number): ListObj[];
+            (...items: ListObj[]): ListObj[];
+            new (arrayLength: number): ListObj[];
+            new (...items: ListObj[]): ListObj[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
     disabled: {
-        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
-    };
-    selects: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
-    width: import("../../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
-    value: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+        type: BooleanConstructor;
+    };
+    selects: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    width: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: ObjectConstructor;
+        default(): {};
+    };
     buts: {
-        readonly type: import("vue").PropType<ButObj[]>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
+        type: {
+            (arrayLength: number): ButObj[];
+            (...items: ButObj[]): ButObj[];
+            new (arrayLength: number): ButObj[];
+            new (...items: ButObj[]): ButObj[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
     };
     ajax: {
-        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(StringConstructor | FunctionConstructor)[], unknown, unknown>>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
+        type: (StringConstructor | FunctionConstructor)[];
+    };
+    param: {
+        type: ObjectConstructor;
+        default(): {};
     };
-    param: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
     axios: {
-        readonly type: import("vue").PropType<Record<string, any>>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
+        type: ObjectConstructor;
+    };
+    refresh: {
+        type: NumberConstructor;
+        default: number;
+    };
+    inDataFilter: {
+        type: FunctionConstructor;
+        default(res: any): any;
     };
-    refresh: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
-    inDataFilter: import("../../../utils").EpPropFinalized<FunctionConstructor, unknown, unknown, (res: any) => any, boolean>;
     inParamFilter: {
-        readonly type: import("vue").PropType<Function>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
-    };
-}>> & {
-    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
-}, {
+        type: FunctionConstructor;
+    };
+}>> & Readonly<{}>, {
     value: Record<string, any>;
+    param: Record<string, any>;
     list: ListObj[];
-    selects: Record<string, any>;
+    disabled: boolean;
     width: string;
-    param: Record<string, any>;
+    selects: Record<string, any>;
     refresh: number;
     inDataFilter: Function;
-}>;
-export default _sfc_main;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    refForm: unknown;
+}, HTMLDivElement>;
+export default _default;

package/dist/components/forms/src/index.js

@@ -1,21 +1,21 @@
-import { defineComponent, computed, reactive, ref, watch, openBlock, createElementBlock, normalizeClass, unref, createElementVNode, createVNode, withCtx, Fragment, renderList, toDisplayString, normalizeStyle, withDirectives, vShow, createBlock, createTextVNode, createCommentVNode } from "vue";
-import { dataProps, dataEmits, dataExpose } from "./data.js";
+import { defineComponent, computed, reactive, ref, watch, createElementBlock, openBlock, normalizeClass, unref, createElementVNode, createVNode, withCtx, createBlock, createCommentVNode, Fragment, renderList, toDisplayString, normalizeStyle, withDirectives, vShow, createTextVNode } from "vue";
+import { dataEmits, dataProps, dataExpose } from "./data.js";
 import { FormsItem } from "../../forms-item/index.js";
 import { ElForm, ElFormItem, ElButton } from "element-plus";
 import { useCssName } from "../../../hooks/cssname/index.js";
-import "../../../hooks/global-config/index.js";
-import { setObjStyle } from "../../../utils/css.js";
 import { useLocale } from "../../../hooks/locale/index.js";
+import { setObjStyle } from "../../../utils/css.js";
 import { getRule } from "./util.js";
 const _hoisted_1 = { key: 0 };
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "index",
   props: dataProps,
   emits: dataEmits,
-  setup(__props, { expose, emit }) {
-    const props = __props;
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const ElForm$1 = ElForm;
     const { getLocale } = useLocale();
     const cs = useCssName("forms");
+    const props = __props;
     const buts = computed(() => {
       if (typeof props.buts == "undefined") {
         return [
@@ -38,6 +38,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       rules: {},
       defObj: {}
     });
+    const emit = __emit;
     const refForm = ref();
     function setStyles(v) {
       let width = v.width;
@@ -76,11 +77,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     watch(
       () => props.value,
       () => {
-        data.form = Object.assign(
-          {},
-          data.defObj,
-          props.value
-        );
+        data.form = Object.assign({}, data.defObj, props.value);
       }
     );
     watch(
@@ -130,7 +127,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       }
     }
     setForm();
-    expose({
+    __expose({
       ...dataExpose,
       submitForm,
       getForm
@@ -142,7 +139,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         createElementVNode("div", {
           class: normalizeClass(unref(cs).z("div"))
         }, [
-          createVNode(unref(ElForm), {
+          createVNode(unref(ElForm$1), {
             "status-icon": "",
             class: normalizeClass(unref(cs).z("el")),
             model: data.form,
@@ -162,9 +159,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                     style: normalizeStyle(setStyles(val))
                   }, [
                     withDirectives(createVNode(unref(ElFormItem), {
-                      class: normalizeClass(
-                        unref(cs).z("el-item", val.class)
-                      ),
+                      class: normalizeClass(unref(cs).z("el-item", val.class)),
                       label: val.label,
                       prop: val.prop,
                       required: val.required,
@@ -188,12 +183,12 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                   ], 4))
                 ], 64);
               }), 256)),
-              unref(buts) && unref(buts).length > 0 ? (openBlock(), createBlock(unref(ElFormItem), {
+              buts.value && buts.value.length > 0 ? (openBlock(), createBlock(unref(ElFormItem), {
                 key: 0,
                 class: normalizeClass(unref(cs).z("buts"))
               }, {
                 default: withCtx(() => [
-                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref(buts), (item, index) => {
+                  (openBlock(true), createElementBlock(Fragment, null, renderList(buts.value, (item, index) => {
                     return openBlock(), createBlock(unref(ElButton), {
                       key: index,
                       type: item.type,

package/dist/components/forms/src/util.cjs

@@ -55,11 +55,7 @@ function getRule(v, getLocale) {
         } else if (multiple && val.length == 0) {
           callback(new Error(typename + name));
         } else if (isjy(val)) {
-          callback(
-            new Error(
-              name + getLocale("form.verif")
-            )
-          );
+          callback(new Error(name + getLocale("form.verif")));
         } else {
           callback();
         }
@@ -69,11 +65,7 @@ function getRule(v, getLocale) {
         if (v.hide) {
           callback();
         } else if (val && val !== 0 && isjy(val)) {
-          callback(
-            new Error(
-              name + getLocale("form.verif")
-            )
-          );
+          callback(new Error(name + getLocale("form.verif")));
         } else {
           callback();
         }

package/dist/components/forms/src/util.d.ts

@@ -1,5 +1,5 @@
-import type { ListObj } from './data';
-import type { Translator } from '../../../types';
+import { ListObj } from './data';
+import { Translator } from '../../types/locale';
 /**
  * 后期要实现 v.rule 多匹配，
  * 错误提示自定义

package/dist/components/forms/src/util.js

@@ -53,11 +53,7 @@ function getRule(v, getLocale) {
         } else if (multiple && val.length == 0) {
           callback(new Error(typename + name));
         } else if (isjy(val)) {
-          callback(
-            new Error(
-              name + getLocale("form.verif")
-            )
-          );
+          callback(new Error(name + getLocale("form.verif")));
         } else {
           callback();
         }
@@ -67,11 +63,7 @@ function getRule(v, getLocale) {
         if (v.hide) {
           callback();
         } else if (val && val !== 0 && isjy(val)) {
-          callback(
-            new Error(
-              name + getLocale("form.verif")
-            )
-          );
+          callback(new Error(name + getLocale("form.verif")));
         } else {
           callback();
         }

package/dist/components/forms-item/index.cjs

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-require("vue");
-const withInstall = require("../../utils/vue/withInstall.cjs");
+const withInstall = require("../../utils/vues/withInstall.cjs");
 const index_vue_vue_type_script_setup_true_lang = require("./src/index.cjs");
 const FormsItem = withInstall.withInstall(index_vue_vue_type_script_setup_true_lang.default, "FormsItem");
 exports.FormsItem = FormsItem;