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

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,
-}

package/cli/dist/commands/initCommand/test/initAndroid.test.js

@@ -0,0 +1,75 @@
+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)
+  }
+}
+`;
+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 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/dist/commands/initCommand/test/initIos.test.js

@@ -0,0 +1,95 @@
+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"];');
+    });
+});

package/cli/dist/commands/releaseCommand/addToReleaseHistory.js

@@ -0,0 +1,32 @@
+import path from "path";
+import fs from "fs";
+export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownloadUrl, packageHash, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout) {
+    const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
+    const updateInfo = releaseHistory[appVersion];
+    if (updateInfo) {
+        console.error(`v${appVersion} is already released`);
+        process.exit(1);
+    }
+    const newReleaseHistory = structuredClone(releaseHistory);
+    newReleaseHistory[appVersion] = {
+        enabled: enable,
+        mandatory: mandatory,
+        downloadUrl: bundleDownloadUrl,
+        packageHash: packageHash,
+    };
+    if (typeof rollout === 'number') {
+        newReleaseHistory[appVersion].rollout = rollout;
+    }
+    try {
+        const JSON_FILE_NAME = `${binaryVersion}.json`;
+        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
+        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(newReleaseHistory, null, 2));
+        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(newReleaseHistory));
+        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, newReleaseHistory, platform, identifier);
+        fs.unlinkSync(JSON_FILE_PATH);
+    }
+    catch (error) {
+        console.error('Error occurred while updating history:', error);
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,38 @@
+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";
+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.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version')
+    .requiredOption('-v, --app-version <string>', '(Required) The app version to be released. It must be greater than the binary version.')
+    .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('-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', ENTRY_FILE)
+    .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('--rollout <number>', 'rollout percentage (0-100)', parseFloat)
+    .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)
+    .action(async (options) => {
+    const config = findAndReadConfigFile(process.cwd(), options.config);
+    if (typeof options.rollout === 'number' && (options.rollout < 0 || options.rollout > 100)) {
+        console.error('Rollout percentage number must be between 0 and 100 (inclusive).');
+        process.exit(1);
+    }
+    await release(config.bundleUploader, config.getReleaseHistory, config.setReleaseHistory, options.binaryVersion, options.appVersion, options.framework, options.platform, options.identifier, options.outputPath, options.entryFile, options.bundleName, options.mandatory, options.enable, options.rollout, options.skipBundle, options.skipCleanup, `${options.outputPath}/${options.outputBundleDir}`);
+    console.log('🚀 Release completed.');
+});
+function parseBoolean(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    else
+        return undefined;
+}

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

@@ -0,0 +1,36 @@
+import fs from "fs";
+import path from "path";
+import { bundleCodePush } from "../bundleCommand/bundleCodePush.js";
+import { addToReleaseHistory } from "./addToReleaseHistory.js";
+export async function release(bundleUploader, getReleaseHistory, setReleaseHistory, binaryVersion, appVersion, framework, platform, identifier, outputPath, entryFile, jsBundleName, mandatory, enable, rollout, skipBundle, skipCleanup, bundleDirectory) {
+    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) {
+    fs.rmSync(dir, { recursive: true });
+}
+function readBundleFileNameFrom(bundleDirectory) {
+    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/dist/commands/showHistoryCommand/index.js

@@ -0,0 +1,14 @@
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+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.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version for retrieving the release 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)
+    .action(async (options) => {
+    const config = findAndReadConfigFile(process.cwd(), options.config);
+    const releaseHistory = await config.getReleaseHistory(options.binaryVersion, options.platform, options.identifier);
+    console.log(JSON.stringify(releaseHistory, null, 2));
+});

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

@@ -0,0 +1,30 @@
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { updateReleaseHistory } from "./updateReleaseHistory.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+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.')
+    .requiredOption('-v, --app-version <string>', '(Required) The app version for which update information is to be modified.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version of the app for which update information is to be modified.')
+    .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)
+    .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)
+    .action(async (options) => {
+    const config = findAndReadConfigFile(process.cwd(), options.config);
+    if (typeof options.mandatory !== "boolean" && typeof options.enable !== "boolean") {
+        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);
+});
+function parseBoolean(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    else
+        return undefined;
+}

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

@@ -0,0 +1,26 @@
+import fs from "fs";
+import path from "path";
+export async function updateReleaseHistory(appVersion, binaryVersion, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout) {
+    const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
+    const updateInfo = releaseHistory[appVersion];
+    if (!updateInfo)
+        throw new Error(`v${appVersion} is not released`);
+    if (typeof mandatory === "boolean")
+        updateInfo.mandatory = mandatory;
+    if (typeof enable === "boolean")
+        updateInfo.enabled = enable;
+    if (typeof rollout === "number")
+        updateInfo.rollout = rollout;
+    try {
+        const JSON_FILE_NAME = `${binaryVersion}.json`;
+        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
+        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(releaseHistory, null, 2));
+        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(releaseHistory));
+        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, releaseHistory, platform, identifier);
+        fs.unlinkSync(JSON_FILE_PATH);
+    }
+    catch (error) {
+        console.error('Error occurred while updating history:', error);
+        process.exit(1);
+    }
+}

package/cli/dist/constant.js

@@ -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/functions/getReactTempDir.js

@@ -0,0 +1,10 @@
+/**
+ * code based on appcenter-cli
+ */
+import os from "os";
+/**
+ * Return the path of the temporary directory for react-native bundling
+ */
+export function getReactTempDir() {
+    return `${os.tmpdir()}/react-*`;
+}

package/cli/{functions → dist/functions}/makeCodePushBundle.js

@@ -1,8 +1,7 @@
-const path = require('path');
-const shell = require('shelljs');
-const zip = require('../utils/zip');
-const {generatePackageHashFromDirectory} = require('../utils/hash-utils');
-
+import path from "path";
+import shell from "shelljs";
+import { zip } from "../utils/zip.js";
+import { generatePackageHashFromDirectory } from "../utils/hash-utils.js";
 /**
  * Create a CodePush bundle file and return the information.
  *
@@ -10,19 +9,14 @@ const {generatePackageHashFromDirectory} = require('../utils/hash-utils');
  * @param bundleDirectory {string} The directory path to save the CodePush bundle file
  * @return {Promise<{ bundleFileName: string }>}
  */
-async function makeCodePushBundle(contentsPath, bundleDirectory) {
+export async function makeCodePushBundle(contentsPath, bundleDirectory) {
     const updateContentsZipPath = await zip(contentsPath);
-
     const packageHash = await generatePackageHashFromDirectory(contentsPath, path.join(contentsPath, '..'));
-
     shell.mkdir('-p', `./${bundleDirectory}`);
     shell.mv(updateContentsZipPath, `./${bundleDirectory}/${packageHash}`);
-
     return {
         // To allow the "release" command to get the file and hash value from the result of the "bundle" command,
         // use the hash value as the name of the file.
         bundleFileName: packageHash,
     };
 }
-
-module.exports = { makeCodePushBundle };

package/cli/{functions → dist/functions}/prepareToBundleJS.js

@@ -1,12 +1,9 @@
-const shell = require('shelljs');
-
+import shell from "shelljs";
 /**
  * @param deleteDirs {string[]} Directories to delete
  * @param makeDir {string} Directory path to create
  */
-function prepareToBundleJS({ deleteDirs, makeDir }) {
+export function prepareToBundleJS({ deleteDirs, makeDir }) {
     shell.rm('-rf', deleteDirs);
     shell.mkdir('-p', makeDir);
 }
-
-module.exports = { prepareToBundleJS };

package/cli/{functions → dist/functions}/runExpoBundleCommand.js

@@ -1,6 +1,5 @@
-const path = require('path');
-const shell = require('shelljs');
-
+import path from "path";
+import shell from "shelljs";
 /**
  * Run `expo bundle` CLI command
  *
@@ -11,23 +10,10 @@ const shell = require('shelljs');
  * @param sourcemapOutput {string} Path to output sourcemap file (Warning: if sourcemapOutput points to the outputPath, the sourcemap will be included in the CodePush bundle and increase the deployment size)
  * @return {void}
  */
-function runExpoBundleCommand(
-    bundleName,
-    outputPath,
-    platform,
-    sourcemapOutput,
-    entryFile,
-) {
-    /**
-     * @return {string}
-     */
+export function runExpoBundleCommand(bundleName, outputPath, platform, sourcemapOutput, entryFile) {
     function getCliPath() {
         return path.join('node_modules', '.bin', 'expo');
     }
-
-    /**
-     * @type {string[]}
-     */
     const expoBundleArgs = [
         'export:embed',
         '--assets-dest',
@@ -44,10 +30,6 @@ function runExpoBundleCommand(
         sourcemapOutput,
         '--reset-cache',
     ];
-
     console.log('Running "expo export:embed" command:\n');
-
     shell.exec(`${getCliPath()} ${expoBundleArgs.join(' ')}`);
 }
-
-module.exports = { runExpoBundleCommand };