@glasshome/ui 1.41.0 → 1.43.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 (188) hide show
  1. package/SPEC.md +5 -0
  2. package/dist/index.d.ts +1 -1
  3. package/dist/index.js +3 -3
  4. package/dist/lib/anchor-placement.d.ts +34 -0
  5. package/dist/lib/balance-rows.d.ts +10 -4
  6. package/dist/lib/behavior/anchored.d.ts +26 -0
  7. package/dist/lib/behavior/button-root.d.ts +7 -0
  8. package/dist/lib/behavior/collection.d.ts +32 -0
  9. package/dist/lib/behavior/controllable.d.ts +8 -0
  10. package/dist/lib/behavior/dismiss.d.ts +13 -0
  11. package/dist/lib/behavior/focus-scope.d.ts +24 -0
  12. package/dist/lib/behavior/hide-outside.d.ts +7 -0
  13. package/dist/lib/behavior/layer-stack.d.ts +34 -0
  14. package/dist/lib/behavior/menu.d.ts +59 -0
  15. package/dist/lib/behavior/modal-root.d.ts +68 -0
  16. package/dist/lib/behavior/polymorphic.d.ts +6 -0
  17. package/dist/lib/behavior/presence.d.ts +18 -0
  18. package/dist/lib/behavior/range.d.ts +44 -0
  19. package/dist/lib/behavior/solid.d.ts +13 -0
  20. package/dist/lib/color/color.d.ts +41 -0
  21. package/dist/lib/color/index.d.ts +2 -0
  22. package/dist/lib/color/intl.d.ts +40 -0
  23. package/dist/lib/dock-slot-classes.d.ts +2 -0
  24. package/dist/lib/hold.d.ts +1 -1
  25. package/dist/lib/locale.d.ts +3 -0
  26. package/dist/lib/menu-classes.d.ts +2 -0
  27. package/dist/lib/motion-classes.d.ts +5 -2
  28. package/dist/lib/overlay-classes.d.ts +4 -0
  29. package/dist/lib/page-cover.d.ts +8 -0
  30. package/dist/lib/scroll-track.d.ts +3 -2
  31. package/dist/lib/section-tokens.d.ts +1 -1
  32. package/dist/lib/segment-classes.d.ts +2 -0
  33. package/dist/lib/shadow-layer.d.ts +0 -43
  34. package/dist/lib/toggle-set.d.ts +44 -0
  35. package/dist/lib/visually-hidden.d.ts +3 -0
  36. package/dist/solid/accordion.d.ts +35 -11
  37. package/dist/solid/alert-dialog.d.ts +5 -8
  38. package/dist/solid/avatar.d.ts +8 -4
  39. package/dist/solid/bottom-sheet/bottom-sheet.d.ts +2 -2
  40. package/dist/solid/bottom-sheet/constants.d.ts +1 -1
  41. package/dist/solid/button.d.ts +5 -4
  42. package/dist/solid/charts.d.ts +1 -1
  43. package/dist/solid/checkbox.d.ts +14 -4
  44. package/dist/solid/collapsible.d.ts +33 -5
  45. package/dist/solid/color-disc.d.ts +1 -1
  46. package/dist/solid/color-slider.d.ts +1 -1
  47. package/dist/solid/color-wheel.d.ts +1 -1
  48. package/dist/solid/context-menu.d.ts +58 -24
  49. package/dist/solid/dialog-parts.d.ts +53 -16
  50. package/dist/solid/dialog.d.ts +7 -10
  51. package/dist/solid/dropdown-menu.d.ts +55 -24
  52. package/dist/solid/empty.d.ts +1 -1
  53. package/dist/solid/form.d.ts +5 -6
  54. package/dist/solid/hover-card.d.ts +65 -9
  55. package/dist/solid/index.d.ts +5 -2
  56. package/dist/solid/index.js +8671 -14317
  57. package/dist/solid/input-group.d.ts +6 -6
  58. package/dist/solid/item.d.ts +1 -1
  59. package/dist/solid/menu-parts.d.ts +175 -24
  60. package/dist/solid/option-card.d.ts +1 -4
  61. package/dist/solid/picker-row.d.ts +2 -0
  62. package/dist/solid/popover.d.ts +77 -12
  63. package/dist/solid/progress.d.ts +11 -3
  64. package/dist/solid/radio-group.d.ts +31 -6
  65. package/dist/solid/responsive-dialog.d.ts +3 -1
  66. package/dist/solid/scroll-area.d.ts +1 -1
  67. package/dist/solid/section-card.d.ts +2 -3
  68. package/dist/solid/select.d.ts +107 -10
  69. package/dist/solid/selection.d.ts +10 -1
  70. package/dist/solid/sheet.d.ts +6 -9
  71. package/dist/solid/sliding-indicator.d.ts +1 -1
  72. package/dist/solid/sonner.d.ts +1 -1
  73. package/dist/solid/stale-veil.d.ts +7 -0
  74. package/dist/solid/tabs.d.ts +28 -9
  75. package/dist/solid/toggle-group.d.ts +30 -5
  76. package/dist/solid/toggle.d.ts +11 -3
  77. package/dist/solid/tooltip.d.ts +71 -9
  78. package/dist/tokens/index.js +54 -51
  79. package/dist/{utils-CGN4X-2O.js → utils-3Codx-NZ.js} +848 -618
  80. package/package.json +6 -7
  81. package/src/index.ts +1 -0
  82. package/src/lib/anchor-placement.ts +77 -4
  83. package/src/lib/balance-rows.ts +115 -40
  84. package/src/lib/behavior/anchored.ts +106 -0
  85. package/src/lib/behavior/button-root.tsx +103 -0
  86. package/src/lib/behavior/collection.ts +218 -0
  87. package/src/lib/behavior/controllable.ts +22 -0
  88. package/src/lib/behavior/dismiss.ts +185 -0
  89. package/src/lib/behavior/focus-scope.ts +227 -0
  90. package/src/lib/behavior/hide-outside.ts +85 -0
  91. package/src/lib/behavior/layer-stack.ts +150 -0
  92. package/src/lib/behavior/menu.ts +470 -0
  93. package/src/lib/behavior/modal-root.tsx +452 -0
  94. package/src/lib/behavior/polymorphic.tsx +30 -0
  95. package/src/lib/behavior/presence.ts +89 -0
  96. package/src/lib/behavior/range.ts +212 -0
  97. package/src/lib/behavior/solid.ts +30 -0
  98. package/src/lib/clipboard.ts +4 -4
  99. package/src/lib/color/color.ts +746 -0
  100. package/src/lib/color/index.ts +2 -0
  101. package/src/lib/color/intl.ts +60 -0
  102. package/src/lib/dock-slot-classes.ts +3 -0
  103. package/src/lib/hold.ts +1 -1
  104. package/src/lib/locale.ts +62 -0
  105. package/src/lib/menu-classes.ts +3 -0
  106. package/src/lib/motion-classes.ts +33 -8
  107. package/src/lib/overlay-classes.ts +8 -3
  108. package/src/lib/page-cover.ts +47 -0
  109. package/src/lib/scroll-track.ts +11 -6
  110. package/src/lib/section-tokens.ts +1 -1
  111. package/src/lib/segment-classes.ts +3 -0
  112. package/src/lib/shadow-layer.ts +0 -136
  113. package/src/lib/toggle-set.ts +133 -0
  114. package/src/lib/visually-hidden.ts +15 -0
  115. package/src/solid/accordion.tsx +294 -20
  116. package/src/solid/alert-dialog.tsx +36 -85
  117. package/src/solid/area-picker.tsx +5 -3
  118. package/src/solid/avatar.tsx +98 -24
  119. package/src/solid/badge.tsx +5 -5
  120. package/src/solid/bottom-sheet/bottom-sheet.tsx +73 -129
  121. package/src/solid/bottom-sheet/constants.ts +3 -1
  122. package/src/solid/bottom-sheet/drag-controller.ts +11 -0
  123. package/src/solid/breadcrumb.tsx +4 -4
  124. package/src/solid/button-group.tsx +4 -4
  125. package/src/solid/button.tsx +12 -6
  126. package/src/solid/card.tsx +5 -4
  127. package/src/solid/charts.tsx +1 -1
  128. package/src/solid/checkbox.tsx +167 -44
  129. package/src/solid/collapsible.tsx +260 -12
  130. package/src/solid/color-disc.tsx +11 -12
  131. package/src/solid/color-slider.tsx +114 -47
  132. package/src/solid/color-wheel.tsx +137 -39
  133. package/src/solid/context-menu.tsx +287 -86
  134. package/src/solid/dialog-parts.tsx +135 -46
  135. package/src/solid/dialog.tsx +44 -76
  136. package/src/solid/dock-edit.tsx +5 -4
  137. package/src/solid/dock.tsx +6 -5
  138. package/src/solid/dropdown-menu.tsx +252 -107
  139. package/src/solid/empty.tsx +1 -1
  140. package/src/solid/entity-selector.tsx +5 -3
  141. package/src/solid/face-toggle.tsx +43 -18
  142. package/src/solid/form.tsx +9 -9
  143. package/src/solid/glyph-tile.tsx +48 -21
  144. package/src/solid/hover-card.tsx +288 -21
  145. package/src/solid/icon-picker.tsx +2 -1
  146. package/src/solid/image-picker.tsx +6 -5
  147. package/src/solid/index.ts +5 -4
  148. package/src/solid/input-group.tsx +7 -5
  149. package/src/solid/input-otp.tsx +2 -1
  150. package/src/solid/item.tsx +5 -5
  151. package/src/solid/logo.tsx +5 -4
  152. package/src/solid/menu-parts.tsx +619 -145
  153. package/src/solid/option-card.tsx +6 -10
  154. package/src/solid/picker-row.tsx +10 -5
  155. package/src/solid/picker-search.tsx +2 -1
  156. package/src/solid/popover.tsx +424 -71
  157. package/src/solid/preview-tile.tsx +1 -1
  158. package/src/solid/progress.tsx +84 -15
  159. package/src/solid/radio-group.tsx +271 -34
  160. package/src/solid/responsive-dialog.tsx +10 -10
  161. package/src/solid/schema-form.tsx +1 -6
  162. package/src/solid/scroll-area.tsx +1 -1
  163. package/src/solid/section-card.tsx +3 -4
  164. package/src/solid/select.tsx +950 -95
  165. package/src/solid/selection.tsx +142 -66
  166. package/src/solid/sheet.tsx +48 -80
  167. package/src/solid/slider.tsx +115 -65
  168. package/src/solid/sliding-indicator.tsx +1 -1
  169. package/src/solid/sonner.tsx +1 -1
  170. package/src/solid/spotlight.tsx +23 -11
  171. package/src/solid/stale-veil.tsx +20 -0
  172. package/src/solid/switch.tsx +8 -6
  173. package/src/solid/tabs.tsx +377 -52
  174. package/src/solid/term.tsx +3 -4
  175. package/src/solid/toggle-group.tsx +237 -95
  176. package/src/solid/toggle.tsx +43 -9
  177. package/src/solid/tooltip.tsx +285 -26
  178. package/src/styles/globals.css +64 -10
  179. package/src/styles/theme.css +12 -4
  180. package/src/tokens/material.ts +11 -2
  181. package/dist/lib/when-animations-settle.d.ts +0 -4
  182. package/dist/solid/bottom-sheet/focus-trap.d.ts +0 -6
  183. package/dist/solid/bottom-sheet/scroll-lock.d.ts +0 -2
  184. package/dist/solid/bottom-sheet/sheet-motion.d.ts +0 -1
  185. package/src/lib/when-animations-settle.ts +0 -12
  186. package/src/solid/bottom-sheet/focus-trap.ts +0 -63
  187. package/src/solid/bottom-sheet/scroll-lock.ts +0 -66
  188. package/src/solid/bottom-sheet/sheet-motion.ts +0 -4
