twcpt 0.0.2 → 0.0.3

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 (24) hide show
  1. package/README.md +33 -4
  2. package/dist/charts.cjs.js +1 -1
  3. package/dist/charts.es.js +1 -1
  4. package/dist/components/j-tw-btn/index.d.ts +43 -6
  5. package/dist/components/j-tw-btn/types.d.ts +19 -4
  6. package/dist/components/j-tw-date-picker/index.d.ts +1590 -0
  7. package/dist/components/j-tw-date-picker/types.d.ts +147 -0
  8. package/dist/components/j-tw-dropdown-btn/index.d.ts +3 -0
  9. package/dist/components/j-tw-dropdown-btn/types.d.ts +69 -0
  10. package/dist/components/j-tw-tree-select-btn/index.d.ts +1356 -0
  11. package/dist/components/j-tw-tree-select-btn/types.d.ts +99 -0
  12. package/dist/global.d.ts +30 -0
  13. package/dist/index.css +1 -1
  14. package/dist/index.d.ts +8 -5
  15. package/dist/twcpt-styles.css +1 -1
  16. package/dist/twcpt.cjs.js +8 -1
  17. package/dist/twcpt.es.js +2598 -1451
  18. package/dist/utils/init.d.ts +19 -0
  19. package/dist/utils/tool.d.ts +1 -1
  20. package/package.json +4 -2
  21. package/dist/charts.css +0 -1
  22. package/dist/utils/website-config.d.ts +0 -15
  23. /package/dist/{charts-CKv8I1ye.js → charts-BRqaKjiE.js} +0 -0
  24. /package/dist/{charts-DIdINgA4.cjs → charts-lTMiYKQB.cjs} +0 -0
