@urql/vue/dist/urql-vue.mjs

A highly customizable and versatile GraphQL client for vue

import { Client as e, createRequest as r } from "@urql/core";

export * from "@urql/core";

import { isRef as t, shallowRef as u, getCurrentInstance as a, provide as n, inject as o, ref as s, computed as l, watchEffect as i, isReadonly as v, onBeforeUnmount as c, onMounted as f } from "vue";

import { subscribe as p, onEnd as h, toPromise as d, take as y, filter as x, onPush as b } from "wonka";

var w = new WeakMap;

function provideClient(r) {
  var o;
  if (!t(r)) {
    o = u(r instanceof e ? r : new e(r));
  } else {
    o = r;
  }
  var s = a();
  if (s) {
    w.set(s, o);
  }
  n("$urql", o);
  return o.value;
}

function install(r, a) {
  var n;
  if (!t(a)) {
    n = u(a instanceof e ? a : new e(a));
  } else {
    n = a;
  }
  r.provide("$urql", n);
}

function useClient() {
  var e = a();
  if ("production" !== process.env.NODE_ENV && !e) {
    throw new Error("use* functions may only be called during the `setup()` or other lifecycle hooks.");
  }
  var r = o("$urql");
  if (!r && e) {
    r = w.get(e);
  }
  if ("production" !== process.env.NODE_ENV && !r) {
    throw new Error("No urql Client was provided. Did you forget to install the plugin or call `provideClient` in a parent?");
  }
  return r;
}

var unwrap = e => "function" == typeof e ? e() : null != e && t(e) ? e.value : e;

var N = Array.isArray;

var unwrapDeeply = e => {
  if ("function" == typeof (e = t(e) ? e.value : e)) {
    return unwrapDeeply(e());
  }
  if (e && "object" == typeof e) {
    if (N(e)) {
      var r = e.length;
      var u = new Array(r);
      var a = 0;
      for (;a < r; a++) {
        u[a] = unwrapDeeply(e[a]);
      }
      return u;
    } else if ((e => {
      if ("object" != typeof e || null === e) {
        return !1;
      }
      return e.constructor && Object.getPrototypeOf(e).constructor === Object.prototype.constructor;
    })(e)) {
      var n = Object.keys(e);
      var o = n.length;
      var s = 0;
      var l;
      var i = {};
      for (;s < o; s++) {
        i[l = n[s]] = unwrapDeeply(e[l]);
      }
      return i;
    }
  }
  return e;
};

var createRequestWithArgs = e => r(unwrap(e.query), unwrapDeeply(e.variables));

var useRequestState = () => ({
  hasNext: s(!1),
  stale: s(!1),
  fetching: s(!1),
  error: u(),
  operation: u(),
  extensions: u()
});

function useClientState(e, r, a) {
  var n = u();
  var o = t(e.pause) ? e.pause : "function" == typeof e.pause ? l(e.pause) : s(!!e.pause);
  var c = l((() => createRequestWithArgs(e)));
  var f = l((() => "requestPolicy" in e ? {
    requestPolicy: unwrap(e.requestPolicy),
    ...unwrap(e.context)
  } : {
    ...unwrap(e.context)
  }));
  var executeRaw = e => r.value[a](c.value, {
    ...f.value,
    ...e
  });
  var p = i((() => {
    n.value = !o.value ? executeRaw() : void 0;
  }));
  return {
    source: n,
    isPaused: o,
    pause: () => {
      if (!v(o)) {
        o.value = !0;
      }
    },
    resume: () => {
      if (!v(o)) {
        o.value = !1;
      }
    },
    execute: e => {
      n.value = executeRaw(e);
    },
    teardown: p
  };
}

function useQuery(e) {
  return callUseQuery(e);
}

