@bitrise/bitkit-v2 0.3.53 → 0.3.55

package/dist/node_modules/@chakra-ui/react/dist/esm/styled-system/system.js

@@ -0,0 +1,220 @@
+import { isCssProperty as H } from "../../../../../@pandacss/is-valid-prop/dist/index.js";
+import { compact as I } from "../utils/compact.js";
+import { mapEntries as K } from "../utils/entries.js";
+import { flatten as $ } from "../utils/flatten.js";
+import { isObject as X } from "../utils/is.js";
+import { memo as Z } from "../utils/memo.js";
+import { mergeWith as ee } from "../utils/merge.js";
+import { splitProps as te } from "../utils/split-props.js";
+import { createBreakpoints as se } from "./breakpoints.js";
+import { createConditions as re } from "./conditions.js";
+import { mergeConfigs as oe } from "./merge-config.js";
+import { createCssFn as ne } from "./css.js";
+import { createRecipeFn as ie } from "./cva.js";
+import { createLayers as ce } from "./layers.js";
+import { createNormalizeFn as ae } from "./normalize.js";
+import { createPreflight as le } from "./preflight.js";
+import { createSerializeFn as me } from "./serialize.js";
+import { EMPTY_OBJECT as r, createEmptyObject as pe } from "./singleton.js";
+import { createSlotRecipeFn as fe } from "./sva.js";
+import { createTokenDictionary as ue } from "./token-dictionary.js";
+import { createUtility as ye } from "./utility.js";
+function _e(...n) {
+  const o = oe(...n), {
+    theme: t = {},
+    utilities: l = {},
+    globalCss: m = {},
+    cssVarsRoot: a = ":where(:root, :host)",
+    cssVarsPrefix: y = "chakra",
+    preflight: g
+  } = o, p = ce(o), f = ue({
+    breakpoints: t.breakpoints,
+    tokens: t.tokens,
+    semanticTokens: t.semanticTokens,
+    prefix: y
+  }), v = se(t.breakpoints ?? r), u = re({
+    conditions: o.conditions ?? r,
+    breakpoints: v
+  }), k = ye({
+    config: l,
+    tokens: f
+  });
+  function N() {
+    const { textStyles: e, layerStyles: s, animationStyles: i } = t, c = I({
+      textStyle: e,
+      layerStyle: s,
+      animationStyle: i
+    });
+    for (const [b, j] of Object.entries(c)) {
+      const O = $(j ?? r, B);
+      k.register(b, {
+        values: Object.keys(O),
+        transform(Y) {
+          return h(O[Y]);
+        }
+      });
+    }
+  }
+  N(), k.addPropertyType(
+    "animationName",
+    Object.keys(t.keyframes ?? r)
+  );
+  const P = /* @__PURE__ */ new Set(["css", ...k.keys(), ...u.keys()]), S = Z(
+    (e) => P.has(e) || H(e)
+  ), T = (e) => {
+    if (Array.isArray(e)) {
+      const s = pe();
+      for (let i = 0; i < e.length; i++) {
+        const c = e[i];
+        if (c != null) {
+          const b = u.breakpoints[i];
+          s[b] = c;
+        }
+      }
+      return s;
+    }
+    return e;
+  }, x = ae({
+    utility: k,
+    normalize: T
+  }), C = me({
+    conditions: u,
+    isValidProperty: S
+  }), h = ne({
+    transform: k.transform,
+    conditions: u,
+    normalize: x
+  }), R = ie({
+    css: h,
+    conditions: u,
+    normalize: x,
+    layers: p
+  }), W = fe({ cva: R });
+  function w() {
+    const e = {};
+    for (const [s, i] of f.cssVarMap.entries()) {
+      const c = Object.fromEntries(i);
+      if (Object.keys(c).length === 0) continue;
+      const b = s === "base" ? a : u.resolve(s), j = b.startsWith("@"), O = h(
+        C({
+          [b]: j ? { [a]: c } : c
+        })
+      );
+      ee(e, O);
+    }
+    return p.wrap("tokens", e);
+  }
+  function z() {
+    const e = K(
+      t.keyframes ?? r,
+      (i, c) => [`@keyframes ${i}`, c]
+    ), s = Object.assign({}, e, h(C(m)));
+    return p.wrap("base", s);
+  }
+  function q(e) {
+    return te(e, S);
+  }
+  function F() {
+    const e = le({ preflight: g });
+    return p.wrap("reset", e);
+  }
+  const V = ke(f), E = (e, s) => V.get(e)?.value || s;
+  E.var = (e, s) => V.get(e)?.variable || s;
+  function D(e, s) {
+    return t.recipes?.[e] ?? s;
+  }
+  function G(e, s) {
+    return t.slotRecipes?.[e] ?? s;
+  }
+  function M(e) {
+    return Object.hasOwnProperty.call(t.recipes ?? r, e);
+  }
+  function A(e) {
+    return Object.hasOwnProperty.call(t.slotRecipes ?? r, e);
+  }
+  function J(e) {
+    return M(e) || A(e);
+  }
+  const L = [F(), z(), w()], U = {
+    layerStyles: d(t.layerStyles ?? r),
+    textStyles: d(t.textStyles ?? r),
+    animationStyles: d(t.animationStyles ?? r),
+    tokens: Q(
+      f,
+      Object.keys(t.tokens ?? r),
+      (e, s) => !e.extensions.conditions && !s.includes("colorPalette")
+    ),
+    semanticTokens: Q(
+      f,
+      Object.keys(t.semanticTokens ?? r),
+      (e) => !!e.extensions.conditions
+    ),
+    keyframes: _(t.keyframes ?? r),
+    breakpoints: _(t.breakpoints ?? r)
+  };
+  return {
+    $$chakra: !0,
+    _config: o,
+    _global: L,
+    breakpoints: v,
+    tokens: f,
+    conditions: u,
+    utility: k,
+    token: E,
+    properties: P,
+    layers: p,
+    isValidProperty: S,
+    splitCssProps: q,
+    normalizeValue: T,
+    getTokenCss: w,
+    getGlobalCss: z,
+    getPreflightCss: F,
+    css: h,
+    cva: R,
+    sva: W,
+    getRecipe: D,
+    getSlotRecipe: G,
+    hasRecipe: J,
+    isRecipe: M,
+    isSlotRecipe: A,
+    query: U
+  };
+}
+function ke(n) {
+  const o = /* @__PURE__ */ new Map();
+  return n.allTokens.forEach((t) => {
+    const { cssVar: l, virtual: m, conditions: a } = t.extensions, y = a || m ? l.ref : t.value;
+    o.set(t.name, { value: y, variable: l.ref });
+  }), o;
+}
+const B = (n) => X(n) && "value" in n, d = (n) => ({
+  list() {
+    return Object.keys($(n, B));
+  },
+  search(o) {
+    return this.list().filter((t) => t.includes(o));
+  }
+}), Q = (n, o, t) => ({
+  categoryKeys: o,
+  list(l) {
+    const m = n.categoryMap.get(l), a = m ? [...m.entries()] : [], y = [];
+    for (let g = 0; g < a.length; g++) {
+      const [p, f] = a[g];
+      t(f, p) && y.push(p);
+    }
+    return y;
+  },
+  search(l, m) {
+    return this.list(l).filter((a) => a.includes(m));
+  }
+}), _ = (n) => ({
+  list() {
+    return Object.keys(n);
+  },
+  search(o) {
+    return this.list().filter((t) => t.includes(o));
+  }
+});
+export {
+  _e as createSystem
+};

