@sanity/client 4.0.1-1 → 5.0.0-esm.0

package/dist/index.browser.cjs

@@ -0,0 +1,1335 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+var getIt = require('get-it');
+var middleware = require('get-it/middleware');
+var rxjs = require('rxjs');
+var makeError = require('make-error');
+var operators = require('rxjs/operators');
+var polyfilledEventSource = require('@sanity/eventsource');
+function _interopDefaultCompat(e) {
+  return e && typeof e === 'object' && 'default' in e ? e : {
+    default: e
+  };
+}
+var polyfilledEventSource__default = /*#__PURE__*/_interopDefaultCompat(polyfilledEventSource);
+var envMiddleware = [];
+class ClientError extends makeError.BaseError {
+  constructor(res) {
+    const props = extractErrorProps(res);
+    super(props.message);
+    this.statusCode = 400;
+    Object.assign(this, props);
+  }
+}
+class ServerError extends makeError.BaseError {
+  constructor(res) {
+    const props = extractErrorProps(res);
+    super(props.message);
+    this.statusCode = 500;
+    Object.assign(this, props);
+  }
+}
+function extractErrorProps(res) {
+  const body = res.body;
+  const props = {
+    response: res,
+    statusCode: res.statusCode,
+    responseBody: stringifyBody(body, res),
+    message: "",
+    details: void 0
+  };
+  if (body.error && body.message) {
+    props.message = "".concat(body.error, " - ").concat(body.message);
+    return props;
+  }
+  if (body.error && body.error.description) {
+    props.message = body.error.description;
+    props.details = body.error;
+    return props;
+  }
+  props.message = body.error || body.message || httpErrorMessage(res);
+  return props;
+}
+function httpErrorMessage(res) {
+  const statusMessage = res.statusMessage ? " ".concat(res.statusMessage) : "";
+  return "".concat(res.method, "-request to ").concat(res.url, " resulted in HTTP ").concat(res.statusCode).concat(statusMessage);
+}
+function stringifyBody(body, res) {
+  const contentType = (res.headers["content-type"] || "").toLowerCase();
+  const isJson = contentType.indexOf("application/json") !== -1;
+  return isJson ? JSON.stringify(body, null, 2) : body;
+}
+const httpError = {
+  onResponse: res => {
+    if (res.statusCode >= 500) {
+      throw new ServerError(res);
+    } else if (res.statusCode >= 400) {
+      throw new ClientError(res);
+    }
+    return res;
+  }
+};
+const printWarnings = {
+  onResponse: res => {
+    const warn = res.headers["x-sanity-warning"];
+    const warnings = Array.isArray(warn) ? warn : [warn];
+    warnings.filter(Boolean).forEach(msg => console.warn(msg));
+    return res;
+  }
+};
+function defineHttpRequest(envMiddleware) {
+  const request = getIt.getIt([...envMiddleware, printWarnings, middleware.jsonRequest(), middleware.jsonResponse(), middleware.progress(), httpError, middleware.observable({
+    implementation: rxjs.Observable
+  })]);
+  function httpRequest(options) {
+    let requester = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : request;
+    return requester({
+      maxRedirects: 0,
+      ...options
+    });
+  }
+  httpRequest.defaultRequester = request;
+  return httpRequest;
+}
+const projectHeader = "X-Sanity-Project-ID";
+var getRequestOptions = function (config) {
+  let overrides = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const headers = {};
+  const token = overrides.token || config.token;
+  if (token) {
+    headers.Authorization = "Bearer ".concat(token);
+  }
+  if (!overrides.useGlobalApi && !config.useProjectHostname && config.projectId) {
+    headers[projectHeader] = config.projectId;
+  }
+  const withCredentials = Boolean(typeof overrides.withCredentials === "undefined" ? config.token || config.withCredentials : overrides.withCredentials);
+  const timeout = typeof overrides.timeout === "undefined" ? config.timeout : overrides.timeout;
+  return Object.assign({}, overrides, {
+    headers: Object.assign({}, headers, overrides.headers || {}),
+    timeout: typeof timeout === "undefined" ? 5 * 60 * 1e3 : timeout,
+    proxy: overrides.proxy || config.proxy,
+    json: true,
+    withCredentials
+  });
+};
+function getSelection(sel) {
+  if (typeof sel === "string" || Array.isArray(sel)) {
+    return {
+      id: sel
+    };
+  }
+  if (typeof sel === "object" && sel !== null && "query" in sel && typeof sel.query === "string") {
+    return "params" in sel && typeof sel.params === "object" && sel.params !== null ? {
+      query: sel.query,
+      params: sel.params
+    } : {
+      query: sel.query
+    };
+  }
+  const selectionOpts = ["* Document ID (<docId>)", "* Array of document IDs", "* Object containing `query`"].join("\n");
+  throw new Error("Unknown selection - must be one of:\n\n".concat(selectionOpts));
+}
+const VALID_ASSET_TYPES = ["image", "file"];
+const VALID_INSERT_LOCATIONS = ["before", "after", "replace"];
+const dataset = name => {
+  if (!/^(~[a-z0-9]{1}[-\w]{0,63}|[a-z0-9]{1}[-\w]{0,63})$/.test(name)) {
+    throw new Error("Datasets can only contain lowercase characters, numbers, underscores and dashes, and start with tilde, and be maximum 64 characters");
+  }
+};
+const projectId = id => {
+  if (!/^[-a-z0-9]+$/i.test(id)) {
+    throw new Error("`projectId` can only contain only a-z, 0-9 and dashes");
+  }
+};
+const validateAssetType = type => {
+  if (VALID_ASSET_TYPES.indexOf(type) === -1) {
+    throw new Error("Invalid asset type: ".concat(type, ". Must be one of ").concat(VALID_ASSET_TYPES.join(", ")));
+  }
+};
+const validateObject = (op, val) => {
+  if (val === null || typeof val !== "object" || Array.isArray(val)) {
+    throw new Error("".concat(op, "() takes an object of properties"));
+  }
+};
+const validateDocumentId = (op, id) => {
+  if (typeof id !== "string" || !/^[a-z0-9_.-]+$/i.test(id)) {
+    throw new Error("".concat(op, "(): \"").concat(id, "\" is not a valid document ID"));
+  }
+};
+const requireDocumentId = (op, doc) => {
+  if (!doc._id) {
+    throw new Error("".concat(op, "() requires that the document contains an ID (\"_id\" property)"));
+  }
+  validateDocumentId(op, doc._id);
+};
+const validateInsert = (at, selector, items) => {
+  const signature = "insert(at, selector, items)";
+  if (VALID_INSERT_LOCATIONS.indexOf(at) === -1) {
+    const valid = VALID_INSERT_LOCATIONS.map(loc => "\"".concat(loc, "\"")).join(", ");
+    throw new Error("".concat(signature, " takes an \"at\"-argument which is one of: ").concat(valid));
+  }
+  if (typeof selector !== "string") {
+    throw new Error("".concat(signature, " takes a \"selector\"-argument which must be a string"));
+  }
+  if (!Array.isArray(items)) {
+    throw new Error("".concat(signature, " takes an \"items\"-argument which must be an array"));
+  }
+};
+const hasDataset = config => {
+  if (!config.dataset) {
+    throw new Error("`dataset` must be provided to perform queries");
+  }
+  return config.dataset || "";
+};
+const requestTag = tag => {
+  if (typeof tag !== "string" || !/^[a-z0-9._-]{1,75}$/i.test(tag)) {
+    throw new Error("Tag can only contain alphanumeric characters, underscores, dashes and dots, and be between one and 75 characters long.");
+  }
+  return tag;
+};
+const enc = encodeURIComponent;
+var encodeQueryString = _ref => {
+  let {
+    query,
+    params = {},
+    options = {}
+  } = _ref;
+  const {
+    tag,
+    ...opts
+  } = options;
+  const q = "query=".concat(enc(query));
+  const base = tag ? "?tag=".concat(enc(tag), "&").concat(q) : "?".concat(q);
+  const qString = Object.keys(params).reduce((qs, param) => "".concat(qs, "&").concat(enc("$".concat(param)), "=").concat(enc(JSON.stringify(params[param]))), base);
+  return Object.keys(opts).reduce((qs, option) => {
+    return options[option] ? "".concat(qs, "&").concat(enc(option), "=").concat(enc(options[option])) : qs;
+  }, qString);
+};
+var __accessCheck$4 = (obj, member, msg) => {
+  if (!member.has(obj)) throw TypeError("Cannot " + msg);
+};
+var __privateGet$3 = (obj, member, getter) => {
+  __accessCheck$4(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$4 = (obj, member, value) => {
+  if (member.has(obj)) throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$3 = (obj, member, value, setter) => {
+  __accessCheck$4(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _client$2, _client2$2;
+class BasePatch {
+  constructor(selection) {
+    let operations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    this.selection = selection;
+    this.operations = operations;
+  }
+  replace(attrs) {
+    validateObject("replace", attrs);
+    return this._set("set", {
+      $: attrs
+    });
+  }
+  set(attrs) {
+    return this._assign("set", attrs);
+  }
+  setIfMissing(attrs) {
+    return this._assign("setIfMissing", attrs);
+  }
+  diffMatchPatch(attrs) {
+    validateObject("diffMatchPatch", attrs);
+    return this._assign("diffMatchPatch", attrs);
+  }
+  unset(attrs) {
+    if (!Array.isArray(attrs)) {
+      throw new Error("unset(attrs) takes an array of attributes to unset, non-array given");
+    }
+    this.operations = Object.assign({}, this.operations, {
+      unset: attrs
+    });
+    return this;
+  }
+  inc(attrs) {
+    return this._assign("inc", attrs);
+  }
+  dec(attrs) {
+    return this._assign("dec", attrs);
+  }
+  insert(at, selector, items) {
+    validateInsert(at, selector, items);
+    return this._assign("insert", {
+      [at]: selector,
+      items
+    });
+  }
+  append(selector, items) {
+    return this.insert("after", "".concat(selector, "[-1]"), items);
+  }
+  prepend(selector, items) {
+    return this.insert("before", "".concat(selector, "[0]"), items);
+  }
+  splice(selector, start, deleteCount, items) {
+    const delAll = typeof deleteCount === "undefined" || deleteCount === -1;
+    const startIndex = start < 0 ? start - 1 : start;
+    const delCount = delAll ? -1 : Math.max(0, start + deleteCount);
+    const delRange = startIndex < 0 && delCount >= 0 ? "" : delCount;
+    const rangeSelector = "".concat(selector, "[").concat(startIndex, ":").concat(delRange, "]");
+    return this.insert("replace", rangeSelector, items || []);
+  }
+  ifRevisionId(rev) {
+    this.operations.ifRevisionID = rev;
+    return this;
+  }
+  serialize() {
+    return {
+      ...getSelection(this.selection),
+      ...this.operations
+    };
+  }
+  toJSON() {
+    return this.serialize();
+  }
+  reset() {
+    this.operations = {};
+    return this;
+  }
+  _assign(op, props) {
+    let merge = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    validateObject(op, props);
+    this.operations = Object.assign({}, this.operations, {
+      [op]: Object.assign({}, merge && this.operations[op] || {}, props)
+    });
+    return this;
+  }
+  _set(op, props) {
+    return this._assign(op, props, false);
+  }
+}
+const _ObservablePatch = class extends BasePatch {
+  constructor(selection, operations, client) {
+    super(selection, operations);
+    __privateAdd$4(this, _client$2, void 0);
+    __privateSet$3(this, _client$2, client);
+  }
+  clone() {
+    return new _ObservablePatch(this.selection, {
+      ...this.operations
+    }, __privateGet$3(this, _client$2));
+  }
+  commit(options) {
+    if (!__privateGet$3(this, _client$2)) {
+      throw new Error("No `client` passed to patch, either provide one or pass the patch to a clients `mutate()` method");
+    }
+    const returnFirst = typeof this.selection === "string";
+    const opts = Object.assign({
+      returnFirst,
+      returnDocuments: true
+    }, options);
+    return __privateGet$3(this, _client$2).mutate({
+      patch: this.serialize()
+    }, opts);
+  }
+};
+let ObservablePatch = _ObservablePatch;
+_client$2 = new WeakMap();
+const _Patch = class extends BasePatch {
+  constructor(selection, operations, client) {
+    super(selection, operations);
+    __privateAdd$4(this, _client2$2, void 0);
+    __privateSet$3(this, _client2$2, client);
+  }
+  clone() {
+    return new _Patch(this.selection, {
+      ...this.operations
+    }, __privateGet$3(this, _client2$2));
+  }
+  commit(options) {
+    if (!__privateGet$3(this, _client2$2)) {
+      throw new Error("No `client` passed to patch, either provide one or pass the patch to a clients `mutate()` method");
+    }
+    const returnFirst = typeof this.selection === "string";
+    const opts = Object.assign({
+      returnFirst,
+      returnDocuments: true
+    }, options);
+    return __privateGet$3(this, _client2$2).mutate({
+      patch: this.serialize()
+    }, opts);
+  }
+};
+let Patch = _Patch;
+_client2$2 = new WeakMap();
+var __accessCheck$3 = (obj, member, msg) => {
+  if (!member.has(obj)) throw TypeError("Cannot " + msg);
+};
+var __privateGet$2 = (obj, member, getter) => {
+  __accessCheck$3(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$3 = (obj, member, value) => {
+  if (member.has(obj)) throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$3(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _client$1, _client2$1;
+const defaultMutateOptions = {
+  returnDocuments: false
+};
+class BaseTransaction {
+  constructor() {
+    let operations = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    let transactionId = arguments.length > 1 ? arguments[1] : undefined;
+    this.operations = operations;
+    this.trxId = transactionId;
+  }
+  create(doc) {
+    validateObject("create", doc);
+    return this._add({
+      create: doc
+    });
+  }
+  createIfNotExists(doc) {
+    const op = "createIfNotExists";
+    validateObject(op, doc);
+    requireDocumentId(op, doc);
+    return this._add({
+      [op]: doc
+    });
+  }
+  createOrReplace(doc) {
+    const op = "createOrReplace";
+    validateObject(op, doc);
+    requireDocumentId(op, doc);
+    return this._add({
+      [op]: doc
+    });
+  }
+  delete(documentId) {
+    validateDocumentId("delete", documentId);
+    return this._add({
+      delete: {
+        id: documentId
+      }
+    });
+  }
+  transactionId(id) {
+    if (!id) {
+      return this.trxId;
+    }
+    this.trxId = id;
+    return this;
+  }
+  serialize() {
+    return [...this.operations];
+  }
+  toJSON() {
+    return this.serialize();
+  }
+  reset() {
+    this.operations = [];
+    return this;
+  }
+  _add(mut) {
+    this.operations.push(mut);
+    return this;
+  }
+}
+const _Transaction = class extends BaseTransaction {
+  constructor(operations, client, transactionId) {
+    super(operations, transactionId);
+    __privateAdd$3(this, _client$1, void 0);
+    __privateSet$2(this, _client$1, client);
+  }
+  clone() {
+    return new _Transaction([...this.operations], __privateGet$2(this, _client$1), this.trxId);
+  }
+  commit(options) {
+    if (!__privateGet$2(this, _client$1)) {
+      throw new Error("No `client` passed to transaction, either provide one or pass the transaction to a clients `mutate()` method");
+    }
+    return __privateGet$2(this, _client$1).mutate(this.serialize(), Object.assign({
+      transactionId: this.trxId
+    }, defaultMutateOptions, options || {}));
+  }
+  patch(patchOrDocumentId, patchOps) {
+    const isBuilder = typeof patchOps === "function";
+    const isPatch = typeof patchOrDocumentId !== "string" && patchOrDocumentId instanceof Patch;
+    if (isPatch) {
+      return this._add({
+        patch: patchOrDocumentId.serialize()
+      });
+    }
+    if (isBuilder) {
+      const patch = patchOps(new Patch(patchOrDocumentId, {}, __privateGet$2(this, _client$1)));
+      if (!(patch instanceof Patch)) {
+        throw new Error("function passed to `patch()` must return the patch");
+      }
+      return this._add({
+        patch: patch.serialize()
+      });
+    }
+    return this._add({
+      patch: {
+        id: patchOrDocumentId,
+        ...patchOps
+      }
+    });
+  }
+};
+let Transaction = _Transaction;
+_client$1 = new WeakMap();
+const _ObservableTransaction = class extends BaseTransaction {
+  constructor(operations, client, transactionId) {
+    super(operations, transactionId);
+    __privateAdd$3(this, _client2$1, void 0);
+    __privateSet$2(this, _client2$1, client);
+  }
+  clone() {
+    return new _ObservableTransaction([...this.operations], __privateGet$2(this, _client2$1), this.trxId);
+  }
+  commit(options) {
+    if (!__privateGet$2(this, _client2$1)) {
+      throw new Error("No `client` passed to transaction, either provide one or pass the transaction to a clients `mutate()` method");
+    }
+    return __privateGet$2(this, _client2$1).mutate(this.serialize(), Object.assign({
+      transactionId: this.trxId
+    }, defaultMutateOptions, options || {}));
+  }
+  patch(patchOrDocumentId, patchOps) {
+    const isBuilder = typeof patchOps === "function";
+    const isPatch = typeof patchOrDocumentId !== "string" && patchOrDocumentId instanceof ObservablePatch;
+    if (isPatch) {
+      return this._add({
+        patch: patchOrDocumentId.serialize()
+      });
+    }
+    if (isBuilder) {
+      const patch = patchOps(new ObservablePatch(patchOrDocumentId, {}, __privateGet$2(this, _client2$1)));
+      if (!(patch instanceof ObservablePatch)) {
+        throw new Error("function passed to `patch()` must return the patch");
+      }
+      return this._add({
+        patch: patch.serialize()
+      });
+    }
+    return this._add({
+      patch: {
+        id: patchOrDocumentId,
+        ...patchOps
+      }
+    });
+  }
+};
+let ObservableTransaction = _ObservableTransaction;
+_client2$1 = new WeakMap();
+const excludeFalsey = (param, defValue) => {
+  const value = typeof param === "undefined" ? defValue : param;
+  return param === false ? void 0 : value;
+};
+const getMutationQuery = function () {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return {
+    dryRun: options.dryRun,
+    returnIds: true,
+    returnDocuments: excludeFalsey(options.returnDocuments, true),
+    visibility: options.visibility || "sync",
+    autoGenerateArrayKeys: options.autoGenerateArrayKeys,
+    skipCrossDatasetReferenceValidation: options.skipCrossDatasetReferenceValidation
+  };
+};
+const isResponse = event => event.type === "response";
+const getBody = event => event.body;
+const indexBy = (docs, attr) => docs.reduce((indexed, doc) => {
+  indexed[attr(doc)] = doc;
+  return indexed;
+}, /* @__PURE__ */Object.create(null));
+const getQuerySizeLimit = 11264;
+function _fetch(client, httpRequest, query, params) {
+  let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  const mapResponse = options.filterResponse === false ? res => res : res => res.result;
+  return _dataRequest(client, httpRequest, "query", {
+    query,
+    params
+  }, options).pipe(operators.map(mapResponse));
+}
+function _getDocument(client, httpRequest, id) {
+  let opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  const options = {
+    uri: client.getDataUrl("doc", id),
+    json: true,
+    tag: opts.tag
+  };
+  return _requestObservable(client, httpRequest, options).pipe(operators.filter(isResponse), operators.map(event => event.body.documents && event.body.documents[0]));
+}
+function _getDocuments(client, httpRequest, ids) {
+  let opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  const options = {
+    uri: client.getDataUrl("doc", ids.join(",")),
+    json: true,
+    tag: opts.tag
+  };
+  return _requestObservable(client, httpRequest, options).pipe(operators.filter(isResponse), operators.map(event => {
+    const indexed = indexBy(event.body.documents || [], doc => doc._id);
+    return ids.map(id => indexed[id] || null);
+  }));
+}
+function _createIfNotExists(client, httpRequest, doc, options) {
+  requireDocumentId("createIfNotExists", doc);
+  return _create(client, httpRequest, doc, "createIfNotExists", options);
+}
+function _createOrReplace(client, httpRequest, doc, options) {
+  requireDocumentId("createOrReplace", doc);
+  return _create(client, httpRequest, doc, "createOrReplace", options);
+}
+function _delete(client, httpRequest, selection, options) {
+  return _dataRequest(client, httpRequest, "mutate", {
+    mutations: [{
+      delete: getSelection(selection)
+    }]
+  }, options);
+}
+function _mutate(client, httpRequest, mutations, options) {
+  const mut = mutations instanceof Patch || mutations instanceof ObservablePatch || mutations instanceof Transaction || mutations instanceof ObservableTransaction ? mutations.serialize() : mutations;
+  const muts = Array.isArray(mut) ? mut : [mut];
+  const transactionId = options && options.transactionId;
+  return _dataRequest(client, httpRequest, "mutate", {
+    mutations: muts,
+    transactionId
+  }, options);
+}
+function _dataRequest(client, httpRequest, endpoint, body) {
+  let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  const isMutation = endpoint === "mutate";
+  const isQuery = endpoint === "query";
+  const strQuery = isMutation ? "" : encodeQueryString(body);
+  const useGet = !isMutation && strQuery.length < getQuerySizeLimit;
+  const stringQuery = useGet ? strQuery : "";
+  const returnFirst = options.returnFirst;
+  const {
+    timeout,
+    token,
+    tag,
+    headers
+  } = options;
+  const uri = client.getDataUrl(endpoint, stringQuery);
+  const reqOptions = {
+    method: useGet ? "GET" : "POST",
+    uri,
+    json: true,
+    body: useGet ? void 0 : body,
+    query: isMutation && getMutationQuery(options),
+    timeout,
+    headers,
+    token,
+    tag,
+    canUseCdn: isQuery
+  };
+  return _requestObservable(client, httpRequest, reqOptions).pipe(operators.filter(isResponse), operators.map(getBody), operators.map(res => {
+    if (!isMutation) {
+      return res;
+    }
+    const results = res.results || [];
+    if (options.returnDocuments) {
+      return returnFirst ? results[0] && results[0].document : results.map(mut => mut.document);
+    }
+    const key = returnFirst ? "documentId" : "documentIds";
+    const ids = returnFirst ? results[0] && results[0].id : results.map(mut => mut.id);
+    return {
+      transactionId: res.transactionId,
+      results,
+      [key]: ids
+    };
+  }));
+}
+function _create(client, httpRequest, doc, op) {
+  let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  const mutation = {
+    [op]: doc
+  };
+  const opts = Object.assign({
+    returnFirst: true,
+    returnDocuments: true
+  }, options);
+  return _dataRequest(client, httpRequest, "mutate", {
+    mutations: [mutation]
+  }, opts);
+}
+function _requestObservable(client, httpRequest, options) {
+  const uri = options.url || options.uri;
+  const config = client.config();
+  const canUseCdn = typeof options.canUseCdn === "undefined" ? ["GET", "HEAD"].indexOf(options.method || "GET") >= 0 && uri.indexOf("/data/") === 0 : options.canUseCdn;
+  const useCdn = config.useCdn && canUseCdn;
+  const tag = options.tag && config.requestTagPrefix ? [config.requestTagPrefix, options.tag].join(".") : options.tag || config.requestTagPrefix;
+  if (tag) {
+    options.query = {
+      tag: requestTag(tag),
+      ...options.query
+    };
+  }
+  const reqOptions = getRequestOptions(config, Object.assign({}, options, {
+    url: client.getUrl(uri, useCdn)
+  }));
+  return new rxjs.Observable(subscriber => httpRequest(reqOptions, config.requester).subscribe(subscriber));
+}
+function _request(client, httpRequest, options) {
+  const observable = _requestObservable(client, httpRequest, options).pipe(operators.filter(event => event.type === "response"), operators.map(event => event.body));
+  return observable;
+}
+var __accessCheck$2 = (obj, member, msg) => {
+  if (!member.has(obj)) throw TypeError("Cannot " + msg);
+};
+var __privateGet$1 = (obj, member, getter) => {
+  __accessCheck$2(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$2 = (obj, member, value) => {
+  if (member.has(obj)) throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$1 = (obj, member, value, setter) => {
+  __accessCheck$2(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _client, _httpRequest$1, _client2, _httpRequest2$1;
+class ObservableAssetsClient {
+  constructor(client, httpRequest) {
+    __privateAdd$2(this, _client, void 0);
+    __privateAdd$2(this, _httpRequest$1, void 0);
+    __privateSet$1(this, _client, client);
+    __privateSet$1(this, _httpRequest$1, httpRequest);
+  }
+  upload(assetType, body, options) {
+    return _upload(__privateGet$1(this, _client), __privateGet$1(this, _httpRequest$1), assetType, body, options);
+  }
+}
+_client = new WeakMap();
+_httpRequest$1 = new WeakMap();
+class AssetsClient {
+  constructor(client, httpRequest) {
+    __privateAdd$2(this, _client2, void 0);
+    __privateAdd$2(this, _httpRequest2$1, void 0);
+    __privateSet$1(this, _client2, client);
+    __privateSet$1(this, _httpRequest2$1, httpRequest);
+  }
+  upload(assetType, body, options) {
+    const observable = _upload(__privateGet$1(this, _client2), __privateGet$1(this, _httpRequest2$1), assetType, body, options);
+    return rxjs.lastValueFrom(observable.pipe(operators.filter(event => event.type === "response"), operators.map(event => event.body.document)));
+  }
+}
+_client2 = new WeakMap();
+_httpRequest2$1 = new WeakMap();
+function _upload(client, httpRequest, assetType, body) {
+  let opts = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  validateAssetType(assetType);
+  let meta = opts.extract || void 0;
+  if (meta && !meta.length) {
+    meta = ["none"];
+  }
+  const dataset = hasDataset(client.config());
+  const assetEndpoint = assetType === "image" ? "images" : "files";
+  const options = optionsFromFile(opts, body);
+  const {
+    tag,
+    label,
+    title,
+    description,
+    creditLine,
+    filename,
+    source
+  } = options;
+  const query = {
+    label,
+    title,
+    description,
+    filename,
+    meta,
+    creditLine
+  };
+  if (source) {
+    query.sourceId = source.id;
+    query.sourceName = source.name;
+    query.sourceUrl = source.url;
+  }
+  return _requestObservable(client, httpRequest, {
+    tag,
+    method: "POST",
+    timeout: options.timeout || 0,
+    uri: "/assets/".concat(assetEndpoint, "/").concat(dataset),
+    headers: options.contentType ? {
+      "Content-Type": options.contentType
+    } : {},
+    query,
+    body
+  });
+}
+function optionsFromFile(opts, file) {
+  if (typeof window === "undefined" || !(file instanceof window.File)) {
+    return opts;
+  }
+  return Object.assign({
+    filename: opts.preserveFilename === false ? void 0 : file.name,
+    contentType: file.type
+  }, opts);
+}
+class BaseAuthClient {
+  getLoginProviders() {
+    return this.client.request({
+      uri: "/auth/providers"
+    });
+  }
+  logout() {
+    return this.client.request({
+      uri: "/auth/logout",
+      method: "POST"
+    });
+  }
+}
+class ObservableAuthClient extends BaseAuthClient {
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+}
+class AuthClient extends BaseAuthClient {
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+}
+const BASE_URL = "https://docs.sanity.io/help/";
+function generateHelpUrl(slug) {
+  return BASE_URL + slug;
+}
+var once = fn => {
+  let didCall = false;
+  let returnValue;
+  return function () {
+    if (didCall) {
+      return returnValue;
+    }
+    returnValue = fn(...arguments);
+    didCall = true;
+    return returnValue;
+  };
+};
+const createWarningPrinter = message => once(function () {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return console.warn(message.join(" "), ...args);
+});
+const printCdnWarning = createWarningPrinter(["You are not using the Sanity CDN. That means your data is always fresh, but the CDN is faster and", "cheaper. Think about it! For more info, see ".concat(generateHelpUrl("js-client-cdn-configuration"), "."), "To hide this warning, please set the `useCdn` option to either `true` or `false` when creating", "the client."]);
+const printBrowserTokenWarning = createWarningPrinter(["You have configured Sanity client to use a token in the browser. This may cause unintentional security issues.", "See ".concat(generateHelpUrl("js-client-browser-token"), " for more information and how to hide this warning.")]);
+const printNoApiVersionSpecifiedWarning = createWarningPrinter(["Using the Sanity client without specifying an API version is deprecated.", "See ".concat(generateHelpUrl("js-client-api-version"))]);
+const defaultCdnHost = "apicdn.sanity.io";
+const defaultConfig = {
+  apiHost: "https://api.sanity.io",
+  apiVersion: "1",
+  useProjectHostname: true
+};
+const LOCALHOSTS = ["localhost", "127.0.0.1", "0.0.0.0"];
+const isLocal = host => LOCALHOSTS.indexOf(host) !== -1;
+const validateApiVersion = function validateApiVersion2(apiVersion) {
+  if (apiVersion === "1" || apiVersion === "X") {
+    return;
+  }
+  const apiDate = new Date(apiVersion);
+  const apiVersionValid = /^\d{4}-\d{2}-\d{2}$/.test(apiVersion) && apiDate instanceof Date && apiDate.getTime() > 0;
+  if (!apiVersionValid) {
+    throw new Error("Invalid API version string, expected `1` or date in format `YYYY-MM-DD`");
+  }
+};
+const initConfig = (config, prevConfig) => {
+  const specifiedConfig = Object.assign({}, prevConfig, config);
+  if (!specifiedConfig.apiVersion) {
+    printNoApiVersionSpecifiedWarning();
+  }
+  const newConfig = Object.assign({}, defaultConfig, specifiedConfig);
+  const projectBased = newConfig.useProjectHostname;
+  if (typeof Promise === "undefined") {
+    const helpUrl = generateHelpUrl("js-client-promise-polyfill");
+    throw new Error("No native Promise-implementation found, polyfill needed - see ".concat(helpUrl));
+  }
+  if (projectBased && !newConfig.projectId) {
+    throw new Error("Configuration must contain `projectId`");
+  }
+  const isBrowser = typeof window !== "undefined" && window.location && window.location.hostname;
+  const isLocalhost = isBrowser && isLocal(window.location.hostname);
+  if (isBrowser && isLocalhost && newConfig.token && newConfig.ignoreBrowserTokenWarning !== true) {
+    printBrowserTokenWarning();
+  } else if (typeof newConfig.useCdn === "undefined") {
+    printCdnWarning();
+  }
+  if (projectBased) {
+    projectId(newConfig.projectId);
+  }
+  if (newConfig.dataset) {
+    dataset(newConfig.dataset);
+  }
+  if ("requestTagPrefix" in newConfig) {
+    newConfig.requestTagPrefix = newConfig.requestTagPrefix ? requestTag(newConfig.requestTagPrefix).replace(/\.+$/, "") : void 0;
+  }
+  newConfig.apiVersion = "".concat(newConfig.apiVersion).replace(/^v/, "");
+  newConfig.isDefaultApi = newConfig.apiHost === defaultConfig.apiHost;
+  newConfig.useCdn = Boolean(newConfig.useCdn) && !newConfig.withCredentials;
+  validateApiVersion(newConfig.apiVersion);
+  const hostParts = newConfig.apiHost.split("://", 2);
+  const protocol = hostParts[0];
+  const host = hostParts[1];
+  const cdnHost = newConfig.isDefaultApi ? defaultCdnHost : host;
+  if (newConfig.useProjectHostname) {
+    newConfig.url = "".concat(protocol, "://").concat(newConfig.projectId, ".").concat(host, "/v").concat(newConfig.apiVersion);
+    newConfig.cdnUrl = "".concat(protocol, "://").concat(newConfig.projectId, ".").concat(cdnHost, "/v").concat(newConfig.apiVersion);
+  } else {
+    newConfig.url = "".concat(newConfig.apiHost, "/v").concat(newConfig.apiVersion);
+    newConfig.cdnUrl = newConfig.url;
+  }
+  return newConfig;
+};
+var defaults = (obj, defaults) => Object.keys(defaults).concat(Object.keys(obj)).reduce((target, prop) => {
+  target[prop] = typeof obj[prop] === "undefined" ? defaults[prop] : obj[prop];
+  return target;
+}, {});
+var pick = (obj, props) => props.reduce((selection, prop) => {
+  if (typeof obj[prop] === "undefined") {
+    return selection;
+  }
+  selection[prop] = obj[prop];
+  return selection;
+}, {});
+const MAX_URL_LENGTH = 16e3 - 1200;
+const EventSource = polyfilledEventSource__default.default;
+const possibleOptions = ["includePreviousRevision", "includeResult", "visibility", "effectFormat", "tag"];
+const defaultOptions = {
+  includeResult: true
+};
+function _listen(query, params) {
+  let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const {
+    url,
+    token,
+    withCredentials,
+    requestTagPrefix
+  } = this.config();
+  const tag = opts.tag && requestTagPrefix ? [requestTagPrefix, opts.tag].join(".") : opts.tag;
+  const options = {
+    ...defaults(opts, defaultOptions),
+    tag
+  };
+  const listenOpts = pick(options, possibleOptions);
+  const qs = encodeQueryString({
+    query,
+    params,
+    options: {
+      tag,
+      ...listenOpts
+    }
+  });
+  const uri = "".concat(url).concat(this.getDataUrl("listen", qs));
+  if (uri.length > MAX_URL_LENGTH) {
+    return new rxjs.Observable(observer => observer.error(new Error("Query too large for listener")));
+  }
+  const listenFor = options.events ? options.events : ["mutation"];
+  const shouldEmitReconnect = listenFor.indexOf("reconnect") !== -1;
+  const esOptions = {};
+  if (token || withCredentials) {
+    esOptions.withCredentials = true;
+  }
+  if (token) {
+    esOptions.headers = {
+      Authorization: "Bearer ".concat(token)
+    };
+  }
+  return new rxjs.Observable(observer => {
+    let es = getEventSource();
+    let reconnectTimer;
+    let stopped = false;
+    function onError() {
+      if (stopped) {
+        return;
+      }
+      emitReconnect();
+      if (stopped) {
+        return;
+      }
+      if (es.readyState === EventSource.CLOSED) {
+        unsubscribe();
+        clearTimeout(reconnectTimer);
+        reconnectTimer = setTimeout(open, 100);
+      }
+    }
+    function onChannelError(err) {
+      observer.error(cooerceError(err));
+    }
+    function onMessage(evt) {
+      const event = parseEvent(evt);
+      return event instanceof Error ? observer.error(event) : observer.next(event);
+    }
+    function onDisconnect() {
+      stopped = true;
+      unsubscribe();
+      observer.complete();
+    }
+    function unsubscribe() {
+      es.removeEventListener("error", onError, false);
+      es.removeEventListener("channelError", onChannelError, false);
+      es.removeEventListener("disconnect", onDisconnect, false);
+      listenFor.forEach(type => es.removeEventListener(type, onMessage, false));
+      es.close();
+    }
+    function emitReconnect() {
+      if (shouldEmitReconnect) {
+        observer.next({
+          type: "reconnect"
+        });
+      }
+    }
+    function getEventSource() {
+      const evs = new EventSource(uri, esOptions);
+      evs.addEventListener("error", onError, false);
+      evs.addEventListener("channelError", onChannelError, false);
+      evs.addEventListener("disconnect", onDisconnect, false);
+      listenFor.forEach(type => evs.addEventListener(type, onMessage, false));
+      return evs;
+    }
+    function open() {
+      es = getEventSource();
+    }
+    function stop() {
+      stopped = true;
+      unsubscribe();
+    }
+    return stop;
+  });
+}
+function parseEvent(event) {
+  try {
+    const data = event.data && JSON.parse(event.data) || {};
+    return Object.assign({
+      type: event.type
+    }, data);
+  } catch (err) {
+    return err;
+  }
+}
+function cooerceError(err) {
+  if (err instanceof Error) {
+    return err;
+  }
+  const evt = parseEvent(err);
+  return evt instanceof Error ? evt : new Error(extractErrorMessage(evt));
+}
+function extractErrorMessage(err) {
+  if (!err.error) {
+    return err.message || "Unknown listener error";
+  }
+  if (err.error.description) {
+    return err.error.description;
+  }
+  return typeof err.error === "string" ? err.error : JSON.stringify(err.error, null, 2);
+}
+var __accessCheck$1 = (obj, member, msg) => {
+  if (!member.has(obj)) throw TypeError("Cannot " + msg);
+};
+var __privateAdd$1 = (obj, member, value) => {
+  if (member.has(obj)) throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck$1(obj, member, "access private method");
+  return method;
+};
+var __modify, _modify_fn;
+class BaseDatasetsClient {
+  constructor() {
+    __privateAdd$1(this, __modify);
+  }
+  create(name, options) {
+    return __privateMethod(this, __modify, _modify_fn).call(this, "PUT", name, options);
+  }
+  edit(name, options) {
+    return __privateMethod(this, __modify, _modify_fn).call(this, "PATCH", name, options);
+  }
+  delete(name) {
+    return __privateMethod(this, __modify, _modify_fn).call(this, "DELETE", name);
+  }
+  list() {
+    return this.client.request({
+      uri: "/datasets"
+    });
+  }
+}
+__modify = new WeakSet();
+_modify_fn = function (method, name, options) {
+  dataset(name);
+  return this.client.request({
+    method,
+    uri: "/datasets/".concat(name),
+    body: options
+  });
+};
+class ObservableDatasetsClient extends BaseDatasetsClient {
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+}
+class DatasetsClient extends BaseDatasetsClient {
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+}
+class BaseProjectsClient {
+  list() {
+    return this.client.request({
+      uri: "/projects"
+    });
+  }
+  getById(projectId) {
+    return this.client.request({
+      uri: "/projects/".concat(projectId)
+    });
+  }
+}
+class ObservableProjectsClient extends BaseProjectsClient {
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+}
+class ProjectsClient extends BaseProjectsClient {
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+}
+class BaseUsersClient {
+  getById(id) {
+    return this.client.request({
+      uri: "/users/".concat(id)
+    });
+  }
+}
+class ObservableUsersClient extends BaseUsersClient {
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+}
+class UsersClient extends BaseUsersClient {
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+}
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj)) throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj)) throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _clientConfig, _httpRequest, _httpRequest2;
+class BaseSanityClient {
+  constructor(config) {
+    __privateAdd(this, _clientConfig, void 0);
+    this.config(config);
+  }
+  config(newConfig) {
+    if (newConfig === void 0) {
+      return {
+        ...__privateGet(this, _clientConfig)
+      };
+    }
+    if (__privateGet(this, _clientConfig) && __privateGet(this, _clientConfig).allowReconfigure === false) {
+      throw new Error("Existing client instance cannot be reconfigured - use `withConfig(newConfig)` to return a new client");
+    }
+    __privateSet(this, _clientConfig, initConfig(newConfig, __privateGet(this, _clientConfig) || {}));
+    return this;
+  }
+  isPromiseAPI() {
+    return this instanceof SanityClient;
+  }
+  getUrl(uri) {
+    let canUseCdn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const base = canUseCdn ? __privateGet(this, _clientConfig).cdnUrl : __privateGet(this, _clientConfig).url;
+    return "".concat(base, "/").concat(uri.replace(/^\//, ""));
+  }
+  getDataUrl(operation, path) {
+    const config = this.config();
+    const catalog = hasDataset(config);
+    const baseUri = "/".concat(operation, "/").concat(catalog);
+    const uri = path ? "".concat(baseUri, "/").concat(path) : baseUri;
+    return "/data".concat(uri).replace(/\/($|\?)/, "$1");
+  }
+}
+_clientConfig = new WeakMap();
+const _ObservableSanityClient = class extends BaseSanityClient {
+  constructor(httpRequest, config) {
+    super(config);
+    __privateAdd(this, _httpRequest, void 0);
+    __privateSet(this, _httpRequest, httpRequest);
+    this.assets = new ObservableAssetsClient(this, __privateGet(this, _httpRequest));
+    this.auth = new ObservableAuthClient(this);
+    this.datasets = new ObservableDatasetsClient(this);
+    this.projects = new ObservableProjectsClient(this);
+    this.users = new ObservableUsersClient(this);
+  }
+  clone() {
+    return new _ObservableSanityClient(__privateGet(this, _httpRequest), this.config());
+  }
+  config(newConfig) {
+    return super.config(newConfig);
+  }
+  withConfig(newConfig) {
+    return new _ObservableSanityClient(__privateGet(this, _httpRequest), {
+      ...this.config(),
+      ...newConfig
+    });
+  }
+  fetch(query, params) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    return _fetch(this, __privateGet(this, _httpRequest), query, params, options);
+  }
+  getDocument(id, options) {
+    return _getDocument(this, __privateGet(this, _httpRequest), id, options);
+  }
+  getDocuments(ids, options) {
+    return _getDocuments(this, __privateGet(this, _httpRequest), ids, options);
+  }
+  create(document, options) {
+    return _create(this, __privateGet(this, _httpRequest), document, "create", options);
+  }
+  createIfNotExists(document, options) {
+    return _createIfNotExists(this, __privateGet(this, _httpRequest), document, options);
+  }
+  createOrReplace(document, options) {
+    return _createOrReplace(this, __privateGet(this, _httpRequest), document, options);
+  }
+  delete(selection, options) {
+    return _delete(this, __privateGet(this, _httpRequest), selection, options);
+  }
+  mutate(operations, options) {
+    return _mutate(this, __privateGet(this, _httpRequest), operations, options);
+  }
+  patch(documentId, operations) {
+    return new ObservablePatch(documentId, operations, this);
+  }
+  transaction(operations) {
+    return new ObservableTransaction(operations, this);
+  }
+  request(options) {
+    return _request(this, __privateGet(this, _httpRequest), options);
+  }
+};
+let ObservableSanityClient = _ObservableSanityClient;
+_httpRequest = new WeakMap();
+const _SanityClient = class extends BaseSanityClient {
+  constructor(httpRequest, config) {
+    super(config);
+    __privateAdd(this, _httpRequest2, void 0);
+    this.listen = _listen;
+    __privateSet(this, _httpRequest2, httpRequest);
+    this.assets = new AssetsClient(this, __privateGet(this, _httpRequest2));
+    this.auth = new AuthClient(this);
+    this.datasets = new DatasetsClient(this);
+    this.projects = new ProjectsClient(this);
+    this.users = new UsersClient(this);
+    this.observable = new ObservableSanityClient(httpRequest, this.config());
+  }
+  clone() {
+    return new _SanityClient(__privateGet(this, _httpRequest2), this.config());
+  }
+  config(newConfig) {
+    if (newConfig) {
+      this.observable.config(newConfig);
+    }
+    return super.config(newConfig);
+  }
+  withConfig(newConfig) {
+    return new _SanityClient(__privateGet(this, _httpRequest2), {
+      ...this.config(),
+      ...newConfig
+    });
+  }
+  fetch(query, params) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    return rxjs.lastValueFrom(_fetch(this, __privateGet(this, _httpRequest2), query, params, options));
+  }
+  getDocument(id, options) {
+    return rxjs.lastValueFrom(_getDocument(this, __privateGet(this, _httpRequest2), id, options));
+  }
+  getDocuments(ids, options) {
+    return rxjs.lastValueFrom(_getDocuments(this, __privateGet(this, _httpRequest2), ids, options));
+  }
+  create(document, options) {
+    return rxjs.lastValueFrom(_create(this, __privateGet(this, _httpRequest2), document, "create", options));
+  }
+  createIfNotExists(document, options) {
+    return rxjs.lastValueFrom(_createIfNotExists(this, __privateGet(this, _httpRequest2), document, options));
+  }
+  createOrReplace(document, options) {
+    return rxjs.lastValueFrom(_createOrReplace(this, __privateGet(this, _httpRequest2), document, options));
+  }
+  delete(selection, options) {
+    return rxjs.lastValueFrom(_delete(this, __privateGet(this, _httpRequest2), selection, options));
+  }
+  mutate(operations, options) {
+    return rxjs.lastValueFrom(_mutate(this, __privateGet(this, _httpRequest2), operations, options));
+  }
+  patch(documentId, operations) {
+    return new Patch(documentId, operations, this);
+  }
+  transaction(operations) {
+    return new Transaction(operations, this);
+  }
+  request(options) {
+    return rxjs.lastValueFrom(_request(this, __privateGet(this, _httpRequest2), options));
+  }
+  dataRequest(endpoint, body, options) {
+    return rxjs.lastValueFrom(_dataRequest(this, __privateGet(this, _httpRequest2), endpoint, body, options));
+  }
+};
+let SanityClient = _SanityClient;
+_httpRequest2 = new WeakMap();
+const httpRequest = defineHttpRequest(envMiddleware);
+const requester = httpRequest.defaultRequester;
+function createClient(config) {
+  return new SanityClient(httpRequest, config);
+}
+exports.BasePatch = BasePatch;
+exports.BaseSanityClient = BaseSanityClient;
+exports.BaseTransaction = BaseTransaction;
+exports.ClientError = ClientError;
+exports.ObservablePatch = ObservablePatch;
+exports.ObservableSanityClient = ObservableSanityClient;
+exports.ObservableTransaction = ObservableTransaction;
+exports.Patch = Patch;
+exports.SanityClient = SanityClient;
+exports.ServerError = ServerError;
+exports.Transaction = Transaction;
+exports.createClient = createClient;
+exports.requester = requester;
+//# sourceMappingURL=index.browser.cjs.map