@sendbird/uikit-react-native 1.0.0-rc.1

package/src/platform/createClipboardService.expo.ts

@@ -0,0 +1,16 @@
+import type * as Clipboard from 'expo-clipboard';
+
+import type { ClipboardServiceInterface } from './types';
+
+const createExpoClipboardService = (clipboardModule: typeof Clipboard): ClipboardServiceInterface => {
+  return {
+    getString(): Promise<string> {
+      return clipboardModule.getStringAsync();
+    },
+    setString(text: string) {
+      return clipboardModule.setString(text);
+    },
+  };
+};
+
+export default createExpoClipboardService;

package/src/platform/createClipboardService.native.ts

@@ -0,0 +1,16 @@
+import type Clipboard from '@react-native-clipboard/clipboard';
+
+import type { ClipboardServiceInterface } from './types';
+
+const createNativeClipboardService = (clipboardModule: typeof Clipboard): ClipboardServiceInterface => {
+  return {
+    getString(): Promise<string> {
+      return clipboardModule.getString();
+    },
+    setString(text: string) {
+      return clipboardModule.setString(text);
+    },
+  };
+};
+
+export default createNativeClipboardService;

package/src/platform/createFileService.expo.ts

@@ -0,0 +1,142 @@
+import type ExpoDocumentPicker from 'expo-document-picker';
+import type ExpoFs from 'expo-file-system';
+import type ExpoImagePicker from 'expo-image-picker';
+import type ExpoMediaLibrary from 'expo-media-library';
+
+import { getFileExtension, getFileType } from '@sendbird/uikit-utils';
+
+import type { ExpoMediaLibraryPermissionResponse, ExpoPermissionResponse } from '../utils/expoPermissionGranted';
+import expoPermissionGranted from '../utils/expoPermissionGranted';
+import fileTypeGuard from '../utils/fileTypeGuard';
+import type {
+  FilePickerResponse,
+  FileServiceInterface,
+  OpenCameraOptions,
+  OpenDocumentOptions,
+  OpenMediaLibraryOptions,
+  SaveOptions,
+} from './types';
+
+const createExpoFileService = ({
+  imagePickerModule,
+  documentPickerModule,
+  mediaLibraryModule,
+  fsModule,
+}: {
+  imagePickerModule: typeof ExpoImagePicker;
+  documentPickerModule: typeof ExpoDocumentPicker;
+  mediaLibraryModule: typeof ExpoMediaLibrary;
+  fsModule: typeof ExpoFs;
+}): FileServiceInterface => {
+  class ExpoFileServiceInterface implements FileServiceInterface {
+    async hasCameraPermission(): Promise<boolean> {
+      const res = (await imagePickerModule.getCameraPermissionsAsync()) as ExpoPermissionResponse;
+      return expoPermissionGranted([res]);
+    }
+    async requestCameraPermission(): Promise<boolean> {
+      const res = (await imagePickerModule.requestCameraPermissionsAsync()) as ExpoPermissionResponse;
+      return expoPermissionGranted([res]);
+    }
+    async hasMediaLibraryPermission(type: 'write' | 'read'): Promise<boolean> {
+      const perms = (await mediaLibraryModule.getPermissionsAsync(
+        type === 'write',
+      )) as ExpoMediaLibraryPermissionResponse;
+      return expoPermissionGranted([perms]);
+    }
+    async requestMediaLibraryPermission(type: 'write' | 'read'): Promise<boolean> {
+      const perms = (await mediaLibraryModule.requestPermissionsAsync(
+        type === 'write',
+      )) as ExpoMediaLibraryPermissionResponse;
+      return expoPermissionGranted([perms]);
+    }
+
+    async openCamera(options?: OpenCameraOptions): Promise<FilePickerResponse> {
+      const hasPermission = await this.hasCameraPermission();
+      if (!hasPermission) {
+        const granted = await this.requestCameraPermission();
+        if (!granted) {
+          options?.onOpenFailureWithToastMessage?.();
+          return null;
+        }
+      }
+
+      const response = await imagePickerModule.launchCameraAsync({
+        mediaTypes: (() => {
+          switch (options?.mediaType) {
+            case 'photo':
+              return imagePickerModule.MediaTypeOptions.Images;
+            case 'video':
+              return imagePickerModule.MediaTypeOptions.Videos;
+            default:
+              return imagePickerModule.MediaTypeOptions.All;
+          }
+        })(),
+      });
+
+      if (response.cancelled) return null;
+
+      const { uri } = response;
+      const { size } = await fsModule.getInfoAsync(response.uri);
+      const ext = getFileExtension(uri);
+      const type = getFileType(ext);
+
+      return fileTypeGuard({ uri, size, type: `${type}/${ext.slice(1)}`, name: Date.now() + ext });
+    }
+    async openMediaLibrary(options: OpenMediaLibraryOptions) {
+      const selectionLimit = options?.selectionLimit || 1;
+      const hasPermission = await this.hasMediaLibraryPermission('read');
+      if (!hasPermission) {
+        const granted = await this.requestMediaLibraryPermission('read');
+        if (!granted) {
+          options?.onOpenFailureWithToastMessage?.();
+          return null;
+        }
+      }
+
+      const response = await imagePickerModule.launchImageLibraryAsync({ allowsMultipleSelection: true });
+      if (response.cancelled) return null;
+
+      return Promise.all(
+        response.selected.slice(0, selectionLimit).map(async ({ uri }) => {
+          const { size } = await fsModule.getInfoAsync(uri);
+          const ext = getFileExtension(uri);
+          const type = getFileType(ext);
+          return fileTypeGuard({ uri, size, type: `${type}/${ext.slice(1)}`, name: Date.now() + ext });
+        }),
+      );
+    }
+
+    async openDocument(options?: OpenDocumentOptions): Promise<FilePickerResponse> {
+      try {
+        const response = await documentPickerModule.getDocumentAsync({ type: '*/*' });
+        if (response.type === 'cancel') return null;
+        const { mimeType, uri, size, name } = response;
+        return fileTypeGuard({ uri, size, name, type: mimeType });
+      } catch {
+        options?.onOpenFailureWithToastMessage?.();
+        return null;
+      }
+    }
+
+    async save(options: SaveOptions): Promise<string> {
+      const hasPermission = await this.hasMediaLibraryPermission('write');
+      if (!hasPermission) {
+        const granted = await this.requestMediaLibraryPermission('write');
+        if (!granted) throw new Error('Permission not granted');
+      }
+
+      const basePath = fsModule.documentDirectory || fsModule.cacheDirectory;
+      if (!basePath) throw new Error('Cannot determine directory');
+
+      const downloadPath = `${basePath}/${options.fileName}`;
+
+      const response = await fsModule.downloadAsync(options.fileUrl, downloadPath);
+      await mediaLibraryModule.saveToLibraryAsync(response.uri);
+      return response.uri;
+    }
+  }
+
+  return new ExpoFileServiceInterface();
+};
+
+export default createExpoFileService;

