eslint-plugin-ts-data-forge 0.8.0 → 0.8.2

package/src/rules/prefer-arr-uniq.mts

@@ -79,18 +79,25 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
     ): void => {
       const arrayExpression = getSetSourceArray(setNode);
 
-      if (arrayExpression === undefined) return;
+      if (arrayExpression === undefined) {
+        return;
+      }
 
-      if (!isGlobal(sourceCode, node, 'Set')) return;
+      if (!isGlobal(sourceCode, node, 'Set')) {
+        return;
+      }
 
       const arrayTsNode = getTsNode(arrayExpression);
 
-      if (arrayTsNode === undefined) return;
+      if (arrayTsNode === undefined) {
+        return;
+      }
 
       if (
         !isPrimitiveArrayType(checker, checker.getTypeAtLocation(arrayTsNode))
-      )
+      ) {
         return;
+      }
 
       mut_matches.push({
         node,
@@ -117,17 +124,23 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
           return;
         }
 
-        if (!isGlobal(sourceCode, node, 'Array')) return;
+        if (!isGlobal(sourceCode, node, 'Array')) {
+          return;
+        }
 
         check(node, node.arguments[0]);
       },
       ArrayExpression: (node) => {
         // [...new Set(xs)]
-        if (!Arr.isFixedLengthTuple(1, node.elements)) return;
+        if (!Arr.isFixedLengthTuple(1, node.elements)) {
+          return;
+        }
 
         const element = node.elements[0];
 
-        if (element?.type !== AST_NODE_TYPES.SpreadElement) return;
+        if (element?.type !== AST_NODE_TYPES.SpreadElement) {
+          return;
+        }
 
         check(node, element.argument);
       },
