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

package/src/rules/prefer-num-safe-parse-float.mts

@@ -91,32 +91,43 @@ export const preferNumSafeParseFloat: TSESLint.RuleModule<MessageIds, Options> =
             callee.type === AST_NODE_TYPES.Identifier &&
             callee.name === 'Number';
 
-          if (!isGlobalParseFloat && !isNumberParseFloat && !isNumberCall)
+          if (!isGlobalParseFloat && !isNumberParseFloat && !isNumberCall) {
             return;
+          }
 
           const args = node.arguments;
 
           const firstArg = args[0];
 
-          if (firstArg === undefined) return;
+          if (firstArg === undefined) {
+            return;
+          }
 
           // Spread argument (`parseFloat(...rest)`) cannot be rewritten safely.
-          if (firstArg.type === AST_NODE_TYPES.SpreadElement) return;
+          if (firstArg.type === AST_NODE_TYPES.SpreadElement) {
+            return;
+          }
 
           // The argument must be purely `string` so the autofix is type-safe
           // against `Num.safeParseFloat(s: string)`. Without type information,
           // skip.
-          if (services?.program == null) return;
+          if (services?.program == null) {
+            return;
+          }
 
           const checker = services.program.getTypeChecker();
 
           const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
 
-          if (tsNode === undefined) return;
+          if (tsNode === undefined) {
+            return;
+          }
 
           const argType = checker.getTypeAtLocation(tsNode);
 
-          if (!isStringType(argType)) return;
+          if (!isStringType(argType)) {
+            return;
+          }
 
           mut_nodesToFix.push({ node, argExpression: firstArg });
         },

package/src/rules/prefer-num-safe-parse-int.mts

@@ -84,16 +84,22 @@ export const preferNumSafeParseInt: TSESLint.RuleModule<MessageIds, Options> = {
           callee.property.type === AST_NODE_TYPES.Identifier &&
           callee.property.name === 'parseInt';
 
-        if (!isGlobalParseInt && !isNumberParseInt) return;
+        if (!isGlobalParseInt && !isNumberParseInt) {
+          return;
+        }
 
         const args = node.arguments;
 
         const firstArg = args[0];
 
-        if (firstArg === undefined) return;
+        if (firstArg === undefined) {
+          return;
+        }
 
         // Spread argument (`parseInt(...rest)`) cannot be rewritten safely.
-        if (firstArg.type === AST_NODE_TYPES.SpreadElement) return;
+        if (firstArg.type === AST_NODE_TYPES.SpreadElement) {
+          return;
+        }
 
         // Only base 10: accept a missing radix or an explicit literal `10`.
         if (args.length >= 2) {
@@ -106,17 +112,23 @@ export const preferNumSafeParseInt: TSESLint.RuleModule<MessageIds, Options> = {
 
         // The argument must be a `string` so the autofix is type-safe against
         // `Num.safeParseInt(s: string)`. Without type information, skip.
-        if (services?.program == null) return;
+        if (services?.program == null) {
+          return;
+        }
 
         const checker = services.program.getTypeChecker();
 
         const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
 
-        if (tsNode === undefined) return;
+        if (tsNode === undefined) {
+          return;
+        }
 
         const argType = checker.getTypeAtLocation(tsNode);
 
-        if (!isStringType(argType)) return;
+        if (!isStringType(argType)) {
+          return;
+        }
 
         mut_nodesToFix.push({ node, argExpression: firstArg });
       },

package/src/rules/prefer-obj-over-entries-round-trip.mts

@@ -159,7 +159,9 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
       CallExpression: (node) => {
         const roundTrip = parseEntriesRoundTrip(node);
 
-        if (roundTrip === undefined) return;
+        if (roundTrip === undefined) {
+          return;
+        }
 
         mut_roundTrips.push({ node, roundTrip });
       },
@@ -225,13 +227,19 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
 const parseEntriesRoundTrip = (
   node: TSESTree.CallExpression,
 ): RoundTrip | undefined => {
-  if (!isObjectStaticCall(node, 'fromEntries')) return undefined;
+  if (!isObjectStaticCall(node, 'fromEntries')) {
+    return undefined;
+  }
 
-  if (!Arr.isFixedLengthTuple(1, node.arguments)) return undefined;
+  if (!Arr.isFixedLengthTuple(1, node.arguments)) {
+    return undefined;
+  }
 
   const [transform] = node.arguments;
 
-  if (transform.type !== AST_NODE_TYPES.CallExpression) return undefined;
+  if (transform.type !== AST_NODE_TYPES.CallExpression) {
+    return undefined;
+  }
 
   const { callee } = transform;
 
@@ -265,11 +273,15 @@ const parseEntriesRoundTrip = (
 
   const [record] = entriesCall.arguments;
 
-  if (record.type === AST_NODE_TYPES.SpreadElement) return undefined;
+  if (record.type === AST_NODE_TYPES.SpreadElement) {
+    return undefined;
+  }
 
   // A second argument (`thisArg`) or a callback that also takes the entry index
   // has no counterpart in `Obj`.
-  if (!Arr.isFixedLengthTuple(1, transform.arguments)) return undefined;
+  if (!Arr.isFixedLengthTuple(1, transform.arguments)) {
+    return undefined;
+  }
 
   const [callback] = transform.arguments;
 
@@ -287,11 +299,15 @@ const parseEntriesRoundTrip = (
 
   const [entryPattern] = callback.params;
 
-  if (entryPattern.type !== AST_NODE_TYPES.ArrayPattern) return undefined;
+  if (entryPattern.type !== AST_NODE_TYPES.ArrayPattern) {
+    return undefined;
+  }
 
   const entryParams = parseEntryPattern(entryPattern);
 
-  if (entryParams === undefined) return undefined;
+  if (entryParams === undefined) {
+    return undefined;
+  }
 
   const body = callback.body;
 
@@ -320,7 +336,9 @@ const parseEntriesRoundTrip = (
     }
 
     case 'flatMap': {
-      if (body.type !== AST_NODE_TYPES.ConditionalExpression) return undefined;
+      if (body.type !== AST_NODE_TYPES.ConditionalExpression) {
+        return undefined;
+      }
 
       const onTrue = parseSingletonEntry(body.consequent, entryParams.keyParam);
 
@@ -365,7 +383,9 @@ type EntryParams = Readonly<{
 const parseEntryPattern = (
   pattern: TSESTree.ArrayPattern,
 ): EntryParams | undefined => {
-  if (pattern.elements.length > 2) return undefined;
+  if (pattern.elements.length > 2) {
+    return undefined;
+  }
 
   const [keyElement, valueElement] = pattern.elements;
 
@@ -399,7 +419,9 @@ const parseKeptEntry = (
   node: TSESTree.Expression,
   keyParam: TSESTree.Identifier | undefined,
 ): KeptEntry | undefined => {
-  if (keyParam === undefined) return undefined;
+  if (keyParam === undefined) {
+    return undefined;
+  }
 
   const tuple = stripTypeWrappers(node);
 

package/src/rules/prefer-range-for-loop.mts

@@ -81,7 +81,9 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
         const endExpr = node.test.right;
 
         // Check update: ++i, i++, i += 1, or i += step
-        if (node.update === null) return;
+        if (node.update === null) {
+          return;
+        }
 
         let mut_step: string | undefined;