fsevents 1.1.3 → 1.2.4

package/node_modules/node-pre-gyp/lib/util/versioning.js

@@ -6,6 +6,7 @@ var path = require('path');
 var semver = require('semver');
 var url = require('url');
 var detect_libc = require('detect-libc');
+var napi = require('./napi.js');
 
 var abi_crosswalk;
 
@@ -211,7 +212,7 @@ function validate_config(package_json) {
         if (missing.indexOf('binary') > -1) {
             missing.pop('binary');
         }
-        if (!o || o[p] === undefined) {
+        if (!o || o[p] === undefined || o[p] === "") {
             missing.push('binary.' + p);
         }
     });
@@ -225,6 +226,7 @@ function validate_config(package_json) {
             throw new Error("'host' protocol ("+protocol+") is invalid - only 'https:' is accepted");
         }
     }
+    napi.validate_package_json(package_json);
 }
 
 module.exports.validate_config = validate_config;
@@ -272,7 +274,7 @@ module.exports.get_process_runtime = get_process_runtime;
 var default_package_name = '{module_name}-v{version}-{node_abi}-{platform}-{arch}.tar.gz';
 var default_remote_path = '';
 
-module.exports.evaluate = function(package_json,options) {
+module.exports.evaluate = function(package_json,options,napi_build_version) {
     options = options || {};
     validate_config(package_json);
     var v = package_json.version;
@@ -291,6 +293,9 @@ module.exports.evaluate = function(package_json,options) {
         patch: module_version.patch,
         runtime: runtime,
         node_abi: get_runtime_abi(runtime,options.target),
+        node_abi_napi: napi.get_napi_version() ? 'napi' : get_runtime_abi(runtime,options.target),
+        napi_version: napi.get_napi_version(), // non-zero numeric, undefined if unsupported
+        napi_build_version: napi_build_version, // undefined if not specified
         target: options.target || '',
         platform: options.target_platform || process.platform,
         target_platform: options.target_platform || process.platform,

package/node_modules/node-pre-gyp/package.json

@@ -1,26 +1,26 @@
 {
-  "_from": "node-pre-gyp@^0.6.39",
-  "_id": "node-pre-gyp@0.6.39",
+  "_from": "node-pre-gyp@^0.10.0",
+  "_id": "node-pre-gyp@0.10.0",
   "_inBundle": false,
-  "_integrity": "sha512-OsJV74qxnvz/AMGgcfZoDaeDXKD3oY3QVIbBmwszTFkRisTSXbMQyn4UWzUMOtA5SVhrBZOTp0wcoSBgfMfMmQ==",
+  "_integrity": "sha512-G7kEonQLRbcA/mOoFoxvlMrw6Q6dPf92+t/l0DFSMuSlDoWaI9JWIyPwK0jyE1bph//CUEL65/Fz1m2vJbmjQQ==",
   "_location": "/node-pre-gyp",
   "_phantomChildren": {},
   "_requested": {
     "type": "range",
     "registry": true,
-    "raw": "node-pre-gyp@^0.6.39",
+    "raw": "node-pre-gyp@^0.10.0",
     "name": "node-pre-gyp",
     "escapedName": "node-pre-gyp",
-    "rawSpec": "^0.6.39",
+    "rawSpec": "^0.10.0",
     "saveSpec": null,
-    "fetchSpec": "^0.6.39"
+    "fetchSpec": "^0.10.0"
   },
   "_requiredBy": [
     "/"
   ],
-  "_resolved": "https://registry.npmjs.org/node-pre-gyp/-/node-pre-gyp-0.6.39.tgz",
-  "_shasum": "c00e96860b23c0e1420ac7befc5044e1d78d8649",
-  "_spec": "node-pre-gyp@^0.6.39",
+  "_resolved": "https://registry.npmjs.org/node-pre-gyp/-/node-pre-gyp-0.10.0.tgz",
+  "_shasum": "6e4ef5bb5c5203c6552448828c852c40111aac46",
+  "_spec": "node-pre-gyp@^0.10.0",
   "_where": "/Users/eshanker/Code/fsevents",
   "author": {
     "name": "Dane Springmeyer",
@@ -35,22 +35,22 @@
   "bundleDependencies": false,
   "dependencies": {
     "detect-libc": "^1.0.2",
-    "hawk": "3.1.3",
     "mkdirp": "^0.5.1",
+    "needle": "^2.2.0",
     "nopt": "^4.0.1",
+    "npm-packlist": "^1.1.6",
     "npmlog": "^4.0.2",
     "rc": "^1.1.7",
-    "request": "2.81.0",
     "rimraf": "^2.6.1",
     "semver": "^5.3.0",
-    "tar": "^2.2.1",
-    "tar-pack": "^3.4.0"
+    "tar": "^4"
   },
   "deprecated": false,
   "description": "Node.js native addon binary install tool",
   "devDependencies": {
     "aws-sdk": "^2.28.0",
-    "jshint": "^2.9.4",
+    "jshint": "^2.9.5",
+    "nock": "^9.2.3",
     "retire": "^1.2.12",
     "tape": "^4.6.3"
   },
@@ -79,9 +79,9 @@
     "url": "git://github.com/mapbox/node-pre-gyp.git"
   },
   "scripts": {
-    "pretest": "jshint test/build.test.js test/s3_setup.test.js test/versioning.test.js lib lib/util scripts bin/node-pre-gyp",
+    "pretest": "jshint test/build.test.js test/s3_setup.test.js test/versioning.test.js test/fetch.test.js lib lib/util scripts bin/node-pre-gyp",
     "test": "jshint lib lib/util scripts bin/node-pre-gyp && tape test/*test.js",
     "update-crosswalk": "node scripts/abi_crosswalk.js"
   },
-  "version": "0.6.39"
+  "version": "0.10.0"
 }

package/node_modules/nopt/package.json

@@ -21,7 +21,9 @@
     "saveSpec": null,
     "fetchSpec": "4.0.1"
   },
-  "_requiredBy": [],
+  "_requiredBy": [
+    "/node-pre-gyp"
+  ],
   "_resolved": "https://registry.npmjs.org/nopt/-/nopt-4.0.1.tgz",
   "_spec": "4.0.1",
   "_where": "/Users/eshanker/Code/fsevents",

package/node_modules/npm-bundled/README.md

@@ -0,0 +1,46 @@
+# npm-bundled
+
+Run this in a node package, and it'll tell you which things in
+node_modules are bundledDependencies, or transitive dependencies of
+bundled dependencies.
+
+## USAGE
+
+To get the list of deps at the top level that are bundled (or
+transitive deps of a bundled dep) run this:
+
+```js
+const bundled = require('npm-bundled')
+
+// async version
+bundled({ path: '/path/to/pkg/defaults/to/cwd'}, (er, list) => {
+  // er means it had an error, which is _hella_ weird
+  // list is a list of package names, like `fooblz` or `@corp/blerg`
+  // the might not all be deps of the top level, because transitives
+})
+
+// async promise version
+bundled({ path: '/path/to/pkg/defaults/to/cwd'}).then(list => {
+  // so promisey!
+  // actually the callback version returns a promise, too, it just
+  // attaches the supplied callback to the promise
+})
+
+// sync version, throws if there's an error
+const list = bundled({ path: '/path/to/pkg/defaults/to/cwd'})
+```
+
+That's basically all you need to know.  If you care to dig into it,
+you can also use the `bundled.Walker` and `bundled.WalkerSync`
+classes to get fancy.
+
+This library does not write anything to the filesystem, but it _may_
+have undefined behavior if the structure of `node_modules` changes
+while it's reading deps.
+
+All symlinks are followed.  This means that it can lead to surprising
+results if a symlinked bundled dependency has a missing dependency
+that is satisfied at the top level.  Since package creation resolves
+symlinks as well, this is an edge case where package creation and
+development environment are not going to be aligned, and is best
+avoided.

package/node_modules/npm-bundled/index.js

@@ -0,0 +1,227 @@
+'use strict'
+
+// walk the tree of deps starting from the top level list of bundled deps
+// Any deps at the top level that are depended on by a bundled dep that
+// does not have that dep in its own node_modules folder are considered
+// bundled deps as well.  This list of names can be passed to npm-packlist
+// as the "bundled" argument.  Additionally, packageJsonCache is shared so
+// packlist doesn't have to re-read files already consumed in this pass
+
+const fs = require('fs')
+const path = require('path')
+const EE = require('events').EventEmitter
+
+class BundleWalker extends EE {
+  constructor (opt) {
+    opt = opt || {}
+    super(opt)
+    this.path = path.resolve(opt.path || process.cwd())
+
+    this.parent = opt.parent || null
+    if (this.parent) {
+      this.result = this.parent.result
+      // only collect results in node_modules folders at the top level
+      // since the node_modules in a bundled dep is included always
+      if (!this.parent.parent) {
+        const base = path.basename(this.path)
+        const scope = path.basename(path.dirname(this.path))
+        this.result.add(/^@/.test(scope) ? scope + '/' + base : base)
+      }
+      this.root = this.parent.root
+      this.packageJsonCache = this.parent.packageJsonCache
+    } else {
+      this.result = new Set()
+      this.root = this.path
+      this.packageJsonCache = opt.packageJsonCache || new Map()
+    }
+
+    this.didDone = false
+    this.children = 0
+    this.node_modules = []
+    this.package = null
+    this.bundle = null
+  }
+
+  done () {
+    if (!this.didDone) {
+      this.didDone = true
+      if (!this.parent) {
+        const res = Array.from(this.result)
+        this.result = res
+        this.emit('done', res)
+      } else {
+        this.emit('done')
+      }
+    }
+  }
+
+  start () {
+    const pj = this.path + '/package.json'
+    if (this.packageJsonCache.has(pj))
+      this.onPackage(this.packageJsonCache.get(pj))
+    else
+      this.readPackageJson(pj)
+    return this
+  }
+
+  readPackageJson (pj) {
+    fs.readFile(pj, (er, data) =>
+      er ? this.done() : this.onPackageJson(pj, data))
+  }
+
+  onPackageJson (pj, data) {
+    try {
+      this.package = JSON.parse(data + '')
+    } catch (er) {
+      return this.done()
+    }
+    this.packageJsonCache.set(pj, this.package)
+    this.onPackage(this.package)
+  }
+
+  onPackage (pkg) {
+    // all deps are bundled if we got here as a child.
+    // otherwise, only bundle bundledDeps
+    // Get a unique-ified array with a short-lived Set
+    const bdRaw = this.parent
+      ? Object.keys(pkg.dependencies || {}).concat(
+        Object.keys(pkg.optionalDependencies || {}))
+      : pkg.bundleDependencies || pkg.bundledDependencies || []
+
+    const bd = Array.from(new Set(
+      Array.isArray(bdRaw) ? bdRaw : Object.keys(bdRaw)))
+
+    if (!bd.length)
+      return this.done()
+
+    this.bundle = bd
+    const nm = this.path + '/node_modules'
+    this.readModules()
+  }
+
+  readModules () {
+    readdirNodeModules(this.path + '/node_modules', (er, nm) =>
+      er ? this.onReaddir([]) : this.onReaddir(nm))
+  }
+
+  onReaddir (nm) {
+    // keep track of what we have, in case children need it
+    this.node_modules = nm
+
+    this.bundle.forEach(dep => this.childDep(dep))
+    if (this.children === 0)
+      this.done()
+  }
+
+  childDep (dep) {
+    if (this.node_modules.indexOf(dep) !== -1) {
+      this.child(dep)
+    } else if (this.parent) {
+      this.parent.childDep(dep)
+    }
+  }
+
+  child (dep) {
+    const p = this.path + '/node_modules/' + dep
+    this.children += 1
+    const child = new BundleWalker({
+      path: p,
+      parent: this
+    })
+    child.on('done', _ => {
+      if (--this.children === 0)
+        this.done()
+    })
+    child.start()
+  }
+}
+
+class BundleWalkerSync extends BundleWalker {
+  constructor (opt) {
+    super(opt)
+  }
+
+  start () {
+    super.start()
+    this.done()
+    return this
+  }
+
+  readPackageJson (pj) {
+    try {
+      this.onPackageJson(pj, fs.readFileSync(pj))
+    } catch (er) {}
+    return this
+  }
+
+  readModules () {
+    try {
+      this.onReaddir(readdirNodeModulesSync(this.path + '/node_modules'))
+    } catch (er) {
+      this.onReaddir([])
+    }
+  }
+
+  child (dep) {
+    new BundleWalkerSync({
+      path: this.path + '/node_modules/' + dep,
+      parent: this
+    }).start()
+  }
+}
+
+const readdirNodeModules = (nm, cb) => {
+  fs.readdir(nm, (er, set) => {
+    if (er)
+      cb(er)
+    else {
+      const scopes = set.filter(f => /^@/.test(f))
+      if (!scopes.length)
+        cb(null, set)
+      else {
+        const unscoped = set.filter(f => !/^@/.test(f))
+        let count = scopes.length
+        scopes.forEach(scope => {
+          fs.readdir(nm + '/' + scope, (er, pkgs) => {
+            if (er || !pkgs.length)
+              unscoped.push(scope)
+            else
+              unscoped.push.apply(unscoped, pkgs.map(p => scope + '/' + p))
+            if (--count === 0)
+              cb(null, unscoped)
+          })
+        })
+      }
+    }
+  })
+}
+
+const readdirNodeModulesSync = nm => {
+  const set = fs.readdirSync(nm)
+  const unscoped = set.filter(f => !/^@/.test(f))
+  const scopes = set.filter(f => /^@/.test(f)).map(scope => {
+    try {
+      const pkgs = fs.readdirSync(nm + '/' + scope)
+      return pkgs.length ? pkgs.map(p => scope + '/' + p) : [scope]
+    } catch (er) {
+      return [scope]
+    }
+  }).reduce((a, b) => a.concat(b), [])
+  return unscoped.concat(scopes)
+}
+
+const walk = (options, callback) => {
+  const p = new Promise((resolve, reject) => {
+    new BundleWalker(options).on('done', resolve).on('error', reject).start()
+  })
+  return callback ? p.then(res => callback(null, res), callback) : p
+}
+
+const walkSync = options => {
+  return new BundleWalkerSync(options).start().result
+}
+
+module.exports = walk
+walk.sync = walkSync
+walk.BundleWalker = BundleWalker
+walk.BundleWalkerSync = BundleWalkerSync

package/node_modules/npm-bundled/package.json

@@ -0,0 +1,63 @@
+{
+  "_args": [
+    [
+      "npm-bundled@1.0.3",
+      "/Users/eshanker/Code/fsevents"
+    ]
+  ],
+  "_from": "npm-bundled@1.0.3",
+  "_id": "npm-bundled@1.0.3",
+  "_inBundle": false,
+  "_integrity": "sha512-ByQ3oJ/5ETLyglU2+8dBObvhfWXX8dtPZDMePCahptliFX2iIuhyEszyFk401PZUNQH20vvdW5MLjJxkwU80Ow==",
+  "_location": "/npm-bundled",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "npm-bundled@1.0.3",
+    "name": "npm-bundled",
+    "escapedName": "npm-bundled",
+    "rawSpec": "1.0.3",
+    "saveSpec": null,
+    "fetchSpec": "1.0.3"
+  },
+  "_requiredBy": [
+    "/npm-packlist"
+  ],
+  "_resolved": "https://registry.npmjs.org/npm-bundled/-/npm-bundled-1.0.3.tgz",
+  "_spec": "1.0.3",
+  "_where": "/Users/eshanker/Code/fsevents",
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "bugs": {
+    "url": "https://github.com/npm/npm-bundled/issues"
+  },
+  "description": "list things in node_modules that are bundledDependencies, or transitive dependencies thereof",
+  "devDependencies": {
+    "mkdirp": "^0.5.1",
+    "mutate-fs": "^1.1.0",
+    "rimraf": "^2.6.1",
+    "tap": "^10.3.2"
+  },
+  "files": [
+    "index.js"
+  ],
+  "homepage": "https://github.com/npm/npm-bundled#readme",
+  "license": "ISC",
+  "main": "index.js",
+  "name": "npm-bundled",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/npm-bundled.git"
+  },
+  "scripts": {
+    "postpublish": "git push origin --all; git push origin --tags",
+    "postversion": "npm publish",
+    "preversion": "npm test",
+    "test": "tap test/*.js -J --100"
+  },
+  "version": "1.0.3"
+}

