@entropic-bond/firebase 1.13.2 → 1.13.4

package/functions/package.json

@@ -1,26 +0,0 @@
-{
-  "name": "functions",
-  "scripts": {
-    "build": "tsc",
-    "build:watch": "tsc --watch",
-    "serve": "npm run build && firebase emulators:start --only functions",
-    "shell": "npm run build && firebase functions:shell",
-    "start": "npm run shell",
-    "deploy": "firebase deploy --only functions",
-    "logs": "firebase functions:log",
-    "install-build": "npm i && npm run build",
-    "postinstall": "npm run build"
-  },
-  "engines": {
-    "node": "20"
-  },
-  "main": "lib/index.js",
-  "dependencies": {
-    "firebase-admin": "^12.0.0",
-    "firebase-functions": "^4.7.0"
-  },
-  "devDependencies": {
-    "typescript": "^5.3.3"
-  },
-  "private": true
-}

package/functions/src/index.ts

@@ -1,33 +0,0 @@
-import * as _functions from 'firebase-functions'
-import admin from 'firebase-admin'
-import { persistent, Persistent, PersistentObject, registerPersistentClass } from 'entropic-bond'
-
-@registerPersistentClass( 'ParamWrapper' )
-export class ParamWrapper extends Persistent {
-	constructor( a?: string, b?: number ) {
-		super()
-		this._a = a
-		this._b = b
-	}
-	@persistent _a: string
-	@persistent _b: number
-}
-
-
-admin.initializeApp()
-const functions = _functions.region('europe-west1')
-
-export const test = functions.https.onRequest((_req, res) => {
-  res.send('Hello from Firebase!')
-})
-
-export const testCallablePersistent = functions.https.onCall( 
-	( param: PersistentObject<ParamWrapper> ) => {
-		Persistent.registerFactory( 'ParamWrapper', ParamWrapper )
-		return param
-	}
-)
-
-export const testCallablePlain = functions.https.onCall( 
-	( param: string ) => param.length
-)

package/functions/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2021",
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "sourceMap": true,
-    "outDir": "lib",
-		"resolveJsonModule": true,
-    "experimentalDecorators": true,
-    "lib": [
-      "ES2021", "WebWorker"
-    ]
-  },
-  "compileOnSave": false,
-  "include": [
-    "src"
-  ]
-}

package/src/auth/firebase-auth.spec.ts

@@ -1,90 +0,0 @@
-import { Auth } from 'entropic-bond'
-import { FirebaseHelper } from '../firebase-helper'
-import { FirebaseAuth } from './firebase-auth'
-
-// NOTE: Firebase auth emulator requires a modification of the code to test which
-//       violates testing best practices. Therefore, this test is disabled.
-
-describe( 'Firebase Auth', ()=>{
-	it( 'should pass', ()=>{
-		expect( true ).toBe( true )
-	})
-	
-// 	let authChangeSpy = vi.fn()
-// 	FirebaseHelper.setFirebaseConfig({
-// 		projectId: "demo-test",
-// 	})
-// 	FirebaseHelper.useEmulator({ authPort: 9099 })
-
-// 	beforeEach(()=>{
-// 		Auth.registerAuthService( new FirebaseAuth() )
-// 		Auth.instance.onAuthStateChange( authChangeSpy ) 
-// 	})
-
-// 	it( 'should emulate sign-up', async ()=>{
-// 		const userCredential = await Auth.instance.signUp({
-// 			authProvider: 'google',
-// 			email: 'test@test.com',
-// 			password: 'password'
-// 		})
-
-// 		expect( userCredential.email ).toEqual( 'test@test.com' )
-// 		expect( authChangeSpy ).toHaveBeenCalledWith( userCredential )
-// 	})
-
-// 	it( 'should emulate failed sign-up', async ()=>{
-// 		try {
-// 			var userCredential = await Auth.instance.signUp({
-// 				authProvider: 'fail',
-// 				email: 'test@test.com',
-// 				password: 'password'
-// 			})
-// 		}
-// 		catch {}
-
-// 		expect( userCredential ).toBeUndefined()
-// 		expect( authChangeSpy ).toHaveBeenCalledWith( undefined )
-// 	})
-
-// 	it( 'should login with fake registered user', async ()=>{
-// 		const userCredentials = await Auth.instance.login({
-// 			email: 'fakeUser@test.com',
-// 			password: 'password',
-// 			authProvider: 'google'
-// 		})
-
-// 		expect( userCredentials ).toEqual( 'fakeUseCredentials' )
-// 		expect( authChangeSpy ).toHaveBeenCalledWith( 'fakeUseCredentials' )
-// 	})
-
-// 	it( 'should fail login with email auth provider if does not match fake user credentials', async ()=>{
-// 		try {
-// 			var userCredentials = await Auth.instance.login({
-// 				email: 'test@test.com',
-// 				password: 'password',
-// 				authProvider: 'email'
-// 			})
-// 		} catch {}
-
-// 		expect( userCredentials ).toEqual( undefined )
-// 		expect( authChangeSpy ).toHaveBeenCalledWith( undefined )
-// 	})
-	
-// 	it( 'should NOT fail login with non email auth provider even if does not match fake user credentials', async ()=>{
-// 		const userCredentials = await Auth.instance.login({
-// 			email: 'test@test.com',
-// 			password: 'password',
-// 			authProvider: 'google'
-// 		})
-
-// 		expect( userCredentials.email ).toEqual( 'test@test.com' )
-// 		expect( authChangeSpy ).toHaveBeenCalledWith( undefined )
-// 	})
-
-// 	it( 'should logout', async ()=>{
-// 		await Auth.instance.logout()
-
-// 		expect( authChangeSpy ).toHaveBeenCalledWith( undefined )
-// 	})
-	
-})