function callUseQuery(e, r = useClient(), t) {
  var a = u();
  var {fetching: n, operation: o, extensions: s, stale: l, error: v, hasNext: c} = useRequestState();
  var {isPaused: f, source: d, pause: y, resume: x, execute: b, teardown: w} = useClientState(e, r, "executeQuery");
  var N = i((e => {
    if (d.value) {
      n.value = !0;
      l.value = !1;
      e(p((e => {
        a.value = e.data;
        l.value = !!e.stale;
        n.value = !1;
        v.value = e.error;
        o.value = e.operation;
        s.value = e.extensions;
        c.value = e.hasNext;
      }))(h((() => {
        n.value = !1;
        l.value = !1;
        c.value = !1;
      }))(d.value)).unsubscribe);
    } else {
      n.value = !1;
      l.value = !1;
      c.value = !1;
    }
  }), {
    flush: "sync"
  });
  t && t.push(w, N);
  var then = (e, r) => {
    var t;
    return new Promise((e => {
      if (!d.value) {
        return e(g);
      }
      var r = !1;
      t = p((() => {
        if (!g.fetching.value && !g.stale.value) {
          if (t) {
            t.unsubscribe();
          }
          r = !0;
          e(g);
        }
      }))(d.value);
      if (r) {
        t.unsubscribe();
      }
    })).then(e, r);
  };
  var g = {
    data: a,
    stale: l,
    error: v,
    operation: o,
    extensions: s,
    fetching: n,
    isPaused: f,
    hasNext: c,
    pause: y,
    resume: x,
    executeQuery(e) {
      b(e);
      return {
        ...g,
        then
      };
    }
  };
  return {
    ...g,
    then
  };
}

function useMutation(e) {
  return callUseMutation(e);
}

function callUseMutation(e, r = useClient()) {
  var t = u();
  var {fetching: a, operation: n, extensions: o, stale: s, error: l, hasNext: i} = useRequestState();
  return {
    data: t,
    stale: s,
    fetching: a,
    error: l,
    operation: n,
    extensions: o,
    hasNext: i,
    executeMutation(u, v) {
      a.value = !0;
      return d(y(1)(x((e => !e.hasNext))(b((e => {
        t.value = e.data;
        s.value = e.stale;
        a.value = !1;
        l.value = e.error;
        n.value = e.operation;
        o.value = e.extensions;
        i.value = e.hasNext;
      }))(r.value.executeMutation(createRequestWithArgs({
        query: e,
        variables: u
      }), v || {})))));
    }
  };
}

function useSubscription(e, r) {
  return callUseSubscription(e, r);
}

function callUseSubscription(e, r, a = useClient(), n) {
  var o = u();
  var {fetching: s, operation: l, extensions: v, stale: c, error: f} = useRequestState();
  var {isPaused: d, source: y, pause: x, resume: b, execute: w, teardown: N} = useClientState(e, a, "executeSubscription");
  var g = i((e => {
    if (y.value) {
      s.value = !0;
      e(p((e => {
        s.value = !0;
        f.value = e.error;
        v.value = e.extensions;
        c.value = !!e.stale;
        l.value = e.operation;
        if (null != e.data && r) {
          var u = t(r) ? r.value : r;
          if ("function" == typeof u) {
            o.value = u(o.value, e.data);
            return;
          }
        }
        o.value = e.data;
      }))(h((() => {
        s.value = !1;
      }))(y.value)).unsubscribe);
    } else {
      s.value = !1;
    }
  }));
  n && n.push(N, g);
  var m = {
    data: o,
    stale: c,
    error: f,
    operation: l,
    extensions: v,
    fetching: s,
    isPaused: d,
    pause: x,
    resume: b,
    executeSubscription(e) {
      w(e);
      return m;
    }
  };
  return m;
}

function useClientHandle() {
  var e = useClient();
  var r = [];
  c((() => {
    var e;
    while (e = r.shift()) {
      e();
    }
  }));
  var t = {
    client: e.value,
    useQuery: t => callUseQuery(t, e, r),
    useSubscription: (t, u) => callUseSubscription(t, u, e, r),
    useMutation: r => callUseMutation(r, e)
  };
  if ("production" !== process.env.NODE_ENV) {
    f((() => {
      Object.assign(t, {
        useQuery(t) {
          if ("production" !== process.env.NODE_ENV && !a()) {
            throw new Error("`handle.useQuery()` should only be called in the `setup()` or a lifecycle hook.");
          }
          return callUseQuery(t, e, r);
        },
        useSubscription(t, u) {
          if ("production" !== process.env.NODE_ENV && !a()) {
            throw new Error("`handle.useSubscription()` should only be called in the `setup()` or a lifecycle hook.");
          }
          return callUseSubscription(t, u, e, r);
        }
      });
    }));
  }
  return t;
}

export { install as default, install, provideClient, useClientHandle, useMutation, useQuery, useSubscription };
//# sourceMappingURL=urql-vue.mjs.map