@react-native-documents/picker 9.3.1

package/lib/commonjs/index.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "errorCodes", {
+  enumerable: true,
+  get: function () {
+    return _errors.errorCodes;
+  }
+});
+Object.defineProperty(exports, "isErrorWithCode", {
+  enumerable: true,
+  get: function () {
+    return _errors.isErrorWithCode;
+  }
+});
+Object.defineProperty(exports, "isKnownType", {
+  enumerable: true,
+  get: function () {
+    return _isKnownType.isKnownType;
+  }
+});
+Object.defineProperty(exports, "keepLocalCopy", {
+  enumerable: true,
+  get: function () {
+    return _keepLocalCopy.keepLocalCopy;
+  }
+});
+Object.defineProperty(exports, "pick", {
+  enumerable: true,
+  get: function () {
+    return _pick.pick;
+  }
+});
+Object.defineProperty(exports, "pickDirectory", {
+  enumerable: true,
+  get: function () {
+    return _pickDirectory.pickDirectory;
+  }
+});
+Object.defineProperty(exports, "releaseLongTermAccess", {
+  enumerable: true,
+  get: function () {
+    return _release.releaseLongTermAccess;
+  }
+});
+Object.defineProperty(exports, "releaseSecureAccess", {
+  enumerable: true,
+  get: function () {
+    return _release.releaseSecureAccess;
+  }
+});
+Object.defineProperty(exports, "saveDocuments", {
+  enumerable: true,
+  get: function () {
+    return _saveDocuments.saveDocuments;
+  }
+});
+Object.defineProperty(exports, "types", {
+  enumerable: true,
+  get: function () {
+    return _fileTypes.types;
+  }
+});
+var _isKnownType = require("./isKnownType");
+var _keepLocalCopy = require("./keepLocalCopy");
+var _fileTypes = require("./fileTypes");
+var _errors = require("./errors");
+var _pickDirectory = require("./pickDirectory");
+var _pick = require("./pick");
+var _saveDocuments = require("./saveDocuments");
+var _release = require("./release");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_isKnownType","require","_keepLocalCopy","_fileTypes","_errors","_pickDirectory","_pick","_saveDocuments","_release"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,cAAA,GAAAD,OAAA;AAQA,IAAAE,UAAA,GAAAF,OAAA;AACA,IAAAG,OAAA,GAAAH,OAAA;AACA,IAAAI,cAAA,GAAAJ,OAAA;AASA,IAAAK,KAAA,GAAAL,OAAA;AACA,IAAAM,cAAA,GAAAN,OAAA;AAqBA,IAAAO,QAAA,GAAAP,OAAA","ignoreList":[]}

package/lib/commonjs/isKnownType.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isKnownType = isKnownType;
+var _NativeDocumentPicker = require("./spec/NativeDocumentPicker");
+/**
+ * The result of calling {@link isKnownType}
+ * */
+
+/**
+ *
+ * Checks if the given value (which can be a file extension, UTType identifier or mime) is known to the system.
+ * Also returns the mime type which you can use to filter files on Android.
+ *
+ * @group DocumentPicker
+ * */
+function isKnownType(options) {
+  const {
+    kind,
+    value
+  } = options;
+  const result = _NativeDocumentPicker.NativeDocumentPicker.isKnownType(kind, value);
+  return result;
+}
+//# sourceMappingURL=isKnownType.js.map

package/lib/commonjs/isKnownType.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_NativeDocumentPicker","require","isKnownType","options","kind","value","result","NativeDocumentPicker"],"sourceRoot":"../../src","sources":["isKnownType.ts"],"mappings":";;;;;;AAAA,IAAAA,qBAAA,GAAAC,OAAA;AAEA;AACA;AACA;;AAgCA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,WAAWA,CAACC,OAA2B,EAAuB;EAC5E,MAAM;IAAEC,IAAI;IAAEC;EAAM,CAAC,GAAGF,OAAO;EAC/B,MAAMG,MAAM,GAAGC,0CAAoB,CAACL,WAAW,CAACE,IAAI,EAAEC,KAAK,CAAwB;EACnF,OAAOC,MAAM;AACf","ignoreList":[]}

