fix: call each method from FileReader.prototype

Author: myrear

__tests__/readAs.test.ts

@@ -1,58 +1,68 @@
 import './setup.ts'
 import { assertEquals, assertInstanceOf } from 'std/assert/mod.ts'
-import { assertSpyCall, spy } from 'std/testing/mock.ts'
+import { assertSpyCall, Spy, spy } from 'std/testing/mock.ts'
+import { afterEach, describe, it } from 'std/testing/bdd.ts'
 import { readAs } from '../mod.ts'
 
-Deno.test('read blob', async (t) => {
+describe('read blob', () => {
+  let readAsSpy: Spy<FileReader, [blob: Blob, encoding?: string], void>
+
+  afterEach(() => {
+    readAsSpy.restore()
+  })
+
   const blob = new Blob(['foo'], { type: 'text/plain' })
 
-  await t.step('as `ArrayBuffer`', async () => {
+  it('as `ArrayBuffer`', async () => {
     const reader = new FileReader()
-    const readAsArrayBufferSpy = spy(reader, 'readAsArrayBuffer')
+    readAsSpy = spy(FileReader.prototype, 'readAsArrayBuffer')
     const result = await readAs(reader, blob, 'ArrayBuffer')
 
     assertEquals(result, reader.result)
     assertInstanceOf(result, ArrayBuffer)
-    assertSpyCall(readAsArrayBufferSpy, 0, {
+    assertSpyCall(readAsSpy, 0, {
       self: reader,
       args: [blob, undefined],
     })
   })
 
-  await t.step('as `BinaryString`', async () => {
+  it('as `BinaryString`', async () => {
     const reader = new FileReader()
-    const readAsBinaryStringSpy = spy(reader, 'readAsBinaryString')
+    readAsSpy = spy(
+      FileReader.prototype,
+      'readAsBinaryString',
+    )
     const result = await readAs(reader, blob, 'BinaryString')
 
     assertEquals(result, reader.result)
     assertEquals(result, 'foo')
-    assertSpyCall(readAsBinaryStringSpy, 0, {
+    assertSpyCall(readAsSpy, 0, {
       self: reader,
       args: [blob, undefined],
     })
   })
 
-  await t.step('as `DataURL`', async () => {
+  it('as `DataURL`', async () => {
     const reader = new FileReader()
-    const readAsDataURLSpy = spy(reader, 'readAsDataURL')
+    readAsSpy = spy(FileReader.prototype, 'readAsDataURL')
     const result = await readAs(reader, blob, 'DataURL')
 
     assertEquals(result, reader.result)
     assertEquals(result, 'data:text/plain;base64,Zm9v')
-    assertSpyCall(readAsDataURLSpy, 0, {
+    assertSpyCall(readAsSpy, 0, {
       self: reader,
       args: [blob, undefined],
     })
   })
 
-  await t.step('as `Text` with encoding utf-8', async () => {
+  it('as `Text` with encoding utf-8', async () => {
     const reader = new FileReader()
-    const readAsTextSpy = spy(reader, 'readAsText')
+    readAsSpy = spy(FileReader.prototype, 'readAsText')
     const result = await readAs(reader, blob, 'Text', 'utf-8')
 
     assertEquals(result, reader.result)
-    assertEquals(typeof result, 'string')
-    assertSpyCall(readAsTextSpy, 0, {
+    assertEquals(result, 'foo')
+    assertSpyCall(readAsSpy, 0, {
       self: reader,
       args: [blob, 'utf-8'],
     })

deno.lock

@@ -1,27 +1,19 @@
-import { promisifyReader } from './promisifyReader.ts'
+import { readAs } from './readAs.ts'
 
 export class FileReader extends globalThis.FileReader {
-  readAsArrayBuffer(blob: Blob): Promise<ArrayBuffer>
   readAsArrayBuffer(blob: Blob) {
-    super.readAsArrayBuffer(blob)
-    return promisifyReader(this)
+    return readAs(this, blob, 'ArrayBuffer')
   }
 
-  readAsBinaryString(blob: Blob): Promise<string>
   readAsBinaryString(blob: Blob) {
-    super.readAsBinaryString(blob)
-    return promisifyReader(this)
+    return readAs(this, blob, 'BinaryString')
   }
 
-  readAsDataURL(blob: Blob): Promise<string>
   readAsDataURL(blob: Blob) {
-    super.readAsDataURL(blob)
-    return promisifyReader(this)
+    return readAs(this, blob, 'DataURL')
   }
 
-  readAsText(blob: Blob, encoding?: string): Promise<string>
   readAsText(blob: Blob, encoding?: string) {
-    super.readAsText(blob, encoding)
-    return promisifyReader(this)
+    return readAs(this, blob, 'Text', encoding)
   }
 }

src/FileReader.ts

@@ -1,5 +1,3 @@
-import { promisifyReader } from './promisifyReader.ts'
-
 export function readAs(
   reader: FileReader,
   blob: Blob,
@@ -25,6 +23,22 @@ export function readAs(
   as: 'ArrayBuffer' | 'DataURL' | 'Text' | 'BinaryString',
   encoding?: string,
 ) {
-  reader[`readAs${as}`](blob, encoding)
-  return promisifyReader(reader)
+  return new Promise<FileReader['result']>((resolve, reject) => {
+    reader.addEventListener('load', loadListener)
+    reader.addEventListener('error', reject)
+    reader.addEventListener('abort', reject)
+    reader.addEventListener('loadend', removeEventListener)
+    FileReader.prototype[`readAs${as}`].call(reader, blob, encoding)
+
+    function removeEventListener() {
+      reader.removeEventListener('load', loadListener)
+      reader.removeEventListener('error', reject)
+      reader.removeEventListener('abort', reject)
+      reader.removeEventListener('loadend', removeEventListener)
+    }
+
+    function loadListener() {
+      resolve(reader.result)
+    }
+  })
 }