diffstalker 0.1.6 → 0.2.0

package/dist/utils/diffRowCalculations.js

@@ -1 +1,113 @@
-import{isDisplayableDiffLine as p}from"./diffFilters.js";import{getLineRowCount as m}from"./lineBreaking.js";export function getLineContent(t){return t.type==="addition"||t.type==="deletion"||t.type==="context"&&t.content.startsWith(" ")?t.content.slice(1):t.content}export function getLineNumWidth(t){let e=0;for(const o of t)o.oldLineNum&&o.oldLineNum>e&&(e=o.oldLineNum),o.newLineNum&&o.newLineNum>e&&(e=o.newLineNum);return Math.max(3,String(e).length)}export function getDiffLineWidth(t,e){if(t.type==="header"){if(t.content.startsWith("diff --git")){const n=t.content.match(/diff --git a\/.+ b\/(.+)$/);if(n)return n[1].length+6+2}return t.content.length+2}if(t.type==="hunk"){const n=t.content.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/);if(n){const c=parseInt(n[1],10),i=n[2]?parseInt(n[2],10):1,s=parseInt(n[3],10),f=n[4]?parseInt(n[4],10):1,u=n[5]?.trim()??"",a=c+i-1,d=s+f-1,g=i===1?`${c}`:`${c}-${a}`,h=f===1?`${s}`:`${s}-${d}`;return`Lines ${g} \u2192 ${h}`.length+(u?u.length+1:0)+2}return t.content.length+2}const r=getLineContent(t);return e+1+1+1+r.length+2}export function getDiffLineRowCount(t,e,o){if(o<=0||t.type==="header"||t.type==="hunk")return 1;const r=o-e-5;if(r<=0)return 1;const n=getLineContent(t);return m(n,r)}export function getDiffTotalRows(t,e,o){if(!t||e<=0)return 0;const r=t.lines.filter(p);if(r.length===0)return 0;const n=o??getLineNumWidth(r);let c=0;for(const i of r)c+=getDiffLineRowCount(i,n,e);return c}
+/**
+ * Utilities for calculating how diff lines wrap in the terminal.
+ * Used for accurate scroll calculations when lines exceed terminal width.
+ */
+import { isDisplayableDiffLine } from './diffFilters.js';
+import { getLineRowCount } from './lineBreaking.js';
+/**
+ * Get the content of a diff line without the leading +/-/space character.
+ */
+export function getLineContent(line) {
+    if (line.type === 'addition' || line.type === 'deletion') {
+        return line.content.slice(1);
+    }
+    if (line.type === 'context' && line.content.startsWith(' ')) {
+        return line.content.slice(1);
+    }
+    return line.content;
+}
+/**
+ * Calculate the width of the line number column based on the largest line number.
+ */
+export function getLineNumWidth(lines) {
+    let maxLineNum = 0;
+    for (const line of lines) {
+        if (line.oldLineNum && line.oldLineNum > maxLineNum)
+            maxLineNum = line.oldLineNum;
+        if (line.newLineNum && line.newLineNum > maxLineNum)
+            maxLineNum = line.newLineNum;
+    }
+    return Math.max(3, String(maxLineNum).length);
+}
+/**
+ * Calculate the rendered width of a diff line in terminal columns.
+ *
+ * Layout for content lines (addition/deletion/context):
+ *   paddingX(1) + lineNum + space(1) + symbol(1) + space(1) + content + paddingX(1)
+ *
+ * Layout for headers:
+ *   paddingX(1) + "── filename ──" or raw content + paddingX(1)
+ *
+ * Layout for hunk headers:
+ *   paddingX(1) + "Lines X-Y → X-Y context" + paddingX(1)
+ */
+export function getDiffLineWidth(line, lineNumWidth) {
+    const PADDING_X = 2; // 1 on each side
+    if (line.type === 'header') {
+        if (line.content.startsWith('diff --git')) {
+            const match = line.content.match(/diff --git a\/.+ b\/(.+)$/);
+            if (match) {
+                // "── " + filename + " ──" = 6 chars wrapper
+                return match[1].length + 6 + PADDING_X;
+            }
+        }
+        return line.content.length + PADDING_X;
+    }
+    if (line.type === 'hunk') {
+        const match = line.content.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/);
+        if (match) {
+            const oldStart = parseInt(match[1], 10);
+            const oldCount = match[2] ? parseInt(match[2], 10) : 1;
+            const newStart = parseInt(match[3], 10);
+            const newCount = match[4] ? parseInt(match[4], 10) : 1;
+            const context = match[5]?.trim() ?? '';
+            const oldEnd = oldStart + oldCount - 1;
+            const newEnd = newStart + newCount - 1;
+            const oldRange = oldCount === 1 ? `${oldStart}` : `${oldStart}-${oldEnd}`;
+            const newRange = newCount === 1 ? `${newStart}` : `${newStart}-${newEnd}`;
+            // "Lines X-Y → X-Y" + optional " context"
+            const rangeText = `Lines ${oldRange} → ${newRange}`;
+            return rangeText.length + (context ? context.length + 1 : 0) + PADDING_X;
+        }
+        return line.content.length + PADDING_X;
+    }
+    // Addition/Deletion/Context lines
+    // lineNum + space + symbol + space + content
+    const content = getLineContent(line);
+    return lineNumWidth + 1 + 1 + 1 + content.length + PADDING_X;
+}
+/**
+ * Calculate how many terminal rows a diff line will take when rendered.
+ * Uses the same line-breaking logic as the actual rendering for accuracy.
+ */
+export function getDiffLineRowCount(line, lineNumWidth, terminalWidth) {
+    if (terminalWidth <= 0)
+        return 1;
+    // Headers and hunks are truncated, so they're always 1 row
+    if (line.type === 'header' || line.type === 'hunk') {
+        return 1;
+    }
+    // Content lines (addition/deletion/context) use manual line breaking
+    // Layout: paddingX(1) + lineNum + space(1) + symbol(1) + space(1) + content + paddingX(1)
+    const contentWidth = terminalWidth - lineNumWidth - 5;
+    if (contentWidth <= 0)
+        return 1;
+    const content = getLineContent(line);
+    return getLineRowCount(content, contentWidth);
+}
+/**
+ * Calculate the total number of terminal rows for a diff.
+ */
+export function getDiffTotalRows(diff, terminalWidth, lineNumWidth) {
+    if (!diff || terminalWidth <= 0)
+        return 0;
+    const displayableLines = diff.lines.filter(isDisplayableDiffLine);
+    if (displayableLines.length === 0)
+        return 0;
+    const lnWidth = lineNumWidth ?? getLineNumWidth(displayableLines);
+    let totalRows = 0;
+    for (const line of displayableLines) {
+        totalRows += getDiffLineRowCount(line, lnWidth, terminalWidth);
+    }
+    return totalRows;
+}

