eslint-plugin-package-json 1.5.0 → 1.6.1

package/lib/rules/no-redundant-publishConfig.d.mts

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

package/lib/rules/no-redundant-publishConfig.mjs

@@ -1,50 +0,0 @@
-import { isJSONStringLiteral } from "../utils/predicates/isJSONStringLiteral.mjs";
-import { createRule } from "../createRule.mjs";
-import { fixRemoveObjectProperty } from "eslint-fix-utils";
-//#region src/rules/no-redundant-publishConfig.ts
-const rule = createRule({
-	create(context) {
-		let packageName;
-		let publishConfigAccessProperty;
-		return {
-			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=name]"(node) {
-				if (isJSONStringLiteral(node.value)) packageName = node.value.value;
-			},
-			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=publishConfig]"(node) {
-				if (node.value.type !== "JSONObjectExpression") return;
-				for (const property of node.value.properties) if (isJSONStringLiteral(property.key) && property.key.value === "access") {
-					publishConfigAccessProperty = property;
-					break;
-				}
-			},
-			"Program:exit"() {
-				if (!packageName || !publishConfigAccessProperty) return;
-				if (!packageName.startsWith("@")) context.report({
-					messageId: "redundantAccess",
-					node: publishConfigAccessProperty,
-					suggest: [{
-						fix: fixRemoveObjectProperty(context, publishConfigAccessProperty),
-						messageId: "removeAccess"
-					}]
-				});
-			}
-		};
-	},
-	meta: {
-		docs: {
-			category: "Best Practices",
-			description: "Warns when publishConfig.access is used in unscoped packages.",
-			recommended: true
-		},
-		hasSuggestions: true,
-		messages: {
-			redundantAccess: "'publishConfig.access' is redundant for unscoped packages - they are always public.",
-			removeAccess: "Remove the redundant 'access' field."
-		},
-		schema: [],
-		type: "suggestion"
-	},
-	name: "no-redundant-publishConfig"
-});
-//#endregion
-export { rule };

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

@@ -1,25 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/order-properties.d.ts
-declare const rule: PackageJsonRuleModule<[({
-  order?: "sort-package-json" | string[] | undefined;
-} | undefined)?], [{
-  readonly additionalProperties: false;
-  readonly properties: {
-    readonly order: {
-      readonly anyOf: readonly [{
-        readonly enum: readonly ["sort-package-json"];
-        readonly type: readonly ["string"];
-      }, {
-        readonly items: {
-          readonly type: readonly ["string"];
-        };
-        readonly type: readonly ["array"];
-      }];
-      readonly description: "Specifies the sorting order of top-level properties.";
-    };
-  };
-  readonly type: "object";
-}]>;
-//#endregion
-export { rule };

package/lib/rules/order-properties.mjs

