Apply auto lint-fix changes

Author: Code-Hex

example/index.ts

@@ -1,5 +1,5 @@
-import type { EmulatorEnv } from '../src'
-import { Auth, emulatorHost, WorkersKVStoreSingle } from '../src'
+import type { EmulatorEnv } from '../src';
+import { Auth, emulatorHost, WorkersKVStoreSingle } from '../src';
 
 interface Bindings extends EmulatorEnv {
   EMAIL_ADDRESS: string;
@@ -10,13 +10,13 @@ interface Bindings extends EmulatorEnv {
   PUBLIC_JWK_CACHE_KEY: string;
 }
 
-const signInPath = '/identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key=test1234'
+const signInPath = '/identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key=test1234';
 
 export async function handleRequest(req: Request, env: Bindings) {
-  const url = new URL(req.url)
-  const firebaseEmuHost = emulatorHost(env)
+  const url = new URL(req.url);
+  const firebaseEmuHost = emulatorHost(env);
   if (url.pathname === '/get-jwt' && !!firebaseEmuHost) {
-    const firebaseEmulatorSignInUrl = 'http://' + firebaseEmuHost + signInPath
+    const firebaseEmulatorSignInUrl = 'http://' + firebaseEmuHost + signInPath;
     const resp = await fetch(firebaseEmulatorSignInUrl, {
       method: 'POST',
       body: JSON.stringify({
@@ -27,28 +27,28 @@ export async function handleRequest(req: Request, env: Bindings) {
       headers: {
         'Content-Type': 'application/json',
       },
-    })
-    return resp
+    });
+    return resp;
   }
 
-  const authorization = req.headers.get('Authorization')
+  const authorization = req.headers.get('Authorization');
   if (authorization === null) {
     return new Response(null, {
       status: 400,
-    })
+    });
   }
-  const jwt = authorization.replace(/Bearer\s+/i, '')
+  const jwt = authorization.replace(/Bearer\s+/i, '');
   const auth = Auth.getOrInitialize(
     env.PROJECT_ID,
     WorkersKVStoreSingle.getOrInitialize(env.PUBLIC_JWK_CACHE_KEY, env.PUBLIC_JWK_CACHE_KV)
-  )
-  const firebaseToken = await auth.verifyIdToken(jwt, env)
+  );
+  const firebaseToken = await auth.verifyIdToken(jwt, env);
 
   return new Response(JSON.stringify(firebaseToken), {
     headers: {
       'Content-Type': 'application/json',
     },
-  })
+  });
 }
 
-export default { fetch: handleRequest }
+export default { fetch: handleRequest };

src/auth.ts

@@ -1,15 +1,15 @@
-import type { EmulatorEnv } from './emulator'
-import { useEmulator } from './emulator'
-import type { KeyStorer } from './key-store'
-import type { FirebaseIdToken, FirebaseTokenVerifier } from './token-verifier'
-import { createIdTokenVerifier } from './token-verifier'
+import type { EmulatorEnv } from './emulator';
+import { useEmulator } from './emulator';
+import type { KeyStorer } from './key-store';
+import type { FirebaseIdToken, FirebaseTokenVerifier } from './token-verifier';
+import { createIdTokenVerifier } from './token-verifier';
 
 export class BaseAuth {
   /** @internal */
-  protected readonly idTokenVerifier: FirebaseTokenVerifier
+  protected readonly idTokenVerifier: FirebaseTokenVerifier;
 
   constructor(projectId: string, keyStore: KeyStorer) {
-    this.idTokenVerifier = createIdTokenVerifier(projectId, keyStore)
+    this.idTokenVerifier = createIdTokenVerifier(projectId, keyStore);
   }
 
   /**
@@ -25,7 +25,7 @@ export class BaseAuth {
    *   promise.
    */
   public verifyIdToken(idToken: string, env?: EmulatorEnv): Promise<FirebaseIdToken> {
-    const isEmulator = useEmulator(env)
-    return this.idTokenVerifier.verifyJWT(idToken, isEmulator)
+    const isEmulator = useEmulator(env);
+    return this.idTokenVerifier.verifyJWT(idToken, isEmulator);
   }
 }

