eslint-plugin-node-dependencies 1.3.0 → 2.0.0

package/dist/utils/meta.js

@@ -1,269 +0,0 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __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.getMetaFromNodeModules = getMetaFromNodeModules;
-exports.getMetaFromNpm = getMetaFromNpm;
-exports.getEngines = getEngines;
-exports.getDependencies = getDependencies;
-const module_1 = __importDefault(require("module"));
-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 eslint_compat_utils_1 = require("eslint-compat-utils");
-const TTL = 1000 * 60 * 60;
-const CACHE_VERSION = 2;
-const CACHED_META_ROOT = path_1.default.join(__dirname, `../../.cached_meta`);
-function getMetaFromNodeModules(name, ver, options) {
-    try {
-        const ownerJsonPath = options.ownerPackageJsonPath || (0, eslint_compat_utils_1.getFilename)(options.context);
-        const relativeTo = path_1.default.join(ownerJsonPath && path_1.default.isAbsolute(ownerJsonPath)
-            ? (0, path_1.dirname)(ownerJsonPath)
-            : (0, eslint_compat_utils_1.getCwd)(options.context), "__placeholder__.js");
-        const req = module_1.default.createRequire(relativeTo);
-        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;
-            }
-        }
-    }
-    catch (_a) {
-    }
-    return null;
-}
-function getMetaFromNpm(name, ver) {
-    var _a;
-    const trimmed = ver.trim();
-    if (trimmed.startsWith("npm:")) {
-        let parsed = null;
-        try {
-            parsed = (0, npm_package_arg_1.default)(`${trimmed.slice(4).trim()}`);
-        }
-        catch (_b) {
-        }
-        if (parsed &&
-            (parsed.type === "range" ||
-                parsed.type === "version" ||
-                parsed.type === "tag")) {
-            return getMetaFromNameAndSpec(parsed.name, (_a = parsed.fetchSpec) === null || _a === void 0 ? void 0 : _a.trim());
-        }
-    }
-    if (trimmed.includes("/") || trimmed.includes(":")) {
-        return { cache: [], get: () => [] };
-    }
-    return getMetaFromNameAndSpec(name, ver.trim());
-}
-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) {
-        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;
-                }
-                const v = (_a = meta["dist-tags"]) === null || _a === void 0 ? void 0 : _a[parsed.fetchSpec];
-                if (v == null) {
-                    hasUnknown = true;
-                }
-                return v === meta.version;
-            };
-        }
-        else {
-            return {
-                cache: [],
-                get: () => null,
-            };
-        }
-    }
-    if (cache) {
-        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: metaList,
-                get: () => (hasUnknown ? null : metaList),
-            };
-        }
-        return {
-            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: () => {
-            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 getMetaFromName(name, cachedFilePath) {
-    const cache = getCache();
-    return {
-        cache,
-        get: () => {
-            return getMetaFromNameWithoutCache(name, cachedFilePath);
-        },
-    };
-    function getCache() {
-        makeDirs(path_1.default.dirname(cachedFilePath));
-        if (!fs_1.default.existsSync(cachedFilePath)) {
-            return null;
-        }
-        const data = require(cachedFilePath);
-        if (!data || data.meta == null) {
-            return null;
-        }
-        if (data.v !== CACHE_VERSION) {
-            return null;
-        }
-        const alive = Boolean((typeof data.expired === "number" && data.expired >= Date.now()) ||
-            (typeof data.timestamp === "number" &&
-                data.timestamp + TTL >= Date.now()) ||
-            (data.meta.length === 1 && data.meta[0].deprecated));
-        return {
-            data,
-            alive,
-        };
-    }
-}
-function getMetaFromNameWithoutCache(name, cachedFilePath) {
-    let meta = [];
-    try {
-        const allMeta = (0, package_json_1.syncPackageJson)(name);
-        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,
-                dist: vm.dist,
-            };
-        });
-    }
-    catch (_a) {
-        return null;
-    }
-    const timestamp = Date.now();
-    const content = {
-        v: CACHE_VERSION,
-        meta,
-        timestamp,
-        expired: timestamp + Math.floor(Math.random() * 1000 * 60),
-    };
-    fs_1.default.writeFileSync(cachedFilePath, JSON.stringify(content));
-    delete require.cache[cachedFilePath];
-    return meta;
-}
-function getEngines(meta) {
-    if (!maybeMeta(meta)) {
-        return new Map();
-    }
-    return getStrMap(meta.engines);
-}
-function getDependencies(meta, kind) {
-    if (!maybeMeta(meta)) {
-        return new Map();
-    }
-    return getStrMap(meta[kind]);
-}
-function getStrMap(maybeObject) {
-    const map = new Map();
-    if (typeof maybeObject !== "object" ||
-        !maybeObject ||
-        Array.isArray(maybeObject)) {
-        return map;
-    }
-    for (const [key, val] of Object.entries(maybeObject)) {
-        if (val != null) {
-            map.set(key, `${val}`);
-        }
-    }
-    return map;
-}
-function maybeMeta(json) {
-    if (typeof json !== "object" || !json || Array.isArray(json)) {
-        return false;
-    }
-    return true;
-}
-function makeDirs(dir) {
-    const dirs = [dir];
-    while (!fs_1.default.existsSync(dirs[0])) {
-        dirs.unshift(path_1.default.dirname(dirs[0]));
-    }
-    dirs.shift();
-    for (const d of dirs) {
-        fs_1.default.mkdirSync(d);
-    }
-}

