diffstalker 0.1.6 → 0.1.7

package/dist/utils/languageDetection.js

@@ -0,0 +1,180 @@
+/**
+ * Language detection and syntax highlighting utilities for file content.
+ * Uses the emphasize package for ANSI terminal colors.
+ */
+import { createEmphasize } from 'emphasize';
+import { common } from 'lowlight';
+// Create emphasize instance with common languages
+const emphasize = createEmphasize(common);
+// Map file extensions to highlight.js language names
+const EXTENSION_TO_LANGUAGE = {
+    // TypeScript/JavaScript
+    ts: 'typescript',
+    tsx: 'typescript',
+    js: 'javascript',
+    jsx: 'javascript',
+    mjs: 'javascript',
+    cjs: 'javascript',
+    // Web
+    html: 'xml',
+    htm: 'xml',
+    xml: 'xml',
+    svg: 'xml',
+    css: 'css',
+    scss: 'scss',
+    sass: 'scss',
+    less: 'less',
+    // Data formats
+    json: 'json',
+    yaml: 'yaml',
+    yml: 'yaml',
+    toml: 'ini',
+    // Shell/Config
+    sh: 'bash',
+    bash: 'bash',
+    zsh: 'bash',
+    fish: 'bash',
+    ps1: 'powershell',
+    bat: 'dos',
+    cmd: 'dos',
+    // Systems languages
+    c: 'c',
+    h: 'c',
+    cpp: 'cpp',
+    hpp: 'cpp',
+    cc: 'cpp',
+    cxx: 'cpp',
+    rs: 'rust',
+    go: 'go',
+    zig: 'zig',
+    // JVM
+    java: 'java',
+    kt: 'kotlin',
+    kts: 'kotlin',
+    scala: 'scala',
+    groovy: 'groovy',
+    gradle: 'groovy',
+    // Scripting
+    py: 'python',
+    rb: 'ruby',
+    pl: 'perl',
+    lua: 'lua',
+    php: 'php',
+    r: 'r',
+    // Functional
+    hs: 'haskell',
+    ml: 'ocaml',
+    fs: 'fsharp',
+    fsx: 'fsharp',
+    ex: 'elixir',
+    exs: 'elixir',
+    erl: 'erlang',
+    clj: 'clojure',
+    cljs: 'clojure',
+    // .NET
+    cs: 'csharp',
+    vb: 'vbnet',
+    // Documentation
+    md: 'markdown',
+    markdown: 'markdown',
+    rst: 'plaintext',
+    txt: 'plaintext',
+    // Config/Build
+    Makefile: 'makefile',
+    Dockerfile: 'dockerfile',
+    cmake: 'cmake',
+    ini: 'ini',
+    conf: 'ini',
+    cfg: 'ini',
+    // SQL
+    sql: 'sql',
+    // Other
+    vim: 'vim',
+    diff: 'diff',
+    patch: 'diff',
+};
+// Special filenames that map to languages
+const FILENAME_TO_LANGUAGE = {
+    Makefile: 'makefile',
+    makefile: 'makefile',
+    GNUmakefile: 'makefile',
+    Dockerfile: 'dockerfile',
+    dockerfile: 'dockerfile',
+    Jenkinsfile: 'groovy',
+    Vagrantfile: 'ruby',
+    Gemfile: 'ruby',
+    Rakefile: 'ruby',
+    '.gitignore': 'plaintext',
+    '.gitattributes': 'plaintext',
+    '.editorconfig': 'ini',
+    '.prettierrc': 'json',
+    '.eslintrc': 'json',
+    'tsconfig.json': 'json',
+    'package.json': 'json',
+    'package-lock.json': 'json',
+    'bun.lockb': 'plaintext',
+    'yarn.lock': 'yaml',
+    'pnpm-lock.yaml': 'yaml',
+    'Cargo.toml': 'ini',
+    'Cargo.lock': 'ini',
+    'go.mod': 'go',
+    'go.sum': 'plaintext',
+};
+// Cache of available languages
+let availableLanguages = null;
+function getAvailableLanguages() {
+    if (!availableLanguages) {
+        availableLanguages = new Set(emphasize.listLanguages());
+    }
+    return availableLanguages;
+}
+/**
+ * Get the highlight.js language name from a file path.
+ * Returns null if the language cannot be determined or is not supported.
+ */
+export function getLanguageFromPath(filePath) {
+    if (!filePath)
+        return null;
+    // Check special filenames first
+    const filename = filePath.split('/').pop() ?? '';
+    if (FILENAME_TO_LANGUAGE[filename]) {
+        const lang = FILENAME_TO_LANGUAGE[filename];
+        return getAvailableLanguages().has(lang) ? lang : null;
+    }
+    // Get extension
+    const ext = filename.includes('.') ? filename.split('.').pop()?.toLowerCase() : null;
+    if (!ext)
+        return null;
+    const lang = EXTENSION_TO_LANGUAGE[ext];
+    if (!lang)
+        return null;
+    // Verify language is available
+    return getAvailableLanguages().has(lang) ? lang : null;
+}
+/**
+ * Apply syntax highlighting to a line of code.
+ * Returns the highlighted string with ANSI escape codes.
+ * If highlighting fails, returns the original content.
+ */
+export function highlightLine(content, language) {
+    if (!content || !language)
+        return content;
+    try {
+        const result = emphasize.highlight(language, content);
+        return result.value;
+    }
+    catch {
+        // If highlighting fails, return original content
+        return content;
+    }
+}
+/**
+ * Apply syntax highlighting to multiple lines.
+ * More efficient than calling highlightLine for each line
+ * as it reuses the language detection.
+ */
+export function highlightLines(lines, language) {
+    if (!language || lines.length === 0)
+        return lines;
+    return lines.map((line) => highlightLine(line, language));
+}

