@depup/got 14.6.6-depup.1

package/dist/source/core/utils/timer.js

@@ -0,0 +1,162 @@
+import { errorMonitor } from 'node:events';
+import { types } from 'node:util';
+import deferToConnect from './defer-to-connect.js';
+const timer = (request) => {
+    if (request.timings) {
+        return request.timings;
+    }
+    const timings = {
+        start: Date.now(),
+        socket: undefined,
+        lookup: undefined,
+        connect: undefined,
+        secureConnect: undefined,
+        upload: undefined,
+        response: undefined,
+        end: undefined,
+        error: undefined,
+        abort: undefined,
+        phases: {
+            wait: undefined,
+            dns: undefined,
+            tcp: undefined,
+            tls: undefined,
+            request: undefined,
+            firstByte: undefined,
+            download: undefined,
+            total: undefined,
+        },
+    };
+    request.timings = timings;
+    const handleError = (origin) => {
+        origin.once(errorMonitor, () => {
+            timings.error = Date.now();
+            timings.phases.total = timings.error - timings.start;
+        });
+    };
+    handleError(request);
+    const onAbort = () => {
+        timings.abort = Date.now();
+        timings.phases.total = timings.abort - timings.start;
+    };
+    request.prependOnceListener('abort', onAbort);
+    const onSocket = (socket) => {
+        timings.socket = Date.now();
+        timings.phases.wait = timings.socket - timings.start;
+        if (types.isProxy(socket)) {
+            // HTTP/2: The socket is a proxy, so connection events won't fire.
+            // We can't measure connection timings, so leave them undefined.
+            // This prevents NaN in phases.request calculation.
+            return;
+        }
+        // Check if socket is already connected (reused from connection pool)
+        const socketAlreadyConnected = socket.writable && !socket.connecting;
+        if (socketAlreadyConnected) {
+            // Socket reuse detected: the socket was already connected from a previous request.
+            // For reused sockets, set all connection timestamps to socket time since no new
+            // connection was made for THIS request. But preserve phase durations from the
+            // original connection so they're not lost.
+            timings.lookup = timings.socket;
+            timings.connect = timings.socket;
+            if (socket.__initial_connection_timings__) {
+                // Restore the phase timings from the initial connection
+                timings.phases.dns = socket.__initial_connection_timings__.dnsPhase;
+                timings.phases.tcp = socket.__initial_connection_timings__.tcpPhase;
+                timings.phases.tls = socket.__initial_connection_timings__.tlsPhase;
+                // Set secureConnect timestamp if there was TLS
+                if (timings.phases.tls !== undefined) {
+                    timings.secureConnect = timings.socket;
+                }
+            }
+            else {
+                // Socket reused but no initial timings stored (e.g., from external code)
+                // Set phases to 0
+                timings.phases.dns = 0;
+                timings.phases.tcp = 0;
+            }
+            return;
+        }
+        const lookupListener = () => {
+            timings.lookup = Date.now();
+            timings.phases.dns = timings.lookup - timings.socket;
+        };
+        socket.prependOnceListener('lookup', lookupListener);
+        deferToConnect(socket, {
+            connect() {
+                timings.connect = Date.now();
+                if (timings.lookup === undefined) {
+                    // No DNS lookup occurred (e.g., connecting to an IP address directly)
+                    // Set lookup to socket time (no time elapsed for DNS)
+                    socket.removeListener('lookup', lookupListener);
+                    timings.lookup = timings.socket;
+                    timings.phases.dns = 0;
+                }
+                timings.phases.tcp = timings.connect - timings.lookup;
+                // If lookup and connect happen at the EXACT same time (tcp = 0),
+                // DNS was served from cache and the dns value is just event loop overhead.
+                // Set dns to 0 to indicate no actual DNS resolution occurred.
+                // Fixes https://github.com/szmarczak/http-timer/issues/35
+                if (timings.phases.tcp === 0 && timings.phases.dns && timings.phases.dns > 0) {
+                    timings.phases.dns = 0;
+                }
+                // Store connection phase timings on socket for potential reuse
+                if (!socket.__initial_connection_timings__) {
+                    socket.__initial_connection_timings__ = {
+                        dnsPhase: timings.phases.dns,
+                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TypeScript can't prove this is defined due to callback structure
+                        tcpPhase: timings.phases.tcp,
+                    };
+                }
+            },
+            secureConnect() {
+                timings.secureConnect = Date.now();
+                timings.phases.tls = timings.secureConnect - timings.connect;
+                // Update stored timings with TLS phase timing
+                if (socket.__initial_connection_timings__) {
+                    socket.__initial_connection_timings__.tlsPhase = timings.phases.tls;
+                }
+            },
+        });
+    };
+    if (request.socket) {
+        onSocket(request.socket);
+    }
+    else {
+        request.prependOnceListener('socket', onSocket);
+    }
+    const onUpload = () => {
+        timings.upload = Date.now();
+        // Calculate request phase if we have connection timings
+        const secureOrConnect = timings.secureConnect ?? timings.connect;
+        if (secureOrConnect !== undefined) {
+            timings.phases.request = timings.upload - secureOrConnect;
+        }
+        // If both are undefined (HTTP/2), phases.request stays undefined (not NaN)
+    };
+    if (request.writableFinished) {
+        onUpload();
+    }
+    else {
+        request.prependOnceListener('finish', onUpload);
+    }
+    request.prependOnceListener('response', (response) => {
+        timings.response = Date.now();
+        timings.phases.firstByte = timings.response - timings.upload;
+        response.timings = timings;
+        handleError(response);
+        response.prependOnceListener('end', () => {
+            request.off('abort', onAbort);
+            response.off('aborted', onAbort);
+            if (timings.phases.total !== undefined) {
+                // Aborted or errored
+                return;
+            }
+            timings.end = Date.now();
+            timings.phases.download = timings.end - timings.response;
+            timings.phases.total = timings.end - timings.start;
+        });
+        response.prependOnceListener('aborted', onAbort);
+    });
+    return timings;
+};
+export default timer;

