@konvert7/klint 0.37.1 → 1.0.0

package/rules/no-sync-in-async.ts

@@ -1,43 +0,0 @@
-import ts from "typescript";
-import { nearestFunctionIsAsync, walkAst } from "../core/ast";
-import { relativeSlashPath } from "../core/paths";
-import type { KlintRule } from "../core/types";
-
-export const noSyncInAsync: KlintRule = {
-  meta: {
-    description:
-      "Flags synchronous I/O (`readFileSync`, `execSync`, etc.) inside async functions — blocks the event loop when an async equivalent is available.",
-    examples: [
-      "no-sync-in-async: error",
-      'no-sync-in-async:\n  severity: warn\n  include: ["src/server/**"]',
-    ],
-  },
-  check({ files, root, fileContents }, violations) {
-    for (const file of files) {
-      const content = fileContents.get(file) ?? "";
-      walkAst(file, content, (node, src) => {
-        if (ts.isCallExpression(node)) {
-          const callee = node.expression;
-          let name: string | null = null;
-          if (ts.isIdentifier(callee)) {
-            name = callee.text;
-          } else if (ts.isPropertyAccessExpression(callee)) {
-            name = callee.name.text;
-          }
-          if (
-            name?.endsWith("Sync") &&
-            name !== "existsSync" &&
-            nearestFunctionIsAsync(node)
-          ) {
-            const { line } = src.getLineAndCharacterOfPosition(node.getStart());
-            violations.push({
-              file: relativeSlashPath(root, file),
-              line: line + 1,
-              message: `${name}() blocks the event loop inside an async function — use the async equivalent from node:fs/promises.`,
-            });
-          }
-        }
-      });
-    }
-  },
-};

package/rules/no-unguarded-json-parse.ts

@@ -1,35 +0,0 @@
-import ts from "typescript";
-import { isInsideTry, walkAst } from "../core/ast";
-import { relativeSlashPath } from "../core/paths";
-import type { KlintRule } from "../core/types";
-
-export const noUnguardedJsonParse: KlintRule = {
-  meta: {
-    description:
-      "Flags `JSON.parse()` calls that aren't wrapped in try/catch — malformed input crashes the process.",
-    examples: ["no-unguarded-json-parse: error"],
-  },
-  check({ files, root, fileContents }, violations) {
-    for (const file of files) {
-      const content = fileContents.get(file) ?? "";
-      walkAst(file, content, (node, src) => {
-        if (
-          ts.isCallExpression(node) &&
-          ts.isPropertyAccessExpression(node.expression) &&
-          node.expression.name.text === "parse" &&
-          ts.isIdentifier(node.expression.expression) &&
-          node.expression.expression.text === "JSON" &&
-          !isInsideTry(node)
-        ) {
-          const { line } = src.getLineAndCharacterOfPosition(node.getStart());
-          violations.push({
-            file: relativeSlashPath(root, file),
-            line: line + 1,
-            message:
-              "JSON.parse() called without a surrounding try/catch — a malformed payload will throw an unhandled exception.",
-          });
-        }
-      });
-    }
-  },
-};

package/rules/prefer-at.ts

@@ -1,46 +0,0 @@
-import ts from "typescript";
-import { walkAst } from "../core/ast";
-import { relativeSlashPath } from "../core/paths";
-import { buildNodeReplacementFix } from "../core/rule-helpers";
-import type { KlintRule } from "../core/types";
-
-export const preferAt: KlintRule = {
-  meta: {
-    description:
-      "Flags negative-index access via `arr[arr.length - 1]` — `.at(-1)` reads cleaner for last-element access.",
-    examples: ["sonar/prefer-at: warn"],
-  },
-  check({ files, root, fileContents }, violations) {
-    for (const file of files) {
-      const content = fileContents.get(file) ?? "";
-      walkAst(file, content, (node, src) => {
-        // Match: base[base.length - n]
-        if (!ts.isElementAccessExpression(node)) return;
-
-        const arg = node.argumentExpression;
-        if (!ts.isBinaryExpression(arg)) return;
-        if (arg.operatorToken.kind !== ts.SyntaxKind.MinusToken) return;
-        if (!ts.isPropertyAccessExpression(arg.left)) return;
-        if (arg.left.name.text !== "length") return;
-        if (!ts.isNumericLiteral(arg.right)) return;
-
-        const n = Number(arg.right.text);
-        // n=0 changes semantics: arr[arr.length - 0] is undefined, arr.at(-0) is arr[0]
-        if (!Number.isInteger(n) || n <= 0) return;
-
-        const baseText = node.expression.getText(src);
-        if (baseText !== arg.left.expression.getText(src)) return;
-
-        const fixedCall = `${baseText}.at(-${n})`;
-        const fix = buildNodeReplacementFix(src, node, fixedCall);
-
-        violations.push({
-          file: relativeSlashPath(root, file),
-          line: fix.startLine,
-          message: `Prefer ${baseText}.at(-${n}) over ${baseText}[${baseText}.length - ${n}] for cleaner negative indexing.`,
-          fix,
-        });
-      });
-    }
-  },
-};

