oxlint-plugin-arch 0.2.2 → 0.2.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.2.3
+
+- Add `declaration-name` so selected declarations can follow a file prefix or pattern per glob.
+- Add `export-file-prefix` `singularize` so plural filenames accept singular prefixes.
+- Add `no-type-declarations` to keep type aliases and interfaces out of matched files.
+
 ## 0.2.2
 
 - Publish compiled `dist/index.js` so Oxlint can load the package from `node_modules`.

package/README.md

@@ -41,13 +41,14 @@ Then point `jsPlugins[].specifier` at the copied entry file instead of the packa
 ## Configuration examples
 
 - [`examples/minimal.oxlint.config.ts`](examples/minimal.oxlint.config.ts) — three small rules showing plugin registration, glob ownership, and options.
-- [`examples/full.oxlint.config.ts`](examples/full.oxlint.config.ts) — all 25 rules across representative component, action, service, route, API, schema, and database scopes.
+- [`examples/full.oxlint.config.ts`](examples/full.oxlint.config.ts) — all 27 rules across representative component, action, service, route, API, schema, and database scopes.
 
 Copy the shapes that match your repository; do not copy globs or naming policy blindly.
 
 ## Rules
 
-- `export-file-prefix` — require export names, or every function and type, to start with a filename-derived prefix.
+- `declaration-name` — require selected declarations to match a filename-derived prefix or a consumer pattern.
+- `export-file-prefix` — require export names, or every function and type, to start with a filename-derived prefix, optionally singularized.
 - `export-name-pattern` — require export names, or every function and type, to match a configured regular expression.
 - `filename-export-name` — derive expected function names from filename templates, optionally including locals.
 - `filename-match` — require filenames to match a configured pattern.
@@ -65,6 +66,7 @@ Copy the shapes that match your repository; do not copy globs or naming policy b
 - `no-single-use-scalar-schema` — reject local scalar Zod aliases used once where they can be safely inlined.
 - `no-top-level-functions` — reject top-level functions and optional re-exports.
 - `no-trivial-functions` — reject empty or passthrough top-level functions.
+- `no-type-declarations` — reject type aliases and interfaces in matched files.
 - `no-unescaped-like` — require configured sanitizers for configured query methods.
 - `only-export-components` — allow only React component and type exports.
 - `require-file-factory` — derive and require a filename-based factory function.

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
-// src/rules/export-file-prefix.ts
+// src/rules/declaration-name.ts
 import { defineRule } from "@oxlint/plugins";
 
 // src/utils/helpers/ast.ts
@@ -194,16 +194,42 @@ function declarationsIsTrivialFunction(node) {
   }
   return statement.type === "ExpressionStatement" && declarationsIsTrivialExpression(statement.expression);
 }
