@react-native-documents/picker 9.3.1

package/lib/module/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+export { isKnownType } from './isKnownType';
+export { keepLocalCopy } from './keepLocalCopy';
+
+// TODO expose from /fileTypes?
+export { types } from './fileTypes';
+export { errorCodes, isErrorWithCode } from './errors';
+export { pickDirectory } from './pickDirectory';
+export { pick } from './pick';
+export { saveDocuments } from './saveDocuments';
+export { releaseLongTermAccess, releaseSecureAccess } from './release';
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isKnownType","keepLocalCopy","types","errorCodes","isErrorWithCode","pickDirectory","pick","saveDocuments","releaseLongTermAccess","releaseSecureAccess"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,WAAW,QAA2D,eAAe;AAC9F,SACEC,aAAa,QAIR,iBAAiB;;AAExB;AACA,SAASC,KAAK,QAAkC,aAAa;AAC7D,SAASC,UAAU,EAAEC,eAAe,QAAQ,UAAU;AACtD,SAASC,aAAa,QAAQ,iBAAiB;AAS/C,SAASC,IAAI,QAAwC,QAAQ;AAC7D,SACEC,aAAa,QAGR,iBAAiB;AAiBxB,SACEC,qBAAqB,EACrBC,mBAAmB,QAEd,WAAW","ignoreList":[]}

package/lib/module/isKnownType.js

@@ -0,0 +1,24 @@
+"use strict";
+
+import { NativeDocumentPicker } from './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
+ * */
+export function isKnownType(options) {
+  const {
+    kind,
+    value
+  } = options;
+  const result = NativeDocumentPicker.isKnownType(kind, value);
+  return result;
+}
+//# sourceMappingURL=isKnownType.js.map

package/lib/module/isKnownType.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeDocumentPicker","isKnownType","options","kind","value","result"],"sourceRoot":"../../src","sources":["isKnownType.ts"],"mappings":";;AAAA,SAASA,oBAAoB,QAAQ,6BAA6B;;AAElE;AACA;AACA;;AAgCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,WAAWA,CAACC,OAA2B,EAAuB;EAC5E,MAAM;IAAEC,IAAI;IAAEC;EAAM,CAAC,GAAGF,OAAO;EAC/B,MAAMG,MAAM,GAAGL,oBAAoB,CAACC,WAAW,CAACE,IAAI,EAAEC,KAAK,CAAwB;EACnF,OAAOC,MAAM;AACf","ignoreList":[]}

package/lib/module/keepLocalCopy.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import { NativeDocumentPicker } from './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
+ * */
+export function keepLocalCopy(options) {
+  const response = NativeDocumentPicker.keepLocalCopy(options);
+  return response;
+}
+//# sourceMappingURL=keepLocalCopy.js.map

package/lib/module/keepLocalCopy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeDocumentPicker","keepLocalCopy","options","response"],"sourceRoot":"../../src","sources":["keepLocalCopy.ts"],"mappings":";;AACA,SAAiCA,oBAAoB,QAAQ,6BAA6B;;AAE1F;AACA;AACA;;AAmBA;AACA;AACA;AACA;;AAMA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,aAAaA,CAACC,OAA6B,EAAkC;EAC3F,MAAMC,QAAQ,GAAGH,oBAAoB,CAACC,aAAa,CAACC,OAAO,CAAC;EAC5D,OAAOC,QAAQ;AACjB","ignoreList":[]}

package/lib/module/package.json

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

package/lib/module/pick.js

