fix(types): type-check the shipped source against React Native 0.87

The package's "types" entry is src/index.ts, so consumer projects compile
this source with their own compiler options and skipLibCheck does not
cover it. Against RN 0.87's globals it failed in three places:

- client.ts requestCheckResult merged the caller's AbortSignal into the
  RequestInit. With RN 0.87 plus DOM-style fetch types (@types/bun, which
  loads Node's), the global AbortSignal and RequestInit.signal come from
  different declarations and the spread is rejected (onabort nullable vs
  not). fetchWithTimeout now takes the caller's signal as its own
  argument and chains it as before; params.signal still works.
- setTimeout(resolve) in the logger wait and retry backoff: RN 0.87 types
  the callback as () => void. Wrap the resolve call.
- core.ts used `global`, which RN 0.87's typings no longer declare (only
  @types/node did). Declare it module-locally; no runtime change.

Verified with tsc on RN 0.87.1 and react-native-tvos 0.87.1-1 projects
(template tsconfig; with types ["bun"], ["jest","node"]; with the DOM lib)
and an Expo 58 preview project. With the 10.58.0 source, the plain
template fails on setTimeout and `global`, types ["bun"] fails on the
signal, and the DOM-lib and Expo configs fail on `global`.

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

Author: sunnylqm

src/__tests__/utils.test.ts

@@ -148,6 +148,30 @@ describe('fetchWithTimeout', () => {
     expect(capturedSignal?.aborted).toBe(true);
   });
 
+  test('a caller signal passed separately cancels the request, not as a timeout', async () => {
+    let capturedSignal: AbortSignal | undefined;
+    (globalThis as any).fetch = mock((_url: string, params: any) => {
+      capturedSignal = params?.signal;
+      return new Promise((_, reject) => {
+        params?.signal?.addEventListener('abort', () =>
+          reject(new Error('Aborted'))
+        );
+      });
+    });
+    const caller = new AbortController();
+
+    const pending = fetchWithTimeout(
+      'https://example.com/slow',
+      { method: 'POST' },
+      10_000,
+      caller.signal
+    );
+    caller.abort();
+
+    await expect(pending).rejects.toThrow('Aborted');
+    expect(capturedSignal?.aborted).toBe(true);
+  });
+
   test('resolves normally before the timeout', async () => {
     const response = { ok: true } as Response;
     (globalThis as any).fetch = mock(async () => response);

src/client.ts

@@ -742,8 +742,8 @@ export class Pushy {
       let timer: ReturnType<typeof setTimeout> | undefined;
       await Promise.race([
         this.loggerPromise.promise,
-        new Promise((resolve) => {
-          timer = setTimeout(resolve, 10 * 1000);
+        new Promise<void>((resolve) => {
+          timer = setTimeout(() => resolve(), 10 * 1000);
         }),
       ]);
       clearTimeout(timer);
@@ -977,8 +977,9 @@ export class Pushy {
   ) => {
     const resp = await fetchWithTimeout(
       this.getCheckUrl(endpoint),
-      signal ? { ...fetchPayload, signal } : fetchPayload,
-      DEFAULT_FETCH_TIMEOUT_MS
+      fetchPayload,
+      DEFAULT_FETCH_TIMEOUT_MS,
+      signal
     );
 
     if (!resp.ok) {
@@ -1532,7 +1533,7 @@ export class Pushy {
             (0.75 + Math.random() * 0.5)
         );
         log(`retry attempt ${attempt}/${maxRetries}, waiting ${backoffMs}ms`);
-        await new Promise((r) => setTimeout(r, backoffMs));
+        await new Promise<void>((r) => setTimeout(() => r(), backoffMs));
         errorMessages.length = 0;
         errorMessages.push(...exhaustedStrategies.values());
         lastError = undefined;

src/core.ts

@@ -3,14 +3,20 @@ import { UpdateError } from './error';
 import i18n from './i18n';
 import { emptyModule, error, log } from './utils';
 
+// RN's JS global object. Declared locally because RN 0.87's own typings no
+// longer define `global` (only @types/node did), and this source is
+// type-checked in consumer projects; the module-scoped declaration also
+// shadows @types/node's without conflicting.
+declare const global: any;
+
 /* eslint-disable @react-native/no-deep-imports */
 const {
   version: v,
 } = require('react-native/Libraries/Core/ReactNativeVersion');
 const RNVersion = `${v.major}.${v.minor}.${v.patch}`;
 const isTurboModuleEnabled =
   // https://github.com/facebook/react-native/pull/48362
-  (global as any).__turboModuleProxy || (global as any).RN$Bridgeless;
+  global.__turboModuleProxy || global.RN$Bridgeless;
 
 const isWebPlatform = Platform.OS === 'web';
 

src/utils.ts

@@ -132,7 +132,11 @@ export const computeProgress = (received: number, total: number): number =>
 export const fetchWithTimeout = (
   url: string,
   params: Parameters<typeof fetch>[1],
-  timeoutMs = DEFAULT_FETCH_TIMEOUT_MS
+  timeoutMs = DEFAULT_FETCH_TIMEOUT_MS,
+  // Taken apart from params: merging it into the RequestInit only type-checks
+  // when the global AbortSignal and fetch's RequestInit come from the same
+  // declarations, which RN 0.87 globals mixed with DOM/Node/bun types break.
+  signal?: AbortSignal
 ): Promise<Response> => {
   // AbortController landed in the RN fetch polyfill around 0.60; we support
   // older peers, so fall back to a plain timer race when it is unavailable
@@ -161,7 +165,8 @@ export const fetchWithTimeout = (
   // The timeout controller replaces params.signal on the fetch call, so a
   // caller-provided signal (e.g. the hedged endpoint race cancelling losers)
   // must be chained onto it manually.
-  const externalSignal = (params as any)?.signal as AbortSignal | undefined;
+  const externalSignal =
+    signal ?? ((params as any)?.signal as AbortSignal | undefined);
   const onExternalAbort = () => controller.abort();
   if (externalSignal?.aborted) {
     controller.abort();