fix(deps): update dependencies & Node 16 supports

.githooks/pre-commit

@@ -0,0 +1,2 @@
+#!/bin/sh
+npx --no-install lint-staged

.github/workflows/test.yml

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [10, 12, 14]
+        node-version: [ 12, 14, 16 ]
     steps:
       - name: checkout
         uses: actions/checkout@v2

.mocharc.json

@@ -0,0 +1,3 @@
+{
+  "timeout": "5000"
+}

bin/cmd.js

@@ -36,7 +36,7 @@ canNpmPublish(cli.input[0], {
     .then(() => {
         process.exit(0);
     })
-    .catch(error => {
+    .catch((error) => {
         if (cli.flags.verbose) {
             console.error(error.message);
         }

lib/can-npm-publish.js

@@ -1,16 +1,32 @@
 // MIT © 2018 azu
 "use strict";
+const path = require("path");
 const spawn = require("cross-spawn");
 const readPkg = require("read-pkg");
 const validatePkgName = require("validate-npm-package-name");
+/**
+ * @param {string} [filePathOrDirPath]
+ * @returns {Promise<readPkg.NormalizedPackageJson>}
+ */
+const readPkgWithPath = (filePathOrDirPath) => {
+    if (filePathOrDirPath) {
+        const isJSON = path.extname(filePathOrDirPath) === ".json";
+        if (isJSON) {
+            return Promise.resolve(require(filePathOrDirPath));
+        }
+        return readPkg({ cwd: filePathOrDirPath });
+    } else {
+        return readPkg();
+    }
+};
 /**
  * Return rejected promise if the package name is invalid
  * @param {string} packagePath
  * @param {{verbose:boolean}} options
  * @returns {Promise}
  */
 const checkPkgName = (packagePath, options) => {
-    return readPkg(packagePath).then(pkg => {
+    return readPkgWithPath(packagePath).then((pkg) => {
         const name = pkg["name"];
         const result = validatePkgName(name);
         // Treat Legacy Names as valid
@@ -34,8 +50,8 @@ const checkPkgName = (packagePath, options) => {
  * @param {string} packagePath
  * @returns {Promise}
  */
-const checkPrivateField = packagePath => {
-    return readPkg(packagePath).then(pkg => {
+const checkPrivateField = (packagePath) => {
+    return readPkgWithPath(packagePath).then((pkg) => {
         if (pkg["private"] === true) {
             return Promise.reject(new Error("This package is private."));
         }
@@ -56,15 +72,18 @@ const viewPackage = (packageName, registry) => {
         let result = "";
         let errorResult = "";
 
-        view.stdout.on("data", data => {
+        view.stdout.on("data", (data) => {
             result += data.toString();
         });
 
-        view.stderr.on("data", err => {
+        view.stderr.on("data", (err) => {
             errorResult += err.toString();
         });
 
-        view.on("close", code => {
+        view.on("close", (code) => {
+            if (code !== 0) {
+                return reject(new Error(errorResult));
+            }
             const resultJSON = JSON.parse(result);
             if (resultJSON && resultJSON.error) {
                 // the package is not in the npm registry => can publish
@@ -75,13 +94,13 @@ const viewPackage = (packageName, registry) => {
                     return reject(new Error(errorResult));
                 }
             }
-            resolve(JSON.parse(result));
+            resolve(resultJSON);
         });
     });
 };
 
-const checkAlreadyPublish = packagePath => {
-    return readPkg(packagePath).then(pkg => {
+const checkAlreadyPublish = (packagePath) => {
+    return readPkgWithPath(packagePath).then((pkg) => {
         const name = pkg["name"];
         const version = pkg["version"];
         const publishConfig = pkg["publishConfig"];
@@ -92,7 +111,7 @@ const checkAlreadyPublish = packagePath => {
         if (version === undefined) {
             return Promise.reject(new Error("This package has no `version`."));
         }
-        return viewPackage(name, registry).then(versions => {
+        return viewPackage(name, registry).then((versions) => {
             if (versions.includes(version)) {
                 return Promise.reject(new Error(`${name}@${version} is already published`));
             }

package.json

@@ -32,31 +32,31 @@
   },
   "scripts": {
     "test": "mocha test",
-    "prettier": "prettier --write \"**/*.{js,jsx,ts,tsx,css}\"",
     "precommit": "lint-staged",
-    "postcommit": "git reset"
+    "postcommit": "git reset",
+    "format": "prettier --write \"**/*.{js,jsx,ts,tsx,css}\"",
+    "prepare": "git config --local core.hooksPath .githooks"
   },
   "dependencies": {
-    "cross-spawn": "^6.0.5",
-    "meow": "^4.0.0",
-    "read-pkg": "^3.0.0",
+    "cross-spawn": "^7.0.3",
+    "meow": "^9.0.0",
+    "read-pkg": "^5.0.0",
     "validate-npm-package-name": "^3.0.0"
   },
   "devDependencies": {
-    "husky": "^0.14.3",
-    "lint-staged": "^6.0.1",
-    "mocha": "^5.0.0",
-    "prettier": "^1.10.2"
+    "lint-staged": "^11.0.0",
+    "mocha": "^9.0.0",
+    "prettier": "^2.3.1"
   },
   "prettier": {
     "singleQuote": false,
     "printWidth": 120,
-    "tabWidth": 4
+    "tabWidth": 4,
+    "trailingComma": "none"
   },
   "lint-staged": {
     "*.{js,jsx,ts,tsx,css}": [
-      "prettier --write",
-      "git add"
+      "prettier --write"
     ]
   }
 }

test/can-npm-publish-bin-test.js

@@ -10,29 +10,29 @@ const shouldNotCalled = () => {
 };
 
 describe("can-npm-publish bin", () => {
-    it("should return 0, it can publish", done => {
+    it("should return 0, it can publish", (done) => {
         const bin = spawn("node", [binPath, path.join(__dirname, "fixtures/not-published-yet.json")]);
 
         // Finish the test when the executable finishes and returns 0
-        bin.on("close", exit_code => {
+        bin.on("close", (exit_code) => {
             assert.ok(exit_code === 0);
             done();
         });
     });
-    it("should return 1, it can't publish", done => {
+    it("should return 1, it can't publish", (done) => {
         const bin = spawn("node", [binPath, path.join(__dirname, "fixtures/already-published.json")]);
 
         // Finish the test when the executable finishes and returns 1
-        bin.on("close", exit_code => {
+        bin.on("close", (exit_code) => {
             assert.ok(exit_code === 1);
             done();
         });
     });
-    it("should send errors to stderr when verbose, it can't publish", done => {
+    it("should send errors to stderr when verbose, it can't publish", (done) => {
         const bin = spawn("node", [binPath, path.join(__dirname, "fixtures/already-published.json"), "--verbose"]);
 
         // Finish the test and stop the executable when it outputs to stderr
-        bin.stderr.on("data", data => {
+        bin.stderr.on("data", (data) => {
             assert.ok(/almin@0.15.2 is already published/.test(data));
             bin.kill();
             done();

test/can-npm-publish-test.js

@@ -7,30 +7,30 @@ const shouldNotCalled = () => {
 };
 describe("can-npm-publish", () => {
     it("should be rejected, it is invalid name", () => {
-        return canNpmPublish(path.join(__dirname, "fixtures/invalid-name.json")).then(shouldNotCalled, error => {
-            assert.ok(/Invalid name/s.test(error.message));
+        return canNpmPublish(path.join(__dirname, "fixtures/invalid-name.json")).then(shouldNotCalled, (error) => {
+            assert.ok(/name can only contain URL-friendly characters/s.test(error.message));
         });
     });
     it("should be rejected, it is private:true", () => {
-        return canNpmPublish(path.join(__dirname, "fixtures/private.json")).then(shouldNotCalled, error => {
+        return canNpmPublish(path.join(__dirname, "fixtures/private.json")).then(shouldNotCalled, (error) => {
             assert.ok(/This package is private/.test(error.message));
         });
     });
     it("should be rejected, it is already published", () => {
-        return canNpmPublish(path.join(__dirname, "fixtures/already-published.json")).then(shouldNotCalled, error => {
+        return canNpmPublish(path.join(__dirname, "fixtures/already-published.json")).then(shouldNotCalled, (error) => {
             assert.ok(/is already published/.test(error.message));
         });
     });
     it("should be rejected, it is already published to yarnpkg registry", () => {
         return canNpmPublish(path.join(__dirname, "fixtures/already-published-registry.json")).then(
             shouldNotCalled,
-            error => {
+            (error) => {
                 assert.ok(/is already published/.test(error.message));
             }
         );
     });
     it("should be rejected, it is already published scoped package", () => {
-        return canNpmPublish(path.join(__dirname, "fixtures/scoped-package.json")).then(shouldNotCalled, error => {
+        return canNpmPublish(path.join(__dirname, "fixtures/scoped-package.json")).then(shouldNotCalled, (error) => {
             assert.ok(/is already published/.test(error.message));
         });
     });
@@ -51,11 +51,16 @@ describe("can-npm-publish", () => {
             }
         };
 
-        return canNpmPublish(path.join(__dirname, "fixtures/legacy-name.json"), { verbose: true }).then(() => {
-            // Restore stderr to normal
-            process.stderr.write = stderrWrite;
-
-            assert.ok(/name can no longer contain capital letters/.test(stderrOutput));
-        }, shouldNotCalled);
+        return canNpmPublish(path.join(__dirname, "fixtures/legacy-name.json"), { verbose: true }).then(
+            () => {
+                // Restore stderr to normal
+                process.stderr.write = stderrWrite;
+                assert.ok(/name can no longer contain capital letters/.test(stderrOutput));
+            },
+            (error) => {
+                console.log(error);
+                shouldNotCalled();
+            }
+        );
     });
 });

test/fixtures/legacy-name.json

@@ -1,5 +1,5 @@
 {
   "private": false,
-  "name": "lEgAcY-nAmE",
+  "name": "JSONStream",
   "version": "1.0.0"
 }