package/lib/commonjs/keepLocalCopy.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keepLocalCopy = keepLocalCopy;
+var _NativeDocumentPicker = require("./spec/NativeDocumentPicker");
+/**
+ * Parameter of {@link keepLocalCopy}. Object type representing the file(s) whose copy should be kept in the app's storage.
+ * */
+
+/**
+ * options for {@link keepLocalCopy}
+ *
+ * */
+
+/**
+ * Result of the call to {@link keepLocalCopy}. Please note the promise always resolves, even if there was an error processing any uri(s) (as indicated by the `status` field, and `copyError` field).
+ * */
+
+/**
+ * Makes the file available in the app's storage. The behavior is different on iOS and Android, and for simple use cases (such as uploading file to remote server), you may not need to call this method at all.
+ *
+ * On Android, it can be used to "convert" a `content://` Uri into a local file. It also "exports" virtual files (such as Google docs or sheets) into local files.
+ *
+ * However, note that for some use cases, such as uploading the picked file to a server, you may not need to call `keepLocalCopy` at all. React Native's `fetch` can handle `content://` uris.
+ *
+ * @group DocumentPicker
+ * */
+function keepLocalCopy(options) {
+  const response = _NativeDocumentPicker.NativeDocumentPicker.keepLocalCopy(options);
+  return response;
+}
+//# sourceMappingURL=keepLocalCopy.js.map

package/lib/commonjs/keepLocalCopy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_NativeDocumentPicker","require","keepLocalCopy","options","response","NativeDocumentPicker"],"sourceRoot":"../../src","sources":["keepLocalCopy.ts"],"mappings":";;;;;;AACA,IAAAA,qBAAA,GAAAC,OAAA;AAEA;AACA;AACA;;AAmBA;AACA;AACA;AACA;;AAMA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,aAAaA,CAACC,OAA6B,EAAkC;EAC3F,MAAMC,QAAQ,GAAGC,0CAAoB,CAACH,aAAa,CAACC,OAAO,CAAC;EAC5D,OAAOC,QAAQ;AACjB","ignoreList":[]}

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/commonjs/pick.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pick = pick;
+var _NativeDocumentPicker = require("./spec/NativeDocumentPicker");
+var _fileTypes = require("./fileTypes");
+var _reactNative = require("react-native");
+var _validateTypes = require("./validateTypes");
+/**
+ * Base options object for the document picker.
+ * You'd rarely use this type directly, but instead use one of
+ *
+ * {@link DocumentPickerOptionsImport}, {@link DocumentPickerOptionsOpenOnce} or {@link DocumentPickerOptionsOpenLongTerm}
+ *
+ * which extend this type
+ * @group pick() types
+ */
+
+/**
+ * Present the document picker in import mode.
+ *
+ * @group pick() types
+ */
+
+/**
+ * Present the document picker in open mode, with permissions to access the file for a limited time (until the app terminates).
+ *
+ * @group pick() types
+ */
+
+/**
+ * Present the document picker in open mode, with long-term permissions to access the opened file.
+ *
+ * @group pick() types
+ */
+
+/**
+ * @hidden
+ */
+
+/**
+ * The result of calling {@link pick} with `mode: 'open'` and `requestLongTermAccess: true`
+ *
+ * @group pick() types
+ */
+
+// TODO not entirely sure this is a good idea but let's try
+
+/**
+ * The method for picking a file, both for `import` and `open` modes.
+ *
+ * For result types, see {@link DocumentPickerResponse} or {@link DocumentPickerResponseOpenLongTerm}.
+ *
+ * For options, see {@link DocumentPickerOptionsImport}, {@link DocumentPickerOptionsOpenOnce} or {@link DocumentPickerOptionsOpenLongTerm}.
+ *
+ * @group DocumentPicker
+ * */
+async function pick(options) {
+  const type = (() => {
+    if (!options?.type) {
+      return [_fileTypes.types.allFiles];
+    }
+    const newType = Array.isArray(options.type) ? options.type : [options.type];
+    return newType.flat().map(it => it.trim());
+  })();
+  const newOpts = {
+    mode: 'import',
+    // allowMultiSelection must be false to maintain old (v5) behavior
+    allowMultiSelection: false,
+    allowVirtualFiles: false,
+    ...options,
+    type
+  };
+  if (!newOpts.type.every(it => typeof it === 'string')) {
+    throw new TypeError(`Unexpected type option in ${newOpts.type}, did you try using a DocumentPicker.types.* that does not exist?`);
+  }
+  if ('mode' in newOpts && !['import', 'open'].includes(newOpts.mode)) {
+    throw new TypeError('Invalid mode option: ' + newOpts.mode);
+  }
+  const response = _NativeDocumentPicker.NativeDocumentPicker.pick(newOpts);
+  const awaitedResult = await response;
+  for (const res of awaitedResult) {
+    if (_reactNative.Platform.OS === 'android') {
+      res.hasRequestedType = (0, _validateTypes.safeValidate)(newOpts.type, res);
+    } else {
+      res.hasRequestedType = true;
+    }
+  }
+  return awaitedResult;
+}
+//# sourceMappingURL=pick.js.map

