@ardrive/turbo-sdk 1.26.0 → 1.27.0-alpha.1

package/lib/cjs/web/index.js

@@ -34,3 +34,4 @@ __exportStar(require("./upload.js"), exports);
 __exportStar(require("./signer.js"), exports);
 __exportStar(require("../common/index.js"), exports);
 __exportStar(require("../types.js"), exports);
+__exportStar(require("../common/events.js"), exports);

package/lib/cjs/web/signer.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TurboWebArweaveSigner = exports.HexSolanaSigner = exports.EthereumSigner = exports.ArweaveSigner = exports.ArconnectSigner = void 0;
+exports.readableStreamToAsyncIterable = exports.TurboWebArweaveSigner = exports.HexSolanaSigner = exports.EthereumSigner = exports.ArweaveSigner = exports.ArconnectSigner = void 0;
+exports.streamSignerReadableStream = streamSignerReadableStream;
+exports.isAsyncIterable = isAsyncIterable;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -46,61 +48,21 @@ class TurboWebArweaveSigner extends signer_js_1.TurboDataItemAbstractSigner {
         await this.setPublicKey();
         // Create signing emitter if events are provided
         const fileSize = fileSizeFactory();
-        try {
-            const fileStream = fileStreamFactory();
-            // start with 0 progress
-            emitter?.emit('signing-progress', {
-                processedBytes: 0,
-                totalBytes: fileSize,
-            });
-            // TODO: implement streamReadableStreamSigner that incrementally signs the stream with events instead of converting to a buffer
-            const buffer = fileStream instanceof Buffer
-                ? fileStream
-                : await (0, readableStream_js_1.readableStreamToBuffer)({
-                    stream: fileStream,
-                    size: fileSize,
-                });
-            // TODO: replace this with streamSigner that uses a ReadableStream with events
-            emitter?.emit('signing-progress', {
-                processedBytes: Math.floor(fileSize / 2),
-                totalBytes: fileSize,
-            });
-            let signedDataItem;
-            this.logger.debug('Signing data item...');
-            if (this.signer instanceof arbundles_1.ArconnectSigner) {
-                this.logger.debug('Arconnect signer detected, signing with Arconnect signData Item API...');
-                const sign = Buffer.from(await this.signer['signer'].signDataItem({
-                    data: Uint8Array.from(buffer),
-                    tags: dataItemOpts?.tags,
-                    target: dataItemOpts?.target,
-                    anchor: dataItemOpts?.anchor,
-                }));
-                signedDataItem = new arbundles_1.DataItem(sign);
-            }
-            else {
-                signedDataItem = (0, arbundles_1.createData)(Uint8Array.from(buffer), this.signer, dataItemOpts);
-                await signedDataItem.sign(this.signer);
-            }
-            // emit last progress event (100%)
-            emitter?.emit('signing-progress', {
-                processedBytes: fileSize,
-                totalBytes: fileSize,
-            });
-            // emit completion event
-            emitter?.emit('signing-success');
-            this.logger.debug('Successfully signed data item...');
-            return {
-                // while this returns a Buffer - it needs to match our return type for uploading
-                dataItemStreamFactory: () => signedDataItem.getRaw(),
-                dataItemSizeFactory: () => signedDataItem.getRaw().length,
-            };
-        }
-        catch (error) {
-            // If we have a signing emitter, emit error
-            // TODO: create a SigningError class and throw that instead of the generic Error
-            emitter?.emit('signing-error', error);
-            throw error;
-        }
+        this.logger.debug('Signing data item...');
+        const { signedDataItemFactory, signedDataItemSize } = await streamSignerReadableStream({
+            streamFactory: (0, readableStream_js_1.createUint8ArrayReadableStreamFactory)({
+                data: fileStreamFactory(),
+            }),
+            signer: this.signer,
+            dataItemOpts,
+            fileSize,
+            emitter,
+        });
+        this.logger.debug('Successfully signed data item...');
+        return {
+            dataItemStreamFactory: signedDataItemFactory,
+            dataItemSizeFactory: () => signedDataItemSize,
+        };
     }
     async generateSignedRequestHeaders() {
         await this.setPublicKey();
@@ -112,3 +74,113 @@ class TurboWebArweaveSigner extends signer_js_1.TurboDataItemAbstractSigner {
     }
 }
 exports.TurboWebArweaveSigner = TurboWebArweaveSigner;
