eslint-plugin-node-dependencies 0.7.0 → 0.9.1

package/README.md

@@ -33,7 +33,7 @@ npm install --save-dev eslint eslint-plugin-node-dependencies
 > **Requirements**
 >
 > - ESLint v6.0.0 and above
-> - Node.js v12.x, v14.x and above
+> - Node.js v14.16.0 and above
 
 <!--DOCS_IGNORE_END-->
 
@@ -119,6 +119,7 @@ The rules with the following star :star: are included in the `plugin:node-depend
 | Rule ID | Description |    |
 |:--------|:------------|:---|
 | [node-dependencies/compat-engines](https://ota-meshi.github.io/eslint-plugin-node-dependencies/rules/compat-engines.html) | enforce the versions of the engines of the dependencies to be compatible. | :star: |
+| [node-dependencies/no-dupe-deps](https://ota-meshi.github.io/eslint-plugin-node-dependencies/rules/no-dupe-deps.html) | disallow duplicate dependencies. | :star: |
 | [node-dependencies/valid-semver](https://ota-meshi.github.io/eslint-plugin-node-dependencies/rules/valid-semver.html) | enforce versions that is valid as a semantic version. | :star: |
 
 ### Best Practices
@@ -127,6 +128,14 @@ The rules with the following star :star: are included in the `plugin:node-depend
 |:--------|:------------|:---|
 | [node-dependencies/absolute-version](https://ota-meshi.github.io/eslint-plugin-node-dependencies/rules/absolute-version.html) | require or disallow absolute version of dependency. |  |
 | [node-dependencies/no-deprecated](https://ota-meshi.github.io/eslint-plugin-node-dependencies/rules/no-deprecated.html) | disallow having dependencies on deprecate packages. |  |
+| [node-dependencies/no-restricted-deps](https://ota-meshi.github.io/eslint-plugin-node-dependencies/rules/no-restricted-deps.html) | Disallows dependence on the specified package. |  |
+
+### Stylistic Issues
+
+| Rule ID | Description |    |
+|:--------|:------------|:---|
+| [node-dependencies/prefer-caret-range-version](https://ota-meshi.github.io/eslint-plugin-node-dependencies/rules/prefer-caret-range-version.html) | require caret(`^`) version instead of range version. | :wrench: |
+| [node-dependencies/prefer-tilde-range-version](https://ota-meshi.github.io/eslint-plugin-node-dependencies/rules/prefer-tilde-range-version.html) | require tilde(`~`) version instead of range version. | :wrench: |
 
 ### Deprecated
 

package/dist/configs/recommended.js

@@ -7,6 +7,7 @@ module.exports = {
             parser: require.resolve("jsonc-eslint-parser"),
             rules: {
                 "node-dependencies/compat-engines": "error",
+                "node-dependencies/no-dupe-deps": "error",
                 "node-dependencies/valid-semver": "error",
             },
         },

package/dist/rules/absolute-version.js

@@ -100,6 +100,9 @@ exports.default = (0, utils_1.createRule)("absolute-version", {
         type: "suggestion",
     },
     create(context) {
+        if (!context.parserServices.isJSON) {
+            return {};
+        }
         const getOption = parseOption(context.options[0]);
         function defineVisitor(visitName) {
             return (node) => {

package/dist/rules/compat-engines.js

@@ -160,7 +160,7 @@ exports.default = (0, utils_1.createRule)("compat-engines", {
         }
         function processDependencyModule(ctx, name, ver, modules, node) {
             const currModules = [...modules, `${name}@${ver}`];
-            processMeta(ctx, (0, meta_1.getMetaFromNodeModules)(name, ver, context));
+            processMeta(ctx, (0, meta_1.getMetaFromNodeModules)(name, ver, { context }));
             if (!ctx.hasInvalid() && ctx.isAllProcessed()) {
                 return;
             }

package/dist/rules/no-dupe-deps.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const ast_utils_1 = require("../utils/ast-utils");
+const DEPS = [
+    "dependencies",
+    "peerDependencies",
+    "optionalDependencies",
+    "devDependencies",
+];
+class AllowDuplicates {
+    constructor() {
+        this.edges = [];
+    }
+    add(d1, d2) {
+        this.edges.push([d1, d2]);
+    }
+    isAllowedDuplicate(dep1, dep2) {
+        return this.edges.some(([d1, d2]) => (d1 === dep1 && d2 === dep2) || (d2 === dep1 && d1 === dep2));
+    }
+}
+exports.default = (0, utils_1.createRule)("no-dupe-deps", {
+    meta: {
+        docs: {
+            description: "disallow duplicate dependencies.",
+            category: "Possible Errors",
+            recommended: true,
+        },
+        schema: [],
+        messages: {
+            duplicated: "Duplicated dependency '{{name}}'.",
+        },
+        type: "problem",
+    },
+    create(context) {
+        if (!context.parserServices.isJSON) {
+            return {};
+        }
+        const allowDuplicates = new AllowDuplicates();
+        allowDuplicates.add("devDependencies", "peerDependencies");
+        allowDuplicates.add("devDependencies", "optionalDependencies");
+        const maps = {
+            dependencies: new Map(),
+            peerDependencies: new Map(),
+            optionalDependencies: new Map(),
+            devDependencies: new Map(),
+        };
+        const reported = new Set();
+        function report(name, node) {
+            if (reported.has(node)) {
+                return;
+            }
+            reported.add(node);
+            context.report({
+                loc: node.key.loc,
+                messageId: "duplicated",
+                data: {
+                    name,
+                },
+            });
+        }
+        function verify(depsName, name, node) {
+            for (const dep of DEPS) {
+                if (allowDuplicates.isAllowedDuplicate(dep, depsName)) {
+                    continue;
+                }
+                const dupeNode = maps[dep].get(name);
+                if (dupeNode) {
+                    report(name, dupeNode);
+                    report(name, node);
+                }
+            }
+        }
+        function defineVisitor(depsName) {
+            return (node) => {
+                const name = String((0, ast_utils_1.getKeyFromJSONProperty)(node));
+                verify(depsName, name, node);
+                maps[depsName].set(name, node);
+            };
+        }
+        return (0, utils_1.defineJsonVisitor)({
+            dependencies: defineVisitor("dependencies"),
+            peerDependencies: defineVisitor("peerDependencies"),
+            optionalDependencies: defineVisitor("optionalDependencies"),
+            devDependencies: defineVisitor("devDependencies"),
+        });
+    },
+});

package/dist/rules/no-restricted-deps.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const regexp_1 = require("../utils/regexp");
+const semver_1 = require("semver");
+const semver_2 = require("../utils/semver");
+const ast_utils_1 = require("../utils/ast-utils");
+const jsonc_eslint_parser_1 = require("jsonc-eslint-parser");
+const meta_1 = require("../utils/meta");
+const DEPS = [
+    "dependencies",
+    "peerDependencies",
+    "optionalDependencies",
+];
+class Deps {
+    constructor() {
+        this.map = Object.create(null);
+        this.list = [];
+    }
+    push(name, ver, ownerPackageJsonPath) {
+        const range = (0, semver_2.getSemverRange)(ver);
+        if (range) {
+            const data = this.map[name];
+            if (data) {
+                const newRange = (0, semver_2.normalizeSemverRange)(data.range, range);
+                this.map[name] = {
+                    range: newRange,
+                    ownerPackageJsonPath: ownerPackageJsonPath || data.ownerPackageJsonPath,
+                };
+            }
+            else {
+                this.map[name] = {
+                    range,
+                    ownerPackageJsonPath,
+                };
+            }
+            return;
+        }
+        this.list.push({ name, ver, ownerPackageJsonPath });
+    }
+    pop() {
+        const resultForList = this.list.shift();
+        if (resultForList) {
+            return resultForList;
+        }
+        const [key] = Object.keys(this.map);
+        if (key) {
+            const data = this.map[key];
+            delete this.map[key];
+            return {
+                name: key,
+                ver: (0, semver_2.normalizeVer)(data.range),
+                ownerPackageJsonPath: data.ownerPackageJsonPath,
+            };
+        }
+        return null;
+    }
+}
+class DeepValidateContext {
+    constructor(context, validator) {
+        this.deepValidatedCache = new Map();
+        this.context = context;
+        this.validator = validator;
+    }
+    buildDeepValidator(deepOption) {
+        return (n, v) => this.deepDepsValidate(n, v, deepOption);
+    }
+    deepDepsValidate(packageName, version, deepOption) {
+        const { validator: validate, context } = this;
+        const depsQueue = new Deps();
+        depsQueue.push(packageName, version);
+        let dep;
+        while ((dep = depsQueue.pop())) {
+            const key = `${dep.name}@${dep.ver}`;
+            if (this.deepValidatedCache.has(key)) {
+                const result = this.deepValidatedCache.get(key);
+                if (result) {
+                    return result;
+                }
+            }
+            else {
+                const result = validateWithoutCache(dep.name, dep.ver, dep.ownerPackageJsonPath);
+                this.deepValidatedCache.set(key, result);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        return null;
+        function validateWithoutCache(name, ver, ownerPackageJsonPath) {
+            const result = validate(name, ver);
+            if (result) {
+                return result;
+            }
+            for (const { name: n, ver: v, packageJsonPath } of iterateDeps(name, ver, ownerPackageJsonPath)) {
+                const r = validate(n, v);
+                if (r) {
+                    return r;
+                }
+                depsQueue.push(n, v, packageJsonPath);
+            }
+            return null;
+        }
+        function* iterateDeps(name, ver, ownerPackageJsonPath) {
+            yield* iterateDepsForMeta((0, meta_1.getMetaFromNodeModules)(name, ver, {
+                context,
+                ownerPackageJsonPath,
+            }));
+            if (deepOption === "server") {
+                const metaData = (0, meta_1.getMetaFromNpm)(name, ver);
+                for (const meta of metaData.cache) {
+                    yield* iterateDepsForMeta(meta);
+                }
+                const metaList = metaData.get();
+                if (metaList) {
+                    for (const meta of metaList) {
+                        yield* iterateDepsForMeta(meta);
+                    }
+                }
+            }
+        }
+        function* iterateDepsForMeta(meta) {
+            if (!meta) {
+                return;
+            }
+            for (const depName of DEPS) {
+                const deps = meta[depName];
+                if (!deps) {
+                    continue;
+                }
+                for (const [n, v] of Object.entries(deps)) {
+                    if (typeof v === "string") {
+                        yield { name: n, ver: v, packageJsonPath: meta._where };
+                    }
+                }
+            }
+        }
+    }
+}
+exports.default = (0, utils_1.createRule)("no-restricted-deps", {
+    meta: {
+        docs: {
+            description: "Disallows dependence on the specified package.",
+            category: "Best Practices",
+            recommended: false,
+        },
+        schema: {
+            type: "array",
+            items: {
+                oneOf: [
+                    {
+                        type: "string",
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            package: { type: "string" },
+                            version: { type: "string" },
+                            message: { type: "string" },
+                            deep: { enum: ["local", "server"] },
+                        },
+                        required: ["package"],
+                        additionalProperties: false,
+                    },
+                ],
+            },
+            uniqueItems: true,
+            minItems: 0,
+        },
+        messages: {
+            restricted: "{{message}}",
+        },
+        type: "suggestion",
+    },
+    create(context) {
+        if (!context.parserServices.isJSON) {
+            return {};
+        }
+        const validateForPackage = parseOptions(context.options);
+        function defineVisitor(_depsName) {
+            return (node) => {
+                const name = String((0, ast_utils_1.getKeyFromJSONProperty)(node));
+                const ver = String((0, jsonc_eslint_parser_1.getStaticJSONValue)(node.value));
+                const result = validateForPackage(name, ver);
+                if (!result) {
+                    return;
+                }
+                context.report({
+                    loc: node.loc,
+                    messageId: "restricted",
+                    data: result,
+                });
+            };
+        }
+        return (0, utils_1.defineJsonVisitor)({
+            dependencies: defineVisitor("dependencies"),
+            peerDependencies: defineVisitor("peerDependencies"),
+            optionalDependencies: defineVisitor("optionalDependencies"),
+            devDependencies: defineVisitor("devDependencies"),
+        });
+        function matchVersions(version, optionVersion) {
+            if (!optionVersion) {
+                return true;
+            }
+            const range = (0, semver_2.getSemverRange)(version);
+            return Boolean(range && (0, semver_1.intersects)(range, optionVersion));
+        }
+        function parseOption(option) {
+            if (typeof option === "string") {
+                const regexp = (0, regexp_1.toRegExp)(option);
+                return (n, _v) => {
+                    if (regexp.test(n)) {
+                        return {
+                            message: `Depend on '${option}' is not allowed.`,
+                        };
+                    }
+                    return null;
+                };
+            }
+            const regexp = (0, regexp_1.toRegExp)(option.package);
+            const version = option.version
+                ? (0, semver_2.getSemverRange)(option.version)
+                : null;
+            const validator = (n, v) => {
+                if (regexp.test(n) && matchVersions(v, version)) {
+                    return {
+                        message: option.message || buildDefaultMessage(option),
+                    };
+                }
+                return null;
+            };
+            if (!option.deep) {
+                return validator;
+            }
+            const deepValidateContext = new DeepValidateContext(context, validator);
+            return deepValidateContext.buildDeepValidator(option.deep);
+            function buildDefaultMessage(objectOption) {
+                const versionForMessage = objectOption.version
+                    ? `@${objectOption.version}`
+                    : "";
+                if (objectOption.package.startsWith("/") && versionForMessage) {
+                    return `Depend on '${objectOption.package} ${versionForMessage}' is not allowed.`;
+                }
+                return `Depend on '${objectOption.package}${versionForMessage}' is not allowed.`;
+            }
+        }
+        function parseOptions(options) {
+            const validators = options.map(parseOption);
+            return (packageName, version) => {
+                for (const validator of validators) {
+                    const result = validator(packageName, version);
+                    if (result)
+                        return result;
+                }
+                return null;
+            };
+        }
+    },
+});

package/dist/rules/prefer-caret-range-version.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const semver_1 = require("semver");
+const utils_1 = require("../utils");
+const semver_2 = require("../utils/semver");
+const semver_range_1 = require("../utils/semver-range");
+exports.default = (0, utils_1.createRule)("prefer-caret-range-version", {
+    meta: {
+        docs: {
+            description: "require caret(`^`) version instead of range version.",
+            category: "Stylistic Issues",
+            recommended: false,
+        },
+        fixable: "code",
+        schema: [],
+        messages: {},
+        type: "suggestion",
+    },
+    create(context) {
+        if (!context.parserServices.isJSON) {
+            return {};
+        }
+        const sourceCode = context.getSourceCode();
+        function convertToUseCaret(range) {
+            if (range.comparators.length !== 2) {
+                return null;
+            }
+            const start = range.comparators.find((c) => c.operator === ">=");
+            const end = range.comparators.find((c) => c.operator === "<");
+            if (!start || !end) {
+                return null;
+            }
+            const caretRangeText = `^${start.semver.version}`;
+            const caretRange = (0, semver_2.getSemverRange)(caretRangeText);
+            if (!caretRange) {
+                return null;
+            }
+            const caretEnd = caretRange.set[0].find((c) => c.operator === "<");
+            if (!caretEnd) {
+                return null;
+            }
+            if (caretEnd.semver.compare(end.semver) !== 0) {
+                const endPre = new semver_1.SemVer(`${end.semver.version}-0`);
+                if (caretEnd.semver.compare(endPre) !== 0) {
+                    return null;
+                }
+            }
+            return caretRangeText;
+        }
+        function verifyRange(range, node) {
+            const fixedRange = convertToUseCaret(range);
+            if (!fixedRange) {
+                return;
+            }
+            context.report({
+                loc: {
+                    start: sourceCode.getLocFromIndex(node.range[0] + range.range[0]),
+                    end: sourceCode.getLocFromIndex(node.range[0] + range.range[1]),
+                },
+                message: `Use '${fixedRange}' syntax instead.`,
+                fix(fixer) {
+                    return fixer.replaceTextRange(node.range, JSON.stringify(node.value.slice(0, range.range[0]) +
+                        fixedRange +
+                        node.value.slice(range.range[1])));
+                },
+            });
+        }
+        function verifyVersion(node) {
+            if (maybeDepId(node.value)) {
+                return;
+            }
+            for (const range of (0, semver_range_1.iterateSemverRanges)(node.value)) {
+                const lowerRange = range.value.toLowerCase();
+                if (!lowerRange.startsWith("~")) {
+                    if (lowerRange.startsWith("^") ||
+                        /^\d+$/u.test(range.value) ||
+                        ((range.value.endsWith(".x") ||
+                            range.value.endsWith(".*")) &&
+                            !/\s+-\s+/u.test(range.value)))
+                        continue;
+                }
+                verifyRange(range, node);
+            }
+        }
+        return (0, utils_1.defineJsonVisitor)({
+            "engines, dependencies, peerDependencies, devDependencies, optionalDependencies"(node) {
+                if (isJSONStringLiteral(node.value)) {
+                    verifyVersion(node.value);
+                }
+            },
+        });
+    },
+});
+function isJSONStringLiteral(node) {
+    return node.type === "JSONLiteral" && typeof node.value === "string";
+}
+function maybeDepId(ver) {
+    return ver.includes("/") || ver.includes(":") || /^[-a-z]+$/.test(ver);
+}

package/dist/rules/prefer-tilde-range-version.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const semver_1 = require("semver");
+const utils_1 = require("../utils");
+const semver_2 = require("../utils/semver");
+const semver_range_1 = require("../utils/semver-range");
+exports.default = (0, utils_1.createRule)("prefer-tilde-range-version", {
+    meta: {
+        docs: {
+            description: "require tilde(`~`) version instead of range version.",
+            category: "Stylistic Issues",
+            recommended: false,
+        },
+        fixable: "code",
+        schema: [],
+        messages: {},
+        type: "suggestion",
+    },
+    create(context) {
+        if (!context.parserServices.isJSON) {
+            return {};
+        }
+        const sourceCode = context.getSourceCode();
+        function convertToUseTilde(range) {
+            if (range.comparators.length !== 2) {
+                return null;
+            }
+            const start = range.comparators.find((c) => c.operator === ">=");
+            const end = range.comparators.find((c) => c.operator === "<");
+            if (!start || !end) {
+                return null;
+            }
+            const tildeRangeText = `~${start.semver.version}`;
+            const tildeRange = (0, semver_2.getSemverRange)(tildeRangeText);
+            if (!tildeRange) {
+                return null;
+            }
+            const tildeEnd = tildeRange.set[0].find((c) => c.operator === "<");
+            if (!tildeEnd) {
+                return null;
+            }
+            if (tildeEnd.semver.compare(end.semver) !== 0) {
+                const endPre = new semver_1.SemVer(`${end.semver.version}-0`);
+                if (tildeEnd.semver.compare(endPre) !== 0) {
+                    return null;
+                }
+            }
+            return tildeRangeText;
+        }
+        function verifyRange(range, node) {
+            const fixedRange = convertToUseTilde(range);
+            if (!fixedRange) {
+                return;
+            }
+            context.report({
+                loc: {
+                    start: sourceCode.getLocFromIndex(node.range[0] + range.range[0]),
+                    end: sourceCode.getLocFromIndex(node.range[0] + range.range[1]),
+                },
+                message: `Use '${fixedRange}' syntax instead.`,
+                fix(fixer) {
+                    return fixer.replaceTextRange(node.range, JSON.stringify(node.value.slice(0, range.range[0]) +
+                        fixedRange +
+                        node.value.slice(range.range[1])));
+                },
+            });
+        }
+        function verifyVersion(node) {
+            if (maybeDepId(node.value)) {
+                return;
+            }
+            for (const range of (0, semver_range_1.iterateSemverRanges)(node.value)) {
+                const lowerRange = range.value.toLowerCase();
+                if (!lowerRange.startsWith("^")) {
+                    if (lowerRange.startsWith("~") ||
+                        /^\d+$/u.test(range.value) ||
+                        /^\d+\.\d+$/u.test(range.value) ||
+                        ((range.value.endsWith(".x") ||
+                            range.value.endsWith(".*")) &&
+                            !/\s+-\s+/u.test(range.value)))
+                        continue;
+                }
+                verifyRange(range, node);
+            }
+        }
+        return (0, utils_1.defineJsonVisitor)({
+            "engines, dependencies, peerDependencies, devDependencies, optionalDependencies"(node) {
+                if (isJSONStringLiteral(node.value)) {
+                    verifyVersion(node.value);
+                }
+            },
+        });
+    },
+});
+function isJSONStringLiteral(node) {
+    return node.type === "JSONLiteral" && typeof node.value === "string";
+}
+function maybeDepId(ver) {
+    return ver.includes("/") || ver.includes(":") || /^[-a-z]+$/.test(ver);
+}

package/dist/rules/valid-semver.js

@@ -36,7 +36,7 @@ exports.default = (0, utils_1.createRule)("valid-semver", {
                     });
                 }
             },
-            "dependencies, peerDependencies, devDependencies"(node) {
+            "dependencies, peerDependencies, devDependencies, optionalDependencies"(node) {
                 const name = (0, ast_utils_1.getKeyFromJSONProperty)(node);
                 if (typeof name !== "string") {
                     return;

package/dist/utils/meta.js

@@ -1,36 +1,55 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDependencies = exports.getEngines = exports.getMetaFromNpm = exports.getMetaFromNodeModules = void 0;
 const module_1 = __importDefault(require("module"));
-const child_process_1 = require("child_process");
-const path_1 = __importDefault(require("path"));
+const path_1 = __importStar(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const semver_1 = require("./semver");
 const semver_2 = require("semver");
 const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
+const package_json_1 = require("./package-json");
 const TTL = 1000 * 60 * 60;
-const NPM_INFO_PROPERTIES = [
-    "version",
-    "engines",
-    "deprecated",
-    "dependencies",
-    "peerDependencies",
-    "dist-tags",
-];
 const CACHED_META_ROOT = path_1.default.join(__dirname, `../../.cached_meta`);
-function getMetaFromNodeModules(name, ver, context) {
+function getMetaFromNodeModules(name, ver, options) {
     try {
-        const cwd = getCwd(context);
-        const relativeTo = path_1.default.join(cwd, "__placeholder__.js");
+        const ownerJsonPath = options.ownerPackageJsonPath || options.context.getFilename();
+        const relativeTo = path_1.default.join(ownerJsonPath && path_1.default.isAbsolute(ownerJsonPath)
+            ? (0, path_1.dirname)(ownerJsonPath)
+            : getCwd(options.context), "__placeholder__.js");
         const req = module_1.default.createRequire(relativeTo);
-        const pkg = req(`${name}/package.json`);
+        const where = req.resolve(`${name}/package.json`);
+        const pkg = req(where);
         if (maybeMeta(pkg)) {
             const vr = (0, semver_1.getSemverRange)(ver);
             if (typeof pkg.version === "string" &&
                 (!vr || (0, semver_2.satisfies)(pkg.version, vr))) {
+                pkg._where = where;
                 return pkg;
             }
         }
@@ -54,85 +73,91 @@ function getMetaFromNpm(name, ver) {
             (parsed.type === "range" ||
                 parsed.type === "version" ||
                 parsed.type === "tag")) {
-            return getMetaFromNpmView(parsed.name, (_a = parsed.fetchSpec) === null || _a === void 0 ? void 0 : _a.trim());
+            return getMetaFromNameAndSpec(parsed.name, (_a = parsed.fetchSpec) === null || _a === void 0 ? void 0 : _a.trim());
         }
     }
     if (trimmed.includes("/") || trimmed.includes(":")) {
         return { cache: [], get: () => [] };
     }
-    return getMetaFromNpmView(name, ver.trim());
+    return getMetaFromNameAndSpec(name, ver.trim());
 }
 exports.getMetaFromNpm = getMetaFromNpm;
-function getMetaFromNpmView(name, verOrTag) {
-    const range = (0, semver_1.getSemverRange)(verOrTag);
+function getMetaFromNameAndSpec(name, verOrTag) {
+    const cachedFilePath = path_1.default.join(CACHED_META_ROOT, `${name}.json`);
+    const { cache, get } = getMetaFromName(name, cachedFilePath);
+    let isTargetVersion;
+    let hasUnknown = false;
+    const range = (0, semver_1.getSemverRange)(verOrTag || "*");
     if (range) {
-        const min = (0, semver_2.minVersion)(range);
-        if (min) {
-            const isTargetVersion = (meta) => {
+        isTargetVersion = (meta) => {
+            if (!meta.version) {
+                return true;
+            }
+            return range.test(meta.version);
+        };
+    }
+    else {
+        const parsed = npm_package_arg_1.default.resolve(name, verOrTag);
+        if (parsed.type === "tag") {
+            isTargetVersion = (meta) => {
+                var _a;
                 if (!meta.version) {
                     return true;
                 }
-                return range.test(meta.version);
-            };
-            const cachedFilePath = path_1.default.join(CACHED_META_ROOT, `${name}.json`);
-            const { cache, get } = getMetaFromNpmViewWithPackageArg((minVer) => `${name}@>=${minVer}`, cachedFilePath, min);
-            if (cache) {
-                const metaList = cache.data.meta.filter(isTargetVersion);
-                let alive = cache.alive;
-                if (!alive) {
-                    const maxNext = (0, semver_1.maxNextVersion)(range);
-                    if (maxNext) {
-                        alive = cache.data.meta.some((m) => m.version && maxNext.compare(m.version) <= 0);
-                    }
-                }
-                if (alive) {
-                    return {
-                        cache: metaList,
-                        get: () => metaList,
-                    };
+                const v = (_a = meta["dist-tags"]) === null || _a === void 0 ? void 0 : _a[parsed.fetchSpec];
+                if (v == null) {
+                    hasUnknown = true;
                 }
-                return {
-                    cache: metaList,
-                    get: () => { var _a, _b; return (_b = (_a = get()) === null || _a === void 0 ? void 0 : _a.filter(isTargetVersion)) !== null && _b !== void 0 ? _b : null; },
-                };
-            }
+                return v === meta.version;
+            };
+        }
+        else {
             return {
                 cache: [],
-                get: () => { var _a, _b; return (_b = (_a = get()) === null || _a === void 0 ? void 0 : _a.filter(isTargetVersion)) !== null && _b !== void 0 ? _b : null; },
+                get: () => null,
             };
         }
     }
-    const packageArg = `${name}@${verOrTag || "*"}`;
-    const cachedFilePath = path_1.default.join(CACHED_META_ROOT, `${packageArg
-        .replace(/[^\d+\-./<=>@\\^a-z|~]/giu, "_")
-        .toLowerCase()}.json`);
-    const { cache, get } = getMetaFromNpmViewWithPackageArg(() => packageArg, cachedFilePath);
     if (cache) {
-        if (cache.alive) {
+        let alive = cache.alive;
+        if (!alive && range) {
+            const maxNext = (0, semver_1.maxNextVersion)(range);
+            if (maxNext) {
+                alive = cache.data.meta.some((m) => m.version && maxNext.compare(m.version) <= 0);
+            }
+        }
+        const metaList = cache.data.meta.filter(isTargetVersion);
+        if (alive) {
             return {
-                cache: cache.data.meta,
-                get: () => cache.data.meta,
+                cache: metaList,
+                get: () => (hasUnknown ? null : metaList),
             };
         }
         return {
-            cache: cache.data.meta,
-            get,
+            cache: metaList,
+            get: () => {
+                var _a, _b;
+                const list = (_b = (_a = get()) === null || _a === void 0 ? void 0 : _a.filter(isTargetVersion)) !== null && _b !== void 0 ? _b : null;
+                return hasUnknown && !(list === null || list === void 0 ? void 0 : list.length) ? null : list;
+            },
         };
     }
     return {
         cache: [],
-        get,
+        get: () => {
+            var _a, _b;
+            const list = (_b = (_a = get()) === null || _a === void 0 ? void 0 : _a.filter(isTargetVersion)) !== null && _b !== void 0 ? _b : null;
+            return hasUnknown && !(list === null || list === void 0 ? void 0 : list.length) ? null : list;
+        },
     };
 }
-function getMetaFromNpmViewWithPackageArg(getPackageArg, cachedFilePath, min) {
-    let minVer = min === null || min === void 0 ? void 0 : min.version;
+function getMetaFromName(name, cachedFilePath) {
     const cache = getCache();
-    if (cache === null || cache === void 0 ? void 0 : cache.data.minVersion) {
-        minVer = cache.data.minVersion;
-    }
     return {
-        cache: getCache(),
-        get: () => getMetaFromNpmViewWithPackageArgWithoutCache(getPackageArg(minVer), cachedFilePath, minVer),
+        cache,
+        get: () => {
+            return getMetaFromNameWithoutCache(name, cachedFilePath);
+        },
     };
     function getCache() {
         makeDirs(path_1.default.dirname(cachedFilePath));
@@ -143,14 +168,6 @@ function getMetaFromNpmViewWithPackageArg(getPackageArg, cachedFilePath, min) {
         if (data.meta == null) {
             return null;
         }
-        if (min) {
-            if (!data.minVersion) {
-                return null;
-            }
-            if (min.compare(data.minVersion) < 0) {
-                return null;
-            }
-        }
         const alive = Boolean((typeof data.expired === "number" && data.expired >= Date.now()) ||
             (typeof data.timestamp === "number" &&
                 data.timestamp + TTL >= Date.now()) ||
@@ -161,19 +178,23 @@ function getMetaFromNpmViewWithPackageArg(getPackageArg, cachedFilePath, min) {
         };
     }
 }
-function getMetaFromNpmViewWithPackageArgWithoutCache(packageArg, cachedFilePath, minVer) {
+function getMetaFromNameWithoutCache(name, cachedFilePath) {
     let meta = [];
     try {
-        const json = exec("npm", [
-            "view",
-            `${packageArg}`,
-            ...NPM_INFO_PROPERTIES,
-            "--json",
-        ]);
-        meta = JSON.parse(json);
-        if (!Array.isArray(meta)) {
-            meta = [meta];
-        }
+        const allMeta = (0, package_json_1.syncPackageJson)(name, {
+            allVersions: true,
+        });
+        meta = Object.values(allMeta.versions).map((vm) => {
+            return {
+                version: vm.version,
+                engines: vm.engines,
+                dependencies: vm.dependencies,
+                peerDependencies: vm.peerDependencies,
+                optionalDependencies: vm.optionalDependencies,
+                "dist-tags": allMeta["dist-tags"],
+                deprecated: vm.deprecated,
+            };
+        });
     }
     catch (e) {
         return null;
@@ -183,7 +204,6 @@ function getMetaFromNpmViewWithPackageArgWithoutCache(packageArg, cachedFilePath
         meta,
         timestamp,
         expired: timestamp + Math.floor(Math.random() * 1000 * 60),
-        minVersion: minVer,
     };
     fs_1.default.writeFileSync(cachedFilePath, JSON.stringify(content));
     delete require.cache[cachedFilePath];
@@ -233,19 +253,6 @@ function makeDirs(dir) {
         fs_1.default.mkdirSync(d);
     }
 }
-function exec(command, args) {
-    const result = (0, child_process_1.spawnSync)(command, args, {
-        windowsHide: true,
-        maxBuffer: Infinity,
-    });
-    if (result.error) {
-        throw result.error;
-    }
-    if (result.status !== 0) {
-        throw new Error(`Failed:\n${result.stdout.toString()}\n${result.stderr.toString()}`);
-    }
-    return result.stdout.toString("utf8");
-}
 function getCwd(context) {
     if (context.getCwd) {
         return context.getCwd();

package/dist/utils/package-json/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncPackageJson = void 0;
+const synckit_1 = require("synckit");
+exports.syncPackageJson = (0, synckit_1.createSyncFn)(require.resolve("./worker"));

package/dist/utils/package-json/worker.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const synckit_1 = require("synckit");
+const tunnel_agent_1 = __importDefault(require("tunnel-agent"));
+const dynamicImport = new Function("m", "return import(m)");
+(0, synckit_1.runAsWorker)((packageName, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const m = yield dynamicImport("package-json");
+    const packageJson = (m === null || m === void 0 ? void 0 : m.default) || m;
+    return packageJson(packageName, withAutoProxy(options));
+}));
+function withAutoProxy(options) {
+    const PROXY_ENV = [
+        "https_proxy",
+        "HTTPS_PROXY",
+        "http_proxy",
+        "HTTP_PROXY",
+        "npm_config_https_proxy",
+        "npm_config_http_proxy",
+    ];
+    const proxyStr = PROXY_ENV.map((k) => process.env[k]).find((v) => v);
+    if (proxyStr) {
+        const proxyUrl = new URL(proxyStr);
+        const tunnelOption = {
+            proxy: {
+                host: proxyUrl.hostname,
+                port: Number(proxyUrl.port),
+                proxyAuth: proxyUrl.username || proxyUrl.password
+                    ? `${proxyUrl.username}:${proxyUrl.password}`
+                    : undefined,
+            },
+        };
+        const httpAgent = tunnel_agent_1.default[`httpOverHttp${proxyUrl.protocol === "https:" ? "s" : ""}`](tunnelOption);
+        const httpsAgent = tunnel_agent_1.default[`httpsOverHttp${proxyUrl.protocol === "https:" ? "s" : ""}`](tunnelOption);
+        return Object.assign({ agent: { http: httpAgent, https: httpsAgent } }, options);
+    }
+    return options;
+}

package/dist/utils/rules.js

@@ -7,12 +7,20 @@ exports.rules = void 0;
 const absolute_version_1 = __importDefault(require("../rules/absolute-version"));
 const compat_engines_1 = __importDefault(require("../rules/compat-engines"));
 const no_deprecated_1 = __importDefault(require("../rules/no-deprecated"));
+const no_dupe_deps_1 = __importDefault(require("../rules/no-dupe-deps"));
+const no_restricted_deps_1 = __importDefault(require("../rules/no-restricted-deps"));
+const prefer_caret_range_version_1 = __importDefault(require("../rules/prefer-caret-range-version"));
+const prefer_tilde_range_version_1 = __importDefault(require("../rules/prefer-tilde-range-version"));
 const valid_engines_1 = __importDefault(require("../rules/valid-engines"));
 const valid_semver_1 = __importDefault(require("../rules/valid-semver"));
 exports.rules = [
     absolute_version_1.default,
     compat_engines_1.default,
     no_deprecated_1.default,
+    no_dupe_deps_1.default,
+    no_restricted_deps_1.default,
+    prefer_caret_range_version_1.default,
+    prefer_tilde_range_version_1.default,
     valid_engines_1.default,
     valid_semver_1.default,
 ];

package/dist/utils/semver-range.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iterateSemverRanges = void 0;
+const semver_1 = require("./semver");
+function* iterateSemverRanges(versionRanges) {
+    let startOffset = 0;
+    for (const strRange of versionRanges.split("||")) {
+        const result = toRangeResult(strRange, startOffset);
+        if (result) {
+            yield result;
+        }
+        startOffset += strRange.length + 2;
+    }
+}
+exports.iterateSemverRanges = iterateSemverRanges;
+function toRangeResult(strRange, startOffset) {
+    let start = 0;
+    while (strRange.length > start && !strRange[start].trim()) {
+        start++;
+    }
+    let end = strRange.length;
+    while (end > start && !strRange[end - 1].trim()) {
+        end--;
+    }
+    const value = strRange.slice(start, end);
+    const range = (0, semver_1.getSemverRange)(value);
+    if (!range) {
+        return null;
+    }
+    if (range.set.length !== 1) {
+        return null;
+    }
+    return {
+        value,
+        comparators: range.set[0],
+        range: [startOffset + start, startOffset + end],
+    };
+}

package/package.json

@@ -1,101 +1,104 @@
 {
-    "name": "eslint-plugin-node-dependencies",
-    "version": "0.7.0",
-    "description": "ESLint plugin to check Node.js dependencies.",
-    "engines": {
-        "node": "^12 || >=14"
-    },
-    "main": "dist/index.js",
-    "files": [
-        "dist"
-    ],
-    "scripts": {
-        "prebuild": "npm run -s clean",
-        "build": "tsc --project ./tsconfig.build.json",
-        "clean": "rimraf .nyc_output dist coverage",
-        "lint": "eslint . --ext .js,.vue,.ts,.json,.yaml,.yml",
-        "eslint-fix": "eslint . --ext .js,.vue,.ts,.json,.yaml,.yml --fix",
-        "pretest": "npm run build",
-        "test:base": "mocha --require ts-node/register \"tests/**/*.ts\" --reporter dot --timeout 60000",
-        "test": "npm run test:nyc",
-        "test:nyc": "nyc --reporter=lcov npm run test:base",
-        "test:debug": "mocha --require ts-node/register/transpile-only \"tests/**/*.ts\" --reporter dot --timeout 60000",
-        "test:watch": "npm run test:base -- --watch",
-        "update": "ts-node --transpile-only ./tools/update.ts && npm run eslint-fix",
-        "new": "ts-node ./tools/new-rule.ts",
-        "docs:watch": "vuepress dev --debug docs",
-        "docs:build": "npm run build && vuepress build docs --no-cache",
-        "preversion": "npm test && git add .",
-        "version": "env-cmd -e version npm run update && git add ."
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/ota-meshi/eslint-plugin-node-dependencies.git"
-    },
-    "keywords": [
-        "eslint",
-        "eslintplugin",
-        "eslint-plugin",
-        "nodejs",
-        "dependencies",
-        "json"
-    ],
-    "author": "Yosuke Ota (https://github.com/ota-meshi)",
-    "funding": "https://github.com/sponsors/ota-meshi",
-    "license": "MIT",
-    "bugs": {
-        "url": "https://github.com/ota-meshi/eslint-plugin-node-dependencies/issues"
-    },
-    "homepage": "https://github.com/ota-meshi/eslint-plugin-node-dependencies#readme",
-    "peerDependencies": {
-        "eslint": ">=6.0.0"
-    },
-    "devDependencies": {
-        "@ota-meshi/eslint-plugin": "^0.10.0",
-        "@types/chai": "^4.2.18",
-        "@types/eslint": "^8.0.0",
-        "@types/eslint-scope": "^3.7.0",
-        "@types/eslint-visitor-keys": "^1.0.0",
-        "@types/estree": "^0.0.51",
-        "@types/mocha": "^9.0.0",
-        "@types/node": "^16.0.0",
-        "@types/npm-package-arg": "^6.1.1",
-        "@types/semver": "^7.3.8",
-        "@typescript-eslint/eslint-plugin": "^5.0.0",
-        "@typescript-eslint/parser": "^5.0.0",
-        "chai": "^4.3.4",
-        "env-cmd": "^10.1.0",
-        "eslint": "^8.0.0",
-        "eslint-config-prettier": "^8.0.0",
-        "eslint-plugin-eslint-comments": "^3.2.0",
-        "eslint-plugin-eslint-plugin": "^4.0.0",
-        "eslint-plugin-json-schema-validator": "^2.0.0",
-        "eslint-plugin-jsonc": "^2.0.0",
-        "eslint-plugin-node": "^11.1.0",
-        "eslint-plugin-node-dependencies": "^0.6.0",
-        "eslint-plugin-prettier": "^4.0.0",
-        "eslint-plugin-regexp": "^1.0.0",
-        "eslint-plugin-vue": "^8.0.0",
-        "eslint-plugin-yml": "^0.14.0",
-        "eslint4b": "^7.3.1",
-        "mocha": "^9.0.0",
-        "mocha-chai-jest-snapshot": "^1.1.2",
-        "nyc": "^15.1.0",
-        "prettier": "^2.0.5",
-        "raw-loader": "^4.0.1",
-        "stylelint": "^14.0.0",
-        "stylelint-config-recommended-vue": "^1.0.0",
-        "stylelint-config-standard": "^25.0.0",
-        "stylelint-plugin-stylus": "^0.13.0",
-        "ts-node": "^10.0.0",
-        "typescript": "^4.0.0",
-        "vue-eslint-editor": "^1.1.0",
-        "vue-eslint-parser": "^8.0.0",
-        "vuepress": "^1.5.2"
-    },
-    "dependencies": {
-        "jsonc-eslint-parser": "^1 || ^2.0.2",
-        "npm-package-arg": "^8.1.5",
-        "semver": "^7.3.5"
-    }
+  "name": "eslint-plugin-node-dependencies",
+  "version": "0.9.1",
+  "description": "ESLint plugin to check Node.js dependencies.",
+  "engines": {
+    "node": ">=14.17.0"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prebuild": "npm run -s clean",
+    "build": "tsc --project ./tsconfig.build.json",
+    "clean": "rimraf .nyc_output dist coverage",
+    "lint": "eslint . --ext .js,.vue,.ts,.json,.yaml,.yml",
+    "eslint-fix": "eslint . --ext .js,.vue,.ts,.json,.yaml,.yml --fix",
+    "pretest": "npm run build",
+    "test:base": "mocha --require ts-node/register \"tests/**/*.ts\" --reporter dot --timeout 60000",
+    "test": "npm run test:nyc",
+    "test:nyc": "nyc --reporter=lcov npm run test:base",
+    "test:debug": "mocha --require ts-node/register/transpile-only \"tests/**/*.ts\" --reporter dot --timeout 60000",
+    "test:watch": "npm run test:base -- --watch",
+    "update": "ts-node --transpile-only ./tools/update.ts && npm run eslint-fix",
+    "new": "ts-node ./tools/new-rule.ts",
+    "docs:watch": "export NODE_OPTIONS=--openssl-legacy-provider && vuepress dev --debug docs",
+    "docs:build": "export NODE_OPTIONS=--openssl-legacy-provider && npm run build && vuepress build docs --no-cache",
+    "preversion": "npm test && git add .",
+    "version": "env-cmd -e version npm run update && git add ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ota-meshi/eslint-plugin-node-dependencies.git"
+  },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "nodejs",
+    "dependencies",
+    "json"
+  ],
+  "author": "Yosuke Ota (https://github.com/ota-meshi)",
+  "funding": "https://github.com/sponsors/ota-meshi",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ota-meshi/eslint-plugin-node-dependencies/issues"
+  },
+  "homepage": "https://github.com/ota-meshi/eslint-plugin-node-dependencies#readme",
+  "peerDependencies": {
+    "eslint": ">=6.0.0"
+  },
+  "devDependencies": {
+    "@ota-meshi/eslint-plugin": "^0.11.0",
+    "@types/chai": "^4.2.18",
+    "@types/eslint": "^8.0.0",
+    "@types/eslint-scope": "^3.7.0",
+    "@types/eslint-visitor-keys": "^1.0.0",
+    "@types/estree": "^0.0.52",
+    "@types/mocha": "^9.0.0",
+    "@types/node": "^16.0.0",
+    "@types/npm-package-arg": "^6.1.1",
+    "@types/semver": "^7.3.8",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "chai": "^4.3.4",
+    "env-cmd": "^10.1.0",
+    "eslint": "^8.0.0",
+    "eslint-config-prettier": "^8.0.0",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-eslint-plugin": "^4.0.0",
+    "eslint-plugin-json-schema-validator": "^3.0.0",
+    "eslint-plugin-jsonc": "^2.0.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-node-dependencies": "^0.9.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-regexp": "^1.0.0",
+    "eslint-plugin-vue": "^9.0.0",
+    "eslint-plugin-yml": "^1.0.0",
+    "eslint4b": "^7.3.1",
+    "mocha": "^10.0.0",
+    "mocha-chai-jest-snapshot": "^1.1.2",
+    "nyc": "^15.1.0",
+    "prettier": "^2.0.5",
+    "raw-loader": "^4.0.1",
+    "stylelint": "^14.0.0",
+    "stylelint-config-recommended-vue": "^1.0.0",
+    "stylelint-config-standard": "^26.0.0",
+    "stylelint-stylus": "^0.16.0",
+    "ts-node": "^10.0.0",
+    "typescript": "^4.0.0",
+    "vue-eslint-editor": "^1.1.0",
+    "vue-eslint-parser": "^9.0.0",
+    "vuepress": "^1.5.2"
+  },
+  "dependencies": {
+    "jsonc-eslint-parser": "^2.0.2",
+    "npm-package-arg": "^9.0.0",
+    "package-json": "^8.1.0",
+    "semver": "^7.3.5",
+    "synckit": "^0.7.1",
+    "tunnel-agent": "^0.6.0"
+  }
 }