@microlink/mql 0.10.33 → 0.10.35

package/README.md

@@ -1,5 +1,6 @@
 <div align="center">
-  <img src="https://cdn.microlink.io/banner/mql.png" alt="microlink logo">
+  <img src="https://github.com/microlinkhq/cdn/raw/master/dist/banner/mql.png#gh-light-mode-only" alt="microlink logo">
+  <img src="https://github.com/microlinkhq/cdn/raw/master/dist/banner/mql-dark.png#gh-dark-mode-only" alt="microlink logo">
 </div>
 
 ###### [Documentation](https://microlink.io/mql) | [CLI](https://github.com/microlinkhq/cli) | [Playground](https://mql.microlink.io) | [Chat](https://microlink.io/chat)

package/dist/mql.js

@@ -6,11 +6,15 @@
 
 	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
+	function getDefaultExportFromCjs (x) {
+		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+	}
+
 	const URL$1 = globalThis.URL;
 
 	const REGEX_HTTP_PROTOCOL = /^https?:\/\//i;
 
-	var lightweight = url => {
+	var lightweight$2 = url => {
 	  try {
 	    const { href } = new URL$1(url);
 	    return REGEX_HTTP_PROTOCOL.test(href) && href
@@ -103,7 +107,7 @@
 	    }, {})
 	  };
 