package/src/auth/firebase-auth.ts

@@ -1,212 +0,0 @@
-import { AuthProvider, SignData, UserCredentials, AuthService, RejectedCallback, ResovedCallback, AuthErrorCode, camelCase } from 'entropic-bond'
-import { connectAuthEmulator, createUserWithEmailAndPassword, FacebookAuthProvider, GoogleAuthProvider, linkWithPopup, sendEmailVerification, signInAnonymously, signInWithEmailAndPassword, signInWithPopup, TwitterAuthProvider, updateProfile, unlink, User, UserCredential, sendPasswordResetEmail } from 'firebase/auth'
-import { EmulatorConfig, FirebaseHelper } from '../firebase-helper'
-
-interface CredentialProviders {
-	[ name: string ]: ( signData: SignData ) => Promise<UserCredential>
-}
-
-const providerFactory = {
-	'twitter': () => new TwitterAuthProvider(),
-	'facebook': () => new FacebookAuthProvider(),
-	'google': () => new GoogleAuthProvider()
-}
-
-export class FirebaseAuth extends AuthService {
-	constructor( emulator?: EmulatorConfig ) {
-		super()
-		if ( emulator ) FirebaseHelper.useEmulator( emulator )
-		
-		if ( FirebaseHelper.emulator?.emulate ) {
-			const { host, authPort } = FirebaseHelper.emulator
-			if ( !host || !authPort ) throw new Error( `You should define a host and an auth emulator port to use the emulator` )
-
-			connectAuthEmulator( FirebaseHelper.instance.auth(), `http://${ host }:${ authPort }` )
-		}
-
-		this.registerCredentialProviders()
-	}
-
-	signUp<T extends {}>( signData: SignData ): Promise<UserCredentials<T>> {
-		const { authProvider, verificationLink } = signData
-	
-		if ( authProvider.slice( 0, 5 ) === 'email' ) {
-			return new Promise<UserCredentials<T>>( async ( resolve: ResovedCallback<T>, reject: RejectedCallback ) => {
-				try {
-					const credentialFactory = this.credentialProviders[ 'email-sign-up' ]
-					if ( !credentialFactory ) throw new Error( `The provider ${ authProvider } is not registered` )
-
-					const userCredentials = await credentialFactory( signData )
-
-					if ( signData.name ) {
-						await updateProfile( userCredentials.user, {
-							displayName: signData.name
-						})
-					}
-					
-					if ( verificationLink ) {
-						await sendEmailVerification( userCredentials.user, {
-							url: verificationLink
-						})
-					}
-
-					resolve( await this.toUserCredentials( userCredentials.user ) )
-				}
-				catch( error ) {
-					reject({ 
-						code: camelCase( error.code.slice( 5 ) ) as AuthErrorCode, 
-						message: error.message 
-					})
-				}
-			})
-		}
-		else return this.login( signData )
-	}
-
-	login<T extends {}>( signData: SignData ): Promise<UserCredentials<T>> {
-		const { authProvider } = signData
-
-		return new Promise<UserCredentials<T>>( async ( resolve: ResovedCallback<T>, reject: RejectedCallback ) => {
-			try {
-				const credentialFactory = this.credentialProviders[ authProvider ]
-				if ( !credentialFactory ) throw new Error( `The provider ${ authProvider } is not registered` )
-				const userCredentials = await credentialFactory( signData )
-				resolve( await this.toUserCredentials<T>( userCredentials.user ) )
-			}
-			catch( error ) {
-				reject({ 
-					code: error.code === 400? 'missingPassword' : camelCase( error.code.slice( 5 )) as AuthErrorCode, 
-					message: error.message
-				})
-			}
-		})
-	}
-
-	logout(): Promise<void> {
-		return FirebaseHelper.instance.auth().signOut()
-	}
-
-	resetEmailPassword( email: string ) {
-		return new Promise<void>( async ( resolve, reject ) => {
-			try {
-				await sendPasswordResetEmail( FirebaseHelper.instance.auth(), email )
-				resolve()
-			}
-			catch( error ) {
-				reject({
-					code: camelCase( error.code.slice( 5 ) ) as AuthErrorCode,
-					message: error.message
-				})
-			}
-		})
-	}
-
-	resendVerificationEmail( email: string, password: string, verificationLink: string ): Promise<void> {
-		return new Promise<void>( async ( resolve, reject ) => {
-			try {
-				await signInWithEmailAndPassword( FirebaseHelper.instance.auth(), email, password )
-				const user = FirebaseHelper.instance.auth().currentUser
-				if ( !user ) { 
-					reject({
-						code: 'userNotFound',
-						message: `There is no logged in user`
-					})
-					return
-				}
-
-				await sendEmailVerification( user, {
-					url: verificationLink
-				})
-				resolve()
-			}
-			catch( error ) {
-				reject({
-					code: camelCase( error.code.slice( 5 ) ) as AuthErrorCode,
-					message: verificationLink
-				})
-			}
-		})
-	}
-
-	override refreshToken(): Promise<void> {
-		return FirebaseHelper.instance.auth().currentUser?.getIdToken( true ) as unknown as Promise<void>
-	}
-
-	onAuthStateChange<T extends {}>( onChange: (userCredentials: UserCredentials<T> | undefined) => void ) {
-		FirebaseHelper.instance.auth().onAuthStateChanged( async credentials =>{
-			onChange( credentials? await this.toUserCredentials( credentials ) : undefined )
-		})
-	}
-
-	linkAdditionalProvider( provider: AuthProvider ): Promise<unknown> {
-		const providerInstance = providerFactory[ provider ]()
-		const currentUser = FirebaseHelper.instance.auth().currentUser
-		if ( !currentUser ) throw new Error( `There is no logged in user` )
-
-		return linkWithPopup( currentUser, providerInstance )
-	}
-
-	unlinkProvider( provider: AuthProvider ): Promise<unknown> {
-		const { currentUser } = FirebaseHelper.instance.auth()
-		if ( !currentUser ) throw new Error( `There is no logged in user` )
-
-		currentUser.providerData
-		return unlink( currentUser, providerFactory[ provider ]().providerId )
-	}
-
-	private async toUserCredentials<T extends {}>( nativeUserCredential: User ): Promise<UserCredentials<T>> {
-		if ( !nativeUserCredential ) throw new Error( `The user in user credentials is not defined` )
-		
-		const claims = ( await nativeUserCredential.getIdTokenResult() ).claims as T
-
-		return FirebaseAuth.convertCredentials<T>( nativeUserCredential, claims )
-	}
-
-	static convertCredentials<T extends {}>( nativeUserCredential: User, claims: T ): UserCredentials<T> {
-		return ({
-			id: nativeUserCredential.uid,
-			email: nativeUserCredential.email ?? '',
-			name: nativeUserCredential.displayName ?? undefined,
-			pictureUrl: nativeUserCredential.photoURL ?? undefined,
-			phoneNumber: nativeUserCredential.phoneNumber ?? undefined,
-			emailVerified: nativeUserCredential.emailVerified,
-			customData: {...claims},
-			lastLogin: Date.now(),
-			creationDate: nativeUserCredential.metadata.creationTime? new Date( nativeUserCredential.metadata.creationTime ).getTime() : undefined,
-		})
-	}
-
-	registerCredentialProvider( name: string, providerFactory: ( singData: SignData ) => Promise<UserCredential> ) {
-		this.credentialProviders[ name ] = providerFactory		
-	}
-
-	private registerCredentialProviders() { //TODO: refactor. Not needed anymore
-		this.registerCredentialProvider( 'email-sign-up', signData => {
-			if ( !signData.email || !signData.password ) throw new Error( `Email and password are required` )
-			return createUserWithEmailAndPassword(	FirebaseHelper.instance.auth(), signData.email, signData.password )
-		})
-		this.registerCredentialProvider( 'email', signData => {
-			if ( !signData.email || !signData.password ) throw new Error( `Email and password are required` )
-			return signInWithEmailAndPassword( FirebaseHelper.instance.auth(), signData.email, signData.password )
-		})
-		this.registerCredentialProvider( 'google', () => signInWithPopup(
-			FirebaseHelper.instance.auth(), new GoogleAuthProvider()
-		))
-		this.registerCredentialProvider( 'facebook', () => signInWithPopup(
-			FirebaseHelper.instance.auth(), new FacebookAuthProvider()
-		))
-		this.registerCredentialProvider( 'twitter', () => signInWithPopup(
-			FirebaseHelper.instance.auth(), new TwitterAuthProvider()
-		))
-		this.registerCredentialProvider( 'link-twitter', () => {
-			const currentUser = FirebaseHelper.instance.auth().currentUser
-			if ( !currentUser ) throw new Error( `There is no logged in user` )
-			return linkWithPopup(	currentUser, new TwitterAuthProvider() )
-		})
-		this.registerCredentialProvider( 'anonymous', () => signInAnonymously(
-			FirebaseHelper.instance.auth()
-		))
-	}
-
-	private credentialProviders: CredentialProviders = {}
-}

