eslint-plugin-package-json 0.52.0 → 0.53.0

package/lib/rules/order-properties.js

@@ -1,124 +1,100 @@
+import { createRule } from "../createRule.js";
 import detectIndent from "detect-indent";
 import { detectNewlineGraceful } from "detect-newline";
 import sortObjectKeys from "sort-object-keys";
 import { sortOrder } from "sort-package-json";
-import { createRule } from "../createRule.js";
+
+//#region src/rules/order-properties.ts
 const standardOrderLegacy = [
-  "name",
-  "version",
-  "private",
-  "publishConfig",
-  "description",
-  "main",
-  "exports",
-  "browser",
-  "files",
-  "bin",
-  "directories",
-  "man",
-  "scripts",
-  "repository",
-  "keywords",
-  "author",
-  "license",
-  "bugs",
-  "homepage",
-  "config",
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-  "bundledDependencies",
-  "engines",
-  "os",
-  "cpu"
+	"name",
+	"version",
+	"private",
+	"publishConfig",
+	"description",
+	"main",
+	"exports",
+	"browser",
+	"files",
+	"bin",
+	"directories",
+	"man",
+	"scripts",
+	"repository",
+	"keywords",
+	"author",
+	"license",
+	"bugs",
+	"homepage",
+	"config",
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies",
+	"bundledDependencies",
+	"engines",
+	"os",
+	"cpu"
 ];
 const rule = createRule({
-  create(context) {
-    return {
-      "Program:exit"() {
-        const { ast, text } = context.sourceCode;
-        const options = {
-          order: "sort-package-json",
-          ...context.options[0]
-        };
-        const requiredOrder = options.order === "legacy" ? standardOrderLegacy : options.order === "sort-package-json" ? sortOrder : options.order;
-        const json = JSON.parse(text);
-        const orderedSource = sortObjectKeys(json, [
-          ...requiredOrder,
-          ...Object.keys(json)
-        ]);
-        const orderedKeys = Object.keys(orderedSource);
-        const { properties } = ast.body[0].expression;
-        for (let i = 0; i < properties.length; i += 1) {
-          const property = properties[i].key;
-          const { value } = property;
-          if (value === orderedKeys[i]) {
-            continue;
-          }
-          context.report({
-            data: {
-              property: value
-            },
-            fix(fixer) {
-              const { indent, type } = detectIndent(text);
-              const endCharacters = text.endsWith("\n") ? "\n" : "";
-              const newline = detectNewlineGraceful(text);
-              let result = JSON.stringify(
-                orderedSource,
-                null,
-                type === "tab" ? "	" : indent
-              ) + endCharacters;
-              if (newline === "\r\n") {
-                result = result.replace(/\n/g, newline);
-              }
-              return fixer.replaceText(
-                context.sourceCode.ast,
-                result
-              );
-            },
-            loc: properties[i].loc,
-            messageId: "incorrectOrder"
-          });
-        }
-      }
-    };
-  },
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Package properties must be declared in standard order",
-      recommended: true
-    },
-    fixable: "code",
-    messages: {
-      incorrectOrder: 'Package top-level property "{{property}}" is not ordered in the npm standard way. Run the ESLint auto-fixer to correct.'
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          order: {
-            anyOf: [
-              {
-                enum: ["legacy", "sort-package-json"],
-                type: ["string"]
-              },
-              {
-                items: {
-                  type: ["string"]
-                },
-                type: ["array"]
-              }
-            ]
-          }
-        },
-        type: "object"
-      }
-    ],
-    type: "layout"
-  }
+	create(context) {
+		return { "Program:exit"() {
+			const { ast, text } = context.sourceCode;
+			const options = {
+				order: "sort-package-json",
+				...context.options[0]
+			};
+			const requiredOrder = options.order === "legacy" ? standardOrderLegacy : options.order === "sort-package-json" ? sortOrder : options.order;
+			const json = JSON.parse(text);
+			const orderedSource = sortObjectKeys(json, [...requiredOrder, ...Object.keys(json)]);
+			const orderedKeys = Object.keys(orderedSource);
+			const { properties } = ast.body[0].expression;
+			for (let i = 0; i < properties.length; i += 1) {
+				const property = properties[i].key;
+				const { value } = property;
+				if (value === orderedKeys[i]) continue;
+				context.report({
+					data: { property: value },
+					fix(fixer) {
+						const { indent, type } = detectIndent(text);
+						const endCharacters = text.endsWith("\n") ? "\n" : "";
+						const newline = detectNewlineGraceful(text);
+						let result = JSON.stringify(orderedSource, null, type === "tab" ? "	" : indent) + endCharacters;
+						if (newline === "\r\n") result = result.replace(/\n/g, newline);
+						return fixer.replaceText(context.sourceCode.ast, result);
+					},
+					loc: properties[i].loc,
+					messageId: "incorrectOrder"
+				});
+			}
+		} };
+	},
+	meta: {
+		defaultOptions: [{ order: "sort-package-json" }],
+		docs: {
+			category: "Best Practices",
+			description: "Package properties must be declared in standard order",
+			recommended: true
+		},
+		fixable: "code",
+		messages: { incorrectOrder: "Package top-level property \"{{property}}\" is not ordered in the npm standard way. Run the ESLint auto-fixer to correct." },
+		schema: [{
+			additionalProperties: false,
+			properties: { order: {
+				anyOf: [{
+					enum: ["legacy", "sort-package-json"],
+					type: ["string"]
+				}, {
+					items: { type: ["string"] },
+					type: ["array"]
+				}],
+				description: "Specifies the sorting order of top-level properties."
+			} },
+			type: "object"
+		}],
+		type: "layout"
+	},
+	name: "order-properties"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

