eslint-plugin-package-json 1.5.0 → 1.6.1

package/lib/rules/restrict-dependency-ranges.mjs

@@ -1,147 +0,0 @@
-import { isJSONStringLiteral } from "../utils/predicates/isJSONStringLiteral.mjs";
-import { createRule } from "../createRule.mjs";
-import semver from "semver";
-//#region src/rules/restrict-dependency-ranges.ts
-const DEPENDENCY_TYPES = [
-	"dependencies",
-	"devDependencies",
-	"optionalDependencies",
-	"peerDependencies"
-];
-const RANGE_TYPES = [
-	"caret",
-	"pin",
-	"tilde"
-];
-const schemaOptions = {
-	additionalProperties: false,
-	properties: {
-		forDependencyTypes: {
-			description: "Apply a range type restriction for an entire group of dependencies by which type of dependencies they belong to.",
-			items: { enum: DEPENDENCY_TYPES },
-			type: "array"
-		},
-		forPackages: {
-			description: "The exact name of a package, or a regex pattern used to match a group of packages by name.",
-			items: { type: "string" },
-			type: "array"
-		},
-		forVersions: {
-			description: "Apply a restriction to a specific semver range.",
-			type: "string"
-		},
-		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 },
-				type: "array"
-			}]
-		}
-	},
-	required: ["rangeType"],
-	type: "object"
-};
-const SYMBOLS = {
-	caret: "^",
-	pin: "",
-	tilde: "~"
-};
-/**
-* 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:~";
-	}
-	return version.replace(/^(workspace:)?(\^|~|<=?|>=?)?/, `$1${SYMBOLS[rangeType]}`);
-};
-/**
-* 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:/, "");
-	return !!semver.validRange(rawVersion);
-};
-const capitalize = (str) => {
-	return str.charAt(0).toUpperCase() + str.slice(1);
-};
-const rule = createRule({
-	create(context) {
-		if (!context.options[0]) return {};
-		const optionsArray = (Array.isArray(context.options[0]) ? context.options[0].toReversed() : [context.options[0]]).map((option) => ({
-			...option,
-			forPackages: option.forPackages?.map((pattern) => new RegExp(pattern)),
-			rangeTypes: Array.isArray(option.rangeType) ? option.rangeType : [option.rangeType]
-		}));
-		return { "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.type=JSONLiteral][value.type=JSONObjectExpression]"(node) {
-			const dependencyType = node.key.value;
-			if (!DEPENDENCY_TYPES.includes(dependencyType)) return;
-			for (const property of node.value.properties) {
-				if (!isJSONStringLiteral(property.key) || !isJSONStringLiteral(property.value)) continue;
-				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:^");
-				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 (version === "*") {
-						context.report({
-							data: { rangeTypes: rangeTypes.join(", ") },
-							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(", ") },
-						messageId: "wrongRangeType",
-						node: property.value,
-						suggest: rangeTypes.map((rangeType) => ({
-							fix(fixer) {
-								return fixer.replaceText(property.value, `"${changeVersionRange(version, rangeType)}"`);
-							},
-							messageId: `changeTo${capitalize(rangeType)}`
-						}))
-					});
-					break;
-				}
-			}
-		} };
-	},
-	meta: {
-		defaultOptions: [[]],
-		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.",
-			wrongRangeType: "This dependency is using the wrong range type.  Acceptable range type(s): {{rangeTypes}}"
-		},
-		schema: [{ oneOf: [schemaOptions, {
-			description: "Array of configuration options, specifying range requirements.",
-			items: schemaOptions,
-			type: "array"
-		}] }],
-		type: "suggestion"
-	},
-	name: "restrict-dependency-ranges"
-});
-//#endregion
-export { rule };

package/lib/rules/restrict-private-properties.d.mts

@@ -1,20 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/restrict-private-properties.d.ts
-declare const rule: PackageJsonRuleModule<[({
-  blockedProperties?: string[] | undefined;
-} | undefined)?], [{
-  readonly additionalProperties: false;
-  readonly properties: {
-    readonly blockedProperties: {
-      readonly description: "Array of property names to disallow in private packages.";
-      readonly items: {
-        readonly type: "string";
-      };
-      readonly type: "array";
-    };
-  };
-  readonly type: "object";
-}]>;
-//#endregion
-export { rule };

package/lib/rules/restrict-private-properties.mjs

@@ -1,53 +0,0 @@
-import { isJSONStringLiteral } from "../utils/predicates/isJSONStringLiteral.mjs";
-import { createRule } from "../createRule.mjs";
-import { fixRemoveObjectProperty } from "eslint-fix-utils";
-//#region src/rules/restrict-private-properties.ts
-const defaultBlockedProperties = ["files", "publishConfig"];
-const rule = createRule({
-	create(context) {
-		const blockedProperties = context.options[0]?.blockedProperties ?? defaultBlockedProperties;
-		return { "Program > JSONExpressionStatement > JSONObjectExpression"(node) {
-			if (node.properties.every((property) => !(isJSONStringLiteral(property.key) && property.key.value === "private" && property.value.type === "JSONLiteral" && property.value.value === true))) return;
-			for (const property of node.properties) if (isJSONStringLiteral(property.key) && blockedProperties.includes(property.key.value)) {
-				const isEmpty = property.value.type === "JSONArrayExpression" && property.value.elements.length === 0 || property.value.type === "JSONObjectExpression" && property.value.properties.length === 0;
-				context.report({
-					data: { property: property.key.value },
-					messageId: "unnecessaryProperty",
-					node: property,
-					...isEmpty ? { fix: fixRemoveObjectProperty(context, property) } : { suggest: [{
-						data: { property: property.key.value },
-						fix: fixRemoveObjectProperty(context, property),
-						messageId: "removePropertySuggestion"
-					}] }
-				});
-			}
-		} };
-	},
-	meta: {
-		defaultOptions: [{ blockedProperties: defaultBlockedProperties }],
-		docs: {
-			category: "Best Practices",
-			description: "Disallows unnecessary properties in private packages.",
-			recommended: false
-		},
-		fixable: "code",
-		hasSuggestions: true,
-		messages: {
-			removePropertySuggestion: "Remove the '{{ property }}' field.",
-			unnecessaryProperty: "The '{{ property }}' field is unnecessary in private packages and can be removed."
-		},
-		schema: [{
-			additionalProperties: false,
-			properties: { blockedProperties: {
-				description: "Array of property names to disallow in private packages.",
-				items: { type: "string" },
-				type: "array"
-			} },
-			type: "object"
-		}],
-		type: "suggestion"
-	},
-	name: "restrict-private-properties"
-});
-//#endregion
-export { rule };

package/lib/rules/restrict-top-level-properties.d.mts

@@ -1,39 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/restrict-top-level-properties.d.ts
-declare const rule: PackageJsonRuleModule<[({
-  ban?: (string | {
-    message?: string | undefined;
-    property: string;
-  })[] | undefined;
-} | undefined)?], [{
-  readonly additionalProperties: false;
-  readonly properties: {
-    readonly ban: {
-      readonly description: "List of top-level properties to ban. Each entry can be a property name string or an object with a property name and an optional custom message.";
-      readonly items: {
-        readonly oneOf: readonly [{
-          readonly type: "string";
-        }, {
-          readonly additionalProperties: false;
-          readonly properties: {
-            readonly message: {
-              readonly description: "Custom message to append to the error report.";
-              readonly type: "string";
-            };
-            readonly property: {
-              readonly description: "The top-level property name to ban.";
-              readonly type: "string";
-            };
-          };
-          readonly required: readonly ["property"];
-          readonly type: "object";
-        }];
-      };
-      readonly type: "array";
-    };
-  };
-  readonly type: "object";
-}]>;
-//#endregion
-export { rule };

package/lib/rules/restrict-top-level-properties.mjs

@@ -1,73 +0,0 @@
-import { isJSONStringLiteral } from "../utils/predicates/isJSONStringLiteral.mjs";
-import { createRule } from "../createRule.mjs";
-import { fixRemoveObjectProperty } from "eslint-fix-utils";
-//#region src/rules/restrict-top-level-properties.ts
-const rule = createRule({
-	create(context) {
-		const banList = Object.fromEntries(
-			/* v8 ignore next - not possible to cover due to presence of `defaultOptions` */
-			(context.options[0]?.ban ?? []).map((entry) => typeof entry === "string" ? [entry, ""] : [entry.property, entry.message ?? ""])
-		);
-		return { "Program > JSONExpressionStatement > JSONObjectExpression"(node) {
-			for (const property of node.properties) {
-				if (!isJSONStringLiteral(property.key)) continue;
-				const propertyName = property.key.value;
-				if (Object.hasOwn(banList, propertyName)) {
-					const customMessage = banList[propertyName];
-					context.report({
-						data: {
-							customMessage: customMessage ? `: ${customMessage}` : "",
-							property: propertyName
-						},
-						messageId: "bannedProperty",
-						node: property.key,
-						suggest: [{
-							fix: fixRemoveObjectProperty(context, property),
-							messageId: "removePropertySuggestion"
-						}]
-					});
-				}
-			}
-		} };
-	},
-	meta: {
-		defaultOptions: [{ ban: [] }],
-		docs: {
-			category: "Best Practices",
-			description: "Disallows specified top-level properties in package.json.",
-			recommended: false
-		},
-		hasSuggestions: true,
-		messages: {
-			bannedProperty: "The `{{ property }}` property is not allowed{{ customMessage }}",
-			removePropertySuggestion: "Remove the property."
-		},
-		schema: [{
-			additionalProperties: false,
-			properties: { ban: {
-				description: "List of top-level properties to ban. Each entry can be a property name string or an object with a property name and an optional custom message.",
-				items: { oneOf: [{ type: "string" }, {
-					additionalProperties: false,
-					properties: {
-						message: {
-							description: "Custom message to append to the error report.",
-							type: "string"
-						},
-						property: {
-							description: "The top-level property name to ban.",
-							type: "string"
-						}
-					},
-					required: ["property"],
-					type: "object"
-				}] },
-				type: "array"
-			} },
-			type: "object"
-		}],
-		type: "suggestion"
-	},
-	name: "restrict-top-level-properties"
-});
-//#endregion
-export { rule };

