foldkit-mixins-ui 0.1.0

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.
package/dist/index.mjs ADDED
@@ -0,0 +1,623 @@
1
+ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
2
+ import { Attr, Capability, Event, Slot, SlotView, Slots } from "foldkit-mixins";
3
+ //#region src/resolve.ts
4
+ const resolveFor = (slots, mixins, context) => (base) => {
5
+ const builders = SlotView.buildersFor(slots, mixins, context);
6
+ const out = Object.assign(Object.create(null), base);
7
+ for (const name of Object.getOwnPropertyNames(slots)) out[name] = builders[name].attrs(base[name]);
8
+ return out;
9
+ };
10
+ //#endregion
11
+ //#region src/button.ts
12
+ var button_exports = /* @__PURE__ */ __exportAll({
13
+ ButtonSlots: () => ButtonSlots,
14
+ resolve: () => resolve$14
15
+ });
16
+ /**
17
+ * The button publishes one slot. `click` is owned by the base `OnClick` when
18
+ * the button is interactive, so a Behavior that adds its own click handler is a
19
+ * conflict rather than a second silent owner.
20
+ */
21
+ const ButtonSlots = Slots.define({ button: Slot.make({
22
+ capability: Capability.Interactive,
23
+ events: [Event.Click],
24
+ attributes: [
25
+ Attr.Role,
26
+ Attr.AriaDisabled,
27
+ Attr.Disabled
28
+ ]
29
+ }) });
30
+ const resolve$14 = (attributes, mixins, context) => resolveFor(ButtonSlots, mixins, context)(attributes);
31
+ //#endregion
32
+ //#region src/calendar.ts
33
+ var calendar_exports = /* @__PURE__ */ __exportAll({
34
+ CalendarSlots: () => CalendarSlots,
35
+ resolve: () => resolve$13
36
+ });
37
+ /**
38
+ * Calendar is a nested Submodel whose shape depends on `model.viewMode`. The
39
+ * top-level groups (`root`, `grid`, the navigation buttons) and per-item groups
40
+ * (`columnHeaders[]`, `weeks[].attributes`, the day/month/year cells and their
41
+ * buttons) are each resolved with `SlotView.buildersFor`, so a contribution to
42
+ * a cell slot applies to every cell while each cell's base keeps its own event
43
+ * ownership (a disabled day omits `OnClick`).
44
+ */
45
+ const CalendarSlots = Slots.define({
46
+ root: Slot.make({ capability: Capability.Container }),
47
+ previousMonthButton: Slot.make({
48
+ capability: Capability.Interactive,
49
+ events: [Event.Click],
50
+ attributes: [
51
+ Attr.Role,
52
+ Attr.Disabled,
53
+ Attr.AriaDisabled
54
+ ]
55
+ }),
56
+ nextMonthButton: Slot.make({
57
+ capability: Capability.Interactive,
58
+ events: [Event.Click],
59
+ attributes: [
60
+ Attr.Role,
61
+ Attr.Disabled,
62
+ Attr.AriaDisabled
63
+ ]
64
+ }),
65
+ headingButton: Slot.make({
66
+ capability: Capability.Interactive,
67
+ events: [Event.Click],
68
+ attributes: [Attr.Role]
69
+ }),
70
+ previousPageButton: Slot.make({
71
+ capability: Capability.Interactive,
72
+ events: [Event.Click],
73
+ attributes: [
74
+ Attr.Role,
75
+ Attr.Disabled,
76
+ Attr.AriaDisabled
77
+ ]
78
+ }),
79
+ nextPageButton: Slot.make({
80
+ capability: Capability.Interactive,
81
+ events: [Event.Click],
82
+ attributes: [
83
+ Attr.Role,
84
+ Attr.Disabled,
85
+ Attr.AriaDisabled
86
+ ]
87
+ }),
88
+ grid: Slot.make({
89
+ capability: Capability.Container,
90
+ events: [Event.Focus, Event.Blur],
91
+ attributes: [Attr.Role]
92
+ }),
93
+ headerRow: Slot.make({
94
+ capability: Capability.Container,
95
+ attributes: [Attr.Role]
96
+ }),
97
+ columnHeader: Slot.make({
98
+ capability: Capability.Container,
99
+ attributes: [Attr.Role]
100
+ }),
101
+ weekRow: Slot.make({
102
+ capability: Capability.Container,
103
+ attributes: [Attr.Role]
104
+ }),
105
+ dayCell: Slot.make({
106
+ capability: Capability.Container,
107
+ attributes: [Attr.Role]
108
+ }),
109
+ dayButton: Slot.make({
110
+ capability: Capability.Interactive,
111
+ events: [Event.Click],
112
+ attributes: [
113
+ Attr.Role,
114
+ Attr.Disabled,
115
+ Attr.AriaDisabled
116
+ ]
117
+ }),
118
+ monthCell: Slot.make({
119
+ capability: Capability.Container,
120
+ attributes: [Attr.Role]
121
+ }),
122
+ monthButton: Slot.make({
123
+ capability: Capability.Interactive,
124
+ events: [Event.Click],
125
+ attributes: [
126
+ Attr.Role,
127
+ Attr.Disabled,
128
+ Attr.AriaDisabled
129
+ ]
130
+ }),
131
+ yearCell: Slot.make({
132
+ capability: Capability.Container,
133
+ attributes: [Attr.Role]
134
+ }),
135
+ yearButton: Slot.make({
136
+ capability: Capability.Interactive,
137
+ events: [Event.Click],
138
+ attributes: [
139
+ Attr.Role,
140
+ Attr.Disabled,
141
+ Attr.AriaDisabled
142
+ ]
143
+ })
144
+ });
145
+ /** Resolves every mode's nested groups, preserving the `_tag` and heading data. */
146
+ const resolve$13 = (render, mixins, context) => {
147
+ const builders = SlotView.buildersFor(CalendarSlots, mixins, context);
148
+ const root = builders.root.attrs(render.root);
149
+ const grid = builders.grid.attrs(render.grid);
150
+ switch (render._tag) {
151
+ case "Days": return {
152
+ _tag: "Days",
153
+ root,
154
+ grid,
155
+ heading: render.heading,
156
+ previousMonthButton: builders.previousMonthButton.attrs(render.previousMonthButton),
157
+ nextMonthButton: builders.nextMonthButton.attrs(render.nextMonthButton),
158
+ headingButton: builders.headingButton.attrs(render.headingButton),
159
+ headerRow: builders.headerRow.attrs(render.headerRow),
160
+ columnHeaders: render.columnHeaders.map((column) => ({
161
+ ...column,
162
+ attributes: builders.columnHeader.attrs(column.attributes)
163
+ })),
164
+ weeks: render.weeks.map((week) => ({
165
+ ...week,
166
+ attributes: builders.weekRow.attrs(week.attributes),
167
+ cells: week.cells.map((cell) => ({
168
+ ...cell,
169
+ cellAttributes: builders.dayCell.attrs(cell.cellAttributes),
170
+ buttonAttributes: builders.dayButton.attrs(cell.buttonAttributes)
171
+ }))
172
+ }))
173
+ };
174
+ case "Months": return {
175
+ _tag: "Months",
176
+ root,
177
+ grid,
178
+ heading: render.heading,
179
+ headingButton: builders.headingButton.attrs(render.headingButton),
180
+ cells: render.cells.map((cell) => ({
181
+ ...cell,
182
+ cellAttributes: builders.monthCell.attrs(cell.cellAttributes),
183
+ buttonAttributes: builders.monthButton.attrs(cell.buttonAttributes)
184
+ }))
185
+ };
186
+ case "Years": return {
187
+ _tag: "Years",
188
+ root,
189
+ grid,
190
+ heading: render.heading,
191
+ previousPageButton: builders.previousPageButton.attrs(render.previousPageButton),
192
+ nextPageButton: builders.nextPageButton.attrs(render.nextPageButton),
193
+ cells: render.cells.map((cell) => ({
194
+ ...cell,
195
+ cellAttributes: builders.yearCell.attrs(cell.cellAttributes),
196
+ buttonAttributes: builders.yearButton.attrs(cell.buttonAttributes)
197
+ }))
198
+ };
199
+ }
200
+ };
201
+ //#endregion
202
+ //#region src/checkbox.ts
203
+ var checkbox_exports = /* @__PURE__ */ __exportAll({
204
+ CheckboxSlots: () => CheckboxSlots,
205
+ resolve: () => resolve$12
206
+ });
207
+ /**
208
+ * Both the control and its label carry the base toggle handlers, so both own
209
+ * `click`. `hiddenInput` exists only when a form `name` is configured; its base
210
+ * bundle is then empty.
211
+ */
212
+ const CheckboxSlots = Slots.define({
213
+ checkbox: Slot.make({
214
+ capability: Capability.Interactive,
215
+ events: [Event.Click],
216
+ attributes: [
217
+ Attr.Role,
218
+ Attr.AriaDisabled,
219
+ Attr.Disabled,
220
+ Attr.Value
221
+ ]
222
+ }),
223
+ label: Slot.make({
224
+ capability: Capability.Container,
225
+ events: [Event.Click]
226
+ }),
227
+ description: Slot.make({ capability: Capability.Container }),
228
+ hiddenInput: Slot.make({
229
+ capability: Capability.Base,
230
+ attributes: [Attr.Value]
231
+ })
232
+ });
233
+ const resolve$12 = (attributes, mixins, context) => resolveFor(CheckboxSlots, mixins, context)(attributes);
234
+ //#endregion
235
+ //#region src/dialog.ts
236
+ var dialog_exports = /* @__PURE__ */ __exportAll({
237
+ DialogSlots: () => DialogSlots,
238
+ resolve: () => resolve$11
239
+ });
240
+ /**
241
+ * Dialog is a Submodel: each published bundle is a `ChildAttribute` group that
242
+ * carries the dialog boundary's dispatcher. The resolver treats those as opaque
243
+ * and preserves their identity, so spreading a resolved bundle into the parent's
244
+ * markup keeps routing through the dialog's `toParentMessage`.
245
+ *
246
+ * `dialog` owns `cancel` (the native Escape handler); `backdrop` and
247
+ * `closeButton` own `click`. A Behavior adding its own handler to one of those
248
+ * is a conflict, not a second silent owner.
249
+ */
250
+ const DialogSlots = Slots.define({
251
+ dialog: Slot.make({
252
+ capability: Capability.Container,
253
+ events: [Event.Cancel],
254
+ attributes: [Attr.AriaDescribedby]
255
+ }),
256
+ backdrop: Slot.make({
257
+ capability: Capability.Container,
258
+ events: [Event.Click]
259
+ }),
260
+ panel: Slot.make({ capability: Capability.Container }),
261
+ title: Slot.make({ capability: Capability.Container }),
262
+ description: Slot.make({ capability: Capability.Container }),
263
+ initialFocus: Slot.make({ capability: Capability.Focusable }),
264
+ closeButton: Slot.make({
265
+ capability: Capability.Interactive,
266
+ events: [Event.Click],
267
+ attributes: [Attr.Role, Attr.Disabled]
268
+ })
269
+ });
270
+ /** Resolves the dialog's render groups; `isVisible` passes through unchanged. */
271
+ const resolve$11 = (render, mixins, context) => resolveFor(DialogSlots, mixins, context)(render);
272
+ //#endregion
273
+ //#region src/disclosure.ts
274
+ var disclosure_exports = /* @__PURE__ */ __exportAll({
275
+ DisclosureSlots: () => DisclosureSlots,
276
+ resolve: () => resolve$10
277
+ });
278
+ const DisclosureSlots = Slots.define({
279
+ button: Slot.make({
280
+ capability: Capability.Interactive,
281
+ events: [Event.Click],
282
+ attributes: [
283
+ Attr.Role,
284
+ Attr.AriaExpanded,
285
+ Attr.AriaDisabled,
286
+ Attr.Disabled
287
+ ]
288
+ }),
289
+ panel: Slot.make({ capability: Capability.Container })
290
+ });
291
+ /** `animatePanel` is not an attribute bundle, so it passes through unchanged. */
292
+ const resolve$10 = (attributes, mixins, context) => resolveFor(DisclosureSlots, mixins, context)(attributes);
293
+ //#endregion
294
+ //#region src/fieldset.ts
295
+ var fieldset_exports = /* @__PURE__ */ __exportAll({
296
+ FieldsetSlots: () => FieldsetSlots,
297
+ resolve: () => resolve$9
298
+ });
299
+ const FieldsetSlots = Slots.define({
300
+ fieldset: Slot.make({
301
+ capability: Capability.Container,
302
+ attributes: [Attr.Disabled]
303
+ }),
304
+ legend: Slot.make({ capability: Capability.Container }),
305
+ description: Slot.make({ capability: Capability.Container })
306
+ });
307
+ const resolve$9 = (attributes, mixins, context) => resolveFor(FieldsetSlots, mixins, context)(attributes);
308
+ //#endregion
309
+ //#region src/input.ts
310
+ var input_exports = /* @__PURE__ */ __exportAll({
311
+ InputSlots: () => InputSlots,
312
+ resolve: () => resolve$8
313
+ });
314
+ const InputSlots = Slots.define({
315
+ input: Slot.make({
316
+ capability: Capability.TextInput,
317
+ events: [
318
+ Event.Input,
319
+ Event.Focus,
320
+ Event.Blur
321
+ ],
322
+ attributes: [
323
+ Attr.AriaLabel,
324
+ Attr.AriaInvalid,
325
+ Attr.Disabled,
326
+ Attr.Value
327
+ ]
328
+ }),
329
+ label: Slot.make({ capability: Capability.Container }),
330
+ description: Slot.make({ capability: Capability.Container })
331
+ });
332
+ const resolve$8 = (attributes, mixins, context) => resolveFor(InputSlots, mixins, context)(attributes);
333
+ //#endregion
334
+ //#region src/popover.ts
335
+ var popover_exports = /* @__PURE__ */ __exportAll({
336
+ PopoverSlots: () => PopoverSlots,
337
+ resolve: () => resolve$7
338
+ });
339
+ /**
340
+ * Popover is a Submodel; every bundle is a `ChildAttribute` group. `button`
341
+ * owns `click` (and its pointer/keyboard handlers) while open; `panel` owns
342
+ * `blur`; `backdrop` owns `click`. The panel and backdrop bundles also carry
343
+ * the anchor and portal Mounts, preserved as opaque `ChildAttribute`s.
344
+ */
345
+ const PopoverSlots = Slots.define({
346
+ button: Slot.make({
347
+ capability: Capability.Interactive,
348
+ events: [Event.Click],
349
+ attributes: [
350
+ Attr.Role,
351
+ Attr.AriaExpanded,
352
+ Attr.AriaDisabled,
353
+ Attr.Disabled
354
+ ]
355
+ }),
356
+ panel: Slot.make({
357
+ capability: Capability.Container,
358
+ events: [Event.Blur]
359
+ }),
360
+ backdrop: Slot.make({
361
+ capability: Capability.Container,
362
+ events: [Event.Click]
363
+ }),
364
+ arrow: Slot.make({ capability: Capability.Container })
365
+ });
366
+ /** Resolves the popover's render groups; `isVisible` passes through unchanged. */
367
+ const resolve$7 = (render, mixins, context) => resolveFor(PopoverSlots, mixins, context)(render);
368
+ //#endregion
369
+ //#region src/radioGroup.ts
370
+ var radioGroup_exports = /* @__PURE__ */ __exportAll({
371
+ RadioGroupSlots: () => RadioGroupSlots,
372
+ resolve: () => resolve$6
373
+ });
374
+ /**
375
+ * RadioGroup is a Submodel: each published bundle is a `ChildAttribute` group
376
+ * that carries the boundary's dispatcher. The resolver treats those as opaque
377
+ * and preserves their identity, so spreading a resolved bundle into the
378
+ * parent's markup keeps routing through the radio group's `toParentMessage`.
379
+ *
380
+ * The base installs `OnClick` on an enabled, non-readonly option's `option`
381
+ * bundle, so a Behavior adding its own click handler is a conflict rather than
382
+ * a second silent owner.
383
+ */
384
+ const RadioGroupSlots = Slots.define({
385
+ group: Slot.make({
386
+ capability: Capability.Container,
387
+ attributes: [Attr.Role]
388
+ }),
389
+ option: Slot.make({
390
+ capability: Capability.Interactive,
391
+ events: [Event.Click],
392
+ attributes: [
393
+ Attr.Role,
394
+ Attr.AriaSelected,
395
+ Attr.Disabled,
396
+ Attr.AriaDisabled
397
+ ]
398
+ }),
399
+ label: Slot.make({ capability: Capability.Container }),
400
+ description: Slot.make({ capability: Capability.Container }),
401
+ hiddenInput: Slot.make({
402
+ capability: Capability.Base,
403
+ attributes: [Attr.Value]
404
+ })
405
+ });
406
+ /** Resolves every option's bundles alongside the group and hidden input. */
407
+ const resolve$6 = (render, mixins, context) => {
408
+ const builders = SlotView.buildersFor(RadioGroupSlots, mixins, context);
409
+ return {
410
+ group: builders.group.attrs(render.group),
411
+ options: render.options.map((option) => ({
412
+ ...option,
413
+ option: builders.option.attrs(option.option),
414
+ label: builders.label.attrs(option.label),
415
+ description: builders.description.attrs(option.description)
416
+ })),
417
+ selectedValue: render.selectedValue,
418
+ hiddenInput: builders.hiddenInput.attrs(render.hiddenInput)
419
+ };
420
+ };
421
+ //#endregion
422
+ //#region src/select.ts
423
+ var select_exports = /* @__PURE__ */ __exportAll({
424
+ SelectSlots: () => SelectSlots,
425
+ resolve: () => resolve$5
426
+ });
427
+ /**
428
+ * The base bundle installs `OnChange` only when `onChange` is configured and
429
+ * the control is enabled, so a Behavior that adds its own handler is a
430
+ * conflict rather than a second silent owner.
431
+ */
432
+ const SelectSlots = Slots.define({
433
+ select: Slot.make({
434
+ capability: Capability.Interactive,
435
+ events: [Event.Change],
436
+ attributes: [
437
+ Attr.AriaLabel,
438
+ Attr.AriaInvalid,
439
+ Attr.Disabled,
440
+ Attr.Value
441
+ ]
442
+ }),
443
+ label: Slot.make({ capability: Capability.Container }),
444
+ description: Slot.make({ capability: Capability.Container })
445
+ });
446
+ const resolve$5 = (attributes, mixins, context) => resolveFor(SelectSlots, mixins, context)(attributes);
447
+ //#endregion
448
+ //#region src/slider.ts
449
+ var slider_exports = /* @__PURE__ */ __exportAll({
450
+ SliderSlots: () => SliderSlots,
451
+ resolve: () => resolve$4
452
+ });
453
+ /**
454
+ * Slider is a Submodel: each published bundle is a `ChildAttribute` group that
455
+ * carries the boundary's dispatcher. The resolver treats those as opaque and
456
+ * preserves their identity, so spreading a resolved bundle into the parent's
457
+ * markup keeps routing through the slider's `toParentMessage`.
458
+ *
459
+ * The base installs the pointer handler on `track` and `thumb` only while the
460
+ * slider is interactive. A Behavior adding one of those owns it in the same
461
+ * window, so a second owner is a conflict rather than a silent takeover. Its
462
+ * keyboard handler is `OnKeyDownPreventDefault`, a distinct tag from `KeyDown`,
463
+ * so the thumb does not advertise `Event.KeyDown` (it would falsely imply a
464
+ * conflict the resolver cannot see).
465
+ */
466
+ const SliderSlots = Slots.define({
467
+ root: Slot.make({ capability: Capability.Container }),
468
+ track: Slot.make({
469
+ capability: Capability.Container,
470
+ events: [Event.PointerDown]
471
+ }),
472
+ filledTrack: Slot.make({ capability: Capability.Base }),
473
+ thumb: Slot.make({
474
+ capability: Capability.Focusable,
475
+ events: [Event.PointerDown],
476
+ attributes: [Attr.Role]
477
+ }),
478
+ label: Slot.make({ capability: Capability.Container }),
479
+ hiddenInput: Slot.make({
480
+ capability: Capability.Base,
481
+ attributes: [Attr.Value]
482
+ })
483
+ });
484
+ /** Resolves the slider's render groups; `value` and the rest pass through unchanged. */
485
+ const resolve$4 = (render, mixins, context) => resolveFor(SliderSlots, mixins, context)(render);
486
+ //#endregion
487
+ //#region src/switch.ts
488
+ var switch_exports = /* @__PURE__ */ __exportAll({
489
+ SwitchSlots: () => SwitchSlots,
490
+ resolve: () => resolve$3
491
+ });
492
+ /** Mirrors the checkbox contract: both the control and its label own `click`. */
493
+ const SwitchSlots = Slots.define({
494
+ button: Slot.make({
495
+ capability: Capability.Interactive,
496
+ events: [Event.Click],
497
+ attributes: [
498
+ Attr.Role,
499
+ Attr.AriaDisabled,
500
+ Attr.Disabled,
501
+ Attr.Value
502
+ ]
503
+ }),
504
+ label: Slot.make({
505
+ capability: Capability.Container,
506
+ events: [Event.Click]
507
+ }),
508
+ description: Slot.make({ capability: Capability.Container }),
509
+ hiddenInput: Slot.make({
510
+ capability: Capability.Base,
511
+ attributes: [Attr.Value]
512
+ })
513
+ });
514
+ const resolve$3 = (attributes, mixins, context) => resolveFor(SwitchSlots, mixins, context)(attributes);
515
+ //#endregion
516
+ //#region src/tabs.ts
517
+ var tabs_exports = /* @__PURE__ */ __exportAll({
518
+ TabsSlots: () => TabsSlots,
519
+ resolve: () => resolve$2
520
+ });
521
+ /**
522
+ * Tabs is a nested Submodel: one `tablist` group plus a `tab`/`panel` pair per
523
+ * item, so the resolver runs once per group and each base `ChildAttribute`
524
+ * bundle passes through by identity.
525
+ *
526
+ * Enabled tabs own `click` through the base `OnClick`; a Behavior adding its
527
+ * own click handler is a conflict rather than a second silent owner. Disabled
528
+ * tabs publish no click, so the contract still lists it as allowed.
529
+ */
530
+ const TabsSlots = Slots.define({
531
+ tablist: Slot.make({
532
+ capability: Capability.Container,
533
+ attributes: [Attr.Role]
534
+ }),
535
+ tab: Slot.make({
536
+ capability: Capability.Interactive,
537
+ events: [Event.Click],
538
+ attributes: [
539
+ Attr.Role,
540
+ Attr.AriaSelected,
541
+ Attr.Disabled,
542
+ Attr.AriaDisabled
543
+ ]
544
+ }),
545
+ panel: Slot.make({
546
+ capability: Capability.Container,
547
+ attributes: [Attr.Role]
548
+ })
549
+ });
550
+ /** Resolves the tabs' nested render groups, preserving `activeIndex`. */
551
+ const resolve$2 = (render, mixins, context) => {
552
+ const builders = SlotView.buildersFor(TabsSlots, mixins, context);
553
+ return {
554
+ tablist: builders.tablist.attrs(render.tablist),
555
+ tabs: render.tabs.map((item) => ({
556
+ ...item,
557
+ tab: builders.tab.attrs(item.tab),
558
+ panel: builders.panel.attrs(item.panel)
559
+ })),
560
+ activeIndex: render.activeIndex
561
+ };
562
+ };
563
+ //#endregion
564
+ //#region src/textarea.ts
565
+ var textarea_exports = /* @__PURE__ */ __exportAll({
566
+ TextareaSlots: () => TextareaSlots,
567
+ resolve: () => resolve$1
568
+ });
569
+ const TextareaSlots = Slots.define({
570
+ textarea: Slot.make({
571
+ capability: Capability.TextInput,
572
+ events: [
573
+ Event.Input,
574
+ Event.Focus,
575
+ Event.Blur
576
+ ],
577
+ attributes: [
578
+ Attr.AriaLabel,
579
+ Attr.AriaInvalid,
580
+ Attr.Disabled,
581
+ Attr.Value
582
+ ]
583
+ }),
584
+ label: Slot.make({ capability: Capability.Container }),
585
+ description: Slot.make({ capability: Capability.Container })
586
+ });
587
+ const resolve$1 = (attributes, mixins, context) => resolveFor(TextareaSlots, mixins, context)(attributes);
588
+ //#endregion
589
+ //#region src/tooltip.ts
590
+ var tooltip_exports = /* @__PURE__ */ __exportAll({
591
+ TooltipSlots: () => TooltipSlots,
592
+ resolve: () => resolve
593
+ });
594
+ /**
595
+ * Tooltip is a Submodel; both bundles are `ChildAttribute` groups. `trigger`
596
+ * owns `focus`, `blur` and `pointerdown` (the hover/keyboard entry points);
597
+ * `panel` carries the anchor Mount. `resolve` preserves each group by identity.
598
+ */
599
+ const TooltipSlots = Slots.define({
600
+ trigger: Slot.make({
601
+ capability: Capability.Interactive,
602
+ events: [
603
+ Event.Focus,
604
+ Event.Blur,
605
+ Event.PointerDown
606
+ ],
607
+ attributes: [
608
+ Attr.Role,
609
+ Attr.AriaDisabled,
610
+ Attr.Disabled
611
+ ]
612
+ }),
613
+ panel: Slot.make({
614
+ capability: Capability.Container,
615
+ attributes: [Attr.Role]
616
+ })
617
+ });
618
+ /** Resolves the tooltip's render groups; `isVisible` passes through unchanged. */
619
+ const resolve = (render, mixins, context) => resolveFor(TooltipSlots, mixins, context)(render);
620
+ //#endregion
621
+ export { button_exports as Button, ButtonSlots, calendar_exports as Calendar, CalendarSlots, checkbox_exports as Checkbox, CheckboxSlots, dialog_exports as Dialog, DialogSlots, disclosure_exports as Disclosure, DisclosureSlots, fieldset_exports as Fieldset, FieldsetSlots, input_exports as Input, InputSlots, popover_exports as Popover, PopoverSlots, radioGroup_exports as RadioGroup, RadioGroupSlots, select_exports as Select, SelectSlots, slider_exports as Slider, SliderSlots, switch_exports as Switch, SwitchSlots, tabs_exports as Tabs, TabsSlots, textarea_exports as Textarea, TextareaSlots, tooltip_exports as Tooltip, TooltipSlots, resolveFor as resolve };
622
+
623
+ //# sourceMappingURL=index.mjs.map