eslint-plugin-package-json 0.52.0 → 0.53.0

package/lib/rules/no-empty-fields.js

@@ -1,123 +1,91 @@
-import {
-  fixRemoveArrayElement,
-  fixRemoveObjectProperty
-} from "eslint-fix-utils";
 import { createRule } from "../createRule.js";
+import { fixRemoveArrayElement, fixRemoveObjectProperty } from "eslint-fix-utils";
+
+//#region src/rules/no-empty-fields.ts
 const getDataAndMessageId = (node) => {
-  switch (node.type) {
-    case "JSONArrayExpression":
-      return {
-        data: {
-          expressionType: "array"
-        },
-        messageId: "emptyExpression"
-      };
-    case "JSONObjectExpression":
-      return {
-        data: {
-          expressionType: "object"
-        },
-        messageId: "emptyExpression"
-      };
-    case "JSONProperty":
-      return {
-        data: {
-          field: node.key.value
-        },
-        messageId: "emptyFields"
-      };
-  }
+	switch (node.type) {
+		case "JSONArrayExpression": return {
+			data: { expressionType: "array" },
+			messageId: "emptyExpression"
+		};
+		case "JSONObjectExpression": return {
+			data: { expressionType: "object" },
+			messageId: "emptyExpression"
+		};
+		case "JSONProperty": return {
+			data: { field: node.key.value },
+			messageId: "emptyFields"
+		};
+	}
 };
 const report = (context, node) => {
-  const { data, messageId } = getDataAndMessageId(node);
-  context.report({
-    data,
-    messageId,
-    node,
-    suggest: [
-      {
-        fix: node.type === "JSONProperty" ? fixRemoveObjectProperty(
-          context,
-          node
-        ) : fixRemoveArrayElement(
-          context,
-          node,
-          node.parent
-        ),
-        messageId: "remove"
-      }
-    ]
-  });
+	const { data, messageId } = getDataAndMessageId(node);
+	context.report({
+		data,
+		messageId,
+		node,
+		suggest: [{
+			fix: node.type === "JSONProperty" ? fixRemoveObjectProperty(context, node) : fixRemoveArrayElement(context, node, node.parent),
+			messageId: "remove"
+		}]
+	});
 };
 const getNode = (node) => {
-  return node.parent.type === "JSONProperty" ? node.parent : node;
+	return node.parent.type === "JSONProperty" ? node.parent : node;
 };
 const getTopLevelProperty = (node) => {
-  let n = node;
-  while (n.parent.parent?.parent?.type !== void 0 && n.parent.parent.parent.type !== "Program") {
-    n = n.parent;
-  }
-  return n.type === "JSONProperty" ? n.key : void 0;
+	let n = node;
+	while (n.parent.parent?.parent?.type !== void 0 && n.parent.parent.parent.type !== "Program") n = n.parent;
+	return n.type === "JSONProperty" ? n.key : void 0;
 };
 const rule = createRule({
-  create(context) {
-    const ignoreProperties = context.options[0]?.ignoreProperties ?? [];
-    return {
-      JSONArrayExpression(node) {
-        const topLevelProperty = getTopLevelProperty(node);
-        if (!topLevelProperty) {
-          return;
-        }
-        if (!node.elements.length) {
-          const topLevelPropertyName = topLevelProperty.value;
-          if (!ignoreProperties.includes(topLevelPropertyName)) {
-            report(context, getNode(node));
-          }
-        }
-      },
-      JSONObjectExpression(node) {
-        const topLevelProperty = getTopLevelProperty(node);
-        if (!topLevelProperty) {
-          return;
-        }
-        if (!node.properties.length) {
-          const topLevelPropertyName = topLevelProperty.value;
-          if (!ignoreProperties.includes(topLevelPropertyName)) {
-            report(context, getNode(node));
-          }
-        }
-      }
-    };
-  },
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Reports on unnecessary empty arrays and objects.",
-      recommended: true
-    },
-    hasSuggestions: true,
-    messages: {
-      emptyExpression: "This {{expressionType}} does nothing and can be removed.",
-      emptyFields: "The field '{{field}}' does nothing and can be removed.",
-      remove: "Remove this empty field."
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          ignoreProperties: {
-            items: {
-              type: "string"
-            },
-            type: "array"
-          }
-        },
-        type: "object"
-      }
-    ],
-    type: "suggestion"
-  }
+	create(context) {
+		const ignoreProperties = context.options[0]?.ignoreProperties ?? [];
+		return {
+			JSONArrayExpression(node) {
+				const topLevelProperty = getTopLevelProperty(node);
+				if (!topLevelProperty) return;
+				if (!node.elements.length) {
+					const topLevelPropertyName = topLevelProperty.value;
+					if (!ignoreProperties.includes(topLevelPropertyName)) report(context, getNode(node));
+				}
+			},
+			JSONObjectExpression(node) {
+				const topLevelProperty = getTopLevelProperty(node);
+				if (!topLevelProperty) return;
+				if (!node.properties.length) {
+					const topLevelPropertyName = topLevelProperty.value;
+					if (!ignoreProperties.includes(topLevelPropertyName)) report(context, getNode(node));
+				}
+			}
+		};
+	},
+	meta: {
+		defaultOptions: [{ ignoreProperties: [] }],
+		docs: {
+			category: "Best Practices",
+			description: "Reports on unnecessary empty arrays and objects.",
+			recommended: true
+		},
+		hasSuggestions: true,
+		messages: {
+			emptyExpression: "This {{expressionType}} does nothing and can be removed.",
+			emptyFields: "The field '{{field}}' does nothing and can be removed.",
+			remove: "Remove this empty field."
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: { ignoreProperties: {
+				description: "Array of top-level properties to ignore.",
+				items: { type: "string" },
+				type: "array"
+			} },
+			type: "object"
+		}],
+		type: "suggestion"
+	},
+	name: "no-empty-fields"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

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

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