package/lib/rules/repository-shorthand.d.ts

@@ -1,15 +1,10 @@
-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/repository-shorthand.d.ts
 type Form = "object" | "shorthand";
 type Options = [{
-    form: Form;
+  form: Form;
 }?];
-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/repository-shorthand.js

@@ -1,119 +1,86 @@
 import { createRule } from "../createRule.js";
-import { findPropertyWithKeyValue } from "../utils/findPropertyWithKeyValue.js";
 import { isJSONStringLiteral } from "../utils/predicates.js";
+import { findPropertyWithKeyValue } from "../utils/findPropertyWithKeyValue.js";
+
+//#region src/rules/repository-shorthand.ts
 const githubUrlRegex = /^(?:git\+)?(?:ssh:\/\/git@|http?s:\/\/)?(?:www\.)?github\.com\//;
 const isGitHubUrl = (url) => githubUrlRegex.test(url);
 const cleanGitHubUrl = (url) => url.replace(githubUrlRegex, "").replace(/\.git$/, "");
 const rule = createRule({
-  create(context) {
-    const [{ form = "object" } = {}] = context.options;
-    function validateRepositoryForObject(node) {
-      if (isJSONStringLiteral(node.value)) {
-        context.report({
-          fix(fixer) {
-            if (!isJSONStringLiteral(node.value) || node.value.value.split("/").filter(Boolean).length !== 2) {
-              return null;
-            }
-            return fixer.replaceText(
-              node.value,
-              JSON.stringify(
-                {
-                  type: "git",
-                  url: `https://github.com/${node.value.value}`
-                },
-                null,
-                2
-              )
-            );
-          },
-          messageId: "preferObject",
-          node: node.value
-        });
-      }
-    }
-    function validateRepositoryForShorthand(node) {
-      if (isJSONStringLiteral(node.value)) {
-        const { value } = node.value;
-        if (typeof value === "string" && isGitHubUrl(value)) {
-          context.report({
-            fix(fixer) {
-              return fixer.replaceText(
-                node.value,
-                JSON.stringify(cleanGitHubUrl(value))
-              );
-            },
-            messageId: "preferShorthand",
-            node: node.value
-          });
-        }
-        return;
-      }
-      if (node.value.type !== "JSONObjectExpression") {
-        return;
-      }
-      const { properties } = node.value;
-      if (findPropertyWithKeyValue(properties, "directory")) {
-        return;
-      }
-      const typeProperty = findPropertyWithKeyValue(properties, "type");
-      if (typeProperty?.value.type !== "JSONLiteral" || typeProperty.value.value !== "git") {
-        return;
-      }
-      const urlProperty = findPropertyWithKeyValue(properties, "url");
-      if (urlProperty?.value.type !== "JSONLiteral" || typeof urlProperty.value.value !== "string" || !isGitHubUrl(urlProperty.value.value)) {
-        return;
-      }
-      const url = urlProperty.value.value;
-      context.report({
-        fix(fixer) {
-          return fixer.replaceText(
-            node.value,
-            JSON.stringify(cleanGitHubUrl(url))
-          );
-        },
-        messageId: "preferShorthand",
-        node: node.value
-      });
-    }
-    return {
-      JSONProperty(node) {
-        if (node.key.type !== "JSONLiteral" || node.key.value !== "repository" || node.parent.parent.parent.type !== "Program") {
-          return;
-        }
-        if (form === "shorthand") {
-          validateRepositoryForShorthand(node);
-        } else {
-          validateRepositoryForObject(node);
-        }
-      }
-    };
-  },
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Enforce either object or shorthand declaration for repository.",
-      recommended: true
-    },
-    fixable: "code",
-    messages: {
-      preferObject: "Prefer an object locator for a repository.",
-      preferShorthand: "Prefer a shorthand locator for a GitHub repository."
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          form: {
-            enum: ["object", "shorthand"],
-            type: ["string"]
-          }
-        },
-        type: "object"
-      }
-    ],
-    type: "suggestion"
-  }
+	create(context) {
+		const [{ form = "object" } = {}] = context.options;
+		function validateRepositoryForObject(node) {
+			if (isJSONStringLiteral(node.value)) context.report({
+				fix(fixer) {
+					if (!isJSONStringLiteral(node.value) || node.value.value.split("/").filter(Boolean).length !== 2) return null;
+					return fixer.replaceText(node.value, JSON.stringify({
+						type: "git",
+						url: `https://github.com/${node.value.value}`
+					}, null, 2));
+				},
+				messageId: "preferObject",
+				node: node.value
+			});
+		}
+		function validateRepositoryForShorthand(node) {
+			if (isJSONStringLiteral(node.value)) {
+				const { value } = node.value;
+				if (typeof value === "string" && isGitHubUrl(value)) context.report({
+					fix(fixer) {
+						return fixer.replaceText(node.value, JSON.stringify(cleanGitHubUrl(value)));
+					},
+					messageId: "preferShorthand",
+					node: node.value
+				});
+				return;
+			}
+			if (node.value.type !== "JSONObjectExpression") return;
+			const { properties } = node.value;
+			if (findPropertyWithKeyValue(properties, "directory")) return;
+			const typeProperty = findPropertyWithKeyValue(properties, "type");
+			if (typeProperty?.value.type !== "JSONLiteral" || typeProperty.value.value !== "git") return;
+			const urlProperty = findPropertyWithKeyValue(properties, "url");
+			if (urlProperty?.value.type !== "JSONLiteral" || typeof urlProperty.value.value !== "string" || !isGitHubUrl(urlProperty.value.value)) return;
+			const url = urlProperty.value.value;
+			context.report({
+				fix(fixer) {
+					return fixer.replaceText(node.value, JSON.stringify(cleanGitHubUrl(url)));
+				},
+				messageId: "preferShorthand",
+				node: node.value
+			});
+		}
+		return { JSONProperty(node) {
+			if (node.key.type !== "JSONLiteral" || node.key.value !== "repository" || node.parent.parent.parent.type !== "Program") return;
+			if (form === "shorthand") validateRepositoryForShorthand(node);
+			else validateRepositoryForObject(node);
+		} };
+	},
+	meta: {
+		defaultOptions: [{ form: "object" }],
+		docs: {
+			category: "Best Practices",
+			description: "Enforce either object or shorthand declaration for repository.",
+			recommended: true
+		},
+		fixable: "code",
+		messages: {
+			preferObject: "Prefer an object locator for a repository.",
+			preferShorthand: "Prefer a shorthand locator for a GitHub repository."
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: { form: {
+				description: "Specifies which repository form to enforce.",
+				enum: ["object", "shorthand"],
+				type: ["string"]
+			} },
+			type: "object"
+		}],
+		type: "suggestion"
+	},
+	name: "repository-shorthand"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