-	  const fetchFromApi = async (apiUrl, opts = {}, retryCount = 0) => {
+	  const fetchFromApi = async (apiUrl, opts = {}) => {
 	    try {
 	      const response = await got(apiUrl, opts);
 	      return opts.responseType === 'buffer'
@@ -124,10 +128,6 @@
 	          ? rawBody
 	          : parseBody(isBodyBuffer ? rawBody.toString() : rawBody, err, uri);
 
-	      if (body.code === 'EFATALCLIENT' && retryCount++ < 2) {
-	        return fetchFromApi(apiUrl, opts, retryCount)
-	      }
-
 	      throw new MicrolinkError({
 	        ...body,
 	        message: body.message,
@@ -181,11 +181,7 @@
 
 	var factory_1 = factory$1;
 
-	var kyExports = {};
-	var ky$1 = {
-	  get exports(){ return kyExports; },
-	  set exports(v){ kyExports = v; },
-	};
+	var ky$1 = {exports: {}};
 
 	(function (module, exports) {
 		(function (global, factory) {
@@ -199,6 +195,24 @@
 		            const status = `${code} ${title}`.trim();
 		            const reason = status ? `status code ${status}` : 'an unknown error';
 		            super(`Request failed with ${reason}`);
+		            Object.defineProperty(this, "response", {
+		                enumerable: true,
+		                configurable: true,
+		                writable: true,
+		                value: void 0
+		            });
+		            Object.defineProperty(this, "request", {
+		                enumerable: true,
+		                configurable: true,
+		                writable: true,
+		                value: void 0
+		            });
+		            Object.defineProperty(this, "options", {
+		                enumerable: true,
+		                configurable: true,
+		                writable: true,
+		                value: void 0
+		            });
 		            this.name = 'HTTPError';
 		            this.response = response;
 		            this.request = request;
@@ -209,6 +223,12 @@
 		    class TimeoutError extends Error {
 		        constructor(request) {
 		            super('Request timed out');
+		            Object.defineProperty(this, "request", {
+		                enumerable: true,
+		                configurable: true,
+		                writable: true,
+		                value: void 0
+		            });
 		            this.name = 'TimeoutError';
 		            this.request = request;
 		        }
@@ -219,7 +239,7 @@
 
 		    const validateAndMerge = (...sources) => {
 		        for (const source of sources) {
-		            if ((!isObject(source) || Array.isArray(source)) && typeof source !== 'undefined') {
+		            if ((!isObject(source) || Array.isArray(source)) && source !== undefined) {
 		                throw new TypeError('The `options` argument must be an object');
 		            }
 		        }
@@ -266,8 +286,26 @@
 		        return returnValue;
 		    };
 
+		    const supportsRequestStreams = (() => {
+		        let duplexAccessed = false;
+		        let hasContentType = false;
+		        const supportsReadableStream = typeof globalThis.ReadableStream === 'function';
+		        const supportsRequest = typeof globalThis.Request === 'function';
+		        if (supportsReadableStream && supportsRequest) {
+		            hasContentType = new globalThis.Request('https://empty.invalid', {
+		                body: new globalThis.ReadableStream(),
+		                method: 'POST',
+		                // @ts-expect-error - Types are outdated.
+		                get duplex() {
+		                    duplexAccessed = true;
+		                    return 'half';
+		                },
+		            }).headers.has('Content-Type');
+		        }
+		        return duplexAccessed && !hasContentType;
+		    })();
 		    const supportsAbortController = typeof globalThis.AbortController === 'function';
-		    const supportsStreams = typeof globalThis.ReadableStream === 'function';
+		    const supportsResponseStreams = typeof globalThis.ReadableStream === 'function';
 		    const supportsFormData = typeof globalThis.FormData === 'function';
 		    const requestMethods = ['get', 'post', 'put', 'patch', 'head', 'delete'];
 		    const responseTypes = {
@@ -291,6 +329,7 @@
 		        statusCodes: retryStatusCodes,
 		        afterStatusCodes: retryAfterStatusCodes,
 		        maxRetryAfter: Number.POSITIVE_INFINITY,
+		        backoffLimit: Number.POSITIVE_INFINITY,
 		    };
 		    const normalizeRetryOptions = (retry = {}) => {
 		        if (typeof retry === 'number') {
@@ -313,30 +352,139 @@
 		    };
 
 		    // `Promise.race()` workaround (#91)
-		    const timeout = async (request, abortController, options) => new Promise((resolve, reject) => {
-		        const timeoutId = setTimeout(() => {
-		            if (abortController) {
-		                abortController.abort();
+		    async function timeout(request, abortController, options) {
+		        return new Promise((resolve, reject) => {
+		            const timeoutId = setTimeout(() => {
+		                if (abortController) {
+		                    abortController.abort();
+		                }
+		                reject(new TimeoutError(request));
+		            }, options.timeout);
+		            void options
+		                .fetch(request)
+		                .then(resolve)
+		                .catch(reject)
+		                .then(() => {
+		                clearTimeout(timeoutId);
+		            });
+		        });
+		    }
+
+		    // https://github.com/sindresorhus/delay/tree/ab98ae8dfcb38e1593286c94d934e70d14a4e111
+		    async function delay(ms, { signal }) {
+		        return new Promise((resolve, reject) => {
+		            if (signal) {
+		                signal.throwIfAborted();
+		                signal.addEventListener('abort', abortHandler, { once: true });
+		            }
+		            function abortHandler() {
+		                clearTimeout(timeoutId);
+		                reject(signal.reason);
 		            }
-		            reject(new TimeoutError(request));
-		        }, options.timeout);
-		        void options
-		            .fetch(request)
-		            .then(resolve)
-		            .catch(reject)
-		            .then(() => {
-		            clearTimeout(timeoutId);
+		            const timeoutId = setTimeout(() => {
+		                signal?.removeEventListener('abort', abortHandler);
+		                resolve();
+		            }, ms);
 		        });
-		    });
-		    const delay = async (ms) => new Promise(resolve => {
-		        setTimeout(resolve, ms);
-		    });
+		    }
 
 		    class Ky {
+		        static create(input, options) {
+		            const ky = new Ky(input, options);
+		            const fn = async () => {
+		                if (typeof ky._options.timeout === 'number' && ky._options.timeout > maxSafeTimeout) {
+		                    throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
+		                }
+		                // Delay the fetch so that body method shortcuts can set the Accept header
+		                await Promise.resolve();
+		                let response = await ky._fetch();
+		                for (const hook of ky._options.hooks.afterResponse) {
+		                    // eslint-disable-next-line no-await-in-loop
+		                    const modifiedResponse = await hook(ky.request, ky._options, ky._decorateResponse(response.clone()));
+		                    if (modifiedResponse instanceof globalThis.Response) {
+		                        response = modifiedResponse;
+		                    }
+		                }
+		                ky._decorateResponse(response);
+		                if (!response.ok && ky._options.throwHttpErrors) {
+		                    let error = new HTTPError(response, ky.request, ky._options);
+		                    for (const hook of ky._options.hooks.beforeError) {
+		                        // eslint-disable-next-line no-await-in-loop
+		                        error = await hook(error);
+		                    }
+		                    throw error;
+		                }
+		                // If `onDownloadProgress` is passed, it uses the stream API internally
+		                /* istanbul ignore next */
+		                if (ky._options.onDownloadProgress) {
+		                    if (typeof ky._options.onDownloadProgress !== 'function') {
+		                        throw new TypeError('The `onDownloadProgress` option must be a function');
+		                    }
+		                    if (!supportsResponseStreams) {
+		                        throw new Error('Streams are not supported in your environment. `ReadableStream` is missing.');
+		                    }
+		                    return ky._stream(response.clone(), ky._options.onDownloadProgress);
+		                }
+		                return response;
+		            };
+		            const isRetriableMethod = ky._options.retry.methods.includes(ky.request.method.toLowerCase());
+		            const result = (isRetriableMethod ? ky._retry(fn) : fn());
+		            for (const [type, mimeType] of Object.entries(responseTypes)) {
+		                result[type] = async () => {
+		                    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+		                    ky.request.headers.set('accept', ky.request.headers.get('accept') || mimeType);
+		                    const awaitedResult = await result;
+		                    const response = awaitedResult.clone();
+		                    if (type === 'json') {
+		                        if (response.status === 204) {
+		                            return '';
+		                        }
+		                        const arrayBuffer = await response.clone().arrayBuffer();
+		                        const responseSize = arrayBuffer.byteLength;
+		                        if (responseSize === 0) {
+		                            return '';
+		                        }
+		                        if (options.parseJson) {
+		                            return options.parseJson(await response.text());
+		                        }
+		                    }
+		                    return response[type]();
+		                };
+		            }
+		            return result;
+		        }
 		        // eslint-disable-next-line complexity
 		        constructor(input, options = {}) {
-		            var _a, _b, _c;
-		            this._retryCount = 0;
+		            Object.defineProperty(this, "request", {
+		                enumerable: true,
+		                configurable: true,
+		                writable: true,
+		                value: void 0
+		            });
+		            Object.defineProperty(this, "abortController", {
+		                enumerable: true,
+		                configurable: true,
+		                writable: true,
+		                value: void 0
+		            });
+		            Object.defineProperty(this, "_retryCount", {
+		                enumerable: true,
+		                configurable: true,
+		                writable: true,
+		                value: 0
+		            });
+		            Object.defineProperty(this, "_input", {
+		                enumerable: true,
+		                configurable: true,
+		                writable: true,
+		                value: void 0
+		            });
+		            Object.defineProperty(this, "_options", {
+		                enumerable: true,
+		                configurable: true,
+		                writable: true,
+		                value: void 0
+		            });
 		            this._input = input;
 		            this._options = {
 		                // TODO: credentials can be removed when the spec change is implemented in all browsers. Context: https://www.chromestatus.com/feature/4539473312350208
@@ -349,13 +497,13 @@
 		                    beforeError: [],
 		                    afterResponse: [],
 		                }, options.hooks),
-		                method: normalizeRequestMethod((_a = options.method) !== null && _a !== void 0 ? _a : this._input.method),
+		                method: normalizeRequestMethod(options.method ?? this._input.method),
 		                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
 		                prefixUrl: String(options.prefixUrl || ''),
 		                retry: normalizeRetryOptions(options.retry),
 		                throwHttpErrors: options.throwHttpErrors !== false,
-		                timeout: typeof options.timeout === 'undefined' ? 10000 : options.timeout,
-		                fetch: (_b = options.fetch) !== null && _b !== void 0 ? _b : globalThis.fetch.bind(globalThis),
+		                timeout: options.timeout ?? 10000,
+		                fetch: options.fetch ?? globalThis.fetch.bind(globalThis),
 		            };
 		            if (typeof this._input !== 'string' && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
 		                throw new TypeError('`input` must be a string, URL, or Request');
@@ -372,12 +520,17 @@
 		            if (supportsAbortController) {
 		                this.abortController = new globalThis.AbortController();
 		                if (this._options.signal) {
+		                    const originalSignal = this._options.signal;
 		                    this._options.signal.addEventListener('abort', () => {
-		                        this.abortController.abort();
+		                        this.abortController.abort(originalSignal.reason);
 		                    });
 		                }
 		                this._options.signal = this.abortController.signal;
 		            }
+		            if (supportsRequestStreams) {
+		                // @ts-expect-error - Types are outdated.
+		                this._options.duplex = 'half';
+		            }
 		            this.request = new globalThis.Request(this._input, this._options);
 		            if (this._options.searchParams) {
 		                // eslint-disable-next-line unicorn/prevent-abbreviations
@@ -392,74 +545,15 @@
 		                    || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers['content-type'])) {
 		                    this.request.headers.delete('content-type');
 		                }
-		                this.request = new globalThis.Request(new globalThis.Request(url, this.request), this._options);
+		                // The spread of `this.request` is required as otherwise it misses the `duplex` option for some reason and throws.
+		                this.request = new globalThis.Request(new globalThis.Request(url, { ...this.request }), this._options);
 		            }
 		            if (this._options.json !== undefined) {
 		                this._options.body = JSON.stringify(this._options.json);
-		                this.request.headers.set('content-type', (_c = this._options.headers.get('content-type')) !== null && _c !== void 0 ? _c : 'application/json');
+		                this.request.headers.set('content-type', this._options.headers.get('content-type') ?? 'application/json');
 		                this.request = new globalThis.Request(this.request, { body: this._options.body });
 		            }
 		        }
-		        // eslint-disable-next-line @typescript-eslint/promise-function-async
-		        static create(input, options) {
-		            const ky = new Ky(input, options);
-		            const fn = async () => {
-		                if (ky._options.timeout > maxSafeTimeout) {
-		                    throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
-		                }
-		                // Delay the fetch so that body method shortcuts can set the Accept header
-		                await Promise.resolve();
-		                let response = await ky._fetch();
-		                for (const hook of ky._options.hooks.afterResponse) {
-		                    // eslint-disable-next-line no-await-in-loop
-		                    const modifiedResponse = await hook(ky.request, ky._options, ky._decorateResponse(response.clone()));
-		                    if (modifiedResponse instanceof globalThis.Response) {
-		                        response = modifiedResponse;
-		                    }
-		                }
-		                ky._decorateResponse(response);
-		                if (!response.ok && ky._options.throwHttpErrors) {
-		                    let error = new HTTPError(response, ky.request, ky._options);
-		                    for (const hook of ky._options.hooks.beforeError) {
-		                        // eslint-disable-next-line no-await-in-loop
-		                        error = await hook(error);
-		                    }
-		                    throw error;
-		                }
-		                // If `onDownloadProgress` is passed, it uses the stream API internally
-		                /* istanbul ignore next */
-		                if (ky._options.onDownloadProgress) {
-		                    if (typeof ky._options.onDownloadProgress !== 'function') {
-		                        throw new TypeError('The `onDownloadProgress` option must be a function');
-		                    }
-		                    if (!supportsStreams) {
-		                        throw new Error('Streams are not supported in your environment. `ReadableStream` is missing.');
-		                    }
-		                    return ky._stream(response.clone(), ky._options.onDownloadProgress);
-		                }
-		                return response;
-		            };
-		            const isRetriableMethod = ky._options.retry.methods.includes(ky.request.method.toLowerCase());
-		            const result = (isRetriableMethod ? ky._retry(fn) : fn());
-		            for (const [type, mimeType] of Object.entries(responseTypes)) {
-		                result[type] = async () => {
-		                    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-		                    ky.request.headers.set('accept', ky.request.headers.get('accept') || mimeType);
-		                    const awaitedResult = await result;
-		                    const response = awaitedResult.clone();
-		                    if (type === 'json') {
-		                        if (response.status === 204) {
-		                            return '';
-		                        }
-		                        if (options.parseJson) {
-		                            return options.parseJson(await response.text());
-		                        }
-		                    }
-		                    return response[type]();
-		                };
-		            }
-		            return result;
-		        }
 		        _calculateRetryDelay(error) {
 		            this._retryCount++;
 		            if (this._retryCount < this._options.retry.limit && !(error instanceof TimeoutError)) {
@@ -476,7 +570,7 @@
 		                        else {
 		                            after *= 1000;
 		                        }
-		                        if (typeof this._options.retry.maxRetryAfter !== 'undefined' && after > this._options.retry.maxRetryAfter) {
+		                        if (this._options.retry.maxRetryAfter !== undefined && after > this._options.retry.maxRetryAfter) {
 		                            return 0;
 		                        }
 		                        return after;
@@ -486,7 +580,7 @@
 		                    }
 		                }
 		                const BACKOFF_FACTOR = 0.3;
-		                return BACKOFF_FACTOR * (2 ** (this._retryCount - 1)) * 1000;
+		                return Math.min(this._options.retry.backoffLimit, BACKOFF_FACTOR * (2 ** (this._retryCount - 1)) * 1000);
 		            }
 		            return 0;
 		        }
@@ -499,12 +593,11 @@
 		        async _retry(fn) {
 		            try {
 		                return await fn();
-		                // eslint-disable-next-line @typescript-eslint/no-implicit-any-catch
 		            }
 		            catch (error) {
 		                const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
 		                if (ms !== 0 && this._retryCount > 0) {
-		                    await delay(ms);
+		                    await delay(ms, { signal: this._options.signal });
 		                    for (const hook of this._options.hooks.beforeRetry) {
 		                        // eslint-disable-next-line no-await-in-loop
 		                        const hookResult = await hook({
@@ -544,6 +637,16 @@
 		        _stream(response, onDownloadProgress) {
 		            const totalBytes = Number(response.headers.get('content-length')) || 0;
 		            let transferredBytes = 0;
+		            if (response.status === 204) {
+		                if (onDownloadProgress) {
+		                    onDownloadProgress({ percent: 1, totalBytes, transferredBytes }, new Uint8Array());
+		                }
+		                return new globalThis.Response(null, {
+		                    status: response.status,
+		                    statusText: response.statusText,
+		                    headers: response.headers,
+		                });
+		            }
 		            return new globalThis.Response(new globalThis.ReadableStream({
 		                async start(controller) {
 		                    const reader = response.body.getReader();
@@ -566,7 +669,11 @@
 		                    }
 		                    await read();
 		                },
-		            }));
+		            }), {
+		                status: response.status,
+		                statusText: response.statusText,
+		                headers: response.headers,
+		            });
 		        }
 		    }
 
@@ -587,14 +694,16 @@
 
 		    exports.HTTPError = HTTPError;
 		    exports.TimeoutError = TimeoutError;
-		    exports["default"] = ky;
+		    exports.default = ky;
 
 		    Object.defineProperty(exports, '__esModule', { value: true });
 
-		}));
-	} (ky$1, kyExports));
+		})); 
+	} (ky$1, ky$1.exports));
 
-	const urlHttp = lightweight;
+	var kyExports = ky$1.exports;
+
+	const urlHttp = lightweight$2;
 	const { flattie: flatten } = dist;
 
 	const factory = factory_1;
@@ -614,6 +723,7 @@
 
 	const got = async (url, opts) => {
 	  try {
+	    if (opts.retry > 0) opts.retry = opts.retry + 1;
 	    if (opts.timeout === undefined) opts.timeout = false;
 	    const response = await ky(url, opts);
 	    const body = await response.json();
@@ -639,15 +749,17 @@
 	  }
 	};
 
-	var browser = factory({
+	var lightweight = factory({
 	  MicrolinkError,
 	  urlHttp,
 	  got,
 	  flatten,
-	  VERSION: '0.10.33'
+	  VERSION: '0.10.35'
 	});
 
-	return browser;
+	var lightweight$1 = /*@__PURE__*/getDefaultExportFromCjs(lightweight);
+
+	return lightweight$1;
 
 }));
 //# sourceMappingURL=mql.js.map