eslint-plugin-package-json 0.52.0 → 0.53.0

package/lib/rules/unique-dependencies.js

@@ -1,87 +1,63 @@
-import {
-  fixRemoveArrayElement,
-  fixRemoveObjectProperty
-} from "eslint-fix-utils";
 import { createRule } from "../createRule.js";
 import { isJSONStringLiteral, isNotNullish } from "../utils/predicates.js";
-const dependencyPropertyNames = /* @__PURE__ */ new Set([
-  "bundledDependencies",
-  "bundleDependencies",
-  "dependencies",
-  "devDependencies",
-  "optionalDependencies",
-  "overrides",
-  "peerDependencies"
+import { fixRemoveArrayElement, fixRemoveObjectProperty } from "eslint-fix-utils";
+
+//#region src/rules/unique-dependencies.ts
+const dependencyPropertyNames = new Set([
+	"bundledDependencies",
+	"bundleDependencies",
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies",
+	"overrides",
+	"peerDependencies"
 ]);
 const rule = createRule({
-  create(context) {
-    function check(elements, getNodeToRemove) {
-      const seen = /* @__PURE__ */ new Set();
-      for (const element of elements.filter(isNotNullish).filter(isJSONStringLiteral).reverse()) {
-        if (seen.has(element.value)) {
-          report(element, elements);
-        } else {
-          seen.add(element.value);
-        }
-      }
-      function report(node, elements2) {
-        const removal = getNodeToRemove(node);
-        context.report({
-          messageId: "overridden",
-          node,
-          suggest: [
-            {
-              fix: removal.type === "JSONProperty" ? fixRemoveObjectProperty(
-                context,
-                removal
-              ) : fixRemoveArrayElement(
-                context,
-                removal,
-                elements2
-              ),
-              messageId: "remove"
-            }
-          ]
-        });
-      }
-    }
-    return {
-      "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.type=JSONLiteral]"(node) {
-        if (!dependencyPropertyNames.has(node.key.value)) {
-          return;
-        }
-        switch (node.value.type) {
-          case "JSONArrayExpression":
-            check(node.value.elements, (element) => element);
-            break;
-          case "JSONObjectExpression":
-            check(
-              node.value.properties.map(
-                (property) => property.key
-              ),
-              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-              (property) => property.parent
-            );
-            break;
-        }
-      }
-    };
-  },
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Checks a dependency isn't specified more than once (i.e. in `dependencies` and `devDependencies`)",
-      recommended: true
-    },
-    hasSuggestions: true,
-    messages: {
-      overridden: "Package name is overridden by a duplicate listing later on.",
-      remove: "Remove this redundant dependency listing."
-    },
-    schema: [],
-    type: "suggestion"
-  }
+	create(context) {
+		function check(elements, getNodeToRemove) {
+			const seen = /* @__PURE__ */ new Set();
+			for (const element of elements.filter(isNotNullish).filter(isJSONStringLiteral).reverse()) if (seen.has(element.value)) report(element, elements);
+			else seen.add(element.value);
+			function report(node, elements$1) {
+				const removal = getNodeToRemove(node);
+				context.report({
+					messageId: "overridden",
+					node,
+					suggest: [{
+						fix: removal.type === "JSONProperty" ? fixRemoveObjectProperty(context, removal) : fixRemoveArrayElement(context, removal, elements$1),
+						messageId: "remove"
+					}]
+				});
+			}
+		}
+		return { "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.type=JSONLiteral]"(node) {
+			if (!dependencyPropertyNames.has(node.key.value)) return;
+			switch (node.value.type) {
+				case "JSONArrayExpression":
+					check(node.value.elements, (element) => element);
+					break;
+				case "JSONObjectExpression":
+					check(node.value.properties.map((property) => property.key), (property) => property.parent);
+					break;
+			}
+		} };
+	},
+	meta: {
+		docs: {
+			category: "Best Practices",
+			description: "Checks a dependency isn't specified more than once (i.e. in `dependencies` and `devDependencies`)",
+			recommended: true
+		},
+		hasSuggestions: true,
+		messages: {
+			overridden: "Package name is overridden by a duplicate listing later on.",
+			remove: "Remove this redundant dependency listing."
+		},
+		schema: [],
+		type: "suggestion"
+	},
+	name: "unique-dependencies"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

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

@@ -1,14 +1,9 @@
-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/valid-bin.d.ts
 type Options = [{
-    enforceCase: boolean;
+  enforceCase: boolean;
 }?];
-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/valid-bin.js

@@ -1,82 +1,63 @@
-import { kebabCase } from "change-case";
-import { validateBin } from "package-json-validator";
 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 binValue = JSON.parse(
-          context.sourceCode.getText(binValueNode)
-        );
-        const errors = validateBin(binValue);
-        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: {
-    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: {
-            default: false,
-            type: "boolean"
-          }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem"
-  }
+	create(context) {
+		const shouldEnforceCase = !!context.options[0]?.enforceCase;
+		return { "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=bin]"(node) {
+			const binValueNode = node.value;
+			const binValue = JSON.parse(context.sourceCode.getText(binValueNode));
+			const errors = validateBin(binValue);
+			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"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

package/lib/rules/valid-local-dependency.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/valid-local-dependency.d.ts
+declare const rule: PackageJsonRuleModule<unknown[]>;
+//#endregion
+export { rule };

package/lib/rules/valid-local-dependency.js

@@ -1,62 +1,54 @@
-import path from "path";
 import { createRule } from "../createRule.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+//#region src/rules/valid-local-dependency.ts
+const require = createRequire(import.meta.url);
 const fileRegex = /^file:/;
 const linkRegex = /^link:/;
 const rule = createRule({
-  create(context) {
-    return {
-      "Program:exit"() {
-        const original = JSON.parse(context.sourceCode.text);
-        const { dependencies, devDependencies, peerDependencies } = original;
-        const depObjs = [
-          Object.entries(dependencies ?? {}),
-          Object.entries(peerDependencies ?? {}),
-          Object.entries(devDependencies ?? {})
-        ];
-        for (const obj of depObjs) {
-          for (const [key, value] of obj) {
-            const response = (pathToken) => {
-              const filePath = path.join(
-                context.filename.replace("package.json", ""),
-                value.replace(pathToken, "")
-              );
-              try {
-                require.resolve(filePath);
-              } catch {
-                context.report({
-                  data: {
-                    package: key,
-                    path: value
-                  },
-                  messageId: "invalidPath",
-                  node: context.sourceCode.ast
-                });
-              }
-            };
-            if (value.startsWith("link:")) {
-              response(linkRegex);
-            }
-            if (value.startsWith("file:")) {
-              response(fileRegex);
-            }
-          }
-        }
-      }
-    };
-  },
-  meta: {
-    deprecated: true,
-    docs: {
-      category: "Best Practices",
-      description: "Checks existence of local dependencies in the package.json"
-    },
-    messages: {
-      invalidPath: "The package {{package}} does not exist given the specified path: {{path}}."
-    },
-    schema: [],
-    type: "problem"
-  }
+	create(context) {
+		return { "Program:exit"() {
+			const original = JSON.parse(context.sourceCode.text);
+			const { dependencies, devDependencies, peerDependencies } = original;
+			const depObjs = [
+				Object.entries(dependencies ?? {}),
+				Object.entries(peerDependencies ?? {}),
+				Object.entries(devDependencies ?? {})
+			];
+			for (const obj of depObjs) for (const [key, value] of obj) {
+				const response = (pathToken) => {
+					const filePath = path.join(context.filename.replace("package.json", ""), value.replace(pathToken, ""));
+					try {
+						require.resolve(filePath);
+					} catch {
+						context.report({
+							data: {
+								package: key,
+								path: value
+							},
+							messageId: "invalidPath",
+							node: context.sourceCode.ast
+						});
+					}
+				};
+				if (value.startsWith("link:")) response(linkRegex);
+				if (value.startsWith("file:")) response(fileRegex);
+			}
+		} };
+	},
+	meta: {
+		deprecated: true,
+		docs: {
+			category: "Best Practices",
+			description: "Checks existence of local dependencies in the package.json"
+		},
+		messages: { invalidPath: "The package {{package}} does not exist given the specified path: {{path}}." },
+		schema: [],
+		type: "problem"
+	},
+	name: "valid-local-dependency"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

package/lib/rules/valid-name.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/valid-name.d.ts
+declare const rule: PackageJsonRuleModule<unknown[]>;
+//#endregion
+export { rule };

package/lib/rules/valid-name.js

@@ -1,51 +1,44 @@
-import validate from "validate-npm-package-name";
 import { createRule } from "../createRule.js";
+import validate from "validate-npm-package-name";
+
+//#region src/rules/valid-name.ts
 const rule = createRule({
-  create(context) {
-    return {
-      "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=name]"(node) {
-        if (node.value.type !== "JSONLiteral" || typeof node.value.value !== "string") {
-          context.report({
-            messageId: "type",
-            node: node.value
-          });
-          return;
-        }
-        const privateField = node.parent.properties.find(
-          (p) => p.key.type === "JSONLiteral" && p.key.value === "private"
-        );
-        if (privateField && privateField.value.type === "JSONLiteral" && (privateField.value.value === true || privateField.value.value === "true")) {
-          return;
-        }
-        const { errors, warnings } = validate(node.value.value);
-        const complaints = [...errors ?? [], ...warnings ?? []];
-        if (!complaints.length) {
-          return;
-        }
-        context.report({
-          data: {
-            complaints: complaints.map((error) => error.substring(0, error.length)).join("; ")
-          },
-          messageId: "invalid",
-          node: node.value
-        });
-      }
-    };
-  },
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Enforce that package names are valid npm package names",
-      recommended: true
-    },
-    messages: {
-      invalid: "Invalid npm package name: {{ complaints }}.",
-      type: '"name" should be a string.'
-    },
-    schema: [],
-    type: "problem"
-  }
+	create(context) {
+		return { "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=name]"(node) {
+			if (node.value.type !== "JSONLiteral" || typeof node.value.value !== "string") {
+				context.report({
+					messageId: "type",
+					node: node.value
+				});
+				return;
+			}
+			const privateField = node.parent.properties.find((p) => p.key.type === "JSONLiteral" && p.key.value === "private");
+			if (privateField && privateField.value.type === "JSONLiteral" && (privateField.value.value === true || privateField.value.value === "true")) return;
+			const { errors, warnings } = validate(node.value.value);
+			const complaints = [...errors ?? [], ...warnings ?? []];
+			if (!complaints.length) return;
+			context.report({
+				data: { complaints: complaints.map((error) => error.substring(0, error.length)).join("; ") },
+				messageId: "invalid",
+				node: node.value
+			});
+		} };
+	},
+	meta: {
+		docs: {
+			category: "Best Practices",
+			description: "Enforce that package names are valid npm package names",
+			recommended: true
+		},
+		messages: {
+			invalid: "Invalid npm package name: {{ complaints }}.",
+			type: "\"name\" should be a string."
+		},
+		schema: [],
+		type: "problem"
+	},
+	name: "valid-name"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

package/lib/rules/valid-package-definition.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/valid-package-definition.d.ts
 interface Option {
-    ignoreProperties?: string[];
+  ignoreProperties?: string[];
 }
 type Options = [Option?];
-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 };