@react-native-documents/picker 9.3.1

package/android/src/main/java/com/reactnativedocumentpicker/PickOptions.kt

@@ -0,0 +1,63 @@
+// LICENSE: see License.md in the package root
+package com.reactnativedocumentpicker
+
+import android.content.Intent
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+
+data class PickOptions(
+  private val mode: String?,
+  val mimeTypes: Array<String>,
+  val initialDirectoryUrl: String?,
+  val localOnly: Boolean,
+  val multiple: Boolean,
+  val requestLongTermAccess: Boolean,
+  val allowVirtualFiles: Boolean,
+) {
+  val action: String
+    get() = if ("open" == mode) Intent.ACTION_OPEN_DOCUMENT else Intent.ACTION_GET_CONTENT
+
+  val intentFilterTypes: String get() {
+    return if (action == Intent.ACTION_OPEN_DOCUMENT) {
+      // https://developer.android.com/reference/android/content/Intent.html#ACTION_OPEN_DOCUMENT
+      "*/*"
+    } else {
+      // https://stackoverflow.com/a/46074075/2070942
+      mimeTypes.joinToString("|")
+    }
+  }
+}
+
+fun parsePickOptions(readableMap: ReadableMap): PickOptions {
+  val mode = readableMap.getString("mode")
+
+  val mimeTypes = if (readableMap.hasKey("type") && !readableMap.isNull("type")) {
+    readableMap.getArray("type")?.let { readableArrayToStringArray(it) } ?: arrayOf("*/*")
+  } else {
+    arrayOf("*/*")
+  }
+
+  val initialDirectoryUrl = if (readableMap.hasKey("initialDirectoryUrl")) readableMap.getString("initialDirectoryUrl") else null
+  val localOnly = readableMap.hasKey("localOnly") && readableMap.getBoolean("localOnly")
+  val multiple = readableMap.hasKey("allowMultiSelection") && readableMap.getBoolean("allowMultiSelection")
+  val requestLongTermAccess = readableMap.hasKey("requestLongTermAccess") && readableMap.getBoolean("requestLongTermAccess")
+  val allowVirtualFiles = readableMap.hasKey("allowVirtualFiles") && readableMap.getBoolean("allowVirtualFiles")
+
+  return PickOptions(
+    mode = mode,
+    mimeTypes = mimeTypes,
+    initialDirectoryUrl = initialDirectoryUrl,
+    localOnly = localOnly,
+    multiple = multiple,
+    requestLongTermAccess = requestLongTermAccess,
+    allowVirtualFiles = allowVirtualFiles,
+  )
+}
+fun readableArrayToStringArray(readableArray: ReadableArray): Array<String> {
+  /**
+   * MIME type and Uri scheme matching in the
+   * Android framework is case-sensitive, unlike the formal RFC definitions.
+   * As a result, you should always write these elements with lower case letters,
+   * */
+  return readableArray.toArrayList().map { Intent.normalizeMimeType(it.toString())!! }.toTypedArray()
+}

package/android/src/main/java/com/reactnativedocumentpicker/PromiseWrapper.java

