@urql/core/dist/urql-core.js

"use strict";

function _ref2(a, b, c) {
  return c.indexOf(a) === b;
}

function _ref3(a) {
  return a.kind === graphql.Kind.FIELD && "__typename" === a.name.value;
}

function withPromise(a) {
  a.toPromise = function() {
    return wonka.toPromise(wonka.take(1)(a));
  };
  return a;
}

function makeOperation(a, b, c) {
  c || (c = b.context);
  return {
    key: b.key,
    query: b.query,
    variables: b.variables,
    kind: a,
    context: c,
    get operationName() {
      "production" !== process.env.NODE_ENV && deprecationWarning(DEPRECATED_operationName);
      return this.kind;
    }
  };
}

function _ref(a) {
  return a.path || a.extensions ? {
    message: a.message,
    path: a.path,
    extensions: a.extensions
  } : a.message;
}

function _ref$1(a) {
  var b = makeOperation(a.kind, a);
  b.query = formatDocument(a.query);
  return b;
}

function _ref5(a) {
  return "query" !== a.kind || "cache-only" !== a.context.requestPolicy;
}

function _ref6(a) {
  return addMetadata(a, {
    cacheOutcome: "miss"
  });
}

function _ref8(a) {
  return shouldSkip$1(a);
}

function _ref2$1(a) {
  return console.log("[Exchange debug]: Completed operation: ", a);
}

function _ref3$1(a) {
  return console.log("[Exchange debug]: Incoming operation: ", a);
}

function _ref$2(a) {
  return "query" === a.kind || "mutation" === a.kind;
}

function _ref2$2(a) {
  return "query" !== a.kind && "mutation" !== a.kind;
}

function _ref$3() {
  return !1;
}

function _ref2$3(a) {
  a.data = maskTypename(a.data);
  return a;
}

