mirror of
https://github.com/shimataro/ssh-key-action.git
synced 2025-06-19 22:52:10 +10:00
* first action!
This commit is contained in:
shimataro
parent
8deacc95b1
commit
4e3aad3b7f
3750 changed files with 1155519 additions and 0 deletions
252
node_modules/node-fetch-npm/CHANGELOG.md
generated
vendored
Normal file
252
node_modules/node-fetch-npm/CHANGELOG.md
generated
vendored
Normal file
|
|
@ -0,0 +1,252 @@
|
|||
# Change Log
|
||||
|
||||
All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
|
||||
|
||||
<a name="2.0.2"></a>
|
||||
## [2.0.2](https://github.com/npm/node-fetch-npm/compare/v2.0.1...v2.0.2) (2017-08-15)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **json:** replace jju with a custom syntax error reporter ([#6](https://github.com/npm/node-fetch-npm/issues/6)) ([84d169c](https://github.com/npm/node-fetch-npm/commit/84d169c))
|
||||
|
||||
|
||||
|
||||
<a name="2.0.1"></a>
|
||||
## [2.0.1](https://github.com/npm/node-fetch-npm/compare/v2.0.0...v2.0.1) (2017-05-24)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **json:** improve JSON parse error reporting ([1c810df](https://github.com/npm/node-fetch-npm/commit/1c810df))
|
||||
|
||||
|
||||
|
||||
<a name="2.0.0"></a>
|
||||
# [2.0.0](https://github.com/npm/node-fetch-npm/compare/v1.0.1...v2.0.0) (2017-05-06)
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* **version:** force bump to 2.0 ([39c5d50](https://github.com/npm/node-fetch-npm/commit/39c5d50))
|
||||
|
||||
|
||||
### BREAKING CHANGES
|
||||
|
||||
* **version:** tooling got confused, so hitting 2.0.0 for reals now
|
||||
|
||||
|
||||
|
||||
<a name="1.0.1"></a>
|
||||
## [1.0.1](https://github.com/npm/node-fetch-npm/compare/v1.0.0...v1.0.1) (2017-05-06)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **redirect:** Remove authorization header on redirect to different host ([#2](https://github.com/npm/node-fetch-npm/issues/2)) ([273260e](https://github.com/npm/node-fetch-npm/commit/273260e))
|
||||
|
||||
|
||||
|
||||
<a name="1.0.0"></a>
|
||||
# [1.0.0](https://github.com/npm/node-fetch-npm/compare/v2.0.0-alpha.3...v1.0.0) (2017-04-26)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **proj:** initial fork changes ([0a190a8](https://github.com/npm/node-fetch-npm/commit/0a190a8))
|
||||
|
||||
|
||||
### BREAKING CHANGES
|
||||
|
||||
* **proj:** this renames the library altogether
|
||||
|
||||
|
||||
|
||||
|
||||
Changelog
|
||||
=========
|
||||
|
||||
|
||||
# 2.x release
|
||||
|
||||
## v2.0.0
|
||||
|
||||
This is a major release. Check [our upgrade guide](https://github.com/bitinn/node-fetch/blob/master/UPGRADE-GUIDE.md) for an overview on some key differences between v1 and v2.
|
||||
|
||||
### General changes
|
||||
|
||||
- Major: Node.js 0.10.x and 0.12.x support is dropped
|
||||
- Major: `require('node-fetch/lib/response')` etc. is now unsupported; use `require('node-fetch').Response` or ES6 module imports
|
||||
- Enhance: start testing on Node.js 4, 6, 7
|
||||
- Enhance: use Rollup to produce a distributed bundle (less memory overhead and faster startup)
|
||||
- Enhance: make `Object.prototype.toString()` on Headers, Requests, and Responses return correct class strings
|
||||
- Other: rewrite in ES2015 using Babel
|
||||
- Other: use Codecov for code coverage tracking
|
||||
|
||||
### HTTP requests
|
||||
|
||||
- Major: overwrite user's `Content-Length` if we can be sure our information is correct (per spec)
|
||||
- Fix: support WHATWG URL objects, created by `whatwg-url` package or `require('url').URL` in Node.js 7+
|
||||
|
||||
### Response and Request classes
|
||||
|
||||
- Major: `response.text()` no longer attempts to detect encoding, instead always opting for UTF-8 (per spec); use `response.textConverted()` for the v1 behavior
|
||||
- Major: make `response.json()` throw error instead of returning an empty object on 204 no-content respose (per spec; reverts behavior changed in v1.6.2)
|
||||
- Major: internal methods are no longer exposed
|
||||
- Major: throw error when a `GET` or `HEAD` Request is constructed with a non-null body (per spec)
|
||||
- Enhance: add `response.arrayBuffer()` (also applies to Requests)
|
||||
- Enhance: add experimental `response.blob()` (also applies to Requests)
|
||||
- Fix: fix Request and Response with `null` body
|
||||
|
||||
### Headers class
|
||||
|
||||
- Major: remove `headers.getAll()`; make `get()` return all headers delimited by commas (per spec)
|
||||
- Enhance: make Headers iterable
|
||||
- Enhance: make Headers constructor accept an array of tuples
|
||||
- Enhance: make sure header names and values are valid in HTTP
|
||||
- Fix: coerce Headers prototype function parameters to strings, where applicable
|
||||
|
||||
### Documentation
|
||||
|
||||
- Enhance: more comprehensive API docs
|
||||
- Enhance: add a list of default headers in README
|
||||
|
||||
|
||||
# 1.x release
|
||||
|
||||
## v1.6.3
|
||||
|
||||
- Enhance: error handling document to explain `FetchError` design
|
||||
- Fix: support `form-data` 2.x releases (requires `form-data` >= 2.1.0)
|
||||
|
||||
## v1.6.2
|
||||
|
||||
- Enhance: minor document update
|
||||
- Fix: response.json() returns empty object on 204 no-content response instead of throwing a syntax error
|
||||
|
||||
## v1.6.1
|
||||
|
||||
- Fix: if `res.body` is a non-stream non-formdata object, we will call `body.toString` and send it as a string
|
||||
- Fix: `counter` value is incorrectly set to `follow` value when wrapping Request instance
|
||||
- Fix: documentation update
|
||||
|
||||
## v1.6.0
|
||||
|
||||
- Enhance: added `res.buffer()` api for convenience, it returns body as a Node.js buffer
|
||||
- Enhance: better old server support by handling raw deflate response
|
||||
- Enhance: skip encoding detection for non-HTML/XML response
|
||||
- Enhance: minor document update
|
||||
- Fix: HEAD request doesn't need decompression, as body is empty
|
||||
- Fix: `req.body` now accepts a Node.js buffer
|
||||
|
||||
## v1.5.3
|
||||
|
||||
- Fix: handle 204 and 304 responses when body is empty but content-encoding is gzip/deflate
|
||||
- Fix: allow resolving response and cloned response in any order
|
||||
- Fix: avoid setting `content-length` when `form-data` body use streams
|
||||
- Fix: send DELETE request with content-length when body is present
|
||||
- Fix: allow any url when calling new Request, but still reject non-http(s) url in fetch
|
||||
|
||||
## v1.5.2
|
||||
|
||||
- Fix: allow node.js core to handle keep-alive connection pool when passing a custom agent
|
||||
|
||||
## v1.5.1
|
||||
|
||||
- Fix: redirect mode `manual` should work even when there is no redirection or broken redirection
|
||||
|
||||
## v1.5.0
|
||||
|
||||
- Enhance: rejected promise now use custom `Error` (thx to @pekeler)
|
||||
- Enhance: `FetchError` contains `err.type` and `err.code`, allows for better error handling (thx to @pekeler)
|
||||
- Enhance: basic support for redirect mode `manual` and `error`, allows for location header extraction (thx to @jimmywarting for the initial PR)
|
||||
|
||||
## v1.4.1
|
||||
|
||||
- Fix: wrapping Request instance with FormData body again should preserve the body as-is
|
||||
|
||||
## v1.4.0
|
||||
|
||||
- Enhance: Request and Response now have `clone` method (thx to @kirill-konshin for the initial PR)
|
||||
- Enhance: Request and Response now have proper string and buffer body support (thx to @kirill-konshin)
|
||||
- Enhance: Body constructor has been refactored out (thx to @kirill-konshin)
|
||||
- Enhance: Headers now has `forEach` method (thx to @tricoder42)
|
||||
- Enhance: back to 100% code coverage
|
||||
- Fix: better form-data support (thx to @item4)
|
||||
- Fix: better character encoding detection under chunked encoding (thx to @dsuket for the initial PR)
|
||||
|
||||
## v1.3.3
|
||||
|
||||
- Fix: make sure `Content-Length` header is set when body is string for POST/PUT/PATCH requests
|
||||
- Fix: handle body stream error, for cases such as incorrect `Content-Encoding` header
|
||||
- Fix: when following certain redirects, use `GET` on subsequent request per Fetch Spec
|
||||
- Fix: `Request` and `Response` constructors now parse headers input using `Headers`
|
||||
|
||||
## v1.3.2
|
||||
|
||||
- Enhance: allow auto detect of form-data input (no `FormData` spec on node.js, this is form-data specific feature)
|
||||
|
||||
## v1.3.1
|
||||
|
||||
- Enhance: allow custom host header to be set (server-side only feature, as it's a forbidden header on client-side)
|
||||
|
||||
## v1.3.0
|
||||
|
||||
- Enhance: now `fetch.Request` is exposed as well
|
||||
|
||||
## v1.2.1
|
||||
|
||||
- Enhance: `Headers` now normalized `Number` value to `String`, prevent common mistakes
|
||||
|
||||
## v1.2.0
|
||||
|
||||
- Enhance: now fetch.Headers and fetch.Response are exposed, making testing easier
|
||||
|
||||
## v1.1.2
|
||||
|
||||
- Fix: `Headers` should only support `String` and `Array` properties, and ignore others
|
||||
|
||||
## v1.1.1
|
||||
|
||||
- Enhance: now req.headers accept both plain object and `Headers` instance
|
||||
|
||||
## v1.1.0
|
||||
|
||||
- Enhance: timeout now also applies to response body (in case of slow response)
|
||||
- Fix: timeout is now cleared properly when fetch is done/has failed
|
||||
|
||||
## v1.0.6
|
||||
|
||||
- Fix: less greedy content-type charset matching
|
||||
|
||||
## v1.0.5
|
||||
|
||||
- Fix: when `follow = 0`, fetch should not follow redirect
|
||||
- Enhance: update tests for better coverage
|
||||
- Enhance: code formatting
|
||||
- Enhance: clean up doc
|
||||
|
||||
## v1.0.4
|
||||
|
||||
- Enhance: test iojs support
|
||||
- Enhance: timeout attached to socket event only fire once per redirect
|
||||
|
||||
## v1.0.3
|
||||
|
||||
- Fix: response size limit should reject large chunk
|
||||
- Enhance: added character encoding detection for xml, such as rss/atom feed (encoding in DTD)
|
||||
|
||||
## v1.0.2
|
||||
|
||||
- Fix: added res.ok per spec change
|
||||
|
||||
## v1.0.0
|
||||
|
||||
- Enhance: better test coverage and doc
|
||||
|
||||
|
||||
# 0.x release
|
||||
|
||||
## v0.1
|
||||
|
||||
- Major: initial public release
|
||||
22
node_modules/node-fetch-npm/LICENSE.md
generated
vendored
Normal file
22
node_modules/node-fetch-npm/LICENSE.md
generated
vendored
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2016 David Frank
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
||||
398
node_modules/node-fetch-npm/README.md
generated
vendored
Normal file
398
node_modules/node-fetch-npm/README.md
generated
vendored
Normal file
|
|
@ -0,0 +1,398 @@
|
|||
|
||||
node-fetch-npm
|
||||
==============
|
||||
|
||||
[![npm version][npm-image]][npm-url]
|
||||
[![build status][travis-image]][travis-url]
|
||||
[![coverage status][codecov-image]][codecov-url]
|
||||
|
||||
A light-weight module that brings `window.fetch` to Node.js
|
||||
|
||||
`node-fetch-npm` is a fork of [`node-fetch`](https://npm.im/node-fetch) used in
|
||||
npm itself, through [`make-fetch-happen`](https://npm.im/make-fetch-happen). It
|
||||
has more regular releases and accepts some patches that would not fit with
|
||||
`node-fetch`'s own design goals (such as picking a specific cookie library,
|
||||
removing `babel` dependency altogether, etc).
|
||||
|
||||
This library is *not a replacement* for `node-fetch`, nor does it intend to
|
||||
supplant it. It's purely a fork maintained for the sake of easier patching of
|
||||
specific needs that it wouldn't be fair to shove down the main project's throat.
|
||||
This project will still send patches for shared bugs over and hopefully help
|
||||
improve its "parent".
|
||||
|
||||
## Motivation
|
||||
|
||||
Instead of implementing `XMLHttpRequest` in Node.js to run browser-specific [Fetch polyfill](https://github.com/github/fetch), why not go from native `http` to `fetch` API directly? Hence `node-fetch`, minimal code for a `window.fetch` compatible API on Node.js runtime.
|
||||
|
||||
See Matt Andrews' [isomorphic-fetch](https://github.com/matthew-andrews/isomorphic-fetch) for isomorphic usage (exports `node-fetch` for server-side, `whatwg-fetch` for client-side).
|
||||
|
||||
|
||||
## Features
|
||||
|
||||
- Stay consistent with `window.fetch` API.
|
||||
- Make conscious trade-off when following [whatwg fetch spec][whatwg-fetch] and [stream spec](https://streams.spec.whatwg.org/) implementation details, document known difference.
|
||||
- Use native promise, but allow substituting it with [insert your favorite promise library].
|
||||
- Use native stream for body, on both request and response.
|
||||
- Decode content encoding (gzip/deflate) properly, and convert string output (such as `res.text()` and `res.json()`) to UTF-8 automatically.
|
||||
- Useful extensions such as timeout, redirect limit, response size limit, [explicit errors][] for troubleshooting.
|
||||
|
||||
|
||||
## Difference from client-side fetch
|
||||
|
||||
- See [Known Differences](https://github.com/npm/node-fetch-npm/blob/master/LIMITS.md) for details.
|
||||
- If you happen to use a missing feature that `window.fetch` offers, feel free to open an issue.
|
||||
- Pull requests are welcomed too!
|
||||
|
||||
|
||||
## Install
|
||||
|
||||
```sh
|
||||
$ npm install node-fetch-npm --save
|
||||
```
|
||||
|
||||
|
||||
## Usage
|
||||
|
||||
```javascript
|
||||
import fetch from 'node-fetch';
|
||||
// or
|
||||
// const fetch = require('node-fetch');
|
||||
|
||||
// if you are using your own Promise library, set it through fetch.Promise. Eg.
|
||||
|
||||
// import Bluebird from 'bluebird';
|
||||
// fetch.Promise = Bluebird;
|
||||
|
||||
// plain text or html
|
||||
|
||||
fetch('https://github.com/')
|
||||
.then(res => res.text())
|
||||
.then(body => console.log(body));
|
||||
|
||||
// json
|
||||
|
||||
fetch('https://api.github.com/users/github')
|
||||
.then(res => res.json())
|
||||
.then(json => console.log(json));
|
||||
|
||||
// catching network error
|
||||
// 3xx-5xx responses are NOT network errors, and should be handled in then()
|
||||
// you only need one catch() at the end of your promise chain
|
||||
|
||||
fetch('http://domain.invalid/')
|
||||
.catch(err => console.error(err));
|
||||
|
||||
// stream
|
||||
// the node.js way is to use stream when possible
|
||||
|
||||
fetch('https://assets-cdn.github.com/images/modules/logos_page/Octocat.png')
|
||||
.then(res => {
|
||||
const dest = fs.createWriteStream('./octocat.png');
|
||||
res.body.pipe(dest);
|
||||
});
|
||||
|
||||
// buffer
|
||||
// if you prefer to cache binary data in full, use buffer()
|
||||
// note that buffer() is a node-fetch only API
|
||||
|
||||
import fileType from 'file-type';
|
||||
|
||||
fetch('https://assets-cdn.github.com/images/modules/logos_page/Octocat.png')
|
||||
.then(res => res.buffer())
|
||||
.then(buffer => fileType(buffer))
|
||||
.then(type => { /* ... */ });
|
||||
|
||||
// meta
|
||||
|
||||
fetch('https://github.com/')
|
||||
.then(res => {
|
||||
console.log(res.ok);
|
||||
console.log(res.status);
|
||||
console.log(res.statusText);
|
||||
console.log(res.headers.raw());
|
||||
console.log(res.headers.get('content-type'));
|
||||
});
|
||||
|
||||
// post
|
||||
|
||||
fetch('http://httpbin.org/post', { method: 'POST', body: 'a=1' })
|
||||
.then(res => res.json())
|
||||
.then(json => console.log(json));
|
||||
|
||||
// post with stream from file
|
||||
|
||||
import { createReadStream } from 'fs';
|
||||
|
||||
const stream = createReadStream('input.txt');
|
||||
fetch('http://httpbin.org/post', { method: 'POST', body: stream })
|
||||
.then(res => res.json())
|
||||
.then(json => console.log(json));
|
||||
|
||||
// post with JSON
|
||||
|
||||
var body = { a: 1 };
|
||||
fetch('http://httpbin.org/post', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify(body),
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
})
|
||||
.then(res => res.json())
|
||||
.then(json => console.log(json));
|
||||
|
||||
// post with form-data (detect multipart)
|
||||
|
||||
import FormData from 'form-data';
|
||||
|
||||
const form = new FormData();
|
||||
form.append('a', 1);
|
||||
fetch('http://httpbin.org/post', { method: 'POST', body: form })
|
||||
.then(res => res.json())
|
||||
.then(json => console.log(json));
|
||||
|
||||
// post with form-data (custom headers)
|
||||
// note that getHeaders() is non-standard API
|
||||
|
||||
import FormData from 'form-data';
|
||||
|
||||
const form = new FormData();
|
||||
form.append('a', 1);
|
||||
fetch('http://httpbin.org/post', { method: 'POST', body: form, headers: form.getHeaders() })
|
||||
.then(res => res.json())
|
||||
.then(json => console.log(json));
|
||||
|
||||
// node 7+ with async function
|
||||
|
||||
(async function () {
|
||||
const res = await fetch('https://api.github.com/users/github');
|
||||
const json = await res.json();
|
||||
console.log(json);
|
||||
})();
|
||||
```
|
||||
|
||||
See [test cases](https://github.com/npm/node-fetch-npm/blob/master/test/test.js) for more examples.
|
||||
|
||||
|
||||
## API
|
||||
|
||||
### fetch(url[, options])
|
||||
|
||||
- `url` A string representing the URL for fetching
|
||||
- `options` [Options](#fetch-options) for the HTTP(S) request
|
||||
- Returns: <code>Promise<[Response](#class-response)></code>
|
||||
|
||||
Perform an HTTP(S) fetch.
|
||||
|
||||
`url` should be an absolute url, such as `http://example.com/`. A path-relative URL (`/file/under/root`) or protocol-relative URL (`//can-be-http-or-https.com/`) will result in a rejected promise.
|
||||
|
||||
<a id="fetch-options"></a>
|
||||
#### Options
|
||||
|
||||
The default values are shown after each option key.
|
||||
|
||||
```js
|
||||
{
|
||||
// These properties are part of the Fetch Standard
|
||||
method: 'GET',
|
||||
headers: {}, // request headers. format is the identical to that accepted by the Headers constructor (see below)
|
||||
body: null, // request body. can be null, a string, a Buffer, a Blob, or a Node.js Readable stream
|
||||
redirect: 'follow', // set to `manual` to extract redirect headers, `error` to reject redirect
|
||||
|
||||
// The following properties are node-fetch-npm extensions
|
||||
follow: 20, // maximum redirect count. 0 to not follow redirect
|
||||
timeout: 0, // req/res timeout in ms, it resets on redirect. 0 to disable (OS limit applies)
|
||||
compress: true, // support gzip/deflate content encoding. false to disable
|
||||
size: 0, // maximum response body size in bytes. 0 to disable
|
||||
agent: null // http(s).Agent instance, allows custom proxy, certificate etc.
|
||||
}
|
||||
```
|
||||
|
||||
##### Default Headers
|
||||
|
||||
If no values are set, the following request headers will be sent automatically:
|
||||
|
||||
Header | Value
|
||||
----------------- | --------------------------------------------------------
|
||||
`Accept-Encoding` | `gzip,deflate` _(when `options.compress === true`)_
|
||||
`Accept` | `*/*`
|
||||
`Connection` | `close` _(when no `options.agent` is present)_
|
||||
`Content-Length` | _(automatically calculated, if possible)_
|
||||
`User-Agent` | `node-fetch-npm/1.0 (+https://github.com/npm/node-fetch-npm)`
|
||||
|
||||
<a id="class-request"></a>
|
||||
### Class: Request
|
||||
|
||||
An HTTP(S) request containing information about URL, method, headers, and the body. This class implements the [Body](#iface-body) interface.
|
||||
|
||||
Due to the nature of Node.js, the following properties are not implemented at this moment:
|
||||
|
||||
- `type`
|
||||
- `destination`
|
||||
- `referrer`
|
||||
- `referrerPolicy`
|
||||
- `mode`
|
||||
- `credentials`
|
||||
- `cache`
|
||||
- `integrity`
|
||||
- `keepalive`
|
||||
|
||||
The following node-fetch-npm extension properties are provided:
|
||||
|
||||
- `follow`
|
||||
- `compress`
|
||||
- `counter`
|
||||
- `agent`
|
||||
|
||||
See [options](#fetch-options) for exact meaning of these extensions.
|
||||
|
||||
#### new Request(input[, options])
|
||||
|
||||
<small>*(spec-compliant)*</small>
|
||||
|
||||
- `input` A string representing a URL, or another `Request` (which will be cloned)
|
||||
- `options` [Options][#fetch-options] for the HTTP(S) request
|
||||
|
||||
Constructs a new `Request` object. The constructor is identical to that in the [browser](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request).
|
||||
|
||||
In most cases, directly `fetch(url, options)` is simpler than creating a `Request` object.
|
||||
|
||||
<a id="class-response"></a>
|
||||
### Class: Response
|
||||
|
||||
An HTTP(S) response. This class implements the [Body](#iface-body) interface.
|
||||
|
||||
The following properties are not implemented in node-fetch-npm at this moment:
|
||||
|
||||
- `Response.error()`
|
||||
- `Response.redirect()`
|
||||
- `type`
|
||||
- `redirected`
|
||||
- `trailer`
|
||||
|
||||
#### new Response([body[, options]])
|
||||
|
||||
<small>*(spec-compliant)*</small>
|
||||
|
||||
- `body` A string or [Readable stream][node-readable]
|
||||
- `options` A [`ResponseInit`][response-init] options dictionary
|
||||
|
||||
Constructs a new `Response` object. The constructor is identical to that in the [browser](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response).
|
||||
|
||||
Because Node.js does not implement service workers (for which this class was designed), one rarely has to construct a `Response` directly.
|
||||
|
||||
<a id="class-headers"></a>
|
||||
### Class: Headers
|
||||
|
||||
This class allows manipulating and iterating over a set of HTTP headers. All methods specified in the [Fetch Standard][whatwg-fetch] are implemented.
|
||||
|
||||
#### new Headers([init])
|
||||
|
||||
<small>*(spec-compliant)*</small>
|
||||
|
||||
- `init` Optional argument to pre-fill the `Headers` object
|
||||
|
||||
Construct a new `Headers` object. `init` can be either `null`, a `Headers` object, an key-value map object, or any iterable object.
|
||||
|
||||
```js
|
||||
// Example adapted from https://fetch.spec.whatwg.org/#example-headers-class
|
||||
|
||||
const meta = {
|
||||
'Content-Type': 'text/xml',
|
||||
'Breaking-Bad': '<3'
|
||||
};
|
||||
const headers = new Headers(meta);
|
||||
|
||||
// The above is equivalent to
|
||||
const meta = [
|
||||
[ 'Content-Type', 'text/xml' ],
|
||||
[ 'Breaking-Bad', '<3' ]
|
||||
];
|
||||
const headers = new Headers(meta);
|
||||
|
||||
// You can in fact use any iterable objects, like a Map or even another Headers
|
||||
const meta = new Map();
|
||||
meta.set('Content-Type', 'text/xml');
|
||||
meta.set('Breaking-Bad', '<3');
|
||||
const headers = new Headers(meta);
|
||||
const copyOfHeaders = new Headers(headers);
|
||||
```
|
||||
|
||||
<a id="iface-body"></a>
|
||||
### Interface: Body
|
||||
|
||||
`Body` is an abstract interface with methods that are applicable to both `Request` and `Response` classes.
|
||||
|
||||
The following methods are not yet implemented in node-fetch-npm at this moment:
|
||||
|
||||
- `formData()`
|
||||
|
||||
#### body.body
|
||||
|
||||
<small>*(deviation from spec)*</small>
|
||||
|
||||
* Node.js [`Readable` stream][node-readable]
|
||||
|
||||
The data encapsulated in the `Body` object. Note that while the [Fetch Standard][whatwg-fetch] requires the property to always be a WHATWG `ReadableStream`, in node-fetch-npm it is a Node.js [`Readable` stream][node-readable].
|
||||
|
||||
#### body.bodyUsed
|
||||
|
||||
<small>*(spec-compliant)*</small>
|
||||
|
||||
* `Boolean`
|
||||
|
||||
A boolean property for if this body has been consumed. Per spec, a consumed body cannot be used again.
|
||||
|
||||
#### body.arrayBuffer()
|
||||
#### body.blob()
|
||||
#### body.json()
|
||||
#### body.text()
|
||||
|
||||
<small>*(spec-compliant)*</small>
|
||||
|
||||
* Returns: <code>Promise</code>
|
||||
|
||||
Consume the body and return a promise that will resolve to one of these formats.
|
||||
|
||||
#### body.buffer()
|
||||
|
||||
<small>*(node-fetch-npm extension)*</small>
|
||||
|
||||
* Returns: <code>Promise<Buffer></code>
|
||||
|
||||
Consume the body and return a promise that will resolve to a Buffer.
|
||||
|
||||
#### body.textConverted()
|
||||
|
||||
<small>*(node-fetch-npm extension)*</small>
|
||||
|
||||
* Returns: <code>Promise<String></code>
|
||||
|
||||
Identical to `body.text()`, except instead of always converting to UTF-8, encoding sniffing will be performed and text converted to UTF-8, if possible.
|
||||
|
||||
<a id="class-fetcherror"></a>
|
||||
### Class: FetchError
|
||||
|
||||
<small>*(node-fetch-npm extension)*</small>
|
||||
|
||||
An operational error in the fetching process. See [ERROR-HANDLING.md][] for more info.
|
||||
|
||||
## License
|
||||
|
||||
MIT
|
||||
|
||||
|
||||
## Acknowledgement
|
||||
|
||||
Thanks to [github/fetch](https://github.com/github/fetch) for providing a solid implementation reference.
|
||||
|
||||
|
||||
[npm-image]: https://img.shields.io/npm/v/node-fetch-npm.svg?style=flat-square
|
||||
[npm-url]: https://www.npmjs.com/package/node-fetch-npm
|
||||
[travis-image]: https://img.shields.io/travis/npm/node-fetch-npm.svg?style=flat-square
|
||||
[travis-url]: https://travis-ci.org/npm/node-fetch-npm
|
||||
[codecov-image]: https://img.shields.io/codecov/c/github/npm/node-fetch-npm.svg?style=flat-square
|
||||
[codecov-url]: https://codecov.io/gh/npm/node-fetch-npm
|
||||
[ERROR-HANDLING.md]: https://github.com/npm/node-fetch-npm/blob/master/ERROR-HANDLING.md
|
||||
[whatwg-fetch]: https://fetch.spec.whatwg.org/
|
||||
[response-init]: https://fetch.spec.whatwg.org/#responseinit
|
||||
[node-readable]: https://nodejs.org/api/stream.html#stream_readable_streams
|
||||
[mdn-headers]: https://developer.mozilla.org/en-US/docs/Web/API/Headers
|
||||
100
node_modules/node-fetch-npm/package.json
generated
vendored
Normal file
100
node_modules/node-fetch-npm/package.json
generated
vendored
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
{
|
||||
"_from": "node-fetch-npm@^2.0.2",
|
||||
"_id": "node-fetch-npm@2.0.2",
|
||||
"_inBundle": false,
|
||||
"_integrity": "sha512-nJIxm1QmAj4v3nfCvEeCrYSoVwXyxLnaPBK5W1W5DGEJwjlKuC2VEUycGw5oxk+4zZahRrB84PUJJgEmhFTDFw==",
|
||||
"_location": "/node-fetch-npm",
|
||||
"_phantomChildren": {},
|
||||
"_requested": {
|
||||
"type": "range",
|
||||
"registry": true,
|
||||
"raw": "node-fetch-npm@^2.0.2",
|
||||
"name": "node-fetch-npm",
|
||||
"escapedName": "node-fetch-npm",
|
||||
"rawSpec": "^2.0.2",
|
||||
"saveSpec": null,
|
||||
"fetchSpec": "^2.0.2"
|
||||
},
|
||||
"_requiredBy": [
|
||||
"/make-fetch-happen"
|
||||
],
|
||||
"_resolved": "https://registry.npmjs.org/node-fetch-npm/-/node-fetch-npm-2.0.2.tgz",
|
||||
"_shasum": "7258c9046182dca345b4208eda918daf33697ff7",
|
||||
"_spec": "node-fetch-npm@^2.0.2",
|
||||
"_where": "/home/shimataro/projects/actions/ssh-key-action/node_modules/make-fetch-happen",
|
||||
"author": {
|
||||
"name": "David Frank"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/npm/node-fetch-npm/issues"
|
||||
},
|
||||
"bundleDependencies": false,
|
||||
"contributors": [
|
||||
{
|
||||
"name": "Rebecca Turner",
|
||||
"email": "me@re-becca.org"
|
||||
},
|
||||
{
|
||||
"name": "Kat Marchán",
|
||||
"email": "kzm@sykosomatic.org"
|
||||
}
|
||||
],
|
||||
"dependencies": {
|
||||
"encoding": "^0.1.11",
|
||||
"json-parse-better-errors": "^1.0.0",
|
||||
"safe-buffer": "^5.1.1"
|
||||
},
|
||||
"deprecated": false,
|
||||
"description": "An npm cli-oriented fork of the excellent node-fetch",
|
||||
"devDependencies": {
|
||||
"chai": "^3.5.0",
|
||||
"chai-as-promised": "^6.0.0",
|
||||
"chai-iterator": "^1.1.1",
|
||||
"chai-string": "^1.4.0",
|
||||
"codecov": "^1.0.1",
|
||||
"cross-env": "^3.1.4",
|
||||
"form-data": "^2.2.0",
|
||||
"is-builtin-module": "^1.0.0",
|
||||
"mocha": "^3.5.0",
|
||||
"nyc": "^10.3.2",
|
||||
"parted": "^0.1.1",
|
||||
"promise": "^7.3.1",
|
||||
"resumer": "0.0.0",
|
||||
"standard": "^10.0.3",
|
||||
"standard-version": "^4.2.0",
|
||||
"weallbehave": "^1.2.0",
|
||||
"weallcontribute": "^1.0.8",
|
||||
"whatwg-url": "^4.8.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=4"
|
||||
},
|
||||
"files": [
|
||||
"src/*.js"
|
||||
],
|
||||
"homepage": "https://github.com/npm/node-fetch-npm",
|
||||
"keywords": [
|
||||
"fetch",
|
||||
"http",
|
||||
"promise"
|
||||
],
|
||||
"license": "MIT",
|
||||
"main": "src/index.js",
|
||||
"name": "node-fetch-npm",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/npm/node-fetch-npm.git"
|
||||
},
|
||||
"scripts": {
|
||||
"coverage": "nyc --reporter json --reporter text mocha -R spec test/test.js && codecov -f coverage/coverage-final.json",
|
||||
"postrelease": "npm publish && git push --follow-tags",
|
||||
"prerelease": "npm t",
|
||||
"pretest": "standard src/*",
|
||||
"release": "standard-version -s",
|
||||
"report": "nyc --reporter lcov --reporter text mocha -R spec test/test.js",
|
||||
"test": "mocha test/test.js",
|
||||
"update-coc": "weallbehave -o . && git add CODE_OF_CONDUCT.md && git commit -m 'docs(coc): updated CODE_OF_CONDUCT.md'",
|
||||
"update-contrib": "weallcontribute -o . && git add CONTRIBUTING.md && git commit -m 'docs(contributing): updated CONTRIBUTING.md'"
|
||||
},
|
||||
"version": "2.0.2"
|
||||
}
|
||||
109
node_modules/node-fetch-npm/src/blob.js
generated
vendored
Normal file
109
node_modules/node-fetch-npm/src/blob.js
generated
vendored
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
'use strict'
|
||||
// Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js
|
||||
// (MIT licensed)
|
||||
|
||||
const Buffer = require('safe-buffer').Buffer
|
||||
|
||||
const BUFFER = Symbol('buffer')
|
||||
const TYPE = Symbol('type')
|
||||
const CLOSED = Symbol('closed')
|
||||
|
||||
class Blob {
|
||||
constructor () {
|
||||
Object.defineProperty(this, Symbol.toStringTag, {
|
||||
value: 'Blob',
|
||||
writable: false,
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
})
|
||||
|
||||
this[CLOSED] = false
|
||||
this[TYPE] = ''
|
||||
|
||||
const blobParts = arguments[0]
|
||||
const options = arguments[1]
|
||||
|
||||
const buffers = []
|
||||
|
||||
if (blobParts) {
|
||||
const a = blobParts
|
||||
const length = Number(a.length)
|
||||
for (let i = 0; i < length; i++) {
|
||||
const element = a[i]
|
||||
let buffer
|
||||
if (Buffer.isBuffer(element)) {
|
||||
buffer = element
|
||||
} else if (ArrayBuffer.isView(element)) {
|
||||
buffer = Buffer.from(new Uint8Array(element.buffer, element.byteOffset, element.byteLength))
|
||||
} else if (element instanceof ArrayBuffer) {
|
||||
buffer = Buffer.from(new Uint8Array(element))
|
||||
} else if (element instanceof Blob) {
|
||||
buffer = element[BUFFER]
|
||||
} else {
|
||||
buffer = Buffer.from(typeof element === 'string' ? element : String(element))
|
||||
}
|
||||
buffers.push(buffer)
|
||||
}
|
||||
}
|
||||
|
||||
this[BUFFER] = Buffer.concat(buffers)
|
||||
|
||||
let type = options && options.type !== undefined && String(options.type).toLowerCase()
|
||||
if (type && !/[^\u0020-\u007E]/.test(type)) {
|
||||
this[TYPE] = type
|
||||
}
|
||||
}
|
||||
get size () {
|
||||
return this[CLOSED] ? 0 : this[BUFFER].length
|
||||
}
|
||||
get type () {
|
||||
return this[TYPE]
|
||||
}
|
||||
get isClosed () {
|
||||
return this[CLOSED]
|
||||
}
|
||||
slice () {
|
||||
const size = this.size
|
||||
|
||||
const start = arguments[0]
|
||||
const end = arguments[1]
|
||||
let relativeStart, relativeEnd
|
||||
if (start === undefined) {
|
||||
relativeStart = 0
|
||||
} else if (start < 0) {
|
||||
relativeStart = Math.max(size + start, 0)
|
||||
} else {
|
||||
relativeStart = Math.min(start, size)
|
||||
}
|
||||
if (end === undefined) {
|
||||
relativeEnd = size
|
||||
} else if (end < 0) {
|
||||
relativeEnd = Math.max(size + end, 0)
|
||||
} else {
|
||||
relativeEnd = Math.min(end, size)
|
||||
}
|
||||
const span = Math.max(relativeEnd - relativeStart, 0)
|
||||
|
||||
const buffer = this[BUFFER]
|
||||
const slicedBuffer = buffer.slice(
|
||||
relativeStart,
|
||||
relativeStart + span
|
||||
)
|
||||
const blob = new Blob([], { type: arguments[2] })
|
||||
blob[BUFFER] = slicedBuffer
|
||||
blob[CLOSED] = this[CLOSED]
|
||||
return blob
|
||||
}
|
||||
close () {
|
||||
this[CLOSED] = true
|
||||
}
|
||||
}
|
||||
exports = module.exports = Blob
|
||||
exports.BUFFER = BUFFER
|
||||
|
||||
Object.defineProperty(Blob.prototype, Symbol.toStringTag, {
|
||||
value: 'BlobPrototype',
|
||||
writable: false,
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
})
|
||||
411
node_modules/node-fetch-npm/src/body.js
generated
vendored
Normal file
411
node_modules/node-fetch-npm/src/body.js
generated
vendored
Normal file
|
|
@ -0,0 +1,411 @@
|
|||
'use strict'
|
||||
|
||||
/**
|
||||
* body.js
|
||||
*
|
||||
* Body interface provides common methods for Request and Response
|
||||
*/
|
||||
|
||||
const Buffer = require('safe-buffer').Buffer
|
||||
|
||||
const Blob = require('./blob.js')
|
||||
const BUFFER = Blob.BUFFER
|
||||
const convert = require('encoding').convert
|
||||
const parseJson = require('json-parse-better-errors')
|
||||
const FetchError = require('./fetch-error.js')
|
||||
const Stream = require('stream')
|
||||
|
||||
const PassThrough = Stream.PassThrough
|
||||
const DISTURBED = Symbol('disturbed')
|
||||
|
||||
/**
|
||||
* Body class
|
||||
*
|
||||
* Cannot use ES6 class because Body must be called with .call().
|
||||
*
|
||||
* @param Stream body Readable stream
|
||||
* @param Object opts Response options
|
||||
* @return Void
|
||||
*/
|
||||
exports = module.exports = Body
|
||||
|
||||
function Body (body, opts) {
|
||||
if (!opts) opts = {}
|
||||
const size = opts.size == null ? 0 : opts.size
|
||||
const timeout = opts.timeout == null ? 0 : opts.timeout
|
||||
if (body == null) {
|
||||
// body is undefined or null
|
||||
body = null
|
||||
} else if (typeof body === 'string') {
|
||||
// body is string
|
||||
} else if (body instanceof Blob) {
|
||||
// body is blob
|
||||
} else if (Buffer.isBuffer(body)) {
|
||||
// body is buffer
|
||||
} else if (body instanceof Stream) {
|
||||
// body is stream
|
||||
} else {
|
||||
// none of the above
|
||||
// coerce to string
|
||||
body = String(body)
|
||||
}
|
||||
this.body = body
|
||||
this[DISTURBED] = false
|
||||
this.size = size
|
||||
this.timeout = timeout
|
||||
}
|
||||
|
||||
Body.prototype = {
|
||||
get bodyUsed () {
|
||||
return this[DISTURBED]
|
||||
},
|
||||
|
||||
/**
|
||||
* Decode response as ArrayBuffer
|
||||
*
|
||||
* @return Promise
|
||||
*/
|
||||
arrayBuffer () {
|
||||
return consumeBody.call(this).then(buf => buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength))
|
||||
},
|
||||
|
||||
/**
|
||||
* Return raw response as Blob
|
||||
*
|
||||
* @return Promise
|
||||
*/
|
||||
blob () {
|
||||
let ct = (this.headers && this.headers.get('content-type')) || ''
|
||||
return consumeBody.call(this).then(buf => Object.assign(
|
||||
// Prevent copying
|
||||
new Blob([], {
|
||||
type: ct.toLowerCase()
|
||||
}),
|
||||
{
|
||||
[BUFFER]: buf
|
||||
}
|
||||
))
|
||||
},
|
||||
|
||||
/**
|
||||
* Decode response as json
|
||||
*
|
||||
* @return Promise
|
||||
*/
|
||||
json () {
|
||||
return consumeBody.call(this).then(buffer => parseJson(buffer.toString()))
|
||||
},
|
||||
|
||||
/**
|
||||
* Decode response as text
|
||||
*
|
||||
* @return Promise
|
||||
*/
|
||||
text () {
|
||||
return consumeBody.call(this).then(buffer => buffer.toString())
|
||||
},
|
||||
|
||||
/**
|
||||
* Decode response as buffer (non-spec api)
|
||||
*
|
||||
* @return Promise
|
||||
*/
|
||||
buffer () {
|
||||
return consumeBody.call(this)
|
||||
},
|
||||
|
||||
/**
|
||||
* Decode response as text, while automatically detecting the encoding and
|
||||
* trying to decode to UTF-8 (non-spec api)
|
||||
*
|
||||
* @return Promise
|
||||
*/
|
||||
textConverted () {
|
||||
return consumeBody.call(this).then(buffer => convertBody(buffer, this.headers))
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Body.mixIn = function (proto) {
|
||||
for (const name of Object.getOwnPropertyNames(Body.prototype)) {
|
||||
// istanbul ignore else: future proof
|
||||
if (!(name in proto)) {
|
||||
const desc = Object.getOwnPropertyDescriptor(Body.prototype, name)
|
||||
Object.defineProperty(proto, name, desc)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode buffers into utf-8 string
|
||||
*
|
||||
* @return Promise
|
||||
*/
|
||||
function consumeBody (body) {
|
||||
if (this[DISTURBED]) {
|
||||
return Body.Promise.reject(new Error(`body used already for: ${this.url}`))
|
||||
}
|
||||
|
||||
this[DISTURBED] = true
|
||||
|
||||
// body is null
|
||||
if (this.body === null) {
|
||||
return Body.Promise.resolve(Buffer.alloc(0))
|
||||
}
|
||||
|
||||
// body is string
|
||||
if (typeof this.body === 'string') {
|
||||
return Body.Promise.resolve(Buffer.from(this.body))
|
||||
}
|
||||
|
||||
// body is blob
|
||||
if (this.body instanceof Blob) {
|
||||
return Body.Promise.resolve(this.body[BUFFER])
|
||||
}
|
||||
|
||||
// body is buffer
|
||||
if (Buffer.isBuffer(this.body)) {
|
||||
return Body.Promise.resolve(this.body)
|
||||
}
|
||||
|
||||
// istanbul ignore if: should never happen
|
||||
if (!(this.body instanceof Stream)) {
|
||||
return Body.Promise.resolve(Buffer.alloc(0))
|
||||
}
|
||||
|
||||
// body is stream
|
||||
// get ready to actually consume the body
|
||||
let accum = []
|
||||
let accumBytes = 0
|
||||
let abort = false
|
||||
|
||||
return new Body.Promise((resolve, reject) => {
|
||||
let resTimeout
|
||||
|
||||
// allow timeout on slow response body
|
||||
if (this.timeout) {
|
||||
resTimeout = setTimeout(() => {
|
||||
abort = true
|
||||
reject(new FetchError(`Response timeout while trying to fetch ${this.url} (over ${this.timeout}ms)`, 'body-timeout'))
|
||||
}, this.timeout)
|
||||
}
|
||||
|
||||
// handle stream error, such as incorrect content-encoding
|
||||
this.body.on('error', err => {
|
||||
reject(new FetchError(`Invalid response body while trying to fetch ${this.url}: ${err.message}`, 'system', err))
|
||||
})
|
||||
|
||||
this.body.on('data', chunk => {
|
||||
if (abort || chunk === null) {
|
||||
return
|
||||
}
|
||||
|
||||
if (this.size && accumBytes + chunk.length > this.size) {
|
||||
abort = true
|
||||
reject(new FetchError(`content size at ${this.url} over limit: ${this.size}`, 'max-size'))
|
||||
return
|
||||
}
|
||||
|
||||
accumBytes += chunk.length
|
||||
accum.push(chunk)
|
||||
})
|
||||
|
||||
this.body.on('end', () => {
|
||||
if (abort) {
|
||||
return
|
||||
}
|
||||
|
||||
clearTimeout(resTimeout)
|
||||
resolve(Buffer.concat(accum))
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
/**
|
||||
* Detect buffer encoding and convert to target encoding
|
||||
* ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding
|
||||
*
|
||||
* @param Buffer buffer Incoming buffer
|
||||
* @param String encoding Target encoding
|
||||
* @return String
|
||||
*/
|
||||
function convertBody (buffer, headers) {
|
||||
const ct = headers.get('content-type')
|
||||
let charset = 'utf-8'
|
||||
let res, str
|
||||
|
||||
// header
|
||||
if (ct) {
|
||||
res = /charset=([^;]*)/i.exec(ct)
|
||||
}
|
||||
|
||||
// no charset in content type, peek at response body for at most 1024 bytes
|
||||
str = buffer.slice(0, 1024).toString()
|
||||
|
||||
// html5
|
||||
if (!res && str) {
|
||||
res = /<meta.+?charset=(['"])(.+?)\1/i.exec(str)
|
||||
}
|
||||
|
||||
// html4
|
||||
if (!res && str) {
|
||||
res = /<meta[\s]+?http-equiv=(['"])content-type\1[\s]+?content=(['"])(.+?)\2/i.exec(str)
|
||||
|
||||
if (res) {
|
||||
res = /charset=(.*)/i.exec(res.pop())
|
||||
}
|
||||
}
|
||||
|
||||
// xml
|
||||
if (!res && str) {
|
||||
res = /<\?xml.+?encoding=(['"])(.+?)\1/i.exec(str)
|
||||
}
|
||||
|
||||
// found charset
|
||||
if (res) {
|
||||
charset = res.pop()
|
||||
|
||||
// prevent decode issues when sites use incorrect encoding
|
||||
// ref: https://hsivonen.fi/encoding-menu/
|
||||
if (charset === 'gb2312' || charset === 'gbk') {
|
||||
charset = 'gb18030'
|
||||
}
|
||||
}
|
||||
|
||||
// turn raw buffers into a single utf-8 buffer
|
||||
return convert(
|
||||
buffer
|
||||
, 'UTF-8'
|
||||
, charset
|
||||
).toString()
|
||||
}
|
||||
|
||||
/**
|
||||
* Clone body given Res/Req instance
|
||||
*
|
||||
* @param Mixed instance Response or Request instance
|
||||
* @return Mixed
|
||||
*/
|
||||
exports.clone = function clone (instance) {
|
||||
let p1, p2
|
||||
let body = instance.body
|
||||
|
||||
// don't allow cloning a used body
|
||||
if (instance.bodyUsed) {
|
||||
throw new Error('cannot clone body after it is used')
|
||||
}
|
||||
|
||||
// check that body is a stream and not form-data object
|
||||
// note: we can't clone the form-data object without having it as a dependency
|
||||
if ((body instanceof Stream) && (typeof body.getBoundary !== 'function')) {
|
||||
// tee instance body
|
||||
p1 = new PassThrough()
|
||||
p2 = new PassThrough()
|
||||
body.pipe(p1)
|
||||
body.pipe(p2)
|
||||
// set instance body to teed body and return the other teed body
|
||||
instance.body = p1
|
||||
body = p2
|
||||
}
|
||||
|
||||
return body
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs the operation "extract a `Content-Type` value from |object|" as
|
||||
* specified in the specification:
|
||||
* https://fetch.spec.whatwg.org/#concept-bodyinit-extract
|
||||
*
|
||||
* This function assumes that instance.body is present and non-null.
|
||||
*
|
||||
* @param Mixed instance Response or Request instance
|
||||
*/
|
||||
exports.extractContentType = function extractContentType (instance) {
|
||||
const body = instance.body
|
||||
|
||||
// istanbul ignore if: Currently, because of a guard in Request, body
|
||||
// can never be null. Included here for completeness.
|
||||
if (body === null) {
|
||||
// body is null
|
||||
return null
|
||||
} else if (typeof body === 'string') {
|
||||
// body is string
|
||||
return 'text/plain;charset=UTF-8'
|
||||
} else if (body instanceof Blob) {
|
||||
// body is blob
|
||||
return body.type || null
|
||||
} else if (Buffer.isBuffer(body)) {
|
||||
// body is buffer
|
||||
return null
|
||||
} else if (typeof body.getBoundary === 'function') {
|
||||
// detect form data input from form-data module
|
||||
return `multipart/form-data;boundary=${body.getBoundary()}`
|
||||
} else {
|
||||
// body is stream
|
||||
// can't really do much about this
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
exports.getTotalBytes = function getTotalBytes (instance) {
|
||||
const body = instance.body
|
||||
|
||||
// istanbul ignore if: included for completion
|
||||
if (body === null) {
|
||||
// body is null
|
||||
return 0
|
||||
} else if (typeof body === 'string') {
|
||||
// body is string
|
||||
return Buffer.byteLength(body)
|
||||
} else if (body instanceof Blob) {
|
||||
// body is blob
|
||||
return body.size
|
||||
} else if (Buffer.isBuffer(body)) {
|
||||
// body is buffer
|
||||
return body.length
|
||||
} else if (body && typeof body.getLengthSync === 'function') {
|
||||
// detect form data input from form-data module
|
||||
if ((
|
||||
// 1.x
|
||||
body._lengthRetrievers &&
|
||||
body._lengthRetrievers.length === 0
|
||||
) || (
|
||||
// 2.x
|
||||
body.hasKnownLength && body.hasKnownLength()
|
||||
)) {
|
||||
return body.getLengthSync()
|
||||
}
|
||||
return null
|
||||
} else {
|
||||
// body is stream
|
||||
// can't really do much about this
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
exports.writeToStream = function writeToStream (dest, instance) {
|
||||
const body = instance.body
|
||||
|
||||
if (body === null) {
|
||||
// body is null
|
||||
dest.end()
|
||||
} else if (typeof body === 'string') {
|
||||
// body is string
|
||||
dest.write(body)
|
||||
dest.end()
|
||||
} else if (body instanceof Blob) {
|
||||
// body is blob
|
||||
dest.write(body[BUFFER])
|
||||
dest.end()
|
||||
} else if (Buffer.isBuffer(body)) {
|
||||
// body is buffer
|
||||
dest.write(body)
|
||||
dest.end()
|
||||
} else {
|
||||
// body is stream
|
||||
body.pipe(dest)
|
||||
}
|
||||
}
|
||||
|
||||
// expose Promise
|
||||
Body.Promise = global.Promise
|
||||
92
node_modules/node-fetch-npm/src/common.js
generated
vendored
Normal file
92
node_modules/node-fetch-npm/src/common.js
generated
vendored
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
'use strict'
|
||||
/**
|
||||
* A set of utilities borrowed from Node.js' _http_common.js
|
||||
*/
|
||||
|
||||
/**
|
||||
* Verifies that the given val is a valid HTTP token
|
||||
* per the rules defined in RFC 7230
|
||||
* See https://tools.ietf.org/html/rfc7230#section-3.2.6
|
||||
*
|
||||
* Allowed characters in an HTTP token:
|
||||
* ^_`a-z 94-122
|
||||
* A-Z 65-90
|
||||
* - 45
|
||||
* 0-9 48-57
|
||||
* ! 33
|
||||
* #$%&' 35-39
|
||||
* *+ 42-43
|
||||
* . 46
|
||||
* | 124
|
||||
* ~ 126
|
||||
*
|
||||
* This implementation of checkIsHttpToken() loops over the string instead of
|
||||
* using a regular expression since the former is up to 180% faster with v8 4.9
|
||||
* depending on the string length (the shorter the string, the larger the
|
||||
* performance difference)
|
||||
*
|
||||
* Additionally, checkIsHttpToken() is currently designed to be inlinable by v8,
|
||||
* so take care when making changes to the implementation so that the source
|
||||
* code size does not exceed v8's default max_inlined_source_size setting.
|
||||
**/
|
||||
/* istanbul ignore next */
|
||||
function isValidTokenChar (ch) {
|
||||
if (ch >= 94 && ch <= 122) { return true }
|
||||
if (ch >= 65 && ch <= 90) { return true }
|
||||
if (ch === 45) { return true }
|
||||
if (ch >= 48 && ch <= 57) { return true }
|
||||
if (ch === 34 || ch === 40 || ch === 41 || ch === 44) { return false }
|
||||
if (ch >= 33 && ch <= 46) { return true }
|
||||
if (ch === 124 || ch === 126) { return true }
|
||||
return false
|
||||
}
|
||||
/* istanbul ignore next */
|
||||
function checkIsHttpToken (val) {
|
||||
if (typeof val !== 'string' || val.length === 0) { return false }
|
||||
if (!isValidTokenChar(val.charCodeAt(0))) { return false }
|
||||
const len = val.length
|
||||
if (len > 1) {
|
||||
if (!isValidTokenChar(val.charCodeAt(1))) { return false }
|
||||
if (len > 2) {
|
||||
if (!isValidTokenChar(val.charCodeAt(2))) { return false }
|
||||
if (len > 3) {
|
||||
if (!isValidTokenChar(val.charCodeAt(3))) { return false }
|
||||
for (var i = 4; i < len; i++) {
|
||||
if (!isValidTokenChar(val.charCodeAt(i))) { return false }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
exports.checkIsHttpToken = checkIsHttpToken
|
||||
|
||||
/**
|
||||
* True if val contains an invalid field-vchar
|
||||
* field-value = *( field-content / obs-fold )
|
||||
* field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
|
||||
* field-vchar = VCHAR / obs-text
|
||||
*
|
||||
* checkInvalidHeaderChar() is currently designed to be inlinable by v8,
|
||||
* so take care when making changes to the implementation so that the source
|
||||
* code size does not exceed v8's default max_inlined_source_size setting.
|
||||
**/
|
||||
/* istanbul ignore next */
|
||||
function checkInvalidHeaderChar (val) {
|
||||
val += ''
|
||||
if (val.length < 1) { return false }
|
||||
var c = val.charCodeAt(0)
|
||||
if ((c <= 31 && c !== 9) || c > 255 || c === 127) { return true }
|
||||
if (val.length < 2) { return false }
|
||||
c = val.charCodeAt(1)
|
||||
if ((c <= 31 && c !== 9) || c > 255 || c === 127) { return true }
|
||||
if (val.length < 3) { return false }
|
||||
c = val.charCodeAt(2)
|
||||
if ((c <= 31 && c !== 9) || c > 255 || c === 127) { return true }
|
||||
for (var i = 3; i < val.length; ++i) {
|
||||
c = val.charCodeAt(i)
|
||||
if ((c <= 31 && c !== 9) || c > 255 || c === 127) { return true }
|
||||
}
|
||||
return false
|
||||
}
|
||||
exports.checkInvalidHeaderChar = checkInvalidHeaderChar
|
||||
35
node_modules/node-fetch-npm/src/fetch-error.js
generated
vendored
Normal file
35
node_modules/node-fetch-npm/src/fetch-error.js
generated
vendored
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
'use strict'
|
||||
|
||||
/**
|
||||
* fetch-error.js
|
||||
*
|
||||
* FetchError interface for operational errors
|
||||
*/
|
||||
|
||||
/**
|
||||
* Create FetchError instance
|
||||
*
|
||||
* @param String message Error message for human
|
||||
* @param String type Error type for machine
|
||||
* @param String systemError For Node.js system error
|
||||
* @return FetchError
|
||||
*/
|
||||
module.exports = FetchError
|
||||
function FetchError (message, type, systemError) {
|
||||
Error.call(this, message)
|
||||
|
||||
this.message = message
|
||||
this.type = type
|
||||
|
||||
// when err.type is `system`, err.code contains system error code
|
||||
if (systemError) {
|
||||
this.code = this.errno = systemError.code
|
||||
}
|
||||
|
||||
// hide custom error implementation details from end-users
|
||||
Error.captureStackTrace(this, this.constructor)
|
||||
}
|
||||
|
||||
FetchError.prototype = Object.create(Error.prototype)
|
||||
FetchError.prototype.constructor = FetchError
|
||||
FetchError.prototype.name = 'FetchError'
|
||||
296
node_modules/node-fetch-npm/src/headers.js
generated
vendored
Normal file
296
node_modules/node-fetch-npm/src/headers.js
generated
vendored
Normal file
|
|
@ -0,0 +1,296 @@
|
|||
'use strict'
|
||||
|
||||
/**
|
||||
* headers.js
|
||||
*
|
||||
* Headers class offers convenient helpers
|
||||
*/
|
||||
|
||||
const common = require('./common.js')
|
||||
const checkInvalidHeaderChar = common.checkInvalidHeaderChar
|
||||
const checkIsHttpToken = common.checkIsHttpToken
|
||||
|
||||
function sanitizeName (name) {
|
||||
name += ''
|
||||
if (!checkIsHttpToken(name)) {
|
||||
throw new TypeError(`${name} is not a legal HTTP header name`)
|
||||
}
|
||||
return name.toLowerCase()
|
||||
}
|
||||
|
||||
function sanitizeValue (value) {
|
||||
value += ''
|
||||
if (checkInvalidHeaderChar(value)) {
|
||||
throw new TypeError(`${value} is not a legal HTTP header value`)
|
||||
}
|
||||
return value
|
||||
}
|
||||
|
||||
const MAP = Symbol('map')
|
||||
class Headers {
|
||||
/**
|
||||
* Headers class
|
||||
*
|
||||
* @param Object headers Response headers
|
||||
* @return Void
|
||||
*/
|
||||
constructor (init) {
|
||||
this[MAP] = Object.create(null)
|
||||
|
||||
if (init instanceof Headers) {
|
||||
const rawHeaders = init.raw()
|
||||
const headerNames = Object.keys(rawHeaders)
|
||||
|
||||
for (const headerName of headerNames) {
|
||||
for (const value of rawHeaders[headerName]) {
|
||||
this.append(headerName, value)
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// We don't worry about converting prop to ByteString here as append()
|
||||
// will handle it.
|
||||
if (init == null) {
|
||||
// no op
|
||||
} else if (typeof init === 'object') {
|
||||
const method = init[Symbol.iterator]
|
||||
if (method != null) {
|
||||
if (typeof method !== 'function') {
|
||||
throw new TypeError('Header pairs must be iterable')
|
||||
}
|
||||
|
||||
// sequence<sequence<ByteString>>
|
||||
// Note: per spec we have to first exhaust the lists then process them
|
||||
const pairs = []
|
||||
for (const pair of init) {
|
||||
if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') {
|
||||
throw new TypeError('Each header pair must be iterable')
|
||||
}
|
||||
pairs.push(Array.from(pair))
|
||||
}
|
||||
|
||||
for (const pair of pairs) {
|
||||
if (pair.length !== 2) {
|
||||
throw new TypeError('Each header pair must be a name/value tuple')
|
||||
}
|
||||
this.append(pair[0], pair[1])
|
||||
}
|
||||
} else {
|
||||
// record<ByteString, ByteString>
|
||||
for (const key of Object.keys(init)) {
|
||||
const value = init[key]
|
||||
this.append(key, value)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
throw new TypeError('Provided initializer must be an object')
|
||||
}
|
||||
|
||||
Object.defineProperty(this, Symbol.toStringTag, {
|
||||
value: 'Headers',
|
||||
writable: false,
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
})
|
||||
}
|
||||
|
||||
/**
|
||||
* Return first header value given name
|
||||
*
|
||||
* @param String name Header name
|
||||
* @return Mixed
|
||||
*/
|
||||
get (name) {
|
||||
const list = this[MAP][sanitizeName(name)]
|
||||
if (!list) {
|
||||
return null
|
||||
}
|
||||
|
||||
return list.join(', ')
|
||||
}
|
||||
|
||||
/**
|
||||
* Iterate over all headers
|
||||
*
|
||||
* @param Function callback Executed for each item with parameters (value, name, thisArg)
|
||||
* @param Boolean thisArg `this` context for callback function
|
||||
* @return Void
|
||||
*/
|
||||
forEach (callback, thisArg) {
|
||||
let pairs = getHeaderPairs(this)
|
||||
let i = 0
|
||||
while (i < pairs.length) {
|
||||
const name = pairs[i][0]
|
||||
const value = pairs[i][1]
|
||||
callback.call(thisArg, value, name, this)
|
||||
pairs = getHeaderPairs(this)
|
||||
i++
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Overwrite header values given name
|
||||
*
|
||||
* @param String name Header name
|
||||
* @param String value Header value
|
||||
* @return Void
|
||||
*/
|
||||
set (name, value) {
|
||||
this[MAP][sanitizeName(name)] = [sanitizeValue(value)]
|
||||
}
|
||||
|
||||
/**
|
||||
* Append a value onto existing header
|
||||
*
|
||||
* @param String name Header name
|
||||
* @param String value Header value
|
||||
* @return Void
|
||||
*/
|
||||
append (name, value) {
|
||||
if (!this.has(name)) {
|
||||
this.set(name, value)
|
||||
return
|
||||
}
|
||||
|
||||
this[MAP][sanitizeName(name)].push(sanitizeValue(value))
|
||||
}
|
||||
|
||||
/**
|
||||
* Check for header name existence
|
||||
*
|
||||
* @param String name Header name
|
||||
* @return Boolean
|
||||
*/
|
||||
has (name) {
|
||||
return !!this[MAP][sanitizeName(name)]
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete all header values given name
|
||||
*
|
||||
* @param String name Header name
|
||||
* @return Void
|
||||
*/
|
||||
delete (name) {
|
||||
delete this[MAP][sanitizeName(name)]
|
||||
};
|
||||
|
||||
/**
|
||||
* Return raw headers (non-spec api)
|
||||
*
|
||||
* @return Object
|
||||
*/
|
||||
raw () {
|
||||
return this[MAP]
|
||||
}
|
||||
|
||||
/**
|
||||
* Get an iterator on keys.
|
||||
*
|
||||
* @return Iterator
|
||||
*/
|
||||
keys () {
|
||||
return createHeadersIterator(this, 'key')
|
||||
}
|
||||
|
||||
/**
|
||||
* Get an iterator on values.
|
||||
*
|
||||
* @return Iterator
|
||||
*/
|
||||
values () {
|
||||
return createHeadersIterator(this, 'value')
|
||||
}
|
||||
|
||||
/**
|
||||
* Get an iterator on entries.
|
||||
*
|
||||
* This is the default iterator of the Headers object.
|
||||
*
|
||||
* @return Iterator
|
||||
*/
|
||||
[Symbol.iterator] () {
|
||||
return createHeadersIterator(this, 'key+value')
|
||||
}
|
||||
}
|
||||
Headers.prototype.entries = Headers.prototype[Symbol.iterator]
|
||||
|
||||
Object.defineProperty(Headers.prototype, Symbol.toStringTag, {
|
||||
value: 'HeadersPrototype',
|
||||
writable: false,
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
})
|
||||
|
||||
function getHeaderPairs (headers, kind) {
|
||||
const keys = Object.keys(headers[MAP]).sort()
|
||||
return keys.map(
|
||||
kind === 'key'
|
||||
? k => [k]
|
||||
: k => [k, headers.get(k)]
|
||||
)
|
||||
}
|
||||
|
||||
const INTERNAL = Symbol('internal')
|
||||
|
||||
function createHeadersIterator (target, kind) {
|
||||
const iterator = Object.create(HeadersIteratorPrototype)
|
||||
iterator[INTERNAL] = {
|
||||
target,
|
||||
kind,
|
||||
index: 0
|
||||
}
|
||||
return iterator
|
||||
}
|
||||
|
||||
const HeadersIteratorPrototype = Object.setPrototypeOf({
|
||||
next () {
|
||||
// istanbul ignore if
|
||||
if (!this ||
|
||||
Object.getPrototypeOf(this) !== HeadersIteratorPrototype) {
|
||||
throw new TypeError('Value of `this` is not a HeadersIterator')
|
||||
}
|
||||
|
||||
const target = this[INTERNAL].target
|
||||
const kind = this[INTERNAL].kind
|
||||
const index = this[INTERNAL].index
|
||||
const values = getHeaderPairs(target, kind)
|
||||
const len = values.length
|
||||
if (index >= len) {
|
||||
return {
|
||||
value: undefined,
|
||||
done: true
|
||||
}
|
||||
}
|
||||
|
||||
const pair = values[index]
|
||||
this[INTERNAL].index = index + 1
|
||||
|
||||
let result
|
||||
if (kind === 'key') {
|
||||
result = pair[0]
|
||||
} else if (kind === 'value') {
|
||||
result = pair[1]
|
||||
} else {
|
||||
result = pair
|
||||
}
|
||||
|
||||
return {
|
||||
value: result,
|
||||
done: false
|
||||
}
|
||||
}
|
||||
}, Object.getPrototypeOf(
|
||||
Object.getPrototypeOf([][Symbol.iterator]())
|
||||
))
|
||||
|
||||
Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, {
|
||||
value: 'HeadersIterator',
|
||||
writable: false,
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
})
|
||||
|
||||
module.exports = Headers
|
||||
214
node_modules/node-fetch-npm/src/index.js
generated
vendored
Normal file
214
node_modules/node-fetch-npm/src/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,214 @@
|
|||
'use strict'
|
||||
|
||||
/**
|
||||
* index.js
|
||||
*
|
||||
* a request API compatible with window.fetch
|
||||
*/
|
||||
|
||||
const url = require('url')
|
||||
const http = require('http')
|
||||
const https = require('https')
|
||||
const zlib = require('zlib')
|
||||
const PassThrough = require('stream').PassThrough
|
||||
|
||||
const Body = require('./body.js')
|
||||
const writeToStream = Body.writeToStream
|
||||
const Response = require('./response')
|
||||
const Headers = require('./headers')
|
||||
const Request = require('./request')
|
||||
const getNodeRequestOptions = Request.getNodeRequestOptions
|
||||
const FetchError = require('./fetch-error')
|
||||
const isURL = /^https?:/
|
||||
|
||||
/**
|
||||
* Fetch function
|
||||
*
|
||||
* @param Mixed url Absolute url or Request instance
|
||||
* @param Object opts Fetch options
|
||||
* @return Promise
|
||||
*/
|
||||
exports = module.exports = fetch
|
||||
function fetch (uri, opts) {
|
||||
// allow custom promise
|
||||
if (!fetch.Promise) {
|
||||
throw new Error('native promise missing, set fetch.Promise to your favorite alternative')
|
||||
}
|
||||
|
||||
Body.Promise = fetch.Promise
|
||||
|
||||
// wrap http.request into fetch
|
||||
return new fetch.Promise((resolve, reject) => {
|
||||
// build request object
|
||||
const request = new Request(uri, opts)
|
||||
const options = getNodeRequestOptions(request)
|
||||
|
||||
const send = (options.protocol === 'https:' ? https : http).request
|
||||
|
||||
// http.request only support string as host header, this hack make custom host header possible
|
||||
if (options.headers.host) {
|
||||
options.headers.host = options.headers.host[0]
|
||||
}
|
||||
|
||||
// send request
|
||||
const req = send(options)
|
||||
let reqTimeout
|
||||
|
||||
if (request.timeout) {
|
||||
req.once('socket', socket => {
|
||||
reqTimeout = setTimeout(() => {
|
||||
req.abort()
|
||||
reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout'))
|
||||
}, request.timeout)
|
||||
})
|
||||
}
|
||||
|
||||
req.on('error', err => {
|
||||
clearTimeout(reqTimeout)
|
||||
reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err))
|
||||
})
|
||||
|
||||
req.on('response', res => {
|
||||
clearTimeout(reqTimeout)
|
||||
|
||||
// handle redirect
|
||||
if (fetch.isRedirect(res.statusCode) && request.redirect !== 'manual') {
|
||||
if (request.redirect === 'error') {
|
||||
reject(new FetchError(`redirect mode is set to error: ${request.url}`, 'no-redirect'))
|
||||
return
|
||||
}
|
||||
|
||||
if (request.counter >= request.follow) {
|
||||
reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'))
|
||||
return
|
||||
}
|
||||
|
||||
if (!res.headers.location) {
|
||||
reject(new FetchError(`redirect location header missing at: ${request.url}`, 'invalid-redirect'))
|
||||
return
|
||||
}
|
||||
// Remove authorization if changing hostnames (but not if just
|
||||
// changing ports or protocols). This matches the behavior of request:
|
||||
// https://github.com/request/request/blob/b12a6245/lib/redirect.js#L134-L138
|
||||
const resolvedUrl = url.resolve(request.url, res.headers.location)
|
||||
let redirectURL = ''
|
||||
if (!isURL.test(res.headers.location)) {
|
||||
redirectURL = url.parse(resolvedUrl)
|
||||
} else {
|
||||
redirectURL = url.parse(res.headers.location)
|
||||
}
|
||||
if (url.parse(request.url).hostname !== redirectURL.hostname) {
|
||||
request.headers.delete('authorization')
|
||||
}
|
||||
|
||||
// per fetch spec, for POST request with 301/302 response, or any request with 303 response, use GET when following redirect
|
||||
if (res.statusCode === 303 ||
|
||||
((res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST')) {
|
||||
request.method = 'GET'
|
||||
request.body = null
|
||||
request.headers.delete('content-length')
|
||||
}
|
||||
|
||||
request.counter++
|
||||
|
||||
resolve(fetch(resolvedUrl, request))
|
||||
return
|
||||
}
|
||||
|
||||
// normalize location header for manual redirect mode
|
||||
const headers = new Headers()
|
||||
for (const name of Object.keys(res.headers)) {
|
||||
if (Array.isArray(res.headers[name])) {
|
||||
for (const val of res.headers[name]) {
|
||||
headers.append(name, val)
|
||||
}
|
||||
} else {
|
||||
headers.append(name, res.headers[name])
|
||||
}
|
||||
}
|
||||
if (request.redirect === 'manual' && headers.has('location')) {
|
||||
headers.set('location', url.resolve(request.url, headers.get('location')))
|
||||
}
|
||||
|
||||
// prepare response
|
||||
let body = res.pipe(new PassThrough())
|
||||
const responseOptions = {
|
||||
url: request.url,
|
||||
status: res.statusCode,
|
||||
statusText: res.statusMessage,
|
||||
headers: headers,
|
||||
size: request.size,
|
||||
timeout: request.timeout
|
||||
}
|
||||
|
||||
// HTTP-network fetch step 16.1.2
|
||||
const codings = headers.get('Content-Encoding')
|
||||
|
||||
// HTTP-network fetch step 16.1.3: handle content codings
|
||||
|
||||
// in following scenarios we ignore compression support
|
||||
// 1. compression support is disabled
|
||||
// 2. HEAD request
|
||||
// 3. no Content-Encoding header
|
||||
// 4. no content response (204)
|
||||
// 5. content not modified response (304)
|
||||
if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) {
|
||||
resolve(new Response(body, responseOptions))
|
||||
return
|
||||
}
|
||||
|
||||
// Be less strict when decoding compressed responses, since sometimes
|
||||
// servers send slightly invalid responses that are still accepted
|
||||
// by common browsers.
|
||||
// Always using Z_SYNC_FLUSH is what cURL does.
|
||||
const zlibOptions = {
|
||||
flush: zlib.Z_SYNC_FLUSH,
|
||||
finishFlush: zlib.Z_SYNC_FLUSH
|
||||
}
|
||||
|
||||
// for gzip
|
||||
if (codings === 'gzip' || codings === 'x-gzip') {
|
||||
body = body.pipe(zlib.createGunzip(zlibOptions))
|
||||
resolve(new Response(body, responseOptions))
|
||||
return
|
||||
}
|
||||
|
||||
// for deflate
|
||||
if (codings === 'deflate' || codings === 'x-deflate') {
|
||||
// handle the infamous raw deflate response from old servers
|
||||
// a hack for old IIS and Apache servers
|
||||
const raw = res.pipe(new PassThrough())
|
||||
raw.once('data', chunk => {
|
||||
// see http://stackoverflow.com/questions/37519828
|
||||
if ((chunk[0] & 0x0F) === 0x08) {
|
||||
body = body.pipe(zlib.createInflate(zlibOptions))
|
||||
} else {
|
||||
body = body.pipe(zlib.createInflateRaw(zlibOptions))
|
||||
}
|
||||
resolve(new Response(body, responseOptions))
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
// otherwise, use response as-is
|
||||
resolve(new Response(body, responseOptions))
|
||||
})
|
||||
|
||||
writeToStream(req, request)
|
||||
})
|
||||
};
|
||||
|
||||
/**
|
||||
* Redirect code matching
|
||||
*
|
||||
* @param Number code Status code
|
||||
* @return Boolean
|
||||
*/
|
||||
fetch.isRedirect = code => code === 301 || code === 302 || code === 303 || code === 307 || code === 308
|
||||
|
||||
// expose Promise
|
||||
fetch.Promise = global.Promise
|
||||
exports.Headers = Headers
|
||||
exports.Request = Request
|
||||
exports.Response = Response
|
||||
exports.FetchError = FetchError
|
||||
174
node_modules/node-fetch-npm/src/request.js
generated
vendored
Normal file
174
node_modules/node-fetch-npm/src/request.js
generated
vendored
Normal file
|
|
@ -0,0 +1,174 @@
|
|||
'use strict'
|
||||
|
||||
/**
|
||||
* request.js
|
||||
*
|
||||
* Request class contains server only options
|
||||
*/
|
||||
|
||||
const url = require('url')
|
||||
const Headers = require('./headers.js')
|
||||
const Body = require('./body.js')
|
||||
const clone = Body.clone
|
||||
const extractContentType = Body.extractContentType
|
||||
const getTotalBytes = Body.getTotalBytes
|
||||
|
||||
const PARSED_URL = Symbol('url')
|
||||
|
||||
/**
|
||||
* Request class
|
||||
*
|
||||
* @param Mixed input Url or Request instance
|
||||
* @param Object init Custom options
|
||||
* @return Void
|
||||
*/
|
||||
class Request {
|
||||
constructor (input, init) {
|
||||
if (!init) init = {}
|
||||
let parsedURL
|
||||
|
||||
// normalize input
|
||||
if (!(input instanceof Request)) {
|
||||
if (input && input.href) {
|
||||
// in order to support Node.js' Url objects; though WHATWG's URL objects
|
||||
// will fall into this branch also (since their `toString()` will return
|
||||
// `href` property anyway)
|
||||
parsedURL = url.parse(input.href)
|
||||
} else {
|
||||
// coerce input to a string before attempting to parse
|
||||
parsedURL = url.parse(`${input}`)
|
||||
}
|
||||
input = {}
|
||||
} else {
|
||||
parsedURL = url.parse(input.url)
|
||||
}
|
||||
|
||||
let method = init.method || input.method || 'GET'
|
||||
|
||||
if ((init.body != null || (input instanceof Request && input.body !== null)) &&
|
||||
(method === 'GET' || method === 'HEAD')) {
|
||||
throw new TypeError('Request with GET/HEAD method cannot have body')
|
||||
}
|
||||
|
||||
let inputBody = init.body != null
|
||||
? init.body
|
||||
: input instanceof Request && input.body !== null
|
||||
? clone(input)
|
||||
: null
|
||||
|
||||
Body.call(this, inputBody, {
|
||||
timeout: init.timeout || input.timeout || 0,
|
||||
size: init.size || input.size || 0
|
||||
})
|
||||
|
||||
// fetch spec options
|
||||
this.method = method.toUpperCase()
|
||||
this.redirect = init.redirect || input.redirect || 'follow'
|
||||
this.headers = new Headers(init.headers || input.headers || {})
|
||||
|
||||
if (init.body != null) {
|
||||
const contentType = extractContentType(this)
|
||||
if (contentType !== null && !this.headers.has('Content-Type')) {
|
||||
this.headers.append('Content-Type', contentType)
|
||||
}
|
||||
}
|
||||
|
||||
// server only options
|
||||
this.follow = init.follow !== undefined
|
||||
? init.follow : input.follow !== undefined
|
||||
? input.follow : 20
|
||||
this.compress = init.compress !== undefined
|
||||
? init.compress : input.compress !== undefined
|
||||
? input.compress : true
|
||||
this.counter = init.counter || input.counter || 0
|
||||
this.agent = init.agent || input.agent
|
||||
|
||||
this[PARSED_URL] = parsedURL
|
||||
Object.defineProperty(this, Symbol.toStringTag, {
|
||||
value: 'Request',
|
||||
writable: false,
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
})
|
||||
}
|
||||
|
||||
get url () {
|
||||
return url.format(this[PARSED_URL])
|
||||
}
|
||||
|
||||
/**
|
||||
* Clone this request
|
||||
*
|
||||
* @return Request
|
||||
*/
|
||||
clone () {
|
||||
return new Request(this)
|
||||
}
|
||||
}
|
||||
|
||||
Body.mixIn(Request.prototype)
|
||||
|
||||
Object.defineProperty(Request.prototype, Symbol.toStringTag, {
|
||||
value: 'RequestPrototype',
|
||||
writable: false,
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
})
|
||||
|
||||
exports = module.exports = Request
|
||||
|
||||
exports.getNodeRequestOptions = function getNodeRequestOptions (request) {
|
||||
const parsedURL = request[PARSED_URL]
|
||||
const headers = new Headers(request.headers)
|
||||
|
||||
// fetch step 3
|
||||
if (!headers.has('Accept')) {
|
||||
headers.set('Accept', '*/*')
|
||||
}
|
||||
|
||||
// Basic fetch
|
||||
if (!parsedURL.protocol || !parsedURL.hostname) {
|
||||
throw new TypeError('Only absolute URLs are supported')
|
||||
}
|
||||
|
||||
if (!/^https?:$/.test(parsedURL.protocol)) {
|
||||
throw new TypeError('Only HTTP(S) protocols are supported')
|
||||
}
|
||||
|
||||
// HTTP-network-or-cache fetch steps 5-9
|
||||
let contentLengthValue = null
|
||||
if (request.body == null && /^(POST|PUT)$/i.test(request.method)) {
|
||||
contentLengthValue = '0'
|
||||
}
|
||||
if (request.body != null) {
|
||||
const totalBytes = getTotalBytes(request)
|
||||
if (typeof totalBytes === 'number') {
|
||||
contentLengthValue = String(totalBytes)
|
||||
}
|
||||
}
|
||||
if (contentLengthValue) {
|
||||
headers.set('Content-Length', contentLengthValue)
|
||||
}
|
||||
|
||||
// HTTP-network-or-cache fetch step 12
|
||||
if (!headers.has('User-Agent')) {
|
||||
headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)')
|
||||
}
|
||||
|
||||
// HTTP-network-or-cache fetch step 16
|
||||
if (request.compress) {
|
||||
headers.set('Accept-Encoding', 'gzip,deflate')
|
||||
}
|
||||
if (!headers.has('Connection') && !request.agent) {
|
||||
headers.set('Connection', 'close')
|
||||
}
|
||||
|
||||
// HTTP-network fetch step 4
|
||||
// chunked encoding is handled by Node.js
|
||||
|
||||
return Object.assign({}, parsedURL, {
|
||||
method: request.method,
|
||||
headers: headers.raw(),
|
||||
agent: request.agent
|
||||
})
|
||||
}
|
||||
71
node_modules/node-fetch-npm/src/response.js
generated
vendored
Normal file
71
node_modules/node-fetch-npm/src/response.js
generated
vendored
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
'use strict'
|
||||
|
||||
/**
|
||||
* response.js
|
||||
*
|
||||
* Response class provides content decoding
|
||||
*/
|
||||
|
||||
const STATUS_CODES = require('http').STATUS_CODES
|
||||
const Headers = require('./headers.js')
|
||||
const Body = require('./body.js')
|
||||
const clone = Body.clone
|
||||
|
||||
/**
|
||||
* Response class
|
||||
*
|
||||
* @param Stream body Readable stream
|
||||
* @param Object opts Response options
|
||||
* @return Void
|
||||
*/
|
||||
class Response {
|
||||
constructor (body, opts) {
|
||||
if (!opts) opts = {}
|
||||
Body.call(this, body, opts)
|
||||
|
||||
this.url = opts.url
|
||||
this.status = opts.status || 200
|
||||
this.statusText = opts.statusText || STATUS_CODES[this.status]
|
||||
|
||||
this.headers = new Headers(opts.headers)
|
||||
|
||||
Object.defineProperty(this, Symbol.toStringTag, {
|
||||
value: 'Response',
|
||||
writable: false,
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
})
|
||||
}
|
||||
|
||||
/**
|
||||
* Convenience property representing if the request ended normally
|
||||
*/
|
||||
get ok () {
|
||||
return this.status >= 200 && this.status < 300
|
||||
}
|
||||
|
||||
/**
|
||||
* Clone this response
|
||||
*
|
||||
* @return Response
|
||||
*/
|
||||
clone () {
|
||||
return new Response(clone(this), {
|
||||
url: this.url,
|
||||
status: this.status,
|
||||
statusText: this.statusText,
|
||||
headers: this.headers,
|
||||
ok: this.ok
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
Body.mixIn(Response.prototype)
|
||||
|
||||
Object.defineProperty(Response.prototype, Symbol.toStringTag, {
|
||||
value: 'ResponsePrototype',
|
||||
writable: false,
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
})
|
||||
module.exports = Response
|
||||
Loading…
Add table
Add a link
Reference in a new issue