eslint-plugin-package-json 0.62.0 → 0.64.0

package/CHANGELOG.md

@@ -1,11 +1,23 @@
 # Changelog
 
-# [0.62.0](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/compare/v0.61.0...v0.62.0) (2025-11-03)
+# [0.64.0](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/compare/v0.63.0...v0.64.0) (2025-11-04)
+
+
+### Features
+
+* **bin-name-casing:** add new rule ([#1343](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/issues/1343)) ([0e10e87](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/commit/0e10e875eb4cc5f680e154e6ea2333e5902d4c4c)), closes [#1346](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/issues/1346)
 
+# [0.63.0](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/compare/v0.62.0...v0.63.0) (2025-11-04)
+
+### Features
+
+- **restrict-private-properties:** add new rule ([#1336](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/issues/1336)) ([e1225cf](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/commit/e1225cf991be2f3829cdddcae8b06cef8196f070)), closes [#1323](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/issues/1323)
+
+# [0.62.0](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/compare/v0.61.0...v0.62.0) (2025-11-03)
 
 ### Features
 
-* **scripts-name-casing:** add new rule ([#1344](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/issues/1344)) ([e735595](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/commit/e735595537e6857c771eac12a1efcd55cb2d3564)), closes [#61](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/issues/61)
+- **scripts-name-casing:** add new rule ([#1344](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/issues/1344)) ([e735595](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/commit/e735595537e6857c771eac12a1efcd55cb2d3564)), closes [#61](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/issues/61)
 
 # [0.61.0](https://github.com/JoshuaKGoldberg/eslint-plugin-package-json/compare/v0.60.0...v0.61.0) (2025-11-03)
 

package/README.md

@@ -183,6 +183,7 @@ The default settings don't conflict, and Prettier plugins can quickly fix up ord
 
 | Name                                                                       | Description                                                                                                 | 💼   | 🔧 | 💡 | ❌  |
 | :------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------- | :--- | :- | :- | :- |
+| [bin-name-casing](docs/rules/bin-name-casing.md)                           | Enforce that names for bin properties are in kebab case.                                                    | 🎨   |    | 💡 |    |
 | [exports-subpaths-style](docs/rules/exports-subpaths-style.md)             | Enforce consistent format for the exports field (implicit or explicit subpaths).                            | 🎨   | 🔧 |    |    |
 | [no-empty-fields](docs/rules/no-empty-fields.md)                           | Reports on unnecessary empty arrays and objects.                                                            | ✔️ ✅ |    | 💡 |    |
 | [no-redundant-files](docs/rules/no-redundant-files.md)                     | Prevents adding unnecessary / redundant files.                                                              | ✔️ ✅ |    | 💡 |    |
@@ -205,11 +206,12 @@ The default settings don't conflict, and Prettier plugins can quickly fix up ord
 | [require-types](docs/rules/require-types.md)                               | Requires the `types` property to be present.                                                                |      |    |    |    |
 | [require-version](docs/rules/require-version.md)                           | Requires the `version` property to be present.                                                              | ✔️ ✅ |    |    |    |
 | [restrict-dependency-ranges](docs/rules/restrict-dependency-ranges.md)     | Restricts the range of dependencies to allow or disallow specific types of ranges.                          |      |    | 💡 |    |
+| [restrict-private-properties](docs/rules/restrict-private-properties.md)   | Disallows unnecessary properties in private packages.                                                       |      | 🔧 | 💡 |    |
 | [scripts-name-casing](docs/rules/scripts-name-casing.md)                   | Enforce that names for `scripts` are in kebab case (optionally separated by colons).                        | 🎨   |    | 💡 |    |
 | [sort-collections](docs/rules/sort-collections.md)                         | Selected collections must be in a consistent order (lexicographical for most; lifecycle-aware for scripts). | ✔️ ✅ | 🔧 |    |    |
 | [unique-dependencies](docs/rules/unique-dependencies.md)                   | Checks a dependency isn't specified more than once (i.e. in `dependencies` and `devDependencies`)           | ✔️ ✅ |    | 💡 |    |
 | [valid-author](docs/rules/valid-author.md)                                 | Enforce that the `author` property is valid.                                                                | ✔️ ✅ |    |    |    |
-| [valid-bin](docs/rules/valid-bin.md)                                       | Enforce that the `bin` property is valid.                                                                   | ✔️ ✅ |    | 💡 |    |
+| [valid-bin](docs/rules/valid-bin.md)                                       | Enforce that the `bin` property is valid.                                                                   | ✔️ ✅ |    |    |    |
 | [valid-bundleDependencies](docs/rules/valid-bundleDependencies.md)         | Enforce that the `bundleDependencies` (also: `bundledDependencies`) property is valid.                      | ✔️ ✅ |    |    |    |
 | [valid-config](docs/rules/valid-config.md)                                 | Enforce that the `config` property is valid.                                                                | ✔️ ✅ |    |    |    |
 | [valid-cpu](docs/rules/valid-cpu.md)                                       | Enforce that the `cpu` property is valid.                                                                   | ✔️ ✅ |    |    |    |

package/lib/plugin.js

@@ -1,52 +1,54 @@
-import { rule } from "./rules/exports-subpaths-style.js";
-import { rule as rule$1 } from "./rules/no-empty-fields.js";
-import { rule as rule$2 } from "./rules/no-redundant-files.js";
-import { rule as rule$3 } from "./rules/order-properties.js";
-import { rule as rule$4 } from "./rules/repository-shorthand.js";
+import { rule } from "./rules/bin-name-casing.js";
+import { rule as rule$1 } from "./rules/exports-subpaths-style.js";
+import { rule as rule$2 } from "./rules/no-empty-fields.js";
+import { rule as rule$3 } from "./rules/no-redundant-files.js";
+import { rule as rule$4 } from "./rules/order-properties.js";
+import { rule as rule$5 } from "./rules/repository-shorthand.js";
 import { rules } from "./rules/require-properties.js";
-import { rule as rule$5 } from "./rules/restrict-dependency-ranges.js";
-import { rule as rule$6 } from "./rules/scripts-name-casing.js";
-import { rule as rule$7 } from "./rules/sort-collections.js";
-import { rule as rule$8 } from "./rules/unique-dependencies.js";
-import { rule as rule$9 } from "./rules/valid-author.js";
-import { rule as rule$10 } from "./rules/valid-bin.js";
-import { rule as rule$11 } from "./rules/valid-local-dependency.js";
-import { rule as rule$12 } from "./rules/valid-name.js";
-import { rule as rule$13 } from "./rules/valid-package-definition.js";
+import { rule as rule$6 } from "./rules/restrict-dependency-ranges.js";
+import { rule as rule$7 } from "./rules/restrict-private-properties.js";
+import { rule as rule$8 } from "./rules/scripts-name-casing.js";
+import { rule as rule$9 } from "./rules/sort-collections.js";
+import { rule as rule$10 } from "./rules/unique-dependencies.js";
+import { rule as rule$11 } from "./rules/valid-author.js";
+import { rule as rule$12 } from "./rules/valid-local-dependency.js";
+import { rule as rule$13 } from "./rules/valid-name.js";
+import { rule as rule$14 } from "./rules/valid-package-definition.js";
 import { rules as rules$1 } from "./rules/valid-properties.js";
-import { rule as rule$14 } from "./rules/valid-repository-directory.js";
-import { rule as rule$15 } from "./rules/valid-version.js";
+import { rule as rule$15 } from "./rules/valid-repository-directory.js";
+import { rule as rule$16 } from "./rules/valid-version.js";
 import { createRequire } from "node:module";
 import * as parserJsonc from "jsonc-eslint-parser";
 
 //#region src/plugin.ts
 const { name, version } = createRequire(import.meta.url)("../package.json");
 const rules$2 = {
-	"exports-subpaths-style": rule,
-	"no-empty-fields": rule$1,
-	"no-redundant-files": rule$2,
-	"order-properties": rule$3,
+	"bin-name-casing": rule,
+	"exports-subpaths-style": rule$1,
+	"no-empty-fields": rule$2,
+	"no-redundant-files": rule$3,
+	"order-properties": rule$4,
 	...rules,
-	"repository-shorthand": rule$4,
-	"restrict-dependency-ranges": rule$5,
-	"scripts-name-casing": rule$6,
-	"sort-collections": rule$7,
-	"unique-dependencies": rule$8,
+	"repository-shorthand": rule$5,
+	"restrict-dependency-ranges": rule$6,
+	"restrict-private-properties": rule$7,
+	"scripts-name-casing": rule$8,
+	"sort-collections": rule$9,
+	"unique-dependencies": rule$10,
 	...rules$1,
-	"valid-author": rule$9,
-	"valid-bin": rule$10,
-	"valid-local-dependency": rule$11,
-	"valid-name": rule$12,
-	"valid-package-definition": rule$13,
-	"valid-repository-directory": rule$14,
-	"valid-version": rule$15
+	"valid-author": rule$11,
+	"valid-local-dependency": rule$12,
+	"valid-name": rule$13,
+	"valid-package-definition": rule$14,
+	"valid-repository-directory": rule$15,
+	"valid-version": rule$16
 };
-const baseRecommendedRules = { ...Object.fromEntries(Object.entries(rules$2).filter(([, rule$16]) => rule$16.meta.docs?.recommended).map(([name$1]) => ["package-json/" + name$1, "error"])) };
+const baseRecommendedRules = { ...Object.fromEntries(Object.entries(rules$2).filter(([, rule$17]) => rule$17.meta.docs?.recommended).map(([name$1]) => ["package-json/" + name$1, "error"])) };
 const recommendedRules = {
 	...baseRecommendedRules,
 	"package-json/valid-package-definition": ["error", { ignoreProperties: Object.entries(baseRecommendedRules).filter(([name$1]) => name$1.startsWith("package-json/valid-") && name$1 !== "package-json/valid-package-definition").map(([name$1]) => name$1.replace("package-json/valid-", "")) }]
 };
-const stylisticRules = { ...Object.fromEntries(Object.entries(rules$2).filter(([, rule$16]) => rule$16.meta.docs?.category === "Stylistic").map(([name$1]) => ["package-json/" + name$1, "error"])) };
+const stylisticRules = { ...Object.fromEntries(Object.entries(rules$2).filter(([, rule$17]) => rule$17.meta.docs?.category === "Stylistic").map(([name$1]) => ["package-json/" + name$1, "error"])) };
 const plugin = {
 	configs: {
 		"legacy-recommended": {

package/lib/rules/bin-name-casing.d.ts

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

package/lib/rules/bin-name-casing.js

@@ -0,0 +1,43 @@
+import { createRule } from "../createRule.js";
+import { kebabCase } from "change-case";
+
+//#region src/rules/bin-name-casing.ts
+const rule = createRule({
+	create(context) {
+		return { "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=bin]"(node) {
+			if (node.value.type === "JSONObjectExpression") for (const property of node.value.properties) {
+				const key = property.key;
+				const kebabCaseKey = kebabCase(key.value);
+				if (kebabCaseKey !== key.value) context.report({
+					data: { property: key.value },
+					messageId: "invalidCase",
+					node: key,
+					suggest: [{
+						data: { property: key.value },
+						fix: (fixer) => {
+							return fixer.replaceText(key, JSON.stringify(kebabCaseKey));
+						},
+						messageId: "convertToKebabCase"
+					}]
+				});
+			}
+		} };
+	},
+	meta: {
+		docs: {
+			category: "Stylistic",
+			description: "Enforce that names for bin properties are in kebab case."
+		},
+		hasSuggestions: true,
+		messages: {
+			convertToKebabCase: "Convert {{ property }} to kebab case.",
+			invalidCase: "Command name {{ property }} should be in kebab case."
+		},
+		schema: [],
+		type: "suggestion"
+	},
+	name: "bin-name-casing"
+});
+
+//#endregion
+export { rule };

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

@@ -0,0 +1,20 @@
+import { PackageJsonRuleModule } from "../createRule.js";
+
+//#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.js

@@ -0,0 +1,55 @@
+import { createRule } from "../createRule.js";
+import { isJSONStringLiteral } from "../utils/predicates.js";
+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.some((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/valid-properties.js

@@ -1,8 +1,9 @@
 import { createSimpleValidPropertyRule } from "../utils/createSimpleValidPropertyRule.js";
-import { validateBundleDependencies, validateConfig, validateCpu, validateDependencies, validateDescription, validateDirectories, validateExports, validateLicense, validateScripts, validateType } from "package-json-validator";
+import { validateBin, validateBundleDependencies, validateConfig, validateCpu, validateDependencies, validateDescription, validateDirectories, validateExports, validateLicense, validateScripts, validateType } from "package-json-validator";
 
 //#region src/rules/valid-properties.ts
 const properties = [
+	["bin", validateBin],
 	["bundleDependencies", {
 		aliases: ["bundledDependencies"],
 		validator: validateBundleDependencies

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-package-json",
-	"version": "0.62.0",
+	"version": "0.64.0",
 	"description": "Rules for consistent, readable, and valid package.json files. 🗂️",
 	"homepage": "https://github.com/JoshuaKGoldberg/eslint-plugin-package-json#readme",
 	"bugs": {
@@ -59,7 +59,7 @@
 		"@eslint/js": "9.38.0",
 		"@release-it/conventional-changelog": "10.0.0",
 		"@types/estree": "1.0.7",
-		"@types/node": "24.9.1",
+		"@types/node": "24.10.0",
 		"@types/semver": "7.7.0",
 		"@types/validate-npm-package-name": "4.0.2",
 		"@vitest/coverage-v8": "4.0.4",
@@ -97,7 +97,7 @@
 		"eslint": ">=8.0.0",
 		"jsonc-eslint-parser": "^2.0.0"
 	},
-	"packageManager": "pnpm@10.19.0",
+	"packageManager": "pnpm@10.20.0",
 	"engines": {
 		"node": "^20.19.0 || >=22.12.0"
 	},

package/lib/rules/valid-bin.d.ts

@@ -1,17 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.js";
-
-//#region src/rules/valid-bin.d.ts
-declare const rule: PackageJsonRuleModule<[({
-  enforceCase?: boolean | undefined;
-} | undefined)?], [{
-  readonly additionalProperties: false;
-  readonly properties: {
-    readonly enforceCase: {
-      readonly description: "Enforce that the bin's keys should be in kebab case.";
-      readonly type: "boolean";
-    };
-  };
-  readonly type: "object";
-}]>;
-//#endregion
-export { rule };

package/lib/rules/valid-bin.js

@@ -1,62 +0,0 @@
-import { createRule } from "../createRule.js";
-import { formatErrors } from "../utils/formatErrors.js";
-import { kebabCase } from "change-case";
-import { validateBin } from "package-json-validator";
-
-//#region src/rules/valid-bin.ts
-const rule = createRule({
-	create(context) {
-		const shouldEnforceCase = !!context.options[0]?.enforceCase;
-		return { "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=bin]"(node) {
-			const binValueNode = node.value;
-			const errors = validateBin(JSON.parse(context.sourceCode.getText(binValueNode)));
-			if (errors.length) context.report({
-				data: { errors: formatErrors(errors) },
-				messageId: "validationError",
-				node: binValueNode
-			});
-			if (shouldEnforceCase && node.value.type === "JSONObjectExpression") for (const property of node.value.properties) {
-				const key = property.key;
-				const kebabCaseKey = kebabCase(key.value);
-				if (kebabCaseKey !== key.value) context.report({
-					data: { property: key.value },
-					messageId: "invalidCase",
-					node: key,
-					suggest: [{
-						fix: (fixer) => {
-							return fixer.replaceText(key, JSON.stringify(kebabCaseKey));
-						},
-						messageId: "convertToKebabCase"
-					}]
-				});
-			}
-		} };
-	},
-	meta: {
-		defaultOptions: [{ enforceCase: false }],
-		docs: {
-			category: "Best Practices",
-			description: "Enforce that the `bin` property is valid.",
-			recommended: true
-		},
-		hasSuggestions: true,
-		messages: {
-			convertToKebabCase: "Convert command name to kebab case.",
-			invalidCase: "Command name {{ property }} should be in kebab case.",
-			validationError: "Invalid bin: {{ errors }}"
-		},
-		schema: [{
-			additionalProperties: false,
-			properties: { enforceCase: {
-				description: "Enforce that the bin's keys should be in kebab case.",
-				type: "boolean"
-			} },
-			type: "object"
-		}],
-		type: "problem"
-	},
-	name: "valid-bin"
-});
-
-//#endregion
-export { rule };