package/src/cloud-functions/firebase-cloud-functions.spec.ts

@@ -1,47 +0,0 @@
-import { CloudFunctions, Persistent, persistent, registerPersistentClass } from 'entropic-bond'
-import { FirebaseHelper } from '../firebase-helper'
-import { FirebaseCloudFunctions } from './firebase-cloud-functions'
-
-@registerPersistentClass( 'ParamWrapper' )
-export class ParamWrapper extends Persistent {
-	constructor( a?: string, b?: number ) {
-		super()
-		this._a = a
-		this._b = b
-	}
-	@persistent _a: string | undefined
-	@persistent _b: number | undefined
-}
-
-describe( 'Cloud functions', ()=>{
-
-	beforeEach(()=>{
-		FirebaseHelper.setFirebaseConfig({
-			projectId: 'demo-test',
-			storageBucket: 'default-bucket'
-		})
-		
-		FirebaseHelper.useEmulator()
-		CloudFunctions.useCloudFunctionsService( 
-			new FirebaseCloudFunctions( 'europe-west1', { emulate: true })
-		)
-	})
-
-	it( 'should call cloud functions with plain types', async ()=>{
-		const testCallablePlain = CloudFunctions.instance.getFunction<string, number>( 'testCallablePlain' )
-		const result = await testCallablePlain( 'Hello' )
-
-		expect( result ).toBe( 5 )
-	})
-	
-	it( 'should call cloud function for Persistent', async ()=>{
-		const testCallablePersistent = CloudFunctions.instance.getFunction<ParamWrapper, ParamWrapper>( 'testCallablePersistent' )
-		const paramWrapper = new ParamWrapper( 'test', 30 )
-
-		const a = paramWrapper.toObject()
-
-		const result = await testCallablePersistent( paramWrapper )
-		expect( result._a ).toEqual( 'test' )
-		expect( result._b ).toEqual( 30 )
-	})
-})

