@destyler/dialog 0.0.6 → 0.0.7-beta.2

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.
@@ -1,453 +0,0 @@
1
- import { D as DialogRootContext } from './shared/dialog.f396ab6e.cjs';
2
- export { a as DialogClose, b as DialogCloseProps, c as DialogContent, g as DialogContentProps, h as DialogDescription, j as DialogDescriptionProps, k as DialogOverlay, l as DialogPortal, n as DialogPortalProps, o as DialogRoot, r as DialogRootProps, s as DialogTitle, u as DialogTitleProps, v as DialogTrigger, x as DialogTriggerProps, d as dialogCloseProps, f as dialogContentEmits, e as dialogContentProps, i as dialogDescriptionProps, m as dialogPortalProps, q as dialogRootEmits, p as dialogRootProps, t as dialogTitleProps, w as dialogTriggerProps } from './shared/dialog.f396ab6e.cjs';
3
- import * as _destyler_primitive from '@destyler/primitive';
4
- import * as vue from 'vue';
5
- import { PropType } from 'vue';
6
- import { ExtractPublicPropTypes } from '@destyler/shared';
7
-
8
- declare const dialogContentImplProps: {
9
- /**
10
- * Used to force mounting when more control is needed.
11
- * Useful when controlling animation with Vue animation libraries.
12
- *
13
- * @default false
14
- */
15
- readonly forceMount: {
16
- readonly type: PropType<boolean>;
17
- readonly required: false;
18
- };
19
- /**
20
- * When `true`, focus cannot escape the Content via keyboard,
21
- * pointer, or a programmatic focus.
22
- *
23
- * @default false
24
- */
25
- readonly trapFocus: {
26
- readonly type: PropType<boolean>;
27
- readonly required: false;
28
- readonly default: false;
29
- };
30
- readonly disableOutsidePointerEvents: {
31
- readonly type: PropType<boolean>;
32
- readonly required: false;
33
- readonly default: false;
34
- };
35
- readonly isDismissable: {
36
- readonly type: PropType<boolean>;
37
- readonly required: false;
38
- readonly default: true;
39
- };
40
- readonly as: {
41
- readonly type: PropType<vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions, {}, any> | _destyler_primitive.AsTag>;
42
- readonly required: false;
43
- readonly default: "div";
44
- };
45
- readonly asChild: {
46
- readonly type: PropType<boolean>;
47
- readonly required: false;
48
- readonly default: false;
49
- };
50
- };
51
- declare const dialogContentImplEmtis: {
52
- /**
53
- * Event handler called when auto-focusing on open. Can be prevented.
54
- */
55
- openAutoFocus: (_event: Event) => boolean;
56
- /**
57
- * Event handler called when the a `pointerdown` event happens
58
- * outside of the `DismissableLayer`. Can be prevented.
59
- */
60
- closeAutoFocus: (_event: Event) => boolean;
61
- escapeKeyDown: (_event: KeyboardEvent) => boolean;
62
- pointerDownOutside: (_event: CustomEvent<{
63
- originalEvent: PointerEvent;
64
- }>) => boolean;
65
- focusOutside: (_event: CustomEvent<{
66
- originalEvent: FocusEvent;
67
- }>) => boolean;
68
- interactOutside: (_event: CustomEvent<{
69
- originalEvent: PointerEvent;
70
- }> | CustomEvent<{
71
- originalEvent: FocusEvent;
72
- }>) => boolean;
73
- };
74
- declare const DialogContentImpl: vue.DefineComponent<{
75
- /**
76
- * Used to force mounting when more control is needed.
77
- * Useful when controlling animation with Vue animation libraries.
78
- *
79
- * @default false
80
- */
81
- readonly forceMount: {
82
- readonly type: PropType<boolean>;
83
- readonly required: false;
84
- };
85
- /**
86
- * When `true`, focus cannot escape the Content via keyboard,
87
- * pointer, or a programmatic focus.
88
- *
89
- * @default false
90
- */
91
- readonly trapFocus: {
92
- readonly type: PropType<boolean>;
93
- readonly required: false;
94
- readonly default: false;
95
- };
96
- readonly disableOutsidePointerEvents: {
97
- readonly type: PropType<boolean>;
98
- readonly required: false;
99
- readonly default: false;
100
- };
101
- readonly isDismissable: {
102
- readonly type: PropType<boolean>;
103
- readonly required: false;
104
- readonly default: true;
105
- };
106
- readonly as: {
107
- readonly type: PropType<vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions, {}, any> | _destyler_primitive.AsTag>;
108
- readonly required: false;
109
- readonly default: "div";
110
- };
111
- readonly asChild: {
112
- readonly type: PropType<boolean>;
113
- readonly required: false;
114
- readonly default: false;
115
- };
116
- }, {
117
- rootContext: DialogRootContext;
118
- forwardRef: (ref: Element | vue.ComponentPublicInstance | null) => void;
119
- }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
120
- /**
121
- * Event handler called when auto-focusing on open. Can be prevented.
122
- */
123
- openAutoFocus: (_event: Event) => boolean;
124
- /**
125
- * Event handler called when the a `pointerdown` event happens
126
- * outside of the `DismissableLayer`. Can be prevented.
127
- */
128
- closeAutoFocus: (_event: Event) => boolean;
129
- escapeKeyDown: (_event: KeyboardEvent) => boolean;
130
- pointerDownOutside: (_event: CustomEvent<{
131
- originalEvent: PointerEvent;
132
- }>) => boolean;
133
- focusOutside: (_event: CustomEvent<{
134
- originalEvent: FocusEvent;
135
- }>) => boolean;
136
- interactOutside: (_event: CustomEvent<{
137
- originalEvent: PointerEvent;
138
- }> | CustomEvent<{
139
- originalEvent: FocusEvent;
140
- }>) => boolean;
141
- }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
142
- /**
143
- * Used to force mounting when more control is needed.
144
- * Useful when controlling animation with Vue animation libraries.
145
- *
146
- * @default false
147
- */
148
- readonly forceMount: {
149
- readonly type: PropType<boolean>;
150
- readonly required: false;
151
- };
152
- /**
153
- * When `true`, focus cannot escape the Content via keyboard,
154
- * pointer, or a programmatic focus.
155
- *
156
- * @default false
157
- */
158
- readonly trapFocus: {
159
- readonly type: PropType<boolean>;
160
- readonly required: false;
161
- readonly default: false;
162
- };
163
- readonly disableOutsidePointerEvents: {
164
- readonly type: PropType<boolean>;
165
- readonly required: false;
166
- readonly default: false;
167
- };
168
- readonly isDismissable: {
169
- readonly type: PropType<boolean>;
170
- readonly required: false;
171
- readonly default: true;
172
- };
173
- readonly as: {
174
- readonly type: PropType<vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions, {}, any> | _destyler_primitive.AsTag>;
175
- readonly required: false;
176
- readonly default: "div";
177
- };
178
- readonly asChild: {
179
- readonly type: PropType<boolean>;
180
- readonly required: false;
181
- readonly default: false;
182
- };
183
- }>> & {
184
- onOpenAutoFocus?: ((_event: Event) => any) | undefined;
185
- onCloseAutoFocus?: ((_event: Event) => any) | undefined;
186
- onEscapeKeyDown?: ((_event: KeyboardEvent) => any) | undefined;
187
- onPointerDownOutside?: ((_event: CustomEvent<{
188
- originalEvent: PointerEvent;
189
- }>) => any) | undefined;
190
- onFocusOutside?: ((_event: CustomEvent<{
191
- originalEvent: FocusEvent;
192
- }>) => any) | undefined;
193
- onInteractOutside?: ((_event: CustomEvent<{
194
- originalEvent: PointerEvent;
195
- }> | CustomEvent<{
196
- originalEvent: FocusEvent;
197
- }>) => any) | undefined;
198
- }, {
199
- readonly as: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions, {}, any> | _destyler_primitive.AsTag;
200
- readonly asChild: boolean;
201
- readonly trapFocus: boolean;
202
- readonly disableOutsidePointerEvents: boolean;
203
- readonly isDismissable: boolean;
204
- }, {}>;
205
-
206
- declare const DialogContentModal: vue.DefineComponent<{
207
- readonly forceMount: {
208
- readonly type: vue.PropType<boolean>;
209
- readonly required: false;
210
- };
211
- readonly trapFocus: {
212
- readonly type: vue.PropType<boolean>;
213
- readonly required: false;
214
- readonly default: false;
215
- };
216
- readonly disableOutsidePointerEvents: {
217
- readonly type: vue.PropType<boolean>;
218
- readonly required: false;
219
- readonly default: false;
220
- };
221
- readonly isDismissable: {
222
- readonly type: vue.PropType<boolean>;
223
- readonly required: false;
224
- readonly default: true;
225
- };
226
- readonly as: {
227
- readonly type: vue.PropType<vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions, {}, any> | _destyler_primitive.AsTag>;
228
- readonly required: false;
229
- readonly default: "div";
230
- };
231
- readonly asChild: {
232
- readonly type: vue.PropType<boolean>;
233
- readonly required: false;
234
- readonly default: false;
235
- };
236
- }, {
237
- rootContext: DialogRootContext;
238
- emitsAsProps: Record<string, any>;
239
- forwardRef: (ref: Element | vue.ComponentPublicInstance | null) => void;
240
- }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
241
- openAutoFocus: (_event: Event) => boolean;
242
- closeAutoFocus: (_event: Event) => boolean;
243
- escapeKeyDown: (_event: KeyboardEvent) => boolean;
244
- pointerDownOutside: (_event: CustomEvent<{
245
- originalEvent: PointerEvent;
246
- }>) => boolean;
247
- focusOutside: (_event: CustomEvent<{
248
- originalEvent: FocusEvent;
249
- }>) => boolean;
250
- interactOutside: (_event: CustomEvent<{
251
- originalEvent: PointerEvent;
252
- }> | CustomEvent<{
253
- originalEvent: FocusEvent;
254
- }>) => boolean;
255
- }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
256
- readonly forceMount: {
257
- readonly type: vue.PropType<boolean>;
258
- readonly required: false;
259
- };
260
- readonly trapFocus: {
261
- readonly type: vue.PropType<boolean>;
262
- readonly required: false;
263
- readonly default: false;
264
- };
265
- readonly disableOutsidePointerEvents: {
266
- readonly type: vue.PropType<boolean>;
267
- readonly required: false;
268
- readonly default: false;
269
- };
270
- readonly isDismissable: {
271
- readonly type: vue.PropType<boolean>;
272
- readonly required: false;
273
- readonly default: true;
274
- };
275
- readonly as: {
276
- readonly type: vue.PropType<vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions, {}, any> | _destyler_primitive.AsTag>;
277
- readonly required: false;
278
- readonly default: "div";
279
- };
280
- readonly asChild: {
281
- readonly type: vue.PropType<boolean>;
282
- readonly required: false;
283
- readonly default: false;
284
- };
285
- }>> & {
286
- onOpenAutoFocus?: ((_event: Event) => any) | undefined;
287
- onCloseAutoFocus?: ((_event: Event) => any) | undefined;
288
- onEscapeKeyDown?: ((_event: KeyboardEvent) => any) | undefined;
289
- onPointerDownOutside?: ((_event: CustomEvent<{
290
- originalEvent: PointerEvent;
291
- }>) => any) | undefined;
292
- onFocusOutside?: ((_event: CustomEvent<{
293
- originalEvent: FocusEvent;
294
- }>) => any) | undefined;
295
- onInteractOutside?: ((_event: CustomEvent<{
296
- originalEvent: PointerEvent;
297
- }> | CustomEvent<{
298
- originalEvent: FocusEvent;
299
- }>) => any) | undefined;
300
- }, {
301
- readonly as: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions, {}, any> | _destyler_primitive.AsTag;
302
- readonly asChild: boolean;
303
- readonly trapFocus: boolean;
304
- readonly disableOutsidePointerEvents: boolean;
305
- readonly isDismissable: boolean;
306
- }, {}>;
307
-
308
- declare const DialogContentNonModal: vue.DefineComponent<{
309
- readonly forceMount: {
310
- readonly type: vue.PropType<boolean>;
311
- readonly required: false;
312
- };
313
- readonly trapFocus: {
314
- readonly type: vue.PropType<boolean>;
315
- readonly required: false;
316
- readonly default: false;
317
- };
318
- readonly disableOutsidePointerEvents: {
319
- readonly type: vue.PropType<boolean>;
320
- readonly required: false;
321
- readonly default: false;
322
- };
323
- readonly isDismissable: {
324
- readonly type: vue.PropType<boolean>;
325
- readonly required: false;
326
- readonly default: true;
327
- };
328
- readonly as: {
329
- readonly type: vue.PropType<vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions, {}, any> | _destyler_primitive.AsTag>;
330
- readonly required: false;
331
- readonly default: "div";
332
- };
333
- readonly asChild: {
334
- readonly type: vue.PropType<boolean>;
335
- readonly required: false;
336
- readonly default: false;
337
- };
338
- }, {
339
- rootContext: DialogRootContext;
340
- hasInteractedOutsideRef: vue.Ref<boolean>;
341
- hasPointerDownOutsideRef: vue.Ref<boolean>;
342
- emitsAsProps: Record<string, any>;
343
- }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
344
- openAutoFocus: (_event: Event) => boolean;
345
- closeAutoFocus: (_event: Event) => boolean;
346
- escapeKeyDown: (_event: KeyboardEvent) => boolean;
347
- pointerDownOutside: (_event: CustomEvent<{
348
- originalEvent: PointerEvent;
349
- }>) => boolean;
350
- focusOutside: (_event: CustomEvent<{
351
- originalEvent: FocusEvent;
352
- }>) => boolean;
353
- interactOutside: (_event: CustomEvent<{
354
- originalEvent: PointerEvent;
355
- }> | CustomEvent<{
356
- originalEvent: FocusEvent;
357
- }>) => boolean;
358
- }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
359
- readonly forceMount: {
360
- readonly type: vue.PropType<boolean>;
361
- readonly required: false;
362
- };
363
- readonly trapFocus: {
364
- readonly type: vue.PropType<boolean>;
365
- readonly required: false;
366
- readonly default: false;
367
- };
368
- readonly disableOutsidePointerEvents: {
369
- readonly type: vue.PropType<boolean>;
370
- readonly required: false;
371
- readonly default: false;
372
- };
373
- readonly isDismissable: {
374
- readonly type: vue.PropType<boolean>;
375
- readonly required: false;
376
- readonly default: true;
377
- };
378
- readonly as: {
379
- readonly type: vue.PropType<vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions, {}, any> | _destyler_primitive.AsTag>;
380
- readonly required: false;
381
- readonly default: "div";
382
- };
383
- readonly asChild: {
384
- readonly type: vue.PropType<boolean>;
385
- readonly required: false;
386
- readonly default: false;
387
- };
388
- }>> & {
389
- onOpenAutoFocus?: ((_event: Event) => any) | undefined;
390
- onCloseAutoFocus?: ((_event: Event) => any) | undefined;
391
- onEscapeKeyDown?: ((_event: KeyboardEvent) => any) | undefined;
392
- onPointerDownOutside?: ((_event: CustomEvent<{
393
- originalEvent: PointerEvent;
394
- }>) => any) | undefined;
395
- onFocusOutside?: ((_event: CustomEvent<{
396
- originalEvent: FocusEvent;
397
- }>) => any) | undefined;
398
- onInteractOutside?: ((_event: CustomEvent<{
399
- originalEvent: PointerEvent;
400
- }> | CustomEvent<{
401
- originalEvent: FocusEvent;
402
- }>) => any) | undefined;
403
- }, {
404
- readonly as: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions, {}, any> | _destyler_primitive.AsTag;
405
- readonly asChild: boolean;
406
- readonly trapFocus: boolean;
407
- readonly disableOutsidePointerEvents: boolean;
408
- readonly isDismissable: boolean;
409
- }, {}>;
410
-
411
- declare const dialogOverlayImplProps: {
412
- readonly as: {
413
- readonly type: vue.PropType<_destyler_primitive.AsTag | vue.Component>;
414
- readonly required: false;
415
- readonly default: "div";
416
- };
417
- readonly asChild: {
418
- readonly type: vue.PropType<boolean>;
419
- readonly required: false;
420
- readonly default: false;
421
- };
422
- };
423
- type DialogOverlayImplProps = ExtractPublicPropTypes<typeof dialogOverlayImplProps>;
424
- declare const DialogOverlayImpl: vue.DefineComponent<{
425
- readonly as: {
426
- readonly type: vue.PropType<_destyler_primitive.AsTag | vue.Component>;
427
- readonly required: false;
428
- readonly default: "div";
429
- };
430
- readonly asChild: {
431
- readonly type: vue.PropType<boolean>;
432
- readonly required: false;
433
- readonly default: false;
434
- };
435
- }, {
436
- rootContext: DialogRootContext;
437
- }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
438
- readonly as: {
439
- readonly type: vue.PropType<_destyler_primitive.AsTag | vue.Component>;
440
- readonly required: false;
441
- readonly default: "div";
442
- };
443
- readonly asChild: {
444
- readonly type: vue.PropType<boolean>;
445
- readonly required: false;
446
- readonly default: false;
447
- };
448
- }>>, {
449
- readonly as: _destyler_primitive.AsTag | vue.Component;
450
- readonly asChild: boolean;
451
- }, {}>;
452
-
453
- export { DialogContentImpl, DialogContentModal, DialogContentNonModal, DialogOverlayImpl, type DialogOverlayImplProps, dialogContentImplEmtis, dialogContentImplProps, dialogOverlayImplProps };