@appium/support 2.56.1 → 2.57.0

package/build/lib/env.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Returns `true` if appium is installed as a dependency of a local package at `cwd`.
+ *
+ * The following special cases are considered:
+ *
+ * - If `resolved` starts with `file:`, then `cwd` likely points to `appium-monorepo`, and (for now) we expect `APPIUM_HOME` to be the default.
+ * - If the `version` begins with `0` or `1`, we're looking at an old version of `appium` (not this one!)
+ *
+ * Note that we are _not_ performing the check "is the currently running Appium the same one as found in the list of dependencies", because I'm not sure it actually matters (assuming the versions are compatible).
+ * Regardless we may want to make this more robust in the future, as we hit edge cases.
+ *
+ * _Also_ note that if `appium` appears as a dependency in `package.json` _but it is not yet installed_ this function will resolve `false`.  This may not be exactly what we want.
+ *
+ * @param {string} cwd
+ * @returns {Promise<boolean>}
+ */
+export function hasAppiumDependency(cwd: string): Promise<boolean>;
+/**
+ * Path to the default `APPIUM_HOME` dir (`~/.appium`).
+ * @type {string}
+ */
+export const DEFAULT_APPIUM_HOME: string;
+/**
+ * Basename of extension manifest file.
+ * @type {string}
+ */
+export const MANIFEST_BASENAME: string;
+/**
+ * Relative path to extension manifest file from `APPIUM_HOME`.
+ * @type {string}
+ */
+export const MANIFEST_RELATIVE_PATH: string;
+/**
+ * Read a `package.json` in dir `cwd`.  If none found, return `undefined`.
+ */
+export const readPackageInDir: ((cwd: string) => Promise<import('read-pkg').NormalizedPackageJson | undefined>) & _.MemoizedFunction;
+/**
+ * Determines location of Appium's "home" dir
+ *
+ * - If `APPIUM_HOME` is set in the environment, use that
+ * - If we have an `extensions.yaml` in {@linkcode DEFAULT_APPIUM_HOME}, then use that.
+ * - If we find a `package.json` in or above `cwd` and {@linkcode shouldUseCwdForAppiumHome} returns `true`, then use the directory containing the `package.json`.
+ */
+export const resolveAppiumHome: ((cwd?: string | undefined) => Promise<string>) & _.MemoizedFunction;
+/**
+ * Figure out manifest path based on `appiumHome`.
+ *
+ * The assumption is that, if `appiumHome` has been provided, it was resolved via {@link resolveAppiumHome `resolveAppiumHome()`}!  If unsure,
+ * don't pass a parameter and let `resolveAppiumHome()` handle it.
+ */
+export const resolveManifestPath: ((appiumHome?: string | undefined) => Promise<string>) & _.MemoizedFunction;
+export type NormalizedPackageJson = import('read-pkg').NormalizedPackageJson;
+import _ from "lodash";
+//# sourceMappingURL=env.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../lib/env.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;GAeG;AACH,yCAHW,MAAM,GACJ,QAAQ,OAAO,CAAC,CAqC5B;AA1ED;;;GAGG;AACH,kCAFU,MAAM,CAEsD;AAEtE;;;GAGG;AACH,gCAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,qCAFU,MAAM,CAOd;AAuDF;;GAEG;AACH,sCAGa,MAAM,KACJ,QAAQ,OAAO,UAAU,EAAE,qBAAqB,GAAC,SAAS,CAAC,uBAKxE;AAEF;;;;;;GAMG;AACH,+DAGe,QAAQ,MAAM,CAAC,uBA+B5B;AAEF;;;;;GAKG;AACH,wEAGe,QAAQ,MAAM,CAAC,uBAO5B;oCAGW,OAAO,UAAU,EAAE,qBAAqB"}

package/build/lib/fs.d.ts

