Aucune description

index.d.ts 19KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631
  1. // Type definitions for react-native-fetch-blob 0.10
  2. // Project: https://github.com/wkh237/react-native-fetch-blob#readme
  3. // Definitions by: MNB <https://github.com/MNBuyskih>
  4. // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
  5. export const RNFetchBlob: RNFetchBlobStatic;
  6. export type RNFetchBlob = RNFetchBlobStatic;
  7. export default RNFetchBlob;
  8. interface RNFetchBlobStatic {
  9. fetch(method: Methods, url: string, headers?: { [key: string]: string }, body?: any
  10. | null): StatefulPromise<FetchBlobResponse>;
  11. base64: { encode(input: string): string; decode(input: string): string };
  12. android: AndroidApi;
  13. ios: IOSApi;
  14. config(options: RNFetchBlobConfig): RNFetchBlobStatic;
  15. session(name: string): RNFetchBlobSession;
  16. fs: FS;
  17. wrap(path: string): string;
  18. net: Net;
  19. polyfill: Polyfill;
  20. // this require external module https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/oboe
  21. JSONStream: any;
  22. }
  23. export interface Polyfill {
  24. Blob: PolyfillBlob;
  25. File: PolyfillFile;
  26. XMLHttpRequest: PolyfillXMLHttpRequest;
  27. ProgressEvent: PolyfillProgressEvent;
  28. Event: PolyfillEvent;
  29. FileReader: PolyfillFileReader;
  30. Fetch: PolyfillFetch;
  31. }
  32. export declare class PolyfillFetch extends RNFetchBlobFetchPolyfill {
  33. constructor(config: RNFetchBlobConfig);
  34. }
  35. export declare class RNFetchBlobFetchPolyfill {
  36. constructor(config: RNFetchBlobConfig);
  37. build(): (url: string, options: RNFetchBlobConfig) => StatefulPromise<RNFetchBlobFetchRepsonse>;
  38. }
  39. export interface RNFetchBlobFetchRepsonse {
  40. arrayBuffer(): Promise<any[]>;
  41. blob(): Promise<PolyfillBlob>;
  42. json(): Promise<any>;
  43. rawResp(): Promise<FetchBlobResponse>;
  44. text(): Promise<string>;
  45. bodyUsed: boolean;
  46. headers: any;
  47. ok: boolean;
  48. resp: FetchBlobResponse;
  49. rnfbResp: FetchBlobResponse;
  50. rnfbRespInfo: RNFetchBlobResponseInfo;
  51. status: number;
  52. type: string;
  53. }
  54. /**
  55. * RNFetchBlob response object class.
  56. */
  57. export interface FetchBlobResponse {
  58. taskId: string;
  59. /**
  60. * get path of response temp file
  61. * @return File path of temp file.
  62. */
  63. path(): string;
  64. type: "base64" | "path" | "utf8";
  65. data: any;
  66. /**
  67. * Convert result to javascript RNFetchBlob object.
  68. * @return Return a promise resolves Blob object.
  69. */
  70. blob(contentType: string, sliceSize: number): Promise<PolyfillBlob>;
  71. /**
  72. * Convert result to text.
  73. * @return Decoded base64 string.
  74. */
  75. text(): string | Promise<any>;
  76. /**
  77. * Convert result to JSON object.
  78. * @return Parsed javascript object.
  79. */
  80. json(): any;
  81. /**
  82. * Return BASE64 string directly.
  83. * @return BASE64 string of response body.
  84. */
  85. base64(): any;
  86. /**
  87. * Remove cahced file
  88. */
  89. flush(): void;
  90. respInfo: RNFetchBlobResponseInfo;
  91. session(name: string): RNFetchBlobSession | null;
  92. /**
  93. * Read file content with given encoding, if the response does not contains
  94. * a file path, show warning message
  95. * @param encode Encode type, should be one of `base64`, `ascrii`, `utf8`.
  96. */
  97. readFile(encode: Encoding): Promise<any> | null;
  98. /**
  99. * Start read stream from cached file
  100. * @param encode Encode type, should be one of `base64`, `ascrii`, `utf8`.
  101. */
  102. readStream(encode: Encoding): RNFetchBlobStream | null;
  103. }
  104. export interface PolyfillFileReader extends EventTarget {
  105. isRNFBPolyFill: boolean;
  106. onloadstart(e: Event): void;
  107. onprogress(e: Event): void;
  108. onload(e: Event): void;
  109. onabort(e: Event): void;
  110. onerror(e: Event): void;
  111. onloadend(e: Event): void;
  112. abort(): void;
  113. readAsArrayBuffer(b: PolyfillBlob): void;
  114. readAsBinaryString(b: PolyfillBlob): void;
  115. readAsText(b: PolyfillBlob, label?: string): void;
  116. readAsDataURL(b: PolyfillBlob): void;
  117. readyState: number;
  118. result: number;
  119. }
  120. export declare namespace PolyfillFileReader {
  121. const EMPTY: number;
  122. const LOADING: number;
  123. const DONE: number;
  124. }
  125. export declare class PolyfillEvent {
  126. }
  127. export interface PolyfillProgressEvent extends EventTarget {
  128. lengthComputable: boolean;
  129. loaded: number;
  130. total: number;
  131. }
  132. export declare class PolyfillBlob implements EventTarget {
  133. /**
  134. * RNFetchBlob Blob polyfill, create a Blob directly from file path, BASE64
  135. * encoded data, and string. The conversion is done implicitly according to
  136. * given `mime`. However, the blob creation is asynchronously, to register
  137. * event `onCreated` is need to ensure the Blob is creadted.
  138. *
  139. * @param data Content of Blob object
  140. * @param cType Content type settings of Blob object, `text/plain` by default
  141. * @param defer When this argument set to `true`, blob constructor will not invoke blob created event automatically.
  142. */
  143. constructor(data: any, cType: any, defer: boolean);
  144. /**
  145. * Since Blob content will asynchronously write to a file during creation,
  146. * use this method to register an event handler for Blob initialized event.
  147. * @param fn An event handler invoked when Blob created
  148. * @return The Blob object instance itself
  149. */
  150. onCreated(fn: () => void): PolyfillBlob;
  151. markAsDerived(): void;
  152. /**
  153. * Get file reference of the Blob object.
  154. * @return Blob file reference which can be consumed by RNFetchBlob fs
  155. */
  156. getRNFetchBlobRef(): string;
  157. /**
  158. * Create a Blob object which is sliced from current object
  159. * @param start Start byte number
  160. * @param end End byte number
  161. * @param contentType Optional, content type of new Blob object
  162. */
  163. slice(start?: number, end?: number, contentType?: string): PolyfillBlob;
  164. /**
  165. * Read data of the Blob object, this is not standard method.
  166. * @param encoding Read data with encoding
  167. */
  168. readBlob(encoding: string): Promise<any>;
  169. /**
  170. * Release the resource of the Blob object.
  171. * @nonstandard
  172. */
  173. close(): Promise<void>;
  174. }
  175. export declare namespace PolyfillBlob {
  176. function clearCache(): void;
  177. function build(data: any, cType: any): Promise<PolyfillBlob>;
  178. function setLog(level: number): void;
  179. }
  180. export declare class PolyfillFile extends PolyfillBlob {
  181. }
  182. export interface PolyfillXMLHttpRequest extends PolyfillXMLHttpRequestEventTarget {
  183. upload: PolyfillXMLHttpRequestEventTarget;
  184. readonly UNSENT: number;
  185. readonly OPENED: number;
  186. readonly HEADERS_RECEIVED: number;
  187. readonly LOADING: number;
  188. readonly DONE: number;
  189. /**
  190. * XMLHttpRequest.open, always async, user and password not supported. When
  191. * this method invoked, headers should becomes empty again.
  192. * @param method Request method
  193. * @param url Request URL
  194. * @param async Always async
  195. * @param user NOT SUPPORTED
  196. * @param password NOT SUPPORTED
  197. */
  198. open(method: string, url: string, async: true, user: any, password: any): void;
  199. /**
  200. * Invoke this function to send HTTP request, and set body.
  201. * @param body Body in RNfetchblob flavor
  202. */
  203. send(body: any): void;
  204. overrideMimeType(mime: string): void;
  205. setRequestHeader(name: string, value: string): void;
  206. abort(): void;
  207. getResponseHeader(field: string): string | null;
  208. getAllResponseHeaders(): string | null;
  209. onreadystatechange(e: Event): void;
  210. readyState: number;
  211. status: number;
  212. statusText: string;
  213. response: any;
  214. responseText: any;
  215. responseURL: string;
  216. responseHeaders: any;
  217. timeout: number;
  218. responseType: string;
  219. }
  220. export declare namespace PolyfillXMLHttpRequest {
  221. const binaryContentTypes: string[];
  222. const UNSENT: number;
  223. const OPENED: number;
  224. const HEADERS_RECEIVED: number;
  225. const LOADING: number;
  226. const DONE: number;
  227. function setLog(level: number): void;
  228. function addBinaryContentType(substr: string): void;
  229. function removeBinaryContentType(): void;
  230. }
  231. export interface PolyfillXMLHttpRequestEventTarget extends EventTarget {
  232. onabort(e: Event): void;
  233. onerror(e: Event): void;
  234. onload(e: Event): void;
  235. onloadstart(e: Event): void;
  236. onprogress(e: Event): void;
  237. ontimeout(e: Event): void;
  238. onloadend(e: Event): void;
  239. }
  240. export interface Net {
  241. /**
  242. * Get cookie according to the given url.
  243. * @param domain Domain of the cookies to be removed, remove all
  244. * @return Cookies of a specific domain.
  245. */
  246. getCookies(domain: string): Promise<string[]>;
  247. /**
  248. * Remove cookies for a specific domain
  249. * @param domain Domain of the cookies to be removed, remove all
  250. * cookies when this is null.
  251. */
  252. removeCookies(domain?: string): Promise<null>;
  253. }
  254. type HashAlgorithm = "md5" | "sha1" | "sha224" | "sha256" | "sha384" | "sha512";
  255. export interface FS {
  256. RNFetchBlobSession: RNFetchBlobSession;
  257. /**
  258. * Remove file at path.
  259. * @param path:string Path of target file.
  260. */
  261. unlink(path: string): Promise<void>;
  262. /**
  263. * Create a directory.
  264. * @param path Path of directory to be created
  265. */
  266. mkdir(path: string): Promise<void>;
  267. /**
  268. * Get a file cache session
  269. * @param name Stream ID
  270. */
  271. session(name: string): RNFetchBlobSession;
  272. ls(path: string): Promise<string[]>;
  273. /**
  274. * Read the file from the given path and calculate a cryptographic hash sum over its contents.
  275. *
  276. * @param path Path to the file
  277. * @param algorithm The hash algorithm to use
  278. */
  279. hash(path: string, algorithm: HashAlgorithm);
  280. /**
  281. * Create file stream from file at `path`.
  282. * @param path The file path.
  283. * @param encoding Data encoding, should be one of `base64`, `utf8`, `ascii`
  284. * @param bufferSize Size of stream buffer.
  285. * @return RNFetchBlobStream stream instance.
  286. */
  287. readStream(path: string, encoding: Encoding, bufferSize?: number, tick?: number): Promise<RNFetchBlobReadStream>;
  288. mv(path: string, dest: string): Promise<boolean>;
  289. cp(path: string, dest: string): Promise<boolean>;
  290. /**
  291. * Create write stream to a file.
  292. * @param path Target path of file stream.
  293. * @param encoding Encoding of input data.
  294. * @param append A flag represent if data append to existing ones.
  295. * @return A promise resolves a `WriteStream` object.
  296. */
  297. writeStream(path: string, encoding: Encoding, append?: boolean): Promise<RNFetchBlobWriteStream>;
  298. /**
  299. * Write data to file.
  300. * @param path Path of the file.
  301. * @param data Data to write to the file.
  302. * @param encoding Encoding of data (Optional).
  303. */
  304. writeFile(path: string, data: string | number[], encoding?: Encoding): Promise<void>;
  305. appendFile(path: string, data: string | number[], encoding?: Encoding): Promise<void>;
  306. /**
  307. * Wrapper method of readStream.
  308. * @param path Path of the file.
  309. * @param encoding Encoding of read stream.
  310. */
  311. readFile(path: string, encoding: Encoding, bufferSize?: number): Promise<any>;
  312. /**
  313. * Check if file exists and if it is a folder.
  314. * @param path Path to check
  315. */
  316. exists(path: string): Promise<boolean>;
  317. createFile(path: string, data: string, encoding: Encoding): Promise<void>;
  318. isDir(path: string): Promise<boolean>;
  319. /**
  320. * Show statistic data of a path.
  321. * @param path Target path
  322. */
  323. stat(path: string): Promise<RNFetchBlobStat>;
  324. lstat(path: string): Promise<RNFetchBlobStat[]>;
  325. /**
  326. * Android only method, request media scanner to scan the file.
  327. * @param pairs Array contains Key value pairs with key `path` and `mime`.
  328. */
  329. scanFile(pairs: Array<{ [key: string]: string }>): Promise<void>;
  330. dirs: Dirs;
  331. slice(src: string, dest: string, start: number, end: number): Promise<void>;
  332. asset(path: string): string;
  333. df(): Promise<{ free: number, total: number }>;
  334. }
  335. export interface Dirs {
  336. DocumentDir: string;
  337. CacheDir: string;
  338. PictureDir: string;
  339. MusicDir: string;
  340. MovieDir: string;
  341. DownloadDir: string;
  342. DCIMDir: string;
  343. SDCardDir: string;
  344. MainBundleDir: string;
  345. }
  346. export interface RNFetchBlobWriteStream {
  347. id: string;
  348. encoding: string;
  349. append: boolean;
  350. write(data: string): Promise<void>;
  351. close(): void;
  352. }
  353. export interface RNFetchBlobReadStream {
  354. path: string;
  355. encoding: Encoding;
  356. bufferSize?: number;
  357. closed: boolean;
  358. tick: number;
  359. open(): void;
  360. onData(fn: (chunk: string | number[]) => void): void;
  361. onError(fn: (err: any) => void): void;
  362. onEnd(fn: () => void): void;
  363. }
  364. type Encoding = "utf8" | "ascii" | "base64";
  365. /* tslint:disable-next-line interface-name*/
  366. export interface IOSApi {
  367. /**
  368. * Open a file in {@link https://developer.apple.com/reference/uikit/uidocumentinteractioncontroller UIDocumentInteractionController},
  369. * this is the default document viewer of iOS, supports several kinds of files. On Android, there's an similar method {@link android.actionViewIntent}.
  370. * @param path This is a required field, the path to the document. The path should NOT contains any scheme prefix.
  371. */
  372. previewDocument(path: string): void;
  373. /**
  374. * Show options menu for interact with the file.
  375. * @param path This is a required field, the path to the document. The path should NOT contains any scheme prefix.
  376. */
  377. openDocument(path: string): void;
  378. }
  379. export interface AndroidApi {
  380. /**
  381. * When sending an ACTION_VIEW intent with given file path and MIME type, system will try to open an
  382. * App to handle the file. For example, open Gallery app to view an image, or install APK.
  383. * @param path Path of the file to be opened.
  384. * @param mime Basically system will open an app according to this MIME type.
  385. */
  386. actionViewIntent(path: string, mime: string): Promise<any>;
  387. }
  388. type Methods = "POST" | "GET" | "DELETE" | "PUT" | "post" | "get" | "delete" | "put";
  389. /**
  390. * A declare class inherits Promise, it has extra method like progress, uploadProgress,
  391. * and cancel which can help managing an asynchronous task's state.
  392. */
  393. export interface StatefulPromise<T> extends Promise<T> {
  394. /**
  395. * Cancel the request when invoke this method.
  396. */
  397. cancel(cb?: (reason: any) => void): StatefulPromise<FetchBlobResponse>;
  398. /**
  399. * Add an event listener which triggers when data receiving from server.
  400. */
  401. progress(callback: (received: number, total: number) => void): StatefulPromise<FetchBlobResponse>;
  402. /**
  403. * Add an event listener with custom configuration
  404. */
  405. progress(config: { count?: number, interval?: number }, callback: (received: number, total: number) => void): StatefulPromise<FetchBlobResponse>;
  406. /**
  407. * Add an event listener with custom configuration.
  408. */
  409. uploadProgress(callback: (sent: number, total: number) => void): StatefulPromise<FetchBlobResponse>;
  410. /**
  411. * Add an event listener with custom configuration
  412. */
  413. uploadProgress(config: { count?: number, interval?: number }, callback: (sent: number, total: number) => void): StatefulPromise<FetchBlobResponse>;
  414. /**
  415. * An IOS only API, when IOS app turns into background network tasks will be terminated after ~180 seconds,
  416. * in order to handle these expired tasks, you can register an event handler, which will be called after the
  417. * app become active.
  418. */
  419. expire(callback: () => void): StatefulPromise<void>;
  420. }
  421. export declare class RNFetchBlobSession {
  422. constructor(name: string, list: string[]);
  423. add(path: string): RNFetchBlobSession;
  424. remove(path: string): RNFetchBlobSession;
  425. dispose(): Promise<void>;
  426. list(): string[];
  427. name: string;
  428. static getSession(name: string): any;
  429. static setSession(name: string): void;
  430. static removeSession(name: string): void;
  431. }
  432. /**
  433. * A set of configurations that will be injected into a fetch method, with the following properties.
  434. */
  435. export interface RNFetchBlobConfig {
  436. /**
  437. * When this property is true, the downloaded data will overwrite the existing file. (true by default)
  438. */
  439. overwrite?: boolean;
  440. /**
  441. * Set timeout of the request (in milliseconds).
  442. */
  443. timeout?: number;
  444. /**
  445. * Set this property to true to display a network indicator on status bar, this feature is only supported on IOS.
  446. */
  447. indicator?: boolean;
  448. /**
  449. * Set this property to true will allow the request create connection with server have self-signed SSL
  450. * certification. This is not recommended to use in production.
  451. */
  452. trusty?: boolean;
  453. /**
  454. * Set this property to true will makes response data of the fetch stored in a temp file, by default the temp
  455. * file will stored in App's own root folder with file name template RNFetchBlob_tmp${timestamp}.
  456. */
  457. fileCache?: boolean;
  458. /**
  459. * Set this property to change temp file extension that created by fetch response data.
  460. */
  461. appendExt?: string;
  462. /**
  463. * When this property has value, fetch API will try to store response data in the path ignoring fileCache and
  464. * appendExt property.
  465. */
  466. path?: string;
  467. session?: string;
  468. addAndroidDownloads?: AddAndroidDownloads;
  469. /**
  470. * Fix IOS request timeout issue #368 by change default request setting to defaultSessionConfiguration, and make backgroundSessionConfigurationWithIdentifier optional
  471. */
  472. IOSBackgroundTask?: boolean;
  473. }
  474. export interface AddAndroidDownloads {
  475. /**
  476. * download file using Android download manager or not.
  477. */
  478. useDownloadManager?: boolean;
  479. /**
  480. * title of the file
  481. */
  482. title?: string;
  483. /**
  484. * File description of the file.
  485. */
  486. description?: string;
  487. /**
  488. * The destination which the file will be downloaded, it SHOULD be a location on external storage (DCIMDir).
  489. */
  490. path?: string;
  491. /**
  492. * MIME type of the file. By default is text/plain
  493. */
  494. mime?: string;
  495. /**
  496. * A boolean value, see Officail Document
  497. * (https://developer.android.com/reference/android/app/DownloadManager.html#addCompletedDownload(java.lang.String, java.lang.String, boolean, java.lang.String, java.lang.String, long, boolean))
  498. */
  499. mediaScannable?: boolean;
  500. /**
  501. * A boolean value decide whether show a notification when download complete.
  502. */
  503. notification?: boolean;
  504. }
  505. export interface RNFetchBlobResponseInfo {
  506. taskId: string;
  507. state: number;
  508. headers: any;
  509. status: number;
  510. respType: "text" | "blob" | "" | "json";
  511. rnfbEncode: "path" | "base64" | "ascii" | "utf8";
  512. }
  513. export interface RNFetchBlobStream {
  514. onData(): void;
  515. onError(): void;
  516. onEnd(): void;
  517. }
  518. export declare class RNFetchBlobFile {
  519. }
  520. export declare class RNFetchBlobStat {
  521. lastModified: string;
  522. size: string;
  523. type: "directory" | "file";
  524. path: string;
  525. filename: string;
  526. }