eslint-plugin-package-json 1.4.0 → 1.6.0

package/lib/rules/unique-dependencies.mjs

@@ -1,86 +0,0 @@
-import { createRule } from "../createRule.mjs";
-import { isJSONStringLiteral, isNotNullish } from "../utils/predicates.mjs";
-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) {
-		const dependenciesCache = {
-			dependencies: [],
-			devDependencies: [],
-			peerDependencies: []
-		};
-		const trackForCrossGroupUniqueness = Object.keys(dependenciesCache);
-		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);
-			else seen.add(element.value);
-			function report(node) {
-				const removal = getNodeToRemove(node);
-				context.report({
-					messageId: "overridden",
-					node,
-					suggest: [{
-						fix: removal.type === "JSONProperty" ? fixRemoveObjectProperty(context, removal) : fixRemoveArrayElement(context, removal, elements),
-						messageId: "remove"
-					}]
-				});
-			}
-		}
-		return {
-			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.type=JSONLiteral]"(node) {
-				if (!dependencyPropertyNames.has(node.key.value)) return;
-				const nodeValueType = node.value.type;
-				if (nodeValueType === "JSONArrayExpression") check(node.value.elements, (element) => element);
-				if (nodeValueType === "JSONObjectExpression") {
-					check(node.value.properties.map((property) => property.key), (property) => property.parent);
-					if (trackForCrossGroupUniqueness.includes(node.key.value)) dependenciesCache[node.key.value] = node.value.properties;
-				}
-			},
-			"Program:exit"() {
-				const dependencyNames = new Set(dependenciesCache.dependencies.map((node) => node.key).filter(isJSONStringLiteral).map((dependencyNameNode) => dependencyNameNode.value));
-				if (!dependencyNames.size) return;
-				for (const dependencyType of ["devDependencies", "peerDependencies"]) {
-					const otherDependencies = dependenciesCache[dependencyType];
-					for (const otherDependencyNode of otherDependencies) {
-						const otherDependencyKey = otherDependencyNode.key;
-						if (isJSONStringLiteral(otherDependencyKey) && dependencyNames.has(otherDependencyKey.value)) context.report({
-							messageId: "crossGroupDuplicate",
-							node: otherDependencyNode,
-							suggest: [{
-								fix: fixRemoveObjectProperty(context, otherDependencyNode),
-								messageId: "remove"
-							}]
-						});
-					}
-				}
-			}
-		};
-	},
-	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: {
-			crossGroupDuplicate: "Dependency is also declared in \"dependencies\" and is redundant",
-			overridden: "Dependency is overridden by a duplicate entry later on",
-			remove: "Remove this redundant dependency"
-		},
-		schema: [],
-		type: "suggestion"
-	},
-	name: "unique-dependencies"
-});
-//#endregion
-export { rule };

package/lib/rules/valid-peerDependenciesMeta-relationship.d.mts

@@ -1,6 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/valid-peerDependenciesMeta-relationship.d.ts
-declare const rule: PackageJsonRuleModule<[], []>;
-//#endregion
-export { rule };

package/lib/rules/valid-peerDependenciesMeta-relationship.mjs

