react-native-update 10.41.0 → 10.42.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update",
-  "version": "10.41.0",
+  "version": "10.42.1",
   "description": "react-native hot update",
   "main": "src/index",
   "scripts": {

package/src/client.ts

@@ -18,6 +18,7 @@ import {
 } from './core';
 import { PermissionsAndroid } from './permissions';
 import {
+  BeforeReloadContext,
   CheckResult,
   ClientOptions,
   EventType,
@@ -218,6 +219,18 @@ export class Pushy {
       log('afterCheckUpdate failed:', error?.message || error);
     });
   };
+  runBeforeReload = async (context: BeforeReloadContext) => {
+    const { beforeReload } = this.options;
+    if (!beforeReload) {
+      return true;
+    }
+    const shouldReload = await beforeReload(context);
+    if (shouldReload === false) {
+      log('beforeReload returned false, skipping reload');
+      return false;
+    }
+    return true;
+  };
   getCheckUrl = (endpoint: string) => {
     return `${endpoint}/checkUpdate/${this.options.appKey}`;
   };
@@ -325,6 +338,15 @@ export class Pushy {
     if (assertHash(hash) && !sharedState.applyingUpdate) {
       log(`switchVersion: ${hash}`);
       sharedState.applyingUpdate = true;
+      try {
+        if (!(await this.runBeforeReload({ type: 'switchVersion', hash }))) {
+          sharedState.applyingUpdate = false;
+          return;
+        }
+      } catch (e) {
+        sharedState.applyingUpdate = false;
+        throw e;
+      }
       return PushyModule.reloadUpdate({ hash });
     }
   };
@@ -452,6 +474,10 @@ export class Pushy {
     if (!updateInfo.update || !hash) {
       return;
     }
+    if (hash === currentVersion) {
+      log(`current hash ${currentVersion}, ignored`);
+      return;
+    }
     if (rolledBackVersion === hash) {
       log(`rolledback hash ${rolledBackVersion}, ignored`);
       return;
@@ -664,6 +690,9 @@ export class Pushy {
     }
   };
   restartApp = async () => {
+    if (!(await this.runBeforeReload({ type: 'restartApp' }))) {
+      return;
+    }
     return PushyModule.restartApp();
   };
 }

package/src/provider.tsx

@@ -23,11 +23,10 @@ import {
   CheckResult,
   ProgressData,
   UpdateTestPayload,
-  VersionInfo,
 } from './type';
 import { UpdateContext } from './context';
 import { URL } from 'react-native-url-polyfill';
