basecoat-css 0.3.11 → 1.0.0-beta.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.
Files changed (97) hide show
  1. package/README.md +8 -1
  2. package/dist/base/base.css +150 -0
  3. package/dist/basecoat-base.cdn.css +2942 -0
  4. package/dist/basecoat-base.cdn.min.css +2 -0
  5. package/dist/basecoat-base.css +2 -0
  6. package/dist/basecoat-components.css +32 -0
  7. package/dist/basecoat-luma.cdn.css +6073 -0
  8. package/dist/basecoat-luma.cdn.min.css +2 -0
  9. package/dist/basecoat-luma.css +2 -0
  10. package/dist/basecoat-lyra.cdn.css +6004 -0
  11. package/dist/basecoat-lyra.cdn.min.css +2 -0
  12. package/dist/basecoat-lyra.css +2 -0
  13. package/dist/basecoat-maia.cdn.css +6012 -0
  14. package/dist/basecoat-maia.cdn.min.css +2 -0
  15. package/dist/basecoat-maia.css +2 -0
  16. package/dist/basecoat-mira.cdn.css +6063 -0
  17. package/dist/basecoat-mira.cdn.min.css +2 -0
  18. package/dist/basecoat-mira.css +2 -0
  19. package/dist/basecoat-nova.cdn.css +6067 -0
  20. package/dist/basecoat-nova.cdn.min.css +2 -0
  21. package/dist/basecoat-nova.css +2 -0
  22. package/dist/basecoat-rhea.cdn.css +6092 -0
  23. package/dist/basecoat-rhea.cdn.min.css +2 -0
  24. package/dist/basecoat-rhea.css +2 -0
  25. package/dist/basecoat-sera.cdn.css +5840 -0
  26. package/dist/basecoat-sera.cdn.min.css +2 -0
  27. package/dist/basecoat-sera.css +2 -0
  28. package/dist/basecoat-vega.cdn.css +6023 -0
  29. package/dist/basecoat-vega.cdn.min.css +2 -0
  30. package/dist/basecoat-vega.css +2 -0
  31. package/dist/basecoat.all.css +1 -0
  32. package/dist/basecoat.cdn.css +5084 -2646
  33. package/dist/basecoat.cdn.min.css +1 -1
  34. package/dist/basecoat.css +1 -1311
  35. package/dist/components/alert.css +21 -0
  36. package/dist/components/badge.css +12 -0
  37. package/dist/components/button-group.css +54 -0
  38. package/dist/components/button.css +61 -0
  39. package/dist/components/card.css +22 -0
  40. package/dist/components/checkbox.css +12 -0
  41. package/dist/components/collapsible.css +21 -0
  42. package/dist/components/combobox.css +78 -0
  43. package/dist/components/command.css +133 -0
  44. package/dist/components/dialog.css +52 -0
  45. package/dist/components/dropdown-menu.css +48 -0
  46. package/dist/components/empty.css +26 -0
  47. package/dist/components/field.css +86 -0
  48. package/dist/components/form.css +9 -0
  49. package/dist/components/input-group.css +50 -0
  50. package/dist/components/input.css +32 -0
  51. package/dist/components/item.css +50 -0
  52. package/dist/components/kbd.css +10 -0
  53. package/dist/components/label.css +12 -0
  54. package/dist/components/native-select.css +12 -0
  55. package/dist/components/popover.css +81 -0
  56. package/dist/components/radio.css +11 -0
  57. package/dist/components/range.css +50 -0
  58. package/dist/components/select.css +64 -0
  59. package/dist/components/sidebar.css +101 -0
  60. package/dist/components/skeleton.css +6 -0
  61. package/dist/components/switch.css +8 -0
  62. package/dist/components/table.css +34 -0
  63. package/dist/components/tabs.css +31 -0
  64. package/dist/components/textarea.css +7 -0
  65. package/dist/components/toast.css +57 -0
  66. package/dist/components/tooltip.css +82 -0
  67. package/dist/js/all.js +1435 -755
  68. package/dist/js/all.min.js +1 -1
  69. package/dist/js/basecoat.js +95 -40
  70. package/dist/js/basecoat.min.js +1 -1
  71. package/dist/js/combobox.js +483 -0
  72. package/dist/js/combobox.min.js +1 -0
  73. package/dist/js/command.js +165 -126
  74. package/dist/js/command.min.js +1 -1
  75. package/dist/js/dropdown-menu.js +158 -133
  76. package/dist/js/dropdown-menu.min.js +1 -1
  77. package/dist/js/popover.js +22 -8
  78. package/dist/js/popover.min.js +1 -1
  79. package/dist/js/range.js +25 -0
  80. package/dist/js/range.min.js +1 -0
  81. package/dist/js/select.js +347 -359
  82. package/dist/js/select.min.js +1 -1
  83. package/dist/js/sidebar.js +27 -31
  84. package/dist/js/sidebar.min.js +1 -1
  85. package/dist/js/tabs.js +82 -38
  86. package/dist/js/tabs.min.js +1 -1
  87. package/dist/js/toast.js +42 -37
  88. package/dist/js/toast.min.js +1 -1
  89. package/dist/styles/luma.css +1308 -0
  90. package/dist/styles/lyra.css +1289 -0
  91. package/dist/styles/maia.css +1296 -0
  92. package/dist/styles/mira.css +1297 -0
  93. package/dist/styles/nova.css +1293 -0
  94. package/dist/styles/rhea.css +1305 -0
  95. package/dist/styles/sera.css +1316 -0
  96. package/dist/styles/vega.css +1293 -0
  97. package/package.json +47 -3
package/dist/js/all.js CHANGED
@@ -2,435 +2,1042 @@
2
2
  const componentRegistry = {};
3
3
  let observer = null;
4
4
 