package/dist/utils/layoutCalculations.js

@@ -1 +1,98 @@
-import{getFileListSectionCounts as h}from"./fileCategories.js";export{getFileListSectionCounts}from"./fileCategories.js";export function getFileListTotalRows(o){const{modifiedCount:t,untrackedCount:i,stagedCount:n}=h(o);let r=0;return t>0&&(r+=1+t),i>0&&(t>0&&(r+=1),r+=1+i),n>0&&((t>0||i>0)&&(r+=1),r+=1+n),r}export function calculatePaneHeights(o,t,i=.4){const n=getFileListTotalRows(o),r=3,a=Math.floor(t*i),s=Math.max(r,Math.min(n,a)),f=t-s;return{topPaneHeight:s,bottomPaneHeight:f}}export function getRowForFileIndex(o,t,i,n){let r=0;if(o<t)return 1+o;t>0&&(r+=1+t);const a=t;if(o<a+i){const g=o-a;return t>0&&(r+=1),r+1+g}i>0&&(t>0&&(r+=1),r+=1+i);const s=t+i,f=o-s;return(t>0||i>0)&&(r+=1),r+1+f}export function calculateScrollOffset(o,t,i){return o<t?Math.max(0,o-1):o>=t+i?o-i+1:t}
+import { getFileListSectionCounts } from './fileCategories.js';
+// Re-export for backwards compatibility
+export { getFileListSectionCounts } from './fileCategories.js';
+/**
+ * Calculate total rows for the FileList component.
+ * Accounts for headers and spacers between sections.
+ */
+export function getFileListTotalRows(files) {
+    const { modifiedCount, untrackedCount, stagedCount } = getFileListSectionCounts(files);
+    let rows = 0;
+    // Modified section
+    if (modifiedCount > 0) {
+        rows += 1 + modifiedCount; // header + files
+    }
+    // Untracked section
+    if (untrackedCount > 0) {
+        if (modifiedCount > 0)
+            rows += 1; // spacer
+        rows += 1 + untrackedCount; // header + files
+    }
+    // Staged section
+    if (stagedCount > 0) {
+        if (modifiedCount > 0 || untrackedCount > 0)
+            rows += 1; // spacer
+        rows += 1 + stagedCount; // header + files
+    }
+    return rows;
+}
+/**
+ * Calculate the heights of the top (file list) and bottom (diff/commit/etc) panes
+ * based on the number of files and available content area.
+ *
+ * The top pane grows to fit files up to 40% of content height.
+ * The bottom pane gets the remaining space.
+ */
+export function calculatePaneHeights(files, contentHeight, maxTopRatio = 0.4) {
+    // Calculate content rows needed for staging area
+    // Uses getFileListTotalRows for consistency with FileList rendering
+    const neededRows = getFileListTotalRows(files);
+    // Minimum height of 3 (header + 2 lines for empty state)
+    const minHeight = 3;
+    // Maximum is maxTopRatio of content area
+    const maxHeight = Math.floor(contentHeight * maxTopRatio);
+    // Use the smaller of needed or max, but at least min
+    const topHeight = Math.max(minHeight, Math.min(neededRows, maxHeight));
+    const bottomHeight = contentHeight - topHeight;
+    return { topPaneHeight: topHeight, bottomPaneHeight: bottomHeight };
+}
+/**
+ * Calculate which row in the file list a file at a given index occupies.
+ * This accounts for headers and spacers in the list.
+ * File order: Modified → Untracked → Staged (matches FileList.tsx)
+ */
+export function getRowForFileIndex(selectedIndex, modifiedCount, untrackedCount, _stagedCount) {
+    let row = 0;
+    // Modified section
+    if (selectedIndex < modifiedCount) {
+        // In modified section: header + file rows
+        return 1 + selectedIndex;
+    }
+    if (modifiedCount > 0) {
+        row += 1 + modifiedCount; // header + files
+    }
+    // Untracked section
+    const untrackedStart = modifiedCount;
+    if (selectedIndex < untrackedStart + untrackedCount) {
+        // In untracked section
+        const untrackedIdx = selectedIndex - untrackedStart;
+        if (modifiedCount > 0)
+            row += 1; // spacer
+        return row + 1 + untrackedIdx; // header + file position
+    }
+    if (untrackedCount > 0) {
+        if (modifiedCount > 0)
+            row += 1; // spacer
+        row += 1 + untrackedCount; // header + files
+    }
+    // Staged section
+    const stagedStart = modifiedCount + untrackedCount;
+    const stagedIdx = selectedIndex - stagedStart;
+    if (modifiedCount > 0 || untrackedCount > 0)
+        row += 1; // spacer
+    return row + 1 + stagedIdx; // header + file position
+}
+/**
+ * Calculate the scroll offset needed to keep a selected row visible.
+ */
+export function calculateScrollOffset(selectedRow, currentScrollOffset, visibleHeight) {
+    // Scroll up if selected is above visible area
+    if (selectedRow < currentScrollOffset) {
+        return Math.max(0, selectedRow - 1);
+    }
+    // Scroll down if selected is below visible area
+    else if (selectedRow >= currentScrollOffset + visibleHeight) {
+        return selectedRow - visibleHeight + 1;
+    }
+    return currentScrollOffset;
+}