package/src/platform/createFileService.native.ts

@@ -0,0 +1,191 @@
+import type CameraRoll from '@react-native-community/cameraroll';
+import { Platform } from 'react-native';
+import type * as DocumentPicker from 'react-native-document-picker';
+import type * as FileAccess from 'react-native-file-access';
+import type * as ImagePicker from 'react-native-image-picker';
+import type * as Permissions from 'react-native-permissions';
+import type { Permission } from 'react-native-permissions';
+
+import { getFileExtension, getFileType } from '@sendbird/uikit-utils';
+
+import fileTypeGuard from '../utils/fileTypeGuard';
+import nativePermissionGranted from '../utils/nativePermissionGranted';
+import type {
+  FilePickerResponse,
+  FileServiceInterface,
+  OpenCameraOptions,
+  OpenDocumentOptions,
+  OpenMediaLibraryOptions,
+  SaveOptions,
+} from './types';
+
+function getAndroidStoragePermissionsByAPILevel(permissionModule: typeof Permissions): Permission[] {
+  if (Platform.OS !== 'android') return [];
+
+  if (Platform.Version > 32) {
+    return [
+      permissionModule.PERMISSIONS.ANDROID.READ_MEDIA_AUDIO,
+      permissionModule.PERMISSIONS.ANDROID.READ_MEDIA_IMAGES,
+      permissionModule.PERMISSIONS.ANDROID.READ_MEDIA_VIDEO,
+    ];
+  }
+
+  if (Platform.Version > 28) {
+    return [permissionModule.PERMISSIONS.ANDROID.READ_EXTERNAL_STORAGE];
+  }
+
+  return [
+    permissionModule.PERMISSIONS.ANDROID.WRITE_EXTERNAL_STORAGE,
+    permissionModule.PERMISSIONS.ANDROID.READ_EXTERNAL_STORAGE,
+  ];
+}
+
+const createNativeFileService = ({
+  imagePickerModule,
+  documentPickerModule,
+  permissionModule,
+  mediaLibraryModule,
+  fsModule,
+}: {
+  imagePickerModule: typeof ImagePicker;
+  documentPickerModule: typeof DocumentPicker;
+  permissionModule: typeof Permissions;
+  mediaLibraryModule: typeof CameraRoll;
+  fsModule: typeof FileAccess;
+}): FileServiceInterface => {
+  const cameraPermissions: Permission[] = Platform.select({
+    ios: [permissionModule.PERMISSIONS.IOS.CAMERA],
+    android: [permissionModule.PERMISSIONS.ANDROID.CAMERA],
+    default: [],
+  });
+  const mediaLibraryPermissions: Permission[] = Platform.select({
+    ios: [permissionModule.PERMISSIONS.IOS.MEDIA_LIBRARY, permissionModule.PERMISSIONS.IOS.PHOTO_LIBRARY],
+    android: getAndroidStoragePermissionsByAPILevel(permissionModule),
+    default: [],
+  });
+
+  class NativeFileService implements FileServiceInterface {
+    async hasCameraPermission(): Promise<boolean> {
+      const status = await permissionModule.checkMultiple(cameraPermissions);
+      return nativePermissionGranted(status);
+    }
+    async requestCameraPermission(): Promise<boolean> {
+      const status = await permissionModule.requestMultiple(cameraPermissions);
+      return nativePermissionGranted(status);
+    }
+    async hasMediaLibraryPermission(): Promise<boolean> {
+      const status = await permissionModule.checkMultiple(mediaLibraryPermissions);
+      return nativePermissionGranted(status);
+    }
+    async requestMediaLibraryPermission(): Promise<boolean> {
+      const status = await permissionModule.requestMultiple(mediaLibraryPermissions);
+      return nativePermissionGranted(status);
+    }
+
+    async openCamera(options?: OpenCameraOptions): Promise<FilePickerResponse> {
+      const hasPermission = await this.hasCameraPermission();
+      if (!hasPermission) {
+        const granted = await this.requestCameraPermission();
+        if (!granted) {
+          options?.onOpenFailureWithToastMessage?.();
+          return null;
+        }
+      }
+
+      const response = await imagePickerModule.launchCamera({
+        cameraType: options?.cameraType ?? 'back',
+        mediaType: options?.mediaType ?? 'photo',
+      });
+      if (response.didCancel) return null;
+      if (response.errorCode === 'camera_unavailable') {
+        options?.onOpenFailureWithToastMessage?.();
+        return null;
+      }
+
+      const { fileName: name, fileSize: size, type, uri } = response.assets?.[0] ?? {};
+      return fileTypeGuard({ uri, size, name, type });
+    }
+    async openMediaLibrary(options?: OpenMediaLibraryOptions): Promise<FilePickerResponse[] | null> {
+      /**
+       * NOTE: options.selectionLimit {@link https://github.com/react-native-image-picker/react-native-image-picker#options}
+       * We do not support 0 (any number of files)
+       **/
+      const selectionLimit = options?.selectionLimit || 1;
+      const hasPermission = await this.hasMediaLibraryPermission();
+      if (!hasPermission) {
+        const granted = await this.requestMediaLibraryPermission();
+        if (!granted) {
+          options?.onOpenFailureWithToastMessage?.();
+          return null;
+        }
+      }
+
+      const response = await imagePickerModule.launchImageLibrary({
+        selectionLimit,
+        mediaType: (() => {
+          switch (options?.mediaType) {
+            case 'photo':
+              return 'photo';
+            case 'video':
+              return 'video';
+            default:
+              return 'mixed';
+          }
+        })(),
+      });
+      if (response.didCancel) return null;
+      if (response.errorCode === 'camera_unavailable') {
+        options?.onOpenFailureWithToastMessage?.();
+        return null;
+      }
+
+      return (response.assets || [])
+        .slice(0, selectionLimit)
+        .map(({ fileName: name, fileSize: size, type, uri }) => fileTypeGuard({ uri, size, name, type }));
+    }
+    async openDocument(options?: OpenDocumentOptions): Promise<FilePickerResponse> {
+      try {
+        const { uri, size, name, type } = await documentPickerModule.pickSingle();
+        return fileTypeGuard({ uri, size, name, type });
+      } catch (e) {
+        if (!documentPickerModule.isCancel(e) && documentPickerModule.isInProgress(e)) {
+          options?.onOpenFailureWithToastMessage?.();
+        }
+        return null;
+      }
+    }
+    async save(options: SaveOptions): Promise<string> {
+      const hasPermission = await this.hasMediaLibraryPermission();
+      if (!hasPermission) {
+        const granted = await this.requestMediaLibraryPermission();
+        if (!granted) throw new Error('Permission not granted');
+      }
+
+      const basePath = Platform.select({ android: fsModule.Dirs.CacheDir, default: fsModule.Dirs.DocumentDir });
+      let downloadPath = `${basePath}/${options.fileName}`;
+      if (!getFileExtension(options.fileName)) {
+        const extensionFromUrl = getFileExtension(options.fileUrl);
+        if (getFileType(extensionFromUrl).match(/image|video/)) {
+          downloadPath += extensionFromUrl;
+        }
+      }
+
+      await fsModule.FileSystem.fetch(options.fileUrl, { path: downloadPath });
+      const fileType = getFileType(getFileExtension(options.fileUrl));
+
+      if (Platform.OS === 'ios' && fileType.match(/image|video/)) {
+        await mediaLibraryModule.save(downloadPath);
+      }
+
+      if (Platform.OS === 'android') {
+        const dirType = { 'file': 'downloads', 'audio': 'audio', 'image': 'images', 'video': 'video' } as const;
+        await fsModule.FileSystem.cpExternal(downloadPath, options.fileName, dirType[fileType]);
+      }
+      return downloadPath;
+    }
+  }
+
+  return new NativeFileService();
+};
+
+export default createNativeFileService;

