@vue-jsx/eslint 3.3.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 zhiyuanzmj <https://github.com/zhiyuanzmj>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+import { ClassicConfig, Linter } from "@typescript-eslint/utils/ts-eslint";
+
+//#region src/rules/jsx-sort-props/types.d.ts
+interface JsxSortPropsSchema0 {
+  callbacksLast?: boolean;
+  shorthandFirst?: boolean;
+  shorthandLast?: boolean;
+  multiline?: 'ignore' | 'first' | 'last';
+  ignoreCase?: boolean;
+  noSortAlphabetically?: boolean;
+  reservedFirst?: string[] | boolean;
+  reservedLast?: string[];
+  locale?: string;
+}
+type JsxSortPropsRuleOptions = [JsxSortPropsSchema0?];
+type MessageIds$1 = 'listIsEmpty' | 'listReservedPropsFirst' | 'listReservedPropsLast' | 'listCallbacksLast' | 'listShorthandFirst' | 'listShorthandLast' | 'listMultilineFirst' | 'listMultilineLast' | 'sortPropsByAlpha';
+//#endregion
+//#region src/rules/define-style/types.d.ts
+interface DefineStyleSchema0 {
+  tabWidth?: number;
+}
+type DefineStyleRuleOptions = [DefineStyleSchema0?];
+type MessageIds = 'define-style' | 'define-style-syntax-error';
+//#endregion
+//#region src/rules/index.d.ts
+declare const ruleOptions: {
+  'jsx-sort-props': _$_typescript_eslint_utils_ts_eslint0.RuleModule<MessageIds$1, JsxSortPropsRuleOptions, unknown, _$_typescript_eslint_utils_ts_eslint0.RuleListener>;
+  'define-style': _$_typescript_eslint_utils_ts_eslint0.RuleModule<MessageIds, DefineStyleRuleOptions, unknown, _$_typescript_eslint_utils_ts_eslint0.RuleListener>;
+};
+interface RuleOptions {
+  'vue-jsx-vapor/jsx-sort-props': JsxSortPropsRuleOptions;
+  'vue-jsx-vapor/define-style': DefineStyleRuleOptions;
+}
+type Rules = Partial<{ [K in keyof RuleOptions]: Linter.Severity | [Linter.Severity, ...RuleOptions[K]] }>;
+//#endregion
+//#region src/index.d.ts
+declare const plugins: {
+  'vue-jsx-vapor': {
+    rules: {
+      'jsx-sort-props': _$_typescript_eslint_utils_ts_eslint0.RuleModule<MessageIds$1, JsxSortPropsRuleOptions, unknown, _$_typescript_eslint_utils_ts_eslint0.RuleListener>;
+      'define-style': _$_typescript_eslint_utils_ts_eslint0.RuleModule<MessageIds, DefineStyleRuleOptions, unknown, _$_typescript_eslint_utils_ts_eslint0.RuleListener>;
+    };
+  };
+};
+declare const config: (options: ClassicConfig.Config) => Record<string, unknown>;
+//#endregion
+export { type Rules, config as default, plugins, ruleOptions as rules };

package/dist/index.js