package/dist/node_modules/@chakra-ui/react/dist/esm/styled-system/token-dictionary.js

@@ -0,0 +1,309 @@
+import { compact as pe } from "../utils/compact.js";
+import { createProps as de } from "../utils/create-props.js";
+import { mapEntries as me } from "../utils/entries.js";
+import { isString as L, isObject as ge, isFunction as ve } from "../utils/is.js";
+import { memo as R } from "../utils/memo.js";
+import { mapObject as xe, walkObject as j } from "../utils/walk-object.js";
+import { cssVar as be } from "./css-var.js";
+import { esc as Te } from "./esc.js";
+import { expandTokenReferences as Me } from "./expand-reference.js";
+import { mapToJson as ye } from "./map-to-json.js";
+import { hasReference as we, expandReferences as Ve, getReferences as Ee, TOKEN_PATH_REGEX as ke } from "./references.js";
+import { tokenMiddlewares as he } from "./token-middleware.js";
+import { tokenTransforms as Pe } from "./token-transforms.js";
+const U = (o) => ge(o) && Object.prototype.hasOwnProperty.call(o, "value");
+function Ce(o) {
+  return o ? {
+    breakpoints: xe(o, (c) => ({ value: c })),
+    sizes: me(o, (c, u) => [
+      `breakpoint-${c}`,
+      { value: u }
+    ])
+  } : { breakpoints: {}, sizes: {} };
+}
+function _e(o) {
+  const {
+    prefix: c = "",
+    tokens: u = {},
+    semanticTokens: v = {},
+    breakpoints: m = {}
+  } = o, a = (n) => n.join("."), g = (n, e) => be(n.join("-"), { prefix: e }), l = [], w = /* @__PURE__ */ new Map(), V = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map(), D = [];
+  function M(n, e) {
+    l.push(n), w.set(n.name, n), e && k.forEach((t) => {
+      t.enforce === e && F(t, n);
+    });
+  }
+  const z = Ce(m), H = pe({
+    ...u,
+    breakpoints: z.breakpoints,
+    sizes: {
+      ...u.sizes,
+      ...z.sizes
+    }
+  });
+  function J() {
+    j(
+      H,
+      (n, e) => {
+        const t = e.includes("DEFAULT");
+        e = W(e);
+        const s = e[0], r = a(e), i = L(n) ? { value: n } : n, f = {
+          value: i.value,
+          originalValue: i.value,
+          name: r,
+          path: e,
+          extensions: {
+            condition: "base",
+            originalPath: e,
+            category: s,
+            prop: a(e.slice(1))
+          }
+        };
+        t && (f.extensions.default = !0), M(f);
+      },
+      { stop: U }
+    ), j(
+      v,
+      (n, e) => {
+        const t = e.includes("DEFAULT");
+        e = _(W(e));
+        const s = e[0], r = a(e), i = L(n.value) ? { value: { base: n.value } } : n, f = {
+          value: i.value.base || "",
+          originalValue: i.value.base || "",
+          name: r,
+          path: e,
+          extensions: {
+            originalPath: e,
+            category: s,
+            conditions: i.value,
+            condition: "base",
+            prop: a(e.slice(1))
+          }
+        };
+        t && (f.extensions.default = !0), M(f);
+      },
+      { stop: U }
+    );
+  }
+  function d(n) {
+    return w.get(n);
+  }
+  function G(n) {
+    const { condition: e } = n.extensions;
+    e && (V.has(e) || V.set(e, /* @__PURE__ */ new Set()), V.get(e).add(n));
+  }
+  function K(n) {
+    const { category: e, prop: t } = n.extensions;
+    e && (T.has(e) || T.set(e, /* @__PURE__ */ new Map()), T.get(e).set(t, n));
+  }
+  function X(n) {
+    const { condition: e, negative: t, virtual: s, cssVar: r } = n.extensions;
+    t || s || !e || !r || (x.has(e) || x.set(e, /* @__PURE__ */ new Map()), x.get(e).set(r.var, n.value));
+  }
+  function q(n) {
+    const { category: e, prop: t, cssVar: s, negative: r } = n.extensions;
+    if (!e) return;
+    b.has(e) || b.set(e, /* @__PURE__ */ new Map());
+    const i = r ? n.extensions.conditions ? n.originalValue : n.value : s.ref;
+    b.get(e).set(t, i), E.set([e, t].join("."), i);
+  }
+  function Q(n) {
+    const { colorPalette: e, virtual: t, default: s } = n.extensions;
+    !e || t || e.roots.forEach((r) => {
+      const i = a(r);
+      p.has(i) || p.set(i, /* @__PURE__ */ new Map());
+      const f = Re(
+        [...n.path],
+        [...r]
+      ), y = a(f), C = d(y);
+      if (!C || !C.extensions.cssVar) return;
+      const { var: ue } = C.extensions.cssVar;
+      if (p.get(i).set(ue, n.extensions.cssVar.ref), s && r.length === 1) {
+        const fe = a(["colors", "colorPalette"]), I = d(fe);
+        if (!I) return;
+        const le = a(n.path), S = d(le);
+        if (!S) return;
+        const B = e.keys[0]?.filter(Boolean);
+        if (!B.length) return;
+        const N = a(r.concat(B));
+        p.has(N) || p.set(N, /* @__PURE__ */ new Map()), p.get(N).set(
+          I.extensions.cssVar.var,
+          S.extensions.cssVar.ref
+        );
+      }
+    });
+  }
+  let O = {};
+  function Y() {
+    l.forEach((n) => {
+      G(n), K(n), X(n), q(n), Q(n);
+    }), O = ye(b);
+  }
+  const Z = (n, e) => {
+    if (!n || typeof n != "string") return { invalid: !0, value: n };
+    const [t, s] = n.split("/");
+    if (!t || !s)
+      return { invalid: !0, value: t };
+    const r = e(t), i = d(`opacity.${s}`)?.value;
+    if (!i && isNaN(Number(s)))
+      return { invalid: !0, value: t };
+    const f = i ? Number(i) * 100 + "%" : `${s}%`, y = r ?? t;
+    return {
+      invalid: !1,
+      color: y,
+      value: `color-mix(in srgb, ${y} ${f}, transparent)`
+    };
+  }, h = R((n, e) => E.get(n) ?? e), ee = R((n) => O[n] || null), ne = R((n) => Me(n, (e) => {
+    if (!e) return;
+    if (e.includes("/")) {
+      const s = Z(e, (r) => h(r));
+      if (s.invalid)
+        throw new Error("Invalid color mix at " + e + ": " + s.value);
+      return s.value;
+    }
+    const t = h(e);
+    return t || (ke.test(e) ? Te(e) : e);
+  })), P = {
+    prefix: c,
+    allTokens: l,
+    tokenMap: w,
+    registerToken: M,
+    getByName: d,
+    formatTokenName: a,
+    formatCssVar: g,
+    flatMap: E,
+    cssVarMap: x,
+    categoryMap: T,
+    colorPaletteMap: p,
+    getVar: h,
+    getCategoryValues: ee,
+    expandReferenceInValue: ne
+  };
+  function te(...n) {
+    n.forEach((e) => {
+      k.set(e.name, e);
+    });
+  }
+  function se(...n) {
+    D.push(...n);
+  }
+  function F(n, e) {
+    if (e.extensions.references || ve(n.match) && !n.match(e)) return;
+    const s = ((r) => n.transform(r, P))(e);
+    switch (!0) {
+      case n.type === "extensions":
+        Object.assign(e.extensions, s);
+        break;
+      case n.type === "value":
+        e.value = s;
+        break;
+      default:
+        e[n.type] = s;
+        break;
+    }
+  }
+  function $(n) {
+    D.forEach((e) => {
+      e.enforce === n && e.transform(P);
+    });
+  }
+  function A(n) {
+    k.forEach((e) => {
+      e.enforce === n && l.forEach((t) => {
+        F(e, t);
+      });
+    });
+  }
+  function oe() {
+    l.forEach((n) => {
+      const e = Ne(n);
+      !e || e.length === 0 || e.forEach((t) => {
+        M(t);
+      });
+    });
+  }
+  function re(n) {
+    const e = Ee(n), t = [];
+    for (let s = 0; s < e.length; s++) {
+      const r = d(e[s]);
+      r && t.push(r);
+    }
+    return t;
+  }
+  function ie() {
+    l.forEach((n) => {
+      if (!we(n.value)) return;
+      const e = re(n.value);
+      n.extensions.references = e.reduce((t, s) => (t[s.name] = s, t), {});
+    });
+  }
+  function ae() {
+    l.forEach((n) => {
+      Ve(n);
+    });
+  }
+  function ce() {
+    $("pre"), A("pre"), oe(), ie(), ae(), $("post"), A("post"), Y();
+  }
+  return J(), te(...Pe), se(...he), ce(), P;
+}
+function W(o) {
+  return o[0] === "DEFAULT" ? o : o.filter((c) => c !== "DEFAULT");
+}
+function _(o) {
+  return o.filter((c) => c !== "base");
+}
+function Ne(o) {
+  if (!o.extensions.conditions) return;
+  const { conditions: c } = o.extensions, u = [];
+  return j(c, (v, m) => {
+    const a = _(m);
+    if (!a.length) return;
+    const g = {
+      ...o,
+      value: v,
+      extensions: {
+        ...o.extensions,
+        condition: a.join(":")
+      }
+    };
+    u.push(g);
+  }), u;
+}
+function Re(o, c) {
+  const u = o.findIndex(
+    (v, m) => c.every(
+      (a, g) => o[m + g] === a
+    )
+  );
+  return u === -1 || (o.splice(u, c.length), o.splice(u, 0, "colorPalette")), o;
+}
+de()([
+  "aspectRatios",
+  "zIndex",
+  "opacity",
+  "colors",
+  "fonts",
+  "fontSizes",
+  "fontWeights",
+  "lineHeights",
+  "letterSpacings",
+  "sizes",
+  "shadows",
+  "spacing",
+  "radii",
+  "cursor",
+  "borders",
+  "borderWidths",
+  "borderStyles",
+  "durations",
+  "easings",
+  "animations",
+  "blurs",
+  "gradients",
+  "breakpoints",
+  "assets"
+]);
+export {
+  _e as createTokenDictionary
+};

