Drop Node Buffer code

Buffer is now a subtype of Uint8Array, so no special handling is required anymore

karma.conf.cjs

@@ -22,15 +22,15 @@ module.exports = function(config) {
         ],
 
         // list of files / patterns to load in the browser
-        files: [{ pattern: 'test/browser.test.js', watched: false }],
+        files: [{ pattern: 'test/{browser,common}.test.js', watched: false }],
 
         // list of files / patterns to exclude
         exclude: [],
 
         // preprocess matching files before serving them to the browser
         // available preprocessors: https://www.npmjs.com/search?q=keywords:karma-preprocessor
         preprocessors: {
-            'test/browser.test.js': 'webpack'
+            'test/{browser,common}.test.js': 'webpack'
         },
 
         webpack: {},

lib/node-conversions/browser-fallback.js → lib/node-utils/browser-fallback.js

@@ -1,2 +1 @@
 export const NodeReadableStream = null;
-export const NodeBuffer = null;

lib/node-utils/index.js

@@ -0,0 +1 @@
+export { NodeReadableStream } from './node.js';

lib/node-utils/node.js

@@ -0,0 +1,2 @@
+// This file is only included in the Node build
+export { Readable as NodeReadableStream } from 'node:stream';

lib/reader.js

@@ -2,6 +2,11 @@ import { isUint8Array, isStream, isArrayStream } from './util.js';
 import * as streams from './streams.js';
 
 const doneReadingSet = new WeakSet();
+/**
+ * The external buffer is used to store values that have been peeked or unshifted from the original stream.
+ * Because of how streams are implemented, such values cannot be "put back" in the original stream,
+ * but they need to be returned first when reading from the input again.
+ */
 const externalBuffer = Symbol('externalBuffer');
 
 /**

lib/streams.js

@@ -1,5 +1,4 @@
 import { isStream, isArrayStream, isUint8Array, concatUint8Array } from './util.js';
-import { NodeBuffer } from './node-conversions/index.js';
 import { Reader, externalBuffer } from './reader.js';
 import { ArrayStream, Writer } from './writer.js';
 
@@ -55,9 +54,6 @@ function concat(list) {
   if (typeof list[0] === 'string') {
     return list.join('');
   }
-  if (NodeBuffer && NodeBuffer.isBuffer(list[0])) {
-    return NodeBuffer.concat(list);
-  }
   return concatUint8Array(list);
 }
 
@@ -466,9 +462,8 @@ function slice(input, begin=0, end=Infinity) {
   if (input[externalBuffer]) {
     input = concat(input[externalBuffer].concat([input]));
   }
-  if (isUint8Array(input) && !(NodeBuffer && NodeBuffer.isBuffer(input))) {
-    if (end === Infinity) end = input.length;
-    return input.subarray(begin, end);
+  if (isUint8Array(input)) {
+    return input.subarray(begin, end === Infinity ? input.length : end);
   }
   return input.slice(begin, end);
 }

lib/util.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-prototype-builtins */
 import { isArrayStream } from './writer.js';
-import { NodeReadableStream } from './node-conversions/index.js'
+import { NodeReadableStream as NodeNativeReadableStream } from './node-utils/index.js';
 const isNode = typeof globalThis.process === 'object' &&
   typeof globalThis.process.versions === 'object';
 
