@algocare/react-native-code-push 12.6.3 → 13.0.0-rc.0

package/cli/commands/createPullRequestReleaseCommand/createPullRequestRelease.ts

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import { bundleCodePush } from "../bundleCommand/bundleCodePush.js";
+import { addToPullRequestRelease } from "./addToPullRequestRelease.js";
+import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+
+export async function createPullRequestRelease(
+    bundleUploader: CliConfigInterface['bundleUploader'],
+    getReleaseHistory: CliConfigInterface['getReleaseHistory'],
+    setReleaseHistory: CliConfigInterface['setReleaseHistory'],
+    binaryVersion: string,
+    prNumber: string,
+    framework: 'expo' | undefined,
+    platform: 'ios' | 'android',
+    identifier: string | undefined,
+    app: string | undefined,
+    outputPath: string,
+    entryFile: string | undefined,
+    jsBundleName: string,
+    mandatory: boolean,
+    enable: boolean,
+    skipBundle: boolean,
+    skipCleanup: boolean,
+    bundleDirectory: string,
+    outputMetroDir?: string,
+): Promise<void> {
+    const bundleFileName = skipBundle
+        ? readBundleFileNameFrom(bundleDirectory)
+        : await bundleCodePush(framework, platform, outputPath, entryFile, jsBundleName, bundleDirectory, outputMetroDir);
+    const bundleFilePath = `${bundleDirectory}/${bundleFileName}`;
+
+    const downloadUrl = await (async () => {
+        try {
+            console.log('Uploading Bundle File...');
+            const { downloadUrl } = await bundleUploader(bundleFilePath, platform, identifier, app);
+            console.log('Bundle File uploaded:', downloadUrl);
+            return downloadUrl;
+        } catch (error) {
+            console.error('Failed to upload the bundle file. Exiting the program.\n', error);
+            process.exit(1);
+        }
+    })();
+
+    await addToPullRequestRelease(
+        binaryVersion,
+        prNumber,
+        downloadUrl,
+        bundleFileName, // bundleFileName represents the package hash
+        getReleaseHistory,
+        setReleaseHistory,
+        platform,
+        identifier,
+        app,
+        mandatory,
+        enable,
+    );
+
+    if (!skipCleanup) {
+        cleanUpOutputs(outputPath);
+    }
+}
+
+function cleanUpOutputs(dir: string) {
+    fs.rmSync(dir, { recursive: true });
+}
+
+function readBundleFileNameFrom(bundleDirectory: string): string {
+    const files = fs.readdirSync(bundleDirectory);
+    if (files.length !== 1) {
+        console.error('The bundlePath must contain only one file.');
+        process.exit(1);
+    }
+    const bundleFilePath = path.join(bundleDirectory, files[0]);
+    return path.basename(bundleFilePath);
+}

package/cli/commands/createPullRequestReleaseCommand/index.ts

