jotai/umd/urql.development.js

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@urql/core'), require('jotai'), require('wonka')) :
  typeof define === 'function' && define.amd ? define(['exports', '@urql/core', 'jotai', 'wonka'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jotaiUrql = {}, global.core, global.jotai, global.wonka));
})(this, (function (exports, core, jotai, wonka) { 'use strict';

  var DEFAULT_URL = function () {
    try {
      return process.env.JOTAI_URQL_DEFAULT_URL;
    } catch (_unused) {
      return undefined;
    }
  }() || '/graphql';

  var clientAtom = jotai.atom(core.createClient({
    url: DEFAULT_URL
  }));

  function _extends() {
    _extends = Object.assign ? Object.assign.bind() : function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];

        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }

      return target;
    };
    return _extends.apply(this, arguments);
  }

  var isOperationResultWithData$1 = function isOperationResultWithData(result) {
    return 'data' in result && !result.error;
  };

  function atomWithQuery(createQueryArgs, getClient) {
    if (getClient === void 0) {
      getClient = function getClient(get) {
        return get(clientAtom);
      };
    }

    var queryResultAtom = jotai.atom(function (get) {
      var args = createQueryArgs(get);

      if (args.pause) {
        return null;
      }

      var client = getClient(get);
      var resolve = null;
      var baseResultAtom = jotai.atom(new Promise(function (r) {
        resolve = r;
      }));

      var setResult = function setResult() {
        throw new Error('setting result without mount');
      };

      var listener = function listener(result) {
        if (result instanceof Promise) {
          setResult(result);
          return;
        }

        if (!isOperationResultWithData$1(result)) {
          throw new Error('result does not have data');
        }

        if (resolve) {
          resolve(result);
          resolve = null;
        } else {
          setResult(result);
        }
      };

      client.query(args.query, args.variables, _extends({}, args.requestPolicy && {
        requestPolicy: args.requestPolicy
      }, args.context)).toPromise().then(listener).catch(function () {});

      baseResultAtom.onMount = function (update) {
        setResult = update;
      };

      var subscriptionAtom = jotai.atom(null);
      var resultAtom = jotai.atom(function (get) {
        return get(baseResultAtom);
      }, function (get, set, callback) {
        var subscription = wonka.pipe(client.query(args.query, args.variables, _extends({}, args.requestPolicy && {
          requestPolicy: args.requestPolicy
        }, args.context)), wonka.subscribe(listener));
        set(subscriptionAtom, subscription);
        callback(function () {
          var _get;

          return (_get = get(subscriptionAtom)) == null ? void 0 : _get.unsubscribe();
        });
      });

      resultAtom.onMount = function (init) {
        var cleanup;
        init(function (c) {
          cleanup = c;
        });
        return cleanup;
      };

      return {
        args: args,
        client: client,
        resultAtom: resultAtom,
        subscriptionAtom: subscriptionAtom,
        listener: listener
      };
    });
    var queryAtom = jotai.atom(function (get) {
      var queryResult = get(queryResultAtom);

      if (!queryResult) {
        return null;
      }

      var resultAtom = queryResult.resultAtom;
      return get(resultAtom);
    }, function (get, set, action) {
      switch (action.type) {
        case 'reexecute':
          {
            var queryResult = get(queryResultAtom);

            if (!queryResult) {
              throw new Error('query is paused');
            }

            var args = queryResult.args,
                client = queryResult.client,
                subscriptionAtom = queryResult.subscriptionAtom,
                listener = queryResult.listener;
            listener(new Promise(function () {}));
            var newSubscription = wonka.pipe(client.query(args.query, args.variables, _extends({}, args.requestPolicy && {
              requestPolicy: args.requestPolicy
            }, args.context, action.opts)), wonka.subscribe(listener));
            var oldSubscription = get(subscriptionAtom);
            oldSubscription == null ? void 0 : oldSubscription.unsubscribe();
            set(subscriptionAtom, newSubscription);
          }
      }
    });
    return queryAtom;
  }

  function atomWithMutation(createQuery, getClient) {
    if (getClient === void 0) {
      getClient = function getClient(get) {
        return get(clientAtom);
      };
    }

    var operationResultAtom = jotai.atom(new Promise(function () {}));
    var queryResultAtom = jotai.atom(function (get) {
      return get(operationResultAtom);
    }, function (get, set, action) {
      set(operationResultAtom, new Promise(function () {}));
      var client = getClient(get);
      var query = createQuery(get);
      client.mutation(query, action.variables, action.context).toPromise().then(function (result) {
        set(operationResultAtom, result);
        action.callback == null ? void 0 : action.callback(result);
      }).catch(function () {});
    });
    return queryResultAtom;
  }

  var isOperationResultWithData = function isOperationResultWithData(result) {
    return 'data' in result;
  };

  function atomWithSubscription(createSubscriptionArgs, getClient) {
    if (getClient === void 0) {
      getClient = function getClient(get) {
        return get(clientAtom);
      };
    }

    var queryResultAtom = jotai.atom(function (get) {
      var args = createSubscriptionArgs(get);

      if (args.pause) {
        return {
          args: args
        };
      }

      var client = getClient(get);
      var resolve = null;
      var resultAtom = jotai.atom(new Promise(function (r) {
        resolve = r;
      }));

      var setResult = function setResult() {
        throw new Error('setting result without mount');
      };

      var isMounted = false;

      var listener = function listener(result) {
        if (!isOperationResultWithData(result)) {
          throw new Error('result does not have data');
        }

        if (resolve) {
          if (!isMounted) {
            var _subscription;

            (_subscription = subscription) == null ? void 0 : _subscription.unsubscribe();
            subscription = null;
          }

          resolve(result);
          resolve = null;
        } else {
          setResult(result);
        }
      };

      var subscription = wonka.pipe(client.subscription(args.query, args.variables, args.context), wonka.subscribe(listener));

      resultAtom.onMount = function (update) {
        setResult = update;
        isMounted = true;

        if (!subscription) {
          subscription = wonka.pipe(client.subscription(args.query, args.variables, args.context), wonka.subscribe(listener));
        }

        return function () {
          var _subscription2;

          return (_subscription2 = subscription) == null ? void 0 : _subscription2.unsubscribe();
        };
      };

      return {
        resultAtom: resultAtom,
        args: args
      };
    });
    var queryAtom = jotai.atom(function (get) {
      var _get = get(queryResultAtom),
          resultAtom = _get.resultAtom;

      return resultAtom ? get(resultAtom) : null;
    });
    return queryAtom;
  }

  exports.atomWithMutation = atomWithMutation;
  exports.atomWithQuery = atomWithQuery;
  exports.atomWithSubscription = atomWithSubscription;
  exports.clientAtom = clientAtom;

  Object.defineProperty(exports, '__esModule', { value: true });

}));