fix(hook): handle initConnection errors with onError callback

- Wrap initConnection in try/catch to prevent unhandled exceptions
- Call invokeOnError when initConnection fails
- Clean up listeners on error
- Add tests for initConnection error handling

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: hyochan

src/__tests__/hooks/useIAP.test.ts

@@ -285,5 +285,68 @@ describe('hooks/useIAP (renderer)', () => {
       expect(onError).toHaveBeenCalledWith(expect.any(Error));
       expect(onError.mock.calls[0][0].message).toBe(stringError);
     });
+
+    it('calls onError when initConnection fails', async () => {
+      const initError = new Error('Failed to initialize connection');
+      jest.spyOn(IAP, 'initConnection').mockRejectedValueOnce(initError);
+
+      const onError = jest.fn();
+      const Harness = () => {
+        useIAP({onError});
+        return null;
+      };
+
+      await act(async () => {
+        TestRenderer.create(React.createElement(Harness));
+      });
+
+      // Wait for initConnection to be called and fail
+      await act(async () => {});
+
+      expect(onError).toHaveBeenCalledWith(initError);
+    });
+
+    it('does not throw unhandled exception when initConnection fails with onError', async () => {
+      const initError = new Error('Store unavailable');
+      jest.spyOn(IAP, 'initConnection').mockRejectedValueOnce(initError);
+
+      const onError = jest.fn();
+      const Harness = () => {
+        useIAP({onError});
+        return null;
+      };
+
+      // This should not throw an unhandled promise rejection
+      await act(async () => {
+        TestRenderer.create(React.createElement(Harness));
+      });
+
+      await act(async () => {});
+
+      // onError should be called, error should be handled gracefully
+      expect(onError).toHaveBeenCalledWith(initError);
+    });
+
+    it('handles initConnection failure without onError callback', async () => {
+      const initError = new Error('Connection failed');
+      const initConnectionSpy = jest
+        .spyOn(IAP, 'initConnection')
+        .mockRejectedValueOnce(initError);
+
+      // No onError callback - should not throw unhandled exception
+      const Harness = () => {
+        useIAP();
+        return null;
+      };
+
+      await act(async () => {
+        TestRenderer.create(React.createElement(Harness));
+      });
+
+      await act(async () => {});
+
+      // Test passes if no unhandled exception is thrown
+      expect(initConnectionSpy).toHaveBeenCalled();
+    });
   });
 });

src/hooks/useIAP.ts

@@ -440,15 +440,28 @@ export function useIAP(options?: UseIapOptions): UseIap {
       }
     }
 
-    const result = await initConnection(config);
-    setConnected(result);
-    if (!result) {
-      // Clean up some listeners but leave purchaseError for potential retries
+    try {
+      const result = await initConnection(config);
+      setConnected(result);
+      if (!result) {
+        // Clean up some listeners but leave purchaseError for potential retries
+        subscriptionsRef.current.purchaseUpdate?.remove();
+        subscriptionsRef.current.purchaseUpdate = undefined;
+      }
+    } catch (error) {
+      RnIapConsole.error('initConnection failed:', error);
+      invokeOnError(error);
+      // Clean up listeners on error
       subscriptionsRef.current.purchaseUpdate?.remove();
+      subscriptionsRef.current.promotedProductIOS?.remove();
       subscriptionsRef.current.purchaseUpdate = undefined;
-      return;
+      subscriptionsRef.current.promotedProductIOS = undefined;
     }
-  }, [getActiveSubscriptionsInternal, getAvailablePurchasesInternal]);
+  }, [
+    getActiveSubscriptionsInternal,
+    getAvailablePurchasesInternal,
+    invokeOnError,
+  ]);
 
   useEffect(() => {
     initIapWithSubscriptions();