oxlint-plugin-arch 0.6.2 → 0.7.0

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
-// src/rules/call-array-multiline.ts
+// src/rules/call-arguments-multiline.ts
 import { defineRule } from "@oxlint/plugins";
 
 // src/utils/helpers/ast.ts
@@ -894,6 +894,49 @@ function routesInspectFunction(context, item, bannedHooks, banIntrinsicJsx) {
     }
   });
 }
+// src/utils/helpers/runtime.ts
+import { builtinModules } from "node:module";
+var runtimeServerGlobals = ["process", "Bun", "Deno", "Buffer", "__dirname", "__filename", "require"];
+var runtimeBrowserGlobals = [
+  "window",
+  "document",
+  "navigator",
+  "localStorage",
+  "sessionStorage",
+  "location",
+  "history",
+  "screen",
+  "HTMLElement",
+  "Element",
+  "HTMLInputElement",
+  "ResizeObserver",
+  "MutationObserver",
+  "IntersectionObserver",
+  "FileReader",
+  "matchMedia",
+  "getComputedStyle",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "alert",
+  "confirm",
+  "prompt"
+];
+function runtimeMatchesImport(values, source) {
+  return Boolean(values?.some((value) => source === value || source.startsWith(value + "/")));
+}
+function runtimeIsBackendImport(options, target, source) {
+  return options.backend.some((path) => target.startsWith(path + "/")) || options.backendPackages.some((name) => source === name || source.startsWith(name + "/") && /\/(?:server|rpc)(?:\/|$)/.test(source.slice(name.length)));
+}
+function runtimeIsServerPlatformImport(source) {
+  return builtinModules.includes(source) || source === "@orpc/server" || /^(?:node:|bun(?::|$)|cloudflare:)/.test(source) || /^react-dom\/server(?:\.|\/|$)/.test(source);
+}
+function runtimeMemberName(node) {
+  if (node?.type !== "MemberExpression")
+    return null;
+  if (!node.computed && node.property.type === "Identifier")
+    return node.property.name;
+  return node.computed && node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : null;
+}
 // src/utils/helpers/sanitizers.ts
 function sanitizersCallsConfigured(node, names) {
   let found = false;
@@ -981,7 +1024,91 @@ function boundaryResolveTarget(options, file, source) {
   const alias = Object.entries(options.aliases).sort(([a], [b]) => b.length - a.length).find(([prefix]) => source === prefix || source.startsWith(`${prefix}/`));
   return alias ? resolve(alias[1], source.slice(alias[0].length).replace(/^\//, "")).replaceAll("\\", "/") : source.startsWith(".") ? resolve(dirname(file), source).replaceAll("\\", "/") : source.startsWith("@/") && web ? `${web}/${source.slice(2)}` : source.startsWith("#/") && owner ? `${owner}/${source.slice(2)}` : source.startsWith("#services/") && owner ? `${owner}/services/${source.slice(10)}` : source;
 }
+// src/rules/call-arguments-multiline.ts
+function callArgumentsIsCallback(node) {
+  return (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") && node.loc.start.line !== node.loc.end.line;
+}
+var callArgumentsMultiline = defineRule({
+  meta: {
+    type: "layout",
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          minArguments: {
+            type: "integer",
+            minimum: 2,
+            default: 3
+          },
+          indent: {
+            type: "integer",
+            minimum: 1,
+            default: 2
+          }
+        }
+      }
+    ],
+    messages: {
+      multiline: "A call with {{min}}+ arguments puts each argument on its own line."
+    }
+  },
+  createOnce(context) {
+    let minArguments = 3;
+    let indent = 2;
+    const check = (node) => {
+      const args = node.arguments;
+      if (args.length < minArguments || args.some(callArgumentsIsCallback) || context.sourceCode.getCommentsInside(node).length > 0) {
+        return;
+      }
+      const text = context.sourceCode.text;
+      const open = text.indexOf("(", (node.typeArguments ?? node.callee).range[1]);
+      const close = node.range[1] - 1;
+      const first = args[0];
+      const last = args[args.length - 1];
+      const gaps = [[open + 1, first.range[0]]];
+      for (let index = 1;index < args.length; index++) {
+        gaps.push([args[index - 1].range[1], args[index].range[0]]);
+      }
+      gaps.push([last.range[1], close]);
+      const between = gaps.map(([start, end]) => text.slice(start, end));
+      if (text[open] !== "(" || text[close] !== ")" || !/^\s*$/.test(between[0]) || between.slice(1, -1).some((gap) => !/^\s*,\s*$/.test(gap)) || !/^\s*,?\s*$/.test(between[between.length - 1])) {
+        return;
+      }
+      if (between.every((gap) => gap.includes(`
+`))) {
+        return;
+      }
+      const baseIndent = layoutLineIndent(text, open);
+      const newline = layoutNewline(text);
+      const argumentIndent = `${baseIndent}${" ".repeat(indent)}`;
+      context.report({
+        node,
+        messageId: "multiline",
+        data: { min: String(minArguments) },
+        fix: (fixer) => gaps.map((gap, index) => {
+          if (index === 0) {
+            return fixer.replaceTextRange(gap, `${newline}${argumentIndent}`);
+          }
+          return fixer.replaceTextRange(gap, index === gaps.length - 1 ? `,${newline}${baseIndent}` : `,${newline}${argumentIndent}`);
+        })
+      });
+    };
+    return {
+      before() {
+        const options2 = optionsFirst(context, {});
+        minArguments = options2.minArguments ?? 3;
+        indent = options2.indent ?? 2;
+      },
+      CallExpression: check,
+      NewExpression: check
+    };
+  }
+});
+
 // src/rules/call-array-multiline.ts
+import { defineRule as defineRule2 } from "@oxlint/plugins";
 function callArrayMultilineCallee(node) {
   if (node.type === "Identifier")
     return { name: node.name, root: node };
@@ -1048,7 +1175,7 @@ function callArrayMultilineEdits(array, source, text, elementIndent, baseIndent,
   });
   return edits;
 }