package/dist/utils/package-json/index.d.ts

@@ -1 +0,0 @@
-export declare const syncPackageJson: (name: string) => import("package-json").AbbreviatedMetadata;

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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncPackageJson = void 0;
-const synckit_1 = require("synckit");
-const module_1 = require("module");
-exports.syncPackageJson = (0, synckit_1.createSyncFn)(getWorkerPath(), {
-    timeout: 10000,
-});
-function getWorkerPath() {
-    try {
-        return require.resolve("./worker.mjs");
-    }
-    catch (_a) {
-    }
-    const r = (0, module_1.createRequire)(__filename);
-    return r.resolve("./worker.mts");
-}

package/dist/utils/package-json/worker.d.mts

@@ -1 +0,0 @@
-export declare function setupProxy(): void;

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

@@ -1,26 +0,0 @@
-import packageJson from "package-json";
-import { runAsWorker } from "synckit";
-import { ProxyAgent, setGlobalDispatcher } from "undici";
-let proxySet = false;
-const PROXY_ENV = [
-    "https_proxy",
-    "HTTPS_PROXY",
-    "http_proxy",
-    "HTTP_PROXY",
-    "npm_config_https_proxy",
-    "npm_config_http_proxy",
-];
-export function setupProxy() {
-    if (proxySet) {
-        return;
-    }
-    proxySet = true;
-    const proxy = PROXY_ENV.map((k) => process.env[k]).find((v) => v);
-    if (proxy) {
-        setGlobalDispatcher(new ProxyAgent(proxy));
-    }
-}
-runAsWorker((packageName) => {
-    setupProxy();
-    return packageJson(packageName, { allVersions: true });
-});

package/dist/utils/regexp.d.ts

@@ -1,3 +0,0 @@
-export declare function toRegExp(str: string): {
-    test(s: string): boolean;
-};

package/dist/utils/regexp.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toRegExp = toRegExp;
-function toRegExp(str) {
-    const regexp = parseRegExp(str);
-    if (regexp) {
-        return regexp;
-    }
-    return { test: (s) => s === str };
-}
-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.d.ts

@@ -1,2 +0,0 @@
-import type { RuleModule } from "../types";
-export declare const rules: RuleModule[];

package/dist/utils/rules.js

@@ -1,28 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": 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 require_provenance_deps_1 = __importDefault(require("../rules/require-provenance-deps"));
-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,
-    require_provenance_deps_1.default,
-    valid_engines_1.default,
-    valid_semver_1.default,
-];

package/dist/utils/semver-range.d.ts

@@ -1,7 +0,0 @@
-import type { Comparator } from "semver";
-export type RangeResult = {
-    value: string;
-    comparators: readonly Comparator[];
-    range: readonly [number, number];
-};
-export declare function iterateSemverRanges(versionRanges: string): Iterable<RangeResult>;

package/dist/utils/semver-range.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.iterateSemverRanges = iterateSemverRanges;
-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;
-    }
-}
-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.d.ts

@@ -1,7 +0,0 @@
-import type { Comparator } from "semver";
-import { Range, SemVer } from "semver";
-export declare function getSemverRange(value: string | undefined | null): Range | null;
-export declare function normalizeVer(ver: Range): string;
-export declare function normalizeSemverRange(...values: Range[]): Range | null;
-export declare function maxNextVersion(range: Range): SemVer | null;
-export declare function isAnyComparator(comparator: Comparator): boolean;

package/dist/utils/semver.js