@@ -1,64 +0,0 @@
-import { createRule } from "../createRule.mjs";
-import detectIndent from "detect-indent";
-import { detectNewlineGraceful } from "detect-newline";
-import sortObjectKeys from "sort-object-keys";
-import { sortOrder } from "sort-package-json";
-//#region src/rules/order-properties.ts
-const rule = createRule({
-	create(context) {
-		return { "Program:exit"() {
-			const { ast, text } = context.sourceCode;
-			const { order = "sort-package-json" } = context.options[0] ?? {};
-			const requiredOrder = order === "sort-package-json" ? sortOrder : order;
-			const json = JSON.parse(text);
-			const orderedNonStandardKeys = Object.keys(json).filter((key) => !requiredOrder.includes(key)).sort();
-			const orderedSource = sortObjectKeys(json, [...requiredOrder, ...orderedNonStandardKeys]);
-			const orderedKeys = Object.keys(orderedSource);
-			const { properties } = ast.body[0].expression;
-			for (let i = 0; i < properties.length; i += 1) {
-				const { value } = properties[i].key;
-				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: "Stylistic",
-			description: "Enforces that package properties are declared in a consistent order."
-		},
-		fixable: "code",
-		messages: { incorrectOrder: "Top-level property `{{property}}` is not ordered in the standard way." },
-		schema: [{
-			additionalProperties: false,
-			properties: { order: {
-				anyOf: [{
-					enum: ["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"
-});
-//#endregion
-export { rule };

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

@@ -1,18 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/repository-shorthand.d.ts
-declare const rule: PackageJsonRuleModule<[({
-  form?: "object" | "shorthand" | undefined;
-} | undefined)?], [{
-  readonly additionalProperties: false;
-  readonly properties: {
-    readonly form: {
-      readonly description: "Specifies which repository form to enforce.";
-      readonly enum: readonly ["object", "shorthand"];
-      readonly type: readonly ["string"];
-    };
-  };
-  readonly type: "object";
-}]>;
-//#endregion
-export { rule };

package/lib/rules/repository-shorthand.mjs

@@ -1,111 +0,0 @@
-import { isJSONStringLiteral } from "../utils/predicates/isJSONStringLiteral.mjs";
-import { createRule } from "../createRule.mjs";
-import { findPropertyWithKeyValue } from "../utils/findPropertyWithKeyValue.mjs";
-//#region src/rules/repository-shorthand.ts
-const providerRegexes = {
-	bitbucket: /^(?:git\+)?(?:ssh:\/\/git@|http?s:\/\/)?(?:www\.)?bitbucket\.org\//,
-	gist: /^(?:git\+)?(?:ssh:\/\/git@|http?s:\/\/)?(?:www\.)?gist\.github\.com\//,
-	github: /^(?:git\+)?(?:ssh:\/\/git@|http?s:\/\/)?(?:www\.)?github\.com\//,
-	gitlab: /^(?:git\+)?(?:ssh:\/\/git@|http?s:\/\/)?(?:www\.)?gitlab\.com\//
-};
-const providerUrls = {
-	bitbucket: "https://bitbucket.org/",
-	gist: "https://gist.github.com/",
-	github: "https://github.com/",
-	gitlab: "https://gitlab.com/"
-};
-const providers = Object.keys(providerRegexes);
-const isProvider = (value) => value in providerRegexes;
-const cleanUrl = (url, provider) => url.replace(providerRegexes[provider], "").replace(/\.git$/, "");
-const getProviderFromUrl = (url) => {
-	return providers.find((provider) => providerRegexes[provider].test(url));
-};
-const createShorthand = (url, provider) => {
-	return `${provider}:${cleanUrl(url, provider)}`;
-};
-const createUrl = (shorthand) => {
-	if (shorthand.includes(":")) {
-		const [provider, repo] = shorthand.split(":");
-		if (isProvider(provider)) return `${providerUrls[provider]}${repo}`;
-	}
-	return `${providerUrls.github}${shorthand}`;
-};
-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: createUrl(node.value.value)
-					}, null, 2));
-				},
-				messageId: "preferObject",
-				node: node.value
-			});
-		}
-		function validateRepositoryForShorthand(node) {
-			if (isJSONStringLiteral(node.value)) {
-				const { value } = node.value;
-				const provider = getProviderFromUrl(value);
-				if (provider) context.report({
-					fix(fixer) {
-						return fixer.replaceText(node.value, JSON.stringify(createShorthand(value, provider)));
-					},
-					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") return;
-			const url = urlProperty.value.value;
-			const provider = getProviderFromUrl(url);
-			if (provider) context.report({
-				fix(fixer) {
-					return fixer.replaceText(node.value, JSON.stringify(createShorthand(url, provider)));
-				},
-				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 supported repository provider."
-		},
-		schema: [{
-			additionalProperties: false,
-			properties: { form: {
-				description: "Specifies which repository form to enforce.",
-				enum: ["object", "shorthand"],
-				type: ["string"]
-			} },
-			type: "object"
-		}],
-		type: "suggestion"
-	},
-	name: "repository-shorthand"
-});
-//#endregion
-export { rule };

package/lib/rules/require-attribution.d.mts

@@ -1,22 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/require-attribution.d.ts
-declare const rule: PackageJsonRuleModule<[({
-  ignorePrivate?: boolean | undefined;
-  preferContributorsOnly?: boolean | undefined;
-} | undefined)?], [{
-  readonly additionalProperties: false;
-  readonly properties: {
-    readonly ignorePrivate: {
-      readonly description: "Skip attribution requirements for packages with `\"private\": true`.";
-      readonly type: "boolean";
-    };
-    readonly preferContributorsOnly: {
-      readonly description: "Require that only `contributors` is present, and `author` is not defined.";
-      readonly type: "boolean";
-    };
-  };
-  readonly type: "object";
-}]>;
-//#endregion
-export { rule };

package/lib/rules/require-attribution.mjs

@@ -1,91 +0,0 @@
-import { createRule } from "../createRule.mjs";
-import { fixRemoveObjectProperty } from "eslint-fix-utils";
-//#region src/rules/require-attribution.ts
-const rule = createRule({
-	create(context) {
-		const preferContributorsOnly = context.options[0]?.preferContributorsOnly ?? false;
-		const ignorePrivate = context.options[0]?.ignorePrivate ?? true;
-		let authorPropertyNode;
-		let contributorsPropertyNode;
-		let isPrivatePackage = false;
-		return {
-			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=author]"(node) {
-				authorPropertyNode = node;
-			},
-			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=contributors]"(node) {
-				contributorsPropertyNode = node;
-				const contributorsValue = node.value;
-				if (contributorsValue.type !== "JSONArrayExpression" || contributorsValue.elements.every((element) => !element)) context.report({
-					messageId: "noContributors",
-					node
-				});
-			},
-			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=private]"(node) {
-				if (node.value.type === "JSONLiteral" && node.value.value === true) isPrivatePackage = true;
-			},
-			"Program:exit"() {
-				if (ignorePrivate && isPrivatePackage) return;
-				if (preferContributorsOnly) {
-					if (authorPropertyNode) context.report({
-						messageId: "contributorsOnly",
-						node: authorPropertyNode,
-						suggest: [{
-							fix: fixRemoveObjectProperty(context, authorPropertyNode),
-							messageId: "removeAuthor"
-						}]
-					});
-					if (!contributorsPropertyNode) context.report({
-						loc: {
-							column: 0,
-							line: 1
-						},
-						messageId: "missingContributor"
-					});
-				} else if (!authorPropertyNode && !contributorsPropertyNode) context.report({
-					loc: {
-						column: 0,
-						line: 1
-					},
-					messageId: "missing"
-				});
-			}
-		};
-	},
-	meta: {
-		defaultOptions: [{
-			ignorePrivate: true,
-			preferContributorsOnly: false
-		}],
-		docs: {
-			category: "Best Practices",
-			description: "Ensures that proper attribution is included, requiring that either `author` or `contributors` is defined, and that if `contributors` is present, it should include at least one contributor.",
-			recommended: true
-		},
-		hasSuggestions: true,
-		messages: {
-			contributorsOnly: "Only `contributors` should be defined for attribution.",
-			missing: "Property attribution is required. Either `author` or `contributors` should be defined.",
-			missingContributor: "Property attribution is required. `contributors` should be defined.",
-			noContributors: "At least one contributor should be defined.",
-			removeAuthor: "Remove `author`."
-		},
-		schema: [{
-			additionalProperties: false,
-			properties: {
-				ignorePrivate: {
-					description: "Skip attribution requirements for packages with `\"private\": true`.",
-					type: "boolean"
-				},
-				preferContributorsOnly: {
-					description: "Require that only `contributors` is present, and `author` is not defined.",
-					type: "boolean"
-				}
-			},
-			type: "object"
-		}],
-		type: "suggestion"
-	},
-	name: "require-attribution"
-});
-//#endregion
-export { rule };

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