@@ -0,0 +1,105 @@
+// LICENSE: see License.md in the package root
+package com.reactnativedocumentpicker;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Promise;
+
+public class PromiseWrapper {
+
+  private Promise promise;
+  private String nameOfCallInProgress;
+  public static final String ASYNC_OP_IN_PROGRESS = "ASYNC_OP_IN_PROGRESS";
+  public static final String E_DOCUMENT_PICKER_CANCELED = "OPERATION_CANCELED";
+  private final String MODULE_NAME;
+
+  public PromiseWrapper(String moduleName) {
+    MODULE_NAME = moduleName;
+  }
+
+  public void setPromiseRejectingPrevious(Promise promise, @NonNull String fromCallsite) {
+    Promise previousPromise = this.promise;
+    if (previousPromise != null) {
+      rejectPreviousPromiseBecauseNewOneIsInProgress(previousPromise, fromCallsite);
+    }
+    this.promise = promise;
+    nameOfCallInProgress = fromCallsite;
+  }
+
+  public boolean trySetPromiseRejectingIncoming(Promise promise, @NonNull String fromCallsite) {
+    Promise previousPromise = this.promise;
+    if (previousPromise != null) {
+      rejectNewPromiseBecauseOldOneIsInProgress(promise, fromCallsite);
+      return false;
+    }
+    this.promise = promise;
+    nameOfCallInProgress = fromCallsite;
+    return true;
+  }
+
+  public void resolve(Object value) {
+    Promise resolver = promise;
+    if (resolver == null) {
+      Log.e(MODULE_NAME, "cannot resolve promise because it's null");
+      return;
+    }
+
+    resetMembers();
+    resolver.resolve(value);
+  }
+
+  public void reject(@NonNull String code, Exception e) {
+    String message = e.getLocalizedMessage() != null ? e.getLocalizedMessage() :
+      e.getMessage() != null ? e.getMessage() : "unknown error";
+
+    this.reject(code, message, e);
+  }
+
+  public void reject(Exception e) {
+    String message = e.getLocalizedMessage() != null ? e.getLocalizedMessage() :
+      e.getMessage() != null ? e.getMessage() : "unknown error";
+
+    this.reject(nameOfCallInProgress, message, e);
+  }
+
+  public void rejectAsUserCancelledOperation() {
+    this.reject(E_DOCUMENT_PICKER_CANCELED, "user canceled the document picker");
+  }
+
+  public void reject(@NonNull String code, @NonNull String message) {
+    reject(code, message, null);
+  }
+  public void reject(@NonNull String code, @NonNull String message, Exception e) {
+    Promise rejecter = promise;
+    if (rejecter == null) {
+      Log.e(MODULE_NAME, "cannot reject promise because it's null");
+      return;
+    }
+
+    resetMembers();
+    rejecter.reject(code, message, e);
+  }
+
+  public String getNameOfCallInProgress() {
+    return nameOfCallInProgress;
+  }
+
+  private void resetMembers() {
+    nameOfCallInProgress = null;
+    promise = null;
+  }
+
+
+  private void rejectPreviousPromiseBecauseNewOneIsInProgress(Promise promise, String requestedOperation) {
+    // TODO better message
+    promise.reject(ASYNC_OP_IN_PROGRESS, "Warning: previous promise did not settle and was overwritten. " +
+      "You've called \"" + requestedOperation + "\" while \"" + getNameOfCallInProgress() + "\" was already in progress and has not completed yet.");
+  }
+  private void rejectNewPromiseBecauseOldOneIsInProgress(Promise promise, String requestedOperation) {
+    // TODO better message
+    promise.reject(ASYNC_OP_IN_PROGRESS, "Warning: previous promise did not settle and you attempted to overwrite it. " +
+      "You've called \"" + requestedOperation + "\" while \"" + getNameOfCallInProgress() + "\" was already in progress and has not completed yet.");
+  }
+}

package/android/src/main/java/com/reactnativedocumentpicker/RNDocumentPickerModule.kt