package/dist/utils/lineBreaking.js

@@ -1,5 +1,88 @@
-export function breakLine(t,n,i=!0){if(n<=0)return[{text:t,isContinuation:!1}];if(t.length<=n)return[{text:t,isContinuation:!1}];const r=[];let e=t,o=!0;for(;e.length>0;){if(e.length<=n){r.push({text:e,isContinuation:!o});break}r.push({text:e.slice(0,n),isContinuation:!o}),e=e.slice(n),o=!1}return i&&l(t,n,r),r}function l(t,n,i){const r=i.map(e=>e.text).join("");if(r!==t)throw new Error(`[LineBreaking] Content was lost during breaking!
-Original (${t.length} chars): "${t.slice(0,50)}${t.length>50?"...":""}"
-Joined (${r.length} chars): "${r.slice(0,50)}${r.length>50?"...":""}"`);for(let e=0;e<i.length;e++){const o=i[e];if(o.text.length>n&&n>=1)throw new Error(`[LineBreaking] Segment ${e} exceeds maxWidth!
-Segment length: ${o.text.length}, maxWidth: ${n}
-Segment: "${o.text.slice(0,50)}${o.text.length>50?"...":""}"`)}if(i.length>0&&i[0].isContinuation)throw new Error("[LineBreaking] First segment incorrectly marked as continuation!");for(let e=1;e<i.length;e++)if(!i[e].isContinuation)throw new Error(`[LineBreaking] Segment ${e} should be marked as continuation but isn't!`)}export function getLineRowCount(t,n){return n<=0||t.length<=n?1:Math.ceil(t.length/n)}
+/**
+ * Utilities for manually breaking long lines at exact character boundaries.
+ * This gives us full control over line wrapping behavior in the diff view.
+ */
+/**
+ * Break a string into segments that fit within the given width.
+ * Breaks at exact character boundaries for predictable, consistent output.
+ *
+ * @param content - The string to break
+ * @param maxWidth - Maximum width for each segment
+ * @param validate - If true, validates the result and throws on errors (default: true)
+ * @returns Array of line segments
+ */
+export function breakLine(content, maxWidth, validate = true) {
+    if (maxWidth <= 0) {
+        return [{ text: content, isContinuation: false }];
+    }
+    if (content.length <= maxWidth) {
+        return [{ text: content, isContinuation: false }];
+    }
+    const segments = [];
+    let remaining = content;
+    let isFirst = true;
+    while (remaining.length > 0) {
+        if (remaining.length <= maxWidth) {
+            segments.push({ text: remaining, isContinuation: !isFirst });
+            break;
+        }
+        segments.push({
+            text: remaining.slice(0, maxWidth),
+            isContinuation: !isFirst,
+        });
+        remaining = remaining.slice(maxWidth);
+        isFirst = false;
+    }
+    // Validate the result
+    if (validate) {
+        validateBreakResult(content, maxWidth, segments);
+    }
+    return segments;
+}
+/**
+ * Validate that line breaking produced correct results.
+ * Throws an error if validation fails, making issues visible during development.
+ */
+function validateBreakResult(original, maxWidth, segments) {
+    // Check 1: Segments should join to equal original
+    const joined = segments.map((s) => s.text).join('');
+    if (joined !== original) {
+        throw new Error(`[LineBreaking] Content was lost during breaking!\n` +
+            `Original (${original.length} chars): "${original.slice(0, 50)}${original.length > 50 ? '...' : ''}"\n` +
+            `Joined (${joined.length} chars): "${joined.slice(0, 50)}${joined.length > 50 ? '...' : ''}"`);
+    }
+    // Check 2: No segment should exceed maxWidth (except if maxWidth is too small)
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if (segment.text.length > maxWidth && maxWidth >= 1) {
+            throw new Error(`[LineBreaking] Segment ${i} exceeds maxWidth!\n` +
+                `Segment length: ${segment.text.length}, maxWidth: ${maxWidth}\n` +
+                `Segment: "${segment.text.slice(0, 50)}${segment.text.length > 50 ? '...' : ''}"`);
+        }
+    }
+    // Check 3: First segment should not be marked as continuation
+    if (segments.length > 0 && segments[0].isContinuation) {
+        throw new Error(`[LineBreaking] First segment incorrectly marked as continuation!`);
+    }
+    // Check 4: Subsequent segments should be marked as continuation
+    for (let i = 1; i < segments.length; i++) {
+        if (!segments[i].isContinuation) {
+            throw new Error(`[LineBreaking] Segment ${i} should be marked as continuation but isn't!`);
+        }
+    }
+}
+/**
+ * Calculate how many visual rows a content string will take when broken.
+ *
+ * @param content - The string content
+ * @param maxWidth - Maximum width per row
+ * @returns Number of rows needed
+ */
+export function getLineRowCount(content, maxWidth) {
+    if (maxWidth <= 0)
+        return 1;
+    if (content.length <= maxWidth)
+        return 1;
+    // Simple math since we break at exact boundaries
+    return Math.ceil(content.length / maxWidth);
+}

