@tstdl/base 0.90.7 → 0.90.9

package/http/utils.js

@@ -49,7 +49,7 @@ export async function readBodyAsBuffer(body, headers, options = {}) {
         uint8Array = new Uint8Array(buffer);
     }
     else if (isReadableStream(body) || isAnyIterable(body)) {
-        uint8Array = await readBinaryStream(readBodyAsBinaryStream(body, headers, options), headers.contentLength);
+        uint8Array = await readBinaryStream(readBodyAsBinaryStream(body, headers, options), { length: headers.contentLength });
     }
     else {
         throw new NotSupportedError('Unsupported body type.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.7",
+  "version": "0.90.9",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/utils/binary.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryData } from '../types.js';
+import type { BinaryData, Type } from '../types.js';
 /**
  * Get ArrayBuffer from binary data
  * @param data data to get ArrayBuffer from
@@ -14,3 +14,4 @@ export declare function toArrayBuffer(data: BinaryData, clone?: boolean): ArrayB
 export declare function toUint8Array(data: BinaryData, clone?: boolean): Uint8Array;
 export declare function concatArrayBuffers(buffers: ArrayBufferLike[]): ArrayBuffer;
 export declare function concatArrayBufferViews<T extends ArrayBufferView>(arrays: T[], totalLength?: number): T;
+export declare function concatArrayBufferViews<T extends ArrayBufferView>(arrays: ArrayBufferView[], targetType: Type<T, [ArrayBufferLike, number, number]>, totalLength?: number): T;

package/utils/binary.js

@@ -1,5 +1,6 @@
 import { supportsBuffer } from '../supports.js';
-import { assert, isArrayBuffer } from './type-guards.js';
+import { typeExtends } from './index.js';
+import { assert, isArrayBuffer, isFunction, isNumber } from './type-guards.js';
 /**
  * Get ArrayBuffer from binary data
  * @param data data to get ArrayBuffer from
@@ -36,11 +37,13 @@ export function concatArrayBuffers(buffers) {
     const bytes = concatArrayBufferViews(arrays);
     return bytes.buffer;
 }
-export function concatArrayBufferViews(arrays, totalLength) {
+export function concatArrayBufferViews(arrays, totalLengthOrTargetType, totalLengthOrNothing) {
     assert(arrays.length > 0, 'No array provided.');
-    const type = arrays[0].constructor;
-    if (supportsBuffer && ((type == Buffer) || (type == Uint8Array))) {
-        return Buffer.concat(arrays, totalLength);
+    const totalLength = isNumber(totalLengthOrTargetType) ? totalLengthOrTargetType : totalLengthOrNothing;
+    const type = isFunction(totalLengthOrTargetType) ? totalLengthOrTargetType : arrays[0].constructor;
+    if (supportsBuffer && typeExtends(type, Uint8Array)) {
+        const merged = Buffer.concat(arrays, totalLength);
+        return new type(merged.buffer, merged.byteOffset, merged.byteLength);
     }
     const totalBytes = totalLength ?? arrays.reduce((sum, array) => sum + array.byteLength, 0);
     const merged = new Uint8Array(totalBytes);
@@ -50,5 +53,5 @@ export function concatArrayBufferViews(arrays, totalLength) {
         merged.set(uint8Array, currentIndex);
         currentIndex += uint8Array.byteLength;
     }
-    return new type(merged.buffer);
+    return new type(merged.buffer, merged.byteOffset, merged.byteLength);
 }

package/utils/index.d.ts

@@ -49,6 +49,7 @@ export * from './timer.js';
 export * from './timing.js';
 export * from './type-guards.js';
 export * from './type-of.js';
+export * from './type/index.js';
 export * from './units.js';
 export * from './url-builder.js';
 export * from './value-or-provider.js';

package/utils/index.js

@@ -49,6 +49,7 @@ export * from './timer.js';
 export * from './timing.js';
 export * from './type-guards.js';
 export * from './type-of.js';
+export * from './type/index.js';
 export * from './units.js';
 export * from './url-builder.js';
 export * from './value-or-provider.js';

package/utils/stream/index.d.ts

@@ -4,3 +4,4 @@ export * from './readable-stream-from-promise.js';
 export * from './size-limited-stream.js';
 export * from './stream-helper-types.js';
 export * from './stream-reader.js';
+export * from './to-bytes-stream.js';

package/utils/stream/index.js

@@ -4,3 +4,4 @@ export * from './readable-stream-from-promise.js';
 export * from './size-limited-stream.js';
 export * from './stream-helper-types.js';
 export * from './stream-reader.js';
+export * from './to-bytes-stream.js';

package/utils/stream/readable-stream-adapter.js

@@ -14,15 +14,14 @@ export async function* getReadableStreamIterable(stream, options = {}) {
         if (options.close != false) {
             await reader.cancel();
         }
-        reader.releaseLock();
+        else {
+            reader.releaseLock();
+        }
     }
 }
 export function getReadableStreamFromIterable(iterable) {
-    let iterator;
+    const iterator = isAsyncIterable(iterable) ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
     return new ReadableStream({
-        cancel: async (reason) => {
-            await iterator.return?.(reason);
-        },
         pull: async (controller) => {
             const result = await iterator.next();
             if (result.done == true) {
@@ -32,8 +31,8 @@ export function getReadableStreamFromIterable(iterable) {
                 controller.enqueue(result.value);
             }
         },
-        start: () => {
-            iterator = isAsyncIterable(iterable) ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
+        cancel: async (reason) => {
+            await iterator.return?.(reason);
         }
     });
 }

package/utils/stream/stream-reader.d.ts

@@ -1,2 +1,9 @@
 import type { AnyIterable } from '../any-iterable-iterator.js';
-export declare function readBinaryStream(iterableOrStream: AnyIterable<Uint8Array> | ReadableStream<Uint8Array>, length?: number): Promise<Uint8Array>;
+export type ReadBinaryStreamOptions = {
+    length?: number;
+    /** Action if source stream has more bytes than provided length */
+    onLengthExceed?: 'error' | 'close' | 'leave-open';
+    /** Action if source stream has less bytes than provided length */
+    onLengthSubceed?: 'error' | 'close' | 'leave-open';
+};
+export declare function readBinaryStream(iterableOrStream: AnyIterable<ArrayBufferView> | ReadableStream<ArrayBufferView>, { length, onLengthExceed, onLengthSubceed }?: ReadBinaryStreamOptions): Promise<Uint8Array>;