@@ -16,7 +16,7 @@ function isStream(input) {
   if (globalThis.ReadableStream && globalThis.ReadableStream.prototype.isPrototypeOf(input)) {
     return 'web';
   }
-  if (NodeReadableStream && NodeReadableStream.prototype.isPrototypeOf(input)) {
+  if (NodeNativeReadableStream && NodeNativeReadableStream.prototype.isPrototypeOf(input)) {
     throw new Error('Native Node streams are no longer supported: please manually convert the stream to a WebStream, using e.g. `stream.Readable.toWeb`');
   }
   if (input && input.getReader) {

package.json

@@ -13,10 +13,6 @@
   },
   "types": "./lib/index.d.ts",
   "main": "./lib/index.js",
-  "browser": {
-    "buffer": false,
-    "stream": false
-  },
   "engines": {
     "node": ">= 16.5.0"
   },
@@ -32,7 +28,7 @@
   "homepage": "https://github.com/openpgpjs/web-stream-tools#readme",
   "devDependencies": {
     "@openpgp/jsdoc": "^3.6.11",
-    "@types/node": "^18.11.9",
+    "@types/node": "^20.11.4",
     "@typescript-eslint/eslint-plugin": "^5.59.6",
     "@typescript-eslint/parser": "^5.59.6",
     "chai": "^4.3.7",
@@ -59,7 +55,7 @@
   "scripts": {
     "test-type-definitions": "tsx test/typescript.test.ts && tsx --tsconfig test/tsconfig.es5.json test/typescript.test.ts",
     "test-browser": "karma start karma.conf.cjs",
-    "test-node": "mocha ./test/node.test.js",
+    "test-node": "mocha ./test/node.test.js ./test/common.test.js",
     "lint": "eslint lib test",
     "docs": "jsdoc --configure .jsdocrc.cjs --destination docs --readme README.md lib && printf '%s' 'web-stream-tools.openpgpjs.org' > docs/CNAME",
     "preversion": "rm -rf docs",

test/browser.test.js

@@ -1,10 +1,16 @@
 import { expect } from 'chai';
-import { toStream, readToEnd } from '../lib/index.js';
+import { toStream, readToEnd } from '@openpgp/web-stream-tools';
 
 describe('Browser integration tests', () => {
-  it('toStream/readToEnd', async () => {
+  it('accepts readable stream', async () => {
     const input = 'chunk';
-    const streamedData = toStream('chunk');
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(input);
+        controller.close();
+      }
+    });
+    const streamedData = toStream(stream);
     expect(await readToEnd(streamedData)).to.equal(input);
-  })
+  });
 })

test/common.test.js

@@ -0,0 +1,17 @@
+import { expect } from 'chai';
+import { toStream, readToEnd, slice } from  '@openpgp/web-stream-tools';
+
+describe('Common integration tests', () => {
+  it('toStream/readToEnd', async () => {
+    const input = 'chunk';
+    const streamedData = toStream('chunk');
+    expect(await readToEnd(streamedData)).to.equal(input);
+  });
+
+  it('slice', async () => {
+    const input = 'another chunk';
+    const streamedData = toStream(input);
+    const slicedStream = slice(streamedData, 8);
+    expect(await readToEnd(slicedStream)).to.equal('chunk');
+  })
+})

test/node.test.js

@@ -1,29 +1,49 @@
 import { expect } from 'chai';
-import { Readable } from 'stream';
-import { ReadableStream as NodeWebReadableStream } from 'stream/web';
+import { Readable as NodeNativeReadableStream } from 'node:stream';
+import { ReadableStream as NodeWebReadableStream } from 'node:stream/web';
 import { toStream, readToEnd } from '@openpgp/web-stream-tools';
+import { ReadableStream as PolyfilledReadableStream } from 'web-streams-polyfill';
 
 describe('Node integration tests', () => {
   it('throws on node native stream', async () => {
-    const input = new Readable();
+    const input = new NodeNativeReadableStream();
     expect(() => toStream(input)).to.throw(/Native Node streams are no longer supported/);
   });
 
-  it('accepts on node web stream', async () => {
+  it('accepts node web stream', async () => {
     const input = 'chunk';
     const stream = new NodeWebReadableStream({
       start(controller) {
-        controller.enqueue('chunk');
+        controller.enqueue(input);
         controller.close();
       }
     });
     const streamedData = toStream(stream);
     expect(await readToEnd(streamedData)).to.equal(input);
   });
 
-  it('toStream/readToEnd', async () => {
+  it('returned node web stream can be converted into node native stream', async () => {
     const input = 'chunk';
-    const streamedData = toStream('chunk');
-    expect(await readToEnd(streamedData)).to.equal(input);
-  })
-})
+    const stream = new NodeWebReadableStream({
+      start(controller) {
+        controller.enqueue(input);
+        controller.close();
+      }
+    });
+    const streamedData = toStream(stream);
+    expect(NodeNativeReadableStream.fromWeb(streamedData)).to.exist;
+  });
+
+  it('polyfilled web stream cannot be converted into node native stream', async () => {
+    // this test is just to keep track that this behaviour is expected
+    const input = 'chunk';
+    const stream = new PolyfilledReadableStream({
+      start(controller) {
+        controller.enqueue(input);
+        controller.close();
+      }
+    });
+    const streamedData = toStream(stream);
+    expect(() => NodeNativeReadableStream.fromWeb(streamedData)).to.throw(/must be an instance of ReadableStream/);
+  });
+});