package/lib/commonjs/pick.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_NativeDocumentPicker","require","_fileTypes","_reactNative","_validateTypes","pick","options","type","types","allFiles","newType","Array","isArray","flat","map","it","trim","newOpts","mode","allowMultiSelection","allowVirtualFiles","every","TypeError","includes","response","NativeDocumentPicker","awaitedResult","res","Platform","OS","hasRequestedType","safeValidate"],"sourceRoot":"../../src","sources":["pick.ts"],"mappings":";;;;;;AAAA,IAAAA,qBAAA,GAAAC,OAAA;AAEA,IAAAC,UAAA,GAAAD,OAAA;AAQA,IAAAE,YAAA,GAAAF,OAAA;AACA,IAAAG,cAAA,GAAAH,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAgCA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;AACA;;AAOA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;;AAGA;;AASA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,eAAeI,IAAIA,CAAkCC,OAAW,EAAmB;EACxF,MAAMC,IAAc,GAAG,CAAC,MAAM;IAC5B,IAAI,CAACD,OAAO,EAAEC,IAAI,EAAE;MAClB,OAAO,CAACC,gBAAK,CAACC,QAAQ,CAAC;IACzB;IACA,MAAMC,OAAO,GAAGC,KAAK,CAACC,OAAO,CAACN,OAAO,CAACC,IAAI,CAAC,GAAGD,OAAO,CAACC,IAAI,GAAG,CAACD,OAAO,CAACC,IAAI,CAAC;IAC3E,OAAOG,OAAO,CAACG,IAAI,CAAC,CAAC,CAACC,GAAG,CAAEC,EAAE,IAAKA,EAAE,CAACC,IAAI,CAAC,CAAC,CAAC;EAC9C,CAAC,EAAE,CAAC;EACJ,MAAMC,OAAsB,GAAG;IAC7BC,IAAI,EAAE,QAAQ;IACd;IACAC,mBAAmB,EAAE,KAAK;IAC1BC,iBAAiB,EAAE,KAAK;IACxB,GAAGd,OAAO;IACVC;EACF,CAAC;EAED,IAAI,CAACU,OAAO,CAACV,IAAI,CAACc,KAAK,CAAEN,EAAW,IAAK,OAAOA,EAAE,KAAK,QAAQ,CAAC,EAAE;IAChE,MAAM,IAAIO,SAAS,CACjB,6BAA6BL,OAAO,CAACV,IAAI,mEAC3C,CAAC;EACH;EAEA,IAAI,MAAM,IAAIU,OAAO,IAAI,CAAC,CAAC,QAAQ,EAAE,MAAM,CAAC,CAACM,QAAQ,CAACN,OAAO,CAACC,IAAI,CAAC,EAAE;IACnE,MAAM,IAAII,SAAS,CAAC,uBAAuB,GAAGL,OAAO,CAACC,IAAI,CAAC;EAC7D;EAEA,MAAMM,QAA2C,GAAGC,0CAAoB,CAACpB,IAAI,CAACY,OAAO,CAAC;EACtF,MAAMS,aAAa,GAAG,MAAMF,QAAQ;EACpC,KAAK,MAAMG,GAAG,IAAID,aAAa,EAAE;IAC/B,IAAIE,qBAAQ,CAACC,EAAE,KAAK,SAAS,EAAE;MAC7BF,GAAG,CAACG,gBAAgB,GAAG,IAAAC,2BAAY,EAACd,OAAO,CAACV,IAAI,EAAEoB,GAAG,CAAC;IACxD,CAAC,MAAM;MACLA,GAAG,CAACG,gBAAgB,GAAG,IAAI;IAC7B;EACF;EAEA,OAAOJ,aAAa;AACtB","ignoreList":[]}

package/lib/commonjs/pickDirectory.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pickDirectory = pickDirectory;
+var _reactNative = require("react-native");
+var _NativeDocumentPicker = require("./spec/NativeDocumentPicker");
+/**
+ * Base options object for the directory picker. They only slightly influence the appearance of the picker modal on iOS.
+ * You'd rarely use this type directly, but instead use {@link DirectoryPickerOptions}
+ *
+ * which extend this type
+ * @group pickDirectory() types
+ */
+
+/**
+ * @hidden
+ * */
+
+/**
+ * Options for {@link pickDirectory}.
+ *
+ * @group pickDirectory() types
+ * */
+
+/**
+ * This object represents the response from the directory picker, when long-term access was not requested.
+ *
+ * @group pickDirectory() types
+ * */
+
+/**
+ * This object represents the response from the directory picker, when long-term access was requested.
+ *
+ * @group pickDirectory() types
+ * */
+
+// TODO not entirely sure this is a good idea but let's try
+/**
+ * You likely won't use this type directly, but instead use {@link DirectoryPickerResponse} or {@link DirectoryPickerResponseLongTerm}.
+ *
+ * @group pickDirectory() types
+ * */
+
+/**
+ * Opens a directory picker.
+ *
+ * @group DocumentPicker
+ * */
+async function pickDirectory(options) {
+  const optionsOverride = (() => {
+    if (_reactNative.Platform.OS === 'ios') {
+      return {
+        ...options,
+        mode: 'open',
+        allowMultiSelection: false,
+        type: ['public.folder']
+      };
+    } else {
+      return {
+        // technically, "mode" is ignored here, and we shouldn't need to specify anything but the PickOptions data class
+        // requires mode to be set
+        mode: 'open',
+        ...options
+      };
+    }
+  })();
+  return _NativeDocumentPicker.NativeDocumentPicker.pickDirectory(optionsOverride);
+}
+//# sourceMappingURL=pickDirectory.js.map

