react-native-cloud-storage 2.3.0 → 3.0.0

package/src/storages/google-drive/client.ts

@@ -116,7 +116,7 @@ export default class GoogleDriveApiClient {
     return body.join('');
   }
 
-  public async listFiles(space: GoogleDriveFileSpace): Promise<GoogleDriveFile[]> {
+  public async listFiles(space: GoogleDriveFileSpace, query?: string): Promise<GoogleDriveFile[]> {
     const files: GoogleDriveFile[] = [];
     let pageToken: string | undefined;
     const fields = ['id', 'kind', 'mimeType', 'name', 'parents', 'spaces', 'size', 'createdTime', 'modifiedTime'];
@@ -125,6 +125,7 @@ export default class GoogleDriveApiClient {
         fields: `files(${fields.join(',')}),nextPageToken`,
         spaces: space,
         pageToken,
+        q: query,
       };
       const response = await this.request<GoogleDriveListOperationResponse>(`/files`, {
         queryParameters,

package/src/storages/google-drive/index.ts

@@ -49,13 +49,23 @@ export default class GoogleDrive implements NativeStorage {
       case 'documents': {
         return 'drive';
       }
+      case 'documents_legacy': {
+        return 'drive';
+      }
       case 'app_data': {
         return 'appDataFolder';
       }
     }
   }
 
-  private resolvePathToDirectories(path: string): { directories: string[]; filename: string } {
+  private isRootPath(path: string): boolean {
+    return path === '' || path === '/';
+  }
+
+  private resolvePathToDirectories(path: string): {
+    directories: string[];
+    filename: string;
+  } {
     if (path.startsWith('/')) path = path.slice(1);
     if (path.endsWith('/')) path = path.slice(0, -1);
     const directories = path.split('/');
@@ -63,86 +73,90 @@ export default class GoogleDrive implements NativeStorage {
     return { directories, filename: actualFilename };
   }
 
-  private findParentDirectoryId(files: GoogleDriveFile[], directoryTree: string[]): string | null {
-    const possibleTopDirectories = files
-      .filter((f) => f.mimeType === MimeTypes.FOLDER)
-      .filter((f) => f.name === directoryTree[0]);
+  private escapeDriveQueryValue(value: string): string {
+    return value.replaceAll('\\', String.raw`\\`).replaceAll("'", String.raw`\'`);
+  }
 
-    let topDirectoryId: string | undefined;
-    if (possibleTopDirectories.length === 0) return null;
-    else if (possibleTopDirectories.length === 1) {
-      topDirectoryId = possibleTopDirectories[0]!.id;
-    } else {
-      /* when multiple directories carry the same name, we need to check every one of them if their parent id exists in
-      the files array - if it does not, it means that the directory is a child of the root directory and the one we're
-      looking for */
-      for (const possibleTopDirectory of possibleTopDirectories) {
-        if (!files.some((f) => f.id === possibleTopDirectory!.parents![0] && f.mimeType === MimeTypes.FOLDER)) {
-          topDirectoryId = possibleTopDirectory!.id;
-          break;
-        }
-      }
+  private async getQueryRootParentId(scope: NativeStorageScope): Promise<string> {
+    if (scope === 'app_data') {
+      return this.getRootDirectory(scope);
     }
 
-    if (!topDirectoryId) {
-      throw new CloudStorageError(
-        `Could not find top directory with name ${directoryTree[0]}`,
-        NativeCloudStorageErrorCode.DIRECTORY_NOT_FOUND
-      );
-    }
+    return this.getRootDirectoryId(scope);
+  }
 
-    // now, we traverse the directories array and get the id of the last directory from the files array
-    let currentDirectoryId = topDirectoryId;
-    for (let index = 1; index < directoryTree.length; index++) {
-      const currentDirectory = files.find((f) => f.id === currentDirectoryId);
-      if (!currentDirectory)
-        throw new CloudStorageError(
-          `Could not find directory with id ${currentDirectoryId}`,
-          NativeCloudStorageErrorCode.DIRECTORY_NOT_FOUND
-        );
-      const nextDirectory = files.find((f) => f.name === directoryTree[index] && f.parents![0] === currentDirectoryId);
-      if (!nextDirectory)
-        throw new CloudStorageError(
-          `Could not find directory with name ${directoryTree[index]}`,
-          NativeCloudStorageErrorCode.DIRECTORY_NOT_FOUND
-        );
-      currentDirectoryId = nextDirectory.id;
+  private async findDirectoryByNameAndParent(
+    name: string,
+    parentId: string,
+    scope: NativeStorageScope
+  ): Promise<GoogleDriveFile[]> {
+    const escapedName = this.escapeDriveQueryValue(name);
+    const escapedParentId = this.escapeDriveQueryValue(parentId);
+    const query = `name = '${escapedName}' and '${escapedParentId}' in parents and mimeType = '${MimeTypes.FOLDER}' and trashed = false`;
+    return this.drive.listFiles(this.getRootDirectory(scope), query);
+  }
+
+  private async findFilesByNameAndParent(
+    name: string,
+    parentId: string,
+    scope: NativeStorageScope
+  ): Promise<GoogleDriveFile[]> {
+    const escapedName = this.escapeDriveQueryValue(name);
+    const escapedParentId = this.escapeDriveQueryValue(parentId);
+    const query = `name = '${escapedName}' and '${escapedParentId}' in parents and trashed = false`;
+    return this.drive.listFiles(this.getRootDirectory(scope), query);
+  }
+
+  private async findFilesByParent(parentId: string, scope: NativeStorageScope): Promise<GoogleDriveFile[]> {
+    const escapedParentId = this.escapeDriveQueryValue(parentId);
+    const query = `'${escapedParentId}' in parents and trashed = false`;
+    return this.drive.listFiles(this.getRootDirectory(scope), query);
+  }
+
+  private async findParentDirectoryId(directoryTree: string[], scope: NativeStorageScope): Promise<string | null> {
+    let parentDirectoryId = await this.getQueryRootParentId(scope);
+
+    for (const directoryName of directoryTree) {
+      const directories = await this.findDirectoryByNameAndParent(directoryName, parentDirectoryId, scope);
+      if (directories.length === 0) {
+        return null;
+      }
+
+      parentDirectoryId = directories[0]!.id;
     }
 
-    return currentDirectoryId;
+    return parentDirectoryId;
   }
 
   /**
    * Gets the Google Drive ID of the root directory for the given scope.
    * @param scope The scope to get the root directory for.
-   * @returns A promise that resolves to the ID of the root directory or null if it could not be found.
+   * @returns A promise that resolves to the ID of the root directory.
    */
-  private async getRootDirectoryId(scope: NativeStorageScope): Promise<string | null> {
+  private async getRootDirectoryId(scope: NativeStorageScope): Promise<string> {
+    if (scope !== 'app_data') {
+      return 'root';
+    }
+
     const files = await this.drive.listFiles(this.getRootDirectory(scope));
     for (const file of files) {
-      if (!files.some((f) => f.id === file.parents![0])) return file.parents![0] ?? null;
+      const parentId = file.parents?.[0];
+      if (parentId && !files.some((candidate) => candidate.id === parentId)) {
+        return parentId;
+      }
     }
 
-    return null;
+    return this.getRootDirectory(scope);
   }
 
-  private checkIfMultipleFilesWithSameName(
-    path: string,
-    files: GoogleDriveFile[],
-    filename: string,
-    parentDirectoryId: string | null
-  ) {
+  private checkIfMultipleFilesWithSameName(path: string, files: GoogleDriveFile[]) {
     const { strictFilenames } = this.options;
 
-    const possibleFiles: GoogleDriveFile[] = parentDirectoryId
-      ? files.filter((f) => f.name === filename && f.parents![0] === parentDirectoryId)
-      : files.filter((f) => f.name === filename && !files.some((f2) => f2.id === f.parents![0]));
-
-    if (possibleFiles.length <= 1) return;
+    if (files.length <= 1) return;
 
     if (strictFilenames) {
       throw new CloudStorageError(
-        `Multiple files with the same name found at path ${path}: ${possibleFiles.map((f) => f.id).join(', ')}`,
+        `Multiple files with the same name found at path ${path}: ${files.map((f) => f.id).join(', ')}`,
         NativeCloudStorageErrorCode.MULTIPLE_FILES_SAME_NAME
       );
     }
@@ -154,30 +168,29 @@ export default class GoogleDrive implements NativeStorage {
     throwIf: 'directory' | 'file' | false = false
   ): Promise<string> {
     try {
-      const files = await this.drive.listFiles(this.getRootDirectory(scope));
+      if (this.isRootPath(path)) {
+        if (throwIf === 'directory') {
+          throw new CloudStorageError(`Path ${path} is a directory`, NativeCloudStorageErrorCode.PATH_IS_DIRECTORY);
+        }
 
-      if (path === '' || path === '/') {
         const rootDirectoryId = await this.getRootDirectoryId(scope);
-        if (!rootDirectoryId)
-          throw new CloudStorageError(
-            `Root directory in scope ${scope} not found`,
-            NativeCloudStorageErrorCode.DIRECTORY_NOT_FOUND
-          );
+        if (scope !== 'app_data') {
+          await this.drive.getFile(rootDirectoryId);
+        }
+
         return rootDirectoryId;
       }
 
       const { directories, filename } = this.resolvePathToDirectories(path);
-      const parentDirectoryId = this.findParentDirectoryId(files, directories);
-      let file: GoogleDriveFile | undefined;
+      const parentDirectoryId = await this.findParentDirectoryId(directories, scope);
       if (parentDirectoryId === null) {
-        this.checkIfMultipleFilesWithSameName(path, files, filename, null);
-        /* when the file is supposed to be in the root directory, we need to get the file where the name is the filename
-        and the first parent has an id which does not exist in the files array */
-        file = files.find((f) => f.name === filename && !files.some((f2) => f2.id === f.parents![0]));
-      } else {
-        this.checkIfMultipleFilesWithSameName(path, files, filename, parentDirectoryId);
-        file = files.find((f) => f.name === filename && f.parents![0] === parentDirectoryId);
+        throw new CloudStorageError(`File not found`, NativeCloudStorageErrorCode.FILE_NOT_FOUND);
       }
+
+      const files = await this.findFilesByNameAndParent(filename, parentDirectoryId, scope);
+      this.checkIfMultipleFilesWithSameName(path, files);
+
+      const file = files[0];
       if (!file) throw new CloudStorageError(`File not found`, NativeCloudStorageErrorCode.FILE_NOT_FOUND);
       if (file.mimeType === MimeTypes.FOLDER && throwIf === 'directory') {
         throw new CloudStorageError(`Path ${path} is a directory`, NativeCloudStorageErrorCode.PATH_IS_DIRECTORY);
@@ -217,7 +230,7 @@ export default class GoogleDrive implements NativeStorage {
     let fileId: string | undefined;
     let previousContent = '';
     try {
-      fileId = await this.getFileId(path, scope);
+      fileId = await this.getFileId(path, scope, 'directory');
       previousContent = await this.drive.getFileText(fileId);
     } catch (error: unknown) {
       if (error instanceof CloudStorageError && error.code === NativeCloudStorageErrorCode.FILE_NOT_FOUND) {
@@ -233,17 +246,16 @@ export default class GoogleDrive implements NativeStorage {
         mimeType: MimeTypes.TEXT,
       });
     } else {
-      const files = await this.drive.listFiles(this.getRootDirectory(scope));
       const { directories, filename } = this.resolvePathToDirectories(path);
-      const parentDirectoryId = this.findParentDirectoryId(files, directories);
+      const parentDirectoryId = await this.findParentDirectoryId(directories, scope);
+      if (parentDirectoryId === null) {
+        throw new CloudStorageError(`Directory not found`, NativeCloudStorageErrorCode.DIRECTORY_NOT_FOUND);
+      }
+
       await this.drive.createFile(
         {
           name: filename,
-          parents: parentDirectoryId
-            ? [parentDirectoryId]
-            : scope === 'app_data'
-            ? [this.getRootDirectory(scope)]
-            : undefined,
+          parents: [parentDirectoryId],
         },
         {
           body: data,
@@ -257,7 +269,7 @@ export default class GoogleDrive implements NativeStorage {
     let fileId: string | undefined;
     if (overwrite) {
       try {
-        fileId = await this.getFileId(path, scope);
+        fileId = await this.getFileId(path, scope, 'directory');
       } catch (error: unknown) {
         if (error instanceof CloudStorageError && error.code === NativeCloudStorageErrorCode.FILE_NOT_FOUND) {
           /* do nothing, simply create the file */
@@ -267,7 +279,7 @@ export default class GoogleDrive implements NativeStorage {
       }
     } else {
       try {
-        await this.getFileId(path, scope);
+        await this.getFileId(path, scope, 'directory');
         throw new CloudStorageError(`File ${path} already exists`, NativeCloudStorageErrorCode.FILE_ALREADY_EXISTS);
       } catch (error: unknown) {
         if (error instanceof CloudStorageError && error.code === NativeCloudStorageErrorCode.FILE_NOT_FOUND) {
@@ -284,17 +296,16 @@ export default class GoogleDrive implements NativeStorage {
         mimeType: MimeTypes.TEXT,
       });
     } else {
-      const files = await this.drive.listFiles(this.getRootDirectory(scope));
       const { directories, filename } = this.resolvePathToDirectories(path);
-      const parentDirectoryId = this.findParentDirectoryId(files, directories);
+      const parentDirectoryId = await this.findParentDirectoryId(directories, scope);
+      if (parentDirectoryId === null) {
+        throw new CloudStorageError(`Directory not found`, NativeCloudStorageErrorCode.DIRECTORY_NOT_FOUND);
+      }
+
       await this.drive.createFile(
         {
           name: filename,
-          parents: parentDirectoryId
-            ? [parentDirectoryId]
-            : scope === 'app_data'
-            ? [this.getRootDirectory(scope)]
-            : undefined,
+          parents: [parentDirectoryId],
         },
         {
           body: data,
@@ -305,25 +316,25 @@ export default class GoogleDrive implements NativeStorage {
   }
 
   async listFiles(path: string, scope: NativeStorageScope): Promise<string[]> {
-    const allFiles = await this.drive.listFiles(this.getRootDirectory(scope));
-    if (path === '') {
-      const rootDirectoryId = await this.getRootDirectoryId(scope);
-      return [...new Set(allFiles.filter((f) => (f.parents ?? [])[0] === rootDirectoryId).map((f) => f.name))];
-    } else {
-      const fileId = await this.getFileId(path, scope);
-      const files = allFiles.filter((f) => (f.parents ?? [])[0] === fileId);
+    const parentDirectoryId = this.isRootPath(path)
+      ? await this.getQueryRootParentId(scope)
+      : await this.getFileId(path, scope);
 
-      return [...new Set(files.map((f) => f.name))];
-    }
+    const files = await this.findFilesByParent(parentDirectoryId, scope);
+    return [...new Set(files.map((f) => f.name))];
   }
 
   async createDirectory(path: string, scope: NativeStorageScope): Promise<void> {
+    if (this.isRootPath(path)) {
+      throw new CloudStorageError(`Directory ${path} already exists`, NativeCloudStorageErrorCode.FILE_ALREADY_EXISTS);
+    }
+
     try {
       await this.getFileId(path, scope);
       throw new CloudStorageError(`File ${path} already exists`, NativeCloudStorageErrorCode.FILE_ALREADY_EXISTS);
     } catch (error: unknown) {
       if (error instanceof CloudStorageError && error.code === NativeCloudStorageErrorCode.FILE_NOT_FOUND) {
-        /* do nothing, simply create the file */
+        /* do nothing, simply create the directory */
       } else if (error instanceof CloudStorageError && error.code === NativeCloudStorageErrorCode.PATH_IS_DIRECTORY) {
         throw new CloudStorageError(
           `Directory ${path} already exists`,
@@ -334,22 +345,20 @@ export default class GoogleDrive implements NativeStorage {
       }
     }
 
-    const files = await this.drive.listFiles(this.getRootDirectory(scope));
     const { directories, filename } = this.resolvePathToDirectories(path);
-    const parentDirectoryId = this.findParentDirectoryId(files, directories);
+    const parentDirectoryId = await this.findParentDirectoryId(directories, scope);
+    if (parentDirectoryId === null) {
+      throw new CloudStorageError(`Directory not found`, NativeCloudStorageErrorCode.DIRECTORY_NOT_FOUND);
+    }
 
     await this.drive.createDirectory({
       name: filename,
-      parents: parentDirectoryId
-        ? [parentDirectoryId]
-        : scope === 'app_data'
-        ? [this.getRootDirectory(scope)]
-        : undefined,
+      parents: [parentDirectoryId],
     });
   }
 
   async readFile(path: string, scope: NativeStorageScope): Promise<string> {
-    const fileId = await this.getFileId(path, scope);
+    const fileId = await this.getFileId(path, scope, 'directory');
     const content = await this.drive.getFileText(fileId);
     return content;
   }
@@ -371,8 +380,7 @@ export default class GoogleDrive implements NativeStorage {
 
     if (!recursive) {
       // check if the directory is empty
-      const files = await this.drive.listFiles(this.getRootDirectory(scope));
-      const filesInDirectory = files.filter((f) => (f.parents ?? [])[0] === fileId);
+      const filesInDirectory = await this.findFilesByParent(fileId, scope);
       if (filesInDirectory.length > 0) {
         throw new CloudStorageError(
           `Directory ${path} is not empty`,
@@ -425,7 +433,7 @@ export default class GoogleDrive implements NativeStorage {
 
     if (overwrite) {
       try {
-        fileId = await this.getFileId(remotePath, scope);
+        fileId = await this.getFileId(remotePath, scope, 'directory');
       } catch (error: unknown) {
         if (error instanceof CloudStorageError && error.code === NativeCloudStorageErrorCode.FILE_NOT_FOUND) {
           /* File doesn't exist -> we'll create it below */
@@ -435,7 +443,7 @@ export default class GoogleDrive implements NativeStorage {
       }
     } else {
       try {
-        await this.getFileId(remotePath, scope);
+        await this.getFileId(remotePath, scope, 'directory');
         throw new CloudStorageError(
           `File ${remotePath} already exists`,
           NativeCloudStorageErrorCode.FILE_ALREADY_EXISTS
@@ -459,18 +467,16 @@ export default class GoogleDrive implements NativeStorage {
       });
     } else {
       // Need to create a new file first
-      const files = await this.drive.listFiles(this.getRootDirectory(scope));
       const { directories, filename } = this.resolvePathToDirectories(remotePath);
-      const parentDirectoryId = this.findParentDirectoryId(files, directories);
+      const parentDirectoryId = await this.findParentDirectoryId(directories, scope);
+      if (parentDirectoryId === null) {
+        throw new CloudStorageError(`Directory not found`, NativeCloudStorageErrorCode.DIRECTORY_NOT_FOUND);
+      }
 
       await this.drive.createFile(
         {
           name: filename,
-          parents: parentDirectoryId
-            ? [parentDirectoryId]
-            : scope === 'app_data'
-            ? [this.getRootDirectory(scope)]
-            : undefined,
+          parents: [parentDirectoryId],
         },
         {
           mimeType,

package/src/types/main.ts

@@ -8,6 +8,8 @@ export enum CloudStorageScope {
   AppData = 'app_data',
 }
 
+export type ICloudDocumentsMode = 'icloud' | 'legacy_sandbox';
+
 export interface CloudStorageFileStat {
   size: number;
   birthtimeMs: number;
@@ -29,6 +31,13 @@ export interface CloudStorageProviderOptions {
      * The directory scope to use for iCloud operations. Defaults to 'app_data'.
      */
     scope?: CloudStorageScope;
+    /**
+     * The directory mode to use for CloudStorageScope.Documents.
+     * `icloud` uses the user-facing iCloud Documents directory, while
+     * `legacy_sandbox` uses the local app sandbox Documents directory.
+     * Defaults to `icloud`.
+     */
+    documentsMode?: ICloudDocumentsMode;
   };
 
   [CloudStorageProvider.GoogleDrive]: {

package/src/types/native.ts

@@ -1,12 +1,12 @@
-export type NativeStorageScope = 'documents' | 'app_data';
+import type {
+  CloudStorageFileStat,
+  Spec as NativeCloudStorageCloudKitSpec,
+} from '../specs/NativeCloudStorageCloudKitIOS';
+import type { Spec as NativeCloudStorageLocalFileSystemSpec } from '../specs/NativeCloudStorageLocalFileSystem';
 
-export interface NativeStorageFileStat {
-  size: number;
-  birthtimeMs: number;
-  mtimeMs: number;
-  isDirectory: boolean;
-  isFile: boolean;
-}
+export type NativeStorageScope = 'documents' | 'documents_legacy' | 'app_data';
+
+export type NativeStorageFileStat = CloudStorageFileStat;
 
 export enum NativeCloudStorageErrorCode {
   INVALID_SCOPE = 'ERR_INVALID_SCOPE',
@@ -29,50 +29,6 @@ export enum NativeCloudStorageErrorCode {
   NETWORK_ERROR = 'ERR_NETWORK_ERROR',
 }
 
-export interface NativeLocalFileSystem {
-  getConstants: () => {
-    temporaryDirectory: string;
-  };
-  createFile: (path: string, data: string) => Promise<string>;
-  readFile: (path: string) => Promise<string>;
-  downloadFile: (remoteUri: string, localPath: string, options?: { headers?: Record<string, string> }) => Promise<void>;
-  uploadFile: (
-    localPath: string,
-    remoteUri: string,
-    options?: {
-      headers?: Record<string, string>;
-      method?: 'PUT' | 'POST' | 'PATCH';
-    } & (
-      | {
-          uploadType?: 'binary';
-        }
-      | {
-          uploadType?: 'multipart';
-          fieldName?: string;
-          parameters?: Record<string, string>;
-        }
-    )
-  ) => Promise<void>;
-}
+export type NativeLocalFileSystem = NativeCloudStorageLocalFileSystemSpec;
 
-export interface NativeStorage {
-  fileExists: (path: string, scope: NativeStorageScope) => Promise<boolean>;
-  appendToFile: (path: string, data: string, scope: NativeStorageScope) => Promise<void>;
-  createFile: (path: string, data: string, scope: NativeStorageScope, overwrite: boolean) => Promise<void>;
-  createDirectory: (path: string, scope: NativeStorageScope) => Promise<void>;
-  listFiles: (path: string, scope: NativeStorageScope) => Promise<string[]>;
-  readFile: (path: string, scope: NativeStorageScope) => Promise<string>;
-  deleteFile: (path: string, scope: NativeStorageScope) => Promise<void>;
-  deleteDirectory: (path: string, recursively: boolean, scope: NativeStorageScope) => Promise<void>;
-  statFile: (path: string, scope: NativeStorageScope) => Promise<NativeStorageFileStat>;
-  downloadFile: (remotePath: string, localPath: string, scope: NativeStorageScope) => Promise<void>;
-  uploadFile: (
-    remotePath: string,
-    localPath: string,
-    mimeType: string,
-    scope: NativeStorageScope,
-    overwrite: boolean
-  ) => Promise<void>;
-  isCloudAvailable: () => Promise<boolean>;
-  triggerSync: (path: string, scope: NativeStorageScope) => Promise<void>;
-}
+export type NativeStorage = Omit<NativeCloudStorageCloudKitSpec, 'onCloudAvailabilityChanged'>;

package/src/utils/constants.ts

@@ -10,6 +10,7 @@ export const LINKING_ERROR =
 export const DEFAULT_PROVIDER_OPTIONS: DeepRequired<CloudStorageProviderOptions> = {
   [CloudStorageProvider.ICloud]: {
     scope: CloudStorageScope.AppData,
+    documentsMode: 'icloud',
   },
   [CloudStorageProvider.GoogleDrive]: {
     scope: CloudStorageScope.AppData,

package/src/utils/local-fs.ts

@@ -1,10 +1,10 @@
-import { NativeModules } from 'react-native';
+import NativeCloudStorageLocalFileSystem from '../specs/NativeCloudStorageLocalFileSystem';
 import { NativeLocalFileSystem as TNativeLocalFileSystem } from '../types/native';
 import { createProxiedNativeModule } from '../utils/native';
 import { LINKING_ERROR } from './constants';
 
 const NativeLocalFileSystem = createProxiedNativeModule<TNativeLocalFileSystem>(
-  NativeModules.CloudStorageLocalFileSystem
+  NativeCloudStorageLocalFileSystem as unknown as TNativeLocalFileSystem | null
 );
 
 export const localFileSystem =

package/src/utils/native.ts

@@ -6,7 +6,7 @@ import CloudStorageError from './cloud-storage-error';
  * @param nativeModule The native module to proxy.
  * @returns The proxied native module.
  */
-export const createProxiedNativeModule = <T extends object>(nativeModule: T | undefined): T | null => {
+export const createProxiedNativeModule = <T extends object>(nativeModule: T | null | undefined): T | null => {
   if (!nativeModule) return null;
 
   return new Proxy(nativeModule, {

package/ios/CloudStorageCloudKit.m

@@ -1,24 +0,0 @@
-#import <React/RCTBridgeModule.h>
-
-@interface RCT_EXTERN_MODULE(CloudStorageCloudKit, NSObject)
-
-RCT_EXTERN_METHOD(fileExists:(NSString *)path withScope:(NSString *)scope withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(appendToFile:(NSString *)path withData:(NSString *)data withScope:(NSString *)scope withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(createFile:(NSString *)path withData:(NSString *)data withScope:(NSString *)scope withOverwrite:(BOOL)overwrite withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(createDirectory:(NSString *)path withScope:(NSString *)scope withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(listFiles:(NSString *)path withScope:(NSString *)scope withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(readFile:(NSString *)path withScope:(NSString *)scope withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(triggerSync:(NSString *)path withScope:(NSString *)scope withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(deleteFile:(NSString *)path withScope:(NSString *)scope withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(deleteDirectory:(NSString *)path withRecursive:(BOOL)recursive withScope:(NSString *)scope withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(statFile:(NSString *)path withScope:(NSString *)scope withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(downloadFile:(NSString *)remotePath withLocalPath:(NSString *)localPath withScope:(NSString *)scope withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(uploadFile:(NSString *)remotePath withLocalPath:(NSString *)localPath withMimeType:(NSString *)mimeType withScope:(NSString *)scope withOverwrite:(BOOL)overwrite withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(isCloudAvailable:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-
-+ (BOOL)requiresMainQueueSetup
-{
-  return NO;
-}
-
-@end

package/ios/CloudStorageEventEmitter.m

@@ -1,16 +0,0 @@
-#import <React/RCTBridgeModule.h>
-#import <React/RCTEventEmitter.h>
-
-@interface RCT_EXTERN_MODULE(CloudStorageEventEmitter, RCTEventEmitter)
-
-RCT_EXTERN_METHOD(supportedEvents)
-RCT_EXTERN_METHOD(startObserving)
-RCT_EXTERN_METHOD(stopObserving)
-RCT_EXTERN_METHOD(iCloudIdentityChanged:(NSNotification *)notification)
-
-+ (BOOL)requiresMainQueueSetup
-{
-  return NO;
-}
-
-@end

package/ios/CloudStorageEventEmitter.swift

@@ -1,30 +0,0 @@
-import Foundation
-
-@objc(CloudStorageEventEmitter)
-class CloudStorageEventEmitter: RCTEventEmitter {
-  public static var shared: CloudStorageEventEmitter!
-
-  override init() {
-    super.init()
-    CloudStorageEventEmitter.shared = self
-  }
-
-  override func supportedEvents() -> [String]! {
-    ["RNCloudStorage.cloud.availability-changed"]
-  }
-
-  override func startObserving() {
-    NotificationCenter.default.addObserver(self, selector: #selector(iCloudIdentityChanged(_:)), name: NSNotification.Name.NSUbiquityIdentityDidChange, object: nil)
-    // call this immediately after init to trigger an initial value being sent to the JS side
-    iCloudIdentityChanged()
-  }
-
-  override func stopObserving() {
-    NotificationCenter.default.removeObserver(self, name: NSNotification.Name.NSUbiquityIdentityDidChange, object: nil)
-  }
-
-  @objc func iCloudIdentityChanged(_: Notification? = nil) {
-    let isAvailable = CloudKitUtils.isCloudKitAvailable()
-    CloudStorageEventEmitter.shared.sendEvent(withName: "RNCloudStorage.cloud.availability-changed", body: ["available": isAvailable])
-  }
-}

package/ios/CloudStorageLocalFileSystem.m

@@ -1,15 +0,0 @@
-#import <React/RCTBridgeModule.h>
-
-@interface RCT_EXTERN_MODULE(CloudStorageLocalFileSystem, NSObject)
-
-RCT_EXTERN_METHOD(readFile:(NSString *)path withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(createFile:(NSString *)path withData:(NSString *)data withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(downloadFile:(NSString *)remoteUri withLocalPath:(NSString *)localPath withOptions:(NSDictionary *)options withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(uploadFile:(NSString *)localPath withRemoteUri:(NSString *)remoteUri withOptions:(NSDictionary *)options withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-
-+ (BOOL)requiresMainQueueSetup
-{
-  return NO;
-}
-
-@end