package/dist/utils/mouseCoordinates.js

@@ -1 +1,165 @@
-import{categorizeFiles as d}from"./fileCategories.js";export function calculatePaneBoundaries(t,e,r,a=1){const s=a+2,i=a+1+t,f=i+1,l=i+2,c=l+e-1;return{stagingPaneStart:s,fileListEnd:i,separatorRow:f,diffPaneStart:l,diffPaneEnd:c,footerRow:r}}export function getClickedFileIndex(t,e,r,a,s){if(t<a+1||t>s)return-1;const i=t-(a+1)+e,{modified:f,untracked:l,staged:c}=d(r);let n=0,u=0;if(f.length>0){n++;for(let o=0;o<f.length;o++){if(i===n)return u;n++,u++}}if(l.length>0){f.length>0&&n++,n++;for(let o=0;o<l.length;o++){if(i===n)return u;n++,u++}}if(c.length>0){(f.length>0||l.length>0)&&n++,n++;for(let o=0;o<c.length;o++){if(i===n)return u;n++,u++}}return-1}export function getTabBoundaries(t){const e=t-51;return{diffStart:e,diffEnd:e+6,commitStart:e+8,commitEnd:e+16,historyStart:e+18,historyEnd:e+27,compareStart:e+29,compareEnd:e+38,explorerStart:e+40,explorerEnd:e+50}}export function getClickedTab(t,e){const r=getTabBoundaries(e);return t>=r.diffStart&&t<=r.diffEnd?"diff":t>=r.commitStart&&t<=r.commitEnd?"commit":t>=r.historyStart&&t<=r.historyEnd?"history":t>=r.compareStart&&t<=r.compareEnd?"compare":t>=r.explorerStart&&t<=r.explorerEnd?"explorer":null}export function isButtonAreaClick(t){return t<=6}export function isInPane(t,e,r){return t>=e&&t<=r}export function getFooterLeftClick(t){return t===1?"hotkeys":t>=3&&t<=10?"mouse-mode":t>=12&&t<=17?"auto-tab":t>=19&&t<=24?"wrap":null}
+import { categorizeFiles } from './fileCategories.js';
+/**
+ * Calculate the row boundaries for each pane in the layout.
+ * Layout: Header (headerHeight) + sep (1) + top pane + sep (1) + bottom pane + sep (1) + footer (1)
+ */
+export function calculatePaneBoundaries(topPaneHeight, bottomPaneHeight, terminalHeight, headerHeight = 1) {
+    // Layout (1-indexed rows):
+    // Rows 1 to headerHeight: Header
+    // Row headerHeight+1: Separator
+    // Row headerHeight+2: Top pane header ("STAGING AREA" or "COMMITS")
+    // Rows headerHeight+3 to headerHeight+1+topPaneHeight: Top pane content
+    const stagingPaneStart = headerHeight + 2; // First row of top pane (the header row)
+    const fileListEnd = headerHeight + 1 + topPaneHeight; // Last row of top pane
+    const separatorRow = fileListEnd + 1; // Separator between panes
+    const diffPaneStart = fileListEnd + 2; // First row of bottom pane content
+    const diffPaneEnd = diffPaneStart + bottomPaneHeight - 1;
+    const footerRow = terminalHeight;
+    return {
+        stagingPaneStart,
+        fileListEnd,
+        separatorRow,
+        diffPaneStart,
+        diffPaneEnd,
+        footerRow,
+    };
+}
+/**
+ * Given a y-coordinate in the file list area, calculate which file index was clicked.
+ * Returns -1 if the click is not on a file.
+ *
+ * FileList layout: Modified → Untracked → Staged (with headers and spacers)
+ */
+export function getClickedFileIndex(y, scrollOffset, files, stagingPaneStart, fileListEnd) {
+    if (y < stagingPaneStart + 1 || y > fileListEnd)
+        return -1;
+    // Calculate which row in the list was clicked (0-indexed)
+    // Use stagingPaneStart + 1 to account for the "STAGING AREA" header row
+    const listRow = y - (stagingPaneStart + 1) + scrollOffset;
+    // Split files into 3 categories (same order as FileList)
+    const { modified: modifiedFiles, untracked: untrackedFiles, staged: stagedFiles, } = categorizeFiles(files);
+    // Build row map (same structure as FileList builds)
+    // Each section: header (1) + files (n)
+    // Spacer (1) between sections if previous section exists
+    let currentRow = 0;
+    let currentFileIndex = 0;
+    // Modified section
+    if (modifiedFiles.length > 0) {
+        currentRow++; // "Modified:" header
+        for (let i = 0; i < modifiedFiles.length; i++) {
+            if (listRow === currentRow) {
+                return currentFileIndex;
+            }
+            currentRow++;
+            currentFileIndex++;
+        }
+    }
+    // Untracked section
+    if (untrackedFiles.length > 0) {
+        if (modifiedFiles.length > 0) {
+            currentRow++; // spacer
+        }
+        currentRow++; // "Untracked:" header
+        for (let i = 0; i < untrackedFiles.length; i++) {
+            if (listRow === currentRow) {
+                return currentFileIndex;
+            }
+            currentRow++;
+            currentFileIndex++;
+        }
+    }
+    // Staged section
+    if (stagedFiles.length > 0) {
+        if (modifiedFiles.length > 0 || untrackedFiles.length > 0) {
+            currentRow++; // spacer
+        }
+        currentRow++; // "Staged:" header
+        for (let i = 0; i < stagedFiles.length; i++) {
+            if (listRow === currentRow) {
+                return currentFileIndex;
+            }
+            currentRow++;
+            currentFileIndex++;
+        }
+    }
+    return -1;
+}
+/**
+ * Calculate the x-coordinate boundaries for each tab in the footer.
+ * Tab layout (right-aligned): [1]Diff [2]Commit [3]History [4]Compare [5]Explorer (51 chars total)
+ */
+export function getTabBoundaries(terminalWidth) {
+    const tabsStart = terminalWidth - 51; // 1-indexed start of tabs section
+    return {
+        diffStart: tabsStart,
+        diffEnd: tabsStart + 6,
+        commitStart: tabsStart + 8,
+        commitEnd: tabsStart + 16,
+        historyStart: tabsStart + 18,
+        historyEnd: tabsStart + 27,
+        compareStart: tabsStart + 29,
+        compareEnd: tabsStart + 38,
+        explorerStart: tabsStart + 40,
+        explorerEnd: tabsStart + 50,
+    };
+}
+/**
+ * Given an x-coordinate in the footer row, determine which tab was clicked.
+ * Returns null if no tab was clicked.
+ */
+export function getClickedTab(x, terminalWidth) {
+    const bounds = getTabBoundaries(terminalWidth);
+    if (x >= bounds.diffStart && x <= bounds.diffEnd) {
+        return 'diff';
+    }
+    else if (x >= bounds.commitStart && x <= bounds.commitEnd) {
+        return 'commit';
+    }
+    else if (x >= bounds.historyStart && x <= bounds.historyEnd) {
+        return 'history';
+    }
+    else if (x >= bounds.compareStart && x <= bounds.compareEnd) {
+        return 'compare';
+    }
+    else if (x >= bounds.explorerStart && x <= bounds.explorerEnd) {
+        return 'explorer';
+    }
+    return null;
+}
+/**
+ * Check if a click is in the file button area (first 6 columns for stage/unstage toggle).
+ */
+export function isButtonAreaClick(x) {
+    return x <= 6;
+}
+/**
+ * Check if a y-coordinate is within a given pane.
+ */
+export function isInPane(y, paneStart, paneEnd) {
+    return y >= paneStart && y <= paneEnd;
+}
+/**
+ * Given an x-coordinate in the footer row, determine which left indicator was clicked.
+ * Layout (scroll mode): "? [scroll] [auto] [wrap]"
+ *                        1 3      10 12  17 19  24
+ * (In select mode, mouse tracking is disabled so clicks don't register)
+ */
+export function getFooterLeftClick(x) {
+    // "?" area: column 1
+    if (x === 1) {
+        return 'hotkeys';
+    }
+    // "[scroll]" or "[select]" area: columns 3-10
+    if (x >= 3 && x <= 10) {
+        return 'mouse-mode';
+    }
+    // "[auto]" area: columns 12-17
+    if (x >= 12 && x <= 17) {
+        return 'auto-tab';
+    }
+    // "[wrap]" area: columns 19-24
+    if (x >= 19 && x <= 24) {
+        return 'wrap';
+    }
+    return null;
+}