1.0.7

Bumps [xo](https://github.com/xojs/xo) from 0.30.0 to 0.32.0.
- [Release notes](https://github.com/xojs/xo/releases)
- [Commits](https://github.com/xojs/xo/compare/v0.30.0...v0.32.0)

Signed-off-by: dependabot-preview[bot] <support@dependabot.com>

Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>

.gitignore

@@ -1,3 +1,8 @@
+# Lock files
+
+package-lock.json
+yarn.lock
+
 # Logs
 logs
 *.log
@@ -57,5 +62,4 @@ typings/
 # dotenv environment variables file
 .env
 
-# next.js build output
+index.d.ts
-.next

.npmrc

@@ -0,0 +1 @@
+package-lock=false

.travis.yml

@@ -1,11 +1,13 @@
 language: node_js
+
 node_js:
-  - "8"
+  - "lts/*"
-  - "10"
-  - "12"
   - "node"
+
 script:
+  - npm run lint
   - npm run coverage
+
 cache:
   directories:
     - node_modules

CHANGELOG.md

@@ -1,10 +1,25 @@
-
 Changelog
 =========
 
+## v1.0.7
+
+- Enhance: create TypeScript declarations from JSDoc (#45)
+- Enhance: operate on blob parts (byte sequence) (#44)
+- Enhance: use a `WeakMap` for private properties (#42) 
+- Other: update formatting
+
+## v1.0.6
+
+- Enhance: use upstream Blob directly in typings (#38)
+- Other: update dependencies
+
+## v1.0.5
+
+- Other: no change to code, update dev dependency to address vulnerability reports
+
 ## v1.0.4
 
-- Other: general code revwrite to pass linting, prepare for `node-fetch` release v3
+- Other: general code rewrite to pass linting, prepare for `node-fetch` release v3
 
 ## v1.0.3
 

README.md

@@ -1,38 +1,39 @@
-
+# fetch-blob
-fetch-blob
-==========
 
 [![npm version][npm-image]][npm-url]
 [![build status][travis-image]][travis-url]
 [![coverage status][codecov-image]][codecov-url]
 [![install size][install-size-image]][install-size-url]
 
-A Blob implementation on node.js, originally from node-fetch
+A Blob implementation in Node.js, originally from [node-fetch](https://github.com/node-fetch/node-fetch).
 
-## Usage
+## Installation
 
 ```sh
-$ npm install fetch-blob
+npm install fetch-blob
 ```
 
+## Usage
+
 ```js
 const Blob = require('fetch-blob');
 const fetch = require('node-fetch');
+
 fetch('https://httpbin.org/post', {
-        method: 'POST',
+    method: 'POST',
-        body: new Blob(['hello'], { type: 'text/plain' })
+    body: new Blob(['Hello World'], { type: 'text/plain' })
-    })
+})
-    .then(res => res.json()) // expecting a json response
+    .then(res => res.json());
     .then(json => console.log(json));
 ```
 
-See [MDN doc](https://developer.mozilla.org/en-US/docs/Web/API/Blob) and [Tests](https://github.com/bitinn/fetch-blob/blob/master/test.js) for more details.
+See the [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/API/Blob) and [tests](https://github.com/node-fetch/fetch-blob/blob/master/test.js) for more details.
 
 [npm-image]: https://flat.badgen.net/npm/v/fetch-blob
 [npm-url]: https://www.npmjs.com/package/fetch-blob
-[travis-image]: https://flat.badgen.net/travis/bitinn/fetch-blob
+[travis-image]: https://flat.badgen.net/travis/node-fetch/fetch-blob
-[travis-url]: https://travis-ci.org/bitinn/fetch-blob
+[travis-url]: https://travis-ci.org/node-fetch/fetch-blob
-[codecov-image]: https://flat.badgen.net/codecov/c/github/bitinn/fetch-blob/master
+[codecov-image]: https://flat.badgen.net/codecov/c/github/node-fetch/fetch-blob/master
-[codecov-url]: https://codecov.io/gh/bitinn/fetch-blob
+[codecov-url]: https://codecov.io/gh/node-fetch/fetch-blob
 [install-size-image]: https://flat.badgen.net/packagephobia/install/fetch-blob
 [install-size-url]: https://packagephobia.now.sh/result?p=fetch-blob

blob.js

@@ -1,135 +0,0 @@
-// Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js
-// (MIT licensed)
-
-const Stream = require('stream');
-
-// Fix for "Readable" isn't a named export issue
-const {Readable} = Stream;
-
-const BUFFER = Symbol('buffer');
-const TYPE = Symbol('type');
-
-class Blob {
-	constructor(...args) {
-		this[TYPE] = '';
-
-		const blobParts = args[0];
-		const options = args[1];
-
-		const buffers = [];
-		/* eslint-disable-next-line no-unused-vars */
-		let size = 0;
-
-		if (blobParts) {
-			blobParts.forEach(element => {
-				let buffer;
-				if (element instanceof Buffer) {
-					buffer = element;
-				} else if (ArrayBuffer.isView(element)) {
-					buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
-				} else if (element instanceof ArrayBuffer) {
-					buffer = Buffer.from(element);
-				} else if (element instanceof Blob) {
-					buffer = element[BUFFER];
-				} else {
-					buffer = Buffer.from(typeof element === 'string' ? element : String(element));
-				}
-
-				size += buffer.length;
-				buffers.push(buffer);
-			});
-		}
-
-		this[BUFFER] = Buffer.concat(buffers);
-
-		const type = options && options.type !== undefined && String(options.type).toLowerCase();
-		if (type && !/[^\u0020-\u007E]/.test(type)) {
-			this[TYPE] = type;
-		}
-
-		if (options && Buffer.isBuffer(options.buffer)) {
-			this[BUFFER] = options.buffer;
-		}
-	}
-
-	get size() {
-		return this[BUFFER].length;
-	}
-
-	get type() {
-		return this[TYPE];
-	}
-
-	text() {
-		return Promise.resolve(this[BUFFER].toString());
-	}
-
-	arrayBuffer() {
-		const buf = this[BUFFER];
-		const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-		return Promise.resolve(ab);
-	}
-
-	stream() {
-		const readable = new Readable();
-		readable._read = () => { };
-		readable.push(this[BUFFER]);
-		readable.push(null);
-		return readable;
-	}
-
-	toString() {
-		return '[object Blob]';
-	}
-
-	slice(...args) {
-		const {size} = this;
-
-		const start = args[0];
-		const end = args[1];
-		let relativeStart;
-		let 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: args[2]});
-		blob[BUFFER] = slicedBuffer;
-		return blob;
-	}
-}
-
-Object.defineProperties(Blob.prototype, {
-	size: {enumerable: true},
-	type: {enumerable: true},
-	slice: {enumerable: true}
-});
-
-Object.defineProperty(Blob.prototype, Symbol.toStringTag, {
-	value: 'Blob',
-	writable: false,
-	enumerable: false,
-	configurable: true
-});
-
-module.exports = Blob;

index.js

@@ -0,0 +1,185 @@
+const {Readable} = require('stream');
+
+/**
+ * @type {WeakMap<Blob, {type: string, size: number, parts: (Blob | Buffer)[] }>}
+ */
+const wm = new WeakMap();
+
+async function * read(parts) {
+	for (const part of parts) {
+		if ('stream' in part) {
+			yield * part.stream();
+		} else {
+			yield part;
+		}
+	}
+}
+
+/**
+ * @template T
+ * @param {T} object
+ * @returns {T is Blob}
+ */
+const isBlob = object => {
+	return (
+		typeof object === 'object' &&
+		typeof object.stream === 'function' &&
+		typeof object.constructor === 'function' &&
+		/^(Blob|File)$/.test(object[Symbol.toStringTag])
+	);
+};
+
+class Blob {
+	/**
+	 * The Blob() constructor returns a new Blob object. The content
+	 * of the blob consists of the concatenation of the values given
+	 * in the parameter array.
+	 *
+	 * @param {(ArrayBufferLike | ArrayBufferView | Blob | Buffer | string)[]} blobParts
+	 * @param {{ type?: string }} [options]
+	 */
+	constructor(blobParts = [], options = {type: ''}) {
+		let size = 0;
+
+		const parts = blobParts.map(element => {
+			let buffer;
+			if (Buffer.isBuffer(element)) {
+				buffer = element;
+			} else if (ArrayBuffer.isView(element)) {
+				buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
+			} else if (element instanceof ArrayBuffer) {
+				buffer = Buffer.from(element);
+			} else if (isBlob(element)) {
+				buffer = element;
+			} else {
+				buffer = Buffer.from(typeof element === 'string' ? element : String(element));
+			}
+
+			size += buffer.length || buffer.size || 0;
+			return buffer;
+		});
+
+		const type = options.type === undefined ? '' : String(options.type).toLowerCase();
+
+		wm.set(this, {
+			type: /[^\u0020-\u007E]/.test(type) ? '' : type,
+			size,
+			parts
+		});
+	}
+
+	/**
+	 * The Blob interface's size property returns the
+	 * size of the Blob in bytes.
+	 */
+	get size() {
+		return wm.get(this).size;
+	}
+
+	/**
+	 * The type property of a Blob object returns the MIME type of the file.
+	 */
+	get type() {
+		return wm.get(this).type;
+	}
+
+	/**
+	 * The text() method in the Blob interface returns a Promise
+	 * that resolves with a string containing the contents of
+	 * the blob, interpreted as UTF-8.
+	 *
+	 * @return {Promise<string>}
+	 */
+	async text() {
+		return Buffer.from(await this.arrayBuffer()).toString();
+	}
+
+	/**
+	 * The arrayBuffer() method in the Blob interface returns a
+	 * Promise that resolves with the contents of the blob as
+	 * binary data contained in an ArrayBuffer.
+	 *
+	 * @return {Promise<ArrayBuffer>}
+	 */
+	async arrayBuffer() {
+		const data = new Uint8Array(this.size);
+		let offset = 0;
+		for await (const chunk of this.stream()) {
+			data.set(chunk, offset);
+			offset += chunk.length;
+		}
+
+		return data.buffer;
+	}
+
+	/**
+	 * The Blob interface's stream() method is difference from native
+	 * and uses node streams instead of whatwg streams.
+	 *
+	 * @returns {Readable} Node readable stream
+	 */
+	stream() {
+		return Readable.from(read(wm.get(this).parts));
+	}
+
+	/**
+	 * The Blob interface's slice() method creates and returns a
+	 * new Blob object which contains data from a subset of the
+	 * blob on which it's called.
+	 *
+	 * @param {number} [start]
+	 * @param {number} [end]
+	 * @param {string} [type]
+	 */
+	slice(start = 0, end = this.size, type = '') {
+		const {size} = this;
+
+		let relativeStart = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
+		let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+
+		const span = Math.max(relativeEnd - relativeStart, 0);
+		const parts = wm.get(this).parts.values();
+		const blobParts = [];
+		let added = 0;
+
+		for (const part of parts) {
+			const size = ArrayBuffer.isView(part) ? part.byteLength : part.size;
+			if (relativeStart && size <= relativeStart) {
+				// Skip the beginning and change the relative
+				// start & end position as we skip the unwanted parts
+				relativeStart -= size;
+				relativeEnd -= size;
+			} else {
+				const chunk = part.slice(relativeStart, Math.min(size, relativeEnd));
+				blobParts.push(chunk);
+				added += size;
+				relativeStart = 0; // All next sequental parts should start at 0
+
+				// don't add the overflow to new blobParts
+				if (added >= span) {
+					break;
+				}
+			}
+		}
+
+		const blob = new Blob([], {type});
+		Object.assign(wm.get(blob), {size: span, parts: blobParts});
+
+		return blob;
+	}
+}
+
+Object.defineProperties(Blob.prototype, {
+	size: {enumerable: true},
+	type: {enumerable: true},
+	slice: {enumerable: true}
+});
+
+Object.defineProperty(Blob.prototype, Symbol.toStringTag, {
+	value: 'Blob',
+	writable: false,
+	enumerable: false,
+	configurable: true
+});
+
+module.exports = Blob;

package.json

@@ -1,32 +1,52 @@
 {
-  "name": "fetch-blob",
+    "name": "fetch-blob",
-  "version": "1.0.4",
+    "version": "1.0.7",
-  "description": "A Blob implementation on node.js, originally from node-fetch",
+    "description": "A Blob implementation in Node.js, originally from node-fetch.",
-  "main": "blob.js",
+    "main": "index.js",
-  "scripts": {
+    "files": [
-    "test": "ava",
+        "index.js",
-    "report": "nyc ava",
+        "index.d.ts"
-    "coverage": "nyc --reporter json --reporter text ava && codecov -f coverage/coverage-final.json"
+    ],
-  },
+    "scripts": {
-  "repository": {
+        "lint": "xo",
-    "type": "git",
+        "test": "xo && ava",
-    "url": "git+https://github.com/bitinn/fetch-blob.git"
+        "report": "nyc ava",
-  },
+        "coverage": "nyc --reporter json --reporter text ava && codecov -f coverage/coverage-final.json",
-  "keywords": [
+        "prepublishOnly": "tsc --declaration --emitDeclarationOnly --allowJs index.js"
-    "blob",
+    },
-    "node-fetch"
+    "repository": "https://github.com/node-fetch/fetch-blob.git",
-  ],
+    "keywords": [
-  "author": "David Frank",
+        "blob",
-  "license": "MIT",
+        "node-fetch"
-  "bugs": {
+    ],
-    "url": "https://github.com/bitinn/fetch-blob/issues"
+    "engines": {
-  },
+        "node": "^10.17.0"
-  "homepage": "https://github.com/bitinn/fetch-blob#readme",
+    },
-  "devDependencies": {
+    "author": "David Frank",
-    "ava": "^1.4.1",
+    "license": "MIT",
-    "codecov": "^3.5.0",
+    "bugs": {
-    "get-stream": "^5.1.0",
+        "url": "https://github.com/node-fetch/fetch-blob/issues"
-    "node-fetch": "^2.6.0",
+    },
-    "nyc": "^14.1.1"
+    "homepage": "https://github.com/node-fetch/fetch-blob#readme",
-  }
+    "devDependencies": {
+        "ava": "^3.8.2",
+        "codecov": "^3.7.0",
+        "get-stream": "^5.1.0",
+        "node-fetch": "^2.6.0",
+        "nyc": "^15.1.0",
+        "typescript": "^3.9.5",
+        "xo": "^0.32.0"
+    },
+    "xo": {
+        "overrides": [
+            {
+                "files": "test.js",
+                "rules": {
+                    "node/no-unsupported-features/es-syntax": 0,
+                    "node/no-unsupported-features/node-builtins": 0
+                }
+            }
+        ]
+    },
+    "dependencies": {}
 }

test.js

@@ -1,87 +1,137 @@
+const test = require('ava');
+const Blob = require('.');
+const getStream = require('get-stream');
+const {Response} = require('node-fetch');
 
-import test from 'ava';
+test('new Blob()', t => {
-import Blob from './blob';
+	const blob = new Blob(); // eslint-disable-line no-unused-vars
-import util from 'util';
-import stream from 'stream';
-import getStream from 'get-stream';
-import { Response } from 'node-fetch';
-
-const TextDecoder = util.TextDecoder;
-const Readable = stream.Readable;
-
-test('Blob ctor', t => {
-	let data = 'a=1';
-	let blob = new Blob([data]);
 	t.pass();
 });
 
+test('new Blob(parts)', t => {
+	const data = 'a=1';
+	const blob = new Blob([data]); // eslint-disable-line no-unused-vars
+	t.pass();
+});
+
+test('Blob ctor parts', async t => {
+	const parts = [
+		'a',
+		new Uint8Array([98]),
+		new Uint16Array([25699]),
+		new Uint8Array([101]).buffer,
+		Buffer.from('f'),
+		new Blob(['g']),
+		{}
+	];
+
+	const blob = new Blob(parts);
+	t.is(await blob.text(), 'abcdefg[object Object]');
+});
+
 test('Blob size', t => {
-	let data = 'a=1';
+	const data = 'a=1';
-	let blob = new Blob([data]);
+	const blob = new Blob([data]);
 	t.is(blob.size, data.length);
 });
 
 test('Blob type', t => {
-	let data = 'a=1';
+	const type = 'text/plain';
-	let type = 'text/plain';
+	const blob = new Blob([], {type});
-	let blob = new Blob([data], { type });
 	t.is(blob.type, type);
 });
 
+test('Blob slice type', t => {
+	const type = 'text/plain';
+	const blob = new Blob().slice(0, 0, type);
+	t.is(blob.type, type);
+});
+
+test('invalid Blob type', t => {
+	const blob = new Blob([], {type: '\u001Ftext/plain'});
+	t.is(blob.type, '');
+});
+
+test('invalid Blob slice type', t => {
+	const blob = new Blob().slice(0, 0, '\u001Ftext/plain');
+	t.is(blob.type, '');
+});
+
 test('Blob text()', async t => {
-	let data = 'a=1';
+	const data = 'a=1';
-	let type = 'text/plain';
+	const type = 'text/plain';
-	let blob = new Blob([data], { type });
+	const blob = new Blob([data], {type});
 	t.is(await blob.text(), data);
 });
 
 test('Blob arrayBuffer()', async t => {
-	let data = 'a=1';
+	const data = 'a=1';
-	let type = 'text/plain';
+	const type = 'text/plain';
-	let blob = new Blob([data], { type });
+	const blob = new Blob([data], {type});
 
-	let decoder = new TextDecoder('utf-8');
+	const decoder = new TextDecoder('utf-8');
-	let buffer = await blob.arrayBuffer();
+	const buffer = await blob.arrayBuffer();
 	t.is(decoder.decode(buffer), data);
 });
 
 test('Blob stream()', async t => {
-	let data = 'a=1';
+	const data = 'a=1';
-	let type = 'text/plain';
+	const type = 'text/plain';
-	let blob = new Blob([data], { type });
+	const blob = new Blob([data], {type});
-	let result = await getStream(blob.stream());
+	const result = await getStream(blob.stream());
 	t.is(result, data);
 });
 
 test('Blob toString()', t => {
-	let data = 'a=1';
+	const data = 'a=1';
-	let type = 'text/plain';
+	const type = 'text/plain';
-	let blob = new Blob([data], { type });
+	const blob = new Blob([data], {type});
 	t.is(blob.toString(), '[object Blob]');
 });
 
 test('Blob slice()', async t => {
-	let data = 'a=1';
+	const data = 'abcdefgh';
-	let type = 'text/plain';
+	const blob = new Blob([data]).slice();
-	let blob = new Blob([data], { type });
+	t.is(await blob.text(), data);
-	let blob2 = blob.slice(0, 1);
+});
-	t.is(await blob2.text(), data.slice(0, 1));
+
+test('Blob slice(0, 1)', async t => {
+	const data = 'abcdefgh';
+	const blob = new Blob([data]).slice(0, 1);
+	t.is(await blob.text(), 'a');
+});
+
+test('Blob slice(-1)', async t => {
+	const data = 'abcdefgh';
+	const blob = new Blob([data]).slice(-1);
+	t.is(await blob.text(), 'h');
+});
+
+test('Blob slice(0, -1)', async t => {
+	const data = 'abcdefgh';
+	const blob = new Blob([data]).slice(0, -1);
+	t.is(await blob.text(), 'abcdefg');
+});
+
+test('throw away unwanted parts', async t => {
+	const blob = new Blob(['a', 'b', 'c']).slice(1, 2);
+	t.is(await blob.text(), 'b');
 });
 
 test('Blob works with node-fetch Response.blob()', async t => {
-	let data = 'a=1';
+	const data = 'a=1';
-	let type = 'text/plain';
+	const type = 'text/plain';
-	let blob = new Blob([data], { type });
+	const blob = new Blob([data], {type});
-	let res = new Response(blob);
+	const response = new Response(blob);
-	let blob2 = await res.blob();
+	const blob2 = await response.blob();
 	t.is(await blob2.text(), data);
 });
 
 test('Blob works with node-fetch Response.text()', async t => {
-	let data = 'a=1';
+	const data = 'a=1';
-	let type = 'text/plain';
+	const type = 'text/plain';
-	let blob = new Blob([data], { type });
+	const blob = new Blob([data], {type});
-	let res = new Response(blob);
+	const response = new Response(blob);
-	let text = await res.text();
+	const text = await response.text();
 	t.is(text, data);
 });