oxlint-plugin-arch 0.3.3 → 0.4.0

package/CHANGELOG.md

@@ -1,8 +1,18 @@
 # Changelog
 
-## 0.3.2
+## Unreleased
 
-- Fix `chain-newline` reporting already-wrapped chains whose root is parenthesized, like `(db as TestDb)\n  .insertInto()`, spans several lines, or has a comment between two links.
+- Add `prefer-namespace-type-import` with a configurable named-type-import limit (default 3), module-specific namespace names, and scope-aware autofixes that qualify type references while reporting unsafe rewrites without a fix.
+
+- Options that took one regex string now also take a non-empty list, where any pattern may match: `pattern`, `allowPattern`, `allowNamePattern`, `denyTypePattern`, `hookPattern`, `rootPattern`, `factoryPattern`, `forbid`, and `require`. Single strings keep their behavior.
+- `no-type-declarations` `allowPattern` entries starting with `=` or `^=` match a type alias's value (`= ` plus its source text) instead of its name, so `'^= ReturnType<typeof '` keeps factory return types next to their factory. A name pattern that starts with `=` or `^=` is now read as a value pattern.
+- Fix `declaration-name` `pattern` with `g` or `y` flags rejecting every name after the first match.
+
+## 0.3.3
+
+Version 0.3.2 was tagged but never published to npm; 0.3.3 contains its fixes.
+
+- Fix `chain-newline` reporting chains that already have one call per line when the root is parenthesized (`(db as TestDb)\n  .insertInto()`), the root spans several lines, or a comment sits between two links.
 - Autofix `call-array-multiline` arrays with parenthesized elements, like `Promise.all([(a), (b)])`.
 
 ## 0.3.1

package/README.md

@@ -6,7 +6,7 @@ Keep a codebase shaped the way you designed it: files in the right folders, expo
 
 - 🗂️ **Filename-aware.** Rules derive expected names from the file they run on (`user-action.create.ts` → `makeUserActionCreate`).
 - 🎛️ **Configurable.** No app names, folders, or libraries are baked in. Globs and policy live in your config.
-- 🛟 **Safe autofix.** Fixable rules only touch whitespace or comments, and never guess when a fix could change your code.
+- 🛟 **Safe autofix.** Layout and comment rules only touch whitespace or comments. Type-import fixes qualify scope-resolved references and skip unsafe rewrites.
 - ⚡ **Fast.** Built on Oxlint's JS plugin API and ESTree, with no extra parser.
 
 ---