package/lib/commonjs/pickDirectory.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_NativeDocumentPicker","pickDirectory","options","optionsOverride","Platform","OS","mode","allowMultiSelection","type","NativeDocumentPicker"],"sourceRoot":"../../src","sources":["pickDirectory.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,qBAAA,GAAAD,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAWA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;;AAOA;AACA;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AACA;;AAOA;AACA;AACA;AACA;AACA;AACO,eAAeE,aAAaA,CACjCC,OAAW,EACe;EAC1B,MAAMC,eAAe,GAAG,CAAC,MAAM;IAC7B,IAAIC,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;MACzB,OAAO;QACL,GAAGH,OAAO;QACVI,IAAI,EAAE,MAAM;QACZC,mBAAmB,EAAE,KAAK;QAC1BC,IAAI,EAAE,CAAC,eAAe;MACxB,CAAC;IACH,CAAC,MAAM;MACL,OAAO;QACL;QACA;QACAF,IAAI,EAAE,MAAM;QACZ,GAAGJ;MACL,CAAC;IACH;EACF,CAAC,EAAE,CAAC;EACJ,OAAOO,0CAAoB,CAACR,aAAa,CAACE,eAAe,CAAC;AAG5D","ignoreList":[]}

package/lib/commonjs/release.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.releaseSecureAccess = exports.releaseLongTermAccess = void 0;
+var _NativeDocumentPicker = require("./spec/NativeDocumentPicker");
+/**
+ * For each uri whose release was requested, the result will contain an object with the uri and a status.
+ * */
+
+/**
+ * Android only - Releases long-term access to the given URIs. There's no need to call this method on iOS - there's no iOS equivalent.
+ *
+ * See [Android documentation](https://developer.android.com/reference/android/content/ContentResolver#releasePersistableUriPermission(android.net.Uri,%20int)) for more information.
+ */
+const releaseLongTermAccess = async uris => {
+  return _NativeDocumentPicker.NativeDocumentPicker.releaseLongTermAccess(uris);
+};
+
+/**
+ * iOS only - Releases (stops) secure access to the given URIs. Use with URIs obtained with Open mode or with the Directory Picker.
+ * See [iOS documentation](https://developer.apple.com/documentation/foundation/nsurl/1413736-stopaccessingsecurityscopedresou) for more information.
+ * There's no need to call this method on Android - there's no equivalent method on Android.
+ * */
+exports.releaseLongTermAccess = releaseLongTermAccess;
+const releaseSecureAccess = async uris => {
+  return _NativeDocumentPicker.NativeDocumentPicker.releaseSecureAccess(uris);
+};
+exports.releaseSecureAccess = releaseSecureAccess;
+//# sourceMappingURL=release.js.map

package/lib/commonjs/release.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_NativeDocumentPicker","require","releaseLongTermAccess","uris","NativeDocumentPicker","exports","releaseSecureAccess"],"sourceRoot":"../../src","sources":["release.ts"],"mappings":";;;;;;AAAA,IAAAA,qBAAA,GAAAC,OAAA;AAEA;AACA;AACA;;AAaA;AACA;AACA;AACA;AACA;AACO,MAAMC,qBAAqB,GAAG,MACnCC,IAAc,IAC2B;EACzC,OAAOC,0CAAoB,CAACF,qBAAqB,CAACC,IAAI,CAAC;AACzD,CAAC;;AAED;AACA;AACA;AACA;AACA;AAJAE,OAAA,CAAAH,qBAAA,GAAAA,qBAAA;AAKO,MAAMI,mBAAmB,GAAG,MAAOH,IAAc,IAAoB;EAC1E,OAAOC,0CAAoB,CAACE,mBAAmB,CAACH,IAAI,CAAC;AACvD,CAAC;AAAAE,OAAA,CAAAC,mBAAA,GAAAA,mBAAA","ignoreList":[]}

