Fallback.tsx

Full source

import { c as _c } from "react/compiler-runtime";
import { diffWordsWithSpace, type StructuredPatchHunk } from 'diff';
import * as React from 'react';
import { useMemo } from 'react';
import type { ThemeName } from 'src/utils/theme.js';
import { stringWidth } from '../../ink/stringWidth.js';
import { Box, NoSelect, Text, useTheme, wrapText } from '../../ink.js';

/*
 * StructuredDiffFallback Component: Word-Level Diff Highlighting Example
 *
 * This component shows diff changes with word-level highlighting. Here's a walkthrough:
 *
 * Example:
 * ```
 * // Original code
 * function oldName(param) {
 *   return param.oldProperty;
 * }
 *
 * // Changed code
 * function newName(param) {
 *   return param.newProperty;
 * }
 * ```
 *
 * Processing flow:
 * 1. Component receives a patch with lines including '+' and '-' prefixes
 * 2. Lines are transformed into objects with type (add/remove/nochange)
 * 3. Related add/remove lines are paired (e.g., oldName with newName)
 * 4. Word-level diffing identifies specific changed parts:
 *    [
 *      { value: 'function ', added: undefined, removed: undefined },  // Common
 *      { value: 'oldName', removed: true },                           // Removed
 *      { value: 'newName', added: true },                             // Added
 *      { value: '(param) {', added: undefined, removed: undefined }   // Common
 *    ]
 * 5. Renders with enhanced highlighting:
 *    - Common parts are shown normally
 *    - Removed words get a darker red background
 *    - Added words get a darker green background
 *
 * This produces a visually clear diff where users can see exactly which words
 * changed rather than just which lines were modified.
 */

// Define DiffLine interface to be used throughout the file
interface DiffLine {
  code: string;
  type: 'add' | 'remove' | 'nochange';
  i: number;
  originalCode: string;
  wordDiff?: boolean; // Flag for word-level diffing
  matchedLine?: DiffLine;
}

// Line object type for internal functions
export interface LineObject {
  code: string;
  i: number;
  type: 'add' | 'remove' | 'nochange';
  originalCode: string;
  wordDiff?: boolean;
  matchedLine?: LineObject;
}

// Type for word-level diff parts
interface DiffPart {
  added?: boolean;
  removed?: boolean;
  value: string;
}
type Props = {
  patch: StructuredPatchHunk;
  dim: boolean;
  width: number;
};

// Threshold for when we show a full-line diff instead of word-level diffing
const CHANGE_THRESHOLD = 0.4;
export function StructuredDiffFallback(t0) {
  const $ = _c(10);
  const {
    patch,
    dim,
    width
  } = t0;
  const [theme] = useTheme();
  let t1;
  if ($[0] !== dim || $[1] !== patch.lines || $[2] !== patch.oldStart || $[3] !== theme || $[4] !== width) {
    t1 = formatDiff(patch.lines, patch.oldStart, width, dim, theme);
    $[0] = dim;
    $[1] = patch.lines;
    $[2] = patch.oldStart;
    $[3] = theme;
    $[4] = width;
    $[5] = t1;
  } else {
    t1 = $[5];
  }
  const diff = t1;
  let t2;
  if ($[6] !== diff) {
    t2 = diff.map(_temp);
    $[6] = diff;
    $[7] = t2;
  } else {
    t2 = $[7];
  }
  let t3;
  if ($[8] !== t2) {
    t3 = <Box flexDirection="column" flexGrow={1}>{t2}</Box>;
    $[8] = t2;
    $[9] = t3;
  } else {
    t3 = $[9];
  }
  return t3;
}

// Transform lines to line objects with type information
function _temp(node, i) {
  return <Box key={i}>{node}</Box>;
}
export function transformLinesToObjects(lines: string[]): LineObject[] {
  return lines.map(code => {
    if (code.startsWith('+')) {
      return {
        code: code.slice(1),
        i: 0,
        type: 'add',
        originalCode: code.slice(1)
      };
    }
    if (code.startsWith('-')) {
      return {
        code: code.slice(1),
        i: 0,
        type: 'remove',
        originalCode: code.slice(1)
      };
    }
    return {
      code: code.slice(1),
      i: 0,
      type: 'nochange',
      originalCode: code.slice(1)
    };
  });
}