package/src/platform/createNotificationService.expo.ts

@@ -0,0 +1,36 @@
+import type ExpoNotification from 'expo-notifications';
+
+import type { ExpoPushPermissionResponse } from '../utils/expoPermissionGranted';
+import type { NotificationServiceInterface } from './types';
+
+const createExpoNotificationService = (messagingModule: typeof ExpoNotification): NotificationServiceInterface => {
+  const authorizedStatus = [
+    messagingModule.IosAuthorizationStatus.AUTHORIZED,
+    messagingModule.IosAuthorizationStatus.PROVISIONAL,
+  ];
+
+  return {
+    async getAPNSToken(): Promise<string | null> {
+      const response = await messagingModule.getDevicePushTokenAsync();
+      return response.data;
+    },
+    async getFCMToken(): Promise<string | null> {
+      const response = await messagingModule.getDevicePushTokenAsync();
+      return response.data;
+    },
+    async hasPushPermission(): Promise<boolean> {
+      const status = (await messagingModule.getPermissionsAsync()) as ExpoPushPermissionResponse;
+      return Boolean(status.granted || (status.ios?.status && authorizedStatus.includes(status.ios.status)));
+    },
+    async requestPushPermission(): Promise<boolean> {
+      const status = (await messagingModule.requestPermissionsAsync()) as ExpoPushPermissionResponse;
+      return Boolean(status.granted || (status.ios?.status && authorizedStatus.includes(status.ios.status)));
+    },
+    onTokenRefresh(handler: (token: string) => void): () => void | undefined {
+      const subscription = messagingModule.addPushTokenListener(({ data }) => handler(data));
+      return () => messagingModule.removePushTokenSubscription(subscription);
+    },
+  };
+};
+
+export default createExpoNotificationService;

