初始化项目

15815213711

2024-08-26 67b8b6731811983447e053d4396b3708c14dfe3c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
'use strict';
const urlLib = require('url');
const http = require('http');
const PCancelable = require('p-cancelable');
const is = require('@sindresorhus/is');
 
class GotError extends Error {
    constructor(message, error, options) {
        super(message);
        Error.captureStackTrace(this, this.constructor);
        this.name = 'GotError';
 
        if (!is.undefined(error.code)) {
            this.code = error.code;
        }
 
        Object.assign(this, {
            host: options.host,
            hostname: options.hostname,
            method: options.method,
            path: options.path,
            socketPath: options.socketPath,
            protocol: options.protocol,
            url: options.href,
            gotOptions: options
        });
    }
}
 
module.exports.GotError = GotError;
 
module.exports.CacheError = class extends GotError {
    constructor(error, options) {
        super(error.message, error, options);
        this.name = 'CacheError';
    }
};
 
module.exports.RequestError = class extends GotError {
    constructor(error, options) {
        super(error.message, error, options);
        this.name = 'RequestError';
    }
};
 
module.exports.ReadError = class extends GotError {
    constructor(error, options) {
        super(error.message, error, options);
        this.name = 'ReadError';
    }
};
 
module.exports.ParseError = class extends GotError {
    constructor(error, statusCode, options, data) {
        super(`${error.message} in "${urlLib.format(options)}": \n${data.slice(0, 77)}...`, error, options);
        this.name = 'ParseError';
        this.statusCode = statusCode;
        this.statusMessage = http.STATUS_CODES[this.statusCode];
    }
};
 
module.exports.HTTPError = class extends GotError {
    constructor(response, options) {
        const {statusCode} = response;
        let {statusMessage} = response;
 
        if (statusMessage) {
            statusMessage = statusMessage.replace(/\r?\n/g, ' ').trim();
        } else {
            statusMessage = http.STATUS_CODES[statusCode];
        }
 
        super(`Response code ${statusCode} (${statusMessage})`, {}, options);
        this.name = 'HTTPError';
        this.statusCode = statusCode;
        this.statusMessage = statusMessage;
        this.headers = response.headers;
        this.body = response.body;
    }
};
 
module.exports.MaxRedirectsError = class extends GotError {
    constructor(statusCode, redirectUrls, options) {
        super('Redirected 10 times. Aborting.', {}, options);
        this.name = 'MaxRedirectsError';
        this.statusCode = statusCode;
        this.statusMessage = http.STATUS_CODES[this.statusCode];
        this.redirectUrls = redirectUrls;
    }
};
 
module.exports.UnsupportedProtocolError = class extends GotError {
    constructor(options) {
        super(`Unsupported protocol "${options.protocol}"`, {}, options);
        this.name = 'UnsupportedProtocolError';
    }
};
 
module.exports.TimeoutError = class extends GotError {
    constructor(error, options) {
        super(error.message, {code: 'ETIMEDOUT'}, options);
        this.name = 'TimeoutError';
        this.event = error.event;
    }
};
 
module.exports.CancelError = PCancelable.CancelError;