@vue-start/pro 0.5.0 → 0.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/dist/index.d.ts +1389 -1387
  2. package/dist/index.es.js +909 -888
  3. package/dist/index.js +1 -1
  4. package/package.json +2 -2
package/dist/index.d.ts CHANGED
@@ -9,1446 +9,1448 @@ import { IRequestActor } from '@vue-start/request';
9
9
  import { Subject } from 'rxjs';
10
10
  import * as lodash from 'lodash';
11
11
 
12
- declare const proGridProps: () => {
13
- row: {
14
- type: PropType<Record<string, any>>;
15
- default: undefined;
16
- };
17
- col: {
18
- type: PropType<Record<string, any>>;
19
- };
20
- items: {
21
- type: PropType<{
22
- vNode: VNode;
23
- rowKey?: string | number | undefined;
24
- col?: Record<string, any> | undefined;
25
- }[]>;
26
- };
27
- };
28
- declare type ProGridProps = Partial<ExtractPropTypes<ReturnType<typeof proGridProps>>>;
29
- declare const ProGrid: vue.DefineComponent<Partial<ExtractPropTypes<{
30
- row: {
31
- type: PropType<Record<string, any>>;
32
- default: undefined;
33
- };
34
- col: {
35
- type: PropType<Record<string, any>>;
36
- };
37
- items: {
38
- type: PropType<{
39
- vNode: VNode;
40
- rowKey?: string | number | undefined;
41
- col?: Record<string, any> | undefined;
42
- }[]>;
43
- };
44
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
45
- row: {
46
- type: PropType<Record<string, any>>;
47
- default: undefined;
48
- };
49
- col: {
50
- type: PropType<Record<string, any>>;
51
- };
52
- items: {
53
- type: PropType<{
54
- vNode: VNode;
55
- rowKey?: string | number | undefined;
56
- col?: Record<string, any> | undefined;
57
- }[]>;
58
- };
12
+ declare const proGridProps: () => {
13
+ row: {
14
+ type: PropType<Record<string, any>>;
15
+ default: undefined;
16
+ };
17
+ col: {
18
+ type: PropType<Record<string, any>>;
19
+ };
20
+ items: {
21
+ type: PropType<{
22
+ vNode: VNode;
23
+ rowKey?: string | number | undefined;
24
+ col?: Record<string, any> | undefined;
25
+ }[]>;
26
+ };
27
+ };
28
+ declare type ProGridProps = Partial<ExtractPropTypes<ReturnType<typeof proGridProps>>>;
29
+ declare const ProGrid: vue.DefineComponent<Partial<ExtractPropTypes<{
30
+ row: {
31
+ type: PropType<Record<string, any>>;
32
+ default: undefined;
33
+ };
34
+ col: {
35
+ type: PropType<Record<string, any>>;
36
+ };
37
+ items: {
38
+ type: PropType<{
39
+ vNode: VNode;
40
+ rowKey?: string | number | undefined;
41
+ col?: Record<string, any> | undefined;
42
+ }[]>;
43
+ };
44
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
45
+ row: {
46
+ type: PropType<Record<string, any>>;
47
+ default: undefined;
48
+ };
49
+ col: {
50
+ type: PropType<Record<string, any>>;
51
+ };
52
+ items: {
53
+ type: PropType<{
54
+ vNode: VNode;
55
+ rowKey?: string | number | undefined;
56
+ col?: Record<string, any> | undefined;
57
+ }[]>;
58
+ };
59
59
  }>>>, {}>;
60
60
 
61
- declare type TDefaultValueType = "text" | "textarea" | "password" | "digit" | "date" | "dateRange" | "time" | "timeRange" | "select" | "treeSelect" | "checkbox" | "radio" | "slider" | "switch" | "rate" | "cascader";
62
- declare type TValueType = TDefaultValueType | string;
63
- declare type TOption = {
64
- label?: string;
65
- value: string | number;
66
- disabled?: boolean;
67
- };
68
- declare type TOptions = TOption[];
69
- declare type TreeOption = {
70
- label?: string;
71
- value: string | number;
72
- disabled?: boolean;
73
- children?: TreeOption[];
74
- };
75
- declare type TreeOptions = TreeOption[];
76
- declare type TColumn = {
77
- title?: string | VNode;
78
- dataIndex?: string | number;
79
- valueType?: TValueType;
80
- formValueType?: TValueType;
81
- showProps?: Record<string, any>;
82
- formItemProps?: {
83
- name?: string;
84
- label?: string;
85
- };
86
- formFieldProps?: Record<string, any>;
87
- search?: boolean;
88
- extra?: {
89
- desc?: Record<string, any>;
90
- col?: Record<string, any>;
91
- } & Record<string, any>;
92
- };
93
- declare type TColumns = TColumn[];
94
- /**
95
- * 发送事件对象
96
- */
97
- declare type TActionEvent = {
98
- type: string;
99
- payload?: any;
100
- /**
101
- * 发送事件源
102
- * 公共组件（如：Curd）只处理source为undefined的事件
103
- * 业务组件可以传入该参数覆盖之前的默认行为
104
- */
105
- source?: string;
106
- extra?: Record<string, any>;
107
- };
108
- /**
109
- * 发送state对象
110
- */
111
- declare type TActionState = {
112
- type: string;
113
- payload: any;
114
- extra?: Record<string, any>;
115
- };
116
- /**
117
- * 组件Map
118
- */
119
- declare type TElementMap = Record<string, any>;
120
- declare type BooleanObjType = {
121
- [key: string]: boolean;
122
- };
123
- declare type BooleanRulesObjType = {
124
- [key: string]: (record: any) => boolean;
125
- };
126
- /**
127
- *
128
- */
129
- interface FieldNames {
130
- value?: string;
131
- label?: string;
132
- children?: string;
61
+ declare type TDefaultValueType = "text" | "textarea" | "password" | "digit" | "date" | "dateRange" | "time" | "timeRange" | "select" | "treeSelect" | "checkbox" | "radio" | "slider" | "switch" | "rate" | "cascader";
62
+ declare type TValueType = TDefaultValueType | string;
63
+ declare type TOption = {
64
+ label?: string;
65
+ value: string | number;
66
+ disabled?: boolean;
67
+ };
68
+ declare type TOptions = TOption[];
69
+ declare type TreeOption = {
70
+ label?: string;
71
+ value: string | number;
72
+ disabled?: boolean;
73
+ children?: TreeOption[];
74
+ };
75
+ declare type TreeOptions = TreeOption[];
76
+ declare type TColumn = {
77
+ title?: string | VNode;
78
+ dataIndex?: string | number;
79
+ valueType?: TValueType;
80
+ formValueType?: TValueType;
81
+ showProps?: Record<string, any>;
82
+ formItemProps?: {
83
+ name?: string;
84
+ label?: string;
85
+ };
86
+ formFieldProps?: Record<string, any>;
87
+ search?: boolean;
88
+ extra?: {
89
+ desc?: Record<string, any>;
90
+ col?: Record<string, any>;
91
+ } & Record<string, any>;
92
+ };
93
+ declare type TColumns = TColumn[];
94
+ /**
95
+ * 发送事件对象
96
+ */
97
+ declare type TActionEvent = {
98
+ type: string;
99
+ payload?: any;
100
+ /**
101
+ * 发送事件源
102
+ * 公共组件（如：Curd）只处理source为undefined的事件
103
+ * 业务组件可以传入该参数覆盖之前的默认行为
104
+ */
105
+ source?: string;
106
+ extra?: Record<string, any>;
107
+ };
108
+ /**
109
+ * 发送state对象
110
+ */
111
+ declare type TActionState = {
112
+ type: string;
113
+ payload: any;
114
+ extra?: Record<string, any>;
115
+ };
116
+ /**
117
+ * 组件Map
118
+ */
119
+ declare type TElementMap = Record<string, any>;
120
+ declare type BooleanObjType = {
121
+ [key: string]: boolean;
122
+ };
123
+ declare type BooleanRulesObjType = {
124
+ [key: string]: (record: any) => boolean;
125
+ };
126
+ /**
127
+ *
128
+ */
129
+ interface FieldNames {
130
+ value?: string;
131
+ label?: string;
132
+ children?: string;
133
133
  }
134
134
 
135
- /***************************************** curd模式 *****************************************/
136
- /**
137
- * 获取Column的valueType，默认"text"
138
- * @param column
139
- */
140
- declare const getColumnValueType: (column: TColumn) => TValueType;
141
- /**
142
- *获取Column的FormItem name
143
- * @param column
144
- */
145
- declare const getColumnFormItemName: (column: TColumn) => string | number | undefined;
146
- /**
147
- * 根据Column生成FormItem VNode
148
- * formFieldProps中的slots参数会以v-slots的形式传递到FormItem的录入组件（子组件）中
149
- * @param formElementMap
150
- * @param column
151
- * @param needRules
152
- */
153
- declare const getFormItemEl: (formElementMap: any, column: TColumn, needRules?: boolean | undefined) => VNode | null;
154
- /**
155
- * 根据Column生成Item VNode
156
- * @param elementMap
157
- * @param column
158
- * @param value
159
- */
160
- declare const getItemEl: <T extends TColumn>(elementMap: any, column: T, value: any) => VNode | null;
161
- /***************************************** 通用模式 *****************************************/
162
- declare type InternalNamePath = (string | number)[];
163
- declare type NamePath = string | number | InternalNamePath;
164
- interface IHighConfig {
165
- registerStateList?: {
166
- name: NamePath;
167
- mapName?: NamePath;
168
- }[];
169
- registerEventList?: {
170
- name: string;
171
- sendEventName?: TActionEvent["type"];
172
- }[];
173
- registerPropsTrans?: {
174
- name: NamePath;
175
- isFun?: boolean;
176
- needParams?: boolean;
177
- }[];
178
- }
179
- /**
180
- * 组件树描述
181
- */
182
- interface IElementConfig {
183
- elementType: string;
184
- elementId: string;
185
- elementProps?: Record<string, any>;
186
- slots?: {
187
- [name: string]: ((...params$: any[]) => any) | (IElementConfig & {
188
- needParams?: boolean;
189
- });
190
- };
191
- children?: IElementConfig[];
192
- childrenSlotName?: string;
193
- highConfig$?: IHighConfig;
194
- }
195
- declare const renderElements: (elementMap: TElementMap, elementConfigs: IElementConfig[]) => (VNode | null)[];
196
- /**
197
- *
198
- * @param elementMap
199
- * @param elementConfig
200
- */
201
- declare const renderElement: (elementMap: TElementMap, elementConfig: IElementConfig) => VNode<vue.RendererNode, vue.RendererElement, {
202
- [key: string]: any;
203
- }>;
204
- /**
205
- * 获取第一层级属性名
206
- * 如：['aaa','bbb',...] 中的 'aaa'
207
- * 如："aaa.bbb.ccc..." 中的 'aaa'
208
- */
209
- declare const getFirstPropName: (name: NamePath) => string | number | undefined;
210
- /**
211
- * 处理highConfig$
212
- */
213
- declare const Wrapper: vue.DefineComponent<{
214
- elementMap: TElementMap;
215
- elementConfig: IElementConfig;
216
- }, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<{
217
- elementMap: TElementMap;
218
- elementConfig: IElementConfig;
135
+ /***************************************** curd模式 *****************************************/
136
+ /**
137
+ * 获取Column的valueType，默认"text"
138
+ * @param column
139
+ */
140
+ declare const getColumnValueType: (column: TColumn) => TValueType;
141
+ /**
142
+ *获取Column的FormItem name
143
+ * @param column
144
+ */
145
+ declare const getColumnFormItemName: (column: TColumn) => string | number | undefined;
146
+ /**
147
+ * 根据Column生成FormItem VNode
148
+ * formFieldProps中的slots参数会以v-slots的形式传递到FormItem的录入组件（子组件）中
149
+ * @param formElementMap
150
+ * @param column
151
+ * @param needRules
152
+ */
153
+ declare const getFormItemEl: (formElementMap: any, column: TColumn, needRules?: boolean | undefined) => VNode | null;
154
+ /**
155
+ * 根据Column生成Item VNode
156
+ * @param elementMap
157
+ * @param column
158
+ * @param value
159
+ */
160
+ declare const getItemEl: <T extends TColumn>(elementMap: any, column: T, value: any) => VNode | null;
161
+ /***************************************** 通用模式 *****************************************/
162
+ declare type InternalNamePath = (string | number)[];
163
+ declare type NamePath = string | number | InternalNamePath;
164
+ interface IHighConfig {
165
+ registerStateList?: {
166
+ name: NamePath;
167
+ mapName?: NamePath;
168
+ }[];
169
+ registerEventList?: {
170
+ name: string;
171
+ sendEventName?: TActionEvent["type"];
172
+ }[];
173
+ registerPropsTrans?: {
174
+ name: NamePath;
175
+ isFun?: boolean;
176
+ needParams?: boolean;
177
+ }[];
178
+ }
179
+ /**
180
+ * 组件树描述
181
+ */
182
+ interface IElementConfig {
183
+ elementType: string;
184
+ elementId: string;
185
+ elementProps?: Record<string, any>;
186
+ slots?: {
187
+ [name: string]: ((...params$: any[]) => any) | (IElementConfig & {
188
+ needParams?: boolean;
189
+ });
190
+ };
191
+ children?: IElementConfig[];
192
+ childrenSlotName?: string;
193
+ highConfig$?: IHighConfig;
194
+ }
195
+ declare const renderElements: (elementMap: TElementMap, elementConfigs: IElementConfig[]) => (VNode | null)[];
196
+ /**
197
+ *
198
+ * @param elementMap
199
+ * @param elementConfig
200
+ */
201
+ declare const renderElement: (elementMap: TElementMap, elementConfig: IElementConfig) => VNode<vue.RendererNode, vue.RendererElement, {
202
+ [key: string]: any;
203
+ }>;
204
+ /**
205
+ * 获取第一层级属性名
206
+ * 如：['aaa','bbb',...] 中的 'aaa'
207
+ * 如："aaa.bbb.ccc..." 中的 'aaa'
208
+ */
209
+ declare const getFirstPropName: (name: NamePath) => string | number | undefined;
210
+ /**
211
+ * 处理highConfig$
212
+ */
213
+ declare const Wrapper: vue.DefineComponent<{
214
+ elementMap: TElementMap;
215
+ elementConfig: IElementConfig;
216
+ }, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<{
217
+ elementMap: TElementMap;
218
+ elementConfig: IElementConfig;
219
219
  }>, {}>;
220
220
 
221
- interface IProModuleProvide {
222
- elementMap: TElementMap;
223
- subject$: Subject<TActionEvent>;
224
- sendEvent: (action: TActionEvent) => void;
225
- state: UnwrapNestedRefs<Record<string, any>>;
226
- dispatch: (action: TActionState) => void;
227
- requests: IRequestOpts[];
228
- sendRequest: (requestNameOrAction: string, ...params: any[]) => void;
229
- }
230
- declare const useProModule: () => IProModuleProvide;
231
- declare const provideProModule: (ctx: IProModuleProvide) => void;
232
- declare const useModuleEvent: (cb: (action: TActionEvent) => void) => void;
233
- interface IRequestOpts {
234
- actor: IRequestActor;
235
- /**
236
- * 如果设置action，可以使用该值发起请求 住：要保证唯一性
237
- * 设置该字段原因：因为actor中的name不友好，可以理解为一个备选方案
238
- */
239
- action?: string;
240
- stateName?: string;
241
- loadingName?: string;
242
- convertParams?: (...params: any[]) => Record<string, any>;
243
- convertData?: (actor: IRequestActor) => Record<string, any>;
244
- onSuccess?: (actor?: IRequestActor) => void;
245
- onFailed?: (actor?: IRequestActor) => void;
246
- }
247
- declare const RequestAction: {
248
- Success: string;
249
- Fail: string;
250
- };
251
- declare const proModuleProps: () => {
252
- /**
253
- * module状态
254
- */
255
- state: {
256
- type: PropType<Record<string, any>>;
257
- };
258
- /**
259
- * 组件集
260
- */
261
- elementMap: {
262
- type: PropType<TElementMap>;
263
- };
264
- /**
265
- * 组件描述（树）
266
- */
267
- elementConfigs: {
268
- type: PropType<IElementConfig[]>;
269
- };
270
- /**
271
- * requests
272
- */
273
- requests: {
274
- type: PropType<IRequestOpts[]>;
275
- };
276
- };
277
- declare type ProModuleProps = Partial<ExtractPropTypes<ReturnType<typeof proModuleProps>>>;
278
- declare const ProModule: vue.DefineComponent<Partial<ExtractPropTypes<{
279
- /**
280
- * module状态
281
- */
282
- state: {
283
- type: PropType<Record<string, any>>;
284
- };
285
- /**
286
- * 组件集
287
- */
288
- elementMap: {
289
- type: PropType<TElementMap>;
290
- };
291
- /**
292
- * 组件描述（树）
293
- */
294
- elementConfigs: {
295
- type: PropType<IElementConfig[]>;
296
- };
297
- /**
298
- * requests
299
- */
300
- requests: {
301
- type: PropType<IRequestOpts[]>;
302
- };
303
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
304
- /**
305
- * module状态
306
- */
307
- state: {
308
- type: PropType<Record<string, any>>;
309
- };
310
- /**
311
- * 组件集
312
- */
313
- elementMap: {
314
- type: PropType<TElementMap>;
315
- };
316
- /**
317
- * 组件描述（树）
318
- */
319
- elementConfigs: {
320
- type: PropType<IElementConfig[]>;
321
- };
322
- /**
323
- * requests
324
- */
325
- requests: {
326
- type: PropType<IRequestOpts[]>;
327
- };
221
+ interface IProModuleProvide {
222
+ elementMap: TElementMap;
223
+ subject$: Subject<TActionEvent>;
224
+ sendEvent: (action: TActionEvent) => void;
225
+ state: UnwrapNestedRefs<Record<string, any>>;
226
+ dispatch: (action: TActionState) => void;
227
+ requests: IRequestOpts[];
228
+ sendRequest: (requestNameOrAction: string, ...params: any[]) => void;
229
+ }
230
+ declare const useProModule: () => IProModuleProvide;
231
+ declare const provideProModule: (ctx: IProModuleProvide) => void;
232
+ declare const useModuleEvent: (cb: (action: TActionEvent) => void) => void;
233
+ interface IRequestOpts {
234
+ actor: IRequestActor;
235
+ /**
236
+ * 如果设置action，可以使用该值发起请求 住：要保证唯一性
237
+ * 设置该字段原因：因为actor中的name不友好，可以理解为一个备选方案
238
+ */
239
+ action?: string;
240
+ stateName?: string;
241
+ loadingName?: string;
242
+ convertParams?: (...params: any[]) => Record<string, any>;
243
+ convertData?: (actor: IRequestActor) => Record<string, any>;
244
+ onSuccess?: (actor?: IRequestActor) => void;
245
+ onFailed?: (actor?: IRequestActor) => void;
246
+ }
247
+ declare const RequestAction: {
248
+ Success: string;
249
+ Fail: string;
250
+ };
251
+ declare const proModuleProps: () => {
252
+ /**
253
+ * module状态
254
+ */
255
+ state: {
256
+ type: PropType<Record<string, any>>;
257
+ };
258
+ /**
259
+ * 组件集
260
+ */
261
+ elementMap: {
262
+ type: PropType<TElementMap>;
263
+ };
264
+ /**
265
+ * 组件描述（树）
266
+ */
267
+ elementConfigs: {
268
+ type: PropType<IElementConfig[]>;
269
+ };
270
+ /**
271
+ * requests
272
+ */
273
+ requests: {
274
+ type: PropType<IRequestOpts[]>;
275
+ };
276
+ };
277
+ declare type ProModuleProps = Partial<ExtractPropTypes<ReturnType<typeof proModuleProps>>>;
278
+ declare const ProModule: vue.DefineComponent<Partial<ExtractPropTypes<{
279
+ /**
280
+ * module状态
281
+ */
282
+ state: {
283
+ type: PropType<Record<string, any>>;
284
+ };
285
+ /**
286
+ * 组件集
287
+ */
288
+ elementMap: {
289
+ type: PropType<TElementMap>;
290
+ };
291
+ /**
292
+ * 组件描述（树）
293
+ */
294
+ elementConfigs: {
295
+ type: PropType<IElementConfig[]>;
296
+ };
297
+ /**
298
+ * requests
299
+ */
300
+ requests: {
301
+ type: PropType<IRequestOpts[]>;
302
+ };
303
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
304
+ /**
305
+ * module状态
306
+ */
307
+ state: {
308
+ type: PropType<Record<string, any>>;
309
+ };
310
+ /**
311
+ * 组件集
312
+ */
313
+ elementMap: {
314
+ type: PropType<TElementMap>;
315
+ };
316
+ /**
317
+ * 组件描述（树）
318
+ */
319
+ elementConfigs: {
320
+ type: PropType<IElementConfig[]>;
321
+ };
322
+ /**
323
+ * requests
324
+ */
325
+ requests: {
326
+ type: PropType<IRequestOpts[]>;
327
+ };
328
328
  }>>>, {}>;
329
329
 
330
- declare type TInitialState<T> = T | (() => T);
331
- declare type TRegisterStore = {
332
- key: string;
333
- initialState?: TInitialState<any>;
334
- persist?: boolean;
335
- };
336
- declare type TRegisterStoreMap = Record<string, TRegisterStore>;
337
- /**
338
- * 更新全局状态
339
- */
340
- declare const useDispatchStore: <T>() => (key: string, stateOrUpdater: T | TUpdater<T>) => void;
341
- /**
342
- * 读取全局状态
343
- * 返回ref对象
344
- */
330
+ declare type TInitialState<T> = T | (() => T);
331
+ declare type TRegisterStore = {
332
+ key: string;
333
+ initialState?: TInitialState<any>;
334
+ persist?: boolean;
335
+ };
336
+ declare type TRegisterStoreMap = Record<string, TRegisterStore>;
337
+ /**
338
+ * 更新全局状态
339
+ */
340
+ declare const useDispatchStore: <T>() => (key: string, stateOrUpdater: T | TUpdater<T>) => void;
341
+ /**
342
+ * 读取全局状态
343
+ * 返回ref对象
344
+ */
345
345
  declare const useReadStore: (key: string) => _vue_reactivity.Ref<any>;
346
346
 
347
- declare const useDoneRequestActor: (actors: (IRequestActor | string)[], callback: (actor: IRequestActor) => void) => void;
348
- declare const useFailedRequestActor: (actors: (IRequestActor | string)[], callback: (actor: IRequestActor) => void) => void;
349
- declare const useComposeRequestActor: (actors: (IRequestActor | string)[], options: {
350
- onSuccess?: ((actor: IRequestActor) => void) | undefined;
351
- onFailed?: ((actor: IRequestActor) => void) | undefined;
352
- onFinish?: ((actor: IRequestActor) => void) | undefined;
353
- }, cancelWhileUnmount?: boolean) => void;
354
- /******************************* meta *********************************/
355
- /**
356
- * 转换请求数据
357
- * @param actor
358
- * @param convertData
359
- * @param convertPath
360
- */
361
- declare const convertResData: (actor: IRequestActor, convertData?: ((res: IRequestActor["res"], actor: IRequestActor) => any) | undefined, convertPath?: (string | number)[]) => any;
362
- declare type TMeta = {
363
- actorName: string;
364
- storeName?: string;
365
- initParams?: Record<string, any>;
366
- convertPath?: (string | number)[];
367
- convertData?: (data: any, actor: IRequestActor) => any;
368
- };
369
- /**
370
- * 发送meta请求
371
- */
372
- declare const useDispatchMeta: () => (actorName: string) => void;
347
+ declare const useDoneRequestActor: (actors: (IRequestActor | string)[], callback: (actor: IRequestActor) => void) => void;
348
+ declare const useFailedRequestActor: (actors: (IRequestActor | string)[], callback: (actor: IRequestActor) => void) => void;
349
+ declare const useComposeRequestActor: (actors: (IRequestActor | string)[], options: {
350
+ onSuccess?: ((actor: IRequestActor) => void) | undefined;
351
+ onFailed?: ((actor: IRequestActor) => void) | undefined;
352
+ onFinish?: ((actor: IRequestActor) => void) | undefined;
353
+ }, cancelWhileUnmount?: boolean) => void;
354
+ /******************************* meta *********************************/
355
+ /**
356
+ * 转换请求数据
357
+ * @param actor
358
+ * @param convertData
359
+ * @param convertPath
360
+ */
361
+ declare const convertResData: (actor: IRequestActor, convertData?: ((res: IRequestActor["res"], actor: IRequestActor) => any) | undefined, convertPath?: (string | number)[]) => any;
362
+ declare type TMeta = {
363
+ actorName: string;
364
+ storeName?: string;
365
+ initParams?: Record<string, any>;
366
+ convertPath?: (string | number)[];
367
+ convertData?: (data: any, actor: IRequestActor) => any;
368
+ };
369
+ /**
370
+ * 发送meta请求
371
+ */
372
+ declare const useDispatchMeta: () => (actorName: string) => void;
373
373
  declare const useMetaRegister: (registerMetaMap: IProConfigProvide["registerMetaMap"], registerActorMap: IProConfigProvide["registerActorMap"]) => void;
374
374
 
375
- declare const proBasePropsFn: () => {
376
- /**
377
- * 组件集
378
- */
379
- elementMap: {
380
- type: PropType<TElementMap>;
381
- };
382
- /**
383
- * form组件集（使用FormItem包裹的组件集合）
384
- * readonly模式下使用elementMap中的组件渲染
385
- */
386
- formElementMap: {
387
- type: PropType<TElementMap>;
388
- };
389
- /**
390
- * 基础项配置
391
- */
392
- columns: {
393
- type: PropType<TColumns>;
394
- };
395
- /**
396
- * 对 column 进行补充
397
- * 通常对columns为静态值时候使用
398
- */
399
- columnState: {
400
- type: PropType<Record<string, any>>;
401
- };
402
- };
403
- declare type ProBaseProps = Partial<ExtractPropTypes<ReturnType<typeof proBasePropsFn>>>;
404
- declare const proBaseProps: ProBaseProps;
405
- declare type ProDispatchRequestType = (actorName: string, params?: IRequestActor["req"], extra?: IRequestActor["extra"]) => IRequestActor | undefined;
406
- interface IProConfigProvide {
407
- /**
408
- * 组件集
409
- */
410
- elementMap?: TElementMap;
411
- /**
412
- * form组件集（使用FormItem包裹的组件集合）
413
- */
414
- formElementMap?: TElementMap;
415
- /**
416
- * 注册的全局状态
417
- */
418
- registerStoreMap: TRegisterStoreMap;
419
- /**
420
- * 注册的全局接口
421
- */
422
- registerActorMap: Record<string, {
423
- actor: IRequestActor;
424
- }>;
425
- /**
426
- * 注册的全局Meta
427
- */
428
- registerMetaMap: Record<string, TMeta>;
429
- /**
430
- * 发送请求
431
- * @param actorName
432
- * @param params
433
- * @param extra
434
- */
435
- dispatchRequest: ProDispatchRequestType;
436
- }
437
- declare const proConfigProps: () => {
438
- elementMap: {
439
- type: PropType<TElementMap>;
440
- };
441
- formElementMap: {
442
- type: PropType<TElementMap>;
443
- };
444
- registerStores: {
445
- type: PropType<TRegisterStore[]>;
446
- };
447
- registerActors: {
448
- type: PropType<{
449
- actor: IRequestActor;
450
- }[]>;
451
- };
452
- registerMetas: {
453
- type: PropType<TMeta[]>;
454
- };
455
- };
456
- declare const useProConfig: () => IProConfigProvide;
457
- declare type ProConfigProps = Partial<ExtractPropTypes<ReturnType<typeof proConfigProps>>>;
458
- /**
459
- * 组件方式注册
460
- */
461
- declare const ProConfig: vue.DefineComponent<Partial<ExtractPropTypes<{
462
- elementMap: {
463
- type: PropType<TElementMap>;
464
- };
465
- formElementMap: {
466
- type: PropType<TElementMap>;
467
- };
468
- registerStores: {
469
- type: PropType<TRegisterStore[]>;
470
- };
471
- registerActors: {
472
- type: PropType<{
473
- actor: IRequestActor;
474
- }[]>;
475
- };
476
- registerMetas: {
477
- type: PropType<TMeta[]>;
478
- };
479
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
480
- elementMap: {
481
- type: PropType<TElementMap>;
482
- };
483
- formElementMap: {
484
- type: PropType<TElementMap>;
485
- };
486
- registerStores: {
487
- type: PropType<TRegisterStore[]>;
488
- };
489
- registerActors: {
490
- type: PropType<{
491
- actor: IRequestActor;
492
- }[]>;
493
- };
494
- registerMetas: {
495
- type: PropType<TMeta[]>;
496
- };
497
- }>>>, {}>;
498
- /**
499
- * app.use 方式注册
500
- * @param config
501
- */
375
+ declare const proBasePropsFn: () => {
376
+ /**
377
+ * 组件集
378
+ */
379
+ elementMap: {
380
+ type: PropType<TElementMap>;
381
+ };
382
+ /**
383
+ * form组件集（使用FormItem包裹的组件集合）
384
+ * readonly模式下使用elementMap中的组件渲染
385
+ */
386
+ formElementMap: {
387
+ type: PropType<TElementMap>;
388
+ };
389
+ /**
390
+ * 基础项配置
391
+ */
392
+ columns: {
393
+ type: PropType<TColumns>;
394
+ };
395
+ /**
396
+ * 对 column 进行补充
397
+ * 通常对columns为静态值时候使用
398
+ */
399
+ columnState: {
400
+ type: PropType<Record<string, any>>;
401
+ };
402
+ };
403
+ declare type ProBaseProps = Partial<ExtractPropTypes<ReturnType<typeof proBasePropsFn>>>;
404
+ declare const proBaseProps: ProBaseProps;
405
+ declare type ProDispatchRequestType = (actorName: string, params?: IRequestActor["req"], extra?: IRequestActor["extra"]) => IRequestActor | undefined;
406
+ interface IProConfigProvide {
407
+ /**
408
+ * 组件集
409
+ */
410
+ elementMap?: TElementMap;
411
+ /**
412
+ * form组件集（使用FormItem包裹的组件集合）
413
+ */
414
+ formElementMap?: TElementMap;
415
+ /**
416
+ * 注册的全局状态
417
+ */
418
+ registerStoreMap: TRegisterStoreMap;
419
+ /**
420
+ * 注册的全局接口
421
+ */
422
+ registerActorMap: Record<string, {
423
+ actor: IRequestActor;
424
+ }>;
425
+ /**
426
+ * 注册的全局Meta
427
+ */
428
+ registerMetaMap: Record<string, TMeta>;
429
+ /**
430
+ * 发送请求
431
+ * @param actorName
432
+ * @param params
433
+ * @param extra
434
+ */
435
+ dispatchRequest: ProDispatchRequestType;
436
+ }
437
+ declare const proConfigProps: () => {
438
+ elementMap: {
439
+ type: PropType<TElementMap>;
440
+ };
441
+ formElementMap: {
442
+ type: PropType<TElementMap>;
443
+ };
444
+ registerStores: {
445
+ type: PropType<TRegisterStore[]>;
446
+ };
447
+ registerActors: {
448
+ type: PropType<{
449
+ actor: IRequestActor;
450
+ }[]>;
451
+ };
452
+ registerMetas: {
453
+ type: PropType<TMeta[]>;
454
+ };
455
+ };
456
+ declare const useProConfig: () => IProConfigProvide;
457
+ declare type ProConfigProps = Partial<ExtractPropTypes<ReturnType<typeof proConfigProps>>>;
458
+ /**
459
+ * 组件方式注册
460
+ */
461
+ declare const ProConfig: vue.DefineComponent<Partial<ExtractPropTypes<{
462
+ elementMap: {
463
+ type: PropType<TElementMap>;
464
+ };
465
+ formElementMap: {
466
+ type: PropType<TElementMap>;
467
+ };
468
+ registerStores: {
469
+ type: PropType<TRegisterStore[]>;
470
+ };
471
+ registerActors: {
472
+ type: PropType<{
473
+ actor: IRequestActor;
474
+ }[]>;
475
+ };
476
+ registerMetas: {
477
+ type: PropType<TMeta[]>;
478
+ };
479
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
480
+ elementMap: {
481
+ type: PropType<TElementMap>;
482
+ };
483
+ formElementMap: {
484
+ type: PropType<TElementMap>;
485
+ };
486
+ registerStores: {
487
+ type: PropType<TRegisterStore[]>;
488
+ };
489
+ registerActors: {
490
+ type: PropType<{
491
+ actor: IRequestActor;
492
+ }[]>;
493
+ };
494
+ registerMetas: {
495
+ type: PropType<TMeta[]>;
496
+ };
497
+ }>>>, {}>;
498
+ /**
499
+ * app.use 方式注册
500
+ * @param config
501
+ */
502
502
  declare const createProConfig: (config?: ProConfigProps) => (app: App) => void;
503
503
 
504
- interface IAccess extends Record<string, any> {
505
- token?: string;
506
- }
507
- declare type TAccess = UnwrapNestedRefs<IAccess>;
508
- declare const useAccess: () => TAccess;
509
- declare const useAccessMgr: () => readonly [any, (stateOrUpdater: _vue_start_store.TUpdater<undefined> | undefined) => void, () => void];
510
- declare const MustLogon: vue.DefineComponent<unknown, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
511
- [key: string]: any;
512
- }>[] | null | undefined, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<unknown>, {}>;
513
- declare const LogonUserKey: unique symbol;
514
- interface IUser extends Record<string, any> {
515
- id?: string | number;
516
- }
517
- declare type TLogonUserProvide = {
518
- user: UnwrapNestedRefs<IUser>;
519
- setUser: (u: IUser) => void;
520
- per: UnwrapNestedRefs<Record<string, any>>;
521
- setPer: (u: IUser) => void;
522
- opts: Record<string, any>;
523
- };
524
- declare const useLogonUser: () => TLogonUserProvide;
525
- declare const LogonUser: vue.DefineComponent<unknown, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
526
- [key: string]: any;
504
+ interface IAccess extends Record<string, any> {
505
+ token?: string;
506
+ }
507
+ declare type TAccess = UnwrapNestedRefs<IAccess>;
508
+ declare const useAccess: () => TAccess;
509
+ declare const useAccessMgr: () => readonly [any, (stateOrUpdater: _vue_start_store.TUpdater<undefined> | undefined) => void, () => void];
510
+ declare const MustLogon: vue.DefineComponent<unknown, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
511
+ [key: string]: any;
512
+ }>[] | null | undefined, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<unknown>, {}>;
513
+ declare const LogonUserKey: unique symbol;
514
+ interface IUser extends Record<string, any> {
515
+ id?: string | number;
516
+ }
517
+ declare type TLogonUserProvide = {
518
+ user: UnwrapNestedRefs<IUser>;
519
+ setUser: (u: IUser) => void;
520
+ per: UnwrapNestedRefs<Record<string, any>>;
521
+ setPer: (u: IUser) => void;
522
+ opts: Record<string, any>;
523
+ };
524
+ declare const useLogonUser: () => TLogonUserProvide;
525
+ declare const LogonUser: vue.DefineComponent<unknown, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
526
+ [key: string]: any;
527
527
  }>[] | undefined, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<unknown>, {}>;
528
528
 
529
- interface IProFormProvideExtra extends Record<string, any> {
530
- }
531
- interface IProFormProvide extends IProFormProvideExtra {
532
- formState: UnwrapNestedRefs<Record<string, any>>;
533
- showState: UnwrapNestedRefs<Record<string, any>>;
534
- readonlyState: UnwrapNestedRefs<Record<string, any>>;
535
- disableState: UnwrapNestedRefs<Record<string, any>>;
536
- readonly: Ref<boolean | undefined>;
537
- elementMap?: TElementMap;
538
- formElementMap?: TElementMap;
539
- columns: Ref<TColumns>;
540
- }
541
- declare const useProForm: () => IProFormProvide;
542
- declare enum FormAction {
543
- RESET = "RESET",
544
- SUBMIT = "SUBMIT",
545
- CONTINUE = "CONTINUE"
546
- }
547
- declare type TProFormOperate = ProOperateProps & {
548
- onReset?: () => void;
549
- onSubmit?: () => void;
550
- onContinue?: () => void;
551
- };
552
- declare const proFormProps: () => {
553
- /**
554
- * class名称
555
- */
556
- clsName: {
557
- type: StringConstructor;
558
- default: string;
559
- };
560
- /**
561
- * 同 antd 或 element form中的model
562
- */
563
- model: {
564
- type: PropType<Record<string, any>>;
565
- };
566
- /**
567
- * 子组件是否只读样式
568
- */
569
- readonly: {
570
- type: BooleanConstructor;
571
- default: undefined;
572
- };
573
- /**
574
- * FormComponent 根据此项来确定组件是否显示
575
- * rules 根据rules中方法生成showState对象
576
- */
577
- showState: {
578
- type: PropType<BooleanObjType>;
579
- };
580
- showStateRules: {
581
- type: PropType<BooleanRulesObjType>;
582
- };
583
- /**
584
- * 是否只读
585
- */
586
- readonlyState: {
587
- type: PropType<BooleanObjType>;
588
- };
589
- readonlyStateRules: {
590
- type: PropType<BooleanRulesObjType>;
591
- };
592
- /**
593
- * 是否disabled
594
- */
595
- disableState: {
596
- type: PropType<BooleanObjType>;
597
- };
598
- disableStateRules: {
599
- type: PropType<BooleanRulesObjType>;
600
- };
601
- /**
602
- * 是否启用rules验证
603
- */
604
- needRules: {
605
- type: BooleanConstructor;
606
- default: boolean;
607
- };
608
- /**
609
- * provide传递
610
- */
611
- provideExtra: {
612
- type: PropType<IProFormProvideExtra>;
613
- };
614
- /**
615
- * 操作按钮
616
- */
617
- operate: {
618
- type: PropType<TProFormOperate>;
619
- };
620
- submitLoading: {
621
- type: BooleanConstructor;
622
- };
623
- /**
624
- * ref 默认中转方法
625
- */
626
- formMethods: {
627
- type: PropType<string[]>;
628
- };
629
- };
630
- declare type ProFormProps = Partial<ExtractPropTypes<ReturnType<typeof proFormProps>>> & ProBaseProps & Omit<ProGridProps, "items"> & {
631
- onFinish?: (showValues?: Record<string, any>, values?: Record<string, any>) => void;
632
- onFinishFailed?: (errs: any) => void;
633
- };
529
+ interface IProFormProvideExtra extends Record<string, any> {
530
+ }
531
+ interface IProFormProvide extends IProFormProvideExtra {
532
+ formState: UnwrapNestedRefs<Record<string, any>>;
533
+ showState: UnwrapNestedRefs<Record<string, any>>;
534
+ readonlyState: UnwrapNestedRefs<Record<string, any>>;
535
+ disableState: UnwrapNestedRefs<Record<string, any>>;
536
+ readonly: Ref<boolean | undefined>;
537
+ elementMap?: TElementMap;
538
+ formElementMap?: TElementMap;
539
+ columns: Ref<TColumns>;
540
+ }
541
+ declare const useProForm: () => IProFormProvide;
542
+ declare enum FormAction {
543
+ RESET = "RESET",
544
+ SUBMIT = "SUBMIT",
545
+ CONTINUE = "CONTINUE"
546
+ }
547
+ declare type TProFormOperate = ProOperateProps & {
548
+ onReset?: () => void;
549
+ onSubmit?: () => void;
550
+ onContinue?: () => void;
551
+ };
552
+ declare const proFormProps: () => {
553
+ /**
554
+ * class名称
555
+ */
556
+ clsName: {
557
+ type: StringConstructor;
558
+ default: string;
559
+ };
560
+ /**
561
+ * 同 antd 或 element form中的model
562
+ */
563
+ model: {
564
+ type: PropType<Record<string, any>>;
565
+ };
566
+ /**
567
+ * 子组件是否只读样式
568
+ */
569
+ readonly: {
570
+ type: BooleanConstructor;
571
+ default: undefined;
572
+ };
573
+ /**
574
+ * FormComponent 根据此项来确定组件是否显示
575
+ * rules 根据rules中方法生成showState对象
576
+ */
577
+ showState: {
578
+ type: PropType<BooleanObjType>;
579
+ };
580
+ showStateRules: {
581
+ type: PropType<BooleanRulesObjType>;
582
+ };
583
+ /**
584
+ * 是否只读
585
+ */
586
+ readonlyState: {
587
+ type: PropType<BooleanObjType>;
588
+ };
589
+ readonlyStateRules: {
590
+ type: PropType<BooleanRulesObjType>;
591
+ };
592
+ /**
593
+ * 是否disabled
594
+ */
595
+ disableState: {
596
+ type: PropType<BooleanObjType>;
597
+ };
598
+ disableStateRules: {
599
+ type: PropType<BooleanRulesObjType>;
600
+ };
601
+ /**
602
+ * 是否启用rules验证
603
+ */
604
+ needRules: {
605
+ type: BooleanConstructor;
606
+ default: boolean;
607
+ };
608
+ /**
609
+ * provide传递
610
+ */
611
+ provideExtra: {
612
+ type: PropType<IProFormProvideExtra>;
613
+ };
614
+ /**
615
+ * 操作按钮
616
+ */
617
+ operate: {
618
+ type: PropType<TProFormOperate>;
619
+ };
620
+ submitLoading: {
621
+ type: BooleanConstructor;
622
+ };
623
+ /**
624
+ * ref 默认中转方法
625
+ */
626
+ formMethods: {
627
+ type: PropType<string[]>;
628
+ };
629
+ };
630
+ declare type ProFormProps = Partial<ExtractPropTypes<ReturnType<typeof proFormProps>>> & ProBaseProps & Omit<ProGridProps, "items"> & {
631
+ onFinish?: (showValues?: Record<string, any>, values?: Record<string, any>) => void;
632
+ onFinishFailed?: (errs: any) => void;
633
+ };
634
634
  declare const ProForm: vue.DefineComponent<ProFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProFormProps>, {}>;
635
635
 
636
- declare enum SearchMode {
637
- AUTO = "AUTO",
638
- MANUAL = "MANUAL"
639
- }
640
- declare type ISearchMode = keyof typeof SearchMode;
641
- declare const proSearchFormProps: () => {
642
- /**
643
- * 初始化触发 onFinish
644
- */
645
- initEmit: {
646
- type: BooleanConstructor;
647
- default: boolean;
648
- };
649
- /**
650
- * 模式 自动触发或者手动触发 onFinish
651
- */
652
- searchMode: {
653
- type: PropType<"AUTO" | "MANUAL">;
654
- default: SearchMode;
655
- };
656
- /**
657
- * 需要debounce处理的字段
658
- */
659
- debounceKeys: {
660
- type: PropType<string[]>;
661
- };
662
- debounceTypes: {
663
- type: PropType<string[]>;
664
- default: string[];
665
- };
666
- debounceTime: {
667
- type: NumberConstructor;
668
- default: number;
669
- };
670
- };
671
- declare type ProSearchFormProps = Partial<ExtractPropTypes<ReturnType<typeof proSearchFormProps>>> & ProFormProps;
636
+ declare enum SearchMode {
637
+ AUTO = "AUTO",
638
+ MANUAL = "MANUAL"
639
+ }
640
+ declare type ISearchMode = keyof typeof SearchMode;
641
+ declare const proSearchFormProps: () => {
642
+ /**
643
+ * 初始化触发 onFinish
644
+ */
645
+ initEmit: {
646
+ type: BooleanConstructor;
647
+ default: boolean;
648
+ };
649
+ /**
650
+ * 模式 自动触发或者手动触发 onFinish
651
+ */
652
+ searchMode: {
653
+ type: PropType<"AUTO" | "MANUAL">;
654
+ default: SearchMode;
655
+ };
656
+ /**
657
+ * 需要debounce处理的字段
658
+ */
659
+ debounceKeys: {
660
+ type: PropType<string[]>;
661
+ };
662
+ debounceTypes: {
663
+ type: PropType<string[]>;
664
+ default: string[];
665
+ };
666
+ debounceTime: {
667
+ type: NumberConstructor;
668
+ default: number;
669
+ };
670
+ };
671
+ declare type ProSearchFormProps = Partial<ExtractPropTypes<ReturnType<typeof proSearchFormProps>>> & ProFormProps;
672
672
  declare const ProSearchForm: vue.DefineComponent<ProSearchFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProSearchFormProps>, {}>;
673
673
 
674
- interface FormItemProps {
675
- name?: string | number | (string | number)[];
676
- }
677
- declare const proFormItemProps: () => {
678
- readonly: {
679
- type: BooleanConstructor;
680
- default: undefined;
681
- };
682
- fieldProps: {
683
- type: ObjectConstructor;
684
- };
685
- showProps: {
686
- type: ObjectConstructor;
687
- };
688
- slots: {
689
- type: ObjectConstructor;
690
- };
691
- };
692
- declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & Record<string, any>;
693
- declare const createFormItemCompFn: <T extends FormItemProps>(FormItem: any, convertInputCompProps: (value: any, setValue: (v: any) => void, disabled: boolean | undefined) => Record<string, any>) => ({ InputComp, valueType, name }: {
694
- InputComp: any;
695
- valueType: TValueType;
696
- name?: string | undefined;
697
- }) => vue.DefineComponent<T & Partial<ExtractPropTypes<{
698
- readonly: {
699
- type: BooleanConstructor;
700
- default: undefined;
701
- };
702
- fieldProps: {
703
- type: ObjectConstructor;
704
- };
705
- showProps: {
706
- type: ObjectConstructor;
707
- };
708
- slots: {
709
- type: ObjectConstructor;
710
- };
711
- }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<T & Partial<ExtractPropTypes<{
712
- readonly: {
713
- type: BooleanConstructor;
714
- default: undefined;
715
- };
716
- fieldProps: {
717
- type: ObjectConstructor;
718
- };
719
- showProps: {
720
- type: ObjectConstructor;
721
- };
722
- slots: {
723
- type: ObjectConstructor;
724
- };
725
- }>> & Record<string, any> extends infer T_1 ? T_1 extends T & Partial<ExtractPropTypes<{
726
- readonly: {
727
- type: BooleanConstructor;
728
- default: undefined;
729
- };
730
- fieldProps: {
731
- type: ObjectConstructor;
732
- };
733
- showProps: {
734
- type: ObjectConstructor;
735
- };
736
- slots: {
737
- type: ObjectConstructor;
738
- };
739
- }>> & Record<string, any> ? T_1 extends vue.ComponentPropsOptions<{
740
- [x: string]: unknown;
741
- }> ? ExtractPropTypes<T_1> : T_1 : never : never>, vue.ExtractDefaultPropTypes<T & Partial<ExtractPropTypes<{
742
- readonly: {
743
- type: BooleanConstructor;
744
- default: undefined;
745
- };
746
- fieldProps: {
747
- type: ObjectConstructor;
748
- };
749
- showProps: {
750
- type: ObjectConstructor;
751
- };
752
- slots: {
753
- type: ObjectConstructor;
754
- };
674
+ interface FormItemProps {
675
+ name?: string | number | (string | number)[];
676
+ }
677
+ declare const proFormItemProps: () => {
678
+ readonly: {
679
+ type: BooleanConstructor;
680
+ default: undefined;
681
+ };
682
+ fieldProps: {
683
+ type: ObjectConstructor;
684
+ };
685
+ showProps: {
686
+ type: ObjectConstructor;
687
+ };
688
+ slots: {
689
+ type: ObjectConstructor;
690
+ };
691
+ };
692
+ declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & Record<string, any>;
693
+ declare const createFormItemCompFn: <T extends FormItemProps>(FormItem: any, convertInputCompProps: (value: any, setValue: (v: any) => void, disabled: boolean | undefined) => Record<string, any>) => ({ InputComp, valueType, name }: {
694
+ InputComp: any;
695
+ valueType: TValueType;
696
+ name?: string | undefined;
697
+ }) => vue.DefineComponent<T & Partial<ExtractPropTypes<{
698
+ readonly: {
699
+ type: BooleanConstructor;
700
+ default: undefined;
701
+ };
702
+ fieldProps: {
703
+ type: ObjectConstructor;
704
+ };
705
+ showProps: {
706
+ type: ObjectConstructor;
707
+ };
708
+ slots: {
709
+ type: ObjectConstructor;
710
+ };
711
+ }>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<T & Partial<ExtractPropTypes<{
712
+ readonly: {
713
+ type: BooleanConstructor;
714
+ default: undefined;
715
+ };
716
+ fieldProps: {
717
+ type: ObjectConstructor;
718
+ };
719
+ showProps: {
720
+ type: ObjectConstructor;
721
+ };
722
+ slots: {
723
+ type: ObjectConstructor;
724
+ };
725
+ }>> & Record<string, any> extends infer T_1 ? T_1 extends T & Partial<ExtractPropTypes<{
726
+ readonly: {
727
+ type: BooleanConstructor;
728
+ default: undefined;
729
+ };
730
+ fieldProps: {
731
+ type: ObjectConstructor;
732
+ };
733
+ showProps: {
734
+ type: ObjectConstructor;
735
+ };
736
+ slots: {
737
+ type: ObjectConstructor;
738
+ };
739
+ }>> & Record<string, any> ? T_1 extends vue.ComponentPropsOptions<{
740
+ [x: string]: unknown;
741
+ }> ? ExtractPropTypes<T_1> : T_1 : never : never>, vue.ExtractDefaultPropTypes<T & Partial<ExtractPropTypes<{
742
+ readonly: {
743
+ type: BooleanConstructor;
744
+ default: undefined;
745
+ };
746
+ fieldProps: {
747
+ type: ObjectConstructor;
748
+ };
749
+ showProps: {
750
+ type: ObjectConstructor;
751
+ };
752
+ slots: {
753
+ type: ObjectConstructor;
754
+ };
755
755
  }>> & Record<string, any>>>;
756
756
 
757
- interface IProFormListProvide {
758
- pathList: (string | number)[];
759
- }
760
- declare const useProFormList: () => IProFormListProvide;
761
- declare const provideProFormList: (ctx: IProFormListProvide) => void;
762
- declare const proFormListProps: () => {
763
- rowKey: {
764
- type: StringConstructor;
765
- default: string;
766
- };
767
- name: {
768
- type: PropType<string | number | (string | number)[]>;
769
- required: boolean;
770
- };
771
- };
772
- declare type ProFormListProps = Partial<ExtractPropTypes<ReturnType<typeof proFormListProps>>>;
773
- declare const ProFormList: vue.DefineComponent<Partial<ExtractPropTypes<{
774
- rowKey: {
775
- type: StringConstructor;
776
- default: string;
777
- };
778
- name: {
779
- type: PropType<string | number | (string | number)[]>;
780
- required: boolean;
781
- };
782
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
783
- rowKey: {
784
- type: StringConstructor;
785
- default: string;
786
- };
787
- name: {
788
- type: PropType<string | number | (string | number)[]>;
789
- required: boolean;
790
- };
757
+ interface IProFormListProvide {
758
+ pathList: (string | number)[];
759
+ }
760
+ declare const useProFormList: () => IProFormListProvide;
761
+ declare const provideProFormList: (ctx: IProFormListProvide) => void;
762
+ declare const proFormListProps: () => {
763
+ rowKey: {
764
+ type: StringConstructor;
765
+ default: string;
766
+ };
767
+ name: {
768
+ type: PropType<string | number | (string | number)[]>;
769
+ required: boolean;
770
+ };
771
+ };
772
+ declare type ProFormListProps = Partial<ExtractPropTypes<ReturnType<typeof proFormListProps>>>;
773
+ declare const ProFormList: vue.DefineComponent<Partial<ExtractPropTypes<{
774
+ rowKey: {
775
+ type: StringConstructor;
776
+ default: string;
777
+ };
778
+ name: {
779
+ type: PropType<string | number | (string | number)[]>;
780
+ required: boolean;
781
+ };
782
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
783
+ rowKey: {
784
+ type: StringConstructor;
785
+ default: string;
786
+ };
787
+ name: {
788
+ type: PropType<string | number | (string | number)[]>;
789
+ required: boolean;
790
+ };
791
791
  }>>>, {}>;
792
792
 
793
- interface IOpeItem {
794
- value: string | number;
795
- label?: string | VNode | (() => string | VNode);
796
- show?: boolean | (() => boolean);
797
- disabled?: boolean | (() => boolean);
798
- loading?: boolean | (() => boolean);
799
- extraProps?: object | (() => Record<string, any>);
800
- onClick?: (value: string | number | boolean) => void;
801
- element?: (item?: Omit<IOpeItem, "show" | "disabled" | "opeProps" | "element"> & {
802
- disabled?: boolean;
803
- }) => VNode | null;
804
- }
805
- declare const proOperateProps: () => {
806
- /**
807
- * class名称
808
- */
809
- clsName: {
810
- type: StringConstructor;
811
- default: string;
812
- };
813
- items: {
814
- type: PropType<IOpeItem[]>;
815
- };
816
- itemState: {
817
- type: PropType<Record<string, IOpeItem>>;
818
- };
819
- elementKey: {
820
- type: StringConstructor;
821
- default: string;
822
- };
823
- };
824
- declare type ProOperateProps = Partial<ExtractPropTypes<ReturnType<typeof proOperateProps>>>;
825
- declare const ProOperate: vue.DefineComponent<Partial<ExtractPropTypes<{
826
- /**
827
- * class名称
828
- */
829
- clsName: {
830
- type: StringConstructor;
831
- default: string;
832
- };
833
- items: {
834
- type: PropType<IOpeItem[]>;
835
- };
836
- itemState: {
837
- type: PropType<Record<string, IOpeItem>>;
838
- };
839
- elementKey: {
840
- type: StringConstructor;
841
- default: string;
842
- };
843
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
844
- /**
845
- * class名称
846
- */
847
- clsName: {
848
- type: StringConstructor;
849
- default: string;
850
- };
851
- items: {
852
- type: PropType<IOpeItem[]>;
853
- };
854
- itemState: {
855
- type: PropType<Record<string, IOpeItem>>;
856
- };
857
- elementKey: {
858
- type: StringConstructor;
859
- default: string;
860
- };
793
+ interface IOpeItem {
794
+ value: string | number;
795
+ label?: string | VNode | (() => string | VNode);
796
+ show?: boolean | (() => boolean);
797
+ disabled?: boolean | (() => boolean);
798
+ loading?: boolean | (() => boolean);
799
+ extraProps?: object | (() => Record<string, any>);
800
+ onClick?: (value: string | number | boolean) => void;
801
+ element?: (item?: Omit<IOpeItem, "show" | "disabled" | "opeProps" | "element"> & {
802
+ disabled?: boolean;
803
+ }) => VNode | null;
804
+ }
805
+ declare const proOperateProps: () => {
806
+ /**
807
+ * class名称
808
+ */
809
+ clsName: {
810
+ type: StringConstructor;
811
+ default: string;
812
+ };
813
+ items: {
814
+ type: PropType<IOpeItem[]>;
815
+ };
816
+ itemState: {
817
+ type: PropType<Record<string, IOpeItem>>;
818
+ };
819
+ elementKey: {
820
+ type: StringConstructor;
821
+ default: string;
822
+ };
823
+ };
824
+ declare type ProOperateProps = Partial<ExtractPropTypes<ReturnType<typeof proOperateProps>>>;
825
+ declare const ProOperate: vue.DefineComponent<Partial<ExtractPropTypes<{
826
+ /**
827
+ * class名称
828
+ */
829
+ clsName: {
830
+ type: StringConstructor;
831
+ default: string;
832
+ };
833
+ items: {
834
+ type: PropType<IOpeItem[]>;
835
+ };
836
+ itemState: {
837
+ type: PropType<Record<string, IOpeItem>>;
838
+ };
839
+ elementKey: {
840
+ type: StringConstructor;
841
+ default: string;
842
+ };
843
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
844
+ /**
845
+ * class名称
846
+ */
847
+ clsName: {
848
+ type: StringConstructor;
849
+ default: string;
850
+ };
851
+ items: {
852
+ type: PropType<IOpeItem[]>;
853
+ };
854
+ itemState: {
855
+ type: PropType<Record<string, IOpeItem>>;
856
+ };
857
+ elementKey: {
858
+ type: StringConstructor;
859
+ default: string;
860
+ };
861
861
  }>>>, {}>;
862
862
 
863
- interface IProTableProvideExtra extends Record<string, any> {
864
- }
865
- interface IProTableProvide extends IProTableProvideExtra {
866
- columns: Ref<TTableColumns>;
867
- originColumns: Ref<TTableColumns>;
868
- state: UnwrapNestedRefs<{
869
- selectIds: (string | number)[];
870
- }>;
871
- }
872
- declare const useProTable: () => IProTableProvide;
873
- declare type TTableColumn = {
874
- customRender?: (opt: {
875
- value: any;
876
- text: any;
877
- record: Record<string, any>;
878
- index: number;
879
- column: TTableColumn;
880
- }) => VNode | string | number;
881
- fixed?: boolean | string;
882
- width?: number | string;
883
- } & TColumn;
884
- declare type TTableColumns = TTableColumn[];
885
- /**
886
- * 单个操作描述
887
- */
888
- interface IOperateItem {
889
- value: string | number;
890
- label?: string | VNode;
891
- show?: boolean | ((record: Record<string, any>) => boolean);
892
- disabled?: boolean | ((record: Record<string, any>) => boolean);
893
- loading?: boolean | ((record: Record<string, any>) => boolean);
894
- extraProps?: object | ((record: Record<string, any>) => Record<string, any>);
895
- onClick?: (record: Record<string, any>) => void;
896
- sort?: number;
897
- element?: (record: Record<string, any>, item: IOperateItem) => VNode;
898
- }
899
- /**
900
- * 整个操作栏描述
901
- */
902
- interface ITableOperate {
903
- column?: TColumn;
904
- items?: IOperateItem[];
905
- itemState?: {
906
- [key: string]: Omit<IOperateItem, "value">;
907
- };
908
- clsName?: ProOperateProps["clsName"];
909
- elementKey?: ProOperateProps["elementKey"];
910
- }
911
- declare const proTableProps: () => {
912
- /**
913
- * class名称
914
- */
915
- clsName: {
916
- type: StringConstructor;
917
- default: string;
918
- };
919
- operate: {
920
- type: PropType<ITableOperate>;
921
- };
922
- columnEmptyText: {
923
- type: StringConstructor;
924
- };
925
- /**
926
- * 公共column，会merge到columns item中
927
- */
928
- column: {
929
- type: PropType<TTableColumn>;
930
- };
931
- /**
932
- * 序号
933
- */
934
- serialNumber: {
935
- type: (BooleanConstructor | ObjectConstructor)[];
936
- };
937
- /**
938
- * 分页
939
- */
940
- paginationState: {
941
- type: PropType<{
942
- page?: number | undefined;
943
- pageSize?: number | undefined;
944
- }>;
945
- };
946
- /**
947
- * 操作栏
948
- */
949
- toolbar: {
950
- type: PropType<{
951
- columnSetting?: Partial<ExtractPropTypes<{
952
- clsName: {
953
- type: StringConstructor;
954
- default: string;
955
- };
956
- signName: {
957
- type: StringConstructor;
958
- default: string;
959
- };
960
- popoverProps: ObjectConstructor;
961
- }>> | undefined;
962
- }>;
963
- };
964
- /**
965
- * provide传递
966
- */
967
- provideExtra: {
968
- type: PropType<IProTableProvideExtra>;
969
- };
970
- /**
971
- * ref 默认中转方法
972
- */
973
- tableMethods: {
974
- type: PropType<string[]>;
975
- };
976
- };
977
- declare type ProTableProps = Partial<ExtractPropTypes<ReturnType<typeof proTableProps>>> & ProBaseProps & {
978
- loading?: boolean;
979
- dataSource?: Record<string, any>[];
980
- };
863
+ interface IProTableProvideExtra extends Record<string, any> {
864
+ }
865
+ interface IProTableProvide extends IProTableProvideExtra {
866
+ columns: Ref<TTableColumns>;
867
+ originColumns: Ref<TTableColumns>;
868
+ state: UnwrapNestedRefs<{
869
+ selectIds: (string | number)[];
870
+ }>;
871
+ }
872
+ declare const useProTable: () => IProTableProvide;
873
+ declare type TTableColumn = {
874
+ children?: TTableColumn[];
875
+ customRender?: (opt: {
876
+ value: any;
877
+ text: any;
878
+ record: Record<string, any>;
879
+ index: number;
880
+ column: TTableColumn;
881
+ }) => VNode | string | number;
882
+ fixed?: boolean | string;
883
+ width?: number | string;
884
+ } & TColumn;
885
+ declare type TTableColumns = TTableColumn[];
886
+ /**
887
+ * 单个操作描述
888
+ */
889
+ interface IOperateItem {
890
+ value: string | number;
891
+ label?: string | VNode;
892
+ show?: boolean | ((record: Record<string, any>) => boolean);
893
+ disabled?: boolean | ((record: Record<string, any>) => boolean);
894
+ loading?: boolean | ((record: Record<string, any>) => boolean);
895
+ extraProps?: object | ((record: Record<string, any>) => Record<string, any>);
896
+ onClick?: (record: Record<string, any>) => void;
897
+ sort?: number;
898
+ element?: (record: Record<string, any>, item: IOperateItem) => VNode;
899
+ }
900
+ /**
901
+ * 整个操作栏描述
902
+ */
903
+ interface ITableOperate {
904
+ column?: TColumn;
905
+ items?: IOperateItem[];
906
+ itemState?: {
907
+ [key: string]: Omit<IOperateItem, "value">;
908
+ };
909
+ clsName?: ProOperateProps["clsName"];
910
+ elementKey?: ProOperateProps["elementKey"];
911
+ }
912
+ declare const proTableProps: () => {
913
+ /**
914
+ * class名称
915
+ */
916
+ clsName: {
917
+ type: StringConstructor;
918
+ default: string;
919
+ };
920
+ operate: {
921
+ type: PropType<ITableOperate>;
922
+ };
923
+ columnEmptyText: {
924
+ type: StringConstructor;
925
+ };
926
+ /**
927
+ * 公共column，会merge到columns item中
928
+ */
929
+ column: {
930
+ type: PropType<TTableColumn>;
931
+ };
932
+ /**
933
+ * 序号
934
+ */
935
+ serialNumber: {
936
+ type: (BooleanConstructor | ObjectConstructor)[];
937
+ };
938
+ /**
939
+ * 分页
940
+ */
941
+ paginationState: {
942
+ type: PropType<{
943
+ page?: number | undefined;
944
+ pageSize?: number | undefined;
945
+ }>;
946
+ };
947
+ /**
948
+ * 操作栏
949
+ */
950
+ toolbar: {
951
+ type: PropType<{
952
+ columnSetting?: Partial<ExtractPropTypes<{
953
+ clsName: {
954
+ type: StringConstructor;
955
+ default: string;
956
+ };
957
+ signName: {
958
+ type: StringConstructor;
959
+ default: string;
960
+ };
961
+ popoverProps: ObjectConstructor;
962
+ }>> | undefined;
963
+ }>;
964
+ };
965
+ /**
966
+ * provide传递
967
+ */
968
+ provideExtra: {
969
+ type: PropType<IProTableProvideExtra>;
970
+ };
971
+ /**
972
+ * ref 默认中转方法
973
+ */
974
+ tableMethods: {
975
+ type: PropType<string[]>;
976
+ };
977
+ };
978
+ declare type ProTableProps = Partial<ExtractPropTypes<ReturnType<typeof proTableProps>>> & ProBaseProps & {
979
+ loading?: boolean;
980
+ dataSource?: Record<string, any>[];
981
+ };
981
982
  declare const ProTable: vue.DefineComponent<ProTableProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProTableProps>, {}>;
982
983
 
983
- declare const proPageHeaderProps: () => {
984
- title: {
985
- type: StringConstructor;
986
- };
987
- subTitle: {
988
- type: StringConstructor;
989
- };
990
- showBack: BooleanConstructor;
991
- hideWhileNoHistory: {
992
- type: BooleanConstructor;
993
- default: boolean;
994
- };
995
- };
996
- declare type PageHeaderProps = Partial<ExtractPropTypes<ReturnType<typeof proPageHeaderProps>>>;
997
- declare const PageHeader: vue.DefineComponent<{
998
- title: {
999
- type: StringConstructor;
1000
- };
1001
- subTitle: {
1002
- type: StringConstructor;
1003
- };
1004
- showBack: BooleanConstructor;
1005
- hideWhileNoHistory: {
1006
- type: BooleanConstructor;
1007
- default: boolean;
1008
- };
1009
- }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<{
1010
- title: {
1011
- type: StringConstructor;
1012
- };
1013
- subTitle: {
1014
- type: StringConstructor;
1015
- };
1016
- showBack: BooleanConstructor;
1017
- hideWhileNoHistory: {
1018
- type: BooleanConstructor;
1019
- default: boolean;
1020
- };
1021
- }>>, {
1022
- showBack: boolean;
1023
- hideWhileNoHistory: boolean;
1024
- }>;
1025
- declare const proPageProps: () => {
1026
- loading: {
1027
- type: BooleanConstructor;
1028
- default: boolean;
1029
- };
1030
- loadingOpts: ObjectConstructor;
1031
- fillMode: {
1032
- type: BooleanConstructor;
1033
- default: boolean;
1034
- };
1035
- };
1036
- declare type ProPageProps = Partial<ExtractPropTypes<ReturnType<typeof proPageProps>>> & PageHeaderProps;
984
+ declare const proPageHeaderProps: () => {
985
+ title: {
986
+ type: StringConstructor;
987
+ };
988
+ subTitle: {
989
+ type: StringConstructor;
990
+ };
991
+ showBack: BooleanConstructor;
992
+ hideWhileNoHistory: {
993
+ type: BooleanConstructor;
994
+ default: boolean;
995
+ };
996
+ };
997
+ declare type PageHeaderProps = Partial<ExtractPropTypes<ReturnType<typeof proPageHeaderProps>>>;
998
+ declare const PageHeader: vue.DefineComponent<{
999
+ title: {
1000
+ type: StringConstructor;
1001
+ };
1002
+ subTitle: {
1003
+ type: StringConstructor;
1004
+ };
1005
+ showBack: BooleanConstructor;
1006
+ hideWhileNoHistory: {
1007
+ type: BooleanConstructor;
1008
+ default: boolean;
1009
+ };
1010
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<{
1011
+ title: {
1012
+ type: StringConstructor;
1013
+ };
1014
+ subTitle: {
1015
+ type: StringConstructor;
1016
+ };
1017
+ showBack: BooleanConstructor;
1018
+ hideWhileNoHistory: {
1019
+ type: BooleanConstructor;
1020
+ default: boolean;
1021
+ };
1022
+ }>>, {
1023
+ showBack: boolean;
1024
+ hideWhileNoHistory: boolean;
1025
+ }>;
1026
+ declare const proPageProps: () => {
1027
+ loading: {
1028
+ type: BooleanConstructor;
1029
+ default: boolean;
1030
+ };
1031
+ loadingOpts: ObjectConstructor;
1032
+ fillMode: {
1033
+ type: BooleanConstructor;
1034
+ default: boolean;
1035
+ };
1036
+ };
1037
+ declare type ProPageProps = Partial<ExtractPropTypes<ReturnType<typeof proPageProps>>> & PageHeaderProps;
1037
1038
  declare const ProPage: vue.DefineComponent<ProPageProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProPageProps>, {}>;
1038
1039
 
1039
- declare type TPageState = {
1040
- page: number;
1041
- pageSize: number;
1042
- };
1043
- declare const defaultPage: TPageState;
1044
- declare const proListProps: () => {
1045
- /**
1046
- * class名称
1047
- */
1048
- clsName: {
1049
- type: StringConstructor;
1050
- default: string;
1051
- };
1052
- searchProps: {
1053
- type: PropType<Record<string, any>>;
1054
- };
1055
- tableProps: {
1056
- type: PropType<Record<string, any>>;
1057
- };
1058
- paginationProps: {
1059
- type: PropType<Record<string, any>>;
1060
- };
1061
- pageState: {
1062
- type: PropType<TPageState>;
1063
- };
1064
- };
1065
- declare type ProListProps = Partial<ExtractPropTypes<ReturnType<typeof proListProps>>>;
1066
- declare type SearchSlotProps = {
1067
- executeSearchWithResetPage: (values: Record<string, any>, page?: number) => void;
1068
- pageState: TPageState;
1069
- };
1070
- declare type PaginationSlotProps = {
1071
- executePageChange: (page: number, pageSize: number) => void;
1072
- pageState: TPageState;
1073
- };
1074
- /**
1075
- * 搜索框+表格+分页 三个组件组成
1076
- * onSearch 方法：search改变、page改变触发
1077
- */
1078
- declare const ProList: vue.DefineComponent<Partial<ExtractPropTypes<{
1079
- /**
1080
- * class名称
1081
- */
1082
- clsName: {
1083
- type: StringConstructor;
1084
- default: string;
1085
- };
1086
- searchProps: {
1087
- type: PropType<Record<string, any>>;
1088
- };
1089
- tableProps: {
1090
- type: PropType<Record<string, any>>;
1091
- };
1092
- paginationProps: {
1093
- type: PropType<Record<string, any>>;
1094
- };
1095
- pageState: {
1096
- type: PropType<TPageState>;
1097
- };
1098
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
1099
- /**
1100
- * class名称
1101
- */
1102
- clsName: {
1103
- type: StringConstructor;
1104
- default: string;
1105
- };
1106
- searchProps: {
1107
- type: PropType<Record<string, any>>;
1108
- };
1109
- tableProps: {
1110
- type: PropType<Record<string, any>>;
1111
- };
1112
- paginationProps: {
1113
- type: PropType<Record<string, any>>;
1114
- };
1115
- pageState: {
1116
- type: PropType<TPageState>;
1117
- };
1040
+ declare type TPageState = {
1041
+ page: number;
1042
+ pageSize: number;
1043
+ };
1044
+ declare const defaultPage: TPageState;
1045
+ declare const proListProps: () => {
1046
+ /**
1047
+ * class名称
1048
+ */
1049
+ clsName: {
1050
+ type: StringConstructor;
1051
+ default: string;
1052
+ };
1053
+ searchProps: {
1054
+ type: PropType<Record<string, any>>;
1055
+ };
1056
+ tableProps: {
1057
+ type: PropType<Record<string, any>>;
1058
+ };
1059
+ paginationProps: {
1060
+ type: (PropType<Record<string, any>> | PropType<boolean>)[];
1061
+ };
1062
+ pageState: {
1063
+ type: PropType<TPageState>;
1064
+ };
1065
+ };
1066
+ declare type ProListProps = Partial<ExtractPropTypes<ReturnType<typeof proListProps>>>;
1067
+ declare type SearchSlotProps = {
1068
+ executeSearchWithResetPage: (values: Record<string, any>, page?: number) => void;
1069
+ pageState: TPageState;
1070
+ };
1071
+ declare type PaginationSlotProps = {
1072
+ executePageChange: (page: number, pageSize: number) => void;
1073
+ pageState: TPageState;
1074
+ };
1075
+ /**
1076
+ * 搜索框+表格+分页 三个组件组成
1077
+ * onSearch 方法：search改变、page改变触发
1078
+ */
1079
+ declare const ProList: vue.DefineComponent<Partial<ExtractPropTypes<{
1080
+ /**
1081
+ * class名称
1082
+ */
1083
+ clsName: {
1084
+ type: StringConstructor;
1085
+ default: string;
1086
+ };
1087
+ searchProps: {
1088
+ type: PropType<Record<string, any>>;
1089
+ };
1090
+ tableProps: {
1091
+ type: PropType<Record<string, any>>;
1092
+ };
1093
+ paginationProps: {
1094
+ type: (PropType<Record<string, any>> | PropType<boolean>)[];
1095
+ };
1096
+ pageState: {
1097
+ type: PropType<TPageState>;
1098
+ };
1099
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
1100
+ /**
1101
+ * class名称
1102
+ */
1103
+ clsName: {
1104
+ type: StringConstructor;
1105
+ default: string;
1106
+ };
1107
+ searchProps: {
1108
+ type: PropType<Record<string, any>>;
1109
+ };
1110
+ tableProps: {
1111
+ type: PropType<Record<string, any>>;
1112
+ };
1113
+ paginationProps: {
1114
+ type: (PropType<Record<string, any>> | PropType<boolean>)[];
1115
+ };
1116
+ pageState: {
1117
+ type: PropType<TPageState>;
1118
+ };
1118
1119
  }>>>, {}>;
1119
1120
 
1120
- declare const proDescProps: () => {
1121
- /**
1122
- * class名称
1123
- */
1124
- clsName: {
1125
- type: StringConstructor;
1126
- default: string;
1127
- };
1128
- model: {
1129
- type: PropType<any>;
1130
- };
1131
- };
1132
- declare type ProDescProps = Partial<ExtractPropTypes<ReturnType<typeof proDescProps>>> & ProBaseProps;
1133
- declare const ProDesc: vue.DefineComponent<ProDescProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProDescProps>, {
1134
- model?: any;
1121
+ declare const proDescProps: () => {
1122
+ /**
1123
+ * class名称
1124
+ */
1125
+ clsName: {
1126
+ type: StringConstructor;
1127
+ default: string;
1128
+ };
1129
+ model: {
1130
+ type: PropType<any>;
1131
+ };
1132
+ };
1133
+ declare type ProDescProps = Partial<ExtractPropTypes<ReturnType<typeof proDescProps>>> & ProBaseProps;
1134
+ declare const ProDesc: vue.DefineComponent<ProDescProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProDescProps>, {
1135
+ model?: any;
1135
1136
  }>;
1136
1137
 
1137
- /******************************** 原始组件key ********************************/
1138
- declare const LoadingKey = "Loading$";
1139
- declare const RowKey = "Row$";
1140
- declare const ColKey = "Col$";
1141
- declare const ButtonKey = "Button$";
1142
- declare const DescriptionsKey = "ProDescriptions$";
1143
- declare const DescriptionsItemKey = "ProDescriptionsItem$";
1144
- declare const PaginationKey = "Pagination$";
1145
- declare const PopoverKey = "Popover$";
1146
- declare const CheckboxKey = "Checkbox$";
1147
- declare const ModalKey = "Modal$";
1148
- declare const FormKey = "Form$";
1149
- declare const FormItemKey = "FormItem$";
1150
- declare const TableKey = "Table$";
1151
- /******************************** pro组件key ********************************/
1152
- declare const ProFormKey = "ProForm$";
1153
- declare const ProSearchFormKey = "ProSearchForm$";
1154
- declare const ProTableKey = "ProTable$";
1155
- /**
1156
- * 根据elementKey获取组件
1157
- */
1138
+ /******************************** 组件key ********************************/
1139
+ declare const ElementKeys: {
1140
+ LoadingKey: string;
1141
+ RowKey: string;
1142
+ ColKey: string;
1143
+ ButtonKey: string;
1144
+ DescriptionsKey: string;
1145
+ DescriptionsItemKey: string;
1146
+ PaginationKey: string;
1147
+ PopoverKey: string;
1148
+ CheckboxKey: string;
1149
+ ModalKey: string;
1150
+ FormKey: string;
1151
+ FormItemKey: string;
1152
+ TableKey: string;
1153
+ ProFormKey: string;
1154
+ ProSearchFormKey: string;
1155
+ ProTableKey: string;
1156
+ };
1157
+ /**
1158
+ * 根据elementKey获取组件
1159
+ */
1158
1160
  declare const useGetCompByKey: () => (elementKey: string) => any;
1159
1161
 
1160
- interface IListData extends Record<string, any> {
1161
- total: number;
1162
- dataSource: Record<string, any>[];
1163
- }
1164
- interface ICurdState extends Record<string, any> {
1165
- listLoading?: boolean;
1166
- listData?: IListData;
1167
- mode?: ICurdCurrentMode;
1168
- detailLoading?: boolean;
1169
- detailData?: Record<string, any>;
1170
- operateLoading?: boolean;
1171
- addAction?: ICurdAddAction;
1172
- }
1173
- /**
1174
- * action：list,detail,add,edit,delete
1175
- */
1176
- interface ICurdOperateOpts extends Omit<IRequestOpts, "actor" | "action">, Omit<IOperateItem, "value"> {
1177
- action: ICurdAction;
1178
- actor?: IRequestActor;
1179
- tableOperate?: boolean;
1180
- }
1181
- declare type TCurdActionEvent = {
1182
- action: ICurdAction;
1183
- type: ICurdSubAction;
1184
- record?: Record<string, any>;
1185
- values?: Record<string, any>;
1186
- source?: TActionEvent["source"];
1187
- };
1188
- declare const proCurdProps: () => {
1189
- /**
1190
- * 列表 或 详情 的唯一标识
1191
- */
1192
- rowKey: {
1193
- type: StringConstructor;
1194
- default: string;
1195
- };
1196
- /**
1197
- * operates
1198
- */
1199
- operates: {
1200
- type: PropType<ICurdOperateOpts[]>;
1201
- };
1202
- /************************* 子组件props *******************************/
1203
- listProps: {
1204
- type: PropType<Record<string, any>>;
1205
- };
1206
- formProps: {
1207
- type: PropType<Record<string, any>>;
1208
- };
1209
- descProps: {
1210
- type: PropType<Record<string, any>>;
1211
- };
1212
- modalProps: {
1213
- type: PropType<Record<string, any>>;
1214
- };
1215
- };
1216
- declare type CurdProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdProps>>> & ProBaseProps;
1217
- declare const CurdMethods: string[];
1218
- declare type ProCurdProps = CurdProps & Omit<ProModuleProps, "state" | "requests"> & {
1219
- curdState?: UnwrapNestedRefs<ICurdState>;
1220
- };
1162
+ interface IListData extends Record<string, any> {
1163
+ total: number;
1164
+ dataSource: Record<string, any>[];
1165
+ }
1166
+ interface ICurdState extends Record<string, any> {
1167
+ listLoading?: boolean;
1168
+ listData?: IListData;
1169
+ mode?: ICurdCurrentMode;
1170
+ detailLoading?: boolean;
1171
+ detailData?: Record<string, any>;
1172
+ operateLoading?: boolean;
1173
+ addAction?: ICurdAddAction;
1174
+ }
1175
+ /**
1176
+ * action：list,detail,add,edit,delete
1177
+ */
1178
+ interface ICurdOperateOpts extends Omit<IRequestOpts, "actor" | "action">, Omit<IOperateItem, "value"> {
1179
+ action: ICurdAction;
1180
+ actor?: IRequestActor;
1181
+ tableOperate?: boolean;
1182
+ }
1183
+ declare type TCurdActionEvent = {
1184
+ action: ICurdAction;
1185
+ type: ICurdSubAction;
1186
+ record?: Record<string, any>;
1187
+ values?: Record<string, any>;
1188
+ source?: TActionEvent["source"];
1189
+ };
1190
+ declare const proCurdProps: () => {
1191
+ /**
1192
+ * 列表 或 详情 的唯一标识
1193
+ */
1194
+ rowKey: {
1195
+ type: StringConstructor;
1196
+ default: string;
1197
+ };
1198
+ /**
1199
+ * operates
1200
+ */
1201
+ operates: {
1202
+ type: PropType<ICurdOperateOpts[]>;
1203
+ };
1204
+ /************************* 子组件props *******************************/
1205
+ listProps: {
1206
+ type: PropType<Record<string, any>>;
1207
+ };
1208
+ formProps: {
1209
+ type: PropType<Record<string, any>>;
1210
+ };
1211
+ descProps: {
1212
+ type: PropType<Record<string, any>>;
1213
+ };
1214
+ modalProps: {
1215
+ type: PropType<Record<string, any>>;
1216
+ };
1217
+ };
1218
+ declare type CurdProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdProps>>> & ProBaseProps;
1219
+ declare const CurdMethods: string[];
1220
+ declare type ProCurdProps = CurdProps & Omit<ProModuleProps, "state" | "requests"> & {
1221
+ curdState?: UnwrapNestedRefs<ICurdState>;
1222
+ };
1221
1223
  declare const ProCurd: vue.DefineComponent<ProCurdProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCurdProps>, {}>;
1222
1224
 
1223
- interface IProCurdProvide {
1224
- columns: Ref<TColumns>;
1225
- getSignColumns: (signName: string) => TColumns;
1226
- getFormItemVNode: (column: TColumn, needRules: boolean | undefined) => VNode | null;
1227
- getItemVNode: (column: TColumn, value: any) => VNode | null;
1228
- elementMap: TElementMap;
1229
- formElementMap: TElementMap;
1230
- rowKey: string;
1231
- curdState: UnwrapNestedRefs<ICurdState>;
1232
- formColumns: Ref<TColumns>;
1233
- descColumns: Ref<TColumns>;
1234
- tableColumns: Ref<TColumns>;
1235
- searchColumns: Ref<TColumns>;
1236
- sendCurdEvent: (event: TCurdActionEvent) => void;
1237
- operates: ICurdOperateOpts[];
1238
- getOperate: (action: ICurdAction) => ICurdOperateOpts | undefined;
1239
- refreshList: (extra?: Record<string, any>) => void;
1240
- /******************子组件参数*******************/
1241
- listProps?: ComputedRef<Record<string, any> | undefined>;
1242
- formProps?: ComputedRef<Record<string, any> | undefined>;
1243
- descProps?: ComputedRef<Record<string, any> | undefined>;
1244
- modalProps?: ComputedRef<Record<string, any> | undefined>;
1245
- }
1246
- declare const useProCurd: <T extends IProCurdProvide>() => T;
1247
- declare const provideProCurd: (ctx: IProCurdProvide) => void;
1248
- /************************************ 常量 *************************************/
1249
- /**
1250
- * curd 5种基础Action
1251
- */
1252
- declare enum CurdAction {
1253
- LIST = "LIST",
1254
- DETAIL = "DETAIL",
1255
- ADD = "ADD",
1256
- EDIT = "EDIT",
1257
- DELETE = "DELETE"
1258
- }
1259
- declare type ICurdAction = keyof typeof CurdAction | string;
1260
- /**
1261
- * CurdAction 的子事件
1262
- */
1263
- declare enum CurdSubAction {
1264
- EMIT = "EMIT",
1265
- EXECUTE = "EXECUTE",
1266
- PAGE = "PAGE",
1267
- SUCCESS = "SUCCESS",
1268
- FAIL = "FAIL"
1269
- }
1270
- declare type ICurdSubAction = keyof typeof CurdSubAction;
1271
- /**
1272
- * curd 操作模式
1273
- */
1274
- declare enum CurdCurrentMode {
1275
- ADD = "ADD",
1276
- EDIT = "EDIT",
1277
- DETAIL = "DETAIL"
1278
- }
1279
- declare type ICurdCurrentMode = keyof typeof CurdCurrentMode | string;
1280
- /**
1281
- * curd add 模式下 标记 "确定" "确定并继续" 触发
1282
- */
1283
- declare enum CurdAddAction {
1284
- NORMAL = "NORMAL",
1285
- CONTINUE = "CONTINUE"
1286
- }
1225
+ interface IProCurdProvide {
1226
+ columns: Ref<TColumns>;
1227
+ getSignColumns: (signName: string) => TColumns;
1228
+ getFormItemVNode: (column: TColumn, needRules: boolean | undefined) => VNode | null;
1229
+ getItemVNode: (column: TColumn, value: any) => VNode | null;
1230
+ elementMap: TElementMap;
1231
+ formElementMap: TElementMap;
1232
+ rowKey: string;
1233
+ curdState: UnwrapNestedRefs<ICurdState>;
1234
+ formColumns: Ref<TColumns>;
1235
+ descColumns: Ref<TColumns>;
1236
+ tableColumns: Ref<TColumns>;
1237
+ searchColumns: Ref<TColumns>;
1238
+ sendCurdEvent: (event: TCurdActionEvent) => void;
1239
+ operates: ICurdOperateOpts[];
1240
+ getOperate: (action: ICurdAction) => ICurdOperateOpts | undefined;
1241
+ refreshList: (extra?: Record<string, any>) => void;
1242
+ /******************子组件参数*******************/
1243
+ listProps?: ComputedRef<Record<string, any> | undefined>;
1244
+ formProps?: ComputedRef<Record<string, any> | undefined>;
1245
+ descProps?: ComputedRef<Record<string, any> | undefined>;
1246
+ modalProps?: ComputedRef<Record<string, any> | undefined>;
1247
+ }
1248
+ declare const useProCurd: <T extends IProCurdProvide>() => T;
1249
+ declare const provideProCurd: (ctx: IProCurdProvide) => void;
1250
+ /************************************ 常量 *************************************/
1251
+ /**
1252
+ * curd 5种基础Action
1253
+ */
1254
+ declare enum CurdAction {
1255
+ LIST = "LIST",
1256
+ DETAIL = "DETAIL",
1257
+ ADD = "ADD",
1258
+ EDIT = "EDIT",
1259
+ DELETE = "DELETE"
1260
+ }
1261
+ declare type ICurdAction = keyof typeof CurdAction | string;
1262
+ /**
1263
+ * CurdAction 的子事件
1264
+ */
1265
+ declare enum CurdSubAction {
1266
+ EMIT = "EMIT",
1267
+ EXECUTE = "EXECUTE",
1268
+ PAGE = "PAGE",
1269
+ SUCCESS = "SUCCESS",
1270
+ FAIL = "FAIL"
1271
+ }
1272
+ declare type ICurdSubAction = keyof typeof CurdSubAction;
1273
+ /**
1274
+ * curd 操作模式
1275
+ */
1276
+ declare enum CurdCurrentMode {
1277
+ ADD = "ADD",
1278
+ EDIT = "EDIT",
1279
+ DETAIL = "DETAIL"
1280
+ }
1281
+ declare type ICurdCurrentMode = keyof typeof CurdCurrentMode | string;
1282
+ /**
1283
+ * curd add 模式下 标记 "确定" "确定并继续" 触发
1284
+ */
1285
+ declare enum CurdAddAction {
1286
+ NORMAL = "NORMAL",
1287
+ CONTINUE = "CONTINUE"
1288
+ }
1287
1289
  declare type ICurdAddAction = keyof typeof CurdAddAction;
1288
1290
 
1289
- declare const modalCurdProps: () => {
1290
- defaultAddRecord: {
1291
- type: PropType<Record<string, any>>;
1292
- };
1293
- };
1294
- declare type ModalCurdProps = Partial<ExtractPropTypes<ReturnType<typeof modalCurdProps>>>;
1295
- declare type ProModalCurdProps = ModalCurdProps & ProCurdProps;
1291
+ declare const modalCurdProps: () => {
1292
+ defaultAddRecord: {
1293
+ type: PropType<Record<string, any>>;
1294
+ };
1295
+ };
1296
+ declare type ModalCurdProps = Partial<ExtractPropTypes<ReturnType<typeof modalCurdProps>>>;
1297
+ declare type ProModalCurdProps = ModalCurdProps & ProCurdProps;
1296
1298
  declare const ProModalCurd: vue.DefineComponent<ProModalCurdProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProModalCurdProps>, {}>;
1297
1299
 
1298
- declare const pageCurdProps: () => {
1299
- defaultAddRecord: {
1300
- type: PropType<Record<string, any>>;
1301
- };
1302
- routeBack: {
1303
- type: PropType<(action: ICurdAction) => void>;
1304
- };
1305
- };
1306
- declare type PageCurdProps = Partial<ExtractPropTypes<ReturnType<typeof pageCurdProps>>>;
1307
- declare type ProPageCurdProps = PageCurdProps & ProCurdProps;
1300
+ declare const pageCurdProps: () => {
1301
+ defaultAddRecord: {
1302
+ type: PropType<Record<string, any>>;
1303
+ };
1304
+ routeBack: {
1305
+ type: PropType<(action: ICurdAction) => void>;
1306
+ };
1307
+ };
1308
+ declare type PageCurdProps = Partial<ExtractPropTypes<ReturnType<typeof pageCurdProps>>>;
1309
+ declare type ProPageCurdProps = PageCurdProps & ProCurdProps;
1308
1310
  declare const ProPageCurd: vue.DefineComponent<ProPageCurdProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProPageCurdProps>, {}>;
1309
1311
 
1310
- /**
1311
- *
1312
- */
1313
- declare const ProCurdList: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1314
- clsName: {
1315
- type: StringConstructor;
1316
- default: string;
1317
- };
1318
- searchProps: {
1319
- type: vue.PropType<Record<string, any>>;
1320
- };
1321
- tableProps: {
1322
- type: vue.PropType<Record<string, any>>;
1323
- };
1324
- paginationProps: {
1325
- type: vue.PropType<Record<string, any>>;
1326
- };
1327
- pageState: {
1328
- type: vue.PropType<TPageState>;
1329
- };
1330
- }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<vue.ExtractPropTypes<{
1331
- clsName: {
1332
- type: StringConstructor;
1333
- default: string;
1334
- };
1335
- searchProps: {
1336
- type: vue.PropType<Record<string, any>>;
1337
- };
1338
- tableProps: {
1339
- type: vue.PropType<Record<string, any>>;
1340
- };
1341
- paginationProps: {
1342
- type: vue.PropType<Record<string, any>>;
1343
- };
1344
- pageState: {
1345
- type: vue.PropType<TPageState>;
1346
- };
1347
- }>>>, {}>;
1312
+ /**
1313
+ *
1314
+ */
1315
+ declare const ProCurdList: vue.DefineComponent<Partial<vue.ExtractPropTypes<{
1316
+ clsName: {
1317
+ type: StringConstructor;
1318
+ default: string;
1319
+ };
1320
+ searchProps: {
1321
+ type: vue.PropType<Record<string, any>>;
1322
+ };
1323
+ tableProps: {
1324
+ type: vue.PropType<Record<string, any>>;
1325
+ };
1326
+ paginationProps: {
1327
+ type: (vue.PropType<Record<string, any>> | vue.PropType<boolean>)[];
1328
+ };
1329
+ pageState: {
1330
+ type: vue.PropType<TPageState>;
1331
+ };
1332
+ }>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<vue.ExtractPropTypes<{
1333
+ clsName: {
1334
+ type: StringConstructor;
1335
+ default: string;
1336
+ };
1337
+ searchProps: {
1338
+ type: vue.PropType<Record<string, any>>;
1339
+ };
1340
+ tableProps: {
1341
+ type: vue.PropType<Record<string, any>>;
1342
+ };
1343
+ paginationProps: {
1344
+ type: (vue.PropType<Record<string, any>> | vue.PropType<boolean>)[];
1345
+ };
1346
+ pageState: {
1347
+ type: vue.PropType<TPageState>;
1348
+ };
1349
+ }>>>, {}>;
1348
1350
  declare const ProCurdListConnect: vue.DefineComponent<unknown, () => JSX.Element, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<unknown>, {}>;
1349
1351
 
1350
- declare const proCurdFormProps: () => {
1351
- /**
1352
- * class名称
1353
- */
1354
- clsName: {
1355
- type: StringConstructor;
1356
- default: string;
1357
- };
1358
- signName: {
1359
- type: StringConstructor;
1360
- };
1361
- };
1362
- declare type ProCurdFormProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdFormProps>>> & ProFormProps;
1363
- declare const ProCurdForm: vue.DefineComponent<ProCurdFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCurdFormProps>, {}>;
1352
+ declare const proCurdFormProps: () => {
1353
+ /**
1354
+ * class名称
1355
+ */
1356
+ clsName: {
1357
+ type: StringConstructor;
1358
+ default: string;
1359
+ };
1360
+ signName: {
1361
+ type: StringConstructor;
1362
+ };
1363
+ };
1364
+ declare type ProCurdFormProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdFormProps>>> & ProFormProps;
1365
+ declare const ProCurdForm: vue.DefineComponent<ProCurdFormProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCurdFormProps>, {}>;
1364
1366
  declare const ProCurdFormConnect: vue.DefineComponent<unknown, () => JSX.Element, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<unknown>, {}>;
1365
1367
 
1366
- declare const proCurdDescProps: () => {
1367
- /**
1368
- * class名称
1369
- */
1370
- clsName: {
1371
- type: StringConstructor;
1372
- default: string;
1373
- };
1374
- signName: {
1375
- type: StringConstructor;
1376
- };
1377
- };
1378
- declare type ProCurdDescProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdDescProps>>> & ProBaseProps & ProDescProps;
1379
- declare const ProCurdDesc: vue.DefineComponent<ProCurdDescProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCurdDescProps>, {
1380
- model?: any;
1381
- }>;
1368
+ declare const proCurdDescProps: () => {
1369
+ /**
1370
+ * class名称
1371
+ */
1372
+ clsName: {
1373
+ type: StringConstructor;
1374
+ default: string;
1375
+ };
1376
+ signName: {
1377
+ type: StringConstructor;
1378
+ };
1379
+ };
1380
+ declare type ProCurdDescProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdDescProps>>> & ProBaseProps & ProDescProps;
1381
+ declare const ProCurdDesc: vue.DefineComponent<ProCurdDescProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCurdDescProps>, {
1382
+ model?: any;
1383
+ }>;
1382
1384
  declare const ProCurdDescConnect: vue.DefineComponent<unknown, () => JSX.Element, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<unknown>, {}>;
1383
1385
 
1384
- declare const proCurdModalProps: () => {
1385
- /**
1386
- * class名称
1387
- */
1388
- clsName: {
1389
- type: StringConstructor;
1390
- default: string;
1391
- };
1392
- validMode: {
1393
- type: ArrayConstructor;
1394
- default: CurdAction[];
1395
- };
1396
- };
1397
- declare type ProCurdModalProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdModalProps>>> & Record<string, any>;
1398
- declare const ProCurdModal: vue.DefineComponent<ProCurdModalProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<ProCurdModalProps>>, {
1399
- [x: string]: any;
1400
- }>;
1401
- declare const ProCurdModalForm: vue.DefineComponent<{
1402
- modalProps: ObjectConstructor;
1403
- formProps: ObjectConstructor;
1404
- }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<{
1405
- modalProps: ObjectConstructor;
1406
- formProps: ObjectConstructor;
1407
- }>>, {}>;
1386
+ declare const proCurdModalProps: () => {
1387
+ /**
1388
+ * class名称
1389
+ */
1390
+ clsName: {
1391
+ type: StringConstructor;
1392
+ default: string;
1393
+ };
1394
+ validMode: {
1395
+ type: ArrayConstructor;
1396
+ default: CurdAction[];
1397
+ };
1398
+ };
1399
+ declare type ProCurdModalProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdModalProps>>> & Record<string, any>;
1400
+ declare const ProCurdModal: vue.DefineComponent<ProCurdModalProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<ProCurdModalProps>>, {
1401
+ [x: string]: any;
1402
+ }>;
1403
+ declare const ProCurdModalForm: vue.DefineComponent<{
1404
+ modalProps: ObjectConstructor;
1405
+ formProps: ObjectConstructor;
1406
+ }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<{
1407
+ modalProps: ObjectConstructor;
1408
+ formProps: ObjectConstructor;
1409
+ }>>, {}>;
1408
1410
  declare const ProCurdModalFormConnect: vue.DefineComponent<unknown, () => JSX.Element, {}, vue.ComputedOptions, vue.MethodOptions, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<unknown>, {}>;
1409
1411
 
1410
- /**
1411
- * 剔除showState或showStateRules规则为!true的值
1412
- * @param values
1413
- * @param showState
1414
- * @param showStateRules
1415
- */
1416
- declare const getValidValues: (values: Record<string, any>, showState?: BooleanObjType, showStateRules?: BooleanRulesObjType) => Record<string, any>;
1417
- /**
1418
- * string类型的path转为arr
1419
- * @param path
1420
- */
1421
- declare const convertPathToList: (path: undefined | string | number | (string | number)[]) => undefined | (string | number)[];
1422
- /**
1423
- * 将listState 中的数据通过id merge到 list item中
1424
- * ps：数组会替换
1425
- * 注意：mergeWith 会改变原始对象
1426
- * @param list
1427
- * @param listState
1428
- * @param id
1429
- */
1412
+ /**
1413
+ * 剔除showState或showStateRules规则为!true的值
1414
+ * @param values
1415
+ * @param showState
1416
+ * @param showStateRules
1417
+ */
1418
+ declare const getValidValues: (values: Record<string, any>, showState?: BooleanObjType, showStateRules?: BooleanRulesObjType) => Record<string, any>;
1419
+ /**
1420
+ * string类型的path转为arr
1421
+ * @param path
1422
+ */
1423
+ declare const convertPathToList: (path: undefined | string | number | (string | number)[]) => undefined | (string | number)[];
1424
+ /**
1425
+ * 将listState 中的数据通过id merge到 list item中
1426
+ * ps：数组会替换
1427
+ * 注意：mergeWith 会改变原始对象
1428
+ * @param list
1429
+ * @param listState
1430
+ * @param id
1431
+ */
1430
1432
  declare const mergeStateToList: (list: Record<string, any>[], listState: Record<string, any>, id: string | number | ((item: Record<string, any>) => string | number)) => Record<string, any>[];
1431
1433
 
1432
- /**
1433
- * ref 传递
1434
- */
1435
- declare const createExpose: (methods: string[], targetRef: Ref$1) => Record<string, any>;
1436
- declare const createExposeObj: (targetRef: Ref$1, methods?: string[], opts?: Record<string, any>) => Record<string, any>;
1437
- /**
1438
- * 从TColumn中查找标记值
1439
- * @param item
1440
- * @param signName
1441
- */
1442
- declare const getSignValue: <T = any>(item: TColumn, signName: string) => T;
1443
- /**
1444
- * 从slots对象中找出`${prefix}`开头的属性组成一个对象
1445
- * {
1446
- * `${prefix}${slot name}}`: ()=>Function,
1447
- * ...
1448
- * }
1449
- * @param slots
1450
- * @param prefix
1451
- */
1434
+ /**
1435
+ * ref 传递
1436
+ */
1437
+ declare const createExpose: (methods: string[], targetRef: Ref$1) => Record<string, any>;
1438
+ declare const createExposeObj: (targetRef: Ref$1, methods?: string[], opts?: Record<string, any>) => Record<string, any>;
1439
+ /**
1440
+ * 从TColumn中查找标记值
1441
+ * @param item
1442
+ * @param signName
1443
+ */
1444
+ declare const getSignValue: <T = any>(item: TColumn, signName: string) => T;
1445
+ /**
1446
+ * 从slots对象中找出`${prefix}`开头的属性组成一个对象
1447
+ * {
1448
+ * `${prefix}${slot name}}`: ()=>Function,
1449
+ * ...
1450
+ * }
1451
+ * @param slots
1452
+ * @param prefix
1453
+ */
1452
1454
  declare const filterSlotsByPrefix: (slots: Record<string, any>, prefix: string) => lodash.Dictionary<any>;
1453
1455
 
1454
- export { BooleanObjType, BooleanRulesObjType, ButtonKey, CheckboxKey, ColKey, CurdAction, CurdAddAction, CurdCurrentMode, CurdMethods, CurdSubAction, DescriptionsItemKey, DescriptionsKey, FieldNames, FormAction, FormItemKey, FormItemProps, FormKey, IAccess, ICurdAction, ICurdAddAction, ICurdCurrentMode, ICurdOperateOpts, ICurdState, ICurdSubAction, IElementConfig, IHighConfig, IListData, IOpeItem, IOperateItem, IProConfigProvide, IProCurdProvide, IProFormProvideExtra, IProModuleProvide, IProTableProvide, IProTableProvideExtra, IRequestOpts, ISearchMode, ITableOperate, IUser, InternalNamePath, LoadingKey, LogonUser, LogonUserKey, ModalKey, MustLogon, NamePath, PageHeader, PageHeaderProps, PaginationKey, PaginationSlotProps, PopoverKey, ProBaseProps, ProConfig, ProConfigProps, ProCurd, ProCurdDesc, ProCurdDescConnect, ProCurdDescProps, ProCurdForm, ProCurdFormConnect, ProCurdFormProps, ProCurdList, ProCurdListConnect, ProCurdModal, ProCurdModalForm, ProCurdModalFormConnect, ProCurdModalProps, ProCurdProps, ProDesc, ProDescProps, ProDispatchRequestType, ProForm, ProFormItemProps, ProFormKey, ProFormList, ProFormListProps, ProFormProps, ProGrid, ProGridProps, ProList, ProListProps, ProModalCurd, ProModalCurdProps, ProModule, ProModuleProps, ProOperate, ProOperateProps, ProPage, ProPageCurd, ProPageCurdProps, ProPageProps, ProSearchForm, ProSearchFormKey, ProSearchFormProps, ProTable, ProTableKey, ProTableProps, RequestAction, RowKey, SearchMode, SearchSlotProps, TAccess, TActionEvent, TActionState, TColumn, TColumns, TCurdActionEvent, TDefaultValueType, TElementMap, TInitialState, TLogonUserProvide, TMeta, TOption, TOptions, TPageState, TProFormOperate, TRegisterStore, TRegisterStoreMap, TTableColumn, TTableColumns, TValueType, TableKey, TreeOption, TreeOptions, Wrapper, convertPathToList, convertResData, createExpose, createExposeObj, createFormItemCompFn, createProConfig, defaultPage, filterSlotsByPrefix, getColumnFormItemName, getColumnValueType, getFirstPropName, getFormItemEl, getItemEl, getSignValue, getValidValues, mergeStateToList, proBaseProps, provideProCurd, provideProFormList, provideProModule, renderElement, renderElements, useAccess, useAccessMgr, useComposeRequestActor, useDispatchMeta, useDispatchStore, useDoneRequestActor, useFailedRequestActor, useGetCompByKey, useLogonUser, useMetaRegister, useModuleEvent, useProConfig, useProCurd, useProForm, useProFormList, useProModule, useProTable, useReadStore };
1456
+ export { BooleanObjType, BooleanRulesObjType, CurdAction, CurdAddAction, CurdCurrentMode, CurdMethods, CurdSubAction, ElementKeys, FieldNames, FormAction, FormItemProps, IAccess, ICurdAction, ICurdAddAction, ICurdCurrentMode, ICurdOperateOpts, ICurdState, ICurdSubAction, IElementConfig, IHighConfig, IListData, IOpeItem, IOperateItem, IProConfigProvide, IProCurdProvide, IProFormProvideExtra, IProModuleProvide, IProTableProvide, IProTableProvideExtra, IRequestOpts, ISearchMode, ITableOperate, IUser, InternalNamePath, LogonUser, LogonUserKey, MustLogon, NamePath, PageHeader, PageHeaderProps, PaginationSlotProps, ProBaseProps, ProConfig, ProConfigProps, ProCurd, ProCurdDesc, ProCurdDescConnect, ProCurdDescProps, ProCurdForm, ProCurdFormConnect, ProCurdFormProps, ProCurdList, ProCurdListConnect, ProCurdModal, ProCurdModalForm, ProCurdModalFormConnect, ProCurdModalProps, ProCurdProps, ProDesc, ProDescProps, ProDispatchRequestType, ProForm, ProFormItemProps, ProFormList, ProFormListProps, ProFormProps, ProGrid, ProGridProps, ProList, ProListProps, ProModalCurd, ProModalCurdProps, ProModule, ProModuleProps, ProOperate, ProOperateProps, ProPage, ProPageCurd, ProPageCurdProps, ProPageProps, ProSearchForm, ProSearchFormProps, ProTable, ProTableProps, RequestAction, SearchMode, SearchSlotProps, TAccess, TActionEvent, TActionState, TColumn, TColumns, TCurdActionEvent, TDefaultValueType, TElementMap, TInitialState, TLogonUserProvide, TMeta, TOption, TOptions, TPageState, TProFormOperate, TRegisterStore, TRegisterStoreMap, TTableColumn, TTableColumns, TValueType, TreeOption, TreeOptions, Wrapper, convertPathToList, convertResData, createExpose, createExposeObj, createFormItemCompFn, createProConfig, defaultPage, filterSlotsByPrefix, getColumnFormItemName, getColumnValueType, getFirstPropName, getFormItemEl, getItemEl, getSignValue, getValidValues, mergeStateToList, proBaseProps, provideProCurd, provideProFormList, provideProModule, renderElement, renderElements, useAccess, useAccessMgr, useComposeRequestActor, useDispatchMeta, useDispatchStore, useDoneRequestActor, useFailedRequestActor, useGetCompByKey, useLogonUser, useMetaRegister, useModuleEvent, useProConfig, useProCurd, useProForm, useProFormList, useProModule, useProTable, useReadStore };