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 || 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;
  };

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

    var refAtom = jotai.atom(function () {
      return {};
    });

    var createResultAtom = function createResultAtom(ref, client, args, opts) {
      var resolve = null;
      var resultAtom = jotai.atom(new Promise(function (r) {
        resolve = r;
      }));
      ref.resultAtom = resultAtom;

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

      var listener = function listener(result) {
        if (resultAtom !== ref.resultAtom) {
          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, opts)).toPromise().then(listener).catch(function () {});

      resultAtom.onMount = function (update) {
        setResult = update;
        var subscription = wonka.pipe(client.query(args.query, args.variables, _extends({}, args.requestPolicy && {
          requestPolicy: args.requestPolicy
        }, args.context, opts)), wonka.skip(1), wonka.subscribe(listener));
        return function () {
          return subscription.unsubscribe();
        };
      };

      return resultAtom;
    };

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

      if (args.pause) {
        return null;
      }

      var client = getClient(get);
      var resultAtom = createResultAtom(get(refAtom), client, args);
      return {
        resultAtom: resultAtom,
        client: client,
        args: args
      };
    });
    var overwrittenResultAtom = jotai.atom(null);
    var queryAtom = jotai.atom(function (get) {
      var queryResult = get(queryResultAtom);

      if (!queryResult) {
        return null;
      }

      var resultAtom = queryResult.resultAtom;
      var overwrittenResult = get(overwrittenResultAtom);

      if (overwrittenResult && overwrittenResult.oldResultAtom === resultAtom) {
        resultAtom = overwrittenResult.newResultAtom;
      }

      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 resultAtom = queryResult.resultAtom,
                client = queryResult.client,
                args = queryResult.args;
            set(overwrittenResultAtom, {
              oldResultAtom: resultAtom,
              newResultAtom: createResultAtom(get(refAtom), client, args, action.opts)
            });
          }
      }
    });
    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 listener = function listener(result) {
        if (!isOperationResultWithData(result)) {
          throw new Error('result does not have data');
        }

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

      var subscriptionInRender = wonka.pipe(client.subscription(args.query, args.variables, args.context), wonka.subscribe(listener));
      var timer = setTimeout(function () {
        timer = null;
        subscriptionInRender.unsubscribe();
      }, 1000);

      resultAtom.onMount = function (update) {
        setResult = update;
        var subscription;

        if (timer) {
          clearTimeout(timer);
          subscription = subscriptionInRender;
        } else {
          subscription = wonka.pipe(client.subscription(args.query, args.variables, args.context), wonka.subscribe(listener));
        }

        return function () {
          return subscription.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 });

}));