UrgentcareCLI 0.1.1 → 0.2.3

data/node_modules/selenium-webdriver/io/exec.js

@@ -1,162 +0,0 @@
-// Licensed to the Software Freedom Conservancy (SFC) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The SFC licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-'use strict'
-
-const childProcess = require('child_process')
-
-/**
- * Options for configuring an executed command.
- *
- * @record
- */
-class Options {
-  constructor() {
-    /**
-     * Command line arguments for the child process, if any.
-     * @type (!Array<string>|undefined)
-     */
-    this.args
-
-    /**
-     * Environment variables for the spawned process. If unspecified, the
-     * child will inherit this process' environment.
-     *
-     * @type {(!Object<string, string>|undefined)}
-     */
-    this.env
-
-    /**
-     * IO conifguration for the spawned server child process. If unspecified,
-     * the child process' IO output will be ignored.
-     *
-     * @type {(string|!Array<string|number|!stream.Stream|null|undefined>|
-     *           undefined)}
-     * @see <https://nodejs.org/dist/latest-v8.x/docs/api/child_process.html#child_process_options_stdio>
-     */
-    this.stdio
-  }
-}
-
-/**
- * Describes a command's termination conditions.
- */
-class Result {
-  /**
-   * @param {?number} code The exit code, or {@code null} if the command did not
-   *     exit normally.
-   * @param {?string} signal The signal used to kill the command, or
-   *     {@code null}.
-   */
-  constructor(code, signal) {
-    /** @type {?number} */
-    this.code = code
-
-    /** @type {?string} */
-    this.signal = signal
-  }
-
-  /** @override */
-  toString() {
-    return `Result(code=${this.code}, signal=${this.signal})`
-  }
-}
-
-const COMMAND_RESULT = /** !WeakMap<!Command, !Promise<!Result>> */ new WeakMap()
-const KILL_HOOK = /** !WeakMap<!Command, function(string)> */ new WeakMap()
-
-/**
- * Represents a command running in a sub-process.
- */
-class Command {
-  /**
-   * @param {!Promise<!Result>} result The command result.
-   * @param {function(string)} onKill The function to call when {@link #kill()}
-   *     is called.
-   */
-  constructor(result, onKill) {
-    COMMAND_RESULT.set(this, result)
-    KILL_HOOK.set(this, onKill)
-  }
-
-  /**
-   * @return {!Promise<!Result>} A promise for the result of this
-   *     command.
-   */
-  result() {
-    return /** @type {!Promise<!Result>} */ (COMMAND_RESULT.get(this))
-  }
-
-  /**
-   * Sends a signal to the underlying process.
-   * @param {string=} opt_signal The signal to send; defaults to `SIGTERM`.
-   */
-  kill(opt_signal) {
-    KILL_HOOK.get(this)(opt_signal || 'SIGTERM')
-  }
-}
-
-// PUBLIC API
-
-/**
- * Spawns a child process. The returned {@link Command} may be used to wait
- * for the process result or to send signals to the process.
- *
- * @param {string} command The executable to spawn.
- * @param {Options=} opt_options The command options.
- * @return {!Command} The launched command.
- */
-module.exports = function exec(command, opt_options) {
-  const options = opt_options || {}
-
-  let proc = childProcess.spawn(command, options.args || [], {
-    env: options.env || process.env,
-    stdio: options.stdio || 'ignore',
-  })
-
-  // This process should not wait on the spawned child, however, we do
-  // want to ensure the child is killed when this process exits.
-  proc.unref()
-  process.once('exit', onProcessExit)
-
-  const result = new Promise((resolve) => {
-    proc.once('exit', (code, signal) => {
-      proc = null
-      process.removeListener('exit', onProcessExit)
-      resolve(new Result(code, signal))
-    })
-  })
-  return new Command(result, killCommand)
-
-  function onProcessExit() {
-    killCommand('SIGTERM')
-  }
-
-  function killCommand(signal) {
-    process.removeListener('exit', onProcessExit)
-    if (proc) {
-      proc.kill(signal)
-      proc = null
-    }
-  }
-}
-
-// Exported to improve generated API documentation.
-
-module.exports.Command = Command
-module.exports.Options = Options
-module.exports.Result = Result

data/node_modules/selenium-webdriver/io/index.js

