Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import {
cleanup,
fireEvent,
render,
screen,
waitFor,
} from '@solidjs/testing-library';
import { type Accessor, type ComponentProps, createSignal } from 'solid-js';
import {
afterEach,
beforeEach,
describe,
expect,
it,
onTestFinished,
vi,
} from 'vitest';
import type { SpreadsheetCells } from '../core/spreadsheet-document';
import {
createGridController,
type GridController,
} from '../primitives/create-grid-controller';
import { SpreadsheetGrid } from './SpreadsheetGrid';
import { FormulaBar } from './SpreadsheetToolbar';
// The formula bar shares a module with toolbar buttons; their app hotkey
// infrastructure is not mounted by this editor interaction fixture.
vi.mock('@ui/components/Button', () => ({ Button: () => null }));
// jsdom has no viewport. Give the row window a deterministic visible height.
vi.mock('@solid-primitives/resize-observer', () => ({
createElementSize: () => ({ width: 1000, height: 960 }),
}));
afterEach(cleanup);
function renderGrid(
initial: SpreadsheetCells = {},
options: Pick<
ComponentProps<typeof SpreadsheetGrid>,
| 'comments'
| 'onCellAction'
| 'mentions'
| 'zoom'
| 'showGridlines'
| 'showFormulas'
| 'columnWidths'
| 'hiddenColumns'
| 'rowCount'
| 'sheetId'
| 'onFill'
| 'onResizeColumn'
| 'dropdowns'
| 'ownsClipboard'
| 'tables'
| 'tableUi'
> & {
values?: ComponentProps<typeof SpreadsheetGrid>['values'];
readonly?: boolean;
} = {}
) {
let controller!: GridController;
let cells!: Accessor<SpreadsheetCells>;
const onPaste = vi.fn((text: string) => controller.paste(text));
const onClear = vi.fn(() => controller.clear());
const onCopy = vi.fn(() => controller.copy());
const onCopyMetadata = vi.fn((cut?: boolean) => controller.copyMetadata(cut));
const onMove = vi.fn((row: number, column: number) =>
controller.move(row, column)
);
const view = render(() => {
const [values, setValues] = createSignal(initial);
cells = values;
controller = createGridController({
cells,
sheetId: () => options.sheetId ?? 'sheet1',
canEdit: () => !options.readonly,
setCells: (edits) => {
const next = { ...values() };
for (const [address, edit] of Object.entries(edits)) {
if (edit === null) delete next[address];
else next[address] = { ...(next[address] ?? { value: '' }), ...edit };
}
setValues(next);
},
undo: () => {},
redo: () => {},
});
return (
<>
<FormulaBar
address={controller.activeAddress()}
value={
controller.editing()
? controller.draft()
: (cells()[controller.activeAddress()]?.value ?? '')
}
readonly={options.readonly ?? false}
complete={async () => undefined}
selectionRequest={controller.editorSelection()}
pickingReference={controller.pickingReference()}
onSelectionChange={controller.setTextSelection}
onNavigate={() => {}}
onEdit={() => controller.beginEdit('formula')}
onInput={controller.setDraft}
onCommit={controller.commit}
onCancel={controller.cancel}
onReturnToGrid={() => {}}
/>
<SpreadsheetGrid
onCellAction={options.onCellAction}
comments={options.comments}
mentions={options.mentions}
cells={cells()}
sheetId={options.sheetId}
rowCount={options.rowCount ?? 30}
zoom={options.zoom}
showGridlines={options.showGridlines}
showFormulas={options.showFormulas}
columnWidths={options.columnWidths}
hiddenColumns={options.hiddenColumns}
onFill={options.onFill}
onResizeColumn={options.onResizeColumn}
dropdowns={options.dropdowns}
tables={options.tables}
tableUi={options.tableUi}
onToggleCheckbox={(position) => {
controller.select(position);
controller.toggleCheckboxes();
}}
values={options.values ?? {}}
remoteCursors={[]}
selection={controller.selection()}
editing={controller.editing() === 'cell'}
formulaEditing={controller.editing() === 'formula'}
editorSelection={controller.editorSelection()}
referenceSelection={controller.referenceSelection()}
pickingReference={controller.pickingReference()}
onTextSelection={controller.setTextSelection}
onReferenceStart={controller.beginReference}
onReferenceMove={controller.updateReference}
onReferenceEnd={controller.endReference}
draft={controller.draft()}
readonly={options.readonly ?? false}
onSelect={controller.select}
onSelectRange={controller.selectRange}
onEdit={() => controller.beginEdit('cell')}
onDraft={controller.setDraft}
onCommit={controller.commit}
onCancel={controller.cancel}
onMove={onMove}
onKeyDown={controller.keyDown}
onCopy={onCopy}
onCopyMetadata={onCopyMetadata}
onPaste={onPaste}
ownsClipboard={options.ownsClipboard}
onClear={onClear}
onGridReady={() => {}}
/>
</>
);
});
const element = view.getByRole('grid');
// Coordinates map to cells within the grid's client box, the mocked viewport.
Object.defineProperties(element, {
clientWidth: { configurable: true, value: 1000 },
clientHeight: { configurable: true, value: 960 },
});
// jsdom has no layout or scrolling; only the selected cells need this DOM API.
for (const address of ['A1', 'A2']) {
const cell = view.container.querySelector<HTMLElement>(
`[data-address="${address}"]`
);
if (cell) cell.scrollIntoView = vi.fn();
}
return {
...view,
element,
controller,
cells,
onPaste,
onClear,
onMove,
onCopy,
onCopyMetadata,
};
}
function clipboardEvent(
type: 'paste' | 'cut' | 'copy' | 'beforecopy',
data: {
types: string[];
getData: (format: string) => string;
setData?: (format: string, value: string) => void;
} | null
): Event {
const event = new Event(type, { bubbles: true, cancelable: true });
Object.defineProperty(event, 'clipboardData', { value: data });
return event;
}
function touchPointer(
target: Element | Window,
type: string,
x = 196,
y = 55,
pointerId = 1
) {
const event = new MouseEvent(type, {
button: 0,
buttons: type === 'pointerup' ? 0 : 1,
clientX: x,
clientY: y,
bubbles: true,
cancelable: true,
});
Object.defineProperties(event, {
pointerType: { value: 'touch' },
pointerId: { value: pointerId },
isPrimary: { value: true },
});
fireEvent(target, event);
return event;
}
describe('spreadsheet dropdown cells', () => {
const marker = (view: ReturnType<typeof renderGrid>, address: string) =>
view.container.querySelector<HTMLElement>(
`[data-address="${address}"] [data-dropdown-marker]`
);
it('shows an arrow in each dropdown cell that selects the cell', () => {
const view = renderGrid({}, { dropdowns: [{ range: 'B2:B3 D1' }] });
expect(marker(view, 'B2')?.tagName).toBe('BUTTON');
expect(marker(view, 'B3')).not.toBeNull();
expect(marker(view, 'D1')).not.toBeNull();
expect(marker(view, 'B4')).toBeNull();
expect(marker(view, 'C2')).toBeNull();
// jsdom has no PointerEvent; a MouseEvent carries the pressed button.
fireEvent(
marker(view, 'B3')!,
new MouseEvent('pointerdown', { bubbles: true, button: 0 })
);
expect(view.controller.activeAddress()).toBe('B3');
});
it('marks dropdown cells without a control in a view-only sheet', () => {
const view = renderGrid(
{},
{ dropdowns: [{ range: 'B2' }], readonly: true }
);
expect(marker(view, 'B2')?.tagName).toBe('SPAN');
expect(marker(view, 'B2')?.getAttribute('aria-hidden')).toBe('true');
});
it('draws a colored choice as a chip in its cells, matching case-insensitively', () => {
const view = renderGrid(
{
B2: { value: 'done' },
B3: { value: 'Open' },
B4: { value: 'Elsewhere' },
C2: { value: 'Done' },
},
{
dropdowns: [
{
range: 'B2:B4',
colors: new Map([
['done', '#bbf7d0'],
['open', '#1e3a8a'],
]),
},
],
}
);
const chip = (address: string) =>
view.container.querySelector<HTMLElement>(
`[data-address="${address}"] [data-choice-chip]`
);
expect(chip('B2')?.textContent).toBe('done');
expect(chip('B2')?.style.backgroundColor).toBe('rgb(187, 247, 208)');
expect(chip('B2')?.style.color).toBe('rgb(0, 0, 0)');
// Dark choices keep their text legible.
expect(chip('B3')?.style.color).toBe('rgb(255, 255, 255)');
expect(chip('B4')).toBeNull();
expect(view.getByRole('gridcell', { name: 'B4: Elsewhere' })).toBeTruthy();
// Outside the dropdown the same text stays plain.
expect(chip('C2')).toBeNull();
});
});
describe('spreadsheet checkbox cells', () => {
const cells: SpreadsheetCells = {
B2: { value: 'TRUE', checkbox: true, textColor: '#AA0000' },
B3: { value: 'FALSE', checkbox: true, horizontalAlign: 'left' },
B4: { value: '', checkbox: true },
B5: { value: 'Pending', checkbox: true },
B6: { value: 'TRUE' },
};
it('shows TRUE, FALSE and blank checkbox cells as boxes in the cell color and alignment', () => {
const view = renderGrid(cells);
expect(
view.getByRole('checkbox', { name: 'B2' }).getAttribute('aria-checked')
).toBe('true');
expect(
view.getByRole('checkbox', { name: 'B3' }).getAttribute('aria-checked')
).toBe('false');
expect(
view.getByRole('checkbox', { name: 'B4' }).getAttribute('aria-checked')
).toBe('false');
expect(view.queryByRole('checkbox', { name: 'B5' })).toBeNull();
expect(view.getByRole('gridcell', { name: 'B5: Pending' })).toBeTruthy();
expect(view.queryByRole('checkbox', { name: 'B6' })).toBeNull();
const checked = view.getByRole('gridcell', { name: 'B2: checked' });
expect(checked.style.textAlign).toBe('center');
expect(checked.style.color).toBe('rgb(170, 0, 0)');
expect(
view.getByRole('gridcell', { name: 'B3: not checked' }).style.textAlign
).toBe('left');
});
it('selects and toggles a box when it is clicked, without starting an edit', () => {
const view = renderGrid(cells);
const box = view.getByRole('checkbox', { name: 'B3' });
fireEvent(box, new MouseEvent('pointerdown', { bubbles: true, button: 0 }));
fireEvent.click(box);
fireEvent.dblClick(box);
expect(view.controller.activeAddress()).toBe('B3');
expect(view.cells().B3.value).toBe('TRUE');
expect(view.controller.editing()).toBeUndefined();
fireEvent.click(view.getByRole('checkbox', { name: 'B3' }));
expect(view.cells().B3.value).toBe('FALSE');
});
it('extends the selection on a Shift+click over a box without toggling it', () => {
const view = renderGrid(cells);
view.controller.select({ row: 1, column: 1 });
const box = view.getByRole('checkbox', { name: 'B4' });
fireEvent(
box,
new MouseEvent('pointerdown', {
bubbles: true,
button: 0,
shiftKey: true,
})
);
fireEvent.click(box, { shiftKey: true });
expect(view.controller.selection()).toEqual({
anchor: { row: 1, column: 1 },
focus: { row: 3, column: 1 },
});
expect(view.cells().B4.value).toBe('');
});
it('shows boxes that cannot be toggled in a view-only sheet', () => {
const view = renderGrid(cells, { readonly: true });
const box = view.getByRole('checkbox', { name: 'B2' });
expect(box.getAttribute('aria-disabled')).toBe('true');
fireEvent.click(box);
expect(view.cells().B2.value).toBe('TRUE');
});
});
describe('spreadsheet touch gestures', () => {
it('waits for a tap and leaves swipes and cancelled gestures to native scrolling', () => {
const view = renderGrid();
const cell = view.getByRole('gridcell', { name: 'B2' });
expect(touchPointer(cell, 'pointerdown').defaultPrevented).toBe(false);
expect(view.controller.activeAddress()).toBe('A1');
expect(touchPointer(window, 'pointermove', 196, 100).defaultPrevented).toBe(
false
);
touchPointer(window, 'pointerup', 196, 100);
expect(view.controller.activeAddress()).toBe('A1');
touchPointer(cell, 'pointerdown');
touchPointer(window, 'pointercancel');
touchPointer(window, 'pointerup');
expect(view.controller.activeAddress()).toBe('A1');
touchPointer(cell, 'pointerdown');
touchPointer(window, 'pointerup');
expect(view.controller.activeAddress()).toBe('B2');
expect(view.controller.editing()).toBeUndefined();
expect(
view.getByRole('button', { name: 'Move selection end' })
).toBeTruthy();
});
it('edits on a second tap and cancels iOS compatibility focus transfer', () => {
const view = renderGrid({ B2: { value: 'original' } });
const cell = view.getByRole('gridcell', { name: 'B2: original' });
for (let tap = 0; tap < 2; tap++) {
touchPointer(cell, 'pointerdown');
touchPointer(window, 'pointerup');
}
const editor = view.getByRole('textbox', { name: 'Edit B2' });
const compatibility = new MouseEvent('mousedown', {
bubbles: true,
cancelable: true,
});
fireEvent(cell, compatibility);
expect(compatibility.defaultPrevented).toBe(true);
expect(document.activeElement).toBe(editor);
expect(view.cells().B2.value).toBe('original');
});
it('moves selection handles by coordinates even when touch capture keeps targeting the handle', () => {
const view = renderGrid();
view.element.setPointerCapture = vi.fn();
const cell = view.getByRole('gridcell', { name: 'B2' });
touchPointer(cell, 'pointerdown');
touchPointer(window, 'pointerup');
const handle = view.getByRole('button', { name: 'Move selection end' });
expect(touchPointer(handle, 'pointerdown', 246, 66).defaultPrevented).toBe(
true
);
touchPointer(handle, 'pointermove', 296, 97);
touchPointer(window, 'pointerup', 296, 97);
expect(view.controller.selection()).toEqual({
anchor: { row: 1, column: 1 },
focus: { row: 3, column: 2 },
});
expect(document.activeElement).toBe(view.element);
expect(view.element.setPointerCapture).toHaveBeenCalledWith(1);
});
it('lets a tap in the handle padding select the cell underneath', () => {
const view = renderGrid();
view.element.setPointerCapture = vi.fn();
const cell = view.getByRole('gridcell', { name: 'B2' });
touchPointer(cell, 'pointerdown');
touchPointer(window, 'pointerup');
const handle = view.getByRole('button', { name: 'Move selection end' });
// B2's handle is centered at (246, 66); its 44px grip overlaps C3.
touchPointer(handle, 'pointerdown', 255, 76);
touchPointer(window, 'pointerup', 255, 76);
expect(view.controller.activeAddress()).toBe('C3');
expect(view.controller.editing()).toBeUndefined();
});
it('does not start edge scrolling until a handle actually moves', () => {
const view = renderGrid();
view.element.setPointerCapture = vi.fn();
touchPointer(view.getByRole('gridcell', { name: 'B2' }), 'pointerdown');
touchPointer(window, 'pointerup');
const requestFrame = vi.spyOn(window, 'requestAnimationFrame');
try {
touchPointer(
view.getByRole('button', { name: 'Move selection start' }),
'pointerdown',
146,
45
);
touchPointer(window, 'pointermove', 147, 45);
expect(requestFrame).not.toHaveBeenCalled();
touchPointer(window, 'pointerup', 147, 45);
expect(view.controller.selection()).toEqual({
anchor: { row: 1, column: 1 },
focus: { row: 1, column: 1 },
});
} finally {
requestFrame.mockRestore();
}
});
it('cancels a pending tap when zoom or remote column geometry changes', () => {
const [zoom, setZoom] = createSignal(100);
const [columnWidths, setWidths] = createSignal<Record<number, number>>({});
const view = renderGrid(
{},
{
get zoom() {
return zoom();
},
get columnWidths() {
return columnWidths();
},
}
);
const cell = view.getByRole('gridcell', { name: 'B2' });
touchPointer(cell, 'pointerdown');
setZoom(150);
touchPointer(window, 'pointerup');
expect(view.controller.activeAddress()).toBe('A1');
touchPointer(cell, 'pointerdown');
setWidths({ 0: 300 });
touchPointer(window, 'pointerup');
expect(view.controller.activeAddress()).toBe('A1');
});
it.each(['cell', 'formula'] as const)(
'extends a tapped reference with a handle while keeping the %s editor focused',
(location) => {
const view = renderGrid();
view.element.setPointerCapture = vi.fn();
if (location === 'cell') fireEvent.keyDown(view.element, { key: 'F2' });
const editor = view.getByRole('textbox', {
name: location === 'cell' ? 'Edit A1' : 'Formula bar',
}) as HTMLTextAreaElement;
editor.focus();
fireEvent.input(editor, { target: { value: '=SUM(' } });
editor.setSelectionRange(5, 5);
fireEvent.select(editor);
const cell = view.getByRole('gridcell', { name: 'B2' });
touchPointer(cell, 'pointerdown');
touchPointer(window, 'pointerup');
expect(editor.value).toBe('=SUM(B2');
const handle = view.getByRole('button', { name: 'Move reference end' });
touchPointer(handle, 'pointerdown', 246, 66);
touchPointer(handle, 'pointermove', 296, 97);
touchPointer(window, 'pointerup', 296, 97);
fireEvent.mouseDown(handle);
expect(document.activeElement).toBe(editor);
expect(editor.value).toBe('=SUM(B2:C4');
expect(view.controller.activeAddress()).toBe('A1');
expect(view.cells().A1).toBeUndefined();
}
);
it('cancels pending taps and handles when switching sheets, and never edits for viewers', () => {
const [sheetId, setSheetId] = createSignal('before');
const view = renderGrid(
{},
{
readonly: true,
get sheetId() {
return sheetId();
},
}
);
const cell = view.getByRole('gridcell', { name: 'B2' });
touchPointer(cell, 'pointerdown');
setSheetId('after');
touchPointer(window, 'pointerup');
expect(view.controller.activeAddress()).toBe('A1');
for (let tap = 0; tap < 2; tap++) {
touchPointer(cell, 'pointerdown');
touchPointer(window, 'pointerup');
}
expect(view.controller.activeAddress()).toBe('B2');
expect(view.controller.editing()).toBeUndefined();
view.element.setPointerCapture = vi.fn();
touchPointer(
view.getByRole('button', { name: 'Move selection end' }),
'pointerdown',
246,
66
);
setSheetId('final');
touchPointer(window, 'pointermove', 296, 97);
touchPointer(window, 'pointerup', 296, 97);
expect(view.controller.activeAddress()).toBe('A1');
});
});
describe('spreadsheet pointer gestures across sheet changes', () => {
it('cancels a pending fill when its sheet disappears and allows a new fill', () => {
const [sheetId, setSheetId] = createSignal('deleted');
const onFill = vi.fn();
const view = renderGrid(
{},
{
get sheetId() {
return sheetId();
},
onFill,
}
);
const handle = view.getByRole('button', { name: 'Drag to fill selection' });
const startFill = () =>
fireEvent(
handle,
new MouseEvent('pointerdown', {
button: 0,
buttons: 1,
bubbles: true,
cancelable: true,
})
);
const enter = (address: string) =>
fireEvent(
view.getByRole('gridcell', { name: address }),
new MouseEvent('pointerenter', { buttons: 1 })
);
startFill();
enter('A3');
expect(
view.container.querySelectorAll('[role="gridcell"][aria-selected="true"]')
).toHaveLength(3);
setSheetId('retained');
enter('A4');
fireEvent(window, new MouseEvent('pointerup', { button: 0 }));
expect(onFill).not.toHaveBeenCalled();
expect(
view.container.querySelectorAll('[role="gridcell"][aria-selected="true"]')
).toHaveLength(1);
startFill();
enter('A2');
fireEvent(window, new MouseEvent('pointerup', { button: 0 }));
expect(onFill).toHaveBeenCalledExactlyOnceWith(
{ anchor: { row: 0, column: 0 }, focus: { row: 0, column: 0 } },
{ anchor: { row: 0, column: 0 }, focus: { row: 1, column: 0 } }
);
});
it('cancels an in-progress resize without carrying its width into the next sheet', () => {
const [sheetId, setSheetId] = createSignal('deleted');
const onResizeColumn = vi.fn();
const view = renderGrid(
{},
{
get sheetId() {
return sheetId();
},
get columnWidths() {
return { 0: sheetId() === 'deleted' ? 120 : 200 };
},
onResizeColumn,
}
);
const handle = view.getByRole('separator', { name: 'Resize column A' });
handle.setPointerCapture = vi.fn();
const pointer = (type: string, clientX: number) =>
fireEvent(
handle,
new MouseEvent(type, {
button: 0,
buttons: 1,
clientX,
bubbles: true,
cancelable: true,
})
);
const cell = view.getByRole('gridcell', { name: 'A1' });
pointer('pointerdown', 100);
pointer('pointermove', 160);
expect(cell.style.width).toBe('180px');
setSheetId('retained');
pointer('pointermove', 180);
fireEvent(window, new MouseEvent('pointerup', { button: 0 }));
expect(onResizeColumn).not.toHaveBeenCalled();
expect(cell.style.width).toBe('200px');
pointer('pointerdown', 100);
pointer('pointermove', 116);
fireEvent(window, new MouseEvent('pointerup', { button: 0 }));
expect(onResizeColumn).toHaveBeenCalledExactlyOnceWith(0, 216);
});
it('ends selection dragging at the sheet boundary', () => {
const [sheetId, setSheetId] = createSignal('deleted');
const view = renderGrid(
{},
{
get sheetId() {
return sheetId();
},
}
);
fireEvent(
view.getByRole('gridcell', { name: 'B2' }),
new MouseEvent('pointerdown', {
button: 0,
buttons: 1,
bubbles: true,
cancelable: true,
})
);
fireEvent(
view.getByRole('gridcell', { name: 'C3' }),
new MouseEvent('pointerenter', { buttons: 1 })
);
expect(view.controller.selection().focus).toEqual({ row: 2, column: 2 });
setSheetId('retained');
fireEvent(
view.getByRole('gridcell', { name: 'D4' }),
new MouseEvent('pointerenter', { buttons: 1 })
);
fireEvent(window, new MouseEvent('pointerup', { button: 0 }));
expect(view.controller.selection()).toEqual({
anchor: { row: 0, column: 0 },
focus: { row: 0, column: 0 },
});
});
});
describe('spreadsheet drag auto-scroll', () => {
function mouse(
target: Element | Window,
type: string,
x: number,
y: number,
buttons = type === 'pointerup' ? 0 : 1
) {
fireEvent(
target,
new MouseEvent(type, {
button: 0,
buttons,
clientX: x,
clientY: y,
bubbles: true,
cancelable: true,
})
);
}
it('scrolls once a drag moves, faster the farther past the edge, until release', () => {
vi.useFakeTimers();
onTestFinished(() => {
vi.useRealTimers();
});
const view = renderGrid({}, { rowCount: 200 });
// B45 spans y 948-969; the grid's client box ends at 960.
mouse(view.getByRole('gridcell', { name: 'B45' }), 'pointerdown', 196, 950);
mouse(window, 'pointermove', 196, 953);
vi.advanceTimersToNextFrame();
expect(view.element.scrollTop).toBe(0);
// 34px into the bottom edge zone for a 16ms frame is 10.88px, then 134px
// is 42.88px plus the carried 0.88px.
mouse(window, 'pointermove', 196, 970);
vi.advanceTimersToNextFrame();
expect(view.element.scrollTop).toBe(10);
mouse(window, 'pointermove', 196, 1070);
vi.advanceTimersToNextFrame();
expect(view.element.scrollTop).toBe(53);
expect(view.controller.selection()).toEqual({
anchor: { row: 44, column: 1 },
focus: { row: 47, column: 1 },
});
mouse(window, 'pointerup', 196, 1070);
vi.advanceTimersToNextFrame();
expect(view.element.scrollTop).toBe(53);
});
it('keeps the scroll rate at slow speeds by carrying partial pixels between frames', () => {
vi.useFakeTimers();
onTestFinished(() => {
vi.useRealTimers();
});
const view = renderGrid({}, { rowCount: 200 });
mouse(view.getByRole('gridcell', { name: 'B45' }), 'pointerdown', 196, 950);
// 1px into the bottom edge zone: 20px a second, 0.32px a 16ms frame.
mouse(window, 'pointermove', 196, 937);
for (let frame = 0; frame < 60; frame++) vi.advanceTimersToNextFrame();
expect(view.element.scrollTop).toBe(19);
});
it('scrolls a column header drag only across, and stops when the release was missed', () => {
vi.useFakeTimers();
onTestFinished(() => {
vi.useRealTimers();
});
const view = renderGrid();
mouse(
view.getByRole('button', { name: 'Select column B' }),
'pointerdown',
196,
12
);
mouse(window, 'pointermove', 1010, 1000);
vi.advanceTimersToNextFrame();
expect(view.element.scrollTop).toBe(0);
expect(view.element.scrollLeft).toBe(10);
expect(view.controller.selection()).toEqual({
anchor: { row: 0, column: 1 },
focus: { row: 29, column: 9 },
});
mouse(window, 'pointermove', 1010, 1000, 0);
vi.advanceTimersToNextFrame();
mouse(window, 'pointermove', 400, 500);
vi.advanceTimersToNextFrame();
expect(view.element.scrollLeft).toBe(10);
expect(view.controller.selection().focus).toEqual({ row: 29, column: 9 });
});
it('cancels a fill whose release the window missed instead of applying it to the next drag', () => {
const onFill = vi.fn();
const view = renderGrid({}, { onFill });
mouse(
view.getByRole('button', { name: 'Drag to fill selection' }),
'pointerdown',
146,
45
);
mouse(window, 'pointermove', 146, 80);
fireEvent(
view.getByRole('gridcell', { name: 'A3' }),
new MouseEvent('pointerenter', { buttons: 1 })
);
// Released outside the window: the next move arrives without the button.
mouse(window, 'pointermove', 146, 80, 0);
mouse(view.getByRole('gridcell', { name: 'B2' }), 'pointerdown', 196, 55);
fireEvent(
view.getByRole('gridcell', { name: 'B3' }),
new MouseEvent('pointerenter', { buttons: 1 })
);
mouse(window, 'pointerup', 196, 76);
expect(onFill).not.toHaveBeenCalled();
expect(view.controller.selection()).toEqual({
anchor: { row: 1, column: 1 },
focus: { row: 2, column: 1 },
});
});
});
describe('spreadsheet grid clipboard and editing', () => {
it('copies instead of marking formulas as moved when a viewer uses cut', () => {
const view = renderGrid({ A1: { value: '=B1' } }, { readonly: true });
const setData = vi.fn();
fireEvent(
view.element,
clipboardEvent('cut', { types: [], getData: () => '', setData })
);
expect(view.onCopy).toHaveBeenCalledWith(false);
expect(view.onCopyMetadata).toHaveBeenCalledWith(false);
expect(view.onClear).not.toHaveBeenCalled();
expect(view.cells().A1.value).toBe('=B1');
const metadata = JSON.parse(setData.mock.calls[1][1]);
expect(metadata.cut).toBeUndefined();
expect(metadata.cells[0][0].value).toBe('=B1');
});
it('does not erase content for image paste or a cut without a clipboard', () => {
const view = renderGrid({ A1: { value: 'preserve me' } });
fireEvent(
view.element,
clipboardEvent('paste', { types: ['Files'], getData: () => '' })
);
fireEvent(view.element, clipboardEvent('cut', null));
expect(view.onPaste).not.toHaveBeenCalled();
expect(view.onClear).not.toHaveBeenCalled();
expect(view.cells().A1.value).toBe('preserve me');
// A deliberately copied blank cell remains a valid paste operation.
fireEvent(
view.element,
clipboardEvent('paste', { types: ['text/plain'], getData: () => '' })
);
expect(view.onPaste).toHaveBeenCalledWith('', undefined);
expect(view.cells().A1.value).toBe('');
});
it('handles clipboard shortcuts while focus rests outside the grid in its block', () => {
const toolbarButton = document.createElement('button');
document.body.append(toolbarButton);
const view = renderGrid(
{ A1: { value: 'copied' } },
{ ownsClipboard: (event) => event.target === toolbarButton }
);
const setData = vi.fn();
const copy = clipboardEvent('copy', {
types: [],
getData: () => '',
setData,
});
fireEvent(toolbarButton, copy);
expect(copy.defaultPrevented).toBe(true);
expect(view.onCopy).toHaveBeenCalledTimes(1);
expect(setData).toHaveBeenCalledWith('text/plain', 'copied');
const beforeCopy = clipboardEvent('beforecopy', null);
fireEvent(toolbarButton, beforeCopy);
expect(beforeCopy.defaultPrevented).toBe(true);
fireEvent(
toolbarButton,
clipboardEvent('paste', {
types: ['text/plain'],
getData: (format: string) => (format === 'text/plain' ? 'pasted' : ''),
})
);
expect(view.onPaste).toHaveBeenCalledWith('pasted', undefined);
expect(view.cells().A1.value).toBe('pasted');
// Another block's focus, or an event the grid already handled, is left alone.
const elsewhere = document.createElement('button');
document.body.append(elsewhere);
const foreign = clipboardEvent('copy', {
types: [],
getData: () => '',
setData,
});
fireEvent(elsewhere, foreign);
expect(foreign.defaultPrevented).toBe(false);
fireEvent(
view.element,
clipboardEvent('copy', { types: [], getData: () => '', setData })
);
expect(view.onCopy).toHaveBeenCalledTimes(2);
toolbarButton.remove();
elsewhere.remove();
});
it('leaves outside inputs and text selections to the browser', () => {
const host = document.createElement('div');
const input = document.createElement('input');
const text = document.createElement('p');
text.textContent = 'selectable text';
host.append(input, text);
document.body.append(host);
const view = renderGrid(
{ A1: { value: 'keep' } },
{ ownsClipboard: () => true }
);
const paste = clipboardEvent('paste', {
types: ['text/plain'],
getData: () => 'typed',
});
fireEvent(input, paste);
expect(paste.defaultPrevented).toBe(false);
expect(view.onPaste).not.toHaveBeenCalled();
const selection = document.getSelection()!;
selection.selectAllChildren(text);
const copy = clipboardEvent('copy', {
types: [],
getData: () => '',
setData: vi.fn(),
});
fireEvent(text, copy);
expect(copy.defaultPrevented).toBe(false);
expect(view.onCopy).not.toHaveBeenCalled();
selection.removeAllRanges();
host.remove();
});
it('preserves multiline input and focus while editing, then commits on Enter', () => {
const view = renderGrid({ A1: { value: 'line\nbreak' } });
fireEvent.keyDown(view.element, { key: 'F2' });
const editor = view.getByRole('textbox', { name: 'Edit A1' });
expect(editor).toBeInstanceOf(HTMLTextAreaElement);
expect(document.activeElement).toBe(editor);
expect((editor as HTMLTextAreaElement).value).toBe('line\nbreak');
fireEvent.input(editor, { target: { value: 'line\nbreak!' } });
expect(view.getByRole('textbox', { name: 'Edit A1' })).toBe(editor);
expect(document.activeElement).toBe(editor);
expect(view.controller.draft()).toBe('line\nbreak!');
const newline = new KeyboardEvent('keydown', {
key: 'Enter',
altKey: true,
bubbles: true,
cancelable: true,
});
fireEvent(editor, newline);
expect(newline.defaultPrevented).toBe(false);
expect(view.cells().A1.value).toBe('line\nbreak');
expect(view.onMove).not.toHaveBeenCalled();
fireEvent.keyDown(editor, { key: 'Enter' });
expect(view.cells().A1.value).toBe('line\nbreak!');
expect(view.controller.activeAddress()).toBe('A2');
expect(document.activeElement).toBe(view.element);
expect(view.queryByRole('textbox', { name: 'Edit A1' })).toBeNull();
});
it('leaves textarea clipboard events native and restores grid focus on Escape', () => {
const view = renderGrid({ A1: { value: 'original\ntext' } });
fireEvent.keyDown(view.element, { key: 'F2' });
const editor = view.getByRole('textbox', { name: 'Edit A1' });
const paste = clipboardEvent('paste', {
types: ['text/plain'],
getData: () => 'inside editor',
});
fireEvent(editor, paste);
expect(paste.defaultPrevented).toBe(false);
expect(view.onPaste).not.toHaveBeenCalled();
fireEvent.input(editor, { target: { value: 'discard this' } });
fireEvent.keyDown(editor, { key: 'Escape' });
expect(view.cells().A1.value).toBe('original\ntext');
expect(document.activeElement).toBe(view.element);
expect(view.queryByRole('textbox', { name: 'Edit A1' })).toBeNull();
});
});
it.each(['cell', 'formula'] as const)(
'keeps the %s editor focused and inserts a dragged range at its caret',
(location) => {
const view = renderGrid();
let editor: HTMLTextAreaElement;
if (location === 'cell') {
fireEvent.keyDown(view.element, { key: 'F2' });
editor = view.getByRole('textbox', {
name: 'Edit A1',
}) as HTMLTextAreaElement;
} else {
editor = view.getByRole('textbox', {
name: 'Formula bar',
}) as HTMLTextAreaElement;
editor.focus();
}
fireEvent.input(editor, { target: { value: '=SUM(,D1)' } });
editor.setSelectionRange(5, 5);
fireEvent.select(editor);
const start = view.getByRole('gridcell', { name: 'B2' });
const end = view.getByRole('gridcell', { name: 'C4' });
fireEvent(
start,
new MouseEvent('pointerdown', {
button: 0,
buttons: 1,
bubbles: true,
cancelable: true,
})
);
fireEvent(end, new MouseEvent('pointerenter', { buttons: 1 }));
fireEvent(window, new MouseEvent('pointerup', { button: 0 }));
const compatibilityMouseDown = new MouseEvent('mousedown', {
button: 0,
bubbles: true,
cancelable: true,
});
fireEvent(end, compatibilityMouseDown);
expect(compatibilityMouseDown.defaultPrevented).toBe(true);
expect(document.activeElement).toBe(editor);
expect(editor.value).toBe('=SUM(B2:C4,D1)');
expect(editor.selectionStart).toBe(10);
expect(view.controller.activeAddress()).toBe('A1');
expect(view.cells().A1).toBeUndefined();
expect(
view.container.querySelectorAll('[data-formula-reference]')
).toHaveLength(1);
fireEvent.keyDown(editor, { key: 'Enter' });
expect(view.cells().A1.value).toBe('=SUM(B2:C4,D1)');
expect(view.container.querySelector('[data-formula-reference]')).toBeNull();
}
);
it('keeps a constant number of selection overlays as ranges grow, with accurate cell semantics', () => {
const view = renderGrid();
view.controller.selectRange({ row: 2, column: 1 }, { row: 20, column: 12 });
expect(
view.container.querySelectorAll('[data-selection-range]')
).toHaveLength(1);
expect(
view.container.querySelectorAll('[data-selection-active]')
).toHaveLength(1);
expect(
view.container.querySelectorAll('[role="gridcell"][aria-selected="true"]')
).toHaveLength(19 * 12);
const first = view.container.querySelector('[data-selection-range]');
view.controller.selectRange({ row: 0, column: 0 }, { row: 29, column: 25 });
expect(view.container.querySelector('[data-selection-range]')).toBe(first);
// Columns outside the viewport are not rendered, like rows; every rendered
// cell inside the range is selected.
const rendered = [
...view.container.querySelectorAll<HTMLElement>('[role="gridcell"]'),
].filter((cell) => {
const row = Number(/\d+$/.exec(cell.dataset.address ?? '')?.[0]) - 1;
return row <= 29;
});
expect(
new Set(rendered.map((cell) => cell.dataset.address?.replace(/\d+$/, '')))
.size
).toBeLessThan(26);
expect(
view.container.querySelectorAll('[role="gridcell"][aria-selected="true"]')
).toHaveLength(rendered.length);
});
it('selects every cell with Cmd+A without scrolling to the last cell', () => {
const scroll = vi.fn();
Object.defineProperty(HTMLElement.prototype, 'scrollIntoView', {
configurable: true,
writable: true,
value: scroll,
});
onTestFinished(() => {
delete (HTMLElement.prototype as Partial<HTMLElement>).scrollIntoView;
});
const view = renderGrid({}, { rowCount: 200 });
fireEvent.keyDown(view.element, { key: 'a', metaKey: true });
expect(view.controller.selection()).toEqual({
anchor: { row: 0, column: 0 },
focus: { row: 199, column: 25 },
});
expect(view.container.querySelector('[data-address="Z200"]')).not.toBeNull();
expect(scroll).not.toHaveBeenCalled();
});
describe('spreadsheet presentation', () => {
it('renders persistent text, fill, borders and alignment independently of gridlines', () => {
const view = renderGrid(
{
A1: {
value: 'Styled cell',
borderTopColor: '#123456',
borderRightColor: '#123456',
borderLeftColor: '#123456',
borderBottomColor: '#123456',
borderBottomStyle: 'double',
bold: true,
italic: true,
underline: true,
strikethrough: true,
fontFamily: 'serif',
fontSize: 18,
textColor: '#123456',
fillColor: '#abcdef',
horizontalAlign: 'center',
verticalAlign: 'top',
borderTop: true,
borderRight: true,
borderBottom: true,
borderLeft: true,
wrap: true,
},
},
{ showGridlines: false }
);
const cell = view.container.querySelector<HTMLElement>(
'[data-address="A1"]'
)!;
expect(cell.style.fontSize).toBe('24px');
expect(cell.style.fontFamily).toBe('serif');
expect(cell.style.fontStyle).toBe('italic');
expect(cell.style.textDecorationLine).toBe('underline line-through');
expect(cell.style.color).toBe('rgb(18, 52, 86)');
expect(cell.style.backgroundColor).toBe('rgb(171, 205, 239)');
expect(cell.style.textAlign).toBe('center');
expect(cell.style.justifyContent).toBe('flex-start');
expect(cell.style.borderBottomColor).not.toBe('transparent');
expect(cell.style.borderTopStyle).toBe('solid');
expect(cell.style.borderBottomStyle).toBe('double');
expect(cell.style.borderRightStyle).toBe('solid');
expect(cell.style.borderLeftStyle).toBe('solid');
expect(cell.classList.contains('font-semibold')).toBe(true);
expect((cell.firstElementChild as HTMLElement).style.whiteSpace).toBe(
'pre-wrap'
);
expect(Number.parseFloat(cell.parentElement!.style.height)).toBeGreaterThan(
32
);
});
it('indents from the aligned edge by three spaces of the default font per level', () => {
const view = renderGrid(
{
A1: { value: 'Product', indent: 2 },
A2: { value: '1200', indent: 1 },
A3: { value: '1200', indent: 1, horizontalAlign: 'right' },
A4: { value: 'Title', indent: 2, horizontalAlign: 'center' },
A5: { value: 'Revenue' },
},
{ zoom: 150 }
);
const cell = (address: string) =>
view.container.querySelector<HTMLElement>(`[data-address="${address}"]`)!;
// 10 pt is 13⅓ px; three spaces are 10 px per level, zoomed by 150%.
expect(cell('A1').style.paddingLeft).toBe('30px');
expect(cell('A1').style.paddingRight).toBe('');
// An indented automatic number aligns left, as Excel's Increase Indent does.
expect(cell('A2').style.textAlign).toBe('left');
expect(cell('A2').style.paddingLeft).toBe('15px');
expect(cell('A3').style.textAlign).toBe('right');
expect(cell('A3').style.paddingRight).toBe('15px');
expect(cell('A3').style.paddingLeft).toBe('');
expect(cell('A4').style.paddingLeft).toBe('');
expect(cell('A4').style.paddingRight).toBe('');
expect(cell('A5').style.paddingLeft).toBe('');
});
it('hides the gridlines a fill covers and those a neighboring border replaces', () => {
const view = renderGrid({
B2: { value: '', fillColor: '#fff2cc' },
B5: { value: 'Total', borderTop: true, borderTopColor: '#123456' },
E2: { value: '', borderLeft: true, borderLeftColor: '#123456' },
});
const style = (address: string) =>
view.container.querySelector<HTMLElement>(`[data-address="${address}"]`)!
.style;
expect(style('B2').borderRightColor).toBe('transparent');
expect(style('B2').borderBottomColor).toBe('transparent');
expect(style('A2').borderRightColor).toBe('transparent');
expect(style('B1').borderBottomColor).toBe('transparent');
expect(style('B4').borderBottomColor).toBe('transparent');
expect(style('D2').borderRightColor).toBe('transparent');
expect(style('B5').borderTopStyle).toBe('solid');
expect(style('E2').borderLeftStyle).toBe('solid');
expect(style('C3').borderRight).toBe('');
expect(style('C3').borderBottom).toBe('');
});
it('uses wrapped row geometry for active and range outlines at different zoom levels', () => {
const view = renderGrid(
{ A1: { value: 'one\ntwo\nthree', wrap: true } },
{ zoom: 150 }
);
const active = view.container.querySelector<HTMLElement>(
'[data-selection-active]'
)!;
expect(active.style.top).toBe('36px');
expect(active.style.left).toBe('69px');
expect(active.style.width).toBe('150px');
expect(active.style.height).toBe('79.5px');
view.controller.selectRange({ row: 1, column: 1 }, { row: 3, column: 2 });
const range = view.container.querySelector<HTMLElement>(
'[data-selection-range]'
)!;
expect(range.style.top).toBe('115.5px');
expect(range.style.left).toBe('219px');
expect(range.style.width).toBe('300px');
expect(range.style.height).toBe('94.5px');
});
it('accounts for offscreen wrapped rows while keeping only the viewport and selection mounted', () => {
const view = renderGrid(
{ A100: { value: 'one\ntwo\nthree', wrap: true } },
{ rowCount: 1000 }
);
expect(view.container.querySelector('[data-address="A100"]')).toBeNull();
view.controller.select({ row: 199, column: 0 });
const active = view.container.querySelector<HTMLElement>(
'[data-selection-active]'
)!;
const cell = view.container.querySelector<HTMLElement>(
'[data-address="A200"]'
)!;
expect(active.style.top).toBe('4235px');
expect(cell.parentElement!.style.top).toBe(active.style.top);
expect(view.container.querySelectorAll('[role="row"]').length).toBeLessThan(
56
);
fireEvent.scroll(view.element, { target: { scrollTop: 4100 } });
expect(view.container.querySelector('[data-address="A200"]')).toBe(cell);
expect(view.container.querySelectorAll('[role="row"]').length).toBeLessThan(
64
);
});
it('waits for new formula results without flashing expressions or hiding literal text', () => {
const [values, setValues] = createSignal<
ComponentProps<typeof SpreadsheetGrid>['values']
>({});
const view = renderGrid(
{
A1: { value: '=SUM(B1:B3)' },
A2: { value: '=literal', format: 'text' },
},
{
get values() {
return values();
},
}
);
const cell = view.container.querySelector('[data-address="A1"]')!;
expect(cell.textContent).toBe('');
expect(
view.container.querySelector('[data-address="A2"]')?.textContent
).toBe('=literal');
setValues({ A1: { display: '6', number: 6 } });
expect(cell.textContent).toBe('6');
expect(view.cells().A1.value).toBe('=SUM(B1:B3)');
});
it('shows formulas without changing their values or numeric alignment in the normal view', () => {
const [showFormulas, setShowFormulas] = createSignal(false);
const view = renderGrid(
{ A1: { value: '=SUM(B1:B3)' } },
{
get showFormulas() {
return showFormulas();
},
values: { A1: { display: '6', number: 6 } },
}
);
const cell = view.container.querySelector<HTMLElement>(
'[data-address="A1"]'
)!;
expect(cell.textContent).toBe('6');
expect(cell.style.textAlign).toBe('right');
setShowFormulas(true);
expect(cell.textContent).toBe('=SUM(B1:B3)');
expect(cell.style.textAlign).toBe('left');
expect(view.cells().A1.value).toBe('=SUM(B1:B3)');
});
it('pins the accounting symbol to the left edge and pads amounts to line up with negatives', () => {
const [showFormulas, setShowFormulas] = createSignal(false);
const view = renderGrid(
{
A1: { value: '1234.5', format: 'accounting' },
A2: { value: '=-A1', format: 'accounting' },
A3: { value: '=A1-A1', format: 'accounting' },
A4: { value: 'Total', format: 'accounting' },
},
{
get showFormulas() {
return showFormulas();
},
values: {
A2: { display: '$(1,234.50)', number: -1234.5 },
A3: { display: '$-', number: 0 },
A4: { display: 'Total' },
},
}
);
const cell = (address: string) =>
view.container.querySelector<HTMLElement>(`[data-address="${address}"]`)!;
const layout = (address: string) => {
const parts = cell(address).querySelector('[data-accounting]');
return (
parts && {
symbol: parts.children[0].textContent,
amount: parts.children[1].firstChild?.textContent,
padding: parts.querySelector('.invisible')?.textContent,
}
);
};
// A literal shows as calculation will before its first result arrives.
expect(layout('A1')).toEqual({
symbol: '$',
amount: '1,234.50',
padding: ')',
});
expect(layout('A2')).toEqual({
symbol: '$',
amount: '(1,234.50)',
padding: '',
});
expect(layout('A3')).toEqual({ symbol: '$', amount: '-', padding: '00)' });
expect(cell('A2').getAttribute('aria-label')).toBe('A2: $(1,234.50)');
expect(layout('A4')).toBeNull();
expect(cell('A4').textContent).toBe('Total');
setShowFormulas(true);
expect(layout('A2')).toBeNull();
expect(cell('A2').textContent).toBe('=-A1');
});
});
it('renders imported URL and email cells without raw native tooltips, but leaves formulas intact', () => {
const renderText = vi.fn((value: string) => (
<a href="https://example.com">{value}</a>
));
const view = renderGrid(
{
A1: { value: "'https://example.com" },
A2: { value: '[email protected]' },
A3: { value: '=HYPERLINK("https://example.com","Site")' },
},
{
mentions: { renderText, renderEditor: () => null },
values: { A3: { display: 'Site' } },
}
);
expect(view.getByRole('link', { name: 'https://example.com' })).toBeTruthy();
expect(view.getByRole('link', { name: '[email protected]' })).toBeTruthy();
expect(
view.container.querySelector('[data-address="A1"]')?.hasAttribute('title')
).toBe(false);
expect(view.container.querySelector('[data-address="A3"]')?.textContent).toBe(
'Site'
);
expect(renderText).not.toHaveBeenCalledWith(
expect.stringContaining('HYPERLINK')
);
fireEvent.keyDown(view.getByRole('link', { name: 'https://example.com' }), {
key: 'Enter',
});
expect(view.queryByRole('textbox', { name: 'Edit A1' })).toBeNull();
});
it('marks commented cells and opens hover/click comments without selecting or editing the cell', () => {
const comments = {
canComment: () => true,
add: vi.fn(),
hasComment: (address: string) => address === 'B2',
enter: vi.fn(),
leave: vi.fn(),
show: vi.fn(),
};
const view = renderGrid({}, { comments });
const cell = view.getByRole('gridcell', { name: 'B2' });
expect(cell.getAttribute('aria-description')).toBe('Has comments');
fireEvent.mouseEnter(cell);
expect(comments.enter).toHaveBeenCalledWith('B2', cell);
const marker = view.getByRole('button', { name: 'Comments on B2' });
fireEvent.keyDown(marker, { key: 'Enter' });
expect(view.controller.editing()).toBeUndefined();
fireEvent.pointerDown(marker, { pointerId: 1, button: 0 });
fireEvent.click(marker);
expect(comments.show).toHaveBeenCalledWith('B2', cell);
expect(view.controller.activeAddress()).toBe('A1');
expect(view.controller.editing()).toBeUndefined();
fireEvent.mouseLeave(cell);
expect(comments.leave).toHaveBeenCalled();
});
describe('cell context menu', () => {
beforeEach(() => {
// jsdom has no CSS animations or layout. Explicitly use the browser's
// default animation name so Kobalte can finish its unmount/focus lifecycle.
const style = document.createElement('style');
style.textContent = '[role="menu"] { animation-name: none; }';
document.head.append(style);
const scroll = vi.spyOn(window, 'scrollTo').mockImplementation(() => {});
return () => {
style.remove();
scroll.mockRestore();
};
});
it('preserves a range on right-click and dispatches its command after restoring focus', async () => {
const onCellAction = vi.fn();
const view = renderGrid({}, { onCellAction });
view.controller.selectRange({ row: 1, column: 1 }, { row: 3, column: 2 });
const selection = structuredClone(view.controller.selection());
const cell = view.getByRole('gridcell', { name: 'C3' });
fireEvent.pointerDown(cell, { button: 2 });
expect(fireEvent.contextMenu(cell, { clientX: 250, clientY: 120 })).toBe(
false
);
expect(view.controller.selection()).toEqual(selection);
const copy = await screen.findByRole('menuitem', {
name: 'Copy',
});
fireEvent.keyDown(copy, { key: 'ArrowDown' });
expect(view.controller.selection()).toEqual(selection);
fireEvent.keyDown(copy, { key: 'Enter' });
await waitFor(() => expect(onCellAction).toHaveBeenCalledWith('copy'));
expect(view.controller.selection()).toEqual(selection);
expect(document.activeElement).toBe(view.element);
});
it('targets an unselected cell and enables fill only for the matching range dimension', async () => {
const view = renderGrid();
view.controller.selectRange({ row: 0, column: 0 }, { row: 2, column: 2 });
fireEvent.contextMenu(view.getByRole('gridcell', { name: 'E5' }));
expect(view.controller.activeAddress()).toBe('E5');
expect(view.controller.selection().anchor).toEqual(
view.controller.selection().focus
);
expect(
(await screen.findByRole('menuitem', { name: 'Fill down' })).hasAttribute(
'data-disabled'
)
).toBe(true);
expect(
screen
.getByRole('menuitem', { name: 'Fill right' })
.hasAttribute('data-disabled')
).toBe(true);
fireEvent.keyDown(document, { key: 'Escape' });
await waitFor(() => expect(screen.queryByRole('menu')).toBeNull());
view.controller.selectRange({ row: 0, column: 1 }, { row: 2, column: 1 });
fireEvent.keyDown(view.element, { key: 'F10', shiftKey: true });
expect(
(await screen.findByRole('menuitem', { name: 'Fill down' })).hasAttribute(
'data-disabled'
)
).toBe(false);
expect(
screen
.getByRole('menuitem', { name: 'Fill right' })
.hasAttribute('data-disabled')
).toBe(true);
});
it('allows comments and copy for commenters while disabling cell mutations', async () => {
const comments = {
canComment: () => true,
add: vi.fn(),
hasComment: () => false,
enter: vi.fn(),
leave: vi.fn(),
show: vi.fn(),
};
const onCellAction = vi.fn();
const view = renderGrid({}, { readonly: true, comments, onCellAction });
const cell = view.getByRole('gridcell', { name: 'B2' });
fireEvent.contextMenu(cell);
for (const name of [
'Cut',
'Paste',
'Paste values only',
'Clear values',
'Clear formatting',
'Fill down',
'Fill right',
]) {
expect(
(await screen.findByRole('menuitem', { name })).hasAttribute(
'data-disabled'
)
).toBe(true);
}
expect(
screen
.getByRole('menuitem', { name: 'Copy' })
.hasAttribute('data-disabled')
).toBe(false);
fireEvent.keyDown(screen.getByRole('menuitem', { name: 'Comment' }), {
key: 'Enter',
});
await waitFor(() => expect(comments.add).toHaveBeenCalledWith(cell));
expect(onCellAction).not.toHaveBeenCalled();
});
it('anchors a range comment to a rendered cell when its selection anchor is hidden', async () => {
const comments = {
canComment: () => true,
add: vi.fn(),
hasComment: () => false,
enter: vi.fn(),
leave: vi.fn(),
show: vi.fn(),
};
const view = renderGrid({}, { comments, hiddenColumns: [0] });
// Keep full-grid role queries outside the polling callback so they cannot
// starve the menu's deferred close/focus handlers on slower CI runners.
const anchor = view.getByRole('gridcell', { name: 'B2' });
view.controller.selectRange({ row: 1, column: 0 }, { row: 1, column: 25 });
fireEvent.keyDown(view.element, { key: 'ContextMenu' });
const comment = await screen.findByRole('menuitem', { name: 'Comment' });
fireEvent.keyDown(comment, { key: 'Enter' });
await waitFor(() => expect(comments.add).toHaveBeenCalledWith(anchor));
});
it('keeps the native text editing menu and does not open the cell menu over headers', async () => {
const view = renderGrid({ A1: { value: 'draft' } });
view.controller.beginEdit('cell');
const input = view.getByRole('textbox', { name: 'Edit A1' });
expect(fireEvent.contextMenu(input)).toBe(true);
expect(screen.queryByRole('menu')).toBeNull();
expect(view.controller.editing()).toBe('cell');
view.controller.cancel();
fireEvent.contextMenu(
view.getByRole('button', { name: 'Select column B' })
);
await screen.findByRole('menuitem', { name: 'Resize 1 column…' });
expect(
screen.queryByRole('menuitem', { name: 'Clear formatting' })
).toBeNull();
});
it('ignores a stale cell action after switching sheets', async () => {
const [sheetId, setSheetId] = createSignal('one');
const onCellAction = vi.fn();
const view = renderGrid(
{},
{
get sheetId() {
return sheetId();
},
onCellAction,
}
);
fireEvent.keyDown(view.element, { key: 'ContextMenu' });
const clear = await screen.findByRole('menuitem', { name: 'Clear values' });
setSheetId('two');
fireEvent.keyDown(clear, { key: 'Enter' });
await waitFor(() => expect(screen.queryByRole('menu')).toBeNull());
expect(onCellAction).not.toHaveBeenCalled();
});
});
describe('tables in the grid', () => {
const tables = [
{
name: 'Sales',
range: 'A1:B41',
totalsRow: true,
bandedRows: true,
style: 'TableStyleMedium2',
},
];
const tableUi = {
columnMenu: (table: () => { name: string }, column: number) => (
<span data-testid="column-menu">{`${table().name} ${column}`}</span>
),
tableMenu: (table: () => { name: string }) => (
<span data-testid="table-menu">{table().name}</span>
),
mismatch: (row: number, column: number) =>
row === 2 && column === 1 ? 'Expected a number' : undefined,
totalLabel: (row: number, column: number) =>
row === 40 && column === 1 ? 'Sum' : undefined,
columnNames: () => ['Item', 'Amount'],
menuTable: () => undefined,
};
const cells = {
A1: { value: 'Item' },
B1: { value: 'Amount' },
B3: { value: 'n/a' },
B41: { value: '=SUBTOTAL(109,[Amount])' },
};
it('names the active table, marks mismatches and labels totals', () => {
const view = renderGrid(cells, { rowCount: 100, tables, tableUi });
view.controller.select({ row: 9, column: 4 });
expect(view.queryByTestId('table-menu')).toBeNull();
view.controller.select({ row: 2, column: 1 });
expect(view.getByTestId('table-menu').textContent).toBe('Sales');
expect(view.getAllByTestId('column-menu')).toHaveLength(2);
const mismatch = view.getByRole('gridcell', { name: 'B3: n/a' });
expect(mismatch.getAttribute('title')).toBe('Expected a number');
expect(mismatch.querySelector('[data-type-mismatch]')).not.toBeNull();
expect(
view.container.querySelector('[data-address="B41"] [data-total-label]')
?.textContent
).toBe('Sum');
view.controller.select({ row: 0, column: 0 });
expect(view.queryByTestId('table-menu')).not.toBeNull();
});
it('shows the column names in the column headers once the header row scrolls away', () => {
const view = renderGrid(cells, { rowCount: 100, tables, tableUi });
view.controller.select({ row: 20, column: 0 });
const header = () =>
view.getByRole('button', { name: 'Select column A' }).textContent;
expect(header()).toBe('A');
view.element.scrollTop = 200;
fireEvent.scroll(view.element);
expect(header()).toBe('Item');
view.controller.select({ row: 60, column: 0 });
expect(header()).toBe('A');
});
});