@appium/support 2.55.4 → 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/env.js

@@ -0,0 +1,102 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MANIFEST_RELATIVE_PATH = exports.MANIFEST_BASENAME = exports.DEFAULT_APPIUM_HOME = void 0;
+exports.hasAppiumDependency = hasAppiumDependency;
+exports.resolveManifestPath = exports.resolveAppiumHome = exports.readPackageInDir = void 0;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _os = require("os");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _pkgDir = _interopRequireDefault(require("pkg-dir"));
+
+var _readPkg = _interopRequireDefault(require("read-pkg"));
+
+var _npm = require("./npm");
+
+const DEFAULT_APPIUM_HOME = _path.default.resolve((0, _os.homedir)(), '.appium');
+
+exports.DEFAULT_APPIUM_HOME = DEFAULT_APPIUM_HOME;
+const MANIFEST_BASENAME = 'extensions.yaml';
+exports.MANIFEST_BASENAME = MANIFEST_BASENAME;
+
+const MANIFEST_RELATIVE_PATH = _path.default.join('node_modules', '.cache', 'appium', MANIFEST_BASENAME);
+
+exports.MANIFEST_RELATIVE_PATH = MANIFEST_RELATIVE_PATH;
+
+async function hasAppiumDependency(cwd) {
+  let listResult;
+  let resolved;
+  let version;
+
+  try {
+    var _listResult$dependenc, _listResult, _listResult$dependenc2, _listResult$dependenc3, _listResult$dependenc4, _listResult2, _listResult2$dependen, _listResult2$dependen2;
+
+    listResult = await _npm.npm.list(cwd, 'appium');
+    resolved = (_listResult$dependenc = (_listResult = listResult) === null || _listResult === void 0 ? void 0 : (_listResult$dependenc2 = _listResult.dependencies) === null || _listResult$dependenc2 === void 0 ? void 0 : (_listResult$dependenc3 = _listResult$dependenc2.appium) === null || _listResult$dependenc3 === void 0 ? void 0 : _listResult$dependenc3.resolved) !== null && _listResult$dependenc !== void 0 ? _listResult$dependenc : '';
+    version = (_listResult$dependenc4 = (_listResult2 = listResult) === null || _listResult2 === void 0 ? void 0 : (_listResult2$dependen = _listResult2.dependencies) === null || _listResult2$dependen === void 0 ? void 0 : (_listResult2$dependen2 = _listResult2$dependen.appium) === null || _listResult2$dependen2 === void 0 ? void 0 : _listResult2$dependen2.version) !== null && _listResult$dependenc4 !== void 0 ? _listResult$dependenc4 : '';
+  } catch {
+    try {
+      var _ref, _pkg$dependencies$app, _pkg$dependencies, _pkg$devDependencies, _pkg$optionalDependen;
+
+      const pkg = await readPackageInDir(cwd);
+      version = resolved = (_ref = (_pkg$dependencies$app = pkg === null || pkg === void 0 ? void 0 : (_pkg$dependencies = pkg.dependencies) === null || _pkg$dependencies === void 0 ? void 0 : _pkg$dependencies.appium) !== null && _pkg$dependencies$app !== void 0 ? _pkg$dependencies$app : pkg === null || pkg === void 0 ? void 0 : (_pkg$devDependencies = pkg.devDependencies) === null || _pkg$devDependencies === void 0 ? void 0 : _pkg$devDependencies.appium) !== null && _ref !== void 0 ? _ref : pkg === null || pkg === void 0 ? void 0 : (_pkg$optionalDependen = pkg.optionalDependencies) === null || _pkg$optionalDependen === void 0 ? void 0 : _pkg$optionalDependen.appium;
+    } catch {}
+  }
+
+  return Boolean(version && (!resolved || resolved && !resolved.startsWith('file:')) && !version.startsWith('1') && !version.startsWith('0'));
+}
+
+const readPackageInDir = _lodash.default.memoize(async function _readPackageInDir(cwd) {
+  return await (0, _readPkg.default)({
+    cwd,
+    normalize: true
+  });
+});
+
+exports.readPackageInDir = readPackageInDir;
+
+const resolveAppiumHome = _lodash.default.memoize(async function _resolveAppiumHome(cwd = process.cwd()) {
+  if (process.env.APPIUM_HOME) {
+    return process.env.APPIUM_HOME;
+  }
+
+  if (!_path.default.isAbsolute(cwd)) {
+    throw new TypeError('`cwd` parameter must be an absolute path');
+  }
+
+  let currentPkgDir;
+
+  try {
+    currentPkgDir = await (0, _pkgDir.default)(cwd);
+
+    if (!currentPkgDir) {
+      return DEFAULT_APPIUM_HOME;
+    }
+  } catch {
+    return DEFAULT_APPIUM_HOME;
+  }
+
+  return (await hasAppiumDependency(currentPkgDir)) ? currentPkgDir : DEFAULT_APPIUM_HOME;
+});
+
+exports.resolveAppiumHome = resolveAppiumHome;
+
+const resolveManifestPath = _lodash.default.memoize(async function _resolveManifestPath(appiumHome) {
+  var _appiumHome;
+
+  appiumHome = (_appiumHome = appiumHome) !== null && _appiumHome !== void 0 ? _appiumHome : await resolveAppiumHome();
+  return _path.default.join(appiumHome, MANIFEST_RELATIVE_PATH);
+});
+
+exports.resolveManifestPath = resolveManifestPath;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/env.js"],"names":["DEFAULT_APPIUM_HOME","path","resolve","MANIFEST_BASENAME","MANIFEST_RELATIVE_PATH","join","hasAppiumDependency","cwd","listResult","resolved","version","npm","list","dependencies","appium","pkg","readPackageInDir","devDependencies","optionalDependencies","Boolean","startsWith","_","memoize","_readPackageInDir","normalize","resolveAppiumHome","_resolveAppiumHome","process","env","APPIUM_HOME","isAbsolute","TypeError","currentPkgDir","resolveManifestPath","_resolveManifestPath","appiumHome"],"mappings":"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","sourcesContent":["// @ts-check\nimport _ from 'lodash';\nimport { homedir } from 'os';\nimport path from 'path';\nimport pkgDir from 'pkg-dir';\nimport readPkg from 'read-pkg';\nimport { npm } from './npm';\n\n/**\n * Path to the default `APPIUM_HOME` dir (`~/.appium`).\n * @type {string}\n */\nexport const DEFAULT_APPIUM_HOME = path.resolve(homedir(), '.appium');\n\n/**\n * Basename of extension manifest file.\n * @type {string}\n */\nexport const MANIFEST_BASENAME = 'extensions.yaml';\n\n/**\n * Relative path to extension manifest file from `APPIUM_HOME`.\n * @type {string}\n */\nexport const MANIFEST_RELATIVE_PATH = path.join(\n  'node_modules',\n  '.cache',\n  'appium',\n  MANIFEST_BASENAME,\n);\n\n/**\n * Returns `true` if appium is installed as a dependency of a local package at `cwd`.\n *\n * The following special cases are considered:\n *\n * - If `resolved` starts with `file:`, then `cwd` likely points to `appium-monorepo`, and (for now) we expect `APPIUM_HOME` to be the default.\n * - If the `version` begins with `0` or `1`, we're looking at an old version of `appium` (not this one!)\n *\n * 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).\n * Regardless we may want to make this more robust in the future, as we hit edge cases.\n *\n * _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.\n *\n * @param {string} cwd\n * @returns {Promise<boolean>}\n */\nexport async function hasAppiumDependency (cwd) {\n  /**\n   * @todo type this\n   * @type {object}\n   */\n  let listResult;\n  /** @type {string|undefined} */\n  let resolved;\n  /** @type {string|undefined} */\n  let version;\n  try {\n    listResult = await npm.list(cwd, 'appium');\n    // if \"resolved\" is empty, then `appium` is in dependencies, but `npm install` has not been run.\n    // in other words, this function can resolve `true` even if `resolved` is empty...\n    resolved = listResult?.dependencies?.appium?.resolved ?? '';\n    // ...however, it cannot do so unless `version` is nonempty.\n    version = listResult?.dependencies?.appium?.version ?? '';\n  } catch {\n    try {\n      const pkg = await readPackageInDir(cwd);\n      // we're only going to look at these three fields for now, but we can change it later if need be.\n      version = resolved =\n        pkg?.dependencies?.appium ??\n        pkg?.devDependencies?.appium ??\n        pkg?.optionalDependencies?.appium;\n    } catch {}\n  }\n  return Boolean(\n    version &&\n      (!resolved || (resolved && !resolved.startsWith('file:'))) &&\n      // doing any further checking here may be a fool's errand, because you can pin the version\n      // to a _lot_ of different things (tags, URLs, etc).\n      !version.startsWith('1') &&\n      !version.startsWith('0'),\n  );\n}\n\n/**\n * Read a `package.json` in dir `cwd`.  If none found, return `undefined`.\n */\nexport const readPackageInDir = _.memoize(\n  /**\n   *\n   * @param {string} cwd - Directory ostensibly having a `package.json`\n   * @returns {Promise<import('read-pkg').NormalizedPackageJson|undefined>}\n   */\n  async function _readPackageInDir (cwd) {\n    return await readPkg({cwd, normalize: true});\n  },\n);\n\n/**\n * Determines location of Appium's \"home\" dir\n *\n * - If `APPIUM_HOME` is set in the environment, use that\n * - If we have an `extensions.yaml` in {@linkcode DEFAULT_APPIUM_HOME}, then use that.\n * - If we find a `package.json` in or above `cwd` and {@linkcode shouldUseCwdForAppiumHome} returns `true`, then use the directory containing the `package.json`.\n */\nexport const resolveAppiumHome = _.memoize(\n  /**\n   * @param {string} [cwd] - Current working directory.  _Must_ be absolute, if specified.\n   * @returns {Promise<string>}\n   */\n  async function _resolveAppiumHome (cwd = process.cwd()) {\n    if (process.env.APPIUM_HOME) {\n      return process.env.APPIUM_HOME;\n    }\n\n    if (!path.isAbsolute(cwd)) {\n      throw new TypeError('`cwd` parameter must be an absolute path');\n    }\n\n    /** @type {string|undefined} */\n    let currentPkgDir;\n\n    try {\n      currentPkgDir = await pkgDir(cwd);\n\n      // if we can't find a `package.json`, use the default\n      if (!currentPkgDir) {\n        return DEFAULT_APPIUM_HOME;\n      }\n    } catch {\n      // unclear if this can actually happen\n      /* istanbul ignore next */\n      return DEFAULT_APPIUM_HOME;\n    }\n\n    return (await hasAppiumDependency(currentPkgDir))\n      ? currentPkgDir\n      : DEFAULT_APPIUM_HOME;\n  },\n);\n\n/**\n * Figure out manifest path based on `appiumHome`.\n *\n * The assumption is that, if `appiumHome` has been provided, it was resolved via {@link resolveAppiumHome `resolveAppiumHome()`}!  If unsure,\n * don't pass a parameter and let `resolveAppiumHome()` handle it.\n */\nexport const resolveManifestPath = _.memoize(\n  /**\n   * @param {string} [appiumHome] - Appium home directory\n   * @returns {Promise<string>}\n   */\n  async function _resolveManifestPath (appiumHome) {\n    // can you \"await\" in a default parameter? is that a good idea?\n    appiumHome = appiumHome ?? (await resolveAppiumHome());\n    return path.join(appiumHome, MANIFEST_RELATIVE_PATH);\n  },\n);\n\n/**\n * @typedef {import('read-pkg').NormalizedPackageJson} NormalizedPackageJson\n */\n"]}

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"}