@@ -0,0 +1,74 @@
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { createPullRequestRelease } from "./createPullRequestRelease.js";
+import { OUTPUT_BUNDLE_DIR, CONFIG_FILE_NAME, ROOT_OUTPUT_DIR } from "../../constant.js";
+
+type Options = {
+    binaryVersion: string;
+    prNumber: string;
+    framework: 'expo' | undefined;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    app?: string;
+    config: string;
+    outputPath: string;
+    entryFile?: string;
+    jsBundleName: string;
+    mandatory: boolean;
+    enable: boolean;
+    skipBundle: boolean;
+    skipCleanup: boolean;
+    outputBundleDir: string;
+    outputMetroDir?: string;
+}
+
+program.command('create-pr-release')
+    .description('Deploys a PR preview CodePush release.\nThe release is keyed as `{prNumber}-{semver}` in the release history so that only clients syncing with the matching `prNumber` receive it.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version')
+    .requiredOption('-r, --pr-number <string>', '(Required) The pull request number')
+    .addOption(new Option('-f, --framework <type>', 'framework type (expo)').choices(['expo']))
+    .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
+    .option('-i, --identifier <string>', 'reserved characters to distinguish the release.')
+    .option('-a, --app <string>', 'target app name for multi-app repositories. (e.g. home-mobile)')
+    .option('-c, --config <path>', 'set config file name (JS/TS)', CONFIG_FILE_NAME)
+    .option('-o, --output-path <string>', 'path to output root directory', ROOT_OUTPUT_DIR)
+    .option('-e, --entry-file <string>', 'path to JS/TS entry file (default: auto-detect index.<platform>.js → index.js → index.ts)')
+    .option('-j, --js-bundle-name <string>', 'JS bundle file name (default-ios: "main.jsbundle" / default-android: "index.android.bundle")')
+    .option('-m, --mandatory [bool]', 'make the release to be mandatory', parseBoolean, false)
+    .option('--enable [bool]', 'make the release to be enabled', parseBoolean, true)
+    .option('--skip-bundle [bool]', 'skip bundle process', parseBoolean, false)
+    .option('--skip-cleanup [bool]', 'skip cleanup process', parseBoolean, false)
+    .option('--output-metro-dir <string>', 'name of directory to copy the Metro JS bundle and sourcemap before Hermes compilation')
+    .option('--output-bundle-dir <string>', 'name of directory containing the bundle file created by the "bundle" command', OUTPUT_BUNDLE_DIR)
+    .action(async (options: Options) => {
+        const config = findAndReadConfigFile(process.cwd(), options.config);
+
+        await createPullRequestRelease(
+            config.bundleUploader,
+            config.getReleaseHistory,
+            config.setReleaseHistory,
+            options.binaryVersion,
+            options.prNumber,
+            options.framework,
+            options.platform,
+            options.identifier,
+            options.app,
+            options.outputPath,
+            options.entryFile,
+            options.jsBundleName,
+            options.mandatory,
+            options.enable,
+            options.skipBundle,
+            options.skipCleanup,
+            `${options.outputPath}/${options.outputBundleDir}`,
+            options.outputMetroDir,
+        );
+
+        console.log('🚀 PR preview release completed.');
+    });
+
+function parseBoolean(value: string): boolean | undefined {
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    else return undefined;
+}

package/cli/commands/getPackageHashCommand/index.ts

@@ -0,0 +1,45 @@
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+
+type Options = {
+    binaryVersion: string;
+    prNumber?: string;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    app?: string;
+    config: string;
+}
+
+program.command('get-package-hash')
+    .description('Retrieves and prints the package hash of the latest release for a specific binary version.\nWhen --pr-number is given, only PR preview releases (`{prNumber}-*` keys) are considered.\n`getReleaseHistory` function should be implemented in the config file.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version')
+    .option('-r, --pr-number <string>', 'pull request number (filters PR preview releases)')
+    .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
+    .option('-i, --identifier <string>', 'reserved characters to distinguish the release.')
+    .option('-a, --app <string>', 'target app name for multi-app repositories. (e.g. home-mobile)')
+    .option('-c, --config <path>', 'configuration file name (JS/TS)', CONFIG_FILE_NAME)
+    .action(async (options: Options) => {
+        const config = findAndReadConfigFile(process.cwd(), options.config);
+
+        const releaseHistory = await config.getReleaseHistory(
+            options.binaryVersion,
+            options.platform,
+            options.identifier,
+            options.app,
+        );
+
+        const targetKeys = Object.keys(releaseHistory).filter((key) => {
+            return options.prNumber
+                ? key.startsWith(`${options.prNumber}-`)
+                : !key.includes('-');
+        });
+
+        const latestReleaseKey = targetKeys.at(-1);
+        if (!latestReleaseKey) {
+            console.error('No matching release found.');
+            process.exit(1);
+        }
+
+        process.stdout.write(releaseHistory[latestReleaseKey].packageHash);
+    });

package/cli/commands/initCommand/index.ts

@@ -0,0 +1,14 @@
+import { initAndroid } from "./initAndroid.js";
+import { initIos } from "./initIos.js";
+import { program } from "commander";
+
+program
+    .command('init')
+    .description('Automatically performs iOS/Android native configurations to initialize the CodePush project.')
+    .action(async () => {
+        console.log('log: Start initializing CodePush...');
+        await initAndroid();
+        await initIos();
+        console.log('log: CodePush has been successfully initialized.');
+    });
+

package/cli/commands/initCommand/initAndroid.ts

