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