@@ -65,7 +65,7 @@ export default defineConfig({
 | --- | --- |
 | [`minimal.oxlint.config.ts`](examples/minimal.oxlint.config.ts) | You want the smallest possible starting point. |
 | [`monorepo.oxlint.config.ts`](examples/monorepo.oxlint.config.ts) | ⭐ You are starting an `apps/server` + `apps/web` monorepo and want a strict, copy-ready setup. |
-| [`full.oxlint.config.ts`](examples/full.oxlint.config.ts) | You want to see every one of the 42 rules with its options. |
+| [`full.oxlint.config.ts`](examples/full.oxlint.config.ts) | You want to see every one of the 43 rules with its options. |
 
 > [!TIP]
 > `monorepo.oxlint.config.ts` already loads `oxlint-plugin-arch`, so you can copy it as-is and adjust globs and names. The other two load `../src/index.ts`; change that specifier to `oxlint-plugin-arch` when you copy them.
@@ -74,7 +74,9 @@ export default defineConfig({
 
 ## 🧩 Rules
 
-42 rules in 9 groups. 🔧 means the rule can autofix. Each rule file in [`src/rules/`](src/rules) explains its behavior in plain English, and the tests in [`src/tests/`](src/tests) show every option shape.
+43 rules in 9 groups. 🔧 means the rule can autofix. Each rule file in [`src/rules/`](src/rules) explains its behavior in plain English, and the tests in [`src/tests/`](src/tests) show every option shape.
+
+Options that take one regex string (`pattern`, `allowPattern`, `forbid`, `require`, and the other `*Pattern` options) also take a non-empty list; any pattern in the list may match. Options that were already lists, such as `allowPatterns` and `allowCallees`, are unchanged.
 
 ### 📁 Files & folders
 
@@ -115,6 +117,7 @@ export default defineConfig({
 | `no-type-declarations` | No type aliases or interfaces in matched files, so types live in one place. |
 | `no-runtime-in-types` | Type modules stay free of runtime code. Opt in to also ban runtime imports and re-exports. |
 | `no-imported-type-alias` | No exported aliases that only rename an imported type. |
+| `prefer-namespace-type-import` 🔧 | Long type-only named imports become a namespace import with qualified references. [Details ↓](#prefer-namespace-type-import) |
 
 ### 🧪 Schemas & APIs
 
@@ -198,6 +201,46 @@ Use `no-type-declarations` separately to control where named types may live. Wit
 
 </details>
 
+### `prefer-namespace-type-import`
+
+Prefers a namespace when a type-only import has **more than** `max` named specifiers. Both `import type { A, B }` and `import { type A, type B }` are checked; any runtime or default binding leaves the declaration alone.
+
+| Option | Default | What it does |
+| --- | --- | --- |
+| `max` | `3` | Maximum named specifiers allowed (non-negative integer). Three passes; four fails. |
+| `names` | `{}` | Exact module-path-to-namespace-name map, such as `{ '#/types/room.types': 'RoomTypes' }`. Values must be ASCII binding identifiers, not reserved words. |
+
+The default name is the last path segment in PascalCase, stripping JS/TS extensions and adding `Types` unless already present: `#/types/room.types` → `RoomTypes`, `./harness.types.ts` → `HarnessTypes`, `@orbs/server/client` → `ClientTypes`. Other punctuation separates words; names starting with a digit get a `Module` prefix.
+
+```ts
+// Before
+import type { A, B as LocalB, C, D } from './room.types'
+export type Result = [A, LocalB, C, D]
+
+// After
+import type * as RoomTypes from './room.types'
+export type Result = [RoomTypes.A, RoomTypes.B, RoomTypes.C, RoomTypes.D]
+```
+
+The autofix updates scope-resolved type references, generics, indexed access, type-position `typeof`, interface heritage, and class implementations, including TSX. Shadowed local names are untouched. Exported type declarations are updated, but local export lists (`export type { A }`, `export { type A }`, or `export { A }`) are **report-only**; direct re-exports from another module are untouched.
+
+The diagnostic explains why an autofix was skipped: comments inside the import, an existing namespace import from the same module (no merging), a namespace name colliding with any binding/reference in the file or another proposed namespace, an unsupported imported name, or a reference outside the supported type syntax. Multiple qualifying imports from the same module are report-only too. Choose distinct `names` overrides to resolve collisions between different modules. Fixes preserve the module string, import attributes, semicolon, and comments outside the import.
+
+### `no-type-declarations`
+
+Rejects type aliases and interfaces in matched files, so types live in one place.
+
+| Option | Default | What it does |
+| --- | --- | --- |
+| `allowPattern` | none | Keep a declaration whose **name** matches. A pattern that starts with `=` or `^=` matches a type alias's **value** instead: `= ` followed by the value's source text, without surrounding parentheses or comments. Interfaces have no value, so only name patterns apply to them. |
+
+```ts
+// allowPattern: ['(Service|Deps)$', '^= ReturnType<typeof ']
+export type AiRetry = ReturnType<typeof makeAiRetry>  // ✅ value matches
+export interface OrderDeps { db: Database }            // ✅ name matches
+export type OrderCreateParams = { id: string }         // ❌ move it to your types file
+```
+
 ### `only-export-constants`
 
 Every runtime export must point to a local `const`. Direct, destructured, renamed, and default exports of local constants all work.

package/dist/index.js

@@ -551,6 +551,27 @@ function factoriesObjectPropertyName(property) {
 function optionsFirst(context, fallback) {
   return context.options[0] ?? fallback;
 }
+var optionsPatternSchema = {
+  anyOf: [
+    { type: "string" },
+    { type: "array", items: { type: "string" }, minItems: 1 }
+  ]
+};
+function optionsPatterns(pattern, flags) {
+  return pattern === undefined ? [] : [pattern].flat().map((source) => new RegExp(source, flags));
+}
+function optionsOptionalPatterns(pattern, flags) {
+  return optionsPatterns(pattern === undefined ? undefined : [pattern].flat().filter((source) => source !== ""), flags);
+}
+function optionsPatternLabel(pattern) {
+  return pattern === undefined ? "" : [pattern].flat().join(" | ");
+}
+function optionsPatternsTest(patterns, value) {
+  return patterns.some((pattern) => {
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+  });
+}
 // src/utils/helpers/orpc.ts
 function orpcFindChainCall(expression, method) {
   if (expression.type === "CallExpression") {
@@ -947,7 +968,7 @@ function chainNewlineRootIdentifier(node) {
 function chainNewlineMatches(root, links, group) {
   if (links.length < group.minDepth)
     return false;
-  const hasCriteria = group.methods !== undefined || group.onlyMethods !== undefined || group.rootPattern !== undefined;
+  const hasCriteria = group.methods !== undefined || group.onlyMethods !== undefined || group.rootPatterns.length > 0;
   if (!hasCriteria)
     return true;
   if (group.methods && links.some((link) => link.methodName !== null && group.methods?.has(link.methodName))) {
@@ -956,7 +977,7 @@ function chainNewlineMatches(root, links, group) {
   if (group.onlyMethods && links.every((link) => link.methodName !== null && group.onlyMethods?.has(link.methodName)))
     return true;
   const rootName = chainNewlineRootIdentifier(root);
-  return rootName !== null && group.rootPattern !== undefined && group.rootPattern.test(rootName);
+  return rootName !== null && optionsPatternsTest(group.rootPatterns, rootName);
 }
 var chainNewline = defineRule2({
   meta: {
@@ -975,7 +996,7 @@ var chainNewline = defineRule2({
               minDepth: { type: "integer", minimum: 1 },
               methods: { type: "array", items: { type: "string" } },
               onlyMethods: { type: "array", items: { type: "string" } },
-              rootPattern: { type: "string" }
+              rootPattern: optionsPatternSchema
             },
             required: ["minDepth"]
           }
@@ -1001,7 +1022,7 @@ var chainNewline = defineRule2({
           minDepth: group.minDepth,
           methods: group.methods ? new Set(group.methods) : undefined,
           onlyMethods: group.onlyMethods ? new Set(group.onlyMethods) : undefined,
-          rootPattern: group.rootPattern === undefined ? undefined : new RegExp(group.rootPattern)
+          rootPatterns: optionsPatterns(group.rootPattern)
         }));
         indentUnit = layoutIndentUnit(options.indent);
         newline = layoutNewline(context.sourceCode.text);
@@ -1074,14 +1095,14 @@ var declarationName = defineRule3({
           type: "array",
           items: { type: "string", enum: [...declarationsKinds] }
         },
-        pattern: { type: "string" },
+        pattern: optionsPatternSchema,
         flags: { type: "string" },
         stem: { type: "string", enum: [...namingStemModes] },
         trailingRoles: { type: "array", items: { type: "string" } },
         roleSeparators: { type: "array", items: { type: "string" } },
         normalize: { type: "string", enum: ["remove-separators", "none"] },
         singularize: { type: "string", enum: ["none", "trailing-s"] },
-        allowPattern: { type: "string" }
+        allowPattern: optionsPatternSchema
       }
     }],
     messages: {
@@ -1092,23 +1113,23 @@ var declarationName = defineRule3({
   createOnce(context) {
     let options = {};
     let kinds = null;
-    let allowed = null;
-    let expected = null;
+    let allowed = [];
+    let expected = [];
     let prefixes = [];
     function check(node) {
       const item = declarationsNamedFromNode(node);
-      if (!item || kinds && !kinds.has(item.kind) || allowed?.test(item.name)) {
+      if (!item || kinds && !kinds.has(item.kind) || optionsPatternsTest(allowed, item.name)) {
         return;
       }
       const comparableName = options.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
-      const matches = expected ? expected.test(item.name) : prefixes.some((prefix) => comparableName.startsWith(prefix));
+      const matches = expected.length > 0 ? optionsPatternsTest(expected, item.name) : prefixes.some((prefix) => comparableName.startsWith(prefix));
       if (matches) {
         return;
       }
       context.report({
         node: item.node,
-        messageId: expected ? "pattern" : "prefix",
-        data: expected ? { name: item.name, pattern: options.pattern ?? "" } : { name: item.name, prefix: prefixes.join(" or ") }
+        messageId: expected.length > 0 ? "pattern" : "prefix",
+        data: expected.length > 0 ? { name: item.name, pattern: optionsPatternLabel([options.pattern ?? []].flat().filter((source) => source !== "")) } : { name: item.name, prefix: prefixes.join(" or ") }
       });
     }
     return {
@@ -1118,8 +1139,8 @@ var declarationName = defineRule3({
           normalize: "remove-separators"
         });
         kinds = options.kinds && options.kinds.length > 0 ? new Set(options.kinds) : null;
-        allowed = options.allowPattern ? new RegExp(options.allowPattern) : null;
-        expected = options.pattern ? new RegExp(options.pattern, options.flags) : null;
+        allowed = optionsOptionalPatterns(options.allowPattern);
+        expected = optionsOptionalPatterns(options.pattern, options.flags);
         const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
         const stem = namingFileStem(basename, options.stem, options.trailingRoles, options.roleSeparators);
         prefixes = namingFilePrefixes(stem, options.normalize ?? "remove-separators", options.singularize ?? "none");
@@ -1149,7 +1170,7 @@ var exportFilePrefix = defineRule4({
         normalize: { type: "string", enum: ["remove-separators", "none"] },
         singularize: { type: "string", enum: ["none", "trailing-s"] },
         allDeclarations: { type: "boolean" },
-        allowPattern: { type: "string" }
+        allowPattern: optionsPatternSchema
       }
     }],
     messages: {
@@ -1166,7 +1187,7 @@ var exportFilePrefix = defineRule4({
         const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
         const stem = namingFileStem(basename, options.stem, options.trailingRoles, options.roleSeparators);
         const prefixes = namingFilePrefixes(stem, options.normalize ?? "remove-separators", options.singularize ?? "none");
-        const allowed = options.allowPattern ? new RegExp(options.allowPattern) : null;
+        const allowed = optionsOptionalPatterns(options.allowPattern);
         const names = options.allDeclarations ? declarationsCollectNamed(program) : exportsCollect(program).map((binding) => ({
           name: binding.localName ?? binding.exportedName,
           node: binding.node
@@ -1175,7 +1196,7 @@ var exportFilePrefix = defineRule4({
         for (const item of names) {
           const key = `${item.name}:${item.node.start}:${item.node.end}`;
           const comparableName = options.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
-          if (seen.has(key) || allowed?.test(item.name) || prefixes.some((prefix) => comparableName.startsWith(prefix))) {
+          if (seen.has(key) || optionsPatternsTest(allowed, item.name) || prefixes.some((prefix) => comparableName.startsWith(prefix))) {
             continue;
           }
           seen.add(key);
@@ -1199,11 +1220,11 @@ var exportNamePattern = defineRule5({
       type: "object",
       additionalProperties: false,
       properties: {
-        pattern: { type: "string" },
+        pattern: optionsPatternSchema,
         flags: { type: "string" },
         ignoreTypeExports: { type: "boolean" },
         allDeclarations: { type: "boolean" },
-        allowPattern: { type: "string" }
+        allowPattern: optionsPatternSchema
       },
       required: ["pattern"]
     }],
@@ -1221,19 +1242,20 @@ var exportNamePattern = defineRule5({
           allDeclarations = false,
           allowPattern
         } = optionsFirst(context);
-        const allowed = allowPattern ? new RegExp(allowPattern) : null;
+        const allowed = optionsOptionalPatterns(allowPattern);
+        const expected = optionsPatterns(pattern, flags);
         const names = allDeclarations ? declarationsCollectNamed(program) : exportsCollect(program).flatMap((binding) => ignoreTypeExports && binding.typeOnly ? [] : [{ name: binding.localName ?? binding.exportedName, node: binding.node }]);
         const seen = new Set;
         for (const item of names) {
           const key = `${item.name}:${item.node.start}:${item.node.end}`;
-          if (seen.has(key) || allowed?.test(item.name) || new RegExp(pattern, flags).test(item.name)) {
+          if (seen.has(key) || optionsPatternsTest(allowed, item.name) || optionsPatternsTest(expected, item.name)) {
             continue;
           }
           seen.add(key);
           context.report({
             node: item.node,
             messageId: "pattern",
-            data: { name: item.name, pattern }
+            data: { name: item.name, pattern: optionsPatternLabel(pattern) }
           });
         }
       }
@@ -1312,7 +1334,7 @@ var filenameMatch = defineRule7({
       type: "object",
       additionalProperties: false,
       properties: {
-        pattern: { type: "string" },
+        pattern: optionsPatternSchema,
         message: { type: "string" },
         flags: { type: "string" }
       },
@@ -1326,7 +1348,8 @@ var filenameMatch = defineRule7({
     return {
       Program(program) {
         const { pattern, message, flags } = optionsFirst(context);
-        if (!new RegExp(pattern, flags).test(namingFileBasename(context.filename))) {
+        const patterns = optionsPatterns(pattern, flags);
+        if (!optionsPatternsTest(patterns, namingFileBasename(context.filename))) {
           context.report({
             node: program,
             messageId: "mismatch",
@@ -1798,7 +1821,7 @@ import { defineRule as defineRule13 } from "@oxlint/plugins";
 function compileFactoryKeys(pattern, keys, requireKeys) {
   const allowedList = keys.concat(requireKeys.filter((key) => !keys.includes(key)));
   return {
-    pattern: new RegExp(pattern),
+    patterns: optionsPatterns(pattern),
     allowed: new Set(allowedList),
     allowedList,
     requireKeys
@@ -1812,7 +1835,7 @@ var noExtraFactoryKeys = defineRule13({
       additionalProperties: false,
       properties: {
         keys: { type: "array", items: { type: "string" } },
-        factoryPattern: { type: "string" },
+        factoryPattern: optionsPatternSchema,
         requireKeys: { type: "array", items: { type: "string" } },
         keySets: {
           type: "array",
@@ -1820,7 +1843,7 @@ var noExtraFactoryKeys = defineRule13({
             type: "object",
             additionalProperties: false,
             properties: {
-              factoryPattern: { type: "string" },
+              factoryPattern: optionsPatternSchema,
               keys: { type: "array", items: { type: "string" } },
               requireKeys: { type: "array", items: { type: "string" } }
             },
@@ -1839,11 +1862,11 @@ var noExtraFactoryKeys = defineRule13({
     let keySets = [];
     let fallback;
     function resolveFactoryKeys(name) {
-      const matched = keySets.find((item) => item.pattern.test(name));
+      const matched = keySets.find((item) => optionsPatternsTest(item.patterns, name));
       if (matched) {
         return matched;
       }
-      if (fallback?.pattern.test(name)) {
+      if (fallback && optionsPatternsTest(fallback.patterns, name)) {
         return fallback;
       }
     }
@@ -1910,9 +1933,9 @@ var noFileLevelHelpers = defineRule14({
       type: "object",
       additionalProperties: false,
       properties: {
-        allowPattern: { type: "string" },
+        allowPattern: optionsPatternSchema,
         detectComponents: { type: "boolean" },
-        hookPattern: { type: "string" }
+        hookPattern: optionsPatternSchema
       }
     }],
     messages: {
@@ -1927,10 +1950,10 @@ var noFileLevelHelpers = defineRule14({
           detectComponents = true,
           hookPattern = "^use[A-Z]"
         } = optionsFirst(context, {});
-        const allowed = allowPattern ? new RegExp(allowPattern) : null;
-        const hooks = new RegExp(hookPattern);
+        const allowed = optionsOptionalPatterns(allowPattern);
+        const hooks = optionsPatterns(hookPattern);
         for (const candidate of declarationsFileLevelFunctionCandidates(program)) {
-          if (detectComponents && reactComponentsIsLike(program, candidate) || hooks.test(candidate.name) || allowed?.test(candidate.name)) {
+          if (detectComponents && reactComponentsIsLike(program, candidate) || optionsPatternsTest(hooks, candidate.name) || optionsPatternsTest(allowed, candidate.name)) {
             continue;
           }
           context.report({
@@ -2443,7 +2466,7 @@ var noModuleMutableState = defineRule21({
           type: "array",
           items: { type: "string", enum: ["let", "var"] }
         },
-        allowNamePattern: { type: "string" }
+        allowNamePattern: optionsPatternSchema
       }
     }],
     messages: {
@@ -2452,12 +2475,12 @@ var noModuleMutableState = defineRule21({
   },
   createOnce(context) {
     let kindSet = new Set(["let", "var"]);
-    let allowed = null;
+    let allowed = [];
     return {
       before() {
         const { kinds = ["let", "var"], allowNamePattern } = optionsFirst(context, {});
         kindSet = new Set(kinds);
-        allowed = allowNamePattern ? new RegExp(allowNamePattern) : null;
+        allowed = optionsOptionalPatterns(allowNamePattern);
       },
       VariableDeclaration(node) {
         if (node.declare || !kindSet.has(node.kind)) {
@@ -2468,7 +2491,7 @@ var noModuleMutableState = defineRule21({
         }
         for (const declarator of node.declarations) {
           for (const binding of moduleMutableStateBindings(declarator.id)) {
-            if (!allowed?.test(binding.name)) {
+            if (!optionsPatternsTest(allowed, binding.name)) {
               context.report({
                 node: binding.node,
                 messageId: "moduleState"
@@ -3349,7 +3372,7 @@ var noTopLevelFunctions = defineRule29({
       additionalProperties: false,
       properties: {
         banReExports: { type: "boolean" },
-        allowPattern: { type: "string" }
+        allowPattern: optionsPatternSchema
       }
     }],
     defaultOptions: [{ banReExports: true }],
@@ -3362,7 +3385,7 @@ var noTopLevelFunctions = defineRule29({
     return {
       Program(program) {
         const { banReExports, allowPattern } = optionsFirst(context);
-        const allowed = allowPattern ? new RegExp(allowPattern) : null;
+        const allowed = optionsOptionalPatterns(allowPattern);
         for (const statement of program.body) {
           if (banReExports && (statement.type === "ExportAllDeclaration" || statement.type === "ExportNamedDeclaration" && statement.source)) {
             context.report({ node: statement, messageId: "noReExport" });
@@ -3370,7 +3393,7 @@ var noTopLevelFunctions = defineRule29({
           }
           const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
           if (declaration?.type === "FunctionDeclaration") {
-            if (!allowed?.test(declarationsFunctionName(declaration))) {
+            if (!optionsPatternsTest(allowed, declarationsFunctionName(declaration))) {
               context.report({
                 node: declaration,
                 messageId: "noFunction",
@@ -3383,7 +3406,7 @@ var noTopLevelFunctions = defineRule29({
             continue;
           }
           for (const item of declaration.declarations) {
-            if ((item.init?.type === "FunctionExpression" || item.init?.type === "ArrowFunctionExpression") && !allowed?.test(declarationsFunctionName(item))) {
+            if ((item.init?.type === "FunctionExpression" || item.init?.type === "ArrowFunctionExpression") && !optionsPatternsTest(allowed, declarationsFunctionName(item))) {
               context.report({
                 node: item,
                 messageId: "noFunction",
@@ -3432,7 +3455,7 @@ var noTrivialFunctions = defineRule30({
       type: "object",
       additionalProperties: false,
       properties: {
-        allowPattern: { type: "string" },
+        allowPattern: optionsPatternSchema,
         allowCallees: { type: "array", items: { type: "string" } },
         allowAsync: { type: "boolean" }
       }
@@ -3442,13 +3465,13 @@ var noTrivialFunctions = defineRule30({
     }
   },
   createOnce(context) {
-    let allowed = null;
+    let allowed = [];
     let allowedCallees = [];
     let allowAsync = false;
     return {
       before() {
         const { allowPattern, allowCallees: calleePatterns = [], allowAsync: asyncAllowed = false } = optionsFirst(context, {});
-        allowed = allowPattern ? new RegExp(allowPattern) : null;
+        allowed = optionsOptionalPatterns(allowPattern);
         allowedCallees = calleePatterns.map((pattern) => new RegExp(pattern));
         allowAsync = asyncAllowed;
       },
@@ -3456,7 +3479,7 @@ var noTrivialFunctions = defineRule30({
         const seen = new Set;
         for (const item of [...exportsCollectFunctions(program), ...declarationsTopLevelUnexportedFunctions(program)]) {
           const key = `${item.name}:${item.node.start}:${item.node.end}`;
-          if (seen.has(key) || allowed?.test(item.name) || !declarationsIsTrivialFunction(item.node)) {
+          if (seen.has(key) || optionsPatternsTest(allowed, item.name) || !declarationsIsTrivialFunction(item.node)) {
             continue;
           }
           const expression = forwardedExpression(item.node);
@@ -3486,7 +3509,7 @@ var noTypeDeclarations = defineRule31({
       type: "object",
       additionalProperties: false,
       properties: {
-        allowPattern: { type: "string" }
+        allowPattern: optionsPatternSchema
       }
     }],
     messages: {
@@ -3494,11 +3517,13 @@ var noTypeDeclarations = defineRule31({
     }
   },
   createOnce(context) {
-    let allowed = null;
+    let allowedNames = [];
+    let allowedValues = [];
     function check(node) {
-      if (allowed?.test(node.id.name)) {
+      if (optionsPatternsTest(allowedNames, node.id.name))
+        return;
+      if (node.type === "TSTypeAliasDeclaration" && allowedValues.length > 0 && optionsPatternsTest(allowedValues, `= ${context.sourceCode.getText(node.typeAnnotation)}`))
         return;
-      }
       context.report({
         node,
         messageId: "typeDeclaration",
@@ -3508,7 +3533,10 @@ var noTypeDeclarations = defineRule31({
     return {
       before() {
         const { allowPattern } = optionsFirst(context, {});
-        allowed = allowPattern ? new RegExp(allowPattern) : null;
+        const sources = allowPattern === undefined ? [] : [allowPattern].flat();
+        const isValuePattern = (source) => /^\^?=/.test(source);
+        allowedNames = optionsOptionalPatterns(sources.filter((source) => !isValuePattern(source)));
+        allowedValues = optionsOptionalPatterns(sources.filter(isValuePattern));
       },
       TSTypeAliasDeclaration: check,
       TSInterfaceDeclaration: check
@@ -3671,7 +3699,7 @@ var onlyExportComponents = defineRule34({
       properties: {
         matchFileName: { type: "boolean" },
         allowTypeExports: { type: "boolean" },
-        denyTypePattern: { type: "string" }
+        denyTypePattern: optionsPatternSchema
       }
     }],
     messages: {
@@ -3690,7 +3718,7 @@ var onlyExportComponents = defineRule34({
           denyTypePattern
         } = optionsFirst(context, {});
         const expected = reactComponentsPascalFromBasename(namingFileBasename(context.filename));
-        const denied = denyTypePattern ? new RegExp(denyTypePattern) : null;
+        const denied = optionsOptionalPatterns(denyTypePattern);
         const components = [];
         for (const candidate of reactComponentsExportCandidates(program)) {
           if (candidate.typeOnly) {
@@ -3700,7 +3728,7 @@ var onlyExportComponents = defineRule34({
                 messageId: "typeExport",
                 data: { name: candidate.name, expected }
               });
-            } else if (denied?.test(candidate.name)) {
+            } else if (optionsPatternsTest(denied, candidate.name)) {
               context.report({
                 node: candidate.node,
                 messageId: "deniedType",
@@ -3995,9 +4023,142 @@ var paddingBetweenStatements = defineRule36({
   }
 });
 
-// src/rules/require-file-factory.ts
+// src/rules/prefer-namespace-type-import.ts
 import { defineRule as defineRule37 } from "@oxlint/plugins";
-var requireFileFactory = defineRule37({
+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) {
+  if (Object.hasOwn(names, source)) {
+    return names[source];
+  }
+  const stem = namingFileBasename(source).replace(/(?:\.d)?\.[cm]?[jt]sx?$/i, "");
+  const name = namingPascalCase(stem.replace(/[^A-Za-z0-9_$.-]/g, "-")) || "Module";
+  const prefixed = /^\d/.test(name) ? `Module${name}` : name;
+  return prefixed.endsWith("Types") ? prefixed : `${prefixed}Types`;
+}
+function isTypeOnlyNamedImport(node) {
+  return node.specifiers.length > 0 && node.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && (node.importKind === "type" || specifier.importKind === "type"));
+}
+function safeReference(node) {
+  let current = node;
+  let parent = current.parent;
+  while (parent?.type === "TSQualifiedName" && parent.left === current || parent?.type === "MemberExpression" && !parent.computed && parent.object === current) {
+    current = parent;
+    parent = current.parent;
+  }
+  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({
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        max: { type: "integer", minimum: 0 },
+        names: { type: "object", additionalProperties: { type: "string", pattern: bindingName.source } }
+      }
+    }],
+    defaultOptions: [{ max: 3, names: {} }],
+    messages: {
+      namespace: "Use a type namespace '{{name}}' for {{count}} named imports (maximum {{max}}).{{reason}}"
+    }
+  },
+  createOnce(context) {
+    const imports = [];
+    return {
+      before() {
+        imports.length = 0;
+      },
+      ImportDeclaration(node) {
+        imports.push(node);
+      },
+      "Program:exit"() {
+        const { max, names } = optionsFirst(context);
+        const candidates = imports.filter((node) => isTypeOnlyNamedImport(node) && node.specifiers.length > max);
+        if (candidates.length === 0) {
+          return;
+        }
+        const sourceCode = context.sourceCode;
+        const occupied = new Set;
+        for (const scope of sourceCode.scopeManager.scopes) {
+          for (const variable of scope.variables) {
+            occupied.add(variable.name);
+          }
+          for (const reference of scope.references) {
+            occupied.add(reference.identifier.name);
+          }
+        }
+        const proposed = candidates.map((node) => namespaceName(node.source.value, names));
+        const comments = sourceCode.getAllComments();
+        const reports = [];
+        const edits = [];
+        for (const [index, node] of candidates.entries()) {
+          const name = proposed[index];
+          let reason = "";
+          const replacements = new Map;
+          if (!bindingName.test(name) || reservedNames.has(name)) {
+            reason = "invalid namespace binding";
+          } else if (imports.some((other) => other.source.value === node.source.value && other.specifiers.some((specifier) => specifier.type === "ImportNamespaceSpecifier"))) {
+            reason = "existing namespace import from this module";
+          } else if (occupied.has(name) || proposed.some((other, otherIndex) => otherIndex !== index && other === name)) {
+            reason = "namespace name collides with a binding, reference, or another proposed namespace";
+          } else if (comments.some((comment) => comment.range[0] >= node.range[0] && comment.range[1] <= node.range[1])) {
+            reason = "comment inside import";
+          } else {
+            const variables = sourceCode.getDeclaredVariables(node);
+            for (const specifier of node.specifiers) {
+              if (specifier.type !== "ImportSpecifier") {
+                continue;
+              }
+              const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+              const variable = variables.find((binding) => binding.identifiers.some((id) => id.range[0] === specifier.local.range[0]));
+              if (!bindingName.test(imported) || !variable || variable.defs.length !== 1) {
+                reason = "unsupported imported name or binding";
+                break;
+              }
+              for (const reference of variable.references) {
+                const identifier = reference.identifier;
+                if (identifier.parent.type === "ExportSpecifier") {
+                  reason = "local re-export";
+                  break;
+                }
+                if (!safeReference(identifier)) {
+                  reason = "unsupported reference syntax";
+                  break;
+                }
+                replacements.set(identifier, `${name}.${imported}`);
+              }
+              if (reason) {
+                break;
+              }
+            }
+          }
+          reports.push({ node, name, reason });
+          if (!reason) {
+            edits.push({ range: [node.range[0], node.source.range[0]], text: `import type * as ${name} from ` });
+            for (const [identifier, text] of replacements) {
+              edits.push({ range: identifier.range, text });
+            }
+          }
+        }
+        for (const { node, name, reason } of reports) {
+          context.report({
+            node,
+            messageId: "namespace",
+            data: { name, count: node.specifiers.length, max, reason: reason ? ` Autofix skipped: ${reason}.` : "" },
+            fix: reason ? undefined : (fixer) => edits.map((edit) => fixer.replaceTextRange(edit.range, edit.text))
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/require-file-factory.ts
+import { defineRule as defineRule38 } from "@oxlint/plugins";
+var requireFileFactory = defineRule38({
   meta: {
     type: "problem",
     schema: [{
@@ -4043,8 +4204,8 @@ var requireFileFactory = defineRule37({
 });
 
 // src/rules/require-object-params.ts
-import { defineRule as defineRule38 } from "@oxlint/plugins";
-var requireObjectParams = defineRule38({
+import { defineRule as defineRule39 } from "@oxlint/plugins";
+var requireObjectParams = defineRule39({
   meta: {
     type: "problem",
     schema: [{
@@ -4053,7 +4214,7 @@ var requireObjectParams = defineRule38({
       properties: {
         maxParams: { type: "integer", minimum: 1 },
         allDeclarations: { type: "boolean" },
-        allowPattern: { type: "string" }
+        allowPattern: optionsPatternSchema
       }
     }],
     messages: {
@@ -4064,12 +4225,12 @@ var requireObjectParams = defineRule38({
     return {
       Program(program) {
         const { maxParams = 1, allDeclarations = false, allowPattern } = optionsFirst(context, {});
-        const allowed = allowPattern ? new RegExp(allowPattern) : null;
+        const allowed = optionsOptionalPatterns(allowPattern);
         const seen = new Set;
         const functions = allDeclarations ? [...exportsCollectFunctions(program), ...declarationsTopLevelUnexportedFunctions(program)] : exportsCollectFunctions(program);
         for (const item of functions) {
           const key = `${item.name}:${item.node.start}:${item.node.end}`;
-          if (seen.has(key) || allowed?.test(item.name)) {
+          if (seen.has(key) || optionsPatternsTest(allowed, item.name)) {
             continue;
           }
           seen.add(key);
@@ -4092,8 +4253,8 @@ var requireObjectParams = defineRule38({
 });
 
 // src/rules/require-orpc-output.ts
-import { defineRule as defineRule39 } from "@oxlint/plugins";
-var requireOrpcOutput = defineRule39({
+import { defineRule as defineRule40 } from "@oxlint/plugins";
+var requireOrpcOutput = defineRule40({
   meta: {
     type: "problem",
     schema: [{
@@ -4135,8 +4296,8 @@ var requireOrpcOutput = defineRule39({
 });
 
 // src/rules/require-paired-call.ts
-import { defineRule as defineRule40 } from "@oxlint/plugins";
-var requirePairedCall = defineRule40({
+import { defineRule as defineRule41 } from "@oxlint/plugins";
+var requirePairedCall = defineRule41({
   meta: {
     type: "problem",
     schema: [{
@@ -4211,8 +4372,8 @@ var requirePairedCall = defineRule40({
 });
 
 // src/rules/route-surface.ts
-import { defineRule as defineRule41 } from "@oxlint/plugins";
-var routeSurface = defineRule41({
+import { defineRule as defineRule42 } from "@oxlint/plugins";
+var routeSurface = defineRule42({
   meta: {
     type: "problem",
     schema: [{
@@ -4254,7 +4415,7 @@ var routeSurface = defineRule41({
 });
 
 // src/rules/test-title-pattern.ts
-import { defineRule as defineRule42 } from "@oxlint/plugins";
+import { defineRule as defineRule43 } from "@oxlint/plugins";
 var TEST_MODIFIERS = new Set(["only", "skip", "concurrent", "todo", "each"]);
 function isConfiguredName(name, callees) {
   if (!name) {
@@ -4291,7 +4452,10 @@ function regexMatches(regex, value) {
   regex.lastIndex = 0;
   return regex.test(value);
 }
-var testTitlePattern = defineRule42({
+function titlePatterns(pattern, flags) {
+  return pattern === undefined ? [] : [pattern].flat().map((source) => ({ regex: new RegExp(source, flags), pattern: source }));
+}
+var testTitlePattern = defineRule43({
   meta: {
     type: "suggestion",
     schema: [{
@@ -4299,8 +4463,8 @@ var testTitlePattern = defineRule42({
       additionalProperties: false,
       properties: {
         callees: { type: "array", items: { type: "string" } },
-        forbid: { type: "string" },
-        require: { type: "string" },
+        forbid: optionsPatternSchema,
+        require: optionsPatternSchema,
         flags: { type: "string", pattern: "^[dgimsuvy]*$" }
       }
     }],
@@ -4315,16 +4479,18 @@ var testTitlePattern = defineRule42({
   },
   createOnce(context) {
     let callees = [];
-    let forbid;
-    let required;
+    let forbid = [];
+    let required = [];
+    let requiredLabel = "";
     return {
       before() {
         const options = optionsFirst(context);
         callees = options.callees;
         const flags = options.flags ?? "";
-        forbid = options.forbid === undefined ? undefined : { regex: new RegExp(options.forbid, flags), pattern: options.forbid };
-        required = options.require === undefined ? undefined : { regex: new RegExp(options.require, flags), pattern: options.require };
-        if (forbid === undefined && required === undefined) {
+        forbid = titlePatterns(options.forbid, flags);
+        required = titlePatterns(options.require, flags);
+        requiredLabel = optionsPatternLabel(options.require);
+        if (forbid.length === 0 && required.length === 0) {
           return false;
         }
       },
@@ -4340,18 +4506,19 @@ var testTitlePattern = defineRule42({
         if (text === undefined) {
           return;
         }
-        if (forbid && regexMatches(forbid.regex, text)) {
+        const forbidden = forbid.find((item) => regexMatches(item.regex, text));
+        if (forbidden) {
           context.report({
             node: title,
             messageId: "forbidden",
-            data: { pattern: forbid.pattern }
+            data: { pattern: forbidden.pattern }
           });
         }
-        if (required && !regexMatches(required.regex, text)) {
+        if (required.length > 0 && !required.some((item) => regexMatches(item.regex, text))) {
           context.report({
             node: title,
             messageId: "required",
-            data: { pattern: required.pattern }
+            data: { pattern: requiredLabel }
           });
         }
       }
@@ -4399,6 +4566,7 @@ var src_default = eslintCompatPlugin({
     "only-export-components": onlyExportComponents,
     "only-export-constants": onlyExportConstants,
     "padding-between-statements": paddingBetweenStatements,
+    "prefer-namespace-type-import": preferNamespaceTypeImport,
     "require-file-factory": requireFileFactory,
     "require-object-params": requireObjectParams,
     "require-orpc-output": requireOrpcOutput,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-arch",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "Configurable architecture rules for Oxlint JavaScript plugins.",
   "type": "module",
   "main": "./dist/index.js",