@@ -0,0 +1,91 @@
+import path from "path";
+import fs from "fs";
+import { EOL } from "os";
+
+const IMPORT_CODE_PUSH = 'import com.microsoft.codepush.react.CodePush';
+const RN_LEGACY_MARKER = 'object : DefaultReactNativeHost(this)';
+const RN_082_MARKER = '  getDefaultReactHost(';
+
+export function modifyMainApplicationKt(mainApplicationContent: string) {
+    const hasCodePushImport = mainApplicationContent.includes(IMPORT_CODE_PUSH);
+    const hasGetJSBundleFileFn = mainApplicationContent.includes('CodePush.getJSBundleFile()');
+
+    if (hasCodePushImport && hasGetJSBundleFileFn) {
+        console.log('log: MainApplication.kt already has CodePush initialized.');
+        return mainApplicationContent;
+    }
+
+    let updatedContent = mainApplicationContent;
+
+    if (!hasCodePushImport) {
+        updatedContent = mainApplicationContent.replace('import com.facebook.react.ReactApplication', `import com.facebook.react.ReactApplication${EOL}${IMPORT_CODE_PUSH}`);
+    }
+
+    const isExtendingDefaultReactNativeHost = mainApplicationContent.includes(RN_LEGACY_MARKER);
+
+    // RN <0.82
+    if (isExtendingDefaultReactNativeHost) {
+        if (!hasGetJSBundleFileFn) {
+            updatedContent = updatedContent.replace('override fun getJSMainModuleName(): String = "index"', `override fun getJSMainModuleName(): String = "index"${EOL}        override fun getJSBundleFile(): String = CodePush.getJSBundleFile()`);
+        }
+        return updatedContent;
+    }
+
+    // RN 0.82+
+    const isUsingGetDefaultReactHost = mainApplicationContent.includes(RN_082_MARKER);
+    if (isUsingGetDefaultReactHost) {
+        if (!hasGetJSBundleFileFn) {
+            return addJsBundleFilePathArgument(updatedContent);
+        }
+        return updatedContent;
+    }
+
+    throw new Error('Unsupported MainApplication.kt structure.');
+}
+
+function addJsBundleFilePathArgument(mainApplicationContent: string) {
+    const packageListArgumentPattern = /(packageList\s*=\s*\n\s*PackageList\(this\)[\s\S]+?\},?\s*\n)/;
+
+    if (!packageListArgumentPattern.test(mainApplicationContent)) {
+        console.log('log: Could not find packageList argument while updating MainApplication.kt.');
+        return mainApplicationContent;
+    }
+
+    return mainApplicationContent.replace(packageListArgumentPattern, (match) => {
+        if (match.includes('jsBundleFilePath')) {
+            return match;
+        }
+
+        return `${match}      jsBundleFilePath = CodePush.getJSBundleFile(),${EOL}`;
+    });
+}
+
+export async function initAndroid() {
+    console.log('log: Running Android setup...');
+    await applyMainApplication();
+}
+
+async function applyMainApplication() {
+    const mainApplicationPath = await findMainApplication();
+    if (!mainApplicationPath) {
+        console.log('log: Could not find MainApplication.kt');
+        return;
+    }
+
+    if (mainApplicationPath.endsWith('.java')) {
+        console.log('log: MainApplication.java is not supported. Please migrate to MainApplication.kt.');
+        return;
+    }
+
+    const mainApplicationContent = fs.readFileSync(mainApplicationPath, 'utf-8');
+    const newContent = modifyMainApplicationKt(mainApplicationContent);
+    fs.writeFileSync(mainApplicationPath, newContent);
+    console.log('log: Successfully updated MainApplication.kt.');
+}
+
+async function findMainApplication() {
+    const searchPath = path.join(process.cwd(), 'android', 'app', 'src', 'main', 'java');
+    const files = fs.readdirSync(searchPath, { encoding: 'utf-8', recursive: true });
+    const mainApplicationFile = files.find(file => file.endsWith('MainApplication.java') || file.endsWith('MainApplication.kt'));
+    return mainApplicationFile ? path.join(searchPath, mainApplicationFile) : null;
+}

package/cli/commands/initCommand/initIos.ts