var fetchSource = require("./3fe74c44.js"), wonka = require("wonka"), graphql = require("graphql"), collectTypes = function(a, b) {
  void 0 === b && (b = []);
  if (Array.isArray(a)) {
    a.forEach((function c(a) {
      collectTypes(a, b);
    }));
  } else if ("object" == typeof a && null !== a) {
    for (var d in a) {
      "__typename" === d && "string" == typeof a[d] ? b.push(a[d]) : collectTypes(a[d], b);
    }
  }
  return b;
}, collectTypesFromResponse = function(a) {
  return collectTypes(a).filter(_ref2);
}, formatNode = function(a) {
  if (a.selectionSet && !a.selectionSet.selections.some(_ref3)) {
    return fetchSource._extends({}, a, {
      selectionSet: fetchSource._extends({}, a.selectionSet, {
        selections: a.selectionSet.selections.concat([ {
          kind: graphql.Kind.FIELD,
          name: {
            kind: graphql.Kind.NAME,
            value: "__typename"
          }
        } ])
      })
    });
  }
}, formatDocument = function(a) {
  var b = graphql.visit(a, {
    Field: formatNode,
    InlineFragment: formatNode
  });
  b.__key = a.__key;
  return b;
}, maskTypename = function(a) {
  return a && "object" == typeof a ? Object.keys(a).reduce((function(b, c) {
    var d = a[c];
    "__typename" === c ? Object.defineProperty(b, "__typename", {
      enumerable: !1,
      value: d
    }) : Array.isArray(d) ? b[c] = d.map(maskTypename) : b[c] = d && "object" == typeof d && "__typename" in d ? maskTypename(d) : d;
    return b;
  }), {}) : a;
}, issuedWarnings = {}, deprecationWarning = function(a) {
  var b = a.key;
  a = a.message;
  issuedWarnings[b] || (console.warn("[WARNING: Deprecated] " + a), issuedWarnings[b] = !0);
}, DEPRECATED_operationName = {
  key: "Operation.operationName",
  message: 'The "Operation.operationName" property has been deprecated and will be removed in a future release of urql. Use "Operation.kind" instead.'
}, addMetadata = function(a, b) {
  return makeOperation(a.kind, a, fetchSource._extends({}, a.context, {
    meta: fetchSource._extends({}, a.context.meta, b)
  }));
}, noop = function() {}, shouldSkip = function(a) {
  return "subscription" !== (a = a.kind) && "query" !== a;
}, serializeResult = function(a) {
  var b = a.error;
  a = {
    data: JSON.stringify(a.data),
    error: void 0
  };
  b && (a.error = {
    graphQLErrors: b.graphQLErrors.map(_ref),
    networkError: b.networkError ? "" + b.networkError : void 0
  });
  return a;
}, deserializeResult = function(a, b) {
  var c = b.error;
  return {
    operation: a,
    data: (b = b.data) ? JSON.parse(b) : void 0,
    extensions: void 0,
    error: c ? new fetchSource.CombinedError({
      networkError: c.networkError ? Error(c.networkError) : void 0,
      graphQLErrors: c.graphQLErrors && c.graphQLErrors.length ? c.graphQLErrors : void 0
    }) : void 0
  };
}, ssrExchange = function(a) {
  function b() {
    for (var a; a = g.shift(); ) {
      delete h[a];
    }
  }
  function c(a) {
    return !m(a);
  }
  function d(a) {
    return deserializeResult(a, h[a.key]);
  }
  function f(a) {
    return m(a);
  }
  function k(a) {
    var b = a.operation;
    shouldSkip(b) || (a = serializeResult(a), h[b.key] = a);
  }
  var h = {}, g = [], e = function(a) {
    g.push(a.operation.key);
    1 === g.length && Promise.resolve().then(b);
  }, m = function(a) {
    return !shouldSkip(a) && void 0 !== h[a.key];
  }, l = function(b) {
    var h = b.client, q = b.forward;
    return function(b) {
      var l = a && "boolean" == typeof a.isClient ? !!a.isClient : !h.suspense, g = wonka.share(b);
      b = q(wonka.filter(c)(g));
      g = wonka.map(d)(wonka.filter(f)(g));
      l ? g = wonka.tap(e)(g) : b = wonka.tap(k)(b);
      return wonka.merge([ b, g ]);
    };
  };
  l.restoreData = function(a) {
    return fetchSource._extends(h, a);
  };
  l.extractData = function() {
    return fetchSource._extends({}, h);
  };
  a && a.initialState && l.restoreData(a.initialState);
  return l;
}, shouldSkip$1 = function(a) {
  return "mutation" !== (a = a.kind) && "query" !== a;
}, cacheExchange = function(a) {
  function b(a) {
    var b = e.get(a.key);
    "production" !== process.env.NODE_ENV && g(fetchSource._extends({}, {
      operation: a
    }, b ? {
      type: "cacheHit",
      message: "The result was successfully retried from the cache"
    } : {
      type: "cacheMiss",
      message: "The result could not be retrieved from the cache"
    }));
    b = fetchSource._extends({}, b, {
      operation: addMetadata(a, {
        cacheOutcome: b ? "hit" : "miss"
      })
    });
    "cache-and-network" === a.context.requestPolicy && (b.stale = !0, reexecuteOperation(h, a));
    return b;
  }
  function c(a) {
    return !shouldSkip$1(a) && n(a);
  }
  function d(a) {
    a.operation && "mutation" === a.operation.kind ? l(a) : a.operation && "query" === a.operation.kind && p(a);
  }
  function f(a) {
    return !shouldSkip$1(a) && !n(a);
  }
  var m, l, p, n, k = a.forward, h = a.client, g = a.dispatchDebug, e = new Map;
  a = Object.create(null);
  m = _ref$1, l = afterMutation(e, a, h, g), p = afterQuery(e, a), n = function(a) {
    var c = a.context.requestPolicy;
    return "query" === a.kind && "network-only" !== c && ("cache-only" === c || e.has(a.key));
  };
  return function(a) {
    var e = wonka.share(a);
    a = wonka.map(b)(wonka.filter(c)(e));
    e = wonka.tap(d)(k(wonka.filter(_ref5)(wonka.map(_ref6)(wonka.merge([ wonka.map(m)(wonka.filter(f)(e)), wonka.filter(_ref8)(e) ])))));
    return wonka.merge([ a, e ]);
  };
}, reexecuteOperation = function(a, b) {
  return a.reexecuteOperation(makeOperation(b.kind, b, fetchSource._extends({}, b.context, {
    requestPolicy: "network-only"
  })));
}, afterMutation = function(a, b, c, d) {
  function f(b) {
    if (a.has(b)) {
      var d = a.get(b).operation;
      a.delete(b);
      reexecuteOperation(c, d);
    }
  }
  return function(a) {
    function c(a) {
      g.add(a);
    }
    var g = new Set, e = a.operation.context.additionalTypenames;
    e = collectTypesFromResponse(a.data).concat(e || []);
    "production" !== process.env.NODE_ENV && d({
      type: "cacheInvalidation",
      message: "The following typenames have been invalidated: " + e,
      operation: a.operation,
      data: {
        typenames: e,
        response: a
      },
      source: "cacheExchange"
    });
    e.forEach((function(a) {
      (a = b[a] || (b[a] = new Set)).forEach(c);
      a.clear();
    }));
    g.forEach(f);
  };
}, afterQuery = function(a, b) {
  return function(c) {
    var d = c.operation, f = c.data, k = d.context.additionalTypenames;
    null != f && (a.set(d.key, {
      operation: d,
      data: f,
      error: c.error
    }), collectTypesFromResponse(c.data).concat(k || []).forEach((function(a) {
      (b[a] || (b[a] = new Set)).add(d.key);
    })));
  };
}, subscriptionExchange = function(a) {
  function b(a) {
    return "subscription" === (a = a.kind) || !!d && ("query" === a || "mutation" === a);
  }
  var c = a.forwardSubscription, d = a.enableAllOperations;
  return function(a) {
    function d(a) {
      return !m(a);
    }
    var f = a.client, g = a.forward, e = function(a) {
      var b = c({
        key: a.key.toString(36),
        query: graphql.print(a.query),
        variables: a.variables,
        context: fetchSource._extends({}, a.context)
      });
      return wonka.make((function(c) {
        function d(b) {
          return g(fetchSource.makeResult(a, b));
        }
        function e(b) {
          return g(fetchSource.makeErrorResult(a, b));
        }
        function h() {
          k || (k = !0, "subscription" === a.kind && f.reexecuteOperation(makeOperation("teardown", a, a.context)), 
          m());
        }
        var l, g = c.next, m = c.complete, k = !1;
        Promise.resolve().then((function() {
          k || (l = b.subscribe({
            next: d,
            error: e,
            complete: h
          }));
        }));
        return function() {
          k = !0;
          l && l.unsubscribe();
        };
      }));
    }, m = b;
    return function(a) {
      var c, b = wonka.share(a);
      a = wonka.mergeMap((function(a) {
        var c = a.key, d = wonka.filter((function(a) {
          return "teardown" === a.kind && a.key === c;
        }))(b);
        return wonka.takeUntil(d)(e(a));
      }))(wonka.filter(m)(b));
      c = g(wonka.filter(d)(b));
      return wonka.merge([ a, c ]);
    };
  };
}, debugExchange = function(a) {
  var d = a.forward;
  return "production" === process.env.NODE_ENV ? function b(a) {
    return d(a);
  } : function c(a) {
    return wonka.tap(_ref2$1)(d(wonka.tap(_ref3$1)(a)));
  };
}, dedupExchange = function(a) {
  var b = a.forward, c = a.dispatchDebug, d = new Set, f = function(a) {
    var b = a.key, e = a.kind;
    if ("teardown" === e) {
      return d.delete(b), !0;
    }
    if ("query" !== e && "subscription" !== e) {
      return !0;
    }
    e = d.has(b);
    d.add(b);
    e && "production" !== process.env.NODE_ENV && c({
      type: "dedup",
      message: "An operation has been deduped.",
      operation: a,
      source: "dedupExchange"
    });
    return !e;
  }, k = function(a) {
    d.delete(a.operation.key);
  };
  return function(a) {
    a = wonka.filter(f)(a);
    return wonka.tap(k)(b(a));
  };
}, fetchExchange = function(a) {
  var b = a.forward, c = a.dispatchDebug;
  return function(a) {
    var k, d = wonka.share(a);
    a = wonka.mergeMap((function(a) {
      var b = a.key, e = wonka.filter((function(a) {
        return "teardown" === a.kind && a.key === b;
      }))(d), f = fetchSource.makeFetchBody(a), k = fetchSource.makeFetchURL(a, f), h = fetchSource.makeFetchOptions(a, f);
      "production" !== process.env.NODE_ENV && c({
        type: "fetchRequest",
        message: "A fetch request is being executed.",
        operation: a,
        data: {
          url: k,
          fetchOptions: h
        },
        source: "fetchExchange"
      });
      return wonka.onPush((function(b) {
        var d = b.data ? void 0 : b.error;
        "production" !== process.env.NODE_ENV && c({
          type: d ? "fetchError" : "fetchSuccess",
          message: "A " + (d ? "failed" : "successful") + " fetch response has been returned.",
          operation: a,
          data: {
            url: k,
            fetchOptions: h,
            value: d || b
          },
          source: "fetchExchange"
        });
      }))(wonka.takeUntil(e)(fetchSource.makeFetchSource(a, k, h)));
    }))(wonka.filter(_ref$2)(d));
    k = b(wonka.filter(_ref2$2)(d));
    return wonka.merge([ a, k ]);
  };
}, fallbackExchange = function(a) {
  function b(a) {
    if ("teardown" !== a.kind && "production" !== process.env.NODE_ENV) {
      var b = 'No exchange has handled operations of kind "' + a.kind + "\". Check whether you've added an exchange responsible for these operations.";
      "production" !== process.env.NODE_ENV && c({
        type: "fallbackCatch",
        message: b,
        operation: a,
        source: "fallbackExchange"
      });
      console.warn(b);
    }
  }
  var c = a.dispatchDebug;
  return function(a) {
    return wonka.filter(_ref$3)(wonka.tap(b)(a));
  };
}, fallbackExchangeIO = fallbackExchange({
  dispatchDebug: noop
}), composeExchanges = function(a) {
  return function(b) {
    var c = b.client, d = b.dispatchDebug;
    return a.reduceRight((function(a, b) {
      return b({
        client: c,
        forward: a,
        dispatchDebug: function(a) {
          "production" !== process.env.NODE_ENV && d(fetchSource._extends({}, {
            timestamp: Date.now(),
            source: b.name
          }, a));
        }
      });
    }), b.forward);
  };
}, errorExchange = function(a) {
  function b(a) {
    var b = a.error;
    a = a.operation;
    b && c(b, a);
  }
  var c = a.onError;
  return function(a) {
    var c = a.forward;
    return function(a) {
      return wonka.tap(b)(c(a));
    };
  };
}, defaultExchanges = [ dedupExchange, cacheExchange, fetchExchange ], createClient = function(a) {
  return new Client(a);
}, Client = function(a) {
  var d, f, k, h, g, c = this;
  this.activeOperations = Object.create(null);
  this.queue = [];
  this.createOperationContext = function(a) {
    a || (a = {});
    return fetchSource._extends({}, {
      url: c.url,
      fetchOptions: c.fetchOptions,
      fetch: c.fetch,
      preferGetMethod: c.preferGetMethod
    }, a, {
      suspense: a.suspense || !1 !== a.suspense && c.suspense,
      requestPolicy: a.requestPolicy || c.requestPolicy
    });
  };
  this.createRequestOperation = function(a, b, d) {
    return makeOperation(a, b, c.createOperationContext(d));
  };
  this.executeQuery = function(a, b) {
    a = c.createRequestOperation("query", a, b);
    return c.executeRequestOperation(a);
  };
  this.executeSubscription = function(a, b) {
    a = c.createRequestOperation("subscription", a, b);
    return c.executeRequestOperation(a);
  };
  this.executeMutation = function(a, b) {
    a = c.createRequestOperation("mutation", a, b);
    return c.executeRequestOperation(a);
  };
  if ("production" !== process.env.NODE_ENV && !a.url) {
    throw Error("You are creating an urql-client without a url.");
  }
  d = noop;
  if ("production" !== process.env.NODE_ENV) {
    f = (d = wonka.makeSubject()).next, k = d.source;
    this.subscribeToDebugTarget = function b(a) {
      return wonka.subscribe(a)(k);
    };
    d = f;
  }
  this.url = a.url;
  this.fetchOptions = a.fetchOptions;
  this.fetch = a.fetch;
  this.suspense = !!a.suspense;
  this.requestPolicy = a.requestPolicy || "cache-first";
  this.preferGetMethod = !!a.preferGetMethod;
  this.maskTypename = !!a.maskTypename;
  f = wonka.makeSubject();
  h = f.next;
  this.operations$ = f.source;
  g = !1;
  this.dispatchOperation = function(a) {
    g = !0;
    for (a && h(a); a = c.queue.shift(); ) {
      h(a);
    }
    g = !1;
  };
  this.reexecuteOperation = function(a) {
    if ("mutation" === a.kind || 0 < (c.activeOperations[a.key] || 0)) {
      c.queue.push(a), g || Promise.resolve().then(c.dispatchOperation);
    }
  };
  a = composeExchanges(void 0 !== a.exchanges ? a.exchanges : defaultExchanges);
  this.results$ = wonka.share(a({
    client: this,
    dispatchDebug: d,
    forward: fallbackExchange({
      dispatchDebug: d
    })
  })(this.operations$));
  wonka.publish(this.results$);
};

