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

package/CodePush.js

@@ -1,972 +0,0 @@
-import { Alert } from './AlertAdapter'
-import { AppState, Platform } from 'react-native'
-import log from './logging'
-import hoistStatics from 'hoist-non-react-statics'
-import { SemverVersioning } from './versioning/SemverVersioning'
-
-let NativeCodePush = require('react-native').NativeModules.CodePush
-const PackageMixins = require('./package-mixins')(NativeCodePush)
-
-async function checkForUpdate(
-  prNumber = null,
-  packageHash = null,
-  deploymentKey = null,
-  handleBinaryVersionMismatchCallback = null
-) {
-  /*
-   * Before we ask the server if an update exists, we
-   * need to retrieve three pieces of information from the
-   * native side: deployment key, app version (e.g. 1.0.1)
-   * and the hash of the currently running update (if there is one).
-   * This allows the client to only receive updates which are targetted
-   * for their specific deployment and version and which are actually
-   * different from the CodePush update they have already installed.
-   */
-  const nativeConfig = await getConfiguration()
-  /*
-   * If a deployment key was explicitly provided,
-   * then let's override the one we retrieved
-   * from the native-side of the app. This allows
-   * dynamically "redirecting" end-users at different
-   * deployments (e.g. an early access deployment for insiders).
-   */
-  const config = deploymentKey
-    ? { ...nativeConfig, ...{ deploymentKey } }
-    : nativeConfig
-
-  // Use dynamically overridden getCurrentPackage() during tests.
-  const localPackage = await module.exports.getCurrentPackage()
-
-  /*
-   * If the app has a previously installed update, and that update
-   * was targetted at the same app version that is currently running,
-   * then we want to use its package hash to determine whether a new
-   * release has been made on the server. Otherwise, we only need
-   * to send the app version to the server, since we are interested
-   * in any updates for current binary version, regardless of hash.
-   */
-  let queryPackage
-  if (localPackage) {
-    queryPackage = localPackage
-  } else {
-    queryPackage = { appVersion: config.appVersion }
-    if (Platform.OS === 'ios' && config.packageHash) {
-      queryPackage.packageHash = config.packageHash
-    }
-  }
-
-  const update = await (async () => {
-    try {
-      // refer to `UpdateCheckRequest` type inside code-push SDK
-      const updateRequest = {
-        deployment_key: config.deploymentKey,
-        app_version: queryPackage.appVersion,
-        package_hash: queryPackage.packageHash,
-        is_companion: config.ignoreAppVersion,
-        label: queryPackage.label,
-        client_unique_id: config.clientUniqueId,
-      }
-
-      console.log('updateRequest')
-      console.log(updateRequest)
-
-      /**
-       * @type {updateChecker|undefined}
-       * @deprecated
-       */
-      const updateChecker = sharedCodePushOptions.updateChecker
-      if (updateChecker) {
-        const { update_info } = await updateChecker(updateRequest)
-
-        return mapToRemotePackageMetadata(update_info, config.deploymentKey)
-      } else {
-        /**
-         * `releaseHistory`
-         * @type {ReleaseHistoryInterface}
-         */
-        const releaseHistory =
-          await sharedCodePushOptions.releaseHistoryFetcher(updateRequest)
-
-        const releaseHistoryVersions = Object.keys(releaseHistory)
-
-        console.log('releaseHistory')
-        console.log(releaseHistory)
-
-        console.log('prNumber')
-        console.log(prNumber)
-
-        if (
-          !prNumber &&
-          updateRequest.label &&
-          updateRequest.label.includes('-') &&
-          releaseHistoryVersions.includes(updateRequest.label)
-        ) {
-          // Pull Request 업데이트 체크 후 재시작 시 다시 시작 방지
-          console.log('after updating pull request, skip update check')
-          return
-        }
-
-        const filteredReleaseHistory = prNumber
-          ? Object.entries(releaseHistory)
-              .filter(([key]) => key.includes(prNumber))
-              .reduce((acc, [key, value]) => {
-                const version = key.split('-')[1]
-                acc[version] = value
-                return acc
-              }, {})
-          : Object.entries(releaseHistory)
-              .filter(([key]) => !key.includes('-'))
-              .reduce((acc, [key, value]) => {
-                acc[key] = value
-                return acc
-              }, {})
-
-        console.log('filteredReleaseHistory')
-        console.log(filteredReleaseHistory)
-        /**
-         * `runtimeVersion`
-         * The version of currently running CodePush update. (It can be undefined if the app is running without CodePush update.)
-         * @type {string|undefined}
-         */
-        const runtimeVersion =
-          updateRequest.label && updateRequest.label.includes('-')
-            ? updateRequest.label.split('-')[1]
-            : updateRequest.label
-
-        const versioning = new SemverVersioning(filteredReleaseHistory)
-
-        const shouldRollbackToBinary =
-          versioning.shouldRollbackToBinary(runtimeVersion)
-        if (shouldRollbackToBinary) {
-          // Reset to latest major version and restart
-          CodePush.clearUpdates()
-          CodePush.allowRestart()
-          CodePush.restartApp()
-        }
-
-        const [latestVersion, latestReleaseInfo] =
-          versioning.findLatestRelease()
-        const isMandatory = versioning.checkIsMandatory(runtimeVersion)
-
-        console.log('latestVersion')
-        console.log(latestVersion)
-
-        /**
-         * Convert the update information decided from `ReleaseHistoryInterface` to be passed to the library core (original CodePush library).
-         *
-         * @type {UpdateCheckResponse} the interface required by the original CodePush library.
-         */
-        const updateInfo = {
-          download_url: latestReleaseInfo.downloadUrl,
-          // (`enabled` will always be true in the release information obtained from the previous process.)
-          is_available: latestReleaseInfo.enabled,
-          package_hash: latestReleaseInfo.packageHash,
-          is_mandatory: isMandatory,
-          // 이건 항상 현재 실행중인 바이너리 버전을 전달한다.
-          // 조회한 업데이트가 현재 바이너리를 타겟하는가? 를 API 서버에서 판단한 다음, 해당 된다면 런타임 바이너리 버전을 그대로 돌려주던 것임.
-          // 우리는 updateChecker 조회 결과가 넘어왔다면 해당 정보는 현재 런타임 바이너리에 호환됨을 전제로 하고있음.
-          target_binary_range: updateRequest.app_version,
-          /**
-           * Retrieve the update version from the ReleaseHistory and store it in the label.
-           * This information can be accessed at runtime through the CodePush bundle metadata.
-           */
-          label: prNumber ? `${prNumber}-${latestVersion}` : latestVersion,
-          // false 전달해야 정상 동작함
-          update_app_version: false,
-          // 그닥 쓸모 없음
-          description: '',
-          // 런타임에 안쓰임
-          is_disabled: false,
-          // 런타임에 안쓰임
-          package_size: 0,
-          // 런타임에 안쓰임
-          should_run_binary_version: false,
-        }
-
-        return mapToRemotePackageMetadata(updateInfo, config.deploymentKey)
-      }
-    } catch (error) {
-      log(`An error has occurred at update checker :`)
-      console.error(error)
-      // update will not happen
-      return undefined
-    }
-  })()
-
-  /*
-   * There are four cases where checkForUpdate will resolve to null:
-   * ----------------------------------------------------------------
-   * 1) The server said there isn't an update. This is the most common case.
-   * 2) The server said there is an update but it requires a newer binary version.
-   *    This would occur when end-users are running an older binary version than
-   *    is available, and CodePush is making sure they don't get an update that
-   *    potentially wouldn't be compatible with what they are running.
-   * 3) The server said there is an update, but the update's hash is the same as
-   *    the currently running update. This should _never_ happen, unless there is a
-   *    bug in the server, but we're adding this check just to double-check that the
-   *    client app is resilient to a potential issue with the update check.
-   * 4) The server said there is an update, but the update's hash is the same as that
-   *    of the binary's currently running version. This should only happen in Android -
-   *    unlike iOS, we don't attach the binary's hash to the updateCheck request
-   *    because we want to avoid having to install diff updates against the binary's
-   *    version, which we can't do yet on Android.
-   */
-  if (
-    !update ||
-    update.updateAppVersion ||
-    (localPackage && update.packageHash === localPackage.packageHash) ||
-    ((!localPackage || localPackage._isDebugOnly) &&
-      config.packageHash === update.packageHash)
-  ) {
-    if (update && update.updateAppVersion) {
-      log(
-        'An update is available but it is not targeting the binary version of your app.'
-      )
-      if (
-        handleBinaryVersionMismatchCallback &&
-        typeof handleBinaryVersionMismatchCallback === 'function'
-      ) {
-        handleBinaryVersionMismatchCallback(update)
-      }
-    }
-
-    return null
-  } else {
-    const remotePackage = { ...update, ...PackageMixins.remote() }
-    remotePackage.failedInstall = await NativeCodePush.isFailedUpdate(
-      remotePackage.packageHash
-    )
-    remotePackage.deploymentKey = deploymentKey || nativeConfig.deploymentKey
-    return remotePackage
-  }
-}
-
-/**
- * @param updateInfo {UpdateCheckResponse}
- * @param deploymentKey {string}
- * @return {RemotePackage | null}
- */
-function mapToRemotePackageMetadata(updateInfo, deploymentKey) {
-  if (!updateInfo) {
-    return null
-  } else if (!updateInfo.download_url) {
-    log('download_url is missed in the release history.')
-    return null
-  } else if (!updateInfo.is_available) {
-    return null
-  }
-
-  // refer to `RemotePackage` type inside code-push SDK
-  return {
-    deploymentKey: deploymentKey,
-    description: updateInfo.description ?? '',
-    label: updateInfo.label ?? '',
-    appVersion: updateInfo.target_binary_range ?? '',
-    isMandatory: updateInfo.is_mandatory ?? false,
-    packageHash: updateInfo.package_hash ?? '',
-    packageSize: updateInfo.package_size ?? 0,
-    downloadUrl: updateInfo.download_url ?? '',
-  }
-}
-
-const getConfiguration = (() => {
-  let config
-  return async function getConfiguration() {
-    if (config) {
-      return config
-    } else if (testConfig) {
-      return testConfig
-    } else {
-      config = await NativeCodePush.getConfiguration()
-      return config
-    }
-  }
-})()
-
-async function getCurrentPackage() {
-  return await getUpdateMetadata(CodePush.UpdateState.LATEST)
-}
-
-async function getUpdateMetadata(updateState) {
-  let updateMetadata = await NativeCodePush.getUpdateMetadata(
-    updateState || CodePush.UpdateState.RUNNING
-  )
-
-  if (updateMetadata) {
-    updateMetadata = { ...PackageMixins.local, ...updateMetadata }
-    updateMetadata.failedInstall = await NativeCodePush.isFailedUpdate(
-      updateMetadata.packageHash
-    )
-    updateMetadata.isFirstRun = await NativeCodePush.isFirstRun(
-      updateMetadata.packageHash
-    )
-  }
-  return updateMetadata
-}
-
-// This ensures that notifyApplicationReadyInternal is only called once
-// in the lifetime of this module instance.
-const notifyApplicationReady = (() => {
-  let notifyApplicationReadyPromise
-  return () => {
-    if (!notifyApplicationReadyPromise) {
-      notifyApplicationReadyPromise = notifyApplicationReadyInternal()
-    }
-
-    return notifyApplicationReadyPromise
-  }
-})()
-
-async function notifyApplicationReadyInternal() {
-  await NativeCodePush.notifyApplicationReady()
-  const statusReport = await NativeCodePush.getNewStatusReport()
-  statusReport && tryReportStatus(statusReport) // Don't wait for this to complete.
-
-  return statusReport
-}
-
-async function tryReportStatus(statusReport, retryOnAppResume) {
-  const config = await getConfiguration()
-
-  try {
-    if (statusReport.appVersion) {
-      log(`Reporting binary update (${statusReport.appVersion})`)
-
-      if (!config.deploymentKey) {
-        throw new Error('Deployment key is missed')
-      }
-    } else {
-      const label = statusReport.package.label
-      if (statusReport.status === 'DeploymentSucceeded') {
-        log(`Reporting CodePush update success (${label})`)
-      } else {
-        log(`Reporting CodePush update rollback (${label})`)
-        await NativeCodePush.setLatestRollbackInfo(
-          statusReport.package.packageHash
-        )
-      }
-    }
-
-    NativeCodePush.recordStatusReported(statusReport)
-    retryOnAppResume && retryOnAppResume.remove()
-  } catch (e) {
-    log(`Report status failed: ${JSON.stringify(statusReport)}`)
-    NativeCodePush.saveStatusReportForRetry(statusReport)
-    // Try again when the app resumes
-    if (!retryOnAppResume) {
-      const resumeListener = AppState.addEventListener(
-        'change',
-        async (newState) => {
-          if (newState !== 'active') return
-          const refreshedStatusReport =
-            await NativeCodePush.getNewStatusReport()
-          if (refreshedStatusReport) {
-            tryReportStatus(refreshedStatusReport, resumeListener)
-          } else {
-            resumeListener && resumeListener.remove()
-          }
-        }
-      )
-    }
-  }
-}
-
-async function shouldUpdateBeIgnored(remotePackage, syncOptions) {
-  let { rollbackRetryOptions } = syncOptions
-
-  const isFailedPackage = remotePackage && remotePackage.failedInstall
-  if (!isFailedPackage || !syncOptions.ignoreFailedUpdates) {
-    return false
-  }
-
-  if (!rollbackRetryOptions) {
-    return true
-  }
-
-  if (typeof rollbackRetryOptions !== 'object') {
-    rollbackRetryOptions = CodePush.DEFAULT_ROLLBACK_RETRY_OPTIONS
-  } else {
-    rollbackRetryOptions = {
-      ...CodePush.DEFAULT_ROLLBACK_RETRY_OPTIONS,
-      ...rollbackRetryOptions,
-    }
-  }
-
-  if (!validateRollbackRetryOptions(rollbackRetryOptions)) {
-    return true
-  }
-
-  const latestRollbackInfo = await NativeCodePush.getLatestRollbackInfo()
-  if (
-    !validateLatestRollbackInfo(latestRollbackInfo, remotePackage.packageHash)
-  ) {
-    log('The latest rollback info is not valid.')
-    return true
-  }
-
-  const { delayInHours, maxRetryAttempts } = rollbackRetryOptions
-  const hoursSinceLatestRollback =
-    (Date.now() - latestRollbackInfo.time) / (1000 * 60 * 60)
-  if (
-    hoursSinceLatestRollback >= delayInHours &&
-    maxRetryAttempts >= latestRollbackInfo.count
-  ) {
-    log('Previous rollback should be ignored due to rollback retry options.')
-    return false
-  }
-
-  return true
-}
-
-function validateLatestRollbackInfo(latestRollbackInfo, packageHash) {
-  return (
-    latestRollbackInfo &&
-    latestRollbackInfo.time &&
-    latestRollbackInfo.count &&
-    latestRollbackInfo.packageHash &&
-    latestRollbackInfo.packageHash === packageHash
-  )
-}
-
-function validateRollbackRetryOptions(rollbackRetryOptions) {
-  if (typeof rollbackRetryOptions.delayInHours !== 'number') {
-    log("The 'delayInHours' rollback retry parameter must be a number.")
-    return false
-  }
-
-  if (typeof rollbackRetryOptions.maxRetryAttempts !== 'number') {
-    log("The 'maxRetryAttempts' rollback retry parameter must be a number.")
-    return false
-  }
-
-  if (rollbackRetryOptions.maxRetryAttempts < 1) {
-    log(
-      "The 'maxRetryAttempts' rollback retry parameter cannot be less then 1."
-    )
-    return false
-  }
-
-  return true
-}
-
-let testConfig
-
-// This function is only used for tests. Replaces the default SDK, configuration and native bridge
-function setUpTestDependencies(testSdk, providedTestConfig, testNativeBridge) {
-  if (testSdk) module.exports.AcquisitionSdk = testSdk
-  if (providedTestConfig) testConfig = providedTestConfig
-  if (testNativeBridge) NativeCodePush = testNativeBridge
-}
-
-async function restartApp(onlyIfUpdateIsPending = false) {
-  NativeCodePush.restartApp(onlyIfUpdateIsPending)
-}
-
-// This function allows only one syncInternal operation to proceed at any given time.
-// Parallel calls to sync() while one is ongoing yields CodePush.SyncStatus.SYNC_IN_PROGRESS.
-const sync = (() => {
-  let syncInProgress = false
-  const setSyncCompleted = () => {
-    syncInProgress = false
-  }
-
-  return (
-    options = {},
-    syncStatusChangeCallback,
-    downloadProgressCallback,
-    handleBinaryVersionMismatchCallback
-  ) => {
-    let syncStatusCallbackWithTryCatch, downloadProgressCallbackWithTryCatch
-    if (typeof syncStatusChangeCallback === 'function') {
-      syncStatusCallbackWithTryCatch = (...args) => {
-        try {
-          syncStatusChangeCallback(...args)
-        } catch (error) {
-          log(`An error has occurred : ${error.stack}`)
-        }
-      }
-    }
-
-    if (typeof downloadProgressCallback === 'function') {
-      downloadProgressCallbackWithTryCatch = (...args) => {
-        try {
-          downloadProgressCallback(...args)
-        } catch (error) {
-          log(`An error has occurred: ${error.stack}`)
-        }
-      }
-    }
-
-    if (syncInProgress) {
-      typeof syncStatusCallbackWithTryCatch === 'function'
-        ? syncStatusCallbackWithTryCatch(CodePush.SyncStatus.SYNC_IN_PROGRESS)
-        : log('Sync already in progress.')
-      return Promise.resolve(CodePush.SyncStatus.SYNC_IN_PROGRESS)
-    }
-
-    syncInProgress = true
-    const syncPromise = syncInternal(
-      options,
-      syncStatusCallbackWithTryCatch,
-      downloadProgressCallbackWithTryCatch,
-      handleBinaryVersionMismatchCallback
-    )
-    syncPromise.then(setSyncCompleted).catch(setSyncCompleted)
-
-    return syncPromise
-  }
-})()
-
-/*
- * The syncInternal method provides a simple, one-line experience for
- * incorporating the check, download and installation of an update.
- *
- * It simply composes the existing API methods together and adds additional
- * support for respecting mandatory updates, ignoring previously failed
- * releases, and displaying a standard confirmation UI to the end-user
- * when an update is available.
- */
-async function syncInternal(
-  options = {},
-  syncStatusChangeCallback,
-  downloadProgressCallback,
-  handleBinaryVersionMismatchCallback
-) {
-  let resolvedInstallMode
-  const syncOptions = {
-    deploymentKey: null,
-    ignoreFailedUpdates: true,
-    rollbackRetryOptions: null,
-    installMode: CodePush.InstallMode.ON_NEXT_RESTART,
-    mandatoryInstallMode: CodePush.InstallMode.IMMEDIATE,
-    minimumBackgroundDuration: 0,
-    updateDialog: null,
-    ...options,
-  }
-
-  syncStatusChangeCallback =
-    typeof syncStatusChangeCallback === 'function'
-      ? syncStatusChangeCallback
-      : (syncStatus) => {
-          switch (syncStatus) {
-            case CodePush.SyncStatus.CHECKING_FOR_UPDATE:
-              log('Checking for update.')
-              break
-            case CodePush.SyncStatus.AWAITING_USER_ACTION:
-              log('Awaiting user action.')
-              break
-            case CodePush.SyncStatus.DOWNLOADING_PACKAGE:
-              log('Downloading package.')
-              break
-            case CodePush.SyncStatus.INSTALLING_UPDATE:
-              log('Installing update.')
-              break
-            case CodePush.SyncStatus.UP_TO_DATE:
-              log('App is up to date.')
-              break
-            case CodePush.SyncStatus.UPDATE_IGNORED:
-              log('User cancelled the update.')
-              break
-            case CodePush.SyncStatus.UPDATE_INSTALLED:
-              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.`
-                  )
-                } else {
-                  log(
-                    'Update is installed and will be run when the app next resumes.'
-                  )
-                }
-              }
-              break
-            case CodePush.SyncStatus.PREPARING_UPDATE:
-              log('Download complete. Preparing update (unzip/file-copy).')
-              break
-            case CodePush.SyncStatus.UNKNOWN_ERROR:
-              log('An unknown error occurred.')
-              break
-          }
-        }
-
-  try {
-    await CodePush.notifyApplicationReady()
-
-    syncStatusChangeCallback(CodePush.SyncStatus.CHECKING_FOR_UPDATE)
-    console.log('syncOptions')
-    console.log(syncOptions)
-    const remotePackage = await checkForUpdate(
-      syncOptions.prNumber,
-      syncOptions.packageHash,
-      syncOptions.deploymentKey,
-      handleBinaryVersionMismatchCallback
-    )
-
-    const doDownloadAndInstall = async () => {
-      syncStatusChangeCallback(CodePush.SyncStatus.DOWNLOADING_PACKAGE)
-      const localPackage = await remotePackage.download(
-        downloadProgressCallback,
-        () => {
-          // HTTP download complete, post-processing (unzip/file-copy) starts
-          syncStatusChangeCallback(CodePush.SyncStatus.PREPARING_UPDATE)
-        }
-      )
-
-      // Determine the correct install mode based on whether the update is mandatory or not.
-      resolvedInstallMode = localPackage.isMandatory
-        ? syncOptions.mandatoryInstallMode
-        : syncOptions.installMode
-
-      syncStatusChangeCallback(CodePush.SyncStatus.INSTALLING_UPDATE)
-      await localPackage.install(
-        resolvedInstallMode,
-        syncOptions.minimumBackgroundDuration,
-        () => {
-          syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_INSTALLED)
-        }
-      )
-
-      return CodePush.SyncStatus.UPDATE_INSTALLED
-    }
-
-    const updateShouldBeIgnored = await shouldUpdateBeIgnored(
-      remotePackage,
-      syncOptions
-    )
-
-    if (!remotePackage || updateShouldBeIgnored) {
-      if (updateShouldBeIgnored) {
-        log(
-          'An update is available, but it is being ignored due to having been previously rolled back.'
-        )
-      }
-
-      const currentPackage = await CodePush.getCurrentPackage()
-      if (currentPackage && currentPackage.isPending) {
-        syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_INSTALLED)
-        return CodePush.SyncStatus.UPDATE_INSTALLED
-      } else {
-        syncStatusChangeCallback(CodePush.SyncStatus.UP_TO_DATE)
-        return CodePush.SyncStatus.UP_TO_DATE
-      }
-    } else if (syncOptions.updateDialog) {
-      // updateDialog supports any truthy value (e.g. true, "goo", 12),
-      // but we should treat a non-object value as just the default dialog
-      if (typeof syncOptions.updateDialog !== 'object') {
-        syncOptions.updateDialog = CodePush.DEFAULT_UPDATE_DIALOG
-      } else {
-        syncOptions.updateDialog = {
-          ...CodePush.DEFAULT_UPDATE_DIALOG,
-          ...syncOptions.updateDialog,
-        }
-      }
-
-      return await new Promise((resolve, reject) => {
-        let message = null
-        let installButtonText = null
-
-        const dialogButtons = []
-
-        if (remotePackage.isMandatory) {
-          message = syncOptions.updateDialog.mandatoryUpdateMessage
-          installButtonText =
-            syncOptions.updateDialog.mandatoryContinueButtonLabel
-        } else {
-          message = syncOptions.updateDialog.optionalUpdateMessage
-          installButtonText =
-            syncOptions.updateDialog.optionalInstallButtonLabel
-          // Since this is an optional update, add a button
-          // to allow the end-user to ignore it
-          dialogButtons.push({
-            text: syncOptions.updateDialog.optionalIgnoreButtonLabel,
-            onPress: () => {
-              syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_IGNORED)
-              resolve(CodePush.SyncStatus.UPDATE_IGNORED)
-            },
-          })
-        }
-
-        // Since the install button should be placed to the
-        // right of any other button, add it last
-        dialogButtons.push({
-          text: installButtonText,
-          onPress: () => {
-            doDownloadAndInstall().then(resolve, reject)
-          },
-        })
-
-        // If the update has a description, and the developer
-        // explicitly chose to display it, then set that as the message
-        if (
-          syncOptions.updateDialog.appendReleaseDescription &&
-          remotePackage.description
-        ) {
-          message += `${syncOptions.updateDialog.descriptionPrefix} ${remotePackage.description}`
-        }
-
-        syncStatusChangeCallback(CodePush.SyncStatus.AWAITING_USER_ACTION)
-        Alert.alert(syncOptions.updateDialog.title, message, dialogButtons)
-      })
-    } else {
-      return await doDownloadAndInstall()
-    }
-  } catch (error) {
-    syncStatusChangeCallback(CodePush.SyncStatus.UNKNOWN_ERROR)
-    log(error.message)
-    throw error
-  }
-}
-
-let CodePush
-
-/**
- * @callback releaseHistoryFetcher
- * @param {UpdateCheckRequest} updateRequest Current package information to check for updates.
- * @returns {Promise<ReleaseHistoryInterface>} The release history of the updates deployed for a specific binary version.
- */
-
-/**
- * @callback updateChecker
- * @param {UpdateCheckRequest} updateRequest Current package information to check for updates.
- * @returns {Promise<{update_info: UpdateCheckResponse}>} The result of the update check. Follows the AppCenter API response interface.
- *
- * @deprecated It will be removed in the next major version.
- */
-
-/**
- * If you pass options once when calling `codePushify`, they will be shared with related functions.
- * @type {{
- *   releaseHistoryFetcher: releaseHistoryFetcher | undefined,
- *   setReleaseHistoryFetcher(releaseHistoryFetcherFunction: releaseHistoryFetcher | undefined): void,
- *   updateChecker: updateChecker | undefined,
- *   setUpdateChecker(updateCheckerFunction: updateChecker | undefined): void,
- * }}
- */
-const sharedCodePushOptions = {
-  releaseHistoryFetcher: undefined,
-  setReleaseHistoryFetcher(releaseHistoryFetcherFunction) {
-    if (
-      !releaseHistoryFetcherFunction ||
-      typeof releaseHistoryFetcherFunction !== 'function'
-    )
-      throw new Error('Please implement the releaseHistoryFetcher function')
-    this.releaseHistoryFetcher = releaseHistoryFetcherFunction
-  },
-  updateChecker: undefined,
-  setUpdateChecker(updateCheckerFunction) {
-    if (!updateCheckerFunction) return
-    if (typeof updateCheckerFunction !== 'function')
-      throw new Error('Please pass a function to updateChecker')
-    this.updateChecker = updateCheckerFunction
-  },
-}
-
-function codePushify(options = {}) {
-  let React
-  let ReactNative = require('react-native')
-
-  try {
-    React = require('react')
-  } catch (e) {}
-  if (!React) {
-    try {
-      React = ReactNative.React
-    } catch (e) {}
-    if (!React) {
-      throw new Error("Unable to find the 'React' module.")
-    }
-  }
-
-  if (!React.Component) {
-    throw new Error(
-      `Unable to find the "Component" class, please either:
-1. Upgrade to a newer version of React Native that supports it, or
-2. Call the codePush.sync API in your component instead of using the @codePush decorator`
-    )
-  }
-
-  if (options.updateChecker && !options.releaseHistoryFetcher) {
-    throw new Error(
-      'If you want to use `updateChecker`, pass a no-op function to releaseHistoryFetcher option. (e.g. `releaseHistoryFetcher: async () => ({})`)'
-    )
-  }
-
-  sharedCodePushOptions.setReleaseHistoryFetcher(options.releaseHistoryFetcher)
-  sharedCodePushOptions.setUpdateChecker(options.updateChecker)
-
-  const decorator = (RootComponent) => {
-    class CodePushComponent extends React.Component {
-      constructor(props) {
-        super(props)
-        this.rootComponentRef = React.createRef()
-      }
-
-      componentDidMount() {
-        if (options.checkFrequency === CodePush.CheckFrequency.MANUAL) {
-          CodePush.notifyAppReady()
-        } else {
-          const rootComponentInstance = this.rootComponentRef.current
-
-          let syncStatusCallback
-          if (
-            rootComponentInstance &&
-            rootComponentInstance.codePushStatusDidChange
-          ) {
-            syncStatusCallback =
-              rootComponentInstance.codePushStatusDidChange.bind(
-                rootComponentInstance
-              )
-          }
-
-          let downloadProgressCallback
-          if (
-            rootComponentInstance &&
-            rootComponentInstance.codePushDownloadDidProgress
-          ) {
-            downloadProgressCallback =
-              rootComponentInstance.codePushDownloadDidProgress.bind(
-                rootComponentInstance
-              )
-          }
-
-          let handleBinaryVersionMismatchCallback
-          if (
-            rootComponentInstance &&
-            rootComponentInstance.codePushOnBinaryVersionMismatch
-          ) {
-            handleBinaryVersionMismatchCallback =
-              rootComponentInstance.codePushOnBinaryVersionMismatch.bind(
-                rootComponentInstance
-              )
-          }
-
-          CodePush.sync(
-            options,
-            syncStatusCallback,
-            downloadProgressCallback,
-            handleBinaryVersionMismatchCallback
-          )
-
-          if (
-            options.checkFrequency === CodePush.CheckFrequency.ON_APP_RESUME
-          ) {
-            ReactNative.AppState.addEventListener('change', (newState) => {
-              if (newState === 'active') {
-                CodePush.sync(
-                  options,
-                  syncStatusCallback,
-                  downloadProgressCallback
-                )
-              }
-            })
-          }
-        }
-      }
-
-      render() {
-        const props = { ...this.props }
-
-        // We can set ref property on class components only (not stateless)
-        // Check it by render method
-        if (RootComponent.prototype && RootComponent.prototype.render) {
-          props.ref = this.rootComponentRef
-        }
-
-        return <RootComponent {...props} />
-      }
-    }
-
-    return hoistStatics(CodePushComponent, RootComponent)
-  }
-
-  if (typeof options === 'function') {
-    // Infer that the root component was directly passed to us.
-    return decorator(options)
-  } else {
-    return decorator
-  }
-}
-
-// If the "NativeCodePush" variable isn't defined, then
-// the app didn't properly install the native module,
-// and therefore, it doesn't make sense initializing
-// the JS interface when it wouldn't work anyways.
-if (NativeCodePush) {
-  CodePush = codePushify
-  Object.assign(CodePush, {
-    checkForUpdate,
-    getConfiguration,
-    getCurrentPackage,
-    getUpdateMetadata,
-    log,
-    notifyAppReady: notifyApplicationReady,
-    notifyApplicationReady,
-    restartApp,
-    setUpTestDependencies,
-    sync,
-    disallowRestart: NativeCodePush.disallow,
-    allowRestart: NativeCodePush.allow,
-    clearUpdates: NativeCodePush.clearUpdates,
-    InstallMode: {
-      IMMEDIATE: NativeCodePush.codePushInstallModeImmediate, // Restart the app immediately
-      ON_NEXT_RESTART: NativeCodePush.codePushInstallModeOnNextRestart, // Don't artificially restart the app. Allow the update to be "picked up" on the next app restart
-      ON_NEXT_RESUME: NativeCodePush.codePushInstallModeOnNextResume, // Restart the app the next time it is resumed from the background
-      ON_NEXT_SUSPEND: NativeCodePush.codePushInstallModeOnNextSuspend, // Restart the app _while_ it is in the background,
-      // but only after it has been in the background for "minimumBackgroundDuration" seconds (0 by default),
-      // so that user context isn't lost unless the app suspension is long enough to not matter
-    },
-    SyncStatus: {
-      UP_TO_DATE: 0, // The running app is up-to-date
-      UPDATE_INSTALLED: 1, // The app had an optional/mandatory update that was successfully downloaded and is about to be installed.
-      UPDATE_IGNORED: 2, // The app had an optional update and the end-user chose to ignore it
-      UNKNOWN_ERROR: 3,
-      SYNC_IN_PROGRESS: 4, // There is an ongoing "sync" operation in progress.
-      CHECKING_FOR_UPDATE: 5,
-      AWAITING_USER_ACTION: 6,
-      DOWNLOADING_PACKAGE: 7,
-      INSTALLING_UPDATE: 8,
-      PREPARING_UPDATE: 9, // HTTP download complete, post-processing (unzip/file-copy) in progress
-    },
-    CheckFrequency: {
-      ON_APP_START: 0,
-      ON_APP_RESUME: 1,
-      MANUAL: 2,
-    },
-    UpdateState: {
-      RUNNING: NativeCodePush.codePushUpdateStateRunning,
-      PENDING: NativeCodePush.codePushUpdateStatePending,
-      LATEST: NativeCodePush.codePushUpdateStateLatest,
-    },
-    DeploymentStatus: {
-      FAILED: 'DeploymentFailed',
-      SUCCEEDED: 'DeploymentSucceeded',
-    },
-    DEFAULT_UPDATE_DIALOG: {
-      appendReleaseDescription: false,
-      descriptionPrefix: ' Description: ',
-      mandatoryContinueButtonLabel: 'Continue',
-      mandatoryUpdateMessage: 'An update is available that must be installed.',
-      optionalIgnoreButtonLabel: 'Ignore',
-      optionalInstallButtonLabel: 'Install',
-      optionalUpdateMessage:
-        'An update is available. Would you like to install it?',
-      title: 'Update available',
-    },
-    DEFAULT_ROLLBACK_RETRY_OPTIONS: {
-      delayInHours: 24,
-      maxRetryAttempts: 1,
-    },
-  })
-} else {
-  log(
-    "The CodePush module doesn't appear to be properly installed. Please double-check that everything is setup correctly."
-  )
-}
-
-module.exports = CodePush