@ohos-ports/react-native-fs 2.20.0-beta.0

package/FS.common.js

@@ -0,0 +1,997 @@
+/**
+ * React Native FS — HarmonyOS Node.js migration (Round 1)
+ *
+ * Original implementation was backed by React Native's NativeModules.RNFSManager
+ * (Objective-C / Java / C# native bridges) and react-native's NativeEventEmitter.
+ * The HarmonyOS Node.js runtime has no React Native host runtime, so the native
+ * bridge layer has been rewritten on top of verified Node.js built-in capabilities:
+ *   - file operations  -> node:fs / node:fs/promises
+ *   - downloadFile     -> node:http / node:https
+ *   - uploadFiles      -> node:http / node:https (multipart/form-data)
+ *   - NativeEventEmitter -> node:events (EventEmitter)
+ *
+ * Flow type annotations have been stripped so the file is plain CommonJS that
+ * Node.js can parse directly. All public API names, signatures and
+ * Promise/event semantics are preserved from the original FS.common.js.
+ */
+
+'use strict';
+
+var fsp = require('node:fs/promises');
+var fs = require('node:fs');
+var path = require('node:path');
+var os = require('node:os');
+var http = require('node:http');
+var https = require('node:https');
+var crypto = require('node:crypto');
+var EventEmitter = require('node:events');
+
+var base64 = require('base-64');
+var utf8 = require('utf8');
+
+function fsSafeCreateWriteStream(toFile) {
+  var fspSync = require('node:fs');
+  return fspSync.createWriteStream(toFile, { flags: 'w' });
+}
+
+// ---------------------------------------------------------------------------
+// Event emitter replacement (react-native NativeEventEmitter -> node:events)
+// ---------------------------------------------------------------------------
+var RNFS_NativeEventEmitter = new EventEmitter();
+var _nativeAddListener = RNFS_NativeEventEmitter.addListener.bind(RNFS_NativeEventEmitter);
+// RN listeners are removed via `subscription.remove()`; wrap to keep that contract
+RNFS_NativeEventEmitter.addListener = function (eventName, handler) {
+  _nativeAddListener(eventName, handler);
+  return {
+    remove: function () {
+      RNFS_NativeEventEmitter.removeListener(eventName, handler);
+    },
+  };
+};
+
+var RNFSFileTypeRegular = 0;
+var RNFSFileTypeDirectory = 1;
+
+var jobId = 0;
+
+var getJobId = function () {
+  jobId += 1;
+  return jobId;
+};
+
+var normalizeFilePath = function (path) {
+  return path.startsWith('file://') ? path.slice(7) : path;
+};
+
+var homeDir = process.env.HOME || process.cwd();
+
+var downloadJobs = {};
+var uploadJobs = {};
+
+function toSeconds(ms) {
+  return Math.floor(ms / 1000);
+}
+
+// ---------------------------------------------------------------------------
+// Bridge layer (replaces NativeModules.RNFSManager)
+// Every method mirrors the original RNFSManager native bridge contract:
+// readFile/read/write return base64 strings, stat/readDir return raw records
+// with epoch-second timestamps, so the public API layer below stays untouched.
+// ---------------------------------------------------------------------------
+var RNFSManager = {
+
+  mkdir: function (dirPath) {
+    return fsp.mkdir(dirPath, { recursive: true }).then(function () { return void 0; });
+  },
+
+  moveFile: function (filepath, destPath) {
+    return fsp.rename(filepath, destPath).catch(function (err) {
+      if (err && err.code === 'EXDEV') {
+        // cross-device move: copy then remove
+        return fsp.copyFile(filepath, destPath).then(function () {
+          return fsp.unlink(filepath);
+        });
+      }
+      throw err;
+    }).then(function () { return void 0; });
+  },
+
+  copyFile: function (filepath, destPath) {
+    return fsp.copyFile(filepath, destPath).then(function () { return void 0; });
+  },
+
+  unlink: function (filepath) {
+    return fsp.rm(filepath, { recursive: true }).then(function () { return void 0; });
+  },
+
+  exists: function (filepath) {
+    return fsp.stat(filepath).then(function () { return true; }, function () { return false; });
+  },
+
+  stat: function (filepath) {
+    return fsp.stat(filepath).then(function (st) {
+      return {
+        name: path.basename(filepath),
+        path: filepath,
+        size: st.size,
+        mode: st.mode,
+        ctime: toSeconds(st.ctimeMs),
+        mtime: toSeconds(st.mtimeMs),
+        originalFilepath: filepath,
+        type: st.isDirectory() ? RNFSFileTypeDirectory : RNFSFileTypeRegular,
+      };
+    });
+  },
+
+  readFile: function (filepath) {
+    return fsp.readFile(filepath).then(function (buf) {
+      return buf.toString('base64');
+    });
+  },
+
+  read: function (filepath, length, position) {
+    return fsp.open(filepath, 'r').then(function (fh) {
+      var done = false;
+      var finish = function (p) {
+        if (done) return p;
+        done = true;
+        return fh.close().then(function () { return p; });
+      };
+      return fh.stat().then(function (st) {
+        var start = position && position >= 0 ? position : 0;
+        var readLen = length && length > 0 ? length : Math.max(st.size - start, 0);
+        var buf = Buffer.alloc(readLen);
+        return fh.read(buf, 0, readLen, start).then(function (result) {
+          var out = buf.slice(0, result.bytesRead).toString('base64');
+          return finish(out);
+        });
+      }).catch(function (err) {
+        return finish(Promise.reject(err));
+      });
+    });
+  },
+
+  writeFile: function (filepath, b64) {
+    return fsp.writeFile(filepath, Buffer.from(b64, 'base64')).then(function () { return void 0; });
+  },
+
+  appendFile: function (filepath, b64) {
+    return fsp.appendFile(filepath, Buffer.from(b64, 'base64')).then(function () { return void 0; });
+  },
+
+  write: function (filepath, b64, position) {
+    var data = Buffer.from(b64, 'base64');
+    if (position === undefined || position === null || position < 0) {
+      // RN bridge semantics: position -1 (or undefined) means append
+      return fsp.appendFile(filepath, data).then(function () { return void 0; });
+    }
+    return fsp.open(filepath, 'r+').then(function (fh) {
+      var done = false;
+      var finish = function (p) {
+        if (done) return p;
+        done = true;
+        return fh.close().then(function () { return p; });
+      };
+      return fh.write(data, 0, data.length, position)
+        .then(function () { return finish(void 0); })
+        .catch(function (err) { return finish(Promise.reject(err)); });
+    });
+  },
+
+  readDir: function (dirPath) {
+    return fsp.readdir(dirPath, { withFileTypes: true }).then(function (entries) {
+      return Promise.all(entries.map(function (entry) {
+        var full = path.join(dirPath, entry.name);
+        return fsp.stat(full).then(
+          function (st) {
+            return {
+              ctime: toSeconds(st.ctimeMs),
+              mtime: toSeconds(st.mtimeMs),
+              name: entry.name,
+              path: full,
+              size: String(st.size),
+              type: st.isDirectory() ? RNFSFileTypeDirectory : RNFSFileTypeRegular,
+            };
+          },
+          function () {
+            return {
+              ctime: null,
+              mtime: null,
+              name: entry.name,
+              path: full,
+              size: '0',
+              type: entry.isDirectory() ? RNFSFileTypeDirectory : RNFSFileTypeRegular,
+            };
+          }
+        );
+      }));
+    });
+  },
+
+  hash: function (filepath, algorithm) {
+    return fsp.readFile(filepath).then(function (buf) {
+      return crypto.createHash(algorithm).update(buf).digest('hex');
+    });
+  },
+
+  touch: function (filepath, mtimeMs) {
+    var when = mtimeMs ? new Date(mtimeMs) : new Date();
+    // touch creates the file if it does not exist (same as the native bridges)
+    return fsp.stat(filepath).catch(function (err) {
+      if (err && err.code === 'ENOENT') {
+        return fsp.writeFile(filepath, '', { flag: 'a' }).then(function () { return null; });
+      }
+      throw err;
+    }).then(function () {
+      return fsp.utimes(filepath, when, when).then(function () { return void 0; });
+    });
+  },
+
+  setReadable: function (filepath, readable, ownerOnly) {
+    var mode = readable ? (ownerOnly ? 0o700 : 0o755) : 0o000;
+    return fsp.chmod(filepath, mode).then(function () { return true; }, function () { return false; });
+  },
+
+  scanFile: function (filepath) {
+    return fsp.stat(filepath).then(function (st) {
+      return [{
+        path: filepath,
+        name: path.basename(filepath),
+        size: String(st.size),
+        type: st.isDirectory() ? RNFSFileTypeDirectory : RNFSFileTypeRegular,
+        ctime: toSeconds(st.ctimeMs),
+        mtime: toSeconds(st.mtimeMs),
+      }];
+    });
+  },
+
+  getFSInfo: function () {
+    return fsp.statfs(homeDir).then(function (stats) {
+      return {
+        totalSpace: Number(stats.blocks) * Number(stats.bsize),
+        freeSpace: Number(stats.bavail) * Number(stats.bsize),
+      };
+    });
+  },
+
+  downloadFile: function (options) {
+    return new Promise(function (resolve, reject) {
+      var jid = options.jobId;
+      var failed = false;
+
+      var doRequest = function (urlStr, redirects) {
+        var parsed;
+        try {
+          parsed = new URL(urlStr);
+        } catch (e) {
+          reject(e);
+          return;
+        }
+        var mod = parsed.protocol === 'https:' ? https : (parsed.protocol === 'http:' ? http : null);
+        if (!mod) {
+          reject(new Error('Unsupported protocol: ' + parsed.protocol));
+          return;
+        }
+
+        var req = mod.get(parsed, { headers: options.headers || {} }, function (res) {
+          // follow redirects like the native bridges do
+          if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+            if (redirects >= 5) {
+              res.resume();
+              reject(new Error('Maximum redirect count reached'));
+              return;
+            }
+            res.resume();
+            doRequest(new URL(res.headers.location, parsed).toString(), redirects + 1);
+            return;
+          }
+
+          var statusCode = res.statusCode;
+          var contentLength = parseInt(res.headers['content-length'] || '0', 10) || 0;
+
+          RNFS_NativeEventEmitter.emit('DownloadBegin', {
+            jobId: jid,
+            statusCode: statusCode,
+            contentLength: contentLength,
+            headers: res.headers,
+          });
+
+          var out = fs.createWriteStream(options.toFile, { flags: 'w' });
+          var bytesWritten = 0;
+          var lastEmitTime = Date.now();
+          var lastEmitBytes = 0;
+
+          var abort = function (err) {
+            if (failed) return;
+            failed = true;
+            delete downloadJobs[jid];
+            try { req.destroy(); } catch (e) { /* noop */ }
+            try { out.destroy(); } catch (e) { /* noop */ }
+            reject(err);
+          };
+          downloadJobs[jid] = { abort: abort };
+
+          res.on('data', function (chunk) {
+            bytesWritten += chunk.length;
+            if (!out.write(chunk)) {
+              res.pause();
+              out.once('drain', function () { res.resume(); });
+            }
+            var now = Date.now();
+            var intervalOk = !options.progressInterval || (now - lastEmitTime) >= options.progressInterval;
+            var dividerOk = !options.progressDivider || (bytesWritten - lastEmitBytes) >= options.progressDivider;
+            if (intervalOk && dividerOk) {
+              lastEmitTime = now;
+              lastEmitBytes = bytesWritten;
+              RNFS_NativeEventEmitter.emit('DownloadProgress', {
+                jobId: jid,
+                contentLength: contentLength,
+                bytesWritten: bytesWritten,
+              });
+            }
+          });
+
+          res.on('error', function (err) { abort(err); });
+          out.on('error', function (err) { abort(err); });
+
+          res.on('end', function () {
+            out.end(function () {
+              if (failed) return;
+              delete downloadJobs[jid];
+              resolve({ jobId: jid, statusCode: statusCode, bytesWritten: bytesWritten });
+            });
+          });
+        });
+
+        // connection timeout (time to establish the connection)
+        var connectTimer = setTimeout(function () {
+          req.destroy(new Error('Connection timeout'));
+          reject(new Error('Connection timeout'));
+        }, options.connectionTimeout || 5000);
+        req.on('socket', function (socket) {
+          socket.once('connect', function () { clearTimeout(connectTimer); });
+        });
+        // read/inactivity timeout
+        req.setTimeout(options.readTimeout || 15000, function () {
+          req.destroy(new Error('Read timeout'));
+          reject(new Error('Read timeout'));
+        });
+        req.on('error', function (err) {
+          if (failed) return;
+          failed = true;
+          delete downloadJobs[jid];
+          reject(err);
+        });
+      };
+
+      doRequest(options.fromUrl, 0);
+    });
+  },
+
+  uploadFiles: function (options) {
+    return new Promise(function (resolve, reject) {
+      var jid = options.jobId;
+      var boundary = 'RNFSBoundary' + Date.now().toString(16) + Math.random().toString(16).slice(2);
+
+      var prepareBody;
+      if (options.binaryStreamOnly && options.files && options.files.length > 0) {
+        // raw binary stream upload of the first file, no multipart framing
+        prepareBody = fsp.readFile(options.files[0].filepath).then(function (data) {
+          return { body: data, contentType: null };
+        });
+      } else {
+        var parts = [];
+        var fields = options.fields || {};
+        Object.keys(fields).forEach(function (name) {
+          parts.push(Buffer.from(
+            '--' + boundary + '\r\n' +
+            'Content-Disposition: form-data; name="' + String(name) + '"\r\n\r\n' +
+            String(fields[name]) + '\r\n'
+          ));
+        });
+        var fileParts = (options.files || []).map(function (file) {
+          var filename = file.filename || path.basename(file.filepath || '');
+          var filetype = file.filetype || 'application/octet-stream';
+          return fsp.readFile(normalizeFilePath(file.filepath)).then(function (data) {
+            parts.push(Buffer.concat([
+              Buffer.from(
+                '--' + boundary + '\r\n' +
+                'Content-Disposition: form-data; name="' + (file.name || filename) +
+                '"; filename="' + filename + '"\r\n' +
+                'Content-Type: ' + filetype + '\r\n\r\n'
+              ),
+              data,
+              Buffer.from('\r\n'),
+            ]));
+          });
+        });
+        prepareBody = Promise.all(fileParts).then(function () {
+          parts.push(Buffer.from('--' + boundary + '--\r\n'));
+          return { body: Buffer.concat(parts), contentType: 'multipart/form-data; boundary=' + boundary };
+        });
+      }
+
+      prepareBody.then(function (prepared) {
+        var body = prepared.body;
+        var parsed;
+        try {
+          parsed = new URL(options.toUrl);
+        } catch (e) {
+          reject(e);
+          return;
+        }
+        var mod = parsed.protocol === 'https:' ? https : (parsed.protocol === 'http:' ? http : null);
+        if (!mod) {
+          reject(new Error('Unsupported protocol: ' + parsed.protocol));
+          return;
+        }
+        var headers = Object.assign({}, options.headers || {});
+        if (prepared.contentType) headers['Content-Type'] = prepared.contentType;
+        headers['Content-Length'] = body.length;
+        var req = mod.request(parsed, { method: options.method || 'POST', headers: headers }, function (res) {
+          var chunks = [];
+          res.on('data', function (c) { chunks.push(c); });
+          res.on('end', function () {
+            delete uploadJobs[jid];
+            resolve({
+              jobId: jid,
+              statusCode: res.statusCode,
+              headers: res.headers,
+              body: Buffer.concat(chunks).toString('utf8'),
+            });
+          });
+          res.on('error', function (err) { reject(err); });
+        });
+        uploadJobs[jid] = {
+          abort: function (err) {
+            delete uploadJobs[jid];
+            try { req.destroy(); } catch (e) { /* noop */ }
+            reject(err);
+          },
+        };
+
+        RNFS_NativeEventEmitter.emit('UploadBegin', { jobId: jid });
+
+        // write in chunks to provide progress callbacks
+        var CHUNK = 64 * 1024;
+        var totalBytesSent = 0;
+        var offset = 0;
+        var writeNext = function () {
+          if (offset >= body.length) {
+            req.end();
+            return;
+          }
+          var chunk = body.slice(offset, Math.min(offset + CHUNK, body.length));
+          offset += chunk.length;
+          totalBytesSent += chunk.length;
+          RNFS_NativeEventEmitter.emit('UploadProgress', {
+            jobId: jid,
+            totalBytesExpectedToSend: body.length,
+            totalBytesSent: totalBytesSent,
+          });
+          if (req.write(chunk)) {
+            process.nextTick(writeNext);
+          } else {
+            req.once('drain', writeNext);
+          }
+        };
+        writeNext();
+
+        req.on('error', function (err) {
+          delete uploadJobs[jid];
+          reject(err);
+        });
+      }).catch(reject);
+    });
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Public API layer — identical structure and semantics to the original
+// FS.common.js, with Flow type annotations stripped for plain Node.js.
+// ---------------------------------------------------------------------------
+
+/**
+ * Generic function used by readFile and readFileAssets
+ */
+function readFileGeneric(filepath, encodingOrOptions, command) {
+  var options = {
+    encoding: 'utf8'
+  };
+
+  if (encodingOrOptions) {
+    if (typeof encodingOrOptions === 'string') {
+      options.encoding = encodingOrOptions;
+    } else if (typeof encodingOrOptions === 'object') {
+      options = encodingOrOptions;
+    }
+  }
+
+  return command(normalizeFilePath(filepath)).then(function (b64) {
+    var contents;
+
+    if (options.encoding === 'utf8') {
+      contents = utf8.decode(base64.decode(b64));
+    } else if (options.encoding === 'ascii') {
+      contents = base64.decode(b64);
+    } else if (options.encoding === 'base64') {
+      contents = b64;
+    } else {
+      throw new Error('Invalid encoding type "' + String(options.encoding) + '"');
+    }
+
+    return contents;
+  });
+}
+
+/**
+ * Generic function used by readDir and readDirAssets
+ */
+function readDirGeneric(dirpath, command) {
+  return command(normalizeFilePath(dirpath)).then(function (files) {
+    return files.map(function (file) {
+      return {
+        ctime: file.ctime && new Date(file.ctime * 1000) || null,
+        mtime: file.mtime && new Date(file.mtime * 1000) || null,
+        name: file.name,
+        path: file.path,
+        size: file.size,
+        isFile: function () { return file.type === RNFSFileTypeRegular; },
+        isDirectory: function () { return file.type === RNFSFileTypeDirectory; },
+      };
+    });
+  });
+}
+
+var RNFS = {
+
+  mkdir(filepath, options = {}) {
+    return RNFSManager.mkdir(normalizeFilePath(filepath), options).then(() => void 0);
+  },
+
+  moveFile(filepath, destPath, options = {}) {
+    return RNFSManager.moveFile(normalizeFilePath(filepath), normalizeFilePath(destPath), options).then(() => void 0);
+  },
+
+  copyFile(filepath, destPath, options = {}) {
+    return RNFSManager.copyFile(normalizeFilePath(filepath), normalizeFilePath(destPath), options).then(() => void 0);
+  },
+
+  pathForBundle(bundleNamed) {
+    // Bundle concept does not exist in a plain Node.js runtime; resolve
+    // relative to the module directory instead of failing entirely.
+    return Promise.resolve(path.resolve(__dirname, bundleNamed));
+  },
+
+  pathForGroup(groupName) {
+    return Promise.reject(new Error('pathForGroup is not supported on this platform'));
+  },
+
+  getFSInfo() {
+    return RNFSManager.getFSInfo();
+  },
+
+  getAllExternalFilesDirs() {
+    return Promise.resolve(path.join(homeDir, 'files'));
+  },
+
+  unlink(filepath) {
+    return RNFSManager.unlink(normalizeFilePath(filepath)).then(() => void 0);
+  },
+
+  exists(filepath) {
+    return RNFSManager.exists(normalizeFilePath(filepath));
+  },
+
+  stopDownload(jobId) {
+    var job = downloadJobs[jobId];
+    if (job && job.abort) {
+      job.abort(new Error('Download has been aborted'));
+    }
+  },
+
+  resumeDownload(jobId) {
+    throw new Error('resumeDownload is not supported on this platform');
+  },
+
+  isResumable(jobId) {
+    return Promise.resolve(false);
+  },
+
+  stopUpload(jobId) {
+    var job = uploadJobs[jobId];
+    if (job && job.abort) {
+      job.abort(new Error('Upload has been aborted'));
+    }
+  },
+
+  completeHandlerIOS(jobId) {
+    // iOS background-fetch completion handler; no-op without an RN host app
+    return void 0;
+  },
+
+  readDir(dirpath) {
+    return readDirGeneric(dirpath, RNFSManager.readDir);
+  },
+
+  // Android-only
+  readDirAssets(dirpath) {
+    if (!RNFSManager.readDirAssets) {
+      throw new Error('readDirAssets is not available on this platform');
+    }
+    return readDirGeneric(dirpath, RNFSManager.readDirAssets);
+  },
+
+  // Android-only
+  existsAssets(filepath) {
+    if (!RNFSManager.existsAssets) {
+      throw new Error('existsAssets is not available on this platform');
+    }
+    return RNFSManager.existsAssets(filepath);
+  },
+
+  // Android-only
+  existsRes(filename) {
+    if (!RNFSManager.existsRes) {
+      throw new Error('existsRes is not available on this platform');
+    }
+    return RNFSManager.existsRes(filename);
+  },
+
+  // Node style version (lowercase d). Returns just the names
+  readdir(dirpath) {
+    return RNFS.readDir(normalizeFilePath(dirpath)).then(files => {
+      return files.map(file => file.name);
+    });
+  },
+
+  // setReadable for Android
+  setReadable(filepath, readable, ownerOnly) {
+    return RNFSManager.setReadable(filepath, readable, ownerOnly).then((result) => {
+      return result;
+    })
+  },
+
+  stat(filepath) {
+    return RNFSManager.stat(normalizeFilePath(filepath)).then((result) => {
+      return {
+        'path': filepath,
+        'ctime': new Date(result.ctime * 1000),
+        'mtime': new Date(result.mtime * 1000),
+        'size': result.size,
+        'mode': result.mode,
+        'originalFilepath': result.originalFilepath,
+        isFile: () => result.type === RNFSFileTypeRegular,
+        isDirectory: () => result.type === RNFSFileTypeDirectory,
+      };
+    });
+  },
+
+  readFile(filepath, encodingOrOptions) {
+    return readFileGeneric(filepath, encodingOrOptions, RNFSManager.readFile);
+  },
+
+  read(filepath, length = 0, position = 0, encodingOrOptions) {
+    var options = {
+      encoding: 'utf8'
+    };
+
+    if (encodingOrOptions) {
+      if (typeof encodingOrOptions === 'string') {
+        options.encoding = encodingOrOptions;
+      } else if (typeof encodingOrOptions === 'object') {
+        options = encodingOrOptions;
+      }
+    }
+
+    return RNFSManager.read(normalizeFilePath(filepath), length, position).then((b64) => {
+      var contents;
+
+      if (options.encoding === 'utf8') {
+        contents = utf8.decode(base64.decode(b64));
+      } else if (options.encoding === 'ascii') {
+        contents = base64.decode(b64);
+      } else if (options.encoding === 'base64') {
+        contents = b64;
+      } else {
+        throw new Error('Invalid encoding type "' + String(options.encoding) + '"');
+      }
+
+      return contents;
+    });
+  },
+
+  // Android only
+  readFileAssets(filepath, encodingOrOptions) {
+    if (!RNFSManager.readFileAssets) {
+      throw new Error('readFileAssets is not available on this platform');
+    }
+    return readFileGeneric(filepath, encodingOrOptions, RNFSManager.readFileAssets);
+  },
+
+  // Android only
+  readFileRes(filename, encodingOrOptions) {
+    if (!RNFSManager.readFileRes) {
+      throw new Error('readFileRes is not available on this platform');
+    }
+    return readFileGeneric(filename, encodingOrOptions, RNFSManager.readFileRes);
+  },
+
+  hash(filepath, algorithm) {
+    return RNFSManager.hash(normalizeFilePath(filepath), algorithm);
+  },
+
+  // Android only
+  copyFileAssets(filepath, destPath) {
+    if (!RNFSManager.copyFileAssets) {
+      throw new Error('copyFileAssets is not available on this platform');
+    }
+    return RNFSManager.copyFileAssets(normalizeFilePath(filepath), normalizeFilePath(destPath)).then(() => void 0);
+  },
+
+  // Android only
+  copyFileRes(filename, destPath) {
+    if (!RNFSManager.copyFileRes) {
+      throw new Error('copyFileRes is not available on this platform');
+    }
+    return RNFSManager.copyFileRes(filename, normalizeFilePath(destPath)).then(() => void 0);
+  },
+
+  // iOS only
+  // Copies fotos from asset-library (camera-roll) to a specific location
+  // with a given width or height
+  // @see: https://developer.apple.com/reference/photos/phimagemanager/1616964-requestimageforasset
+  copyAssetsFileIOS(imageUri, destPath, width, height,
+    scale = 1.0, compression = 1.0, resizeMode = 'contain') {
+    return Promise.reject(new Error('copyAssetsFileIOS is not available on this platform'));
+  },
+
+  // iOS only
+  copyAssetsVideoIOS(imageUri, destPath) {
+    return Promise.reject(new Error('copyAssetsVideoIOS is not available on this platform'));
+  },
+
+  writeFile(filepath, contents, encodingOrOptions) {
+    var b64;
+
+    var options = {
+      encoding: 'utf8'
+    };
+
+    if (encodingOrOptions) {
+      if (typeof encodingOrOptions === 'string') {
+        options.encoding = encodingOrOptions;
+      } else if (typeof encodingOrOptions === 'object') {
+        options = {
+          ...options,
+          ...encodingOrOptions
+        };
+      }
+    }
+
+    if (options.encoding === 'utf8') {
+      b64 = base64.encode(utf8.encode(contents));
+    } else if (options.encoding === 'ascii') {
+      b64 = base64.encode(contents);
+    } else if (options.encoding === 'base64') {
+      b64 = contents;
+    } else {
+      throw new Error('Invalid encoding type "' + options.encoding + '"');
+    }
+
+    return RNFSManager.writeFile(normalizeFilePath(filepath), b64, options).then(() => void 0);
+  },
+
+  appendFile(filepath, contents, encodingOrOptions) {
+    var b64;
+
+    var options = {
+      encoding: 'utf8'
+    };
+
+    if (encodingOrOptions) {
+      if (typeof encodingOrOptions === 'string') {
+        options.encoding = encodingOrOptions;
+      } else if (typeof encodingOrOptions === 'object') {
+        options = encodingOrOptions;
+      }
+    }
+
+    if (options.encoding === 'utf8') {
+      b64 = base64.encode(utf8.encode(contents));
+    } else if (options.encoding === 'ascii') {
+      b64 = base64.encode(contents);
+    } else if (options.encoding === 'base64') {
+      b64 = contents;
+    } else {
+      throw new Error('Invalid encoding type "' + options.encoding + '"');
+    }
+
+    return RNFSManager.appendFile(normalizeFilePath(filepath), b64);
+  },
+
+  write(filepath, contents, position, encodingOrOptions) {
+    var b64;
+
+    var options = {
+      encoding: 'utf8'
+    };
+
+    if (encodingOrOptions) {
+      if (typeof encodingOrOptions === 'string') {
+        options.encoding = encodingOrOptions;
+      } else if (typeof encodingOrOptions === 'object') {
+        options = encodingOrOptions;
+      }
+    }
+
+    if (options.encoding === 'utf8') {
+      b64 = base64.encode(utf8.encode(contents));
+    } else if (options.encoding === 'ascii') {
+      b64 = base64.encode(contents);
+    } else if (options.encoding === 'base64') {
+      b64 = contents;
+    } else {
+      throw new Error('Invalid encoding type "' + options.encoding + '"');
+    }
+
+    if (position === undefined) {
+      position = -1;
+    }
+
+    return RNFSManager.write(normalizeFilePath(filepath), b64, position).then(() => void 0);
+  },
+
+  downloadFile(options) {
+    if (typeof options !== 'object') throw new Error('downloadFile: Invalid value for argument `options`');
+    if (typeof options.fromUrl !== 'string') throw new Error('downloadFile: Invalid value for property `fromUrl`');
+    if (typeof options.toFile !== 'string') throw new Error('downloadFile: Invalid value for property `toFile`');
+    if (options.headers && typeof options.headers !== 'object') throw new Error('downloadFile: Invalid value for property `headers`');
+    if (options.background && typeof options.background !== 'boolean') throw new Error('downloadFile: Invalid value for property `background`');
+    if (options.progressDivider && typeof options.progressDivider !== 'number') throw new Error('downloadFile: Invalid value for property `progressDivider`');
+    if (options.progressInterval && typeof options.progressInterval !== 'number') throw new Error('downloadFile: Invalid value for property `progressInterval`');
+    if (options.readTimeout && typeof options.readTimeout !== 'number') throw new Error('downloadFile: Invalid value for property `readTimeout`');
+    if (options.connectionTimeout && typeof options.connectionTimeout !== 'number') throw new Error('downloadFile: Invalid value for property `connectionTimeout`');
+    if (options.backgroundTimeout && typeof options.backgroundTimeout !== 'number') throw new Error('downloadFile: Invalid value for property `backgroundTimeout`');
+
+    var jobId = getJobId();
+    var subscriptions = [];
+
+    if (options.begin) {
+      subscriptions.push(RNFS_NativeEventEmitter.addListener('DownloadBegin', (res) => {
+        if (res.jobId === jobId) options.begin(res);
+      }));
+    }
+
+    if (options.progress) {
+      subscriptions.push(RNFS_NativeEventEmitter.addListener('DownloadProgress', (res) => {
+        if (res.jobId === jobId) options.progress(res);
+      }));
+    }
+
+    if (options.resumable) {
+      subscriptions.push(RNFS_NativeEventEmitter.addListener('DownloadResumable', (res) => {
+        if (res.jobId === jobId) options.resumable(res);
+      }));
+    }
+
+    var bridgeOptions = {
+      jobId: jobId,
+      fromUrl: options.fromUrl,
+      toFile: normalizeFilePath(options.toFile),
+      headers: options.headers || {},
+      background: !!options.background,
+      progressDivider: options.progressDivider || 0,
+      progressInterval: options.progressInterval || 0,
+      readTimeout: options.readTimeout || 15000,
+      connectionTimeout: options.connectionTimeout || 5000,
+      backgroundTimeout: options.backgroundTimeout || 3600000, // 1 hour
+      hasBeginCallback: options.begin instanceof Function,
+      hasProgressCallback: options.progress instanceof Function,
+      hasResumableCallback: options.resumable instanceof Function,
+    };
+
+    return {
+      jobId,
+      promise: RNFSManager.downloadFile(bridgeOptions).then(res => {
+        subscriptions.forEach(sub => sub.remove());
+        return res;
+      })
+        .catch(e => {
+          subscriptions.forEach(sub => sub.remove());
+          return Promise.reject(e);
+        })
+    };
+  },
+
+  uploadFiles(options) {
+    if (!RNFSManager.uploadFiles) {
+      return {
+        jobId: -1,
+        promise: Promise.reject(new Error('`uploadFiles` is unsupported on this platform'))
+      };
+    }
+
+    var jobId = getJobId();
+    var subscriptions = [];
+
+    if (typeof options !== 'object') throw new Error('uploadFiles: Invalid value for argument `options`');
+    if (typeof options.toUrl !== 'string') throw new Error('uploadFiles: Invalid value for property `toUrl`');
+    if (!Array.isArray(options.files)) throw new Error('uploadFiles: Invalid value for property `files`');
+    if (options.headers && typeof options.headers !== 'object') throw new Error('uploadFiles: Invalid value for property `headers`');
+    if (options.fields && typeof options.fields !== 'object') throw new Error('uploadFiles: Invalid value for property `fields`');
+    if (options.method && typeof options.method !== 'string') throw new Error('uploadFiles: Invalid value for property `method`');
+
+    if (options.begin) {
+      subscriptions.push(RNFS_NativeEventEmitter.addListener('UploadBegin', options.begin));
+    } else if (options.beginCallback) {
+      // Deprecated
+      subscriptions.push(RNFS_NativeEventEmitter.addListener('UploadBegin', options.beginCallback));
+    }
+
+    if (options.progress) {
+      subscriptions.push(RNFS_NativeEventEmitter.addListener('UploadProgress', options.progress));
+    } else if (options.progressCallback) {
+      // Deprecated
+      subscriptions.push(RNFS_NativeEventEmitter.addListener('UploadProgress', options.progressCallback));
+    }
+
+    var bridgeOptions = {
+      jobId: jobId,
+      toUrl: options.toUrl,
+      files: options.files,
+      binaryStreamOnly: options.binaryStreamOnly || false,
+      headers: options.headers || {},
+      fields: options.fields || {},
+      method: options.method || 'POST',
+      hasBeginCallback: options.begin instanceof Function || options.beginCallback instanceof Function,
+      hasProgressCallback: options.progress instanceof Function || options.progressCallback instanceof Function,
+    };
+
+    return {
+      jobId,
+      promise: RNFSManager.uploadFiles(bridgeOptions).then(res => {
+        subscriptions.forEach(sub => sub.remove());
+        return res;
+      }).catch(e => {
+        subscriptions.forEach(sub => sub.remove());
+        return Promise.reject(e);
+      })
+    };
+  },
+
+  touch(filepath, mtime, ctime) {
+    if (ctime && !(ctime instanceof Date)) throw new Error('touch: Invalid value for argument `ctime`');
+    if (mtime && !(mtime instanceof Date)) throw new Error('touch: Invalid value for argument `mtime`');
+    var ctimeTime = 0;
+    if (isIOS) {
+      ctimeTime = ctime && ctime.getTime();
+    }
+    return RNFSManager.touch(
+      normalizeFilePath(filepath),
+      mtime && mtime.getTime(),
+      ctimeTime
+    );
+  },
+
+  scanFile(path) {
+    return RNFSManager.scanFile(path);
+  },
+
+  MainBundlePath: __dirname,
+  CachesDirectoryPath: path.join(os.tmpdir(), 'rnfs-cache'),
+  ExternalCachesDirectoryPath: path.join(os.tmpdir(), 'rnfs-cache'),
+  DocumentDirectoryPath: path.join(homeDir, 'Documents'),
+  DownloadDirectoryPath: path.join(homeDir, 'Downloads'),
+  ExternalDirectoryPath: path.join(homeDir, 'files'),
+  ExternalStorageDirectoryPath: homeDir,
+  TemporaryDirectoryPath: os.tmpdir(),
+  LibraryDirectoryPath: path.join(homeDir, 'Library'),
+  PicturesDirectoryPath: path.join(homeDir, 'Pictures'),
+  FileProtectionKeys: null
+};
+
+var isIOS = false; // React Native Platform.OS is unavailable; Node.js runtime is not iOS
+
+module.exports = RNFS;
+exports = RNFS;