@@ -0,0 +1,221 @@
+/// <reference types="node" />
+export default fs;
+/**
+ * The callback function which will be called during the directory walking
+ */
+export type WalkDirCallback = (itemPath: string, isDirectory: boolean) => boolean;
+export type glob = typeof glob;
+export type mv = typeof mv;
+export namespace fs {
+    /**
+     * Resolves `true` if `path` is _readable_, which differs from Node.js' default behavior of "can we see it?"
+     * @param {import('fs').PathLike} path
+     * @returns {Promise<boolean>}
+     */
+    export function hasAccess(path: import("fs").PathLike): Promise<boolean>;
+    /**
+     * Resolves `true` if `path` is _readable_, which differs from Node.js' default behavior of "can we see it?"
+     * @param {import('fs').PathLike} path
+     * @returns {Promise<boolean>}
+     */
+    export function hasAccess(path: import("fs").PathLike): Promise<boolean>;
+    /**
+     * Alias for {@linkcode fs.hasAccess}
+     * @param {import('fs').PathLike} path
+     */
+    export function exists(path: import("fs").PathLike): Promise<boolean>;
+    /**
+     * Alias for {@linkcode fs.hasAccess}
+     * @param {import('fs').PathLike} path
+     */
+    export function exists(path: import("fs").PathLike): Promise<boolean>;
+    export function rimraf(dirpath: string, opts?: rimrafIdx.Options | undefined): Promise<void>;
+    export const rimrafSync: typeof rimrafIdx.sync;
+    /**
+     * Like Node.js' `fsPromises.mkdir()`, but will _not_ reject if the directory already exists.
+     *
+     * @param {string|Buffer|URL} filepath
+     * @param {import('fs').MakeDirectoryOptions} [opts]
+     * @returns {Promise<string|undefined>}
+     * @see https://nodejs.org/api/fs.html#fspromisesmkdirpath-options
+     */
+    export function mkdir(filepath: string | Buffer | URL, opts?: import("fs").MakeDirectoryOptions | undefined): Promise<string | undefined>;
+    /**
+     * Like Node.js' `fsPromises.mkdir()`, but will _not_ reject if the directory already exists.
+     *
+     * @param {string|Buffer|URL} filepath
+     * @param {import('fs').MakeDirectoryOptions} [opts]
+     * @returns {Promise<string|undefined>}
+     * @see https://nodejs.org/api/fs.html#fspromisesmkdirpath-options
+     */
+    export function mkdir(filepath: string | Buffer | URL, opts?: import("fs").MakeDirectoryOptions | undefined): Promise<string | undefined>;
+    /**
+     * Copies files _and entire directories_
+     * @param {string} source - Source to copy
+     * @param {string} destination - Destination to copy to
+     * @param {ncp.Options} [opts] - Additional arguments to pass to `ncp`
+     * @see https://npm.im/ncp
+     * @returns {Promise<void>}
+     */
+    export function copyFile(source: string, destination: string, opts?: ncp.Options | undefined): Promise<void>;
+    /**
+     * Copies files _and entire directories_
+     * @param {string} source - Source to copy
+     * @param {string} destination - Destination to copy to
+     * @param {ncp.Options} [opts] - Additional arguments to pass to `ncp`
+     * @see https://npm.im/ncp
+     * @returns {Promise<void>}
+     */
+    export function copyFile(source: string, destination: string, opts?: ncp.Options | undefined): Promise<void>;
+    /**
+     * Create an MD5 hash of a file.
+     * @param {import('fs').PathLike} filePath
+     * @returns {Promise<string>}
+     */
+    export function md5(filePath: import("fs").PathLike): Promise<string>;
+    /**
+     * Create an MD5 hash of a file.
+     * @param {import('fs').PathLike} filePath
+     * @returns {Promise<string>}
+     */
+    export function md5(filePath: import("fs").PathLike): Promise<string>;
+    export function mv_1(from: string, to: string, opts?: mv.Options | undefined): B<void>;
+    export { mv_1 as mv };
+    export { which };
+    export function glob_1(pattern: string, opts?: glob.IOptions | undefined): B<string[]>;
+    export { glob_1 as glob };
+    export { sanitize as sanitizeName };
+    /**
+     * Create a hex digest of some file at `filePath`
+     * @param {import('fs').PathLike} filePath
+     * @param {string} [algorithm]
+     * @returns {Promise<string>}
+     */
+    export function hash(filePath: import("fs").PathLike, algorithm?: string | undefined): Promise<string>;
+    /**
+     * Create a hex digest of some file at `filePath`
+     * @param {import('fs').PathLike} filePath
+     * @param {string} [algorithm]
+     * @returns {Promise<string>}
+     */
+    export function hash(filePath: import("fs").PathLike, algorithm?: string | undefined): Promise<string>;
+    /**
+     * Returns an `Walker` instance, which is a readable stream (and thusly an async iterator).
+     *
+     * @param {string} dir - Dir to start walking at
+     * @param {import('klaw').Options} [opts]
+     * @returns {import('klaw').Walker}
+     * @see https://www.npmjs.com/package/klaw
+     */
+    export function walk(dir: string, opts?: klaw.Options | undefined): klaw.Walker;
+    /**
+     * Returns an `Walker` instance, which is a readable stream (and thusly an async iterator).
+     *
+     * @param {string} dir - Dir to start walking at
+     * @param {import('klaw').Options} [opts]
+     * @returns {import('klaw').Walker}
+     * @see https://www.npmjs.com/package/klaw
+     */
+    export function walk(dir: string, opts?: klaw.Options | undefined): klaw.Walker;
+    /**
+     * Recursively create a directory.
+     * @param {import('fs').PathLike} dir
+     * @returns {Promise<string|undefined>}
+     */
+    export function mkdirp(dir: import("fs").PathLike): Promise<string | undefined>;
+    /**
+     * Recursively create a directory.
+     * @param {import('fs').PathLike} dir
+     * @returns {Promise<string|undefined>}
+     */
+    export function mkdirp(dir: import("fs").PathLike): Promise<string | undefined>;
+    /**
+     * Walks a directory given according to the parameters given. The callback will be invoked with a path joined with the dir parameter
+     * @param {string} dir Directory path where we will start walking
+     * @param {boolean} recursive Set it to true if you want to continue walking sub directories
+     * @param {WalkDirCallback} callback The callback to be called when a new path is found
+     * @throws {Error} If the `dir` parameter contains a path to an invalid folder
+     * @returns {Promise<string?>} returns the found path or null if the item was not found
+     */
+    export function walkDir(dir: string, recursive: boolean, callback: WalkDirCallback): Promise<string | null>;
+    /**
+     * Walks a directory given according to the parameters given. The callback will be invoked with a path joined with the dir parameter
+     * @param {string} dir Directory path where we will start walking
+     * @param {boolean} recursive Set it to true if you want to continue walking sub directories
+     * @param {WalkDirCallback} callback The callback to be called when a new path is found
+     * @throws {Error} If the `dir` parameter contains a path to an invalid folder
+     * @returns {Promise<string?>} returns the found path or null if the item was not found
+     */
+    export function walkDir(dir: string, recursive: boolean, callback: WalkDirCallback): Promise<string | null>;
+    /**
+     * Reads the closest `package.json` file from absolute path `dir`.
+     * @param {string} dir - Directory to search from
+     * @param {import('read-pkg').Options} [opts] - Additional options for `read-pkg`
+     * @throws {Error} If there were problems finding or reading a `package.json` file
+     * @returns {object} A parsed `package.json`
+     */
+    export function readPackageJsonFrom(dir: string, opts?: readPkg.Options | undefined): any;
+    /**
+     * Reads the closest `package.json` file from absolute path `dir`.
+     * @param {string} dir - Directory to search from
+     * @param {import('read-pkg').Options} [opts] - Additional options for `read-pkg`
+     * @throws {Error} If there were problems finding or reading a `package.json` file
+     * @returns {object} A parsed `package.json`
+     */
+    export function readPackageJsonFrom(dir: string, opts?: readPkg.Options | undefined): any;
+    /**
+     * Finds the project root directory from `dir`.
+     * @param {string} dir - Directory to search from
+     * @throws {TypeError} If `dir` is not a nonempty string or relative path
+     * @throws {Error} If there were problems finding the project root
+     * @returns {string} The closeset parent dir containing `package.json`
+     */
+    export function findRoot(dir: string): string;
+    /**
+     * Finds the project root directory from `dir`.
+     * @param {string} dir - Directory to search from
+     * @throws {TypeError} If `dir` is not a nonempty string or relative path
+     * @throws {Error} If there were problems finding the project root
+     * @returns {string} The closeset parent dir containing `package.json`
+     */
+    export function findRoot(dir: string): string;
+    export const access: typeof fsPromises.access;
+    export const appendFile: typeof fsPromises.appendFile;
+    export const chmod: typeof fsPromises.chmod;
+    export const close: (arg1: number) => B<any>;
+    export { constants };
+    export { createWriteStream };
+    export { createReadStream };
+    export const lstat: typeof fsPromises.lstat;
+    export const open: (path: import("fs").PathLike, flags: import("fs").OpenMode, mode?: import("fs").Mode | undefined) => Promise<number>;
+    export const openFile: typeof fsPromises.open;
+    export const readdir: typeof fsPromises.readdir;
+    export function read<TBuffer extends NodeJS.ArrayBufferView>(arg1: number, arg2: TBuffer, arg3: number, arg4: number, arg5: import("fs").ReadPosition | null): B<number>;
+    export const readFile: typeof fsPromises.readFile;
+    export const readlink: typeof fsPromises.readlink;
+    export const realpath: typeof fsPromises.realpath;
+    export const rename: typeof fsPromises.rename;
+    export const stat: typeof fsPromises.stat;
+    export const symlink: typeof fsPromises.symlink;
+    export const unlink: typeof fsPromises.unlink;
+    export const write: (arg1: number, arg2: string) => B<number>;
+    export const writeFile: typeof fsPromises.writeFile;
+    export const F_OK: number;
+    export const R_OK: number;
+    export const W_OK: number;
+    export const X_OK: number;
+}
+import glob from "glob";
+import mv from "mv";
+import rimrafIdx from "rimraf";
+import ncp from "ncp";
+import B from "bluebird";
+import which from "which";
+import sanitize from "sanitize-filename";
+import klaw from "klaw";
+import readPkg from "read-pkg";
+import { promises as fsPromises } from "fs";
+import { constants } from "fs";
+import { createWriteStream } from "fs";
+import { createReadStream } from "fs";
+//# sourceMappingURL=fs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../lib/fs.js"],"names":[],"mappings":";;;;;yCA2UW,MAAM,eACN,OAAO,KACN,OAAO;;;;IArTjB;;;;OAIG;IACH,yEAOC;IAZD;;;;OAIG;IACH,yEAOC;IAED;;;OAGG;IACH,sEAEC;IAND;;;OAGG;IACH,sEAEC;IAMkB,6FAAmE;;IAQtF;;;;;;;OAOG;IACH,0IAQC;IAhBD;;;;;;;OAOG;IACH,0IAQC;IACD;;;;;;;OAOG;IACH,6GAKC;IAbD;;;;;;;OAOG;IACH,6GAKC;IAED;;;;OAIG;IACH,sEAEC;IAPD;;;;OAIG;IACH,sEAEC;IAKc,uFAAwD;;;IAYtD,uFAAsD;;;IAQvE;;;;;OAKG;IACH,uGASC;IAfD;;;;;OAKG;IACH,uGASC;IAED;;;;;;;OAOG;IACH,gFAEC;IAVD;;;;;;;OAOG;IACH,gFAEC;IAED;;;;OAIG;IACH,gFAEC;IAPD;;;;OAIG;IACH,gFAEC;IAED;;;;;;;OAOG;IACH,4GAmEC;IA3ED;;;;;;;OAOG;IACH,4GAmEC;IACD;;;;;;OAMG;IACH,0FAQC;IAfD;;;;;;OAMG;IACH,0FAQC;IACD;;;;;;OAMG;IACH,8CASC;IAhBD;;;;;;OAMG;IACH,8CASC;;;;;;;;;;;;IAwEoqnB,yKAAkE"}

