@timmo001/oxlint-rules 0.2.1 → 0.3.1

package/dist/configs/{effect.js → recommended-effect.js}

@@ -1,3 +1,8 @@
+// node_modules/oxlint/dist/index.js
+function defineConfig(config) {
+  return config;
+}
+
 // src/effect/index.ts
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
@@ -158,11 +163,211 @@ var antiSlopEffectPlugin = eslintCompatPlugin2({
   }
 });
 var effect_default2 = antiSlopEffectPlugin;
+// src/configs/enable-plugin-rules.ts
+function enablePluginRules(namespace, plugin) {
+  return Object.fromEntries(Object.keys(plugin.rules).sort().map((rule) => [`${namespace}/${rule}`, "error"]));
+}
+
 // vendor/anti-slop/src/index.ts
 import { eslintCompatPlugin as eslintCompatPlugin3 } from "@oxlint/plugins";
 
-// vendor/anti-slop/src/rules/no-chained-type-assertions.ts
+// vendor/anti-slop/src/rules/no-array-filter-map.ts
 import { defineRule as defineRule3 } from "@oxlint/plugins";
+
+// vendor/anti-slop/src/shared/array-method.ts
+function unwrapArrayExpression(node) {
+  while (node.type === "ParenthesizedExpression" || node.type === "ChainExpression" || node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "TSSatisfiesExpression") {
+    node = node.expression;
+  }
+  return node;
+}
+function resolveArrayBinding(sourceCode, node) {
+  node = unwrapArrayExpression(node);
+  if (node.type !== "Identifier")
+    return null;
+  let scope = sourceCode.getScope(node);
+  while (scope !== null) {
+    const variable = scope.set.get(node.name);
+    if (variable !== undefined)
+      return variable;
+    scope = scope.upper;
+  }
+  return null;
+}
+function arrayMethodTarget(node) {
+  node = unwrapArrayExpression(node);
+  if (node.type !== "MemberExpression")
+    return null;
+  const property = node.property;
+  if (!node.computed && property.type === "Identifier") {
+    return { name: property.name, object: node.object };
+  }
+  if (node.computed && property.type === "Literal" && typeof property.value === "string") {
+    return { name: property.value, object: node.object };
+  }
+  return null;
+}
+function isArrayAnnotation(type) {
+  if (type.type === "TSArrayType" || type.type === "TSTupleType")
+    return true;
+  if (type.type === "TSParenthesizedType")
+    return isArrayAnnotation(type.typeAnnotation);
+  if (type.type === "TSTypeOperator" && type.operator === "readonly") {
+    return isArrayAnnotation(type.typeAnnotation);
+  }
+  return type.type === "TSTypeReference" && type.typeName.type === "Identifier" && (type.typeName.name === "Array" || type.typeName.name === "ReadonlyArray");
+}
+function isKnownArrayExpression(sourceCode, node, visited = new Set) {
+  node = unwrapArrayExpression(node);
+  if (node.type === "ArrayExpression")
+    return true;
+  if (node.type === "CallExpression") {
+    const method = arrayMethodTarget(node.callee);
+    return method !== null && ["map", "filter", "flatMap", "slice", "concat", "toSorted", "toReversed", "toSpliced"].includes(method.name) && isKnownArrayExpression(sourceCode, method.object, visited);
+  }
+  if (node.type !== "Identifier")
+    return false;
+  const variable = resolveArrayBinding(sourceCode, node);
+  if (variable === null || visited.has(variable))
+    return false;
+  visited.add(variable);
+  if (variable.references.some((reference) => reference.isWrite() && !reference.init))
+    return false;
+  for (const identifier of variable.identifiers) {
+    const annotation = identifier.typeAnnotation?.typeAnnotation;
+    if (annotation !== undefined)
+      return isArrayAnnotation(annotation);
+  }
+  for (const definition of variable.defs) {
+    if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" && definition.node.id.type === "Identifier" && definition.node.init !== null && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const") {
+      return isKnownArrayExpression(sourceCode, definition.node.init, visited);
+    }
+  }
+  return false;
+}
+
+// vendor/anti-slop/src/rules/no-array-filter-map.ts
+var noArrayFilterMapRule = defineRule3({
+  meta: {
+    type: "suggestion",
+    docs: { description: "Disallow adjacent array filter/map passes in favor of lazy iterator helpers or a single transformation." },
+    messages: {
+      arrayFilterMap: "Avoid consecutive array `{{first}}` and `{{second}}` passes. Prefer `.values().{{first}}(...).{{second}}(...).toArray()` where iterator helpers are supported, or a single `flatMap`/mutating reducer. Preserve callback ordering, indexes, and filtering semantics."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const outer = arrayMethodTarget(node.callee);
+        if (outer === null || outer.name !== "map" && outer.name !== "filter")
+          return;
+        const innerCall = unwrapArrayExpression(outer.object);
+        if (innerCall.type !== "CallExpression")
+          return;
+        const inner = arrayMethodTarget(innerCall.callee);
+        if (inner === null || inner.name !== (outer.name === "map" ? "filter" : "map"))
+          return;
+        if (!isKnownArrayExpression(context.sourceCode, inner.object))
+          return;
+        context.report({ node, messageId: "arrayFilterMap", data: { first: inner.name, second: outer.name } });
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/rules/no-reduce-accumulator-copy.ts
+import { defineRule as defineRule4 } from "@oxlint/plugins";
+function enclosingReducer(node) {
+  let parent = node.parent;
+  while (parent !== null) {
+    if (parent.type === "FunctionDeclaration")
+      return null;
+    if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") {
+      const callback = parent;
+      let owner = callback.parent;
+      while (owner !== null && unwrapArrayExpression(owner) === callback)
+        owner = owner.parent;
+      if (owner?.type !== "CallExpression")
+        return null;
+      const method = arrayMethodTarget(owner.callee);
+      const firstArgument = owner.arguments[0];
+      if (method === null || method.name !== "reduce" && method.name !== "reduceRight" || owner.arguments.length > 2 || firstArgument === undefined || unwrapArrayExpression(firstArgument) !== callback)
+        return null;
+      const firstParameter = callback.params[0];
+      const accumulator = firstParameter?.type === "AssignmentPattern" ? firstParameter.left : firstParameter;
+      if (accumulator?.type !== "Identifier")
+        return null;
+      return { callback, accumulator, initialValue: owner.arguments[1] };
+    }
+    parent = parent.parent;
+  }
+  return null;
+}
+function referencesAccumulator(sourceCode, node, accumulator, visited = new Set) {
+  const variable = resolveArrayBinding(sourceCode, node);
+  if (variable === null || visited.has(variable))
+    return false;
+  if (variable === accumulator)
+    return true;
+  visited.add(variable);
+  if (variable.references.some((reference) => reference.isWrite() && !reference.init))
+    return false;
+  for (const definition of variable.defs) {
+    if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" && definition.node.id.type === "Identifier" && definition.node.init !== null && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const") {
+      return referencesAccumulator(sourceCode, definition.node.init, accumulator, visited);
+    }
+  }
+  return false;
+}
+function isGlobalCopyOwner(sourceCode, node, name) {
+  node = unwrapArrayExpression(node);
+  if (node.type !== "Identifier" || node.name !== name)
+    return false;
+  const variable = resolveArrayBinding(sourceCode, node);
+  return variable === null || variable.defs.length === 0;
+}
+var noReduceAccumulatorCopyRule = defineRule4({
+  meta: {
+    type: "problem",
+    docs: { description: "Disallow copying growing reducer accumulators with Object.assign, Array.from, or array copy methods." },
+    messages: {
+      accumulatorCopy: "Do not copy the reducer accumulator on every iteration; growing copies can cause quadratic work. Mutate a fresh, locally owned accumulator and return it, or use an iterator pipeline/flatMap."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const method = arrayMethodTarget(node.callee);
+        if (method === null)
+          return;
+        const reducer = enclosingReducer(node);
+        if (reducer === null)
+          return;
+        const accumulator = context.sourceCode.getDeclaredVariables(reducer.callback).find((variable) => variable.identifiers.some((identifier) => identifier.start === reducer.accumulator.start));
+        if (accumulator === undefined)
+          return;
+        const isAccumulator = (expression) => referencesAccumulator(context.sourceCode, expression, accumulator);
+        let copiesAccumulator = false;
+        if (method.name === "assign" && isGlobalCopyOwner(context.sourceCode, method.object, "Object")) {
+          const target = node.arguments[0];
+          copiesAccumulator = target !== undefined && unwrapArrayExpression(target).type === "ObjectExpression" && node.arguments.slice(1).some(isAccumulator);
+        } else if (method.name === "from" && isGlobalCopyOwner(context.sourceCode, method.object, "Array")) {
+          const source = node.arguments[0];
+          copiesAccumulator = source !== undefined && isAccumulator(source);
+        } else if (["concat", "slice", "toSpliced", "toSorted", "toReversed", "with"].includes(method.name)) {
+          const initialValue = reducer.initialValue;
+          const arrayAccumulator = initialValue !== undefined && isKnownArrayExpression(context.sourceCode, initialValue);
+          copiesAccumulator = arrayAccumulator && isAccumulator(method.object);
+        }
+        if (copiesAccumulator)
+          context.report({ node, messageId: "accumulatorCopy" });
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/rules/no-chained-type-assertions.ts
+import { defineRule as defineRule5 } from "@oxlint/plugins";
 function isTypeAssertionExpression(node) {
   return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
 }
@@ -197,7 +402,7 @@ function isForbiddenAssertionChain(node) {
   }
   return assertionCount > 1 && hasNonConstAssertion;
 }
-var noChainedTypeAssertionsRule = defineRule3({
+var noChainedTypeAssertionsRule = defineRule5({
   meta: {
     type: "problem",
     docs: {
@@ -221,7 +426,7 @@ var noChainedTypeAssertionsRule = defineRule3({
 });
 
 // vendor/anti-slop/src/rules/no-conditional-empty-object-spread.ts
-import { defineRule as defineRule4 } from "@oxlint/plugins";
+import { defineRule as defineRule6 } from "@oxlint/plugins";
 function unwrapParentheses(node) {
   let current = node;
   while (current.type === "ParenthesizedExpression") {
@@ -236,7 +441,7 @@ function isConditionalEmptyObjectSpread(node) {
   const conditional = unwrapParentheses(node);
   return conditional.type === "ConditionalExpression" && (isEmptyObjectExpression(conditional.consequent) || isEmptyObjectExpression(conditional.alternate));
 }
-var noConditionalEmptyObjectSpreadRule = defineRule4({
+var noConditionalEmptyObjectSpreadRule = defineRule6({
   meta: {
     type: "suggestion",
     docs: {
@@ -260,7 +465,7 @@ var noConditionalEmptyObjectSpreadRule = defineRule4({
 });
 
 // vendor/anti-slop/src/rules/no-known-value-widening.ts
-import { defineRule as defineRule5 } from "@oxlint/plugins";
+import { defineRule as defineRule7 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/shared/lexical-type-parameters.ts
 function isNode(value) {
@@ -663,9 +868,9 @@ function classifyWideningTarget(type, environment) {
   if (alias === null)
     return null;
   if ((alias.typeParameters?.params.length ?? 0) > 0) {
-    const substitutions2 = aliasSubstitution(alias, unwrapped, new Map);
-    const resolved2 = substitutions2 === null ? null : classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions2, new Set([name]));
-    return resolved2?.kind === "open dictionary" ? { kind: "generic container" } : null;
+    const substitutions = aliasSubstitution(alias, unwrapped, new Map);
+    const resolved = substitutions === null ? null : classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, new Set([name]));
+    return resolved?.kind === "open dictionary" ? { kind: "generic container" } : null;
   }
   const substitutions = aliasSubstitution(alias, unwrapped, new Map);
   if (substitutions === null)
@@ -959,7 +1164,7 @@ function isDictionaryAccumulatorTarget(destination) {
 function hasParentAssertion(node) {
   return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
 }
-var noKnownValueWideningRule = defineRule5({
+var noKnownValueWideningRule = defineRule7({
   meta: {
     type: "problem",
     docs: {
@@ -1072,7 +1277,7 @@ var noKnownValueWideningRule = defineRule5({
 });
 
 // vendor/anti-slop/src/rules/no-module-mocking.ts
-import { defineRule as defineRule6 } from "@oxlint/plugins";
+import { defineRule as defineRule8 } from "@oxlint/plugins";
 var moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
 function resolveVariable3(sourceCode, identifier) {
   let scope = sourceCode.getScope(identifier);
@@ -1117,7 +1322,7 @@ function moduleMockCall(sourceCode, callee) {
   const method = callee.computed ? property.type === "Literal" && (property.value === "doMock" || property.value === "mock" || property.value === "unstable_mockModule") ? property.value : null : property.type === "Identifier" ? property.name : null;
   return method !== null && moduleMockMethods.has(method);
 }
-var noModuleMockingRule = defineRule6({
+var noModuleMockingRule = defineRule8({
   meta: {
     type: "problem",
     docs: {
@@ -1141,8 +1346,8 @@ var noModuleMockingRule = defineRule6({
 });
 
 // vendor/anti-slop/src/rules/no-object-parameters.ts
-import { defineRule as defineRule7 } from "@oxlint/plugins";
-var noObjectParametersRule = defineRule7({
+import { defineRule as defineRule9 } from "@oxlint/plugins";
+var noObjectParametersRule = defineRule9({
   meta: {
     type: "problem",
     docs: {
@@ -1195,7 +1400,7 @@ var noObjectParametersRule = defineRule7({
 });
 
 // vendor/anti-slop/src/rules/no-reflect-apply.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
+import { defineRule as defineRule10 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/shared/reflect-method.ts
 function resolveVariable4(sourceCode, identifier) {
@@ -1226,7 +1431,7 @@ function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
 }
 
 // vendor/anti-slop/src/rules/no-reflect-apply.ts
-var noReflectApplyRule = defineRule8({
+var noReflectApplyRule = defineRule10({
   meta: {
     type: "problem",
     docs: {
@@ -1250,8 +1455,8 @@ var noReflectApplyRule = defineRule8({
 });
 
 // vendor/anti-slop/src/rules/no-reflect-get.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
-var noReflectGetRule = defineRule9({
+import { defineRule as defineRule11 } from "@oxlint/plugins";
+var noReflectGetRule = defineRule11({
   meta: {
     type: "problem",
     docs: {
@@ -1275,7 +1480,7 @@ var noReflectGetRule = defineRule9({
 });
 
 // vendor/anti-slop/src/rules/no-runtime-typeof.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
+import { defineRule as defineRule12 } from "@oxlint/plugins";
 function isRuntimeFunction(node) {
   return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
 }
@@ -1298,7 +1503,7 @@ function isExistenceProbe(node) {
   const other = parent.left === node ? parent.right : parent.left;
   return other.type === "Literal" && other.value === "undefined";
 }
-var noRuntimeTypeofRule = defineRule10({
+var noRuntimeTypeofRule = defineRule12({
   meta: {
     type: "problem",
     docs: {
@@ -1332,7 +1537,7 @@ var noRuntimeTypeofRule = defineRule10({
 });
 
 // vendor/anti-slop/src/rules/no-shape-in-symbol-names.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
+import { defineRule as defineRule13 } from "@oxlint/plugins";
 var FORBIDDEN_SYMBOL_NAME = "shape";
 function containsForbiddenSymbolName(name) {
   return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
@@ -1343,7 +1548,7 @@ function isBorrowedMemberName(node) {
     return false;
   return parent.property === node && parent.computed === false;
 }
-var noForbiddenTermInSymbolNamesRule = defineRule11({
+var noForbiddenTermInSymbolNamesRule = defineRule13({
   meta: {
     type: "problem",
     docs: {
@@ -1372,12 +1577,12 @@ var noForbiddenTermInSymbolNamesRule = defineRule11({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-parameters.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
+import { defineRule as defineRule14 } from "@oxlint/plugins";
 function isTypePredicateSubject(owner, parameterName) {
   const predicate = owner.returnType?.typeAnnotation;
   return predicate?.type === "TSTypePredicate" && predicate.parameterName.type === "Identifier" && predicate.parameterName.name === parameterName;
 }
-var noUnknownParametersRule = defineRule12({
+var noUnknownParametersRule = defineRule14({
   meta: {
     type: "problem",
     docs: {
@@ -1421,8 +1626,8 @@ var noUnknownParametersRule = defineRule12({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-returns.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
-var noUnknownReturnsRule = defineRule13({
+import { defineRule as defineRule15 } from "@oxlint/plugins";
+var noUnknownReturnsRule = defineRule15({
   meta: {
     type: "problem",
     docs: {
@@ -1475,8 +1680,8 @@ var noUnknownReturnsRule = defineRule13({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-type-aliases.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
-var noUnknownTypeAliasesRule = defineRule14({
+import { defineRule as defineRule16 } from "@oxlint/plugins";
+var noUnknownTypeAliasesRule = defineRule16({
   meta: {
     type: "problem",
     docs: {
@@ -1514,7 +1719,7 @@ var noUnknownTypeAliasesRule = defineRule14({
 });
 
 // vendor/anti-slop/src/rules/no-unsafe-dictionary-type.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
+import { defineRule as defineRule17 } from "@oxlint/plugins";
 var typeNodeKinds = new Set([
   "JSDocNonNullableType",
   "JSDocNullableType",
@@ -1601,7 +1806,7 @@ function shouldReportType(node, environment) {
   }
   return true;
 }
-var noUnsafeDictionaryTypeRule = defineRule15({
+var noUnsafeDictionaryTypeRule = defineRule17({
   meta: {
     type: "problem",
     docs: {
@@ -1643,7 +1848,7 @@ var noUnsafeDictionaryTypeRule = defineRule15({
 });
 
 // vendor/anti-slop/src/rules/no-widen-then-assert.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
+import { defineRule as defineRule18 } from "@oxlint/plugins";
 var functionBoundaryTypes = new Set([
   "ArrowFunctionExpression",
   "FunctionDeclaration",
@@ -1839,7 +2044,7 @@ function assertionIsNarrower(sourceText, broadKind, evidence, assertedType) {
     return isDefinitelyObjectType(assertedType);
   return isDefinitelyNarrowerRecordType(assertedType);
 }
-var noWidenThenAssertRule = defineRule16({
+var noWidenThenAssertRule = defineRule18({
   meta: {
     type: "problem",
     docs: {
@@ -1879,7 +2084,7 @@ var noWidenThenAssertRule = defineRule16({
 });
 
 // vendor/anti-slop/src/rules/require-safety-comment-for-type-assertion.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
+import { defineRule as defineRule19 } from "@oxlint/plugins";
 var DEFAULT_SAFETY_MARKERS = ["SAFETY"];
 var commentOwnerKinds = new Set([
   "ExpressionStatement",
@@ -1922,7 +2127,7 @@ function hasSafetyComment(sourceCode, node, pattern) {
     current = current.parent;
   }
 }
-var requireSafetyCommentForTypeAssertionRule = defineRule17({
+var requireSafetyCommentForTypeAssertionRule = defineRule19({
   meta: {
     type: "problem",
     docs: {
@@ -1975,6 +2180,8 @@ var requireSafetyCommentForTypeAssertionRule = defineRule17({
 var antiSlopPlugin = eslintCompatPlugin3({
   meta: { name: "anti-slop" },
   rules: {
+    "no-array-filter-map": noArrayFilterMapRule,
+    "no-reduce-accumulator-copy": noReduceAccumulatorCopyRule,
     "no-chained-type-assertions": noChainedTypeAssertionsRule,
     "no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
     "no-known-value-widening": noKnownValueWideningRule,
@@ -1997,7 +2204,7 @@ var src_default = antiSlopPlugin;
 import { eslintCompatPlugin as eslintCompatPlugin4 } from "@oxlint/plugins";
 
 // src/generic/rules/prefer-event-parameter-type.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
+import { defineRule as defineRule20 } from "@oxlint/plugins";
 function nearestEnclosingFunction2(node) {
   let current = node.parent;
   while (current) {
@@ -2024,7 +2231,7 @@ function assertedEventParameter(node) {
     property
   };
 }
-var preferEventParameterTypeRule = defineRule18({
+var preferEventParameterTypeRule = defineRule20({
   meta: {
     type: "suggestion",
     docs: {
@@ -2061,16 +2268,6 @@ var timmoPlugin = eslintCompatPlugin4({
 });
 var generic_default = timmoPlugin;
 
-// node_modules/oxlint/dist/index.js
-function defineConfig(config) {
-  return config;
-}
-
-// src/configs/enable-plugin-rules.ts
-function enablePluginRules(namespace, plugin) {
-  return Object.fromEntries(Object.keys(plugin.rules).sort().map((rule) => [`${namespace}/${rule}`, "error"]));
-}
-
 // src/configs/recommended.ts
 var recommended = defineConfig({
   jsPlugins: [
@@ -2087,8 +2284,8 @@ var recommended = defineConfig({
 });
 var recommended_default = recommended;
 
-// src/configs/effect.ts
-var effect = defineConfig({
+// src/configs/recommended-effect.ts
+var recommendedEffect = defineConfig({
   extends: [recommended_default],
   jsPlugins: [
     {
@@ -2102,7 +2299,7 @@ var effect = defineConfig({
     ...enablePluginRules("timmo-effect", effect_default)
   }
 });
-var effect_default3 = effect;
+var recommended_effect_default = recommendedEffect;
 export {
-  effect_default3 as default
+  recommended_effect_default as default
 };