src/base64.ts

@@ -1,25 +1,25 @@
 export const decodeBase64Url = (str: string): Uint8Array => {
-  return decodeBase64(str.replace(/_|-/g, m => ({ _: '/', '-': '+' })[m] ?? m))
-}
+  return decodeBase64(str.replace(/_|-/g, m => ({ _: '/', '-': '+' })[m] ?? m));
+};
 
 export const encodeBase64Url = (buf: ArrayBufferLike): string =>
-  encodeBase64(buf).replace(/\/|\+/g, m => ({ '/': '_', '+': '-' })[m] ?? m)
+  encodeBase64(buf).replace(/\/|\+/g, m => ({ '/': '_', '+': '-' })[m] ?? m);
 
 // This approach is written in MDN.
 // btoa does not support utf-8 characters. So we need a little bit hack.
 export const encodeBase64 = (buf: ArrayBufferLike): string => {
-  const binary = String.fromCharCode(...new Uint8Array(buf))
-  return btoa(binary)
-}
+  const binary = String.fromCharCode(...new Uint8Array(buf));
+  return btoa(binary);
+};
 
 // atob does not support utf-8 characters. So we need a little bit hack.
 const decodeBase64 = (str: string): Uint8Array => {
-  const binary = atob(str)
-  const bytes = new Uint8Array(new ArrayBuffer(binary.length))
-  const half = binary.length / 2
+  const binary = atob(str);
+  const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+  const half = binary.length / 2;
   for (let i = 0, j = binary.length - 1; i <= half; i++, j--) {
-    bytes[i] = binary.charCodeAt(i)
-    bytes[j] = binary.charCodeAt(j)
+    bytes[i] = binary.charCodeAt(i);
+    bytes[j] = binary.charCodeAt(j);
   }
-  return bytes
-}
+  return bytes;
+};

src/emulator.ts

@@ -3,13 +3,13 @@ export interface EmulatorEnv {
 }
 
 export function emulatorHost(env?: EmulatorEnv): string | undefined {
-  return env?.FIREBASE_AUTH_EMULATOR_HOST
+  return env?.FIREBASE_AUTH_EMULATOR_HOST;
 }
 
 /**
  * When true the SDK should communicate with the Auth Emulator for all API
  * calls and also produce unsigned tokens.
  */
 export const useEmulator = (env?: EmulatorEnv): boolean => {
-  return !!emulatorHost(env)
-}
+  return !!emulatorHost(env);
+};

src/errors.ts

@@ -11,7 +11,7 @@ export class JwtError extends Error {
     readonly message: string
   ) {
     super(message);
-    (this as any).__proto__ = JwtError.prototype
+    (this as any).__proto__ = JwtError.prototype;
   }
 }
 
@@ -32,7 +32,7 @@ export enum JwtErrorCode {
  * App client error codes and their default messages.
  */
 export class AppErrorCodes {
-  public static INVALID_CREDENTIAL = 'invalid-credential'
+  public static INVALID_CREDENTIAL = 'invalid-credential';
 }
 
 /**
@@ -42,31 +42,31 @@ export class AuthClientErrorCode {
   public static INVALID_ARGUMENT = {
     code: 'argument-error',
     message: 'Invalid argument provided.',
-  }
+  };
   public static INVALID_CREDENTIAL = {
     code: 'invalid-credential',
     message: 'Invalid credential object provided.',
-  }
+  };
   public static ID_TOKEN_EXPIRED = {
     code: 'id-token-expired',
     message: 'The provided Firebase ID token is expired.',
-  }
+  };
   public static ID_TOKEN_REVOKED = {
     code: 'id-token-revoked',
     message: 'The Firebase ID token has been revoked.',
-  }
+  };
   public static INTERNAL_ERROR = {
     code: 'internal-error',
     message: 'An internal error has occurred.',
-  }
+  };
   public static USER_NOT_FOUND = {
     code: 'user-not-found',
     message: 'There is no user record corresponding to the provided identifier.',
-  }
+  };
   public static USER_DISABLED = {
     code: 'user-disabled',
     message: 'The user record is disabled.',
-  }
+  };
 }
 
 /**
@@ -124,25 +124,25 @@ export class FirebaseError extends Error implements FirebaseErrorInterface {
     // Set the prototype explicitly. See the following link for more details:
     // https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
     /* tslint:enable:max-line-length */
-    (this as any).__proto__ = FirebaseError.prototype
+    (this as any).__proto__ = FirebaseError.prototype;
   }
 
   /** @returns The error code. */
   public get code(): string {
-    return this.errorInfo.code
+    return this.errorInfo.code;
   }
 
   /** @returns The error message. */
   public get message(): string {
-    return this.errorInfo.message
+    return this.errorInfo.message;
   }
 
   /** @returns The object representation of the error. */
   public toJSON(): object {
     return {
       code: this.code,
       message: this.message,
-    }
+    };
   }
 }
 