Client.prototype.onOperationStart = function(a) {
  var b = a.key;
  this.activeOperations[b] = (this.activeOperations[b] || 0) + 1;
  this.dispatchOperation(a);
};

Client.prototype.onOperationEnd = function(a) {
  var b = a.key, c = this.activeOperations[b] || 0;
  if (0 >= (this.activeOperations[b] = 0 >= c ? 0 : c - 1)) {
    for (b = this.queue.length - 1; 0 <= b; b--) {
      this.queue[b].key === a.key && this.queue.splice(b, 1);
    }
    this.dispatchOperation(makeOperation("teardown", a, a.context));
  }
};

Client.prototype.executeRequestOperation = function(a) {
  var k, h, d = this, f = wonka.filter((function(b) {
    return b.operation.key === a.key;
  }))(this.results$);
  this.maskTypename && (f = wonka.map(_ref2$3)(f));
  if ("mutation" === a.kind) {
    return wonka.take(1)(wonka.onStart((function b() {
      return d.dispatchOperation(a);
    }))(f));
  }
  k = wonka.filter((function(b) {
    return "teardown" === b.kind && b.key === a.key;
  }))(this.operations$), h = wonka.onEnd((function() {
    d.onOperationEnd(a);
  }))(wonka.onStart((function() {
    d.onOperationStart(a);
  }))(wonka.takeUntil(k)(f)));
  return "query" === a.kind && a.context.pollInterval ? wonka.switchMap((function c() {
    return h;
  }))(wonka.merge([ wonka.fromValue(0), wonka.interval(a.context.pollInterval) ])) : h;
};

