eslint-plugin-package-json 1.2.0 → 1.4.0

package/README.md

@@ -43,9 +43,10 @@ See [Getting Started](https://eslint-plugin-package-json.dev/getting-started) fo
 | [bin-name-casing](https://eslint-plugin-package-json.dev/rules/bin-name-casing)                                                 | Enforce that names for bin properties are in kebab case.                                                                                                                                     | 🎨    |     | 💡  |
 | [exports-subpaths-style](https://eslint-plugin-package-json.dev/rules/exports-subpaths-style)                                   | Enforce consistent format for the exports field (implicit or explicit subpaths).                                                                                                             | 🎨    | 🔧  |     |
 | [no-empty-fields](https://eslint-plugin-package-json.dev/rules/no-empty-fields)                                                 | Reports on unnecessary empty arrays and objects.                                                                                                                                             | ✅ 📦 |     | 💡  |
+| [no-local-dependencies](https://eslint-plugin-package-json.dev/rules/no-local-dependencies)                                     | Requires that dependencies do not use local file paths, which will likely result in errors when installing from a registry.                                                                  |       |     |     |
 | [no-redundant-files](https://eslint-plugin-package-json.dev/rules/no-redundant-files)                                           | Prevents adding unnecessary / redundant files.                                                                                                                                               | ✅ 📦 |     | 💡  |
 | [no-redundant-publishConfig](https://eslint-plugin-package-json.dev/rules/no-redundant-publishConfig)                           | Warns when publishConfig.access is used in unscoped packages.                                                                                                                                | ✅ 📦 |     | 💡  |
-| [order-properties](https://eslint-plugin-package-json.dev/rules/order-properties)                                               | Package properties should be declared in standard order                                                                                                                                      | 🎨    | 🔧  |     |
+| [order-properties](https://eslint-plugin-package-json.dev/rules/order-properties)                                               | Enforces that package properties are declared in a consistent order.                                                                                                                         | 🎨    | 🔧  |     |
 | [repository-shorthand](https://eslint-plugin-package-json.dev/rules/repository-shorthand)                                       | Enforce either object or shorthand declaration for repository.                                                                                                                               | ✅ 📦 | 🔧  |     |
 | [require-attribution](https://eslint-plugin-package-json.dev/rules/require-attribution)                                         | Ensures that proper attribution is included, requiring that either `author` or `contributors` is defined, and that if `contributors` is present, it should include at least one contributor. | ✅ 📦 |     | 💡  |
 | [restrict-dependency-ranges](https://eslint-plugin-package-json.dev/rules/restrict-dependency-ranges)                           | Restricts the range of dependencies to allow or disallow specific types of ranges.                                                                                                           |       |     | 💡  |

package/lib/plugin.mjs

@@ -1,22 +1,23 @@
 import { rule } from "./rules/bin-name-casing.mjs";
 import { rule as rule$1 } from "./rules/exports-subpaths-style.mjs";
 import { rule as rule$2 } from "./rules/no-empty-fields.mjs";
-import { rule as rule$3 } from "./rules/no-redundant-files.mjs";
-import { rule as rule$4 } from "./rules/no-redundant-publishConfig.mjs";
-import { rule as rule$5 } from "./rules/order-properties.mjs";
-import { rule as rule$6 } from "./rules/repository-shorthand.mjs";
-import { rule as rule$7 } from "./rules/require-attribution.mjs";
+import { rule as rule$3 } from "./rules/no-local-dependencies.mjs";
+import { rule as rule$4 } from "./rules/no-redundant-files.mjs";
+import { rule as rule$5 } from "./rules/no-redundant-publishConfig.mjs";
+import { rule as rule$6 } from "./rules/order-properties.mjs";
+import { rule as rule$7 } from "./rules/repository-shorthand.mjs";
+import { rule as rule$8 } from "./rules/require-attribution.mjs";
 import { rules as rules$1 } from "./rules/require-properties.mjs";
-import { rule as rule$8 } from "./rules/restrict-dependency-ranges.mjs";
-import { rule as rule$9 } from "./rules/restrict-private-properties.mjs";
-import { rule as rule$10 } from "./rules/restrict-top-level-properties.mjs";
-import { rule as rule$11 } from "./rules/scripts-name-casing.mjs";
-import { rule as rule$12 } from "./rules/sort-collections.mjs";
-import { rule as rule$13 } from "./rules/specify-peers-locally.mjs";
-import { rule as rule$14 } from "./rules/unique-dependencies.mjs";
-import { rule as rule$15 } from "./rules/valid-peerDependenciesMeta-relationship.mjs";
+import { rule as rule$9 } from "./rules/restrict-dependency-ranges.mjs";
+import { rule as rule$10 } from "./rules/restrict-private-properties.mjs";
+import { rule as rule$11 } from "./rules/restrict-top-level-properties.mjs";
+import { rule as rule$12 } from "./rules/scripts-name-casing.mjs";
+import { rule as rule$13 } from "./rules/sort-collections.mjs";
+import { rule as rule$14 } from "./rules/specify-peers-locally.mjs";
+import { rule as rule$15 } from "./rules/unique-dependencies.mjs";
+import { rule as rule$16 } from "./rules/valid-peerDependenciesMeta-relationship.mjs";
 import { rules as rules$2 } from "./rules/valid-properties.mjs";
-import { rule as rule$16 } from "./rules/valid-repository-directory.mjs";
+import { rule as rule$17 } from "./rules/valid-repository-directory.mjs";
 import { createRequire } from "node:module";
 import * as parserJsonc from "jsonc-eslint-parser";
 //#region src/plugin.ts
@@ -25,22 +26,23 @@ const rules = {
 	"bin-name-casing": rule,
 	"exports-subpaths-style": rule$1,
 	"no-empty-fields": rule$2,
-	"no-redundant-files": rule$3,
-	"no-redundant-publishConfig": rule$4,
-	"order-properties": rule$5,
-	"require-attribution": rule$7,
+	"no-local-dependencies": rule$3,
+	"no-redundant-files": rule$4,
+	"no-redundant-publishConfig": rule$5,
+	"order-properties": rule$6,
+	"require-attribution": rule$8,
 	...rules$1,
-	"repository-shorthand": rule$6,
-	"restrict-dependency-ranges": rule$8,
-	"restrict-private-properties": rule$9,
-	"restrict-top-level-properties": rule$10,
-	"scripts-name-casing": rule$11,
-	"sort-collections": rule$12,
-	"specify-peers-locally": rule$13,
-	"unique-dependencies": rule$14,
+	"repository-shorthand": rule$7,
+	"restrict-dependency-ranges": rule$9,
+	"restrict-private-properties": rule$10,
+	"restrict-top-level-properties": rule$11,
+	"scripts-name-casing": rule$12,
+	"sort-collections": rule$13,
+	"specify-peers-locally": rule$14,
+	"unique-dependencies": rule$15,
 	...rules$2,
-	"valid-peerDependenciesMeta-relationship": rule$15,
-	"valid-repository-directory": rule$16
+	"valid-peerDependenciesMeta-relationship": rule$16,
+	"valid-repository-directory": rule$17
 };
 const recommendedRules = { ...Object.fromEntries(Object.entries(rules).filter(([, rule]) => rule.meta.docs?.recommended).map(([name]) => ["package-json/" + name, "error"])) };
 const recommendedPublishableRules = {

package/lib/rules/no-local-dependencies.d.mts

@@ -0,0 +1,17 @@
+import { PackageJsonRuleModule } from "../createRule.mjs";
+
+//#region src/rules/no-local-dependencies.d.ts
+declare const rule: PackageJsonRuleModule<[({
+  ignorePrivate?: boolean | undefined;
+} | undefined)?], [{
+  readonly additionalProperties: false;
+  readonly properties: {
+    readonly ignorePrivate: {
+      readonly description: "Determines if this rule should be enforced when the package's `private` property is `true`.";
+      readonly type: "boolean";
+    };
+  };
+  readonly type: "object";
+}]>;
+//#endregion
+export { rule };

package/lib/rules/no-local-dependencies.mjs

@@ -0,0 +1,47 @@
+import { createRule } from "../createRule.mjs";
+import { isJSONStringLiteral } from "../utils/predicates.mjs";
+//#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 rule = createRule({
+	create(context) {
+		const ignorePrivate = context.options[0]?.ignorePrivate ?? true;
+		let isPrivate = false;
+		let dependencyNodes = [];
+		return {
+			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.type=JSONLiteral][value.type=JSONLiteral][key.value=private]"(node) {
+				if (node.value.value === true) isPrivate = true;
+			},
+			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.type=JSONLiteral][value.type=JSONObjectExpression][key.value=dependencies]"(node) {
+				dependencyNodes = node.value.properties;
+			},
+			"Program:exit"() {
+				if (ignorePrivate && isPrivate) return;
+				for (const dependencyPropertyNode of dependencyNodes) {
+					const dependencyValue = dependencyPropertyNode.value;
+					if (isJSONStringLiteral(dependencyValue) && isLocalDependency(dependencyValue.value)) context.report({
+						data: { name: dependencyValue.value },
+						messageId: "localDependencyFound",
+						node: dependencyValue
+					});
+				}
+			}
+		};
+	},
+	meta: {
+		defaultOptions: [{ ignorePrivate: true }],
+		docs: { description: "Requires that dependencies do not use local file paths, which will likely result in errors when installing from a registry." },
+		messages: { localDependencyFound: "Local dependency \"{{ name }}\" is not allowed." },
+		schema: [{
+			additionalProperties: false,
+			properties: { ignorePrivate: {
+				description: "Determines if this rule should be enforced when the package's `private` property is `true`.",
+				type: "boolean"
+			} },
+			type: "object"
+		}],
+		type: "problem"
+	},
+	name: "no-local-dependencies"
+});
+//#endregion
+export { rule };

package/lib/rules/no-redundant-files.mjs

@@ -47,15 +47,14 @@ const rule = createRule({
 				}
 			},
 			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=files]"(node) {
-				if (node.value.type === "JSONArrayExpression") {
-					const seen = /* @__PURE__ */ new Set();
-					const elements = node.value.elements;
-					entryCache.files = elements;
-					for (const [index, element] of elements.entries()) if (isNotNullish(element) && isJSONStringLiteral(element)) {
-						if (seen.has(element.value)) report(elements, index, "duplicate");
-						else seen.add(element.value);
-						for (const defaultFile of defaultFiles) if (defaultFile.test(element.value)) report(elements, index, "unnecessaryDefault");
-					}
+				if (node.value.type !== "JSONArrayExpression") return;
+				const seen = /* @__PURE__ */ new Set();
+				const elements = node.value.elements;
+				entryCache.files = elements;
+				for (const [index, element] of elements.entries()) if (isNotNullish(element) && isJSONStringLiteral(element)) {
+					if (seen.has(element.value)) report(elements, index, "duplicate");
+					else seen.add(element.value);
+					for (const defaultFile of defaultFiles) if (defaultFile.test(element.value)) report(elements, index, "unnecessaryDefault");
 				}
 			},
 			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=main]"(node) {

package/lib/rules/order-properties.mjs

@@ -38,10 +38,10 @@ const rule = createRule({
 		defaultOptions: [{ order: "sort-package-json" }],
 		docs: {
 			category: "Stylistic",
-			description: "Package properties should be declared in standard order"
+			description: "Enforces that package properties are declared in a consistent order."
 		},
 		fixable: "code",
-		messages: { incorrectOrder: "Top-level property \"{{property}}\" is not ordered in the standard way." },
+		messages: { incorrectOrder: "Top-level property `{{property}}` is not ordered in the standard way." },
 		schema: [{
 			additionalProperties: false,
 			properties: { order: {

package/lib/rules/require-attribution.mjs

@@ -15,7 +15,7 @@ const rule = createRule({
 			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=contributors]"(node) {
 				contributorsPropertyNode = node;
 				const contributorsValue = node.value;
-				if (contributorsValue.type !== "JSONArrayExpression" || !contributorsValue.elements.some((element) => !!element)) context.report({
+				if (contributorsValue.type !== "JSONArrayExpression" || contributorsValue.elements.every((element) => !element)) context.report({
 					messageId: "noContributors",
 					node
 				});

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

@@ -102,7 +102,7 @@ const rule = createRule({
 						});
 						break;
 					}
-					if (!rangeTypes.find((rangeType) => {
+					if (!rangeTypes.some((rangeType) => {
 						switch (rangeType) {
 							case "caret": return isCaretRange;
 							case "pin": return isPinned;

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

@@ -7,7 +7,7 @@ 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;
+			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({

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

@@ -1,10 +1,33 @@
 import { PackageJsonRuleModule } from "../createRule.mjs";
 
 //#region src/rules/sort-collections.d.ts
-declare const rule: PackageJsonRuleModule<[(string[] | undefined)?], [{
-  readonly description: "Array of package properties to require sorting.";
+declare const rule: PackageJsonRuleModule<[((string | {
+  key: string;
+  order: 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 type: "string";
+    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";
 }]>;

package/lib/rules/sort-collections.mjs

@@ -1,4 +1,6 @@
 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([
@@ -14,7 +16,7 @@ const defaultCollections = new Set([
 ]);
 const rule = createRule({
 	create(context) {
-		const toSort = context.options[0] ? new Set(context.options[0]) : defaultCollections;
+		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;
@@ -22,27 +24,47 @@ const rule = createRule({
 			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(".");
-			if (!toSort.has(key)) return;
+			const customOrder = toSort.get(key);
+			if (customOrder === void 0) return;
 			const currentOrder = collection.properties;
-			let desiredOrder;
-			if (keyPartsReversed.at(-1) === "scripts") {
+			const isScripts = keyPartsReversed.at(-1) === "scripts";
+			let naturalCompare;
+			if (isScripts) {
 				const scriptsSource = context.sourceCode.getText(node);
 				const { scripts: sortedScripts } = sortPackageJson(JSON.parse(`{${scriptsSource}}`));
-				const propertyNodeMap = Object.fromEntries(collection.properties.map((prop) => [prop.key.value, prop]));
-				desiredOrder = Object.keys(sortedScripts).map((prop) => propertyNodeMap[prop]);
-			} else desiredOrder = currentOrder.toSorted((a, b) => {
-				return a.key.value > b.key.value ? 1 : -1;
+				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) {
-					return fixer.replaceText(collection, JSON.stringify(desiredOrder.reduce((out, property) => {
+					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, 2).split("\n").join("\n  "));
+					}, {}), 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: keyPartsReversed.at(-1) === "scripts" ? "unsortedScripts" : "unsortedKeys",
+				messageId: customOrder ? "unsortedOrder" : isScripts ? "unsortedScripts" : "unsortedKeys",
 				node
 			});
 		} };
@@ -57,11 +79,28 @@ const rule = createRule({
 		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.",
-			items: { type: "string" },
+			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"

package/lib/rules/valid-repository-directory.mjs

@@ -1,8 +1,8 @@
 import { createRule } from "../createRule.mjs";
 import { findPropertyWithKeyValue } from "../utils/findPropertyWithKeyValue.mjs";
-import { findRootSync } from "@altano/repository-tools";
 import path from "node:path";
 import { sep } from "node:path/posix";
+import { findRootSync } from "@altano/repository-tools";
 //#region src/rules/valid-repository-directory.ts
 /**
 * Checks if the child path appears at the end of the parent path.
@@ -11,15 +11,16 @@ import { sep } from "node:path/posix";
 * @example '/a/b/c', 'b' => false
 * @example '/a/b/c', 'd' => false
 */
-function pathEndsWith(parent, child) {
-	const segments = parent.split(path.sep);
+const pathEndsWith = (parent, child) => {
 	if (parent === child) return true;
+	const segments = parent.split(path.sep);
 	let pathToCheck = "";
 	return segments.reverse().some((segment) => {
 		pathToCheck = path.join(segment, pathToCheck);
 		if (pathToCheck === child) return true;
 	});
-}
+};
+let repoRootCache = null;
 const rule = createRule({
 	create(context) {
 		return { "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=repository][value.type=JSONObjectExpression]"(node) {
@@ -27,13 +28,13 @@ const rule = createRule({
 			if (directoryProperty?.value.type !== "JSONLiteral" || typeof directoryProperty.value.value !== "string") return;
 			const directoryValue = directoryProperty.value.value;
 			const fileDirectory = path.normalize(path.dirname(context.filename));
-			const repositoryRoot = findRootSync(fileDirectory);
-			if (repositoryRoot == null) {
-				if (!pathEndsWith(fileDirectory, path.normalize(directoryValue))) context.report({
-					messageId: "mismatched",
-					node: directoryProperty.value
-				});
-			} else {
+			let repositoryRoot;
+			if (repoRootCache && fileDirectory.startsWith(repoRootCache)) repositoryRoot = repoRootCache;
+			else {
+				repositoryRoot = findRootSync(fileDirectory);
+				if (repositoryRoot) repoRootCache = path.normalize(repositoryRoot);
+			}
+			if (repositoryRoot) {
 				const expected = path.relative(repositoryRoot, fileDirectory).replaceAll(path.sep, sep);
 				if (expected !== directoryValue) context.report({
 					messageId: "mismatched",
@@ -46,7 +47,10 @@ const rule = createRule({
 						messageId: "replace"
 					}]
 				});
-			}
+			} else if (!pathEndsWith(fileDirectory, path.normalize(directoryValue))) context.report({
+				messageId: "mismatched",
+				node: directoryProperty.value
+			});
 		} };
 	},
 	meta: {

package/lib/utils/createSimpleRequirePropertyRule.mjs

@@ -16,7 +16,7 @@ const createSimpleRequirePropertyRule = (propertyName, { category, fixValue, ign
 				const ignorePrivate = context.options[0]?.ignorePrivate ?? (typeof enforceForPrivate === "boolean" ? !enforceForPrivate : ignorePrivateDefault);
 				return { "Program > JSONExpressionStatement > JSONObjectExpression"(node) {
 					if (ignorePrivate && node.properties.some((property) => isJSONStringLiteral(property.key) && property.key.value === "private" && property.value.type === "JSONLiteral" && property.value.value === true)) return;
-					if (!node.properties.some((property) => isJSONStringLiteral(property.key) && property.key.value === propertyName)) context.report({
+					if (node.properties.every((property) => !(isJSONStringLiteral(property.key) && property.key.value === propertyName))) context.report({
 						data: { property: propertyName },
 						fix: fixValue === void 0 ? void 0 : function* (fixer) {
 							yield fixer.insertTextAfterRange([0, 1], `\n  "${propertyName}": ${JSON.stringify(fixValue)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-package-json",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Rules for consistent, readable, and valid package.json files. 🗂️",
   "homepage": "https://github.com/michaelfaith/eslint-plugin-package-json#readme",
   "bugs": {
@@ -53,50 +53,52 @@
     "package-json-validator": "^1.5.0",
     "semver": "^7.7.3",
     "sort-object-keys": "^2.0.0",
-    "sort-package-json": "^3.4.0"
+    "sort-package-json": "^4.0.0"
   },
   "devDependencies": {
-    "@astrojs/starlight": "0.39.0",
+    "@astrojs/check": "0.9.9",
+    "@astrojs/starlight": "0.40.0",
     "@catppuccin/starlight": "2.0.1",
-    "@eslint-community/eslint-plugin-eslint-comments": "4.7.0",
+    "@eslint-community/eslint-plugin-eslint-comments": "4.7.2",
     "@eslint/js": "10.0.1",
-    "@eslint/json": "1.2.0",
+    "@eslint/json": "2.0.0",
     "@eslint/markdown": "8.0.1",
+    "@ianvs/prettier-plugin-sort-imports": "4.7.1",
     "@types/estree": "1.0.8",
-    "@types/node": "24.12.0",
+    "@types/node": "24.13.0",
     "@types/semver": "7.7.1",
-    "@vitest/coverage-v8": "4.1.0",
-    "@vitest/eslint-plugin": "1.6.1",
-    "astro": "6.3.0",
+    "@vitest/coverage-v8": "4.1.8",
+    "@vitest/eslint-plugin": "1.6.20",
+    "astro": "6.4.2",
     "astro-og-canvas": "0.11.1",
     "canvaskit-wasm": "0.41.1",
     "console-fail-test": "0.6.0",
-    "eslint": "10.4.0",
+    "eslint": "10.5.0",
     "eslint-doc-generator": "3.6.0",
-    "eslint-plugin-eslint-plugin": "7.3.1",
-    "eslint-plugin-jsdoc": "63.0.0",
-    "eslint-plugin-jsonc": "3.1.0",
-    "eslint-plugin-n": "18.0.0",
+    "eslint-plugin-eslint-plugin": "7.4.0",
+    "eslint-plugin-jsdoc": "63.0.2",
+    "eslint-plugin-jsonc": "3.2.0",
+    "eslint-plugin-n": "18.1.0",
     "eslint-plugin-node-dependencies": "2.2.0",
     "eslint-plugin-perfectionist": "5.9.0",
     "eslint-plugin-regexp": "3.1.0",
-    "eslint-plugin-unicorn": "64.0.0",
-    "eslint-plugin-yml": "3.3.0",
+    "eslint-plugin-unicorn": "66.0.0",
+    "eslint-plugin-yml": "3.4.0",
     "jiti": "2.7.0",
     "json-schema-to-ts": "3.1.1",
-    "knip": "6.14.0",
-    "prettier": "3.8.0",
-    "prettier-plugin-curly": "0.4.0",
-    "prettier-plugin-packagejson": "3.0.0",
-    "prettier-plugin-sh": "0.18.0",
+    "knip": "6.16.0",
+    "prettier": "3.8.4",
+    "prettier-plugin-curly": "0.4.1",
+    "prettier-plugin-packagejson": "3.0.2",
+    "prettier-plugin-sh": "0.18.1",
     "pretty-quick": "4.2.2",
-    "sharp": "0.34.5",
+    "sharp": "0.35.0",
     "simple-git-hooks": "2.13.1",
     "starlight-auto-sidebar": "0.4.0",
-    "tsdown": "0.22.0",
-    "typescript": "6.0.2",
-    "typescript-eslint": "8.60.0",
-    "vitest": "4.1.0"
+    "tsdown": "0.22.2",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.61.0",
+    "vitest": "4.1.8"
   },
   "peerDependencies": {
     "@eslint/json": ">=1.0.0",
@@ -117,10 +119,10 @@
     "lint": "eslint . --max-warnings 0",
     "lint:knip": "knip",
     "site:build": "astro build",
+    "site:check": "astro check --root site",
     "site:dev": "astro dev",
     "site:preview": "astro preview",
     "site:sync": "astro sync",
-    "site:typecheck": "pnpm site:sync && tsc --project site/tsconfig.json",
     "test": "vitest",
     "typecheck": "tsc"
   }