@zag-js/tooltip 1.47.0 → 1.48.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.
@@ -1,432 +1,421 @@
1
- // src/tooltip.machine.ts
2
- import { createGuards, createMachine } from "@zag-js/core";
1
+ import { getActiveTriggerEl, getPositionerEl } from "./tooltip.dom.mjs";
2
+ import { store } from "./tooltip.store.mjs";
3
3
  import { addDomEvent, getOverflowAncestors, isComposingEvent } from "@zag-js/dom-query";
4
4
  import { trackFocusVisible } from "@zag-js/focus-visible";
5
5
  import { getPlacement } from "@zag-js/popper";
6
6
  import { ensureProps } from "@zag-js/utils";
7
- import * as dom from "./tooltip.dom.mjs";
8
- import { store } from "./tooltip.store.mjs";
9
- var { and, not } = createGuards();
10
- var machine = createMachine({
11
- initialState: ({ prop }) => {
12
- const open = prop("open") || prop("defaultOpen");
13
- return open ? "open" : "closed";
14
- },
15
- props({ props }) {
16
- ensureProps(props, ["id"]);
17
- const closeOnClick = props.closeOnClick ?? true;
18
- const closeOnPointerDown = props.closeOnPointerDown ?? closeOnClick;
19
- return {
20
- openDelay: 400,
21
- closeDelay: 150,
22
- closeOnEscape: true,
23
- interactive: false,
24
- closeOnScroll: true,
25
- disabled: false,
26
- ...props,
27
- closeOnPointerDown,
28
- closeOnClick,
29
- positioning: {
30
- placement: "bottom",
31
- ...props.positioning
32
- }
33
- };
34
- },
35
- effects: ["trackFocusVisible", "trackStore"],
36
- exit: ["clearGlobalId"],
37
- context: ({ bindable, prop, scope }) => ({
38
- currentPlacement: bindable(() => ({ defaultValue: void 0 })),
39
- hasPointerMoveOpened: bindable(() => ({ defaultValue: null })),
40
- triggerValue: bindable(() => ({
41
- defaultValue: prop("defaultTriggerValue") ?? null,
42
- value: prop("triggerValue"),
43
- onChange(value) {
44
- const onTriggerValueChange = prop("onTriggerValueChange");
45
- if (!onTriggerValueChange) return;
46
- const triggerElement = dom.getActiveTriggerEl(scope, value);
47
- onTriggerValueChange({ value, triggerElement });
48
- }
49
- }))
50
- }),
51
- watch({ track, action, prop }) {
52
- track([() => prop("disabled")], () => {
53
- action(["closeIfDisabled"]);
54
- });
55
- track([() => prop("open")], () => {
56
- action(["toggleVisibility"]);
57
- });
58
- track([() => prop("triggerValue")], () => {
59
- action(["repositionImmediate"]);
60
- });
61
- },
62
- on: {
63
- "triggerValue.set": {
64
- actions: ["setTriggerValue", "repositionImmediate"]
65
- }
66
- },
67
- states: {
68
- closed: {
69
- entry: ["clearGlobalId"],
70
- on: {
71
- "controlled.open": {
72
- target: "open"
73
- },
74
- open: [
75
- {
76
- guard: "isOpenControlled",
77
- actions: ["setTriggerValue", "invokeOnOpen"]
78
- },
79
- {
80
- target: "open",
81
- actions: ["setTriggerValue", "invokeOnOpen"]
82
- }
83
- ],
84
- "pointer.leave": {
85
- actions: ["clearPointerMoveOpened"]
86
- },
87
- "pointer.move": [
88
- {
89
- guard: and("noVisibleTooltip", not("hasPointerMoveOpened")),
90
- target: "opening",
91
- actions: ["setTriggerValue"]
92
- },
93
- {
94
- guard: not("hasPointerMoveOpened"),
95
- target: "open",
96
- actions: ["setPointerMoveOpened", "invokeOnOpen", "setTriggerValue"]
97
- }
98
- ]
99
- }
100
- },
101
- opening: {
102
- effects: ["trackScroll", "trackPointerlockChange", "waitForOpenDelay"],
103
- on: {
104
- "after.openDelay": [
105
- {
106
- guard: "isOpenControlled",
107
- actions: ["setPointerMoveOpened", "invokeOnOpen"]
108
- },
109
- {
110
- target: "open",
111
- actions: ["setPointerMoveOpened", "invokeOnOpen"]
112
- }
113
- ],
114
- "controlled.open": {
115
- target: "open"
116
- },
117
- "controlled.close": {
118
- target: "closed"
119
- },
120
- open: [
121
- {
122
- guard: "isOpenControlled",
123
- actions: ["setTriggerValue", "invokeOnOpen"]
124
- },
125
- {
126
- target: "open",
127
- actions: ["setTriggerValue", "invokeOnOpen"]
128
- }
129
- ],
130
- "pointer.leave": [
131
- {
132
- guard: "isDisabled",
133
- actions: ["clearPointerMoveOpened"]
134
- },
135
- {
136
- guard: "isOpenControlled",
137
- // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
138
- actions: ["clearPointerMoveOpened", "invokeOnClose", "toggleVisibility"]
139
- },
140
- {
141
- target: "closed",
142
- actions: ["clearPointerMoveOpened", "invokeOnClose"]
143
- }
144
- ],
145
- close: [
146
- {
147
- guard: "isOpenControlled",
148
- // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
149
- actions: ["invokeOnClose", "toggleVisibility"]
150
- },
151
- {
152
- target: "closed",
153
- actions: ["invokeOnClose"]
154
- }
155
- ]
156
- }
157
- },
158
- open: {
159
- effects: ["trackEscapeKey", "trackScroll", "trackPointerlockChange", "trackPositioning"],
160
- entry: ["setGlobalId"],
161
- on: {
162
- "controlled.close": {
163
- target: "closed"
164
- },
165
- close: [
166
- {
167
- guard: "isOpenControlled",
168
- actions: ["invokeOnClose"]
169
- },
170
- {
171
- target: "closed",
172
- actions: ["invokeOnClose"]
173
- }
174
- ],
175
- "pointer.leave": [
176
- {
177
- // A controlled tooltip can stay open while disabled
178
- guard: "isDisabled",
179
- actions: ["clearPointerMoveOpened"]
180
- },
181
- {
182
- guard: "isVisible",
183
- target: "closing",
184
- actions: ["clearPointerMoveOpened"]
185
- },
186
- // == group ==
187
- {
188
- guard: "isOpenControlled",
189
- actions: ["clearPointerMoveOpened", "invokeOnClose"]
190
- },
191
- {
192
- target: "closed",
193
- actions: ["clearPointerMoveOpened", "invokeOnClose"]
194
- }
195
- ],
196
- "content.pointer.leave": {
197
- guard: "isInteractive",
198
- target: "closing"
199
- },
200
- "positioning.set": {
201
- actions: ["reposition"]
202
- },
203
- "triggerValue.set": {
204
- // Transition to closing (which cleans up trackPositioning) then immediately back to open
205
- // This re-creates the positioning effect with the new trigger
206
- target: "closing",
207
- actions: ["setTriggerValue", "immediateReopen"]
208
- }
209
- }
210
- },
211
- closing: {
212
- effects: ["trackPositioning", "waitForCloseDelay"],
213
- on: {
214
- "after.closeDelay": [
215
- {
216
- guard: "isOpenControlled",
217
- actions: ["invokeOnClose"]
218
- },
219
- {
220
- target: "closed",
221
- actions: ["invokeOnClose"]
222
- }
223
- ],
224
- "controlled.close": {
225
- target: "closed"
226
- },
227
- "controlled.open": {
228
- target: "open"
229
- },
230
- close: [
231
- {
232
- guard: "isOpenControlled",
233
- actions: ["invokeOnClose"]
234
- },
235
- {
236
- target: "closed",
237
- actions: ["invokeOnClose"]
238
- }
239
- ],
240
- "pointer.move": [
241
- {
242
- guard: "isOpenControlled",
243
- // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
244
- actions: ["setPointerMoveOpened", "setTriggerValue", "invokeOnOpen", "toggleVisibility"]
245
- },
246
- {
247
- target: "open",
248
- actions: ["setPointerMoveOpened", "setTriggerValue", "invokeOnOpen"]
249
- }
250
- ],
251
- "triggerValue.set": {
252
- target: "open",
253
- actions: ["setTriggerValue", "repositionImmediate"]
254
- },
255
- reopen: {
256
- target: "open"
257
- },
258
- "content.pointer.move": {
259
- guard: "isInteractive",
260
- target: "open"
261
- },
262
- "positioning.set": {
263
- actions: ["reposition"]
264
- }
265
- }
266
- }
267
- },
268
- implementations: {
269
- guards: {
270
- noVisibleTooltip: () => store.get("id") === null,
271
- isVisible: ({ prop }) => prop("id") === store.get("id"),
272
- isInteractive: ({ prop }) => !!prop("interactive"),
273
- hasPointerMoveOpened: ({ context }) => !!context.get("hasPointerMoveOpened"),
274
- isOpenControlled: ({ prop }) => prop("open") !== void 0,
275
- isDisabled: ({ prop }) => !!prop("disabled")
276
- },
277
- actions: {
278
- setGlobalId: ({ prop }) => {
279
- const prevId = store.get("id");
280
- const isInstant = prevId !== null && prevId !== prop("id");
281
- store.update({ id: prop("id"), prevId: isInstant ? prevId : null, instant: isInstant });
282
- },
283
- clearGlobalId: ({ prop }) => {
284
- if (prop("id") === store.get("id")) {
285
- store.update({ id: null, prevId: null, instant: false });
286
- }
287
- },
288
- invokeOnOpen: ({ prop }) => {
289
- prop("onOpenChange")?.({ open: true });
290
- },
291
- invokeOnClose: ({ prop }) => {
292
- prop("onOpenChange")?.({ open: false });
293
- },
294
- closeIfDisabled: ({ prop, send }) => {
295
- if (!prop("disabled")) return;
296
- send({ type: "close", src: "disabled.change" });
297
- },
298
- reposition: ({ context, event, prop, scope }) => {
299
- if (event.type !== "positioning.set") return;
300
- const getPositionerEl2 = () => dom.getPositionerEl(scope);
301
- const getTriggerEl = () => dom.getActiveTriggerEl(scope, context.get("triggerValue"));
302
- getPlacement(getTriggerEl, getPositionerEl2, {
303
- ...prop("positioning"),
304
- ...event.options,
305
- listeners: false,
306
- onComplete(data) {
307
- context.set("currentPlacement", data.placement);
308
- }
309
- });
310
- },
311
- repositionImmediate: ({ context, event, prop, scope }) => {
312
- const triggerValue = event.value ?? context.get("triggerValue");
313
- const getPositionerEl2 = () => dom.getPositionerEl(scope);
314
- const getTriggerEl = () => dom.getActiveTriggerEl(scope, triggerValue);
315
- return getPlacement(getTriggerEl, getPositionerEl2, {
316
- ...prop("positioning"),
317
- onComplete(data) {
318
- context.set("currentPlacement", data.placement);
319
- }
320
- });
321
- },
322
- toggleVisibility: ({ prop, event, send }) => {
323
- queueMicrotask(() => {
324
- send({
325
- type: prop("open") ? "controlled.open" : "controlled.close",
326
- previousEvent: event
327
- });
328
- });
329
- },
330
- setPointerMoveOpened: ({ context, event }) => {
331
- const triggerId = event.triggerId ?? event.previousEvent?.triggerId;
332
- context.set("hasPointerMoveOpened", triggerId ?? null);
333
- },
334
- clearPointerMoveOpened: ({ context }) => {
335
- context.set("hasPointerMoveOpened", null);
336
- },
337
- setTriggerValue: ({ context, event }) => {
338
- if (event.value === void 0) return;
339
- context.set("triggerValue", event.value);
340
- },
341
- immediateReopen: ({ send }) => {
342
- queueMicrotask(() => {
343
- send({ type: "reopen" });
344
- });
345
- }
346
- },
347
- effects: {
348
- trackFocusVisible: ({ scope }) => {
349
- return trackFocusVisible({ root: scope.getRootNode?.() });
350
- },
351
- trackPositioning: ({ context, prop, scope }) => {
352
- if (!context.get("currentPlacement")) {
353
- context.set("currentPlacement", prop("positioning").placement);
354
- }
355
- const getPositionerEl2 = () => dom.getPositionerEl(scope);
356
- const getTriggerEl = () => dom.getActiveTriggerEl(scope, context.get("triggerValue"));
357
- return getPlacement(getTriggerEl, getPositionerEl2, {
358
- ...prop("positioning"),
359
- defer: true,
360
- onComplete(data) {
361
- context.set("currentPlacement", data.placement);
362
- }
363
- });
364
- },
365
- trackPointerlockChange: ({ send, scope }) => {
366
- const doc = scope.getDoc();
367
- const onChange = () => send({ type: "close", src: "pointerlock:change" });
368
- return addDomEvent(doc, "pointerlockchange", onChange, false);
369
- },
370
- trackScroll: ({ send, prop, scope, context }) => {
371
- if (!prop("closeOnScroll")) return;
372
- const triggerValue = context.get("triggerValue");
373
- const triggerEl = dom.getActiveTriggerEl(scope, triggerValue);
374
- if (!triggerEl) return;
375
- const overflowParents = getOverflowAncestors(triggerEl);
376
- const cleanups = overflowParents.map((overflowParent) => {
377
- const onScroll = () => {
378
- send({ type: "close", src: "scroll" });
379
- };
380
- return addDomEvent(overflowParent, "scroll", onScroll, {
381
- passive: true,
382
- capture: true
383
- });
384
- });
385
- return () => {
386
- cleanups.forEach((fn) => fn?.());
387
- };
388
- },
389
- trackStore: ({ prop, send }) => {
390
- let cleanup;
391
- let cancelled = false;
392
- queueMicrotask(() => {
393
- if (cancelled) return;
394
- cleanup = store.subscribe(() => {
395
- if (store.get("id") !== prop("id")) {
396
- send({ type: "close", src: "id.change" });
397
- }
398
- });
399
- });
400
- return () => {
401
- cancelled = true;
402
- cleanup?.();
403
- };
404
- },
405
- trackEscapeKey: ({ send, prop }) => {
406
- if (!prop("closeOnEscape")) return;
407
- const onKeyDown = (event) => {
408
- if (isComposingEvent(event)) return;
409
- if (event.key !== "Escape") return;
410
- event.stopPropagation();
411
- send({ type: "close", src: "keydown.escape" });
412
- };
413
- return addDomEvent(document, "keydown", onKeyDown, true);
414
- },
415
- waitForOpenDelay: ({ send, prop, event }) => {
416
- const id = setTimeout(() => {
417
- send({ type: "after.openDelay", previousEvent: event });
418
- }, prop("openDelay"));
419
- return () => clearTimeout(id);
420
- },
421
- waitForCloseDelay: ({ send, prop, event }) => {
422
- const id = setTimeout(() => {
423
- send({ type: "after.closeDelay", previousEvent: event });
424
- }, prop("closeDelay"));
425
- return () => clearTimeout(id);
426
- }
427
- }
428
- }
7
+ import { createGuards, createMachine } from "@zag-js/core";
8
+ // src/tooltip.machine.ts
9
+ const { and, not } = createGuards();
10
+ const machine = createMachine({
11
+ initialState: ({ prop }) => {
12
+ return prop("open") || prop("defaultOpen") ? "open" : "closed";
13
+ },
14
+ props({ props }) {
15
+ ensureProps(props, ["id"]);
16
+ const closeOnClick = props.closeOnClick ?? true;
17
+ const closeOnPointerDown = props.closeOnPointerDown ?? closeOnClick;
18
+ return {
19
+ openDelay: 400,
20
+ closeDelay: 150,
21
+ closeOnEscape: true,
22
+ interactive: false,
23
+ closeOnScroll: true,
24
+ disabled: false,
25
+ ...props,
26
+ closeOnPointerDown,
27
+ closeOnClick,
28
+ positioning: {
29
+ placement: "bottom",
30
+ ...props.positioning
31
+ }
32
+ };
33
+ },
34
+ effects: ["trackFocusVisible", "trackStore"],
35
+ exit: ["clearGlobalId"],
36
+ context: ({ bindable, prop, scope }) => ({
37
+ currentPlacement: bindable(() => ({ defaultValue: void 0 })),
38
+ hasPointerMoveOpened: bindable(() => ({ defaultValue: null })),
39
+ triggerValue: bindable(() => ({
40
+ defaultValue: prop("defaultTriggerValue") ?? null,
41
+ value: prop("triggerValue"),
42
+ onChange(value) {
43
+ const onTriggerValueChange = prop("onTriggerValueChange");
44
+ if (!onTriggerValueChange) return;
45
+ onTriggerValueChange({
46
+ value,
47
+ triggerElement: getActiveTriggerEl(scope, value)
48
+ });
49
+ }
50
+ }))
51
+ }),
52
+ watch({ track, action, prop }) {
53
+ track([() => prop("disabled")], () => {
54
+ action(["closeIfDisabled"]);
55
+ });
56
+ track([() => prop("open")], () => {
57
+ action(["toggleVisibility"]);
58
+ });
59
+ track([() => prop("triggerValue")], () => {
60
+ action(["repositionImmediate"]);
61
+ });
62
+ },
63
+ on: { "triggerValue.set": { actions: ["setTriggerValue", "repositionImmediate"] } },
64
+ states: {
65
+ closed: {
66
+ entry: ["clearGlobalId"],
67
+ on: {
68
+ "controlled.open": { target: "open" },
69
+ open: [{
70
+ guard: "isOpenControlled",
71
+ actions: ["setTriggerValue", "invokeOnOpen"]
72
+ }, {
73
+ target: "open",
74
+ actions: ["setTriggerValue", "invokeOnOpen"]
75
+ }],
76
+ "pointer.leave": { actions: ["clearPointerMoveOpened"] },
77
+ "pointer.move": [{
78
+ guard: and("noVisibleTooltip", not("hasPointerMoveOpened")),
79
+ target: "opening",
80
+ actions: ["setTriggerValue"]
81
+ }, {
82
+ guard: not("hasPointerMoveOpened"),
83
+ target: "open",
84
+ actions: [
85
+ "setPointerMoveOpened",
86
+ "invokeOnOpen",
87
+ "setTriggerValue"
88
+ ]
89
+ }]
90
+ }
91
+ },
92
+ opening: {
93
+ effects: [
94
+ "trackScroll",
95
+ "trackPointerlockChange",
96
+ "waitForOpenDelay"
97
+ ],
98
+ on: {
99
+ "after.openDelay": [{
100
+ guard: "isOpenControlled",
101
+ actions: ["setPointerMoveOpened", "invokeOnOpen"]
102
+ }, {
103
+ target: "open",
104
+ actions: ["setPointerMoveOpened", "invokeOnOpen"]
105
+ }],
106
+ "controlled.open": { target: "open" },
107
+ "controlled.close": { target: "closed" },
108
+ open: [{
109
+ guard: "isOpenControlled",
110
+ actions: ["setTriggerValue", "invokeOnOpen"]
111
+ }, {
112
+ target: "open",
113
+ actions: ["setTriggerValue", "invokeOnOpen"]
114
+ }],
115
+ "pointer.leave": [
116
+ {
117
+ guard: "isDisabled",
118
+ actions: ["clearPointerMoveOpened"]
119
+ },
120
+ {
121
+ guard: "isOpenControlled",
122
+ actions: [
123
+ "clearPointerMoveOpened",
124
+ "invokeOnClose",
125
+ "toggleVisibility"
126
+ ]
127
+ },
128
+ {
129
+ target: "closed",
130
+ actions: ["clearPointerMoveOpened", "invokeOnClose"]
131
+ }
132
+ ],
133
+ close: [{
134
+ guard: "isOpenControlled",
135
+ actions: ["invokeOnClose", "toggleVisibility"]
136
+ }, {
137
+ target: "closed",
138
+ actions: ["invokeOnClose"]
139
+ }]
140
+ }
141
+ },
142
+ open: {
143
+ effects: [
144
+ "trackEscapeKey",
145
+ "trackScroll",
146
+ "trackPointerlockChange",
147
+ "trackPositioning"
148
+ ],
149
+ entry: ["setGlobalId"],
150
+ on: {
151
+ "controlled.close": { target: "closed" },
152
+ close: [{
153
+ guard: "isOpenControlled",
154
+ actions: ["invokeOnClose"]
155
+ }, {
156
+ target: "closed",
157
+ actions: ["invokeOnClose"]
158
+ }],
159
+ "pointer.leave": [
160
+ {
161
+ guard: "isDisabled",
162
+ actions: ["clearPointerMoveOpened"]
163
+ },
164
+ {
165
+ guard: "isVisible",
166
+ target: "closing",
167
+ actions: ["clearPointerMoveOpened"]
168
+ },
169
+ {
170
+ guard: "isOpenControlled",
171
+ actions: ["clearPointerMoveOpened", "invokeOnClose"]
172
+ },
173
+ {
174
+ target: "closed",
175
+ actions: ["clearPointerMoveOpened", "invokeOnClose"]
176
+ }
177
+ ],
178
+ "content.pointer.leave": {
179
+ guard: "isInteractive",
180
+ target: "closing"
181
+ },
182
+ "positioning.set": { actions: ["reposition"] },
183
+ "triggerValue.set": {
184
+ target: "closing",
185
+ actions: ["setTriggerValue", "immediateReopen"]
186
+ }
187
+ }
188
+ },
189
+ closing: {
190
+ effects: ["trackPositioning", "waitForCloseDelay"],
191
+ on: {
192
+ "after.closeDelay": [{
193
+ guard: "isOpenControlled",
194
+ actions: ["invokeOnClose"]
195
+ }, {
196
+ target: "closed",
197
+ actions: ["invokeOnClose"]
198
+ }],
199
+ "controlled.close": { target: "closed" },
200
+ "controlled.open": { target: "open" },
201
+ close: [{
202
+ guard: "isOpenControlled",
203
+ actions: ["invokeOnClose"]
204
+ }, {
205
+ target: "closed",
206
+ actions: ["invokeOnClose"]
207
+ }],
208
+ "pointer.move": [{
209
+ guard: "isOpenControlled",
210
+ actions: [
211
+ "setPointerMoveOpened",
212
+ "setTriggerValue",
213
+ "invokeOnOpen",
214
+ "toggleVisibility"
215
+ ]
216
+ }, {
217
+ target: "open",
218
+ actions: [
219
+ "setPointerMoveOpened",
220
+ "setTriggerValue",
221
+ "invokeOnOpen"
222
+ ]
223
+ }],
224
+ "triggerValue.set": {
225
+ target: "open",
226
+ actions: ["setTriggerValue", "repositionImmediate"]
227
+ },
228
+ reopen: { target: "open" },
229
+ "content.pointer.move": {
230
+ guard: "isInteractive",
231
+ target: "open"
232
+ },
233
+ "positioning.set": { actions: ["reposition"] }
234
+ }
235
+ }
236
+ },
237
+ implementations: {
238
+ guards: {
239
+ noVisibleTooltip: () => store.get("id") === null,
240
+ isVisible: ({ prop }) => prop("id") === store.get("id"),
241
+ isInteractive: ({ prop }) => !!prop("interactive"),
242
+ hasPointerMoveOpened: ({ context }) => !!context.get("hasPointerMoveOpened"),
243
+ isOpenControlled: ({ prop }) => prop("open") !== void 0,
244
+ isDisabled: ({ prop }) => !!prop("disabled")
245
+ },
246
+ actions: {
247
+ setGlobalId: ({ prop }) => {
248
+ const prevId = store.get("id");
249
+ const isInstant = prevId !== null && prevId !== prop("id");
250
+ store.update({
251
+ id: prop("id"),
252
+ prevId: isInstant ? prevId : null,
253
+ instant: isInstant
254
+ });
255
+ },
256
+ clearGlobalId: ({ prop }) => {
257
+ if (prop("id") === store.get("id")) store.update({
258
+ id: null,
259
+ prevId: null,
260
+ instant: false
261
+ });
262
+ },
263
+ invokeOnOpen: ({ prop }) => {
264
+ prop("onOpenChange")?.({ open: true });
265
+ },
266
+ invokeOnClose: ({ prop }) => {
267
+ prop("onOpenChange")?.({ open: false });
268
+ },
269
+ closeIfDisabled: ({ prop, send }) => {
270
+ if (!prop("disabled")) return;
271
+ send({
272
+ type: "close",
273
+ src: "disabled.change"
274
+ });
275
+ },
276
+ reposition: ({ context, event, prop, scope }) => {
277
+ if (event.type !== "positioning.set") return;
278
+ const getPositionerEl$1 = () => getPositionerEl(scope);
279
+ const getTriggerEl = () => getActiveTriggerEl(scope, context.get("triggerValue"));
280
+ getPlacement(getTriggerEl, getPositionerEl$1, {
281
+ ...prop("positioning"),
282
+ ...event.options,
283
+ listeners: false,
284
+ onComplete(data) {
285
+ context.set("currentPlacement", data.placement);
286
+ }
287
+ });
288
+ },
289
+ repositionImmediate: ({ context, event, prop, scope }) => {
290
+ const triggerValue = event.value ?? context.get("triggerValue");
291
+ const getPositionerEl$2 = () => getPositionerEl(scope);
292
+ const getTriggerEl = () => getActiveTriggerEl(scope, triggerValue);
293
+ return getPlacement(getTriggerEl, getPositionerEl$2, {
294
+ ...prop("positioning"),
295
+ onComplete(data) {
296
+ context.set("currentPlacement", data.placement);
297
+ }
298
+ });
299
+ },
300
+ toggleVisibility: ({ prop, event, send }) => {
301
+ queueMicrotask(() => {
302
+ send({
303
+ type: prop("open") ? "controlled.open" : "controlled.close",
304
+ previousEvent: event
305
+ });
306
+ });
307
+ },
308
+ setPointerMoveOpened: ({ context, event }) => {
309
+ const triggerId = event.triggerId ?? event.previousEvent?.triggerId;
310
+ context.set("hasPointerMoveOpened", triggerId ?? null);
311
+ },
312
+ clearPointerMoveOpened: ({ context }) => {
313
+ context.set("hasPointerMoveOpened", null);
314
+ },
315
+ setTriggerValue: ({ context, event }) => {
316
+ if (event.value === void 0) return;
317
+ context.set("triggerValue", event.value);
318
+ },
319
+ immediateReopen: ({ send }) => {
320
+ queueMicrotask(() => {
321
+ send({ type: "reopen" });
322
+ });
323
+ }
324
+ },
325
+ effects: {
326
+ trackFocusVisible: ({ scope }) => {
327
+ return trackFocusVisible({ root: scope.getRootNode?.() });
328
+ },
329
+ trackPositioning: ({ context, prop, scope }) => {
330
+ if (!context.get("currentPlacement")) context.set("currentPlacement", prop("positioning").placement);
331
+ const getPositionerEl$3 = () => getPositionerEl(scope);
332
+ const getTriggerEl = () => getActiveTriggerEl(scope, context.get("triggerValue"));
333
+ return getPlacement(getTriggerEl, getPositionerEl$3, {
334
+ ...prop("positioning"),
335
+ defer: true,
336
+ onComplete(data) {
337
+ context.set("currentPlacement", data.placement);
338
+ }
339
+ });
340
+ },
341
+ trackPointerlockChange: ({ send, scope }) => {
342
+ const doc = scope.getDoc();
343
+ const onChange = () => send({
344
+ type: "close",
345
+ src: "pointerlock:change"
346
+ });
347
+ return addDomEvent(doc, "pointerlockchange", onChange, false);
348
+ },
349
+ trackScroll: ({ send, prop, scope, context }) => {
350
+ if (!prop("closeOnScroll")) return;
351
+ const triggerValue = context.get("triggerValue");
352
+ const triggerEl = getActiveTriggerEl(scope, triggerValue);
353
+ if (!triggerEl) return;
354
+ const cleanups = getOverflowAncestors(triggerEl).map((overflowParent) => {
355
+ const onScroll = () => {
356
+ send({
357
+ type: "close",
358
+ src: "scroll"
359
+ });
360
+ };
361
+ return addDomEvent(overflowParent, "scroll", onScroll, {
362
+ passive: true,
363
+ capture: true
364
+ });
365
+ });
366
+ return () => {
367
+ cleanups.forEach((fn) => fn?.());
368
+ };
369
+ },
370
+ trackStore: ({ prop, send }) => {
371
+ let cleanup;
372
+ let cancelled = false;
373
+ queueMicrotask(() => {
374
+ if (cancelled) return;
375
+ cleanup = store.subscribe(() => {
376
+ if (store.get("id") !== prop("id")) send({
377
+ type: "close",
378
+ src: "id.change"
379
+ });
380
+ });
381
+ });
382
+ return () => {
383
+ cancelled = true;
384
+ cleanup?.();
385
+ };
386
+ },
387
+ trackEscapeKey: ({ send, prop }) => {
388
+ if (!prop("closeOnEscape")) return;
389
+ const onKeyDown = (event) => {
390
+ if (isComposingEvent(event)) return;
391
+ if (event.key !== "Escape") return;
392
+ event.stopPropagation();
393
+ send({
394
+ type: "close",
395
+ src: "keydown.escape"
396
+ });
397
+ };
398
+ return addDomEvent(document, "keydown", onKeyDown, true);
399
+ },
400
+ waitForOpenDelay: ({ send, prop, event }) => {
401
+ const id = setTimeout(() => {
402
+ send({
403
+ type: "after.openDelay",
404
+ previousEvent: event
405
+ });
406
+ }, prop("openDelay"));
407
+ return () => clearTimeout(id);
408
+ },
409
+ waitForCloseDelay: ({ send, prop, event }) => {
410
+ const id = setTimeout(() => {
411
+ send({
412
+ type: "after.closeDelay",
413
+ previousEvent: event
414
+ });
415
+ }, prop("closeDelay"));
416
+ return () => clearTimeout(id);
417
+ }
418
+ }
419
+ }
429
420
  });
430
- export {
431
- machine
432
- };
421
+ export { machine };