package/src/platform/createNotificationService.native.ts

@@ -0,0 +1,60 @@
+import type RNFBMessaging from '@react-native-firebase/messaging';
+import { Platform } from 'react-native';
+import type * as Permissions from 'react-native-permissions';
+
+import type { NotificationServiceInterface } from './types';
+
+const createNativeNotificationService = ({
+  messagingModule,
+  permissionModule,
+}: {
+  messagingModule: typeof RNFBMessaging;
+  permissionModule: typeof Permissions;
+}): NotificationServiceInterface => {
+  const module = messagingModule();
+  const authorizedStatus = [
+    messagingModule.AuthorizationStatus.AUTHORIZED,
+    messagingModule.AuthorizationStatus.PROVISIONAL,
+  ];
+  return {
+    getAPNSToken(): Promise<string | null> {
+      return module.getAPNSToken();
+    },
+    getFCMToken(): Promise<string | null> {
+      return module.getToken();
+    },
+    async hasPushPermission(): Promise<boolean> {
+      if (Platform.OS === 'android') {
+        const result = await permissionModule.checkNotifications();
+        return result.status === 'granted';
+      }
+
+      if (Platform.OS === 'ios') {
+        const status = await module.hasPermission();
+        return authorizedStatus.includes(status);
+      }
+
+      return false;
+    },
+    async requestPushPermission(): Promise<boolean> {
+      if (Platform.OS === 'android') {
+        const result = await permissionModule.requestNotifications([]);
+        return result.status === 'granted';
+      }
+
+      if (Platform.OS === 'ios') {
+        const status = await module.requestPermission();
+        return authorizedStatus.includes(status);
+      }
+
+      return false;
+    },
+    onTokenRefresh(handler: (token: string) => void): () => void | undefined {
+      return module.onTokenRefresh((token) => {
+        if (Platform.OS === 'android') handler(token);
+      });
+    },
+  };
+};
+
+export default createNativeNotificationService;