package/src/cloud-functions/firebase-cloud-functions.ts

@@ -1,25 +0,0 @@
-import { CloudFunction, CloudFunctionsService } from 'entropic-bond'
-import { connectFunctionsEmulator, httpsCallable } from 'firebase/functions'
-import { EmulatorConfig, FirebaseHelper } from '../firebase-helper'
-
-export class FirebaseCloudFunctions implements CloudFunctionsService {
-	constructor( region?: string, emulator?: Partial<EmulatorConfig> ) {
-		if ( region ) FirebaseHelper.setRegion( region )
-		if ( emulator ) FirebaseHelper.useEmulator( emulator )
-		
-		if ( FirebaseHelper.emulator?.emulate ) {
-			const { host, functionsPort } = FirebaseHelper.emulator
-			connectFunctionsEmulator( FirebaseHelper.instance.functions(), host, functionsPort )
-		}
-
-	}
-
-	retrieveFunction<P, R>( cloudFunction: string ): CloudFunction<P, R> {
-		return httpsCallable<P,R>( FirebaseHelper.instance.functions(), cloudFunction ) as unknown as CloudFunction<P, R>
-	}
-
-	async callFunction<P, R>( func: CloudFunction<P, R>, params: P ): Promise<R> {
-		const res = await func( params ) as any
-		return res.data
-	}
-}