@@ -177,7 +177,7 @@ export class PrefixedFirebaseError extends FirebaseError {
     // Set the prototype explicitly. See the following link for more details:
     // https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
     /* tslint:enable:max-line-length */
-    (this as any).__proto__ = PrefixedFirebaseError.prototype
+    (this as any).__proto__ = PrefixedFirebaseError.prototype;
   }
 
   /**
@@ -188,7 +188,7 @@ export class PrefixedFirebaseError extends FirebaseError {
    * @returns True if the code matches, false otherwise.
    */
   public hasCode(code: string): boolean {
-    return `${this.codePrefix}/${code}` === this.code
+    return `${this.codePrefix}/${code}` === this.code;
   }
 }
 
@@ -209,6 +209,6 @@ export class FirebaseAuthError extends PrefixedFirebaseError {
     // Set the prototype explicitly. See the following link for more details:
     // https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
     /* tslint:enable:max-line-length */
-    (this as any).__proto__ = FirebaseAuthError.prototype
+    (this as any).__proto__ = FirebaseAuthError.prototype;
   }
 }

src/index.ts

@@ -1,38 +1,38 @@
-import { BaseAuth } from './auth'
-import type { KeyStorer } from './key-store'
-import { WorkersKVStore } from './key-store'
+import { BaseAuth } from './auth';
+import type { KeyStorer } from './key-store';
+import { WorkersKVStore } from './key-store';
 
-export { emulatorHost, useEmulator } from './emulator'
-export type { KeyStorer }
-export type { EmulatorEnv } from './emulator'
-export type { FirebaseIdToken } from './token-verifier'
+export { emulatorHost, useEmulator } from './emulator';
+export type { KeyStorer };
+export type { EmulatorEnv } from './emulator';
+export type { FirebaseIdToken } from './token-verifier';
 
 export class Auth extends BaseAuth {
-  private static instance?: Auth
+  private static instance?: Auth;
 
   private constructor(projectId: string, keyStore: KeyStorer) {
-    super(projectId, keyStore)
+    super(projectId, keyStore);
   }
 
   static getOrInitialize(projectId: string, keyStore: KeyStorer): Auth {
     if (!Auth.instance) {
-      Auth.instance = new Auth(projectId, keyStore)
+      Auth.instance = new Auth(projectId, keyStore);
     }
-    return Auth.instance
+    return Auth.instance;
   }
 }
 
 export class WorkersKVStoreSingle extends WorkersKVStore {
-  private static instance?: WorkersKVStoreSingle
+  private static instance?: WorkersKVStoreSingle;
 
   private constructor(cacheKey: string, cfKVNamespace: KVNamespace) {
-    super(cacheKey, cfKVNamespace)
+    super(cacheKey, cfKVNamespace);
   }
 
   static getOrInitialize(cacheKey: string, cfKVNamespace: KVNamespace): WorkersKVStoreSingle {
     if (!WorkersKVStoreSingle.instance) {
-      WorkersKVStoreSingle.instance = new WorkersKVStoreSingle(cacheKey, cfKVNamespace)
+      WorkersKVStoreSingle.instance = new WorkersKVStoreSingle(cacheKey, cfKVNamespace);
     }
-    return WorkersKVStoreSingle.instance
+    return WorkersKVStoreSingle.instance;
   }
 }