@pythonidaer/complexity-report 1.0.2

package/function-boundaries/arrow-jsx.js

@@ -0,0 +1,73 @@
+/**
+ * Arrow function end detection for JSX return and JSX attribute patterns.
+ */
+
+import { scanForJSXReturnClosingParens } from './arrow-helpers.js';
+
+/**
+ * Finds the end line for an arrow function returning JSX (=> ( ... ))
+ * @param {Array<string>} lines - Array of source code lines
+ * @param {number} startLine - Start line index (0-based)
+ * @param {number} arrowIndex - Index of => in the line
+ * @param {number} functionLine - Reported line number (1-based)
+ * @returns {{end: number, found: boolean}} End line (1-based) and whether end was found
+ */
+export function findArrowFunctionEndJSXReturn(
+  lines,
+  startLine,
+  arrowIndex,
+  functionLine
+) {
+  const line = lines[startLine];
+  const afterArrow = line.substring(arrowIndex + 2).trim();
+  if (!afterArrow.startsWith('(')) {
+    return { end: functionLine, found: false };
+  }
+  const arrowEndPos = arrowIndex + 2;
+  const parenPos = line.indexOf('(', arrowEndPos);
+  const scanIndex = parenPos + 1;
+  const endLine = scanForJSXReturnClosingParens(
+    lines,
+    startLine,
+    line,
+    scanIndex
+  );
+  if (endLine !== null) {
+    return { end: endLine, found: true };
+  }
+  return { end: functionLine, found: false };
+}
+
+/**
+ * Finds the end line for an arrow function inside JSX attribute
+ * (onChange={...})
+ * @param {Array<string>} lines - Array of source code lines
+ * @param {number} startLine - Start line index (0-based)
+ * @param {number} arrowIndex - Index of => in the line
+ * @param {number} functionLine - Reported line number (1-based)
+ * @returns {{end: number, found: boolean}} End line and whether found
+ */
+export function findArrowFunctionEndJSXAttribute(
+  lines,
+  startLine,
+  arrowIndex,
+  functionLine
+) {
+  const line = lines[startLine];
+  const isInJSXAttribute = line.includes('{') && line.indexOf('{') < arrowIndex;
+  if (!isInJSXAttribute) {
+    return { end: functionLine, found: false };
+  }
+  const afterArrow = line.substring(arrowIndex + 2);
+  let parenCount = 0;
+  for (let k = 0; k < afterArrow.length; k += 1) {
+    if (afterArrow[k] === '(') parenCount += 1;
+    else if (afterArrow[k] === ')') {
+      parenCount -= 1;
+      if (parenCount === 0) {
+        return { end: startLine + 1, found: true };
+      }
+    }
+  }
+  return { end: startLine + 1, found: true };
+}

package/function-boundaries/arrow-object-literal.js

