react-native-nitro-auth 0.5.6 → 0.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-auth",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "High-performance authentication library for React Native with Google Sign-In, Apple Sign-In, and Microsoft Sign-In support, powered by Nitro Modules (JSI)",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -33,14 +33,16 @@
     "build": "bob build",
     "clean": "rimraf lib nitrogen/generated",
     "codegen": "nitrogen --logLevel=\"debug\"",
+    "format:check": "eslint .",
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",
-"test": "jest",
+    "test": "jest",
     "test:coverage": "jest --coverage",
     "test:cpp": "node scripts/test-cpp.js",
-    "prepublishOnly": "bun run clean && bun run build",
-    "prepack": "node -e \"const fs=require('fs'); fs.copyFileSync('../../README.md','./README.md'); try{fs.copyFileSync('../../LICENSE','./LICENSE')}catch(e){}\"",
-    "postpack": "node -e \"const fs=require('fs'); ['./README.md','./LICENSE'].forEach(f=>fs.existsSync(f)&&fs.unlinkSync(f))\""
+    "prepublishOnly": "bun run clean && bun run codegen && bun run build && bun run typecheck && bun run lint && bun run test && bun run test:cpp",
+    "prepack": "bun ../../scripts/sync-package-docs.ts",
+    "pack:dry-run": "bun pm pack --dry-run",
+    "publish:dry-run": "bun publish --dry-run --access public"
   },
   "keywords": [
     "react-native",
@@ -79,14 +81,14 @@
     "access": "public"
   },
   "devDependencies": {
-    "@expo/config-plugins": "^55.0.6",
+    "@expo/config-plugins": "^55.0.8",
     "@react-native/babel-preset": "^0.83.0",
     "@testing-library/react": "^16.3.2",
     "@types/node": "^22.19.11",
     "jest-environment-jsdom": "^29.7.0",
     "react": "19.2.0",
-    "react-native": "0.83.2",
-    "react-native-nitro-modules": "^0.35.0",
+    "react-native": "0.83.4",
+    "react-native-nitro-modules": "^0.35.4",
     "react-native-web": "^0.21.2",
     "typescript": "^5.9.3"
   },

package/src/Auth.nitro.ts

@@ -8,6 +8,8 @@ export type AuthErrorCode =
   | "popup_blocked"
   | "network_error"
   | "configuration_error"
+  | "not_signed_in"
+  | "operation_in_progress"
   | "unsupported_provider"
   | "invalid_state"
   | "invalid_nonce"
