@appium/support 2.61.1 → 3.0.1

package/build/lib/net.js

@@ -1,272 +1,296 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.downloadFile = downloadFile;
-exports.uploadFile = uploadFile;
-
-require("source-map-support/register");
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-var _fs = _interopRequireDefault(require("./fs"));
-
-var _bluebird = _interopRequireDefault(require("bluebird"));
-
-var _util = require("./util");
-
-var _logger = _interopRequireDefault(require("./logger"));
-
-var _jsftp = _interopRequireDefault(require("jsftp"));
-
-var _timing = _interopRequireDefault(require("./timing"));
-
-var _axios = _interopRequireDefault(require("axios"));
-
-var _formData = _interopRequireDefault(require("form-data"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = exports.uploadFile = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const fs_1 = __importDefault(require("./fs"));
+const bluebird_1 = __importDefault(require("bluebird"));
+const util_1 = require("./util");
+const logger_1 = __importDefault(require("./logger"));
+const jsftp_1 = __importDefault(require("jsftp"));
+const timing_1 = __importDefault(require("./timing"));
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
 const DEFAULT_TIMEOUT_MS = 4 * 60 * 1000;
-
+/**
+ * Type guard for param to {@linkcode toAxiosAuth}
+ * @param {any} value
+ * @returns {value is AuthCredentials | import('axios').AxiosBasicCredentials}
+ */
+function isAxiosAuth(value) {
+    return lodash_1.default.isPlainObject(value);
+}
+/**
+ * Converts {@linkcode AuthCredentials} to credentials understood by {@linkcode axios}.
+ * @param {AuthCredentials | import('axios').AxiosBasicCredentials} [auth]
+ * @returns {import('axios').AxiosBasicCredentials?}
+ */
 function toAxiosAuth(auth) {
-  if (!_lodash.default.isPlainObject(auth)) {
-    return null;
-  }
-
-  const axiosAuth = {
-    username: _lodash.default.get(auth, 'username', _lodash.default.get(auth, 'user')),
-    password: _lodash.default.get(auth, 'password', _lodash.default.get(auth, 'pass'))
-  };
-  return axiosAuth.username && axiosAuth.password ? axiosAuth : null;
+    if (!isAxiosAuth(auth)) {
+        return null;
+    }
+    const axiosAuth = {
+        username: 'username' in auth ? auth.username : auth.user,
+        password: 'password' in auth ? auth.password : auth.pass,
+    };
+    return axiosAuth.username && axiosAuth.password ? axiosAuth : null;
 }
-
-async function uploadFileToHttp(localFileStream, parsedUri, uploadOptions = {}) {
-  const {
-    method = 'POST',
-    timeout = DEFAULT_TIMEOUT_MS,
-    headers,
-    auth,
-    fileFieldName = 'file',
-    formFields
-  } = uploadOptions;
-  const {
-    href
-  } = parsedUri;
-  const requestOpts = {
-    url: href,
-    method,
-    timeout,
-    maxContentLength: Infinity,
-    maxBodyLength: Infinity
-  };
-  const axiosAuth = toAxiosAuth(auth);
-
-  if (axiosAuth) {
-    requestOpts.auth = axiosAuth;
-  }
-
-  if (fileFieldName) {
-    const form = new _formData.default();
-    form.append(fileFieldName, localFileStream);
-
-    if (formFields) {
-      let pairs = [];
-
-      if (_lodash.default.isArray(formFields)) {
-        pairs = formFields;
-      } else if (_lodash.default.isPlainObject(formFields)) {
-        pairs = _lodash.default.toPairs(formFields);
-      }
-
-      for (const [key, value] of pairs) {
-        if (_lodash.default.toLower(key) !== _lodash.default.toLower(fileFieldName)) {
-          form.append(key, value);
+/**
+ * @param {NodeJS.ReadableStream} localFileStream
+ * @param {URL} parsedUri
+ * @param {HttpUploadOptions & NetOptions} [uploadOptions]
+ */
+async function uploadFileToHttp(localFileStream, parsedUri, uploadOptions = /** @type {HttpUploadOptions & NetOptions} */ ({})) {
+    const { method = 'POST', timeout = DEFAULT_TIMEOUT_MS, headers, auth, fileFieldName = 'file', formFields, } = uploadOptions;
+    const { href } = parsedUri;
+    /** @type {import('axios').AxiosRequestConfig} */
+    const requestOpts = {
+        url: href,
+        method,
+        timeout,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+    };
+    const axiosAuth = toAxiosAuth(auth);
+    if (axiosAuth) {
+        requestOpts.auth = axiosAuth;
+    }
+    if (fileFieldName) {
+        const form = new form_data_1.default();
+        form.append(fileFieldName, localFileStream);
+        if (formFields) {
+            let pairs = [];
+            if (lodash_1.default.isArray(formFields)) {
+                pairs = formFields;
+            }
+            else if (lodash_1.default.isPlainObject(formFields)) {
+                pairs = lodash_1.default.toPairs(formFields);
+            }
+            for (const [key, value] of pairs) {
+                if (lodash_1.default.toLower(key) !== lodash_1.default.toLower(fileFieldName)) {
+                    form.append(key, value);
+                }
+            }
         }
-      }
+        requestOpts.headers = {
+            ...(lodash_1.default.isPlainObject(headers) ? headers : {}),
+            ...form.getHeaders(),
+        };
+        requestOpts.data = form;
     }
-
-    requestOpts.headers = { ...(_lodash.default.isPlainObject(headers) ? headers : {}),
-      ...form.getHeaders()
-    };
-    requestOpts.data = form;
-  } else {
-    if (_lodash.default.isPlainObject(headers)) {
-      requestOpts.headers = headers;
+    else {
+        if (lodash_1.default.isPlainObject(headers)) {
+            requestOpts.headers = headers;
+        }
+        requestOpts.data = localFileStream;
     }
-
-    requestOpts.data = localFileStream;
-  }
-
-  _logger.default.debug(`Performing ${method} to ${href} with options (excluding data): ` + JSON.stringify(_lodash.default.omit(requestOpts, ['data'])));
-
-  const {
-    status,
-    statusText
-  } = await (0, _axios.default)(requestOpts);
-
-  _logger.default.info(`Server response: ${status} ${statusText}`);
+    logger_1.default.debug(`Performing ${method} to ${href} with options (excluding data): ` +
+        JSON.stringify(lodash_1.default.omit(requestOpts, ['data'])));
+    const { status, statusText } = await (0, axios_1.default)(requestOpts);
+    logger_1.default.info(`Server response: ${status} ${statusText}`);
 }
-
-async function uploadFileToFtp(localFileStream, parsedUri, uploadOptions = {}) {
-  const {
-    auth
-  } = uploadOptions;
-  const {
-    hostname,
-    port,
-    protocol,
-    pathname
-  } = parsedUri;
-  const ftpOpts = {
-    host: hostname,
-    port: !_lodash.default.isUndefined(port) ? _lodash.default.parseInt(port) : 21
-  };
-
-  if (auth !== null && auth !== void 0 && auth.user && auth !== null && auth !== void 0 && auth.pass) {
-    ftpOpts.user = auth.user;
-    ftpOpts.pass = auth.pass;
-  }
-
-  _logger.default.debug(`${protocol} upload options: ${JSON.stringify(ftpOpts)}`);
-
-  return await new _bluebird.default((resolve, reject) => {
-    new _jsftp.default(ftpOpts).put(localFileStream, pathname, err => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve();
-      }
+/**
+ * @param {string | Buffer | NodeJS.ReadableStream} localFileStream
+ * @param {URL} parsedUri
+ * @param {NotHttpUploadOptions & NetOptions} [uploadOptions]
+ */
+async function uploadFileToFtp(localFileStream, parsedUri, uploadOptions = /** @type {NotHttpUploadOptions & NetOptions} */ ({})) {
+    const { auth } = uploadOptions;
+    const { hostname, port, protocol, pathname } = parsedUri;
+    const ftpOpts = {
+        host: hostname,
+        port: !lodash_1.default.isUndefined(port) ? lodash_1.default.parseInt(port) : 21,
+    };
+    if (auth?.user && auth?.pass) {
+        ftpOpts.user = auth.user;
+        ftpOpts.pass = auth.pass;
+    }
+    logger_1.default.debug(`${protocol} upload options: ${JSON.stringify(ftpOpts)}`);
+    return await new bluebird_1.default((resolve, reject) => {
+        new jsftp_1.default(ftpOpts).put(localFileStream, pathname, (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        });
     });
-  });
 }
-
+/**
+ * Returns `true` if params are valid for {@linkcode uploadFileToHttp}.
+ * @param {any} opts
+ * @param {URL} url
+ * @returns {opts is HttpUploadOptions & NetOptions}
+ */
 function isHttpUploadOptions(opts, url) {
-  try {
-    const {
-      protocol
-    } = new URL(url);
-    return protocol === 'http:' || protocol === 'https:';
-  } catch {
-    return false;
-  }
+    try {
+        const { protocol } = url;
+        return protocol === 'http:' || protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
 }
-
+/**
+ * Returns `true` if params are valid for {@linkcode uploadFileToFtp}.
+ * @param {any} opts
+ * @param {URL} url
+ * @returns {opts is NotHttpUploadOptions & NetOptions}
+ */
 function isNotHttpUploadOptions(opts, url) {
-  try {
-    const {
-      protocol
-    } = new URL(url);
-    return protocol === 'ftp:';
-  } catch {
-    return false;
-  }
+    try {
+        const { protocol } = url;
+        return protocol === 'ftp:';
+    }
+    catch {
+        return false;
+    }
 }
-
-async function uploadFile(localPath, remoteUri, uploadOptions = {}) {
-  if (!(await _fs.default.exists(localPath))) {
-    throw new Error(`'${localPath}' does not exists or is not accessible`);
-  }
-
-  const {
-    isMetered = true
-  } = uploadOptions;
-  const url = new URL(remoteUri);
-  const {
-    size
-  } = await _fs.default.stat(localPath);
-
-  if (isMetered) {
-    _logger.default.info(`Uploading '${localPath}' of ${(0, _util.toReadableSizeString)(size)} size to '${remoteUri}'`);
-  }
-
-  const timer = new _timing.default().start();
-
-  if (isHttpUploadOptions(uploadOptions, url)) {
-    if (!uploadOptions.fileFieldName) {
-      uploadOptions.headers = { ...(_lodash.default.isPlainObject(uploadOptions.headers) ? uploadOptions.headers : {}),
-        'Content-Length': size
-      };
+/**
+ * Uploads the given file to a remote location. HTTP(S) and FTP
+ * protocols are supported.
+ *
+ * @param {string} localPath - The path to a file on the local storage.
+ * @param {string} remoteUri - The remote URI to upload the file to.
+ * @param {(HttpUploadOptions|NotHttpUploadOptions) & NetOptions} [uploadOptions]
+ * @returns {Promise<void>}
+ */
+async function uploadFile(localPath, remoteUri, uploadOptions = /** @type {(HttpUploadOptions|NotHttpUploadOptions) & NetOptions} */ ({})) {
+    if (!(await fs_1.default.exists(localPath))) {
+        throw new Error(`'${localPath}' does not exists or is not accessible`);
+    }
+    const { isMetered = true } = uploadOptions;
+    const url = new URL(remoteUri);
+    const { size } = await fs_1.default.stat(localPath);
+    if (isMetered) {
+        logger_1.default.info(`Uploading '${localPath}' of ${(0, util_1.toReadableSizeString)(size)} size to '${remoteUri}'`);
+    }
+    const timer = new timing_1.default().start();
+    if (isHttpUploadOptions(uploadOptions, url)) {
+        if (!uploadOptions.fileFieldName) {
+            uploadOptions.headers = {
+                ...(lodash_1.default.isPlainObject(uploadOptions.headers) ? uploadOptions.headers : {}),
+                'Content-Length': size,
+            };
+        }
+        await uploadFileToHttp(fs_1.default.createReadStream(localPath), url, uploadOptions);
+    }
+    else if (isNotHttpUploadOptions(uploadOptions, url)) {
+        await uploadFileToFtp(fs_1.default.createReadStream(localPath), url, uploadOptions);
+    }
+    else {
+        throw new Error(`Cannot upload the file at '${localPath}' to '${remoteUri}'. ` +
+            `Unsupported remote protocol '${url.protocol}'. ` +
+            `Only http/https and ftp/ftps protocols are supported.`);
+    }
+    if (isMetered) {
+        logger_1.default.info(`Uploaded '${localPath}' of ${(0, util_1.toReadableSizeString)(size)} size in ` +
+            `${timer.getDuration().asSeconds.toFixed(3)}s`);
     }
-
-    await uploadFileToHttp(_fs.default.createReadStream(localPath), url, uploadOptions);
-  } else if (isNotHttpUploadOptions(uploadOptions, url)) {
-    await uploadFileToFtp(_fs.default.createReadStream(localPath), url, uploadOptions);
-  } else {
-    throw new Error(`Cannot upload the file at '${localPath}' to '${remoteUri}'. ` + `Unsupported remote protocol '${url.protocol}'. ` + `Only http/https and ftp/ftps protocols are supported.`);
-  }
-
-  if (isMetered) {
-    _logger.default.info(`Uploaded '${localPath}' of ${(0, _util.toReadableSizeString)(size)} size in ` + `${timer.getDuration().asSeconds.toFixed(3)}s`);
-  }
 }
-
-async function downloadFile(remoteUrl, dstPath, downloadOptions = {}) {
-  const {
-    isMetered = true,
-    auth,
-    timeout = DEFAULT_TIMEOUT_MS,
-    headers
-  } = downloadOptions;
-  const requestOpts = {
-    url: remoteUrl,
-    responseType: 'stream',
-    timeout
-  };
-  const axiosAuth = toAxiosAuth(auth);
-
-  if (axiosAuth) {
-    requestOpts.auth = axiosAuth;
-  }
-
-  if (_lodash.default.isPlainObject(headers)) {
-    requestOpts.headers = headers;
-  }
-
-  const timer = new _timing.default().start();
-  let responseLength;
-
-  try {
-    const writer = _fs.default.createWriteStream(dstPath);
-
-    const {
-      data: responseStream,
-      headers: responseHeaders
-    } = await (0, _axios.default)(requestOpts);
-    responseLength = parseInt(responseHeaders['content-length'], 10);
-    responseStream.pipe(writer);
-    await new _bluebird.default((resolve, reject) => {
-      responseStream.once('error', reject);
-      writer.once('finish', resolve);
-      writer.once('error', e => {
-        responseStream.unpipe(writer);
-        reject(e);
-      });
-    });
-  } catch (err) {
-    throw new Error(`Cannot download the file from ${remoteUrl}: ${err.message}`);
-  }
-
-  const {
-    size
-  } = await _fs.default.stat(dstPath);
-
-  if (responseLength && size !== responseLength) {
-    await _fs.default.rimraf(dstPath);
-    throw new Error(`The size of the file downloaded from ${remoteUrl} (${size} bytes) ` + `differs from the one in Content-Length response header (${responseLength} bytes)`);
-  }
-
-  if (isMetered) {
-    const secondsElapsed = timer.getDuration().asSeconds;
-
-    _logger.default.debug(`${remoteUrl} (${(0, _util.toReadableSizeString)(size)}) ` + `has been downloaded to '${dstPath}' in ${secondsElapsed.toFixed(3)}s`);
-
-    if (secondsElapsed >= 2) {
-      const bytesPerSec = Math.floor(size / secondsElapsed);
-
-      _logger.default.debug(`Approximate download speed: ${(0, _util.toReadableSizeString)(bytesPerSec)}/s`);
+exports.uploadFile = uploadFile;
+/**
+ * Downloads the given file via HTTP(S)
+ *
+ * @param {string} remoteUrl - The remote url
+ * @param {string} dstPath - The local path to download the file to
+ * @param {DownloadOptions & NetOptions} [downloadOptions]
+ * @throws {Error} If download operation fails
+ */
+async function downloadFile(remoteUrl, dstPath, downloadOptions = /** @type {DownloadOptions & NetOptions} */ ({})) {
+    const { isMetered = true, auth, timeout = DEFAULT_TIMEOUT_MS, headers } = downloadOptions;
+    /**
+     * @type {import('axios').AxiosRequestConfig}
+     */
+    const requestOpts = {
+        url: remoteUrl,
+        responseType: 'stream',
+        timeout,
+    };
+    const axiosAuth = toAxiosAuth(auth);
+    if (axiosAuth) {
+        requestOpts.auth = axiosAuth;
+    }
+    if (lodash_1.default.isPlainObject(headers)) {
+        requestOpts.headers = headers;
+    }
+    const timer = new timing_1.default().start();
+    let responseLength;
+    try {
+        const writer = fs_1.default.createWriteStream(dstPath);
+        const { data: responseStream, headers: responseHeaders } = await (0, axios_1.default)(requestOpts);
+        responseLength = parseInt(responseHeaders['content-length'] || '0', 10);
+        responseStream.pipe(writer);
+        await new bluebird_1.default((resolve, reject) => {
+            responseStream.once('error', reject);
+            writer.once('finish', resolve);
+            writer.once('error', (e) => {
+                responseStream.unpipe(writer);
+                reject(e);
+            });
+        });
+    }
+    catch (err) {
+        throw new Error(`Cannot download the file from ${remoteUrl}: ${err.message}`);
+    }
+    const { size } = await fs_1.default.stat(dstPath);
+    if (responseLength && size !== responseLength) {
+        await fs_1.default.rimraf(dstPath);
+        throw new Error(`The size of the file downloaded from ${remoteUrl} (${size} bytes) ` +
+            `differs from the one in Content-Length response header (${responseLength} bytes)`);
+    }
+    if (isMetered) {
+        const secondsElapsed = timer.getDuration().asSeconds;
+        logger_1.default.debug(`${remoteUrl} (${(0, util_1.toReadableSizeString)(size)}) ` +
+            `has been downloaded to '${dstPath}' in ${secondsElapsed.toFixed(3)}s`);
+        if (secondsElapsed >= 2) {
+            const bytesPerSec = Math.floor(size / secondsElapsed);
+            logger_1.default.debug(`Approximate download speed: ${(0, util_1.toReadableSizeString)(bytesPerSec)}/s`);
+        }
     }
-  }
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DEFAULT_TIMEOUT_MS","toAxiosAuth","auth","_","isPlainObject","axiosAuth","username","get","password","uploadFileToHttp","localFileStream","parsedUri","uploadOptions","method","timeout","headers","fileFieldName","formFields","href","requestOpts","url","maxContentLength","Infinity","maxBodyLength","form","FormData","append","pairs","isArray","toPairs","key","value","toLower","getHeaders","data","log","debug","JSON","stringify","omit","status","statusText","axios","info","uploadFileToFtp","hostname","port","protocol","pathname","ftpOpts","host","isUndefined","parseInt","user","pass","B","resolve","reject","Ftp","put","err","isHttpUploadOptions","opts","URL","isNotHttpUploadOptions","uploadFile","localPath","remoteUri","fs","exists","Error","isMetered","size","stat","toReadableSizeString","timer","Timer","start","createReadStream","getDuration","asSeconds","toFixed","downloadFile","remoteUrl","dstPath","downloadOptions","responseType","responseLength","writer","createWriteStream","responseStream","responseHeaders","pipe","once","e","unpipe","message","rimraf","secondsElapsed","bytesPerSec","Math","floor"],"sources":["../../lib/net.js"],"sourcesContent":["import _ from 'lodash';\nimport fs from './fs';\nimport B from 'bluebird';\nimport {toReadableSizeString} from './util';\nimport log from './logger';\nimport Ftp from 'jsftp';\nimport Timer from './timing';\nimport axios from 'axios';\nimport FormData from 'form-data';\n\nconst DEFAULT_TIMEOUT_MS = 4 * 60 * 1000;\n\n/**\n * Converts {@linkcode AuthCredentials} to credentials understood by {@linkcode axios}.\n * @param {AuthCredentials | import('axios').AxiosBasicCredentials} [auth]\n * @returns {import('axios').AxiosBasicCredentials?}\n */\nfunction toAxiosAuth(auth) {\n  if (!_.isPlainObject(auth)) {\n    return null;\n  }\n\n  const axiosAuth = {\n    username: _.get(auth, 'username', _.get(auth, 'user')),\n    password: _.get(auth, 'password', _.get(auth, 'pass')),\n  };\n  return axiosAuth.username && axiosAuth.password ? axiosAuth : null;\n}\n\n/**\n * @param {NodeJS.ReadableStream} localFileStream\n * @param {URL} parsedUri\n * @param {HttpUploadOptions & NetOptions} [uploadOptions]\n */\nasync function uploadFileToHttp(\n  localFileStream,\n  parsedUri,\n  uploadOptions = /** @type {HttpUploadOptions & NetOptions} */ ({})\n) {\n  const {\n    method = 'POST',\n    timeout = DEFAULT_TIMEOUT_MS,\n    headers,\n    auth,\n    fileFieldName = 'file',\n    formFields,\n  } = uploadOptions;\n  const {href} = parsedUri;\n\n  /** @type {import('axios').AxiosRequestConfig} */\n  const requestOpts = {\n    url: href,\n    method,\n    timeout,\n    maxContentLength: Infinity,\n    maxBodyLength: Infinity,\n  };\n  const axiosAuth = toAxiosAuth(auth);\n  if (axiosAuth) {\n    requestOpts.auth = axiosAuth;\n  }\n  if (fileFieldName) {\n    const form = new FormData();\n    form.append(fileFieldName, localFileStream);\n    if (formFields) {\n      let pairs = [];\n      if (_.isArray(formFields)) {\n        pairs = formFields;\n      } else if (_.isPlainObject(formFields)) {\n        pairs = _.toPairs(formFields);\n      }\n      for (const [key, value] of pairs) {\n        if (_.toLower(key) !== _.toLower(fileFieldName)) {\n          form.append(key, value);\n        }\n      }\n    }\n    requestOpts.headers = {\n      ...(_.isPlainObject(headers) ? headers : {}),\n      ...form.getHeaders(),\n    };\n    requestOpts.data = form;\n  } else {\n    if (_.isPlainObject(headers)) {\n      requestOpts.headers = headers;\n    }\n    requestOpts.data = localFileStream;\n  }\n  log.debug(\n    `Performing ${method} to ${href} with options (excluding data): ` +\n      JSON.stringify(_.omit(requestOpts, ['data']))\n  );\n\n  const {status, statusText} = await axios(requestOpts);\n  log.info(`Server response: ${status} ${statusText}`);\n}\n\n/**\n * @param {string | Buffer | NodeJS.ReadableStream} localFileStream\n * @param {URL} parsedUri\n * @param {NotHttpUploadOptions & NetOptions} [uploadOptions]\n */\nasync function uploadFileToFtp(\n  localFileStream,\n  parsedUri,\n  uploadOptions = /** @type {NotHttpUploadOptions & NetOptions} */ ({})\n) {\n  const {auth} = uploadOptions;\n  const {hostname, port, protocol, pathname} = parsedUri;\n\n  const ftpOpts = {\n    host: hostname,\n    port: !_.isUndefined(port) ? _.parseInt(port) : 21,\n  };\n  if (auth?.user && auth?.pass) {\n    ftpOpts.user = auth.user;\n    ftpOpts.pass = auth.pass;\n  }\n  log.debug(`${protocol} upload options: ${JSON.stringify(ftpOpts)}`);\n  return await new B((resolve, reject) => {\n    new Ftp(ftpOpts).put(localFileStream, pathname, (err) => {\n      if (err) {\n        reject(err);\n      } else {\n        resolve();\n      }\n    });\n  });\n}\n\n/**\n * Returns `true` if params are valid for {@linkcode uploadFileToHttp}.\n * @param {any} opts\n * @param {URL} url\n * @returns {opts is HttpUploadOptions & NetOptions}\n */\nfunction isHttpUploadOptions(opts, url) {\n  try {\n    const {protocol} = new URL(url);\n    return protocol === 'http:' || protocol === 'https:';\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Returns `true` if params are valid for {@linkcode uploadFileToFtp}.\n * @param {any} opts\n * @param {URL} url\n * @returns {opts is NotHttpUploadOptions & NetOptions}\n */\nfunction isNotHttpUploadOptions(opts, url) {\n  try {\n    const {protocol} = new URL(url);\n    return protocol === 'ftp:';\n  } catch {\n    return false;\n  }\n}\n/**\n * Uploads the given file to a remote location. HTTP(S) and FTP\n * protocols are supported.\n *\n * @param {string} localPath - The path to a file on the local storage.\n * @param {string} remoteUri - The remote URI to upload the file to.\n * @param {(HttpUploadOptions|NotHttpUploadOptions) & NetOptions} [uploadOptions]\n * @returns {Promise<void>}\n */\nasync function uploadFile(\n  localPath,\n  remoteUri,\n  uploadOptions = /** @type {(HttpUploadOptions|NotHttpUploadOptions) & NetOptions} */ ({})\n) {\n  if (!(await fs.exists(localPath))) {\n    throw new Error(`'${localPath}' does not exists or is not accessible`);\n  }\n\n  const {isMetered = true} = uploadOptions;\n  const url = new URL(remoteUri);\n  const {size} = await fs.stat(localPath);\n  if (isMetered) {\n    log.info(`Uploading '${localPath}' of ${toReadableSizeString(size)} size to '${remoteUri}'`);\n  }\n  const timer = new Timer().start();\n  if (isHttpUploadOptions(uploadOptions, url)) {\n    if (!uploadOptions.fileFieldName) {\n      uploadOptions.headers = {\n        ...(_.isPlainObject(uploadOptions.headers) ? uploadOptions.headers : {}),\n        'Content-Length': size,\n      };\n    }\n    await uploadFileToHttp(fs.createReadStream(localPath), url, uploadOptions);\n  } else if (isNotHttpUploadOptions(uploadOptions, url)) {\n    await uploadFileToFtp(fs.createReadStream(localPath), url, uploadOptions);\n  } else {\n    throw new Error(\n      `Cannot upload the file at '${localPath}' to '${remoteUri}'. ` +\n        `Unsupported remote protocol '${url.protocol}'. ` +\n        `Only http/https and ftp/ftps protocols are supported.`\n    );\n  }\n  if (isMetered) {\n    log.info(\n      `Uploaded '${localPath}' of ${toReadableSizeString(size)} size in ` +\n        `${timer.getDuration().asSeconds.toFixed(3)}s`\n    );\n  }\n}\n\n/**\n * Downloads the given file via HTTP(S)\n *\n * @param {string} remoteUrl - The remote url\n * @param {string} dstPath - The local path to download the file to\n * @param {DownloadOptions & NetOptions} [downloadOptions]\n * @throws {Error} If download operation fails\n */\nasync function downloadFile(\n  remoteUrl,\n  dstPath,\n  downloadOptions = /** @type {DownloadOptions & NetOptions} */ ({})\n) {\n  const {isMetered = true, auth, timeout = DEFAULT_TIMEOUT_MS, headers} = downloadOptions;\n\n  /**\n   * @type {import('axios').AxiosRequestConfig}\n   */\n  const requestOpts = {\n    url: remoteUrl,\n    responseType: 'stream',\n    timeout,\n  };\n  const axiosAuth = toAxiosAuth(auth);\n  if (axiosAuth) {\n    requestOpts.auth = axiosAuth;\n  }\n  if (_.isPlainObject(headers)) {\n    requestOpts.headers = headers;\n  }\n\n  const timer = new Timer().start();\n  let responseLength;\n  try {\n    const writer = fs.createWriteStream(dstPath);\n    const {data: responseStream, headers: responseHeaders} = await axios(requestOpts);\n    responseLength = parseInt(responseHeaders['content-length'], 10);\n    responseStream.pipe(writer);\n\n    await new B((resolve, reject) => {\n      responseStream.once('error', reject);\n      writer.once('finish', resolve);\n      writer.once('error', (e) => {\n        responseStream.unpipe(writer);\n        reject(e);\n      });\n    });\n  } catch (err) {\n    throw new Error(`Cannot download the file from ${remoteUrl}: ${err.message}`);\n  }\n\n  const {size} = await fs.stat(dstPath);\n  if (responseLength && size !== responseLength) {\n    await fs.rimraf(dstPath);\n    throw new Error(\n      `The size of the file downloaded from ${remoteUrl} (${size} bytes) ` +\n        `differs from the one in Content-Length response header (${responseLength} bytes)`\n    );\n  }\n  if (isMetered) {\n    const secondsElapsed = timer.getDuration().asSeconds;\n    log.debug(\n      `${remoteUrl} (${toReadableSizeString(size)}) ` +\n        `has been downloaded to '${dstPath}' in ${secondsElapsed.toFixed(3)}s`\n    );\n    if (secondsElapsed >= 2) {\n      const bytesPerSec = Math.floor(size / secondsElapsed);\n      log.debug(`Approximate download speed: ${toReadableSizeString(bytesPerSec)}/s`);\n    }\n  }\n}\n\nexport {uploadFile, downloadFile};\n\n/**\n * Common options for {@linkcode uploadFile} and {@linkcode downloadFile}.\n * @typedef NetOptions\n * @property {boolean} [isMetered=true] - Whether to log the actual download performance\n * (e.g. timings and speed)\n * @property {AuthCredentials} [auth] - Authentication credentials\n */\n\n/**\n * Specific options for {@linkcode downloadFile}.\n * @typedef DownloadOptions\n * @property {number} [timeout] - The actual request timeout in milliseconds; defaults to {@linkcode DEFAULT_TIMEOUT_MS}\n * @property {Record<string,any>} [headers] - Request headers mapping\n */\n\n/**\n * Basic auth credentials; used by {@linkcode NetOptions}.\n * @typedef AuthCredentials\n * @property {string} user - Non-empty user name\n * @property {string} pass - Non-empty password\n */\n\n/**\n * This type is used in {@linkcode uploadFile} if the remote location uses the `ftp` protocol, and distinguishes the type from {@linkcode HttpUploadOptions}.\n * @typedef NotHttpUploadOptions\n * @property {never} headers\n * @property {never} method\n * @property {never} timeout\n * @property {never} fileFieldName\n * @property {never} formFields\n */\n\n/**\n * Specific options for {@linkcode uploadFile} if the remote location uses the `http(s)` protocol\n * @typedef HttpUploadOptions\n * @property {Record<string,any>} headers - Additional request headers mapping\n * @property {import('axios').Method} [method='POST'] - The HTTP method used for file upload\n * @property {number} [timeout] - The actual request timeout in milliseconds; defaults to {@linkcode DEFAULT_TIMEOUT_MS}\n * @property {string} [fileFieldName='file'] - The name of the form field containing the file\n * content to be uploaded. Any falsy value make the request to use non-multipart upload\n * @property {Record<string,any>} [formFields] - The additional form fields\n * to be included into the upload request. This property is only considered if\n * `fileFieldName` is set\n */\n"],"mappings":"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"}
+exports.downloadFile = downloadFile;
+/**
+ * Common options for {@linkcode uploadFile} and {@linkcode downloadFile}.
+ * @typedef NetOptions
+ * @property {boolean} [isMetered=true] - Whether to log the actual download performance
+ * (e.g. timings and speed)
+ * @property {AuthCredentials} [auth] - Authentication credentials
+ */
+/**
+ * Specific options for {@linkcode downloadFile}.
+ * @typedef DownloadOptions
+ * @property {number} [timeout] - The actual request timeout in milliseconds; defaults to {@linkcode DEFAULT_TIMEOUT_MS}
+ * @property {Record<string,any>} [headers] - Request headers mapping
+ */
+/**
+ * Basic auth credentials; used by {@linkcode NetOptions}.
+ * @typedef AuthCredentials
+ * @property {string} user - Non-empty user name
+ * @property {string} pass - Non-empty password
+ */
+/**
+ * This type is used in {@linkcode uploadFile} if the remote location uses the `ftp` protocol, and distinguishes the type from {@linkcode HttpUploadOptions}.
+ * @typedef NotHttpUploadOptions
+ * @property {never} headers
+ * @property {never} method
+ * @property {never} timeout
+ * @property {never} fileFieldName
+ * @property {never} formFields
+ */
+/**
+ * Specific options for {@linkcode uploadFile} if the remote location uses the `http(s)` protocol
+ * @typedef HttpUploadOptions
+ * @property {Record<string,any>} headers - Additional request headers mapping
+ * @property {import('axios').Method} [method='POST'] - The HTTP method used for file upload
+ * @property {number} [timeout] - The actual request timeout in milliseconds; defaults to {@linkcode DEFAULT_TIMEOUT_MS}
+ * @property {string} [fileFieldName='file'] - The name of the form field containing the file
+ * content to be uploaded. Any falsy value make the request to use non-multipart upload
+ * @property {Record<string,any>} [formFields] - The additional form fields
+ * to be included into the upload request. This property is only considered if
+ * `fileFieldName` is set
+ */
+//# sourceMappingURL=net.js.map