peek-readable - npm Package Compare versions

Comparing version 5.1.0 to 5.1.1

lib/StreamReader.d.ts

 import { Readable } from 'node:stream';
-import { IStreamReader } from "./index.js";
+import { AbstractStreamReader } from "./AbstractStreamReader.js";
 export { EndOfStreamError } from './EndOfFileStream.js';
-export declare class StreamReader implements IStreamReader {
+/**
+ * Node.js Readable Stream Reader
+ * Ref: https://nodejs.org/api/stream.html#readable-streams
+ */
+export declare class StreamReader extends AbstractStreamReader {
     private s;
@@ -10,27 +14,5 @@ /**
     private deferred;
-    private endOfStream;
-    /**
-     * Store peeked data
-     * @type {Array}
-     */
-    private peekQueue;
     constructor(s: Readable);
     /**
-     * Read ahead (peek) from stream. Subsequent read or peeks will return the same data
-     * @param uint8Array - Uint8Array (or Buffer) to store data read from stream in
-     * @param offset - Offset target
-     * @param length - Number of bytes to read
-     * @returns Number of bytes peeked
-     */
-    peek(uint8Array: Uint8Array, offset: number, length: number): Promise<number>;
-    /**
      * Read chunk from stream
-     * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
-     * @param offset - Offset target
-     * @param length - Number of bytes to read
-     * @returns Number of bytes read
-     */
-    read(buffer: Uint8Array, offset: number, length: number): Promise<number>;
-    /**
-     * Read chunk from stream
      * @param buffer Target Uint8Array (or Buffer) to store data read from stream in
@@ -41,3 +23,3 @@ * @param offset Offset target
      */
-    private readFromStream;
+    protected readFromStream(buffer: Uint8Array, offset: number, length: number): Promise<number>;
     /**
@@ -44,0 +26,0 @@ * Process deferred read request

lib/StreamReader.js

 import { EndOfStreamError } from './EndOfFileStream.js';
 import { Deferred } from './Deferred.js';
+import { AbstractStreamReader } from "./AbstractStreamReader.js";
 export { EndOfStreamError } from './EndOfFileStream.js';
-const maxStreamReadSize = 1 * 1024 * 1024; // Maximum request length on read-stream operation
-export class StreamReader {
+/**
+ * Node.js Readable Stream Reader
+ * Ref: https://nodejs.org/api/stream.html#readable-streams
+ */
+export class StreamReader extends AbstractStreamReader {
     constructor(s) {
+        super();
         this.s = s;
@@ -12,8 +17,2 @@ /**
         this.deferred = null;
-        this.endOfStream = false;
-        /**
-         * Store peeked data
-         * @type {Array}
-         */
-        this.peekQueue = [];
         if (!s.read || !s.once) {
@@ -27,56 +26,3 @@ throw new Error('Expected an instance of stream.Readable');
     /**
-     * Read ahead (peek) from stream. Subsequent read or peeks will return the same data
-     * @param uint8Array - Uint8Array (or Buffer) to store data read from stream in
-     * @param offset - Offset target
-     * @param length - Number of bytes to read
-     * @returns Number of bytes peeked
-     */
-    async peek(uint8Array, offset, length) {
-        const bytesRead = await this.read(uint8Array, offset, length);
-        this.peekQueue.push(uint8Array.subarray(offset, offset + bytesRead)); // Put read data back to peek buffer
-        return bytesRead;
-    }
-    /**
      * Read chunk from stream
-     * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
-     * @param offset - Offset target
-     * @param length - Number of bytes to read
-     * @returns Number of bytes read
-     */
-    async read(buffer, offset, length) {
-        if (length === 0) {
-            return 0;
-        }
-        if (this.peekQueue.length === 0 && this.endOfStream) {
-            throw new EndOfStreamError();
-        }
-        let remaining = length;
-        let bytesRead = 0;
-        // consume peeked data first
-        while (this.peekQueue.length > 0 && remaining > 0) {
-            const peekData = this.peekQueue.pop(); // Front of queue
-            if (!peekData)
-                throw new Error('peekData should be defined');
-            const lenCopy = Math.min(peekData.length, remaining);
-            buffer.set(peekData.subarray(0, lenCopy), offset + bytesRead);
-            bytesRead += lenCopy;
-            remaining -= lenCopy;
-            if (lenCopy < peekData.length) {
-                // remainder back to queue
-                this.peekQueue.push(peekData.subarray(lenCopy));
-            }
-        }
-        // continue reading from stream if required
-        while (remaining > 0 && !this.endOfStream) {
-            const reqLen = Math.min(remaining, maxStreamReadSize);
-            const chunkLen = await this.readFromStream(buffer, offset + bytesRead, reqLen);
-            bytesRead += chunkLen;
-            if (chunkLen < reqLen)
-                break;
-            remaining -= chunkLen;
-        }
-        return bytesRead;
-    }
-    /**
-     * Read chunk from stream
      * @param buffer Target Uint8Array (or Buffer) to store data read from stream in
@@ -88,2 +34,5 @@ * @param offset Offset target
     async readFromStream(buffer, offset, length) {
+        if (this.endOfStream) {
+            return 0;
+        }
         const readBuffer = this.s.read(length);
@@ -90,0 +39,0 @@ if (readBuffer) {

lib/WebStreamReader.d.ts

 import { ReadableStream } from 'node:stream/web';
 export { EndOfStreamError } from './EndOfFileStream.js';
-import type { IStreamReader } from "./index.js";
+import { AbstractStreamReader } from "./AbstractStreamReader.js";
 /**
@@ -8,8 +8,7 @@ * Read from a WebStream
  */
-export declare class WebStreamReader implements IStreamReader {
+export declare class WebStreamReader extends AbstractStreamReader {
     private reader;
-    private peekQueue;
+    private eofStream;
     constructor(stream: ReadableStream<Uint8Array>);
-    peek(buffer: Uint8Array, offset: number, length: number): Promise<number>;
-    read(buffer: Uint8Array, offset: number, length: number): Promise<number>;
+    protected readFromStream(buffer: Uint8Array, offset: number, length: number): Promise<number>;
 }

lib/WebStreamReader.js

 import { EndOfStreamError } from './EndOfFileStream.js';
 export { EndOfStreamError } from './EndOfFileStream.js';
+import { AbstractStreamReader } from "./AbstractStreamReader.js";
 /**
@@ -7,32 +8,15 @@ * Read from a WebStream
  */
-export class WebStreamReader {
+export class WebStreamReader extends AbstractStreamReader {
     constructor(stream) {
-        this.peekQueue = [];
+        super();
+        this.eofStream = false;
         this.reader = stream.getReader({ mode: 'byob' });
     }
-    async peek(buffer, offset, length) {
-        const bytesRead = await this.read(buffer, offset, length);
-        this.peekQueue.push(buffer.subarray(offset, offset + bytesRead));
-        return bytesRead;
-    }
-    async read(buffer, offset, length) {
-        if (length === 0) {
-            return 0;
+    async readFromStream(buffer, offset, length) {
+        if (this.eofStream) {
+            throw new EndOfStreamError();
         }
-        if (this.peekQueue.length > 0) {
-            let bytesRead = 0;
-            while (this.peekQueue.length > 0 && bytesRead < length) {
-                const peeked = this.peekQueue.shift();
-                const toCopy = Math.min(peeked.length, length - bytesRead);
-                buffer.set(peeked.subarray(0, toCopy), offset + bytesRead);
-                bytesRead += toCopy;
-                if (toCopy < peeked.length) {
-                    this.peekQueue.unshift(peeked.subarray(toCopy));
-                }
-            }
-            return bytesRead;
-        }
         const result = await this.reader.read(new Uint8Array(length));
         if (result.done) {
-            throw new EndOfStreamError();
+            this.eofStream = result.done;
         }
@@ -39,0 +23,0 @@ if (result.value) {

package.json

 {
   "name": "peek-readable",
-  "version": "5.1.0",
+  "version": "5.1.1",
   "description": "Read and peek from a readable stream",
@@ -5,0 +5,0 @@ "author": {

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

18369

increased by6.79%

Number of package files

15

increased by15.38%

Lines of code

309

increased by11.96%

No dependency changes