eslint-plugin-package-json 0.52.0 → 0.53.0

package/lib/rules/valid-package-definition.js

@@ -1,56 +1,47 @@
-import { validate } from "package-json-validator";
 import { createRule } from "../createRule.js";
+import { validate } from "package-json-validator";
+
+//#region src/rules/valid-package-definition.ts
 const ignoredErrors = [
-  /^Url not valid/i,
-  /^Invalid version range for .+?: file:/i,
-  /^author field should have name/i
+	/^Url not valid/i,
+	/^Invalid version range for .+?: file:/i,
+	/^author field should have name/i
 ];
 const isUsableError = (errorText) => ignoredErrors.every((pattern) => !pattern.test(errorText));
 const rule = createRule({
-  create(context) {
-    const ignoreProperties = context.options[0]?.ignoreProperties ?? [];
-    return {
-      "Program:exit"() {
-        const validation = validate(context.sourceCode.text);
-        const usableErrors = validation.errors?.filter((error) => {
-          return isUsableError(error.message) && !ignoreProperties.includes(error.field);
-        }) ?? [];
-        for (const error of usableErrors) {
-          if (error.message) {
-            context.report({
-              // eslint-disable-next-line eslint-plugin/prefer-message-ids
-              message: error.message,
-              node: context.sourceCode.ast
-            });
-          }
-        }
-      }
-    };
-  },
-  // eslint-disable-next-line eslint-plugin/prefer-message-ids
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Enforce that package.json has all properties required by the npm spec",
-      recommended: true
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          ignoreProperties: {
-            items: {
-              type: "string"
-            },
-            type: "array"
-          }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem"
-  }
+	create(context) {
+		const ignoreProperties = context.options[0]?.ignoreProperties ?? [];
+		return { "Program:exit"() {
+			const validation = validate(context.sourceCode.text);
+			const usableErrors = validation.errors?.filter((error) => {
+				return isUsableError(error.message) && !ignoreProperties.includes(error.field);
+			}) ?? [];
+			for (const error of usableErrors) if (error.message) context.report({
+				message: error.message,
+				node: context.sourceCode.ast
+			});
+		} };
+	},
+	meta: {
+		defaultOptions: [{ ignoreProperties: [] }],
+		docs: {
+			category: "Best Practices",
+			description: "Enforce that package.json has all properties required by the npm spec",
+			recommended: true
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: { ignoreProperties: {
+				description: "Array of top-level package properties to ignore.",
+				items: { type: "string" },
+				type: "array"
+			} },
+			type: "object"
+		}],
+		type: "problem"
+	},
+	name: "valid-package-definition"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

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

@@ -1,9 +1,9 @@
-import { PackageJsonRuleModule } from '../createRule.js';
-import 'estree';
-import 'eslint';
-import 'jsonc-eslint-parser';
+import { PackageJsonRuleModule } from "../createRule.js";
 
+//#region src/rules/valid-properties.d.ts
 /** All basic valid- flavor rules */
-declare const rules: Record<string, PackageJsonRuleModule<unknown[]>>;
-
-export { rules };
+declare const rules: {
+  [k: string]: PackageJsonRuleModule<unknown[]>;
+};
+//#endregion
+export { rules };

package/lib/rules/valid-properties.js

@@ -1,57 +1,35 @@
-import {
-  validateAuthor,
-  validateBundleDependencies,
-  validateConfig,
-  validateCpu,
-  validateDependencies,
-  validateDescription,
-  validateLicense,
-  validateScripts,
-  validateType
-} from "package-json-validator";
-import {
-  createSimpleValidPropertyRule
-} from "../utils/createSimpleValidPropertyRule.js";
+import { createSimpleValidPropertyRule } from "../utils/createSimpleValidPropertyRule.js";
+import { validateAuthor, validateBundleDependencies, validateConfig, validateCpu, validateDependencies, validateDescription, validateLicense, validateScripts, validateType } from "package-json-validator";
+
+//#region src/rules/valid-properties.ts
 const properties = [
-  ["author", validateAuthor],
-  [
-    "bundleDependencies",
-    {
-      aliases: ["bundledDependencies"],
-      validator: validateBundleDependencies
-    }
-  ],
-  ["config", validateConfig],
-  ["cpu", validateCpu],
-  ["dependencies", validateDependencies],
-  ["description", validateDescription],
-  ["devDependencies", validateDependencies],
-  ["license", validateLicense],
-  ["optionalDependencies", validateDependencies],
-  ["peerDependencies", validateDependencies],
-  ["scripts", validateScripts],
-  ["type", validateType]
-  // TODO: More to come!
+	["author", validateAuthor],
+	["bundleDependencies", {
+		aliases: ["bundledDependencies"],
+		validator: validateBundleDependencies
+	}],
+	["config", validateConfig],
+	["cpu", validateCpu],
+	["dependencies", validateDependencies],
+	["description", validateDescription],
+	["devDependencies", validateDependencies],
+	["license", validateLicense],
+	["optionalDependencies", validateDependencies],
+	["peerDependencies", validateDependencies],
+	["scripts", validateScripts],
+	["type", validateType]
 ];