package/lib/rules/scripts-name-casing.d.mts

@@ -1,6 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/scripts-name-casing.d.ts
-declare const rule: PackageJsonRuleModule<[], []>;
-//#endregion
-export { rule };

package/lib/rules/scripts-name-casing.mjs

@@ -1,44 +0,0 @@
-import { createRule } from "../createRule.mjs";
-import { kebabCase } from "change-case";
-//#region src/rules/scripts-name-casing.ts
-const BUILT_IN_SCRIPTS_IN_CAMEL_CASE = new Set(["prepublishOnly"]);
-const rule = createRule({
-	create(context) {
-		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({
-					data: { property: key },
-					messageId: "invalidCase",
-					node: keyNode,
-					suggest: [{
-						data: { property: key },
-						fix: (fixer) => {
-							return fixer.replaceText(keyNode, JSON.stringify(kebabCaseKey));
-						},
-						messageId: "convertToKebabCase"
-					}]
-				});
-			}
-		} };
-	},
-	meta: {
-		docs: {
-			category: "Stylistic",
-			description: "Enforce that names for `scripts` are in kebab case (optionally separated by colons)."
-		},
-		hasSuggestions: true,
-		messages: {
-			convertToKebabCase: "Convert {{ property }} to kebab case.",
-			invalidCase: "Script name {{ property }} should be in kebab case."
-		},
-		schema: [],
-		type: "suggestion"
-	},
-	name: "scripts-name-casing"
-});
-//#endregion
-export { rule };