package/dist/components/j-tw-tree-select-btn/index.d.ts ADDED
@@ -0,0 +1,1356 @@
1
+ import { nextTick, PropType, DefineComponent, ExtractPropTypes, Ref, ComponentInternalInstance, Component, VNodeProps, AllowedComponentProps, ComponentCustomProps, Attrs, Slot, ComponentPublicInstance, ComponentOptionsBase, ComputedRef, ComponentOptionsMixin, GlobalComponents, GlobalDirectives, ComponentProvideOptions, DebuggerEvent, WatchOptions, WatchStopHandle, ShallowUnwrapRef, ComponentCustomProperties, PublicProps, CreateComponentPublicInstanceWithMixins, ObjectPlugin, CSSProperties, StyleValue } from 'vue';
2
+ import { JTWBtnSizeType, JTWBtnTooltipConfig, JTWBtnTypeType } from '../j-tw-btn/types';
3
+ import { JTWTreeNode } from './types';
4
+ import { ComponentSize, ButtonType, ButtonNativeType, ButtonProps, UseTooltipProps, PopperInstance, TooltipContentInstance, PopperEffect, Placement, Options, TooltipTriggerType } from 'element-plus';
5
+ import { IconPropType, SFCWithInstall } from 'element-plus/es/utils/index.mjs';
6
+ import { OnCleanup } from '@vue/reactivity';
7
+ import { ButtonGroupProps } from 'element-plus/es/components/button/src/button-group.mjs';
8
+ import { Arrayable } from 'element-plus/es/utils/typescript.mjs';
9
+ declare const _default: DefineComponent<ExtractPropTypes<{
10
+ size: {
11
+ type: PropType<JTWBtnSizeType>;
12
+ default: "normal";
13
+ validator: (value: JTWBtnSizeType) => boolean;
14
+ };
15
+ type: {
16
+ type: PropType<JTWBtnTypeType>;
17
+ default: "button";
18
+ validator: (value: JTWBtnTypeType) => boolean;
19
+ };
20
+ outline: {
21
+ type: BooleanConstructor;
22
+ default: boolean;
23
+ };
24
+ label: {
25
+ type: StringConstructor;
26
+ default: string;
27
+ };
28
+ loading: {
29
+ type: BooleanConstructor;
30
+ default: boolean;
31
+ };
32
+ tips: {
33
+ type: (NumberConstructor | StringConstructor)[];
34
+ default: string;
35
+ };
36
+ tooltipConfig: {
37
+ type: PropType<JTWBtnTooltipConfig>;
38
+ default: undefined;
39
+ };
40
+ data: {
41
+ type: PropType<JTWTreeNode[]>;
42
+ default: () => never[];
43
+ };
44
+ modelValue: {
45
+ type: PropType<string | number | (string | number)[]>;
46
+ default: undefined;
47
+ };
48
+ searchPlaceholder: {
49
+ type: StringConstructor;
50
+ default: string;
51
+ };
52
+ dropdownWidth: {
53
+ type: NumberConstructor;
54
+ default: number;
55
+ };
56
+ dropdownMaxHeight: {
57
+ type: NumberConstructor;
58
+ default: number;
59
+ };
60
+ accordion: {
61
+ type: BooleanConstructor;
62
+ default: boolean;
63
+ };
64
+ multiple: {
65
+ type: BooleanConstructor;
66
+ default: boolean;
67
+ };
68
+ }>, {
69
+ treeSelectRef: Ref<HTMLElement | null, HTMLElement | null>;
70
+ mainBtnRef: Ref<({
71
+ $: ComponentInternalInstance;
72
+ $data: {};
73
+ $props: {
74
+ readonly size?: ComponentSize | undefined;
75
+ readonly disabled?: boolean | undefined;
76
+ readonly type?: ButtonType | undefined;
77
+ readonly icon?: IconPropType | undefined;
78
+ readonly nativeType?: ButtonNativeType | undefined;
79
+ readonly loading?: boolean | undefined;
80
+ readonly loadingIcon?: IconPropType | undefined;
81
+ readonly plain?: boolean | undefined;
82
+ readonly text?: boolean | undefined;
83
+ readonly link?: boolean | undefined;
84
+ readonly bg?: boolean | undefined;
85
+ readonly autofocus?: boolean | undefined;
86
+ readonly round?: boolean | undefined;
87
+ readonly circle?: boolean | undefined;
88
+ readonly dashed?: boolean | undefined;
89
+ readonly color?: string | undefined;
90
+ readonly dark?: boolean | undefined;
91
+ readonly autoInsertSpace?: boolean | undefined;
92
+ readonly tag?: (string | Component) | undefined;
93
+ readonly onClick?: ((evt: MouseEvent) => any) | undefined | undefined;
94
+ } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
95
+ $attrs: Attrs;
96
+ $refs: {
97
+ [x: string]: unknown;
98
+ };
99
+ $slots: Readonly<{
100
+ [name: string]: Slot<any> | undefined;
101
+ }>;
102
+ $root: ComponentPublicInstance | null;
103
+ $parent: ComponentPublicInstance | null;
104
+ $host: Element | null;
105
+ $emit: (event: "click", evt: MouseEvent) => void;
106
+ $el: any;
107
+ $options: ComponentOptionsBase<Readonly< ButtonProps> & Readonly<{
108
+ onClick?: ((evt: MouseEvent) => any) | undefined;
109
+ }>, {
110
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
111
+ size: ComputedRef<"" | "default" | "large" | "small">;
112
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
113
+ disabled: ComputedRef<boolean>;
114
+ shouldAddSpace: ComputedRef<boolean>;
115
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
116
+ click: (evt: MouseEvent) => void;
117
+ }, string, {
118
+ type: ButtonType;
119
+ disabled: boolean;
120
+ text: boolean;
121
+ round: boolean;
122
+ dashed: boolean;
123
+ plain: boolean;
124
+ nativeType: ButtonNativeType;
125
+ loadingIcon: IconPropType;
126
+ autoInsertSpace: boolean;
127
+ tag: string | Component;
128
+ }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
129
+ beforeCreate?: (() => void) | (() => void)[];
130
+ created?: (() => void) | (() => void)[];
131
+ beforeMount?: (() => void) | (() => void)[];
132
+ mounted?: (() => void) | (() => void)[];
133
+ beforeUpdate?: (() => void) | (() => void)[];
134
+ updated?: (() => void) | (() => void)[];
135
+ activated?: (() => void) | (() => void)[];
136
+ deactivated?: (() => void) | (() => void)[];
137
+ beforeDestroy?: (() => void) | (() => void)[];
138
+ beforeUnmount?: (() => void) | (() => void)[];
139
+ destroyed?: (() => void) | (() => void)[];
140
+ unmounted?: (() => void) | (() => void)[];
141
+ renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
142
+ renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
143
+ errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
144
+ };
145
+ $forceUpdate: () => void;
146
+ $nextTick: typeof nextTick;
147
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
148
+ } & Readonly<{
149
+ type: ButtonType;
150
+ disabled: boolean;
151
+ text: boolean;
152
+ round: boolean;
153
+ dashed: boolean;
154
+ plain: boolean;
155
+ nativeType: ButtonNativeType;
156
+ loadingIcon: IconPropType;
157
+ autoInsertSpace: boolean;
158
+ tag: string | Component;
159
+ }> & Omit<Readonly< ButtonProps> & Readonly<{
160
+ onClick?: ((evt: MouseEvent) => any) | undefined;
161
+ }>, "type" | "text" | "ref" | "size" | "round" | "disabled" | "nativeType" | "loadingIcon" | "plain" | "dashed" | "autoInsertSpace" | "tag" | "shouldAddSpace"> & ShallowUnwrapRef<{
162
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
163
+ size: ComputedRef<"" | "default" | "large" | "small">;
164
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
165
+ disabled: ComputedRef<boolean>;
166
+ shouldAddSpace: ComputedRef<boolean>;
167
+ }> & {} & ComponentCustomProperties & {} & {
168
+ $slots: {
169
+ loading?: (props: {}) => any;
170
+ } & {
171
+ icon?: (props: {}) => any;
172
+ } & {
173
+ default?: (props: {}) => any;
174
+ };
175
+ }) | null, ({
176
+ $: ComponentInternalInstance;
177
+ $data: {};
178
+ $props: {
179
+ readonly size?: ComponentSize | undefined;
180
+ readonly disabled?: boolean | undefined;
181
+ readonly type?: ButtonType | undefined;
182
+ readonly icon?: IconPropType | undefined;
183
+ readonly nativeType?: ButtonNativeType | undefined;
184
+ readonly loading?: boolean | undefined;
185
+ readonly loadingIcon?: IconPropType | undefined;
186
+ readonly plain?: boolean | undefined;
187
+ readonly text?: boolean | undefined;
188
+ readonly link?: boolean | undefined;
189
+ readonly bg?: boolean | undefined;
190
+ readonly autofocus?: boolean | undefined;
191
+ readonly round?: boolean | undefined;
192
+ readonly circle?: boolean | undefined;
193
+ readonly dashed?: boolean | undefined;
194
+ readonly color?: string | undefined;
195
+ readonly dark?: boolean | undefined;
196
+ readonly autoInsertSpace?: boolean | undefined;
197
+ readonly tag?: (string | Component) | undefined;
198
+ readonly onClick?: ((evt: MouseEvent) => any) | undefined | undefined;
199
+ } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
200
+ $attrs: Attrs;
201
+ $refs: {
202
+ [x: string]: unknown;
203
+ };
204
+ $slots: Readonly<{
205
+ [name: string]: Slot<any> | undefined;
206
+ }>;
207
+ $root: ComponentPublicInstance | null;
208
+ $parent: ComponentPublicInstance | null;
209
+ $host: Element | null;
210
+ $emit: (event: "click", evt: MouseEvent) => void;
211
+ $el: any;
212
+ $options: ComponentOptionsBase<Readonly< ButtonProps> & Readonly<{
213
+ onClick?: ((evt: MouseEvent) => any) | undefined;
214
+ }>, {
215
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
216
+ size: ComputedRef<"" | "default" | "large" | "small">;
217
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
218
+ disabled: ComputedRef<boolean>;
219
+ shouldAddSpace: ComputedRef<boolean>;
220
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
221
+ click: (evt: MouseEvent) => void;
222
+ }, string, {
223
+ type: ButtonType;
224
+ disabled: boolean;
225
+ text: boolean;
226
+ round: boolean;
227
+ dashed: boolean;
228
+ plain: boolean;
229
+ nativeType: ButtonNativeType;
230
+ loadingIcon: IconPropType;
231
+ autoInsertSpace: boolean;
232
+ tag: string | Component;
233
+ }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
234
+ beforeCreate?: (() => void) | (() => void)[];
235
+ created?: (() => void) | (() => void)[];
236
+ beforeMount?: (() => void) | (() => void)[];
237
+ mounted?: (() => void) | (() => void)[];
238
+ beforeUpdate?: (() => void) | (() => void)[];
239
+ updated?: (() => void) | (() => void)[];
240
+ activated?: (() => void) | (() => void)[];
241
+ deactivated?: (() => void) | (() => void)[];
242
+ beforeDestroy?: (() => void) | (() => void)[];
243
+ beforeUnmount?: (() => void) | (() => void)[];
244
+ destroyed?: (() => void) | (() => void)[];
245
+ unmounted?: (() => void) | (() => void)[];
246
+ renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
247
+ renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
248
+ errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
249
+ };
250
+ $forceUpdate: () => void;
251
+ $nextTick: typeof nextTick;
252
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
253
+ } & Readonly<{
254
+ type: ButtonType;
255
+ disabled: boolean;
256
+ text: boolean;
257
+ round: boolean;
258
+ dashed: boolean;
259
+ plain: boolean;
260
+ nativeType: ButtonNativeType;
261
+ loadingIcon: IconPropType;
262
+ autoInsertSpace: boolean;
263
+ tag: string | Component;
264
+ }> & Omit<Readonly< ButtonProps> & Readonly<{
265
+ onClick?: ((evt: MouseEvent) => any) | undefined;
266
+ }>, "type" | "text" | "ref" | "size" | "round" | "disabled" | "nativeType" | "loadingIcon" | "plain" | "dashed" | "autoInsertSpace" | "tag" | "shouldAddSpace"> & ShallowUnwrapRef<{
267
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
268
+ size: ComputedRef<"" | "default" | "large" | "small">;
269
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
270
+ disabled: ComputedRef<boolean>;
271
+ shouldAddSpace: ComputedRef<boolean>;
272
+ }> & {} & ComponentCustomProperties & {} & {
273
+ $slots: {
274
+ loading?: (props: {}) => any;
275
+ } & {
276
+ icon?: (props: {}) => any;
277
+ } & {
278
+ default?: (props: {}) => any;
279
+ };
280
+ }) | null>;
281
+ dropdownMenuRef: Ref<HTMLElement | null, HTMLElement | null>;
282
+ treeContainerRef: Ref<HTMLElement | null, HTMLElement | null>;
283
+ dropdownVisible: Ref<boolean, boolean>;
284
+ dropdownMenuStyle: Ref<Record<string, string>, Record<string, string>>;
285
+ searchText: Ref<string, string>;
286
+ expandedKeys: Ref<Set<string | number> & Omit<Set<string | number>, keyof Set<any>>, Set<string | number> | (Set<string | number> & Omit<Set<string | number>, keyof Set<any>>)>;
287
+ tempSelectedValue: Ref<string | number | undefined, string | number | undefined>;
288
+ tooltipContent: ComputedRef<string>;
289
+ displayLabel: ComputedRef<string>;
290
+ filteredData: ComputedRef<JTWTreeNode[]>;
291
+ treeSelectClass: ComputedRef<{
292
+ 'j-tw-tree-select-btn': boolean;
293
+ 'j-tw-tree-select-btn--large': boolean;
294
+ 'j-tw-tree-select-btn--normal': boolean;
295
+ 'j-tw-tree-select-btn--small': boolean;
296
+ }>;
297
+ mainBtnClass: ComputedRef<{
298
+ 'j-tw-btn': boolean;
299
+ 'j-tw-tree-select-btn__main': boolean;
300
+ 'j-tw-btn--large': boolean;
301
+ 'j-tw-btn--normal': boolean;
302
+ 'j-tw-btn--small': boolean;
303
+ 'j-tw-btn--button': boolean;
304
+ 'j-tw-btn--outline': boolean;
305
+ 'j-tw-btn--text': boolean;
306
+ }>;
307
+ computedStyle: ComputedRef<{
308
+ '--j-btn-color': string;
309
+ '--j-btn-color-1': string;
310
+ '--j-btn-color-2': string;
311
+ '--j-btn-color-3': string;
312
+ '--j-btn-color-4': string;
313
+ '--j-btn-color-5': string;
314
+ '--j-btn-color-6': string;
315
+ '--j-tree-select-btn-color': string;
316
+ }>;
317
+ mergedTooltipConfig: ComputedRef<{
318
+ placement: "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end";
319
+ effect: "dark" | "light";
320
+ trigger: "hover" | "click" | "focus" | "contextmenu";
321
+ showArrow: boolean;
322
+ openDelay: number;
323
+ closeDelay: number;
324
+ offset: number;
325
+ }>;
326
+ handleMainClick: (e: MouseEvent) => void;
327
+ toggleDropdown: () => void;
328
+ toggleExpand: (key: string | number) => void;
329
+ handleNodeClick: (node: JTWTreeNode) => void;
330
+ handleConfirm: () => void;
331
+ handleCancel: () => void;
332
+ isNodeChecked: (nodeValue: string | number) => boolean;
333
+ isNodeIndeterminate: (node: JTWTreeNode) => boolean;
334
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
335
+ click: (_e: MouseEvent) => true;
336
+ 'update:modelValue': (_value: string | number | (string | number)[]) => true;
337
+ select: (_node: JTWTreeNode | JTWTreeNode[]) => true;
338
+ confirm: (_node: JTWTreeNode | JTWTreeNode[] | null) => true;
339
+ cancel: () => true;
340
+ }, string, PublicProps, Readonly< ExtractPropTypes<{
341
+ size: {
342
+ type: PropType<JTWBtnSizeType>;
343
+ default: "normal";
344
+ validator: (value: JTWBtnSizeType) => boolean;
345
+ };
346
+ type: {
347
+ type: PropType<JTWBtnTypeType>;
348
+ default: "button";
349
+ validator: (value: JTWBtnTypeType) => boolean;
350
+ };
351
+ outline: {
352
+ type: BooleanConstructor;
353
+ default: boolean;
354
+ };
355
+ label: {
356
+ type: StringConstructor;
357
+ default: string;
358
+ };
359
+ loading: {
360
+ type: BooleanConstructor;
361
+ default: boolean;
362
+ };
363
+ tips: {
364
+ type: (NumberConstructor | StringConstructor)[];
365
+ default: string;
366
+ };
367
+ tooltipConfig: {
368
+ type: PropType<JTWBtnTooltipConfig>;
369
+ default: undefined;
370
+ };
371
+ data: {
372
+ type: PropType<JTWTreeNode[]>;
373
+ default: () => never[];
374
+ };
375
+ modelValue: {
376
+ type: PropType<string | number | (string | number)[]>;
377
+ default: undefined;
378
+ };
379
+ searchPlaceholder: {
380
+ type: StringConstructor;
381
+ default: string;
382
+ };
383
+ dropdownWidth: {
384
+ type: NumberConstructor;
385
+ default: number;
386
+ };
387
+ dropdownMaxHeight: {
388
+ type: NumberConstructor;
389
+ default: number;
390
+ };
391
+ accordion: {
392
+ type: BooleanConstructor;
393
+ default: boolean;
394
+ };
395
+ multiple: {
396
+ type: BooleanConstructor;
397
+ default: boolean;
398
+ };
399
+ }>> & Readonly<{
400
+ onSelect?: ((_node: JTWTreeNode | JTWTreeNode[]) => any) | undefined;
401
+ onClick?: ((_e: MouseEvent) => any) | undefined;
402
+ onCancel?: (() => any) | undefined;
403
+ "onUpdate:modelValue"?: ((_value: string | number | (string | number)[]) => any) | undefined;
404
+ onConfirm?: ((_node: JTWTreeNode | JTWTreeNode[] | null) => any) | undefined;
405
+ }>, {
406
+ type: JTWBtnTypeType;
407
+ data: JTWTreeNode[];
408
+ label: string;
409
+ size: JTWBtnSizeType;
410
+ loading: boolean;
411
+ outline: boolean;
412
+ tips: string | number;
413
+ tooltipConfig: JTWBtnTooltipConfig;
414
+ modelValue: string | number | (string | number)[];
415
+ searchPlaceholder: string;
416
+ dropdownWidth: number;
417
+ dropdownMaxHeight: number;
418
+ accordion: boolean;
419
+ multiple: boolean;
420
+ }, {}, {
421
+ ElButton: {
422
+ new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ButtonProps> & Readonly<{
423
+ onClick?: ((evt: MouseEvent) => any) | undefined;
424
+ }>, {
425
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
426
+ size: ComputedRef<"" | "default" | "large" | "small">;
427
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
428
+ disabled: ComputedRef<boolean>;
429
+ shouldAddSpace: ComputedRef<boolean>;
430
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
431
+ click: (evt: MouseEvent) => void;
432
+ }, PublicProps, {
433
+ type: ButtonType;
434
+ disabled: boolean;
435
+ text: boolean;
436
+ round: boolean;
437
+ dashed: boolean;
438
+ plain: boolean;
439
+ nativeType: ButtonNativeType;
440
+ loadingIcon: IconPropType;
441
+ autoInsertSpace: boolean;
442
+ tag: string | Component;
443
+ }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
444
+ P: {};
445
+ B: {};
446
+ D: {};
447
+ C: {};
448
+ M: {};
449
+ Defaults: {};
450
+ }, Readonly< ButtonProps> & Readonly<{
451
+ onClick?: ((evt: MouseEvent) => any) | undefined;
452
+ }>, {
453
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
454
+ size: ComputedRef<"" | "default" | "large" | "small">;
455
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
456
+ disabled: ComputedRef<boolean>;
457
+ shouldAddSpace: ComputedRef<boolean>;
458
+ }, {}, {}, {}, {
459
+ type: ButtonType;
460
+ disabled: boolean;
461
+ text: boolean;
462
+ round: boolean;
463
+ dashed: boolean;
464
+ plain: boolean;
465
+ nativeType: ButtonNativeType;
466
+ loadingIcon: IconPropType;
467
+ autoInsertSpace: boolean;
468
+ tag: string | Component;
469
+ }>;
470
+ __isFragment?: never;
471
+ __isTeleport?: never;
472
+ __isSuspense?: never;
473
+ } & ComponentOptionsBase<Readonly< ButtonProps> & Readonly<{
474
+ onClick?: ((evt: MouseEvent) => any) | undefined;
475
+ }>, {
476
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
477
+ size: ComputedRef<"" | "default" | "large" | "small">;
478
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
479
+ disabled: ComputedRef<boolean>;
480
+ shouldAddSpace: ComputedRef<boolean>;
481
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
482
+ click: (evt: MouseEvent) => void;
483
+ }, string, {
484
+ type: ButtonType;
485
+ disabled: boolean;
486
+ text: boolean;
487
+ round: boolean;
488
+ dashed: boolean;
489
+ plain: boolean;
490
+ nativeType: ButtonNativeType;
491
+ loadingIcon: IconPropType;
492
+ autoInsertSpace: boolean;
493
+ tag: string | Component;
494
+ }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
495
+ $slots: {
496
+ loading?: (props: {}) => any;
497
+ } & {
498
+ icon?: (props: {}) => any;
499
+ } & {
500
+ default?: (props: {}) => any;
501
+ };
502
+ }) & ObjectPlugin & {
503
+ setPropsDefaults: (defaults: Partial<{
504
+ readonly size?: ComponentSize | undefined;
505
+ readonly disabled?: boolean | undefined;
506
+ readonly type?: ButtonType | undefined;
507
+ readonly icon?: IconPropType | undefined;
508
+ readonly nativeType?: ButtonNativeType | undefined;
509
+ readonly loading?: boolean | undefined;
510
+ readonly loadingIcon?: IconPropType | undefined;
511
+ readonly plain?: boolean | undefined;
512
+ readonly text?: boolean | undefined;
513
+ readonly link?: boolean | undefined;
514
+ readonly bg?: boolean | undefined;
515
+ readonly autofocus?: boolean | undefined;
516
+ readonly round?: boolean | undefined;
517
+ readonly circle?: boolean | undefined;
518
+ readonly dashed?: boolean | undefined;
519
+ readonly color?: string | undefined;
520
+ readonly dark?: boolean | undefined;
521
+ readonly autoInsertSpace?: boolean | undefined;
522
+ readonly tag?: (string | Component) | undefined;
523
+ readonly onClick?: ((evt: MouseEvent) => any) | undefined | undefined;
524
+ } & VNodeProps & AllowedComponentProps & ComponentCustomProps>) => void;
525
+ } & {
526
+ ButtonGroup: {
527
+ new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
528
+ type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
529
+ direction: "horizontal" | "vertical";
530
+ }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
531
+ P: {};
532
+ B: {};
533
+ D: {};
534
+ C: {};
535
+ M: {};
536
+ Defaults: {};
537
+ }, Readonly< ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
538
+ type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
539
+ direction: "horizontal" | "vertical";
540
+ }>;
541
+ __isFragment?: never;
542
+ __isTeleport?: never;
543
+ __isSuspense?: never;
544
+ } & ComponentOptionsBase<Readonly< ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
545
+ type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
546
+ direction: "horizontal" | "vertical";
547
+ }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
548
+ $slots: {
549
+ default?: (props: {}) => any;
550
+ };
551
+ });
552
+ };
553
+ ElTooltip: SFCWithInstall<{
554
+ new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< UseTooltipProps> & Readonly<{
555
+ onClose?: ((...args: any[]) => any) | undefined;
556
+ "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
557
+ "onBefore-show"?: ((...args: any[]) => any) | undefined;
558
+ "onBefore-hide"?: ((...args: any[]) => any) | undefined;
559
+ onShow?: ((...args: any[]) => any) | undefined;
560
+ onHide?: ((...args: any[]) => any) | undefined;
561
+ onOpen?: ((...args: any[]) => any) | undefined;
562
+ }>, {
563
+ popperRef: Ref< PopperInstance | undefined, PopperInstance | undefined>;
564
+ contentRef: Ref< TooltipContentInstance | undefined, TooltipContentInstance | undefined>;
565
+ isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
566
+ updatePopper: () => void;
567
+ onOpen: (event?: Event, delay?: number) => void;
568
+ onClose: (event?: Event, delay?: number) => void;
569
+ hide: (event?: Event) => void;
570
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
571
+ close: (...args: any[]) => void;
572
+ "update:visible": (...args: any[]) => void;
573
+ "before-show": (...args: any[]) => void;
574
+ "before-hide": (...args: any[]) => void;
575
+ show: (...args: any[]) => void;
576
+ hide: (...args: any[]) => void;
577
+ open: (...args: any[]) => void;
578
+ }, PublicProps, {
579
+ effect: PopperEffect;
580
+ placement: Placement;
581
+ popperStyle: string | false | CSSProperties | StyleValue[] | null;
582
+ teleported: boolean;
583
+ visible: boolean | null;
584
+ style: string | false | CSSProperties | StyleValue[] | null;
585
+ enterable: boolean;
586
+ pure: boolean;
587
+ focusOnShow: boolean;
588
+ trapping: boolean;
589
+ stopPopperMouseEvent: boolean;
590
+ virtualTriggering: boolean;
591
+ loop: boolean;
592
+ boundariesPadding: number;
593
+ gpuAcceleration: boolean;
594
+ offset: number;
595
+ popperOptions: Partial< Options>;
596
+ strategy: "absolute" | "fixed";
597
+ arrowOffset: number;
598
+ showArrow: boolean;
599
+ role: "dialog" | "menu" | "tooltip" | "grid" | "group" | "listbox" | "navigation" | "tree";
600
+ content: string;
601
+ showAfter: number;
602
+ hideAfter: number;
603
+ autoClose: number;
604
+ trigger: Arrayable<TooltipTriggerType>;
605
+ triggerKeys: string[];
606
+ }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
607
+ P: {};
608
+ B: {};
609
+ D: {};
610
+ C: {};
611
+ M: {};
612
+ Defaults: {};
613
+ }, Readonly< UseTooltipProps> & Readonly<{
614
+ onClose?: ((...args: any[]) => any) | undefined;
615
+ "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
616
+ "onBefore-show"?: ((...args: any[]) => any) | undefined;
617
+ "onBefore-hide"?: ((...args: any[]) => any) | undefined;
618
+ onShow?: ((...args: any[]) => any) | undefined;
619
+ onHide?: ((...args: any[]) => any) | undefined;
620
+ onOpen?: ((...args: any[]) => any) | undefined;
621
+ }>, {
622
+ popperRef: Ref< PopperInstance | undefined, PopperInstance | undefined>;
623
+ contentRef: Ref< TooltipContentInstance | undefined, TooltipContentInstance | undefined>;
624
+ isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
625
+ updatePopper: () => void;
626
+ onOpen: (event?: Event, delay?: number) => void;
627
+ onClose: (event?: Event, delay?: number) => void;
628
+ hide: (event?: Event) => void;
629
+ }, {}, {}, {}, {
630
+ effect: PopperEffect;
631
+ placement: Placement;
632
+ popperStyle: string | false | CSSProperties | StyleValue[] | null;
633
+ teleported: boolean;
634
+ visible: boolean | null;
635
+ style: string | false | CSSProperties | StyleValue[] | null;
636
+ enterable: boolean;
637
+ pure: boolean;
638
+ focusOnShow: boolean;
639
+ trapping: boolean;
640
+ stopPopperMouseEvent: boolean;
641
+ virtualTriggering: boolean;
642
+ loop: boolean;
643
+ boundariesPadding: number;
644
+ gpuAcceleration: boolean;
645
+ offset: number;
646
+ popperOptions: Partial< Options>;
647
+ strategy: "absolute" | "fixed";
648
+ arrowOffset: number;
649
+ showArrow: boolean;
650
+ role: "dialog" | "menu" | "tooltip" | "grid" | "group" | "listbox" | "navigation" | "tree";
651
+ content: string;
652
+ showAfter: number;
653
+ hideAfter: number;
654
+ autoClose: number;
655
+ trigger: Arrayable<TooltipTriggerType>;
656
+ triggerKeys: string[];
657
+ }>;
658
+ __isFragment?: never;
659
+ __isTeleport?: never;
660
+ __isSuspense?: never;
661
+ } & ComponentOptionsBase<Readonly< UseTooltipProps> & Readonly<{
662
+ onClose?: ((...args: any[]) => any) | undefined;
663
+ "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
664
+ "onBefore-show"?: ((...args: any[]) => any) | undefined;
665
+ "onBefore-hide"?: ((...args: any[]) => any) | undefined;
666
+ onShow?: ((...args: any[]) => any) | undefined;
667
+ onHide?: ((...args: any[]) => any) | undefined;
668
+ onOpen?: ((...args: any[]) => any) | undefined;
669
+ }>, {
670
+ popperRef: Ref< PopperInstance | undefined, PopperInstance | undefined>;
671
+ contentRef: Ref< TooltipContentInstance | undefined, TooltipContentInstance | undefined>;
672
+ isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
673
+ updatePopper: () => void;
674
+ onOpen: (event?: Event, delay?: number) => void;
675
+ onClose: (event?: Event, delay?: number) => void;
676
+ hide: (event?: Event) => void;
677
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
678
+ close: (...args: any[]) => void;
679
+ "update:visible": (...args: any[]) => void;
680
+ "before-show": (...args: any[]) => void;
681
+ "before-hide": (...args: any[]) => void;
682
+ show: (...args: any[]) => void;
683
+ hide: (...args: any[]) => void;
684
+ open: (...args: any[]) => void;
685
+ }, string, {
686
+ effect: PopperEffect;
687
+ placement: Placement;
688
+ popperStyle: string | false | CSSProperties | StyleValue[] | null;
689
+ teleported: boolean;
690
+ visible: boolean | null;
691
+ style: string | false | CSSProperties | StyleValue[] | null;
692
+ enterable: boolean;
693
+ pure: boolean;
694
+ focusOnShow: boolean;
695
+ trapping: boolean;
696
+ stopPopperMouseEvent: boolean;
697
+ virtualTriggering: boolean;
698
+ loop: boolean;
699
+ boundariesPadding: number;
700
+ gpuAcceleration: boolean;
701
+ offset: number;
702
+ popperOptions: Partial< Options>;
703
+ strategy: "absolute" | "fixed";
704
+ arrowOffset: number;
705
+ showArrow: boolean;
706
+ role: "dialog" | "menu" | "tooltip" | "grid" | "group" | "listbox" | "navigation" | "tree";
707
+ content: string;
708
+ showAfter: number;
709
+ hideAfter: number;
710
+ autoClose: number;
711
+ trigger: Arrayable<TooltipTriggerType>;
712
+ triggerKeys: string[];
713
+ }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
714
+ $slots: {
715
+ default?: (props: {}) => any;
716
+ } & {
717
+ content?: (props: {}) => any;
718
+ };
719
+ })>;
720
+ JTWBtn: DefineComponent<ExtractPropTypes<{
721
+ size: {
722
+ type: PropType<JTWBtnSizeType>;
723
+ default: "normal";
724
+ validator: (value: JTWBtnSizeType) => boolean;
725
+ };
726
+ type: {
727
+ type: PropType<JTWBtnTypeType>;
728
+ default: "button";
729
+ validator: (value: JTWBtnTypeType) => boolean;
730
+ };
731
+ color: {
732
+ type: StringConstructor;
733
+ default: string;
734
+ };
735
+ outline: {
736
+ type: BooleanConstructor;
737
+ default: boolean;
738
+ };
739
+ flat: {
740
+ type: BooleanConstructor;
741
+ default: boolean;
742
+ };
743
+ label: {
744
+ type: StringConstructor;
745
+ default: string;
746
+ };
747
+ loading: {
748
+ type: BooleanConstructor;
749
+ default: boolean;
750
+ };
751
+ tips: {
752
+ type: (NumberConstructor | StringConstructor)[];
753
+ default: string;
754
+ };
755
+ tooltipConfig: {
756
+ type: PropType<JTWBtnTooltipConfig>;
757
+ default: undefined;
758
+ };
759
+ }>, {
760
+ elBtnRef: Ref<({
761
+ $: ComponentInternalInstance;
762
+ $data: {};
763
+ $props: {
764
+ readonly size?: ComponentSize | undefined;
765
+ readonly disabled?: boolean | undefined;
766
+ readonly type?: ButtonType | undefined;
767
+ readonly icon?: IconPropType | undefined;
768
+ readonly nativeType?: ButtonNativeType | undefined;
769
+ readonly loading?: boolean | undefined;
770
+ readonly loadingIcon?: IconPropType | undefined;
771
+ readonly plain?: boolean | undefined;
772
+ readonly text?: boolean | undefined;
773
+ readonly link?: boolean | undefined;
774
+ readonly bg?: boolean | undefined;
775
+ readonly autofocus?: boolean | undefined;
776
+ readonly round?: boolean | undefined;
777
+ readonly circle?: boolean | undefined;
778
+ readonly dashed?: boolean | undefined;
779
+ readonly color?: string | undefined;
780
+ readonly dark?: boolean | undefined;
781
+ readonly autoInsertSpace?: boolean | undefined;
782
+ readonly tag?: (string | Component) | undefined;
783
+ readonly onClick?: ((evt: MouseEvent) => any) | undefined | undefined;
784
+ } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
785
+ $attrs: Attrs;
786
+ $refs: {
787
+ [x: string]: unknown;
788
+ };
789
+ $slots: Readonly<{
790
+ [name: string]: Slot<any> | undefined;
791
+ }>;
792
+ $root: ComponentPublicInstance | null;
793
+ $parent: ComponentPublicInstance | null;
794
+ $host: Element | null;
795
+ $emit: (event: "click", evt: MouseEvent) => void;
796
+ $el: any;
797
+ $options: ComponentOptionsBase<Readonly< ButtonProps> & Readonly<{
798
+ onClick?: ((evt: MouseEvent) => any) | undefined;
799
+ }>, {
800
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
801
+ size: ComputedRef<"" | "default" | "large" | "small">;
802
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
803
+ disabled: ComputedRef<boolean>;
804
+ shouldAddSpace: ComputedRef<boolean>;
805
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
806
+ click: (evt: MouseEvent) => void;
807
+ }, string, {
808
+ type: ButtonType;
809
+ disabled: boolean;
810
+ text: boolean;
811
+ round: boolean;
812
+ dashed: boolean;
813
+ plain: boolean;
814
+ nativeType: ButtonNativeType;
815
+ loadingIcon: IconPropType;
816
+ autoInsertSpace: boolean;
817
+ tag: string | Component;
818
+ }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
819
+ beforeCreate?: (() => void) | (() => void)[];
820
+ created?: (() => void) | (() => void)[];
821
+ beforeMount?: (() => void) | (() => void)[];
822
+ mounted?: (() => void) | (() => void)[];
823
+ beforeUpdate?: (() => void) | (() => void)[];
824
+ updated?: (() => void) | (() => void)[];
825
+ activated?: (() => void) | (() => void)[];
826
+ deactivated?: (() => void) | (() => void)[];
827
+ beforeDestroy?: (() => void) | (() => void)[];
828
+ beforeUnmount?: (() => void) | (() => void)[];
829
+ destroyed?: (() => void) | (() => void)[];
830
+ unmounted?: (() => void) | (() => void)[];
831
+ renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
832
+ renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
833
+ errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
834
+ };
835
+ $forceUpdate: () => void;
836
+ $nextTick: typeof nextTick;
837
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
838
+ } & Readonly<{
839
+ type: ButtonType;
840
+ disabled: boolean;
841
+ text: boolean;
842
+ round: boolean;
843
+ dashed: boolean;
844
+ plain: boolean;
845
+ nativeType: ButtonNativeType;
846
+ loadingIcon: IconPropType;
847
+ autoInsertSpace: boolean;
848
+ tag: string | Component;
849
+ }> & Omit<Readonly< ButtonProps> & Readonly<{
850
+ onClick?: ((evt: MouseEvent) => any) | undefined;
851
+ }>, "type" | "text" | "ref" | "size" | "round" | "disabled" | "nativeType" | "loadingIcon" | "plain" | "dashed" | "autoInsertSpace" | "tag" | "shouldAddSpace"> & ShallowUnwrapRef<{
852
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
853
+ size: ComputedRef<"" | "default" | "large" | "small">;
854
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
855
+ disabled: ComputedRef<boolean>;
856
+ shouldAddSpace: ComputedRef<boolean>;
857
+ }> & {} & ComponentCustomProperties & {} & {
858
+ $slots: {
859
+ loading?: (props: {}) => any;
860
+ } & {
861
+ icon?: (props: {}) => any;
862
+ } & {
863
+ default?: (props: {}) => any;
864
+ };
865
+ }) | null, ({
866
+ $: ComponentInternalInstance;
867
+ $data: {};
868
+ $props: {
869
+ readonly size?: ComponentSize | undefined;
870
+ readonly disabled?: boolean | undefined;
871
+ readonly type?: ButtonType | undefined;
872
+ readonly icon?: IconPropType | undefined;
873
+ readonly nativeType?: ButtonNativeType | undefined;
874
+ readonly loading?: boolean | undefined;
875
+ readonly loadingIcon?: IconPropType | undefined;
876
+ readonly plain?: boolean | undefined;
877
+ readonly text?: boolean | undefined;
878
+ readonly link?: boolean | undefined;
879
+ readonly bg?: boolean | undefined;
880
+ readonly autofocus?: boolean | undefined;
881
+ readonly round?: boolean | undefined;
882
+ readonly circle?: boolean | undefined;
883
+ readonly dashed?: boolean | undefined;
884
+ readonly color?: string | undefined;
885
+ readonly dark?: boolean | undefined;
886
+ readonly autoInsertSpace?: boolean | undefined;
887
+ readonly tag?: (string | Component) | undefined;
888
+ readonly onClick?: ((evt: MouseEvent) => any) | undefined | undefined;
889
+ } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
890
+ $attrs: Attrs;
891
+ $refs: {
892
+ [x: string]: unknown;
893
+ };
894
+ $slots: Readonly<{
895
+ [name: string]: Slot<any> | undefined;
896
+ }>;
897
+ $root: ComponentPublicInstance | null;
898
+ $parent: ComponentPublicInstance | null;
899
+ $host: Element | null;
900
+ $emit: (event: "click", evt: MouseEvent) => void;
901
+ $el: any;
902
+ $options: ComponentOptionsBase<Readonly< ButtonProps> & Readonly<{
903
+ onClick?: ((evt: MouseEvent) => any) | undefined;
904
+ }>, {
905
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
906
+ size: ComputedRef<"" | "default" | "large" | "small">;
907
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
908
+ disabled: ComputedRef<boolean>;
909
+ shouldAddSpace: ComputedRef<boolean>;
910
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
911
+ click: (evt: MouseEvent) => void;
912
+ }, string, {
913
+ type: ButtonType;
914
+ disabled: boolean;
915
+ text: boolean;
916
+ round: boolean;
917
+ dashed: boolean;
918
+ plain: boolean;
919
+ nativeType: ButtonNativeType;
920
+ loadingIcon: IconPropType;
921
+ autoInsertSpace: boolean;
922
+ tag: string | Component;
923
+ }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
924
+ beforeCreate?: (() => void) | (() => void)[];
925
+ created?: (() => void) | (() => void)[];
926
+ beforeMount?: (() => void) | (() => void)[];
927
+ mounted?: (() => void) | (() => void)[];
928
+ beforeUpdate?: (() => void) | (() => void)[];
929
+ updated?: (() => void) | (() => void)[];
930
+ activated?: (() => void) | (() => void)[];
931
+ deactivated?: (() => void) | (() => void)[];
932
+ beforeDestroy?: (() => void) | (() => void)[];
933
+ beforeUnmount?: (() => void) | (() => void)[];
934
+ destroyed?: (() => void) | (() => void)[];
935
+ unmounted?: (() => void) | (() => void)[];
936
+ renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
937
+ renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
938
+ errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
939
+ };
940
+ $forceUpdate: () => void;
941
+ $nextTick: typeof nextTick;
942
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
943
+ } & Readonly<{
944
+ type: ButtonType;
945
+ disabled: boolean;
946
+ text: boolean;
947
+ round: boolean;
948
+ dashed: boolean;
949
+ plain: boolean;
950
+ nativeType: ButtonNativeType;
951
+ loadingIcon: IconPropType;
952
+ autoInsertSpace: boolean;
953
+ tag: string | Component;
954
+ }> & Omit<Readonly< ButtonProps> & Readonly<{
955
+ onClick?: ((evt: MouseEvent) => any) | undefined;
956
+ }>, "type" | "text" | "ref" | "size" | "round" | "disabled" | "nativeType" | "loadingIcon" | "plain" | "dashed" | "autoInsertSpace" | "tag" | "shouldAddSpace"> & ShallowUnwrapRef<{
957
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
958
+ size: ComputedRef<"" | "default" | "large" | "small">;
959
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
960
+ disabled: ComputedRef<boolean>;
961
+ shouldAddSpace: ComputedRef<boolean>;
962
+ }> & {} & ComponentCustomProperties & {} & {
963
+ $slots: {
964
+ loading?: (props: {}) => any;
965
+ } & {
966
+ icon?: (props: {}) => any;
967
+ } & {
968
+ default?: (props: {}) => any;
969
+ };
970
+ }) | null>;
971
+ tooltipContent: ComputedRef<string>;
972
+ computedClass: ComputedRef<{
973
+ 'j-tw-btn': boolean;
974
+ 'j-tw-btn--large': boolean;
975
+ 'j-tw-btn--normal': boolean;
976
+ 'j-tw-btn--small': boolean;
977
+ 'j-tw-btn--button': boolean;
978
+ 'j-tw-btn--outline': boolean;
979
+ 'j-tw-btn--flat': boolean;
980
+ 'j-tw-btn--text': boolean;
981
+ }>;
982
+ computedStyle: ComputedRef<{
983
+ '--j-btn-color': string;
984
+ '--j-btn-color-1': string;
985
+ '--j-btn-color-2': string;
986
+ '--j-btn-color-3': string;
987
+ '--j-btn-color-4': string;
988
+ '--j-btn-color-5': string;
989
+ '--j-btn-color-6': string;
990
+ }>;
991
+ mergedTooltipConfig: ComputedRef<{
992
+ placement: "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end";
993
+ effect: "dark" | "light";
994
+ trigger: "hover" | "click" | "focus" | "contextmenu";
995
+ showArrow: boolean;
996
+ openDelay: number;
997
+ closeDelay: number;
998
+ offset: number;
999
+ }>;
1000
+ handleClick: (e: MouseEvent) => void;
1001
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1002
+ click: (_e: MouseEvent) => true;
1003
+ }, string, PublicProps, Readonly< ExtractPropTypes<{
1004
+ size: {
1005
+ type: PropType<JTWBtnSizeType>;
1006
+ default: "normal";
1007
+ validator: (value: JTWBtnSizeType) => boolean;
1008
+ };
1009
+ type: {
1010
+ type: PropType<JTWBtnTypeType>;
1011
+ default: "button";
1012
+ validator: (value: JTWBtnTypeType) => boolean;
1013
+ };
1014
+ color: {
1015
+ type: StringConstructor;
1016
+ default: string;
1017
+ };
1018
+ outline: {
1019
+ type: BooleanConstructor;
1020
+ default: boolean;
1021
+ };
1022
+ flat: {
1023
+ type: BooleanConstructor;
1024
+ default: boolean;
1025
+ };
1026
+ label: {
1027
+ type: StringConstructor;
1028
+ default: string;
1029
+ };
1030
+ loading: {
1031
+ type: BooleanConstructor;
1032
+ default: boolean;
1033
+ };
1034
+ tips: {
1035
+ type: (NumberConstructor | StringConstructor)[];
1036
+ default: string;
1037
+ };
1038
+ tooltipConfig: {
1039
+ type: PropType<JTWBtnTooltipConfig>;
1040
+ default: undefined;
1041
+ };
1042
+ }>> & Readonly<{
1043
+ onClick?: ((_e: MouseEvent) => any) | undefined;
1044
+ }>, {
1045
+ type: JTWBtnTypeType;
1046
+ flat: boolean;
1047
+ label: string;
1048
+ size: JTWBtnSizeType;
1049
+ color: string;
1050
+ loading: boolean;
1051
+ outline: boolean;
1052
+ tips: string | number;
1053
+ tooltipConfig: JTWBtnTooltipConfig;
1054
+ }, {}, {
1055
+ ElButton: {
1056
+ new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ButtonProps> & Readonly<{
1057
+ onClick?: ((evt: MouseEvent) => any) | undefined;
1058
+ }>, {
1059
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
1060
+ size: ComputedRef<"" | "default" | "large" | "small">;
1061
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
1062
+ disabled: ComputedRef<boolean>;
1063
+ shouldAddSpace: ComputedRef<boolean>;
1064
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1065
+ click: (evt: MouseEvent) => void;
1066
+ }, PublicProps, {
1067
+ type: ButtonType;
1068
+ disabled: boolean;
1069
+ text: boolean;
1070
+ round: boolean;
1071
+ dashed: boolean;
1072
+ plain: boolean;
1073
+ nativeType: ButtonNativeType;
1074
+ loadingIcon: IconPropType;
1075
+ autoInsertSpace: boolean;
1076
+ tag: string | Component;
1077
+ }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
1078
+ P: {};
1079
+ B: {};
1080
+ D: {};
1081
+ C: {};
1082
+ M: {};
1083
+ Defaults: {};
1084
+ }, Readonly< ButtonProps> & Readonly<{
1085
+ onClick?: ((evt: MouseEvent) => any) | undefined;
1086
+ }>, {
1087
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
1088
+ size: ComputedRef<"" | "default" | "large" | "small">;
1089
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
1090
+ disabled: ComputedRef<boolean>;
1091
+ shouldAddSpace: ComputedRef<boolean>;
1092
+ }, {}, {}, {}, {
1093
+ type: ButtonType;
1094
+ disabled: boolean;
1095
+ text: boolean;
1096
+ round: boolean;
1097
+ dashed: boolean;
1098
+ plain: boolean;
1099
+ nativeType: ButtonNativeType;
1100
+ loadingIcon: IconPropType;
1101
+ autoInsertSpace: boolean;
1102
+ tag: string | Component;
1103
+ }>;
1104
+ __isFragment?: never;
1105
+ __isTeleport?: never;
1106
+ __isSuspense?: never;
1107
+ } & ComponentOptionsBase<Readonly< ButtonProps> & Readonly<{
1108
+ onClick?: ((evt: MouseEvent) => any) | undefined;
1109
+ }>, {
1110
+ ref: Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
1111
+ size: ComputedRef<"" | "default" | "large" | "small">;
1112
+ type: ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
1113
+ disabled: ComputedRef<boolean>;
1114
+ shouldAddSpace: ComputedRef<boolean>;
1115
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1116
+ click: (evt: MouseEvent) => void;
1117
+ }, string, {
1118
+ type: ButtonType;
1119
+ disabled: boolean;
1120
+ text: boolean;
1121
+ round: boolean;
1122
+ dashed: boolean;
1123
+ plain: boolean;
1124
+ nativeType: ButtonNativeType;
1125
+ loadingIcon: IconPropType;
1126
+ autoInsertSpace: boolean;
1127
+ tag: string | Component;
1128
+ }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
1129
+ $slots: {
1130
+ loading?: (props: {}) => any;
1131
+ } & {
1132
+ icon?: (props: {}) => any;
1133
+ } & {
1134
+ default?: (props: {}) => any;
1135
+ };
1136
+ }) & ObjectPlugin & {
1137
+ setPropsDefaults: (defaults: Partial<{
1138
+ readonly size?: ComponentSize | undefined;
1139
+ readonly disabled?: boolean | undefined;
1140
+ readonly type?: ButtonType | undefined;
1141
+ readonly icon?: IconPropType | undefined;
1142
+ readonly nativeType?: ButtonNativeType | undefined;
1143
+ readonly loading?: boolean | undefined;
1144
+ readonly loadingIcon?: IconPropType | undefined;
1145
+ readonly plain?: boolean | undefined;
1146
+ readonly text?: boolean | undefined;
1147
+ readonly link?: boolean | undefined;
1148
+ readonly bg?: boolean | undefined;
1149
+ readonly autofocus?: boolean | undefined;
1150
+ readonly round?: boolean | undefined;
1151
+ readonly circle?: boolean | undefined;
1152
+ readonly dashed?: boolean | undefined;
1153
+ readonly color?: string | undefined;
1154
+ readonly dark?: boolean | undefined;
1155
+ readonly autoInsertSpace?: boolean | undefined;
1156
+ readonly tag?: (string | Component) | undefined;
1157
+ readonly onClick?: ((evt: MouseEvent) => any) | undefined | undefined;
1158
+ } & VNodeProps & AllowedComponentProps & ComponentCustomProps>) => void;
1159
+ } & {
1160
+ ButtonGroup: {
1161
+ new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
1162
+ type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
1163
+ direction: "horizontal" | "vertical";
1164
+ }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
1165
+ P: {};
1166
+ B: {};
1167
+ D: {};
1168
+ C: {};
1169
+ M: {};
1170
+ Defaults: {};
1171
+ }, Readonly< ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
1172
+ type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
1173
+ direction: "horizontal" | "vertical";
1174
+ }>;
1175
+ __isFragment?: never;
1176
+ __isTeleport?: never;
1177
+ __isSuspense?: never;
1178
+ } & ComponentOptionsBase<Readonly< ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
1179
+ type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
1180
+ direction: "horizontal" | "vertical";
1181
+ }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
1182
+ $slots: {
1183
+ default?: (props: {}) => any;
1184
+ };
1185
+ });
1186
+ };
1187
+ ElTooltip: SFCWithInstall<{
1188
+ new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< UseTooltipProps> & Readonly<{
1189
+ onClose?: ((...args: any[]) => any) | undefined;
1190
+ "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
1191
+ "onBefore-show"?: ((...args: any[]) => any) | undefined;
1192
+ "onBefore-hide"?: ((...args: any[]) => any) | undefined;
1193
+ onShow?: ((...args: any[]) => any) | undefined;
1194
+ onHide?: ((...args: any[]) => any) | undefined;
1195
+ onOpen?: ((...args: any[]) => any) | undefined;
1196
+ }>, {
1197
+ popperRef: Ref< PopperInstance | undefined, PopperInstance | undefined>;
1198
+ contentRef: Ref< TooltipContentInstance | undefined, TooltipContentInstance | undefined>;
1199
+ isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
1200
+ updatePopper: () => void;
1201
+ onOpen: (event?: Event, delay?: number) => void;
1202
+ onClose: (event?: Event, delay?: number) => void;
1203
+ hide: (event?: Event) => void;
1204
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1205
+ close: (...args: any[]) => void;
1206
+ "update:visible": (...args: any[]) => void;
1207
+ "before-show": (...args: any[]) => void;
1208
+ "before-hide": (...args: any[]) => void;
1209
+ show: (...args: any[]) => void;
1210
+ hide: (...args: any[]) => void;
1211
+ open: (...args: any[]) => void;
1212
+ }, PublicProps, {
1213
+ effect: PopperEffect;
1214
+ placement: Placement;
1215
+ popperStyle: string | false | CSSProperties | StyleValue[] | null;
1216
+ teleported: boolean;
1217
+ visible: boolean | null;
1218
+ style: string | false | CSSProperties | StyleValue[] | null;
1219
+ enterable: boolean;
1220
+ pure: boolean;
1221
+ focusOnShow: boolean;
1222
+ trapping: boolean;
1223
+ stopPopperMouseEvent: boolean;
1224
+ virtualTriggering: boolean;
1225
+ loop: boolean;
1226
+ boundariesPadding: number;
1227
+ gpuAcceleration: boolean;
1228
+ offset: number;
1229
+ popperOptions: Partial< Options>;
1230
+ strategy: "absolute" | "fixed";
1231
+ arrowOffset: number;
1232
+ showArrow: boolean;
1233
+ role: "dialog" | "menu" | "tooltip" | "grid" | "group" | "listbox" | "navigation" | "tree";
1234
+ content: string;
1235
+ showAfter: number;
1236
+ hideAfter: number;
1237
+ autoClose: number;
1238
+ trigger: Arrayable<TooltipTriggerType>;
1239
+ triggerKeys: string[];
1240
+ }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
1241
+ P: {};
1242
+ B: {};
1243
+ D: {};
1244
+ C: {};
1245
+ M: {};
1246
+ Defaults: {};
1247
+ }, Readonly< UseTooltipProps> & Readonly<{
1248
+ onClose?: ((...args: any[]) => any) | undefined;
1249
+ "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
1250
+ "onBefore-show"?: ((...args: any[]) => any) | undefined;
1251
+ "onBefore-hide"?: ((...args: any[]) => any) | undefined;
1252
+ onShow?: ((...args: any[]) => any) | undefined;
1253
+ onHide?: ((...args: any[]) => any) | undefined;
1254
+ onOpen?: ((...args: any[]) => any) | undefined;
1255
+ }>, {
1256
+ popperRef: Ref< PopperInstance | undefined, PopperInstance | undefined>;
1257
+ contentRef: Ref< TooltipContentInstance | undefined, TooltipContentInstance | undefined>;
1258
+ isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
1259
+ updatePopper: () => void;
1260
+ onOpen: (event?: Event, delay?: number) => void;
1261
+ onClose: (event?: Event, delay?: number) => void;
1262
+ hide: (event?: Event) => void;
1263
+ }, {}, {}, {}, {
1264
+ effect: PopperEffect;
1265
+ placement: Placement;
1266
+ popperStyle: string | false | CSSProperties | StyleValue[] | null;
1267
+ teleported: boolean;
1268
+ visible: boolean | null;
1269
+ style: string | false | CSSProperties | StyleValue[] | null;
1270
+ enterable: boolean;
1271
+ pure: boolean;
1272
+ focusOnShow: boolean;
1273
+ trapping: boolean;
1274
+ stopPopperMouseEvent: boolean;
1275
+ virtualTriggering: boolean;
1276
+ loop: boolean;
1277
+ boundariesPadding: number;
1278
+ gpuAcceleration: boolean;
1279
+ offset: number;
1280
+ popperOptions: Partial< Options>;
1281
+ strategy: "absolute" | "fixed";
1282
+ arrowOffset: number;
1283
+ showArrow: boolean;
1284
+ role: "dialog" | "menu" | "tooltip" | "grid" | "group" | "listbox" | "navigation" | "tree";
1285
+ content: string;
1286
+ showAfter: number;
1287
+ hideAfter: number;
1288
+ autoClose: number;
1289
+ trigger: Arrayable<TooltipTriggerType>;
1290
+ triggerKeys: string[];
1291
+ }>;
1292
+ __isFragment?: never;
1293
+ __isTeleport?: never;
1294
+ __isSuspense?: never;
1295
+ } & ComponentOptionsBase<Readonly< UseTooltipProps> & Readonly<{
1296
+ onClose?: ((...args: any[]) => any) | undefined;
1297
+ "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
1298
+ "onBefore-show"?: ((...args: any[]) => any) | undefined;
1299
+ "onBefore-hide"?: ((...args: any[]) => any) | undefined;
1300
+ onShow?: ((...args: any[]) => any) | undefined;
1301
+ onHide?: ((...args: any[]) => any) | undefined;
1302
+ onOpen?: ((...args: any[]) => any) | undefined;
1303
+ }>, {
1304
+ popperRef: Ref< PopperInstance | undefined, PopperInstance | undefined>;
1305
+ contentRef: Ref< TooltipContentInstance | undefined, TooltipContentInstance | undefined>;
1306
+ isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
1307
+ updatePopper: () => void;
1308
+ onOpen: (event?: Event, delay?: number) => void;
1309
+ onClose: (event?: Event, delay?: number) => void;
1310
+ hide: (event?: Event) => void;
1311
+ }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
1312
+ close: (...args: any[]) => void;
1313
+ "update:visible": (...args: any[]) => void;
1314
+ "before-show": (...args: any[]) => void;
1315
+ "before-hide": (...args: any[]) => void;
1316
+ show: (...args: any[]) => void;
1317
+ hide: (...args: any[]) => void;
1318
+ open: (...args: any[]) => void;
1319
+ }, string, {
1320
+ effect: PopperEffect;
1321
+ placement: Placement;
1322
+ popperStyle: string | false | CSSProperties | StyleValue[] | null;
1323
+ teleported: boolean;
1324
+ visible: boolean | null;
1325
+ style: string | false | CSSProperties | StyleValue[] | null;
1326
+ enterable: boolean;
1327
+ pure: boolean;
1328
+ focusOnShow: boolean;
1329
+ trapping: boolean;
1330
+ stopPopperMouseEvent: boolean;
1331
+ virtualTriggering: boolean;
1332
+ loop: boolean;
1333
+ boundariesPadding: number;
1334
+ gpuAcceleration: boolean;
1335
+ offset: number;
1336
+ popperOptions: Partial< Options>;
1337
+ strategy: "absolute" | "fixed";
1338
+ arrowOffset: number;
1339
+ showArrow: boolean;
1340
+ role: "dialog" | "menu" | "tooltip" | "grid" | "group" | "listbox" | "navigation" | "tree";
1341
+ content: string;
1342
+ showAfter: number;
1343
+ hideAfter: number;
1344
+ autoClose: number;
1345
+ trigger: Arrayable<TooltipTriggerType>;
1346
+ triggerKeys: string[];
1347
+ }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
1348
+ $slots: {
1349
+ default?: (props: {}) => any;
1350
+ } & {
1351
+ content?: (props: {}) => any;
1352
+ };
1353
+ })>;
1354
+ }, {}, string, ComponentProvideOptions, true, {}, any>;
1355
+ }, {}, string, ComponentProvideOptions, true, {}, any>;
1356
+ export default _default;