package/lib/commonjs/saveDocuments.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.saveDocuments = saveDocuments;
+var _NativeDocumentPicker = require("./spec/NativeDocumentPicker");
+var _reactNative = require("react-native");
+/**
+ * Options object for the {@link saveDocuments} method. `sourceUris` is the only required field.
+ *
+ * @group saveDocuments() types
+ */
+
+/**
+ * The result of calling {@link saveDocuments}. It is very unlikely that the metadata fields would be `null`, but in theory, it can happen.
+ *
+ * @group saveDocuments() types
+ */
+
+/**
+ * The method for opening a "save as" dialog and saving source file(s) to a new location.
+ *
+ * On Android, only one file can be saved at a time.
+ *
+ * @group DocumentPicker
+ * */
+async function saveDocuments(options) {
+  const writeDocumentResponse = await (async () => {
+    if (_reactNative.Platform.OS === 'android') {
+      const length = options.sourceUris.length;
+      if (length > 1) {
+        console.warn(`DocumentPicker.saveDocuments: Android only allows to save one file at a time.\n
+      You provided an array with ${length} entries.`);
+      }
+      // making this division into 2 calls might be an overkill... but who knows
+      const objectWithSingleUri = await _NativeDocumentPicker.NativeDocumentPicker.saveDocument(options);
+      const response = await _NativeDocumentPicker.NativeDocumentPicker.writeDocuments(objectWithSingleUri);
+      return response;
+    } else {
+      return _NativeDocumentPicker.NativeDocumentPicker.writeDocuments(options);
+    }
+  })();
+  return writeDocumentResponse.map(keepOnlySpecifiedFields);
+}
+function keepOnlySpecifiedFields(source) {
+  return {
+    uri: source.uri,
+    name: source.name,
+    error: source.error
+    // type: source.type,
+    // nativeType: source.nativeType,
+  };
+}
+//# sourceMappingURL=saveDocuments.js.map

package/lib/commonjs/saveDocuments.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_NativeDocumentPicker","require","_reactNative","saveDocuments","options","writeDocumentResponse","Platform","OS","length","sourceUris","console","warn","objectWithSingleUri","NativeDocumentPicker","saveDocument","response","writeDocuments","map","keepOnlySpecifiedFields","source","uri","name","error"],"sourceRoot":"../../src","sources":["saveDocuments.ts"],"mappings":";;;;;;AAAA,IAAAA,qBAAA,GAAAC,OAAA;AAGA,IAAAC,YAAA,GAAAD,OAAA;AAEA;AACA;AACA;AACA;AACA;;AAwBA;AACA;AACA;AACA;AACA;;AAuBA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,eAAeE,aAAaA,CACjCC,OAA6B,EACkB;EAC/C,MAAMC,qBAAqB,GAAG,MAAM,CAAC,YAAY;IAC/C,IAAIC,qBAAQ,CAACC,EAAE,KAAK,SAAS,EAAE;MAC7B,MAAMC,MAAM,GAAGJ,OAAO,CAACK,UAAU,CAACD,MAAM;MACxC,IAAIA,MAAM,GAAG,CAAC,EAAE;QACdE,OAAO,CAACC,IAAI,CAAC;AACrB,mCAAmCH,MAAM,WAAW,CAAC;MAC/C;MACA;MACA,MAAMI,mBAAmB,GAAG,MAAMC,0CAAoB,CAACC,YAAY,CAACV,OAAO,CAAC;MAC5E,MAAMW,QAAQ,GAAG,MAAMF,0CAAoB,CAACG,cAAc,CAACJ,mBAAmB,CAAC;MAC/E,OAAOG,QAAQ;IACjB,CAAC,MAAM;MACL,OAAOF,0CAAoB,CAACG,cAAc,CAACZ,OAAO,CAAC;IAGrD;EACF,CAAC,EAAE,CAAC;EACJ,OAAOC,qBAAqB,CAACY,GAAG,CAACC,uBAAuB,CAAC;AAC3D;AAEA,SAASA,uBAAuBA,CAACC,MAA8B,EAAyB;EACtF,OAAO;IACLC,GAAG,EAAED,MAAM,CAACC,GAAG;IACfC,IAAI,EAAEF,MAAM,CAACE,IAAI;IACjBC,KAAK,EAAEH,MAAM,CAACG;IACd;IACA;EACF,CAAC;AACH","ignoreList":[]}

