@rific/updater 0.1.1 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rific/updater",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "OTA update hook for Expo apps — silent background fetch on foreground, manual check with confirmation dialog",
   "keywords": [
     "expo",
@@ -23,8 +23,8 @@
   "type": "commonjs",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
       "react-native": "./dist/index.js",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
     }
@@ -37,7 +37,10 @@
   },
   "files": [
     "dist",
-    "scripts"
+    "scripts",
+    "src",
+    "!src/__tests__",
+    "!src/__mocks__"
   ],
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts --clean",
@@ -51,7 +54,7 @@
     "test": "jest",
     "test:watch": "jest --watchAll",
     "typecheck": "tsc --noEmit",
-    "preversion": "npm run lint && npm test"
+    "preversion": "npm run lint && npm test && npm run build"
   },
   "devDependencies": {
     "@testing-library/react": "^16.3.2",
@@ -77,8 +80,8 @@
   },
   "peerDependencies": {
     "expo-updates": ">=0.25.0",
-    "react": ">=17.0.0",
-    "react-native": ">=0.70.0"
+    "react": ">=18.0.0",
+    "react-native": ">=0.76.0"
   },
   "publishConfig": {
     "access": "public"

package/src/checkForUpdate.ts

@@ -0,0 +1,10 @@
+import { checkForUpdateAsync, fetchUpdateAsync } from 'expo-updates'
+
+import { UpdateManifest } from './types'
+
+export const checkForUpdate = async (): Promise<UpdateManifest | null> => {
+  const { isAvailable } = await checkForUpdateAsync()
+  if (!isAvailable) return null
+  const { manifest } = await fetchUpdateAsync()
+  return manifest ? (manifest as unknown as UpdateManifest) : null
+}

package/src/getUpdateConfirmation.ts

@@ -0,0 +1,17 @@
+import { Alert } from 'react-native'
+
+import { UpdateManifest } from './types'
+
+export const getUpdateConfirmation = (manifest: UpdateManifest): Promise<boolean> => {
+  const date = new Date(manifest.createdAt)
+  let info = `A new update was released on ${date.toLocaleDateString()} at ${date.toLocaleTimeString()}.`
+  if (manifest.metadata?.message) info += `\n\nMessage: ${manifest.metadata.message}.`
+  info += '\n\nRestart app to update.'
+
+  return new Promise((resolve) => {
+    Alert.alert('Update available', info, [
+      { text: 'Cancel', style: 'cancel', onPress: () => resolve(false) },
+      { text: 'Restart', onPress: () => resolve(true) }
+    ])
+  })
+}

package/src/globals.d.ts

@@ -0,0 +1 @@
+declare const __DEV__: boolean

package/src/index.ts

@@ -0,0 +1,2 @@
+export { type UpdateManifest } from './types'
+export { useUpdater, type UseUpdaterOptions, type UseUpdaterReturn } from './useUpdater'

package/src/types.ts

@@ -0,0 +1,4 @@
+export interface UpdateManifest {
+  createdAt: string
+  metadata?: Record<string, string | undefined>
+}

package/src/useUpdater.ts

@@ -0,0 +1,86 @@
+import { reloadAsync } from 'expo-updates'
+import { useEffect, useRef, useState } from 'react'
+import { Alert, AppState, AppStateStatus, Platform } from 'react-native'
+
+import { checkForUpdate } from './checkForUpdate'
+import { getUpdateConfirmation } from './getUpdateConfirmation'
+import { UpdateManifest } from './types'
+
+export interface UseUpdaterOptions {
+  autoCheck?: boolean
+  onConfirm?: (manifest: UpdateManifest) => Promise<boolean>
+  onError?: (message: string) => void
+}
+
+export interface UseUpdaterReturn {
+  check: () => Promise<void>
+  checking: boolean
+  updateReady: boolean
+}
+
+const isUnsupported = () => __DEV__ || Platform.OS === 'web'
+
+export const useUpdater = (options: UseUpdaterOptions = {}): UseUpdaterReturn => {
+  const { autoCheck = true, onConfirm, onError } = options
+  const [checking, setChecking] = useState(false)
+  const [updateReady, setUpdateReady] = useState(false)
+  const checkingRef = useRef(false)
+  const appState = useRef(AppState.currentState)
+  const stagedManifest = useRef<UpdateManifest | null>(null)
+
+  useEffect(() => {
+    if (!autoCheck || isUnsupported()) return
+
+    const subscription = AppState.addEventListener('change', (nextState: AppStateStatus) => {
+      if (/inactive|background/.test(appState.current) && nextState === 'active') {
+        checkForUpdate()
+          .then((manifest) => {
+            if (manifest) {
+              stagedManifest.current = manifest
+              setUpdateReady(true)
+            }
+          })
+          .catch(() => {})
+      }
+      appState.current = nextState
+    })
+
+    return () => subscription.remove()
+  }, [autoCheck])
+
+  const check = async (): Promise<void> => {
+    if (__DEV__) {
+      Alert.alert('Updates unavailable', 'Update checks are disabled in development mode.')
+      return
+    }
+    if (Platform.OS === 'web') {
+      Alert.alert('Updates unavailable', 'Update checks are not supported on web.')
+      return
+    }
+    if (checkingRef.current) return
+    checkingRef.current = true
+    setChecking(true)
+    try {
+      const manifest = stagedManifest.current ?? (await checkForUpdate())
+      if (!manifest) {
+        Alert.alert('No update', 'You are on the most recent version.')
+        return
+      }
+      const confirmFn = onConfirm ?? getUpdateConfirmation
+      const confirmed = await confirmFn(manifest)
+      if (!confirmed) return
+      await reloadAsync()
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Could not check for updates.'
+      if (onError) onError(message)
+      else Alert.alert('Update error', message)
+    } finally {
+      stagedManifest.current = null
+      setUpdateReady(false)
+      checkingRef.current = false
+      setChecking(false)
+    }
+  }
+
+  return { check, checking, updateReady }
+}