package/node_modules/npm-packlist/README.md

@@ -0,0 +1,68 @@
+# npm-packlist
+
+[![Build Status](https://travis-ci.com/npm/npm-packlist.svg?token=hHeDp9pQmz9kvsgRNVHy&branch=master)](https://travis-ci.com/npm/npm-packlist)
+
+Get a list of the files to add from a folder into an npm package
+
+These can be handed to [tar](http://npm.im/tar) like so to make an npm
+package tarball:
+
+```js
+const packlist = require('npm-packlist')
+const tar = require('tar')
+const packageDir = '/path/to/package'
+const packageTarball = '/path/to/package.tgz'
+
+packlist({ path: packageDir })
+  .then(files => tar.create({
+    prefix: 'package/',
+    cwd: packageDir,
+    file: packageTarball,
+    gzip: true
+  }, files))
+  .then(_ => {
+    // tarball has been created, continue with your day
+  })
+```
+
+This uses the following rules:
+
+1. If a `package.json` file is found, and it has a `files` list,
+   then ignore everything that isn't in `files`.  Always include the
+   readme, license, notice, changes, changelog, and history files, if
+   they exist, and the package.json file itself.
+2. If there's no `package.json` file (or it has no `files` list), and
+   there is a `.npmignore` file, then ignore all the files in the
+   `.npmignore` file.
+3. If there's no `package.json` with a `files` list, and there's no
+   `.npmignore` file, but there is a `.gitignore` file, then ignore
+   all the files in the `.gitignore` file.
+4. Everything in the root `node_modules` is ignored, unless it's a
+   bundled dependency.  If it IS a bundled dependency, and it's a
+   symbolic link, then the target of the link is included, not the
+   symlink itself.
+4. Unless they're explicitly included (by being in a `files` list, or
+   a `!negated` rule in a relevant `.npmignore` or `.gitignore`),
+   always ignore certain common cruft files:
+
+    1. .npmignore and .gitignore files (their effect is in the package
+       already, there's no need to include them in the package)
+    2. editor junk like `.*.swp`, `._*` and `.*.orig` files
+    3. `.npmrc` files (these may contain private configs)
+    4. The `node_modules/.bin` folder
+    5. Waf and gyp cruft like `/build/config.gypi` and `.lock-wscript`
+    6. Darwin's `.DS_Store` files because wtf are those even
+    7. `npm-debug.log` files at the root of a project
+
+    You can explicitly re-include any of these with a `files` list in
+    `package.json` or a negated ignore file rule.
+
+## API
+
+Same API as [ignore-walk](http://npm.im/ignore-walk), just hard-coded
+file list and rule sets.
+
+The `Walker` and `WalkerSync` classes take a `bundled` argument, which
+is a list of package names to include from node_modules.  When calling
+the top-level `packlist()` and `packlist.sync()` functions, this
+module calls into `npm-bundled` directly.