@@ -25,7 +27,7 @@ export interface LoginOptions {
   useOneTap?: boolean;
   /** (iOS only) Use native sign-in sheet */
   useSheet?: boolean;
-  /** Force account picker to show, ignoring any cached session or loginHint */
+  /** Force account picker to show, ignoring any cached session or loginHint. On Android Google, this uses the legacy chooser path. */
   forceAccountPicker?: boolean;
   /** (Android only) Use legacy Google Sign-In flow (e.g. for serverAuthCode) */
   useLegacyGoogleSignIn?: boolean;

package/src/service.ts

@@ -8,28 +8,33 @@ import type {
 } from "./Auth.nitro";
 import { AuthError } from "./utils/auth-error";
 
-const nitroAuth = NitroModules.createHybridObject<Auth>("Auth");
+let nitroAuth: Auth | undefined;
+
+function getNitroAuth(): Auth {
+  nitroAuth ??= NitroModules.createHybridObject<Auth>("Auth");
+  return nitroAuth;
+}
 
 export const AuthService: Auth = {
   get name() {
-    return nitroAuth.name;
+    return getNitroAuth().name;
   },
 
   get currentUser() {
-    return nitroAuth.currentUser;
+    return getNitroAuth().currentUser;
   },
 
   get grantedScopes() {
-    return nitroAuth.grantedScopes;
+    return getNitroAuth().grantedScopes;
   },
 
   get hasPlayServices() {
-    return nitroAuth.hasPlayServices;
+    return getNitroAuth().hasPlayServices;
   },
 
   async login(provider: AuthProvider, options?: LoginOptions) {
     try {
-      await nitroAuth.login(provider, options);
+      await getNitroAuth().login(provider, options);
       return;
     } catch (e) {
       throw AuthError.from(e);
@@ -38,7 +43,7 @@ export const AuthService: Auth = {
 
   async requestScopes(scopes: string[]) {
     try {
-      await nitroAuth.requestScopes(scopes);
+      await getNitroAuth().requestScopes(scopes);
       return;
     } catch (e) {
       throw AuthError.from(e);
@@ -47,7 +52,7 @@ export const AuthService: Auth = {
 
   async revokeScopes(scopes: string[]) {
     try {
-      await nitroAuth.revokeScopes(scopes);
+      await getNitroAuth().revokeScopes(scopes);
       return;
     } catch (e) {
       throw AuthError.from(e);
@@ -56,7 +61,7 @@ export const AuthService: Auth = {
 
   async getAccessToken() {
     try {
-      return await nitroAuth.getAccessToken();
+      return await getNitroAuth().getAccessToken();
     } catch (e) {
       throw AuthError.from(e);
     }
@@ -64,19 +69,19 @@ export const AuthService: Auth = {
 
   async refreshToken() {
     try {
-      return await nitroAuth.refreshToken();
+      return await getNitroAuth().refreshToken();
     } catch (e) {
       throw AuthError.from(e);
     }
   },
 
   logout() {
-    nitroAuth.logout();
+    getNitroAuth().logout();
   },
 
   async silentRestore() {
     try {
-      await nitroAuth.silentRestore();
+      await getNitroAuth().silentRestore();
       return;
     } catch (e) {
       throw AuthError.from(e);
@@ -84,22 +89,22 @@ export const AuthService: Auth = {
   },
 
   onAuthStateChanged(callback: (user: AuthUser | undefined) => void) {
-    return nitroAuth.onAuthStateChanged(callback);
+    return getNitroAuth().onAuthStateChanged(callback);
   },
 
   onTokensRefreshed(callback: (tokens: AuthTokens) => void) {
-    return nitroAuth.onTokensRefreshed(callback);
+    return getNitroAuth().onTokensRefreshed(callback);
   },
 
   setLoggingEnabled(enabled: boolean) {
-    nitroAuth.setLoggingEnabled(enabled);
+    getNitroAuth().setLoggingEnabled(enabled);
   },
 
   dispose() {
-    nitroAuth.dispose();
+    getNitroAuth().dispose();
   },
 
   equals(other: Parameters<Auth["equals"]>[0]): boolean {
-    return nitroAuth.equals(other);
+    return getNitroAuth().equals(other);
   },
 };

package/src/use-auth.ts

@@ -8,6 +8,8 @@ import type {
 import { AuthService } from "./service";
 import { AuthError } from "./utils/auth-error";
 
+const EMPTY_SCOPES: string[] = [];
+
 type AuthState = {
   user: AuthUser | undefined;
   scopes: string[];
@@ -16,13 +18,25 @@ type AuthState = {
 };
 
 const areScopesEqual = (left: string[], right: string[]): boolean => {
+  if (left === right) return true;
   if (left.length !== right.length) return false;
-  const sortedLeft = [...left].sort();
-  const sortedRight = [...right].sort();
-  for (let i = 0; i < sortedLeft.length; i += 1) {
-    if (sortedLeft[i] !== sortedRight[i]) return false;
+
+  let matchesInOrder = true;
+  for (let i = 0; i < left.length; i += 1) {
+    if (left[i] !== right[i]) {
+      matchesInOrder = false;
+      break;
+    }
+  }
+  if (matchesInOrder) return true;
+
+  const remaining = new Set(left);
+  for (const scope of right) {
+    if (!remaining.delete(scope)) {
+      return false;
+    }
   }
-  return true;
+  return remaining.size === 0;
 };
 
 export type UseAuthReturn = AuthState & {
@@ -85,7 +99,22 @@ export function useAuth(): UseAuthReturn {
 
   const logout = useCallback(() => {
     AuthService.logout();
-    setState({ user: undefined, scopes: [], loading: false, error: undefined });
+    setState((prev) => {
+      if (
+        prev.user === undefined &&
+        prev.scopes.length === 0 &&
+        prev.loading === false &&
+        prev.error === undefined
+      ) {
+        return prev;
+      }
+      return {
+        user: undefined,
+        scopes: EMPTY_SCOPES,
+        loading: false,
+        error: undefined,
+      };
+    });
   }, []);
 
   const requestScopes = useCallback(

package/src/utils/auth-error.ts

@@ -6,6 +6,8 @@ const AUTH_ERROR_CODES: ReadonlySet<string> = new Set<AuthErrorCode>([
   "popup_blocked",
   "network_error",
   "configuration_error",
+  "not_signed_in",
+  "operation_in_progress",
   "unsupported_provider",
   "invalid_state",
   "invalid_nonce",
@@ -21,7 +23,16 @@ export function isAuthErrorCode(value: string): value is AuthErrorCode {
 }
 
 export function toAuthErrorCode(raw: string): AuthErrorCode {
-  return isAuthErrorCode(raw) ? raw : "unknown";
+  if (isAuthErrorCode(raw)) {
+    return raw;
+  }
+
+  const prefix = raw.split(":", 1)[0]?.trim();
+  if (prefix && isAuthErrorCode(prefix)) {
+    return prefix;
+  }
+
+  return "unknown";
 }
 
 /**