Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

Fix spreadsheet keyboard, formatting, and cross-sheet editing (#6600)

Jacob Beckerman8b2137f4d7ff
diff --git a/apps/web/src/components/view-shell/ViewBreadcrumbs.test.tsx b/apps/web/src/components/view-shell/ViewBreadcrumbs.test.tsx
new file mode 100644
index 0000000000..0a20d7471b
--- /dev/null
+++ b/apps/web/src/components/view-shell/ViewBreadcrumbs.test.tsx
@@ -0,0 +1,79 @@
+import {
+ cleanup,
+ fireEvent,
+ render,
+ screen,
+ within,
+} from '@solidjs/testing-library';
+import {
+ createContext,
+ createSignal,
+ onCleanup,
+ Show,
+ useContext,
+} from 'solid-js';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { ViewBreadcrumbs } from './ViewBreadcrumbs';
+
+vi.mock('@ui', async () => ({
+ ...(await import('../ui/utils/classname')),
+}));
+
+afterEach(cleanup);
+
+describe('breadcrumb outlet transitions', () => {
+ it.each(['My Files', 'Financial Models'])(
+ 'keeps %s visible and clickable when the previous header unmounts',
+ (label) => {
+ const onChange = vi.fn();
+ const [oldHeader, setOldHeader] = createSignal(true);
+ const [preview, setPreview] = createSignal(false);
+ const Label = createContext('Missing location');
+
+ const disposed = vi.fn();
+ function Location(props: { onSelect: () => void }) {
+ const name = useContext(Label);
+ onCleanup(disposed);
+ return <button onClick={props.onSelect}>{name}</button>;
+ }
+
+ render(() => (
+ <ViewBreadcrumbs.Root value="sheet" onChange={onChange}>
+ <Label.Provider value={label}>
+ <ViewBreadcrumbs.Item value="location" metadata={{}}>
+ {(item) => <Location onSelect={item.onSelect} />}
+ </ViewBreadcrumbs.Item>
+ </Label.Provider>
+ <Show when={oldHeader()}>
+ <ViewBreadcrumbs.Outlet aria-label="List location" />
+ </Show>
+ <Show when={preview()}>
+ <ViewBreadcrumbs.Outlet aria-label="Sheet location" />
+ </Show>
+ </ViewBreadcrumbs.Root>
+ ));
+
+ // The preview mounts while the outgoing list header still exists.
+ setPreview(true);
+ expect(
+ within(
+ screen.getByRole('navigation', { name: 'List location' })
+ ).getByRole('button', { name: label })
+ ).toBeTruthy();
+ setOldHeader(false);
+ const location = () =>
+ within(
+ screen.getByRole('navigation', { name: 'Sheet location' })
+ ).getByRole('button', { name: label });
+ fireEvent.click(location());
+ expect(onChange).toHaveBeenCalledWith('location');
+ expect(disposed).toHaveBeenCalledTimes(1);
+
+ // Reopening the sheet creates a new header with the same registration.
+ setPreview(false);
+ expect(disposed).toHaveBeenCalledTimes(2);
+ setPreview(true);
+ expect(location()).toBeTruthy();
+ }
+ );
+});
diff --git a/apps/web/src/components/view-shell/ViewBreadcrumbs.tsx b/apps/web/src/components/view-shell/ViewBreadcrumbs.tsx
index 9b8e2c8a94..d3810eefa8 100644
--- a/apps/web/src/components/view-shell/ViewBreadcrumbs.tsx
+++ b/apps/web/src/components/view-shell/ViewBreadcrumbs.tsx
@@ -2,10 +2,11 @@ import CaretRightIcon from '@phosphor/caret-right.svg';
import { cn, Tooltip } from '@ui';
import {
type Accessor,
- children,
createContext,
createMemo,
+ createRoot,
For,
+ getOwner,
type JSX,
onCleanup,
onMount,
@@ -183,10 +184,19 @@ function Item<TMetadata = unknown>(props: ViewBreadcrumbsItemProps<TMetadata>) {
isActive: () => context.value() === props.value,
onSelect: () => context.onChange(props.value),
};
- const resolvedChildren = children(() => {
- const child = props.children;
- return <>{typeof child === 'function' ? child(state) : child}</>;
- });
+ const owner = getOwner();
+ const render = () => {
+ let dispose!: () => void;
+ // Outlets can overlap during navigation. Each needs its own DOM, while
+ // retaining the item's provider context and the outlet's cleanup lifetime.
+ const content = createRoot((cleanup) => {
+ dispose = cleanup;
+ const child = props.children;
+ return <>{typeof child === 'function' ? child(state) : child}</>;
+ }, owner);
+ onCleanup(dispose);
+ return content;
+ };
let unregister: (() => void) | undefined;
onMount(() => {
@@ -194,7 +204,7 @@ function Item<TMetadata = unknown>(props: ViewBreadcrumbsItemProps<TMetadata>) {
value: () => props.value,
metadata: () => props.metadata,
order: () => props.order,
- render: resolvedChildren,
+ render,
});
});
onCleanup(() => unregister?.());
diff --git a/apps/web/src/features/block-spreadsheet/browser-test/README.md b/apps/web/src/features/block-spreadsheet/browser-test/README.md
index 1ffc9775f4..39dec89cd9 100644
--- a/apps/web/src/features/block-spreadsheet/browser-test/README.md
+++ b/apps/web/src/features/block-spreadsheet/browser-test/README.md
@@ -92,3 +92,7 @@ recovery and departing-user cleanup. It saves a visual capture to
`/tmp/spreadsheet-live-collaboration.png`. This does not verify hosted authentication
or permission-token refresh. The ordinary fixture remains local-only unless the
explicit test document/socket query parameters are supplied.
+
+## Editor interaction regressions
+
+`editor-interactions.browser.e2e.ts` mounts the real global hotkey listener to verify that selected-cell typing and arrows beat app navigation shortcuts. It also exercises multi-header drag/Shift selection, persistent row resizing and auto-fit, cross-sheet formula reference picking, and numeric/month-end date fill with undo. `formatting.browser.e2e.ts` checks mixed whole-column formatting, style persistence, viewport stability, and percentage entry through both editors against the real calculation worker.
diff --git a/apps/web/src/features/block-spreadsheet/browser-test/colors.browser.e2e.ts b/apps/web/src/features/block-spreadsheet/browser-test/colors.browser.e2e.ts
new file mode 100644
index 0000000000..6c3141a25e
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/browser-test/colors.browser.e2e.ts
@@ -0,0 +1,113 @@
+import { expect, test } from '@playwright/test';
+import ExcelJS from 'exceljs';
+
+test('imported black text and borders follow the theme without changing exported colors', async ({
+ page,
+}) => {
+ await page.goto('/?mentions&hotkeys');
+ await expect(page.locator('[data-address="B4"]')).toHaveText('30');
+ const input = new ExcelJS.Workbook();
+ const sheet = input.addWorksheet('Display colors');
+ const black = sheet.getCell('A1');
+ black.value = 'Imported heading';
+ black.font = { color: { argb: 'FF000000' }, bold: true };
+ black.border = { bottom: { style: 'thin', color: { argb: 'FF000000' } } };
+ const filled = sheet.getCell('A2');
+ filled.value = 'Intentional light fill';
+ filled.font = { color: { argb: 'FF000000' } };
+ filled.fill = {
+ type: 'pattern',
+ pattern: 'solid',
+ fgColor: { argb: 'FFFFF2CC' },
+ };
+ const header = sheet.getCell('A3');
+ header.value = 'Intentional dark header';
+ header.font = { color: { argb: 'FFFFFFFF' } };
+ header.fill = {
+ type: 'pattern',
+ pattern: 'solid',
+ fgColor: { argb: 'FF123456' },
+ };
+ const negative = sheet.getCell('A4');
+ negative.value = -100;
+ negative.font = { color: { argb: 'FFFF0000' } };
+
+ await page.getByLabel('Import spreadsheet file').setInputFiles({
+ name: 'display-colors.xlsx',
+ mimeType:
+ 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+ buffer: Buffer.from(await input.xlsx.writeBuffer()),
+ });
+ await page
+ .getByRole('button', { name: 'Import workbook', exact: true })
+ .click();
+ await expect(page.locator('[data-address="A1"]')).toHaveText(
+ 'Imported heading'
+ );
+ const stored = await page.evaluate(() =>
+ window.spreadsheetFixture.snapshot()
+ );
+ // Use explicit semantic tokens to exercise both palettes, independent of the
+ // browser's preferred theme or the fixture's default palette.
+ for (const [ink, surface] of [
+ ['#ffffff', '#111111'],
+ ['#000000', '#ffffff'],
+ ]) {
+ await page.locator('main').evaluate(
+ (element, colors) => {
+ element.style.setProperty('--color-ink', colors[0]);
+ element.style.setProperty('--color-surface', colors[1]);
+ },
+ [ink, surface]
+ );
+ const expected = ink === '#ffffff' ? 'rgb(255, 255, 255)' : 'rgb(0, 0, 0)';
+ await expect(page.locator('[data-address="A1"]')).toHaveCSS(
+ 'color',
+ expected
+ );
+ await expect(page.locator('[data-address="A1"]')).toHaveCSS(
+ 'border-bottom-color',
+ expected
+ );
+ await expect(page.locator('[data-address="A2"]')).toHaveCSS(
+ 'color',
+ 'rgb(0, 0, 0)'
+ );
+ await expect(page.locator('[data-address="A2"]')).toHaveCSS(
+ 'background-color',
+ 'rgb(255, 242, 204)'
+ );
+ await expect(page.locator('[data-address="A3"]')).toHaveCSS(
+ 'color',
+ 'rgb(255, 255, 255)'
+ );
+ await expect(page.locator('[data-address="A3"]')).toHaveCSS(
+ 'background-color',
+ 'rgb(18, 52, 86)'
+ );
+ await expect(page.locator('[data-address="A4"]')).toHaveCSS(
+ 'color',
+ 'rgb(255, 0, 0)'
+ );
+ expect(
+ await page.evaluate(() => window.spreadsheetFixture.snapshot())
+ ).toEqual(stored);
+ }
+ const downloaded = page.waitForEvent('download');
+ await page
+ .getByRole('button', { name: 'Import and export', exact: true })
+ .click();
+ await page
+ .getByRole('menuitem', { name: 'Download as Excel (.xlsx)', exact: true })
+ .click();
+ const path = await (await downloaded).path();
+ if (!path) throw new Error('Workbook download missing');
+ const output = new ExcelJS.Workbook();
+ await output.xlsx.readFile(path);
+ const exported = output.getWorksheet('Display colors')!;
+ expect(exported.getCell('A1').font.color?.argb).toBe('FF000000');
+ expect(exported.getCell('A1').border.bottom?.color?.argb).toBe('FF000000');
+ expect(exported.getCell('A2').font.color?.argb).toBe('FF000000');
+ expect(exported.getCell('A3').font.color?.argb).toBe('FFFFFFFF');
+ expect(exported.getCell('A4').font.color?.argb).toBe('FFFF0000');
+});
diff --git a/apps/web/src/features/block-spreadsheet/browser-test/editor-interactions.browser.e2e.ts b/apps/web/src/features/block-spreadsheet/browser-test/editor-interactions.browser.e2e.ts
new file mode 100644
index 0000000000..39655ad0c2
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/browser-test/editor-interactions.browser.e2e.ts
@@ -0,0 +1,223 @@
+import { expect, type Locator, type Page, test } from '@playwright/test';
+
+async function drag(page: Page, from: Locator, to: Locator) {
+ const start = await from.boundingBox();
+ const end = await to.boundingBox();
+ if (!start || !end) throw new Error('Drag endpoints must be visible');
+ await page.mouse.move(start.x + start.width / 2, start.y + start.height / 2);
+ await page.mouse.down();
+ await page.mouse.move(end.x + end.width / 2, end.y + end.height / 2, {
+ steps: 8,
+ });
+ await page.mouse.up();
+}
+
+async function edit(page: Page, address: string, value: string) {
+ await page.locator(`[data-address="${address}"]`).dblclick();
+ const input = page.getByRole('textbox', {
+ name: `Edit ${address}`,
+ exact: true,
+ });
+ await input.fill(value);
+ await input.press('Enter');
+}
+
+test.beforeEach(async ({ page }) => {
+ await page.goto('/?hotkeys&mentions');
+ await expect(page.locator('[data-address="B4"]')).toHaveText('30');
+});
+
+test('selected cells own typing and arrow keys before app capture-phase shortcuts', async ({
+ page,
+}) => {
+ const grid = page.getByRole('grid', { name: 'Spreadsheet' });
+ const address = page.getByRole('textbox', { name: 'Go to cell' });
+ await page.locator('[data-address="D2"]').click();
+ await grid.press('h');
+ const input = page.getByRole('textbox', { name: 'Edit D2', exact: true });
+ await expect(input).toHaveText('h');
+ await input.press('Enter');
+ await expect(address).toHaveValue('D3');
+ await grid.press('ArrowDown');
+ await expect(address).toHaveValue('D4');
+ await grid.press('ArrowRight');
+ await expect(address).toHaveValue('E4');
+ expect(
+ await page.evaluate(() => window.spreadsheetFixture.globalShortcutCount())
+ ).toBe(0);
+ // The same shortcut remains active when the spreadsheet relinquishes focus.
+ await page.getByRole('button', { name: 'Add sheet', exact: true }).focus();
+ await page.keyboard.press('h');
+ expect(
+ await page.evaluate(() => window.spreadsheetFixture.globalShortcutCount())
+ ).toBe(1);
+});
+
+test('selects multiple rows and columns by dragging and shift-clicking headers', async ({
+ page,
+}) => {
+ const address = page.getByRole('textbox', { name: 'Go to cell' });
+ const header = (name: string) =>
+ page.getByRole('button', { name, exact: true });
+ await drag(page, header('Select column B'), header('Select column D'));
+ await expect(address).toHaveValue('B1:D200');
+ await header('Select column F').click({ modifiers: ['Shift'] });
+ await expect(address).toHaveValue('B1:F200');
+ await page.getByRole('grid', { name: 'Spreadsheet' }).press('ArrowRight');
+ await expect(address).toHaveValue('C1');
+ await drag(page, header('Select row 3'), header('Select row 5'));
+ await expect(address).toHaveValue('A3:Z5');
+ await header('Select row 7').click({ modifiers: ['Shift'] });
+ await expect(address).toHaveValue('A3:Z7');
+ await page.getByRole('grid', { name: 'Spreadsheet' }).press('ArrowDown');
+ await expect(address).toHaveValue('A4');
+});
+
+test('resizes row height with a pointer, saves it, and restores automatic height', async ({
+ page,
+}) => {
+ const grip = page.getByRole('separator', {
+ name: 'Resize row 2',
+ exact: true,
+ });
+ const box = await grip.boundingBox();
+ if (!box) throw new Error('Resize grip missing');
+ await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+ await page.mouse.down();
+ await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2 + 50, {
+ steps: 8,
+ });
+ await page.mouse.up();
+ await expect(grip).toHaveAttribute('aria-valuenow', '71');
+ expect(
+ await page.evaluate(
+ () => window.spreadsheetFixture.snapshot()[0].metadata?.rowHeights?.[1]
+ )
+ ).toBe(53.25);
+ await page.locator('[data-address="A2"]').click();
+ await page.getByRole('grid', { name: 'Spreadsheet' }).press('ArrowDown');
+ await expect(page.getByRole('textbox', { name: 'Go to cell' })).toHaveValue(
+ 'A3'
+ );
+ await grip.dblclick();
+ await expect(grip).toHaveAttribute('aria-valuenow', '21');
+ expect(
+ await page.evaluate(
+ () => window.spreadsheetFixture.snapshot()[0].metadata?.rowHeights?.[1]
+ )
+ ).toBeUndefined();
+});
+
+test('picks a range on a second sheet and commits the formula back to its original cell', async ({
+ page,
+}) => {
+ await page.getByRole('button', { name: 'Add sheet', exact: true }).click();
+ await edit(page, 'A1', '12');
+ await edit(page, 'A2', '18');
+ await page.getByRole('tab', { name: 'Sheet2', exact: true }).dblclick();
+ await page.getByRole('textbox', { name: 'Sheet name' }).fill('Forecast 2027');
+ await page.getByRole('button', { name: 'Save name' }).click();
+ await page.getByRole('tab', { name: 'Sheet1', exact: true }).click();
+ await page.locator('[data-address="C2"]').dblclick();
+ await page
+ .getByRole('textbox', { name: 'Edit C2', exact: true })
+ .fill('=SUM(');
+ await page.getByRole('tab', { name: 'Forecast 2027', exact: true }).click();
+ await expect(
+ page.getByRole('textbox', { name: 'Formula bar', exact: true })
+ ).toHaveValue('=SUM(');
+ await drag(
+ page,
+ page.locator('[data-address="A1"]'),
+ page.locator('[data-address="A2"]')
+ );
+ const formula = page.getByRole('textbox', {
+ name: 'Formula bar',
+ exact: true,
+ });
+ await expect(formula).toHaveValue("=SUM('Forecast 2027'!A1:A2");
+ await expect(formula).toBeFocused();
+ await formula.press(')');
+ await formula.press('Enter');
+ await expect(
+ page.getByRole('tab', { name: 'Sheet1', exact: true })
+ ).toHaveAttribute('aria-selected', 'true');
+ await expect(page.locator('[data-address="C2"]')).toHaveText('30');
+ const sheets = await page.evaluate(() =>
+ window.spreadsheetFixture.snapshot()
+ );
+ expect(sheets[0].cells.C2.value).toBe("=SUM('Forecast 2027'!A1:A2)");
+ expect(sheets[1].cells.A1.value).toBe('12');
+});
+
+test('drag fill continues numbers and month-end dates and undo restores the empty destination', async ({
+ page,
+}) => {
+ for (let row = 1; row <= 4; row++) await edit(page, `D${row}`, String(row));
+ await drag(
+ page,
+ page.locator('[data-address="D1"]'),
+ page.locator('[data-address="D4"]')
+ );
+ await drag(
+ page,
+ page.getByRole('button', { name: 'Drag to fill selection' }),
+ page.locator('[data-address="D8"]')
+ );
+ await expect(page.locator('[data-address="D8"]')).toHaveText('8');
+ await page
+ .getByRole('grid', { name: 'Spreadsheet' })
+ .press('ControlOrMeta+z');
+ await expect(page.locator('[data-address="D8"]')).toHaveText('');
+ await edit(page, 'E1', '2026-01-31');
+ await edit(page, 'E2', '2026-02-28');
+ await drag(
+ page,
+ page.locator('[data-address="E1"]'),
+ page.locator('[data-address="E2"]')
+ );
+ await drag(
+ page,
+ page.getByRole('button', { name: 'Drag to fill selection' }),
+ page.locator('[data-address="E4"]')
+ );
+ const cells = await page.evaluate(
+ () => window.spreadsheetFixture.snapshot()[0].cells
+ );
+ expect(cells.E3.value).toBe('2026-03-31');
+ expect(cells.E4.value).toBe('2026-04-30');
+});
+
+test('types a spaced formula, picks another sheet by pointer, and returns to the source', async ({
+ page,
+}) => {
+ await page.getByRole('button', { name: 'Add sheet', exact: true }).click();
+ await edit(page, 'A1', '20');
+ await page.getByRole('tab', { name: 'Sheet1', exact: true }).click();
+ await page.locator('[data-address="C2"]').click();
+ await page.keyboard.type('= b2 + ');
+ await expect(
+ page.getByRole('textbox', { name: 'Edit C2', exact: true })
+ ).toHaveValue('= b2 + ');
+ await page.getByRole('tab', { name: 'Sheet2', exact: true }).click();
+ await page.locator('[data-address="A1"]').click();
+ const formula = page.getByRole('textbox', {
+ name: 'Formula bar',
+ exact: true,
+ });
+ await expect(formula).toHaveValue("= b2 + 'Sheet2'!A1");
+ await expect(formula).toBeFocused();
+ await page.keyboard.press('Enter');
+ await expect(
+ page.getByRole('tab', { name: 'Sheet1', exact: true })
+ ).toHaveAttribute('aria-selected', 'true');
+ await expect(page.locator('[data-address="C2"]')).toHaveText('30');
+ expect(
+ await page.evaluate(
+ () => window.spreadsheetFixture.snapshot()[0].cells.C2.value
+ )
+ ).toBe("= b2 + 'Sheet2'!A1");
+ expect(
+ await page.evaluate(() => window.spreadsheetFixture.globalShortcutCount())
+ ).toBe(0);
+});
diff --git a/apps/web/src/features/block-spreadsheet/browser-test/fixture.tsx b/apps/web/src/features/block-spreadsheet/browser-test/fixture.tsx
index d43e544f1d..622850ab17 100644
--- a/apps/web/src/features/block-spreadsheet/browser-test/fixture.tsx
+++ b/apps/web/src/features/block-spreadsheet/browser-test/fixture.tsx
@@ -2,6 +2,7 @@ import '@fontsource-variable/inter';
import '@fontsource-variable/roboto-mono';
import '../../../index.css';
import { useAppSquishHandlers } from '@components/app/useAppSquishHandlers';
+import { registerHotkey, useHotKeyRoot } from '@core/hotkey/hotkeys';
import { isTouchDevice } from '@core/mobile/isTouchDevice';
import { createSyncSocket } from '@macro-inc/collaboration/sync-service/socket';
import {
@@ -28,6 +29,7 @@ declare global {
snapshot: () => SpreadsheetWorkbookSheet[];
setReadonly: (readonly: boolean) => void;
connectionStatus: () => string;
+ globalShortcutCount: () => number;
};
}
}
@@ -51,6 +53,19 @@ function Fixture() {
new URLSearchParams(location.search).has('readonly')
);
const params = new URLSearchParams(location.search);
+ const [globalShortcutCount, setGlobalShortcutCount] = createSignal(0);
+ if (params.has('hotkeys')) {
+ useHotKeyRoot();
+ registerHotkey({
+ scopeId: 'global',
+ hotkey: ['h', 'arrowdown'],
+ description: 'Fixture app navigation',
+ keyDownHandler: () => {
+ setGlobalShortcutCount((count) => count + 1);
+ return true;
+ },
+ });
+ }
const documentId = params.get('document');
const socketUrl = params.get('socket');
const socket =
@@ -84,6 +99,7 @@ function Fixture() {
snapshot: () => structuredClone(store.workbook()),
setReadonly,
connectionStatus: source.status,
+ globalShortcutCount,
};
onCleanup(() => {
// Revoke the fixture bridge when Vite unmounts this owner during HMR.
diff --git a/apps/web/src/features/block-spreadsheet/browser-test/formatting.browser.e2e.ts b/apps/web/src/features/block-spreadsheet/browser-test/formatting.browser.e2e.ts
new file mode 100644
index 0000000000..aa57889d6c
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/browser-test/formatting.browser.e2e.ts
@@ -0,0 +1,156 @@
+import { expect, type Page, test } from '@playwright/test';
+
+async function choose(page: Page, label: string, choice: string) {
+ await page.getByRole('button', { name: label, exact: true }).click();
+ await page.getByRole('menuitem', { name: choice, exact: true }).click();
+}
+
+test.beforeEach(async ({ page }) => {
+ await page.goto('/?mentions&hotkeys');
+ await expect(page.locator('[data-address="B4"]')).toHaveText('30');
+});
+
+test('formats a mixed whole column from ribbon menus without losing selection or scrolling to its bottom', async ({
+ page,
+}) => {
+ const grid = page.getByRole('grid', { name: 'Spreadsheet' });
+ const top = page.locator('[data-address="A1"]');
+ const body = page.locator('[data-address="A2"]');
+ await expect(top).toHaveCSS('font-weight', '600');
+ await expect(body).toHaveCSS('font-weight', '400');
+ await page
+ .getByRole('button', { name: 'Select column A', exact: true })
+ .click();
+ await expect(
+ page.getByRole('button', { name: 'Bold', exact: true })
+ ).toHaveAttribute('aria-pressed', 'false');
+ await page.getByRole('button', { name: 'Bold', exact: true }).click();
+ await expect(body).toHaveCSS('font-weight', '600');
+ await expect(top).toBeInViewport();
+
+ await choose(page, 'Fill color', 'Fill color: Light yellow');
+ await expect(body).toHaveCSS('background-color', 'rgb(255, 242, 204)');
+ await choose(page, 'Text color', 'Text color: Charcoal');
+ await expect(body).toHaveCSS('color', 'rgb(67, 67, 67)');
+ await choose(page, 'Font family', 'Serif');
+ await expect(body).toHaveCSS('font-family', /Georgia/);
+ await choose(page, 'Borders', 'All borders');
+ await expect(body).toHaveCSS('border-top-style', 'solid');
+ await expect(body).toHaveCSS('border-left-style', 'solid');
+ await expect(grid).toBeFocused();
+ await expect(top).toBeInViewport();
+ await expect(page.getByRole('textbox', { name: 'Go to cell' })).toHaveValue(
+ 'A1:A200'
+ );
+
+ const saved = await page.evaluate(
+ () => window.spreadsheetFixture.snapshot()[0].cells
+ );
+ for (const address of ['A1', 'A2', 'A200']) {
+ expect(saved[address]).toMatchObject({
+ bold: true,
+ fontFamily: 'serif',
+ fillColor: '#fff2cc',
+ textColor: '#434343',
+ borderTop: true,
+ borderBottom: true,
+ borderLeft: true,
+ borderRight: true,
+ });
+ }
+ await grid.press('ControlOrMeta+b');
+ await expect(body).toHaveCSS('font-weight', '400');
+ await expect(top).toBeInViewport();
+});
+
+test('treats direct typing and formula-bar edits as percentage points while preserving formula math', async ({
+ page,
+}) => {
+ const cell = page.locator('[data-address="D2"]');
+ await cell.click();
+ await page
+ .getByRole('button', { name: 'Format as percent', exact: true })
+ .click();
+ await page.getByRole('grid', { name: 'Spreadsheet' }).press('5');
+ const editor = page.getByRole('textbox', { name: 'Edit D2', exact: true });
+ await expect(editor).toHaveText('5');
+ await editor.press('Enter');
+ await expect(cell).toHaveText('5%');
+
+ await cell.click();
+ const formula = page.getByRole('textbox', {
+ name: 'Formula bar',
+ exact: true,
+ });
+ await formula.click();
+ await formula.fill('7.5');
+ await formula.press('Enter');
+ await expect(cell).toHaveText('7.5%');
+ await cell.dblclick();
+ await expect(editor).toHaveText('7.5%');
+ await editor.press('Enter');
+ await expect(cell).toHaveText('7.5%');
+
+ await page.locator('[data-address="E2"]').dblclick();
+ const result = page.getByRole('textbox', { name: 'Edit E2', exact: true });
+ await result.fill('=D2*1000');
+ await result.press('Enter');
+ await expect(page.locator('[data-address="E2"]')).toHaveText('75');
+});
+
+test('edits formula-bar text and formulas directly with the production mention editor enabled', async ({
+ page,
+}) => {
+ await page.goto('/?mentions');
+ await expect(page.locator('[data-address="B4"]')).toHaveText('30');
+ const formula = page.getByRole('textbox', {
+ name: 'Formula bar',
+ exact: true,
+ });
+
+ await page.locator('[data-address="A2"]').click();
+ await formula.click();
+ await expect(formula).toBeFocused();
+ await expect(formula).toHaveText('Design');
+ await formula.press('End');
+ await formula.pressSequentially(' team');
+ await formula.press('Enter');
+ await expect(page.locator('[data-address="A2"]')).toHaveText('Design team');
+
+ await page.locator('[data-address="B4"]').click();
+ await formula.click();
+ await expect(formula).toBeFocused();
+ await expect(formula).toHaveValue('=SUM(B2:B3)');
+ await formula.press('End');
+ await formula.pressSequentially('+5');
+ await formula.press('Enter');
+ await expect(page.locator('[data-address="B4"]')).toHaveText('35');
+
+ await page.locator('[data-address="C2"]').click();
+ await formula.click();
+ // Typing '=' replaces the mention editor with the formula textarea. Focus
+ // and the rest of the keystrokes must follow that replacement.
+ await page.keyboard.type('=B2*3');
+ await expect(formula).toBeFocused();
+ await expect(formula).toHaveValue('=B2*3');
+ await formula.press('Enter');
+ await expect(page.locator('[data-address="C2"]')).toHaveText('30');
+});
+
+test('applies ribbon controls while the production cell editor has an uncommitted draft', async ({
+ page,
+}) => {
+ await page.locator('[data-address="D2"]').click();
+ await page.keyboard.type('Draft text');
+ await choose(page, 'Fill color', 'Fill color: Light yellow');
+ const cell = page.locator('[data-address="D2"]');
+ await expect(cell).toHaveText('Draft text');
+ await expect(cell).toHaveCSS('background-color', 'rgb(255, 242, 204)');
+ await choose(page, 'Font family', 'Serif');
+ await expect(cell).toHaveCSS('font-family', /Georgia/);
+ await choose(page, 'Borders', 'All borders');
+ await expect(cell).toHaveCSS('border-top-style', 'solid');
+ await page.getByRole('button', { name: 'Bold', exact: true }).click();
+ await expect(cell).toHaveCSS('font-weight', '600');
+ await expect(page.getByRole('grid', { name: 'Spreadsheet' })).toBeFocused();
+});
diff --git a/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.test.tsx b/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.test.tsx
index 754194d886..c32ce593d4 100644
--- a/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.test.tsx
+++ b/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.test.tsx
@@ -784,6 +784,31 @@ describe('spreadsheet presentation', () => {
);
});
+ 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(
diff --git a/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.tsx b/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.tsx
index 7ad8668527..1d62a66017 100644
--- a/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.tsx
+++ b/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.tsx
@@ -35,6 +35,7 @@ import {
} from '../core/spreadsheet-document';
import type { SpreadsheetCursor } from '../core/spreadsheet-presence';
import type { CompleteFormula } from '../primitives/create-formula-assistance';
+import { cellBorderColor, cellForeground } from './cell-colors';
import { FormulaInput } from './FormulaInput';
import { type CellAction, SpreadsheetCellMenu } from './SpreadsheetCellMenu';
import {
@@ -117,7 +118,11 @@ export function SpreadsheetGrid(props: {
showGridlines?: boolean;
showFormulas?: boolean;
onResizeColumn?: (column: number, width: number) => void;
- onFill?: (source: CellSelection, target: CellSelection) => void;
+ onResizeRow?: (row: number, height: number | undefined) => void;
+ onFill?: (
+ source: CellSelection,
+ target: CellSelection
+ ) => void | Promise<void>;
onCopyMetadata?: (cut?: boolean) => string;
values: Record<string, GridValue>;
remoteCursors: SpreadsheetCursor[];
@@ -164,7 +169,14 @@ export function SpreadsheetGrid(props: {
width: number;
}>();
let fillSource: CellSelection | undefined;
+ let fillGeneration = 0;
let resizeStart: { x: number; width: number } | undefined;
+ const [resizingRow, setResizingRow] = createSignal<{
+ row: number;
+ height: number;
+ }>();
+ let rowResizeStart: { y: number; height: number } | undefined;
+ let headerDrag: { axis: 'row' | 'column'; anchor: number } | undefined;
let touchGesture:
| {
kind: 'tap';
@@ -193,11 +205,17 @@ export function SpreadsheetGrid(props: {
? resizing()!.width
: (props.columnWidths?.[column] ?? DEFAULT_COLUMN_WIDTH);
const width = (column: number) => `${columnWidth(column) * scale()}px`;
- const display = (address: string) =>
- props.showFormulas && props.cells[address]?.value.startsWith('=')
- ? props.cells[address].value
- : (props.values[address]?.display ??
- cellPlainText(props.cells[address]?.value ?? ''));
+ const display = (address: string) => {
+ const cell = props.cells[address];
+ const formula = cell?.value.startsWith('=') && cell.format !== 'text';
+ if (props.showFormulas && formula) return cell.value;
+ // Newly filled formulas have no cached result yet. Keep them blank until
+ // calculation finishes instead of briefly flashing the formula expression.
+ return (
+ props.values[address]?.display ??
+ (formula ? '' : cellPlainText(cell?.value ?? ''))
+ );
+ };
const rootStyle = getComputedStyle(document.documentElement);
const fontFamilies = {
sans: rootStyle.getPropertyValue('--font-sans') || 'sans-serif',
@@ -216,13 +234,20 @@ export function SpreadsheetGrid(props: {
: document.createElement('canvas').getContext('2d');
const rowHeights = createMemo(() => {
const heights = Array.from({ length: rowCount() }, (_, row) =>
- Math.max(ROW_HEIGHT, ((props.rowHeights?.[row] ?? 0) * 4) / 3)
+ resizingRow()?.row === row
+ ? resizingRow()!.height
+ : Math.max(ROW_HEIGHT, ((props.rowHeights?.[row] ?? 0) * 4) / 3)
);
// Gridlines stay one CSS pixel wide when the workbook is zoomed.
const borderInset = 1 / scale();
for (const [address, cell] of Object.entries(props.cells)) {
const position = parseCellAddress(address);
if (!position || position.row >= heights.length) continue;
+ if (
+ props.rowHeights?.[position.row] !== undefined ||
+ resizingRow()?.row === position.row
+ )
+ continue;
const pixels = fontPixels(cell);
const lineHeight = pixels * CELL_LINE_HEIGHT;
const verticalInset = CELL_PADDING_Y * 2 + borderInset;
@@ -369,29 +394,44 @@ export function SpreadsheetGrid(props: {
tapCell(gesture.tapPosition, event.timeStamp);
}
dragging = false;
+ headerDrag = undefined;
props.onReferenceEnd?.();
const target = fillTarget();
- if (fillSource && target && !props.readonly)
- props.onFill?.(fillSource, target);
+ const source = fillSource;
fillSource = undefined;
- setFillTarget(undefined);
+ if (source && target && !props.readonly) {
+ const generation = ++fillGeneration;
+ // Keep the preview until formula relocation has committed the new cells.
+ void Promise.resolve(props.onFill?.(source, target)).finally(() => {
+ if (generation === fillGeneration) setFillTarget(undefined);
+ });
+ }
const resize = resizing();
if (resize && !props.readonly)
props.onResizeColumn?.(resize.column, resize.width);
setResizing(undefined);
resizeStart = undefined;
+ const rowResize = resizingRow();
+ if (rowResize && !props.readonly)
+ props.onResizeRow?.(rowResize.row, rowResize.height);
+ setResizingRow(undefined);
+ rowResizeStart = undefined;
}
function cancelPointer() {
stopTouchGesture();
lastTap = undefined;
dragging = false;
+ headerDrag = undefined;
keepReferenceFocus = false;
props.onReferenceEnd?.();
fillSource = undefined;
+ fillGeneration++;
setFillTarget(undefined);
setResizing(undefined);
resizeStart = undefined;
+ setResizingRow(undefined);
+ rowResizeStart = undefined;
}
function previewFill(position: CellPosition) {
@@ -459,6 +499,34 @@ export function SpreadsheetGrid(props: {
target instanceof HTMLTextAreaElement ||
(target instanceof HTMLElement && !!target.closest('[contenteditable]'));
const focusGrid = () => grid.focus({ preventScroll: true });
+ const selectHeaderRange = (
+ axis: 'row' | 'column',
+ index: number,
+ anchor = index
+ ) => {
+ if (axis === 'row')
+ props.onSelectRange(
+ { row: anchor, column: 0 },
+ { row: index, column: GRID_COLUMNS - 1 }
+ );
+ else
+ props.onSelectRange(
+ { row: 0, column: anchor },
+ { row: rowCount() - 1, column: index }
+ );
+ focusGrid();
+ };
+ const startHeader = (
+ event: PointerEvent,
+ axis: 'row' | 'column',
+ index: number
+ ) => {
+ if (event.button !== 0 || event.ctrlKey) return;
+ event.preventDefault();
+ const anchor = event.shiftKey ? props.selection.anchor[axis] : index;
+ headerDrag = { axis, anchor };
+ selectHeaderRange(axis, index, anchor);
+ };
function positionAtPoint(x: number, y: number): CellPosition {
const rect = grid.getBoundingClientRect();
@@ -504,6 +572,15 @@ export function SpreadsheetGrid(props: {
}
function movePointer(event: PointerEvent) {
+ if (headerDrag && event.buttons === 1) {
+ const position = positionAtPoint(event.clientX, event.clientY);
+ selectHeaderRange(
+ headerDrag.axis,
+ position[headerDrag.axis],
+ headerDrag.anchor
+ );
+ return;
+ }
const gesture = touchGesture;
if (!gesture || gesture.pointerId !== event.pointerId) return;
if (gesture.kind === 'tap') {
@@ -734,6 +811,7 @@ export function SpreadsheetGrid(props: {
setScrollElement(element);
}}
role="grid"
+ data-keyboard-input
aria-label="Spreadsheet"
aria-rowcount={rowCount() + 1}
aria-colcount={GRID_COLUMNS + 1}
@@ -792,8 +870,14 @@ export function SpreadsheetGrid(props: {
openCellMenu(rect.left + Math.min(rect.width, 24), rect.bottom);
return;
}
+ const previous = props.selection.focus;
props.onKeyDown(event);
- if (!props.editing) revealSelection();
+ if (
+ !props.editing &&
+ (previous.row !== props.selection.focus.row ||
+ previous.column !== props.selection.focus.column)
+ )
+ revealSelection();
}}
onCopy={(event) => {
if (isInput(event.target)) return;
@@ -899,12 +983,18 @@ export function SpreadsheetGrid(props: {
tabIndex={-1}
aria-label={`Select column ${String.fromCharCode(65 + column)}`}
class="size-full hover:bg-hover"
- onClick={() => {
- props.onSelectRange(
- { row: 0, column },
- { row: rowCount() - 1, column }
- );
- focusGrid();
+ onPointerDown={(event) =>
+ startHeader(event, 'column', column)
+ }
+ onClick={(event) => {
+ if (event.detail === 0)
+ selectHeaderRange(
+ 'column',
+ column,
+ event.shiftKey
+ ? props.selection.anchor.column
+ : column
+ );
}}
>
{String.fromCharCode(65 + column)}
@@ -1016,17 +1106,89 @@ export function SpreadsheetGrid(props: {
tabIndex={-1}
aria-label={`Select row ${row + 1}`}
class="size-full hover:bg-hover"
- onClick={() => {
- props.onSelectRange(
- { row, column: 0 },
- { row, column: GRID_COLUMNS - 1 }
- );
- focusGrid();
+ onPointerDown={(event) =>
+ startHeader(event, 'row', row)
+ }
+ onClick={(event) => {
+ if (event.detail === 0)
+ selectHeaderRange(
+ 'row',
+ row,
+ event.shiftKey ? props.selection.anchor.row : row
+ );
}}
>
{row + 1}
</button>
</SpreadsheetHeaderMenu>
+ <Show when={!props.readonly && props.onResizeRow}>
+ <div
+ role="separator"
+ aria-label={`Resize row ${row + 1}`}
+ aria-orientation="horizontal"
+ aria-valuenow={rowHeights()[row] / scale()}
+ aria-valuemin={ROW_HEIGHT}
+ aria-valuemax={1000}
+ tabIndex={0}
+ title="Drag to resize · Double-click to fit"
+ class="absolute -bottom-1 left-0 z-[1] h-2 w-full touch-none cursor-row-resize hover:bg-accent/30 focus-visible:bg-accent/30 outline-none"
+ onPointerDown={(event) => {
+ if (event.button !== 0) return;
+ event.preventDefault();
+ event.stopPropagation();
+ rowResizeStart = {
+ y: event.clientY,
+ height: rowHeights()[row] / scale(),
+ };
+ setResizingRow({
+ row,
+ height: rowResizeStart.height,
+ });
+ event.currentTarget.setPointerCapture(
+ event.pointerId
+ );
+ }}
+ onPointerMove={(event) => {
+ if (!rowResizeStart || resizingRow()?.row !== row)
+ return;
+ setResizingRow({
+ row,
+ height: Math.max(
+ ROW_HEIGHT,
+ Math.min(
+ 1000,
+ rowResizeStart.height +
+ (event.clientY - rowResizeStart.y) / scale()
+ )
+ ),
+ });
+ }}
+ onDblClick={() => props.onResizeRow?.(row, undefined)}
+ onKeyDown={(event) => {
+ event.stopPropagation();
+ if (event.key === 'Enter') {
+ event.preventDefault();
+ props.onResizeRow?.(row, undefined);
+ } else if (
+ event.key === 'ArrowUp' ||
+ event.key === 'ArrowDown'
+ ) {
+ event.preventDefault();
+ props.onResizeRow?.(
+ row,
+ Math.max(
+ ROW_HEIGHT,
+ Math.min(
+ 1000,
+ rowHeights()[row] / scale() +
+ (event.key === 'ArrowDown' ? 8 : -8)
+ )
+ )
+ );
+ }
+ }}
+ />
+ </Show>
</div>
<For each={columns()}>
{(column) => {
@@ -1055,7 +1217,7 @@ export function SpreadsheetGrid(props: {
: style === 'dotted'
? 'dotted'
: 'solid';
- return `${width}px ${line} ${cell()?.[`border${edge}Color`] || 'var(--color-ink)'}`;
+ return `${width}px ${line} ${cellBorderColor(cell()?.[`border${edge}Color`], cell()?.fillColor)}`;
};
const horizontalAlign = () => {
const align = cell()?.horizontalAlign;
@@ -1129,7 +1291,10 @@ export function SpreadsheetGrid(props: {
: undefined),
'border-left': border('Left'),
'background-color': cell()?.fillColor || undefined,
- color: cell()?.textColor || undefined,
+ color: cellForeground(
+ cell()?.textColor,
+ cell()?.fillColor
+ ),
'font-family': fontFamily(cell()),
'font-size': `${fontPixels(cell()) * scale()}px`,
'font-style': cell()?.italic ? 'italic' : undefined,
@@ -1251,7 +1416,9 @@ export function SpreadsheetGrid(props: {
value={props.draft}
onInput={props.onDraft}
onKeyDown={editKeyDown}
- onBlur={props.onCommit}
+ onBlur={() => {
+ if (props.editing) props.onCommit();
+ }}
/>
</Show>
<Show when={props.comments?.hasComment(address)}>
@@ -1376,6 +1543,7 @@ export function SpreadsheetGrid(props: {
event.preventDefault();
event.stopPropagation();
props.onCommit();
+ fillGeneration++;
fillSource = props.selection;
setFillTarget(props.selection);
focusGrid();
diff --git a/apps/web/src/features/block-spreadsheet/components/SpreadsheetSheetTabs.tsx b/apps/web/src/features/block-spreadsheet/components/SpreadsheetSheetTabs.tsx
index 5aa2bcd897..7bd6d6d204 100644
--- a/apps/web/src/features/block-spreadsheet/components/SpreadsheetSheetTabs.tsx
+++ b/apps/web/src/features/block-spreadsheet/components/SpreadsheetSheetTabs.tsx
@@ -16,6 +16,7 @@ export type SpreadsheetSheetTabsProps = {
activeSheetId: string;
readonly: boolean;
canAdd: boolean;
+ preserveEditorFocus?: boolean;
onSelect: (id: string) => void;
onAdd: () => void;
onRename: (id: string) => void;
@@ -197,6 +198,14 @@ export function SpreadsheetSheetTabs(props: SpreadsheetSheetTabsProps) {
'border-transparent text-ink-muted':
props.activeSheetId !== sheet.id,
}}
+ onPointerDown={(event) => {
+ if (props.preserveEditorFocus && event.button === 0)
+ event.preventDefault();
+ }}
+ onMouseDown={(event) => {
+ if (props.preserveEditorFocus && event.button === 0)
+ event.preventDefault();
+ }}
onClick={() => props.onSelect(sheet.id)}
onDblClick={() => {
if (!props.readonly) props.onRename(sheet.id);
diff --git a/apps/web/src/features/block-spreadsheet/components/cell-colors.test.ts b/apps/web/src/features/block-spreadsheet/components/cell-colors.test.ts
new file mode 100644
index 0000000000..e36f4eada5
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/components/cell-colors.test.ts
@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest';
+import { cellBorderColor, cellForeground } from './cell-colors';
+
+describe('workbook display colors', () => {
+ it('uses themed ink for automatic or Excel black text on unfilled cells', () => {
+ expect(cellForeground()).toBeUndefined();
+ expect(cellForeground('#000000')).toBe('var(--color-ink)');
+ expect(cellForeground('#000000', '')).toBe('var(--color-ink)');
+ expect(cellBorderColor('#000000')).toBe('var(--color-ink)');
+ });
+
+ it('preserves intentional text, fill and border colors', () => {
+ expect(cellForeground('#000000', '#fff2cc')).toBe('#000000');
+ expect(cellForeground('#ffffff', '#123456')).toBe('#ffffff');
+ expect(cellForeground('#FF0000')).toBe('#FF0000');
+ expect(cellBorderColor('#123456')).toBe('#123456');
+ expect(cellBorderColor('#000000', '#ffffff')).toBe('#000000');
+ });
+
+ it('chooses readable automatic text on literal fills in either theme', () => {
+ expect(cellForeground('', '#fff2cc')).toBe('#000000');
+ expect(cellForeground(undefined, '#ffffff')).toBe('#000000');
+ expect(cellForeground(undefined, '#000000')).toBe('#ffffff');
+ expect(cellForeground(undefined, '#123456')).toBe('#ffffff');
+ expect(cellBorderColor(undefined, '#fff2cc')).toBe('#000000');
+ expect(cellBorderColor(undefined, '#123456')).toBe('#ffffff');
+ });
+});
diff --git a/apps/web/src/features/block-spreadsheet/components/cell-colors.ts b/apps/web/src/features/block-spreadsheet/components/cell-colors.ts
new file mode 100644
index 0000000000..a4c7c04b70
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/components/cell-colors.ts
@@ -0,0 +1,28 @@
+/** Excel's default black follows the app foreground on an unfilled cell.
+ * Explicit fill/text pairs remain workbook colors, including on export: these
+ * helpers only choose CSS values and never modify the stored cell style.
+ */
+export function cellForeground(
+ color?: string,
+ fill?: string
+): string | undefined {
+ if (!color && !fill) return undefined;
+ if (color && (fill || color.toLowerCase() !== '#000000')) return color;
+ if (!fill) return 'var(--color-ink)';
+
+ // A fill is a literal workbook color rather than a themed surface. Choose
+ // the higher-contrast default so both pale fills and dark headers stay legible.
+ const channels = [1, 3, 5].map((offset) => {
+ const channel = Number.parseInt(fill.slice(offset, offset + 2), 16) / 255;
+ return channel <= 0.04045
+ ? channel / 12.92
+ : ((channel + 0.055) / 1.055) ** 2.4;
+ });
+ const luminance =
+ channels[0] * 0.2126 + channels[1] * 0.7152 + channels[2] * 0.0722;
+ return luminance > 0.179 ? '#000000' : '#ffffff';
+}
+
+export function cellBorderColor(color?: string, fill?: string): string {
+ return cellForeground(color, fill) ?? 'var(--color-ink)';
+}
diff --git a/apps/web/src/features/block-spreadsheet/core/cell-input.test.ts b/apps/web/src/features/block-spreadsheet/core/cell-input.test.ts
new file mode 100644
index 0000000000..9ffe1974c1
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/cell-input.test.ts
@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest';
+import { cellEditValue, normalizeCellInput } from './cell-input';
+
+describe('percentage cell entry', () => {
+ it.each([
+ ['5', '5%'],
+ ['-5', '-5%'],
+ ['0.5', '0.5%'],
+ ['.25', '.25%'],
+ [' 12.5 ', '12.5%'],
+ ['1e-3', '1e-3%'],
+ ['0', '0%'],
+ ])('treats typed %s as percentage points', (input, expected) => {
+ expect(normalizeCellInput(input, { value: '', format: 'percent' })).toBe(
+ expected
+ );
+ });
+
+ it.each([
+ '=A1/100',
+ '=SUM(A1:A4)',
+ '5%',
+ "'5",
+ 'revenue',
+ '',
+ '1/2',
+ 'Infinity',
+ ])(
+ 'does not reinterpret formula, explicit percentage, or text %s',
+ (input) => {
+ expect(normalizeCellInput(input, { value: '', format: 'percent' })).toBe(
+ input
+ );
+ }
+ );
+
+ it('respects imported Excel percentage formats without treating literal percent labels as numeric formats', () => {
+ expect(
+ normalizeCellInput('5', { value: '', numberFormat: '0.00%;[Red](0.00%)' })
+ ).toBe('5%');
+ for (const numberFormat of ['0"%"', '0\\%', '0" percent"', '0.00']) {
+ expect(normalizeCellInput('5', { value: '', numberFormat })).toBe('5');
+ }
+ expect(normalizeCellInput('5', { value: '', format: 'number' })).toBe('5');
+ expect(
+ normalizeCellInput('5', { value: '', format: 'text', numberFormat: '0%' })
+ ).toBe('5');
+ });
+
+ it.each([
+ ['0.05', '5%'],
+ ['0.07', '7%'],
+ ['-0.025', '-2.5%'],
+ ['0', '0%'],
+ ['5%', '5%'],
+ ['=B1/C1', '=B1/C1'],
+ ])(
+ 'shows stored %s as %s when editing without double scaling',
+ (value, expected) => {
+ const cell = { value, format: 'percent' as const };
+ expect(cellEditValue(cell)).toBe(expected);
+ expect(normalizeCellInput(cellEditValue(cell), cell)).toBe(expected);
+ }
+ );
+});
diff --git a/apps/web/src/features/block-spreadsheet/core/cell-input.ts b/apps/web/src/features/block-spreadsheet/core/cell-input.ts
new file mode 100644
index 0000000000..68c1df5215
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/cell-input.ts
@@ -0,0 +1,35 @@
+import type { SpreadsheetCell } from './spreadsheet-document';
+
+const numericInput = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+
+function isPercentCell(cell?: SpreadsheetCell) {
+ if (cell?.format === 'text') return false;
+ if (!cell?.numberFormat) return cell?.format === 'percent';
+ // A quoted or escaped percent sign is a literal label, not a scale factor.
+ const format = cell.numberFormat.replace(
+ /"[^"]*"|\\.|_.|\*.|\[[^\]]*\]/g,
+ ''
+ );
+ return format.includes('%');
+}
+
+/** User input in percentage cells uses percentage points; API/import values stay raw. */
+export function normalizeCellInput(value: string, cell?: SpreadsheetCell) {
+ const trimmed = value.trim();
+ return isPercentCell(cell) &&
+ numericInput.test(trimmed) &&
+ Number.isFinite(Number(trimmed))
+ ? `${trimmed}%`
+ : value;
+}
+
+/** Show an existing numeric percentage in the editor without changing its value. */
+export function cellEditValue(cell?: SpreadsheetCell) {
+ const value = cell?.value ?? '';
+ if (!isPercentCell(cell) || !numericInput.test(value.trim())) return value;
+ const percent = Number(value) * 100;
+ if (!Number.isFinite(percent)) return value;
+ // Spreadsheets display 15 significant decimal digits. Rounding here also
+ // avoids exposing binary float artifacts such as 0.07 * 100 = 7.000000000001.
+ return `${Number(percent.toPrecision(15))}%`;
+}
diff --git a/apps/web/src/features/block-spreadsheet/core/formula-reference.test.ts b/apps/web/src/features/block-spreadsheet/core/formula-reference.test.ts
index 9ffedfdf11..6481c5e7fe 100644
--- a/apps/web/src/features/block-spreadsheet/core/formula-reference.test.ts
+++ b/apps/web/src/features/block-spreadsheet/core/formula-reference.test.ts
@@ -68,3 +68,25 @@ describe('formula reference slots', () => {
).toBe('B4');
});
});
+
+it('quotes cross-sheet ranges and replaces a complete sheet-qualified operand', () => {
+ const range = { anchor: { row: 0, column: 0 }, focus: { row: 3, column: 1 } };
+ expect(formulaRangeReference(range, "Owner's budget")).toBe(
+ "'Owner''s budget'!A1:B4"
+ );
+ for (const reference of ["'Owner''s budget'!A1:B4", 'Sheet2!$C$3:$D8']) {
+ const text = `=SUM(${reference},2)`;
+ expect(
+ formulaReferenceSlot(text, {
+ start: 5 + reference.length,
+ end: 5 + reference.length,
+ })
+ ).toEqual({ start: 5, end: 5 + reference.length });
+ }
+ expect(formulaReferenceSlot("='Cash flow'!A1", { start: 6, end: 6 })).toEqual(
+ { start: 1, end: 15 }
+ );
+ expect(
+ formulaReferenceSlot('="Sheet2!A1"', { start: 8, end: 8 })
+ ).toBeUndefined();
+});
diff --git a/apps/web/src/features/block-spreadsheet/core/formula-reference.ts b/apps/web/src/features/block-spreadsheet/core/formula-reference.ts
index 5ea9cd96c7..a3e8ce3bbc 100644
--- a/apps/web/src/features/block-spreadsheet/core/formula-reference.ts
+++ b/apps/web/src/features/block-spreadsheet/core/formula-reference.ts
@@ -22,10 +22,11 @@ export function formulaReferenceSlot(
else quote = undefined;
} else if (!quote && (char === '"' || char === "'")) quote = char;
}
- if (quote) return;
+ if (quote === '"') return;
// A caret in/on a reference replaces the entire reference, including its range.
- const references = /\$?[A-Z]{1,3}\$?[1-9]\d*(?::\$?[A-Z]{1,3}\$?[1-9]\d*)?/gi;
+ const references =
+ /(?:(?:'(?:[^']|'')+'|[A-Z_][\w.]*)!)?\$?[A-Z]{1,3}\$?[1-9]\d*(?::\$?[A-Z]{1,3}\$?[1-9]\d*)?/gi;
for (const match of text.matchAll(references)) {
const from = match.index;
const to = from + match[0].length;
@@ -35,6 +36,8 @@ export function formulaReferenceSlot(
return { start: from, end: to };
}
+ if (quote) return;
+
// Point mode begins after an operator or argument separator. A completed
// expression still commits normally when the user clicks elsewhere.
if (!/[=+\-*/^&<>,;({:]\s*$/.test(text.slice(0, start))) return;
@@ -42,9 +45,16 @@ export function formulaReferenceSlot(
return { start, end };
}
-export function formulaRangeReference(selection: CellSelection) {
+export function formulaRangeReference(
+ selection: CellSelection,
+ sheetName?: string
+) {
const { top, bottom, left, right } = selectionBounds(selection);
const first = cellAddress({ row: top, column: left });
const last = cellAddress({ row: bottom, column: right });
- return first === last ? first : `${first}:${last}`;
+ const range = first === last ? first : `${first}:${last}`;
+ if (!sheetName) return range;
+ // Always quote sheet names: names like A1 and names containing apostrophes
+ // are valid tabs but ambiguous or invalid when inserted without escaping.
+ return `'${sheetName.replaceAll("'", "''")}'!${range}`;
}
diff --git a/apps/web/src/features/block-spreadsheet/core/selection-formatting.test.ts b/apps/web/src/features/block-spreadsheet/core/selection-formatting.test.ts
new file mode 100644
index 0000000000..401393838b
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/selection-formatting.test.ts
@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import { selectionToggleStyles } from './selection-formatting';
+import type { SpreadsheetCells } from './spreadsheet-document';
+
+describe('selection formatting state', () => {
+ const column = {
+ anchor: { row: 0, column: 0 },
+ focus: { row: 199, column: 0 },
+ };
+
+ it('does not treat a bold column header as a fully bold column', () => {
+ expect(
+ selectionToggleStyles(
+ { A1: { value: 'Revenue', bold: true }, A2: { value: '100' } },
+ column
+ ).bold
+ ).toBe(false);
+ });
+
+ it('recognizes uniformly formatted whole columns, including blank cells', () => {
+ const cells: SpreadsheetCells = Object.fromEntries(
+ Array.from({ length: 200 }, (_, row) => [
+ `A${row + 1}`,
+ { value: row < 2 ? 'Amount' : '', bold: true, wrap: true },
+ ])
+ );
+ expect(selectionToggleStyles(cells, column)).toEqual({
+ bold: true,
+ italic: false,
+ underline: false,
+ strikethrough: false,
+ wrap: true,
+ });
+ delete cells.A100;
+ expect(selectionToggleStyles(cells, column).bold).toBe(false);
+ });
+
+ it('reports each toggle independently across reverse row selections', () => {
+ const styles = selectionToggleStyles(
+ {
+ A1: { value: 'A', bold: true, italic: true, underline: true },
+ B1: { value: 'B', italic: true, underline: true },
+ C1: { value: 'C', italic: true },
+ },
+ { anchor: { row: 0, column: 2 }, focus: { row: 0, column: 0 } }
+ );
+ expect(styles).toEqual({
+ bold: false,
+ italic: true,
+ underline: false,
+ strikethrough: false,
+ wrap: false,
+ });
+ });
+});
diff --git a/apps/web/src/features/block-spreadsheet/core/selection-formatting.ts b/apps/web/src/features/block-spreadsheet/core/selection-formatting.ts
new file mode 100644
index 0000000000..5d536afda7
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/selection-formatting.ts
@@ -0,0 +1,40 @@
+import {
+ type CellSelection,
+ cellAddress,
+ selectionBounds,
+} from './grid-selection';
+import type { SpreadsheetCells } from './spreadsheet-document';
+
+/** Mixed selections enable a style on the first toggle, including blank cells. */
+export function selectionToggleStyles(
+ cells: SpreadsheetCells,
+ selection: CellSelection
+) {
+ const styles = {
+ bold: true,
+ italic: true,
+ underline: true,
+ strikethrough: true,
+ wrap: true,
+ };
+ const { top, bottom, left, right } = selectionBounds(selection);
+ for (let row = top; row <= bottom; row++) {
+ for (let column = left; column <= right; column++) {
+ const cell = cells[cellAddress({ row, column })];
+ styles.bold &&= !!cell?.bold;
+ styles.italic &&= !!cell?.italic;
+ styles.underline &&= !!cell?.underline;
+ styles.strikethrough &&= !!cell?.strikethrough;
+ styles.wrap &&= !!cell?.wrap;
+ if (
+ !styles.bold &&
+ !styles.italic &&
+ !styles.underline &&
+ !styles.strikethrough &&
+ !styles.wrap
+ )
+ return styles;
+ }
+ }
+ return styles;
+}
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-grid-controller.test.ts b/apps/web/src/features/block-spreadsheet/primitives/create-grid-controller.test.ts
index 0856fa7564..a97d5e7022 100644
--- a/apps/web/src/features/block-spreadsheet/primitives/create-grid-controller.test.ts
+++ b/apps/web/src/features/block-spreadsheet/primitives/create-grid-controller.test.ts
@@ -614,3 +614,167 @@ it('bounds navigation to added rows and cancels a draft when empty rows are remo
grid.commit();
expect(setCells).not.toHaveBeenCalled();
});
+
+function crossSheetSetup() {
+ return createRoot((dispose) => {
+ cleanups.push(dispose);
+ const [sheetId, setSheetId] = createSignal('summary');
+ const [sheets, setSheets] = createSignal([
+ { id: 'summary', name: 'Summary' },
+ { id: 'inputs', name: "Owner's budget" },
+ ]);
+ const [books, setBooks] = createSignal<Record<string, SpreadsheetCells>>({
+ summary: { B4: { value: 'before' } },
+ inputs: {
+ A1: { value: '10' },
+ A2: { value: '20' },
+ B4: { value: 'leave me' },
+ },
+ });
+ const [canEdit, setCanEdit] = createSignal(true);
+ const setSheetCells = vi.fn((id: string, edits: SpreadsheetCellEdits) => {
+ if (!sheets().some((sheet) => sheet.id === id)) return;
+ const cells = { ...books()[id] };
+ for (const [address, value] of Object.entries(edits)) {
+ if (value) cells[address] = { ...cells[address], ...value };
+ }
+ setBooks({ ...books(), [id]: cells });
+ });
+ const grid = createGridController({
+ cells: () => books()[sheetId()],
+ sheetId,
+ sheets,
+ setActiveSheet: setSheetId,
+ setSheetCells,
+ setCells: (edits) => setSheetCells(sheetId(), edits),
+ canEdit,
+ undo: () => {},
+ redo: () => {},
+ });
+ return {
+ grid,
+ books,
+ sheetId,
+ setSheetId,
+ setSheets,
+ setCanEdit,
+ setSheetCells,
+ };
+ });
+}
+
+describe('cross-sheet formula editing', () => {
+ it('keeps the draft while changing tabs and commits the escaped range to its original sheet', () => {
+ const view = crossSheetSetup();
+ view.grid.select({ row: 3, column: 1 });
+ view.grid.beginEdit('cell', '=SUM(');
+ view.grid.switchSheet('inputs');
+ expect(view.sheetId()).toBe('inputs');
+ expect(view.grid.editing()).toBe('formula');
+ expect(view.grid.editingAddress()).toBe('B4');
+ expect(view.grid.isEditingActiveSheet()).toBe(false);
+ expect(view.grid.beginReference({ row: 0, column: 0 })).toBe(true);
+ view.grid.updateReference({ row: 1, column: 0 });
+ view.grid.endReference();
+ expect(view.grid.draft()).toBe("=SUM('Owner''s budget'!A1:A2");
+ view.grid.beginEdit('formula');
+ expect(view.grid.draft()).toBe("=SUM('Owner''s budget'!A1:A2");
+ view.grid.setDraft(view.grid.draft() + ')');
+ view.grid.commit();
+ expect(view.books().summary.B4.value).toBe("=SUM('Owner''s budget'!A1:A2)");
+ expect(view.books().inputs.B4.value).toBe('leave me');
+ expect(view.sheetId()).toBe('summary');
+ expect(view.grid.activeAddress()).toBe('B4');
+ });
+
+ it('replaces a prior reference when choosing another sheet and omits the qualifier on the origin', () => {
+ const view = crossSheetSetup();
+ view.grid.beginEdit('formula', '=');
+ view.grid.switchSheet('inputs');
+ view.grid.beginReference({ row: 0, column: 0 });
+ view.grid.endReference();
+ view.grid.switchSheet('summary');
+ expect(view.grid.referenceSelection()).toBeUndefined();
+ view.grid.beginReference({ row: 0, column: 1 });
+ view.grid.endReference();
+ expect(view.grid.draft()).toBe('=B1');
+ view.grid.cancel();
+ expect(view.setSheetCells).not.toHaveBeenCalled();
+ });
+
+ it('cancels if the origin is removed, restores the origin on Escape, and rejects revoked permission', () => {
+ const view = crossSheetSetup();
+ view.grid.beginEdit('cell', '=SUM(');
+ view.grid.switchSheet('inputs');
+ view.grid.cancel();
+ expect(view.sheetId()).toBe('summary');
+ view.grid.beginEdit('cell', '=');
+ view.grid.switchSheet('inputs');
+ view.grid.beginReference({ row: 0, column: 0 });
+ view.grid.endReference();
+ view.setCanEdit(false);
+ view.grid.commit();
+ expect(view.setSheetCells).not.toHaveBeenCalled();
+ view.setCanEdit(true);
+ view.grid.beginEdit('cell', '=');
+ view.grid.switchSheet('inputs');
+ view.setSheets([{ id: 'inputs', name: 'Inputs' }]);
+ expect(view.grid.editing()).toBeUndefined();
+ view.grid.commit();
+ expect(view.setSheetCells).not.toHaveBeenCalled();
+ });
+
+ it('commits non-formulas during normal tab navigation and cancels on unrequested sheet changes', () => {
+ const view = crossSheetSetup();
+ view.grid.beginEdit('cell', 'New value');
+ view.grid.switchSheet('inputs');
+ expect(view.books().summary.A1.value).toBe('New value');
+ view.grid.beginEdit('cell', '=SUM(');
+ view.setSheetId('summary');
+ expect(view.grid.editing()).toBeUndefined();
+ expect(view.books().inputs.A1.value).toBe('10');
+ });
+});
+
+it('fills literal series immediately and keeps keyboard fill-down as a copy', async () => {
+ const view = setup({ A1: { value: '1' }, A2: { value: '2' } });
+ const source = {
+ anchor: { row: 0, column: 0 },
+ focus: { row: 1, column: 0 },
+ };
+ const target = {
+ anchor: { row: 0, column: 0 },
+ focus: { row: 3, column: 0 },
+ };
+ const done = view.grid.fill(source, target);
+ expect(view.cells().A3.value).toBe('3');
+ expect(view.cells().A4.value).toBe('4');
+ await done;
+ view.grid.selectRange({ row: 0, column: 0 }, { row: 3, column: 0 });
+ view.key('d', { ctrlKey: true });
+ expect(view.cells().A4.value).toBe('1');
+});
+
+it('interprets newly typed percentage points without rescaling unchanged stored percentages', () => {
+ const view = setup({ A1: { value: '0.05', format: 'percent' } });
+ view.grid.beginEdit('cell');
+ expect(view.grid.draft()).toBe('5%');
+ view.grid.commit();
+ expect(view.setCells).not.toHaveBeenCalled();
+ view.key('7');
+ view.grid.commit();
+ expect(view.cells().A1.value).toBe('7%');
+ view.grid.beginEdit('formula', '=5/100');
+ view.grid.commit();
+ expect(view.cells().A1.value).toBe('=5/100');
+});
+
+it('moves from the active cell after whole-row or whole-column selections, not the far edge', () => {
+ const { grid, key } = setup();
+ grid.selectRange({ row: 0, column: 2 }, { row: 199, column: 2 });
+ key('ArrowDown');
+ expect(grid.activeAddress()).toBe('C2');
+ grid.selectRange({ row: 4, column: 0 }, { row: 4, column: 25 });
+ key('ArrowRight');
+ expect(grid.activeAddress()).toBe('B5');
+});
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-grid-controller.ts b/apps/web/src/features/block-spreadsheet/primitives/create-grid-controller.ts
index f3f0bd7796..7d981c0724 100644
--- a/apps/web/src/features/block-spreadsheet/primitives/create-grid-controller.ts
+++ b/apps/web/src/features/block-spreadsheet/primitives/create-grid-controller.ts
@@ -13,6 +13,7 @@ import {
rangeCopies,
readCopiedRange,
} from '../core/cell-copy';
+import { cellEditValue, normalizeCellInput } from '../core/cell-input';
import {
type FormulaTextSelection,
formulaRangeReference,
@@ -29,6 +30,7 @@ import {
selectionBounds,
serializeTable,
} from '../core/grid-selection';
+import { selectionToggleStyles } from '../core/selection-formatting';
import {
SPREADSHEET_DEFAULT_STYLE,
SPREADSHEET_MAX_CELL_LENGTH,
@@ -41,6 +43,9 @@ import {
type GridSource = {
cells: Accessor<SpreadsheetCells>;
sheetId?: Accessor<string>;
+ sheets?: Accessor<{ id: string; name: string }[]>;
+ setActiveSheet?: (id: string) => void;
+ setSheetCells?: (id: string, edits: SpreadsheetCellEdits) => void;
canEdit: Accessor<boolean>;
rowCount?: Accessor<number>;
hiddenRows?: Accessor<number[]>;
@@ -105,14 +110,24 @@ export function createGridController(source: GridSource) {
const [pickingReference, setPickingReference] = createSignal(false);
let textSelection: FormulaTextSelection = { start: 0, end: 0 };
let referenceDraft:
- | { prefix: string; suffix: string; anchor: CellPosition }
+ | { prefix: string; suffix: string; anchor: CellPosition; sheetId?: string }
| undefined;
const [notice, setNotice] = createSignal('');
const activeAddress = () => cellAddress(selection().anchor);
let originalValue = '';
+ let originalCell: SpreadsheetCell | undefined;
+ let editTarget: { sheetId: string; address: string } | undefined;
+ let switchingReferenceSheet: string | undefined;
+ const [referenceSheetId, setReferenceSheetId] = createSignal<string>();
+ const isEditingActiveSheet = () =>
+ !editTarget || editTarget.sheetId === source.sheetId?.();
+ const editingAddress = () => editTarget?.address ?? activeAddress();
+ const canPickReference = () =>
+ !!editing() && !!formulaReferenceSlot(draft(), textSelection);
// Remote deletion and local tab changes invalidate drafts and async fills.
- // Keep a separate selection per sheet; a draft never crosses this boundary.
+ // An explicit reference-picking tab switch keeps the origin draft. Remote
+ // changes and other navigation still invalidate it.
const sheetSelections = new Map<string, CellSelection>();
if (source.sheetId) {
let previousSheetId = source.sheetId();
@@ -123,7 +138,10 @@ export function createGridController(source: GridSource) {
sheetSelections.set(previousSheetId, selection());
previousSheetId = id;
operation++;
- cancel();
+ if (switchingReferenceSheet !== id) cancel(false);
+ switchingReferenceSheet = undefined;
+ setPickingReference(false);
+ referenceDraft = undefined;
const saved = sheetSelections.get(id);
setSelection(
saved
@@ -140,6 +158,30 @@ export function createGridController(source: GridSource) {
);
}
+ if (source.sheets) {
+ createEffect(
+ on(source.sheets, (sheets) => {
+ if (
+ editTarget &&
+ !sheets.some((sheet) => sheet.id === editTarget?.sheetId)
+ )
+ cancel(false);
+ })
+ );
+ }
+
+ function switchSheet(id: string) {
+ if (!source.setActiveSheet || id === source.sheetId?.()) return;
+ if (source.sheets && !source.sheets().some((sheet) => sheet.id === id))
+ return;
+ if (canPickReference() && source.setSheetCells && editTarget) {
+ switchingReferenceSheet = id;
+ // The formula bar remains available when the original cell is off-sheet.
+ setEditing('formula');
+ } else commit();
+ source.setActiveSheet(id);
+ }
+
// A local undo or remote layout operation can remove the selected empty row.
// End its draft before moving focus so it cannot commit into a different cell.
createEffect(
@@ -177,11 +219,21 @@ export function createGridController(source: GridSource) {
cancelPendingCopy();
if (!editing()) return;
const value = draft();
+ const target = editTarget;
+ const address = editingAddress();
setEditing(undefined);
+ editTarget = undefined;
resetReference();
if (source.canEdit() && value !== originalValue) {
- source.setCells({ [activeAddress()]: { value } });
+ const edits = {
+ [address]: { value: normalizeCellInput(value, originalCell) },
+ };
+ if (target && source.setSheetCells)
+ source.setSheetCells(target.sheetId, edits);
+ else source.setCells(edits);
}
+ if (target && target.sheetId !== source.sheetId?.())
+ source.setActiveSheet?.(target.sheetId);
}
function select(position: CellPosition, extend = false) {
@@ -211,21 +263,35 @@ export function createGridController(source: GridSource) {
const visible = visiblePosition(selection().anchor);
if (cellAddress(visible) !== activeAddress())
setSelection({ anchor: visible, focus: visible });
- originalValue = source.cells()[activeAddress()]?.value ?? '';
+ // Moving between in-cell and formula-bar editors must keep the same draft.
+ if (editing()) {
+ setEditing(location);
+ return;
+ }
+ originalCell = source.cells()[activeAddress()];
+ originalValue = cellEditValue(originalCell);
+ editTarget = source.sheetId
+ ? { sheetId: source.sheetId(), address: activeAddress() }
+ : undefined;
setDraft(initial ?? originalValue);
setEditing(location);
setNotice('');
}
- function cancel() {
+ function cancel(returnToOrigin = true) {
+ const target = editTarget;
+ editTarget = undefined;
setEditing(undefined);
setDraft('');
+ if (returnToOrigin && target && target.sheetId !== source.sheetId?.())
+ source.setActiveSheet?.(target.sheetId);
}
function resetReference() {
referenceDraft = undefined;
setPickingReference(false);
setReferenceSelection(undefined);
+ setReferenceSheetId(undefined);
setEditorSelection(undefined);
}
@@ -247,7 +313,9 @@ export function createGridController(source: GridSource) {
prefix: draft().slice(0, slot.start),
suffix: draft().slice(slot.end),
anchor: boundPosition(position),
+ sheetId: source.sheetId?.(),
};
+ setReferenceSheetId(source.sheetId?.());
setPickingReference(true);
updateReference(position);
return true;
@@ -259,7 +327,13 @@ export function createGridController(source: GridSource) {
anchor: referenceDraft.anchor,
focus: boundPosition(position),
};
- const reference = formulaRangeReference(range);
+ const sheetName =
+ editTarget && editTarget.sheetId !== referenceDraft.sheetId
+ ? source
+ .sheets?.()
+ .find((sheet) => sheet.id === referenceDraft?.sheetId)?.name
+ : undefined;
+ const reference = formulaRangeReference(range, sheetName);
const value = referenceDraft.prefix + reference + referenceDraft.suffix;
if (value.length > SPREADSHEET_MAX_CELL_LENGTH) {
setNotice('A cell can contain up to 10,000 characters.');
@@ -349,12 +423,26 @@ export function createGridController(source: GridSource) {
}
async function applyCopies(copies: CellCopy[], target: CellSelection) {
- if (!source.canEdit() || !source.copyCells || !copies.length) return;
+ if (!source.canEdit() || !copies.length) return;
+ const hasFormulas = copies.some(
+ ({ cell }) => cell.value.startsWith('=') && cell.format !== 'text'
+ );
+ if (hasFormulas && !source.copyCells) return;
const current = ++operation;
const before = source.cells();
setNotice('Copying cells…');
try {
- const edits = await source.copyCells(copies);
+ // Literal/series fills are synchronous, avoiding an old-value flash while
+ // a worker starts up. Formula translation still uses IronCalc's parser.
+ const edits =
+ hasFormulas && source.copyCells
+ ? await source.copyCells(copies)
+ : Object.fromEntries(
+ copies.map(({ to, cell }) => [
+ cellAddress(to),
+ { ...SPREADSHEET_DEFAULT_STYLE, ...cell },
+ ])
+ );
if (current !== operation) return;
if (!source.canEdit()) {
setNotice('Copy cancelled because this spreadsheet is view only.');
@@ -382,13 +470,20 @@ export function createGridController(source: GridSource) {
}
}
- function fill(sourceRange: CellSelection, target: CellSelection) {
+ function fill(
+ sourceRange: CellSelection,
+ target: CellSelection,
+ mode: 'series' | 'copy' = 'series'
+ ) {
commit();
const bounded = {
anchor: boundPosition(target.anchor),
focus: boundPosition(target.focus),
};
- void applyCopies(fillCopies(source.cells(), sourceRange, bounded), bounded);
+ return applyCopies(
+ fillCopies(source.cells(), sourceRange, bounded, mode),
+ bounded
+ );
}
function fillDirection(direction: 'down' | 'right') {
@@ -401,7 +496,8 @@ export function createGridController(source: GridSource) {
column: direction === 'down' ? right : left,
},
},
- selection()
+ selection(),
+ 'copy'
);
}
@@ -492,13 +588,20 @@ export function createGridController(source: GridSource) {
(event.shiftKey ? redo : undo)();
} else if (command && event.key.toLowerCase() === 'b') {
event.preventDefault();
- format({ bold: !source.cells()[activeAddress()]?.bold });
+ format({
+ bold: !selectionToggleStyles(source.cells(), selection()).bold,
+ });
} else if (command && event.key.toLowerCase() === 'i') {
event.preventDefault();
- format({ italic: !source.cells()[activeAddress()]?.italic });
+ format({
+ italic: !selectionToggleStyles(source.cells(), selection()).italic,
+ });
} else if (command && event.key.toLowerCase() === 'u') {
event.preventDefault();
- format({ underline: !source.cells()[activeAddress()]?.underline });
+ format({
+ underline: !selectionToggleStyles(source.cells(), selection())
+ .underline,
+ });
} else if (command && ['d', 'r'].includes(event.key.toLowerCase())) {
event.preventDefault();
fillDirection(event.key.toLowerCase() === 'd' ? 'down' : 'right');
@@ -542,12 +645,19 @@ export function createGridController(source: GridSource) {
fill,
fillDirection,
activeAddress,
+ editingAddress,
+ isEditingActiveSheet,
+ canPickReference,
+ switchSheet,
editing,
draft,
setDraft,
setTextSelection,
editorSelection,
- referenceSelection,
+ referenceSelection: () =>
+ referenceSheetId() === source.sheetId?.()
+ ? referenceSelection()
+ : undefined,
pickingReference,
beginReference,
updateReference,
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-store.ts b/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-store.ts
index aff47b1bae..9e18f1b1d0 100644
--- a/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-store.ts
+++ b/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-store.ts
@@ -284,6 +284,13 @@ export function createSpreadsheetStore(options: {
else selections.delete(activeSheetId());
publishSelection(current);
},
+ setSheetCells(id: string, edits: SpreadsheetCellEdits) {
+ const doc = options.source.doc();
+ if (!doc || !editable() || !workbook().some((sheet) => sheet.id === id))
+ return;
+ writeSpreadsheetCells(doc, edits, id);
+ refresh();
+ },
setCells(edits: SpreadsheetCellEdits) {
const doc = options.source.doc();
if (!doc || !editable()) return;
diff --git a/apps/web/src/features/block-spreadsheet/views/SpreadsheetEditor.tsx b/apps/web/src/features/block-spreadsheet/views/SpreadsheetEditor.tsx
index cfcc2285b9..18f21b0389 100644
--- a/apps/web/src/features/block-spreadsheet/views/SpreadsheetEditor.tsx
+++ b/apps/web/src/features/block-spreadsheet/views/SpreadsheetEditor.tsx
@@ -26,6 +26,7 @@ import {
} from '../components/SpreadsheetWorkbookDialogs';
import type { SpreadsheetCommentsCapability } from '../context/spreadsheet-comments';
import type { SpreadsheetMentions } from '../context/spreadsheet-mentions';
+import { cellEditValue } from '../core/cell-input';
import { encodeCsv } from '../core/csv-export';
import { formulaRangeReference } from '../core/formula-reference';
import {
@@ -34,6 +35,7 @@ import {
positionFromAddress,
selectionBounds,
} from '../core/grid-selection';
+import { selectionToggleStyles } from '../core/selection-formatting';
import type { SpreadsheetCommentAnchor } from '../core/spreadsheet-comments';
import { SPREADSHEET_MAX_ROWS } from '../core/spreadsheet-document';
import { spreadsheetCursors } from '../core/spreadsheet-presence';
@@ -57,6 +59,7 @@ export function SpreadsheetEditor(props: {
onExportXlsx: (bytes: Uint8Array) => void;
}) {
let gridElement: HTMLDivElement | undefined;
+ let editorElement!: HTMLElement;
let importInput!: HTMLInputElement;
const [zoom, setZoom] = createSignal(100);
const [showGridlines, setShowGridlines] = createSignal(true);
@@ -167,8 +170,14 @@ export function SpreadsheetEditor(props: {
'textarea, [contenteditable=true]'
);
editor?.focus({ preventScroll: true });
+ } else if (grid.editing() === 'formula') {
+ const editor = editorElement.querySelector<HTMLElement>(
+ '[aria-label="Formula bar"]'
+ );
+ editor?.focus({ preventScroll: true });
+ if (editor instanceof HTMLTextAreaElement)
+ editor.setSelectionRange(editor.value.length, editor.value.length);
} else focusGrid();
- revealSelection();
};
const menuCommand = (action: SpreadsheetCommand) => {
// Create a new focus owner only after the menu's focus trap has closed.
@@ -442,6 +451,7 @@ export function SpreadsheetEditor(props: {
return (
<section
+ ref={editorElement}
class="flex size-full min-h-0 min-w-0 flex-col overflow-hidden bg-surface text-ink"
aria-label={`${props.name} spreadsheet`}
onKeyDown={(event) => {
@@ -534,7 +544,10 @@ export function SpreadsheetEditor(props: {
readonly={!editable() || actions.pending() || !!workbookActions.busy()}
canUndo={props.store.canUndo()}
canRedo={props.store.canRedo()}
- cell={activeCell()}
+ cell={{
+ ...activeCell(),
+ ...selectionToggleStyles(props.store.cells(), grid.selection()),
+ }}
zoom={zoom()}
showGridlines={showGridlines()}
showFormulaBar={showFormulaBar()}
@@ -559,7 +572,13 @@ export function SpreadsheetEditor(props: {
void importFile(file);
}}
/>
- <Show when={showFormulaBar() || (isTouchDevice() && !!grid.editing())}>
+ <Show
+ when={
+ showFormulaBar() ||
+ grid.editing() === 'formula' ||
+ (isTouchDevice() && !!grid.editing())
+ }
+ >
<FormulaBar
mentions={props.mentions}
editing={!!grid.editing()}
@@ -570,8 +589,12 @@ export function SpreadsheetEditor(props: {
(isTouchDevice() && !!grid.referenceSelection())
}
onSelectionChange={grid.setTextSelection}
- address={formulaRangeReference(grid.selection())}
- value={grid.editing() ? grid.draft() : (activeCell()?.value ?? '')}
+ address={
+ grid.editing()
+ ? grid.editingAddress()
+ : formulaRangeReference(grid.selection())
+ }
+ value={grid.editing() ? grid.draft() : cellEditValue(activeCell())}
readonly={!editable()}
onNavigate={(address) => {
const parts = address.split(':');
@@ -618,6 +641,15 @@ export function SpreadsheetEditor(props: {
rowCount={props.store.rowCount()}
columnWidths={props.store.layout().columnWidths}
rowHeights={props.store.activeSheet().metadata?.rowHeights}
+ onResizeRow={(row, height) => {
+ if (!editable()) return;
+ const metadata = props.store.activeSheet().metadata;
+ const rowHeights = { ...metadata?.rowHeights };
+ if (height === undefined) delete rowHeights[row];
+ else rowHeights[row] = height * 0.75;
+ props.store.setMetadata({ ...metadata, rowHeights });
+ focusGrid();
+ }}
hiddenRows={props.store.activeSheet().metadata?.hiddenRows}
hiddenColumns={props.store.activeSheet().metadata?.hiddenColumns}
canChangeStructure={props.store.canChangeStructure()}
@@ -630,8 +662,11 @@ export function SpreadsheetEditor(props: {
remoteCursors={remoteCursors()}
comments={props.comments}
selection={grid.selection()}
- editing={grid.editing() === 'cell'}
- formulaEditing={grid.editing() === 'formula'}
+ editing={grid.editing() === 'cell' && grid.isEditingActiveSheet()}
+ formulaEditing={
+ !!grid.editing() &&
+ (grid.editing() === 'formula' || !grid.isEditingActiveSheet())
+ }
editorSelection={grid.editorSelection()}
referenceSelection={grid.referenceSelection()}
pickingReference={grid.pickingReference()}
@@ -694,13 +729,18 @@ export function SpreadsheetEditor(props: {
<SpreadsheetSheetTabs
sheets={props.store.sheets()}
activeSheetId={props.store.activeSheetId()}
+ preserveEditorFocus={grid.canPickReference()}
readonly={!editable()}
canAdd={props.store.sheets().length < SPREADSHEET_MAX_SHEETS}
onSelect={(id) => {
- workbookActions.selectSheet(id);
+ grid.switchSheet(id);
actions.clearNotice();
- focusGrid();
- queueMicrotask(revealSelection);
+ workbookActions.clearNotice();
+ if (grid.editing()) queueMicrotask(restoreEditorFocus);
+ else {
+ focusGrid();
+ queueMicrotask(revealSelection);
+ }
}}
onAdd={() => {
workbookActions.addSheet();
@@ -817,7 +857,7 @@ export function SpreadsheetEditor(props: {
<Show when={statistics().count <= 1}>
<span class="hidden sm:inline">
{editable()
- ? 'Double-click to edit · Shift + click to select'
+ ? 'Type to edit · Shift + click to select'
: 'Select cells to explore'}
</span>
</Show>
diff --git a/apps/web/src/lib/core/util/isEditableInput.ts b/apps/web/src/lib/core/util/isEditableInput.ts
index 7879059ac3..0853a4cae4 100644
--- a/apps/web/src/lib/core/util/isEditableInput.ts
+++ b/apps/web/src/lib/core/util/isEditableInput.ts
@@ -1,5 +1,8 @@
export function isEditableInput(target: Element | undefined | null) {
if (!target) return false;
+ // Composite editors (such as a spreadsheet grid between cell edits) own
+ // typing/navigation even though they are not native text inputs.
+ if (target.hasAttribute('data-keyboard-input')) return true;
// Check if target is an input
if (target instanceof HTMLInputElement) {
// Exclude checkbox and radio which aren't text-editable
diff --git a/docs/AGENT_GUIDE/documents.md b/docs/AGENT_GUIDE/documents.md
index 6411565a92..5094b87039 100644
--- a/docs/AGENT_GUIDE/documents.md
+++ b/docs/AGENT_GUIDE/documents.md
@@ -44,12 +44,20 @@ at the caret (for example, type `=SUM(`, then drag B4 through B7). The draft upd
to `=SUM(B4:B7` without committing or moving the active cell. A dashed outline shows
the referenced range. Release, type `)`, and press Enter to calculate. This works
in both the cell editor and formula bar, including reverse drags, replacement of
-an existing reference, and subsequent arguments after a comma or operator.
+an existing reference, and subsequent arguments after a comma or operator. To reference another sheet,
+click its tab while the formula is awaiting a reference, then click or drag the
+source cells. The draft stays in the formula bar; Enter commits it to the original
+sheet and cell. Names with spaces are quoted automatically. Escape cancels and
+returns to the original sheet.
On touch screens, tap a cell while editing a formula, then drag **Move reference
start** or **Move reference end** to extend its reference. Tapping a suggestion or
adjusting a reference should keep the input focused and the software keyboard open.
Drag across cells, Shift-click, or use Shift + arrow keys to select a range.
+Drag across row/column headers or Shift-click a second header to select multiple
+whole rows/columns. Arrow keys then move from the selection's active cell. The
+focused grid owns typing and navigation; app navigation shortcuts do not run while
+it has focus.
The active cell keeps a complete border while editing; a range has a shaded
fill and an outer border. Verify selection in both drag directions and after
scrolling, including near the last row and column.
@@ -60,10 +68,15 @@ Copy within Macro and paste elsewhere to translate relative references: copying
`=B4-C4` down becomes `=B5-C5`, while `$B$4` stays fixed. Drag the small handle
at the selection's bottom-right corner to fill down/up or right/left. Select a
range and use **Format and data → Fill down / Fill right** or **Cmd/Ctrl+D** /
-**Cmd/Ctrl+R**. Fill repeats values/formulas and formatting; it does not infer
-number sequences. Plain-text paste from other apps keeps formulas as supplied.
-
-Drag a column header's right boundary to resize; double-click it to auto-fit.
+**Cmd/Ctrl+R**. Drag fill continues arithmetic number sequences and daily,
+weekly, monthly, or quarterly date sequences (including month ends). Text and
+irregular patterns repeat; relative formula references translate. Keyboard/menu
+Fill down/right explicitly copies the starting row/column. Plain-text paste from
+other apps keeps formulas as supplied.
+
+Drag a column header's right boundary or row header's bottom boundary to resize;
+double-click the boundary to auto-fit. Row separators support Up/Down arrows and
+Enter to restore automatic height. Explicit row heights take precedence over wrap.
At 100% zoom, default columns are 100 pixels wide and rows are 21 pixels high;
larger text and wrapping expand the row. Saved custom column widths take precedence.
The resize separator also supports Left/Right arrows and Enter for auto-fit.
@@ -75,9 +88,16 @@ undo/redo, paste, zoom and view options, currency/percent/decimals/number format
font and size, text styles, text/fill color, borders, alignment, wrapping,
functions, format/data actions, and find. Icon controls expose accessible button
names and tooltips. **Paste special** offers **Paste** and **Paste values only**.
-Select a range first; formatting applies to all selected cells. Font sizes are
+Select a range first; formatting applies to all selected cells. Toggling bold,
+italic, underline, or strikethrough on a mixed selection first enables it for the
+entire selection. Whole-column formatting preserves the viewport. In a cell that
+is already percentage-formatted, typing `5` means `5%`; formulas and AI/API numeric
+values still use fractional values (`0.05` for 5%). Font sizes are
points. Wrapped rows grow automatically up to 160 pixels at 100% zoom. Check
selection and formula-reference outlines after changing wrapping, font size, or zoom.
+Excel black text and borders on unfilled cells follow the app's foreground color
+so imported sheets remain readable in dark mode. Explicit text/fill color pairs
+remain unchanged; theme changes never alter saved or exported workbook colors.
**View options** directly toggles gridlines, the formula bar, and formula display;
these settings and zoom are local to the editor. **Go to cell** accepts ranges such
diff --git a/packages/spreadsheet/src/ai-formatting.test.ts b/packages/spreadsheet/src/ai-formatting.test.ts
new file mode 100644
index 0000000000..7d50692788
--- /dev/null
+++ b/packages/spreadsheet/src/ai-formatting.test.ts
@@ -0,0 +1,123 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { initSync } from '@ironcalc/wasm';
+import { LoroDoc } from 'loro-crdt';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { prepareSpreadsheetEdit, readSpreadsheetForAi } from './ai-workbook';
+import {
+ createInitializedSpreadsheetCalculator,
+ type SpreadsheetCalculator,
+} from './calculation';
+import {
+ readSpreadsheetCells,
+ writeSpreadsheetCells,
+} from './spreadsheet-document';
+
+let calculator: SpreadsheetCalculator;
+beforeAll(() => {
+ initSync({
+ module: readFileSync(
+ createRequire(import.meta.url).resolve('@ironcalc/wasm/wasm_bg.wasm')
+ ),
+ });
+ calculator = createInitializedSpreadsheetCalculator();
+});
+afterAll(() => calculator.dispose());
+
+describe('AI formatting preserves spreadsheet values', () => {
+ it('formats an entire column without overwriting a concurrent cell value', () => {
+ const doc = new LoroDoc();
+ try {
+ doc.getMap('spreadsheetMeta').set('formatVersion', 1);
+ writeSpreadsheetCells(doc, {
+ A1: { value: 'Revenue', bold: true },
+ A2: { value: '100' },
+ });
+ const style = {
+ bold: true,
+ fontFamily: 'serif' as const,
+ fillColor: '#fff2cc',
+ textColor: '#434343',
+ borderBottom: true,
+ };
+ const prepared = prepareSpreadsheetEdit(
+ doc,
+ {
+ action: 'edit',
+ expectedRevision: 'v',
+ operations: [
+ {
+ type: 'format_cells',
+ sheetId: 'sheet1',
+ range: 'A1:A200',
+ style,
+ },
+ ],
+ },
+ calculator
+ );
+ writeSpreadsheetCells(doc, {
+ A2: { value: '125' },
+ B2: { value: '=A2*2' },
+ });
+ doc.import(prepared.update);
+ const cells = readSpreadsheetCells(doc);
+ expect(cells.A1).toEqual({ value: 'Revenue', ...style });
+ expect(cells.A2).toEqual({ value: '125', ...style });
+ expect(cells.A200).toEqual({ value: '', ...style });
+ expect(cells.B2).toEqual({ value: '=A2*2' });
+ } finally {
+ doc.free();
+ }
+ });
+
+ it('keeps API fractional percentages and explicit user-entered percentages numerically equivalent', () => {
+ const doc = new LoroDoc();
+ try {
+ doc.getMap('spreadsheetMeta').set('formatVersion', 1);
+ writeSpreadsheetCells(doc, { A1: { value: '5%', format: 'percent' } });
+ const prepared = prepareSpreadsheetEdit(
+ doc,
+ {
+ action: 'edit',
+ expectedRevision: 'v',
+ operations: [
+ {
+ type: 'set_cells',
+ sheetId: 'sheet1',
+ cells: [
+ { address: 'A2', value: '0.05' },
+ { address: 'B1', value: '=SUM(A1:A2)' },
+ ],
+ },
+ {
+ type: 'format_cells',
+ sheetId: 'sheet1',
+ range: 'A1:B2',
+ style: { format: 'percent' },
+ },
+ ],
+ },
+ calculator
+ );
+ doc.import(prepared.update);
+ const result = readSpreadsheetForAi(
+ doc,
+ 'v',
+ { action: 'read', ranges: ['A1:B2'] },
+ calculator
+ );
+ expect(
+ result.ranges[0].cells.find((cell) => cell.address === 'A1')
+ ).toMatchObject({ source: '5%', value: 0.05, display: '5%' });
+ expect(
+ result.ranges[0].cells.find((cell) => cell.address === 'A2')
+ ).toMatchObject({ source: '0.05', value: 0.05, display: '5%' });
+ expect(
+ result.ranges[0].cells.find((cell) => cell.address === 'B1')
+ ).toMatchObject({ source: '=SUM(A1:A2)', value: 0.1, display: '10%' });
+ } finally {
+ doc.free();
+ }
+ });
+});
diff --git a/packages/spreadsheet/src/ai-workbook.test.ts b/packages/spreadsheet/src/ai-workbook.test.ts
index 75218412f1..3f6894499d 100644
--- a/packages/spreadsheet/src/ai-workbook.test.ts
+++ b/packages/spreadsheet/src/ai-workbook.test.ts
@@ -483,3 +483,64 @@ it('uses selected-sheet local names in private AI calculations without changing
expect(result.results[0]).toMatchObject({ type: 'number', value: 25 });
expect(doc.version().encode()).toEqual(before);
});
+
+it('extends numeric and financial date series through the AI edit tool, then calculates cross-sheet formulas', () => {
+ const doc = document();
+ const edit = prepareSpreadsheetEdit(
+ doc,
+ {
+ action: 'edit',
+ expectedRevision: 'v',
+ operations: [
+ { type: 'add_sheet', name: "Owner's budget" },
+ {
+ type: 'set_cells',
+ sheetId: "Owner's budget",
+ cells: [
+ { address: 'A1', value: '1' },
+ { address: 'A2', value: '2' },
+ { address: 'B1', value: '2026-01-31' },
+ { address: 'B2', value: '2026-02-28' },
+ { address: 'C1', value: '=A1*10' },
+ { address: 'C2', value: '=A2*10' },
+ ],
+ },
+ {
+ type: 'fill_cells',
+ sheetId: "Owner's budget",
+ sourceRange: 'A1:C2',
+ targetRange: 'A1:C4',
+ },
+ {
+ type: 'set_cells',
+ sheetId: 'sheet1',
+ cells: [{ address: 'A1', value: "=SUM('Owner''s budget'!C1:C4)" }],
+ },
+ ],
+ },
+ calculator
+ );
+ doc.import(edit.update);
+ const input = readSpreadsheetWorkbook(doc).find(
+ (sheet) => sheet.name === "Owner's budget"
+ )!;
+ expect(input.cells.A4.value).toBe('4');
+ expect(input.cells.B3.value).toBe('2026-03-31');
+ expect(input.cells.B4.value).toBe('2026-04-30');
+ expect(input.cells.C4.value).toBe('=A4*10');
+ const before = doc.version().encode();
+ const result = calculateSpreadsheetForAi(
+ doc,
+ 'v',
+ {
+ action: 'calculate',
+ formulas: [
+ { formula: "=SUM('Owner''s budget'!C1:C4)" },
+ { formula: '=Sheet1!A1' },
+ ],
+ },
+ calculator
+ );
+ expect(result.results.map((cell) => cell.value)).toEqual([100, 100]);
+ expect(doc.version().encode()).toEqual(before);
+});
diff --git a/packages/spreadsheet/src/cell-copy.test.ts b/packages/spreadsheet/src/cell-copy.test.ts
new file mode 100644
index 0000000000..ae22e635fb
--- /dev/null
+++ b/packages/spreadsheet/src/cell-copy.test.ts
@@ -0,0 +1,151 @@
+import { describe, expect, it } from 'vitest';
+import { fillCopies } from './cell-copy';
+import { cellAddress } from './grid-selection';
+import type { SpreadsheetCells } from './spreadsheet-document';
+
+const vertical = (start: number, end: number, left = 0, right = left) => ({
+ anchor: { row: start, column: left },
+ focus: { row: end, column: right },
+});
+function filled(
+ cells: SpreadsheetCells,
+ source: ReturnType<typeof vertical>,
+ target: ReturnType<typeof vertical>,
+ mode?: 'series' | 'copy'
+) {
+ return Object.fromEntries(
+ fillCopies(cells, source, target, mode).map(({ to, cell }) => [
+ cellAddress(to),
+ cell,
+ ])
+ );
+}
+
+describe('smart drag-fill series', () => {
+ it('extends independent numeric lanes forward and backward while preserving source styles', () => {
+ const cells = {
+ A3: { value: '1', bold: true },
+ A4: { value: '2' },
+ B3: { value: '20' },
+ B4: { value: '15' },
+ };
+ expect(filled(cells, vertical(3, 2, 1, 0), vertical(0, 6, 0, 1))).toEqual({
+ A1: { value: '-1', bold: true },
+ B1: { value: '30' },
+ A2: { value: '0' },
+ B2: { value: '25' },
+ A5: { value: '3', bold: true },
+ B5: { value: '10' },
+ A6: { value: '4' },
+ B6: { value: '5' },
+ A7: { value: '5', bold: true },
+ B7: { value: '0' },
+ });
+ expect(cells.A3.value).toBe('1');
+ });
+
+ it('fills horizontal decimal steps without exposing floating-point artifacts', () => {
+ expect(
+ filled(
+ { B1: { value: '0.1' }, C1: { value: '0.2' } },
+ vertical(0, 0, 1, 2),
+ vertical(0, 0, 0, 5)
+ )
+ ).toEqual({
+ A1: { value: '0' },
+ D1: { value: '0.3' },
+ E1: { value: '0.4' },
+ F1: { value: '0.5' },
+ });
+ });
+
+ it('repeats a lone number, explicit text, formulas, blanks and non-arithmetic patterns', () => {
+ const cells: SpreadsheetCells = {
+ A1: { value: '5' },
+ B1: { value: '1', format: 'text' },
+ B2: { value: '2', format: 'text' },
+ C1: { value: '=B1' },
+ C2: { value: '=B2' },
+ D1: { value: '1' },
+ D2: { value: '3' },
+ D3: { value: '4' },
+ };
+ expect(filled(cells, vertical(0, 0), vertical(0, 2)).A3.value).toBe('5');
+ expect(filled(cells, vertical(0, 1, 1, 2), vertical(0, 3, 1, 2))).toEqual({
+ B3: { value: '1', format: 'text' },
+ C3: { value: '=B1' },
+ B4: { value: '2', format: 'text' },
+ C4: { value: '=B2' },
+ });
+ expect(filled(cells, vertical(0, 2, 3), vertical(0, 4, 3)).D5.value).toBe(
+ '3'
+ );
+ expect(filled(cells, vertical(0, 1), vertical(0, 3)).A3.value).toBe('5');
+ });
+
+ it('advances daily and weekly dates, including leap years and reverse drags', () => {
+ expect(
+ filled({ A2: { value: '2024-02-28' } }, vertical(1, 1), vertical(0, 3))
+ ).toEqual({
+ A1: { value: '2024-02-27' },
+ A3: { value: '2024-02-29' },
+ A4: { value: '2024-03-01' },
+ });
+ expect(
+ filled(
+ { A1: { value: '9/1/2026' }, A2: { value: '9/8/2026' } },
+ vertical(0, 1),
+ vertical(0, 3)
+ ).A4.value
+ ).toBe('9/22/2026');
+ });
+
+ it('continues month ends and quarterly imported financial dates without drifting', () => {
+ expect(
+ filled(
+ { A1: { value: '2024-01-31' }, A2: { value: '2024-02-29' } },
+ vertical(0, 1),
+ vertical(0, 3)
+ )
+ ).toEqual({
+ A3: { value: '2024-03-31' },
+ A4: { value: '2024-04-30' },
+ });
+ const serial = (value: string) =>
+ String(
+ (Date.parse(`${value}T00:00:00Z`) - Date.UTC(1899, 11, 30)) / 86_400_000
+ );
+ const cells = {
+ A1: { value: serial('2026-03-31'), numberFormat: 'mmm-yy' },
+ A2: { value: serial('2026-06-30'), numberFormat: 'mmm-yy' },
+ };
+ expect(filled(cells, vertical(0, 1), vertical(0, 3))).toEqual({
+ A3: { value: serial('2026-09-30'), numberFormat: 'mmm-yy' },
+ A4: { value: serial('2026-12-31'), numberFormat: 'mmm-yy' },
+ });
+ });
+
+ it('does not infer invalid dates or non-finite numbers and keeps explicit fill-copy commands literal', () => {
+ for (const value of ['2026-02-30', '1e999', "'12", '=1+1']) {
+ expect(
+ filled({ A1: { value } }, vertical(0, 0), vertical(0, 1)).A2.value
+ ).toBe(value);
+ }
+ expect(
+ filled(
+ { A1: { value: '2026-09-01' } },
+ vertical(0, 0),
+ vertical(0, 1),
+ 'copy'
+ ).A2.value
+ ).toBe('2026-09-01');
+ expect(
+ filled(
+ { A1: { value: '1' }, A2: { value: '2' } },
+ vertical(0, 1),
+ vertical(0, 3),
+ 'copy'
+ ).A3.value
+ ).toBe('1');
+ });
+});
diff --git a/packages/spreadsheet/src/cell-copy.ts b/packages/spreadsheet/src/cell-copy.ts
index 28c9ffa2d7..67b18b06c0 100644
--- a/packages/spreadsheet/src/cell-copy.ts
+++ b/packages/spreadsheet/src/cell-copy.ts
@@ -1,4 +1,5 @@
import type { CellCopy } from './calculation';
+import { inferFillSeries } from './fill-series';
import {
type CellPosition,
type CellSelection,
@@ -115,15 +116,41 @@ export function rangeCopies(
);
}
-/** Repeat a source rectangle into an adjacent vertical or horizontal region. */
+/** Extend numeric/date sequences; repeat text and translate formulas. */
export function fillCopies(
cells: SpreadsheetCells,
source: CellSelection,
- target: CellSelection
+ target: CellSelection,
+ mode: 'series' | 'copy' = 'series'
): CellCopy[] {
const from = selectionBounds(source);
const to = selectionBounds(target);
const copies: CellCopy[] = [];
+ const vertical = to.left === from.left && to.right === from.right;
+ const horizontal = to.top === from.top && to.bottom === from.bottom;
+ const series = new Map<number, ReturnType<typeof inferFillSeries>>();
+ if (mode === 'series' && (vertical || horizontal)) {
+ const start = vertical ? from.left : from.top;
+ const end = vertical ? from.right : from.bottom;
+ for (let lane = start; lane <= end; lane++) {
+ const entries: SpreadsheetCell[] = [];
+ for (
+ let index = vertical ? from.top : from.left;
+ index <= (vertical ? from.bottom : from.right);
+ index++
+ ) {
+ entries.push(
+ cells[
+ cellAddress({
+ row: vertical ? index : lane,
+ column: vertical ? lane : index,
+ })
+ ] ?? { value: '' }
+ );
+ }
+ series.set(lane, inferFillSeries(entries));
+ }
+ }
const mod = (value: number, size: number) => ((value % size) + size) % size;
for (let row = to.top; row <= to.bottom; row++) {
for (let column = to.left; column <= to.right; column++) {
@@ -138,10 +165,14 @@ export function fillCopies(
row: from.top + mod(row - from.top, from.bottom - from.top + 1),
column: from.left + mod(column - from.left, from.right - from.left + 1),
};
+ const cell = cells[cellAddress(position)] ?? { value: '' };
+ const generated = series.get(vertical ? column : row)?.(
+ vertical ? row - from.top : column - from.left
+ );
copies.push({
from: position,
to: { row, column },
- cell: cells[cellAddress(position)] ?? { value: '' },
+ cell: generated === undefined ? cell : { ...cell, value: generated },
});
}
}
diff --git a/packages/spreadsheet/src/fill-series.ts b/packages/spreadsheet/src/fill-series.ts
new file mode 100644
index 0000000000..0f3332ff5f
--- /dev/null
+++ b/packages/spreadsheet/src/fill-series.ts
@@ -0,0 +1,128 @@
+import { is_date } from 'ssf';
+import type { SpreadsheetCell } from './spreadsheet-document';
+
+const DAY_MS = 86_400_000;
+const EXCEL_EPOCH = Date.UTC(1899, 11, 30);
+const numberInput = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+type SeriesValue = {
+ number: number;
+ date?: Date;
+ render: (value: number) => string;
+};
+
+function numericText(value: number) {
+ return String(Number(value.toPrecision(15)));
+}
+
+function readValue(cell: SpreadsheetCell): SeriesValue | undefined {
+ if (cell.format === 'text') return;
+ const text = cell.value.trim();
+ if (numberInput.test(text)) {
+ const number = Number(text);
+ if (!Number.isFinite(number)) return;
+ const dated =
+ cell.format === 'date' ||
+ (!!cell.numberFormat && is_date(cell.numberFormat));
+ // Serial 60 is Excel's fictitious leap day; leave that sequence numeric.
+ const date =
+ dated && number >= 61 && Number.isInteger(number)
+ ? new Date(EXCEL_EPOCH + number * DAY_MS)
+ : undefined;
+ return { number, date, render: numericText };
+ }
+ const iso = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(text);
+ const slash = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/.exec(text);
+ if (!iso && !slash) return;
+ const [year, month, day] = iso
+ ? [Number(iso[1]), Number(iso[2]), Number(iso[3])]
+ : [Number(slash![3]), Number(slash![1]), Number(slash![2])];
+ const date = new Date(Date.UTC(year, month - 1, day));
+ if (
+ year < 1900 ||
+ date.getUTCFullYear() !== year ||
+ date.getUTCMonth() !== month - 1 ||
+ date.getUTCDate() !== day
+ )
+ return;
+ return {
+ number: (date.getTime() - EXCEL_EPOCH) / DAY_MS,
+ date,
+ render: (value) => {
+ const next = new Date(EXCEL_EPOCH + value * DAY_MS);
+ return iso
+ ? next.toISOString().slice(0, 10)
+ : `${next.getUTCMonth() + 1}/${next.getUTCDate()}/${next.getUTCFullYear()}`;
+ },
+ };
+}
+
+function monthEnd(date: Date) {
+ return new Date(
+ Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 0)
+ ).getUTCDate();
+}
+
+/** Infer one lane of a drag fill. Formulas, text and irregular patterns repeat. */
+export function inferFillSeries(
+ cells: SpreadsheetCell[]
+): ((index: number) => string | undefined) | undefined {
+ const values = cells.map(readValue);
+ if (!values.length || values.some((value) => !value)) return;
+ const samples = values as SeriesValue[];
+ const first = samples[0];
+ const dates = samples.map((value) => value.date);
+ if (
+ dates.every(
+ (date): date is Date => !!date && Number.isFinite(date.getTime())
+ ) &&
+ dates.length > 1
+ ) {
+ const months = dates.map(
+ (date) => date.getUTCFullYear() * 12 + date.getUTCMonth()
+ );
+ const step = months[1] - months[0];
+ const ends = dates.every((date) => date.getUTCDate() === monthEnd(date));
+ const sameDay = dates.every(
+ (date) => date.getUTCDate() === dates[0].getUTCDate()
+ );
+ if (
+ step &&
+ (ends || sameDay) &&
+ months.every((month, index) => month === months[0] + index * step)
+ ) {
+ return (index) => {
+ const next = new Date(
+ Date.UTC(
+ dates[0].getUTCFullYear(),
+ dates[0].getUTCMonth() + index * step,
+ 1
+ )
+ );
+ next.setUTCDate(
+ ends
+ ? monthEnd(next)
+ : Math.min(dates[0].getUTCDate(), monthEnd(next))
+ );
+ return Number.isFinite(next.getTime())
+ ? first.render((next.getTime() - EXCEL_EPOCH) / DAY_MS)
+ : undefined;
+ };
+ }
+ }
+ if (samples.length < 2 && !first.date) return;
+ const step = samples.length > 1 ? samples[1].number - first.number : 1;
+ if (
+ !samples.every(
+ (value, index) =>
+ Math.abs(value.number - (first.number + index * step)) <=
+ 1e-10 * Math.max(1, Math.abs(step))
+ )
+ )
+ return;
+ return (index) => {
+ const next = first.number + index * step;
+ if (!Number.isFinite(next) || (first.date && Math.abs(next) > 100_000_000))
+ return;
+ return first.render(next);
+ };
+}