@@ -0,0 +1,352 @@
+package com.reactnativedocumentpicker
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.ActivityNotFoundException
+import android.content.ClipData
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.provider.DocumentsContract
+import android.util.Base64
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.BaseActivityEventListener
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+class RNDocumentPickerModule(reactContext: ReactApplicationContext) :
+    NativeDocumentPickerSpec(reactContext), LifecycleEventListener {
+  private var currentPickOptions: PickOptions? = null
+  private var currentUriOfFileBeingExported: Uri? = null
+  private val promiseWrapper = PromiseWrapper(NAME)
+  private val pickedFilesUriMap = mutableMapOf<String, Uri>()
+  private val metadataGetter = MetadataGetter(pickedFilesUriMap)
+  private val fileOps = FileOperations(pickedFilesUriMap)
+  private val fileCopyingCoroutine = CoroutineScope(Dispatchers.IO)
+
+  private val activityEventListener: ActivityEventListener =
+      object : BaseActivityEventListener() {
+        override fun onActivityResult(
+            activity: Activity,
+            requestCode: Int,
+            resultCode: Int,
+            data: Intent?
+        ) {
+          if (requestCode != PICK_FILES_REQUEST_CODE && requestCode != PICK_DIR_REQUEST_CODE && requestCode != SAVE_DOC_REQUEST_CODE) {
+            // we only handle the document picker library request codes
+            return
+          }
+
+          when (resultCode) {
+            Activity.RESULT_CANCELED -> promiseWrapper.rejectAsUserCancelledOperation()
+            (Activity.RESULT_OK) -> {
+              if (data == null) {
+                promiseWrapper.reject(E_INVALID_DATA_RETURNED, "Data from document picker is null")
+                return
+              }
+              when (requestCode) {
+                PICK_FILES_REQUEST_CODE -> processFilePickerResult(data)
+                PICK_DIR_REQUEST_CODE -> processDirectoryPickerResult(data)
+                SAVE_DOC_REQUEST_CODE -> processSaveAsResult(data)
+                else -> promiseWrapper.reject(
+                  "UNEXPECTED_ACTIVITY_RESULT", "Unknown activity result: $resultCode", null)
+              }
+            }
+            else ->
+                promiseWrapper.reject(
+                  "UNEXPECTED_ACTIVITY_RESULT", "Unknown activity result: $resultCode", null)
+          }
+        }
+      }
+
+  init {
+    reactContext.addActivityEventListener(activityEventListener)
+    reactContext.addLifecycleEventListener(this)
+  }
+
+  override fun invalidate() {
+    reactApplicationContext.removeActivityEventListener(activityEventListener)
+    // TODO verify this should be done (and order)
+    // reactApplicationContext.removeLifecycleEventListener(this)
+    super.invalidate()
+  }
+
+  @ReactMethod
+  override fun pick(opts: ReadableMap, promise: Promise) {
+    val currentActivity = currentActivity
+
+    if (currentActivity == null) {
+      rejectWithNullActivity(promise)
+      return
+    }
+    if (!promiseWrapper.trySetPromiseRejectingIncoming(promise, "pick")) {
+      return
+    }
+    val options = parsePickOptions(opts)
+    currentPickOptions = options
+
+    try {
+      val intent = IntentFactory.getPickIntent(options)
+      currentActivity.startActivityForResult(intent, PICK_FILES_REQUEST_CODE)
+    } catch (e: ActivityNotFoundException) {
+      promise.reject(UNABLE_TO_OPEN_FILE_TYPE, e)
+    } catch (e: Exception) {
+      promise.reject(E_OTHER_PRESENTING_ERROR, e)
+    }
+  }
+
+  override fun saveDocument(options: ReadableMap, promise: Promise) {
+    val currentActivity = currentActivity
+    if (currentActivity == null) {
+      rejectWithNullActivity(promise)
+      return
+    }
+    if (!promiseWrapper.trySetPromiseRejectingIncoming(promise, "saveDocuments")) {
+      return
+    }
+
+    try {
+      val uri = Uri.parse(options.getArray("sourceUris")!!.getString(0))
+      currentUriOfFileBeingExported = uri
+
+      val mimeType = if (options.hasKey("mimeType")) options.getString("mimeType") else {
+        val contentResolver = reactApplicationContext.contentResolver
+        contentResolver.getType(uri) ?: throw IllegalStateException("MIME type could not be determined from the URI")
+      }
+      val suggestedTitle = if (options.hasKey("fileName")) options.getString("fileName") else null
+      val intent = Intent(Intent.ACTION_CREATE_DOCUMENT).apply {
+        addCategory(Intent.CATEGORY_OPENABLE)
+        type = mimeType
+        suggestedTitle?.let { putExtra(Intent.EXTRA_TITLE, it) }
+
+        // Optionally, specify a URI for the directory that should be opened in
+        // the system file picker before your app creates the document.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && options.hasKey("initialUri")) {
+          putExtra(DocumentsContract.EXTRA_INITIAL_URI, options.getString("initialUri"))
+        }
+      }
+      currentActivity.startActivityForResult(intent, SAVE_DOC_REQUEST_CODE)
+    } catch (e: ActivityNotFoundException) {
+      promise.reject(UNABLE_TO_OPEN_FILE_TYPE, e)
+    } catch (e: Exception) {
+      promise.reject(E_OTHER_PRESENTING_ERROR, e)
+    }
+  }
+
+  @ReactMethod
+  override fun pickDirectory(opts: ReadableMap, promise: Promise) {
+    val currentActivity = currentActivity
+    if (currentActivity == null) {
+      rejectWithNullActivity(promise)
+      return
+    }
+    if (!promiseWrapper.trySetPromiseRejectingIncoming(promise, "pickDirectory")) {
+      return
+    }
+    val options = parsePickOptions(opts)
+    currentPickOptions = options
+    try {
+      val intent =
+          Intent(Intent.ACTION_OPEN_DOCUMENT_TREE).apply {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O &&
+                options.initialDirectoryUrl != null) {
+              putExtra(
+                  // TODO must be URI
+                  DocumentsContract.EXTRA_INITIAL_URI,
+                  options.initialDirectoryUrl)
+            }
+          }
+      // TODO option for extra task on stack?
+      currentActivity.startActivityForResult(intent, PICK_DIR_REQUEST_CODE)
+    } catch (e: ActivityNotFoundException) {
+      promise.reject(UNABLE_TO_OPEN_FILE_TYPE, e)
+    } catch (e: Exception) {
+      promise.reject(E_OTHER_PRESENTING_ERROR, e)
+    }
+  }
+
+  @ReactMethod
+  override fun keepLocalCopy(options: ReadableMap, promise: Promise) {
+    val filesToCopy = options.getArray("files")
+    val copyTo = options.getString("destination")
+    if (copyTo == null || filesToCopy == null) {
+      promise.reject("keepLocalCopy",
+        "You did not provide the correct options. Expected 'files' and 'destination', got: ${options.toHashMap().keys}"
+      )
+    } else {
+      fileCopyingCoroutine.launch {
+        val results = fileOps.copyFilesToLocalStorage(
+                reactApplicationContext,
+                filesToCopy,
+                CopyDestination.fromPath(copyTo),
+            )
+        promise.resolve(results)
+      }
+    }
+  }
+
+  override fun isKnownType(kind: String, value: String): WritableMap {
+    return IsKnownTypeImpl.isKnownType(kind, value)
+  }
+
+  override fun releaseSecureAccess(uris: ReadableArray, promise: Promise) {
+    promise.resolve(null)
+  }
+
+  override fun releaseLongTermAccess(uris: ReadableArray, promise: Promise) {
+    val contentResolver = reactApplicationContext.contentResolver
+    val results = Arguments.createArray()
+    for (i in 0 until uris.size()) {
+      val uriString = uris.getString(i)
+      val result = Arguments.createMap().apply {
+        putString("uri", uriString)
+      }
+      try {
+        val uri = Uri.parse(uriString)
+        contentResolver.releasePersistableUriPermission(
+          uri,
+          Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION
+        )
+        // TODO clarify if this should be done
+        // pickedFilesUriMap.remove(uriString)
+        result.putString("status", "success")
+      } catch (e: Exception) {
+        result.putString("status", "error")
+        result.putString("errorMessage", e.message ?: "Unknown error")
+      }
+      results.pushMap(result)
+    }
+    promise.resolve(results)
+  }
+
+  @SuppressLint("WrongConstant") // in takePersistableUriPermission
+  private fun processDirectoryPickerResult(intent: Intent) {
+    val uri: Uri? = intent.data
+    val pickOptions = currentPickOptions
+    if (uri == null || pickOptions == null) {
+      promiseWrapper.reject(E_INVALID_DATA_RETURNED, "Data from document picker is null")
+      return
+    }
+
+    val map = Arguments.createMap().apply {
+      putString("uri", uri.toString())
+    }
+
+    if (pickOptions.requestLongTermAccess) {
+      // https://developer.android.com/training/data-storage/shared/documents-files#persist-permissions
+      // checking FLAG_GRANT_PERSISTABLE_URI_PERMISSION is not mentioned in the official docs
+      val takeFlags =
+          intent.flags and
+              (Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION)
+
+      // TODO detect whether we have read or write permissions
+      // TODO use metadataBuilder too?
+      try {
+        reactApplicationContext.contentResolver.takePersistableUriPermission(uri, takeFlags)
+        val encodedBookmark =
+            Base64.encodeToString(uri.toString().toByteArray(Charsets.UTF_8), Base64.DEFAULT)
+        map.putString("status", "success")
+        map.putString("bookmark", encodedBookmark)
+      } catch (e: Exception) {
+        val error =
+            e.localizedMessage ?: e.message ?: "Unknown error with takePersistableUriPermission"
+        map.putString("status", "error")
+        map.putString("bookmarkError", error)
+      }
+    }
+    promiseWrapper.resolve(map)
+  }
+
+  override fun writeDocuments(options: ReadableMap, promise: Promise) {
+    fileCopyingCoroutine.launch {
+      try {
+        val targetUriString = if (options.hasKey("uri")) options.getString("uri") else null
+
+        val metadataBuilder = fileOps.writeDocumentImpl(currentUriOfFileBeingExported, targetUriString, reactApplicationContext)
+        metadataGetter.queryContentResolverMetadata(reactApplicationContext.contentResolver, metadataBuilder, reactApplicationContext)
+
+        val arrayWithSingleResult = Arguments.createArray().apply {
+          val resultMap = metadataBuilder.build()
+          pushMap(resultMap)
+        }
+        promise.resolve(arrayWithSingleResult)
+      } catch (e: Exception) {
+        promise.reject(e)
+      }
+    }
+  }
+
+  private fun processSaveAsResult(intent: Intent) {
+    val targetUri: Uri? = intent.data
+    if (targetUri != null) {
+      pickedFilesUriMap[targetUri.toString()] = targetUri
+      val map = Arguments.createMap().apply {
+        putString("uri", targetUri.toString())
+      }
+      promiseWrapper.resolve(map)
+    } else {
+      promiseWrapper.reject(E_INVALID_DATA_RETURNED, "Data from document picker is null")
+    }
+  }
+
+  fun processFilePickerResult(intent: Intent) {
+    val singleFileUri: Uri? = intent.data
+    val multiSelectClipData: ClipData? = intent.clipData
+
+    val uris: List<Uri> =
+        when {
+          multiSelectClipData != null && multiSelectClipData.itemCount > 0 -> {
+            // multiple files selected
+            (0 until multiSelectClipData.itemCount).map { index ->
+              multiSelectClipData.getItemAt(index).uri
+            }
+          }
+          singleFileUri != null -> listOf(singleFileUri)
+          else -> emptyList()
+        }
+
+    CoroutineScope(Dispatchers.IO).launch {
+      try {
+        val pickOptions = currentPickOptions
+        require(pickOptions != null)
+        val results =
+            metadataGetter.processPickedFileUris(reactApplicationContext, uris, pickOptions)
+        promiseWrapper.resolve(results)
+      } catch (e: Exception) {
+        promiseWrapper.reject(e)
+      }
+    }
+  }
+
+  companion object {
+    fun rejectWithNullActivity(promise: Promise) {
+      promise.reject(PRESENTER_IS_NULL, PRESENTER_IS_NULL)
+    }
+
+    private const val PICK_FILES_REQUEST_CODE = 41
+    private const val PICK_DIR_REQUEST_CODE = 42
+    private const val SAVE_DOC_REQUEST_CODE = 43
+    private const val PRESENTER_IS_NULL = "NULL_PRESENTER"
+    private const val UNABLE_TO_OPEN_FILE_TYPE = "UNABLE_TO_OPEN_FILE_TYPE"
+    private const val E_OTHER_PRESENTING_ERROR = "OTHER_PRESENTING_ERROR"
+    private const val E_INVALID_DATA_RETURNED = "INVALID_DATA_RETURNED"
+  }
+
+  override fun onHostResume() {}
+
+  override fun onHostPause() {}
+
+  override fun onHostDestroy() {
+    fileCopyingCoroutine.cancel("host destroyed")
+  }
+}