package/src/cloud-storage/firebase-cloud-storage.spec.ts

@@ -1,135 +0,0 @@
-(global as any).XMLHttpRequest = require('xhr2')
-import { FirebaseCloudStorage } from './firebase-cloud-storage'
-import { FirebaseHelper } from '../firebase-helper'
-import { FirebaseDatasource } from '../store/firebase-datasource'
-import { CloudStorage, Model, Persistent, persistent, registerPersistentClass, Store, StoredFile } from 'entropic-bond'
-
-// Note about tests leaking. I've been checking and looks like firebase.storage 
-// methods are the responsible for the test leaking (as firebase v. 8.6.3).
-
-class File {	
-	data: Uint8Array | undefined
-	name: string | undefined
-	lastModified: any
-	size: number | undefined
-	type: any
-	arrayBuffer: any
-	slice: any
-	stream: any
-	text: any
-}
-global['File'] = File as any
-
-@registerPersistentClass( 'Test' )
-class Test extends Persistent {
-
-	get file(): StoredFile {
-		return this._file
-	}
-	
-	@persistent private _file: StoredFile = new StoredFile()
-}
-
-describe( 'Firebase Cloud Storage', ()=>{
-	const blobData1 = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x21]);
-	const blobData2 = new Uint8Array([0x6c, 0x6c, 0x6f, 0x2c, 0x48, 0x65, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x21]);
-	let file: StoredFile
-
-	FirebaseHelper.setFirebaseConfig({
-		projectId: 'demo-test',
-		storageBucket: 'default-bucket'
-	})
-	FirebaseHelper.useEmulator({ firestorePort: 9080 })
-	Store.useDataSource( new FirebaseDatasource() )
-
-	beforeEach(()=>{
-		CloudStorage.useCloudStorage( new FirebaseCloudStorage() )
-		file = new StoredFile()
-	})
-
-	it( 'should save and get a url', async ()=>{
-		await file.save({ data:blobData1 })
-
-		expect( file.url ).toContain( file.id )
-	})
-	
-	it( 'should report metadata', async ()=>{
-		await file.save({ data: blobData1, fileName: 'test.dat' })
-
-		expect( file.originalFileName ).toEqual( 'test.dat' )
-		expect( file.provider.className ).toEqual( 'FirebaseCloudStorage' )
-	})
-
-	it( 'should delete file', async ()=>{
-		await file.save({ data:blobData1 })
-
-		await file.delete()
-		expect( file.url ).not.toBeDefined()		
-	})
-
-	it( 'should overwrite file on subsequent writes', async ()=>{
-		await file.save({ data:blobData1 })
-		const firstUrl = file.url
-		let resp = await fetch( file.url! )
-		expect( await resp.text() ).toEqual( 'Hello, world!')
-
-		await file.save({ data:blobData2 })
-		resp = await fetch( file.url! )
-		expect( 
-			file.url?.slice( 0, file.url.indexOf('token') ) 
-		).toEqual( 
-			firstUrl?.slice( 0, firstUrl.indexOf('token') ) 
-		)
-		expect( await resp.text() ).toEqual( 'llo,He world!')
-	})
-
-	it( 'should trigger events', async () => {
-		const cb = vi.fn()
-
-		const savePromise = file.save({ data:blobData1 })
-		file.uploadControl().onProgress( cb )
-		await savePromise
-
-		expect( cb ).toHaveBeenCalledTimes( 2 )
-	})
-
-	describe( 'Streaming', ()=>{
-		let model: Model<Test>
-		let testObj: Test
-
-		beforeEach(()=>{
-			testObj = new Test()
-			model = Store.getModel<Test>( testObj )
-		})
-
-		it( 'should load object with StoredFile', async ()=>{
-			await testObj.file.save({ data: blobData1, fileName: 'test.dat' })
-			await model.save( testObj )
-
-			const newTestObj = await model.findById( testObj.id )
-
-			expect( newTestObj?.file ).toBeInstanceOf( StoredFile )
-			expect( newTestObj?.file.url ).toContain( testObj.file.id )
-		})
-
-		it( 'should replace file on save after load', async ()=>{
-			const deleteSpy = vi.spyOn( testObj.file, 'delete' )
-
-			await testObj.file.save({ data: blobData1, fileName: 'test.dat' })
-			await model.save( testObj )
-
-			const newTestObj = await model.findById( testObj.id )
-
-			expect( newTestObj?.file ).toBeInstanceOf( StoredFile )
-			expect( newTestObj?.file.url ).toContain( testObj.file.id )
-			expect( deleteSpy ).not.toHaveBeenCalled()
-
-			testObj.file.setDataToStore( blobData2 )
-			await testObj.file.save()
-
-			expect( deleteSpy ).toHaveBeenCalled()
-		})		
-
-	})
-
-})