@@ -0,0 +1,90 @@
+"use strict";
+
+import { NativeDocumentPicker } from './spec/NativeDocumentPicker';
+import { types } from './fileTypes';
+import { Platform } from 'react-native';
+import { safeValidate } from './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
+ * */
+export async function pick(options) {
+  const type = (() => {
+    if (!options?.type) {
+      return [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.pick(newOpts);
+  const awaitedResult = await response;
+  for (const res of awaitedResult) {
+    if (Platform.OS === 'android') {
+      res.hasRequestedType = safeValidate(newOpts.type, res);
+    } else {
+      res.hasRequestedType = true;
+    }
+  }
+  return awaitedResult;
+}
+//# sourceMappingURL=pick.js.map

package/lib/module/pick.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeDocumentPicker","types","Platform","safeValidate","pick","options","type","allFiles","newType","Array","isArray","flat","map","it","trim","newOpts","mode","allowMultiSelection","allowVirtualFiles","every","TypeError","includes","response","awaitedResult","res","OS","hasRequestedType"],"sourceRoot":"../../src","sources":["pick.ts"],"mappings":";;AAAA,SAASA,oBAAoB,QAAQ,6BAA6B;AAElE,SAA8BC,KAAK,QAAQ,aAAa;AAQxD,SAASC,QAAQ,QAAQ,cAAc;AACvC,SAASC,YAAY,QAAQ,iBAAiB;;AAE9C;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;AACA,OAAO,eAAeC,IAAIA,CAAkCC,OAAW,EAAmB;EACxF,MAAMC,IAAc,GAAG,CAAC,MAAM;IAC5B,IAAI,CAACD,OAAO,EAAEC,IAAI,EAAE;MAClB,OAAO,CAACL,KAAK,CAACM,QAAQ,CAAC;IACzB;IACA,MAAMC,OAAO,GAAGC,KAAK,CAACC,OAAO,CAACL,OAAO,CAACC,IAAI,CAAC,GAAGD,OAAO,CAACC,IAAI,GAAG,CAACD,OAAO,CAACC,IAAI,CAAC;IAC3E,OAAOE,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,GAAGb,OAAO;IACVC;EACF,CAAC;EAED,IAAI,CAACS,OAAO,CAACT,IAAI,CAACa,KAAK,CAAEN,EAAW,IAAK,OAAOA,EAAE,KAAK,QAAQ,CAAC,EAAE;IAChE,MAAM,IAAIO,SAAS,CACjB,6BAA6BL,OAAO,CAACT,IAAI,mEAC3C,CAAC;EACH;EAEA,IAAI,MAAM,IAAIS,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,GAAGtB,oBAAoB,CAACI,IAAI,CAACW,OAAO,CAAC;EACtF,MAAMQ,aAAa,GAAG,MAAMD,QAAQ;EACpC,KAAK,MAAME,GAAG,IAAID,aAAa,EAAE;IAC/B,IAAIrB,QAAQ,CAACuB,EAAE,KAAK,SAAS,EAAE;MAC7BD,GAAG,CAACE,gBAAgB,GAAGvB,YAAY,CAACY,OAAO,CAACT,IAAI,EAAEkB,GAAG,CAAC;IACxD,CAAC,MAAM;MACLA,GAAG,CAACE,gBAAgB,GAAG,IAAI;IAC7B;EACF;EAEA,OAAOH,aAAa;AACtB","ignoreList":[]}

package/lib/module/pickDirectory.js

@@ -0,0 +1,68 @@
+"use strict";
+
+import { Platform } from 'react-native';
+import { NativeDocumentPicker } from './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
+ * */
+export async function pickDirectory(options) {
+  const optionsOverride = (() => {
+    if (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.pickDirectory(optionsOverride);
+}
+//# sourceMappingURL=pickDirectory.js.map

package/lib/module/pickDirectory.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Platform","NativeDocumentPicker","pickDirectory","options","optionsOverride","OS","mode","allowMultiSelection","type"],"sourceRoot":"../../src","sources":["pickDirectory.ts"],"mappings":";;AACA,SAASA,QAAQ,QAAQ,cAAc;AACvC,SAASC,oBAAoB,QAAQ,6BAA6B;;AAElE;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;AACA,OAAO,eAAeC,aAAaA,CACjCC,OAAW,EACe;EAC1B,MAAMC,eAAe,GAAG,CAAC,MAAM;IAC7B,IAAIJ,QAAQ,CAACK,EAAE,KAAK,KAAK,EAAE;MACzB,OAAO;QACL,GAAGF,OAAO;QACVG,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,GAAGH;MACL,CAAC;IACH;EACF,CAAC,EAAE,CAAC;EACJ,OAAOF,oBAAoB,CAACC,aAAa,CAACE,eAAe,CAAC;AAG5D","ignoreList":[]}

package/lib/module/release.js

@@ -0,0 +1,26 @@
+"use strict";
+
+import { NativeDocumentPicker } from './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.
+ */
+export const releaseLongTermAccess = async uris => {
+  return 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.
+ * */
+export const releaseSecureAccess = async uris => {
+  return NativeDocumentPicker.releaseSecureAccess(uris);
+};
+//# sourceMappingURL=release.js.map

package/lib/module/release.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeDocumentPicker","releaseLongTermAccess","uris","releaseSecureAccess"],"sourceRoot":"../../src","sources":["release.ts"],"mappings":";;AAAA,SAASA,oBAAoB,QAAQ,6BAA6B;;AAElE;AACA;AACA;;AAaA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,qBAAqB,GAAG,MACnCC,IAAc,IAC2B;EACzC,OAAOF,oBAAoB,CAACC,qBAAqB,CAACC,IAAI,CAAC;AACzD,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,mBAAmB,GAAG,MAAOD,IAAc,IAAoB;EAC1E,OAAOF,oBAAoB,CAACG,mBAAmB,CAACD,IAAI,CAAC;AACvD,CAAC","ignoreList":[]}

package/lib/module/saveDocuments.js

@@ -0,0 +1,52 @@
+"use strict";
+
+import { NativeDocumentPicker } from './spec/NativeDocumentPicker';
+import { Platform } from '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
+ * */
+export async function saveDocuments(options) {
+  const writeDocumentResponse = await (async () => {
+    if (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.saveDocument(options);
+      const response = await NativeDocumentPicker.writeDocuments(objectWithSingleUri);
+      return response;
+    } else {
+      return 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/module/saveDocuments.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeDocumentPicker","Platform","saveDocuments","options","writeDocumentResponse","OS","length","sourceUris","console","warn","objectWithSingleUri","saveDocument","response","writeDocuments","map","keepOnlySpecifiedFields","source","uri","name","error"],"sourceRoot":"../../src","sources":["saveDocuments.ts"],"mappings":";;AAAA,SAASA,oBAAoB,QAAQ,6BAA6B;AAGlE,SAASC,QAAQ,QAAQ,cAAc;;AAEvC;AACA;AACA;AACA;AACA;;AAwBA;AACA;AACA;AACA;AACA;;AAuBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeC,aAAaA,CACjCC,OAA6B,EACkB;EAC/C,MAAMC,qBAAqB,GAAG,MAAM,CAAC,YAAY;IAC/C,IAAIH,QAAQ,CAACI,EAAE,KAAK,SAAS,EAAE;MAC7B,MAAMC,MAAM,GAAGH,OAAO,CAACI,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,MAAMV,oBAAoB,CAACW,YAAY,CAACR,OAAO,CAAC;MAC5E,MAAMS,QAAQ,GAAG,MAAMZ,oBAAoB,CAACa,cAAc,CAACH,mBAAmB,CAAC;MAC/E,OAAOE,QAAQ;IACjB,CAAC,MAAM;MACL,OAAOZ,oBAAoB,CAACa,cAAc,CAACV,OAAO,CAAC;IAGrD;EACF,CAAC,EAAE,CAAC;EACJ,OAAOC,qBAAqB,CAACU,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/module/spec/NativeDocumentPicker.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { TurboModuleRegistry } from '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.
+ * */
+
+export const NativeDocumentPicker = TurboModuleRegistry.getEnforcing('RNDocumentPicker');
+//# sourceMappingURL=NativeDocumentPicker.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","NativeDocumentPicker","getEnforcing"],"sourceRoot":"../../../src","sources":["spec/NativeDocumentPicker.ts"],"mappings":";;AACA,SAASA,mBAAmB,QAAQ,cAAc;;AAGlD;AACA;AACA;AACA;AACA;AACA;;AAqBA,OAAO,MAAMC,oBAAoB,GAAGD,mBAAmB,CAACE,YAAY,CAAO,kBAAkB,CAAC","ignoreList":[]}

package/lib/module/types.js

@@ -0,0 +1,33 @@
+"use strict";
+
+/**
+ * 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
+ * */
+
+export const typesAreEqual = true;
+//# sourceMappingURL=types.js.map

package/lib/module/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["typesAreEqual"],"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;;AAIA,OAAO,MAAMA,aAAoF,GAC/F,IAAI","ignoreList":[]}

package/lib/module/validateTypes.js

@@ -0,0 +1,24 @@
+"use strict";
+
+export const safeValidate = (requestedTypes, singlePickResult) => {
+  const {
+    nativeType
+  } = singlePickResult;
+  return requestedTypes.some(it => nativeTypeMatches(it, nativeType));
+};
+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/module/validateTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["safeValidate","requestedTypes","singlePickResult","nativeType","some","it","nativeTypeMatches","requiredType","actualType","endsWith","requiredTypeWithoutStar","slice","startsWith"],"sourceRoot":"../../src","sources":["validateTypes.ts"],"mappings":";;AAEA,OAAO,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;AAED,MAAMG,iBAAiB,GAAGA,CAACC,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/typescript/errors.d.ts

@@ -0,0 +1,40 @@
+export interface NativeModuleError extends Error {
+    code: string;
+}
+/**
+ * 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 declare const errorCodes: Readonly<{
+    OPERATION_CANCELED: "OPERATION_CANCELED";
+    IN_PROGRESS: "ASYNC_OP_IN_PROGRESS";
+    UNABLE_TO_OPEN_FILE_TYPE: "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 declare const isErrorWithCode: (error: any) => error is NativeModuleError;
+//# sourceMappingURL=errors.d.ts.map

package/lib/typescript/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAkB,SAAQ,KAAK;IAC9C,IAAI,EAAE,MAAM,CAAA;CACb;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;KAyBK;AACL,eAAO,MAAM,UAAU;;;;EAIrB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,UAAW,GAAG,KAAG,KAAK,IAAI,iBAIrD,CAAA"}

package/lib/typescript/fileTypes.d.ts

@@ -0,0 +1,94 @@
+declare const mimeTypes: Readonly<{
+    readonly allFiles: "*/*";
+    readonly audio: "audio/*";
+    readonly csv: readonly ["text/csv", "text/comma-separated-values"];
+    readonly doc: "application/msword";
+    readonly docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    readonly images: "image/*";
+    readonly pdf: "application/pdf";
+    readonly plainText: "text/plain";
+    readonly json: "application/json";
+    readonly ppt: "application/vnd.ms-powerpoint";
+    readonly pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    readonly video: "video/*";
+    readonly xls: "application/vnd.ms-excel";
+    readonly xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    readonly zip: "application/zip";
+}>;
+declare const utis: Readonly<{
+    readonly allFiles: "public.item";
+    readonly audio: "public.audio";
+    readonly csv: "public.comma-separated-values-text";
+    readonly doc: "com.microsoft.word.doc";
+    readonly docx: "org.openxmlformats.wordprocessingml.document";
+    readonly images: "public.image";
+    readonly pdf: "com.adobe.pdf";
+    readonly plainText: "public.plain-text";
+    readonly json: "public.json";
+    readonly ppt: "com.microsoft.powerpoint.ppt";
+    readonly pptx: "org.openxmlformats.presentationml.presentation";
+    readonly video: "public.movie";
+    readonly xls: "com.microsoft.excel.xls";
+    readonly xlsx: "org.openxmlformats.spreadsheetml.sheet";
+    readonly zip: "public.zip-archive";
+}>;
+/**
+ * @hidden
+ * */
+export declare const types: Readonly<{
+    readonly allFiles: "*/*";
+    readonly audio: "audio/*";
+    readonly csv: readonly ["text/csv", "text/comma-separated-values"];
+    readonly doc: "application/msword";
+    readonly docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    readonly images: "image/*";
+    readonly pdf: "application/pdf";
+    readonly plainText: "text/plain";
+    readonly json: "application/json";
+    readonly ppt: "application/vnd.ms-powerpoint";
+    readonly pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    readonly video: "video/*";
+    readonly xls: "application/vnd.ms-excel";
+    readonly xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    readonly zip: "application/zip";
+}> | Readonly<{
+    readonly allFiles: "public.item";
+    readonly audio: "public.audio";
+    readonly csv: "public.comma-separated-values-text";
+    readonly doc: "com.microsoft.word.doc";
+    readonly docx: "org.openxmlformats.wordprocessingml.document";
+    readonly images: "public.image";
+    readonly pdf: "com.adobe.pdf";
+    readonly plainText: "public.plain-text";
+    readonly json: "public.json";
+    readonly ppt: "com.microsoft.powerpoint.ppt";
+    readonly pptx: "org.openxmlformats.presentationml.presentation";
+    readonly video: "public.movie";
+    readonly xls: "com.microsoft.excel.xls";
+    readonly xlsx: "org.openxmlformats.spreadsheetml.sheet";
+    readonly zip: "public.zip-archive";
+}>;
+type ValuesOf<T> = T[keyof T];
+type Flatten<T> = T extends Array<infer U> ? U : T;
+type AllMimeTypes = Flatten<ValuesOf<typeof mimeTypes>>;
+type AllAppleUTIs = ValuesOf<typeof utis>;
+/**
+ * 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 PredefinedFileTypes = Flatten<AllMimeTypes> | AllAppleUTIs;
+export declare const typesAreEqual: true;
+export {};
+//# sourceMappingURL=fileTypes.d.ts.map

package/lib/typescript/fileTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileTypes.d.ts","sourceRoot":"","sources":["../../src/fileTypes.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;EAgBJ,CAAA;AAEX,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;EAgBC,CAAA;AAWX;;KAEK;AACL,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAgC,CAAA;AAElD,KAAK,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA;AAC7B,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAElD,KAAK,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,OAAO,SAAS,CAAC,CAAC,CAAA;AACvD,KAAK,YAAY,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAA;AAEzC;;;;;;;;;;;;;;;KAeK;AACL,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAAA;AAetE,eAAO,MAAM,aAAa,MAAuB,CAAA"}

package/lib/typescript/index.d.ts

@@ -0,0 +1,13 @@
+export { isKnownType, type IsKnownTypeResponse, type IsKnownTypeOptions } from './isKnownType';
+export { keepLocalCopy, type KeepLocalCopyOptions, type KeepLocalCopyResponse, type FileToCopy, } from './keepLocalCopy';
+export { types, type PredefinedFileTypes } from './fileTypes';
+export { errorCodes, isErrorWithCode } from './errors';
+export { pickDirectory } from './pickDirectory';
+export type { PickDirectoryResponse, DirectoryPickerOptions, DirectoryPickerOptionsLongTerm, DirectoryPickerResponse, DirectoryPickerResponseLongTerm, DirectoryPickerOptionsBase, } from './pickDirectory';
+export { pick, type DocumentPickerOptionsBase } from './pick';
+export { saveDocuments, type SaveDocumentsResponse, type SaveDocumentsOptions, } from './saveDocuments';
+export type { NonEmptyArray, TransitionStyle, BookmarkingResponse, DocumentPickerResponse, PresentationStyle, VirtualFileMeta, } from './types';
+export type { DocumentPickerOptions, DocumentPickerOptionsImport, DocumentPickerOptionsOpenOnce, DocumentPickerOptionsOpenLongTerm, DocumentPickerResponseOpenLongTerm, } from './pick';
+export type { LocalCopyResponse } from './spec/NativeDocumentPicker';
+export { releaseLongTermAccess, releaseSecureAccess, type ReleaseLongTermAccessResult, } from './release';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAC9F,OAAO,EACL,aAAa,EACb,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,UAAU,GAChB,MAAM,iBAAiB,CAAA;AAGxB,OAAO,EAAE,KAAK,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,YAAY,EACV,qBAAqB,EACrB,sBAAsB,EACtB,8BAA8B,EAC9B,uBAAuB,EACvB,+BAA+B,EAC/B,0BAA0B,GAC3B,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,IAAI,EAAE,KAAK,yBAAyB,EAAE,MAAM,QAAQ,CAAA;AAC7D,OAAO,EACL,aAAa,EACb,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,GAC1B,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,sBAAsB,EACtB,iBAAiB,EACjB,eAAe,GAChB,MAAM,SAAS,CAAA;AAChB,YAAY,EACV,qBAAqB,EACrB,2BAA2B,EAC3B,6BAA6B,EAC7B,iCAAiC,EACjC,kCAAkC,GACnC,MAAM,QAAQ,CAAA;AACf,YAAY,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,KAAK,2BAA2B,GACjC,MAAM,WAAW,CAAA"}

package/lib/typescript/isKnownType.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The result of calling {@link isKnownType}
+ * */
+export type IsKnownTypeResponse = {
+    /**
+     * On iOS, this is true if the type is known to the device. That means it can be used with the document picker to filter what files can be picked.
+     * On Android, this is true if the internal mime type database contains the given value.
+     * */
+    isKnown: boolean;
+    /**
+     * the preferred filename extension for the given value, if any
+     * */
+    preferredFilenameExtension: string | null;
+    /**
+     * the mime type for the given value, if any
+     * */
+    mimeType: string | null;
+    /**
+     * the UTType identifier for the given value, if any
+     * */
+    UTType: string | null;
+};
+export type IsKnownTypeOptions = {
+    /**
+     * the kind of value you're passing
+     * */
+    kind: 'UTType' | 'mimeType' | 'extension';
+    /**
+     * the value you're checking, for example: application/pdf, com.adobe.pdf, pdf
+     * */
+    value: string;
+};
+/**
+ *
+ * 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
+ * */
+export declare function isKnownType(options: IsKnownTypeOptions): IsKnownTypeResponse;
+//# sourceMappingURL=isKnownType.d.ts.map

package/lib/typescript/isKnownType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isKnownType.d.ts","sourceRoot":"","sources":["../../src/isKnownType.ts"],"names":[],"mappings":"AAEA;;KAEK;AACL,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;SAGK;IACL,OAAO,EAAE,OAAO,CAAA;IAChB;;SAEK;IACL,0BAA0B,EAAE,MAAM,GAAG,IAAI,CAAA;IACzC;;SAEK;IACL,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB;;SAEK;IACL,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;SAEK;IACL,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,WAAW,CAAA;IACzC;;SAEK;IACL,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;KAMK;AACL,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,mBAAmB,CAI5E"}