@@ -0,0 +1,123 @@
+import path from "path";
+import fs from "fs";
+// @ts-expect-error -- types for "xcode" are not available
+import xcode from "xcode";
+
+export async function initIos() {
+    console.log('log: Running iOS setup...');
+    const projectDir = path.join(process.cwd(), 'ios');
+    const files = fs.readdirSync(projectDir);
+    const xcodeprojFile = files.find(file => file.endsWith('.xcodeproj'));
+    if (!xcodeprojFile) {
+        console.log('log: Could not find .xcodeproj file in ios directory');
+        return;
+    }
+    const projectName = xcodeprojFile.replace('.xcodeproj', '');
+    const appDelegatePath = findAppDelegate(path.join(projectDir, projectName));
+
+    if (!appDelegatePath) {
+        console.log('log: Could not find AppDelegate file');
+        return;
+    }
+
+    if (appDelegatePath.endsWith('.swift')) {
+        await setupSwift(appDelegatePath, projectDir, projectName);
+    } else {
+        await setupObjectiveC(appDelegatePath);
+    }
+
+    console.log('log: Please run `cd ios && pod install` to complete the setup.');
+}
+
+function findAppDelegate(searchPath: string) {
+    if (!fs.existsSync(searchPath)) return null;
+    const files = fs.readdirSync(searchPath);
+    const appDelegateFile = files.find(file => file.startsWith('AppDelegate') && (file.endsWith('.m') || file.endsWith('.mm') || file.endsWith('.swift')));
+    return appDelegateFile ? path.join(searchPath, appDelegateFile) : null;
+}
+
+export function modifyObjectiveCAppDelegate(appDelegateContent: string) {
+    const IMPORT_STATEMENT = '#import <CodePush/CodePush.h>';
+    if (appDelegateContent.includes(IMPORT_STATEMENT)) {
+        console.log('log: AppDelegate already has CodePush imported.');
+        return appDelegateContent;
+    }
+
+    return appDelegateContent
+        .replace('#import "AppDelegate.h"\n', `#import "AppDelegate.h"\n${IMPORT_STATEMENT}\n`)
+        .replace('[[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];', '[CodePush bundleURL];');
+}
+
+export function modifySwiftAppDelegate(appDelegateContent: string) {
+    const CODEPUSH_CALL_STATEMENT = 'CodePush.bundleURL()';
+    if (appDelegateContent.includes(CODEPUSH_CALL_STATEMENT)) {
+        console.log('log: AppDelegate.swift already configured for CodePush.');
+        return appDelegateContent;
+    }
+
+    return appDelegateContent
+        .replace('Bundle.main.url(forResource: "main", withExtension: "jsbundle")', CODEPUSH_CALL_STATEMENT);
+}
+
+async function setupObjectiveC(appDelegatePath: string) {
+    const appDelegateContent = fs.readFileSync(appDelegatePath, 'utf-8');
+    const newContent = modifyObjectiveCAppDelegate(appDelegateContent);
+    fs.writeFileSync(appDelegatePath, newContent);
+    console.log('log: Successfully updated AppDelegate.m/mm.');
+}
+
+async function setupSwift(appDelegatePath: string, projectDir: string, projectName: string) {
+    const bridgingHeaderPath = await ensureBridgingHeader(projectDir, projectName);
+    if (!bridgingHeaderPath) {
+        console.log('log: Failed to create or find bridging header.');
+        return;
+    }
+
+    const appDelegateContent = fs.readFileSync(appDelegatePath, 'utf-8');
+    const newContent = modifySwiftAppDelegate(appDelegateContent);
+    fs.writeFileSync(appDelegatePath, newContent);
+    console.log('log: Successfully updated AppDelegate.swift.');
+}
+
+async function ensureBridgingHeader(projectDir: string, projectName: string) {
+    const projectPath = path.join(projectDir, `${projectName}.xcodeproj`, 'project.pbxproj');
+    const myProj = xcode.project(projectPath);
+
+    return new Promise((resolve, reject) => {
+        myProj.parse(function (err: unknown) {
+            if (err) {
+                console.error(`Error parsing Xcode project: ${err}`);
+                return reject(err);
+            }
+
+            const bridgingHeaderRelativePath = `${projectName}/${projectName}-Bridging-Header.h`;
+            const bridgingHeaderAbsolutePath = path.join(projectDir, bridgingHeaderRelativePath);
+
+            const configurations = myProj.pbxXCBuildConfigurationSection();
+            for (const name in configurations) {
+                const config = configurations[name];
+                if (config.buildSettings) {
+                    config.buildSettings.SWIFT_OBJC_BRIDGING_HEADER = `"${bridgingHeaderRelativePath}"`;
+                }
+            }
+
+            if (!fs.existsSync(bridgingHeaderAbsolutePath)) {
+                fs.mkdirSync(path.dirname(bridgingHeaderAbsolutePath), { recursive: true });
+                fs.writeFileSync(bridgingHeaderAbsolutePath, '#import <CodePush/CodePush.h>\n');
+                console.log(`log: Created bridging header at ${bridgingHeaderAbsolutePath}`);
+                const groupKey = myProj.findPBXGroupKey({ name: projectName });
+                myProj.addHeaderFile(bridgingHeaderRelativePath, { public: true }, groupKey);
+            } else {
+                const headerContent = fs.readFileSync(bridgingHeaderAbsolutePath, 'utf-8');
+                if (!headerContent.includes('#import <CodePush/CodePush.h>')) {
+                    fs.appendFileSync(bridgingHeaderAbsolutePath, '\n#import <CodePush/CodePush.h>\n');
+                    console.log(`log: Updated bridging header at ${bridgingHeaderAbsolutePath}`);
+                }
+            }
+
+            fs.writeFileSync(projectPath, myProj.writeSync());
+            console.log('log: Updated Xcode project with bridging header path.');
+            resolve(bridgingHeaderAbsolutePath);
+        });
+    });
+}