package/lib/commonjs/spec/NativeDocumentPicker.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NativeDocumentPicker = void 0;
+var _reactNative = require("react-native");
+/**
+ * Indicates, for each Uri that was passed to {@link keepLocalCopy}, whether the local copy was successfully created or not.
+ *
+ * If the copy was successful, the status field is `success` and `localUri` contains the local Uri.
+ * If the copy was not successful, the status field is `error` and `copyError` field contains the error message.
+ * */
+
+const NativeDocumentPicker = exports.NativeDocumentPicker = _reactNative.TurboModuleRegistry.getEnforcing('RNDocumentPicker');
+//# sourceMappingURL=NativeDocumentPicker.js.map

package/lib/commonjs/spec/NativeDocumentPicker.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","NativeDocumentPicker","exports","TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../../src","sources":["spec/NativeDocumentPicker.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAGA;AACA;AACA;AACA;AACA;AACA;;AAqBO,MAAMC,oBAAoB,GAAAC,OAAA,CAAAD,oBAAA,GAAGE,gCAAmB,CAACC,YAAY,CAAO,kBAAkB,CAAC","ignoreList":[]}

package/lib/commonjs/types.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.typesAreEqual = void 0;
+/**
+ * If you've requested long-term access to a directory or file, this object will be returned in the response.
+ * In order to access the same directory or file in the future, you must store the `bookmark` opaque string,
+ * and then pass it to the document viewer if you want to preview the file.
+ *
+ * See the Document viewer source on how to retrieve the file from the bookmark, if you need to do that (advanced use case).
+ * */
+
+/**
+ * @group pick() types
+ */
+
+/**
+ * @group pick() types
+ */
+
+/**
+ * iOS only. Configure the transition style of the picker.
+ * */
+
+/**
+ * iOS only. Configure the presentation style of the picker.
+ * */
+
+/*
+ * really, PresentationStyle shouldn't be here and we should just use ModalPropsIOS['presentationStyle']>
+ * but I'm not sure how to get that working with TypeDoc producing a nice output so we duplicate it here
+ * */
+
+const typesAreEqual = exports.typesAreEqual = true;
+//# sourceMappingURL=types.js.map

package/lib/commonjs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["typesAreEqual","exports"],"sourceRoot":"../../src","sources":["types.ts"],"mappings":";;;;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;;AAWA;AACA;AACA;;AAkBA;AACA;AACA;;AAiDA;AACA;AACA;;AAQA;AACA;AACA;;AAOA;AACA;AACA;AACA;;AAIO,MAAMA,aAAoF,GAAAC,OAAA,CAAAD,aAAA,GAC/F,IAAI","ignoreList":[]}

package/lib/commonjs/validateTypes.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.safeValidate = void 0;
+const safeValidate = (requestedTypes, singlePickResult) => {
+  const {
+    nativeType
+  } = singlePickResult;
+  return requestedTypes.some(it => nativeTypeMatches(it, nativeType));
+};
+exports.safeValidate = safeValidate;
+const nativeTypeMatches = (requiredType, actualType) => {
+  if (requiredType === actualType || requiredType === '*/*') {
+    return true;
+  }
+  if (actualType === null) {
+    return false;
+  }
+  if (requiredType.endsWith('/*')) {
+    const requiredTypeWithoutStar = requiredType.slice(0, -2);
+    if (actualType.startsWith(requiredTypeWithoutStar)) {
+      return true;
+    }
+  }
+  return false;
+};
+//# sourceMappingURL=validateTypes.js.map

package/lib/commonjs/validateTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["safeValidate","requestedTypes","singlePickResult","nativeType","some","it","nativeTypeMatches","exports","requiredType","actualType","endsWith","requiredTypeWithoutStar","slice","startsWith"],"sourceRoot":"../../src","sources":["validateTypes.ts"],"mappings":";;;;;;AAEO,MAAMA,YAAY,GAAGA,CAC1BC,cAAwB,EACxBC,gBAA4D,KACzD;EACH,MAAM;IAAEC;EAAW,CAAC,GAAGD,gBAAgB;EACvC,OAAOD,cAAc,CAACG,IAAI,CAAEC,EAAE,IAAKC,iBAAiB,CAACD,EAAE,EAAEF,UAAU,CAAC,CAAC;AACvE,CAAC;AAAAI,OAAA,CAAAP,YAAA,GAAAA,YAAA;AAED,MAAMM,iBAAiB,GAAGA,CAACE,YAAoB,EAAEC,UAAyB,KAAK;EAC7E,IAAID,YAAY,KAAKC,UAAU,IAAID,YAAY,KAAK,KAAK,EAAE;IACzD,OAAO,IAAI;EACb;EACA,IAAIC,UAAU,KAAK,IAAI,EAAE;IACvB,OAAO,KAAK;EACd;EACA,IAAID,YAAY,CAACE,QAAQ,CAAC,IAAI,CAAC,EAAE;IAC/B,MAAMC,uBAAuB,GAAGH,YAAY,CAACI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACzD,IAAIH,UAAU,CAACI,UAAU,CAACF,uBAAuB,CAAC,EAAE;MAClD,OAAO,IAAI;IACb;EACF;EAEA,OAAO,KAAK;AACd,CAAC","ignoreList":[]}