@@ -0,0 +1,524 @@
+import prettier from "@prettier/sync";
+//#region src/rules/define-style/index.ts
+const rule$1 = {
+	defaultOptions: [{ tabWidth: 2 }],
+	meta: {
+		type: "layout",
+		docs: { description: "Enforce consistent formatting in defineStyle CSS" },
+		fixable: "code",
+		messages: {
+			"define-style": "Style in defineStyle should be properly formatted",
+			"define-style-syntax-error": "Syntax error in defineStyle"
+		},
+		schema: [{
+			type: "object",
+			properties: { tabWidth: {
+				type: "number",
+				default: 2
+			} }
+		}]
+	},
+	create(context) {
+		const tabWidth = (context.options[0] || {}).tabWidth || 2;
+		return { CallExpression(node) {
+			const callee = node.callee.type === "MemberExpression" ? node.callee.object : node.callee;
+			const parser = node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier" ? node.callee.property.name : "css";
+			if (callee.type === "Identifier" && callee.name === "defineStyle") {
+				const arg = node.arguments[0];
+				if (arg?.type === "TemplateLiteral") {
+					let index = 0;
+					const cssRaw = context.sourceCode.text.slice(arg.range[0] + 1, arg.range[1] - 1);
+					let formattedCss;
+					try {
+						formattedCss = prettier.format(arg.quasis.map((i) => i.value.raw + (arg.expressions[index] ? `-MACROS_START-${context.sourceCode.text.slice(...arg.expressions[index++].range)}-MACROS_END-` : "")).join(""), {
+							parser,
+							tabWidth
+						}).replaceAll("-MACROS_START-", "${").replaceAll("-MACROS_END-", "}");
+					} catch {
+						return context.report({
+							node: arg,
+							messageId: "define-style-syntax-error"
+						});
+					}
+					const line = callee.loc.start.line;
+					function getOffset(node) {
+						if (node.parent?.loc.start.line === line) return getOffset(node.parent);
+						return node.loc.start.column;
+					}
+					const column = getOffset(callee);
+					const placeholder = " ".repeat(column + tabWidth);
+					const result = `\n${placeholder}${formattedCss.slice(0, -1).replaceAll("\n", `\n${placeholder}`)}\n${" ".repeat(column)}`;
+					if (result !== cssRaw) context.report({
+						node: arg,
+						messageId: "define-style",
+						fix(fixer) {
+							return fixer.replaceTextRange([arg.range[0] + 1, arg.range[1] - 1], result);
+						}
+					});
+				}
+			}
+		} };
+	}
+};
+//#endregion
+//#region src/rules/jsx-sort-props/index.ts
+const COMPAT_TAG_REGEX = /^[a-z]/;
+/**
+* Checks if a node represents a DOM element according to React.
+* @param node - JSXOpeningElement to check.
+* @returns Whether or not the node corresponds to a DOM element.
+*/
+function isDOMComponent(node) {
+	const name = getElementType(node);
+	return COMPAT_TAG_REGEX.test(name);
+}
+/**
+* Returns the name of the prop given the JSXAttribute object.
+*
+* Ported from `jsx-ast-utils/propName` to reduce bundle size
+* @see https://github.com/jsx-eslint/jsx-ast-utils/blob/main/src/propName.js
+*/
+function getPropName(prop) {
+	if (!prop.type || prop.type !== "JSXAttribute") throw new Error("The prop must be a JSXAttribute collected by the AST parser.");
+	if (prop.name.type === "JSXNamespacedName") return `${prop.name.namespace.name}:${prop.name.name.name}`;
+	return prop.name.name;
+}
+function resolveMemberExpressions(object, property) {
+	if (object.type === "JSXMemberExpression") return `${resolveMemberExpressions(object.object, object.property)}.${property.name}`;
+	return `${object.name}.${property.name}`;
+}
+/**
+* Returns the tagName associated with a JSXElement.
+*
+* Ported from `jsx-ast-utils/elementType` to reduce bundle size
+* @see https://github.com/jsx-eslint/jsx-ast-utils/blob/main/src/elementType.js
+*/
+function getElementType(node) {
+	if (node.type === "JSXOpeningFragment") return "<>";
+	const { name } = node;
+	if (!name) throw new Error("The argument provided is not a JSXElement node.");
+	if (name.type === "JSXMemberExpression") {
+		const { object, property } = name;
+		return resolveMemberExpressions(object, property);
+	}
+	if (name.type === "JSXNamespacedName") return `${name.namespace.name}:${name.name.name}`;
+	return node.name.name;
+}
+function isCallbackPropName(name) {
+	return /^on[A-Z]/.test(name);
+}
+function isMultilineProp(node) {
+	return node.loc.start.line !== node.loc.end.line;
+}
+const messages = {
+	listIsEmpty: "A customized reserved first list must not be empty",
+	listReservedPropsFirst: "Reserved props must be listed before all other props",
+	listReservedPropsLast: "Reserved props must be listed after all other props",
+	listCallbacksLast: "Callbacks must be listed after all other props",
+	listShorthandFirst: "Shorthand props must be listed before all other props",
+	listShorthandLast: "Shorthand props must be listed after all other props",
+	listMultilineFirst: "Multiline props must be listed before all other props",
+	listMultilineLast: "Multiline props must be listed after all other props",
+	sortPropsByAlpha: "Props should be sorted alphabetically"
+};
+const RESERVED_PROPS_LIST = [
+	"children",
+	"dangerouslySetInnerHTML",
+	"key",
+	"ref"
+];
+function getReservedPropIndex(name, list) {
+	return list.indexOf(name.split(":")[0]);
+}
+let attributeMap;
+function shouldSortToEnd(node) {
+	const attr = attributeMap.get(node);
+	return !!attr && !!attr.hasComment;
+}
+function contextCompare(a, b, options) {
+	let aProp = getPropName(a);
+	let bProp = getPropName(b);
+	const aPropNamespace = aProp.split(":")[0];
+	const bPropNamespace = bProp.split(":")[0];
+	const aSortToEnd = shouldSortToEnd(a);
+	const bSortToEnd = shouldSortToEnd(b);
+	if (aSortToEnd && !bSortToEnd) return 1;
+	if (!aSortToEnd && bSortToEnd) return -1;
+	if (options.reservedFirst) {
+		const aIndex = getReservedPropIndex(aProp, options.reservedList);
+		const bIndex = getReservedPropIndex(bProp, options.reservedList);
+		if (aIndex > -1 && bIndex === -1) return -1;
+		if (aIndex === -1 && bIndex > -1) return 1;
+		if (aIndex > -1 && bIndex > -1 && aPropNamespace !== bPropNamespace) return aIndex > bIndex ? 1 : -1;
+	}
+	if (options.reservedLast.length > 0) {
+		const aLastIndex = getReservedPropIndex(aProp, options.reservedLast);
+		const bLastIndex = getReservedPropIndex(bProp, options.reservedLast);
+		if (aLastIndex > -1 && bLastIndex === -1) return 1;
+		if (aLastIndex === -1 && bLastIndex > -1) return -1;
+		if (aLastIndex > -1 && bLastIndex > -1 && aPropNamespace !== bPropNamespace) return aLastIndex > bLastIndex ? -1 : 1;
+	}
+	if (options.callbacksLast) {
+		const aIsCallback = isCallbackPropName(aProp);
+		const bIsCallback = isCallbackPropName(bProp);
+		if (aIsCallback && !bIsCallback) return 1;
+		if (!aIsCallback && bIsCallback) return -1;
+	}
+	if (options.shorthandFirst || options.shorthandLast) {
+		const shorthandSign = options.shorthandFirst ? -1 : 1;
+		if (!a.value && b.value) return shorthandSign;
+		if (a.value && !b.value) return -shorthandSign;
+	}
+	if (options.multiline !== "ignore") {
+		const multilineSign = options.multiline === "first" ? -1 : 1;
+		const aIsMultiline = isMultilineProp(a);
+		const bIsMultiline = isMultilineProp(b);
+		if (aIsMultiline && !bIsMultiline) return multilineSign;
+		if (!aIsMultiline && bIsMultiline) return -multilineSign;
+	}
+	if (options.noSortAlphabetically) return 0;
+	const actualLocale = options.locale === "auto" ? void 0 : options.locale;
+	if (options.ignoreCase) {
+		aProp = aProp.toLowerCase();
+		bProp = bProp.toLowerCase();
+		return aProp.localeCompare(bProp, actualLocale);
+	}
+	if (aProp === bProp) return 0;
+	if (options.locale === "auto") return aProp < bProp ? -1 : 1;
+	return aProp.localeCompare(bProp, actualLocale);
+}
+/**
+* Create an array of arrays where each subarray is composed of attributes
+* that are considered sortable.
+* @param attributes
+* @param context The context of the rule
+*/
+function getGroupsOfSortableAttributes(attributes, context) {
+	const sourceCode = context.sourceCode;
+	const sortableAttributeGroups = [];
+	let groupCount = 0;
+	function addtoSortableAttributeGroups(attribute) {
+		sortableAttributeGroups[groupCount - 1].push(attribute);
+	}
+	for (let i = 0; i < attributes.length; i++) {
+		const attribute = attributes[i];
+		const nextAttribute = attributes[i + 1];
+		const attributeline = attribute.loc.start.line;
+		let comment = [];
+		try {
+			comment = sourceCode.getCommentsAfter(attribute);
+		} catch {}
+		const lastAttr = attributes[i - 1];
+		const attrIsSpread = attribute.type === "JSXSpreadAttribute";
+		if (!lastAttr || lastAttr.type === "JSXSpreadAttribute" && !attrIsSpread) {
+			groupCount += 1;
+			sortableAttributeGroups[groupCount - 1] = [];
+		}
+		if (!attrIsSpread) if (comment.length === 0) {
+			attributeMap.set(attribute, {
+				end: attribute.range[1],
+				hasComment: false
+			});
+			addtoSortableAttributeGroups(attribute);
+		} else {
+			const firstComment = comment[0];
+			const commentline = firstComment.loc.start.line;
+			if (comment.length === 1) {
+				if (attributeline + 1 === commentline && nextAttribute) {
+					attributeMap.set(attribute, {
+						end: nextAttribute.range[1],
+						hasComment: true
+					});
+					addtoSortableAttributeGroups(attribute);
+					i += 1;
+				} else if (attributeline === commentline) {
+					if (firstComment.type === "Block" && nextAttribute) {
+						attributeMap.set(attribute, {
+							end: nextAttribute.range[1],
+							hasComment: true
+						});
+						i += 1;
+					} else if (firstComment.type === "Block") attributeMap.set(attribute, {
+						end: firstComment.range[1],
+						hasComment: true
+					});
+					else attributeMap.set(attribute, {
+						end: firstComment.range[1],
+						hasComment: false
+					});
+					addtoSortableAttributeGroups(attribute);
+				}
+			} else if (comment.length > 1 && attributeline + 1 === comment[1].loc.start.line && nextAttribute) {
+				const commentNextAttribute = sourceCode.getCommentsAfter(nextAttribute);
+				attributeMap.set(attribute, {
+					end: nextAttribute.range[1],
+					hasComment: true
+				});
+				if (commentNextAttribute.length === 1 && nextAttribute.loc.start.line === commentNextAttribute[0].loc.start.line) attributeMap.set(attribute, {
+					end: commentNextAttribute[0].range[1],
+					hasComment: true
+				});
+				addtoSortableAttributeGroups(attribute);
+				i += 1;
+			}
+		}
+	}
+	return sortableAttributeGroups;
+}
+function generateFixerFunction(node, context, reservedList) {
+	const sourceCode = context.sourceCode;
+	const attributes = node.attributes.slice(0);
+	const configuration = context.options[0] || {};
+	const options = {
+		ignoreCase: configuration.ignoreCase || false,
+		callbacksLast: configuration.callbacksLast || false,
+		shorthandFirst: configuration.shorthandFirst || false,
+		shorthandLast: configuration.shorthandLast || false,
+		multiline: configuration.multiline || "ignore",
+		noSortAlphabetically: configuration.noSortAlphabetically || false,
+		reservedFirst: configuration.reservedFirst || false,
+		reservedList,
+		reservedLast: configuration.reservedLast || [],
+		locale: configuration.locale || "auto"
+	};
+	const sortableAttributeGroups = getGroupsOfSortableAttributes(attributes, context);
+	const sortedAttributeGroups = sortableAttributeGroups.slice(0).map((group) => [...group].sort((a, b) => contextCompare(a, b, options)));
+	return function fixFunction(fixer) {
+		const fixers = [];
+		let source = sourceCode.getText();
+		sortableAttributeGroups.forEach((sortableGroup, ii) => {
+			sortableGroup.forEach((attr, jj) => {
+				const sortedAttr = sortedAttributeGroups[ii][jj];
+				const sortedAttrText = source.slice(sortedAttr.range[0], attributeMap.get(sortedAttr).end);
+				fixers.push({
+					range: [attr.range[0], attributeMap.get(attr).end],
+					text: sortedAttrText
+				});
+			});
+		});
+		fixers.sort((a, b) => b.range[0] - a.range[0]);
+		const firstFixer = fixers[0];
+		const lastFixer = fixers.at(-1);
+		const rangeStart = lastFixer ? lastFixer.range[0] : 0;
+		const rangeEnd = firstFixer ? firstFixer.range[1] : -0;
+		fixers.forEach((fix) => {
+			source = `${source.slice(0, fix.range[0])}${fix.text}${source.slice(fix.range[1])}`;
+		});
+		return fixer.replaceTextRange([rangeStart, rangeEnd], source.slice(rangeStart, rangeEnd));
+	};
+}
+/**
+* Checks if the `reservedFirst` option is valid
+* @param context The context of the rule
+* @param reservedFirst The `reservedFirst` option
+* @return {Function|undefined} If an error is detected, a function to generate the error message, otherwise, `undefined`
+*/
+function validateReservedFirstConfig(context, reservedFirst) {
+	if (reservedFirst && Array.isArray(reservedFirst) && reservedFirst.length === 0) return function Report(decl) {
+		context.report({
+			node: decl,
+			messageId: "listIsEmpty"
+		});
+	};
+}
+const reportedNodeAttributes = /* @__PURE__ */ new WeakMap();
+/**
+* Check if the current node attribute has already been reported with the same error type
+* if that's the case then we don't report a new error
+* otherwise we report the error
+* @param nodeAttribute The node attribute to be reported
+* @param errorType The error type to be reported
+* @param node The parent node for the node attribute
+* @param context The context of the rule
+* @param reservedList The list of reserved props
+*/
+function reportNodeAttribute(nodeAttribute, errorType, node, context, reservedList) {
+	const errors = reportedNodeAttributes.get(nodeAttribute) || [];
+	if (errors.includes(errorType)) return;
+	errors.push(errorType);
+	reportedNodeAttributes.set(nodeAttribute, errors);
+	context.report({
+		node: nodeAttribute.name ?? "",
+		messageId: errorType,
+		fix: generateFixerFunction(node, context, reservedList)
+	});
+}
+//#endregion
+//#region src/rules/index.ts
+const ruleOptions = {
+	"jsx-sort-props": {
+		defaultOptions: [{
+			multiline: "ignore",
+			locale: "auto"
+		}],
+		meta: {
+			type: "layout",
+			docs: { description: "Enforce props alphabetical sorting" },
+			fixable: "code",
+			messages,
+			schema: [{
+				type: "object",
+				properties: {
+					callbacksLast: { type: "boolean" },
+					shorthandFirst: { type: "boolean" },
+					shorthandLast: { type: "boolean" },
+					multiline: {
+						type: "string",
+						enum: [
+							"ignore",
+							"first",
+							"last"
+						],
+						default: "ignore"
+					},
+					ignoreCase: { type: "boolean" },
+					noSortAlphabetically: { type: "boolean" },
+					reservedFirst: { type: ["array", "boolean"] },
+					reservedLast: { type: "array" },
+					locale: {
+						type: "string",
+						default: "auto"
+					}
+				},
+				additionalProperties: false
+			}]
+		},
+		create(context) {
+			const configuration = context.options[0] || {};
+			const ignoreCase = configuration.ignoreCase || false;
+			const callbacksLast = configuration.callbacksLast || false;
+			const shorthandFirst = configuration.shorthandFirst || false;
+			const shorthandLast = configuration.shorthandLast || false;
+			const multiline = configuration.multiline || "ignore";
+			const noSortAlphabetically = configuration.noSortAlphabetically || false;
+			const reservedFirst = configuration.reservedFirst || false;
+			const reservedFirstError = validateReservedFirstConfig(context, reservedFirst);
+			const reservedList = Array.isArray(reservedFirst) ? reservedFirst : RESERVED_PROPS_LIST;
+			const reservedLastList = configuration.reservedLast || [];
+			const locale = configuration.locale || "auto";
+			return {
+				Program() {
+					attributeMap = /* @__PURE__ */ new WeakMap();
+				},
+				JSXOpeningElement(node) {
+					const nodeReservedList = reservedFirst && !isDOMComponent(node) ? reservedList.filter((prop) => prop !== "dangerouslySetInnerHTML") : reservedList;
+					node.attributes.reduce((memo, decl, idx, attrs) => {
+						if (decl.type === "JSXSpreadAttribute") return attrs[idx + 1];
+						let previousPropName = getPropName(memo);
+						let currentPropName = getPropName(decl);
+						const previousReservedNamespace = previousPropName.split(":")[0];
+						const currentReservedNamespace = currentPropName.split(":")[0];
+						const previousValue = memo.value;
+						const currentValue = decl.value;
+						const previousIsCallback = isCallbackPropName(previousPropName);
+						const currentIsCallback = isCallbackPropName(currentPropName);
+						if (ignoreCase) {
+							previousPropName = previousPropName.toLowerCase();
+							currentPropName = currentPropName.toLowerCase();
+						}
+						if (reservedFirst) {
+							if (reservedFirstError) {
+								reservedFirstError(decl);
+								return memo;
+							}
+							const previousReservedIndex = getReservedPropIndex(previousPropName, nodeReservedList);
+							const currentReservedIndex = getReservedPropIndex(currentPropName, nodeReservedList);
+							if (previousReservedIndex > -1 && currentReservedIndex === -1) return decl;
+							if (reservedFirst !== true && previousReservedIndex > currentReservedIndex || previousReservedIndex === -1 && currentReservedIndex > -1) {
+								reportNodeAttribute(decl, "listReservedPropsFirst", node, context, nodeReservedList);
+								return memo;
+							}
+							if (previousReservedIndex > -1 && currentReservedIndex > -1 && currentReservedIndex > previousReservedIndex && previousReservedNamespace !== currentReservedNamespace) return decl;
+						}
+						if (reservedLastList.length > 0) {
+							const previousReservedIndex = getReservedPropIndex(previousPropName, reservedLastList);
+							const currentReservedIndex = getReservedPropIndex(currentPropName, reservedLastList);
+							if (previousReservedIndex === -1 && currentReservedIndex > -1) return decl;
+							if (previousReservedIndex < currentReservedIndex || previousReservedIndex > -1 && currentReservedIndex === -1) {
+								reportNodeAttribute(decl, "listReservedPropsLast", node, context, nodeReservedList);
+								return memo;
+							}
+							if (previousReservedIndex > -1 && currentReservedIndex > -1 && currentReservedIndex > previousReservedIndex && previousReservedNamespace !== currentReservedNamespace) return decl;
+						}
+						if (callbacksLast) {
+							if (!previousIsCallback && currentIsCallback) return decl;
+							if (previousIsCallback && !currentIsCallback) {
+								reportNodeAttribute(memo, "listCallbacksLast", node, context, nodeReservedList);
+								return memo;
+							}
+						}
+						if (shorthandFirst) {
+							if (currentValue && !previousValue) return decl;
+							if (!currentValue && previousValue) {
+								reportNodeAttribute(decl, "listShorthandFirst", node, context, nodeReservedList);
+								return memo;
+							}
+						}
+						if (shorthandLast) {
+							if (!currentValue && previousValue) return decl;
+							if (currentValue && !previousValue) {
+								reportNodeAttribute(memo, "listShorthandLast", node, context, nodeReservedList);
+								return memo;
+							}
+						}
+						const previousIsMultiline = isMultilineProp(memo);
+						const currentIsMultiline = isMultilineProp(decl);
+						if (multiline === "first") {
+							if (previousIsMultiline && !currentIsMultiline) return decl;
+							if (!previousIsMultiline && currentIsMultiline) {
+								reportNodeAttribute(decl, "listMultilineFirst", node, context, nodeReservedList);
+								return memo;
+							}
+						} else if (multiline === "last") {
+							if (!previousIsMultiline && currentIsMultiline) return decl;
+							if (previousIsMultiline && !currentIsMultiline) {
+								reportNodeAttribute(memo, "listMultilineLast", node, context, nodeReservedList);
+								return memo;
+							}
+						}
+						if (!noSortAlphabetically && (ignoreCase || locale !== "auto" ? previousPropName.localeCompare(currentPropName, locale === "auto" ? void 0 : locale) > 0 : previousPropName > currentPropName)) {
+							reportNodeAttribute(decl, "sortPropsByAlpha", node, context, nodeReservedList);
+							return memo;
+						}
+						return decl;
+					}, node.attributes[0]);
+				}
+			};
+		}
+	},
+	"define-style": rule$1
+};
+//#endregion
+//#region src/index.ts
+const plugins = { "vue-jsx-vapor": { rules: ruleOptions } };
+const config = ({ rules = {}, ...options } = {}) => ({
+	name: "vue-jsx-vapor",
+	plugins,
+	rules: {
+		"style/jsx-sort-props": "off",
+		"react/jsx-sort-props": "off",
+		"vue-jsx-vapor/jsx-sort-props": rules["vue-jsx-vapor/jsx-sort-props"] || ["warn", {
+			callbacksLast: true,
+			shorthandFirst: true,
+			reservedFirst: [
+				"v-if",
+				"v-else-if",
+				"v-else",
+				"v-for",
+				"key",
+				"ref",
+				"v-model"
+			],
+			reservedLast: [
+				"v-slot",
+				"v-slots",
+				"v-text",
+				"v-html"
+			]
+		}],
+		"vue-jsx-vapor/define-style": rules["vue-jsx-vapor/define-style"] || "warn"
+	},
+	...options
+});
+//#endregion
+export { config as default, plugins, ruleOptions as rules };

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@vue-jsx/eslint",
+  "type": "module",
+  "version": "3.3.0-beta.0",
+  "description": "Vue JSX ESLint Plugin",
+  "license": "MIT",
+  "homepage": "https://github.com/vuejs/vue-jsx-vapor#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/vue-jsx-vapor.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vuejs/vue-jsx-vapor/issues"
+  },
+  "keywords": [
+    "vue",
+    "jsx",
+    "vapor",
+    "eslint"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./*": "./*"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@prettier/sync": "^0.6.1",
+    "@typescript-eslint/utils": "^8.59.1"
+  },
+  "devDependencies": {
+    "eslint-vitest-rule-tester": "^3.1.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "DEV=true tsdown",
+    "release": "bumpp && npm publish",
+    "test": "vitest"
+  }
+}