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