package/dist/utils/displayRows.js

@@ -1,2 +1,351 @@
-import{formatDateAbsolute as d}from"./formatDate.js";import{isDisplayableDiffLine as h}from"./diffFilters.js";import{breakLine as m,getLineRowCount as l}from"./lineBreaking.js";function p(t){return t.type==="addition"||t.type==="deletion"||t.type==="context"&&t.content.startsWith(" ")?t.content.slice(1):t.content}function y(t){switch(t.type){case"header":return{type:"diff-header",content:t.content};case"hunk":return{type:"diff-hunk",content:t.content};case"addition":return{type:"diff-add",lineNum:t.newLineNum,content:p(t)};case"deletion":return{type:"diff-del",lineNum:t.oldLineNum,content:p(t)};case"context":return{type:"diff-context",lineNum:t.oldLineNum??t.newLineNum,content:p(t)}}}export function buildDiffDisplayRows(t){return t?t.lines.filter(h).map(y):[]}export function buildHistoryDisplayRows(t,o){const e=[];if(t){e.push({type:"commit-header",content:`commit ${t.hash}`}),e.push({type:"commit-header",content:`Author: ${t.author}`}),e.push({type:"commit-header",content:`Date:   ${d(t.date)}`}),e.push({type:"spacer"});for(const f of t.message.split(`
-`))e.push({type:"commit-message",content:`    ${f}`});e.push({type:"spacer"})}return e.push(...buildDiffDisplayRows(o)),e}export function buildCompareDisplayRows(t){if(!t||t.files.length===0)return[];const o=[];for(const e of t.files)o.push(...buildDiffDisplayRows(e.diff));return o}export function getDisplayRowsLineNumWidth(t){let o=0;for(const e of t)"lineNum"in e&&e.lineNum!==void 0&&(o=Math.max(o,e.lineNum));return Math.max(3,String(o).length)}export function wrapDisplayRows(t,o,e){if(!e)return t;const s=Math.max(10,o),i=[];for(const n of t)if(n.type==="diff-add"||n.type==="diff-del"||n.type==="diff-context"){const r=n.content;if(!r||r.length<=s){i.push(n);continue}const a=m(r,s);for(let u=0;u<a.length;u++){const c=a[u];i.push({...n,content:c.text,lineNum:c.isContinuation?void 0:n.lineNum,isContinuation:c.isContinuation})}}else i.push(n);return i}export function getWrappedRowCount(t,o,e){if(!e)return t.length;const s=Math.max(10,o);let i=0;for(const n of t)if(n.type==="diff-add"||n.type==="diff-del"||n.type==="diff-context"){const r=n.content;!r||r.length<=s?i+=1:i+=l(r,s)}else i+=1;return i}
+// Unified row model for all diff views
+// Every row = exactly 1 terminal row
+import { formatDateAbsolute } from './formatDate.js';
+import { isDisplayableDiffLine } from './diffFilters.js';
+import { breakLine, getLineRowCount } from './lineBreaking.js';
+import { computeWordDiff, areSimilarEnough } from './wordDiff.js';
+import { getLanguageFromPath, highlightBlockPreserveBg, } from './languageDetection.js';
+/**
+ * Get the text content from a diff line (strip leading +/-/space and control chars)
+ */
+function getLineContent(line) {
+    let content;
+    if (line.type === 'addition' || line.type === 'deletion') {
+        content = line.content.slice(1);
+    }
+    else if (line.type === 'context') {
+        // Context lines start with space
+        content = line.content.startsWith(' ') ? line.content.slice(1) : line.content;
+    }
+    else {
+        content = line.content;
+    }
+    // Strip control characters that cause rendering artifacts
+    // and convert tabs to spaces for consistent width calculation
+    return content.replace(/[\x00-\x08\x0a-\x1f\x7f]/g, '').replace(/\t/g, '    ');
+}
+/**
+ * Convert a DiffLine to a DisplayRow
+ */
+function convertDiffLineToDisplayRow(line) {
+    switch (line.type) {
+        case 'header':
+            return { type: 'diff-header', content: line.content };
+        case 'hunk':
+            return { type: 'diff-hunk', content: line.content };
+        case 'addition':
+            return {
+                type: 'diff-add',
+                lineNum: line.newLineNum,
+                content: getLineContent(line),
+            };
+        case 'deletion':
+            return {
+                type: 'diff-del',
+                lineNum: line.oldLineNum,
+                content: getLineContent(line),
+            };
+        case 'context':
+            return {
+                type: 'diff-context',
+                lineNum: line.oldLineNum ?? line.newLineNum,
+                content: getLineContent(line),
+            };
+    }
+}
+/**
+ * Extract file path from a diff --git header line.
+ */
+function extractFilePathFromHeader(content) {
+    const match = content.match(/^diff --git a\/.+ b\/(.+)$/);
+    return match ? match[1] : null;
+}
+/**
+ * Build display rows from a DiffResult.
+ * Filters out non-displayable lines (index, ---, +++ headers).
+ * Pairs consecutive deletions/additions within hunks and computes word-level diffs.
+ * Applies block-based syntax highlighting to properly handle multi-line constructs.
+ */
+export function buildDiffDisplayRows(diff) {
+    if (!diff)
+        return [];
+    const filteredLines = diff.lines.filter(isDisplayableDiffLine);
+    const rows = [];
+    const fileSections = [];
+    let currentSection = null;
+    // Phase 1: Build display rows WITHOUT highlighting
+    // Also collect content for block highlighting
+    let i = 0;
+    while (i < filteredLines.length) {
+        const line = filteredLines[i];
+        // Headers - start new file section
+        if (line.type === 'header') {
+            const filePath = extractFilePathFromHeader(line.content);
+            if (filePath) {
+                // Save previous section if any
+                if (currentSection) {
+                    fileSections.push(currentSection);
+                    // Add spacer between files for visual separation
+                    rows.push({ type: 'spacer' });
+                }
+                // Start new section
+                currentSection = {
+                    language: getLanguageFromPath(filePath),
+                    startRowIndex: rows.length,
+                    oldContent: [],
+                    oldRowIndices: [],
+                    newContent: [],
+                    newRowIndices: [],
+                };
+            }
+            rows.push(convertDiffLineToDisplayRow(line));
+            i++;
+            continue;
+        }
+        // Hunks - just convert (don't highlight)
+        if (line.type === 'hunk') {
+            rows.push(convertDiffLineToDisplayRow(line));
+            i++;
+            continue;
+        }
+        // Context lines - add to both streams
+        if (line.type === 'context') {
+            const content = getLineContent(line);
+            const rowIndex = rows.length;
+            rows.push({
+                type: 'diff-context',
+                lineNum: line.oldLineNum ?? line.newLineNum,
+                content,
+            });
+            // Context appears in both old and new streams
+            if (currentSection && currentSection.language) {
+                currentSection.oldContent.push(content);
+                currentSection.oldRowIndices.push(rowIndex);
+                currentSection.newContent.push(content);
+                currentSection.newRowIndices.push(rowIndex);
+            }
+            i++;
+            continue;
+        }
+        // Collect consecutive deletions
+        const deletions = [];
+        while (i < filteredLines.length && filteredLines[i].type === 'deletion') {
+            deletions.push(filteredLines[i]);
+            i++;
+        }
+        // Collect consecutive additions (immediately following deletions)
+        const additions = [];
+        while (i < filteredLines.length && filteredLines[i].type === 'addition') {
+            additions.push(filteredLines[i]);
+            i++;
+        }
+        // Build arrays to store word diff segments for paired lines
+        const delSegmentsMap = new Map();
+        const addSegmentsMap = new Map();
+        // Pair deletions with additions for word-level diff (only if similar enough)
+        const pairCount = Math.min(deletions.length, additions.length);
+        for (let j = 0; j < pairCount; j++) {
+            const delContent = getLineContent(deletions[j]);
+            const addContent = getLineContent(additions[j]);
+            // Only compute word diff if lines are similar enough
+            if (areSimilarEnough(delContent, addContent)) {
+                const { oldSegments, newSegments } = computeWordDiff(delContent, addContent);
+                delSegmentsMap.set(j, oldSegments);
+                addSegmentsMap.set(j, newSegments);
+            }
+        }
+        // Output deletions first (preserving original diff order)
+        for (let j = 0; j < deletions.length; j++) {
+            const delLine = deletions[j];
+            const delContent = getLineContent(delLine);
+            const segments = delSegmentsMap.get(j);
+            const rowIndex = rows.length;
+            rows.push({
+                type: 'diff-del',
+                lineNum: delLine.oldLineNum,
+                content: delContent,
+                ...(segments && { wordDiffSegments: segments }),
+            });
+            // Add to old stream (only if no word-diff, as word-diff takes priority)
+            if (currentSection && currentSection.language && !segments) {
+                currentSection.oldContent.push(delContent);
+                currentSection.oldRowIndices.push(rowIndex);
+            }
+        }
+        // Then output additions
+        for (let j = 0; j < additions.length; j++) {
+            const addLine = additions[j];
+            const addContent = getLineContent(addLine);
+            const segments = addSegmentsMap.get(j);
+            const rowIndex = rows.length;
+            rows.push({
+                type: 'diff-add',
+                lineNum: addLine.newLineNum,
+                content: addContent,
+                ...(segments && { wordDiffSegments: segments }),
+            });
+            // Add to new stream (only if no word-diff, as word-diff takes priority)
+            if (currentSection && currentSection.language && !segments) {
+                currentSection.newContent.push(addContent);
+                currentSection.newRowIndices.push(rowIndex);
+            }
+        }
+    }
+    // Save final section
+    if (currentSection) {
+        fileSections.push(currentSection);
+    }
+    // Phase 2: Apply block highlighting for each file section
+    for (const section of fileSections) {
+        if (!section.language)
+            continue;
+        // Highlight old stream (context + deletions)
+        if (section.oldContent.length > 0) {
+            const oldHighlighted = highlightBlockPreserveBg(section.oldContent, section.language);
+            for (let j = 0; j < section.oldRowIndices.length; j++) {
+                const rowIndex = section.oldRowIndices[j];
+                const row = rows[rowIndex];
+                const highlighted = oldHighlighted[j];
+                // Only set highlighted if it's different from content
+                if (highlighted &&
+                    highlighted !== row.content &&
+                    (row.type === 'diff-del' || row.type === 'diff-context')) {
+                    row.highlighted = highlighted;
+                }
+            }
+        }
+        // Highlight new stream (context + additions)
+        if (section.newContent.length > 0) {
+            const newHighlighted = highlightBlockPreserveBg(section.newContent, section.language);
+            for (let j = 0; j < section.newRowIndices.length; j++) {
+                const rowIndex = section.newRowIndices[j];
+                const row = rows[rowIndex];
+                const highlighted = newHighlighted[j];
+                // Only set highlighted if it's different from content
+                // Note: context lines appear in both streams, but result should be same
+                if (highlighted &&
+                    highlighted !== row.content &&
+                    (row.type === 'diff-add' || row.type === 'diff-context')) {
+                    row.highlighted = highlighted;
+                }
+            }
+        }
+    }
+    return rows;
+}
+/**
+ * Build display rows from commit + diff (for History tab).
+ * Includes commit metadata, message, then diff lines.
+ */
+export function buildHistoryDisplayRows(commit, diff) {
+    const rows = [];
+    if (commit) {
+        rows.push({ type: 'commit-header', content: `commit ${commit.hash}` });
+        rows.push({ type: 'commit-header', content: `Author: ${commit.author}` });
+        rows.push({ type: 'commit-header', content: `Date:   ${formatDateAbsolute(commit.date)}` });
+        rows.push({ type: 'spacer' });
+        for (const line of commit.message.split('\n')) {
+            rows.push({ type: 'commit-message', content: `    ${line}` });
+        }
+        rows.push({ type: 'spacer' });
+    }
+    rows.push(...buildDiffDisplayRows(diff));
+    return rows;
+}
+/**
+ * Build display rows for compare view from CompareDiff.
+ * Combines all file diffs into a single DisplayRow array.
+ */
+export function buildCompareDisplayRows(compareDiff) {
+    if (!compareDiff || compareDiff.files.length === 0) {
+        return [];
+    }
+    const rows = [];
+    for (const file of compareDiff.files) {
+        rows.push(...buildDiffDisplayRows(file.diff));
+    }
+    return rows;
+}
+/**
+ * Get the maximum line number width needed for alignment.
+ * Scans all rows with line numbers and returns the digit count.
+ */
+export function getDisplayRowsLineNumWidth(rows) {
+    let max = 0;
+    for (const row of rows) {
+        if ('lineNum' in row && row.lineNum !== undefined) {
+            max = Math.max(max, row.lineNum);
+        }
+    }
+    return Math.max(3, String(max).length);
+}
+/**
+ * Expand display rows for wrap mode.
+ * Long content lines are broken into multiple rows with continuation markers.
+ * Headers, hunks, and metadata rows remain truncated (not wrapped).
+ *
+ * @param rows - Original display rows
+ * @param contentWidth - Available width for content (after line num, symbol, padding)
+ * @param wrapEnabled - Whether wrap mode is enabled
+ * @returns Array of rows, potentially expanded with continuations
+ */
+export function wrapDisplayRows(rows, contentWidth, wrapEnabled) {
+    if (!wrapEnabled)
+        return rows;
+    // Minimum content width to prevent excessive segments
+    const minWidth = 10;
+    const effectiveWidth = Math.max(minWidth, contentWidth);
+    const result = [];
+    for (const row of rows) {
+        // Only wrap diff content lines (add, del, context)
+        if (row.type === 'diff-add' || row.type === 'diff-del' || row.type === 'diff-context') {
+            const content = row.content;
+            // Skip wrapping for empty or short content
+            if (!content || content.length <= effectiveWidth) {
+                result.push(row);
+                continue;
+            }
+            const segments = breakLine(content, effectiveWidth);
+            for (let i = 0; i < segments.length; i++) {
+                const segment = segments[i];
+                result.push({
+                    ...row,
+                    content: segment.text,
+                    lineNum: segment.isContinuation ? undefined : row.lineNum,
+                    isContinuation: segment.isContinuation,
+                });
+            }
+        }
+        else {
+            // Headers, hunks, commit metadata - don't wrap
+            result.push(row);
+        }
+    }
+    return result;
+}
+/**
+ * Calculate the total row count after wrapping.
+ * More efficient than wrapDisplayRows().length when you only need the count.
+ */
+export function getWrappedRowCount(rows, contentWidth, wrapEnabled) {
+    if (!wrapEnabled)
+        return rows.length;
+    const minWidth = 10;
+    const effectiveWidth = Math.max(minWidth, contentWidth);
+    let count = 0;
+    for (const row of rows) {
+        if (row.type === 'diff-add' || row.type === 'diff-del' || row.type === 'diff-context') {
+            const content = row.content;
+            if (!content || content.length <= effectiveWidth) {
+                count += 1;
+            }
+            else {
+                count += getLineRowCount(content, effectiveWidth);
+            }
+        }
+        else {
+            count += 1;
+        }
+    }
+    return count;
+}

