fix(storage, other): work around Hermes Blob / firebase-js-sdk mal-interaction

Hermes Blob implementation is lacking, and breaks storage uploads done using
firebase-js-sdk which expects a full-featured implementation if "Blob" exists
on globalThis

if you temporarily hide the Blob implementation firebase-js-sdk will fallback
to a different data upload method, then binary storage uploads will work

So, make a custom binary upload pathway for storage when using firebase-js-sdk
and hide Blob in it, but only if platform is not in fact web

Author: mikehardy

packages/storage/e2e/StorageTask.e2e.js

@@ -1076,16 +1076,11 @@ describe('storage() -> StorageTask', function () {
         const jsonDerulo = JSON.stringify({ foo: 'bar' });
         const expectedByteLength = jsonDerulo.length;
 
-        const arrayBuffer = new ArrayBuffer(jsonDerulo.length);
-        const arrayBufferView = new Uint8Array(arrayBuffer);
-
-        for (let i = 0, strLen = jsonDerulo.length; i < strLen; i++) {
-          arrayBufferView[i] = jsonDerulo.charCodeAt(i);
-        }
+        const jsonDeruloBytes = new Uint8Array([...jsonDerulo].map(char => char.charCodeAt(0)));
 
         const uploadResult = await uploadBytes(
           ref(getStorage(), `${PATH}/uploadBytesModular.json`),
-          arrayBuffer,
+          jsonDeruloBytes,
           {
             contentType: 'application/json',
           },
@@ -1100,7 +1095,11 @@ describe('storage() -> StorageTask', function () {
       it('rejects when metadata is not an object', async function () {
         const { getStorage, ref, uploadBytes } = storageModular;
         try {
-          await uploadBytes(ref(getStorage(), `${PATH}/uploadBytesBadMeta.json`), new ArrayBuffer(), 123);
+          await uploadBytes(
+            ref(getStorage(), `${PATH}/uploadBytesBadMeta.json`),
+            new ArrayBuffer(),
+            123,
+          );
           return Promise.reject(new Error('Did not error!'));
         } catch (error) {
           error.message.should.containEql('must be an object value');

packages/storage/lib/StorageReference.ts

@@ -47,6 +47,25 @@ import type {
 } from './types/storage';
 import type { ListResultInternal, StorageInternal } from './types/internal';
 
+async function putPayloadToUint8Array(data: Blob | Uint8Array | ArrayBuffer): Promise<Uint8Array> {
+  if (data instanceof Uint8Array) {
+    return data.byteOffset === 0 && data.byteLength === data.buffer.byteLength
+      ? data
+      : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  return new Uint8Array(
+    await new Promise<ArrayBuffer>((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result as ArrayBuffer);
+      reader.onerror = () => reject(reader.error);
+      reader.readAsArrayBuffer(data);
+    }),
+  );
+}
+
 export default class Reference extends ReferenceBase implements StorageReference {
   _storage: StorageInternal;
 
@@ -206,6 +225,21 @@ export default class Reference extends ReferenceBase implements StorageReference
   put(data: Blob | Uint8Array | ArrayBuffer, metadata?: UploadMetadata): Task {
     const validatedMetadata = isUndefined(metadata) ? metadata : validateMetadata(metadata, false);
 
+    // Firebase-js fallback (e.g. macOS) exposes `uploadBinary`; iOS/Android native omit it.
+    const uploadBinary = this._storage.native.uploadBinary;
+    if (uploadBinary) {
+      return new StorageUploadTask(this, async task => {
+        const bytes = await putPayloadToUint8Array(data);
+        return uploadBinary.call(
+          this._storage.native,
+          this.toString(),
+          bytes,
+          validatedMetadata,
+          task._id,
+        );
+      });
+    }
+
     return new StorageUploadTask(this, task =>
       Base64.fromData(data).then(({ string, format }) => {
         const { _string, _format, _metadata } = this._updateString(

packages/storage/lib/types/internal.ts

@@ -158,12 +158,22 @@ export interface RNFBStorageModule {
     metadata: UploadMetadata | undefined,
     taskId: number,
   ): Promise<TaskSnapshot>;
+
+  /** Optional on firebase-js fallback only; native modules use base64 + {@link putString}. */
+  uploadBinary?(
+    url: string,
+    data: Uint8Array,
+    metadata: UploadMetadata | undefined,
+    taskId: number,
+  ): Promise<TaskSnapshot>;
+
   putFile(
     url: string,
     filePath: string,
     metadata: UploadMetadata | undefined,
     taskId: number,
   ): Promise<TaskSnapshot>;
+
   writeToFile(url: string, filePath: string, taskId: number): Promise<TaskSnapshot>;
 
   /**