package/lib/module/errors.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const OPERATION_CANCELED = 'OPERATION_CANCELED';
+const IN_PROGRESS = 'ASYNC_OP_IN_PROGRESS';
+const UNABLE_TO_OPEN_FILE_TYPE = 'UNABLE_TO_OPEN_FILE_TYPE';
+
+/**
+ * Error codes that can be returned by the module, and are available on the `code` property of the error.
+ *
+ * @example
+ * ```ts
+ *   const handleError = (err: unknown) => {
+ *     if (isErrorWithCode(err)) {
+ *       switch (err.code) {
+ *         case errorCodes.IN_PROGRESS:
+ *           ...
+ *           break
+ *         case errorCodes.UNABLE_TO_OPEN_FILE_TYPE:
+ *           ...
+ *           break
+ *         case errorCodes.OPERATION_CANCELED:
+ *           // ignore
+ *           break
+ *         default:
+ *           console.error(err)
+ *       }
+ *     } else {
+ *        console.error(err)
+ *     }
+ *   }
+ * ```
+ * */
+export const errorCodes = Object.freeze({
+  OPERATION_CANCELED,
+  IN_PROGRESS,
+  UNABLE_TO_OPEN_FILE_TYPE
+});
+
+/**
+ * TypeScript helper to check if an object has the `code` property.
+ * This is used to avoid `as` casting when you access the `code` property on errors returned by the module.
+ */
+export const isErrorWithCode = error => {
+  // to account for https://github.com/facebook/react-native/issues/41950
+  const isNewArchErrorIOS = typeof error === 'object' && error != null;
+  return (error instanceof Error || isNewArchErrorIOS) && 'code' in error;
+};
+//# sourceMappingURL=errors.js.map

package/lib/module/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["OPERATION_CANCELED","IN_PROGRESS","UNABLE_TO_OPEN_FILE_TYPE","errorCodes","Object","freeze","isErrorWithCode","error","isNewArchErrorIOS","Error"],"sourceRoot":"../../src","sources":["errors.ts"],"mappings":";;AAIA,MAAMA,kBAAkB,GAAG,oBAAoB;AAC/C,MAAMC,WAAW,GAAG,sBAAsB;AAC1C,MAAMC,wBAAwB,GAAG,0BAA0B;;AAE3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,UAAU,GAAGC,MAAM,CAACC,MAAM,CAAC;EACtCL,kBAAkB;EAClBC,WAAW;EACXC;AACF,CAAC,CAAC;;AAEF;AACA;AACA;AACA;AACA,OAAO,MAAMI,eAAe,GAAIC,KAAU,IAAiC;EACzE;EACA,MAAMC,iBAAiB,GAAG,OAAOD,KAAK,KAAK,QAAQ,IAAIA,KAAK,IAAI,IAAI;EACpE,OAAO,CAACA,KAAK,YAAYE,KAAK,IAAID,iBAAiB,KAAK,MAAM,IAAID,KAAK;AACzE,CAAC","ignoreList":[]}

package/lib/module/fileTypes.js