@@ -1,50 +0,0 @@
-import { createRule } from "../createRule.mjs";
-import { isJSONStringLiteral } from "../utils/predicates.mjs";
-import { fixRemoveObjectProperty } from "eslint-fix-utils";
-//#region src/rules/valid-peerDependenciesMeta-relationship.ts
-const rule = createRule({
-	create(context) {
-		const peerDependencies = /* @__PURE__ */ new Set();
-		const peerDependenciesMeta = /* @__PURE__ */ new Map();
-		return {
-			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=peerDependencies]"(node) {
-				if (node.value.type === "JSONObjectExpression") {
-					for (const property of node.value.properties) if (isJSONStringLiteral(property.key)) peerDependencies.add(property.key.value);
-				}
-			},
-			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=peerDependenciesMeta]"(node) {
-				if (node.value.type === "JSONObjectExpression") {
-					for (const property of node.value.properties) if (isJSONStringLiteral(property.key)) peerDependenciesMeta.set(property.key.value, property);
-				}
-			},
-			"Program:exit"() {
-				for (const [dependencyName, propertyNode] of peerDependenciesMeta) if (!peerDependencies.has(dependencyName)) context.report({
-					data: { dependencyName },
-					messageId: "unnecessaryPeerDependency",
-					node: propertyNode,
-					suggest: [{
-						fix: fixRemoveObjectProperty(context, propertyNode),
-						messageId: "removePeerDependencyMeta"
-					}]
-				});
-			}
-		};
-	},
-	meta: {
-		docs: {
-			category: "Best Practices",
-			description: "Enforces that any dependencies declared in `peerDependenciesMeta` are also defined in the package's `peerDependencies`.",
-			recommended: true
-		},
-		hasSuggestions: true,
-		messages: {
-			removePeerDependencyMeta: "Remove from `peerDependenciesMeta`.",
-			unnecessaryPeerDependency: "Dependency '{{ dependencyName }}' is declared in `peerDependenciesMeta` but not in `peerDependencies`."
-		},
-		schema: [],
-		type: "problem"
-	},
-	name: "valid-peerDependenciesMeta-relationship"
-});
-//#endregion
-export { rule };

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

@@ -1,9 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/valid-properties.d.ts
-/** All basic valid- flavor rules */
-declare const rules: {
-  [k: string]: PackageJsonRuleModule<[], []>;
-};
-//#endregion
-export { rules };

package/lib/rules/valid-properties.mjs

@@ -1,58 +0,0 @@
-import { createSimpleValidPropertyRule } from "../utils/createSimpleValidPropertyRule.mjs";
-import { validateAuthor, validateBin, validateBrowser, validateBugs, validateBundleDependencies, validateConfig, validateContributors, validateCpu, validateDependencies, validateDescription, validateDevEngines, validateDirectories, validateEngines, validateExports, validateFiles, validateFunding, validateGypfile, validateHomepage, validateKeywords, validateLibc, validateLicense, validateMain, validateMan, validateName, validateOs, validatePackageManager, validatePeerDependenciesMeta, validatePrivate, validatePublishConfig, validateRepository, validateScripts, validateSideEffects, validateType, validateVersion, validateWorkspaces } from "package-json-validator";
-/** All basic valid- flavor rules */
-const rules = Object.fromEntries([
-	["author", validateAuthor],
-	["bin", validateBin],
-	["browser", validateBrowser],
-	["bugs", validateBugs],
-	["bundleDependencies", {
-		aliases: ["bundledDependencies"],
-		validator: validateBundleDependencies
-	}],
-	["config", validateConfig],
-	["contributors", validateContributors],
-	["cpu", validateCpu],
-	["description", validateDescription],
-	["dependencies", validateDependencies],
-	["devDependencies", validateDependencies],
-	["devEngines", validateDevEngines],
-	["directories", validateDirectories],
-	["engines", validateEngines],
-	["exports", validateExports],
-	["files", validateFiles],
-	["funding", validateFunding],
-	["gypfile", validateGypfile],
-	["homepage", validateHomepage],
-	["keywords", validateKeywords],
-	["libc", validateLibc],
-	["license", validateLicense],
-	["main", validateMain],
-	["man", validateMan],
-	["module", validateMain],
-	["name", validateName],
-	["optionalDependencies", validateDependencies],
-	["os", validateOs],
-	["packageManager", validatePackageManager],
-	["peerDependencies", validateDependencies],
-	["peerDependenciesMeta", validatePeerDependenciesMeta],
-	["private", validatePrivate],
-	["publishConfig", validatePublishConfig],
-	["repository", validateRepository],
-	["scripts", validateScripts],
-	["sideEffects", validateSideEffects],
-	["type", validateType],
-	["version", validateVersion],
-	["workspaces", validateWorkspaces]
-].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.mts

@@ -1,6 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/valid-repository-directory.d.ts
-declare const rule: PackageJsonRuleModule<[], []>;
-//#endregion
-export { rule };

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

@@ -1,73 +0,0 @@
-import { createRule } from "../createRule.mjs";
-import { findPropertyWithKeyValue } from "../utils/findPropertyWithKeyValue.mjs";
-import path from "node:path";
-import { sep } from "node:path/posix";
-import { findRootSync } from "@altano/repository-tools";
-//#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
-*/
-const pathEndsWith = (parent, child) => {
-	if (parent === child) return true;
-	const segments = parent.split(path.sep);
-	let pathToCheck = "";
-	return segments.reverse().some((segment) => {
-		pathToCheck = path.join(segment, pathToCheck);
-		if (pathToCheck === child) return true;
-	});
-};
-let repoRootCache = null;
-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));
-			let repositoryRoot;
-			if (repoRootCache && fileDirectory.startsWith(repoRootCache)) repositoryRoot = repoRootCache;
-			else {
-				repositoryRoot = findRootSync(fileDirectory);
-				if (repositoryRoot) repoRootCache = path.normalize(repositoryRoot);
-			}
-			if (repositoryRoot) {
-				const expected = path.relative(repositoryRoot, fileDirectory).replaceAll(path.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"
-					}]
-				});
-			} else if (!pathEndsWith(fileDirectory, path.normalize(directoryValue))) context.report({
-				messageId: "mismatched",
-				node: directoryProperty.value
-			});
-		} };
-	},
-	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"
-});
-//#endregion
-export { rule };