@@ -1,146 +1,103 @@
-import { fixRemoveArrayElement } from "eslint-fix-utils";
 import { createRule } from "../createRule.js";
 import { isJSONStringLiteral, isNotNullish } from "../utils/predicates.js";
+import { fixRemoveArrayElement } from "eslint-fix-utils";
+
+//#region src/rules/no-redundant-files.ts
 const defaultFiles = [
-  /* cspell:disable-next-line */
-  /^(\.\/)?LICEN(C|S)E(\.|$)/i,
-  /^(\.\/)?README(\.|$)/i,
-  /^(\.\/)?package\.json$/i
+	/^(\.\/)?LICEN(C|S)E(\.|$)/i,
+	/^(\.\/)?README(\.|$)/i,
+	/^(\.\/)?package\.json$/i
 ];
 const wildcardsRegex = /[*?[\]{}]/;
 const cachedRegex = /* @__PURE__ */ new Map();
 const getCachedLocalFileRegex = (filename) => {
-  if (wildcardsRegex.test(filename)) {
-    return null;
-  }
-  const baseFilename = filename.replace("./", "");
-  let regex = cachedRegex.get(baseFilename);
-  if (regex) {
-    return regex;
-  } else {
-    regex = new RegExp(`^(./)?${baseFilename}$`, "i");
-    cachedRegex.set(baseFilename, regex);
-    return regex;
-  }
+	if (wildcardsRegex.test(filename)) return null;
+	const baseFilename = filename.replace("./", "");
+	let regex = cachedRegex.get(baseFilename);
+	if (regex) return regex;
+	else {
+		regex = new RegExp(`^(./)?${baseFilename}$`, "i");
+		cachedRegex.set(baseFilename, regex);
+		return regex;
+	}
 };
 const rule = createRule({
-  create(context) {
-    const entryCache = { bin: [], files: [] };
-    const report = (elements, index, messageId) => {
-      const element = elements[index];
-      if (isNotNullish(element) && isJSONStringLiteral(element)) {
-        context.report({
-          data: { file: element.value },
-          messageId,
-          node: element,
-          suggest: [
-            {
-              fix: fixRemoveArrayElement(
-                context,
-                index,
-                elements
-              ),
-              messageId: "remove"
-            }
-          ]
-        });
-      }
-    };
-    return {
-      "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=bin]"(node) {
-        const binValue = node.value;
-        if (isJSONStringLiteral(binValue)) {
-          entryCache.bin.push(binValue.value);
-        } else if (binValue.type === "JSONObjectExpression") {
-          for (const prop of binValue.properties) {
-            if (isJSONStringLiteral(prop.value)) {
-              entryCache.bin.push(prop.value.value);
-            }
-          }
-        }
-      },
-      "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"
-                  );
-                }
-              }
-            }
-          }
-        }
-      },
-      "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=main]"(node) {
-        if (isJSONStringLiteral(node.value)) {
-          entryCache.main = node.value.value;
-        }
-      },
-      "Program:exit"() {
-        const files = entryCache.files;
-        if (files.length === 0) {
-          return;
-        }
-        const validations = [
-          // First check if the "main" entry is included in "files".
-          {
-            files: entryCache.main ? [entryCache.main] : [],
-            messageId: "unnecessaryMain"
-          },
-          // Next check if any "bin" entries are included in "files".
-          {
-            files: entryCache.bin,
-            messageId: "unnecessaryBin"
-          }
-        ];
-        for (const validation of validations) {
-          for (const fileToCheck of validation.files) {
-            for (const [index, fileEntry] of files.entries()) {
-              if (isNotNullish(fileEntry) && isJSONStringLiteral(fileEntry)) {
-                const regex = getCachedLocalFileRegex(
-                  fileEntry.value
-                );
-                if (regex?.test(fileToCheck)) {
-                  report(files, index, validation.messageId);
-                }
-              }
-            }
-          }
-        }
-      }
-    };
-  },
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Prevents adding unnecessary / redundant files.",
-      recommended: false
-    },
-    hasSuggestions: true,
-    messages: {
-      duplicate: 'Files has more than one entry for "{{file}}".',
-      remove: "Remove this redundant entry.",
-      unnecessaryBin: `Explicitly declaring "{{file}}" in "files" is unnecessary; it's included in "bin".`,
-      unnecessaryDefault: `Explicitly declaring "{{file}}" in "files" is unnecessary; it's included by default.`,
-      unnecessaryMain: `Explicitly declaring "{{file}}" in "files" is unnecessary; it's the "main" entry.`
-    },
-    schema: [],
-    type: "suggestion"
-  }
+	create(context) {
+		const entryCache = {
+			bin: [],
+			files: []
+		};
+		const report = (elements, index, messageId) => {
+			const element = elements[index];
+			if (isNotNullish(element) && isJSONStringLiteral(element)) context.report({
+				data: { file: element.value },
+				messageId,
+				node: element,
+				suggest: [{
+					fix: fixRemoveArrayElement(context, index, elements),
+					messageId: "remove"
+				}]
+			});
+		};
+		return {
+			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=bin]"(node) {
+				const binValue = node.value;
+				if (isJSONStringLiteral(binValue)) entryCache.bin.push(binValue.value);
+				else if (binValue.type === "JSONObjectExpression") {
+					for (const prop of binValue.properties) if (isJSONStringLiteral(prop.value)) entryCache.bin.push(prop.value.value);
+				}
+			},
+			"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");
+					}
+				}
+			},
+			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=main]"(node) {
+				if (isJSONStringLiteral(node.value)) entryCache.main = node.value.value;
+			},
+			"Program:exit"() {
+				const files = entryCache.files;
+				if (files.length === 0) return;
+				const validations = [{
+					files: entryCache.main ? [entryCache.main] : [],
+					messageId: "unnecessaryMain"
+				}, {
+					files: entryCache.bin,
+					messageId: "unnecessaryBin"
+				}];
+				for (const validation of validations) for (const fileToCheck of validation.files) for (const [index, fileEntry] of files.entries()) if (isNotNullish(fileEntry) && isJSONStringLiteral(fileEntry)) {
+					const regex = getCachedLocalFileRegex(fileEntry.value);
+					if (regex?.test(fileToCheck)) report(files, index, validation.messageId);
+				}
+			}
+		};
+	},
+	meta: {
+		docs: {
+			category: "Best Practices",
+			description: "Prevents adding unnecessary / redundant files.",
+			recommended: false
+		},
+		hasSuggestions: true,
+		messages: {
+			duplicate: "Files has more than one entry for \"{{file}}\".",
+			remove: "Remove this redundant entry.",
+			unnecessaryBin: `Explicitly declaring "{{file}}" in "files" is unnecessary; it's included in "bin".`,
+			unnecessaryDefault: `Explicitly declaring "{{file}}" in "files" is unnecessary; it's included by default.`,
+			unnecessaryMain: `Explicitly declaring "{{file}}" in "files" is unnecessary; it's the "main" entry.`
+		},
+		schema: [],
+		type: "suggestion"
+	},
+	name: "no-redundant-files"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

package/lib/rules/order-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/order-properties.d.ts
 type Options = [{
-    order: Order;
+  order: Order;
 }?];
 type Order = "legacy" | "sort-package-json" | 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 };