one 2.6.18 → 2.6.20

package/src/platform/index.native.ts

@@ -60,7 +60,7 @@ import { Widgets, LiveActivities, WidgetUI } from './widgets/index'
 
 export * from './extras'
 export { Storage } from './storage/index.native'
-export { KeepAwake } from './keep-awake/index'
+export { KeepAwake, useKeepAwake } from './keep-awake/index'
 export { Print } from './print/index'
 export { StoreReview } from './store-review/index'
 export { QuickActions } from './quick-actions/index'
@@ -278,6 +278,7 @@ export type {
 export { ImageManipulator } from './image-manipulator/index.native'
 export type {
   ImageCrop,
+  ImageFlip,
   ImageFormat,
   ImageResize,
   ImageManipulatorOptions,
@@ -324,7 +325,7 @@ export type {
   ReminderInfo,
   ReminderInput,
 } from './calendar/index'
-export type { HapticImpact, HapticNotification, HapticsApi } from './haptics/index.native'
+export type { AndroidHaptic, HapticImpact, HapticNotification, HapticsApi } from './haptics/index.native'
 export type {
   LaunchScreenApi,
   LaunchScreenHideOptions,

package/src/platform/index.ts

@@ -61,7 +61,7 @@ export type { LocalAuthenticationStatus } from './local-authentication/index'
 export { ProtectedStore } from './protected-store/index'
 export type { ProtectedStorePolicy } from './protected-store/index'
 export { Storage } from './storage/index'
-export { KeepAwake } from './keep-awake/index'
+export { KeepAwake, useKeepAwake } from './keep-awake/index'
 export { Print } from './print/index'
 export { StoreReview } from './store-review/index'
 export { QuickActions } from './quick-actions/index'
@@ -152,6 +152,7 @@ export type {
 export { ImageManipulator } from './image-manipulator/index'
 export type {
   ImageCrop,
+  ImageFlip,
   ImageFormat,
   ImageResize,
   ImageManipulatorOptions,
@@ -198,7 +199,7 @@ export type {
   ReminderInfo,
   ReminderInput,
 } from './calendar/index'
-export type { HapticImpact, HapticNotification, HapticsApi } from './haptics/index'
+export type { AndroidHaptic, HapticImpact, HapticNotification, HapticsApi } from './haptics/index'
 export type { LaunchScreenApi, LaunchScreenHideOptions } from './launchScreen/index'
 export { AppInfo } from './app-info/index'
 export type { AppInfoApi } from './app-info/index'

package/src/platform/keep-awake/index.native.ts

@@ -1,7 +1,8 @@
+import { useEffect, useId } from 'react'
 import { NitroModules } from 'react-native-nitro-modules'
 import { rethrowNativeError } from '../nativeError'
 import type { OneKeepAwake } from '../specs/OneKeepAwake.nitro'
-import { assertKeepAwakeEnabled } from './validate'
+import { assertKeepAwakeEnabled, assertKeepAwakeTag, normalizeKeepAwakeTag } from './validate'
 
 let hybrid: OneKeepAwake | undefined
 
@@ -19,4 +20,32 @@ function setEnabled(enabled: boolean): Promise<void> {
   return native().setEnabled(enabled).catch(rethrowNativeError)
 }
 
-export const KeepAwake = Object.freeze({ isEnabled, setEnabled })
+function activate(tag?: string): Promise<void> {
+  assertKeepAwakeTag(tag, 'activate')
+  return native().activate(normalizeKeepAwakeTag(tag)).catch(rethrowNativeError)
+}
+
+function deactivate(tag?: string): Promise<void> {
+  assertKeepAwakeTag(tag, 'deactivate')
+  return native().deactivate(normalizeKeepAwakeTag(tag)).catch(rethrowNativeError)
+}
+
+export function useKeepAwake(tag?: string): void {
+  const fallback = useId()
+  assertKeepAwakeTag(tag, 'useKeepAwake')
+  // a hook without a tag owns an id unique to its component instance, never
+  // the shared default tag, matching expo-keep-awake.
+  const effective = tag ?? fallback
+  useEffect(() => {
+    // a hook has no caller to reject to, so failures are reported, as
+    // usePreventScreenCapture does.
+    activate(effective).catch((error: unknown) => {
+      console.error(`Failed to keep the screen awake: ${String(error)}`)
+    })
+    return () => {
+      deactivate(effective).catch(() => {})
+    }
+  }, [effective])
+}
+
+export const KeepAwake = Object.freeze({ isEnabled, setEnabled, activate, deactivate })

package/src/platform/keep-awake/index.ts

@@ -1,27 +1,76 @@
+import { useEffect, useId } from 'react'
 import { KeepAwake as unavailable } from './unavailable'
-import { assertKeepAwakeEnabled } from './validate'
+import {
+  assertKeepAwakeEnabled,
+  assertKeepAwakeTag,
+  normalizeKeepAwakeTag,
+} from './validate'
+
+const active = new Set<string>()
 let lock: WakeLockSentinel | undefined
 let operation: Promise<void> = Promise.resolve()
+
+function live(): boolean {
+  return !!lock && !lock.released
+}
+
+function apply(owner: 'setEnabled' | 'activate' | 'deactivate'): Promise<void> {
+  const next = operation
+    .catch(() => {})
+    .then(async () => {
+      if (active.size === 0) {
+        await lock?.release()
+        lock = undefined
+        return
+      }
+      if (live()) return
+      if (!navigator.wakeLock)
+        throw new Error(`KeepAwake.${owner}: Screen Wake Lock is unavailable`)
+      lock = await navigator.wakeLock.request('screen')
+    })
+  operation = next
+  return next
+}
+
 export const KeepAwake = Object.freeze({
   isEnabled: async (): Promise<boolean> =>
-    typeof window !== 'undefined' && !!lock && !lock.released,
+    typeof window !== 'undefined' && active.size > 0 && live(),
   setEnabled: (enabled: boolean): Promise<void> => {
     assertKeepAwakeEnabled(enabled)
     if (typeof window === 'undefined') return unavailable.setEnabled(enabled)
-    const next = operation
-      .catch(() => {})
-      .then(async () => {
-        if (!enabled) {
-          await lock?.release()
-          lock = undefined
-          return
-        }
-        if (lock && !lock.released) return
-        if (!navigator.wakeLock)
-          throw new Error('KeepAwake.setEnabled: Screen Wake Lock is unavailable')
-        lock = await navigator.wakeLock.request('screen')
-      })
-    operation = next
-    return next
+    if (enabled) active.add(normalizeKeepAwakeTag(undefined))
+    else active.delete(normalizeKeepAwakeTag(undefined))
+    return apply('setEnabled')
+  },
+  activate: (tag?: string): Promise<void> => {
+    assertKeepAwakeTag(tag, 'activate')
+    if (typeof window === 'undefined') return unavailable.activate(tag)
+    active.add(normalizeKeepAwakeTag(tag))
+    return apply('activate')
+  },
+  deactivate: (tag?: string): Promise<void> => {
+    assertKeepAwakeTag(tag, 'deactivate')
+    if (typeof window === 'undefined') return unavailable.deactivate(tag)
+    active.delete(normalizeKeepAwakeTag(tag))
+    return apply('deactivate')
   },
 })
+
+export function useKeepAwake(tag?: string): void {
+  const fallback = useId()
+  assertKeepAwakeTag(tag, 'useKeepAwake')
+  // a hook without a tag owns an id unique to its component instance, never
+  // the shared default tag, matching expo-keep-awake.
+  const effective = tag ?? fallback
+  useEffect(() => {
+    if (typeof window === 'undefined') return
+    // a hook has no caller to reject to, so failures are reported, as
+    // usePreventScreenCapture does.
+    KeepAwake.activate(effective).catch((error: unknown) => {
+      console.error(`Failed to keep the screen awake: ${String(error)}`)
+    })
+    return () => {
+      KeepAwake.deactivate(effective).catch(() => {})
+    }
+  }, [effective])
+}

package/src/platform/keep-awake/unavailable.ts

@@ -1,4 +1,4 @@
-import { assertKeepAwakeEnabled } from './validate'
+import { assertKeepAwakeEnabled, assertKeepAwakeTag } from './validate'
 
 function isEnabled(): Promise<boolean> {
   return Promise.resolve(false)
@@ -9,4 +9,14 @@ function setEnabled(enabled: boolean): Promise<void> {
   return Promise.resolve()
 }
 
-export const KeepAwake = Object.freeze({ isEnabled, setEnabled })
+function activate(tag?: string): Promise<void> {
+  assertKeepAwakeTag(tag, 'activate')
+  return Promise.resolve()
+}
+
+function deactivate(tag?: string): Promise<void> {
+  assertKeepAwakeTag(tag, 'deactivate')
+  return Promise.resolve()
+}
+
+export const KeepAwake = Object.freeze({ isEnabled, setEnabled, activate, deactivate })

package/src/platform/keep-awake/validate.ts

@@ -4,3 +4,19 @@ export function assertKeepAwakeEnabled(value: unknown): asserts value is boolean
     throw new Error('KeepAwake.setEnabled: enabled must be a boolean')
   }
 }
+
+// expo's default tag, used when activate/deactivate omit one.
+export const keepAwakeDefaultTag = 'ExpoKeepAwakeDefaultTag'
+
+export function assertKeepAwakeTag(
+  value: unknown,
+  owner: 'activate' | 'deactivate' | 'useKeepAwake'
+): asserts value is string | undefined {
+  if (value !== undefined && typeof value !== 'string') {
+    throw new Error(`KeepAwake.${owner}: tag must be a string`)
+  }
+}
+
+export function normalizeKeepAwakeTag(value: string | undefined): string {
+  return value ?? keepAwakeDefaultTag
+}

package/src/platform/localization/index.native.ts

@@ -0,0 +1,47 @@
+import { useEffect, useState } from 'react'
+import { NitroModules } from 'react-native-nitro-modules'
+import type { OneDevice } from '../specs/OneDevice.nitro'
+import { toCalendars, toLocales } from './map'
+import type { Calendar, Locale, Localization as LocalizationApi } from './types'
+
+export type { Calendar, Locale, LocalizationApi }
+
+// expo-localization's synchronous reads plus its live hooks, backed by the
+// OneDevice nitro hybrid object (created on first use and cached). the first
+// hook subscription starts the platform locale observer and the last removal
+// stops it, so a change can never race the subscription.
+let hybrid: OneDevice | undefined
+
+function native(): OneDevice {
+  hybrid ??= NitroModules.createHybridObject<OneDevice>('OneDevice')
+  return hybrid
+}
+
+function getLocales(): [Locale, ...Locale[]] {
+  return toLocales(native().getLocales())
+}
+
+function getCalendars(): [Calendar, ...Calendar[]] {
+  return toCalendars(native().getCalendars())
+}
+
+function useLocales(): [Locale, ...Locale[]] {
+  const [locales, setLocales] = useState<[Locale, ...Locale[]]>(() => getLocales())
+  useEffect(() => {
+    setLocales(getLocales())
+    return native().addLocalizationListener(() => setLocales(getLocales()))
+  }, [])
+  return locales
+}
+
+function useCalendars(): [Calendar, ...Calendar[]] {
+  const [calendars, setCalendars] = useState<[Calendar, ...Calendar[]]>(() => getCalendars())
+  useEffect(() => {
+    setCalendars(getCalendars())
+    return native().addLocalizationListener(() => setCalendars(getCalendars()))
+  }, [])
+  return calendars
+}
+
+export const Localization: LocalizationApi = Object.freeze({ getLocales, getCalendars })
+export { useCalendars, useLocales }

package/src/platform/localization/index.ts

@@ -0,0 +1,90 @@
+import { useEffect, useState } from 'react'
+import { FALLBACK_CALENDAR, FALLBACK_LOCALE } from './map'
+import type { Calendar, Locale, Localization as LocalizationApi } from './types'
+
+export type { Calendar, Locale, LocalizationApi }
+
+// web entry. same shape as the native entry, read from Intl and navigator:
+// currency and measurement are not exposed on the web, so they stay null as
+// in expo-localization. on the server every read is the en-US fallback, so a
+// route module that imports this renders under SSR and SSG.
+function localeFor(tag: string): Locale {
+  try {
+    const parsed = new Intl.Locale(tag)
+    const numbers = new Intl.NumberFormat(tag).formatToParts(1234567.89)
+    const part = (type: string) => numbers.find((entry) => entry.type === type)?.value ?? null
+    // Intl.Locale textInfo and weekInfo are stage-3: read them structurally.
+    const direction = (parsed as { textInfo?: { direction?: string } }).textInfo?.direction
+    return {
+      languageTag: parsed.baseName,
+      languageCode: parsed.language ?? null,
+      languageScriptCode: parsed.script ?? null,
+      regionCode: parsed.region ?? null,
+      languageRegionCode: parsed.region ?? null,
+      currencyCode: null,
+      currencySymbol: null,
+      languageCurrencyCode: null,
+      languageCurrencySymbol: null,
+      decimalSeparator: part('decimal'),
+      digitGroupingSeparator: part('group'),
+      textDirection: direction === 'rtl' ? 'rtl' : 'ltr',
+      measurementSystem: null,
+      temperatureUnit: null,
+    }
+  } catch {
+    return { ...FALLBACK_LOCALE, languageTag: tag }
+  }
+}
+
+function getLocales(): [Locale, ...Locale[]] {
+  if (typeof navigator === 'undefined' || !navigator.languages?.length) {
+    return [FALLBACK_LOCALE]
+  }
+  const locales = [...navigator.languages].map(localeFor)
+  return locales.length > 0 ? (locales as [Locale, ...Locale[]]) : [FALLBACK_LOCALE]
+}
+
+function getCalendars(): [Calendar, ...Calendar[]] {
+  if (typeof Intl === 'undefined') return [FALLBACK_CALENDAR]
+  try {
+    const options = new Intl.DateTimeFormat().resolvedOptions()
+    const parsed = new Intl.Locale(options.locale) as Intl.Locale & {
+      hourCycle?: string
+      weekInfo?: { firstDay?: number }
+    }
+    const firstDay = parsed.weekInfo?.firstDay
+    return [
+      {
+        calendar: options.calendar ?? null,
+        timeZone: options.timeZone ?? null,
+        uses24hourClock:
+          parsed.hourCycle === undefined ? null : parsed.hourCycle === 'h23' || parsed.hourCycle === 'h24',
+        // weekInfo numbers monday as 1; expo numbers sunday as 1.
+        firstWeekday: firstDay === undefined ? null : (firstDay % 7) + 1,
+      },
+    ]
+  } catch {
+    return [FALLBACK_CALENDAR]
+  }
+}
+
+function subscribe(refresh: () => void): (() => void) | undefined {
+  if (typeof window === 'undefined') return undefined
+  window.addEventListener('languagechange', refresh)
+  return () => window.removeEventListener('languagechange', refresh)
+}
+
+function useLocales(): [Locale, ...Locale[]] {
+  const [locales, setLocales] = useState<[Locale, ...Locale[]]>(() => getLocales())
+  useEffect(() => subscribe(() => setLocales(getLocales())), [])
+  return locales
+}
+
+function useCalendars(): [Calendar, ...Calendar[]] {
+  const [calendars, setCalendars] = useState<[Calendar, ...Calendar[]]>(() => getCalendars())
+  useEffect(() => subscribe(() => setCalendars(getCalendars())), [])
+  return calendars
+}
+
+export const Localization: LocalizationApi = Object.freeze({ getLocales, getCalendars })
+export { useCalendars, useLocales }

package/src/platform/localization/map.ts

@@ -0,0 +1,77 @@
+import type { CalendarInfo, LocaleInfo } from '../specs/OneDevice.nitro'
+import type { Calendar, Locale } from './types'
+
+// the native spec carries unknown fields as undefined; expo's shape carries
+// them as null. this is the only place that conversion happens.
+export function toLocale(info: LocaleInfo): Locale {
+  return {
+    languageTag: info.languageTag,
+    languageCode: info.languageCode ?? null,
+    languageScriptCode: info.languageScriptCode ?? null,
+    regionCode: info.regionCode ?? null,
+    languageRegionCode: info.languageRegionCode ?? null,
+    currencyCode: info.currencyCode ?? null,
+    currencySymbol: info.currencySymbol ?? null,
+    languageCurrencyCode: info.languageCurrencyCode ?? null,
+    languageCurrencySymbol: info.languageCurrencySymbol ?? null,
+    decimalSeparator: info.decimalSeparator ?? null,
+    digitGroupingSeparator: info.digitGroupingSeparator ?? null,
+    textDirection: info.textDirection === 'rtl' ? 'rtl' : 'ltr',
+    measurementSystem:
+      info.measurementSystem === 'metric' ||
+      info.measurementSystem === 'us' ||
+      info.measurementSystem === 'uk'
+        ? info.measurementSystem
+        : null,
+    temperatureUnit:
+      info.temperatureUnit === 'celsius' || info.temperatureUnit === 'fahrenheit'
+        ? info.temperatureUnit
+        : null,
+  }
+}
+
+export function toCalendar(info: CalendarInfo): Calendar {
+  return {
+    calendar: info.calendar ?? null,
+    timeZone: info.timeZone ?? null,
+    uses24hourClock: info.uses24hourClock ?? null,
+    firstWeekday: info.firstWeekday ?? null,
+  }
+}
+
+// expo guarantees at least one entry. native always answers with the current
+// locale, so an empty list means a broken build: fall back to a plain en-US
+// snapshot rather than handing callers an empty array to crash on.
+export const FALLBACK_LOCALE: Locale = {
+  languageTag: 'en-US',
+  languageCode: 'en',
+  languageScriptCode: null,
+  regionCode: 'US',
+  languageRegionCode: 'US',
+  currencyCode: null,
+  currencySymbol: null,
+  languageCurrencyCode: null,
+  languageCurrencySymbol: null,
+  decimalSeparator: null,
+  digitGroupingSeparator: null,
+  textDirection: 'ltr',
+  measurementSystem: null,
+  temperatureUnit: null,
+}
+
+export const FALLBACK_CALENDAR: Calendar = {
+  calendar: 'gregory',
+  timeZone: null,
+  uses24hourClock: null,
+  firstWeekday: null,
+}
+
+export function toLocales(infos: LocaleInfo[]): [Locale, ...Locale[]] {
+  const locales = infos.map(toLocale)
+  return locales.length > 0 ? (locales as [Locale, ...Locale[]]) : [FALLBACK_LOCALE]
+}
+
+export function toCalendars(infos: CalendarInfo[]): [Calendar, ...Calendar[]] {
+  const calendars = infos.map(toCalendar)
+  return calendars.length > 0 ? (calendars as [Calendar, ...Calendar[]]) : [FALLBACK_CALENDAR]
+}

package/src/platform/localization/types.ts

@@ -0,0 +1,36 @@
+// expo-localization's Locale and Calendar shapes, field for field: unknown
+// values are null, never undefined, and text direction, measurement system
+// and temperature unit are lowercase string unions.
+
+export interface Locale {
+  languageTag: string
+  languageCode: string | null
+  languageScriptCode: string | null
+  regionCode: string | null
+  languageRegionCode: string | null
+  currencyCode: string | null
+  currencySymbol: string | null
+  languageCurrencyCode: string | null
+  languageCurrencySymbol: string | null
+  decimalSeparator: string | null
+  digitGroupingSeparator: string | null
+  textDirection: 'ltr' | 'rtl'
+  measurementSystem: 'metric' | 'us' | 'uk' | null
+  temperatureUnit: 'celsius' | 'fahrenheit' | null
+}
+
+export interface Calendar {
+  /** unicode calendar type, e.g. 'gregory', 'buddhist', 'islamic' */
+  calendar: string | null
+  timeZone: string | null
+  uses24hourClock: boolean | null
+  /** first day of the week: sunday is 1, saturday is 7 */
+  firstWeekday: number | null
+}
+
+export interface Localization {
+  /** preferred locales in the user's order, always at least one */
+  getLocales(): [Locale, ...Locale[]]
+  /** preferred calendars, always at least one */
+  getCalendars(): [Calendar, ...Calendar[]]
+}

package/src/platform/secure-store/index.native.ts

@@ -1,7 +1,14 @@
 import { NitroModules } from 'react-native-nitro-modules'
 import { rethrowNativeError } from '../nativeError'
 import type { OneSecureStore } from '../specs/OneSecureStore.nitro'
-import { assertSecureStoreKey, assertSecureStoreValue } from './validate'
+import type { SecureStoreOptions } from './types'
+import {
+  assertSecureStoreKey,
+  assertSecureStoreOptions,
+  assertSecureStoreValue,
+} from './validate'
+
+export type { SecureStoreAccessibility, SecureStoreOptions } from './types'
 
 // string key-value storage matching expo-secure-store's item api, backed by
 // the OneSecureStore nitro hybrid object (created on first use and cached).
@@ -13,49 +20,55 @@ function native(): OneSecureStore {
   return hybrid
 }
 
-function getItem(key: string): Promise<string | null> {
+function getItem(key: string, options?: SecureStoreOptions): Promise<string | null> {
   assertSecureStoreKey(key, 'SecureStore.getItem')
+  const checked = assertSecureStoreOptions(options, 'SecureStore.getItem')
   return native()
-    .getItem(key)
+    .getItem(key, checked)
     .then((value) => value ?? null, rethrowNativeError)
 }
 
-function setItem(key: string, value: string): Promise<void> {
+function setItem(key: string, value: string, options?: SecureStoreOptions): Promise<void> {
   assertSecureStoreKey(key, 'SecureStore.setItem')
   assertSecureStoreValue(value, 'SecureStore.setItem')
-  return native().setItem(key, value).catch(rethrowNativeError)
+  const checked = assertSecureStoreOptions(options, 'SecureStore.setItem')
+  return native().setItem(key, value, checked).catch(rethrowNativeError)
 }
 
-function deleteItem(key: string): Promise<void> {
+function deleteItem(key: string, options?: SecureStoreOptions): Promise<void> {
   assertSecureStoreKey(key, 'SecureStore.deleteItem')
-  return native().deleteItem(key).catch(rethrowNativeError)
+  const checked = assertSecureStoreOptions(options, 'SecureStore.deleteItem')
+  return native().deleteItem(key, checked).catch(rethrowNativeError)
 }
 
 // the synchronous verbs block the js thread on the keychain or keystore, as
 // expo-secure-store's getItem and setItem do: for values a first render needs
-function getItemSync(key: string): string | null {
+function getItemSync(key: string, options?: SecureStoreOptions): string | null {
   assertSecureStoreKey(key, 'SecureStore.getItemSync')
+  const checked = assertSecureStoreOptions(options, 'SecureStore.getItemSync')
   try {
-    return native().getItemSync(key) ?? null
+    return native().getItemSync(key, checked) ?? null
   } catch (error) {
     rethrowNativeError(error)
   }
 }
 
-function setItemSync(key: string, value: string): void {
+function setItemSync(key: string, value: string, options?: SecureStoreOptions): void {
   assertSecureStoreKey(key, 'SecureStore.setItemSync')
   assertSecureStoreValue(value, 'SecureStore.setItemSync')
+  const checked = assertSecureStoreOptions(options, 'SecureStore.setItemSync')
   try {
-    native().setItemSync(key, value)
+    native().setItemSync(key, value, checked)
   } catch (error) {
     rethrowNativeError(error)
   }
 }
 
-function deleteItemSync(key: string): void {
+function deleteItemSync(key: string, options?: SecureStoreOptions): void {
   assertSecureStoreKey(key, 'SecureStore.deleteItemSync')
+  const checked = assertSecureStoreOptions(options, 'SecureStore.deleteItemSync')
   try {
-    native().deleteItemSync(key)
+    native().deleteItemSync(key, checked)
   } catch (error) {
     rethrowNativeError(error)
   }

package/src/platform/secure-store/index.ts

@@ -1,38 +1,51 @@
-import { assertSecureStoreKey, assertSecureStoreValue } from './validate'
+import type { SecureStoreOptions } from './types'
+import {
+  assertSecureStoreKey,
+  assertSecureStoreOptions,
+  assertSecureStoreValue,
+} from './validate'
+
+export type { SecureStoreAccessibility, SecureStoreOptions } from './types'
 
 // web entry. secure storage has no honest web equivalent: anything kept in
 // localStorage or a cookie persists in cleartext, so every verb rejects
 // instead of faking it. same signatures as the native entry: the published
 // declarations are built from this file and serve both platforms.
-function getItem(key: string): Promise<string | null> {
+function getItem(key: string, options?: SecureStoreOptions): Promise<string | null> {
   assertSecureStoreKey(key, 'SecureStore.getItem')
+  assertSecureStoreOptions(options, 'SecureStore.getItem')
   return Promise.reject(new Error('SecureStore.getItem needs an iOS or Android build'))
 }
 
-function setItem(key: string, value: string): Promise<void> {
+function setItem(key: string, value: string, options?: SecureStoreOptions): Promise<void> {
   assertSecureStoreKey(key, 'SecureStore.setItem')
   assertSecureStoreValue(value, 'SecureStore.setItem')
+  assertSecureStoreOptions(options, 'SecureStore.setItem')
   return Promise.reject(new Error('SecureStore.setItem needs an iOS or Android build'))
 }
 
-function deleteItem(key: string): Promise<void> {
+function deleteItem(key: string, options?: SecureStoreOptions): Promise<void> {
   assertSecureStoreKey(key, 'SecureStore.deleteItem')
+  assertSecureStoreOptions(options, 'SecureStore.deleteItem')
   return Promise.reject(new Error('SecureStore.deleteItem needs an iOS or Android build'))
 }
 
-function getItemSync(key: string): string | null {
+function getItemSync(key: string, options?: SecureStoreOptions): string | null {
   assertSecureStoreKey(key, 'SecureStore.getItemSync')
+  assertSecureStoreOptions(options, 'SecureStore.getItemSync')
   throw new Error('SecureStore.getItemSync needs an iOS or Android build')
 }
 
-function setItemSync(key: string, value: string): void {
+function setItemSync(key: string, value: string, options?: SecureStoreOptions): void {
   assertSecureStoreKey(key, 'SecureStore.setItemSync')
   assertSecureStoreValue(value, 'SecureStore.setItemSync')
+  assertSecureStoreOptions(options, 'SecureStore.setItemSync')
   throw new Error('SecureStore.setItemSync needs an iOS or Android build')
 }
 
-function deleteItemSync(key: string): void {
+function deleteItemSync(key: string, options?: SecureStoreOptions): void {
   assertSecureStoreKey(key, 'SecureStore.deleteItemSync')
+  assertSecureStoreOptions(options, 'SecureStore.deleteItemSync')
   throw new Error('SecureStore.deleteItemSync needs an iOS or Android build')
 }
 

package/src/platform/secure-store/types.ts

@@ -0,0 +1,33 @@
+// expo-secure-store's SecureStoreOptions, with its numeric
+// KeychainAccessibilityConstant values as a lowercase string union.
+export type SecureStoreAccessibility =
+  | 'afterFirstUnlock'
+  | 'afterFirstUnlockThisDeviceOnly'
+  | 'always'
+  | 'alwaysThisDeviceOnly'
+  | 'whenPasscodeSetThisDeviceOnly'
+  | 'whenUnlocked'
+  | 'whenUnlockedThisDeviceOnly'
+
+export interface SecureStoreOptions {
+  /**
+   * ios: the keychain item's service (kSecAttrService). android: the
+   * AndroidKeyStore key alias. an item set with a service is read and
+   * deleted with the same service.
+   */
+  keychainService?: string
+  /** ios only: when the item is accessible (kSecAttrAccessible). default 'whenUnlocked' */
+  keychainAccessible?: SecureStoreAccessibility
+  /**
+   * require biometric authentication to read or write the item. ios uses a
+   * biometryCurrentSet access control; android uses a user-authentication
+   * bound AndroidKeyStore key, invalidated when biometrics change. on
+   * android the prompt needs a foreground activity, so the sync verbs throw
+   * for an authenticated item instead of prompting.
+   */
+  requireAuthentication?: boolean
+  /** message shown while requireAuthentication prompts */
+  authenticationPrompt?: string
+  /** ios only: the keychain access group the item belongs to */
+  accessGroup?: string
+}