@appium/support 2.56.1 → 2.57.0

package/build/lib/net.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Common options for {@linkcode uploadFile } and {@linkcode downloadFile }.
+ */
+export type NetOptions = {
+    /**
+     * - Whether to log the actual download performance
+     * (e.g. timings and speed)
+     */
+    isMetered?: boolean | undefined;
+    auth: AuthCredentials;
+};
+/**
+ * Specific options for {@linkcode downloadFile }.
+ */
+export type DownloadOptions = {
+    /**
+     * - The actual request timeout in milliseconds; defaults to {@linkcode DEFAULT_TIMEOUT_MS }
+     */
+    timeout?: number | undefined;
+    /**
+     * - Request headers mapping
+     */
+    headers: Record<string, any>;
+};
+/**
+ * Basic auth credentials; used by {@linkcode NetOptions }.
+ */
+export type AuthCredentials = {
+    /**
+     * - Non-empty user name
+     */
+    user: string;
+    /**
+     * - Non-empty password
+     */
+    pass: string;
+};
+/**
+ * This type is used in {@linkcode uploadFile } if the remote location uses the `ftp` protocol, and distinguishes the type from {@linkcode HttpUploadOptions }.
+ */
+export type NotHttpUploadOptions = {
+    headers: never;
+    method: never;
+    timeout: never;
+    fileFieldName: never;
+    formFields: never;
+};
+/**
+ * Specific options for {@linkcode uploadFile } if the remote location uses the `http(s)` protocol
+ */
+export type HttpUploadOptions = {
+    /**
+     * - Additional request headers mapping
+     */
+    headers: Record<string, any>;
+    /**
+     * - The HTTP method used for file upload
+     */
+    method?: import("axios").Method | undefined;
+    /**
+     * - The actual request timeout in milliseconds; defaults to {@linkcode DEFAULT_TIMEOUT_MS }
+     */
+    timeout?: number | undefined;
+    /**
+     * - The name of the form field containing the file
+     * content to be uploaded. Any falsy value make the request to use non-multipart upload
+     */
+    fileFieldName?: string | undefined;
+    /**
+     * - The additional form fields
+     * to be included into the upload request. This property is only considered if
+     * `fileFieldName` is set
+     */
+    formFields?: Record<string, any> | undefined;
+};
+/**
+ * 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>}
+ */
+export function uploadFile(localPath: string, remoteUri: string, uploadOptions?: ((HttpUploadOptions | NotHttpUploadOptions) & NetOptions) | undefined): Promise<void>;
+/**
+ * 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
+ */
+export function downloadFile(remoteUrl: string, dstPath: string, downloadOptions?: (DownloadOptions & NetOptions) | undefined): Promise<void>;
+//# sourceMappingURL=net.d.ts.map

package/build/lib/net.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"net.d.ts","sourceRoot":"","sources":["../../lib/net.js"],"names":[],"mappings":";;;;;;;;;UAuRc,eAAe;;;;;;;;;;;;;aAOf,OAAO,MAAM,EAAC,GAAG,CAAC;;;;;;;;;UAMlB,MAAM;;;;UACN,MAAM;;;;;;aAMN,KAAK;YACL,KAAK;aACL,KAAK;mBACL,KAAK;gBACL,KAAK;;;;;;;;;aAML,OAAO,MAAM,EAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;AAzJhC;;;;;;;;GAQG;AACH,sCALW,MAAM,aACN,MAAM,0FAEJ,QAAQ,IAAI,CAAC,CAmCzB;AAED;;;;;;;GAOG;AACH,wCALW,MAAM,WACN,MAAM,+EAkEhB"}

package/build/lib/net.js

@@ -14,8 +14,6 @@ var _lodash = _interopRequireDefault(require("lodash"));
 
 var _fs = _interopRequireDefault(require("./fs"));
 
-var _url = _interopRequireDefault(require("url"));
-
 var _bluebird = _interopRequireDefault(require("bluebird"));
 
 var _util = require("./util");
@@ -38,8 +36,8 @@ function toAxiosAuth(auth) {
   }
 
   const axiosAuth = {
-    username: auth.username || auth.user,
-    password: auth.password || auth.pass
+    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;
 }
@@ -89,7 +87,9 @@ async function uploadFileToHttp(localFileStream, parsedUri, uploadOptions = {})
       }
     }
 