-const rules = properties.reduce(
-  (acc, [propertyName, validationFunctionOrOptions]) => {
-    let validationFunction;
-    let aliases = [];
-    if (typeof validationFunctionOrOptions === "object") {
-      validationFunction = validationFunctionOrOptions.validator;
-      aliases = validationFunctionOrOptions.aliases;
-    } else {
-      validationFunction = validationFunctionOrOptions;
-    }
-    acc[`valid-${propertyName}`] = createSimpleValidPropertyRule(
-      propertyName,
-      validationFunction,
-      aliases
-    );
-    return acc;
-  },
-  {}
-);
-export {
-  rules
-};
+/** All basic valid- flavor rules */
+const rules = Object.fromEntries(properties.map(([propertyName, validationFunctionOrOptions]) => {
+	let validationFunction;
+	let aliases = [];
+	if (typeof validationFunctionOrOptions === "object") {
+		validationFunction = validationFunctionOrOptions.validator;
+		aliases = validationFunctionOrOptions.aliases;
+	} else validationFunction = validationFunctionOrOptions;
+	const { rule, ruleName } = createSimpleValidPropertyRule(propertyName, validationFunction, aliases);
+	return [ruleName, rule];
+}));
+
+//#endregion
+export { rules };

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

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

@@ -1,86 +1,71 @@
-import { findRootSync } from "@altano/repository-tools";
-import * as path from "node:path";
-import { sep as posixSep } from "node:path/posix";
 import { createRule } from "../createRule.js";
 import { findPropertyWithKeyValue } from "../utils/findPropertyWithKeyValue.js";
