@fangzhongya/fang-ui 0.0.3 → 0.0.5

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

@@ -1,170 +1,260 @@
-import { withInstall } from '../../utils';
-declare const Forms: withInstall<import("vue").DefineComponent<{
-    list: import("../../utils").EpPropFinalized<{
-        (arrayLength: number): import("./src/data").ListObj[];
-        (...items: import("./src/data").ListObj[]): import("./src/data").ListObj[];
-        new (arrayLength: number): import("./src/data").ListObj[];
-        new (...items: import("./src/data").ListObj[]): import("./src/data").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>;
+declare const Forms: import('../../utils/vues').WithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    list: {
+        type: {
+            (arrayLength: number): import('./src/data').ListObj[];
+            (...items: import('./src/data').ListObj[]): import('./src/data').ListObj[];
+            new (arrayLength: number): import('./src/data').ListObj[];
+            new (...items: import('./src/data').ListObj[]): import('./src/data').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<import("./src/data").ButObj[]>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
+        type: {
+            (arrayLength: number): import('./src/data').ButObj[];
+            (...items: import('./src/data').ButObj[]): import('./src/data').ButObj[];
+            new (arrayLength: number): import('./src/data').ButObj[];
+            new (...items: import('./src/data').ButObj[]): import('./src/data').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;
+        type: FunctionConstructor;
     };
-}, {
+}>, {
     submitForm: () => void;
     getForm: () => Promise<unknown>;
     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): import("./src/data").ListObj[];
-        (...items: import("./src/data").ListObj[]): import("./src/data").ListObj[];
-        new (arrayLength: number): import("./src/data").ListObj[];
-        new (...items: import("./src/data").ListObj[]): import("./src/data").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): import('./src/data').ListObj[];
+            (...items: import('./src/data').ListObj[]): import('./src/data').ListObj[];
+            new (arrayLength: number): import('./src/data').ListObj[];
+            new (...items: import('./src/data').ListObj[]): import('./src/data').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<import("./src/data").ButObj[]>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
+        type: {
+            (arrayLength: number): import('./src/data').ButObj[];
+            (...items: import('./src/data').ButObj[]): import('./src/data').ButObj[];
+            new (arrayLength: number): import('./src/data').ButObj[];
+            new (...items: import('./src/data').ButObj[]): import('./src/data').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>;
-    list: import("./src/data").ListObj[];
-    selects: Record<string, any>;
-    width: string;
     param: Record<string, any>;
+    list: import('./src/data').ListObj[];
+    disabled: boolean;
+    width: string;
+    selects: Record<string, any>;
     refresh: number;
     inDataFilter: Function;
-}>>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    refForm: unknown;
+}, HTMLDivElement>> & Record<string, any>;
 export { Forms, Forms as default };

package/dist/components/forms/index.js

@@ -1,5 +1,4 @@
-import "vue";
-import { withInstall } from "../../utils/vue/withInstall.js";
+import { withInstall } from "../../utils/vues/withInstall.js";
 import _sfc_main from "./src/index.js";
 const Forms = withInstall(_sfc_main, "Forms");
 export {

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

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const runtime = require("../../../utils/vue/props/runtime.cjs");
-require("vue");
+const buildProps = require("../../../utils/vues/buildProps.cjs");
 const urls = require("../../common/data/urls.cjs");
-const dataProps = runtime.buildProps({
+const dataProps = buildProps.buildProps({
   ...urls.props,
   /**
    * @props { Array<ListObj> } list 展示数据列表

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

@@ -1,5 +1,5 @@
-import type { ExtractPropTypes } from 'vue';
-import type { ObjAny } from '../../../types';
+import { ExtractPublicPropTypes } from 'vue';
+import { ObjAny } from '../../types/object';
 export type ListObj = {
     /**
      * 表单类型
@@ -83,58 +83,101 @@ export type ButObj = {
     [key: string]: any;
 };
 export declare const dataProps: {
-    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>;
+    /**
+     * @props { Array<ListObj> } list 展示数据列表
+     */
+    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[];
+    };
+    /**
+     * @props { Boolean } disabled 是否全部禁用
+     */
     disabled: {
-        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
-        readonly required: false;
-        readonly validator: ((val: unknown) => boolean) | undefined;
-        __epPropKey: true;
+        type: BooleanConstructor;
+    };
+    /**
+     * @props { Object } selects 选择数据集合
+     */
+    selects: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    /**
+     * @props { String } width=80px ( )
+     * 标签的长度
+     */
+    width: {
+        type: StringConstructor;
+        default: string;
     };
-    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>;
+    /**
+     * @props { Object } value 默认展示数据
+     */
+    value: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    /**
+     * @props { Object } buts=[] 表单按钮
+     * pid: {1, 调用确认提交的方法; 2, 调用取消的方法}
+     */
     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;
+        type: FunctionConstructor;
     };
 };
-export type DataProps = ExtractPropTypes<typeof dataProps>;
+export type DataProps = ExtractPublicPropTypes<typeof dataProps>;
 /**
  * @emits submit 提交数据
  * @emits cancel 取消

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

@@ -1,5 +1,4 @@
-import { buildProps } from "../../../utils/vue/props/runtime.js";
-import "vue";
+import { buildProps } from "../../../utils/vues/buildProps.js";
 import { props } from "../../common/data/urls.js";
 const dataProps = buildProps({
   ...props,