@bitrise/bitkit-v2 0.3.53 → 0.3.55

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

@@ -0,0 +1,97 @@
+import { callAll as f, isString as u, isEqual as d } from "../../utils/dist/index.js";
+import { isActiveElement as g, getActiveElement as m, getDocument as p } from "../../dom-query/dist/index.js";
+var v = (...t) => t.map((e) => e?.trim?.()).filter(Boolean).join(" "), y = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g, s = (t) => {
+  const e = {};
+  let r;
+  for (; r = y.exec(t); )
+    e[r[1]] = r[2];
+  return e;
+}, E = (t, e) => {
+  if (u(t)) {
+    if (u(e)) return `${t};${e}`;
+    t = s(t);
+  } else u(e) && (e = s(e));
+  return Object.assign({}, t ?? {}, e ?? {});
+};
+function _(...t) {
+  let e = {};
+  for (let r of t) {
+    if (!r) continue;
+    for (let n in e) {
+      if (n.startsWith("on") && typeof e[n] == "function" && typeof r[n] == "function") {
+        e[n] = f(r[n], e[n]);
+        continue;
+      }
+      if (n === "className" || n === "class") {
+        e[n] = v(e[n], r[n]);
+        continue;
+      }
+      if (n === "style") {
+        e[n] = E(e[n], r[n]);
+        continue;
+      }
+      e[n] = r[n] !== void 0 ? r[n] : e[n];
+    }
+    for (let n in r)
+      e[n] === void 0 && (e[n] = r[n]);
+    const o = Object.getOwnPropertySymbols(r);
+    for (let n of o)
+      e[n] = r[n];
+  }
+  return e;
+}
+function G(t, e, r) {
+  let o = [], n;
+  return (c) => {
+    const i = t(c);
+    return (i.length !== o.length || i.some((l, a) => !d(o[a], l))) && (o = i, n = e(i, c)), n;
+  };
+}
+function S() {
+  return {
+    and: (...t) => function(r) {
+      return t.every((o) => r.guard(o));
+    },
+    or: (...t) => function(r) {
+      return t.some((o) => r.guard(o));
+    },
+    not: (t) => function(r) {
+      return !r.guard(t);
+    }
+  };
+}
+function I(t) {
+  return t;
+}
+function B() {
+  return {
+    guards: S(),
+    createMachine: (t) => t,
+    choose: (t) => function({ choose: r }) {
+      return r(t)?.actions;
+    }
+  };
+}
+var h = /* @__PURE__ */ ((t) => (t.NotStarted = "Not Started", t.Started = "Started", t.Stopped = "Stopped", t))(h || {}), j = "__init__";
+function x(t) {
+  const e = () => t.getRootNode?.() ?? document, r = () => p(e());
+  return {
+    ...t,
+    getRootNode: e,
+    getDoc: r,
+    getWin: () => r().defaultView ?? window,
+    getActiveElement: () => m(e()),
+    isActiveElement: g,
+    getById: (i) => e().getElementById(i)
+  };
+}
+export {
+  j as INIT_STATE,
+  h as MachineStatus,
+  S as createGuards,
+  I as createMachine,
+  x as createScope,
+  G as memo,
+  _ as mergeProps,
+  B as setup
+};

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

@@ -0,0 +1,42 @@
+import { createAnatomy as e } from "../../anatomy/dist/index.js";
+import { createProps as o } from "../../types/dist/index.js";
+var t = e("dialog").parts(
+  "trigger",
+  "backdrop",
+  "positioner",
+  "content",
+  "title",
+  "description",
+  "closeTrigger"
+);
+t.build();
+o()([
+  "aria-label",
+  "closeOnEscape",
+  "closeOnInteractOutside",
+  "dir",
+  "finalFocusEl",
+  "getRootNode",
+  "getRootNode",
+  "id",
+  "id",
+  "ids",
+  "initialFocusEl",
+  "modal",
+  "onEscapeKeyDown",
+  "onFocusOutside",
+  "onInteractOutside",
+  "onOpenChange",
+  "onPointerDownOutside",
+  "onRequestDismiss",
+  "defaultOpen",
+  "open",
+  "persistentElements",
+  "preventScroll",
+  "restoreFocus",
+  "role",
+  "trapFocus"
+]);
+export {
+  t as anatomy
+};

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

