eslint-plugin-package-json 1.6.2 → 1.7.0

package/dist/experimental/index.mjs

@@ -1,4 +1,4 @@
-import { t as plugin$1 } from "../plugin-C-Z8sf5g.mjs";
+import { t as plugin$1 } from "../plugin-Dzfp9IK7.mjs";
 import { toCompatRule } from "eslint-json-compat-utils";
 //#region src/experimental/plugin.ts
 const language = "json/json";

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { t as plugin } from "./plugin-C-Z8sf5g.mjs";
+import { t as plugin } from "./plugin-Dzfp9IK7.mjs";
 //#region src/index.ts
 const rules = plugin.rules;
 const configs = plugin.configs;

package/dist/{plugin-C-Z8sf5g.mjs → plugin-Dzfp9IK7.mjs}

@@ -9,7 +9,9 @@ import sortPackageJson, { sortOrder } from "sort-package-json";
 import { execFileSync } from "node:child_process";
 import semver from "semver";
 import { validateAuthor, validateBin, validateBrowser, validateBugs, validateBundleDependencies, validateConfig, validateContributors, validateCpu, validateDependencies, validateDescription, validateDevEngines, validateDirectories, validateEngines, validateExports, validateFiles, validateFunding, validateGypfile, validateHomepage, validateKeywords, validateLibc, validateLicense, validateMain, validateMan, validateName, validateOs, validatePackageManager, validatePeerDependenciesMeta, validatePrivate, validatePublishConfig, validateRepository, validateScripts, validateSideEffects, validateType, validateVersion, validateWorkspaces } from "package-json-validator";
+import fs from "node:fs";
 import path from "node:path";
+import process from "node:process";
 import { sep } from "node:path/posix";
 import { findRootSync } from "@altano/repository-tools";
 //#region src/utils/predicates/isJSONStringLiteral.ts
