@appium/support 2.55.4 → 2.57.0

package/build/lib/timing.js

@@ -93,7 +93,5 @@ class Timer {
 
 exports.Timer = Timer;
 var _default = Timer;
-exports.default = _default;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/util.d.ts

@@ -0,0 +1,183 @@
+export function hasContent(val: any): boolean;
+export type PluralizeOptions = {
+    /**
+     * - Whether to prefix with the number (e.g., 3 ducks)
+     */
+    inclusive?: boolean | undefined;
+};
+export type EncodingOptions = {
+    /**
+     * The maximum size of
+     * the resulting buffer in bytes. This is set to 1GB by default, because
+     * Appium limits the maximum HTTP body size to 1GB. Also, the NodeJS heap
+     * size must be enough to keep the resulting object (usually this size is
+     * limited to 1.4 GB)
+     */
+    maxSize?: number | undefined;
+};
+export type LockFileOptions = {
+    /**
+     * The max time in seconds to wait for the lock
+     */
+    timeout?: number | undefined;
+    /**
+     * Whether to try lock recovery if
+     * the first attempt to acquire it timed out.
+     */
+    tryRecovery?: boolean | undefined;
+};
+export function hasValue(val: any): boolean;
+export function escapeSpace(str: any): any;
+export function escapeSpecialChars(str: any, quoteEscape: any): any;
+export function localIp(): any;
+export function cancellableDelay(ms: any): B<any>;
+export function multiResolve(roots: any, ...args: any[]): any;
+export function safeJsonParse(obj: any): any;
+export function wrapElement(elementId: any): {
+    ELEMENT: any;
+    "element-6066-11e4-a52e-4f735466cecf": any;
+};
+export function unwrapElement(el: any): any;
+export function filterObject(obj: any, predicate: any): any;
+/**
+ * Converts number of bytes to a readable size string.
+ *
+ * @param {number|string} bytes - The actual number of bytes.
+ * @returns {string} The actual string representation, for example
+ *                   '1.00 KB' for '1024 B'
+ * @throws {Error} If bytes count cannot be converted to an integer or
+ *                 if it is less than zero.
+ */
+export function toReadableSizeString(bytes: number | string): string;
+/**
+ * Checks whether the given path is a subpath of the
+ * particular root folder. Both paths can include .. and . specifiers
+ *
+ * @param {string} originalPath The absolute file/folder path
+ * @param {string} root The absolute root folder path
+ * @param {?boolean} forcePosix Set it to true if paths must be interpreted in POSIX format
+ * @returns {boolean} true if the given original path is the subpath of the root folder
+ * @throws {Error} if any of the given paths is not absolute
+ */
+export function isSubPath(originalPath: string, root: string, forcePosix?: boolean | null): boolean;
+export const W3C_WEB_ELEMENT_IDENTIFIER: "element-6066-11e4-a52e-4f735466cecf";
+/**
+ * Checks whether the given paths are pointing to the same file system
+ * destination.
+ *
+ * @param {string} path1 - Absolute or relative path to a file/folder
+ * @param {string} path2 - Absolute or relative path to a file/folder
+ * @param {...string} pathN - Zero or more absolute or relative paths to files/folders
+ * @returns {Promise<boolean>} true if all paths are pointing to the same file system item
+ */
+export function isSameDestination(path1: string, path2: string, ...pathN: string[]): Promise<boolean>;
+/**
+ * Compares two version strings
+ *
+ * @param {string} ver1 - The first version number to compare. Should be a valid
+ * version number supported by semver parser.
+ * @param {string} ver2 - The second version number to compare. Should be a valid
+ * version number supported by semver parser.
+ * @param {string} operator - One of supported version number operators:
+ * ==, !=, >, <, <=, >=, =
+ * @returns {boolean} true or false depending on the actual comparison result
+ * @throws {Error} if an unsupported operator is supplied or any of the supplied
+ * version strings cannot be coerced
+ */
+export function compareVersions(ver1: string, operator: string, ver2: string): boolean;
+/**
+ * Coerces the given number/string to a valid version string
+ *
+ * @template {boolean} [Strict=true]
+ * @param {string} ver - Version string to coerce
+ * @param {Strict} [strict] - If `true` then an exception will be thrown
+ * if `ver` cannot be coerced
+ * @returns {Strict extends true ? string : string|null} Coerced version number or null if the string cannot be
+ * coerced and strict mode is disabled
+ * @throws {Error} if strict mode is enabled and `ver` cannot be coerced
+ */
+export function coerceVersion<Strict extends boolean = true>(ver: string, strict?: Strict | undefined): Strict extends true ? string : string | null;
+/**
+ * Add appropriate quotes to command arguments. See https://github.com/substack/node-shell-quote
+ * for more details
+ *
+ * @param {string|string[]} args - The arguments that will be parsed
+ * @returns {string} - The arguments, quoted
+ */
+export function quote(args: string | string[]): string;
+/**
+ * This function is necessary to workaround unexpected memory leaks
+ * caused by NodeJS string interning
+ * behavior described in https://bugs.chromium.org/p/v8/issues/detail?id=2869
+ *
+ * @param {*} s - The string to unleak
+ * @return {string} Either the unleaked string or the original object converted to string
+ */
+export function unleakString(s: any): string;
+export function jsonStringify(obj: any, replacer: any, space?: number): string;
+/**
+ * @typedef PluralizeOptions
+ * @property {boolean} [inclusive=false] - Whether to prefix with the number (e.g., 3 ducks)
+ */
+/**
+ * Get the form of a word appropriate to the count
+ *
+ * @param {string} word - The word to pluralize
+ * @param {number} count - How many of the word exist
+ * @param {PluralizeOptions|boolean} options - options for word pluralization,
+ *   or a boolean indicating the options.inclusive property
+ * @returns {string} The word pluralized according to the number
+ */
+export function pluralize(word: string, count: number, options?: PluralizeOptions | boolean): string;
+export const GiB: number;
+export const MiB: number;
+export const KiB: 1024;
+/**
+ * @typedef EncodingOptions
+ * @property {number} [maxSize=1073741824] The maximum size of
+ * the resulting buffer in bytes. This is set to 1GB by default, because
+ * Appium limits the maximum HTTP body size to 1GB. Also, the NodeJS heap
+ * size must be enough to keep the resulting object (usually this size is
+ * limited to 1.4 GB)
+ */
+/**
+ * Converts contents of a local file to an in-memory base-64 encoded buffer.
+ * The operation is memory-usage friendly and should be used while encoding
+ * large files to base64
+ *
+ * @param {string} srcPath The full path to the file being encoded
+ * @param {EncodingOptions} opts
+ * @returns {Promise<Buffer>} base64-encoded content of the source file as memory buffer
+ * @throws {Error} if there was an error while reading the source file
+ * or the source file is too
+ */
+export function toInMemoryBase64(srcPath: string, opts?: EncodingOptions): Promise<Buffer>;
+import { v1 as uuidV1 } from "uuid";
+import { v3 as uuidV3 } from "uuid";
+import { v4 as uuidV4 } from "uuid";
+import { v5 as uuidV5 } from "uuid";
+import { parse as shellParse } from "shell-quote";
+/**
+ * @typedef LockFileOptions
+ * @property {number} [timeout=120] The max time in seconds to wait for the lock
+ * @property {boolean} [tryRecovery=false] Whether to try lock recovery if
+ * the first attempt to acquire it timed out.
+ */
+/**
+ * Create an async function which, when called, will not proceed until a certain file is no
+ * longer present on the system. This allows for preventing concurrent behavior across processes
+ * using a known lockfile path.
+ *
+ * @template T
+ * @param {string} lockFile The full path to the file used for the lock
+ * @param {LockFileOptions} opts
+ * @returns async function that takes another async function defining the locked
+ * behavior
+ */
+export function getLockFileGuard<T>(lockFile: string, opts?: LockFileOptions): {
+    (behavior: (...args: any[]) => T): Promise<T>;
+    check(): Promise<boolean>;
+};
+import B from "bluebird";
+export { uuidV1, uuidV3, uuidV4, uuidV5, shellParse };
+//# sourceMappingURL=util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../lib/util.js"],"names":[],"mappings":"AA6BA,8CAEC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGD,4CAUC;AAGD,2CAEC;AAED,oEAsBC;AAED,+BAYC;AAMD,kDAoBC;AAED,8DAEC;AAKD,6CAOC;AAkDD;;;EAKC;AAdD,4CAOC;AAiBD,4DAgBC;AAED;;;;;;;;GAQG;AACH,4CANW,MAAM,GAAC,MAAM,GACX,MAAM,CAkBlB;AAED;;;;;;;;;GASG;AACH,wCANW,MAAM,QACN,MAAM,eACL,OAAO,UACN,OAAO,CAanB;AAxOD,+EAAyE;AA0OzE;;;;;;;;GAQG;AACH,yCALW,MAAM,SACN,MAAM,YACH,MAAM,KACP,QAAQ,OAAO,CAAC,CAiB5B;AAuBD;;;;;;;;;;;;GAYG;AACH,sCAVW,MAAM,YAIN,MAAM,QAFN,MAAM,GAIJ,OAAO,CAanB;AA3CD;;;;;;;;;;GAUG;AACH,kEAPW,MAAM,6EAahB;AA4BD;;;;;;GAMG;AACH,4BAHW,MAAM,GAAC,MAAM,EAAE,GACb,MAAM,CAIlB;AAED;;;;;;;GAOG;AACH,sCAFY,MAAM,CAIjB;AA/MD,+EAoBC;AA8LD;;;GAGG;AAEH;;;;;;;;GAQG;AACH,gCANW,MAAM,SACN,MAAM,YACN,gBAAgB,GAAC,OAAO,GAEtB,MAAM,CAYlB;AA9VD,yBAAuB;AADvB,yBAAuB;AADvB,uBAAiB;AAkWjB;;;;;;;GAOG;AAEH;;;;;;;;;;GAUG;AACH,0CANW,MAAM,SACN,eAAe,GACb,QAAQ,MAAM,CAAC,CA+C3B;;;;;;AAED;;;;;GAKG;AAEH;;;;;;;;;;GAUG;AACH,8CALW,MAAM,SACN,eAAe;yBAeH,GAAG,EAAE;;EAwC3B"}

package/build/lib/util.js

@@ -229,18 +229,18 @@ function filterObject(obj, predicate) {
 }
 
 function toReadableSizeString(bytes) {
-  const intBytes = parseInt(bytes, 10);
+  const intBytes = parseInt(String(bytes), 10);
 
   if (isNaN(intBytes) || intBytes < 0) {
     throw new Error(`Cannot convert '${bytes}' to a readable size format`);
   }
 
   if (intBytes >= GiB) {
-    return `${parseFloat(intBytes / (GiB * 1.0)).toFixed(2)} GB`;
+    return `${(intBytes / (GiB * 1.0)).toFixed(2)} GB`;
   } else if (intBytes >= MiB) {
-    return `${parseFloat(intBytes / (MiB * 1.0)).toFixed(2)} MB`;
+    return `${(intBytes / (MiB * 1.0)).toFixed(2)} MB`;
   } else if (intBytes >= KiB) {
-    return `${parseFloat(intBytes / (KiB * 1.0)).toFixed(2)} KB`;
+    return `${(intBytes / (KiB * 1.0)).toFixed(2)} KB`;
   }
 
   return `${intBytes} B`;
@@ -273,13 +273,9 @@ async function isSameDestination(path1, path2, ...pathN) {
     return true;
   }
 
-  let mapCb = async x => await _fs.default.stat(x, {
+  let mapCb = async x => (await _fs.default.stat(x, {
     bigint: true
-  }).ino;
-
-  if (_semver.default.lt(process.version, '10.5.0')) {
-    mapCb = async x => await _fs.default.stat(x).ino;
-  }
+  })).ino;
 
   return areAllItemsEqual(await _bluebird.default.map(allPaths, mapCb));
 }
@@ -309,7 +305,7 @@ function compareVersions(ver1, operator, ver2) {
 }
 
 function quote(args) {
-  return (0, _shellQuote.quote)(args);
+  return (0, _shellQuote.quote)(_lodash.default.castArray(args));
 }
 
 function unleakString(s) {
@@ -421,7 +417,5 @@ function getLockFileGuard(lockFile, opts = {}) {
   guard.check = async () => await check(lockFile);
 
   return guard;
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/util.js"],"names":["W3C_WEB_ELEMENT_IDENTIFIER","KiB","MiB","GiB","hasContent","val","_","isString","hasValue","hasVal","isNumber","isNaN","isUndefined","isNull","escapeSpace","str","split","join","escapeSpecialChars","quoteEscape","replace","re","RegExp","localIp","ip","chain","os","networkInterfaces","values","flatten","filter","family","internal","map","first","value","cancellableDelay","ms","timer","resolve","reject","delay","B","Promise","_resolve","_reject","setTimeout","cancel","clearTimeout","CancellationError","multiResolve","roots","args","root","path","safeJsonParse","obj","JSON","parse","ign","jsonStringify","replacer","space","isFunction","k","v","bufferToJSON","Buffer","prototype","toJSON","stringify","key","updatedValue","isBuffer","toString","unwrapElement","el","propName","has","wrapElement","elementId","ELEMENT","filterObject","predicate","newObj","clone","valuePredicate","Object","keys","toReadableSizeString","bytes","intBytes","parseInt","Error","parseFloat","toFixed","isSubPath","originalPath","forcePosix","pathObj","posix","p","isAbsolute","normalizedRoot","normalize","normalizedPath","startsWith","isSameDestination","path1","path2","pathN","allPaths","reduce","a","b","fs","exists","areAllItemsEqual","arr","NaN","mapCb","x","stat","bigint","ino","semver","lt","process","version","coerceVersion","ver","strict","result","valid","coerce","SUPPORTED_OPERATORS","compareVersions","ver1","operator","ver2","includes","semverOperator","satisfies","quote","unleakString","s","substr","pluralize","word","count","options","inclusive","isBoolean","toInMemoryBase64","srcPath","opts","isDirectory","maxSize","resultBuffers","resultBuffersSize","resultWriteStream","stream","Writable","write","buffer","encoding","next","push","length","emit","readerStream","createReadStream","base64EncoderStream","Base64Encode","resultWriteStreamPromise","once","e","unpipe","destroy","readStreamPromise","message","pipe","all","concat","getLockFileGuard","lockFile","timeout","tryRecovery","lock","promisify","_lockfile","check","unlock","guard","behavior","triedRecovery","checkSync","wait","lockSync","unlockSync"],"mappings":"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","sourcesContent":["import B from 'bluebird';\nimport _ from 'lodash';\nimport os from 'os';\nimport path from 'path';\nimport fs from './fs';\nimport semver from 'semver';\nimport {\n  // https://www.npmjs.com/package/shell-quote\n  quote as shellQuote,\n  parse as shellParse,\n} from 'shell-quote';\nimport pluralizeLib from 'pluralize';\nimport stream from 'stream';\nimport { Base64Encode } from 'base64-stream';\nimport {\n  // https://www.npmjs.com/package/uuid\n  v1 as uuidV1, v3 as uuidV3,\n  v4 as uuidV4, v5 as uuidV5\n} from 'uuid';\nimport _lockfile from 'lockfile';\n\n\nconst W3C_WEB_ELEMENT_IDENTIFIER = 'element-6066-11e4-a52e-4f735466cecf';\nconst KiB = 1024;\nconst MiB = KiB * 1024;\nconst GiB = MiB * 1024;\n\nexport function hasContent (val) {\n  return _.isString(val) && val !== '';\n}\n\n// return true if the the value is not undefined, null, or NaN.\nfunction hasValue (val) {\n  let hasVal = false;\n  // avoid incorrectly evaluating `0` as false\n  if (_.isNumber(val)) {\n    hasVal = !_.isNaN(val);\n  } else {\n    hasVal = !_.isUndefined(val) && !_.isNull(val);\n  }\n\n  return hasVal;\n}\n\n// escape spaces in string, for commandline calls\nfunction escapeSpace (str) {\n  return str.split(/ /).join('\\\\ ');\n}\n\nfunction escapeSpecialChars (str, quoteEscape) {\n  if (typeof str !== 'string') {\n    return str;\n  }\n  if (typeof quoteEscape === 'undefined') {\n    quoteEscape = false;\n  }\n  str = str\n    .replace(/[\\\\]/g, '\\\\\\\\')\n    .replace(/[\\/]/g, '\\\\/') // eslint-disable-line no-useless-escape\n    .replace(/[\\b]/g, '\\\\b')\n    .replace(/[\\f]/g, '\\\\f')\n    .replace(/[\\n]/g, '\\\\n')\n    .replace(/[\\r]/g, '\\\\r')\n    .replace(/[\\t]/g, '\\\\t')\n    .replace(/[\\\"]/g, '\\\\\"') // eslint-disable-line no-useless-escape\n    .replace(/\\\\'/g, \"\\\\'\");\n  if (quoteEscape) {\n    let re = new RegExp(quoteEscape, 'g');\n    str = str.replace(re, `\\\\${quoteEscape}`);\n  }\n  return str;\n}\n\nfunction localIp () {\n  let ip = _.chain(os.networkInterfaces())\n    .values()\n    .flatten()\n    .filter(function (val) {\n      return (val.family === 'IPv4' && val.internal === false);\n    })\n    .map('address')\n    .first()\n    .value();\n  return ip;\n}\n\n/*\n * Creates a promise that is cancellable, and will timeout\n * after `ms` delay\n */\nfunction cancellableDelay (ms) {\n  let timer;\n  let resolve;\n  let reject;\n\n  const delay = new B.Promise((_resolve, _reject) => {\n    resolve = _resolve;\n    reject = _reject;\n    timer = setTimeout(function () {\n      resolve();\n    }, ms);\n  });\n\n  // override Bluebird's `cancel`, which does not work when using `await` on\n  // a promise, since `resolve`/`reject` are never called\n  delay.cancel = function () {\n    clearTimeout(timer);\n    reject(new B.CancellationError());\n  };\n  return delay;\n}\n\nfunction multiResolve (roots, ...args) {\n  return roots.map((root) => path.resolve(root, ...args));\n}\n\n/*\n * Parses an object if possible. Otherwise returns the object without parsing.\n */\nfunction safeJsonParse (obj) {\n  try {\n    return JSON.parse(obj);\n  } catch (ign) {\n    // ignore: this is not json parsable\n    return obj;\n  }\n}\n\n/*\n * Stringifies the object passed in, converting Buffers into Strings for better\n * display. This mimics JSON.stringify (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify)\n * except the `replacer` argument can only be a function.\n *\n * @param {object} obj - the object to be serialized\n * @param {?function} replacer - function to transform the properties added to the\n *                               serialized object\n * @param {?number|string} space - used to insert white space into the output JSON\n *                                 string for readability purposes. Defaults to 2\n * returns {string} - the JSON object serialized as a string\n */\nfunction jsonStringify (obj, replacer, space = 2) {\n  // if no replacer is passed, or it is not a function, just use a pass-through\n  if (!_.isFunction(replacer)) {\n    replacer = (k, v) => v;\n  }\n\n  // Buffers cannot be serialized in a readable way\n  const bufferToJSON = Buffer.prototype.toJSON;\n  delete Buffer.prototype.toJSON;\n  try {\n    return JSON.stringify(obj, (key, value) => {\n      const updatedValue = Buffer.isBuffer(value)\n        ? value.toString('utf8')\n        : value;\n      return replacer(key, updatedValue);\n    }, space);\n  } finally {\n    // restore the function, so as to not break further serialization\n    Buffer.prototype.toJSON = bufferToJSON;\n  }\n}\n\n/*\n * Removes the wrapper from element, if it exists.\n *   { ELEMENT: 4 } becomes 4\n *   { element-6066-11e4-a52e-4f735466cecf: 5 } becomes 5\n */\nfunction unwrapElement (el) {\n  for (const propName of [W3C_WEB_ELEMENT_IDENTIFIER, 'ELEMENT']) {\n    if (_.has(el, propName)) {\n      return el[propName];\n    }\n  }\n  return el;\n}\n\nfunction wrapElement (elementId) {\n  return {\n    ELEMENT: elementId,\n    [W3C_WEB_ELEMENT_IDENTIFIER]: elementId,\n  };\n}\n\n/*\n * Returns object consisting of all properties in the original element\n * which were truthy given the predicate.\n * If the predicate is\n *   * missing - it will remove all properties whose values are `undefined`\n *   * a scalar - it will test all properties' values against that value\n *   * a function - it will pass each value and the original object into the function\n */\nfunction filterObject (obj, predicate) {\n  let newObj = _.clone(obj);\n  if (_.isUndefined(predicate)) {\n    // remove any element from the object whose value is undefined\n    predicate = (v) => !_.isUndefined(v);\n  } else if (!_.isFunction(predicate)) {\n    // make predicate into a function\n    const valuePredicate = predicate;\n    predicate = (v) => v === valuePredicate;\n  }\n  for (const key of Object.keys(obj)) {\n    if (!predicate(obj[key], obj)) {\n      delete newObj[key];\n    }\n  }\n  return newObj;\n}\n\n/**\n * Converts number of bytes to a readable size string.\n *\n * @param {number|string} bytes - The actual number of bytes.\n * @returns {string} The actual string representation, for example\n *                   '1.00 KB' for '1024 B'\n * @throws {Error} If bytes count cannot be converted to an integer or\n *                 if it is less than zero.\n */\nfunction toReadableSizeString (bytes) {\n  const intBytes = parseInt(bytes, 10);\n  if (isNaN(intBytes) || intBytes < 0) {\n    throw new Error(`Cannot convert '${bytes}' to a readable size format`);\n  }\n  if (intBytes >= GiB) {\n    return `${parseFloat(intBytes / (GiB * 1.0)).toFixed(2)} GB`;\n  } else if (intBytes >= MiB) {\n    return `${parseFloat(intBytes / (MiB * 1.0)).toFixed(2)} MB`;\n  } else if (intBytes >= KiB) {\n    return `${parseFloat(intBytes / (KiB * 1.0)).toFixed(2)} KB`;\n  }\n  return `${intBytes} B`;\n}\n\n/**\n * Checks whether the given path is a subpath of the\n * particular root folder. Both paths can include .. and . specifiers\n *\n * @param {string} originalPath The absolute file/folder path\n * @param {string} root The absolute root folder path\n * @param {?boolean} forcePosix Set it to true if paths must be interpreted in POSIX format\n * @returns {boolean} true if the given original path is the subpath of the root folder\n * @throws {Error} if any of the given paths is not absolute\n */\nfunction isSubPath (originalPath, root, forcePosix = null) {\n  const pathObj = forcePosix ? path.posix : path;\n  for (const p of [originalPath, root]) {\n    if (!pathObj.isAbsolute(p)) {\n      throw new Error(`'${p}' is expected to be an absolute path`);\n    }\n  }\n  const normalizedRoot = pathObj.normalize(root);\n  const normalizedPath = pathObj.normalize(originalPath);\n  return normalizedPath.startsWith(normalizedRoot);\n}\n\n/**\n * Checks whether the given paths are pointing to the same file system\n * destination.\n *\n * @param {string} path1 - Absolute or relative path to a file/folder\n * @param {string} path2 - Absolute or relative path to a file/folder\n * @param {...string} pathN - Zero or more absolute or relative paths to files/folders\n * @returns {boolean} true if all paths are pointing to the same file system item\n */\nasync function isSameDestination (path1, path2, ...pathN) {\n  const allPaths = [path1, path2, ...pathN];\n  if (!await B.reduce(allPaths, async (a, b) => a && await fs.exists(b), true)) {\n    return false;\n  }\n\n  const areAllItemsEqual = (arr) => !!arr.reduce((a, b) => a === b ? a : NaN);\n  if (areAllItemsEqual(allPaths)) {\n    return true;\n  }\n\n  // Node 10.5.0 introduced bigint support in stat, which allows for more precision\n  // however below that the options get interpreted as the callback\n  // TODO: remove when Node 10 is no longer supported\n  let mapCb = async (x) => await fs.stat(x, {\n    bigint: true,\n  }).ino;\n  if (semver.lt(process.version, '10.5.0')) {\n    mapCb = async (x) => await fs.stat(x).ino;\n  }\n  return areAllItemsEqual(await B.map(allPaths, mapCb));\n}\n\n/**\n * Coerces the given number/string to a valid version string\n *\n * @param {string|number} ver - Version string to coerce\n * @param {boolean} strict [true] - If true then an exception will be thrown\n * if `ver` cannot be coerced\n * @returns {string} Coerced version number or null if the string cannot be\n * coerced and strict mode is disabled\n * @throws {Error} if strict mode is enabled and `ver` cannot be coerced\n */\nfunction coerceVersion (ver, strict = true) {\n  const result = semver.valid(semver.coerce(`${ver}`));\n  if (strict && !result) {\n    throw new Error(`'${ver}' cannot be coerced to a valid version number`);\n  }\n  return result;\n}\n\nconst SUPPORTED_OPERATORS = ['==', '!=', '>', '<', '>=', '<=', '='];\n\n/**\n * Compares two version strings\n *\n * @param {string|number} ver1 - The first version number to compare. Should be a valid\n * version number supported by semver parser.\n * @param {string|number} ver2 - The second version number to compare. Should be a valid\n * version number supported by semver parser.\n * @param {string} operator - One of supported version number operators:\n * ==, !=, >, <, <=, >=, =\n * @returns {boolean} true or false depending on the actual comparison result\n * @throws {Error} if an unsupported operator is supplied or any of the supplied\n * version strings cannot be coerced\n */\nfunction compareVersions (ver1, operator, ver2) {\n  if (!SUPPORTED_OPERATORS.includes(operator)) {\n    throw new Error(`The '${operator}' comparison operator is not supported. ` +\n      `Only '${JSON.stringify(SUPPORTED_OPERATORS)}' operators are supported`);\n  }\n\n  const semverOperator = ['==', '!='].includes(operator) ? '=' : operator;\n  const result = semver.satisfies(coerceVersion(ver1), `${semverOperator}${coerceVersion(ver2)}`);\n  return operator === '!=' ? !result : result;\n}\n\n/**\n * Add appropriate quotes to command arguments. See https://github.com/substack/node-shell-quote\n * for more details\n *\n * @param {string|Array<string>} - The arguments that will be parsed\n * @returns {string} - The arguments, quoted\n */\nfunction quote (args) {\n  return shellQuote(args);\n}\n\n/**\n * This function is necessary to workaround unexpected memory leaks\n * caused by NodeJS string interning\n * behavior described in https://bugs.chromium.org/p/v8/issues/detail?id=2869\n *\n * @param {*} s - The string to unleak\n * @return {string} Either the unleaked string or the original object converted to string\n */\nfunction unleakString (s) {\n  return ` ${s}`.substr(1);\n}\n\n\n/**\n * @typedef {Object} PluralizeOptions\n * @property {?boolean} inclusive [false] - Whether to prefix with the number (e.g., 3 ducks)\n */\n\n/**\n * Get the form of a word appropriate to the count\n *\n * @param {string} word - The word to pluralize\n * @param {number} count - How many of the word exist\n * @param {?PluralizeOptions|boolean} options|inclusive - options for word pluralization,\n *   or a boolean indicating the options.inclusive property\n * @returns {string} The word pluralized according to the number\n */\nfunction pluralize (word, count, options = {}) {\n  let inclusive = false;\n  if (_.isBoolean(options)) {\n    // if passed in as a boolean\n    inclusive = options;\n  } else if (_.isBoolean(options?.inclusive)) {\n    // if passed in as an options hash\n    inclusive = options.inclusive;\n  }\n  return pluralizeLib(word, count, inclusive);\n}\n\n/**\n * @typedef {Object} EncodingOptions\n * @property {number} maxSize [1073741824] The maximum size of\n * the resulting buffer in bytes. This is set to 1GB by default, because\n * Appium limits the maximum HTTP body size to 1GB. Also, the NodeJS heap\n * size must be enough to keep the resulting object (usually this size is\n * limited to 1.4 GB)\n */\n\n/**\n * Converts contents of a local file to an in-memory base-64 encoded buffer.\n * The operation is memory-usage friendly and should be used while encoding\n * large files to base64\n *\n * @param {string} srcPath The full path to the file being encoded\n * @param {EncodingOptions} opts\n * @returns {Buffer} base64-encoded content of the source file as memory buffer\n * @throws {Error} if there was an error while reading the source file\n * or the source file is too\n */\nasync function toInMemoryBase64 (srcPath, opts = {}) {\n  if (!(await fs.exists(srcPath)) || (await fs.stat(srcPath)).isDirectory()) {\n    throw new Error(`No such file: ${srcPath}`);\n  }\n\n  const {\n    maxSize = 1 * GiB,\n  } = opts;\n  const resultBuffers = [];\n  let resultBuffersSize = 0;\n  const resultWriteStream = new stream.Writable({\n    write: (buffer, encoding, next) => {\n      resultBuffers.push(buffer);\n      resultBuffersSize += buffer.length;\n      if (maxSize > 0 && resultBuffersSize > maxSize) {\n        resultWriteStream.emit('error', new Error(`The size of the resulting ` +\n          `buffer must not be greater than ${toReadableSizeString(maxSize)}`));\n      }\n      next();\n    },\n  });\n\n  const readerStream = fs.createReadStream(srcPath);\n  const base64EncoderStream = new Base64Encode();\n  const resultWriteStreamPromise = new B((resolve, reject) => {\n    resultWriteStream.once('error', (e) => {\n      readerStream.unpipe(base64EncoderStream);\n      base64EncoderStream.unpipe(resultWriteStream);\n      readerStream.destroy();\n      reject(e);\n    });\n    resultWriteStream.once('finish', resolve);\n  });\n  const readStreamPromise = new B((resolve, reject) => {\n    readerStream.once('close', resolve);\n    readerStream.once('error', (e) => reject(\n      new Error(`Failed to read '${srcPath}': ${e.message}`)));\n  });\n  readerStream.pipe(base64EncoderStream);\n  base64EncoderStream.pipe(resultWriteStream);\n\n  await B.all([readStreamPromise, resultWriteStreamPromise]);\n  return Buffer.concat(resultBuffers);\n}\n\n/**\n * @typedef {Object} LockFileOptions\n * @property {number} timeout [120] The max time in seconds to wait for the lock\n * @property {boolean} tryRecovery [false] Whether to try lock recovery if\n * the first attempt to acquire it timed out.\n */\n\n/**\n * Create an async function which, when called, will not proceed until a certain file is no\n * longer present on the system. This allows for preventing concurrent behavior across processes\n * using a known lockfile path.\n *\n * @param {string} lockFile The full path to the file used for the lock\n * @param {LockFileOptions} opts\n * @returns {AsyncFunction} async function that takes another async function defining the locked\n * behavior\n */\nfunction getLockFileGuard (lockFile, opts = {}) {\n  const {\n    timeout = 120,\n    tryRecovery = false,\n  } = opts;\n\n  const lock = B.promisify(_lockfile.lock);\n  const check = B.promisify(_lockfile.check);\n  const unlock = B.promisify(_lockfile.unlock);\n\n  const guard = async (behavior) => {\n    let triedRecovery = false;\n    do {\n      try {\n        // if the lockfile doesn't exist, lock it synchronously to make sure no other call\n        // on the same spin of the event loop can also initiate a lock. If the lockfile does exist\n        // then just use the regular async 'lock' method which will wait on the lock.\n        if (_lockfile.checkSync(lockFile)) {\n          await lock(lockFile, {wait: timeout * 1000});\n        } else {\n          _lockfile.lockSync(lockFile);\n        }\n        break;\n      } catch (e) {\n        if (_.includes(e.message, 'EEXIST') && tryRecovery && !triedRecovery) {\n          // There could be cases where a process has been forcefully terminated\n          // without a chance to clean up pending locks: https://github.com/npm/lockfile/issues/26\n          _lockfile.unlockSync(lockFile);\n          triedRecovery = true;\n          continue;\n        }\n        throw new Error(`Could not acquire lock on '${lockFile}' after ${timeout}s. ` +\n          `Original error: ${e.message}`);\n      }\n    // eslint-disable-next-line no-constant-condition\n    } while (true);\n    try {\n      return await behavior();\n    } finally {\n      // whether the behavior succeeded or not, get rid of the lock\n      await unlock(lockFile);\n    }\n  };\n\n  guard.check = async () => await check(lockFile);\n\n  return guard;\n}\n\nexport {\n  hasValue, escapeSpace, escapeSpecialChars, localIp, cancellableDelay,\n  multiResolve, safeJsonParse, wrapElement, unwrapElement, filterObject,\n  toReadableSizeString, isSubPath, W3C_WEB_ELEMENT_IDENTIFIER,\n  isSameDestination, compareVersions, coerceVersion, quote, unleakString,\n  jsonStringify, pluralize, GiB, MiB, KiB, toInMemoryBase64,\n  uuidV1, uuidV3, uuidV4, uuidV5, shellParse, getLockFileGuard\n};\n"],"file":"lib/util.js","sourceRoot":"../.."}
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/util.js"],"names":["W3C_WEB_ELEMENT_IDENTIFIER","KiB","MiB","GiB","hasContent","val","_","isString","hasValue","hasVal","isNumber","isNaN","isUndefined","isNull","escapeSpace","str","split","join","escapeSpecialChars","quoteEscape","replace","re","RegExp","localIp","ip","chain","os","networkInterfaces","values","flatten","filter","family","internal","map","first","value","cancellableDelay","ms","timer","resolve","reject","delay","B","Promise","_resolve","_reject","setTimeout","cancel","clearTimeout","CancellationError","multiResolve","roots","args","root","path","safeJsonParse","obj","JSON","parse","ign","jsonStringify","replacer","space","isFunction","k","v","bufferToJSON","Buffer","prototype","toJSON","stringify","key","updatedValue","isBuffer","toString","unwrapElement","el","propName","has","wrapElement","elementId","ELEMENT","filterObject","predicate","newObj","clone","valuePredicate","Object","keys","toReadableSizeString","bytes","intBytes","parseInt","String","Error","toFixed","isSubPath","originalPath","forcePosix","pathObj","posix","p","isAbsolute","normalizedRoot","normalize","normalizedPath","startsWith","isSameDestination","path1","path2","pathN","allPaths","reduce","a","b","fs","exists","areAllItemsEqual","arr","NaN","mapCb","x","stat","bigint","ino","coerceVersion","ver","strict","result","semver","valid","coerce","SUPPORTED_OPERATORS","compareVersions","ver1","operator","ver2","includes","semverOperator","satisfies","quote","castArray","unleakString","s","substr","pluralize","word","count","options","inclusive","isBoolean","toInMemoryBase64","srcPath","opts","isDirectory","maxSize","resultBuffers","resultBuffersSize","resultWriteStream","stream","Writable","write","buffer","encoding","next","push","length","emit","readerStream","createReadStream","base64EncoderStream","Base64Encode","resultWriteStreamPromise","once","e","unpipe","destroy","readStreamPromise","message","pipe","all","concat","getLockFileGuard","lockFile","timeout","tryRecovery","lock","promisify","_lockfile","check","unlock","guard","behavior","triedRecovery","checkSync","wait","lockSync","unlockSync"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport B from 'bluebird';\nimport _ from 'lodash';\nimport os from 'os';\nimport path from 'path';\nimport fs from './fs';\nimport semver from 'semver';\nimport {\n  // https://www.npmjs.com/package/shell-quote\n  quote as shellQuote,\n  parse as shellParse,\n} from 'shell-quote';\nimport pluralizeLib from 'pluralize';\nimport stream from 'stream';\nimport { Base64Encode } from 'base64-stream';\nimport {\n  // https://www.npmjs.com/package/uuid\n  v1 as uuidV1, v3 as uuidV3,\n  v4 as uuidV4, v5 as uuidV5\n} from 'uuid';\nimport _lockfile from 'lockfile';\n\n\nconst W3C_WEB_ELEMENT_IDENTIFIER = 'element-6066-11e4-a52e-4f735466cecf';\nconst KiB = 1024;\nconst MiB = KiB * 1024;\nconst GiB = MiB * 1024;\n\nexport function hasContent (val) {\n  return _.isString(val) && val !== '';\n}\n\n// return true if the the value is not undefined, null, or NaN.\nfunction hasValue (val) {\n  let hasVal = false;\n  // avoid incorrectly evaluating `0` as false\n  if (_.isNumber(val)) {\n    hasVal = !_.isNaN(val);\n  } else {\n    hasVal = !_.isUndefined(val) && !_.isNull(val);\n  }\n\n  return hasVal;\n}\n\n// escape spaces in string, for commandline calls\nfunction escapeSpace (str) {\n  return str.split(/ /).join('\\\\ ');\n}\n\nfunction escapeSpecialChars (str, quoteEscape) {\n  if (typeof str !== 'string') {\n    return str;\n  }\n  if (typeof quoteEscape === 'undefined') {\n    quoteEscape = false;\n  }\n  str = str\n    .replace(/[\\\\]/g, '\\\\\\\\')\n    .replace(/[\\/]/g, '\\\\/') // eslint-disable-line no-useless-escape\n    .replace(/[\\b]/g, '\\\\b')\n    .replace(/[\\f]/g, '\\\\f')\n    .replace(/[\\n]/g, '\\\\n')\n    .replace(/[\\r]/g, '\\\\r')\n    .replace(/[\\t]/g, '\\\\t')\n    .replace(/[\\\"]/g, '\\\\\"') // eslint-disable-line no-useless-escape\n    .replace(/\\\\'/g, \"\\\\'\");\n  if (quoteEscape) {\n    let re = new RegExp(quoteEscape, 'g');\n    str = str.replace(re, `\\\\${quoteEscape}`);\n  }\n  return str;\n}\n\nfunction localIp () {\n  let ip = _.chain(os.networkInterfaces())\n    .values()\n    .flatten()\n    // @ts-ignore\n    .filter(function (val) {\n      return (val.family === 'IPv4' && val.internal === false);\n    })\n    .map('address')\n    .first()\n    .value();\n  return ip;\n}\n\n/*\n * Creates a promise that is cancellable, and will timeout\n * after `ms` delay\n */\nfunction cancellableDelay (ms) {\n  let timer;\n  let resolve;\n  let reject;\n\n  const delay = new B.Promise((_resolve, _reject) => {\n    resolve = _resolve;\n    reject = _reject;\n    timer = setTimeout(function () {\n      resolve();\n    }, ms);\n  });\n\n  // override Bluebird's `cancel`, which does not work when using `await` on\n  // a promise, since `resolve`/`reject` are never called\n  delay.cancel = function () {\n    clearTimeout(timer);\n    reject(new B.CancellationError());\n  };\n  return delay;\n}\n\nfunction multiResolve (roots, ...args) {\n  return roots.map((root) => path.resolve(root, ...args));\n}\n\n/*\n * Parses an object if possible. Otherwise returns the object without parsing.\n */\nfunction safeJsonParse (obj) {\n  try {\n    return JSON.parse(obj);\n  } catch (ign) {\n    // ignore: this is not json parsable\n    return obj;\n  }\n}\n\n/*\n * Stringifies the object passed in, converting Buffers into Strings for better\n * display. This mimics JSON.stringify (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify)\n * except the `replacer` argument can only be a function.\n *\n * @param {object} obj - the object to be serialized\n * @param {?function} replacer - function to transform the properties added to the\n *                               serialized object\n * @param {?number|string} space - used to insert white space into the output JSON\n *                                 string for readability purposes. Defaults to 2\n * returns {string} - the JSON object serialized as a string\n */\nfunction jsonStringify (obj, replacer, space = 2) {\n  // if no replacer is passed, or it is not a function, just use a pass-through\n  if (!_.isFunction(replacer)) {\n    replacer = (k, v) => v;\n  }\n\n  // Buffers cannot be serialized in a readable way\n  const bufferToJSON = Buffer.prototype.toJSON;\n  delete Buffer.prototype.toJSON;\n  try {\n    return JSON.stringify(obj, (key, value) => {\n      const updatedValue = Buffer.isBuffer(value)\n        ? value.toString('utf8')\n        : value;\n      return replacer(key, updatedValue);\n    }, space);\n  } finally {\n    // restore the function, so as to not break further serialization\n    Buffer.prototype.toJSON = bufferToJSON;\n  }\n}\n\n/*\n * Removes the wrapper from element, if it exists.\n *   { ELEMENT: 4 } becomes 4\n *   { element-6066-11e4-a52e-4f735466cecf: 5 } becomes 5\n */\nfunction unwrapElement (el) {\n  for (const propName of [W3C_WEB_ELEMENT_IDENTIFIER, 'ELEMENT']) {\n    if (_.has(el, propName)) {\n      return el[propName];\n    }\n  }\n  return el;\n}\n\nfunction wrapElement (elementId) {\n  return {\n    ELEMENT: elementId,\n    [W3C_WEB_ELEMENT_IDENTIFIER]: elementId,\n  };\n}\n\n/*\n * Returns object consisting of all properties in the original element\n * which were truthy given the predicate.\n * If the predicate is\n *   * missing - it will remove all properties whose values are `undefined`\n *   * a scalar - it will test all properties' values against that value\n *   * a function - it will pass each value and the original object into the function\n */\nfunction filterObject (obj, predicate) {\n  let newObj = _.clone(obj);\n  if (_.isUndefined(predicate)) {\n    // remove any element from the object whose value is undefined\n    predicate = (v) => !_.isUndefined(v);\n  } else if (!_.isFunction(predicate)) {\n    // make predicate into a function\n    const valuePredicate = predicate;\n    predicate = (v) => v === valuePredicate;\n  }\n  for (const key of Object.keys(obj)) {\n    if (!predicate(obj[key], obj)) {\n      delete newObj[key];\n    }\n  }\n  return newObj;\n}\n\n/**\n * Converts number of bytes to a readable size string.\n *\n * @param {number|string} bytes - The actual number of bytes.\n * @returns {string} The actual string representation, for example\n *                   '1.00 KB' for '1024 B'\n * @throws {Error} If bytes count cannot be converted to an integer or\n *                 if it is less than zero.\n */\nfunction toReadableSizeString (bytes) {\n  const intBytes = parseInt(String(bytes), 10);\n  if (isNaN(intBytes) || intBytes < 0) {\n    throw new Error(`Cannot convert '${bytes}' to a readable size format`);\n  }\n  if (intBytes >= GiB) {\n    return `${(intBytes / (GiB * 1.0)).toFixed(2)} GB`;\n  } else if (intBytes >= MiB) {\n    return `${(intBytes / (MiB * 1.0)).toFixed(2)} MB`;\n  } else if (intBytes >= KiB) {\n    return `${(intBytes / (KiB * 1.0)).toFixed(2)} KB`;\n  }\n  return `${intBytes} B`;\n}\n\n/**\n * Checks whether the given path is a subpath of the\n * particular root folder. Both paths can include .. and . specifiers\n *\n * @param {string} originalPath The absolute file/folder path\n * @param {string} root The absolute root folder path\n * @param {?boolean} forcePosix Set it to true if paths must be interpreted in POSIX format\n * @returns {boolean} true if the given original path is the subpath of the root folder\n * @throws {Error} if any of the given paths is not absolute\n */\nfunction isSubPath (originalPath, root, forcePosix = null) {\n  const pathObj = forcePosix ? path.posix : path;\n  for (const p of [originalPath, root]) {\n    if (!pathObj.isAbsolute(p)) {\n      throw new Error(`'${p}' is expected to be an absolute path`);\n    }\n  }\n  const normalizedRoot = pathObj.normalize(root);\n  const normalizedPath = pathObj.normalize(originalPath);\n  return normalizedPath.startsWith(normalizedRoot);\n}\n\n/**\n * Checks whether the given paths are pointing to the same file system\n * destination.\n *\n * @param {string} path1 - Absolute or relative path to a file/folder\n * @param {string} path2 - Absolute or relative path to a file/folder\n * @param {...string} pathN - Zero or more absolute or relative paths to files/folders\n * @returns {Promise<boolean>} true if all paths are pointing to the same file system item\n */\nasync function isSameDestination (path1, path2, ...pathN) {\n  const allPaths = [path1, path2, ...pathN];\n  if (!await B.reduce(allPaths, async (a, b) => a && await fs.exists(b), true)) {\n    return false;\n  }\n\n  const areAllItemsEqual = (arr) => !!arr.reduce((a, b) => a === b ? a : NaN);\n  if (areAllItemsEqual(allPaths)) {\n    return true;\n  }\n\n  let mapCb = async (x) => (await fs.stat(x, {\n    bigint: true,\n  })).ino;\n  return areAllItemsEqual(await B.map(allPaths, mapCb));\n}\n\n/**\n * Coerces the given number/string to a valid version string\n *\n * @template {boolean} [Strict=true]\n * @param {string} ver - Version string to coerce\n * @param {Strict} [strict] - If `true` then an exception will be thrown\n * if `ver` cannot be coerced\n * @returns {Strict extends true ? string : string|null} Coerced version number or null if the string cannot be\n * coerced and strict mode is disabled\n * @throws {Error} if strict mode is enabled and `ver` cannot be coerced\n */\nfunction coerceVersion (ver, strict = /** @type {Strict} */(true)) {\n  const result = semver.valid(semver.coerce(`${ver}`));\n  if (strict && !result) {\n    throw new Error(`'${ver}' cannot be coerced to a valid version number`);\n  }\n  return /** @type {Strict extends true ? string : string?} */(result);\n}\n\nconst SUPPORTED_OPERATORS = ['==', '!=', '>', '<', '>=', '<=', '='];\n\n/**\n * Compares two version strings\n *\n * @param {string} ver1 - The first version number to compare. Should be a valid\n * version number supported by semver parser.\n * @param {string} ver2 - The second version number to compare. Should be a valid\n * version number supported by semver parser.\n * @param {string} operator - One of supported version number operators:\n * ==, !=, >, <, <=, >=, =\n * @returns {boolean} true or false depending on the actual comparison result\n * @throws {Error} if an unsupported operator is supplied or any of the supplied\n * version strings cannot be coerced\n */\nfunction compareVersions (ver1, operator, ver2) {\n  if (!SUPPORTED_OPERATORS.includes(operator)) {\n    throw new Error(`The '${operator}' comparison operator is not supported. ` +\n      `Only '${JSON.stringify(SUPPORTED_OPERATORS)}' operators are supported`);\n  }\n\n  const semverOperator = ['==', '!='].includes(operator) ? '=' : operator;\n  const result = semver.satisfies(coerceVersion(ver1), `${semverOperator}${coerceVersion(ver2)}`);\n  return operator === '!=' ? !result : result;\n}\n\n/**\n * Add appropriate quotes to command arguments. See https://github.com/substack/node-shell-quote\n * for more details\n *\n * @param {string|string[]} args - The arguments that will be parsed\n * @returns {string} - The arguments, quoted\n */\nfunction quote (args) {\n  return shellQuote(_.castArray(args));\n}\n\n/**\n * This function is necessary to workaround unexpected memory leaks\n * caused by NodeJS string interning\n * behavior described in https://bugs.chromium.org/p/v8/issues/detail?id=2869\n *\n * @param {*} s - The string to unleak\n * @return {string} Either the unleaked string or the original object converted to string\n */\nfunction unleakString (s) {\n  return ` ${s}`.substr(1);\n}\n\n\n/**\n * @typedef PluralizeOptions\n * @property {boolean} [inclusive=false] - Whether to prefix with the number (e.g., 3 ducks)\n */\n\n/**\n * Get the form of a word appropriate to the count\n *\n * @param {string} word - The word to pluralize\n * @param {number} count - How many of the word exist\n * @param {PluralizeOptions|boolean} options - options for word pluralization,\n *   or a boolean indicating the options.inclusive property\n * @returns {string} The word pluralized according to the number\n */\nfunction pluralize (word, count, options = {}) {\n  let inclusive = false;\n  if (_.isBoolean(options)) {\n    // if passed in as a boolean\n    inclusive = options;\n  } else if (_.isBoolean(options?.inclusive)) {\n    // if passed in as an options hash\n    inclusive = options.inclusive;\n  }\n  return pluralizeLib(word, count, inclusive);\n}\n\n/**\n * @typedef EncodingOptions\n * @property {number} [maxSize=1073741824] The maximum size of\n * the resulting buffer in bytes. This is set to 1GB by default, because\n * Appium limits the maximum HTTP body size to 1GB. Also, the NodeJS heap\n * size must be enough to keep the resulting object (usually this size is\n * limited to 1.4 GB)\n */\n\n/**\n * Converts contents of a local file to an in-memory base-64 encoded buffer.\n * The operation is memory-usage friendly and should be used while encoding\n * large files to base64\n *\n * @param {string} srcPath The full path to the file being encoded\n * @param {EncodingOptions} opts\n * @returns {Promise<Buffer>} base64-encoded content of the source file as memory buffer\n * @throws {Error} if there was an error while reading the source file\n * or the source file is too\n */\nasync function toInMemoryBase64 (srcPath, opts = {}) {\n  if (!(await fs.exists(srcPath)) || (await fs.stat(srcPath)).isDirectory()) {\n    throw new Error(`No such file: ${srcPath}`);\n  }\n\n  const {\n    maxSize = 1 * GiB,\n  } = opts;\n  const resultBuffers = [];\n  let resultBuffersSize = 0;\n  const resultWriteStream = new stream.Writable({\n    write: (buffer, encoding, next) => {\n      resultBuffers.push(buffer);\n      resultBuffersSize += buffer.length;\n      if (maxSize > 0 && resultBuffersSize > maxSize) {\n        resultWriteStream.emit('error', new Error(`The size of the resulting ` +\n          `buffer must not be greater than ${toReadableSizeString(maxSize)}`));\n      }\n      next();\n    },\n  });\n\n  const readerStream = fs.createReadStream(srcPath);\n  const base64EncoderStream = new Base64Encode();\n  const resultWriteStreamPromise = new B((resolve, reject) => {\n    resultWriteStream.once('error', (e) => {\n      readerStream.unpipe(base64EncoderStream);\n      base64EncoderStream.unpipe(resultWriteStream);\n      readerStream.destroy();\n      reject(e);\n    });\n    resultWriteStream.once('finish', resolve);\n  });\n  const readStreamPromise = new B((resolve, reject) => {\n    readerStream.once('close', resolve);\n    readerStream.once('error', (e) => reject(\n      new Error(`Failed to read '${srcPath}': ${e.message}`)));\n  });\n  readerStream.pipe(base64EncoderStream);\n  base64EncoderStream.pipe(resultWriteStream);\n\n  await B.all([readStreamPromise, resultWriteStreamPromise]);\n  return Buffer.concat(resultBuffers);\n}\n\n/**\n * @typedef LockFileOptions\n * @property {number} [timeout=120] The max time in seconds to wait for the lock\n * @property {boolean} [tryRecovery=false] Whether to try lock recovery if\n * the first attempt to acquire it timed out.\n */\n\n/**\n * Create an async function which, when called, will not proceed until a certain file is no\n * longer present on the system. This allows for preventing concurrent behavior across processes\n * using a known lockfile path.\n *\n * @template T\n * @param {string} lockFile The full path to the file used for the lock\n * @param {LockFileOptions} opts\n * @returns async function that takes another async function defining the locked\n * behavior\n */\nfunction getLockFileGuard (lockFile, opts = {}) {\n  const {\n    timeout = 120,\n    tryRecovery = false,\n  } = opts;\n\n  const lock = /** @type {(lockfile: string, opts: import('lockfile').Options)=>B<void>} */(B.promisify(_lockfile.lock));\n  const check = B.promisify(_lockfile.check);\n  const unlock = B.promisify(_lockfile.unlock);\n\n  /**\n   * @param {(...args: any[]) => T} behavior\n   * @returns {Promise<T>}\n   */\n  const guard = async (behavior) => {\n    let triedRecovery = false;\n    do {\n      try {\n        // if the lockfile doesn't exist, lock it synchronously to make sure no other call\n        // on the same spin of the event loop can also initiate a lock. If the lockfile does exist\n        // then just use the regular async 'lock' method which will wait on the lock.\n        if (_lockfile.checkSync(lockFile)) {\n          await lock(lockFile, {wait: timeout * 1000});\n        } else {\n          _lockfile.lockSync(lockFile);\n        }\n        break;\n      } catch (e) {\n        if (_.includes(e.message, 'EEXIST') && tryRecovery && !triedRecovery) {\n          // There could be cases where a process has been forcefully terminated\n          // without a chance to clean up pending locks: https://github.com/npm/lockfile/issues/26\n          _lockfile.unlockSync(lockFile);\n          triedRecovery = true;\n          continue;\n        }\n        throw new Error(`Could not acquire lock on '${lockFile}' after ${timeout}s. ` +\n          `Original error: ${e.message}`);\n      }\n    // eslint-disable-next-line no-constant-condition\n    } while (true);\n    try {\n      return await behavior();\n    } finally {\n      // whether the behavior succeeded or not, get rid of the lock\n      await unlock(lockFile);\n    }\n  };\n\n  guard.check = async () => await check(lockFile);\n\n  return guard;\n}\n\nexport {\n  hasValue, escapeSpace, escapeSpecialChars, localIp, cancellableDelay,\n  multiResolve, safeJsonParse, wrapElement, unwrapElement, filterObject,\n  toReadableSizeString, isSubPath, W3C_WEB_ELEMENT_IDENTIFIER,\n  isSameDestination, compareVersions, coerceVersion, quote, unleakString,\n  jsonStringify, pluralize, GiB, MiB, KiB, toInMemoryBase64,\n  uuidV1, uuidV3, uuidV4, uuidV5, shellParse, getLockFileGuard\n};\n"]}

package/build/lib/zip.d.ts

@@ -0,0 +1,180 @@
+declare namespace _default {
+    export { extractAllTo };
+    export { readEntries };
+    export { toInMemoryZip };
+    export { assertValidZip };
+    export { toArchive };
+}
+export default _default;
+export type ExtractAllOptions = {
+    /**
+     * The encoding to use for extracted file names.
+     * For ZIP archives created on MacOS it is usually expected to be `utf8`.
+     * By default it is autodetected based on the entry metadata and is only needed to be set explicitly
+     * if the particular archive does not comply to the standards, which leads to corrupted file names
+     * after extraction. Only applicable if system unzip binary is NOT being used.
+     */
+    fileNamesEncoding: string | null;
+    /**
+     * [false] If true, attempt to use system unzip; if this fails,
+     * fallback to the JS unzip implementation.
+     */
+    useSystemUnzip: boolean | null;
+};
+export type ZipEntry = {
+    /**
+     * The actual entry instance
+     */
+    entry: yauzl.Entry;
+    /**
+     * An async function, which accepts one parameter.
+     * This parameter contains the destination folder path to which this function is going to extract the entry.
+     */
+    extractEntryTo: Function;
+};
+export type ZipOptions = {
+    /**
+     * [false] Whether to encode
+     * the resulting archive to a base64-encoded string
+     */
+    encodeToBase64: boolean;
+    /**
+     * [true] Whether to log the actual
+     * archiver performance
+     */
+    isMetered: boolean;
+    /**
+     * [1073741824] The maximum size of
+     * the resulting archive in bytes. This is set to 1GB by default, because
+     * Appium limits the maximum HTTP body size to 1GB. Also, the NodeJS heap
+     * size must be enough to keep the resulting object (usually this size is
+     * limited to 1.4 GB)
+     */
+    maxSize: number;
+    /**
+     * [9] The compression level. The maximum
+     * level is 9 (the best compression, worst performance). The minimum
+     * compression level is 0 (no compression).
+     */
+    level: number;
+};
+export type ZipCompressionOptions = {
+    /**
+     * [9] - Compression level in range 0..9
+     * (greater numbers mean better compression, but longer processing time)
+     */
+    level: number;
+};
+export type ZipSourceOptions = {
+    /**
+     * ['**\/*'] - GLOB pattern for compression
+     */
+    pattern: string;
+    /**
+     * - The source root folder (the parent folder of
+     * the destination file by default)
+     */
+    cwd: string;
+    /**
+     * - The list of ignored patterns
+     */
+    ignore?: string[] | undefined;
+};
+/**
+ * @typedef ExtractAllOptions
+ * @property {?string} fileNamesEncoding The encoding to use for extracted file names.
+ * For ZIP archives created on MacOS it is usually expected to be `utf8`.
+ * By default it is autodetected based on the entry metadata and is only needed to be set explicitly
+ * if the particular archive does not comply to the standards, which leads to corrupted file names
+ * after extraction. Only applicable if system unzip binary is NOT being used.
+ * @property {?boolean} useSystemUnzip [false] If true, attempt to use system unzip; if this fails,
+ * fallback to the JS unzip implementation.
+ */
+/**
+ * Extract zipfile to a directory
+ *
+ * @param {string} zipFilePath The full path to the source ZIP file
+ * @param {string} destDir The full path to the destination folder
+ * @param {ExtractAllOptions} [opts]
+ */
+export function extractAllTo(zipFilePath: string, destDir: string, opts?: ExtractAllOptions | undefined): Promise<void>;
+/**
+ * @typedef ZipEntry
+ * @property {yauzl.Entry} entry The actual entry instance
+ * @property {function} extractEntryTo An async function, which accepts one parameter.
+ * This parameter contains the destination folder path to which this function is going to extract the entry.
+ */
+/**
+ * Get entries for a zip folder
+ *
+ * @param {string} zipFilePath The full path to the source ZIP file
+ * @param {function} onEntry Callback when entry is read.
+ * The callback is expected to accept one argument of ZipEntry type.
+ * The iteration through the source zip file will bi terminated as soon as
+ * the result of this function equals to `false`.
+ */
+export function readEntries(zipFilePath: string, onEntry: Function): Promise<any>;
+/**
+ * @typedef ZipOptions
+ * @property {boolean} encodeToBase64 [false] Whether to encode
+ * the resulting archive to a base64-encoded string
+ * @property {boolean} isMetered [true] Whether to log the actual
+ * archiver performance
+ * @property {number} maxSize [1073741824] The maximum size of
+ * the resulting archive in bytes. This is set to 1GB by default, because
+ * Appium limits the maximum HTTP body size to 1GB. Also, the NodeJS heap
+ * size must be enough to keep the resulting object (usually this size is
+ * limited to 1.4 GB)
+ * @property {number} level [9] The compression level. The maximum
+ * level is 9 (the best compression, worst performance). The minimum
+ * compression level is 0 (no compression).
+ */
+/**
+ * Converts contents of local directory to an in-memory .zip buffer
+ *
+ * @param {string} srcPath The full path to the folder or file being zipped
+ * @param {ZipOptions} opts Zipping options
+ * @returns {Promise<Buffer>} Zipped (and encoded if `encodeToBase64` is truthy)
+ * content of the source path as memory buffer
+ * @throws {Error} if there was an error while reading the source
+ * or the source is too big
+ */
+export function toInMemoryZip(srcPath: string, opts?: ZipOptions): Promise<Buffer>;
+/**
+ * Extract a single zip entry to a directory
+ *
+ * @param {yauzl.ZipFile} zipFile The source ZIP stream
+ * @param {yauzl.Entry} entry The entry instance
+ * @param {string} destDir The full path to the destination folder
+ */
+export function _extractEntryTo(zipFile: yauzl.ZipFile, entry: yauzl.Entry, destDir: string): Promise<[any, any] | undefined>;
+/**
+ * Verifies whether the given file is a valid ZIP archive
+ *
+ * @param {string} filePath - Full path to the file
+ * @throws {Error} If the file does not exist or is not a valid ZIP archive
+ */
+export function assertValidZip(filePath: string): Promise<boolean>;
+/**
+ * @typedef ZipCompressionOptions
+ * @property {number} level [9] - Compression level in range 0..9
+ * (greater numbers mean better compression, but longer processing time)
+ */
+/**
+ * @typedef ZipSourceOptions
+ * @property {string} pattern ['**\/*'] - GLOB pattern for compression
+ * @property {string} cwd - The source root folder (the parent folder of
+ * the destination file by default)
+ * @property {string[]} [ignore] - The list of ignored patterns
+ */
+/**
+ * Creates an archive based on the given glob pattern
+ *
+ * @param {string} dstPath - The resulting archive path
+ * @param {ZipSourceOptions} src - Source options
+ * @param {ZipCompressionOptions} opts - Compression options
+ * @throws {Error} If there was an error while creating the archive
+ */
+export function toArchive(dstPath: string, src?: ZipSourceOptions, opts?: ZipCompressionOptions): Promise<any>;
+import yauzl from "yauzl";
+//# sourceMappingURL=zip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../../lib/zip.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;uBAsLe,MAAM;;;;;oBAKN,OAAO;;;;;;WAwHR,MAAM,KAAK;;;;;;;;;;;;oBAyCX,OAAO;;;;;eAEP,OAAO;;;;;;;;aAEP,MAAM;;;;;;WAKN,MAAM;;;;;;;WAmIN,MAAM;;;;;;aAMN,MAAM;;;;;SACN,MAAM;;;;;;AA3TpB;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,0CAJW,MAAM,WACN,MAAM,uDAuBhB;AAuFD;;;;;GAKG;AAEH;;;;;;;;GAQG;AACH,yCANW,MAAM,mCA6BhB;AAED;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH,uCAPW,MAAM,SACN,UAAU,GACR,QAAQ,MAAM,CAAC,CAuF3B;AAlMD;;;;;;GAMG;AACH,yCAJW,MAAM,OAAO,SACb,MAAM,KAAK,WACX,MAAM,mCAsChB;AAyJD;;;;;GAKG;AACH,yCAHW,MAAM,oBAyBhB;AAED;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH,mCALW,MAAM,QACN,gBAAgB,SAChB,qBAAqB,gBAgC/B"}