package/dist/utils/explorerDisplayRows.js

@@ -0,0 +1,169 @@
+/**
+ * Row model for explorer file content view.
+ * Follows the same pattern as displayRows.ts - single source of truth
+ * for both rendering and scroll calculations.
+ */
+import { breakLine, getLineRowCount } from './lineBreaking.js';
+import { getLanguageFromPath, highlightLine } from './languageDetection.js';
+/**
+ * Build display rows from file content with optional syntax highlighting.
+ * Each line becomes one row with line number and content.
+ *
+ * @param content - File content string
+ * @param filePath - File path for language detection
+ * @param truncated - Whether the file was truncated
+ * @returns Array of explorer content rows
+ */
+export function buildExplorerContentRows(content, filePath, truncated) {
+    if (!content)
+        return [];
+    const lines = content.split('\n');
+    const rows = [];
+    // Detect language for highlighting
+    const language = filePath ? getLanguageFromPath(filePath) : null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const highlighted = language ? highlightLine(line, language) : undefined;
+        rows.push({
+            type: 'code',
+            lineNum: i + 1,
+            content: line,
+            highlighted,
+        });
+    }
+    // Add truncation indicator if needed
+    if (truncated) {
+        rows.push({
+            type: 'truncation',
+            content: '(file truncated)',
+        });
+    }
+    return rows;
+}
+/**
+ * Apply line wrapping to explorer content rows.
+ * Long lines are broken into multiple rows with continuation markers.
+ *
+ * @param rows - Original explorer content rows
+ * @param contentWidth - Available width for content (after line num and padding)
+ * @param wrapEnabled - Whether wrap mode is enabled
+ * @returns Array of rows, potentially expanded with continuations
+ */
+export function wrapExplorerContentRows(rows, contentWidth, wrapEnabled) {
+    if (!wrapEnabled)
+        return rows;
+    const minWidth = 10;
+    const effectiveWidth = Math.max(minWidth, contentWidth);
+    const result = [];
+    for (const row of rows) {
+        if (row.type === 'code') {
+            const content = row.content;
+            // Skip wrapping for empty or short content
+            if (!content || content.length <= effectiveWidth) {
+                result.push(row);
+                continue;
+            }
+            // Break into segments
+            // Note: We don't wrap highlighted content because ANSI codes
+            // would be split, so we wrap the raw content and apply highlighting
+            // to each segment if available
+            const segments = breakLine(content, effectiveWidth);
+            for (let i = 0; i < segments.length; i++) {
+                const segment = segments[i];
+                result.push({
+                    type: 'code',
+                    lineNum: segment.isContinuation ? 0 : row.lineNum,
+                    content: segment.text,
+                    // Don't apply per-segment highlighting as it would be incorrect
+                    // The renderer should handle continuation display
+                    highlighted: undefined,
+                    isContinuation: segment.isContinuation,
+                });
+            }
+        }
+        else {
+            // Truncation rows - don't wrap
+            result.push(row);
+        }
+    }
+    return result;
+}
+/**
+ * Calculate total row count after wrapping.
+ * More efficient than wrapExplorerContentRows().length when only count is needed.
+ *
+ * @param rows - Original explorer content rows
+ * @param contentWidth - Available width for content
+ * @param wrapEnabled - Whether wrap mode is enabled
+ * @returns Total number of rows after wrapping
+ */
+export function getExplorerContentRowCount(rows, contentWidth, wrapEnabled) {
+    if (!wrapEnabled)
+        return rows.length;
+    const minWidth = 10;
+    const effectiveWidth = Math.max(minWidth, contentWidth);
+    let count = 0;
+    for (const row of rows) {
+        if (row.type === 'code') {
+            const content = row.content;
+            if (!content || content.length <= effectiveWidth) {
+                count += 1;
+            }
+            else {
+                count += getLineRowCount(content, effectiveWidth);
+            }
+        }
+        else {
+            count += 1;
+        }
+    }
+    return count;
+}
+/**
+ * Get the line number column width needed for alignment.
+ * Returns minimum width of 3 (for lines up to 999).
+ *
+ * @param rows - Explorer content rows
+ * @returns Width needed for line number column
+ */
+export function getExplorerContentLineNumWidth(rows) {
+    let maxLineNum = 0;
+    for (const row of rows) {
+        if (row.type === 'code' && row.lineNum > maxLineNum) {
+            maxLineNum = row.lineNum;
+        }
+    }
+    return Math.max(3, String(maxLineNum).length);
+}
+/**
+ * Apply middle-dots visualization to content.
+ * Replaces leading spaces with middle-dot character (·) for indentation visibility.
+ *
+ * @param content - Line content
+ * @param enabled - Whether middle-dots mode is enabled
+ * @returns Content with leading spaces replaced by middle-dots
+ */
+export function applyMiddleDots(content, enabled) {
+    if (!enabled || !content)
+        return content;
+    // Count leading spaces
+    let leadingSpaces = 0;
+    for (const char of content) {
+        if (char === ' ') {
+            leadingSpaces++;
+        }
+        else if (char === '\t') {
+            // Convert tab to equivalent spaces (using 2 spaces per tab)
+            leadingSpaces += 2;
+        }
+        else {
+            break;
+        }
+    }
+    if (leadingSpaces === 0)
+        return content;
+    // Replace leading whitespace with dots
+    const dots = '·'.repeat(leadingSpaces);
+    const rest = content.slice(leadingSpaces);
+    return dots + rest;
+}