package/dist/source/core/utils/unhandle.d.ts

@@ -0,0 +1,10 @@
+import type { EventEmitter } from 'node:events';
+type Origin = EventEmitter;
+type Event = string | symbol;
+type AnyFunction = (...arguments_: any[]) => void;
+type Unhandler = {
+    once: (origin: Origin, event: Event, function_: AnyFunction) => void;
+    unhandleAll: () => void;
+};
+export default function unhandle(): Unhandler;
+export {};

package/dist/source/core/utils/unhandle.js

@@ -0,0 +1,20 @@
+// When attaching listeners, it's very easy to forget about them.
+// Especially if you do error handling and set timeouts.
+// So instead of checking if it's proper to throw an error on every timeout ever,
+// use this simple tool which will remove all listeners you have attached.
+export default function unhandle() {
+    const handlers = [];
+    return {
+        once(origin, event, function_) {
+            origin.once(event, function_);
+            handlers.push({ origin, event, fn: function_ });
+        },
+        unhandleAll() {
+            for (const handler of handlers) {
+                const { origin, event, fn } = handler;
+                origin.removeListener(event, fn);
+            }
+            handlers.length = 0;
+        },
+    };
+}

package/dist/source/core/utils/url-to-options.d.ts

@@ -0,0 +1,14 @@
+import type { UrlWithStringQuery } from 'node:url';
+export type LegacyUrlOptions = {
+    protocol: string;
+    hostname: string;
+    host: string;
+    hash: string | null;
+    search: string | null;
+    pathname: string;
+    href: string;
+    path: string;
+    port?: number;
+    auth?: string;
+};
+export default function urlToOptions(url: URL | UrlWithStringQuery): LegacyUrlOptions;

package/dist/source/core/utils/url-to-options.js

@@ -0,0 +1,22 @@
+import is from '@sindresorhus/is';
+export default function urlToOptions(url) {
+    // Cast to URL
+    url = url;
+    const options = {
+        protocol: url.protocol,
+        hostname: is.string(url.hostname) && url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname,
+        host: url.host,
+        hash: url.hash,
+        search: url.search,
+        pathname: url.pathname,
+        href: url.href,
+        path: `${url.pathname || ''}${url.search || ''}`,
+    };
+    if (is.string(url.port) && url.port.length > 0) {
+        options.port = Number(url.port);
+    }
+    if (url.username || url.password) {
+        options.auth = `${url.username || ''}:${url.password || ''}`;
+    }
+    return options;
+}