+import * as path$1 from "node:path";
+import { findRootSync } from "@altano/repository-tools";
+import { sep } from "node:path/posix";
+
+//#region src/rules/valid-repository-directory.ts
+/**
+* Checks if the child path appears at the end of the parent path.
+* @example '/a/b/c', 'c' => true
+* @example '/a/b/c', 'b/c' => true
+* @example '/a/b/c', 'b' => false
+* @example '/a/b/c', 'd' => false
+*/
 function pathEndsWith(parent, child) {
-  const segments = parent.split(path.sep);
-  if (parent === child) {
-    return true;
-  }
-  let pathToCheck = "";
-  return segments.reverse().some((segment) => {
-    pathToCheck = path.join(segment, pathToCheck);
-    if (pathToCheck === child) {
-      return true;
-    }
-  });
+	const segments = parent.split(path$1.sep);
+	if (parent === child) return true;
+	let pathToCheck = "";
+	return segments.reverse().some((segment) => {
+		pathToCheck = path$1.join(segment, pathToCheck);
+		if (pathToCheck === child) return true;
+	});
 }
 const rule = createRule({
-  create(context) {
-    return {
-      "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=repository][value.type=JSONObjectExpression]"(node) {
-        const directoryProperty = findPropertyWithKeyValue(
-          node.value.properties,
-          "directory"
-        );
-        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 {
-          const expected = path.relative(repositoryRoot, fileDirectory).replaceAll(path.sep, posixSep);
-          if (expected !== directoryValue) {
-            context.report({
-              messageId: "mismatched",
-              node: directoryProperty.value,
-              suggest: [
-                {
-                  data: { expected },
-                  fix(fixer) {
-                    return fixer.replaceText(
-                      directoryProperty.value,
-                      `"${expected}"`
-                    );
-                  },
-                  messageId: "replace"
-                }
-              ]
-            });
-          }
-        }
-      }
-    };
-  },
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Enforce that if repository directory is specified, it matches the path to the package.json file",
-      recommended: true
-    },
-    hasSuggestions: true,
-    messages: {
-      mismatched: "Directory does not match package.json directory.",
-      replace: "Replace with '{{ expected }}'."
-    },
-    schema: [],
-    type: "suggestion"
-  }
+	create(context) {
+		return { "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=repository][value.type=JSONObjectExpression]"(node) {
+			const directoryProperty = findPropertyWithKeyValue(node.value.properties, "directory");
+			if (directoryProperty?.value.type !== "JSONLiteral" || typeof directoryProperty.value.value !== "string") return;
+			const directoryValue = directoryProperty.value.value;
+			const fileDirectory = path$1.normalize(path$1.dirname(context.filename));
+			const repositoryRoot = findRootSync(fileDirectory);
+			if (repositoryRoot == null) {
+				if (!pathEndsWith(fileDirectory, path$1.normalize(directoryValue))) context.report({
+					messageId: "mismatched",
+					node: directoryProperty.value
+				});
+			} else {
+				const expected = path$1.relative(repositoryRoot, fileDirectory).replaceAll(path$1.sep, sep);
+				if (expected !== directoryValue) context.report({
+					messageId: "mismatched",
+					node: directoryProperty.value,
+					suggest: [{
+						data: { expected },
+						fix(fixer) {
+							return fixer.replaceText(directoryProperty.value, `"${expected}"`);
+						},
+						messageId: "replace"
+					}]
+				});
+			}
+		} };
+	},
+	meta: {
+		docs: {
+			category: "Best Practices",
+			description: "Enforce that if repository directory is specified, it matches the path to the package.json file",
+			recommended: true
+		},
+		hasSuggestions: true,
+		messages: {
+			mismatched: "Directory does not match package.json directory.",
+			replace: "Replace with '{{ expected }}'."
+		},
+		schema: [],
+		type: "suggestion"
+	},
+	name: "valid-repository-directory"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

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

package/lib/rules/valid-version.js

@@ -1,39 +1,38 @@
-import semver from "semver";
 import { createRule } from "../createRule.js";
+import semver from "semver";
+
+//#region src/rules/valid-version.ts
 const rule = createRule({
-  create(context) {
-    return {
-      "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=version]"(node) {
-        if (node.value.type !== "JSONLiteral" || typeof node.value.value !== "string") {
-          context.report({
-            messageId: "type",
-            node: node.value
-          });
-          return;
-        }
-        if (!semver.valid(node.value.value)) {
-          context.report({
-            messageId: "invalid",
-            node: node.value
-          });
-        }
-      }
-    };
-  },
-  meta: {
-    docs: {
-      category: "Best Practices",
-      description: "Enforce that package versions are valid semver specifiers",
-      recommended: true
-    },
-    messages: {
-      invalid: "Version is not a valid semver specifier.",
-      type: '"version" should be a string.'
-    },
-    schema: [],
-    type: "problem"
-  }
+	create(context) {
+		return { "Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=version]"(node) {
+			if (node.value.type !== "JSONLiteral" || typeof node.value.value !== "string") {
+				context.report({
+					messageId: "type",
+					node: node.value
+				});
+				return;
+			}
+			if (!semver.valid(node.value.value)) context.report({
+				messageId: "invalid",
+				node: node.value
+			});
+		} };
+	},
+	meta: {
+		docs: {
+			category: "Best Practices",
+			description: "Enforce that package versions are valid semver specifiers",
+			recommended: true
+		},
+		messages: {
+			invalid: "Version is not a valid semver specifier.",
+			type: "\"version\" should be a string."
+		},
+		schema: [],
+		type: "problem"
+	},
+	name: "valid-version"
 });
-export {
-  rule
-};
+
+//#endregion
+export { rule };

package/lib/types/estree.d.ts

@@ -0,0 +1,8 @@
+import { JSONNode } from "jsonc-eslint-parser";
+
+//#region src/types/estree.d.ts
+declare module "estree" {
+  interface NodeMap {
+    JSONNode: JSONNode;
+  }
+}

package/lib/utils/createSimpleRequirePropertyRule.d.ts