package/rules/prefer-nullish-coalescing-assign.ts

@@ -1,111 +0,0 @@
-import ts from "typescript";
-import { walkAst } from "../core/ast";
-import { relativeSlashPath } from "../core/paths";
-import type { KlintRule } from "../core/types";
-
-export const preferNullishCoalescingAssign: KlintRule = {
-  meta: {
-    description:
-      "Flags explicit nullish assignment guards — `x ??= y` is the dedicated nullish assignment operator.",
-    examples: ["sonar/prefer-nullish-coalescing-assign: warn"],
-  },
-  check({ files, root, fileContents }, violations) {
-    for (const file of files) {
-      const content = fileContents.get(file) ?? "";
-      walkAst(file, content, (node, src) => {
-        if (!ts.isIfStatement(node) || node.elseStatement !== undefined) return;
-
-        const assignExpr = extractAssignment(node.thenStatement);
-        if (!assignExpr) return;
-
-        const xText = nullishGuardTarget(node.expression, src);
-        if (!xText) return;
-        if (assignExpr.left.getText(src) !== xText) return;
-
-        const yText = assignExpr.right.getText(src);
-        const { line: s } = src.getLineAndCharacterOfPosition(node.getStart());
-        const { line: e } = src.getLineAndCharacterOfPosition(node.getEnd());
-        const indent = getIndent(src, node);
-
-        violations.push({
-          file: relativeSlashPath(root, file),
-          line: s + 1,
-          message: `Prefer \`${xText} ??= ${yText}\` over explicit nullish guard assignment — ??= only assigns when null or undefined.`,
-          fix: {
-            startLine: s + 1,
-            endLine: e + 1,
-            replacement: `${indent}${xText} ??= ${yText};`,
-          },
-        });
-      });
-    }
-  },
-};
-
-function extractAssignment(stmt: ts.Statement): ts.BinaryExpression | undefined {
-  if (ts.isExpressionStatement(stmt)) {
-    return isAssign(stmt.expression) ? stmt.expression : undefined;
-  }
-  if (ts.isBlock(stmt) && stmt.statements.length === 1) {
-    const inner = stmt.statements[0];
-    if (ts.isExpressionStatement(inner) && isAssign(inner.expression)) {
-      return inner.expression;
-    }
-  }
-  return undefined;
-}
-
-function isAssign(node: ts.Expression): node is ts.BinaryExpression {
-  return (
-    ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken
-  );
-}
-
-function nullishGuardTarget(
-  expression: ts.Expression,
-  src: ts.SourceFile
-): string | undefined {
-  if (!ts.isBinaryExpression(expression)) return undefined;
-
-  const direct = equalityNullishTarget(expression, src);
-  if (direct) return direct.target;
-
-  if (expression.operatorToken.kind !== ts.SyntaxKind.BarBarToken) return undefined;
-
-  const left = equalityNullishTarget(expression.left, src);
-  const right = equalityNullishTarget(expression.right, src);
-  if (!left || !right || left.target !== right.target) return undefined;
-
-  const values = new Set([left.value, right.value]);
-  if (values.has("null") && values.has("undefined")) return left.target;
-  return undefined;
-}
-
-function equalityNullishTarget(
-  expression: ts.Expression,
-  src: ts.SourceFile
-): { target: string; value: "null" | "undefined" } | undefined {
-  if (!ts.isBinaryExpression(expression)) return undefined;
-
-  const operator = expression.operatorToken.kind;
-  if (
-    operator !== ts.SyntaxKind.EqualsEqualsToken &&
-    operator !== ts.SyntaxKind.EqualsEqualsEqualsToken
-  )
-    return undefined;
-
-  const left = expression.left.getText(src);
-  const right = expression.right.getText(src);
-
-  if (right === "null") return { target: left, value: "null" };
-  if (right === "undefined") return { target: left, value: "undefined" };
-  if (left === "null") return { target: right, value: "null" };
-  if (left === "undefined") return { target: right, value: "undefined" };
-  return undefined;
-}
-
-function getIndent(src: ts.SourceFile, node: ts.Node): string {
-  const { line } = src.getLineAndCharacterOfPosition(node.getStart());
-  const lineStart = src.getPositionOfLineAndCharacter(line, 0);
-  return new RegExp(/^(\s*)/).exec(src.text.slice(lineStart, node.getStart()))?.[1] ?? "";
-}

