react-native-update 10.47.0 → 10.48.1

package/src/client.ts

@@ -9,6 +9,7 @@ import {
   cInfo,
   currentVersion,
   currentVersionInfo,
+  supportedDiffVersion,
   isFirstTime,
   isRolledBack,
   packageVersion,
@@ -39,7 +40,12 @@ import {
   testUrls,
 } from './utils';
 import i18n from './i18n';
-import { toUpdateError, UpdateError, UpdateErrorCode } from './error';
+import {
+  asUpdateErrorCode,
+  toUpdateError,
+  UpdateError,
+  UpdateErrorCode,
+} from './error';
 import { dedupeEndpoints, executeEndpointFallback } from './endpoint';
 import {
   resolveServerEventHash,
@@ -103,6 +109,10 @@ const defaultClientOptions: ClientOptions = {
 export const sharedState: {
   progressHandlers: Record<string, EmitterSubscription>;
   downloadingTasks: Record<string, Promise<string | undefined>>;
+  // Progress callbacks per hash: concurrent downloadUpdate callers of the
+  // same hash each register theirs here instead of the second one being
+  // silently dropped by the in-flight dedup.
+  progressCallbacks: Record<string, Set<(data: ProgressData) => void>>;
   downloadedHash?: string;
   toHash?: string;
   apkStatus: 'downloading' | 'downloaded' | null;
@@ -111,6 +121,7 @@ export const sharedState: {
 } = {
   progressHandlers: {},
   downloadingTasks: {},
+  progressCallbacks: {},
   downloadedHash: undefined,
   apkStatus: null,
   marked: false,
@@ -324,6 +335,7 @@ export class Pushy {
     }
   };
   private errorListeners = new Set<UpdateErrorListener>();
+  private emittedErrors = new WeakSet<Error>();
   /**
    * Subscribe to every error the client reports (regardless of throwError).
    * Returns an unsubscribe function.
@@ -334,6 +346,15 @@ export class Pushy {
       this.errorListeners.delete(listener);
     };
   };
+  /**
+   * Whether this exact error object already went through emitError (and was
+   * therefore delivered to onError subscribers). Lets UI layers decide if a
+   * caught error still needs surfacing — checking `e.code` is not enough,
+   * since axios/system errors carry their own code without ever entering the
+   * pipeline.
+   */
+  wasEmitted = (e: unknown): boolean =>
+    e instanceof Error && this.emittedErrors.has(e);
   /**
    * Single exit point for errors: reports to the logger (with the stable
    * code) and notifies onError listeners. Whether to also throw stays with
@@ -347,7 +368,15 @@ export class Pushy {
       data,
     }: { message?: string; data?: Record<string, string | number> } = {},
   ) => {
-    this.report({ type, message, code: error.code, data });
+    this.emittedErrors.add(error);
+    this.report({
+      type,
+      message,
+      code: error.code,
+      // Structured context from the error (e.g. HTTP status) reaches the
+      // logger; explicit data wins on key conflicts.
+      data: error.extra ? { ...error.extra, ...data } : data,
+    });
     for (const listener of this.errorListeners) {
       try {
         listener(error, type);
@@ -501,7 +530,10 @@ export class Pushy {
         }
       } catch (e) {
         sharedState.applyingUpdate = false;
-        const err = toUpdateError(e, 'SWITCH_VERSION_FAILED');
+        // A throw from the user's beforeReload hook is business-code failure,
+        // not an update-pipeline one: give it a distinct code so telemetry
+        // excludes it from the server-side patch-health stats.
+        const err = toUpdateError(e, 'USER_HOOK_ERROR');
         this.emitError(err, 'errorSwitchVersion', {
           data: { newVersion: hash },
         });
@@ -562,9 +594,20 @@ export class Pushy {
       this.lastChecking &&
       now - this.lastChecking < 1000 * 5
     ) {
-      const result = await this.lastRespJson;
-      this.notifyAfterCheckUpdate({ status: 'completed', result });
-      return result;
+      try {
+        const result = await this.lastRespJson;
+        this.notifyAfterCheckUpdate({ status: 'completed', result });
+        return result;
+      } catch (e: any) {
+        // The shared in-flight check failed. Its initiating call reports it
+        // through emitError/throw; this call must still honor its own
+        // contract — afterCheckUpdate always fires and throwError applies —
+        // without double-reporting the same error.
+        const err = toUpdateError(e, 'CHECK_FAILED');
+        this.notifyAfterCheckUpdate({ status: 'error', error: err });
+        this.throwIfEnabled(err);
+        return undefined;
+      }
     }
     this.lastChecking = now;
     const fetchBody: Record<string, any> = {
@@ -572,6 +615,8 @@ export class Pushy {
       hash: currentVersion,
       buildTime,
       cInfo,
+      // 可消费的 diff 轨道版本(2 = hdiffv2 轨道),服务端据此门控下发
+      ...(supportedDiffVersion ? { diffV: supportedDiffVersion } : {}),
       ...extra,
     };
     if (__DEV__) {
@@ -652,6 +697,10 @@ export class Pushy {
     const existingTask = sharedState.downloadingTasks[hash];
     if (existingTask) {
       log(`download for hash ${hash} already in progress, reusing it`);
+      // The second caller's progress callback must still fire.
+      if (onDownloadProgress) {
+        sharedState.progressCallbacks[hash]?.add(onDownloadProgress);
+      }
       return existingTask;
     }
     const task = this.performDownload(updateInfo, onDownloadProgress);
@@ -679,38 +728,42 @@ export class Pushy {
     if (!hash) {
       return;
     }
-    if (sharedState.progressHandlers[hash]) {
-      return;
-    }
     const patchStartTime = Date.now();
+    // One native listener per hash dispatching to a callback set, so
+    // concurrent callers deduped onto this task can each observe progress
+    // (they register via downloadUpdate).
+    const progressCallbacks = new Set<(data: ProgressData) => void>();
     if (onDownloadProgress) {
-      const wrapProgress = (data: ProgressData) => {
-        onDownloadProgress({
-          ...data,
-          progress: computeProgress(data.received, data.total),
-        });
+      progressCallbacks.add(onDownloadProgress);
+    }
+    sharedState.progressCallbacks[hash] = progressCallbacks;
+    const dispatchProgress = (data: ProgressData) => {
+      const callbacks = sharedState.progressCallbacks[hash];
+      if (!callbacks || callbacks.size === 0) {
+        return;
+      }
+      const payload = {
+        ...data,
+        progress: computeProgress(data.received, data.total),
       };
-      // @ts-expect-error harmony not in existing platforms
-      if (Platform.OS === 'harmony') {
-        sharedState.progressHandlers[hash] = DeviceEventEmitter.addListener(
-          'RCTPushyDownloadProgress',
-          (progressData: ProgressData) => {
-            if (progressData.hash === hash) {
-              wrapProgress(progressData);
-            }
-          },
-        );
-      } else {
-        sharedState.progressHandlers[hash] =
-          pushyNativeEventEmitter.addListener(
-            'RCTPushyDownloadProgress',
-            (progressData: ProgressData) => {
-              if (progressData.hash === hash) {
-                wrapProgress(progressData);
-              }
-            },
-          );
+      callbacks.forEach(callback => callback(payload));
+    };
+    const onNativeProgress = (progressData: ProgressData) => {
+      if (progressData.hash === hash) {
+        dispatchProgress(progressData);
       }
+    };
+    // @ts-expect-error harmony not in existing platforms
+    if (Platform.OS === 'harmony') {
+      sharedState.progressHandlers[hash] = DeviceEventEmitter.addListener(
+        'RCTPushyDownloadProgress',
+        onNativeProgress,
+      );
+    } else {
+      sharedState.progressHandlers[hash] = pushyNativeEventEmitter.addListener(
+        'RCTPushyDownloadProgress',
+        onNativeProgress,
+      );
     }
     const maxRetries = Math.max(0, Math.floor(this.options.maxRetries ?? 3));
     let succeeded = '';
@@ -801,7 +854,14 @@ export class Pushy {
               message: e.message,
             });
             errorMessages.push(errorMessage);
-            lastError = Error(errorMessage);
+            // Keep the i18n message for display, but preserve the native
+            // rejection's stable code (e.g. PATCH_FAILED vs DOWNLOAD_FAILED —
+            // telemetry classifies on it) and the original error as cause.
+            lastError = new UpdateError(
+              errorMessage,
+              asUpdateErrorCode(e?.code) ?? 'DOWNLOAD_FAILED',
+              { cause: e },
+            );
             log(errorMessage);
           }
         } else if (!url && strategy.devNoopWhenNoUrl && __DEV__) {
@@ -817,6 +877,7 @@ export class Pushy {
       sharedState.progressHandlers[hash].remove();
       delete sharedState.progressHandlers[hash];
     }
+    delete sharedState.progressCallbacks[hash];
     if (!succeeded) {
       const message = errorMessages.join(';');
       if (lastError) {
@@ -943,10 +1004,78 @@ export class Pushy {
     }
   };
   restartApp = async () => {
-    if (!(await this.runBeforeReload({ type: 'restartApp' }))) {
-      return;
+    try {
+      if (!(await this.runBeforeReload({ type: 'restartApp' }))) {
+        return;
+      }
+    } catch (e) {
+      const err = toUpdateError(e, 'USER_HOOK_ERROR');
+      this.emitError(err, 'errorRestart');
+      throw err;
+    }
+    try {
+      return await PushyModule.restartApp();
+    } catch (e) {
+      const err = toUpdateError(e, 'RESTART_FAILED');
+      this.emitError(err, 'errorRestart');
+      throw err;
+    }
+  };
+  /**
+   * Reset to the bundle packaged in the binary: wipes every downloaded update
+   * and the whole update state on the native side, so the app loads the
+   * built-in bundle on the next launch (or immediately with
+   * `{ restart: true }`). The client uuid is preserved.
+   *
+   * Returns whether the reset actually happened. Like the other update-flow
+   * APIs it never throws by default — failures land in lastError/onError with
+   * code RESET_FAILED — but the boolean must not be ignored: a false means the
+   * app is still running the hot-updated bundle. Set `throwError` to throw.
+   */
+  resetToPackagedBundle = async (options?: {
+    restart?: boolean;
+  }): Promise<boolean> => {
+    if (!assertWeb()) {
+      // On web PushyModule is a Proxy of noops, so the feature-detect below
+      // would report a false success.
+      return false;
     }
-    return PushyModule.restartApp();
+    if (typeof PushyModule.resetToPackagedBundle !== 'function') {
+      // The JS layer can arrive via hot update onto an older binary whose
+      // native module predates this method.
+      const err = new UpdateError(
+        this.t('error_reset_not_supported'),
+        'RESET_FAILED',
+      );
+      this.emitError(err, 'errorReset');
+      this.throwIfEnabled(err);
+      return false;
+    }
+    try {
+      await PushyModule.resetToPackagedBundle();
+    } catch (e) {
+      const err = toUpdateError(e, 'RESET_FAILED');
+      this.emitError(err, 'errorReset');
+      this.throwIfEnabled(err);
+      return false;
+    }
+    // The downloaded versions are gone; drop JS bookkeeping referring to them
+    // so a stale downloadedHash cannot be switched to.
+    sharedState.downloadedHash = undefined;
+    sharedState.toHash = undefined;
+    sharedState.marked = false;
+    this.report({ type: 'reset' });
+    if (options?.restart) {
+      try {
+        await this.restartApp();
+      } catch (e: any) {
+        // The reset itself succeeded and the restart failure was already
+        // reported through the pipeline; the boolean must still say "state
+        // is reset".
+        log('restart after reset failed:', e?.message || e);
+      }
+    }
+    return true;
   };
 }
 

package/src/context.ts

@@ -15,6 +15,7 @@ export const defaultContext = {
   downloadUpdate: asyncNoop,
   downloadAndInstallApk: asyncNoop,
   restartApp: asyncNoop,
+  resetToPackagedBundle: asyncNoop,
   getCurrentVersionInfo: () => Promise.resolve({}),
   parseTestQrCode: () => false,
   currentHash: '',
@@ -43,6 +44,9 @@ export const UpdateContext = createContext<{
   } | null;
   parseTestQrCode: (code: string) => boolean;
   restartApp: () => Promise<void>;
+  resetToPackagedBundle: (options?: {
+    restart?: boolean;
+  }) => Promise<boolean | void>;
   currentHash: string;
   packageVersion: string;
   client?: Pushy | Cresc;

package/src/core.ts

@@ -65,6 +65,10 @@ export const rolledBackVersion: string = PushyConstants.rolledBackVersion;
 export const isRolledBack: boolean = !!rolledBackVersion;
 
 export const buildTime: string = PushyConstants.buildTime;
+// 原生 patch 内核可消费的 diff 轨道版本(2 = hdiffv2 轨道:HBC 变换 +
+// 流式容器);旧原生无此常量时为 0(不上报,服务端只发 baseline)
+export const supportedDiffVersion: number =
+	PushyConstants.supportedDiffVersion || 0;
 let uuid = PushyConstants.uuid;
 
 async function getLocalHashInfo(hash: string) {

package/src/error.ts

@@ -21,14 +21,53 @@ export type UpdateErrorCode =
   | 'STORAGE_PERMISSION_REJECTED'
   | 'STORAGE_PERMISSION_ERROR'
   | 'APK_DOWNLOAD_FAILED'
+  // A throw from a user-provided hook (e.g. beforeReload) — not an update
+  // pipeline failure, and excluded from server-side patch-health telemetry.
+  | 'USER_HOOK_ERROR'
   // Native codes (see cpp/patch_core/error_codes.h)
   | 'INVALID_OPTIONS'
   | 'PATCH_FAILED'
   | 'FILE_OPERATION_FAILED'
   | 'RESTART_FAILED'
+  | 'RESET_FAILED'
   | 'INVALID_HASH_INFO'
   | 'UNSUPPORTED_PLATFORM';
 
+const KNOWN_CODES = new Set<string>([
+  'MODULE_NOT_LOADED',
+  'APPKEY_REQUIRED',
+  'NO_ENDPOINTS',
+  'HTTP_STATUS',
+  'CHECK_FAILED',
+  'DOWNLOAD_FAILED',
+  'SWITCH_VERSION_FAILED',
+  'MARK_SUCCESS_FAILED',
+  'APK_INSTALL_PENDING',
+  'STORAGE_PERMISSION_REJECTED',
+  'STORAGE_PERMISSION_ERROR',
+  'APK_DOWNLOAD_FAILED',
+  'USER_HOOK_ERROR',
+  'INVALID_OPTIONS',
+  'PATCH_FAILED',
+  'FILE_OPERATION_FAILED',
+  'RESTART_FAILED',
+  'RESET_FAILED',
+  'INVALID_HASH_INFO',
+  'UNSUPPORTED_PLATFORM',
+]);
+
+/**
+ * Narrow an arbitrary `code` property (axios' ERR_NETWORK, Node's
+ * ECONNREFUSED, RN's default EUNSPECIFIED, ...) to our stable set; anything
+ * else is treated as absent so it never leaks into telemetry aggregation.
+ */
+export const asUpdateErrorCode = (
+  code: unknown,
+): UpdateErrorCode | undefined =>
+  typeof code === 'string' && KNOWN_CODES.has(code)
+    ? (code as UpdateErrorCode)
+    : undefined;
+
 export class UpdateError extends Error {
   code: UpdateErrorCode;
   cause?: unknown;
@@ -49,9 +88,11 @@ export class UpdateError extends Error {
 
 /**
  * Attach a code to an unknown thrown value. An existing Error keeps its
- * identity (message, stack, and any code already assigned upstream) so callers
- * comparing the caught error to the original still match; non-Error values are
- * wrapped.
+ * identity (message, stack, and any known code already assigned upstream) so
+ * callers comparing the caught error to the original still match; non-Error
+ * values are wrapped. A foreign `code` (axios/system errors) is overwritten
+ * with ours; a frozen/sealed Error that rejects the assignment is wrapped
+ * instead (identity is lost only in that edge case).
  */
 export const toUpdateError = (
   e: unknown,
@@ -59,8 +100,13 @@ export const toUpdateError = (
 ): UpdateError => {
   if (e instanceof Error) {
     const err = e as UpdateError;
-    if (!err.code) {
-      err.code = code;
+    if (!asUpdateErrorCode(err.code)) {
+      try {
+        err.code = code;
+      } catch {}
+      if (err.code !== code) {
+        return new UpdateError(err.message, code, { cause: err });
+      }
     }
     return err;
   }

package/src/locales/en.ts

@@ -61,6 +61,8 @@ export default {
   error_storage_permission_rejected:
     'Storage permission denied, unable to download the APK',
   error_apk_download_failed: 'Failed to download or install the APK',
+  error_reset_not_supported:
+    'resetToPackagedBundle is not available in the installed native module. Please rebuild the app with the latest react-native-update.',
 
   // Development messages
   dev_debug_disabled:

package/src/locales/zh.ts

@@ -56,6 +56,8 @@ export default {
   error_apk_pending_install: '安装包已下载完成，请在系统安装界面完成安装',
   error_storage_permission_rejected: '存储权限被拒绝，无法下载安装包',
   error_apk_download_failed: '安装包下载或安装失败',
+  error_reset_not_supported:
+    '当前安装的原生模块不支持 resetToPackagedBundle，请使用最新版 react-native-update 重新打包后再试。',
 
   // Development messages
   dev_debug_disabled:

package/src/provider.tsx

@@ -152,10 +152,12 @@ export const UpdateProvider = ({
         ]);
         return true;
       } catch (e: any) {
-        // Client pipeline errors carry a code and were already surfaced via
-        // the onError subscription; errors thrown by user hooks
-        // (afterDownloadUpdate) bypass the pipeline and are surfaced here.
-        if (!e?.code) {
+        // Client pipeline errors were already surfaced via the onError
+        // subscription; errors thrown by user hooks (afterDownloadUpdate)
+        // bypass the pipeline and are surfaced here. Asking the client
+        // instead of checking `e.code` matters: axios/system errors carry
+        // their own code without ever entering the pipeline.
+        if (!client.wasEmitted(e)) {
           setLastError(e);
           alertError(client.t('update_failed'), e.message);
         }
@@ -186,10 +188,10 @@ export const UpdateProvider = ({
       try {
         rootInfo = await client.checkUpdate(extra);
       } catch (e: any) {
-        // Client pipeline errors carry a code and were already surfaced via
-        // the onError subscription; errors thrown by user hooks
-        // (beforeCheckUpdate) bypass the pipeline and are surfaced here.
-        if (!e?.code) {
+        // Client pipeline errors were already surfaced via the onError
+        // subscription; errors thrown by user hooks (beforeCheckUpdate)
+        // bypass the pipeline and are surfaced here (see wasEmitted).
+        if (!client.wasEmitted(e)) {
           setLastError(e);
           alertError(client.t('error_update_check_failed'), e.message);
         }
@@ -388,6 +390,13 @@ export const UpdateProvider = ({
     return client.restartApp();
   }, [client]);
 
+  const resetToPackagedBundle = useCallback(
+    async (resetOptions?: { restart?: boolean }) => {
+      return client.resetToPackagedBundle(resetOptions);
+    },
+    [client],
+  );
+
   useEffect(() => {
     if (!assertWeb()) {
       return;
@@ -396,15 +405,21 @@ export const UpdateProvider = ({
       if (!url) {
         return;
       }
-      const params = new URL(url).searchParams;
-      const payload = {
-        type: params.get('type'),
-        data: params.get('data'),
-      };
-      parseTestPayload(payload);
+      try {
+        const params = new URL(url).searchParams;
+        const payload = {
+          type: params.get('type'),
+          data: params.get('data'),
+        };
+        parseTestPayload(payload);
+      } catch (e: any) {
+        // A malformed deep link (new URL throws) must not become an
+        // unhandled rejection / a throw inside the 'url' event handler.
+        log('parseLinking: invalid url', e?.message || e);
+      }
     };
 
-    Linking.getInitialURL().then(parseLinking);
+    Linking.getInitialURL().then(parseLinking).catch(noop);
     const linkingHandler = ({ url }: { url: string }) => {
       parseLinking(url);
     };
@@ -438,6 +453,7 @@ export const UpdateProvider = ({
       currentVersionInfo,
       parseTestQrCode,
       restartApp,
+      resetToPackagedBundle,
     }),
     [
       checkUpdate,
@@ -452,6 +468,7 @@ export const UpdateProvider = ({
       downloadAndInstallApk,
       parseTestQrCode,
       restartApp,
+      resetToPackagedBundle,
     ],
   );
 

package/src/telemetry.ts

@@ -43,7 +43,12 @@ export const resolveServerEventType = (
     case 'errorUpdate':
       return code === 'PATCH_FAILED' ? 'patch_fail' : 'download_fail';
     case 'errorSwitchVersion':
-      return 'patch_fail';
+      // Activation failures are patch-health signals, but a throw from a
+      // user hook (beforeReload) or a restart-mechanics failure is not —
+      // those must not poison the stats driving the rollback safety net.
+      return code === 'USER_HOOK_ERROR' || code === 'RESTART_FAILED'
+        ? undefined
+        : 'patch_fail';
     case 'markSuccess':
       return 'mark_success';
     case 'rollback':

package/src/type.ts

@@ -55,6 +55,9 @@ export type EventType =
   | 'errorUpdate'
   | 'markSuccess'
   | 'errorMarkSuccess'
+  | 'reset'
+  | 'errorReset'
+  | 'errorRestart'
   | 'errorSwitchVersion'
   | 'downloadingApk'
   | 'rejectStoragePermission'