// Group adjacent add/remove lines for word-level diffing
export function processAdjacentLines(lineObjects: LineObject[]): LineObject[] {
  const processedLines: LineObject[] = [];
  let i = 0;
  while (i < lineObjects.length) {
    const current = lineObjects[i];
    if (!current) {
      i++;
      continue;
    }

    // Find a sequence of remove followed by add (possible word-level diff candidates)
    if (current.type === 'remove') {
      const removeLines: LineObject[] = [current];
      let j = i + 1;

      // Collect consecutive remove lines
      while (j < lineObjects.length && lineObjects[j]?.type === 'remove') {
        const line = lineObjects[j];
        if (line) {
          removeLines.push(line);
        }
        j++;
      }

      // Check if there are add lines following the remove lines
      const addLines: LineObject[] = [];
      while (j < lineObjects.length && lineObjects[j]?.type === 'add') {
        const line = lineObjects[j];
        if (line) {
          addLines.push(line);
        }
        j++;
      }

      // If we have both remove and add lines, perform word-level diffing
      if (removeLines.length > 0 && addLines.length > 0) {
        // For word diffing, we'll compare each pair of lines or the closest available match
        const pairCount = Math.min(removeLines.length, addLines.length);

        // Add paired lines with word diff info
        for (let k = 0; k < pairCount; k++) {
          const removeLine = removeLines[k];
          const addLine = addLines[k];
          if (removeLine && addLine) {
            removeLine.wordDiff = true;
            addLine.wordDiff = true;

            // Store the matched pair for later word diffing
            removeLine.matchedLine = addLine;
            addLine.matchedLine = removeLine;
          }
        }

        // Add all remove lines (both paired and unpaired)
        processedLines.push(...removeLines.filter(Boolean));

        // Then add all add lines (both paired and unpaired)
        processedLines.push(...addLines.filter(Boolean));
        i = j; // Skip all the lines we've processed
      } else {
        // No matching add lines, just add the current remove line
        processedLines.push(current);
        i++;
      }
    } else {
      // Not a remove line, just add it
      processedLines.push(current);
      i++;
    }
  }
  return processedLines;
}

// Calculate word-level diffs between two text strings
export function calculateWordDiffs(oldText: string, newText: string): DiffPart[] {
  // Use diffWordsWithSpace instead of diffWords to preserve whitespace
  // This ensures spaces between tokens like > and { are preserved
  const result = diffWordsWithSpace(oldText, newText, {
    ignoreCase: false
  });
  return result;
}

