@bravemobile/react-native-code-push 13.1.0 → 13.3.0

package/cli/dist/commands/releaseCommand/release.test.js

@@ -95,7 +95,7 @@ async function runRelease(staged, overrides = {}) {
     await release(recordingUploader(uploads, overrides.uploadFailsFor), history.getReleaseHistory, history.setReleaseHistory, BINARY_VERSION, APP_VERSION, undefined, overrides.platform ?? 'ios', undefined, staged.outputPath, 'index.ts', 
     // Left unset unless the case is about -j, the way commander leaves it.
     overrides.jsBundleName, false, true, undefined, true, // skipBundle
-    overrides.skipCleanup ?? true, staged.bundleDirectory, undefined, undefined, overrides.binaryBundlePath, overrides.onOversizedPatch, overrides.bundleDownloader, overrides.diffBaseCount);
+    overrides.skipCleanup ?? true, staged.bundleDirectory, undefined, undefined, overrides.binaryBundlePath, overrides.onOversizedPatch, overrides.bundleDownloader, overrides.diffBaseCount, overrides.minimumBackgroundDuration);
     return { uploads, releaseHistories: history.saved, uploadCountsWhenHistorySaved };
 }
 let logs;
@@ -563,3 +563,20 @@ describe("release with asset diff bases", () => {
         expect(path.basename(uploads[0].filePath)).toBe(staged.bundleFileName);
     });
 });
+describe("release --minimum-background-duration", () => {
+    it("records the background wait on the release it publishes", async () => {
+        const staged = await stageBundleOutput("minimum-background-duration");
+        const { releaseHistories } = await runRelease(staged, { minimumBackgroundDuration: 600 });
+        expect(releaseHistories[0][APP_VERSION].minimumBackgroundDuration).toBe(600);
+    });
+    it("releases a background wait of zero seconds as zero, not as an unset option", async () => {
+        const staged = await stageBundleOutput("zero-minimum-background-duration");
+        const { releaseHistories } = await runRelease(staged, { minimumBackgroundDuration: 0 });
+        expect(releaseHistories[0][APP_VERSION].minimumBackgroundDuration).toBe(0);
+    });
+    it("leaves the release saying nothing about the background wait when the option is not given", async () => {
+        const staged = await stageBundleOutput("no-minimum-background-duration");
+        const { releaseHistories } = await runRelease(staged);
+        expect(releaseHistories[0][APP_VERSION]).not.toHaveProperty('minimumBackgroundDuration');
+    });
+});

package/cli/dist/commands/updateHistoryCommand/index.js

@@ -12,14 +12,35 @@ program.command('update-history')
     .option('-m, --mandatory <bool>', 'make the release to be mandatory', parseBoolean, undefined)
     .option('-e, --enable <bool>', 'make the release to be enabled', parseBoolean, undefined)
     .option('--rollout <number>', 'rollout percentage (0-100)', parseFloat, undefined)
