oxlint-plugin-arch 0.13.0 → 0.13.2

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

@@ -152,6 +152,12 @@ function optionsAssertMockingApis(patterns) {
     throw new OptionsError("Test mocking APIs must be `*` or `<vi|jest|*>.<method|*>`.");
   }
 }
+function optionsEscape(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function optionsWildcards(names) {
+  return [names ?? []].flat().map((name) => new RegExp(`^${name.split("*").map(optionsEscape).join(".*")}$`));
+}
 
 // src/utils/ast.utils.ts
 var astSkippedKeys = new Set(["parent", "type", "start", "end", "range", "loc", "tokens", "comments"]);
@@ -339,9 +345,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 +354,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 +1253,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 +1284,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 +1762,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 +1786,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.13.0",
+  "version": "0.13.2",
   "description": "Configurable architecture rules for Oxlint JavaScript plugins.",
   "type": "module",
   "main": "./dist/index.js",

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.