@@ -1,20 +1,18 @@
-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/utils/createSimpleRequirePropertyRule.d.ts
 interface CreateRequirePropertyRuleOptions {
-    /**
-     * The default value of `ignorePrivate` rule option.
-     */
-    ignorePrivateDefault?: boolean;
-    /**
-     * Whether the rule should be included in the recommended config.
-     */
-    isRecommended?: boolean;
+  /**
+   * The default value of `ignorePrivate` rule option.
+   */
+  ignorePrivateDefault?: boolean;
+  /**
+   * Whether the rule should be included in the recommended config.
+   */
+  isRecommended?: boolean;
 }
 type Options = [{
-    ignorePrivate?: boolean;
+  ignorePrivate?: boolean;
 }?];
 /**
  * Given a top-level property name, create a rule that requires that property to be present.
@@ -22,9 +20,12 @@ type Options = [{
  * Note: this will only create a basic require rule, with no options.  If you need
  * to create a more complex rule, create it in its own file.
  */
-declare const createSimpleRequirePropertyRule: (propertyName: string, { ignorePrivateDefault, isRecommended, }?: CreateRequirePropertyRuleOptions) => {
-    create(context: PackageJsonRuleContext<Options>): jsonc_eslint_parser.RuleListener;
-    meta: eslint.Rule.RuleMetaData;
+declare const createSimpleRequirePropertyRule: (propertyName: string, {
+  ignorePrivateDefault,
+  isRecommended
+}?: CreateRequirePropertyRuleOptions) => {
+  rule: PackageJsonRuleModule<Options>;
+  ruleName: string;
 };
-
-export { type CreateRequirePropertyRuleOptions, createSimpleRequirePropertyRule };
+//#endregion
+export { CreateRequirePropertyRuleOptions, createSimpleRequirePropertyRule };

package/lib/utils/createSimpleRequirePropertyRule.js

@@ -1,56 +1,51 @@
 import { createRule } from "../createRule.js";
 import { isJSONStringLiteral } from "./predicates.js";
-const createSimpleRequirePropertyRule = (propertyName, {
-  ignorePrivateDefault = false,
-  isRecommended
-} = {}) => {
-  return createRule({
-    create(context) {
-      const enforceForPrivate = context.settings.packageJson?.enforceForPrivate;
-      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({
-              data: { property: propertyName },
-              messageId: "missing",
-              node: context.sourceCode.ast
-            });
-          }
-        }
-      };
-    },
-    meta: {
-      docs: {
-        description: `Requires the \`${propertyName}\` property to be present.`,
-        recommended: isRecommended
-      },
-      messages: {
-        missing: "Property '{{property}}' is required."
-      },
-      schema: [
-        {
-          additionalProperties: false,
-          properties: {
-            ignorePrivate: {
-              default: ignorePrivateDefault,
-              type: "boolean"
-            }
-          },
-          type: "object"
-        }
-      ],
-      type: "suggestion"
-    }
-  });
-};
-export {
-  createSimpleRequirePropertyRule
+
+//#region src/utils/createSimpleRequirePropertyRule.ts
+/**
+* Given a top-level property name, create a rule that requires that property to be present.
+* Optionally, include it in the recommended config.
+* Note: this will only create a basic require rule, with no options.  If you need
+* to create a more complex rule, create it in its own file.
+*/
+const createSimpleRequirePropertyRule = (propertyName, { ignorePrivateDefault = false, isRecommended } = {}) => {
+	const ruleName = `require-${propertyName}`;
+	const rule = createRule({
+		create(context) {
+			const enforceForPrivate = context.settings.packageJson?.enforceForPrivate;
+			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({
+					data: { property: propertyName },
+					messageId: "missing",
+					node: context.sourceCode.ast
+				});
+			} };
+		},
+		meta: {
+			docs: {
+				description: `Requires the \`${propertyName}\` property to be present.`,
+				recommended: isRecommended
+			},
+			messages: { missing: "Property '{{property}}' is required." },
+			schema: [{
+				additionalProperties: false,
+				properties: { ignorePrivate: {
+					default: ignorePrivateDefault,
+					type: "boolean"
+				} },
+				type: "object"
+			}],
+			type: "suggestion"
+		},
+		name: ruleName
+	});
+	return {
+		rule,
+		ruleName
+	};
 };
+
+//#endregion
+export { createSimpleRequirePropertyRule };