package/src/platform/dynamicModule.ts

@@ -0,0 +1,110 @@
+/* eslint-disable no-console */
+import type RNNetInfo from '@react-native-community/netinfo';
+import { NativeModules } from 'react-native';
+import type RNFastImage from 'react-native-fast-image';
+import type RNFileAccess from 'react-native-file-access';
+
+import { Logger } from '@sendbird/uikit-utils';
+
+export interface DynamicModules {
+  'react-native-file-access': typeof RNFileAccess;
+  'react-native-fast-image': typeof RNFastImage;
+  '@react-native-community/netinfo': typeof RNNetInfo;
+}
+export type SBUNativeModule = keyof DynamicModules;
+
+interface SBUDynamicModuleInfo {
+  packageName: SBUNativeModule;
+  minVersion: string;
+  moduleName: string;
+  getPackage: <T>(logLevel: 'error' | 'warn' | 'none') => T;
+  url: string;
+}
+
+export function checkVersion(minVersion: string, currentVersion: string) {
+  const [minMajor, minMinor, minPatch] = minVersion.split('.');
+  const [currMajor, currMinor, currPatch] = currentVersion.split('.');
+
+  if (minMajor < currMajor) return true;
+  if (minMajor === currMajor) {
+    if (minMinor < currMinor) return true;
+    if (minMinor === currMinor) {
+      return minPatch <= currPatch;
+    }
+    return false;
+  }
+  return false;
+}
+
+function checkLink(dmi: SBUDynamicModuleInfo, logLevel: 'error' | 'warn' | 'none') {
+  const nativeModule = NativeModules[dmi.moduleName];
+  if (!nativeModule) {
+    const message = `[UIKit] Cannot use native module, you should install and link ${dmi.packageName} (${dmi.url})`;
+    if (logLevel === 'error') console.error(message);
+    if (logLevel === 'warn') console.warn(message);
+  }
+}
+
+const SBUDynamicModuleRegistry: Record<SBUNativeModule, SBUDynamicModuleInfo> = {
+  'react-native-file-access': {
+    minVersion: '2.4.3',
+    packageName: 'react-native-file-access',
+    moduleName: 'RNFileAccess',
+    url: 'https://github.com/alpha0010/react-native-file-access',
+    getPackage(logLevel) {
+      checkLink(this, logLevel);
+
+      try {
+        return require('react-native-file-access');
+      } catch (e) {
+        return null;
+      }
+    },
+  },
+  'react-native-fast-image': {
+    minVersion: '8.5.11',
+    packageName: 'react-native-fast-image',
+    moduleName: 'FastImageView',
+    url: 'https://github.com/DylanVann/react-native-fast-image',
+    getPackage(logLevel) {
+      checkLink(this, logLevel);
+
+      try {
+        return require('react-native-fast-image');
+      } catch (e) {
+        return null;
+      }
+    },
+  },
+  '@react-native-community/netinfo': {
+    minVersion: '9.3.0',
+    packageName: '@react-native-community/netinfo',
+    moduleName: 'RNCNetInfo',
+    url: 'https://github.com/react-native-netinfo/react-native-netinfo',
+    getPackage(logLevel) {
+      checkLink(this, logLevel);
+
+      try {
+        return require('@react-native-community/netinfo');
+      } catch (e) {
+        return null;
+      }
+    },
+  },
+};
+
+const SBUDynamicModule = {
+  register(mdi: SBUDynamicModuleInfo) {
+    SBUDynamicModuleRegistry[mdi.moduleName as SBUNativeModule] = mdi;
+  },
+  getInfo(name: SBUNativeModule) {
+    return SBUDynamicModuleRegistry[name] ?? null;
+  },
+  get<K extends SBUNativeModule, T extends DynamicModules[K]>(name: K, logLevel: 'error' | 'warn' | 'none' = 'error') {
+    const dmi = this.getInfo(name);
+    if (!dmi) Logger.warn(`${name} doesn't exist in the dynamic module`);
+    return dmi?.getPackage<T>(logLevel);
+  },
+};
+
+export default SBUDynamicModule;