package/lib/types/estree.d.mts

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

package/lib/utils/createSimpleRequirePropertyRule.d.mts

@@ -1,48 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/utils/createSimpleRequirePropertyRule.d.ts
-interface CreateRequirePropertyRuleOptions {
-  /**
-   * The category for this rule.
-   */
-  category?: 'Publishable' | (string & {});
-  /** The value to use when fixing a violation when this property is missing */
-  fixValue?: unknown;
-  /**
-   * The default value of `ignorePrivate` rule option.
-   */
-  ignorePrivateDefault?: boolean;
-  /**
-   * Whether the rule should be included in the recommended config.
-   */
-  isRecommended?: boolean;
-}
-/**
- * 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.
- */
-declare const createSimpleRequirePropertyRule: (propertyName: string, {
-  category,
-  fixValue,
-  ignorePrivateDefault,
-  isRecommended
-}?: CreateRequirePropertyRuleOptions) => {
-  rule: PackageJsonRuleModule<[] | [({
-    ignorePrivate: boolean;
-  } | undefined)?], [] | [{
-    readonly additionalProperties: false;
-    readonly properties: {
-      readonly ignorePrivate: {
-        readonly default: boolean;
-        readonly description: "Determines if this rule should be enforced when the package's `private` property is `true`.";
-        readonly type: "boolean";
-      };
-    };
-    readonly type: "object";
-  }]>;
-  ruleName: string;
-};
-//#endregion
-export { CreateRequirePropertyRuleOptions, createSimpleRequirePropertyRule };

package/lib/utils/createSimpleRequirePropertyRule.mjs

