@react-native-documents/picker 9.3.1

package/ios/RNDocumentPicker.mm

@@ -0,0 +1,128 @@
+// LICENSE: see License.md in the package root
+
+
+#import "RNDocumentPicker.h"
+
+#import "RCTConvert+RNDocumentPicker.h"
+// this header file is generated by Xcode: https://developer.apple.com/documentation/swift/importing-swift-into-objective-c
+// if it cannot be found, try cleaning the build folder and Xcode derived data folder
+#import "react_native_document_picker-Swift.h"
+// for UIModalPresentationStyle conversion
+// remove after https://github.com/facebook/react-native/commit/2d547a3252b328251e49dabfeec85f8d46c85411 is released
+#import <React/RCTModalHostViewManager.h>
+
+@interface RNDocumentPicker ()
+@end
+
+@implementation RNDocumentPicker {
+  DocPicker *docPicker;
+  DocSaver *docSaver;
+}
+
+- (instancetype)init {
+  if ((self = [super init])) {
+    docPicker = [DocPicker new];
+    docSaver = [DocSaver new];
+  }
+  return self;
+}
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+RCT_EXPORT_MODULE()
+
+RCT_EXPORT_METHOD(pick:
+                  (NSDictionary *) options
+                  resolve:
+                  (RCTPromiseResolveBlock) resolve
+                  reject:
+                  (RCTPromiseRejectBlock) reject)
+{
+  // https://stackoverflow.com/questions/5270519/what-is-difference-between-uimodaltransitionstyle-and-uimodalpresentationstyle
+  UIModalPresentationStyle presentationStyle = [RCTConvert UIModalPresentationStyle:options[@"presentationStyle"]];
+  UIModalTransitionStyle transitionStyle = [RCTConvert UIModalTransitionStyle:options[@"transitionStyle"]];
+  NSArray *allowedUTIs = [RCTConvert NSArray:options[@"type"]];
+  BOOL allowMultiple = [RCTConvert BOOL:options[@"allowMultiSelection"]];
+  BOOL showExtensions = [RCTConvert BOOL:options[@"showFileExtensions"]];
+  NSString *mode = options[@"mode"];
+  NSString *initialDir = options[@"initialDirectoryUrl"];
+  BOOL requestLongTermAccess = [RCTConvert BOOL:options[@"requestLongTermAccess"]];
+  
+  PickerOptions *pickerOptions = [[PickerOptions alloc] initWithTypes:allowedUTIs
+                                                                 mode:mode
+                                                  initialDirectoryUrl:initialDir
+                                                  allowMultiSelection:allowMultiple
+                                             shouldShowFileExtensions:showExtensions
+                                                      transitionStyle:transitionStyle
+                                                    presentationStyle:presentationStyle
+                                                requestLongTermAccess:requestLongTermAccess];
+  
+  [docPicker presentWithOptions:pickerOptions resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(pickDirectory:(NSDictionary *)options resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+  void (^resolveWithDirectoryUri)(NSArray<NSDictionary *> *) = ^void(NSArray<NSDictionary *> *pickedValues) {
+    NSDictionary* firstObject = pickedValues.firstObject;
+    resolve(firstObject);
+  };
+  
+  [self pick:options resolve:resolveWithDirectoryUri reject:reject];
+}
+
+RCT_EXPORT_METHOD(keepLocalCopy:
+                  (NSDictionary *) options
+                  resolve:
+                  (RCTPromiseResolveBlock) resolve
+                  reject:
+                  (RCTPromiseRejectBlock) reject) {
+  NSArray *uris = options[@"files"];
+  NSString *destination = options[@"destination"];
+  
+  [[FileOperations class] keepLocalCopyAtUniqueDestinationFrom:uris destinationPreset:destination resolve:resolve];
+}
+
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, isKnownType:(NSString *)kind value:(NSString *)value) {
+  NSDictionary* result = [[IsKnownTypeImpl class] checkType:kind value:value];
+  return result;
+}
+
+RCT_EXPORT_METHOD(writeDocuments:(NSDictionary *)options resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+  UIModalPresentationStyle presentationStyle = [RCTConvert UIModalPresentationStyle:options[@"presentationStyle"]];
+  UIModalTransitionStyle transitionStyle = [RCTConvert UIModalTransitionStyle:options[@"transitionStyle"]];
+  BOOL showExtensions = [RCTConvert BOOL:options[@"showFileExtensions"]];
+  BOOL asCopy = [RCTConvert BOOL:options[@"copy"]];
+
+  NSString *initialDir = options[@"initialDirectoryUri"];
+  NSArray<NSString*> *documentUrl = options[@"sourceUris"];
+  
+  SaverOptions* saverOptions = [[SaverOptions alloc] initWithSourceUrlStrings:documentUrl asCopy:asCopy initialDirectoryUrl:initialDir shouldShowFileExtensions:showExtensions transitionStyle:transitionStyle presentationStyle:presentationStyle];
+  
+  [docSaver presentWithOptions:saverOptions resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(releaseSecureAccess:(NSArray *)uris resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+  [docPicker stopAccessingOpenedUrls:uris];
+  resolve([NSNull null]);
+}
+
+RCT_EXPORT_METHOD(releaseLongTermAccess:(NSArray *)uris resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+  resolve([NSNull null]);
+}
+
+// Thanks to this guard, we won't compile this code when we build for the old architecture.
+#ifdef RCT_NEW_ARCH_ENABLED
+
+- (void)saveDocument:(NSDictionary *)options resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  // not needed on iOS
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+(const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeDocumentPickerSpecJSI>(params);
+}
+
+#endif
+
+@end

package/ios/swift/DocPicker.swift

@@ -0,0 +1,84 @@
+// LICENSE: see License.md in the package root
+
+import Foundation
+import UniformTypeIdentifiers
+import MobileCoreServices
+
+@objc public class DocPicker: PickerWithMetadataImpl {
+
+  var currentOptions: PickerOptions? = nil
+
+  @objc public func present(options: PickerOptions, resolve: @escaping RNDPPromiseResolveBlock, reject: @escaping RNDPPromiseRejectBlock) {
+    // TODO fix callsite param
+    if (!promiseWrapper.trySetPromiseRejectingIncoming(resolve, rejecter: reject, fromCallSite: "pick")) {
+      return;
+    }
+    currentOptions = options;
+    DispatchQueue.main.async {
+      let documentPicker = UIDocumentPickerViewController(forOpeningContentTypes: options.allowedTypes, asCopy: options.modeAsCopy())
+
+      documentPicker.modalPresentationStyle = options.presentationStyle
+      documentPicker.allowsMultipleSelection = options.allowMultiSelection
+      documentPicker.modalTransitionStyle = options.transitionStyle
+      //        documentPicker.directoryURL = options.initialDirectoryUrl
+      //        documentPicker.shouldShowFileExtensions = options.shouldShowFileExtensions
+
+      self.presentInternal(documentPicker: documentPicker)
+    }
+  }
+
+  public func getMetadataFor(url: URL) throws -> DocumentMetadataBuilder {
+    if (currentOptions?.isOpenMode() == true) {
+      return try self.getOpenedDocumentInfo(url: url, requestLongTermAccess: currentOptions?.requestLongTermAccess ?? false)
+    } else {
+      return try self.getAnyModeMetadata(url: url)
+    }
+  }
+
+  private func getAnyModeMetadata(url: URL) throws -> DocumentMetadataBuilder {
+    let resourceValues = try url.resourceValues(forKeys: [.fileSizeKey, .nameKey, .isDirectoryKey, .contentTypeKey])
+
+    return DocumentMetadataBuilder(forUri: url, resourceValues: resourceValues)
+  }
+
+  enum KeepLocalCopyError: Error {
+    case sourceAccessError
+  }
+
+  func getOpenedDocumentInfo(url: URL, requestLongTermAccess: Bool) throws -> DocumentMetadataBuilder {
+    guard url.startAccessingSecurityScopedResource() else {
+      throw KeepLocalCopyError.sourceAccessError
+    }
+
+    // url.stopAccessingSecurityScopedResource() must be called later
+    openedUrls.append(url)
+
+    // Use file coordination for reading and writing any of the URL’s content.
+    var error: NSError? = nil
+    var success = false
+    var metadataBuilder: DocumentMetadataBuilder = DocumentMetadataBuilder(forUri: url)
+
+    NSFileCoordinator().coordinate(readingItemAt: url, error: &error) { (url) in
+      do {
+        metadataBuilder = try self.getAnyModeMetadata(url: url)
+        success = true
+      } catch {
+        metadataBuilder.setMetadataReadingError(error)
+      }
+
+      if (requestLongTermAccess == true) {
+        do {
+          let bookmarkData = try url.bookmarkData(options: .minimalBookmark, includingResourceValuesForKeys: nil, relativeTo: nil)
+          metadataBuilder.setBookmark(bookmarkData)
+        } catch {
+          metadataBuilder.setBookmarkError(error)
+        }
+      }
+    }
+    if let err = error, success == false {
+      throw err
+    }
+    return metadataBuilder
+  }
+
+}

package/ios/swift/DocSaver.swift

@@ -0,0 +1,41 @@
+//
+//  DocSaver.swift
+//  react-native-document-picker
+//
+//  Created by Vojtech Novak on 25.05.2024.
+//
+
+// LICENSE: see License.md in the package root
+
+import Foundation
+import UniformTypeIdentifiers
+import MobileCoreServices
+
+@objc public class DocSaver: PickerWithMetadataImpl {
+
+  @objc public func present(options: SaverOptions, resolve: @escaping (Any?) -> Void, reject: @escaping (String?, String?, Error?) -> Void) {
+    if (!promiseWrapper.trySetPromiseRejectingIncoming(resolve, rejecter: reject, fromCallSite: "saveDocuments")) {
+      return;
+    }
+    DispatchQueue.main.async {
+      let documentPicker = UIDocumentPickerViewController(forExporting: options.sourceUrls, asCopy: options.asCopy)
+
+      documentPicker.modalPresentationStyle = options.presentationStyle
+      documentPicker.modalTransitionStyle = options.transitionStyle
+      //        documentPicker.directoryURL = options.initialDirectoryUrl
+      //        documentPicker.shouldShowFileExtensions = options.shouldShowFileExtensions
+
+      self.presentInternal(documentPicker: documentPicker)
+    }
+  }
+
+  public func getMetadataFor(url: URL) throws -> DocumentMetadataBuilder {
+    let name = url.lastPathComponent.removingPercentEncoding
+
+    var resourceValues = URLResourceValues()
+    resourceValues.name = name
+
+    return DocumentMetadataBuilder(forUri: url, resourceValues: resourceValues)
+  }
+
+}

package/ios/swift/DocumentMetadataBuilder.swift

@@ -0,0 +1,69 @@
+// LICENSE: see License.md in the package root
+
+import Foundation
+import UniformTypeIdentifiers
+
+public class DocumentMetadataBuilder {
+  private let uri: URL
+  private let resourceValues: URLResourceValues?
+  private var bookmarkData: Data?
+  private var metadataError: Error?
+  private var bookmarkError: Error?
+  
+  init(forUri uri: URL) {
+    self.uri = uri
+    self.resourceValues = nil
+  }
+  
+  init(forUri uri: URL, resourceValues: URLResourceValues) {
+    self.uri = uri
+    self.resourceValues = resourceValues
+  }
+  
+  convenience init(forUri uri: URL, error: Error) {
+    self.init(forUri: uri)
+    self.metadataError = error
+  }
+  
+  func setBookmark(_ bookmark: Data) {
+    self.bookmarkData = bookmark
+  }
+  
+  func setBookmarkError(_ bookmarkError: Error) {
+    self.bookmarkError = bookmarkError
+  }
+  
+  func setMetadataReadingError(_ error: Error) {
+    self.metadataError = error
+  }
+  
+  func build() -> [String: Any?] {
+    var dictionary: [String: Any?] = [:]
+    if (resourceValues?.isDirectory ?? false == false) {
+      let utTypeFromFile: UTType? = resourceValues?.contentType
+      let utType: UTType? = utTypeFromFile ?? UTType(filenameExtension: uri.pathExtension)
+
+      dictionary = [
+        "name": resourceValues?.name,
+        "size": resourceValues?.fileSize,
+        "type": utType?.preferredMIMEType,
+        "nativeType": utType?.identifier,
+        "error": metadataError?.localizedDescription,
+        "isVirtual": false,
+        "convertibleToMimeTypes": nil
+      ]
+    }
+
+    dictionary["uri"] = uri.absoluteString
+
+    if let bookmark = bookmarkData {
+      dictionary["bookmarkStatus"] = "success"
+      dictionary["bookmark"] = bookmark.base64EncodedString()
+    } else if let bookmarkError = bookmarkError {
+      dictionary["bookmarkStatus"] = "error"
+      dictionary["bookmarkError"] = bookmarkError.localizedDescription
+    }
+    
+    return dictionary
+  }
+}

package/ios/swift/FileOperations.swift

@@ -0,0 +1,68 @@
+// LICENSE: see License.md in the package root
+
+import Foundation
+
+@objc public class FileOperations: NSObject {
+  
+  @objc public static func keepLocalCopyAtUniqueDestination(from: Array<Dictionary<String, String>>, destinationPreset: String, resolve: @escaping RNDPPromiseResolveBlock) {
+    Task {
+      let results = await moveFiles(from: from, destinationPreset: destinationPreset)
+      resolve(results)
+    }
+  }
+  
+  static func moveFiles(from: Array<Dictionary<String, String>>, destinationPreset: String) async -> [[String: String?]] {
+    let destinationRootDir = getDirectoryForFileDestination(destinationPreset)
+    let uniqueSubDirName = UUID().uuidString
+    let destinationDir: URL = destinationRootDir.appendingPathComponent("\(uniqueSubDirName)/", isDirectory: true)
+    // TODO do we need all of this Task dance?
+    
+    return await withTaskGroup(of: LocalCopyResponse.self) { group in
+      var results: Array<Dictionary<String, String?>> = [[String: String?]]()
+      
+      for dictionary in from {
+        group.addTask {
+          do {
+            guard let uriString = dictionary["uri"], let uri = URL(string: uriString) else {
+              return LocalCopyResponse.error(sourceUri: dictionary["uri"], copyError: "Invalid URI")
+            }
+            guard let fileName = dictionary["fileName"] else {
+              return LocalCopyResponse.error(sourceUri: uri.absoluteString, copyError: "Invalid fileName")
+            }
+            
+            let destinationUrl = try moveToDestination(from: uri, usingFilename: fileName, destinationDir: destinationDir)
+            return LocalCopyResponse.success(sourceUri: uri.absoluteString, localUri: destinationUrl.absoluteString)
+          } catch {
+            return LocalCopyResponse.error(sourceUri: dictionary["uri"]!, copyError: error.localizedDescription)
+          }
+        }
+      }
+      
+      for await result in group {
+        results.append(result.dictionaryRepresentation)
+      }
+      
+      return results
+    }
+  }
+  
+  static func moveToDestination(from: URL, usingFilename fileName: String, destinationDir: URL) throws -> URL {
+    let destinationFile = destinationDir.appendingPathComponent(fileName).standardized
+    
+    guard destinationFile.path.hasPrefix(destinationDir.standardized.path) else {
+      throw NSError(domain: "PathTraversalPrevention", code: 400, userInfo: [NSLocalizedDescriptionKey: "The copied file is attempting to write outside of the target directory."])
+    }
+    
+    try FileManager.default.createDirectory(at: destinationDir, withIntermediateDirectories: true, attributes: nil)
+    try FileManager.default.moveItem(at: from, to: destinationFile)
+    
+    return destinationFile
+  }
+  
+  static func getDirectoryForFileDestination(_ copyToDirectory: String) -> URL {
+    if copyToDirectory == "documentDirectory" {
+      return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+    }
+    return FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
+  }
+}

package/ios/swift/IsKnownTypeImpl.swift

@@ -0,0 +1,42 @@
+//
+//  IsKnownTypeImpl.swift
+//  react-native-document-picker
+//
+//  Created by Vojtech Novak on 26.05.2024.
+// LICENSE: see License.md in the package root
+//
+
+import Foundation
+import UniformTypeIdentifiers
+
+@objc public class IsKnownTypeImpl: NSObject {
+  
+  @objc public static func checkType(_ kind: String, value: String) -> NSDictionary {
+    let dict = getTypeResult(kind, value: value)
+    return NSDictionary(dictionary: dict as [AnyHashable: Any])
+  }
+
+  static func getTypeResult(_ kind: String, value: String) -> Dictionary<String, Any?> {
+    if let utType = createUTType(kind: kind, value: value), utType.isDeclared == true {
+      return ["isKnown": true,
+              "UTType": utType.identifier,
+              "preferredFilenameExtension": utType.preferredFilenameExtension,
+              "mimeType": utType.preferredMIMEType]
+    }
+    return ["isKnown": false, "UTType": nil, "preferredFilenameExtension": nil, "mimeType": nil]
+  }
+
+  static func createUTType(kind: String, value: String) -> UTType? {
+    switch kind {
+    case "UTType":
+      return UTType(value)
+    case "mimeType":
+      return UTType(mimeType: value)
+    case "extension":
+      return UTType(filenameExtension: value)
+    default:
+      return nil
+    }
+  }
+}
+

package/ios/swift/LocalCopyResponse.swift

@@ -0,0 +1,27 @@
+// LICENSE: see License.md in the package root
+
+import Foundation
+
+// export type LocalCopyResponse =
+//   | {
+//       status: 'success'
+//       sourceUri: string
+//       localUri: string
+//     }
+//   | { status: 'error'; sourceUri: string; copyError: string }
+
+enum LocalCopyResponse {
+  case success(sourceUri: String, localUri: String)
+  case error(sourceUri: String?, copyError: String)
+
+  var dictionaryRepresentation: [String: String?] {
+    switch self {
+    case .success(let sourceUri, let localUri):
+      return ["sourceUri": sourceUri, "localUri": localUri, "status": "success"]
+    case .error(let sourceUri, let copyError):
+      var result = ["copyError": copyError, "status": "error"]
+      result["sourceUri"] = sourceUri ?? nil
+      return result
+    }
+  }
+}

package/ios/swift/PickerBase.swift

@@ -0,0 +1,78 @@
+//
+//  DocSaver.swift
+//  react-native-document-picker
+//
+//  Created by Vojtech Novak on 25.05.2024.
+//
+
+// LICENSE: see License.md in the package root
+
+import Foundation
+import UniformTypeIdentifiers
+import MobileCoreServices
+
+public protocol GetsMetadataProtocol {
+    func getMetadataFor(url: URL) throws -> DocumentMetadataBuilder
+}
+
+// https://stackoverflow.com/a/51333906/2070942
+public typealias PickerWithMetadataImpl = PickerBase & GetsMetadataProtocol
+
+public class PickerBase: NSObject, UIDocumentPickerDelegate, UIAdaptivePresentationControllerDelegate {
+  let promiseWrapper = PromiseWrapper()
+  var openedUrls: Array<URL> = []
+
+  func presentInternal(documentPicker: UIDocumentPickerViewController) {
+    documentPicker.delegate = self
+    documentPicker.presentationController?.delegate = self;
+        
+    if let viewController = RCTPresentedViewController() {
+      viewController.present(documentPicker, animated: true, completion: nil)
+    } else {
+      let error = NSError(domain: NSCocoaErrorDomain, code: 0, userInfo: nil)
+      promiseWrapper.reject("RCTPresentedViewController was nil", withCode: "PRESENTER_IS_NULL", withError: error)
+    }
+  }
+  
+  public func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
+    DispatchQueue.global(qos: .userInitiated).async {
+      // this doesn't run on the main thread
+      let documentsInfo = urls.compactMap(self.createDocumentMetadata).compactMap { $0.build() }
+      self.promiseWrapper.resolve(documentsInfo)
+    }
+    // https://developer.apple.com/library/archive/documentation/FileManagement/Conceptual/DocumentPickerProgrammingGuide/AccessingDocuments/AccessingDocuments.html#//apple_ref/doc/uid/TP40014451-CH2-SW4 "Accessing Files Outside Your Sandbox"
+    // https://developer.apple.com/documentation/uikit/view_controllers/providing_access_to_directories
+  }
+  
+  private func createDocumentMetadata(for url: URL) -> DocumentMetadataBuilder? {
+    guard let subclassThatGetsMetadata = self as? GetsMetadataProtocol else {
+      let error = NSError(domain: NSCocoaErrorDomain, code: 0, userInfo: nil)
+      self.promiseWrapper.reject("PickerBase", withCode: "BAD_CLASS", withError: error)
+      return nil
+    }
+    
+    do {
+      return try subclassThatGetsMetadata.getMetadataFor(url: url)
+    } catch {
+      return DocumentMetadataBuilder(forUri: url, error: error)
+    }
+  }
+  
+  public func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
+    promiseWrapper.rejectAsUserCancelledOperation()
+  }
+
+  public func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {
+    promiseWrapper.rejectAsUserCancelledOperation()
+  }
+
+  @objc public func stopAccessingOpenedUrls(_ urlStrings: [String]) {
+    let incomingUrls = Set(urlStrings.compactMap { URL(string: $0) })
+    openedUrls.removeAll { url in
+      guard incomingUrls.contains(url) else { return false }
+      url.stopAccessingSecurityScopedResource()
+      return true
+    }
+  }
+
+}

package/ios/swift/PickerOptions.swift

@@ -0,0 +1,44 @@
+// LICENSE: see License.md in the package root
+
+import Foundation
+import UIKit
+import UniformTypeIdentifiers
+
+@objc public class PickerOptions: NSObject {
+  let allowedTypes: Array<UTType>
+  let mode: String // "import" or "open"
+  let allowMultiSelection: Bool
+  let transitionStyle: UIModalTransitionStyle
+  let presentationStyle: UIModalPresentationStyle
+  let initialDirectoryUrl: URL?
+  let shouldShowFileExtensions: Bool
+  let requestLongTermAccess: Bool
+  
+  @objc public init(types: Array<String>, mode: String = "import", initialDirectoryUrl: String? = nil, allowMultiSelection: Bool, shouldShowFileExtensions: Bool, transitionStyle: UIModalTransitionStyle = .coverVertical, presentationStyle: UIModalPresentationStyle = .fullScreen, requestLongTermAccess: Bool = false) {
+    // TODO check if types were valid
+    allowedTypes = types.compactMap {
+      UTType($0)
+    }
+    self.allowMultiSelection = allowMultiSelection
+    self.transitionStyle = transitionStyle
+    self.presentationStyle = presentationStyle
+    self.mode = mode
+    if let unwrappedUrl = initialDirectoryUrl, let url = URL(string: unwrappedUrl) {
+      self.initialDirectoryUrl = url
+    } else {
+      self.initialDirectoryUrl = nil
+    }
+    self.shouldShowFileExtensions = shouldShowFileExtensions
+    self.requestLongTermAccess = requestLongTermAccess
+  }
+  
+  // asCopy: if true, the picker will give you access to a local copy of the document, otherwise you will have access to the original document
+  public func modeAsCopy() -> Bool {
+    return self.mode == "import"
+  }
+
+  public func isOpenMode() -> Bool {
+    return self.mode == "open"
+  }
+
+}

package/ios/swift/PromiseSupport.swift

@@ -0,0 +1,2 @@
+public typealias RNDPPromiseResolveBlock = ((Any?) -> Void)
+public typealias RNDPPromiseRejectBlock = (String?, String?, Error?) -> Void

package/ios/swift/PromiseWrapper.swift

@@ -0,0 +1,92 @@
+// LICENSE: see License.md in the package root
+
+import Foundation
+
+class PromiseWrapper {
+  private var promiseResolve: RNDPPromiseResolveBlock?
+  private var promiseReject: RNDPPromiseRejectBlock?
+  private var nameOfCallInProgress: String?
+
+  private let E_DOCUMENT_PICKER_CANCELED = "E_DOCUMENT_PICKER_CANCELED"
+  private let ASYNC_OP_IN_PROGRESS = "ASYNC_OP_IN_PROGRESS"
+
+  func setPromiseRejectingPrevious(_ resolve: @escaping RNDPPromiseResolveBlock,
+                                   rejecter reject: @escaping RNDPPromiseRejectBlock,
+                                   fromCallSite callsite: String) {
+    if let previousReject = promiseReject {
+      rejectPreviousPromiseBecauseNewOneIsInProgress(previousReject, requestedOperation: callsite)
+    }
+    promiseResolve = resolve
+    promiseReject = reject
+    nameOfCallInProgress = callsite
+  }
+
+  func trySetPromiseRejectingIncoming(_ resolve: @escaping RNDPPromiseResolveBlock,
+                                      rejecter reject: @escaping RNDPPromiseRejectBlock,
+                                      fromCallSite callsite: String) -> Bool {
+    if promiseReject != nil {
+      rejectNewPromiseBecauseOldOneIsInProgress(reject, requestedOperation: callsite)
+      return false
+    }
+    promiseResolve = resolve
+    promiseReject = reject
+    nameOfCallInProgress = callsite
+    return true
+  }
+
+  func resolve(_ result: Any?) {
+    guard let resolver = promiseResolve else {
+      print("cannot resolve promise because it's null")
+      return
+    }
+    resetMembers()
+    resolver(result)
+  }
+
+  func reject(_ message: String, withError error: NSError) {
+    let errorCode = String(error.code)
+    reject(message, withCode: errorCode, withError: error)
+  }
+
+  func reject(_ message: String, withCode errorCode: String, withError error: NSError) {
+    guard let rejecter = promiseReject else {
+      print("cannot reject promise because it's null")
+      return
+    }
+    let errorMessage = "RNDPPromiseWrapper: \(message), \(error.description)"
+    resetMembers()
+    rejecter(errorCode, errorMessage, error)
+  }
+
+  func rejectAsUserCancelledOperation() {
+    let error = NSError(domain: NSCocoaErrorDomain,
+                        code: NSUserCancelledError,
+                        userInfo: nil)
+    reject("user canceled the document picker",
+           withCode: E_DOCUMENT_PICKER_CANCELED,
+           withError: error)
+  }
+
+  private func resetMembers() {
+    promiseResolve = nil
+    promiseReject = nil
+    nameOfCallInProgress = nil
+  }
+
+  // TODO error messages
+  private func rejectPreviousPromiseBecauseNewOneIsInProgress(_ reject: RNDPPromiseRejectBlock,
+                                                              requestedOperation callSiteName: String) {
+    let msg = "Warning: previous promise did not settle and was overwritten. " +
+    "You've called \"\(callSiteName)\" while \"\(nameOfCallInProgress ?? "")\" " +
+    "was already in progress and has not completed yet."
+    reject(ASYNC_OP_IN_PROGRESS, msg, nil)
+  }
+
+  private func rejectNewPromiseBecauseOldOneIsInProgress(_ reject: RNDPPromiseRejectBlock,
+                                                         requestedOperation callSiteName: String) {
+    let msg = "Warning: previous promise did not settle and you attempted to overwrite it. " +
+    "You've called \"\(callSiteName)\" while \"\(nameOfCallInProgress ?? "")\" " +
+    "was already in progress and has not completed yet."
+    reject(ASYNC_OP_IN_PROGRESS, msg, nil)
+  }
+}