@bitrise/bitkit-v2 0.3.55 → 0.3.57

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

@@ -1,48 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,443 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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
-};