@take-out/native-hot-update 0.0.36

package/src/createHotUpdater.ts

@@ -0,0 +1,240 @@
+import {
+  getUpdateSource,
+  HotUpdater,
+  useHotUpdaterStore,
+} from '@hot-updater/react-native'
+import * as Application from 'expo-application'
+import { useEffect, useRef, useState } from 'react'
+import { Alert } from 'react-native'
+
+import type { HotUpdaterConfig, HotUpdaterInstance, UpdateInfo } from './types'
+
+const INITIAL_OTA_ID = '00000000-0000-0000-0000-000000000000'
+const BUNDLE_ID_KEY_PREFIX = 'hotUpdater.bundleId'
+const PRE_RELEASE_BUNDLE_ID_KEY = 'hotUpdater.preReleaseBundleId'
+
+export function createHotUpdater(config: HotUpdaterConfig): HotUpdaterInstance {
+  const { serverUrl, storage, updateStrategy = 'appVersion' } = config
+
+  let isUpdatePending = false
+
+  const getAppliedOta = (): string | null => {
+    const id = HotUpdater.getBundleId()
+    if (id === INITIAL_OTA_ID) return null
+    if (id === HotUpdater.getMinBundleId()) return null
+    return id
+  }
+
+  const getShortOtaId = (): string | null => {
+    const fullId = getAppliedOta()
+    return fullId ? fullId.slice(24) : null
+  }
+
+  const getIsUpdatePending = (): boolean => {
+    return isUpdatePending
+  }
+
+  const getPreReleaseBundleId = (): string | undefined => {
+    return storage.get(PRE_RELEASE_BUNDLE_ID_KEY)
+  }
+
+  const handleUpdateDownloaded = (
+    id: string,
+    options: { isPreRelease?: boolean } = {}
+  ) => {
+    const appVersion = Application.nativeApplicationVersion
+    if (appVersion) {
+      storage.set(`${BUNDLE_ID_KEY_PREFIX}.${appVersion}`, id)
+    }
+
+    if (options.isPreRelease) {
+      storage.set(PRE_RELEASE_BUNDLE_ID_KEY, id)
+    } else {
+      storage.delete(PRE_RELEASE_BUNDLE_ID_KEY)
+    }
+
+    isUpdatePending = true
+  }
+
+  const useOtaUpdater = (
+    options: {
+      enabled?: boolean
+      onUpdateDownloaded?: (info: UpdateInfo) => void
+      onError?: (error: unknown) => void
+    } = {}
+  ) => {
+    const {
+      enabled = true,
+      onUpdateDownloaded: onUpdateDownloadedCallback,
+      onError,
+    } = options
+
+    const progress = useHotUpdaterStore((state) => state.progress)
+    const isUpdating = progress > 0.01
+
+    const [isUserClearedForAccess, setIsUserClearedForAccess] = useState(false)
+    const isUserClearedForAccessRef = useRef(isUserClearedForAccess)
+    isUserClearedForAccessRef.current = isUserClearedForAccess
+
+    // 5s timeout if no update started
+    useEffect(() => {
+      if (!isUpdating) {
+        const timer = setTimeout(() => {
+          if (!isUserClearedForAccessRef.current) {
+            setIsUserClearedForAccess(true)
+          }
+        }, 5000)
+        return () => clearTimeout(timer)
+      }
+    }, [isUpdating])
+
+    // 20s hard timeout
+    useEffect(() => {
+      const timer = setTimeout(() => {
+        if (!isUserClearedForAccessRef.current) {
+          setIsUserClearedForAccess(true)
+        }
+      }, 20000)
+      return () => clearTimeout(timer)
+    }, [])
+
+    // Update check
+    useEffect(() => {
+      let shouldContinue = true
+
+      ;(async () => {
+        try {
+          if (!enabled) {
+            setIsUserClearedForAccess(true)
+            return
+          }
+
+          if (!shouldContinue) return
+
+          const updateInfo = await HotUpdater.checkForUpdate({
+            source: getUpdateSource(serverUrl, { updateStrategy }),
+          })
+
+          if (!updateInfo) {
+            setIsUserClearedForAccess(true)
+            return
+          }
+
+          if (!shouldContinue) return
+
+          // Handle rollback for pre-release bundles
+          if (updateInfo.status === 'ROLLBACK') {
+            const preReleaseBundleId = getPreReleaseBundleId()
+            const currentBundleId = HotUpdater.getBundleId()
+
+            if (
+              preReleaseBundleId &&
+              preReleaseBundleId === currentBundleId &&
+              currentBundleId > updateInfo.id
+            ) {
+              Alert.alert(
+                'Update Skipped',
+                'Skipped rollback because you are using a newer pre-release bundle.'
+              )
+              setIsUserClearedForAccess(true)
+              return
+            }
+          }
+
+          if (!updateInfo.shouldForceUpdate) {
+            setIsUserClearedForAccess(true)
+          }
+
+          if (!shouldContinue) return
+
+          await updateInfo.updateBundle()
+          handleUpdateDownloaded(updateInfo.id)
+
+          const info: UpdateInfo = {
+            id: updateInfo.id,
+            isCriticalUpdate: updateInfo.shouldForceUpdate,
+            fileUrl: updateInfo.fileUrl,
+            message: updateInfo.message,
+          }
+          onUpdateDownloadedCallback?.(info)
+
+          if (!shouldContinue) return
+
+          if (updateInfo.shouldForceUpdate) {
+            if (!isUserClearedForAccessRef.current) {
+              HotUpdater.reload()
+              return
+            }
+            Alert.alert(
+              'Update Downloaded',
+              'An important update has been downloaded. Reload now to apply it?',
+              [
+                { text: 'Later', style: 'cancel' },
+                { text: 'Reload Now', onPress: () => HotUpdater.reload() },
+              ]
+            )
+          }
+        } catch (error) {
+          onError?.(error)
+          setIsUserClearedForAccess(true)
+        } finally {
+          if (!isUserClearedForAccessRef.current) {
+            setIsUserClearedForAccess(true)
+          }
+        }
+      })()
+
+      return () => {
+        shouldContinue = false
+      }
+    }, [enabled, onUpdateDownloadedCallback, onError])
+
+    return {
+      userClearedForAccess: isUserClearedForAccess,
+      progress,
+      isUpdatePending: getIsUpdatePending(),
+    }
+  }
+
+  const checkForUpdate = async (
+    options: { channel?: string; isPreRelease?: boolean } = {}
+  ) => {
+    const { channel, isPreRelease = false } = options
+
+    const updateSource = getUpdateSource(serverUrl, { updateStrategy })
+
+    const finalSource = channel
+      ? (params: any) => updateSource({ ...params, channel })
+      : updateSource
+
+    const updateInfo = await HotUpdater.checkForUpdate({
+      source: finalSource,
+    })
+
+    if (updateInfo) {
+      await updateInfo.updateBundle()
+      handleUpdateDownloaded(updateInfo.id, { isPreRelease })
+
+      return {
+        id: updateInfo.id,
+        isCriticalUpdate: updateInfo.shouldForceUpdate,
+        fileUrl: updateInfo.fileUrl,
+        message: updateInfo.message,
+      }
+    }
+
+    return null
+  }
+
+  return {
+    useOtaUpdater,
+    checkForUpdate,
+    getAppliedOta,
+    getShortOtaId,
+    getIsUpdatePending,
+    reload: () => HotUpdater.reload(),
+    getBundleId: () => HotUpdater.getBundleId(),
+    getMinBundleId: () => HotUpdater.getMinBundleId(),
+    getChannel: () => HotUpdater.getChannel(),
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { createHotUpdater } from './createHotUpdater'
+export type * from './types'

package/src/mmkv.ts

@@ -0,0 +1,20 @@
+import type { HotUpdateStorage } from './types'
+import type { MMKV } from 'react-native-mmkv'
+
+/**
+ * Create a storage adapter for MMKV.
+ *
+ * @example
+ * import { MMKV } from 'react-native-mmkv'
+ * import { createMMKVStorage } from '@take-out/native-hot-update/mmkv'
+ *
+ * const mmkv = new MMKV({ id: 'hot-updater' })
+ * const storage = createMMKVStorage(mmkv)
+ */
+export function createMMKVStorage(mmkv: MMKV): HotUpdateStorage {
+  return {
+    get: (key: string) => mmkv.getString(key),
+    set: (key: string, value: string) => mmkv.set(key, value),
+    delete: (key: string) => mmkv.delete(key),
+  }
+}

package/src/types.ts

@@ -0,0 +1,62 @@
+/** Simple key-value storage interface */
+export interface HotUpdateStorage {
+  get(key: string): string | undefined
+  set(key: string, value: string): void
+  delete(key: string): void
+}
+
+export interface HotUpdaterConfig {
+  /** Hot update server URL */
+  serverUrl: string
+  /** Storage for persisting update state */
+  storage: HotUpdateStorage
+  /** Update strategy (default: 'appVersion') */
+  updateStrategy?: 'appVersion' | 'fingerprint'
+}
+
+export interface UpdateInfo {
+  id: string
+  isCriticalUpdate: boolean
+  fileUrl: string | null
+  message: string | null
+}
+
+export interface HotUpdaterInstance {
+  /** React hook for automatic update checking */
+  useOtaUpdater: (options?: {
+    enabled?: boolean
+    onUpdateDownloaded?: (info: UpdateInfo) => void
+    onError?: (error: unknown) => void
+  }) => {
+    userClearedForAccess: boolean
+    progress: number
+    isUpdatePending: boolean
+  }
+
+  /** Manually check for updates (for dev/testing) */
+  checkForUpdate: (options?: {
+    channel?: string
+    isPreRelease?: boolean
+  }) => Promise<UpdateInfo | null>
+
+  /** Get currently applied OTA bundle ID (null if native) */
+  getAppliedOta: () => string | null
+
+  /** Get short version of OTA ID */
+  getShortOtaId: () => string | null
+
+  /** Check if update is pending (will apply on restart) */
+  getIsUpdatePending: () => boolean
+
+  /** Reload the app to apply update */
+  reload: () => void
+
+  /** Get current bundle ID */
+  getBundleId: () => string
+
+  /** Get minimum bundle ID (native build time) */
+  getMinBundleId: () => string
+
+  /** Get current channel */
+  getChannel: () => string
+}