Client.prototype.query = function(a, b, c) {
  c && "boolean" == typeof c.suspense || (c = fetchSource._extends({}, c, {
    suspense: !1
  }));
  return withPromise(this.executeQuery(fetchSource.createRequest(a, b), c));
};

Client.prototype.readQuery = function(a, b, c) {
  var d = null;
  wonka.subscribe((function(a) {
    d = a;
  }))(this.executeQuery(fetchSource.createRequest(a, b), c)).unsubscribe();
  return d;
};

Client.prototype.subscription = function(a, b, c) {
  return this.executeSubscription(fetchSource.createRequest(a, b), c);
};

Client.prototype.mutation = function(a, b, c) {
  return withPromise(this.executeMutation(fetchSource.createRequest(a, b), c));
};

exports.CombinedError = fetchSource.CombinedError;

exports.createRequest = fetchSource.createRequest;

exports.makeErrorResult = fetchSource.makeErrorResult;

exports.makeResult = fetchSource.makeResult;

exports.stringifyVariables = fetchSource.stringifyVariables;

exports.Client = Client;

exports.cacheExchange = cacheExchange;

exports.composeExchanges = composeExchanges;

exports.createClient = createClient;

exports.debugExchange = debugExchange;

exports.dedupExchange = dedupExchange;

exports.defaultExchanges = defaultExchanges;

exports.errorExchange = errorExchange;

exports.fallbackExchangeIO = fallbackExchangeIO;

exports.fetchExchange = fetchExchange;

exports.formatDocument = formatDocument;

exports.makeOperation = makeOperation;

exports.maskTypename = maskTypename;

exports.ssrExchange = ssrExchange;

exports.subscriptionExchange = subscriptionExchange;
//# sourceMappingURL=urql-core.js.map