@@ -1,22 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-import { CreateRequirePropertyRuleOptions } from "../utils/createSimpleRequirePropertyRule.mjs";
-
-//#region src/rules/require-properties.d.ts
-declare const propertyConfig: [name: string, options?: CreateRequirePropertyRuleOptions][];
-declare const rules: {
-  [k: string]: 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";
-  }]>;
-};
-//#endregion
-export { propertyConfig, rules };

package/lib/rules/require-properties.mjs

@@ -1,74 +0,0 @@
-import { createSimpleRequirePropertyRule } from "../utils/createSimpleRequirePropertyRule.mjs";
-import { getGitAuthor } from "../utils/git/getGitAuthor.mjs";
-//#region src/rules/require-properties.ts
-const propertyConfig = [
-	["author", { fixValue: getGitAuthor }],
-	["bin"],
-	["browser"],
-	["bugs", { ignorePrivateDefault: true }],
-	["bundleDependencies"],
-	["config"],
-	["contributors"],
-	["cpu"],
-	["dependencies"],
-	["description", { isRecommended: true }],
-	["devDependencies"],
-	["devEngines"],
-	["directories"],
-	["engines"],
-	["exports", {
-		ignorePrivateDefault: true,
-		isRecommended: true
-	}],
-	["files", {
-		ignorePrivateDefault: true,
-		isRecommended: true
-	}],
-	["funding"],
-	["gypfile"],
-	["homepage", { ignorePrivateDefault: true }],
-	["keywords", { ignorePrivateDefault: true }],
-	["libc"],
-	["license", {
-		ignorePrivateDefault: true,
-		isRecommended: true
-	}],
-	["main"],
-	["man"],
-	["module"],
-	["name", {
-		ignorePrivateDefault: true,
-		isRecommended: true
-	}],
-	["optionalDependencies"],
-	["os"],
-	["packageManager"],
-	["peerDependencies"],
-	["peerDependenciesMeta"],
-	["private", { fixValue: false }],
-	["publishConfig", { ignorePrivateDefault: true }],
-	["repository", {
-		ignorePrivateDefault: true,
-		isRecommended: true
-	}],
-	["scripts"],
-	["sideEffects", {
-		ignorePrivateDefault: true,
-		isRecommended: true
-	}],
-	["type", {
-		fixValue: "commonjs",
-		isRecommended: true
-	}],
-	["types"],
-	["version", {
-		ignorePrivateDefault: true,
-		isRecommended: true
-	}]
-];
-const rules = Object.fromEntries(propertyConfig.map(([propertyName, options]) => {
-	const { rule, ruleName } = createSimpleRequirePropertyRule(propertyName, options);
-	return [ruleName, rule];
-}));
-//#endregion
-export { propertyConfig, rules };

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