package/dist/source/core/utils/weakable-map.d.ts

@@ -0,0 +1,7 @@
+export default class WeakableMap<K, V> {
+    weakMap: WeakMap<Record<string, unknown>, V>;
+    map: Map<K, V>;
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+}

package/dist/source/core/utils/weakable-map.js

@@ -0,0 +1,24 @@
+export default class WeakableMap {
+    weakMap = new WeakMap();
+    map = new Map();
+    set(key, value) {
+        if (typeof key === 'object') {
+            this.weakMap.set(key, value);
+        }
+        else {
+            this.map.set(key, value);
+        }
+    }
+    get(key) {
+        if (typeof key === 'object') {
+            return this.weakMap.get(key);
+        }
+        return this.map.get(key);
+    }
+    has(key) {
+        if (typeof key === 'object') {
+            return this.weakMap.has(key);
+        }
+        return this.map.has(key);
+    }
+}

package/dist/source/create.d.ts

@@ -0,0 +1,3 @@
+import type { Got, InstanceDefaults } from './types.js';
+declare const create: (defaults: InstanceDefaults) => Got;
+export default create;

package/dist/source/create.js

@@ -0,0 +1,188 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import is, { assert } from '@sindresorhus/is';
+import asPromise from './as-promise/index.js';
+import Request from './core/index.js';
+import Options from './core/options.js';
+const isGotInstance = (value) => is.function(value);
+const aliases = [
+    'get',
+    'post',
+    'put',
+    'patch',
+    'head',
+    'delete',
+];
+const create = (defaults) => {
+    defaults = {
+        options: new Options(undefined, undefined, defaults.options),
+        handlers: [...defaults.handlers],
+        mutableDefaults: defaults.mutableDefaults,
+    };
+    Object.defineProperty(defaults, 'mutableDefaults', {
+        enumerable: true,
+        configurable: false,
+        writable: false,
+    });
+    // Got interface
+    const got = ((url, options, defaultOptions = defaults.options) => {
+        const request = new Request(url, options, defaultOptions);
+        let promise;
+        const lastHandler = (normalized) => {
+            // Note: `options` is `undefined` when `new Options(...)` fails
+            request.options = normalized;
+            request._noPipe = !normalized?.isStream;
+            void request.flush();
+            if (normalized?.isStream) {
+                return request;
+            }
+            promise ||= asPromise(request);
+            return promise;
+        };
+        let iteration = 0;
+        const iterateHandlers = (newOptions) => {
+            const handler = defaults.handlers[iteration++] ?? lastHandler;
+            const result = handler(newOptions, iterateHandlers);
+            if (is.promise(result) && !request.options?.isStream) {
+                promise ||= asPromise(request);
+                if (result !== promise) {
+                    const descriptors = Object.getOwnPropertyDescriptors(promise);
+                    for (const key in descriptors) {
+                        if (key in result) {
+                            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                            delete descriptors[key];
+                        }
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    Object.defineProperties(result, descriptors);
+                    result.cancel = promise.cancel;
+                }
+            }
+            return result;
+        };
+        return iterateHandlers(request.options);
+    });
+    got.extend = (...instancesOrOptions) => {
+        const options = new Options(undefined, undefined, defaults.options);
+        const handlers = [...defaults.handlers];
+        let mutableDefaults;
+        for (const value of instancesOrOptions) {
+            if (isGotInstance(value)) {
+                options.merge(value.defaults.options);
+                handlers.push(...value.defaults.handlers);
+                mutableDefaults = value.defaults.mutableDefaults;
+            }
+            else {
+                options.merge(value);
+                if (value.handlers) {
+                    handlers.push(...value.handlers);
+                }
+                mutableDefaults = value.mutableDefaults;
+            }
+        }
+        return create({
+            options,
+            handlers,
+            mutableDefaults: Boolean(mutableDefaults),
+        });
+    };
+    // Pagination
+    const paginateEach = (async function* (url, options) {
+        let normalizedOptions = new Options(url, options, defaults.options);
+        normalizedOptions.resolveBodyOnly = false;
+        const { pagination } = normalizedOptions;
+        assert.function(pagination.transform);
+        assert.function(pagination.shouldContinue);
+        assert.function(pagination.filter);
+        assert.function(pagination.paginate);
+        assert.number(pagination.countLimit);
+        assert.number(pagination.requestLimit);
+        assert.number(pagination.backoff);
+        const allItems = [];
+        let { countLimit } = pagination;
+        let numberOfRequests = 0;
+        while (numberOfRequests < pagination.requestLimit) {
+            if (numberOfRequests !== 0) {
+                // eslint-disable-next-line no-await-in-loop
+                await delay(pagination.backoff);
+            }
+            // eslint-disable-next-line no-await-in-loop
+            const response = (await got(undefined, undefined, normalizedOptions));
+            // eslint-disable-next-line no-await-in-loop
+            const parsed = await pagination.transform(response);
+            const currentItems = [];
+            assert.array(parsed);
+            for (const item of parsed) {
+                if (pagination.filter({ item, currentItems, allItems })) {
+                    if (!pagination.shouldContinue({ item, currentItems, allItems })) {
+                        return;
+                    }
+                    yield item;
+                    if (pagination.stackAllItems) {
+                        allItems.push(item);
+                    }
+                    currentItems.push(item);
+                    if (--countLimit <= 0) {
+                        return;
+                    }
+                }
+            }
+            const optionsToMerge = pagination.paginate({
+                response,
+                currentItems,
+                allItems,
+            });
+            if (optionsToMerge === false) {
+                return;
+            }
+            if (optionsToMerge === response.request.options) {
+                normalizedOptions = response.request.options;
+            }
+            else {
+                normalizedOptions.merge(optionsToMerge);
+                try {
+                    assert.any([is.urlInstance, is.undefined], optionsToMerge.url);
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        error.message = `Option 'pagination.paginate.url': ${error.message}`;
+                    }
+                    throw error;
+                }
+                if (optionsToMerge.url !== undefined) {
+                    normalizedOptions.prefixUrl = '';
+                    normalizedOptions.url = optionsToMerge.url;
+                }
+            }
+            numberOfRequests++;
+        }
+    });
+    got.paginate = paginateEach;
+    got.paginate.all = (async (url, options) => {
+        const results = [];
+        for await (const item of paginateEach(url, options)) {
+            results.push(item);
+        }
+        return results;
+    });
+    // For those who like very descriptive names
+    got.paginate.each = paginateEach;
+    // Stream API
+    got.stream = ((url, options) => got(url, { ...options, isStream: true }));
+    // Shortcuts
+    for (const method of aliases) {
+        got[method] = ((url, options) => got(url, { ...options, method }));
+        got.stream[method] = ((url, options) => got(url, { ...options, method, isStream: true }));
+    }
+    if (!defaults.mutableDefaults) {
+        Object.freeze(defaults.handlers);
+        defaults.options.freeze();
+    }
+    Object.defineProperty(got, 'defaults', {
+        value: defaults,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    });
+    return got;
+};
+export default create;

