oxlint-plugin-arch 0.5.0 → 0.6.0

package/dist/index.js

@@ -1252,9 +1252,130 @@ var chainNewline = defineRule2({
   }
 });
 
-// src/rules/declaration-name.ts
+// src/rules/component-props.ts
 import { defineRule as defineRule3 } from "@oxlint/plugins";
-var declarationName = defineRule3({
+function unwrapExport(statement) {
+  return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+}
+function topLevelComponents(program) {
+  return program.body.flatMap((statement, index) => {
+    const declaration = unwrapExport(statement);
+    if (declaration?.type === "FunctionDeclaration" && declaration.id) {
+      return [{ candidate: { name: declaration.id.name, node: declaration, declaration }, index }];
+    }
+    if (declaration?.type !== "VariableDeclaration") {
+      return [];
+    }
+    return declaration.declarations.flatMap((item) => item.id.type === "Identifier" ? [{ candidate: { name: item.id.name, node: item, declaration, initializer: item.init }, index }] : []);
+  });
+}
+function propsTarget(node) {
+  if (node?.type === "FunctionDeclaration" || node?.type === "FunctionExpression" || node?.type === "ArrowFunctionExpression") {
+    return { fn: node };
+  }
+  if (node?.type !== "CallExpression") {
+    return;
+  }
+  const name = astCallName(node);
+  const inner = name === "memo" || name === "forwardRef" ? propsTarget(node.arguments[0]) : undefined;
+  const typeArgument = name === "forwardRef" ? node.typeArguments?.params[1] : undefined;
+  return inner && typeArgument ? { ...inner, typeArgument } : inner;
+}
+function parameterType(parameter) {
+  if (parameter?.type === "AssignmentPattern") {
+    return parameterType(parameter.left);
+  }
+  return parameter && parameter.type !== "TSParameterProperty" ? parameter.typeAnnotation?.typeAnnotation : undefined;
+}
+function containsTypeLiteral(node) {
+  let found = false;
+  astVisit(node, [], (candidate) => {
+    found ||= candidate.type === "TSTypeLiteral";
+  });
+  return found;
+}
+function isPassThrough(type) {
+  if (type.type !== "TSTypeReference") {
+    return false;
+  }
+  const { typeName } = type;
+  const name = typeName.type === "TSQualifiedName" ? typeName.right.name : typeName.type === "Identifier" ? typeName.name : "";
+  const argument = type.typeArguments?.params.length === 1 ? type.typeArguments.params[0] : undefined;
+  return name === "ComponentProps" && (argument?.type === "TSTypeQuery" || argument?.type === "TSLiteralType" && argument.literal.type === "Literal" && typeof argument.literal.value === "string");
+}
+var componentProps = defineRule3({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          filePrefix: { type: "boolean" }
+        }
+      }
+    ],
+    messages: {
+      inline: "'{{name}}' props are typed inline. Declare `interface {{expected}}` directly above it and use that.",
+      name: "'{{name}}' props must use `interface {{expected}}` declared directly above it, not '{{actual}}'.",
+      placement: "Move `interface {{expected}}` directly above '{{name}}', with only blank lines between them.",
+      rename: "Local component '{{name}}' would need `interface {{expected}}`, which breaks the file prefix '{{prefix}}'. Rename the component to start with '{{prefix}}' (for example '{{prefix}}Item')."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { filePrefix = false } = optionsFirst(context, {});
+        const stem = namingFileStem(namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, ""));
+        const exported = new Set(exportsCollect(program).flatMap((binding) => binding.typeOnly ? [] : [binding.localName]));
+        const interfaces = new Map(program.body.flatMap((statement, index) => {
+          const declaration = unwrapExport(statement);
+          return declaration?.type === "TSInterfaceDeclaration" ? [[declaration.id.name, index]] : [];
+        }));
+        for (const { candidate, index } of topLevelComponents(program)) {
+          const target = propsTarget(candidate.initializer ?? candidate.declaration);
+          const parameter = target?.fn.params[0];
+          if (!target || !parameter || !reactComponentsIsLike(program, candidate)) {
+            continue;
+          }
+          const type = target.typeArgument ?? parameterType(parameter);
+          const expected = `${candidate.name}Props`;
+          const data = { name: candidate.name, expected };
+          if (filePrefix && !exported.has(candidate.name) && !candidate.name.toLowerCase().startsWith(namingNormalized(stem, "remove-separators"))) {
+            context.report({ node: candidate.node, messageId: "rename", data: { ...data, prefix: namingPascalCase(stem) } });
+            continue;
+          }
+          if (type && containsTypeLiteral(type)) {
+            context.report({ node: type, messageId: "inline", data });
+            continue;
+          }
+          if (type && isPassThrough(type)) {
+            continue;
+          }
+          const declared = interfaces.get(expected);
+          if (declared === undefined || type?.type !== "TSTypeReference" || type.typeName.type !== "Identifier" || type.typeName.name !== expected) {
+            context.report({
+              node: type ?? parameter,
+              messageId: "name",
+              data: { ...data, actual: type ? context.sourceCode.getText(type) : "untyped" }
+            });
+            continue;
+          }
+          const previous = program.body[declared];
+          const statement = program.body[index];
+          const between = previous && statement ? context.sourceCode.text.slice(previous.range[1], statement.range[0]) : "";
+          if (declared !== index - 1 || between.trim() !== "") {
+            context.report({ node: type, messageId: "placement", data });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/declaration-name.ts
+import { defineRule as defineRule4 } from "@oxlint/plugins";
+var declarationName = defineRule4({
   meta: {
     type: "problem",
     schema: [
@@ -1331,8 +1452,8 @@ var declarationName = defineRule3({
 });
 
 // src/rules/export-file-prefix.ts
-import { defineRule as defineRule4 } from "@oxlint/plugins";
-var exportFilePrefix = defineRule4({
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var exportFilePrefix = defineRule5({
   meta: {
     type: "problem",
     schema: [
@@ -1397,8 +1518,8 @@ var exportFilePrefix = defineRule4({
 });
 
 // src/rules/export-name-pattern.ts
-import { defineRule as defineRule5 } from "@oxlint/plugins";
-var exportNamePattern = defineRule5({
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+var exportNamePattern = defineRule6({
   meta: {
     type: "problem",
     schema: [
@@ -1451,8 +1572,8 @@ var exportNamePattern = defineRule5({
 });
 
 // src/rules/filename-export-name.ts
-import { defineRule as defineRule6 } from "@oxlint/plugins";
-var filenameExportName = defineRule6({
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+var filenameExportName = defineRule7({
   meta: {
     type: "problem",
     schema: [
@@ -1517,8 +1638,8 @@ var filenameExportName = defineRule6({
 });
 
 // src/rules/filename-match.ts
-import { defineRule as defineRule7 } from "@oxlint/plugins";
-var filenameMatch = defineRule7({
+import { defineRule as defineRule8 } from "@oxlint/plugins";
+var filenameMatch = defineRule8({
   meta: {
     type: "problem",
     schema: [
@@ -1555,8 +1676,8 @@ var filenameMatch = defineRule7({
 });
 
 // src/rules/folder-prefix.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
-var folderPrefix = defineRule8({
+import { defineRule as defineRule9 } from "@oxlint/plugins";
+var folderPrefix = defineRule9({
   meta: {
     type: "problem",
     schema: [
@@ -1614,7 +1735,7 @@ var folderPrefix = defineRule8({
 });
 
 // src/rules/jsx-attributes-multiline.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
+import { defineRule as defineRule10 } from "@oxlint/plugins";
 function jsxAttributesMultilineEdits(node, text, attributeIndent, baseIndent, newline) {
   const first = node.attributes[0];
   const last = node.attributes.at(-1);
@@ -1645,7 +1766,7 @@ function jsxAttributesMultilineEdits(node, text, attributeIndent, baseIndent, ne
   edits.push({ range: closingRange, text: `${newline}${baseIndent}` });
   return edits;
 }
-var jsxAttributesMultiline = defineRule9({
+var jsxAttributesMultiline = defineRule10({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -1694,8 +1815,8 @@ var jsxAttributesMultiline = defineRule9({
 });
 
 // src/rules/key-value-same-line.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
-var keyValueSameLine = defineRule10({
+import { defineRule as defineRule11 } from "@oxlint/plugins";
+var keyValueSameLine = defineRule11({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -1744,7 +1865,7 @@ var keyValueSameLine = defineRule10({
 });
 
 // src/rules/no-comments.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
+import { defineRule as defineRule12 } from "@oxlint/plugins";
 var NO_COMMENTS_LINE_GAP = /^[\t \r\n\u2028\u2029]*$/;
 var NO_COMMENTS_LINE_TERMINATOR = /\r\n|[\n\r\u2028\u2029]/;
 var NO_COMMENTS_TRAILING_LINES = /^[\t ]*(?:\r\n|[\n\r\u2028\u2029])(?:[\t ]*(?:\r\n|[\n\r\u2028\u2029]))*/;
@@ -1836,7 +1957,7 @@ function noCommentsJsxEmptyContainer(containers, start, end) {
   const container = containers[low - 1];
   return container?.range[1] >= end ? container : undefined;
 }
-var noComments = defineRule11({
+var noComments = defineRule12({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -1968,8 +2089,8 @@ var noComments = defineRule11({
 });
 
 // src/rules/no-extra-exports.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
-var noExtraExports = defineRule12({
+import { defineRule as defineRule13 } from "@oxlint/plugins";
+var noExtraExports = defineRule13({
   meta: {
     type: "problem",
     schema: [
@@ -2028,7 +2149,7 @@ var noExtraExports = defineRule12({
 });
 
 // src/rules/no-extra-factory-keys.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
+import { defineRule as defineRule14 } from "@oxlint/plugins";
 function compileFactoryKeys(pattern, keys, requireKeys) {
   const allowedList = keys.concat(requireKeys.filter((key) => !keys.includes(key)));
   return {
@@ -2038,7 +2159,7 @@ function compileFactoryKeys(pattern, keys, requireKeys) {
     requireKeys
   };
 }
-var noExtraFactoryKeys = defineRule13({
+var noExtraFactoryKeys = defineRule14({
   meta: {
     type: "problem",
     schema: [
@@ -2142,8 +2263,8 @@ var noExtraFactoryKeys = defineRule13({
 });
 
 // src/rules/no-file-level-helpers.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
-var noFileLevelHelpers = defineRule14({
+import { defineRule as defineRule15 } from "@oxlint/plugins";
+var noFileLevelHelpers = defineRule15({
   meta: {
     type: "problem",
     schema: [
@@ -2189,7 +2310,7 @@ var noFileLevelHelpers = defineRule14({
 });
 
 // src/rules/no-imported-type-alias.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
+import { defineRule as defineRule16 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
   if (declaration?.type !== "TSTypeAliasDeclaration" || declaration.typeAnnotation.type !== "TSTypeReference" || declaration.typeAnnotation.typeName.type !== "Identifier" || Boolean(declaration.typeAnnotation.typeArguments?.params.length) || !imports.has(declaration.typeAnnotation.typeName.name)) {
     return;
@@ -2199,7 +2320,7 @@ function importedAliasTarget(declaration, imports) {
 function specifierLocalName(specifier) {
   return specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
 }
-var noImportedTypeAlias = defineRule15({
+var noImportedTypeAlias = defineRule16({
   meta: {
     type: "problem",
     schema: [],
@@ -2273,8 +2394,8 @@ var noImportedTypeAlias = defineRule15({
 });
 
 // src/rules/no-inline-schema-elements.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
-var noInlineSchemaElements = defineRule16({
+import { defineRule as defineRule17 } from "@oxlint/plugins";
+var noInlineSchemaElements = defineRule17({
   meta: {
     type: "problem",
     schema: [
@@ -2335,7 +2456,7 @@ var noInlineSchemaElements = defineRule16({
 });
 
 // src/rules/no-inline-types.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
+import { defineRule as defineRule18 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -2345,7 +2466,7 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var noInlineTypes = defineRule17({
+var noInlineTypes = defineRule18({
   meta: {
     type: "problem",
     schema: [
@@ -2415,7 +2536,7 @@ var noInlineTypes = defineRule17({
 });
 
 // src/rules/no-literal-in.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
+import { defineRule as defineRule19 } from "@oxlint/plugins";
 function literalKey(node) {
   if (node.type === "Literal" && typeof node.value === "string") {
     return node.value;
@@ -2424,7 +2545,7 @@ function literalKey(node) {
     return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;
   }
 }
-var noLiteralIn = defineRule18({
+var noLiteralIn = defineRule19({
   meta: {
     type: "suggestion",
     schema: [
@@ -2465,13 +2586,13 @@ var noLiteralIn = defineRule18({
 });
 
 // src/rules/no-local-schema-construction.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
+import { defineRule as defineRule20 } from "@oxlint/plugins";
 var defaultRuntimeImportMessage = "Do not import runtime schema constructors from {{source}}; import a named schema instead.";
 var defaultConstructionMessage = "Do not construct schemas locally; import a named schema instead.";
 function formatMessage(template, data) {
   return Object.entries(data).reduce((result, [key, value]) => result.replaceAll(`{{${key}}}`, value), template);
 }
-var noLocalSchemaConstruction = defineRule19({
+var noLocalSchemaConstruction = defineRule20({
   meta: {
     type: "problem",
     schema: [
@@ -2593,8 +2714,8 @@ var noLocalSchemaConstruction = defineRule19({
 });
 
 // src/rules/no-member-comments.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
-var noMemberComments = defineRule20({
+import { defineRule as defineRule21 } from "@oxlint/plugins";
+var noMemberComments = defineRule21({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -2690,7 +2811,7 @@ var noMemberComments = defineRule20({
 });
 
 // src/rules/no-module-mutable-state.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
+import { defineRule as defineRule22 } from "@oxlint/plugins";
 function moduleMutableStateBindings(pattern) {
   if (pattern.type === "Identifier") {
     return [{ name: pattern.name, node: pattern }];
@@ -2729,7 +2850,7 @@ function moduleMutableStateInsideAmbient(node) {
   }
   return false;
 }
-var noModuleMutableState = defineRule21({
+var noModuleMutableState = defineRule22({
   meta: {
     type: "problem",
     schema: [
@@ -2781,7 +2902,7 @@ var noModuleMutableState = defineRule21({
 });
 
 // src/rules/no-promise-all-mutation.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
+import { defineRule as defineRule23 } from "@oxlint/plugins";
 function mutationBinding(node) {
   if (node.type === "Identifier") {
     return node;
@@ -2809,7 +2930,7 @@ function mutationBindings(node) {
     }
   }
 }
-var noPromiseAllMutation = defineRule22({
+var noPromiseAllMutation = defineRule23({
   meta: {
     type: "problem",
     schema: [
@@ -2909,8 +3030,8 @@ var noPromiseAllMutation = defineRule22({
 });
 
 // src/rules/no-rederive-schema.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
-var noRederiveSchema = defineRule23({
+import { defineRule as defineRule24 } from "@oxlint/plugins";
+var noRederiveSchema = defineRule24({
   meta: {
     type: "problem",
     schema: [
@@ -2954,7 +3075,7 @@ var noRederiveSchema = defineRule23({
 });
 
 // src/rules/no-restricted-constructor.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
+import { defineRule as defineRule25 } from "@oxlint/plugins";
 function restrictedConstructorEntries(constructors) {
   const entries = new Map;
   for (const item of constructors) {
@@ -2970,7 +3091,7 @@ function restrictedConstructorEntries(constructors) {
   }
   return entries;
 }
-var noRestrictedConstructor = defineRule24({
+var noRestrictedConstructor = defineRule25({
   meta: {
     type: "problem",
     schema: [
@@ -3045,8 +3166,8 @@ var noRestrictedConstructor = defineRule24({
 });
 
 // src/rules/no-restricted-files.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
-var noRestrictedFiles = defineRule25({
+import { defineRule as defineRule26 } from "@oxlint/plugins";
+var noRestrictedFiles = defineRule26({
   meta: {
     type: "problem",
     schema: [
@@ -3078,7 +3199,7 @@ var noRestrictedFiles = defineRule25({
 });
 
 // src/rules/no-restricted-token.ts
-import { defineRule as defineRule26 } from "@oxlint/plugins";
+import { defineRule as defineRule27 } from "@oxlint/plugins";
 function tokenIsTypeOnlyImport(node) {
   const parent = node.parent;
   if (parent?.type === "ImportSpecifier") {
@@ -3089,7 +3210,7 @@ function tokenIsTypeOnlyImport(node) {
 function memberMatches(node, restriction) {
   return restriction.startsWith("*.") ? astStaticMemberName(node) === restriction.slice(2) : astDottedName(node) === restriction;
 }
-var noRestrictedToken = defineRule26({
+var noRestrictedToken = defineRule27({
   meta: {
     type: "problem",
     schema: [
@@ -3186,7 +3307,7 @@ var noRestrictedToken = defineRule26({
 });
 
 // src/rules/no-runtime-in-types.ts
-import { defineRule as defineRule27 } from "@oxlint/plugins";
+import { defineRule as defineRule28 } from "@oxlint/plugins";
 function isTypeOnlyImport(statement) {
   return statement.importKind === "type" || statement.specifiers.length > 0 && statement.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
 }
@@ -3403,7 +3524,7 @@ function isRuntimeReExport(statement, runtimeImportLocals, valueNames, isAmbient
   }
   return statement.specifiers.some((specifier) => specifier.exportKind !== "type" && runtimeImportLocals.has(exportLocalName(specifier)));
 }
-var noRuntimeInTypes = defineRule27({
+var noRuntimeInTypes = defineRule28({
   meta: {
     type: "problem",
     schema: [
@@ -3547,7 +3668,7 @@ var noRuntimeInTypes = defineRule27({
 });
 
 // src/rules/no-single-use-scalar-schema.ts
-import { defineRule as defineRule28 } from "@oxlint/plugins";
+import { defineRule as defineRule29 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -3581,7 +3702,7 @@ function isAllowedStructuralElement(identifier, initializer, ancestors, options,
   const method = call.callee.type === "MemberExpression" ? astStaticMemberName(call.callee) : undefined;
   return Boolean(method && options.methods.includes(method) && schemasElements(call).includes(identifier));
 }
-var noSingleUseScalarSchema = defineRule28({
+var noSingleUseScalarSchema = defineRule29({
   meta: {
     type: "suggestion",
     schema: [
@@ -3666,8 +3787,8 @@ var noSingleUseScalarSchema = defineRule28({
 });
 
 // src/rules/no-top-level-functions.ts
-import { defineRule as defineRule29 } from "@oxlint/plugins";
-var noTopLevelFunctions = defineRule29({
+import { defineRule as defineRule30 } from "@oxlint/plugins";
+var noTopLevelFunctions = defineRule30({
   meta: {
     type: "problem",
     schema: [
@@ -3726,7 +3847,7 @@ var noTopLevelFunctions = defineRule29({
 });
 
 // src/rules/no-trivial-functions.ts
-import { defineRule as defineRule30 } from "@oxlint/plugins";
+import { defineRule as defineRule31 } from "@oxlint/plugins";
 
 // src/constants/trivial.constants.ts
 var trivialBannedNames = [
@@ -3742,7 +3863,7 @@ var trivialBannedNames = [
 ];
 
 // src/rules/no-trivial-functions.ts
-var noTrivialFunctions = defineRule30({
+var noTrivialFunctions = defineRule31({
   meta: {
     type: "problem",
     schema: [
@@ -3859,8 +3980,8 @@ var noTrivialFunctions = defineRule30({
 });
 
 // src/rules/no-type-declarations.ts
-import { defineRule as defineRule31 } from "@oxlint/plugins";
-var noTypeDeclarations = defineRule31({
+import { defineRule as defineRule32 } from "@oxlint/plugins";
+var noTypeDeclarations = defineRule32({
   meta: {
     type: "problem",
     schema: [
@@ -3905,8 +4026,8 @@ var noTypeDeclarations = defineRule31({
 });
 
 // src/rules/no-unescaped-like.ts
-import { defineRule as defineRule32 } from "@oxlint/plugins";
-var noUnescapedLike = defineRule32({
+import { defineRule as defineRule33 } from "@oxlint/plugins";
+var noUnescapedLike = defineRule33({
   meta: {
     type: "problem",
     schema: [
@@ -3957,7 +4078,7 @@ var noUnescapedLike = defineRule32({
 });
 
 // src/rules/object-multiline.ts
-import { defineRule as defineRule33 } from "@oxlint/plugins";
+import { defineRule as defineRule34 } from "@oxlint/plugins";
 function objectMultilineIsCallArg(node) {
   const parent = node.parent;
   return (parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node);
@@ -3994,7 +4115,7 @@ function objectMultilineGaps(text, node) {
   }
   return gaps;
 }
-var objectMultiline = defineRule33({
+var objectMultiline = defineRule34({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4056,8 +4177,8 @@ var objectMultiline = defineRule33({
 });
 
 // src/rules/only-export-components.ts
-import { defineRule as defineRule34 } from "@oxlint/plugins";
-var onlyExportComponents = defineRule34({
+import { defineRule as defineRule35 } from "@oxlint/plugins";
+var onlyExportComponents = defineRule35({
   meta: {
     type: "problem",
     schema: [
@@ -4137,7 +4258,7 @@ var onlyExportComponents = defineRule34({
 });
 
 // src/rules/only-export-constants.ts
-import { defineRule as defineRule35 } from "@oxlint/plugins";
+import { defineRule as defineRule36 } from "@oxlint/plugins";
 function bindingNames(pattern) {
   switch (pattern.type) {
     case "Identifier":
@@ -4192,7 +4313,7 @@ function collectBindings(program) {
   }
   return bindings;
 }
-var onlyExportConstants = defineRule35({
+var onlyExportConstants = defineRule36({
   meta: {
     type: "problem",
     schema: [
@@ -4280,7 +4401,7 @@ var onlyExportConstants = defineRule35({
 });
 
 // src/rules/padding-between-statements.ts
-import { defineRule as defineRule36 } from "@oxlint/plugins";
+import { defineRule as defineRule37 } from "@oxlint/plugins";
 function paddingKind(node) {
   if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") {
     return node.declaration ? paddingKind(node.declaration) : "other";
@@ -4332,7 +4453,7 @@ function paddingBlankLineFix(sourceText, comments, prev, curr, newline) {
   }
   return { newlineEnd, newline };
 }
-var paddingBetweenStatements = defineRule36({
+var paddingBetweenStatements = defineRule37({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4406,7 +4527,7 @@ var paddingBetweenStatements = defineRule36({
 });
 
 // src/rules/prefer-namespace-type-import.ts
-import { defineRule as defineRule37 } from "@oxlint/plugins";
+import { defineRule as defineRule38 } from "@oxlint/plugins";
 var bindingName = /^[A-Za-z_$][\w$]*$/;
 var reservedNames = new Set("await break case catch class const continue debugger default delete do else enum export extends false finally for function if import in instanceof new null return super switch this throw true try typeof var void while with yield implements interface let package private protected public static arguments eval".split(" "));
 function namespaceName(source, names) {
@@ -4430,7 +4551,7 @@ function safeReference(node) {
   }
   return parent?.type === "TSTypeReference" && parent.typeName === current || parent?.type === "TSTypeQuery" && parent.exprName === current || (parent?.type === "TSInterfaceHeritage" || parent?.type === "TSClassImplements") && parent.expression === current;
 }
-var preferNamespaceTypeImport = defineRule37({
+var preferNamespaceTypeImport = defineRule38({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -4547,8 +4668,8 @@ var preferNamespaceTypeImport = defineRule37({
 });
 
 // src/rules/require-file-factory.ts
-import { defineRule as defineRule38 } from "@oxlint/plugins";
-var requireFileFactory = defineRule38({
+import { defineRule as defineRule39 } from "@oxlint/plugins";
+var requireFileFactory = defineRule39({
   meta: {
     type: "problem",
     schema: [
@@ -4596,8 +4717,8 @@ var requireFileFactory = defineRule38({
 });
 
 // src/rules/require-object-params.ts
-import { defineRule as defineRule39 } from "@oxlint/plugins";
-var requireObjectParams = defineRule39({
+import { defineRule as defineRule40 } from "@oxlint/plugins";
+var requireObjectParams = defineRule40({
   meta: {
     type: "problem",
     schema: [
@@ -4655,8 +4776,8 @@ var requireObjectParams = defineRule39({
 });
 
 // src/rules/require-orpc-output.ts
-import { defineRule as defineRule40 } from "@oxlint/plugins";
-var requireOrpcOutput = defineRule40({
+import { defineRule as defineRule41 } from "@oxlint/plugins";
+var requireOrpcOutput = defineRule41({
   meta: {
     type: "problem",
     schema: [
@@ -4704,8 +4825,8 @@ var requireOrpcOutput = defineRule40({
 });
 
 // src/rules/require-paired-call.ts
-import { defineRule as defineRule41 } from "@oxlint/plugins";
-var requirePairedCall = defineRule41({
+import { defineRule as defineRule42 } from "@oxlint/plugins";
+var requirePairedCall = defineRule42({
   meta: {
     type: "problem",
     schema: [
@@ -4779,8 +4900,8 @@ var requirePairedCall = defineRule41({
 });
 
 // src/rules/route-surface.ts
-import { defineRule as defineRule42 } from "@oxlint/plugins";
-var routeSurface = defineRule42({
+import { defineRule as defineRule43 } from "@oxlint/plugins";
+var routeSurface = defineRule43({
   meta: {
     type: "problem",
     schema: [
@@ -4826,8 +4947,8 @@ var routeSurface = defineRule42({
 });
 
 // src/rules/test-title-pattern.ts
-import { defineRule as defineRule43 } from "@oxlint/plugins";
-var TEST_MODIFIERS = new Set(["only", "skip", "concurrent", "todo", "each"]);
+import { defineRule as defineRule44 } from "@oxlint/plugins";
+var TEST_MODIFIERS = new Set(["only", "skip", "concurrent", "sequential", "todo", "each", "for"]);
 function isConfiguredName(name, callees) {
   if (!name) {
     return false;
@@ -4866,7 +4987,7 @@ function regexMatches(regex, value) {
 function titlePatterns(pattern, flags) {
   return pattern === undefined ? [] : [pattern].flat().map((source) => ({ regex: new RegExp(source, flags), pattern: source }));
 }
-var testTitlePattern = defineRule43({
+var testTitlePattern = defineRule44({
   meta: {
     type: "suggestion",
     schema: [
@@ -4947,6 +5068,7 @@ var src_default = eslintCompatPlugin({
   rules: {
     "call-array-multiline": callArrayMultiline,
     "chain-newline": chainNewline,
+    "component-props": componentProps,
     "declaration-name": declarationName,
     "export-file-prefix": exportFilePrefix,
     "export-name-pattern": exportNamePattern,