package/rules/prefer-string-raw-regexp.ts

@@ -1,93 +0,0 @@
-import ts from "typescript";
-import { walkAst } from "../core/ast";
-import { relativeSlashPath } from "../core/paths";
-import type { KlintRule } from "../core/types";
-
-export const preferStringRawRegexp: KlintRule = {
-  meta: {
-    description:
-      "Flags regex literals built from escape-heavy string concatenation — `String.raw` drops the double backslashes.",
-    examples: ["sonar/prefer-string-raw-regexp: warn"],
-  },
-  check({ files, root, fileContents }, violations) {
-    for (const file of files) {
-      const content = fileContents.get(file) ?? "";
-      walkAst(file, content, (node, src) => {
-        if (
-          !ts.isNewExpression(node) ||
-          !ts.isIdentifier(node.expression) ||
-          node.expression.text !== "RegExp" ||
-          !node.arguments ||
-          node.arguments.length === 0
-        )
-          return;
-
-        const arg = node.arguments[0];
-        if (!ts.isNoSubstitutionTemplateLiteral(arg) && !ts.isTemplateExpression(arg))
-          return;
-
-        if (!hasDoubleBackslash(arg as ts.TemplateLiteral, src)) return;
-
-        const { line } = src.getLineAndCharacterOfPosition(node.getStart());
-        const { line: argStartLine } = src.getLineAndCharacterOfPosition(arg.getStart());
-        const { line: argEndLine } = src.getLineAndCharacterOfPosition(arg.getEnd());
-
-        const lineStarts = src.getLineStarts();
-        const lineStart = lineStarts[argStartLine];
-        const lineEnd =
-          argEndLine + 1 < lineStarts.length
-            ? lineStarts[argEndLine + 1] - 1
-            : src.text.length;
-        const linesText = src.text.slice(lineStart, lineEnd);
-
-        const argOffset = arg.getStart() - lineStart;
-        const argEndOffset = arg.getEnd() - lineStart;
-        const fixedArg = toStringRaw(arg as ts.TemplateLiteral, src);
-        const fixedLines =
-          linesText.slice(0, argOffset) + fixedArg + linesText.slice(argEndOffset);
-
-        violations.push({
-          file: relativeSlashPath(root, file),
-          line: line + 1,
-          message:
-            "Use String.raw`...` for RegExp template argument to avoid double backslashes (Sonar S7780).",
-          fix: {
-            startLine: argStartLine + 1,
-            endLine: argEndLine + 1,
-            replacement: fixedLines,
-          },
-        });
-      });
-    }
-  },
-};
-
-function hasDoubleBackslash(node: ts.TemplateLiteral, src: ts.SourceFile): boolean {
-  if (ts.isNoSubstitutionTemplateLiteral(node)) {
-    return node.getText(src).includes("\\\\");
-  }
-  if (node.head.getText(src).includes("\\\\")) return true;
-  for (const span of node.templateSpans) {
-    if (span.literal.getText(src).includes("\\\\")) return true;
-  }
-  return false;
-}
-
-function toStringRaw(node: ts.TemplateLiteral, src: ts.SourceFile): string {
-  if (ts.isNoSubstitutionTemplateLiteral(node)) {
-    const raw = node.getText(src);
-    const inner = raw.slice(1, -1);
-    return `String.raw\`${inner.replaceAll("\\\\", "\\")}\``;
-  }
-  let result = "String.raw`";
-  const headSrc = node.head.getText(src);
-  result += `${headSrc.slice(1, -2).replaceAll("\\\\", "\\")}\${`;
-  for (const span of node.templateSpans) {
-    result += span.expression.getText(src);
-    const litSrc = span.literal.getText(src);
-    const isMiddle = ts.isTemplateMiddle(span.literal);
-    const litContent = isMiddle ? litSrc.slice(1, -2) : litSrc.slice(1, -1);
-    result += `}${litContent.replaceAll("\\\\", "\\")}${isMiddle ? "${" : "`"}`;
-  }
-  return result;
-}