package/src/platform/types.ts

@@ -0,0 +1,51 @@
+export type Unsubscribe = () => void | undefined;
+export type DownloadedPath = string;
+export type FilePickerResponse = FileType | null;
+export type FileType = { uri: string; size: number; name: string; type: string };
+
+export interface NotificationServiceInterface {
+  hasPushPermission(): Promise<boolean>;
+  requestPushPermission(): Promise<boolean>;
+
+  getAPNSToken(): Promise<string | null>;
+  getFCMToken(): Promise<string | null>;
+  onTokenRefresh(handler: (token: string) => void): Unsubscribe;
+}
+
+export interface ClipboardServiceInterface {
+  setString(text: string): void;
+  getString(): Promise<string>;
+}
+
+export interface FileServiceInterface extends FilePickerServiceInterface, FileSystemServiceInterface {}
+
+export interface OpenResultListener {
+  onOpenFailureWithToastMessage?: () => void;
+}
+export interface OpenMediaLibraryOptions extends OpenResultListener {
+  selectionLimit?: number;
+  mediaType?: 'photo' | 'video' | 'all';
+}
+export interface OpenCameraOptions extends OpenResultListener {
+  cameraType?: 'front' | 'back';
+  mediaType?: 'photo' | 'video';
+}
+export type OpenDocumentOptions = OpenResultListener;
+export interface SaveOptions {
+  fileUrl: string;
+  fileName: string;
+  fileType?: string | null;
+}
+
+export interface FilePickerServiceInterface {
+  openMediaLibrary(options?: OpenMediaLibraryOptions): Promise<null | FilePickerResponse[]>;
+  openCamera(options?: OpenCameraOptions): Promise<FilePickerResponse>;
+  openDocument(options?: OpenDocumentOptions): Promise<FilePickerResponse>;
+}
+
+export interface FileSystemServiceInterface {
+  // NOTE: On iOS, You can access the downloaded files by providing options below to info.plist
+  // - Supports opening documents in place
+  // - Application supports iTunes file sharing
+  save(options?: SaveOptions): Promise<DownloadedPath | null>;
+}

