@cloudpss/fetch 0.5.53 → 0.6.0-alpha.1

package/src/proxy-from-env.ts

@@ -1,128 +0,0 @@
-/**
- * Ref:
- * @see https://about.gitlab.com/blog/2021/01/27/we-need-to-talk-no-proxy/
- */
-
-const DEFAULT_PORTS = Object.freeze({
-    'ftp:': 21,
-    'http:': 80,
-    'https:': 443,
-    'ws:': 80,
-    'wss:': 443,
-} as Record<string, number>);
-
-const NEVER_PROXY_PROTOCOL = new Set(['file:', 'data:', 'blob:']);
-
-/**
- * Get the value for an environment variable.
- */
-function getEnv(key: string): string {
-    return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || '';
-}
-
-/** parsed no proxy pattern */
-type Pattern = {
-    suffix: string;
-    port: number | undefined;
-};
-
-/** parse no proxy */
-function parseNoProxy(noProxy: string | undefined): boolean | Pattern[] {
-    if (!noProxy) return true;
-    noProxy = noProxy.trim().toLowerCase();
-    if (noProxy === '*') return false;
-
-    const records = noProxy.split(/[,\s]+/);
-    const patterns: Pattern[] = [];
-    let all = false;
-    for (const record of records) {
-        const trimmed = record.trim();
-        if (!trimmed) continue;
-        const parsed = /^(.+):(\d+)$/.exec(trimmed);
-        let parsedHostname = parsed ? parsed[1]! : trimmed;
-        if (parsedHostname.startsWith('*.')) {
-            parsedHostname = parsedHostname.slice(2);
-        } else if (parsedHostname.startsWith('.') || parsedHostname.startsWith('*')) {
-            parsedHostname = parsedHostname.slice(1);
-        }
-        const parsedPort = parsed ? Number.parseInt(parsed[2]!) : undefined;
-        if (!parsedHostname && !parsedPort) {
-            all = true;
-            break;
-        }
-        // deduplicate
-        if (patterns.some((item) => item.suffix === parsedHostname && item.port === parsedPort)) continue;
-        patterns.push({
-            suffix: parsedHostname,
-            port: parsedPort,
-        });
-    }
-    if (all) return false;
-    if (!patterns.length) return true;
-    return patterns;
-}
-
-let noProxyPatternsCache: boolean | readonly Pattern[];
-let noProxyCache: string;
-
-/**
- * Determines whether a given URL should be proxied.
- */
-function shouldProxy(hostname: string, port: number): boolean {
-    const noProxy = getEnv('npm_config_no_proxy') || getEnv('no_proxy');
-    let patterns;
-    if (noProxy === noProxyCache) {
-        patterns = noProxyPatternsCache;
-    } else {
-        noProxyCache = noProxy;
-        patterns = noProxyPatternsCache = parseNoProxy(noProxy);
-    }
-
-    if (typeof patterns == 'boolean') {
-        return patterns;
-    }
-    for (const pattern of patterns) {
-        if (pattern.port && pattern.port !== port) continue;
-        if (hostname === pattern.suffix) return false;
-        if (
-            hostname.length > pattern.suffix.length &&
-            hostname.endsWith(pattern.suffix) &&
-            hostname[hostname.length - pattern.suffix.length - 1] === '.'
-        )
-            return false;
-    }
-    return true;
-}
-
-/**
- * getProxyForUrl
- */
-export function getProxyForUrl(url: URL | string): string {
-    try {
-        if (typeof url === 'string') url = new URL(url);
-    } catch {
-        return '';
-    }
-
-    const { protocol, hostname, port } = url;
-    if (!hostname || NEVER_PROXY_PROTOCOL.has(protocol)) {
-        return '';
-    }
-
-    const portNumber = (port ? Number.parseInt(port) : DEFAULT_PORTS[protocol]!) || 0;
-    if (!shouldProxy(hostname, portNumber)) {
-        return ''; // Don't proxy URLs that match NO_PROXY.
-    }
-
-    const proto = protocol.slice(0, -1);
-    const proxy =
-        getEnv('npm_config_' + proto + '_proxy') ||
-        getEnv(proto + '_proxy') ||
-        getEnv('npm_config_proxy') ||
-        getEnv('all_proxy');
-    if (proxy && !proxy.includes('://')) {
-        // Missing scheme in proxy, default to the requested URL's scheme.
-        return proto + '://' + proxy;
-    }
-    return proxy;
-}