@@ -1,92 +0,0 @@
-import { PackageJsonRuleModule } from "../createRule.mjs";
-
-//#region src/rules/restrict-dependency-ranges.d.ts
-declare const rule: PackageJsonRuleModule<[({
-  forDependencyTypes?: string[] | undefined;
-  forPackages?: string[] | undefined;
-  forVersions?: string | undefined;
-  rangeType: "caret" | "pin" | "tilde" | ("caret" | "pin" | "tilde")[];
-} | {
-  forDependencyTypes?: string[] | undefined;
-  forPackages?: string[] | undefined;
-  forVersions?: string | undefined;
-  rangeType: "caret" | "pin" | "tilde" | ("caret" | "pin" | "tilde")[];
-}[] | undefined)?], [{
-  readonly oneOf: readonly [{
-    readonly additionalProperties: false;
-    readonly properties: {
-      readonly forDependencyTypes: {
-        readonly description: "Apply a range type restriction for an entire group of dependencies by which type of dependencies they belong to.";
-        readonly items: {
-          readonly enum: string[];
-        };
-        readonly type: "array";
-      };
-      readonly forPackages: {
-        readonly description: "The exact name of a package, or a regex pattern used to match a group of packages by name.";
-        readonly items: {
-          readonly type: "string";
-        };
-        readonly type: "array";
-      };
-      readonly forVersions: {
-        readonly description: "Apply a restriction to a specific semver range.";
-        readonly type: "string";
-      };
-      readonly rangeType: {
-        readonly description: "Identifies which range type or types you want to apply to packages that match any of the other match options (or all dependencies if no other options are provided).";
-        readonly oneOf: readonly [{
-          readonly enum: readonly ["caret", "pin", "tilde"];
-        }, {
-          readonly items: {
-            readonly enum: readonly ["caret", "pin", "tilde"];
-          };
-          readonly type: "array";
-        }];
-      };
-    };
-    readonly required: readonly ["rangeType"];
-    readonly type: "object";
-  }, {
-    readonly description: "Array of configuration options, specifying range requirements.";
-    readonly items: {
-      readonly additionalProperties: false;
-      readonly properties: {
-        readonly forDependencyTypes: {
-          readonly description: "Apply a range type restriction for an entire group of dependencies by which type of dependencies they belong to.";
-          readonly items: {
-            readonly enum: string[];
-          };
-          readonly type: "array";
-        };
-        readonly forPackages: {
-          readonly description: "The exact name of a package, or a regex pattern used to match a group of packages by name.";
-          readonly items: {
-            readonly type: "string";
-          };
-          readonly type: "array";
-        };
-        readonly forVersions: {
-          readonly description: "Apply a restriction to a specific semver range.";
-          readonly type: "string";
-        };
-        readonly rangeType: {
-          readonly description: "Identifies which range type or types you want to apply to packages that match any of the other match options (or all dependencies if no other options are provided).";
-          readonly oneOf: readonly [{
-            readonly enum: readonly ["caret", "pin", "tilde"];
-          }, {
-            readonly items: {
-              readonly enum: readonly ["caret", "pin", "tilde"];
-            };
-            readonly type: "array";
-          }];
-        };
-      };
-      readonly required: readonly ["rangeType"];
-      readonly type: "object";
-    };
-    readonly type: "array";
-  }];
-}]>;
-//#endregion
-export { rule };