package/src/cloud-storage/firebase-cloud-storage.ts

@@ -1,67 +0,0 @@
-import { registerCloudStorage, CloudStorage, UploadControl, UploadProgress } from 'entropic-bond'
-import { deleteObject, getDownloadURL, ref, uploadBytesResumable, UploadTask, connectStorageEmulator } from 'firebase/storage'
-import { EmulatorConfig, FirebaseHelper } from '../firebase-helper'
-
-@registerCloudStorage( 'FirebaseCloudStorage', ()=> new FirebaseCloudStorage() )
-export class FirebaseCloudStorage extends CloudStorage {
-	constructor( emulator?: EmulatorConfig ) {
-		super()
-		if ( emulator ) FirebaseHelper.useEmulator( emulator )
-		
-		if ( FirebaseHelper.emulator?.emulate ) {
-			const { host, storagePort } = FirebaseHelper.emulator
-			connectStorageEmulator( FirebaseHelper.instance.storage(), host, storagePort )
-		}
-	}
-
-	save( id: string, data: Blob | Uint8Array | ArrayBuffer, progress?: UploadProgress ): Promise<string> {
-		const storage = FirebaseHelper.instance.storage()
-
-		return new Promise<string>(( resolve, reject ) => {
-			this._uploadTask = uploadBytesResumable( ref( storage, id ), data )
-			
-			if ( progress ) {
-				var unsubscribe = this._uploadTask.on( 'state_changed', 
-					snapshot => {
-						progress( snapshot.bytesTransferred, snapshot.totalBytes )
-					},
-					null, 
-					()=>unsubscribe() 
-				);
-			}
-
-			this._uploadTask
-				.then( () => resolve( id ) )
-				.catch( error => reject( error ))
-		})
-	}
-
-	getUrl( reference: string ): Promise<string> {
-		if ( !reference ) return Promise.reject( 'needs a reference' )
-
-		const storage = FirebaseHelper.instance.storage()
-		return getDownloadURL( ref( storage, reference ) )
-	}
-
-	uploadControl(): UploadControl {
-		if ( !this._uploadTask ) throw new Error( `You should call save() before uploadControl()` )
-
-		return {
-			cancel: ()=>this._uploadTask?.cancel(),
-			pause: ()=>this._uploadTask?.pause(),
-			resume: ()=>this._uploadTask?.resume(),
-			onProgress: ( callback )=> this._uploadTask?.on( 'state_changed', snapShot => {
-				if ( callback ) {
-					callback( snapShot.bytesTransferred, snapShot.totalBytes )
-				}
-			})
-		}
-	}
-
-	delete( reference: string ): Promise<void> {
-		const storage = FirebaseHelper.instance.storage()
-		return deleteObject( ref( storage, reference ) )
-	}
-
-	private _uploadTask: UploadTask | undefined
-}