eslint-plugin-node-dependencies 0.5.1 → 0.8.0

package/README.md

@@ -119,13 +119,23 @@ 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. |  |
 | [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
 
 | Rule ID | Description |    |
 |:--------|:------------|:---|
+| [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/rules/absolute-version.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsonc_eslint_parser_1 = require("jsonc-eslint-parser");
+const utils_1 = require("../utils");
+const ast_utils_1 = require("../utils/ast-utils");
+const regexp_1 = require("../utils/regexp");
+const semver_1 = require("../utils/semver");
+const PREFERS = ["always", "never", "ignore"];
+const SCHEMA_FOR_DEPS_PROPERTIES = {
+    dependencies: { enum: PREFERS },
+    peerDependencies: { enum: PREFERS },
+    optionalDependencies: { enum: PREFERS },
+    devDependencies: { enum: PREFERS },
+};
+const DEFAULT = {
+    dependencies: "ignore",
+    peerDependencies: "ignore",
+    optionalDependencies: "ignore",
+    devDependencies: "always",
+};
+function stringToOption(option) {
+    return {
+        dependencies: option,
+        peerDependencies: option,
+        optionalDependencies: option,
+        devDependencies: option,
+    };
+}
+function objectToOption(option, defaults) {
+    return {
+        dependencies: option.dependencies || defaults.dependencies,
+        peerDependencies: option.peerDependencies || defaults.peerDependencies,
+        optionalDependencies: option.optionalDependencies || defaults.optionalDependencies,
+        devDependencies: option.devDependencies || defaults.devDependencies,
+    };
+}
+function parseOption(option) {
+    if (!option) {
+        return () => DEFAULT;
+    }
+    if (typeof option === "string") {
+        const objectOption = stringToOption(option);
+        return () => objectOption;
+    }
+    const baseOption = objectToOption(option, DEFAULT);
+    if (!option.overridePackages) {
+        return () => baseOption;
+    }
+    const overridePackages = Object.entries(option.overridePackages).map(([packageName, opt]) => {
+        const regexp = (0, regexp_1.toRegExp)(packageName);
+        return Object.assign({ test: (s) => regexp.test(s) }, (typeof opt === "string"
+            ? stringToOption(opt)
+            : objectToOption(opt, baseOption)));
+    });
+    return (name) => {
+        for (const overridePackage of overridePackages) {
+            if (overridePackage.test(name)) {
+                return overridePackage;
+            }
+        }
+        return baseOption;
+    };
+}
+exports.default = (0, utils_1.createRule)("absolute-version", {
+    meta: {
+        docs: {
+            description: "require or disallow absolute version of dependency.",
+            category: "Best Practices",
+            recommended: false,
+        },
+        schema: [
+            {
+                oneOf: [
+                    { enum: PREFERS.filter((p) => p !== "ignore") },
+                    {
+                        type: "object",
+                        properties: Object.assign(Object.assign({}, SCHEMA_FOR_DEPS_PROPERTIES), { overridePackages: {
+                                type: "object",
+                                patternProperties: {
+                                    "^(?:\\S+)$": {
+                                        oneOf: [
+                                            { enum: PREFERS },
+                                            {
+                                                type: "object",
+                                                properties: SCHEMA_FOR_DEPS_PROPERTIES,
+                                                additionalProperties: false,
+                                            },
+                                        ],
+                                    },
+                                },
+                                minProperties: 1,
+                                additionalProperties: false,
+                            } }),
+                        additionalProperties: false,
+                    },
+                ],
+            },
+        ],
+        messages: {},
+        type: "suggestion",
+    },
+    create(context) {
+        if (!context.parserServices.isJSON) {
+            return {};
+        }
+        const getOption = parseOption(context.options[0]);
+        function defineVisitor(visitName) {
+            return (node) => {
+                const ver = (0, jsonc_eslint_parser_1.getStaticJSONValue)(node.value);
+                if (typeof ver !== "string" || ver == null) {
+                    return;
+                }
+                const name = String((0, ast_utils_1.getKeyFromJSONProperty)(node));
+                const option = getOption(name)[visitName];
+                const semver = (0, semver_1.getSemverRange)(ver);
+                if (semver == null) {
+                    return;
+                }
+                if (option === "always") {
+                    if (isAbsoluteVersion(semver)) {
+                        return;
+                    }
+                    context.report({
+                        loc: node.value.loc,
+                        message: "Use the absolute version instead.",
+                    });
+                }
+                else if (option === "never") {
+                    if (!isAbsoluteVersion(semver)) {
+                        return;
+                    }
+                    context.report({
+                        loc: node.value.loc,
+                        message: "Do not use the absolute version.",
+                    });
+                }
+            };
+        }
+        return (0, utils_1.defineJsonVisitor)({
+            dependencies: defineVisitor("dependencies"),
+            peerDependencies: defineVisitor("peerDependencies"),
+            optionalDependencies: defineVisitor("optionalDependencies"),
+            devDependencies: defineVisitor("devDependencies"),
+        });
+    },
+});
+function isAbsoluteVersion(semver) {
+    for (const comparators of semver.set) {
+        for (const comparator of comparators) {
+            if ((0, semver_1.isAnyComparator)(comparator)) {
+                return false;
+            }
+            if (comparator.operator !== "=" && comparator.operator !== "") {
+                return false;
+            }
+        }
+    }
+    return true;
+}

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: false,
+        },
+        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,246 @@
+"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) {
+        const version = (0, semver_2.getSemverRange)(ver);
+        if (version) {
+            const range = this.map[name];
+            if (range) {
+                const newRange = (0, semver_2.normalizeSemverRange)(range, version);
+                this.map[name] = newRange;
+            }
+            else {
+                this.map[name] = version;
+            }
+            return;
+        }
+        this.list.push([name, ver]);
+    }
+    pop() {
+        const resultForList = this.list.shift();
+        if (resultForList) {
+            return resultForList;
+        }
+        const [key] = Object.keys(this.map);
+        if (key) {
+            const range = this.map[key];
+            delete this.map[key];
+            return [key, (0, semver_2.normalizeVer)(range)];
+        }
+        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[0]}@${dep[1]}`;
+            if (this.deepValidatedCache.has(key)) {
+                const result = this.deepValidatedCache.get(key);
+                if (result) {
+                    return result;
+                }
+            }
+            else {
+                const result = validateWithoutCache(dep[0], dep[1]);
+                this.deepValidatedCache.set(key, result);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        return null;
+        function validateWithoutCache(name, ver) {
+            const result = validate(name, ver);
+            if (result) {
+                return result;
+            }
+            for (const [n, v] of iterateDeps(name, ver)) {
+                const r = validate(n, v);
+                if (r) {
+                    return r;
+                }
+                depsQueue.push(n, v);
+            }
+            return null;
+        }
+        function* iterateDeps(name, ver) {
+            yield* iterateDepsForMeta((0, meta_1.getMetaFromNodeModules)(name, ver, context));
+            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 [n, v];
+                    }
+                }
+            }
+        }
+    }
+}
+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/ast-utils.js

@@ -10,7 +10,8 @@ function getKeyFromJSONProperty(node) {
 exports.getKeyFromJSONProperty = getKeyFromJSONProperty;
 function getKey(node) {
     let parent = node.parent;
-    while (parent.type === "JSONUnaryExpression") {
+    while (parent.type === "JSONUnaryExpression" ||
+        parent.type === "JSONBinaryExpression") {
         parent = parent.parent;
     }
     if (parent.type === "JSONExpressionStatement") {

package/dist/utils/meta.js

@@ -18,6 +18,7 @@ const NPM_INFO_PROPERTIES = [
     "deprecated",
     "dependencies",
     "peerDependencies",
+    "optionalDependencies",
     "dist-tags",
 ];
 const CACHED_META_ROOT = path_1.default.join(__dirname, `../../.cached_meta`);

package/dist/utils/regexp.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRegExp = void 0;
+function toRegExp(str) {
+    const regexp = parseRegExp(str);
+    if (regexp) {
+        return regexp;
+    }
+    return { test: (s) => s === str };
+}
+exports.toRegExp = toRegExp;
+function parseRegExp(str) {
+    if (!str.startsWith("/")) {
+        return null;
+    }
+    const lastSlashIndex = str.lastIndexOf("/");
+    if (lastSlashIndex <= 1) {
+        return null;
+    }
+    return new RegExp(str.slice(1, lastSlashIndex), str.slice(lastSlashIndex + 1));
+}

package/dist/utils/rules.js

@@ -4,13 +4,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 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/dist/utils/semver.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maxNextVersion = exports.normalizeSemverRange = exports.normalizeVer = exports.getSemverRange = void 0;
+exports.isAnyComparator = exports.maxNextVersion = exports.normalizeSemverRange = exports.normalizeVer = exports.getSemverRange = void 0;
 const semver_1 = require("semver");
 function getSemverRange(value) {
     if (value == null) {
@@ -171,7 +171,7 @@ function maxNextVersion(range) {
         let max = null;
         let hasMin = false;
         for (const comparator of comparators) {
-            if (!comparator.semver.version) {
+            if (isAnyComparator(comparator)) {
                 return null;
             }
             const compVer = new semver_1.SemVer(comparator.semver.version);
@@ -204,3 +204,7 @@ function maxNextVersion(range) {
     return maxVer;
 }
 exports.maxNextVersion = maxNextVersion;
+function isAnyComparator(comparator) {
+    return !comparator.semver.version;
+}
+exports.isAnyComparator = isAnyComparator;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-node-dependencies",
-    "version": "0.5.1",
+    "version": "0.8.0",
     "description": "ESLint plugin to check Node.js dependencies.",
     "engines": {
         "node": "^12 || >=14"
@@ -41,6 +41,7 @@
         "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"
@@ -52,12 +53,12 @@
     "devDependencies": {
         "@ota-meshi/eslint-plugin": "^0.10.0",
         "@types/chai": "^4.2.18",
-        "@types/eslint": "^7.2.0",
+        "@types/eslint": "^8.0.0",
         "@types/eslint-scope": "^3.7.0",
         "@types/eslint-visitor-keys": "^1.0.0",
-        "@types/estree": "^0.0.50",
+        "@types/estree": "^0.0.51",
         "@types/mocha": "^9.0.0",
-        "@types/node": "^14.14.39",
+        "@types/node": "^16.0.0",
         "@types/npm-package-arg": "^6.1.1",
         "@types/semver": "^7.3.8",
         "@typescript-eslint/eslint-plugin": "^5.0.0",
@@ -68,14 +69,14 @@
         "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": "^1.0.9",
-        "eslint-plugin-jsonc": "^1.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.5.0",
+        "eslint-plugin-node-dependencies": "^0.7.0",
         "eslint-plugin-prettier": "^4.0.0",
         "eslint-plugin-regexp": "^1.0.0",
-        "eslint-plugin-vue": "^7.5.0",
-        "eslint-plugin-yml": "^0.10.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",
@@ -83,8 +84,9 @@
         "prettier": "^2.0.5",
         "raw-loader": "^4.0.1",
         "stylelint": "^14.0.0",
-        "stylelint-config-standard": "^23.0.0",
-        "stylelint-plugin-stylus": "^0.11.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",
@@ -92,7 +94,7 @@
         "vuepress": "^1.5.2"
     },
     "dependencies": {
-        "jsonc-eslint-parser": "^1.1.0",
+        "jsonc-eslint-parser": "^1 || ^2.0.2",
         "npm-package-arg": "^8.1.5",
         "semver": "^7.3.5"
     }