Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
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.tsxnew file mode 100644index 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.tsxindex 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.mdindex 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 authenticationor permission-token refresh. The ordinary fixture remains local-only unless theexplicit 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsxindex 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.tsnew file mode 100644index 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.tsxindex 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.tsxindex 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-inputaria-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.tsxindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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 remogrid.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.tsindex 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.tsindex 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.tsxindex 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())+ }+ ><FormulaBarmentions={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: {<SpreadsheetSheetTabssheets={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.tsindex 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 inputif (target instanceof HTMLInputElement) {// Exclude checkbox and radio which aren't text-editablediff --git a/docs/AGENT_GUIDE/documents.md b/docs/AGENT_GUIDE/documents.mdindex 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 updto `=SUM(B4:B7` without committing or moving the active cell. A dashed outline showsthe referenced range. Release, type `)`, and press Enter to calculate. This worksin 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 referencestart** or **Move reference end** to extend its reference. Tapping a suggestion oradjusting 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 shadedfill and an outer border. Verify selection in both drag directions and afterscrolling, 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 handleat the selection's bottom-right corner to fill down/up or right/left. Select arange 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 formatfont and size, text styles, text/fill color, borders, alignment, wrapping,functions, format/data actions, and find. Icon controls expose accessible buttonnames 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 arepoints. Wrapped rows grow automatically up to 160 pixels at 100% zoom. Checkselection 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 suchdiff --git a/packages/spreadsheet/src/ai-formatting.test.ts b/packages/spreadsheet/src/ai-formatting.test.tsnew file mode 100644index 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.tsindex 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 changingexpect(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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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);+ };+}