@pythonidaer/complexity-report 1.0.2

package/export-generators/txt-exports.js

@@ -0,0 +1,262 @@
+import { buildHierarchicalFunctionName, groupFunctionsByFolder } from './helpers.js';
+import { getDirectory } from '../function-extraction/index.js';
+
+/**
+ * Generates TXT export for all functions including callbacks (alphabetically)
+ * @param {Array} allFunctions - All functions array
+ * @param {Map} fileBoundariesMap - Map of filePath -> Map of line -> boundary
+ * @param {Map} fileToFunctions - Map of filePath -> functions array
+ * @returns {string} TXT string
+ */
+export function generateAllFunctionsTXT(
+  allFunctions,
+  fileBoundariesMap,
+  fileToFunctions
+) {
+  // Build hierarchical names for all functions using file-specific boundaries
+  const functionsWithHierarchy = allFunctions.map(func => {
+    const fileBoundaries = fileBoundariesMap.get(func.file) || new Map();
+    const fileFunctions = fileToFunctions.get(func.file) || [];
+    return {
+      ...func,
+      hierarchicalName: buildHierarchicalFunctionName(
+        func,
+        fileBoundaries,
+        fileFunctions
+      ),
+    };
+  });
+  
+  // Sort alphabetically by hierarchical name
+  functionsWithHierarchy.sort((a, b) => {
+    const nameA = (a.hierarchicalName || 'unknown').toLowerCase();
+    const nameB = (b.hierarchicalName || 'unknown').toLowerCase();
+    return nameA.localeCompare(nameB);
+  });
+  
+  const lines = [
+    'All Functions Including Callbacks (Alphabetical)',
+    '=================================================',
+    '',
+    `Total: ${functionsWithHierarchy.length} functions`,
+    `Generated: ${new Date().toISOString()}`,
+    '',
+    ...functionsWithHierarchy.map(func => func.hierarchicalName),
+  ];
+  
+  return lines.join('\n');
+}
+
+/**
+ * Returns the leaf (innermost) part of a hierarchical name.
+ * e.g. "AgencyLogosComponent → useEffect → map" → "map"; "TopLevel" → "TopLevel"
+ * @param {string} hierarchicalName - Full name possibly with " → " segments
+ * @returns {string}
+ */
+function getLeafNameFromHierarchy(hierarchicalName) {
+  if (!hierarchicalName || typeof hierarchicalName !== 'string') {
+    return hierarchicalName || '';
+  }
+  const idx = hierarchicalName.lastIndexOf(' → ');
+  return idx === -1
+    ? hierarchicalName.trim()
+    : hierarchicalName.slice(idx + 3).trim();
+}
+
+/**
+ * Generates TXT export for all functions with leaf names only
+ * (e.g. "map" instead of "Component → map")
+ * @param {Array} allFunctions - All functions array
+ * @param {Map} fileBoundariesMap - Map of filePath -> Map
+ * @param {Map} fileToFunctions - Map of filePath -> functions array
+ * @returns {string} TXT string
+ */
+export function generateAllFunctionsLeafOnlyTXT(
+  allFunctions,
+  fileBoundariesMap,
+  fileToFunctions
+) {
+  const functionsWithHierarchy = allFunctions.map(func => {
+    const fileBoundaries = fileBoundariesMap.get(func.file) || new Map();
+    const fileFunctions = fileToFunctions.get(func.file) || [];
+    return {
+      ...func,
+      hierarchicalName: buildHierarchicalFunctionName(
+        func,
+        fileBoundaries,
+        fileFunctions
+      ),
+    };
+  });
+  functionsWithHierarchy.sort((a, b) => {
+    const leafA = getLeafNameFromHierarchy(
+      a.hierarchicalName || 'unknown'
+    ).toLowerCase();
+    const leafB = getLeafNameFromHierarchy(
+      b.hierarchicalName || 'unknown'
+    ).toLowerCase();
+    return leafA.localeCompare(leafB);
+  });
+  const lines = [
+    'All Functions — Leaf Names Only (Alphabetical)',
+    '==============================================',
+    '',
+    `Total: ${functionsWithHierarchy.length} functions`,
+    `Generated: ${new Date().toISOString()}`,
+    '',
+    ...functionsWithHierarchy.map((func) =>
+      getLeafNameFromHierarchy(func.hierarchicalName)
+    ),
+  ];
+  return lines.join('\n');
+}
+
+/**
+ * Generates TXT export for functions organized by folder/file
+ * @param {Array} allFunctions - All functions array
+ * @param {Map} fileBoundariesMap - Map of filePath -> Map of line -> boundary
+ * @param {Map} fileToFunctions - Map of filePath -> functions array
+ * @returns {string} TXT string
+ */
+export function generateFunctionsByFolderTXT(
+  allFunctions,
+  fileBoundariesMap,
+  fileToFunctions
+) {
+  const folderMap = groupFunctionsByFolder(allFunctions, getDirectory);
+  
+  const lines = [
+    'Functions by Folder/File',
+    '=======================',
+    '',
+    `Total folders: ${folderMap.size}`,
+    `Total functions: ${allFunctions.length}`,
+    `Generated: ${new Date().toISOString()}`,
+    '',
+  ];
+  
+  // Sort folders alphabetically
+  const sortedFolders = Array.from(folderMap.entries()).sort((a, b) =>
+    a[0].localeCompare(b[0])
+  );
+  
+  for (const [folder, fileMap] of sortedFolders) {
+    lines.push(`\n${folder}/`);
+    lines.push('─'.repeat(folder.length + 1));
+    
+    // Sort files alphabetically
+    const sortedFiles = Array.from(fileMap.entries()).sort((a, b) =>
+      a[0].localeCompare(b[0])
+    );
+    
+    for (const [file, functions] of sortedFiles) {
+      const fileName = file.split('/').pop();
+      lines.push(`\n  ${fileName}`);
+      
+      // Get file-specific boundaries and functions
+      const fileBoundaries = fileBoundariesMap.get(file) || new Map();
+      const fileFunctions = fileToFunctions.get(file) || [];
+      
+      // Build hierarchical names and sort alphabetically
+      const functionsWithHierarchy = functions.map(func => ({
+        ...func,
+        hierarchicalName: buildHierarchicalFunctionName(
+          func,
+          fileBoundaries,
+          fileFunctions
+        ),
+      })).sort((a, b) => {
+        const nameA = (a.hierarchicalName || 'unknown').toLowerCase();
+        const nameB = (b.hierarchicalName || 'unknown').toLowerCase();
+        return nameA.localeCompare(nameB);
+      });
+      
+      for (const func of functionsWithHierarchy) {
+        lines.push(`    - ${func.hierarchicalName}`);
+      }
+    }
+  }
+  
+  return lines.join('\n');
+}
+
+/**
+ * Generates TXT export for functions by folder/file with leaf names only
+ * @param {Array} allFunctions - All functions array
+ * @param {Map} fileBoundariesMap - Map of filePath -> Map
+ * @param {Map} fileToFunctions - Map of filePath -> functions array
+ * @returns {string} TXT string
+ */
+export function generateFunctionsByFolderLeafOnlyTXT(
+  allFunctions,
+  fileBoundariesMap,
+  fileToFunctions
+) {
+  const folderMap = groupFunctionsByFolder(allFunctions, getDirectory);
+  const lines = [
+    'Functions by Folder/File — Leaf Names Only',
+    '============================================',
+    '',
+    `Total folders: ${folderMap.size}`,
+    `Total functions: ${allFunctions.length}`,
+    `Generated: ${new Date().toISOString()}`,
+    '',
+  ];
+  const sortedFolders = Array.from(folderMap.entries()).sort((a, b) =>
+    a[0].localeCompare(b[0])
+  );
+  for (const [folder, fileMap] of sortedFolders) {
+    lines.push(`\n${folder}/`);
+    lines.push('─'.repeat(folder.length + 1));
+    const sortedFiles = Array.from(fileMap.entries()).sort((a, b) =>
+      a[0].localeCompare(b[0])
+    );
+    for (const [file, functions] of sortedFiles) {
+      const fileName = file.split('/').pop();
+      lines.push(`\n  ${fileName}`);
+      const fileBoundaries = fileBoundariesMap.get(file) || new Map();
+      const fileFunctions = fileToFunctions.get(file) || [];
+      const functionsWithHierarchy = functions.map(func => ({
+        ...func,
+        hierarchicalName: buildHierarchicalFunctionName(
+          func,
+          fileBoundaries,
+          fileFunctions
+        ),
+      })).sort((a, b) => {
+        const leafA = getLeafNameFromHierarchy(
+          a.hierarchicalName || 'unknown'
+        ).toLowerCase();
+        const leafB = getLeafNameFromHierarchy(
+          b.hierarchicalName || 'unknown'
+        ).toLowerCase();
+        return leafA.localeCompare(leafB);
+      });
+      for (const func of functionsWithHierarchy) {
+        lines.push(`    - ${getLeafNameFromHierarchy(func.hierarchicalName)}`);
+      }
+    }
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Generates TXT export of all file names (paths) in alphabetical order
+ * @param {Map} fileToFunctions - Map of filePath -> functions array
+ * @returns {string} TXT string
+ */
+export function generateFileNamesAlphabeticalTXT(fileToFunctions) {
+  const sortedFiles = Array.from(fileToFunctions.keys()).sort((a, b) =>
+    a.localeCompare(b)
+  );
+  const lines = [
+    'File Names (Alphabetical)',
+    '=========================',
+    '',
+    `Total files: ${sortedFiles.length}`,
+    `Generated: ${new Date().toISOString()}`,
+    '',
+    ...sortedFiles,
+  ];
+  return lines.join('\n');
+}

package/function-boundaries/arrow-brace-body.js

@@ -0,0 +1,302 @@
+/**
+ * Arrow function end detection: brace body and main dispatcher.
+ */
+
+import { findArrowFunctionEndJSXReturn } from './arrow-jsx.js';
+import { findArrowFunctionEndJSXAttribute } from './arrow-jsx.js';
+import { findArrowFunctionEndObjectLiteral } from './arrow-object-literal.js';
+import { findArrowFunctionEndSingleExpression } from './arrow-single-expr.js';
+
+/**
+ * Handles arrow function with JSX return pattern
+ * @param {Array<string>} lines - Array of source code lines
+ * @param {number} i - Current line index
+ * @param {number} arrowIndex - Index of => in the line
+ * @param {number} functionLine - Reported line number (1-based)
+ * @param {Map} boundaries - Map to store boundaries
+ * @returns {{end, found, arrowFunctionHandled, arrowFunctionEndSet}|null}
+ */
+export function handleJSXReturnPattern(
+  lines,
+  i,
+  arrowIndex,
+  functionLine,
+  boundaries
+) {
+  const jsxResult = findArrowFunctionEndJSXReturn(
+    lines,
+    i,
+    arrowIndex,
+    functionLine
+  );
+  if (jsxResult.found) {
+    boundaries.set(functionLine, { start: i + 1, end: jsxResult.end });
+    return {
+      end: jsxResult.end,
+      found: true,
+      arrowFunctionHandled: true,
+      arrowFunctionEndSet: true
+    };
+  }
+  return null;
+}
+
+/**
+ * Checks if arrow function body is a single-line brace body
+ * with balanced braces. Example: .forEach((item) => { doSomething(); });
+ * @param {string} line - Current line content
+ * @param {number} arrowIndex - Index of => in the line
+ * @returns {boolean} True if single-line brace body with balanced braces
+ */
+function isSingleLineBraceBody(line, arrowIndex) {
+  const afterArrow = line.substring(arrowIndex + 2);
+  const openBraces = (afterArrow.match(/{/g) || []).length;
+  const closeBraces = (afterArrow.match(/}/g) || []).length;
+  
+  // Must have at least one brace, and braces must balance
+  if (openBraces === 0 || openBraces !== closeBraces) {
+    return false;
+  }
+  
+  // Check for common single-line patterns:
+  // - Ends with }); (callback in method call)
+  // - Ends with }; (arrow function assignment)
+  // - Ends with }) (callback without semicolon)
+  const trimmed = afterArrow.trim();
+  return (
+    trimmed.endsWith('});') ||
+    trimmed.endsWith('};') ||
+    trimmed.endsWith('})')
+  );
+}
+
+/**
+ * Handles arrow function with brace on same line
+ * @param {Array<string>} lines - Array of source code lines
+ * @param {number} i - Current line index
+ * @param {number} arrowIndex - Index of => in the line
+ * @param {number} functionLine - Reported line number (1-based)
+ * @param {Map} boundaries - Map to store boundaries
+ * @param {string} line - Current line content
+ * @returns {{end, found, arrowFunctionHandled, arrowFunctionEndSet,
+ *   inFunctionBody, braceCount}|null} Result or null
+ */
+export function handleBraceOnSameLine(
+  lines,
+  i,
+  arrowIndex,
+  functionLine,
+  boundaries,
+  line
+) {
+  const braceIndex = line.indexOf('{', arrowIndex);
+  if (braceIndex === -1) {
+    const jsxAttrResult = findArrowFunctionEndJSXAttribute(
+      lines,
+      i,
+      arrowIndex,
+      functionLine
+    );
+    if (jsxAttrResult.found) {
+      boundaries.set(functionLine, { start: i + 1, end: jsxAttrResult.end });
+      return {
+        end: jsxAttrResult.end,
+        found: true,
+        arrowFunctionHandled: true,
+        arrowFunctionEndSet: true,
+        inFunctionBody: false,
+        braceCount: 0
+      };
+    }
+    return null;
+  }
+  
+  // CRITICAL FIX: Check if this is a single-line arrow function
+  // with balanced braces. This prevents sibling callbacks from being
+  // treated as nested. Example: .forEach((type) => { total += x; });
+  if (isSingleLineBraceBody(line, arrowIndex)) {
+    boundaries.set(functionLine, { start: i + 1, end: i + 1 });
+    return {
+      end: i + 1,
+      found: true,
+      arrowFunctionHandled: true,
+      arrowFunctionEndSet: true,
+      inFunctionBody: false,
+      braceCount: 0
+    };
+  }
+  
+  const objLiteralResult = findArrowFunctionEndObjectLiteral(
+    lines,
+    i,
+    arrowIndex,
+    braceIndex,
+    functionLine
+  );
+  if (objLiteralResult.found) {
+    boundaries.set(functionLine, { start: i + 1, end: objLiteralResult.end });
+    return {
+      end: objLiteralResult.end,
+      found: true,
+      arrowFunctionHandled: true,
+      arrowFunctionEndSet: true,
+      inFunctionBody: false,
+      braceCount: 0
+    };
+  }
+  const openBraces = (line.match(/{/g) || []).length;
+  return {
+    end: functionLine,
+    found: false,
+    arrowFunctionHandled: true,
+    arrowFunctionEndSet: false,
+    inFunctionBody: true,
+    braceCount: openBraces
+  };
+}
+
+/**
+ * Handles arrow function without brace on same line
+ * @param {Array<string>} lines - Array of source code lines
+ * @param {number} i - Current line index
+ * @param {number} arrowIndex - Index of => in the line
+ * @param {number} functionLine - Reported line number (1-based)
+ * @param {Map} boundaries - Map to store boundaries
+ * @returns {{end, found, arrowFunctionHandled, arrowFunctionEndSet,
+ *   inFunctionBody, braceCount}} Result
+ */
+export function handleNoBraceOnSameLine(
+  lines,
+  i,
+  arrowIndex,
+  functionLine,
+  boundaries
+) {
+  if (i + 1 < lines.length && lines[i + 1].trim().startsWith('{')) {
+    return {
+      end: functionLine,
+      found: false,
+      arrowFunctionHandled: true,
+      arrowFunctionEndSet: false,
+      inFunctionBody: true,
+      braceCount: 1
+    };
+  }
+  const jsxAttrResult = findArrowFunctionEndJSXAttribute(
+    lines,
+    i,
+    arrowIndex,
+    functionLine
+  );
+  if (jsxAttrResult.found) {
+    boundaries.set(functionLine, { start: i + 1, end: jsxAttrResult.end });
+    return {
+      end: jsxAttrResult.end,
+      found: true,
+      arrowFunctionHandled: true,
+      arrowFunctionEndSet: false,
+      inFunctionBody: false,
+      braceCount: 0
+    };
+  }
+  const singleExprResult = findArrowFunctionEndSingleExpression(
+    lines,
+    i,
+    arrowIndex,
+    functionLine
+  );
+  if (singleExprResult.found) {
+    boundaries.set(functionLine, { start: i + 1, end: singleExprResult.end });
+    return {
+      end: singleExprResult.end,
+      found: true,
+      arrowFunctionHandled: true,
+      arrowFunctionEndSet: false,
+      inFunctionBody: false,
+      braceCount: 0
+    };
+  }
+  return {
+    end: functionLine,
+    found: false,
+    arrowFunctionHandled: false,
+    arrowFunctionEndSet: false,
+    inFunctionBody: false,
+    braceCount: 0
+  };
+}
+
+/**
+ * Finds the end line for an arrow function (main dispatcher)
+ * @param {Array<string>} lines - Array of source code lines
+ * @param {number} start - Start line number (1-based)
+ * @param {number} functionLine - Reported line number (1-based)
+ * @param {Map} boundaries - Map to store boundaries
+ * @returns {{end, found, arrowFunctionHandled, arrowFunctionEndSet,
+ *   inFunctionBody, braceCount}} Result object
+ */
+export function findArrowFunctionEnd(
+  lines,
+  start,
+  functionLine,
+  boundaries
+) {
+  let end = functionLine;
+  let arrowFunctionHandled = false;
+  let arrowFunctionEndSet = false;
+  let inFunctionBody = false;
+  let braceCount = 0;
+
+  for (let i = start - 1; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (line.includes('=>')) {
+      const arrowIndex = line.indexOf('=>');
+      const afterArrow = line.substring(arrowIndex + 2).trim();
+
+      if (afterArrow.startsWith('(')) {
+        const jsxResult = handleJSXReturnPattern(
+          lines,
+          i,
+          arrowIndex,
+          functionLine,
+          boundaries
+        );
+        if (jsxResult) {
+          return { ...jsxResult, inFunctionBody, braceCount };
+        }
+      }
+
+      if (line.includes('{')) {
+        const braceResult = handleBraceOnSameLine(
+          lines,
+          i,
+          arrowIndex,
+          functionLine,
+          boundaries,
+          line
+        );
+        if (braceResult) {
+          return braceResult;
+        }
+      } else {
+        return handleNoBraceOnSameLine(
+          lines,
+          i,
+          arrowIndex,
+          functionLine,
+          boundaries
+        );
+      }
+      break;
+    }
+  }
+
+  return {
+    end,
+    found: false,
+    arrowFunctionHandled,
+    arrowFunctionEndSet,
+    inFunctionBody,
+    braceCount,
+  };
+}

package/function-boundaries/arrow-helpers.js

@@ -0,0 +1,93 @@
+/**
+ * Arrow function start and JSX return closing pattern helpers.
+ */
+
+/**
+ * Finds the start line for an arrow function (multi-line arrow declarations).
+ * For multi-line arrows (e.g. const fn = (\n  a,\n  b\n) => {),
+ * returns the line where declaration starts (e.g. "const fn = ("),
+ * so the whole declaration can be highlighted, not just the "=>" line.
+ * @param {Array<string>} lines - Array of source code lines
+ * @param {number} functionLine - Reported line (1-based), typically "=>"
+ * @returns {number} Start line number (1-based)
+ */
+export function findArrowFunctionStart(lines, functionLine) {
+  const lineIndex = functionLine - 1;
+  if (lineIndex < 0 || lineIndex >= lines.length) return functionLine;
+
+  const arrowLine = lines[lineIndex];
+  const hasArrow = arrowLine && arrowLine.includes('=>');
+  // Default: start on the line that has "=>"
+  let start = functionLine;
+
+  if (hasArrow) {
+    start = lineIndex + 1;
+    // Walk backward to find declaration start: first line with
+    // "= (" or "=(" (assignment to open paren).
+    // Stop when we hit a line containing "=>" so we don't attribute
+    // another function's declaration to this arrow.
+    for (let i = lineIndex - 1; i >= 0; i -= 1) {
+      const line = lines[i];
+      if (!line) continue;
+      if (line.includes('=>')) break;
+      if (/=\s*\(/.test(line)) {
+        start = i + 1;
+        break;
+      }
+    }
+  }
+
+  return start;
+}
+
+/**
+ * Checks if a closing paren matches the JSX return pattern ()) or )} followed by )
+ * @param {string} scanLine - Current line being scanned
+ * @param {number} k - Index of closing paren
+ * @param {number} j - Current line index
+ * @param {Array<string>} lines - All lines
+ * @returns {number|null} End line number if pattern matches, null otherwise
+ */
+export function checkJSXReturnClosingPattern(scanLine, k, j, lines) {
+  const nextChar = k + 1 < scanLine.length ? scanLine[k + 1] : '';
+  if (nextChar === ')') {
+    return j + 1;
+  }
+  if (nextChar === '}' && j + 1 < lines.length) {
+    const nextLine = lines[j + 1];
+    if (nextLine.trim().startsWith(')')) {
+      return j + 2;
+    }
+  }
+  return null;
+}
+
+/**
+ * Scans lines to find matching closing parens for JSX return pattern
+ * @param {Array<string>} lines - Array of source code lines
+ * @param {number} startLine - Start line index (0-based)
+ * @param {string} line - First line content
+ * @param {number} scanIndex - Starting character index
+ * @returns {number|null} End line number if found, null otherwise
+ */
+export function scanForJSXReturnClosingParens(lines, startLine, line, scanIndex) {
+  let parenCount = 1;
+  for (let j = startLine; j < lines.length && j < startLine + 50; j += 1) {
+    const scanLine = j === startLine ? line.substring(scanIndex) : lines[j];
+    for (let k = 0; k < scanLine.length; k += 1) {
+      const char = scanLine[k];
+      if (char === '(') {
+        parenCount += 1;
+      } else if (char === ')') {
+        parenCount -= 1;
+        if (parenCount === 0) {
+          const endLine = checkJSXReturnClosingPattern(scanLine, k, j, lines);
+          if (endLine !== null) {
+            return endLine;
+          }
+        }
+      }
+    }
+  }
+  return null;
+}