@@ -246,11 +259,10 @@ const findVariable = (
 ): TSESLint.Scope.Variable | undefined => {
   const variable = scope.set.get(name);
 
-  if (variable !== undefined) return variable;
-
-  if (scope.upper === null) return undefined;
-
-  return findVariable(scope.upper, name);
+  return (
+    variable ??
+    (scope.upper === null ? undefined : findVariable(scope.upper, name))
+  );
 };
 
 /**
@@ -296,11 +308,9 @@ const isPrimitiveType = (
 ): boolean => {
   const resolved = resolveConstraint(checker, type);
 
-  if (resolved.isUnion()) {
-    return resolved.types.every((t) => isPrimitiveType(checker, t));
-  }
-
-  return (resolved.flags & primitiveTypeFlags) !== 0;
+  return resolved.isUnion()
+    ? resolved.types.every((t) => isPrimitiveType(checker, t))
+    : (resolved.flags & primitiveTypeFlags) !== 0;
 };
 
 const primitiveTypeFlags =
@@ -338,7 +348,9 @@ const needsMutableResult = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: TSESTree.Node,
 ): boolean => {
-  if (isUsedAsMutable(checker, getTsNode, node)) return true;
+  if (isUsedAsMutable(checker, getTsNode, node)) {
+    return true;
+  }
 
   const parent = node.parent;
 
@@ -401,9 +413,13 @@ const isUsedAsMutable = (
   // whose declared type is a mutable array.
   const tsNode = getTsNode(node);
 
-  if (tsNode === undefined) return false;
+  if (tsNode === undefined) {
+    return false;
+  }
 
-  if (!ts.isExpression(tsNode)) return false;
+  if (!ts.isExpression(tsNode)) {
+    return false;
+  }
 
   const expectedType =
     getDeclaredParameterType(checker, tsNode) ??
@@ -436,7 +452,9 @@ const getDeclaredParameterType = (
 
   const index = call.arguments?.indexOf(argument) ?? -1;
 
-  if (index === -1) return undefined;
+  if (index === -1) {
+    return undefined;
+  }
 
   const declaration = checker.getResolvedSignature(call)?.getDeclaration();
 
@@ -444,11 +462,9 @@ const getDeclaredParameterType = (
 
   // A rest parameter's declared type is the array of arguments, not the type of
   // one; the contextual type is the better answer there.
-  if (parameter === undefined || parameter.dotDotDotToken !== undefined) {
-    return undefined;
-  }
-
-  return checker.getTypeAtLocation(parameter);
+  return parameter === undefined || parameter.dotDotDotToken !== undefined
+    ? undefined
+    : checker.getTypeAtLocation(parameter);
 };
 
 /**

package/src/rules/prefer-as-int.mts

@@ -47,7 +47,9 @@ export const preferAsInt: TSESLint.RuleModule<MessageIds, Options> = {
       TSAsExpression: (node) => {
         const typeInfo = getBrandedNumberTypeInfo(node.typeAnnotation);
 
-        if (typeInfo === undefined) return;
+        if (typeInfo === undefined) {
+          return;
+        }
 
         mut_nodesToFix.push({
           node,
@@ -59,26 +61,13 @@ export const preferAsInt: TSESLint.RuleModule<MessageIds, Options> = {
         const namedImports = getNamedImports(tsDataForgeImport);
 
         // Group nodes by function name to handle imports efficiently
-        const mut_functionNameToNodes = new Map<
-          string,
-          Readonly<{
-            node: TSESTree.TSAsExpression;
-            typeName: string;
-            functionName: string;
-          }>[]
-        >();
-
-        for (const nodeInfo of mut_nodesToFix) {
-          const mut_nodes =
-            mut_functionNameToNodes.get(nodeInfo.functionName) ?? [];
-
-          mut_nodes.push(nodeInfo);
-
-          mut_functionNameToNodes.set(nodeInfo.functionName, mut_nodes);
-        }
+        const functionNameToNodes = Map.groupBy(
+          mut_nodesToFix,
+          (nodeInfo) => nodeInfo.functionName,
+        );
 
         // Process each group
-        for (const [functionName, nodes] of mut_functionNameToNodes) {
+        for (const [functionName, nodes] of functionNameToNodes) {
           const hasImport = namedImports.includes(functionName);
 
           for (const [index, { node, typeName }] of nodes.entries()) {
@@ -114,18 +103,21 @@ export const preferAsInt: TSESLint.RuleModule<MessageIds, Options> = {
 const getBrandedNumberTypeInfo = (
   typeAnnotation: DeepReadonly<TSESTree.TypeNode>,
 ): Readonly<{ typeName: string; functionName: string }> | undefined => {
-  if (typeAnnotation.type !== AST_NODE_TYPES.TSTypeReference) return undefined;
+  if (typeAnnotation.type !== AST_NODE_TYPES.TSTypeReference) {
+    return undefined;
+  }
 
-  if (typeAnnotation.typeName.type !== AST_NODE_TYPES.Identifier)
+  if (typeAnnotation.typeName.type !== AST_NODE_TYPES.Identifier) {
     return undefined;
+  }
 
   const typeName = typeAnnotation.typeName.name;
 
-  if (!brandedNumberTypeNameToFunctionName.has(typeName)) return undefined;
+  if (!brandedNumberTypeNameToFunctionName.has(typeName)) {
+    return undefined;
+  }
 
   const functionName = brandedNumberTypeNameToFunctionName.get(typeName);
 
-  if (functionName === undefined) return undefined;
-
-  return { typeName, functionName };
+  return functionName === undefined ? undefined : { typeName, functionName };
 };

package/src/rules/prefer-canonical-array-slicing.mts

@@ -421,7 +421,9 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
         return classifyLiteralComparison(op, n);
       }
 
-      if (!isSimpleReference(receiver)) return undefined;
+      if (!isSimpleReference(receiver)) {
+        return undefined;
+      }
 
       const m = matchLengthMinus(other, receiverText);
 
@@ -435,11 +437,15 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
       if (args.length === 1) {
         const [start] = args;
 
-        if (start === undefined) return undefined;
+        if (start === undefined) {
+          return undefined;
+        }
 
         const n = asNonNegativeIntegerLiteral(start);
 
-        if (n !== undefined) return normalizeCountedOp('skip', n);
+        if (n !== undefined) {
+          return normalizeCountedOp('skip', n);
+        }
 
         const negated = asNegatedPositiveIntegerLiteral(start);
 
@@ -461,7 +467,9 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
 
         const n = asNonNegativeIntegerLiteral(end);
 
-        if (n !== undefined) return normalizeCountedOp('take', n);
+        if (n !== undefined) {
+          return normalizeCountedOp('take', n);
+        }
 
         const negated = asNegatedPositiveIntegerLiteral(end);
 
@@ -469,7 +477,9 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
           return normalizeCountedOp('skipLast', negated);
         }
 
-        if (!isSimpleReference(receiver)) return undefined;
+        if (!isSimpleReference(receiver)) {
+          return undefined;
+        }
 
         const m = matchLengthMinus(end, sourceCode.getText(receiver));
 
@@ -487,12 +497,16 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
       if (args.length === 1) {
         const [start] = args;
 
-        if (start === undefined) return undefined;
+        if (start === undefined) {
+          return undefined;
+        }
 
         const n = asNonNegativeIntegerLiteral(start);
 
         // `xs.toSpliced(N)` removes everything from index N on → take N.
-        if (n !== undefined) return normalizeCountedOp('take', n);
+        if (n !== undefined) {
+          return normalizeCountedOp('take', n);
+        }
 
         const negated = asNegatedPositiveIntegerLiteral(start);
 
@@ -516,12 +530,16 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
         // `xs.toSpliced(0, N)` removes the first N elements → skip N.
         const n = asNonNegativeIntegerLiteral(deleteCount);
 
-        if (n !== undefined) return normalizeCountedOp('skip', n);
+        if (n !== undefined) {
+          return normalizeCountedOp('skip', n);
+        }
 
         // `xs.toSpliced(0, xs.length - N)` keeps the last N → takeLast N.
         // (Note: `xs.toSpliced(0, -N)` clamps the delete count to 0 and is a
         // plain copy, so it is deliberately NOT treated as takeLast.)
-        if (!isSimpleReference(receiver)) return undefined;
+        if (!isSimpleReference(receiver)) {
+          return undefined;
+        }
 
         const m = matchLengthMinus(deleteCount, receiverText);
 
@@ -649,7 +667,9 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
 
         // The receiver must be an array or tuple (not a string / typed array
         // / other object that happens to share the method name).
-        if (!isArrayOrTupleType(getTypeOf(receiver))) return;
+        if (!isArrayOrTupleType(getTypeOf(receiver))) {
+          return;
+        }
 
         const receiverText = sourceCode.getText(receiver);
 
@@ -657,7 +677,9 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
           case 'slice': {
             const op = classifySliceArgs(node.arguments, receiver);
 
-            if (op !== undefined) report(node, op, toArgText(receiver));
+            if (op !== undefined) {
+              report(node, op, toArgText(receiver));
+            }
 
             return;
           }
@@ -669,7 +691,9 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
               receiverText,
             );
 
-            if (op !== undefined) report(node, op, toArgText(receiver));
+            if (op !== undefined) {
+              report(node, op, toArgText(receiver));
+            }
 
             return;
           }
@@ -683,7 +707,9 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
 
             const op = classifyFilterCallback(callback, receiver, receiverText);
 
-            if (op !== undefined) report(node, op, toArgText(receiver));
+            if (op !== undefined) {
+              report(node, op, toArgText(receiver));
+            }
 
             return;
           }
@@ -735,7 +761,9 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
       ArrayExpression: (node) => {
         // `[item, ...xs]` → `Arr.toUnshifted(xs, item)`,
         // `[...xs, item]` → `Arr.toPushed(xs, item)`.
-        if (node.elements.length !== 2) return;
+        if (node.elements.length !== 2) {
+          return;
+        }
 
         const [first, second] = node.elements;
 
@@ -760,11 +788,15 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
         // `spread`, `item`, and `fn` are set together (all from the same
         // tuple), so checking `spread` also guarantees the others are
         // defined.
-        if (spread === undefined) return;
+        if (spread === undefined) {
+          return;
+        }
 
         // Spreading a non-array iterable (`[v, ...someSet]`) is a genuine
         // conversion, not an element addition to an array.
-        if (!isArrayOrTupleType(getTypeOf(spread.argument))) return;
+        if (!isArrayOrTupleType(getTypeOf(spread.argument))) {
+          return;
+        }
 
         report(
           node,

package/src/rules/prefer-canonical-length-cast.mts

@@ -145,20 +145,26 @@ export const preferCanonicalLengthCast: TSESLint.RuleModule<
       'Arr',
     );
 
-    if (arrLocalName === undefined) return {};
+    if (arrLocalName === undefined) {
+      return {};
+    }
 
     return {
       CallExpression: (node) => {
         const castName = getCastName(node, arrLocalName);
 
-        if (castName === undefined) return;
+        if (castName === undefined) {
+          return;
+        }
 
         const rewrite = CAST_REWRITES.find(
           (candidate) =>
             candidate.cast === castName && matchesBounds(node, candidate),
         );
 
-        if (rewrite === undefined) return;
+        if (rewrite === undefined) {
+          return;
+        }
 
         const boundsText = node.arguments
           .slice(0, rewrite.bounds.length)
@@ -238,7 +244,9 @@ const matchesBounds = (
   return rewrite.bounds.every((matcher, index) => {
     const value = bounds[index];
 
-    if (value === undefined) return false;
+    if (value === undefined) {
+      return false;
+    }
 
     switch (matcher) {
       case 'anyLength':
@@ -277,9 +285,9 @@ const dropBoundsFix = (
 
     const next = node.arguments[index + 1];
 
-    if (rewrite.keep.includes(index)) return [];
-
-    return dropped === undefined || next === undefined
+    return dropped === undefined ||
+      next === undefined ||
+      rewrite.keep.includes(index)
       ? []
       : [fixer.removeRange([dropped.range[0], next.range[0]])];
   });

package/src/rules/prefer-canonical-length-guard.mts

@@ -124,7 +124,9 @@ export const preferCanonicalLengthGuard: TSESLint.RuleModule<
       rule.create(context),
     );
 
-    if (arrLocalName === undefined) return mergeVisitors(comparisonVisitors);
+    if (arrLocalName === undefined) {
+      return mergeVisitors(comparisonVisitors);
+    }
 
     return mergeVisitors([
       ...comparisonVisitors,
@@ -132,7 +134,9 @@ export const preferCanonicalLengthGuard: TSESLint.RuleModule<
         CallExpression: (node) => {
           const guardName = getGuardName(node, arrLocalName);
 
-          if (guardName === undefined) return;
+          if (guardName === undefined) {
+            return;
+          }
 
           const rewrite = GUARD_REWRITES.find(
             (entry) => entry.guard === guardName,
@@ -145,7 +149,9 @@ export const preferCanonicalLengthGuard: TSESLint.RuleModule<
           // The array is the last argument; the bounds precede it.
           const array = node.arguments[rewrite.bounds.length];
 
-          if (array === undefined) return;
+          if (array === undefined) {
+            return;
+          }
 
           const arrayText = sourceCode.getText(array);
 
@@ -185,7 +191,9 @@ const mergeVisitors = (
 
   for (const visitor of visitors) {
     for (const [selector, handler] of Object.entries(visitor)) {
-      if (typeof handler !== 'function') continue;
+      if (typeof handler !== 'function') {
+        continue;
+      }
 
       const mut_handlers = mut_merged[selector] ?? [];
 

package/src/rules/prefer-comparison-over-nullish-guard.mts

@@ -97,7 +97,9 @@ export const preferComparisonOverNullishGuard: TSESLint.RuleModule<
 
     return {
       CallExpression: (node) => {
-        if (node.arguments.length !== 1) return;
+        if (node.arguments.length !== 1) {
+          return;
+        }
 
         const argument = node.arguments[0];
 
@@ -110,11 +112,15 @@ export const preferComparisonOverNullishGuard: TSESLint.RuleModule<
 
         const resolved = resolveGuard(node.callee);
 
-        if (resolved === undefined) return;
+        if (resolved === undefined) {
+          return;
+        }
 
         const spec = COMPARISON_GUARDS[resolved.canonicalName];
 
-        if (spec === undefined) return;
+        if (spec === undefined) {
+          return;
+        }
 
         const argRaw = sourceCode.getText(argument);
 

package/src/rules/prefer-is-non-null-object.mts

@@ -45,7 +45,9 @@ export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
       LogicalExpression: (node) => {
         const identifierName = getNonNullObjectIdentifierName(node);
 
-        if (identifierName === undefined) return;
+        if (identifierName === undefined) {
+          return;
+        }
 
         mut_nodesToFix.push({ node, identifierName });
       },
@@ -89,57 +91,59 @@ export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
 const getNonNullObjectIdentifierName = (
   node: DeepReadonly<TSESTree.LogicalExpression>,
 ): string | undefined => {
-  if (node.operator !== '&&') return undefined;
+  if (node.operator !== '&&') {
+    return undefined;
+  }
 
   const leftIdentifierName = getTypeofObjectIdentifierName(node.left);
 
   const rightIdentifierName = getNonNullCheckIdentifierName(node.right);
 
-  if (leftIdentifierName === undefined) return undefined;
-
-  if (rightIdentifierName === undefined) return undefined;
-
-  if (leftIdentifierName !== rightIdentifierName) return undefined;
-
-  return leftIdentifierName;
+  return leftIdentifierName === undefined ||
+    rightIdentifierName === undefined ||
+    leftIdentifierName !== rightIdentifierName
+    ? undefined
+    : leftIdentifierName;
 };
 
 const getTypeofObjectIdentifierName = (
   node: DeepReadonly<TSESTree.Expression>,
 ): string | undefined => {
-  if (node.type !== AST_NODE_TYPES.BinaryExpression) return undefined;
+  if (node.type !== AST_NODE_TYPES.BinaryExpression) {
+    return undefined;
+  }
 
-  if (node.operator !== '===') return undefined;
+  if (node.operator !== '===') {
+    return undefined;
+  }
 
   const { left, right } = node;
 
-  if (left.type !== AST_NODE_TYPES.UnaryExpression) return undefined;
-
-  if (left.operator !== 'typeof') return undefined;
-
-  if (right.type !== AST_NODE_TYPES.Literal) return undefined;
-
-  if (right.value !== 'object') return undefined;
-
-  if (left.argument.type !== AST_NODE_TYPES.Identifier) return undefined;
-
-  return left.argument.name;
+  return left.type !== AST_NODE_TYPES.UnaryExpression ||
+    left.operator !== 'typeof' ||
+    right.type !== AST_NODE_TYPES.Literal ||
+    right.value !== 'object' ||
+    left.argument.type !== AST_NODE_TYPES.Identifier
+    ? undefined
+    : left.argument.name;
 };
 
 const getNonNullCheckIdentifierName = (
   node: DeepReadonly<TSESTree.Expression>,
 ): string | undefined => {
-  if (node.type !== AST_NODE_TYPES.BinaryExpression) return undefined;
+  if (node.type !== AST_NODE_TYPES.BinaryExpression) {
+    return undefined;
+  }
 
-  if (node.operator !== '!==') return undefined;
+  if (node.operator !== '!==') {
+    return undefined;
+  }
 
   const { left, right } = node;
 
-  if (left.type !== AST_NODE_TYPES.Identifier) return undefined;
-
-  if (right.type !== AST_NODE_TYPES.Literal) return undefined;
-
-  if (right.value !== null) return undefined;
-
-  return left.name;
+  return left.type !== AST_NODE_TYPES.Identifier ||
+    right.type !== AST_NODE_TYPES.Literal ||
+    right.value !== null
+    ? undefined
+    : left.name;
 };

package/src/rules/prefer-is-record-and-has-key.mts

@@ -54,7 +54,9 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
         // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
         expression: TSESTree.Expression,
       ): boolean => {
-        if (checker === undefined) return false;
+        if (checker === undefined) {
+          return false;
+        }
 
         const tsNode = services?.esTreeNodeToTSNodeMap?.get(expression);
 
@@ -84,13 +86,17 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
           }
 
           // Check arguments: Object.hasOwn(obj, key)
-          if (node.arguments.length !== 2) return;
+          if (node.arguments.length !== 2) {
+            return;
+          }
 
           const objArg = node.arguments[0];
 
           const keyArg = node.arguments[1];
 
-          if (objArg === undefined || keyArg === undefined) return;
+          if (objArg === undefined || keyArg === undefined) {
+            return;
+          }
 
           // Type guard: ensure arguments are Expressions (not SpreadElement)
           if (
@@ -109,14 +115,18 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
 
         // Handle key in obj
         BinaryExpression: (node) => {
-          if (node.operator !== 'in') return;
+          if (node.operator !== 'in') {
+            return;
+          }
 
           const keyExpression = node.left;
 
           const objExpression = node.right;
 
           // Type guard: ensure keyExpression is Expression (not PrivateIdentifier)
-          if (keyExpression.type === AST_NODE_TYPES.PrivateIdentifier) return;
+          if (keyExpression.type === AST_NODE_TYPES.PrivateIdentifier) {
+            return;
+          }
 
           mut_nodesToFix.push({
             node,