oxlint-plugin-arch 0.12.6 → 0.13.1

package/dist/vendor/dillon-anti-slop/index.js

@@ -139,7 +139,7 @@ function optionsPatternsTest(patterns, value) {
 function optionsGlob(pattern) {
   const negated = [];
   const source = pattern.replaceAll(/!\(([^()]*)\)/g, (_, options) => {
-    negated.push(options.split("|").map((option) => option.replaceAll(/[.+^$()|[\]\\*?{}]/g, "\\$&")).join("|"));
+    negated.push(options.split("|").map((option) => option.replaceAll(/[.+^$()|[\]\\?{}]/g, "\\$&").replaceAll("*", "[^/]*")).join("|"));
     return `\x02${negated.length - 1}\x03`;
   }).replaceAll(/[.+^$()|[\]\\]/g, "\\$&").replaceAll("?", "[^/]").replaceAll("**/", "\x00").replaceAll("**", "\x01").replaceAll("*", "[^/]*").replaceAll("\x00", "(?:.*/)?").replaceAll("\x01", ".*").replaceAll(/\{([^}]*)\}/g, (_, options) => `(?:${options.split(",").join("|")})`);
   return new RegExp(`^${negated.reduce((text, names, index) => text.replace(`\x02${index}\x03`, `(?!(?:${names})(?:/|$))[^/]*`), source)}$`);
@@ -152,6 +152,9 @@ function optionsAssertMockingApis(patterns) {
     throw new OptionsError("Test mocking APIs must be `*` or `<vi|jest|*>.<method|*>`.");
   }
 }