@@ -0,0 +1,81 @@
+"use strict";
+
+import { Platform } from 'react-native';
+
+// TODO split this into platform-specific files, and / or topic-specific files
+
+const mimeTypes = Object.freeze({
+  allFiles: '*/*',
+  audio: 'audio/*',
+  csv: ['text/csv', 'text/comma-separated-values'],
+  doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  images: 'image/*',
+  pdf: 'application/pdf',
+  plainText: 'text/plain',
+  json: 'application/json',
+  ppt: 'application/vnd.ms-powerpoint',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  video: 'video/*',
+  xls: 'application/vnd.ms-excel',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  zip: 'application/zip'
+}); //satisfies TypeOfFileTypes
+
+const utis = Object.freeze({
+  allFiles: 'public.item',
+  audio: 'public.audio',
+  csv: 'public.comma-separated-values-text',
+  doc: 'com.microsoft.word.doc',
+  docx: 'org.openxmlformats.wordprocessingml.document',
+  images: 'public.image',
+  pdf: 'com.adobe.pdf',
+  plainText: 'public.plain-text',
+  json: 'public.json',
+  ppt: 'com.microsoft.powerpoint.ppt',
+  pptx: 'org.openxmlformats.presentationml.presentation',
+  video: 'public.movie',
+  xls: 'com.microsoft.excel.xls',
+  xlsx: 'org.openxmlformats.spreadsheetml.sheet',
+  zip: 'public.zip-archive'
+}); // satisfies TypeOfFileTypes
+
+const perPlatformTypes = {
+  android: mimeTypes,
+  ios: utis,
+  // unsupported, but added to make TS happy
+  macos: utis,
+  windows: mimeTypes,
+  web: mimeTypes
+};
+
+/**
+ * @hidden
+ * */
+export const types = perPlatformTypes[Platform.OS];
+
+/**
+ * You'd rarely use this type directly.
+ * It represents the predefined file types which are exported as `types` and can be used to limit the kinds of files that can be picked.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   pick,
+ *   types,
+ * } from '@react-native-documents/picker'
+ * // ...
+ * const result = await pick({
+ *   type: [types.pdf, types.docx],
+ * })
+ * ```
+ * */
+
+// export type PlatformTypes = typeof perPlatformTypes
+
+// ensure shapes of platformTypes are the same: https://stackoverflow.com/a/67027347/2070942
+// let me know if there's a nicer way
+
+const mimesAndUtisAreEqual = true;
+export const typesAreEqual = mimesAndUtisAreEqual;
+//# sourceMappingURL=fileTypes.js.map

package/lib/module/fileTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Platform","mimeTypes","Object","freeze","allFiles","audio","csv","doc","docx","images","pdf","plainText","json","ppt","pptx","video","xls","xlsx","zip","utis","perPlatformTypes","android","ios","macos","windows","web","types","OS","mimesAndUtisAreEqual","typesAreEqual"],"sourceRoot":"../../src","sources":["fileTypes.ts"],"mappings":";;AAAA,SAASA,QAAQ,QAAQ,cAAc;;AAEvC;;AAEA,MAAMC,SAAS,GAAGC,MAAM,CAACC,MAAM,CAAC;EAC9BC,QAAQ,EAAE,KAAK;EACfC,KAAK,EAAE,SAAS;EAChBC,GAAG,EAAE,CAAC,UAAU,EAAE,6BAA6B,CAAC;EAChDC,GAAG,EAAE,oBAAoB;EACzBC,IAAI,EAAE,yEAAyE;EAC/EC,MAAM,EAAE,SAAS;EACjBC,GAAG,EAAE,iBAAiB;EACtBC,SAAS,EAAE,YAAY;EACvBC,IAAI,EAAE,kBAAkB;EACxBC,GAAG,EAAE,+BAA+B;EACpCC,IAAI,EAAE,2EAA2E;EACjFC,KAAK,EAAE,SAAS;EAChBC,GAAG,EAAE,0BAA0B;EAC/BC,IAAI,EAAE,mEAAmE;EACzEC,GAAG,EAAE;AACP,CAAU,CAAC,EAAC;;AAEZ,MAAMC,IAAI,GAAGjB,MAAM,CAACC,MAAM,CAAC;EACzBC,QAAQ,EAAE,aAAa;EACvBC,KAAK,EAAE,cAAc;EACrBC,GAAG,EAAE,oCAAoC;EACzCC,GAAG,EAAE,wBAAwB;EAC7BC,IAAI,EAAE,8CAA8C;EACpDC,MAAM,EAAE,cAAc;EACtBC,GAAG,EAAE,eAAe;EACpBC,SAAS,EAAE,mBAAmB;EAC9BC,IAAI,EAAE,aAAa;EACnBC,GAAG,EAAE,8BAA8B;EACnCC,IAAI,EAAE,gDAAgD;EACtDC,KAAK,EAAE,cAAc;EACrBC,GAAG,EAAE,yBAAyB;EAC9BC,IAAI,EAAE,wCAAwC;EAC9CC,GAAG,EAAE;AACP,CAAU,CAAC,EAAC;;AAEZ,MAAME,gBAAgB,GAAG;EACvBC,OAAO,EAAEpB,SAAS;EAClBqB,GAAG,EAAEH,IAAI;EACT;EACAI,KAAK,EAAEJ,IAAI;EACXK,OAAO,EAAEvB,SAAS;EAClBwB,GAAG,EAAExB;AACP,CAAC;;AAED;AACA;AACA;AACA,OAAO,MAAMyB,KAAK,GAAGN,gBAAgB,CAACpB,QAAQ,CAAC2B,EAAE,CAAC;;AAQlD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA;;AAEA;AACA;;AASA,MAAMC,oBAAoE,GAAG,IAAI;AACjF,OAAO,MAAMC,aAAa,GAAGD,oBAAoB","ignoreList":[]}