@appzung/react-native-code-push 10.0.0-rc1 → 10.0.1

package/src/CodePush.tsx

@@ -0,0 +1,108 @@
+import hoistStatics from 'hoist-non-react-statics';
+import React from 'react';
+import { AppState } from 'react-native';
+import { CheckFrequency } from './enums/CheckFrequency.enum';
+import { notifyAppReady } from './notifyAppReady';
+import { sync } from './sync';
+import type {
+  DownloadProgressCallback,
+  HandleBinaryVersionMismatchCallback,
+  SyncOptions,
+  SyncStatusChangedCallback,
+} from './types';
+
+export interface CodePushOptions extends SyncOptions {
+  /**
+   * Specifies when you would like to synchronize updates with the CodePush server.
+   * Defaults to codePush.CheckFrequency.ON_APP_START.
+   */
+  checkFrequency?: CheckFrequency;
+}
+
+/**
+ * Decorates a React Component configuring it to sync for updates with the CodePush server.
+ *
+ * @param component the React Component that will be decorated
+ */
+// @ts-ignore
+export function withCodePush(component: any): React.FunctionComponent;
+
+/**
+ * Decorates a React Component configuring it to sync for updates with the CodePush server.
+ *
+ * @param options Options used to configure the end-user sync and update experience (e.g. when to check for updates?, show a prompt?, install the update immediately?).
+ */
+export function withCodePush(options: CodePushOptions): (component: any) => React.FunctionComponent;
+
+export function withCodePush<P extends object>(optionsOrComponent: CodePushOptions | React.ComponentType<P>) {
+  const options: CodePushOptions = typeof optionsOrComponent === 'function' ? {} : optionsOrComponent;
+
+  const WithCodePush = (RootComponent: React.ComponentType<P>) => {
+    class CodePushComponent extends React.Component<P> {
+      rootComponentRef: React.RefObject<any>;
+
+      constructor(props: never) {
+        super(props);
+        this.rootComponentRef = React.createRef();
+      }
+
+      componentDidMount() {
+        if (options.checkFrequency === CheckFrequency.MANUAL) {
+          notifyAppReady();
+        } else {
+          const rootComponentInstance = this.rootComponentRef.current;
+
+          let syncStatusCallback: SyncStatusChangedCallback | undefined;
+          if (rootComponentInstance && rootComponentInstance.codePushStatusDidChange) {
+            syncStatusCallback = rootComponentInstance.codePushStatusDidChange.bind(rootComponentInstance);
+          }
+
+          let downloadProgressCallback: DownloadProgressCallback | undefined;
+          if (rootComponentInstance && rootComponentInstance.codePushDownloadDidProgress) {
+            downloadProgressCallback = rootComponentInstance.codePushDownloadDidProgress.bind(rootComponentInstance);
+          }
+
+          let handleBinaryVersionMismatchCallback: HandleBinaryVersionMismatchCallback | undefined;
+          if (rootComponentInstance && rootComponentInstance.codePushOnBinaryVersionMismatch) {
+            handleBinaryVersionMismatchCallback =
+              rootComponentInstance.codePushOnBinaryVersionMismatch.bind(rootComponentInstance);
+          }
+
+          sync(options, syncStatusCallback, downloadProgressCallback, handleBinaryVersionMismatchCallback);
+
+          if (options.checkFrequency === CheckFrequency.ON_APP_RESUME) {
+            AppState.addEventListener('change', (newState: string) => {
+              if (newState === 'active') {
+                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) {
+          // @ts-ignore
+          props.ref = this.rootComponentRef;
+        }
+
+        return <RootComponent {...props} />;
+      }
+    }
+
+    return hoistStatics(CodePushComponent, RootComponent);
+  };
+
+  if (typeof optionsOrComponent === 'function') {
+    // Infer that the root component was directly passed to us.
+    return WithCodePush(optionsOrComponent);
+  } else {
+    return WithCodePush;
+  }
+}
+
+export default withCodePush;

package/src/allowRestart.ts

@@ -0,0 +1,6 @@
+import { NativeRNAppZungCodePushModule } from './internals/NativeRNAppZungCodePushModule';
+
+/**
+ * Allow CodePush to restart the app.
+ */
+export const allowRestart: () => void = NativeRNAppZungCodePushModule.allow;

package/src/checkForUpdates.ts

@@ -0,0 +1,109 @@
+import { Platform } from 'react-native';
+import { NativeRNAppZungCodePushModule } from './internals/NativeRNAppZungCodePushModule';
+import { RemotePackageImpl } from './internals/RemotePackageImplementation';
+import { getConfiguration } from './internals/getConfiguration';
+import { getCurrentPackage } from './internals/getCurrentPackage';
+import { type PromisifiedSdkQueryPackage, getPromisifiedSdk } from './internals/getPromisifiedSdk';
+import type { Configuration } from './internals/types';
+import { log } from './internals/utils/log';
+import { requestFetchAdapter } from './internals/utils/request-fetch-adapter';
+import type { HandleBinaryVersionMismatchCallback, RemotePackage } from './types';
+
+/**
+ * Asks the CodePush service whether the configured app release channel has an update available.
+ *
+ * @param releaseChannelPublicId The release channel public ID to use to query the CodePush server for an update.
+ * @param handleBinaryVersionMismatchCallback An optional callback for handling target binary version mismatch
+ */
+export async function checkForUpdate(
+  releaseChannelPublicId?: string,
+  handleBinaryVersionMismatchCallback?: HandleBinaryVersionMismatchCallback,
+): Promise<RemotePackage | null> {
+  /*
+   * Before we ask the server if an update exists, we
+   * need to retrieve three pieces of information from the
+   * native side: release channel, 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 targeted
+   * for their specific release channel and version and which are actually
+   * different from the CodePush update they have already installed.
+   */
+  const nativeConfig = await getConfiguration();
+  /*
+   * If a release channel 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
+   * release channels (e.g. an early access release channel for insiders).
+   */
+  const config: Configuration = releaseChannelPublicId
+    ? { ...nativeConfig, ...{ releaseChannelPublicId } }
+    : nativeConfig;
+  const sdk = getPromisifiedSdk(requestFetchAdapter, config);
+
+  const localPackage = await getCurrentPackage();
+
+  /*
+   * If the app has a previously installed update, and that update
+   * was targeted 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: PromisifiedSdkQueryPackage;
+  if (localPackage) {
+    queryPackage = localPackage;
+  } else {
+    queryPackage = { appVersion: config.appVersion };
+    if (Platform.OS === 'ios' && config.packageHash) {
+      queryPackage.packageHash = config.packageHash;
+    }
+  }
+
+  const update = await sdk.queryUpdateWithCurrentPackage(queryPackage);
+
+  /*
+   * 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) {
+    return null;
+  }
+
+  if ('updateAppVersion' in update && update.updateAppVersion) {
+    log('An update is available but it is not targeting the binary version of your app.');
+    handleBinaryVersionMismatchCallback?.(update);
+
+    return null;
+  }
+
+  if (
+    (localPackage && 'packageHash' in update && update.packageHash === localPackage.packageHash) ||
+    ((!localPackage || ('_isDebugOnly' in localPackage && localPackage._isDebugOnly)) &&
+      'packageHash' in update &&
+      config.packageHash === update.packageHash)
+  ) {
+    return null;
+  }
+
+  // @ts-expect-error sdk typing is wrong
+  const remotePackage = new RemotePackageImpl(update, sdk.reportStatusDownload);
+  remotePackage.failedInstall = await NativeRNAppZungCodePushModule.isFailedUpdate(remotePackage.packageHash);
+  remotePackage.releaseChannelPublicId = releaseChannelPublicId || nativeConfig.releaseChannelPublicId;
+  return remotePackage;
+}

package/src/clearUpdates.ts

@@ -0,0 +1,9 @@
+import { NativeRNAppZungCodePushModule } from './internals/NativeRNAppZungCodePushModule';
+
+/**
+ * Clears all downloaded CodePush updates.
+ * This is useful when switching to a different release channel which may have an older release than the current package.
+ * Note: we don’t recommend to use this method in scenarios other than that (CodePush will call
+ * this method automatically when needed in other cases) as it could lead to unpredictable behavior.
+ */
+export const clearUpdates: () => void = NativeRNAppZungCodePushModule.clearUpdates;

package/src/disallowRestart.ts

@@ -0,0 +1,6 @@
+import { NativeRNAppZungCodePushModule } from './internals/NativeRNAppZungCodePushModule';
+
+/**
+ * Forbid CodePush to restart the app.
+ */
+export const disallowRestart: () => void = NativeRNAppZungCodePushModule.disallow;

package/src/enums/CheckFrequency.enum.ts

@@ -0,0 +1,19 @@
+/**
+ * Indicates when you would like to check for (and install) updates from the CodePush server.
+ */
+export enum CheckFrequency {
+  /**
+   * When the app is fully initialized (or more specifically, when the root component is mounted).
+   */
+  ON_APP_START,
+
+  /**
+   * When the app re-enters the foreground.
+   */
+  ON_APP_RESUME,
+
+  /**
+   * Don't automatically check for updates, but only do it when codePush.sync() is manually called inside app code.
+   */
+  MANUAL,
+}

package/src/enums/DeploymentStatus.enum.ts

@@ -0,0 +1,14 @@
+/**
+ * Indicates the status of a deployment (after installing and restarting).
+ */
+export enum DeploymentStatus {
+  /**
+   * The deployment failed (and was rolled back).
+   */
+  FAILED = 'DeploymentFailed',
+
+  /**
+   * The deployment succeeded.
+   */
+  SUCCEEDED = 'DeploymentSucceeded',
+}

package/src/enums/InstallMode.enum.ts

@@ -0,0 +1,31 @@
+import { NativeRNAppZungCodePushModule } from '../internals/NativeRNAppZungCodePushModule';
+
+/**
+ * Indicates when you would like an installed update to actually be applied.
+ */
+export enum InstallMode {
+  /**
+   * Indicates that you want to install the update and restart the app immediately.
+   */
+  IMMEDIATE = NativeRNAppZungCodePushModule.getConstants().codePushInstallModeImmediate,
+
+  /**
+   * Indicates that you want to install the update, but not forcibly restart the app.
+   */
+  ON_NEXT_RESTART = NativeRNAppZungCodePushModule.getConstants().codePushInstallModeOnNextRestart,
+
+  /**
+   * Indicates that you want to install the update, but don't want to restart the app until the next time
+   * the end user resumes it from the background. This way, you don't disrupt their current session,
+   * but you can get the update in front of them sooner than having to wait for the next natural restart.
+   * This value is appropriate for silent installs that can be applied on resume in a non-invasive way.
+   */
+  ON_NEXT_RESUME = NativeRNAppZungCodePushModule.getConstants().codePushInstallModeOnNextResume,
+
+  /**
+   * Indicates that you want to install the update when the app 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.
+   */
+  ON_NEXT_SUSPEND = NativeRNAppZungCodePushModule.getConstants().codePushInstallModeOnNextSuspend,
+}

package/src/enums/SyncStatus.enum.ts

@@ -0,0 +1,53 @@
+/**
+ * Indicates the current status of a sync operation.
+ */
+export enum SyncStatus {
+  /**
+   * The app is up-to-date with the CodePush server.
+   */
+  UP_TO_DATE,
+
+  /**
+   * An available update has been installed and will be run either immediately after the
+   * syncStatusChangedCallback function returns or the next time the app resumes/restarts,
+   * depending on the InstallMode specified in SyncOptions
+   */
+  UPDATE_INSTALLED,
+
+  /**
+   * The app had an optional update which the end user chose to ignore.
+   * (This is only applicable when the updateDialog is used)
+   */
+  UPDATE_IGNORED,
+
+  /**
+   * The sync operation encountered an unknown error.
+   */
+  UNKNOWN_ERROR,
+
+  /**
+   * There is an ongoing sync operation running which prevents the current call from being executed.
+   */
+  SYNC_IN_PROGRESS,
+
+  /**
+   * The CodePush server is being queried for an update.
+   */
+  CHECKING_FOR_UPDATE,
+
+  /**
+   * An update is available, and a confirmation dialog was shown
+   * to the end user. (This is only applicable when the updateDialog is used)
+   */
+  AWAITING_USER_ACTION,
+
+  /**
+   * An available update is being downloaded from the CodePush server.
+   */
+  DOWNLOADING_PACKAGE,
+
+  /**
+   * An available update was downloaded and is about to be installed.
+   */
+  INSTALLING_UPDATE,
+}

package/src/enums/UpdateState.enum.ts

@@ -0,0 +1,24 @@
+import { NativeRNAppZungCodePushModule } from '../internals/NativeRNAppZungCodePushModule';
+
+/**
+ * Indicates the state that an update is currently in.
+ */
+export enum UpdateState {
+  /**
+   * Indicates that an update represents the
+   * version of the app that is currently running.
+   */
+  RUNNING = NativeRNAppZungCodePushModule.getConstants().codePushUpdateStateRunning,
+
+  /**
+   * Indicates than an update has been installed, but the
+   * app hasn't been restarted yet in order to apply it.
+   */
+  PENDING = NativeRNAppZungCodePushModule.getConstants().codePushUpdateStatePending,
+
+  /**
+   * Indicates than an update represents the latest available
+   * release, and can be either currently running or pending.
+   */
+  LATEST = NativeRNAppZungCodePushModule.getConstants().codePushUpdateStateLatest,
+}

package/src/getUpdateMetadata.ts

@@ -0,0 +1,23 @@
+import { UpdateState } from './enums/UpdateState.enum';
+import { LocalPackageImplementation } from './internals/LocalPackageImplementation';
+import { NativeRNAppZungCodePushModule } from './internals/NativeRNAppZungCodePushModule';
+import type { LocalPackage } from './types';
+
+/**
+ * Retrieves the metadata for an installed update (e.g. description, mandatory).
+ *
+ * @param updateState The state of the update you want to retrieve the metadata for. Defaults to UpdateState.RUNNING.
+ */
+export async function getUpdateMetadata(updateState?: UpdateState): Promise<LocalPackage | null> {
+  const nativeUpdateMetadata = await NativeRNAppZungCodePushModule.getUpdateMetadata(
+    updateState || UpdateState.RUNNING,
+  );
+  if (!nativeUpdateMetadata) {
+    return null;
+  }
+
+  const localPackage = new LocalPackageImplementation(nativeUpdateMetadata);
+  localPackage.failedInstall = await NativeRNAppZungCodePushModule.isFailedUpdate(nativeUpdateMetadata.packageHash);
+  localPackage.isFirstRun = await NativeRNAppZungCodePushModule.isFirstRun(nativeUpdateMetadata.packageHash);
+  return localPackage;
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+export * from './allowRestart';
+export * from './checkForUpdates';
+export * from './clearUpdates';
+export * from './CodePush';
+export { default } from './CodePush';
+export * from './disallowRestart';
+export * from './getUpdateMetadata';
+export * from './notifyAppReady';
+export * from './restartApp';
+export * from './sync';
+
+export * from './types';
+
+export * from './enums/SyncStatus.enum';
+export * from './enums/InstallMode.enum';
+export * from './enums/UpdateState.enum';
+export * from './enums/DeploymentStatus.enum';
+export * from './enums/CheckFrequency.enum';

package/src/internals/AcquisitionSdk.ts

@@ -0,0 +1,3 @@
+import { AcquisitionManager } from 'code-push/script/acquisition-sdk';
+
+export const AcquisitionSdk = AcquisitionManager;

package/src/internals/LocalPackageImplementation.ts

@@ -0,0 +1,45 @@
+import type { InstallMode } from '../enums/InstallMode.enum';
+import type { LocalPackage } from '../types';
+import { NativeRNAppZungCodePushModule } from './NativeRNAppZungCodePushModule';
+
+export class LocalPackageImplementation implements LocalPackage {
+  constructor(localPackageData: Omit<LocalPackage, 'install'>) {
+    Object.assign(this, localPackageData);
+
+    this.install = async (
+      installMode = NativeRNAppZungCodePushModule.getConstants().codePushInstallModeOnNextRestart,
+      minimumBackgroundDuration = 0,
+      updateInstalledCallback?: () => Promise<void> | void,
+    ) => {
+      const { ...localPackageCopy } = localPackageData;
+      await NativeRNAppZungCodePushModule.installUpdate(localPackageCopy, installMode, minimumBackgroundDuration);
+
+      if (installMode === NativeRNAppZungCodePushModule.getConstants().codePushInstallModeImmediate) {
+        await updateInstalledCallback?.();
+        await NativeRNAppZungCodePushModule.restartApp(false);
+        return;
+      }
+
+      await NativeRNAppZungCodePushModule.clearPendingRestart();
+      this.isPending = true; // Mark the package as pending since it hasn't been applied yet
+      await updateInstalledCallback?.();
+    };
+  }
+
+  appVersion!: string;
+  description!: string;
+  failedInstall!: boolean;
+  isFirstRun!: boolean;
+  isMandatory!: boolean;
+  isPending = false; // A local package wouldn't be pending until it was installed
+  label!: string;
+  packageHash!: string;
+  packageSize!: number;
+  releaseChannelPublicId!: string;
+
+  install: (
+    installMode?: InstallMode,
+    minimumBackgroundDuration?: number,
+    onUpdateInstalled?: () => Promise<void> | void,
+  ) => Promise<void>;
+}

package/src/internals/NativeRNAppZungCodePushModule.ts

@@ -0,0 +1,3 @@
+import { type Spec } from './RNAppZungCodePushModuleSpec';
+
+export const NativeRNAppZungCodePushModule = require('react-native').NativeModules.CodePush as Spec;

package/src/internals/RNAppZungCodePushModuleSpec.ts

@@ -0,0 +1,54 @@
+import { type TurboModule } from 'react-native';
+import type { InstallMode } from '../enums/InstallMode.enum';
+import type { UpdateState } from '../enums/UpdateState.enum';
+import type { LocalPackage, RemotePackage, StatusReport } from '../types';
+import type { Configuration, LatestRollbackInfo, OmitFunctions } from './types';
+
+export interface Spec extends TurboModule {
+  addListener: (eventName: string) => void;
+  removeListeners: (count: number) => void;
+
+  getConstants(): {
+    codePushInstallModeImmediate: number;
+    codePushInstallModeOnNextRestart: number;
+    codePushInstallModeOnNextResume: number;
+    codePushInstallModeOnNextSuspend: number;
+
+    codePushUpdateStateLatest: number;
+    codePushUpdateStatePending: number;
+    codePushUpdateStateRunning: number;
+  };
+
+  getConfiguration(): Promise<Configuration>;
+
+  getUpdateMetadata(updateState: UpdateState): Promise<OmitFunctions<LocalPackage>>;
+  installUpdate(
+    localPackage: OmitFunctions<LocalPackage>,
+    installMode: InstallMode,
+    minimumBackgroundDuration: number,
+  ): Promise<void>;
+  downloadUpdate(
+    remotePackage: OmitFunctions<RemotePackage>,
+    notifyProgress: boolean,
+  ): Promise<OmitFunctions<LocalPackage>>;
+
+  restartApp(onlyIfUpdateIsPending: boolean): Promise<void>;
+  clearPendingRestart(): Promise<void>;
+
+  disallow(): Promise<void>;
+  allow(): Promise<void>;
+
+  clearUpdates(): void;
+
+  notifyApplicationReady(): Promise<void>;
+  setLatestRollbackInfo(packageHash: string): Promise<void>;
+
+  getNewStatusReport(): Promise<StatusReport>;
+  recordStatusReported(statusReport: StatusReport): void;
+  saveStatusReportForRetry(statusReport: StatusReport): void;
+
+  getLatestRollbackInfo(): Promise<LatestRollbackInfo>;
+
+  isFirstRun(packageHash: string): Promise<boolean>;
+  isFailedUpdate(packageHash: string): Promise<boolean>;
+}

package/src/internals/RemotePackageImplementation.ts

@@ -0,0 +1,69 @@
+import type { Package } from 'code-push/script/acquisition-sdk';
+import { NativeEventEmitter } from 'react-native';
+import type { DownloadProgressCallback, LocalPackage, RemotePackage } from '../types';
+import { LocalPackageImplementation } from './LocalPackageImplementation';
+import { NativeRNAppZungCodePushModule } from './NativeRNAppZungCodePushModule';
+import { log } from './utils/log';
+
+export class RemotePackageImpl implements RemotePackage {
+  constructor(
+    remotePackageData: Omit<RemotePackage, 'download'>,
+    reportStatusDownload?: (downloadedPackage: Package) => Promise<void>,
+  ) {
+    Object.assign(this, remotePackageData);
+
+    this.download = async (downloadProgressCallback?: DownloadProgressCallback) => {
+      if (!this.downloadUrl) {
+        throw new Error('Cannot download an update without a download url');
+      }
+
+      let downloadProgressSubscription;
+
+      if (downloadProgressCallback) {
+        const codePushEventEmitter = new NativeEventEmitter(NativeRNAppZungCodePushModule);
+        // Use event subscription to obtain download progress.
+        downloadProgressSubscription = codePushEventEmitter.addListener(
+          'CodePushDownloadProgress',
+          downloadProgressCallback,
+        );
+      }
+
+      // Use the downloaded package info. Native code will save the package info
+      // so that the client knows what the current package version is.
+      try {
+        const { ...updatePackageCopy } = remotePackageData; // In dev mode, React Native deep freezes any object queued over the bridge
+        const downloadedPackage = await NativeRNAppZungCodePushModule.downloadUpdate(
+          updatePackageCopy,
+          !!downloadProgressCallback,
+        );
+
+        if (reportStatusDownload) {
+          reportStatusDownload({
+            ...this,
+            deploymentKey: this.releaseChannelPublicId,
+          }).catch((err) => {
+            log(`Report download status failed: ${err}`);
+          });
+        }
+
+        return new LocalPackageImplementation(downloadedPackage);
+      } finally {
+        downloadProgressSubscription && downloadProgressSubscription.remove();
+      }
+    };
+  }
+
+  download: (downloadProgressCallback?: DownloadProgressCallback) => Promise<LocalPackage>;
+
+  appVersion!: string;
+  description!: string;
+  downloadUrl!: string;
+  failedInstall!: boolean;
+  isFirstRun!: boolean;
+  isMandatory!: boolean;
+  isPending = false; // A remote package could never be in a pending state
+  label!: string;
+  packageHash!: string;
+  packageSize!: number;
+  releaseChannelPublicId!: string;
+}

package/src/internals/getConfiguration.ts

@@ -0,0 +1,12 @@
+import { NativeRNAppZungCodePushModule } from './NativeRNAppZungCodePushModule';
+import type { Configuration } from './types';
+
+let config: Configuration;
+
+export async function getConfiguration() {
+  if (!config) {
+    config = await NativeRNAppZungCodePushModule.getConfiguration();
+  }
+
+  return config;
+}

package/src/internals/getCurrentPackage.ts

@@ -0,0 +1,6 @@
+import { UpdateState } from '../enums/UpdateState.enum';
+import { getUpdateMetadata } from '../getUpdateMetadata';
+
+export async function getCurrentPackage() {
+  return await getUpdateMetadata(UpdateState.LATEST);
+}