@bitrise/bitkit-v2 0.3.53 → 0.3.55

package/dist/node_modules/@zag-js/slider/dist/index.js

@@ -0,0 +1,48 @@
+import { createAnatomy as a } from "../../anatomy/dist/index.js";
+import { createProps as e } from "../../types/dist/index.js";
+var r = a("slider").parts(
+  "root",
+  "label",
+  "thumb",
+  "valueText",
+  "track",
+  "range",
+  "control",
+  "markerGroup",
+  "marker",
+  "draggingIndicator"
+);
+r.build();
+e()([
+  "aria-label",
+  "aria-labelledby",
+  "dir",
+  "disabled",
+  "form",
+  "getAriaValueText",
+  "getRootNode",
+  "id",
+  "ids",
+  "invalid",
+  "max",
+  "min",
+  "minStepsBetweenThumbs",
+  "name",
+  "onFocusChange",
+  "onValueChange",
+  "onValueChangeEnd",
+  "orientation",
+  "origin",
+  "readOnly",
+  "step",
+  "thumbAlignment",
+  "thumbAlignment",
+  "thumbSize",
+  "value",
+  "defaultValue"
+]);
+e()(["index", "name"]);
+e()(["value"]);
+export {
+  r as anatomy
+};

package/dist/node_modules/@zag-js/switch/dist/index.js

@@ -0,0 +1,24 @@
+import { createAnatomy as e } from "../../anatomy/dist/index.js";
+import { createProps as o } from "../../types/dist/index.js";
+var r = e("switch").parts("root", "label", "control", "thumb");
+r.build();
+o()([
+  "checked",
+  "defaultChecked",
+  "dir",
+  "disabled",
+  "form",
+  "getRootNode",
+  "id",
+  "ids",
+  "invalid",
+  "label",
+  "name",
+  "onCheckedChange",
+  "readOnly",
+  "required",
+  "value"
+]);
+export {
+  r as anatomy
+};

package/dist/node_modules/@zag-js/tooltip/dist/index.js