package/android/src/main/java/com/reactnativedocumentpicker/RNDocumentPickerPackage.java

@@ -0,0 +1,49 @@
+// LICENSE: see License.md in the package root
+package com.reactnativedocumentpicker;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class RNDocumentPickerPackage extends TurboReactPackage {
+
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, @NonNull ReactApplicationContext reactContext) {
+    if (name.equals(RNDocumentPickerModule.NAME)) {
+      return new RNDocumentPickerModule(reactContext);
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+      boolean isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED;
+      final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+      moduleInfos.put(
+        RNDocumentPickerModule.NAME,
+        // deprecated in RN 0.73
+        new ReactModuleInfo(
+          RNDocumentPickerModule.NAME,
+          RNDocumentPickerModule.NAME,
+//          "DocumentPickerModule",
+          false, // canOverrideExistingModule
+          false, // needsEagerInit
+          false, // hasConstants
+          false, // isCxxModule
+          isTurboModule // isTurboModule
+        ));
+      return moduleInfos;
+    };
+  }
+}

package/android/src/paper/java/com/reactnativedocumentpicker/NativeDocumentPickerSpec.java

@@ -0,0 +1,69 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Then it was commited. It is here to support the old architecture.
+ * If you use the new architecture, this file won't be included and instead will be generated by the codegen.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.reactnativedocumentpicker;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeDocumentPickerSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "RNDocumentPicker";
+
+  public NativeDocumentPickerSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void pick(ReadableMap options, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void saveDocument(ReadableMap options, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void writeDocuments(ReadableMap options, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void pickDirectory(ReadableMap options, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void keepLocalCopy(ReadableMap options, Promise promise);
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract WritableMap isKnownType(String kind, String value);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void releaseSecureAccess(ReadableArray uris, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void releaseLongTermAccess(ReadableArray uris, Promise promise);
+}

package/ios/RCTConvert+RNDocumentPicker.h

@@ -0,0 +1,8 @@
+#import <React/RCTConvert.h>
+#import <UIKit/UIKit.h>
+
+@interface RCTConvert(RNDocumentPicker)
+
++ (UIModalTransitionStyle)UIModalTransitionStyle:(NSString*)value;
+
+@end

package/ios/RCTConvert+RNDocumentPicker.mm

@@ -0,0 +1,16 @@
+#import "RCTConvert+RNDocumentPicker.h"
+
+@implementation RCTConvert (RNDocumentPicker)
+
+RCT_ENUM_CONVERTER(
+    UIModalTransitionStyle,
+    (@{
+      @"coverVertical" : @(UIModalTransitionStyleCoverVertical),
+      @"flipHorizontal" : @(UIModalTransitionStyleFlipHorizontal),
+      @"crossDissolve" : @(UIModalTransitionStyleCrossDissolve),
+      @"partialCurl" : @(UIModalTransitionStylePartialCurl),
+    }),
+    UIModalTransitionStyleCoverVertical,
+    integerValue)
+
+@end

package/ios/RNDocumentPicker.h

@@ -0,0 +1,19 @@
+// LICENSE: see License.md in the package root
+
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <rndocumentpickerCGen/rndocumentpickerCGen.h>
+#else
+#import <React/RCTBridgeModule.h>
+#endif
+
+@interface RNDocumentPicker : NSObject <
+#ifdef RCT_NEW_ARCH_ENABLED
+        NativeDocumentPickerSpec
+#else
+        RCTBridgeModule
+#endif
+    >
+
+
+@end