feat!(sdk): Remove 'toFile' method

This removes a dependency on streamsaver.js. The equivalent function to this method is now viewable in the `App.tsx` file:

```ts
async function toFile(
  stream: ReadableStream<Uint8Array>,
  filepath = 'download.tdf',
  options?: {
    encoding?: BufferEncoding;
    signal?: AbortSignal;
  }
): Promise<void> {

  const fileStream = streamsaver.createWriteStream(filepath, {
    writableStrategy: { highWaterMark: 1 },
    readableStrategy: { highWaterMark: 1 },
  });

  return stream.pipeTo(fileStream, options);
}
```

lib/package.json

@@ -71,10 +71,8 @@
     "browser-fs-access": "^0.34.1",
     "buffer-crc32": "^0.2.13",
     "dpop": "^1.2.0",
-    "eventemitter3": "^5.0.1",
     "jose": "^4.14.4",
     "json-canonicalize": "^1.0.6",
-    "streamsaver": "^2.0.6",
     "uuid": "~9.0.0"
   },
   "devDependencies": {

lib/tdf3/src/client/DecoratedReadableStream.ts

@@ -1,11 +1,5 @@
-import { EventEmitter } from 'eventemitter3';
-import streamSaver from 'streamsaver';
-import { fileSave } from 'browser-fs-access';
-import { isFirefox } from '../../../src/utils.js';
-
 import { type Metadata } from '../tdf.js';
 import { type Manifest } from '../models/index.js';
-import { ConfigurationError } from '../../../src/errors.js';
 
 export async function streamToBuffer(stream: ReadableStream<Uint8Array>): Promise<Uint8Array> {
   const accumulator = await new Response(stream).arrayBuffer();
@@ -24,9 +18,6 @@ export class DecoratedReadableStream {
   tdfSize: number;
   fileSize: number | undefined;
   stream: ReadableStream<Uint8Array>;
-  ee: EventEmitter;
-  on: EventEmitter['on'];
-  emit: EventEmitter['emit'];
   metadata?: Metadata;
   manifest: Manifest;
   fileStreamServiceWorker?: string;
@@ -42,23 +33,10 @@ export class DecoratedReadableStream {
     this.stream = new ReadableStream(underlyingSource, {
       highWaterMark: 1,
     }) as ReadableStream<Uint8Array>;
-    this.ee = new EventEmitter();
-    this.on = (...args) => this.ee.on(...args);
-    this.emit = (...args) => this.ee.emit(...args);
   }
 
   async getMetadata() {
-    return new Promise((resolve, reject) => {
-      if (this.metadata) {
-        resolve(this.metadata);
-      } else {
-        this.on('error', reject);
-        this.on('rewrap', (rewrapResponse: Metadata) => {
-          this.metadata = rewrapResponse;
-          resolve(rewrapResponse);
-        });
-      }
-    });
+    return this.metadata;
   }
 
   /**
@@ -82,66 +60,12 @@ export class DecoratedReadableStream {
   async toString(): Promise<string> {
     return new Response(this.stream).text();
   }
-
-  /**
-   * Dump the stream content to a local file. This will consume the stream.
-   *
-   * @param filepath The path of the local file to write plaintext to.
-   * @param encoding The charset encoding to use. Defaults to utf-8.
-   */
-  async toFile(
-    filepath = 'download.tdf',
-    options?: BufferEncoding | DecoratedReadableStreamSinkOptions
-  ): Promise<void> {
-    if (options && typeof options === 'string') {
-      throw new ConfigurationError('unsupported operation: Cannot set encoding in browser');
-    }
-    if (isFirefox()) {
-      await fileSave(new Response(this.stream), {
-        fileName: filepath,
-        extensions: [`.${filepath.split('.').pop()}`],
-      });
-      return;
-    }
-
-    if (this.fileStreamServiceWorker) {
-      streamSaver.mitm = this.fileStreamServiceWorker;
-    }
-
-    const fileStream = streamSaver.createWriteStream(filepath, {
-      writableStrategy: { highWaterMark: 1 },
-      readableStrategy: { highWaterMark: 1 },
-    });
-
-    if (WritableStream) {
-      return this.stream.pipeTo(fileStream, options);
-    }
-
-    // Write (pipe) manually
-    const reader = this.stream.getReader();
-    const writer = fileStream.getWriter();
-    const pump = async (): Promise<void> => {
-      const res = await reader.read();
-
-      if (res.done) {
-        return await writer.close();
-      } else {
-        await writer.write(res.value);
-        return pump();
-      }
-    };
-    return pump();
-
-    // const pump = (): Promise<void> =>
-    //   reader.read().then((res) => (res.done ? writer.close() : writer.write(res.value).then(pump)));
-    // pump();
-  }
 }
 
 export function isDecoratedReadableStream(s: unknown): s is DecoratedReadableStream {
   return (
+    typeof (s as DecoratedReadableStream)?.stream !== 'undefined' &&
     typeof (s as DecoratedReadableStream)?.toBuffer !== 'undefined' &&
-    typeof (s as DecoratedReadableStream)?.toFile !== 'undefined' &&
     typeof (s as DecoratedReadableStream)?.toString !== 'undefined'
   );
 }

lib/tdf3/src/tdf.ts

@@ -1023,8 +1023,6 @@ export async function readStream(cfg: DecryptConfiguration) {
   const outputStream = new DecoratedReadableStream(underlyingSource);
 
   outputStream.manifest = manifest;
-  outputStream.emit('manifest', manifest);
   outputStream.metadata = metadata;
-  outputStream.emit('rewrap', metadata);
   return outputStream;
 }

web-app/package.json

@@ -19,7 +19,8 @@
     "clsx": "^2.1.1",
     "native-file-system-adapter": "^3.0.1",
     "react": "^18.3.1",
-    "react-dom": "^18.3.1"
+    "react-dom": "^18.3.1",
+    "streamsaver": "^2.0.6"
   },
   "devDependencies": {
     "@playwright/test": "^1.48.2",

web-app/src/App.tsx

@@ -1,11 +1,30 @@
 import { clsx } from 'clsx';
 import { useState, useEffect, type ChangeEvent } from 'react';
+import streamsaver from 'streamsaver';
 import { showSaveFilePicker } from 'native-file-system-adapter';
 import './App.css';
 import { type Chunker, type DecryptSource, NanoTDFClient, TDF3Client } from '@opentdf/sdk';
 import { type SessionInformation, OidcClient } from './session.js';
 import { c } from './config.js';
 
+
+async function toFile(
+  stream: ReadableStream<Uint8Array>,
+  filepath = 'download.tdf',
+  options?: {
+    encoding?: BufferEncoding;
+    signal?: AbortSignal;
+  }
+): Promise<void> {
+
+  const fileStream = streamsaver.createWriteStream(filepath, {
+    writableStrategy: { highWaterMark: 1 },
+    readableStrategy: { highWaterMark: 1 },
+  });
+
+  return stream.pipeTo(fileStream, options);
+}
+
 function decryptedFileName(encryptedFileName: string): string {
   // Groups: 1 file 'name' bit
   // 2: original file extension
@@ -425,7 +444,7 @@ function App() {
           cipherText.stream = cipherText.stream.pipeThrough(progressTransformers.writer);
           switch (sinkType) {
             case 'file':
-              await cipherText.toFile(downloadName, { signal: sc.signal });
+              await toFile(cipherText.stream, downloadName, { signal: sc.signal });
               break;
             case 'fsapi':
               if (!f) {
@@ -493,7 +512,7 @@ function App() {
           cipherText.stream = cipherText.stream.pipeThrough(progressTransformers.writer);
           switch (sinkType) {
             case 'file':
-              await cipherText.toFile(downloadName, { signal: sc.signal });
+              await toFile(cipherText.stream, downloadName, { signal: sc.signal });
               break;
             case 'fsapi':
               if (!f) {
@@ -571,7 +590,7 @@ function App() {
             .pipeThrough(progressTransformers.writer);
           switch (sinkType) {
             case 'file':
-              await plainText.toFile(dfn, { signal: sc.signal });
+              await toFile(plainText.stream, dfn, { signal: sc.signal });
               break;
             case 'fsapi':
               if (!f) {