package/utils/stream/stream-reader.js

@@ -1,34 +1,78 @@
 import { BadRequestError } from '../../errors/bad-request.error.js';
-import { isAnyIterable } from '../any-iterable-iterator.js';
+import { MaxBytesExceededError } from '../../errors/max-bytes-exceeded.error.js';
+import { NotSupportedError } from '../../errors/not-supported.error.js';
 import { concatArrayBufferViews } from '../binary.js';
-import { isDefined } from '../type-guards.js';
-import { getReadableStreamIterable } from './readable-stream-adapter.js';
+import { isDefined, isReadableStream } from '../type-guards.js';
+import { getReadableStreamFromIterable } from './readable-stream-adapter.js';
+import { toBytesStream } from './to-bytes-stream.js';
 // eslint-disable-next-line max-statements
-export async function readBinaryStream(iterableOrStream, length) {
-    const iterable = isAnyIterable(iterableOrStream) ? iterableOrStream : getReadableStreamIterable(iterableOrStream);
+export async function readBinaryStream(iterableOrStream, { length, onLengthExceed = 'error', onLengthSubceed = 'error' } = {}) {
+    const stream = isReadableStream(iterableOrStream)
+        ? isDefined(length)
+            ? toBytesStream(iterableOrStream)
+            : iterableOrStream
+        : getReadableStreamFromIterable(iterableOrStream);
     if (isDefined(length)) {
-        const array = new Uint8Array(length);
-        let bytesWritten = 0;
-        for await (const chunk of iterable) {
-            if ((bytesWritten + chunk.length) > length) {
-                throw new BadRequestError('Size of stream is greater than provided length.');
+        const reader = stream.getReader({ mode: 'byob' });
+        let buffer = new ArrayBuffer(length + 1);
+        let bytesRead = 0;
+        while (true) {
+            const result = await reader.read(new Uint8Array(buffer, bytesRead, buffer.byteLength - bytesRead));
+            buffer = result.value.buffer;
+            bytesRead += result.value.byteLength;
+            if (result.done) {
+                break;
+            }
+            if (bytesRead > length) {
+                switch (onLengthExceed) {
+                    case 'error':
+                        await reader.cancel();
+                        throw new MaxBytesExceededError('Size of stream is greater than provided length.');
+                    case 'close':
+                        await reader.cancel();
+                        break;
+                    case 'leave-open':
+                        reader.releaseLock();
+                        break;
+                    default:
+                        throw new NotSupportedError(`Action ${onLengthExceed} not supported.`);
+                }
+            }
+            if (bytesRead == length + 1) {
+                break;
             }
-            array.set(chunk, bytesWritten);
-            bytesWritten += chunk.length;
         }
-        if (bytesWritten != length) {
-            throw new BadRequestError('Size of stream did not match provided length.');
+        if (bytesRead < length) {
+            switch (onLengthSubceed) {
+                case 'error':
+                    await reader.cancel();
+                    throw new BadRequestError('Size of stream was less than provided length.');
+                case 'close':
+                    await reader.cancel();
+                    break;
+                case 'leave-open':
+                    reader.releaseLock();
+                    break;
+                default:
+                    throw new NotSupportedError(`Action ${onLengthSubceed} not supported.`);
+            }
         }
-        return array;
+        await reader.cancel();
+        return new Uint8Array(buffer, 0, Math.min(length, bytesRead));
     }
     let totalLength = 0;
-    const chunks = [];
-    for await (const chunk of iterable) {
-        chunks.push(chunk);
-        totalLength += chunk.length;
+    const reader = stream.getReader();
+    const views = [];
+    while (true) {
+        const result = await reader.read();
+        if (result.done) {
+            break;
+        }
+        views.push(result.value);
+        totalLength += result.value.byteLength;
     }
-    if (chunks.length == 0) {
+    if (views.length == 0) {
         return new Uint8Array(0);
     }
-    return concatArrayBufferViews(chunks, totalLength);
+    return concatArrayBufferViews(views, Uint8Array, totalLength);
 }

package/utils/stream/to-bytes-stream.d.ts

@@ -0,0 +1,4 @@
+export type ToBytesStreamOptions = {
+    ignoreCancel?: boolean;
+};
+export declare function toBytesStream(stream: ReadableStream<ArrayBufferView>, options?: ToBytesStreamOptions): ReadableStream<Uint8Array>;

package/utils/stream/to-bytes-stream.js

@@ -0,0 +1,78 @@
+import { isNotNull, isNull } from '../type-guards.js';
+export function toBytesStream(stream, options) {
+    try { // try to use byob mode from source
+        let byobReader;
+        return new ReadableStream({
+            type: 'bytes',
+            autoAllocateChunkSize: 10240,
+            start() {
+                byobReader = stream.getReader({ mode: 'byob' });
+            },
+            async pull(controller) {
+                const readResult = await byobReader.read(controller.byobRequest.view);
+                if (readResult.done) {
+                    controller.close();
+                    controller.byobRequest.respond(0);
+                    return;
+                }
+                controller.byobRequest.respondWithNewView(readResult.value);
+            },
+            async cancel(reason) {
+                if (options?.ignoreCancel == true) {
+                    byobReader.releaseLock();
+                }
+                else {
+                    await byobReader.cancel(reason);
+                }
+            }
+        });
+    }
+    catch { /* ignore */ }
+    let reader;
+    let buffer = null;
+    return new ReadableStream({
+        type: 'bytes',
+        start() {
+            reader = stream.getReader();
+        },
+        async pull(controller) {
+            const isByobRequest = isNotNull(controller.byobRequest);
+            const bufferIsEmpty = isNull(buffer) || (buffer.byteLength == 0);
+            if (!isByobRequest && !bufferIsEmpty) {
+                // we stil have data left in buffer from previous pull which was byob
+                controller.enqueue(buffer);
+                buffer = null;
+                return;
+            }
+            if (bufferIsEmpty) {
+                const readResult = await reader.read();
+                if (readResult.done) {
+                    controller.close();
+                    controller.byobRequest?.respond(0);
+                    return;
+                }
+                buffer = readResult.value; // eslint-disable-line require-atomic-updates
+            }
+            if (!isByobRequest) {
+                controller.enqueue(buffer);
+                buffer = null;
+                return;
+            }
+            const targetView = controller.byobRequest.view;
+            const targetArray = new Uint8Array(targetView.buffer, targetView.byteOffset, targetView.byteLength);
+            const setLength = Math.min(buffer.byteLength, targetArray.byteLength);
+            const sourceArray = new Uint8Array(buffer.buffer, buffer.byteOffset, setLength);
+            targetArray.set(sourceArray);
+            buffer = new Uint8Array(buffer.buffer, buffer.byteOffset + setLength);
+            controller.byobRequest.respond(setLength);
+        },
+        async cancel(reason) {
+            if (options?.ignoreCancel == true) {
+                reader.releaseLock();
+            }
+            else {
+                await reader.cancel(reason);
+            }
+        }
+    });
+}

package/utils/type/extends.d.ts

@@ -0,0 +1,2 @@
+import type { AbstractConstructor } from '../../types.js';
+export declare function typeExtends(type: AbstractConstructor, base: AbstractConstructor): boolean;

package/utils/type/extends.js

@@ -0,0 +1,3 @@
+export function typeExtends(type, base) {
+    return ((type == base) || (type.prototype instanceof base));
+}

package/utils/type/index.d.ts

@@ -0,0 +1 @@
+export * from './extends.js';

package/utils/type/index.js

@@ -0,0 +1 @@
+export * from './extends.js';