Skip to content

armgit / macro

Public Imported from GitHub
0

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

Improve spreadsheet imports, cell collaboration, and Files integration (#6583)

Jacob Beckerman62e9dca64aca
diff --git a/apps/web/src/components/entity-detail/EntityDetail.tsx b/apps/web/src/components/entity-detail/EntityDetail.tsx
index f58a1b426e..48c9f31ac9 100644
--- a/apps/web/src/components/entity-detail/EntityDetail.tsx
+++ b/apps/web/src/components/entity-detail/EntityDetail.tsx
@@ -26,6 +26,7 @@ export type EntityDetailProps = {
target: EntityDetailTarget;
shareOpen?: boolean;
onShareOpenChange?: (open: boolean) => void;
+ previewHeaderLeading?: JSX.Element;
children?: (context: EntityDetailContext) => JSX.Element;
};
@@ -38,6 +39,7 @@ function PreviewPanelEntityDetail(props: EntityDetailProps) {
selectedEntity={props.target}
orchestrator={orchestrator}
splitPanelContext={panel}
+ headerLeading={props.previewHeaderLeading}
/>
);
}
@@ -64,6 +66,7 @@ export function entityDetailBlockType(
blockType === 'snippet' ||
blockType === 'skill' ||
blockType === 'canvas' ||
+ blockType === 'spreadsheet' ||
blockType === 'code' ||
blockType === 'csv' ||
blockType === 'image' ||
@@ -203,7 +206,10 @@ export function EntityDetail(props: EntityDetailProps) {
</UnknownDetail>
</Match>
<Match when={true}>
- <PreviewPanelEntityDetail target={props.target} />
+ <PreviewPanelEntityDetail
+ target={props.target}
+ previewHeaderLeading={props.previewHeaderLeading}
+ />
</Match>
</Switch>
);
diff --git a/apps/web/src/features/block-code/component/Block.tsx b/apps/web/src/features/block-code/component/Block.tsx
index 76413d5486..72311a5fa0 100644
--- a/apps/web/src/features/block-code/component/Block.tsx
+++ b/apps/web/src/features/block-code/component/Block.tsx
@@ -7,7 +7,16 @@ import {
blockTextSignal,
blockUserAccessSignal,
} from '@core/signal/load';
-import { createEffect, createMemo, createSignal, on, Show } from 'solid-js';
+import {
+ createEffect,
+ createMemo,
+ createSignal,
+ lazy,
+ on,
+ Show,
+ Suspense,
+} from 'solid-js';
+import { useSpreadsheetAccess } from '../../block-spreadsheet/primitives/use-spreadsheet-access';
import { saveCodeDocument } from '../queries/code-document';
import { isHtmlFileType } from '../util/fileMode';
import { type CodeBlockMode, CodeContent } from './CodeContent';
@@ -15,6 +24,10 @@ import { CodeMarkdown } from './CodeMarkdown';
import { ModalsProvider } from './ModalsProvider';
import { TopBar } from './TopBar';
+const UploadedWorkbook = lazy(
+ () => import('../../block-spreadsheet/views/UploadedWorkbook')
+);
+
export default function BlockCode() {
useBlockEntityCommands();
const isNestedBlock = useIsNestedBlock();
@@ -23,6 +36,9 @@ export default function BlockCode() {
const blockText = blockTextSignal.get;
const setBlockText = blockTextSignal.set;
const blockUserAccess = blockUserAccessSignal.get;
+ const spreadsheetEnabled = useSpreadsheetAccess();
+ const spreadsheet = () =>
+ spreadsheetEnabled() && blockMetadata()?.fileType?.toLowerCase() === 'csv';
const isHtmlFile = createMemo(() =>
isHtmlFileType(blockMetadata()?.fileType)
);
@@ -50,14 +66,27 @@ export default function BlockCode() {
mode={mode()}
onModeChange={setMode}
/>
- <CodeContent
- text={blockText() ?? ''}
- fileType={blockMetadata()?.fileType}
- readOnly={readOnly()}
- mode={mode()}
- onTextChange={setBlockText}
- onSave={(text) => saveCodeDocument(documentId, text)}
- />
+ <Show
+ when={spreadsheet()}
+ fallback={
+ <CodeContent
+ text={blockText() ?? ''}
+ fileType={blockMetadata()?.fileType}
+ readOnly={readOnly()}
+ mode={mode()}
+ onTextChange={setBlockText}
+ onSave={(text) => saveCodeDocument(documentId, text)}
+ />
+ }
+ >
+ <Suspense
+ fallback={
+ <div class="p-6 text-ink-muted">Opening spreadsheet…</div>
+ }
+ >
+ <UploadedWorkbook />
+ </Suspense>
+ </Show>
</div>
</SidePanel.Layout>
</ModalsProvider>
diff --git a/apps/web/src/features/block-spreadsheet/SpreadsheetBlock.tsx b/apps/web/src/features/block-spreadsheet/SpreadsheetBlock.tsx
index 9af568f09f..200aee111c 100644
--- a/apps/web/src/features/block-spreadsheet/SpreadsheetBlock.tsx
+++ b/apps/web/src/features/block-spreadsheet/SpreadsheetBlock.tsx
@@ -30,6 +30,8 @@ import type { SpreadsheetData } from './definition';
import { createSpreadsheetStore } from './primitives/create-spreadsheet-store';
import { useSpreadsheetAccess } from './primitives/use-spreadsheet-access';
import { createSpreadsheetSession } from './queries/spreadsheet-session';
+import { SpreadsheetComments } from './SpreadsheetComments';
+import { spreadsheetMentions } from './spreadsheet-mentions';
import { SpreadsheetEditor } from './views/SpreadsheetEditor';
import { SpreadsheetModalsProvider } from './views/SpreadsheetModalsProvider';
@@ -138,24 +140,33 @@ function SpreadsheetBlockContent() {
/>
</div>
</SplitHeaderRight>
- <SpreadsheetEditor
- store={store}
- name={name()}
- onExportXlsx={(bytes) =>
- downloadFile(
- new Blob([bytes.slice().buffer], {
- type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
- }),
- `${name()}.xlsx`
- )
- }
- onExport={(content) =>
- downloadFile(
- new Blob([content], { type: 'text/csv;charset=utf-8' }),
- `${name()}.csv`
- )
- }
- />
+ <SpreadsheetComments documentId={documentId} store={store}>
+ {(commentLocation, comments) => (
+ <SpreadsheetEditor
+ commentLocation={commentLocation()}
+ comments={comments}
+ mentions={spreadsheetMentions}
+ store={store}
+ name={name()}
+ onExportXlsx={(bytes) =>
+ downloadFile(
+ new Blob([bytes.slice().buffer], {
+ type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+ }),
+ `${name()}.xlsx`
+ )
+ }
+ onExport={(content) =>
+ downloadFile(
+ new Blob([content], {
+ type: 'text/csv;charset=utf-8',
+ }),
+ `${name()}.csv`
+ )
+ }
+ />
+ )}
+ </SpreadsheetComments>
</>
);
}}
diff --git a/apps/web/src/features/block-spreadsheet/SpreadsheetComments.test.tsx b/apps/web/src/features/block-spreadsheet/SpreadsheetComments.test.tsx
new file mode 100644
index 0000000000..8915f46885
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/SpreadsheetComments.test.tsx
@@ -0,0 +1,259 @@
+import type { CommentThread } from '@service-storage/generated/schemas/commentThread';
+import {
+ cleanup,
+ fireEvent,
+ render,
+ screen,
+ waitFor,
+} from '@solidjs/testing-library';
+import { createSignal, For, type JSX, type ParentProps } from 'solid-js';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import type { SpreadsheetCommentsCapability } from './context/spreadsheet-comments';
+import type { SpreadsheetStore } from './primitives/create-spreadsheet-store';
+
+const mocks = vi.hoisted(() => ({
+ api: { create: vi.fn(), edit: vi.fn(), delete: vi.fn() },
+ refresh: vi.fn(async () => {}),
+ data: [] as CommentThread[],
+ target: undefined as string | undefined,
+ canComment: true,
+}));
+vi.mock('@components/app/split-layout/components/SplitHeader', () => ({
+ SplitHeaderRight: (p: ParentProps) => p.children,
+}));
+vi.mock('@core/component/ScopedPortal', () => ({
+ ScopedPortal: (p: ParentProps) => p.children,
+}));
+vi.mock('@core/component/LexicalMarkdown/directive/floatWithElement', () => ({
+ floatWithElement: () => {},
+}));
+vi.mock(
+ '@core/component/LexicalMarkdown/component/core/StaticMarkdown',
+ () => ({ StaticMarkdownContext: (p: ParentProps) => p.children })
+);
+vi.mock('@core/component/ParamsProvider', () => ({
+ useUrlParams: () => ({ commentId: () => mocks.target }),
+}));
+vi.mock('@core/context/user', () => ({ useUserId: () => () => 'me' }));
+vi.mock('@core/signal/permissions', () => ({
+ useCanComment: () => () => mocks.canComment,
+}));
+vi.mock('@core/util/url', () => ({ buildSimpleEntityUrl: () => 'link' }));
+vi.mock('@ui/components/Button', () => ({
+ Button: (p: JSX.ButtonHTMLAttributes<HTMLButtonElement>) => <button {...p} />,
+}));
+vi.mock('./queries/spreadsheet-comments', () => ({
+ useSpreadsheetComments: () => ({
+ query: { isSuccess: true, data: mocks.data },
+ api: mocks.api,
+ refresh: mocks.refresh,
+ }),
+}));
+vi.mock('@core/comments/discussion', async () => {
+ const { DiscussionProvider, useDiscussion } = await import(
+ '@core/comments/discussion/context'
+ );
+ return {
+ DiscussionProvider,
+ Discussion: () => <div>Thread list</div>,
+ DiscussionComposer: () => {
+ const source = useDiscussion();
+ const [text, setText] = createSignal('');
+ return (
+ <>
+ <input
+ aria-label="Comment draft"
+ value={text()}
+ onInput={(e) => setText(e.currentTarget.value)}
+ />
+ <button onClick={() => source.createThread(text(), [])}>Post</button>
+ </>
+ );
+ },
+ DiscussionThreadView: (p: {
+ thread: { id: string; comments: { text: string }[] };
+ }) => {
+ const source = useDiscussion();
+ return (
+ <>
+ <For each={p.thread.comments}>{(c) => <p>{c.text}</p>}</For>
+ <button
+ onClick={() =>
+ source.createReply(p.thread.id, 'Reply from card', [])
+ }
+ >
+ Reply
+ </button>
+ </>
+ );
+ },
+ };
+});
+
+import { SpreadsheetComments } from './SpreadsheetComments';
+
+const anchor = { sheetId: 'sheet1', sheetName: 'Budget', range: 'B4:C5' };
+let cap: SpreadsheetCommentsCapability;
+let active!: (id: string) => void;
+let selection = { anchor: 'B4', focus: 'C5' };
+function mount() {
+ return render(() => {
+ const [id, setId] = createSignal('sheet1');
+ active = setId;
+ const sheets = [
+ { id: 'sheet1', name: 'Budget', layout: { rowCount: 200 }, cells: {} },
+ ];
+ const store = {
+ ready: () => true,
+ workbook: () => sheets,
+ activeSheetId: id,
+ activeSheet: () => sheets[0],
+ selection: () => selection,
+ } as unknown as SpreadsheetStore;
+ return (
+ <SpreadsheetComments documentId="doc" store={store}>
+ {(location, comments) => {
+ cap = comments;
+ let cell!: HTMLButtonElement;
+ return (
+ <>
+ <button
+ ref={cell}
+ onMouseEnter={() => comments.enter('B4', cell)}
+ onMouseLeave={comments.leave}
+ >
+ B4
+ </button>
+ <button onClick={() => comments.add(cell)}>Comment</button>
+ <output>{location()?.range}</output>
+ </>
+ );
+ }}
+ </SpreadsheetComments>
+ );
+ });
+}
+beforeEach(() => {
+ mocks.data = [
+ {
+ thread: {
+ threadId: 7,
+ documentId: 'doc',
+ owner: 'me',
+ resolved: false,
+ metadata: { spreadsheet: anchor },
+ },
+ comments: [
+ { commentId: 42, threadId: 7, owner: 'me', text: 'Check assumptions' },
+ ],
+ },
+ ];
+ mocks.api.create.mockResolvedValue({ thread: { threadId: 8 }, comments: [] });
+ mocks.target = undefined;
+ mocks.canComment = true;
+ selection = { anchor: 'B4', focus: 'C5' };
+});
+afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+});
+it('offers a cell-anchored composer and freezes the range even if the grid selection moves', async () => {
+ mount();
+ fireEvent.click(screen.getByRole('button', { name: 'Comment' }));
+ expect(screen.getByRole('dialog').getAttribute('aria-label')).toBe(
+ 'Comments on Budget · B4:C5'
+ );
+ expect(screen.queryByRole('complementary')).toBeNull();
+ selection = { anchor: 'D9', focus: 'D9' };
+ fireEvent.input(screen.getByRole('textbox', { name: 'Comment draft' }), {
+ target: { value: 'Check this' },
+ });
+ fireEvent.click(screen.getByRole('button', { name: 'Post' }));
+ await waitFor(() =>
+ expect(mocks.api.create).toHaveBeenCalledWith(
+ expect.objectContaining({
+ threadMetadata: expect.objectContaining({ spreadsheet: anchor }),
+ })
+ )
+ );
+});
+it('shows existing comments on hover, replies in place, and pins the card when interacted with', async () => {
+ mount();
+ expect(cap.hasComment('B4')).toBe(true);
+ expect(cap.hasComment('C5')).toBe(false);
+ fireEvent.mouseEnter(screen.getByRole('button', { name: 'B4' }));
+ await waitFor(() =>
+ expect(screen.getByText('Check assumptions')).toBeTruthy()
+ );
+ fireEvent.pointerDown(screen.getByRole('dialog'));
+ fireEvent.mouseLeave(screen.getByRole('button', { name: 'B4' }));
+ await new Promise((resolve) => setTimeout(resolve, 400));
+ expect(screen.getByRole('dialog')).toBeTruthy();
+ fireEvent.click(screen.getByRole('button', { name: 'Reply' }));
+ await waitFor(() =>
+ expect(mocks.api.create).toHaveBeenCalledWith({
+ text: 'Reply from card',
+ threadId: 7,
+ mentions: undefined,
+ })
+ );
+ expect(screen.queryByRole('complementary')).toBeNull();
+ active('sheet2');
+ await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull());
+});
+it('dismisses unpinned previews and supports clicking a marker for touch/keyboard use', async () => {
+ mount();
+ const cell = screen.getByRole('button', { name: 'B4' });
+ fireEvent.mouseEnter(cell);
+ await waitFor(() => expect(screen.getByRole('dialog')).toBeTruthy());
+ fireEvent.mouseLeave(cell);
+ await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull());
+ cap.show('B4', cell);
+ expect(screen.getByRole('dialog')).toBeTruthy();
+ fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' });
+ expect(screen.queryByRole('dialog')).toBeNull();
+});
+it('opens notification targets at the linked range and keeps deleted-sheet threads accessible', async () => {
+ mocks.target = '42';
+ mount();
+ expect(
+ screen.getByRole('complementary', { name: 'Spreadsheet comments' })
+ ).toBeTruthy();
+ expect(screen.getByRole('status').textContent).toBe('B4:C5');
+ cleanup();
+ mocks.data[0].thread.metadata = {
+ spreadsheet: { ...anchor, sheetId: 'deleted' },
+ };
+ mount();
+ expect(
+ screen.getByText('This comment refers to a sheet that has been deleted.')
+ ).toBeTruthy();
+});
+
+it('keeps sidebar and floating composer attachments independent', async () => {
+ mount();
+ fireEvent.click(screen.getByRole('button', { name: 'Comments' }));
+ selection = { anchor: 'D9', focus: 'D9' };
+ fireEvent.click(screen.getByRole('button', { name: 'Comment' }));
+ const panel = screen.getByRole('complementary');
+ fireEvent.input(panel.querySelector('input')!, {
+ target: { value: 'Sidebar draft' },
+ });
+ fireEvent.click(
+ [...panel.querySelectorAll('button')].find(
+ (button) => button.textContent === 'Post'
+ )!
+ );
+ await waitFor(() =>
+ expect(mocks.api.create).toHaveBeenCalledWith(
+ expect.objectContaining({
+ text: 'Sidebar draft',
+ threadMetadata: expect.objectContaining({ spreadsheet: anchor }),
+ })
+ )
+ );
+ expect(screen.getByRole('dialog').getAttribute('aria-label')).toBe(
+ 'Comments on Budget · D9'
+ );
+ expect(screen.getByRole('dialog').querySelector('input')).toBeTruthy();
+});
diff --git a/apps/web/src/features/block-spreadsheet/SpreadsheetComments.tsx b/apps/web/src/features/block-spreadsheet/SpreadsheetComments.tsx
new file mode 100644
index 0000000000..6e1c068e79
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/SpreadsheetComments.tsx
@@ -0,0 +1,399 @@
+import { SplitHeaderRight } from '@components/app/split-layout/components/SplitHeader';
+import {
+ Discussion,
+ DiscussionComposer,
+ DiscussionProvider,
+} from '@core/comments/discussion';
+import { StaticMarkdownContext } from '@core/component/LexicalMarkdown/component/core/StaticMarkdown';
+import { useUrlParams } from '@core/component/ParamsProvider';
+import { useUserId } from '@core/context/user';
+import { useCanComment } from '@core/signal/permissions';
+import { buildSimpleEntityUrl } from '@core/util/url';
+import ChatIcon from '@phosphor/chat-circle.svg';
+import XIcon from '@phosphor/x.svg';
+import { Button } from '@ui/components/Button';
+import {
+ createEffect,
+ createMemo,
+ createSignal,
+ type JSX,
+ on,
+ onCleanup,
+ Show,
+} from 'solid-js';
+import { SpreadsheetCommentCard } from './components/SpreadsheetCommentCard';
+import type { SpreadsheetCommentsCapability } from './context/spreadsheet-comments';
+import { spreadsheetChatContext } from './core/chat-context';
+import {
+ cellAddress,
+ positionFromAddress,
+ selectionBounds,
+} from './core/grid-selection';
+import {
+ SPREADSHEET_COMMENT_PARAMS,
+ type SpreadsheetCommentAnchor,
+ spreadsheetCommentAnchor,
+} from './core/spreadsheet-comments';
+import { createSpreadsheetDiscussion } from './primitives/create-spreadsheet-discussion';
+import type { SpreadsheetStore } from './primitives/create-spreadsheet-store';
+import { useSpreadsheetComments } from './queries/spreadsheet-comments';
+
+/** Production wiring: shared discussions + the document annotation service. */
+export function SpreadsheetComments(props: {
+ documentId: string;
+ store: SpreadsheetStore;
+ children: (
+ location: () => SpreadsheetCommentAnchor | undefined,
+ comments: SpreadsheetCommentsCapability
+ ) => JSX.Element;
+}) {
+ const userId = useUserId();
+ const canComment = useCanComment();
+ const params = useUrlParams(SPREADSHEET_COMMENT_PARAMS);
+ const { query, api, refresh } = useSpreadsheetComments(props.documentId);
+ const [open, setOpen] = createSignal(false);
+ const [anchor, setAnchor] = createSignal<SpreadsheetCommentAnchor>();
+ const [location, setLocation] = createSignal<SpreadsheetCommentAnchor>();
+ const [error, setError] = createSignal('');
+ const threads = () => (query.isSuccess ? query.data : []);
+ const request = createMemo(() => ({ id: params.commentId() }), undefined, {
+ equals: false,
+ });
+ const target = () => request().id ?? null;
+ const [card, setCard] = createSignal<{
+ element: HTMLElement;
+ anchor: SpreadsheetCommentAnchor;
+ threadIds: string[];
+ creating: boolean;
+ pinned: boolean;
+ }>();
+ let hoverTimer: ReturnType<typeof setTimeout> | undefined;
+ const clearHover = () => {
+ clearTimeout(hoverTimer);
+ hoverTimer = undefined;
+ };
+ const closeCard = () => {
+ clearHover();
+ setCard(undefined);
+ };
+ onCleanup(clearHover);
+ const makeSource = (
+ getAnchor: () => SpreadsheetCommentAnchor | undefined,
+ operations = api
+ ) =>
+ createSpreadsheetDiscussion({
+ threads,
+ canComment,
+ userId,
+ anchor: getAnchor,
+ targetCommentId: target,
+ targetRevision: request,
+ api: operations,
+ refresh,
+ buildLink: (id) =>
+ buildSimpleEntityUrl(
+ { type: 'spreadsheet', id: props.documentId },
+ { comment_id: id }
+ ),
+ });
+ const source = makeSource(anchor);
+ const cardSource = makeSource(() => card()?.anchor, {
+ ...api,
+ create: async (body) => {
+ const postingCard = card();
+ const result = await api.create(body);
+ if (!body.threadId && postingCard?.creating && card() === postingCard) {
+ setCard({
+ ...postingCard,
+ creating: false,
+ threadIds: [String(result.thread.threadId)],
+ });
+ }
+ return result;
+ },
+ });
+ const count = () =>
+ source
+ .threads()
+ .reduce(
+ (sum, thread) =>
+ sum + thread.comments.filter((comment) => !comment.deletedAt).length,
+ 0
+ );
+ const navigate = (value: SpreadsheetCommentAnchor) => {
+ const sheet = props.store
+ .workbook()
+ .find((sheet) => sheet.id === value.sheetId);
+ if (!sheet) {
+ setError('This comment refers to a sheet that has been deleted.');
+ return;
+ }
+ const last = positionFromAddress(value.range.split(':').at(-1)!);
+ if (!last || last.row >= sheet.layout.rowCount) {
+ setError('The cells referenced by this comment are no longer available.');
+ return;
+ }
+ setError('');
+ setLocation({ ...value });
+ };
+ const currentAnchor = () => {
+ const context = spreadsheetChatContext(
+ props.store.activeSheet(),
+ props.store.selection()
+ );
+ return {
+ sheetId: context.sheetId,
+ sheetName: context.sheetName,
+ range: context.range,
+ };
+ };
+ const selectAnchor = () => setAnchor(currentAnchor());
+ const toggle = () => {
+ if (!open()) selectAnchor();
+ closeCard();
+ setOpen(!open());
+ };
+ const anchoredThreads = createMemo(() =>
+ threads().flatMap((thread) => {
+ const value = spreadsheetCommentAnchor(thread.thread.metadata);
+ if (
+ !value ||
+ thread.thread.deletedAt ||
+ !thread.comments.some((comment) => !comment.deletedAt) ||
+ value.sheetId !== props.store.activeSheetId()
+ )
+ return [];
+ const [start, end = start] = value.range.split(':');
+ const first = positionFromAddress(start)!;
+ const last = positionFromAddress(end)!;
+ const bounds = selectionBounds({ anchor: first, focus: last });
+ return [{ id: String(thread.thread.threadId), anchor: value, bounds }];
+ })
+ );
+ const markers = createMemo(
+ () =>
+ new Set(
+ anchoredThreads().map(({ bounds }) =>
+ cellAddress({ row: bounds.top, column: bounds.left })
+ )
+ )
+ );
+ const showCell = (address: string, element: HTMLElement, pinned: boolean) => {
+ const position = positionFromAddress(address);
+ if (!position) return;
+ const hits = anchoredThreads().filter(
+ ({ bounds }) =>
+ position.row >= bounds.top &&
+ position.row <= bounds.bottom &&
+ position.column >= bounds.left &&
+ position.column <= bounds.right
+ );
+ if (!hits.length) {
+ setCard(undefined);
+ return;
+ }
+ setCard({
+ element,
+ anchor: hits[0].anchor,
+ threadIds: hits.map((hit) => hit.id),
+ creating: false,
+ pinned,
+ });
+ };
+ const comments: SpreadsheetCommentsCapability = {
+ canComment: () => canComment() && props.store.ready(),
+ hasComment: (address) => markers().has(address),
+ add: (element) => {
+ if (!canComment()) return;
+ clearHover();
+ const selected = currentAnchor();
+ if (!element) {
+ setAnchor(selected);
+ setOpen(true);
+ return;
+ }
+ setCard({
+ element,
+ anchor: selected,
+ threadIds: [],
+ creating: true,
+ pinned: true,
+ });
+ },
+ show: (address, element) => {
+ clearHover();
+ showCell(address, element, true);
+ },
+ enter: (address, element) => {
+ clearHover();
+ if (card()?.pinned) return;
+ hoverTimer = setTimeout(() => showCell(address, element, false), 250);
+ },
+ leave: () => {
+ clearHover();
+ if (card()?.pinned) return;
+ hoverTimer = setTimeout(() => setCard(undefined), 350);
+ },
+ };
+ // Tab changes invalidate the floating DOM anchor.
+ createEffect(on(props.store.activeSheetId, closeCard, { defer: true }));
+ // URL navigation is an external event, including repeated inbox opens of the same comment.
+ createEffect(
+ on(
+ [request, () => query.isSuccess, props.store.ready],
+ ([value, loaded, ready]) => {
+ if (!value.id) return;
+ closeCard();
+ setOpen(true);
+ if (!loaded || !ready) return;
+ const thread = threads().find((thread) =>
+ thread.comments.some(
+ (comment) => String(comment.commentId) === value.id
+ )
+ );
+ const linked = spreadsheetCommentAnchor(thread?.thread.metadata);
+ if (linked) navigate(linked);
+ }
+ )
+ );
+ return (
+ <DiscussionProvider source={source}>
+ <SplitHeaderRight>
+ <Button
+ size="sm"
+ variant="ghost"
+ onClick={toggle}
+ aria-label="Comments"
+ aria-expanded={open()}
+ >
+ <ChatIcon class="size-4" />
+ <span class="hidden sm:inline">Comments</span>
+ <Show when={count()}>
+ <span class="text-xs">{count()}</span>
+ </Show>
+ </Button>
+ </SplitHeaderRight>
+ <div class="relative flex min-h-0 min-w-0 flex-1 overflow-hidden">
+ <div class="flex min-h-0 min-w-0 flex-1 flex-col">
+ {props.children(location, comments)}
+ </div>
+ <Show when={open()}>
+ <aside
+ aria-label="Spreadsheet comments"
+ class="absolute inset-0 z-30 flex flex-col bg-panel border-l border-edge-muted sm:static sm:w-96 sm:shrink-0"
+ >
+ <div class="flex items-center justify-between border-b border-edge-muted px-4 py-2">
+ <h2 class="text-sm font-medium">Comments</h2>
+ <Button
+ size="sm"
+ variant="ghost"
+ aria-label="Close comments"
+ onClick={() => setOpen(false)}
+ >
+ <XIcon class="size-4" />
+ </Button>
+ </div>
+ <div class="min-h-0 flex-1 overflow-y-auto p-3">
+ <Show when={query.isPending}>
+ <p class="text-sm text-ink-muted">Loading comments…</p>
+ </Show>
+ <Show when={query.isError}>
+ <p role="alert" class="text-sm">
+ Could not load comments.{' '}
+ <button
+ class="underline"
+ onClick={() => void query.refetch()}
+ >
+ Try again
+ </button>
+ </p>
+ </Show>
+ <Show when={error()}>
+ <p role="status" class="text-sm text-ink-muted">
+ {error()}
+ </p>
+ </Show>
+ <Show when={query.isSuccess && !count()}>
+ <p class="py-4 text-sm text-ink-muted">
+ No comments yet. Start a discussion about the selected cells.
+ </p>
+ </Show>
+ <Discussion
+ hideComposer
+ threadHeader={(thread) => {
+ const linked = () =>
+ spreadsheetCommentAnchor(
+ threads().find(
+ (item) => String(item.thread.threadId) === thread.id
+ )?.thread.metadata
+ );
+ const label = () => {
+ const value = linked();
+ if (!value) return 'Workbook';
+ const sheet = props.store
+ .workbook()
+ .find((sheet) => sheet.id === value.sheetId);
+ return `${sheet?.name ?? value.sheetName} · ${value.range}${sheet ? '' : ' (deleted sheet)'}`;
+ };
+ return (
+ <button
+ class="mt-3 mb-1 rounded px-2 py-1 text-xs text-accent hover:bg-hover"
+ disabled={!linked()}
+ onClick={() => {
+ const value = linked();
+ if (value) navigate(value);
+ }}
+ >
+ {label()}
+ </button>
+ );
+ }}
+ />
+ </div>
+ <Show when={canComment()}>
+ <div class="shrink-0 border-t border-edge-muted p-3">
+ <div class="mb-2 flex items-center justify-between gap-2 text-xs text-ink-muted">
+ <span>
+ {anchor()
+ ? `${anchor()!.sheetName} · ${anchor()!.range}`
+ : 'Workbook comment'}
+ </span>
+ <button class="underline" onClick={selectAnchor}>
+ Use selection
+ </button>
+ </div>
+ <StaticMarkdownContext>
+ <DiscussionComposer />
+ </StaticMarkdownContext>
+ </div>
+ </Show>
+ </aside>
+ </Show>
+ </div>
+ <Show when={card()}>
+ {(value) => (
+ <DiscussionProvider source={cardSource}>
+ <SpreadsheetCommentCard
+ element={value().element}
+ label={`${props.store.workbook().find((sheet) => sheet.id === value().anchor.sheetId)?.name ?? value().anchor.sheetName} · ${value().anchor.range}`}
+ creating={value().creating}
+ threads={source
+ .threads()
+ .filter((thread) => value().threadIds.includes(thread.id))}
+ onEnter={clearHover}
+ onLeave={comments.leave}
+ onInteract={() => {
+ clearHover();
+ if (!card()?.pinned)
+ setCard((current) =>
+ current ? { ...current, pinned: true } : current
+ );
+ }}
+ onClose={closeCard}
+ />
+ </DiscussionProvider>
+ )}
+ </Show>
+ </DiscussionProvider>
+ );
+}
diff --git a/apps/web/src/features/block-spreadsheet/SpreadsheetDemo.test.tsx b/apps/web/src/features/block-spreadsheet/SpreadsheetDemo.test.tsx
index 292ba18fb3..33f4a02078 100644
--- a/apps/web/src/features/block-spreadsheet/SpreadsheetDemo.test.tsx
+++ b/apps/web/src/features/block-spreadsheet/SpreadsheetDemo.test.tsx
@@ -9,6 +9,7 @@ import type { JSX, ParentProps } from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { SpreadsheetStore } from './primitives/create-spreadsheet-store';
+vi.mock('./spreadsheet-mentions', () => ({ spreadsheetMentions: undefined }));
const mocks = vi.hoisted(() => ({
create: vi.fn(),
save: vi.fn(),
diff --git a/apps/web/src/features/block-spreadsheet/SpreadsheetDemo.tsx b/apps/web/src/features/block-spreadsheet/SpreadsheetDemo.tsx
index afbd1be5a0..649b3fc101 100644
--- a/apps/web/src/features/block-spreadsheet/SpreadsheetDemo.tsx
+++ b/apps/web/src/features/block-spreadsheet/SpreadsheetDemo.tsx
@@ -16,7 +16,6 @@ import { downloadFile } from '@filesystem/download';
import IconShared from '@phosphor/share.svg';
import { Button, Dialog } from '@ui';
import { createSignal } from 'solid-js';
-
import { spreadsheetChatContext } from './core/chat-context';
import type { SpreadsheetCells } from './core/spreadsheet-document';
import { createDraftActions } from './primitives/create-draft-actions';
@@ -24,6 +23,7 @@ import { createLocalSpreadsheetSource } from './primitives/create-local-spreadsh
import { createSpreadsheetStore } from './primitives/create-spreadsheet-store';
import { createSpreadsheetDocument } from './queries/create-spreadsheet';
import { saveSpreadsheetDraft } from './queries/save-spreadsheet-draft';
+import { spreadsheetMentions } from './spreadsheet-mentions';
import { SpreadsheetDraftMenu } from './views/SpreadsheetDraftMenu';
import { SpreadsheetEditor } from './views/SpreadsheetEditor';
@@ -214,6 +214,7 @@ export default function SpreadsheetDemo() {
</Dialog>
<div class="min-h-0 min-w-0 flex-1">
<SpreadsheetEditor
+ mentions={spreadsheetMentions}
store={store}
name={name()}
onExportXlsx={(bytes) =>
diff --git a/apps/web/src/features/block-spreadsheet/browser-test/fixture.tsx b/apps/web/src/features/block-spreadsheet/browser-test/fixture.tsx
index 80400aacf4..d43e544f1d 100644
--- a/apps/web/src/features/block-spreadsheet/browser-test/fixture.tsx
+++ b/apps/web/src/features/block-spreadsheet/browser-test/fixture.tsx
@@ -9,8 +9,13 @@ import {
SyncServiceSource,
} from '@macro-inc/collaboration/sync-service/source';
import { createWebsocketStateSignal } from '@macro-inc/collaboration/websocket/solid/state-signal';
+import {
+ cellPlainText,
+ encodeCellMention,
+} from '@macro-inc/spreadsheet/cell-mentions';
import { createEffect, createSignal, onCleanup } from 'solid-js';
import { render } from 'solid-js/web';
+import { CellMentionEditor } from '../components/CellMentionEditor';
import type { SpreadsheetWorkbookSheet } from '../core/workbook-document';
import { createLocalSpreadsheetSource } from '../primitives/create-local-spreadsheet-source';
import { createSpreadsheetStore } from '../primitives/create-spreadsheet-store';
@@ -88,6 +93,40 @@ function Fixture() {
return (
<main class="h-[calc(var(--dvh,1dvh)*100)] w-screen overflow-hidden bg-page font-sans text-ink">
<SpreadsheetEditor
+ mentions={
+ params.has('mentions')
+ ? {
+ renderText: cellPlainText,
+ renderEditor: (props) => (
+ <CellMentionEditor
+ {...props}
+ convertPaste={(value) => value}
+ renderMenu={(menu, _anchor, pick) => (
+ <button
+ type="button"
+ class="fixed right-4 top-4 z-[100]"
+ aria-label="Mention Taylor"
+ onPointerDown={(e) => e.preventDefault()}
+ onMouseDown={(e) => e.preventDefault()}
+ onClick={() =>
+ pick(
+ encodeCellMention({
+ type: 'user',
+ userId: 'macro|[email protected]',
+ email: '[email protected]',
+ displayName: 'Taylor',
+ })
+ )
+ }
+ >
+ Taylor ({menu.searchTerm()})
+ </button>
+ )}
+ />
+ ),
+ }
+ : undefined
+ }
store={store}
name="Browser fixture"
autoFocus
diff --git a/apps/web/src/features/block-spreadsheet/browser-test/spreadsheet.browser.e2e.ts b/apps/web/src/features/block-spreadsheet/browser-test/spreadsheet.browser.e2e.ts
index 0b959efab6..87e7e572ba 100644
--- a/apps/web/src/features/block-spreadsheet/browser-test/spreadsheet.browser.e2e.ts
+++ b/apps/web/src/features/block-spreadsheet/browser-test/spreadsheet.browser.e2e.ts
@@ -162,7 +162,10 @@ test('view options toggle display directly and return focus to the selected cell
await expect(grid).toBeFocused();
await expect(total).toHaveAttribute('aria-selected', 'true');
}
- await expect(total).toHaveCSS('border-color', 'rgba(0, 0, 0, 0)');
+ await expect(total).toHaveCSS('border-bottom-color', 'rgba(0, 0, 0, 0)');
+ await expect(total).toHaveCSS('border-right-color', 'rgba(0, 0, 0, 0)');
+ await expect(total).toHaveCSS('border-top-width', '0px');
+ await expect(total).toHaveCSS('border-left-width', '0px');
await expect(formulaBar).toBeHidden();
await expect(total).toHaveText('=SUM(B2:B3)');
@@ -512,7 +515,13 @@ test('ribbon formatting and data actions preserve the range, formulas, focus, an
await expect(address).toHaveValue('A2:B3');
await expect(page.locator('[data-address="A2"]')).toHaveText('Engineering');
await expect(page.locator('[data-address="B2"]')).toHaveText('20');
- await expect(page.locator('[data-address="A3"]')).toHaveText('Design');
+ await expect
+ .poll(
+ async () =>
+ (await page.evaluate(() => window.spreadsheetFixture.snapshot()[0]))
+ .cells
+ )
+ .toMatchObject({ A3: { value: 'Design' } });
await expect(page.locator('[data-address="B4"]')).toHaveText('30');
await page.getByRole('button', { name: 'Undo', exact: true }).click();
await expect(page.locator('[data-address="A2"]')).toHaveText('Design');
@@ -581,3 +590,255 @@ test('double-click renames tabs and right-click actions target the clicked sheet
page.getByRole('menuitem', { name: label, exact: true })
).toBeDisabled();
});
+
+test('imports, edits and exports an independent financial workbook using real workers', async ({
+ page,
+}) => {
+ const chooser = page.waitForEvent('filechooser');
+ await menu(page, 'Import and export', 'Import…');
+ await (await chooser).setFiles(
+ fileURLToPath(
+ new URL('../core/xlsx-fixtures/financial-model.xlsx', import.meta.url)
+ )
+ );
+ await page.getByRole('button', { name: 'Import workbook' }).click();
+ await page.getByRole('tab', { name: 'DCF model', exact: true }).click();
+ await expect(page.locator('[data-address="B18"]')).toHaveText(
+ '(1,250,000.13)'
+ );
+ await expect(page.locator('[data-address="B14"]')).toHaveText('25');
+ await page.getByRole('button', { name: 'View options', exact: true }).click();
+ await page
+ .getByRole('menuitemcheckbox', { name: 'Gridlines', exact: true })
+ .click();
+ await page.keyboard.press('Escape');
+ await expect(page.locator('[data-address="B18"]')).toHaveCSS(
+ 'border-bottom-style',
+ 'double'
+ );
+ await expect(page.locator('[data-address="B18"]')).toHaveCSS(
+ 'border-bottom-color',
+ 'rgb(18, 52, 86)'
+ );
+ await page.locator('[data-address="B18"]').dblclick();
+ await page
+ .getByRole('textbox', { name: 'Edit B18', exact: true })
+ .fill('-2500000.125');
+ await page.keyboard.press('Enter');
+ await expect(page.locator('[data-address="B18"]')).toHaveText(
+ '(2,500,000.13)'
+ );
+ const downloaded = page.waitForEvent('download');
+ await menu(page, 'Import and export', 'Download as Excel (.xlsx)');
+ const path = await (await downloaded).path();
+ if (!path) throw new Error('Workbook download missing');
+ const workbook = new ExcelJS.Workbook();
+ await workbook.xlsx.readFile(path);
+ const model = workbook.getWorksheet('DCF model')!;
+ expect(model.getCell('B18').value).toBe(-2500000.125);
+ expect(model.getCell('B18').numFmt).toBe('#,##0.00;[Red](#,##0.00);"—"');
+ expect(model.getCell('B18').border.bottom?.style).toBe('double');
+ expect(model.getCell('B14').value).toEqual({
+ formula: 'TaxRate*100',
+ result: 25,
+ });
+ expect(model.getCell('A1').isMerged).toBe(true);
+ expect(model.getRow(6).hidden).toBe(true);
+ expect(model.views[0]).toMatchObject({
+ state: 'frozen',
+ xSplit: 1,
+ ySplit: 3,
+ });
+});
+
+test('row context menu inserts and deletes with formula updates and supports undo', async ({
+ page,
+}) => {
+ await page
+ .getByRole('button', { name: 'Select row 2', exact: true })
+ .click({ button: 'right' });
+ await page
+ .getByRole('menuitem', { name: 'Insert 1 row above', exact: true })
+ .click();
+ await expect
+ .poll(
+ async () =>
+ (await page.evaluate(() => window.spreadsheetFixture.snapshot()[0]))
+ .cells
+ )
+ .toMatchObject({ A3: { value: 'Design' } });
+ await expect(page.locator('[data-address="B5"]')).toHaveText('30');
+ const after = await page.evaluate(
+ () => window.spreadsheetFixture.snapshot()[0]
+ );
+ expect(after.cells.B5.value).toBe('=SUM(B3:B4)');
+ await page
+ .getByRole('button', { name: 'Select row 3', exact: true })
+ .click({ button: 'right' });
+ await page
+ .getByRole('menuitem', { name: 'Delete 1 row', exact: true })
+ .click();
+ await expect(page.locator('[data-address="A3"]')).toHaveText('Engineering');
+ await expect(page.locator('[data-address="B4"]')).toHaveText('20');
+ await page.getByRole('grid').press('ControlOrMeta+z');
+ await expect(page.locator('[data-address="A3"]')).toHaveText('Design');
+ await expect(page.locator('[data-address="B5"]')).toHaveText('30');
+});
+
+test('column context menu hides, unhides and resizes without losing data', async ({
+ page,
+}) => {
+ await page
+ .getByRole('button', { name: 'Select column B', exact: true })
+ .click({ button: 'right' });
+ await page
+ .getByRole('menuitem', { name: 'Hide 1 column', exact: true })
+ .click();
+ await expect(
+ page.getByRole('button', { name: 'Select column B', exact: true })
+ ).toHaveCount(0);
+ await page.locator('[data-address="A2"]').click();
+ await page.getByRole('grid').press('ArrowRight');
+ await expect(page.locator('[data-address="C2"]')).toHaveAttribute(
+ 'aria-selected',
+ 'true'
+ );
+ await page
+ .getByRole('button', { name: 'Select column A', exact: true })
+ .click({ button: 'right' });
+ await page
+ .getByRole('menuitem', { name: 'Unhide all columns', exact: true })
+ .click();
+ await expect(page.locator('[data-address="B4"]')).toHaveText('30');
+ await page
+ .getByRole('button', { name: 'Select column B', exact: true })
+ .click({ button: 'right' });
+ await page
+ .getByRole('menuitem', { name: 'Resize 1 column…', exact: true })
+ .click();
+ await page.getByRole('spinbutton', { name: 'Size in pixels' }).fill('180');
+ await page.getByRole('button', { name: 'Apply', exact: true }).click();
+ await expect(page.locator('[data-address="B2"]')).toHaveCSS('width', '180px');
+});
+
+test('header context menus respect view-only access', async ({ page }) => {
+ await page.evaluate(() => window.spreadsheetFixture.setReadonly(true));
+ await page
+ .getByRole('button', { name: 'Select row 2', exact: true })
+ .click({ button: 'right' });
+ await expect(
+ page.getByRole('menuitem', { name: 'Copy', exact: true })
+ ).not.toHaveAttribute('aria-disabled', 'true');
+ await expect(
+ page.getByRole('menuitem', { name: 'Delete 1 row', exact: true })
+ ).toHaveAttribute('aria-disabled', 'true');
+ await expect(
+ page.getByRole('menuitem', { name: 'Insert 1 row above', exact: true })
+ ).toHaveAttribute('aria-disabled', 'true');
+});
+
+test('cell mention editor retains focus, inserts atomic pills, and can switch to formulas', async ({
+ page,
+}) => {
+ await page.goto('/?mentions');
+ await expect(page.locator('[data-address="B4"]')).toHaveText('30');
+ await page.locator('[data-address="A6"]').dblclick();
+ const editor = page.getByRole('textbox', { name: 'Edit A6', exact: true });
+ await expect(editor).toBeFocused();
+ await editor.pressSequentially('Owner @tay');
+ await expect(editor).toBeFocused();
+ await expect(editor).toHaveText('Owner @tay');
+ await page.getByRole('button', { name: 'Mention Taylor' }).click();
+ await expect(editor).toBeFocused();
+ await expect(editor.locator('[data-cell-mention]')).toHaveText('@Taylor');
+ await editor.press('Enter');
+ await expect(page.locator('[data-address="A6"]')).toHaveText(
+ 'Owner @Taylor '
+ );
+ await page.locator('[data-address="B6"]').dblclick();
+ await page
+ .getByRole('textbox', { name: 'Edit B6', exact: true })
+ .pressSequentially('=SUM(B2:B3)');
+ await expect(
+ page.getByRole('textbox', { name: 'Edit B6', exact: true })
+ ).toBeFocused();
+ await page.keyboard.press('Enter');
+ await expect(page.locator('[data-address="B6"]')).toHaveText('30');
+});
+
+test('mention editing switches back from formulas and leaves other inputs focusable', async ({
+ page,
+}) => {
+ await page.goto('/?mentions');
+ await expect(page.locator('[data-address="B4"]')).toHaveText('30');
+ await page.locator('[data-address="A6"]').dblclick();
+ let editor = page.getByRole('textbox', { name: 'Edit A6', exact: true });
+ await editor.pressSequentially('=');
+ await editor.press('Backspace');
+ await expect(editor).toBeFocused();
+ await editor.pressSequentially('**plain** @tay');
+ await page.getByRole('button', { name: 'Mention Taylor' }).click();
+ await editor.press('Enter');
+ await expect(page.locator('[data-address="A6"]')).toHaveText(
+ '**plain** @Taylor '
+ );
+ await page.getByRole('textbox', { name: 'Formula bar', exact: true }).click();
+ await expect(
+ page.getByRole('textbox', { name: 'Formula bar', exact: true })
+ ).toBeFocused();
+});
+
+test('header menu keyboard navigation keeps the targeted row selected', async ({
+ page,
+}) => {
+ await page
+ .getByRole('button', { name: 'Select row 4', exact: true })
+ .click({ button: 'right' });
+ await expect(
+ page.getByRole('textbox', { name: 'Go to cell', includeHidden: true })
+ ).toHaveValue('A4:Z4');
+ await page.keyboard.press('ArrowDown');
+ await expect(
+ page.getByRole('textbox', { name: 'Go to cell', includeHidden: true })
+ ).toHaveValue('A4:Z4');
+ await page.keyboard.press('Escape');
+ await expect(
+ page.getByRole('textbox', { name: 'Go to cell', includeHidden: true })
+ ).toHaveValue('A4:Z4');
+});
+
+test('cell context menu preserves ranges, edits the right cells and supports keyboard dismissal', async ({
+ page,
+}) => {
+ const grid = page.getByRole('grid', { name: 'Spreadsheet' });
+ await page.locator('[data-address="B2"]').click();
+ await page.locator('[data-address="B3"]').click({ modifiers: ['Shift'] });
+ await page.locator('[data-address="B2"]').click({ button: 'right' });
+ await expect(page.getByRole('menu')).toBeVisible();
+ await expect(
+ page.getByRole('menuitem', { name: 'Fill down', exact: true })
+ ).toBeEnabled();
+ await expect(
+ page.getByRole('menuitem', { name: 'Fill right', exact: true })
+ ).toBeDisabled();
+ await page.getByRole('menuitem', { name: 'Fill down', exact: true }).click();
+ await expect(grid).toBeFocused();
+ await expect(page.locator('[data-address="B3"]')).toHaveText('10');
+ await expect(page.locator('[data-address="B4"]')).toHaveText('20');
+ await page.locator('[data-address="A2"]').click({ button: 'right' });
+ await page
+ .getByRole('menuitem', { name: 'Clear values', exact: true })
+ .click();
+ await expect(page.locator('[data-address="A2"]')).toHaveText('');
+ await expect(page.locator('[data-address="A3"]')).toHaveText('Engineering');
+ await grid.press('Shift+F10');
+ await expect(page.getByRole('menu')).toBeVisible();
+ await page.keyboard.press('Escape');
+ await expect(page.getByRole('menu')).toHaveCount(0);
+ await expect(grid).toBeFocused();
+ await page.locator('[data-address="B2"]').dblclick();
+ const editor = page.getByRole('textbox', { name: 'Edit B2', exact: true });
+ await editor.click({ button: 'right' });
+ await expect(page.getByRole('menu')).toHaveCount(0);
+ await expect(editor).toHaveValue('10');
+});
diff --git a/apps/web/src/features/block-spreadsheet/browser-test/vite.config.ts b/apps/web/src/features/block-spreadsheet/browser-test/vite.config.ts
index d6860ed8b2..ddf25b8a38 100644
--- a/apps/web/src/features/block-spreadsheet/browser-test/vite.config.ts
+++ b/apps/web/src/features/block-spreadsheet/browser-test/vite.config.ts
@@ -26,7 +26,9 @@ export default defineConfig({
},
// Worker-only lazy dependencies otherwise trigger a page reload on the first
// import, discarding the file chooser's pending request in a cold test run.
- optimizeDeps: { include: ['@ironcalc/wasm', 'exceljs', 'fflate', 'saxes'] },
+ optimizeDeps: {
+ include: ['@ironcalc/wasm', 'exceljs', 'fflate', 'saxes', 'ssf'],
+ },
server: {
host: '127.0.0.1',
port: 3017,
diff --git a/apps/web/src/features/block-spreadsheet/components/CellMentionEditor.tsx b/apps/web/src/features/block-spreadsheet/components/CellMentionEditor.tsx
new file mode 100644
index 0000000000..4e2a267161
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/components/CellMentionEditor.tsx
@@ -0,0 +1,191 @@
+import { createMenuOperations } from '@core/component/LexicalMarkdown/shared/inlineMenu';
+import { cellMentionQuery } from '@macro-inc/spreadsheet/cell-mentions';
+import {
+ createEffect,
+ createSignal,
+ type JSX,
+ on,
+ onCleanup,
+ onMount,
+ Show,
+} from 'solid-js';
+import type { CellTextEditorProps } from '../context/spreadsheet-mentions';
+import {
+ cellTextSelection,
+ readCellText,
+ setCellTextCursor,
+ writeCellText,
+} from '../primitives/cell-mention-dom';
+
+export function CellMentionEditor(
+ props: CellTextEditorProps & {
+ convertPaste: (value: string) => string;
+ renderMenu: (
+ menu: ReturnType<typeof createMenuOperations>,
+ anchor: HTMLElement,
+ pick: (value: string) => void
+ ) => JSX.Element;
+ }
+) {
+ let root!: HTMLDivElement;
+ const [anchor, setAnchor] = createSignal<HTMLElement>();
+ const menu = createMenuOperations();
+ let acceptedValue = props.value;
+ let search: ReturnType<typeof cellMentionQuery>;
+ const update = () => {
+ if (props.readonly || document.activeElement !== root) {
+ menu.closeMenu();
+ return;
+ }
+ const selection = cellTextSelection(root);
+ if (!selection) return;
+ props.onSelectionChange?.(selection.start, selection.end);
+ search =
+ selection.start === selection.end
+ ? cellMentionQuery(readCellText(root), selection.start)
+ : undefined;
+ if (search) {
+ menu.setSearchTerm(search.query);
+ menu.openMenu();
+ } else menu.closeMenu();
+ };
+ const publish = () => {
+ const value = readCellText(root);
+ if (value.length > 10_000) {
+ writeCellText(root, acceptedValue);
+ setCellTextCursor(root, acceptedValue.length);
+ return;
+ }
+ acceptedValue = value;
+ props.onInput(value);
+ update();
+ };
+ const replace = (text: string, start?: number, end?: number) => {
+ const selection = cellTextSelection(root);
+ const value = readCellText(root);
+ const from = start ?? selection?.start ?? value.length;
+ const to = end ?? selection?.end ?? from;
+ const next = value.slice(0, from) + text + value.slice(to);
+ if (next.length > 10_000) return;
+ writeCellText(root, next);
+ root.focus({ preventScroll: true });
+ setCellTextCursor(root, from + text.length);
+ publish();
+ };
+ onMount(() => {
+ writeCellText(root, props.value);
+ setAnchor(root);
+ document.addEventListener('selectionchange', update);
+ onCleanup(() => document.removeEventListener('selectionchange', update));
+ if (props.autoFocus) {
+ root.focus({ preventScroll: true });
+ setCellTextCursor(root, props.value.length);
+ update();
+ }
+ });
+ createEffect(
+ on(
+ () => props.value,
+ (value) => {
+ if (!root || value === acceptedValue) return;
+ acceptedValue = value;
+ writeCellText(root, value);
+ }
+ )
+ );
+ return (
+ <>
+ <div
+ ref={root}
+ role="textbox"
+ aria-label={props.label}
+ aria-readonly={props.readonly}
+ data-spreadsheet-input
+ contentEditable={!props.readonly}
+ tabIndex={0}
+ class={`${props.class} whitespace-pre-wrap touch:text-[max(16px,1rem)]`}
+ spellcheck={false}
+ onFocus={() => {
+ props.onFocus?.();
+ update();
+ }}
+ onInput={publish}
+ onKeyDown={(event) => {
+ event.stopPropagation();
+ if (event.isComposing) return;
+ if (event.key === 'Enter' && event.altKey && !props.readonly) {
+ event.preventDefault();
+ replace('\n');
+ return;
+ }
+ props.onKeyDown(event);
+ }}
+ onPaste={(event) => {
+ event.preventDefault();
+ event.stopPropagation();
+ if (!props.readonly)
+ replace(
+ props.convertPaste(
+ event.clipboardData?.getData('text/plain') ?? ''
+ )
+ );
+ }}
+ onCopy={(event) => {
+ const selected = cellTextSelection(root);
+ if (!selected || selected.start === selected.end) return;
+ event.preventDefault();
+ event.stopPropagation();
+ event.clipboardData?.setData(
+ 'text/plain',
+ readCellText(root).slice(selected.start, selected.end)
+ );
+ }}
+ onCut={(event) => {
+ const selected = cellTextSelection(root);
+ if (!selected || selected.start === selected.end) return;
+ event.preventDefault();
+ event.stopPropagation();
+ event.clipboardData?.setData(
+ 'text/plain',
+ readCellText(root).slice(selected.start, selected.end)
+ );
+ if (!props.readonly) replace('', selected.start, selected.end);
+ }}
+ onDrop={(event) => {
+ event.preventDefault();
+ event.stopPropagation();
+ if (!props.readonly)
+ replace(
+ props.convertPaste(
+ event.dataTransfer?.getData('text/plain') ?? ''
+ )
+ );
+ }}
+ onBlur={() => {
+ menu.closeMenu();
+ props.onBlur();
+ }}
+ />
+ <Show when={anchor() && menu.isOpen()}>
+ <div
+ class="contents"
+ onPointerDown={(event) => {
+ event.preventDefault();
+ event.stopPropagation();
+ }}
+ onMouseDown={(event) => {
+ event.preventDefault();
+ event.stopPropagation();
+ }}
+ onClick={(event) => event.stopPropagation()}
+ >
+ {props.renderMenu(menu, anchor()!, (value) => {
+ if (search && !props.readonly)
+ replace(value + ' ', search.start, search.end);
+ menu.closeMenu();
+ })}
+ </div>
+ </Show>
+ </>
+ );
+}
diff --git a/apps/web/src/features/block-spreadsheet/components/FormulaInput.test.tsx b/apps/web/src/features/block-spreadsheet/components/FormulaInput.test.tsx
index 92189df4d8..9b285ecdff 100644
--- a/apps/web/src/features/block-spreadsheet/components/FormulaInput.test.tsx
+++ b/apps/web/src/features/block-spreadsheet/components/FormulaInput.test.tsx
@@ -109,3 +109,25 @@ it.each(['readonly', 'pickingReference'] as const)(
expect(input.hasAttribute('aria-describedby')).toBe(false);
}
);
+
+it('commits on blur after starting a formula without a mention adapter', () => {
+ const blur = vi.fn();
+ const view = render(() => {
+ const [value, setValue] = createSignal('');
+ return (
+ <FormulaInput
+ label="Formula"
+ value={value()}
+ class=""
+ onInput={setValue}
+ onKeyDown={() => {}}
+ onBlur={blur}
+ />
+ );
+ });
+ const input = view.getByRole('textbox', { name: 'Formula' });
+ input.focus();
+ fireEvent.input(input, { target: { value: '=' } });
+ input.blur();
+ expect(blur).toHaveBeenCalledOnce();
+});
diff --git a/apps/web/src/features/block-spreadsheet/components/FormulaInput.tsx b/apps/web/src/features/block-spreadsheet/components/FormulaInput.tsx
index ce08bbb2a8..6638093ac0 100644
--- a/apps/web/src/features/block-spreadsheet/components/FormulaInput.tsx
+++ b/apps/web/src/features/block-spreadsheet/components/FormulaInput.tsx
@@ -11,12 +11,14 @@ import {
createSignal,
createUniqueId,
For,
+ mergeProps,
on,
onCleanup,
onMount,
Show,
} from 'solid-js';
import { Portal } from 'solid-js/web';
+import type { SpreadsheetMentions } from '../context/spreadsheet-mentions';
import {
argumentLabel,
formulaFunctions,
@@ -30,7 +32,8 @@ import {
import { createTouchPress } from '../primitives/create-touch-press';
/** Shared cell/formula-bar input. The popup keeps focus and editing in the textarea. */
-export function FormulaInput(props: {
+export type FormulaInputProps = {
+ mentions?: SpreadsheetMentions;
label: string;
value: string;
class: string;
@@ -45,7 +48,38 @@ export function FormulaInput(props: {
onInput: (value: string) => void;
onKeyDown: (event: KeyboardEvent) => void;
onBlur: () => void;
-}) {
+};
+export function FormulaInput(props: FormulaInputProps) {
+ let transferFocus = false;
+ const inputProps = mergeProps(props, {
+ get autoFocus() {
+ return props.autoFocus || transferFocus;
+ },
+ onFocus: () => {
+ transferFocus = false;
+ props.onFocus?.();
+ },
+ onBlur: () => {
+ if (!transferFocus) props.onBlur();
+ },
+ onInput: (value: string) => {
+ transferFocus =
+ !!props.mentions &&
+ value.startsWith('=') !== props.value.startsWith('=');
+ props.onInput(value);
+ },
+ });
+ return (
+ <Show
+ when={props.mentions && !props.value.startsWith('=')}
+ fallback={<FormulaTextarea {...inputProps} />}
+ >
+ {(_enabled) => props.mentions!.renderEditor(inputProps)}
+ </Show>
+ );
+}
+
+function FormulaTextarea(props: FormulaInputProps) {
let input!: HTMLTextAreaElement;
let popup: HTMLDivElement | undefined;
const id = createUniqueId();
diff --git a/apps/web/src/features/block-spreadsheet/components/SpreadsheetCellMenu.tsx b/apps/web/src/features/block-spreadsheet/components/SpreadsheetCellMenu.tsx
new file mode 100644
index 0000000000..383781a44a
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/components/SpreadsheetCellMenu.tsx
@@ -0,0 +1,118 @@
+import { ContextMenuContent, MenuItem } from '@core/component/ContextMenu';
+import { ContextMenu } from '@kobalte/core/context-menu';
+import ArrowDown from '@phosphor/arrow-down.svg?component-solid';
+import ArrowRight from '@phosphor/arrow-right.svg?component-solid';
+import Chat from '@phosphor/chat-circle.svg?component-solid';
+import Clipboard from '@phosphor/clipboard.svg?component-solid';
+import Copy from '@phosphor/copy.svg?component-solid';
+import Eraser from '@phosphor/eraser.svg?component-solid';
+import Scissors from '@phosphor/scissors.svg?component-solid';
+import Trash from '@phosphor/trash.svg?component-solid';
+import { type Component, type JSX, Show } from 'solid-js';
+import type { SpreadsheetCommand } from '../core/toolbar-types';
+
+export type CellAction =
+ | Extract<
+ SpreadsheetCommand,
+ | 'cut'
+ | 'copy'
+ | 'paste'
+ | 'paste-values'
+ | 'clear-values'
+ | 'clear-formatting'
+ | 'fill-down'
+ | 'fill-right'
+ >
+ | 'comment';
+
+/** One menu for the virtual grid, anchored at a pointer or keyboard-selected cell. */
+export function SpreadsheetCellMenu(props: {
+ readonly: boolean;
+ canComment?: boolean;
+ hasComments?: boolean;
+ canFillDown: boolean;
+ canFillRight: boolean;
+ onAction: (action: CellAction) => void;
+ onRestoreFocus: () => void;
+ children: (open: (x: number, y: number) => void) => JSX.Element;
+}) {
+ let trigger!: HTMLSpanElement;
+ let pending: CellAction | undefined;
+ const item = (
+ text: string,
+ action: CellAction,
+ icon: Component<JSX.SvgSVGAttributes<SVGSVGElement>>,
+ disabled = props.readonly
+ ) => (
+ <MenuItem
+ text={text}
+ icon={icon}
+ disabled={disabled}
+ closeOnSelect
+ onClick={() => {
+ pending = action;
+ }}
+ />
+ );
+ return (
+ <ContextMenu>
+ <ContextMenu.Trigger
+ as="span"
+ ref={trigger}
+ class="hidden"
+ aria-hidden="true"
+ />
+ {props.children((x, y) => {
+ // Use the primitive's trigger so pointer placement, focus and dismissal
+ // behave exactly like the app's other context menus.
+ trigger.dispatchEvent(
+ new MouseEvent('contextmenu', {
+ bubbles: true,
+ cancelable: true,
+ clientX: x,
+ clientY: y,
+ })
+ );
+ })}
+ <ContextMenu.Portal>
+ <ContextMenuContent
+ class="min-w-56"
+ onCloseAutoFocus={(event) => {
+ event.preventDefault();
+ const action = pending;
+ pending = undefined;
+ queueMicrotask(() => {
+ props.onRestoreFocus();
+ if (action) props.onAction(action);
+ });
+ }}
+ >
+ {item('Cut', 'cut', Scissors)}
+ {item('Copy', 'copy', Copy, false)}
+ {item('Paste', 'paste', Clipboard)}
+ {item('Paste values only', 'paste-values', Clipboard)}
+ <ContextMenu.Separator class="my-1 border-t border-edge-muted" />
+ {item('Clear values', 'clear-values', Trash)}
+ {item('Clear formatting', 'clear-formatting', Eraser)}
+ <ContextMenu.Separator class="my-1 border-t border-edge-muted" />
+ {item(
+ 'Fill down',
+ 'fill-down',
+ ArrowDown,
+ props.readonly || !props.canFillDown
+ )}
+ {item(
+ 'Fill right',
+ 'fill-right',
+ ArrowRight,
+ props.readonly || !props.canFillRight
+ )}
+ <Show when={props.hasComments}>
+ <ContextMenu.Separator class="my-1 border-t border-edge-muted" />
+ {item('Comment', 'comment', Chat, !props.canComment)}
+ </Show>
+ </ContextMenuContent>
+ </ContextMenu.Portal>
+ </ContextMenu>
+ );
+}
diff --git a/apps/web/src/features/block-spreadsheet/components/SpreadsheetCommentCard.tsx b/apps/web/src/features/block-spreadsheet/components/SpreadsheetCommentCard.tsx
new file mode 100644
index 0000000000..c91b079824
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/components/SpreadsheetCommentCard.tsx
@@ -0,0 +1,75 @@
+import {
+ DiscussionComposer,
+ type DiscussionThread,
+ DiscussionThreadView,
+} from '@core/comments/discussion';
+import { StaticMarkdownContext } from '@core/component/LexicalMarkdown/component/core/StaticMarkdown';
+import { floatWithElement } from '@core/component/LexicalMarkdown/directive/floatWithElement';
+import { ScopedPortal } from '@core/component/ScopedPortal';
+import XIcon from '@phosphor/x.svg';
+import { Button } from '@ui/components/Button';
+import { For, Show } from 'solid-js';
+
+false && floatWithElement;
+
+/** Same thread/reply controls as the sidebar, anchored beside a cell. */
+export function SpreadsheetCommentCard(props: {
+ element: HTMLElement;
+ label: string;
+ creating: boolean;
+ threads: DiscussionThread[];
+ onEnter: () => void;
+ onLeave: () => void;
+ onInteract: () => void;
+ onClose: () => void;
+}) {
+ return (
+ <ScopedPortal>
+ <div
+ role="dialog"
+ aria-label={`Comments on ${props.label}`}
+ class="absolute z-modal w-88 max-w-[calc(100vw-24px)] rounded-xl border border-edge bg-panel text-ink shadow-xl"
+ use:floatWithElement={{
+ element: () => props.element,
+ spacing: 6,
+ floatingOptions: { placement: 'right-start' },
+ }}
+ onMouseEnter={props.onEnter}
+ onMouseLeave={props.onLeave}
+ onPointerDown={props.onInteract}
+ onFocusIn={props.onInteract}
+ onKeyDown={(event) => {
+ event.stopPropagation();
+ if (event.key === 'Escape') {
+ event.preventDefault();
+ props.onClose();
+ }
+ }}
+ >
+ <div class="flex items-center justify-between border-b border-edge-muted px-3 py-2">
+ <span class="text-xs font-medium">{props.label}</span>
+ <Button
+ size="icon-sm"
+ variant="ghost"
+ aria-label="Close cell comment"
+ onClick={props.onClose}
+ >
+ <XIcon class="size-4" />
+ </Button>
+ </div>
+ <div class="max-h-[min(28rem,65dvh)] overflow-y-auto p-3 text-xs">
+ <StaticMarkdownContext>
+ <For each={props.threads}>
+ {(thread) => (
+ <DiscussionThreadView showReplyAction thread={thread} />
+ )}
+ </For>
+ <Show when={props.creating}>
+ <DiscussionComposer autofocus />
+ </Show>
+ </StaticMarkdownContext>
+ </div>
+ </div>
+ </ScopedPortal>
+ );
+}
diff --git a/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.test.tsx b/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.test.tsx
index 738387534e..754194d886 100644
--- a/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.test.tsx
+++ b/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.test.tsx
@@ -1,6 +1,12 @@
-import { cleanup, fireEvent, render } from '@solidjs/testing-library';
+import {
+ cleanup,
+ fireEvent,
+ render,
+ screen,
+ waitFor,
+} from '@solidjs/testing-library';
import { type Accessor, type ComponentProps, createSignal } from 'solid-js';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { SpreadsheetCells } from '../core/spreadsheet-document';
import {
createGridController,
@@ -23,6 +29,9 @@ function renderGrid(
initial: SpreadsheetCells = {},
options: Pick<
ComponentProps<typeof SpreadsheetGrid>,
+ | 'comments'
+ | 'onCellAction'
+ | 'mentions'
| 'zoom'
| 'showGridlines'
| 'showFormulas'
@@ -85,6 +94,9 @@ function renderGrid(
onReturnToGrid={() => {}}
/>
<SpreadsheetGrid
+ onCellAction={options.onCellAction}
+ comments={options.comments}
+ mentions={options.mentions}
cells={cells()}
sheetId={options.sheetId}
rowCount={options.rowCount ?? 30}
@@ -676,6 +688,11 @@ describe('spreadsheet presentation', () => {
{
A1: {
value: 'Styled cell',
+ borderTopColor: '#123456',
+ borderRightColor: '#123456',
+ borderLeftColor: '#123456',
+ borderBottomColor: '#123456',
+ borderBottomStyle: 'double',
bold: true,
italic: true,
underline: true,
@@ -706,8 +723,11 @@ describe('spreadsheet presentation', () => {
expect(cell.style.backgroundColor).toBe('rgb(171, 205, 239)');
expect(cell.style.textAlign).toBe('center');
expect(cell.style.justifyContent).toBe('flex-start');
- expect(cell.style.borderColor).toBe('transparent');
- expect(cell.style.boxShadow.match(/inset/g)).toHaveLength(4);
+ expect(cell.style.borderBottomColor).not.toBe('transparent');
+ expect(cell.style.borderTopStyle).toBe('solid');
+ expect(cell.style.borderBottomStyle).toBe('double');
+ expect(cell.style.borderRightStyle).toBe('solid');
+ expect(cell.style.borderLeftStyle).toBe('solid');
expect(cell.classList.contains('font-semibold')).toBe(true);
expect((cell.firstElementChild as HTMLElement).style.whiteSpace).toBe(
'pre-wrap'
@@ -786,3 +806,208 @@ describe('spreadsheet presentation', () => {
expect(view.cells().A1.value).toBe('=SUM(B1:B3)');
});
});
+
+it('renders imported URL and email cells without raw native tooltips, but leaves formulas intact', () => {
+ const renderText = vi.fn((value: string) => (
+ <a href="https://example.com">{value}</a>
+ ));
+ const view = renderGrid(
+ {
+ A1: { value: "'https://example.com" },
+ A2: { value: '[email protected]' },
+ A3: { value: '=HYPERLINK("https://example.com","Site")' },
+ },
+ {
+ mentions: { renderText, renderEditor: () => null },
+ values: { A3: { display: 'Site' } },
+ }
+ );
+ expect(view.getByRole('link', { name: 'https://example.com' })).toBeTruthy();
+ expect(view.getByRole('link', { name: '[email protected]' })).toBeTruthy();
+ expect(
+ view.container.querySelector('[data-address="A1"]')?.hasAttribute('title')
+ ).toBe(false);
+ expect(view.container.querySelector('[data-address="A3"]')?.textContent).toBe(
+ 'Site'
+ );
+ expect(renderText).not.toHaveBeenCalledWith(
+ expect.stringContaining('HYPERLINK')
+ );
+ fireEvent.keyDown(view.getByRole('link', { name: 'https://example.com' }), {
+ key: 'Enter',
+ });
+ expect(view.queryByRole('textbox', { name: 'Edit A1' })).toBeNull();
+});
+
+it('marks commented cells and opens hover/click comments without selecting or editing the cell', () => {
+ const comments = {
+ canComment: () => true,
+ add: vi.fn(),
+ hasComment: (address: string) => address === 'B2',
+ enter: vi.fn(),
+ leave: vi.fn(),
+ show: vi.fn(),
+ };
+ const view = renderGrid({}, { comments });
+ const cell = view.getByRole('gridcell', { name: 'B2' });
+ expect(cell.getAttribute('aria-description')).toBe('Has comments');
+ fireEvent.mouseEnter(cell);
+ expect(comments.enter).toHaveBeenCalledWith('B2', cell);
+ const marker = view.getByRole('button', { name: 'Comments on B2' });
+ fireEvent.keyDown(marker, { key: 'Enter' });
+ expect(view.controller.editing()).toBeUndefined();
+ fireEvent.pointerDown(marker, { pointerId: 1, button: 0 });
+ fireEvent.click(marker);
+ expect(comments.show).toHaveBeenCalledWith('B2', cell);
+ expect(view.controller.activeAddress()).toBe('A1');
+ expect(view.controller.editing()).toBeUndefined();
+ fireEvent.mouseLeave(cell);
+ expect(comments.leave).toHaveBeenCalled();
+});
+
+describe('cell context menu', () => {
+ beforeEach(() => {
+ // jsdom has no CSS animations or layout. Explicitly use the browser's
+ // default animation name so Kobalte can finish its unmount/focus lifecycle.
+ const style = document.createElement('style');
+ style.textContent = '[role="menu"] { animation-name: none; }';
+ document.head.append(style);
+ const scroll = vi.spyOn(window, 'scrollTo').mockImplementation(() => {});
+ return () => {
+ style.remove();
+ scroll.mockRestore();
+ };
+ });
+ it('preserves a range on right-click and dispatches its command after restoring focus', async () => {
+ const onCellAction = vi.fn();
+ const view = renderGrid({}, { onCellAction });
+ view.controller.selectRange({ row: 1, column: 1 }, { row: 3, column: 2 });
+ const selection = structuredClone(view.controller.selection());
+ const cell = view.getByRole('gridcell', { name: 'C3' });
+ fireEvent.pointerDown(cell, { button: 2 });
+ expect(fireEvent.contextMenu(cell, { clientX: 250, clientY: 120 })).toBe(
+ false
+ );
+ expect(view.controller.selection()).toEqual(selection);
+ const copy = await screen.findByRole('menuitem', {
+ name: 'Copy',
+ });
+ fireEvent.keyDown(copy, { key: 'ArrowDown' });
+ expect(view.controller.selection()).toEqual(selection);
+ fireEvent.keyDown(copy, { key: 'Enter' });
+ await waitFor(() => expect(onCellAction).toHaveBeenCalledWith('copy'));
+ expect(view.controller.selection()).toEqual(selection);
+ expect(document.activeElement).toBe(view.element);
+ });
+
+ it('targets an unselected cell and enables fill only for the matching range dimension', async () => {
+ const view = renderGrid();
+ view.controller.selectRange({ row: 0, column: 0 }, { row: 2, column: 2 });
+ fireEvent.contextMenu(view.getByRole('gridcell', { name: 'E5' }));
+ expect(view.controller.activeAddress()).toBe('E5');
+ expect(view.controller.selection().anchor).toEqual(
+ view.controller.selection().focus
+ );
+ expect(
+ (await screen.findByRole('menuitem', { name: 'Fill down' })).hasAttribute(
+ 'data-disabled'
+ )
+ ).toBe(true);
+ expect(
+ screen
+ .getByRole('menuitem', { name: 'Fill right' })
+ .hasAttribute('data-disabled')
+ ).toBe(true);
+ fireEvent.keyDown(document, { key: 'Escape' });
+ await waitFor(() => expect(screen.queryByRole('menu')).toBeNull());
+ view.controller.selectRange({ row: 0, column: 1 }, { row: 2, column: 1 });
+ fireEvent.keyDown(view.element, { key: 'F10', shiftKey: true });
+ expect(
+ (await screen.findByRole('menuitem', { name: 'Fill down' })).hasAttribute(
+ 'data-disabled'
+ )
+ ).toBe(false);
+ expect(
+ screen
+ .getByRole('menuitem', { name: 'Fill right' })
+ .hasAttribute('data-disabled')
+ ).toBe(true);
+ });
+
+ it('allows comments and copy for commenters while disabling cell mutations', async () => {
+ const comments = {
+ canComment: () => true,
+ add: vi.fn(),
+ hasComment: () => false,
+ enter: vi.fn(),
+ leave: vi.fn(),
+ show: vi.fn(),
+ };
+ const onCellAction = vi.fn();
+ const view = renderGrid({}, { readonly: true, comments, onCellAction });
+ const cell = view.getByRole('gridcell', { name: 'B2' });
+ fireEvent.contextMenu(cell);
+ for (const name of [
+ 'Cut',
+ 'Paste',
+ 'Paste values only',
+ 'Clear values',
+ 'Clear formatting',
+ 'Fill down',
+ 'Fill right',
+ ]) {
+ expect(
+ (await screen.findByRole('menuitem', { name })).hasAttribute(
+ 'data-disabled'
+ )
+ ).toBe(true);
+ }
+ expect(
+ screen
+ .getByRole('menuitem', { name: 'Copy' })
+ .hasAttribute('data-disabled')
+ ).toBe(false);
+ fireEvent.keyDown(screen.getByRole('menuitem', { name: 'Comment' }), {
+ key: 'Enter',
+ });
+ await waitFor(() => expect(comments.add).toHaveBeenCalledWith(cell));
+ expect(onCellAction).not.toHaveBeenCalled();
+ });
+
+ it('keeps the native text editing menu and does not open the cell menu over headers', async () => {
+ const view = renderGrid({ A1: { value: 'draft' } });
+ view.controller.beginEdit('cell');
+ const input = view.getByRole('textbox', { name: 'Edit A1' });
+ expect(fireEvent.contextMenu(input)).toBe(true);
+ expect(screen.queryByRole('menu')).toBeNull();
+ expect(view.controller.editing()).toBe('cell');
+ view.controller.cancel();
+ fireEvent.contextMenu(
+ view.getByRole('button', { name: 'Select column B' })
+ );
+ await screen.findByRole('menuitem', { name: 'Resize 1 column…' });
+ expect(
+ screen.queryByRole('menuitem', { name: 'Clear formatting' })
+ ).toBeNull();
+ });
+
+ it('ignores a stale cell action after switching sheets', async () => {
+ const [sheetId, setSheetId] = createSignal('one');
+ const onCellAction = vi.fn();
+ const view = renderGrid(
+ {},
+ {
+ get sheetId() {
+ return sheetId();
+ },
+ onCellAction,
+ }
+ );
+ fireEvent.keyDown(view.element, { key: 'ContextMenu' });
+ const clear = await screen.findByRole('menuitem', { name: 'Clear values' });
+ setSheetId('two');
+ fireEvent.keyDown(clear, { key: 'Enter' });
+ await waitFor(() => expect(screen.queryByRole('menu')).toBeNull());
+ expect(onCellAction).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.tsx b/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.tsx
index 8f8e3599b9..7ad8668527 100644
--- a/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.tsx
+++ b/apps/web/src/features/block-spreadsheet/components/SpreadsheetGrid.tsx
@@ -1,4 +1,5 @@
import { isTouchDevice } from '@core/mobile/isTouchDevice';
+import { cellPlainText } from '@macro-inc/spreadsheet/cell-mentions';
import { createElementSize } from '@solid-primitives/resize-observer';
import {
createEffect,
@@ -12,6 +13,8 @@ import {
onMount,
Show,
} from 'solid-js';
+import type { SpreadsheetCommentsCapability } from '../context/spreadsheet-comments';
+import type { SpreadsheetMentions } from '../context/spreadsheet-mentions';
import { SPREADSHEET_CLIPBOARD_TYPE } from '../core/cell-copy';
import type { FormulaTextSelection } from '../core/formula-reference';
import {
@@ -33,8 +36,18 @@ import {
import type { SpreadsheetCursor } from '../core/spreadsheet-presence';
import type { CompleteFormula } from '../primitives/create-formula-assistance';
import { FormulaInput } from './FormulaInput';
+import { type CellAction, SpreadsheetCellMenu } from './SpreadsheetCellMenu';
+import {
+ type HeaderAction,
+ SpreadsheetHeaderMenu,
+} from './SpreadsheetHeaderMenu';
-export type GridValue = { display: string; number?: number; error?: string };
+export type GridValue = {
+ display: string;
+ number?: number;
+ error?: string;
+ warning?: string;
+};
const ROW_HEIGHT = 21;
const COLUMN_HEADER_HEIGHT = 24;
@@ -88,10 +101,18 @@ function wrappedLines(
export function SpreadsheetGrid(props: {
cells: SpreadsheetCells;
+ comments?: SpreadsheetCommentsCapability;
+ mentions?: SpreadsheetMentions;
sheetId?: string;
complete?: CompleteFormula;
rowCount?: number;
columnWidths?: Record<number, number>;
+ rowHeights?: Record<number, number>;
+ hiddenRows?: number[];
+ hiddenColumns?: number[];
+ canChangeStructure?: boolean;
+ onCellAction?: (action: Exclude<CellAction, 'comment'>) => void;
+ onHeaderAction?: (axis: 'row' | 'column', action: HeaderAction) => void;
zoom?: number;
showGridlines?: boolean;
showFormulas?: boolean;
@@ -134,7 +155,9 @@ export function SpreadsheetGrid(props: {
const headerHeight = () => COLUMN_HEADER_HEIGHT * scale();
const headerWidth = () => ROW_HEADER_WIDTH * scale();
const rowCount = () => props.rowCount ?? GRID_ROWS;
- const columns = Array.from({ length: GRID_COLUMNS }, (_, index) => index);
+ const allColumns = Array.from({ length: GRID_COLUMNS }, (_, index) => index);
+ const columns = () =>
+ allColumns.filter((column) => !props.hiddenColumns?.includes(column));
const [fillTarget, setFillTarget] = createSignal<CellSelection>();
const [resizing, setResizing] = createSignal<{
column: number;
@@ -173,7 +196,8 @@ export function SpreadsheetGrid(props: {
const display = (address: string) =>
props.showFormulas && props.cells[address]?.value.startsWith('=')
? props.cells[address].value
- : (props.values[address]?.display ?? props.cells[address]?.value ?? '');
+ : (props.values[address]?.display ??
+ cellPlainText(props.cells[address]?.value ?? ''));
const rootStyle = getComputedStyle(document.documentElement);
const fontFamilies = {
sans: rootStyle.getPropertyValue('--font-sans') || 'sans-serif',
@@ -181,7 +205,9 @@ export function SpreadsheetGrid(props: {
mono: rootStyle.getPropertyValue('--font-mono') || 'monospace',
};
const fontFamily = (cell?: SpreadsheetCell) =>
- fontFamilies[cell?.fontFamily ?? 'sans'];
+ cell?.fontName
+ ? `${JSON.stringify(cell.fontName)}, ${fontFamilies[cell.fontFamily ?? 'sans']}`
+ : fontFamilies[cell?.fontFamily ?? 'sans'];
// No cell measurement runs on pointer movement: only document, calculation,
// column width, and zoom changes invalidate row geometry.
const context =
@@ -189,7 +215,9 @@ export function SpreadsheetGrid(props: {
? null
: document.createElement('canvas').getContext('2d');
const rowHeights = createMemo(() => {
- const heights = Array<number>(rowCount()).fill(ROW_HEIGHT);
+ const heights = Array.from({ length: rowCount() }, (_, row) =>
+ 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)) {
@@ -215,7 +243,9 @@ export function SpreadsheetGrid(props: {
Math.min(MAX_ROW_HEIGHT, Math.ceil(lines * lineHeight + verticalInset))
);
}
- return heights.map((height) => height * scale());
+ return heights.map((height, row) =>
+ props.hiddenRows?.includes(row) ? 0 : height * scale()
+ );
});
const rowOffsets = createMemo(() => {
const offsets = [headerHeight()];
@@ -240,7 +270,9 @@ export function SpreadsheetGrid(props: {
props.selection.anchor.row,
props.selection.focus.row,
]),
- ].sort((a, b) => a - b)
+ ]
+ .filter((row) => !props.hiddenRows?.includes(row))
+ .sort((a, b) => a - b)
);
const bounds = createMemo(() =>
selectionBounds(fillTarget() ?? props.selection)
@@ -258,8 +290,13 @@ export function SpreadsheetGrid(props: {
const activeCell = createSelector(() => cellAddress(props.selection.anchor));
const columnOffsets = createMemo(() => {
const offsets = [headerWidth()];
- for (const column of columns)
- offsets.push(offsets[column] + Number.parseFloat(width(column)));
+ for (const column of allColumns)
+ offsets.push(
+ offsets[column] +
+ (props.hiddenColumns?.includes(column)
+ ? 0
+ : Number.parseFloat(width(column)))
+ );
return offsets;
});
const rangeStyle = (area = bounds()) => {
@@ -418,7 +455,9 @@ export function SpreadsheetGrid(props: {
let dragging = false;
let keepReferenceFocus = false;
const isInput = (target: EventTarget | null) =>
- target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement;
+ target instanceof HTMLInputElement ||
+ target instanceof HTMLTextAreaElement ||
+ (target instanceof HTMLElement && !!target.closest('[contenteditable]'));
const focusGrid = () => grid.focus({ preventScroll: true });
function positionAtPoint(x: number, y: number): CellPosition {
@@ -601,538 +640,777 @@ export function SpreadsheetGrid(props: {
});
});
+ let headerSelection: CellSelection | undefined;
+ function selectHeader(
+ axis: 'row' | 'column',
+ index: number,
+ preserve = false
+ ) {
+ const area = selectionBounds(props.selection);
+ if (
+ preserve &&
+ (axis === 'row'
+ ? area.left === 0 &&
+ area.right === GRID_COLUMNS - 1 &&
+ index >= area.top &&
+ index <= area.bottom
+ : area.top === 0 &&
+ area.bottom === rowCount() - 1 &&
+ index >= area.left &&
+ index <= area.right)
+ )
+ return;
+ props.onSelectRange(
+ axis === 'row' ? { row: index, column: 0 } : { row: 0, column: index },
+ axis === 'row'
+ ? { row: index, column: GRID_COLUMNS - 1 }
+ : { row: rowCount() - 1, column: index }
+ );
+ }
+ function openHeader(axis: 'row' | 'column', index: number) {
+ selectHeader(axis, index, true);
+ headerSelection = {
+ anchor: { ...props.selection.anchor },
+ focus: { ...props.selection.focus },
+ };
+ }
+ function headerAction(axis: 'row' | 'column', action: HeaderAction) {
+ if (headerSelection)
+ props.onSelectRange(headerSelection.anchor, headerSelection.focus);
+ props.onHeaderAction?.(axis, action);
+ }
+ let cellMenuSelection: CellSelection | undefined;
+ let cellMenuSheet: string | undefined;
+ function prepareCellMenu(position: CellPosition) {
+ cancelPointer();
+ props.onCommit();
+ const area = selectionBounds(props.selection);
+ if (
+ position.row < area.top ||
+ position.row > area.bottom ||
+ position.column < area.left ||
+ position.column > area.right
+ )
+ props.onSelect(position);
+ cellMenuSelection = {
+ anchor: { ...props.selection.anchor },
+ focus: { ...props.selection.focus },
+ };
+ cellMenuSheet = props.sheetId;
+ }
+ function cellAction(action: CellAction) {
+ if (cellMenuSheet !== props.sheetId || !cellMenuSelection) return;
+ props.onSelectRange(cellMenuSelection.anchor, cellMenuSelection.focus);
+ if (action === 'comment') {
+ if (props.comments?.canComment())
+ props.comments.add(
+ grid.querySelector<HTMLElement>(
+ `[data-address="${cellAddress(cellMenuSelection.anchor)}"]`
+ ) ?? undefined
+ );
+ } else if (action === 'copy' || !props.readonly)
+ props.onCellAction?.(action);
+ }
return (
- <div
- ref={(element) => {
- grid = element;
- setScrollElement(element);
- }}
- role="grid"
- aria-label="Spreadsheet"
- aria-rowcount={rowCount() + 1}
- aria-colcount={GRID_COLUMNS + 1}
- aria-multiselectable="true"
- aria-readonly={props.readonly}
- aria-activedescendant={`${id}-${cellAddress(props.selection.anchor)}`}
- tabIndex={0}
- class="relative min-h-0 flex-1 overflow-auto overscroll-contain touch-pan-x touch-pan-y touch-pinch-zoom outline-none bg-panel selection:bg-accent/20"
- style={{
- '--spreadsheet-cell-padding': `${CELL_PADDING_X * scale()}px`,
- '--spreadsheet-cell-padding-y': `${CELL_PADDING_Y * scale()}px`,
- }}
- onScroll={(event) => {
- setScrollTop(event.currentTarget.scrollTop);
- if (touchGesture?.kind === 'tap') touchGesture.moved = true;
- }}
- onMouseDown={(event) => {
- // iOS still sends compatibility mousedown after cancelled pointerdown.
- if (keepReferenceFocus && !isInput(event.target))
- event.preventDefault();
- }}
- onClick={() => {
- keepReferenceFocus = false;
- }}
- onKeyDown={(event) => {
- if (isInput(event.target)) return;
- event.stopPropagation();
- props.onKeyDown(event);
- if (!props.editing) revealSelection();
- }}
- onCopy={(event) => {
- if (isInput(event.target)) return;
- event.preventDefault();
- event.clipboardData?.setData('text/plain', props.onCopy());
- if (props.onCopyMetadata)
- event.clipboardData?.setData(
- SPREADSHEET_CLIPBOARD_TYPE,
- props.onCopyMetadata()
- );
- }}
- onCut={(event) => {
- if (isInput(event.target)) return;
- if (!event.clipboardData) return;
- event.preventDefault();
- // A viewer can copy with the cut shortcut, but no cells move. Mark its
- // metadata as a copy so formulas still translate on a later paste.
- const cut = !props.readonly;
- event.clipboardData.setData('text/plain', props.onCopy(cut));
- if (props.onCopyMetadata)
- event.clipboardData.setData(
- SPREADSHEET_CLIPBOARD_TYPE,
- props.onCopyMetadata(cut)
- );
- if (cut) props.onClear();
- }}
- onPaste={(event) => {
- if (isInput(event.target)) return;
- event.preventDefault();
- if (
- !props.readonly &&
- event.clipboardData?.types.includes('text/plain')
- )
- props.onPaste(
- event.clipboardData.getData('text/plain'),
- event.clipboardData.getData(SPREADSHEET_CLIPBOARD_TYPE) || undefined
- );
- }}
+ <SpreadsheetCellMenu
+ readonly={props.readonly}
+ canComment={props.comments?.canComment()}
+ hasComments={!!props.comments}
+ canFillDown={
+ selectionBounds(props.selection).bottom >
+ selectionBounds(props.selection).top
+ }
+ canFillRight={
+ selectionBounds(props.selection).right >
+ selectionBounds(props.selection).left
+ }
+ onRestoreFocus={focusGrid}
+ onAction={cellAction}
>
- <div
- class="relative w-max min-w-full"
- style={{ height: `${rowOffsets()[rowCount()]}px` }}
- >
+ {(openCellMenu) => (
<div
- role="row"
- aria-rowindex={1}
- class="sticky top-0 z-20 flex bg-panel text-ink-muted font-medium select-none"
+ ref={(element) => {
+ grid = element;
+ setScrollElement(element);
+ }}
+ role="grid"
+ aria-label="Spreadsheet"
+ aria-rowcount={rowCount() + 1}
+ aria-colcount={GRID_COLUMNS + 1}
+ aria-multiselectable="true"
+ aria-readonly={props.readonly}
+ aria-activedescendant={`${id}-${cellAddress(props.selection.anchor)}`}
+ tabIndex={0}
+ class="relative min-h-0 flex-1 overflow-auto overscroll-contain touch-pan-x touch-pan-y touch-pinch-zoom outline-none bg-panel selection:bg-accent/20"
style={{
- height: `${headerHeight()}px`,
- 'font-size': `${11 * scale()}px`,
+ '--spreadsheet-cell-padding': `${CELL_PADDING_X * scale()}px`,
+ '--spreadsheet-cell-padding-y': `${CELL_PADDING_Y * scale()}px`,
+ }}
+ onScroll={(event) => {
+ setScrollTop(event.currentTarget.scrollTop);
+ if (touchGesture?.kind === 'tap') touchGesture.moved = true;
+ }}
+ onMouseDown={(event) => {
+ // iOS still sends compatibility mousedown after cancelled pointerdown.
+ if (keepReferenceFocus && !isInput(event.target))
+ event.preventDefault();
+ }}
+ onClick={() => {
+ keepReferenceFocus = false;
+ }}
+ onContextMenu={(event) => {
+ if (isInput(event.target)) return;
+ const cell = event.target.closest<HTMLElement>('[data-address]');
+ if (!cell || !grid.contains(cell)) return;
+ const parsed = parseCellAddress(cell.dataset.address ?? '');
+ if (!parsed) return;
+ event.preventDefault();
+ event.stopPropagation();
+ prepareCellMenu(parsed);
+ openCellMenu(event.clientX, event.clientY);
+ }}
+ onKeyDown={(event) => {
+ // Solid portals retain logical ancestry; menu keys belong to the menu.
+ if (
+ !event.currentTarget.contains(event.target) ||
+ isInput(event.target) ||
+ event.target.closest('a[href]')
+ )
+ return;
+ event.stopPropagation();
+ if (
+ event.key === 'ContextMenu' ||
+ (event.shiftKey && event.key === 'F10')
+ ) {
+ event.preventDefault();
+ prepareCellMenu(props.selection.anchor);
+ const cell = grid.querySelector<HTMLElement>(
+ `[data-address="${cellAddress(props.selection.anchor)}"]`
+ );
+ const rect =
+ cell?.getBoundingClientRect() ?? grid.getBoundingClientRect();
+ openCellMenu(rect.left + Math.min(rect.width, 24), rect.bottom);
+ return;
+ }
+ props.onKeyDown(event);
+ if (!props.editing) revealSelection();
+ }}
+ onCopy={(event) => {
+ if (isInput(event.target)) return;
+ event.preventDefault();
+ event.clipboardData?.setData('text/plain', props.onCopy());
+ if (props.onCopyMetadata)
+ event.clipboardData?.setData(
+ SPREADSHEET_CLIPBOARD_TYPE,
+ props.onCopyMetadata()
+ );
+ }}
+ onCut={(event) => {
+ if (isInput(event.target)) return;
+ if (!event.clipboardData) return;
+ event.preventDefault();
+ // A viewer can copy with the cut shortcut, but no cells move. Mark its
+ // metadata as a copy so formulas still translate on a later paste.
+ const cut = !props.readonly;
+ event.clipboardData.setData('text/plain', props.onCopy(cut));
+ if (props.onCopyMetadata)
+ event.clipboardData.setData(
+ SPREADSHEET_CLIPBOARD_TYPE,
+ props.onCopyMetadata(cut)
+ );
+ if (cut) props.onClear();
+ }}
+ onPaste={(event) => {
+ if (isInput(event.target)) return;
+ event.preventDefault();
+ if (
+ !props.readonly &&
+ event.clipboardData?.types.includes('text/plain')
+ )
+ props.onPaste(
+ event.clipboardData.getData('text/plain'),
+ event.clipboardData.getData(SPREADSHEET_CLIPBOARD_TYPE) ||
+ undefined
+ );
}}
>
<div
- role="columnheader"
- aria-label="Select all cells"
- class="sticky left-0 z-30 shrink-0 border-b border-r border-edge bg-panel"
- style={{ width: `${headerWidth()}px` }}
+ class="relative w-max min-w-full"
+ style={{ height: `${rowOffsets()[rowCount()]}px` }}
>
- <button
- type="button"
- aria-label="Select all cells"
- class="size-full hover:bg-hover"
- onClick={() => {
- props.onSelectRange(
- { row: 0, column: 0 },
- { row: rowCount() - 1, column: GRID_COLUMNS - 1 }
- );
- focusGrid();
- }}
- >
- ▦
- </button>
- </div>
- <For each={columns}>
- {(column) => (
- <div
- role="columnheader"
- aria-colindex={column + 2}
- style={{ width: width(column) }}
- class="relative shrink-0 border-b border-r border-edge-muted"
- classList={{
- 'bg-accent-bg text-accent':
- column >= bounds().left && column <= bounds().right,
- }}
- >
- <button
- type="button"
- 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();
- }}
- >
- {String.fromCharCode(65 + column)}
- </button>
- <Show when={!props.readonly && props.onResizeColumn}>
- <div
- role="separator"
- aria-label={`Resize column ${String.fromCharCode(65 + column)}`}
- aria-orientation="vertical"
- aria-valuenow={
- props.columnWidths?.[column] ?? DEFAULT_COLUMN_WIDTH
- }
- aria-valuemin={MIN_COLUMN_WIDTH}
- aria-valuemax={MAX_COLUMN_WIDTH}
- tabIndex={0}
- title="Drag to resize · Double-click to fit"
- class="absolute -right-1 top-0 z-[1] h-full w-2 touch-none cursor-col-resize hover:bg-accent/30 focus-visible:bg-accent/30 outline-none"
- onPointerDown={(event) => {
- if (event.button !== 0) return;
- event.preventDefault();
- event.stopPropagation();
- resizeStart = {
- x: event.clientX,
- width:
- props.columnWidths?.[column] ?? DEFAULT_COLUMN_WIDTH,
- };
- setResizing({ column, width: resizeStart.width });
- event.currentTarget.setPointerCapture(event.pointerId);
- }}
- onPointerMove={(event) => {
- if (!resizeStart || resizing()?.column !== column) return;
- setResizing({
- column,
- width: Math.max(
- MIN_COLUMN_WIDTH,
- Math.min(
- MAX_COLUMN_WIDTH,
- resizeStart.width +
- (event.clientX - resizeStart.x) / scale()
- )
- ),
- });
- }}
- onDblClick={() => autoFit(column)}
- onKeyDown={(event) => {
- event.stopPropagation();
- if (event.key === 'Enter') {
- event.preventDefault();
- autoFit(column);
- }
- if (
- event.key === 'ArrowLeft' ||
- event.key === 'ArrowRight'
- ) {
- event.preventDefault();
- props.onResizeColumn?.(
- column,
- (props.columnWidths?.[column] ??
- DEFAULT_COLUMN_WIDTH) +
- (event.key === 'ArrowRight' ? 16 : -16)
- );
- }
- }}
- />
- </Show>
- </div>
- )}
- </For>
- </div>
- <For each={visibleRows()}>
- {(row) => (
<div
role="row"
- aria-rowindex={row + 2}
- class="absolute left-0 flex w-max min-w-full"
+ aria-rowindex={1}
+ class="sticky top-0 z-20 flex bg-panel text-ink-muted font-medium select-none"
style={{
- top: `${rowOffsets()[row]}px`,
- height: `${rowHeights()[row]}px`,
+ height: `${headerHeight()}px`,
+ 'font-size': `${11 * scale()}px`,
}}
>
<div
- role="rowheader"
- class="sticky left-0 z-10 shrink-0 border-b border-r border-edge-muted bg-panel text-center text-ink-muted select-none"
- style={{
- width: `${headerWidth()}px`,
- 'font-size': `${11 * scale()}px`,
- }}
- classList={{
- 'bg-accent-bg text-accent':
- row >= bounds().top && row <= bounds().bottom,
- }}
+ role="columnheader"
+ aria-label="Select all cells"
+ class="sticky left-0 z-30 shrink-0 border-b border-r border-edge bg-panel"
+ style={{ width: `${headerWidth()}px` }}
>
<button
type="button"
- tabIndex={-1}
- aria-label={`Select row ${row + 1}`}
+ aria-label="Select all cells"
class="size-full hover:bg-hover"
onClick={() => {
props.onSelectRange(
- { row, column: 0 },
- { row, column: GRID_COLUMNS - 1 }
+ { row: 0, column: 0 },
+ { row: rowCount() - 1, column: GRID_COLUMNS - 1 }
);
focusGrid();
}}
>
- {row + 1}
+ ▦
</button>
</div>
- <For each={columns}>
- {(column) => {
- const address = cellAddress({ row, column });
- const position = { row, column };
- const active = () => activeCell(address);
- const selected = () => selectedCell(position);
- const value = () => props.values[address];
- const cell = () => props.cells[address];
- const borders = () => {
- const shadows = [];
- if (cell()?.borderTop)
- shadows.push('inset 0 1px 0 var(--color-ink)');
- if (cell()?.borderRight)
- shadows.push('inset -1px 0 0 var(--color-ink)');
- if (cell()?.borderBottom)
- shadows.push('inset 0 -1px 0 var(--color-ink)');
- if (cell()?.borderLeft)
- shadows.push('inset 1px 0 0 var(--color-ink)');
- return shadows.join(', ') || undefined;
- };
- const horizontalAlign = () => {
- const align = cell()?.horizontalAlign;
- return align && align !== 'auto'
- ? align
- : value()?.number !== undefined &&
- !(props.showFormulas && cell()?.value.startsWith('='))
- ? 'right'
- : 'left';
- };
- return (
- <div
- id={`${id}-${address}`}
- role="gridcell"
- aria-colindex={column + 2}
- aria-label={`${address}${display(address) ? `: ${display(address)}` : ''}`}
- aria-selected={selected()}
- data-address={address}
- title={value()?.error ?? props.cells[address]?.value}
- style={{
- width: width(column),
- 'scroll-margin-top': `${headerHeight()}px`,
- 'scroll-margin-left': `${headerWidth()}px`,
- 'box-shadow': borders(),
- 'border-color':
- props.showGridlines === false
- ? 'transparent'
- : undefined,
- 'background-color': cell()?.fillColor || undefined,
- color: cell()?.textColor || undefined,
- 'font-family': fontFamily(cell()),
- 'font-size': `${fontPixels(cell()) * scale()}px`,
- 'font-style': cell()?.italic ? 'italic' : undefined,
- 'text-decoration-line':
- [
- cell()?.underline ? 'underline' : '',
- cell()?.strikethrough ? 'line-through' : '',
- ]
- .filter(Boolean)
- .join(' ') || undefined,
- 'text-align': horizontalAlign(),
- 'justify-content':
- cell()?.verticalAlign === 'top'
- ? 'flex-start'
- : cell()?.verticalAlign === 'bottom'
- ? 'flex-end'
- : 'center',
- 'padding-block': 'var(--spreadsheet-cell-padding-y)',
- 'line-height': CELL_LINE_HEIGHT,
- }}
- class="relative flex flex-col shrink-0 border-b border-r border-edge-muted bg-surface text-ink select-none"
- classList={{
- 'font-semibold': cell()?.bold,
- 'tabular-nums': value()?.number !== undefined,
- 'text-failure': !!value()?.error,
+ <For each={columns()}>
+ {(column) => (
+ <div
+ role="columnheader"
+ aria-colindex={column + 2}
+ style={{ width: width(column) }}
+ class="relative shrink-0 border-b border-r border-edge-muted"
+ classList={{
+ 'bg-accent-bg text-accent':
+ column >= bounds().left && column <= bounds().right,
+ }}
+ >
+ <SpreadsheetHeaderMenu
+ canChangeStructure={props.canChangeStructure}
+ axis="column"
+ count={bounds().right - bounds().left + 1}
+ readonly={props.readonly}
+ onOpen={() => openHeader('column', column)}
+ onRestoreFocus={focusGrid}
+ onAction={(action) => {
+ if (action === 'autofit') {
+ for (let c = bounds().left; c <= bounds().right; c++)
+ autoFit(c);
+ } else headerAction('column', action);
}}
- onPointerDown={(event) => {
- if (event.button !== 0 || isInput(event.target)) return;
- setTouchMode(event.pointerType === 'touch');
- if (event.pointerType === 'touch') {
- if (event.isPrimary === false) {
- cancelPointer();
- return;
- }
- // Defer selection until a tap is known; native panning
- // owns movement and pointercancel without changing cells.
- touchGesture = {
- kind: 'tap',
- pointerId: event.pointerId,
+ >
+ <button
+ type="button"
+ 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();
+ }}
+ >
+ {String.fromCharCode(65 + column)}
+ </button>
+ </SpreadsheetHeaderMenu>
+ <Show when={!props.readonly && props.onResizeColumn}>
+ <div
+ role="separator"
+ aria-label={`Resize column ${String.fromCharCode(65 + column)}`}
+ aria-orientation="vertical"
+ aria-valuenow={
+ props.columnWidths?.[column] ?? DEFAULT_COLUMN_WIDTH
+ }
+ aria-valuemin={MIN_COLUMN_WIDTH}
+ aria-valuemax={MAX_COLUMN_WIDTH}
+ tabIndex={0}
+ title="Drag to resize · Double-click to fit"
+ class="absolute -right-1 top-0 z-[1] h-full w-2 touch-none cursor-col-resize hover:bg-accent/30 focus-visible:bg-accent/30 outline-none"
+ onPointerDown={(event) => {
+ if (event.button !== 0) return;
+ event.preventDefault();
+ event.stopPropagation();
+ resizeStart = {
x: event.clientX,
- y: event.clientY,
- position,
- moved: false,
+ width:
+ props.columnWidths?.[column] ??
+ DEFAULT_COLUMN_WIDTH,
};
- keepReferenceFocus = !!(
- props.editing || props.formulaEditing
+ setResizing({ column, width: resizeStart.width });
+ event.currentTarget.setPointerCapture(
+ event.pointerId
);
- return;
- }
- event.preventDefault();
- keepReferenceFocus =
- props.onReferenceStart?.({ row, column }) ?? false;
- if (keepReferenceFocus) return;
- dragging = true;
- props.onSelect({ row, column }, event.shiftKey);
- focusGrid();
- }}
- onPointerEnter={(event) => {
- if (event.pointerType === 'touch') return;
- if (props.pickingReference && event.buttons === 1) {
- props.onReferenceMove?.({ row, column });
- return;
- }
- if (fillSource && event.buttons === 1) {
- previewFill({ row, column });
- return;
- }
- if (dragging && event.buttons === 1)
- props.onSelect({ row, column }, true);
- else dragging = false;
- }}
- onDblClick={() => {
- if (!touchMode() && !props.referenceSelection)
- props.onEdit();
- }}
- >
- <Show
- when={active() && props.editing}
- fallback={
- <div
- class="w-full min-h-0 overflow-hidden text-ellipsis px-[var(--spreadsheet-cell-padding)]"
- style={{
- 'white-space': cell()?.wrap
- ? 'pre-wrap'
- : 'nowrap',
- 'overflow-wrap': cell()?.wrap
- ? 'anywhere'
- : undefined,
- }}
- >
- {display(address)}
- </div>
- }
- >
- <FormulaInput
- label={`Edit ${address}`}
- autoFocus
- complete={props.complete}
- readonly={props.readonly}
- selectionRequest={props.editorSelection}
- pickingReference={
- props.pickingReference ||
- (isTouchDevice() && !!props.referenceSelection)
+ }}
+ onPointerMove={(event) => {
+ if (!resizeStart || resizing()?.column !== column)
+ return;
+ setResizing({
+ column,
+ width: Math.max(
+ MIN_COLUMN_WIDTH,
+ Math.min(
+ MAX_COLUMN_WIDTH,
+ resizeStart.width +
+ (event.clientX - resizeStart.x) / scale()
+ )
+ ),
+ });
+ }}
+ onDblClick={() => autoFit(column)}
+ onKeyDown={(event) => {
+ event.stopPropagation();
+ if (event.key === 'Enter') {
+ event.preventDefault();
+ autoFit(column);
}
- onSelectionChange={props.onTextSelection}
- class="absolute inset-0 size-full resize-none overflow-hidden bg-surface px-[var(--spreadsheet-cell-padding)] py-[var(--spreadsheet-cell-padding-y)] font-normal text-left text-ink outline-none select-text"
- value={props.draft}
- onInput={props.onDraft}
- onKeyDown={editKeyDown}
- onBlur={props.onCommit}
- />
- </Show>
- <Show when={value()?.error}>
- <span class="absolute right-0.5 top-0.5 size-1 rounded-full bg-failure" />
- </Show>
- </div>
- );
- }}
+ if (
+ event.key === 'ArrowLeft' ||
+ event.key === 'ArrowRight'
+ ) {
+ event.preventDefault();
+ props.onResizeColumn?.(
+ column,
+ (props.columnWidths?.[column] ??
+ DEFAULT_COLUMN_WIDTH) +
+ (event.key === 'ArrowRight' ? 16 : -16)
+ );
+ }
+ }}
+ />
+ </Show>
+ </div>
+ )}
</For>
</div>
- )}
- </For>
- <For each={props.remoteCursors}>
- {(cursor) => (
- <>
- <div
- data-remote-selection={cursor.peerId}
- class="absolute pointer-events-none z-[2] border-2"
- style={{
- ...rangeStyle(selectionBounds(cursor.selection)),
- 'border-color': cursor.color,
- background: `color-mix(in srgb, ${cursor.color} 8%, transparent)`,
- }}
- />
- <div
- data-remote-cursor={cursor.peerId}
- aria-label={`${cursor.name}: ${cellAddress(cursor.selection.focus)}`}
- class="absolute pointer-events-none z-[4] border-2"
- style={{
- ...rangeStyle(
- selectionBounds({
- anchor: cursor.selection.focus,
- focus: cursor.selection.focus,
- })
- ),
- 'border-color': cursor.color,
- }}
- >
- <span
- data-remote-cursor-name
- class="absolute left-[-2px] max-w-40 truncate rounded-t-sm px-1.5 py-0.5 text-[11px] font-medium leading-4 text-surface shadow-sm"
+ <For each={visibleRows()}>
+ {(row) => (
+ <div
+ role="row"
+ aria-rowindex={row + 2}
+ class="absolute left-0 flex w-max min-w-full"
style={{
- background: cursor.color,
- bottom:
- cursor.selection.focus.row === 0 ? undefined : '100%',
- top: cursor.selection.focus.row === 0 ? '100%' : undefined,
+ top: `${rowOffsets()[row]}px`,
+ height: `${rowHeights()[row]}px`,
}}
>
- {cursor.name}
- </span>
- </div>
- </>
- )}
- </For>
- <div
- aria-hidden="true"
- data-selection-range
- class="pointer-events-none absolute z-[1] border border-accent bg-accent/10"
- style={rangeStyle()}
- />
- <div
- aria-hidden="true"
- data-selection-active
- class="pointer-events-none absolute z-[2] border-2 border-accent"
- style={activeStyle()}
- />
- <Show when={props.referenceSelection}>
- {(range) => (
+ <div
+ role="rowheader"
+ class="sticky left-0 z-10 shrink-0 border-b border-r border-edge-muted bg-panel text-center text-ink-muted select-none"
+ style={{
+ width: `${headerWidth()}px`,
+ 'font-size': `${11 * scale()}px`,
+ }}
+ classList={{
+ 'bg-accent-bg text-accent':
+ row >= bounds().top && row <= bounds().bottom,
+ }}
+ >
+ <SpreadsheetHeaderMenu
+ canChangeStructure={props.canChangeStructure}
+ axis="row"
+ count={bounds().bottom - bounds().top + 1}
+ readonly={props.readonly}
+ onOpen={() => openHeader('row', row)}
+ onRestoreFocus={focusGrid}
+ onAction={(action) => headerAction('row', action)}
+ >
+ <button
+ type="button"
+ 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();
+ }}
+ >
+ {row + 1}
+ </button>
+ </SpreadsheetHeaderMenu>
+ </div>
+ <For each={columns()}>
+ {(column) => {
+ const address = cellAddress({ row, column });
+ const position = { row, column };
+ const active = () => activeCell(address);
+ const selected = () => selectedCell(position);
+ const value = () => props.values[address];
+ const cell = () => props.cells[address];
+ const border = (
+ edge: 'Top' | 'Right' | 'Bottom' | 'Left'
+ ) => {
+ if (!cell()?.[`border${edge}`]) return undefined;
+ const style = cell()?.[`border${edge}Style`] || 'thin';
+ const width =
+ style === 'double' || style === 'thick'
+ ? 3
+ : style.startsWith('medium')
+ ? 2
+ : 1;
+ const line =
+ style === 'double'
+ ? 'double'
+ : style.toLowerCase().includes('dash')
+ ? 'dashed'
+ : style === 'dotted'
+ ? 'dotted'
+ : 'solid';
+ return `${width}px ${line} ${cell()?.[`border${edge}Color`] || 'var(--color-ink)'}`;
+ };
+ const horizontalAlign = () => {
+ const align = cell()?.horizontalAlign;
+ return align && align !== 'auto'
+ ? align
+ : value()?.number !== undefined &&
+ !(
+ props.showFormulas &&
+ cell()?.value.startsWith('=')
+ )
+ ? 'right'
+ : 'left';
+ };
+ const decorated = () =>
+ !!props.mentions &&
+ !(
+ cell()?.value.startsWith('=') &&
+ cell()?.format !== 'text'
+ ) &&
+ /<m-(?:user|document)-mention>|https?:\/\/|www\.|[^\s@]+@[^\s@]+\.[^\s@]+/i.test(
+ cell()?.value ?? ''
+ );
+ return (
+ <div
+ id={`${id}-${address}`}
+ role="gridcell"
+ aria-colindex={column + 2}
+ aria-label={`${address}${display(address) ? `: ${display(address)}` : ''}`}
+ aria-selected={selected()}
+ data-address={address}
+ aria-description={
+ props.comments?.hasComment(address)
+ ? 'Has comments'
+ : undefined
+ }
+ onMouseEnter={(event) => {
+ if (
+ !props.editing &&
+ !props.formulaEditing &&
+ !event.buttons
+ )
+ props.comments?.enter(
+ address,
+ event.currentTarget
+ );
+ }}
+ onMouseLeave={() => props.comments?.leave()}
+ title={
+ value()?.error ??
+ value()?.warning ??
+ (decorated()
+ ? undefined
+ : cellPlainText(
+ props.cells[address]?.value ?? ''
+ ).replace(/^'/, ''))
+ }
+ style={{
+ width: width(column),
+ 'scroll-margin-top': `${headerHeight()}px`,
+ 'scroll-margin-left': `${headerWidth()}px`,
+ 'border-top': border('Top'),
+ 'border-right':
+ border('Right') ??
+ (props.showGridlines === false
+ ? '1px solid transparent'
+ : undefined),
+ 'border-bottom':
+ border('Bottom') ??
+ (props.showGridlines === false
+ ? '1px solid transparent'
+ : undefined),
+ 'border-left': border('Left'),
+ 'background-color': cell()?.fillColor || undefined,
+ color: cell()?.textColor || undefined,
+ 'font-family': fontFamily(cell()),
+ 'font-size': `${fontPixels(cell()) * scale()}px`,
+ 'font-style': cell()?.italic ? 'italic' : undefined,
+ 'text-decoration-line':
+ [
+ cell()?.underline ? 'underline' : '',
+ cell()?.strikethrough ? 'line-through' : '',
+ ]
+ .filter(Boolean)
+ .join(' ') || undefined,
+ 'text-align': horizontalAlign(),
+ 'justify-content':
+ cell()?.verticalAlign === 'top'
+ ? 'flex-start'
+ : cell()?.verticalAlign === 'bottom'
+ ? 'flex-end'
+ : 'center',
+ 'padding-block':
+ 'var(--spreadsheet-cell-padding-y)',
+ 'line-height': CELL_LINE_HEIGHT,
+ }}
+ class="relative flex flex-col shrink-0 border-b border-r border-edge-muted bg-surface text-ink select-none"
+ classList={{
+ 'font-semibold': cell()?.bold,
+ 'tabular-nums': value()?.number !== undefined,
+ 'text-failure': !!value()?.error,
+ }}
+ onPointerDown={(event) => {
+ if (
+ event.button !== 0 ||
+ event.ctrlKey ||
+ isInput(event.target)
+ )
+ return;
+ setTouchMode(event.pointerType === 'touch');
+ if (event.pointerType === 'touch') {
+ if (event.isPrimary === false) {
+ cancelPointer();
+ return;
+ }
+ // Defer selection until a tap is known; native panning
+ // owns movement and pointercancel without changing cells.
+ touchGesture = {
+ kind: 'tap',
+ pointerId: event.pointerId,
+ x: event.clientX,
+ y: event.clientY,
+ position,
+ moved: false,
+ };
+ keepReferenceFocus = !!(
+ props.editing || props.formulaEditing
+ );
+ return;
+ }
+ event.preventDefault();
+ keepReferenceFocus =
+ props.onReferenceStart?.({ row, column }) ??
+ false;
+ if (keepReferenceFocus) return;
+ dragging = true;
+ props.onSelect({ row, column }, event.shiftKey);
+ focusGrid();
+ }}
+ onPointerEnter={(event) => {
+ if (event.pointerType === 'touch') return;
+ if (props.pickingReference && event.buttons === 1) {
+ props.onReferenceMove?.({ row, column });
+ return;
+ }
+ if (fillSource && event.buttons === 1) {
+ previewFill({ row, column });
+ return;
+ }
+ if (dragging && event.buttons === 1)
+ props.onSelect({ row, column }, true);
+ else dragging = false;
+ }}
+ onDblClick={() => {
+ if (!touchMode() && !props.referenceSelection)
+ props.onEdit();
+ }}
+ >
+ <Show
+ when={active() && props.editing}
+ fallback={
+ <div
+ class="w-full min-h-0 overflow-hidden text-ellipsis px-[var(--spreadsheet-cell-padding)]"
+ style={{
+ 'white-space': cell()?.wrap
+ ? 'pre-wrap'
+ : 'nowrap',
+ 'overflow-wrap': cell()?.wrap
+ ? 'anywhere'
+ : undefined,
+ }}
+ >
+ {decorated()
+ ? props.mentions!.renderText(
+ cell()!.value.replace(/^'/, '')
+ )
+ : display(address)}
+ </div>
+ }
+ >
+ <FormulaInput
+ mentions={props.mentions}
+ label={`Edit ${address}`}
+ autoFocus
+ complete={props.complete}
+ readonly={props.readonly}
+ selectionRequest={props.editorSelection}
+ pickingReference={
+ props.pickingReference ||
+ (isTouchDevice() && !!props.referenceSelection)
+ }
+ onSelectionChange={props.onTextSelection}
+ class="absolute inset-0 size-full resize-none overflow-hidden bg-surface px-[var(--spreadsheet-cell-padding)] py-[var(--spreadsheet-cell-padding-y)] font-normal text-left text-ink outline-none select-text"
+ value={props.draft}
+ onInput={props.onDraft}
+ onKeyDown={editKeyDown}
+ onBlur={props.onCommit}
+ />
+ </Show>
+ <Show when={props.comments?.hasComment(address)}>
+ <button
+ type="button"
+ aria-label={`Comments on ${address}`}
+ onKeyDown={(event) => event.stopPropagation()}
+ class="absolute right-0 top-0 z-[3] h-3 w-3 bg-transparent p-0 touch:h-5 touch:w-5"
+ onPointerDown={(event) => event.stopPropagation()}
+ onMouseDown={(event) => {
+ event.preventDefault();
+ event.stopPropagation();
+ }}
+ onDblClick={(event) => event.stopPropagation()}
+ onClick={(event) => {
+ event.stopPropagation();
+ props.comments?.show(
+ address,
+ event.currentTarget.parentElement!
+ );
+ }}
+ >
+ <span class="pointer-events-none absolute right-0 top-0 size-0 border-t-[7px] border-l-[7px] border-t-accent border-l-transparent" />
+ </button>
+ </Show>
+ <Show when={value()?.error}>
+ <span class="absolute right-0.5 top-0.5 size-1 rounded-full bg-failure" />
+ </Show>
+ </div>
+ );
+ }}
+ </For>
+ </div>
+ )}
+ </For>
+ <For each={props.remoteCursors}>
+ {(cursor) => (
+ <>
+ <div
+ data-remote-selection={cursor.peerId}
+ class="absolute pointer-events-none z-[2] border-2"
+ style={{
+ ...rangeStyle(selectionBounds(cursor.selection)),
+ 'border-color': cursor.color,
+ background: `color-mix(in srgb, ${cursor.color} 8%, transparent)`,
+ }}
+ />
+ <div
+ data-remote-cursor={cursor.peerId}
+ aria-label={`${cursor.name}: ${cellAddress(cursor.selection.focus)}`}
+ class="absolute pointer-events-none z-[4] border-2"
+ style={{
+ ...rangeStyle(
+ selectionBounds({
+ anchor: cursor.selection.focus,
+ focus: cursor.selection.focus,
+ })
+ ),
+ 'border-color': cursor.color,
+ }}
+ >
+ <span
+ data-remote-cursor-name
+ class="absolute left-[-2px] max-w-40 truncate rounded-t-sm px-1.5 py-0.5 text-[11px] font-medium leading-4 text-surface shadow-sm"
+ style={{
+ background: cursor.color,
+ bottom:
+ cursor.selection.focus.row === 0 ? undefined : '100%',
+ top:
+ cursor.selection.focus.row === 0 ? '100%' : undefined,
+ }}
+ >
+ {cursor.name}
+ </span>
+ </div>
+ </>
+ )}
+ </For>
<div
aria-hidden="true"
- data-formula-reference
- class="pointer-events-none absolute z-[3] border-2 border-dashed border-accent bg-accent/10"
- style={rangeStyle(selectionBounds(range()))}
+ data-selection-range
+ class="pointer-events-none absolute z-[1] border border-accent bg-accent/10"
+ style={rangeStyle()}
/>
- )}
- </Show>
- <Show
- when={
- !touchMode() &&
- !props.readonly &&
- !props.editing &&
- !props.formulaEditing &&
- props.onFill
- }
- >
- <button
- type="button"
- tabIndex={-1}
- aria-label="Drag to fill selection"
- title="Drag to fill · ⌘/Ctrl D fills down · ⌘/Ctrl R fills right"
- class="absolute z-[3] size-2.5 border-2 border-surface bg-accent cursor-crosshair touch-none"
- style={{
- left: `${columnOffsets()[bounds().right + 1] - 5}px`,
- top: `${rowOffsets()[bounds().bottom + 1] - 5}px`,
- }}
- onPointerDown={(event) => {
- if (event.button !== 0) return;
- event.preventDefault();
- event.stopPropagation();
- props.onCommit();
- fillSource = props.selection;
- setFillTarget(props.selection);
- focusGrid();
- }}
- />
- </Show>
- <Show
- when={
- touchMode() &&
- (props.referenceSelection ||
- (!props.editing && !props.formulaEditing))
- }
- >
- <For each={[true, false]}>
- {(start) => (
+ <div
+ aria-hidden="true"
+ data-selection-active
+ class="pointer-events-none absolute z-[2] border-2 border-accent"
+ style={activeStyle()}
+ />
+ <Show when={props.referenceSelection}>
+ {(range) => (
+ <div
+ aria-hidden="true"
+ data-formula-reference
+ class="pointer-events-none absolute z-[3] border-2 border-dashed border-accent bg-accent/10"
+ style={rangeStyle(selectionBounds(range()))}
+ />
+ )}
+ </Show>
+ <Show
+ when={
+ !touchMode() &&
+ !props.readonly &&
+ !props.editing &&
+ !props.formulaEditing &&
+ props.onFill
+ }
+ >
<button
type="button"
tabIndex={-1}
- aria-label={`Move ${props.referenceSelection ? 'reference' : 'selection'} ${start ? 'start' : 'end'}`}
- class="absolute z-[4] flex size-[44px] touch-none select-none items-center justify-center outline-none"
+ aria-label="Drag to fill selection"
+ title="Drag to fill · ⌘/Ctrl D fills down · ⌘/Ctrl R fills right"
+ class="absolute z-[3] size-2.5 border-2 border-surface bg-accent cursor-crosshair touch-none"
style={{
- left: `${columnOffsets()[start ? selectionBounds(touchRange()).left : selectionBounds(touchRange()).right + 1] - 22}px`,
- top: `${rowOffsets()[start ? selectionBounds(touchRange()).top : selectionBounds(touchRange()).bottom + 1] - 22}px`,
+ left: `${columnOffsets()[bounds().right + 1] - 5}px`,
+ top: `${rowOffsets()[bounds().bottom + 1] - 5}px`,
}}
- onPointerDown={(event) => startTouchHandle(event, start)}
- onMouseDown={(event) => event.preventDefault()}
- >
- <span class="pointer-events-none size-3 rounded-full border-2 border-surface bg-accent shadow-sm" />
- </button>
- )}
- </For>
- </Show>
- </div>
- </div>
+ onPointerDown={(event) => {
+ if (event.button !== 0) return;
+ event.preventDefault();
+ event.stopPropagation();
+ props.onCommit();
+ fillSource = props.selection;
+ setFillTarget(props.selection);
+ focusGrid();
+ }}
+ />
+ </Show>
+ <Show
+ when={
+ touchMode() &&
+ (props.referenceSelection ||
+ (!props.editing && !props.formulaEditing))
+ }
+ >
+ <For each={[true, false]}>
+ {(start) => (
+ <button
+ type="button"
+ tabIndex={-1}
+ aria-label={`Move ${props.referenceSelection ? 'reference' : 'selection'} ${start ? 'start' : 'end'}`}
+ class="absolute z-[4] flex size-[44px] touch-none select-none items-center justify-center outline-none"
+ style={{
+ left: `${columnOffsets()[start ? selectionBounds(touchRange()).left : selectionBounds(touchRange()).right + 1] - 22}px`,
+ top: `${rowOffsets()[start ? selectionBounds(touchRange()).top : selectionBounds(touchRange()).bottom + 1] - 22}px`,
+ }}
+ onPointerDown={(event) => startTouchHandle(event, start)}
+ onMouseDown={(event) => event.preventDefault()}
+ >
+ <span class="pointer-events-none size-3 rounded-full border-2 border-surface bg-accent shadow-sm" />
+ </button>
+ )}
+ </For>
+ </Show>
+ </div>
+ </div>
+ )}
+ </SpreadsheetCellMenu>
);
}
diff --git a/apps/web/src/features/block-spreadsheet/components/SpreadsheetHeaderMenu.tsx b/apps/web/src/features/block-spreadsheet/components/SpreadsheetHeaderMenu.tsx
new file mode 100644
index 0000000000..0e5efcdc51
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/components/SpreadsheetHeaderMenu.tsx
@@ -0,0 +1,113 @@
+import { ContextMenuContent, MenuItem } from '@core/component/ContextMenu';
+import { ContextMenu } from '@kobalte/core/context-menu';
+import type { JSX } from 'solid-js';
+import { Show } from 'solid-js';
+
+export type HeaderAction =
+ | 'cut'
+ | 'copy'
+ | 'paste'
+ | 'paste-values'
+ | 'clear-values'
+ | 'insert-before'
+ | 'insert-after'
+ | 'delete'
+ | 'hide'
+ | 'unhide'
+ | 'resize'
+ | 'autofit'
+ | 'sort-asc'
+ | 'sort-desc';
+export function SpreadsheetHeaderMenu(props: {
+ axis: 'row' | 'column';
+ count: number;
+ readonly: boolean;
+ canChangeStructure?: boolean;
+ children: JSX.Element;
+ onOpen: () => void;
+ onAction: (action: HeaderAction) => void;
+ onRestoreFocus: () => void;
+}) {
+ let pending: HeaderAction | undefined;
+ const label = () =>
+ `${props.count} ${props.axis}${props.count === 1 ? '' : 's'}`;
+ const item = (text: string, action: HeaderAction, writable = true) => (
+ <MenuItem
+ text={text}
+ disabled={
+ (writable && props.readonly) ||
+ ((action.startsWith('insert-') || action === 'delete') &&
+ !props.canChangeStructure)
+ }
+ closeOnSelect
+ onClick={() => {
+ pending = action;
+ }}
+ />
+ );
+ return (
+ <ContextMenu
+ onOpenChange={(open) => {
+ if (open) props.onOpen();
+ }}
+ >
+ <ContextMenu.Trigger
+ as="div"
+ class="contents"
+ onKeyDown={(event: KeyboardEvent) => {
+ if (
+ event.key === 'ContextMenu' ||
+ (event.shiftKey && event.key === 'F10')
+ )
+ event.stopPropagation();
+ }}
+ >
+ {props.children}
+ </ContextMenu.Trigger>
+ <ContextMenu.Portal>
+ <ContextMenuContent
+ class="min-w-56"
+ onCloseAutoFocus={(event) => {
+ event.preventDefault();
+ const action = pending;
+ pending = undefined;
+ queueMicrotask(() => {
+ props.onRestoreFocus();
+ if (action) props.onAction(action);
+ });
+ }}
+ >
+ {item('Cut', 'cut')}
+ {item('Copy', 'copy', false)}
+ {item('Paste', 'paste')}
+ {item('Paste values only', 'paste-values')}
+ <ContextMenu.Separator class="my-1 border-t border-edge-muted" />
+ {item(
+ `Insert ${label()} ${props.axis === 'row' ? 'above' : 'left'}`,
+ 'insert-before'
+ )}
+ {item(
+ `Insert ${label()} ${props.axis === 'row' ? 'below' : 'right'}`,
+ 'insert-after'
+ )}
+ <Show when={!props.canChangeStructure && !props.readonly}>
+ <div class="max-w-64 px-3 py-1 text-xs text-ink-muted">
+ Insert and delete are available in local workbooks.
+ </div>
+ </Show>
+ {item(`Delete ${label()}`, 'delete')}
+ {item(`Clear ${label()}`, 'clear-values')}
+ {item(`Hide ${label()}`, 'hide')}
+ {item(`Unhide all ${props.axis}s`, 'unhide')}
+ {item(`Resize ${label()}…`, 'resize')}
+ {item('Fit to data', 'autofit')}
+ <Show when={props.axis === 'column'}>
+ <ContextMenu.Separator class="my-1 border-t border-edge-muted" />
+ {item('Sort sheet A to Z', 'sort-asc')}
+ {item('Sort sheet Z to A', 'sort-desc')}
+ </Show>
+ </ContextMenuContent>
+ </ContextMenu.Portal>
+ </ContextMenu>
+ );
+}
diff --git a/apps/web/src/features/block-spreadsheet/components/SpreadsheetToolbar.tsx b/apps/web/src/features/block-spreadsheet/components/SpreadsheetToolbar.tsx
index d1b7dc222f..070e873d0e 100644
--- a/apps/web/src/features/block-spreadsheet/components/SpreadsheetToolbar.tsx
+++ b/apps/web/src/features/block-spreadsheet/components/SpreadsheetToolbar.tsx
@@ -1,6 +1,7 @@
import ArrowBendDownRight from '@phosphor/arrow-bend-down-right.svg';
import ArrowClockwise from '@phosphor/arrow-clockwise.svg';
import ArrowCounterClockwise from '@phosphor/arrow-counter-clockwise.svg';
+import CommentIcon from '@phosphor/chat-circle.svg';
import Check from '@phosphor/check.svg';
import CurrencyDollar from '@phosphor/currency-dollar.svg';
import FunctionIcon from '@phosphor/function.svg';
@@ -15,6 +16,7 @@ import TextUnderline from '@phosphor/text-underline.svg';
import X from '@phosphor/x.svg';
import { Button, type ButtonProps } from '@ui/components/Button';
import { Show } from 'solid-js';
+import type { SpreadsheetMentions } from '../context/spreadsheet-mentions';
import type { FormulaTextSelection } from '../core/formula-reference';
import type { SpreadsheetToolbarProps } from '../core/toolbar-types';
import type { CompleteFormula } from '../primitives/create-formula-assistance';
@@ -261,6 +263,20 @@ export function SpreadsheetToolbar(props: SpreadsheetToolbarProps) {
>
<MagnifyingGlass class="size-[18px]" />
</ToolbarButton>
+ <Show when={props.onComment}>
+ <Divider />
+ <Button
+ size="sm"
+ variant="ghost"
+ class="shrink-0 h-7 gap-1.5 px-2 text-[13px] touch:min-h-[44px]"
+ disabled={!props.canComment}
+ onClick={() => props.onComment?.()}
+ tooltip="Comment on selected cells (⌘/Ctrl Alt M)"
+ >
+ <CommentIcon class="size-[18px]" />
+ Comment
+ </Button>
+ </Show>
<Show when={props.readonly}>
<span class="ml-auto shrink-0 px-2 text-[10px] text-ink-muted">
View only
@@ -272,6 +288,7 @@ export function SpreadsheetToolbar(props: SpreadsheetToolbarProps) {
}
export function FormulaBar(props: {
+ mentions?: SpreadsheetMentions;
address: string;
value: string;
readonly: boolean;
@@ -330,6 +347,7 @@ export function FormulaBar(props: {
/>
<FunctionIcon class="mx-2 size-3.5 shrink-0 text-ink-subtle" />
<FormulaInput
+ mentions={props.mentions}
label="Formula bar"
complete={props.complete}
selectionRequest={props.selectionRequest}
diff --git a/apps/web/src/features/block-spreadsheet/context/spreadsheet-comments.ts b/apps/web/src/features/block-spreadsheet/context/spreadsheet-comments.ts
new file mode 100644
index 0000000000..5c619fc8d2
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/context/spreadsheet-comments.ts
@@ -0,0 +1,9 @@
+/** Optional comments bridge. Draft/offline-only workbooks don't expose server comments. */
+export type SpreadsheetCommentsCapability = {
+ canComment: () => boolean;
+ add: (cell: HTMLElement | undefined) => void;
+ hasComment: (address: string) => boolean;
+ enter: (address: string, cell: HTMLElement) => void;
+ leave: () => void;
+ show: (address: string, cell: HTMLElement) => void;
+};
diff --git a/apps/web/src/features/block-spreadsheet/context/spreadsheet-mentions.ts b/apps/web/src/features/block-spreadsheet/context/spreadsheet-mentions.ts
new file mode 100644
index 0000000000..c61b0fae5f
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/context/spreadsheet-mentions.ts
@@ -0,0 +1,17 @@
+import type { JSX } from 'solid-js';
+export type CellTextEditorProps = {
+ label: string;
+ value: string;
+ class: string;
+ readonly?: boolean;
+ autoFocus?: boolean;
+ onFocus?: () => void;
+ onInput: (value: string) => void;
+ onKeyDown: (event: KeyboardEvent) => void;
+ onBlur: () => void;
+ onSelectionChange?: (start: number, end: number) => void;
+};
+export type SpreadsheetMentions = {
+ renderText: (value: string) => JSX.Element;
+ renderEditor: (props: CellTextEditorProps) => JSX.Element;
+};
diff --git a/apps/web/src/features/block-spreadsheet/core/calculation-inputs.ts b/apps/web/src/features/block-spreadsheet/core/calculation-inputs.ts
index 9ca887003b..94ef208328 100644
--- a/apps/web/src/features/block-spreadsheet/core/calculation-inputs.ts
+++ b/apps/web/src/features/block-spreadsheet/core/calculation-inputs.ts
@@ -1,8 +1,9 @@
+import type { WorkbookSheetMetadata } from '@macro-inc/spreadsheet/workbook-metadata';
import type { SpreadsheetCell, SpreadsheetCells } from './spreadsheet-document';
export type CalculationCells = Record<
string,
- Pick<SpreadsheetCell, 'value' | 'format' | 'decimals'>
+ Pick<SpreadsheetCell, 'value' | 'format' | 'decimals' | 'numberFormat'>
>;
/** Keep appearance edits out of the calculation dependency graph. */
@@ -17,14 +18,27 @@ export function calculationInputs(
const decimals = cell.decimals ?? -1;
// Formatting an otherwise empty cell must not trigger calculation. Keep
// number formats, though: a blank source cell can display an array spill.
- if (cell.value === '' && format === 'general' && decimals === -1) continue;
- next[address] = { value: cell.value, format, decimals };
+ const numberFormat = cell.numberFormat;
+ if (
+ cell.value === '' &&
+ format === 'general' &&
+ decimals === -1 &&
+ !numberFormat
+ )
+ continue;
+ next[address] = {
+ value: cell.value,
+ format,
+ decimals,
+ ...(numberFormat && { numberFormat }),
+ };
const prior = previous[address];
if (
!prior ||
prior.value !== cell.value ||
prior.format !== format ||
- prior.decimals !== decimals
+ prior.decimals !== decimals ||
+ prior.numberFormat !== numberFormat
) {
unchanged = false;
}
@@ -39,6 +53,7 @@ export type CalculationWorkbookInput = {
name: string;
cells: SpreadsheetCells;
rowCount: number;
+ metadata?: WorkbookSheetMetadata;
};
/** Preserve each sheet's calculation identity across formatting and layout edits. */
@@ -53,6 +68,8 @@ export function workbookCalculationInputs(
return prior &&
prior.name === sheet.name &&
prior.rowCount === sheet.rowCount &&
+ JSON.stringify(prior.metadata?.definedNames) ===
+ JSON.stringify(sheet.metadata?.definedNames) &&
cells === prior.cells
? prior
: { ...sheet, cells };
diff --git a/apps/web/src/features/block-spreadsheet/core/calculation-protocol.ts b/apps/web/src/features/block-spreadsheet/core/calculation-protocol.ts
index a163ac4be9..53de957a48 100644
--- a/apps/web/src/features/block-spreadsheet/core/calculation-protocol.ts
+++ b/apps/web/src/features/block-spreadsheet/core/calculation-protocol.ts
@@ -1,4 +1,5 @@
import type { CompletionContext } from '@ironcalc/wasm';
+import type { AxisChange } from '@macro-inc/spreadsheet/workbook-structure';
import type {
CalculationContext,
CalculationSheet,
@@ -10,8 +11,15 @@ import type {
SpreadsheetCellEdits,
SpreadsheetCells,
} from './spreadsheet-document';
+import type { SpreadsheetWorkbookSheet } from './workbook-document';
export type CalculationRequest =
+ | {
+ id: number;
+ type: 'change-axis';
+ sheets: SpreadsheetWorkbookSheet[];
+ change: AxisChange;
+ }
| { id: number; type: 'calculate'; cells: SpreadsheetCells; rowCount: number }
| { id: number; type: 'calculate-workbook'; sheets: CalculationSheet[] }
| {
@@ -29,6 +37,7 @@ export type CalculationRequest =
};
export type CalculationResponse =
+ | { id: number; type: 'change-axis'; sheets: SpreadsheetWorkbookSheet[] }
| { id: number; type: 'started' }
| { id: number; type: 'calculate'; values: SpreadsheetCalculation }
| { id: number; type: 'calculate-workbook'; values: WorkbookCalculation }
@@ -37,6 +46,7 @@ export type CalculationResponse =
| { id: number; type: 'error'; message: string };
export type CalculationOperation =
+ | Omit<Extract<CalculationRequest, { type: 'change-axis' }>, 'id'>
| Omit<Extract<CalculationRequest, { type: 'calculate' }>, 'id'>
| Omit<Extract<CalculationRequest, { type: 'calculate-workbook' }>, 'id'>
| Omit<Extract<CalculationRequest, { type: 'copy' }>, 'id'>
diff --git a/apps/web/src/features/block-spreadsheet/core/cell-mentions.test.ts b/apps/web/src/features/block-spreadsheet/core/cell-mentions.test.ts
new file mode 100644
index 0000000000..a5b16c0c6c
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/cell-mentions.test.ts
@@ -0,0 +1,100 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { initSync } from '@ironcalc/wasm';
+import { createInitializedSpreadsheetCalculator } from '@macro-inc/spreadsheet/calculation';
+import {
+ cellMentionQuery,
+ cellPlainText,
+ cellTextParts,
+ encodeCellMention,
+} from '@macro-inc/spreadsheet/cell-mentions';
+import { LoroDoc } from 'loro-crdt';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { encodeCsv } from './csv-export';
+import {
+ readSpreadsheetCells,
+ writeSpreadsheetCells,
+} from './spreadsheet-document';
+
+beforeAll(() =>
+ initSync({
+ module: readFileSync(
+ createRequire(import.meta.url).resolve('@ironcalc/wasm/wasm_bg.wasm')
+ ),
+ })
+);
+const person = encodeCellMention({
+ type: 'user',
+ userId: 'macro|[email protected]',
+ email: '[email protected]',
+ displayName: 'Taylor',
+});
+describe('spreadsheet mention source', () => {
+ it('reuses docs tags with mixed text while treating all other Markdown literally', () => {
+ expect(cellPlainText(`**Owner:** ${person} _review_`)).toBe(
+ '**Owner:** @Taylor _review_'
+ );
+ expect(cellTextParts(`Hi ${person}!`)).toHaveLength(3);
+ expect(
+ cellPlainText('=CONCAT("' + person + '")').startsWith('=CONCAT')
+ ).toBe(true);
+ });
+ it('preserves malformed or unsafe mention payloads as text', () => {
+ for (const text of [
+ '<m-user-mention>bad</m-user-mention>',
+ '<m-document-mention>{"documentId":"id","documentName":"X","blockName":"javascript"}</m-document-mention>',
+ ])
+ expect(cellPlainText(text)).toBe(text);
+ const mention = encodeCellMention({
+ type: 'document',
+ documentId: 'a',
+ documentName: '</m-document-mention><img src=x>',
+ blockName: 'md',
+ });
+ expect(cellTextParts(mention)[0].mention?.type).toBe('document');
+ expect(mention).not.toContain('<img');
+ });
+ it('finds @ queries at the caret without matching email addresses, formula strings, or encoded pills', () => {
+ expect(cellMentionQuery('Owner @tay', 10)).toEqual({
+ start: 6,
+ end: 10,
+ query: 'tay',
+ });
+ expect(cellMentionQuery('[email protected]', 14)).toBeUndefined();
+ expect(cellMentionQuery('="@tay"', 6)).toBeUndefined();
+ expect(cellMentionQuery(person, 20)).toBeUndefined();
+ expect(cellMentionQuery(person + ' @', person.length + 2)?.query).toBe('');
+ });
+ it('round trips through collaboration and calculates/export labels without stripping stored mentions', () => {
+ const first = new LoroDoc(),
+ second = new LoroDoc();
+ const engine = createInitializedSpreadsheetCalculator();
+ try {
+ writeSpreadsheetCells(first, {
+ A1: { value: person },
+ B1: { value: '=A1&" owns this"' },
+ C1: {
+ value: encodeCellMention({
+ type: 'document',
+ documentId: 'doc',
+ documentName: '=1+1',
+ blockName: 'md',
+ }),
+ },
+ });
+ second.import(first.export({ mode: 'snapshot' }));
+ const cells = readSpreadsheetCells(second);
+ const values = engine.calculate(cells);
+ expect(cells.A1.value).toBe(person);
+ expect(values.A1.display).toBe('@Taylor');
+ expect(values.B1.display).toBe('@Taylor owns this');
+ expect(values.C1.display).toBe('=1+1');
+ expect(values.C1.number).toBeUndefined();
+ expect(encodeCsv(cells, values)).not.toContain('m-user');
+ } finally {
+ first.free();
+ second.free();
+ engine.dispose();
+ }
+ });
+});
diff --git a/apps/web/src/features/block-spreadsheet/core/csv-export.ts b/apps/web/src/features/block-spreadsheet/core/csv-export.ts
new file mode 100644
index 0000000000..22a1fa08f7
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/csv-export.ts
@@ -0,0 +1,40 @@
+import type { SpreadsheetCalculation } from './calculation';
+import {
+ cellAddress,
+ positionFromAddress,
+ safeCsvValue,
+ serializeTable,
+} from './grid-selection';
+import type { SpreadsheetCells } from './spreadsheet-document';
+
+/** Export raw numeric results (never rounded UI labels), with RFC 4180 quoting
+ * and protection against executing formula-like text in external applications. */
+export function encodeCsv(
+ cells: SpreadsheetCells,
+ values: SpreadsheetCalculation
+) {
+ const positions = [
+ ...new Set([...Object.keys(cells), ...Object.keys(values)]),
+ ]
+ .map(positionFromAddress)
+ .filter((position) => position !== undefined);
+ const bottom = Math.max(0, ...positions.map((position) => position.row));
+ const right = Math.max(0, ...positions.map((position) => position.column));
+ return serializeTable(
+ Array.from({ length: bottom + 1 }, (_, row) =>
+ Array.from({ length: right + 1 }, (_, column) => {
+ const address = cellAddress({ row, column });
+ const result = values[address];
+ return safeCsvValue(
+ result?.number !== undefined
+ ? String(result.number)
+ : (result?.display ??
+ cells[address]?.value.replace(/^'/, '') ??
+ ''),
+ result?.number !== undefined
+ );
+ })
+ ),
+ ','
+ );
+}
diff --git a/apps/web/src/features/block-spreadsheet/core/csv-file.test.ts b/apps/web/src/features/block-spreadsheet/core/csv-file.test.ts
new file mode 100644
index 0000000000..407bb31418
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/csv-file.test.ts
@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest';
+import { encodeCsv } from './csv-export';
+import { csvImportEdits } from './sheet-operations';
+import { decodeCsv, isUploadedWorkbook } from './uploaded-workbook';
+
+describe('uploaded Excel/CSV detection', () => {
+ it.each(['xlsx', 'XLSX', 'csv', 'CSV'])('recognizes %s', (type) =>
+ expect(isUploadedWorkbook(type)).toBe(true)
+ );
+ it.each(['xls', 'xlsm', 'pdf', 'spreadsheet', '', null, undefined])(
+ 'rejects %s',
+ (type) => expect(isUploadedWorkbook(type)).toBe(false)
+ );
+});
+describe('CSV file import and export', () => {
+ it('reads BOM, CRLF, embedded newlines, escaped quotes, Unicode, empty and trailing fields', () => {
+ const { cells } = decodeCsv(
+ '\uFEFFAccount,Amount,Note,Empty\r\n00123,-1234.56789,"First line\nSecond, ""quoted"" €",\r\n'
+ ).sheets[0];
+ expect(cells).toEqual({
+ A1: { value: "'Account" },
+ B1: { value: "'Amount" },
+ C1: { value: "'Note" },
+ D1: { value: "'Empty" },
+ A2: { value: "'00123" },
+ B2: { value: '-1234.56789' },
+ C2: { value: '\'First line\nSecond, "quoted" €' },
+ });
+ });
+ it('preserves 16+ digit identifiers and protects formula-looking values', () => {
+ const { cells } = decodeCsv(
+ '1234567890123456,0,0.125,1e3,=SUM(A1:A2),@SUM(A1),+cmd,-12,001,TRUE'
+ ).sheets[0];
+ expect(Object.values(cells).map((cell) => cell.value)).toEqual([
+ "'1234567890123456",
+ '0',
+ '0.125',
+ '1e3',
+ "'=SUM(A1:A2)",
+ "'@SUM(A1)",
+ "'+cmd",
+ '-12',
+ "'001",
+ "'TRUE",
+ ]);
+ });
+ it('exports unrounded numbers and quotes multiline/comma/quote values; external formulas stay inert', () => {
+ const csv = encodeCsv(
+ {
+ A1: { value: '=1/3' },
+ B1: { value: '\'two, "words"\nnext' },
+ C1: { value: "'=1+1" },
+ A2: { value: '-42' },
+ },
+ {
+ A1: { display: '$0.33', number: 1 / 3 },
+ B1: { display: 'two, "words"\nnext' },
+ C1: { display: '=1+1' },
+ A2: { display: '($42.00)', number: -42 },
+ }
+ );
+ expect(csv).toBe('0.3333333333333333,"two, ""words""\nnext",\'=1+1\n-42,,');
+ const parsed = decodeCsv(csv).sheets[0].cells;
+ expect(parsed.B1.value).toBe('\'two, "words"\nnext');
+ expect(parsed.C1.value).toBe("''=1+1");
+ expect(parsed.A2.value).toBe('-42');
+ });
+ it('uses the same safe interpretation when importing into an existing selection', () => {
+ const result = csvImportEdits('00123,=1+1\n42,0.125', {
+ anchor: { row: 2, column: 1 },
+ focus: { row: 2, column: 1 },
+ });
+ expect(result.edits).toEqual({
+ B3: { value: "'00123" },
+ C3: { value: "'=1+1" },
+ B4: { value: '42' },
+ C4: { value: '0.125' },
+ });
+ });
+ it.each([
+ '',
+ '"unterminated',
+ 'a'.repeat(10001),
+ 'x\n'.repeat(1001),
+ Array(27).fill('x').join(','),
+ ])('rejects invalid or oversized input atomically', (text) =>
+ expect(() => decodeCsv(text)).toThrow()
+ );
+});
diff --git a/apps/web/src/features/block-spreadsheet/core/csv-value.ts b/apps/web/src/features/block-spreadsheet/core/csv-value.ts
new file mode 100644
index 0000000000..d280b75196
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/csv-value.ts
@@ -0,0 +1,9 @@
+/** CSV has no type metadata. Preserve identifiers and formula-looking text. */
+export function csvCellValue(value: string): string {
+ if (!value) return '';
+ const numeric =
+ /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(value) &&
+ Number.isFinite(Number(value)) &&
+ value.replace(/[^\d]/g, '').length <= 15;
+ return numeric ? value : `'${value}`;
+}
diff --git a/apps/web/src/features/block-spreadsheet/core/sheet-operations.test.ts b/apps/web/src/features/block-spreadsheet/core/sheet-operations.test.ts
index 6e0826398d..01e989fbd6 100644
--- a/apps/web/src/features/block-spreadsheet/core/sheet-operations.test.ts
+++ b/apps/web/src/features/block-spreadsheet/core/sheet-operations.test.ts
@@ -1,3 +1,4 @@
+import { encodeCellMention } from '@macro-inc/spreadsheet/cell-mentions';
import { describe, expect, it } from 'vitest';
import type { CellSelection } from './grid-selection';
import {
@@ -93,11 +94,11 @@ describe('spreadsheet range operations', () => {
);
expect(result).toEqual({
edits: {
- B2: { value: 'Name' },
- C2: { value: 'Note' },
- B3: { value: 'Smith, Lee' },
- C3: { value: 'said "yes"\nnext line' },
- B4: { value: 'Last' },
+ B2: { value: "'Name" },
+ C2: { value: "'Note" },
+ B3: { value: "'Smith, Lee" },
+ C3: { value: '\'said "yes"\nnext line' },
+ B4: { value: "'Last" },
C4: { value: '' },
},
rowCount: 4,
@@ -124,7 +125,7 @@ describe('spreadsheet range operations', () => {
expect(() => csvImportEdits('one,two', lastCell)).toThrow('fit within');
expect(() => csvImportEdits('one\ntwo', lastCell)).toThrow('fit within');
expect(csvImportEdits('fits', lastCell).edits).toEqual({
- Z1000: { value: 'fits' },
+ Z1000: { value: "'fits" },
});
});
@@ -182,3 +183,34 @@ describe('spreadsheet range operations', () => {
).toEqual({ A1: { value: 'a b\n c' }, C1: { value: '=literal text' } });
});
});
+
+it('treats mentions as atomic during find, replace and whitespace cleanup', () => {
+ const mention = encodeCellMention({
+ type: 'document',
+ documentId: 'id-2026',
+ documentName: 'Budget 2026',
+ blockName: 'md',
+ });
+ const value = ` Budget 2026 ${mention} `;
+ expect(replaceCellText(value, '2026', '2027"\\', options)).toBe(
+ ` Budget 2027"\\ ${mention} `
+ );
+ expect(
+ replaceCellText(mention, 'Budget 2026', 'Changed', {
+ ...options,
+ entireCell: true,
+ })
+ ).toBe(mention);
+ expect(trimWhitespaceEdits({ A1: { value } }, origin).A1?.value).toBe(
+ `Budget 2026 ${mention}`
+ );
+ expect(
+ findCells({ A1: { value } }, {}, 'id-2026', { ...options, formulas: true })
+ ).toEqual([]);
+ expect(
+ findCells({ A1: { value } }, {}, 'Budget 2026', {
+ ...options,
+ formulas: true,
+ })
+ ).toEqual(['A1']);
+});
diff --git a/apps/web/src/features/block-spreadsheet/core/sheet-operations.ts b/apps/web/src/features/block-spreadsheet/core/sheet-operations.ts
index 7039712f68..16249c3521 100644
--- a/apps/web/src/features/block-spreadsheet/core/sheet-operations.ts
+++ b/apps/web/src/features/block-spreadsheet/core/sheet-operations.ts
@@ -1,4 +1,9 @@
+import {
+ cellPlainText,
+ cellTextParts,
+} from '@macro-inc/spreadsheet/cell-mentions';
import type { CellCopy, SpreadsheetCalculation } from './calculation';
+import { csvCellValue } from './csv-value';
import {
type CellSelection,
cellAddress,
@@ -49,10 +54,10 @@ export function sortedRangeCopies(
cells: SpreadsheetCells,
values: SpreadsheetCalculation,
selection: CellSelection,
- descending: boolean
+ descending: boolean,
+ keyColumn = selection.anchor.column
): CellCopy[] {
const { top, bottom, left, right } = selectionBounds(selection);
- const keyColumn = selection.anchor.column;
const rows = Array.from(
{ length: bottom - top + 1 },
(_, index) => top + index
@@ -102,7 +107,12 @@ export function trimWhitespaceEdits(
const value = cells[address]?.value;
if (!value || (value.startsWith('=') && cells[address]?.format !== 'text'))
continue;
- const trimmed = value.trim().replace(/[\t ]+/g, ' ');
+ const trimmed = cellTextParts(value)
+ .map((part) =>
+ part.mention ? part.text : part.text.replace(/[\t ]+/g, ' ')
+ )
+ .join('')
+ .trim();
if (trimmed !== value) edits[address] = { value: trimmed };
}
return edits;
@@ -132,7 +142,7 @@ export function csvImportEdits(text: string, selection: CellSelection) {
throw new Error('A cell can contain up to 10,000 characters.');
edits[
cellAddress({ row: start.row + index, column: start.column + column })
- ] = { value };
+ ] = { value: csvCellValue(value) };
}
});
return {
@@ -164,9 +174,11 @@ export function findCells(
return [...new Set([...Object.keys(cells), ...Object.keys(values)])]
.filter((address) => {
const text = normalize(
- options.formulas
- ? (cells[address]?.value ?? '')
- : (values[address]?.display ?? cells[address]?.value ?? '')
+ cellPlainText(
+ options.formulas
+ ? (cells[address]?.value ?? '')
+ : (values[address]?.display ?? cells[address]?.value ?? '')
+ )
);
return options.entireCell ? text === needle : text.includes(needle);
})
@@ -186,8 +198,16 @@ export function replaceCellText(
if (!query) return text;
const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
const pattern = options.entireCell ? `^${escaped}$` : escaped;
- return text.replace(
- new RegExp(pattern, options.matchCase ? 'g' : 'gi'),
- () => replacement
- );
+ const parts = cellTextParts(text);
+ if (options.entireCell && parts.some((part) => part.mention)) return text;
+ return parts
+ .map((part) =>
+ part.mention
+ ? part.text
+ : part.text.replace(
+ new RegExp(pattern, options.matchCase ? 'g' : 'gi'),
+ () => replacement
+ )
+ )
+ .join('');
}
diff --git a/apps/web/src/features/block-spreadsheet/core/spreadsheet-comments.ts b/apps/web/src/features/block-spreadsheet/core/spreadsheet-comments.ts
new file mode 100644
index 0000000000..1781cad164
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/spreadsheet-comments.ts
@@ -0,0 +1,47 @@
+import { positionFromAddress } from './grid-selection';
+
+export const SPREADSHEET_COMMENT_PARAMS = { commentId: 'comment_id' } as const;
+
+export type SpreadsheetCommentAnchor = {
+ sheetId: string;
+ sheetName: string;
+ range: string;
+};
+
+/** Stored on the existing document annotation thread, never in cell contents. */
+export function spreadsheetCommentAnchor(
+ metadata: unknown
+): SpreadsheetCommentAnchor | undefined {
+ if (!metadata || typeof metadata !== 'object' || !('spreadsheet' in metadata))
+ return;
+ const value = metadata.spreadsheet;
+ if (
+ !value ||
+ typeof value !== 'object' ||
+ !('sheetId' in value) ||
+ !('sheetName' in value) ||
+ !('range' in value)
+ )
+ return;
+ if (
+ typeof value.sheetId !== 'string' ||
+ !value.sheetId ||
+ typeof value.sheetName !== 'string' ||
+ typeof value.range !== 'string'
+ )
+ return;
+ const addresses = value.range.split(':');
+ if (
+ addresses.length > 2 ||
+ !addresses.every(
+ (address) =>
+ /^[A-Z]+[1-9]\d*$/.test(address) && positionFromAddress(address)
+ )
+ )
+ return;
+ return {
+ sheetId: value.sheetId,
+ sheetName: value.sheetName,
+ range: value.range,
+ };
+}
diff --git a/apps/web/src/features/block-spreadsheet/core/spreadsheet-document.test.ts b/apps/web/src/features/block-spreadsheet/core/spreadsheet-document.test.ts
index 87a8098d0f..3753774212 100644
--- a/apps/web/src/features/block-spreadsheet/core/spreadsheet-document.test.ts
+++ b/apps/web/src/features/block-spreadsheet/core/spreadsheet-document.test.ts
@@ -131,6 +131,17 @@ describe('spreadsheet document', () => {
it('reopens all formatting fields and clears style without changing values', () => {
const original = new LoroDoc();
const style: Required<SpreadsheetCellStyle> = {
+ numberFormat: '#,##0;(#,##0);"—"',
+ fontName: 'Calibri',
+ borderTopStyle: 'double',
+ borderTopColor: '#123456',
+ borderRightStyle: 'double',
+ borderRightColor: '#123456',
+ borderBottomStyle: 'double',
+ borderBottomColor: '#123456',
+ borderLeftStyle: 'double',
+ borderLeftColor: '#123456',
+
bold: true,
italic: true,
underline: true,
diff --git a/apps/web/src/features/block-spreadsheet/core/spreadsheet-history.test.ts b/apps/web/src/features/block-spreadsheet/core/spreadsheet-history.test.ts
index a3b157d135..768803cd8c 100644
--- a/apps/web/src/features/block-spreadsheet/core/spreadsheet-history.test.ts
+++ b/apps/web/src/features/block-spreadsheet/core/spreadsheet-history.test.ts
@@ -42,6 +42,21 @@ function pair() {
}
describe('structural spreadsheet history', () => {
+ it('blocks axis undo when a peer adds a reference at an untouched address', () => {
+ const { left, right, id, history, sync, dispose } = pair();
+ writeSpreadsheetCells(left, { A1: { value: '10' } }, id);
+ writeSpreadsheetCells(left, { A1: null, A2: { value: '10' } }, id, false);
+ left.commit({ origin: 'spreadsheet-axis-change' });
+ expect(history.undo()).toBeUndefined();
+ expect(history.redo()).toBeUndefined();
+ sync();
+ writeSpreadsheetCells(right, { B1: { value: '=A2' } }, id);
+ sync();
+ const before = left.version().toJSON();
+ expect(history.undo()).toContain('workbook changed');
+ expect(left.version().toJSON()).toEqual(before);
+ dispose();
+ });
it('blocks undo of a rename referenced by a peer without emitting any live operation or consuming history', () => {
const { left, right, id, history, sync, dispose } = pair();
renameSpreadsheetSheet(left, id, 'After');
diff --git a/apps/web/src/features/block-spreadsheet/core/spreadsheet-history.ts b/apps/web/src/features/block-spreadsheet/core/spreadsheet-history.ts
index de51652113..4e10579beb 100644
--- a/apps/web/src/features/block-spreadsheet/core/spreadsheet-history.ts
+++ b/apps/web/src/features/block-spreadsheet/core/spreadsheet-history.ts
@@ -18,7 +18,11 @@ type HistoryChange = {
after: Scalar;
};
type HistoryMetadata =
- | { kind: 'structural' | 'edit'; changes: HistoryChange[] }
+ | {
+ kind: 'structural' | 'edit';
+ changes: HistoryChange[];
+ axisWorkbook?: string;
+ }
| { kind: 'unavailable' };
function metadata(value: Value | undefined): HistoryMetadata | undefined {
@@ -53,6 +57,13 @@ export function createSpreadsheetHistory(doc: LoroDoc, onChange: () => void) {
popped && popped.kind !== 'unavailable'
? {
kind: popped.kind,
+ ...(popped.axisWorkbook
+ ? {
+ axisWorkbook: JSON.stringify(
+ readSpreadsheetWorkbook(doc)
+ ),
+ }
+ : {}),
changes: popped.changes.map((change) => ({
...change,
after: scalar(doc, change.map, change.key),
@@ -81,7 +92,13 @@ export function createSpreadsheetHistory(doc: LoroDoc, onChange: () => void) {
}));
});
return {
- value: { kind: structural ? 'structural' : 'edit', changes },
+ value: {
+ kind: structural ? 'structural' : 'edit',
+ changes,
+ ...(event.origin === 'spreadsheet-axis-change'
+ ? { axisWorkbook: JSON.stringify(readSpreadsheetWorkbook(doc)) }
+ : {}),
+ },
cursors: [],
};
} catch {
@@ -99,6 +116,11 @@ export function createSpreadsheetHistory(doc: LoroDoc, onChange: () => void) {
const action = direction === 'undo' ? 'Undo' : 'Redo';
if (item?.kind === 'unavailable')
return `${action} is unavailable because this sheet change could not be checked safely.`;
+ if (
+ item?.axisWorkbook &&
+ item.axisWorkbook !== JSON.stringify(readSpreadsheetWorkbook(doc))
+ )
+ return `${action} is blocked because the workbook changed after moving rows or columns. Newer changes have been kept.`;
if (
item?.changes.some(
(change) =>
@@ -148,6 +170,7 @@ export function createSpreadsheetHistory(doc: LoroDoc, onChange: () => void) {
reversing = item
? {
kind: item.kind,
+ ...(item.axisWorkbook ? { axisWorkbook: item.axisWorkbook } : {}),
changes: item.changes.map((change) => ({
...change,
before: scalar(doc, change.map, change.key),
diff --git a/apps/web/src/features/block-spreadsheet/core/toolbar-types.ts b/apps/web/src/features/block-spreadsheet/core/toolbar-types.ts
index 581be3b130..40e1fbb712 100644
--- a/apps/web/src/features/block-spreadsheet/core/toolbar-types.ts
+++ b/apps/web/src/features/block-spreadsheet/core/toolbar-types.ts
@@ -34,6 +34,8 @@ export type SpreadsheetCommand =
export type SpreadsheetToolbarProps = {
readonly: boolean;
+ onComment?: () => void;
+ canComment?: boolean;
canUndo: boolean;
canRedo: boolean;
cell: SpreadsheetCell | undefined;
diff --git a/apps/web/src/features/block-spreadsheet/core/uploaded-workbook.ts b/apps/web/src/features/block-spreadsheet/core/uploaded-workbook.ts
new file mode 100644
index 0000000000..df0551bb3d
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/uploaded-workbook.ts
@@ -0,0 +1,35 @@
+import { csvImportEdits } from './sheet-operations';
+import {
+ SPREADSHEET_ROWS,
+ type SpreadsheetCells,
+} from './spreadsheet-document';
+import type { WorkbookFileData } from './workbook-file-types';
+
+export function isUploadedWorkbook(fileType: string | null | undefined) {
+ return /^(xlsx|csv)$/i.test(fileType ?? '');
+}
+
+/** CSV carries values, not executable formulas or cell types. Keep identifiers
+ * and formula-looking text literal; only unambiguous finite numbers are inferred. */
+export function decodeCsv(text: string): WorkbookFileData {
+ const result = csvImportEdits(text, {
+ anchor: { row: 0, column: 0 },
+ focus: { row: 0, column: 0 },
+ });
+ const cells: SpreadsheetCells = {};
+ for (const [address, edit] of Object.entries(result.edits)) {
+ const value = edit?.value ?? '';
+ if (value) cells[address] = { value };
+ }
+ return {
+ sheets: [
+ {
+ name: 'Sheet1',
+ cells,
+ rowCount: Math.max(SPREADSHEET_ROWS, result.rowCount),
+ columnWidths: {},
+ },
+ ],
+ warnings: [],
+ };
+}
diff --git a/apps/web/src/features/block-spreadsheet/core/workbook-document.test.ts b/apps/web/src/features/block-spreadsheet/core/workbook-document.test.ts
index 8eff1ca38c..80a232a058 100644
--- a/apps/web/src/features/block-spreadsheet/core/workbook-document.test.ts
+++ b/apps/web/src/features/block-spreadsheet/core/workbook-document.test.ts
@@ -773,3 +773,54 @@ describe('sheet formula references', () => {
expect(formulaReferencesSheet(formula, name)).toBe(expected);
});
});
+
+it('duplicates local definitions without duplicating global names and rejects colliding appended names atomically', () => {
+ const doc = new LoroDoc();
+ try {
+ importSpreadsheetSheets(
+ doc,
+ [
+ {
+ name: 'Inputs',
+ cells: { A1: { value: '10' } },
+ rowCount: 200,
+ columnWidths: {},
+ metadata: {
+ definedNames: [
+ { name: 'GlobalRate', formula: '0.1' },
+ { name: 'LocalRate', formula: '0.2', local: true },
+ ],
+ },
+ },
+ ],
+ true
+ );
+ const source = readSpreadsheetWorkbook(doc)[0];
+ duplicateSpreadsheetSheet(doc, source.id);
+ const workbook = readSpreadsheetWorkbook(doc);
+ expect(workbook[1].metadata?.definedNames).toEqual([
+ { name: 'LocalRate', formula: '0.2', local: true },
+ ]);
+ const before = doc.version().encode();
+ expect(() =>
+ importSpreadsheetSheets(
+ doc,
+ [
+ {
+ name: 'Extra',
+ cells: {},
+ rowCount: 200,
+ columnWidths: {},
+ metadata: {
+ definedNames: [{ name: 'globalrate', formula: '0.3' }],
+ },
+ },
+ ],
+ false
+ )
+ ).toThrow(/name/i);
+ expect(doc.version().encode()).toEqual(before);
+ } finally {
+ doc.free();
+ }
+});
diff --git a/apps/web/src/features/block-spreadsheet/core/workbook-file-types.ts b/apps/web/src/features/block-spreadsheet/core/workbook-file-types.ts
index 338c812375..b66901caf9 100644
--- a/apps/web/src/features/block-spreadsheet/core/workbook-file-types.ts
+++ b/apps/web/src/features/block-spreadsheet/core/workbook-file-types.ts
@@ -1,3 +1,4 @@
+import type { WorkbookSheetMetadata } from '@macro-inc/spreadsheet/workbook-metadata';
import type { SpreadsheetCalculation } from './calculation';
import type { SpreadsheetCells } from './spreadsheet-document';
@@ -13,6 +14,7 @@ export type WorkbookFileSheet = {
rowCount: number;
columnWidths: Record<number, number>;
values?: SpreadsheetCalculation;
+ metadata?: WorkbookSheetMetadata;
};
export type WorkbookFileData = {
sheets: WorkbookFileSheet[];
diff --git a/apps/web/src/features/block-spreadsheet/core/workbook-structure.test.ts b/apps/web/src/features/block-spreadsheet/core/workbook-structure.test.ts
new file mode 100644
index 0000000000..8936b7a447
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/workbook-structure.test.ts
@@ -0,0 +1,154 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { initSync } from '@ironcalc/wasm';
+import { changeWorkbookAxis } from '@macro-inc/spreadsheet/workbook-structure';
+import { beforeAll, describe, expect, it } from 'vitest';
+import type { SpreadsheetWorkbookSheet } from './workbook-document';
+
+beforeAll(() =>
+ initSync({
+ module: readFileSync(
+ createRequire(import.meta.url).resolve('@ironcalc/wasm/wasm_bg.wasm')
+ ),
+ })
+);
+const workbook = (): SpreadsheetWorkbookSheet[] => [
+ {
+ id: 'one',
+ name: 'Inputs',
+ cells: {
+ A1: { value: '10', bold: true },
+ A2: { value: '20' },
+ B2: { value: '=SUM($A$1:A2)' },
+ C1: { value: '=A1', format: 'text' },
+ },
+ layout: { rowCount: 200, columnWidths: { 0: 180, 1: 90 } },
+ metadata: {
+ hiddenRows: [1],
+ hiddenColumns: [1],
+ rowHeights: { 1: 30 },
+ merges: ['C3:D3'],
+ autoFilter: 'A1:B3',
+ freeze: { rows: 1, columns: 1 },
+ definedNames: [{ name: 'Revenue', formula: 'Inputs!$A$1:$A$2' }],
+ },
+ },
+ {
+ id: 'two',
+ name: 'Model',
+ cells: { A1: { value: '=Inputs!A2+Inputs!$A$1' }, A2: { value: '="A2"' } },
+ layout: { rowCount: 200, columnWidths: {} },
+ },
+];
+describe('row and column structure', () => {
+ it('inserts rows with absolute, relative, cross-sheet and named references, retaining styles and layout', () => {
+ const before = workbook();
+ const next = changeWorkbookAxis(before, {
+ sheetId: 'one',
+ axis: 'row',
+ index: 0,
+ count: 2,
+ kind: 'insert',
+ });
+ expect(next[0].cells.A3).toEqual({ value: '10', bold: true });
+ expect(next[0].cells.B4.value).toBe('=SUM($A$3:A4)');
+ expect(next[0].cells.C3).toEqual({ value: '=A1', format: 'text' });
+ expect(next[1].cells.A1.value).toBe('=Inputs!A4+Inputs!$A$3');
+ expect(next[1].cells.A2.value).toBe('="A2"');
+ expect(next[0].metadata).toMatchObject({
+ hiddenRows: [3],
+ rowHeights: { 3: 30 },
+ merges: ['C5:D5'],
+ autoFilter: 'A3:B5',
+ freeze: { rows: 3, columns: 1 },
+ });
+ expect(next[0].metadata?.definedNames?.[0].formula).toContain('$A$3:$A$4');
+ expect(before[0].cells.A1.value).toBe('10');
+ });
+ it('shrinks a partly deleted formula range and keeps an unfrozen axis unfrozen', () => {
+ const sheets = workbook();
+ sheets[0].cells.B3 = { value: '=SUM($A$1:A2)' };
+ sheets[0].metadata!.freeze = { rows: 0, columns: 1 };
+ const inserted = changeWorkbookAxis(sheets, {
+ sheetId: 'one',
+ axis: 'row',
+ index: 0,
+ count: 1,
+ kind: 'insert',
+ });
+ expect(inserted[0].metadata?.freeze).toEqual({ rows: 0, columns: 1 });
+ const removed = changeWorkbookAxis(sheets, {
+ sheetId: 'one',
+ axis: 'row',
+ index: 0,
+ count: 1,
+ kind: 'delete',
+ });
+ expect(removed[0].cells.B2.value).toBe('=SUM($A$1:A1)');
+ });
+ it('deletes referenced columns as #REF and moves column widths, hidden state and remaining cells', () => {
+ const next = changeWorkbookAxis(workbook(), {
+ sheetId: 'one',
+ axis: 'column',
+ index: 0,
+ count: 1,
+ kind: 'delete',
+ });
+ expect(next[0].cells.A2.value).toContain('#REF!');
+ expect(next[1].cells.A1.value).toContain('#REF!');
+ expect(next[0].cells.B1.value).toBe('=A1');
+ expect(next[0].layout.columnWidths).toEqual({ 0: 90 });
+ expect(next[0].metadata?.hiddenColumns).toEqual([0]);
+ expect(next[0].metadata?.merges).toEqual(['B3:C3']);
+ });
+ it('refuses to push occupied trailing cells beyond limits without modifying input', () => {
+ const sheets = workbook();
+ sheets[0].cells.Z1 = { value: 'Keep me' };
+ const before = JSON.stringify(sheets);
+ expect(() =>
+ changeWorkbookAxis(sheets, {
+ sheetId: 'one',
+ axis: 'column',
+ index: 0,
+ count: 1,
+ kind: 'insert',
+ })
+ ).toThrow('push cells');
+ expect(JSON.stringify(sheets)).toBe(before);
+ });
+ it('shrinks overlapping ranges and removes wholly deleted merges', () => {
+ const sheets = workbook();
+ sheets[0].metadata = { merges: ['A2:B3', 'C5:D7'], hiddenRows: [1, 2, 6] };
+ const next = changeWorkbookAxis(sheets, {
+ sheetId: 'one',
+ axis: 'row',
+ index: 1,
+ count: 3,
+ kind: 'delete',
+ });
+ expect(next[0].metadata?.merges).toEqual(['C2:D4']);
+ expect(next[0].metadata?.hiddenRows).toEqual([3]);
+ });
+});
+
+it.each([
+ ['row', '=SUM(1:2)', '=SUM(1:1)'],
+ ['row', '=SUM(A:A)', '=SUM(A:A)'],
+ ['column', '=SUM(A:B)', '=SUM(A:A)'],
+ ['column', '=SUM(1:1)', '=SUM(1:1)'],
+] as const)(
+ 'preserves whole-axis syntax on %s deletion: %s',
+ (axis, formula, expected) => {
+ const sheets = workbook();
+ sheets[0].cells = { C3: { value: formula } };
+ sheets[0].metadata = undefined;
+ const next = changeWorkbookAxis(sheets, {
+ sheetId: 'one',
+ axis,
+ index: 0,
+ count: 1,
+ kind: 'delete',
+ });
+ expect(next[0].cells[axis === 'row' ? 'C2' : 'B3'].value).toBe(expected);
+ }
+);
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-archive.ts b/apps/web/src/features/block-spreadsheet/core/xlsx-archive.ts
index 6c6793c448..2ef8422898 100644
--- a/apps/web/src/features/block-spreadsheet/core/xlsx-archive.ts
+++ b/apps/web/src/features/block-spreadsheet/core/xlsx-archive.ts
@@ -161,10 +161,6 @@ export function xlsxFeatureWarnings(
if (!name.endsWith('.xml')) continue;
const text = strFromU8(bytes);
if (/<!DOCTYPE|<!ENTITY/i.test(text)) throw invalid();
- if (/<(?:\w+:)?definedName[\s>]/.test(text))
- warnings.add(
- 'Named ranges are not imported; formulas using names may show errors.'
- );
if (/<(?:\w+:)?conditionalFormatting[\s>]/.test(text))
warnings.add('Conditional formatting rules are not imported.');
if (/<(?:\w+:)?dataValidation[\s>]/.test(text))
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-codec.test.ts b/apps/web/src/features/block-spreadsheet/core/xlsx-codec.test.ts
index dd4e58d6e8..fd555079a3 100644
--- a/apps/web/src/features/block-spreadsheet/core/xlsx-codec.test.ts
+++ b/apps/web/src/features/block-spreadsheet/core/xlsx-codec.test.ts
@@ -1,6 +1,7 @@
import { readFileSync } from 'node:fs';
import { createRequire } from 'node:module';
import { initSync } from '@ironcalc/wasm';
+import { encodeCellMention } from '@macro-inc/spreadsheet/cell-mentions';
import ExcelJS from 'exceljs';
import { strFromU8, strToU8, unzipSync, zipSync } from 'fflate';
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
@@ -50,6 +51,25 @@ function simpleSheet(): WorkbookFileSheet {
}
describe('Excel workbook files', () => {
+ it('exports mention labels as literal Excel text with an explicit warning', async () => {
+ const sheet = simpleSheet();
+ sheet.cells.A1 = {
+ value: encodeCellMention({
+ type: 'document',
+ documentId: 'document',
+ documentName: '=1+1',
+ blockName: 'md',
+ }),
+ };
+ const result = await encodeXlsx({ sheets: [sheet] });
+ expect(result.warnings.join(' ')).toContain('mention');
+ const workbook = new ExcelJS.Workbook();
+ await workbook.xlsx.load(result.bytes.slice().buffer);
+ expect(workbook.worksheets[0].getCell('A1').value).toBe('=1+1');
+ expect(workbook.worksheets[0].getCell('A1').type).toBe(
+ ExcelJS.ValueType.String
+ );
+ });
it('round trips real XLSX with multiple sheets, formula caches, values, styles and widths', async () => {
const sheets: WorkbookFileSheet[] = [
{
@@ -357,15 +377,12 @@ describe('Excel workbook files', () => {
for (const term of [
'Charts',
'External workbook',
- 'Named ranges',
'validation',
'Hidden sheets',
- 'Merged cells',
+ 'Merged ranges',
'Frozen panes',
- 'row heights',
'Hyperlinks',
'Rich text',
- 'error cells',
'comments',
])
expect(warning).toContain(term);
@@ -550,7 +567,9 @@ describe('Excel workbook files', () => {
const result = await decodeXlsx(zipSync(entries));
expect(result.sheets[0].cells.A1.value).toBe('42');
expect(result.warnings.join(' ')).toContain('Data validation');
- expect(result.warnings.join(' ')).toContain('Named ranges');
+ expect(result.sheets[0].metadata?.definedNames).toEqual([
+ { name: 'WholeSheet', formula: "'Sheet 1'!$A$1:$XFD$1048576" },
+ ]);
expect(load).toHaveBeenCalledOnce();
} finally {
load.mockRestore();
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-codec.ts b/apps/web/src/features/block-spreadsheet/core/xlsx-codec.ts
index cdce99402c..deecb505bc 100644
--- a/apps/web/src/features/block-spreadsheet/core/xlsx-codec.ts
+++ b/apps/web/src/features/block-spreadsheet/core/xlsx-codec.ts
@@ -1,6 +1,12 @@
+import { cellPlainText } from '@macro-inc/spreadsheet/cell-mentions';
+import {
+ parseWorkbookMetadata,
+ type WorkbookSheetMetadata,
+} from '@macro-inc/spreadsheet/workbook-metadata';
import type { Cell, CellValue, Workbook, Worksheet } from 'exceljs';
import { strFromU8, strToU8, zipSync } from 'fflate';
import { SaxesParser } from 'saxes';
+import type { CalculatedCell } from './calculation';
import {
formatCellAddress,
isSpreadsheetCellStyle,
@@ -24,6 +30,11 @@ import {
} from './workbook-file-types';
import { inspectXlsxArchive, xlsxFeatureWarnings } from './xlsx-archive';
import { readXlsxStyle, readXlsxTheme, writeXlsxStyle } from './xlsx-styles';
+import {
+ escapeXml,
+ normalizeSpreadsheetXml,
+ originalDateSerials,
+} from './xlsx-xml';
async function newWorkbook(): Promise<Workbook> {
const excel = await import('exceljs');
@@ -35,13 +46,17 @@ function boundedSheet(name: string, row: number, column: number) {
`“${name}” exceeds the supported 1,000 rows or 26 columns. No sheets were imported.`
);
}
-function readCellValue(cell: Cell, warnings: Set<string>): string {
+function readCellValue(
+ cell: Cell,
+ warnings: Set<string>,
+ dateSerial?: number
+): string {
const value = cell.value;
if (value === null || value === undefined) return '';
if (typeof value === 'number') return String(value);
if (typeof value === 'boolean') return value ? 'TRUE' : 'FALSE';
if (value instanceof Date)
- return String(value.getTime() / 86_400_000 + 25569);
+ return String(dateSerial ?? value.getTime() / 86_400_000 + 25569);
if (typeof value === 'string') {
// Preserve the stored string type even if it resembles a number/formula/date.
return cell.numFmt === '@' ? value : `'${value}`;
@@ -62,8 +77,21 @@ function readCellValue(cell: Cell, warnings: Set<string>): string {
);
return cell.numFmt === '@' ? value.text : `'${value.text}`;
}
- warnings.add('Stored error cells are imported as literal error text.');
- return `'${value.error}`;
+ if (
+ ![
+ '#DIV/0!',
+ '#N/A',
+ '#NAME?',
+ '#NULL!',
+ '#NUM!',
+ '#REF!',
+ '#VALUE!',
+ ].includes(value.error)
+ )
+ throw new Error(
+ `Stored Excel error ${value.error} at ${cell.address} cannot be preserved yet. Resolve it in Excel before importing. No sheets were imported.`
+ );
+ return value.error;
}
// These functions natively return dynamic arrays. Traditional CSE formulas can
// require implicit intersection, repetition or fixed-size truncation, none of
@@ -160,40 +188,67 @@ function stringLikeValue(value: CellValue): boolean {
function readSheet(
sheet: Worksheet,
theme: (string | undefined)[],
- warnings: Set<string>
+ warnings: Set<string>,
+ dateSerials?: { numbers: Map<string, number>; offset: number }
): WorkbookFileSheet {
boundedSheet(sheet.name, sheet.rowCount, sheet.columnCount);
const cells: SpreadsheetCells = {};
const arrayChildren = arrayFormulaChildren(sheet, warnings);
+ const metadata: WorkbookSheetMetadata = {};
+ if (sheet.model.merges?.length) metadata.merges = [...sheet.model.merges];
+ if (sheet.state !== 'visible') metadata.hidden = true;
+ const frozen = sheet.views?.find((view) => view.state === 'frozen');
+ if (frozen?.state === 'frozen')
+ metadata.freeze = { rows: frozen.ySplit ?? 0, columns: frozen.xSplit ?? 0 };
+ if (typeof sheet.autoFilter === 'string')
+ metadata.autoFilter = sheet.autoFilter.replaceAll('$', '');
if (sheet.state !== 'visible')
- warnings.add('Hidden sheets are imported as visible tabs.');
+ warnings.add(
+ 'Hidden sheets are shown in Macro; their visibility is retained in Excel downloads.'
+ );
if (sheet.model.merges?.length)
warnings.add(
- 'Merged cells are unmerged; their value stays in the top-left cell.'
+ 'Merged ranges are shown as individual cells in Macro and restored on Excel export when their covered cells remain empty.'
);
if (
(sheet.views ?? []).some(
(view) => view.state === 'frozen' || view.state === 'split'
)
)
- warnings.add('Frozen panes and split views are not imported.');
+ warnings.add(
+ 'Frozen panes are retained for Excel export; Macro uses its own scrolling view.'
+ );
if (sheet.autoFilter)
- warnings.add('Excel filters are not imported; all rows remain visible.');
+ warnings.add(
+ 'Excel filters are retained for export; Macro displays all rows.'
+ );
sheet.eachRow({ includeEmpty: true }, (row) => {
- if (row.height !== undefined)
- warnings.add('Custom row heights are reset to the editor’s row sizes.');
- if (row.hidden)
- warnings.add('Hidden rows and columns are imported as visible.');
+ if (row.height !== undefined) {
+ metadata.rowHeights ??= {};
+ metadata.rowHeights[row.number - 1] = row.height;
+ }
+ if (row.hidden) {
+ metadata.hiddenRows ??= [];
+ metadata.hiddenRows.push(row.number - 1);
+ }
row.eachCell({ includeEmpty: true }, (cell) => {
if (cell.isMerged && cell.master.address !== cell.address) return;
+ const style = readXlsxStyle(cell, theme, warnings);
+ const serial = dateSerials?.numbers.get(cell.address);
+ const calendarDate =
+ style.format === 'date' ||
+ !/[hs]/i.test((cell.numFmt ?? '').replace(/"[^"]*"|\\./g, ''));
+ const dateValue =
+ serial === undefined
+ ? undefined
+ : serial + (calendarDate ? (dateSerials?.offset ?? 0) : 0);
const value = arrayChildren.has(cell.address)
? ''
- : readCellValue(cell, warnings);
+ : readCellValue(cell, warnings, dateValue);
if (value.length > SPREADSHEET_MAX_CELL_LENGTH)
throw new Error(
`Cell ${sheet.name}!${cell.address} exceeds 10,000 characters. No sheets were imported.`
);
- const style = readXlsxStyle(cell, theme, warnings);
if (
style.format === 'text' &&
cell.value !== null &&
@@ -214,8 +269,10 @@ function readSheet(
const columnWidths: Record<number, number> = {};
for (let index = 1; index <= SPREADSHEET_COLUMNS; index++) {
const column = sheet.getColumn(index);
- if (column.hidden)
- warnings.add('Hidden rows and columns are imported as visible.');
+ if (column.hidden) {
+ metadata.hiddenColumns ??= [];
+ metadata.hiddenColumns.push(index - 1);
+ }
if (column.width !== undefined) {
const pixels = Math.round(column.width * 7 + 5);
columnWidths[index - 1] = Math.max(
@@ -228,6 +285,7 @@ function readSheet(
}
return {
name: sheet.name,
+ metadata,
cells,
rowCount: Math.max(SPREADSHEET_ROWS, sheet.rowCount),
columnWidths,
@@ -353,6 +411,40 @@ function prepareWorkbookXml(name: string, text: string, worksheet: boolean) {
export async function decodeXlsx(bytes: Uint8Array): Promise<WorkbookFileData> {
const archive = inspectXlsxArchive(bytes);
const warnings = new Set(xlsxFeatureWarnings(archive.files));
+ for (const [name, bytes] of Object.entries(archive.files))
+ if (name.endsWith('.xml') || name.endsWith('.rels'))
+ archive.files[name] = strToU8(
+ normalizeSpreadsheetXml(strFromU8(bytes), name)
+ );
+ const dates = originalDateSerials(archive.files);
+ const names: { name: string; formula: string; sheet?: number }[] = [];
+ const nameParser = new SaxesParser();
+ let current: (typeof names)[number] | undefined;
+ nameParser.on('opentag', (node) => {
+ if (node.name.split(':').at(-1) === 'definedName') {
+ const name = node.attributes.name;
+ if (!name || name.startsWith('_xlnm.')) return;
+ current = {
+ name,
+ formula: '',
+ ...(node.attributes.localSheetId !== undefined && {
+ sheet: Number(node.attributes.localSheetId),
+ }),
+ };
+ }
+ });
+ nameParser.on('text', (text) => {
+ if (current) current.formula += text;
+ });
+ nameParser.on('closetag', (node) => {
+ if (node.name.split(':').at(-1) === 'definedName' && current) {
+ names.push(current);
+ current = undefined;
+ }
+ });
+ nameParser.write(strFromU8(archive.files['xl/workbook.xml'])).close();
+ if (names.length > 256)
+ throw new Error('Import up to 256 Excel name definitions.');
// ExcelJS uses an unanchored worksheet-path match. Reject aliases it would
// parse outside the canonical entries covered by the preflight checks below.
for (const name of Object.keys(archive.files))
@@ -385,9 +477,10 @@ export async function decodeXlsx(bytes: Uint8Array): Promise<WorkbookFileData> {
await workbook.xlsx.load(
zipSync(archive.files, { level: 0 }).slice().buffer
);
- } catch {
+ } catch (cause) {
throw new Error(
- 'This Excel workbook could not be read. Choose an unencrypted .xlsx file.'
+ 'This Excel workbook could not be read. Choose an unencrypted .xlsx file.',
+ { cause }
);
}
if (
@@ -396,32 +489,78 @@ export async function decodeXlsx(bytes: Uint8Array): Promise<WorkbookFileData> {
)
throw new Error('Import a workbook with 1–10 sheets.');
const theme = readXlsxTheme(archive.files);
+ const sheets = workbook.worksheets.map((sheet, index) =>
+ readSheet(sheet, theme, warnings, dates[index])
+ );
+ for (const entry of names) {
+ const target = sheets[entry.sheet ?? 0];
+ if (!target) throw new Error('An Excel name refers to a missing sheet.');
+ target.metadata ??= {};
+ target.metadata.definedNames ??= [];
+ target.metadata.definedNames.push({
+ name: entry.name,
+ formula: entry.formula,
+ ...(entry.sheet !== undefined && { local: true }),
+ });
+ }
+ for (const sheet of sheets)
+ if (!parseWorkbookMetadata(JSON.stringify(sheet.metadata)))
+ throw new Error('Unsupported Excel layout or name definitions.');
return {
- sheets: workbook.worksheets.map((sheet) =>
- readSheet(sheet, theme, warnings)
- ),
+ sheets,
warnings: [...warnings],
};
}
function exportValue(
cell: SpreadsheetCell,
- calculated?: { display: string; number?: number; error?: string }
+ calculated?: CalculatedCell
): CellValue {
+ if (cellPlainText(cell.value) !== cell.value)
+ return cellPlainText(cell.value);
if (cell.format === 'text') return cell.value;
if (cell.value.startsWith('='))
return {
formula: cell.value.slice(1),
...(calculated &&
!calculated.error && {
- result: calculated.number ?? calculated.display,
+ result:
+ calculated.type === 'boolean'
+ ? (calculated.value as boolean)
+ : (calculated.number ?? calculated.display),
}),
};
if (cell.value.startsWith("'")) return cell.value.slice(1);
if (/^(?:true|false)$/i.test(cell.value))
return cell.value.toUpperCase() === 'TRUE';
- if (calculated?.number !== undefined) return calculated.number;
if (/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(cell.value.trim()))
return Number(cell.value);
+ if (
+ cell.value === '#DIV/0!' ||
+ cell.value === '#N/A' ||
+ cell.value === '#NAME?' ||
+ cell.value === '#NULL!' ||
+ cell.value === '#NUM!' ||
+ cell.value === '#REF!' ||
+ cell.value === '#VALUE!'
+ )
+ return { error: cell.value };
+ if (
+ [
+ '#SPILL!',
+ '#CALC!',
+ '#CIRC!',
+ '#ERROR!',
+ '#GETTING_DATA',
+ '#CONNECT!',
+ '#BLOCKED!',
+ '#FIELD!',
+ '#UNKNOWN!',
+ ].includes(cell.value)
+ )
+ throw new Error(
+ `Stored error ${cell.value} cannot be exported as an Excel value. Use a formula or literal text instead.`
+ );
+ if (calculated?.number !== undefined) return calculated.number;
return cell.value || null;
}
@@ -474,7 +613,32 @@ export async function encodeXlsx(
warnings.add(
'Extra blank rows beyond the used range are not preserved when importing this Excel file back into Macro.'
);
+ if (
+ source.metadata &&
+ !parseWorkbookMetadata(JSON.stringify(source.metadata))
+ )
+ throw new Error('Invalid workbook metadata.');
const sheet = workbook.addWorksheet(source.name);
+ const metadata = source.metadata;
+ if (metadata?.hidden) sheet.state = 'hidden';
+ if (metadata?.freeze)
+ sheet.views = [
+ {
+ state: 'frozen',
+ xSplit: metadata.freeze.columns,
+ ySplit: metadata.freeze.rows,
+ },
+ ];
+ if (metadata?.autoFilter) sheet.autoFilter = metadata.autoFilter;
+ for (const [row, height] of Object.entries(metadata?.rowHeights ?? {}))
+ sheet.getRow(Number(row) + 1).height = height;
+ for (const row of metadata?.hiddenRows ?? []) {
+ sheet.getRow(row + 1).hidden = true;
+ // ExcelJS drops completely empty rows, including their hidden flag.
+ sheet.getRow(row + 1).getCell(1);
+ }
+ for (const column of metadata?.hiddenColumns ?? [])
+ sheet.getColumn(column + 1).hidden = true;
for (const [address, cell] of Object.entries(source.cells)) {
if (!parseCellAddress(address))
throw new Error(`Unsupported cell address ${source.name}!${address}.`);
@@ -484,6 +648,10 @@ export async function encodeXlsx(
);
const target = sheet.getCell(address);
target.value = exportValue(cell, source.values?.[address]);
+ if (cellPlainText(cell.value) !== cell.value)
+ warnings.add(
+ 'Macro mentions are exported as their display text; interactive pills remain in Macro.'
+ );
target.style = writeXlsxStyle(cell);
}
for (const [column, pixels] of Object.entries(source.columnWidths)) {
@@ -497,7 +665,48 @@ export async function encodeXlsx(
sheet.getColumn(index + 1).width = Math.max(1, (pixels - 5) / 7);
}
}
- const bytes = new Uint8Array(await workbook.xlsx.writeBuffer());
+ // ExcelJS may destroy values when merging; never merge over a later user edit.
+ for (const [index, source] of input.sheets.entries()) {
+ const sheet = workbook.worksheets[index];
+ for (const range of source.metadata?.merges ?? []) {
+ const [a, b = a] = range.split(':');
+ const first = parseCellAddress(a)!;
+ const last = parseCellAddress(b)!;
+ let occupied = false;
+ for (let r = first.row; r <= last.row; r++)
+ for (let c = first.column; c <= last.column; c++) {
+ if (
+ (r !== first.row || c !== first.column) &&
+ source.cells[formatCellAddress(r, c)]?.value
+ )
+ occupied = true;
+ }
+ if (occupied)
+ warnings.add(
+ `Merge ${source.name}!${range} was omitted to preserve values entered in its covered cells.`
+ );
+ else sheet.mergeCellsWithoutStyle(range);
+ }
+ }
+ // ExcelJS expands defined names into a cell matrix. Write OOXML directly so
+ // whole-column names remain small and local scopes/formula names survive.
+ const files = inspectXlsxArchive(
+ new Uint8Array(await workbook.xlsx.writeBuffer())
+ ).files;
+ const definitions = input.sheets.flatMap((sheet, index) =>
+ (sheet.metadata?.definedNames ?? []).map(
+ (entry) =>
+ `<definedName name="${escapeXml(entry.name)}"${entry.local ? ` localSheetId="${index}"` : ''}>${escapeXml(entry.formula)}</definedName>`
+ )
+ );
+ if (definitions.length)
+ files['xl/workbook.xml'] = strToU8(
+ strFromU8(files['xl/workbook.xml']).replace(
+ '</workbook>',
+ `<definedNames>${definitions.join('')}</definedNames></workbook>`
+ )
+ );
+ const bytes = zipSync(files);
if (bytes.length > XLSX_MAX_BYTES)
throw new Error(
'The exported workbook exceeds the 5 MB file limit. Export a smaller workbook.'
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-financial.test.ts b/apps/web/src/features/block-spreadsheet/core/xlsx-financial.test.ts
new file mode 100644
index 0000000000..dbe4816a96
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/xlsx-financial.test.ts
@@ -0,0 +1,288 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { initSync } from '@ironcalc/wasm';
+import { createInitializedSpreadsheetCalculator } from '@macro-inc/spreadsheet/calculation';
+import {
+ importSpreadsheetSheets,
+ readSpreadsheetWorkbook,
+} from '@macro-inc/spreadsheet/workbook-document';
+import ExcelJS from 'exceljs';
+import { strFromU8, unzipSync } from 'fflate';
+import { LoroDoc } from 'loro-crdt';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { writeSpreadsheetCells } from './spreadsheet-document';
+import { decodeXlsx, encodeXlsx } from './xlsx-codec';
+
+beforeAll(() =>
+ initSync({
+ module: readFileSync(
+ createRequire(import.meta.url).resolve('@ironcalc/wasm/wasm_bg.wasm')
+ ),
+ })
+);
+const fixture = (name: string) =>
+ new Uint8Array(
+ readFileSync(
+ createRequire(import.meta.url).resolve(`./xlsx-fixtures/${name}.xlsx`)
+ )
+ );
+
+describe('independent financial workbook regression', () => {
+ it('imports valid namespace prefixes, absolute package references and table relationships', async () => {
+ const imported = await decodeXlsx(fixture('namespaced-table'));
+ expect(imported.sheets[0].cells.A2.value).toBe("'Sample A");
+ expect(imported.sheets[0].cells.B2.value).toBe('42');
+ expect(imported.sheets[0].cells.D1.value).toBe('=SUM(B2:B3)');
+ const engine = createInitializedSpreadsheetCalculator();
+ try {
+ expect(engine.calculate(imported.sheets[0].cells).D1.number).toBe(100);
+ } finally {
+ engine.dispose();
+ }
+ });
+
+ it('keeps financial formulas, names, precision, number formats and layout through native persistence and XLSX export', async () => {
+ const imported = await decodeXlsx(fixture('financial-model'));
+ const doc = new LoroDoc();
+ const reopened = new LoroDoc();
+ const engine = createInitializedSpreadsheetCalculator();
+ try {
+ importSpreadsheetSheets(doc, imported.sheets, true);
+ reopened.import(doc.export({ mode: 'snapshot' }));
+ const sheets = readSpreadsheetWorkbook(reopened);
+ expect(sheets.map((s) => s.name)).toEqual(['Assumptions', 'DCF model']);
+ const results = engine.calculateWorkbook(
+ sheets.map((s) => ({ ...s, rowCount: s.layout.rowCount })),
+ { includeTypes: true }
+ );
+ const values = results[sheets[1].id];
+ expect(Object.entries(values).filter(([, value]) => value.error)).toEqual(
+ []
+ );
+ expect(values.B4.number).toBeCloseTo(
+ 100 / 1.1 + 120 / 1.1 ** 2 + 140 / 1.1 ** 3 - 100,
+ 10
+ );
+ expect(values.B5.number).toBeCloseTo(0.1, 10);
+ expect(values.B8.number).toBeCloseTo(0.1, 8);
+ expect(values.B9.number).toBeCloseTo(-1498.876312881892, 7);
+ expect(values.B10.number).toBe(360);
+ expect(values.C10.number).toBe(36);
+ expect(values.B11.number).toBe(260);
+ expect(values.B12.number).toBe(120);
+ expect(values.B13.number).toBe(0);
+ expect(values.B14.number).toBe(25);
+ expect(values.C16.number).toBe(1);
+ expect(values.A16.display).toBe('0000123');
+ expect(values.B18.display).toBe('(1,250,000.13)');
+ expect(values.B19.display).toBe('—');
+ expect(values.B20.display).toBe('1.3m');
+ expect(values.B21.display).toBe('1.3x');
+ expect(values.B22.display).toBe('12.50%');
+ expect(values.B23.display).toBe('36:00');
+ expect(sheets[1].cells.B24.value).toBe('60');
+ expect(values.B24.display).toBe('02/29/1900');
+ // A value edit and formatting edit must survive export without destroying import metadata.
+ writeSpreadsheetCells(
+ reopened,
+ { B18: { bold: true, value: '-2500000.125' } },
+ sheets[1].id
+ );
+ const edited = readSpreadsheetWorkbook(reopened);
+ const exported = await encodeXlsx({
+ sheets: edited.map((s) => ({
+ ...s,
+ ...s.layout,
+ values: results[s.id],
+ })),
+ });
+ const external = new ExcelJS.Workbook();
+ await external.xlsx.load(exported.bytes.slice().buffer);
+ const dcf = external.getWorksheet('DCF model')!;
+ expect(dcf.getCell('B4').formula).toBe('NPV(DiscountRate,C3:E3)+B3');
+ expect(dcf.getCell('B14').formula).toBe('TaxRate*100');
+ expect(dcf.getCell('B18').value).toBe(-2500000.125);
+ expect(dcf.getCell('B18').numFmt).toBe('#,##0.00;[Red](#,##0.00);"—"');
+ expect(dcf.getCell('B18').font).toMatchObject({
+ name: 'Calibri',
+ color: { argb: 'FF0000FF' },
+ bold: true,
+ });
+ expect(dcf.getCell('B18').border.bottom).toMatchObject({
+ style: 'double',
+ color: { argb: 'FF123456' },
+ });
+ expect(dcf.getCell('A1').isMerged).toBe(true);
+ expect(dcf.getRow(1).height).toBe(32);
+ expect(dcf.getRow(6).hidden).toBe(true);
+ expect(dcf.getColumn('F').hidden).toBe(true);
+ expect(dcf.views[0]).toMatchObject({
+ state: 'frozen',
+ xSplit: 1,
+ ySplit: 3,
+ });
+ expect(dcf.autoFilter).toBe('A2:E3');
+ expect(external.getWorksheet('Assumptions')!.state).toBe('hidden');
+ const xml = strFromU8(unzipSync(exported.bytes)['xl/workbook.xml']);
+ expect(xml).toContain('name="TaxRate" localSheetId="1"');
+ const again = await decodeXlsx(exported.bytes);
+ for (let index = 0; index < edited.length; index++) {
+ expect(again.sheets[index].metadata).toEqual(edited[index].metadata);
+ for (const [address, cell] of Object.entries(edited[index].cells)) {
+ expect(again.sheets[index].cells[address]).toMatchObject(cell);
+ }
+ }
+ } finally {
+ engine.dispose();
+ reopened.free();
+ doc.free();
+ }
+ });
+
+ it('does not merge away values added inside an imported merged range', async () => {
+ const imported = await decodeXlsx(fixture('financial-model'));
+ imported.sheets[1].cells.B1 = { value: '42' };
+ const exported = await encodeXlsx(imported);
+ expect(exported.warnings.join(' ')).toContain('omitted to preserve values');
+ const result = await decodeXlsx(exported.bytes);
+ expect(result.sheets[1].cells.B1.value).toBe('42');
+ expect(result.sheets[1].metadata?.merges).toBeUndefined();
+ });
+});
+
+it('preserves 1904 calendar dates without shifting times or elapsed durations', async () => {
+ const excel = new ExcelJS.Workbook();
+ excel.properties.date1904 = true;
+ const sheet = excel.addWorksheet('Dates');
+ for (const [address, value, format] of [
+ ['A1', 0.5, '[h]:mm'],
+ ['A2', 0.5, 'hh:mm:ss'],
+ ['A3', 40000, 'mm/dd/yyyy'],
+ ] as const) {
+ sheet.getCell(address).value = value;
+ sheet.getCell(address).numFmt = format;
+ }
+ sheet.getCell('B1').value = { formula: 'A1*24' };
+ const input = await decodeXlsx(
+ new Uint8Array(await excel.xlsx.writeBuffer())
+ );
+ expect(input.sheets[0].cells.A1.value).toBe('0.5');
+ expect(input.sheets[0].cells.A2.value).toBe('0.5');
+ expect(input.sheets[0].cells.A3.value).toBe('41462');
+ const engine = createInitializedSpreadsheetCalculator();
+ try {
+ const values = engine.calculate(input.sheets[0].cells);
+ expect(values.B1.number).toBe(12);
+ expect(values.A1.display).toBe('12:00');
+ const exported = await encodeXlsx(input);
+ expect((await decodeXlsx(exported.bytes)).sheets[0].cells).toEqual(
+ input.sheets[0].cells
+ );
+ } finally {
+ engine.dispose();
+ }
+});
+
+it('preserves stored errors, IFERROR and error propagation through native and Excel round trips', async () => {
+ const excel = new ExcelJS.Workbook();
+ const sheet = excel.addWorksheet('Errors');
+ sheet.getCell('A1').value = { error: '#DIV/0!' };
+ sheet.getCell('A2').value = '#DIV/0!';
+ sheet.getCell('B1').value = { formula: 'IFERROR(A1,0)' };
+ sheet.getCell('C1').value = { formula: 'SUM(A1,1)' };
+ const imported = await decodeXlsx(
+ new Uint8Array(await excel.xlsx.writeBuffer())
+ );
+ const doc = new LoroDoc();
+ const reopened = new LoroDoc();
+ const engine = createInitializedSpreadsheetCalculator();
+ try {
+ importSpreadsheetSheets(doc, imported.sheets, true);
+ reopened.import(doc.export({ mode: 'snapshot' }));
+ const native = readSpreadsheetWorkbook(reopened)[0];
+ const values = engine.calculate(native.cells);
+ expect(values.A1.display).toBe('#DIV/0!');
+ expect(values.A1.error).toBeDefined();
+ expect(values.A2.error).toBeUndefined();
+ expect(values.B1.number).toBe(0);
+ expect(values.C1.display).toBe('#DIV/0!');
+ const exported = await encodeXlsx({
+ sheets: [{ ...native, ...native.layout, values }],
+ });
+ const external = new ExcelJS.Workbook();
+ await external.xlsx.load(exported.bytes.slice().buffer);
+ expect(external.worksheets[0].getCell('A1').value).toEqual({
+ error: '#DIV/0!',
+ });
+ expect(external.worksheets[0].getCell('A2').value).toBe('#DIV/0!');
+ expect((await decodeXlsx(exported.bytes)).sheets[0].cells).toEqual(
+ native.cells
+ );
+ } finally {
+ doc.free();
+ reopened.free();
+ engine.dispose();
+ }
+});
+
+it('isolates unsupported display formats and resolves qualified worksheet-local names', () => {
+ const engine = createInitializedSpreadsheetCalculator();
+ try {
+ const result = engine.calculateWorkbook([
+ {
+ id: 'a',
+ name: 'Inputs',
+ rowCount: 200,
+ cells: { A1: { value: '10' } },
+ metadata: {
+ definedNames: [{ name: 'Rate', formula: '0.2', local: true }],
+ },
+ },
+ {
+ id: 'b',
+ name: 'Tax assumptions',
+ rowCount: 200,
+ cells: { A1: { value: '5' } },
+ metadata: {
+ definedNames: [
+ { name: 'Rate', formula: "'Tax assumptions'!$A$1", local: true },
+ ],
+ },
+ },
+ {
+ id: 'c',
+ name: 'Output',
+ rowCount: 200,
+ cells: {
+ A1: { value: '40000', numberFormat: '[$-411]ge.m.d' },
+ B1: { value: '=Inputs!Rate*10' },
+ B2: { value: "='Tax assumptions'!Rate*10" },
+ B3: { value: '="Inputs!Rate"' },
+ },
+ },
+ ]);
+ expect(result.c.A1.number).toBe(40000);
+ expect(result.c.A1.warning).toContain('format');
+ expect(result.c.B1.number).toBe(2);
+ expect(result.c.B2.number).toBe(50);
+ expect(result.c.B3.display).toBe('Inputs!Rate');
+ } finally {
+ engine.dispose();
+ }
+});
+
+it.each(['#SPILL!', '#CALC!'])(
+ 'rejects unsupported stored %s errors rather than changing error propagation',
+ async (error) => {
+ const workbook = new ExcelJS.Workbook();
+ workbook.addWorksheet('Errors').getCell('A1').value = { error: '#N/A' };
+ const { unzipSync, zipSync, strToU8 } = await import('fflate');
+ const files = unzipSync(new Uint8Array(await workbook.xlsx.writeBuffer()));
+ files['xl/worksheets/sheet1.xml'] = strToU8(
+ strFromU8(files['xl/worksheets/sheet1.xml']).replace('#N/A', error)
+ );
+ await expect(decodeXlsx(zipSync(files))).rejects.toThrow(
+ `Stored Excel error ${error}`
+ );
+ }
+);
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/README.md b/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/README.md
new file mode 100644
index 0000000000..27ca1904ff
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/README.md
@@ -0,0 +1,9 @@
+# XLSX interoperability fixtures
+
+`financial-model.xlsx` and `namespaced-table.xlsx` are synthetic workbooks generated independently with openpyxl, not with Macro's ExcelJS exporter. Regenerate them with `python3 generate-financial.py` from this directory after installing openpyxl. No customer data is included.
+
+The financial fixture covers cross-sheet and absolute/mixed references, global and local names, NPV/IRR/XIRR/PMT, SUMIFS, INDEX/MATCH, IFERROR, precision, accounting negative/zero sections, scaling, multiples, percentages, elapsed time, Excel's 1900 leap-day compatibility, fonts/colors, double borders, merges, hidden rows/columns/sheets, row heights, filters, and frozen panes. Tests check independently specified results, native Loro save/reopen, value and style edits, and Excel import/export round trips.
+
+The namespaced fixture uses valid prefixed OOXML and absolute package relationship targets, including a table relationship. This catches ExcelJS parser assumptions that are not part of the Excel file format. Tables are intentionally represented as ordinary cells with an import warning.
+
+Additional generated-in-test workbooks exercise the 1904 date system, stored Excel errors and their propagation, unsupported formats, malformed/oversized archives, cancellation, quoted Unicode CSV, long identifiers, and formula-like CSV text. Browser tests exercise real worker import, calculation, editing, and exported download contents.
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/financial-model.xlsx b/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/financial-model.xlsx
new file mode 100644
index 0000000000..50e9c26ed4
Binary files /dev/null and b/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/financial-model.xlsx differ
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/generate-financial.py b/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/generate-financial.py
new file mode 100644
index 0000000000..122bb427f1
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/generate-financial.py
@@ -0,0 +1,95 @@
+"""Independent OOXML fixtures; no production/user data. Requires openpyxl.
+Run from the repo root with python3 <this file>.
+"""
+from pathlib import Path
+from datetime import datetime
+from zipfile import ZipFile, ZIP_DEFLATED
+import xml.etree.ElementTree as ET
+from openpyxl import Workbook
+from openpyxl.styles import Font, Border, Side, Alignment
+from openpyxl.workbook.defined_name import DefinedName
+from openpyxl.worksheet.table import Table, TableStyleInfo
+
+out = Path(__file__).parent
+w = Workbook()
+a = w.active
+a.title = 'Assumptions'
+a.append(['Rate', .1])
+a.append(['Principal', 250000])
+a.append(['First date', datetime(2026, 1, 1)])
+a.append(['Next date', datetime(2027, 1, 1)])
+a['B1'].number_format = '0.0%'
+a['B3'].number_format = a['B4'].number_format = 'yyyy-mm-dd'
+a.sheet_state = 'hidden'
+w.defined_names.add(DefinedName('DiscountRate', attr_text="Assumptions!$B$1"))
+b = w.create_sheet('DCF model')
+b['A1'] = 'Illustrative DCF — independent fixture'
+b.merge_cells('A1:F1')
+b.row_dimensions[1].height = 32
+b.freeze_panes = 'B4'
+b.row_dimensions[6].hidden = True
+b.column_dimensions['F'].hidden = True
+b.column_dimensions['A'].width = 28
+b.append(['Cash flow', 'Year 0', 'Year 1', 'Year 2', 'Year 3'])
+b.append(['Unlevered cash flow', -100, 100, 120, 140])
+b['B4'] = '=NPV(DiscountRate,C3:E3)+B3'
+b['B5'] = '=IRR(B7:C7)'
+b['B7'], b['C7'] = -100, 110
+b['B8'] = '=XIRR(B7:C7,Assumptions!B3:B4)'
+b['B9'] = '=PMT(0.06/12,360,Assumptions!B2)'
+b['B10'] = '=SUM($C$3:E3)'
+b['C10'] = '=B10*DiscountRate'
+b['B11'] = '=SUMIFS(C3:E3,C3:E3,">100")'
+b['B12'] = '=INDEX(C3:E3,1,MATCH(120,C3:E3,0))'
+b['B13'] = '=IFERROR(1/0,0)'
+b['B14'] = '=TaxRate*100'
+b.defined_names.add(DefinedName('TaxRate', attr_text='0.25'))
+b['A16'] = '0000123'
+b['B16'] = '=1/3'
+b['C16'] = '=B16*3'
+b['D16'] = 'literal =SUM(1,2)'
+b['E16'] = True
+for addr, value, fmt in [
+ ('B18', -1250000.125, '#,##0.00;[Red](#,##0.00);"—"'),
+ ('B19', 0, '#,##0.00;[Red](#,##0.00);"—"'),
+ ('B20', 1250000, '0.0,,"m"'),
+ ('B21', 1.25, '0.0"x"'),
+ ('B22', .125, '0.00%'),
+ ('B23', 1.5, '[h]:mm'),
+ ('B24', 60, 'mm/dd/yyyy'),
+]:
+ b[addr] = value
+ b[addr].number_format = fmt
+b['B18'].font = Font(name='Calibri', size=11, color='0000FF')
+b['B18'].border = Border(bottom=Side(style='double', color='123456'), top=Side(style='thin', color='000000'))
+b['B18'].alignment = Alignment(horizontal='right', indent=1)
+b.auto_filter.ref = 'A2:E3'
+w.save(out / 'financial-model.xlsx')
+
+# A namespaced workbook with absolute relationships, like the reported upload.
+w = Workbook()
+s = w.active
+s.title = 'Companies'
+s.append(['Company', 'Value'])
+s.append(['Sample A', 42])
+s.append(['Sample B', 58])
+t = Table(displayName='CompaniesTable', ref='A1:B3')
+t.tableStyleInfo = TableStyleInfo(name='TableStyleMedium2', showRowStripes=True)
+s.add_table(t)
+s['D1'] = '=SUM(B2:B3)'
+w.save(out / 'namespaced-table.xlsx')
+with ZipFile(out / 'namespaced-table.xlsx') as z:
+ files = {name: z.read(name) for name in z.namelist()}
+for name, content in list(files.items()):
+ if name.endswith(('.xml', '.rels')):
+ root = ET.fromstring(content)
+ if name.endswith('.rels'):
+ base = name.rsplit('/_rels/', 1)[0] if '/_rels/' in name else ''
+ import posixpath
+ for rel in root:
+ target = rel.get('Target', '')
+ if rel.get('TargetMode') != 'External' and not target.startswith('/'):
+ rel.set('Target', '/' + posixpath.normpath(posixpath.join(base, target)))
+ files[name] = ET.tostring(root, encoding='utf-8', xml_declaration=True)
+with ZipFile(out / 'namespaced-table.xlsx', 'w', ZIP_DEFLATED) as z:
+ for name, data in files.items(): z.writestr(name, data)
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/namespaced-table.xlsx b/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/namespaced-table.xlsx
new file mode 100644
index 0000000000..c074d906de
Binary files /dev/null and b/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/namespaced-table.xlsx differ
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-styles.ts b/apps/web/src/features/block-spreadsheet/core/xlsx-styles.ts
index aade2e2881..51878ddc72 100644
--- a/apps/web/src/features/block-spreadsheet/core/xlsx-styles.ts
+++ b/apps/web/src/features/block-spreadsheet/core/xlsx-styles.ts
@@ -1,4 +1,4 @@
-import type { Cell, Color, Style } from 'exceljs';
+import type { BorderStyle, Cell, Color, Style } from 'exceljs';
import { strFromU8 } from 'fflate';
import {
SPREADSHEET_DEFAULT_STYLE,
@@ -46,10 +46,7 @@ function colorValue(
warnings.add('Some indexed or custom theme colors could not be imported.');
return undefined;
}
-function readNumberFormat(
- format: string,
- warnings: Set<string>
-): SpreadsheetCellStyle {
+function readNumberFormat(format: string): SpreadsheetCellStyle {
if (!format || format.toLowerCase() === 'general') return {};
if (format === '@') return { format: 'text' };
const tokens = format.replace(/"[^"]*"|\\.|\[[^\]]*\]/g, '').split(';')[0];
@@ -64,14 +61,15 @@ function readNumberFormat(
else if (/[0#]/.test(tokens))
style = { format: tokens.includes(',') ? 'number' : 'general', decimals };
else style = {};
- const standard =
- /^(?:General|@|#,##0(?:\.[0#]{1,10})?|0(?:\.[0#]{1,10})?%?|\$#,##0(?:\.[0#]{1,10})?|0(?:\.[0#]{1,10})?E\+00|m\/d\/(?:yy|yyyy)|mm\/dd\/yyyy|h:mm(?::ss)?(?: AM\/PM)?)$/i.test(
- format
- );
- if (!standard)
- warnings.add(
- 'Custom number formats are approximated by the available number, date, time or currency formats.'
- );
+ // Retain the actual format instead of approximating accounting sections,
+ // negative parentheses, scaling, currencies, or date/time precision.
+ if (
+ format.length > 512 ||
+ Array.from(format).some((character) => character.charCodeAt(0) < 32)
+ )
+ throw new Error('A cell has an unsupported Excel number format.');
+ if (writeXlsxStyle({ value: '', ...style }).numFmt !== format)
+ style.numberFormat = format;
return style;
}
export function readXlsxStyle(
@@ -79,7 +77,7 @@ export function readXlsxStyle(
theme: (string | undefined)[],
warnings: Set<string>
): SpreadsheetCellStyle {
- const result = readNumberFormat(cell.numFmt, warnings);
+ const result = readNumberFormat(cell.numFmt);
const font = cell.font;
if (font) {
if (font.bold) result.bold = true;
@@ -98,13 +96,12 @@ export function readXlsxStyle(
? 'serif'
: 'sans';
if (
- !['Arial', 'Calibri', 'Inter', 'Georgia', 'Courier New'].includes(
- font.name
- )
+ font.name !==
+ { sans: 'Arial', serif: 'Georgia', mono: 'Courier New' }[
+ result.fontFamily
+ ]
)
- warnings.add(
- 'Fonts are mapped to the available sans, serif and monospace families.'
- );
+ result.fontName = font.name;
}
const color = colorValue(font.color, theme, warnings);
if (color) result.textColor = color;
@@ -168,14 +165,9 @@ export function readXlsxStyle(
const border = cell.border?.[edge];
if (border?.style) {
result[key] = true;
- if (
- border.style !== 'thin' ||
- (border.color?.argb &&
- !/^(?:FF)?(?:000000|808080)$/i.test(border.color.argb))
- )
- warnings.add(
- 'Border colors and line styles are simplified to standard cell borders.'
- );
+ if (border.style !== 'thin') result[`${key}Style`] = border.style;
+ const color = colorValue(border.color, theme, warnings);
+ if (color && color !== '#808080') result[`${key}Color`] = color;
}
}
if (cell.border?.diagonal?.style)
@@ -205,11 +197,13 @@ export function writeXlsxStyle(cell: SpreadsheetCell): Partial<Style> {
argb: `FF${value.slice(1).toUpperCase()}`,
});
return {
- numFmt: numberFormat,
+ numFmt: style.numberFormat || numberFormat,
font: {
- name: { sans: 'Arial', serif: 'Georgia', mono: 'Courier New' }[
- style.fontFamily
- ],
+ name:
+ style.fontName ||
+ { sans: 'Arial', serif: 'Georgia', mono: 'Courier New' }[
+ style.fontFamily
+ ],
size: style.fontSize,
bold: style.bold,
italic: style.italic,
@@ -241,7 +235,22 @@ export function writeXlsxStyle(cell: SpreadsheetCell): Partial<Style> {
] as const
)
.filter(([, enabled]) => enabled)
- .map(([edge]) => [edge, { style: 'thin', color: { argb: 'FF808080' } }])
+ .map(([edge]) => {
+ const key = `border${edge[0].toUpperCase()}${edge.slice(1)}` as
+ | 'borderTop'
+ | 'borderRight'
+ | 'borderBottom'
+ | 'borderLeft';
+ return [
+ edge,
+ {
+ style: (style[`${key}Style`] || 'thin') as BorderStyle,
+ color: style[`${key}Color`]
+ ? rgb(style[`${key}Color`])
+ : { argb: 'FF808080' },
+ },
+ ];
+ })
),
};
}
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-xml.ts b/apps/web/src/features/block-spreadsheet/core/xlsx-xml.ts
new file mode 100644
index 0000000000..fc097ba87f
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/xlsx-xml.ts
@@ -0,0 +1,168 @@
+import { strFromU8 } from 'fflate';
+import { SaxesParser } from 'saxes';
+
+const MAIN = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+const NORMALIZED = [
+ MAIN,
+ 'http://schemas.openxmlformats.org/officeDocument/2006/extended-properties',
+ 'http://schemas.openxmlformats.org/package/2006/relationships',
+ 'http://schemas.openxmlformats.org/package/2006/content-types',
+];
+const REL =
+ 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+export function escapeXml(value: string) {
+ return value
+ .replaceAll('&', '&amp;')
+ .replaceAll('<', '&lt;')
+ .replaceAll('>', '&gt;')
+ .replaceAll('"', '&quot;')
+ .replaceAll('\r', '&#13;');
+}
+
+/** ExcelJS matches literal tag names, although valid OOXML may use any prefix.
+ * Normalize names through namespace-aware XML parsing, never regex text edits. */
+export function normalizeSpreadsheetXml(text: string, path: string): string {
+ const prefixes: Record<string, string> = {
+ 'http://schemas.openxmlformats.org/package/2006/metadata/core-properties':
+ 'cp',
+ 'http://purl.org/dc/elements/1.1/': 'dc',
+ 'http://purl.org/dc/terms/': 'dcterms',
+ 'http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes':
+ 'vt',
+ };
+ const tagName = (uri: string, local: string, name: string) =>
+ NORMALIZED.includes(uri)
+ ? local
+ : prefixes[uri]
+ ? `${prefixes[uri]}:${local}`
+ : name;
+ if (
+ ![...NORMALIZED, ...Object.keys(prefixes)].some((namespace) =>
+ text.includes(namespace)
+ )
+ )
+ return text;
+ const parser = new SaxesParser({ xmlns: true });
+ const output: string[] = [];
+ const defaultNamespaces: string[] = [];
+ parser.on('doctype', () => {
+ throw new Error('Unsupported Excel XML document type.');
+ });
+ parser.on('opentag', (node) => {
+ const name = tagName(node.uri, node.local, node.name);
+ const normalized = NORMALIZED.includes(node.uri);
+ const inherited = defaultNamespaces.at(-1) ?? '';
+ const defaultNamespace = normalized
+ ? node.uri
+ : (node.attributes.xmlns?.value ?? inherited);
+ defaultNamespaces.push(defaultNamespace);
+ const attributes = Object.values(node.attributes)
+ .filter((attribute) => !(normalized && attribute.name === 'xmlns'))
+ .map((attribute) => {
+ const key =
+ attribute.uri === REL ? `r:${attribute.local}` : attribute.name;
+ let value = attribute.value;
+ if (
+ node.local === 'Relationship' &&
+ key === 'Target' &&
+ value.startsWith('/') &&
+ node.attributes.TargetMode?.value !== 'External'
+ ) {
+ const base = path
+ .replace(/(?:^|\/)_rels\/[^/]+$/, '')
+ .split('/')
+ .filter(Boolean);
+ const target = value.split('/').filter(Boolean);
+ while (base.length && target.length && base[0] === target[0]) {
+ base.shift();
+ target.shift();
+ }
+ value = [...base.map(() => '..'), ...target].join('/');
+ }
+ return `${key}="${escapeXml(value).replaceAll('\n', '&#10;').replaceAll('\t', '&#9;')}"`;
+ });
+ if (prefixes[node.uri] && !node.attributes[`xmlns:${prefixes[node.uri]}`])
+ attributes.push(`xmlns:${prefixes[node.uri]}="${node.uri}"`);
+ if (normalized && defaultNamespace !== inherited)
+ attributes.push(`xmlns="${node.uri}"`);
+ if (
+ Object.values(node.attributes).some(
+ (attribute) => attribute.uri === REL
+ ) &&
+ !node.attributes['xmlns:r']
+ )
+ attributes.push(`xmlns:r="${REL}"`);
+ output.push(
+ `<${name}${attributes.length ? ` ${attributes.join(' ')}` : ''}>`
+ );
+ });
+ parser.on('closetag', (node) => {
+ defaultNamespaces.pop();
+ output.push(`</${tagName(node.uri, node.local, node.name)}>`);
+ });
+ parser.on('text', (text) => output.push(escapeXml(text)));
+ parser.on('cdata', (text) => output.push(escapeXml(text)));
+ parser.on('comment', (text) => output.push(`<!--${text}-->`));
+ parser.write(text.replace(/^\uFEFF/, '')).close();
+ return output.join('');
+}
+
+/** Read date serials before ExcelJS converts them to JS Dates (which cannot
+ * represent Excel's fictitious 1900-02-29). Resolve sheets by relationships. */
+export function originalDateSerials(files: Record<string, Uint8Array>) {
+ const sheetIds: string[] = [];
+ let offset = 0;
+ const workbook = new SaxesParser();
+ workbook.on('opentag', (node) => {
+ if (node.name === 'sheet') sheetIds.push(node.attributes['r:id']);
+ if (
+ node.name === 'workbookPr' &&
+ ['1', 'true'].includes(node.attributes.date1904)
+ )
+ offset = 1462;
+ });
+ workbook.write(strFromU8(files['xl/workbook.xml'])).close();
+ const paths = new Map<string, string>();
+ const rels = new SaxesParser();
+ rels.on('opentag', (node) => {
+ if (
+ node.name === 'Relationship' &&
+ node.attributes.TargetMode !== 'External'
+ )
+ paths.set(node.attributes.Id, `xl/${node.attributes.Target}`);
+ });
+ if (files['xl/_rels/workbook.xml.rels'])
+ rels.write(strFromU8(files['xl/_rels/workbook.xml.rels'])).close();
+ return sheetIds.map((id) => {
+ const numbers = new Map<string, number>();
+ const bytes = files[paths.get(id) ?? ''];
+ if (!bytes) return { numbers, offset };
+ const parser = new SaxesParser();
+ let address = '';
+ let value = '';
+ let reading = false;
+ parser.on('opentag', (node) => {
+ if (node.name === 'c')
+ address =
+ !node.attributes.t || node.attributes.t === 'n'
+ ? node.attributes.r
+ : '';
+ if (node.name === 'v') {
+ reading = true;
+ value = '';
+ }
+ });
+ parser.on('text', (text) => {
+ if (reading) value += text;
+ });
+ parser.on('closetag', (node) => {
+ if (node.name === 'v') {
+ reading = false;
+ if (address && value.trim() && Number.isFinite(Number(value)))
+ numbers.set(address, Number(value));
+ }
+ });
+ parser.write(strFromU8(bytes)).close();
+ return { numbers, offset };
+ });
+}
diff --git a/apps/web/src/features/block-spreadsheet/primitives/cell-mention-dom.test.ts b/apps/web/src/features/block-spreadsheet/primitives/cell-mention-dom.test.ts
new file mode 100644
index 0000000000..6c08db16a4
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/primitives/cell-mention-dom.test.ts
@@ -0,0 +1,34 @@
+import { encodeCellMention } from '@macro-inc/spreadsheet/cell-mentions';
+import { expect, it } from 'vitest';
+import {
+ cellTextSelection,
+ readCellText,
+ setCellTextCursor,
+ writeCellText,
+} from './cell-mention-dom';
+
+it('edits mention tokens atomically and maps selection offsets to the canonical cell input', () => {
+ const root = document.createElement('div');
+ root.contentEditable = 'true';
+ document.body.append(root);
+ const token = encodeCellMention({
+ type: 'user',
+ userId: 'macro|[email protected]',
+ email: '[email protected]',
+ displayName: 'Alice',
+ });
+ const value = `Owner ${token} next`;
+ writeCellText(root, value);
+ expect(root.textContent).toBe('Owner @Alice next');
+ expect(root.querySelector('span')?.contentEditable).toBe('false');
+ setCellTextCursor(root, 6 + token.length);
+ expect(cellTextSelection(root)).toEqual({
+ start: 6 + token.length,
+ end: 6 + token.length,
+ });
+ expect(readCellText(root)).toBe(value);
+ writeCellText(root, '**literal** <script>unsafe</script>');
+ expect(root.querySelector('script')).toBeNull();
+ expect(root.textContent).toBe('**literal** <script>unsafe</script>');
+ root.remove();
+});
diff --git a/apps/web/src/features/block-spreadsheet/primitives/cell-mention-dom.ts b/apps/web/src/features/block-spreadsheet/primitives/cell-mention-dom.ts
new file mode 100644
index 0000000000..f2d09d9d1e
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/primitives/cell-mention-dom.ts
@@ -0,0 +1,61 @@
+import {
+ cellMentionLabel,
+ cellTextParts,
+} from '@macro-inc/spreadsheet/cell-mentions';
+
+export function readCellText(node: Node): string {
+ if (node instanceof HTMLElement && node.dataset.cellMention)
+ return node.dataset.cellMention;
+ if (node.nodeType === Node.TEXT_NODE) return node.textContent ?? '';
+ if (node instanceof HTMLBRElement) return '\n';
+ return Array.from(node.childNodes).map(readCellText).join('');
+}
+export function writeCellText(root: HTMLElement, value: string) {
+ root.replaceChildren(
+ ...cellTextParts(value).map((part) => {
+ if (!part.mention) return document.createTextNode(part.text);
+ const pill = document.createElement('span');
+ pill.contentEditable = 'false';
+ pill.dataset.cellMention = part.text;
+ pill.className =
+ 'inline-block max-w-full align-bottom truncate rounded border border-edge-muted bg-accent/8 px-1 text-accent';
+ pill.textContent = cellMentionLabel(part.mention);
+ return pill;
+ })
+ );
+}
+export function cellTextSelection(root: HTMLElement) {
+ const selection = document.getSelection();
+ if (!selection?.rangeCount) return;
+ const range = selection.getRangeAt(0);
+ if (
+ !root.contains(range.startContainer) ||
+ !root.contains(range.endContainer)
+ )
+ return;
+ const prefix = document.createRange();
+ prefix.selectNodeContents(root);
+ prefix.setEnd(range.startContainer, range.startOffset);
+ const start = readCellText(prefix.cloneContents()).length;
+ return { start, end: start + readCellText(range.cloneContents()).length };
+}
+export function setCellTextCursor(root: HTMLElement, offset: number) {
+ const range = document.createRange();
+ for (const node of root.childNodes) {
+ const length = readCellText(node).length;
+ if (offset <= length) {
+ if (node.nodeType === Node.TEXT_NODE) range.setStart(node, offset);
+ else if (offset === 0) range.setStartBefore(node);
+ else range.setStartAfter(node);
+ range.collapse(true);
+ document.getSelection()?.removeAllRanges();
+ document.getSelection()?.addRange(range);
+ return;
+ }
+ offset -= length;
+ }
+ range.selectNodeContents(root);
+ range.collapse(false);
+ document.getSelection()?.removeAllRanges();
+ document.getSelection()?.addRange(range);
+}
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-calculation.ts b/apps/web/src/features/block-spreadsheet/primitives/create-calculation.ts
index 0c93c90b8d..2debf94902 100644
--- a/apps/web/src/features/block-spreadsheet/primitives/create-calculation.ts
+++ b/apps/web/src/features/block-spreadsheet/primitives/create-calculation.ts
@@ -1,3 +1,4 @@
+import type { AxisChange } from '@macro-inc/spreadsheet/workbook-structure';
import {
type Accessor,
createEffect,
@@ -61,6 +62,7 @@ export function createCalculation(
name: sheet.name,
cells: sheet.cells,
rowCount: sheet.layout.rowCount,
+ metadata: sheet.metadata,
})) ?? [],
previous
),
@@ -140,6 +142,12 @@ export function createCalculation(
});
return result.type === 'complete' ? result.context : undefined;
},
+ async changeAxis(sheets: SpreadsheetWorkbookSheet[], change: AxisChange) {
+ const result = await copier.run({ type: 'change-axis', sheets, change });
+ if (result.type !== 'change-axis')
+ throw new Error('Unable to change sheet structure.');
+ return result.sheets;
+ },
async copy(copies: CellCopy[]) {
const result = await copier.run({
type: 'copy',
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-draft-actions.test.ts b/apps/web/src/features/block-spreadsheet/primitives/create-draft-actions.test.ts
index 5d8dfea3da..a6022751ff 100644
--- a/apps/web/src/features/block-spreadsheet/primitives/create-draft-actions.test.ts
+++ b/apps/web/src/features/block-spreadsheet/primitives/create-draft-actions.test.ts
@@ -97,3 +97,27 @@ describe('spreadsheet draft actions', () => {
expect(options.openDocument).not.toHaveBeenCalled();
});
});
+
+it('converts an upload once, waits for durable acknowledgement, and retries the same copy after failure', async () => {
+ const { actions, options } = fixture();
+ options.saveDocument.mockRejectedValueOnce(new Error('Disconnected'));
+ await actions.edit();
+ expect(options.openDocument).not.toHaveBeenCalled();
+ expect(options.onSaveFailure).toHaveBeenCalledWith('edit');
+ let acknowledge = () => {};
+ options.saveDocument.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ acknowledge = resolve;
+ })
+ );
+ const saving = actions.edit();
+ await vi.waitFor(() => expect(options.saveDocument).toHaveBeenCalledTimes(2));
+ await actions.edit();
+ expect(options.createDocument).toHaveBeenCalledOnce();
+ expect(options.openDocument).not.toHaveBeenCalled();
+ acknowledge();
+ await saving;
+ expect(options.openDocument).toHaveBeenCalledWith('document-id', 'edit');
+ expect(options.openChat).not.toHaveBeenCalled();
+});
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-draft-actions.ts b/apps/web/src/features/block-spreadsheet/primitives/create-draft-actions.ts
index 2790ed1f89..18a8d67887 100644
--- a/apps/web/src/features/block-spreadsheet/primitives/create-draft-actions.ts
+++ b/apps/web/src/features/block-spreadsheet/primitives/create-draft-actions.ts
@@ -1,6 +1,6 @@
import { createSignal, onCleanup } from 'solid-js';
-type DraftAction = 'share' | 'ask';
+type DraftAction = 'share' | 'ask' | 'edit';
/** Save a local draft once, await durability, then hand it to sharing or chat. */
export function createDraftActions(options: {
@@ -47,5 +47,10 @@ export function createDraftActions(options: {
}
}
- return { pending, share: () => run('share'), ask: () => run('ask') };
+ return {
+ pending,
+ share: () => run('share'),
+ ask: () => run('ask'),
+ edit: () => run('edit'),
+ };
}
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-grid-controller.test.ts b/apps/web/src/features/block-spreadsheet/primitives/create-grid-controller.test.ts
index 463bdbfbf6..0856fa7564 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
@@ -28,6 +28,8 @@ function setup(
const [cells, updateCells] = createSignal(initial);
const [canEdit, setCanEdit] = createSignal(true);
const [rowCount, setRowCount] = createSignal(200);
+ const [hiddenRows, setHiddenRows] = createSignal<number[]>([]);
+ const [hiddenColumns, setHiddenColumns] = createSignal<number[]>([]);
const [sheetId, setSheetId] = createSignal(initialSheetId ?? 'sheet1');
const setCells = vi.fn((edits: SpreadsheetCellEdits) => {
const next = { ...cells() };
@@ -42,6 +44,8 @@ function setup(
const redo = vi.fn();
const grid = createGridController({
cells,
+ hiddenRows,
+ hiddenColumns,
setSelection: publishSelection,
canEdit,
setCells,
@@ -67,6 +71,8 @@ function setup(
setCells,
setCanEdit,
setRowCount,
+ setHiddenRows,
+ setHiddenColumns,
setSheetId,
undo,
redo,
@@ -76,6 +82,23 @@ function setup(
}
describe('spreadsheet grid editing', () => {
+ it('keeps Home and typing into a whole-row/column selection out of hidden cells', () => {
+ const { grid, key, setHiddenRows, setHiddenColumns, cells } = setup();
+ setHiddenRows([0]);
+ setHiddenColumns([0]);
+ grid.select({ row: 2, column: 4 });
+ key('Home');
+ expect(grid.activeAddress()).toBe('B3');
+ key('Home', { ctrlKey: true });
+ expect(grid.activeAddress()).toBe('B2');
+ grid.selectRange({ row: 0, column: 0 }, { row: 0, column: 25 });
+ key('x');
+ grid.commit();
+ expect(cells().B2.value).toBe('x');
+ expect(cells().A1).toBeUndefined();
+ key('ArrowLeft');
+ expect(grid.activeAddress()).toBe('B2');
+ });
it('publishes the current range for direct selection, keyboard movement, and tab restoration', async () => {
const { grid, publishSelection, setSheetId, key } = setup(
{},
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-grid-controller.ts b/apps/web/src/features/block-spreadsheet/primitives/create-grid-controller.ts
index 7f0fc4bda9..f3f0bd7796 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
@@ -43,6 +43,8 @@ type GridSource = {
sheetId?: Accessor<string>;
canEdit: Accessor<boolean>;
rowCount?: Accessor<number>;
+ hiddenRows?: Accessor<number[]>;
+ hiddenColumns?: Accessor<number[]>;
copyCells?: (copies: CellCopy[]) => Promise<SpreadsheetCellEdits>;
setCells: (edits: Record<string, Partial<SpreadsheetCell> | null>) => void;
setSelection?: (selection: SpreadsheetSelection) => void;
@@ -60,7 +62,26 @@ export function createGridController(source: GridSource) {
onCleanup(() => {
operation++;
});
- const origin = { row: 0, column: 0 };
+ const visiblePosition = (position: CellPosition): CellPosition => {
+ const bounded = boundPosition(position);
+ const visible = (index: number, limit: number, hidden: number[]) => {
+ if (!hidden.includes(index)) return index;
+ for (let next = index + 1; next < limit; next++)
+ if (!hidden.includes(next)) return next;
+ for (let next = index - 1; next >= 0; next--)
+ if (!hidden.includes(next)) return next;
+ return 0;
+ };
+ return {
+ row: visible(bounded.row, rowCount(), source.hiddenRows?.() ?? []),
+ column: visible(
+ bounded.column,
+ GRID_COLUMNS,
+ source.hiddenColumns?.() ?? []
+ ),
+ };
+ };
+ const origin = visiblePosition({ row: 0, column: 0 });
const [selection, setSelectionValue] = createSignal<CellSelection>({
anchor: origin,
focus: origin,
@@ -166,7 +187,7 @@ export function createGridController(source: GridSource) {
function select(position: CellPosition, extend = false) {
commit();
operation++;
- const bounded = boundPosition(position);
+ const bounded = visiblePosition(position);
setSelection((current) => ({
anchor: extend ? current.anchor : bounded,
focus: bounded,
@@ -187,6 +208,9 @@ export function createGridController(source: GridSource) {
function beginEdit(location: 'cell' | 'formula', initial?: string) {
if (!source.canEdit()) return;
operation++;
+ const visible = visiblePosition(selection().anchor);
+ if (cellAddress(visible) !== activeAddress())
+ setSelection({ anchor: visible, focus: visible });
originalValue = source.cells()[activeAddress()]?.value ?? '';
setDraft(initial ?? originalValue);
setEditing(location);
@@ -257,7 +281,27 @@ export function createGridController(source: GridSource) {
function move(row: number, column: number, extend = false) {
const from = extend ? selection().focus : selection().anchor;
- select({ row: from.row + row, column: from.column + column }, extend);
+ const next = boundPosition({
+ row: from.row + row,
+ column: from.column + column,
+ });
+ while (row && source.hiddenRows?.().includes(next.row)) {
+ const candidate = next.row + Math.sign(row);
+ if (candidate < 0 || candidate >= rowCount()) {
+ next.row = from.row;
+ break;
+ }
+ next.row = candidate;
+ }
+ while (column && source.hiddenColumns?.().includes(next.column)) {
+ const candidate = next.column + Math.sign(column);
+ if (candidate < 0 || candidate >= GRID_COLUMNS) {
+ next.column = from.column;
+ break;
+ }
+ next.column = candidate;
+ }
+ select(next, extend);
}
function clear() {
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-sheet-actions.test.ts b/apps/web/src/features/block-spreadsheet/primitives/create-sheet-actions.test.ts
index 52d01cf107..876f1d2502 100644
--- a/apps/web/src/features/block-spreadsheet/primitives/create-sheet-actions.test.ts
+++ b/apps/web/src/features/block-spreadsheet/primitives/create-sheet-actions.test.ts
@@ -273,9 +273,9 @@ describe('spreadsheet menu actions', () => {
expect(state.appendRows).toHaveBeenCalledExactlyOnceWith(1);
expect(state.setCells).toHaveBeenCalledOnce();
expect(state.cells()).toEqual({
- A200: { value: 'one,two', italic: true },
- B200: { value: 'multi\nline' },
- A201: { value: 'next' },
+ A200: { value: "'one,two", italic: true },
+ B200: { value: "'multi\nline" },
+ A201: { value: "'next" },
B201: { value: '' },
});
expect(state.grid.selection().focus).toEqual({ row: 200, column: 1 });
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-sheet-actions.ts b/apps/web/src/features/block-spreadsheet/primitives/create-sheet-actions.ts
index 1419397015..87e3b2a2ae 100644
--- a/apps/web/src/features/block-spreadsheet/primitives/create-sheet-actions.ts
+++ b/apps/web/src/features/block-spreadsheet/primitives/create-sheet-actions.ts
@@ -128,7 +128,7 @@ export function createSheetActions(
source.setCells(edits);
setNotice(`Trimmed whitespace in ${Object.keys(edits).length} cells`);
}
- async function sort(descending: boolean) {
+ async function sort(descending: boolean, sheetColumn?: number) {
grid.commit();
if (!source.canEdit() || source.busy() || pending()) return;
const selection = grid.selection();
@@ -145,7 +145,18 @@ export function createSheetActions(
setNotice('Sorting selected range…');
try {
const edits = await source.copyCells(
- sortedRangeCopies(before, source.values(), selection, descending)
+ sortedRangeCopies(
+ before,
+ source.values(),
+ sheetColumn === undefined
+ ? selection
+ : {
+ anchor: { row: 0, column: 0 },
+ focus: { row: source.rowCount() - 1, column: 25 },
+ },
+ descending,
+ sheetColumn
+ )
);
if (revision !== operation) return;
if (
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-discussion.test.ts b/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-discussion.test.ts
new file mode 100644
index 0000000000..63d5858b51
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-discussion.test.ts
@@ -0,0 +1,186 @@
+import type { ItemMention } from '@core/component/LexicalMarkdown/plugins';
+import type { CommentThread } from '@service-storage/generated/schemas/commentThread';
+import { createRoot, createSignal } from 'solid-js';
+import { describe, expect, it, vi } from 'vitest';
+import { spreadsheetCommentAnchor } from '../core/spreadsheet-comments';
+import {
+ createSpreadsheetDiscussion,
+ spreadsheetDiscussionThread,
+} from './create-spreadsheet-discussion';
+
+const anchor = { sheetId: 'sheet-1', sheetName: 'Budget', range: 'B4:C9' };
+const comment = {
+ id: '42',
+ threadId: '7',
+ authorId: 'me',
+ text: 'Budget?',
+ createdAt: '',
+ updatedAt: '',
+ deletedAt: null,
+};
+const server: CommentThread = {
+ thread: {
+ threadId: 7,
+ documentId: 'doc',
+ owner: 'me',
+ resolved: false,
+ metadata: { spreadsheet: anchor },
+ },
+ comments: [
+ { commentId: 42, threadId: 7, owner: 'me', text: 'Budget?', order: 0 },
+ ],
+};
+function setup() {
+ const [canComment, setCanComment] = createSignal(true);
+ const [threads, setThreads] = createSignal([server]);
+ const [target, setTarget] = createSignal<string | null>(null);
+ const api = {
+ create: vi.fn(async () => ({})),
+ edit: vi.fn(async () => ({})),
+ delete: vi.fn(async () => ({})),
+ };
+ const refresh = vi.fn(async () => {});
+ const source = createSpreadsheetDiscussion({
+ threads,
+ canComment,
+ userId: () => 'me',
+ anchor: () => anchor,
+ targetCommentId: target,
+ targetRevision: target,
+ api,
+ refresh,
+ buildLink: (id) => `https://macro.com/app/spreadsheet/doc?comment_id=${id}`,
+ });
+ return { source, api, refresh, setCanComment, setThreads, setTarget };
+}
+
+describe('spreadsheet document discussions', () => {
+ it('posts range metadata and unique user mentions through the existing document API', async () => {
+ await createRoot(async (dispose) => {
+ const { source, api, refresh } = setup();
+ const mentions = [
+ { itemType: 'user', itemId: 'alice' },
+ { itemType: 'user', itemId: 'alice' },
+ { itemType: 'document', itemId: 'other-doc' },
+ ] as ItemMention[];
+ await source.createThread('Please check this range', mentions);
+ expect(api.create).toHaveBeenCalledWith({
+ text: 'Please check this range',
+ threadMetadata: {
+ markId: expect.stringMatching(/^DISCUSSION:/),
+ spreadsheet: anchor,
+ },
+ mentions: { mentionId: expect.any(String), users: ['alice'] },
+ });
+ expect(refresh).toHaveBeenCalledOnce();
+ await source.createReply('7', 'Looks right', []);
+ expect(api.create).toHaveBeenLastCalledWith({
+ threadId: 7,
+ text: 'Looks right',
+ mentions: undefined,
+ });
+ expect(source.buildCommentLink?.(comment)).toContain('comment_id=42');
+ dispose();
+ });
+ });
+ it('allows commenters without requiring edit permission, and blocks revoked permissions and other authors', async () => {
+ await createRoot(async (dispose) => {
+ const { source, api, setCanComment } = setup();
+ await source.editComment(comment, 'Updated');
+ expect(api.edit).toHaveBeenCalledWith(42, 7, 'Updated');
+ expect(() =>
+ source.deleteComment({ ...comment, authorId: 'other' })
+ ).toThrow(/own comments/);
+ setCanComment(false);
+ await expect(source.createThread('no', [])).rejects.toThrow(/permission/);
+ await expect(source.createReply('7', 'no', [])).rejects.toThrow(
+ /permission/
+ );
+ await expect(source.editComment(comment, 'no')).rejects.toThrow(
+ /permission/
+ );
+ await expect(source.deleteComment(comment)).rejects.toThrow(/permission/);
+ expect(api.create).not.toHaveBeenCalled();
+ expect(api.delete).not.toHaveBeenCalled();
+ dispose();
+ });
+ });
+ it('propagates write failures so drafts survive and does not retry a successful post after a read failure', async () => {
+ await createRoot(async (dispose) => {
+ const { source, api, refresh } = setup();
+ api.create.mockRejectedValueOnce(new Error('offline'));
+ await expect(source.createThread('Keep my draft', [])).rejects.toThrow(
+ 'offline'
+ );
+ expect(refresh).not.toHaveBeenCalled();
+ refresh.mockRejectedValueOnce(new Error('read failed'));
+ await expect(
+ source.createThread('Sent once', [])
+ ).resolves.toBeUndefined();
+ expect(api.create).toHaveBeenCalledTimes(2);
+ dispose();
+ });
+ });
+ it('updates live threads without remounting reply composers; deleted threads disappear', () =>
+ createRoot((dispose) => {
+ const { source, setThreads, setTarget } = setup();
+ const first = source.threads()[0];
+ setThreads([
+ {
+ ...server,
+ comments: [
+ ...server.comments,
+ {
+ commentId: 43,
+ threadId: 7,
+ owner: 'other',
+ sender: 'sender',
+ text: 'Reply',
+ order: 1,
+ },
+ ],
+ },
+ ]);
+ expect(source.threads()[0]).toBe(first);
+ expect(first.comments.map((c) => c.authorId)).toEqual(['me', 'sender']);
+ setTarget('43');
+ expect(source.targetCommentId()).toBe('43');
+ setThreads([
+ { ...server, thread: { ...server.thread, deletedAt: 'today' } },
+ ]);
+ expect(source.threads()).toEqual([]);
+ dispose();
+ }));
+ it('sorts roots before replies and preserves deletion and sender information', () => {
+ const thread = spreadsheetDiscussionThread({
+ ...server,
+ comments: [
+ {
+ commentId: 43,
+ threadId: 7,
+ owner: 'owner',
+ sender: 'sender',
+ text: '',
+ order: 1,
+ deletedAt: 'today',
+ },
+ ...server.comments,
+ ],
+ });
+ expect(thread.comments.map((c) => c.id)).toEqual(['42', '43']);
+ expect(thread.comments[1].deletedAt).toBe('today');
+ });
+ it('accepts validated range anchors and ignores foreign/malformed annotation metadata', () => {
+ expect(spreadsheetCommentAnchor({ spreadsheet: anchor })).toEqual(anchor);
+ for (const metadata of [
+ null,
+ {},
+ { markId: 'DISCUSSION:old' },
+ { spreadsheet: { ...anchor, range: 'A0' } },
+ { spreadsheet: { ...anchor, range: 'A1:B2:C3' } },
+ { spreadsheet: { ...anchor, range: '=NOW()' } },
+ { spreadsheet: { ...anchor, sheetId: 10 } },
+ ])
+ expect(spreadsheetCommentAnchor(metadata)).toBeUndefined();
+ });
+});
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-discussion.ts b/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-discussion.ts
new file mode 100644
index 0000000000..a8965f7965
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-discussion.ts
@@ -0,0 +1,148 @@
+import type {
+ DiscussionSource,
+ DiscussionThread,
+} from '@core/comments/discussion/types';
+import type { ItemMention } from '@core/component/LexicalMarkdown/plugins';
+import type { CommentThread } from '@service-storage/generated/schemas/commentThread';
+import type { CreateCommentRequest } from '@service-storage/generated/schemas/createCommentRequest';
+import { type Accessor, createMemo } from 'solid-js';
+import type { SpreadsheetCommentAnchor } from '../core/spreadsheet-comments';
+
+export function createSpreadsheetDiscussion(options: {
+ threads: Accessor<CommentThread[]>;
+ canComment: Accessor<boolean>;
+ userId: Accessor<string | undefined>;
+ anchor: Accessor<SpreadsheetCommentAnchor | undefined>;
+ targetCommentId: Accessor<string | null>;
+ targetRevision: Accessor<unknown>;
+ api: {
+ create(body: CreateCommentRequest): Promise<unknown>;
+ edit(commentId: number, threadId: number, text: string): Promise<unknown>;
+ delete(commentId: number): Promise<unknown>;
+ };
+ refresh(): Promise<unknown>;
+ buildLink(commentId: string): string;
+}): DiscussionSource {
+ // Keep each thread's UI mounted when a live reply arrives while composing.
+ const adapters = new Map<
+ string,
+ ReturnType<typeof spreadsheetDiscussionThread>
+ >();
+ const mapped = createMemo(
+ () =>
+ new Map(
+ options
+ .threads()
+ .filter((value) => !value.thread.deletedAt)
+ .map((value) => [
+ String(value.thread.threadId),
+ spreadsheetDiscussionThread(value),
+ ])
+ )
+ );
+ const threads = createMemo(() =>
+ [...mapped().keys()].map((id) => {
+ let adapter = adapters.get(id);
+ if (!adapter) {
+ adapter = {
+ id,
+ get resolved() {
+ return mapped().get(id)?.resolved ?? false;
+ },
+ get comments() {
+ return mapped().get(id)?.comments ?? [];
+ },
+ };
+ adapters.set(id, adapter);
+ }
+ return adapter;
+ })
+ );
+ async function write(operation: () => Promise<unknown>) {
+ if (!options.canComment() || !options.userId())
+ throw new Error('You do not have permission to comment.');
+ await operation();
+ // Posting succeeded even if refreshing later fails. Never invite duplicate sends.
+ void options.refresh().catch(() => {});
+ }
+ function assertOwner(authorId: string) {
+ if (authorId !== options.userId())
+ throw new Error('You can only change your own comments.');
+ }
+ return {
+ threads,
+ canEdit: options.canComment,
+ currentUserId: options.userId,
+ targetCommentId: options.targetCommentId,
+ targetRevision: options.targetRevision,
+ createThread: (text, mentions) => {
+ const anchor = options.anchor();
+ return write(() =>
+ options.api.create({
+ text,
+ threadMetadata: {
+ markId: `DISCUSSION:${crypto.randomUUID()}`,
+ ...(anchor ? { spreadsheet: anchor } : {}),
+ },
+ mentions: spreadsheetCommentMentions(mentions),
+ })
+ );
+ },
+ createReply: (threadId, text, mentions) =>
+ write(() =>
+ options.api.create({
+ text,
+ threadId: Number(threadId),
+ mentions: spreadsheetCommentMentions(mentions),
+ })
+ ),
+ editComment: (comment, text) => {
+ assertOwner(comment.authorId);
+ return write(() =>
+ options.api.edit(Number(comment.id), Number(comment.threadId), text)
+ );
+ },
+ deleteComment: (comment) => {
+ assertOwner(comment.authorId);
+ return write(() => options.api.delete(Number(comment.id)));
+ },
+ buildCommentLink: (comment) => options.buildLink(comment.id),
+ };
+}
+
+export function spreadsheetCommentMentions(mentions: ItemMention[]) {
+ const users = [
+ ...new Set(
+ mentions
+ .filter((item) => item.itemType === 'user')
+ .map((item) => item.itemId)
+ ),
+ ];
+ return users.length ? { mentionId: crypto.randomUUID(), users } : undefined;
+}
+
+export function spreadsheetDiscussionThread(
+ value: CommentThread
+): DiscussionThread {
+ return {
+ id: String(value.thread.threadId),
+ resolved: value.thread.resolved,
+ comments: [...value.comments]
+ .sort(
+ (a, b) =>
+ (a.order ?? Number.MAX_SAFE_INTEGER) -
+ (b.order ?? Number.MAX_SAFE_INTEGER) ||
+ (a.createdAt ?? '').localeCompare(b.createdAt ?? '') ||
+ a.commentId - b.commentId
+ )
+ .map((comment) => ({
+ id: String(comment.commentId),
+ threadId: String(comment.threadId),
+ authorId: comment.sender ?? comment.owner,
+ text: comment.text,
+ createdAt: comment.createdAt ?? '',
+ updatedAt: comment.updatedAt ?? comment.createdAt ?? '',
+ deletedAt: comment.deletedAt ?? null,
+ })),
+ };
+}
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-store.test.ts b/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-store.test.ts
index 3cccd52b2f..4f6a7b787e 100644
--- a/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-store.test.ts
+++ b/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-store.test.ts
@@ -16,6 +16,85 @@ import {
import { createSpreadsheetStore } from './create-spreadsheet-store';
describe('spreadsheet store', () => {
+ it('applies structural patches as one undo step and rejects stale collaborator snapshots', async () => {
+ const doc = new LoroDoc();
+ writeSpreadsheetCells(doc, {
+ A1: { value: '10', bold: true },
+ A2: { value: '20' },
+ });
+ let dispose = () => {};
+ const store = createRoot((cleanup) => {
+ dispose = cleanup;
+ return createSpreadsheetStore({
+ canEdit: () => true,
+ source: {
+ doc: () => doc,
+ ready: () => true,
+ error: () => undefined,
+ status: () => 'local',
+ peers: () => [],
+ setSelection: () => {},
+ },
+ });
+ });
+ await Promise.resolve();
+ const before = store.workbook();
+ const next = before.map((sheet) => ({
+ ...sheet,
+ cells: { A2: sheet.cells.A1, A3: sheet.cells.A2 },
+ metadata: { hiddenRows: [1] },
+ }));
+ store.applyStructure(before, next);
+ expect(store.cells().A1).toBeUndefined();
+ expect(store.cells().A2).toEqual({ value: '10', bold: true });
+ store.undo();
+ expect(store.cells()).toEqual(before[0].cells);
+ expect(store.activeSheet().metadata?.hiddenRows).toBeUndefined();
+ const peer = new LoroDoc();
+ peer.import(doc.export({ mode: 'snapshot' }));
+ writeSpreadsheetCells(peer, { B1: { value: 'New collaborator edit' } });
+ doc.import(peer.export({ mode: 'update' }));
+ expect(() => store.applyStructure(before, next)).toThrow(
+ 'workbook changed'
+ );
+ expect(readSpreadsheetCells(doc).B1.value).toBe('New collaborator edit');
+ dispose();
+ peer.free();
+ doc.free();
+ });
+
+ it.each(['connected', 'connecting', 'offline'] as const)(
+ 'rejects coordinate shifts for a %s collaborative source',
+ async (status) => {
+ const doc = new LoroDoc();
+ writeSpreadsheetCells(doc, { A1: { value: 'Keep me' } });
+ let dispose = () => {};
+ const store = createRoot((cleanup) => {
+ dispose = cleanup;
+ return createSpreadsheetStore({
+ canEdit: () => true,
+ source: {
+ doc: () => doc,
+ ready: () => true,
+ error: () => undefined,
+ status: () => status,
+ peers: () => [],
+ setSelection: () => {},
+ },
+ });
+ });
+ await Promise.resolve();
+ const before = store.workbook(),
+ version = doc.version().toJSON();
+ expect(store.canChangeStructure()).toBe(false);
+ expect(() => store.applyStructure(before, before)).toThrow(
+ 'shared workbooks'
+ );
+ expect(doc.version().toJSON()).toEqual(version);
+ dispose();
+ doc.free();
+ }
+ );
it('reports blocked structural history through its error accessor and preserves the undo step', async () => {
const doc = new LoroDoc();
const peer = new LoroDoc();
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-store.ts b/apps/web/src/features/block-spreadsheet/primitives/create-spreadsheet-store.ts
index 03c55258b2..aff47b1bae 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
@@ -1,3 +1,7 @@
+import {
+ parseWorkbookMetadata,
+ type WorkbookSheetMetadata,
+} from '@macro-inc/spreadsheet/workbook-metadata';
import { leadingAndTrailing, throttle } from '@solid-primitives/scheduled';
import {
type Accessor,
@@ -10,11 +14,15 @@ import {
import type { SpreadsheetDocumentSource } from '../context/spreadsheet-source';
import {
appendSpreadsheetRows,
+ DEFAULT_COLUMN_WIDTH,
DEFAULT_SHEET_ID,
resizeSpreadsheetColumn,
+ SPREADSHEET_DEFAULT_STYLE,
SPREADSHEET_ROWS,
type SpreadsheetCellEdits,
type SpreadsheetSelection,
+ spreadsheetSheetKey,
+ validateSpreadsheetCellEdits,
writeSpreadsheetCells,
} from '../core/spreadsheet-document';
import { createSpreadsheetHistory } from '../core/spreadsheet-history';
@@ -162,6 +170,92 @@ export function createSpreadsheetStore(options: {
resizeSpreadsheetColumn(doc, column, width, activeSheetId());
refresh();
},
+ setMetadata(metadata: WorkbookSheetMetadata) {
+ const doc = options.source.doc();
+ if (!doc || !editable()) return;
+ const encoded = JSON.stringify(metadata);
+ if (!parseWorkbookMetadata(encoded))
+ throw new Error('Invalid sheet layout.');
+ doc.getMap('spreadsheetSheetMetadata').set(activeSheetId(), encoded);
+ doc.commit({ origin: 'spreadsheet-layout' });
+ refresh();
+ },
+ canChangeStructure: () => editable() && options.source.status() === 'local',
+ applyStructure(
+ expected: SpreadsheetWorkbookSheet[],
+ next: SpreadsheetWorkbookSheet[]
+ ) {
+ const doc = options.source.doc();
+ if (!doc || !editable())
+ throw new Error('This spreadsheet is view only.');
+ if (options.source.status() !== 'local')
+ throw new Error(
+ 'Inserting and deleting rows or columns is not yet available in shared workbooks.'
+ );
+ if (
+ JSON.stringify(readSpreadsheetWorkbook(doc)) !==
+ JSON.stringify(expected)
+ )
+ throw new Error(
+ 'The workbook changed while moving cells. No changes were applied; try again.'
+ );
+ for (const sheet of next) {
+ validateSpreadsheetCellEdits(sheet.cells);
+ if (
+ sheet.metadata &&
+ !parseWorkbookMetadata(JSON.stringify(sheet.metadata))
+ )
+ throw new Error(
+ 'The changed layout would exceed the supported sheet size.'
+ );
+ }
+ for (const sheet of next) {
+ const previous = expected.find((item) => item.id === sheet.id)!;
+ const edits: SpreadsheetCellEdits = {};
+ for (const address of new Set([
+ ...Object.keys(previous.cells),
+ ...Object.keys(sheet.cells),
+ ])) {
+ if (
+ JSON.stringify(previous.cells[address]) !==
+ JSON.stringify(sheet.cells[address])
+ )
+ edits[address] = sheet.cells[address]
+ ? { ...SPREADSHEET_DEFAULT_STYLE, ...sheet.cells[address] }
+ : null;
+ }
+ writeSpreadsheetCells(doc, edits, sheet.id, false);
+ if (
+ JSON.stringify(previous.metadata) !== JSON.stringify(sheet.metadata)
+ )
+ doc
+ .getMap('spreadsheetSheetMetadata')
+ .set(sheet.id, JSON.stringify(sheet.metadata ?? {}));
+ for (const key of new Set([
+ ...Object.keys(previous.layout.columnWidths),
+ ...Object.keys(sheet.layout.columnWidths),
+ ])) {
+ if (
+ previous.layout.columnWidths[Number(key)] !==
+ sheet.layout.columnWidths[Number(key)]
+ )
+ resizeSpreadsheetColumn(
+ doc,
+ Number(key),
+ sheet.layout.columnWidths[Number(key)] ?? DEFAULT_COLUMN_WIDTH,
+ sheet.id,
+ false
+ );
+ }
+ const addition = sheet.layout.rowCount - previous.layout.rowCount;
+ if (addition > 0)
+ doc
+ .getMap('spreadsheetRowAdditions')
+ .set(spreadsheetSheetKey(crypto.randomUUID(), sheet.id), addition);
+ }
+ doc.commit({ origin: 'spreadsheet-axis-change' });
+ refresh();
+ },
appendRows(count: number) {
const doc = options.source.doc();
if (!doc || !editable()) return;
diff --git a/apps/web/src/features/block-spreadsheet/primitives/create-workbook-actions.ts b/apps/web/src/features/block-spreadsheet/primitives/create-workbook-actions.ts
index d77e653959..c6cf2852b9 100644
--- a/apps/web/src/features/block-spreadsheet/primitives/create-workbook-actions.ts
+++ b/apps/web/src/features/block-spreadsheet/primitives/create-workbook-actions.ts
@@ -147,6 +147,7 @@ export function createWorkbookActions(options: {
{
sheets: options.store.workbook().map((sheet) => ({
name: sheet.name,
+ metadata: sheet.metadata,
cells: sheet.cells,
rowCount: sheet.layout.rowCount,
columnWidths: sheet.layout.columnWidths,
diff --git a/apps/web/src/features/block-spreadsheet/queries/keys.ts b/apps/web/src/features/block-spreadsheet/queries/keys.ts
new file mode 100644
index 0000000000..f4c407c40c
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/queries/keys.ts
@@ -0,0 +1,11 @@
+import { createQueryKeys } from '@lukemorales/query-key-factory';
+
+export const uploadedWorkbookKeys = createQueryKeys('uploadedWorkbook', {
+ file: (id: string, version: number, fileType: string) => ({
+ queryKey: [id, version, fileType],
+ }),
+});
+
+export const spreadsheetCommentKeys = createQueryKeys('spreadsheetComments', {
+ document: (id: string) => [id],
+});
diff --git a/apps/web/src/features/block-spreadsheet/queries/spreadsheet-comments.test.tsx b/apps/web/src/features/block-spreadsheet/queries/spreadsheet-comments.test.tsx
new file mode 100644
index 0000000000..cc71c9f68f
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/queries/spreadsheet-comments.test.tsx
@@ -0,0 +1,110 @@
+import { cleanup, render, waitFor } from '@solidjs/testing-library';
+import { QueryClient, QueryClientProvider } from '@tanstack/solid-query';
+import { err, ok } from 'neverthrow';
+import { afterEach, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+ annotations: {
+ getComments: vi.fn(),
+ createComment: vi.fn(),
+ editComment: vi.fn(),
+ deleteComment: vi.fn(),
+ },
+ event: undefined as
+ | undefined
+ | ((event: { type: string; data: string }) => void),
+}));
+vi.mock('@service-storage/client', () => ({
+ storageServiceClient: { annotations: mocks.annotations },
+}));
+vi.mock('@service-connection/websocket', () => ({
+ state: () => 1,
+ createConnectionWebsocketEffect: (fn: typeof mocks.event) => {
+ mocks.event = fn;
+ },
+}));
+
+import {
+ spreadsheetCommentsApi,
+ useSpreadsheetComments,
+} from './spreadsheet-comments';
+
+afterEach(() => {
+ cleanup();
+ vi.resetAllMocks();
+});
+it('uses the existing comment API for list, create, edit, and delete', async () => {
+ const api = spreadsheetCommentsApi('sheet-document');
+ mocks.annotations.getComments.mockResolvedValue(ok({ data: [] }));
+ mocks.annotations.createComment.mockResolvedValue(
+ ok({ thread: { threadId: 8 }, comments: [] })
+ );
+ mocks.annotations.editComment.mockResolvedValue(ok({ commentId: 42 }));
+ mocks.annotations.deleteComment.mockResolvedValue(ok({ commentId: 42 }));
+ expect(await api.list()).toEqual([]);
+ const body = { text: 'Hello', threadId: 8 };
+ await api.create(body);
+ await api.edit(42, 8, 'Updated');
+ await api.delete(42);
+ expect(mocks.annotations.getComments).toHaveBeenCalledWith({
+ documentId: 'sheet-document',
+ });
+ expect(mocks.annotations.createComment).toHaveBeenCalledWith({
+ documentId: 'sheet-document',
+ body,
+ });
+ expect(mocks.annotations.editComment).toHaveBeenCalledWith({
+ commentId: 42,
+ body: { text: 'Updated', threadId: 8 },
+ });
+ expect(mocks.annotations.deleteComment).toHaveBeenCalledWith({
+ commentId: 42,
+ body: {},
+ });
+});
+it('surfaces API errors instead of treating them as successful writes', async () => {
+ const api = spreadsheetCommentsApi('sheet');
+ for (const mock of Object.values(mocks.annotations))
+ mock.mockResolvedValue(err('denied'));
+ await expect(api.list()).rejects.toThrow('load comments');
+ await expect(api.create({ text: 'draft' })).rejects.toThrow(
+ 'draft has been kept'
+ );
+ await expect(api.edit(1, 2, 'draft')).rejects.toThrow('draft has been kept');
+ await expect(api.delete(1)).rejects.toThrow('delete comment');
+});
+it('refreshes live changes only for this document and tolerates malformed events', async () => {
+ mocks.annotations.getComments.mockResolvedValue(ok({ data: [] }));
+ const client = new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+ });
+ let state!: ReturnType<typeof useSpreadsheetComments>;
+ function Probe() {
+ state = useSpreadsheetComments('sheet');
+ return null;
+ }
+ render(() => (
+ <QueryClientProvider client={client}>
+ <Probe />
+ </QueryClientProvider>
+ ));
+ await waitFor(() => expect(state.query.isSuccess).toBe(true));
+ const send = (documentId: string) =>
+ mocks.event?.({
+ type: 'comment',
+ data: JSON.stringify({
+ updateType: 'create-comment',
+ payload: { documentId },
+ }),
+ });
+ send('other');
+ mocks.event?.({ type: 'comment', data: 'not json' });
+ expect(mocks.annotations.getComments).toHaveBeenCalledTimes(1);
+ mocks.annotations.getComments.mockResolvedValue(
+ ok({ data: [{ thread: { threadId: 8 }, comments: [] }] })
+ );
+ send('sheet');
+ await waitFor(() => expect(state.query.data?.[0]?.thread.threadId).toBe(8));
+ expect(mocks.annotations.getComments).toHaveBeenCalledTimes(2);
+ client.clear();
+});
diff --git a/apps/web/src/features/block-spreadsheet/queries/spreadsheet-comments.ts b/apps/web/src/features/block-spreadsheet/queries/spreadsheet-comments.ts
new file mode 100644
index 0000000000..53fb62afde
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/queries/spreadsheet-comments.ts
@@ -0,0 +1,82 @@
+import { WebsocketConnectionState } from '@macro-inc/collaboration/websocket';
+import {
+ state as connectionState,
+ createConnectionWebsocketEffect,
+} from '@service-connection/websocket';
+import { storageServiceClient } from '@service-storage/client';
+import type { CreateCommentRequest } from '@service-storage/generated/schemas/createCommentRequest';
+import { useQuery, useQueryClient } from '@tanstack/solid-query';
+import { createEffect, on } from 'solid-js';
+import { spreadsheetCommentKeys } from './keys';
+
+/** Uses the document annotation routes: ownership, mentions, inbox and live events
+ * are handled by the same backend as document/task discussions. */
+export function spreadsheetCommentsApi(documentId: string) {
+ return {
+ async list() {
+ const result = await storageServiceClient.annotations.getComments({
+ documentId,
+ });
+ if (result.isErr()) throw new Error('Unable to load comments.');
+ return result.value.data;
+ },
+ async create(body: CreateCommentRequest) {
+ const result = await storageServiceClient.annotations.createComment({
+ documentId,
+ body,
+ });
+ if (result.isErr())
+ throw new Error('Unable to post comment. Your draft has been kept.');
+ return result.value;
+ },
+ async edit(commentId: number, threadId: number, text: string) {
+ const result = await storageServiceClient.annotations.editComment({
+ commentId,
+ body: { threadId, text },
+ });
+ if (result.isErr())
+ throw new Error('Unable to edit comment. Your draft has been kept.');
+ return result.value;
+ },
+ async delete(commentId: number) {
+ const result = await storageServiceClient.annotations.deleteComment({
+ commentId,
+ body: {},
+ });
+ if (result.isErr()) throw new Error('Unable to delete comment.');
+ return result.value;
+ },
+ };
+}
+
+export function useSpreadsheetComments(documentId: string) {
+ const api = spreadsheetCommentsApi(documentId);
+ const client = useQueryClient();
+ const queryKey = spreadsheetCommentKeys.document(documentId).queryKey;
+ const query = useQuery(() => ({
+ queryKey,
+ queryFn: api.list,
+ staleTime: 30_000,
+ }));
+ const refresh = () => client.invalidateQueries({ queryKey });
+ // Recover comments missed while the connection gateway was disconnected.
+ createEffect(
+ on(
+ connectionState,
+ (state) => {
+ if (state === WebsocketConnectionState.Open) void refresh();
+ },
+ { defer: true }
+ )
+ );
+ createConnectionWebsocketEffect((message) => {
+ if (message.type !== 'comment') return;
+ try {
+ const event = JSON.parse(message.data);
+ if (event?.payload?.documentId === documentId) void refresh();
+ } catch {
+ /* Ignore malformed connection events. */
+ }
+ });
+ return { query, api, refresh };
+}
diff --git a/apps/web/src/features/block-spreadsheet/queries/uploaded-workbook.test.ts b/apps/web/src/features/block-spreadsheet/queries/uploaded-workbook.test.ts
new file mode 100644
index 0000000000..6d72f708a3
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/queries/uploaded-workbook.test.ts
@@ -0,0 +1,100 @@
+import { Blob } from 'node:buffer';
+import { platformFetch } from '@core/util/platformFetch';
+import { getPresignedUrl } from '@service-storage/util/presignedUrl';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { uploadedWorkbookQuery } from './uploaded-workbook';
+
+vi.mock('@core/util/platformFetch', () => ({ platformFetch: vi.fn() }));
+vi.mock('@service-storage/util/presignedUrl', () => ({
+ getPresignedUrl: vi.fn(async () => 'https://storage.example/workbook'),
+}));
+const excel = vi.fn(async () => ({ sheets: [], warnings: [] }));
+const query = (fileType = 'xlsx', version = 1) =>
+ uploadedWorkbookQuery({ id: 'document', version, fileType }, excel);
+beforeEach(() => {
+ vi.clearAllMocks();
+ vi.stubGlobal('Blob', Blob);
+});
+afterEach(() => vi.unstubAllGlobals());
+
+describe('uploaded workbook retrieval', () => {
+ it('uses immutable document versions and decodes Excel with the cancellation signal', async () => {
+ const signal = new AbortController().signal;
+ vi.mocked(platformFetch).mockResolvedValueOnce(
+ new Response(new Uint8Array([1, 2, 3]))
+ );
+ await query().queryFn({ signal });
+ expect(getPresignedUrl).toHaveBeenCalledWith({
+ documentId: 'document',
+ versionId: 1,
+ });
+ expect(excel).toHaveBeenCalledWith(new Uint8Array([1, 2, 3]), signal);
+ expect(query().queryKey).not.toEqual(query('xlsx', 2).queryKey);
+ expect(query().queryKey).not.toEqual(query('csv').queryKey);
+ });
+ it('opens CSV text as safe typed cells, without invoking the Excel worker', async () => {
+ vi.mocked(platformFetch).mockResolvedValueOnce(
+ new Response('ID,Amount\r\n00123,12.5')
+ );
+ const result = await query('CSV').queryFn({
+ signal: new AbortController().signal,
+ });
+ expect(result.sheets[0].cells.A2.value).toBe("'00123");
+ expect(result.sheets[0].cells.B2.value).toBe('12.5');
+ expect(excel).not.toHaveBeenCalled();
+ });
+ it.each([
+ ['xlsx', 5 * 1024 * 1024 + 1],
+ ['csv', 1_000_001],
+ ] as const)(
+ 'rejects declared oversize %s before buffering the response',
+ async (type, size) => {
+ const cancel = vi.fn();
+ const stream = new ReadableStream({ cancel });
+ vi.mocked(platformFetch).mockResolvedValueOnce(
+ new Response(stream, { headers: { 'Content-Length': String(size) } })
+ );
+ await expect(
+ query(type).queryFn({ signal: new AbortController().signal })
+ ).rejects.toThrow(/limit/);
+ expect(cancel).toHaveBeenCalledOnce();
+ expect(excel).not.toHaveBeenCalled();
+ }
+ );
+ it('cancels a chunked oversized response, even when Content-Length is absent', async () => {
+ const cancel = vi.fn();
+ const stream = new ReadableStream({
+ start(controller) {
+ controller.enqueue(new Uint8Array(700_000));
+ controller.enqueue(new Uint8Array(700_000));
+ },
+ cancel,
+ });
+ vi.mocked(platformFetch).mockResolvedValueOnce(new Response(stream));
+ await expect(
+ query('csv').queryFn({ signal: new AbortController().signal })
+ ).rejects.toThrow(/limit/);
+ expect(cancel).toHaveBeenCalledOnce();
+ });
+ it('does not download an already cancelled request', async () => {
+ const controller = new AbortController();
+ controller.abort();
+ await expect(
+ query().queryFn({ signal: controller.signal })
+ ).rejects.toThrow();
+ expect(platformFetch).not.toHaveBeenCalled();
+ });
+ it('reports missing files and decoder failures without creating a document', async () => {
+ vi.mocked(platformFetch).mockResolvedValueOnce(
+ new Response('', { status: 404 })
+ );
+ await expect(
+ query().queryFn({ signal: new AbortController().signal })
+ ).rejects.toThrow(/not found/i);
+ vi.mocked(platformFetch).mockResolvedValueOnce(new Response('bad archive'));
+ excel.mockRejectedValueOnce(new Error('Invalid Excel workbook'));
+ await expect(
+ query().queryFn({ signal: new AbortController().signal })
+ ).rejects.toThrow('Invalid Excel workbook');
+ });
+});
diff --git a/apps/web/src/features/block-spreadsheet/queries/uploaded-workbook.ts b/apps/web/src/features/block-spreadsheet/queries/uploaded-workbook.ts
new file mode 100644
index 0000000000..c8ce8cd6e9
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/queries/uploaded-workbook.ts
@@ -0,0 +1,52 @@
+import { throwOnErr } from '@core/util/result';
+import { fetchPresignedBlobWithProgress } from '@service-storage/util/fetchPresigned';
+import { getPresignedUrl } from '@service-storage/util/presignedUrl';
+import { decodeCsv } from '../core/uploaded-workbook';
+import {
+ type WorkbookFileData,
+ XLSX_MAX_BYTES,
+} from '../core/workbook-file-types';
+import { uploadedWorkbookKeys } from './keys';
+
+/** Cache by immutable file version; a failed/cancelled import never writes a doc. */
+export function uploadedWorkbookQuery(
+ args: { id: string; version: number; fileType: string },
+ decodeExcel: (
+ bytes: Uint8Array,
+ signal: AbortSignal
+ ) => Promise<WorkbookFileData>
+) {
+ return {
+ queryKey: uploadedWorkbookKeys.file(args.id, args.version, args.fileType)
+ .queryKey,
+ staleTime: Infinity,
+ gcTime: 60_000,
+ retry: false,
+ queryFn: async ({ signal }: { signal: AbortSignal }) => {
+ const url = await getPresignedUrl({
+ documentId: args.id,
+ versionId: args.version,
+ });
+ const csv = args.fileType.toLowerCase() === 'csv';
+ signal.throwIfAborted();
+ const blob = await throwOnErr(() =>
+ fetchPresignedBlobWithProgress(
+ url,
+ () => {},
+ { signal },
+ csv ? 1_000_000 : XLSX_MAX_BYTES
+ )
+ );
+ if (!blob) throw new Error('This file is empty.');
+ if (blob.size > (csv ? 1_000_000 : XLSX_MAX_BYTES))
+ throw new Error(
+ csv
+ ? 'Import a CSV up to 1 MB.'
+ : 'Import an Excel workbook up to 5 MB.'
+ );
+ if (signal.aborted) throw new Error('Import cancelled.');
+ if (csv) return decodeCsv(await blob.text());
+ return decodeExcel(new Uint8Array(await blob.arrayBuffer()), signal);
+ },
+ };
+}
diff --git a/apps/web/src/features/block-spreadsheet/spreadsheet-cell-links.test.tsx b/apps/web/src/features/block-spreadsheet/spreadsheet-cell-links.test.tsx
new file mode 100644
index 0000000000..59fad0cc34
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/spreadsheet-cell-links.test.tsx
@@ -0,0 +1,65 @@
+import {
+ cleanup,
+ fireEvent,
+ render,
+ screen,
+ waitFor,
+} from '@solidjs/testing-library';
+import type { ParentProps } from 'solid-js';
+import { afterEach, expect, it, vi } from 'vitest';
+
+const open = vi.hoisted(() => vi.fn());
+vi.mock('@core/util/url', async (original) => ({
+ ...(await original<typeof import('@core/util/url')>()),
+ openExternalUrl: open,
+}));
+vi.mock('@core/signal/unfurl', () => ({
+ useUnfurl: (url: string) => [
+ () => ({ type: 'success', data: { url, title: 'Shared channel preview' } }),
+ ],
+}));
+vi.mock('@core/component/ScopedPortal', () => ({
+ ScopedPortal: (props: ParentProps) => props.children,
+}));
+vi.mock('@ui', () => ({
+ cn: (...parts: (string | undefined)[]) => parts.filter(Boolean).join(' '),
+}));
+
+import { SpreadsheetCellLinks } from './spreadsheet-cell-links';
+
+afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+});
+it('links URLs and email addresses in plain cell text with channel hover previews', async () => {
+ const text =
+ 'See https://www.linkedin.com/in/sridiptoghosh/, then https://x.com/example. Email [email protected]; [email protected]';
+ render(() => <SpreadsheetCellLinks value={text} />);
+ const links = screen.getAllByRole('link');
+ expect(links.map((a) => a.getAttribute('href'))).toEqual([
+ 'https://www.linkedin.com/in/sridiptoghosh/',
+ 'https://x.com/example',
+ 'mailto:[email protected]',
+ 'mailto:[email protected]',
+ ]);
+ expect(document.body.textContent).toBe(text);
+ fireEvent.mouseEnter(links[0]);
+ await screen.findByText('Shared channel preview');
+ fireEvent.mouseLeave(links[0]);
+ await waitFor(() =>
+ expect(screen.queryByText('Shared channel preview')).toBeNull()
+ );
+ fireEvent.click(links[0]);
+ expect(open).toHaveBeenCalledWith(
+ 'https://www.linkedin.com/in/sridiptoghosh/'
+ );
+ open.mockClear();
+ fireEvent.click(links[0], { ctrlKey: true });
+ expect(open).not.toHaveBeenCalled();
+});
+it('leaves other Markdown and unsafe protocols as literal text', () => {
+ const text = '**hello** javascript:alert(1) data:text/html,hello';
+ render(() => <SpreadsheetCellLinks value={text} />);
+ expect(screen.queryByRole('link')).toBeNull();
+ expect(document.body.textContent).toBe(text);
+});
diff --git a/apps/web/src/features/block-spreadsheet/spreadsheet-cell-links.tsx b/apps/web/src/features/block-spreadsheet/spreadsheet-cell-links.tsx
new file mode 100644
index 0000000000..df82d77d2f
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/spreadsheet-cell-links.tsx
@@ -0,0 +1,54 @@
+import { LinkWithPreview } from '@core/component/LexicalMarkdown/component/core/LinkWithPreview';
+import { findNextAutoLinkMatch } from '@core/component/LexicalMarkdown/plugins/links/linksPlugin';
+import { For } from 'solid-js';
+export function SpreadsheetCellLinks(props: { value: string }) {
+ const parts = () => {
+ const result: { text: string; url?: string }[] = [];
+ let remaining = props.value;
+ while (remaining) {
+ const web = findNextAutoLinkMatch(remaining);
+ // Email domains can use newer TLDs absent from linkify's bundled list.
+ const email = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i.exec(remaining);
+ const match =
+ email && (!web || email.index < web.index)
+ ? {
+ index: email.index,
+ lastIndex: email.index + email[0].length,
+ raw: email[0],
+ url: `mailto:${email[0]}`,
+ }
+ : web;
+ if (!match) {
+ result.push({ text: remaining });
+ break;
+ }
+ if (match.index) result.push({ text: remaining.slice(0, match.index) });
+ result.push({ text: match.raw, url: match.url });
+ remaining = remaining.slice(match.lastIndex);
+ }
+ return result;
+ };
+ return (
+ <For each={parts()}>
+ {(part) =>
+ part.url ? (
+ <span
+ onPointerDown={(event) => event.stopPropagation()}
+ onMouseDown={(event) => event.stopPropagation()}
+ onDblClick={(event) => event.stopPropagation()}
+ >
+ <LinkWithPreview
+ url={part.url}
+ title={part.text}
+ class="underline decoration-current/30 underline-offset-2 hover:decoration-current"
+ >
+ {part.text}
+ </LinkWithPreview>
+ </span>
+ ) : (
+ part.text
+ )
+ }
+ </For>
+ );
+}
diff --git a/apps/web/src/features/block-spreadsheet/spreadsheet-mentions.tsx b/apps/web/src/features/block-spreadsheet/spreadsheet-mentions.tsx
new file mode 100644
index 0000000000..7a6ba90ea1
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/spreadsheet-mentions.tsx
@@ -0,0 +1,106 @@
+import { DocumentMention } from '@core/component/LexicalMarkdown/component/decorator/DocumentMention';
+import { UserMention } from '@core/component/LexicalMarkdown/component/decorator/UserMention';
+import { MentionsMenu } from '@core/component/LexicalMarkdown/component/menu/MentionsMenu/MentionsMenu';
+import { getBlockNameFromEntity } from '@core/component/LexicalMarkdown/component/menu/MentionsMenu/utils/entityUtils';
+import { parseMacroAppUrl } from '@core/component/LexicalMarkdown/plugins/text-paste/textPastePlugin';
+import type { MentionItem } from '@core/component/LexicalMarkdown/utils/mentionsUtils';
+import {
+ cellTextParts,
+ encodeCellMention,
+} from '@macro-inc/spreadsheet/cell-mentions';
+import { For, Suspense } from 'solid-js';
+import { CellMentionEditor } from './components/CellMentionEditor';
+import type { SpreadsheetMentions } from './context/spreadsheet-mentions';
+import { SpreadsheetCellLinks } from './spreadsheet-cell-links';
+
+function linkMentions(value: string): string {
+ if (value.startsWith('=')) return value;
+ return cellTextParts(value)
+ .map((part) =>
+ part.mention
+ ? part.text
+ : part.text.replace(/https?:\/\/[^\s<>]+/g, (url) => {
+ const parsed = parseMacroAppUrl(url);
+ return parsed.isValid && parsed.id && parsed.block
+ ? encodeCellMention({
+ type: 'document',
+ documentId: parsed.id,
+ documentName: '',
+ blockName: parsed.block,
+ blockParams: parsed.params,
+ })
+ : url;
+ })
+ )
+ .join('');
+}
+function fromItem(item: MentionItem): string | undefined {
+ if (item.kind === 'user')
+ return encodeCellMention({
+ type: 'user',
+ userId: item.id,
+ email: item.data.email,
+ displayName: item.data.name,
+ });
+ if (item.kind === 'entity')
+ return encodeCellMention({
+ type: 'document',
+ documentId: item.id,
+ documentName: item.data.name ?? '',
+ blockName: getBlockNameFromEntity(item),
+ });
+}
+function CellMentions(props: { value: string }) {
+ return (
+ <For each={cellTextParts(linkMentions(props.value))}>
+ {(part) => {
+ const mention = part.mention;
+ if (!mention) return <SpreadsheetCellLinks value={part.text} />;
+ return (
+ <span
+ data-spreadsheet-mention
+ class="inline-block max-w-full align-bottom truncate"
+ onPointerDown={(event) => event.stopPropagation()}
+ onMouseDown={(event) => event.stopPropagation()}
+ onDblClick={(event) => event.stopPropagation()}
+ >
+ <Suspense
+ fallback={
+ mention.type === 'user'
+ ? mention.email
+ : mention.documentName || 'Linked item'
+ }
+ >
+ {mention.type === 'user' ? (
+ <UserMention {...mention} key="spreadsheet" theme={{}} />
+ ) : (
+ <DocumentMention {...mention} key="spreadsheet" theme={{}} />
+ )}
+ </Suspense>
+ </span>
+ );
+ }}
+ </For>
+ );
+}
+export const spreadsheetMentions: SpreadsheetMentions = {
+ renderText: (value) => <CellMentions value={value} />,
+ renderEditor: (props) => (
+ <CellMentionEditor
+ {...props}
+ convertPaste={linkMentions}
+ renderMenu={(menu, anchor, pick) => (
+ <MentionsMenu
+ menu={menu}
+ anchor={anchor}
+ sources={['users', 'documents', 'channels', 'emails']}
+ showOpenTabs={false}
+ onPick={(item) => {
+ const value = fromItem(item);
+ if (value) pick(value);
+ }}
+ />
+ )}
+ />
+ ),
+};
diff --git a/apps/web/src/features/block-spreadsheet/views/SpreadsheetEditor.tsx b/apps/web/src/features/block-spreadsheet/views/SpreadsheetEditor.tsx
index 859a848019..cfcc2285b9 100644
--- a/apps/web/src/features/block-spreadsheet/views/SpreadsheetEditor.tsx
+++ b/apps/web/src/features/block-spreadsheet/views/SpreadsheetEditor.tsx
@@ -1,10 +1,20 @@
import { isTouchDevice } from '@core/mobile/isTouchDevice';
import { Button } from '@ui/components/Button';
-import { createDeferred, createMemo, createSignal, For, Show } from 'solid-js';
+import {
+ createDeferred,
+ createEffect,
+ createMemo,
+ createSignal,
+ For,
+ on,
+ Show,
+} from 'solid-js';
import { match } from 'ts-pattern';
import { SpreadsheetFileMenu } from '../components/SpreadsheetActionMenus';
+import { SpreadsheetDialog } from '../components/SpreadsheetDialog';
import { SpreadsheetFindDialog } from '../components/SpreadsheetDialogs';
import { SpreadsheetGrid } from '../components/SpreadsheetGrid';
+import type { HeaderAction } from '../components/SpreadsheetHeaderMenu';
import { SpreadsheetSheetTabs } from '../components/SpreadsheetSheetTabs';
import {
FormulaBar,
@@ -14,15 +24,17 @@ import {
SpreadsheetImportDialog,
SpreadsheetSheetDialog,
} from '../components/SpreadsheetWorkbookDialogs';
+import type { SpreadsheetCommentsCapability } from '../context/spreadsheet-comments';
+import type { SpreadsheetMentions } from '../context/spreadsheet-mentions';
+import { encodeCsv } from '../core/csv-export';
import { formulaRangeReference } from '../core/formula-reference';
import {
cellAddress,
GRID_COLUMNS,
positionFromAddress,
- safeCsvValue,
selectionBounds,
- serializeTable,
} from '../core/grid-selection';
+import type { SpreadsheetCommentAnchor } from '../core/spreadsheet-comments';
import { SPREADSHEET_MAX_ROWS } from '../core/spreadsheet-document';
import { spreadsheetCursors } from '../core/spreadsheet-presence';
import type { SpreadsheetCommand } from '../core/toolbar-types';
@@ -36,8 +48,11 @@ import { createWorkbookActions } from '../primitives/create-workbook-actions';
export function SpreadsheetEditor(props: {
store: SpreadsheetStore;
+ mentions?: SpreadsheetMentions;
name: string;
autoFocus?: boolean;
+ commentLocation?: SpreadsheetCommentAnchor;
+ comments?: SpreadsheetCommentsCapability;
onExport: (content: string) => void;
onExportXlsx: (bytes: Uint8Array) => void;
}) {
@@ -47,7 +62,15 @@ export function SpreadsheetEditor(props: {
const [showGridlines, setShowGridlines] = createSignal(true);
const [showFormulaBar, setShowFormulaBar] = createSignal(true);
const [showFormulas, setShowFormulas] = createSignal(false);
- const editable = () => props.store.canEdit();
+ const [structureBusy, setStructureBusy] = createSignal(false);
+ const [resize, setResize] = createSignal<{
+ sheetId: string;
+ axis: 'row' | 'column';
+ start: number;
+ end: number;
+ }>();
+ const [resizeSize, setResizeSize] = createSignal('100');
+ const editable = () => props.store.canEdit() && !structureBusy();
const calculation = createCalculation(
props.store.cells,
props.store.rowCount,
@@ -59,6 +82,9 @@ export function SpreadsheetEditor(props: {
canEdit: editable,
sheetId: props.store.activeSheetId,
copyCells: calculation.copy,
+ hiddenRows: () => props.store.activeSheet().metadata?.hiddenRows ?? [],
+ hiddenColumns: () =>
+ props.store.activeSheet().metadata?.hiddenColumns ?? [],
});
const values = calculation.values;
const workbookActions = createWorkbookActions({
@@ -98,6 +124,34 @@ export function SpreadsheetEditor(props: {
gridElement
?.querySelector(`[data-address="${cellAddress(grid.selection().focus)}"]`)
?.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+ // Comment links drive the imperative grid selection and scroll without moving
+ // keyboard focus out of the comment composer.
+ createEffect(
+ on(
+ () => props.commentLocation,
+ (location) => {
+ if (!location) return;
+ const [start, end = start] = location.range.split(':');
+ const anchor = positionFromAddress(start);
+ const focus = positionFromAddress(end);
+ if (!anchor || !focus) return;
+ grid.commit();
+ props.store.setActiveSheet(location.sheetId);
+ queueMicrotask(() => {
+ grid.selectRange(anchor, focus);
+ revealSelection();
+ });
+ }
+ )
+ );
+ const addComment = () => {
+ grid.commit();
+ props.comments?.add(
+ gridElement?.querySelector<HTMLElement>(
+ `[data-address="${grid.activeAddress()}"]`
+ ) ?? undefined
+ );
+ };
const restoreEditorFocus = () => {
const pending = pendingMenuAction;
pendingMenuAction = undefined;
@@ -109,7 +163,9 @@ export function SpreadsheetEditor(props: {
)
return;
if (grid.editing() === 'cell') {
- const editor = gridElement?.querySelector('textarea');
+ const editor = gridElement?.querySelector<HTMLElement>(
+ 'textarea, [contenteditable=true]'
+ );
editor?.focus({ preventScroll: true });
} else focusGrid();
revealSelection();
@@ -170,29 +226,7 @@ export function SpreadsheetEditor(props: {
return;
}
if (calculation.busy() || calculation.error()) return;
- const positions = [
- ...new Set([
- ...Object.keys(props.store.cells()),
- ...Object.keys(values()),
- ]),
- ]
- .map(positionFromAddress)
- .filter((position) => position !== undefined);
- const bottom = Math.max(0, ...positions.map((position) => position.row));
- const right = Math.max(0, ...positions.map((position) => position.column));
- const rows = Array.from({ length: bottom + 1 }, (_, row) =>
- Array.from({ length: right + 1 }, (_, column) => {
- const address = cellAddress({ row, column });
- const value = values()[address];
- return safeCsvValue(
- value?.number !== undefined
- ? String(value.number)
- : (value?.display ?? props.store.cells()[address]?.value ?? ''),
- value?.number !== undefined
- );
- })
- );
- props.onExport(serializeTable(rows, ','));
+ props.onExport(encodeCsv(props.store.cells(), values()));
}
function command(action: SpreadsheetCommand) {
@@ -247,6 +281,123 @@ export function SpreadsheetEditor(props: {
.exhaustive();
}
+ async function headerAction(axis: 'row' | 'column', action: HeaderAction) {
+ grid.commit();
+ if (action === 'copy') {
+ command('copy');
+ return;
+ }
+ if (!editable()) return;
+ const area = selectionBounds(grid.selection());
+ const start = axis === 'row' ? area.top : area.left;
+ const end = axis === 'row' ? area.bottom : area.right;
+ const sheet = props.store.activeSheet();
+ actions.clearNotice();
+ try {
+ if (
+ action === 'insert-before' ||
+ action === 'insert-after' ||
+ action === 'delete'
+ ) {
+ const before = props.store.workbook();
+ setStructureBusy(true);
+ const next = await calculation.changeAxis(before, {
+ sheetId: sheet.id,
+ axis,
+ index: action === 'insert-after' ? end + 1 : start,
+ count: end - start + 1,
+ kind: action === 'delete' ? 'delete' : 'insert',
+ });
+ props.store.applyStructure(before, next);
+ } else if (action === 'resize') {
+ setResizeSize(
+ String(
+ axis === 'row'
+ ? Math.round(
+ ((sheet.metadata?.rowHeights?.[start] ?? 15.75) * 4) / 3
+ )
+ : (sheet.layout.columnWidths[start] ?? 100)
+ )
+ );
+ setResize({ sheetId: sheet.id, axis, start, end });
+ } else if (action === 'hide' || action === 'unhide') {
+ const key = axis === 'row' ? 'hiddenRows' : 'hiddenColumns';
+ const hidden =
+ action === 'unhide'
+ ? []
+ : [
+ ...new Set([
+ ...(sheet.metadata?.[key] ?? []),
+ ...Array.from(
+ { length: end - start + 1 },
+ (_, i) => start + i
+ ),
+ ]),
+ ];
+ if (
+ hidden.length >=
+ (axis === 'row' ? props.store.rowCount() : GRID_COLUMNS)
+ )
+ throw new Error(`Keep at least one ${axis} visible.`);
+ props.store.setMetadata({ ...sheet.metadata, [key]: hidden });
+ if (action === 'hide') {
+ const next = Array.from(
+ { length: axis === 'row' ? props.store.rowCount() : GRID_COLUMNS },
+ (_, i) => i
+ ).find((i) => !hidden.includes(i))!;
+ grid.select(
+ axis === 'row'
+ ? { row: next, column: area.left }
+ : { row: area.top, column: next }
+ );
+ }
+ } else if (action === 'autofit') {
+ const heights = { ...sheet.metadata?.rowHeights };
+ for (let row = start; row <= end; row++) delete heights[row];
+ props.store.setMetadata({ ...sheet.metadata, rowHeights: heights });
+ } else if (action === 'sort-asc' || action === 'sort-desc') {
+ await actions.sort(action === 'sort-desc', start);
+ } else command(action);
+ } catch (error) {
+ actions.setNotice(
+ error instanceof Error
+ ? error.message
+ : 'Unable to change rows or columns.'
+ );
+ } finally {
+ setStructureBusy(false);
+ }
+ }
+
+ function confirmResize() {
+ const selection = resize();
+ const value = Number(resizeSize());
+ if (
+ !selection ||
+ !editable() ||
+ props.store.activeSheetId() !== selection.sheetId
+ ) {
+ setResize(undefined);
+ return;
+ }
+ if (
+ !Number.isFinite(value) ||
+ value < (selection.axis === 'row' ? 21 : 64) ||
+ value > (selection.axis === 'row' ? 400 : 640)
+ )
+ return;
+ if (selection.axis === 'row') {
+ const metadata = props.store.activeSheet().metadata;
+ const heights = { ...metadata?.rowHeights };
+ for (let row = selection.start; row <= selection.end; row++)
+ heights[row] = (value * 3) / 4;
+ props.store.setMetadata({ ...metadata, rowHeights: heights });
+ } else
+ for (let column = selection.start; column <= selection.end; column++)
+ props.store.resizeColumn(column, value);
+ setResize(undefined);
+ }
+
async function importFile(file: File | undefined) {
if (!file || !editable()) return;
if (!/\.(csv|xlsx)$/i.test(file.name)) {
@@ -304,6 +455,50 @@ export function SpreadsheetEditor(props: {
}
}}
>
+ <SpreadsheetDialog
+ open={!!resize()}
+ onOpenChange={(open) => {
+ if (!open) setResize(undefined);
+ }}
+ onRestoreFocus={focusGrid}
+ position="center"
+ class="w-80"
+ >
+ <form
+ class="p-5 text-sm"
+ onSubmit={(event) => {
+ event.preventDefault();
+ confirmResize();
+ }}
+ onKeyDown={(event) => event.stopPropagation()}
+ >
+ <SpreadsheetDialog.Title class="font-semibold">
+ Resize {resize()?.axis}s
+ </SpreadsheetDialog.Title>
+ <SpreadsheetDialog.Description class="my-3 text-ink-muted">
+ Enter the size in pixels.
+ </SpreadsheetDialog.Description>
+ <input
+ aria-label="Size in pixels"
+ type="number"
+ required
+ min={resize()?.axis === 'row' ? 21 : 64}
+ max={resize()?.axis === 'row' ? 400 : 640}
+ value={resizeSize()}
+ onInput={(event) => setResizeSize(event.currentTarget.value)}
+ onFocus={(event) => event.currentTarget.select()}
+ class="w-full rounded border border-edge-muted bg-input px-3 py-2 outline-none focus:border-accent"
+ />
+ <div class="mt-4 flex justify-end gap-2">
+ <Button type="button" onClick={() => setResize(undefined)}>
+ Cancel
+ </Button>
+ <Button type="submit" variant="accent">
+ Apply
+ </Button>
+ </div>
+ </form>
+ </SpreadsheetDialog>
<Show when={props.store.error()}>
{(error) => (
<div
@@ -334,6 +529,8 @@ export function SpreadsheetEditor(props: {
)}
</Show>
<SpreadsheetToolbar
+ onComment={props.comments ? addComment : undefined}
+ canComment={props.comments?.canComment()}
readonly={!editable() || actions.pending() || !!workbookActions.busy()}
canUndo={props.store.canUndo()}
canRedo={props.store.canRedo()}
@@ -364,6 +561,7 @@ export function SpreadsheetEditor(props: {
/>
<Show when={showFormulaBar() || (isTouchDevice() && !!grid.editing())}>
<FormulaBar
+ mentions={props.mentions}
editing={!!grid.editing()}
complete={calculation.complete}
selectionRequest={grid.editorSelection()}
@@ -410,6 +608,7 @@ export function SpreadsheetEditor(props: {
}
>
<SpreadsheetGrid
+ mentions={props.mentions}
sheetId={props.store.activeSheetId()}
complete={calculation.complete}
cells={props.store.cells()}
@@ -418,11 +617,18 @@ export function SpreadsheetEditor(props: {
showFormulas={showFormulas()}
rowCount={props.store.rowCount()}
columnWidths={props.store.layout().columnWidths}
+ rowHeights={props.store.activeSheet().metadata?.rowHeights}
+ hiddenRows={props.store.activeSheet().metadata?.hiddenRows}
+ hiddenColumns={props.store.activeSheet().metadata?.hiddenColumns}
+ canChangeStructure={props.store.canChangeStructure()}
+ onCellAction={command}
+ onHeaderAction={(axis, action) => void headerAction(axis, action)}
onResizeColumn={props.store.resizeColumn}
onFill={grid.fill}
onCopyMetadata={grid.copyMetadata}
values={values()}
remoteCursors={remoteCursors()}
+ comments={props.comments}
selection={grid.selection()}
editing={grid.editing() === 'cell'}
formulaEditing={grid.editing() === 'formula'}
@@ -460,6 +666,17 @@ export function SpreadsheetEditor(props: {
command('find');
return;
}
+ if (
+ (event.metaKey || event.ctrlKey) &&
+ event.altKey &&
+ (event.code === 'KeyM' || event.key.toLowerCase() === 'm') &&
+ props.comments?.canComment()
+ ) {
+ event.preventDefault();
+ event.stopPropagation();
+ addComment();
+ return;
+ }
grid.keyDown(event);
}}
onCopy={actions.copyText}
diff --git a/apps/web/src/features/block-spreadsheet/views/UploadedWorkbook.test.tsx b/apps/web/src/features/block-spreadsheet/views/UploadedWorkbook.test.tsx
new file mode 100644
index 0000000000..ac5f9627f7
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/views/UploadedWorkbook.test.tsx
@@ -0,0 +1,187 @@
+import {
+ cleanup,
+ fireEvent,
+ render,
+ screen,
+ waitFor,
+} from '@solidjs/testing-library';
+import { QueryClient, QueryClientProvider } from '@tanstack/solid-query';
+import { LoroDoc } from 'loro-crdt';
+import { type JSX, Suspense } from 'solid-js';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { readSpreadsheetWorkbook } from '../core/workbook-document';
+import type { SpreadsheetStore } from '../primitives/create-spreadsheet-store';
+
+vi.mock('../spreadsheet-mentions', () => ({ spreadsheetMentions: undefined }));
+const mocks = vi.hoisted(() => ({
+ load: vi.fn(),
+ create: vi.fn(),
+ save: vi.fn(),
+ replace: vi.fn(),
+ failure: vi.fn(),
+ download: vi.fn(),
+}));
+vi.mock('@core/block', () => ({ useBlockId: () => 'original-upload' }));
+vi.mock('@core/signal/load', () => ({
+ blockMetadataSignal: {
+ get: () => ({ documentVersionId: 7, fileType: 'xlsx' }),
+ },
+}));
+vi.mock('@core/util/currentBlockDocumentName', () => ({
+ useBlockDocumentName: () => () => 'Imported budget',
+}));
+vi.mock('@components/app/split-layout/layoutUtils', () => ({
+ useSplitPanelOrThrow: () => ({ handle: { replace: mocks.replace } }),
+}));
+vi.mock('@core/component/Toast/Toast', () => ({
+ toast: { failure: mocks.failure },
+}));
+vi.mock('@filesystem/download', () => ({ downloadFile: mocks.download }));
+vi.mock('../queries/create-spreadsheet', () => ({
+ createSpreadsheetDocument: mocks.create,
+}));
+vi.mock('../queries/save-spreadsheet-draft', () => ({
+ saveSpreadsheetDraft: mocks.save,
+}));
+vi.mock('../primitives/workbook-file-client', () => ({
+ importWorkbookFile: vi.fn(),
+}));
+vi.mock('../queries/uploaded-workbook', () => ({
+ uploadedWorkbookQuery: () => ({
+ queryKey: ['uploaded-workbook-test'],
+ queryFn: mocks.load,
+ retry: false,
+ }),
+}));
+vi.mock('@ui', () => ({
+ Button: (props: JSX.ButtonHTMLAttributes<HTMLButtonElement>) => (
+ <button type="button" disabled={props.disabled} onClick={props.onClick}>
+ {props.children}
+ </button>
+ ),
+}));
+vi.mock('./SpreadsheetEditor', () => ({
+ SpreadsheetEditor: (props: { store: SpreadsheetStore }) => (
+ <div>
+ <span>{props.store.cells().A1?.value}</span>
+ <button type="button" disabled={!props.store.canEdit()}>
+ Edit cell
+ </button>
+ </div>
+ ),
+}));
+
+import UploadedWorkbook from './UploadedWorkbook';
+
+const clients: QueryClient[] = [];
+const imported = {
+ sheets: [
+ {
+ name: 'Forecast',
+ cells: {
+ A1: { value: '=SUM(B1:C1)', numberFormat: '#,##0.00' },
+ B1: { value: '12.5' },
+ C1: { value: '2.5' },
+ },
+ rowCount: 200,
+ columnWidths: {},
+ metadata: {
+ merges: ['A2:C2'],
+ definedNames: [{ name: 'Rate', formula: '0.1' }],
+ },
+ },
+ ],
+ warnings: ['Charts are not imported.'],
+};
+function mount() {
+ const client = new QueryClient();
+ clients.push(client);
+ return render(() => (
+ <QueryClientProvider client={client}>
+ <Suspense fallback={<div>Outer fallback</div>}>
+ <UploadedWorkbook />
+ </Suspense>
+ </QueryClientProvider>
+ ));
+}
+beforeEach(() => {
+ vi.clearAllMocks();
+ mocks.load.mockResolvedValue(imported);
+ mocks.create.mockResolvedValue('native-copy');
+ mocks.save.mockResolvedValue(undefined);
+});
+afterEach(() => {
+ cleanup();
+ for (const client of clients.splice(0)) client.clear();
+});
+
+it('loads without suspending its host, exposes import notes, and preserves all data in the durably saved copy', async () => {
+ let finish: (value: typeof imported) => void = () => {};
+ mocks.load.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ finish = resolve;
+ })
+ );
+ mount();
+ expect(screen.getByText('Opening spreadsheet…')).toBeTruthy();
+ expect(screen.queryByText('Outer fallback')).toBeNull();
+ expect(mocks.create).not.toHaveBeenCalled();
+ finish(imported);
+ await screen.findByText('=SUM(B1:C1)');
+ expect(
+ screen.getByRole('button', { name: 'Edit cell' }).hasAttribute('disabled')
+ ).toBe(true);
+ expect(screen.getByText('Charts are not imported.')).toBeTruthy();
+ let acknowledge = () => {};
+ mocks.save.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ acknowledge = resolve;
+ })
+ );
+ fireEvent.click(screen.getByRole('button', { name: 'Edit in Macro' }));
+ await waitFor(() => expect(mocks.save).toHaveBeenCalledOnce());
+ expect(mocks.replace).not.toHaveBeenCalled();
+ const doc = new LoroDoc();
+ try {
+ doc.import(mocks.save.mock.calls[0][1]);
+ const [sheet] = readSpreadsheetWorkbook(doc);
+ expect(sheet.cells).toEqual(imported.sheets[0].cells);
+ expect(sheet.metadata).toEqual(imported.sheets[0].metadata);
+ } finally {
+ doc.free();
+ }
+ expect(mocks.create).toHaveBeenCalledWith({
+ title: 'Imported budget',
+ source: 'spreadsheet-upload',
+ });
+ acknowledge();
+ await waitFor(() =>
+ expect(mocks.replace).toHaveBeenCalledWith({
+ next: { type: 'spreadsheet', id: 'native-copy' },
+ mergeHistory: true,
+ referredFrom: 'entity-actions-menu',
+ })
+ );
+});
+it('keeps the source preview and retries the same copy after a failed durable save', async () => {
+ mocks.save.mockRejectedValueOnce(new Error('Disconnected'));
+ mount();
+ fireEvent.click(await screen.findByRole('button', { name: 'Edit in Macro' }));
+ await waitFor(() => expect(mocks.failure).toHaveBeenCalledOnce());
+ expect(screen.getByText('=SUM(B1:C1)')).toBeTruthy();
+ expect(mocks.replace).not.toHaveBeenCalled();
+ fireEvent.click(screen.getByRole('button', { name: 'Edit in Macro' }));
+ await waitFor(() => expect(mocks.replace).toHaveBeenCalledOnce());
+ expect(mocks.create).toHaveBeenCalledOnce();
+});
+it('shows import failures without offering conversion, and allows retry', async () => {
+ mocks.load.mockRejectedValueOnce(new Error('Unsupported workbook'));
+ mount();
+ await screen.findByText('Unsupported workbook');
+ expect(screen.queryByRole('button', { name: 'Edit in Macro' })).toBeNull();
+ expect(mocks.create).not.toHaveBeenCalled();
+ fireEvent.click(screen.getByRole('button', { name: 'Try again' }));
+ await screen.findByText('=SUM(B1:C1)');
+});
diff --git a/apps/web/src/features/block-spreadsheet/views/UploadedWorkbook.tsx b/apps/web/src/features/block-spreadsheet/views/UploadedWorkbook.tsx
new file mode 100644
index 0000000000..e42cdc927c
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/views/UploadedWorkbook.tsx
@@ -0,0 +1,138 @@
+import { useSplitPanelOrThrow } from '@components/app/split-layout/layoutUtils';
+import { useBlockId } from '@core/block';
+import { toast } from '@core/component/Toast/Toast';
+import { blockMetadataSignal } from '@core/signal/load';
+import { useBlockDocumentName } from '@core/util/currentBlockDocumentName';
+import { downloadFile } from '@filesystem/download';
+import { createQuery } from '@tanstack/solid-query';
+import { Button } from '@ui';
+import { For, Show } from 'solid-js';
+import { importSpreadsheetSheets } from '../core/workbook-document';
+import type { WorkbookFileData } from '../core/workbook-file-types';
+import { createDraftActions } from '../primitives/create-draft-actions';
+import { createLocalSpreadsheetSource } from '../primitives/create-local-spreadsheet-source';
+import { createSpreadsheetStore } from '../primitives/create-spreadsheet-store';
+import { importWorkbookFile } from '../primitives/workbook-file-client';
+import { createSpreadsheetDocument } from '../queries/create-spreadsheet';
+import { saveSpreadsheetDraft } from '../queries/save-spreadsheet-draft';
+import { uploadedWorkbookQuery } from '../queries/uploaded-workbook';
+import { spreadsheetMentions } from '../spreadsheet-mentions';
+import { SpreadsheetEditor } from './SpreadsheetEditor';
+
+/** Used by both the old /unknown URLs and CSV blocks, including channel splits. */
+export default function UploadedWorkbook() {
+ const id = useBlockId();
+ const query = createQuery(() =>
+ uploadedWorkbookQuery(
+ {
+ id,
+ version: blockMetadataSignal.get()?.documentVersionId ?? 0,
+ fileType: blockMetadataSignal.get()?.fileType ?? '',
+ },
+ importWorkbookFile
+ )
+ );
+ return (
+ <Show
+ when={query.isSuccess ? query.data : undefined}
+ keyed
+ fallback={
+ <div
+ class="flex size-full flex-col items-center justify-center gap-3 p-6 text-sm text-ink-muted"
+ role="status"
+ >
+ <span>
+ {query.isError
+ ? query.error instanceof Error
+ ? query.error.message
+ : 'Unable to open this workbook.'
+ : 'Opening spreadsheet…'}
+ </span>
+ <Show when={query.isError}>
+ <Button size="sm" onClick={() => void query.refetch()}>
+ Try again
+ </Button>
+ </Show>
+ </div>
+ }
+ >
+ {(workbook) => <UploadedWorkbookPreview workbook={workbook} />}
+ </Show>
+ );
+}
+
+function UploadedWorkbookPreview(props: { workbook: WorkbookFileData }) {
+ const panel = useSplitPanelOrThrow();
+ const name = useBlockDocumentName('Imported spreadsheet');
+ const source = createLocalSpreadsheetSource();
+ importSpreadsheetSheets(source.doc()!, props.workbook.sheets, true);
+ const store = createSpreadsheetStore({ source, canEdit: () => false });
+ const actions = createDraftActions({
+ snapshot: () => source.doc()?.export({ mode: 'snapshot' }),
+ context: () => ({}),
+ createDocument: () =>
+ createSpreadsheetDocument({
+ title: name(),
+ source: 'spreadsheet-upload',
+ }),
+ saveDocument: saveSpreadsheetDraft,
+ openChat: async () => false,
+ openDocument: (id) =>
+ panel.handle.replace({
+ next: { type: 'spreadsheet', id },
+ mergeHistory: true,
+ referredFrom: 'entity-actions-menu',
+ }),
+ onSaveFailure: () =>
+ toast.failure('Could not save spreadsheet', {
+ subtext: 'Your original file is unchanged. Try converting again.',
+ }),
+ });
+ return (
+ <div class="flex size-full min-h-0 flex-col">
+ <div class="flex shrink-0 flex-wrap items-center justify-between gap-2 border-b border-edge-muted px-3 py-2 text-xs text-ink-muted">
+ <span>
+ Uploaded workbook · Convert to edit and collaborate. The original file
+ stays available.
+ </span>
+ <Button
+ size="sm"
+ variant="accent"
+ disabled={!!actions.pending()}
+ onClick={() => void actions.edit()}
+ >
+ {actions.pending() ? 'Saving…' : 'Edit in Macro'}
+ </Button>
+ <Show when={props.workbook.warnings.length}>
+ <details class="w-full">
+ <summary>Import notes ({props.workbook.warnings.length})</summary>
+ <ul class="list-disc pl-5 pt-2">
+ <For each={props.workbook.warnings}>
+ {(warning) => <li>{warning}</li>}
+ </For>
+ </ul>
+ </details>
+ </Show>
+ </div>
+ <SpreadsheetEditor
+ mentions={spreadsheetMentions}
+ store={store}
+ name={name()}
+ onExportXlsx={(bytes) =>
+ downloadFile(
+ new Blob([bytes.slice().buffer], {
+ type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+ }),
+ `${name()}.xlsx`
+ )
+ }
+ onExport={(content) =>
+ downloadFile(
+ new Blob([content], { type: 'text/csv;charset=utf-8' }),
+ `${name()}.csv`
+ )
+ }
+ />
+ </div>
+ );
+}
diff --git a/apps/web/src/features/block-spreadsheet/workers/calculation.worker.ts b/apps/web/src/features/block-spreadsheet/workers/calculation.worker.ts
index 467dd7cd71..8d859e1884 100644
--- a/apps/web/src/features/block-spreadsheet/workers/calculation.worker.ts
+++ b/apps/web/src/features/block-spreadsheet/workers/calculation.worker.ts
@@ -17,6 +17,11 @@ self.onmessage = async (event: MessageEvent<CalculationRequest>) => {
} satisfies CalculationResponse);
response = match(request)
.returnType<CalculationResponse>()
+ .with({ type: 'change-axis' }, (operation) => ({
+ id: operation.id,
+ type: 'change-axis',
+ sheets: engine.changeAxis(operation.sheets, operation.change),
+ }))
.with({ type: 'calculate' }, (operation) => ({
id: operation.id,
type: 'calculate',
@@ -25,7 +30,9 @@ self.onmessage = async (event: MessageEvent<CalculationRequest>) => {
.with({ type: 'calculate-workbook' }, (operation) => ({
id: operation.id,
type: 'calculate-workbook',
- values: engine.calculateWorkbook(operation.sheets),
+ values: engine.calculateWorkbook(operation.sheets, {
+ includeTypes: true,
+ }),
}))
.with({ type: 'copy' }, (operation) => ({
id: operation.id,
diff --git a/apps/web/src/features/block-unknown/component/Block.tsx b/apps/web/src/features/block-unknown/component/Block.tsx
index b04933f026..adabfff00b 100644
--- a/apps/web/src/features/block-unknown/component/Block.tsx
+++ b/apps/web/src/features/block-unknown/component/Block.tsx
@@ -2,17 +2,25 @@ import { FileSidePanelSections, SidePanel } from '@components/app/side-panel';
import { DocumentBlockContainer } from '@core/component/DocumentBlockContainer';
import { toast } from '@core/component/Toast/Toast';
import { useShareDialogContext } from '@core/component/TopBar/ShareButton';
+import { blockMetadataSignal } from '@core/signal/load';
import {
useBlockDocumentDownloadName,
useBlockDocumentName,
} from '@core/util/currentBlockDocumentName';
import { downloadFile } from '@filesystem/download';
import { createCallback } from '@solid-primitives/rootless';
+import { lazy, Show, Suspense } from 'solid-js';
+import { isUploadedWorkbook } from '../../block-spreadsheet/core/uploaded-workbook';
+import { useSpreadsheetAccess } from '../../block-spreadsheet/primitives/use-spreadsheet-access';
import { useGetFileBlob } from '../signal/blockData';
import { ModalsProvider } from './ModalsProvider';
import { TopBar } from './TopBar';
import { UnknownContent } from './UnknownContent';
+const UploadedWorkbook = lazy(
+ () => import('../../block-spreadsheet/views/UploadedWorkbook')
+);
+
export default function BlockUnknown() {
return (
<DocumentBlockContainer>
@@ -26,6 +34,9 @@ export default function BlockUnknown() {
}
function BlockUnknownContent() {
+ const enabled = useSpreadsheetAccess();
+ const spreadsheet = () =>
+ enabled() && isUploadedWorkbook(blockMetadataSignal.get()?.fileType);
const fileName = useBlockDocumentName();
const downloadName = useBlockDocumentDownloadName();
const shareCtx = useShareDialogContext();
@@ -42,18 +53,31 @@ function BlockUnknownContent() {
});
return (
- <SidePanel.Layout>
+ <SidePanel.Layout defaultOpen={!spreadsheet()}>
<FileSidePanelSections />
<div class="flex size-full min-w-0 flex-col overflow-hidden">
<div class="relative">
<TopBar />
</div>
<div class="w-full grow relative overflow-hidden">
- <UnknownContent
- fileName={fileName()}
- onShare={shareCtx.open}
- onDownload={() => void downloadDocument()}
- />
+ <Show
+ when={spreadsheet()}
+ fallback={
+ <UnknownContent
+ fileName={fileName()}
+ onShare={shareCtx.open}
+ onDownload={() => void downloadDocument()}
+ />
+ }
+ >
+ <Suspense
+ fallback={
+ <div class="p-6 text-ink-muted">Opening spreadsheet…</div>
+ }
+ >
+ <UploadedWorkbook />
+ </Suspense>
+ </Show>
</div>
</div>
</SidePanel.Layout>
diff --git a/apps/web/src/features/drive-view/components/DriveDetailView.tsx b/apps/web/src/features/drive-view/components/DriveDetailView.tsx
index 6f05cdf92d..579650e70f 100644
--- a/apps/web/src/features/drive-view/components/DriveDetailView.tsx
+++ b/apps/web/src/features/drive-view/components/DriveDetailView.tsx
@@ -11,7 +11,7 @@ import {
entityDetailTarget,
useEntityDetailNavigationStack,
} from '@app/components/entity-detail/EntityDetailNavigationStack';
-import { ViewShell } from '@app/components/view-shell';
+import { ViewBreadcrumbs, ViewShell } from '@app/components/view-shell';
import { MarkdownDetailBreadcrumbItem } from '@block-md/component/MarkdownDetailBreadcrumbItem';
import type { MarkdownDocumentKind } from '@block-md/types';
import { SidePanel } from '@components/app/side-panel';
@@ -159,6 +159,18 @@ function StackEntityDetail(props: {
target={props.entry.data}
shareOpen={props.shareOpen}
onShareOpenChange={props.onShareOpenChange}
+ previewHeaderLeading={
+ <Show
+ when={entityDetailBlockType(props.entry.data) === 'spreadsheet'}
+ >
+ <DriveBreadcrumbsOutlet
+ aria-label="File location"
+ class="max-w-[min(40vw,24rem)] overflow-hidden"
+ >
+ <ViewBreadcrumbs.Separator />
+ </DriveBreadcrumbsOutlet>
+ </Show>
+ }
>
{(context) => (
<FileDetailBreadcrumbItem
@@ -192,6 +204,13 @@ function StackEntityDetail(props: {
export function DriveDetailView(props: { breadcrumbOrderOffset: number }) {
const [shareOpen, setShareOpen] = createSignal(false);
+ const navigationStack = useEntityDetailNavigationStack();
+ // Spreadsheets use their live block in PreviewPanel, which supplies its own
+ // header, sharing controls and the enclosing ViewShell's sidebar toggle.
+ const hasBlockHeader = () => {
+ const target = navigationStack.active()?.data;
+ return target && entityDetailBlockType(target) === 'spreadsheet';
+ };
return (
<ShareDialogContext.Provider
@@ -206,7 +225,9 @@ export function DriveDetailView(props: { breadcrumbOrderOffset: number }) {
/>
<SidePanel.Root>
<div class="flex size-full min-h-0 min-w-0 flex-col overflow-hidden">
- <DriveDetailTopBar />
+ <Show when={!hasBlockHeader()}>
+ <DriveDetailTopBar />
+ </Show>
<div class="relative min-h-0 min-w-0 flex-1">
<EntityDetailNavigationStack.Outlet>
{(entry, state) => (
diff --git a/apps/web/src/features/inbox-view/components/InboxList.tsx b/apps/web/src/features/inbox-view/components/InboxList.tsx
index d9bb238747..9a90606627 100644
--- a/apps/web/src/features/inbox-view/components/InboxList.tsx
+++ b/apps/web/src/features/inbox-view/components/InboxList.tsx
@@ -347,6 +347,7 @@ export function InboxList(props: InboxListProps) {
});
useEntityActionHotkeys({
+ enableDeleteHotkey: false,
scopeId: panel.splitHotkeyScope,
list: actionState,
selectedEntities,
diff --git a/apps/web/src/features/next-soup/actions/use-entity-action-hotkeys.ts b/apps/web/src/features/next-soup/actions/use-entity-action-hotkeys.ts
index bcdd854c9b..299f8e59c6 100644
--- a/apps/web/src/features/next-soup/actions/use-entity-action-hotkeys.ts
+++ b/apps/web/src/features/next-soup/actions/use-entity-action-hotkeys.ts
@@ -51,6 +51,8 @@ type UseEntityActionHotkeysOptions = {
| EntityActionNavigationHandler
| undefined;
condition?: () => boolean;
+ /** Home previews reserve Delete/Backspace for the open editor. */
+ enableDeleteHotkey?: boolean;
};
export const useEntityActionHotkeys = (
@@ -291,31 +293,33 @@ export const useEntityActionHotkeys = (
tags: [HotkeyTags.SelectionModification],
}).withGroup(group);
- // Delete - 'delete', 'backspace'
- registerHotkey({
- hotkey: ['delete', 'backspace'],
- hotkeyToken: TOKENS.entity.action.delete,
- scopeId,
- description: () => {
- const count = getEntitiesForAction().length;
- return count > 1 ? 'Delete items' : 'Delete item';
- },
- keyDownHandler: () => {
- const entities = getEntitiesForAction();
- if (entities.length === 0) return false;
- if (!entities.every(deleteAction.canExecute)) return false;
+ if (options.enableDeleteHotkey !== false) {
+ // Delete - 'delete', 'backspace'
+ registerHotkey({
+ hotkey: ['delete', 'backspace'],
+ hotkeyToken: TOKENS.entity.action.delete,
+ scopeId,
+ description: () => {
+ const count = getEntitiesForAction().length;
+ return count > 1 ? 'Delete items' : 'Delete item';
+ },
+ keyDownHandler: () => {
+ const entities = getEntitiesForAction();
+ if (entities.length === 0) return false;
+ if (!entities.every(deleteAction.canExecute)) return false;
- deleteAction.executeWithSoup(entities, list);
- return true;
- },
- condition: () => {
- if (condition && !condition()) return false;
- const entities = getEntitiesForAction();
- return entities.length > 0 && entities.every(deleteAction.canExecute);
- },
- displayPriority: 10,
- tags: [HotkeyTags.SelectionModification],
- }).withGroup(group);
+ deleteAction.executeWithSoup(entities, list);
+ return true;
+ },
+ condition: () => {
+ if (condition && !condition()) return false;
+ const entities = getEntitiesForAction();
+ return entities.length > 0 && entities.every(deleteAction.canExecute);
+ },
+ displayPriority: 10,
+ tags: [HotkeyTags.SelectionModification],
+ }).withGroup(group);
+ }
/**
* Whether 'r' should open the reminder editor rather than rename.
diff --git a/apps/web/src/features/notifications/notification-navigation.ts b/apps/web/src/features/notifications/notification-navigation.ts
index b1d9269551..6ae620d912 100644
--- a/apps/web/src/features/notifications/notification-navigation.ts
+++ b/apps/web/src/features/notifications/notification-navigation.ts
@@ -174,7 +174,8 @@ function safeDocumentContentToBlockName(
function resolveBlockCommentParamName(type: BlockName | BlockAlias) {
const resolved = resolveBlockAlias(type);
- if (resolved === 'md') return MD_URL_PARAMS.commentId;
+ if (resolved === 'md' || resolved === 'spreadsheet')
+ return MD_URL_PARAMS.commentId;
if (resolved === 'pdf') return PDF_URL_PARAMS.annotationId;
}
diff --git a/apps/web/src/features/notifications/tests/spreadsheet-comment-navigation.test.ts b/apps/web/src/features/notifications/tests/spreadsheet-comment-navigation.test.ts
new file mode 100644
index 0000000000..6712d6e4f9
--- /dev/null
+++ b/apps/web/src/features/notifications/tests/spreadsheet-comment-navigation.test.ts
@@ -0,0 +1,95 @@
+vi.mock('../notification-helpers', () => ({
+ isChannelNotification: () => false,
+}));
+vi.mock('../notification-source', () => ({
+ CHANNEL_EVENT_TYPES: [
+ 'channel_mention',
+ 'channel_message_send',
+ 'channel_message_reply',
+ 'document_mention',
+ ],
+}));
+vi.mock('../notification-stacking', () => ({
+ getMostRecentNotification: vi.fn(),
+ stackNotifications: vi.fn(),
+}));
+
+import type { SplitManager } from '@components/app/split-layout/layoutManager';
+import { expect, it, vi } from 'vitest';
+import type { UnifiedNotification } from '../types';
+
+vi.mock('@block-calendar/calendar-range', () => ({
+ createCalendarBlockRange: vi.fn(),
+}));
+vi.mock('@block-channel/utils/link', () => ({
+ getChannelParams: vi.fn(),
+ navigateToChannelMessage: vi.fn(),
+}));
+vi.mock('@core/constant/allBlocks', () => ({
+ itemToBlockName: (value: { fileType: string }) => value.fileType,
+ resolveBlockAlias: (type: string) => (type === 'task' ? 'md' : type),
+}));
+vi.mock('@core/constant/featureFlags', () => ({
+ enableCalendarUi: false,
+ enableReminders: false,
+ isFeatureEnabled: vi.fn(),
+ USE_MACRO_PR_SUMMARY_BLOCK: true,
+}));
+vi.mock('@core/util/url', () => ({ openExternalUrl: vi.fn() }));
+vi.mock('@queries/notification/user-notifications', () => ({
+ getNotificationById: vi.fn(),
+}));
+vi.mock('@queries/reminders/reminders', () => ({ getReminderById: vi.fn() }));
+vi.mock('../notification-resolvers', () => ({
+ DefaultNotificationBlockNameResolver: vi.fn(),
+}));
+
+import { openNotification } from '../notification-navigation';
+
+it.each([
+ 'commented_on_document',
+ 'mentioned_in_document_comment',
+ 'replied_to_document_comment_thread',
+] as const)(
+ 'opens %s at the spreadsheet comment, including an already open sheet',
+ async (tag) => {
+ const navigate = vi.fn();
+ const open = vi.fn();
+ const activate = vi.fn();
+ const layout = {
+ getSplitByContent: vi.fn(() => undefined as unknown),
+ openWithSplit: open,
+ getOrchestrator: () => ({
+ getBlockHandle: async () => ({ goToLocationFromParams: navigate }),
+ }),
+ };
+ const notification = {
+ entity_id: 'sheet-doc',
+ notification_metadata: {
+ tag,
+ content: { fileType: 'spreadsheet', commentId: 42, threadId: 7 },
+ },
+ } as UnifiedNotification;
+ const result = await openNotification(
+ notification,
+ layout as unknown as SplitManager
+ );
+ expect(result.isOk()).toBe(true);
+ await vi.waitFor(() =>
+ expect(navigate).toHaveBeenCalledWith({ comment_id: '42' })
+ );
+ expect(open).toHaveBeenCalledWith(
+ { type: 'spreadsheet', id: 'sheet-doc' },
+ expect.anything()
+ );
+ layout.getSplitByContent.mockReturnValue({ activate });
+ open.mockClear();
+ navigate.mockClear();
+ await openNotification(notification, layout as unknown as SplitManager);
+ await vi.waitFor(() =>
+ expect(navigate).toHaveBeenCalledWith({ comment_id: '42' })
+ );
+ expect(activate).toHaveBeenCalledOnce();
+ expect(open).not.toHaveBeenCalled();
+ }
+);
diff --git a/apps/web/src/lib/core/comments/discussion/Discussion.tsx b/apps/web/src/lib/core/comments/discussion/Discussion.tsx
index 37f7ae16a1..8b72bea501 100644
--- a/apps/web/src/lib/core/comments/discussion/Discussion.tsx
+++ b/apps/web/src/lib/core/comments/discussion/Discussion.tsx
@@ -18,6 +18,7 @@ import {
createMemo,
createSignal,
For,
+ type JSX,
onCleanup,
onMount,
Show,
@@ -38,7 +39,10 @@ import type {
* [`DiscussionSource`]. Backend-agnostic: drive it via a `DiscussionProvider`
* supplying a document/task or CRM source.
*/
-export function Discussion(props: { hideComposer?: boolean }) {
+export function Discussion(props: {
+ hideComposer?: boolean;
+ threadHeader?: (thread: ViewThread) => JSX.Element;
+}) {
const source = useDiscussion();
const [isExpanded, setIsExpanded] = createSignal(true);
const [mountedCommentsVersion, setMountedCommentsVersion] = createSignal(0);
@@ -143,12 +147,15 @@ export function Discussion(props: { hideComposer?: boolean }) {
const listMeta = () =>
root() ? rootMetaById()[root()!.id] : undefined;
return (
- <DiscussionThreadView
- thread={thread}
- listMeta={listMeta()}
- onCommentMount={registerMountedComment}
- onCommentCleanup={unregisterMountedComment}
- />
+ <>
+ {props.threadHeader?.(thread)}
+ <DiscussionThreadView
+ thread={thread}
+ listMeta={listMeta()}
+ onCommentMount={registerMountedComment}
+ onCommentCleanup={unregisterMountedComment}
+ />
+ </>
);
}}
</For>
@@ -169,6 +176,7 @@ export function Discussion(props: { hideComposer?: boolean }) {
/** The new-thread composer can be placed independently of the thread list. */
export function DiscussionComposer(props: {
collapsible?: boolean;
+ autofocus?: boolean;
/** Dismiss the keyboard after submitting from a floating mobile composer. */
blurOnSend?: boolean;
}) {
@@ -192,7 +200,7 @@ export function DiscussionComposer(props: {
onReady={(handle) => {
inputHandle = handle;
}}
- autofocus={false}
+ autofocus={props.autofocus ?? false}
/>
</Show>
);
@@ -200,6 +208,7 @@ export function DiscussionComposer(props: {
export function DiscussionThreadView(props: {
thread: ViewThread;
+ showReplyAction?: boolean;
listMeta?: ChannelMessageListMeta;
onCommentMount?: (commentId: string, element: HTMLElement) => void;
onCommentCleanup?: (commentId: string, element: HTMLElement) => void;
@@ -257,15 +266,24 @@ export function DiscussionThreadView(props: {
setIsReplying(true);
}
: undefined,
- onEdit: own
- ? () => {
- setEditingId(comment.id);
- }
- : undefined,
+ onEdit:
+ own && canEdit()
+ ? () => {
+ setEditingId(comment.id);
+ }
+ : undefined,
onDelete:
own && canEdit()
? async () => {
- await source.deleteComment(comment);
+ try {
+ await source.deleteComment(comment);
+ } catch (error) {
+ toast.failure(
+ error instanceof Error
+ ? error.message
+ : 'Unable to delete comment.'
+ );
+ }
}
: undefined,
onCopyLink: makeCopyLink(comment),
@@ -320,6 +338,26 @@ export function DiscussionThreadView(props: {
/>
</div>
+ <Show
+ when={
+ props.showReplyAction &&
+ !hasReplies() &&
+ !isReplying() &&
+ canEdit()
+ }
+ >
+ <Thread.ActionsFooter>
+ <Thread.ReplyButton
+ getFocusTarget={() =>
+ replyInputContainerRef?.querySelector<HTMLElement>(
+ '[contenteditable]'
+ ) ?? null
+ }
+ onClick={() => setIsReplying(true)}
+ aria-label="Reply"
+ />
+ </Thread.ActionsFooter>
+ </Show>
<Show when={hasReplies() || isReplying()}>
<div class="relative w-full">
<Thread.ReplyRailDecorations />
diff --git a/apps/web/src/lib/core/comments/discussion/DiscussionInput.test.tsx b/apps/web/src/lib/core/comments/discussion/DiscussionInput.test.tsx
index 263e31247a..ec1e057b4d 100644
--- a/apps/web/src/lib/core/comments/discussion/DiscussionInput.test.tsx
+++ b/apps/web/src/lib/core/comments/discussion/DiscussionInput.test.tsx
@@ -10,6 +10,8 @@ const editor = vi.hoisted(() => ({
}));
const pickPhotos = vi.hoisted(() => vi.fn<() => Promise<File[] | null>>());
const addMedia = vi.hoisted(() => vi.fn());
+const failure = vi.hoisted(() => vi.fn());
+vi.mock('@core/component/Toast/Toast', () => ({ toast: { failure } }));
vi.mock('@solid-primitives/platform', () => ({
get isIOS() {
@@ -237,7 +239,8 @@ describe('discussion submission focus', () => {
throw new Error('Send failed');
},
});
- await expect(handle.send()).rejects.toThrow('Send failed');
+ expect(await handle.send()).toBe(false);
+ expect(failure).toHaveBeenCalledWith('Send failed');
await vi.runAllTimersAsync();
expect(document.activeElement).toBe(field);
expect(field.value).toBe('My comment');
diff --git a/apps/web/src/lib/core/comments/discussion/DiscussionInput.tsx b/apps/web/src/lib/core/comments/discussion/DiscussionInput.tsx
index 27e6fc06c7..afe04cffa2 100644
--- a/apps/web/src/lib/core/comments/discussion/DiscussionInput.tsx
+++ b/apps/web/src/lib/core/comments/discussion/DiscussionInput.tsx
@@ -20,6 +20,7 @@ import type { ItemMention } from '@core/component/LexicalMarkdown/plugins';
import { addMediaFromFile } from '@core/component/LexicalMarkdown/plugins/media';
import { singleLineMarkdownTheme } from '@core/component/LexicalMarkdown/theme';
import { createComposerLayout } from '@core/component/LexicalMarkdown/utils/create-composer-layout';
+import { toast } from '@core/component/Toast/Toast';
import { isMobile } from '@core/mobile/isMobile';
import { isTouchDevice } from '@core/mobile/isTouchDevice';
import type { IUser } from '@core/user/types';
@@ -178,6 +179,13 @@ export function DiscussionInput(props: DiscussionInputProps) {
collapsedInput.collapse();
}
return true;
+ } catch (error) {
+ toast.failure(
+ error instanceof Error
+ ? error.message
+ : 'Unable to send comment. Your draft has been kept.'
+ );
+ return false;
} finally {
setIsSending(false);
}
diff --git a/apps/web/src/lib/core/component/LexicalMarkdown/component/menu/FloatingFormatMenu.tsx b/apps/web/src/lib/core/component/LexicalMarkdown/component/menu/FloatingFormatMenu.tsx
index a19c5a808b..6815041802 100644
--- a/apps/web/src/lib/core/component/LexicalMarkdown/component/menu/FloatingFormatMenu.tsx
+++ b/apps/web/src/lib/core/component/LexicalMarkdown/component/menu/FloatingFormatMenu.tsx
@@ -370,7 +370,7 @@ export function FloatingFormatMenu(props: {
<ScopedPortal scope={props.portalScope}>
<div
ref={setMenuRef}
- class="fixed top-0 left-0 z-highlight-menu w-fit"
+ class="fixed top-0 left-0 z-action-menu w-fit"
use:floatWithSelection={{
selection: domSelection(),
reactiveOnContainer: editor.getRootElement(),
diff --git a/apps/web/src/lib/core/component/LexicalMarkdown/component/menu/MentionsMenu/MentionsMenu.tsx b/apps/web/src/lib/core/component/LexicalMarkdown/component/menu/MentionsMenu/MentionsMenu.tsx
index b25da71182..28529a0d84 100644
--- a/apps/web/src/lib/core/component/LexicalMarkdown/component/menu/MentionsMenu/MentionsMenu.tsx
+++ b/apps/web/src/lib/core/component/LexicalMarkdown/component/menu/MentionsMenu/MentionsMenu.tsx
@@ -60,7 +60,6 @@ const VIRTUAL_ITEM_HEIGHT = 36;
const PANEL_DECORATION_HEIGHT = 18;
type MentionsMenuProps = {
- editor: LexicalEditor;
menu: MenuOperations;
/** pass in a custom users list if necessary */
users?: Accessor<IUser[]>;
@@ -79,7 +78,10 @@ type MentionsMenuProps = {
showOpenTabs?: boolean;
/** restrict which mention source buckets to show (e.g. ['users'] for user-only mentions) */
sources?: MentionBucketId[];
-};
+} & (
+ | { editor: LexicalEditor; onPick?: never }
+ | { editor?: never; anchor: HTMLElement; onPick: (item: MentionItem) => void }
+);
export function MentionsMenu(props: MentionsMenuProps) {
return (
@@ -393,19 +395,22 @@ function MentionsMenuInner(props: MentionsMenuProps) {
}
});
- const itemActionHandler = createItemHandler({
- editor: props.editor,
- blockName: useMaybeBlockName(),
- blockId: useMaybeBlockId(),
- onUserMention: props.onUserMention,
- onDocumentMention: props.onDocumentMention,
- onEmailMention: props.onEmailMention,
- disableMentionTracking: props.disableMentionTracking,
- });
+ const itemActionHandler = props.editor
+ ? createItemHandler({
+ editor: props.editor,
+ blockName: useMaybeBlockName(),
+ blockId: useMaybeBlockId(),
+ onUserMention: props.onUserMention,
+ onDocumentMention: props.onDocumentMention,
+ onEmailMention: props.onEmailMention,
+ disableMentionTracking: props.disableMentionTracking,
+ })
+ : undefined;
const itemAction = async (item: MentionItem) => {
analytics.track('mentions_menu_use', { itemType: item.kind });
- await itemActionHandler(item);
+ if (props.onPick) props.onPick(item);
+ else await itemActionHandler?.(item);
};
createEffect(() => {
@@ -422,7 +427,7 @@ function MentionsMenuInner(props: MentionsMenuProps) {
});
const closeMenu = () => {
- props.editor.dispatchCommand(CLOSE_INLINE_SEARCH_COMMAND, undefined);
+ props.editor?.dispatchCommand(CLOSE_INLINE_SEARCH_COMMAND, undefined);
setMenuOpen(false);
};
@@ -565,7 +570,7 @@ function MentionsMenuInner(props: MentionsMenuProps) {
const clickOutsideHandler = (e: MouseEvent) => {
e.stopPropagation();
- props.editor.dispatchCommand(CLOSE_INLINE_SEARCH_COMMAND, undefined);
+ props.editor?.dispatchCommand(CLOSE_INLINE_SEARCH_COMMAND, undefined);
setMenuOpen(false);
};
@@ -593,7 +598,7 @@ function MentionsMenuInner(props: MentionsMenuProps) {
!props.anchor
? {
selection: untrack(mountSelection),
- reactiveOnContainer: props.editor.getRootElement(),
+ reactiveOnContainer: props.editor?.getRootElement(),
useBlockBoundary: props.useBlockBoundary,
onAvailableHeight: setMenuAvailableHeight,
}
@@ -605,6 +610,12 @@ function MentionsMenuInner(props: MentionsMenuProps) {
<div
class="w-96 max-w-[calc(100cqw-1rem-2px)] cursor-default select-none z-modal-content menu-open-animation"
on:touchstart={(e) => e.stopPropagation()}
+ onPointerDown={(event) => {
+ if (props.onPick) event.preventDefault();
+ }}
+ onMouseDown={(event) => {
+ if (props.onPick) event.preventDefault();
+ }}
ref={(el) => {
floatWithElement(el, floatWithElementProps);
floatWithSelection(el, floatWithSelectionProps);
diff --git a/apps/web/src/lib/service-clients/service-cognition/generated/tools/schemas.ts b/apps/web/src/lib/service-clients/service-cognition/generated/tools/schemas.ts
index fa51fda3d3..ae07ea355a 100644
--- a/apps/web/src/lib/service-clients/service-cognition/generated/tools/schemas.ts
+++ b/apps/web/src/lib/service-clients/service-cognition/generated/tools/schemas.ts
@@ -162,6 +162,180 @@ export const SpreadsheetResponse = z.any().superRefine((x, ctx) => {
.union([
z
.object({
+ numberFormat: z.union([z.string(), z.null()]).optional(),
+ fontName: z.union([z.string(), z.null()]).optional(),
+ borderTopStyle: z
+ .union([
+ z.any().superRefine((x, ctx) => {
+ const schemas = [
+ z.literal(''),
+ z.literal('thin'),
+ z.literal('medium'),
+ z.literal('thick'),
+ z.literal('double'),
+ z.literal('dotted'),
+ z.literal('dashed'),
+ z.literal('dashDot'),
+ z.literal('dashDotDot'),
+ z.literal('slantDashDot'),
+ z.literal('hair'),
+ z.literal('mediumDashed'),
+ z.literal('mediumDashDot'),
+ z.literal('mediumDashDotDot'),
+ ];
+ const errors = schemas.reduce<z.ZodError[]>(
+ (errors, schema) =>
+ ((result) =>
+ result.error
+ ? [...errors, result.error]
+ : errors)(schema.safeParse(x)),
+ []
+ );
+ if (schemas.length - errors.length !== 1) {
+ ctx.addIssue({
+ path: ctx.path,
+ code: 'invalid_union',
+ unionErrors: errors,
+ message:
+ 'Invalid input: Should pass single schema',
+ });
+ }
+ }),
+ z.null(),
+ ])
+ .optional(),
+ borderTopColor: z
+ .union([z.string(), z.null()])
+ .optional(),
+ borderRightStyle: z
+ .union([
+ z.any().superRefine((x, ctx) => {
+ const schemas = [
+ z.literal(''),
+ z.literal('thin'),
+ z.literal('medium'),
+ z.literal('thick'),
+ z.literal('double'),
+ z.literal('dotted'),
+ z.literal('dashed'),
+ z.literal('dashDot'),
+ z.literal('dashDotDot'),
+ z.literal('slantDashDot'),
+ z.literal('hair'),
+ z.literal('mediumDashed'),
+ z.literal('mediumDashDot'),
+ z.literal('mediumDashDotDot'),
+ ];
+ const errors = schemas.reduce<z.ZodError[]>(
+ (errors, schema) =>
+ ((result) =>
+ result.error
+ ? [...errors, result.error]
+ : errors)(schema.safeParse(x)),
+ []
+ );
+ if (schemas.length - errors.length !== 1) {
+ ctx.addIssue({
+ path: ctx.path,
+ code: 'invalid_union',
+ unionErrors: errors,
+ message:
+ 'Invalid input: Should pass single schema',
+ });
+ }
+ }),
+ z.null(),
+ ])
+ .optional(),
+ borderRightColor: z
+ .union([z.string(), z.null()])
+ .optional(),
+ borderBottomStyle: z
+ .union([
+ z.any().superRefine((x, ctx) => {
+ const schemas = [
+ z.literal(''),
+ z.literal('thin'),
+ z.literal('medium'),
+ z.literal('thick'),
+ z.literal('double'),
+ z.literal('dotted'),
+ z.literal('dashed'),
+ z.literal('dashDot'),
+ z.literal('dashDotDot'),
+ z.literal('slantDashDot'),
+ z.literal('hair'),
+ z.literal('mediumDashed'),
+ z.literal('mediumDashDot'),
+ z.literal('mediumDashDotDot'),
+ ];
+ const errors = schemas.reduce<z.ZodError[]>(
+ (errors, schema) =>
+ ((result) =>
+ result.error
+ ? [...errors, result.error]
+ : errors)(schema.safeParse(x)),
+ []
+ );
+ if (schemas.length - errors.length !== 1) {
+ ctx.addIssue({
+ path: ctx.path,
+ code: 'invalid_union',
+ unionErrors: errors,
+ message:
+ 'Invalid input: Should pass single schema',
+ });
+ }
+ }),
+ z.null(),
+ ])
+ .optional(),
+ borderBottomColor: z
+ .union([z.string(), z.null()])
+ .optional(),
+ borderLeftStyle: z
+ .union([
+ z.any().superRefine((x, ctx) => {
+ const schemas = [
+ z.literal(''),
+ z.literal('thin'),
+ z.literal('medium'),
+ z.literal('thick'),
+ z.literal('double'),
+ z.literal('dotted'),
+ z.literal('dashed'),
+ z.literal('dashDot'),
+ z.literal('dashDotDot'),
+ z.literal('slantDashDot'),
+ z.literal('hair'),
+ z.literal('mediumDashed'),
+ z.literal('mediumDashDot'),
+ z.literal('mediumDashDotDot'),
+ ];
+ const errors = schemas.reduce<z.ZodError[]>(
+ (errors, schema) =>
+ ((result) =>
+ result.error
+ ? [...errors, result.error]
+ : errors)(schema.safeParse(x)),
+ []
+ );
+ if (schemas.length - errors.length !== 1) {
+ ctx.addIssue({
+ path: ctx.path,
+ code: 'invalid_union',
+ unionErrors: errors,
+ message:
+ 'Invalid input: Should pass single schema',
+ });
+ }
+ }),
+ z.null(),
+ ])
+ .optional(),
+ borderLeftColor: z
+ .union([z.string(), z.null()])
+ .optional(),
bold: z.union([z.boolean(), z.null()]).optional(),
italic: z.union([z.boolean(), z.null()]).optional(),
underline: z.union([z.boolean(), z.null()]).optional(),
@@ -1867,6 +2041,168 @@ export const EditSpreadsheet = z.object({
range: z.string(),
style: z
.object({
+ numberFormat: z.union([z.string(), z.null()]).optional(),
+ fontName: z.union([z.string(), z.null()]).optional(),
+ borderTopStyle: z
+ .union([
+ z.any().superRefine((x, ctx) => {
+ const schemas = [
+ z.literal(''),
+ z.literal('thin'),
+ z.literal('medium'),
+ z.literal('thick'),
+ z.literal('double'),
+ z.literal('dotted'),
+ z.literal('dashed'),
+ z.literal('dashDot'),
+ z.literal('dashDotDot'),
+ z.literal('slantDashDot'),
+ z.literal('hair'),
+ z.literal('mediumDashed'),
+ z.literal('mediumDashDot'),
+ z.literal('mediumDashDotDot'),
+ ];
+ const errors = schemas.reduce<z.ZodError[]>(
+ (errors, schema) =>
+ ((result) =>
+ result.error ? [...errors, result.error] : errors)(
+ schema.safeParse(x)
+ ),
+ []
+ );
+ if (schemas.length - errors.length !== 1) {
+ ctx.addIssue({
+ path: ctx.path,
+ code: 'invalid_union',
+ unionErrors: errors,
+ message: 'Invalid input: Should pass single schema',
+ });
+ }
+ }),
+ z.null(),
+ ])
+ .optional(),
+ borderTopColor: z.union([z.string(), z.null()]).optional(),
+ borderRightStyle: z
+ .union([
+ z.any().superRefine((x, ctx) => {
+ const schemas = [
+ z.literal(''),
+ z.literal('thin'),
+ z.literal('medium'),
+ z.literal('thick'),
+ z.literal('double'),
+ z.literal('dotted'),
+ z.literal('dashed'),
+ z.literal('dashDot'),
+ z.literal('dashDotDot'),
+ z.literal('slantDashDot'),
+ z.literal('hair'),
+ z.literal('mediumDashed'),
+ z.literal('mediumDashDot'),
+ z.literal('mediumDashDotDot'),
+ ];
+ const errors = schemas.reduce<z.ZodError[]>(
+ (errors, schema) =>
+ ((result) =>
+ result.error ? [...errors, result.error] : errors)(
+ schema.safeParse(x)
+ ),
+ []
+ );
+ if (schemas.length - errors.length !== 1) {
+ ctx.addIssue({
+ path: ctx.path,
+ code: 'invalid_union',
+ unionErrors: errors,
+ message: 'Invalid input: Should pass single schema',
+ });
+ }
+ }),
+ z.null(),
+ ])
+ .optional(),
+ borderRightColor: z.union([z.string(), z.null()]).optional(),
+ borderBottomStyle: z
+ .union([
+ z.any().superRefine((x, ctx) => {
+ const schemas = [
+ z.literal(''),
+ z.literal('thin'),
+ z.literal('medium'),
+ z.literal('thick'),
+ z.literal('double'),
+ z.literal('dotted'),
+ z.literal('dashed'),
+ z.literal('dashDot'),
+ z.literal('dashDotDot'),
+ z.literal('slantDashDot'),
+ z.literal('hair'),
+ z.literal('mediumDashed'),
+ z.literal('mediumDashDot'),
+ z.literal('mediumDashDotDot'),
+ ];
+ const errors = schemas.reduce<z.ZodError[]>(
+ (errors, schema) =>
+ ((result) =>
+ result.error ? [...errors, result.error] : errors)(
+ schema.safeParse(x)
+ ),
+ []
+ );
+ if (schemas.length - errors.length !== 1) {
+ ctx.addIssue({
+ path: ctx.path,
+ code: 'invalid_union',
+ unionErrors: errors,
+ message: 'Invalid input: Should pass single schema',
+ });
+ }
+ }),
+ z.null(),
+ ])
+ .optional(),
+ borderBottomColor: z.union([z.string(), z.null()]).optional(),
+ borderLeftStyle: z
+ .union([
+ z.any().superRefine((x, ctx) => {
+ const schemas = [
+ z.literal(''),
+ z.literal('thin'),
+ z.literal('medium'),
+ z.literal('thick'),
+ z.literal('double'),
+ z.literal('dotted'),
+ z.literal('dashed'),
+ z.literal('dashDot'),
+ z.literal('dashDotDot'),
+ z.literal('slantDashDot'),
+ z.literal('hair'),
+ z.literal('mediumDashed'),
+ z.literal('mediumDashDot'),
+ z.literal('mediumDashDotDot'),
+ ];
+ const errors = schemas.reduce<z.ZodError[]>(
+ (errors, schema) =>
+ ((result) =>
+ result.error ? [...errors, result.error] : errors)(
+ schema.safeParse(x)
+ ),
+ []
+ );
+ if (schemas.length - errors.length !== 1) {
+ ctx.addIssue({
+ path: ctx.path,
+ code: 'invalid_union',
+ unionErrors: errors,
+ message: 'Invalid input: Should pass single schema',
+ });
+ }
+ }),
+ z.null(),
+ ])
+ .optional(),
+ borderLeftColor: z.union([z.string(), z.null()]).optional(),
bold: z.union([z.boolean(), z.null()]).optional(),
italic: z.union([z.boolean(), z.null()]).optional(),
underline: z.union([z.boolean(), z.null()]).optional(),
diff --git a/apps/web/src/lib/service-clients/service-cognition/generated/tools/types.ts b/apps/web/src/lib/service-clients/service-cognition/generated/tools/types.ts
index 9804e699aa..46b60e9d34 100644
--- a/apps/web/src/lib/service-clients/service-cognition/generated/tools/types.ts
+++ b/apps/web/src/lib/service-clients/service-cognition/generated/tools/types.ts
@@ -104,6 +104,24 @@ export type SpreadsheetResponse =
warnings: string[];
action: 'edit';
};
+/**
+ * Excel border line style.
+ */
+export type SpreadsheetBorderStyle =
+ | ''
+ | 'thin'
+ | 'medium'
+ | 'thick'
+ | 'double'
+ | 'dotted'
+ | 'dashed'
+ | 'dashDot'
+ | 'dashDotDot'
+ | 'slantDashDot'
+ | 'hair'
+ | 'mediumDashed'
+ | 'mediumDashDot'
+ | 'mediumDashDotDot';
/**
* Font family.
*/
@@ -1271,7 +1289,10 @@ export interface SpreadsheetCellInput {
*/
address: string;
/**
- * Raw text or formula, at most 10,000 characters.
+ * Raw text or formula, at most 10,000 characters. Macro links render as mention pills.
+ * For named pills, use the same inline tags as docs: <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]","displayName":"Person"}</m-user-mention>
+ * or <m-document-mention>{"documentId":"UUID","documentName":"Budget","blockName":"spreadsheet"}</m-document-mention>.
+ * Tags can be mixed with ordinary text. Use IDs from search/read results; do not invent them. Other Markdown is literal.
*/
value: string;
}
@@ -1377,6 +1398,46 @@ export interface SpreadsheetReadCell {
* Sparse cell styling patch. Omitted fields remain unchanged.
*/
export interface SpreadsheetStyle {
+ /**
+ * Exact Excel number format, up to 512 characters.
+ */
+ numberFormat?: string | null;
+ /**
+ * Exact Excel font name, up to 128 characters.
+ */
+ fontName?: string | null;
+ /**
+ * Top border style.
+ */
+ borderTopStyle?: SpreadsheetBorderStyle | null;
+ /**
+ * Top border color.
+ */
+ borderTopColor?: string | null;
+ /**
+ * Right border style.
+ */
+ borderRightStyle?: SpreadsheetBorderStyle | null;
+ /**
+ * Right border color.
+ */
+ borderRightColor?: string | null;
+ /**
+ * Bottom border style.
+ */
+ borderBottomStyle?: SpreadsheetBorderStyle | null;
+ /**
+ * Bottom border color.
+ */
+ borderBottomColor?: string | null;
+ /**
+ * Left border style.
+ */
+ borderLeftStyle?: SpreadsheetBorderStyle | null;
+ /**
+ * Left border color.
+ */
+ borderLeftColor?: string | null;
/**
* Bold text.
*/
diff --git a/apps/web/src/lib/service-clients/service-storage/util/fetchPresigned.ts b/apps/web/src/lib/service-clients/service-storage/util/fetchPresigned.ts
index 7d8959e718..1eaab838a9 100644
--- a/apps/web/src/lib/service-clients/service-storage/util/fetchPresigned.ts
+++ b/apps/web/src/lib/service-clients/service-storage/util/fetchPresigned.ts
@@ -75,7 +75,8 @@ export type FetchProgress = {
export async function fetchPresignedBlobWithProgress(
url: string,
onProgress: (progress: FetchProgress) => void,
- init?: RequestInit
+ init?: RequestInit,
+ maxBytes = Infinity
): Promise<Result<Blob, ResultError<FetchError>[]>> {
try {
const response = await platformFetch(url, init);
@@ -87,11 +88,17 @@ export async function fetchPresignedBlobWithProgress(
const totalHeader = response.headers.get('Content-Length');
const total = totalHeader ? Number.parseInt(totalHeader, 10) : 0;
const contentType = response.headers.get('Content-Type') ?? undefined;
+ if (total > maxBytes) {
+ await response.body?.cancel();
+ throw new Error(`File exceeds the ${maxBytes}-byte download limit.`);
+ }
onProgress({ loaded: 0, total });
if (!response.body) {
const blob = await response.blob();
+ if (blob.size > maxBytes)
+ throw new Error(`File exceeds the ${maxBytes}-byte download limit.`);
onProgress({ loaded: blob.size, total: blob.size });
return ok(blob);
}
@@ -103,13 +110,21 @@ export async function fetchPresignedBlobWithProgress(
while (true) {
const { done, value } = await reader.read();
if (done) break;
+ loaded += value.byteLength;
+ if (loaded > maxBytes || init?.signal?.aborted) {
+ await reader.cancel();
+ throw new Error(
+ init?.signal?.aborted
+ ? 'Download cancelled.'
+ : `File exceeds the ${maxBytes}-byte download limit.`
+ );
+ }
chunks.push(
value.buffer.slice(
value.byteOffset,
value.byteOffset + value.byteLength
) as ArrayBuffer
);
- loaded += value.byteLength;
onProgress({ loaded, total });
}
diff --git a/bun.lock b/bun.lock
index 953ef7e445..23caf5df86 100644
--- a/bun.lock
+++ b/bun.lock
@@ -312,6 +312,7 @@
"@ironcalc/wasm": "0.8.4",
"@loro-mirror/core": "workspace:*",
"loro-crdt": "catalog:",
+ "ssf": "0.11.2",
},
"devDependencies": {
"typescript": "^5.9.3",
@@ -2341,6 +2342,8 @@
"formidable": ["[email protected]", "", { "dependencies": { "@paralleldrive/cuid2": "^2.2.2", "dezalgo": "^1.0.4", "once": "^1.4.0", "qs": "^6.11.0" } }, "sha512-Oz5Hwvwak/DCaXVVUtPn4oLMLLy1CdclLKO1LFgU7XzDpVMUU5UjlSLpGMocyQNNk8F6IJW9M/YdooSn2MRI+Q=="],
+ "frac": ["[email protected]", "", {}, "sha512-w/XBfkibaTl3YDqASwfDUqkna4Z2p9cFSr1aHDt0WoMTECnRfBOv2WArlZILlqgWlmdIlALXGpM2AOhEk5W3IA=="],
+
"fs-constants": ["[email protected]", "", {}, "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow=="],
"fs-extra": ["[email protected]", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-w8ZNZr2mKIc7qeNaQ9AVPT1+iFaI+Avd4xudVOvdDJ8VytREi1Ft5Ih7hd9jjehod8vAM5GMsfQ/TpPf4EyoEA=="],
@@ -3299,6 +3302,8 @@
"sprintf-js": ["[email protected]", "", {}, "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g=="],
+ "ssf": ["[email protected]", "", { "dependencies": { "frac": "~1.1.2" } }, "sha512-+idbmIXoYET47hH+d7dfm2epdOMUDjqcB4648sTZ+t2JwoyBFL/insLfB/racrDmsKB3diwsDA696pZMieAC5g=="],
+
"ssh2": ["[email protected]", "", { "dependencies": { "asn1": "^0.2.6", "bcrypt-pbkdf": "^1.0.2" }, "optionalDependencies": { "cpu-features": "~0.0.10", "nan": "^2.23.0" } }, "sha512-wPldCk3asibAjQ/kziWQQt1Wh3PgDFpC0XpwclzKcdT1vql6KeYxf5LIt4nlFkUeR8WuphYMKqUA56X4rjbfgQ=="],
"sshpk": ["[email protected]", "", { "dependencies": { "asn1": "~0.2.3", "assert-plus": "^1.0.0", "bcrypt-pbkdf": "^1.0.0", "dashdash": "^1.12.0", "ecc-jsbn": "~0.1.1", "getpass": "^0.1.1", "jsbn": "~0.1.0", "safer-buffer": "^2.0.2", "tweetnacl": "~0.14.0" }, "bin": { "sshpk-conv": "bin/sshpk-conv", "sshpk-sign": "bin/sshpk-sign", "sshpk-verify": "bin/sshpk-verify" } }, "sha512-HXXqVUq7+pcKeLqqZj6mHFUMvXtOJt1uoUx09pFW6011inTMxqI8BA8PM95myrIyyKwdnzjdFjLiE6KBPVtJIg=="],
diff --git a/crates/documents/src/domain/spreadsheet/models.rs b/crates/documents/src/domain/spreadsheet/models.rs
index cd1bf3dac7..7f5863efa8 100644
--- a/crates/documents/src/domain/spreadsheet/models.rs
+++ b/crates/documents/src/domain/spreadsheet/models.rs
@@ -62,10 +62,76 @@ pub enum SpreadsheetNumberFormat {
Text,
}
+/// Excel border line style.
+#[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
+#[serde(rename_all = "camelCase")]
+pub enum SpreadsheetBorderStyle {
+ /// Restore the default border style.
+ #[serde(rename = "")]
+ Reset,
+ /// Thin line.
+ Thin,
+ /// Medium line.
+ Medium,
+ /// Thick line.
+ Thick,
+ /// Double line.
+ Double,
+ /// Dotted line.
+ Dotted,
+ /// Dashed line.
+ Dashed,
+ /// DashDot line.
+ DashDot,
+ /// DashDotDot line.
+ DashDotDot,
+ /// SlantDashDot line.
+ SlantDashDot,
+ /// Hair line.
+ Hair,
+ /// MediumDashed line.
+ MediumDashed,
+ /// MediumDashDot line.
+ MediumDashDot,
+ /// MediumDashDotDot line.
+ MediumDashDotDot,
+}
+
/// Sparse cell styling patch. Omitted fields remain unchanged.
#[derive(Debug, Clone, Default, Deserialize, Serialize, JsonSchema)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SpreadsheetStyle {
+ /// Exact Excel number format, up to 512 characters.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub number_format: Option<String>,
+ /// Exact Excel font name, up to 128 characters.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub font_name: Option<String>,
+ /// Top border style.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub border_top_style: Option<SpreadsheetBorderStyle>,
+ /// Top border color.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub border_top_color: Option<String>,
+ /// Right border style.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub border_right_style: Option<SpreadsheetBorderStyle>,
+ /// Right border color.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub border_right_color: Option<String>,
+ /// Bottom border style.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub border_bottom_style: Option<SpreadsheetBorderStyle>,
+ /// Bottom border color.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub border_bottom_color: Option<String>,
+ /// Left border style.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub border_left_style: Option<SpreadsheetBorderStyle>,
+ /// Left border color.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub border_left_color: Option<String>,
+
/// Bold text.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bold: Option<bool>,
@@ -125,7 +191,10 @@ pub struct SpreadsheetStyle {
pub struct SpreadsheetCellInput {
/// A1 address, from A1 through Z1000.
pub address: String,
- /// Raw text or formula, at most 10,000 characters.
+ /// Raw text or formula, at most 10,000 characters. Macro links render as mention pills.
+ /// For named pills, use the same inline tags as docs: <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]","displayName":"Person"}</m-user-mention>
+ /// or <m-document-mention>{"documentId":"UUID","documentName":"Budget","blockName":"spreadsheet"}</m-document-mention>.
+ /// Tags can be mixed with ordinary text. Use IDs from search/read results; do not invent them. Other Markdown is literal.
pub value: String,
}
diff --git a/crates/documents/src/domain/spreadsheet/test.rs b/crates/documents/src/domain/spreadsheet/test.rs
index c0705e4693..3bb93b243e 100644
--- a/crates/documents/src/domain/spreadsheet/test.rs
+++ b/crates/documents/src/domain/spreadsheet/test.rs
@@ -213,3 +213,21 @@ fn worker_json_contract_omits_optional_fields_and_round_trips_response() {
matches!(parsed, SpreadsheetResponse::Read { ranges, .. } if ranges[0].cells[0].source == "=1+1")
);
}
+
+#[test]
+fn imported_styles_round_trip_through_the_ai_contract() {
+ let json = serde_json::json!({
+ "numberFormat": "#,##0.00;[Red](#,##0.00)",
+ "fontName": "Calibri",
+ "borderBottomStyle": "double",
+ "borderBottomColor": "#123456"
+ });
+ let style: super::models::SpreadsheetStyle = serde_json::from_value(json.clone()).unwrap();
+ assert_eq!(serde_json::to_value(style).unwrap(), json);
+ assert!(
+ serde_json::from_value::<super::models::SpreadsheetStyle>(
+ serde_json::json!({"borderBottomStyle":"bogus"})
+ )
+ .is_err()
+ );
+}
diff --git a/docs/AGENT_GUIDE/documents.md b/docs/AGENT_GUIDE/documents.md
index a2c3e8a0ea..18036f1437 100644
--- a/docs/AGENT_GUIDE/documents.md
+++ b/docs/AGENT_GUIDE/documents.md
@@ -13,8 +13,9 @@ ellipsis beside the title uses the same menu as documents, including rename,
favorite, move, copy, and permission-appropriate file actions. Native spreadsheets
use a green grid icon in file lists and search. The grid fills
the panel beneath the formatting and formula bars. They have the `.spreadsheet` file type; uploading an
-Excel workbook in Files does not automatically convert it. Open a native spreadsheet
-and use the bottom-right **Import and export → Import…** menu to import its sheets.
+Excel or CSV file in Files or a channel opens a read-only spreadsheet preview, including existing `/app/unknown/<uuid>` links and CSV code routes. Review **Import notes**, then choose **Edit in Macro** to create a collaborative native copy. The original file and its link remain intact. Conversion waits for a durable save before opening the copy; a failed save can be retried without creating another copy. The normal document download action retrieves the original; the spreadsheet footer exports the imported representation.
+
+You can also open a native spreadsheet and use the bottom-right **Import and export → Import…** menu to import its sheets.
Select a cell to inspect its address and input in the formula bar. Double-click
a cell, start typing, or use the formula bar to edit its value. Formulas begin
@@ -96,18 +97,39 @@ Select data without its header when sorting. A concurrent edit cancels a pending
sort; references elsewhere in the sheet are not rewritten to follow sorted rows.
The footer's bottom-right **Import and export → Import…** accepts `.csv` and `.xlsx`.
+Right-click a row number or column letter for Macro's contextual menu: clipboard actions,
+clear, hide/unhide, resize and fit-to-data; columns also offer whole-sheet sorting.
+The menu keeps an existing whole-row/column selection when opened within it.
+Insert/delete shifts references and named ranges in local workbooks only; these
+commands are disabled on shared workbooks (including offline sessions) until
+collaborative rows and columns have stable identities. Adding blank rows at the
+bottom remains available. Hidden cells are skipped by keyboard navigation.
+
+Cells support Macro mentions without Markdown formatting. Type `@` in a cell or
+the formula bar to search people, documents, channels and email, then choose an
+item with the pointer or keyboard. Pasting a Macro app link renders a document
+pill, preserving navigation parameters. Formulas still use the formula editor;
+`@` inside a formula or email address does not start mention search. Other Markdown
+is literal text. Mentions remain attached through copy/fill, undo and collaboration;
+Excel/CSV export uses their display text. Plain URLs and email addresses are clickable;
+web links use the same hover preview as channel messages. Click the surrounding cell
+or use the formula bar to edit link text. AI `set_cells` accepts Macro URLs or the
+same `<m-user-mention>` / `<m-document-mention>` encoding as docs. Formula references
+to mention cells use literal labels, never execute a label as a formula.
+
CSV imports a file up to 1 MB into the selection, adding rows if needed within the
1,000 × 26 limit. Existing cells in that rectangle
are replaced, with undo available. Excel imports accept up to 5 MB, 10 sheets, and
1,000 rows × 26 columns per sheet. An import preview lists each sheet and warns about
-unsupported content (for example charts, merges, and custom formatting). Choose
+unsupported content (for example charts, validation rules, and rich text). Choose
**Insert new sheets** to keep existing work, or **Replace workbook** to replace it
in one undoable operation. Names must be unique when inserting sheets. Canceling
leaves the workbook untouched; a replacement is blocked if the workbook changed
while the preview was open. Legacy `.xls`, macros, and encrypted files are rejected.
**Import and export → Download as Excel (.xlsx)** exports every sheet with formulas,
-current formula result caches, supported formatting, and column widths.
+current formula result caches, precise numeric values, custom Excel number formats, fonts, borders, and column widths. Named ranges and named constants are retained; unsupported named expressions show explicit calculation errors. Imported merged ranges, hidden sheets/rows/columns, row heights, filters, and frozen panes are retained for export. Macro hides imported rows and columns, shows hidden sheets and individual cells of merged ranges; editing a covered merged cell omits that merge during export with a warning so the edit is preserved. Complex Excel features such as pivots, structured table formulas, charts, conditional formatting, validation, and rich text are not fully supported; review import notes before conversion.
+CSV imports preserve long identifiers and leading zeros as text and never execute formula-like strings.
**Download as CSV** in the same menu exports only the active sheet's current
calculated values. Clipboard menu actions use the browser clipboard; if access is
unavailable, use Cmd/Ctrl+V or Cmd/Ctrl+Shift+V in the grid.
@@ -172,6 +194,41 @@ iPhone WebKit projects. Chromium uses trusted touch drags; WebKit uses native ta
and mouse-pointer handle drags. A reduced test viewport only checks layout; verify
actual keyboard resizing and iOS gesture behavior in the simulator or on a device.
+Right-click a cell for the Macro cell menu: Cut, Copy, Paste, Paste values only,
+Clear values, Clear formatting, Fill down/right, and Comment on saved workbooks.
+Right-click inside a selected range to act on that range; outside it targets the
+clicked cell. **Shift + F10** or the keyboard context-menu key opens the same menu
+for the selection; Escape returns focus to the grid. Fill requires a multi-cell
+range along that direction. Commenters can copy and comment without editing cells.
+Right-click inside the cell text editor retains the native text-editing menu.
+
+Opening a saved spreadsheet from Files/Drive (including a favorite) keeps the
+Drive navigation sidebar in place. Collapse it with the sidebar control; the
+spreadsheet header then shows the navigation toggle to reopen it. Opening a
+spreadsheet does not change the saved sidebar preference. The header keeps the
+Files location breadcrumbs before the sheet title; click a location breadcrumb
+to return to that file listing.
+
+## Spreadsheet comments
+
+On a saved spreadsheet, select a cell or range and choose **Comment** in the
+formatting ribbon (or **⌘/Ctrl + Alt + M**) to compose beside the cell. A comment
+captures the sheet ID and selected range; later selection changes do not move
+the draft's attachment. The top-right triangle marks the first cell of a
+commented range. Hover any cell in that range to read its threads; choose
+**Reply** in the card to respond without opening the sidebar. Clicking the
+triangle also opens the card on touch devices. Interacting with a card keeps it
+open until dismissed so a reply is not lost when moving the pointer.
+
+**Comments** in the document header opens all workbook threads. Range labels
+navigate to the corresponding sheet and cells; deleted-sheet threads remain
+readable. These are the same document annotation comments used by docs/tasks:
+mentions and replies use the existing inbox notifications and comment links.
+Opening an inbox notification opens the sidebar and targets its comment/range.
+Comment-only access can post/reply; view-only access can read. Edit/delete applies
+to the author's own comments, and failures retain the input draft. Draft demos
+must be saved before persistent comments are available.
+
## Ask Macro about a spreadsheet
**Ask Macro** sits immediately left of **Share**. Select the relevant cells, then
diff --git a/docs/AGENT_GUIDE/navigation.md b/docs/AGENT_GUIDE/navigation.md
index df05fff76a..408563d095 100644
--- a/docs/AGENT_GUIDE/navigation.md
+++ b/docs/AGENT_GUIDE/navigation.md
@@ -329,3 +329,7 @@ refreshes the session credential and restores the saved selection.
Claude sessions expose **Open in Claude** in the header
toolbar (or its overflow menu). With a live runtime, messages sent in Claude are
polled into Macro about every two seconds; disconnected runtimes must resume first.
+
+Home does not bind Delete or Backspace to deleting list items. These keys remain
+available to the open editor (for example, clearing a selected spreadsheet range).
+Use the item menu to delete an item from Home.
diff --git a/nix-support/node_modules-hashes.json b/nix-support/node_modules-hashes.json
index 4f31a01eec..c0659d717d 100644
--- a/nix-support/node_modules-hashes.json
+++ b/nix-support/node_modules-hashes.json
@@ -1,6 +1,6 @@
{
"nodeModules": {
- "aarch64-darwin": "sha256-p+199faJnF5zIMWT4tX76VaWXXgpVRVFL5SHnnnfP74=",
- "x86_64-linux": "sha256-arlzHUXcmFuD1hdgF76Wztmw/5HnmY8k+ybVUoCRzLU="
+ "aarch64-darwin": "sha256-TS1OhqcriaqnBeP25E3/dp1c706fL5KqXyW/LFe0hqc=",
+ "x86_64-linux": "sha256-gyE4B9ICMVKSVufFojUOdI/Nvk3PAnawpDLqyiqER5c="
}
}
diff --git a/packages/spreadsheet/package.json b/packages/spreadsheet/package.json
index 842ced789c..26034e0915 100644
--- a/packages/spreadsheet/package.json
+++ b/packages/spreadsheet/package.json
@@ -9,7 +9,8 @@
"dependencies": {
"@ironcalc/wasm": "0.8.4",
"@loro-mirror/core": "workspace:*",
- "loro-crdt": "catalog:"
+ "loro-crdt": "catalog:",
+ "ssf": "0.11.2"
},
"scripts": {
"type-check": "tsc --noEmit --project tsconfig.json",
diff --git a/packages/spreadsheet/src/ai-workbook.test.ts b/packages/spreadsheet/src/ai-workbook.test.ts
index f24ce391f1..75218412f1 100644
--- a/packages/spreadsheet/src/ai-workbook.test.ts
+++ b/packages/spreadsheet/src/ai-workbook.test.ts
@@ -460,3 +460,26 @@ describe('spreadsheet AI atomic editing', () => {
expect(readSpreadsheetCells(doc)).toEqual({});
});
});
+
+it('uses selected-sheet local names in private AI calculations without changing the workbook', () => {
+ const doc = document();
+ doc.getMap('spreadsheetSheetMetadata').set(
+ 'sheet1',
+ JSON.stringify({
+ definedNames: [
+ { name: 'Rate', formula: '0.1' },
+ { name: 'Rate', formula: '0.25', local: true },
+ ],
+ })
+ );
+ doc.commit();
+ const before = doc.version().encode();
+ const result = calculateSpreadsheetForAi(
+ doc,
+ 'revision',
+ { action: 'calculate', formulas: [{ formula: '=Rate*100' }] },
+ calculator
+ );
+ expect(result.results[0]).toMatchObject({ type: 'number', value: 25 });
+ expect(doc.version().encode()).toEqual(before);
+});
diff --git a/packages/spreadsheet/src/ai-workbook.ts b/packages/spreadsheet/src/ai-workbook.ts
index ff5a286f0d..61fbde77cc 100644
--- a/packages/spreadsheet/src/ai-workbook.ts
+++ b/packages/spreadsheet/src/ai-workbook.ts
@@ -334,6 +334,11 @@ export function calculateSpreadsheetForAi(
name,
cells: { A1: { value: qualifyScratchFormula(formula, sheet.name) } },
layout: { rowCount: 200, columnWidths: {} },
+ metadata: {
+ definedNames: sheet.metadata?.definedNames?.filter(
+ (entry) => entry.local
+ ),
+ },
};
return scratch;
});
diff --git a/packages/spreadsheet/src/calculation.ts b/packages/spreadsheet/src/calculation.ts
index 9876c48859..3a4569c58c 100644
--- a/packages/spreadsheet/src/calculation.ts
+++ b/packages/spreadsheet/src/calculation.ts
@@ -1,4 +1,6 @@
import { type CompletionContext, getTokens, Model } from '@ironcalc/wasm';
+import { format as formatExcelNumber } from 'ssf';
+import { cellPlainText } from './cell-mentions';
import {
formatCellAddress,
parseCellAddress,
@@ -10,11 +12,14 @@ import {
type SpreadsheetCellEdits,
type SpreadsheetCells,
} from './spreadsheet-document';
+import type { WorkbookSheetMetadata } from './workbook-metadata';
+import { changeWorkbookAxis } from './workbook-structure';
export type CalculatedCell = {
display: string;
number?: number;
error?: string;
+ warning?: string;
/** Included only for callers requesting typed results. */
type?: 'blank' | 'number' | 'text' | 'boolean' | 'error';
value?: string | number | boolean | null;
@@ -26,6 +31,7 @@ export type CalculationSheet = {
name: string;
cells: SpreadsheetCells;
rowCount: number;
+ metadata?: WorkbookSheetMetadata;
};
export type WorkbookCalculation = Record<string, SpreadsheetCalculation>;
export type CalculationContext = { sheetNames: string[]; activeSheet: number };
@@ -53,6 +59,7 @@ export type SpreadsheetCalculator = {
cursor: number,
context?: CalculationContext
) => CompletionContext;
+ changeAxis: typeof changeWorkbookAxis;
dispose: () => void;
};
@@ -196,25 +203,113 @@ export function createInitializedSpreadsheetCalculator(): SpreadsheetCalculator
model,
bounded.map((sheet) => sheet.name)
);
+ const definedNames = new Set<string>();
+ const constants = new Map<string, string>();
+ const invalidNames = new Set<string>();
+ const definitions = new Map<string, string>();
+ for (const [sheetIndex, sheet] of bounded.entries()) {
+ for (const entry of sheet.metadata?.definedNames ?? []) {
+ const key = `${entry.local ? sheetIndex : 'global'}:${entry.name.toLowerCase()}`;
+ if (definedNames.has(key))
+ throw new Error(`Duplicate Excel name: ${entry.name}`);
+ definedNames.add(key);
+ const formula = entry.formula.replace(/^=/, '');
+ definitions.set(key, formula);
+ // IronCalc's named-range API only accepts references. Named constants
+ // remain authoritative definitions; substitute tokens for calculation.
+ if (
+ /^(?:[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?|TRUE|FALSE|"(?:[^"\r\n]|"")*")$/i.test(
+ formula
+ )
+ )
+ constants.set(key, formula);
+ else {
+ try {
+ model.newDefinedName(
+ entry.name,
+ entry.local ? sheetIndex : undefined,
+ formula
+ );
+ } catch {
+ invalidNames.add(key);
+ }
+ }
+ }
+ }
for (const [sheetIndex, { id, cells, rowCount }] of bounded.entries()) {
const unsupported: Record<string, string> = {};
unsupportedBySheet[id] = unsupported;
for (const address of Object.keys(cells).sort()) {
const position = parseCellAddress(address);
const cell = cells[address];
- const value = cell.value;
+ const value = cellPlainText(cell.value);
+ const literal = cell.format === 'text' || value !== cell.value;
if (!position || position.row >= rowCount || value === '') continue;
- const fn =
- cell.format === 'text' ? undefined : unsupportedFunction(value);
+ const fn = literal ? undefined : unsupportedFunction(value);
if (fn) {
unsupported[address] =
`${fn} is not supported yet because collaborators need the same calculation clock and random seed.`;
}
+ let input = fn ? '=NA()' : literal ? `'${value}` : value;
+ if (!fn && !literal && value.startsWith('=')) {
+ // Excel permits Sheet!LocalName, which IronCalc does not tokenize.
+ // Skip double-quoted literals and resolve only known definitions;
+ // ordinary sheet-qualified cell references stay unchanged.
+ const qualified = value.replace(
+ /"(?:[^"]|"")*"|'((?:[^']|'')+)'!([\p{L}_\\][\p{L}\p{N}_.\\]*)|([\p{L}_\\][\p{L}\p{N}_.\\]*)!([\p{L}_\\][\p{L}\p{N}_.\\]*)/gu,
+ (
+ match,
+ quoted: string | undefined,
+ quotedName: string | undefined,
+ plain: string | undefined,
+ plainName: string | undefined
+ ) => {
+ if (match.startsWith('"')) return match;
+ const target = bounded.findIndex(
+ (sheet) =>
+ sheet.name.toLowerCase() ===
+ (quoted?.replaceAll("''", "'") ?? plain ?? '').toLowerCase()
+ );
+ if (target < 0) return match;
+ const name = (quotedName ?? plainName ?? '').toLowerCase();
+ const local = `${target}:${name}`;
+ const key = definedNames.has(local) ? local : `global:${name}`;
+ if (invalidNames.has(key))
+ unsupported[address] =
+ `The Excel name ${name} uses a definition this calculation engine does not support.`;
+ const definition = definitions.get(key);
+ return definition === undefined ? match : `(${definition})`;
+ }
+ );
+ const characters = Array.from(qualified);
+ const tokens = getTokens(qualified);
+ for (let index = tokens.length - 1; index >= 0; index--) {
+ const { token, start, end } = tokens[index];
+ if (
+ typeof token !== 'object' ||
+ !('Ident' in token) ||
+ tokens[index + 1]?.token === 'LeftParenthesis'
+ )
+ continue;
+ const name = token.Ident.toLowerCase();
+ const localKey = `${sheetIndex}:${name}`;
+ const key = definedNames.has(localKey)
+ ? localKey
+ : `global:${name}`;
+ if (invalidNames.has(key))
+ unsupported[address] =
+ `The Excel name ${token.Ident} uses a definition this calculation engine does not support.`;
+ const constant = constants.get(key);
+ if (constant !== undefined)
+ characters.splice(start, end - start, `(${constant})`);
+ }
+ input = unsupported[address] ? '=NA()' : characters.join('');
+ }
model.setUserInput(
sheetIndex,
position.row + 1,
position.column + 1,
- fn ? '=NA()' : cell.format === 'text' ? `'${value}` : value
+ input
);
}
// The WASM binding exposes numeric values through its formatter. Read
@@ -272,8 +367,21 @@ export function createInitializedSpreadsheetCalculator(): SpreadsheetCalculator
};
} else if (cellType === 1) {
const number = Number(display);
+ const customFormat = cells[address]?.numberFormat;
+
+ let formatted = displayNumber(number, cells[address]);
+ let warning: string | undefined;
+ if (customFormat) {
+ try {
+ formatted = formatExcelNumber(customFormat, number);
+ } catch {
+ warning =
+ 'This Excel number format cannot be displayed in Macro. Its value and original format are retained for export.';
+ }
+ }
results[address] = {
- display: displayNumber(number, cells[address]),
+ display: formatted,
+ ...(warning && { warning }),
number,
...(options?.includeTypes && {
type: 'number' as const,
@@ -302,6 +410,7 @@ export function createInitializedSpreadsheetCalculator(): SpreadsheetCalculator
}
return {
+ changeAxis: changeWorkbookAxis,
complete(text, cursor, context) {
if (disposed) throw new Error('The spreadsheet calculator is disposed.');
const model = new Model('Formula help', 'en', 'UTC', 'en');
diff --git a/packages/spreadsheet/src/cell-mentions.ts b/packages/spreadsheet/src/cell-mentions.ts
new file mode 100644
index 0000000000..efa94c6659
--- /dev/null
+++ b/packages/spreadsheet/src/cell-mentions.ts
@@ -0,0 +1,141 @@
+/** The existing Macro mention encoding; ordinary cell text is never Markdown. */
+export type CellMention =
+ | { type: 'user'; userId: string; email: string; displayName?: string }
+ | {
+ type: 'document';
+ documentId: string;
+ documentName: string;
+ blockName: string;
+ blockParams?: Record<string, string>;
+ };
+export type CellTextPart = { text: string; mention?: CellMention };
+const blocks = new Set([
+ 'csv',
+ 'write',
+ 'automation',
+ 'pr',
+ 'md',
+ 'task',
+ 'snippet',
+ 'skill',
+ 'pdf',
+ 'docx',
+ 'spreadsheet',
+ 'canvas',
+ 'channel',
+ 'chat',
+ 'project',
+ 'email',
+ 'unknown',
+ 'code',
+ 'image',
+ 'video',
+ 'audio',
+ 'agent',
+ 'company',
+ 'contact',
+ 'calendar',
+ 'call',
+]);
+
+function mentionData(type: string, encoded: string): CellMention | undefined {
+ try {
+ const data = JSON.parse(encoded);
+ if (!data || typeof data !== 'object' || Array.isArray(data)) return;
+ const text = (key: string) =>
+ typeof data[key] === 'string' &&
+ data[key].length > 0 &&
+ data[key].length <= 2048;
+ if (
+ type === 'user' &&
+ text('userId') &&
+ text('email') &&
+ (data.displayName === undefined || typeof data.displayName === 'string')
+ )
+ return {
+ type: 'user',
+ userId: data.userId,
+ email: data.email,
+ displayName: data.displayName,
+ };
+ if (
+ type === 'document' &&
+ text('documentId') &&
+ typeof data.documentName === 'string' &&
+ blocks.has(data.blockName)
+ ) {
+ const params = data.blockParams;
+ if (
+ params !== undefined &&
+ (!params ||
+ typeof params !== 'object' ||
+ Array.isArray(params) ||
+ Object.values(params).some((v) => typeof v !== 'string'))
+ )
+ return;
+ return {
+ type: 'document',
+ documentId: data.documentId,
+ documentName: data.documentName,
+ blockName: data.blockName,
+ ...(params ? { blockParams: params } : {}),
+ };
+ }
+ } catch {
+ /* Malformed tags remain literal text. */
+ }
+}
+
+export function cellTextParts(value: string): CellTextPart[] {
+ if (!value.includes('<m-') || value.startsWith('=')) return [{ text: value }];
+ const parts: CellTextPart[] = [];
+ let end = 0;
+ for (const match of value.matchAll(
+ /<m-(user|document)-mention>(.*?)<\/m-\1-mention>/gs
+ )) {
+ const mention = mentionData(match[1], match[2]);
+ if (!mention) continue;
+ if (match.index > end) parts.push({ text: value.slice(end, match.index) });
+ parts.push({ text: match[0], mention });
+ end = match.index + match[0].length;
+ }
+ if (end < value.length) parts.push({ text: value.slice(end) });
+ return parts.length ? parts : [{ text: value }];
+}
+export function cellMentionLabel(mention: CellMention): string {
+ return mention.type === 'user'
+ ? `@${mention.displayName || mention.email}`
+ : mention.documentName || 'Linked item';
+}
+export function cellPlainText(value: string): string {
+ return cellTextParts(value)
+ .map((part) => (part.mention ? cellMentionLabel(part.mention) : part.text))
+ .join('');
+}
+export function encodeCellMention(mention: CellMention): string {
+ const { type, ...data } = mention;
+ return `<m-${type}-mention>${JSON.stringify(data).replaceAll('<', '\\u003c')}</m-${type}-mention>`;
+}
+
+/** Only a text-token @ starts search; email addresses and formulas stay literal. */
+export function cellMentionQuery(value: string, cursor: number) {
+ if (value.startsWith('=')) return;
+ let offset = 0;
+ for (const part of cellTextParts(value)) {
+ if (
+ !part.mention &&
+ cursor >= offset &&
+ cursor <= offset + part.text.length
+ ) {
+ const before = part.text.slice(0, cursor - offset);
+ const match = /(?:^|\s)@([^@\n<>]*)$/.exec(before);
+ if (match)
+ return {
+ start: offset + before.lastIndexOf('@'),
+ end: cursor,
+ query: match[1],
+ };
+ }
+ offset += part.text.length;
+ }
+}
diff --git a/packages/spreadsheet/src/spreadsheet-document.ts b/packages/spreadsheet/src/spreadsheet-document.ts
index b83e76eecb..dafba9639f 100644
--- a/packages/spreadsheet/src/spreadsheet-document.ts
+++ b/packages/spreadsheet/src/spreadsheet-document.ts
@@ -44,6 +44,17 @@ export type SpreadsheetCell = {
borderLeft?: boolean;
decimals?: number;
format?: SpreadsheetFormat;
+ /** Excel number format, preserved verbatim for display and export. */
+ numberFormat?: string;
+ fontName?: string;
+ borderTopStyle?: string;
+ borderTopColor?: string;
+ borderRightStyle?: string;
+ borderRightColor?: string;
+ borderBottomStyle?: string;
+ borderBottomColor?: string;
+ borderLeftStyle?: string;
+ borderLeftColor?: string;
};
export type SpreadsheetCellStyle = Omit<SpreadsheetCell, 'value'>;
export type SpreadsheetCells = Record<string, SpreadsheetCell>;
@@ -67,10 +78,39 @@ export const SPREADSHEET_DEFAULT_STYLE: Required<SpreadsheetCellStyle> = {
borderLeft: false,
decimals: -1,
format: 'general',
+ numberFormat: '',
+ fontName: '',
+ borderTopStyle: '',
+ borderTopColor: '',
+ borderRightStyle: '',
+ borderRightColor: '',
+ borderBottomStyle: '',
+ borderBottomColor: '',
+ borderLeftStyle: '',
+ borderLeftColor: '',
};
const booleanStyle = (value: unknown): value is boolean =>
typeof value === 'boolean';
+const borderStyle = (value: unknown): value is string =>
+ typeof value === 'string' &&
+ [
+ '',
+ 'thin',
+ 'medium',
+ 'thick',
+ 'double',
+ 'dotted',
+ 'dashed',
+ 'dashDot',
+ 'dashDotDot',
+ 'slantDashDot',
+ 'hair',
+ 'mediumDashed',
+ 'mediumDashDot',
+ 'mediumDashDotDot',
+ ].includes(value);
+
const colorStyle = (value: unknown): value is string =>
typeof value === 'string' && (value === '' || /^#[0-9a-f]{6}$/i.test(value));
const integerStyle = (
@@ -127,6 +167,34 @@ const styleFields: {
valid: (value): value is number => integerStyle(value, -1, 10),
},
format: { map: 'spreadsheetFormats', valid: isSpreadsheetFormat },
+ fontName: {
+ map: 'spreadsheetFontNames',
+ valid: (value): value is string =>
+ typeof value === 'string' &&
+ value.length <= 128 &&
+ Array.from(value).every((character) => character.charCodeAt(0) >= 32),
+ },
+ borderTopStyle: { map: 'spreadsheetBorderTopStyles', valid: borderStyle },
+ borderTopColor: { map: 'spreadsheetBorderTopColors', valid: colorStyle },
+ borderRightStyle: { map: 'spreadsheetBorderRightStyles', valid: borderStyle },
+ borderRightColor: { map: 'spreadsheetBorderRightColors', valid: colorStyle },
+ borderBottomStyle: {
+ map: 'spreadsheetBorderBottomStyles',
+ valid: borderStyle,
+ },
+ borderBottomColor: {
+ map: 'spreadsheetBorderBottomColors',
+ valid: colorStyle,
+ },
+ borderLeftStyle: { map: 'spreadsheetBorderLeftStyles', valid: borderStyle },
+ borderLeftColor: { map: 'spreadsheetBorderLeftColors', valid: colorStyle },
+ numberFormat: {
+ map: 'spreadsheetNumberFormats',
+ valid: (value): value is string =>
+ typeof value === 'string' &&
+ value.length <= 512 &&
+ Array.from(value).every((character) => character.charCodeAt(0) >= 32),
+ },
};
const styleKeys = Object.keys(styleFields) as (keyof SpreadsheetCellStyle)[];
@@ -409,6 +477,14 @@ export function writeSpreadsheetCells(
if (edit.value) values.set(key, edit.value);
else values.delete(key);
}
+ // Choosing a built-in format/precision explicitly replaces the imported format.
+ if (edit.fontFamily !== undefined && edit.fontName === undefined)
+ doc.getMap('spreadsheetFontNames').delete(key);
+ if (
+ edit.numberFormat === undefined &&
+ (edit.format !== undefined || edit.decimals !== undefined)
+ )
+ doc.getMap('spreadsheetNumberFormats').delete(key);
for (const { key: styleKey, map } of styles) {
const value = edit[styleKey];
if (value === undefined) continue;
diff --git a/packages/spreadsheet/src/spreadsheet-schema.ts b/packages/spreadsheet/src/spreadsheet-schema.ts
index a9e2968055..8c4adf8fc2 100644
--- a/packages/spreadsheet/src/spreadsheet-schema.ts
+++ b/packages/spreadsheet/src/spreadsheet-schema.ts
@@ -4,6 +4,9 @@ import { schema } from '@loro-mirror/core';
// cell concurrently. Separate properties also let formatting and value edits
// merge independently. Calculated values are deliberately never persisted.
export const SPREADSHEET_LORO_SCHEMA = schema({
+ spreadsheetSheetMetadata: schema.LoroMap(
+ {} as Record<string, ReturnType<typeof schema.String>>
+ ),
spreadsheetSheetNames: schema.LoroMap(
{} as Record<string, ReturnType<typeof schema.String>>
),
@@ -25,6 +28,36 @@ export const SPREADSHEET_LORO_SCHEMA = schema({
spreadsheetBold: schema.LoroMap(
{} as Record<string, ReturnType<typeof schema.Boolean>>
),
+ spreadsheetFontNames: schema.LoroMap(
+ {} as Record<string, ReturnType<typeof schema.String>>
+ ),
+ spreadsheetBorderTopStyles: schema.LoroMap(
+ {} as Record<string, ReturnType<typeof schema.String>>
+ ),
+ spreadsheetBorderTopColors: schema.LoroMap(
+ {} as Record<string, ReturnType<typeof schema.String>>
+ ),
+ spreadsheetBorderRightStyles: schema.LoroMap(
+ {} as Record<string, ReturnType<typeof schema.String>>
+ ),
+ spreadsheetBorderRightColors: schema.LoroMap(
+ {} as Record<string, ReturnType<typeof schema.String>>
+ ),
+ spreadsheetBorderBottomStyles: schema.LoroMap(
+ {} as Record<string, ReturnType<typeof schema.String>>
+ ),
+ spreadsheetBorderBottomColors: schema.LoroMap(
+ {} as Record<string, ReturnType<typeof schema.String>>
+ ),
+ spreadsheetBorderLeftStyles: schema.LoroMap(
+ {} as Record<string, ReturnType<typeof schema.String>>
+ ),
+ spreadsheetBorderLeftColors: schema.LoroMap(
+ {} as Record<string, ReturnType<typeof schema.String>>
+ ),
+ spreadsheetNumberFormats: schema.LoroMap(
+ {} as Record<string, ReturnType<typeof schema.String>>
+ ),
spreadsheetFormats: schema.LoroMap(
{} as Record<string, ReturnType<typeof schema.String>>
),
diff --git a/packages/spreadsheet/src/workbook-document.ts b/packages/spreadsheet/src/workbook-document.ts
index a6d501d235..f36502bf9e 100644
--- a/packages/spreadsheet/src/workbook-document.ts
+++ b/packages/spreadsheet/src/workbook-document.ts
@@ -1,5 +1,9 @@
import type { LoroDoc } from 'loro-crdt';
import { formulaReferencesSheet } from './sheet-references';
+import {
+ parseWorkbookMetadata,
+ type WorkbookSheetMetadata,
+} from './workbook-metadata';
export { formulaReferencesSheet } from './sheet-references';
@@ -41,12 +45,14 @@ export const SPREADSHEET_MAX_SHEETS = 10;
export type SpreadsheetWorkbookSheet = SpreadsheetSheet & {
cells: SpreadsheetCells;
layout: SpreadsheetLayout;
+ metadata?: WorkbookSheetMetadata;
};
export type SpreadsheetSheetInput = {
name: string;
cells: SpreadsheetCells;
rowCount: number;
columnWidths: Record<number, number>;
+ metadata?: WorkbookSheetMetadata;
};
export function readSpreadsheetWorkbook(
@@ -55,6 +61,9 @@ export function readSpreadsheetWorkbook(
const readEntries = createSpreadsheetEntryReader(doc);
return readSpreadsheetSheets(doc).map((sheet) => ({
...sheet,
+ metadata: parseWorkbookMetadata(
+ doc.getMap('spreadsheetSheetMetadata').get(sheet.id)
+ ),
cells: readSpreadsheetCells(doc, sheet.id, readEntries),
layout: readSpreadsheetLayout(doc, sheet.id, readEntries),
}));
@@ -98,6 +107,21 @@ function availableSheetName(doc: LoroDoc, base?: string): string {
function assertUnreferenced(doc: LoroDoc, sheet: SpreadsheetSheet) {
for (const current of readSpreadsheetWorkbook(doc)) {
+ if (current.id === sheet.id && current.metadata?.definedNames?.length)
+ throw new Error(
+ `“${sheet.name}” contains Excel name definitions. Keep the sheet name while those definitions are in use.`
+ );
+ if (
+ current.metadata?.definedNames?.some((entry) =>
+ formulaReferencesSheet(
+ `=${entry.formula.replace(/^=/, '')}`,
+ sheet.name
+ )
+ )
+ )
+ throw new Error(
+ `“${sheet.name}” is referenced by an Excel name definition.`
+ );
for (const cell of Object.values(current.cells)) {
if (
cell.format !== 'text' &&
@@ -148,7 +172,27 @@ function validateSheetInputs(
`A workbook can contain up to ${SPREADSHEET_MAX_SHEETS} sheets.`
);
const names = new Set(existing.map((sheet) => sheet.name.toLowerCase()));
+ const globalNames = new Set(
+ (replace ? [] : readSpreadsheetWorkbook(doc)).flatMap((sheet) =>
+ (sheet.metadata?.definedNames ?? [])
+ .filter((entry) => !entry.local)
+ .map((entry) => entry.name.toLowerCase())
+ )
+ );
for (const sheet of inputs) {
+ if (
+ sheet.metadata &&
+ !parseWorkbookMetadata(JSON.stringify(sheet.metadata))
+ )
+ throw new Error('Invalid Excel workbook metadata.');
+ const localNames = new Set<string>();
+ for (const entry of sheet.metadata?.definedNames ?? []) {
+ const definitions = entry.local ? localNames : globalNames;
+ const key = entry.name.toLowerCase();
+ if (definitions.has(key))
+ throw new Error(`Duplicate Excel name: ${entry.name}`);
+ definitions.add(key);
+ }
const name = validateSpreadsheetSheetName(sheet.name);
if (name !== sheet.name)
throw new Error(
@@ -212,6 +256,10 @@ export function importSpreadsheetSheets(
}
inputs.forEach((sheet, index) => {
const id = ids[index];
+ if (sheet.metadata)
+ doc
+ .getMap('spreadsheetSheetMetadata')
+ .set(id, JSON.stringify(sheet.metadata));
doc.getMap('spreadsheetSheetNames').set(id, sheet.name);
doc.getMap('spreadsheetSheetOrder').set(id, order + index + 1);
writeSpreadsheetCells(doc, sheet.cells, id, false);
@@ -252,9 +300,17 @@ export function duplicateSpreadsheetSheet(
sheetId: string
): string {
const sheet = existingSheet(doc, sheetId);
+ const metadata = parseWorkbookMetadata(
+ doc.getMap('spreadsheetSheetMetadata').get(sheetId)
+ );
+ if (metadata?.definedNames)
+ metadata.definedNames = metadata.definedNames.filter(
+ (entry) => entry.local
+ );
return importSpreadsheetSheets(doc, [
{
name: availableSheetName(doc, sheet.name),
+ metadata,
cells: readSpreadsheetCells(doc, sheetId),
...readSpreadsheetLayout(doc, sheetId),
},
diff --git a/packages/spreadsheet/src/workbook-metadata.ts b/packages/spreadsheet/src/workbook-metadata.ts
new file mode 100644
index 0000000000..489ecac0f7
--- /dev/null
+++ b/packages/spreadsheet/src/workbook-metadata.ts
@@ -0,0 +1,133 @@
+import {
+ parseCellAddress,
+ SPREADSHEET_COLUMNS,
+ SPREADSHEET_MAX_ROWS,
+} from './spreadsheet-document';
+
+/** Excel layout and definitions retained independently from editable cell maps. */
+export type WorkbookSheetMetadata = {
+ merges?: string[];
+ rowHeights?: Record<number, number>;
+ hiddenRows?: number[];
+ hiddenColumns?: number[];
+ hidden?: boolean;
+ freeze?: { rows: number; columns: number };
+ autoFilter?: string;
+ definedNames?: { name: string; formula: string; local?: boolean }[];
+};
+
+export function validWorkbookRange(range: unknown): range is string {
+ if (typeof range !== 'string') return false;
+ const parts = range.split(':');
+ const first = parseCellAddress(parts[0]);
+ const last = parseCellAddress(parts[1] ?? parts[0]);
+ return (
+ parts.length <= 2 &&
+ !!first &&
+ !!last &&
+ first.row <= last.row &&
+ first.column <= last.column
+ );
+}
+
+export function parseWorkbookMetadata(
+ encoded: unknown
+): WorkbookSheetMetadata | undefined {
+ if (typeof encoded !== 'string' || encoded.length > 100_000) return;
+ try {
+ const value = JSON.parse(encoded);
+ if (!value || typeof value !== 'object' || Array.isArray(value)) return;
+ if (
+ Object.keys(value).some(
+ (key) =>
+ ![
+ 'merges',
+ 'rowHeights',
+ 'hiddenRows',
+ 'hiddenColumns',
+ 'hidden',
+ 'freeze',
+ 'autoFilter',
+ 'definedNames',
+ ].includes(key)
+ )
+ )
+ return;
+ const indices = (values: unknown, limit: number) =>
+ values === undefined ||
+ (Array.isArray(values) &&
+ values.length <= limit &&
+ values.every((v) => Number.isInteger(v) && v >= 0 && v < limit));
+ if (
+ value.merges !== undefined &&
+ (!Array.isArray(value.merges) ||
+ value.merges.length > 1000 ||
+ !value.merges.every(validWorkbookRange))
+ )
+ return;
+ if (
+ !indices(value.hiddenRows, SPREADSHEET_MAX_ROWS) ||
+ !indices(value.hiddenColumns, SPREADSHEET_COLUMNS)
+ )
+ return;
+ if (
+ value.rowHeights !== undefined &&
+ (!value.rowHeights ||
+ typeof value.rowHeights !== 'object' ||
+ Array.isArray(value.rowHeights) ||
+ !Object.entries(value.rowHeights).every(
+ ([key, height]) =>
+ /^\d+$/.test(key) &&
+ +key < SPREADSHEET_MAX_ROWS &&
+ typeof height === 'number' &&
+ Number.isFinite(height) &&
+ height >= 0 &&
+ height <= 409.5
+ ))
+ )
+ return;
+ if (value.hidden !== undefined && typeof value.hidden !== 'boolean') return;
+ if (
+ value.freeze !== undefined &&
+ (!value.freeze ||
+ Object.keys(value.freeze).length !== 2 ||
+ !Number.isInteger(value.freeze.rows) ||
+ value.freeze.rows < 0 ||
+ value.freeze.rows > SPREADSHEET_MAX_ROWS ||
+ !Number.isInteger(value.freeze.columns) ||
+ value.freeze.columns < 0 ||
+ value.freeze.columns > SPREADSHEET_COLUMNS)
+ )
+ return;
+ if (value.autoFilter !== undefined && !validWorkbookRange(value.autoFilter))
+ return;
+ if (
+ value.definedNames !== undefined &&
+ (!Array.isArray(value.definedNames) ||
+ value.definedNames.length > 256 ||
+ !value.definedNames.every((entry: unknown) => {
+ if (
+ !entry ||
+ typeof entry !== 'object' ||
+ Object.keys(entry).some(
+ (key) => !['name', 'formula', 'local'].includes(key)
+ )
+ )
+ return false;
+ const { name, formula, local } = entry as Record<string, unknown>;
+ return (
+ typeof name === 'string' &&
+ name.length > 0 &&
+ name.length <= 255 &&
+ typeof formula === 'string' &&
+ formula.length <= 10_000 &&
+ (local === undefined || typeof local === 'boolean')
+ );
+ }))
+ )
+ return;
+ return value;
+ } catch {
+ return;
+ }
+}
diff --git a/packages/spreadsheet/src/workbook-structure.ts b/packages/spreadsheet/src/workbook-structure.ts
new file mode 100644
index 0000000000..4339d8c6c5
--- /dev/null
+++ b/packages/spreadsheet/src/workbook-structure.ts
@@ -0,0 +1,297 @@
+import { getTokens, Model } from '@ironcalc/wasm';
+import {
+ formatCellAddress,
+ parseCellAddress,
+ SPREADSHEET_COLUMNS,
+ SPREADSHEET_MAX_ROWS,
+ type SpreadsheetCells,
+} from './spreadsheet-document';
+import type { SpreadsheetWorkbookSheet } from './workbook-document';
+
+export type AxisChange = {
+ sheetId: string;
+ axis: 'row' | 'column';
+ index: number;
+ count: number;
+ kind: 'insert' | 'delete';
+};
+
+/** Trim partially deleted ranges before IronCalc turns a deleted endpoint into #REF. */
+function prepareDeletion(
+ formula: string,
+ currentSheet: string,
+ targetSheet: string,
+ change: AxisChange
+): string {
+ if (change.kind !== 'delete') return formula;
+ const characters = Array.from(formula);
+ for (const { token, start, end } of getTokens(formula).reverse()) {
+ if (typeof token !== 'object' || !('Range' in token)) continue;
+ const range = token.Range;
+ if (
+ (range.sheet ?? currentSheet).toLowerCase() !== targetSheet.toLowerCase()
+ )
+ continue;
+ const left = { ...range.left },
+ right = { ...range.right };
+ const referenceText = characters
+ .slice(start, end)
+ .join('')
+ .split('!')
+ .at(-1)!;
+ const wholeRows = /^\$?\d+:\$?\d+$/.test(referenceText);
+ const wholeColumns = /^\$?[A-Z]+:\$?[A-Z]+$/i.test(referenceText);
+ if (
+ (wholeRows && change.axis === 'column') ||
+ (wholeColumns && change.axis === 'row')
+ )
+ continue;
+ const low = Math.min(left[change.axis], right[change.axis]);
+ const high = Math.max(left[change.axis], right[change.axis]);
+ const first = change.index + 1,
+ last = change.index + change.count;
+ if (low >= first && high <= last) continue;
+ let changed = false;
+ for (const reference of [left, right]) {
+ if (reference[change.axis] >= first && reference[change.axis] <= last) {
+ reference[change.axis] =
+ reference[change.axis] === low ? last + 1 : first - 1;
+ changed = true;
+ }
+ }
+ if (!changed) continue;
+ const address = (ref: typeof left) => {
+ let column = '';
+ for (
+ let index = ref.column;
+ index > 0;
+ index = Math.floor((index - 1) / 26)
+ ) {
+ column = String.fromCharCode(65 + ((index - 1) % 26)) + column;
+ }
+ if (wholeRows) return `${ref.absolute_row ? '$' : ''}${ref.row}`;
+ if (wholeColumns) return `${ref.absolute_column ? '$' : ''}${column}`;
+ const cell = `${column}${ref.row}`;
+ return cell.replace(
+ /^([A-Z]+)(\d+)$/,
+ (_, column: string, row: string) =>
+ `${ref.absolute_column ? '$' : ''}${column}${ref.absolute_row ? '$' : ''}${row}`
+ );
+ };
+ const prefix = range.sheet ? `'${range.sheet.replaceAll("'", "''")}'!` : '';
+ characters.splice(
+ start,
+ end - start,
+ `${prefix}${address(left)}:${address(right)}`
+ );
+ }
+ return characters.join('');
+}
+
+/** Keep cell identity, styles and all sheet references together during a structural edit. */
+export function changeWorkbookAxis(
+ sheets: SpreadsheetWorkbookSheet[],
+ change: AxisChange
+): SpreadsheetWorkbookSheet[] {
+ const target = sheets.findIndex((sheet) => sheet.id === change.sheetId);
+ const limit =
+ change.axis === 'row' ? SPREADSHEET_MAX_ROWS : SPREADSHEET_COLUMNS;
+ if (
+ target < 0 ||
+ !Number.isInteger(change.index) ||
+ !Number.isInteger(change.count) ||
+ change.index < 0 ||
+ change.count < 1 ||
+ change.index + change.count > limit
+ )
+ throw new Error('Invalid row or column selection.');
+ const move = (index: number): number | undefined => {
+ if (index < change.index) return index;
+ if (change.kind === 'insert') return index + change.count;
+ return index < change.index + change.count
+ ? undefined
+ : index - change.count;
+ };
+ const movedRecord = (record: Record<number, number> | undefined) =>
+ Object.fromEntries(
+ Object.entries(record ?? {}).flatMap(([key, value]) => {
+ const next = move(Number(key));
+ return next === undefined || next >= limit ? [] : [[next, value]];
+ })
+ );
+ const range = (value: string): string | undefined => {
+ const [start, end = start] = value.split(':').map(parseCellAddress);
+ if (!start || !end) throw new Error('Invalid sheet layout range.');
+ const first = start[change.axis];
+ const last = end[change.axis];
+ if (
+ change.kind === 'delete' &&
+ first >= change.index &&
+ last < change.index + change.count
+ )
+ return;
+ start[change.axis] = move(first) ?? change.index;
+ end[change.axis] = move(last) ?? change.index - 1;
+ if (end[change.axis] >= limit)
+ throw new Error(
+ 'This change would move a formatted range outside the supported sheet size.'
+ );
+ return `${formatCellAddress(start.row, start.column)}:${formatCellAddress(end.row, end.column)}`;
+ };
+ const model = new Model('Sheet structure', 'en', 'UTC', 'en');
+ try {
+ model.pauseEvaluation();
+ sheets.forEach((_, index) => {
+ if (index) model.newSheet();
+ model.renameSheet(index, `__macro_structure_${index}`);
+ });
+ sheets.forEach((sheet, index) => model.renameSheet(index, sheet.name));
+ for (const [index, sheet] of sheets.entries()) {
+ for (const [nameIndex, name] of (
+ sheet.metadata?.definedNames ?? []
+ ).entries()) {
+ model.setUserInput(
+ index,
+ SPREADSHEET_MAX_ROWS + 1 + nameIndex,
+ SPREADSHEET_COLUMNS + 2,
+ prepareDeletion(
+ `=${name.formula.replace(/^=/, '')}`,
+ sheet.name,
+ sheets[target].name,
+ change
+ )
+ );
+ if (
+ /^[=]?(?:[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?|TRUE|FALSE|"(?:[^"\r\n]|"")*")$/i.test(
+ name.formula
+ )
+ )
+ continue;
+ try {
+ model.newDefinedName(
+ name.name,
+ name.local ? index : undefined,
+ name.formula.replace(/^=/, '')
+ );
+ } catch {
+ throw new Error(
+ `Cannot move rows or columns while the named expression “${name.name}” uses an unsupported reference. No cells were changed.`
+ );
+ }
+ }
+ for (const [address, cell] of Object.entries(sheet.cells)) {
+ const position = parseCellAddress(address)!;
+ if (cell.value.startsWith('=') && cell.format !== 'text')
+ model.setUserInput(
+ index,
+ position.row + 1,
+ position.column + 1,
+ prepareDeletion(cell.value, sheet.name, sheets[target].name, change)
+ );
+ }
+ }
+ if (change.axis === 'row') {
+ if (change.kind === 'insert')
+ model.insertRows(target, change.index + 1, change.count);
+ else model.deleteRows(target, change.index + 1, change.count);
+ } else if (change.kind === 'insert')
+ model.insertColumns(target, change.index + 1, change.count);
+ else model.deleteColumns(target, change.index + 1, change.count);
+ return sheets.map((sheet, index) => {
+ const cells: SpreadsheetCells = {};
+ for (const [address, cell] of Object.entries(sheet.cells)) {
+ const position = parseCellAddress(address)!;
+ if (index === target) {
+ const next = move(position[change.axis]);
+ if (next === undefined) continue;
+ if (next >= limit)
+ throw new Error(
+ `This change would push cells past ${limit} ${change.axis}s. Clear the trailing cells first.`
+ );
+ position[change.axis] = next;
+ }
+ cells[formatCellAddress(position.row, position.column)] = {
+ ...cell,
+ value:
+ cell.value.startsWith('=') && cell.format !== 'text'
+ ? model.getCellContent(
+ index,
+ position.row + 1,
+ position.column + 1
+ )
+ : cell.value,
+ };
+ }
+ const metadata = { ...sheet.metadata };
+ if (metadata.definedNames)
+ metadata.definedNames = metadata.definedNames.map(
+ (entry, nameIndex) => {
+ // IronCalc moves formula references but not its named-range definitions.
+ // Read each definition from an out-of-grid formula after the same move.
+ let row = SPREADSHEET_MAX_ROWS + nameIndex;
+ let column = SPREADSHEET_COLUMNS + 1;
+ if (index === target) {
+ if (change.axis === 'row') row = move(row)!;
+ else column = move(column)!;
+ }
+ return {
+ ...entry,
+ formula: model
+ .getCellContent(index, row + 1, column + 1)
+ .replace(/^=/, ''),
+ };
+ }
+ );
+ let layout = sheet.layout;
+ if (index === target) {
+ if (metadata.merges)
+ metadata.merges = metadata.merges.flatMap((value) => {
+ const next = range(value);
+ return next ? [next] : [];
+ });
+ if (metadata.autoFilter)
+ metadata.autoFilter = range(metadata.autoFilter);
+ const hidden = change.axis === 'row' ? 'hiddenRows' : 'hiddenColumns';
+ if (metadata[hidden])
+ metadata[hidden] = metadata[hidden].flatMap((value) => {
+ const next = move(value);
+ return next === undefined || next >= limit ? [] : [next];
+ });
+ if (metadata.freeze) {
+ const key = change.axis === 'row' ? 'rows' : 'columns';
+ const edge = metadata.freeze[key];
+ metadata.freeze = {
+ ...metadata.freeze,
+ [key]:
+ edge === 0 || change.index >= edge
+ ? edge
+ : Math.min(limit, move(edge) ?? change.index),
+ };
+ }
+ if (change.axis === 'row') {
+ if (metadata.rowHeights)
+ metadata.rowHeights = movedRecord(metadata.rowHeights);
+ layout = {
+ ...layout,
+ rowCount: Math.min(
+ SPREADSHEET_MAX_ROWS,
+ Math.max(
+ layout.rowCount + (change.kind === 'insert' ? change.count : 0),
+ ...Object.keys(cells).map(
+ (key) => parseCellAddress(key)!.row + 1
+ )
+ )
+ ),
+ };
+ } else
+ layout = {
+ ...layout,
+ columnWidths: movedRecord(layout.columnWidths),
+ };
+ }
+ return { ...sheet, cells, metadata, layout };
+ });
+ } finally {
+ model.free();
+ }
+}
diff --git a/services/ai-editing-worker/src/spreadsheet/runtime.test.ts b/services/ai-editing-worker/src/spreadsheet/runtime.test.ts
index 32dc6de585..c835e9f917 100644
--- a/services/ai-editing-worker/src/spreadsheet/runtime.test.ts
+++ b/services/ai-editing-worker/src/spreadsheet/runtime.test.ts
@@ -54,6 +54,36 @@ function store() {
const signal = () => new AbortController().signal;
describe('deterministic spreadsheet worker runtime', () => {
+ it('AI can write and reread native mention cells without an open editor', async () => {
+ const { doc, storage, revision } = store();
+ const value =
+ '<m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]","displayName":"Taylor"}</m-user-mention>';
+ await runSpreadsheetRequest(
+ {
+ action: 'edit',
+ expectedRevision: revision(),
+ operations: [
+ {
+ type: 'set_cells',
+ sheetId: 'sheet1',
+ cells: [
+ { address: 'B1', value },
+ { address: 'C1', value: '=B1&" owns this"' },
+ ],
+ },
+ ],
+ },
+ storage,
+ calculator,
+ signal()
+ );
+ expect(readSpreadsheetCells(doc).B1.value).toBe(value);
+ const result = calculator.calculate(readSpreadsheetCells(doc));
+ expect(result.B1.display).toBe('@Taylor');
+ expect(result.C1.display).toBe('@Taylor owns this');
+ expect(storage.commit).toHaveBeenCalledOnce();
+ });
+
it('reads and calculates without calling persistence; edits return the committed revision', async () => {
const { doc, storage, revision } = store();
const read = await runSpreadsheetRequest(
@@ -288,3 +318,30 @@ describe('deterministic spreadsheet worker runtime', () => {
).toBe(false);
});
});
+
+it('accepts imported financial styles in AI edits while rejecting unknown border types', () => {
+ const body = {
+ documentId: crypto.randomUUID(),
+ documentToken: 'token',
+ request: {
+ action: 'edit',
+ expectedRevision: 'rev',
+ operations: [
+ {
+ type: 'format_cells',
+ sheetId: 'sheet1',
+ range: 'A1',
+ style: {
+ numberFormat: '#,##0.00;[Red](#,##0.00)',
+ fontName: 'Calibri',
+ borderBottomStyle: 'double',
+ borderBottomColor: '#123456',
+ },
+ },
+ ],
+ },
+ };
+ expect(spreadsheetBodySchema.safeParse(body).success).toBe(true);
+ body.request.operations[0].style.borderBottomStyle = 'bogus';
+ expect(spreadsheetBodySchema.safeParse(body).success).toBe(false);
+});
diff --git a/services/ai-editing-worker/src/spreadsheet/schema.ts b/services/ai-editing-worker/src/spreadsheet/schema.ts
index adc2de7f75..8293caca22 100644
--- a/services/ai-editing-worker/src/spreadsheet/schema.ts
+++ b/services/ai-editing-worker/src/spreadsheet/schema.ts
@@ -6,8 +6,46 @@ const cell = z
.object({ address: z.string().min(2).max(8), value: z.string().max(10_000) })
.strict();
const color = z.string().regex(/^(#[0-9a-fA-F]{6})?$/);
+const borderStyle = z.enum([
+ '',
+ 'thin',
+ 'dotted',
+ 'dashDot',
+ 'hair',
+ 'dashDotDot',
+ 'slantDashDot',
+ 'mediumDashed',
+ 'mediumDashDotDot',
+ 'mediumDashDot',
+ 'medium',
+ 'double',
+ 'thick',
+ 'dashed',
+]);
const style = z
.object({
+ numberFormat: z
+ .string()
+ .max(512)
+ .refine((value) =>
+ Array.from(value).every((character) => character.charCodeAt(0) >= 32)
+ )
+ .optional(),
+ fontName: z
+ .string()
+ .max(128)
+ .refine((value) =>
+ Array.from(value).every((character) => character.charCodeAt(0) >= 32)
+ )
+ .optional(),
+ borderTopStyle: borderStyle.optional(),
+ borderTopColor: color.optional(),
+ borderRightStyle: borderStyle.optional(),
+ borderRightColor: color.optional(),
+ borderBottomStyle: borderStyle.optional(),
+ borderBottomColor: color.optional(),
+ borderLeftStyle: borderStyle.optional(),
+ borderLeftColor: color.optional(),
bold: z.boolean().optional(),
italic: z.boolean().optional(),
underline: z.boolean().optional(),
diff --git a/services/sync-service/src/spreadsheet.rs b/services/sync-service/src/spreadsheet.rs
index dfd861b67b..35c94c5b19 100644
--- a/services/sync-service/src/spreadsheet.rs
+++ b/services/sync-service/src/spreadsheet.rs
@@ -265,9 +265,94 @@ fn choice(value: &Value, choices: &[&str]) -> bool {
value.as_str().is_some_and(|value| choices.contains(&value))
}
+fn metadata_range(value: &Value) -> bool {
+ let Some(range) = value.as_str() else {
+ return false;
+ };
+ let parts: Vec<_> = range.split(':').collect();
+ if parts.is_empty()
+ || parts.len() > 2
+ || !parts.iter().all(|part| {
+ address(part)
+ && !part.contains('!')
+ && part[1..].bytes().all(|byte| byte.is_ascii_digit())
+ })
+ {
+ return false;
+ }
+ let first = parts[0];
+ let last = parts[parts.len() - 1];
+ first.as_bytes()[0] <= last.as_bytes()[0]
+ && first[1..].parse::<u16>().unwrap_or(0) <= last[1..].parse::<u16>().unwrap_or(0)
+}
+
+fn workbook_metadata(value: &Value) -> bool {
+ let Some(encoded) = value
+ .as_str()
+ .filter(|text| text.encode_utf16().count() <= 100_000)
+ else {
+ return false;
+ };
+ let Ok(Value::Object(fields)) = serde_json::from_str::<Value>(encoded) else {
+ return false;
+ };
+ fields.iter().all(|(key, value)| match key.as_str() {
+ "merges" => value
+ .as_array()
+ .is_some_and(|items| items.len() <= 1000 && items.iter().all(metadata_range)),
+ "rowHeights" => value.as_object().is_some_and(|items| {
+ items.iter().all(|(key, value)| {
+ key.bytes().all(|byte| byte.is_ascii_digit())
+ && key.parse::<u16>().is_ok_and(|row| row < 1000)
+ && value
+ .as_f64()
+ .is_some_and(|height| (0.0..=409.5).contains(&height))
+ })
+ }),
+ "hiddenRows" | "hiddenColumns" => value.as_array().is_some_and(|items| {
+ let limit = if key == "hiddenRows" { 1000 } else { 26 };
+ items.len() <= limit && items.iter().all(|item| integer(item, 0, limit as i64 - 1))
+ }),
+ "hidden" => value.is_boolean(),
+ "freeze" => value.as_object().is_some_and(|fields| {
+ fields.len() == 2
+ && fields
+ .get("rows")
+ .is_some_and(|value| integer(value, 0, 1000))
+ && fields
+ .get("columns")
+ .is_some_and(|value| integer(value, 0, 26))
+ }),
+ "autoFilter" => metadata_range(value),
+ "definedNames" => value.as_array().is_some_and(|items| {
+ items.len() <= 256
+ && items.iter().all(|item| {
+ item.as_object().is_some_and(|fields| {
+ fields
+ .keys()
+ .all(|key| ["name", "formula", "local"].contains(&key.as_str()))
+ && fields
+ .get("name")
+ .and_then(Value::as_str)
+ .is_some_and(|name| {
+ !name.is_empty() && name.encode_utf16().count() <= 255
+ })
+ && fields
+ .get("formula")
+ .and_then(Value::as_str)
+ .is_some_and(|formula| formula.encode_utf16().count() <= 10_000)
+ && fields.get("local").is_none_or(Value::is_boolean)
+ })
+ })
+ }),
+ _ => false,
+ })
+}
+
fn valid_entry(root: &str, key: &str, value: &Value) -> bool {
match root {
"spreadsheetMeta" => key == "formatVersion" && value.as_u64() == Some(1),
+ "spreadsheetSheetMetadata" => sheet_id(key) && workbook_metadata(value),
"spreadsheetSheetNames" => sheet_id(key) && value.as_str().is_some_and(sheet_name),
"spreadsheetSheetOrder" => sheet_id(key) && value.as_f64().is_some_and(f64::is_finite),
"spreadsheetDeletedSheets" => sheet_id(key) && value.is_boolean(),
@@ -319,9 +404,39 @@ fn valid_entry(root: &str, key: &str, value: &Value) -> bool {
| "spreadsheetBorderRight"
| "spreadsheetBorderBottom"
| "spreadsheetBorderLeft" => value.is_boolean(),
+ "spreadsheetFontNames" => value.as_str().is_some_and(|value| {
+ value.encode_utf16().count() <= 128 && !value.chars().any(|ch| ch <= '\u{001f}')
+ }),
+ "spreadsheetBorderTopStyles"
+ | "spreadsheetBorderRightStyles"
+ | "spreadsheetBorderBottomStyles"
+ | "spreadsheetBorderLeftStyles" => choice(
+ value,
+ &[
+ "",
+ "thin",
+ "medium",
+ "thick",
+ "double",
+ "dotted",
+ "dashed",
+ "dashDot",
+ "dashDotDot",
+ "slantDashDot",
+ "hair",
+ "mediumDashed",
+ "mediumDashDot",
+ "mediumDashDotDot",
+ ],
+ ),
"spreadsheetFontFamily" => choice(value, &["sans", "serif", "mono"]),
"spreadsheetFontSize" => integer(value, 8, 36),
- "spreadsheetTextColor" | "spreadsheetFillColor" => value.as_str().is_some_and(|value| {
+ "spreadsheetBorderTopColors"
+ | "spreadsheetBorderRightColors"
+ | "spreadsheetBorderBottomColors"
+ | "spreadsheetBorderLeftColors"
+ | "spreadsheetTextColor"
+ | "spreadsheetFillColor" => value.as_str().is_some_and(|value| {
value.is_empty()
|| (value.len() == 7
&& value.starts_with('#')
@@ -330,6 +445,9 @@ fn valid_entry(root: &str, key: &str, value: &Value) -> bool {
"spreadsheetHorizontalAlign" => choice(value, &["auto", "left", "center", "right"]),
"spreadsheetVerticalAlign" => choice(value, &["top", "middle", "bottom"]),
"spreadsheetDecimals" => integer(value, -1, 10),
+ "spreadsheetNumberFormats" => value.as_str().is_some_and(|value| {
+ value.encode_utf16().count() <= 512 && !value.chars().any(|ch| ch <= '\u{001f}')
+ }),
"spreadsheetFormats" => choice(
value,
&[
@@ -352,6 +470,7 @@ fn known_root(root: &str) -> bool {
root,
"spreadsheetMeta"
| "spreadsheetSheetNames"
+ | "spreadsheetSheetMetadata"
| "spreadsheetSheetOrder"
| "spreadsheetDeletedSheets"
| "spreadsheetSheetRevivals"
@@ -368,6 +487,15 @@ fn known_root(root: &str) -> bool {
| "spreadsheetBorderRight"
| "spreadsheetBorderBottom"
| "spreadsheetBorderLeft"
+ | "spreadsheetFontNames"
+ | "spreadsheetBorderTopStyles"
+ | "spreadsheetBorderTopColors"
+ | "spreadsheetBorderRightStyles"
+ | "spreadsheetBorderRightColors"
+ | "spreadsheetBorderBottomStyles"
+ | "spreadsheetBorderBottomColors"
+ | "spreadsheetBorderLeftStyles"
+ | "spreadsheetBorderLeftColors"
| "spreadsheetFontFamily"
| "spreadsheetFontSize"
| "spreadsheetTextColor"
@@ -376,6 +504,7 @@ fn known_root(root: &str) -> bool {
| "spreadsheetVerticalAlign"
| "spreadsheetDecimals"
| "spreadsheetFormats"
+ | "spreadsheetNumberFormats"
)
}
diff --git a/services/sync-service/src/spreadsheet/test.rs b/services/sync-service/src/spreadsheet/test.rs
index 5ede756381..9c42ea08f2 100644
--- a/services/sync-service/src/spreadsheet/test.rs
+++ b/services/sync-service/src/spreadsheet/test.rs
@@ -256,3 +256,42 @@ fn notification_failure_preserves_durable_update_and_allows_idempotent_retry() {
assert!(!retried.applied);
assert_eq!(*port.calls.borrow(), ["persist", "broadcast", "keep_alive"]);
}
+
+#[test]
+fn imported_financial_styles_and_metadata_are_validated_before_commit() {
+ let doc = document();
+ let fork = doc.fork();
+ for (root, value) in [
+ ("spreadsheetNumberFormats", "#,##0.00;[Red](#,##0.00);\"—\""),
+ ("spreadsheetFontNames", "Calibri"),
+ ("spreadsheetBorderBottomStyles", "double"),
+ ("spreadsheetBorderBottomColors", "#123456"),
+ ] {
+ fork.get_map(root).insert("A1", value).unwrap();
+ }
+ fork.get_map("spreadsheetSheetMetadata").insert("sheet1", r#"{"merges":["A1:C1"],"rowHeights":{"0":32},"hiddenRows":[5],"hiddenColumns":[5],"freeze":{"rows":3,"columns":1},"definedNames":[{"name":"Rate","formula":"0.1","local":true}]}"#).unwrap();
+ let update = fork
+ .export(ExportMode::Updates {
+ from: Cow::Owned(doc.oplog_vv()),
+ })
+ .unwrap();
+ assert!(prepare_update(&access(), &doc, &doc.oplog_vv().encode(), &update).is_ok());
+ for invalid in [
+ r#"{"merges":["A1:AA1001"]}"#,
+ r#"{"rowHeights":{"1000":32}}"#,
+ r#"{"hiddenColumns":[26]}"#,
+ r#"{"freeze":{"rows":1001,"columns":1}}"#,
+ r#"{"definedNames":[{"name":"Rate","formula":false}]}"#,
+ r#"{"unexpected":true}"#,
+ ] {
+ assert!(
+ prepare_update(
+ &access(),
+ &doc,
+ &doc.oplog_vv().encode(),
+ &delta(&doc, "spreadsheetSheetMetadata", "sheet1", invalid)
+ )
+ .is_err()
+ );
+ }
+}