package/cli/commands/initCommand/test/initAndroid.test.ts

@@ -0,0 +1,128 @@
+import fs from "fs";
+import path from "path";
+import { initAndroid, modifyMainApplicationKt } from "../initAndroid.js";
+import { jest, expect, describe, it } from "@jest/globals";
+
+const tempDir = path.join(__dirname, 'temp');
+
+// https://github.com/react-native-community/template/blob/0.80.2/template/android/app/src/main/java/com/helloworld/MainApplication.kt
+const ktTemplate = `
+package com.helloworld
+
+import android.app.Application
+import com.facebook.react.PackageList
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeApplicationEntryPoint.loadReactNative
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
+import com.facebook.react.defaults.DefaultReactNativeHost
+
+class MainApplication : Application(), ReactApplication {
+
+  override val reactNativeHost: ReactNativeHost =
+      object : DefaultReactNativeHost(this) {
+        override fun getPackages(): List<ReactPackage> =
+            PackageList(this).packages.apply {
+              // Packages that cannot be autolinked yet can be added manually here, for example:
+              // add(MyReactNativePackage())
+            }
+
+        override fun getJSMainModuleName(): String = "index"
+
+        override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
+
+        override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+        override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
+      }
+
+  override val reactHost: ReactHost
+    get() = getDefaultReactHost(applicationContext, reactNativeHost)
+
+  override fun onCreate() {
+    super.onCreate()
+    loadReactNative(this)
+  }
+}
+`;
+
+// https://github.com/react-native-community/template/blob/0.82.1/template/android/app/src/main/java/com/helloworld/MainApplication.kt
+const ktRN82Template = `
+package com.helloworld
+
+import android.app.Application
+import com.facebook.react.PackageList
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeApplicationEntryPoint.loadReactNative
+import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
+
+class MainApplication : Application(), ReactApplication {
+
+  override val reactHost: ReactHost by lazy {
+    getDefaultReactHost(
+      context = applicationContext,
+      packageList =
+        PackageList(this).packages.apply {
+          // Packages that cannot be autolinked yet can be added manually here, for example:
+          // add(MyReactNativePackage())
+        },
+    )
+  }
+
+  override fun onCreate() {
+    super.onCreate()
+    loadReactNative(this)
+  }
+}
+`;
+
+describe('Android init command', () => {
+    it('should correctly modify Kotlin MainApplication content', () => {
+        const modifiedContent = modifyMainApplicationKt(ktTemplate);
+        expect(modifiedContent).toContain('import com.microsoft.codepush.react.CodePush');
+        expect(modifiedContent).toContain('override fun getJSBundleFile(): String = CodePush.getJSBundleFile()');
+    });
+
+    it('should insert jsBundleFilePath argument for RN 0.82 style MainApplication', () => {
+        const modifiedContent = modifyMainApplicationKt(ktRN82Template);
+
+        expect(modifiedContent).toContain('import com.microsoft.codepush.react.CodePush');
+        expect(modifiedContent).toContain('jsBundleFilePath = CodePush.getJSBundleFile()');
+
+        const packageListIndex = modifiedContent.indexOf('packageList =');
+        const jsBundleIndex = modifiedContent.indexOf('jsBundleFilePath = CodePush.getJSBundleFile()');
+        expect(jsBundleIndex).toBeGreaterThan(packageListIndex);
+    });
+
+    it('should log a message and exit if MainApplication.java is found', async () => {
+        const originalCwd = process.cwd();
+
+        fs.mkdirSync(tempDir, { recursive: true });
+        process.chdir(tempDir);
+
+        // Arrange
+        const javaAppDir = path.join(tempDir, 'android', 'app', 'src', 'main', 'java', 'com', 'helloworld');
+        fs.mkdirSync(javaAppDir, { recursive: true });
+        const javaFilePath = path.join(javaAppDir, 'MainApplication.java');
+        const originalContent = '// Java file content';
+        fs.writeFileSync(javaFilePath, originalContent);
+
+        const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {
+        });
+
+        // Act
+        await initAndroid();
+
+        // Assert
+        expect(consoleSpy).toHaveBeenCalledWith('log: MainApplication.java is not supported. Please migrate to MainApplication.kt.');
+        const finalContent = fs.readFileSync(javaFilePath, 'utf-8');
+        expect(finalContent).toBe(originalContent); // Ensure file is not modified
+
+        consoleSpy.mockRestore();
+
+        process.chdir(originalCwd);
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+});

package/cli/commands/initCommand/test/initIos.test.ts

@@ -0,0 +1,99 @@
+import { modifyObjectiveCAppDelegate, modifySwiftAppDelegate } from "../initIos.js";
+import { expect, describe, it} from "@jest/globals";
+
+// https://github.com/react-native-community/template/blob/0.80.2/template/ios/HelloWorld/AppDelegate.swift
+const swiftTemplate = `
+import UIKit
+import React
+import React_RCTAppDelegate
+import ReactAppDependencyProvider
+
+@main
+class AppDelegate: UIResponder, UIApplicationDelegate {
+  var window: UIWindow?
+  var reactNativeDelegate: ReactNativeDelegate?
+  var reactNativeFactory: RCTReactNativeFactory?
+
+  func application(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
+  ) -> Bool {
+    let delegate = ReactNativeDelegate()
+    let factory = RCTReactNativeFactory(delegate: delegate)
+    delegate.dependencyProvider = RCTAppDependencyProvider()
+    reactNativeDelegate = delegate
+    reactNativeFactory = factory
+    window = UIWindow(frame: UIScreen.main.bounds)
+    factory.startReactNative(
+      withModuleName: "HelloWorld",
+      in: window,
+      launchOptions: launchOptions
+    )
+    return true
+  }
+}
+
+class ReactNativeDelegate: RCTDefaultReactNativeFactoryDelegate {
+  override func sourceURL(for bridge: RCTBridge) -> URL? {
+    self.bundleURL()
+  }
+
+  override func bundleURL() -> URL? {
+    #if DEBUG
+    RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: "index")
+    #else
+    Bundle.main.url(forResource: "main", withExtension: "jsbundle")
+    #endif
+  }
+}
+`;
+
+// https://github.com/react-native-community/template/blob/0.76.9/template/ios/HelloWorld/AppDelegate.mm
+const objcTemplate = `
+#import "AppDelegate.h"
+
+#import <React/RCTBundleURLProvider.h>
+
+@implementation AppDelegate
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
+{
+  self.moduleName = @"HelloWorld";
+  // You can add your custom initial props in the dictionary below.
+  // They will be passed down to the ViewController used by React Native.
+  self.initialProps = @{};
+
+  return [super application:application didFinishLaunchingWithOptions:launchOptions];
+}
+
+- (NSURL *)sourceURLForBridge:(RCTBridge *)bridge
+{
+  return [self bundleURL];
+}
+
+- (NSURL *)bundleURL
+{
+#if DEBUG
+  return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index"];
+#else
+  return [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
+#endif
+}
+
+@end
+`;
+
+describe('iOS init command - pure functions', () => {
+    it('should correctly modify Swift AppDelegate content', () => {
+        const modifiedContent = modifySwiftAppDelegate(swiftTemplate);
+        expect(modifiedContent).toContain('CodePush.bundleURL()');
+        expect(modifiedContent).not.toContain('Bundle.main.url(forResource: "main", withExtension: "jsbundle")');
+    });
+
+    it('should correctly modify Objective-C AppDelegate content', () => {
+        const modifiedContent = modifyObjectiveCAppDelegate(objcTemplate);
+        expect(modifiedContent).toContain('#import <CodePush/CodePush.h>');
+        expect(modifiedContent).toContain('[CodePush bundleURL]');
+        expect(modifiedContent).not.toContain('[[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];');
+    });
+});