-function declarationsCollectNamed(root) {
+var declarationsKinds = ["function", "const", "let", "var", "class", "type", "interface", "enum"];
+function declarationsNamedKind(node, ancestors) {
+  if (node.type === "FunctionDeclaration") {
+    return "function";
+  }
+  if (node.type === "ClassDeclaration") {
+    return "class";
+  }
+  if (node.type === "TSTypeAliasDeclaration") {
+    return "type";
+  }
+  if (node.type === "TSInterfaceDeclaration") {
+    return "interface";
+  }
+  if (node.type === "TSEnumDeclaration") {
+    return "enum";
+  }
+  if (node.type !== "VariableDeclarator") {
+    return;
+  }
+  const declaration = ancestors.findLast((ancestor) => ancestor.type === "VariableDeclaration");
+  return declaration?.type === "VariableDeclaration" && (declaration.kind === "const" || declaration.kind === "let" || declaration.kind === "var") ? declaration.kind : undefined;
+}
+function declarationsCollectNamed(root, kinds) {
+  const allowed = kinds && kinds.length > 0 ? new Set(kinds) : null;
   const result = [];
   astVisit(root, [], (node, ancestors) => {
-    if ((node.type === "FunctionDeclaration" || node.type === "ClassDeclaration" || node.type === "TSTypeAliasDeclaration" || node.type === "TSInterfaceDeclaration" || node.type === "TSEnumDeclaration") && node.id?.name) {
-      result.push({ name: node.id.name, node });
+    const kind = declarationsNamedKind(node, ancestors);
+    const name = node.type === "VariableDeclarator" && node.id.type === "Identifier" ? node.id.name : ("id" in node) && node.id && ("name" in node.id) ? node.id.name : undefined;
+    if (!kind || !name || allowed && !allowed.has(kind)) {
       return;
     }
-    if (node.type === "VariableDeclarator" && node.id.type === "Identifier" && !ancestors.some((ancestor) => ancestor.type === "ForStatement" || ancestor.type === "ForInStatement" || ancestor.type === "ForOfStatement")) {
-      result.push({ name: node.id.name, node });
+    if (node.type === "VariableDeclarator" && ancestors.some((ancestor) => ancestor.type === "ForStatement" || ancestor.type === "ForInStatement" || ancestor.type === "ForOfStatement")) {
+      return;
     }
+    result.push({ name, node, kind });
   });
   return result;
 }
@@ -396,6 +422,18 @@ function namingMatchTemplate(basename, template, placeholderPattern = "[a-z0-9-]
   }
   return new RegExp(`^${pattern}$`).exec(basename)?.groups ?? null;
 }
+function namingNormalized(value, normalize) {
+  return normalize === "none" ? value : value.replaceAll(/[-_]/g, "").toLowerCase();
+}
+function namingFilePrefixes(stem, normalize = "remove-separators", singularize = "none") {
+  const prefixes = [namingNormalized(stem, normalize)];
+  const parts = stem.split(/[-_]+/).filter(Boolean);
+  const last = parts.at(-1) ?? "";
+  if (singularize === "trailing-s" && last.endsWith("s") && last.length > 1) {
+    prefixes.push(namingNormalized([...parts.slice(0, -1), last.slice(0, -1)].join("-"), normalize));
+  }
+  return [...new Set(prefixes.filter(Boolean))];
+}
 
 // src/utils/helpers/factories.ts
 function factoriesExpandTemplate(template, groups) {
@@ -647,8 +685,66 @@ function schemasIsAllowedElement(node, allowScalars, namespaces, structuralMetho
 function schemasTypeOperator(node, namespaces, operators) {
   return node.typeName.type === "TSQualifiedName" && node.typeName.left.type === "Identifier" && namespaces.has(node.typeName.left.name) && operators.has(node.typeName.right.name) ? node.typeName.right.name : undefined;
 }
+// src/rules/declaration-name.ts
+var declarationName = defineRule({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        kinds: {
+          type: "array",
+          items: { type: "string", enum: [...declarationsKinds] }
+        },
+        pattern: { type: "string" },
+        flags: { type: "string" },
+        stem: { type: "string", enum: ["before-first-dot", "full-basename"] },
+        normalize: { type: "string", enum: ["remove-separators", "none"] },
+        singularize: { type: "string", enum: ["none", "trailing-s"] },
+        allowPattern: { type: "string" }
+      }
+    }],
+    messages: {
+      prefix: "'{{name}}' must start with file prefix '{{prefix}}'.",
+      pattern: "'{{name}}' must match {{pattern}}."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const options2 = optionsFirst(context, {
+          stem: "before-first-dot",
+          normalize: "remove-separators"
+        });
+        const allowed = options2.allowPattern ? new RegExp(options2.allowPattern) : null;
+        const expected = options2.pattern ? new RegExp(options2.pattern, options2.flags) : null;
+        const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
+        const stem = options2.stem === "full-basename" ? basename : basename.split(".")[0] ?? "";
+        const prefixes = namingFilePrefixes(stem, options2.normalize ?? "remove-separators", options2.singularize ?? "none");
+        const seen = new Set;
+        for (const item of declarationsCollectNamed(program, options2.kinds)) {
+          const key = `${item.name}:${item.node.start}:${item.node.end}`;
+          const comparableName = options2.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
+          const matches = expected ? expected.test(item.name) : prefixes.some((prefix) => comparableName.startsWith(prefix));
+          if (seen.has(key) || allowed?.test(item.name) || matches) {
+            continue;
+          }
+          seen.add(key);
+          context.report({
+            node: item.node,
+            messageId: expected ? "pattern" : "prefix",
+            data: expected ? { name: item.name, pattern: options2.pattern ?? "" } : { name: item.name, prefix: prefixes.join(" or ") }
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/export-file-prefix.ts
-var exportFilePrefix = defineRule({
+import { defineRule as defineRule2 } from "@oxlint/plugins";
+var exportFilePrefix = defineRule2({
   meta: {
     type: "problem",
     schema: [{
@@ -657,6 +753,7 @@ var exportFilePrefix = defineRule({
       properties: {
         stem: { type: "string", enum: ["before-first-dot", "full-basename"] },
         normalize: { type: "string", enum: ["remove-separators", "none"] },
+        singularize: { type: "string", enum: ["none", "trailing-s"] },
         allDeclarations: { type: "boolean" },
         allowPattern: { type: "string" }
       }
@@ -674,7 +771,7 @@ var exportFilePrefix = defineRule({
         });
         const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
         const stem = options2.stem === "full-basename" ? basename : basename.split(".")[0] ?? "";
-        const prefix = options2.normalize === "none" ? stem : stem.replaceAll(/[-_]/g, "").toLowerCase();
+        const prefixes = namingFilePrefixes(stem, options2.normalize ?? "remove-separators", options2.singularize ?? "none");
         const allowed = options2.allowPattern ? new RegExp(options2.allowPattern) : null;
         const names = options2.allDeclarations ? declarationsCollectNamed(program) : exportsCollect(program).map((binding) => ({
           name: binding.localName ?? binding.exportedName,
@@ -684,14 +781,14 @@ var exportFilePrefix = defineRule({
         for (const item of names) {
           const key = `${item.name}:${item.node.start}:${item.node.end}`;
           const comparableName = options2.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
-          if (seen.has(key) || allowed?.test(item.name) || comparableName.startsWith(prefix)) {
+          if (seen.has(key) || allowed?.test(item.name) || prefixes.some((prefix) => comparableName.startsWith(prefix))) {
             continue;
           }
           seen.add(key);
           context.report({
             node: item.node,
             messageId: "prefix",
-            data: { name: item.name, prefix }
+            data: { name: item.name, prefix: prefixes.join(" or ") }
           });
         }
       }
@@ -700,8 +797,8 @@ var exportFilePrefix = defineRule({
 });
 
 // src/rules/export-name-pattern.ts
-import { defineRule as defineRule2 } from "@oxlint/plugins";
-var exportNamePattern = defineRule2({
+import { defineRule as defineRule3 } from "@oxlint/plugins";
+var exportNamePattern = defineRule3({
   meta: {
     type: "problem",
     schema: [{
@@ -751,8 +848,8 @@ var exportNamePattern = defineRule2({
 });
 
 // src/rules/filename-export-name.ts
-import { defineRule as defineRule3 } from "@oxlint/plugins";
-var filenameExportName = defineRule3({
+import { defineRule as defineRule4 } from "@oxlint/plugins";
+var filenameExportName = defineRule4({
   meta: {
     type: "problem",
     schema: [{
@@ -813,8 +910,8 @@ var filenameExportName = defineRule3({
 });
 
 // src/rules/filename-match.ts
-import { defineRule as defineRule4 } from "@oxlint/plugins";
-var filenameMatch = defineRule4({
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var filenameMatch = defineRule5({
   meta: {
     type: "problem",
     schema: [{
@@ -848,8 +945,8 @@ var filenameMatch = defineRule4({
 });
 
 // src/rules/folder-prefix.ts
-import { defineRule as defineRule5 } from "@oxlint/plugins";
-var folderPrefix = defineRule5({
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+var folderPrefix = defineRule6({
   meta: {
     type: "problem",
     schema: [{
@@ -897,8 +994,8 @@ var folderPrefix = defineRule5({
 });
 
 // src/rules/no-extra-exports.ts
-import { defineRule as defineRule6 } from "@oxlint/plugins";
-var noExtraExports = defineRule6({
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+var noExtraExports = defineRule7({
   meta: {
     type: "problem",
     schema: [{
@@ -941,8 +1038,8 @@ var noExtraExports = defineRule6({
 });
 
 // src/rules/no-extra-factory-keys.ts
-import { defineRule as defineRule7 } from "@oxlint/plugins";
-var noExtraFactoryKeys = defineRule7({
+import { defineRule as defineRule8 } from "@oxlint/plugins";
+var noExtraFactoryKeys = defineRule8({
   meta: {
     type: "problem",
     schema: [{
@@ -982,8 +1079,8 @@ var noExtraFactoryKeys = defineRule7({
 });
 
 // src/rules/no-file-level-helpers.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
-var noFileLevelHelpers = defineRule8({
+import { defineRule as defineRule9 } from "@oxlint/plugins";
+var noFileLevelHelpers = defineRule9({
   meta: {
     type: "problem",
     schema: [{
@@ -1025,7 +1122,7 @@ var noFileLevelHelpers = defineRule8({
 });
 
 // src/rules/no-imported-type-alias.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
+import { defineRule as defineRule10 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
   if (declaration?.type !== "TSTypeAliasDeclaration" || declaration.typeAnnotation.type !== "TSTypeReference" || declaration.typeAnnotation.typeName.type !== "Identifier" || !imports.has(declaration.typeAnnotation.typeName.name)) {
     return;
@@ -1035,7 +1132,7 @@ function importedAliasTarget(declaration, imports) {
 function specifierLocalName(specifier) {
   return specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
 }
-var noImportedTypeAlias = defineRule9({
+var noImportedTypeAlias = defineRule10({
   meta: {
     type: "problem",
     schema: [],
@@ -1085,8 +1182,8 @@ var noImportedTypeAlias = defineRule9({
 });
 
 // src/rules/no-inline-schema-elements.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
-var noInlineSchemaElements = defineRule10({
+import { defineRule as defineRule11 } from "@oxlint/plugins";
+var noInlineSchemaElements = defineRule11({
   meta: {
     type: "problem",
     schema: [{
@@ -1134,13 +1231,13 @@ var noInlineSchemaElements = defineRule10({
 });
 
 // src/rules/no-local-schema-construction.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
+import { defineRule as defineRule12 } 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 = defineRule11({
+var noLocalSchemaConstruction = defineRule12({
   meta: {
     type: "problem",
     schema: [{
@@ -1252,8 +1349,8 @@ var noLocalSchemaConstruction = defineRule11({
 });
 
 // src/rules/no-rederive-schema.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
-var noRederiveSchema = defineRule12({
+import { defineRule as defineRule13 } from "@oxlint/plugins";
+var noRederiveSchema = defineRule13({
   meta: {
     type: "problem",
     schema: [{
@@ -1298,8 +1395,8 @@ var noRederiveSchema = defineRule12({
 });
 
 // src/rules/no-restricted-files.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
-var noRestrictedFiles = defineRule13({
+import { defineRule as defineRule14 } from "@oxlint/plugins";
+var noRestrictedFiles = defineRule14({
   meta: {
     type: "problem",
     schema: [{
@@ -1329,7 +1426,7 @@ var noRestrictedFiles = defineRule13({
 });
 
 // src/rules/no-restricted-token.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
+import { defineRule as defineRule15 } from "@oxlint/plugins";
 function tokenIsTypeOnlyImport(node) {
   const parent = node.parent;
   if (parent?.type === "ImportSpecifier") {
@@ -1337,7 +1434,7 @@ function tokenIsTypeOnlyImport(node) {
   }
   return (parent?.type === "ImportDefaultSpecifier" || parent?.type === "ImportNamespaceSpecifier") && parent.parent.type === "ImportDeclaration" && parent.parent.importKind === "type";
 }
-var noRestrictedToken = defineRule14({
+var noRestrictedToken = defineRule15({
   meta: {
     type: "problem",
     schema: [{
@@ -1379,8 +1476,8 @@ var noRestrictedToken = defineRule14({
 });
 
 // src/rules/no-runtime-in-types.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
-var noRuntimeInTypes = defineRule15({
+import { defineRule as defineRule16 } from "@oxlint/plugins";
+var noRuntimeInTypes = defineRule16({
   meta: {
     type: "problem",
     schema: [{
@@ -1430,7 +1527,7 @@ var noRuntimeInTypes = defineRule15({
 });
 
 // src/rules/no-single-use-scalar-schema.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
+import { defineRule as defineRule17 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -1464,7 +1561,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 = defineRule16({
+var noSingleUseScalarSchema = defineRule17({
   meta: {
     type: "suggestion",
     schema: [{
@@ -1532,8 +1629,8 @@ var noSingleUseScalarSchema = defineRule16({
 });
 
 // src/rules/no-top-level-functions.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
-var noTopLevelFunctions = defineRule17({
+import { defineRule as defineRule18 } from "@oxlint/plugins";
+var noTopLevelFunctions = defineRule18({
   meta: {
     type: "problem",
     schema: [{
@@ -1590,8 +1687,8 @@ var noTopLevelFunctions = defineRule17({
 });
 
 // src/rules/no-trivial-functions.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
-var noTrivialFunctions = defineRule18({
+import { defineRule as defineRule19 } from "@oxlint/plugins";
+var noTrivialFunctions = defineRule19({
   meta: {
     type: "problem",
     schema: [{
@@ -1628,9 +1725,45 @@ var noTrivialFunctions = defineRule18({
   }
 });
 
+// src/rules/no-type-declarations.ts
+import { defineRule as defineRule20 } from "@oxlint/plugins";
+var noTypeDeclarations = defineRule20({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        allowPattern: { type: "string" }
+      }
+    }],
+    messages: {
+      typeDeclaration: "Type '{{name}}' must not be declared in this file."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { allowPattern } = optionsFirst(context, {});
+        const allowed = allowPattern ? new RegExp(allowPattern) : null;
+        for (const item of declarationsCollectNamed(program)) {
+          if (item.node.type !== "TSTypeAliasDeclaration" && item.node.type !== "TSInterfaceDeclaration" || allowed?.test(item.name)) {
+            continue;
+          }
+          context.report({
+            node: item.node,
+            messageId: "typeDeclaration",
+            data: { name: item.name }
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/no-unescaped-like.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
-var noUnescapedLike = defineRule19({
+import { defineRule as defineRule21 } from "@oxlint/plugins";
+var noUnescapedLike = defineRule21({
   meta: {
     type: "problem",
     schema: [{
@@ -1676,8 +1809,8 @@ var noUnescapedLike = defineRule19({
 });
 
 // src/rules/only-export-components.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
-var onlyExportComponents = defineRule20({
+import { defineRule as defineRule22 } from "@oxlint/plugins";
+var onlyExportComponents = defineRule22({
   meta: {
     type: "problem",
     schema: [{
@@ -1733,8 +1866,8 @@ var onlyExportComponents = defineRule20({
 });
 
 // src/rules/require-file-factory.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
-var requireFileFactory = defineRule21({
+import { defineRule as defineRule23 } from "@oxlint/plugins";
+var requireFileFactory = defineRule23({
   meta: {
     type: "problem",
     schema: [{
@@ -1780,8 +1913,8 @@ var requireFileFactory = defineRule21({
 });
 
 // src/rules/require-object-params.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
-var requireObjectParams = defineRule22({
+import { defineRule as defineRule24 } from "@oxlint/plugins";
+var requireObjectParams = defineRule24({
   meta: {
     type: "problem",
     schema: [],
@@ -1807,8 +1940,8 @@ var requireObjectParams = defineRule22({
 });
 
 // src/rules/require-orpc-output.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
-var requireOrpcOutput = defineRule23({
+import { defineRule as defineRule25 } from "@oxlint/plugins";
+var requireOrpcOutput = defineRule25({
   meta: {
     type: "problem",
     schema: [{
@@ -1850,8 +1983,8 @@ var requireOrpcOutput = defineRule23({
 });
 
 // src/rules/require-paired-call.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
-var requirePairedCall = defineRule24({
+import { defineRule as defineRule26 } from "@oxlint/plugins";
+var requirePairedCall = defineRule26({
   meta: {
     type: "problem",
     schema: [{
@@ -1906,8 +2039,8 @@ var requirePairedCall = defineRule24({
 });
 
 // src/rules/route-surface.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
-var routeSurface = defineRule25({
+import { defineRule as defineRule27 } from "@oxlint/plugins";
+var routeSurface = defineRule27({
   meta: {
     type: "problem",
     schema: [{
@@ -1952,6 +2085,7 @@ var routeSurface = defineRule25({
 var src_default = eslintCompatPlugin({
   meta: { name: "arch" },
   rules: {
+    "declaration-name": declarationName,
     "export-file-prefix": exportFilePrefix,
     "export-name-pattern": exportNamePattern,
     "filename-export-name": filenameExportName,
@@ -1970,6 +2104,7 @@ var src_default = eslintCompatPlugin({
     "no-single-use-scalar-schema": noSingleUseScalarSchema,
     "no-top-level-functions": noTopLevelFunctions,
     "no-trivial-functions": noTrivialFunctions,
+    "no-type-declarations": noTypeDeclarations,
     "no-unescaped-like": noUnescapedLike,
     "only-export-components": onlyExportComponents,
     "require-file-factory": requireFileFactory,

package/package.json

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