Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
150 changes: 150 additions & 0 deletions src/utils/__tests__/renderer-separator-collapse.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,150 @@
import {
describe,
expect,
it
} from 'vitest';

import type { RenderContext } from '../../types/RenderContext';
import {
DEFAULT_SETTINGS,
type Settings
} from '../../types/Settings';
import type { WidgetItem } from '../../types/Widget';
import { renderStatusLine } from '../renderer';

interface PreRenderedWidget {
content: string;
plainLength: number;
widget: WidgetItem;
}

function createSettings(overrides: Partial<Settings> = {}): Settings {
return {
...DEFAULT_SETTINGS,
...overrides,
powerline: {
...DEFAULT_SETTINGS.powerline,
...(overrides.powerline ?? {})
}
};
}

function makePreRendered(widgets: WidgetItem[], contentByIndex: Record<number, string>): PreRenderedWidget[] {
return widgets.map((widget, i) => {
const content = contentByIndex[i] ?? '';
return { content, plainLength: content.length, widget };
});
}

function render(
widgets: WidgetItem[],
contentByIndex: Record<number, string>,
settingsOverrides: Partial<Settings> = {}
): string {
const settings = createSettings({ colorLevel: 0, ...settingsOverrides });
const context: RenderContext = { isPreview: false, terminalWidth: 200 };
const preRenderedWidgets = makePreRendered(widgets, contentByIndex);
return renderStatusLine(widgets, settings, context, preRenderedWidgets, []);
}

const T = (id: string): WidgetItem => ({ id, type: 'custom-text' });
const SEP: WidgetItem = { id: 'sep', type: 'separator' };

describe('renderer separator collapse around empty widgets', () => {
it('emits exactly one separator between content widgets (regression baseline)', () => {
const widgets = [T('a'), SEP, T('b')];
const out = render(widgets, { 0: 'A', 2: 'B' });
expect((out.match(/\|/g) ?? []).length).toBe(1);
});

it('drops the trailing separator when the widget after it renders empty', () => {
const widgets = [T('a'), SEP, T('b'), SEP, T('c')];
// 'b' renders empty; the separator after 'b' (before 'c') must be dropped
const out = render(widgets, { 0: 'A', 2: '', 4: 'C' });
expect((out.match(/\|/g) ?? []).length).toBe(1);
expect(out).toContain('A');
expect(out).toContain('C');
});

it('collapses multiple consecutive empty widgets into a single separator', () => {
const widgets = [T('a'), SEP, T('b'), SEP, T('c'), SEP, T('d')];
// both 'b' and 'c' render empty
const out = render(widgets, { 0: 'A', 2: '', 4: '', 6: 'D' });
expect((out.match(/\|/g) ?? []).length).toBe(1);
});

it('suppresses a leading separator when no prior widget has rendered (existing behavior)', () => {
const widgets = [T('a'), SEP, T('b')];
// 'a' renders empty; the separator after it should not emit
const out = render(widgets, { 0: '', 2: 'B' });
expect(out).not.toMatch(/\|/);
});

it('drops separators that follow a sequence of leading empty widgets', () => {
const widgets = [T('a'), SEP, T('b'), SEP, T('c')];
// both 'a' and 'b' render empty; only 'c' has content
const out = render(widgets, { 0: '', 2: '', 4: 'C' });
expect(out).not.toMatch(/\|/);
expect(out).toContain('C');
});

it('removes trailing separator when the last widget renders empty', () => {
const widgets = [T('a'), SEP, T('b')];
// 'b' renders empty
const out = render(widgets, { 0: 'A', 2: '' });
expect(out).not.toMatch(/\|/);
expect(out).toContain('A');
});

it('keeps separators between widgets that all rendered content', () => {
const widgets = [T('a'), SEP, T('b'), SEP, T('c')];
const out = render(widgets, { 0: 'A', 2: 'B', 4: 'C' });
expect((out.match(/\|/g) ?? []).length).toBe(2);
});

it('does not affect the auto-separator (defaultSeparator) path', () => {
// The auto-separator path operates on the already-filtered `elements`
// array (line ~778) — empty widgets never reach it. This test locks in
// that the fix doesn't accidentally couple to the auto-separator logic.
const widgets = [T('a'), T('b'), T('c')];
const out = render(widgets, { 0: 'A', 1: '', 2: 'C' }, { defaultSeparator: '·' });

// With B empty, exactly one auto-added '·' should appear between A and C.
expect((out.match(/·/g) ?? []).length).toBe(1);
expect(out).toContain('A');
expect(out).toContain('C');
});

it('lets a merge:no-padding widget glue to the next visible widget across an empty middle widget', () => {
// Layout: [A(merge:no-padding), B(empty), SEP, C].
//
// Without the fix, the SEP between B and C would emit (its walkback
// would skip past B's empty content and find A with content), so
// `elements` would be [A, SEP, C] and A's merge would not reach C
// (the separator sits between them in the element chain).
//
// With the fix, the SEP is suppressed because B (the immediate-prior
// non-separator) is empty. `elements` becomes [A, C] and the
// omitLeadingPadding check at the C step sees prevElem=A with
// merge:'no-padding' — A glues directly to C with no padding or
// separator between them.
const widgets: WidgetItem[] = [
{ id: 'a', type: 'custom-text', merge: 'no-padding' },
{ id: 'b', type: 'custom-text' },
SEP,
{ id: 'c', type: 'custom-text' }
];
const out = render(widgets, { 0: 'A', 1: '', 3: 'C' });

// No separator visible.
expect(out).not.toMatch(/\|/);
// A and C are present and adjacent (only intra-widget content between
// them after stripping ANSI), confirming the merge took effect.
const stripped = out.replace(/\[[0-9;]*m/g, '');
expect(stripped).toContain('A');
expect(stripped).toContain('C');
// No whitespace separator between A and C — they are directly adjacent.
expect(stripped).toMatch(/A\s*C/);
expect(stripped).not.toMatch(/A\s+\S+\s+C/);
});
});
21 changes: 12 additions & 9 deletions src/utils/renderer.ts
Original file line number Diff line number Diff line change
Expand Up @@ -668,18 +668,21 @@ export function renderStatusLine(

// Handle separators specially (they're not widgets)
if (widget.type === 'separator') {
// Check if there's any widget before this separator that actually rendered content
// Look backwards to find ANY widget that produced content
// Look backwards to the immediately-prior non-separator widget and
// emit this separator only if that widget actually rendered content.
// This collapses separators around hide-capable widgets that rendered
// empty (e.g., git-changes with no changes, conditional widgets with
// hide-when-zero semantics) and also suppresses a leading separator
// when no prior widget has rendered.
let hasContentBefore = false;
for (let j = i - 1; j >= 0; j--) {
const prevWidget = widgets[j];
if (prevWidget && prevWidget.type !== 'separator' && prevWidget.type !== 'flex-separator') {
if (preRenderedWidgets[j]?.content) {
hasContentBefore = true;
break;
}
// Continue looking backwards even if this widget didn't render content
}
if (!prevWidget)
continue;
if (prevWidget.type === 'separator' || prevWidget.type === 'flex-separator')
continue;
hasContentBefore = Boolean(preRenderedWidgets[j]?.content);
break;
}
if (!hasContentBefore)
continue;
Expand Down