package/lib/rules/require-properties.d.ts

@@ -1,15 +1,10 @@
-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/require-properties.d.ts
 declare const rules: {
-    [k: string]: {
-        create(context: PackageJsonRuleContext<[({
-            ignorePrivate?: boolean;
-        } | undefined)?]>): jsonc_eslint_parser.RuleListener;
-        meta: eslint.Rule.RuleMetaData;
-    };
+  [k: string]: PackageJsonRuleModule<[({
+    ignorePrivate?: boolean;
+  } | undefined)?]>;
 };
-
-export { rules };
+//#endregion
+export { rules };

package/lib/rules/require-properties.js

@@ -1,29 +1,33 @@
-import {
-  createSimpleRequirePropertyRule
-} from "../utils/createSimpleRequirePropertyRule.js";
+import { createSimpleRequirePropertyRule } from "../utils/createSimpleRequirePropertyRule.js";
+
+//#region src/rules/require-properties.ts
 const properties = [
-  ["author"],
-  ["bugs"],
-  ["bundleDependencies"],
-  ["dependencies"],
-  ["description", { isRecommended: true }],
-  ["devDependencies"],
-  ["engines"],
-  ["files"],
-  ["keywords"],
-  ["name", { ignorePrivateDefault: true, isRecommended: true }],
-  ["optionalDependencies"],
-  ["peerDependencies"],
-  ["type", { isRecommended: true }],
-  ["types"],
-  ["version", { ignorePrivateDefault: true, isRecommended: true }]
+	["author"],
+	["bugs"],
+	["bundleDependencies"],
+	["dependencies"],
+	["description", { isRecommended: true }],
+	["devDependencies"],
+	["engines"],
+	["files"],
+	["keywords"],
+	["name", {
+		ignorePrivateDefault: true,
+		isRecommended: true
+	}],
+	["optionalDependencies"],
+	["peerDependencies"],
+	["type", { isRecommended: true }],
+	["types"],
+	["version", {
+		ignorePrivateDefault: true,
+		isRecommended: true
+	}]
 ];
-const rules = Object.fromEntries(
-  properties.map(([propertyName, options]) => [
-    `require-${propertyName}`,
-    createSimpleRequirePropertyRule(propertyName, options)
-  ])
-);
-export {
-  rules
-};
+const rules = Object.fromEntries(properties.map(([propertyName, options]) => {
+	const { rule, ruleName } = createSimpleRequirePropertyRule(propertyName, options);
+	return [ruleName, rule];
+}));
+
+//#endregion
+export { rules };

package/lib/rules/restrict-dependency-ranges.d.ts

@@ -1,20 +1,15 @@
-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/restrict-dependency-ranges.d.ts
 interface Option {
-    forDependencyTypes?: string[];
-    forPackages?: string[];
-    forVersions?: string;
-    rangeType: RangeType | RangeType[];
+  forDependencyTypes?: string[];
+  forPackages?: string[];
+  forVersions?: string;
+  rangeType: RangeType | RangeType[];
 }
 type Options = [Option | Option[] | undefined];
 declare const RANGE_TYPES: readonly ["caret", "pin", "tilde"];
 type RangeType = (typeof RANGE_TYPES)[number];
-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 };