@bravemobile/react-native-code-push 12.0.1 → 12.1.0

package/cli/commands/releaseCommand/{addToReleaseHistory.js → addToReleaseHistory.ts}

@@ -1,46 +1,20 @@
-const path = require("path");
-const fs = require("fs");
-
-/**
- *
- * @param appVersion {string}
- * @param binaryVersion {string}
- * @param bundleDownloadUrl {string}
- * @param packageHash {string}
- * @param getReleaseHistory {
- *   function(
- *     targetBinaryVersion: string,
- *     platform: string,
- *     identifier?: string
- *   ): Promise<ReleaseHistoryInterface>}
- * @param setReleaseHistory {
- *   function(
- *     targetBinaryVersion: string,
- *     jsonFilePath: string,
- *     releaseInfo: ReleaseHistoryInterface,
- *     platform: string,
- *     identifier?: string
- *   ): Promise<void>}
- * @param platform {"ios" | "android"}
- * @param identifier {string?}
- * @param mandatory {boolean?}
- * @param enable {boolean?}
- * @param rollout {number?}
- * @returns {Promise<void>}
- */
-async function addToReleaseHistory(
-    appVersion,
-    binaryVersion,
-    bundleDownloadUrl,
-    packageHash,
-    getReleaseHistory,
-    setReleaseHistory,
-    platform,
-    identifier,
-    mandatory,
-    enable,
-    rollout
-) {
+import path from "path";
+import fs from "fs";
+import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+
+export async function addToReleaseHistory(
+    appVersion: string,
+    binaryVersion: string,
+    bundleDownloadUrl: string,
+    packageHash: string,
+    getReleaseHistory: CliConfigInterface['getReleaseHistory'],
+    setReleaseHistory: CliConfigInterface['setReleaseHistory'],
+    platform: 'ios' | 'android',
+    identifier: string | undefined,
+    mandatory: boolean,
+    enable: boolean,
+    rollout: number | undefined,
+): Promise<void> {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
 
     const updateInfo = releaseHistory[appVersion]
@@ -77,5 +51,3 @@ async function addToReleaseHistory(
         process.exit(1)
     }
 }
-
-module.exports = { addToReleaseHistory: addToReleaseHistory }

package/cli/commands/releaseCommand/{index.js → index.ts}

@@ -1,7 +1,25 @@
-const { program, Option } = require("commander");
-const { findAndReadConfigFile } = require("../../utils/fsUtils");
-const { release } = require("./release");
-const { OUTPUT_BUNDLE_DIR, CONFIG_FILE_NAME, ROOT_OUTPUT_DIR, ENTRY_FILE } = require('../../constant');
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { release } from "./release.js";
+import { OUTPUT_BUNDLE_DIR, CONFIG_FILE_NAME, ROOT_OUTPUT_DIR, ENTRY_FILE } from "../../constant.js";
+
+type Options = {
+    binaryVersion: string;
+    appVersion: string;
+    framework: 'expo' | undefined;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    config: string;
+    outputPath: string;
+    entryFile: string;
+    bundleName: string;
+    mandatory: boolean;
+    enable: boolean;
+    rollout?: number;
+    skipBundle: boolean;
+    skipCleanup: boolean;
+    outputBundleDir: string;
+}
 
 program.command('release')
     .description('Deploys a new CodePush update for a target binary app.\nAfter creating the CodePush bundle, it uploads the file and updates the ReleaseHistory information.\n`bundleUploader`, `getReleaseHistory`, and `setReleaseHistory` functions should be implemented in the config file.')
@@ -20,26 +38,7 @@ program.command('release')
     .option('--skip-bundle <bool>', 'skip bundle process', parseBoolean, false)
     .option('--skip-cleanup <bool>', 'skip cleanup process', parseBoolean, false)
     .option('--output-bundle-dir <string>', 'name of directory containing the bundle file created by the "bundle" command', OUTPUT_BUNDLE_DIR)
-    /**
-     * @param {Object} options
-     * @param {string} options.binaryVersion
-     * @param {string} options.appVersion
-     * @param {string} options.framework
-     * @param {string} options.platform
-     * @param {string} options.identifier
-     * @param {string} options.config
-     * @param {string} options.outputPath
-     * @param {string} options.entryFile
-     * @param {string} options.bundleName
-     * @param {string} options.mandatory
-     * @param {string} options.enable
-     * @param {number} options.rollout
-     * @param {string} options.skipBundle
-     * @param {string} options.skipCleanup
-     * @param {string} options.outputBundleDir
-     * @return {void}
-     */
-    .action(async (options) => {
+    .action(async (options: Options) => {
         const config = findAndReadConfigFile(process.cwd(), options.config);
 
         if (typeof options.rollout === 'number' && (options.rollout < 0 || options.rollout > 100)) {
@@ -70,7 +69,7 @@ program.command('release')
         console.log('🚀 Release completed.')
     });
 
-function parseBoolean(value) {
+function parseBoolean(value: string): boolean | undefined {
     if (value === 'true') return true;
     if (value === 'false') return false;
     else return undefined;

package/cli/commands/releaseCommand/release.ts

@@ -0,0 +1,72 @@
+import fs from "fs";
+import path from "path";
+import { bundleCodePush } from "../bundleCommand/bundleCodePush.js";
+import { addToReleaseHistory } from "./addToReleaseHistory.js";
+import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+
+export async function release(
+    bundleUploader: CliConfigInterface['bundleUploader'],
+    getReleaseHistory: CliConfigInterface['getReleaseHistory'],
+    setReleaseHistory: CliConfigInterface['setReleaseHistory'],
+    binaryVersion: string,
+    appVersion: string,
+    framework: 'expo' | undefined,
+    platform: 'ios' | 'android',
+    identifier: string | undefined,
+    outputPath: string,
+    entryFile: string,
+    jsBundleName: string,
+    mandatory: boolean,
+    enable: boolean,
+    rollout: number | undefined,
+    skipBundle: boolean,
+    skipCleanup: boolean,
+    bundleDirectory: string,
+): Promise<void> {
+    const bundleFileName = skipBundle
+        ? readBundleFileNameFrom(bundleDirectory)
+        : await bundleCodePush(framework, platform, outputPath, entryFile, jsBundleName, bundleDirectory);
+    const bundleFilePath = `${bundleDirectory}/${bundleFileName}`;
+
+    const downloadUrl = await (async () => {
+        try {
+            const { downloadUrl } = await bundleUploader(bundleFilePath, platform, identifier);
+            return downloadUrl
+        } catch (error) {
+            console.error('Failed to upload the bundle file. Exiting the program.\n', error)
+            process.exit(1)
+        }
+    })();
+
+    await addToReleaseHistory(
+        appVersion,
+        binaryVersion,
+        downloadUrl,
+        bundleFileName,
+        getReleaseHistory,
+        setReleaseHistory,
+        platform,
+        identifier,
+        mandatory,
+        enable,
+        rollout,
+    )
+
+    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/showHistoryCommand/{index.js → index.ts}

@@ -1,6 +1,13 @@
-const { program, Option } = require("commander");
-const { findAndReadConfigFile } = require("../../utils/fsUtils");
-const { CONFIG_FILE_NAME } = require('../../constant');
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+
+type Options = {
+    binaryVersion: string;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    config: string;
+}
 
 program.command('show-history')
     .description('Retrieves and prints the release history of a specific binary version.\n`getReleaseHistory` function should be implemented in the config file.')
@@ -8,15 +15,7 @@ program.command('show-history')
     .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
     .option('-i, --identifier <string>', 'reserved characters to distinguish the release.')
     .option('-c, --config <path>', 'configuration file name (JS/TS)', CONFIG_FILE_NAME)
-    /**
-     * @param {Object} options
-     * @param {string} options.binaryVersion
-     * @param {string} options.platform
-     * @param {string} options.identifier
-     * @param {string} options.config
-     * @return {void}
-     */
-    .action(async (options) => {
+    .action(async (options: Options) => {
         const config = findAndReadConfigFile(process.cwd(), options.config);
 
         const releaseHistory = await config.getReleaseHistory(

package/cli/commands/updateHistoryCommand/{index.js → index.ts}

@@ -1,7 +1,18 @@
-const { program, Option } = require("commander");
-const { findAndReadConfigFile } = require("../../utils/fsUtils");
-const { updateReleaseHistory } = require("./updateReleaseHistory");
-const { CONFIG_FILE_NAME } = require('../../constant');
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { updateReleaseHistory } from "./updateReleaseHistory.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+
+type Options = {
+    appVersion: string;
+    binaryVersion: string;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    config: string;
+    mandatory?: boolean;
+    enable?: boolean;
+    rollout?: number;
+}
 
 program.command('update-history')
     .description('Updates the release history for a specific binary version.\n`getReleaseHistory`, `setReleaseHistory` functions should be implemented in the config file.')
@@ -13,19 +24,7 @@ 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)
-    /**
-     * @param {Object} options
-     * @param {string} options.appVersion
-     * @param {string} options.binaryVersion
-     * @param {string} options.platform
-     * @param {string} options.identifier
-     * @param {string} options.config
-     * @param {string} options.mandatory
-     * @param {string} options.enable
-     * @param {number} options.rollout
-     * @return {void}
-     */
-    .action(async (options) => {
+    .action(async (options: Options) => {
         const config = findAndReadConfigFile(process.cwd(), options.config);
 
         if (typeof options.mandatory !== "boolean" && typeof options.enable !== "boolean") {
@@ -46,7 +45,7 @@ program.command('update-history')
         )
     });
 
-function parseBoolean(value) {
+function parseBoolean(value: string) {
     if (value === 'true') return true;
     if (value === 'false') return false;
     else return undefined;

package/cli/commands/updateHistoryCommand/{updateReleaseHistory.js → updateReleaseHistory.ts}

@@ -1,42 +1,18 @@
-const fs = require('fs');
-const path = require('path');
-
-/**
- *
- * @param appVersion {string}
- * @param binaryVersion {string}
- * @param getReleaseHistory {
- *   function(
- *     targetBinaryVersion: string,
- *     platform: string,
- *     identifier?: string
- *   ): Promise<ReleaseHistoryInterface>}
- * @param setReleaseHistory {
- *   function(
- *     targetBinaryVersion: string,
- *     jsonFilePath: string,
- *     releaseInfo: ReleaseHistoryInterface,
- *     platform: string,
- *     identifier?: string
- *   ): Promise<void>}
- * @param platform {"ios" | "android"}
- * @param identifier {string?}
- * @param mandatory {boolean?}
- * @param enable {boolean?}
- * @param rollout {number?}
- * @returns {Promise<void>}
- */
-async function updateReleaseHistory(
-    appVersion,
-    binaryVersion,
-    getReleaseHistory,
-    setReleaseHistory,
-    platform,
-    identifier,
-    mandatory,
-    enable,
-    rollout
-) {
+import fs from "fs";
+import path from "path";
+import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+
+export async function updateReleaseHistory(
+    appVersion: string,
+    binaryVersion: string,
+    getReleaseHistory: CliConfigInterface['getReleaseHistory'],
+    setReleaseHistory: CliConfigInterface['setReleaseHistory'],
+    platform: 'ios' | 'android',
+    identifier: string | undefined,
+    mandatory: boolean | undefined,
+    enable: boolean | undefined,
+    rollout: number | undefined,
+): Promise<void> {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
 
     const updateInfo = releaseHistory[appVersion]
@@ -61,5 +37,3 @@ async function updateReleaseHistory(
         process.exit(1)
     }
 }
-
-module.exports = { updateReleaseHistory: updateReleaseHistory }

package/cli/constant.ts

@@ -0,0 +1,4 @@
+export const CONFIG_FILE_NAME = "code-push.config.ts";
+export const OUTPUT_BUNDLE_DIR = "bundleOutput";
+export const ROOT_OUTPUT_DIR = "build";
+export const ENTRY_FILE = "index.ts";

package/cli/dist/commands/bundleCommand/bundleCodePush.js

@@ -0,0 +1,34 @@
+import fs from "fs";
+import { prepareToBundleJS } from "../../functions/prepareToBundleJS.js";
+import { runReactNativeBundleCommand } from "../../functions/runReactNativeBundleCommand.js";
+import { runExpoBundleCommand } from "../../functions/runExpoBundleCommand.js";
+import { getReactTempDir } from "../../functions/getReactTempDir.js";
+import { runHermesEmitBinaryCommand } from "../../functions/runHermesEmitBinaryCommand.js";
+import { makeCodePushBundle } from "../../functions/makeCodePushBundle.js";
+import { ROOT_OUTPUT_DIR, ENTRY_FILE } from "../../constant.js";
+/**
+ * @return {Promise<string>} CodePush bundle file name (equals to packageHash)
+ */
+export async function bundleCodePush(framework, platform = 'ios', outputRootPath = ROOT_OUTPUT_DIR, entryFile = ENTRY_FILE, jsBundleName, // JS bundle file name (not CodePush bundle file)
+bundleDirectory) {
+    if (fs.existsSync(outputRootPath)) {
+        fs.rmSync(outputRootPath, { recursive: true });
+    }
+    const OUTPUT_CONTENT_PATH = `${outputRootPath}/CodePush`;
+    const DEFAULT_JS_BUNDLE_NAME = platform === 'ios' ? 'main.jsbundle' : 'index.android.bundle';
+    const _jsBundleName = jsBundleName || DEFAULT_JS_BUNDLE_NAME; // react-native JS bundle output name
+    const SOURCEMAP_OUTPUT = `${outputRootPath}/${_jsBundleName}.map`;
+    prepareToBundleJS({ deleteDirs: [outputRootPath, getReactTempDir()], makeDir: OUTPUT_CONTENT_PATH });
+    if (framework === 'expo') {
+        runExpoBundleCommand(_jsBundleName, OUTPUT_CONTENT_PATH, platform, SOURCEMAP_OUTPUT, entryFile);
+    }
+    else {
+        runReactNativeBundleCommand(_jsBundleName, OUTPUT_CONTENT_PATH, platform, SOURCEMAP_OUTPUT, entryFile);
+    }
+    console.log('log: JS bundling complete');
+    await runHermesEmitBinaryCommand(_jsBundleName, OUTPUT_CONTENT_PATH, SOURCEMAP_OUTPUT);
+    console.log('log: Hermes compilation complete');
+    const { bundleFileName: codePushBundleFileName } = await makeCodePushBundle(OUTPUT_CONTENT_PATH, bundleDirectory);
+    console.log(`log: CodePush bundle created (file path: ./${bundleDirectory}/${codePushBundleFileName})`);
+    return codePushBundleFileName;
+}

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

@@ -0,0 +1,14 @@
+import { program, Option } from "commander";
+import { bundleCodePush } from "./bundleCodePush.js";
+import { OUTPUT_BUNDLE_DIR, ROOT_OUTPUT_DIR, ENTRY_FILE } from "../../constant.js";
+program.command('bundle')
+    .description('Creates a CodePush bundle file (assumes Hermes is enabled).')
+    .addOption(new Option('-f, --framework <type>', 'framework type (expo)').choices(['expo']))
+    .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
+    .option('-o, --output-path <string>', 'path to output root directory', ROOT_OUTPUT_DIR)
+    .option('-e, --entry-file <string>', 'path to JS/TS entry file', ENTRY_FILE)
+    .option('-b, --bundle-name <string>', 'bundle file name (default-ios: "main.jsbundle" / default-android: "index.android.bundle")')
+    .option('--output-bundle-dir <string>', 'name of directory containing the bundle file created by the "bundle" command', OUTPUT_BUNDLE_DIR)
+    .action((options) => {
+    bundleCodePush(options.framework, options.platform, options.outputPath, options.entryFile, options.bundleName, `${options.outputPath}/${options.outputBundleDir}`);
+});

package/cli/dist/commands/createHistoryCommand/createReleaseHistory.js

@@ -0,0 +1,25 @@
+import fs from "fs";
+import path from "path";
+export async function createReleaseHistory(targetVersion, setReleaseHistory, platform, identifier) {
+    const BINARY_RELEASE = {
+        enabled: true,
+        mandatory: false,
+        downloadUrl: "",
+        packageHash: "",
+    };
+    const INITIAL_HISTORY = {
+        [targetVersion]: BINARY_RELEASE
+    };
+    try {
+        const JSON_FILE_NAME = `${targetVersion}.json`;
+        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
+        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(INITIAL_HISTORY, null, 2));
+        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(INITIAL_HISTORY));
+        await setReleaseHistory(targetVersion, JSON_FILE_PATH, INITIAL_HISTORY, platform, identifier);
+        fs.unlinkSync(JSON_FILE_PATH);
+    }
+    catch (error) {
+        console.error('Error occurred while creating new history:', error);
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { createReleaseHistory } from "./createReleaseHistory.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+program.command('create-history')
+    .description('Creates a new release history for the binary app.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version')
+    .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
+    .option('-i, --identifier <string>', 'reserved characters to distinguish the release.')
+    .option('-c, --config <path>', 'set config file name (JS/TS)', CONFIG_FILE_NAME)
+    .action(async (options) => {
+    const config = findAndReadConfigFile(process.cwd(), options.config);
+    await createReleaseHistory(options.binaryVersion, config.setReleaseHistory, options.platform, options.identifier);
+});

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

@@ -0,0 +1,12 @@
+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/dist/commands/initCommand/initAndroid.js

@@ -0,0 +1,37 @@
+import path from "path";
+import fs from "fs";
+import { EOL } from "os";
+export function modifyMainApplicationKt(mainApplicationContent) {
+    if (mainApplicationContent.includes('CodePush.getJSBundleFile()')) {
+        console.log('log: MainApplication.kt already has CodePush initialized.');
+        return mainApplicationContent;
+    }
+    return mainApplicationContent
+        .replace('import com.facebook.react.ReactApplication', `import com.facebook.react.ReactApplication${EOL}import com.microsoft.codepush.react.CodePush`)
+        .replace('override fun getJSMainModuleName(): String = "index"', `override fun getJSMainModuleName(): String = "index"${EOL}        override fun getJSBundleFile(): String = CodePush.getJSBundleFile()`);
+}
+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 → dist/commands}/initCommand/initIos.js

@@ -1,8 +1,8 @@
-const path = require('path');
-const fs = require('fs');
-const xcode = require('xcode');
-
-async function initIos() {
+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);
@@ -13,85 +13,72 @@ async function initIos() {
     }
     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 {
+    }
+    else {
         await setupObjectiveC(appDelegatePath);
     }
-
     console.log('log: Please run `cd ios && pod install` to complete the setup.');
 }
-
 function findAppDelegate(searchPath) {
-    if (!fs.existsSync(searchPath)) return null;
+    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;
 }
-
-function modifyObjectiveCAppDelegate(appDelegateContent) {
+export function modifyObjectiveCAppDelegate(appDelegateContent) {
     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];');
 }
-
-function modifySwiftAppDelegate(appDelegateContent) {
+export function modifySwiftAppDelegate(appDelegateContent) {
     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) {
     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, projectDir, projectName) {
     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, projectName) {
     const projectPath = path.join(projectDir, `${projectName}.xcodeproj`, 'project.pbxproj');
     const myProj = xcode.project(projectPath);
-
     return new Promise((resolve, reject) => {
         myProj.parse(function (err) {
             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];
@@ -99,30 +86,23 @@ async function ensureBridgingHeader(projectDir, projectName) {
                     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 {
+            }
+            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);
         });
     });
 }
-
-module.exports = {
-    initIos: initIos,
-    modifyObjectiveCAppDelegate: modifyObjectiveCAppDelegate,
-    modifySwiftAppDelegate: modifySwiftAppDelegate,
-}