@@ -1,59 +0,0 @@
-import { createRule } from "../createRule.mjs";
-import { isJSONStringLiteral } from "./predicates.mjs";
-//#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, { category, fixValue, ignorePrivateDefault = false, isRecommended } = {}) => {
-	const ruleName = `require-${propertyName}`;
-	return {
-		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.every((property) => !(isJSONStringLiteral(property.key) && property.key.value === propertyName))) context.report({
-						data: { property: propertyName },
-						fix: fixValue === void 0 ? void 0 : function* (fixer) {
-							yield fixer.insertTextAfterRange([0, 1], `\n  "${propertyName}": ${JSON.stringify(fixValue)}`);
-							yield node.properties.length > 0 ? fixer.insertTextAfterRange([0, 1], ",") : fixer.insertTextAfterRange([0, 1], "\n");
-						},
-						loc: {
-							column: 0,
-							line: 1
-						},
-						messageId: "missing"
-					});
-				} };
-			},
-			meta: {
-				docs: {
-					category,
-					description: `Requires the \`${propertyName}\` property to be present.`,
-					recommended: isRecommended,
-					ruleGroup: "require-properties"
-				},
-				fixable: fixValue === void 0 ? void 0 : "code",
-				messages: { missing: "Property '{{property}}' is required." },
-				schema: propertyName === "private" ? [] : [{
-					additionalProperties: false,
-					properties: { ignorePrivate: {
-						default: ignorePrivateDefault,
-						description: "Determines if this rule should be enforced when the package's `private` property is `true`.",
-						type: "boolean"
-					} },
-					type: "object"
-				}],
-				type: "suggestion"
-			},
-			name: ruleName
-		}),
-		ruleName
-	};
-};
-//#endregion
-export { createSimpleRequirePropertyRule };

package/lib/utils/createSimpleValidPropertyRule.d.mts

@@ -1,17 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-import { Result } from "package-json-validator";
-
-//#region src/utils/createSimpleValidPropertyRule.d.ts
-type ValidationFunction = (value: unknown) => Result;
-/**
- * Given a top-level property name, and a validation function, create a rule that validates the property using the validation function.
- * These rules will always be included in the recommended config.
- * Note: this will only create a basic validation rule, with no options.  If you need
- * to create a more complex rule, create it in its own file.
- */
-declare const createSimpleValidPropertyRule: (propertyName: string, validationFunction: ValidationFunction, aliases?: string[]) => {
-  rule: PackageJsonRuleModule<[], []>;
-  ruleName: string;
-};
-//#endregion
-export { ValidationFunction, createSimpleValidPropertyRule };

package/lib/utils/createSimpleValidPropertyRule.mjs

@@ -1,57 +0,0 @@
-import { createRule } from "../createRule.mjs";
-//#region src/utils/createSimpleValidPropertyRule.ts
-/**
-* Given a top-level property name, and a validation function, create a rule that validates the property using the validation function.
-* These rules will always be included in the recommended config.
-* Note: this will only create a basic validation rule, with no options.  If you need
-* to create a more complex rule, create it in its own file.
-*/
-const createSimpleValidPropertyRule = (propertyName, validationFunction, aliases = []) => {
-	const ruleName = `valid-${propertyName}`;
-	const propertyNames = [propertyName, ...aliases];
-	return {
-		rule: createRule({
-			create(context) {
-				const reportIssues = (result, node) => {
-					if (result.errorMessages.length === 0) return;
-					if (result.issues.length) for (const issue of result.issues) context.report({
-						data: { error: issue.message },
-						messageId: "validationError",
-						node
-					});
-					const childrenWithIssues = result.childResults.filter((childResult) => childResult.errorMessages.length);
-					if (node.type === "JSONObjectExpression" && childrenWithIssues.length) for (const childResult of childrenWithIssues) {
-						const childNode = node.properties[childResult.index];
-						reportIssues(childResult, childNode.value);
-					}
-					else if (node.type === "JSONArrayExpression" && childrenWithIssues.length) for (const childResult of childrenWithIssues) {
-						const childNode = node.elements[childResult.index];
-						if (childNode) reportIssues(childResult, childNode);
-					}
-				};
-				return propertyNames.reduce((acc, name) => {
-					acc[`Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=${name}]`] = (node) => {
-						const valueNode = node.value;
-						reportIssues(validationFunction(JSON.parse(context.sourceCode.getText(valueNode))), valueNode);
-					};
-					return acc;
-				}, {});
-			},
-			meta: {
-				docs: {
-					category: "Best Practices",
-					description: `Enforce that the \`${propertyName}\`${aliases.length ? ` (also ${aliases.map((alias) => `\`${alias}\``).join(", ")})` : ""} property is valid.`,
-					recommended: true,
-					ruleGroup: "valid-properties"
-				},
-				messages: { validationError: `Invalid ${propertyName}: {{ error }}` },
-				schema: [],
-				type: "problem"
-			},
-			name: ruleName
-		}),
-		ruleName
-	};
-};
-//#endregion
-export { createSimpleValidPropertyRule };