package/dist/source/index.d.ts

@@ -0,0 +1,16 @@
+declare const got: import("./types.js").Got;
+export default got;
+export { got };
+export { default as Options } from './core/options.js';
+export * from './core/options.js';
+export * from './core/response.js';
+export type { default as Request } from './core/index.js';
+export * from './core/index.js';
+export * from './core/errors.js';
+export * from './core/diagnostics-channel.js';
+export type { Delays } from './core/timed-out.js';
+export { default as calculateRetryDelay } from './core/calculate-retry-delay.js';
+export * from './as-promise/types.js';
+export * from './types.js';
+export { default as create } from './create.js';
+export { default as parseLinkHeader } from './core/parse-link-header.js';

package/dist/source/index.js

@@ -0,0 +1,22 @@
+import create from './create.js';
+import Options from './core/options.js';
+const defaults = {
+    options: new Options(),
+    handlers: [],
+    mutableDefaults: false,
+};
+const got = create(defaults);
+export default got;
+// TODO: Remove this in the next major version.
+export { got };
+export { default as Options } from './core/options.js';
+export * from './core/options.js';
+export * from './core/response.js';
+export * from './core/index.js';
+export * from './core/errors.js';
+export * from './core/diagnostics-channel.js';
+export { default as calculateRetryDelay } from './core/calculate-retry-delay.js';
+export * from './as-promise/types.js';
+export * from './types.js';
+export { default as create } from './create.js';
+export { default as parseLinkHeader } from './core/parse-link-header.js';