@@ -0,0 +1,180 @@
+import { raf as D, contains as y, getDocument as L, waitForElement as T, setStyle as I, addDomEvent as A, isHTMLElement as b, getEventTarget as p } from "../../dom-query/dist/index.js";
+import { trackInteractOutside as N } from "../../interact-outside/dist/index.js";
+import { isFunction as M, warn as S } from "../../utils/dist/index.js";
+function q(e, t) {
+  const n = (s) => {
+    s.key === "Escape" && (s.isComposing || t?.(s));
+  };
+  return A(L(e), "keydown", n, { capture: !0 });
+}
+var m = "layer:request-dismiss", o = {
+  layers: [],
+  branches: [],
+  count() {
+    return this.layers.length;
+  },
+  pointerBlockingLayers() {
+    return this.layers.filter((e) => e.pointerBlocking);
+  },
+  topMostPointerBlockingLayer() {
+    return [...this.pointerBlockingLayers()].slice(-1)[0];
+  },
+  hasPointerBlockingLayer() {
+    return this.pointerBlockingLayers().length > 0;
+  },
+  isBelowPointerBlockingLayer(e) {
+    const t = this.indexOf(e), n = this.topMostPointerBlockingLayer() ? this.indexOf(this.topMostPointerBlockingLayer()?.node) : -1;
+    return t < n;
+  },
+  isTopMost(e) {
+    return this.layers[this.count() - 1]?.node === e;
+  },
+  getNestedLayers(e) {
+    return Array.from(this.layers).slice(this.indexOf(e) + 1);
+  },
+  getLayersByType(e) {
+    return this.layers.filter((t) => t.type === e);
+  },
+  getNestedLayersByType(e, t) {
+    const n = this.indexOf(e);
+    return n === -1 ? [] : this.layers.slice(n + 1).filter((s) => s.type === t);
+  },
+  getParentLayerOfType(e, t) {
+    const n = this.indexOf(e);
+    if (!(n <= 0))
+      return this.layers.slice(0, n).reverse().find((s) => s.type === t);
+  },
+  countNestedLayersOfType(e, t) {
+    return this.getNestedLayersByType(e, t).length;
+  },
+  isInNestedLayer(e, t) {
+    return this.getNestedLayers(e).some((n) => y(n.node, t));
+  },
+  isInBranch(e) {
+    return Array.from(this.branches).some((t) => y(t, e));
+  },
+  add(e) {
+    this.layers.push(e), this.syncLayers();
+  },
+  addBranch(e) {
+    this.branches.push(e);
+  },
+  remove(e) {
+    const t = this.indexOf(e);
+    t < 0 || (t < this.count() - 1 && this.getNestedLayers(e).forEach((s) => o.dismiss(s.node, e)), this.layers.splice(t, 1), this.syncLayers());
+  },
+  removeBranch(e) {
+    const t = this.branches.indexOf(e);
+    t >= 0 && this.branches.splice(t, 1);
+  },
+  syncLayers() {
+    this.layers.forEach((e, t) => {
+      e.node.style.setProperty("--layer-index", `${t}`), e.node.removeAttribute("data-nested"), e.node.removeAttribute("data-has-nested"), this.getParentLayerOfType(e.node, e.type) && e.node.setAttribute("data-nested", e.type);
+      const s = this.countNestedLayersOfType(e.node, e.type);
+      s > 0 && e.node.setAttribute("data-has-nested", e.type), e.node.style.setProperty("--nested-layer-count", `${s}`);
+    });
+  },
+  indexOf(e) {
+    return this.layers.findIndex((t) => t.node === e);
+  },
+  dismiss(e, t) {
+    const n = this.indexOf(e);
+    if (n === -1) return;
+    const s = this.layers[n];
+    C(e, m, (i) => {
+      s.requestDismiss?.(i), i.defaultPrevented || s?.dismiss();
+    }), _(e, m, {
+      originalLayer: e,
+      targetLayer: t,
+      originalIndex: n,
+      targetIndex: t ? this.indexOf(t) : -1
+    }), this.syncLayers();
+  },
+  clear() {
+    this.remove(this.layers[0].node);
+  }
+};
+function _(e, t, n) {
+  const s = e.ownerDocument.defaultView || window, i = new s.CustomEvent(t, { cancelable: !0, bubbles: !0, detail: n });
+  return e.dispatchEvent(i);
+}
+function C(e, t, n) {
+  e.addEventListener(t, n, { once: !0 });
+}
+var g;
+function E() {
+  o.layers.forEach(({ node: e }) => {
+    e.style.pointerEvents = o.isBelowPointerBlockingLayer(e) ? "none" : "auto";
+  });
+}
+function K(e) {
+  e.style.pointerEvents = "";
+}
+function F(e, t) {
+  const n = L(e), s = [];
+  return o.hasPointerBlockingLayer() && !n.body.hasAttribute("data-inert") && (g = document.body.style.pointerEvents, queueMicrotask(() => {
+    n.body.style.pointerEvents = "none", n.body.setAttribute("data-inert", "");
+  })), t?.forEach((i) => {
+    const [a, d] = T(
+      () => {
+        const c = i();
+        return b(c) ? c : null;
+      },
+      { timeout: 1e3 }
+    );
+    a.then((c) => s.push(I(c, { pointerEvents: "auto" }))), s.push(d);
+  }), () => {
+    o.hasPointerBlockingLayer() || (queueMicrotask(() => {
+      n.body.style.pointerEvents = g, n.body.removeAttribute("data-inert"), n.body.style.length === 0 && n.body.removeAttribute("style");
+    }), s.forEach((i) => i()));
+  };
+}
+function R(e, t) {
+  const { warnOnMissingNode: n = !0 } = t;
+  if (n && !e) {
+    S("[@zag-js/dismissable] node is `null` or `undefined`");
+    return;
+  }
+  if (!e)
+    return;
+  const { onDismiss: s, onRequestDismiss: i, pointerBlocking: a, exclude: d, debug: c, type: v = "dialog" } = t, B = { dismiss: s, node: e, type: v, pointerBlocking: a, requestDismiss: i };
+  o.add(B), E();
+  function O(r) {
+    const u = p(r.detail.originalEvent);
+    o.isBelowPointerBlockingLayer(e) || o.isInBranch(u) || (t.onPointerDownOutside?.(r), t.onInteractOutside?.(r), !r.defaultPrevented && (c && console.log("onPointerDownOutside:", r.detail.originalEvent), s?.()));
+  }
+  function x(r) {
+    const u = p(r.detail.originalEvent);
+    o.isInBranch(u) || (t.onFocusOutside?.(r), t.onInteractOutside?.(r), !r.defaultPrevented && (c && console.log("onFocusOutside:", r.detail.originalEvent), s?.()));
+  }
+  function k(r) {
+    o.isTopMost(e) && (t.onEscapeKeyDown?.(r), !r.defaultPrevented && s && (r.preventDefault(), s()));
+  }
+  function P(r) {
+    if (!e) return !1;
+    const u = typeof d == "function" ? d() : d, f = Array.isArray(u) ? u : [u], h = t.persistentElements?.map((l) => l()).filter(b);
+    return h && f.push(...h), f.some((l) => y(l, r)) || o.isInNestedLayer(e, r);
+  }
+  const w = [
+    a ? F(e, t.persistentElements) : void 0,
+    q(e, k),
+    N(e, { exclude: P, onFocusOutside: x, onPointerDownOutside: O, defer: t.defer })
+  ];
+  return () => {
+    o.remove(e), E(), K(e), w.forEach((r) => r?.());
+  };
+}
+function z(e, t) {
+  const { defer: n } = t, s = n ? D : (a) => a(), i = [];
+  return i.push(
+    s(() => {
+      const a = M(e) ? e() : e;
+      i.push(R(a, t));
+    })
+  ), () => {
+    i.forEach((a) => a?.());
+  };
+}
+export {
+  z as trackDismissableElement
+};