eslint-plugin-discordjs 0.0.1

package/dist/index.cjs

@@ -0,0 +1,861 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+let typescript = require("typescript");
+
+//#region src/createRule.ts
+const createRule = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/seedcord/seedcord/blob/next/packages/eslint-plugin-discordjs/docs/rules/${name}.md`);
+
+//#endregion
+//#region ../eslint-utils/dist/index.mjs
+function isFromDiscordJs(symbol) {
+	const file = symbol?.declarations?.[0]?.getSourceFile().fileName;
+	return file !== void 0 && (file.includes("/discord.js/") || file.includes("/@discordjs/"));
+}
+function asClassOrInterface(type) {
+	if (type.isClassOrInterface()) return type;
+	const target = type.target;
+	if (target !== void 0 && target !== type && target.isClassOrInterface()) return target;
+}
+function walkBaseChain(checker, type, match) {
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [type];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (current === void 0 || seen.has(current)) continue;
+		seen.add(current);
+		if (current.isUnionOrIntersection()) {
+			stack.push(...current.types);
+			continue;
+		}
+		const symbol = current.getSymbol();
+		if (symbol !== void 0 && match(symbol)) return true;
+		const iface = asClassOrInterface(current);
+		if (iface !== void 0) stack.push(...checker.getBaseTypes(iface));
+	}
+	return false;
+}
+function extendsDjsType(checker, type, names) {
+	const wanted = typeof names === "string" ? new Set([names]) : names;
+	return walkBaseChain(checker, type, (symbol) => wanted.has(symbol.getName()) && isFromDiscordJs(symbol));
+}
+function booleanLiteralValue(checker, type) {
+	if ((type.flags & typescript.TypeFlags.BooleanLiteral) === 0) return void 0;
+	return checker.typeToString(type) === "true";
+}
+function extendsSeedcordType(checker, type, names) {
+	const wanted = typeof names === "string" ? new Set([names]) : names;
+	return walkBaseChain(checker, type, (symbol) => wanted.has(symbol.getName()));
+}
+function methodName(call) {
+	const { callee } = call;
+	if (callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || callee.computed) return void 0;
+	if (callee.property.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return void 0;
+	return callee.property.name;
+}
+function isChainTop(node) {
+	const { parent } = node;
+	return parent.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || parent.object !== node;
+}
+function collectChain(top) {
+	const calls = [];
+	let current = top;
+	while (current.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && current.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) {
+		calls.push(current);
+		current = current.callee.object;
+	}
+	return calls;
+}
+function chainRoot(top) {
+	let current = top;
+	while (current.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && current.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) current = current.callee.object;
+	return current;
+}
+function resolveConstInit(sourceCode, identifier) {
+	const variable = sourceCode.getScope(identifier).references.find((ref) => ref.identifier === identifier)?.resolved;
+	const definition = variable?.defs[0];
+	if (definition?.node.type !== _typescript_eslint_utils.AST_NODE_TYPES.VariableDeclarator) return void 0;
+	if (variable?.references.some((ref) => ref.isWrite() && !ref.init)) return void 0;
+	return definition.node.init ?? void 0;
+}
+function propertyKeyIs(prop, name) {
+	if (prop.computed) return false;
+	const { key } = prop;
+	if (key.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return key.name === name;
+	return key.value === name;
+}
+function getProperty(node, name) {
+	return node.properties.find((prop) => prop.type === _typescript_eslint_utils.AST_NODE_TYPES.Property && propertyKeyIs(prop, name));
+}
+function unwrapAssertions(expr) {
+	let current = expr;
+	while (current.type === _typescript_eslint_utils.AST_NODE_TYPES.TSAsExpression || current.type === _typescript_eslint_utils.AST_NODE_TYPES.TSTypeAssertion || current.type === _typescript_eslint_utils.AST_NODE_TYPES.TSSatisfiesExpression) current = current.expression;
+	return current;
+}
+const V2_BUILDERS = new Set([
+	"ContainerBuilder",
+	"SectionBuilder",
+	"TextDisplayBuilder",
+	"MediaGalleryBuilder",
+	"FileBuilder",
+	"SeparatorBuilder",
+	"ThumbnailBuilder"
+]);
+function isV2Type(type, checker) {
+	return extendsDjsType(checker, type, V2_BUILDERS);
+}
+function arrayHoldsV2(type, checker) {
+	const elementType = type?.getNumberIndexType();
+	return elementType !== void 0 && isV2Type(elementType, checker);
+}
+function componentsValueIsV2(value, services, checker) {
+	if (value.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression) return value.elements.some((element) => {
+		if (element === null) return false;
+		if (element.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) return arrayHoldsV2(services.getTypeAtLocation(element.argument), checker);
+		return isV2Type(services.getTypeAtLocation(element), checker);
+	});
+	return arrayHoldsV2(services.getTypeAtLocation(value), checker);
+}
+function hasV2Components(node, services, checker) {
+	let holdsV2 = false;
+	for (const prop of node.properties) if (prop.type === _typescript_eslint_utils.AST_NODE_TYPES.Property && propertyKeyIs(prop, "components")) holdsV2 = componentsValueIsV2(prop.value, services, checker);
+	else if (prop.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) {
+		const symbol = services.getTypeAtLocation(prop.argument).getProperty("components");
+		if (symbol !== void 0) holdsV2 = arrayHoldsV2(checker.getTypeOfSymbol(symbol), checker);
+	}
+	return holdsV2;
+}
+
+//#endregion
+//#region src/rules/discord/no-choices-and-autocomplete.ts
+const OPTION_BUILDERS = new Set([
+	"SlashCommandStringOption",
+	"SlashCommandIntegerOption",
+	"SlashCommandNumberOption"
+]);
+function autocompleteOn(calls, services, checker) {
+	const arg = calls.find((call) => methodName(call) === "setAutocomplete")?.arguments[0];
+	if (arg === void 0) return false;
+	if (arg.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal) return arg.value === true;
+	return booleanLiteralValue(checker, services.getTypeAtLocation(arg)) === true;
+}
+function declaresChoices(calls) {
+	let has = false;
+	for (const call of [...calls].reverse()) {
+		const name = methodName(call);
+		if (name === "addChoices") {
+			if (call.arguments.some((arg) => arg.type !== _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement)) has = true;
+		} else if (name === "setChoices") has = call.arguments.some((arg) => {
+			if (arg.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) return false;
+			if (arg.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression) return arg.elements.some((el) => el !== null && el.type !== _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement);
+			return true;
+		});
+	}
+	return has;
+}
+var no_choices_and_autocomplete_default = createRule({
+	name: "no-choices-and-autocomplete",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow both autocomplete and choices on the same slash option." },
+		messages: { bothSet: "A slash option cannot enable autocomplete and declare choices at once. Building that throws a RangeError." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		return { CallExpression(node) {
+			if (!isChainTop(node)) return;
+			if (!extendsDjsType(checker, services.getTypeAtLocation(chainRoot(node)), OPTION_BUILDERS)) return;
+			const calls = collectChain(node);
+			if (autocompleteOn(calls, services, checker) && declaresChoices(calls)) context.report({
+				node,
+				messageId: "bothSet"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/discord/no-conflicting-button-props.ts
+const BUTTON_STYLE_LINK = 5;
+function setsLinkStyle(call, services) {
+	if (methodName(call) !== "setStyle") return false;
+	const arg = call.arguments[0];
+	if (arg === void 0) return false;
+	if (arg.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && arg.value === BUTTON_STYLE_LINK) return true;
+	if (arg.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && arg.object.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && arg.object.name === "ButtonStyle" && arg.property.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && arg.property.name === "Link") return true;
+	const type = services.getTypeAtLocation(arg);
+	return type.isNumberLiteral() && type.value === BUTTON_STYLE_LINK;
+}
+var no_conflicting_button_props_default = createRule({
+	name: "no-conflicting-button-props",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow conflicting props on a button builder." },
+		messages: {
+			idAndUrl: "A button cannot set both a customId and a url.",
+			linkWithCustomId: "A link button uses a url and cannot have a customId."
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		return { CallExpression(node) {
+			if (!isChainTop(node)) return;
+			if (!extendsDjsType(checker, services.getTypeAtLocation(chainRoot(node)), "ButtonBuilder")) return;
+			const calls = collectChain(node);
+			const hasCustomId = calls.some((call) => methodName(call) === "setCustomId");
+			const hasUrl = calls.some((call) => methodName(call) === "setURL");
+			if (hasCustomId && hasUrl) context.report({
+				node,
+				messageId: "idAndUrl"
+			});
+			else if (hasCustomId && calls.some((call) => setsLinkStyle(call, services))) context.report({
+				node,
+				messageId: "linkWithCustomId"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/discord/no-discord-limit-exceeded.ts
+const LIMITS = [
+	{
+		builders: new Set(["ActionRowBuilder"]),
+		addMethod: "addComponents",
+		setMethod: "setComponents",
+		cap: 5,
+		detail: "An action row holds at most 5 components"
+	},
+	{
+		builders: new Set(["StringSelectMenuBuilder"]),
+		addMethod: "addOptions",
+		setMethod: "setOptions",
+		cap: 25,
+		detail: "A select menu holds at most 25 options"
+	},
+	{
+		builders: new Set(["EmbedBuilder"]),
+		addMethod: "addFields",
+		setMethod: "setFields",
+		cap: 25,
+		detail: "An embed holds at most 25 fields"
+	},
+	{
+		builders: new Set([
+			"SlashCommandStringOption",
+			"SlashCommandIntegerOption",
+			"SlashCommandNumberOption"
+		]),
+		addMethod: "addChoices",
+		setMethod: "setChoices",
+		cap: 25,
+		detail: "A slash option holds at most 25 choices"
+	}
+];
+function tupleLength(type, checker) {
+	if (!checker.isTupleType(type)) return void 0;
+	const reference = type;
+	const target = reference.target;
+	const length = checker.getTypeArguments(reference).length;
+	return target.minLength === length ? length : void 0;
+}
+function spreadCount(spread, services, checker) {
+	return tupleLength(services.getTypeAtLocation(spread.argument), checker);
+}
+function arrayLength(array, services, checker) {
+	let count = 0;
+	for (const element of array.elements) if (element?.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) {
+		const arity = spreadCount(element, services, checker);
+		if (arity === void 0) return void 0;
+		count += arity;
+	} else count += 1;
+	return count;
+}
+function countStaticItems(calls, limit, services, checker) {
+	let count = 0;
+	let matched = false;
+	for (const call of [...calls].reverse()) {
+		const name = methodName(call);
+		if (name === limit.addMethod) {
+			matched = true;
+			for (const arg of call.arguments) if (arg.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) {
+				const arity = spreadCount(arg, services, checker);
+				if (arity === void 0) return void 0;
+				count += arity;
+			} else count += 1;
+		} else if (name === limit.setMethod) {
+			matched = true;
+			const arg = call.arguments[0];
+			const length = arg?.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression ? arrayLength(arg, services, checker) : arg !== void 0 && arg.type !== _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement ? tupleLength(services.getTypeAtLocation(arg), checker) : void 0;
+			if (length === void 0) return void 0;
+			count = length;
+		}
+	}
+	return matched ? count : void 0;
+}
+var no_discord_limit_exceeded_default = createRule({
+	name: "no-discord-limit-exceeded",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow exceeding a Discord builder limit with a statically-known number of items." },
+		messages: { tooMany: "{{detail}}. This chain declares {{count}}." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		return { CallExpression(node) {
+			if (!isChainTop(node)) return;
+			const calls = collectChain(node);
+			const methods = new Set(calls.map((call) => methodName(call)));
+			if (!LIMITS.some((limit) => methods.has(limit.addMethod) || methods.has(limit.setMethod))) return;
+			const type = services.getTypeAtLocation(chainRoot(node));
+			const limit = LIMITS.find((entry) => extendsDjsType(checker, type, entry.builders));
+			if (!limit) return;
+			const count = countStaticItems(calls, limit, services, checker);
+			if (count !== void 0 && count > limit.cap) context.report({
+				node,
+				messageId: "tooMany",
+				data: {
+					detail: limit.detail,
+					count
+				}
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/discord/no-mixed-message-format.ts
+const CONTENT_FIELDS = [
+	"content",
+	"embeds",
+	"poll",
+	"stickers",
+	"sticker_ids"
+];
+function isDefinitelyUndefined(type) {
+	return (type.flags & typescript.TypeFlags.Undefined) !== 0;
+}
+var no_mixed_message_format_default = createRule({
+	name: "no-mixed-message-format",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow a message that mixes builder components with content, embeds, poll, or stickers." },
+		messages: { mixedFormat: "A message cannot mix builder components with content, embeds, poll, or stickers. Discord rejects the payload." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		function spreadHasContent(node) {
+			for (const prop of node.properties) {
+				if (prop.type !== _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) continue;
+				const type = services.getTypeAtLocation(prop.argument);
+				if (CONTENT_FIELDS.some((name) => {
+					const symbol = type.getProperty(name);
+					if (symbol === void 0 || (symbol.flags & typescript.SymbolFlags.Optional) !== 0) return false;
+					return !isDefinitelyUndefined(checker.getTypeOfSymbol(symbol));
+				})) return true;
+			}
+			return false;
+		}
+		function hasContentField(node) {
+			return CONTENT_FIELDS.some((name) => {
+				const prop = getProperty(node, name);
+				return prop !== void 0 && !isDefinitelyUndefined(services.getTypeAtLocation(prop.value));
+			}) || spreadHasContent(node);
+		}
+		return { ObjectExpression(node) {
+			if (hasV2Components(node, services, checker) && hasContentField(node)) context.report({
+				node,
+				messageId: "mixedFormat"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/discord/prefer-ephemeral-flag.ts
+const REPLY_METHODS = new Set([
+	"reply",
+	"deferReply",
+	"followUp"
+]);
+function propertyName(property) {
+	if (property.type !== _typescript_eslint_utils.AST_NODE_TYPES.Property || property.computed) return void 0;
+	if (property.key.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return property.key.name;
+	return typeof property.key.value === "string" ? property.key.value : void 0;
+}
+function resolveOptions(sourceCode, arg) {
+	if (arg?.type === _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression) return arg;
+	if (arg?.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return void 0;
+	const init = resolveConstInit(sourceCode, arg);
+	return init?.type === _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression ? init : void 0;
+}
+function canReplaceEphemeral(ephemeral, options, messageFlagsAlias) {
+	const hasFlags = options.properties.some((property) => propertyName(property) === "flags");
+	const hasSpread = options.properties.some((property) => property.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement);
+	const isTrue = ephemeral.value.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && ephemeral.value.value === true;
+	return messageFlagsAlias !== void 0 && !hasFlags && !hasSpread && isTrue;
+}
+function destructuredReply(node, sourceCode) {
+	if (node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return void 0;
+	const calleeId = node.callee;
+	const def = (sourceCode.getScope(node).references.find((ref) => ref.identifier === calleeId)?.resolved)?.defs[0];
+	if (def?.node.type !== _typescript_eslint_utils.AST_NODE_TYPES.VariableDeclarator) return void 0;
+	const { id: pattern, init } = def.node;
+	if (pattern.type !== _typescript_eslint_utils.AST_NODE_TYPES.ObjectPattern || !init) return void 0;
+	const prop = pattern.properties.find((p) => p.type === _typescript_eslint_utils.AST_NODE_TYPES.Property && !p.computed && p.key.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && p.value.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && p.value.name === calleeId.name);
+	if (prop?.key.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return void 0;
+	return {
+		name: prop.key.name,
+		init
+	};
+}
+var prefer_ephemeral_flag_default = createRule({
+	name: "prefer-ephemeral-flag",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Disallow the deprecated ephemeral reply option in favor of MessageFlags.Ephemeral." },
+		messages: { deprecated: "The ephemeral reply option is deprecated. Use flags: MessageFlags.Ephemeral." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		let messageFlagsAlias;
+		return {
+			ImportDeclaration(node) {
+				if (node.source.value !== "discord.js") return;
+				for (const spec of node.specifiers) if (spec.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && spec.imported.name === "MessageFlags") messageFlagsAlias = spec.local.name;
+			},
+			CallExpression(node) {
+				let name;
+				let receiverType;
+				if (node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) {
+					name = methodName(node);
+					receiverType = services.getTypeAtLocation(node.callee.object);
+				} else {
+					const reply = destructuredReply(node, context.sourceCode);
+					name = reply?.name;
+					receiverType = reply ? services.getTypeAtLocation(reply.init) : void 0;
+				}
+				if (name === void 0 || !REPLY_METHODS.has(name) || receiverType === void 0) return;
+				if (!extendsDjsType(checker, receiverType, "BaseInteraction")) return;
+				const options = resolveOptions(context.sourceCode, node.arguments[0]);
+				if (options === void 0) return;
+				const ephemeral = options.properties.find((property) => propertyName(property) === "ephemeral");
+				if (ephemeral?.type !== _typescript_eslint_utils.AST_NODE_TYPES.Property) return;
+				const canFix = canReplaceEphemeral(ephemeral, options, messageFlagsAlias);
+				context.report({
+					node: ephemeral,
+					messageId: "deprecated",
+					fix: canFix ? (fixer) => fixer.replaceText(ephemeral, `flags: ${messageFlagsAlias}.Ephemeral`) : null
+				});
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/discord/prefer-v2-component.ts
+var prefer_v2_component_default = createRule({
+	name: "prefer-v2-component",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer a components v2 layout over a legacy embed." },
+		messages: { preferV2: "Prefer a components v2 layout (ContainerBuilder, TextDisplayBuilder) over an embed." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		return {
+			NewExpression(node) {
+				if (extendsDjsType(checker, services.getTypeAtLocation(node), "EmbedBuilder")) context.report({
+					node,
+					messageId: "preferV2"
+				});
+			},
+			CallExpression(node) {
+				if (node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
+				if (node.callee.property.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier || node.callee.property.name !== "from") return;
+				if (extendsDjsType(checker, services.getTypeAtLocation(node.callee.object), "EmbedBuilder")) context.report({
+					node,
+					messageId: "preferV2"
+				});
+			},
+			ClassDeclaration(node) {
+				if (!node.superClass || !node.id) return;
+				const symbol = services.getSymbolAtLocation(node.id);
+				if (!symbol) return;
+				const classType = checker.getDeclaredTypeOfSymbol(symbol);
+				if (!extendsSeedcordType(checker, classType, "BuilderComponent")) return;
+				const component = classType.getProperty("component");
+				if (!component) return;
+				const componentSymbol = checker.getTypeOfSymbolAtLocation(component, services.esTreeNodeToTSNodeMap.get(node)).getSymbol();
+				if (componentSymbol?.getName() === "EmbedBuilder" && isFromDiscordJs(componentSymbol)) context.report({
+					node: node.id,
+					messageId: "preferV2"
+				});
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/discord/require-components-v2-flag.ts
+const IS_COMPONENTS_V2 = 32768;
+function combine(states) {
+	const [first] = states;
+	if (first === void 0) return "unknown";
+	return states.every((state) => state === first) ? first : "unknown";
+}
+function bitState(value) {
+	return (value & IS_COMPONENTS_V2) === 0 ? "absent" : "present";
+}
+function flagTypeState(type) {
+	if (type === void 0) return "unknown";
+	if (type.isUnion()) return combine(type.types.map(flagTypeState));
+	if (type.isNumberLiteral()) return bitState(type.value);
+	if (type.isStringLiteral()) {
+		if (type.value === "IsComponentsV2") return "present";
+		if (/^\d+$/u.test(type.value)) return bitState(Number(type.value));
+		return "absent";
+	}
+	const element = type.getNumberIndexType();
+	if (element !== void 0) return flagTypeState(element);
+	return "unknown";
+}
+function applyBitwise(operator, left, right) {
+	switch (operator) {
+		case "|": return left | right;
+		case "&": return left & right;
+		case "^": return left ^ right;
+		case "<<": return left << right;
+		case ">>": return left >> right;
+		case ">>>": return left >>> right;
+		default: return;
+	}
+}
+function foldToNumber(node, services) {
+	switch (node.type) {
+		case _typescript_eslint_utils.AST_NODE_TYPES.Literal: return typeof node.value === "number" ? node.value : void 0;
+		case _typescript_eslint_utils.AST_NODE_TYPES.TSAsExpression: return foldToNumber(node.expression, services);
+		case _typescript_eslint_utils.AST_NODE_TYPES.UnaryExpression: {
+			const value = foldToNumber(node.argument, services);
+			if (value === void 0) return void 0;
+			if (node.operator === "-") return -value;
+			if (node.operator === "~") return ~value;
+			if (node.operator === "+") return value;
+			return;
+		}
+		case _typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression: {
+			const left = foldToNumber(node.left, services);
+			const right = foldToNumber(node.right, services);
+			if (left === void 0 || right === void 0) return void 0;
+			return applyBitwise(node.operator, left, right);
+		}
+		case _typescript_eslint_utils.AST_NODE_TYPES.Identifier:
+		case _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression: {
+			const type = services.getTypeAtLocation(node);
+			return type.isNumberLiteral() ? type.value : void 0;
+		}
+		default: return;
+	}
+}
+function elementState(node, services) {
+	const folded = foldToNumber(node, services);
+	if (folded !== void 0) return bitState(folded);
+	return flagTypeState(services.getTypeAtLocation(node));
+}
+function flagValueState(value, services) {
+	if (value.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression) {
+		const states = new Set(value.elements.map((element) => {
+			if (element === null) return "absent";
+			if (element.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) return flagTypeState(services.getTypeAtLocation(element.argument).getNumberIndexType());
+			return elementState(element, services);
+		}));
+		if (states.has("present")) return "present";
+		return states.has("unknown") ? "unknown" : "absent";
+	}
+	return elementState(value, services);
+}
+function flagState(node, services, checker) {
+	let state = "absent";
+	for (const prop of node.properties) if (prop.type === _typescript_eslint_utils.AST_NODE_TYPES.Property && propertyKeyIs(prop, "flags")) state = flagValueState(prop.value, services);
+	else if (prop.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) {
+		const symbol = services.getTypeAtLocation(prop.argument).getProperty("flags");
+		if (symbol !== void 0) state = flagTypeState(checker.getTypeOfSymbol(symbol));
+	}
+	return state;
+}
+function isMessageOptionsType(type) {
+	if (type.isUnion()) return type.types.some(isMessageOptionsType);
+	const components = type.getProperty("components");
+	const flags = type.getProperty("flags");
+	return components !== void 0 && flags !== void 0 && isFromDiscordJs(components) && isFromDiscordJs(flags);
+}
+var require_components_v2_flag_default = createRule({
+	name: "require-components-v2-flag",
+	meta: {
+		type: "problem",
+		docs: { description: "Require the IsComponentsV2 flag on a message that uses v2 builder components." },
+		messages: { missingFlag: "A message using v2 builder components must set flags: MessageFlags.IsComponentsV2. Discord rejects the payload otherwise." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		const reportedInits = /* @__PURE__ */ new Set();
+		function payloadViolates(node) {
+			return hasV2Components(node, services, checker) && flagState(node, services, checker) === "absent";
+		}
+		function contextualType(node) {
+			return checker.getContextualType(services.esTreeNodeToTSNodeMap.get(node));
+		}
+		return {
+			ObjectExpression(node) {
+				if (!payloadViolates(node)) return;
+				const contextual = contextualType(node);
+				if (contextual === void 0 || !isMessageOptionsType(contextual)) return;
+				context.report({
+					node,
+					messageId: "missingFlag"
+				});
+			},
+			CallExpression(node) {
+				for (const arg of node.arguments) {
+					if (arg.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) continue;
+					const init = resolveConstInit(context.sourceCode, arg);
+					if (init?.type !== _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression) continue;
+					if (contextualType(init) !== void 0) continue;
+					if (reportedInits.has(init)) continue;
+					const contextual = contextualType(arg);
+					if (contextual === void 0 || !isMessageOptionsType(contextual)) continue;
+					if (payloadViolates(init)) {
+						reportedInits.add(init);
+						context.report({
+							node: init,
+							messageId: "missingFlag"
+						});
+					}
+				}
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/discord/required-option-before-optional.ts
+const SLASH_COMMAND_BUILDERS = new Set(["SlashCommandBuilder", "SlashCommandSubcommandBuilder"]);
+const ADD_OPTION = new Set([
+	"addStringOption",
+	"addIntegerOption",
+	"addBooleanOption",
+	"addUserOption",
+	"addChannelOption",
+	"addRoleOption",
+	"addMentionableOption",
+	"addNumberOption",
+	"addAttachmentOption"
+]);
+function optionChain(callback) {
+	if (callback?.type !== _typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression && callback?.type !== _typescript_eslint_utils.AST_NODE_TYPES.FunctionExpression) return;
+	if (callback.body.type !== _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return callback.body;
+	for (const statement of callback.body.body) if (statement.type === _typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return statement.argument ?? void 0;
+}
+function optionRequiredState(callback, services, checker) {
+	const chain = optionChain(callback);
+	if (chain?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return "unknown";
+	const setRequired = collectChain(chain).find((call) => methodName(call) === "setRequired");
+	if (!setRequired) return "optional";
+	const arg = setRequired.arguments[0];
+	if (arg?.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof arg.value === "boolean") return arg.value ? "required" : "optional";
+	if (arg === void 0 || arg.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) return "unknown";
+	const value = booleanLiteralValue(checker, services.getTypeAtLocation(arg));
+	if (value === void 0) return "unknown";
+	return value ? "required" : "optional";
+}
+var required_option_before_optional_default = createRule({
+	name: "required-option-before-optional",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow a required slash option after an optional one." },
+		messages: { outOfOrder: "A required slash option cannot come after an optional one." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		return { CallExpression(node) {
+			if (!isChainTop(node)) return;
+			if (!extendsDjsType(checker, services.getTypeAtLocation(chainRoot(node)), SLASH_COMMAND_BUILDERS)) return;
+			const options = collectChain(node).filter((call) => ADD_OPTION.has(methodName(call) ?? "")).reverse().map((call) => ({
+				call,
+				state: optionRequiredState(call.arguments[0], services, checker)
+			}));
+			if (options.length < 2) return;
+			if (options.some((option) => option.state === "unknown")) return;
+			let seenOptional = false;
+			for (const { call, state } of options) if (state === "optional") seenOptional = true;
+			else if (seenOptional) {
+				const target = call.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? call.callee.property : call;
+				context.report({
+					node: target,
+					messageId: "outOfOrder"
+				});
+				return;
+			}
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/discord/select-menu-min-exceeds-max.ts
+function lastCall(calls, name) {
+	return calls.find((call) => methodName(call) === name);
+}
+function staticNumber(arg, services) {
+	if (arg === void 0 || arg.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) return void 0;
+	const target = unwrapAssertions(arg);
+	if (target.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof target.value === "number") return target.value;
+	const type = services.getTypeAtLocation(target);
+	return type.isNumberLiteral() ? type.value : void 0;
+}
+var select_menu_min_exceeds_max_default = createRule({
+	name: "select-menu-min-exceeds-max",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow a select menu whose minimum selections exceed its maximum." },
+		messages: { minOverMax: "setMinValues({{min}}) is greater than setMaxValues({{max}}). Discord rejects the select menu." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		return { CallExpression(node) {
+			if (!isChainTop(node)) return;
+			const calls = collectChain(node);
+			const minCall = lastCall(calls, "setMinValues");
+			const maxCall = lastCall(calls, "setMaxValues");
+			if (minCall === void 0 || maxCall === void 0) return;
+			if (!extendsDjsType(checker, services.getTypeAtLocation(chainRoot(node)), "BaseSelectMenuBuilder")) return;
+			const min = staticNumber(minCall.arguments[0], services);
+			const max = staticNumber(maxCall.arguments[0], services);
+			if (min === void 0 || max === void 0 || min <= max) return;
+			const target = minCall.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? minCall.callee.property : minCall;
+			context.report({
+				node: target,
+				messageId: "minOverMax",
+				data: {
+					min,
+					max
+				}
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/discord/valid-command-name.ts
+const SLASH_BUILDERS = new Set([
+	"SlashCommandBuilder",
+	"SlashCommandSubcommandBuilder",
+	"SlashCommandSubcommandGroupBuilder",
+	"SlashCommandStringOption",
+	"SlashCommandIntegerOption",
+	"SlashCommandNumberOption",
+	"SlashCommandBooleanOption",
+	"SlashCommandUserOption",
+	"SlashCommandChannelOption",
+	"SlashCommandRoleOption",
+	"SlashCommandMentionableOption",
+	"SlashCommandAttachmentOption"
+]);
+function isValidChatInputName(name) {
+	return /^[\p{Ll}\p{Lm}\p{Lo}\p{N}\p{sc=Devanagari}\p{sc=Thai}_-]{1,32}$/u.test(name);
+}
+function staticName(arg) {
+	if (arg.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof arg.value === "string") return arg.value;
+	if (arg.type === _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral && arg.expressions.length === 0) return arg.quasis[0]?.value.cooked ?? void 0;
+}
+var valid_command_name_default = createRule({
+	name: "valid-command-name",
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce Discord chat-input name rules on slash command and option names." },
+		messages: { invalidName: "This name is not a valid chat-input name. Use lowercase letters, digits, hyphens, or underscores, 1 to 32 characters." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const services = _typescript_eslint_utils.ESLintUtils.getParserServices(context);
+		return { CallExpression(node) {
+			if (methodName(node) !== "setName") return;
+			const arg = node.arguments[0];
+			if (arg === void 0) return;
+			let name = staticName(arg);
+			if (name === void 0 && (arg.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier || arg.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression)) {
+				const argType = services.getTypeAtLocation(arg);
+				if (argType.isStringLiteral()) name = argType.value;
+			}
+			if (name === void 0 || isValidChatInputName(name)) return;
+			if (node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
+			if (!extendsDjsType(services.program.getTypeChecker(), services.getTypeAtLocation(node.callee.object), SLASH_BUILDERS)) return;
+			context.report({
+				node: arg,
+				messageId: "invalidName"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/index.ts
+const rules = {
+	"no-choices-and-autocomplete": no_choices_and_autocomplete_default,
+	"no-conflicting-button-props": no_conflicting_button_props_default,
+	"no-discord-limit-exceeded": no_discord_limit_exceeded_default,
+	"no-mixed-message-format": no_mixed_message_format_default,
+	"prefer-ephemeral-flag": prefer_ephemeral_flag_default,
+	"prefer-v2-component": prefer_v2_component_default,
+	"require-components-v2-flag": require_components_v2_flag_default,
+	"required-option-before-optional": required_option_before_optional_default,
+	"select-menu-min-exceeds-max": select_menu_min_exceeds_max_default,
+	"valid-command-name": valid_command_name_default
+};
+const plugin = {
+	meta: {
+		name: "eslint-plugin-discordjs",
+		version: "0.0.1"
+	},
+	rules
+};
+const WARN_RULES = new Set(["prefer-ephemeral-flag", "prefer-v2-component"]);
+const presetRules = {};
+for (const name of Object.keys(rules)) presetRules[`discordjs/${name}`] = WARN_RULES.has(name) ? "warn" : "error";
+const recommended = {
+	plugins: { discordjs: plugin },
+	rules: presetRules
+};
+plugin.configs = { recommended };
+
+//#endregion
+exports.default = plugin;
+exports.recommended = recommended;
+//# sourceMappingURL=index.cjs.map