@zag-js/tooltip 0.1.15 → 0.1.16

package/dist/index.d.ts

@@ -54,6 +54,10 @@ declare type PublicContext = CommonProperties & {
      * The user provided options used to position the popover content
      */
     positioning: PositioningOptions;
+    /**
+     * Whether the tooltip is disabled
+     */
+    disabled?: boolean;
 };
 declare type UserDefinedContext = RequiredBy<PublicContext, "id">;
 declare type ComputedContext = Readonly<{

package/dist/index.js

@@ -1,4 +1,31 @@
-// ../../utilities/dom/dist/index.js
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  connect: () => connect,
+  machine: () => machine
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../../utilities/dom/dist/index.mjs
 var dataAttr = (guard) => {
   return guard ? "" : void 0;
 };
@@ -191,7 +218,7 @@ var visuallyHiddenStyle = {
 };
 
 // src/tooltip.connect.ts
-import { getPlacementStyles } from "@zag-js/popper";
+var import_popper = require("@zag-js/popper");
 
 // src/tooltip.dom.ts
 var dom = defineDomHelpers({
@@ -220,8 +247,8 @@ var dom = defineDomHelpers({
 });
 
 // src/tooltip.store.ts
-import { proxy } from "@zag-js/core";
-var store = proxy({
+var import_core = require("@zag-js/core");
+var store = (0, import_core.proxy)({
   id: null,
   prevId: null,
   setId(val) {
@@ -237,7 +264,8 @@ function connect(state, send, normalize) {
   const isOpen = state.hasTag("open");
   const triggerId = dom.getTriggerId(state.context);
   const contentId = dom.getContentId(state.context);
-  const popperStyles = getPlacementStyles({
+  const isDisabled = state.context.disabled;
+  const popperStyles = (0, import_popper.getPlacementStyles)({
     measured: !!state.context.isPlacementComplete,
     placement: state.context.currentPlacement
   });
@@ -272,17 +300,25 @@ function connect(state, send, normalize) {
         }
       },
       onPointerDown() {
+        if (isDisabled)
+          return;
         if (id === store.id) {
           send("POINTER_DOWN");
         }
       },
       onPointerMove() {
+        if (isDisabled)
+          return;
         send("POINTER_ENTER");
       },
       onPointerLeave() {
+        if (isDisabled)
+          return;
         send("POINTER_LEAVE");
       },
       onPointerCancel() {
+        if (isDisabled)
+          return;
         send("POINTER_LEAVE");
       }
     }),
@@ -335,10 +371,10 @@ function connect(state, send, normalize) {
 }
 
 // src/tooltip.machine.ts
-import { createMachine, subscribe } from "@zag-js/core";
-import { getPlacement } from "@zag-js/popper";
+var import_core2 = require("@zag-js/core");
+var import_popper2 = require("@zag-js/popper");
 function machine(ctx) {
-  return createMachine(
+  return (0, import_core2.createMachine)(
     {
       id: "tooltip",
       initial: "unknown",
@@ -358,6 +394,9 @@ function machine(ctx) {
       computed: {
         hasAriaLabel: (ctx2) => !!ctx2["aria-label"]
       },
+      watch: {
+        disabled: ["closeIfDisabled"]
+      },
       on: {
         OPEN: "open",
         CLOSE: "closed"
@@ -455,7 +494,7 @@ function machine(ctx) {
           ctx2.currentPlacement = ctx2.positioning.placement;
           let cleanup;
           raf(() => {
-            cleanup = getPlacement(dom.getTriggerEl(ctx2), dom.getPositionerEl(ctx2), {
+            cleanup = (0, import_popper2.getPlacement)(dom.getTriggerEl(ctx2), dom.getPositionerEl(ctx2), {
               ...ctx2.positioning,
               onComplete(data) {
                 ctx2.currentPlacement = data.placement;
@@ -487,7 +526,7 @@ function machine(ctx) {
           };
         },
         trackStore(ctx2, _evt, { send }) {
-          return subscribe(store, () => {
+          return (0, import_core2.subscribe)(store, () => {
             if (store.id !== ctx2.id) {
               send("FORCE_CLOSE");
             }
@@ -537,6 +576,11 @@ function machine(ctx) {
           if (!omit.includes(evt.type)) {
             (_a = ctx2.onClose) == null ? void 0 : _a.call(ctx2);
           }
+        },
+        closeIfDisabled(ctx2, _evt, { send }) {
+          if (ctx2.disabled) {
+            send("CLOSE");
+          }
         }
       },
       guards: {
@@ -552,7 +596,8 @@ function machine(ctx) {
     }
   );
 }
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   connect,
   machine
-};
+});

package/dist/index.mjs

@@ -0,0 +1,575 @@
+// ../../utilities/dom/dist/index.mjs
+var dataAttr = (guard) => {
+  return guard ? "" : void 0;
+};
+function getCache() {
+  const g = globalThis;
+  g.__styleCache = g.__styleCache || /* @__PURE__ */ new WeakMap();
+  return g.__styleCache;
+}
+function getComputedStyle(el) {
+  if (!el)
+    return {};
+  const cache = getCache();
+  let style = cache.get(el);
+  if (!style) {
+    const win = (el == null ? void 0 : el.ownerDocument.defaultView) ?? window;
+    style = win.getComputedStyle(el);
+    cache.set(el, style);
+  }
+  return style;
+}
+var runIfFn = (v, ...a) => {
+  const res = typeof v === "function" ? v(...a) : v;
+  return res ?? void 0;
+};
+var isArray = (v) => Array.isArray(v);
+var isObject = (v) => !(v == null || typeof v !== "object" || isArray(v));
+var hasProp = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+var isDom = () => typeof window !== "undefined";
+function getPlatform() {
+  const agent = navigator.userAgentData;
+  return (agent == null ? void 0 : agent.platform) ?? navigator.platform;
+}
+var pt = (v) => isDom() && v.test(getPlatform());
+var vn = (v) => isDom() && v.test(navigator.vendor);
+var isSafari = () => isApple() && vn(/apple/i);
+var isApple = () => pt(/mac|iphone|ipad|ipod/i);
+function isDocument(el) {
+  return el.nodeType === Node.DOCUMENT_NODE;
+}
+function isWindow(value) {
+  return (value == null ? void 0 : value.toString()) === "[object Window]";
+}
+function getDocument(el) {
+  if (isWindow(el))
+    return el.document;
+  if (isDocument(el))
+    return el;
+  return (el == null ? void 0 : el.ownerDocument) ?? document;
+}
+function getWindow(el) {
+  return (el == null ? void 0 : el.ownerDocument.defaultView) ?? window;
+}
+function getNodeName(node) {
+  return isWindow(node) ? "" : (node == null ? void 0 : node.localName) ?? "";
+}
+function getParent(el) {
+  const doc = getDocument(el);
+  if (getNodeName(el) === "html")
+    return el;
+  return el.assignedSlot || el.parentElement || doc.documentElement;
+}
+function defineDomHelpers(helpers) {
+  const dom2 = {
+    getRootNode: (ctx) => {
+      var _a;
+      return ((_a = ctx.getRootNode) == null ? void 0 : _a.call(ctx)) ?? document;
+    },
+    getDoc: (ctx) => getDocument(dom2.getRootNode(ctx)),
+    getWin: (ctx) => dom2.getDoc(ctx).defaultView ?? window,
+    getActiveElement: (ctx) => dom2.getDoc(ctx).activeElement,
+    getById: (ctx, id) => dom2.getRootNode(ctx).getElementById(id)
+  };
+  return {
+    ...dom2,
+    ...helpers
+  };
+}
+function isHTMLElement(v) {
+  return typeof v === "object" && (v == null ? void 0 : v.nodeType) === Node.ELEMENT_NODE && typeof (v == null ? void 0 : v.nodeName) === "string";
+}
+var supportsPointerEvent = () => isDom() && window.onpointerdown === null;
+var supportsTouchEvent = () => isDom() && window.ontouchstart === null;
+var supportsMouseEvent = () => isDom() && window.onmousedown === null;
+var isTouchEvent = (v) => isObject(v) && hasProp(v, "touches");
+var isRef = (v) => hasProp(v, "current");
+var fallback2 = { pageX: 0, pageY: 0, clientX: 0, clientY: 0 };
+function extractInfo(event, type = "page") {
+  const point = isTouchEvent(event) ? event.touches[0] || event.changedTouches[0] || fallback2 : event;
+  return {
+    point: {
+      x: point[`${type}X`],
+      y: point[`${type}Y`]
+    }
+  };
+}
+function addDomEvent(target, eventName, handler, options) {
+  const node = isRef(target) ? target.current : runIfFn(target);
+  node == null ? void 0 : node.addEventListener(eventName, handler, options);
+  return () => {
+    node == null ? void 0 : node.removeEventListener(eventName, handler, options);
+  };
+}
+function addPointerEvent(target, event, listener, options) {
+  const type = getEventName(event) ?? event;
+  return addDomEvent(target, type, wrapHandler(listener, event === "pointerdown"), options);
+}
+function wrapHandler(fn, filter = false) {
+  const listener = (event) => {
+    fn(event, extractInfo(event));
+  };
+  return filter ? filterPrimaryPointer(listener) : listener;
+}
+function filterPrimaryPointer(fn) {
+  return (event) => {
+    const win = event.view ?? window;
+    const isMouseEvent2 = event instanceof win.MouseEvent;
+    const isPrimary = !isMouseEvent2 || isMouseEvent2 && event.button === 0;
+    if (isPrimary)
+      fn(event);
+  };
+}
+var mouseEventNames = {
+  pointerdown: "mousedown",
+  pointermove: "mousemove",
+  pointerup: "mouseup",
+  pointercancel: "mousecancel",
+  pointerover: "mouseover",
+  pointerout: "mouseout",
+  pointerenter: "mouseenter",
+  pointerleave: "mouseleave"
+};
+var touchEventNames = {
+  pointerdown: "touchstart",
+  pointermove: "touchmove",
+  pointerup: "touchend",
+  pointercancel: "touchcancel"
+};
+function getEventName(evt) {
+  if (supportsPointerEvent())
+    return evt;
+  if (supportsTouchEvent())
+    return touchEventNames[evt];
+  if (supportsMouseEvent())
+    return mouseEventNames[evt];
+  return evt;
+}
+function raf(fn) {
+  const id = globalThis.requestAnimationFrame(fn);
+  return function cleanup() {
+    globalThis.cancelAnimationFrame(id);
+  };
+}
+function addPointerlockChangeListener(doc, fn) {
+  return addDomEvent(doc, "pointerlockchange", fn, false);
+}
+function isScrollParent(el) {
+  const { overflow, overflowX, overflowY } = getComputedStyle(el);
+  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+}
+function getScrollParent(el) {
+  if (["html", "body", "#document"].includes(getNodeName(el))) {
+    return getDocument(el).body;
+  }
+  if (isHTMLElement(el) && isScrollParent(el)) {
+    return el;
+  }
+  return getScrollParent(getParent(el));
+}
+function getScrollParents(el, list = []) {
+  const scrollParent = getScrollParent(el);
+  const isBody = scrollParent === getDocument(el).body;
+  const win = getWindow(scrollParent);
+  const target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
+  const parents = list.concat(target);
+  if (isBody)
+    return parents;
+  return parents.concat(getScrollParents(getParent(target)));
+}
+var visuallyHiddenStyle = {
+  border: "0",
+  clip: "rect(0 0 0 0)",
+  height: "1px",
+  margin: "-1px",
+  overflow: "hidden",
+  padding: "0",
+  position: "absolute",
+  width: "1px",
+  whiteSpace: "nowrap",
+  wordWrap: "normal"
+};
+
+// src/tooltip.connect.ts
+import { getPlacementStyles } from "@zag-js/popper";
+
+// src/tooltip.dom.ts
+var dom = defineDomHelpers({
+  getTriggerId: (ctx) => {
+    var _a;
+    return ((_a = ctx.ids) == null ? void 0 : _a.trigger) ?? `tooltip:${ctx.id}:trigger`;
+  },
+  getContentId: (ctx) => {
+    var _a;
+    return ((_a = ctx.ids) == null ? void 0 : _a.content) ?? `tooltip:${ctx.id}:content`;
+  },
+  getArrowId: (ctx) => `tooltip:${ctx.id}:arrow`,
+  getPositionerId: (ctx) => `tooltip:${ctx.id}:popper`,
+  portalId: "tooltip-portal",
+  getTriggerEl: (ctx) => dom.getById(ctx, dom.getTriggerId(ctx)),
+  getContentEl: (ctx) => dom.getById(ctx, dom.getContentId(ctx)),
+  getPositionerEl: (ctx) => dom.getById(ctx, dom.getPositionerId(ctx)),
+  getArrowEl: (ctx) => dom.getById(ctx, dom.getArrowId(ctx)),
+  getScrollParent: (ctx) => getScrollParent(dom.getTriggerEl(ctx)),
+  getPortalEl: (ctx) => dom.getDoc(ctx).getElementById(dom.portalId),
+  createPortalEl: (ctx) => {
+    const portal = dom.getDoc(ctx).createElement(dom.portalId);
+    portal.id = dom.portalId;
+    return portal;
+  }
+});
+
+// src/tooltip.store.ts
+import { proxy } from "@zag-js/core";
+var store = proxy({
+  id: null,
+  prevId: null,
+  setId(val) {
+    this.prevId = this.id;
+    this.id = val;
+  }
+});
+
+// src/tooltip.connect.ts
+function connect(state, send, normalize) {
+  const id = state.context.id;
+  const hasAriaLabel = state.context.hasAriaLabel;
+  const isOpen = state.hasTag("open");
+  const triggerId = dom.getTriggerId(state.context);
+  const contentId = dom.getContentId(state.context);
+  const isDisabled = state.context.disabled;
+  const popperStyles = getPlacementStyles({
+    measured: !!state.context.isPlacementComplete,
+    placement: state.context.currentPlacement
+  });
+  return {
+    isOpen,
+    open() {
+      send("OPEN");
+    },
+    close() {
+      send("CLOSE");
+    },
+    getAnimationState() {
+      return {
+        enter: store.prevId === null && id === store.id,
+        exit: store.id === null
+      };
+    },
+    triggerProps: normalize.button({
+      "data-part": "trigger",
+      id: triggerId,
+      "data-expanded": dataAttr(isOpen),
+      "aria-describedby": isOpen ? contentId : void 0,
+      onClick() {
+        send("CLICK");
+      },
+      onFocus() {
+        send("FOCUS");
+      },
+      onBlur() {
+        if (id === store.id) {
+          send("BLUR");
+        }
+      },
+      onPointerDown() {
+        if (isDisabled)
+          return;
+        if (id === store.id) {
+          send("POINTER_DOWN");
+        }
+      },
+      onPointerMove() {
+        if (isDisabled)
+          return;
+        send("POINTER_ENTER");
+      },
+      onPointerLeave() {
+        if (isDisabled)
+          return;
+        send("POINTER_LEAVE");
+      },
+      onPointerCancel() {
+        if (isDisabled)
+          return;
+        send("POINTER_LEAVE");
+      }
+    }),
+    arrowProps: normalize.element({
+      id: dom.getArrowId(state.context),
+      "data-part": "arrow",
+      style: popperStyles.arrow
+    }),
+    innerArrowProps: normalize.element({
+      "data-part": "arrow-inner",
+      style: popperStyles.innerArrow
+    }),
+    positionerProps: normalize.element({
+      id: dom.getPositionerId(state.context),
+      "data-part": "positioner",
+      style: popperStyles.floating
+    }),
+    contentProps: normalize.element({
+      "data-part": "content",
+      role: hasAriaLabel ? void 0 : "tooltip",
+      id: hasAriaLabel ? void 0 : contentId,
+      "data-placement": state.context.currentPlacement,
+      onPointerEnter() {
+        send("TOOLTIP_POINTER_ENTER");
+      },
+      onPointerLeave() {
+        send("TOOLTIP_POINTER_LEAVE");
+      },
+      style: {
+        pointerEvents: state.context.interactive ? "auto" : "none"
+      }
+    }),
+    labelProps: normalize.element({
+      "data-part": "label",
+      id: contentId,
+      role: "tooltip",
+      style: visuallyHiddenStyle,
+      children: state.context["aria-label"]
+    }),
+    createPortal() {
+      const doc = dom.getDoc(state.context);
+      const exist = dom.getPortalEl(state.context);
+      if (exist)
+        return exist;
+      const portal = dom.createPortalEl(state.context);
+      doc.body.appendChild(portal);
+      return portal;
+    }
+  };
+}
+
+// src/tooltip.machine.ts
+import { createMachine, subscribe } from "@zag-js/core";
+import { getPlacement } from "@zag-js/popper";
+function machine(ctx) {
+  return createMachine(
+    {
+      id: "tooltip",
+      initial: "unknown",
+      context: {
+        openDelay: 1e3,
+        closeDelay: 500,
+        closeOnPointerDown: true,
+        closeOnEsc: true,
+        interactive: true,
+        currentPlacement: void 0,
+        ...ctx,
+        positioning: {
+          placement: "bottom",
+          ...ctx.positioning
+        }
+      },
+      computed: {
+        hasAriaLabel: (ctx2) => !!ctx2["aria-label"]
+      },
+      watch: {
+        disabled: ["closeIfDisabled"]
+      },
+      on: {
+        OPEN: "open",
+        CLOSE: "closed"
+      },
+      states: {
+        unknown: {
+          on: {
+            SETUP: "closed"
+          }
+        },
+        closed: {
+          tags: ["closed"],
+          entry: ["clearGlobalId", "invokeOnClose"],
+          on: {
+            FOCUS: "open",
+            POINTER_ENTER: [
+              {
+                guard: "noVisibleTooltip",
+                target: "opening"
+              },
+              { target: "open" }
+            ]
+          }
+        },
+        opening: {
+          tags: ["closed"],
+          activities: ["trackScroll", "trackPointerlockChange"],
+          after: {
+            OPEN_DELAY: "open"
+          },
+          on: {
+            POINTER_LEAVE: "closed",
+            BLUR: "closed",
+            SCROLL: "closed",
+            POINTER_LOCK_CHANGE: "closed",
+            POINTER_DOWN: {
+              guard: "closeOnPointerDown",
+              target: "closed"
+            }
+          }
+        },
+        open: {
+          tags: ["open"],
+          activities: [
+            "trackEscapeKey",
+            "trackDisabledTriggerOnSafari",
+            "trackScroll",
+            "trackPointerlockChange",
+            "computePlacement"
+          ],
+          entry: ["setGlobalId", "invokeOnOpen"],
+          on: {
+            POINTER_LEAVE: [
+              {
+                guard: "isVisible",
+                target: "closing"
+              },
+              { target: "closed" }
+            ],
+            BLUR: "closed",
+            ESCAPE: "closed",
+            SCROLL: "closed",
+            POINTER_LOCK_CHANGE: "closed",
+            TOOLTIP_POINTER_LEAVE: {
+              guard: "isInteractive",
+              target: "closing"
+            },
+            POINTER_DOWN: {
+              guard: "closeOnPointerDown",
+              target: "closed"
+            },
+            CLICK: "closed"
+          }
+        },
+        closing: {
+          tags: ["open"],
+          activities: ["trackStore", "computePlacement"],
+          after: {
+            CLOSE_DELAY: "closed"
+          },
+          on: {
+            FORCE_CLOSE: "closed",
+            POINTER_ENTER: "open",
+            TOOLTIP_POINTER_ENTER: {
+              guard: "isInteractive",
+              target: "open"
+            }
+          }
+        }
+      }
+    },
+    {
+      activities: {
+        computePlacement(ctx2) {
+          ctx2.currentPlacement = ctx2.positioning.placement;
+          let cleanup;
+          raf(() => {
+            cleanup = getPlacement(dom.getTriggerEl(ctx2), dom.getPositionerEl(ctx2), {
+              ...ctx2.positioning,
+              onComplete(data) {
+                ctx2.currentPlacement = data.placement;
+                ctx2.isPlacementComplete = true;
+              },
+              onCleanup() {
+                ctx2.currentPlacement = void 0;
+                ctx2.isPlacementComplete = false;
+              }
+            });
+          });
+          return cleanup;
+        },
+        trackPointerlockChange(ctx2, _evt, { send }) {
+          return addPointerlockChangeListener(dom.getDoc(ctx2), () => {
+            send("POINTER_LOCK_CHANGE");
+          });
+        },
+        trackScroll(ctx2, _evt, { send }) {
+          const trigger = dom.getTriggerEl(ctx2);
+          if (!trigger)
+            return;
+          const cleanups = getScrollParents(trigger).map((el) => {
+            const opts = { passive: true, capture: true };
+            return addDomEvent(el, "scroll", () => send("SCROLL"), opts);
+          });
+          return () => {
+            cleanups.forEach((fn) => fn == null ? void 0 : fn());
+          };
+        },
+        trackStore(ctx2, _evt, { send }) {
+          return subscribe(store, () => {
+            if (store.id !== ctx2.id) {
+              send("FORCE_CLOSE");
+            }
+          });
+        },
+        trackDisabledTriggerOnSafari(ctx2, _evt, { send }) {
+          if (!isSafari())
+            return;
+          const doc = dom.getDoc(ctx2);
+          return addPointerEvent(doc, "pointermove", (event) => {
+            const selector = "[data-part=trigger][data-expanded]";
+            if (isHTMLElement(event.target) && event.target.closest(selector))
+              return;
+            send("POINTER_LEAVE");
+          });
+        },
+        trackEscapeKey(ctx2, _evt, { send }) {
+          if (!ctx2.closeOnEsc)
+            return;
+          const doc = dom.getDoc(ctx2);
+          return addDomEvent(doc, "keydown", (event) => {
+            if (event.key === "Escape") {
+              send("ESCAPE");
+            }
+          });
+        }
+      },
+      actions: {
+        setGlobalId(ctx2) {
+          store.setId(ctx2.id);
+        },
+        clearGlobalId(ctx2) {
+          if (ctx2.id === store.id) {
+            store.setId(null);
+          }
+        },
+        invokeOnOpen(ctx2, evt) {
+          var _a;
+          const omit = ["TOOLTIP_POINTER_ENTER", "POINTER_ENTER"];
+          if (!omit.includes(evt.type)) {
+            (_a = ctx2.onOpen) == null ? void 0 : _a.call(ctx2);
+          }
+        },
+        invokeOnClose(ctx2, evt) {
+          var _a;
+          const omit = ["SETUP"];
+          if (!omit.includes(evt.type)) {
+            (_a = ctx2.onClose) == null ? void 0 : _a.call(ctx2);
+          }
+        },
+        closeIfDisabled(ctx2, _evt, { send }) {
+          if (ctx2.disabled) {
+            send("CLOSE");
+          }
+        }
+      },
+      guards: {
+        closeOnPointerDown: (ctx2) => ctx2.closeOnPointerDown,
+        noVisibleTooltip: () => store.id === null,
+        isVisible: (ctx2) => ctx2.id === store.id,
+        isInteractive: (ctx2) => ctx2.interactive
+      },
+      delays: {
+        OPEN_DELAY: (ctx2) => ctx2.openDelay,
+        CLOSE_DELAY: (ctx2) => ctx2.closeDelay
+      }
+    }
+  );
+}
+export {
+  connect,
+  machine
+};

package/package.json

@@ -1,8 +1,10 @@
 {
-  "type": "module",
   "name": "@zag-js/tooltip",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Core logic for the tooltip widget implemented as a state machine",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "keywords": [
     "js",
     "machine",
@@ -15,8 +17,6 @@
   "author": "Segun Adebayo <sage@adebayosegun.com>",
   "homepage": "https://github.com/chakra-ui/zag#readme",
   "license": "MIT",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "repository": "https://github.com/chakra-ui/zag/tree/main/packages/tooltip",
   "sideEffects": false,
   "files": [
@@ -29,18 +29,18 @@
     "url": "https://github.com/chakra-ui/zag/issues"
   },
   "dependencies": {
-    "@zag-js/core": "0.1.11",
-    "@zag-js/popper": "0.1.12",
-    "@zag-js/types": "0.2.6"
+    "@zag-js/core": "0.1.12",
+    "@zag-js/popper": "0.1.13",
+    "@zag-js/types": "0.2.7"
   },
   "devDependencies": {
-    "@zag-js/dom-utils": "0.1.12",
-    "@zag-js/utils": "0.1.5"
+    "@zag-js/dom-utils": "0.1.13",
+    "@zag-js/utils": "0.1.6"
   },
   "scripts": {
-    "build-fast": "tsup src/index.ts --format=esm",
+    "build-fast": "tsup src/index.ts --format=esm,cjs",
     "start": "pnpm build --watch",
-    "build": "tsup src/index.ts --format=esm --dts",
+    "build": "tsup src/index.ts --format=esm,cjs --dts",
     "test": "jest --config ../../../jest.config.js --rootDir . --passWithNoTests",
     "lint": "eslint src --ext .ts,.tsx",
     "test-ci": "pnpm test --ci --runInBand",