+const readableStreamToAsyncIterable = (stream) => ({
+    async *[Symbol.asyncIterator]() {
+        const reader = stream.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value !== undefined)
+                    yield Buffer.from(value);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    },
+});
+exports.readableStreamToAsyncIterable = readableStreamToAsyncIterable;
+async function streamSignerReadableStream({ streamFactory, signer, dataItemOpts, fileSize, emitter, }) {
+    try {
+        const header = (0, arbundles_1.createData)('', signer, dataItemOpts);
+        const headerSize = header.getRaw().byteLength;
+        const totalDataItemSizeWithHeader = fileSize + headerSize;
+        const [stream1, stream2] = streamFactory().tee();
+        const reader1 = stream1.getReader();
+        let bytesProcessed = 0;
+        const eventingStream = new ReadableStream({
+            start() {
+                // technically this should be emitted after each DeepHashChunk be we cannot access that stage, so we emit it here instead
+                bytesProcessed = headerSize;
+                emitter?.emit('signing-progress', {
+                    processedBytes: bytesProcessed,
+                    totalBytes: totalDataItemSizeWithHeader,
+                });
+            },
+            async pull(controller) {
+                const { done, value } = await reader1.read();
+                if (done) {
+                    controller.close();
+                    return;
+                }
+                bytesProcessed += value.byteLength;
+                controller.enqueue(value);
+                emitter?.emit('signing-progress', {
+                    processedBytes: bytesProcessed,
+                    totalBytes: totalDataItemSizeWithHeader,
+                });
+            },
+            cancel() {
+                reader1.cancel();
+            },
+        });
+        // create a readable that emits signing events as bytes are pulled through using the first stream from .tee()
+        const asyncIterableReadableStream = (0, exports.readableStreamToAsyncIterable)(eventingStream);
+        // provide that ReadableStream with events to deep hash, so as it pulls bytes through events get emitted
+        const parts = [
+            (0, arbundles_1.stringToBuffer)('dataitem'),
+            (0, arbundles_1.stringToBuffer)('1'),
+            (0, arbundles_1.stringToBuffer)(header.signatureType.toString()),
+            Uint8Array.from(header.rawOwner),
+            Uint8Array.from(header.rawTarget),
+            Uint8Array.from(header.rawAnchor),
+            Uint8Array.from(header.rawTags),
+            asyncIterableReadableStream,
+        ];
+        const hash = await (0, arbundles_1.deepHash)(parts);
+        const sigBytes = Buffer.from(await signer.sign(hash));
+        emitter?.emit('signing-success');
+        header.setSignature(sigBytes);
+        const headerBytes = header.getRaw();
+        const signedDataItemFactory = () => {
+            const reader = stream2.getReader();
+            return new ReadableStream({
+                start(controller) {
+                    controller.enqueue(Uint8Array.from(headerBytes));
+                    bytesProcessed += headerBytes.byteLength;
+                },
+                async pull(controller) {
+                    try {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            controller.close();
+                            return;
+                        }
+                        controller.enqueue(value);
+                    }
+                    catch (error) {
+                        controller.error(error);
+                    }
+                },
+                cancel() {
+                    reader.cancel();
+                },
+            });
+        };
+        return {
+            signedDataItemSize: totalDataItemSizeWithHeader,
+            signedDataItemFactory,
+        };
+    }
+    catch (error) {
+        emitter?.emit('signing-error', error);
+        throw error;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isAsyncIterable(data) {
+    return (typeof data[Symbol.asyncIterator] ===
+        'function');
+}

package/lib/esm/common/events.js

@@ -40,7 +40,7 @@ function createReadableStreamWithEvents({ data, dataSize, emitter, eventNamesMap
         ? data
         : new ReadableStream({
             start: (controller) => {
-                controller.enqueue(data);
+                controller.enqueue(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
                 controller.close();
             },
         });
@@ -58,12 +58,12 @@ function createReadableStreamWithEvents({ data, dataSize, emitter, eventNamesMap
                     controller.close();
                     return;
                 }
-                processedBytes += value.length;
+                processedBytes += value.byteLength;
                 emitter.emit(eventNamesMap['on-progress'], {
                     processedBytes,
                     totalBytes: dataSize,
                 });
-                controller.enqueue(value);
+                controller.enqueue(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
             }
             catch (error) {
                 emitter.emit(eventNamesMap['on-error'], error);
@@ -119,7 +119,7 @@ function createReadableWithEvents({ data, dataSize, emitter, eventNamesMap, }) {
     let processedBytes = 0;
     existingStream.on('data', (chunk) => {
         eventingStream.write(chunk);
-        processedBytes += chunk.length;
+        processedBytes += chunk.byteLength;
         emitter.emit(eventNamesMap['on-progress'], {
             processedBytes,
             totalBytes: dataSize,

package/lib/esm/common/upload.js

@@ -41,19 +41,19 @@ export class TurboUnauthenticatedUploadService {
         this.retryConfig = retryConfig;
     }
     async uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, dataItemOpts, signal, events = {}, }) {
-        const fileSize = dataItemSizeFactory();
+        const dataItemSize = dataItemSizeFactory();
         this.logger.debug('Uploading signed data item...');
         // create the tapped stream with events
         const emitter = new TurboEventEmitter(events);
         // create the stream with upload events
         const { stream: streamWithUploadEvents, resume } = createStreamWithUploadEvents({
             data: dataItemStreamFactory(),
-            dataSize: fileSize,
+            dataSize: dataItemSize,
             emitter,
         });
         const headers = {
             'content-type': 'application/octet-stream',
-            'content-length': `${fileSize}`,
+            'content-length': `${dataItemSize}`,
         };
         if (dataItemOpts !== undefined && dataItemOpts.paidBy !== undefined) {
             const paidBy = Array.isArray(dataItemOpts.paidBy)
@@ -136,11 +136,10 @@ export class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUpl
             if (signal?.aborted) {
                 throw new CanceledError();
             }
+            // Now that we have the signed data item, we can upload it using the uploadSignedDataItem method
+            // which will create a new emitter with upload events. We await
+            // this result due to the wrapped retry logic of this method.
             try {
-                this.logger.debug('Uploading signed data item...');
-                // Now that we have the signed data item, we can upload it using the uploadSignedDataItem method
-                // which will create a new emitter with upload events. We await
-                // this result due to the wrapped retry logic of this method.
                 const response = await this.uploadSignedDataItem({
                     dataItemStreamFactory,
                     dataItemSizeFactory,
@@ -246,6 +245,7 @@ export class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUpl
             };
             try {
                 const result = await this.uploadFile({
+                    // TODO: can fix this type by passing a class generic and specifying in the node/web abstracts which stream type to use
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     fileStreamFactory: () => this.getFileStreamForFile(file),
                     fileSizeFactory: () => this.getFileSize(file),
@@ -290,6 +290,7 @@ export class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUpl
         ];
         const manifestBuffer = Buffer.from(JSON.stringify(manifest));
         const manifestResponse = await this.uploadFile({
+            // TODO: can fix this type by passing a class generic and specifying in the node/web abstracts which stream type to use
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             fileStreamFactory: () => this.createManifestStream(manifestBuffer),
             fileSizeFactory: () => manifestBuffer.byteLength,

package/lib/esm/utils/readableStream.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export const DEFAULT_STREAM_CHUNK_SIZE = 20 * 1024 * 1024; // 20mb
 export async function readableStreamToBuffer({ stream, size, }) {
     const reader = stream.getReader();
     const buffer = Buffer.alloc(size);
@@ -28,3 +29,97 @@ export async function readableStreamToBuffer({ stream, size, }) {
     }
     return buffer;
 }
+export function ensureChunkedStream(input, maxChunkSize = DEFAULT_STREAM_CHUNK_SIZE) {
+    const reader = input.getReader();
+    let leftover = null;
+    return new ReadableStream({
+        async pull(controller) {
+            // If we have leftover from a previous large chunk, continue slicing it
+            if (leftover) {
+                const chunk = leftover.subarray(0, maxChunkSize);
+                leftover = leftover.subarray(chunk.length);
+                if (leftover.length === 0)
+                    leftover = null;
+                controller.enqueue(chunk);
+                return;
+            }
+            const { value, done } = await reader.read();
+            if (done) {
+                controller.close();
+                return;
+            }
+            // Runtime check because ReadableStream defaults to <any> and can be abused
+            if (!(value instanceof Uint8Array)) {
+                throw new TypeError('Expected Uint8Array from source stream');
+            }
+            if (value.byteLength <= maxChunkSize) {
+                controller.enqueue(value);
+            }
+            else {
+                // Slice and enqueue one piece now, keep the rest
+                // subarray is the new view with the same buffer (not copy)
+                controller.enqueue(value.subarray(0, maxChunkSize));
+                leftover = value.subarray(maxChunkSize);
+            }
+        },
+    });
+}
+export function createUint8ArrayReadableStreamFactory({ data, maxChunkSize = DEFAULT_STREAM_CHUNK_SIZE, }) {
+    // Blob streams are already ReadableStream<Uint8Array>
+    if (data instanceof Blob) {
+        return () => ensureChunkedStream(data.stream());
+    }
+    // We need to handle the case where the data is a ReadableStream that is not a Uint8Array
+    // This is to ensure downstream code can handle the data as a Uint8Array
+    if (data instanceof ReadableStream) {
+        return () => {
+            const reader = data.getReader();
+            const stream = new ReadableStream({
+                async pull(controller) {
+                    const { value, done } = await reader.read();
+                    if (done) {
+                        controller.close();
+                        return;
+                    }
+                    if (ArrayBuffer.isView(value)) {
+                        // specifying offset and length is required to ensure chunks remain within their slice of the buffer
+                        controller.enqueue(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+                    }
+                    else if (value instanceof ArrayBuffer ||
+                        value instanceof SharedArrayBuffer) {
+                        controller.enqueue(new Uint8Array(value));
+                    }
+                    else {
+                        throw new TypeError('Unsupported chunk type in ReadableStream');
+                    }
+                },
+            });
+            return ensureChunkedStream(stream, maxChunkSize);
+        };
+    }
+    return () => {
+        let uint8;
+        if (typeof data === 'string') {
+            uint8 = new TextEncoder().encode(data);
+        }
+        else if (ArrayBuffer.isView(data)) {
+            // In theory we could use the view directly, but that might allow other typed arrays like BigInt64Array to be used which could behave unexpectedly downstream
+            // specifying offset and length is required to ensure chunks remain within their slice of the buffer
+            uint8 = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else if (data instanceof ArrayBuffer ||
+            data instanceof SharedArrayBuffer) {
+            uint8 = new Uint8Array(data);
+        }
+        else {
+            throw new TypeError('Unsupported input type for stream');
+        }
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(uint8);
+                controller.close();
+            },
+        });
+        return ensureChunkedStream(stream, maxChunkSize);
+    };
+}

package/lib/esm/version.js

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-export const version = '1.26.0';
+export const version = '1.27.0-alpha.1';

package/lib/esm/web/index.js

@@ -18,3 +18,4 @@ export * from './upload.js';
 export * from './signer.js';
 export * from '../common/index.js';
 export * from '../types.js';
+export * from '../common/events.js';

package/lib/esm/web/signer.js

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ArconnectSigner, ArweaveSigner, DataItem, EthereumSigner, HexSolanaSigner, InjectedEthereumSigner, createData, } from '@dha-team/arbundles';
+import { ArconnectSigner, ArweaveSigner, EthereumSigner, HexSolanaSigner, InjectedEthereumSigner, createData, deepHash, stringToBuffer, } from '@dha-team/arbundles';
 import { TurboDataItemAbstractSigner } from '../common/signer.js';
-import { readableStreamToBuffer } from '../utils/readableStream.js';
+import { createUint8ArrayReadableStreamFactory } from '../utils/readableStream.js';
 /**
  * Utility exports to avoid clients having to install arbundles
  */
@@ -43,61 +43,21 @@ export class TurboWebArweaveSigner extends TurboDataItemAbstractSigner {
         await this.setPublicKey();
         // Create signing emitter if events are provided
         const fileSize = fileSizeFactory();
-        try {
-            const fileStream = fileStreamFactory();
-            // start with 0 progress
-            emitter?.emit('signing-progress', {
-                processedBytes: 0,
-                totalBytes: fileSize,
-            });
-            // TODO: implement streamReadableStreamSigner that incrementally signs the stream with events instead of converting to a buffer
-            const buffer = fileStream instanceof Buffer
-                ? fileStream
-                : await readableStreamToBuffer({
-                    stream: fileStream,
-                    size: fileSize,
-                });
-            // TODO: replace this with streamSigner that uses a ReadableStream with events
-            emitter?.emit('signing-progress', {
-                processedBytes: Math.floor(fileSize / 2),
-                totalBytes: fileSize,
-            });
-            let signedDataItem;
-            this.logger.debug('Signing data item...');
-            if (this.signer instanceof ArconnectSigner) {
-                this.logger.debug('Arconnect signer detected, signing with Arconnect signData Item API...');
-                const sign = Buffer.from(await this.signer['signer'].signDataItem({
-                    data: Uint8Array.from(buffer),
-                    tags: dataItemOpts?.tags,
-                    target: dataItemOpts?.target,
-                    anchor: dataItemOpts?.anchor,
-                }));
-                signedDataItem = new DataItem(sign);
-            }
-            else {
-                signedDataItem = createData(Uint8Array.from(buffer), this.signer, dataItemOpts);
-                await signedDataItem.sign(this.signer);
-            }
-            // emit last progress event (100%)
-            emitter?.emit('signing-progress', {
-                processedBytes: fileSize,
-                totalBytes: fileSize,
-            });
-            // emit completion event
-            emitter?.emit('signing-success');
-            this.logger.debug('Successfully signed data item...');
-            return {
-                // while this returns a Buffer - it needs to match our return type for uploading
-                dataItemStreamFactory: () => signedDataItem.getRaw(),
-                dataItemSizeFactory: () => signedDataItem.getRaw().length,
-            };
-        }
-        catch (error) {
-            // If we have a signing emitter, emit error
-            // TODO: create a SigningError class and throw that instead of the generic Error
-            emitter?.emit('signing-error', error);
-            throw error;
-        }
+        this.logger.debug('Signing data item...');
+        const { signedDataItemFactory, signedDataItemSize } = await streamSignerReadableStream({
+            streamFactory: createUint8ArrayReadableStreamFactory({
+                data: fileStreamFactory(),
+            }),
+            signer: this.signer,
+            dataItemOpts,
+            fileSize,
+            emitter,
+        });
+        this.logger.debug('Successfully signed data item...');
+        return {
+            dataItemStreamFactory: signedDataItemFactory,
+            dataItemSizeFactory: () => signedDataItemSize,
+        };
     }
     async generateSignedRequestHeaders() {
         await this.setPublicKey();
@@ -108,3 +68,112 @@ export class TurboWebArweaveSigner extends TurboDataItemAbstractSigner {
         return super.signData(dataToSign);
     }
 }
+export const readableStreamToAsyncIterable = (stream) => ({
+    async *[Symbol.asyncIterator]() {
+        const reader = stream.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value !== undefined)
+                    yield Buffer.from(value);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    },
+});
+export async function streamSignerReadableStream({ streamFactory, signer, dataItemOpts, fileSize, emitter, }) {
+    try {
+        const header = createData('', signer, dataItemOpts);
+        const headerSize = header.getRaw().byteLength;
+        const totalDataItemSizeWithHeader = fileSize + headerSize;
+        const [stream1, stream2] = streamFactory().tee();
+        const reader1 = stream1.getReader();
+        let bytesProcessed = 0;
+        const eventingStream = new ReadableStream({
+            start() {
+                // technically this should be emitted after each DeepHashChunk be we cannot access that stage, so we emit it here instead
+                bytesProcessed = headerSize;
+                emitter?.emit('signing-progress', {
+                    processedBytes: bytesProcessed,
+                    totalBytes: totalDataItemSizeWithHeader,
+                });
+            },
+            async pull(controller) {
+                const { done, value } = await reader1.read();
+                if (done) {
+                    controller.close();
+                    return;
+                }
+                bytesProcessed += value.byteLength;
+                controller.enqueue(value);
+                emitter?.emit('signing-progress', {
+                    processedBytes: bytesProcessed,
+                    totalBytes: totalDataItemSizeWithHeader,
+                });
+            },
+            cancel() {
+                reader1.cancel();
+            },
+        });
+        // create a readable that emits signing events as bytes are pulled through using the first stream from .tee()
+        const asyncIterableReadableStream = readableStreamToAsyncIterable(eventingStream);
+        // provide that ReadableStream with events to deep hash, so as it pulls bytes through events get emitted
+        const parts = [
+            stringToBuffer('dataitem'),
+            stringToBuffer('1'),
+            stringToBuffer(header.signatureType.toString()),
+            Uint8Array.from(header.rawOwner),
+            Uint8Array.from(header.rawTarget),
+            Uint8Array.from(header.rawAnchor),
+            Uint8Array.from(header.rawTags),
+            asyncIterableReadableStream,
+        ];
+        const hash = await deepHash(parts);
+        const sigBytes = Buffer.from(await signer.sign(hash));
+        emitter?.emit('signing-success');
+        header.setSignature(sigBytes);
+        const headerBytes = header.getRaw();
+        const signedDataItemFactory = () => {
+            const reader = stream2.getReader();
+            return new ReadableStream({
+                start(controller) {
+                    controller.enqueue(Uint8Array.from(headerBytes));
+                    bytesProcessed += headerBytes.byteLength;
+                },
+                async pull(controller) {
+                    try {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            controller.close();
+                            return;
+                        }
+                        controller.enqueue(value);
+                    }
+                    catch (error) {
+                        controller.error(error);
+                    }
+                },
+                cancel() {
+                    reader.cancel();
+                },
+            });
+        };
+        return {
+            signedDataItemSize: totalDataItemSizeWithHeader,
+            signedDataItemFactory,
+        };
+    }
+    catch (error) {
+        emitter?.emit('signing-error', error);
+        throw error;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isAsyncIterable(data) {
+    return (typeof data[Symbol.asyncIterator] ===
+        'function');
+}

package/lib/types/common/events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/common/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAe,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAE/C,OAAO,EACL,4BAA4B,EAC5B,6BAA6B,EAC7B,0BAA0B,EAC1B,2BAA2B,EAC3B,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,aAAa,CAAC;AAwLrB;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,IAAI,EACJ,QAAQ,EACR,OAAO,EACP,aAAa,GACd,EAAE;IACD,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,cAAc,CAAC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,aAAa,EAAE;QACb,aAAa,EACT,MAAM,4BAA4B,GAClC,MAAM,6BAA6B,GACnC,MAAM,2BAA2B,CAAC;QACtC,UAAU,EACN,MAAM,4BAA4B,GAClC,MAAM,6BAA6B,GACnC,MAAM,2BAA2B,CAAC;QACtC,QAAQ,EACJ,MAAM,4BAA4B,GAClC,MAAM,6BAA6B,GACnC,MAAM,2BAA2B,CAAC;KACvC,CAAC;CACH,GAAG;IAAE,MAAM,EAAE,QAAQ,GAAG,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAuB5D;AAED,MAAM,MAAM,uBAAuB,GAAG,4BAA4B,GAChE,6BAA6B,GAC7B,2BAA2B,CAAC;AAC9B,MAAM,MAAM,0BAA0B,GAAG,2BAA2B,GAClE,4BAA4B,GAC5B,0BAA0B,CAAC;AAE7B,qBAAa,iBAAkB,SAAQ,YAAY,CAAC,uBAAuB,CAAC;gBAC9D,EACV,UAAU,EACV,OAAO,EACP,SAAS,EACT,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,gBAAgB,GACjB,GAAE,0BAA+B;CA2DnC;AAED,wBAAgB,4BAA4B,CAAC,EAC3C,IAAI,EACJ,QAAQ,EACR,OAAiC,GAClC,EAAE;IACD,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,cAAc,CAAC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC7B,GAAG;IAAE,MAAM,EAAE,QAAQ,GAAG,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAW5D;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,IAAI,EACJ,QAAQ,EACR,OAAiC,GAClC,EAAE;IACD,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,cAAc,CAAC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC7B,GAAG;IAAE,MAAM,EAAE,QAAQ,GAAG,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAW5D"}
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/common/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAe,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAE/C,OAAO,EACL,4BAA4B,EAC5B,6BAA6B,EAC7B,0BAA0B,EAC1B,2BAA2B,EAC3B,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,aAAa,CAAC;AA4LrB;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,IAAI,EACJ,QAAQ,EACR,OAAO,EACP,aAAa,GACd,EAAE;IACD,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,cAAc,CAAC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,aAAa,EAAE;QACb,aAAa,EACT,MAAM,4BAA4B,GAClC,MAAM,6BAA6B,GACnC,MAAM,2BAA2B,CAAC;QACtC,UAAU,EACN,MAAM,4BAA4B,GAClC,MAAM,6BAA6B,GACnC,MAAM,2BAA2B,CAAC;QACtC,QAAQ,EACJ,MAAM,4BAA4B,GAClC,MAAM,6BAA6B,GACnC,MAAM,2BAA2B,CAAC;KACvC,CAAC;CACH,GAAG;IAAE,MAAM,EAAE,QAAQ,GAAG,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAuB5D;AAED,MAAM,MAAM,uBAAuB,GAAG,4BAA4B,GAChE,6BAA6B,GAC7B,2BAA2B,CAAC;AAC9B,MAAM,MAAM,0BAA0B,GAAG,2BAA2B,GAClE,4BAA4B,GAC5B,0BAA0B,CAAC;AAE7B,qBAAa,iBAAkB,SAAQ,YAAY,CAAC,uBAAuB,CAAC;gBAC9D,EACV,UAAU,EACV,OAAO,EACP,SAAS,EACT,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,gBAAgB,GACjB,GAAE,0BAA+B;CA2DnC;AAED,wBAAgB,4BAA4B,CAAC,EAC3C,IAAI,EACJ,QAAQ,EACR,OAAiC,GAClC,EAAE;IACD,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,cAAc,CAAC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC7B,GAAG;IAAE,MAAM,EAAE,QAAQ,GAAG,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAW5D;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,IAAI,EACJ,QAAQ,EACR,OAAiC,GAClC,EAAE;IACD,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,cAAc,CAAC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC7B,GAAG;IAAE,MAAM,EAAE,QAAQ,GAAG,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAW5D"}

package/lib/types/common/upload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../../src/common/upload.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../../src/common/upload.ts"],"names":[],"mappings":"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"}

package/lib/types/utils/readableStream.d.ts

@@ -13,8 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export declare const DEFAULT_STREAM_CHUNK_SIZE: number;
 export declare function readableStreamToBuffer({ stream, size, }: {
     stream: ReadableStream;
     size: number;
 }): Promise<Buffer>;
+export declare function ensureChunkedStream(input: ReadableStream<Uint8Array>, maxChunkSize?: number): ReadableStream<Uint8Array>;
+export declare function createUint8ArrayReadableStreamFactory({ data, maxChunkSize, }: {
+    data: string | Uint8Array | ArrayBuffer | Buffer | SharedArrayBuffer | Blob | ReadableStream;
+    maxChunkSize?: number;
+}): () => ReadableStream<Uint8Array>;
 //# sourceMappingURL=readableStream.d.ts.map

package/lib/types/utils/readableStream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"readableStream.d.ts","sourceRoot":"","sources":["../../../src/utils/readableStream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,sBAAsB,CAAC,EAC3C,MAAM,EACN,IAAI,GACL,EAAE;IACD,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,MAAM,CAAC,CAelB"}
+{"version":3,"file":"readableStream.d.ts","sourceRoot":"","sources":["../../../src/utils/readableStream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,yBAAyB,QAAmB,CAAC;AAE1D,wBAAsB,sBAAsB,CAAC,EAC3C,MAAM,EACN,IAAI,GACL,EAAE;IACD,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,MAAM,CAAC,CAelB;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,cAAc,CAAC,UAAU,CAAC,EACjC,YAAY,SAA4B,GACvC,cAAc,CAAC,UAAU,CAAC,CAoC5B;AAED,wBAAgB,qCAAqC,CAAC,EACpD,IAAI,EACJ,YAAwC,GACzC,EAAE;IACD,IAAI,EACA,MAAM,GACN,UAAU,GACV,WAAW,GACX,MAAM,GACN,iBAAiB,GACjB,IAAI,GACJ,cAAc,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,MAAM,cAAc,CAAC,UAAU,CAAC,CA6DnC"}