@@ -0,0 +1,218 @@
1
+ import { type Accessor, createSignal, onCleanup } from "solid-js";
2
+ import { activeOf, focusWithoutTracking } from "./focus-scope.js";
3
+ import { effect } from "./solid.js";
4
+
5
+ export const TYPEAHEAD_MS = 1000;
6
+
7
+ type Orientation = "horizontal" | "vertical";
8
+ type HighlightBy = "keyboard" | "pointer";
9
+
10
+ export interface CollectionOptions {
11
+ root: Accessor<HTMLElement | undefined>;
12
+ itemSelector: string;
13
+ orientation: Accessor<Orientation>;
14
+ focus: "roving" | "virtual";
15
+ loop?: Accessor<boolean>;
16
+ dir?: Accessor<"ltr" | "rtl">;
17
+ /** Keys that hold the tab stop while focus is outside, first present wins (a selected tab). */
18
+ preferred?: Accessor<readonly string[]>;
19
+ /** APG's focusable when disabled: an `aria-disabled` item stays in the arrow order and can hold the tab stop. */
20
+ disabledFocusable?: boolean;
21
+ }
22
+
23
+ export interface Collection {
24
+ highlighted: Accessor<string | undefined>;
25
+ highlight: (key: string, by: HighlightBy) => void;
26
+ tabIndex: (key: string) => 0 | -1;
27
+ onKeyDown: (event: KeyboardEvent) => void;
28
+ /** Items call this as they mount, unmount or change disabled, so the tab stop always sits on a present, enabled item. */
29
+ refresh: () => void;
30
+ }
31
+
32
+ const isDisabled = (el: HTMLElement) =>
33
+ el.getAttribute("aria-disabled") === "true" ||
34
+ el.hasAttribute("data-disabled") ||
35
+ el.matches(":disabled");
36
+
37
+ const keyOf = (el: HTMLElement) => el.dataset.key ?? "";
38
+
39
+ function step(
40
+ items: HTMLElement[],
41
+ from: number,
42
+ by: number,
43
+ loop: boolean,
44
+ ): HTMLElement | undefined {
45
+ if (from < 0) return by > 0 ? items[0] : items.at(-1);
46
+ const next = from + by;
47
+ if (loop) return items[(next + items.length) % items.length];
48
+ return items[Math.max(0, Math.min(items.length - 1, next))];
49
+ }
50
+
51
+ function forwardKeys(orientation: Orientation, rtl: boolean): { next: string; prev: string } {
52
+ if (orientation === "vertical") return { next: "ArrowDown", prev: "ArrowUp" };
53
+ return rtl
54
+ ? { next: "ArrowLeft", prev: "ArrowRight" }
55
+ : { next: "ArrowRight", prev: "ArrowLeft" };
56
+ }
57
+
58
+ const textOf = (el: HTMLElement) => el.textContent ?? "";
59
+
60
+ function matchText(texts: readonly string[], from: number, buffer: string): number {
61
+ const first = buffer.charAt(0);
62
+ const cycling = buffer.length > 1 && buffer === first.repeat(buffer.length);
63
+ const search = cycling ? first : buffer;
64
+ const start = cycling || buffer.length === 1 ? from + 1 : Math.max(from, 0);
65
+ for (let i = 0; i < texts.length; i++) {
66
+ const index = (start + i) % texts.length;
67
+ if ((texts[index] ?? "").trim().toLowerCase().startsWith(search)) return index;
68
+ }
69
+ return -1;
70
+ }
71
+
72
+ export interface Typeahead {
73
+ /** The index in `texts` the key leads to: -1 when nothing matches, `undefined` when the key types nothing. */
74
+ match: (event: KeyboardEvent, texts: readonly string[], from: number) => number | undefined;
75
+ }
76
+
77
+ /** The typing buffer alone, for a list whose items are not in the DOM (a closed Select's trigger). */
78
+ export function createTypeahead(): Typeahead {
79
+ let buffer = "";
80
+ let timer: ReturnType<typeof setTimeout> | undefined;
81
+ onCleanup(() => clearTimeout(timer));
82
+ return {
83
+ match(event, texts, from) {
84
+ const char = event.key;
85
+ if (char.length !== 1 || (char === " " && buffer === "")) return undefined;
86
+ buffer += char.toLowerCase();
87
+ clearTimeout(timer);
88
+ timer = setTimeout(() => (buffer = ""), TYPEAHEAD_MS);
89
+ return matchText(texts, from, buffer);
90
+ },
91
+ };
92
+ }
93
+
94
+ export function createCollection(options: CollectionOptions): Collection {
95
+ const [own, setOwn] = createSignal<string>();
96
+ const highlighted = () => own() ?? options.preferred?.()[0];
97
+ const skipped = options.disabledFocusable
98
+ ? (el: HTMLElement) => el.matches(":disabled")
99
+ : isDisabled;
100
+ const enabledItems = (root: HTMLElement) =>
101
+ [...root.querySelectorAll<HTMLElement>(options.itemSelector)].filter((el) => !skipped(el));
102
+
103
+ // Tracked from focus events, which a sealed widget already receives; reading activeElement asks the page.
104
+ let focused: Element | null = null;
105
+ const focusIsWithin = (root: HTMLElement) =>
106
+ !!focused && focused.isConnected && root.contains(focused);
107
+
108
+ function placeStop(root: HTMLElement | undefined, preferred: readonly string[]) {
109
+ if (!root || focusIsWithin(root)) return;
110
+ const items = enabledItems(root);
111
+ const stop =
112
+ items.find((el) => preferred.includes(keyOf(el))) ??
113
+ items.find((el) => keyOf(el) === own()) ??
114
+ items[0];
115
+ setOwn(stop ? keyOf(stop) : undefined);
116
+ }
117
+
118
+ let disposed = false;
119
+ let queued = false;
120
+ onCleanup(() => (disposed = true));
121
+
122
+ // A microtask, so an unmounting item has left the DOM and a burst of changes places the stop once.
123
+ function refresh() {
124
+ if (options.focus !== "roving" || queued) return;
125
+ queued = true;
126
+ queueMicrotask(() => {
127
+ queued = false;
128
+ if (!disposed) placeStop(options.root(), options.preferred?.() ?? []);
129
+ });
130
+ }
131
+
132
+ if (options.focus === "roving") {
133
+ effect(options.root, (root) => {
134
+ if (!root) return;
135
+ // One read when the listeners attach, so an item focused before them (autofocus) keeps the stop.
136
+ const current = activeOf(root);
137
+ focused = current && root.contains(current) ? current : null;
138
+ const item = focused?.closest<HTMLElement>(options.itemSelector);
139
+ if (item && root.contains(item)) setOwn(keyOf(item));
140
+ const enter = (event: FocusEvent) => {
141
+ focused = event.target instanceof Element ? event.target : null;
142
+ };
143
+ const leave = (event: FocusEvent) => {
144
+ const next = event.relatedTarget;
145
+ if (next instanceof Element && root.contains(next)) return;
146
+ focused = null;
147
+ refresh();
148
+ };
149
+ root.addEventListener("focusin", enter);
150
+ root.addEventListener("focusout", leave);
151
+ return () => {
152
+ root.removeEventListener("focusin", enter);
153
+ root.removeEventListener("focusout", leave);
154
+ };
155
+ });
156
+ effect(
157
+ () => [options.root(), options.preferred?.() ?? []] as const,
158
+ ([root, preferred]) => placeStop(root, preferred),
159
+ );
160
+ }
161
+
162
+ const typer = createTypeahead();
163
+
164
+ function moveTo(el: HTMLElement | undefined) {
165
+ if (!el) return;
166
+ setOwn(keyOf(el));
167
+ if (options.focus === "roving") focusWithoutTracking(el);
168
+ el.scrollIntoView({ block: "nearest", inline: "nearest" });
169
+ }
170
+
171
+ function highlight(key: string, by: HighlightBy) {
172
+ if (by === "pointer") return void setOwn(key);
173
+ const root = options.root();
174
+ const el = root
175
+ ? [...root.querySelectorAll<HTMLElement>(options.itemSelector)].find((i) => keyOf(i) === key)
176
+ : undefined;
177
+ if (el) moveTo(el);
178
+ else setOwn(key);
179
+ }
180
+
181
+ function typeahead(event: KeyboardEvent, items: HTMLElement[], current: number): boolean {
182
+ const index = typer.match(event, items.map(textOf), current);
183
+ if (index === undefined) return false;
184
+ moveTo(items[index]);
185
+ return true;
186
+ }
187
+
188
+ function onKeyDown(event: KeyboardEvent) {
189
+ if (event.defaultPrevented || event.ctrlKey || event.metaKey || event.altKey) return;
190
+ const root = options.root();
191
+ if (!root) return;
192
+ const items = enabledItems(root);
193
+ const key = highlighted();
194
+ const target = event.target instanceof Element ? event.target : null;
195
+ let current = items.findIndex((el) => keyOf(el) === key);
196
+ if (current < 0 && target) current = items.findIndex((el) => el.contains(target));
197
+ const { next, prev } = forwardKeys(options.orientation(), options.dir?.() === "rtl");
198
+ const loop = options.loop?.() ?? false;
199
+ const destinations: Record<string, () => HTMLElement | undefined> = {
200
+ [next]: () => step(items, current, 1, loop),
201
+ [prev]: () => step(items, current, -1, loop),
202
+ Home: () => items[0],
203
+ End: () => items.at(-1),
204
+ };
205
+ const destination = destinations[event.key];
206
+ if (destination) moveTo(destination());
207
+ else if (!typeahead(event, items, current)) return;
208
+ event.preventDefault();
209
+ }
210
+
211
+ return {
212
+ highlighted,
213
+ highlight,
214
+ tabIndex: (key) => (options.focus === "roving" && key === highlighted() ? 0 : -1),
215
+ onKeyDown,
216
+ refresh,
217
+ };
218
+ }
@@ -0,0 +1,22 @@
1
+ import { createSignal, untrack, type Accessor } from "solid-js";
2
+
3
+ export interface ControllableOptions<T> {
4
+ value: Accessor<T | undefined>;
5
+ defaultValue: Accessor<T>;
6
+ onChange?: (next: T) => void;
7
+ equals?: (a: T, b: T) => boolean;
8
+ }
9
+
10
+ export function createControllableSignal<T>(
11
+ options: ControllableOptions<T>,
12
+ ): [Accessor<T>, (next: T) => void] {
13
+ const [stored, setStored] = createSignal<T>(untrack(options.defaultValue), { equals: false });
14
+ const get = (): T => options.value() ?? stored();
15
+ const set = (next: T) => {
16
+ const same = options.equals ?? Object.is;
17
+ if (same(next, untrack(get))) return;
18
+ setStored(() => next);
19
+ options.onChange?.(next);
20
+ };
21
+ return [get, set];
22
+ }
@@ -0,0 +1,185 @@
1
+ import type { Accessor } from "solid-js";
2
+ import { type Layer, type LayerHandle, layerStack } from "./layer-stack.js";
3
+ import { effect } from "./solid.js";
4
+
5
+ export type DismissReason = "escape" | "outside-press" | "focus-outside";
6
+
7
+ export interface DismissOptions {
8
+ layer: LayerHandle;
9
+ /** `event` is the keydown for `escape`, the pointerdown for `outside-press` and the focusin for `focus-outside`. */
10
+ onDismiss: (reason: DismissReason, event: KeyboardEvent | PointerEvent | FocusEvent) => void;
11
+ outsidePress?: Accessor<boolean>;
12
+ /** Off unless asked: a non-modal layer closes when focus lands outside it. */
13
+ focusOutside?: Accessor<boolean>;
14
+ escapeFrom?: "layer" | "document";
15
+ }
16
+
17
+ const SHADOW_ROOT_NODE = 11;
18
+
19
+ function rootOf(element: HTMLElement): Document | ShadowRoot {
20
+ const root = typeof element.getRootNode === "function" ? element.getRootNode() : document;
21
+ return root.nodeType === SHADOW_ROOT_NODE ? (root as ShadowRoot) : document;
22
+ }
23
+
24
+ const takesKeys = (entry: Layer): boolean => entry.element() !== undefined;
25
+
26
+ // A layer in a shadow root tops its own root: layers newer in other roots never shield it.
27
+ function topsItsRoot(layer: LayerHandle, mine: Layer): boolean {
28
+ if (layer.isTop()) return true;
29
+ const root = mine.element()?.getRootNode();
30
+ if (root?.nodeType !== SHADOW_ROOT_NODE) return false;
31
+ return !layer
32
+ .above()
33
+ .some((other) => other.kind !== "tooltip" && other.element()?.getRootNode() === root);
34
+ }
35
+
36
+ function isOutside(layer: LayerHandle, event: Event): boolean {
37
+ const mine = layer.layer();
38
+ if (!mine || (mine.kind !== "menu" && !topsItsRoot(layer, mine))) return false;
39
+ const full = event.composedPath();
40
+ const listener = event.currentTarget;
41
+ const end = listener === document || !listener ? -1 : full.indexOf(listener);
42
+ return !layer.containsPath(end >= 0 ? full.slice(0, end) : full);
43
+ }
44
+
45
+ function listenersFor(element: HTMLElement) {
46
+ const root = rootOf(element);
47
+ const host = root === document ? undefined : (root as ShadowRoot).host;
48
+ return { host, targets: host ? [root, document] : [root] };
49
+ }
50
+
51
+ function createFocusOutside(options: DismissOptions) {
52
+ const { layer } = options;
53
+ effect(
54
+ () => [layer.layer()?.element(), options.focusOutside?.() ?? false] as const,
55
+ ([element, enabled]) => {
56
+ if (!element || !enabled) return;
57
+ const { host, targets } = listenersFor(element);
58
+ const onFocus = (event: FocusEvent) => {
59
+ if (event.currentTarget === document && host && event.target === host) return;
60
+ if (isOutside(layer, event)) options.onDismiss("focus-outside", event);
61
+ };
62
+ const listener = onFocus as EventListener;
63
+ // After the tick that opened it: focus moved by the opening itself is never outside.
64
+ const timer = setTimeout(() => {
65
+ for (const target of targets) target.addEventListener("focusin", listener, true);
66
+ }, 0);
67
+ return () => {
68
+ clearTimeout(timer);
69
+ for (const target of targets) target.removeEventListener("focusin", listener, true);
70
+ };
71
+ },
72
+ );
73
+ }
74
+
75
+ function createOutsidePress(options: DismissOptions) {
76
+ const { layer } = options;
77
+ effect(
78
+ () => [layer.layer()?.element(), options.outsidePress?.() ?? true] as const,
79
+ ([element, enabled]) => {
80
+ if (!element || !enabled) return;
81
+ const { host, targets } = listenersFor(element);
82
+ const outside = (event: Event): boolean => isOutside(layer, event);
83
+
84
+ let pending: { target: EventTarget; click: (e: Event) => void } | undefined;
85
+ const dropPending = () => {
86
+ if (pending) pending.target.removeEventListener("click", pending.click);
87
+ pending = undefined;
88
+ };
89
+ const onDown = (event: PointerEvent) => {
90
+ if (event.currentTarget === document && host && event.target === host) return;
91
+ dropPending();
92
+ if (!outside(event)) return;
93
+ const target = event.currentTarget;
94
+ if (event.pointerType === "touch" && target) {
95
+ const click = (e: Event) => {
96
+ pending = undefined;
97
+ if (outside(e)) options.onDismiss("outside-press", event);
98
+ };
99
+ pending = { target, click };
100
+ target.addEventListener("click", click, { once: true });
101
+ } else {
102
+ options.onDismiss("outside-press", event);
103
+ }
104
+ };
105
+
106
+ const listener = onDown as EventListener;
107
+ const timer = setTimeout(() => {
108
+ for (const target of targets) target.addEventListener("pointerdown", listener, true);
109
+ }, 0);
110
+ return () => {
111
+ clearTimeout(timer);
112
+ for (const target of targets) target.removeEventListener("pointerdown", listener, true);
113
+ dropPending();
114
+ };
115
+ },
116
+ );
117
+ }
118
+
119
+ function createTooltipEscape(options: DismissOptions) {
120
+ const { layer } = options;
121
+ const onKey = (event: KeyboardEvent) => {
122
+ if (event.key !== "Escape" || event.isComposing) return;
123
+ const mine = layer.layer();
124
+ if (!mine || !mine.escape() || !takesKeys(mine)) return;
125
+ const stack = layerStack.layers();
126
+ if (stack.slice(stack.indexOf(mine) + 1).some((entry) => entry.kind !== "tooltip")) return;
127
+ options.onDismiss("escape", event);
128
+ };
129
+ document.addEventListener("keydown", onKey, true);
130
+ return () => document.removeEventListener("keydown", onKey, true);
131
+ }
132
+
133
+ const escapeHandlers = new WeakMap<Layer, (event: KeyboardEvent) => void>();
134
+ const claimedKeys = new WeakSet<Event>();
135
+
136
+ function createEscape(options: DismissOptions) {
137
+ const { layer } = options;
138
+ effect(
139
+ () =>
140
+ [
141
+ layer.layer(),
142
+ layer.layer()?.element(),
143
+ layer.layer()?.kind === "tooltip" ? "tooltip" : (options.escapeFrom ?? "layer"),
144
+ ] as const,
145
+ ([entry, element, from]) => {
146
+ if (!entry || !element) return;
147
+ if (from === "tooltip") return createTooltipEscape(options);
148
+ escapeHandlers.set(entry, (event) => options.onDismiss("escape", event));
149
+ // The root element, so the key is taken before any document listener hears it.
150
+ const target = from === "document" ? document.documentElement : element;
151
+ const onKey = (event: KeyboardEvent) => {
152
+ if (event.key !== "Escape" || event.isComposing || claimedKeys.has(event)) return;
153
+ const mine = layer.layer();
154
+ if (!mine || !takesKeys(mine)) return;
155
+ const stack = layerStack.layers().slice(layerStack.layers().indexOf(mine));
156
+ const claims = stack.findLast(
157
+ (other) =>
158
+ other.kind !== "tooltip" &&
159
+ takesKeys(other) &&
160
+ (other.escape() || other.kind === "modal"),
161
+ );
162
+ if (!claims) return;
163
+ claimedKeys.add(event);
164
+ event.stopPropagation();
165
+ if (claims.escape()) {
166
+ const handler = escapeHandlers.get(claims);
167
+ if (handler) handler(event);
168
+ else claims.dismiss?.();
169
+ }
170
+ event.preventDefault();
171
+ };
172
+ target.addEventListener("keydown", onKey as EventListener);
173
+ return () => {
174
+ target.removeEventListener("keydown", onKey as EventListener);
175
+ escapeHandlers.delete(entry);
176
+ };
177
+ },
178
+ );
179
+ }
180
+
181
+ export function createDismiss(options: DismissOptions): void {
182
+ createOutsidePress(options);
183
+ createFocusOutside(options);
184
+ createEscape(options);
185
+ }
@@ -0,0 +1,227 @@
1
+ import { type Accessor, onCleanup, untrack } from "solid-js";
2
+ import { layerStack } from "./layer-stack.js";
3
+ import { effect } from "./solid.js";
4
+
5
+ export const CANDIDATES =
6
+ 'a[href], button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), summary, [contenteditable]:not([contenteditable="false"]), [tabindex]:not([tabindex="-1"])';
7
+
8
+ const MARKED_LAYER = "[data-kb-top-layer]";
9
+
10
+ function within(ancestor: Element | undefined, node: Node): boolean {
11
+ const hosted = typeof ShadowRoot !== "undefined";
12
+ for (
13
+ let n: Node | null = node;
14
+ n;
15
+ n = hosted && n instanceof ShadowRoot ? n.host : n.parentNode
16
+ ) {
17
+ if (n === ancestor) return true;
18
+ }
19
+ return false;
20
+ }
21
+
22
+ export type InitialFocus = "container" | "first" | ((container: HTMLElement) => HTMLElement | null);
23
+
24
+ export interface FocusScopeOptions {
25
+ container: Accessor<HTMLElement | undefined>;
26
+ active: Accessor<boolean>;
27
+ trapped: Accessor<boolean>;
28
+ initialFocus?: InitialFocus;
29
+ }
30
+
31
+ export interface FocusScope {
32
+ skipRestore(): void;
33
+ untrap(): void;
34
+ }
35
+
36
+ const DOCUMENT_NODE = 9;
37
+ const SHADOW_ROOT_NODE = 11;
38
+
39
+ /** The focused element in the node's own root, or null while focus is in another root. */
40
+ export function activeOf(node: Node): Element | null {
41
+ const root = node.getRootNode();
42
+ if (root.nodeType === DOCUMENT_NODE) return (root as Document).activeElement;
43
+ if (root.nodeType !== SHADOW_ROOT_NODE) return null;
44
+ let host = (root as ShadowRoot).host;
45
+ for (let up = host.getRootNode(); up.nodeType === SHADOW_ROOT_NODE; up = host.getRootNode())
46
+ host = (up as ShadowRoot).host;
47
+ // A shadow root holds focus only while the document's focus sits on its outermost host.
48
+ return host.ownerDocument.activeElement === host ? (root as ShadowRoot).activeElement : null;
49
+ }
50
+
51
+ /** Whether `el` holds focus, from its own focus and blur events, which a sealed widget receives without asking the page. */
52
+ export function trackFocus(el: Element): { has: () => boolean; stop: () => void } {
53
+ let has = false;
54
+ const on = () => (has = true);
55
+ const off = () => (has = false);
56
+ el.addEventListener("focus", on);
57
+ el.addEventListener("blur", off);
58
+ return {
59
+ has: () => has,
60
+ stop: () => {
61
+ el.removeEventListener("focus", on);
62
+ el.removeEventListener("blur", off);
63
+ },
64
+ };
65
+ }
66
+
67
+ export function focusWithoutTracking(
68
+ el: HTMLElement | null | undefined,
69
+ options?: { preventScroll?: boolean },
70
+ ): boolean {
71
+ if (!el) return false;
72
+ untrack(() => el.focus({ preventScroll: options?.preventScroll ?? true }));
73
+ return activeOf(el) === el;
74
+ }
75
+
76
+ // Scopes in activation order: a later one sits above the earlier ones.
77
+ const activeScopes: HTMLElement[] = [];
78
+
79
+ function firstThatTakesFocus(candidates: Iterable<HTMLElement>): boolean {
80
+ for (const candidate of candidates) if (focusWithoutTracking(candidate)) return true;
81
+ return false;
82
+ }
83
+
84
+ function initialTarget(container: HTMLElement, initial: InitialFocus): HTMLElement | null {
85
+ if (initial === "container") return container;
86
+ if (initial !== "first") return initial(container);
87
+ return null;
88
+ }
89
+
90
+ // A deactivation restores after a microtask, so a scope that activates in the same tick can inherit the target.
91
+ let pendingRestore: { target: Element | null } | undefined;
92
+
93
+ // Tab stops beside the container: the browser's own order reaches them, so focus wraps without leaving the page and without hearing the key.
94
+ function edge(container: HTMLElement, onFocus: () => void): HTMLSpanElement {
95
+ const span = container.ownerDocument.createElement("span");
96
+ span.tabIndex = 0;
97
+ span.setAttribute("aria-hidden", "true");
98
+ Object.assign(span.style, {
99
+ position: "fixed",
100
+ top: "0",
101
+ left: "0",
102
+ width: "1px",
103
+ height: "1px",
104
+ overflow: "hidden",
105
+ clipPath: "inset(50%)",
106
+ whiteSpace: "nowrap",
107
+ });
108
+ span.addEventListener("focus", onFocus);
109
+ return span;
110
+ }
111
+
112
+ export function createFocusScope(options: FocusScopeOptions): FocusScope {
113
+ let skipNext = false;
114
+ let held:
115
+ | { container: HTMLElement; trapped: boolean; release: () => void; untrap: () => void }
116
+ | undefined;
117
+ onCleanup(() => held?.release());
118
+
119
+ const activate = (
120
+ container: HTMLElement,
121
+ trapped: boolean,
122
+ ): { release: () => void; untrap: () => void } => {
123
+ skipNext = false;
124
+ const previous = pendingRestore ? pendingRestore.target : activeOf(container);
125
+ pendingRestore = undefined;
126
+ activeScopes.push(container);
127
+
128
+ const initial = options.initialFocus ?? "container";
129
+ const chosen = initialTarget(container, initial);
130
+ if (chosen) focusWithoutTracking(chosen);
131
+ else if (!firstThatTakesFocus(container.querySelectorAll<HTMLElement>(CANDIDATES))) {
132
+ focusWithoutTracking(container);
133
+ }
134
+
135
+ let tab: { shift: boolean } | null = null;
136
+ let trapping = true;
137
+ const onKeyDown = (event: KeyboardEvent) => {
138
+ if (event.key === "Tab") tab = { shift: event.shiftKey };
139
+ };
140
+ const onKeyUp = (event: KeyboardEvent) => {
141
+ if (event.key === "Tab") tab = null;
142
+ };
143
+ const isAbove = (node: Node) => {
144
+ if (node instanceof Element && node.closest(MARKED_LAYER) !== null) return true;
145
+ const layers = layerStack.layers();
146
+ const mine = layers.findIndex((layer) => layer.element() === container);
147
+ return mine >= 0 && layers.slice(mine + 1).some((above) => within(above.element(), node));
148
+ };
149
+ const toCandidate = (backward: boolean) => {
150
+ const candidates = Array.from(container.querySelectorAll<HTMLElement>(CANDIDATES));
151
+ if (backward) candidates.reverse();
152
+ if (!firstThatTakesFocus(candidates)) focusWithoutTracking(container);
153
+ };
154
+ const before = edge(container, () => toCandidate(true));
155
+ const after = edge(container, () => toCandidate(false));
156
+ const onFocusOut = (event: FocusEvent) => {
157
+ const next = event.relatedTarget;
158
+ if (next === before || next === after) return;
159
+ if (next instanceof Node && (container.contains(next) || isAbove(next))) return;
160
+ if (next !== null) {
161
+ toCandidate(tab?.shift ?? false);
162
+ return;
163
+ }
164
+ // Chromium fires focusout while removing the focused node; refocusing then strands keys on a detached node.
165
+ const pressed = tab;
166
+ queueMicrotask(() => {
167
+ const current = activeOf(container);
168
+ if (trapping && container.isConnected && !(current && container.contains(current))) {
169
+ if (pressed) toCandidate(pressed.shift);
170
+ else focusWithoutTracking(container);
171
+ }
172
+ });
173
+ };
174
+ if (trapped) {
175
+ container.addEventListener("keydown", onKeyDown);
176
+ container.addEventListener("keyup", onKeyUp);
177
+ container.addEventListener("focusout", onFocusOut);
178
+ container.before(before);
179
+ container.after(after);
180
+ }
181
+
182
+ const untrap = () => {
183
+ trapping = false;
184
+ before.remove();
185
+ after.remove();
186
+ container.removeEventListener("keydown", onKeyDown);
187
+ container.removeEventListener("keyup", onKeyUp);
188
+ container.removeEventListener("focusout", onFocusOut);
189
+ };
190
+
191
+ const release = () => {
192
+ untrap();
193
+ activeScopes.splice(activeScopes.indexOf(container), 1);
194
+ if (skipNext) return;
195
+ const pending = { target: previous };
196
+ pendingRestore = pending;
197
+ queueMicrotask(() => {
198
+ if (pendingRestore !== pending) return;
199
+ pendingRestore = undefined;
200
+ const current = activeOf(container);
201
+ const tookOver = activeScopes.some((scope) => current && scope.contains(current));
202
+ if (!tookOver && previous instanceof HTMLElement && previous.isConnected) {
203
+ focusWithoutTracking(previous);
204
+ }
205
+ });
206
+ };
207
+ return { release, untrap };
208
+ };
209
+
210
+ effect(
211
+ () => [options.container(), options.active(), options.trapped()] as const,
212
+ ([container, active, trapped]) => {
213
+ const wanted = container && active ? container : undefined;
214
+ if (held && held.container === wanted && held.trapped === trapped) return;
215
+ held?.release();
216
+ held = wanted ? { container: wanted, trapped, ...activate(wanted, trapped) } : undefined;
217
+ },
218
+ );
219
+ return {
220
+ skipRestore() {
221
+ skipNext = true;
222
+ },
223
+ untrap() {
224
+ held?.untrap();
225
+ },
226
+ };
227
+ }