@@ -1,204 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSemverRange = getSemverRange;
-exports.normalizeVer = normalizeVer;
-exports.normalizeSemverRange = normalizeSemverRange;
-exports.maxNextVersion = maxNextVersion;
-exports.isAnyComparator = isAnyComparator;
-const semver_1 = require("semver");
-function getSemverRange(value) {
-    if (value == null) {
-        return null;
-    }
-    try {
-        return new semver_1.Range(value);
-    }
-    catch (_a) {
-        return null;
-    }
-}
-function normalizeVer(ver) {
-    const n = normalizeSemverRange(ver);
-    if (n) {
-        return n.raw;
-    }
-    return ver.raw;
-}
-function normalizeSemverRange(...values) {
-    const map = new Map();
-    for (const ver of values) {
-        for (const comparators of ver.set) {
-            const normalized = normalizeComparators(comparators);
-            if (map.has(normalized)) {
-                continue;
-            }
-            const normalizedVer = getSemverRange(normalized);
-            if (!normalizedVer) {
-                continue;
-            }
-            let consume = false;
-            let target = { range: normalizedVer, comparators };
-            for (const [k, data] of map) {
-                if ((0, semver_1.subset)(target.range, data.range)) {
-                    consume = true;
-                    break;
-                }
-                if ((0, semver_1.subset)(data.range, target.range)) {
-                    map.delete(k);
-                }
-                if ((0, semver_1.intersects)(target.range, data.range)) {
-                    const newComparators = joinComparators(comparators, data.comparators);
-                    if (newComparators) {
-                        target = {
-                            range: new semver_1.Range(normalizeComparators(newComparators)),
-                            comparators: newComparators,
-                        };
-                        map.delete(k);
-                    }
-                }
-            }
-            if (consume) {
-                continue;
-            }
-            map.set(target.range.raw, target);
-        }
-    }
-    const ranges = [...map]
-        .sort(([, a], [, b]) => {
-        const aVer = getMinVer(a.comparators);
-        const bVer = getMinVer(b.comparators);
-        return aVer.compare(bVer);
-    })
-        .map(([v]) => v);
-    return getSemverRange(ranges.join("||"));
-    function getMinVer(comparators) {
-        let min = null;
-        for (const comp of comparators) {
-            if (!min || comp.semver.compare(min) < 0) {
-                min = comp.semver;
-            }
-        }
-        return min;
-    }
-}
-function normalizeComparators(comparators) {
-    const rangeComparator = toRangeComparator(comparators);
-    if (rangeComparator && rangeComparator.min && rangeComparator.max) {
-        if (rangeComparator.min.operator === ">=" &&
-            rangeComparator.max.operator === "<") {
-            if (rangeComparator.min.semver.major !== 0 &&
-                (0, semver_1.inc)(rangeComparator.min.semver.version, "premajor") ===
-                    rangeComparator.max.semver.version)
-                return `^${rangeComparator.min.semver.version}`;
-            if ((0, semver_1.inc)(rangeComparator.min.semver.version, "preminor") ===
-                rangeComparator.max.semver.version)
-                return `~${rangeComparator.min.semver.version}`;
-        }
-    }
-    return comparators.map(normalizeComparator).join(" ");
-}
-function normalizeComparator(comparator) {
-    if (comparator.operator === "") {
-        return comparator.value || "*";
-    }
-    return comparator.value;
-}
-function joinComparators(a, b) {
-    const aRangeComparator = toRangeComparator(a);
-    const bRangeComparator = toRangeComparator(b);
-    if (aRangeComparator && bRangeComparator) {
-        const comparators = [];
-        if (aRangeComparator.min && bRangeComparator.min) {
-            comparators.push(aRangeComparator.min.semver.compare(bRangeComparator.min.semver) <= 0
-                ? aRangeComparator.min
-                : bRangeComparator.min);
-        }
-        if (aRangeComparator.max && bRangeComparator.max) {
-            comparators.push(aRangeComparator.max.semver.compare(bRangeComparator.max.semver) >= 0
-                ? aRangeComparator.max
-                : bRangeComparator.max);
-        }
-        if (comparators.length === 0) {
-            return new semver_1.Range("*").set[0];
-        }
-        return comparators;
-    }
-    return null;
-}
-function toRangeComparator(comparators) {
-    if (comparators.length === 2) {
-        if (comparators[0].operator === ">" || comparators[0].operator === ">=") {
-            if (comparators[1].operator === "<" || comparators[1].operator === "<=") {
-                return {
-                    min: comparators[0],
-                    max: comparators[1],
-                };
-            }
-        }
-        else if (comparators[0].operator === "<" ||
-            comparators[0].operator === "<=") {
-            if (comparators[1].operator === ">" || comparators[1].operator === ">=") {
-                return {
-                    min: comparators[1],
-                    max: comparators[0],
-                };
-            }
-        }
-    }
-    if (comparators.length === 1) {
-        if (comparators[0].operator === ">" || comparators[0].operator === ">=") {
-            return {
-                min: comparators[0],
-                max: null,
-            };
-        }
-        else if (comparators[0].operator === "<" ||
-            comparators[0].operator === "<=") {
-            return {
-                min: null,
-                max: comparators[0],
-            };
-        }
-    }
-    return null;
-}
-function maxNextVersion(range) {
-    let maxVer = null;
-    for (const comparators of range.set) {
-        let max = null;
-        let hasMin = false;
-        for (const comparator of comparators) {
-            if (isAnyComparator(comparator)) {
-                return null;
-            }
-            const compVer = new semver_1.SemVer(comparator.semver.version);
-            if (comparator.operator === "<=" ||
-                comparator.operator === "<" ||
-                comparator.operator === "") {
-                if (comparator.operator === "<=") {
-                    compVer.inc("prerelease");
-                }
-                if (!max || (0, semver_1.lt)(max, compVer)) {
-                    max = compVer;
-                }
-            }
-            else if (comparator.operator === ">=" || comparator.operator === ">") {
-                hasMin = true;
-            }
-        }
-        if (max) {
-            if (!maxVer || (0, semver_1.lt)(maxVer, max)) {
-                maxVer = max;
-            }
-        }
-        else {
-            if (hasMin) {
-                return null;
-            }
-        }
-    }
-    return maxVer;
-}
-function isAnyComparator(comparator) {
-    return !comparator.semver.version;
-}