@@ -0,0 +1,443 @@
+import { createAnatomy as D } from "../../anatomy/dist/index.js";
+import { dataAttr as M, isLeftClick as E, addDomEvent as u, getOverflowAncestors as I, isComposingEvent as V } from "../../dom-query/dist/index.js";
+import { trackFocusVisible as S, isFocusVisible as T } from "../../focus-visible/dist/index.js";
+import { getPlacementStyles as F, getPlacement as k } from "../../popper/dist/index.js";
+import { createStore as A } from "../../utils/dist/index.js";
+import { createMachine as G, createGuards as K } from "../../core/dist/index.js";
+import { createProps as L } from "../../types/dist/index.js";
+var $ = D("tooltip").parts("trigger", "arrow", "arrowTip", "positioner", "content"), d = $.build(), b = (e) => e.ids?.trigger ?? `tooltip:${e.id}:trigger`, q = (e) => e.ids?.content ?? `tooltip:${e.id}:content`, B = (e) => e.ids?.arrow ?? `tooltip:${e.id}:arrow`, w = (e) => e.ids?.positioner ?? `tooltip:${e.id}:popper`, v = (e) => e.getById(b(e)), m = (e) => e.getById(w(e)), l = A({ id: null });
+function W(e, t) {
+  const { state: o, context: s, send: n, scope: a, prop: r, event: O } = e, f = r("id"), P = !!r("aria-label"), p = o.matches("open", "closing"), h = b(a), y = q(a), c = r("disabled"), g = F({
+    ...r("positioning"),
+    placement: s.get("currentPlacement")
+  });
+  return {
+    open: p,
+    setOpen(i) {
+      o.matches("open", "closing") !== i && n({ type: i ? "open" : "close" });
+    },
+    reposition(i = {}) {
+      n({ type: "positioning.set", options: i });
+    },
+    getTriggerProps() {
+      return t.button({
+        ...d.trigger.attrs,
+        id: h,
+        dir: r("dir"),
+        "data-expanded": M(p),
+        "data-state": p ? "open" : "closed",
+        "aria-describedby": p ? y : void 0,
+        onClick(i) {
+          i.defaultPrevented || c || r("closeOnClick") && n({ type: "close", src: "trigger.click" });
+        },
+        onFocus(i) {
+          queueMicrotask(() => {
+            i.defaultPrevented || c || O.src !== "trigger.pointerdown" && T() && n({ type: "open", src: "trigger.focus" });
+          });
+        },
+        onBlur(i) {
+          i.defaultPrevented || c || f === l.get("id") && n({ type: "close", src: "trigger.blur" });
+        },
+        onPointerDown(i) {
+          i.defaultPrevented || c || E(i) && r("closeOnPointerDown") && f === l.get("id") && n({ type: "close", src: "trigger.pointerdown" });
+        },
+        onPointerMove(i) {
+          i.defaultPrevented || c || i.pointerType !== "touch" && n({ type: "pointer.move" });
+        },
+        onPointerLeave() {
+          c || n({ type: "pointer.leave" });
+        },
+        onPointerCancel() {
+          c || n({ type: "pointer.leave" });
+        }
+      });
+    },
+    getArrowProps() {
+      return t.element({
+        id: B(a),
+        ...d.arrow.attrs,
+        dir: r("dir"),
+        style: g.arrow
+      });
+    },
+    getArrowTipProps() {
+      return t.element({
+        ...d.arrowTip.attrs,
+        dir: r("dir"),
+        style: g.arrowTip
+      });
+    },
+    getPositionerProps() {
+      return t.element({
+        id: w(a),
+        ...d.positioner.attrs,
+        dir: r("dir"),
+        style: g.floating
+      });
+    },
+    getContentProps() {
+      return t.element({
+        ...d.content.attrs,
+        dir: r("dir"),
+        hidden: !p,
+        "data-state": p ? "open" : "closed",
+        role: P ? void 0 : "tooltip",
+        id: P ? void 0 : y,
+        "data-placement": s.get("currentPlacement"),
+        onPointerEnter() {
+          n({ type: "content.pointer.move" });
+        },
+        onPointerLeave() {
+          n({ type: "content.pointer.leave" });
+        },
+        style: {
+          pointerEvents: r("interactive") ? "auto" : "none"
+        }
+      });
+    }
+  };
+}
+var { and: x, not: C } = K(), X = G({
+  initialState: ({ prop: e }) => e("open") || e("defaultOpen") ? "open" : "closed",
+  props({ props: e }) {
+    const t = e.closeOnClick ?? !0, o = e.closeOnPointerDown ?? t;
+    return {
+      id: "x",
+      openDelay: 400,
+      closeDelay: 150,
+      closeOnEscape: !0,
+      interactive: !1,
+      closeOnScroll: !0,
+      disabled: !1,
+      ...e,
+      closeOnPointerDown: o,
+      closeOnClick: t,
+      positioning: {
+        placement: "bottom",
+        ...e.positioning
+      }
+    };
+  },
+  effects: ["trackFocusVisible", "trackStore"],
+  context: ({ bindable: e }) => ({
+    currentPlacement: e(() => ({ defaultValue: void 0 })),
+    hasPointerMoveOpened: e(() => ({ defaultValue: !1 }))
+  }),
+  watch({ track: e, action: t, prop: o }) {
+    e([() => o("disabled")], () => {
+      t(["closeIfDisabled"]);
+    }), e([() => o("open")], () => {
+      t(["toggleVisibility"]);
+    });
+  },
+  states: {
+    closed: {
+      entry: ["clearGlobalId"],
+      on: {
+        "controlled.open": {
+          target: "open"
+        },
+        open: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen"]
+          }
+        ],
+        "pointer.leave": {
+          actions: ["clearPointerMoveOpened"]
+        },
+        "pointer.move": [
+          {
+            guard: x("noVisibleTooltip", C("hasPointerMoveOpened")),
+            target: "opening"
+          },
+          {
+            guard: C("hasPointerMoveOpened"),
+            target: "open",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          }
+        ]
+      }
+    },
+    opening: {
+      effects: ["trackScroll", "trackPointerlockChange", "waitForOpenDelay"],
+      on: {
+        "after.openDelay": [
+          {
+            guard: "isOpenControlled",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          }
+        ],
+        "controlled.open": {
+          target: "open"
+        },
+        "controlled.close": {
+          target: "closed"
+        },
+        open: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen"]
+          }
+        ],
+        "pointer.leave": [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["clearPointerMoveOpened", "invokeOnClose", "toggleVisibility"]
+          },
+          {
+            target: "closed",
+            actions: ["clearPointerMoveOpened", "invokeOnClose"]
+          }
+        ],
+        close: [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["invokeOnClose", "toggleVisibility"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ]
+      }
+    },
+    open: {
+      effects: ["trackEscapeKey", "trackScroll", "trackPointerlockChange", "trackPositioning"],
+      entry: ["setGlobalId"],
+      on: {
+        "controlled.close": {
+          target: "closed"
+        },
+        close: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "pointer.leave": [
+          {
+            guard: "isVisible",
+            target: "closing",
+            actions: ["clearPointerMoveOpened"]
+          },
+          // == group ==
+          {
+            guard: "isOpenControlled",
+            actions: ["clearPointerMoveOpened", "invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["clearPointerMoveOpened", "invokeOnClose"]
+          }
+        ],
+        "content.pointer.leave": {
+          guard: "isInteractive",
+          target: "closing"
+        },
+        "positioning.set": {
+          actions: ["reposition"]
+        }
+      }
+    },
+    closing: {
+      effects: ["trackPositioning", "waitForCloseDelay"],
+      on: {
+        "after.closeDelay": [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "controlled.close": {
+          target: "closed"
+        },
+        "controlled.open": {
+          target: "open"
+        },
+        close: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "pointer.move": [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["setPointerMoveOpened", "invokeOnOpen", "toggleVisibility"]
+          },
+          {
+            target: "open",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          }
+        ],
+        "content.pointer.move": {
+          guard: "isInteractive",
+          target: "open"
+        },
+        "positioning.set": {
+          actions: ["reposition"]
+        }
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      noVisibleTooltip: () => l.get("id") === null,
+      isVisible: ({ prop: e }) => e("id") === l.get("id"),
+      isInteractive: ({ prop: e }) => !!e("interactive"),
+      hasPointerMoveOpened: ({ context: e }) => e.get("hasPointerMoveOpened"),
+      isOpenControlled: ({ prop: e }) => e("open") !== void 0
+    },
+    actions: {
+      setGlobalId: ({ prop: e }) => {
+        l.set("id", e("id"));
+      },
+      clearGlobalId: ({ prop: e }) => {
+        e("id") === l.get("id") && l.set("id", null);
+      },
+      invokeOnOpen: ({ prop: e }) => {
+        e("onOpenChange")?.({ open: !0 });
+      },
+      invokeOnClose: ({ prop: e }) => {
+        e("onOpenChange")?.({ open: !1 });
+      },
+      closeIfDisabled: ({ prop: e, send: t }) => {
+        e("disabled") && t({ type: "close", src: "disabled.change" });
+      },
+      reposition: ({ context: e, event: t, prop: o, scope: s }) => {
+        if (t.type !== "positioning.set") return;
+        const n = () => m(s);
+        return k(v(s), n, {
+          ...o("positioning"),
+          ...t.options,
+          defer: !0,
+          listeners: !1,
+          onComplete(a) {
+            e.set("currentPlacement", a.placement);
+          }
+        });
+      },
+      toggleVisibility: ({ prop: e, event: t, send: o }) => {
+        queueMicrotask(() => {
+          o({
+            type: e("open") ? "controlled.open" : "controlled.close",
+            previousEvent: t
+          });
+        });
+      },
+      setPointerMoveOpened: ({ context: e }) => {
+        e.set("hasPointerMoveOpened", !0);
+      },
+      clearPointerMoveOpened: ({ context: e }) => {
+        e.set("hasPointerMoveOpened", !1);
+      }
+    },
+    effects: {
+      trackFocusVisible: ({ scope: e }) => S({ root: e.getRootNode?.() }),
+      trackPositioning: ({ context: e, prop: t, scope: o }) => {
+        e.get("currentPlacement") || e.set("currentPlacement", t("positioning").placement);
+        const s = () => m(o);
+        return k(v(o), s, {
+          ...t("positioning"),
+          defer: !0,
+          onComplete(n) {
+            e.set("currentPlacement", n.placement);
+          }
+        });
+      },
+      trackPointerlockChange: ({ send: e, scope: t }) => {
+        const o = t.getDoc();
+        return u(o, "pointerlockchange", () => e({ type: "close", src: "pointerlock:change" }), !1);
+      },
+      trackScroll: ({ send: e, prop: t, scope: o }) => {
+        if (!t("closeOnScroll")) return;
+        const s = v(o);
+        if (!s) return;
+        const a = I(s).map((r) => u(r, "scroll", () => {
+          e({ type: "close", src: "scroll" });
+        }, {
+          passive: !0,
+          capture: !0
+        }));
+        return () => {
+          a.forEach((r) => r?.());
+        };
+      },
+      trackStore: ({ prop: e, send: t }) => {
+        let o;
+        return queueMicrotask(() => {
+          o = l.subscribe(() => {
+            l.get("id") !== e("id") && t({ type: "close", src: "id.change" });
+          });
+        }), () => o?.();
+      },
+      trackEscapeKey: ({ send: e, prop: t }) => t("closeOnEscape") ? u(document, "keydown", (s) => {
+        V(s) || s.key === "Escape" && (s.stopPropagation(), e({ type: "close", src: "keydown.escape" }));
+      }, !0) : void 0,
+      waitForOpenDelay: ({ send: e, prop: t }) => {
+        const o = setTimeout(() => {
+          e({ type: "after.openDelay" });
+        }, t("openDelay"));
+        return () => clearTimeout(o);
+      },
+      waitForCloseDelay: ({ send: e, prop: t }) => {
+        const o = setTimeout(() => {
+          e({ type: "after.closeDelay" });
+        }, t("closeDelay"));
+        return () => clearTimeout(o);
+      }
+    }
+  }
+});
+L()([
+  "aria-label",
+  "closeDelay",
+  "closeOnEscape",
+  "closeOnPointerDown",
+  "closeOnScroll",
+  "closeOnClick",
+  "dir",
+  "disabled",
+  "getRootNode",
+  "id",
+  "ids",
+  "interactive",
+  "onOpenChange",
+  "defaultOpen",
+  "open",
+  "openDelay",
+  "positioning"
+]);
+export {
+  $ as anatomy,
+  W as connect,
+  X as machine
+};

package/dist/node_modules/@zag-js/types/dist/index.js

@@ -0,0 +1,12 @@
+function a(r) {
+  return new Proxy({}, {
+    get(n, e) {
+      return e === "style" ? (t) => r({ style: t }).style : r;
+    }
+  });
+}
+var o = () => (r) => Array.from(new Set(r));
+export {
+  a as createNormalizer,
+  o as createProps
+};