@@ -1,348 +0,0 @@
-// Licensed to the Software Freedom Conservancy (SFC) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The SFC licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-'use strict'
-
-const fs = require('fs')
-const path = require('path')
-const rimraf = require('rimraf')
-const tmp = require('tmp')
-
-/**
- * @param {!Function} fn .
- * @return {!Promise<T>} .
- * @template T
- */
-function checkedCall(fn) {
-  return new Promise((resolve, reject) => {
-    try {
-      fn((err, value) => {
-        if (err) {
-          reject(err)
-        } else {
-          resolve(value)
-        }
-      })
-    } catch (e) {
-      reject(e)
-    }
-  })
-}
-
-// PUBLIC API
-
-/**
- * Recursively removes a directory and all of its contents. This is equivalent
- * to {@code rm -rf} on a POSIX system.
- * @param {string} dirPath Path to the directory to remove.
- * @return {!Promise} A promise to be resolved when the operation has
- *     completed.
- */
-exports.rmDir = function (dirPath) {
-  return new Promise(function (fulfill, reject) {
-    var numAttempts = 0
-    attemptRm()
-    function attemptRm() {
-      numAttempts += 1
-      rimraf(dirPath, function (err) {
-        if (err) {
-          if (err.code && err.code === 'ENOTEMPTY' && numAttempts < 2) {
-            attemptRm()
-            return
-          }
-          reject(err)
-        } else {
-          fulfill()
-        }
-      })
-    }
-  })
-}
-
-/**
- * Copies one file to another.
- * @param {string} src The source file.
- * @param {string} dst The destination file.
- * @return {!Promise<string>} A promise for the copied file's path.
- */
-exports.copy = function (src, dst) {
-  return new Promise(function (fulfill, reject) {
-    var rs = fs.createReadStream(src)
-    rs.on('error', reject)
-
-    var ws = fs.createWriteStream(dst)
-    ws.on('error', reject)
-    ws.on('close', () => fulfill(dst))
-
-    rs.pipe(ws)
-  })
-}
-
-/**
- * Recursively copies the contents of one directory to another.
- * @param {string} src The source directory to copy.
- * @param {string} dst The directory to copy into.
- * @param {(RegExp|function(string): boolean)=} opt_exclude An exclusion filter
- *     as either a regex or predicate function. All files matching this filter
- *     will not be copied.
- * @return {!Promise<string>} A promise for the destination
- *     directory's path once all files have been copied.
- */
-exports.copyDir = function (src, dst, opt_exclude) {
-  var predicate = opt_exclude
-  if (opt_exclude && typeof opt_exclude !== 'function') {
-    predicate = function (p) {
-      return !opt_exclude.test(p)
-    }
-  }
-
-  // TODO(jleyba): Make this function completely async.
-  if (!fs.existsSync(dst)) {
-    fs.mkdirSync(dst)
-  }
-
-  var files = fs.readdirSync(src)
-  files = files.map(function (file) {
-    return path.join(src, file)
-  })
-
-  if (predicate) {
-    files = files.filter(/** @type {function(string): boolean} */ (predicate))
-  }
-
-  var results = []
-  files.forEach(function (file) {
-    var stats = fs.statSync(file)
-    var target = path.join(dst, path.basename(file))
-
-    if (stats.isDirectory()) {
-      if (!fs.existsSync(target)) {
-        fs.mkdirSync(target, stats.mode)
-      }
-      results.push(exports.copyDir(file, target, predicate))
-    } else {
-      results.push(exports.copy(file, target))
-    }
-  })
-
-  return Promise.all(results).then(() => dst)
-}
-
-/**
- * Tests if a file path exists.
- * @param {string} aPath The path to test.
- * @return {!Promise<boolean>} A promise for whether the file exists.
- */
-exports.exists = function (aPath) {
-  return new Promise(function (fulfill, reject) {
-    let type = typeof aPath
-    if (type !== 'string') {
-      reject(TypeError(`expected string path, but got ${type}`))
-    } else {
-      // eslint-disable-next-line node/no-deprecated-api
-      fs.exists(aPath, fulfill)
-    }
-  })
-}
-
-/**
- * Calls `stat(2)`.
- * @param {string} aPath The path to stat.
- * @return {!Promise<!fs.Stats>} A promise for the file stats.
- */
-exports.stat = function stat(aPath) {
-  return checkedCall((callback) => fs.stat(aPath, callback))
-}
-
-/**
- * Deletes a name from the filesystem and possibly the file it refers to. Has
- * no effect if the file does not exist.
- * @param {string} aPath The path to remove.
- * @return {!Promise} A promise for when the file has been removed.
- */
-exports.unlink = function (aPath) {
-  return new Promise(function (fulfill, reject) {
-    // eslint-disable-next-line node/no-deprecated-api
-    fs.exists(aPath, function (exists) {
-      if (exists) {
-        fs.unlink(aPath, function (err) {
-          ;(err && reject(err)) || fulfill()
-        })
-      } else {
-        fulfill()
-      }
-    })
-  })
-}
-
-/**
- * @return {!Promise<string>} A promise for the path to a temporary directory.
- * @see https://www.npmjs.org/package/tmp
- */
-exports.tmpDir = function () {
-  return checkedCall((callback) => tmp.dir({ unsafeCleanup: true }, callback))
-}
-
-/**
- * @param {{postfix: string}=} opt_options Temporary file options.
- * @return {!Promise<string>} A promise for the path to a temporary file.
- * @see https://www.npmjs.org/package/tmp
- */
-exports.tmpFile = function (opt_options) {
-  return checkedCall((callback) => {
-    /**  check fixed in v > 0.2.1 if
-     * (typeof options === 'function') {
-     *     return [{}, options];
-     * }
-     */
-    tmp.file(opt_options, callback)
-  })
-}
-
-/**
- * Searches the {@code PATH} environment variable for the given file.
- * @param {string} file The file to locate on the PATH.
- * @param {boolean=} opt_checkCwd Whether to always start with the search with
- *     the current working directory, regardless of whether it is explicitly
- *     listed on the PATH.
- * @return {?string} Path to the located file, or {@code null} if it could
- *     not be found.
- */
-exports.findInPath = function (file, opt_checkCwd) {
-  const dirs = []
-  if (opt_checkCwd) {
-    dirs.push(process.cwd())
-  }
-  dirs.push.apply(dirs, process.env['PATH'].split(path.delimiter))
-
-  let foundInDir = dirs.find((dir) => {
-    let tmp = path.join(dir, file)
-    try {
-      let stats = fs.statSync(tmp)
-      return stats.isFile() && !stats.isDirectory()
-    } catch (ex) {
-      return false
-    }
-  })
-
-  return foundInDir ? path.join(foundInDir, file) : null
-}
-
-/**
- * Reads the contents of the given file.
- *
- * @param {string} aPath Path to the file to read.
- * @return {!Promise<!Buffer>} A promise that will resolve with a buffer of the
- *     file contents.
- */
-exports.read = function (aPath) {
-  return checkedCall((callback) => fs.readFile(aPath, callback))
-}
-
-/**
- * Writes to a file.
- *
- * @param {string} aPath Path to the file to write to.
- * @param {(string|!Buffer)} data The data to write.
- * @return {!Promise} A promise that will resolve when the operation has
- *     completed.
- */
-exports.write = function (aPath, data) {
-  return checkedCall((callback) => fs.writeFile(aPath, data, callback))
-}
-
-/**
- * Creates a directory.
- *
- * @param {string} aPath The directory path.
- * @return {!Promise<string>} A promise that will resolve with the path of the
- *     created directory.
- */
-exports.mkdir = function (aPath) {
-  return checkedCall((callback) => {
-    fs.mkdir(aPath, undefined, (err) => {
-      if (err && err.code !== 'EEXIST') {
-        callback(err)
-      } else {
-        callback(null, aPath)
-      }
-    })
-  })
-}
-
-/**
- * Recursively creates a directory and any ancestors that do not yet exist.
- *
- * @param {string} dir The directory path to create.
- * @return {!Promise<string>} A promise that will resolve with the path of the
- *     created directory.
- */
-exports.mkdirp = function mkdirp(dir) {
-  return checkedCall((callback) => {
-    fs.mkdir(dir, undefined, (err) => {
-      if (!err) {
-        callback(null, dir)
-        return
-      }
-
-      switch (err.code) {
-        case 'EEXIST':
-          callback(null, dir)
-          return
-        case 'ENOENT':
-          return mkdirp(path.dirname(dir))
-            .then(() => mkdirp(dir))
-            .then(
-              () => callback(null, dir),
-              (err) => callback(err)
-            )
-        default:
-          callback(err)
-          return
-      }
-    })
-  })
-}
-
-/**
- * Recursively walks a directory, returning a promise that will resolve with
- * a list of all files/directories seen.
- *
- * @param {string} rootPath the directory to walk.
- * @return {!Promise<!Array<{path: string, dir: boolean}>>} a promise that will
- *     resolve with a list of entries seen. For each entry, the recorded path
- *     will be relative to `rootPath`.
- */
-exports.walkDir = function (rootPath) {
-  const seen = []
-  return (function walk(dir) {
-    return checkedCall((callback) => fs.readdir(dir, callback)).then((files) =>
-      Promise.all(
-        files.map((file) => {
-          file = path.join(dir, file)
-          return checkedCall((cb) => fs.stat(file, cb)).then((stats) => {
-            seen.push({
-              path: path.relative(rootPath, file),
-              dir: stats.isDirectory(),
-            })
-            return stats.isDirectory() && walk(file)
-          })
-        })
-      )
-    )
-  })(rootPath).then(() => seen)
-}