react-native-update 10.59.1 → 10.60.0

package/src/context.ts

@@ -46,7 +46,7 @@ export interface UpdateContextValue {
   lastError?: Error;
 }
 
-export const defaultContext: UpdateContextValue = {
+const defaultContext: UpdateContextValue = {
   checkUpdate: asyncNoop,
   switchVersion: asyncNoop,
   switchVersionLater: asyncNoop,

package/src/core.ts

@@ -1,7 +1,7 @@
 import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
 import { UpdateError } from './error';
 import i18n from './i18n';
-import { emptyModule, error, log } from './utils';
+import { createNonSecureId, 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
@@ -35,6 +35,34 @@ if (!PushyModule) {
   );
 }
 
+/**
+ * `module[name]` as an always-async function (a synchronous bridge throw
+ * becomes a rejection), or undefined when the module lacks it: the JS layer
+ * can arrive via hot update onto an older binary whose native module predates
+ * the method. Always undefined on web, where the module is a noop Proxy that
+ * would pass any typeof check.
+ */
+export const bindNativeMethod = (
+  module: Record<string, any>,
+  name: string
+): ((...args: any[]) => Promise<any>) | undefined => {
+  const method = module === emptyModule ? undefined : module[name];
+  if (typeof method !== 'function') {
+    return undefined;
+  }
+  return (...args) => {
+    try {
+      return Promise.resolve(method.apply(module, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+};
+
+/** An optional PushyModule method, see bindNativeMethod. */
+export const nativeMethod = (name: string) =>
+  bindNativeMethod(PushyModule, name);
+
 // On web PushyModule is a Proxy whose every property is a noop function, so
 // reading the constants off it would make each of them a function:
 // `isRolledBack` true (a fake rollback report on every page load), a uuid of
@@ -99,7 +127,6 @@ export const currentBundleSha256: string =
     : '';
 
 export const isFirstTime: boolean = PushyConstants.isFirstTime;
-export const isFirstTimeDebug: boolean = isFirstTime && isDebugChannel;
 export const rolledBackVersion: string = PushyConstants.rolledBackVersion;
 export const isRolledBack: boolean = !!rolledBackVersion;
 
@@ -121,9 +148,10 @@ let uuid = PushyConstants.uuid;
 // between its dedup window and the fetch, and a hash is never worth delaying
 // a check for.
 let bundleHash = '';
-// The JS layer can arrive via hot update onto an older binary whose native
-// module predates the method, hence the feature detect (on web the noop Proxy
-// would pass it, so web is excluded explicitly).
+// Feature-detected like nativeMethod (older natives lack it, web has no native
+// module), but called directly rather than through it: a synchronous throw
+// means a broken native integration and must propagate at module load, not be
+// turned into a logged rejection. Only an async failure is tolerated.
 if (!isWebPlatform && typeof PushyModule.getBundleHash === 'function') {
   Promise.resolve(PushyModule.getBundleHash())
     .then((hash: unknown) => {
@@ -156,7 +184,7 @@ export async function getCurrentVersionInfo(): Promise<{
 export const pushyNativeEventEmitter = new NativeEventEmitter(PushyModule);
 
 if (!uuid) {
-  uuid = require('nanoid/non-secure').nanoid();
+  uuid = createNonSecureId();
   // If persisting fails the uuid drifts on every launch, which skews gray
   // release bucketing and inflates stats — log it instead of failing silently.
   // Web has nowhere to persist it (nothing runs there anyway).
@@ -171,7 +199,7 @@ export const cInfo = {
   rnu: require('../package.json').version,
   rn: RNVersion,
   // tvOS reports Platform.OS 'ios'; label it apart so the server can bucket
-  // tvOS devices separately. Must match PushyOsName in RCTPushy.mm.
+  // tvOS devices separately. Must match PushyOsName in RCTPushyOrchestrator.mm.
   os: `${Platform.OS === 'ios' && Platform.isTV ? 'tvos' : Platform.OS} ${Platform.Version}`,
   uuid,
 };
@@ -181,7 +209,6 @@ log('bootup status', {
   currentVersion,
   currentVersionInfo,
   isFirstTime,
-  isFirstTimeDebug,
   isDebugChannel,
   cInfo,
 });

package/src/endpoint.ts

@@ -2,8 +2,6 @@ import { UpdateError } from './error';
 import i18n from './i18n';
 import { dedupeEndpoints, orderEndpointCandidates } from './updateFlowCore';
 
-export { dedupeEndpoints };
-
 export interface EndpointAttemptSuccess<T> {
   endpoint: string;
   value: T;

package/src/error.ts

@@ -7,42 +7,13 @@
  * Android/iOS/Harmony modules — and flow through promise rejections onto the
  * `code` property, which toUpdateError() preserves.
  */
-export type UpdateErrorCode =
+const UPDATE_ERROR_CODES = [
   // JS-layer codes
-  | 'MODULE_NOT_LOADED'
-  | 'APPKEY_REQUIRED'
-  | 'NO_ENDPOINTS'
-  | 'HTTP_STATUS'
-  // A 2xx check response that is not a check verdict (schema gate).
-  | 'INVALID_RESPONSE'
-  | 'CHECK_FAILED'
-  | 'DOWNLOAD_FAILED'
-  | 'SWITCH_VERSION_FAILED'
-  | 'MARK_SUCCESS_FAILED'
-  | 'APK_INSTALL_PENDING'
-  | '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'
-  // A second client/provider in the same process — a hard integration error;
-  // the SDK is a process-level singleton.
-  | 'SINGLETON_VIOLATION'
-  // 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'
-  | 'APK_INSTALL_PERMISSION_REQUIRED'
-  | 'APK_INSTALL_FAILED';
-
-const KNOWN_CODES = new Set<string>([
   'MODULE_NOT_LOADED',
   'APPKEY_REQUIRED',
   'NO_ENDPOINTS',
   'HTTP_STATUS',
+  // A 2xx check response that is not a check verdict (schema gate).
   'INVALID_RESPONSE',
   'CHECK_FAILED',
   'DOWNLOAD_FAILED',
@@ -50,8 +21,13 @@ const KNOWN_CODES = new Set<string>([
   'MARK_SUCCESS_FAILED',
   'APK_INSTALL_PENDING',
   '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',
+  // A second client/provider in the same process — a hard integration error;
+  // the SDK is a process-level singleton.
   'SINGLETON_VIOLATION',
+  // Native codes (see cpp/patch_core/error_codes.h)
   'INVALID_OPTIONS',
   'PATCH_FAILED',
   'FILE_OPERATION_FAILED',
@@ -61,7 +37,12 @@ const KNOWN_CODES = new Set<string>([
   'UNSUPPORTED_PLATFORM',
   'APK_INSTALL_PERMISSION_REQUIRED',
   'APK_INSTALL_FAILED',
-]);
+] as const;
+
+/** A stable error code (see UPDATE_ERROR_CODES). */
+export type UpdateErrorCode = (typeof UPDATE_ERROR_CODES)[number];
+
+const KNOWN_CODES = new Set<string>(UPDATE_ERROR_CODES);
 
 /**
  * Narrow an arbitrary `code` property (axios' ERR_NETWORK, Node's

package/src/i18n.ts

@@ -1,108 +1,43 @@
 import enTranslations from './locales/en';
 import zhTranslations from './locales/zh';
 
+type Locale = 'zh' | 'en';
 type TranslationKey = keyof typeof zhTranslations | keyof typeof enTranslations;
 type TranslationValues = Record<string, string | number>;
 
+const translations: Record<Locale, Record<string, string>> = {
+  zh: zhTranslations,
+  en: enTranslations,
+};
+
 class I18n {
-  private currentLocale: 'zh' | 'en' = 'en';
-  private translations = {
-    zh: zhTranslations,
-    en: enTranslations,
-  };
+  private currentLocale: Locale = 'en';
 
-  /**
-   * Set locale directly
-   * @param locale - 'zh' or 'en'
-   */
-  setLocale(locale: 'zh' | 'en') {
+  setLocale(locale: Locale) {
     this.currentLocale = locale;
   }
 
   /**
-   * Get current locale
-   */
-  getLocale(): 'zh' | 'en' {
-    return this.currentLocale;
-  }
-
-  /**
-   * Translate a key with optional interpolation
-   * @param key - Translation key
-   * @param values - Values for interpolation (optional)
-   * @returns Translated string with interpolated values
+   * Translate a key, filling `{{name}}` placeholders from `values` (unknown
+   * placeholders are kept). A key missing from the current locale falls back
+   * to the other one, then to the key itself.
    */
   t(key: TranslationKey, values?: TranslationValues): string {
-    const translation =
-      this.translations[this.currentLocale][
-        key as keyof (typeof this.translations)[typeof this.currentLocale]
-      ];
-
-    if (!translation) {
-      // Fallback to the other locale if key not found
-      const fallbackLocale = this.currentLocale === 'zh' ? 'en' : 'zh';
-      const fallbackTranslation =
-        this.translations[fallbackLocale][
-          key as keyof (typeof this.translations)[typeof fallbackLocale]
-        ];
-
-      if (!fallbackTranslation) {
-        // If still not found, return the key itself
-        return String(key);
-      }
-
-      return this.interpolate(fallbackTranslation, values);
-    }
-
-    return this.interpolate(translation, values);
-  }
-
-  /**
-   * Interpolate values into a string template
-   * Supports {{key}} syntax
-   * @param template - String template with {{key}} placeholders
-   * @param values - Values to interpolate
-   * @returns Interpolated string
-   */
-  private interpolate(template: string, values?: TranslationValues): string {
+    const fallbackLocale = this.currentLocale === 'zh' ? 'en' : 'zh';
+    const template =
+      translations[this.currentLocale][key] ||
+      translations[fallbackLocale][key] ||
+      String(key);
     if (!values) {
       return template;
     }
-
-    return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
-      const value = values[key];
+    return template.replace(/\{\{(\w+)\}\}/g, (match, name) => {
+      const value = values[name];
       return value !== undefined ? String(value) : match;
     });
   }
-
-  /**
-   * Add or update translations for a specific locale
-   * @param locale - Target locale
-   * @param translations - Translation object to merge
-   */
-  addTranslations(locale: 'zh' | 'en', translations: Record<string, string>) {
-    this.translations[locale] = {
-      ...this.translations[locale],
-      ...translations,
-    };
-  }
 }
 
-// Create singleton instance
 const i18n = new I18n();
 
-// Export both the instance and the class for flexibility
-export { I18n, i18n };
 export default i18n;
-
-/**
- * Usage examples:
- *
- * // Direct locale setting (new preferred method)
- * i18n.setLocale('zh'); // Chinese
- * i18n.setLocale('en'); // English
- *
- * // Get translations
- * i18n.t('checking_update'); // Based on current locale
- * i18n.t('download_progress', { progress: 50 }); // With interpolation
- */

package/src/locales/en.ts

@@ -1,11 +1,7 @@
 export default {
   // Common messages
-  checking_update: 'Checking for updates...',
   update_failed: 'Update failed',
 
-  // Progress messages with interpolation
-  download_progress: 'Download progress: {{progress}}%',
-
   // Alert messages
   alert_title: 'Notice',
   alert_update_ready: 'Download completed. Update now?',

package/src/locales/zh.ts

@@ -1,11 +1,7 @@
 export default {
   // Common messages
-  checking_update: '正在检查更新...',
   update_failed: '更新失败',
 
-  // Progress messages with interpolation
-  download_progress: '下载进度: {{progress}}%',
-
   // Alert messages
   alert_title: '提示',
   alert_update_ready: '下载完毕，是否立即更新?',

package/src/provider.tsx

@@ -22,6 +22,16 @@ import type { CheckResult, ProgressData, UpdateTestPayload } from './type';
 import { decideDownload, resolveCheckResult } from './updateFlowCore';
 import { assertWeb, isWeb, log, noop, parseQueryParams } from './utils';
 
+// A context action applied to the hash of the given (default: the last
+// checked) update info; a no-op without one.
+const forUpdateHash =
+  <T,>(
+    updateInfoRef: { current?: CheckResult },
+    apply: (hash: string) => Promise<T>
+  ) =>
+  async (info: CheckResult | undefined = updateInfoRef.current) =>
+    info?.hash ? apply(info.hash) : undefined;
+
 export const UpdateProvider = ({
   client,
   children,
@@ -100,22 +110,32 @@ export const UpdateProvider = ({
     [client, alertError]
   );
 
-  const switchVersion = useCallback(
-    async (info: CheckResult | undefined = updateInfoRef.current) => {
-      if (info?.hash) {
-        return client.switchVersion(info.hash);
-      }
-    },
+  const switchVersion = useMemo(
+    () => forUpdateHash(updateInfoRef, client.switchVersion),
     [client]
   );
 
-  const switchVersionLater = useCallback(
-    async (info: CheckResult | undefined = updateInfoRef.current) => {
-      if (info?.hash) {
-        return client.switchVersionLater(info.hash);
+  const switchVersionLater = useMemo(
+    () => forUpdateHash(updateInfoRef, client.switchVersionLater),
+    [client]
+  );
+
+  // Client pipeline errors were already surfaced via the onError
+  // subscription; errors thrown by user hooks (beforeCheckUpdate,
+  // 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.
+  const surfaceCaughtError = useCallback(
+    (e: any, title: string) => {
+      if (!client.wasEmitted(e)) {
+        setLastError(e);
+        alertError(title, e.message);
+      }
+      if (options.throwError) {
+        throw e;
       }
     },
-    [client]
+    [client, options, alertError]
   );
 
   const downloadUpdate = useCallback(
@@ -162,27 +182,17 @@ export const UpdateProvider = ({
         ]);
         return true;
       } catch (e: any) {
-        // 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);
-        }
-        if (options.throwError) {
-          throw e;
-        }
+        surfaceCaughtError(e, client.t('update_failed'));
         return false;
       }
     },
-    [client, options, alertUpdate, alertError]
+    [client, options, alertUpdate, surfaceCaughtError]
   );
 
   const downloadAndInstallApk = useCallback(
     async (downloadUrl: string) => {
-      if (Platform.OS === 'android' && downloadUrl) {
+      // The client itself is a no-op off Android.
+      if (downloadUrl) {
         await client.downloadAndInstallApk(downloadUrl, setProgress);
       }
     },
@@ -219,16 +229,7 @@ export const UpdateProvider = ({
       try {
         rootInfo = await client.checkUpdate(extra);
       } catch (e: any) {
-        // 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);
-        }
-        if (options.throwError) {
-          throw e;
-        }
+        surfaceCaughtError(e, client.t('error_update_check_failed'));
         return;
       }
       if (!rootInfo) {
@@ -354,13 +355,14 @@ export const UpdateProvider = ({
       client,
       options,
       alertUpdate,
-      alertError,
+      surfaceCaughtError,
       openExpiredDownload,
       downloadUpdate,
     ]
   );
 
-  const markSuccess = client.markSuccess;
+  // Stable arrow-function properties of the (pinned) client.
+  const { markSuccess, restartApp, resetToPackagedBundle } = client;
 
   // The lifecycle effects below key on the primitive option values they read
   // (re-read on every render, i.e. after every setOptions), so a setOptions
@@ -528,16 +530,15 @@ export const UpdateProvider = ({
     [parseTestPayload]
   );
 
-  const restartApp = useCallback(async () => {
-    return client.restartApp();
-  }, [client]);
-
-  const resetToPackagedBundle = useCallback(
-    async (resetOptions?: { restart?: boolean }) => {
-      return client.resetToPackagedBundle(resetOptions);
-    },
-    [client]
-  );
+  // parseTestPayload's identity follows checkUpdate (and through it the
+  // update strategy callbacks); the Linking subscription reads it through a
+  // ref so it is set up once instead of re-running — and replaying the
+  // initial URL — on every such change.
+  const latestParseTestPayload = useRef(parseTestPayload);
+  useEffect(() => {
+    latestParseTestPayload.current = parseTestPayload;
+  }, [parseTestPayload]);
+  const initialUrlHandled = useRef(false);
 
   useEffect(() => {
     if (!assertWeb()) {
@@ -552,25 +553,31 @@ export const UpdateProvider = ({
       // malformed deep link must not become an unhandled rejection / a throw
       // inside the 'url' event handler.
       const params = parseQueryParams(url);
-      parseTestPayload({
+      latestParseTestPayload.current({
         type: params.type ?? null,
         data: params.data ?? null,
       });
     };
 
-    Linking.getInitialURL().then(parseLinking).catch(noop);
+    // The launch URL is one event: a remount (StrictMode included) must not
+    // replay it.
+    if (!initialUrlHandled.current) {
+      initialUrlHandled.current = true;
+      Linking.getInitialURL().then(parseLinking).catch(noop);
+    }
     const linkingHandler = ({ url }: { url: string }) => {
       parseLinking(url);
     };
     const linkingListener = Linking.addEventListener('url', linkingHandler);
     return () => {
-      if ('removeEventListener' in Linking) {
-        (Linking as any).removeEventListener('url', linkingHandler);
-      } else {
+      // RN < 0.65 returns no subscription, only removeEventListener.
+      if (typeof linkingListener?.remove === 'function') {
         linkingListener.remove();
+      } else {
+        (Linking as any).removeEventListener('url', linkingHandler);
       }
     };
-  }, [parseTestPayload]);
+  }, []);
 
   // progress lives in its own context (see context.ts), so this value only
   // changes when the update state itself changes, not on every progress tick.

package/src/telemetry.ts

@@ -14,19 +14,6 @@ export type ServerEventType =
 // Failure detail is stored server-side in a VARCHAR(512); stay under it.
 export const MAX_DETAIL_LENGTH = 500;
 
-export interface ServerReportPayload {
-  type: ServerEventType;
-  hash: string;
-  packageVersion?: string;
-  cInfo?: {
-    rnu?: string;
-    rn?: string;
-    os?: string;
-    uuid?: string;
-  };
-  detail?: string;
-}
-
 /**
  * Maps a local report event to the server-side aggregate type, or undefined
  * for events the server does not collect. A DOWNLOAD_FAILED whose underlying

package/src/type.ts

@@ -41,21 +41,6 @@ interface RootResult {
   bundleStatus?: 'matched' | 'rebuiltSameJs' | 'unknownBundle';
 }
 
-export type UpToDateCheckResult = RootResult & {
-  upToDate: true;
-};
-
-export type UpdateAvailableCheckResult = RootResult &
-  Partial<VersionInfo> & {
-    update: true;
-    expVersion?: VersionInfo;
-  };
-
-export type ExpiredCheckResult = RootResult & {
-  expired: true;
-  downloadUrl: string;
-};
-
 export type CheckResult = RootResult &
   Partial<VersionInfo> & {
     expVersion?: VersionInfo;