@zag-js/tooltip 1.46.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,417 +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: "isOpenControlled",
133
- // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
134
- actions: ["clearPointerMoveOpened", "invokeOnClose", "toggleVisibility"]
135
- },
136
- {
137
- target: "closed",
138
- actions: ["clearPointerMoveOpened", "invokeOnClose"]
139
- }
140
- ],
141
- close: [
142
- {
143
- guard: "isOpenControlled",
144
- // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
145
- actions: ["invokeOnClose", "toggleVisibility"]
146
- },
147
- {
148
- target: "closed",
149
- actions: ["invokeOnClose"]
150
- }
151
- ]
152
- }
153
- },
154
- open: {
155
- effects: ["trackEscapeKey", "trackScroll", "trackPointerlockChange", "trackPositioning"],
156
- entry: ["setGlobalId"],
157
- on: {
158
- "controlled.close": {
159
- target: "closed"
160
- },
161
- close: [
162
- {
163
- guard: "isOpenControlled",
164
- actions: ["invokeOnClose"]
165
- },
166
- {
167
- target: "closed",
168
- actions: ["invokeOnClose"]
169
- }
170
- ],
171
- "pointer.leave": [
172
- {
173
- guard: "isVisible",
174
- target: "closing",
175
- actions: ["clearPointerMoveOpened"]
176
- },
177
- // == group ==
178
- {
179
- guard: "isOpenControlled",
180
- actions: ["clearPointerMoveOpened", "invokeOnClose"]
181
- },
182
- {
183
- target: "closed",
184
- actions: ["clearPointerMoveOpened", "invokeOnClose"]
185
- }
186
- ],
187
- "content.pointer.leave": {
188
- guard: "isInteractive",
189
- target: "closing"
190
- },
191
- "positioning.set": {
192
- actions: ["reposition"]
193
- },
194
- "triggerValue.set": {
195
- // Transition to closing (which cleans up trackPositioning) then immediately back to open
196
- // This re-creates the positioning effect with the new trigger
197
- target: "closing",
198
- actions: ["setTriggerValue", "immediateReopen"]
199
- }
200
- }
201
- },
202
- closing: {
203
- effects: ["trackPositioning", "waitForCloseDelay"],
204
- on: {
205
- "after.closeDelay": [
206
- {
207
- guard: "isOpenControlled",
208
- actions: ["invokeOnClose"]
209
- },
210
- {
211
- target: "closed",
212
- actions: ["invokeOnClose"]
213
- }
214
- ],
215
- "controlled.close": {
216
- target: "closed"
217
- },
218
- "controlled.open": {
219
- target: "open"
220
- },
221
- close: [
222
- {
223
- guard: "isOpenControlled",
224
- actions: ["invokeOnClose"]
225
- },
226
- {
227
- target: "closed",
228
- actions: ["invokeOnClose"]
229
- }
230
- ],
231
- "pointer.move": [
232
- {
233
- guard: "isOpenControlled",
234
- // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
235
- actions: ["setPointerMoveOpened", "setTriggerValue", "invokeOnOpen", "toggleVisibility"]
236
- },
237
- {
238
- target: "open",
239
- actions: ["setPointerMoveOpened", "setTriggerValue", "invokeOnOpen"]
240
- }
241
- ],
242
- "triggerValue.set": {
243
- target: "open",
244
- actions: ["setTriggerValue", "repositionImmediate"]
245
- },
246
- reopen: {
247
- target: "open"
248
- },
249
- "content.pointer.move": {
250
- guard: "isInteractive",
251
- target: "open"
252
- },
253
- "positioning.set": {
254
- actions: ["reposition"]
255
- }
256
- }
257
- }
258
- },
259
- implementations: {
260
- guards: {
261
- noVisibleTooltip: () => store.get("id") === null,
262
- isVisible: ({ prop }) => prop("id") === store.get("id"),
263
- isInteractive: ({ prop }) => !!prop("interactive"),
264
- hasPointerMoveOpened: ({ context }) => !!context.get("hasPointerMoveOpened"),
265
- isOpenControlled: ({ prop }) => prop("open") !== void 0
266
- },
267
- actions: {
268
- setGlobalId: ({ prop }) => {
269
- const prevId = store.get("id");
270
- const isInstant = prevId !== null && prevId !== prop("id");
271
- store.update({ id: prop("id"), prevId: isInstant ? prevId : null, instant: isInstant });
272
- },
273
- clearGlobalId: ({ prop }) => {
274
- if (prop("id") === store.get("id")) {
275
- store.update({ id: null, prevId: null, instant: false });
276
- }
277
- },
278
- invokeOnOpen: ({ prop }) => {
279
- prop("onOpenChange")?.({ open: true });
280
- },
281
- invokeOnClose: ({ prop }) => {
282
- prop("onOpenChange")?.({ open: false });
283
- },
284
- closeIfDisabled: ({ prop, send }) => {
285
- if (!prop("disabled")) return;
286
- send({ type: "close", src: "disabled.change" });
287
- },
288
- reposition: ({ context, event, prop, scope }) => {
289
- if (event.type !== "positioning.set") return;
290
- const getPositionerEl2 = () => dom.getPositionerEl(scope);
291
- const getTriggerEl = () => dom.getActiveTriggerEl(scope, context.get("triggerValue"));
292
- getPlacement(getTriggerEl, getPositionerEl2, {
293
- ...prop("positioning"),
294
- ...event.options,
295
- listeners: false,
296
- onComplete(data) {
297
- context.set("currentPlacement", data.placement);
298
- }
299
- });
300
- },
301
- repositionImmediate: ({ context, event, prop, scope }) => {
302
- const triggerValue = event.value ?? context.get("triggerValue");
303
- const getPositionerEl2 = () => dom.getPositionerEl(scope);
304
- const getTriggerEl = () => dom.getActiveTriggerEl(scope, triggerValue);
305
- return getPlacement(getTriggerEl, getPositionerEl2, {
306
- ...prop("positioning"),
307
- onComplete(data) {
308
- context.set("currentPlacement", data.placement);
309
- }
310
- });
311
- },
312
- toggleVisibility: ({ prop, event, send }) => {
313
- queueMicrotask(() => {
314
- send({
315
- type: prop("open") ? "controlled.open" : "controlled.close",
316
- previousEvent: event
317
- });
318
- });
319
- },
320
- setPointerMoveOpened: ({ context, event }) => {
321
- const triggerId = event.triggerId ?? event.previousEvent?.triggerId;
322
- context.set("hasPointerMoveOpened", triggerId ?? null);
323
- },
324
- clearPointerMoveOpened: ({ context }) => {
325
- context.set("hasPointerMoveOpened", null);
326
- },
327
- setTriggerValue: ({ context, event }) => {
328
- if (event.value === void 0) return;
329
- context.set("triggerValue", event.value);
330
- },
331
- immediateReopen: ({ send }) => {
332
- queueMicrotask(() => {
333
- send({ type: "reopen" });
334
- });
335
- }
336
- },
337
- effects: {
338
- trackFocusVisible: ({ scope }) => {
339
- return trackFocusVisible({ root: scope.getRootNode?.() });
340
- },
341
- trackPositioning: ({ context, prop, scope }) => {
342
- if (!context.get("currentPlacement")) {
343
- context.set("currentPlacement", prop("positioning").placement);
344
- }
345
- const getPositionerEl2 = () => dom.getPositionerEl(scope);
346
- const getTriggerEl = () => dom.getActiveTriggerEl(scope, context.get("triggerValue"));
347
- return getPlacement(getTriggerEl, getPositionerEl2, {
348
- ...prop("positioning"),
349
- defer: true,
350
- onComplete(data) {
351
- context.set("currentPlacement", data.placement);
352
- }
353
- });
354
- },
355
- trackPointerlockChange: ({ send, scope }) => {
356
- const doc = scope.getDoc();
357
- const onChange = () => send({ type: "close", src: "pointerlock:change" });
358
- return addDomEvent(doc, "pointerlockchange", onChange, false);
359
- },
360
- trackScroll: ({ send, prop, scope, context }) => {
361
- if (!prop("closeOnScroll")) return;
362
- const triggerValue = context.get("triggerValue");
363
- const triggerEl = dom.getActiveTriggerEl(scope, triggerValue);
364
- if (!triggerEl) return;
365
- const overflowParents = getOverflowAncestors(triggerEl);
366
- const cleanups = overflowParents.map((overflowParent) => {
367
- const onScroll = () => {
368
- send({ type: "close", src: "scroll" });
369
- };
370
- return addDomEvent(overflowParent, "scroll", onScroll, {
371
- passive: true,
372
- capture: true
373
- });
374
- });
375
- return () => {
376
- cleanups.forEach((fn) => fn?.());
377
- };
378
- },
379
- trackStore: ({ prop, send }) => {
380
- let cleanup;
381
- queueMicrotask(() => {
382
- cleanup = store.subscribe(() => {
383
- if (store.get("id") !== prop("id")) {
384
- send({ type: "close", src: "id.change" });
385
- }
386
- });
387
- });
388
- return () => cleanup?.();
389
- },
390
- trackEscapeKey: ({ send, prop }) => {
391
- if (!prop("closeOnEscape")) return;
392
- const onKeyDown = (event) => {
393
- if (isComposingEvent(event)) return;
394
- if (event.key !== "Escape") return;
395
- event.stopPropagation();
396
- send({ type: "close", src: "keydown.escape" });
397
- };
398
- return addDomEvent(document, "keydown", onKeyDown, true);
399
- },
400
- waitForOpenDelay: ({ send, prop, event }) => {
401
- const id = setTimeout(() => {
402
- send({ type: "after.openDelay", previousEvent: event });
403
- }, prop("openDelay"));
404
- return () => clearTimeout(id);
405
- },
406
- waitForCloseDelay: ({ send, prop, event }) => {
407
- const id = setTimeout(() => {
408
- send({ type: "after.closeDelay", previousEvent: event });
409
- }, prop("closeDelay"));
410
- return () => clearTimeout(id);
411
- }
412
- }
413
- }
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
+ }
414
420
  });
415
- export {
416
- machine
417
- };
421
+ export { machine };