-    requestOpts.headers = Object.assign({}, _lodash.default.isPlainObject(headers) ? headers : {}, form.getHeaders());
+    requestOpts.headers = { ...(_lodash.default.isPlainObject(headers) ? headers : {}),
+      ...form.getHeaders()
+    };
     requestOpts.data = form;
   } else {
     if (_lodash.default.isPlainObject(headers)) {
@@ -111,9 +111,7 @@ async function uploadFileToHttp(localFileStream, parsedUri, uploadOptions = {})
 
 async function uploadFileToFtp(localFileStream, parsedUri, uploadOptions = {}) {
   const {
-    auth,
-    user,
-    pass
+    auth
   } = uploadOptions;
   const {
     hostname,
@@ -123,12 +121,12 @@ async function uploadFileToFtp(localFileStream, parsedUri, uploadOptions = {}) {
   } = parsedUri;
   const ftpOpts = {
     host: hostname,
-    port: port || 21
+    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 || user && pass) {
-    ftpOpts.user = (auth === null || auth === void 0 ? void 0 : auth.user) || user;
-    ftpOpts.pass = (auth === null || auth === void 0 ? void 0 : auth.pass) || pass;
+  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)}`);
@@ -144,6 +142,28 @@ async function uploadFileToFtp(localFileStream, parsedUri, uploadOptions = {}) {
   });
 }
 
+function isHttpUploadOptions(opts, url) {
+  try {
+    const {
+      protocol
+    } = new URL(url);
+    return protocol === 'http:' || protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+
+function isNotHttpUploadOptions(opts, url) {
+  try {
+    const {
+      protocol
+    } = new URL(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`);
@@ -152,9 +172,7 @@ async function uploadFile(localPath, remoteUri, uploadOptions = {}) {
   const {
     isMetered = true
   } = uploadOptions;
-
-  const parsedUri = _url.default.parse(remoteUri);
-
+  const url = new URL(remoteUri);
   const {
     size
   } = await _fs.default.stat(localPath);
@@ -165,18 +183,18 @@ async function uploadFile(localPath, remoteUri, uploadOptions = {}) {
 
   const timer = new _timing.default().start();
 
-  if (['http:', 'https:'].includes(parsedUri.protocol)) {
+  if (isHttpUploadOptions(uploadOptions, url)) {
     if (!uploadOptions.fileFieldName) {
-      uploadOptions.headers = Object.assign({}, _lodash.default.isPlainObject(uploadOptions.headers) ? uploadOptions.headers : {}, {
+      uploadOptions.headers = { ...(_lodash.default.isPlainObject(uploadOptions.headers) ? uploadOptions.headers : {}),
         'Content-Length': size
-      });
+      };
     }
 
-    await uploadFileToHttp(_fs.default.createReadStream(localPath), parsedUri, uploadOptions);
-  } else if (parsedUri.protocol === 'ftp:') {
-    await uploadFileToFtp(_fs.default.createReadStream(localPath), parsedUri, uploadOptions);
+    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 '${parsedUri.protocol}'. ` + `Only http/https and ftp/ftps protocols are supported.`);
+    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) {
@@ -251,4 +269,4 @@ async function downloadFile(remoteUrl, dstPath, downloadOptions = {}) {
     }
   }
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/net.js"],"names":["DEFAULT_TIMEOUT_MS","toAxiosAuth","auth","_","isPlainObject","axiosAuth","username","user","password","pass","uploadFileToHttp","localFileStream","parsedUri","uploadOptions","method","timeout","headers","fileFieldName","formFields","href","requestOpts","url","maxContentLength","Infinity","maxBodyLength","form","FormData","append","pairs","isArray","toPairs","key","value","toLower","Object","assign","getHeaders","data","log","debug","JSON","stringify","omit","status","statusText","info","uploadFileToFtp","hostname","port","protocol","pathname","ftpOpts","host","B","resolve","reject","Ftp","put","err","uploadFile","localPath","remoteUri","fs","exists","Error","isMetered","parse","size","stat","timer","Timer","start","includes","createReadStream","getDuration","asSeconds","toFixed","downloadFile","remoteUrl","dstPath","downloadOptions","responseType","responseLength","writer","createWriteStream","responseStream","responseHeaders","parseInt","pipe","once","e","unpipe","message","rimraf","secondsElapsed","bytesPerSec","Math","floor"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport fs from './fs';\nimport url from 'url';\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\nfunction toAxiosAuth (auth) {\n  if (!_.isPlainObject(auth)) {\n    return null;\n  }\n\n  const axiosAuth = {\n    username: auth.username || auth.user,\n    password: auth.password || auth.pass,\n  };\n  return (axiosAuth.username && axiosAuth.password) ? axiosAuth : null;\n}\n\nasync function uploadFileToHttp (localFileStream, parsedUri, uploadOptions = {}) {\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  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 = Object.assign({}, _.isPlainObject(headers) ? headers : {},\n      form.getHeaders());\n    requestOpts.data = form;\n  } else {\n    if (_.isPlainObject(headers)) {\n      requestOpts.headers = headers;\n    }\n    requestOpts.data = localFileStream;\n  }\n  log.debug(`Performing ${method} to ${href} with options (excluding data): ` +\n    JSON.stringify(_.omit(requestOpts, ['data'])));\n\n  const {status, statusText} = await axios(requestOpts);\n  log.info(`Server response: ${status} ${statusText}`);\n}\n\nasync function uploadFileToFtp (localFileStream, parsedUri, uploadOptions = {}) {\n  const {\n    auth,\n    user,\n    pass,\n  } = uploadOptions;\n  const {\n    hostname,\n    port,\n    protocol,\n    pathname,\n  } = parsedUri;\n\n  const ftpOpts = {\n    host: hostname,\n    port: port || 21,\n  };\n  if ((auth?.user && auth?.pass) || (user && pass)) {\n    ftpOpts.user = auth?.user || user;\n    ftpOpts.pass = auth?.pass || 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 * @typedef AuthCredentials\n * @property {string} user - Non-empty user name\n * @property {string} pass - Non-empty password\n */\n\n/**\n * @typedef FtpUploadOptions\n * @property {boolean} isMetered [true] - Whether to log the actual upload performance\n * (e.g. timings and speed)\n * @property {AuthCredentials} auth\n */\n\n/**\n * @typedef HttpUploadOptions\n * @property {boolean} isMetered [true] - Whether to log the actual upload performance\n * (e.g. timings and speed)\n * @property {string} method [POST] - The HTTP method used for file upload\n * @property {AuthCredentials} auth\n * @property {number} timeout [240000] - The actual request timeout in milliseconds\n * @property {Object} headers - Additional request headers mapping\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 {Array<Pair>|Object} 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\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 {?FtpUploadOptions|HttpUploadOptions} uploadOptions\n */\nasync function uploadFile (localPath, remoteUri, uploadOptions = {}) {\n  if (!await fs.exists(localPath)) {\n    throw new Error (`'${localPath}' does not exists or is not accessible`);\n  }\n\n  const {\n    isMetered = true,\n  } = uploadOptions;\n\n  const parsedUri = url.parse(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 (['http:', 'https:'].includes(parsedUri.protocol)) {\n    if (!uploadOptions.fileFieldName) {\n      uploadOptions.headers = Object.assign({},\n        _.isPlainObject(uploadOptions.headers) ? uploadOptions.headers : {},\n        {'Content-Length': size}\n      );\n    }\n    await uploadFileToHttp(fs.createReadStream(localPath), parsedUri, uploadOptions);\n  } else if (parsedUri.protocol === 'ftp:') {\n    await uploadFileToFtp(fs.createReadStream(localPath), parsedUri, uploadOptions);\n  } else {\n    throw new Error(`Cannot upload the file at '${localPath}' to '${remoteUri}'. ` +\n      `Unsupported remote protocol '${parsedUri.protocol}'. ` +\n      `Only http/https and ftp/ftps protocols are supported.`);\n  }\n  if (isMetered) {\n    log.info(`Uploaded '${localPath}' of ${toReadableSizeString(size)} size in ` +\n      `${timer.getDuration().asSeconds.toFixed(3)}s`);\n  }\n}\n\n/**\n * @typedef DownloadOptions\n * @property {boolean} isMetered [true] - Whether to log the actual download performance\n * (e.g. timings and speed)\n * @property {AuthCredentials} auth\n * @property {number} timeout [240000] - The actual request timeout in milliseconds\n * @property {Object} headers - Request headers mapping\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} downloadOptions\n * @throws {Error} If download operation fails\n */\nasync function downloadFile (remoteUrl, dstPath, downloadOptions = {}) {\n  const {\n    isMetered = true,\n    auth,\n    timeout = DEFAULT_TIMEOUT_MS,\n    headers,\n  } = downloadOptions;\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 {\n      data: responseStream,\n      headers: responseHeaders,\n    } = 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(`The size of the file downloaded from ${remoteUrl} (${size} bytes) ` +\n      `differs from the one in Content-Length response header (${responseLength} bytes)`);\n  }\n  if (isMetered) {\n    const secondsElapsed = timer.getDuration().asSeconds;\n    log.debug(`${remoteUrl} (${toReadableSizeString(size)}) ` +\n      `has been downloaded to '${dstPath}' in ${secondsElapsed.toFixed(3)}s`);\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"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/net.js"],"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","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","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"],"mappings":"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","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 (localFileStream, parsedUri, uploadOptions = /** @type {HttpUploadOptions & NetOptions} */({})) {\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(`Performing ${method} to ${href} with options (excluding data): ` +\n    JSON.stringify(_.omit(requestOpts, ['data'])));\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 (localFileStream, parsedUri, uploadOptions = /** @type {NotHttpUploadOptions & NetOptions} */({})) {\n  const {\n    auth,\n  } = uploadOptions;\n  const {\n    hostname,\n    port,\n    protocol,\n    pathname,\n  } = 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 (localPath, remoteUri, uploadOptions = /** @type {(HttpUploadOptions|NotHttpUploadOptions) & NetOptions} */({})) {\n  if (!await fs.exists(localPath)) {\n    throw new Error (`'${localPath}' does not exists or is not accessible`);\n  }\n\n  const {\n    isMetered = true,\n  } = 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(`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  if (isMetered) {\n    log.info(`Uploaded '${localPath}' of ${toReadableSizeString(size)} size in ` +\n      `${timer.getDuration().asSeconds.toFixed(3)}s`);\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 (remoteUrl, dstPath, downloadOptions = /** @type {DownloadOptions & NetOptions} */({})) {\n  const {\n    isMetered = true,\n    auth,\n    timeout = DEFAULT_TIMEOUT_MS,\n    headers,\n  } = 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 {\n      data: responseStream,\n      headers: responseHeaders,\n    } = 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(`The size of the file downloaded from ${remoteUrl} (${size} bytes) ` +\n      `differs from the one in Content-Length response header (${responseLength} bytes)`);\n  }\n  if (isMetered) {\n    const secondsElapsed = timer.getDuration().asSeconds;\n    log.debug(`${remoteUrl} (${toReadableSizeString(size)}) ` +\n      `has been downloaded to '${dstPath}' in ${secondsElapsed.toFixed(3)}s`);\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\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\n"]}

package/build/lib/node.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Utility function to extend node functionality, allowing us to require
+ * modules that are installed globally. If the package cannot be required,
+ * this will attempt to link the package and then re-require it
+ *
+ * @param {string} packageName - the name of the package to be required
+ * @returns {Promise<unknown>} - the package object
+ * @throws {Error} If the package is not found locally or globally
+ */
+export function requirePackage(packageName: string): Promise<unknown>;
+/**
+ * Calculate the in-depth size in memory of the provided object.
+ * The original implementation is borrowed from https://github.com/miktam/sizeof.
+ *
+ * @param {*} obj An object whose size should be calculated
+ * @returns {number} Object size in bytes.
+ */
+export function getObjectSize(obj: any): number;
+/**
+ * Calculates a unique object identifier
+ *
+ * @param {object} object Any valid ECMA object
+ * @returns {string} A uuidV4 string that uniquely identifies given object
+ */
+export function getObjectId(object: object): string;
+//# sourceMappingURL=node.d.ts.map

package/build/lib/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../lib/node.js"],"names":[],"mappings":"AAoCA;;;;;;;;GAQG;AACH,4CAJW,MAAM,GACJ,QAAQ,OAAO,CAAC,CA6B5B;AAuED;;;;;;GAMG;AACH,yCAFa,MAAM,CAIlB;AAID;;;;;GAKG;AACH,oCAHW,MAAM,GACJ,MAAM,CAOlB"}

package/build/lib/node.js

@@ -60,7 +60,9 @@ async function requirePackage(packageName) {
   }
 
   try {
-    const globalPackageName = _path.default.resolve(process.env.npm_config_prefix, 'lib', 'node_modules', packageName);
+    var _process$env$npm_conf;
+
+    const globalPackageName = _path.default.resolve((_process$env$npm_conf = process.env.npm_config_prefix) !== null && _process$env$npm_conf !== void 0 ? _process$env$npm_conf : '', 'lib', 'node_modules', packageName);
 
     _logger.default.debug(`Loading global package '${globalPackageName}'`);
 
@@ -166,4 +168,4 @@ function getObjectId(object) {
 
   return OBJECTS_MAPPING.get(object);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/node.js"],"names":["ECMA_SIZES","Object","freeze","STRING","BOOLEAN","NUMBER","linkGlobalPackage","packageName","log","debug","cmd","timeout","err","msg","message","stderr","Error","requirePackage","require","globalPackageName","path","resolve","process","env","npm_config_prefix","errorAndThrow","extractAllProperties","obj","stringProperties","prop","push","_","isFunction","getOwnPropertySymbols","_getSizeOfObject","seen","object","isNil","bytes","properties","key","has","add","getCalculator","ex","RangeError","calculator","isBuffer","length","Symbol","keyFor","toString","isArray","map","reduce","acc","curr","getObjectSize","WeakSet","OBJECTS_MAPPING","WeakMap","getObjectId","set","get"],"mappings":"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","sourcesContent":["import { isWindows } from './system';\nimport log from './logger';\nimport _ from 'lodash';\nimport { exec } from 'teen_process';\nimport path from 'path';\nimport { v4 as uuidV4 } from 'uuid';\n\nconst ECMA_SIZES = Object.freeze({\n  STRING: 2,\n  BOOLEAN: 4,\n  NUMBER: 8,\n});\n\n/**\n * Internal utility to link global package to local context\n *\n * @returns {string} - name of the package to link\n * @throws {Error} If the command fails\n */\nasync function linkGlobalPackage (packageName) {\n  try {\n    log.debug(`Linking package '${packageName}'`);\n    const cmd = isWindows() ? 'npm.cmd' : 'npm';\n    await exec(cmd, ['link', packageName], {timeout: 20000});\n  } catch (err) {\n    const msg = `Unable to load package '${packageName}', linking failed: ${err.message}`;\n    log.debug(msg);\n    if (err.stderr) {\n      // log the stderr if there, but do not add to thrown error as it is\n      // _very_ verbose\n      log.debug(err.stderr);\n    }\n    throw new Error(msg);\n  }\n}\n\n/**\n * Utility function to extend node functionality, allowing us to require\n * modules that are installed globally. If the package cannot be required,\n * this will attempt to link the package and then re-require it\n *\n * @param {string} packageName - the name of the package to be required\n * @returns {object} - the package object\n * @throws {Error} If the package is not found locally or globally\n */\nasync function requirePackage (packageName) {\n  // first, get it in the normal way (see https://nodejs.org/api/modules.html#modules_all_together)\n  try {\n    log.debug(`Loading local package '${packageName}'`);\n    return require(packageName);\n  } catch (err) {\n    log.debug(`Failed to load local package '${packageName}': ${err.message}`);\n  }\n\n  // second, get it from where it ought to be in the global node_modules\n  try {\n    const globalPackageName = path.resolve(process.env.npm_config_prefix, 'lib', 'node_modules', packageName);\n    log.debug(`Loading global package '${globalPackageName}'`);\n    return require(globalPackageName);\n  } catch (err) {\n    log.debug(`Failed to load global package '${packageName}': ${err.message}`);\n  }\n\n  // third, link the file and get locally\n  try {\n    await linkGlobalPackage(packageName);\n    log.debug(`Retrying load of linked package '${packageName}'`);\n    return require(packageName);\n  } catch (err) {\n    log.errorAndThrow(`Unable to load package '${packageName}': ${err.message}`);\n  }\n}\n\nfunction extractAllProperties (obj) {\n  const stringProperties = [];\n  for (const prop in obj) {\n    stringProperties.push(prop);\n  }\n  if (_.isFunction(Object.getOwnPropertySymbols)) {\n    stringProperties.push(...(Object.getOwnPropertySymbols(obj)));\n  }\n  return stringProperties;\n}\n\nfunction _getSizeOfObject (seen, object) {\n  if (_.isNil(object)) {\n    return 0;\n  }\n\n  let bytes = 0;\n  const properties = extractAllProperties(object);\n  for (const key of properties) {\n    // Do not recalculate circular references\n    if (typeof object[key] === 'object' && !_.isNil(object[key])) {\n      if (seen.has(object[key])) {\n        continue;\n      }\n      seen.add(object[key]);\n    }\n\n    bytes += getCalculator(seen)(key);\n    try {\n      bytes += getCalculator(seen)(object[key]);\n    } catch (ex) {\n      if (ex instanceof RangeError) {\n        // circular reference detected, final result might be incorrect\n        // let's be nice and not throw an exception\n        bytes = 0;\n      }\n    }\n  }\n\n  return bytes;\n}\n\nfunction getCalculator (seen) {\n  return function calculator (obj) {\n    if (_.isBuffer(obj)) {\n      return obj.length;\n    }\n\n    switch (typeof (obj)) {\n      case 'string':\n        return obj.length * ECMA_SIZES.STRING;\n      case 'boolean':\n        return ECMA_SIZES.BOOLEAN;\n      case 'number':\n        return ECMA_SIZES.NUMBER;\n      case 'symbol':\n        return _.isFunction(Symbol.keyFor) && Symbol.keyFor(obj)\n          ? Symbol.keyFor(obj).length * ECMA_SIZES.STRING\n          : (obj.toString().length - 8) * ECMA_SIZES.STRING;\n      case 'object':\n        return _.isArray(obj)\n          ? obj.map(getCalculator(seen)).reduce((acc, curr) => acc + curr, 0)\n          : _getSizeOfObject(seen, obj);\n      default:\n        return 0;\n    }\n  };\n}\n\n/**\n * Calculate the in-depth size in memory of the provided object.\n * The original implementation is borrowed from https://github.com/miktam/sizeof.\n *\n * @param {*} obj An object whose size should be calculated\n * @returns {number} Object size in bytes.\n */\nfunction getObjectSize (obj) {\n  return getCalculator(new WeakSet())(obj);\n}\n\nconst OBJECTS_MAPPING = new WeakMap();\n\n/**\n * Calculates a unique object identifier\n *\n * @param {object} object Any valid ECMA object\n * @returns {string} A uuidV4 string that uniquely identifies given object\n */\nfunction getObjectId (object) {\n  if (!OBJECTS_MAPPING.has(object)) {\n    OBJECTS_MAPPING.set(object, uuidV4());\n  }\n  return OBJECTS_MAPPING.get(object);\n}\n\nexport { requirePackage, getObjectSize, getObjectId };\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/node.js"],"names":["ECMA_SIZES","Object","freeze","STRING","BOOLEAN","NUMBER","linkGlobalPackage","packageName","log","debug","cmd","timeout","err","msg","message","stderr","Error","requirePackage","require","globalPackageName","path","resolve","process","env","npm_config_prefix","errorAndThrow","extractAllProperties","obj","stringProperties","prop","push","_","isFunction","getOwnPropertySymbols","_getSizeOfObject","seen","object","isNil","bytes","properties","key","has","add","getCalculator","ex","RangeError","calculator","isBuffer","length","Symbol","keyFor","toString","isArray","map","reduce","acc","curr","getObjectSize","WeakSet","OBJECTS_MAPPING","WeakMap","getObjectId","set","get"],"mappings":"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","sourcesContent":["import { isWindows } from './system';\nimport log from './logger';\nimport _ from 'lodash';\nimport { exec } from 'teen_process';\nimport path from 'path';\nimport { v4 as uuidV4 } from 'uuid';\n\nconst ECMA_SIZES = Object.freeze({\n  STRING: 2,\n  BOOLEAN: 4,\n  NUMBER: 8,\n});\n\n/**\n * Internal utility to link global package to local context\n *\n * @param {string} packageName - name of the package to link\n * @throws {Error} If the command fails\n */\nasync function linkGlobalPackage (packageName) {\n  try {\n    log.debug(`Linking package '${packageName}'`);\n    const cmd = isWindows() ? 'npm.cmd' : 'npm';\n    await exec(cmd, ['link', packageName], {timeout: 20000});\n  } catch (err) {\n    const msg = `Unable to load package '${packageName}', linking failed: ${err.message}`;\n    log.debug(msg);\n    if (err.stderr) {\n      // log the stderr if there, but do not add to thrown error as it is\n      // _very_ verbose\n      log.debug(err.stderr);\n    }\n    throw new Error(msg);\n  }\n}\n\n/**\n * Utility function to extend node functionality, allowing us to require\n * modules that are installed globally. If the package cannot be required,\n * this will attempt to link the package and then re-require it\n *\n * @param {string} packageName - the name of the package to be required\n * @returns {Promise<unknown>} - the package object\n * @throws {Error} If the package is not found locally or globally\n */\nasync function requirePackage (packageName) {\n  // first, get it in the normal way (see https://nodejs.org/api/modules.html#modules_all_together)\n  try {\n    log.debug(`Loading local package '${packageName}'`);\n    return require(packageName);\n  } catch (err) {\n    log.debug(`Failed to load local package '${packageName}': ${err.message}`);\n  }\n\n  // second, get it from where it ought to be in the global node_modules\n  try {\n    const globalPackageName = path.resolve(process.env.npm_config_prefix ?? '', 'lib', 'node_modules', packageName);\n    log.debug(`Loading global package '${globalPackageName}'`);\n    return require(globalPackageName);\n  } catch (err) {\n    log.debug(`Failed to load global package '${packageName}': ${err.message}`);\n  }\n\n  // third, link the file and get locally\n  try {\n    await linkGlobalPackage(packageName);\n    log.debug(`Retrying load of linked package '${packageName}'`);\n    return require(packageName);\n  } catch (err) {\n    log.errorAndThrow(`Unable to load package '${packageName}': ${err.message}`);\n  }\n}\n\nfunction extractAllProperties (obj) {\n  const stringProperties = [];\n  for (const prop in obj) {\n    stringProperties.push(prop);\n  }\n  if (_.isFunction(Object.getOwnPropertySymbols)) {\n    stringProperties.push(...(Object.getOwnPropertySymbols(obj)));\n  }\n  return stringProperties;\n}\n\nfunction _getSizeOfObject (seen, object) {\n  if (_.isNil(object)) {\n    return 0;\n  }\n\n  let bytes = 0;\n  const properties = extractAllProperties(object);\n  for (const key of properties) {\n    // Do not recalculate circular references\n    if (typeof object[key] === 'object' && !_.isNil(object[key])) {\n      if (seen.has(object[key])) {\n        continue;\n      }\n      seen.add(object[key]);\n    }\n\n    bytes += getCalculator(seen)(key);\n    try {\n      bytes += getCalculator(seen)(object[key]);\n    } catch (ex) {\n      if (ex instanceof RangeError) {\n        // circular reference detected, final result might be incorrect\n        // let's be nice and not throw an exception\n        bytes = 0;\n      }\n    }\n  }\n\n  return bytes;\n}\n\nfunction getCalculator (seen) {\n  return function calculator (obj) {\n    if (_.isBuffer(obj)) {\n      return obj.length;\n    }\n\n    switch (typeof (obj)) {\n      case 'string':\n        return obj.length * ECMA_SIZES.STRING;\n      case 'boolean':\n        return ECMA_SIZES.BOOLEAN;\n      case 'number':\n        return ECMA_SIZES.NUMBER;\n      case 'symbol':\n        return _.isFunction(Symbol.keyFor) && Symbol.keyFor(obj)\n          ? /** @type {string} */(Symbol.keyFor(obj)).length * ECMA_SIZES.STRING\n          : (obj.toString().length - 8) * ECMA_SIZES.STRING;\n      case 'object':\n        return _.isArray(obj)\n          ? obj.map(getCalculator(seen)).reduce((acc, curr) => acc + curr, 0)\n          : _getSizeOfObject(seen, obj);\n      default:\n        return 0;\n    }\n  };\n}\n\n/**\n * Calculate the in-depth size in memory of the provided object.\n * The original implementation is borrowed from https://github.com/miktam/sizeof.\n *\n * @param {*} obj An object whose size should be calculated\n * @returns {number} Object size in bytes.\n */\nfunction getObjectSize (obj) {\n  return getCalculator(new WeakSet())(obj);\n}\n\nconst OBJECTS_MAPPING = new WeakMap();\n\n/**\n * Calculates a unique object identifier\n *\n * @param {object} object Any valid ECMA object\n * @returns {string} A uuidV4 string that uniquely identifies given object\n */\nfunction getObjectId (object) {\n  if (!OBJECTS_MAPPING.has(object)) {\n    OBJECTS_MAPPING.set(object, uuidV4());\n  }\n  return OBJECTS_MAPPING.get(object);\n}\n\nexport { requirePackage, getObjectSize, getObjectId };\n"]}

package/build/lib/npm.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Relative path to directory containing any Appium internal files
+ * XXX: this is duplicated in `appium/lib/constants.js`.
+ */
+export const CACHE_DIR_RELATIVE_PATH: string;
+/**
+ * Relative path to lockfile used when installing an extension via `appium`
+ */
+export const INSTALL_LOCKFILE_RELATIVE_PATH: string;
+/**
+ * XXX: This should probably be a singleton, but it isn't.  Maybe this module should just export functions?
+ */
+export class NPM {
+    /**
+     * Returns path to "install" lockfile
+     * @private
+     * @param {string} cwd
+     */
+    private _getInstallLockfilePath;
+    /**
+     * Execute `npm` with given args.
+     *
+     * If the process exits with a nonzero code, the contents of `STDOUT` and `STDERR` will be in the
+     * `message` of the {@link TeenProcessExecError} rejected.
+     * @param {string} cmd
+     * @param {string[]} args
+     * @param {ExecOpts} opts
+     * @param {ExecOpts} [execOpts]
+     */
+    exec(cmd: string, args: string[], opts: ExecOpts, execOpts?: ExecOpts | undefined): Promise<import("teen_process").ExecResult<string> & {
+        json?: any;
+    }>;
+    /**
+     * @param {string} cwd
+     * @param {string} pkg
+     */
+    getLatestVersion(cwd: string, pkg: string): Promise<any>;
+    /**
+     * @param {string} cwd
+     * @param {string} pkg
+     * @param {string} curVersion
+     */
+    getLatestSafeUpgradeVersion(cwd: string, pkg: string, curVersion: string): Promise<string | null>;
+    /**
+     * Runs `npm ls`, optionally for a particular package.
+     * @param {string} cwd
+     * @param {string} [pkg]
+     */
+    list(cwd: string, pkg?: string | undefined): Promise<any>;
+    /**
+     * Given a current version and a list of all versions for a package, return the version which is
+     * the highest safely-upgradable version (meaning not crossing any major revision boundaries, and
+     * not including any alpha/beta/rc versions)
+     *
+     * @param {string} curVersion - the current version of a package
+     * @param {Array<string>} allVersions - a list of version strings
+     *
+     * @return {string|null} - the highest safely-upgradable version, or null if there isn't one
+     */
+    getLatestSafeUpgradeFromVersions(curVersion: string, allVersions: Array<string>): string | null;
+    /**
+     * Installs a package w/ `npm`
+     * @param {string} cwd
+     * @param {string} pkgName
+     * @param {InstallPackageOpts} [opts]
+     * @returns {Promise<import('type-fest').PackageJson>}
+     */
+    installPackage(cwd: string, pkgName: string, { pkgVer }?: InstallPackageOpts | undefined): Promise<import('type-fest').PackageJson>;
+    /**
+     * @param {string} cwd
+     * @param {string} pkg
+     */
+    uninstallPackage(cwd: string, pkg: string): Promise<void>;
+}
+export const npm: NPM;
+/**
+ * Options for {@link NPM.installPackage }
+ */
+export type InstallPackageOpts = {
+    /**
+     * - the version of the package to install
+     */
+    pkgVer?: string | undefined;
+};
+/**
+ * Options for {@link NPM.exec }
+ */
+export type ExecOpts = {
+    /**
+     * - Current working directory
+     */
+    cwd: string;
+    /**
+     * - If `true`, supply `--json` flag to npm and resolve w/ parsed JSON
+     */
+    json?: boolean | undefined;
+    /**
+     * - Path to lockfile to use
+     */
+    lockFile?: string | undefined;
+};
+/**
+ * Extra props `teen_process.exec` adds to its error objects
+ */
+export type TeenProcessExecErrorProps = {
+    /**
+     * - STDOUT
+     */
+    stdout: string;
+    /**
+     * - STDERR
+     */
+    stderr: string;
+    /**
+     * - Exit code
+     */
+    code: number | null;
+};
+/**
+ * Error thrown by `teen_process.exec`
+ */
+export type TeenProcessExecError = Error & TeenProcessExecErrorProps;
+//# sourceMappingURL=npm.d.ts.map

package/build/lib/npm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"npm.d.ts","sourceRoot":"","sources":["../../lib/npm.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH,6CAIE;AAEF;;GAEG;AACH,oDAGE;AAEF;;GAEG;AACH;IACE;;;;OAIG;IACH,gCAEC;IAED;;;;;;;;;OASG;IACH,UALW,MAAM,QACN,MAAM,EAAE,QACR,QAAQ;eAqB8C,GAAG;OAiBnE;IAED;;;OAGG;IACH,sBAHW,MAAM,OACN,MAAM,gBAOhB;IAED;;;;OAIG;IACH,iCAJW,MAAM,OACN,MAAM,cACN,MAAM,0BAQhB;IAED;;;;OAIG;IACH,UAHW,MAAM,0CAKhB;IAED;;;;;;;;;OASG;IACH,6CALW,MAAM,eACN,MAAM,MAAM,CAAC,GAEZ,MAAM,GAAC,IAAI,CAmCtB;IAED;;;;;;OAMG;IACH,oBALW,MAAM,WACN,MAAM,gDAEJ,QAAQ,OAAO,WAAW,EAAE,WAAW,CAAC,CA6DpD;IAED;;;OAGG;IACH,sBAHW,MAAM,OACN,MAAM,iBAOhB;CACF;AAED,sBAA6B;;;;;;;;;;;;;;;;;SAWf,MAAM;;;;;;;;;;;;;;;;;YAUN,MAAM;;;;YACN,MAAM;;;;UACN,MAAM;;;;;mCAKP,KAAK,GAAG,yBAAyB"}