@zag-js/tooltip 2.0.0-next.3 → 2.0.0-next.4

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,481 +1,608 @@
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_safe_area = require("@zag-js/safe-area");
41
- var import_utils = require("@zag-js/utils");
42
- var dom = __toESM(require("./tooltip.dom.js"));
43
- var import_tooltip = require("./tooltip.store.js");
44
- var { and, not } = (0, import_core.createGuards)();
45
- var machine = (0, import_core.createMachine)({
46
- initialState: ({ prop }) => {
47
- const open = prop("open") || prop("defaultOpen");
48
- return open ? "open" : "closed";
49
- },
50
- props({ props }) {
51
- (0, import_utils.ensureProps)(props, ["id"]);
52
- const closeOnClick = props.closeOnClick ?? true;
53
- const closeOnPointerDown = props.closeOnPointerDown ?? closeOnClick;
54
- return {
55
- openDelay: 400,
56
- closeDelay: 150,
57
- closeOnEscape: true,
58
- interactive: false,
59
- closeOnScroll: true,
60
- disabled: false,
61
- ...props,
62
- closeOnPointerDown,
63
- closeOnClick,
64
- positioning: {
65
- placement: "bottom",
66
- ...props.positioning
67
- }
68
- };
69
- },
70
- effects: ["trackFocusVisible", "trackStore"],
71
- context: ({ bindable, prop, scope }) => ({
72
- currentPlacement: bindable(() => ({ defaultValue: void 0 })),
73
- hasPointerMoveOpened: bindable(() => ({ defaultValue: null })),
74
- isPointer: bindable(() => ({ defaultValue: false })),
75
- triggerValue: bindable(() => ({
76
- defaultValue: prop("defaultTriggerValue") ?? null,
77
- value: prop("triggerValue"),
78
- onChange(value) {
79
- const onTriggerValueChange = prop("onTriggerValueChange");
80
- if (!onTriggerValueChange) return;
81
- const triggerElement = dom.getActiveTriggerEl(scope, value);
82
- onTriggerValueChange({ value, triggerElement });
83
- }
84
- }))
85
- }),
86
- watch({ track, action, prop }) {
87
- track([() => prop("disabled")], () => {
88
- action(["closeIfDisabled"]);
89
- });
90
- track([() => prop("open")], () => {
91
- action(["toggleVisibility"]);
92
- });
93
- track([() => prop("triggerValue")], () => {
94
- action(["repositionImmediate"]);
95
- });
96
- },
97
- on: {
98
- "TRIGGER_VALUE.SET": {
99
- actions: ["setTriggerValue", "repositionImmediate"]
100
- }
101
- },
102
- states: {
103
- closed: {
104
- entry: ["clearGlobalId", "clearIsPointer"],
105
- on: {
106
- "CONTROLLED.OPEN": {
107
- target: "open"
108
- },
109
- OPEN: [
110
- {
111
- guard: "isOpenControlled",
112
- actions: ["setTriggerValue", "invokeOnOpen"]
113
- },
114
- {
115
- target: "open",
116
- actions: ["setTriggerValue", "invokeOnOpen"]
117
- }
118
- ],
119
- POINTER_LEAVE: {
120
- actions: ["clearPointerMoveOpened"]
121
- },
122
- POINTER_MOVE: [
123
- {
124
- guard: and("noVisibleTooltip", not("hasPointerMoveOpened")),
125
- target: "opening",
126
- actions: ["setTriggerValue"]
127
- },
128
- {
129
- guard: not("hasPointerMoveOpened"),
130
- target: "open",
131
- actions: ["setPointerMoveOpened", "setIsPointer", "invokeOnOpen", "setTriggerValue"]
132
- }
133
- ]
134
- }
135
- },
136
- opening: {
137
- effects: ["trackScroll", "trackPointerlockChange", "waitForOpenDelay"],
138
- on: {
139
- OPEN_DELAY: [
140
- {
141
- guard: "isOpenControlled",
142
- actions: ["setPointerMoveOpened", "setIsPointer", "invokeOnOpen"]
143
- },
144
- {
145
- target: "open",
146
- actions: ["setPointerMoveOpened", "setIsPointer", "invokeOnOpen"]
147
- }
148
- ],
149
- "CONTROLLED.OPEN": {
150
- target: "open"
151
- },
152
- "CONTROLLED.CLOSE": {
153
- target: "closed"
154
- },
155
- OPEN: [
156
- {
157
- guard: "isOpenControlled",
158
- actions: ["setTriggerValue", "invokeOnOpen"]
159
- },
160
- {
161
- target: "open",
162
- actions: ["setTriggerValue", "invokeOnOpen"]
163
- }
164
- ],
165
- POINTER_LEAVE: [
166
- {
167
- guard: "isOpenControlled",
168
- // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
169
- actions: ["clearPointerMoveOpened", "invokeOnClose", "toggleVisibility"]
170
- },
171
- {
172
- target: "closed",
173
- actions: ["clearPointerMoveOpened", "invokeOnClose"]
174
- }
175
- ],
176
- CLOSE: [
177
- {
178
- guard: "isOpenControlled",
179
- // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
180
- actions: ["invokeOnClose", "toggleVisibility"]
181
- },
182
- {
183
- target: "closed",
184
- actions: ["invokeOnClose"]
185
- }
186
- ]
187
- }
188
- },
189
- open: {
190
- effects: ["trackEscapeKey", "trackScroll", "trackPointerlockChange", "trackPositioning", "trackSafeArea"],
191
- entry: ["setGlobalId"],
192
- on: {
193
- "CONTROLLED.CLOSE": {
194
- target: "closed"
195
- },
196
- CLOSE: [
197
- {
198
- guard: "isOpenControlled",
199
- actions: ["invokeOnClose"]
200
- },
201
- {
202
- target: "closed",
203
- actions: ["invokeOnClose"]
204
- }
205
- ],
206
- // Hoverable content means the pointer may be travelling to it (WCAG 1.4.13), so the
207
- // safe area decides when it has really left.
208
- POINTER_LEAVE: [
209
- {
210
- guard: and(not("isInteractive"), "isVisible"),
211
- target: "closing",
212
- actions: ["clearPointerMoveOpened"]
213
- },
214
- // == group ==
215
- {
216
- guard: and(not("isInteractive"), "isOpenControlled"),
217
- actions: ["clearPointerMoveOpened", "invokeOnClose"]
218
- },
219
- {
220
- guard: not("isInteractive"),
221
- target: "closed",
222
- actions: ["clearPointerMoveOpened", "invokeOnClose"]
223
- }
224
- ],
225
- "SAFE_AREA.EXIT": {
226
- target: "closing",
227
- // Same bookkeeping the `POINTER_LEAVE` path does, or `closed` refuses the next hover.
228
- actions: ["clearPointerMoveOpened"]
229
- },
230
- "POSITIONING.SET": {
231
- actions: ["reposition"]
232
- },
233
- "TRIGGER_VALUE.SET": {
234
- // Transition to closing (which cleans up trackPositioning) then immediately back to open
235
- // This re-creates the positioning effect with the new trigger
236
- target: "closing",
237
- actions: ["setTriggerValue", "immediateReopen"]
238
- }
239
- }
240
- },
241
- closing: {
242
- effects: ["trackPositioning", "waitForCloseDelay"],
243
- on: {
244
- CLOSE_DELAY: [
245
- {
246
- guard: "isOpenControlled",
247
- actions: ["invokeOnClose"]
248
- },
249
- {
250
- target: "closed",
251
- actions: ["invokeOnClose"]
252
- }
253
- ],
254
- "CONTROLLED.CLOSE": {
255
- target: "closed"
256
- },
257
- "CONTROLLED.OPEN": {
258
- target: "open"
259
- },
260
- CLOSE: [
261
- {
262
- guard: "isOpenControlled",
263
- actions: ["invokeOnClose"]
264
- },
265
- {
266
- target: "closed",
267
- actions: ["invokeOnClose"]
268
- }
269
- ],
270
- POINTER_MOVE: [
271
- {
272
- guard: "isOpenControlled",
273
- // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
274
- actions: ["setPointerMoveOpened", "setIsPointer", "setTriggerValue", "invokeOnOpen", "toggleVisibility"]
275
- },
276
- {
277
- target: "open",
278
- actions: ["setPointerMoveOpened", "setIsPointer", "setTriggerValue", "invokeOnOpen"]
279
- }
280
- ],
281
- "TRIGGER_VALUE.SET": {
282
- target: "open",
283
- actions: ["setTriggerValue", "repositionImmediate"]
284
- },
285
- REOPEN: {
286
- target: "open"
287
- },
288
- CONTENT_POINTER_MOVE: {
289
- guard: "isInteractive",
290
- target: "open"
291
- },
292
- "POSITIONING.SET": {
293
- actions: ["reposition"]
294
- }
295
- }
296
- }
297
- },
298
- implementations: {
299
- guards: {
300
- noVisibleTooltip: () => import_tooltip.store.get("id") === null,
301
- isVisible: ({ prop }) => prop("id") === import_tooltip.store.get("id"),
302
- isInteractive: ({ prop }) => !!prop("interactive"),
303
- hasPointerMoveOpened: ({ context }) => !!context.get("hasPointerMoveOpened"),
304
- isOpenControlled: ({ prop }) => prop("open") !== void 0
305
- },
306
- actions: {
307
- setGlobalId: ({ prop, event }) => {
308
- const prevId = import_tooltip.store.get("id");
309
- const isInstant = event.src === "trigger.focus" || prevId !== null && prevId !== prop("id");
310
- import_tooltip.store.update({ id: prop("id"), prevId: isInstant && prevId !== null ? prevId : null, instant: isInstant });
311
- },
312
- clearGlobalId: ({ prop }) => {
313
- if (prop("id") === import_tooltip.store.get("id")) {
314
- import_tooltip.store.update({ id: null, prevId: null, instant: false });
315
- }
316
- },
317
- invokeOnOpen: ({ prop }) => {
318
- prop("onOpenChange")?.({ open: true });
319
- },
320
- invokeOnClose: ({ prop }) => {
321
- prop("onOpenChange")?.({ open: false });
322
- },
323
- closeIfDisabled: ({ prop, send }) => {
324
- if (!prop("disabled")) return;
325
- send({ type: "CLOSE", src: "disabled.change" });
326
- },
327
- reposition: ({ context, event, prop, scope }) => {
328
- if (event.type !== "POSITIONING.SET") return;
329
- const getPositionerEl2 = () => dom.getPositionerEl(scope);
330
- const getTriggerEl = () => dom.getActiveTriggerEl(scope, context.get("triggerValue"));
331
- (0, import_popper.getPlacement)(getTriggerEl, getPositionerEl2, {
332
- getArrowElement: () => dom.getArrowEl(scope),
333
- ...prop("positioning"),
334
- ...event.options,
335
- listeners: false,
336
- onComplete(data) {
337
- context.set("currentPlacement", data.placement);
338
- }
339
- });
340
- },
341
- repositionImmediate: ({ context, event, prop, scope }) => {
342
- const triggerValue = event.value ?? context.get("triggerValue");
343
- const getPositionerEl2 = () => dom.getPositionerEl(scope);
344
- const getTriggerEl = () => dom.getActiveTriggerEl(scope, triggerValue);
345
- return (0, import_popper.getPlacement)(getTriggerEl, getPositionerEl2, {
346
- getArrowElement: () => dom.getArrowEl(scope),
347
- ...prop("positioning"),
348
- onComplete(data) {
349
- context.set("currentPlacement", data.placement);
350
- }
351
- });
352
- },
353
- toggleVisibility: ({ prop, event, send }) => {
354
- queueMicrotask(() => {
355
- send({
356
- type: prop("open") ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE",
357
- previousEvent: event
358
- });
359
- });
360
- },
361
- setPointerMoveOpened: ({ context, event }) => {
362
- const triggerId = event.triggerId ?? event.previousEvent?.triggerId;
363
- context.set("hasPointerMoveOpened", triggerId ?? null);
364
- },
365
- clearPointerMoveOpened: ({ context }) => {
366
- context.set("hasPointerMoveOpened", null);
367
- },
368
- setIsPointer: ({ context }) => {
369
- context.set("isPointer", true);
370
- },
371
- clearIsPointer: ({ context }) => {
372
- context.set("isPointer", false);
373
- },
374
- setTriggerValue: ({ context, event }) => {
375
- if (event.value === void 0) return;
376
- context.set("triggerValue", event.value);
377
- },
378
- immediateReopen: ({ send }) => {
379
- queueMicrotask(() => {
380
- send({ type: "REOPEN" });
381
- });
382
- }
383
- },
384
- effects: {
385
- trackFocusVisible: ({ scope }) => {
386
- return (0, import_focus_visible.trackFocusVisible)({ root: scope.getRootNode?.() });
387
- },
388
- // Only when hoverable: with `interactive: false` the content has `pointer-events: none`,
389
- // so there is no journey to protect and its rect is unreachable.
390
- trackSafeArea: ({ send, prop, scope, context }) => {
391
- if (!prop("interactive")) return;
392
- return (0, import_safe_area.trackSafeArea)({
393
- getTriggerEl: () => dom.getActiveTriggerEl(scope, context.get("triggerValue")),
394
- getContentEl: () => dom.getContentEl(scope),
395
- openedByPointer: () => context.get("isPointer"),
396
- defer: true,
397
- onLeave() {
398
- send({ type: "SAFE_AREA.EXIT" });
399
- }
400
- });
401
- },
402
- trackPositioning: ({ context, prop, scope }) => {
403
- if (!context.get("currentPlacement")) {
404
- context.set("currentPlacement", prop("positioning").placement);
405
- }
406
- const getPositionerEl2 = () => dom.getPositionerEl(scope);
407
- const getTriggerEl = () => dom.getActiveTriggerEl(scope, context.get("triggerValue"));
408
- return (0, import_popper.getPlacement)(getTriggerEl, getPositionerEl2, {
409
- getArrowElement: () => dom.getArrowEl(scope),
410
- ...prop("positioning"),
411
- defer: true,
412
- onComplete(data) {
413
- context.set("currentPlacement", data.placement);
414
- }
415
- });
416
- },
417
- trackPointerlockChange: ({ send, scope }) => {
418
- const doc = scope.getDoc();
419
- const onChange = () => send({ type: "CLOSE", src: "pointerlock:change" });
420
- return (0, import_dom_query.addDomEvent)(doc, "pointerlockchange", onChange, false);
421
- },
422
- trackScroll: ({ send, prop, scope, context }) => {
423
- if (!prop("closeOnScroll")) return;
424
- const triggerValue = context.get("triggerValue");
425
- const triggerEl = dom.getActiveTriggerEl(scope, triggerValue);
426
- if (!triggerEl) return;
427
- const overflowParents = (0, import_dom_query.getOverflowAncestors)(triggerEl);
428
- const cleanups = overflowParents.map((overflowParent) => {
429
- const onScroll = () => {
430
- send({ type: "CLOSE", src: "scroll" });
431
- };
432
- return (0, import_dom_query.addDomEvent)(overflowParent, "scroll", onScroll, {
433
- passive: true,
434
- capture: true
435
- });
436
- });
437
- return () => {
438
- cleanups.forEach((fn) => fn?.());
439
- };
440
- },
441
- trackStore: ({ prop, send }) => {
442
- let cleanup;
443
- queueMicrotask(() => {
444
- cleanup = import_tooltip.store.subscribe(() => {
445
- const id = import_tooltip.store.get("id");
446
- if (id !== null && id !== prop("id")) {
447
- send({ type: "CLOSE", src: "id.change" });
448
- }
449
- });
450
- });
451
- return () => cleanup?.();
452
- },
453
- trackEscapeKey: ({ send, prop }) => {
454
- if (!prop("closeOnEscape")) return;
455
- const onKeyDown = (event) => {
456
- if ((0, import_dom_query.isComposingEvent)(event)) return;
457
- if (event.key !== "Escape") return;
458
- event.stopPropagation();
459
- send({ type: "CLOSE", src: "keydown.escape" });
460
- };
461
- return (0, import_dom_query.addDomEvent)(document, "keydown", onKeyDown, true);
462
- },
463
- waitForOpenDelay: ({ send, prop, event }) => {
464
- const id = setTimeout(() => {
465
- send({ type: "OPEN_DELAY", previousEvent: event });
466
- }, prop("openDelay"));
467
- return () => clearTimeout(id);
468
- },
469
- waitForCloseDelay: ({ send, prop, event }) => {
470
- const id = setTimeout(() => {
471
- send({ type: "CLOSE_DELAY", previousEvent: event });
472
- }, prop("closeDelay"));
473
- return () => clearTimeout(id);
474
- }
475
- }
476
- }
1
+ Object.defineProperties(exports, {
2
+ __esModule: { value: true },
3
+ [Symbol.toStringTag]: { value: "Module" }
477
4
  });
478
- // Annotate the CommonJS export names for ESM import in node:
479
- 0 && (module.exports = {
480
- machine
5
+ const require_tooltip_dom = require("./tooltip.dom.js");
6
+ const require_tooltip_store = require("./tooltip.store.js");
7
+ const require_tooltip_style = require("./tooltip.style.js");
8
+ let _zag_js_dom_query = require("@zag-js/dom-query");
9
+ let _zag_js_focus_visible = require("@zag-js/focus-visible");
10
+ let _zag_js_popper = require("@zag-js/popper");
11
+ let _zag_js_utils = require("@zag-js/utils");
12
+ let _zag_js_core = require("@zag-js/core");
13
+ let _zag_js_safe_area = require("@zag-js/safe-area");
14
+ // src/tooltip.machine.ts
15
+ const { and, not } = (0, _zag_js_core.createGuards)();
16
+ const machine = (0, _zag_js_core.createMachine)({
17
+ initialState: ({ prop }) => {
18
+ return prop("open") || prop("defaultOpen") ? "open" : "closed";
19
+ },
20
+ props({ props }) {
21
+ (0, _zag_js_utils.ensureProps)(props, ["id"]);
22
+ const closeOnClick = props.closeOnClick ?? true;
23
+ const closeOnPointerDown = props.closeOnPointerDown ?? closeOnClick;
24
+ return {
25
+ openDelay: 400,
26
+ closeDelay: 150,
27
+ closeOnEscape: true,
28
+ interactive: false,
29
+ closeOnScroll: true,
30
+ disabled: false,
31
+ ...props,
32
+ closeOnPointerDown,
33
+ closeOnClick,
34
+ positioning: {
35
+ placement: "bottom",
36
+ ...props.positioning
37
+ }
38
+ };
39
+ },
40
+ effects: ["trackFocusVisible", "trackStore"],
41
+ exit: ["clearGlobalId", "endTriggerSwitch"],
42
+ context: ({ bindable, prop, scope }) => ({
43
+ currentPlacement: bindable(() => ({ defaultValue: void 0 })),
44
+ hasPointerMoveOpened: bindable(() => ({ defaultValue: null })),
45
+ isPointer: bindable(() => ({ defaultValue: false })),
46
+ triggerValue: bindable(() => ({
47
+ defaultValue: prop("defaultTriggerValue") ?? null,
48
+ value: prop("triggerValue"),
49
+ onChange(value) {
50
+ const onTriggerValueChange = prop("onTriggerValueChange");
51
+ if (!onTriggerValueChange) return;
52
+ onTriggerValueChange({
53
+ value,
54
+ triggerElement: require_tooltip_dom.getTriggerEl(scope, value)
55
+ });
56
+ }
57
+ })),
58
+ activationDirection: bindable(() => ({ defaultValue: null })),
59
+ previousTriggerValue: bindable(() => ({ defaultValue: null })),
60
+ transitioning: bindable(() => ({ defaultValue: false })),
61
+ viewportRendered: bindable(() => ({ defaultValue: false })),
62
+ viewportSize: bindable(() => ({ defaultValue: null }))
63
+ }),
64
+ refs: () => ({
65
+ cancelTriggerSwitch: null,
66
+ awaitingViewportSize: false
67
+ }),
68
+ watch({ track, action, prop }) {
69
+ track([() => prop("disabled")], () => {
70
+ action(["closeIfDisabled"]);
71
+ });
72
+ track([() => prop("open")], () => {
73
+ action(["toggleVisibility"]);
74
+ });
75
+ track([() => prop("triggerValue")], () => {
76
+ action(["repositionImmediate"]);
77
+ });
78
+ },
79
+ on: {
80
+ "TRIGGER_VALUE.SET": { actions: ["setTriggerValue", "repositionImmediate"] },
81
+ "TRIGGER_SWITCH.END": { actions: ["endTriggerSwitch"] }
82
+ },
83
+ states: {
84
+ closed: {
85
+ entry: [
86
+ "clearGlobalId",
87
+ "clearIsPointer",
88
+ "endTriggerSwitch",
89
+ "clearActivationDirection"
90
+ ],
91
+ on: {
92
+ "CONTROLLED.OPEN": { target: "open" },
93
+ OPEN: [{
94
+ guard: "isOpenControlled",
95
+ actions: ["setTriggerValue", "invokeOnOpen"]
96
+ }, {
97
+ target: "open",
98
+ actions: ["setTriggerValue", "invokeOnOpen"]
99
+ }],
100
+ POINTER_LEAVE: { actions: ["clearPointerMoveOpened"] },
101
+ POINTER_MOVE: [{
102
+ guard: and(not("isWarm"), not("hasPointerMoveOpened")),
103
+ target: "opening",
104
+ actions: ["setTriggerValue", "setPointerMoveOpened"]
105
+ }, {
106
+ guard: not("hasPointerMoveOpened"),
107
+ target: "open",
108
+ actions: [
109
+ "setPointerMoveOpened",
110
+ "setIsPointer",
111
+ "invokeOnOpen",
112
+ "setTriggerValue"
113
+ ]
114
+ }]
115
+ }
116
+ },
117
+ opening: {
118
+ effects: [
119
+ "trackScroll",
120
+ "trackPointerlockChange",
121
+ "waitForOpenDelay"
122
+ ],
123
+ on: {
124
+ OPEN_DELAY: [{
125
+ guard: "isOpenControlled",
126
+ actions: [
127
+ "setPointerMoveOpened",
128
+ "setIsPointer",
129
+ "invokeOnOpen"
130
+ ]
131
+ }, {
132
+ target: "open",
133
+ actions: [
134
+ "setPointerMoveOpened",
135
+ "setIsPointer",
136
+ "invokeOnOpen"
137
+ ]
138
+ }],
139
+ "CONTROLLED.OPEN": { target: "open" },
140
+ "CONTROLLED.CLOSE": { target: "closed" },
141
+ OPEN: [{
142
+ guard: "isOpenControlled",
143
+ actions: ["setTriggerValue", "invokeOnOpen"]
144
+ }, {
145
+ target: "open",
146
+ actions: ["setTriggerValue", "invokeOnOpen"]
147
+ }],
148
+ POINTER_LEAVE: [
149
+ {
150
+ guard: "isDisabled",
151
+ actions: ["clearPointerMoveOpened"]
152
+ },
153
+ {
154
+ guard: "isOpenControlled",
155
+ actions: [
156
+ "clearPointerMoveOpened",
157
+ "invokeOnClose",
158
+ "toggleVisibility"
159
+ ]
160
+ },
161
+ {
162
+ target: "closed",
163
+ actions: ["clearPointerMoveOpened", "invokeOnClose"]
164
+ }
165
+ ],
166
+ CLOSE: [{
167
+ guard: "isOpenControlled",
168
+ actions: ["invokeOnClose", "toggleVisibility"]
169
+ }, {
170
+ target: "closed",
171
+ actions: ["invokeOnClose"]
172
+ }]
173
+ }
174
+ },
175
+ open: {
176
+ effects: [
177
+ "trackEscapeKey",
178
+ "trackScroll",
179
+ "trackPointerlockChange",
180
+ "trackPositioning",
181
+ "trackViewportSize",
182
+ "trackSafeArea"
183
+ ],
184
+ entry: ["setGlobalId"],
185
+ on: {
186
+ "CONTROLLED.CLOSE": { target: "closed" },
187
+ CLOSE: [{
188
+ guard: "isOpenControlled",
189
+ actions: ["invokeOnClose"]
190
+ }, {
191
+ target: "closed",
192
+ actions: ["invokeOnClose"]
193
+ }],
194
+ POINTER_LEAVE: [
195
+ {
196
+ guard: "isDisabled",
197
+ actions: ["clearPointerMoveOpened"]
198
+ },
199
+ {
200
+ guard: and(not("isInteractive"), "isVisible"),
201
+ target: "closing",
202
+ actions: ["clearPointerMoveOpened"]
203
+ },
204
+ {
205
+ guard: and(not("isInteractive"), "isOpenControlled"),
206
+ actions: ["clearPointerMoveOpened", "invokeOnClose"]
207
+ },
208
+ {
209
+ guard: not("isInteractive"),
210
+ target: "closed",
211
+ actions: ["clearPointerMoveOpened", "invokeOnClose"]
212
+ }
213
+ ],
214
+ "SAFE_AREA.EXIT": {
215
+ target: "closing",
216
+ actions: ["clearPointerMoveOpened"]
217
+ },
218
+ "POSITIONING.SET": { actions: ["reposition"] },
219
+ "TRIGGER_VALUE.SET": {
220
+ target: "closing",
221
+ actions: [
222
+ "setActivationDirection",
223
+ "setPreviousTriggerValue",
224
+ "setTriggerValue",
225
+ "startTriggerSwitch",
226
+ "immediateReopen"
227
+ ]
228
+ }
229
+ }
230
+ },
231
+ closing: {
232
+ effects: [
233
+ "trackPositioning",
234
+ "trackViewportSize",
235
+ "waitForCloseDelay"
236
+ ],
237
+ on: {
238
+ CLOSE_DELAY: [{
239
+ guard: "isOpenControlled",
240
+ actions: ["invokeOnClose"]
241
+ }, {
242
+ target: "closed",
243
+ actions: ["invokeOnClose"]
244
+ }],
245
+ "CONTROLLED.CLOSE": { target: "closed" },
246
+ "CONTROLLED.OPEN": { target: "open" },
247
+ CLOSE: [{
248
+ guard: "isOpenControlled",
249
+ actions: ["invokeOnClose"]
250
+ }, {
251
+ target: "closed",
252
+ actions: ["invokeOnClose"]
253
+ }],
254
+ POINTER_MOVE: [
255
+ {
256
+ guard: and("isOpenControlled", "isNewTriggerValue"),
257
+ actions: [
258
+ "setPointerMoveOpened",
259
+ "setIsPointer",
260
+ "setActivationDirection",
261
+ "setPreviousTriggerValue",
262
+ "setTriggerValue",
263
+ "startTriggerSwitch",
264
+ "invokeOnOpen",
265
+ "toggleVisibility"
266
+ ]
267
+ },
268
+ {
269
+ guard: "isOpenControlled",
270
+ actions: [
271
+ "setPointerMoveOpened",
272
+ "setIsPointer",
273
+ "setTriggerValue",
274
+ "invokeOnOpen",
275
+ "toggleVisibility"
276
+ ]
277
+ },
278
+ {
279
+ guard: "isNewTriggerValue",
280
+ target: "open",
281
+ actions: [
282
+ "setPointerMoveOpened",
283
+ "setIsPointer",
284
+ "setActivationDirection",
285
+ "setPreviousTriggerValue",
286
+ "setTriggerValue",
287
+ "startTriggerSwitch",
288
+ "invokeOnOpen"
289
+ ]
290
+ },
291
+ {
292
+ target: "open",
293
+ actions: [
294
+ "setPointerMoveOpened",
295
+ "setIsPointer",
296
+ "setTriggerValue",
297
+ "invokeOnOpen"
298
+ ]
299
+ }
300
+ ],
301
+ "TRIGGER_VALUE.SET": {
302
+ target: "open",
303
+ actions: [
304
+ "setActivationDirection",
305
+ "setPreviousTriggerValue",
306
+ "setTriggerValue",
307
+ "startTriggerSwitch",
308
+ "repositionImmediate"
309
+ ]
310
+ },
311
+ REOPEN: { target: "open" },
312
+ CONTENT_POINTER_MOVE: {
313
+ guard: "isInteractive",
314
+ target: "open"
315
+ },
316
+ "POSITIONING.SET": { actions: ["reposition"] }
317
+ }
318
+ }
319
+ },
320
+ implementations: {
321
+ guards: {
322
+ isWarm: () => require_tooltip_store.isWarm(),
323
+ isVisible: ({ prop }) => prop("id") === require_tooltip_store.store.get("id"),
324
+ isInteractive: ({ prop }) => !!prop("interactive"),
325
+ hasPointerMoveOpened: ({ context }) => !!context.get("hasPointerMoveOpened"),
326
+ isOpenControlled: ({ prop }) => prop("open") !== void 0,
327
+ isDisabled: ({ prop }) => !!prop("disabled"),
328
+ isNewTriggerValue: ({ context, event }) => event.value != null && event.value !== context.get("triggerValue")
329
+ },
330
+ actions: {
331
+ setGlobalId: ({ prop, event }) => {
332
+ const prevId = require_tooltip_store.store.get("id");
333
+ const switching = prevId !== null && prevId !== prop("id");
334
+ const isInstant = event.src === "trigger-focus" || switching || require_tooltip_store.isWarm();
335
+ require_tooltip_store.store.update({
336
+ id: prop("id"),
337
+ prevId: switching ? prevId : null,
338
+ instant: isInstant
339
+ });
340
+ },
341
+ clearGlobalId: ({ prop }) => {
342
+ if (prop("id") === require_tooltip_store.store.get("id")) require_tooltip_store.store.update({
343
+ id: null,
344
+ prevId: null,
345
+ instant: false,
346
+ closedAt: Date.now()
347
+ });
348
+ },
349
+ invokeOnOpen: ({ prop, event }) => {
350
+ prop("onOpenChange")?.({
351
+ open: true,
352
+ reason: getOpenChangeReason(event)
353
+ });
354
+ },
355
+ invokeOnClose: ({ prop, event }) => {
356
+ prop("onOpenChange")?.({
357
+ open: false,
358
+ reason: getOpenChangeReason(event)
359
+ });
360
+ },
361
+ closeIfDisabled: ({ prop, send }) => {
362
+ if (!prop("disabled")) return;
363
+ send({
364
+ type: "CLOSE",
365
+ src: "disabled"
366
+ });
367
+ },
368
+ reposition: ({ context, event, prop, scope, refs }) => {
369
+ if (event.type !== "POSITIONING.SET") return;
370
+ if (refs.get("awaitingViewportSize")) return;
371
+ const getPositionerEl$3 = () => require_tooltip_dom.getPositionerEl(scope);
372
+ const getTriggerEl$3 = () => require_tooltip_dom.getTriggerEl(scope, context.get("triggerValue"));
373
+ (0, _zag_js_popper.getPlacement)(getTriggerEl$3, getPositionerEl$3, {
374
+ getArrowElement: () => require_tooltip_dom.getArrowEl(scope),
375
+ ...prop("positioning"),
376
+ ...event.options,
377
+ listeners: false,
378
+ onComplete(data) {
379
+ context.set("currentPlacement", data.placement);
380
+ }
381
+ });
382
+ },
383
+ repositionImmediate: ({ context, event, prop, scope, refs }) => {
384
+ if (refs.get("awaitingViewportSize")) return;
385
+ const triggerValue = event.value ?? context.get("triggerValue");
386
+ const getPositionerEl$1 = () => require_tooltip_dom.getPositionerEl(scope);
387
+ const getTriggerEl$1 = () => require_tooltip_dom.getTriggerEl(scope, triggerValue);
388
+ return (0, _zag_js_popper.getPlacement)(getTriggerEl$1, getPositionerEl$1, {
389
+ getArrowElement: () => require_tooltip_dom.getArrowEl(scope),
390
+ ...prop("positioning"),
391
+ onComplete(data) {
392
+ context.set("currentPlacement", data.placement);
393
+ }
394
+ });
395
+ },
396
+ toggleVisibility: ({ prop, event, send }) => {
397
+ queueMicrotask(() => {
398
+ send({
399
+ type: prop("open") ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE",
400
+ previousEvent: event
401
+ });
402
+ });
403
+ },
404
+ setPointerMoveOpened: ({ context, event }) => {
405
+ const triggerId = event.triggerId ?? event.previousEvent?.triggerId;
406
+ context.set("hasPointerMoveOpened", triggerId ?? null);
407
+ },
408
+ clearPointerMoveOpened: ({ context }) => {
409
+ context.set("hasPointerMoveOpened", null);
410
+ },
411
+ setIsPointer: ({ context }) => {
412
+ context.set("isPointer", true);
413
+ },
414
+ clearIsPointer: ({ context }) => {
415
+ context.set("isPointer", false);
416
+ },
417
+ setTriggerValue: ({ context, event }) => {
418
+ if (event.value === void 0) return;
419
+ context.set("triggerValue", event.value);
420
+ },
421
+ setActivationDirection: ({ context, event, scope }) => {
422
+ const fromEl = require_tooltip_dom.getTriggerEl(scope, context.get("triggerValue"));
423
+ const toEl = require_tooltip_dom.getTriggerEl(scope, event.value);
424
+ context.set("activationDirection", (0, _zag_js_dom_query.getPopupActivationDirection)(fromEl, toEl));
425
+ },
426
+ clearActivationDirection: ({ context }) => {
427
+ context.set("activationDirection", null);
428
+ },
429
+ setPreviousTriggerValue: ({ context }) => {
430
+ context.set("previousTriggerValue", context.get("triggerValue"));
431
+ },
432
+ startTriggerSwitch: ({ context, refs, scope, send }) => {
433
+ refs.get("cancelTriggerSwitch")?.();
434
+ context.set("transitioning", true);
435
+ const positionerEl = require_tooltip_dom.getPositionerEl(scope);
436
+ if (!positionerEl) return;
437
+ positionerEl.setAttribute("data-transitioning", "");
438
+ refs.set("awaitingViewportSize", !!require_tooltip_dom.getViewportEl(scope));
439
+ const cancel = (0, _zag_js_dom_query.waitForAnimationEnd)(positionerEl, () => send({ type: "TRIGGER_SWITCH.END" }));
440
+ refs.set("cancelTriggerSwitch", cancel);
441
+ },
442
+ endTriggerSwitch: ({ context, refs }) => {
443
+ context.set("previousTriggerValue", null);
444
+ refs.get("cancelTriggerSwitch")?.();
445
+ refs.set("cancelTriggerSwitch", null);
446
+ refs.set("awaitingViewportSize", false);
447
+ context.set("transitioning", false);
448
+ },
449
+ immediateReopen: ({ send }) => {
450
+ queueMicrotask(() => {
451
+ send({ type: "REOPEN" });
452
+ });
453
+ }
454
+ },
455
+ effects: {
456
+ trackFocusVisible: ({ scope }) => {
457
+ return (0, _zag_js_focus_visible.trackFocusVisible)({ root: scope.getRootNode?.() });
458
+ },
459
+ trackSafeArea: ({ send, prop, scope, context }) => {
460
+ if (!prop("interactive")) return;
461
+ return (0, _zag_js_safe_area.trackSafeArea)({
462
+ getTriggerEl: () => require_tooltip_dom.getTriggerEl(scope, context.get("triggerValue")),
463
+ getContentEl: () => require_tooltip_dom.getPopupEl(scope, context.get("triggerValue")),
464
+ openedByPointer: () => context.get("isPointer"),
465
+ defer: true,
466
+ onLeave() {
467
+ send({
468
+ type: "SAFE_AREA.EXIT",
469
+ src: "trigger-hover"
470
+ });
471
+ }
472
+ });
473
+ },
474
+ trackPositioning: ({ context, prop, scope, refs }) => {
475
+ if (!context.get("currentPlacement")) context.set("currentPlacement", prop("positioning").placement);
476
+ const getPositionerEl$2 = () => require_tooltip_dom.getPositionerEl(scope);
477
+ const getTriggerEl$2 = () => require_tooltip_dom.getTriggerEl(scope, context.get("triggerValue"));
478
+ const positioning = prop("positioning");
479
+ return (0, _zag_js_popper.getPlacement)(getTriggerEl$2, getPositionerEl$2, {
480
+ getArrowElement: () => require_tooltip_dom.getArrowEl(scope),
481
+ ...positioning,
482
+ updatePosition(data) {
483
+ if (refs.get("awaitingViewportSize")) return;
484
+ return positioning.updatePosition ? positioning.updatePosition(data) : data.updatePosition();
485
+ },
486
+ defer: true,
487
+ onComplete(data) {
488
+ context.set("currentPlacement", data.placement);
489
+ }
490
+ });
491
+ },
492
+ trackViewportSize: (params) => {
493
+ const { context, scope, watchEffect } = params;
494
+ return watchEffect([() => context.get("triggerValue")], () => {
495
+ const frame = _zag_js_dom_query.AnimationFrame.create();
496
+ const stopObserving = (0, _zag_js_dom_query.raf)(() => {
497
+ const contentEl = require_tooltip_dom.getContentEl(scope, context.get("triggerValue"));
498
+ const viewportRendered = !!require_tooltip_dom.getViewportEl(scope);
499
+ context.set("viewportRendered", viewportRendered);
500
+ if (!viewportRendered || !contentEl) return;
501
+ return _zag_js_dom_query.resizeObserverBorderBox.observe(contentEl, (entry) => {
502
+ const [{ inlineSize, blockSize }] = entry.borderBoxSize;
503
+ frame.request(() => setViewportSize(params, {
504
+ width: inlineSize,
505
+ height: blockSize
506
+ }));
507
+ });
508
+ });
509
+ return () => {
510
+ stopObserving();
511
+ frame.cancel();
512
+ };
513
+ });
514
+ },
515
+ trackPointerlockChange: ({ send, scope }) => {
516
+ const doc = scope.getDoc();
517
+ const onChange = () => send({
518
+ type: "CLOSE",
519
+ src: "interact-outside"
520
+ });
521
+ return (0, _zag_js_dom_query.addDomEvent)(doc, "pointerlockchange", onChange, false);
522
+ },
523
+ trackScroll: ({ send, prop, scope, context }) => {
524
+ if (!prop("closeOnScroll")) return;
525
+ const triggerValue = context.get("triggerValue");
526
+ const triggerEl = require_tooltip_dom.getTriggerEl(scope, triggerValue);
527
+ if (!triggerEl) return;
528
+ const cleanups = (0, _zag_js_dom_query.getOverflowAncestors)(triggerEl).map((overflowParent) => {
529
+ const onScroll = () => {
530
+ send({
531
+ type: "CLOSE",
532
+ src: "scroll"
533
+ });
534
+ };
535
+ return (0, _zag_js_dom_query.addDomEvent)(overflowParent, "scroll", onScroll, {
536
+ passive: true,
537
+ capture: true
538
+ });
539
+ });
540
+ return () => {
541
+ cleanups.forEach((fn) => fn?.());
542
+ };
543
+ },
544
+ trackStore: ({ prop, send }) => {
545
+ let cleanup;
546
+ let cancelled = false;
547
+ queueMicrotask(() => {
548
+ if (cancelled) return;
549
+ cleanup = require_tooltip_store.store.subscribe(() => {
550
+ const id = require_tooltip_store.store.get("id");
551
+ if (id !== null && id !== prop("id")) send({
552
+ type: "CLOSE",
553
+ src: "sibling-open"
554
+ });
555
+ });
556
+ });
557
+ return () => {
558
+ cancelled = true;
559
+ cleanup?.();
560
+ };
561
+ },
562
+ trackEscapeKey: ({ send, prop, scope }) => {
563
+ if (!prop("closeOnEscape")) return;
564
+ const onKeyDown = (event) => {
565
+ if ((0, _zag_js_dom_query.isComposingEvent)(event)) return;
566
+ if (event.key !== "Escape") return;
567
+ event.stopPropagation();
568
+ send({
569
+ type: "CLOSE",
570
+ src: "escape-key"
571
+ });
572
+ };
573
+ return (0, _zag_js_dom_query.addDomEvent)(scope.getDoc(), "keydown", onKeyDown, true);
574
+ },
575
+ waitForOpenDelay: ({ send, prop, event }) => {
576
+ const id = setTimeout(() => {
577
+ send({
578
+ type: "OPEN_DELAY",
579
+ previousEvent: event
580
+ });
581
+ }, prop("openDelay"));
582
+ return () => clearTimeout(id);
583
+ },
584
+ waitForCloseDelay: ({ send, prop, event }) => {
585
+ const id = setTimeout(() => {
586
+ send({
587
+ type: "CLOSE_DELAY",
588
+ previousEvent: event
589
+ });
590
+ }, prop("closeDelay"));
591
+ return () => clearTimeout(id);
592
+ }
593
+ }
594
+ }
481
595
  });
596
+ function setViewportSize(params, size) {
597
+ const { context, scope, refs, send } = params;
598
+ context.set("viewportSize", size);
599
+ const positionerEl = require_tooltip_dom.getPositionerEl(scope);
600
+ for (const [key, value] of Object.entries(require_tooltip_style.getViewportSizeStyle(size))) positionerEl?.style.setProperty(key, value);
601
+ if (!refs.get("awaitingViewportSize")) return;
602
+ refs.set("awaitingViewportSize", false);
603
+ send({ type: "POSITIONING.SET" });
604
+ }
605
+ function getOpenChangeReason(event) {
606
+ return (event.previousEvent ?? event).src;
607
+ }
608
+ exports.machine = machine;