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

package/src/rules/no-unnecessary-type-guard.mts

@@ -156,7 +156,9 @@ export const noUnnecessaryTypeGuard: TSESLint.RuleModule<MessageIds, Options> =
       const strictNullChecks =
         compilerOptions.strictNullChecks ?? compilerOptions.strict ?? false;
 
-      if (!strictNullChecks) return {};
+      if (!strictNullChecks) {
+        return {};
+      }
 
       const checker = parserServices.program.getTypeChecker();
 
@@ -249,7 +251,9 @@ export const noUnnecessaryTypeGuard: TSESLint.RuleModule<MessageIds, Options> =
 
       return {
         CallExpression: (node) => {
-          if (node.arguments.length !== 1) return;
+          if (node.arguments.length !== 1) {
+            return;
+          }
 
           const argument = node.arguments[0];
 
@@ -262,15 +266,21 @@ export const noUnnecessaryTypeGuard: TSESLint.RuleModule<MessageIds, Options> =
 
           const resolved = resolveGuard(node.callee);
 
-          if (resolved === undefined) return;
+          if (resolved === undefined) {
+            return;
+          }
 
           const { canonicalName, propertyNode, isNamespace } = resolved;
 
-          if (ignored.has(canonicalName)) return;
+          if (ignored.has(canonicalName)) {
+            return;
+          }
 
           const spec = GUARD_SPECS[canonicalName];
 
-          if (spec === undefined) return;
+          if (spec === undefined) {
+            return;
+          }
 
           const argTsNode = parserServices.esTreeNodeToTSNodeMap.get(argument);
 
@@ -278,7 +288,9 @@ export const noUnnecessaryTypeGuard: TSESLint.RuleModule<MessageIds, Options> =
 
           const parts = collectUnionParts(argType);
 
-          if (parts === undefined) return; // opaque / generic → bail conservatively
+          if (parts === undefined) {
+            return; // opaque / generic → bail conservatively
+          }
 
           const inputAtoms = new Set(parts.map(classifyAtom));
 
@@ -413,7 +425,9 @@ const collectUnionParts = (type: ts.Type): readonly ts.Type[] | undefined => {
   const parts = type.isUnion() ? type.types : ([type] as const);
 
   for (const part of parts) {
-    if ((part.flags & DEFERRED_OR_OPAQUE_FLAGS) !== 0) return undefined;
+    if ((part.flags & DEFERRED_OR_OPAQUE_FLAGS) !== 0) {
+      return undefined;
+    }
   }
 
   return parts;
@@ -473,19 +487,33 @@ const isCallableType = (
 const classifyAtom = (type: ts.Type): Atom => {
   const { flags } = type;
 
-  if ((flags & ts.TypeFlags.Undefined) !== 0) return 'undefined';
+  if ((flags & ts.TypeFlags.Undefined) !== 0) {
+    return 'undefined';
+  }
 
-  if ((flags & ts.TypeFlags.Null) !== 0) return 'null';
+  if ((flags & ts.TypeFlags.Null) !== 0) {
+    return 'null';
+  }
 
-  if ((flags & ts.TypeFlags.BooleanLike) !== 0) return 'boolean';
+  if ((flags & ts.TypeFlags.BooleanLike) !== 0) {
+    return 'boolean';
+  }
 
-  if ((flags & ts.TypeFlags.NumberLike) !== 0) return 'number';
+  if ((flags & ts.TypeFlags.NumberLike) !== 0) {
+    return 'number';
+  }
 
-  if ((flags & ts.TypeFlags.StringLike) !== 0) return 'string';
+  if ((flags & ts.TypeFlags.StringLike) !== 0) {
+    return 'string';
+  }
 
-  if ((flags & ts.TypeFlags.BigIntLike) !== 0) return 'bigint';
+  if ((flags & ts.TypeFlags.BigIntLike) !== 0) {
+    return 'bigint';
+  }
 
-  if ((flags & ts.TypeFlags.ESSymbolLike) !== 0) return 'symbol';
+  if ((flags & ts.TypeFlags.ESSymbolLike) !== 0) {
+    return 'symbol';
+  }
 
   // Branded primitives (e.g. `NonEmptyString = string & {...}`) are
   // intersections; classify them by their underlying primitive constituent.
@@ -493,7 +521,9 @@ const classifyAtom = (type: ts.Type): Atom => {
     for (const constituent of type.types) {
       const atom = classifyAtom(constituent);
 
-      if (atom !== 'other') return atom;
+      if (atom !== 'other') {
+        return atom;
+      }
     }
   }
 
@@ -525,13 +555,19 @@ const isGuaranteedNonEmptyString = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   checker: ts.TypeChecker,
 ): boolean => {
-  if (type.isStringLiteral()) return type.value !== '';
+  if (type.isStringLiteral()) {
+    return type.value !== '';
+  }
 
-  if (type.getProperty(BRAND_MARKER_PROPERTY) === undefined) return false;
+  if (type.getProperty(BRAND_MARKER_PROPERTY) === undefined) {
+    return false;
+  }
 
   const minLengthSymbol = type.getProperty(MIN_LENGTH_BRAND_KEY);
 
-  if (minLengthSymbol === undefined) return false;
+  if (minLengthSymbol === undefined) {
+    return false;
+  }
 
   // The `MinLength` brand value is `MinLengthTuple<N, 0>`; it has a required
   // first element (`'0'`) exactly when `N >= 1`, i.e. the string is non-empty.
@@ -547,11 +583,8 @@ const isGuaranteedNonEmptyString = (
  * literal and non-string types cannot.
  */
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-const couldBeNonEmptyString = (type: ts.Type): boolean => {
-  if (type.isStringLiteral()) return type.value !== '';
-
-  return classifyAtom(type) === 'string';
-};
+const couldBeNonEmptyString = (type: ts.Type): boolean =>
+  type.isStringLiteral() ? type.value !== '' : classifyAtom(type) === 'string';
 
 /**
  * Returns `true` when evaluating the expression cannot have observable side

package/src/rules/prefer-arr-is-array.mts

@@ -40,7 +40,9 @@ export const preferArrIsArray: TSESLint.RuleModule<MessageIds, Options> = {
 
     return {
       CallExpression: (node) => {
-        if (!isArrayIsArrayCall(node)) return;
+        if (!isArrayIsArrayCall(node)) {
+          return;
+        }
 
         mut_nodesToFix.push(node);
       },
@@ -59,7 +61,9 @@ export const preferArrIsArray: TSESLint.RuleModule<MessageIds, Options> = {
             fix: (fixer) => {
               const callee = node.callee;
 
-              if (callee.type !== AST_NODE_TYPES.MemberExpression) return [];
+              if (callee.type !== AST_NODE_TYPES.MemberExpression) {
+                return [];
+              }
 
               const replacement = `Arr.isArray${sourceCode.getText(node).slice(sourceCode.getText(callee).length)}`;
 
@@ -82,17 +86,27 @@ export const preferArrIsArray: TSESLint.RuleModule<MessageIds, Options> = {
 const isArrayIsArrayCall = (
   node: DeepReadonly<TSESTree.CallExpression>,
 ): boolean => {
-  if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+  if (node.callee.type !== AST_NODE_TYPES.MemberExpression) {
+    return false;
+  }
 
   const { object, property } = node.callee;
 
-  if (object.type !== AST_NODE_TYPES.Identifier) return false;
+  if (object.type !== AST_NODE_TYPES.Identifier) {
+    return false;
+  }
 
-  if (object.name !== 'Array') return false;
+  if (object.name !== 'Array') {
+    return false;
+  }
 
-  if (property.type !== AST_NODE_TYPES.Identifier) return false;
+  if (property.type !== AST_NODE_TYPES.Identifier) {
+    return false;
+  }
 
-  if (property.name !== 'isArray') return false;
+  if (property.name !== 'isArray') {
+    return false;
+  }
 
   return true;
 };

package/src/rules/prefer-arr-is-bounded-length-array.mts

@@ -47,16 +47,22 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
     return {
       LogicalExpression: (node) => {
         // Only `a && b` can encode a `min && max` length range.
-        if (node.operator !== '&&') return;
+        if (node.operator !== '&&') {
+          return;
+        }
 
         const left = parseLengthComparison(node.left, sourceCode);
 
         const right = parseLengthComparison(node.right, sourceCode);
 
-        if (left === undefined || right === undefined) return;
+        if (left === undefined || right === undefined) {
+          return;
+        }
 
         // Need one lower bound and one upper bound on the same array.
-        if (left.kind === right.kind) return;
+        if (left.kind === right.kind) {
+          return;
+        }
 
         if (
           sourceCode.getText(left.array) !== sourceCode.getText(right.array)
@@ -83,7 +89,9 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
             const isArrayType =
               checker.isArrayType(type) || checker.isTupleType(type);
 
-            if (!isArrayType) return;
+            if (!isArrayType) {
+              return;
+            }
           } else {
             return;
           }

package/src/rules/prefer-arr-is-fixed-length-array.mts

@@ -52,7 +52,9 @@ export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
     return {
       BinaryExpression: (node) => {
         // Check for `xs.length === n` or `n === xs.length` or `xs.length !== n`
-        if (node.operator !== '===' && node.operator !== '!==') return;
+        if (node.operator !== '===' && node.operator !== '!==') {
+          return;
+        }
 
         const isNegated = node.operator === '!==';
 
@@ -62,10 +64,14 @@ export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
 
         const valueSide = node[isLengthOnLeft ? 'right' : 'left'];
 
-        if (!isLengthAccess(lengthSide)) return;
+        if (!isLengthAccess(lengthSide)) {
+          return;
+        }
 
         // Only match integer literals or const variables initialized with integer literals
-        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) return;
+        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) {
+          return;
+        }
 
         // lengthSide is MemberExpression accessing .length
         const arrayExpression = lengthSide.object;
@@ -83,7 +89,9 @@ export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
             const isArrayType =
               checker.isArrayType(type) || checker.isTupleType(type);
 
-            if (!isArrayType) return;
+            if (!isArrayType) {
+              return;
+            }
           } else {
             return;
           }

package/src/rules/prefer-arr-is-max-length-array.mts

@@ -50,11 +50,15 @@ export const preferArrIsMaxLengthArray: TSESLint.RuleModule<
     return {
       BinaryExpression: (node) => {
         // Check for `xs.length <= n` or `n >= xs.length`
-        if (node.operator !== '>=' && node.operator !== '<=') return;
+        if (node.operator !== '>=' && node.operator !== '<=') {
+          return;
+        }
 
         // Defer to `prefer-arr-is-bounded-length-array` when this comparison is
         // the upper bound of a `min && max` pair on the same array.
-        if (isPartOfBoundedLengthCheck(node, sourceCode)) return;
+        if (isPartOfBoundedLengthCheck(node, sourceCode)) {
+          return;
+        }
 
         // xs.length <= n  or  n >= xs.length
         const isLengthOnLeft = node.operator === '<=';
@@ -64,10 +68,14 @@ export const preferArrIsMaxLengthArray: TSESLint.RuleModule<
         const valueSide = node[isLengthOnLeft ? 'right' : 'left'];
 
         // Check if lengthSide is accessing .length
-        if (!isLengthAccess(lengthSide)) return;
+        if (!isLengthAccess(lengthSide)) {
+          return;
+        }
 
         // Only match integer literals or const variables initialized with integer literals
-        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) return;
+        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) {
+          return;
+        }
 
         // lengthSide is MemberExpression accessing .length
         const arrayExpression = lengthSide.object;
@@ -85,7 +93,9 @@ export const preferArrIsMaxLengthArray: TSESLint.RuleModule<
             const isArrayType =
               checker.isArrayType(type) || checker.isTupleType(type);
 
-            if (!isArrayType) return;
+            if (!isArrayType) {
+              return;
+            }
           } else {
             return;
           }

package/src/rules/prefer-arr-is-min-length-array.mts

@@ -50,11 +50,15 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
     return {
       BinaryExpression: (node) => {
         // Check for `xs.length >= n` or `n <= xs.length`
-        if (node.operator !== '>=' && node.operator !== '<=') return;
+        if (node.operator !== '>=' && node.operator !== '<=') {
+          return;
+        }
 
         // Defer to `prefer-arr-is-bounded-length-array` when this comparison is
         // the lower bound of a `min && max` pair on the same array.
-        if (isPartOfBoundedLengthCheck(node, sourceCode)) return;
+        if (isPartOfBoundedLengthCheck(node, sourceCode)) {
+          return;
+        }
 
         // xs.length >= n  or  n <= xs.length
         const isLengthOnLeft = node.operator === '>=';
@@ -64,10 +68,14 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
         const valueSide = node[isLengthOnLeft ? 'right' : 'left'];
 
         // Check if lengthSide is accessing .length
-        if (!isLengthAccess(lengthSide)) return;
+        if (!isLengthAccess(lengthSide)) {
+          return;
+        }
 
         // Only match integer literals or const variables initialized with integer literals
-        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) return;
+        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) {
+          return;
+        }
 
         // lengthSide is MemberExpression accessing .length
         const arrayExpression = lengthSide.object;
@@ -85,7 +93,9 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
             const isArrayType =
               checker.isArrayType(type) || checker.isTupleType(type);
 
-            if (!isArrayType) return;
+            if (!isArrayType) {
+              return;
+            }
           } else {
             return;
           }

package/src/rules/prefer-arr-is-non-empty.mts

@@ -45,7 +45,9 @@ export const preferArrIsNonEmpty: TSESLint.RuleModule<MessageIds, Options> = {
     return {
       BinaryExpression: (node) => {
         // Check for `xs.length > 0` or `0 < xs.length`
-        if (node.operator !== '>' && node.operator !== '<') return;
+        if (node.operator !== '>' && node.operator !== '<') {
+          return;
+        }
 
         const isLengthOnLeft = node.operator === '>';
 
@@ -79,7 +81,9 @@ export const preferArrIsNonEmpty: TSESLint.RuleModule<MessageIds, Options> = {
             const isArrayType =
               checker.isArrayType(type) || checker.isTupleType(type);
 
-            if (!isArrayType) return;
+            if (!isArrayType) {
+              return;
+            }
           } else {
             return;
           }

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

@@ -190,7 +190,9 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
     ): boolean => {
       const tsNode = services?.esTreeNodeToTSNodeMap?.get(node);
 
-      if (checker === undefined || tsNode === undefined) return true;
+      if (checker === undefined || tsNode === undefined) {
+        return true;
+      }
 
       const type = checker.getTypeAtLocation(tsNode);
 
@@ -227,14 +229,16 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
       // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
       accumulation: Accumulation,
     ): string | undefined => {
-      if (callback.async || callback.generator) return undefined;
+      if (callback.async || callback.generator) {
+        return undefined;
+      }
 
       // `reduce`'s fourth parameter is the whole array, which `scan` never
       // hands its callback; an annotation on the accumulator describes that
       // array, and would be wrong on `scan`'s value parameter.
       if (
         callback.params.length < 2 ||
-        callback.params.length > 3 ||
+        3 < callback.params.length ||
         callback.params.some(
           (param) =>
             param.type !== AST_NODE_TYPES.Identifier ||
@@ -266,7 +270,9 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
         (variable) => variable.name === accumulatorParam.name,
       );
 
-      if (accumulator === undefined) return undefined;
+      if (accumulator === undefined) {
+        return undefined;
+      }
 
       // `acc.at(-1)` is `T | undefined` only because `at` can go out of bounds,
       // which a seeded accumulator never does. So once the value `scan` carries
@@ -281,13 +287,19 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
         const identifier = reference.identifier;
 
         // The `...acc` / `Arr.toPushed(acc, …)` target the rewrite drops.
-        if (identifier === accumulatorRef) continue;
+        if (identifier === accumulatorRef) {
+          continue;
+        }
 
-        if (identifier.type !== AST_NODE_TYPES.Identifier) return undefined;
+        if (identifier.type !== AST_NODE_TYPES.Identifier) {
+          return undefined;
+        }
 
         const lastRead = enclosingLastRead(identifier);
 
-        if (lastRead === undefined) return undefined;
+        if (lastRead === undefined) {
+          return undefined;
+        }
 
         const guard = carriesNullish ? undefined : nullishGuardAround(lastRead);
 
@@ -299,11 +311,15 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
 
       // Two reads inside one `?? ` — `acc.at(-1) ?? acc.at(-1)` — would give
       // ranges that contain one another, which no ordering of splices resolves.
-      if (overlaps(mut_lastReads)) return undefined;
+      if (overlaps(mut_lastReads)) {
+        return undefined;
+      }
 
       // With no read of the previous value this is a `map` with a seed rather
       // than a scan, and the accumulator parameter would be left unused.
-      if (mut_lastReads.length === 0) return undefined;
+      if (mut_lastReads.length === 0) {
+        return undefined;
+      }
 
       const parameterText = callback.params
         .map((param) => sourceCode.getText(param))
@@ -333,7 +349,9 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
       // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
       callback: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression,
     ): readonly TSESTree.Node[] | undefined => {
-      if (!Arr.isFixedLengthArray(2, callback.params)) return undefined;
+      if (!Arr.isFixedLengthArray(2, callback.params)) {
+        return undefined;
+      }
 
       const [elementParam, indexParam] = callback.params;
 
@@ -358,7 +376,9 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
         return undefined;
       }
 
-      if (elementVariable.references.length > 0) return undefined;
+      if (elementVariable.references.length > 0) {
+        return undefined;
+      }
 
       return indexVariable.references.map(
         (reference) => reference.identifier as TSESTree.Node,
@@ -395,11 +415,15 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
 
         switch (methodName) {
           case 'map': {
-            if (rest.length > 0) break;
+            if (rest.length > 0) {
+              break;
+            }
 
             const indexReads = indexReadsOf(callback);
 
-            if (indexReads === undefined) break;
+            if (indexReads === undefined) {
+              break;
+            }
 
             mut_candidates.push({
               call: node,
@@ -415,7 +439,9 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
             // Two arguments, so that the initial value is explicit: a `reduce`
             // without one starts from the first element and has no `scan`
             // spelling at all.
-            if (rest.length !== 1 || !appendsToItsAccumulator(callback)) break;
+            if (rest.length !== 1 || !appendsToItsAccumulator(callback)) {
+              break;
+            }
 
             const [initial] = rest;
 
@@ -483,7 +509,9 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
               ),
           );
 
-          if (rebuild === undefined) continue;
+          if (rebuild === undefined) {
+            continue;
+          }
 
           context.report({
             node: candidate.call,
@@ -605,7 +633,9 @@ const appendsToItsAccumulator = (
 ): boolean => {
   const [accumulatorParam] = callback.params;
 
-  if (accumulatorParam?.type !== AST_NODE_TYPES.Identifier) return false;
+  if (accumulatorParam?.type !== AST_NODE_TYPES.Identifier) {
+    return false;
+  }
 
   const { body } = callback;
 
@@ -645,14 +675,18 @@ const accumulationOf = (
 ): Accumulation | undefined => {
   const [accumulatorParam] = callback.params;
 
-  if (accumulatorParam?.type !== AST_NODE_TYPES.Identifier) return undefined;
+  if (accumulatorParam?.type !== AST_NODE_TYPES.Identifier) {
+    return undefined;
+  }
 
   const { body } = callback;
 
   // `[...acc, ELEMENT]` — exactly one spread and one new value, since `scan`
   // appends exactly one per step.
   if (body.type === AST_NODE_TYPES.ArrayExpression) {
-    if (!Arr.isFixedLengthArray(2, body.elements)) return undefined;
+    if (!Arr.isFixedLengthArray(2, body.elements)) {
+      return undefined;
+    }
 
     const [spread, element] = body.elements;
 

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

@@ -61,7 +61,9 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
         const arrayExpression = node.callee.object;
 
         // Check if we have 2 arguments: reducer function and initial value 0
-        if (!Arr.isFixedLengthTuple(2, node.arguments)) return;
+        if (!Arr.isFixedLengthTuple(2, node.arguments)) {
+          return;
+        }
 
         const reducer = node.arguments[0];
 
@@ -96,7 +98,9 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
 
         const checker = services?.program?.getTypeChecker();
 
-        if (checker === undefined) return;
+        if (checker === undefined) {
+          return;
+        }
 
         // Case 1: (a, b) => a + b
         if (
@@ -189,7 +193,9 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
             mut_propName = leftProp.value;
           }
 
-          if (mut_propName === undefined) return;
+          if (mut_propName === undefined) {
+            return;
+          }
 
           // Check if property type is number
           if (services?.program !== undefined && services.program !== null) {