package/lib/utils/findPropertyWithKeyValue.d.mts

@@ -1,10 +0,0 @@
-import { AST } from "jsonc-eslint-parser";
-
-//#region src/utils/findPropertyWithKeyValue.d.ts
-type JSONPropertyWithKeyAndValue<Value extends string> = AST.JSONProperty & {
-  key: AST.JSONStringLiteral;
-  value: Value;
-};
-declare function findPropertyWithKeyValue<Value extends string>(properties: AST.JSONProperty[], value: Value): JSONPropertyWithKeyAndValue<Value> | undefined;
-//#endregion
-export { JSONPropertyWithKeyAndValue, findPropertyWithKeyValue };

package/lib/utils/findPropertyWithKeyValue.mjs

@@ -1,6 +0,0 @@
-//#region src/utils/findPropertyWithKeyValue.ts
-function findPropertyWithKeyValue(properties, value) {
-	return properties.find((property) => property.key.type === "JSONLiteral" && property.key.value === value);
-}
-//#endregion
-export { findPropertyWithKeyValue };

package/lib/utils/formatErrors.d.mts

@@ -1,9 +0,0 @@
-//#region src/utils/formatErrors.d.ts
-/**
- * Formats an array of error messages into a single string.
- * When there is more than one error, the errors will be formatted as a list,
- * starting on a new line.
- */
-declare const formatErrors: (errors: string[]) => string;
-//#endregion
-export { formatErrors };

package/lib/utils/formatErrors.mjs

@@ -1,12 +0,0 @@
-//#region src/utils/formatErrors.ts
-/**
-* Formats an array of error messages into a single string.
-* When there is more than one error, the errors will be formatted as a list,
-* starting on a new line.
-*/
-const formatErrors = (errors) => {
-	if (errors.length === 0) return "";
-	return errors.length > 1 ? ["", ...errors].join("\n - ") : errors[0];
-};
-//#endregion
-export { formatErrors };

package/lib/utils/isPackageJson.d.mts

@@ -1,4 +0,0 @@
-//#region src/utils/isPackageJson.d.ts
-declare const isPackageJson: (filePath: string) => boolean;
-//#endregion
-export { isPackageJson };

package/lib/utils/isPackageJson.mjs

@@ -1,4 +0,0 @@
-//#region src/utils/isPackageJson.ts
-const isPackageJson = (filePath) => /(?:^|[/\\])package.json$/.test(filePath);
-//#endregion
-export { isPackageJson };

package/lib/utils/predicates.d.mts

@@ -1,7 +0,0 @@
-import { AST } from "jsonc-eslint-parser";
-
-//#region src/utils/predicates.d.ts
-declare function isJSONStringLiteral(node: AST.JSONNode): node is AST.JSONStringLiteral;
-declare function isNotNullish<T extends NonNullable<unknown>>(value: null | T | undefined): value is T;
-//#endregion
-export { isJSONStringLiteral, isNotNullish };

package/lib/utils/predicates.mjs

@@ -1,9 +0,0 @@
-//#region src/utils/predicates.ts
-function isJSONStringLiteral(node) {
-	return node.type === "JSONLiteral" && typeof node.value === "string";
-}
-function isNotNullish(value) {
-	return value !== null && value !== void 0;
-}
-//#endregion
-export { isJSONStringLiteral, isNotNullish };