package/lib/rules/sort-collections.d.mts

@@ -1,35 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/sort-collections.d.ts
-declare const rule: PackageJsonRuleModule<[((string | {
-  order: string[];
-  key: string;
-})[] | undefined)?], [{
-  readonly description: "Array of package properties to require sorting. Provide a string to sort that collection lexicographically (lifecycle-aware for `scripts`), or an object to sort it by a specified order.";
-  readonly items: {
-    readonly anyOf: readonly [{
-      readonly type: "string";
-    }, {
-      readonly additionalProperties: false;
-      readonly properties: {
-        readonly key: {
-          readonly description: "The collection property to sort.";
-          readonly type: "string";
-        };
-        readonly order: {
-          readonly description: "The order to sort the collection by. Keys not listed are appended in lexicographical order.";
-          readonly items: {
-            readonly type: "string";
-          };
-          readonly type: "array";
-          readonly uniqueItems: true;
-        };
-      };
-      readonly required: readonly ["key", "order"];
-      readonly type: "object";
-    }];
-  };
-  readonly type: "array";
-}]>;
-//#endregion
-export { rule };

package/lib/rules/sort-collections.mjs

@@ -1,111 +0,0 @@
-import { createRule } from "../createRule.mjs";
-import detectIndent from "detect-indent";
-import { detectNewlineGraceful } from "detect-newline";
-import sortPackageJson from "sort-package-json";
-//#region src/rules/sort-collections.ts
-const defaultCollections = new Set([
-	"config",
-	"dependencies",
-	"devDependencies",
-	"exports",
-	"optionalDependencies",
-	"overrides",
-	"peerDependencies",
-	"peerDependenciesMeta",
-	"scripts"
-]);
-const rule = createRule({
-	create(context) {
-		const toSort = new Map((context.options[0] ?? Array.from(defaultCollections)).map((entry) => typeof entry === "string" ? [entry, null] : [entry.key, entry.order]));
-		return { "JSONProperty:exit"(node) {
-			const { key: nodeKey, value: collection } = node;
-			if (nodeKey.type !== "JSONLiteral" || collection.type !== "JSONObjectExpression") return;
-			const keyPartsReversed = [nodeKey.value];
-			for (let currNode = node.parent; currNode; currNode = currNode.parent) if (currNode.type === "JSONProperty" && currNode.key.type === "JSONLiteral") keyPartsReversed.push(currNode.key.value);
-			else if (currNode.type === "JSONArrayExpression") return;
-			const key = keyPartsReversed.reverse().join(".");
-			const customOrder = toSort.get(key);
-			if (customOrder === void 0) return;
-			const currentOrder = collection.properties;
-			const isScripts = keyPartsReversed.at(-1) === "scripts";
-			let naturalCompare;
-			if (isScripts) {
-				const scriptsSource = context.sourceCode.getText(node);
-				const { scripts: sortedScripts } = sortPackageJson(JSON.parse(`{${scriptsSource}}`));
-				const lifecycleIndex = new Map(Object.keys(sortedScripts).map((k, i) => [k, i]));
-				naturalCompare = (a, b) => (lifecycleIndex.get(a) ?? 0) - (lifecycleIndex.get(b) ?? 0);
-			} else naturalCompare = (a, b) => a > b ? 1 : -1;
-			const orderIndex = new Map((customOrder ?? []).map((k, i) => [k, i]));
-			const rank = (k) => orderIndex.get(k) ?? orderIndex.size;
-			const desiredOrder = currentOrder.toSorted((a, b) => {
-				const aKey = a.key.value;
-				const bKey = b.key.value;
-				const ai = rank(aKey);
-				const bi = rank(bKey);
-				if (ai !== bi) return ai - bi;
-				return naturalCompare(aKey, bKey);
-			});
-			if (currentOrder.some((property, i) => desiredOrder[i] !== property)) context.report({
-				data: { key },
-				fix(fixer) {
-					const { text } = context.sourceCode;
-					const { indent, type } = detectIndent(text);
-					const newline = detectNewlineGraceful(text);
-					const indentUnit = type === "tab" ? "	" : indent || "  ";
-					const jsonLines = JSON.stringify(desiredOrder.reduce((out, property) => {
-						out[property.key.value] = JSON.parse(context.sourceCode.getText(property.value));
-						return out;
-					}, {}), null, indentUnit).split("\n");
-					const collectionStartLine = collection.loc.start.line;
-					const lineText = context.sourceCode.lines[collectionStartLine - 1];
-					const leadingWhitespaceMatch = /^\s*/.exec(lineText);
-					const leadingWhitespace = leadingWhitespaceMatch ? leadingWhitespaceMatch[0] : "";
-					const result = jsonLines.map((l, i) => i === 0 ? l : leadingWhitespace + l).join(newline);
-					return fixer.replaceText(collection, result);
-				},
-				loc: collection.loc,
-				messageId: customOrder ? "unsortedOrder" : isScripts ? "unsortedScripts" : "unsortedKeys",
-				node
-			});
-		} };
-	},
-	meta: {
-		defaultOptions: [Array.from(defaultCollections)],
-		docs: {
-			category: "Best Practices",
-			description: "Selected collections must be in a consistent order (lexicographical for most; lifecycle-aware for scripts).",
-			recommended: true
-		},
-		fixable: "code",
-		messages: {
-			unsortedKeys: "Entries in '{{ key }}' are not in lexicographical order",
-			unsortedOrder: "Entries in '{{ key }}' are not in the specified order",
-			unsortedScripts: "Entries in 'scripts' are not in lexicographical order and grouped by lifecycles"
-		},
-		schema: [{
-			description: "Array of package properties to require sorting. Provide a string to sort that collection lexicographically (lifecycle-aware for `scripts`), or an object to sort it by a specified order.",
-			items: { anyOf: [{ type: "string" }, {
-				additionalProperties: false,
-				properties: {
-					key: {
-						description: "The collection property to sort.",
-						type: "string"
-					},
-					order: {
-						description: "The order to sort the collection by. Keys not listed are appended in lexicographical order.",
-						items: { type: "string" },
-						type: "array",
-						uniqueItems: true
-					}
-				},
-				required: ["key", "order"],
-				type: "object"
-			}] },
-			type: "array"
-		}],
-		type: "layout"
-	},
-	name: "sort-collections"
-});
-//#endregion
-export { rule };