package/build/lib/fs.js

@@ -235,4 +235,4 @@ const fs = {
 exports.fs = fs;
 var _default = fs;
 exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/fs.js"],"names":["ncpAsync","B","promisify","ncp","findRootCached","_","memoize","pkgDir","sync","fs","hasAccess","path","fsPromises","access","constants","R_OK","err","exists","rimraf","rimrafSync","mkdir","filepath","opts","code","copyFile","source","destination","Error","md5","filePath","hash","mv","which","glob","sanitizeName","sanitize","algorithm","resolve","reject","fileHash","crypto","createHash","readStream","on","e","message","chunk","update","digest","walk","dir","mkdirp","recursive","walkDir","callback","isValidRoot","errMsg","stat","isDirectory","walker","fileCount","directoryCount","timer","Timer","start","lastFileProcessed","depthLimit","item","pause","stats","try","then","done","resume","catch","log","warn","file","finally","debug","getDuration","asMilliSeconds","toFixed","destroy","readPackageJsonFrom","cwd","findRoot","readPkg","isAbsolute","TypeError","result","appendFile","chmod","close","createWriteStream","createReadStream","lstat","open","openFile","readdir","read","readFile","readlink","realpath","rename","symlink","unlink","write","writeFile","F_OK","W_OK","X_OK"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport B from 'bluebird';\nimport crypto from 'crypto';\nimport { close, constants, createReadStream, createWriteStream, promises as fsPromises, read, write, open } from 'fs';\nimport glob from 'glob';\nimport klaw from 'klaw';\nimport _ from 'lodash';\nimport mv from 'mv';\nimport ncp from 'ncp';\nimport path from 'path';\nimport pkgDir from 'pkg-dir';\nimport readPkg from 'read-pkg';\nimport rimraf from 'rimraf';\nimport sanitize from 'sanitize-filename';\nimport which from 'which';\nimport log from './logger';\nimport Timer from './timing';\nimport { pluralize } from './util';\n\nconst ncpAsync = /** @type {(source: string, dest: string, opts: ncp.Options|undefined) => B<void>} */(B.promisify(ncp));\nconst findRootCached = _.memoize(pkgDir.sync);\n\nconst fs = {\n  /**\n   * Resolves `true` if `path` is _readable_, which differs from Node.js' default behavior of \"can we see it?\"\n   * @param {import('fs').PathLike} path\n   * @returns {Promise<boolean>}\n   */\n  async hasAccess (path) {\n    try {\n      await fsPromises.access(path, constants.R_OK);\n    } catch (err) {\n      return false;\n    }\n    return true;\n  },\n\n  /**\n   * Alias for {@linkcode fs.hasAccess}\n   * @param {import('fs').PathLike} path\n   */\n  async exists (path) {\n    return await fs.hasAccess(path);\n  },\n\n  /**\n   * Remove a directory and all its contents, recursively\n   * @todo Replace with `rm()` from `fs.promises` when Node.js v12 support is dropped.\n   */\n  rimraf: /** @type {(dirpath: string, opts?: rimraf.Options) => Promise<void>} */(B.promisify(rimraf)),\n\n  /**\n   * Alias of {@linkcode rimraf.sync}\n   * @todo Replace with `rmSync()` from `fs` when Node.js v12 support is dropped.\n   */\n  rimrafSync: rimraf.sync,\n\n  /**\n   * Like Node.js' `fsPromises.mkdir()`, but will _not_ reject if the directory already exists.\n   *\n   * @param {string|Buffer|URL} filepath\n   * @param {import('fs').MakeDirectoryOptions} [opts]\n   * @returns {Promise<string|undefined>}\n   * @see https://nodejs.org/api/fs.html#fspromisesmkdirpath-options\n   */\n  async mkdir (filepath, opts = {}) {\n    try {\n      return await fsPromises.mkdir(filepath, opts);\n    } catch (err) {\n      if (err?.code !== 'EEXIST') {\n        throw err;\n      }\n    }\n  },\n  /**\n   * Copies files _and entire directories_\n   * @param {string} source - Source to copy\n   * @param {string} destination - Destination to copy to\n   * @param {ncp.Options} [opts] - Additional arguments to pass to `ncp`\n   * @see https://npm.im/ncp\n   * @returns {Promise<void>}\n   */\n  async copyFile (source, destination, opts = {}) {\n    if (!await fs.hasAccess(source)) {\n      throw new Error(`The file at '${source}' does not exist or is not accessible`);\n    }\n    return await ncpAsync(source, destination, opts);\n  },\n\n  /**\n   * Create an MD5 hash of a file.\n   * @param {import('fs').PathLike} filePath\n   * @returns {Promise<string>}\n   */\n  async md5 (filePath) {\n    return await fs.hash(filePath, 'md5');\n  },\n\n  /**\n   * Move a file\n   */\n  mv: /** @type {(from: string, to: string, opts?: mv.Options) => B<void>} */(B.promisify(mv)),\n\n  /**\n   * Find path to an executable in system `PATH`\n   * @see https://github.com/npm/node-which\n   */\n  which,\n\n  /**\n   * Given a glob pattern, resolve with list of files matching that pattern\n   * @see https://github.com/isaacs/node-glob\n   */\n  glob: /** @type {(pattern: string, opts?: glob.IOptions) => B<string[]>} */(B.promisify(glob)),\n\n  /**\n   * Sanitize a filename\n   * @see https://github.com/parshap/node-sanitize-filename\n   */\n  sanitizeName: sanitize,\n\n  /**\n   * Create a hex digest of some file at `filePath`\n   * @param {import('fs').PathLike} filePath\n   * @param {string} [algorithm]\n   * @returns {Promise<string>}\n   */\n  async hash (filePath, algorithm = 'sha1') {\n    return await new B((resolve, reject) => {\n      const fileHash = crypto.createHash(algorithm);\n      const readStream = createReadStream(filePath);\n      readStream.on('error', (e) => reject(\n        new Error(`Cannot calculate ${algorithm} hash for '${filePath}'. Original error: ${e.message}`)));\n      readStream.on('data', (chunk) => fileHash.update(chunk));\n      readStream.on('end', () => resolve(fileHash.digest('hex')));\n    });\n  },\n\n  /**\n   * Returns an `Walker` instance, which is a readable stream (and thusly an async iterator).\n   *\n   * @param {string} dir - Dir to start walking at\n   * @param {import('klaw').Options} [opts]\n   * @returns {import('klaw').Walker}\n   * @see https://www.npmjs.com/package/klaw\n   */\n  walk (dir, opts) {\n    return klaw(dir, opts);\n  },\n\n  /**\n   * Recursively create a directory.\n   * @param {import('fs').PathLike} dir\n   * @returns {Promise<string|undefined>}\n   */\n  async mkdirp (dir) {\n    return await fs.mkdir(dir, {recursive: true});\n  },\n\n  /**\n   * Walks a directory given according to the parameters given. The callback will be invoked with a path joined with the dir parameter\n   * @param {string} dir Directory path where we will start walking\n   * @param {boolean} recursive Set it to true if you want to continue walking sub directories\n   * @param {WalkDirCallback} callback The callback to be called when a new path is found\n   * @throws {Error} If the `dir` parameter contains a path to an invalid folder\n   * @returns {Promise<string?>} returns the found path or null if the item was not found\n   */\n  async walkDir (dir, recursive, callback) { //eslint-disable-line promise/prefer-await-to-callbacks\n    let isValidRoot = false;\n    let errMsg = null;\n    try {\n      isValidRoot = (await fs.stat(dir)).isDirectory();\n    } catch (e) {\n      errMsg = e.message;\n    }\n    if (!isValidRoot) {\n      throw Error(`'${dir}' is not a valid root directory` + (errMsg ? `. Original error: ${errMsg}` : ''));\n    }\n\n    let walker;\n    let fileCount = 0;\n    let directoryCount = 0;\n    const timer = new Timer().start();\n    return await new B(function (resolve, reject) {\n      let lastFileProcessed = B.resolve();\n      walker = klaw(dir, {\n        depthLimit: recursive ? -1 : 0,\n      });\n      walker.on('data', function (item) {\n        walker.pause();\n\n        if (!item.stats.isDirectory()) {\n          fileCount++;\n        } else {\n          directoryCount++;\n        }\n\n        // eslint-disable-next-line promise/prefer-await-to-callbacks\n        lastFileProcessed = B.try(async () => await callback(item.path, item.stats.isDirectory()))\n          .then(function (done = false) {\n            if (done) {\n              resolve(item.path);\n            } else {\n              walker.resume();\n            }\n          })\n          .catch(reject);\n      })\n      .on('error', function (err, item) {\n        log.warn(`Got an error while walking '${item.path}': ${err.message}`);\n        // klaw cannot get back from an ENOENT error\n        if (err.code === 'ENOENT') {\n          log.warn('All files may not have been accessed');\n          reject(err);\n        }\n      })\n      .on('end', function () {\n        lastFileProcessed\n          .then((file) => {\n            resolve(/** @type {string|undefined} */(file) ?? null);\n          })\n          .catch(function (err) {\n            log.warn(`Unexpected error: ${err.message}`);\n            reject(err);\n          });\n      });\n    }).finally(function () {\n      log.debug(`Traversed ${pluralize('directory', directoryCount, true)} ` +\n        `and ${pluralize('file', fileCount, true)} ` +\n        `in ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);\n      if (walker) {\n        walker.destroy();\n      }\n    });\n  },\n  /**\n   * Reads the closest `package.json` file from absolute path `dir`.\n   * @param {string} dir - Directory to search from\n   * @param {import('read-pkg').Options} [opts] - Additional options for `read-pkg`\n   * @throws {Error} If there were problems finding or reading a `package.json` file\n   * @returns {object} A parsed `package.json`\n   */\n  readPackageJsonFrom (dir, opts = {}) {\n    const cwd = fs.findRoot(dir);\n    try {\n      return readPkg.sync({...opts, cwd});\n    } catch (err) {\n      err.message = `Failed to read a \\`package.json\\` from dir \\`${dir}\\`:\\n\\n${err.message}`;\n      throw err;\n    }\n  },\n  /**\n   * Finds the project root directory from `dir`.\n   * @param {string} dir - Directory to search from\n   * @throws {TypeError} If `dir` is not a nonempty string or relative path\n   * @throws {Error} If there were problems finding the project root\n   * @returns {string} The closeset parent dir containing `package.json`\n   */\n  findRoot (dir) {\n    if (!dir || !path.isAbsolute(dir)) {\n      throw new TypeError('`findRoot()` must be provided a non-empty, absolute path');\n    }\n    const result = findRootCached(dir);\n    if (!result) {\n      throw new Error(`\\`findRoot()\\` could not find \\`package.json\\` from ${dir}`);\n    }\n    return result;\n  },\n\n  // add the supported `fs` functions\n  access: fsPromises.access,\n  appendFile: fsPromises.appendFile,\n  chmod: fsPromises.chmod,\n  close: B.promisify(close),\n  constants,\n  createWriteStream,\n  createReadStream,\n  lstat: fsPromises.lstat,\n  /**\n   * Warning: this is a promisified {@linkcode open fs.open}.\n   * It resolves w/a file descriptor instead of a {@linkcode fsPromises.FileHandle FileHandle} object, as {@linkcode fsPromises.open} does. Use {@linkcode fs.openFile} if you want a `FileHandle`.\n   */\n  open: B.promisify(open),\n  openFile: fsPromises.open,\n  readdir: fsPromises.readdir,\n  read: B.promisify(read),\n  readFile: fsPromises.readFile,\n  readlink: fsPromises.readlink,\n  realpath: fsPromises.realpath,\n  rename: fsPromises.rename,\n  stat: fsPromises.stat,\n  symlink: fsPromises.symlink,\n  unlink: fsPromises.unlink,\n  write: B.promisify(write),\n  writeFile: fsPromises.writeFile,\n\n  // deprecated props\n\n  /**\n   * Use `constants.F_OK` instead.\n   * @deprecated\n   */\n  F_OK: constants.F_OK,\n\n  /**\n   * Use `constants.R_OK` instead.\n   * @deprecated\n   */\n  R_OK: constants.R_OK,\n\n  /**\n   * Use `constants.W_OK` instead.\n   * @deprecated\n   */\n  W_OK: constants.W_OK,\n\n  /**\n   * Use `constants.X_OK` instead.\n   * @deprecated\n   */\n  X_OK: constants.X_OK\n};\n\nexport { fs };\nexport default fs;\n\n/**\n * The callback function which will be called during the directory walking\n * @callback WalkDirCallback\n * @param {string} itemPath The path of the file or folder\n * @param {boolean} isDirectory Shows if it is a directory or a file\n * @return {boolean} return true if you want to stop walking\n*/\n\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/fs.js"],"names":["ncpAsync","B","promisify","ncp","findRootCached","_","memoize","pkgDir","sync","fs","hasAccess","path","fsPromises","access","constants","R_OK","err","exists","rimraf","rimrafIdx","rimrafSync","mkdir","filepath","opts","code","copyFile","source","destination","Error","md5","filePath","hash","mv","which","glob","sanitizeName","sanitize","algorithm","resolve","reject","fileHash","crypto","createHash","readStream","on","e","message","chunk","update","digest","walk","dir","mkdirp","recursive","walkDir","callback","isValidRoot","errMsg","stat","isDirectory","walker","fileCount","directoryCount","timer","Timer","start","lastFileProcessed","depthLimit","item","pause","stats","try","then","done","resume","catch","log","warn","file","finally","debug","getDuration","asMilliSeconds","toFixed","destroy","readPackageJsonFrom","cwd","findRoot","readPkg","isAbsolute","TypeError","result","appendFile","chmod","close","createWriteStream","createReadStream","lstat","open","openFile","readdir","read","readFile","readlink","realpath","rename","symlink","unlink","write","writeFile","F_OK","W_OK","X_OK"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport B from 'bluebird';\nimport crypto from 'crypto';\nimport { close, constants, createReadStream, createWriteStream, promises as fsPromises, read, write, open } from 'fs';\nimport glob from 'glob';\nimport klaw from 'klaw';\nimport _ from 'lodash';\nimport mv from 'mv';\nimport ncp from 'ncp';\nimport path from 'path';\nimport pkgDir from 'pkg-dir';\nimport readPkg from 'read-pkg';\nimport rimrafIdx from 'rimraf';\nimport sanitize from 'sanitize-filename';\nimport which from 'which';\nimport log from './logger';\nimport Timer from './timing';\nimport { pluralize } from './util';\n\nconst ncpAsync = /** @type {(source: string, dest: string, opts: ncp.Options|undefined) => B<void>} */(B.promisify(ncp));\nconst findRootCached = _.memoize(pkgDir.sync);\n\nconst fs = {\n  /**\n   * Resolves `true` if `path` is _readable_, which differs from Node.js' default behavior of \"can we see it?\"\n   * @param {import('fs').PathLike} path\n   * @returns {Promise<boolean>}\n   */\n  async hasAccess (path) {\n    try {\n      await fsPromises.access(path, constants.R_OK);\n    } catch (err) {\n      return false;\n    }\n    return true;\n  },\n\n  /**\n   * Alias for {@linkcode fs.hasAccess}\n   * @param {import('fs').PathLike} path\n   */\n  async exists (path) {\n    return await fs.hasAccess(path);\n  },\n\n  /**\n   * Remove a directory and all its contents, recursively\n   * @todo Replace with `rm()` from `fs.promises` when Node.js v12 support is dropped.\n   */\n  rimraf: /** @type {(dirpath: string, opts?: import('rimraf').Options) => Promise<void>} */(B.promisify(rimrafIdx)),\n\n  /**\n   * Alias of {@linkcode rimrafIdx.sync}\n   * @todo Replace with `rmSync()` from `fs` when Node.js v12 support is dropped.\n   */\n  rimrafSync: rimrafIdx.sync,\n\n  /**\n   * Like Node.js' `fsPromises.mkdir()`, but will _not_ reject if the directory already exists.\n   *\n   * @param {string|Buffer|URL} filepath\n   * @param {import('fs').MakeDirectoryOptions} [opts]\n   * @returns {Promise<string|undefined>}\n   * @see https://nodejs.org/api/fs.html#fspromisesmkdirpath-options\n   */\n  async mkdir (filepath, opts = {}) {\n    try {\n      return await fsPromises.mkdir(filepath, opts);\n    } catch (err) {\n      if (err?.code !== 'EEXIST') {\n        throw err;\n      }\n    }\n  },\n  /**\n   * Copies files _and entire directories_\n   * @param {string} source - Source to copy\n   * @param {string} destination - Destination to copy to\n   * @param {ncp.Options} [opts] - Additional arguments to pass to `ncp`\n   * @see https://npm.im/ncp\n   * @returns {Promise<void>}\n   */\n  async copyFile (source, destination, opts = {}) {\n    if (!await fs.hasAccess(source)) {\n      throw new Error(`The file at '${source}' does not exist or is not accessible`);\n    }\n    return await ncpAsync(source, destination, opts);\n  },\n\n  /**\n   * Create an MD5 hash of a file.\n   * @param {import('fs').PathLike} filePath\n   * @returns {Promise<string>}\n   */\n  async md5 (filePath) {\n    return await fs.hash(filePath, 'md5');\n  },\n\n  /**\n   * Move a file\n   */\n  mv: /** @type {(from: string, to: string, opts?: mv.Options) => B<void>} */(B.promisify(mv)),\n\n  /**\n   * Find path to an executable in system `PATH`\n   * @see https://github.com/npm/node-which\n   */\n  which,\n\n  /**\n   * Given a glob pattern, resolve with list of files matching that pattern\n   * @see https://github.com/isaacs/node-glob\n   */\n  glob: /** @type {(pattern: string, opts?: glob.IOptions) => B<string[]>} */(B.promisify(glob)),\n\n  /**\n   * Sanitize a filename\n   * @see https://github.com/parshap/node-sanitize-filename\n   */\n  sanitizeName: sanitize,\n\n  /**\n   * Create a hex digest of some file at `filePath`\n   * @param {import('fs').PathLike} filePath\n   * @param {string} [algorithm]\n   * @returns {Promise<string>}\n   */\n  async hash (filePath, algorithm = 'sha1') {\n    return await new B((resolve, reject) => {\n      const fileHash = crypto.createHash(algorithm);\n      const readStream = createReadStream(filePath);\n      readStream.on('error', (e) => reject(\n        new Error(`Cannot calculate ${algorithm} hash for '${filePath}'. Original error: ${e.message}`)));\n      readStream.on('data', (chunk) => fileHash.update(chunk));\n      readStream.on('end', () => resolve(fileHash.digest('hex')));\n    });\n  },\n\n  /**\n   * Returns an `Walker` instance, which is a readable stream (and thusly an async iterator).\n   *\n   * @param {string} dir - Dir to start walking at\n   * @param {import('klaw').Options} [opts]\n   * @returns {import('klaw').Walker}\n   * @see https://www.npmjs.com/package/klaw\n   */\n  walk (dir, opts) {\n    return klaw(dir, opts);\n  },\n\n  /**\n   * Recursively create a directory.\n   * @param {import('fs').PathLike} dir\n   * @returns {Promise<string|undefined>}\n   */\n  async mkdirp (dir) {\n    return await fs.mkdir(dir, {recursive: true});\n  },\n\n  /**\n   * Walks a directory given according to the parameters given. The callback will be invoked with a path joined with the dir parameter\n   * @param {string} dir Directory path where we will start walking\n   * @param {boolean} recursive Set it to true if you want to continue walking sub directories\n   * @param {WalkDirCallback} callback The callback to be called when a new path is found\n   * @throws {Error} If the `dir` parameter contains a path to an invalid folder\n   * @returns {Promise<string?>} returns the found path or null if the item was not found\n   */\n  async walkDir (dir, recursive, callback) { //eslint-disable-line promise/prefer-await-to-callbacks\n    let isValidRoot = false;\n    let errMsg = null;\n    try {\n      isValidRoot = (await fs.stat(dir)).isDirectory();\n    } catch (e) {\n      errMsg = e.message;\n    }\n    if (!isValidRoot) {\n      throw Error(`'${dir}' is not a valid root directory` + (errMsg ? `. Original error: ${errMsg}` : ''));\n    }\n\n    let walker;\n    let fileCount = 0;\n    let directoryCount = 0;\n    const timer = new Timer().start();\n    return await new B(function (resolve, reject) {\n      let lastFileProcessed = B.resolve();\n      walker = klaw(dir, {\n        depthLimit: recursive ? -1 : 0,\n      });\n      walker.on('data', function (item) {\n        walker.pause();\n\n        if (!item.stats.isDirectory()) {\n          fileCount++;\n        } else {\n          directoryCount++;\n        }\n\n        // eslint-disable-next-line promise/prefer-await-to-callbacks\n        lastFileProcessed = B.try(async () => await callback(item.path, item.stats.isDirectory()))\n          .then(function (done = false) {\n            if (done) {\n              resolve(item.path);\n            } else {\n              walker.resume();\n            }\n          })\n          .catch(reject);\n      })\n      .on('error', function (err, item) {\n        log.warn(`Got an error while walking '${item.path}': ${err.message}`);\n        // klaw cannot get back from an ENOENT error\n        if (err.code === 'ENOENT') {\n          log.warn('All files may not have been accessed');\n          reject(err);\n        }\n      })\n      .on('end', function () {\n        lastFileProcessed\n          .then((file) => {\n            resolve(/** @type {string|undefined} */(file) ?? null);\n          })\n          .catch(function (err) {\n            log.warn(`Unexpected error: ${err.message}`);\n            reject(err);\n          });\n      });\n    }).finally(function () {\n      log.debug(`Traversed ${pluralize('directory', directoryCount, true)} ` +\n        `and ${pluralize('file', fileCount, true)} ` +\n        `in ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);\n      if (walker) {\n        walker.destroy();\n      }\n    });\n  },\n  /**\n   * Reads the closest `package.json` file from absolute path `dir`.\n   * @param {string} dir - Directory to search from\n   * @param {import('read-pkg').Options} [opts] - Additional options for `read-pkg`\n   * @throws {Error} If there were problems finding or reading a `package.json` file\n   * @returns {object} A parsed `package.json`\n   */\n  readPackageJsonFrom (dir, opts = {}) {\n    const cwd = fs.findRoot(dir);\n    try {\n      return readPkg.sync({...opts, cwd});\n    } catch (err) {\n      err.message = `Failed to read a \\`package.json\\` from dir \\`${dir}\\`:\\n\\n${err.message}`;\n      throw err;\n    }\n  },\n  /**\n   * Finds the project root directory from `dir`.\n   * @param {string} dir - Directory to search from\n   * @throws {TypeError} If `dir` is not a nonempty string or relative path\n   * @throws {Error} If there were problems finding the project root\n   * @returns {string} The closeset parent dir containing `package.json`\n   */\n  findRoot (dir) {\n    if (!dir || !path.isAbsolute(dir)) {\n      throw new TypeError('`findRoot()` must be provided a non-empty, absolute path');\n    }\n    const result = findRootCached(dir);\n    if (!result) {\n      throw new Error(`\\`findRoot()\\` could not find \\`package.json\\` from ${dir}`);\n    }\n    return result;\n  },\n\n  // add the supported `fs` functions\n  access: fsPromises.access,\n  appendFile: fsPromises.appendFile,\n  chmod: fsPromises.chmod,\n  close: B.promisify(close),\n  constants,\n  createWriteStream,\n  createReadStream,\n  lstat: fsPromises.lstat,\n  /**\n   * Warning: this is a promisified {@linkcode open fs.open}.\n   * It resolves w/a file descriptor instead of a {@linkcode fsPromises.FileHandle FileHandle} object, as {@linkcode fsPromises.open} does. Use {@linkcode fs.openFile} if you want a `FileHandle`.\n   * @type {(path: import('fs').PathLike, flags: import('fs').OpenMode, mode?: import('fs').Mode) => Promise<number>}\n   */\n  open: B.promisify(open),\n  openFile: fsPromises.open,\n  readdir: fsPromises.readdir,\n  read: B.promisify(read),\n  readFile: fsPromises.readFile,\n  readlink: fsPromises.readlink,\n  realpath: fsPromises.realpath,\n  rename: fsPromises.rename,\n  stat: fsPromises.stat,\n  symlink: fsPromises.symlink,\n  unlink: fsPromises.unlink,\n  write: B.promisify(write),\n  writeFile: fsPromises.writeFile,\n\n  // deprecated props\n\n  /**\n   * Use `constants.F_OK` instead.\n   * @deprecated\n   */\n  F_OK: constants.F_OK,\n\n  /**\n   * Use `constants.R_OK` instead.\n   * @deprecated\n   */\n  R_OK: constants.R_OK,\n\n  /**\n   * Use `constants.W_OK` instead.\n   * @deprecated\n   */\n  W_OK: constants.W_OK,\n\n  /**\n   * Use `constants.X_OK` instead.\n   * @deprecated\n   */\n  X_OK: constants.X_OK\n};\n\nexport { fs };\nexport default fs;\n\n/**\n * The callback function which will be called during the directory walking\n * @callback WalkDirCallback\n * @param {string} itemPath The path of the file or folder\n * @param {boolean} isDirectory Shows if it is a directory or a file\n * @return {boolean} return true if you want to stop walking\n*/\n\n/**\n * @typedef {import('glob')} glob\n * @typedef {import('mv')} mv\n */\n"]}

package/build/lib/image-util.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+export type AppiumJimp = Omit<Jimp, 'getBuffer'> & {
+    getBuffer: Jimp['getBufferAsync'];
+};
+export type Region = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+/**
+ * Crop the image by given rectangle (use base64 string as input and output)
+ *
+ * @param {string} base64Image The string with base64 encoded image
+ * @param {Region} rect The selected region of image
+ * @return {Promise<string>} base64 encoded string of cropped image
+ */
+export function cropBase64Image(base64Image: string, rect: Region): Promise<string>;
+/**
+ * Create a pngjs image from given base64 image
+ *
+ * @param {string} base64Image The string with base64 encoded image
+ * @return {Promise<PNG>} The image object
+ */
+export function base64ToImage(base64Image: string): Promise<PNG>;
+/**
+ * Create a base64 string for given image object
+ *
+ * @param {PNG} image The image object
+ * @return {Promise<string>} The string with base64 encoded image
+ */
+export function imageToBase64(image: PNG): Promise<string>;
+/**
+ * Crop the image by given rectangle
+ *
+ * @param {PNG} image The image to mutate by cropping
+ * @param {Region} rect The selected region of image
+ */
+export function cropImage(image: PNG, rect: Region): PNG;
+/**
+ * Utility function to get a Jimp image object from buffer or base64 data. Jimp
+ * is a great library however it does IO in the constructor so it's not
+ * convenient for our async/await model.
+ *
+ * @param {Buffer|string} data - binary image buffer or base64-encoded image
+ * string
+ * @returns {Promise<AppiumJimp>} - the jimp image object
+ */
+export function getJimpImage(data: Buffer | string): Promise<AppiumJimp>;
+export const MIME_JPEG: "image/jpeg";
+export const MIME_PNG: "image/png";
+export const MIME_BMP: "image/bmp";
+import Jimp from "jimp";
+import { PNG } from "pngjs";
+import { Buffer } from "buffer";
+//# sourceMappingURL=image-util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"image-util.d.ts","sourceRoot":"","sources":["../../lib/image-util.js"],"names":[],"mappings":";yBAkJa,KAAK,IAAI,EAAC,WAAW,CAAC,GAAG;IAAC,SAAS,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAA;CAAC;;UAK3D,MAAM;SACN,MAAM;WACN,MAAM;YACN,MAAM;;AA5GpB;;;;;;GAMG;AACH,6CAJW,MAAM,QACN,MAAM,GACL,QAAQ,MAAM,CAAC,CAM1B;AAED;;;;;GAKG;AACH,2CAHW,MAAM,GACL,QAAQ,GAAG,CAAC,CAavB;AAED;;;;;GAKG;AACH,qCAHW,GAAG,GACF,QAAQ,MAAM,CAAC,CAa1B;AAED;;;;;GAKG;AACH,iCAHW,GAAG,QACH,MAAM,OA6BhB;AAxHD;;;;;;;;GAQG;AACH,mCAJW,MAAM,GAAC,MAAM,GAEX,QAAQ,UAAU,CAAC,CA2B/B"}

package/build/lib/image-util.js

@@ -54,8 +54,7 @@ async function getJimpImage(data) {
         return reject(new Error('Could not create jimp image from that data'));
       }
 
-      imgObj._getBuffer = imgObj.getBuffer.bind(imgObj);
-      imgObj.getBuffer = _bluebird.default.promisify(imgObj._getBuffer, {
+      imgObj.getBuffer = _bluebird.default.promisify(imgObj.getBuffer.bind(imgObj), {
         context: imgObj
       });
       resolve(imgObj);
@@ -142,4 +141,4 @@ function getRectIntersection(rect, imageSize) {
     height
   };
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/image-util.js"],"names":["BYTES_IN_PIXEL_BLOCK","SCANLINE_FILTER_METHOD","MIME_JPEG","MIME_PNG","MIME_BMP","Jimp","getJimpImage","data","B","resolve","reject","_","isString","isBuffer","Error","Buffer","from","err","imgObj","_getBuffer","getBuffer","bind","promisify","context","cropBase64Image","base64Image","rect","image","base64ToImage","cropImage","imageToBase64","imageBuffer","PNG","filterType","parse","chunks","pack","on","chunk","push","concat","toString","imageRect","width","height","interRect","getRectIntersection","JSON","stringify","firstVerticalPixel","top","lastVerticalPixel","firstHorizontalPixel","left","lastHorizontalPixel","croppedArray","y","x","firstByteIdxInPixelBlock","byteIdx","imageSize"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport Jimp from 'jimp';\nimport { Buffer } from 'buffer';\nimport { PNG } from 'pngjs';\nimport B from 'bluebird';\n\nconst BYTES_IN_PIXEL_BLOCK = 4;\nconst SCANLINE_FILTER_METHOD = 4;\nconst { MIME_JPEG, MIME_PNG, MIME_BMP } = Jimp;\n\n/**\n * Utility function to get a Jimp image object from buffer or base64 data. Jimp\n * is a great library however it does IO in the constructor so it's not\n * convenient for our async/await model.\n *\n * @param {Buffer|string} data - binary image buffer or base64-encoded image\n * string\n * @returns {Jimp} - the jimp image object\n */\nasync function getJimpImage (data) {\n  return await new B((resolve, reject) => {\n    if (!_.isString(data) && !_.isBuffer(data)) {\n      return reject(new Error('Must initialize jimp object with string or buffer'));\n    }\n    // if data is a string, assume it is a base64-encoded image\n    if (_.isString(data)) {\n      data = Buffer.from(data, 'base64');\n    }\n    new Jimp(data, (err, imgObj) => {\n      if (err) {\n        return reject(err);\n      }\n      if (!imgObj) {\n        return reject(new Error('Could not create jimp image from that data'));\n      }\n      imgObj._getBuffer = imgObj.getBuffer.bind(imgObj);\n      imgObj.getBuffer = B.promisify(imgObj._getBuffer, {context: imgObj});\n      resolve(imgObj);\n    });\n  });\n}\n\n/**\n * Crop the image by given rectangle (use base64 string as input and output)\n *\n * @param {string} base64Image The string with base64 encoded image\n * @param {Region} rect The selected region of image\n * @return {string} base64 encoded string of cropped image\n */\nasync function cropBase64Image (base64Image, rect) {\n  const image = await base64ToImage(base64Image);\n  cropImage(image, rect);\n  return await imageToBase64(image);\n}\n\n/**\n * Create a pngjs image from given base64 image\n *\n * @param {string} base64Image The string with base64 encoded image\n * @return {PNG} The image object\n */\nasync function base64ToImage (base64Image) {\n  const imageBuffer = Buffer.from(base64Image, 'base64');\n  return await new B((resolve, reject) => {\n    const image = new PNG({filterType: SCANLINE_FILTER_METHOD});\n    image.parse(imageBuffer, (err, image) => { // eslint-disable-line promise/prefer-await-to-callbacks\n      if (err) {\n        return reject(err);\n      }\n      resolve(image);\n    });\n  });\n}\n\n/**\n * Create a base64 string for given image object\n *\n * @param {PNG} image The image object\n * @return {string} The string with base64 encoded image\n */\nasync function imageToBase64 (image) {\n  return await new B((resolve, reject) => {\n    const chunks = [];\n    image.pack()\n    .on('data', (chunk) => chunks.push(chunk)).on('end', () => {\n      resolve(Buffer.concat(chunks).toString('base64'));\n    })\n    .on('error', (err) => { // eslint-disable-line promise/prefer-await-to-callbacks\n      reject(err);\n    });\n  });\n}\n\n/**\n * Crop the image by given rectangle\n *\n * @param {PNG} image The image to mutate by cropping\n * @param {Region} rect The selected region of image\n */\nfunction cropImage (image, rect) {\n  const imageRect = {width: image.width, height: image.height};\n  const interRect = getRectIntersection(rect, imageRect);\n  if (interRect.width < rect.width || interRect.height < rect.height) {\n    throw new Error(`Cannot crop ${JSON.stringify(rect)} from ${JSON.stringify(imageRect)} because the intersection between them was not the size of the rect`);\n  }\n\n  const firstVerticalPixel = interRect.top;\n  const lastVerticalPixel = interRect.top + interRect.height;\n\n  const firstHorizontalPixel = interRect.left;\n  const lastHorizontalPixel = interRect.left + interRect.width;\n\n  const croppedArray = [];\n  for (let y = firstVerticalPixel; y < lastVerticalPixel; y++) {\n    for (let x = firstHorizontalPixel; x < lastHorizontalPixel; x++) {\n      const firstByteIdxInPixelBlock = (imageRect.width * y + x) << 2;\n      for (let byteIdx = 0; byteIdx < BYTES_IN_PIXEL_BLOCK; byteIdx++) {\n        croppedArray.push(image.data[firstByteIdxInPixelBlock + byteIdx]);\n      }\n    }\n  }\n\n  image.data = Buffer.from(croppedArray);\n  image.width = interRect.width;\n  image.height = interRect.height;\n  return image;\n}\n\nfunction getRectIntersection (rect, imageSize) {\n  const left = rect.left >= imageSize.width ? imageSize.width : rect.left;\n  const top = rect.top >= imageSize.height ? imageSize.height : rect.top;\n  const width = imageSize.width >= (left + rect.width) ? rect.width : (imageSize.width - left);\n  const height = imageSize.height >= (top + rect.height) ? rect.height : (imageSize.height - top);\n  return {left, top, width, height};\n}\n\nexport {\n  cropBase64Image, base64ToImage, imageToBase64, cropImage,\n  getJimpImage, MIME_JPEG, MIME_PNG, MIME_BMP\n};\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/image-util.js"],"names":["BYTES_IN_PIXEL_BLOCK","SCANLINE_FILTER_METHOD","MIME_JPEG","MIME_PNG","MIME_BMP","Jimp","getJimpImage","data","B","resolve","reject","_","isString","isBuffer","Error","Buffer","from","err","imgObj","getBuffer","promisify","bind","context","cropBase64Image","base64Image","rect","image","base64ToImage","cropImage","imageToBase64","imageBuffer","PNG","filterType","parse","chunks","pack","on","chunk","push","concat","toString","imageRect","width","height","interRect","getRectIntersection","JSON","stringify","firstVerticalPixel","top","lastVerticalPixel","firstHorizontalPixel","left","lastHorizontalPixel","croppedArray","y","x","firstByteIdxInPixelBlock","byteIdx","imageSize"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport Jimp from 'jimp';\nimport { Buffer } from 'buffer';\nimport { PNG } from 'pngjs';\nimport B from 'bluebird';\n\nconst BYTES_IN_PIXEL_BLOCK = 4;\nconst SCANLINE_FILTER_METHOD = 4;\nconst { MIME_JPEG, MIME_PNG, MIME_BMP } = Jimp;\n\n/**\n * Utility function to get a Jimp image object from buffer or base64 data. Jimp\n * is a great library however it does IO in the constructor so it's not\n * convenient for our async/await model.\n *\n * @param {Buffer|string} data - binary image buffer or base64-encoded image\n * string\n * @returns {Promise<AppiumJimp>} - the jimp image object\n */\nasync function getJimpImage (data) {\n  return await new B((resolve, reject) => {\n    if (!_.isString(data) && !_.isBuffer(data)) {\n      return reject(new Error('Must initialize jimp object with string or buffer'));\n    }\n    // if data is a string, assume it is a base64-encoded image\n    if (_.isString(data)) {\n      data = Buffer.from(data, 'base64');\n    }\n    new Jimp(data,\n      /**\n       * @param {Error?} err\n       * @param {AppiumJimp} imgObj\n       */\n    (err, imgObj) => {\n      if (err) {\n        return reject(err);\n      }\n      if (!imgObj) {\n        return reject(new Error('Could not create jimp image from that data'));\n      }\n      imgObj.getBuffer = B.promisify(imgObj.getBuffer.bind(imgObj), {context: imgObj});\n      resolve(imgObj);\n    });\n  });\n}\n\n/**\n * Crop the image by given rectangle (use base64 string as input and output)\n *\n * @param {string} base64Image The string with base64 encoded image\n * @param {Region} rect The selected region of image\n * @return {Promise<string>} base64 encoded string of cropped image\n */\nasync function cropBase64Image (base64Image, rect) {\n  const image = await base64ToImage(base64Image);\n  cropImage(image, rect);\n  return await imageToBase64(image);\n}\n\n/**\n * Create a pngjs image from given base64 image\n *\n * @param {string} base64Image The string with base64 encoded image\n * @return {Promise<PNG>} The image object\n */\nasync function base64ToImage (base64Image) {\n  const imageBuffer = Buffer.from(base64Image, 'base64');\n  return await new B((resolve, reject) => {\n    const image = new PNG({filterType: SCANLINE_FILTER_METHOD});\n    image.parse(imageBuffer, (err, image) => { // eslint-disable-line promise/prefer-await-to-callbacks\n      if (err) {\n        return reject(err);\n      }\n      resolve(image);\n    });\n  });\n}\n\n/**\n * Create a base64 string for given image object\n *\n * @param {PNG} image The image object\n * @return {Promise<string>} The string with base64 encoded image\n */\nasync function imageToBase64 (image) {\n  return await new B((resolve, reject) => {\n    const chunks = [];\n    image.pack()\n    .on('data', (chunk) => chunks.push(chunk)).on('end', () => {\n      resolve(Buffer.concat(chunks).toString('base64'));\n    })\n    .on('error', (err) => { // eslint-disable-line promise/prefer-await-to-callbacks\n      reject(err);\n    });\n  });\n}\n\n/**\n * Crop the image by given rectangle\n *\n * @param {PNG} image The image to mutate by cropping\n * @param {Region} rect The selected region of image\n */\nfunction cropImage (image, rect) {\n  const imageRect = {width: image.width, height: image.height};\n  const interRect = getRectIntersection(rect, imageRect);\n  if (interRect.width < rect.width || interRect.height < rect.height) {\n    throw new Error(`Cannot crop ${JSON.stringify(rect)} from ${JSON.stringify(imageRect)} because the intersection between them was not the size of the rect`);\n  }\n\n  const firstVerticalPixel = interRect.top;\n  const lastVerticalPixel = interRect.top + interRect.height;\n\n  const firstHorizontalPixel = interRect.left;\n  const lastHorizontalPixel = interRect.left + interRect.width;\n\n  const croppedArray = [];\n  for (let y = firstVerticalPixel; y < lastVerticalPixel; y++) {\n    for (let x = firstHorizontalPixel; x < lastHorizontalPixel; x++) {\n      const firstByteIdxInPixelBlock = (imageRect.width * y + x) << 2;\n      for (let byteIdx = 0; byteIdx < BYTES_IN_PIXEL_BLOCK; byteIdx++) {\n        croppedArray.push(image.data[firstByteIdxInPixelBlock + byteIdx]);\n      }\n    }\n  }\n\n  image.data = Buffer.from(croppedArray);\n  image.width = interRect.width;\n  image.height = interRect.height;\n  return image;\n}\n\nfunction getRectIntersection (rect, imageSize) {\n  const left = rect.left >= imageSize.width ? imageSize.width : rect.left;\n  const top = rect.top >= imageSize.height ? imageSize.height : rect.top;\n  const width = imageSize.width >= (left + rect.width) ? rect.width : (imageSize.width - left);\n  const height = imageSize.height >= (top + rect.height) ? rect.height : (imageSize.height - top);\n  return {left, top, width, height};\n}\n\nexport {\n  cropBase64Image, base64ToImage, imageToBase64, cropImage,\n  getJimpImage, MIME_JPEG, MIME_PNG, MIME_BMP\n};\n\n/**\n * @typedef {Omit<Jimp,'getBuffer'> & {getBuffer: Jimp['getBufferAsync']}} AppiumJimp\n */\n\n/**\n * @typedef Region\n * @property {number} left\n * @property {number} top\n * @property {number} width\n * @property {number} height\n */\n"]}

package/build/lib/index.d.ts

@@ -0,0 +1,38 @@
+export { npm } from "./npm";
+declare namespace _default {
+    export { tempDir };
+    export { system };
+    export { util };
+    export { fs };
+    export { cancellableDelay };
+    export { plist };
+    export { mkdirp };
+    export { logger };
+    export { process };
+    export { zip };
+    export { imageUtil };
+    export { net };
+    export { mjpeg };
+    export { node };
+    export { timing };
+    export { env };
+}
+export default _default;
+import * as tempDir from "./tempdir";
+import * as system from "./system";
+import * as util from "./util";
+import { fs } from "./fs";
+export const cancellableDelay: typeof util.cancellableDelay;
+import * as plist from "./plist";
+import { mkdirp } from "./mkdirp";
+import * as logger from "./logging";
+import * as process from "./process";
+import * as zip from "./zip";
+import * as imageUtil from "./image-util";
+import * as net from "./net";
+import * as mjpeg from "./mjpeg";
+import * as node from "./node";
+import * as timing from "./timing";
+import * as env from "./env";
+export { tempDir, system, util, fs, plist, mkdirp, logger, process, zip, imageUtil, net, mjpeg, node, timing, env };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.js"],"names":[],"mappings":""}