5
- const registerComponent = (name, selector, initFunction) => {
5
+ const registerComponent = (name, selectorOrOptions, initFunction) => {
6
+ const options = typeof selectorOrOptions === 'object'
7
+ ? selectorOrOptions
8
+ : { selector: selectorOrOptions, init: initFunction };
9
+
6
10
  componentRegistry[name] = {
7
- selector,
8
- init: initFunction
11
+ selector: options.selector,
12
+ init: options.init,
13
+ refresh: options.refresh,
9
14
  };
10
15
  };
11
16
 
12
17
  const initComponent = (element, componentName) => {
13
18
  const component = componentRegistry[componentName];
14
19
  if (!component) return;
15
-
20
+
16
21
  try {
17
22
  component.init(element);
23
+ if (element.hasAttribute(`data-${componentName}-initialized`)) {
24
+ element.dataset.basecoatComponent = componentName;
25
+ }
18
26
  } catch (error) {
19
27
  console.error(`Failed to initialize ${componentName}:`, error);
28
+ if (typeof element._destroy === 'function') {
29
+ try {
30
+ element._destroy();
31
+ } catch (destroyError) {
32
+ console.error(`Failed to clean up ${componentName} after initialization error:`, destroyError);
33
+ }
34
+ }
35
+ delete element._destroy;
36
+ element.removeAttribute(`data-${componentName}-initialized`);
37
+ delete element.dataset.basecoatComponent;
38
+ }
39
+ };
40
+
41
+ const destroyComponent = (element) => {
42
+ if (!element || element.nodeType !== Node.ELEMENT_NODE) return;
43
+ const componentName = element.dataset?.basecoatComponent;
44
+
45
+ if (typeof element._destroy === 'function') {
46
+ try {
47
+ element._destroy();
48
+ } catch (error) {
49
+ console.error('Failed to destroy Basecoat component:', error);
50
+ }
20
51
  }
52
+
53
+ delete element._destroy;
54
+ if (componentName) element.removeAttribute(`data-${componentName}-initialized`);
55
+ delete element.dataset.basecoatComponent;
56
+ };
57
+
58
+ const destroyRemovedComponents = (node) => {
59
+ if (node.nodeType !== Node.ELEMENT_NODE) return;
60
+ if (node.isConnected) return;
61
+
62
+ if (node.dataset?.basecoatComponent) destroyComponent(node);
63
+ node.querySelectorAll('[data-basecoat-component]').forEach(destroyComponent);
21
64
  };
22
65
 
23
66
  const initAllComponents = () => {
24
- Object.entries(componentRegistry).forEach(([name, { selector, init }]) => {
25
- document.querySelectorAll(selector).forEach(init);
67
+ Object.entries(componentRegistry).forEach(([name, { selector }]) => {
68
+ document.querySelectorAll(selector).forEach(element => initComponent(element, name));
26
69
  });
27
70
  };
28
71
 
29
72
  const initNewComponents = (node) => {
30
73
  if (node.nodeType !== Node.ELEMENT_NODE) return;
31
-
32
- Object.entries(componentRegistry).forEach(([name, { selector, init }]) => {
33
- if (node.matches(selector)) {
34
- init(node);
35
- }
36
- node.querySelectorAll(selector).forEach(init);
74
+
75
+ Object.entries(componentRegistry).forEach(([name, { selector }]) => {
76
+ if (node.matches(selector)) initComponent(node, name);
77
+ node.querySelectorAll(selector).forEach(element => initComponent(element, name));
37
78
  });
38
79
  };
39
80
 
81
+ const refreshComponent = (element) => {
82
+ if (!element) return;
83
+ if (typeof element.refresh === 'function') {
84
+ element.refresh();
85
+ return;
86
+ }
87
+
88
+ const componentName = element.dataset?.basecoatComponent;
89
+ const component = componentName ? componentRegistry[componentName] : null;
90
+ if (component?.refresh) {
91
+ component.refresh(element);
92
+ }
93
+ };
94
+
40
95
  const startObserver = () => {
41
96
  if (observer) return;
42
-
97
+
43
98
  observer = new MutationObserver((mutations) => {
44
99
  mutations.forEach((mutation) => {
45
100
  mutation.addedNodes.forEach(initNewComponents);
101
+ mutation.removedNodes.forEach(destroyRemovedComponents);
46
102
  });
47
103
  });
48
-
104
+
49
105
  observer.observe(document.body, { childList: true, subtree: true });
50
106
  };
51
107
 
52
108
  const stopObserver = () => {
53
- if (observer) {
54
- observer.disconnect();
55
- observer = null;
56
- }
109
+ if (!observer) return;
110
+ observer.disconnect();
111
+ observer = null;
57
112
  };
58
113
 
59
- const reinitComponent = (componentName) => {
114
+ const initRegisteredComponent = (componentName) => {
60
115
  const component = componentRegistry[componentName];
61
116
  if (!component) {
62
117
  console.warn(`Component '${componentName}' not found in registry`);
63
118
  return;
64
119
  }
65
-
66
- // Clear initialization flag for this component
67
- const flag = `data-${componentName}-initialized`;
68
- document.querySelectorAll(`[${flag}]`).forEach(el => {
69
- el.removeAttribute(flag);
70
- });
71
-
72
- document.querySelectorAll(component.selector).forEach(component.init);
120
+
121
+ document.querySelectorAll(component.selector).forEach(element => initComponent(element, componentName));
73
122
  };
74
123
 
75
- const reinitAll = () => {
76
- // Clear all initialization flags using the registry
77
- Object.entries(componentRegistry).forEach(([name, { selector }]) => {
78
- const flag = `data-${name}-initialized`;
79
- document.querySelectorAll(`[${flag}]`).forEach(el => {
80
- el.removeAttribute(flag);
81
- });
82
- });
83
-
124
+ const initAllRegisteredComponents = () => {
84
125
  initAllComponents();
85
126
  };
86
127
 
128
+ const setTheme = (mode) => {
129
+ const dark = mode === 'dark';
130
+ document.documentElement.classList.toggle('dark', dark);
131
+ try { localStorage.setItem('themeMode', dark ? 'dark' : 'light'); } catch (_) {}
132
+ };
133
+
134
+ const getTheme = () => document.documentElement.classList.contains('dark') ? 'dark' : 'light';
135
+
87
136
  window.basecoat = {
88
137
  register: registerComponent,
89
- init: reinitComponent,
90
- initAll: reinitAll,
138
+ init: initRegisteredComponent,
139
+ initAll: initAllRegisteredComponents,
140
+ refresh: refreshComponent,
91
141
  start: startObserver,
92
- stop: stopObserver
142
+ stop: stopObserver,
143
+ theme: {
144
+ get: getTheme,
145
+ set: setTheme,
146
+ toggle: () => setTheme(getTheme() === 'dark' ? 'light' : 'dark'),
147
+ },
93
148
  };
94
149
 
95
150
  document.addEventListener('DOMContentLoaded', () => {
96
151
  initAllComponents();
97
152
  startObserver();
98
153
  });
99
- })();
154
+ })();
155
+
100
156
  (() => {
157
+ const states = new WeakMap();
158
+
159
+ const isDisabled = (item) =>
160
+ item.hasAttribute('disabled') || item.getAttribute('aria-disabled') === 'true';
161
+
162
+ const getElements = (container) => ({
163
+ input: container.querySelector('header input'),
164
+ menu: container.querySelector('[role="menu"]'),
165
+ });
166
+
167
+ const getItems = (menu) => {
168
+ const allItems = Array.from(menu.querySelectorAll('[role="menuitem"]'));
169
+ return {
170
+ allItems,
171
+ items: allItems.filter(item => !isDisabled(item)),
172
+ };
173
+ };
174
+
175
+ const scrollItemIntoMenu = (state, item) => {
176
+ const itemRect = item.getBoundingClientRect();
177
+ const menuRect = state.menu.getBoundingClientRect();
178
+
179
+ if (itemRect.top < menuRect.top) {
180
+ state.menu.scrollTop -= menuRect.top - itemRect.top;
181
+ } else if (itemRect.bottom > menuRect.bottom) {
182
+ state.menu.scrollTop += itemRect.bottom - menuRect.bottom;
183
+ }
184
+ };
185
+
186
+ const setActiveItem = (state, index) => {
187
+ if (state.activeIndex > -1 && state.items[state.activeIndex]) {
188
+ state.items[state.activeIndex].classList.remove('active');
189
+ }
190
+
191
+ state.activeIndex = index;
192
+
193
+ if (state.activeIndex > -1) {
194
+ const activeItem = state.items[state.activeIndex];
195
+ activeItem.classList.add('active');
196
+ if (activeItem.id) {
197
+ state.input.setAttribute('aria-activedescendant', activeItem.id);
198
+ } else {
199
+ state.input.removeAttribute('aria-activedescendant');
200
+ }
201
+ } else {
202
+ state.input.removeAttribute('aria-activedescendant');
203
+ }
204
+ };
205
+
206
+ const filterItems = (state) => {
207
+ if (state.manualFilter) {
208
+ setActiveItem(state, -1);
209
+ state.visibleItems = state.items.filter(item => item.getAttribute('aria-hidden') !== 'true');
210
+ if (state.visibleItems.length > 0) {
211
+ setActiveItem(state, state.items.indexOf(state.visibleItems[0]));
212
+ }
213
+ return;
214
+ }
215
+
216
+ const searchTerm = state.input.value.trim().toLowerCase();
217
+
218
+ setActiveItem(state, -1);
219
+ state.visibleItems = [];
220
+
221
+ state.allItems.forEach(item => {
222
+ if (item.hasAttribute('data-force')) {
223
+ item.setAttribute('aria-hidden', 'false');
224
+ if (state.items.includes(item)) state.visibleItems.push(item);
225
+ return;
226
+ }
227
+
228
+ const itemText = (item.dataset.filter || item.textContent).trim().toLowerCase();
229
+ const keywordList = (item.dataset.keywords || '')
230
+ .toLowerCase()
231
+ .split(/[\s,]+/)
232
+ .filter(Boolean);
233
+ const matchesKeyword = keywordList.some(keyword => keyword.includes(searchTerm));
234
+ const matches = itemText.includes(searchTerm) || matchesKeyword;
235
+ item.setAttribute('aria-hidden', String(!matches));
236
+ if (matches && state.items.includes(item)) state.visibleItems.push(item);
237
+ });
238
+
239
+ if (state.visibleItems.length > 0) {
240
+ setActiveItem(state, state.items.indexOf(state.visibleItems[0]));
241
+ scrollItemIntoMenu(state, state.visibleItems[0]);
242
+ }
243
+ };
244
+
245
+ const refreshCommand = (container) => {
246
+ const state = states.get(container);
247
+ if (!state) return;
248
+
249
+ const elements = getElements(container);
250
+ if (!elements.input || !elements.menu) {
251
+ const missing = [];
252
+ if (!elements.input) missing.push('input');
253
+ if (!elements.menu) missing.push('menu');
254
+ console.error(`Command component refresh failed. Missing element(s): ${missing.join(', ')}`, container);
255
+ return;
256
+ }
257
+
258
+ Object.assign(state, elements, getItems(elements.menu));
259
+ state.manualFilter = container.dataset.filter === 'manual';
260
+ filterItems(state);
261
+ };
262
+
263
+ const handleKeyNavigation = (event, state) => {
264
+ if (!['ArrowDown', 'ArrowUp', 'Enter', 'Home', 'End'].includes(event.key)) return;
265
+
266
+ if (event.key === 'Enter') {
267
+ event.preventDefault();
268
+ if (state.activeIndex > -1) state.items[state.activeIndex]?.click();
269
+ return;
270
+ }
271
+
272
+ if (state.visibleItems.length === 0) return;
273
+
274
+ event.preventDefault();
275
+
276
+ const currentVisibleIndex = state.activeIndex > -1 ? state.visibleItems.indexOf(state.items[state.activeIndex]) : -1;
277
+ let nextVisibleIndex = currentVisibleIndex;
278
+
279
+ if (event.key === 'ArrowDown' && currentVisibleIndex < state.visibleItems.length - 1) nextVisibleIndex = currentVisibleIndex + 1;
280
+ if (event.key === 'ArrowUp') nextVisibleIndex = currentVisibleIndex > 0 ? currentVisibleIndex - 1 : 0;
281
+ if (event.key === 'Home') nextVisibleIndex = 0;
282
+ if (event.key === 'End') nextVisibleIndex = state.visibleItems.length - 1;
283
+
284
+ if (nextVisibleIndex !== currentVisibleIndex) {
285
+ const newActiveItem = state.visibleItems[nextVisibleIndex];
286
+ setActiveItem(state, state.items.indexOf(newActiveItem));
287
+ scrollItemIntoMenu(state, newActiveItem);
288
+ }
289
+ };
290
+
101
291
  const initCommand = (container) => {
102
- const input = container.querySelector('header input');
103
- const menu = container.querySelector('[role="menu"]');
292
+ if (container.dataset.commandInitialized) return;
104
293
 
105
- if (!input || !menu) {
294
+ const state = { activeIndex: -1, allItems: [], items: [], visibleItems: [], manualFilter: false };
295
+ states.set(container, state);
296
+
297
+ container.refresh = () => refreshCommand(container);
298
+
299
+ const elements = getElements(container);
300
+ if (!elements.input || !elements.menu) {
106
301
  const missing = [];
107
- if (!input) missing.push('input');
108
- if (!menu) missing.push('menu');
302
+ if (!elements.input) missing.push('input');
303
+ if (!elements.menu) missing.push('menu');
109
304
  console.error(`Command component initialization failed. Missing element(s): ${missing.join(', ')}`, container);
305
+ states.delete(container);
306
+ delete container.refresh;
110
307
  return;
111
308
  }
309
+ Object.assign(state, elements);
112
310
 
113
- const allMenuItems = Array.from(menu.querySelectorAll('[role="menuitem"]'));
114
- const menuItems = allMenuItems.filter(item =>
115
- !item.hasAttribute('disabled') &&
116
- item.getAttribute('aria-disabled') !== 'true'
117
- );
118
- let visibleMenuItems = [...menuItems];
119
- let activeIndex = -1;
120
-
121
- const setActiveItem = (index) => {
122
- if (activeIndex > -1 && menuItems[activeIndex]) {
123
- menuItems[activeIndex].classList.remove('active');
311
+ const handleInput = () => filterItems(state);
312
+ const handleInputKeydown = (event) => handleKeyNavigation(event, state);
313
+ const handleMenuMousemove = (event) => {
314
+ const menuItem = event.target.closest('[role="menuitem"]');
315
+ if (menuItem && state.visibleItems.includes(menuItem)) {
316
+ const index = state.items.indexOf(menuItem);
317
+ if (index !== state.activeIndex) setActiveItem(state, index);
124
318
  }
125
-
126
- activeIndex = index;
127
-
128
- if (activeIndex > -1) {
129
- const activeItem = menuItems[activeIndex];
130
- activeItem.classList.add('active');
131
- if (activeItem.id) {
132
- input.setAttribute('aria-activedescendant', activeItem.id);
133
- } else {
134
- input.removeAttribute('aria-activedescendant');
135
- }
136
- } else {
137
- input.removeAttribute('aria-activedescendant');
319
+ };
320
+ const handleMenuClick = (event) => {
321
+ const clickedItem = event.target.closest('[role="menuitem"]');
322
+ if (clickedItem && state.visibleItems.includes(clickedItem)) {
323
+ const dialog = container.closest('dialog.command-dialog');
324
+ if (dialog && !clickedItem.hasAttribute('data-keep-command-open')) dialog.close();
138
325
  }
139
326
  };
140
327
 
141
- const filterMenuItems = () => {
142
- const searchTerm = input.value.trim().toLowerCase();
328
+ state.input.addEventListener('input', handleInput);
329
+ state.input.addEventListener('keydown', handleInputKeydown);
330
+ state.menu.addEventListener('mousemove', handleMenuMousemove);
331
+ state.menu.addEventListener('click', handleMenuClick);
332
+
333
+ container._destroy = () => {
334
+ state.input.removeEventListener('input', handleInput);
335
+ state.input.removeEventListener('keydown', handleInputKeydown);
336
+ state.menu.removeEventListener('mousemove', handleMenuMousemove);
337
+ state.menu.removeEventListener('click', handleMenuClick);
338
+ states.delete(container);
339
+ delete container.refresh;
340
+ };
143
341
 
144
- setActiveItem(-1);
342
+ refreshCommand(container);
343
+ container.dataset.commandInitialized = 'true';
344
+ container.dispatchEvent(new CustomEvent('basecoat:initialized'));
345
+ };
145
346
 
146
- visibleMenuItems = [];
147
- allMenuItems.forEach(item => {
148
- if (item.hasAttribute('data-force')) {
149
- item.setAttribute('aria-hidden', 'false');
150
- if (menuItems.includes(item)) {
151
- visibleMenuItems.push(item);
152
- }
153
- return;
154
- }
347
+ if (window.basecoat) {
348
+ window.basecoat.register('command', {
349
+ selector: '.command:not([data-command-initialized])',
350
+ init: initCommand,
351
+ refresh: refreshCommand,
352
+ });
353
+ }
354
+ })();
155
355
 
156
- const itemText = (item.dataset.filter || item.textContent).trim().toLowerCase();
157
- const keywordList = (item.dataset.keywords || '')
158
- .toLowerCase()
159
- .split(/[\s,]+/)
160
- .filter(Boolean);
161
- const matchesKeyword = keywordList.some(keyword => keyword.includes(searchTerm));
162
- const matches = itemText.includes(searchTerm) || matchesKeyword;
163
- item.setAttribute('aria-hidden', String(!matches));
164
- if (matches && menuItems.includes(item)) {
165
- visibleMenuItems.push(item);
166
- }
167
- });
356
+ (() => {
357
+ const states = new WeakMap();
168
358
 
169
- if (visibleMenuItems.length > 0) {
170
- setActiveItem(menuItems.indexOf(visibleMenuItems[0]));
171
- visibleMenuItems[0].scrollIntoView({ block: 'nearest' });
172
- }
359
+ const getElements = (root) => {
360
+ const input = root.querySelector(':scope > input[role="combobox"], :scope > .combobox-chips input[role="combobox"]');
361
+ const chips = root.querySelector(':scope > .combobox-chips');
362
+ const popover = root.querySelector(':scope > [data-popover]');
363
+ const listbox = popover ? popover.querySelector('[role="listbox"]') : null;
364
+ const hiddenInput = root.querySelector(':scope > input[type="hidden"]');
365
+ return { input, chips, popover, listbox, hiddenInput };
366
+ };
367
+
368
+ const getValue = option => option.dataset.value ?? option.textContent.trim();
369
+ const getLabel = option => option.dataset.label || option.textContent.trim();
370
+ const getFormat = root => root.dataset.format === 'object' ? 'object' : 'value';
371
+ const isDisabled = option => option.getAttribute('aria-disabled') === 'true';
372
+ const toSelected = option => ({ value: getValue(option), label: getLabel(option) });
373
+ const normalizeEntry = entry => {
374
+ if (entry && typeof entry === 'object') {
375
+ const value = entry.value == null ? '' : String(entry.value);
376
+ return value ? { value, label: String(entry.label ?? entry.value) } : null;
377
+ }
378
+ const value = entry == null ? '' : String(entry);
379
+ return value ? { value, label: value } : null;
380
+ };
381
+
382
+ const getOptions = (listbox) => {
383
+ const allOptions = Array.from(listbox.querySelectorAll('[role="option"]'));
384
+ return {
385
+ allOptions,
386
+ options: allOptions.filter(option => !isDisabled(option)),
173
387
  };
388
+ };
174
389
 
175
- input.addEventListener('input', filterMenuItems);
390
+ const getSelection = (state) => Array.from(state.selected.values());
391
+ const getCanonicalValue = (state) => state.isMultiple ? getSelection(state).map(item => item.value) : (getSelection(state)[0]?.value || '');
392
+ const getSelectedDetail = (state) => state.isMultiple ? getSelection(state) : (getSelection(state)[0] || null);
176
393
 
177
- const handleKeyNavigation = (event) => {
178
- if (!['ArrowDown', 'ArrowUp', 'Enter', 'Home', 'End'].includes(event.key)) {
179
- return;
394
+ const serializeSelection = (state) => {
395
+ const selected = getSelection(state);
396
+ if (state.format === 'object') {
397
+ return JSON.stringify(state.isMultiple ? selected : (selected[0] || null));
398
+ }
399
+ const value = selected.map(item => item.value);
400
+ return state.isMultiple ? JSON.stringify(value) : (value[0] || '');
401
+ };
402
+
403
+ const parseStoredSelection = (storedValue, inputValue, state) => {
404
+ if (state.isMultiple) {
405
+ let parsed = [];
406
+ try {
407
+ parsed = JSON.parse(storedValue || '[]');
408
+ } catch (_) {
409
+ parsed = [];
180
410
  }
411
+ if (!Array.isArray(parsed)) return [];
412
+ return parsed.map(item => {
413
+ const entry = normalizeEntry(state.format === 'object' ? item : { value: item, label: state.selected.get(String(item))?.label ?? item });
414
+ if (!entry) return null;
415
+ const option = state.options.find(opt => getValue(opt) === entry.value);
416
+ return option ? toSelected(option) : entry;
417
+ }).filter(Boolean);
418
+ }
181
419
 
182
- if (event.key === 'Enter') {
183
- event.preventDefault();
184
- if (activeIndex > -1) {
185
- menuItems[activeIndex]?.click();
186
- }
187
- return;
420
+ if (state.format === 'object') {
421
+ try {
422
+ const entry = normalizeEntry(JSON.parse(storedValue || 'null'));
423
+ if (!entry) return [];
424
+ const option = state.options.find(opt => getValue(opt) === entry.value);
425
+ return [option ? toSelected(option) : entry];
426
+ } catch (_) {
427
+ return [];
188
428
  }
429
+ }
189
430
 
190
- if (visibleMenuItems.length === 0) return;
431
+ const value = storedValue || '';
432
+ if (!value) return [];
433
+ const option = state.options.find(opt => getValue(opt) === value);
434
+ return [option ? toSelected(option) : { value, label: state.selected.get(value)?.label || inputValue || value }];
435
+ };
191
436
 
192
- event.preventDefault();
437
+ const scrollOptionIntoListbox = (state, option) => {
438
+ const optionRect = option.getBoundingClientRect();
439
+ const listboxRect = state.listbox.getBoundingClientRect();
193
440
 
194
- const currentVisibleIndex = activeIndex > -1 ? visibleMenuItems.indexOf(menuItems[activeIndex]) : -1;
195
- let nextVisibleIndex = currentVisibleIndex;
441
+ if (optionRect.top < listboxRect.top) {
442
+ state.listbox.scrollTop -= listboxRect.top - optionRect.top;
443
+ } else if (optionRect.bottom > listboxRect.bottom) {
444
+ state.listbox.scrollTop += optionRect.bottom - listboxRect.bottom;
445
+ }
446
+ };
196
447
 
197
- switch (event.key) {
198
- case 'ArrowDown':
199
- if (currentVisibleIndex < visibleMenuItems.length - 1) {
200
- nextVisibleIndex = currentVisibleIndex + 1;
201
- }
202
- break;
203
- case 'ArrowUp':
204
- if (currentVisibleIndex > 0) {
205
- nextVisibleIndex = currentVisibleIndex - 1;
206
- } else if (currentVisibleIndex === -1) {
207
- nextVisibleIndex = 0;
208
- }
209
- break;
210
- case 'Home':
211
- nextVisibleIndex = 0;
212
- break;
213
- case 'End':
214
- nextVisibleIndex = visibleMenuItems.length - 1;
215
- break;
216
- }
448
+ const setActiveOption = (state, index) => {
449
+ if (state.activeIndex > -1 && state.options[state.activeIndex]) {
450
+ state.options[state.activeIndex].classList.remove('active');
451
+ }
452
+
453
+ state.activeIndex = index;
454
+
455
+ if (state.activeIndex > -1) {
456
+ const activeOption = state.options[state.activeIndex];
457
+ activeOption.classList.add('active');
458
+ if (!activeOption.id) activeOption.id = `${state.listbox.id || state.root.id || 'combobox'}-option-${state.activeIndex}`;
459
+ state.input.setAttribute('aria-activedescendant', activeOption.id);
460
+ } else {
461
+ state.input.removeAttribute('aria-activedescendant');
462
+ }
463
+ };
464
+
465
+ const syncEmptyState = (state) => {
466
+ state.popover.dataset.empty = String(state.visibleOptions.length === 0);
467
+ };
468
+
469
+ const filterOptions = (state, { preserveActive = false } = {}) => {
470
+ const previousActive = state.activeIndex > -1 ? state.options[state.activeIndex] : null;
471
+ state.visibleOptions = [];
217
472
 
218
- if (nextVisibleIndex !== currentVisibleIndex) {
219
- const newActiveItem = visibleMenuItems[nextVisibleIndex];
220
- setActiveItem(menuItems.indexOf(newActiveItem));
221
- newActiveItem.scrollIntoView({ block: 'nearest', behavior: 'smooth' });
473
+ if (state.manualFilter) {
474
+ state.visibleOptions = state.options.filter(option => option.getAttribute('aria-hidden') !== 'true');
475
+
476
+ if (preserveActive && previousActive && state.visibleOptions.includes(previousActive)) {
477
+ setActiveOption(state, state.options.indexOf(previousActive));
478
+ } else {
479
+ setActiveOption(state, state.autoHighlight && state.visibleOptions.length > 0 ? state.options.indexOf(state.visibleOptions[0]) : -1);
222
480
  }
223
- };
481
+ syncEmptyState(state);
482
+ return;
483
+ }
224
484
 
225
- menu.addEventListener('mousemove', (event) => {
226
- const menuItem = event.target.closest('[role="menuitem"]');
227
- if (menuItem && visibleMenuItems.includes(menuItem)) {
228
- const index = menuItems.indexOf(menuItem);
229
- if (index !== activeIndex) {
230
- setActiveItem(index);
231
- }
485
+ const search = state.input.value.trim().toLowerCase();
486
+
487
+ state.allOptions.forEach(option => {
488
+ if (option.hasAttribute('data-force')) {
489
+ option.setAttribute('aria-hidden', 'false');
490
+ if (state.options.includes(option)) state.visibleOptions.push(option);
491
+ return;
232
492
  }
493
+
494
+ const optionText = (option.dataset.filter || option.dataset.label || option.textContent).trim().toLowerCase();
495
+ const keywords = (option.dataset.keywords || '').toLowerCase().split(/[\s,]+/).filter(Boolean);
496
+ const matches = !search || optionText.includes(search) || keywords.some(keyword => keyword.includes(search));
497
+ option.setAttribute('aria-hidden', String(!matches));
498
+ if (matches && state.options.includes(option)) state.visibleOptions.push(option);
233
499
  });
234
500
 
235
- menu.addEventListener('click', (event) => {
236
- const clickedItem = event.target.closest('[role="menuitem"]');
237
- if (clickedItem && visibleMenuItems.includes(clickedItem)) {
238
- const dialog = container.closest('dialog.command-dialog');
239
- if (dialog && !clickedItem.hasAttribute('data-keep-command-open')) {
240
- dialog.close();
241
- }
501
+ if (preserveActive && previousActive && state.visibleOptions.includes(previousActive)) {
502
+ setActiveOption(state, state.options.indexOf(previousActive));
503
+ } else {
504
+ setActiveOption(state, state.autoHighlight && state.visibleOptions.length > 0 ? state.options.indexOf(state.visibleOptions[0]) : -1);
505
+ }
506
+ syncEmptyState(state);
507
+ };
508
+
509
+ const renderChips = (root) => {
510
+ const state = states.get(root);
511
+ if (!state.chips) return;
512
+
513
+ state.chips.querySelectorAll('.combobox-chip').forEach(chip => chip.remove());
514
+
515
+ getSelection(state).forEach(entry => {
516
+ const chip = document.createElement('span');
517
+ chip.className = 'combobox-chip';
518
+ chip.dataset.value = entry.value;
519
+ chip.textContent = entry.label;
520
+
521
+ const remove = document.createElement('button');
522
+ remove.type = 'button';
523
+ remove.className = 'combobox-chip-remove';
524
+ remove.setAttribute('aria-label', `Remove ${entry.label}`);
525
+ remove.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 6 6 18"/><path d="m6 6 12 12"/></svg>';
526
+ remove.addEventListener('click', () => root.deselect(entry.value));
527
+
528
+ chip.appendChild(remove);
529
+ state.chips.insertBefore(chip, state.input);
530
+ });
531
+ };
532
+
533
+ const syncSelectedOptions = (state) => {
534
+ state.options.forEach(option => {
535
+ if (state.selected.has(getValue(option))) {
536
+ option.setAttribute('aria-selected', 'true');
537
+ } else {
538
+ option.removeAttribute('aria-selected');
242
539
  }
243
540
  });
541
+ };
244
542
 
245
- input.addEventListener('keydown', handleKeyNavigation);
543
+ const setSelected = (root, entries, triggerEvent = true) => {
544
+ const state = states.get(root);
545
+ const normalized = (Array.isArray(entries) ? entries : [entries]).map(normalizeEntry).filter(Boolean);
546
+
547
+ state.selected.clear();
548
+ if (state.isMultiple) {
549
+ normalized.forEach(entry => state.selected.set(entry.value, entry));
550
+ state.input.value = '';
551
+ } else if (normalized[0]) {
552
+ state.selected.set(normalized[0].value, normalized[0]);
553
+ state.input.value = normalized[0].label;
554
+ } else {
555
+ state.input.value = '';
556
+ }
246
557
 
247
- if (visibleMenuItems.length > 0) {
248
- setActiveItem(menuItems.indexOf(visibleMenuItems[0]));
249
- visibleMenuItems[0].scrollIntoView({ block: 'nearest' });
558
+ state.hiddenInput.value = serializeSelection(state);
559
+ syncSelectedOptions(state);
560
+ if (state.isMultiple) {
561
+ renderChips(root);
562
+ filterOptions(state, { preserveActive: true });
250
563
  }
251
564
 
252
- container.dataset.commandInitialized = true;
253
- container.dispatchEvent(new CustomEvent('basecoat:initialized'));
565
+ if (triggerEvent) {
566
+ root.dispatchEvent(new CustomEvent('change', {
567
+ detail: { value: getCanonicalValue(state), selected: getSelectedDetail(state) },
568
+ bubbles: true,
569
+ }));
570
+ }
254
571
  };
255
572
 
256
- if (window.basecoat) {
257
- window.basecoat.register('command', '.command:not([data-command-initialized])', initCommand);
258
- }
259
- })();
573
+ const closePopover = (state, focusInput = false) => {
574
+ if (state.popover.getAttribute('aria-hidden') === 'true') return;
575
+ state.popover.setAttribute('aria-hidden', 'true');
576
+ state.input.setAttribute('aria-expanded', 'false');
577
+ setActiveOption(state, -1);
578
+ if (focusInput) state.input.focus();
579
+ };
260
580
 
261
- (() => {
262
- const initDropdownMenu = (dropdownMenuComponent) => {
263
- const trigger = dropdownMenuComponent.querySelector(':scope > button');
264
- const popover = dropdownMenuComponent.querySelector(':scope > [data-popover]');
265
- const menu = popover.querySelector('[role="menu"]');
266
-
267
- if (!trigger || !menu || !popover) {
581
+ const refreshCombobox = (root) => {
582
+ const state = states.get(root);
583
+ if (!state) return;
584
+
585
+ const elements = getElements(root);
586
+ if (!elements.input || !elements.popover || !elements.listbox || !elements.hiddenInput) {
268
587
  const missing = [];
269
- if (!trigger) missing.push('trigger');
270
- if (!menu) missing.push('menu');
271
- if (!popover) missing.push('popover');
272
- console.error(`Dropdown menu initialisation failed. Missing element(s): ${missing.join(', ')}`, dropdownMenuComponent);
588
+ if (!elements.input) missing.push('input');
589
+ if (!elements.popover) missing.push('popover');
590
+ if (!elements.listbox) missing.push('listbox');
591
+ if (!elements.hiddenInput) missing.push('hidden input');
592
+ console.error(`Combobox refresh failed. Missing element(s): ${missing.join(', ')}`, root);
273
593
  return;
274
594
  }
275
595
 
276
- let menuItems = [];
277
- let activeIndex = -1;
596
+ const previousValue = elements.hiddenInput.value;
597
+ const previousInputValue = elements.input.value;
598
+ Object.assign(state, elements, getOptions(elements.listbox));
599
+ state.isMultiple = state.listbox.getAttribute('aria-multiselectable') === 'true';
600
+ state.closeOnSelect = root.dataset.closeOnSelect === 'true';
601
+ state.autoHighlight = root.dataset.autoHighlight === 'true';
602
+ state.manualFilter = root.dataset.filter === 'manual';
603
+ state.format = getFormat(root);
604
+
605
+ const stored = parseStoredSelection(previousValue, previousInputValue, state);
606
+ if (stored.length > 0) {
607
+ setSelected(root, stored, false);
608
+ } else {
609
+ const selectedOptions = state.options.filter(option => option.getAttribute('aria-selected') === 'true').map(toSelected);
610
+ if (selectedOptions.length > 0) {
611
+ setSelected(root, state.isMultiple ? selectedOptions : selectedOptions[0], false);
612
+ } else if (state.isMultiple) {
613
+ setSelected(root, [], false);
614
+ } else {
615
+ state.input.value = previousInputValue;
616
+ state.selected.clear();
617
+ state.hiddenInput.value = '';
618
+ syncSelectedOptions(state);
619
+ filterOptions(state, { preserveActive: true });
620
+ }
621
+ }
622
+ };
278
623
 
279
- const closePopover = (focusOnTrigger = true) => {
280
- if (trigger.getAttribute('aria-expanded') === 'false') return;
281
- trigger.setAttribute('aria-expanded', 'false');
282
- trigger.removeAttribute('aria-activedescendant');
283
- popover.setAttribute('aria-hidden', 'true');
284
-
285
- if (focusOnTrigger) {
286
- trigger.focus();
624
+ const resolveEntry = (state, value) => {
625
+ if (value && typeof value === 'object') {
626
+ const entry = normalizeEntry(value);
627
+ if (!entry) return null;
628
+ const option = state.options.find(opt => getValue(opt) === entry.value);
629
+ return option ? toSelected(option) : entry;
630
+ }
631
+
632
+ const option = state.options.find(opt => getValue(opt) === value);
633
+ if (option) return toSelected(option);
634
+ const existing = state.selected.get(String(value));
635
+ return existing || null;
636
+ };
637
+
638
+ const selectValue = (root, value) => {
639
+ const state = states.get(root);
640
+ const entry = resolveEntry(state, value);
641
+ if (!entry) return;
642
+
643
+ if (state.isMultiple) {
644
+ setSelected(root, [...getSelection(state).filter(item => item.value !== entry.value), entry]);
645
+ if (state.closeOnSelect) root.close(true);
646
+ } else {
647
+ setSelected(root, entry);
648
+ root.close(true);
649
+ }
650
+ };
651
+
652
+ const deselectValue = (root, value) => {
653
+ const state = states.get(root);
654
+ if (!state.isMultiple) return;
655
+ const normalized = String(value);
656
+ if (!state.selected.has(normalized)) return;
657
+ setSelected(root, getSelection(state).filter(item => item.value !== normalized));
658
+ };
659
+
660
+ const handleKeydown = (event, root) => {
661
+ const state = states.get(root);
662
+ if (!['ArrowDown', 'ArrowUp', 'Enter', 'Home', 'End', 'Escape', 'Backspace'].includes(event.key)) return;
663
+
664
+ const isOpen = state.popover.getAttribute('aria-hidden') === 'false';
665
+
666
+ if (event.key === 'Backspace' && state.isMultiple && state.input.value === '') {
667
+ const selected = getSelection(state);
668
+ const last = selected[selected.length - 1];
669
+ if (last) root.deselect(last.value);
670
+ return;
671
+ }
672
+
673
+ if (event.key === 'Escape') {
674
+ root.close(true);
675
+ return;
676
+ }
677
+
678
+ if (!isOpen && ['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key)) {
679
+ event.preventDefault();
680
+ root.open();
681
+ }
682
+
683
+ if (state.popover.getAttribute('aria-hidden') === 'true') return;
684
+
685
+ if (event.key === 'Enter') {
686
+ if (state.activeIndex > -1) {
687
+ event.preventDefault();
688
+ const option = state.options[state.activeIndex];
689
+ state.isMultiple ? root.toggle(getValue(option)) : root.select(getValue(option));
287
690
  }
288
-
289
- setActiveItem(-1);
691
+ return;
692
+ }
693
+
694
+ if (!['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key) || state.visibleOptions.length === 0) return;
695
+ event.preventDefault();
696
+
697
+ const currentVisibleIndex = state.activeIndex > -1 ? state.visibleOptions.indexOf(state.options[state.activeIndex]) : -1;
698
+ let nextVisibleIndex = currentVisibleIndex;
699
+
700
+ if (event.key === 'ArrowDown') nextVisibleIndex = Math.min(currentVisibleIndex + 1, state.visibleOptions.length - 1);
701
+ if (event.key === 'ArrowUp') nextVisibleIndex = currentVisibleIndex <= 0 ? 0 : currentVisibleIndex - 1;
702
+ if (event.key === 'Home') nextVisibleIndex = 0;
703
+ if (event.key === 'End') nextVisibleIndex = state.visibleOptions.length - 1;
704
+
705
+ const nextOption = state.visibleOptions[nextVisibleIndex];
706
+ setActiveOption(state, state.options.indexOf(nextOption));
707
+ scrollOptionIntoListbox(state, nextOption);
708
+ };
709
+
710
+ const initCombobox = (root) => {
711
+ if (root.dataset.comboboxInitialized) return;
712
+
713
+ const state = { root, activeIndex: -1, allOptions: [], options: [], visibleOptions: [], selected: new Map(), format: 'value', manualFilter: false };
714
+ states.set(root, state);
715
+ root.refresh = () => refreshCombobox(root);
716
+
717
+ refreshCombobox(root);
718
+ if (!state.input || !state.popover || !state.listbox || !state.hiddenInput) {
719
+ states.delete(root);
720
+ delete root.refresh;
721
+ return;
722
+ }
723
+
724
+ root.open = () => {
725
+ if (state.popover.getAttribute('aria-hidden') === 'false') return;
726
+ document.dispatchEvent(new CustomEvent('basecoat:popover', { detail: { source: root } }));
727
+ root.refresh();
728
+ filterOptions(state);
729
+ state.popover.setAttribute('aria-hidden', 'false');
730
+ state.input.setAttribute('aria-expanded', 'true');
731
+ };
732
+ root.close = (focusInput = false) => closePopover(state, focusInput);
733
+
734
+ root.select = (value) => selectValue(root, value);
735
+ root.selectByValue = root.select;
736
+ root.setValue = (value) => {
737
+ const entries = state.isMultiple ? (Array.isArray(value) ? value : (value == null ? [] : [value])) : [value];
738
+ const resolved = entries.map(entry => resolveEntry(state, entry) || normalizeEntry(entry)).filter(Boolean);
739
+ setSelected(root, state.isMultiple ? resolved : resolved[0]);
290
740
  };
741
+ if (state.isMultiple) {
742
+ root.deselect = (value) => deselectValue(root, value);
743
+ root.toggle = (value) => {
744
+ const entry = resolveEntry(state, value);
745
+ if (!entry) return;
746
+ state.selected.has(entry.value) ? root.deselect(entry.value) : root.select(entry);
747
+ };
748
+ root.selectAll = () => setSelected(root, state.options.map(toSelected));
749
+ root.selectNone = () => setSelected(root, []);
750
+ }
291
751
 
292
- const openPopover = (initialSelection = false) => {
293
- document.dispatchEvent(new CustomEvent('basecoat:popover', {
294
- detail: { source: dropdownMenuComponent }
295
- }));
296
-
297
- trigger.setAttribute('aria-expanded', 'true');
298
- popover.setAttribute('aria-hidden', 'false');
299
- menuItems = Array.from(menu.querySelectorAll('[role^="menuitem"]')).filter(item =>
300
- !item.hasAttribute('disabled') &&
301
- item.getAttribute('aria-disabled') !== 'true'
302
- );
303
-
304
- if (menuItems.length > 0 && initialSelection) {
305
- if (initialSelection === 'first') {
306
- setActiveItem(0);
307
- } else if (initialSelection === 'last') {
308
- setActiveItem(menuItems.length - 1);
309
- }
752
+ const handleInputFocus = root.open;
753
+ const handleInputClick = root.open;
754
+ const handleInput = () => {
755
+ root.open();
756
+ filterOptions(state);
757
+ if (!state.isMultiple) {
758
+ state.hiddenInput.value = '';
759
+ state.selected.clear();
760
+ syncSelectedOptions(state);
310
761
  }
311
762
  };
763
+ const handleInputKeydown = (event) => handleKeydown(event, root);
764
+ const handleListboxMousemove = (event) => {
765
+ const option = event.target.closest('[role="option"]');
766
+ if (option && state.visibleOptions.includes(option)) setActiveOption(state, state.options.indexOf(option));
767
+ };
768
+ const handleListboxClick = (event) => {
769
+ const option = event.target.closest('[role="option"]');
770
+ if (!option || !state.options.includes(option)) return;
771
+ state.isMultiple ? root.toggle(getValue(option)) : root.select(getValue(option));
772
+ if (state.isMultiple && !state.closeOnSelect) state.input.focus();
773
+ };
774
+ const handleDocumentClick = (event) => {
775
+ if (!root.contains(event.target)) root.close(false);
776
+ };
777
+ const handleDocumentPopover = (event) => {
778
+ if (event.detail.source !== root) root.close(false);
779
+ };
312
780
 
313
- const setActiveItem = (index) => {
314
- if (activeIndex > -1 && menuItems[activeIndex]) {
315
- menuItems[activeIndex].classList.remove('active');
316
- }
317
- activeIndex = index;
318
- if (activeIndex > -1 && menuItems[activeIndex]) {
319
- const activeItem = menuItems[activeIndex];
320
- activeItem.classList.add('active');
321
- trigger.setAttribute('aria-activedescendant', activeItem.id);
322
- } else {
323
- trigger.removeAttribute('aria-activedescendant');
324
- }
781
+ state.input.addEventListener('focus', handleInputFocus);
782
+ state.input.addEventListener('click', handleInputClick);
783
+ state.input.addEventListener('input', handleInput);
784
+ state.input.addEventListener('keydown', handleInputKeydown);
785
+ state.listbox.addEventListener('mousemove', handleListboxMousemove);
786
+ state.listbox.addEventListener('click', handleListboxClick);
787
+ document.addEventListener('click', handleDocumentClick);
788
+ document.addEventListener('basecoat:popover', handleDocumentPopover);
789
+
790
+ root._destroy = () => {
791
+ state.input.removeEventListener('focus', handleInputFocus);
792
+ state.input.removeEventListener('click', handleInputClick);
793
+ state.input.removeEventListener('input', handleInput);
794
+ state.input.removeEventListener('keydown', handleInputKeydown);
795
+ state.listbox.removeEventListener('mousemove', handleListboxMousemove);
796
+ state.listbox.removeEventListener('click', handleListboxClick);
797
+ document.removeEventListener('click', handleDocumentClick);
798
+ document.removeEventListener('basecoat:popover', handleDocumentPopover);
799
+ state.chips?.querySelectorAll('.combobox-chip').forEach(chip => chip.remove());
800
+ states.delete(root);
801
+ delete root.refresh;
802
+ delete root.open;
803
+ delete root.close;
804
+ delete root.select;
805
+ delete root.selectByValue;
806
+ delete root.setValue;
807
+ delete root.deselect;
808
+ delete root.toggle;
809
+ delete root.selectAll;
810
+ delete root.selectNone;
325
811
  };
326
812
 
327
- trigger.addEventListener('click', () => {
328
- const isExpanded = trigger.getAttribute('aria-expanded') === 'true';
329
- if (isExpanded) {
330
- closePopover();
331
- } else {
332
- openPopover(false);
333
- }
813
+ state.popover.setAttribute('aria-hidden', 'true');
814
+ state.input.setAttribute('aria-expanded', 'false');
815
+
816
+ Object.defineProperty(root, 'value', {
817
+ configurable: true,
818
+ get: () => getCanonicalValue(state),
819
+ set: (value) => root.setValue(value),
334
820
  });
335
821
 
336
- dropdownMenuComponent.addEventListener('keydown', (event) => {
337
- const isExpanded = trigger.getAttribute('aria-expanded') === 'true';
822
+ Object.defineProperty(root, 'selected', {
823
+ configurable: true,
824
+ get: () => getSelectedDetail(state),
825
+ });
826
+
827
+ root.dataset.comboboxInitialized = 'true';
828
+ root.dispatchEvent(new CustomEvent('basecoat:initialized'));
829
+ };
830
+
831
+ if (window.basecoat) {
832
+ window.basecoat.register('combobox', {
833
+ selector: '.combobox:not([data-combobox-initialized])',
834
+ init: initCombobox,
835
+ refresh: refreshCombobox,
836
+ });
837
+ }
838
+ })();
839
+
840
+ (() => {
841
+ const states = new WeakMap();
842
+
843
+ const isDisabled = (item) =>
844
+ item.hasAttribute('disabled') || item.getAttribute('aria-disabled') === 'true';
845
+
846
+ const getElements = (root) => {
847
+ const trigger = root.querySelector(':scope > button');
848
+ const popover = root.querySelector(':scope > [data-popover]');
849
+ const menu = popover ? popover.querySelector('[role="menu"]') : null;
850
+ return { trigger, popover, menu };
851
+ };
852
+
853
+ const getItems = (menu) => Array.from(menu.querySelectorAll('[role^="menuitem"]')).filter(item => !isDisabled(item));
854
+
855
+ const setActiveItem = (state, index) => {
856
+ if (state.activeIndex > -1 && state.items[state.activeIndex]) {
857
+ state.items[state.activeIndex].classList.remove('active');
858
+ }
859
+ state.activeIndex = index;
860
+ if (state.activeIndex > -1 && state.items[state.activeIndex]) {
861
+ const activeItem = state.items[state.activeIndex];
862
+ activeItem.classList.add('active');
863
+ if (activeItem.id) state.trigger.setAttribute('aria-activedescendant', activeItem.id);
864
+ } else {
865
+ state.trigger.removeAttribute('aria-activedescendant');
866
+ }
867
+ };
868
+
869
+ const refreshDropdownMenu = (root) => {
870
+ const state = states.get(root);
871
+ if (!state) return;
872
+
873
+ const elements = getElements(root);
874
+ if (!elements.trigger || !elements.popover || !elements.menu) {
875
+ const missing = [];
876
+ if (!elements.trigger) missing.push('trigger');
877
+ if (!elements.popover) missing.push('popover');
878
+ if (!elements.menu) missing.push('menu');
879
+ console.error(`Dropdown menu refresh failed. Missing element(s): ${missing.join(', ')}`, root);
880
+ return;
881
+ }
882
+
883
+ Object.assign(state, elements);
884
+ state.items = getItems(state.menu);
885
+ if (state.activeIndex > -1 && !state.items[state.activeIndex]) setActiveItem(state, -1);
886
+ };
887
+
888
+ const closePopover = (state, focusOnTrigger = true) => {
889
+ if (state.trigger.getAttribute('aria-expanded') === 'false') return;
890
+ state.trigger.setAttribute('aria-expanded', 'false');
891
+ state.trigger.removeAttribute('aria-activedescendant');
892
+ state.popover.setAttribute('aria-hidden', 'true');
893
+ if (focusOnTrigger) state.trigger.focus();
894
+ setActiveItem(state, -1);
895
+ };
896
+
897
+ const openPopover = (root, state, initialSelection = false) => {
898
+ document.dispatchEvent(new CustomEvent('basecoat:popover', { detail: { source: root } }));
899
+ root.refresh();
900
+ state.trigger.setAttribute('aria-expanded', 'true');
901
+ state.popover.setAttribute('aria-hidden', 'false');
902
+
903
+ if (state.items.length > 0 && initialSelection) {
904
+ setActiveItem(state, initialSelection === 'last' ? state.items.length - 1 : 0);
905
+ }
906
+ };
907
+
908
+ const initDropdownMenu = (root) => {
909
+ if (root.dataset.dropdownMenuInitialized) return;
910
+
911
+ const state = { activeIndex: -1, items: [] };
912
+ states.set(root, state);
913
+ root.refresh = () => refreshDropdownMenu(root);
914
+
915
+ refreshDropdownMenu(root);
916
+ if (!state.trigger || !state.popover || !state.menu) {
917
+ states.delete(root);
918
+ delete root.refresh;
919
+ return;
920
+ }
921
+
922
+ root.open = (initialSelection = false) => openPopover(root, state, initialSelection);
923
+ root.close = (focusOnTrigger = true) => closePopover(state, focusOnTrigger);
924
+ root.toggle = () => state.trigger.getAttribute('aria-expanded') === 'true' ? root.close() : root.open(false);
925
+
926
+ const handleTriggerClick = root.toggle;
927
+
928
+ const handleKeydown = (event) => {
929
+ const isExpanded = state.trigger.getAttribute('aria-expanded') === 'true';
338
930
 
339
931
  if (event.key === 'Escape') {
340
- if (isExpanded) closePopover();
932
+ if (isExpanded) root.close();
341
933
  return;
342
934
  }
343
-
935
+
344
936
  if (!isExpanded) {
345
937
  if (['Enter', ' '].includes(event.key)) {
346
938
  event.preventDefault();
347
- openPopover(false);
939
+ root.open(false);
348
940
  } else if (event.key === 'ArrowDown') {
349
941
  event.preventDefault();
350
- openPopover('first');
942
+ root.open('first');
351
943
  } else if (event.key === 'ArrowUp') {
352
944
  event.preventDefault();
353
- openPopover('last');
945
+ root.open('last');
354
946
  }
355
947
  return;
356
948
  }
357
949
 
358
- if (menuItems.length === 0) return;
359
-
360
- let nextIndex = activeIndex;
950
+ if (state.items.length === 0) return;
361
951
 
362
- switch (event.key) {
363
- case 'ArrowDown':
364
- event.preventDefault();
365
- nextIndex = activeIndex === -1 ? 0 : Math.min(activeIndex + 1, menuItems.length - 1);
366
- break;
367
- case 'ArrowUp':
368
- event.preventDefault();
369
- nextIndex = activeIndex === -1 ? menuItems.length - 1 : Math.max(activeIndex - 1, 0);
370
- break;
371
- case 'Home':
372
- event.preventDefault();
373
- nextIndex = 0;
374
- break;
375
- case 'End':
376
- event.preventDefault();
377
- nextIndex = menuItems.length - 1;
378
- break;
379
- case 'Enter':
380
- case ' ':
381
- event.preventDefault();
382
- menuItems[activeIndex]?.click();
383
- closePopover();
384
- return;
952
+ let nextIndex = state.activeIndex;
953
+ if (event.key === 'ArrowDown') {
954
+ event.preventDefault();
955
+ nextIndex = state.activeIndex === -1 ? 0 : Math.min(state.activeIndex + 1, state.items.length - 1);
956
+ } else if (event.key === 'ArrowUp') {
957
+ event.preventDefault();
958
+ nextIndex = state.activeIndex === -1 ? state.items.length - 1 : Math.max(state.activeIndex - 1, 0);
959
+ } else if (event.key === 'Home') {
960
+ event.preventDefault();
961
+ nextIndex = 0;
962
+ } else if (event.key === 'End') {
963
+ event.preventDefault();
964
+ nextIndex = state.items.length - 1;
965
+ } else if (['Enter', ' '].includes(event.key)) {
966
+ event.preventDefault();
967
+ state.items[state.activeIndex]?.click();
968
+ root.close();
969
+ return;
970
+ } else {
971
+ return;
385
972
  }
386
973
 
387
- if (nextIndex !== activeIndex) {
388
- setActiveItem(nextIndex);
389
- }
390
- });
974
+ if (nextIndex !== state.activeIndex) setActiveItem(state, nextIndex);
975
+ };
391
976
 
392
- menu.addEventListener('mousemove', (event) => {
977
+ const handleMenuMousemove = (event) => {
393
978
  const menuItem = event.target.closest('[role^="menuitem"]');
394
- if (menuItem && menuItems.includes(menuItem)) {
395
- const index = menuItems.indexOf(menuItem);
396
- if (index !== activeIndex) {
397
- setActiveItem(index);
398
- }
979
+ if (menuItem && !isDisabled(menuItem) && state.items.includes(menuItem)) {
980
+ const index = state.items.indexOf(menuItem);
981
+ if (index !== state.activeIndex) setActiveItem(state, index);
399
982
  }
400
- });
983
+ };
401
984
 
402
- menu.addEventListener('mouseleave', () => {
403
- setActiveItem(-1);
404
- });
985
+ const handleMenuMouseleave = () => setActiveItem(state, -1);
986
+ const handleMenuClick = (event) => {
987
+ const menuItem = event.target.closest('[role^="menuitem"]');
988
+ if (menuItem && !isDisabled(menuItem)) root.close();
989
+ };
405
990
 
406
- menu.addEventListener('click', (event) => {
407
- if (event.target.closest('[role^="menuitem"]')) {
408
- closePopover();
409
- }
410
- });
991
+ const handleDocumentClick = (event) => {
992
+ if (!root.contains(event.target)) root.close(false);
993
+ };
411
994
 
412
- document.addEventListener('click', (event) => {
413
- if (!dropdownMenuComponent.contains(event.target)) {
414
- closePopover();
415
- }
416
- });
995
+ const handleDocumentPopover = (event) => {
996
+ if (event.detail.source !== root) root.close(false);
997
+ };
417
998
 
418
- document.addEventListener('basecoat:popover', (event) => {
419
- if (event.detail.source !== dropdownMenuComponent) {
420
- closePopover(false);
421
- }
422
- });
999
+ state.trigger.addEventListener('click', handleTriggerClick);
1000
+ root.addEventListener('keydown', handleKeydown);
1001
+ state.menu.addEventListener('mousemove', handleMenuMousemove);
1002
+ state.menu.addEventListener('mouseleave', handleMenuMouseleave);
1003
+ state.menu.addEventListener('click', handleMenuClick);
1004
+ document.addEventListener('click', handleDocumentClick);
1005
+ document.addEventListener('basecoat:popover', handleDocumentPopover);
1006
+
1007
+ root._destroy = () => {
1008
+ state.trigger.removeEventListener('click', handleTriggerClick);
1009
+ root.removeEventListener('keydown', handleKeydown);
1010
+ state.menu.removeEventListener('mousemove', handleMenuMousemove);
1011
+ state.menu.removeEventListener('mouseleave', handleMenuMouseleave);
1012
+ state.menu.removeEventListener('click', handleMenuClick);
1013
+ document.removeEventListener('click', handleDocumentClick);
1014
+ document.removeEventListener('basecoat:popover', handleDocumentPopover);
1015
+ states.delete(root);
1016
+ delete root.refresh;
1017
+ delete root.open;
1018
+ delete root.close;
1019
+ delete root.toggle;
1020
+ };
423
1021
 
424
- dropdownMenuComponent.dataset.dropdownMenuInitialized = true;
425
- dropdownMenuComponent.dispatchEvent(new CustomEvent('basecoat:initialized'));
1022
+ state.trigger.setAttribute('aria-expanded', 'false');
1023
+ state.popover.setAttribute('aria-hidden', 'true');
1024
+ root.dataset.dropdownMenuInitialized = 'true';
1025
+ root.dispatchEvent(new CustomEvent('basecoat:initialized'));
426
1026
  };
427
1027
 
428
1028
  if (window.basecoat) {
429
- window.basecoat.register('dropdown-menu', '.dropdown-menu:not([data-dropdown-menu-initialized])', initDropdownMenu);
1029
+ window.basecoat.register('dropdown-menu', {
1030
+ selector: '.dropdown-menu:not([data-dropdown-menu-initialized])',
1031
+ init: initDropdownMenu,
1032
+ refresh: refreshDropdownMenu,
1033
+ });
430
1034
  }
431
1035
  })();
1036
+
432
1037
  (() => {
433
1038
  const initPopover = (popoverComponent) => {
1039
+ if (popoverComponent.dataset.popoverInitialized) return;
1040
+
434
1041
  const trigger = popoverComponent.querySelector(':scope > button');
435
1042
  const content = popoverComponent.querySelector(':scope > [data-popover]');
436
1043
 
@@ -467,32 +1074,44 @@
467
1074
  content.setAttribute('aria-hidden', 'false');
468
1075
  };
469
1076
 
470
- trigger.addEventListener('click', () => {
1077
+ const handleTriggerClick = () => {
471
1078
  const isExpanded = trigger.getAttribute('aria-expanded') === 'true';
472
1079
  if (isExpanded) {
473
1080
  closePopover();
474
1081
  } else {
475
1082
  openPopover();
476
1083
  }
477
- });
1084
+ };
478
1085
 
479
- popoverComponent.addEventListener('keydown', (event) => {
1086
+ const handleKeydown = (event) => {
480
1087
  if (event.key === 'Escape') {
481
1088
  closePopover();
482
1089
  }
483
- });
1090
+ };
484
1091
 
485
- document.addEventListener('click', (event) => {
1092
+ const handleDocumentClick = (event) => {
486
1093
  if (!popoverComponent.contains(event.target)) {
487
1094
  closePopover();
488
1095
  }
489
- });
1096
+ };
490
1097
 
491
- document.addEventListener('basecoat:popover', (event) => {
1098
+ const handleDocumentPopover = (event) => {
492
1099
  if (event.detail.source !== popoverComponent) {
493
1100
  closePopover(false);
494
1101
  }
495
- });
1102
+ };
1103
+
1104
+ trigger.addEventListener('click', handleTriggerClick);
1105
+ popoverComponent.addEventListener('keydown', handleKeydown);
1106
+ document.addEventListener('click', handleDocumentClick);
1107
+ document.addEventListener('basecoat:popover', handleDocumentPopover);
1108
+
1109
+ popoverComponent._destroy = () => {
1110
+ trigger.removeEventListener('click', handleTriggerClick);
1111
+ popoverComponent.removeEventListener('keydown', handleKeydown);
1112
+ document.removeEventListener('click', handleDocumentClick);
1113
+ document.removeEventListener('basecoat:popover', handleDocumentPopover);
1114
+ };
496
1115
 
497
1116
  popoverComponent.dataset.popoverInitialized = true;
498
1117
  popoverComponent.dispatchEvent(new CustomEvent('basecoat:initialized'));
@@ -504,458 +1123,474 @@
504
1123
  })();
505
1124
 
506
1125
  (() => {
507
- const initSelect = (selectComponent) => {
508
- const trigger = selectComponent.querySelector(':scope > button');
509
- const selectedLabel = trigger.querySelector(':scope > span');
510
- const popover = selectComponent.querySelector(':scope > [data-popover]');
511
- const listbox = popover ? popover.querySelector('[role="listbox"]') : null;
512
- const input = selectComponent.querySelector(':scope > input[type="hidden"]');
513
- const filter = selectComponent.querySelector('header input[type="text"]');
1126
+ function updateRange(element) {
1127
+ const min = parseFloat(element.min || '0');
1128
+ const max = parseFloat(element.max || '100');
1129
+ const value = parseFloat(element.value || '0');
1130
+ const percent = max === min ? 0 : ((value - min) / (max - min)) * 100;
1131
+ element.style.setProperty('--slider-value', `${percent}%`);
1132
+ }
514
1133
 
515
- if (!trigger || !popover || !listbox || !input) {
516
- const missing = [];
517
- if (!trigger) missing.push('trigger');
518
- if (!popover) missing.push('popover');
519
- if (!listbox) missing.push('listbox');
520
- if (!input) missing.push('input');
521
- console.error(`Select component initialisation failed. Missing element(s): ${missing.join(', ')}`, selectComponent);
522
- return;
523
- }
1134
+ function initRange(element) {
1135
+ if (element.dataset.rangeInitialized) return;
524
1136
 
525
- const allOptions = Array.from(listbox.querySelectorAll('[role="option"]'));
526
- const options = allOptions.filter(opt => opt.getAttribute('aria-disabled') !== 'true');
527
- let visibleOptions = [...options];
528
- let activeIndex = -1;
529
- const isMultiple = listbox.getAttribute('aria-multiselectable') === 'true';
530
- const selectedOptions = isMultiple ? new Set() : null;
531
- const placeholder = isMultiple ? (selectComponent.dataset.placeholder || '') : null;
532
- const closeOnSelect = selectComponent.dataset.closeOnSelect === 'true';
533
-
534
- const getValue = (opt) => opt.dataset.value ?? opt.textContent.trim();
535
-
536
- const setActiveOption = (index) => {
537
- if (activeIndex > -1 && options[activeIndex]) {
538
- options[activeIndex].classList.remove('active');
539
- }
1137
+ updateRange(element);
1138
+ const handleInput = () => updateRange(element);
1139
+ element.addEventListener('input', handleInput);
1140
+ element._destroy = () => {
1141
+ element.removeEventListener('input', handleInput);
1142
+ };
1143
+ element.dataset.rangeInitialized = 'true';
1144
+ }
540
1145
 
541
- activeIndex = index;
1146
+ if (window.basecoat) {
1147
+ window.basecoat.register('range', 'input[type="range"]:not([data-range-initialized])', initRange);
1148
+ }
1149
+ })();
542
1150
 
543
- if (activeIndex > -1) {
544
- const activeOption = options[activeIndex];
545
- activeOption.classList.add('active');
546
- if (activeOption.id) {
547
- trigger.setAttribute('aria-activedescendant', activeOption.id);
548
- } else {
549
- trigger.removeAttribute('aria-activedescendant');
550
- }
551
- } else {
552
- trigger.removeAttribute('aria-activedescendant');
553
- }
554
- };
1151
+ (() => {
1152
+ const states = new WeakMap();
555
1153
 
556
- const hasTransition = () => {
557
- const style = getComputedStyle(popover);
558
- return parseFloat(style.transitionDuration) > 0 || parseFloat(style.transitionDelay) > 0;
559
- };
1154
+ const getElements = (root) => {
1155
+ const trigger = root.querySelector(':scope > button');
1156
+ const selectedLabel = trigger?.querySelector(':scope > span') || null;
1157
+ const popover = root.querySelector(':scope > [data-popover]');
1158
+ const listbox = popover ? popover.querySelector('[role="listbox"]') : null;
1159
+ const input = root.querySelector(':scope > input[type="hidden"]');
1160
+ return { trigger, selectedLabel, popover, listbox, input };
1161
+ };
560
1162
 
561
- const updateValue = (optionOrOptions, triggerEvent = true) => {
562
- let value;
1163
+ const getValue = (option) => option.dataset.value ?? option.textContent.trim();
1164
+ const getLabel = (option) => option.dataset.label || option.textContent.trim();
1165
+ const getFormat = (root) => root.dataset.format === 'object' ? 'object' : 'value';
1166
+ const isDisabled = (option) => option.getAttribute('aria-disabled') === 'true';
1167
+ const toSelected = (option) => ({ value: getValue(option), label: getLabel(option) });
563
1168
 
564
- if (isMultiple) {
565
- const opts = Array.isArray(optionOrOptions) ? optionOrOptions : [];
566
- selectedOptions.clear();
567
- opts.forEach(opt => selectedOptions.add(opt));
1169
+ const getOptions = (listbox) => {
1170
+ const allOptions = Array.from(listbox.querySelectorAll('[role="option"]'));
1171
+ return {
1172
+ allOptions,
1173
+ options: allOptions.filter(option => !isDisabled(option)),
1174
+ };
1175
+ };
568
1176
 
569
- // Get selected options in DOM order
570
- const selected = options.filter(opt => selectedOptions.has(opt));
571
- if (selected.length === 0) {
572
- selectedLabel.textContent = placeholder;
573
- selectedLabel.classList.add('text-muted-foreground');
574
- } else {
575
- selectedLabel.textContent = selected.map(opt => opt.dataset.label || opt.textContent.trim()).join(', ');
576
- selectedLabel.classList.remove('text-muted-foreground');
577
- }
1177
+ const parseStoredValues = (storedValue, { isMultiple, format }) => {
1178
+ if (isMultiple) {
1179
+ try {
1180
+ const parsed = JSON.parse(storedValue || '[]');
1181
+ if (!Array.isArray(parsed)) return [];
1182
+ return parsed
1183
+ .map(item => format === 'object' && item && typeof item === 'object' ? item.value : item)
1184
+ .filter(value => value != null)
1185
+ .map(String);
1186
+ } catch (_) {
1187
+ return [];
1188
+ }
1189
+ }
578
1190
 
579
- value = selected.map(getValue);
580
- input.value = JSON.stringify(value);
581
- } else {
582
- const option = optionOrOptions;
583
- if (!option) return;
584
- selectedLabel.innerHTML = option.innerHTML;
585
- value = getValue(option);
586
- input.value = value;
1191
+ if (format === 'object') {
1192
+ try {
1193
+ const parsed = JSON.parse(storedValue || 'null');
1194
+ return parsed && typeof parsed === 'object' && parsed.value != null ? String(parsed.value) : '';
1195
+ } catch (_) {
1196
+ return '';
587
1197
  }
1198
+ }
588
1199
 
589
- options.forEach(opt => {
590
- const isSelected = isMultiple ? selectedOptions.has(opt) : opt === optionOrOptions;
591
- if (isSelected) {
592
- opt.setAttribute('aria-selected', 'true');
593
- } else {
594
- opt.removeAttribute('aria-selected');
595
- }
596
- });
1200
+ return storedValue || '';
1201
+ };
597
1202
 
598
- if (triggerEvent) {
599
- selectComponent.dispatchEvent(new CustomEvent('change', {
600
- detail: { value },
601
- bubbles: true
602
- }));
603
- }
604
- };
1203
+ const serializeSelection = (state, selected) => {
1204
+ if (state.format === 'object') {
1205
+ return JSON.stringify(state.isMultiple ? selected : (selected[0] || null));
1206
+ }
605
1207
 
606
- const closePopover = (focusOnTrigger = true) => {
607
- if (popover.getAttribute('aria-hidden') === 'true') return;
1208
+ const value = selected.map(item => item.value);
1209
+ return state.isMultiple ? JSON.stringify(value) : (value[0] || '');
1210
+ };
608
1211
 
609
- if (filter) {
610
- const resetFilter = () => {
611
- filter.value = '';
612
- visibleOptions = [...options];
613
- allOptions.forEach(opt => opt.setAttribute('aria-hidden', 'false'));
614
- };
1212
+ const scrollOptionIntoListbox = (state, option) => {
1213
+ const optionRect = option.getBoundingClientRect();
1214
+ const listboxRect = state.listbox.getBoundingClientRect();
615
1215
 
616
- if (hasTransition()) {
617
- popover.addEventListener('transitionend', resetFilter, { once: true });
618
- } else {
619
- resetFilter();
620
- }
621
- }
1216
+ if (optionRect.top < listboxRect.top) {
1217
+ state.listbox.scrollTop -= listboxRect.top - optionRect.top;
1218
+ } else if (optionRect.bottom > listboxRect.bottom) {
1219
+ state.listbox.scrollTop += optionRect.bottom - listboxRect.bottom;
1220
+ }
1221
+ };
622
1222
 
623
- if (focusOnTrigger) trigger.focus();
624
- popover.setAttribute('aria-hidden', 'true');
625
- trigger.setAttribute('aria-expanded', 'false');
626
- setActiveOption(-1);
627
- };
1223
+ const setActiveOption = (state, index) => {
1224
+ if (state.activeIndex > -1 && state.options[state.activeIndex]) {
1225
+ state.options[state.activeIndex].classList.remove('active');
1226
+ }
1227
+
1228
+ state.activeIndex = index;
628
1229
 
629
- const toggleMultipleValue = (option) => {
630
- if (selectedOptions.has(option)) {
631
- selectedOptions.delete(option);
1230
+ if (state.activeIndex > -1) {
1231
+ const activeOption = state.options[state.activeIndex];
1232
+ activeOption.classList.add('active');
1233
+ if (activeOption.id) {
1234
+ state.trigger.setAttribute('aria-activedescendant', activeOption.id);
632
1235
  } else {
633
- selectedOptions.add(option);
1236
+ state.trigger.removeAttribute('aria-activedescendant');
634
1237
  }
635
- updateValue(options.filter(opt => selectedOptions.has(opt)));
636
- };
1238
+ } else {
1239
+ state.trigger.removeAttribute('aria-activedescendant');
1240
+ }
1241
+ };
637
1242
 
638
- const select = (value) => {
639
- if (isMultiple) {
640
- const option = options.find(opt => getValue(opt) === value && !selectedOptions.has(opt));
641
- if (!option) return;
642
- selectedOptions.add(option);
643
- updateValue(options.filter(opt => selectedOptions.has(opt)));
1243
+ const updateValue = (root, optionOrOptions, triggerEvent = true) => {
1244
+ const state = states.get(root);
1245
+ let value;
1246
+ let selectedDetail;
1247
+
1248
+ if (state.isMultiple) {
1249
+ const selected = Array.isArray(optionOrOptions) ? optionOrOptions : [];
1250
+ state.selectedOptions.clear();
1251
+ selected.forEach(option => state.selectedOptions.add(option));
1252
+
1253
+ const selectedInOrder = state.options.filter(option => state.selectedOptions.has(option));
1254
+ selectedDetail = selectedInOrder.map(toSelected);
1255
+ if (selectedInOrder.length === 0) {
1256
+ state.selectedLabel.textContent = state.placeholder;
1257
+ state.selectedLabel.classList.add('text-muted-foreground');
644
1258
  } else {
645
- const option = options.find(opt => getValue(opt) === value);
646
- if (!option) return;
647
- if (input.value !== value) {
648
- updateValue(option);
649
- }
650
- closePopover();
1259
+ state.selectedLabel.textContent = selectedDetail.map(item => item.label).join(', ');
1260
+ state.selectedLabel.classList.remove('text-muted-foreground');
651
1261
  }
652
- };
653
1262
 
654
- const deselect = (value) => {
655
- if (!isMultiple) return;
656
- const option = options.find(opt => getValue(opt) === value && selectedOptions.has(opt));
1263
+ value = selectedDetail.map(item => item.value);
1264
+ state.input.value = serializeSelection(state, selectedDetail);
1265
+ } else {
1266
+ const option = optionOrOptions;
657
1267
  if (!option) return;
658
- selectedOptions.delete(option);
659
- updateValue(options.filter(opt => selectedOptions.has(opt)));
660
- };
1268
+ state.selectedLabel.innerHTML = option.innerHTML;
1269
+ selectedDetail = toSelected(option);
1270
+ value = selectedDetail.value;
1271
+ state.input.value = serializeSelection(state, [selectedDetail]);
1272
+ }
661
1273
 
662
- const toggle = (value) => {
663
- if (!isMultiple) return;
664
- const option = options.find(opt => getValue(opt) === value);
665
- if (!option) return;
666
- toggleMultipleValue(option);
667
- };
1274
+ state.options.forEach(option => {
1275
+ const isSelected = state.isMultiple ? state.selectedOptions.has(option) : option === optionOrOptions;
1276
+ if (isSelected) {
1277
+ option.setAttribute('aria-selected', 'true');
1278
+ } else {
1279
+ option.removeAttribute('aria-selected');
1280
+ }
1281
+ });
668
1282
 
669
- if (filter) {
670
- const filterOptions = () => {
671
- const searchTerm = filter.value.trim().toLowerCase();
1283
+ if (triggerEvent) {
1284
+ root.dispatchEvent(new CustomEvent('change', {
1285
+ detail: { value, selected: selectedDetail },
1286
+ bubbles: true,
1287
+ }));
1288
+ }
1289
+ };
672
1290
 
673
- setActiveOption(-1);
1291
+ const closePopover = (state, focusOnTrigger = true) => {
1292
+ if (state.popover.getAttribute('aria-hidden') === 'true') return;
1293
+ if (focusOnTrigger) state.trigger.focus();
1294
+ state.popover.setAttribute('aria-hidden', 'true');
1295
+ state.trigger.setAttribute('aria-expanded', 'false');
1296
+ setActiveOption(state, -1);
1297
+ };
674
1298
 
675
- visibleOptions = [];
676
- allOptions.forEach(option => {
677
- if (option.hasAttribute('data-force')) {
678
- option.setAttribute('aria-hidden', 'false');
679
- if (options.includes(option)) {
680
- visibleOptions.push(option);
681
- }
682
- return;
683
- }
1299
+ const refreshSelect = (root) => {
1300
+ const state = states.get(root);
1301
+ if (!state) return;
684
1302
 
685
- const optionText = (option.dataset.filter || option.textContent).trim().toLowerCase();
686
- const keywordList = (option.dataset.keywords || '')
687
- .toLowerCase()
688
- .split(/[\s,]+/)
689
- .filter(Boolean);
690
- const matchesKeyword = keywordList.some(keyword => keyword.includes(searchTerm));
691
- const matches = optionText.includes(searchTerm) || matchesKeyword;
692
- option.setAttribute('aria-hidden', String(!matches));
693
- if (matches && options.includes(option)) {
694
- visibleOptions.push(option);
695
- }
696
- });
697
- };
1303
+ const elements = getElements(root);
1304
+ if (!elements.trigger || !elements.selectedLabel || !elements.popover || !elements.listbox || !elements.input) {
1305
+ const missing = [];
1306
+ if (!elements.trigger) missing.push('trigger');
1307
+ if (!elements.selectedLabel) missing.push('selected label');
1308
+ if (!elements.popover) missing.push('popover');
1309
+ if (!elements.listbox) missing.push('listbox');
1310
+ if (!elements.input) missing.push('input');
1311
+ console.error(`Select component refresh failed. Missing element(s): ${missing.join(', ')}`, root);
1312
+ return;
1313
+ }
698
1314
 
699
- filter.addEventListener('input', filterOptions);
1315
+ const previousValue = elements.input.value;
1316
+ Object.assign(state, elements, getOptions(elements.listbox));
1317
+ state.visibleOptions = [...state.options];
1318
+ state.isMultiple = state.listbox.getAttribute('aria-multiselectable') === 'true';
1319
+ state.format = getFormat(root);
1320
+ state.placeholder = state.isMultiple ? (root.dataset.placeholder || '') : null;
1321
+ state.closeOnSelect = root.dataset.closeOnSelect === 'true';
1322
+
1323
+ if (state.isMultiple) {
1324
+ if (!state.selectedOptions) state.selectedOptions = new Set();
1325
+ const values = parseStoredValues(previousValue, state);
1326
+ const selected = values.length
1327
+ ? values.map(value => state.options.find(option => getValue(option) === value)).filter(Boolean)
1328
+ : state.options.filter(option => option.getAttribute('aria-selected') === 'true');
1329
+ updateValue(root, selected, false);
1330
+ } else {
1331
+ const value = parseStoredValues(previousValue, state);
1332
+ const selected = state.options.find(option => getValue(option) === value)
1333
+ || state.options.find(option => option.getAttribute('aria-selected') === 'true');
1334
+ state.options.forEach(option => option.removeAttribute('aria-selected'));
1335
+ if (selected) updateValue(root, selected, false);
700
1336
  }
701
1337
 
702
- // Initialization
703
- if (isMultiple) {
704
- const ariaSelected = options.filter(opt => opt.getAttribute('aria-selected') === 'true');
705
- try {
706
- const parsed = JSON.parse(input.value || '[]');
707
- const validValues = new Set(options.map(getValue));
708
- const initialValues = Array.isArray(parsed) ? parsed.filter(v => validValues.has(v)) : [];
709
-
710
- const initialOptions = [];
711
- if (initialValues.length > 0) {
712
- // Match values to options in order, allowing duplicates
713
- initialValues.forEach(val => {
714
- const opt = options.find(o => getValue(o) === val && !initialOptions.includes(o));
715
- if (opt) initialOptions.push(opt);
716
- });
717
- } else {
718
- initialOptions.push(...ariaSelected);
719
- }
1338
+ const selectedOption = state.listbox.querySelector('[role="option"][aria-selected="true"]');
1339
+ setActiveOption(state, selectedOption ? state.options.indexOf(selectedOption) : -1);
1340
+ };
720
1341
 
721
- updateValue(initialOptions, false);
722
- } catch (e) {
723
- updateValue(ariaSelected, false);
724
- }
1342
+ const toggleMultipleValue = (root, option) => {
1343
+ const state = states.get(root);
1344
+ if (state.selectedOptions.has(option)) {
1345
+ state.selectedOptions.delete(option);
725
1346
  } else {
726
- const initialOption = options.find(opt => getValue(opt) === input.value) || options[0];
727
- if (initialOption) updateValue(initialOption, false);
1347
+ state.selectedOptions.add(option);
728
1348
  }
1349
+ updateValue(root, state.options.filter(opt => state.selectedOptions.has(opt)));
1350
+ };
729
1351
 
730
- const handleKeyNavigation = (event) => {
731
- const isPopoverOpen = popover.getAttribute('aria-hidden') === 'false';
732
-
733
- if (!['ArrowDown', 'ArrowUp', 'Enter', 'Home', 'End', 'Escape'].includes(event.key)) {
734
- return;
735
- }
1352
+ const selectValue = (root, value) => {
1353
+ const state = states.get(root);
1354
+ if (state.isMultiple) {
1355
+ const option = state.options.find(opt => getValue(opt) === value && !state.selectedOptions.has(opt));
1356
+ if (!option) return;
1357
+ state.selectedOptions.add(option);
1358
+ updateValue(root, state.options.filter(opt => state.selectedOptions.has(opt)));
1359
+ } else {
1360
+ const option = state.options.find(opt => getValue(opt) === value);
1361
+ if (!option) return;
1362
+ if (root.value !== value) updateValue(root, option);
1363
+ closePopover(state);
1364
+ }
1365
+ };
736
1366
 
737
- if (!isPopoverOpen) {
738
- if (event.key !== 'Enter' && event.key !== 'Escape') {
739
- event.preventDefault();
740
- trigger.click();
741
- }
742
- return;
743
- }
1367
+ const deselectValue = (root, value) => {
1368
+ const state = states.get(root);
1369
+ if (!state.isMultiple) return;
1370
+ const option = state.options.find(opt => getValue(opt) === value && state.selectedOptions.has(opt));
1371
+ if (!option) return;
1372
+ state.selectedOptions.delete(option);
1373
+ updateValue(root, state.options.filter(opt => state.selectedOptions.has(opt)));
1374
+ };
744
1375
 
745
- event.preventDefault();
1376
+ const handleKeyNavigation = (event, root) => {
1377
+ const state = states.get(root);
1378
+ const isPopoverOpen = state.popover.getAttribute('aria-hidden') === 'false';
746
1379
 
747
- if (event.key === 'Escape') {
748
- closePopover();
749
- return;
750
- }
1380
+ if (!['ArrowDown', 'ArrowUp', 'Enter', 'Home', 'End', 'Escape'].includes(event.key)) return;
751
1381
 
752
- if (event.key === 'Enter') {
753
- if (activeIndex > -1) {
754
- const option = options[activeIndex];
755
- if (isMultiple) {
756
- toggleMultipleValue(option);
757
- if (closeOnSelect) {
758
- closePopover();
759
- }
760
- } else {
761
- if (input.value !== getValue(option)) {
762
- updateValue(option);
763
- }
764
- closePopover();
765
- }
766
- }
767
- return;
1382
+ if (!isPopoverOpen) {
1383
+ if (event.key !== 'Enter' && event.key !== 'Escape') {
1384
+ event.preventDefault();
1385
+ root.open();
768
1386
  }
1387
+ return;
1388
+ }
769
1389
 
770
- if (visibleOptions.length === 0) return;
1390
+ event.preventDefault();
771
1391
 
772
- const currentVisibleIndex = activeIndex > -1 ? visibleOptions.indexOf(options[activeIndex]) : -1;
773
- let nextVisibleIndex = currentVisibleIndex;
1392
+ if (event.key === 'Escape') {
1393
+ root.close();
1394
+ return;
1395
+ }
774
1396
 
775
- switch (event.key) {
776
- case 'ArrowDown':
777
- if (currentVisibleIndex < visibleOptions.length - 1) {
778
- nextVisibleIndex = currentVisibleIndex + 1;
779
- }
780
- break;
781
- case 'ArrowUp':
782
- if (currentVisibleIndex > 0) {
783
- nextVisibleIndex = currentVisibleIndex - 1;
784
- } else if (currentVisibleIndex === -1) {
785
- nextVisibleIndex = 0;
786
- }
787
- break;
788
- case 'Home':
789
- nextVisibleIndex = 0;
790
- break;
791
- case 'End':
792
- nextVisibleIndex = visibleOptions.length - 1;
793
- break;
1397
+ if (event.key === 'Enter') {
1398
+ if (state.activeIndex > -1) {
1399
+ const option = state.options[state.activeIndex];
1400
+ if (state.isMultiple) {
1401
+ toggleMultipleValue(root, option);
1402
+ if (state.closeOnSelect) root.close();
1403
+ } else {
1404
+ if (root.value !== getValue(option)) updateValue(root, option);
1405
+ root.close();
1406
+ }
794
1407
  }
1408
+ return;
1409
+ }
795
1410
 
796
- if (nextVisibleIndex !== currentVisibleIndex) {
797
- const newActiveOption = visibleOptions[nextVisibleIndex];
798
- setActiveOption(options.indexOf(newActiveOption));
799
- newActiveOption.scrollIntoView({ block: 'nearest', behavior: 'smooth' });
800
- }
801
- };
1411
+ if (state.visibleOptions.length === 0) return;
802
1412
 
803
- listbox.addEventListener('mousemove', (event) => {
804
- const option = event.target.closest('[role="option"]');
805
- if (option && visibleOptions.includes(option)) {
806
- const index = options.indexOf(option);
807
- if (index !== activeIndex) {
808
- setActiveOption(index);
809
- }
810
- }
811
- });
1413
+ const currentVisibleIndex = state.activeIndex > -1 ? state.visibleOptions.indexOf(state.options[state.activeIndex]) : -1;
1414
+ let nextVisibleIndex = currentVisibleIndex;
812
1415
 
813
- listbox.addEventListener('mouseleave', () => {
814
- const selectedOption = listbox.querySelector('[role="option"][aria-selected="true"]');
815
- if (selectedOption) {
816
- setActiveOption(options.indexOf(selectedOption));
817
- } else {
818
- setActiveOption(-1);
819
- }
820
- });
1416
+ if (event.key === 'ArrowDown' && currentVisibleIndex < state.visibleOptions.length - 1) nextVisibleIndex = currentVisibleIndex + 1;
1417
+ if (event.key === 'ArrowUp') nextVisibleIndex = currentVisibleIndex > 0 ? currentVisibleIndex - 1 : 0;
1418
+ if (event.key === 'Home') nextVisibleIndex = 0;
1419
+ if (event.key === 'End') nextVisibleIndex = state.visibleOptions.length - 1;
821
1420
 
822
- trigger.addEventListener('keydown', handleKeyNavigation);
823
- if (filter) {
824
- filter.addEventListener('keydown', handleKeyNavigation);
1421
+ if (nextVisibleIndex !== currentVisibleIndex) {
1422
+ const newActiveOption = state.visibleOptions[nextVisibleIndex];
1423
+ setActiveOption(state, state.options.indexOf(newActiveOption));
1424
+ scrollOptionIntoListbox(state, newActiveOption);
825
1425
  }
1426
+ };
826
1427
 
827
- const openPopover = () => {
828
- document.dispatchEvent(new CustomEvent('basecoat:popover', {
829
- detail: { source: selectComponent }
830
- }));
1428
+ const initSelect = (root) => {
1429
+ if (root.dataset.selectInitialized) return;
831
1430
 
832
- if (filter) {
833
- if (hasTransition()) {
834
- popover.addEventListener('transitionend', () => {
835
- filter.focus();
836
- }, { once: true });
837
- } else {
838
- filter.focus();
839
- }
840
- }
1431
+ const state = { activeIndex: -1, selectedOptions: null, options: [], allOptions: [], visibleOptions: [], format: 'value' };
1432
+ states.set(root, state);
1433
+ root.refresh = () => refreshSelect(root);
841
1434
 
842
- popover.setAttribute('aria-hidden', 'false');
843
- trigger.setAttribute('aria-expanded', 'true');
1435
+ refreshSelect(root);
1436
+ if (!state.trigger || !state.selectedLabel || !state.popover || !state.listbox || !state.input) {
1437
+ states.delete(root);
1438
+ delete root.refresh;
1439
+ return;
1440
+ }
1441
+
1442
+ root.open = () => {
1443
+ document.dispatchEvent(new CustomEvent('basecoat:popover', { detail: { source: root } }));
1444
+ root.refresh();
1445
+ state.popover.setAttribute('aria-hidden', 'false');
1446
+ state.trigger.setAttribute('aria-expanded', 'true');
844
1447
 
845
- const selectedOption = listbox.querySelector('[role="option"][aria-selected="true"]');
1448
+ const selectedOption = state.listbox.querySelector('[role="option"][aria-selected="true"]');
846
1449
  if (selectedOption) {
847
- setActiveOption(options.indexOf(selectedOption));
848
- selectedOption.scrollIntoView({ block: 'nearest' });
1450
+ setActiveOption(state, state.options.indexOf(selectedOption));
1451
+ scrollOptionIntoListbox(state, selectedOption);
849
1452
  }
850
1453
  };
1454
+ root.close = (focusOnTrigger = true) => closePopover(state, focusOnTrigger);
1455
+ root.togglePopover = () => state.trigger.getAttribute('aria-expanded') === 'true' ? root.close() : root.open();
851
1456
 
852
- trigger.addEventListener('click', () => {
853
- const isExpanded = trigger.getAttribute('aria-expanded') === 'true';
854
- if (isExpanded) {
855
- closePopover();
856
- } else {
857
- openPopover();
1457
+ const handleTriggerKeydown = (event) => handleKeyNavigation(event, root);
1458
+ const handleTriggerClick = root.togglePopover;
1459
+ const handleListboxMousemove = (event) => {
1460
+ const option = event.target.closest('[role="option"]');
1461
+ if (option && state.visibleOptions.includes(option)) {
1462
+ const index = state.options.indexOf(option);
1463
+ if (index !== state.activeIndex) setActiveOption(state, index);
858
1464
  }
859
- });
860
-
861
- listbox.addEventListener('click', (event) => {
1465
+ };
1466
+ const handleListboxMouseleave = () => {
1467
+ const selectedOption = state.listbox.querySelector('[role="option"][aria-selected="true"]');
1468
+ setActiveOption(state, selectedOption ? state.options.indexOf(selectedOption) : -1);
1469
+ };
1470
+ const handleListboxClick = (event) => {
862
1471
  const clickedOption = event.target.closest('[role="option"]');
863
1472
  if (!clickedOption) return;
864
1473
 
865
- const option = options.find(opt => opt === clickedOption);
1474
+ const option = state.options.find(opt => opt === clickedOption);
866
1475
  if (!option) return;
867
1476
 
868
- if (isMultiple) {
869
- toggleMultipleValue(option);
870
- if (closeOnSelect) {
871
- closePopover();
1477
+ if (state.isMultiple) {
1478
+ toggleMultipleValue(root, option);
1479
+ if (state.closeOnSelect) {
1480
+ root.close();
872
1481
  } else {
873
- setActiveOption(options.indexOf(option));
874
- if (filter) {
875
- filter.focus();
876
- } else {
877
- trigger.focus();
878
- }
1482
+ setActiveOption(state, state.options.indexOf(option));
1483
+ state.trigger.focus();
879
1484
  }
880
1485
  } else {
881
- if (input.value !== getValue(option)) {
882
- updateValue(option);
883
- }
884
- closePopover();
885
- }
886
- });
887
-
888
- document.addEventListener('click', (event) => {
889
- if (!selectComponent.contains(event.target)) {
890
- closePopover(false);
891
- }
892
- });
893
-
894
- document.addEventListener('basecoat:popover', (event) => {
895
- if (event.detail.source !== selectComponent) {
896
- closePopover(false);
1486
+ if (root.value !== getValue(option)) updateValue(root, option);
1487
+ root.close();
897
1488
  }
898
- });
1489
+ };
1490
+ const handleDocumentClick = (event) => {
1491
+ if (!root.contains(event.target)) root.close(false);
1492
+ };
1493
+ const handleDocumentPopover = (event) => {
1494
+ if (event.detail.source !== root) root.close(false);
1495
+ };
899
1496
 
900
- popover.setAttribute('aria-hidden', 'true');
1497
+ state.trigger.addEventListener('keydown', handleTriggerKeydown);
1498
+ state.trigger.addEventListener('click', handleTriggerClick);
1499
+ state.listbox.addEventListener('mousemove', handleListboxMousemove);
1500
+ state.listbox.addEventListener('mouseleave', handleListboxMouseleave);
1501
+ state.listbox.addEventListener('click', handleListboxClick);
1502
+ document.addEventListener('click', handleDocumentClick);
1503
+ document.addEventListener('basecoat:popover', handleDocumentPopover);
1504
+
1505
+ root._destroy = () => {
1506
+ state.trigger.removeEventListener('keydown', handleTriggerKeydown);
1507
+ state.trigger.removeEventListener('click', handleTriggerClick);
1508
+ state.listbox.removeEventListener('mousemove', handleListboxMousemove);
1509
+ state.listbox.removeEventListener('mouseleave', handleListboxMouseleave);
1510
+ state.listbox.removeEventListener('click', handleListboxClick);
1511
+ document.removeEventListener('click', handleDocumentClick);
1512
+ document.removeEventListener('basecoat:popover', handleDocumentPopover);
1513
+ states.delete(root);
1514
+ delete root.refresh;
1515
+ delete root.open;
1516
+ delete root.close;
1517
+ delete root.togglePopover;
1518
+ delete root.select;
1519
+ delete root.selectByValue;
1520
+ delete root.deselect;
1521
+ delete root.toggle;
1522
+ delete root.selectAll;
1523
+ delete root.selectNone;
1524
+ };
901
1525
 
902
- // Public API
903
- Object.defineProperty(selectComponent, 'value', {
904
- get: () => {
905
- if (isMultiple) {
906
- return options.filter(opt => selectedOptions.has(opt)).map(getValue);
907
- } else {
908
- return input.value;
909
- }
910
- },
911
- set: (val) => {
912
- if (isMultiple) {
913
- const values = Array.isArray(val) ? val : (val != null ? [val] : []);
914
- const opts = [];
915
- values.forEach(v => {
916
- const opt = options.find(o => getValue(o) === v && !opts.includes(o));
917
- if (opt) opts.push(opt);
918
- });
919
- updateValue(opts);
1526
+ Object.defineProperty(root, 'value', {
1527
+ configurable: true,
1528
+ get: () => state.isMultiple ? state.options.filter(option => state.selectedOptions.has(option)).map(getValue) : parseStoredValues(state.input.value, state),
1529
+ set: (value) => {
1530
+ if (state.isMultiple) {
1531
+ const values = Array.isArray(value) ? value : (value != null ? [value] : []);
1532
+ updateValue(root, values.map(v => state.options.find(option => getValue(option) === v)).filter(Boolean));
920
1533
  } else {
921
- const option = options.find(opt => getValue(opt) === val);
1534
+ const option = state.options.find(opt => getValue(opt) === value);
922
1535
  if (option) {
923
- updateValue(option);
924
- closePopover();
1536
+ updateValue(root, option);
1537
+ root.close();
925
1538
  }
926
1539
  }
927
- }
1540
+ },
928
1541
  });
929
1542
 
930
- selectComponent.select = select;
931
- selectComponent.selectByValue = select; // Backward compatibility alias
932
- if (isMultiple) {
933
- selectComponent.deselect = deselect;
934
- selectComponent.toggle = toggle;
935
- selectComponent.selectAll = () => updateValue(options);
936
- selectComponent.selectNone = () => updateValue([]);
1543
+ Object.defineProperty(root, 'selected', {
1544
+ configurable: true,
1545
+ get: () => {
1546
+ if (state.isMultiple) return state.options.filter(option => state.selectedOptions.has(option)).map(toSelected);
1547
+ const value = root.value;
1548
+ const option = state.options.find(opt => getValue(opt) === value);
1549
+ return option ? toSelected(option) : null;
1550
+ },
1551
+ });
1552
+
1553
+ root.select = (value) => selectValue(root, value);
1554
+ root.selectByValue = root.select;
1555
+ if (state.isMultiple) {
1556
+ root.deselect = (value) => deselectValue(root, value);
1557
+ root.toggle = (value) => {
1558
+ const option = state.options.find(opt => getValue(opt) === value);
1559
+ if (option) toggleMultipleValue(root, option);
1560
+ };
1561
+ root.selectAll = () => updateValue(root, state.options);
1562
+ root.selectNone = () => updateValue(root, []);
937
1563
  }
938
- selectComponent.dataset.selectInitialized = true;
939
- selectComponent.dispatchEvent(new CustomEvent('basecoat:initialized'));
1564
+
1565
+ state.popover.setAttribute('aria-hidden', 'true');
1566
+ state.trigger.setAttribute('aria-expanded', 'false');
1567
+ root.dataset.selectInitialized = 'true';
1568
+ root.dispatchEvent(new CustomEvent('basecoat:initialized'));
940
1569
  };
941
1570
 
942
1571
  if (window.basecoat) {
943
- window.basecoat.register('select', 'div.select:not([data-select-initialized])', initSelect);
1572
+ window.basecoat.register('select', {
1573
+ selector: 'div.select:not([data-select-initialized])',
1574
+ init: initSelect,
1575
+ refresh: refreshSelect,
1576
+ });
944
1577
  }
945
1578
  })();
946
1579
 
947
1580
  (() => {
948
1581
  const initSidebar = (sidebarComponent) => {
1582
+ if (sidebarComponent.dataset.sidebarInitialized) return;
1583
+
949
1584
  const initialOpen = sidebarComponent.dataset.initialOpen !== 'false';
950
1585
  const initialMobileOpen = sidebarComponent.dataset.initialMobileOpen === 'true';
951
1586
  const breakpoint = parseInt(sidebarComponent.dataset.breakpoint) || 768;
952
-
953
- let open = breakpoint > 0
1587
+
1588
+ let open = breakpoint > 0
954
1589
  ? (window.innerWidth >= breakpoint ? initialOpen : initialMobileOpen)
955
1590
  : initialOpen;
956
-
1591
+
957
1592
  const updateState = () => {
958
- sidebarComponent.setAttribute('aria-hidden', !open);
1593
+ sidebarComponent.setAttribute('aria-hidden', String(!open));
959
1594
  if (open) {
960
1595
  sidebarComponent.removeAttribute('inert');
961
1596
  } else {
@@ -964,48 +1599,42 @@
964
1599
  };
965
1600
 
966
1601
  const setState = (state) => {
967
- open = state;
1602
+ open = Boolean(state);
968
1603
  updateState();
969
1604
  };
970
1605
 
971
- const sidebarId = sidebarComponent.id;
972
-
973
- document.addEventListener('basecoat:sidebar', (event) => {
974
- if (event.detail?.id && event.detail.id !== sidebarId) return;
975
-
976
- switch (event.detail?.action) {
977
- case 'open':
978
- setState(true);
979
- break;
980
- case 'close':
981
- setState(false);
982
- break;
983
- default:
984
- setState(!open);
985
- break;
986
- }
987
- });
988
-
989
- sidebarComponent.addEventListener('click', (event) => {
1606
+ sidebarComponent.open = () => setState(true);
1607
+ sidebarComponent.close = () => setState(false);
1608
+ sidebarComponent.toggle = () => setState(!open);
1609
+
1610
+ const handleClick = (event) => {
990
1611
  const target = event.target;
991
1612
  const nav = sidebarComponent.querySelector('nav');
992
-
993
1613
  const isMobile = window.innerWidth < breakpoint;
994
-
995
- if (isMobile && (target.closest('a, button') && !target.closest('[data-keep-mobile-sidebar-open]'))) {
1614
+
1615
+ if (isMobile && target.closest('a, button') && !target.closest('[data-keep-mobile-sidebar-open]')) {
996
1616
  if (document.activeElement) document.activeElement.blur();
997
- setState(false);
1617
+ sidebarComponent.close();
998
1618
  return;
999
1619
  }
1000
-
1620
+
1001
1621
  if (target === sidebarComponent || (nav && !nav.contains(target))) {
1002
1622
  if (document.activeElement) document.activeElement.blur();
1003
- setState(false);
1623
+ sidebarComponent.close();
1004
1624
  }
1005
- });
1625
+ };
1626
+
1627
+ sidebarComponent.addEventListener('click', handleClick);
1628
+
1629
+ sidebarComponent._destroy = () => {
1630
+ sidebarComponent.removeEventListener('click', handleClick);
1631
+ delete sidebarComponent.open;
1632
+ delete sidebarComponent.close;
1633
+ delete sidebarComponent.toggle;
1634
+ };
1006
1635
 
1007
1636
  updateState();
1008
- sidebarComponent.dataset.sidebarInitialized = true;
1637
+ sidebarComponent.dataset.sidebarInitialized = 'true';
1009
1638
  sidebarComponent.dispatchEvent(new CustomEvent('basecoat:initialized'));
1010
1639
  };
1011
1640
 
@@ -1015,68 +1644,113 @@
1015
1644
  })();
1016
1645
 
1017
1646
  (() => {
1018
- const initTabs = (tabsComponent) => {
1019
- const tablist = tabsComponent.querySelector('[role="tablist"]');
1020
- if (!tablist) return;
1647
+ const states = new WeakMap();
1021
1648
 
1022
- const tabs = Array.from(tablist.querySelectorAll('[role="tab"]'));
1649
+ const isDisabled = (tab) => tab.disabled || tab.getAttribute('aria-disabled') === 'true';
1650
+
1651
+ const getElements = (root) => {
1652
+ const tablist = root.querySelector('[role="tablist"]');
1653
+ const tabs = tablist ? Array.from(tablist.querySelectorAll('[role="tab"]')) : [];
1023
1654
  const panels = tabs.map(tab => document.getElementById(tab.getAttribute('aria-controls'))).filter(Boolean);
1655
+ return { tablist, tabs, panels };
1656
+ };
1657
+
1658
+ const refreshTabs = (root) => {
1659
+ const state = states.get(root);
1660
+ if (!state) return;
1661
+
1662
+ Object.assign(state, getElements(root));
1663
+ if (!state.tablist) return;
1024
1664
 
1025
- const selectTab = (tabToSelect) => {
1026
- tabs.forEach((tab, index) => {
1665
+ const selected = state.tabs.find(tab => tab.getAttribute('aria-selected') === 'true' && !isDisabled(tab))
1666
+ || state.tabs.find(tab => !isDisabled(tab));
1667
+ if (selected) root.select(selected, false);
1668
+ };
1669
+
1670
+ const initTabs = (root) => {
1671
+ if (root.dataset.tabsInitialized) return;
1672
+
1673
+ const state = {};
1674
+ states.set(root, state);
1675
+ root.refresh = () => refreshTabs(root);
1676
+
1677
+ const selectTab = (tabToSelect, focus = false) => {
1678
+ if (!tabToSelect || isDisabled(tabToSelect)) return;
1679
+
1680
+ state.tabs.forEach((tab) => {
1027
1681
  tab.setAttribute('aria-selected', 'false');
1028
1682
  tab.setAttribute('tabindex', '-1');
1029
- if (panels[index]) panels[index].hidden = true;
1683
+ const panel = document.getElementById(tab.getAttribute('aria-controls'));
1684
+ if (panel) panel.hidden = true;
1030
1685
  });
1031
1686
 
1032
1687
  tabToSelect.setAttribute('aria-selected', 'true');
1033
1688
  tabToSelect.setAttribute('tabindex', '0');
1034
1689
  const activePanel = document.getElementById(tabToSelect.getAttribute('aria-controls'));
1035
1690
  if (activePanel) activePanel.hidden = false;
1691
+ if (focus) tabToSelect.focus();
1036
1692
  };
1037
1693
 
1038
- tablist.addEventListener('click', (event) => {
1694
+ root.select = selectTab;
1695
+ refreshTabs(root);
1696
+ if (!state.tablist) {
1697
+ states.delete(root);
1698
+ delete root.refresh;
1699
+ delete root.select;
1700
+ return;
1701
+ }
1702
+
1703
+ const handleClick = (event) => {
1039
1704
  const clickedTab = event.target.closest('[role="tab"]');
1040
- if (clickedTab) selectTab(clickedTab);
1041
- });
1705
+ if (clickedTab) root.select(clickedTab);
1706
+ };
1042
1707
 
1043
- tablist.addEventListener('keydown', (event) => {
1708
+ const handleKeydown = (event) => {
1044
1709
  const currentTab = event.target;
1045
- if (!tabs.includes(currentTab)) return;
1710
+ if (!state.tabs.includes(currentTab)) return;
1711
+
1712
+ const enabledTabs = state.tabs.filter(tab => !isDisabled(tab));
1713
+ const currentIndex = enabledTabs.indexOf(currentTab);
1714
+ const orientation = state.tablist.getAttribute('aria-orientation') || 'horizontal';
1715
+ if (currentIndex === -1) return;
1046
1716
 
1047
1717
  let nextTab;
1048
- const currentIndex = tabs.indexOf(currentTab);
1049
-
1050
- switch (event.key) {
1051
- case 'ArrowRight':
1052
- nextTab = tabs[(currentIndex + 1) % tabs.length];
1053
- break;
1054
- case 'ArrowLeft':
1055
- nextTab = tabs[(currentIndex - 1 + tabs.length) % tabs.length];
1056
- break;
1057
- case 'Home':
1058
- nextTab = tabs[0];
1059
- break;
1060
- case 'End':
1061
- nextTab = tabs[tabs.length - 1];
1062
- break;
1063
- default:
1064
- return;
1065
- }
1718
+ if (event.key === 'ArrowRight' && orientation === 'horizontal') nextTab = enabledTabs[(currentIndex + 1) % enabledTabs.length];
1719
+ if (event.key === 'ArrowLeft' && orientation === 'horizontal') nextTab = enabledTabs[(currentIndex - 1 + enabledTabs.length) % enabledTabs.length];
1720
+ if (event.key === 'ArrowDown' && orientation === 'vertical') nextTab = enabledTabs[(currentIndex + 1) % enabledTabs.length];
1721
+ if (event.key === 'ArrowUp' && orientation === 'vertical') nextTab = enabledTabs[(currentIndex - 1 + enabledTabs.length) % enabledTabs.length];
1722
+ if (event.key === 'Home') nextTab = enabledTabs[0];
1723
+ if (event.key === 'End') nextTab = enabledTabs[enabledTabs.length - 1];
1724
+ if (!nextTab) return;
1066
1725
 
1067
1726
  event.preventDefault();
1068
- selectTab(nextTab);
1069
- nextTab.focus();
1070
- });
1071
-
1072
- tabsComponent.dataset.tabsInitialized = true;
1073
- tabsComponent.dispatchEvent(new CustomEvent('basecoat:initialized'));
1727
+ root.select(nextTab, true);
1728
+ };
1729
+
1730
+ state.tablist.addEventListener('click', handleClick);
1731
+ state.tablist.addEventListener('keydown', handleKeydown);
1732
+
1733
+ root._destroy = () => {
1734
+ state.tablist.removeEventListener('click', handleClick);
1735
+ state.tablist.removeEventListener('keydown', handleKeydown);
1736
+ states.delete(root);
1737
+ delete root.refresh;
1738
+ delete root.select;
1739
+ };
1740
+
1741
+ root.dataset.tabsInitialized = 'true';
1742
+ root.dispatchEvent(new CustomEvent('basecoat:initialized'));
1074
1743
  };
1075
1744
 
1076
1745
  if (window.basecoat) {
1077
- window.basecoat.register('tabs', '.tabs:not([data-tabs-initialized])', initTabs);
1746
+ window.basecoat.register('tabs', {
1747
+ selector: '.tabs:not([data-tabs-initialized])',
1748
+ init: initTabs,
1749
+ refresh: refreshTabs,
1750
+ });
1078
1751
  }
1079
1752
  })();
1753
+
1080
1754
  (() => {
1081
1755
  let toaster;
1082
1756
  const toasts = new WeakMap();
@@ -1092,17 +1766,38 @@
1092
1766
  if (toasterElement.dataset.toasterInitialized) return;
1093
1767
  toaster = toasterElement;
1094
1768
 
1095
- toaster.addEventListener('mouseenter', pauseAllTimeouts);
1096
- toaster.addEventListener('mouseleave', resumeAllTimeouts);
1097
- toaster.addEventListener('click', (event) => {
1769
+ const handleClick = (event) => {
1098
1770
  const actionLink = event.target.closest('.toast footer a');
1099
1771
  const actionButton = event.target.closest('.toast footer button');
1100
1772
  if (actionLink || actionButton) {
1101
1773
  closeToast(event.target.closest('.toast'));
1102
1774
  }
1103
- });
1775
+ };
1776
+
1777
+ toaster.addEventListener('mouseenter', pauseAllTimeouts);
1778
+ toaster.addEventListener('mouseleave', resumeAllTimeouts);
1779
+ toaster.addEventListener('click', handleClick);
1780
+
1781
+ toasterElement.toast = (config = {}) => {
1782
+ const toastElement = createToast(config);
1783
+ toasterElement.appendChild(toastElement);
1784
+ initToast(toastElement);
1785
+ return toastElement;
1786
+ };
1787
+ toasterElement.closeAll = () => {
1788
+ toasterElement.querySelectorAll('.toast:not([aria-hidden="true"])').forEach(closeToast);
1789
+ };
1104
1790
 
1105
1791
  toaster.querySelectorAll('.toast:not([data-toast-initialized])').forEach(initToast);
1792
+ toaster._destroy = () => {
1793
+ toaster.removeEventListener('mouseenter', pauseAllTimeouts);
1794
+ toaster.removeEventListener('mouseleave', resumeAllTimeouts);
1795
+ toaster.removeEventListener('click', handleClick);
1796
+ toaster.querySelectorAll('.toast[data-toast-initialized]').forEach(toast => toast._destroy?.());
1797
+ delete toaster.toast;
1798
+ delete toaster.closeAll;
1799
+ if (toaster === toasterElement) toaster = null;
1800
+ };
1106
1801
  toaster.dataset.toasterInitialized = 'true';
1107
1802
  toaster.dispatchEvent(new CustomEvent('basecoat:initialized'));
1108
1803
  }
@@ -1114,13 +1809,13 @@
1114
1809
  const timeoutDuration = duration !== -1
1115
1810
  ? duration || (element.dataset.category === 'error' ? 5000 : 3000)
1116
1811
  : -1;
1117
-
1812
+
1118
1813
  const state = {
1119
1814
  remainingTime: timeoutDuration,
1120
1815
  timeoutId: null,
1121
1816
  startTime: null,
1122
1817
  };
1123
-
1818
+
1124
1819
  if (timeoutDuration !== -1) {
1125
1820
  if (isPaused) {
1126
1821
  state.timeoutId = null;
@@ -1130,18 +1825,24 @@
1130
1825
  }
1131
1826
  }
1132
1827
  toasts.set(element, state);
1133
-
1828
+
1829
+ element.close = () => closeToast(element);
1830
+ element._destroy = () => {
1831
+ clearTimeout(state.timeoutId);
1832
+ toasts.delete(element);
1833
+ delete element.close;
1834
+ };
1134
1835
  element.dataset.toastInitialized = 'true';
1135
1836
  }
1136
1837
 
1137
1838
  function pauseAllTimeouts() {
1138
- if (isPaused) return;
1839
+ if (isPaused || !toaster) return;
1139
1840
 
1140
1841
  isPaused = true;
1141
-
1842
+
1142
1843
  toaster.querySelectorAll('.toast:not([aria-hidden="true"])').forEach(element => {
1143
1844
  if (!toasts.has(element)) return;
1144
-
1845
+
1145
1846
  const state = toasts.get(element);
1146
1847
  if (state.timeoutId) {
1147
1848
  clearTimeout(state.timeoutId);
@@ -1152,7 +1853,7 @@
1152
1853
  }
1153
1854
 
1154
1855
  function resumeAllTimeouts() {
1155
- if (!isPaused) return;
1856
+ if (!isPaused || !toaster) return;
1156
1857
 
1157
1858
  isPaused = false;
1158
1859
 
@@ -1172,28 +1873,17 @@
1172
1873
  }
1173
1874
 
1174
1875
  function closeToast(element) {
1175
- if (!toasts.has(element)) return;
1876
+ if (!element || !toasts.has(element)) return;
1176
1877
 
1177
1878
  const state = toasts.get(element);
1178
1879
  clearTimeout(state.timeoutId);
1179
1880
  toasts.delete(element);
1180
-
1881
+
1181
1882
  if (element.contains(document.activeElement)) document.activeElement.blur();
1182
1883
  element.setAttribute('aria-hidden', 'true');
1183
1884
  element.addEventListener('transitionend', () => element.remove(), { once: true });
1184
1885
  }
1185
1886
 
1186
- function executeAction(button, toast) {
1187
- const actionString = button.dataset.toastAction;
1188
- if (!actionString) return;
1189
- try {
1190
- const func = new Function('close', actionString);
1191
- func(() => closeToast(toast));
1192
- } catch (event) {
1193
- console.error('Error executing toast action:', event);
1194
- }
1195
- }
1196
-
1197
1887
  function createToast(config) {
1198
1888
  const {
1199
1889
  category = 'info',
@@ -1214,7 +1904,7 @@
1214
1904
  ? `<button type="button" class="btn" data-toast-action onclick="${action.onclick}">${action.label}</button>`
1215
1905
  : '';
1216
1906
  const cancelHtml = cancel
1217
- ? `<button type="button" class="btn-outline h-6 text-xs px-2.5 rounded-sm" data-toast-cancel onclick="${cancel?.onclick}">${cancel.label}</button>`
1907
+ ? `<button type="button" class="btn-outline h-6 text-xs px-2.5 rounded-sm" data-toast-cancel onclick="${cancel?.onclick || ''}">${cancel.label}</button>`
1218
1908
  : '';
1219
1909
 
1220
1910
  const footerHtml = actionHtml || cancelHtml ? `<footer>${actionHtml}${cancelHtml}</footer>` : '';
@@ -1234,7 +1924,6 @@
1234
1924
  ${descriptionHtml}
1235
1925
  </section>
1236
1926
  ${footerHtml}
1237
- </div>
1238
1927
  </div>
1239
1928
  </div>
1240
1929
  `;
@@ -1243,18 +1932,9 @@
1243
1932
  return template.content.firstChild;
1244
1933
  }
1245
1934
 
1246
- document.addEventListener('basecoat:toast', (event) => {
1247
- if (!toaster) {
1248
- console.error('Cannot create toast: toaster container not found on page.');
1249
- return;
1250
- }
1251
- const config = event.detail?.config || {};
1252
- const toastElement = createToast(config);
1253
- toaster.appendChild(toastElement);
1254
- });
1255
-
1256
1935
  if (window.basecoat) {
1257
1936
  window.basecoat.register('toaster', '#toaster:not([data-toaster-initialized])', initToaster);
1258
1937
  window.basecoat.register('toast', '.toast:not([data-toast-initialized])', initToast);
1259
1938
  }
1260
1939
  })();
1940
+