package/dist/node_modules/@chakra-ui/react/dist/esm/styled-system/token-middleware.js

@@ -0,0 +1,101 @@
+import { isString as m } from "../utils/is.js";
+import { calc as u } from "./calc.js";
+import { toPx as x } from "./unit-conversion.js";
+const k = {
+  enforce: "pre",
+  transform(r) {
+    const { prefix: i, allTokens: s, formatCssVar: a, formatTokenName: p, registerToken: l } = r;
+    s.filter(
+      ({ extensions: e }) => e.category === "spacing"
+    ).forEach((e) => {
+      const t = e.path.slice(), o = a(t, i);
+      if (m(e.value) && e.value === "0rem")
+        return;
+      const n = [...e.path], c = n[n.length - 1];
+      c != null && (n[n.length - 1] = `-${c}`);
+      const f = {
+        ...e,
+        value: u.negate(o.ref),
+        name: p(n),
+        path: n,
+        extensions: {
+          ...e.extensions,
+          negative: !0,
+          prop: `-${e.extensions.prop}`,
+          originalPath: t
+        }
+      };
+      l(f);
+    });
+  }
+}, d = /* @__PURE__ */ new Set([
+  "spacing",
+  "sizes",
+  "borderWidths",
+  "fontSizes",
+  "radii"
+]), T = {
+  enforce: "post",
+  transform(r) {
+    r.allTokens.filter((s) => d.has(s.extensions.category) && !s.extensions.negative).forEach((s) => {
+      Object.assign(s.extensions, {
+        pixelValue: x(s.value)
+      });
+    });
+  }
+}, v = {
+  enforce: "post",
+  transform(r) {
+    const { allTokens: i, registerToken: s, formatTokenName: a } = r, p = i.filter(
+      ({ extensions: e }) => e.category === "colors"
+    ), l = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map();
+    p.forEach((e) => {
+      const { colorPalette: t } = e.extensions;
+      t && (t.keys.forEach((o) => {
+        l.set(a(o), o);
+      }), t.roots.forEach((o) => {
+        const n = a(o), c = g.get(n) || [];
+        if (c.push(e), g.set(n, c), e.extensions.default && o.length === 1) {
+          const f = t.keys[0]?.filter(Boolean);
+          if (!f.length) return;
+          const h = o.concat(f);
+          l.set(a(h), []);
+        }
+      }));
+    }), l.forEach((e) => {
+      const t = ["colors", "colorPalette", ...e].filter(Boolean), o = a(t), n = a(t.slice(1));
+      s({
+        name: o,
+        value: o,
+        originalValue: o,
+        path: t,
+        extensions: {
+          condition: "base",
+          originalPath: t,
+          category: "colors",
+          prop: n,
+          virtual: !0
+        }
+      }, "pre");
+    });
+  }
+}, P = {
+  enforce: "post",
+  transform(r) {
+    r.allTokens = r.allTokens.filter(
+      (i) => i.value !== ""
+    );
+  }
+}, V = [
+  k,
+  v,
+  T,
+  P
+];
+export {
+  k as addNegativeTokens,
+  T as addPixelUnit,
+  v as addVirtualPalette,
+  P as removeEmptyTokens,
+  V as tokenMiddlewares
+};