package/rules/prefer-string-raw.ts

@@ -1,39 +0,0 @@
-import ts from "typescript";
-import { walkAst } from "../core/ast";
-import { relativeSlashPath } from "../core/paths";
-import { buildNodeReplacementFix } from "../core/rule-helpers";
-import type { KlintRule } from "../core/types";
-
-export const preferStringRaw: KlintRule = {
-  meta: {
-    description:
-      "Flags string literals with multiple backslash escapes — `String.raw` is more readable (Windows paths, regex source, etc.).",
-    examples: ["sonar/prefer-string-raw: warn"],
-  },
-  check({ files, root, fileContents }, violations) {
-    for (const file of files) {
-      const content = fileContents.get(file) ?? "";
-      walkAst(file, content, (node, src) => {
-        if (!ts.isStringLiteral(node)) return;
-
-        const sourceText = node.getText(src);
-        if (!sourceText.includes("\\\\")) return;
-
-        const value = node.text;
-        // Can't embed backtick, ${ (would start interpolation), or trailing \ (would escape closing backtick)
-        if (value.includes("`") || value.includes("${") || value.endsWith("\\")) return;
-
-        const fixedNode = `String.raw\`${value}\``;
-        const fix = buildNodeReplacementFix(src, node, fixedNode);
-
-        violations.push({
-          file: relativeSlashPath(root, file),
-          line: fix.startLine,
-          message:
-            "String literal with escaped backslashes — use String.raw`...` for clarity (Sonar S6535).",
-          fix,
-        });
-      });
-    }
-  },
-};

package/rules/prefer-string-replaceall.ts

@@ -1,67 +0,0 @@
-import ts from "typescript";
-import { walkAst } from "../core/ast";
-import { relativeSlashPath } from "../core/paths";
-import { buildNodeReplacementFix } from "../core/rule-helpers";
-import type { KlintRule } from "../core/types";
-
-export const preferStringReplaceall: KlintRule = {
-  meta: {
-    description:
-      "Flags `.replace(/x/g, y)` on strings — `.replaceAll('x', y)` is clearer and faster for all-occurrence replacements.",
-    examples: ["sonar/prefer-string-replaceall: error"],
-  },
-  check({ files, root, fileContents }, violations) {
-    for (const file of files) {
-      const content = fileContents.get(file) ?? "";
-      walkAst(file, content, (node, src) => {
-        if (
-          !ts.isCallExpression(node) ||
-          !ts.isPropertyAccessExpression(node.expression) ||
-          node.expression.name.text !== "replace" ||
-          node.arguments.length !== 2 ||
-          !ts.isRegularExpressionLiteral(node.arguments[0])
-        )
-          return;
-
-        const regexSrc = node.arguments[0].getText(src);
-        const flags = extractFlags(regexSrc);
-        const pattern = extractPattern(regexSrc);
-
-        if (flags !== "g") return;
-        if (!isPlainLiteral(pattern)) return;
-
-        const strText = (
-          node.expression as ts.PropertyAccessExpression
-        ).expression.getText(src);
-        const replacementText = node.arguments[1].getText(src);
-        const patternLit = pattern.includes('"')
-          ? `'${pattern.replaceAll("'", String.raw`\'`)}'`
-          : `"${pattern}"`;
-        const fixedCall = `${strText}.replaceAll(${patternLit}, ${replacementText})`;
-        const fix = buildNodeReplacementFix(src, node, fixedCall);
-
-        violations.push({
-          file: relativeSlashPath(root, file),
-          line: fix.startLine,
-          message: `Prefer \`${strText}.replaceAll(${patternLit}, ...)\` over \`.replace(/${pattern}/g, ...)\` — replaceAll() with a string is clearer and avoids regex escaping pitfalls.`,
-          fix,
-        });
-      });
-    }
-  },
-};
-
-function extractFlags(literal: string): string {
-  const last = literal.lastIndexOf("/");
-  return last > 0 ? literal.slice(last + 1) : "";
-}
-
-function extractPattern(literal: string): string {
-  return literal.slice(1, literal.lastIndexOf("/"));
-}
-
-function isPlainLiteral(pattern: string): boolean {
-  // Strip escaped-backslash pairs (\\) before checking — \\ is a plain literal, not a metachar
-  const stripped = pattern.replaceAll("\\\\", "");
-  return !/[.*+?[\]{}()|^$\\]/.test(stripped);
-}