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/LICENSE +21 -0
- package/README.md +63 -0
- package/dist/index.d.mts +454 -0
- package/dist/index.d.mts.map +1 -0
- package/dist/index.mjs +623 -0
- package/dist/index.mjs.map +1 -0
- package/dist/rolldown-runtime-D7D4PA-g.mjs +13 -0
- package/package.json +47 -0
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
|