-import { isInRollout } from './isInRollout';
+import { resolveCheckResult } from './resolveCheckResult';
 import { assertWeb, log } from './utils';
 
 export const UpdateProvider = ({
@@ -181,94 +180,77 @@ export const UpdateProvider = ({
       if (!rootInfo) {
         return;
       }
-      const versions = [rootInfo.expVersion, rootInfo].filter(
-        Boolean,
-      ) as VersionInfo[];
-      delete rootInfo.expVersion;
-      for (const versionInfo of versions) {
-        const info: CheckResult = {
-          ...rootInfo,
-          ...versionInfo,
-        };
-        const rollout = info.config?.rollout?.[packageVersion];
-        if (info.update && rollout) {
-          if (!isInRollout(rollout)) {
-            log(`${info.name} not in ${rollout}% rollout, ignored`);
-            continue;
-          }
-          log(`${info.name} in ${rollout}% rollout, continue`);
-        }
-        if (info.update) {
-          info.description = info.description ?? '';
+      const info = resolveCheckResult(rootInfo);
+      if (info.update) {
+        info.description = info.description ?? '';
+      }
+      updateInfoRef.current = info;
+      setUpdateInfo(info);
+      if (info.expired) {
+        if (
+          options.onPackageExpired &&
+          (await options.onPackageExpired(info)) === false
+        ) {
+          log('onPackageExpired returned false, skipping');
+          return;
         }
-        updateInfoRef.current = info;
-        setUpdateInfo(info);
-        if (info.expired) {
-          if (
-            options.onPackageExpired &&
-            (await options.onPackageExpired(info)) === false
-          ) {
-            log('onPackageExpired returned false, skipping');
-            return;
-          }
-          const { downloadUrl } = info;
-          if (downloadUrl && sharedState.apkStatus === null) {
-            if (options.updateStrategy === 'silentAndNow') {
-              if (Platform.OS === 'android' && downloadUrl.endsWith('.apk')) {
-                downloadAndInstallApk(downloadUrl);
-              } else {
-                Linking.openURL(downloadUrl);
-              }
-              return info;
+        const { downloadUrl } = info;
+        if (downloadUrl && sharedState.apkStatus === null) {
+          if (options.updateStrategy === 'silentAndNow') {
+            if (Platform.OS === 'android' && downloadUrl.endsWith('.apk')) {
+              downloadAndInstallApk(downloadUrl);
+            } else {
+              Linking.openURL(downloadUrl);
             }
-            alertUpdate(
-              client.t('alert_title'),
-              client.t('alert_app_updated'),
-              [
-                {
-                  text: client.t('alert_update_button'),
-                  onPress: () => {
-                    if (
-                      Platform.OS === 'android' &&
-                      downloadUrl.endsWith('.apk')
-                    ) {
-                      downloadAndInstallApk(downloadUrl);
-                    } else {
-                      Linking.openURL(downloadUrl);
-                    }
-                  },
-                },
-              ],
-            );
-          }
-        } else if (info.update) {
-          if (
-            options.updateStrategy === 'silentAndNow' ||
-            options.updateStrategy === 'silentAndLater'
-          ) {
-            downloadUpdate(info);
             return info;
           }
           alertUpdate(
             client.t('alert_title'),
-            client.t('alert_new_version_found', {
-              name: info.name!,
-              description: info.description!,
-            }),
+            client.t('alert_app_updated'),
             [
-              { text: client.t('alert_cancel'), style: 'cancel' },
               {
-                text: client.t('alert_confirm'),
-                style: 'default',
+                text: client.t('alert_update_button'),
                 onPress: () => {
-                  downloadUpdate();
+                  if (
+                    Platform.OS === 'android' &&
+                    downloadUrl.endsWith('.apk')
+                  ) {
+                    downloadAndInstallApk(downloadUrl);
+                  } else {
+                    Linking.openURL(downloadUrl);
+                  }
                 },
               },
             ],
           );
         }
-        return info;
+      } else if (info.update) {
+        if (
+          options.updateStrategy === 'silentAndNow' ||
+          options.updateStrategy === 'silentAndLater'
+        ) {
+          downloadUpdate(info);
+          return info;
+        }
+        alertUpdate(
+          client.t('alert_title'),
+          client.t('alert_new_version_found', {
+            name: info.name!,
+            description: info.description!,
+          }),
+          [
+            { text: client.t('alert_cancel'), style: 'cancel' },
+            {
+              text: client.t('alert_confirm'),
+              style: 'default',
+              onPress: () => {
+                downloadUpdate();
+              },
+            },
+          ],
+        );
       }
+      return info;
     },
     [
       client,

package/src/resolveCheckResult.ts

@@ -0,0 +1,30 @@
+import { currentVersion, packageVersion } from './core';
+import { isInRollout } from './isInRollout';
+import { CheckResult } from './type';
+import { log } from './utils';
+
+export function resolveCheckResult(rootInfo: CheckResult): CheckResult {
+  const { expVersion, ...rootResult } = rootInfo;
+  const rollout = expVersion?.config?.rollout?.[packageVersion];
+  if (rootResult.update && expVersion && typeof rollout === 'number') {
+    if (isInRollout(rollout)) {
+      log(`${expVersion.name} in ${rollout}% rollout, continue`);
+      if (expVersion.hash === currentVersion) {
+        return { upToDate: true };
+      }
+      const info: CheckResult = {
+        update: true,
+        ...expVersion,
+      };
+      if (rootResult.paths) {
+        info.paths = rootResult.paths;
+      }
+      return info;
+    }
+    log(`${expVersion.name} not in ${rollout}% rollout, ignored`);
+  }
+  if (rootResult.update && rootResult.hash === currentVersion) {
+    return { upToDate: true };
+  }
+  return rootResult;
+}

package/src/type.ts

@@ -88,6 +88,11 @@ export interface UpdateServerConfig {
   queryUrls?: string[];
 }
 
+export interface BeforeReloadContext {
+  type: 'switchVersion' | 'restartApp';
+  hash?: string;
+}
+
 export interface ClientOptions {
   appKey: string;
   server?: UpdateServerConfig;
@@ -109,6 +114,9 @@ export interface ClientOptions {
   afterCheckUpdate?: (state: UpdateCheckState) => Promise<void> | void;
   beforeDownloadUpdate?: (info: CheckResult) => Promise<boolean> | boolean;
   afterDownloadUpdate?: (info: CheckResult) => Promise<boolean> | boolean;
+  beforeReload?: (
+    context: BeforeReloadContext,
+  ) => Promise<boolean | void> | boolean | void;
   onPackageExpired?: (info: CheckResult) => Promise<boolean> | boolean;
   overridePackageVersion?: string;
 }