package/src/types.ts

@@ -0,0 +1,18 @@
+import type { ErrorInfo, ReactNode } from 'react';
+
+export type KeyValuePairGet = [string, string | null];
+export type KeyValuePairSet = [string, string];
+export interface LocalCacheStorage {
+  getAllKeys(): Promise<readonly string[] | string[]>;
+  getItem(key: string): Promise<string | null>;
+  setItem(key: string, value: string): Promise<void>;
+  removeItem(key: string): Promise<void>;
+
+  multiSet?(keyValuePairs: Array<KeyValuePairSet>): Promise<void>;
+  multiGet?(keys: string[]): Promise<readonly KeyValuePairGet[] | KeyValuePairGet[]>;
+  multiRemove?(keys: string[]): Promise<void>;
+}
+
+export type ErrorBoundaryProps = { error: Error; errorInfo: ErrorInfo; reset: () => void };
+
+export type CommonComponent<P = {}> = (props: P & { children?: ReactNode }) => null | JSX.Element; //ReactNode;

package/src/utils/expoPermissionGranted.ts

@@ -0,0 +1,39 @@
+import type { NotificationPermissionsStatus } from 'expo-notifications';
+
+export interface ExpoPermissionResponse {
+  canAskAgain: boolean;
+  granted: boolean;
+  status: 'denied' | 'granted' | 'undetermined';
+}
+
+export interface ExpoMediaLibraryPermissionResponse extends ExpoPermissionResponse {
+  accessPrivileges?: 'all' | 'limited' | 'none';
+}
+export interface ExpoPushPermissionResponse extends ExpoPermissionResponse, NotificationPermissionsStatus {}
+
+const expoPermissionGranted = (
+  stats: Array<ExpoMediaLibraryPermissionResponse | ExpoPushPermissionResponse | ExpoPermissionResponse>,
+  limitedCallback?: () => void,
+) => {
+  return stats.every((res) => {
+    if ('accessPrivileges' in res) {
+      if (res.accessPrivileges === 'limited') limitedCallback?.();
+      return (
+        res.granted || res.status === 'granted' || res.accessPrivileges === 'all' || res.accessPrivileges === 'limited'
+      );
+    }
+    if ('ios' in res) {
+      // NOT_DETERMINED = 0,
+      // DENIED = 1,
+      // AUTHORIZED = 2,
+      // PROVISIONAL = 3,
+      // EPHEMERAL = 4,
+      return (
+        res.granted || res.status === 'granted' || (res.ios?.status && (res.ios.status === 2 || res.ios.status === 3))
+      );
+    }
+    return res.granted || res.status === 'granted';
+  });
+};
+
+export default expoPermissionGranted;