+    .option('--minimum-background-duration <seconds>', 'seconds the app must have been in the background before this update is applied on resume. Overrides the minimumBackgroundDuration sync option.', parseDecimalInt, undefined)
     .action(async (options) => {
     const config = findAndReadConfigFile(process.cwd(), options.config);
-    if (typeof options.mandatory !== "boolean" && typeof options.enable !== "boolean") {
+    if (typeof options.mandatory !== "boolean"
+        && typeof options.enable !== "boolean"
+        && typeof options.rollout !== "number"
+        && typeof options.minimumBackgroundDuration !== "number") {
         console.error('No options specified. Exiting the program.');
         process.exit(1);
     }
-    await updateReleaseHistory(options.appVersion, options.binaryVersion, config.getReleaseHistory, config.setReleaseHistory, options.platform, options.identifier, options.mandatory, options.enable, options.rollout);
+    // `Number.isFinite` is what rejects a non-numeric `--rollout`: `parseFloat` turns it into
+    // NaN, and both `NaN < 0` and `NaN > 100` are false.
+    if (options.rollout !== undefined
+        && (!Number.isFinite(options.rollout) || options.rollout < 0 || options.rollout > 100)) {
+        console.error('Rollout percentage number must be between 0 and 100 (inclusive).');
+        process.exit(1);
+    }
+    if (options.minimumBackgroundDuration !== undefined
+        && (!Number.isInteger(options.minimumBackgroundDuration) || options.minimumBackgroundDuration < 0)) {
+        console.error('--minimum-background-duration must be a whole number of seconds, 0 or greater.');
+        process.exit(1);
+    }
+    await updateReleaseHistory(options.appVersion, options.binaryVersion, config.getReleaseHistory, config.setReleaseHistory, options.platform, options.identifier, options.mandatory, options.enable, options.rollout, options.minimumBackgroundDuration);
 });
+// Not `parseInt` itself: commander hands a coercion function the current value as its
+// second argument, which `parseInt` reads as the radix.
+function parseDecimalInt(value) {
+    return parseInt(value, 10);
+}
 function parseBoolean(value) {
     if (value === 'true')
         return true;

package/cli/dist/commands/updateHistoryCommand/index.test.js

@@ -0,0 +1,102 @@
+import fs from "fs";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
+/**
+ * Checks the command definition against the entry it saves. Everything this command does
+ * ends up in the release history the config is handed, so an option that never reaches it
+ * leaves the release exactly as it was - which the command still reports as a success.
+ */
+const BINARY_VERSION = '1.0.0';
+const APP_VERSION = '1.0.1';
+let mockConfig;
+jest.mock("../../utils/fsUtils.js", () => ({
+    findAndReadConfigFile: () => mockConfig,
+}));
+/**
+ * Puts one released version in the config's history and records every history it is
+ * handed back, so a case can read the entry as the consumer would store it.
+ */
+function stageReleaseHistory() {
+    const releaseHistory = {
+        [APP_VERSION]: {
+            enabled: true,
+            mandatory: false,
+            downloadUrl: 'https://cdn.example.com/bundle',
+            packageHash: 'a3f1c0',
+        },
+    };
+    const saved = [];
+    mockConfig = {
+        bundleUploader: async () => ({ downloadUrl: 'https://cdn.example.com/bundle' }),
+        getReleaseHistory: async () => releaseHistory,
+        // The command edits the history in place, so what it saved is copied out here.
+        setReleaseHistory: async (_binaryVersion, _jsonFilePath, releaseInfo) => {
+            saved.push(structuredClone(releaseInfo));
+        },
+    };
+    return saved;
+}
+/**
+ * Parses an `update-history` invocation against the real command definition. Commander is
+ * asked to throw instead of exiting, and to keep its diagnostics to itself, so a rejected
+ * option can be asserted on without ending the worker or the output.
+ */
+async function parseUpdateHistoryCommand(args) {
+    const { program } = await import("commander");
+    await import("./index.js");
+    const updateHistoryCommand = program.commands.find((command) => command.name() === 'update-history');
+    updateHistoryCommand?.exitOverride();
+    updateHistoryCommand?.configureOutput({ writeErr: () => { } });
+    await program.parseAsync(['update-history', ...args], { from: 'user' });
+}
+async function runUpdateHistoryCommand(args) {
+    await parseUpdateHistoryCommand(['-b', BINARY_VERSION, '-v', APP_VERSION, ...args]);
+}
+let saved;
+beforeEach(() => {
+    jest.resetModules();
+    saved = stageReleaseHistory();
+    jest.spyOn(console, 'log').mockImplementation(() => { });
+    jest.spyOn(console, 'error').mockImplementation(() => { });
+    jest.spyOn(process, 'exit').mockImplementation(((code) => {
+        throw new Error(`process.exit(${code})`);
+    }));
+});
+afterEach(() => {
+    jest.restoreAllMocks();
+    // The command writes its JSON under the directory it was invoked in.
+    fs.rmSync(path.resolve(process.cwd(), "codepush-release-history"), { recursive: true, force: true });
+});
+describe("update-history command options", () => {
+    it("lowers the background wait of a release that is already out to zero seconds", async () => {
+        await runUpdateHistoryCommand(['--minimum-background-duration', '0']);
+        expect(saved).toHaveLength(1);
+        expect(saved[0][APP_VERSION].minimumBackgroundDuration).toBe(0);
+    });
+    it("leaves the entry saying nothing about the background wait when only --enable is given", async () => {
+        await runUpdateHistoryCommand(['--enable', 'false']);
+        expect(saved[0][APP_VERSION].enabled).toBe(false);
+        expect(saved[0][APP_VERSION]).not.toHaveProperty('minimumBackgroundDuration');
+    });
+    it("saves the rollout percentage when --rollout is the only option given", async () => {
+        await runUpdateHistoryCommand(['--rollout', '50']);
+        expect(saved[0][APP_VERSION].rollout).toBe(50);
+    });
+    it("exits without saving anything when no option says what to change", async () => {
+        await expect(runUpdateHistoryCommand([])).rejects.toThrow('process.exit(1)');
+        expect(saved).toHaveLength(0);
+    });
+    it("rejects a negative background wait and saves nothing", async () => {
+        await expect(runUpdateHistoryCommand(['--minimum-background-duration', '-1']))
+            .rejects.toThrow('process.exit(1)');
+        expect(saved).toHaveLength(0);
+    });
+    it.each([
+        ['a percentage above 100', '150'],
+        ['a percentage that is not a number', 'abc'],
+    ])("rejects %s and saves nothing", async (_scenario, rollout) => {
+        await expect(runUpdateHistoryCommand(['--rollout', rollout]))
+            .rejects.toThrow('process.exit(1)');
+        expect(saved).toHaveLength(0);
+    });
+});

package/cli/dist/commands/updateHistoryCommand/updateReleaseHistory.js

@@ -1,5 +1,5 @@
 import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
-export async function updateReleaseHistory(appVersion, binaryVersion, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout) {
+export async function updateReleaseHistory(appVersion, binaryVersion, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout, minimumBackgroundDuration) {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
     const updateInfo = releaseHistory[appVersion];
     if (!updateInfo)
@@ -10,6 +10,9 @@ export async function updateReleaseHistory(appVersion, binaryVersion, getRelease
         updateInfo.enabled = enable;
     if (typeof rollout === "number")
         updateInfo.rollout = rollout;
+    // 0 is what lowers the wait to "apply on the next resume", so truthiness cannot decide here.
+    if (typeof minimumBackgroundDuration === "number")
+        updateInfo.minimumBackgroundDuration = minimumBackgroundDuration;
     try {
         await stageReleaseHistoryFile(binaryVersion, releaseHistory, platform, (jsonFilePath) => setReleaseHistory(binaryVersion, jsonFilePath, releaseHistory, platform, identifier));
     }

package/cli/dist/utils/fsUtils.js

@@ -1,20 +1,15 @@
 import fs from "fs";
 import path from "path";
 import { createRequire } from "module";
-const nodeRequire = createRequire(import.meta.url);
 /**
  * allows to require a config file with .ts extension
  */
 function requireConfig(filePath) {
     const ext = path.extname(filePath);
+    // Resolve the loader from the project the config file lives in, not from the CLI install.
+    const projectRequire = createRequire(filePath);
     if (ext === '.ts') {
-        try {
-            nodeRequire('ts-node/register');
-        }
-        catch {
-            console.error('ts-node not found. Please install ts-node as a devDependency.');
-            process.exit(1);
-        }
+        return unwrapDefaultExport(requireTsConfig(projectRequire, filePath));
     }
     else if (ext === '.js') {
         // do nothing
@@ -22,7 +17,38 @@ function requireConfig(filePath) {
     else {
         throw new Error(`Unsupported file extension: ${ext}`);
     }
-    return nodeRequire(filePath);
+    return unwrapDefaultExport(projectRequire(filePath));
+}
+/**
+ * tsx is preferred: it needs no tsconfig setup and resolves tsconfig `paths` aliases on its own.
+ * ts-node keeps working for projects that already have it configured.
+ */
+function requireTsConfig(projectRequire, filePath) {
+    if (canResolve(projectRequire, 'tsx/cjs/api')) {
+        const { require: tsxRequire } = projectRequire('tsx/cjs/api');
+        return tsxRequire(filePath, filePath);
+    }
+    if (canResolve(projectRequire, 'ts-node/register')) {
+        console.warn('warn: Loading the config file with ts-node, which is no longer maintained. Support for it ' +
+            'will be removed in a future major version - please install tsx instead (`npm i -D tsx`).');
+        projectRequire('ts-node/register');
+        return projectRequire(filePath);
+    }
+    console.error('A TypeScript config file needs a loader. Please install tsx as a devDependency (`npm i -D tsx`).');
+    process.exit(1);
+}
+function canResolve(projectRequire, id) {
+    try {
+        projectRequire.resolve(id);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// `export default` compiles to `exports.default`; `module.exports =` is returned as is.
+function unwrapDefaultExport(loaded) {
+    return (loaded.default ?? loaded);
 }
 export function findAndReadConfigFile(startDir, configFileName) {
     let dir = startDir;

package/cli/package.json

@@ -19,11 +19,15 @@
     "yauzl": "^3.2.0"
   },
   "peerDependencies": {
-    "ts-node": ">=10"
+    "ts-node": ">=10",
+    "tsx": ">=4"
   },
   "peerDependenciesMeta": {
     "ts-node": {
       "optional": true
+    },
+    "tsx": {
+      "optional": true
     }
   },
   "engines": {

package/cli/utils/fsUtils.ts

@@ -3,28 +3,62 @@ import path from "path";
 import { createRequire } from "module";
 import type { CliConfigInterface } from "../../typings/react-native-code-push.d.ts";
 
-const nodeRequire = createRequire(import.meta.url);
-
 /**
  * allows to require a config file with .ts extension
  */
 function requireConfig(filePath: string): CliConfigInterface {
   const ext = path.extname(filePath);
+  // Resolve the loader from the project the config file lives in, not from the CLI install.
+  const projectRequire = createRequire(filePath);
 
   if (ext === '.ts') {
-    try {
-      nodeRequire('ts-node/register');
-    } catch {
-      console.error('ts-node not found. Please install ts-node as a devDependency.');
-      process.exit(1);
-    }
+    return unwrapDefaultExport(requireTsConfig(projectRequire, filePath));
   } else if (ext === '.js') {
     // do nothing
   } else {
     throw new Error(`Unsupported file extension: ${ext}`);
   }
 
-  return nodeRequire(filePath) as CliConfigInterface;
+  return unwrapDefaultExport(projectRequire(filePath));
+}
+
+/**
+ * tsx is preferred: it needs no tsconfig setup and resolves tsconfig `paths` aliases on its own.
+ * ts-node keeps working for projects that already have it configured.
+ */
+function requireTsConfig(projectRequire: NodeRequire, filePath: string): { default?: unknown } {
+  if (canResolve(projectRequire, 'tsx/cjs/api')) {
+    const { require: tsxRequire } = projectRequire('tsx/cjs/api') as {
+      require: (id: string, fromFile: string) => { default?: unknown };
+    };
+    return tsxRequire(filePath, filePath);
+  }
+
+  if (canResolve(projectRequire, 'ts-node/register')) {
+    console.warn(
+      'warn: Loading the config file with ts-node, which is no longer maintained. Support for it ' +
+        'will be removed in a future major version - please install tsx instead (`npm i -D tsx`).',
+    );
+    projectRequire('ts-node/register');
+    return projectRequire(filePath);
+  }
+
+  console.error('A TypeScript config file needs a loader. Please install tsx as a devDependency (`npm i -D tsx`).');
+  process.exit(1);
+}
+
+function canResolve(projectRequire: NodeRequire, id: string): boolean {
+  try {
+    projectRequire.resolve(id);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// `export default` compiles to `exports.default`; `module.exports =` is returned as is.
+function unwrapDefaultExport(loaded: { default?: unknown }): CliConfigInterface {
+  return (loaded.default ?? loaded) as CliConfigInterface;
 }
 
 export function findAndReadConfigFile(startDir: string, configFileName: string): CliConfigInterface {

package/ios/CodePush/CodePush.h

@@ -36,6 +36,10 @@
 @interface CodePush : RCTEventEmitter
 #endif
 
+/*
+ * Returns the bundle embedded in the binary, without resolving an installed update.
+ * The update pipeline uses this as the base for binary patches and asset diffs.
+ */
 + (NSURL *)binaryBundleURL;
 /*
  * This method is used to retrieve the URL for the most recent
@@ -64,8 +68,10 @@
                    subdirectory:(NSString *)resourceSubdirectory
                          bundle:(NSBundle *)resourceBundle;
 
+/* Internal storage root used by CodePushPackage. */
 + (NSString *)getApplicationSupportDirectory;
 
+/* Returns the embedded assets path used as the base for asset diffs. */
 + (NSString *)bundleAssetsPath;
 
 /*
@@ -76,9 +82,8 @@
 + (void)overrideAppVersion:(NSString *)appVersion;
 
 /*
- * This method allows dynamically setting the app's
- * deployment key, in addition to setting it via
- * the Info.plist file's CodePushDeploymentKey setting.
+ * Retained for compatibility. The current implementation ignores the argument
+ * and uses the deprecated deployment key placeholder.
  */
 + (void)setDeploymentKey:(NSString *)deploymentKey;
 

package/ios/CodePush/CodePush.mm

@@ -1,6 +1,7 @@
 #import <React/RCTAssert.h>
 #import <React/RCTBridgeModule.h>
 #import <React/RCTConvert.h>
+#import <React/RCTInvalidating.h>
 #import <React/RCTEventDispatcher.h>
 #import <React/RCTRootView.h>
 #import <React/RCTUtils.h>
@@ -8,7 +9,9 @@
 
 #import "CodePush.h"
 
-@interface CodePush () <RCTFrameUpdateObserver
+#include <atomic>
+
+@interface CodePush () <RCTFrameUpdateObserver, RCTInvalidating
 #ifdef RCT_NEW_ARCH_ENABLED
 , NativeCodePushSpec
 #endif
@@ -32,6 +35,17 @@
     BOOL _allowed;
     BOOL _restartInProgress;
     NSMutableArray *_restartQueue;
+
+    /*
+     * Whether the React Native instance this module was created for is still the one
+     * running.
+     *
+     * A reload starts the next instance before the one being replaced has finished being
+     * torn down, so work this instance started can still be running with nothing left to
+     * hand its result to. Read from whichever thread that work is on, written when the
+     * instance is invalidated, so it is atomic.
+     */
+    std::atomic<bool> _generationAlive;
 }
 
 RCT_EXPORT_MODULE()
@@ -307,7 +321,42 @@ static NSString *const LatestRollbackCountKey = @"count";
     [[NSNotificationCenter defaultCenter] removeObserver:self];
 }
 
+/*
+ * Called when the React Native instance this module belongs to is being replaced.
+ *
+ * A download in flight keeps this module alive past that point, and the suspend timer and
+ * the resume notifications keep it reachable too. None of them may act afterwards: the
+ * runtime they would report to is gone, and the restart they would trigger belongs to a
+ * generation that is no longer on screen.
+ */
+- (void)invalidate
+{
+    _generationAlive.store(false);
+
+    [_appSuspendTimer invalidate];
+    _appSuspendTimer = nil;
+    _hasResumeListener = NO;
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+
+#ifndef RCT_NEW_ARCH_ENABLED
+    [super invalidate];
+#endif
+}
+
+/* Whether this module still belongs to the React Native instance that is running. */
+- (BOOL)isGenerationAlive
+{
+    return _generationAlive.load();
+}
+
 - (void)dispatchDownloadProgressEvent {
+  // The download that is reporting here can be one this module started before the app was
+  // reloaded, in which case the event emitter it would reach belongs to a runtime that has
+  // been torn down.
+  if (![self isGenerationAlive]) {
+    return;
+  }
+
   // Notify the script-side about the progress
   NSDictionary *progress = @{
     @"totalBytes" : [NSNumber numberWithLongLong:_latestExpectedContentLength],
@@ -375,6 +424,7 @@ static NSString *const LatestRollbackCountKey = @"count";
     _restartInProgress = NO;
     _restartQueue = [NSMutableArray arrayWithCapacity:1];
     _lastProgressEventTime = 0;
+    _generationAlive.store(true);
 
     self = [super init];
     if (self) {
@@ -533,6 +583,11 @@ static NSString *const LatestRollbackCountKey = @"count";
  */
 - (void)loadBundle
 {
+    if (![self isGenerationAlive]) {
+        CPLog(@"Ignoring a reload requested by a React Native instance that is no longer running.");
+        return;
+    }
+
     @synchronized([CodePush class]) {
         hasInitializedUpdateAfterRestartForCurrentLoad = NO;
     }
@@ -802,6 +857,11 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
 
 - (void)restartAppInternal:(BOOL)onlyIfUpdateIsPending
 {
+    if (![self isGenerationAlive]) {
+        CPLog(@"Ignoring a restart requested by a React Native instance that is no longer running.");
+        return;
+    }
+
     if (_restartInProgress) {
         CPLog(@"Restart request queued until the current restart is completed.");
         [_restartQueue addObject:@(onlyIfUpdateIsPending)];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bravemobile/react-native-code-push",
-  "version": "13.1.0",
+  "version": "13.3.0",
   "description": "React Native plugin for the CodePush service",
   "main": "src/CodePush.js",
   "react-native": "src/CodePush.js",
@@ -71,8 +71,8 @@
   ],
   "scripts": {
     "setup": "npm install --quiet --no-progress",
-    "setup-example-app": "ts-node --project scripts/setupExampleApp/tsconfig.json scripts/setupExampleApp/runSetupExampleApp.ts",
-    "setup-expo-example-app": "ts-node --project scripts/setupExampleApp/tsconfig.json scripts/setupExpoExampleApp/runSetupExpoExampleApp.ts",
+    "setup-example-app": "tsx scripts/setupExampleApp/runSetupExampleApp.ts",
+    "setup-expo-example-app": "tsx scripts/setupExpoExampleApp/runSetupExpoExampleApp.ts",
     "type:src": "tsc --project tsconfig.json --noEmit",
     "type:cli": "npm run --workspace cli typecheck",
     "type:scripts": "tsc --project scripts/tsconfig.json --noEmit",
@@ -82,7 +82,7 @@
     "prepack": "npm run build:cli",
     "eslint": "eslint --quiet .",
     "jest": "jest src/CodePush.test.js src/versioning/* expo/* && npm run --workspace cli test",
-    "e2e": "ts-node --project e2e/tsconfig.json e2e/run.ts"
+    "e2e": "tsx e2e/run.ts"
   },
   "publishConfig": {
     "access": "public"
@@ -102,11 +102,19 @@
   },
   "peerDependencies": {
     "expo": ">=50.0.0",
-    "react-native": "*"
+    "react-native": "*",
+    "ts-node": ">=10",
+    "tsx": ">=4"
   },
   "peerDependenciesMeta": {
     "expo": {
       "optional": true
+    },
+    "ts-node": {
+      "optional": true
+    },
+    "tsx": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -128,7 +136,7 @@
     "jest": "^29.7.0",
     "react": "19.2.3",
     "react-native": "0.84.1",
-    "ts-node": "^10.9.2",
+    "tsx": "^4.23.13",
     "typescript": "5.0.4",
     "typescript-eslint": "^8.11.0"
   },

package/src/CodePush.js

@@ -200,6 +200,11 @@ async function checkForUpdate(handleBinaryVersionMismatchCallback = null) {
            * back on when the diff fails on its asset side.
            */
           asset_diff_download_url: diffPackageDownloadUrl,
+          /**
+           * Only present when the release asked for a background duration of its own, which
+           * then wins over the one the `sync` call passes.
+           */
+          minimum_background_duration: latestReleaseInfo.minimumBackgroundDuration,
           // (`enabled` will always be true in the release information obtained from the previous process.)
           is_available: latestReleaseInfo.enabled,
           package_hash: latestReleaseInfo.packageHash,
@@ -309,6 +314,11 @@ function mapToRemotePackageMetadata(updateInfo) {
     ...(updateInfo.asset_diff_download_url
       ? { assetDiffDownloadUrl: updateInfo.asset_diff_download_url }
       : {}),
+    // Presence is read off the type, not off truthiness, so that a release asking for `0`
+    // seconds keeps its own value instead of looking like a release that asked for nothing.
+    ...(typeof updateInfo.minimum_background_duration === 'number'
+      ? { minimumBackgroundDuration: updateInfo.minimum_background_duration }
+      : {}),
   };
 }
 
@@ -552,6 +562,7 @@ const sync = (() => {
  */
 async function syncInternal(options = {}, syncStatusChangeCallback, downloadProgressCallback, handleBinaryVersionMismatchCallback) {
   let resolvedInstallMode;
+  let resolvedMinimumBackgroundDuration;
   const syncOptions = {
     deploymentKey: null,
     ignoreFailedUpdates: true,
@@ -596,8 +607,8 @@ async function syncInternal(options = {}, syncStatusChangeCallback, downloadProg
           if (resolvedInstallMode == CodePush.InstallMode.ON_NEXT_RESTART) {
             log("Update is installed and will be run on the next app restart.");
           } else if (resolvedInstallMode == CodePush.InstallMode.ON_NEXT_RESUME) {
-            if (syncOptions.minimumBackgroundDuration > 0) {
-              log(`Update is installed and will be run after the app has been in the background for at least ${syncOptions.minimumBackgroundDuration} seconds.`);
+            if (resolvedMinimumBackgroundDuration > 0) {
+              log(`Update is installed and will be run after the app has been in the background for at least ${resolvedMinimumBackgroundDuration} seconds.`);
             } else {
               log("Update is installed and will be run when the app next resumes.");
             }
@@ -630,9 +641,11 @@ async function syncInternal(options = {}, syncStatusChangeCallback, downloadProg
 
       // Determine the correct install mode based on whether the update is mandatory or not.
       resolvedInstallMode = localPackage.isMandatory ? syncOptions.mandatoryInstallMode : syncOptions.installMode;
+      // `??` rather than `||`, so a release asking for `0` seconds keeps its own value.
+      resolvedMinimumBackgroundDuration = remotePackage.minimumBackgroundDuration ?? syncOptions.minimumBackgroundDuration;
 
       syncStatusChangeCallback(CodePush.SyncStatus.INSTALLING_UPDATE);
-      await localPackage.install(resolvedInstallMode, syncOptions.minimumBackgroundDuration, () => {
+      await localPackage.install(resolvedInstallMode, resolvedMinimumBackgroundDuration, () => {
         syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_INSTALLED);
       });
 

package/src/CodePush.test.js

@@ -649,3 +649,60 @@ describe('telemetry callback errors', () => {
     expect(nativeBridge.saveStatusReportForRetry).not.toHaveBeenCalled();
   });
 });
+
+/**
+ * A release can ask for its own minimum background duration - how long the app has to have
+ * been in the background before an update installed with `ON_NEXT_RESUME` is applied. The
+ * app passes a duration to `sync` for the releases that ask for nothing, and whichever of
+ * the two wins is what the native module is given when the update is installed.
+ */
+describe('the minimum background duration an update is installed with', () => {
+  /** The release the CLI writes when the release carries its own background duration. */
+  function releaseAskingFor(minimumBackgroundDuration) {
+    const history = fullOnlyRelease();
+    history[LABEL].minimumBackgroundDuration = minimumBackgroundDuration;
+    return history;
+  }
+
+  /** The background duration the native module is given, in seconds. */
+  function installedMinimumBackgroundDuration(nativeBridge) {
+    expect(nativeBridge.installUpdate).toHaveBeenCalledTimes(1);
+    return nativeBridge.installUpdate.mock.calls[0][2];
+  }
+
+  it('takes the one the release history entry asks for over the one the sync call passes', async () => {
+    const { CodePush, nativeBridge } = loadCodePush({ releaseHistory: releaseAskingFor(600) });
+
+    const syncStatus = await CodePush.sync({
+      installMode: InstallMode.ON_NEXT_RESUME,
+      minimumBackgroundDuration: 3600,
+    });
+
+    expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
+    expect(installedMinimumBackgroundDuration(nativeBridge)).toBe(600);
+  });
+
+  it('keeps the one the sync call passes when the release history entry asks for none', async () => {
+    const { CodePush, nativeBridge } = loadCodePush({ releaseHistory: fullOnlyRelease() });
+
+    const syncStatus = await CodePush.sync({
+      installMode: InstallMode.ON_NEXT_RESUME,
+      minimumBackgroundDuration: 3600,
+    });
+
+    expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
+    expect(installedMinimumBackgroundDuration(nativeBridge)).toBe(3600);
+  });
+
+  it('runs a release that asks for zero seconds on the next resume, however long the sync call would have waited', async () => {
+    const { CodePush, nativeBridge } = loadCodePush({ releaseHistory: releaseAskingFor(0) });
+
+    const syncStatus = await CodePush.sync({
+      installMode: InstallMode.ON_NEXT_RESUME,
+      minimumBackgroundDuration: 3600,
+    });
+
+    expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
+    expect(installedMinimumBackgroundDuration(nativeBridge)).toBe(0);
+  });
+});