// Process word-level diffs with manual wrapping support
function generateWordDiffElements(item: DiffLine, width: number, maxWidth: number, dim: boolean, overrideTheme?: ThemeName): React.ReactNode[] | null {
  const {
    type,
    i,
    wordDiff,
    matchedLine,
    originalCode
  } = item;
  if (!wordDiff || !matchedLine) {
    return null; // This function only handles word-level diff rendering
  }
  const removedLineText = type === 'remove' ? originalCode : matchedLine.originalCode;
  const addedLineText = type === 'remove' ? matchedLine.originalCode : originalCode;
  const wordDiffs = calculateWordDiffs(removedLineText, addedLineText);

  // Check if we should use word-level diffing
  const totalLength = removedLineText.length + addedLineText.length;
  const changedLength = wordDiffs.filter(part => part.added || part.removed).reduce((sum, part) => sum + part.value.length, 0);
  const changeRatio = changedLength / totalLength;
  if (changeRatio > CHANGE_THRESHOLD || dim) {
    return null; // Fall back to standard rendering for major changes
  }

  // Calculate available width for content
  const diffPrefix = type === 'add' ? '+' : '-';
  const diffPrefixWidth = diffPrefix.length;
  const availableContentWidth = Math.max(1, width - maxWidth - 1 - diffPrefixWidth);

  // Manually wrap the word diff parts with better space efficiency
  const wrappedLines: {
    content: React.ReactNode[];
    contentWidth: number;
  }[] = [];
  let currentLine: React.ReactNode[] = [];
  let currentLineWidth = 0;
  wordDiffs.forEach((part, partIndex) => {
    // Determine if this part should be shown for this line type
    let shouldShow = false;
    let partBgColor: 'diffAddedWord' | 'diffRemovedWord' | undefined;
    if (type === 'add') {
      if (part.added) {
        shouldShow = true;
        partBgColor = 'diffAddedWord';
      } else if (!part.removed) {
        shouldShow = true;
      }
    } else if (type === 'remove') {
      if (part.removed) {
        shouldShow = true;
        partBgColor = 'diffRemovedWord';
      } else if (!part.added) {
        shouldShow = true;
      }
    }
    if (!shouldShow) return;

    // Use wrapText to wrap this individual part if it's long
    const partWrapped = wrapText(part.value, availableContentWidth, 'wrap');
    const partLines = partWrapped.split('\n');
    partLines.forEach((partLine, lineIdx) => {
      if (!partLine) return;

      // Check if we need to start a new line
      if (lineIdx > 0 || currentLineWidth + stringWidth(partLine) > availableContentWidth) {
        if (currentLine.length > 0) {
          wrappedLines.push({
            content: [...currentLine],
            contentWidth: currentLineWidth
          });
          currentLine = [];
          currentLineWidth = 0;
        }
      }
      currentLine.push(<Text key={`part-${partIndex}-${lineIdx}`} backgroundColor={partBgColor}>
          {partLine}
        </Text>);
      currentLineWidth += stringWidth(partLine);
    });
  });
  if (currentLine.length > 0) {
    wrappedLines.push({
      content: currentLine,
      contentWidth: currentLineWidth
    });
  }

  // Render each wrapped line as a separate Text element
  return wrappedLines.map(({
    content,
    contentWidth
  }, lineIndex) => {
    const key = `${type}-${i}-${lineIndex}`;
    const lineBgColor = type === 'add' ? dim ? 'diffAddedDimmed' : 'diffAdded' : dim ? 'diffRemovedDimmed' : 'diffRemoved';
    const lineNum = lineIndex === 0 ? i : undefined;
    const lineNumStr = (lineNum !== undefined ? lineNum.toString().padStart(maxWidth) : ' '.repeat(maxWidth)) + ' ';
    // Calculate padding to fill the entire terminal width
    const usedWidth = lineNumStr.length + diffPrefixWidth + contentWidth;
    const padding = Math.max(0, width - usedWidth);
    return <Box key={key} flexDirection="row">
        <NoSelect fromLeftEdge>
          <Text color={overrideTheme ? 'text' : undefined} backgroundColor={lineBgColor} dimColor={dim}>
            {lineNumStr}
            {diffPrefix}
          </Text>
        </NoSelect>
        <Text color={overrideTheme ? 'text' : undefined} backgroundColor={lineBgColor} dimColor={dim}>
          {content}
          {' '.repeat(padding)}
        </Text>
      </Box>;
  });
}
function formatDiff(lines: string[], startingLineNumber: number, width: number, dim: boolean, overrideTheme?: ThemeName): React.ReactNode[] {
  // Ensure width is at least 1 to prevent rendering issues with very narrow terminals
  const safeWidth = Math.max(1, Math.floor(width));

  // Step 1: Transform lines to line objects with type information
  const lineObjects = transformLinesToObjects(lines);

  // Step 2: Group adjacent add/remove lines for word-level diffing
  const processedLines = processAdjacentLines(lineObjects);

  // Step 3: Number the diff lines
  const ls = numberDiffLines(processedLines, startingLineNumber);

  // Find max line number width for alignment
  const maxLineNumber = Math.max(...ls.map(({
    i
  }) => i), 0);
  const maxWidth = Math.max(maxLineNumber.toString().length + 1, 0);

  // Step 4: Render formatting
  return ls.flatMap((item): React.ReactNode[] => {
    const {
      type,
      code,
      i,
      wordDiff,
      matchedLine
    } = item;

    // Handle word-level diffing for add/remove pairs
    if (wordDiff && matchedLine) {
      const wordDiffElements = generateWordDiffElements(item, safeWidth, maxWidth, dim, overrideTheme);

      // word-diff might refuse (e.g. due to lines being substantially different) in which
      // case we'll fall through to normal renderin gbelow
      if (wordDiffElements !== null) {
        return wordDiffElements;
      }
    }

    // Standard rendering for lines without word diffing or as fallback
    // Calculate available width accounting for line number + space + diff prefix
    const diffPrefixWidth = 2; // "  " for unchanged, "+ " or "- " for changes
    const availableContentWidth = Math.max(1, safeWidth - maxWidth - 1 - diffPrefixWidth); // -1 for space after line number
    const wrappedText = wrapText(code, availableContentWidth, 'wrap');
    const wrappedLines = wrappedText.split('\n');
    return wrappedLines.map((line, lineIndex) => {
      const key = `${type}-${i}-${lineIndex}`;
      const lineNum = lineIndex === 0 ? i : undefined;
      const lineNumStr = (lineNum !== undefined ? lineNum.toString().padStart(maxWidth) : ' '.repeat(maxWidth)) + ' ';
      const sigil = type === 'add' ? '+' : type === 'remove' ? '-' : ' ';
      // Calculate padding to fill the entire terminal width
      const contentWidth = lineNumStr.length + 1 + stringWidth(line); // lineNum + sigil + code
      const padding = Math.max(0, safeWidth - contentWidth);
      const bgColor = type === 'add' ? dim ? 'diffAddedDimmed' : 'diffAdded' : type === 'remove' ? dim ? 'diffRemovedDimmed' : 'diffRemoved' : undefined;

      // Gutter (line number + sigil) is wrapped in <NoSelect> so fullscreen
      // text selection yields clean code. bgColor carries across both boxes
      // so the visual continuity (solid red/green bar) is unchanged.
      return <Box key={key} flexDirection="row">
          <NoSelect fromLeftEdge>
            <Text color={overrideTheme ? 'text' : undefined} backgroundColor={bgColor} dimColor={dim || type === 'nochange'}>
              {lineNumStr}
              {sigil}
            </Text>
          </NoSelect>
          <Text color={overrideTheme ? 'text' : undefined} backgroundColor={bgColor} dimColor={dim}>
            {line}
            {' '.repeat(padding)}
          </Text>
        </Box>;
    });
  });
}
export function numberDiffLines(diff: LineObject[], startLine: number): DiffLine[] {
  let i = startLine;
  const result: DiffLine[] = [];
  const queue = [...diff];
  while (queue.length > 0) {
    const current = queue.shift()!;
    const {
      code,
      type,
      originalCode,
      wordDiff,
      matchedLine
    } = current;
    const line = {
      code,
      type,
      i,
      originalCode,
      wordDiff,
      matchedLine
    };

    // Update counters based on change type
    switch (type) {
      case 'nochange':
        i++;
        result.push(line);
        break;
      case 'add':
        i++;
        result.push(line);
        break;
      case 'remove':
        {
          result.push(line);
          let numRemoved = 0;
          while (queue[0]?.type === 'remove') {
            i++;
            const current = queue.shift()!;
            const {
              code,
              type,
              originalCode,
              wordDiff,
              matchedLine
            } = current;
            const line = {
              code,
              type,
              i,
              originalCode,
              wordDiff,
              matchedLine
            };
            result.push(line);
            numRemoved++;
          }
          i -= numRemoved;
          break;
        }
    }
  }
  return result;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["diffWordsWithSpace","StructuredPatchHunk","React","useMemo","ThemeName","stringWidth","Box","NoSelect","Text","useTheme","wrapText","DiffLine","code","type","i","originalCode","wordDiff","matchedLine","LineObject","DiffPart","added","removed","value","Props","patch","dim","width","CHANGE_THRESHOLD","StructuredDiffFallback","t0","$","_c","theme","t1","lines","oldStart","formatDiff","diff","t2","map","_temp","t3","node","transformLinesToObjects","startsWith","slice","processAdjacentLines","lineObjects","processedLines","length","current","removeLines","j","line","push","addLines","pairCount","Math","min","k","removeLine","addLine","filter","Boolean","calculateWordDiffs","oldText","newText","result","ignoreCase","generateWordDiffElements","item","maxWidth","overrideTheme","ReactNode","removedLineText","addedLineText","wordDiffs","totalLength","changedLength","part","reduce","sum","changeRatio","diffPrefix","diffPrefixWidth","availableContentWidth","max","wrappedLines","content","contentWidth","currentLine","currentLineWidth","forEach","partIndex","shouldShow","partBgColor","partWrapped","partLines","split","partLine","lineIdx","lineIndex","key","lineBgColor","lineNum","undefined","lineNumStr","toString","padStart","repeat","usedWidth","padding","startingLineNumber","safeWidth","floor","ls","numberDiffLines","maxLineNumber","flatMap","wordDiffElements","wrappedText","sigil","bgColor","startLine","queue","shift","numRemoved"],"sources":["Fallback.tsx"],"sourcesContent":["import { diffWordsWithSpace, type StructuredPatchHunk } from 'diff'\nimport * as React from 'react'\nimport { useMemo } from 'react'\nimport type { ThemeName } from 'src/utils/theme.js'\nimport { stringWidth } from '../../ink/stringWidth.js'\nimport { Box, NoSelect, Text, useTheme, wrapText } from '../../ink.js'\n\n/*\n * StructuredDiffFallback Component: Word-Level Diff Highlighting Example\n *\n * This component shows diff changes with word-level highlighting. Here's a walkthrough:\n *\n * Example:\n * ```\n * // Original code\n * function oldName(param) {\n *   return param.oldProperty;\n * }\n *\n * // Changed code\n * function newName(param) {\n *   return param.newProperty;\n * }\n * ```\n *\n * Processing flow:\n * 1. Component receives a patch with lines including '+' and '-' prefixes\n * 2. Lines are transformed into objects with type (add/remove/nochange)\n * 3. Related add/remove lines are paired (e.g., oldName with newName)\n * 4. Word-level diffing identifies specific changed parts:\n *    [\n *      { value: 'function ', added: undefined, removed: undefined },  // Common\n *      { value: 'oldName', removed: true },                           // Removed\n *      { value: 'newName', added: true },                             // Added\n *      { value: '(param) {', added: undefined, removed: undefined }   // Common\n *    ]\n * 5. Renders with enhanced highlighting:\n *    - Common parts are shown normally\n *    - Removed words get a darker red background\n *    - Added words get a darker green background\n *\n * This produces a visually clear diff where users can see exactly which words\n * changed rather than just which lines were modified.\n */\n\n// Define DiffLine interface to be used throughout the file\ninterface DiffLine {\n  code: string\n  type: 'add' | 'remove' | 'nochange'\n  i: number\n  originalCode: string\n  wordDiff?: boolean // Flag for word-level diffing\n  matchedLine?: DiffLine\n}\n\n// Line object type for internal functions\nexport interface LineObject {\n  code: string\n  i: number\n  type: 'add' | 'remove' | 'nochange'\n  originalCode: string\n  wordDiff?: boolean\n  matchedLine?: LineObject\n}\n\n// Type for word-level diff parts\ninterface DiffPart {\n  added?: boolean\n  removed?: boolean\n  value: string\n}\n\ntype Props = {\n  patch: StructuredPatchHunk\n  dim: boolean\n  width: number\n}\n\n// Threshold for when we show a full-line diff instead of word-level diffing\nconst CHANGE_THRESHOLD = 0.4\n\nexport function StructuredDiffFallback({\n  patch,\n  dim,\n  width,\n}: Props): React.ReactNode {\n  const [theme] = useTheme()\n  const diff = useMemo(\n    () => formatDiff(patch.lines, patch.oldStart, width, dim, theme),\n    [patch.lines, patch.oldStart, width, dim, theme],\n  )\n\n  return (\n    <Box flexDirection=\"column\" flexGrow={1}>\n      {diff.map((node, i) => (\n        <Box key={i}>{node}</Box>\n      ))}\n    </Box>\n  )\n}\n\n// Transform lines to line objects with type information\nexport function transformLinesToObjects(lines: string[]): LineObject[] {\n  return lines.map(code => {\n    if (code.startsWith('+')) {\n      return {\n        code: code.slice(1),\n        i: 0,\n        type: 'add',\n        originalCode: code.slice(1),\n      }\n    }\n    if (code.startsWith('-')) {\n      return {\n        code: code.slice(1),\n        i: 0,\n        type: 'remove',\n        originalCode: code.slice(1),\n      }\n    }\n    return {\n      code: code.slice(1),\n      i: 0,\n      type: 'nochange',\n      originalCode: code.slice(1),\n    }\n  })\n}\n\n// Group adjacent add/remove lines for word-level diffing\nexport function processAdjacentLines(lineObjects: LineObject[]): LineObject[] {\n  const processedLines: LineObject[] = []\n  let i = 0\n\n  while (i < lineObjects.length) {\n    const current = lineObjects[i]\n    if (!current) {\n      i++\n      continue\n    }\n\n    // Find a sequence of remove followed by add (possible word-level diff candidates)\n    if (current.type === 'remove') {\n      const removeLines: LineObject[] = [current]\n      let j = i + 1\n\n      // Collect consecutive remove lines\n      while (j < lineObjects.length && lineObjects[j]?.type === 'remove') {\n        const line = lineObjects[j]\n        if (line) {\n          removeLines.push(line)\n        }\n        j++\n      }\n\n      // Check if there are add lines following the remove lines\n      const addLines: LineObject[] = []\n      while (j < lineObjects.length && lineObjects[j]?.type === 'add') {\n        const line = lineObjects[j]\n        if (line) {\n          addLines.push(line)\n        }\n        j++\n      }\n\n      // If we have both remove and add lines, perform word-level diffing\n      if (removeLines.length > 0 && addLines.length > 0) {\n        // For word diffing, we'll compare each pair of lines or the closest available match\n        const pairCount = Math.min(removeLines.length, addLines.length)\n\n        // Add paired lines with word diff info\n        for (let k = 0; k < pairCount; k++) {\n          const removeLine = removeLines[k]\n          const addLine = addLines[k]\n\n          if (removeLine && addLine) {\n            removeLine.wordDiff = true\n            addLine.wordDiff = true\n\n            // Store the matched pair for later word diffing\n            removeLine.matchedLine = addLine\n            addLine.matchedLine = removeLine\n          }\n        }\n\n        // Add all remove lines (both paired and unpaired)\n        processedLines.push(...removeLines.filter(Boolean))\n\n        // Then add all add lines (both paired and unpaired)\n        processedLines.push(...addLines.filter(Boolean))\n\n        i = j // Skip all the lines we've processed\n      } else {\n        // No matching add lines, just add the current remove line\n        processedLines.push(current)\n        i++\n      }\n    } else {\n      // Not a remove line, just add it\n      processedLines.push(current)\n      i++\n    }\n  }\n\n  return processedLines\n}\n\n// Calculate word-level diffs between two text strings\nexport function calculateWordDiffs(\n  oldText: string,\n  newText: string,\n): DiffPart[] {\n  // Use diffWordsWithSpace instead of diffWords to preserve whitespace\n  // This ensures spaces between tokens like > and { are preserved\n  const result = diffWordsWithSpace(oldText, newText, { ignoreCase: false })\n\n  return result\n}\n\n// Process word-level diffs with manual wrapping support\nfunction generateWordDiffElements(\n  item: DiffLine,\n  width: number,\n  maxWidth: number,\n  dim: boolean,\n  overrideTheme?: ThemeName,\n): React.ReactNode[] | null {\n  const { type, i, wordDiff, matchedLine, originalCode } = item\n\n  if (!wordDiff || !matchedLine) {\n    return null // This function only handles word-level diff rendering\n  }\n\n  const removedLineText =\n    type === 'remove' ? originalCode : matchedLine.originalCode\n  const addedLineText =\n    type === 'remove' ? matchedLine.originalCode : originalCode\n\n  const wordDiffs = calculateWordDiffs(removedLineText, addedLineText)\n\n  // Check if we should use word-level diffing\n  const totalLength = removedLineText.length + addedLineText.length\n  const changedLength = wordDiffs\n    .filter(part => part.added || part.removed)\n    .reduce((sum, part) => sum + part.value.length, 0)\n  const changeRatio = changedLength / totalLength\n\n  if (changeRatio > CHANGE_THRESHOLD || dim) {\n    return null // Fall back to standard rendering for major changes\n  }\n\n  // Calculate available width for content\n  const diffPrefix = type === 'add' ? '+' : '-'\n  const diffPrefixWidth = diffPrefix.length\n  const availableContentWidth = Math.max(\n    1,\n    width - maxWidth - 1 - diffPrefixWidth,\n  )\n\n  // Manually wrap the word diff parts with better space efficiency\n  const wrappedLines: { content: React.ReactNode[]; contentWidth: number }[] =\n    []\n  let currentLine: React.ReactNode[] = []\n  let currentLineWidth = 0\n\n  wordDiffs.forEach((part, partIndex) => {\n    // Determine if this part should be shown for this line type\n    let shouldShow = false\n    let partBgColor: 'diffAddedWord' | 'diffRemovedWord' | undefined\n\n    if (type === 'add') {\n      if (part.added) {\n        shouldShow = true\n        partBgColor = 'diffAddedWord'\n      } else if (!part.removed) {\n        shouldShow = true\n      }\n    } else if (type === 'remove') {\n      if (part.removed) {\n        shouldShow = true\n        partBgColor = 'diffRemovedWord'\n      } else if (!part.added) {\n        shouldShow = true\n      }\n    }\n\n    if (!shouldShow) return\n\n    // Use wrapText to wrap this individual part if it's long\n    const partWrapped = wrapText(part.value, availableContentWidth, 'wrap')\n    const partLines = partWrapped.split('\\n')\n\n    partLines.forEach((partLine, lineIdx) => {\n      if (!partLine) return\n\n      // Check if we need to start a new line\n      if (\n        lineIdx > 0 ||\n        currentLineWidth + stringWidth(partLine) > availableContentWidth\n      ) {\n        if (currentLine.length > 0) {\n          wrappedLines.push({\n            content: [...currentLine],\n            contentWidth: currentLineWidth,\n          })\n          currentLine = []\n          currentLineWidth = 0\n        }\n      }\n\n      currentLine.push(\n        <Text\n          key={`part-${partIndex}-${lineIdx}`}\n          backgroundColor={partBgColor}\n        >\n          {partLine}\n        </Text>,\n      )\n\n      currentLineWidth += stringWidth(partLine)\n    })\n  })\n\n  if (currentLine.length > 0) {\n    wrappedLines.push({ content: currentLine, contentWidth: currentLineWidth })\n  }\n\n  // Render each wrapped line as a separate Text element\n  return wrappedLines.map(({ content, contentWidth }, lineIndex) => {\n    const key = `${type}-${i}-${lineIndex}`\n    const lineBgColor =\n      type === 'add'\n        ? dim\n          ? 'diffAddedDimmed'\n          : 'diffAdded'\n        : dim\n          ? 'diffRemovedDimmed'\n          : 'diffRemoved'\n    const lineNum = lineIndex === 0 ? i : undefined\n    const lineNumStr =\n      (lineNum !== undefined\n        ? lineNum.toString().padStart(maxWidth)\n        : ' '.repeat(maxWidth)) + ' '\n    // Calculate padding to fill the entire terminal width\n    const usedWidth = lineNumStr.length + diffPrefixWidth + contentWidth\n    const padding = Math.max(0, width - usedWidth)\n\n    return (\n      <Box key={key} flexDirection=\"row\">\n        <NoSelect fromLeftEdge>\n          <Text\n            color={overrideTheme ? 'text' : undefined}\n            backgroundColor={lineBgColor}\n            dimColor={dim}\n          >\n            {lineNumStr}\n            {diffPrefix}\n          </Text>\n        </NoSelect>\n        <Text\n          color={overrideTheme ? 'text' : undefined}\n          backgroundColor={lineBgColor}\n          dimColor={dim}\n        >\n          {content}\n          {' '.repeat(padding)}\n        </Text>\n      </Box>\n    )\n  })\n}\n\nfunction formatDiff(\n  lines: string[],\n  startingLineNumber: number,\n  width: number,\n  dim: boolean,\n  overrideTheme?: ThemeName,\n): React.ReactNode[] {\n  // Ensure width is at least 1 to prevent rendering issues with very narrow terminals\n  const safeWidth = Math.max(1, Math.floor(width))\n\n  // Step 1: Transform lines to line objects with type information\n  const lineObjects = transformLinesToObjects(lines)\n\n  // Step 2: Group adjacent add/remove lines for word-level diffing\n  const processedLines = processAdjacentLines(lineObjects)\n\n  // Step 3: Number the diff lines\n  const ls = numberDiffLines(processedLines, startingLineNumber)\n\n  // Find max line number width for alignment\n  const maxLineNumber = Math.max(...ls.map(({ i }) => i), 0)\n  const maxWidth = Math.max(maxLineNumber.toString().length + 1, 0)\n\n  // Step 4: Render formatting\n  return ls.flatMap((item): React.ReactNode[] => {\n    const { type, code, i, wordDiff, matchedLine } = item\n\n    // Handle word-level diffing for add/remove pairs\n    if (wordDiff && matchedLine) {\n      const wordDiffElements = generateWordDiffElements(\n        item,\n        safeWidth,\n        maxWidth,\n        dim,\n        overrideTheme,\n      )\n\n      // word-diff might refuse (e.g. due to lines being substantially different) in which\n      // case we'll fall through to normal renderin gbelow\n      if (wordDiffElements !== null) {\n        return wordDiffElements\n      }\n    }\n\n    // Standard rendering for lines without word diffing or as fallback\n    // Calculate available width accounting for line number + space + diff prefix\n    const diffPrefixWidth = 2 // \"  \" for unchanged, \"+ \" or \"- \" for changes\n    const availableContentWidth = Math.max(\n      1,\n      safeWidth - maxWidth - 1 - diffPrefixWidth,\n    ) // -1 for space after line number\n    const wrappedText = wrapText(code, availableContentWidth, 'wrap')\n    const wrappedLines = wrappedText.split('\\n')\n\n    return wrappedLines.map((line, lineIndex) => {\n      const key = `${type}-${i}-${lineIndex}`\n      const lineNum = lineIndex === 0 ? i : undefined\n      const lineNumStr =\n        (lineNum !== undefined\n          ? lineNum.toString().padStart(maxWidth)\n          : ' '.repeat(maxWidth)) + ' '\n      const sigil = type === 'add' ? '+' : type === 'remove' ? '-' : ' '\n      // Calculate padding to fill the entire terminal width\n      const contentWidth = lineNumStr.length + 1 + stringWidth(line) // lineNum + sigil + code\n      const padding = Math.max(0, safeWidth - contentWidth)\n\n      const bgColor =\n        type === 'add'\n          ? dim\n            ? 'diffAddedDimmed'\n            : 'diffAdded'\n          : type === 'remove'\n            ? dim\n              ? 'diffRemovedDimmed'\n              : 'diffRemoved'\n            : undefined\n\n      // Gutter (line number + sigil) is wrapped in <NoSelect> so fullscreen\n      // text selection yields clean code. bgColor carries across both boxes\n      // so the visual continuity (solid red/green bar) is unchanged.\n      return (\n        <Box key={key} flexDirection=\"row\">\n          <NoSelect fromLeftEdge>\n            <Text\n              color={overrideTheme ? 'text' : undefined}\n              backgroundColor={bgColor}\n              dimColor={dim || type === 'nochange'}\n            >\n              {lineNumStr}\n              {sigil}\n            </Text>\n          </NoSelect>\n          <Text\n            color={overrideTheme ? 'text' : undefined}\n            backgroundColor={bgColor}\n            dimColor={dim}\n          >\n            {line}\n            {' '.repeat(padding)}\n          </Text>\n        </Box>\n      )\n    })\n  })\n}\n\nexport function numberDiffLines(\n  diff: LineObject[],\n  startLine: number,\n): DiffLine[] {\n  let i = startLine\n  const result: DiffLine[] = []\n  const queue = [...diff]\n\n  while (queue.length > 0) {\n    const current = queue.shift()!\n    const { code, type, originalCode, wordDiff, matchedLine } = current\n    const line = {\n      code,\n      type,\n      i,\n      originalCode,\n      wordDiff,\n      matchedLine,\n    }\n\n    // Update counters based on change type\n    switch (type) {\n      case 'nochange':\n        i++\n        result.push(line)\n        break\n      case 'add':\n        i++\n        result.push(line)\n        break\n      case 'remove': {\n        result.push(line)\n        let numRemoved = 0\n        while (queue[0]?.type === 'remove') {\n          i++\n          const current = queue.shift()!\n          const { code, type, originalCode, wordDiff, matchedLine } = current\n          const line = {\n            code,\n            type,\n            i,\n            originalCode,\n            wordDiff,\n            matchedLine,\n          }\n          result.push(line)\n          numRemoved++\n        }\n        i -= numRemoved\n        break\n      }\n    }\n  }\n\n  return result\n}\n"],"mappings":"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","ignoreList":[]}