eslint-plugin-package-json 0.52.0 → 0.53.0

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

@@ -1,205 +1,153 @@
-import semver from "semver";
 import { createRule } from "../createRule.js";
 import { isJSONStringLiteral } from "../utils/predicates.js";
+import semver from "semver";
+
+//#region src/rules/restrict-dependency-ranges.ts
 const DEPENDENCY_TYPES = [
-  "dependencies",
-  "devDependencies",
-  "optionalDependencies",
-  "peerDependencies"
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies",
+	"peerDependencies"
+];
+const RANGE_TYPES = [
+	"caret",
+	"pin",
+	"tilde"
 ];
-const RANGE_TYPES = ["caret", "pin", "tilde"];
 const schemaOptions = {
-  additionalProperties: false,
-  properties: {
-    forDependencyTypes: {
-      items: {
-        enum: DEPENDENCY_TYPES
-      },
-      type: "array"
-    },
-    forPackages: {
-      items: {
-        type: "string"
-      },
-      type: "array"
-    },
-    forVersions: {
-      type: "string"
-    },
-    rangeType: {
-      oneOf: [
-        {
-          enum: RANGE_TYPES
-        },
-        {
-          items: {
-            enum: RANGE_TYPES
-          },
-          type: "array"
-        }
-      ]
-    }
-  },
-  required: ["rangeType"],
-  type: "object"
+	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: "~"
+	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:*";
-      case "tilde":
-      default:
-        return "workspace:~";
-    }
-  }
-  return version.replace(
-    /^(workspace:)?(\^|~|<=?|>=?)?/,
-    `$1${SYMBOLS[rangeType]}`
-  );
+	if (/^workspace:[~^*]$/.test(version)) switch (rangeType) {
+		case "caret": return "workspace:^";
+		case "pin": return "workspace:*";
+		case "tilde":
+		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);
+	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);
+	return str.charAt(0).toUpperCase() + str.slice(1);
 };
 const rule = createRule({
-  create(context) {
-    if (!context.options[0]) {
-      return {};
-    }
-    const optionsProvided = Array.isArray(context.options[0]) ? [...context.options[0]].reverse() : [context.options[0]];
-    const optionsArray = optionsProvided.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) {
-              const isMatch = options.forPackages.some(
-                (packageNameRegex) => packageNameRegex.test(name)
-              );
-              if (!isMatch) {
-                continue;
-              }
-            }
-            if (options.forVersions && // We can't determine whether any workspace version without a numeric version to accompany it, matches this range
-            // so we'll just skip it.
-            (/^workspace:[^~*]?$/.test(version) || // * matches all
-            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;
-            }
-            const rangeTypeMatch = rangeTypes.find((rangeType) => {
-              switch (rangeType) {
-                case "caret":
-                  return isCaretRange;
-                case "pin":
-                  return isPinned;
-                case "tilde":
-                  return isTildeRange;
-              }
-            });
-            if (!rangeTypeMatch) {
-              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: {
-    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,
-          {
-            items: schemaOptions,
-            type: "array"
-          }
-        ]
-      }
-    ],
-    type: "suggestion"
-  }
+	create(context) {
+		if (!context.options[0]) return {};
+		const optionsProvided = Array.isArray(context.options[0]) ? [...context.options[0]].reverse() : [context.options[0]];
+		const optionsArray = optionsProvided.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) {
+						const isMatch = options.forPackages.some((packageNameRegex) => packageNameRegex.test(name));
+						if (!isMatch) 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;
+					}
+					const rangeTypeMatch = rangeTypes.find((rangeType) => {
+						switch (rangeType) {
+							case "caret": return isCaretRange;
+							case "pin": return isPinned;
+							case "tilde": return isTildeRange;
+						}
+					});
+					if (!rangeTypeMatch) 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"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

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

@@ -1,12 +1,7 @@
-import * as eslint from 'eslint';
-import * as jsonc_eslint_parser from 'jsonc-eslint-parser';
-import { PackageJsonRuleContext } from '../createRule.js';
-import 'estree';
+import { PackageJsonRuleModule } from "../createRule.js";
 
+//#region src/rules/sort-collections.d.ts
 type Options = string[];
-declare const rule: {
-    create(context: PackageJsonRuleContext<Options>): jsonc_eslint_parser.RuleListener;
-    meta: eslint.Rule.RuleMetaData;
-};
-
-export { rule };
+declare const rule: PackageJsonRuleModule<Options>;
+//#endregion
+export { rule };

package/lib/rules/sort-collections.js

@@ -1,128 +1,75 @@
 import { createRule } from "../createRule.js";
-const defaultCollections = /* @__PURE__ */ new Set([
-  "config",
-  "dependencies",
-  "devDependencies",
-  "exports",
-  "optionalDependencies",
-  "overrides",
-  "peerDependencies",
-  "peerDependenciesMeta",
-  "scripts"
+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 = context.options[0] ? new Set(context.options[0]) : defaultCollections;
-    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;
-          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-          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 currentOrder = collection.properties;
-        const properties = new Set(
-          currentOrder.map(
-            (prop) => prop.key.value
-          )
-        );
-        const desiredOrder = currentOrder.slice().sort((a, b) => {
-          let aKey = a.key.value;
-          let bKey = b.key.value;
-          if (keyPartsReversed.at(-1) !== "scripts") {
-            return aKey > bKey ? 1 : -1;
-          } else {
-            let modifier = 0;
-            if (aKey.startsWith("pre") && properties.has(aKey.substring(3))) {
-              aKey = aKey.substring(3);
-              modifier -= 1;
-            } else if (aKey.startsWith("post") && properties.has(aKey.substring(4))) {
-              aKey = aKey.substring(4);
-              modifier += 1;
-            }
-            if (bKey.startsWith("pre") && properties.has(bKey.substring(3))) {
-              bKey = bKey.substring(3);
-              modifier += 1;
-            } else if (bKey.startsWith("post") && properties.has(bKey.substring(4))) {
-              bKey = bKey.substring(4);
-              modifier -= 1;
-            }
-            if (aKey === bKey) {
-              return modifier;
-            }
-            return aKey > bKey ? 1 : -1;
-          }
-        });
-        if (currentOrder.some(
-          (property, i) => desiredOrder[i] !== property
-        )) {
-          context.report({
-            data: {
-              key
-            },
-            fix(fixer) {
-              return fixer.replaceText(
-                collection,
-                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  ")
-                // nest indents
-              );
-            },
-            loc: collection.loc,
-            messageId: "notAlphabetized",
-            node
-          });
-        }
-      }
-    };
-  },
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Dependencies, scripts, and configuration values must be declared in alphabetical order.",
-      recommended: true
-    },
-    fixable: "code",
-    messages: {
-      notAlphabetized: "Package {{ key }} are not alphabetized"
-    },
-    schema: [
-      {
-        items: {
-          type: "string"
-        },
-        type: "array"
-      }
-    ],
-    type: "layout"
-  }
+	create(context) {
+		const toSort = context.options[0] ? new Set(context.options[0]) : defaultCollections;
+		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(".");
+			if (!toSort.has(key)) return;
+			const currentOrder = collection.properties;
+			let desiredOrder;
+			if (keyPartsReversed.at(-1) !== "scripts") desiredOrder = currentOrder.slice().sort((a, b) => {
+				const aKey = a.key.value;
+				const bKey = b.key.value;
+				return aKey > bKey ? 1 : -1;
+			});
+			else {
+				const scriptsSource = context.sourceCode.getText(node);
+				const minimalJson = JSON.parse(`{${scriptsSource}}`);
+				const { scripts: sortedScripts } = sortPackageJson(minimalJson);
+				const propertyNodeMap = Object.fromEntries(collection.properties.map((prop) => [prop.key.value, prop]));
+				desiredOrder = Object.keys(sortedScripts).map((prop) => propertyNodeMap[prop]);
+			}
+			if (currentOrder.some((property, i) => desiredOrder[i] !== property)) context.report({
+				data: { key },
+				fix(fixer) {
+					return fixer.replaceText(collection, 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  "));
+				},
+				loc: collection.loc,
+				messageId: "notAlphabetized",
+				node
+			});
+		} };
+	},
+	meta: {
+		defaultOptions: [Array.from(defaultCollections)],
+		docs: {
+			category: "Best Practices",
+			description: "Dependencies, scripts, and configuration values must be declared in alphabetical order.",
+			recommended: true
+		},
+		fixable: "code",
+		messages: { notAlphabetized: "Package {{ key }} are not alphabetized" },
+		schema: [{
+			description: "Array of package properties to require sorting.",
+			items: { type: "string" },
+			type: "array"
+		}],
+		type: "layout"
+	},
+	name: "sort-collections"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

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

@@ -1,11 +1,6 @@
-import * as eslint from 'eslint';
-import * as jsonc_eslint_parser from 'jsonc-eslint-parser';
-import { PackageJsonRuleContext } from '../createRule.js';
-import 'estree';
+import { PackageJsonRuleModule } from "../createRule.js";
 
-declare const rule: {
-    create(context: PackageJsonRuleContext<unknown[]>): jsonc_eslint_parser.RuleListener;
-    meta: eslint.Rule.RuleMetaData;
-};
-
-export { rule };
+//#region src/rules/unique-dependencies.d.ts
+declare const rule: PackageJsonRuleModule<unknown[]>;
+//#endregion
+export { rule };