@depup/got 14.6.6-depup.1

package/dist/source/core/errors.js

@@ -0,0 +1,147 @@
+import is from '@sindresorhus/is';
+// A hacky check to prevent circular references.
+function isRequest(x) {
+    return is.object(x) && '_onResponse' in x;
+}
+/**
+An error to be thrown when a request fails.
+Contains a `code` property with error class code, like `ECONNREFUSED`.
+*/
+export class RequestError extends Error {
+    name = 'RequestError';
+    code = 'ERR_GOT_REQUEST_ERROR';
+    input;
+    stack;
+    response;
+    request;
+    timings;
+    constructor(message, error, self) {
+        super(message, { cause: error });
+        Error.captureStackTrace(this, this.constructor);
+        if (error.code) {
+            this.code = error.code;
+        }
+        this.input = error.input;
+        if (isRequest(self)) {
+            Object.defineProperty(this, 'request', {
+                enumerable: false,
+                value: self,
+            });
+            Object.defineProperty(this, 'response', {
+                enumerable: false,
+                value: self.response,
+            });
+            this.options = self.options;
+        }
+        else {
+            this.options = self;
+        }
+        this.timings = this.request?.timings;
+        // Recover the original stacktrace
+        if (is.string(error.stack) && is.string(this.stack)) {
+            const indexOfMessage = this.stack.indexOf(this.message) + this.message.length;
+            const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').reverse();
+            const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message) + error.message.length).split('\n').reverse();
+            // Remove duplicated traces
+            while (errorStackTrace.length > 0 && errorStackTrace[0] === thisStackTrace[0]) {
+                thisStackTrace.shift();
+            }
+            this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.reverse().join('\n')}${errorStackTrace.reverse().join('\n')}`;
+        }
+    }
+}
+/**
+An error to be thrown when the server redirects you more than ten times.
+Includes a `response` property.
+*/
+export class MaxRedirectsError extends RequestError {
+    name = 'MaxRedirectsError';
+    code = 'ERR_TOO_MANY_REDIRECTS';
+    constructor(request) {
+        super(`Redirected ${request.options.maxRedirects} times. Aborting.`, {}, request);
+    }
+}
+/**
+An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304.
+Includes a `response` property.
+*/
+// TODO: Change `HTTPError<T = any>` to `HTTPError<T = unknown>` in the next major version to enforce type usage.
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export class HTTPError extends RequestError {
+    name = 'HTTPError';
+    code = 'ERR_NON_2XX_3XX_RESPONSE';
+    constructor(response) {
+        super(`Request failed with status code ${response.statusCode} (${response.statusMessage}): ${response.request.options.method} ${response.request.options.url.toString()}`, {}, response.request);
+    }
+}
+/**
+An error to be thrown when a cache method fails.
+For example, if the database goes down or there's a filesystem error.
+*/
+export class CacheError extends RequestError {
+    name = 'CacheError';
+    constructor(error, request) {
+        super(error.message, error, request);
+        if (this.code === 'ERR_GOT_REQUEST_ERROR') {
+            this.code = 'ERR_CACHE_ACCESS';
+        }
+    }
+}
+/**
+An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
+*/
+export class UploadError extends RequestError {
+    name = 'UploadError';
+    constructor(error, request) {
+        super(error.message, error, request);
+        if (this.code === 'ERR_GOT_REQUEST_ERROR') {
+            this.code = 'ERR_UPLOAD';
+        }
+    }
+}
+/**
+An error to be thrown when the request is aborted due to a timeout.
+Includes an `event` and `timings` property.
+*/
+export class TimeoutError extends RequestError {
+    name = 'TimeoutError';
+    timings;
+    event;
+    constructor(error, timings, request) {
+        super(error.message, error, request);
+        this.event = error.event;
+        this.timings = timings;
+    }
+}
+/**
+An error to be thrown when reading from response stream fails.
+*/
+export class ReadError extends RequestError {
+    name = 'ReadError';
+    constructor(error, request) {
+        super(error.message, error, request);
+        if (this.code === 'ERR_GOT_REQUEST_ERROR') {
+            this.code = 'ERR_READING_RESPONSE_STREAM';
+        }
+    }
+}
+/**
+An error which always triggers a new retry when thrown.
+*/
+export class RetryError extends RequestError {
+    name = 'RetryError';
+    code = 'ERR_RETRYING';
+    constructor(request) {
+        super('Retrying', {}, request);
+    }
+}
+/**
+An error to be thrown when the request is aborted by AbortController.
+*/
+export class AbortError extends RequestError {
+    name = 'AbortError';
+    code = 'ERR_ABORTED';
+    constructor(request) {
+        super('This operation was aborted.', {}, request);
+    }
+}

package/dist/source/core/index.d.ts

@@ -0,0 +1,192 @@
+import { Duplex } from 'node:stream';
+import { type ClientRequest } from 'node:http';
+import type { Socket } from 'node:net';
+import { type Timings } from './utils/timer.js';
+import Options, { type OptionsInit } from './options.js';
+import { type PlainResponse, type Response } from './response.js';
+import { RequestError } from './errors.js';
+type Error = NodeJS.ErrnoException;
+export type Progress = {
+    percent: number;
+    transferred: number;
+    total?: number;
+};
+export type GotEventFunction<T> = 
+/**
+`request` event to get the request object of the request.
+
+ __Tip__: You can use `request` event to abort requests.
+
+@example
+```
+import got from 'got';
+
+got.stream('https://github.com')
+    .on('request', request => setTimeout(() => request.destroy(), 50));
+```
+*/
+((name: 'request', listener: (request: ClientRequest) => void) => T)
+/**
+The `response` event to get the response object of the final request.
+*/
+ & (<R extends Response>(name: 'response', listener: (response: R) => void) => T)
+/**
+The `redirect` event to get the response object of a redirect. The second argument is options for the next request to the redirect location.
+*/
+ & (<R extends Response, N extends Options>(name: 'redirect', listener: (response: R, nextOptions: N) => void) => T)
+/**
+Progress events for uploading (sending a request) and downloading (receiving a response).
+The `progress` argument is an object like:
+
+```
+{
+    percent: 0.1,
+    transferred: 1024,
+    total: 10240
+}
+```
+
+If the `content-length` header is missing, `total` will be `undefined`.
+
+@example
+```
+import got from 'got';
+
+const response = await got('https://sindresorhus.com')
+    .on('downloadProgress', progress => {
+        // Report download progress
+    })
+    .on('uploadProgress', progress => {
+        // Report upload progress
+    });
+
+console.log(response);
+```
+*/
+ & ((name: 'uploadProgress' | 'downloadProgress', listener: (progress: Progress) => void) => T)
+/**
+To enable retrying on a Got stream, it is required to have a `retry` handler attached.
+
+When this event is emitted, you should reset the stream you were writing to and prepare the body again.
+
+See `got.options.retry` for more information.
+*/
+ & ((name: 'retry', listener: (retryCount: number, error: RequestError, createRetryStream: (options?: OptionsInit) => Request) => void) => T);
+export type RequestEvents<T> = {
+    on: GotEventFunction<T>;
+    once: GotEventFunction<T>;
+    off: GotEventFunction<T>;
+};
+type UrlType = ConstructorParameters<typeof Options>[0];
+type OptionsType = ConstructorParameters<typeof Options>[1];
+type DefaultsType = ConstructorParameters<typeof Options>[2];
+export default class Request extends Duplex implements RequestEvents<Request> {
+    ['constructor']: typeof Request;
+    _noPipe?: boolean;
+    options: Options;
+    response?: PlainResponse;
+    requestUrl?: URL;
+    redirectUrls: URL[];
+    retryCount: number;
+    _stopReading: boolean;
+    private _requestOptions;
+    private _stopRetry;
+    private _downloadedSize;
+    private _uploadedSize;
+    private readonly _pipedServerResponses;
+    private _request?;
+    private _responseSize?;
+    private _bodySize?;
+    private _unproxyEvents;
+    private _isFromCache?;
+    private _triggerRead;
+    private readonly _jobs;
+    private _cancelTimeouts;
+    private readonly _removeListeners;
+    private _nativeResponse?;
+    private _flushed;
+    private _aborted;
+    private _expectedContentLength?;
+    private _compressedBytesCount?;
+    private readonly _requestId;
+    private _requestInitialized;
+    constructor(url: UrlType, options?: OptionsType, defaults?: DefaultsType);
+    flush(): Promise<void>;
+    _beforeError(error: Error): void;
+    _read(): void;
+    _write(chunk: unknown, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    _destroy(error: Error | null, callback: (error: Error | null) => void): void;
+    pipe<T extends NodeJS.WritableStream>(destination: T, options?: {
+        end?: boolean;
+    }): T;
+    unpipe<T extends NodeJS.WritableStream>(destination: T): this;
+    private _checkContentLengthMismatch;
+    private _finalizeBody;
+    private _onResponseBase;
+    private _setRawBody;
+    private _onResponse;
+    private _onRequest;
+    private _asyncWrite;
+    private _sendBody;
+    private _prepareCache;
+    private _createCacheableRequest;
+    private _makeRequest;
+    private _error;
+    private _writeRequest;
+    /**
+    The remote IP address.
+    */
+    get ip(): string | undefined;
+    /**
+    Indicates whether the request has been aborted or not.
+    */
+    get isAborted(): boolean;
+    get socket(): Socket | undefined;
+    /**
+    Progress event for downloading (receiving a response).
+    */
+    get downloadProgress(): Progress;
+    /**
+    Progress event for uploading (sending a request).
+    */
+    get uploadProgress(): Progress;
+    /**
+    The object contains the following properties:
+
+    - `start` - Time when the request started.
+    - `socket` - Time when a socket was assigned to the request.
+    - `lookup` - Time when the DNS lookup finished.
+    - `connect` - Time when the socket successfully connected.
+    - `secureConnect` - Time when the socket securely connected.
+    - `upload` - Time when the request finished uploading.
+    - `response` - Time when the request fired `response` event.
+    - `end` - Time when the response fired `end` event.
+    - `error` - Time when the request fired `error` event.
+    - `abort` - Time when the request fired `abort` event.
+    - `phases`
+        - `wait` - `timings.socket - timings.start`
+        - `dns` - `timings.lookup - timings.socket`
+        - `tcp` - `timings.connect - timings.lookup`
+        - `tls` - `timings.secureConnect - timings.connect`
+        - `request` - `timings.upload - (timings.secureConnect || timings.connect)`
+        - `firstByte` - `timings.response - timings.upload`
+        - `download` - `timings.end - timings.response`
+        - `total` - `(timings.end || timings.error || timings.abort) - timings.start`
+
+    If something has not been measured yet, it will be `undefined`.
+
+    __Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
+    */
+    get timings(): Timings | undefined;
+    /**
+    Whether the response was retrieved from the cache.
+    */
+    get isFromCache(): boolean | undefined;
+    get reusedSocket(): boolean | undefined;
+    /**
+    Whether the stream is read-only. Returns `true` when `body`, `json`, or `form` options are provided.
+    */
+    get isReadonly(): boolean;
+}
+export {};