Nessuna descrizione

index.d.ts 19KB

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