@figma-vars/hooks 1.4.5 → 1.5.0

package/dist/index.mjs

@@ -0,0 +1,838 @@
+import { jsx as Oe } from "react/jsx-runtime";
+import et, { createContext as Zt, useContext as te, useEffect as ve, useLayoutEffect as we, useRef as q, useMemo as ft, useCallback as lt, useDebugValue as Re, useReducer as Te } from "react";
+const ee = Zt(
+  void 0
+), pn = ({
+  children: t,
+  token: e,
+  fileKey: n
+}) => /* @__PURE__ */ Oe(ee.Provider, { value: { token: e, fileKey: n }, children: t }), nt = () => {
+  const t = te(ee);
+  if (t === void 0)
+    throw new Error(
+      "useFigmaTokenContext must be used within a FigmaVarsProvider"
+    );
+  return t;
+};
+var at = { exports: {} }, _t = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ht;
+function ge() {
+  if (Ht) return _t;
+  Ht = 1;
+  var t = et;
+  function e(l, E) {
+    return l === E && (l !== 0 || 1 / l === 1 / E) || l !== l && E !== E;
+  }
+  var n = typeof Object.is == "function" ? Object.is : e, r = t.useState, s = t.useEffect, c = t.useLayoutEffect, o = t.useDebugValue;
+  function u(l, E) {
+    var a = E(), p = r({ inst: { value: a, getSnapshot: E } }), f = p[0].inst, I = p[1];
+    return c(
+      function() {
+        f.value = a, f.getSnapshot = E, m(f) && I({ inst: f });
+      },
+      [l, a, E]
+    ), s(
+      function() {
+        return m(f) && I({ inst: f }), l(function() {
+          m(f) && I({ inst: f });
+        });
+      },
+      [l]
+    ), o(a), a;
+  }
+  function m(l) {
+    var E = l.getSnapshot;
+    l = l.value;
+    try {
+      var a = E();
+      return !n(l, a);
+    } catch {
+      return !0;
+    }
+  }
+  function g(l, E) {
+    return E();
+  }
+  var O = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? g : u;
+  return _t.useSyncExternalStore = t.useSyncExternalStore !== void 0 ? t.useSyncExternalStore : O, _t;
+}
+var St = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var kt;
+function ye() {
+  return kt || (kt = 1, process.env.NODE_ENV !== "production" && function() {
+    function t(a, p) {
+      return a === p && (a !== 0 || 1 / a === 1 / p) || a !== a && p !== p;
+    }
+    function e(a, p) {
+      O || s.startTransition === void 0 || (O = !0, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var f = p();
+      if (!l) {
+        var I = p();
+        c(f, I) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), l = !0);
+      }
+      I = o({
+        inst: { value: f, getSnapshot: p }
+      });
+      var i = I[0].inst, j = I[1];
+      return m(
+        function() {
+          i.value = f, i.getSnapshot = p, n(i) && j({ inst: i });
+        },
+        [a, f, p]
+      ), u(
+        function() {
+          return n(i) && j({ inst: i }), a(function() {
+            n(i) && j({ inst: i });
+          });
+        },
+        [a]
+      ), g(f), f;
+    }
+    function n(a) {
+      var p = a.getSnapshot;
+      a = a.value;
+      try {
+        var f = p();
+        return !c(a, f);
+      } catch {
+        return !0;
+      }
+    }
+    function r(a, p) {
+      return p();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var s = et, c = typeof Object.is == "function" ? Object.is : t, o = s.useState, u = s.useEffect, m = s.useLayoutEffect, g = s.useDebugValue, O = !1, l = !1, E = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? r : e;
+    St.useSyncExternalStore = s.useSyncExternalStore !== void 0 ? s.useSyncExternalStore : E, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  }()), St;
+}
+var Kt;
+function Ae() {
+  return Kt || (Kt = 1, process.env.NODE_ENV === "production" ? at.exports = ge() : at.exports = ye()), at.exports;
+}
+var De = Ae();
+const ne = 0, re = 1, oe = 2, Jt = 3;
+var Yt = Object.prototype.hasOwnProperty;
+function yt(t, e) {
+  var n, r;
+  if (t === e) return !0;
+  if (t && e && (n = t.constructor) === e.constructor) {
+    if (n === Date) return t.getTime() === e.getTime();
+    if (n === RegExp) return t.toString() === e.toString();
+    if (n === Array) {
+      if ((r = t.length) === e.length)
+        for (; r-- && yt(t[r], e[r]); ) ;
+      return r === -1;
+    }
+    if (!n || typeof t == "object") {
+      r = 0;
+      for (n in t)
+        if (Yt.call(t, n) && ++r && !Yt.call(e, n) || !(n in e) || !yt(t[n], e[n])) return !1;
+      return Object.keys(e).length === r;
+    }
+  }
+  return t !== t && e !== e;
+}
+const P = /* @__PURE__ */ new WeakMap(), G = () => {
+}, D = (
+  /*#__NOINLINE__*/
+  G()
+), At = Object, d = (t) => t === D, N = (t) => typeof t == "function", W = (t, e) => ({
+  ...t,
+  ...e
+}), se = (t) => N(t.then), Ot = {}, ct = {}, Nt = "undefined", rt = typeof window != Nt, Dt = typeof document != Nt, Ie = rt && "Deno" in window, Le = () => rt && typeof window.requestAnimationFrame != Nt, ie = (t, e) => {
+  const n = P.get(t);
+  return [
+    // Getter
+    () => !d(e) && t.get(e) || Ot,
+    // Setter
+    (r) => {
+      if (!d(e)) {
+        const s = t.get(e);
+        e in ct || (ct[e] = s), n[5](e, W(s, r), s || Ot);
+      }
+    },
+    // Subscriber
+    n[6],
+    // Get server cache snapshot
+    () => !d(e) && e in ct ? ct[e] : !d(e) && t.get(e) || Ot
+  ];
+};
+let It = !0;
+const Ce = () => It, [Lt, Ct] = rt && window.addEventListener ? [
+  window.addEventListener.bind(window),
+  window.removeEventListener.bind(window)
+] : [
+  G,
+  G
+], be = () => {
+  const t = Dt && document.visibilityState;
+  return d(t) || t !== "hidden";
+}, Ve = (t) => (Dt && document.addEventListener("visibilitychange", t), Lt("focus", t), () => {
+  Dt && document.removeEventListener("visibilitychange", t), Ct("focus", t);
+}), Ne = (t) => {
+  const e = () => {
+    It = !0, t();
+  }, n = () => {
+    It = !1;
+  };
+  return Lt("online", e), Lt("offline", n), () => {
+    Ct("online", e), Ct("offline", n);
+  };
+}, Fe = {
+  isOnline: Ce,
+  isVisible: be
+}, xe = {
+  initFocus: Ve,
+  initReconnect: Ne
+}, zt = !et.useId, tt = !rt || Ie, Me = (t) => Le() ? window.requestAnimationFrame(t) : setTimeout(t, 1), vt = tt ? ve : we, wt = typeof navigator < "u" && navigator.connection, Xt = !tt && wt && ([
+  "slow-2g",
+  "2g"
+].includes(wt.effectiveType) || wt.saveData), ut = /* @__PURE__ */ new WeakMap(), Pe = (t) => At.prototype.toString.call(t), Rt = (t, e) => t === `[object ${e}]`;
+let je = 0;
+const bt = (t) => {
+  const e = typeof t, n = Pe(t), r = Rt(n, "Date"), s = Rt(n, "RegExp"), c = Rt(n, "Object");
+  let o, u;
+  if (At(t) === t && !r && !s) {
+    if (o = ut.get(t), o) return o;
+    if (o = ++je + "~", ut.set(t, o), Array.isArray(t)) {
+      for (o = "@", u = 0; u < t.length; u++)
+        o += bt(t[u]) + ",";
+      ut.set(t, o);
+    }
+    if (c) {
+      o = "#";
+      const m = At.keys(t).sort();
+      for (; !d(u = m.pop()); )
+        d(t[u]) || (o += u + ":" + bt(t[u]) + ",");
+      ut.set(t, o);
+    }
+  } else
+    o = r ? t.toJSON() : e == "symbol" ? t.toString() : e == "string" ? JSON.stringify(t) : "" + t;
+  return o;
+}, Ft = (t) => {
+  if (N(t))
+    try {
+      t = t();
+    } catch {
+      t = "";
+    }
+  const e = t;
+  return t = typeof t == "string" ? t : (Array.isArray(t) ? t.length : t) ? bt(t) : "", [
+    t,
+    e
+  ];
+};
+let Ue = 0;
+const Vt = () => ++Ue;
+async function ae(...t) {
+  const [e, n, r, s] = t, c = W({
+    populateCache: !0,
+    throwOnError: !0
+  }, typeof s == "boolean" ? {
+    revalidate: s
+  } : s || {});
+  let o = c.populateCache;
+  const u = c.rollbackOnError;
+  let m = c.optimisticData;
+  const g = (E) => typeof u == "function" ? u(E) : u !== !1, O = c.throwOnError;
+  if (N(n)) {
+    const E = n, a = [], p = e.keys();
+    for (const f of p)
+      // Skip the special useSWRInfinite and useSWRSubscription keys.
+      !/^\$(inf|sub)\$/.test(f) && E(e.get(f)._k) && a.push(f);
+    return Promise.all(a.map(l));
+  }
+  return l(n);
+  async function l(E) {
+    const [a] = Ft(E);
+    if (!a) return;
+    const [p, f] = ie(e, a), [I, i, j, X] = P.get(e), U = () => {
+      const y = I[a];
+      return (N(c.revalidate) ? c.revalidate(p().data, E) : c.revalidate !== !1) && (delete j[a], delete X[a], y && y[0]) ? y[0](oe).then(() => p().data) : p().data;
+    };
+    if (t.length < 3)
+      return U();
+    let R = r, F, b = !1;
+    const S = Vt();
+    i[a] = [
+      S,
+      0
+    ];
+    const H = !d(m), V = p(), k = V.data, ot = V._c, B = d(ot) ? k : ot;
+    if (H && (m = N(m) ? m(B, k) : m, f({
+      data: m,
+      _c: B
+    })), N(R))
+      try {
+        R = R(B);
+      } catch (y) {
+        F = y, b = !0;
+      }
+    if (R && se(R))
+      if (R = await R.catch((y) => {
+        F = y, b = !0;
+      }), S !== i[a][0]) {
+        if (b) throw F;
+        return R;
+      } else b && H && g(F) && (o = !0, f({
+        data: B,
+        _c: D
+      }));
+    if (o && !b)
+      if (N(o)) {
+        const y = o(R, B);
+        f({
+          data: y,
+          error: D,
+          _c: D
+        });
+      } else
+        f({
+          data: R,
+          error: D,
+          _c: D
+        });
+    if (i[a][1] = Vt(), Promise.resolve(U()).then(() => {
+      f({
+        _c: D
+      });
+    }), b) {
+      if (O) throw F;
+      return;
+    }
+    return R;
+  }
+}
+const Qt = (t, e) => {
+  for (const n in t)
+    t[n][0] && t[n][0](e);
+}, Ge = (t, e) => {
+  if (!P.has(t)) {
+    const n = W(xe, e), r = /* @__PURE__ */ Object.create(null), s = ae.bind(D, t);
+    let c = G;
+    const o = /* @__PURE__ */ Object.create(null), u = (O, l) => {
+      const E = o[O] || [];
+      return o[O] = E, E.push(l), () => E.splice(E.indexOf(l), 1);
+    }, m = (O, l, E) => {
+      t.set(O, l);
+      const a = o[O];
+      if (a)
+        for (const p of a)
+          p(l, E);
+    }, g = () => {
+      if (!P.has(t) && (P.set(t, [
+        r,
+        /* @__PURE__ */ Object.create(null),
+        /* @__PURE__ */ Object.create(null),
+        /* @__PURE__ */ Object.create(null),
+        s,
+        m,
+        u
+      ]), !tt)) {
+        const O = n.initFocus(setTimeout.bind(D, Qt.bind(D, r, ne))), l = n.initReconnect(setTimeout.bind(D, Qt.bind(D, r, re)));
+        c = () => {
+          O && O(), l && l(), P.delete(t);
+        };
+      }
+    };
+    return g(), [
+      t,
+      s,
+      g,
+      c
+    ];
+  }
+  return [
+    t,
+    P.get(t)[4]
+  ];
+}, We = (t, e, n, r, s) => {
+  const c = n.errorRetryCount, o = s.retryCount, u = ~~((Math.random() + 0.5) * (1 << (o < 8 ? o : 8))) * n.errorRetryInterval;
+  !d(c) && o > c || setTimeout(r, u, s);
+}, Be = yt, [ce, $e] = Ge(/* @__PURE__ */ new Map()), qe = W(
+  {
+    // events
+    onLoadingSlow: G,
+    onSuccess: G,
+    onError: G,
+    onErrorRetry: We,
+    onDiscarded: G,
+    // switches
+    revalidateOnFocus: !0,
+    revalidateOnReconnect: !0,
+    revalidateIfStale: !0,
+    shouldRetryOnError: !0,
+    // timeouts
+    errorRetryInterval: Xt ? 1e4 : 5e3,
+    focusThrottleInterval: 5 * 1e3,
+    dedupingInterval: 2 * 1e3,
+    loadingTimeout: Xt ? 5e3 : 3e3,
+    // providers
+    compare: Be,
+    isPaused: () => !1,
+    cache: ce,
+    mutate: $e,
+    fallback: {}
+  },
+  // use web preset by default
+  Fe
+), He = (t, e) => {
+  const n = W(t, e);
+  if (e) {
+    const { use: r, fallback: s } = t, { use: c, fallback: o } = e;
+    r && c && (n.use = r.concat(c)), s && o && (n.fallback = W(s, o));
+  }
+  return n;
+}, ke = Zt({}), Ke = "$inf$", ue = rt && window.__SWR_DEVTOOLS_USE__, Je = ue ? window.__SWR_DEVTOOLS_USE__ : [], Ye = () => {
+  ue && (window.__SWR_DEVTOOLS_REACT__ = et);
+}, ze = (t) => N(t[1]) ? [
+  t[0],
+  t[1],
+  t[2] || {}
+] : [
+  t[0],
+  null,
+  (t[1] === null ? t[2] : t[1]) || {}
+], Xe = () => W(qe, te(ke)), Qe = (t) => (e, n, r) => t(e, n && ((...c) => {
+  const [o] = Ft(e), [, , , u] = P.get(ce);
+  if (o.startsWith(Ke))
+    return n(...c);
+  const m = u[o];
+  return d(m) ? n(...c) : (delete u[o], m);
+}), r), Ze = Je.concat(Qe), tn = (t) => function(...n) {
+  const r = Xe(), [s, c, o] = ze(n), u = He(r, o);
+  let m = t;
+  const { use: g } = u, O = (g || []).concat(Ze);
+  for (let l = O.length; l--; )
+    m = O[l](m);
+  return m(s, c || u.fetcher || null, u);
+}, en = (t, e, n) => {
+  const r = e[t] || (e[t] = []);
+  return r.push(n), () => {
+    const s = r.indexOf(n);
+    s >= 0 && (r[s] = r[r.length - 1], r.pop());
+  };
+};
+Ye();
+const Tt = et.use || // This extra generic is to avoid TypeScript mixing up the generic and JSX sytax
+// and emitting an error.
+// We assume that this is only for the `use(thenable)` case, not `use(context)`.
+// https://github.com/facebook/react/blob/aed00dacfb79d17c53218404c52b1c7aa59c4a89/packages/react-server/src/ReactFizzThenable.js#L45
+((t) => {
+  switch (t.status) {
+    case "pending":
+      throw t;
+    case "fulfilled":
+      return t.value;
+    case "rejected":
+      throw t.reason;
+    default:
+      throw t.status = "pending", t.then((e) => {
+        t.status = "fulfilled", t.value = e;
+      }, (e) => {
+        t.status = "rejected", t.reason = e;
+      }), t;
+  }
+}), gt = {
+  dedupe: !0
+}, nn = (t, e, n) => {
+  const { cache: r, compare: s, suspense: c, fallbackData: o, revalidateOnMount: u, revalidateIfStale: m, refreshInterval: g, refreshWhenHidden: O, refreshWhenOffline: l, keepPreviousData: E } = n, [a, p, f, I] = P.get(r), [i, j] = Ft(t), X = q(!1), U = q(!1), R = q(i), F = q(e), b = q(n), S = () => b.current, H = () => S().isVisible() && S().isOnline(), [V, k, ot, B] = ie(r, i), y = q({}).current, Q = d(o) ? d(n.fallback) ? D : n.fallback[i] : o, Mt = (_, h) => {
+    for (const T in y) {
+      const v = T;
+      if (v === "data") {
+        if (!s(_[v], h[v]) && (!d(_[v]) || !s(it, h[v])))
+          return !1;
+      } else if (h[v] !== _[v])
+        return !1;
+    }
+    return !0;
+  }, Pt = ft(() => {
+    const _ = !i || !e ? !1 : d(u) ? S().isPaused() || c ? !1 : m !== !1 : u, h = (A) => {
+      const x = W(A);
+      return delete x._k, _ ? {
+        isValidating: !0,
+        isLoading: !0,
+        ...x
+      } : x;
+    }, T = V(), v = B(), C = h(T), Y = T === v ? C : h(v);
+    let w = C;
+    return [
+      () => {
+        const A = h(V());
+        return Mt(A, w) ? (w.data = A.data, w.isLoading = A.isLoading, w.isValidating = A.isValidating, w.error = A.error, w) : (w = A, A);
+      },
+      () => Y
+    ];
+  }, [
+    r,
+    i
+  ]), K = De.useSyncExternalStore(lt(
+    (_) => ot(i, (h, T) => {
+      Mt(T, h) || _();
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      r,
+      i
+    ]
+  ), Pt[0], Pt[1]), jt = !X.current, me = a[i] && a[i].length > 0, J = K.data, $ = d(J) ? Q && se(Q) ? Tt(Q) : Q : J, st = K.error, pt = q($), it = E ? d(J) ? d(pt.current) ? $ : pt.current : J : $, Ut = me && !d(st) ? !1 : jt && !d(u) ? u : S().isPaused() ? !1 : c ? d($) ? !1 : m : d($) || m, Gt = !!(i && e && jt && Ut), he = d(K.isValidating) ? Gt : K.isValidating, _e = d(K.isLoading) ? Gt : K.isLoading, Z = lt(
+    async (_) => {
+      const h = F.current;
+      if (!i || !h || U.current || S().isPaused())
+        return !1;
+      let T, v, C = !0;
+      const Y = _ || {}, w = !f[i] || !Y.dedupe, A = () => zt ? !U.current && i === R.current && X.current : i === R.current, x = {
+        isValidating: !1,
+        isLoading: !1
+      }, Bt = () => {
+        k(x);
+      }, $t = () => {
+        const L = f[i];
+        L && L[1] === v && delete f[i];
+      }, qt = {
+        isValidating: !0
+      };
+      d(V().data) && (qt.isLoading = !0);
+      try {
+        if (w && (k(qt), n.loadingTimeout && d(V().data) && setTimeout(() => {
+          C && A() && S().onLoadingSlow(i, n);
+        }, n.loadingTimeout), f[i] = [
+          h(j),
+          Vt()
+        ]), [T, v] = f[i], T = await T, w && setTimeout($t, n.dedupingInterval), !f[i] || f[i][1] !== v)
+          return w && A() && S().onDiscarded(i), !1;
+        x.error = D;
+        const L = p[i];
+        if (!d(L) && // case 1
+        (v <= L[0] || // case 2
+        v <= L[1] || // case 3
+        L[1] === 0))
+          return Bt(), w && A() && S().onDiscarded(i), !1;
+        const M = V().data;
+        x.data = s(M, T) ? M : T, w && A() && S().onSuccess(T, i, n);
+      } catch (L) {
+        $t();
+        const M = S(), { shouldRetryOnError: mt } = M;
+        M.isPaused() || (x.error = L, w && A() && (M.onError(L, i, M), (mt === !0 || N(mt) && mt(L)) && (!S().revalidateOnFocus || !S().revalidateOnReconnect || H()) && M.onErrorRetry(L, i, M, (Se) => {
+          const ht = a[i];
+          ht && ht[0] && ht[0](Jt, Se);
+        }, {
+          retryCount: (Y.retryCount || 0) + 1,
+          dedupe: !0
+        })));
+      }
+      return C = !1, Bt(), !0;
+    },
+    // `setState` is immutable, and `eventsCallback`, `fnArg`, and
+    // `keyValidating` are depending on `key`, so we can exclude them from
+    // the deps array.
+    //
+    // FIXME:
+    // `fn` and `config` might be changed during the lifecycle,
+    // but they might be changed every render like this.
+    // `useSWR('key', () => fetch('/api/'), { suspense: true })`
+    // So we omit the values from the deps array
+    // even though it might cause unexpected behaviors.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      i,
+      r
+    ]
+  ), Wt = lt(
+    // Use callback to make sure `keyRef.current` returns latest result every time
+    (..._) => ae(r, R.current, ..._),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  if (vt(() => {
+    F.current = e, b.current = n, d(J) || (pt.current = J);
+  }), vt(() => {
+    if (!i) return;
+    const _ = Z.bind(D, gt);
+    let h = 0;
+    S().revalidateOnFocus && (h = Date.now() + S().focusThrottleInterval);
+    const v = en(i, a, (C, Y = {}) => {
+      if (C == ne) {
+        const w = Date.now();
+        S().revalidateOnFocus && w > h && H() && (h = w + S().focusThrottleInterval, _());
+      } else if (C == re)
+        S().revalidateOnReconnect && H() && _();
+      else {
+        if (C == oe)
+          return Z();
+        if (C == Jt)
+          return Z(Y);
+      }
+    });
+    return U.current = !1, R.current = i, X.current = !0, k({
+      _k: j
+    }), Ut && (f[i] || (d($) || tt ? _() : Me(_))), () => {
+      U.current = !0, v();
+    };
+  }, [
+    i
+  ]), vt(() => {
+    let _;
+    function h() {
+      const v = N(g) ? g(V().data) : g;
+      v && _ !== -1 && (_ = setTimeout(T, v));
+    }
+    function T() {
+      !V().error && (O || S().isVisible()) && (l || S().isOnline()) ? Z(gt).then(h) : h();
+    }
+    return h(), () => {
+      _ && (clearTimeout(_), _ = -1);
+    };
+  }, [
+    g,
+    O,
+    l,
+    i
+  ]), Re(it), c && d($) && i) {
+    if (!zt && tt)
+      throw new Error("Fallback data is required when using Suspense in SSR.");
+    F.current = e, b.current = n, U.current = !1;
+    const _ = I[i];
+    if (!d(_)) {
+      const h = Wt(_);
+      Tt(h);
+    }
+    if (d(st)) {
+      const h = Z(gt);
+      d(it) || (h.status = "fulfilled", h.value = !0), Tt(h);
+    } else
+      throw st;
+  }
+  return {
+    mutate: Wt,
+    get data() {
+      return y.data = !0, it;
+    },
+    get error() {
+      return y.error = !0, st;
+    },
+    get isValidating() {
+      return y.isValidating = !0, he;
+    },
+    get isLoading() {
+      return y.isLoading = !0, _e;
+    }
+  };
+}, rn = tn(nn), xt = "https://api.figma.com", on = `${xt}/v1/files`, le = `${xt}/v1/variables`, fe = le, de = (t) => `${le}/${t}`, sn = (t) => `${on}/${t}/variables/local`, an = "application/json", Ee = "X-FIGMA-TOKEN", z = "A Figma API token is required.", cn = "An error occurred while fetching data from the Figma API.";
+async function un(t, e) {
+  if (!e)
+    throw new Error(z);
+  const n = await fetch(t, {
+    method: "GET",
+    headers: {
+      [Ee]: e,
+      "Content-Type": an
+    }
+  });
+  if (!n.ok) {
+    let r = cn;
+    try {
+      const s = await n.json();
+      s != null && s.message && (r = s.message);
+    } catch {
+    }
+    throw new Error(r);
+  }
+  return n.json();
+}
+const pe = () => {
+  const { token: t, fileKey: e } = nt(), n = e ? sn(e) : null, { data: r, error: s, isLoading: c, isValidating: o, mutate: u } = rn(
+    t && n ? [n, t] : null,
+    un
+  );
+  return {
+    data: r,
+    isLoading: c,
+    isValidating: o,
+    error: s,
+    mutate: u
+  };
+}, mn = () => {
+  const { data: t } = pe(), e = ft(
+    () => t != null && t.meta ? Object.values(t.meta.variableCollections) : [],
+    [t]
+  ), n = ft(
+    () => t != null && t.meta ? t.meta.variableCollections : {},
+    [t]
+  );
+  return {
+    collections: e,
+    collectionsById: n
+  };
+}, hn = () => {
+  const { data: t } = pe();
+  return ft(() => {
+    const e = [], n = {}, r = {};
+    if (t != null && t.meta)
+      for (const s of Object.values(
+        t.meta.variableCollections
+      )) {
+        e.push(...s.modes), n[s.id] = s.modes;
+        for (const c of s.modes)
+          r[c.modeId] = c;
+      }
+    return {
+      modes: e,
+      modesByCollectionId: n,
+      modesById: r
+    };
+  }, [t]);
+};
+function ln(t, e) {
+  switch (e.type) {
+    case "loading":
+      return { ...t, status: "loading", error: null };
+    case "success":
+      return { ...t, status: "success", data: e.payload };
+    case "error":
+      return { ...t, status: "error", error: e.payload };
+    default:
+      return t;
+  }
+}
+const dt = (t) => {
+  const e = {
+    status: "idle",
+    data: null,
+    error: null
+  }, [n, r] = Te(ln, e);
+  return {
+    mutate: lt(
+      async (c) => {
+        r({ type: "loading" });
+        try {
+          const o = await t(c);
+          return r({ type: "success", payload: o }), o;
+        } catch (o) {
+          r({ type: "error", payload: o });
+          return;
+        }
+      },
+      [t]
+    ),
+    ...n,
+    isLoading: n.status === "loading",
+    isSuccess: n.status === "success",
+    isError: n.status === "error"
+  };
+};
+async function Et(t, e, n, r) {
+  if (!e)
+    throw new Error(z);
+  const c = {
+    CREATE: "POST",
+    UPDATE: "PUT",
+    DELETE: "DELETE"
+  }[n], o = await fetch(`${xt}${t}`, {
+    method: c,
+    headers: {
+      "Content-Type": "application/json",
+      [Ee]: e
+    },
+    body: r ? JSON.stringify(r) : void 0
+  });
+  if (!o.ok) {
+    const u = await o.json().catch(() => ({}));
+    throw new Error(
+      u.err || u.message || "An API error occurred"
+    );
+  }
+  return o.status === 204 || !o.body ? {} : o.json();
+}
+const _n = () => {
+  const { token: t } = nt();
+  return dt(async (n) => {
+    if (!t)
+      throw new Error(z);
+    return await Et(
+      fe,
+      t,
+      "CREATE",
+      n
+    );
+  });
+}, Sn = () => {
+  const { token: t } = nt();
+  return dt(
+    async ({ variableId: n, payload: r }) => {
+      if (!t)
+        throw new Error(z);
+      const s = de(n);
+      return await Et(
+        s,
+        t,
+        "UPDATE",
+        r
+      );
+    }
+  );
+}, On = () => {
+  const { token: t } = nt();
+  return dt(async (n) => {
+    if (!t)
+      throw new Error(z);
+    return await Et(
+      de(n),
+      t,
+      "DELETE",
+      void 0
+    );
+  });
+}, vn = () => {
+  const { token: t } = nt();
+  return dt(async (n) => {
+    if (!t)
+      throw new Error(z);
+    return await Et(
+      fe,
+      t,
+      "CREATE",
+      n
+    );
+  });
+};
+function wn(t, e) {
+  return t.filter((n) => {
+    let r = !0;
+    return e.resolvedType && (r = r && n.resolvedType === e.resolvedType), e.name && (r = r && n.name.includes(e.name)), r;
+  });
+}
+export {
+  pn as FigmaVarsProvider,
+  wn as filterVariables,
+  vn as useBulkUpdateVariables,
+  _n as useCreateVariable,
+  On as useDeleteVariable,
+  Sn as useUpdateVariable,
+  mn as useVariableCollections,
+  hn as useVariableModes,
+  pe as useVariables
+};