-var callArrayMultiline = defineRule({
+var callArrayMultiline = defineRule2({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -1110,7 +1237,7 @@ var callArrayMultiline = defineRule({
 });
 
 // src/rules/chain-newline.ts
-import { defineRule as defineRule2 } from "@oxlint/plugins";
+import { defineRule as defineRule3 } from "@oxlint/plugins";
 function chainNewlineCollect(node) {
   const links = [];
   let current = node;
@@ -1147,7 +1274,7 @@ function chainNewlineMatches(root, links, group) {
   const rootName = chainNewlineRootIdentifier(root);
   return rootName !== null && optionsPatternsTest(group.rootPatterns, rootName);
 }
-var chainNewline = defineRule2({
+var chainNewline = defineRule3({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -1253,7 +1380,7 @@ var chainNewline = defineRule2({
 });
 
 // src/rules/component-props.ts
-import { defineRule as defineRule3 } from "@oxlint/plugins";
+import { defineRule as defineRule4 } from "@oxlint/plugins";
 function unwrapExport(statement) {
   return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
 }
@@ -1303,7 +1430,7 @@ function isPassThrough(type) {
   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({
+var componentProps = defineRule4({
   meta: {
     type: "problem",
     schema: [
@@ -1374,8 +1501,8 @@ var componentProps = defineRule3({
 });
 
 // src/rules/declaration-name.ts
-import { defineRule as defineRule4 } from "@oxlint/plugins";
-var declarationName = defineRule4({
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var declarationName = defineRule5({
   meta: {
     type: "problem",
     schema: [
@@ -1452,8 +1579,8 @@ var declarationName = defineRule4({
 });
 
 // src/rules/export-file-prefix.ts
-import { defineRule as defineRule5 } from "@oxlint/plugins";
-var exportFilePrefix = defineRule5({
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+var exportFilePrefix = defineRule6({
   meta: {
     type: "problem",
     schema: [
@@ -1518,8 +1645,8 @@ var exportFilePrefix = defineRule5({
 });
 
 // src/rules/export-name-pattern.ts
-import { defineRule as defineRule6 } from "@oxlint/plugins";
-var exportNamePattern = defineRule6({
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+var exportNamePattern = defineRule7({
   meta: {
     type: "problem",
     schema: [
@@ -1572,8 +1699,8 @@ var exportNamePattern = defineRule6({
 });
 
 // src/rules/filename-export-name.ts
-import { defineRule as defineRule7 } from "@oxlint/plugins";
-var filenameExportName = defineRule7({
+import { defineRule as defineRule8 } from "@oxlint/plugins";
+var filenameExportName = defineRule8({
   meta: {
     type: "problem",
     schema: [
@@ -1638,8 +1765,8 @@ var filenameExportName = defineRule7({
 });
 
 // src/rules/filename-match.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
-var filenameMatch = defineRule8({
+import { defineRule as defineRule9 } from "@oxlint/plugins";
+var filenameMatch = defineRule9({
   meta: {
     type: "problem",
     schema: [
@@ -1676,8 +1803,8 @@ var filenameMatch = defineRule8({
 });
 
 // src/rules/folder-prefix.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
-var folderPrefix = defineRule9({
+import { defineRule as defineRule10 } from "@oxlint/plugins";
+var folderPrefix = defineRule10({
   meta: {
     type: "problem",
     schema: [
@@ -1735,7 +1862,7 @@ var folderPrefix = defineRule9({
 });
 
 // src/rules/jsx-attributes-multiline.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
+import { defineRule as defineRule11 } from "@oxlint/plugins";
 function jsxAttributesMultilineEdits(node, text, attributeIndent, baseIndent, newline) {
   const first = node.attributes[0];
   const last = node.attributes.at(-1);
@@ -1766,7 +1893,7 @@ function jsxAttributesMultilineEdits(node, text, attributeIndent, baseIndent, ne
   edits.push({ range: closingRange, text: `${newline}${baseIndent}` });
   return edits;
 }
-var jsxAttributesMultiline = defineRule10({
+var jsxAttributesMultiline = defineRule11({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -1815,8 +1942,8 @@ var jsxAttributesMultiline = defineRule10({
 });
 
 // src/rules/key-value-same-line.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
-var keyValueSameLine = defineRule11({
+import { defineRule as defineRule12 } from "@oxlint/plugins";
+var keyValueSameLine = defineRule12({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -1865,7 +1992,7 @@ var keyValueSameLine = defineRule11({
 });
 
 // src/rules/no-comments.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
+import { defineRule as defineRule13 } 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]))*/;
@@ -1957,7 +2084,7 @@ function noCommentsJsxEmptyContainer(containers, start, end) {
   const container = containers[low - 1];
   return container?.range[1] >= end ? container : undefined;
 }
-var noComments = defineRule12({
+var noComments = defineRule13({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -2089,8 +2216,8 @@ var noComments = defineRule12({
 });
 
 // src/rules/no-extra-exports.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
-var noExtraExports = defineRule13({
+import { defineRule as defineRule14 } from "@oxlint/plugins";
+var noExtraExports = defineRule14({
   meta: {
     type: "problem",
     schema: [
@@ -2149,7 +2276,7 @@ var noExtraExports = defineRule13({
 });
 
 // src/rules/no-extra-factory-keys.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
+import { defineRule as defineRule15 } from "@oxlint/plugins";
 function compileFactoryKeys(pattern, keys, requireKeys) {
   const allowedList = keys.concat(requireKeys.filter((key) => !keys.includes(key)));
   return {
@@ -2159,7 +2286,7 @@ function compileFactoryKeys(pattern, keys, requireKeys) {
     requireKeys
   };
 }
-var noExtraFactoryKeys = defineRule14({
+var noExtraFactoryKeys = defineRule15({
   meta: {
     type: "problem",
     schema: [
@@ -2263,8 +2390,8 @@ var noExtraFactoryKeys = defineRule14({
 });
 
 // src/rules/no-file-level-helpers.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
-var noFileLevelHelpers = defineRule15({
+import { defineRule as defineRule16 } from "@oxlint/plugins";
+var noFileLevelHelpers = defineRule16({
   meta: {
     type: "problem",
     schema: [
@@ -2294,8 +2421,10 @@ var noFileLevelHelpers = defineRule15({
         } = optionsFirst(context, {});
         const allowed = optionsOptionalPatterns(allowPattern);
         const hooks = optionsPatterns(hookPattern);
+        const exported = exportsCollect(program);
+        const allowedExport = (name) => exported.some((binding) => binding.localName === name && optionsPatternsTest(allowed, binding.exportedName));
         for (const candidate of declarationsFileLevelFunctionCandidates(program)) {
-          if (detectComponents && reactComponentsIsLike(program, candidate) || optionsPatternsTest(hooks, candidate.name) || optionsPatternsTest(allowed, candidate.name)) {
+          if (detectComponents && reactComponentsIsLike(program, candidate) || optionsPatternsTest(hooks, candidate.name) || optionsPatternsTest(allowed, candidate.name) || allowedExport(candidate.name)) {
             continue;
           }
           context.report({
@@ -2310,7 +2439,7 @@ var noFileLevelHelpers = defineRule15({
 });
 
 // src/rules/no-imported-type-alias.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
+import { defineRule as defineRule17 } 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;
@@ -2320,7 +2449,7 @@ function importedAliasTarget(declaration, imports) {
 function specifierLocalName(specifier) {
   return specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
 }
-var noImportedTypeAlias = defineRule16({
+var noImportedTypeAlias = defineRule17({
   meta: {
     type: "problem",
     schema: [],
@@ -2394,8 +2523,8 @@ var noImportedTypeAlias = defineRule16({
 });
 
 // src/rules/no-inline-schema-elements.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
-var noInlineSchemaElements = defineRule17({
+import { defineRule as defineRule18 } from "@oxlint/plugins";
+var noInlineSchemaElements = defineRule18({
   meta: {
     type: "problem",
     schema: [
@@ -2456,7 +2585,7 @@ var noInlineSchemaElements = defineRule17({
 });
 
 // src/rules/no-inline-types.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
+import { defineRule as defineRule19 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -2466,7 +2595,7 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var noInlineTypes = defineRule18({
+var noInlineTypes = defineRule19({
   meta: {
     type: "problem",
     schema: [
@@ -2536,7 +2665,7 @@ var noInlineTypes = defineRule18({
 });
 
 // src/rules/no-literal-in.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
+import { defineRule as defineRule20 } from "@oxlint/plugins";
 function literalKey(node) {
   if (node.type === "Literal" && typeof node.value === "string") {
     return node.value;
@@ -2545,7 +2674,7 @@ function literalKey(node) {
     return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;
   }
 }
-var noLiteralIn = defineRule19({
+var noLiteralIn = defineRule20({
   meta: {
     type: "suggestion",
     schema: [
@@ -2586,13 +2715,13 @@ var noLiteralIn = defineRule19({
 });
 
 // src/rules/no-local-schema-construction.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
+import { defineRule as defineRule21 } 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 = defineRule20({
+var noLocalSchemaConstruction = defineRule21({
   meta: {
     type: "problem",
     schema: [
@@ -2714,8 +2843,8 @@ var noLocalSchemaConstruction = defineRule20({
 });
 
 // src/rules/no-member-comments.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
-var noMemberComments = defineRule21({
+import { defineRule as defineRule22 } from "@oxlint/plugins";
+var noMemberComments = defineRule22({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -2811,7 +2940,7 @@ var noMemberComments = defineRule21({
 });
 
 // src/rules/no-module-mutable-state.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
+import { defineRule as defineRule23 } from "@oxlint/plugins";
 function moduleMutableStateBindings(pattern) {
   if (pattern.type === "Identifier") {
     return [{ name: pattern.name, node: pattern }];
@@ -2850,7 +2979,7 @@ function moduleMutableStateInsideAmbient(node) {
   }
   return false;
 }
-var noModuleMutableState = defineRule22({
+var noModuleMutableState = defineRule23({
   meta: {
     type: "problem",
     schema: [
@@ -2902,7 +3031,7 @@ var noModuleMutableState = defineRule22({
 });
 
 // src/rules/no-promise-all-mutation.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
+import { defineRule as defineRule24 } from "@oxlint/plugins";
 function mutationBinding(node) {
   if (node.type === "Identifier") {
     return node;
@@ -2930,7 +3059,7 @@ function mutationBindings(node) {
     }
   }
 }
-var noPromiseAllMutation = defineRule23({
+var noPromiseAllMutation = defineRule24({
   meta: {
     type: "problem",
     schema: [
@@ -3030,8 +3159,8 @@ var noPromiseAllMutation = defineRule23({
 });
 
 // src/rules/no-rederive-schema.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
-var noRederiveSchema = defineRule24({
+import { defineRule as defineRule25 } from "@oxlint/plugins";
+var noRederiveSchema = defineRule25({
   meta: {
     type: "problem",
     schema: [
@@ -3075,7 +3204,7 @@ var noRederiveSchema = defineRule24({
 });
 
 // src/rules/no-restricted-constructor.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
+import { defineRule as defineRule26 } from "@oxlint/plugins";
 function restrictedConstructorEntries(constructors) {
   const entries = new Map;
   for (const item of constructors) {
@@ -3091,7 +3220,7 @@ function restrictedConstructorEntries(constructors) {
   }
   return entries;
 }
-var noRestrictedConstructor = defineRule25({
+var noRestrictedConstructor = defineRule26({
   meta: {
     type: "problem",
     schema: [
@@ -3166,8 +3295,8 @@ var noRestrictedConstructor = defineRule25({
 });
 
 // src/rules/no-restricted-files.ts
-import { defineRule as defineRule26 } from "@oxlint/plugins";
-var noRestrictedFiles = defineRule26({
+import { defineRule as defineRule27 } from "@oxlint/plugins";
+var noRestrictedFiles = defineRule27({
   meta: {
     type: "problem",
     schema: [
@@ -3199,7 +3328,7 @@ var noRestrictedFiles = defineRule26({
 });
 
 // src/rules/no-restricted-token.ts
-import { defineRule as defineRule27 } from "@oxlint/plugins";
+import { defineRule as defineRule28 } from "@oxlint/plugins";
 function tokenIsTypeOnlyImport(node) {
   const parent = node.parent;
   if (parent?.type === "ImportSpecifier") {
@@ -3210,7 +3339,7 @@ function tokenIsTypeOnlyImport(node) {
 function memberMatches(node, restriction) {
   return restriction.startsWith("*.") ? astStaticMemberName(node) === restriction.slice(2) : astDottedName(node) === restriction;
 }
-var noRestrictedToken = defineRule27({
+var noRestrictedToken = defineRule28({
   meta: {
     type: "problem",
     schema: [
@@ -3307,7 +3436,7 @@ var noRestrictedToken = defineRule27({
 });
 
 // src/rules/no-runtime-in-types.ts
-import { defineRule as defineRule28 } from "@oxlint/plugins";
+import { defineRule as defineRule29 } from "@oxlint/plugins";
 function isTypeOnlyImport(statement) {
   return statement.importKind === "type" || statement.specifiers.length > 0 && statement.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
 }
@@ -3524,7 +3653,7 @@ function isRuntimeReExport(statement, runtimeImportLocals, valueNames, isAmbient
   }
   return statement.specifiers.some((specifier) => specifier.exportKind !== "type" && runtimeImportLocals.has(exportLocalName(specifier)));
 }
-var noRuntimeInTypes = defineRule28({
+var noRuntimeInTypes = defineRule29({
   meta: {
     type: "problem",
     schema: [
@@ -3668,7 +3797,7 @@ var noRuntimeInTypes = defineRule28({
 });
 
 // src/rules/no-single-use-scalar-schema.ts
-import { defineRule as defineRule29 } from "@oxlint/plugins";
+import { defineRule as defineRule30 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -3702,7 +3831,7 @@ function isAllowedStructuralElement(identifier, initializer, ancestors, options2
   const method = call.callee.type === "MemberExpression" ? astStaticMemberName(call.callee) : undefined;
   return Boolean(method && options2.methods.includes(method) && schemasElements(call).includes(identifier));
 }
-var noSingleUseScalarSchema = defineRule29({
+var noSingleUseScalarSchema = defineRule30({
   meta: {
     type: "suggestion",
     schema: [
@@ -3787,8 +3916,8 @@ var noSingleUseScalarSchema = defineRule29({
 });
 
 // src/rules/no-top-level-functions.ts
-import { defineRule as defineRule30 } from "@oxlint/plugins";
-var noTopLevelFunctions = defineRule30({
+import { defineRule as defineRule31 } from "@oxlint/plugins";
+var noTopLevelFunctions = defineRule31({
   meta: {
     type: "problem",
     schema: [
@@ -3847,7 +3976,7 @@ var noTopLevelFunctions = defineRule30({
 });
 
 // src/rules/no-trivial-functions.ts
-import { defineRule as defineRule31 } from "@oxlint/plugins";
+import { defineRule as defineRule32 } from "@oxlint/plugins";
 
 // src/constants/trivial.constants.ts
 var trivialBannedNames = [
@@ -3863,7 +3992,7 @@ var trivialBannedNames = [
 ];
 
 // src/rules/no-trivial-functions.ts
-var noTrivialFunctions = defineRule31({
+var noTrivialFunctions = defineRule32({
   meta: {
     type: "problem",
     schema: [
@@ -3980,8 +4109,8 @@ var noTrivialFunctions = defineRule31({
 });
 
 // src/rules/no-type-declarations.ts
-import { defineRule as defineRule32 } from "@oxlint/plugins";
-var noTypeDeclarations = defineRule32({
+import { defineRule as defineRule33 } from "@oxlint/plugins";
+var noTypeDeclarations = defineRule33({
   meta: {
     type: "problem",
     schema: [
@@ -4026,8 +4155,8 @@ var noTypeDeclarations = defineRule32({
 });
 
 // src/rules/no-unescaped-like.ts
-import { defineRule as defineRule33 } from "@oxlint/plugins";
-var noUnescapedLike = defineRule33({
+import { defineRule as defineRule34 } from "@oxlint/plugins";
+var noUnescapedLike = defineRule34({
   meta: {
     type: "problem",
     schema: [
@@ -4078,7 +4207,7 @@ var noUnescapedLike = defineRule33({
 });
 
 // src/rules/object-multiline.ts
-import { defineRule as defineRule34 } from "@oxlint/plugins";
+import { defineRule as defineRule35 } from "@oxlint/plugins";
 function objectMultilineIsCallArg(node) {
   const parent = node.parent;
   return (parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node);
@@ -4111,14 +4240,14 @@ function objectMultilineGaps(text, node) {
     if (!objectMultilineIsWhitespace(between.slice(0, comma)) || !objectMultilineIsWhitespace(between.slice(comma + 1))) {
       return null;
     }
-    gaps.push([after + comma + 1, limit]);
+    gaps.push([next ? after + comma + 1 : after, limit]);
   }
   return gaps;
 }
-var objectMultiline = defineRule34({
+var objectMultiline = defineRule35({
   meta: {
     type: "layout",
-    fixable: "whitespace",
+    fixable: "code",
     schema: [
       {
         type: "object",
@@ -4168,7 +4297,7 @@ var objectMultiline = defineRule34({
             if (!gaps) {
               return null;
             }
-            return gaps.map((gap, index) => fixer.replaceTextRange(gap, `${newline}${index === gaps.length - 1 ? baseIndent : propIndent}`));
+            return gaps.map((gap, index) => fixer.replaceTextRange(gap, index === gaps.length - 1 ? `,${newline}${baseIndent}` : `${newline}${propIndent}`));
           }
         });
       }
@@ -4177,8 +4306,8 @@ var objectMultiline = defineRule34({
 });
 
 // src/rules/only-export-components.ts
-import { defineRule as defineRule35 } from "@oxlint/plugins";
-var onlyExportComponents = defineRule35({
+import { defineRule as defineRule36 } from "@oxlint/plugins";
+var onlyExportComponents = defineRule36({
   meta: {
     type: "problem",
     schema: [
@@ -4187,6 +4316,7 @@ var onlyExportComponents = defineRule35({
         additionalProperties: false,
         properties: {
           matchFileName: { type: "boolean" },
+          trailingRoles: { type: "array", items: { type: "string" } },
           allowTypeExports: { type: "boolean" },
           denyTypePattern: optionsPatternSchema
         }
@@ -4204,10 +4334,15 @@ var onlyExportComponents = defineRule35({
       Program(program) {
         const {
           matchFileName = true,
+          trailingRoles = [],
           allowTypeExports = true,
           denyTypePattern
         } = optionsFirst(context, {});
-        const expected = reactComponentsPascalFromBasename(namingFileBasename(context.filename));
+        const basename = namingFileBasename(context.filename);
+        const extension = basename.slice(basename.lastIndexOf("."));
+        const role = trailingRoles.find((candidate) => basename.endsWith(`.${candidate}${extension}`));
+        const expected = reactComponentsPascalFromBasename(role ? basename.replace(`.${role}${extension}`, extension) : basename);
+        const expectedKeys = [expected, ...role ? [reactComponentsPascalFromBasename(basename)] : []].map((name) => name.toLowerCase());
         const denied = optionsOptionalPatterns(denyTypePattern);
         const components = [];
         for (const candidate of reactComponentsExportCandidates(program)) {
@@ -4240,10 +4375,9 @@ var onlyExportComponents = defineRule35({
         if (components.length === 0 || !matchFileName) {
           return;
         }
-        const expectedKey = expected.toLowerCase();
-        const exact = components.some((candidate) => candidate.name.toLowerCase() === expectedKey);
-        const allPrefixed = components.every((candidate) => candidate.name.toLowerCase().startsWith(expectedKey));
-        if (!exact && !allPrefixed) {
+        const names = components.map((candidate) => candidate.name.toLowerCase());
+        const matches = expectedKeys.some((expectedKey) => names.includes(expectedKey) || names.every((name) => name.startsWith(expectedKey)));
+        if (!matches) {
           for (const candidate of components) {
             context.report({
               node: candidate.node,
@@ -4258,7 +4392,7 @@ var onlyExportComponents = defineRule35({
 });
 
 // src/rules/only-export-constants.ts
-import { defineRule as defineRule36 } from "@oxlint/plugins";
+import { defineRule as defineRule37 } from "@oxlint/plugins";
 function bindingNames(pattern) {
   switch (pattern.type) {
     case "Identifier":
@@ -4313,7 +4447,7 @@ function collectBindings(program) {
   }
   return bindings;
 }
-var onlyExportConstants = defineRule36({
+var onlyExportConstants = defineRule37({
   meta: {
     type: "problem",
     schema: [
@@ -4401,7 +4535,7 @@ var onlyExportConstants = defineRule36({
 });
 
 // src/rules/padding-between-statements.ts
-import { defineRule as defineRule37 } from "@oxlint/plugins";
+import { defineRule as defineRule38 } from "@oxlint/plugins";
 function paddingKind(node) {
   if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") {
     return node.declaration ? paddingKind(node.declaration) : "other";
@@ -4453,7 +4587,7 @@ function paddingBlankLineFix(sourceText, comments2, prev, curr, newline) {
   }
   return { newlineEnd, newline };
 }
-var paddingBetweenStatements = defineRule37({
+var paddingBetweenStatements = defineRule38({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4527,7 +4661,7 @@ var paddingBetweenStatements = defineRule37({
 });
 
 // src/rules/prefer-namespace-type-import.ts
-import { defineRule as defineRule38 } from "@oxlint/plugins";
+import { defineRule as defineRule39 } 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) {
@@ -4551,7 +4685,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 = defineRule38({
+var preferNamespaceTypeImport = defineRule39({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -4668,8 +4802,8 @@ var preferNamespaceTypeImport = defineRule38({
 });
 
 // src/rules/require-file-factory.ts
-import { defineRule as defineRule39 } from "@oxlint/plugins";
-var requireFileFactory = defineRule39({
+import { defineRule as defineRule40 } from "@oxlint/plugins";
+var requireFileFactory = defineRule40({
   meta: {
     type: "problem",
     schema: [
@@ -4717,8 +4851,8 @@ var requireFileFactory = defineRule39({
 });
 
 // src/rules/require-object-params.ts
-import { defineRule as defineRule40 } from "@oxlint/plugins";
-var requireObjectParams = defineRule40({
+import { defineRule as defineRule41 } from "@oxlint/plugins";
+var requireObjectParams = defineRule41({
   meta: {
     type: "problem",
     schema: [
@@ -4776,8 +4910,8 @@ var requireObjectParams = defineRule40({
 });
 
 // src/rules/require-orpc-output.ts
-import { defineRule as defineRule41 } from "@oxlint/plugins";
-var requireOrpcOutput = defineRule41({
+import { defineRule as defineRule42 } from "@oxlint/plugins";
+var requireOrpcOutput = defineRule42({
   meta: {
     type: "problem",
     schema: [
@@ -4825,8 +4959,8 @@ var requireOrpcOutput = defineRule41({
 });
 
 // src/rules/require-paired-call.ts
-import { defineRule as defineRule42 } from "@oxlint/plugins";
-var requirePairedCall = defineRule42({
+import { defineRule as defineRule43 } from "@oxlint/plugins";
+var requirePairedCall = defineRule43({
   meta: {
     type: "problem",
     schema: [
@@ -4900,8 +5034,8 @@ var requirePairedCall = defineRule42({
 });
 
 // src/rules/route-surface.ts
-import { defineRule as defineRule43 } from "@oxlint/plugins";
-var routeSurface = defineRule43({
+import { defineRule as defineRule44 } from "@oxlint/plugins";
+var routeSurface = defineRule44({
   meta: {
     type: "problem",
     schema: [
@@ -4910,13 +5044,21 @@ var routeSurface = defineRule43({
         additionalProperties: false,
         properties: {
           exportName: { type: "string" },
+          allowedExports: { type: "array", items: { type: "string" } },
+          inspectExports: { type: "boolean" },
           bannedHooks: { type: "array", items: { type: "string" } },
           banIntrinsicJsx: { type: "boolean" }
         }
       }
     ],
     defaultOptions: [
-      { exportName: "Route", bannedHooks: ["useState", "useEffect", "useMutation"], banIntrinsicJsx: true }
+      {
+        exportName: "Route",
+        allowedExports: [],
+        inspectExports: false,
+        bannedHooks: ["useState", "useEffect", "useMutation"],
+        banIntrinsicJsx: true
+      }
     ],
     messages: {
       extraExport: "Route files may only export '{{expected}}'; found '{{actual}}'.",
@@ -4927,27 +5069,135 @@ var routeSurface = defineRule43({
   createOnce(context) {
     return {
       Program(program) {
-        const { exportName, bannedHooks, banIntrinsicJsx } = optionsFirst(context);
-        for (const binding of exportsCollect(program)) {
-          if (binding.exportedName !== exportName) {
+        const { exportName, allowedExports = [], inspectExports = false, bannedHooks, banIntrinsicJsx } = optionsFirst(context);
+        const allowed = new Set([exportName, ...allowedExports]);
+        const bindings = exportsCollect(program);
+        for (const binding of bindings) {
+          if (!allowed.has(binding.exportedName)) {
             context.report({
               node: binding.node,
               messageId: "extraExport",
-              data: { expected: exportName, actual: binding.exportedName }
+              data: { expected: [...allowed].join("', '"), actual: binding.exportedName }
             });
           }
         }
         const banned = new Set(bannedHooks);
+        const inspected = new Set;
         for (const item of declarationsTopLevelUnexportedFunctions(program)) {
+          inspected.add(item.node.start);
           routesInspectFunction(context, item, banned, banIntrinsicJsx);
         }
+        if (!inspectExports)
+          return;
+        const names = new Set(bindings.filter((binding) => binding.exportedName === exportName).map((binding) => binding.localName ?? binding.exportedName));
+        const defaultExport = program.body.find((statement) => statement.type === "ExportDefaultDeclaration");
+        const declaration = defaultExport?.declaration;
+        const defaultFunctions = declaration?.type === "ArrowFunctionExpression" || declaration?.type === "FunctionExpression" ? [{ name: "default", node: declaration }] : [];
+        for (const item of [...exportsCollectFunctions(program), ...defaultFunctions]) {
+          if (names.has(item.name) && !inspected.has(item.node.start))
+            routesInspectFunction(context, item, banned, banIntrinsicJsx);
+        }
+      }
+    };
+  }
+});
+
+// src/rules/ternary-layout.ts
+import { defineRule as defineRule45 } from "@oxlint/plugins";
+function ternaryLayoutLineStart(text, offset) {
+  return text.lastIndexOf(`
+`, offset - 1) + 1;
+}
+function ternaryLayoutLineEnd(text, offset) {
+  const end = text.indexOf(`
+`, offset);
+  if (end === -1) {
+    return text.length;
+  }
+  return text[end - 1] === "\r" ? end - 1 : end;
+}
+function ternaryLayoutBreak(between, operator, newline) {
+  const at = between.indexOf(operator);
+  return `${between.slice(0, at).trimEnd()}${newline}${operator} ${between.slice(at + 1).trimStart()}`;
+}
+var ternaryLayout = defineRule45({
+  meta: {
+    type: "layout",
+    fixable: "whitespace",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          maxLength: {
+            type: "integer",
+            minimum: 1,
+            default: 160
+          },
+          indent: {
+            type: "integer",
+            minimum: 1,
+            default: 2
+          }
+        }
+      }
+    ],
+    messages: {
+      join: "Keep this conditional on one line ({{length}} columns; limit {{max}}, except in template literals).",
+      split: "This conditional does not fit on one line ({{length}} of {{max}} columns); break before `?` and `:`."
+    }
+  },
+  createOnce(context) {
+    let maxLength = 160;
+    let indent = 2;
+    return {
+      before() {
+        const options2 = optionsFirst(context, {});
+        maxLength = options2.maxLength ?? 160;
+        indent = options2.indent ?? 2;
+      },
+      ConditionalExpression(node) {
+        const source = context.sourceCode;
+        const text = source.text;
+        const operands = [node.test, node.consequent, node.alternate];
+        if (node.parent.type === "ConditionalExpression" || operands.some((operand) => operand.type === "ConditionalExpression" || operand.loc.start.line !== operand.loc.end.line) || source.getCommentsInside(node).length > 0) {
+          return;
+        }
+        const prefix = text.slice(ternaryLayoutLineStart(text, node.range[0]), node.range[0]);
+        const suffix = text.slice(node.range[1], ternaryLayoutLineEnd(text, node.range[1]));
+        const joined = text.slice(node.range[0], node.range[1]).replace(/\s*\n\s*/g, " ");
+        const length = prefix.length + joined.length + suffix.length;
+        const onOneLine = node.loc.start.line === node.loc.end.line;
+        const interpolated = node.parent.type === "TemplateLiteral";
+        if (!onOneLine && (interpolated || length <= maxLength)) {
+          context.report({
+            node,
+            messageId: "join",
+            data: { length: String(length), max: String(maxLength) },
+            fix: (fixer) => fixer.replaceTextRange(node.range, joined)
+          });
+        }
+        if (onOneLine && !interpolated && length > maxLength) {
+          const newline = `${layoutNewline(text)}${layoutLineIndent(text, node.range[0])}${" ".repeat(indent)}`;
+          const question = [node.test.range[1], node.consequent.range[0]];
+          const colon = [node.consequent.range[1], node.alternate.range[0]];
+          context.report({
+            node,
+            messageId: "split",
+            data: { length: String(length), max: String(maxLength) },
+            fix: (fixer) => [
+              fixer.replaceTextRange(question, ternaryLayoutBreak(text.slice(...question), "?", newline)),
+              fixer.replaceTextRange(colon, ternaryLayoutBreak(text.slice(...colon), ":", newline))
+            ]
+          });
+        }
       }
     };
   }
 });
 
 // src/rules/test-title-pattern.ts
-import { defineRule as defineRule44 } from "@oxlint/plugins";
+import { defineRule as defineRule46 } from "@oxlint/plugins";
 var TEST_MODIFIERS = new Set(["only", "skip", "concurrent", "sequential", "todo", "each", "for"]);
 function isConfiguredName(name, callees) {
   if (!name) {
@@ -4987,7 +5237,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 = defineRule44({
+var testTitlePattern = defineRule46({
   meta: {
     type: "suggestion",
     schema: [
@@ -5066,6 +5316,7 @@ var testTitlePattern = defineRule44({
 var src_default = eslintCompatPlugin({
   meta: { name: "arch" },
   rules: {
+    "call-arguments-multiline": callArgumentsMultiline,
     "call-array-multiline": callArrayMultiline,
     "chain-newline": chainNewline,
     "component-props": componentProps,
@@ -5109,6 +5360,7 @@ var src_default = eslintCompatPlugin({
     "require-orpc-output": requireOrpcOutput,
     "require-paired-call": requirePairedCall,
     "route-surface": routeSurface,
+    "ternary-layout": ternaryLayout,
     "test-title-pattern": testTitlePattern
   }
 });