@acdvs/eslint-plugin-amd 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,23 @@
+import { a as DependencyPair, i as DependencyAnalysis, n as DefineCall, r as DefineFactory, t as DefineArgs } from "./types-OWk_tv7p.mjs";
+import { Linter, Rule } from "eslint";
+
+//#region lib/index.d.ts
+declare const plugin: {
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: {
+    'define-indicator': Rule.RuleModule;
+    'no-dynamic-require': Rule.RuleModule;
+    'no-extra-deps': Rule.RuleModule;
+    'no-extra-params': Rule.RuleModule;
+    'no-invalid-define': Rule.RuleModule;
+    'no-module-extensions': Rule.RuleModule;
+    'no-name': Rule.RuleModule;
+    'sorted-deps': Rule.RuleModule;
+  };
+  configs: Record<string, Linter.Config[]>;
+};
+//#endregion
+export { DefineArgs, DefineCall, DefineFactory, DependencyAnalysis, DependencyPair, plugin as default };

package/dist/index.mjs

@@ -0,0 +1,319 @@
+import { a as hasAMDIndicator, i as isRequireCall, n as getDefineCall } from "./define-DldfQ_w6.mjs";
+import globals from "globals";
+import path from "node:path";
+//#region package.json
+var name = "@acdvs/eslint-plugin-amd";
+var version = "1.0.0";
+var homepage = "https://github.com/acdvs/eslint-plugin-amd";
+//#endregion
+//#region lib/rules/index.ts
+var rules_default = {
+	"define-indicator": {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce the presence of the AMD module `define()` indicator.",
+				url: `${homepage}/blob/main/docs/rules/${path.basename(import.meta.filename, ".ts")}.md`
+			},
+			fixable: "code",
+			schema: [],
+			messages: {
+				defineCallWithoutIndicator: "Missing AMD module `define` indicator: `define.amd = {}`",
+				indicatorWithoutDefineCall: "AMD module `define` indicator present without a `define()` call."
+			}
+		},
+		create: (context) => {
+			let hasDefineCall = false;
+			return {
+				"CallExpression[callee.name=define]": () => {
+					hasDefineCall = true;
+				},
+				"Program:exit": (program) => {
+					const hasIndicator = hasAMDIndicator(context.sourceCode);
+					if (hasDefineCall && !hasIndicator) {
+						context.report({
+							node: program,
+							messageId: "defineCallWithoutIndicator",
+							fix: (fixer) => {
+								return fixer.insertTextAfter(program, "\n\ndefine.amd = {};");
+							}
+						});
+						return;
+					}
+					if (!hasDefineCall && hasIndicator) context.report({
+						node: program,
+						messageId: "indicatorWithoutDefineCall"
+					});
+				}
+			};
+		}
+	},
+	"no-dynamic-require": {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow dynamic (non-literal) expressions in `require()` calls.",
+				url: `${homepage}/blob/main/docs/rules/${path.basename(import.meta.filename, ".ts")}.md`
+			},
+			schema: [],
+			messages: {
+				dynamicRequire: "`require()` argument must be a string literal or an array of string literals.",
+				dynamicRequireElement: "All elements of a `require()` dependency array must be string literals."
+			}
+		},
+		create: (context) => {
+			return { CallExpression: (node) => {
+				if (!isRequireCall(node) || node.arguments.length === 0) return;
+				const firstArg = node.arguments[0];
+				if (firstArg.type === "Literal") return;
+				if (firstArg.type === "ArrayExpression") {
+					for (const el of firstArg.elements) if (el === null || el.type !== "Literal") context.report({
+						node: el ?? firstArg,
+						messageId: "dynamicRequireElement"
+					});
+					return;
+				}
+				context.report({
+					node: firstArg,
+					messageId: "dynamicRequire"
+				});
+			} };
+		}
+	},
+	"no-extra-deps": {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow more dependency literals than factory parameters.",
+				recommended: true,
+				url: `${homepage}/blob/main/docs/rules/${path.basename(import.meta.filename, ".ts")}.md`
+			},
+			schema: [{
+				type: "object",
+				properties: { ignoreValueFactory: {
+					type: "boolean",
+					default: true
+				} },
+				additionalProperties: false
+			}],
+			defaultOptions: [{ ignoreValueFactory: true }],
+			messages: { extraDep: "Dependency '{{dep}}' has no corresponding factory parameter. Add a parameter or remove the dependency." }
+		},
+		create: (context) => {
+			const { ignoreValueFactory } = context.options[0] ?? {};
+			return { "CallExpression[callee.name=define]": (node) => {
+				const def = getDefineCall(node);
+				const hasValueFactory = def?.args.factory.type === "ObjectExpression";
+				if (!def?.depAnalysis || hasValueFactory && ignoreValueFactory) return;
+				for (const name of def.depAnalysis.extraNames) context.report({
+					node: name,
+					messageId: "extraDep",
+					data: { dep: String(name.value) }
+				});
+			} };
+		}
+	},
+	"no-extra-params": {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow more factory parameters than dependency literals.",
+				recommended: true,
+				url: `${homepage}/blob/main/docs/rules/${path.basename(import.meta.filename, ".ts")}.md`
+			},
+			schema: [],
+			messages: {
+				extraIdentParam: "Factory parameter '{{param}}' has no corresponding dependency literal. Add a dependency or remove the parameter.",
+				extraNonIdentParam: "Factory parameter has no corresponding dependency literal. Add a dependency or remove the parameter."
+			}
+		},
+		create: (context) => {
+			return { "CallExpression[callee.name=define]": (node) => {
+				const def = getDefineCall(node);
+				if (!def?.depAnalysis) return;
+				for (const param of def.depAnalysis.extraParams) if (param.type === "Identifier") context.report({
+					node: param,
+					messageId: "extraIdentParam",
+					data: { param: param.name }
+				});
+				else context.report({
+					node: param,
+					messageId: "extraNonIdentParam"
+				});
+			} };
+		}
+	},
+	"no-invalid-define": {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow `define()` calls that do not match a valid AMD module signature.",
+				recommended: true,
+				url: `${homepage}/blob/main/docs/rules/${path.basename(import.meta.filename, ".ts")}.md`
+			},
+			schema: [],
+			messages: { invalidDefine: "`define()` call does not match a valid signature." }
+		},
+		create: (context) => {
+			return { "CallExpression[callee.name=define]": (node) => {
+				if (!getDefineCall(node)) context.report({
+					node,
+					messageId: "invalidDefine"
+				});
+			} };
+		}
+	},
+	"no-module-extensions": {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow file extensions in AMD dependency paths.",
+				recommended: true,
+				url: `${homepage}/blob/main/docs/rules/${path.basename(import.meta.filename, ".ts")}.md`
+			},
+			schema: [{ oneOf: [{
+				type: "object",
+				properties: {
+					blacklist: {
+						type: "array",
+						items: { type: "string" },
+						minItems: 1,
+						uniqueItems: true,
+						description: "Extensions disallowed in dependency paths. If set, all other extensions are allowed."
+					},
+					whitelist: {
+						type: "array",
+						items: { type: "string" },
+						minItems: 1,
+						uniqueItems: true,
+						description: "Extensions allowed in dependency paths. If set, all other extensions are disallowed and any `blacklist` is ignored."
+					}
+				},
+				additionalProperties: false
+			}] }],
+			messages: {
+				blacklistedDefault: "Dependency '{{dep}}' should not include a file extension.",
+				blacklisted: "Dependency '{{dep}}' should not include a blacklisted file extension.",
+				notWhitelisted: "Dependency '{{dep}}' includes a non-whitelisted file extension."
+			}
+		},
+		create: (context) => {
+			const { blacklist, whitelist } = context.options[0] ?? {};
+			return { "CallExpression[callee.name=define]": (node) => {
+				const def = getDefineCall(node);
+				if (!def?.args.dependencies) return;
+				for (const el of def.args.dependencies.elements) {
+					const literal = el;
+					const dep = literal.value;
+					if (!/(\.\w+)+$/.test(dep)) continue;
+					if (whitelist && whitelist.length > 0) {
+						if (!whitelist.some((ext) => dep.endsWith(ext))) context.report({
+							node: literal,
+							messageId: "notWhitelisted",
+							data: { dep }
+						});
+						continue;
+					}
+					const isDefaultBlacklist = !blacklist;
+					if (isDefaultBlacklist || blacklist.some((ext) => dep.endsWith(ext))) context.report({
+						node: literal,
+						messageId: isDefaultBlacklist ? "blacklistedDefault" : "blacklisted",
+						data: { dep }
+					});
+				}
+			} };
+		}
+	},
+	"no-name": {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow named AMD modules.",
+				recommended: true,
+				url: `${homepage}/blob/main/docs/rules/${path.basename(import.meta.filename, ".ts")}.md`
+			},
+			schema: [],
+			messages: { noAmdName: "AMD module should be anonymous. Remove the name argument '{{name}}' from the `define()` call." }
+		},
+		create: (context) => {
+			return { "CallExpression[callee.name=define]": (node) => {
+				const def = getDefineCall(node);
+				if (!def) return;
+				if (def.args.name) context.report({
+					node: def.args.name,
+					messageId: "noAmdName",
+					data: { name: def.args.name.value }
+				});
+			} };
+		}
+	},
+	"sorted-deps": {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce alphabetical ordering of `define()` dependency literals.",
+				url: `${homepage}/blob/main/docs/rules/${path.basename(import.meta.filename, ".ts")}.md`
+			},
+			schema: [{
+				type: "object",
+				properties: { order: {
+					type: "string",
+					enum: ["asc", "desc"],
+					default: "asc"
+				} },
+				additionalProperties: false
+			}],
+			defaultOptions: [{ order: "asc" }],
+			messages: { wrongOrder: "Dependencies should be sorted in {{order}} order." }
+		},
+		create: (context) => {
+			const { order } = context.options[0] ?? {};
+			return { "CallExpression[callee.name=define]": (node) => {
+				const deps = getDefineCall(node)?.args.dependencies;
+				const els = deps?.elements;
+				if (!deps || !els) return;
+				for (let i = 1; i < els.length; i++) {
+					const prevEl = els[i - 1];
+					const currEl = els[i];
+					const prevDep = prevEl.value;
+					const currDep = currEl.value;
+					if (order === "asc" ? currDep < prevDep : currDep > prevDep) context.report({
+						node: deps,
+						messageId: "wrongOrder",
+						data: { order: order === "asc" ? "alphabetical" : `reverse alphabetical` }
+					});
+				}
+			} };
+		}
+	}
+};
+//#endregion
+//#region lib/index.ts
+const plugin = {
+	meta: {
+		name,
+		version
+	},
+	rules: rules_default,
+	configs: {}
+};
+const defaults = {
+	plugins: { amd: plugin },
+	languageOptions: {
+		sourceType: "commonjs",
+		globals: { ...globals.amd }
+	}
+};
+plugin.configs.all = [{
+	...defaults,
+	rules: Object.fromEntries(Object.entries(rules_default).map(entryToConfigArray))
+}];
+plugin.configs.recommended = [{
+	...defaults,
+	rules: Object.fromEntries(Object.entries(rules_default).filter(([, rule]) => rule.meta?.docs?.recommended).map(entryToConfigArray))
+}];
+function entryToConfigArray([name, rule]) {
+	return [`amd/${name}`, rule.meta?.type === "problem" ? "error" : "warn"];
+}
+//#endregion
+export { plugin as default };