package/dist/utils/fileCategories.js

@@ -1 +1,26 @@
-export function categorizeFiles(e){const n=e.filter(t=>!t.staged&&t.status!=="untracked"),d=e.filter(t=>!t.staged&&t.status==="untracked"),o=e.filter(t=>t.staged);return{modified:n,untracked:d,staged:o,ordered:[...n,...d,...o]}}export function getFileListSectionCounts(e){const{modified:n,untracked:d,staged:o}=categorizeFiles(e);return{modifiedCount:n.length,untrackedCount:d.length,stagedCount:o.length}}
+/**
+ * Categorize files into the three FileList sections.
+ * This is the single source of truth for file categorization.
+ */
+export function categorizeFiles(files) {
+    const modified = files.filter((f) => !f.staged && f.status !== 'untracked');
+    const untracked = files.filter((f) => !f.staged && f.status === 'untracked');
+    const staged = files.filter((f) => f.staged);
+    return {
+        modified,
+        untracked,
+        staged,
+        ordered: [...modified, ...untracked, ...staged],
+    };
+}
+/**
+ * Get file counts for the 3 FileList sections.
+ */
+export function getFileListSectionCounts(files) {
+    const { modified, untracked, staged } = categorizeFiles(files);
+    return {
+        modifiedCount: modified.length,
+        untrackedCount: untracked.length,
+        stagedCount: staged.length,
+    };
+}