+function optionsEscape(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 // src/utils/ast.utils.ts
 var astSkippedKeys = new Set(["parent", "type", "start", "end", "range", "loc", "tokens", "comments"]);
@@ -339,9 +342,6 @@ function astIsInlineFunction(node) {
 function astIsCall(node) {
   return node.type === "CallExpression" || node.type === "NewExpression";
 }
-function astIsPipe(node) {
-  return node.callee.type === "MemberExpression" && astMemberName(node.callee) === "pipe";
-}
 function astChildren(node) {
   return Object.entries(node).filter(([key]) => !astSkippedKeys.has(key)).map(([, child]) => child);
 }
@@ -351,17 +351,20 @@ function astSome(value, test, enter = () => true) {
   }
   return astIsNode(value) && (test(value) || enter(value) && astChildren(value).some((child) => astSome(child, test, enter)));
 }
-function astCallDepth(value) {
+function astCallDepth(value, callbacks = false) {
   if (Array.isArray(value)) {
-    return Math.max(0, ...value.map(astCallDepth));
+    return Math.max(0, ...value.map((item) => astCallDepth(item, callbacks)));
   }
-  if (!astIsNode(value) || astIsInlineFunction(value)) {
+  if (!astIsNode(value)) {
     return 0;
   }
+  if (astIsInlineFunction(value)) {
+    return callbacks ? astCallDepth(value.body, callbacks) : 0;
+  }
   if (astIsCall(value)) {
-    return Math.max(value.arguments.length === 0 ? 0 : 1 + astCallDepth(value.arguments), astCallDepth(value.callee));
+    return Math.max(value.arguments.length === 0 ? 0 : 1 + astCallDepth(value.arguments, callbacks), astCallDepth(value.callee, callbacks));
   }
-  return astCallDepth(astChildren(value));
+  return astCallDepth(astChildren(value), callbacks);
 }
 
 // src/vendor/dillon-anti-slop/shared/type-reference-name.ts
@@ -1247,7 +1250,6 @@ var noRuntimeTypeofRule = defineRule8({
 
 // src/vendor/dillon-anti-slop/rules/no-shape-in-symbol-names.ts
 import { defineRule as defineRule9 } from "@oxlint/plugins";
-var FORBIDDEN_SYMBOL_NAME = "shape";
 function namesForeignApi(node) {
   const parent = node.parent;
   if (!parent) {
@@ -1279,22 +1281,29 @@ var noForbiddenTermInSymbolNamesRule = defineRule9({
     docs: {
       description: 'Disallow the case-insensitive substring "shape" in JavaScript, TypeScript, private, and JSX symbol names.'
     },
+    schema: [{ type: "object", additionalProperties: false, properties: { terms: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 } } }],
     messages: {
-      forbiddenSymbolName: 'Rename symbol "{{name}}" for its domain role; "shape" describes structure rather than ownership.'
+      forbiddenSymbolName: 'Rename symbol "{{name}}" for its domain role; "{{term}}" describes structure rather than ownership.'
     }
   },
   createOnce(context) {
+    let terms = [];
     const reportForbiddenSymbolName = (node) => {
-      if (!node.name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME) || namesForeignApi(node)) {
+      const lower = node.name.toLowerCase();
+      const term = terms.find((candidate) => lower.includes(candidate));
+      if (term === undefined || namesForeignApi(node)) {
         return;
       }
       context.report({
         node,
         messageId: "forbiddenSymbolName",
-        data: { name: node.name }
+        data: { name: node.name, term }
       });
     };
     return {
+      before() {
+        terms = (optionsFirst(context, {}).terms ?? ["shape"]).map((term) => term.toLowerCase());
+      },
       Identifier: reportForbiddenSymbolName,
       PrivateIdentifier: reportForbiddenSymbolName,
       JSXIdentifier: reportForbiddenSymbolName
@@ -1750,18 +1759,22 @@ var requireSafetyCommentForTypeAssertionRule = defineRule15({
     docs: {
       description: "Require a nearby SAFETY comment for every TypeScript type assertion except const assertions."
     },
+    schema: [{ type: "object", additionalProperties: false, properties: { comment: { type: "string", minLength: 1 } } }],
     messages: {
-      missingSafetyComment: "This type assertion has no `SAFETY:` justification. State the checked invariant immediately before the assertion or its containing statement."
+      missingSafetyComment: "This type assertion has no `{{comment}}` justification. State the checked invariant immediately before the assertion or its containing statement."
     }
   },
   createOnce(context) {
+    let comment = "SAFETY:";
+    let marker = /(?<![\p{L}\p{N}_])SAFETY\s*:/u;
     const checkAssertion = (node) => {
       if (expressionsIsConstAssertion(node)) {
         return;
       }
       let current = node;
+      const justified = (candidate) => candidate.end <= node.start && marker.test(candidate.value);
       for (;; ) {
-        if (context.sourceCode.getCommentsBefore(current).some((comment) => comment.end <= node.start && /\bSAFETY\s*:/u.test(comment.value))) {
+        if (context.sourceCode.getCommentsBefore(current).some(justified)) {
           return;
         }
         const parent = current.parent;
@@ -1770,9 +1783,18 @@ var requireSafetyCommentForTypeAssertionRule = defineRule15({
         }
         current = parent;
       }
-      context.report({ node, messageId: "missingSafetyComment" });
+      context.report({
+        node,
+        messageId: "missingSafetyComment",
+        data: { comment }
+      });
     };
     return {
+      before() {
+        comment = optionsFirst(context, {}).comment ?? "SAFETY:";
+        const word = optionsEscape(comment.replace(/:\s*$/, ""));
+        marker = new RegExp(`(?<![\\p{L}\\p{N}_])${word}\\s*:`, "u");
+      },
       TSAsExpression: checkAssertion,
       TSTypeAssertion: checkAssertion
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-arch",
-  "version": "0.12.6",
+  "version": "0.13.1",
   "description": "Configurable architecture rules for Oxlint JavaScript plugins.",
   "type": "module",
   "main": "./dist/index.js",
@@ -57,8 +57,11 @@
     "@effect/tsgo": ">=0.67.1",
     "@opsydyn/oxlint-effect": ">=2.0.1",
     "@shadcn/lint": ">=0.2.3",
+    "eslint-plugin-de-morgan": ">=2.3.0",
     "eslint-plugin-react": ">=7.37.5",
     "eslint-plugin-react-you-might-not-need-an-effect": ">=1.0.2",
+    "eslint-plugin-regexp": ">=3.3.3",
+    "eslint-plugin-sonarjs": ">=4.2.2",
     "eslint-plugin-svg-jsx": ">=1.3.0",
     "oxlint": ">=1.85.0",
     "oxlint-tailwindcss": ">=1.16.0",
@@ -70,8 +73,10 @@
     "@shadcn/lint": "0.2.3",
     "@types/node": "26.6.5",
     "bumpp": "12.3.0",
+    "eslint-plugin-de-morgan": "2.3.0",
     "eslint-plugin-react": "7.37.5",
     "eslint-plugin-react-you-might-not-need-an-effect": "1.0.2",
+    "eslint-plugin-regexp": "3.3.3",
     "eslint-plugin-svg-jsx": "1.3.0",
     "fallow": "3.36.0",
     "oxlint": "1.89.0",
@@ -111,12 +116,21 @@
     "@shadcn/lint": {
       "optional": true
     },
+    "eslint-plugin-de-morgan": {
+      "optional": true
+    },
     "eslint-plugin-react": {
       "optional": true
     },
     "eslint-plugin-react-you-might-not-need-an-effect": {
       "optional": true
     },
+    "eslint-plugin-regexp": {
+      "optional": true
+    },
+    "eslint-plugin-sonarjs": {
+      "optional": true
+    },
     "eslint-plugin-svg-jsx": {
       "optional": true
     },

package/src/vendor/dillon-anti-slop/UPSTREAM.md

@@ -14,6 +14,9 @@ The TanStack preset selects the enabled rules; this directory implements them
 and is not a separate preset. Upstream intentionally distributes source for
 vendoring and does not publish an official npm package.
 
+Local options: `terms` on `no-shape-in-symbol-names` and `comment` on
+`require-safety-comment-for-type-assertion`; their defaults keep upstream behavior.
+
 Local behavior fixes recognize `SAFETY:` comments on exported declarations and
 export-default assertions, while retaining statement boundaries for other
 assertions.