package/lib/rules/specify-peers-locally.d.mts

@@ -1,6 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/specify-peers-locally.d.ts
-declare const rule: PackageJsonRuleModule<[], []>;
-//#endregion
-export { rule };

package/lib/rules/specify-peers-locally.mjs

@@ -1,63 +0,0 @@
-import { isJSONStringLiteral } from "../utils/predicates/isJSONStringLiteral.mjs";
-import { createRule } from "../createRule.mjs";
-//#region src/rules/specify-peers-locally.ts
-const rule = createRule({
-	create(context) {
-		const devDependencyNames = /* @__PURE__ */ new Set();
-		let devDependenciesObjectNode;
-		const peerDependencyMap = {};
-		return {
-			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.type=JSONLiteral][value.type=JSONObjectExpression][key.value=devDependencies]"(node) {
-				devDependenciesObjectNode = node.value;
-				for (const devDependencyPropertyNode of node.value.properties) {
-					const dependencyKey = devDependencyPropertyNode.key;
-					if (isJSONStringLiteral(dependencyKey)) devDependencyNames.add(dependencyKey.value);
-				}
-			},
-			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.type=JSONLiteral][value.type=JSONObjectExpression][key.value=peerDependencies]"(node) {
-				for (const peerDependencyPropertyNode of node.value.properties) {
-					const dependencyKey = peerDependencyPropertyNode.key;
-					if (isJSONStringLiteral(dependencyKey)) peerDependencyMap[dependencyKey.value] = peerDependencyPropertyNode;
-				}
-			},
-			"Program:exit"() {
-				for (const [peerDependencyName, peerDependencyNode] of Object.entries(peerDependencyMap)) if (!devDependencyNames.has(peerDependencyName)) {
-					const peerDependencyValue = peerDependencyNode.value;
-					context.report({
-						data: { name: peerDependencyName },
-						messageId: "devDependencyNotDefined",
-						node: peerDependencyNode,
-						suggest: devDependenciesObjectNode && isJSONStringLiteral(peerDependencyValue) ? [{
-							data: { name: peerDependencyName },
-							fix: (fixer) => {
-								const updatedDevDependencies = {
-									...JSON.parse(context.sourceCode.getText(devDependenciesObjectNode)),
-									[peerDependencyName]: peerDependencyValue.value
-								};
-								const sortedDevDependencies = Object.fromEntries(Object.entries(updatedDevDependencies).sort((a, b) => a[0] > b[0] ? 1 : -1));
-								return fixer.replaceText(devDependenciesObjectNode, JSON.stringify(sortedDevDependencies, null, 2).split("\n").join("\n  "));
-							},
-							messageId: "addToDevDependencies"
-						}] : []
-					});
-				}
-			}
-		};
-	},
-	meta: {
-		docs: {
-			description: "Requires that all peer dependencies are also declared as dev dependencies",
-			recommended: true
-		},
-		hasSuggestions: true,
-		messages: {
-			addToDevDependencies: "Add \"{{ name }}\" to `devDependencies`",
-			devDependencyNotDefined: "Peer dependency \"{{ name }}\" is not also declared in `devDependencies`."
-		},
-		schema: [],
-		type: "problem"
-	},
-	name: "specify-peers-locally"
-});
-//#endregion
-export { rule };

package/lib/rules/unique-dependencies.d.mts

@@ -1,6 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/unique-dependencies.d.ts
-declare const rule: PackageJsonRuleModule<[], []>;
-//#endregion
-export { rule };