package/src/undici.d.ts

@@ -1,30 +0,0 @@
-/* eslint-disable jsdoc/require-jsdoc */
-
-declare module 'undici/lib/core/symbols.js' {
-    const kClose: unique symbol;
-    const kDestroy: unique symbol;
-    const kDispatch: unique symbol;
-
-    export = {
-        kClose,
-        kDestroy,
-        kDispatch,
-    } as const;
-}
-
-declare module 'undici/lib/dispatcher/dispatcher-base.js' {
-    import { Dispatcher } from 'undici';
-    import symbols from 'undici/lib/core/symbols.js';
-    class DispatcherBase extends Dispatcher {
-        // Should not error.
-        // eslint-disable-next-line @typescript-eslint/unified-signatures
-        protected [symbols.kDestroy](err?: Error | null): Promise<void>;
-        // Should not error.
-        protected [symbols.kClose](): Promise<void>;
-        protected [symbols.kDispatch](
-            options: Dispatcher.DispatchOptions,
-            handler: Dispatcher.DispatchHandlers,
-        ): boolean;
-    }
-    export = DispatcherBase;
-}

package/tests/e2e.js

@@ -1,75 +0,0 @@
-import * as Index from '../dist/index.js';
-import * as Node from '../dist/impl-node.js';
-import * as Browser from '../dist/impl-browser.js';
-
-describe('exports defined', () => {
-    it('index', () => {
-        expect(typeof Index.File).toBe('function');
-        expect(typeof Index.FormData).toBe('function');
-        expect(typeof Index.Headers).toBe('function');
-        expect(typeof Index.Request).toBe('function');
-        expect(typeof Index.Response).toBe('function');
-        expect(typeof Index.WebSocket).toBe('function');
-        expect(typeof Index.fetch).toBe('function');
-        expect(Index.default).toBe(Index.fetch);
-    });
-    it('node', () => {
-        expect(typeof Node.File).toBe('function');
-        expect(typeof Node.FormData).toBe('function');
-        expect(typeof Node.Headers).toBe('function');
-        expect(typeof Node.Request).toBe('function');
-        expect(typeof Node.Response).toBe('function');
-        expect(typeof Node.WebSocket).toBe('function');
-        expect(typeof Node.fetch).toBe('function');
-        expect(Node.default).toBe(Node.fetch);
-    });
-    it('browser', () => {
-        expect(typeof Browser.File).toBe('function');
-        expect(typeof Browser.FormData).toBe('function');
-        expect(typeof Browser.Headers).toBe('function');
-        expect(typeof Browser.Request).toBe('function');
-        expect(typeof Browser.Response).toBe('function');
-        // expect(typeof Browser.WebSocket).toBe('function');
-        expect(typeof Browser.fetch).toBe('function');
-        expect(Browser.default).toBe(Browser.fetch);
-    });
-});
-
-describe('node fetch works', () => {
-    it('can visit http://downloads.cloudpss.net', async () => {
-        const resp = await Node.fetch('http://downloads.cloudpss.net', {
-            headers: { connection: 'close' },
-        });
-        expect(resp).toBeInstanceOf(Node.Response);
-        expect(resp.url).toBe('https://downloads.cloudpss.net/');
-        const data = await resp.json();
-        expect(data).toEqual(
-            expect.objectContaining({
-                name: '/',
-                path: '/',
-                items: expect.any(Array),
-                can_go_up: false,
-            }),
-        );
-    });
-
-    it('can visit via proxy', async () => {
-        const resp = await Node.fetch('http://api.github.com/repos/CloudPSS/docs', {
-            headers: { connection: 'close' },
-        });
-        expect(resp).toBeInstanceOf(Node.Response);
-        expect(resp.url).toBe('https://api.github.com/repos/CloudPSS/docs');
-        const data = await resp.json();
-        expect(data).toEqual(
-            expect.objectContaining({
-                id: expect.any(Number),
-                name: expect.any(String),
-                full_name: expect.any(String),
-                owner: expect.objectContaining({
-                    id: expect.any(Number),
-                    login: expect.any(String),
-                }),
-            }),
-        );
-    });
-});