@vue-jsx-vapor/eslint 2.3.0

package/dist/index.js

@@ -0,0 +1,634 @@
+// src/rules/define-style/index.ts
+import prettier from "@prettier/sync";
+var rule = {
+  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 configuration = context.options[0] || {};
+    const tabWidth = configuration.tabWidth || 2;
+    return {
+      CallExpression(node) {
+        const callee = node.callee.type === "MemberExpression" ? node.callee.object : node.callee;
+        const offset = callee.loc.start.column;
+        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") {
+            const cssRaw = arg.quasis[0].value.raw;
+            let formattedCss = "";
+            try {
+              formattedCss = prettier.format(cssRaw, { parser, tabWidth });
+            } catch {
+              return context.report({
+                node: arg,
+                messageId: "define-style-syntax-error"
+              });
+            }
+            const placeholder = " ".repeat(offset + tabWidth);
+            const result = `
+${placeholder}${formattedCss.slice(0, -1).replaceAll("\n", `
+${placeholder}`)}
+${" ".repeat(offset)}`;
+            if (result !== cssRaw) {
+              context.report({
+                node: arg,
+                messageId: "define-style",
+                fix(fixer) {
+                  return fixer.replaceTextRange(
+                    [arg.range[0] + 1, arg.range[1] - 1],
+                    result
+                  );
+                }
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+var define_style_default = rule;
+
+// src/rules/jsx-sort-props/index.ts
+var COMPAT_TAG_REGEX = /^[a-z]/;
+function isDOMComponent(node) {
+  const name = getElementType(node);
+  return COMPAT_TAG_REGEX.test(name);
+}
+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}`;
+}
+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;
+}
+var 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"
+};
+var RESERVED_PROPS_LIST = [
+  "children",
+  "dangerouslySetInnerHTML",
+  "key",
+  "ref"
+];
+function getReservedPropIndex(name, list) {
+  return list.indexOf(name.split(":")[0]);
+}
+var 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 aPropWithoutNamespace = aProp.split(":")[0];
+  const bPropWithoutNamespace = 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 && aPropWithoutNamespace !== bPropWithoutNamespace)
+      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 && aPropWithoutNamespace !== bPropWithoutNamespace)
+      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);
+}
+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 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 reservedLast = configuration.reservedLast || [];
+  const locale = configuration.locale || "auto";
+  const options = {
+    ignoreCase,
+    callbacksLast,
+    shorthandFirst,
+    shorthandLast,
+    multiline,
+    noSortAlphabetically,
+    reservedFirst,
+    reservedList,
+    reservedLast,
+    locale
+  };
+  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)
+    );
+  };
+}
+function validateReservedFirstConfig(context, reservedFirst) {
+  if (reservedFirst && Array.isArray(reservedFirst) && reservedFirst.length === 0) {
+    return function Report(decl) {
+      context.report({
+        node: decl,
+        messageId: "listIsEmpty"
+      });
+    };
+  }
+}
+var reportedNodeAttributes = /* @__PURE__ */ new WeakMap();
+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)
+  });
+}
+var rule2 = {
+  defaultOptions: [
+    {
+      multiline: "ignore",
+      locale: "auto"
+    }
+  ],
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Enforce props alphabetical sorting"
+    },
+    fixable: "code",
+    messages,
+    schema: [
+      {
+        type: "object",
+        properties: {
+          // Whether callbacks (prefixed with "on") should be listed at the very end,
+          // after all other props. Supersedes shorthandLast.
+          callbacksLast: {
+            type: "boolean"
+          },
+          // Whether shorthand properties (without a value) should be listed first
+          shorthandFirst: {
+            type: "boolean"
+          },
+          // Whether shorthand properties (without a value) should be listed last
+          shorthandLast: {
+            type: "boolean"
+          },
+          // Whether multiline properties should be listed first or last
+          multiline: {
+            type: "string",
+            enum: ["ignore", "first", "last"],
+            default: "ignore"
+          },
+          ignoreCase: {
+            type: "boolean"
+          },
+          // Whether alphabetical sorting should be enforced
+          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 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 (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 (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]);
+      }
+    };
+  }
+};
+var jsx_sort_props_default = rule2;
+
+// src/rules/index.ts
+var ruleOptions = {
+  "jsx-sort-props": jsx_sort_props_default,
+  "define-style": define_style_default
+};
+var rules_default = ruleOptions;
+
+// src/index.ts
+var plugins = {
+  "vue-jsx-vapor": {
+    rules: rules_default
+  }
+};
+var index_default = ({ 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-text", "v-html", "v-slots", "v-slot"]
+      }
+    ],
+    "vue-jsx-vapor/define-style": rules["vue-jsx-vapor/define-style"] || "warn"
+  },
+  ...options
+});
+export {
+  index_default as default,
+  plugins,
+  rules_default as rules
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@vue-jsx-vapor/eslint",
+  "version": "2.3.0",
+  "description": "Vue JSX Vapor ESLint Plugin",
+  "type": "module",
+  "keywords": [
+    "vue",
+    "jsx",
+    "vapor",
+    "eslint"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/vuejs/vue-jsx-vapor#readme",
+  "bugs": {
+    "url": "https://github.com/vuejs/vue-jsx-vapor/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/vue-jsx-vapor.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "dev": "./src/index.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    },
+    "./*": "./*"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./*"
+      ]
+    }
+  },
+  "publishConfig": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    },
+    "./*": "./*"
+  },
+  "dependencies": {
+    "@prettier/sync": "^0.5.5"
+  },
+  "devDependencies": {
+    "@typescript-eslint/utils": "^8.29.1",
+    "eslint-vitest-rule-tester": "^2.2.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "DEV=true tsup",
+    "release": "bumpp && npm publish",
+    "test": "vitest"
+  }
+}