package/dist/node_modules/@chakra-ui/react/dist/esm/styled-system/token-transforms.js

@@ -0,0 +1,56 @@
+import { getReferences as u } from "./references.js";
+const h = {
+  type: "extensions",
+  enforce: "pre",
+  name: "tokens/css-var",
+  transform(e, o) {
+    const { prefix: t, formatCssVar: a } = o, { negative: n, originalPath: l } = e.extensions, s = n ? l : e.path;
+    return {
+      cssVar: a(s.filter(Boolean), t)
+    };
+  }
+}, m = {
+  enforce: "post",
+  type: "value",
+  name: "tokens/conditionals",
+  transform(e, o) {
+    const { prefix: t, formatCssVar: a } = o, n = u(e.value);
+    return n.length && n.forEach((l) => {
+      const s = a(l.split("."), t);
+      e.value = e.value.replace(`{${s.ref}}`, s);
+    }), e.value;
+  }
+}, d = {
+  type: "extensions",
+  enforce: "pre",
+  name: "tokens/colors/colorPalette",
+  match(e) {
+    return e.extensions.category === "colors" && !e.extensions.virtual;
+  },
+  transform(e, o) {
+    let t = e.path.slice();
+    if (t.pop(), t.shift(), t.length === 0) {
+      const r = [...e.path];
+      r.shift(), t = r;
+    }
+    if (t.length === 0)
+      return {};
+    const a = t.reduce((r, f, c, i) => {
+      const p = i.slice(0, c + 1);
+      return r.push(p), r;
+    }, []), n = t[0], l = o.formatTokenName(t), s = e.path.slice(e.path.indexOf(n) + 1).reduce((r, f, c, i) => (r.push(i.slice(c)), r), []);
+    return s.length === 0 && s.push([""]), {
+      colorPalette: { value: l, roots: a, keys: s }
+    };
+  }
+}, x = [
+  h,
+  m,
+  d
+];
+export {
+  d as addColorPalette,
+  m as addConditionalCssVariables,
+  h as addCssVariables,
+  x as tokenTransforms
+};

package/dist/node_modules/@chakra-ui/react/dist/esm/styled-system/unit-conversion.js

@@ -0,0 +1,29 @@
+function r(t = "") {
+  const n = new RegExp(String.raw`-?\d+(?:\.\d+|\d*)`), E = new RegExp("px|em|rem");
+  return t.match(
+    new RegExp(`${n.source}(${E.source})`)
+  )?.[1];
+}
+function o(t = "") {
+  if (typeof t == "number")
+    return `${t}px`;
+  const n = r(t);
+  if (!n || n === "px")
+    return t;
+  if (n === "em" || n === "rem")
+    return `${parseFloat(t) * 16}px`;
+}
+function I(t = "") {
+  const n = r(t);
+  if (!n || n === "rem")
+    return t;
+  if (n === "em")
+    return `${parseFloat(t)}rem`;
+  if (n === "px")
+    return `${parseFloat(t) / 16}rem`;
+}
+export {
+  r as getUnit,
+  o as toPx,
+  I as toRem
+};