@@ -0,0 +1,65 @@
+/**
+ * Arrow function end detection for object literal return (=> ({ ... })).
+ */
+
+/**
+ * Checks if a brace is part of an object literal pattern
+ * @param {string} line - Line content
+ * @param {number} arrowIndex - Index of => in the line
+ * @param {number} braceIndex - Index of { in the line
+ * @returns {boolean} True if object literal pattern
+ */
+export function isObjectLiteralPattern(line, arrowIndex, braceIndex) {
+  if (braceIndex === -1) return false;
+  const betweenArrowAndBrace = line.substring(arrowIndex + 2, braceIndex).trim();
+  return /^\(/.test(betweenArrowAndBrace) ||
+         (betweenArrowAndBrace === '' && braceIndex > 0 && line[braceIndex - 1] === '(');
+}
+
+/**
+ * Finds the closing paren of an object literal and checks if expression ends
+ * @param {string} line - Line content
+ * @param {number} braceIndex - Index of { in the line
+ * @returns {boolean} True if closing paren found and expression ends
+ */
+export function findObjectLiteralClosingParen(line, braceIndex) {
+  let parenCount = 1;
+  for (let k = braceIndex + 1; k < line.length; k += 1) {
+    if (line[k] === '(') parenCount += 1;
+    else if (line[k] === ')') {
+      parenCount -= 1;
+      if (parenCount === 0) {
+        const restOfLine = line.substring(k + 1).trim();
+        return restOfLine.startsWith(';') || restOfLine.startsWith(')') || restOfLine === '';
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Finds the end line for an arrow function returning object literal
+ * (=> ({ ... }))
+ * @param {Array<string>} lines - Array of source code lines
+ * @param {number} startLine - Start line index (0-based)
+ * @param {number} arrowIndex - Index of => in the line
+ * @param {number} braceIndex - Index of { in the line
+ * @param {number} functionLine - Reported line number (1-based)
+ * @returns {{end: number, found: boolean}} End line and whether found
+ */
+export function findArrowFunctionEndObjectLiteral(
+  lines,
+  startLine,
+  arrowIndex,
+  braceIndex,
+  functionLine
+) {
+  const line = lines[startLine];
+  if (!isObjectLiteralPattern(line, arrowIndex, braceIndex)) {
+    return { end: functionLine, found: false };
+  }
+  if (findObjectLiteralClosingParen(line, braceIndex)) {
+    return { end: startLine + 1, found: true };
+  }
+  return { end: startLine + 1, found: true };
+}

package/function-boundaries/arrow-single-expr.js

@@ -0,0 +1,72 @@
+/**
+ * Arrow function end detection for single-expression bodies.
+ */
+
+/**
+ * Checks if arrow function ends on the same line
+ * @param {string} lineAfterArrow - Content after => on the line
+ * @returns {boolean} True if ends on same line
+ */
+export function endsOnSameLine(lineAfterArrow) {
+  return lineAfterArrow.includes(';') ||
+         lineAfterArrow.includes(',') ||
+         lineAfterArrow.includes(')');
+}
+
+/**
+ * Calculates initial paren depth before arrow function
+ * @param {string} lineBeforeArrow - Content before => on the line
+ * @returns {number} Initial paren depth
+ */
+export function calculateInitialParenDepth(lineBeforeArrow) {
+  const openParens = (lineBeforeArrow.match(/\(/g) || []).length;
+  const closeParens = (lineBeforeArrow.match(/\)/g) || []).length;
+  return openParens - closeParens;
+}
+
+/**
+ * Scans forward to find end of single-expression arrow function
+ * @param {Array<string>} lines - Array of source code lines
+ * @param {number} startLine - Start line index (0-based)
+ * @param {number} parenDepth - Initial paren depth
+ * @returns {number} End line number (1-based)
+ */
+export function scanForSingleExpressionEnd(lines, startLine, parenDepth) {
+  for (let j = startLine + 1; j < lines.length; j += 1) {
+    const scanLine = lines[j];
+    for (let k = 0; k < scanLine.length; k += 1) {
+      if (scanLine[k] === '(') parenDepth += 1;
+      else if (scanLine[k] === ')') {
+        parenDepth -= 1;
+        if (parenDepth <= 0) return j + 1;
+      }
+    }
+    if (scanLine.trim().match(/^[;},]/)) return j + 1;
+  }
+  return lines.length;
+}
+
+/**
+ * Finds the end line for a single-expression arrow function
+ * @param {Array<string>} lines - Array of source code lines
+ * @param {number} startLine - Start line index (0-based)
+ * @param {number} arrowIndex - Index of => in the line
+ * @param {number} _functionLine - Reported line number (1-based)
+ * @returns {{end: number, found: boolean}} End line (1-based) and whether end was found
+ */
+export function findArrowFunctionEndSingleExpression(
+  lines,
+  startLine,
+  arrowIndex,
+  _functionLine
+) {
+  const line = lines[startLine];
+  const lineAfterArrow = line.substring(arrowIndex + 2);
+  if (endsOnSameLine(lineAfterArrow)) {
+    return { end: startLine + 1, found: true };
+  }
+  const lineBeforeArrow = line.substring(0, arrowIndex);
+  const parenDepth = calculateInitialParenDepth(lineBeforeArrow);
+  const endLine = scanForSingleExpressionEnd(lines, startLine, parenDepth);
+  return { end: endLine, found: true };
+}

package/function-boundaries/brace-scanning.js

@@ -0,0 +1,151 @@
+/**
+ * Brace counting and function body end detection.
+ */
+
+import { processCharacterForBraces } from './parse-utils.js';
+
+/**
+ * Finds end line for dependency array pattern (}, [deps])
+ */
+export function findDependencyArrayEnd(lines, i) {
+  for (let k = i; k < Math.min(i + 3, lines.length); k += 1) {
+    if (lines[k].includes(']')) return k + 1;
+  }
+  return null;
+}
+
+/**
+ * Finds end line for setTimeout callback pattern (}, delay)
+ */
+export function findSetTimeoutCallbackEnd(lines, i, _functionLine) {
+  for (let k = i; k < Math.min(i + 3, lines.length); k += 1) {
+    const checkLine = lines[k];
+    if (checkLine.includes(')') && (checkLine.includes(';') || k === i + 1)) return k + 1;
+  }
+  return null;
+}
+
+/**
+ * Checks if closing brace is followed by dependency array or callback
+ */
+export function checkCallbackPatterns(line, i, lines) {
+  const firstBraceIndex = line.indexOf('}');
+  if (firstBraceIndex === -1) {
+    return { hasDependencyArray: false, hasCallbackParam: false };
+  }
+  const restOfLine = line.substring(firstBraceIndex);
+  const nextLine = i + 1 < lines.length ? lines[i + 1] : '';
+  const combined = restOfLine + ' ' + nextLine;
+  return {
+    hasDependencyArray: /}\s*,\s*\[/.test(combined),
+    hasCallbackParam: /}\s*,\s*\d+/.test(combined)
+  };
+}
+
+/**
+ * Handles function body end detection (when braces balance)
+ */
+export function handleFunctionBodyEnd(line, i, functionLine, lines) {
+  const { hasDependencyArray, hasCallbackParam } = checkCallbackPatterns(
+    line,
+    i,
+    lines
+  );
+  if (hasDependencyArray) return findDependencyArrayEnd(lines, i);
+  if (hasCallbackParam) return findSetTimeoutCallbackEnd(lines, i, functionLine);
+  return i + 1;
+}
+
+/**
+ * Checks if braces are balanced and function ends
+ */
+export function checkFunctionEnd(
+  updatedBraceCount,
+  closeBraces,
+  line,
+  i,
+  functionLine,
+  lines,
+  nodeType
+) {
+  if (updatedBraceCount === 0 && closeBraces > 0) {
+    if (nodeType === 'FunctionDeclaration') {
+      const { hasDependencyArray } = checkCallbackPatterns(line, i, lines);
+      if (hasDependencyArray) return null;
+    }
+    const trimmed = line.trim();
+    if (trimmed === '};' || trimmed.endsWith('};')) {
+      if (i > 0) {
+        const prevLines = lines.slice(Math.max(0, i - 10), i);
+        const hasAssignmentPattern = prevLines.some(prevLine =>
+          /^\s*(const|let|var)\s+\w+\s*=.*=>/.test(prevLine.trim())
+        );
+        if (hasAssignmentPattern) return i + 1;
+      }
+    }
+    const endLine = handleFunctionBodyEnd(line, i, functionLine, lines);
+    if (endLine !== null) return endLine;
+  }
+  return null;
+}
+
+/**
+ * Processes a line within function body
+ * (brace counting, comment/string/regex aware)
+ */
+export function processLineInFunctionBody(
+  line,
+  i,
+  functionLine,
+  braceCount,
+  lines,
+  nodeType
+) {
+  let openBraces = 0;
+  let closeBraces = 0;
+  let state = {
+    inRegex: false,
+    inString: false,
+    inSingleLineComment: false,
+    inMultiLineComment: false,
+    stringChar: null,
+    escapeNext: false
+  };
+
+  for (let j = 0; j < line.length; j += 1) {
+    const char = line[j];
+    const prevChar = j > 0 ? line[j - 1] : '';
+    const nextChar = j + 1 < line.length ? line[j + 1] : '';
+    const result = processCharacterForBraces(
+      char,
+      prevChar,
+      nextChar,
+      line,
+      j,
+      state,
+      openBraces,
+      closeBraces
+    );
+    openBraces = result.openBraces;
+    closeBraces = result.closeBraces;
+    state = result.state;
+    if (result.shouldBreak) break;
+    if (result.shouldContinue) {
+      if (result.skipNext) j += 1;
+      continue;
+    }
+  }
+
+  const updatedBraceCount = braceCount + openBraces - closeBraces;
+  const endLine = checkFunctionEnd(
+    updatedBraceCount,
+    closeBraces,
+    line,
+    i,
+    functionLine,
+    lines,
+    nodeType
+  );
+  if (endLine !== null) return { braceCount: updatedBraceCount, end: endLine };
+  return { braceCount: updatedBraceCount, end: null };
+}

package/function-boundaries/index.js

@@ -0,0 +1,67 @@
+/**
+ * Function boundaries module — finds start/end lines for each function.
+ * Main export: findFunctionBoundaries.
+ */
+
+import { findArrowFunctionStart } from './arrow-helpers.js';
+import { findArrowFunctionEnd } from './arrow-brace-body.js';
+import { findNamedFunctionStart, findNamedFunctionEnd, findFunctionEndFallback } from './named-helpers.js';
+
+/**
+ * Finds function boundaries (start and end lines) for each function
+ * @param {string} sourceCode - Full source code
+ * @param {Array} functions - Array of function objects with line numbers
+ * @returns {Map} Map of functionLine -> { start, end }
+ */
+export function findFunctionBoundaries(sourceCode, functions) {
+  const boundaries = new Map();
+  const lines = sourceCode.split('\n');
+
+  functions.forEach(func => {
+    const functionLine = func.line;
+    const nodeType = func.nodeType || 'FunctionDeclaration';
+
+    const start = nodeType === 'ArrowFunctionExpression'
+      ? findArrowFunctionStart(lines, functionLine)
+      : findNamedFunctionStart(lines, functionLine, func.functionName);
+
+    let end = functionLine;
+    let braceCount = 0;
+    let inFunctionBody = false;
+    let arrowFunctionEndSet = false;
+    let arrowFunctionHandled = false;
+
+    if (nodeType === 'ArrowFunctionExpression') {
+      const arrowResult = findArrowFunctionEnd(lines, start, functionLine, boundaries);
+      end = arrowResult.end;
+      arrowFunctionHandled = arrowResult.arrowFunctionHandled;
+      arrowFunctionEndSet = arrowResult.arrowFunctionEndSet;
+      inFunctionBody = arrowResult.inFunctionBody;
+      braceCount = arrowResult.braceCount;
+
+      if (arrowFunctionEndSet) return;
+    }
+
+    if (!arrowFunctionEndSet) {
+      end = findNamedFunctionEnd(
+        lines,
+        start,
+        functionLine,
+        arrowFunctionHandled,
+        inFunctionBody,
+        braceCount,
+        nodeType
+      );
+    }
+
+    if (end === functionLine || !inFunctionBody) {
+      end = findFunctionEndFallback(lines, start, functionLine);
+    }
+
+    if (!boundaries.has(functionLine)) {
+      boundaries.set(functionLine, { start, end });
+    }
+  });
+
+  return boundaries;
+}

package/function-boundaries/named-helpers.js

@@ -0,0 +1,227 @@
+/**
+ * Named function start/end and body detection helpers.
+ */
+
+import { processLineInFunctionBody } from './brace-scanning.js';
+
+/**
+ * Checks if a line matches function declaration pattern
+ */
+export function isFunctionDeclarationPattern(line) {
+  return /^\s*(?:export\s+)?function\s+\w+/.test(line) &&
+         line.includes('(') &&
+         line.includes('{') &&
+         !line.includes('=>');
+}
+
+/**
+ * Calculates initial brace count for function body
+ */
+export function calculateFunctionBodyBraceCount(line) {
+  const functionBodyBraceIndex = line.lastIndexOf('{');
+  if (functionBodyBraceIndex === -1) return 1;
+  const paramCloseIndex = line.lastIndexOf(')');
+  if (paramCloseIndex !== -1 && functionBodyBraceIndex > paramCloseIndex) {
+    const afterParams = line.substring(paramCloseIndex);
+    return (afterParams.match(/{/g) || []).length;
+  }
+  return (line.match(/{/g) || []).length;
+}
+
+/**
+ * Handles arrow function without braces case
+ */
+export function handleArrowFunctionWithoutBraces(lines, i) {
+  let j = i + 1;
+  while (j < lines.length && !lines[j].trim().match(/^[;}]/)) j += 1;
+  return j + 1;
+}
+
+/**
+ * Tracks type definition braces (before function body is found)
+ */
+export function trackTypeBraces(line, typeBraceCount) {
+  if (!line.includes('{')) return typeBraceCount;
+  const openBraces = (line.match(/{/g) || []).length;
+  const closeBraces = (line.match(/}/g) || []).length;
+  return typeBraceCount + openBraces - closeBraces;
+}
+
+/**
+ * Handles function body start detection
+ */
+export function handleFunctionBodyStart(line, i, lines) {
+  const hasFunctionBodyPattern = /\)\s*[:\w\s<>[\]|'"]*\s*\{/.test(line);
+  const isFunctionDeclaration = isFunctionDeclarationPattern(line);
+  const hasArrowFunction = line.includes('=>') && !line.includes('{');
+  if (hasFunctionBodyPattern || isFunctionDeclaration) {
+    return {
+      inFunctionBody: true,
+      braceCount: calculateFunctionBodyBraceCount(line),
+      end: null,
+    };
+  }
+  if (hasArrowFunction) {
+    return {
+      inFunctionBody: true,
+      braceCount: 0,
+      end: handleArrowFunctionWithoutBraces(lines, i),
+    };
+  }
+  return { inFunctionBody: false, braceCount: 0, end: null };
+}
+
+/**
+ * Handles processing a line before function body is found
+ */
+export function processLineBeforeFunctionBody(line, i, lines, typeBraceCount) {
+  const bodyStartResult = handleFunctionBodyStart(line, i, lines);
+  if (bodyStartResult.end !== null) {
+    return {
+      inFunctionBody: true,
+      braceCount: 0,
+      end: bodyStartResult.end,
+      typeBraceCount,
+    };
+  }
+  if (bodyStartResult.inFunctionBody) {
+    return {
+      inFunctionBody: true,
+      braceCount: bodyStartResult.braceCount,
+      end: null,
+      typeBraceCount,
+    };
+  }
+  return {
+    inFunctionBody: false,
+    braceCount: 0,
+    end: null,
+    typeBraceCount: trackTypeBraces(line, typeBraceCount)
+  };
+}
+
+/**
+ * Checks if a line contains the function body pattern
+ */
+export function hasFunctionBodyPattern(line) {
+  return /\)\s*[:\w\s<>[\]|'"]*\s*\{/.test(line);
+}
+
+/**
+ * Scans lines to find function end using brace counting
+ */
+export function scanForFunctionEndWithBraces(lines, start, functionLine) {
+  let fallbackBraceCount = 0;
+  let foundFunctionBody = false;
+  for (let i = start - 1; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (!foundFunctionBody && hasFunctionBodyPattern(line)) {
+      foundFunctionBody = true;
+      const result = processLineInFunctionBody(
+        line,
+        i,
+        functionLine,
+        0,
+        lines,
+        undefined
+      );
+      fallbackBraceCount = result.braceCount;
+    } else if (foundFunctionBody) {
+      const result = processLineInFunctionBody(
+        line,
+        i,
+        functionLine,
+        fallbackBraceCount,
+        lines,
+        undefined
+      );
+      fallbackBraceCount = result.braceCount;
+      if (fallbackBraceCount === 0 && result.end !== null) {
+        return result.end;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Fallback logic to find function end when normal detection fails
+ */
+export function findFunctionEndFallback(lines, start, functionLine) {
+  const end = scanForFunctionEndWithBraces(lines, start, functionLine);
+  if (end !== null) return end;
+  return Math.min(start + 500, lines.length);
+}
+
+/**
+ * Finds the end line for a named function by tracking braces
+ */
+export function findNamedFunctionEnd(
+  lines,
+  start,
+  functionLine,
+  arrowFunctionHandled,
+  inFunctionBody,
+  braceCount,
+  nodeType
+) {
+  let end = functionLine;
+  let typeBraceCount = 0;
+  const loopStart = start - 1;
+  const skipFirstLine = (arrowFunctionHandled && inFunctionBody);
+
+  for (let i = loopStart; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (!inFunctionBody) {
+      const result = processLineBeforeFunctionBody(line, i, lines, typeBraceCount);
+      if (result.end !== null) return result.end;
+      if (result.inFunctionBody) {
+        inFunctionBody = true;
+        braceCount = result.braceCount;
+        typeBraceCount = result.typeBraceCount;
+        continue;
+      }
+      typeBraceCount = result.typeBraceCount;
+    } else {
+      if (skipFirstLine && i + 1 === start) continue;
+      const result = processLineInFunctionBody(
+        line,
+        i,
+        functionLine,
+        braceCount,
+        lines,
+        nodeType
+      );
+      if (result.end !== null) return result.end;
+      braceCount = result.braceCount;
+    }
+  }
+  return end;
+}
+
+/**
+ * Finds the start line for a named function
+ */
+export function findNamedFunctionStart(lines, functionLine, functionName) {
+  const startLine = Math.max(0, functionLine - 50);
+  const patterns = [
+    /(?:export\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[<(]/,
+    /const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:\([^)]*\)\s*)?(?:=>|function)/,
+    /export\s+const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:\([^)]*\)\s*)?(?:=>|function)/,
+    /export\s+default\s+function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[<(]/,
+    /(?:export\s+default\s+|const\s+)([A-Z][a-zA-Z0-9_$]*)\s*[:=]\s*(?:\([^)]*\)\s*)?=>/,
+  ];
+  let start = functionLine;
+  for (let i = functionLine - 1; i >= startLine; i -= 1) {
+    const line = lines[i];
+    for (const pattern of patterns) {
+      const match = line.match(pattern);
+      if (match && match[1] === functionName) {
+        start = i + 1;
+        break;
+      }
+    }
+    if (start !== functionLine) break;
+  }
+  return start;
+}