@sanity/client 6.4.8 → 6.4.10-canary.2

package/umd/sanityClient.js

@@ -4,13 +4,13 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SanityClient = {}));
 })(this, (function (exports) { 'use strict';
 
-  const isReactNative = typeof navigator === "undefined" ? false : navigator.product === "ReactNative";
-  const defaultOptions$1 = {
-    timeout: isReactNative ? 6e4 : 12e4
+  const isReactNative$1 = typeof navigator === "undefined" ? false : navigator.product === "ReactNative";
+  const defaultOptions$2 = {
+    timeout: isReactNative$1 ? 6e4 : 12e4
   };
-  const processOptions = function processOptions2(opts) {
+  const processOptions$1 = function processOptions2(opts) {
     const options = {
-      ...defaultOptions$1,
+      ...defaultOptions$2,
       ...(typeof opts === "string" ? {
         url: opts
       } : opts)
@@ -18,7 +18,7 @@
     const {
       searchParams
     } = new URL(options.url, "http://localhost");
-    options.timeout = normalizeTimeout(options.timeout);
+    options.timeout = normalizeTimeout$1(options.timeout);
     if (options.query) {
       for (const [key, value] of Object.entries(options.query)) {
         if (value !== void 0) {
@@ -40,7 +40,7 @@
     options.method = options.body && !options.method ? "POST" : (options.method || "GET").toUpperCase();
     return options;
   };
-  function normalizeTimeout(time) {
+  function normalizeTimeout$1(time) {
     if (time === false || time === 0) {
       return false;
     }
@@ -49,16 +49,16 @@
     }
     const delay = Number(time);
     if (isNaN(delay)) {
-      return normalizeTimeout(defaultOptions$1.timeout);
+      return normalizeTimeout$1(defaultOptions$2.timeout);
     }
     return {
       connect: delay,
       socket: delay
     };
   }
-  const validUrl = /^https?:\/\//i;
-  const validateOptions = function validateOptions2(options) {
-    if (!validUrl.test(options.url)) {
+  const validUrl$1 = /^https?:\/\//i;
+  const validateOptions$1 = function validateOptions2(options) {
+    if (!validUrl$1.test(options.url)) {
       throw new Error('"'.concat(options.url, '" is not a valid URL'));
     }
   };
@@ -147,8 +147,8 @@
       ware[name] = ware[name] || [];
       return ware;
     }, {
-      processOptions: [processOptions],
-      validateOptions: [validateOptions]
+      processOptions: [processOptions$1],
+      validateOptions: [validateOptions$1]
     });
     function request(opts) {
       const onResponse = (reqErr, res, ctx) => {
@@ -498,6 +498,8 @@
   };
   const environment = "browser";
 
+  var middleware_browser = {};
+
   var browser$3 = {exports: {}};
 
   /**
@@ -1217,6 +1219,75 @@
   	}; 
   } (browser$3, browser$3.exports));
 
+  var browserExports = browser$3.exports;
+
+  var defaultOptionsValidator41aa9136 = {};
+
+  const isReactNative = typeof navigator === "undefined" ? false : navigator.product === "ReactNative";
+  const defaultOptions$1 = {
+    timeout: isReactNative ? 6e4 : 12e4
+  };
+  const processOptions = function processOptions2(opts) {
+    const options = {
+      ...defaultOptions$1,
+      ...(typeof opts === "string" ? {
+        url: opts
+      } : opts)
+    };
+    const {
+      searchParams
+    } = new URL(options.url, "http://localhost");
+    options.timeout = normalizeTimeout(options.timeout);
+    if (options.query) {
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value !== void 0) {
+          if (Array.isArray(value)) {
+            for (const v of value) {
+              searchParams.append(key, v);
+            }
+          } else {
+            searchParams.append(key, value);
+          }
+        }
+      }
+    }
+    const [url] = options.url.split("?");
+    const search = searchParams.toString();
+    if (search) {
+      options.url = "".concat(url, "?").concat(search);
+    }
+    options.method = options.body && !options.method ? "POST" : (options.method || "GET").toUpperCase();
+    return options;
+  };
+  function normalizeTimeout(time) {
+    if (time === false || time === 0) {
+      return false;
+    }
+    if (time.connect || time.socket) {
+      return time;
+    }
+    const delay = Number(time);
+    if (isNaN(delay)) {
+      return normalizeTimeout(defaultOptions$1.timeout);
+    }
+    return {
+      connect: delay,
+      socket: delay
+    };
+  }
+  const validUrl = /^https?:\/\//i;
+  const validateOptions = function validateOptions2(options) {
+    if (!validUrl.test(options.url)) {
+      throw new Error('"'.concat(options.url, '" is not a valid URL'));
+    }
+  };
+  defaultOptionsValidator41aa9136.processOptions = processOptions;
+  defaultOptionsValidator41aa9136.validateOptions = validateOptions;
+
+  var isPlainObject$3 = {};
+
+  Object.defineProperty(isPlainObject$3, '__esModule', { value: true });
+
   /*!
    * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
    *
@@ -1228,7 +1299,7 @@
     return Object.prototype.toString.call(o) === '[object Object]';
   }
 
-  function isPlainObject$1(o) {
+  function isPlainObject$2(o) {
     var ctor,prot;
 
     if (isObject(o) === false) return false;
@@ -1250,6 +1321,184 @@
     return true;
   }
 
+  isPlainObject$3.isPlainObject = isPlainObject$2;
+
+  Object.defineProperty(middleware_browser, '__esModule', {
+    value: true
+  });
+  var debugIt = browserExports;
+  var defaultOptionsValidator = defaultOptionsValidator41aa9136;
+  var isPlainObject$1 = isPlainObject$3;
+  function _interopDefaultCompat$1(e) {
+    return e && typeof e === 'object' && 'default' in e ? e : {
+      default: e
+    };
+  }
+  var debugIt__default = /*#__PURE__*/_interopDefaultCompat$1(debugIt);
+  function agent(opts) {
+    return {};
+  }
+  const leadingSlash = /^\//;
+  const trailingSlash = /\/$/;
+  function base(baseUrl) {
+    const baseUri = baseUrl.replace(trailingSlash, "");
+    return {
+      processOptions: options => {
+        if (/^https?:\/\//i.test(options.url)) {
+          return options;
+        }
+        const url = [baseUri, options.url.replace(leadingSlash, "")].join("/");
+        return Object.assign({}, options, {
+          url
+        });
+      }
+    };
+  }
+  const SENSITIVE_HEADERS = ["cookie", "authorization"];
+  const hasOwn = Object.prototype.hasOwnProperty;
+  const redactKeys = (source, redacted) => {
+    const target = {};
+    for (const key in source) {
+      if (hasOwn.call(source, key)) {
+        target[key] = redacted.indexOf(key.toLowerCase()) > -1 ? "<redacted>" : source[key];
+      }
+    }
+    return target;
+  };
+  function debug() {
+    let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const verbose = opts.verbose;
+    const namespace = opts.namespace || "get-it";
+    const defaultLogger = debugIt__default.default(namespace);
+    const log = opts.log || defaultLogger;
+    const shortCircuit = log === defaultLogger && !debugIt__default.default.enabled(namespace);
+    let requestId = 0;
+    return {
+      processOptions: options => {
+        options.debug = log;
+        options.requestId = options.requestId || ++requestId;
+        return options;
+      },
+      onRequest: event => {
+        if (shortCircuit || !event) {
+          return event;
+        }
+        const options = event.options;
+        log("[%s] HTTP %s %s", options.requestId, options.method, options.url);
+        if (verbose && options.body && typeof options.body === "string") {
+          log("[%s] Request body: %s", options.requestId, options.body);
+        }
+        if (verbose && options.headers) {
+          const headers = opts.redactSensitiveHeaders === false ? options.headers : redactKeys(options.headers, SENSITIVE_HEADERS);
+          log("[%s] Request headers: %s", options.requestId, JSON.stringify(headers, null, 2));
+        }
+        return event;
+      },
+      onResponse: (res, context) => {
+        if (shortCircuit || !res) {
+          return res;
+        }
+        const reqId = context.options.requestId;
+        log("[%s] Response code: %s %s", reqId, res.statusCode, res.statusMessage);
+        if (verbose && res.body) {
+          log("[%s] Response body: %s", reqId, stringifyBody$1(res));
+        }
+        return res;
+      },
+      onError: (err, context) => {
+        const reqId = context.options.requestId;
+        if (!err) {
+          log("[%s] Error encountered, but handled by an earlier middleware", reqId);
+          return err;
+        }
+        log("[%s] ERROR: %s", reqId, err.message);
+        return err;
+      }
+    };
+  }
+  function stringifyBody$1(res) {
+    const contentType = (res.headers["content-type"] || "").toLowerCase();
+    const isJson = contentType.indexOf("application/json") !== -1;
+    return isJson ? tryFormat(res.body) : res.body;
+  }
+  function tryFormat(body) {
+    try {
+      const parsed = typeof body === "string" ? JSON.parse(body) : body;
+      return JSON.stringify(parsed, null, 2);
+    } catch (err) {
+      return body;
+    }
+  }
+  function headers(_headers) {
+    let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return {
+      processOptions: options => {
+        const existing = options.headers || {};
+        options.headers = opts.override ? Object.assign({}, existing, _headers) : Object.assign({}, _headers, existing);
+        return options;
+      }
+    };
+  }
+  var __defProp$1$1 = Object.defineProperty;
+  var __defNormalProp$1$1 = (obj, key, value) => key in obj ? __defProp$1$1(obj, key, {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value
+  }) : obj[key] = value;
+  var __publicField$1$1 = (obj, key, value) => {
+    __defNormalProp$1$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  class HttpError extends Error {
+    constructor(res, ctx) {
+      super();
+      __publicField$1$1(this, "response");
+      __publicField$1$1(this, "request");
+      const truncatedUrl = res.url.length > 400 ? "".concat(res.url.slice(0, 399), "\u2026") : res.url;
+      let msg = "".concat(res.method, "-request to ").concat(truncatedUrl, " resulted in ");
+      msg += "HTTP ".concat(res.statusCode, " ").concat(res.statusMessage);
+      this.message = msg.trim();
+      this.response = res;
+      this.request = ctx.options;
+    }
+  }
+  function httpErrors() {
+    return {
+      onResponse: (res, ctx) => {
+        const isHttpError = res.statusCode >= 400;
+        if (!isHttpError) {
+          return res;
+        }
+        throw new HttpError(res, ctx);
+      }
+    };
+  }
+  function injectResponse() {
+    let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (typeof opts.inject !== "function") {
+      throw new Error("`injectResponse` middleware requires a `inject` function");
+    }
+    const inject = function inject2(prevValue, event) {
+      const response = opts.inject(event, prevValue);
+      if (!response) {
+        return prevValue;
+      }
+      const options = event.context.options;
+      return {
+        body: "",
+        url: options.url,
+        method: options.method,
+        headers: {},
+        statusCode: 200,
+        statusMessage: "OK",
+        ...response
+      };
+    };
+    return {
+      interceptRequest: inject
+    };
+  }
   const isBuffer = typeof Buffer === "undefined" ? () => false : obj => Buffer.isBuffer(obj);
   const serializeTypes = ["boolean", "string", "number"];
   function jsonRequest() {
@@ -1260,7 +1509,7 @@
           return options;
         }
         const isStream = typeof body.pipe === "function";
-        const shouldSerialize = !isStream && !isBuffer(body) && (serializeTypes.indexOf(typeof body) !== -1 || Array.isArray(body) || isPlainObject$1(body));
+        const shouldSerialize = !isStream && !isBuffer(body) && (serializeTypes.indexOf(typeof body) !== -1 || Array.isArray(body) || isPlainObject$1.isPlainObject(body));
         if (!shouldSerialize) {
           return options;
         }
@@ -1300,13 +1549,41 @@
       }
     }
   }
+  function isBrowserOptions(options) {
+    return typeof options === "object" && options !== null && !("protocol" in options);
+  }
+  function mtls() {
+    let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (!config.ca) {
+      throw new Error('Required mtls option "ca" is missing');
+    }
+    if (!config.cert) {
+      throw new Error('Required mtls option "cert" is missing');
+    }
+    if (!config.key) {
+      throw new Error('Required mtls option "key" is missing');
+    }
+    return {
+      finalizeOptions: options => {
+        if (isBrowserOptions(options)) {
+          return options;
+        }
+        const mtlsOpts = {
+          cert: config.cert,
+          key: config.key,
+          ca: config.ca
+        };
+        return Object.assign({}, options, mtlsOpts);
+      }
+    };
+  }
   let actualGlobal = {};
   if (typeof globalThis !== "undefined") {
     actualGlobal = globalThis;
   } else if (typeof window !== "undefined") {
     actualGlobal = window;
-  } else if (typeof global !== "undefined") {
-    actualGlobal = global;
+  } else if (typeof commonjsGlobal !== "undefined") {
+    actualGlobal = commonjsGlobal;
   } else if (typeof self !== "undefined") {
     actualGlobal = self;
   }
@@ -1376,6 +1653,35 @@
     __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
     return value;
   };
+  const promise = function () {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const PromiseImplementation = options.implementation || Promise;
+    if (!PromiseImplementation) {
+      throw new Error("`Promise` is not available in global scope, and no implementation was passed");
+    }
+    return {
+      onReturn: (channels, context) => new PromiseImplementation((resolve, reject) => {
+        const cancel = context.options.cancelToken;
+        if (cancel) {
+          cancel.promise.then(reason => {
+            channels.abort.publish(reason);
+            reject(reason);
+          });
+        }
+        channels.error.subscribe(reject);
+        channels.response.subscribe(response => {
+          resolve(options.onlyBody ? response.body : response);
+        });
+        setTimeout(() => {
+          try {
+            channels.request.publish(context);
+          } catch (err) {
+            reject(err);
+          }
+        }, 0);
+      })
+    };
+  };
   class Cancel {
     constructor(message) {
       __publicField$4(this, "__CANCEL__", true);
@@ -1416,6 +1722,21 @@
       cancel
     };
   });
+  let CancelToken = _CancelToken;
+  const isCancel = value => !!(value && (value == null ? void 0 : value.__CANCEL__));
+  promise.Cancel = Cancel;
+  promise.CancelToken = CancelToken;
+  promise.isCancel = isCancel;
+  function proxy(_proxy) {
+    if (_proxy !== false && (!_proxy || !_proxy.host)) {
+      throw new Error("Proxy middleware takes an object of host, port and auth properties");
+    }
+    return {
+      processOptions: options => Object.assign({
+        proxy: _proxy
+      }, options)
+    };
+  }
   var defaultShouldRetry = (err, attempt, options) => {
     if (options.method !== "GET" && options.method !== "HEAD") {
       return false;
@@ -1460,6 +1781,88 @@
     });
   };
   retry.shouldRetry = defaultShouldRetry;
+  function encode(data) {
+    const query = new URLSearchParams();
+    const nest = (name, _value) => {
+      const value = _value instanceof Set ? Array.from(_value) : _value;
+      if (Array.isArray(value)) {
+        if (value.length) {
+          for (const index in value) {
+            nest("".concat(name, "[").concat(index, "]"), value[index]);
+          }
+        } else {
+          query.append("".concat(name, "[]"), "");
+        }
+      } else if (typeof value === "object" && value !== null) {
+        for (const [key, obj] of Object.entries(value)) {
+          nest("".concat(name, "[").concat(key, "]"), obj);
+        }
+      } else {
+        query.append(name, value);
+      }
+    };
+    for (const [key, value] of Object.entries(data)) {
+      nest(key, value);
+    }
+    return query.toString();
+  }
+  function urlEncoded() {
+    return {
+      processOptions: options => {
+        const body = options.body;
+        if (!body) {
+          return options;
+        }
+        const isStream = typeof body.pipe === "function";
+        const shouldSerialize = !isStream && !isBuffer(body) && isPlainObject$1.isPlainObject(body);
+        if (!shouldSerialize) {
+          return options;
+        }
+        return {
+          ...options,
+          body: encode(options.body),
+          headers: {
+            ...options.headers,
+            "Content-Type": "application/x-www-form-urlencoded"
+          }
+        };
+      }
+    };
+  }
+  function buildKeepAlive(agent) {
+    return function keepAlive() {
+      let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      const ms = config.ms || 1e3;
+      const maxFree = config.maxFree || 256;
+      const agentOptions = {
+        keepAlive: true,
+        keepAliveMsecs: ms,
+        maxFreeSockets: maxFree
+      };
+      return agent(agentOptions);
+    };
+  }
+  const keepAlive = buildKeepAlive(agent);
+  middleware_browser.processOptions = defaultOptionsValidator.processOptions;
+  middleware_browser.validateOptions = defaultOptionsValidator.validateOptions;
+  middleware_browser.Cancel = Cancel;
+  middleware_browser.CancelToken = CancelToken;
+  middleware_browser.agent = agent;
+  middleware_browser.base = base;
+  middleware_browser.debug = debug;
+  middleware_browser.headers = headers;
+  middleware_browser.httpErrors = httpErrors;
+  middleware_browser.injectResponse = injectResponse;
+  var jsonRequest_1 = middleware_browser.jsonRequest = jsonRequest;
+  var jsonResponse_1 = middleware_browser.jsonResponse = jsonResponse;
+  middleware_browser.keepAlive = keepAlive;
+  middleware_browser.mtls = mtls;
+  var observable_1 = middleware_browser.observable = observable$1;
+  var progress_1 = middleware_browser.progress = progress;
+  middleware_browser.promise = promise;
+  middleware_browser.proxy = proxy;
+  var retry_1 = middleware_browser.retry = retry;
+  middleware_browser.urlEncoded = urlEncoded;
 
   /******************************************************************************
   Copyright (c) Microsoft Corporation.
@@ -2255,13 +2658,13 @@
       maxRetries = 5,
       retryDelay
     } = _ref;
-    const request = getIt([maxRetries > 0 ? retry({
+    const request = getIt([maxRetries > 0 ? retry_1({
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       retryDelay,
       // This option is typed incorrectly in get-it.
       maxRetries,
       shouldRetry
-    }) : {}, ...envMiddleware, printWarnings, jsonRequest(), jsonResponse(), progress(), httpError, observable$1({
+    }) : {}, ...envMiddleware, printWarnings, jsonRequest_1(), jsonResponse_1(), progress_1(), httpError, observable_1({
       implementation: Observable
     })]);
     function httpRequest(options) {
@@ -2280,7 +2683,7 @@
     const isQuery = uri.startsWith("/data/query");
     const isRetriableResponse = err.response && (err.response.statusCode === 429 || err.response.statusCode === 502 || err.response.statusCode === 503);
     if ((isSafe || isQuery) && isRetriableResponse) return true;
-    return retry.shouldRetry(err, attempt, options);
+    return retry_1.shouldRetry(err, attempt, options);
   }
   const BASE_URL = "https://www.sanity.io/help/";
   function generateHelpUrl(slug) {
@@ -2365,6 +2768,7 @@
     return console.warn(message.join(" "), ...args);
   });
   const printCdnWarning = createWarningPrinter(["Since you haven't set a value for `useCdn`, we will deliver content using our", "global, edge-cached API-CDN. If you wish to have content delivered faster, set", "`useCdn: false` to use the Live API. Note: You may incur higher costs using the live API."]);
+  const printCdnPreviewDraftsWarning = createWarningPrinter(["The Sanity client is configured with the `perspective` set to `previewDrafts`, which doesn't support the API-CDN.", "The Live API will be used instead. Set `useCdn: false` in your configuration to hide this warning."]);
   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 printNoDefaultExport = createWarningPrinter(["The default export of @sanity/client has been deprecated. Use the named export `createClient` instead."]);
@@ -3145,7 +3549,7 @@
     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;
+    let useCdn = config.useCdn && canUseCdn;
     const tag = options.tag && config.requestTagPrefix ? [config.requestTagPrefix, options.tag].join(".") : options.tag || config.requestTagPrefix;
     if (tag) {
       options.query = {
@@ -3167,6 +3571,10 @@
           perspective,
           ...options.query
         };
+        if (perspective === "previewDrafts" && useCdn) {
+          useCdn = false;
+          printCdnPreviewDraftsWarning();
+        }
       }
     }
     const reqOptions = requestOptions(config, Object.assign({}, options, {