@@ -242,12 +244,21 @@ const rule$16 = createRule({
 //#endregion
 //#region src/rules/no-local-dependencies.ts
 const isLocalDependency = (value) => value.startsWith("file:") || value.startsWith("link:") || value.startsWith("./") || value.startsWith("../") || value.startsWith(".\\") || value.startsWith("..\\");
+const getBundledDependencyNames = (value) => {
+	const names = /* @__PURE__ */ new Set();
+	if (value?.type === "JSONArrayExpression") for (const element of value.elements.filter(isNotNullish).filter(isJSONStringLiteral)) names.add(element.value);
+	return names;
+};
 const rule$15 = createRule({
 	create(context) {
 		const ignorePrivate = context.options[0]?.ignorePrivate ?? true;
 		let isPrivate = false;
 		let dependencyNodes = [];
+		const bundleDependencyValues = /* @__PURE__ */ new Map();
 		return {
+			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.type=JSONLiteral]:matches([key.value=bundleDependencies], [key.value=bundledDependencies])"(node) {
+				bundleDependencyValues.set(node.key.value, node.value);
+			},
 			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.type=JSONLiteral][value.type=JSONLiteral][key.value=private]"(node) {
 				if (node.value.value === true) isPrivate = true;
 			},
@@ -256,7 +267,13 @@ const rule$15 = createRule({
 			},
 			"Program:exit"() {
 				if (ignorePrivate && isPrivate) return;
+				let bundleDependenciesValue = bundleDependencyValues.get("bundleDependencies");
+				if (!(bundleDependenciesValue && (bundleDependenciesValue.type !== "JSONLiteral" || Boolean(bundleDependenciesValue.value)))) bundleDependenciesValue = bundleDependencyValues.get("bundledDependencies");
+				if (bundleDependenciesValue?.type === "JSONLiteral" && bundleDependenciesValue.value === true) return;
+				const bundledDependencyNames = getBundledDependencyNames(bundleDependenciesValue);
 				for (const dependencyPropertyNode of dependencyNodes) {
+					const dependencyKey = dependencyPropertyNode.key;
+					if (isJSONStringLiteral(dependencyKey) && bundledDependencyNames.has(dependencyKey.value)) continue;
 					const dependencyValue = dependencyPropertyNode.value;
 					if (isJSONStringLiteral(dependencyValue) && isLocalDependency(dependencyValue.value)) context.report({
 						data: { name: dependencyValue.value },
@@ -845,10 +862,40 @@ const DEPENDENCY_TYPES = [
 	"peerDependencies"
 ];
 const RANGE_TYPES = [
-	"caret",
-	"pin",
-	"tilde"
+	{
+		symbol: "^",
+		alias: "caret",
+		workspaceSymbol: "^"
+	},
+	{
+		alias: "pin",
+		workspaceSymbol: "*"
+	},
+	{
+		symbol: "~",
+		alias: "tilde",
+		workspaceSymbol: "~"
+	},
+	{
+		symbol: "<",
+		alias: "lt"
+	},
+	{
+		symbol: "<=",
+		alias: "le"
+	},
+	{
+		symbol: ">",
+		alias: "gt"
+	},
+	{
+		symbol: ">=",
+		alias: "ge"
+	}
 ];
+const SYMBOLS = RANGE_TYPES.filter((rangeType) => "symbol" in rangeType).map((rangeType) => rangeType.symbol);
+const RANGE_NAMES = RANGE_TYPES.map((rangeType) => rangeType.alias);
+const SYMBOLS_AND_RANGE_NAMES = [...SYMBOLS, ...RANGE_NAMES];
 const schemaOptions = {
 	additionalProperties: false,
 	properties: {
@@ -868,8 +915,8 @@ const schemaOptions = {
 		},
 		rangeType: {
 			description: "Identifies which range type or types you want to apply to packages that match any of the other match options (or all dependencies if no other options are provided).",
-			oneOf: [{ enum: RANGE_TYPES }, {
-				items: { enum: RANGE_TYPES },
+			oneOf: [{ enum: SYMBOLS_AND_RANGE_NAMES }, {
+				items: { enum: SYMBOLS_AND_RANGE_NAMES },
 				type: "array"
 			}]
 		}
@@ -877,33 +924,37 @@ const schemaOptions = {
 	required: ["rangeType"],
 	type: "object"
 };
-const SYMBOLS = {
-	caret: "^",
-	pin: "",
-	tilde: "~"
+const normalizeRangeType = (rangeTypeOrSymbol) => RANGE_TYPES.find((rangeType) => "symbol" in rangeType && rangeType.symbol === rangeTypeOrSymbol || rangeType.alias === rangeTypeOrSymbol);
+/** @returns `undefined` if workspace versions are not supported for the specified {@link rangeType} */
+const getWorkspaceVersionForRange = (rangeType) => {
+	if ("workspaceSymbol" in rangeType) return `workspace:${rangeType.workspaceSymbol}`;
 };
+/** For displaying a range type in a user-facing way (ie. an error message). */
+const displayRangeType = (rangeType) => "symbol" in rangeType ? rangeType.symbol : rangeType.alias;
+const ROLLING_WORKSPACE_REGEX = /^workspace:[~^*]$/;
+const isRollingWorkspaceSpec = (version) => ROLLING_WORKSPACE_REGEX.test(version);
+const CHANGE_VERSION_RANGE_REGEX = /^(workspace:)?(\^|~|<=?|>=?)?/;
 /**
 * Given the original version, update it to use the correct range type.
 */
 const changeVersionRange = (version, rangeType) => {
-	if (/^workspace:[~^*]$/.test(version)) switch (rangeType) {
-		case "caret": return "workspace:^";
-		case "pin": return "workspace:*";
-		default: return "workspace:~";
+	if (isRollingWorkspaceSpec(version)) {
+		const result = getWorkspaceVersionForRange(rangeType);
+		if (result !== void 0) return result;
 	}
-	return version.replace(/^(workspace:)?(\^|~|<=?|>=?)?/, `$1${SYMBOLS[rangeType]}`);
+	const replaceWith = "symbol" in rangeType ? rangeType.symbol : "";
+	return version.replace(CHANGE_VERSION_RANGE_REGEX, `$1${replaceWith}`);
 };
+const IS_VERSION_SUPPORTED_REGEX = /^workspace:/;
 /**
 * Check if the version is in a form that this rule supports.
 */
 const isVersionSupported = (version) => {
-	if (/^workspace:[*^~]$/.test(version)) return true;
-	const rawVersion = version.replace(/^workspace:/, "");
+	if (isRollingWorkspaceSpec(version)) return true;
+	const rawVersion = version.replace(IS_VERSION_SUPPORTED_REGEX, "");
 	return !!semver.validRange(rawVersion);
 };
-const capitalize = (str) => {
-	return str.charAt(0).toUpperCase() + str.slice(1);
-};
+const POSSIBLE_WORKSPACE_SPEC_REGEX = /(?:workspace:)?[^~]?/;
 const rule$9 = createRule({
 	create(context) {
 		if (!context.options[0]) return {};
@@ -920,39 +971,41 @@ const rule$9 = createRule({
 				const name = property.key.value;
 				const version = property.value.value;
 				if (!isVersionSupported(version)) continue;
-				const isPinned = !!semver.parse(version) || version === "workspace:*";
-				const isTildeRange = !!semver.validRange(version) && version.startsWith("~") || version.startsWith("workspace:~");
-				const isCaretRange = !!semver.validRange(version) && version.startsWith("^") || version.startsWith("workspace:^");
+				const doesRangeTypeMatch = (rangeType) => {
+					if ("symbol" in rangeType && semver.validRange(version)) return version.startsWith(rangeType.symbol);
+					if (rangeType.alias === "pin" && (!!semver.parse(version) || version === "workspace:*" || version === "workspace:")) return true;
+					if (version.startsWith("workspace:")) {
+						const workspaceVersion = getWorkspaceVersionForRange(rangeType);
+						return workspaceVersion === void 0 || version.startsWith(workspaceVersion);
+					}
+					return false;
+				};
 				for (const options of optionsArray) {
 					if (options.forDependencyTypes && !options.forDependencyTypes.includes(dependencyType)) continue;
 					if (options.forPackages) {
 						if (!options.forPackages.some((packageNameRegex) => packageNameRegex.test(name))) continue;
 					}
-					if (options.forVersions && (/^workspace:[^~*]?$/.test(version) || version !== "*" && !semver.satisfies(version.replace(/(?:workspace:)?[^~]?/, ""), options.forVersions))) continue;
-					const rangeTypes = options.rangeTypes;
+					if (options.forVersions && (isRollingWorkspaceSpec(version) || version !== "*" && !semver.satisfies(version.replace(POSSIBLE_WORKSPACE_SPEC_REGEX, ""), options.forVersions))) continue;
+					const rangeTypes = options.rangeTypes.map(normalizeRangeType);
+					const validRangeTypes = rangeTypes.map(displayRangeType).join(", ");
 					if (version === "*") {
 						context.report({
-							data: { rangeTypes: rangeTypes.join(", ") },
+							data: { rangeTypes: validRangeTypes },
 							messageId: "wrongRangeType",
 							node: property.value
 						});
 						break;
 					}
-					if (!rangeTypes.some((rangeType) => {
-						switch (rangeType) {
-							case "caret": return isCaretRange;
-							case "pin": return isPinned;
-							case "tilde": return isTildeRange;
-						}
-					})) context.report({
-						data: { rangeTypes: rangeTypes.join(", ") },
+					if (!rangeTypes.some(doesRangeTypeMatch)) context.report({
+						data: { rangeTypes: validRangeTypes },
 						messageId: "wrongRangeType",
 						node: property.value,
 						suggest: rangeTypes.map((rangeType) => ({
 							fix(fixer) {
 								return fixer.replaceText(property.value, `"${changeVersionRange(version, rangeType)}"`);
 							},
-							messageId: `changeTo${capitalize(rangeType)}`
+							messageId: rangeType.alias === "pin" ? "changeToPin" : "changeTo",
+							data: rangeType.alias === "pin" ? void 0 : { rangeType: displayRangeType(rangeType) }
 						}))
 					});
 					break;
@@ -965,9 +1018,8 @@ const rule$9 = createRule({
 		docs: { description: "Restricts the range of dependencies to allow or disallow specific types of ranges." },
 		hasSuggestions: true,
 		messages: {
-			changeToCaret: "Change to use a caret range.",
 			changeToPin: "Pin the version.",
-			changeToTilde: "Change to use a tilde range.",
+			changeTo: "Change to use a {{rangeType}} range",
 			wrongRangeType: "This dependency is using the wrong range type.  Acceptable range type(s): {{rangeTypes}}"
 		},
 		schema: [{ oneOf: [schemaOptions, {
@@ -1099,23 +1151,26 @@ const rule$7 = createRule({
 });
 //#endregion
 //#region src/rules/scripts-name-casing.ts
-const BUILT_IN_SCRIPTS_IN_CAMEL_CASE = /* @__PURE__ */ new Set(["prepublishOnly"]);
+const BUILT_IN_SCRIPTS_IN_CAMEL_CASE = /* @__PURE__ */ new Set(["prepublishOnly", "pnpm:devPreinstall"]);
 const rule$6 = createRule({
 	create(context) {
+		const { ignoreNames = [], ignorePatterns = [] } = context.options[0] ?? {};
+		const ignoreRegexes = ignorePatterns.map((pattern) => new RegExp(pattern));
+		const isIgnored = (name) => ignoreNames.includes(name) || ignoreRegexes.some((regex) => regex.test(name));
 		return { "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=scripts]"(node) {
 			if (node.value.type === "JSONObjectExpression") for (const property of node.value.properties) {
 				const keyNode = property.key;
 				const key = keyNode.value;
-				if (BUILT_IN_SCRIPTS_IN_CAMEL_CASE.has(key)) continue;
-				const kebabCaseKey = key.split(":").map((segment) => kebabCase(segment)).join(":");
-				if (kebabCaseKey !== key) context.report({
+				if (BUILT_IN_SCRIPTS_IN_CAMEL_CASE.has(key) || isIgnored(key)) continue;
+				const kebabCaseKey = (key.startsWith(".") ? key.slice(1) : key).split(":").map((segment) => kebabCase(segment)).join(":");
+				if (kebabCaseKey !== (key.startsWith(".") ? key.slice(1) : key)) context.report({
 					data: { property: key },
 					messageId: "invalidCase",
 					node: keyNode,
 					suggest: [{
 						data: { property: key },
 						fix: (fixer) => {
-							return fixer.replaceText(keyNode, JSON.stringify(kebabCaseKey));
+							return fixer.replaceText(keyNode, JSON.stringify(key.startsWith(".") ? `.${kebabCaseKey}` : kebabCaseKey));
 						},
 						messageId: "convertToKebabCase"
 					}]
@@ -1124,6 +1179,7 @@ const rule$6 = createRule({
 		} };
 	},
 	meta: {
+		defaultOptions: [{}],
 		docs: {
 			category: "Stylistic",
 			description: "Enforce that names for `scripts` are in kebab case (optionally separated by colons)."
@@ -1133,7 +1189,22 @@ const rule$6 = createRule({
 			convertToKebabCase: "Convert {{ property }} to kebab case.",
 			invalidCase: "Script name {{ property }} should be in kebab case."
 		},
-		schema: [],
+		schema: [{
+			additionalProperties: false,
+			properties: {
+				ignoreNames: {
+					items: { type: ["string"] },
+					type: ["array"],
+					description: "Specific script names to ignore."
+				},
+				ignorePatterns: {
+					items: { type: ["string"] },
+					type: ["array"],
+					description: "Regex patterns for script names to ignore."
+				}
+			},
+			type: "object"
+		}],
 		type: "suggestion"
 	},
 	name: "scripts-name-casing"
@@ -1543,6 +1614,130 @@ const createSimpleValidPropertyRule = (propertyName, validationFunction, aliases
 		ruleName
 	};
 };
+//#endregion
+//#region src/utils/packageManager/constants.ts
+const AGENTS = [
+	"npm",
+	"yarn",
+	"pnpm",
+	"bun",
+	"deno",
+	"nub",
+	"aube"
+];
+const LOCK_FILES = {
+	"aube-lock.yaml": "aube",
+	"aube-workspace.yaml": "aube",
+	"bun.lock": "bun",
+	"bun.lockb": "bun",
+	"deno.lock": "deno",
+	"nub.lock": "nub",
+	"pnpm-lock.yaml": "pnpm",
+	"pnpm-workspace.yaml": "pnpm",
+	"yarn.lock": "yarn",
+	"package-lock.json": "npm",
+	"npm-shrinkwrap.json": "npm"
+};
+//#endregion
+//#region src/utils/packageManager/detectPackageManager.ts
+let packageManagerCache;
+const userAgentRegex = /^(.+?)\/(\S+)?/;
+function getPackageManagerFromUserAgent() {
+	const userAgentMatch = process.env.npm_config_user_agent?.match(userAgentRegex);
+	if (userAgentMatch) {
+		const name = userAgentMatch[1];
+		const version = userAgentMatch[2];
+		if (AGENTS.includes(name)) return {
+			name,
+			version
+		};
+	}
+	return null;
+}
+function setPackageManagerCache(result) {
+	packageManagerCache = result;
+	return packageManagerCache;
+}
+function* lookup(cwd = process.cwd()) {
+	let directory = path.resolve(cwd);
+	const { root } = path.parse(directory);
+	while (directory && directory !== root) {
+		yield directory;
+		directory = path.dirname(directory);
+	}
+}
+function parsePackageJson(filepath) {
+	if (!filepath || !fs.existsSync(filepath)) return null;
+	return handlePackageManager(filepath);
+}
+/**
+* Detects the package manager used in the project.
+* @returns The detected package manager or `null` if not found.
+*/
+function detectPackageManager() {
+	if (packageManagerCache) return packageManagerCache;
+	const cwd = process.cwd();
+	const strategies = [
+		"lockfile",
+		"packageManager-field",
+		"user-agent"
+	];
+	for (const directory of lookup(cwd)) for (const strategy of strategies) switch (strategy) {
+		case "lockfile":
+			if (fs.existsSync(path.join(directory, "rush.json"))) return setPackageManagerCache({ name: "pnpm" });
+			for (const lock of Object.keys(LOCK_FILES)) if (fs.existsSync(path.join(directory, lock))) {
+				const name = LOCK_FILES[lock];
+				return setPackageManagerCache(parsePackageJson(path.join(directory, "package.json")) ?? { name });
+			}
+			break;
+		case "packageManager-field": {
+			const result = parsePackageJson(path.join(directory, "package.json"));
+			if (result) return setPackageManagerCache(result);
+			break;
+		}
+		case "user-agent": {
+			const result = getPackageManagerFromUserAgent();
+			if (result) return setPackageManagerCache(result);
+			break;
+		}
+	}
+	return null;
+}
+function getNameAndVersion(pkg) {
+	const normalizeVersion = (version) => version?.match(/\d+(?:\.\d+){0,2}/)?.[0] ?? version;
+	if (typeof pkg.packageManager === "string") {
+		const [name, version] = pkg.packageManager.replace(/^\^/, "").split("@", 2);
+		return {
+			name,
+			version: normalizeVersion(version)
+		};
+	}
+	if (typeof pkg.devEngines?.packageManager?.name === "string") return {
+		name: pkg.devEngines.packageManager.name,
+		version: normalizeVersion(pkg.devEngines.packageManager.version)
+	};
+}
+function handlePackageManager(filepath) {
+	try {
+		const content = fs.readFileSync(filepath, "utf8");
+		const nameAndVer = getNameAndVersion(JSON.parse(content));
+		if (nameAndVer) return {
+			name: nameAndVer.name,
+			version: nameAndVer.version
+		};
+	} catch {}
+	return null;
+}
+//#endregion
+//#region src/rules/valid-properties.ts
+const packageManagerAwareValidateDependencies = (value) => {
+	const result = detectPackageManager();
+	if (result?.name === "pnpm") {
+		const version = result.version;
+		if (!version || semver.gte(version, "11.1.0")) return validateDependencies(value, { allowNamedRegistries: true });
+	}
+	return validateDependencies(value);
+};
 /** All basic valid- flavor rules */
 const rules$1 = Object.fromEntries([
 	["bin", validateBin],
@@ -1556,8 +1751,8 @@ const rules$1 = Object.fromEntries([
 	["contributors", validateContributors],
 	["cpu", validateCpu],
 	["description", validateDescription],
-	["dependencies", validateDependencies],
-	["devDependencies", validateDependencies],
+	["dependencies", packageManagerAwareValidateDependencies],
+	["devDependencies", packageManagerAwareValidateDependencies],
 	["devEngines", validateDevEngines],
 	["directories", validateDirectories],
 	["engines", validateEngines],
@@ -1611,7 +1806,7 @@ const pathEndsWith = (parent, child) => {
 	let pathToCheck = "";
 	return segments.reverse().some((segment) => {
 		pathToCheck = path.join(segment, pathToCheck);
-		if (pathToCheck === child) return true;
+		return pathToCheck === child;
 	});
 };
 let repoRootCache = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-package-json",
-  "version": "1.6.2",
+  "version": "1.7.0",
   "description": "Rules for consistent, readable, and valid package.json files. 🗂️",
   "homepage": "https://github.com/michaelfaith/eslint-plugin-package-json#readme",
   "bugs": {
@@ -51,7 +51,7 @@
     "eslint-fix-utils": "~0.4.3",
     "eslint-json-compat-utils": "^0.2.3",
     "jsonc-eslint-parser": "^3.1.0",
-    "package-json-validator": "^1.5.0",
+    "package-json-validator": "^1.6.0",
     "semver": "^7.7.3",
     "sort-object-keys": "^2.0.0",
     "sort-package-json": "^4.0.0"
@@ -67,28 +67,28 @@
     "@eslint/markdown": "8.0.1",
     "@ianvs/prettier-plugin-sort-imports": "4.7.1",
     "@types/node": "24.13.0",
-    "@types/semver": "7.7.1",
+    "@types/semver": "7.8.0",
     "@typescript/native": "npm:typescript@7.0.2",
     "@vitest/coverage-v8": "4.1.8",
     "@vitest/eslint-plugin": "1.6.20",
-    "astro": "7.1.0",
+    "astro": "7.2.0",
     "astro-og-canvas": "0.13.0",
     "canvaskit-wasm": "0.41.1",
     "console-fail-test": "0.6.0",
-    "eslint": "10.7.0",
+    "eslint": "10.8.0",
     "eslint-doc-generator": "3.7.0",
-    "eslint-plugin-eslint-plugin": "7.5.0",
-    "eslint-plugin-jsdoc": "63.2.0",
-    "eslint-plugin-jsonc": "3.3.0",
+    "eslint-plugin-eslint-plugin": "7.6.0",
+    "eslint-plugin-jsdoc": "63.3.0",
+    "eslint-plugin-jsonc": "3.4.0",
     "eslint-plugin-n": "18.2.1",
     "eslint-plugin-node-dependencies": "2.2.0",
     "eslint-plugin-perfectionist": "5.10.0",
     "eslint-plugin-regexp": "3.1.0",
-    "eslint-plugin-unicorn": "72.0.0",
-    "eslint-plugin-yml": "3.6.0",
+    "eslint-plugin-unicorn": "73.0.0",
+    "eslint-plugin-yml": "3.8.0",
     "jiti": "2.7.0",
     "json-schema-to-ts": "3.1.1",
-    "knip": "6.29.0",
+    "knip": "6.32.0",
     "prettier": "3.9.0",
     "prettier-plugin-curly": "0.4.1",
     "prettier-plugin-packagejson": "3.0.2",
@@ -99,7 +99,7 @@
     "starlight-auto-sidebar": "0.4.0",
     "tsdown": "0.22.2",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "typescript-eslint": "8.65.0",
+    "typescript-eslint": "8.66.0",
     "vitest": "4.1.8"
   },
   "peerDependencies": {